From da848576312800dc229624e928d132d0702c1854 Mon Sep 17 00:00:00 2001 From: Jörg Hohensohn Date: Tue, 28 Dec 2004 22:16:07 +0000 Subject: prepared to mount multiple partitions into one logical file system (most useful for Ondio, internal memory + external MMC) git-svn-id: svn://svn.rockbox.org/rockbox/trunk@5514 a1c6a512-1295-4272-9138-f99709370657 --- firmware/drivers/ata.c | 11 +- firmware/drivers/ata_mmc.c | 32 +- firmware/drivers/fat.c | 734 ++++++++++++++++++++++++++++----------------- 3 files changed, 488 insertions(+), 289 deletions(-) (limited to 'firmware/drivers') diff --git a/firmware/drivers/ata.c b/firmware/drivers/ata.c index 9a0476f5cc..349ba077dd 100644 --- a/firmware/drivers/ata.c +++ b/firmware/drivers/ata.c @@ -310,7 +310,8 @@ static void copy_read_sectors(unsigned char* buf, int wordcount) #endif } -int ata_read_sectors(unsigned long start, +int ata_read_sectors(IF_MV((int drive,)) + unsigned long start, int incount, void* inbuf) { @@ -576,7 +577,8 @@ static void copy_write_sectors(const unsigned char* buf, int wordcount) #endif } -int ata_write_sectors(unsigned long start, +int ata_write_sectors(IF_MV((int drive,)) + unsigned long start, int count, const void* buf) { @@ -669,6 +671,8 @@ int ata_write_sectors(unsigned long start, return ret; } +/* schedule a single sector write, executed with the the next spinup + (volume 0 only, used for config sector) */ extern void ata_delayed_write(unsigned long sector, const void* buf) { memcpy(delayed_sector, buf, SECTOR_SIZE); @@ -676,12 +680,13 @@ extern void ata_delayed_write(unsigned long sector, const void* buf) delayed_write = true; } +/* write the delayed sector to volume 0 */ extern void ata_flush(void) { if ( delayed_write ) { DEBUGF("ata_flush()\n"); delayed_write = false; - ata_write_sectors(delayed_sector_num, 1, delayed_sector); + ata_write_sectors(IF_MV2(0,) delayed_sector_num, 1, delayed_sector); } } diff --git a/firmware/drivers/ata_mmc.c b/firmware/drivers/ata_mmc.c index a61d28cb07..d75309547f 100644 --- a/firmware/drivers/ata_mmc.c +++ b/firmware/drivers/ata_mmc.c @@ -608,17 +608,24 @@ static int send_single_sector(const unsigned char *buf, int timeout) return ret; } -int ata_read_sectors(unsigned long start, - int incount, - void* inbuf) +int ata_read_sectors( +#ifdef HAVE_MULTIVOLUME + int drive, +#endif + unsigned long start, + int incount, + void* inbuf) { int ret = 0; int i; unsigned long addr; unsigned char response; void *inbuf_prev = NULL; - tCardInfo *card = &card_info[current_card]; - + tCardInfo *card; +#ifdef HAVE_MULTIVOLUME + current_card = drive; +#endif + card = &card_info[current_card]; addr = start * SECTOR_SIZE; mutex_lock(&mmc_mutex); @@ -663,7 +670,11 @@ int ata_read_sectors(unsigned long start, return ret; } -int ata_write_sectors(unsigned long start, +int ata_write_sectors( +#ifdef HAVE_MULTIVOLUME + int drive, +#endif + unsigned long start, int count, const void* buf) { @@ -671,7 +682,11 @@ int ata_write_sectors(unsigned long start, int i; unsigned long addr; unsigned char response; - tCardInfo *card = &card_info[current_card]; + tCardInfo *card; +#ifdef HAVE_MULTIVOLUME + current_card = drive; +#endif + card = &card_info[current_card]; if (start == 0) panicf("Writing on sector 0\n"); @@ -733,12 +748,13 @@ extern void ata_delayed_write(unsigned long sector, const void* buf) delayed_write = true; } +/* write the delayed sector to volume 0 */ extern void ata_flush(void) { if ( delayed_write ) { DEBUGF("ata_flush()\n"); delayed_write = false; - ata_write_sectors(delayed_sector_num, 1, delayed_sector); + ata_write_sectors(IF_MV2(0,) delayed_sector_num, 1, delayed_sector); } } diff --git a/firmware/drivers/fat.c b/firmware/drivers/fat.c index 9519ea9825..f0865eb985 100644 --- a/firmware/drivers/fat.c +++ b/firmware/drivers/fat.c @@ -219,17 +219,21 @@ struct bpb bool is_fat16; /* true if we mounted a FAT16 partition, false if FAT32 */ unsigned int rootdirsectors; /* fixed # of sectors occupied by root dir */ #endif /* #ifdef HAVE_FAT16SUPPORT */ +#ifdef HAVE_MULTIVOLUME + int drive; /* on which physical device is this located */ + bool mounted; /* flag if this volume is mounted */ +#endif }; -static struct bpb fat_bpb; +static struct bpb fat_bpbs[NUM_VOLUMES]; /* mounted partition info */ -static int update_fsinfo(void); -static int first_sector_of_cluster(int cluster); -static int bpb_is_sane(void); -static void *cache_fat_sector(int secnum); +static int update_fsinfo(IF_MV_NONVOID(struct bpb* fat_bpb)); +static int bpb_is_sane(IF_MV_NONVOID(struct bpb* fat_bpb)); +static int first_sector_of_cluster(IF_MV2(struct bpb* fat_bpb,) int cluster); +static void *cache_fat_sector(IF_MV2(struct bpb* fat_bpb,) int secnum); static int create_dos_name(const unsigned char *name, unsigned char *newname); -static unsigned int find_free_cluster(unsigned int start); -static int transfer( unsigned int start, int count, char* buf, bool write ); +static unsigned int find_free_cluster(IF_MV2(struct bpb* fat_bpb,) unsigned int start); +static int transfer(IF_MV2(struct bpb* fat_bpb,) unsigned int start, int count, char* buf, bool write ); #define FAT_CACHE_SIZE 0x20 #define FAT_CACHE_MASK (FAT_CACHE_SIZE-1) @@ -239,26 +243,35 @@ struct fat_cache_entry int secnum; bool inuse; bool dirty; +#ifdef HAVE_MULTIVOLUME + struct bpb* fat_vol ; /* shared cache for all volumes */ +#endif }; static char fat_cache_sectors[FAT_CACHE_SIZE][SECTOR_SIZE]; static struct fat_cache_entry fat_cache[FAT_CACHE_SIZE]; -static int sec2cluster(unsigned int sec) +static int sec2cluster(IF_MV2(struct bpb* fat_bpb,) unsigned int sec) { - if ( sec < fat_bpb.firstdatasector ) +#ifndef HAVE_MULTIVOLUME + struct bpb* fat_bpb = &fat_bpbs[0]; +#endif + if ( sec < fat_bpb->firstdatasector ) { DEBUGF( "sec2cluster() - Bad sector number (%d)\n", sec); return -1; } - return ((sec - fat_bpb.firstdatasector) / fat_bpb.bpb_secperclus) + 2; + return ((sec - fat_bpb->firstdatasector) / fat_bpb->bpb_secperclus) + 2; } -static int cluster2sec(int cluster) +static int cluster2sec(IF_MV2(struct bpb* fat_bpb,) int cluster) { - int max_cluster = fat_bpb.totalsectors - - fat_bpb.firstdatasector / fat_bpb.bpb_secperclus + 1; +#ifndef HAVE_MULTIVOLUME + struct bpb* fat_bpb = &fat_bpbs[0]; +#endif + int max_cluster = fat_bpb->totalsectors - + fat_bpb->firstdatasector / fat_bpb->bpb_secperclus + 1; if(cluster > max_cluster) { @@ -267,109 +280,141 @@ static int cluster2sec(int cluster) return -1; } - return first_sector_of_cluster(cluster); + return first_sector_of_cluster(IF_MV2(fat_bpb,) cluster); } -static int first_sector_of_cluster(int cluster) +static int first_sector_of_cluster(IF_MV2(struct bpb* fat_bpb,) int cluster) { +#ifndef HAVE_MULTIVOLUME + struct bpb* fat_bpb = &fat_bpbs[0]; +#endif #ifdef HAVE_FAT16SUPPORT /* negative clusters (FAT16 root dir) don't get the 2 offset */ int zerocluster = cluster < 0 ? 0 : 2; #else const int zerocluster = 2; #endif - return (cluster - zerocluster) * fat_bpb.bpb_secperclus + fat_bpb.firstdatasector; + return (cluster - zerocluster) * fat_bpb->bpb_secperclus + fat_bpb->firstdatasector; } -int fat_startsector(void) +int fat_startsector(IF_MV_NONVOID(int volume)) { - return fat_bpb.startsector; +#ifndef HAVE_MULTIVOLUME + const int volume = 0; +#endif + struct bpb* fat_bpb = &fat_bpbs[volume]; + return fat_bpb->startsector; } -void fat_size(unsigned int* size, unsigned int* free) +void fat_size(IF_MV2(int volume,) unsigned int* size, unsigned int* free) { +#ifndef HAVE_MULTIVOLUME + const int volume = 0; +#endif + struct bpb* fat_bpb = &fat_bpbs[volume]; if (size) - *size = fat_bpb.dataclusters * fat_bpb.bpb_secperclus / 2; + *size = fat_bpb->dataclusters * fat_bpb->bpb_secperclus / 2; if (free) - *free = fat_bpb.fsinfo.freecount * fat_bpb.bpb_secperclus / 2; + *free = fat_bpb->fsinfo.freecount * fat_bpb->bpb_secperclus / 2; } -int fat_mount(int startsector) +void fat_init(void) { - unsigned char buf[SECTOR_SIZE]; - int rc; - int datasec; unsigned int i; - + /* mark the FAT cache as unused */ for(i = 0;i < FAT_CACHE_SIZE;i++) { fat_cache[i].secnum = 8; /* We use a "safe" sector just in case */ fat_cache[i].inuse = false; fat_cache[i].dirty = false; +#ifdef HAVE_MULTIVOLUME + fat_cache[i].fat_vol = NULL; +#endif + } +#ifdef HAVE_MULTIVOLUME + /* mark the possible volumes as not mounted */ + for (i=0; istartsector = startsector; +#ifdef HAVE_MULTIVOLUME + fat_bpb->drive = drive; +#endif + + fat_bpb->bpb_bytspersec = BYTES2INT16(buf,BPB_BYTSPERSEC); + 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_totsec16 = BYTES2INT16(buf,BPB_TOTSEC16); + fat_bpb->bpb_media = buf[BPB_MEDIA]; + fat_bpb->bpb_fatsz16 = BYTES2INT16(buf,BPB_FATSZ16); + fat_bpb->bpb_fatsz32 = BYTES2INT32(buf,BPB_FATSZ32); + fat_bpb->bpb_totsec32 = BYTES2INT32(buf,BPB_TOTSEC32); + fat_bpb->last_word = BYTES2INT16(buf,BPB_LAST_WORD); /* calculate a few commonly used values */ - if (fat_bpb.bpb_fatsz16 != 0) - fat_bpb.fatsize = fat_bpb.bpb_fatsz16; + if (fat_bpb->bpb_fatsz16 != 0) + fat_bpb->fatsize = fat_bpb->bpb_fatsz16; else - fat_bpb.fatsize = fat_bpb.bpb_fatsz32; + fat_bpb->fatsize = fat_bpb->bpb_fatsz32; - if (fat_bpb.bpb_totsec16 != 0) - fat_bpb.totalsectors = fat_bpb.bpb_totsec16; + if (fat_bpb->bpb_totsec16 != 0) + fat_bpb->totalsectors = fat_bpb->bpb_totsec16; else - fat_bpb.totalsectors = fat_bpb.bpb_totsec32; + fat_bpb->totalsectors = fat_bpb->bpb_totsec32; #ifdef HAVE_FAT16SUPPORT - fat_bpb.bpb_rootentcnt = BYTES2INT16(buf,BPB_ROOTENTCNT); - fat_bpb.rootdirsectors = ((fat_bpb.bpb_rootentcnt * 32) - + (fat_bpb.bpb_bytspersec - 1)) / fat_bpb.bpb_bytspersec; + fat_bpb->bpb_rootentcnt = BYTES2INT16(buf,BPB_ROOTENTCNT); + fat_bpb->rootdirsectors = ((fat_bpb->bpb_rootentcnt * 32) + + (fat_bpb->bpb_bytspersec - 1)) / fat_bpb->bpb_bytspersec; #endif /* #ifdef HAVE_FAT16SUPPORT */ - fat_bpb.firstdatasector = fat_bpb.bpb_rsvdseccnt + fat_bpb->firstdatasector = fat_bpb->bpb_rsvdseccnt #ifdef HAVE_FAT16SUPPORT - + fat_bpb.rootdirsectors + + fat_bpb->rootdirsectors #endif - + fat_bpb.bpb_numfats * fat_bpb.fatsize; + + fat_bpb->bpb_numfats * fat_bpb->fatsize; /* Determine FAT type */ - datasec = fat_bpb.totalsectors - fat_bpb.firstdatasector; - fat_bpb.dataclusters = datasec / fat_bpb.bpb_secperclus; + datasec = fat_bpb->totalsectors - fat_bpb->firstdatasector; + fat_bpb->dataclusters = datasec / fat_bpb->bpb_secperclus; #ifdef TEST_FAT /* we are sometimes testing with "illegally small" fat32 images, so we don't use the proper fat32 test case for test code */ - if ( fat_bpb.bpb_fatsz16 ) + if ( fat_bpb->bpb_fatsz16 ) #else - if ( fat_bpb.dataclusters < 65525 ) + if ( fat_bpb->dataclusters < 65525 ) #endif { /* FAT16 */ #ifdef HAVE_FAT16SUPPORT - fat_bpb.is_fat16 = true; - if (fat_bpb.dataclusters < 4085) + fat_bpb->is_fat16 = true; + if (fat_bpb->dataclusters < 4085) { /* FAT12 */ DEBUGF("This is FAT12. Go away!\n"); return -2; @@ -381,26 +426,26 @@ int fat_mount(int startsector) } #ifdef HAVE_FAT16SUPPORT - if (fat_bpb.is_fat16) + if (fat_bpb->is_fat16) { /* FAT16 specific part of BPB */ int dirclusters; - fat_bpb.rootdirsector = fat_bpb.bpb_rsvdseccnt - + fat_bpb.bpb_numfats * fat_bpb.bpb_fatsz16; - dirclusters = ((fat_bpb.rootdirsectors + fat_bpb.bpb_secperclus - 1) - / fat_bpb.bpb_secperclus); /* rounded up, to full clusters */ + fat_bpb->rootdirsector = fat_bpb->bpb_rsvdseccnt + + fat_bpb->bpb_numfats * fat_bpb->bpb_fatsz16; + dirclusters = ((fat_bpb->rootdirsectors + fat_bpb->bpb_secperclus - 1) + / fat_bpb->bpb_secperclus); /* rounded up, to full clusters */ /* I assign negative pseudo cluster numbers for the root directory, their range is counted upward until -1. */ - fat_bpb.bpb_rootclus = 0 - dirclusters; /* backwards, before the data */ + fat_bpb->bpb_rootclus = 0 - dirclusters; /* backwards, before the data */ } else #endif /* #ifdef HAVE_FAT16SUPPORT */ { /* FAT32 specific part of BPB */ - fat_bpb.bpb_rootclus = BYTES2INT32(buf,BPB_ROOTCLUS); - fat_bpb.bpb_fsinfo = BYTES2INT16(buf,BPB_FSINFO); - fat_bpb.rootdirsector = cluster2sec(fat_bpb.bpb_rootclus); + fat_bpb->bpb_rootclus = BYTES2INT32(buf,BPB_ROOTCLUS); + fat_bpb->bpb_fsinfo = BYTES2INT16(buf,BPB_FSINFO); + fat_bpb->rootdirsector = cluster2sec(IF_MV2(fat_bpb,) fat_bpb->bpb_rootclus); } - rc = bpb_is_sane(); + rc = bpb_is_sane(IF_MV(fat_bpb)); if (rc < 0) { DEBUGF( "fat_mount() - BPB is not sane\n"); @@ -408,59 +453,68 @@ int fat_mount(int startsector) } #ifdef HAVE_FAT16SUPPORT - if (fat_bpb.is_fat16) + if (fat_bpb->is_fat16) { - fat_bpb.fsinfo.freecount = 0xffffffff; /* force recalc below */ - fat_bpb.fsinfo.nextfree = 0xffffffff; + fat_bpb->fsinfo.freecount = 0xffffffff; /* force recalc below */ + fat_bpb->fsinfo.nextfree = 0xffffffff; } else #endif /* #ifdef HAVE_FAT16SUPPORT */ { /* Read the fsinfo sector */ - rc = ata_read_sectors(startsector + fat_bpb.bpb_fsinfo, 1, buf); + rc = ata_read_sectors(IF_MV2(drive,) + startsector + fat_bpb->bpb_fsinfo, 1, buf); if (rc < 0) { DEBUGF( "fat_mount() - Couldn't read FSInfo (error code %d)\n", rc); return rc * 10 - 4; } - fat_bpb.fsinfo.freecount = BYTES2INT32(buf, FSINFO_FREECOUNT); - fat_bpb.fsinfo.nextfree = BYTES2INT32(buf, FSINFO_NEXTFREE); + fat_bpb->fsinfo.freecount = BYTES2INT32(buf, FSINFO_FREECOUNT); + fat_bpb->fsinfo.nextfree = BYTES2INT32(buf, FSINFO_NEXTFREE); } /* calculate freecount if unset */ - if ( fat_bpb.fsinfo.freecount == 0xffffffff ) + if ( fat_bpb->fsinfo.freecount == 0xffffffff ) { - fat_recalc_free(); + fat_recalc_free(IF_MV(volume)); } - LDEBUGF("Freecount: %d\n",fat_bpb.fsinfo.freecount); - LDEBUGF("Nextfree: 0x%x\n",fat_bpb.fsinfo.nextfree); - LDEBUGF("Cluster count: 0x%x\n",fat_bpb.dataclusters); - LDEBUGF("Sectors per cluster: %d\n",fat_bpb.bpb_secperclus); - LDEBUGF("FAT sectors: 0x%x\n",fat_bpb.fatsize); + LDEBUGF("Freecount: %d\n",fat_bpb->fsinfo.freecount); + LDEBUGF("Nextfree: 0x%x\n",fat_bpb->fsinfo.nextfree); + LDEBUGF("Cluster count: 0x%x\n",fat_bpb->dataclusters); + LDEBUGF("Sectors per cluster: %d\n",fat_bpb->bpb_secperclus); + LDEBUGF("FAT sectors: 0x%x\n",fat_bpb->fatsize); + +#ifdef HAVE_MULTIVOLUME + fat_bpb->mounted = true; +#endif return 0; } -void fat_recalc_free(void) +void fat_recalc_free(IF_MV_NONVOID(int volume)) { +#ifndef HAVE_MULTIVOLUME + const int volume = 0; +#endif + struct bpb* fat_bpb = &fat_bpbs[volume]; int free = 0; unsigned i; #ifdef HAVE_FAT16SUPPORT - if (fat_bpb.is_fat16) + if (fat_bpb->is_fat16) { - for (i = 0; ifatsize; i++) { unsigned int j; - unsigned short* fat = cache_fat_sector(i); + unsigned short* fat = cache_fat_sector(IF_MV2(fat_bpb,) i); for (j = 0; j < CLUSTERS_PER_FAT16_SECTOR; j++) { unsigned int c = i * CLUSTERS_PER_FAT16_SECTOR + j; - if ( c > fat_bpb.dataclusters+1 ) /* nr 0 is unused */ + if ( c > fat_bpb->dataclusters+1 ) /* nr 0 is unused */ break; if (SWAB16(fat[j]) == 0x0000) { free++; - if ( fat_bpb.fsinfo.nextfree == 0xffffffff ) - fat_bpb.fsinfo.nextfree = c; + if ( fat_bpb->fsinfo.nextfree == 0xffffffff ) + fat_bpb->fsinfo.nextfree = c; } } } @@ -468,116 +522,153 @@ void fat_recalc_free(void) else #endif /* #ifdef HAVE_FAT16SUPPORT */ { - for (i = 0; ifatsize; i++) { unsigned int j; - unsigned int* fat = cache_fat_sector(i); + unsigned int* fat = cache_fat_sector(IF_MV2(fat_bpb,) i); for (j = 0; j < CLUSTERS_PER_FAT_SECTOR; j++) { unsigned int c = i * CLUSTERS_PER_FAT_SECTOR + j; - if ( c > fat_bpb.dataclusters+1 ) /* nr 0 is unused */ + if ( c > fat_bpb->dataclusters+1 ) /* nr 0 is unused */ break; if (!(SWAB32(fat[j]) & 0x0fffffff)) { free++; - if ( fat_bpb.fsinfo.nextfree == 0xffffffff ) - fat_bpb.fsinfo.nextfree = c; + if ( fat_bpb->fsinfo.nextfree == 0xffffffff ) + fat_bpb->fsinfo.nextfree = c; } } } } - fat_bpb.fsinfo.freecount = free; - update_fsinfo(); + fat_bpb->fsinfo.freecount = free; + update_fsinfo(IF_MV(fat_bpb)); } -static int bpb_is_sane(void) +static int bpb_is_sane(IF_MV_NONVOID(struct bpb* fat_bpb)) { - if(fat_bpb.bpb_bytspersec != 512) +#ifndef HAVE_MULTIVOLUME + struct bpb* fat_bpb = &fat_bpbs[0]; +#endif + if(fat_bpb->bpb_bytspersec != 512) { DEBUGF( "bpb_is_sane() - Error: sector size is not 512 (%d)\n", - fat_bpb.bpb_bytspersec); + fat_bpb->bpb_bytspersec); return -1; } - if(fat_bpb.bpb_secperclus * fat_bpb.bpb_bytspersec > 128*1024) + if(fat_bpb->bpb_secperclus * fat_bpb->bpb_bytspersec > 128*1024) { DEBUGF( "bpb_is_sane() - Error: cluster size is larger than 128K " "(%d * %d = %d)\n", - fat_bpb.bpb_bytspersec, fat_bpb.bpb_secperclus, - fat_bpb.bpb_bytspersec * fat_bpb.bpb_secperclus); + fat_bpb->bpb_bytspersec, fat_bpb->bpb_secperclus, + fat_bpb->bpb_bytspersec * fat_bpb->bpb_secperclus); return -2; } - if(fat_bpb.bpb_numfats != 2) + if(fat_bpb->bpb_numfats != 2) { DEBUGF( "bpb_is_sane() - Warning: NumFATS is not 2 (%d)\n", - fat_bpb.bpb_numfats); + fat_bpb->bpb_numfats); } - if(fat_bpb.bpb_media != 0xf0 && fat_bpb.bpb_media < 0xf8) + if(fat_bpb->bpb_media != 0xf0 && fat_bpb->bpb_media < 0xf8) { DEBUGF( "bpb_is_sane() - Warning: Non-standard " "media type (0x%02x)\n", - fat_bpb.bpb_media); + fat_bpb->bpb_media); } - if(fat_bpb.last_word != 0xaa55) + if(fat_bpb->last_word != 0xaa55) { DEBUGF( "bpb_is_sane() - Error: Last word is not " - "0xaa55 (0x%04x)\n", fat_bpb.last_word); + "0xaa55 (0x%04x)\n", fat_bpb->last_word); return -3; } - if (fat_bpb.fsinfo.freecount > - (fat_bpb.totalsectors - fat_bpb.firstdatasector)/ - fat_bpb.bpb_secperclus) + 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); + "(0x%04x)\n", fat_bpb->fsinfo.freecount); return -4; } return 0; } -static void *cache_fat_sector(int fatsector) +static void flush_fat_sector(struct fat_cache_entry *fce, + unsigned char *sectorbuf) { - int secnum = fatsector + fat_bpb.bpb_rsvdseccnt; + int rc; + int secnum; + + /* With multivolume, use only the FAT info from the cached sector! */ +#ifdef HAVE_MULTIVOLUME + secnum = fce->secnum + fce->fat_vol->startsector; +#else + secnum = fce->secnum + fat_bpbs[0].startsector; +#endif + + /* Write to the first FAT */ + rc = ata_write_sectors(IF_MV2(fce->fat_vol->drive,) + secnum, 1, + sectorbuf); + if(rc < 0) + { + panicf("cache_fat_sector() - Could not write sector %d" + " (error %d)\n", + secnum, rc); + } +#ifdef HAVE_MULTIVOLUME + if(fce->fat_vol->bpb_numfats > 1) +#else + if(fat_bpbs[0].bpb_numfats > 1) +#endif + { + /* Write to the second FAT */ +#ifdef HAVE_MULTIVOLUME + secnum += fce->fat_vol->fatsize; +#else + secnum += fat_bpbs[0].fatsize; +#endif + rc = ata_write_sectors(IF_MV2(fce->fat_vol->drive,) + secnum, 1, sectorbuf); + if(rc < 0) + { + panicf("cache_fat_sector() - Could not write sector %d" + " (error %d)\n", + secnum, rc); + } + } + fce->dirty = false; +} + +static void *cache_fat_sector(IF_MV2(struct bpb* fat_bpb,) int fatsector) +{ +#ifndef HAVE_MULTIVOLUME + struct bpb* fat_bpb = &fat_bpbs[0]; +#endif + int secnum = fatsector + fat_bpb->bpb_rsvdseccnt; int cache_index = secnum & FAT_CACHE_MASK; struct fat_cache_entry *fce = &fat_cache[cache_index]; unsigned char *sectorbuf = &fat_cache_sectors[cache_index][0]; int rc; /* Delete the cache entry if it isn't the sector we want */ - if(fce->inuse && fce->secnum != secnum) + if(fce->inuse && (fce->secnum != secnum +#ifdef HAVE_MULTIVOLUME + || fce->fat_vol != fat_bpb +#endif + )) { /* Write back if it is dirty */ if(fce->dirty) { - rc = ata_write_sectors(fce->secnum+fat_bpb.startsector, 1, - sectorbuf); - if(rc < 0) - { - panicf("cache_fat_sector() - Could not write sector %d" - " (error %d)\n", - secnum, rc); - } - if(fat_bpb.bpb_numfats > 1) - { - /* Write to the second FAT */ - rc = ata_write_sectors(fce->secnum+fat_bpb.startsector+ - fat_bpb.fatsize, 1, sectorbuf); - if(rc < 0) - { - panicf("cache_fat_sector() - Could not write sector %d" - " (error %d)\n", - secnum + fat_bpb.fatsize, rc); - } - } + flush_fat_sector(fce, sectorbuf); } - fce->secnum = 8; /* Normally an unused sector */ - fce->dirty = false; fce->inuse = false; } /* Load the sector if it is not cached */ if(!fce->inuse) { - rc = ata_read_sectors(secnum + fat_bpb.startsector,1, + rc = ata_read_sectors(IF_MV2(fat_bpb->drive,) + secnum + fat_bpb->startsector,1, sectorbuf); if(rc < 0) { @@ -587,26 +678,32 @@ static void *cache_fat_sector(int fatsector) } fce->inuse = true; fce->secnum = secnum; +#ifdef HAVE_MULTIVOLUME + fce->fat_vol = fat_bpb; +#endif } return sectorbuf; } -static unsigned int find_free_cluster(unsigned int startcluster) +static unsigned int find_free_cluster(IF_MV2(struct bpb* fat_bpb,) unsigned int startcluster) { +#ifndef HAVE_MULTIVOLUME + struct bpb* fat_bpb = &fat_bpbs[0]; +#endif unsigned int sector; unsigned int offset; unsigned int i; #ifdef HAVE_FAT16SUPPORT - if (fat_bpb.is_fat16) + if (fat_bpb->is_fat16) { sector = startcluster / CLUSTERS_PER_FAT16_SECTOR; offset = startcluster % CLUSTERS_PER_FAT16_SECTOR; - for (i = 0; ifatsize; i++) { unsigned int j; - unsigned int nr = (i + sector) % fat_bpb.fatsize; - unsigned short* fat = cache_fat_sector(nr); + unsigned int nr = (i + sector) % fat_bpb->fatsize; + unsigned short* fat = cache_fat_sector(IF_MV2(fat_bpb,) nr); if ( !fat ) break; for (j = 0; j < CLUSTERS_PER_FAT16_SECTOR; j++) { @@ -615,10 +712,10 @@ static unsigned int find_free_cluster(unsigned int startcluster) unsigned int c = nr * CLUSTERS_PER_FAT16_SECTOR + k; /* Ignore the reserved clusters 0 & 1, and also cluster numbers out of bounds */ - if ( c < 2 || c > fat_bpb.dataclusters+1 ) + if ( c < 2 || c > fat_bpb->dataclusters+1 ) continue; LDEBUGF("find_free_cluster(%x) == %x\n",startcluster,c); - fat_bpb.fsinfo.nextfree = c; + fat_bpb->fsinfo.nextfree = c; return c; } } @@ -631,10 +728,10 @@ static unsigned int find_free_cluster(unsigned int startcluster) sector = startcluster / CLUSTERS_PER_FAT_SECTOR; offset = startcluster % CLUSTERS_PER_FAT_SECTOR; - for (i = 0; ifatsize; i++) { unsigned int j; - unsigned int nr = (i + sector) % fat_bpb.fatsize; - unsigned int* fat = cache_fat_sector(nr); + unsigned int nr = (i + sector) % fat_bpb->fatsize; + unsigned int* fat = cache_fat_sector(IF_MV2(fat_bpb,) nr); if ( !fat ) break; for (j = 0; j < CLUSTERS_PER_FAT_SECTOR; j++) { @@ -643,10 +740,10 @@ static unsigned int find_free_cluster(unsigned int startcluster) unsigned int c = nr * CLUSTERS_PER_FAT_SECTOR + k; /* Ignore the reserved clusters 0 & 1, and also cluster numbers out of bounds */ - if ( c < 2 || c > fat_bpb.dataclusters+1 ) + if ( c < 2 || c > fat_bpb->dataclusters+1 ) continue; LDEBUGF("find_free_cluster(%x) == %x\n",startcluster,c); - fat_bpb.fsinfo.nextfree = c; + fat_bpb->fsinfo.nextfree = c; return c; } } @@ -658,10 +755,13 @@ static unsigned int find_free_cluster(unsigned int startcluster) return 0; /* 0 is an illegal cluster number */ } -static int update_fat_entry(unsigned int entry, unsigned int val) +static int update_fat_entry(IF_MV2(struct bpb* fat_bpb,) unsigned int entry, unsigned int val) { +#ifndef HAVE_MULTIVOLUME + struct bpb* fat_bpb = &fat_bpbs[0]; +#endif #ifdef HAVE_FAT16SUPPORT - if (fat_bpb.is_fat16) + if (fat_bpb->is_fat16) { int sector = entry / CLUSTERS_PER_FAT16_SECTOR; int offset = entry % CLUSTERS_PER_FAT16_SECTOR; @@ -677,24 +777,24 @@ static int update_fat_entry(unsigned int entry, unsigned int val) if ( entry < 2 ) panicf("Updating reserved FAT entry %d.\n",entry); - sec = cache_fat_sector(sector); + sec = cache_fat_sector(IF_MV2(fat_bpb,) sector); if (!sec) { DEBUGF( "update_entry() - Could not cache sector %d\n", sector); return -1; } - fat_cache[(sector + fat_bpb.bpb_rsvdseccnt) & FAT_CACHE_MASK].dirty = true; + fat_cache[(sector + fat_bpb->bpb_rsvdseccnt) & FAT_CACHE_MASK].dirty = true; if ( val ) { - if (SWAB16(sec[offset]) == 0x0000 && fat_bpb.fsinfo.freecount > 0) - fat_bpb.fsinfo.freecount--; + if (SWAB16(sec[offset]) == 0x0000 && fat_bpb->fsinfo.freecount > 0) + fat_bpb->fsinfo.freecount--; } else { if (SWAB16(sec[offset])) - fat_bpb.fsinfo.freecount++; + fat_bpb->fsinfo.freecount++; } - LDEBUGF("update_fat_entry: %d free clusters\n", fat_bpb.fsinfo.freecount); + LDEBUGF("update_fat_entry: %d free clusters\n", fat_bpb->fsinfo.freecount); sec[offset] = SWAB16(val); } @@ -713,25 +813,25 @@ static int update_fat_entry(unsigned int entry, unsigned int val) if ( entry < 2 ) panicf("Updating reserved FAT entry %d.\n",entry); - sec = cache_fat_sector(sector); + sec = cache_fat_sector(IF_MV2(fat_bpb,) sector); if (!sec) { DEBUGF( "update_entry() - Could not cache sector %d\n", sector); return -1; } - fat_cache[(sector + fat_bpb.bpb_rsvdseccnt) & FAT_CACHE_MASK].dirty = true; + fat_cache[(sector + fat_bpb->bpb_rsvdseccnt) & FAT_CACHE_MASK].dirty = true; if ( val ) { if (!(SWAB32(sec[offset]) & 0x0fffffff) && - fat_bpb.fsinfo.freecount > 0) - fat_bpb.fsinfo.freecount--; + fat_bpb->fsinfo.freecount > 0) + fat_bpb->fsinfo.freecount--; } else { if (SWAB32(sec[offset]) & 0x0fffffff) - fat_bpb.fsinfo.freecount++; + fat_bpb->fsinfo.freecount++; } - LDEBUGF("update_fat_entry: %d free clusters\n", fat_bpb.fsinfo.freecount); + LDEBUGF("update_fat_entry: %d free clusters\n", fat_bpb->fsinfo.freecount); /* don't change top 4 bits */ sec[offset] &= SWAB32(0xf0000000); @@ -741,16 +841,19 @@ static int update_fat_entry(unsigned int entry, unsigned int val) return 0; } -static int read_fat_entry(unsigned int entry) +static int read_fat_entry(IF_MV2(struct bpb* fat_bpb,) unsigned int entry) { +#ifndef HAVE_MULTIVOLUME + struct bpb* fat_bpb = &fat_bpbs[0]; +#endif #ifdef HAVE_FAT16SUPPORT - if (fat_bpb.is_fat16) + if (fat_bpb->is_fat16) { int sector = entry / CLUSTERS_PER_FAT16_SECTOR; int offset = entry % CLUSTERS_PER_FAT16_SECTOR; unsigned short* sec; - sec = cache_fat_sector(sector); + sec = cache_fat_sector(IF_MV2(fat_bpb,) sector); if (!sec) { DEBUGF( "read_fat_entry() - Could not cache sector %d\n", sector); @@ -766,7 +869,7 @@ static int read_fat_entry(unsigned int entry) int offset = entry % CLUSTERS_PER_FAT_SECTOR; unsigned int* sec; - sec = cache_fat_sector(sector); + sec = cache_fat_sector(IF_MV2(fat_bpb,) sector); if (!sec) { DEBUGF( "read_fat_entry() - Could not cache sector %d\n", sector); @@ -777,20 +880,23 @@ static int read_fat_entry(unsigned int entry) } } -static int get_next_cluster(int cluster) +static int get_next_cluster(IF_MV2(struct bpb* fat_bpb,) int cluster) { +#ifndef HAVE_MULTIVOLUME + struct bpb* fat_bpb = &fat_bpbs[0]; +#endif int next_cluster; int eof_mark = FAT_EOF_MARK; #ifdef HAVE_FAT16SUPPORT - if (fat_bpb.is_fat16) + if (fat_bpb->is_fat16) { eof_mark &= 0xFFFF; /* only 16 bit */ if (cluster < 0) /* FAT16 root dir */ return cluster + 1; /* don't use the FAT */ } #endif - next_cluster = read_fat_entry(cluster); + next_cluster = read_fat_entry(IF_MV2(fat_bpb,) cluster); /* is this last cluster in chain? */ if ( next_cluster >= eof_mark ) @@ -799,31 +905,36 @@ static int get_next_cluster(int cluster) return next_cluster; } -static int update_fsinfo(void) +static int update_fsinfo(IF_MV_NONVOID(struct bpb* fat_bpb)) { +#ifndef HAVE_MULTIVOLUME + struct bpb* fat_bpb = &fat_bpbs[0]; +#endif unsigned char fsinfo[SECTOR_SIZE]; unsigned int* intptr; int rc; #ifdef HAVE_FAT16SUPPORT - if (fat_bpb.is_fat16) + if (fat_bpb->is_fat16) return 0; /* FAT16 has no FsInfo */ #endif /* #ifdef HAVE_FAT16SUPPORT */ /* update fsinfo */ - rc = ata_read_sectors(fat_bpb.startsector + fat_bpb.bpb_fsinfo, 1,fsinfo); + rc = ata_read_sectors(IF_MV2(fat_bpb->drive,) + fat_bpb->startsector + fat_bpb->bpb_fsinfo, 1,fsinfo); if (rc < 0) { DEBUGF( "flush_fat() - Couldn't read FSInfo (error code %d)\n", rc); return rc * 10 - 1; } intptr = (int*)&(fsinfo[FSINFO_FREECOUNT]); - *intptr = SWAB32(fat_bpb.fsinfo.freecount); + *intptr = SWAB32(fat_bpb->fsinfo.freecount); intptr = (int*)&(fsinfo[FSINFO_NEXTFREE]); - *intptr = SWAB32(fat_bpb.fsinfo.nextfree); + *intptr = SWAB32(fat_bpb->fsinfo.nextfree); - rc = ata_write_sectors(fat_bpb.startsector + fat_bpb.bpb_fsinfo,1,fsinfo); + rc = ata_write_sectors(IF_MV2(fat_bpb->drive,) + fat_bpb->startsector + fat_bpb->bpb_fsinfo,1,fsinfo); if (rc < 0) { DEBUGF( "flush_fat() - Couldn't write FSInfo (error code %d)\n", rc); @@ -833,48 +944,24 @@ static int update_fsinfo(void) return 0; } -static int flush_fat(void) +static int flush_fat(IF_MV_NONVOID(struct bpb* fat_bpb)) { int i; int rc; unsigned char *sec; - int secnum; LDEBUGF("flush_fat()\n"); for(i = 0;i < FAT_CACHE_SIZE;i++) { - if(fat_cache[i].inuse && fat_cache[i].dirty) + struct fat_cache_entry *fce = &fat_cache[i]; + if(fce->inuse && fce->dirty) { - 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 */ - rc = ata_write_sectors(secnum, 1, sec); - if(rc) - { - DEBUGF( "flush_fat() - Couldn't write" - " sector %d (error %d)\n", secnum, rc); - return rc * 10 - 1; - } - - if(fat_bpb.bpb_numfats > 1 ) - { - /* Write to the second FAT */ - rc = ata_write_sectors(secnum + fat_bpb.fatsize, 1, sec); - if (rc) - { - DEBUGF( "flush_fat() - Couldn't write" - " sector %d (error %d)\n", - secnum + fat_bpb.fatsize, rc); - return rc * 10 - 2; - } - } - fat_cache[i].dirty = false; + flush_fat_sector(fce, sec); } } - rc = update_fsinfo(); + rc = update_fsinfo(IF_MV(fat_bpb)); if (rc < 0) return rc * 10 - 3; @@ -1108,6 +1195,11 @@ static int add_dir_entry(struct fat_dir* dir, bool is_directory, bool dotdir) { +#ifdef HAVE_MULTIVOLUME + struct bpb* fat_bpb = &fat_bpbs[dir->file.volume]; +#else + struct bpb* fat_bpb = &fat_bpbs[0]; +#endif unsigned char buf[SECTOR_SIZE]; unsigned char shortname[16]; int rc; @@ -1122,6 +1214,10 @@ static int add_dir_entry(struct fat_dir* dir, LDEBUGF( "add_dir_entry(%s,%x)\n", name, file->firstcluster); +#ifdef HAVE_MULTIVOLUME + file->volume = dir->file.volume; /* inherit the volume, to make sure */ +#endif + /* The "." and ".." directory entries must not be long names */ if(dotdir) { int i; @@ -1173,7 +1269,7 @@ static int add_dir_entry(struct fat_dir* dir, rc = fat_readwrite(&dir->file, 1, buf, true); if (rc < 1) return rc * 10 - 3; - } while (dir->file.sectornum < (int)fat_bpb.bpb_secperclus); + } while (dir->file.sectornum < (int)fat_bpb->bpb_secperclus); } if (rc < 0) { DEBUGF( "add_dir_entry() - Couldn't read dir" @@ -1277,7 +1373,7 @@ static int add_dir_entry(struct fat_dir* dir, if (rc < 1) return rc * 10 - 9; memset(buf, 0, sizeof buf); - } while (dir->file.sectornum < (int)fat_bpb.bpb_secperclus); + } while (dir->file.sectornum < (int)fat_bpb->bpb_secperclus); } else { @@ -1288,7 +1384,7 @@ static int add_dir_entry(struct fat_dir* dir, if (rc < 1) return rc * 10 - 9; /* Same error code as above, can't be more than -9 */ - } while (dir->file.sectornum < (int)fat_bpb.bpb_secperclus); + } while (dir->file.sectornum < (int)fat_bpb->bpb_secperclus); } } @@ -1368,7 +1464,7 @@ static int update_short_entry( struct fat_file* file, int size, int attr ) file->firstcluster, file->direntry, size); /* create a temporary file handle for the dir holding this file */ - rc = fat_open(file->dircluster, &dir, NULL); + rc = fat_open(IF_MV2(file->volume,) file->dircluster, &dir, NULL); if (rc < 0) return rc * 10 - 1; @@ -1445,7 +1541,8 @@ static int parse_direntry(struct fat_direntry *de, const unsigned char *buf) return 1; } -int fat_open(unsigned int startcluster, +int fat_open(IF_MV2(int volume,) + unsigned int startcluster, struct fat_file *file, const struct fat_dir* dir) { @@ -1455,6 +1552,15 @@ int fat_open(unsigned int startcluster, file->clusternum = 0; file->sectornum = 0; file->eof = false; +#ifdef HAVE_MULTIVOLUME + file->volume = volume; + /* fixme: remove error check when done */ + if (volume >= NUM_VOLUMES || !fat_bpbs[volume].mounted) + { + LDEBUGF("fat_open() illegal volume %d\n", volume); + return -1; + } +#endif /* remember where the file's dir entry is located */ if ( dir ) { @@ -1469,19 +1575,26 @@ int fat_open(unsigned int startcluster, #ifdef HAVE_FAT16SUPPORT /* special function to open the FAT16 root dir, which may not be on cluster boundary */ -int fat_open_root(struct fat_file *file) +static int fat_open_root(IF_MV2(int volume,) + struct fat_file *file) { int dirclusters; - file->firstcluster = fat_bpb.bpb_rootclus; - file->lastcluster = fat_bpb.bpb_rootclus; +#ifdef HAVE_MULTIVOLUME + struct bpb* fat_bpb = &fat_bpbs[volume]; + file->volume = volume; +#else + struct bpb* fat_bpb = &fat_bpbs[0]; +#endif + file->firstcluster = fat_bpb->bpb_rootclus; + file->lastcluster = fat_bpb->bpb_rootclus; file->lastsector = 0; file->clusternum = 0; - dirclusters = 0 - fat_bpb.bpb_rootclus; /* bpb_rootclus is the negative */ - file->sectornum = (dirclusters * fat_bpb.bpb_secperclus) - - fat_bpb.rootdirsectors; /* cluster sectors minus real sectors */ + dirclusters = 0 - fat_bpb->bpb_rootclus; /* bpb_rootclus is the negative */ + file->sectornum = (dirclusters * fat_bpb->bpb_secperclus) + - fat_bpb->rootdirsectors; /* cluster sectors minus real sectors */ file->eof = false; - LDEBUGF("fat_open_root(), sector %d\n", cluster2sec(fat_bpb.bpb_rootclus)); + LDEBUGF("fat_open_root(), sector %d\n", cluster2sec(fat_bpb->bpb_rootclus)); return 0; } #endif /* #ifdef HAVE_FAT16SUPPORT */ @@ -1510,6 +1623,11 @@ int fat_create_dir(const char* name, struct fat_dir* newdir, struct fat_dir* dir) { +#ifdef HAVE_MULTIVOLUME + struct bpb* fat_bpb = &fat_bpbs[dir->file.volume]; +#else + struct bpb* fat_bpb = &fat_bpbs[0]; +#endif unsigned char buf[SECTOR_SIZE]; int i; int sector; @@ -1527,17 +1645,17 @@ int fat_create_dir(const char* name, return rc * 10 - 1; /* Allocate a new cluster for the directory */ - newdir->file.firstcluster = find_free_cluster(fat_bpb.fsinfo.nextfree); + newdir->file.firstcluster = find_free_cluster(IF_MV2(fat_bpb,) fat_bpb->fsinfo.nextfree); if(newdir->file.firstcluster == 0) return -1; - update_fat_entry(newdir->file.firstcluster, FAT_EOF_MARK); + update_fat_entry(IF_MV2(fat_bpb,) newdir->file.firstcluster, FAT_EOF_MARK); /* Clear the entire cluster */ memset(buf, 0, sizeof buf); - sector = cluster2sec(newdir->file.firstcluster); - for(i = 0;i < (int)fat_bpb.bpb_secperclus;i++) { - rc = transfer( sector + i, 1, buf, true ); + sector = cluster2sec(IF_MV2(fat_bpb,) newdir->file.firstcluster); + for(i = 0;i < (int)fat_bpb->bpb_secperclus;i++) { + rc = transfer(IF_MV2(fat_bpb,) sector + i, 1, buf, true ); if (rc < 0) return rc * 10 - 2; } @@ -1555,7 +1673,7 @@ int fat_create_dir(const char* name, return rc * 10 - 4; /* The root cluster is cluster 0 in the ".." entry */ - if(dir->file.firstcluster == fat_bpb.bpb_rootclus) + if(dir->file.firstcluster == fat_bpb->bpb_rootclus) dummyfile.firstcluster = 0; else dummyfile.firstcluster = dir->file.firstcluster; @@ -1564,7 +1682,7 @@ int fat_create_dir(const char* name, /* Set the firstcluster field in the direntry */ update_short_entry(&newdir->file, 0, FAT_ATTR_DIRECTORY); - rc = flush_fat(); + rc = flush_fat(IF_MV(fat_bpb)); if (rc < 0) return rc * 10 - 5; @@ -1576,15 +1694,18 @@ int fat_truncate(const struct fat_file *file) /* truncate trailing clusters */ int next; int last = file->lastcluster; +#ifdef HAVE_MULTIVOLUME + struct bpb* fat_bpb = &fat_bpbs[file->volume]; +#endif LDEBUGF("fat_truncate(%x, %x)\n", file->firstcluster, last); - for ( last = get_next_cluster(last); last; last = next ) { - next = get_next_cluster(last); - update_fat_entry(last,0); + for ( last = get_next_cluster(IF_MV2(fat_bpb,) last); last; last = next ) { + next = get_next_cluster(IF_MV2(fat_bpb,) last); + update_fat_entry(IF_MV2(fat_bpb,) last,0); } if (file->lastcluster) - update_fat_entry(file->lastcluster,FAT_EOF_MARK); + update_fat_entry(IF_MV2(fat_bpb,) file->lastcluster,FAT_EOF_MARK); return 0; } @@ -1592,12 +1713,15 @@ int fat_truncate(const struct fat_file *file) int fat_closewrite(struct fat_file *file, int size, int attr) { int rc; +#ifdef HAVE_MULTIVOLUME + struct bpb* fat_bpb = &fat_bpbs[file->volume]; +#endif LDEBUGF("fat_closewrite(size=%d)\n",size); if (!size) { /* empty file */ if ( file->firstcluster ) { - update_fat_entry(file->firstcluster, 0); + update_fat_entry(IF_MV2(fat_bpb,) file->firstcluster, 0); file->firstcluster = 0; } } @@ -1608,21 +1732,26 @@ int fat_closewrite(struct fat_file *file, int size, int attr) return rc * 10 - 1; } - flush_fat(); + flush_fat(IF_MV(fat_bpb)); #ifdef TEST_FAT if ( file->firstcluster ) { /* debug */ +#ifdef HAVE_MULTIVOLUME + struct bpb* fat_bpb = &fat_bpbs[file->volume]; +#else + struct bpb* fat_bpb = &fat_bpbs[0]; +#endif int count = 0; int len; int next; for ( next = file->firstcluster; next; - next = get_next_cluster(next) ) + next = get_next_cluster(IF_MV2(fat_bpb,) next) ) LDEBUGF("cluster %d: %x\n", count++, next); - len = count * fat_bpb.bpb_secperclus * SECTOR_SIZE; + len = count * fat_bpb->bpb_secperclus * SECTOR_SIZE; LDEBUGF("File is %d clusters (chainlen=%d, size=%d)\n", count, len, size ); - if ( len > size + fat_bpb.bpb_secperclus * SECTOR_SIZE) + if ( len > size + fat_bpb->bpb_secperclus * SECTOR_SIZE) panicf("Cluster chain is too long\n"); if ( len < size ) panicf("Cluster chain is too short\n"); @@ -1632,17 +1761,18 @@ int fat_closewrite(struct fat_file *file, int size, int attr) return 0; } -static int free_direntries(int dircluster, int startentry, int numentries) +static int free_direntries(struct fat_file* file) { unsigned char buf[SECTOR_SIZE]; struct fat_file dir; - unsigned int entry = startentry - numentries + 1; + int numentries = file->direntries; + unsigned int entry = file->direntry - numentries + 1; unsigned int sector = entry / DIR_ENTRIES_PER_SECTOR; int i; int rc; /* create a temporary file handle for the dir holding this file */ - rc = fat_open(dircluster, &dir, NULL); + rc = fat_open(IF_MV2(file->volume,) file->dircluster, &dir, NULL); if (rc < 0) return rc * 10 - 1; @@ -1698,19 +1828,20 @@ int fat_remove(struct fat_file* file) { int next, last = file->firstcluster; int rc; +#ifdef HAVE_MULTIVOLUME + struct bpb* fat_bpb = &fat_bpbs[file->volume]; +#endif LDEBUGF("fat_remove(%x)\n",last); while ( last ) { - next = get_next_cluster(last); - update_fat_entry(last,0); + next = get_next_cluster(IF_MV2(fat_bpb,) last); + update_fat_entry(IF_MV2(fat_bpb,) last,0); last = next; } if ( file->dircluster ) { - rc = free_direntries(file->dircluster, - file->direntry, - file->direntries); + rc = free_direntries(file); if (rc < 0) return rc * 10 - 1; } @@ -1718,7 +1849,7 @@ int fat_remove(struct fat_file* file) file->firstcluster = 0; file->dircluster = 0; - rc = flush_fat(); + rc = flush_fat(IF_MV(fat_bpb)); if (rc < 0) return rc * 10 - 2; @@ -1734,6 +1865,9 @@ int fat_rename(struct fat_file* file, int rc; struct fat_dir olddir; struct fat_file newfile = *file; +#ifdef HAVE_MULTIVOLUME + struct bpb* fat_bpb = &fat_bpbs[file->volume]; +#endif if ( !file->dircluster ) { DEBUGF("File has no dir cluster!\n"); @@ -1741,7 +1875,7 @@ int fat_rename(struct fat_file* file, } /* create a temporary file handle */ - rc = fat_opendir(&olddir, file->dircluster, NULL); + rc = fat_opendir(IF_MV2(file->volume,) &olddir, file->dircluster, NULL); if (rc < 0) return rc * 10 - 2; @@ -1756,11 +1890,11 @@ int fat_rename(struct fat_file* file, return rc * 10 - 4; /* remove old name */ - rc = free_direntries(file->dircluster, file->direntry, file->direntries); + rc = free_direntries(file); if (rc < 0) return rc * 10 - 5; - rc = flush_fat(); + rc = flush_fat(IF_MV(fat_bpb)); if (rc < 0) return rc * 10 - 6; @@ -1771,19 +1905,24 @@ static int next_write_cluster(struct fat_file* file, int oldcluster, int* newsector) { +#ifdef HAVE_MULTIVOLUME + struct bpb* fat_bpb = &fat_bpbs[file->volume]; +#else + struct bpb* fat_bpb = &fat_bpbs[0]; +#endif int cluster = 0; int sector; LDEBUGF("next_write_cluster(%x,%x)\n",file->firstcluster, oldcluster); if (oldcluster) - cluster = get_next_cluster(oldcluster); + cluster = get_next_cluster(IF_MV2(fat_bpb,) oldcluster); if (!cluster) { if (oldcluster > 0) - cluster = find_free_cluster(oldcluster+1); + cluster = find_free_cluster(IF_MV2(fat_bpb,) oldcluster+1); else if (oldcluster == 0) - cluster = find_free_cluster(fat_bpb.fsinfo.nextfree); + cluster = find_free_cluster(IF_MV2(fat_bpb,) fat_bpb->fsinfo.nextfree); #ifdef HAVE_FAT16SUPPORT else /* negative, pseudo-cluster of the root dir */ return 0; /* impossible to append something to the root */ @@ -1791,14 +1930,14 @@ static int next_write_cluster(struct fat_file* file, if (cluster) { if (oldcluster) - update_fat_entry(oldcluster, cluster); + update_fat_entry(IF_MV2(fat_bpb,) oldcluster, cluster); else file->firstcluster = cluster; - update_fat_entry(cluster, FAT_EOF_MARK); + update_fat_entry(IF_MV2(fat_bpb,) cluster, FAT_EOF_MARK); } else { #ifdef TEST_FAT - if (fat_bpb.fsinfo.freecount>0) + if (fat_bpb->fsinfo.freecount>0) panicf("There is free space, but find_free_cluster() " "didn't find it!\n"); #endif @@ -1806,7 +1945,7 @@ static int next_write_cluster(struct fat_file* file, return 0; } } - sector = cluster2sec(cluster); + sector = cluster2sec(IF_MV2(fat_bpb,) cluster); if (sector<0) return 0; @@ -1814,30 +1953,36 @@ static int next_write_cluster(struct fat_file* file, return cluster; } -static int transfer( unsigned int start, int count, char* buf, bool write ) +static int transfer(IF_MV2(struct bpb* fat_bpb,) + unsigned int start, int count, char* buf, bool write ) { +#ifndef HAVE_MULTIVOLUME + struct bpb* fat_bpb = &fat_bpbs[0]; +#endif int rc; LDEBUGF("transfer(s=%x, c=%x, %s)\n", - start+ fat_bpb.startsector, count, write?"write":"read"); + start+ fat_bpb->startsector, count, write?"write":"read"); if (write) { unsigned int firstallowed; #ifdef HAVE_FAT16SUPPORT - if (fat_bpb.is_fat16) - firstallowed = fat_bpb.rootdirsector; + if (fat_bpb->is_fat16) + firstallowed = fat_bpb->rootdirsector; else #endif - firstallowed = fat_bpb.firstdatasector; + firstallowed = fat_bpb->firstdatasector; if (start < firstallowed) panicf("Write %d before data\n", firstallowed - start); - if (start + count > fat_bpb.totalsectors) + if (start + count > fat_bpb->totalsectors) panicf("Write %d after data\n", - start + count - fat_bpb.totalsectors); - rc = ata_write_sectors(start + fat_bpb.startsector, count, buf); + start + count - fat_bpb->totalsectors); + rc = ata_write_sectors(IF_MV2(fat_bpb->drive,) + start + fat_bpb->startsector, count, buf); } else - rc = ata_read_sectors(start + fat_bpb.startsector, count, buf); + rc = ata_read_sectors(IF_MV2(fat_bpb->drive,) + start + fat_bpb->startsector, count, buf); if (rc < 0) { DEBUGF( "transfer() - Couldn't %s sector %x" " (error code %d)\n", @@ -1851,6 +1996,11 @@ static int transfer( unsigned int start, int count, char* buf, bool write ) int fat_readwrite( struct fat_file *file, int sectorcount, void* buf, bool write ) { +#ifdef HAVE_MULTIVOLUME + struct bpb* fat_bpb = &fat_bpbs[file->volume]; +#else + struct bpb* fat_bpb = &fat_bpbs[0]; +#endif int cluster = file->lastcluster; int sector = file->lastsector; int clusternum = file->clusternum; @@ -1871,13 +2021,13 @@ int fat_readwrite( struct fat_file *file, int sectorcount, /* find sequential sectors and write them all at once */ for (i=0; (i < sectorcount) && (sector > -1); i++ ) { numsec++; - if ( numsec > (int)fat_bpb.bpb_secperclus || !cluster ) { + if ( numsec > (int)fat_bpb->bpb_secperclus || !cluster ) { int oldcluster = cluster; if (write) cluster = next_write_cluster(file, cluster, §or); else { - cluster = get_next_cluster(cluster); - sector = cluster2sec(cluster); + cluster = get_next_cluster(IF_MV2(fat_bpb,) cluster); + sector = cluster2sec(IF_MV2(fat_bpb,) cluster); } clusternum++; @@ -1902,7 +2052,7 @@ int fat_readwrite( struct fat_file *file, int sectorcount, sector++; else { /* look up first sector of file */ - sector = cluster2sec(file->firstcluster); + sector = cluster2sec(IF_MV2(fat_bpb,) file->firstcluster); numsec=1; } } @@ -1913,7 +2063,7 @@ int fat_readwrite( struct fat_file *file, int sectorcount, if ( ((sector != first) && (sector != last+1)) || /* not sequential */ (last-first+1 == 256) ) { /* max 256 sectors per ata request */ int count = last - first + 1; - rc = transfer( first, count, buf, write ); + rc = transfer(IF_MV2(fat_bpb,) first, count, buf, write ); if (rc < 0) return rc * 10 - 1; @@ -1925,7 +2075,7 @@ int fat_readwrite( struct fat_file *file, int sectorcount, (!eof)) { int count = sector - first + 1; - rc = transfer( first, count, buf, write ); + rc = transfer(IF_MV2(fat_bpb,) first, count, buf, write ); if (rc < 0) return rc * 10 - 2; } @@ -1949,6 +2099,11 @@ int fat_readwrite( struct fat_file *file, int sectorcount, int fat_seek(struct fat_file *file, unsigned int seeksector ) { +#ifdef HAVE_MULTIVOLUME + struct bpb* fat_bpb = &fat_bpbs[file->volume]; +#else + struct bpb* fat_bpb = &fat_bpbs[0]; +#endif int clusternum=0, numclusters=0, sectornum=0, sector=0; int cluster = file->firstcluster; int i; @@ -1958,8 +2113,8 @@ int fat_seek(struct fat_file *file, unsigned int seeksector ) /* we need to find the sector BEFORE the requested, since the file struct stores the last accessed sector */ seeksector--; - numclusters = clusternum = seeksector / fat_bpb.bpb_secperclus; - sectornum = seeksector % fat_bpb.bpb_secperclus; + numclusters = clusternum = seeksector / fat_bpb->bpb_secperclus; + sectornum = seeksector % fat_bpb->bpb_secperclus; if (file->clusternum && clusternum >= file->clusternum) { @@ -1968,7 +2123,7 @@ int fat_seek(struct fat_file *file, unsigned int seeksector ) } for (i=0; i= NUM_VOLUMES || !fat_bpbs[volume].mounted) + { + LDEBUGF("fat_open() illegal volume %d\n", volume); + return -1; + } +#else + struct bpb* fat_bpb = &fat_bpbs[0]; +#endif int rc; dir->entry = 0; @@ -2003,15 +2170,15 @@ int fat_opendir(struct fat_dir *dir, unsigned int startcluster, if (startcluster == 0) { #ifdef HAVE_FAT16SUPPORT - if (fat_bpb.is_fat16) + if (fat_bpb->is_fat16) { /* FAT16 has the root dir outside of the data area */ - return fat_open_root(&dir->file); + return fat_open_root(IF_MV2(volume,) &dir->file); } #endif - startcluster = sec2cluster(fat_bpb.rootdirsector); + startcluster = sec2cluster(IF_MV2(fat_bpb,) fat_bpb->rootdirsector); } - rc = fat_open(startcluster, &dir->file, parent_dir); + rc = fat_open(IF_MV2(volume,) startcluster, &dir->file, parent_dir); if(rc) { DEBUGF( "fat_opendir() - Couldn't open dir" @@ -2196,7 +2363,18 @@ int fat_getnext(struct fat_dir *dir, struct fat_direntry *entry) return 0; } -int fat_get_cluster_size(void) +int fat_get_cluster_size(IF_MV_NONVOID(int volume)) +{ +#ifndef HAVE_MULTIVOLUME + const int volume = 0; +#endif + struct bpb* fat_bpb = &fat_bpbs[volume]; + return fat_bpb->bpb_secperclus * SECTOR_SIZE; +} + +#ifdef HAVE_MULTIVOLUME +bool fat_ismounted(int volume) { - return fat_bpb.bpb_secperclus * SECTOR_SIZE; + return (volume