Currently the fat code is messy related to Coding rules.

Signed-off-by: Remy Bohmer linux@bohmer.net --- fs/fat/fat.c | 1004 ++++++++++++++++++++++++++++----------------------------- fs/fat/file.c | 65 ++-- include/fat.h | 7 +- 3 files changed, 518 insertions(+), 558 deletions(-)

diff --git a/fs/fat/fat.c b/fs/fat/fat.c index 06eabc3..0d4942a 100644 --- a/fs/fat/fat.c +++ b/fs/fat/fat.c @@ -34,8 +34,7 @@ /* * Convert a string to lowercase. */ -static void -downcase(char *str) +static void downcase(char *str) { while (*str != '\0') { TOLOWER(*str); @@ -43,7 +42,7 @@ downcase(char *str) } }

-static block_dev_desc_t *cur_dev = NULL; +static block_dev_desc_t *cur_dev = NULL; static unsigned long part_offset = 0; static int cur_part = 1;

@@ -51,21 +50,18 @@ static int cur_part = 1; #define DOS_PART_MAGIC_OFFSET 0x1fe #define DOS_FS_TYPE_OFFSET 0x36

-int disk_read (__u32 startblock, __u32 getsize, __u8 * bufptr) +static int disk_read(__u32 startblock, __u32 nofblocks, __u8 *bufptr) { startblock += part_offset; if (cur_dev == NULL) return -1; - if (cur_dev->block_read) { - return cur_dev->block_read (cur_dev->dev - , startblock, getsize, (unsigned long *)bufptr); - } + if (cur_dev->block_read) + return cur_dev->block_read(cur_dev->dev, startblock, nofblocks, + (unsigned long *)bufptr); return -1; }

