diff options
Diffstat (limited to 'firmware')
| -rw-r--r-- | firmware/common/dir.c | 3 | ||||
| -rw-r--r-- | firmware/common/file.c | 178 | ||||
| -rw-r--r-- | firmware/common/file.h | 16 | ||||
| -rw-r--r-- | firmware/debug.c | 11 | ||||
| -rw-r--r-- | firmware/debug.h | 6 | ||||
| -rw-r--r-- | firmware/drivers/fat.c | 585 | ||||
| -rw-r--r-- | firmware/drivers/fat.h | 19 | ||||
| -rw-r--r-- | firmware/test/fat/README | 25 | ||||
| -rw-r--r-- | firmware/test/fat/ata-sim.c | 7 | ||||
| -rw-r--r-- | firmware/test/fat/main.c | 52 |
10 files changed, 610 insertions, 292 deletions
diff --git a/firmware/common/dir.c b/firmware/common/dir.c index 70aa494..6bf9a53 100644 --- a/firmware/common/dir.c +++ b/firmware/common/dir.c @@ -105,8 +105,7 @@ struct dirent* readdir(DIR* dir) return NULL; if ( !entry.name[0] ) - return NULL; - + return NULL; strncpy(theent->d_name, entry.name, sizeof( theent->d_name ) ); theent->attribute = entry.attr; diff --git a/firmware/common/file.c b/firmware/common/file.c index 2c00c3e..27258e4 100644 --- a/firmware/common/file.c +++ b/firmware/common/file.c @@ -42,23 +42,25 @@ struct filedesc { int size; struct fat_file fatfile; bool busy; + bool write; }; static struct filedesc openfiles[MAX_OPEN_FILES]; -int open(char* pathname, int flags) +int creat(const char *pathname, int mode) +{ + (void)mode; + return open(pathname, O_WRONLY); +} + +int open(const char* pathname, int flags) { DIR* dir; struct dirent* entry; int fd; char* name; - /* For now, we don't support writing */ - if(flags & (O_WRONLY | O_RDWR)) - { - errno = EROFS; - return -1; - } + LDEBUGF("open(\"%s\",%d)\n",pathname,flags); if ( pathname[0] != '/' ) { DEBUGF("'%s' is not an absolute path.\n",pathname); @@ -75,44 +77,74 @@ int open(char* pathname, int flags) if ( fd == MAX_OPEN_FILES ) { DEBUGF("Too many files open\n"); errno = EMFILE; - return -1; + return -2; } + switch ( flags ) { + case O_RDONLY: + openfiles[fd].write = false; + break; + + case O_WRONLY: + openfiles[fd].write = true; + break; + + default: + DEBUGF("Only O_RDONLY and O_WRONLY is supported\n"); + errno = EROFS; + return -3; + } openfiles[fd].busy = true; /* locate filename */ name=strrchr(pathname+1,'/'); if ( name ) { *name = 0; - dir = opendir(pathname); + dir = opendir((char*)pathname); *name = '/'; name++; } else { dir = opendir("/"); - name = pathname+1; + name = (char*)pathname+1; } if (!dir) { DEBUGF("Failed opening dir\n"); errno = EIO; openfiles[fd].busy = false; - return -1; + return -4; } /* scan dir for name */ while ((entry = readdir(dir))) { if ( !strcasecmp(name, entry->d_name) ) { - fat_open(entry->startcluster, &(openfiles[fd].fatfile)); + fat_open(entry->startcluster, + &(openfiles[fd].fatfile), + &(dir->fatdir)); openfiles[fd].size = entry->size; break; } } closedir(dir); if ( !entry ) { - DEBUGF("Couldn't find %s in %s\n",name,pathname); - errno = ENOENT; - openfiles[fd].busy = false; - return -1; + LDEBUGF("Didn't find file %s\n",name); + if ( openfiles[fd].write ) { + if (fat_create_file(name, + &(openfiles[fd].fatfile), + &(dir->fatdir)) < 0) { + DEBUGF("Couldn't create %s in %s\n",name,pathname); + errno = EIO; + openfiles[fd].busy = false; + return -5; + } + openfiles[fd].size = 0; + } + else { + DEBUGF("Couldn't find %s in %s\n",name,pathname); + errno = ENOENT; + openfiles[fd].busy = false; + return -6; + } } openfiles[fd].cacheoffset = -1; @@ -122,19 +154,37 @@ int open(char* pathname, int flags) int close(int fd) { + int rc = 0; + + LDEBUGF("close(%d)\n",fd); + if (fd < 0 || fd > MAX_OPEN_FILES-1) { errno = EINVAL; return -1; } if (!openfiles[fd].busy) { errno = EBADF; - return -1; + return -2; + } + if (openfiles[fd].write) { + /* flush sector cache */ + if ( openfiles[fd].cacheoffset != -1 ) { + if ( fat_readwrite(&(openfiles[fd].fatfile), 1, + &(openfiles[fd].cache),true) < 0 ) { + DEBUGF("Failed flushing cache\n"); + errno = EIO; + rc = -1; + } + } + + /* tie up all loose ends */ + fat_closewrite(&(openfiles[fd].fatfile), openfiles[fd].size); } openfiles[fd].busy = false; - return 0; + return rc; } -int read(int fd, void* buf, int count) +static int readwrite(int fd, void* buf, int count, bool write) { int sectors; int nread=0; @@ -144,9 +194,16 @@ int read(int fd, void* buf, int count) return -1; } - /* attempt to read past EOF? */ - if ( count > openfiles[fd].size - openfiles[fd].fileoffset ) - count = openfiles[fd].size - openfiles[fd].fileoffset; + LDEBUGF( "readwrite(%d,%x,%d,%s)\n", + fd,buf,count,write?"write":"read"); + + /* attempt to access past EOF? */ + if (count > openfiles[fd].size - openfiles[fd].fileoffset) { + if ( write ) + openfiles[fd].size = openfiles[fd].fileoffset + count; + else + count = openfiles[fd].size - openfiles[fd].fileoffset; + } /* any head bytes? */ if ( openfiles[fd].cacheoffset != -1 ) { @@ -163,23 +220,38 @@ int read(int fd, void* buf, int count) openfiles[fd].cacheoffset = -1; } - /* eof? */ - if ( openfiles[fd].fileoffset + headbytes > openfiles[fd].size ) - headbytes = openfiles[fd].size - openfiles[fd].fileoffset; + if (write) { + memcpy( openfiles[fd].cache + offs, buf, headbytes ); + if (offs+headbytes == SECTOR_SIZE) { + int rc = fat_readwrite(&(openfiles[fd].fatfile), 1, + openfiles[fd].cache, true ); + if ( rc < 0 ) { + DEBUGF("Failed read/writing %d sectors\n",sectors); + errno = EIO; + return -2; + } + openfiles[fd].cacheoffset = -1; + } + } + else { + memcpy( buf, openfiles[fd].cache + offs, headbytes ); + } - memcpy( buf, openfiles[fd].cache + offs, headbytes ); nread = headbytes; count -= headbytes; + + LDEBUGF("readwrite incache: offs=%d\n",openfiles[fd].cacheoffset); } /* read whole sectors right into the supplied buffer */ sectors = count / SECTOR_SIZE; if ( sectors ) { - int rc = fat_read(&(openfiles[fd].fatfile), sectors, buf+nread ); + int rc = fat_readwrite(&(openfiles[fd].fatfile), sectors, + buf+nread, write ); if ( rc < 0 ) { - DEBUGF("Failed reading %d sectors\n",sectors); + DEBUGF("Failed read/writing %d sectors\n",sectors); errno = EIO; - return -1; + return -2; } else { if ( rc > 0 ) { @@ -197,18 +269,19 @@ int read(int fd, void* buf, int count) /* any tail bytes? */ if ( count ) { - if ( fat_read(&(openfiles[fd].fatfile), 1, - &(openfiles[fd].cache)) < 0 ) { - DEBUGF("Failed caching sector\n"); - errno = EIO; - return -1; + if (write) { + memcpy( openfiles[fd].cache, buf + nread, count ); } - - /* eof? */ - if ( openfiles[fd].fileoffset + count > openfiles[fd].size ) - count = openfiles[fd].size - openfiles[fd].fileoffset; - - memcpy( buf + nread, openfiles[fd].cache, count ); + else { + if ( fat_readwrite(&(openfiles[fd].fatfile), 1, + &(openfiles[fd].cache),false) < 0 ) { + DEBUGF("Failed caching sector\n"); + errno = EIO; + return -1; + } + memcpy( buf + nread, openfiles[fd].cache, count ); + } + nread += count; openfiles[fd].cacheoffset = count; } @@ -217,6 +290,17 @@ int read(int fd, void* buf, int count) return nread; } +int write(int fd, void* buf, int count) +{ + return readwrite(fd, buf, count, true); +} + +int read(int fd, void* buf, int count) +{ + return readwrite(fd, buf, count, false); +} + + int lseek(int fd, int offset, int whence) { int pos; @@ -225,6 +309,8 @@ int lseek(int fd, int offset, int whence) int sectoroffset; int rc; + LDEBUGF("lseek(%d,%d,%d)\n",fd,offset,whence); + if ( !openfiles[fd].busy ) { errno = EBADF; return -1; @@ -245,11 +331,11 @@ int lseek(int fd, int offset, int whence) default: errno = EINVAL; - return -1; + return -2; } if ((pos < 0) || (pos > openfiles[fd].size)) { errno = EINVAL; - return -1; + return -3; } /* new sector? */ @@ -263,14 +349,14 @@ int lseek(int fd, int offset, int whence) rc = fat_seek(&(openfiles[fd].fatfile), newsector); if ( rc < 0 ) { errno = EIO; - return -1; + return -4; } } - rc = fat_read(&(openfiles[fd].fatfile), 1, - &(openfiles[fd].cache)); + rc = fat_readwrite(&(openfiles[fd].fatfile), 1, + &(openfiles[fd].cache),false); if ( rc < 0 ) { errno = EIO; - return -1; + return -5; } openfiles[fd].cacheoffset = sectoroffset; } diff --git a/firmware/common/file.h b/firmware/common/file.h index c95811f..7a7c63d 100644 --- a/firmware/common/file.h +++ b/firmware/common/file.h @@ -40,24 +40,22 @@ #endif #if defined(__MINGW32__) && defined(SIMULATOR) -int open (const char*, int, ...); +extern int open(const char*, int, ...); extern int close(int fd); -int read (int, void*, unsigned int); -long lseek (int, long, int); +extern int read(int, void*, unsigned int); +extern long lseek(int, long, int); #else #ifndef SIMULATOR -extern int open(char* pathname, int flags); +extern int open(const char* pathname, int flags); extern int close(int fd); extern int read(int fd, void* buf, int count); extern int lseek(int fd, int offset, int whence); - -#ifdef DISK_WRITE +extern int creat(const char *pathname, int mode); extern int write(int fd, void* buf, int count); -extern int remove(char* pathname); -extern int rename(char* oldname, char* newname); -#endif +extern int remove(const char* pathname); +extern int rename(const char* oldname, const char* newname); #else #ifdef WIN32 diff --git a/firmware/debug.c b/firmware/debug.c index 83eb149..2ebcd86 100644 --- a/firmware/debug.c +++ b/firmware/debug.c @@ -195,7 +195,9 @@ static void debug(char *msg) } #endif /* end of DEBUG section */ +#ifdef __GNUC__ void debugf(char *fmt, ...) +#endif { #ifdef DEBUG va_list ap; @@ -223,4 +225,13 @@ void debugf(char *fmt, ...) vfprintf( stderr, fmt, ap ); va_end( ap ); } + +void ldebugf(char* file, int line, char *fmt, ...) +{ + va_list ap; + va_start( ap, fmt ); + fprintf( stderr, "%s:%d ", file, line ); + vfprintf( stderr, fmt, ap ); + va_end( ap ); +} #endif diff --git a/firmware/debug.h b/firmware/debug.h index e9eec27..878da29 100644 --- a/firmware/debug.h +++ b/firmware/debug.h @@ -21,20 +21,24 @@ extern void debug_init(void); extern void debugf(char* fmt,...); +extern void ldebugf(char* file, int line, char *fmt, ...); #ifdef __GNUC__ /* */ #if defined(DEBUG) || defined(SIMULATOR) -//#define DEBUGF(...) debugf(__VA_ARGS__) #define DEBUGF debugf +#define LDEBUGF(...) ldebugf(__FILE__, __LINE__, __VA_ARGS__) #else #define DEBUGF(...) +#define LDEBUGF(...) #endif + #else #define DEBUGF debugf +#define LDEBUGF debugf #endif /* GCC */ diff --git a/firmware/drivers/fat.c b/firmware/drivers/fat.c index 7bed896..322ae76 100644 --- a/firmware/drivers/fat.c +++ b/firmware/drivers/fat.c @@ -22,14 +22,11 @@ #include <math.h> #include <stdlib.h> #include <ctype.h> -#ifdef DISK_WRITE -#include <time.h> -#include <sys/timeb.h> -#endif #include <stdbool.h> #include "fat.h" #include "ata.h" #include "debug.h" +#include "panic.h" #include "system.h" #define BYTES2INT16(array,pos) \ @@ -38,11 +35,6 @@ (array[pos] | (array[pos+1] << 8 ) | \ (array[pos+2] << 16 ) | (array[pos+3] << 24 )) -#define NUM_ROOT_DIR_ENTRIES 512 -#define NUM_FATS 2 -#define NUM_RESERVED_SECTORS 1 -#define NUM_BLOCKS 10000 - #define FATTYPE_FAT12 0 #define FATTYPE_FAT16 1 #define FATTYPE_FAT32 2 @@ -107,6 +99,12 @@ #define FATDIR_FSTCLUSLO 26 #define FATDIR_FILESIZE 28 +#define CLUSTERS_PER_FAT_SECTOR (SECTOR_SIZE / 4) +#define DIR_ENTRIES_PER_SECTOR (SECTOR_SIZE / 32) +#define DIR_ENTRY_SIZE 32 +#define FAT_BAD_MARK 0x0ffffff7 +#define FAT_EOF_MARK 0x0ffffff8 + struct fsinfo { int freecount; /* last known free cluster count */ int nextfree; /* first cluster to start looking for free clusters, @@ -155,6 +153,7 @@ struct bpb int rootdirsector; int firstdatasector; int startsector; + struct fsinfo fsinfo; }; static struct bpb fat_bpb; @@ -167,6 +166,7 @@ static unsigned int getcurrdostime(unsigned short *dosdate, unsigned short *dostime, unsigned char *dostenth); static int create_dos_name(unsigned char *name, unsigned char *newname); +static int find_free_cluster(int start); #endif #define FAT_CACHE_SIZE 0x20 @@ -256,7 +256,6 @@ int fat_mount(int startsector) fat_bpb.bpb_secperclus = buf[BPB_SECPERCLUS]; fat_bpb.bpb_rsvdseccnt = BYTES2INT16(buf,BPB_RSVDSECCNT); fat_bpb.bpb_numfats = buf[BPB_NUMFATS]; - fat_bpb.bpb_rootentcnt = BYTES2INT16(buf,BPB_ROOTENTCNT); fat_bpb.bpb_totsec16 = BYTES2INT16(buf,BPB_TOTSEC16); fat_bpb.bpb_media = buf[BPB_MEDIA]; fat_bpb.bpb_fatsz16 = BYTES2INT16(buf,BPB_FATSZ16); @@ -295,7 +294,7 @@ int fat_mount(int startsector) #endif { DEBUGF("This is not FAT32. Go away!\n"); - return -1; + return -2; } fat_bpb.bpb_extflags = BYTES2INT16(buf,BPB_EXTFLAGS); @@ -316,11 +315,23 @@ int fat_mount(int startsector) if (bpb_is_sane() < 0) { DEBUGF( "fat_mount() - BPB is not sane\n"); - return -1; + return -3; } fat_bpb.rootdirsector = cluster2sec(fat_bpb.bpb_rootclus); + /* Read the fsinfo sector */ + err = ata_read_sectors(startsector + fat_bpb.bpb_fsinfo, 1, buf); + if (err) + { + DEBUGF( "fat_mount() - Couldn't read FSInfo (error code %d)\n", err); + return -1; + } + fat_bpb.fsinfo.freecount = BYTES2INT32(buf, FSINFO_FREECOUNT); + fat_bpb.fsinfo.nextfree = BYTES2INT32(buf, FSINFO_NEXTFREE); + LDEBUGF("Freecount: %x\n",fat_bpb.fsinfo.freecount); + LDEBUGF("Nextfree: %x\n",fat_bpb.fsinfo.nextfree); + return 0; } @@ -339,9 +350,9 @@ static int bpb_is_sane(void) fat_bpb.bpb_bytspersec, fat_bpb.bpb_secperclus, fat_bpb.bpb_bytspersec * fat_bpb.bpb_secperclus); } - if(fat_bpb.bpb_rsvdseccnt != 1) + if (fat_bpb.bpb_rsvdseccnt != 32) { - DEBUGF( "bpb_is_sane() - Warning: Reserved sectors is not 1 (%d)\n", + DEBUGF( "bpb_is_sane() - Warning: Reserved sectors is not 32 (%d)\n", fat_bpb.bpb_rsvdseccnt); } if(fat_bpb.bpb_numfats != 2) @@ -349,11 +360,6 @@ static int bpb_is_sane(void) DEBUGF( "bpb_is_sane() - Warning: NumFATS is not 2 (%d)\n", fat_bpb.bpb_numfats); } - if(fat_bpb.bpb_rootentcnt != 512) - { - DEBUGF( "bpb_is_sane() - Warning: RootEntCnt is not 512 (%d)\n", - fat_bpb.bpb_rootentcnt); - } if(fat_bpb.bpb_media != 0xf0 && fat_bpb.bpb_media < 0xf8) { DEBUGF( "bpb_is_sane() - Warning: Non-standard " @@ -364,33 +370,42 @@ static int bpb_is_sane(void) { DEBUGF( "bpb_is_sane() - Error: Last word is not " "0xaa55 (0x%04x)\n", fat_bpb.last_word); - return -1; + return -4; + } + + if (fat_bpb.fsinfo.freecount > + (fat_bpb.totalsectors - fat_bpb.firstdatasector)/ + fat_bpb.bpb_secperclus) + { + DEBUGF( "bpb_is_sane() - Error: FSInfo.Freecount > disk size " + "(0x%04x)\n", fat_bpb.fsinfo.freecount); + return -5; } + return 0; } -static void *cache_fat_sector(int secnum) +static void *cache_fat_sector(int fatsector) { + int secnum = fatsector + fat_bpb.bpb_rsvdseccnt; int cache_index = secnum & FAT_CACHE_MASK; /* Delete the cache entry if it isn't the sector we want */ if(fat_cache[cache_index].inuse && fat_cache[cache_index].secnum != secnum) { -#ifdef WRITE /* Write back if it is dirty */ if(fat_cache[cache_index].dirty) { - if(ata_write_sectors(secnum + fat_bpb.startsector, 1, sec)) + if(ata_write_sectors(secnum + fat_bpb.startsector, 1, + fat_cache_sectors[cache_index])) { - panic("cache_fat_sector() - Could" - " not write sector %d\n", - secnum); + panicf("cache_fat_sector() - Could not write sector %d\n", + secnum); } } fat_cache[cache_index].secnum = 8; /* Normally an unused sector */ fat_cache[cache_index].dirty = false; -#endif fat_cache[cache_index].inuse = false; } @@ -409,101 +424,107 @@ static void *cache_fat_sector(int secnum) return fat_cache_sectors[cache_index]; } -#ifdef DISK_WRITE -static int update_entry(int entry, unsigned int val) +static int find_free_cluster(int startcluster) { - unsigned long *sec; - int fatoffset; - int thisfatsecnum; - int thisfatentoffset; + int sector = startcluster / CLUSTERS_PER_FAT_SECTOR; + int offset = startcluster % CLUSTERS_PER_FAT_SECTOR; + int i; - fatoffset = entry * 4; - thisfatsecnum = fatoffset / fat_bpb.bpb_bytspersec + fat_bpb.bpb_rsvdseccnt; - thisfatentoffset = fatoffset % fat_bpb.bpb_bytspersec; + LDEBUGF("find_free_cluster(%x)\n",startcluster); - /* Load the sector if it is not cached */ - sec = cache_fat_sector(thisfatsecnum); - if(!sec) + for (i = sector; i<fat_bpb.fatsize; i++) { + int j; + unsigned int* fat = cache_fat_sector(i); + if ( !fat ) + break; + for (j = offset; j < CLUSTERS_PER_FAT_SECTOR; j++) + if (!(SWAB32(fat[j]) & 0x0fffffff)) { + int c = i * CLUSTERS_PER_FAT_SECTOR + j; + LDEBUGF("Found free cluster %x\n",c); + fat_bpb.fsinfo.nextfree = c; + return c; + } + } + return 0; /* 0 is an illegal cluster number */ +} + +static int update_fat_entry(int entry, unsigned int val) +{ + int sector = entry / CLUSTERS_PER_FAT_SECTOR; + int offset = entry % CLUSTERS_PER_FAT_SECTOR; + unsigned int* sec; + + LDEBUGF("update_fat_entry(%x,%x)\n",entry,val); + + sec = cache_fat_sector(sector); + if (!sec) { - DEBUGF( "update_entry() - Could not cache sector %d\n", - thisfatsecnum); + DEBUGF( "update_entry() - Could not cache sector %d\n", sector); return -1; } + fat_cache[sector & FAT_CACHE_MASK].dirty = true; - /* We can safely assume that the correct sector is in the cache, - so we mark it dirty without checking the sector number */ - fat_cache[thisfatsecnum & FAT_CACHE_MASK].dirty = 1; + if ( val ) { + if (!(sec[offset] & 0x0fffffff)) + fat_bpb.fsinfo.freecount--; + } + else + fat_bpb.fsinfo.freecount++; /* don't change top 4 bits */ - sec[thisfatentoffset/sizeof(int)] &= 0xf000000; - sec[thisfatentoffset/sizeof(int)] |= val & 0x0fffffff; + sec[offset] &= SWAB32(0xf000000); + sec[offset] |= SWAB32(val & 0x0fffffff); return 0; } -#endif -static int read_entry(int entry) +static int read_fat_entry(int entry) { - unsigned long *sec; - int fatoffset; - int thisfatsecnum; - int thisfatentoffset; - int val = -1; - - fatoffset = entry * 4; - thisfatsecnum = fatoffset / fat_bpb.bpb_bytspersec + fat_bpb.bpb_rsvdseccnt; - thisfatentoffset = fatoffset % fat_bpb.bpb_bytspersec; + int sector = entry / CLUSTERS_PER_FAT_SECTOR; + int offset = entry % CLUSTERS_PER_FAT_SECTOR; + unsigned int* sec; - /* Load the sector if it is not cached */ - sec = cache_fat_sector(thisfatsecnum); - if(!sec) + sec = cache_fat_sector(sector); + if (!sec) { - DEBUGF( "read_entry() - Could not cache sector %d\n", - thisfatsecnum); + DEBUGF( "read_fat_entry() - Could not cache sector %d\n", sector); return -1; } - val = sec[thisfatentoffset/sizeof(int)]; - - val = SWAB32(val); - - return val; + return SWAB32(sec[offset]); } static int get_next_cluster(unsigned int cluster) { int next_cluster; - next_cluster = read_entry(cluster); + next_cluster = read_fat_entry(cluster); /* is this last cluster in chain? */ - if ( next_cluster >= 0x0ffffff8 ) + if ( next_cluster >= FAT_EOF_MARK ) return 0; else return next_cluster; } -#ifdef DISK_WRITE -static int flush_fat(struct bpb *bpb) +static int flush_fat(void) { int i; int err; unsigned char *sec; int secnum; - int fatsz; - unsigned short d, t; - char m; + unsigned char fsinfo[SECTOR_SIZE]; + unsigned int* intptr; - fatsz = fat_bpb.fatsize; + LDEBUGF("flush_fat()\n"); for(i = 0;i < FAT_CACHE_SIZE;i++) { - if(fat_cache[i].ptr && fat_cache[i].dirty) + if(fat_cache[i].inuse && fat_cache[i].dirty) { - secnum = fat_cache[i].secnum + fat_bpb.bpb_rsvdseccnt + - fat_bpb.startsector; - DEBUGF("Flushing FAT sector %d\n", secnum); - sec = fat_cache[i].ptr; + secnum = fat_cache[i].secnum + fat_bpb.startsector; + LDEBUGF("Flushing FAT sector %x\n", secnum); + sec = fat_cache_sectors[i]; /* Write to the first FAT */ err = ata_write_sectors(secnum, 1, sec); @@ -514,19 +535,41 @@ static int flush_fat(struct bpb *bpb) return -1; } - /* Write to the second FAT */ - err = ata_write_sectors(secnum + fatsz, 1, sec); - if(err) + if(fat_bpb.bpb_numfats > 1 ) { - DEBUGF( "flush_fat() - Couldn't write" - " sector (%d)\n", secnum + fatsz); - return -1; + /* Write to the second FAT */ + err = ata_write_sectors(secnum + fat_bpb.fatsize, 1, sec); + if (err) + { + DEBUGF( "flush_fat() - Couldn't write" + " sector (%d)\n", secnum + fat_bpb.fatsize); + return -2; + } } - fat_cache[i].dirty = 0; + fat_cache[i].dirty = false; } } - getcurrdostime(&d, &t, &m); + /* update fsinfo */ + err = ata_read_sectors(fat_bpb.startsector + fat_bpb.bpb_fsinfo, 1,fsinfo); + if (err) + { + DEBUGF( "flush_fat() - Couldn't read FSInfo (error code %d)\n", err); + return -1; + } + intptr = (int*)&(fsinfo[FSINFO_FREECOUNT]); + *intptr = SWAB32(fat_bpb.fsinfo.freecount); + + intptr = (int*)&(fsinfo[FSINFO_NEXTFREE]); + *intptr = SWAB32(fat_bpb.fsinfo.nextfree); + + err = ata_write_sectors(fat_bpb.startsector + fat_bpb.bpb_fsinfo,1,fsinfo); + if (err) + { + DEBUGF( "flush_fat() - Couldn't write FSInfo (error code %d)\n", err); + return -1; + } + return 0; } @@ -534,10 +577,9 @@ static unsigned int getcurrdostime(unsigned short *dosdate, unsigned short *dostime, unsigned char *dostenth) { - struct timeb tb; +#if 0 struct tm *tm; - - ftime(&tb); + unsigned long now = time(); tm = localtime(&tb.time); *dosdate = ((tm->tm_year - 80) << 9) | @@ -549,102 +591,92 @@ static unsigned int getcurrdostime(unsigned short *dosdate, (tm->tm_sec >> 1); *dostenth = (tm->tm_sec & 1) * 100 + tb.millitm / 10; +#else + *dosdate = 0; + *dostime = 0; + *dostenth = 0; +#endif return 0; } -static int add_dir_entry(unsigned int currdir, struct fat_direntry *de) +static int add_dir_entry(struct fat_dir* dir, + struct fat_direntry* de, + struct fat_file* file) { unsigned char buf[SECTOR_SIZE]; unsigned char *eptr; int i; int err; - unsigned int sec; - unsigned int sec_cnt; - int need_to_update_last_empty_marker = 0; - int is_rootdir = (currdir == 0); - int done = 0; + int sec; + int sec_cnt; + bool need_to_update_last_empty_marker = false; + bool done = false; unsigned char firstbyte; + int currdir = dir->startcluster; + bool is_rootdir = (currdir == 0); - if(is_rootdir) - { + LDEBUGF( "add_dir_entry()\n"); + + if (is_rootdir) sec = fat_bpb.rootdirsector; - } else - { sec = first_sector_of_cluster(currdir); - } sec_cnt = 0; while(!done) { - /* The root dir has a fixed size */ - if(is_rootdir) - { - if(sec_cnt >= fat_bpb.bpb_rootentcnt * 32 / fat_bpb.bpb_bytspersec) - { - /* We have reached the last sector of the root dir */ - if(need_to_update_last_empty_marker) - { - /* Since the directory is full, there is no room for - a marker, so we just exit */ - return 0; - } - else - { - DEBUGF( "add_dir_entry() -" - " Root dir is full\n"); - return -1; - } - } - } - else + if (sec_cnt >= fat_bpb.bpb_secperclus) { - if(sec_cnt >= fat_bpb.bpb_secperclus) + int oldcluster = currdir; + /* We have reached the end of this cluster */ + LDEBUGF("Moving to the next cluster..."); + currdir = get_next_cluster(currdir); + LDEBUGF("new cluster is %d\n", currdir); + + if (!currdir) { - /* We have reached the end of this cluster */ - DEBUGF("Moving to the next cluster..."); - currdir = get_next_cluster(currdir); - DEBUGF("new cluster is %d\n", currdir); - - if(!currdir) - { - /* This was the last in the chain, - we have to allocate a new cluster */ - /* TODO */ + currdir = find_free_cluster(fat_bpb.fsinfo.nextfree); + if (!currdir) { + currdir = find_free_cluster(0); + if (!currdir) { + DEBUGF("add_dir_entry(): Disk full!\n"); + return -1; + } } + update_fat_entry(oldcluster, currdir); } } - DEBUGF("Reading sector %d...\n", sec); + LDEBUGF("Reading sector %d...\n", sec); /* Read the next sector in the current dir */ err = ata_read_sectors(sec + fat_bpb.startsector,1,buf); - if(err) + if (err) { DEBUGF( "add_dir_entry() - Couldn't read dir sector" " (error code %d)\n", err); - return -1; + return -2; } - if(need_to_update_last_empty_marker) + if (need_to_update_last_empty_marker) { /* All we need to do is to set the first entry to 0 */ - DEBUGF("Clearing the first entry in sector %d\n", sec); + LDEBUGF("Clearing the first entry in sector %x\n", sec); buf[0] = 0; - done = 1; + done = true; } else { /* Look for a free slot */ - for(i = 0;i < SECTOR_SIZE;i+=32) + for (i = 0; i < SECTOR_SIZE; i += DIR_ENTRY_SIZE) { firstbyte = buf[i]; - if(firstbyte == 0xe5 || firstbyte == 0) + if (firstbyte == 0xe5 || firstbyte == 0) { - DEBUGF("Found free slot at entry %d in sector %d\n", - i/32, sec); + LDEBUGF("Found free slot at entry %d in sector %x\n", + i/DIR_ENTRY_SIZE, sec); eptr = &buf[i]; - memset(eptr, 0, 32); + memset(eptr, 0, DIR_ENTRY_SIZE); strncpy(&eptr[FATDIR_NAME], de->name, 11); eptr[FATDIR_ATTR] = de->attr; eptr[FATDIR_NTRES] = 0; @@ -665,31 +697,37 @@ static int add_dir_entry(unsigned int currdir, struct fat_direntry *de) eptr[FATDIR_FILESIZE+2] = (de->filesize >> 16) & 0xff; eptr[FATDIR_FILESIZE+3] = (de->filesize >> 24) & 0xff; + /* remember where the dir entry is located */ + file->dirsector = sec; + file->direntry = i/DIR_ENTRY_SIZE; + /* Advance the last_empty_entry marker */ - if(firstbyte == 0) + if (firstbyte == 0) { - i += 32; - if(i < SECTOR_SIZE) + i += DIR_ENTRY_SIZE; + if (i < SECTOR_SIZE) { buf[i] = 0; /* We are done */ - done = 1; + done = true; } else { /* We must fill in the first entry in the next sector */ - need_to_update_last_empty_marker = 1; + need_to_update_last_empty_marker = true; } } + else + done = true; err = ata_write_sectors(sec + fat_bpb.startsector,1,buf); - if(err) + if (err) { DEBUGF( "add_dir_entry() - " " Couldn't write dir" " sector (error code %d)\n", err); - return -1; + return -3; } break; } @@ -746,11 +784,6 @@ static int create_dos_name(unsigned char *name, unsigned char *newname) int i; char *ext; - if(strlen(name) > 12) - { - return -1; - } - strcpy(n, name); ext = strchr(n, '.'); @@ -763,7 +796,7 @@ static int create_dos_name(unsigned char *name, unsigned char *newname) In either case it is illegal. */ if(n[0] == 0) { - return -1; + return -2; } /* Name part */ @@ -781,10 +814,10 @@ static int create_dos_name(unsigned char *name, unsigned char *newname) } /* Extension part */ - for(i = 0;ext && ext[i] && (i < 3);i++) + for (i = 0;ext && ext[i] && (i < 3);i++) { c = char2dos(ext[i]); - if(c) + if (c) { newname[8+i] = toupper(c); } @@ -796,50 +829,48 @@ static int create_dos_name(unsigned char *name, unsigned char *newname) return 0; } -int fat_create_dir(unsigned int currdir, char *name) +static void update_dir_entry( struct fat_file* file, int size ) { - struct fat_direntry de; + unsigned char buf[SECTOR_SIZE]; + int sector = file->dirsector + fat_bpb.startsector; + unsigned char* entry = buf + file->direntry * DIR_ENTRY_SIZE; + unsigned int* sizeptr; + unsigned short* clusptr; int err; - DEBUGF("fat_create_file()\n"); - memset(&de, 0, sizeof(struct fat_direntry)); - if(create_dos_name(name, de.name) < 0) + LDEBUGF("update_dir_entry(cluster:%x entry:%d size:%d)\n", + file->firstcluster,file->direntry,size); + + if ( file->direntry >= (SECTOR_SIZE / DIR_ENTRY_SIZE) ) { + DEBUGF("update_dir_entry(): Illegal entry %d!\n",file->direntry); + return; + } + + err = ata_read_sectors(sector, 1, buf); + if (err) { - DEBUGF( "fat_create_file() - Illegal file name (%s)\n", name); - return -1; + DEBUGF( "update_dir_entry() - Couldn't read dir sector %d" + " (error code %d)\n", sector, err); + return; } + + clusptr = (short*)(entry + FATDIR_FSTCLUSHI); + *clusptr = SWAB16(file->firstcluster >> 16); - getcurrdostime(&de.crtdate, &de.crttime, &de.crttimetenth); - de.wrtdate = de.crtdate; - de.wrttime = de.crttime; - de.filesize = 0; - de.attr = FAT_ATTR_DIRECTORY; - - err = add_dir_entry(currdir, &de); - return 0; -} + clusptr = (short*)(entry + FATDIR_FSTCLUSLO); + *clusptr = SWAB16(file->firstcluster & 0xffff); -int fat_create_file(unsigned int currdir, char *name) -{ - struct fat_direntry de; - int err; + sizeptr = (int*)(entry + FATDIR_FILESIZE); + *sizeptr = SWAB32(size); - DEBUGF("fat_create_file()\n"); - memset(&de, 0, sizeof(struct fat_direntry)); - if(create_dos_name(name, de.name) < 0) + err = ata_write_sectors(sector, 1, buf); + if (err) { - DEBUGF( "fat_create_file() - Illegal file name (%s)\n", name); - return -1; + DEBUGF( "update_file_size() - Couldn't write dir sector %d" + " (error code %d)\n", sector, err); + return; } - getcurrdostime(&de.crtdate, &de.crttime, &de.crttimetenth); - de.wrtdate = de.crtdate; - de.wrttime = de.crttime; - de.filesize = 0; - - err = add_dir_entry(currdir, &de); - return err; } -#endif static int parse_direntry(struct fat_direntry *de, unsigned char *buf) { @@ -866,37 +897,138 @@ static int parse_direntry(struct fat_direntry *de, unsigned char *buf) return 1; } -int fat_open( unsigned int startcluster, struct fat_file *file) +int fat_open(unsigned int startcluster, + struct fat_file *file, + struct fat_dir* dir) { file->firstcluster = startcluster; file->nextcluster = startcluster; file->nextsector = cluster2sec(startcluster); file->sectornum = 0; + + /* remember where the file's dir entry is located */ + file->dirsector = dir->cached_sec; + file->direntry = (dir->entry % DIR_ENTRIES_PER_SECTOR) - 1; + LDEBUGF("fat_open: entry %d\n",file->direntry); + return 0; +} + +int fat_create_file(char* name, + struct fat_file* file, + struct fat_dir* dir) +{ + struct fat_direntry de; + int err; + + LDEBUGF("fat_create_file(\"%s\",%x,%x)\n",name,file,dir); + memset(&de, 0, sizeof(struct fat_direntry)); + if (create_dos_name(name, de.name) < 0) + { + DEBUGF( "fat_create_file() - Illegal file name (%s)\n", name); + return -1; + } + getcurrdostime(&de.crtdate, &de.crttime, &de.crttimetenth); + de.wrtdate = de.crtdate; + de.wrttime = de.crttime; + de.filesize = 0; + + err = add_dir_entry(dir, &de, file); + if (!err) { + file->firstcluster = 0; + file->nextcluster = 0; + file->nextsector = 0; + file->sectornum = 0; + } + + return err; +} + +int fat_closewrite(struct fat_file *file, int size) +{ + int endcluster = file->nextcluster; + int next, last = endcluster; + + /* free unused clusters, if any */ + for ( next = get_next_cluster(last); next; last = next ) { + LDEBUGF("Clearing cluster %x\n",last); + update_fat_entry(last,0); + } + + /* mark last used cluster as last in chain */ + update_fat_entry(endcluster, FAT_EOF_MARK); + + flush_fat(); + + update_dir_entry(file, size); + return 0; } -int fat_read( struct fat_file *file, int sectorcount, void* buf ) +int fat_readwrite( struct fat_file *file, int sectorcount, + void* buf, bool write ) { int cluster = file->nextcluster; int sector = file->nextsector; int numsec = file->sectornum; - int first = sector, last = sector; + int first, last; int err, i; + LDEBUGF( "fat_readwrite(file:%x,count:%d,buf:%x,%s)\n", + cluster,sectorcount,buf,write?"write":"read"); + if ( sector == -1 ) return 0; - /* find sequential sectors and read them all at once */ + if ( write && !cluster) { + /* new file */ + cluster = find_free_cluster(fat_bpb.fsinfo.nextfree); + if (!cluster) { + cluster = find_free_cluster(0); + if (!cluster) { + DEBUGF("fat_readwrite(): Disk full!\n"); + return -3; + } + } + file->firstcluster = cluster; + sector = cluster2sec(cluster); + if (sector<0) + return -1; + } + + first = sector; + last = sector; + + /* find sequential sectors and read/write them all at once */ for (i=0; i<sectorcount && sector>=0; i++ ) { numsec++; if ( numsec >= fat_bpb.bpb_secperclus ) { + int oldcluster = cluster; cluster = get_next_cluster(cluster); if (!cluster) { - /* end of file */ - sector = -1; + if ( write ) { + /* writing past end-of-file, + find a new free cluster to use. */ + cluster = find_free_cluster(cluster); + if (!cluster) { + /* no cluster found after last, + search from beginning */ + cluster = find_free_cluster(0); + if (!cluster) { + /* no free clusters. disk is full. */ + sector = -1; + DEBUGF("fat_readwrite(): Disk full!\n"); + } + } + if ( cluster ) + update_fat_entry(oldcluster, cluster); + } + else { + /* reading past end-of-file */ + sector = -1; + } } - else - { + + if (cluster) { sector = cluster2sec(cluster); if (sector<0) return -1; @@ -910,11 +1042,14 @@ int fat_read( struct fat_file *file, int sectorcount, void* buf ) (i == sectorcount-1) || /* last sector requested? */ (last-first+1 == 256) ) { /* max 256 sectors per ata request */ int count = last-first+1; - err = ata_read_sectors(first + fat_bpb.startsector, count, buf); - if(err) { - DEBUGF( "fat_read() - Couldn't read sector %d" + if (write) + err = ata_write_sectors(first + fat_bpb.startsector, count, buf); + else + err = ata_read_sectors(first + fat_bpb.startsector, count, buf); + if (err) { + DEBUGF( "fat_readwrite() - Couldn't read sector %d" " (error code %d)\n", sector,err); - return -1; + return -2; } ((char*)buf) += count * SECTOR_SIZE; first = sector; @@ -970,9 +1105,9 @@ int fat_seek(struct fat_file *file, int seeksector ) return 0; } -int fat_opendir(struct fat_dir *dir, unsigned int currdir) +int fat_opendir(struct fat_dir *dir, unsigned int startcluster) { - int is_rootdir = (currdir == 0); + int is_rootdir = (startcluster == 0); unsigned int sec; int err; @@ -982,7 +1117,7 @@ int fat_opendir(struct fat_dir *dir, unsigned int currdir) } else { - sec = first_sector_of_cluster(currdir); + sec = first_sector_of_cluster(startcluster); } /* Read the first sector in the current dir */ @@ -997,13 +1132,14 @@ int fat_opendir(struct fat_dir *dir, unsigned int currdir) dir->entry = 0; dir->cached_sec = sec; dir->num_sec = 0; + dir->startcluster = startcluster; return 0; } int fat_getnext(struct fat_dir *dir, struct fat_direntry *entry) { - int done = 0; + bool done = false; int i; int err; unsigned char firstbyte; @@ -1013,29 +1149,30 @@ int fat_getnext(struct fat_dir *dir, struct fat_direntry *entry) while(!done) { - for(i = dir->entry;i < SECTOR_SIZE/32;i++) + for (i = dir->entry; i < SECTOR_SIZE/DIR_ENTRY_SIZE; i++) { - firstbyte = dir->cached_buf[i*32]; + firstbyte = dir->cached_buf[i*DIR_ENTRY_SIZE]; - if(firstbyte == 0xe5) { + if (firstbyte == 0xe5) { /* free entry */ sectoridx = 0; continue; } - if(firstbyte == 0) { + if (firstbyte == 0) { /* last entry */ entry->name[0] = 0; return 0; } /* longname entry? */ - if ( ( dir->cached_buf[i*32 + FATDIR_ATTR] & + if ( ( dir->cached_buf[i*DIR_ENTRY_SIZE + FATDIR_ATTR] & FAT_ATTR_LONG_NAME_MASK ) == FAT_ATTR_LONG_NAME ) { - longarray[longs++] = i*32 + sectoridx; + longarray[longs++] = i*DIR_ENTRY_SIZE + sectoridx; } else { - if ( parse_direntry(entry, &dir->cached_buf[i*32]) ) { + if ( parse_direntry(entry, + &dir->cached_buf[i*DIR_ENTRY_SIZE]) ) { /* don't return volume id entry */ if ( entry->attr == FAT_ATTR_VOLUME_ID ) @@ -1076,7 +1213,7 @@ int fat_getnext(struct fat_dir *dir, struct fat_direntry *entry) } entry->name[l]=0; } - done = 1; + done = true; sectoridx = 0; break; } @@ -1091,7 +1228,7 @@ int fat_getnext(struct fat_dir *dir, struct fat_direntry *entry) sectoridx += SECTOR_SIZE; /* Next sector? */ - if(i < SECTOR_SIZE/32) + if (i < SECTOR_SIZE / DIR_ENTRY_SIZE) { i++; } @@ -1100,7 +1237,7 @@ int fat_getnext(struct fat_dir *dir, struct fat_direntry *entry) dir->num_sec++; /* Do we need to advance one cluster? */ - if(dir->num_sec < fat_bpb.bpb_secperclus) + if (dir->num_sec < fat_bpb.bpb_secperclus) { dir->cached_sec++; } @@ -1113,16 +1250,16 @@ int fat_getnext(struct fat_dir *dir, struct fat_direntry *entry) } dir->num_sec = 0; cluster = get_next_cluster( cluster ); - if(!cluster) + if (!cluster) { DEBUGF("End of cluster chain.\n"); - return -1; + return -2; } dir->cached_sec = cluster2sec(cluster); if ( dir->cached_sec < 0 ) { DEBUGF("Invalid cluster: %d\n",cluster); - return -1; + return -3; } } @@ -1130,11 +1267,11 @@ int fat_getnext(struct fat_dir *dir, struct fat_direntry *entry) /* Read the next sector */ err = ata_read_sectors(dir->cached_sec + fat_bpb.startsector, 1, dir->cached_buf); - if(err) + if (err) { DEBUGF( "fat_getnext() - Couldn't read dir sector" " (error code %d)\n", err); - return -1; + return -4; } i = 0; diff --git a/firmware/drivers/fat.h b/firmware/drivers/fat.h index 836d5c6..3052488 100644 --- a/firmware/drivers/fat.h +++ b/firmware/drivers/fat.h @@ -20,6 +20,8 @@ #ifndef FAT_H #define FAT_H +#include <stdbool.h> + #define SECTOR_SIZE 512 struct fat_direntry @@ -50,6 +52,7 @@ struct fat_dir int cached_sec; int num_sec; unsigned char cached_buf[SECTOR_SIZE]; + int startcluster; }; struct fat_file @@ -58,17 +61,23 @@ struct fat_file int nextcluster; /* cluster of last access */ int nextsector; /* sector of last access */ int sectornum; /* sector number in this cluster */ + int dirsector; /* sector where the dir entry is located */ + int direntry; /* dir entry index in sector */ }; extern int fat_mount(int startsector); -#ifdef DISK_WRITE -extern int fat_create_file(unsigned int currdir, char *name); extern int fat_create_dir(unsigned int currdir, char *name); -#endif extern int fat_startsector(void); -extern int fat_open(unsigned int cluster, struct fat_file *ent); -extern int fat_read(struct fat_file *ent, int sectorcount, void* buf ); +extern int fat_open(unsigned int cluster, + struct fat_file* ent, + struct fat_dir* dir); +extern int fat_create_file(char* name, + struct fat_file* ent, + struct fat_dir* dir); +extern int fat_readwrite(struct fat_file *ent, int sectorcount, + void* buf, bool write ); +extern int fat_closewrite(struct fat_file *ent, int size); extern int fat_seek(struct fat_file *ent, int sector ); extern int fat_opendir(struct fat_dir *ent, unsigned int currdir); diff --git a/firmware/test/fat/README b/firmware/test/fat/README new file mode 100644 index 0000000..76141c0 --- /dev/null +++ b/firmware/test/fat/README @@ -0,0 +1,25 @@ +This code is for testing the Rockbox fat code on a dummy drive image file. + +Dummy image +----------- +Here's how to create a 1 gig dummy drive image in linux: + +# dd if=/dev/hda of=disk.img bs=1M count=1024 + +You can then format disk.img as a FAT32 partition: + +# mkdosfs -F 32 disk.img + +To mount the image, your linux kernel must include the loopback device: + +# mount -o loop disk.img /mnt/image + +Now copy some test data to the disk, umount it and start testing. + + +Test code +--------- +The files in this dir build the 'fat' program. It will read 'disk.img' and +treat is as a real disk, thanks to the ata-sim.c module. + +Modify the main.c source code to make it perform the tests you want. diff --git a/firmware/test/fat/ata-sim.c b/firmware/test/fat/ata-sim.c index ab7266d..a37fabc 100644 --- a/firmware/test/fat/ata-sim.c +++ b/firmware/test/fat/ata-sim.c @@ -24,6 +24,13 @@ int ata_read_sectors(unsigned long start, unsigned char count, void* buf) int ata_write_sectors(unsigned long start, unsigned char count, void* buf) { + DEBUGF("Writing block 0x%lx\n",start); + + if (start == 0) { + DEBUGF("Holy crap! You're writing on sector 0!\n"); + exit(0); + } + if(fseek(file,start*BLOCK_SIZE,SEEK_SET)) { perror("fseek"); return -1; diff --git a/firmware/test/fat/main.c b/firmware/test/fat/main.c index 4a11e0a..1b9fd22 100644 --- a/firmware/test/fat/main.c +++ b/firmware/test/fat/main.c @@ -1,6 +1,7 @@ #include <stdio.h> #include <stdlib.h> #include <string.h> +#include <stdarg.h> #include "fat.h" #include "debug.h" #include "disk.h" @@ -14,6 +15,15 @@ void dbg_dump_sector(int sec); void dbg_dump_buffer(unsigned char *buf); void dbg_console(void); +void panicf( char *fmt, ...) +{ + va_list ap; + va_start( ap, fmt ); + vprintf( fmt, ap ); + va_end( ap ); + exit(0); +} + void dbg_dump_sector(int sec) { unsigned char buf[512]; @@ -75,14 +85,16 @@ void dbg_dir(char* currdir) void dbg_mkfile(char* name) { char* text = "Detta är en dummy-text\n"; + int i; int fd = open(name,O_WRONLY); if (fd<0) { DEBUGF("Failed creating file\n"); return; } - if (write(fd, text, strlen(text)) < 0) - DEBUGF("Failed writing data\n"); - + for (i=0;i<200;i++) + if (write(fd, text, strlen(text)) < 0) + DEBUGF("Failed writing data\n"); + close(fd); } @@ -168,6 +180,33 @@ void dbg_tail(char* name) close(fd); } +void dbg_head(char* name) +{ + unsigned char buf[SECTOR_SIZE*5]; + int fd,rc; + + fd = open(name,O_RDONLY); + if (fd<0) + return; + DEBUGF("Got file descriptor %d\n",fd); + + rc = read(fd, buf, SECTOR_SIZE); + if( rc > 0 ) + { + buf[rc]=0; + printf("%d: %s\n", strlen(buf), buf); + } + else if ( rc == 0 ) { + DEBUGF("EOF\n"); + } + else + { + DEBUGF("Failed reading file: %d\n",rc); + } + + close(fd); +} + char current_directory[256] = "\\"; int last_secnum = 0; @@ -284,9 +323,12 @@ int main(int argc, char *argv[]) } //dbg_console(); - //dbg_tail("/fat.h"); //dbg_dir("/"); - dbg_mkfile("/apa.txt"); +#if 1 + dbg_head("/bepa.txt"); +#else + dbg_mkfile("/bepa.txt"); +#endif dbg_dir("/"); return 0; |