oneechanhax/phunix
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
phunix/commands/i386/mtools-3.9.7/fat.c
Ben Gras 9865aeaa79 Initial revision
2005-04-21 14:53:53 +00:00

930 lines
21 KiB
C
Executable File
Raw Blame History

#include "sysincludes.h"
#include "msdos.h"
#include "stream.h"
#include "mtools.h"
#include "fsP.h"
extern Stream_t *default_drive;
#ifdef HAVE_LONG_LONG
typedef long long fatBitMask;
#else
typedef long fatBitMask;
#endif
typedef struct FatMap_t {
unsigned char *data;
fatBitMask dirty;
fatBitMask valid;
} FatMap_t;
#define SECT_PER_ENTRY (sizeof(fatBitMask)*8)
#define ONE ((fatBitMask) 1)
static inline int readSector(Fs_t *This, char *buf, unsigned int off,
size_t size)
{
return READS(This->Next, buf, sectorsToBytes((Stream_t *)This, off),
size << This->sectorShift);
}
static inline int forceReadSector(Fs_t *This, char *buf, unsigned int off,
size_t size)
{
return force_read(This->Next, buf, sectorsToBytes((Stream_t *)This, off),
size << This->sectorShift);
}
static inline int writeSector(Fs_t *This, char *buf, unsigned int off,
size_t size)
{
return WRITES(This->Next, buf, sectorsToBytes((Stream_t*)This, off),
size << This->sectorShift);
}
static inline int forceWriteSector(Fs_t *This, char *buf, unsigned int off,
size_t size)
{
return force_write(This->Next, buf, sectorsToBytes((Stream_t*)This, off),
size << This->sectorShift);
}
static FatMap_t *GetFatMap(Fs_t *Stream)
{
int nr_entries,i;
FatMap_t *map;
Stream->fat_error = 0;
nr_entries = (Stream->fat_len + SECT_PER_ENTRY - 1) / SECT_PER_ENTRY;
map = NewArray(nr_entries, FatMap_t);
if(!map)
return 0;
for(i=0; i< nr_entries; i++) {
map[i].data = 0;
map[i].valid = 0;
map[i].dirty = 0;
}
return map;
}
static inline int locate(Fs_t *Stream, int offset, int *slot, int *bit)
{
if(offset >= Stream->fat_len)
return -1;
*slot = offset / SECT_PER_ENTRY;
*bit = offset % SECT_PER_ENTRY;
return 0;
}
static inline int fatReadSector(Fs_t *This, int sector, int slot,
int bit, int dupe)
{
int fat_start, ret;
dupe = (dupe + This->primaryFat) % This->num_fat;
fat_start = This->fat_start + This->fat_len * dupe;
/* first, read as much as the buffer can give us */
ret = readSector(This,
(char *)(This->FatMap[slot].data+(bit<<This->sectorShift)),
fat_start+sector,
(SECT_PER_ENTRY - bit%SECT_PER_ENTRY));
if(ret < 0)
return 0;
if(ret < This->sector_size) {
/* if we got less than one sector's worth, insist to get at
* least one sector */
ret = forceReadSector(This,
(char *) (This->FatMap[slot].data +
(bit << This->sectorShift)),
fat_start+sector, 1);
if(ret < This->sector_size)
return 0;
return 1;
}
return ret >> This->sectorShift;
}
static int fatWriteSector(Fs_t *This, int sector, int slot, int bit, int dupe)
{
int fat_start;
dupe = (dupe + This->primaryFat) % This->num_fat;
if(dupe && !This->writeAllFats)
return This->sector_size;
fat_start = This->fat_start + This->fat_len * dupe;
return forceWriteSector(This,
(char *)
(This->FatMap[slot].data + bit * This->sector_size),
fat_start+sector, 1);
}
static unsigned char *loadSector(Fs_t *This,
unsigned int sector, fatAccessMode_t mode,
int recurs)
{
int slot, bit, i, ret;
if(locate(This,sector, &slot, &bit) < 0)
return 0;
#if 0
if (((This->fat_len + SECT_PER_ENTRY - 1) / SECT_PER_ENTRY) <= slot) {
fprintf(stderr,"This should not happen\n");
fprintf(stderr, "fat_len = %d\n", This->fat_len);
fprintf(stderr, "SECT_PER_ENTRY=%d\n", (int)SECT_PER_ENTRY);
fprintf(stderr, "sector = %d slot = %d bit=%d\n",
sector, slot, bit);
fprintf(stderr, "left = %d",(int)
((This->fat_len+SECT_PER_ENTRY-1) / SECT_PER_ENTRY));
return 0;
}
#endif
if(!This->FatMap[slot].data) {
/* allocate the storage space */
This->FatMap[slot].data =
malloc(This->sector_size * SECT_PER_ENTRY);
if(!This->FatMap[slot].data)
return 0;
memset(This->FatMap[slot].data, 0xee,
This->sector_size * SECT_PER_ENTRY);
}
if(! (This->FatMap[slot].valid & (ONE << bit))) {
ret = -1;
for(i=0; i< This->num_fat; i++) {
/* read the sector */
ret = fatReadSector(This, sector, slot, bit, i);
if(ret == 0) {
fprintf(stderr,
"Error reading fat number %d\n", i);
continue;
}
break;
}
/* all copies bad. Return error */
if(ret == 0)
return 0;
for(i=0; i < ret; i++)
This->FatMap[slot].valid |= ONE << (bit + i);
if(!recurs && ret == 1)
/* do some prefetching, if we happened to only
* get one sector */
loadSector(This, sector+1, mode, 1);
if(!recurs && batchmode)
for(i=0; i < 1024; i++)
loadSector(This, sector+i, mode, 1);
}
if(mode == FAT_ACCESS_WRITE) {
This->FatMap[slot].dirty |= ONE << bit;
This->fat_dirty = 1;
}
return This->FatMap[slot].data + (bit << This->sectorShift);
}
static unsigned char *getAddress(Fs_t *Stream,
unsigned int num, fatAccessMode_t mode)
{
unsigned char *ret;
int sector;
int offset;
sector = num >> Stream->sectorShift;
ret = 0;
if(sector == Stream->lastFatSectorNr &&
Stream->lastFatAccessMode >= mode)
ret = Stream->lastFatSectorData;
if(!ret) {
ret = loadSector(Stream, sector, mode, 0);
if(!ret)
return 0;
Stream->lastFatSectorNr = sector;
Stream->lastFatSectorData = ret;
Stream->lastFatAccessMode = mode;
}
offset = num & Stream->sectorMask;
return ret+offset;
}
static int readByte(Fs_t *Stream, int start)
{
unsigned char *address;
address = getAddress(Stream, start, FAT_ACCESS_READ);
if(!address)
return -1;
return *address;
}
/*
* Fat 12 encoding:
* | byte n | byte n+1 | byte n+2 |
* |7|6|5|4|3|2|1|0|7|6|5|4|3|2|1|0|7|6|5|4|3|2|1|0|
* | | | | | | | | | | | | | | | | | | | | | | | | |
* | n+0.0 | n+0.5 | n+1.0 | n+1.5 | n+2.0 | n+2.5 |
* \_____ \____ \______/________/_____ /
* ____\______\________/ _____/ ____\_/
* / \ \ / / \
* | n+1.5 | n+0.0 | n+0.5 | n+2.0 | n+2.5 | n+1.0 |
* | FAT entry k | FAT entry k+1 |
*/
/*
* Get and decode a FAT (file allocation table) entry. Returns the cluster
* number on success or 1 on failure.
*/
static unsigned int fat12_decode(Fs_t *Stream, unsigned int num)
{
unsigned int start = num * 3 / 2;
int byte0 = readByte(Stream, start);
int byte1 = readByte(Stream, start+1);
if (num < 2 || byte0 < 0 || byte1 < 0 || num > Stream->num_clus+1) {
fprintf(stderr,"[1] Bad address %d\n", num);
return 1;
}
if (num & 1)
return (byte1 << 4) | ((byte0 & 0xf0)>>4);
else
return ((byte1 & 0xf) << 8) | byte0;
}
/*
* Puts a code into the FAT table. Is the opposite of fat_decode(). No
* sanity checking is done on the code. Returns a 1 on error.
*/
static void fat12_encode(Fs_t *Stream, unsigned int num, unsigned int code)
{
int start = num * 3 / 2;
unsigned char *address0 = getAddress(Stream, start, FAT_ACCESS_WRITE);
unsigned char *address1 = getAddress(Stream, start+1, FAT_ACCESS_WRITE);
if (num & 1) {
/* (odd) not on byte boundary */
*address0 = (*address0 & 0x0f) | ((code << 4) & 0xf0);
*address1 = (code >> 4) & 0xff;
} else {
/* (even) on byte boundary */
*address0 = code & 0xff;
*address1 = (*address1 & 0xf0) | ((code >> 8) & 0x0f);
}
}
/*
* Fat 16 encoding:
* | byte n | byte n+1 |
* |7|6|5|4|3|2|1|0|7|6|5|4|3|2|1|0|
* | | | | | | | | | | | | | | | | |
* | FAT entry k |
*/
static unsigned int fat16_decode(Fs_t *Stream, unsigned int num)
{
unsigned char *address = getAddress(Stream, num << 1, FAT_ACCESS_READ);
return _WORD(address);
}
static void fat16_encode(Fs_t *Stream, unsigned int num, unsigned int code)
{
unsigned char *address = getAddress(Stream, num << 1, FAT_ACCESS_WRITE);
set_word(address, code);
}
static unsigned int fast_fat16_decode(Fs_t *Stream, unsigned int num)
{
unsigned short *address =
(unsigned short *) getAddress(Stream, num << 1,
FAT_ACCESS_READ);
return *address;
}
static void fast_fat16_encode(Fs_t *Stream, unsigned int num, unsigned int code)
{
unsigned short *address =
(unsigned short *) getAddress(Stream, num << 1,
FAT_ACCESS_WRITE);
*address = code;
}
/*
* Fat 32 encoding
*/
static unsigned int fat32_decode(Fs_t *Stream, unsigned int num)
{
unsigned char *address = getAddress(Stream, num << 2, FAT_ACCESS_READ);
return _DWORD(address);
}
static void fat32_encode(Fs_t *Stream, unsigned int num, unsigned int code)
{
unsigned char *address = getAddress(Stream, num << 2, FAT_ACCESS_WRITE);
set_dword(address, code);
}
static unsigned int fast_fat32_decode(Fs_t *Stream, unsigned int num)
{
unsigned int *address =
(unsigned int *) getAddress(Stream, num << 2,
FAT_ACCESS_READ);
return *address;
}
static void fast_fat32_encode(Fs_t *Stream, unsigned int num, unsigned int code)
{
unsigned int *address =
(unsigned int *) getAddress(Stream, num << 2,
FAT_ACCESS_WRITE);
*address = code;
}
/*
* Write the FAT table to the disk. Up to now the FAT manipulation has
* been done in memory. All errors are fatal. (Might not be too smart
* to wait till the end of the program to write the table. Oh well...)
*/
void fat_write(Fs_t *This)
{
int i, j, dups, ret, bit, slot;
int fat_start;
/*fprintf(stderr, "Fat write\n");*/
if (!This->fat_dirty)
return;
dups = This->num_fat;
if (This->fat_error)
dups = 1;
for(i=0; i<dups; i++){
j = 0;
fat_start = This->fat_start + i*This->fat_len;
for(slot=0;j<This->fat_len;slot++) {
if(!This->FatMap[slot].dirty) {
j += SECT_PER_ENTRY;
continue;
}
for(bit=0;
bit < SECT_PER_ENTRY && j<This->fat_len;
bit++,j++) {
if(!(This->FatMap[slot].dirty & (ONE << bit)))
continue;
ret = fatWriteSector(This,j,slot, bit, i);
if (ret < This->sector_size){
if (ret < 0 ){
perror("error in fat_write");
exit(1);
} else {
fprintf(stderr,
"end of file in fat_write\n");
exit(1);
}
}
/* if last dupe, zero it out */
if(i==dups-1)
This->FatMap[slot].dirty &= ~(1<<bit);
}
}
}
/* write the info sector, if any */
if(This->infoSectorLoc && This->infoSectorLoc != MAX32) {
/* initialize info sector */
InfoSector_t *infoSector;
infoSector = (InfoSector_t *) safe_malloc(This->sector_size);
set_dword(infoSector->signature1, INFOSECT_SIGNATURE1);
memset(infoSector->filler1, sizeof(infoSector->filler1),0);
memset(infoSector->filler2, sizeof(infoSector->filler2),0);
set_dword(infoSector->signature2, INFOSECT_SIGNATURE2);
set_dword(infoSector->pos, This->last);
set_dword(infoSector->count, This->freeSpace);
set_dword(infoSector->signature3, 0xaa55);
if(forceWriteSector(This, (char *)infoSector, This->infoSectorLoc, 1) !=
This->sector_size)
fprintf(stderr,"Trouble writing the info sector\n");
free(infoSector);
}
This->fat_dirty = 0;
This->lastFatAccessMode = FAT_ACCESS_READ;
}
/*
* Zero-Fat
* Used by mformat.
*/
int zero_fat(Fs_t *Stream, int media_descriptor)
{
int i, j;
int fat_start;
unsigned char *buf;
buf = malloc(Stream->sector_size);
if(!buf) {
perror("alloc fat sector buffer");
return -1;
}
for(i=0; i< Stream->num_fat; i++) {
fat_start = Stream->fat_start + i*Stream->fat_len;
for(j = 0; j < Stream->fat_len; j++) {
if(j <= 1)
memset(buf, 0, Stream->sector_size);
if(!j) {
buf[0] = media_descriptor;
buf[2] = buf[1] = 0xff;
if(Stream->fat_bits > 12)
buf[3] = 0xff;
if(Stream->fat_bits > 16) {
buf[4] = 0xff;
buf[5] = 0xff;
buf[6] = 0xff;
buf[7] = 0x0f;
}
}
if(forceWriteSector(Stream, (char *)buf,
fat_start + j, 1) !=
Stream->sector_size) {
fprintf(stderr,
"Trouble initializing a FAT sector\n");
free(buf);
return -1;
}
}
}
free(buf);
Stream->FatMap = GetFatMap(Stream);
if (Stream->FatMap == NULL) {
perror("alloc fat map");
return -1;
}
return 0;
}
void set_fat12(Fs_t *This)
{
This->fat_bits = 12;
This->end_fat = 0xfff;
This->last_fat = 0xff6;
This->fat_decode = fat12_decode;
This->fat_encode = fat12_encode;
}
static char word_endian_test[] = { 0x34, 0x12 };
void set_fat16(Fs_t *This)
{
This->fat_bits = 16;
This->end_fat = 0xffff;
This->last_fat = 0xfff6;
if(sizeof(unsigned short) == 2 &&
* (unsigned short *) word_endian_test == 0x1234) {
This->fat_decode = fast_fat16_decode;
This->fat_encode = fast_fat16_encode;
} else {
This->fat_decode = fat16_decode;
This->fat_encode = fat16_encode;
}
}
static char dword_endian_test[] = { 0x78, 0x56, 0x34, 0x12 };
void set_fat32(Fs_t *This)
{
This->fat_bits = 32;
This->end_fat = 0xfffffff;
This->last_fat = 0xffffff6;
if(sizeof(unsigned int) == 4 &&
* (unsigned int *) dword_endian_test == 0x12345678) {
This->fat_decode = fast_fat32_decode;
This->fat_encode = fast_fat32_encode;
} else {
This->fat_decode = fat32_decode;
This->fat_encode = fat32_encode;
}
}
static int check_fat(Fs_t *This)
{
/*
* This is only a sanity check. For disks with really big FATs,
* there is no point in checking the whole FAT.
*/
int i, f, tocheck;
if(mtools_skip_check)
return 0;
/* too few sectors in the FAT */
if(This->fat_len < NEEDED_FAT_SIZE(This))
return -1;
/* we do not warn about too much sectors in FAT, which may
* happen when a partition has been shrunk using FIPS, or on
* other occurrences */
tocheck = This->num_clus;
if (tocheck < 0 || tocheck + 1 >= This->last_fat) {
fprintf(stderr, "Too many clusters in FAT\n");
return -1;
}
if(tocheck > 4096)
tocheck = 4096;
for ( i= 3 ; i < tocheck; i++){
f = This->fat_decode(This,i);
if (f == 1 || (f < This->last_fat && f > This->num_clus)){
fprintf(stderr,
"Cluster # at %d too big(%#x)\n", i,f);
fprintf(stderr,"Probably non MS-DOS disk\n");
return -1;
}
}
return 0;
}
/*
* Read the first sector of FAT table into memory. Crude error detection on
* wrong FAT encoding scheme.
*/
static int check_media_type(Fs_t *This, struct bootsector *boot,
unsigned int tot_sectors)
{
unsigned char *address;
This->num_clus = (tot_sectors - This->clus_start) / This->cluster_size;
This->FatMap = GetFatMap(This);
if (This->FatMap == NULL) {
perror("alloc fat map");
return -1;
}
address = getAddress(This, 0, FAT_ACCESS_READ);
if(!address) {
fprintf(stderr,
"Could not read first FAT sector\n");
return -1;
}
if(mtools_skip_check)
return 0;
if(!address[0] && !address[1] && !address[2])
/* Some Atari disks have zeroes where Dos has media descriptor
* and 0xff. Do not consider this as an error */
return 0;
if((address[0] != boot->descr && boot->descr >= 0xf0 &&
((address[0] != 0xf9 && address[0] != 0xf7)
|| boot->descr != 0xf0)) || address[0] < 0xf0) {
fprintf(stderr,
"Bad media types %02x/%02x, probably non-MSDOS disk\n",
address[0],
boot->descr);
return -1;
}
if(address[1] != 0xff || address[2] != 0xff){
fprintf(stderr,"Initial byte of fat is not 0xff\n");
return -1;
}
return 0;
}
static int fat_32_read(Fs_t *This, struct bootsector *boot,
unsigned int tot_sectors)
{
int size;
This->fat_len = DWORD(ext.fat32.bigFat);
This->writeAllFats = !(boot->ext.fat32.extFlags[0] & 0x80);
This->primaryFat = boot->ext.fat32.extFlags[0] & 0xf;
This->rootCluster = DWORD(ext.fat32.rootCluster);
This->clus_start = This->fat_start + This->num_fat * This->fat_len;
/* read the info sector */
size = This->sector_size;
This->infoSectorLoc = WORD(ext.fat32.infoSector);
if(This->sector_size >= 512 &&
This->infoSectorLoc && This->infoSectorLoc != MAX32) {
InfoSector_t *infoSector;
infoSector = (InfoSector_t *) safe_malloc(size);
if(forceReadSector(This, (char *)infoSector,
This->infoSectorLoc, 1) == This->sector_size &&
_DWORD(infoSector->signature1) == INFOSECT_SIGNATURE1 &&
_DWORD(infoSector->signature2) == INFOSECT_SIGNATURE2) {
This->freeSpace = _DWORD(infoSector->count);
This->last = _DWORD(infoSector->pos);
}
free(infoSector);
}
set_fat32(This);
return(check_media_type(This,boot, tot_sectors) ||
check_fat(This));
}
static int old_fat_read(Fs_t *This, struct bootsector *boot,
int config_fat_bits,
size_t tot_sectors, int nodups)
{
This->writeAllFats = 1;
This->primaryFat = 0;
This->dir_start = This->fat_start + This->num_fat * This->fat_len;
This->clus_start = This->dir_start + This->dir_len;
This->infoSectorLoc = MAX32;
if(nodups)
This->num_fat = 1;
if(check_media_type(This,boot, tot_sectors))
return -1;
if(This->num_clus > FAT12) {
set_fat16(This);
/* third FAT byte must be 0xff */
if(!mtools_skip_check && readByte(This, 3) != 0xff)
return -1;
} else
set_fat12(This);
return check_fat(This);
}
/*
* Read the first sector of the FAT table into memory and initialize
* structures.
*/
int fat_read(Fs_t *This, struct bootsector *boot, int fat_bits,
size_t tot_sectors, int nodups)
{
This->fat_error = 0;
This->fat_dirty = 0;
This->last = MAX32;
This->freeSpace = MAX32;
This->lastFatSectorNr = 0;
This->lastFatSectorData = 0;
if(This->fat_len)
return old_fat_read(This, boot, fat_bits, tot_sectors, nodups);
else
return fat_32_read(This, boot, tot_sectors);
}
unsigned int fatDecode(Fs_t *This, unsigned int pos)
{
int ret;
ret = This->fat_decode(This, pos);
if(ret && (ret < 2 || ret > This->num_clus+1) && ret < This->last_fat) {
fprintf(stderr, "Bad FAT entry %d at %d\n", ret, pos);
This->fat_error++;
}
return ret;
}
/* append a new cluster */
void fatAppend(Fs_t *This, unsigned int pos, unsigned int newpos)
{
This->fat_encode(This, pos, newpos);
This->fat_encode(This, newpos, This->end_fat);
if(This->freeSpace != MAX32)
This->freeSpace--;
}
/* de-allocates the given cluster */
void fatDeallocate(Fs_t *This, unsigned int pos)
{
This->fat_encode(This, pos, 0);
if(This->freeSpace != MAX32)
This->freeSpace++;
}
/* allocate a new cluster */
void fatAllocate(Fs_t *This, unsigned int pos, unsigned int value)
{
This->fat_encode(This, pos, value);
if(This->freeSpace != MAX32)
This->freeSpace--;
}
void fatEncode(Fs_t *This, unsigned int pos, unsigned int value)
{
unsigned int oldvalue = This->fat_decode(This, pos);
This->fat_encode(This, pos, value);
if(This->freeSpace != MAX32) {
if(oldvalue)
This->freeSpace++;
if(value)
This->freeSpace--;
}
}
unsigned int get_next_free_cluster(Fs_t *This, unsigned int last)
{
int i;
if(This->last != MAX32)
last = This->last;
if (last < 2 ||
last >= This->num_clus+1)
last = 1;
for (i=last+1; i< This->num_clus+2; i++) {
if (!fatDecode(This, i)) {
This->last = i;
return i;
}
}
for(i=2; i < last+1; i++) {
if (!fatDecode(This, i)) {
This->last = i;
return i;
}
}
fprintf(stderr,"No free cluster %d %d\n", This->preallocatedClusters,
This->last);
return 1;
}
int fat_error(Stream_t *Dir)
{
Stream_t *Stream = GetFs(Dir);
DeclareThis(Fs_t);
if(This->fat_error)
fprintf(stderr,"Fat error detected\n");
return This->fat_error;
}
int fat32RootCluster(Stream_t *Dir)
{
Stream_t *Stream = GetFs(Dir);
DeclareThis(Fs_t);
if(This->fat_bits == 32)
return This->rootCluster;
else
return 0;
}
/*
* Get the amount of free space on the diskette
*/
mt_size_t getfree(Stream_t *Dir)
{
Stream_t *Stream = GetFs(Dir);
DeclareThis(Fs_t);
if(This->freeSpace == MAX32 || This->freeSpace == 0) {
register unsigned int i;
size_t total;
total = 0L;
for (i = 2; i < This->num_clus + 2; i++)
if (!fatDecode(This,i))
total++;
This->freeSpace = total;
}
return sectorsToBytes((Stream_t*)This,
This->freeSpace * This->cluster_size);
}
/*
* Ensure that there is a minimum of total sectors free
*/
int getfreeMinClusters(Stream_t *Dir, size_t size)
{
Stream_t *Stream = GetFs(Dir);
DeclareThis(Fs_t);
register unsigned int i, last;
size_t total;
if(batchmode && This->freeSpace == MAX32)
getfree(Stream);
if(This->freeSpace != MAX32) {
if(This->freeSpace >= size)
return 1;
else {
fprintf(stderr, "Disk full\n");
got_signal = 1;
return 0;
}
}
total = 0L;
/* we start at the same place where we'll start later to actually
* allocate the sectors. That way, the same sectors of the FAT, which
* are already loaded during getfreeMin will be able to be reused
* during get_next_free_cluster */
last = This->last;
if ( last < 2 || last >= This->num_clus + 2)
last = 1;
for (i=last+1; i< This->num_clus+2; i++){
if (!fatDecode(This, i))
total++;
if(total >= size)
return 1;
}
for(i=2; i < last+1; i++){
if (!fatDecode(This, i))
total++;
if(total >= size)
return 1;
}
fprintf(stderr, "Disk full\n");
got_signal = 1;
return 0;
}
int getfreeMinBytes(Stream_t *Dir, mt_size_t size)
{
Stream_t *Stream = GetFs(Dir);
DeclareThis(Fs_t);
size_t size2;
size2 = size / (This->sector_size * This->cluster_size);
if(size % (This->sector_size * This->cluster_size))
size2++;
return getfreeMinClusters(Dir, size2);
}
unsigned int getStart(Stream_t *Dir, struct directory *dir)
{
Stream_t *Stream = GetFs(Dir);
unsigned int first;
first = START(dir);
if(fat32RootCluster(Stream))
first |= STARTHI(dir) << 16;
return first;
}
int fs_free(Stream_t *Stream)
{
DeclareThis(Fs_t);
if(This->FatMap) {
int i, nr_entries;
nr_entries = (This->fat_len + SECT_PER_ENTRY - 1) /
SECT_PER_ENTRY;
for(i=0; i< nr_entries; i++)
if(This->FatMap[i].data)
free(This->FatMap[i].data);
free(This->FatMap);
}
return 0;
}
Reference in New Issue View Git Blame Copy Permalink