summaryrefslogtreecommitdiff
path: root/firmware/drivers/fat.c
diff options
context:
space:
mode:
Diffstat (limited to 'firmware/drivers/fat.c')
-rw-r--r--firmware/drivers/fat.c734
1 files changed, 456 insertions, 278 deletions
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; i<NUM_VOLUMES;i++)
+ {
+ fat_bpbs[i].mounted = false;
}
+#endif
+}
+
+int fat_mount(IF_MV2(int volume,) IF_MV2(int drive,) int startsector)
+{
+#ifndef HAVE_MULTIVOLUME
+ const int volume = 0;
+#endif
+ struct bpb* fat_bpb = &fat_bpbs[volume];
+ unsigned char buf[SECTOR_SIZE];
+ int rc;
+ int datasec;
/* Read the sector */
- rc = ata_read_sectors(startsector,1,buf);
+ rc = ata_read_sectors(IF_MV2(drive,) startsector,1,buf);
if(rc)
{
DEBUGF( "fat_mount() - Couldn't read BPB (error code %d)\n", rc);
return rc * 10 - 1;
}
- memset(&fat_bpb, 0, sizeof(struct bpb));
- fat_bpb.startsector = startsector;
-
- 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);
+ memset(fat_bpb, 0, sizeof(struct bpb));
+ fat_bpb->startsector = 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; i<fat_bpb.fatsize; i++) {
+ for (i = 0; i<fat_bpb->fatsize; 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; i<fat_bpb.fatsize; i++) {
+ for (i = 0; i<fat_bpb->fatsize; 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; i<fat_bpb.fatsize; i++) {
+ for (i = 0; i<fat_bpb->fatsize; 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; i<fat_bpb.fatsize; i++) {
+ for (i = 0; i<fat_bpb->fatsize; 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, &sector);
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<numclusters; i++) {
- cluster = get_next_cluster(cluster);
+ cluster = get_next_cluster(IF_MV2(fat_bpb,) cluster);
if (!cluster) {
DEBUGF("Seeking beyond the end of the file! "
"(sector %d, cluster %d)\n", seeksector, i);
@@ -1976,7 +2131,7 @@ int fat_seek(struct fat_file *file, unsigned int seeksector )
}
}
- sector = cluster2sec(cluster) + sectornum;
+ sector = cluster2sec(IF_MV2(fat_bpb,) cluster) + sectornum;
}
else {
sectornum = -1;
@@ -1992,9 +2147,21 @@ int fat_seek(struct fat_file *file, unsigned int seeksector )
return 0;
}
-int fat_opendir(struct fat_dir *dir, unsigned int startcluster,
+int fat_opendir(IF_MV2(int volume,)
+ struct fat_dir *dir, unsigned int startcluster,
const struct fat_dir *parent_dir)
{
+#ifdef HAVE_MULTIVOLUME
+ struct bpb* fat_bpb = &fat_bpbs[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;
+ }
+#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<NUM_VOLUMES && fat_bpbs[volume].mounted);
}
+#endif
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-02 10:38:10 +0000