The device type was left uninitialized which caused later tests against DEV_TYPE_UNKNOWN to fail. In the result, "usb part" would attempt to print information about non-existent devices like this:

=> usb part print_part of 0

Partition Map for USB device 0 -- Partition Type: DOS

Partition Start Sector Num Sectors Type 1 0 2031616 f8

print_part of 1 ## Unknown partition table

print_part of 2 ## Unknown partition table

print_part of 3 ## Unknown partition table

print_part of 4 ## Unknown partition table =>

By initializing the type as DEV_TYPE_UNKNOWN we avoid all the "Unknown partition table" messages.

[Note: the "print_part of ?" messages is left over debug code that will be removed in another patch.]

Signed-off-by: Wolfgang Denk wd@denx.de Cc: Remy Bohmer linux@bohmer.net

--- common/usb_storage.c | 3 ++- 1 files changed, 2 insertions(+), 1 deletions(-)

diff --git a/common/usb_storage.c b/common/usb_storage.c index 4fc01a2..9f31265 100644 --- a/common/usb_storage.c +++ b/common/usb_storage.c @@ -224,10 +224,11 @@ int usb_stor_scan(int mode)

for (i = 0; i < USB_MAX_STOR_DEV; i++) { memset(&usb_dev_desc[i], 0, sizeof(block_dev_desc_t)); - usb_dev_desc[i].target = 0xff; usb_dev_desc[i].if_type = IF_TYPE_USB; usb_dev_desc[i].dev = i; usb_dev_desc[i].part_type = PART_TYPE_UNKNOWN; + usb_dev_desc[i].target = 0xff; + usb_dev_desc[i].type = DEV_TYPE_UNKNOWN; usb_dev_desc[i].block_read = usb_stor_read; usb_dev_desc[i].block_write = usb_stor_write; }

- reformat - throw out macros like FAT_DPRINT and FAT_DPRINT - remove dead code

Signed-off-by: Wolfgang Denk wd@denx.de --- common/cmd_fat.c | 210 ++-------- fs/fat/fat.c | 1167 +++++++++++++++++++++++++++++------------------------- fs/fat/file.c | 14 +- include/fat.h | 63 ++-- 4 files changed, 698 insertions(+), 756 deletions(-)

diff --git a/common/cmd_fat.c b/common/cmd_fat.c index ede7308..0220494 100644 --- a/common/cmd_fat.c +++ b/common/cmd_fat.c @@ -45,39 +45,43 @@ int do_fat_fsload (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) char *ep;