- -int -fat_register_device(block_dev_desc_t *dev_desc, int part_no) +int fat_register_device(block_dev_desc_t *dev_desc, int part_no) { unsigned char buffer[SECTOR_SIZE]; disk_partition_t info; @@ -74,22 +70,22 @@ fat_register_device(block_dev_desc_t *dev_desc, int part_no) return -1; cur_dev = dev_desc; /* check if we have a MBR (on floppies we have only a PBR) */ - if (dev_desc->block_read (dev_desc->dev, 0, 1, (ulong *) buffer) != 1) { - printf ("** Can't read from device %d **\n", dev_desc->dev); + if (dev_desc->block_read(dev_desc->dev, 0, 1, (ulong *)buffer) != 1) { + printf("** Can't read from device %d **\n", dev_desc->dev); return -1; } if (buffer[DOS_PART_MAGIC_OFFSET] != 0x55 || - buffer[DOS_PART_MAGIC_OFFSET + 1] != 0xaa) { + buffer[DOS_PART_MAGIC_OFFSET + 1] != 0xaa) /* no signature found */ return -1; - } + #if (defined(CONFIG_CMD_IDE) || \ defined(CONFIG_CMD_SCSI) || \ defined(CONFIG_CMD_USB) || \ defined(CONFIG_MMC) || \ defined(CONFIG_SYSTEMACE) ) /* First we assume, there is a MBR */ - if (!get_partition_info (dev_desc, part_no, &info)) { + if (!get_partition_info(dev_desc, part_no, &info)) { part_offset = info.start; cur_part = part_no; } else if (!strncmp((char *)&buffer[DOS_FS_TYPE_OFFSET], "FAT", 3)) { @@ -97,13 +93,13 @@ fat_register_device(block_dev_desc_t *dev_desc, int part_no) cur_part = 1; part_offset = 0; } else { - printf ("** Partition %d not valid on device %d **\n", - part_no, dev_desc->dev); + printf("** Partition %d not valid on device %d **\n", + part_no, dev_desc->dev); return -1; }

#else - if (!strncmp((char *)&buffer[DOS_FS_TYPE_OFFSET],"FAT",3)) { + if (!strncmp((char *)&buffer[DOS_FS_TYPE_OFFSET], "FAT", 3)) { /* ok, we assume we are on a PBR only */ cur_part = 1; part_offset = 0; @@ -121,37 +117,34 @@ fat_register_device(block_dev_desc_t *dev_desc, int part_no) return 0; }

- /* * Get the first occurence of a directory delimiter ('/' or '') in a string. * Return index into string if found, -1 otherwise. */ -static int -dirdelim(char *str) +static int dirdelim(char *str) { char *start = str;

while (*str != '\0') { - if (ISDIRDELIM(*str)) return str - start; + if (ISDIRDELIM(*str)) + return str - start; str++; } return -1; }

- /* * Match volume_info fs_type strings. * Return 0 on match, -1 otherwise. */ -static int -compare_sign(char *str1, char *str2) +static int compare_sign(char *str1, char *str2) { - char *end = str1+SIGNLEN; + char *end = str1 + SIGNLEN;

while (str1 != end) { - if (*str1 != *str2) { + if (*str1 != *str2) return -1; - } + str1++; str2++; } @@ -159,15 +152,14 @@ compare_sign(char *str1, char *str2) return 0; }

- /* * Extract zero terminated short name from a directory entry. */ -static void get_name (dir_entry *dirent, char *s_name) +static void get_name(dir_entry *dirent, char *s_name) { char *ptr;

- memcpy (s_name, dirent->name, 8); + memcpy(s_name, dirent->name, 8); s_name[8] = '\0'; ptr = s_name; while (*ptr && *ptr != ' ') @@ -175,7 +167,7 @@ static void get_name (dir_entry *dirent, char *s_name) if (dirent->ext[0] && dirent->ext[0] != ' ') { *ptr = '.'; ptr++; - memcpy (ptr, dirent->ext, 3); + memcpy(ptr, dirent->ext, 3); ptr[3] = '\0'; while (*ptr && *ptr != ' ') ptr++; @@ -185,19 +177,20 @@ static void get_name (dir_entry *dirent, char *s_name) *s_name = '\0'; else if (*s_name == aRING) *s_name = DELETED_FLAG; - downcase (s_name); + downcase(s_name); }

/* * Get the entry at index 'entry' in a FAT (12/16/32) table. * On failure 0x00 is returned. */ -static __u32 -get_fatent(fsdata *mydata, __u32 entry) +static __u32 get_fatent(fsdata *mydata, __u32 entry) { __u32 bufnum; __u32 offset; __u32 ret = 0x00; + __u32 off16; + __u16 val1, val2;

switch (mydata->fatsize) { case 32: @@ -220,7 +213,7 @@ get_fatent(fsdata *mydata, __u32 entry)

/* Read a new block of FAT entries into the cache. */ if (bufnum != mydata->fatbufnum) { - int getsize = FATBUFSIZE/FS_BLOCK_SIZE; + int nofblocks = FATBUFSIZE / FS_BLOCK_SIZE; __u8 *bufptr = mydata->fatbuf; __u32 fatlength = mydata->fatlength; __u32 startblock = bufnum * FATBUFBLOCKS; @@ -228,8 +221,9 @@ get_fatent(fsdata *mydata, __u32 entry) fatlength *= SECTOR_SIZE; /* We want it in bytes now */ startblock += mydata->fat_sect; /* Offset from start of disk */

- if (getsize > fatlength) getsize = fatlength; - if (disk_read(startblock, getsize, bufptr) < 0) { + if (nofblocks > (fatlength / FS_BLOCK_SIZE)) + nofblocks = fatlength / FS_BLOCK_SIZE; + if (disk_read(startblock, nofblocks, bufptr) < 0) { FAT_DPRINT("Error reading FAT blocks\n"); return ret; } @@ -239,96 +233,89 @@ get_fatent(fsdata *mydata, __u32 entry) /* Get the actual entry from the table */ switch (mydata->fatsize) { case 32: - ret = FAT2CPU32(((__u32*)mydata->fatbuf)[offset]); + ret = FAT2CPU32(((__u32 *) mydata->fatbuf)[offset]); break; case 16: - ret = FAT2CPU16(((__u16*)mydata->fatbuf)[offset]); + ret = FAT2CPU16(((__u16 *) mydata->fatbuf)[offset]); break; - case 12: { - __u32 off16 = (offset*3)/4; - __u16 val1, val2; + case 12: + off16 = (offset * 3) / 4;

switch (offset & 0x3) { case 0: - ret = FAT2CPU16(((__u16*)mydata->fatbuf)[off16]); + ret = FAT2CPU16(((__u16 *) mydata->fatbuf)[off16]); ret &= 0xfff; break; case 1: - val1 = FAT2CPU16(((__u16*)mydata->fatbuf)[off16]); + val1 = FAT2CPU16(((__u16 *) mydata->fatbuf)[off16]); val1 &= 0xf000; - val2 = FAT2CPU16(((__u16*)mydata->fatbuf)[off16+1]); + val2 = FAT2CPU16(((__u16 *) mydata->fatbuf)[off16 + 1]); val2 &= 0x00ff; ret = (val2 << 4) | (val1 >> 12); break; case 2: - val1 = FAT2CPU16(((__u16*)mydata->fatbuf)[off16]); + val1 = FAT2CPU16(((__u16 *) mydata->fatbuf)[off16]); val1 &= 0xff00; - val2 = FAT2CPU16(((__u16*)mydata->fatbuf)[off16+1]); + val2 = FAT2CPU16(((__u16 *) mydata->fatbuf)[off16 + 1]); val2 &= 0x000f; ret = (val2 << 8) | (val1 >> 8); break; case 3: - ret = FAT2CPU16(((__u16*)mydata->fatbuf)[off16]);; + ret = FAT2CPU16(((__u16 *) mydata->fatbuf)[off16]); ret = (ret & 0xfff0) >> 4; break; default: break; } - } - break; + break; } FAT_DPRINT("ret: %d, offset: %d\n", ret, offset);

return ret; }

- /* * Read at most 'size' bytes from the specified cluster into 'buffer'. * Return 0 on success, -1 otherwise. */ -static int -get_cluster(fsdata *mydata, __u32 clustnum, __u8 *buffer, unsigned long size) +static int get_cluster(fsdata *mydata, __u32 clustnum, + __u8 *buffer, unsigned long size_bytes) { int idx = 0; __u32 startsect;

- if (clustnum > 0) { - startsect = mydata->data_begin + clustnum*mydata->clust_size; - } else { + if (clustnum > 0) + startsect = mydata->data_begin + clustnum * mydata->clust_size; + else startsect = mydata->rootdir_sect; - }

FAT_DPRINT("gc - clustnum: %d, startsect: %d\n", clustnum, startsect); - if (disk_read(startsect, size/FS_BLOCK_SIZE , buffer) < 0) { + if (disk_read(startsect, size_bytes / FS_BLOCK_SIZE, buffer) < 0) { FAT_DPRINT("Error reading data\n"); return -1; } - if(size % FS_BLOCK_SIZE) { + if (size_bytes % FS_BLOCK_SIZE) { __u8 tmpbuf[FS_BLOCK_SIZE]; - idx= size/FS_BLOCK_SIZE; + idx = size_bytes / FS_BLOCK_SIZE; if (disk_read(startsect + idx, 1, tmpbuf) < 0) { FAT_DPRINT("Error reading data\n"); return -1; } - buffer += idx*FS_BLOCK_SIZE; + buffer += idx * FS_BLOCK_SIZE;

- memcpy(buffer, tmpbuf, size % FS_BLOCK_SIZE); + memcpy(buffer, tmpbuf, size_bytes % FS_BLOCK_SIZE); return 0; } - return 0; }

- /* * Read at most 'maxsize' bytes from the file associated with 'dentptr' * into 'buffer'. * Return the number of bytes read or -1 on fatal errors. */ -static long -get_contents(fsdata *mydata, dir_entry *dentptr, __u8 *buffer, - unsigned long maxsize) +static long get_contents(fsdata *mydata, dir_entry *dentptr, __u8 *buffer, + unsigned long maxsize) { unsigned long filesize = FAT2CPU32(dentptr->size), gotsize = 0; unsigned int bytesperclust = mydata->clust_size * SECTOR_SIZE; @@ -338,25 +325,44 @@ get_contents(fsdata *mydata, dir_entry *dentptr, __u8 *buffer,

FAT_DPRINT("Filesize: %ld bytes\n", filesize);

- if (maxsize > 0 && filesize > maxsize) filesize = maxsize; + if (maxsize > 0 && filesize > maxsize) + filesize = maxsize;

FAT_DPRINT("Reading: %ld bytes\n", filesize);

- actsize=bytesperclust; - endclust=curclust; - do { + actsize = bytesperclust; + endclust = curclust; + for (;;) { /* search for consecutive clusters */ - while(actsize < filesize) { + while (actsize < filesize) { newclust = get_fatent(mydata, endclust); - if((newclust -1)!=endclust) - goto getit; + if ((newclust - 1) != endclust) { + if (get_cluster(mydata, curclust, buffer, + (int)actsize) != 0) { + FAT_ERROR("Error reading cluster\n"); + return -1; + } + gotsize += (int)actsize; + filesize -= actsize; + buffer += actsize; + curclust = get_fatent(mydata, endclust); + if (CHECK_CLUST(curclust, mydata->fatsize)) { + FAT_DPRINT("curclust: 0x%x\n", + curclust); + FAT_ERROR("Invalid FAT entry\n"); + return gotsize; + } + actsize = bytesperclust; + endclust = curclust; + continue; + } if (CHECK_CLUST(newclust, mydata->fatsize)) { FAT_DPRINT("curclust: 0x%x\n", newclust); FAT_DPRINT("Invalid FAT entry\n"); return gotsize; } - endclust=newclust; - actsize+= bytesperclust; + endclust = newclust; + actsize += bytesperclust; } /* actsize >= file size */ actsize -= bytesperclust; @@ -369,90 +375,75 @@ get_contents(fsdata *mydata, dir_entry *dentptr, __u8 *buffer, gotsize += (int)actsize; filesize -= actsize; buffer += actsize; - actsize= filesize; + actsize = filesize; if (get_cluster(mydata, endclust, buffer, (int)actsize) != 0) { FAT_ERROR("Error reading cluster\n"); return -1; } - gotsize+=actsize; + gotsize += actsize; return gotsize; -getit: - if (get_cluster(mydata, curclust, buffer, (int)actsize) != 0) { - FAT_ERROR("Error reading cluster\n"); - return -1; - } - gotsize += (int)actsize; - filesize -= actsize; - buffer += actsize; - curclust = get_fatent(mydata, endclust); - if (CHECK_CLUST(curclust, mydata->fatsize)) { - FAT_DPRINT("curclust: 0x%x\n", curclust); - FAT_ERROR("Invalid FAT entry\n"); - return gotsize; - } - actsize=bytesperclust; - endclust=curclust; - } while (1); + } }

- #ifdef CONFIG_SUPPORT_VFAT /* * Extract the file name information from 'slotptr' into 'l_name', * starting at l_name[*idx]. * Return 1 if terminator (zero byte) is found, 0 otherwise. */ -static int -slot2str(dir_slot *slotptr, char *l_name, int *idx) +static int slot2str(dir_slot *slotptr, char *l_name, int *idx) { int j;

for (j = 0; j <= 8; j += 2) { l_name[*idx] = slotptr->name0_4[j]; - if (l_name[*idx] == 0x00) return 1; + if (l_name[*idx] == 0x00) + return 1; (*idx)++; } for (j = 0; j <= 10; j += 2) { l_name[*idx] = slotptr->name5_10[j]; - if (l_name[*idx] == 0x00) return 1; + if (l_name[*idx] == 0x00) + return 1; (*idx)++; } for (j = 0; j <= 2; j += 2) { l_name[*idx] = slotptr->name11_12[j]; - if (l_name[*idx] == 0x00) return 1; + if (l_name[*idx] == 0x00) + return 1; (*idx)++; }

return 0; }

- /* * Extract the full long filename starting at 'retdent' (which is really * a slot) into 'l_name'. If successful also copy the real directory entry * into 'retdent' * Return 0 on success, -1 otherwise. */ -__u8 get_vfatname_block[MAX_CLUSTSIZE]; -static int -get_vfatname(fsdata *mydata, int curclust, __u8 *cluster, - dir_entry *retdent, char *l_name) +static __u8 get_vfatname_block[MAX_CLUSTSIZE]; + +static int get_vfatname(fsdata *mydata, int curclust, __u8 *cluster, + dir_entry *retdent, char *l_name) { dir_entry *realdent; - dir_slot *slotptr = (dir_slot*) retdent; - __u8 *nextclust = cluster + mydata->clust_size * SECTOR_SIZE; - __u8 counter = (slotptr->id & ~LAST_LONG_ENTRY_MASK) & 0xff; + dir_slot *slotptr = (dir_slot *) retdent; + __u8 *nextclust = cluster + mydata->clust_size * SECTOR_SIZE; + __u8 counter = (slotptr->id & ~LAST_LONG_ENTRY_MASK) & 0xff; int idx = 0;

- while ((__u8*)slotptr < nextclust) { - if (counter == 0) break; + while ((__u8 *) slotptr < nextclust) { + if (counter == 0) + break; if (((slotptr->id & ~LAST_LONG_ENTRY_MASK) & 0xff) != counter) return -1; slotptr++; counter--; }

- if ((__u8*)slotptr >= nextclust) { + if ((__u8 *) slotptr >= nextclust) { dir_slot *slotptr2;

slotptr--; @@ -467,29 +458,32 @@ get_vfatname(fsdata *mydata, int curclust, __u8 *cluster, FAT_DPRINT("Error: reading directory block\n"); return -1; } - slotptr2 = (dir_slot*) get_vfatname_block; + slotptr2 = (dir_slot *) get_vfatname_block; while (slotptr2->id > 0x01) { slotptr2++; } /* Save the real directory entry */ - realdent = (dir_entry*)slotptr2 + 1; - while ((__u8*)slotptr2 >= get_vfatname_block) { + realdent = (dir_entry *) slotptr2 + 1; + while ((__u8 *) slotptr2 >= get_vfatname_block) { slot2str(slotptr2, l_name, &idx); slotptr2--; } } else { /* Save the real directory entry */ - realdent = (dir_entry*)slotptr; + realdent = (dir_entry *) slotptr; }

do { slotptr--; - if (slot2str(slotptr, l_name, &idx)) break; + if (slot2str(slotptr, l_name, &idx)) + break; } while (!(slotptr->id & LAST_LONG_ENTRY_MASK));

l_name[idx] = '\0'; - if (*l_name == DELETED_FLAG) *l_name = '\0'; - else if (*l_name == aRING) *l_name = DELETED_FLAG; + if (*l_name == DELETED_FLAG) + *l_name = '\0'; + else if (*l_name == aRING) + *l_name = DELETED_FLAG; downcase(l_name);

/* Return the real directory entry */ @@ -498,174 +492,181 @@ get_vfatname(fsdata *mydata, int curclust, __u8 *cluster, return 0; }

- /* Calculate short name checksum */ -static __u8 -mkcksum(const char *str) +static __u8 mkcksum(const char *str) { int i; __u8 ret = 0;

- for (i = 0; i < 11; i++) { - ret = (((ret&1)<<7)|((ret&0xfe)>>1)) + str[i]; - } + for (i = 0; i < 11; i++) + ret = (((ret & 1) << 7) | ((ret & 0xfe) >> 1)) + str[i];

return ret; } #endif

- -/* - * Get the directory entry associated with 'filename' from the directory - * starting at 'startsect' - */ -__u8 get_dentfromdir_block[MAX_CLUSTSIZE]; -static dir_entry *get_dentfromdir (fsdata * mydata, int startsect, - char *filename, dir_entry * retdent, - int dols) +/* Returns 0 on illegal vfat entry, 1 on valid vfat entry */ +static int valid_vfat(fsdata *mydata, dir_entry *dentptr, __u16 *prevcksum, + int curclust, char *l_name, int dols, int *dirs, + int *files, __u8 *read_block) { - __u16 prevcksum = 0xffff; - __u32 curclust = START (retdent); - int files = 0, dirs = 0; - - FAT_DPRINT ("get_dentfromdir: %s\n", filename); - while (1) { - dir_entry *dentptr; - int i; - - if (get_cluster (mydata, curclust, get_dentfromdir_block, - mydata->clust_size * SECTOR_SIZE) != 0) { - FAT_DPRINT ("Error: reading directory block\n"); - return NULL; - } - dentptr = (dir_entry *) get_dentfromdir_block; - for (i = 0; i < DIRENTSPERCLUST; i++) { - char s_name[14], l_name[256]; - - l_name[0] = '\0'; - if (dentptr->name[0] == DELETED_FLAG) { - dentptr++; - continue; - } - if ((dentptr->attr & ATTR_VOLUME)) { #ifdef CONFIG_SUPPORT_VFAT - if ((dentptr->attr & ATTR_VFAT) && - (dentptr->name[0] & LAST_LONG_ENTRY_MASK)) { - prevcksum = ((dir_slot *) dentptr) - ->alias_checksum; - get_vfatname (mydata, curclust, get_dentfromdir_block, - dentptr, l_name); - if (dols) { + if ((dentptr->attr & ATTR_VFAT) && + (dentptr->name[0] & LAST_LONG_ENTRY_MASK)) { + *prevcksum = ((dir_slot *) dentptr)->alias_checksum; + if (get_vfatname(mydata, curclust, read_block, dentptr, l_name)) + return 0; + + if (dols != LS_NO) { int isdir = (dentptr->attr & ATTR_DIR); char dirc; int doit = 0;

if (isdir) { - dirs++; - dirc = '/'; - doit = 1; - } else { - dirc = ' '; - if (l_name[0] != 0) { - files++; + (*dirs)++; + dirc = '/'; doit = 1; - } + } else { + dirc = ' '; + if (l_name[0] != 0) { + (*files)++; + doit = 1; + } } if (doit) { - if (dirc == ' ') { - printf (" %8ld %s%c\n", - (long) FAT2CPU32 (dentptr->size), - l_name, dirc); - } else { - printf (" %s%c\n", l_name, dirc); - } + if (dirc == ' ') + printf(" %8ld %s%c\n", (long)FAT2CPU32 + (dentptr->size), l_name, dirc); + else + printf(" %s%c\n", l_name, + dirc); } - dentptr++; - continue; - } - FAT_DPRINT ("vfatname: |%s|\n", l_name); - } else -#endif - { - /* Volume label or VFAT entry */ - dentptr++; - continue; } - } - if (dentptr->name[0] == 0) { - if (dols) { - printf ("\n%d file(s), %d dir(s)\n\n", files, dirs); + FAT_DPRINT("Rootvfatname: |%s|\n", l_name); + return 1; + } +#endif + /* Probably just a Volume label */ + return 0; +} + +/* + * Get the directory entry associated with 'filename' from the directory + * starting at 'startsect' + */ +static __u8 get_dentfromdir_block[MAX_CLUSTSIZE]; + +static dir_entry *get_dentfromdir(fsdata *mydata, int startsect, + char *filename, dir_entry *retdent, int dols) +{ + __u16 prevcksum = 0xffff; + __u32 curclust = START(retdent); + int files = 0, dirs = 0; + + FAT_DPRINT("get_dentfromdir: %s\n", filename); + for (;;) { + dir_entry *dentptr; + int i; + + if (get_cluster(mydata, curclust, get_dentfromdir_block, + mydata->clust_size * SECTOR_SIZE) != 0) { + FAT_DPRINT("Error: reading directory block\n"); + return NULL; } - FAT_DPRINT ("Dentname == NULL - %d\n", i); - return NULL; - } + dentptr = (dir_entry *) get_dentfromdir_block; + for (i = 0; i < DIRENTSPERCLUST; i++) { + char s_name[14], l_name[256]; + + l_name[0] = '\0'; + if (dentptr->name[0] == DELETED_FLAG) { + dentptr++; + continue; + } + if ((dentptr->attr & ATTR_VOLUME) && + !valid_vfat(mydata, dentptr, &prevcksum, curclust, + l_name, dols, &dirs, &files, + get_dentfromdir_block)) { + /* Ignore volume labels */ + dentptr++; + continue; + } + + if (dentptr->name[0] == 0) { + if (dols != LS_NO) + printf("\n%d file(s), %d dir(s)\n\n", + files, dirs); + + FAT_DPRINT("Dentname == NULL - %d\n", i); + return NULL; + } #ifdef CONFIG_SUPPORT_VFAT - if (dols && mkcksum (dentptr->name) == prevcksum) { - dentptr++; - continue; - } + if ((dols != LS_NO) && + (mkcksum(dentptr->name) == prevcksum)) { + dentptr++; + continue; + } #endif - get_name (dentptr, s_name); - if (dols) { - int isdir = (dentptr->attr & ATTR_DIR); - char dirc; - int doit = 0; - - if (isdir) { - dirs++; - dirc = '/'; - doit = 1; - } else { - dirc = ' '; - if (s_name[0] != 0) { - files++; - doit = 1; - } + get_name(dentptr, s_name); + if (dols != LS_NO) { + int isdir = (dentptr->attr & ATTR_DIR); + char dirc; + int doit = 0; + + if (isdir) { + dirs++; + dirc = '/'; + doit = 1; + } else { + dirc = ' '; + if (s_name[0] != 0) { + files++; + doit = 1; + } + } + if (doit) { + if (dirc == ' ') + printf(" %8ld %s%c\n", (long) + FAT2CPU32(dentptr->size), + s_name, dirc); + else + printf(" %s%c\n", + s_name, dirc); + } + dentptr++; + continue; + } + if (strcmp(filename, s_name) + && strcmp(filename, l_name)) { + FAT_DPRINT("Mismatch: |%s|%s|\n", s_name, + l_name); + dentptr++; + continue; + } + memcpy(retdent, dentptr, sizeof(dir_entry)); + + FAT_DPRINT("DentName: %s", s_name); + FAT_DPRINT(", start: 0x%x", START(dentptr)); + FAT_DPRINT(", size: 0x%x %s\n", + FAT2CPU32(dentptr->size), + (dentptr->attr & ATTR_DIR) ? "(DIR)" : ""); + + return retdent; } - if (doit) { - if (dirc == ' ') { - printf (" %8ld %s%c\n", - (long) FAT2CPU32 (dentptr->size), s_name, - dirc); - } else { - printf (" %s%c\n", s_name, dirc); - } + curclust = get_fatent(mydata, curclust); + if (CHECK_CLUST(curclust, mydata->fatsize)) { + FAT_DPRINT("curclust: 0x%x\n", curclust); + FAT_ERROR("Invalid FAT entry\n"); + return NULL; } - dentptr++; - continue; - } - if (strcmp (filename, s_name) && strcmp (filename, l_name)) { - FAT_DPRINT ("Mismatch: |%s|%s|\n", s_name, l_name); - dentptr++; - continue; - } - memcpy (retdent, dentptr, sizeof (dir_entry)); - - FAT_DPRINT ("DentName: %s", s_name); - FAT_DPRINT (", start: 0x%x", START (dentptr)); - FAT_DPRINT (", size: 0x%x %s\n", - FAT2CPU32 (dentptr->size), - (dentptr->attr & ATTR_DIR) ? "(DIR)" : ""); - - return retdent; - } - curclust = get_fatent (mydata, curclust); - if (CHECK_CLUST(curclust, mydata->fatsize)) { - FAT_DPRINT ("curclust: 0x%x\n", curclust); - FAT_ERROR ("Invalid FAT entry\n"); - return NULL; } - } - - return NULL; + return NULL; }

- /* * Read boot sector and volume info from a FAT filesystem */ -static int -read_bootsectandvi(boot_sector *bs, volume_info *volinfo, int *fatsize) +static int read_bootsectandvi(boot_sector *bs, volume_info *volinfo, + int *fatsize) { __u8 block[FS_BLOCK_SIZE]; volume_info *vistart; @@ -676,27 +677,27 @@ read_bootsectandvi(boot_sector *bs, volume_info *volinfo, int *fatsize) }

memcpy(bs, block, sizeof(boot_sector)); - bs->reserved = FAT2CPU16(bs->reserved); - bs->fat_length = FAT2CPU16(bs->fat_length); - bs->secs_track = FAT2CPU16(bs->secs_track); - bs->heads = FAT2CPU16(bs->heads); -#if 0 /* UNUSED */ - bs->hidden = FAT2CPU32(bs->hidden); + bs->reserved = FAT2CPU16(bs->reserved); + bs->fat_length = FAT2CPU16(bs->fat_length); + bs->secs_track = FAT2CPU16(bs->secs_track); + bs->heads = FAT2CPU16(bs->heads); +#if 0 /* UNUSED */ + bs->hidden = FAT2CPU32(bs->hidden); #endif - bs->total_sect = FAT2CPU32(bs->total_sect); + bs->total_sect = FAT2CPU32(bs->total_sect);

/* FAT32 entries */ if (bs->fat_length == 0) { /* Assume FAT32 */ bs->fat32_length = FAT2CPU32(bs->fat32_length); - bs->flags = FAT2CPU16(bs->flags); + bs->flags = FAT2CPU16(bs->flags); bs->root_cluster = FAT2CPU32(bs->root_cluster); - bs->info_sector = FAT2CPU16(bs->info_sector); - bs->backup_boot = FAT2CPU16(bs->backup_boot); - vistart = (volume_info*) (block + sizeof(boot_sector)); + bs->info_sector = FAT2CPU16(bs->info_sector); + bs->backup_boot = FAT2CPU16(bs->backup_boot); + vistart = (volume_info *) (block + sizeof(boot_sector)); *fatsize = 32; } else { - vistart = (volume_info*) &(bs->fat32_length); + vistart = (volume_info *)&(bs->fat32_length); *fatsize = 0; } memcpy(volinfo, vistart, sizeof(volume_info)); @@ -706,9 +707,8 @@ read_bootsectandvi(boot_sector *bs, volume_info *volinfo, int *fatsize) vistart->fs_type[8] = '\0';

if (*fatsize == 32) { - if (compare_sign(FAT32_SIGN, vistart->fs_type) == 0) { + if (compare_sign(FAT32_SIGN, vistart->fs_type) == 0) return 0; - } } else { if (compare_sign(FAT12_SIGN, vistart->fs_type) == 0) { *fatsize = 12; @@ -724,258 +724,228 @@ read_bootsectandvi(boot_sector *bs, volume_info *volinfo, int *fatsize) return -1; }

+static __u8 do_fat_read_block[MAX_CLUSTSIZE]; /* Block buffer */

-__u8 do_fat_read_block[MAX_CLUSTSIZE]; /* Block buffer */ -long -do_fat_read (const char *filename, void *buffer, unsigned long maxsize, - int dols) +long do_fat_read(const char *filename, void *buffer, + unsigned long maxsize, int dols) { -#if CONFIG_NIOS /* NIOS CPU cannot access big automatic arrays */ - static +#if CONFIG_NIOS /* NIOS CPU cannot access big automatic arrays */ + static #endif - char fnamecopy[2048]; - boot_sector bs; - volume_info volinfo; - fsdata datablock; - fsdata *mydata = &datablock; - dir_entry *dentptr; - __u16 prevcksum = 0xffff; - char *subname = ""; - int rootdir_size, cursect; - int idx, isdir = 0; - int files = 0, dirs = 0; - long ret = 0; - int firsttime; - - if (read_bootsectandvi (&bs, &volinfo, &mydata->fatsize)) { - FAT_DPRINT ("Error: reading boot sector\n"); - return -1; - } - if (mydata->fatsize == 32) { - mydata->fatlength = bs.fat32_length; - } else { - mydata->fatlength = bs.fat_length; - } - mydata->fat_sect = bs.reserved; - cursect = mydata->rootdir_sect - = mydata->fat_sect + mydata->fatlength * bs.fats; - mydata->clust_size = bs.cluster_size; - if (mydata->fatsize == 32) { - rootdir_size = mydata->clust_size; - mydata->data_begin = mydata->rootdir_sect /* + rootdir_size */ - - (mydata->clust_size * 2); - } else { - rootdir_size = ((bs.dir_entries[1] * (int) 256 + bs.dir_entries[0]) - * sizeof (dir_entry)) / SECTOR_SIZE; - mydata->data_begin = mydata->rootdir_sect + rootdir_size - - (mydata->clust_size * 2); - } - mydata->fatbufnum = -1; - - FAT_DPRINT ("FAT%d, fatlength: %d\n", mydata->fatsize, - mydata->fatlength); - FAT_DPRINT ("Rootdir begins at sector: %d, offset: %x, size: %d\n" - "Data begins at: %d\n", - mydata->rootdir_sect, mydata->rootdir_sect * SECTOR_SIZE, - rootdir_size, mydata->data_begin); - FAT_DPRINT ("Cluster size: %d\n", mydata->clust_size); - - /* "cwd" is always the root... */ - while (ISDIRDELIM (*filename)) - filename++; - /* Make a copy of the filename and convert it to lowercase */ - strcpy (fnamecopy, filename); - downcase (fnamecopy); - if (*fnamecopy == '\0') { - if (!dols) - return -1; - dols = LS_ROOT; - } else if ((idx = dirdelim (fnamecopy)) >= 0) { - isdir = 1; - fnamecopy[idx] = '\0'; - subname = fnamecopy + idx + 1; - /* Handle multiple delimiters */ - while (ISDIRDELIM (*subname)) - subname++; - } else if (dols) { - isdir = 1; - } - - while (1) { - int i; - - if (disk_read (cursect, mydata->clust_size, do_fat_read_block) < 0) { - FAT_DPRINT ("Error: reading rootdir block\n"); - return -1; + char fnamecopy[2048]; + boot_sector bs; + volume_info volinfo; + fsdata datablock; + fsdata *mydata = &datablock; + dir_entry *dentptr; + __u16 prevcksum = 0xffff; + char *subname = ""; + int rootdir_size, cursect; + int idx, isdir = 0; + int files = 0, dirs = 0; + long ret = 0; + int firsttime; + + if (read_bootsectandvi(&bs, &volinfo, &mydata->fatsize)) { + FAT_DPRINT("Error: reading boot sector\n"); + return -1; } - dentptr = (dir_entry *) do_fat_read_block; - for (i = 0; i < DIRENTSPERBLOCK; i++) { - char s_name[14], l_name[256]; - - l_name[0] = '\0'; - if ((dentptr->attr & ATTR_VOLUME)) { -#ifdef CONFIG_SUPPORT_VFAT - if ((dentptr->attr & ATTR_VFAT) && - (dentptr->name[0] & LAST_LONG_ENTRY_MASK)) { - prevcksum = ((dir_slot *) dentptr)->alias_checksum; - get_vfatname (mydata, 0, do_fat_read_block, dentptr, l_name); - if (dols == LS_ROOT) { - int isdir = (dentptr->attr & ATTR_DIR); - char dirc; - int doit = 0; - - if (isdir) { - dirs++; - dirc = '/'; - doit = 1; - } else { - dirc = ' '; - if (l_name[0] != 0) { - files++; - doit = 1; - } + if (mydata->fatsize == 32) + mydata->fatlength = bs.fat32_length; + else + mydata->fatlength = bs.fat_length; + + mydata->fat_sect = bs.reserved; + cursect = mydata->rootdir_sect = mydata->fat_sect + + (mydata->fatlength * bs.fats); + mydata->clust_size = bs.cluster_size; + if (mydata->fatsize == 32) { + rootdir_size = mydata->clust_size; + mydata->data_begin = mydata->rootdir_sect /* + rootdir_size */ + - (mydata->clust_size * 2); + } else { + rootdir_size = ((bs.dir_entries[1] * (int)256 + + bs.dir_entries[0]) * sizeof(dir_entry)) / SECTOR_SIZE; + mydata->data_begin = mydata->rootdir_sect + rootdir_size + - (mydata->clust_size * 2); + } + mydata->fatbufnum = -1; + + FAT_DPRINT("FAT%d, fatlength: %d\n", mydata->fatsize, + mydata->fatlength); + FAT_DPRINT("Rootdir begins at sector: %d, offset: %x, size: %d\n" + "Data begins at: %d\n", + mydata->rootdir_sect, mydata->rootdir_sect * SECTOR_SIZE, + rootdir_size, mydata->data_begin); + FAT_DPRINT("Cluster size: %d\n", mydata->clust_size); + + /* "cwd" is always the root... */ + while (ISDIRDELIM(*filename)) + filename++; + /* Make a copy of the filename and convert it to lowercase */ + strcpy(fnamecopy, filename); + downcase(fnamecopy); + if (*fnamecopy == '\0') { + if (dols == LS_NO) + return -1; + dols = LS_ROOT; + } else if ((idx = dirdelim(fnamecopy)) >= 0) { + isdir = 1; + fnamecopy[idx] = '\0'; + subname = fnamecopy + idx + 1; + /* Handle multiple delimiters */ + while (ISDIRDELIM(*subname)) + subname++; + } else if (dols != LS_NO) + isdir = 1; + + for (;;) { + int i; + + if (disk_read(cursect, 1, do_fat_read_block) < 0) { + FAT_DPRINT("Error: reading rootdir block\n"); + return -1; + } + dentptr = (dir_entry *) do_fat_read_block; + for (i = 0; i < DIRENTSPERBLOCK; i++) { + char s_name[14], l_name[256]; + + l_name[0] = '\0'; + if (dentptr->name[0] == DELETED_FLAG) { + /* Ignore deleted entries */ + dentptr++; + continue; } - if (doit) { - if (dirc == ' ') { - printf (" %8ld %s%c\n", - (long) FAT2CPU32 (dentptr->size), - l_name, dirc); - } else { - printf (" %s%c\n", l_name, dirc); - } + if ((dentptr->attr & ATTR_VOLUME) && + !valid_vfat(mydata, dentptr, &prevcksum, 0, l_name, + dols, &dirs, &files, + do_fat_read_block)) { + /* Ignore volume labels */ + dentptr++; + continue; + } + if (dentptr->name[0] == 0) { + FAT_DPRINT("RootDentname == NULL - %d\n", i); + if (dols == LS_ROOT) { + printf("\n%d file(s), %d dir(s)\n\n", + files, dirs); + return 0; + } + return -1; } - dentptr++; - continue; - } - FAT_DPRINT ("Rootvfatname: |%s|\n", l_name); - } else -#endif - { - /* Volume label or VFAT entry */ - dentptr++; - continue; - } - } else if (dentptr->name[0] == 0) { - FAT_DPRINT ("RootDentname == NULL - %d\n", i); - if (dols == LS_ROOT) { - printf ("\n%d file(s), %d dir(s)\n\n", files, dirs); - return 0; - } - return -1; - } #ifdef CONFIG_SUPPORT_VFAT - else if (dols == LS_ROOT - && mkcksum (dentptr->name) == prevcksum) { - dentptr++; - continue; - } + if (dols == LS_ROOT && + mkcksum(dentptr->name) == prevcksum) { + dentptr++; + continue; + } #endif - get_name (dentptr, s_name); - if (dols == LS_ROOT) { - int isdir = (dentptr->attr & ATTR_DIR); - char dirc; - int doit = 0; - - if (isdir) { - dirc = '/'; - if (s_name[0] != 0) { - dirs++; - doit = 1; - } - } else { - dirc = ' '; - if (s_name[0] != 0) { - files++; - doit = 1; - } - } - if (doit) { - if (dirc == ' ') { - printf (" %8ld %s%c\n", - (long) FAT2CPU32 (dentptr->size), s_name, - dirc); - } else { - printf (" %s%c\n", s_name, dirc); - } - } - dentptr++; - continue; - } - if (strcmp (fnamecopy, s_name) && strcmp (fnamecopy, l_name)) { - FAT_DPRINT ("RootMismatch: |%s|%s|\n", s_name, l_name); - dentptr++; - continue; - } - if (isdir && !(dentptr->attr & ATTR_DIR)) - return -1; + get_name(dentptr, s_name); + if (dols == LS_ROOT) { + int isdir = (dentptr->attr & ATTR_DIR); + char dirc; + int doit = 0; + + if (isdir) { + dirc = '/'; + if (s_name[0] != 0) { + dirs++; + doit = 1; + } + } else { + dirc = ' '; + if (s_name[0] != 0) { + files++; + doit = 1; + } + } + if (doit) { + if (dirc == ' ') + printf(" %8ld %s%c\n", (long) + FAT2CPU32(dentptr->size), + s_name, dirc); + else + printf(" %s%c\n", + s_name, dirc); + } + dentptr++; + continue; + } + if (strcmp(fnamecopy, s_name) + && strcmp(fnamecopy, l_name)) { + FAT_DPRINT("RootMismatch: |%s|%s|\n", s_name, + l_name); + dentptr++; + continue; + } + if (isdir && !(dentptr->attr & ATTR_DIR)) + return -1;

- FAT_DPRINT ("RootName: %s", s_name); - FAT_DPRINT (", start: 0x%x", START (dentptr)); - FAT_DPRINT (", size: 0x%x %s\n", - FAT2CPU32 (dentptr->size), isdir ? "(DIR)" : ""); + FAT_DPRINT("RootName: %s", s_name); + FAT_DPRINT(", start: 0x%x", START(dentptr)); + FAT_DPRINT(", size: 0x%x %s\n", + FAT2CPU32(dentptr->size), + isdir ? "(DIR)" : "");

- goto rootdir_done; /* We got a match */ - } - cursect++; - } - rootdir_done: - - firsttime = 1; - while (isdir) { - int startsect = mydata->data_begin - + START (dentptr) * mydata->clust_size; - dir_entry dent; - char *nextname = NULL; - - dent = *dentptr; - dentptr = &dent; - - idx = dirdelim (subname); - if (idx >= 0) { - subname[idx] = '\0'; - nextname = subname + idx + 1; - /* Handle multiple delimiters */ - while (ISDIRDELIM (*nextname)) - nextname++; - if (dols && *nextname == '\0') - firsttime = 0; - } else { - if (dols && firsttime) { - firsttime = 0; - } else { - isdir = 0; - } - } + goto rootdir_done; /* We got a match */ + } + cursect++; + } +rootdir_done: + + firsttime = 1; + while (isdir) { + int startsect = mydata->data_begin + + START(dentptr) * mydata->clust_size; + dir_entry dent; + char *nextname = NULL; + + dent = *dentptr; + dentptr = &dent; + + idx = dirdelim(subname); + if (idx >= 0) { + subname[idx] = '\0'; + nextname = subname + idx + 1; + /* Handle multiple delimiters */ + while (ISDIRDELIM(*nextname)) + nextname++; + if (dols != LS_NO && *nextname == '\0') + firsttime = 0; + } else { + if (dols != LS_NO && firsttime) + firsttime = 0; + else + isdir = 0; + }

- if (get_dentfromdir (mydata, startsect, subname, dentptr, - isdir ? 0 : dols) == NULL) { - if (dols && !isdir) - return 0; - return -1; - } + if (get_dentfromdir(mydata, startsect, subname, dentptr, + isdir ? 0 : dols) == NULL) { + if (dols != LS_NO && !isdir) + return 0; + return -1; + }

- if (idx >= 0) { - if (!(dentptr->attr & ATTR_DIR)) - return -1; - subname = nextname; + if (idx >= 0) { + if (!(dentptr->attr & ATTR_DIR)) + return -1; + subname = nextname; + } } - } - ret = get_contents (mydata, dentptr, buffer, maxsize); - FAT_DPRINT ("Size: %d, got: %ld\n", FAT2CPU32 (dentptr->size), ret); + ret = get_contents(mydata, dentptr, buffer, maxsize); + FAT_DPRINT("Size: %d, got: %ld\n", FAT2CPU32(dentptr->size), ret);

- return ret; + return ret; }

- -int -file_fat_detectfs(void) +int file_fat_detectfs(void) { - boot_sector bs; - volume_info volinfo; - int fatsize; - char vol_label[12]; + boot_sector bs; + volume_info volinfo; + int fatsize; + char vol_label[12];

- if(cur_dev==NULL) { + if (cur_dev == NULL) { printf("No current device\n"); return 1; } @@ -984,41 +954,37 @@ file_fat_detectfs(void) defined(CONFIG_CMD_USB) || \ defined(CONFIG_MMC) printf("Interface: "); - switch(cur_dev->if_type) { + switch (cur_dev->if_type) { case IF_TYPE_IDE : printf("IDE"); break; case IF_TYPE_SCSI : printf("SCSI"); break; case IF_TYPE_ATAPI : printf("ATAPI"); break; case IF_TYPE_USB : printf("USB"); break; case IF_TYPE_DOC : printf("DOC"); break; case IF_TYPE_MMC : printf("MMC"); break; - default : printf("Unknown"); + default : printf("Unknown"); break; } - printf("\n Device %d: ",cur_dev->dev); + printf("\n Device %d: ", cur_dev->dev); dev_print(cur_dev); #endif - if(read_bootsectandvi(&bs, &volinfo, &fatsize)) { + if (read_bootsectandvi(&bs, &volinfo, &fatsize)) { printf("\nNo valid FAT fs found\n"); return 1; } - memcpy (vol_label, volinfo.volume_label, 11); + memcpy(vol_label, volinfo.volume_label, 11); vol_label[11] = '\0'; - volinfo.fs_type[5]='\0'; - printf("Partition %d: Filesystem: %s "%s"\n" - ,cur_part,volinfo.fs_type,vol_label); + volinfo.fs_type[5] = '\0'; + printf("Partition %d: Filesystem: %s "%s"\n", cur_part, + volinfo.fs_type, vol_label); return 0; }

- -int -file_fat_ls(const char *dir) +int file_fat_ls(const char *dir) { return do_fat_read(dir, NULL, 0, LS_YES); }

- -long -file_fat_read(const char *filename, void *buffer, unsigned long maxsize) +long file_fat_read(const char *filename, void *buffer, unsigned long maxsize) { - printf("reading %s\n",filename); + printf("reading %s\n", filename); return do_fat_read(filename, buffer, maxsize, LS_NO); } diff --git a/fs/fat/file.c b/fs/fat/file.c index e870734..e300ff7 100644 --- a/fs/fat/file.c +++ b/fs/fat/file.c @@ -34,8 +34,9 @@

/* Supported filesystems */ static const struct filesystem filesystems[] = { - { file_fat_detectfs, file_fat_ls, file_fat_read, "FAT" }, + {file_fat_detectfs, file_fat_ls, file_fat_read, "FAT"}, }; + #define NUM_FILESYS (sizeof(filesystems)/sizeof(struct filesystem))

/* The filesystem which was last detected */ @@ -43,56 +44,54 @@ static int current_filesystem = FSTYPE_NONE;

/* The current working directory */ #define CWD_LEN 511 -char file_cwd[CWD_LEN+1] = "/"; +char file_cwd[CWD_LEN + 1] = "/";

-const char * -file_getfsname(int idx) +const char *file_getfsname(int idx) { - if (idx < 0 || idx >= NUM_FILESYS) return NULL; + if (idx < 0 || idx >= NUM_FILESYS) + return NULL;

return filesystems[idx].name; }

- -static void -pathcpy(char *dest, const char *src) +static void pathcpy(char *dest, const char *src) { char *origdest = dest;

- do { - if (dest-file_cwd >= CWD_LEN) { + for (;;) { + if (dest - file_cwd >= CWD_LEN) { *dest = '\0'; return; } *(dest) = *(src); if (*src == '\0') { - if (dest-- != origdest && ISDIRDELIM(*dest)) { + if (dest-- != origdest && ISDIRDELIM(*dest)) *dest = '\0'; - } + return; } ++dest; - if (ISDIRDELIM(*src)) { - while (ISDIRDELIM(*src)) src++; - } else { + if (ISDIRDELIM(*src)) + while (ISDIRDELIM(*src)) + src++; + else src++; - } - } while (1); + } }

- -int -file_cd(const char *path) +int file_cd(const char *path) { if (ISDIRDELIM(*path)) { - while (ISDIRDELIM(*path)) path++; - strncpy(file_cwd+1, path, CWD_LEN-1); + while (ISDIRDELIM(*path)) + path++; + strncpy(file_cwd + 1, path, CWD_LEN - 1); } else { const char *origpath = path; char *tmpstr = file_cwd; int back = 0;

- while (*tmpstr != '\0') tmpstr++; + while (*tmpstr != '\0') + tmpstr++; do { tmpstr--; } while (ISDIRDELIM(*tmpstr)); @@ -108,7 +107,8 @@ file_cd(const char *path) back = 0; break; } - while (ISDIRDELIM(*path)) path++; + while (ISDIRDELIM(*path)) + path++; origpath = path; }

@@ -123,7 +123,8 @@ file_cd(const char *path) break; } /* Skip delimiters */ - while (ISDIRDELIM(*tmpstr)) tmpstr--; + while (ISDIRDELIM(*tmpstr)) + tmpstr--; } tmpstr++; if (*path == '\0') { @@ -135,15 +136,13 @@ file_cd(const char *path) return 0; } *tmpstr = '/'; - pathcpy(tmpstr+1, path); + pathcpy(tmpstr + 1, path); }

return 0; }

- -int -file_detectfs(void) +int file_detectfs(void) { int i;

@@ -160,9 +159,7 @@ file_detectfs(void) return current_filesystem; }

- -int -file_ls(const char *dir) +int file_ls(const char *dir) { char fullpath[1024]; const char *arg; @@ -181,9 +178,7 @@ file_ls(const char *dir) return filesystems[current_filesystem].ls(arg); }

- -long -file_read(const char *filename, void *buffer, unsigned long maxsize) +long file_read(const char *filename, void *buffer, unsigned long maxsize) { char fullpath[1024]; const char *arg; diff --git a/include/fat.h b/include/fat.h index c8b9493..be7023a 100644 --- a/include/fat.h +++ b/include/fat.h @@ -49,7 +49,6 @@ #define FAT16BUFSIZE (FATBUFSIZE/2) #define FAT32BUFSIZE (FATBUFSIZE/4)

- /* Filesystem identifiers */ #define FAT12_SIGN "FAT12 " #define FAT16_SIGN "FAT16 " @@ -140,8 +139,7 @@ typedef struct boot_sector { __u16 reserved2[6]; /* Unused */ } boot_sector;

-typedef struct volume_info -{ +typedef struct volume_info { __u8 drive_number; /* BIOS drive number */ __u8 reserved; /* Unused */ __u8 ext_boot_sign; /* 0x29 if fields below exist (DOS 3.3+) */ @@ -188,7 +186,8 @@ typedef struct { __u16 fat_sect; /* Starting sector of the FAT */ __u16 rootdir_sect; /* Start sector of root directory */ __u16 clust_size; /* Size of clusters in sectors */ - short data_begin; /* The sector of the first cluster, can be negative */ + short data_begin; /* The sector of the first cluster, + * can be negative */ int fatbufnum; /* Used by get_fatent, init to -1 */ } fsdata;