if (argc < 5) { - printf ("usage: fatload <interface> <dev[:part]> <addr> <filename> [bytes]\n"); + printf( "usage: fatload <interface> <dev[:part]> " + "<addr> <filename> [bytes]\n"); return 1; } - dev = (int)simple_strtoul (argv[2], &ep, 16); - dev_desc=get_dev(argv[1],dev); - if (dev_desc==NULL) { - puts ("\n** Invalid boot device **\n"); + + dev = (int)simple_strtoul(argv[2], &ep, 16); + dev_desc = get_dev(argv[1],dev); + if (dev_desc == NULL) { + puts("\n** Invalid boot device **\n"); return 1; } if (*ep) { if (*ep != ':') { - puts ("\n** Invalid boot device, use `dev[:part]' **\n"); + puts("\n** Invalid boot device, use `dev[:part]' **\n"); return 1; } part = (int)simple_strtoul(++ep, NULL, 16); } if (fat_register_device(dev_desc,part)!=0) { - printf ("\n** Unable to use %s %d:%d for fatload **\n",argv[1],dev,part); + printf("\n** Unable to use %s %d:%d for fatload **\n", + argv[1], dev, part); return 1; } - offset = simple_strtoul (argv[3], NULL, 16); + offset = simple_strtoul(argv[3], NULL, 16); if (argc == 6) - count = simple_strtoul (argv[5], NULL, 16); + count = simple_strtoul(argv[5], NULL, 16); else count = 0; - size = file_fat_read (argv[4], (unsigned char *) offset, count); + size = file_fat_read(argv[4], (unsigned char *)offset, count);

if(size==-1) { - printf("\n** Unable to read "%s" from %s %d:%d **\n",argv[4],argv[1],dev,part); + printf("\n** Unable to read "%s" from %s %d:%d **\n", + argv[4], argv[1], dev, part); return 1; }

- printf ("\n%ld bytes read\n", size); + printf("\n%ld bytes read\n", size);

sprintf(buf, "%lX", size); setenv("filesize", buf); @@ -104,34 +108,35 @@ int do_fat_ls (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) block_dev_desc_t *dev_desc=NULL;

if (argc < 3) { - printf ("usage: fatls <interface> <dev[:part]> [directory]\n"); - return (0); + printf("usage: fatls <interface> <dev[:part]> [directory]\n"); + return 0; } - dev = (int)simple_strtoul (argv[2], &ep, 16); - dev_desc=get_dev(argv[1],dev); - if (dev_desc==NULL) { - puts ("\n** Invalid boot device **\n"); + dev = (int)simple_strtoul(argv[2], &ep, 16); + dev_desc = get_dev(argv[1],dev); + if (dev_desc == NULL) { + puts("\n** Invalid boot device **\n"); return 1; } if (*ep) { if (*ep != ':') { - puts ("\n** Invalid boot device, use `dev[:part]' **\n"); + puts("\n** Invalid boot device, use `dev[:part]' **\n"); return 1; } part = (int)simple_strtoul(++ep, NULL, 16); } if (fat_register_device(dev_desc,part)!=0) { - printf ("\n** Unable to use %s %d:%d for fatls **\n",argv[1],dev,part); + printf("\n** Unable to use %s %d:%d for fatls **\n", + argv[1], dev, part); return 1; } if (argc == 4) - ret = file_fat_ls (argv[3]); + ret = file_fat_ls(argv[3]); else - ret = file_fat_ls (filename); + ret = file_fat_ls(filename);

if(ret!=0) printf("No Fat FS detected\n"); - return (ret); + return ret; }

U_BOOT_CMD( @@ -149,27 +154,28 @@ int do_fat_fsinfo (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) block_dev_desc_t *dev_desc=NULL;

if (argc < 2) { - printf ("usage: fatinfo <interface> <dev[:part]>\n"); - return (0); + printf("usage: fatinfo <interface> <dev[:part]>\n"); + return 0; } - dev = (int)simple_strtoul (argv[2], &ep, 16); - dev_desc=get_dev(argv[1],dev); - if (dev_desc==NULL) { - puts ("\n** Invalid boot device **\n"); + dev = (int)simple_strtoul(argv[2], &ep, 16); + dev_desc = get_dev(argv[1],dev); + if (dev_desc == NULL) { + puts("\n** Invalid boot device **\n"); return 1; } if (*ep) { if (*ep != ':') { - puts ("\n** Invalid boot device, use `dev[:part]' **\n"); + puts("\n** Invalid boot device, use `dev[:part]' **\n"); return 1; } part = (int)simple_strtoul(++ep, NULL, 16); } if (fat_register_device(dev_desc,part)!=0) { - printf ("\n** Unable to use %s %d:%d for fatinfo **\n",argv[1],dev,part); + printf("\n** Unable to use %s %d:%d for fatinfo **\n", + argv[1], dev, part); return 1; } - return (file_fat_detectfs ()); + return file_fat_detectfs(); }

U_BOOT_CMD( @@ -178,143 +184,3 @@ U_BOOT_CMD( "<interface> <dev[:part]>\n" " - print information about filesystem from 'dev' on 'interface'" ); - -#ifdef NOT_IMPLEMENTED_YET -/* find first device whose first partition is a DOS filesystem */ -int find_fat_partition (void) -{ - int i, j; - block_dev_desc_t *dev_desc; - unsigned char *part_table; - unsigned char buffer[ATA_BLOCKSIZE]; - - for (i = 0; i < CONFIG_SYS_IDE_MAXDEVICE; i++) { - dev_desc = ide_get_dev (i); - if (!dev_desc) { - debug ("couldn't get ide device!\n"); - return (-1); - } - if (dev_desc->part_type == PART_TYPE_DOS) { - if (dev_desc-> - block_read (dev_desc->dev, 0, 1, (ulong *) buffer) != 1) { - debug ("can't perform block_read!\n"); - return (-1); - } - part_table = &buffer[0x1be]; /* start with partition #4 */ - for (j = 0; j < 4; j++) { - if ((part_table[4] == 1 || /* 12-bit FAT */ - part_table[4] == 4 || /* 16-bit FAT */ - part_table[4] == 6) && /* > 32Meg part */ - part_table[0] == 0x80) { /* bootable? */ - curr_dev = i; - part_offset = part_table[11]; - part_offset <<= 8; - part_offset |= part_table[10]; - part_offset <<= 8; - part_offset |= part_table[9]; - part_offset <<= 8; - part_offset |= part_table[8]; - debug ("found partition start at %ld\n", part_offset); - return (0); - } - part_table += 16; - } - } - } - - debug ("no valid devices found!\n"); - return (-1); -} - -int -do_fat_dump (cmd_tbl_t *cmdtp, bd_t *bd, int flag, int argc, char * const argv[]) -{ - __u8 block[1024]; - int ret; - int bknum; - - ret = 0; - - if (argc != 2) { - printf ("needs an argument!\n"); - return (0); - } - - bknum = simple_strtoul (argv[1], NULL, 10); - - if (disk_read (0, bknum, block) != 0) { - printf ("Error: reading block\n"); - return -1; - } - printf ("FAT dump: %d\n", bknum); - hexdump (512, block); - - return (ret); -} - -int disk_read (__u32 startblock, __u32 getsize, __u8 *bufptr) -{ - ulong tot; - block_dev_desc_t *dev_desc; - - if (curr_dev < 0) { - if (find_fat_partition () != 0) - return (-1); - } - - dev_desc = ide_get_dev (curr_dev); - if (!dev_desc) { - debug ("couldn't get ide device\n"); - return (-1); - } - - tot = dev_desc->block_read (0, startblock + part_offset, - getsize, (ulong *) bufptr); - - /* should we do this here? - flush_cache ((ulong)buf, cnt*ide_dev_desc[device].blksz); - */ - - if (tot == getsize) - return (0); - - debug ("unable to read from device!\n"); - - return (-1); -} - - -static int isprint (unsigned char ch) -{ - if (ch >= 32 && ch < 127) - return (1); - - return (0); -} - - -void hexdump (int cnt, unsigned char *data) -{ - int i; - int run; - int offset; - - offset = 0; - while (cnt) { - printf ("%04X : ", offset); - if (cnt >= 16) - run = 16; - else - run = cnt; - cnt -= run; - for (i = 0; i < run; i++) - printf ("%02X ", (unsigned int) data[i]); - printf (": "); - for (i = 0; i < run; i++) - printf ("%c", isprint (data[i]) ? data[i] : '.'); - printf ("\n"); - data = &data[16]; - offset += run; - } -} -#endif /* NOT_IMPLEMENTED_YET */ diff --git a/fs/fat/fat.c b/fs/fat/fat.c index 413c687..b96cdd7 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,8 +42,10 @@ 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;

#define DOS_PART_TBL_OFFSET 0x1be @@ -52,35 +53,38 @@ static int cur_part = 1; #define DOS_FS_TYPE_OFFSET 0x36 #define DOS_FS32_TYPE_OFFSET 0x52

-int disk_read (__u32 startblock, __u32 getsize, __u8 * bufptr) +static int disk_read (__u32 startblock, __u32 getsize, __u8 * bufptr) { - startblock += part_offset; if (cur_dev == NULL) return -1; + + startblock += part_offset; + if (cur_dev->block_read) { - return cur_dev->block_read (cur_dev->dev - , startblock, getsize, (unsigned long *)bufptr); + return cur_dev->block_read(cur_dev->dev, startblock, getsize, + (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;

if (!dev_desc->block_read) 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; } @@ -91,23 +95,23 @@ fat_register_device(block_dev_desc_t *dev_desc, int part_no) 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)) { + /* First we assume there is a MBR */ + 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)==0 || - strncmp((char *)&buffer[DOS_FS32_TYPE_OFFSET],"FAT32",5)==0) { + } else if ((strncmp((char *)&buffer[DOS_FS_TYPE_OFFSET], "FAT", 3) == 0) || + (strncmp((char *)&buffer[DOS_FS32_TYPE_OFFSET], "FAT32", 5) == 0)) { /* ok, we assume we are on a PBR only */ 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; @@ -125,18 +129,17 @@ 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; @@ -149,7 +152,7 @@ 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 != ' ') @@ -157,7 +160,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++; @@ -167,19 +170,19 @@ 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 off16, offset; __u32 ret = 0x00; + __u16 val1, val2;

switch (mydata->fatsize) { case 32: @@ -200,12 +203,12 @@ get_fatent(fsdata *mydata, __u32 entry) return ret; }

- FAT_DPRINT("FAT%d: entry: 0x%04x = %d, offset: 0x%04x = %d\n", - mydata->fatsize, entry, entry, offset, offset); + debug("FAT%d: entry: 0x%04x = %d, offset: 0x%04x = %d\n", + mydata->fatsize, entry, entry, offset, offset);

/* Read a new block of FAT entries into the cache. */ if (bufnum != mydata->fatbufnum) { - int getsize = FATBUFSIZE/FS_BLOCK_SIZE; + int getsize = FATBUFSIZE / FS_BLOCK_SIZE; __u8 *bufptr = mydata->fatbuf; __u32 fatlength = mydata->fatlength; __u32 startblock = bufnum * FATBUFBLOCKS; @@ -213,9 +216,10 @@ 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 (getsize > fatlength) + getsize = fatlength; if (disk_read(startblock, getsize, bufptr) < 0) { - FAT_DPRINT("Error reading FAT blocks\n"); + debug("Error reading FAT blocks\n"); return ret; } mydata->fatbufnum = bufnum; @@ -224,80 +228,81 @@ 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("FAT%d: ret: %08x, offset: %04x\n", - mydata->fatsize, ret, offset); + debug("FAT%d: ret: %08x, offset: %04x\n", + mydata->fatsize, 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) +get_cluster (fsdata *mydata, __u32 clustnum, __u8 *buffer, + unsigned long size) { int idx = 0; __u32 startsect;

if (clustnum > 0) { - startsect = mydata->data_begin + clustnum*mydata->clust_size; + 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) { - FAT_DPRINT("Error reading data\n"); + debug("gc - clustnum: %d, startsect: %d\n", clustnum, startsect); + + if (disk_read(startsect, size / FS_BLOCK_SIZE, buffer) < 0) { + debug("Error reading data\n"); return -1; } - if(size % FS_BLOCK_SIZE) { + if (size % FS_BLOCK_SIZE) { __u8 tmpbuf[FS_BLOCK_SIZE]; - idx= size/FS_BLOCK_SIZE; + + idx = size / FS_BLOCK_SIZE; if (disk_read(startsect + idx, 1, tmpbuf) < 0) { - FAT_DPRINT("Error reading data\n"); + debug("Error reading data\n"); return -1; } - buffer += idx*FS_BLOCK_SIZE; + buffer += idx * FS_BLOCK_SIZE;

memcpy(buffer, tmpbuf, size % FS_BLOCK_SIZE); return 0; @@ -306,15 +311,14 @@ get_cluster(fsdata *mydata, __u32 clustnum, __u8 *buffer, unsigned long size) 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) +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; @@ -322,161 +326,174 @@ get_contents(fsdata *mydata, dir_entry *dentptr, __u8 *buffer, __u32 endclust, newclust; unsigned long actsize;

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

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

- FAT_DPRINT("%ld bytes\n", filesize); + debug("%ld bytes\n", filesize); + + actsize = bytesperclust; + endclust = curclust;

- actsize=bytesperclust; - endclust=curclust; do { /* search for consecutive clusters */ - while(actsize < filesize) { + while (actsize < filesize) { newclust = get_fatent(mydata, endclust); - if((newclust -1)!=endclust) + if ((newclust - 1) != endclust) goto getit; if (CHECK_CLUST(newclust, mydata->fatsize)) { - FAT_DPRINT("curclust: 0x%x\n", newclust); - FAT_DPRINT("Invalid FAT entry\n"); + debug("curclust: 0x%x\n", newclust); + debug("Invalid FAT entry\n"); return gotsize; } - endclust=newclust; - actsize+= bytesperclust; + endclust = newclust; + actsize += bytesperclust; } + /* actsize >= file size */ actsize -= bytesperclust; + /* get remaining clusters */ if (get_cluster(mydata, curclust, buffer, (int)actsize) != 0) { - FAT_ERROR("Error reading cluster\n"); + printf("Error reading cluster\n"); return -1; } + /* get remaining bytes */ 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"); + printf("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"); + printf("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"); + debug("curclust: 0x%x\n", curclust); + printf("Invalid FAT entry\n"); return gotsize; } - actsize=bytesperclust; - endclust=curclust; + 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. */ -__attribute__ ((__aligned__(__alignof__(dir_entry)))) +__attribute__ ((__aligned__ (__alignof__ (dir_entry)))) __u8 get_vfatname_block[MAX_CLUSTSIZE]; + static int -get_vfatname(fsdata *mydata, int curclust, __u8 *cluster, - dir_entry *retdent, char *l_name) +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--; curclust = get_fatent(mydata, curclust); if (CHECK_CLUST(curclust, mydata->fatsize)) { - FAT_DPRINT("curclust: 0x%x\n", curclust); - FAT_ERROR("Invalid FAT entry\n"); + debug("curclust: 0x%x\n", curclust); + printf("Invalid FAT entry\n"); return -1; } + if (get_cluster(mydata, curclust, get_vfatname_block, mydata->clust_size * SECTOR_SIZE) != 0) { - FAT_DPRINT("Error: reading directory block\n"); + debug("Error: reading directory block\n"); return -1; } - slotptr2 = (dir_slot*) get_vfatname_block; - while (slotptr2->id > 0x01) { + + 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 */ @@ -485,214 +502,226 @@ 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]; + ret = (((ret & 1) << 7) | ((ret & 0xfe) >> 1)) + str[i]; }

return ret; } -#endif - +#endif /* CONFIG_SUPPORT_VFAT */

/* * Get the directory entry associated with 'filename' from the directory * starting at 'startsect' */ -__attribute__ ((__aligned__(__alignof__(dir_entry)))) +__attribute__ ((__aligned__ (__alignof__ (dir_entry)))) __u8 get_dentfromdir_block[MAX_CLUSTSIZE]; -static dir_entry *get_dentfromdir (fsdata * mydata, int startsect, - char *filename, dir_entry * retdent, + +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; + __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; + debug("get_dentfromdir: %s\n", filename);

- 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)) { + while (1) { + dir_entry *dentptr; + + int i; + + if (get_cluster(mydata, curclust, get_dentfromdir_block, + mydata->clust_size * SECTOR_SIZE) != 0) { + debug("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) { - 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 ((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) { + int isdir; + char dirc; + int doit = 0; + + isdir = (dentptr->attr & ATTR_DIR); + + if (isdir) { + 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); + } + } + dentptr++; + continue; + } + debug("vfatname: |%s|\n", l_name); + } else +#endif + { + /* Volume label or VFAT entry */ + 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->name[0] == 0) { + if (dols) { + printf("\n%d file(s), %d dir(s)\n\n", + files, dirs); + } + debug("Dentname == NULL - %d\n", i); + return NULL; } - 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 ("Dentname == NULL - %d\n", i); - return NULL; - } #ifdef CONFIG_SUPPORT_VFAT - if (dols && mkcksum (dentptr->name) == prevcksum) { - dentptr++; - continue; - } + if (dols && 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) { + 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)) { + debug("Mismatch: |%s|%s|\n", s_name, l_name); + dentptr++; + continue; + } + + memcpy(retdent, dentptr, sizeof(dir_entry)); + + debug("DentName: %s", s_name); + debug(", start: 0x%x", START(dentptr)); + debug(", 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)) { + debug("curclust: 0x%x\n", curclust); + printf("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) +read_bootsectandvi (boot_sector *bs, volume_info *volinfo, int *fatsize) { __u8 block[FS_BLOCK_SIZE]; + volume_info *vistart;

- if (disk_read(0, 1, block) < 0) { - FAT_DPRINT("Error: reading block\n"); + if (disk_read (0, 1, block) < 0) { + debug("Error: reading block\n"); return -1; }

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); -#endif - bs->total_sect = FAT2CPU32(bs->total_sect); + bs->reserved = FAT2CPU16(bs->reserved); + bs->fat_length = FAT2CPU16(bs->fat_length); + bs->secs_track = FAT2CPU16(bs->secs_track); + bs->heads = FAT2CPU16(bs->heads); + 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));

if (*fatsize == 32) { - if (strncmp(FAT32_SIGN, vistart->fs_type, SIGNLEN) == 0) { + if (strncmp(FAT32_SIGN, vistart->fs_type, SIGNLEN) == 0) return 0; - } } else { if (strncmp(FAT12_SIGN, vistart->fs_type, SIGNLEN) == 0) { *fatsize = 12; @@ -704,298 +733,338 @@ read_bootsectandvi(boot_sector *bs, volume_info *volinfo, int *fatsize) } }

- FAT_DPRINT("Error: broken fs_type sign\n"); + debug("Error: broken fs_type sign\n"); return -1; }

-__attribute__ ((__aligned__(__alignof__(dir_entry)))) +__attribute__ ((__aligned__ (__alignof__ (dir_entry)))) __u8 do_fat_read_block[MAX_CLUSTSIZE]; + long do_fat_read (const char *filename, void *buffer, unsigned long maxsize, int dols) { - char fnamecopy[2048]; - boot_sector bs; - volume_info volinfo; - fsdata datablock; - fsdata *mydata = &datablock; - dir_entry *dentptr; - __u16 prevcksum = 0xffff; - char *subname = ""; - int cursect; - int idx, isdir = 0; - int files = 0, dirs = 0; - long ret = 0; - int firsttime; - int root_cluster; - int j; - - if (read_bootsectandvi (&bs, &volinfo, &mydata->fatsize)) { - FAT_DPRINT ("Error: reading boot sector\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 cursect; + int idx, isdir = 0; + int files = 0, dirs = 0; + long ret = 0; + int firsttime; + int root_cluster; + int j; + + if (read_bootsectandvi(&bs, &volinfo, &mydata->fatsize)) { + debug("Error: reading boot sector\n"); + return -1; + } + root_cluster = bs.root_cluster; - 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) { - mydata->data_begin = mydata->rootdir_sect - - (mydata->clust_size * 2); - } else { - int rootdir_size; - - 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; + + 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) { + mydata->data_begin = mydata->rootdir_sect - + (mydata->clust_size * 2); + } else { + int rootdir_size; + + 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;

#ifdef CONFIG_SUPPORT_VFAT - FAT_DPRINT ("VFAT Support enabled\n"); + debug("VFAT Support enabled\n"); #endif - FAT_DPRINT ("FAT%d, fat_sect: %d, fatlength: %d\n", - mydata->fatsize, - mydata->fat_sect, - mydata->fatlength); - FAT_DPRINT ("Rootdir begins at cluster: %d, sector: %d, offset: %x\n" - "Data begins at: %d\n", - root_cluster, - mydata->rootdir_sect, - mydata->rootdir_sect * SECTOR_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; - } - - j=0; - while (1) { - int i; + debug("FAT%d, fat_sect: %d, fatlength: %d\n", + mydata->fatsize, mydata->fat_sect, mydata->fatlength); + debug("Rootdir begins at cluster: %d, sector: %d, offset: %x\n" + "Data begins at: %d\n", + root_cluster, + mydata->rootdir_sect, + mydata->rootdir_sect * SECTOR_SIZE, mydata->data_begin); + debug("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;

- FAT_DPRINT ("FAT read sect=%d, clust_size=%d, DIRENTSPERBLOCK=%d\n", - cursect, mydata->clust_size, DIRENTSPERBLOCK); - if (disk_read (cursect, mydata->clust_size, do_fat_read_block) < 0) { - FAT_DPRINT ("Error: reading rootdir block\n"); - 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; } - 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)) { + j = 0; + while (1) { + int i; + + debug("FAT read sect=%d, clust_size=%d, DIRENTSPERBLOCK=%d\n", + cursect, mydata->clust_size, DIRENTSPERBLOCK); + + if (disk_read(cursect, mydata->clust_size, do_fat_read_block) < 0) { + debug("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->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 ((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) { + char dirc; + int doit = 0; + int isdir = + (dentptr->attr & ATTR_DIR); + + if (isdir) { + 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); + } + } + dentptr++; + continue; + } + debug("Rootvfatname: |%s|\n", + l_name); + } else +#endif + { + /* Volume label or VFAT entry */ + dentptr++; + continue; + } + } else if (dentptr->name[0] == 0) { + debug("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; } - if (doit) { - if (dirc == ' ') { - printf (" %8ld %s%c\n", - (long) FAT2CPU32 (dentptr->size), - l_name, dirc); - } else { - printf (" %s%c\n", l_name, dirc); - } +#ifdef CONFIG_SUPPORT_VFAT + else if (dols == LS_ROOT && + mkcksum(dentptr->name) == prevcksum) { + dentptr++; + continue; } - 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; + 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)) { + debug("RootMismatch: |%s|%s|\n", s_name, + l_name); + dentptr++; + continue; + } + + if (isdir && !(dentptr->attr & ATTR_DIR)) + return -1; + + debug("RootName: %s", s_name); + debug(", start: 0x%x", START(dentptr)); + debug(", size: 0x%x %s\n", + FAT2CPU32(dentptr->size), + isdir ? "(DIR)" : ""); + + goto rootdir_done; /* We got a match */ } - return -1; - } -#ifdef CONFIG_SUPPORT_VFAT - else 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; - } + debug("END LOOP: j=%d clust_size=%d\n", j, + mydata->clust_size); + + /* + * On FAT32 we must fetch the FAT entries for the next + * root directory clusters when a cluster has been + * completely processed. + */ + if ((mydata->fatsize == 32) && (++j == mydata->clust_size)) { + int nxtsect; + int nxt_clust; + + nxt_clust = get_fatent(mydata, root_cluster); + + nxtsect = mydata->data_begin + + (nxt_clust * mydata->clust_size); + + debug("END LOOP: sect=%d, root_clust=%d, " + "n_sect=%d, n_clust=%d\n", + cursect, root_cluster, + nxtsect, nxt_clust); + + root_cluster = nxt_clust; + + cursect = nxtsect; + j = 0; } else { - dirc = ' '; - if (s_name[0] != 0) { - files++; - doit = 1; - } + cursect++; } - 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; + } +rootdir_done:

- 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)" : ""); + firsttime = 1;

- goto rootdir_done; /* We got a match */ - } - FAT_DPRINT ("END LOOP: j=%d clust_size=%d\n", j, mydata->clust_size); - - /* - * On FAT32 we must fetch the FAT entries for the next - * root directory clusters when a cluster has been - * completely processed. - */ - if ((mydata->fatsize == 32) && (++j == mydata->clust_size)) { - int nxtsect; - int cur_clust, nxt_clust; - - cur_clust = (cursect - mydata->data_begin) / mydata->clust_size; - nxt_clust = get_fatent(mydata, root_cluster); - nxtsect = mydata->data_begin + (nxt_clust * mydata->clust_size); - FAT_DPRINT ("END LOOP: sect=%d, clust=%d, root_clust=%d, n_sect=%d, n_clust=%d\n", - cursect, cur_clust, root_cluster, nxtsect, nxt_clust); - root_cluster = nxt_clust; - - cursect = nxtsect; - j = 0; - } else { - 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; - } - } + while (isdir) { + int startsect = mydata->data_begin + + START(dentptr) * mydata->clust_size; + dir_entry dent; + char *nextname = NULL;

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

- if (idx >= 0) { - if (!(dentptr->attr & ATTR_DIR)) - return -1; - subname = nextname; + 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; + } + } + + if (get_dentfromdir(mydata, startsect, subname, dentptr, + isdir ? 0 : dols) == NULL) { + if (dols && !isdir) + return 0; + return -1; + } + + 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);

- return ret; -} + ret = get_contents(mydata, dentptr, buffer, maxsize); + debug("Size: %d, got: %ld\n", FAT2CPU32(dentptr->size), 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; } + #if defined(CONFIG_CMD_IDE) || \ defined(CONFIG_CMD_MG_DISK) || \ defined(CONFIG_CMD_SATA) || \ @@ -1003,42 +1072,58 @@ file_fat_detectfs(void) defined(CONFIG_CMD_USB) || \ defined(CONFIG_MMC) printf("Interface: "); - switch(cur_dev->if_type) { - case IF_TYPE_IDE : printf("IDE"); break; - case IF_TYPE_SATA : printf("SATA"); 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"); + switch (cur_dev->if_type) { + case IF_TYPE_IDE: + printf("IDE"); + break; + case IF_TYPE_SATA: + printf("SATA"); + 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"); } - 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..59c5d37 100644 --- a/fs/fat/file.c +++ b/fs/fat/file.c @@ -48,12 +48,12 @@ char file_cwd[CWD_LEN+1] = "/"; 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) { @@ -72,15 +72,14 @@ pathcpy(char *dest, const char *src) return; } ++dest; - if (ISDIRDELIM(*src)) { + + if (ISDIRDELIM(*src)) while (ISDIRDELIM(*src)) src++; - } else { + else src++; - } } while (1); }

- int file_cd(const char *path) { @@ -141,7 +140,6 @@ file_cd(const char *path) return 0; }

- int file_detectfs(void) { @@ -160,7 +158,6 @@ file_detectfs(void) return current_filesystem; }

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

- long file_read(const char *filename, void *buffer, unsigned long maxsize) { diff --git a/include/fat.h b/include/fat.h index c8b9493..de48afd 100644 --- a/include/fat.h +++ b/include/fat.h @@ -33,7 +33,7 @@

#define SECTOR_SIZE FS_BLOCK_SIZE

-#define FS_BLOCK_SIZE 512 +#define FS_BLOCK_SIZE 512

#if FS_BLOCK_SIZE != SECTOR_SIZE #error FS_BLOCK_SIZE != SECTOR_SIZE - This code needs to be fixed! @@ -57,37 +57,31 @@ #define SIGNLEN 8

/* File attributes */ -#define ATTR_RO 1 -#define ATTR_HIDDEN 2 -#define ATTR_SYS 4 -#define ATTR_VOLUME 8 -#define ATTR_DIR 16 -#define ATTR_ARCH 32 +#define ATTR_RO 1 +#define ATTR_HIDDEN 2 +#define ATTR_SYS 4 +#define ATTR_VOLUME 8 +#define ATTR_DIR 16 +#define ATTR_ARCH 32

-#define ATTR_VFAT (ATTR_RO | ATTR_HIDDEN | ATTR_SYS | ATTR_VOLUME) +#define ATTR_VFAT (ATTR_RO | ATTR_HIDDEN | ATTR_SYS | ATTR_VOLUME)

#define DELETED_FLAG ((char)0xe5) /* Marks deleted files when in name[0] */ #define aRING 0x05 /* Used as special character in name[0] */

-/* Indicates that the entry is the last long entry in a set of long +/* + * Indicates that the entry is the last long entry in a set of long * dir entries */ #define LAST_LONG_ENTRY_MASK 0x40

/* Flags telling whether we should read a file or list a directory */ -#define LS_NO 0 -#define LS_YES 1 -#define LS_DIR 1 -#define LS_ROOT 2 +#define LS_NO 0 +#define LS_YES 1 +#define LS_DIR 1 +#define LS_ROOT 2

-#ifdef DEBUG -#define FAT_DPRINT(args...) printf(args) -#else -#define FAT_DPRINT(args...) -#endif -#define FAT_ERROR(arg) printf(arg) - -#define ISDIRDELIM(c) ((c) == '/' || (c) == '\') +#define ISDIRDELIM(c) ((c) == '/' || (c) == '\')

#define FSTYPE_NONE (-1)

@@ -166,17 +160,18 @@ typedef struct dir_entry { } dir_entry;

typedef struct dir_slot { - __u8 id; /* Sequence number for slot */ - __u8 name0_4[10]; /* First 5 characters in name */ - __u8 attr; /* Attribute byte */ - __u8 reserved; /* Unused */ - __u8 alias_checksum;/* Checksum for 8.3 alias */ - __u8 name5_10[12]; /* 6 more characters in name */ - __u16 start; /* Unused */ - __u8 name11_12[4]; /* Last 2 characters in name */ + __u8 id; /* Sequence number for slot */ + __u8 name0_4[10]; /* First 5 characters in name */ + __u8 attr; /* Attribute byte */ + __u8 reserved; /* Unused */ + __u8 alias_checksum;/* Checksum for 8.3 alias */ + __u8 name5_10[12]; /* 6 more characters in name */ + __u16 start; /* Unused */ + __u8 name11_12[4]; /* Last 2 characters in name */ } dir_slot;

-/* Private filesystem parameters +/* + * Private filesystem parameters * * Note: FAT buffer has to be 32 bit aligned * (see FAT32 accesses) @@ -198,10 +193,10 @@ typedef long (file_read_func)(const char *filename, void *buffer, unsigned long maxsize);

struct filesystem { - file_detectfs_func *detect; - file_ls_func *ls; - file_read_func *read; - const char name[12]; + file_detectfs_func *detect; + file_ls_func *ls; + file_read_func *read; + const char name[12]; };

/* FAT tables */