|
|
/*******************************************************************************
* * * M-Systems Confidential * * Copyright (C) M-Systems Flash Disk Pioneers Ltd. 1995-2001 * * All Rights Reserved * * * ******************************************************************************* * * * NOTICE OF M-SYSTEMS OEM * * SOFTWARE LICENSE AGREEMENT * * * * THE USE OF THIS SOFTWARE IS GOVERNED BY A SEPARATE LICENSE AGREEMENT * * BETWEEN THE OEM AND M-SYSTEMS. REFER TO THAT AGREEMENT FOR THE SPECIFIC * * TERMS AND CONDITIONS OF USE, OR CONTACT M-SYSTEMS FOR LICENSE * * ASSISTANCE: * * E-MAIL = info@m-sys.com * * * ******************************************************************************* * * * * * Module: FATFILT * * * * This module implements installable FAT12/16 filters. It supports up to * * SOCKETS sockets, with up to MAX_TL_PARTITIONS disks per socket. * * Each disk can contain up to FL_MAX_PARTS_PER_DISK partitions on it, with * * maximum depth of partition nesting in extended partitions equal to * * MAX_PARTITION_DEPTH. * * * * In order for this module to work, disks must be abs.mounted rather then * * mounted. In latter case, this module won't detect any of disk's * * partitions, and won't install FAT filters. * * * * This module uses more then 512 bytes of stack space in case if MALLOC is * * not enabled. * * * *******************************************************************************/
/*
* $Log: V:/Flite/archives/TrueFFS5/Src/FATFILT.C_V $ * * Rev 1.10 Jan 17 2002 23:00:14 oris * Changed debug print added \r. * * Rev 1.9 Sep 15 2001 23:45:50 oris * Changed BIG_ENDIAN to FL_BIG_ENDIAN * * Rev 1.8 Jun 17 2001 16:39:10 oris * Improved documentation and remove warnings. * * Rev 1.7 May 16 2001 21:17:18 oris * Added the FL_ prefix to the following defines: MALLOC and FREE. * * Rev 1.6 May 01 2001 14:21:02 oris * Remove warnings. * * Rev 1.5 Apr 30 2001 18:00:10 oris * Added casting to remove warrnings. * * Rev 1.4 Apr 24 2001 17:07:32 oris * Missing casting of MALLOC calls. * * Rev 1.3 Apr 10 2001 23:54:24 oris * FL_MAX_DISKS_PER_SOCKET changed to MAX_TL_PARTITIONS. * * Rev 1.2 Apr 09 2001 15:00:42 oris * Change static allocation to dynamic allocations. * Renamed flffCheck back to ffCheckBeforeWrite to be backwards compatible with OSAK 4.2. * * Rev 1.1 Apr 01 2001 07:51:16 oris * New implementation of fat filter. * * Rev 1.0 19 Feb 2001 21:14:14 andreyk * Initial revision. */
/*
* Includes */
#include "fatfilt.h"
#include "blockdev.h"
#include "flflash.h"
#include "bddefs.h"
#if defined(ABS_READ_WRITE) && !defined(FL_READ_ONLY)
/*
* Module configuration */
#define FL_INCLUDE_FAT_MONITOR /* undefine it to remove FAT filter code */
/*
* Defines */
/* extract pointer to user's buffer from IOreq */
#ifdef SCATTER_GATHER
#define FLBUF(ioreq,i) (*((char FAR1 **)((ioreq)->irData) + (int)(i)))
#else
#define FLBUF(ioreq,i) ((char FAR1 *)(ioreq->irData) + (SECTOR_SIZE * ((int)(i))))
#endif
/* extract socket# and disk# from TFFS handle */
#define H2S(handle) (((int)(handle)) & 0xf)
#define H2D(handle) ((((int)(handle)) >> 4) & 0xf)
/* construct TFFS handle from socket# and disk# */
#define SD2H(socNo,diskNo) ((int)((((diskNo) & 0xf) << 4) | ((socNo) & 0xf)))
/* unformatted ("raw") disk partition */
#define FL_RAW_PART (-1)
/*
* Local routines */
static FLStatus reset (void);static FLStatus discardDisk (int handle);static FLStatus newDisk (int handle);static FLStatus parseDisk (int handle);static FLStatus discardDiskParts (FLffDisk *pd);static FLStatus addDiskPart (FLffDisk *pd, int partNo);static FLStatus addNewDiskPart (FLffDisk *pd);static FLBoolean isPartTableWrite (FLffDisk *pd, IOreq FAR2 *ioreq);static FLStatus isExtPartPresent (char FAR1 *buf, SectorNo *nextExtPartSec);
#ifdef FL_INCLUDE_FAT_MONITOR
static FLStatus partEnableFF (FLffVol* pv);static FLStatus partFreeDelClusters (FLffVol *pv, SectorNo secNo, char FAR1 *newFAT);
#endif
/*
* Local data */
/* module reset flag */
static FLBoolean resetDone = FALSE;
/* disks (BDTL partitions in OSAK terminology) */
static FLffDisk* ffDisk[SOCKETS][MAX_TL_PARTITIONS] = { { NULL } };
#ifndef FL_MALLOC
/*
* WARNING: Large static arrays ! * * sizeof(ffAllDisks[x][y]) is 64 bytes. * sizeof(ffAllParts[x][y][z]) is 40 bytes. * */
static FLffDisk ffAllDisks[SOCKETS][MAX_TL_PARTITIONS];static FLffVol ffAllParts[SOCKETS][MAX_TL_PARTITIONS][FL_MAX_PARTS_PER_DISK];
#endif /* FL_MALLOC */
static const char zeroes[SECTOR_SIZE] = {0};
/* --------------------------------------------------------------------------- *
* * * d i s c a r d D i s k P a r t s * * * * Discard all the partition info (if any) associated with particular disk. * * * * Parameters: * * pd : disk (BDTL volume) * * * * Returns: * * Always flOK. * * * * --------------------------------------------------------------------------- */
static FLStatus discardDiskParts ( FLffDisk * pd ){ register int i;
if (pd != NULL) {
for (i = 0; i < FL_MAX_PARTS_PER_DISK; i++) {
#ifdef FL_MALLOC
if (pd->part[i] != NULL) FL_FREE(pd->part[i]);#endif
pd->part[i] = NULL; }
pd->parts = 0; }
return flOK;}
/* --------------------------------------------------------------------------- *
* * * a d d D i s k P a r t * * * * If there is partition record #partNo associated with the disk, discard * * this info. Attach new partition record #partNo. * * * * Parameters: * * pd : disk (BDTL volume) * * partNo : partition (0 ... FL_MAX_PARTS_PER_DISK-1) * * * * Returns: * * flOK if success, otherwise respective error code * * * * --------------------------------------------------------------------------- */
static FLStatus addDiskPart ( FLffDisk * pd, int partNo ){ FLffVol * pv; FLStatus status; int socNo, diskNo;
/* arg. sanity check */
if ((pd == NULL) || (partNo >= FL_MAX_PARTS_PER_DISK)) return flBadDriveHandle;
/* break TFFS handle into socket# and disk#, and do sanity check */
socNo = H2S(pd->handle); diskNo = H2D(pd->handle); if ((socNo >= SOCKETS) || (diskNo >= MAX_TL_PARTITIONS)) return flBadDriveHandle;
status = flNotEnoughMemory;
#ifdef FL_MALLOC
pv = (FLffVol *)FL_MALLOC( sizeof(FLffVol) );#else
pv = &ffAllParts[socNo][diskNo][partNo];#endif
if (pv != NULL) {
/* initialize fields in struct FLffDisk to safe values */ pv->handle = pd->handle; pv->type = FL_RAW_PART; pv->flags = 0; pv->ffEnabled = FALSE; /* turn off FAT minitor */ pv->sectors = (SectorNo) 0; pv->firstFATsecNo = (SectorNo) -1; /* none */ pv->lastFATsecNo = pv->firstFATsecNo; /* none */ pv->firstDataSecNo = (SectorNo) 0; pv->clusterSize = (unsigned) 0;
#ifdef FL_MALLOC
if( pd->part[partNo] != NULL ) FL_FREE(pd->part[partNo]);#endif
pd->part[partNo] = pv;
status = flOK; }
return status; }
/* --------------------------------------------------------------------------- *
* * * a d d N e w D i s k P a r t * * * * Add one more partition record to the disk. * * * * Parameters: * * pd : disk (BDTL volume) * * * * Returns: * * flOK if success, otherwise respective error code * * * * --------------------------------------------------------------------------- */
static FLStatus addNewDiskPart ( FLffDisk * pd ){ if (pd->parts < FL_MAX_PARTS_PER_DISK) {
checkStatus( addDiskPart (pd, pd->parts) ); pd->parts++; }
return flOK;}
/* --------------------------------------------------------------------------- *
* * * d i s c a r d D i s k * * * * Remove disk record (with all the associated partition records). * * * * Parameters: * * handle : TFFS handle * * * * Returns: * * flOK if success, otherwise respective error code * * * * --------------------------------------------------------------------------- */
static FLStatus discardDisk ( int handle ){ int socNo, diskNo;
/* break TFFS handle into socket# and disk#, and do sanity check */
socNo = H2S(handle); diskNo = H2D(handle); if ((socNo >= SOCKETS) || (diskNo >= MAX_TL_PARTITIONS)) return flBadDriveHandle;
if( ffDisk[socNo][diskNo] != NULL ) {
/* discard associated partition info */
(void) discardDiskParts( ffDisk[socNo][diskNo] );
#ifdef FL_MALLOC
/* release disk's scratch buffer */ if( (ffDisk[socNo][diskNo])->buf != NULL) FL_FREE( (ffDisk[socNo][diskNo])->buf );
FL_FREE( ffDisk[socNo][diskNo] );
#endif
ffDisk[socNo][diskNo] = NULL; }
return flOK; }
/* --------------------------------------------------------------------------- *
* * * n e w D i s k * * * * Discard existing disk record (if any), and create new one. * * * * Parameters: * * handle : TFFS handle * * * * Returns: * * flOK if success, otherwise respective error code * * * * --------------------------------------------------------------------------- */
static FLStatus newDisk ( int handle ){ int socNo, diskNo; int i; FLffDisk * pd;
/* break TFFS handle into socket# and disk#, and do sanity check */
socNo = H2S(handle); diskNo = H2D(handle); if ((socNo >= SOCKETS) || (diskNo >= MAX_TL_PARTITIONS)) return flBadDriveHandle;
/* discard current disk and associated partition info (if any) */
checkStatus( discardDisk(handle) );
#ifdef FL_MALLOC
pd = (FLffDisk *) FL_MALLOC( sizeof(FLffDisk) );
if (pd == NULL) return flNotEnoughMemory;
/* allocate and attach disk's scratch buffer */
pd->buf = (char *)FL_MALLOC( SECTOR_SIZE );
if (pd->buf == NULL) {
FL_FREE (pd); return flNotEnoughMemory; }
#else /* !FL_MALLOC */
pd = &ffAllDisks[socNo][diskNo];
#endif /* FL_MALLOC */
pd->handle = handle; pd->ffstate = flStateNotInitialized;
/* don't know partition layout yet */
pd->parts = 0; for (i = 0; i < FL_MAX_PARTS_PER_DISK; i++) pd->part[i] = NULL;
/* watch Master Boot Record for update */
pd->secToWatch = (SectorNo) 0;
ffDisk[socNo][diskNo] = pd;
return flOK;}
/* --------------------------------------------------------------------------- *
* * * i s P a r t T a b l e W r i t e * * * * Check if any of the sectors specified by 'ioreq' points to Master Boot * * Record or next extended partition in the extended partitions list. * * * * Parameters: * * pd : pointer to disk structure * * ioreq : standard I/O request * * * * Returns: * * TRUE if write to MBR or extended partition list is detected, otherwise * * FALSE * * * * --------------------------------------------------------------------------- */
static FLBoolean isPartTableWrite ( FLffDisk * pd, IOreq FAR2 * ioreq ){ register long i;
if (pd != NULL) {
for (i = (long)0; i < ioreq->irSectorCount; i++) {
if( (ioreq->irSectorNo + i) == (long)pd->secToWatch ) return TRUE; } }
return FALSE;}
/* --------------------------------------------------------------------------- *
* * * i s E x t P a r t P r e s e n t * * * * Check if extended partition persent in the partition table. If it is, * * calculate the sector # where next partition table will be written to. * * * * Parameters: * * buf : partition table * * nextExtPartSec : sector where next partition table will be written to * * * * Returns: * * flOK on success, otherwise error code * * * * --------------------------------------------------------------------------- */
static FLStatus isExtPartPresent ( char FAR1 * buf, SectorNo * nextExtPartSec ){ Partition FAR1 * p; register int i; /* does it look like partition table ? */
if (LE2(((PartitionTable FAR1 *) buf)->signature) != PARTITION_SIGNATURE) return flBadFormat;
/* if extended. part. present, get sector# that will contain next part. in list */
p = &( ((PartitionTable FAR1 *) buf)->ptEntry[0] );
for (i = 0; i < FL_PART_TBL_ENTRIES; i++, p++) {
if (p->type == EX_PARTIT) {
*nextExtPartSec = (SectorNo) UNAL4( (void *) p[i].startingSectorOfPartition ); return flOK; } }
/* no extended partition found */
return flFileNotFound;}
/* --------------------------------------------------------------------------- *
* * * r e s e t * * * * Resets this software module to it's initial state upon boot. * * * * Parameters: * * none * * * * Returns: * * flOK in case of success, otherwise respective error code * * * * --------------------------------------------------------------------------- */
static FLStatus reset (void){ int iSoc, iDisk;
for (iSoc = 0; iSoc < SOCKETS; iSoc++) {
/* discard existing disk structures for that socket */
for (iDisk = 0; iDisk < MAX_TL_PARTITIONS; iDisk++) (void) discardDisk( SD2H(iSoc, iDisk) );
/* pre-allocate disk structure for first disk of every socket */
checkStatus( newDisk(SD2H(iSoc, 0)) ); }
resetDone = TRUE;
return flOK;}
/* --------------------------------------------------------------------------- *
* * * p a r s e D i s k * * * * Read partition table(s), install and enable FAT filters on all FAT12/16 * * partitions. * * * * Parameters: * * handle : TFFS handle * * * * Returns: * * flOK on success, otherwise error code * * * * NOTE: This routine uses disk's scratch buffer. * * * * --------------------------------------------------------------------------- */
static FLStatus parseDisk ( int handle ){ int socNo, diskNo; SectorNo extPartStartSec, sec; int i, depth; int type; FLffDisk * pd; FLffVol * pv; Partition * pp; IOreq ioreq;
#ifdef FL_MALLOC
char * buf;#else
char buf[SECTOR_SIZE];#endif
/* break TFFS handle into socket# and disk#, and do sanity check */
socNo = H2S(handle); diskNo = H2D(handle); if ((socNo >= ((int) noOfSockets)) || (diskNo >= MAX_TL_PARTITIONS)) return flBadDriveHandle;
/* if disk structure hasn't been allocated yet, do it now */
if (ffDisk[socNo][diskNo] == NULL) checkStatus( newDisk(handle) );
pd = ffDisk[socNo][diskNo]; #ifdef FL_MALLOC
/* make sure scratch buffer is available */
if (pd->buf == NULL) return flBufferingError;
buf = pd->buf;
#endif /* FL_MALLOC */
/* discard obsolete disk's partition info */
(void) discardDiskParts (pd);
/* read Master Boot Record */
ioreq.irHandle = handle; ioreq.irSectorNo = (SectorNo) 0; ioreq.irSectorCount = (SectorNo) 1; ioreq.irData = (void FAR1 *) buf; checkStatus( flAbsRead(&ioreq) );
/* is it MBR indeed ? */
if (LE2(((PartitionTable *) buf)->signature) != PARTITION_SIGNATURE) return flPartitionNotFound;
/* do primary partitions only (we will do extended partitions later) */
pp = &( ((PartitionTable *) buf)->ptEntry[0] );
for (i = 0; i < FL_PART_TBL_ENTRIES; i++, pp++) {
if( pp->type == ((char)0) ) /* skip empty slot */ continue;
if( pp->type == ((char)EX_PARTIT) ) /* skip extended partition */ continue;
/* primary partition found (not necessarily FAT12/16) */
if( addNewDiskPart(pd) != flOK ) break;
pv = pd->part[pd->parts - 1];
/* remember partition's type, and where it starts */
pv->type = (int) pp->type; pv->startSecNo = (SectorNo) UNAL4( (void *) pp->startingSectorOfPartition ); }
/* do extended partitions in depth */
for (i = 0; i < FL_PART_TBL_ENTRIES; i++) {
/* re-read Master Boot Record */
ioreq.irHandle = handle; ioreq.irSectorNo = (SectorNo) 0; ioreq.irSectorCount = (SectorNo) 1; ioreq.irData = (void FAR1 *) buf; checkStatus( flAbsRead(&ioreq) );
/* is it MBR indeed ? */
if (LE2(((PartitionTable *) buf)->signature) != PARTITION_SIGNATURE) return flOK;
/* pick up next extended partition in MBR */
pp = &( ((PartitionTable *) buf)->ptEntry[i] );
if( pp->type == ((char)EX_PARTIT) ) {
/* remember where extended partition starts */
extPartStartSec = (SectorNo) UNAL4( (void *) pp->startingSectorOfPartition );
/* follow the list of partition tables */
sec = extPartStartSec;
for (depth = 0; depth < MAX_PARTITION_DEPTH; depth++) {
/* read next partition table in the list */
ioreq.irHandle = handle; ioreq.irSectorNo = sec; ioreq.irSectorCount = (SectorNo) 1; ioreq.irData = (void FAR1 *) buf; checkStatus( flAbsRead(&ioreq) );
/* is it valid partition table ? */
if (LE2(((PartitionTable *) buf)->signature) != PARTITION_SIGNATURE) break;
/* if 1st entry is zero, it's the end of part. table list */
pp = &( ((PartitionTable *) buf)->ptEntry[0] ); if( pp->type == ((char)0) ) break;
/* Take this partition. Remember it's type, and where it starts */
if( addNewDiskPart(pd) != flOK ) break;
pv = pd->part[pd->parts - 1];
pv->type = (int) pp->type; pv->startSecNo = (SectorNo) UNAL4( (void *) pp->startingSectorOfPartition) + sec;
/* 2nd entry must be extended partition */
pp = &( ((PartitionTable *) buf)->ptEntry[1] ); if( pp->type != ((char)EX_PARTIT) ) break;
/* sector where next part. table in the list resides */
sec = extPartStartSec + (SectorNo) UNAL4( (void *) pp->startingSectorOfPartition );
} /* for(depth) */ } } /* for(i) */
#ifdef FL_INCLUDE_FAT_MONITOR
/* turn on FAT filters on FAT12/16 partition(s) */
if (pd->parts > 0) {
for (i = 0; i < pd->parts; i++) {
pv = pd->part[i]; type = pv->type;
/*
* WARNING : Routine partEnableFF() uses disk's scratch buffer ! */
if((type == FAT12_PARTIT) || (type == FAT16_PARTIT) || (type == DOS4_PARTIT)) partEnableFF (pv); } }
#endif /* FL_INCLUDE_FAT_MONITOR */
/* watch for MBR (sector #0) update */
pd->secToWatch = (SectorNo) 0;
pd->ffstate = flStateInitialized;
return flOK;}
#ifdef FL_INCLUDE_FAT_MONITOR
/* --------------------------------------------------------------------------- *
* * * p a r t E n a b l e F F * * * * Installs and enables FAT filter on partition. * * * * Parameters: * * pv : disk partition (filesystem volume) * * * * Returns: * * flOK on success, otherwise error code * * * * NOTE: This routine uses disk's scratch buffer. * * * * --------------------------------------------------------------------------- */
static FLStatus partEnableFF ( FLffVol * pv ){ int socNo, diskNo; FLffDisk * pd; BPB * bpb; SectorNo sectors; SectorNo rootDirSecNo; SectorNo rootDirSectors; SectorNo sectorsPerFAT; unsigned maxCluster; int partNo; IOreq ioreq;
#ifdef FL_MALLOC
char * buf;#else
char buf[SECTOR_SIZE];#endif
/* arg. sanity check */
if (pv == NULL) return flBadDriveHandle; /* break TFFS handle into socket# and disk#, and do sanity check */
socNo = H2S(pv->handle); diskNo = H2D(pv->handle); if ((socNo >= ((int) noOfSockets)) || (diskNo >= MAX_TL_PARTITIONS)) return flBadDriveHandle;
/* check if 'pv' belongs to this disk */
pd = ffDisk[socNo][diskNo];
if (pd == NULL) return flBadDriveHandle;
for (partNo = 0; partNo < pd->parts; partNo++) {
if (pd->part[partNo] == pv) break; }
if (partNo >= pd->parts) return flBadDriveHandle;
#ifdef FL_MALLOC
/* make sure scratch buffer is available */
if (pd->buf == NULL) return flBufferingError;
buf = pd->buf; #endif /* FL_MALLOC */
/* make sure FAT filter is off on this partition */
pv->ffEnabled = FALSE;
pv->firstFATsecNo = (SectorNo) -1; pv->lastFATsecNo = pv->firstFATsecNo; pv->clusterSize = (unsigned) 0;
/* read the BPB */
ioreq.irHandle = pv->handle; ioreq.irSectorNo = pv->startSecNo; ioreq.irSectorCount = (SectorNo) 1; ioreq.irData = (void FAR1 *) buf; checkStatus( flAbsRead(&ioreq) );
/* Does it look like DOS bootsector ? */
bpb = &( ((DOSBootSector *) buf)->bpb );
if( !((bpb->jumpInstruction[0] == 0xe9) || ((bpb->jumpInstruction[0] == 0xeb) && (bpb->jumpInstruction[2] == 0x90)))) {
return flNonFATformat; }
/* Do we handle this sector size ? */
if (UNAL2(bpb->bytesPerSector) != SECTOR_SIZE) return flFormatNotSupported;
/*
* Is it a bogus BPB (leftover from previous disk partitioning) ? * Check that there is no overlap with next partition (if one exists). */
sectors = UNAL2(bpb->totalSectorsInVolumeDOS3); if (sectors == (SectorNo)0) sectors = (SectorNo) LE4(bpb->totalSectorsInVolume);
if ((partNo+1 < pd->parts) && (pd->part[partNo+1] != NULL)) {
if( sectors > (pd->part[partNo+1])->startSecNo - pv->startSecNo ) return flNonFATformat; }
/* number of sectors in partition as reported by BPB */
pv->sectors = sectors;
/* valid BPB; get the rest of partition info from it */
pv->firstFATsecNo = pv->startSecNo + (SectorNo)( LE2(bpb->reservedSectors) ); sectorsPerFAT = (SectorNo) LE2(bpb->sectorsPerFAT); pv->lastFATsecNo = pv->firstFATsecNo + sectorsPerFAT - (SectorNo)1; rootDirSecNo = pv->firstFATsecNo + (sectorsPerFAT * bpb->noOfFATS); rootDirSectors = (SectorNo)1 + (SectorNo) (((UNAL2(bpb->rootDirectoryEntries) * DIRECTORY_ENTRY_SIZE) - 1) / SECTOR_SIZE); pv->firstDataSecNo = rootDirSecNo + rootDirSectors;
pv->clusterSize = bpb->sectorsPerCluster;
/* decide which type of FAT is it */
maxCluster = (unsigned)1 + (unsigned) ((pv->sectors - (pv->firstDataSecNo - pv->startSecNo)) / pv->clusterSize);
if (maxCluster < 4085) { pv->flags |= VOLUME_12BIT_FAT; /* 12-bit FAT */
#ifndef FAT_12BIT
DEBUG_PRINT(("Debug: FAT_12BIT must be defined.\r\n")); return flFormatNotSupported;#endif
}
/* turn on FAT filter on this partition */
pv->ffEnabled = TRUE;
return flOK;}
/* --------------------------------------------------------------------------- *
* * * p a r t F r e e D e l C l u s t e r s * * * * Compare the new contents of the specified FAT sector against the old * * one on the disk. If any freed clusters are found, issue 'sector delete' * * calls for all sectors that are occupied by these freed clusters. * * * * Parameters: * * pv : disk partition (filesystem volume) * * secNo : abs. sector # of the FAT sector * * newFAT : new contents of this FAT sector * * * * Returns: * * flOK on success, otherwise error code * * * * NOTE: This routine uses disk's scratch buffer. * * * * --------------------------------------------------------------------------- */
static FLStatus partFreeDelClusters ( FLffVol * pv, SectorNo secNo, char FAR1 * newFAT){ FLffDisk * pd; int socNo, diskNo; unsigned short oldFATentry, newFATentry; SectorNo iSec; unsigned firstCluster; IOreq ioreq; int offset; int iPart;
#ifdef FAT_12BIT
int halfBytes;#endif
#ifdef FL_MALLOC
char * oldFAT;#else
char oldFAT[SECTOR_SIZE];#endif
/* arg. sanity check */
if (pv == NULL) return flBadDriveHandle; /* break TFFS handle into socket# and disk#, and do sanity check */
socNo = H2S(pv->handle); diskNo = H2D(pv->handle); if ((socNo >= ((int) noOfSockets)) || (diskNo >= MAX_TL_PARTITIONS)) return flBadDriveHandle;
/* check if 'pv' belongs to this disk */
pd = ffDisk[socNo][diskNo];
if (pd == NULL) return flBadDriveHandle;
for (iPart = 0; iPart < pd->parts; iPart++) {
if (pd->part[iPart] == pv) break; }
if (iPart >= pd->parts) return flBadDriveHandle;
#ifdef FL_MALLOC
/* make sure scratch buffer is available */
if (pd->buf == NULL) return flBufferingError;
oldFAT = pd->buf; #endif /* FL_MALLOC */
/* read in the FAT sector from the disk */
ioreq.irHandle = pv->handle; ioreq.irSectorNo = secNo; ioreq.irSectorCount = 1; ioreq.irData = (void FAR1 *) oldFAT; checkStatus( flAbsRead(&ioreq) );
#ifdef FAT_12BIT
/* size of FAT entry in half-bytes */
halfBytes = ((pv->flags & VOLUME_12BIT_FAT) ? 3 : 4);
/* starting cluster */
if (halfBytes == 3) {
firstCluster = ((((unsigned)(secNo - pv->firstFATsecNo)) * (2 * SECTOR_SIZE)) + 2) / 3; } else { firstCluster = ((unsigned)(secNo - pv->firstFATsecNo)) * (SECTOR_SIZE / 2); }
/* staring data sector */
iSec = (((SectorNo)firstCluster - 2) * pv->clusterSize) + pv->firstDataSecNo;
offset = (firstCluster * ((unsigned) halfBytes)) & ((2 * SECTOR_SIZE) - 1);
/*
* Find if any clusters were logically deleted, and if so, delete them. * * NOTE: We are skipping over 12-bit FAT entries which span more than * one sector. */
for (; offset < ((2 * SECTOR_SIZE) - 2); offset += halfBytes, iSec += pv->clusterSize) {
#ifdef FL_BIG_ENDIAN
oldFATentry = LE2( *(LEushort FAR0 *)(oldFAT + (offset / 2)) ); newFATentry = LE2( *(LEushort FAR1 *)(newFAT + (offset / 2)) );#else
oldFATentry = UNAL2( *(Unaligned FAR0 *)(oldFAT + (offset / 2)) ); newFATentry = UNAL2( *(Unaligned FAR1 *)(newFAT + (offset / 2)) );#endif /* FL_BIG_ENDIAN */
if (offset & 1) { oldFATentry >>= 4; newFATentry >>= 4; } else { if (halfBytes == 3) { oldFATentry &= 0xfff; newFATentry &= 0xfff; } }
#else /* !FAT_12BIT */
firstCluster = ((unsigned) (secNo - pv->firstFATsecNo) * (SECTOR_SIZE / 2)); iSec = pv->firstDataSecNo + (((SectorNo)(firstCluster - (unsigned)2)) * pv->clusterSize);
/* Find if any clusters were logically deleted, and if so, delete them */
for (offset = 0; offset < SECTOR_SIZE; offset += 2, iSec += pv->clusterSize) {
oldFATentry = LE2( *(LEushort FAR0 *)(oldFAT + offset) ); newFATentry = LE2( *(LEushort FAR1 *)(newFAT + offset) );
#endif /* FAT_12BIT */
if ((oldFATentry != FAT_FREE) && (newFATentry == FAT_FREE)) {
ioreq.irHandle = pv->handle; ioreq.irSectorNo = iSec; ioreq.irSectorCount = pv->clusterSize; checkStatus( flAbsDelete(&ioreq) ); } }
return flOK;}
#endif /* FL_INCLUDE_FAT_MONITOR */
/* --------------------------------------------------------------------------- *
* * * f f C h e c k B e f o r e W r i t e * * * * Catch all the FAT updates. Detect disk partitioning operation, track it * * to completion, re-read partition tables, and re-install FAT filters on * * all FAT12/16 partitions. * * * * Parameters: * * ioreq : standard I/O request to be checked * * * * Returns: * * flOK on success, otherwise error code * * * * --------------------------------------------------------------------------- */
FLStatus ffCheckBeforeWrite ( IOreq FAR2 * ioreq ){ int socNo, diskNo; FLffDisk * pd; FLffVol * pv; long iSec; int iPart; IOreq ioreq2; char FAR1 * usrBuf;
/* if module hasn't been reset yet, do it now */
if (resetDone == FALSE) (void) reset();
/* break TFFS handle into socket# and disk#, and do sanity check */
socNo = H2S(ioreq->irHandle); diskNo = H2D(ioreq->irHandle); if ((socNo >= ((int) noOfSockets)) || (diskNo >= MAX_TL_PARTITIONS)) return flBadDriveHandle;
/* if disk structure hasn't been allocated yet, do it now */
if (ffDisk[socNo][diskNo] == NULL) checkStatus( newDisk((int)ioreq->irHandle) );
pd = ffDisk[socNo][diskNo];
/* read partition table(s) and install FAT filters is needed */
if (pd->ffstate == flStateNotInitialized) checkStatus( parseDisk((int)ioreq->irHandle) );
/* catch writes to MBR, and track the whole disk partitioning operations */
while( isPartTableWrite(pd, ioreq) == TRUE ) {
/* disk re-partitioning is in progress */
if( pd->secToWatch == (SectorNo)0 ) {
/* it's write to MBR, so trash BPBs in all disk's partitions */
if (pd->parts > 0) {
for (iPart = 0; iPart < pd->parts; iPart++) {
ioreq2.irHandle = ioreq->irHandle; ioreq2.irSectorNo = (pd->part[iPart])->startSecNo; ioreq2.irSectorCount = (SectorNo) 1; ioreq2.irData = (void FAR1 *) zeroes; (void) flAbsWrite(&ioreq2); } } }
/* keep FAT filters disabled while disk partitioning is in progress */
pd->ffstate = flStateInitInProgress;
/* partition table which is about to be written to disk */
usrBuf = FLBUF( ioreq, (pd->secToWatch - ioreq->irSectorNo) );
switch( isExtPartPresent(usrBuf, &(pd->secToWatch)) ) {
case flOK:
/*
* Found valid partition table with extended partition. * The pd->secToWatch has been updated to point to the * sector where next partition table will be written to. */ continue;
case flFileNotFound:
/*
* Valid partition table, but no extended partition in it. * Partitioning has been completed. Set pd->ffstate to * 'flStateNotInitialized' to initiate parsing of partition * table(s) and FAT filter installation next time this routine * is called. */
pd->ffstate = flStateNotInitialized; break;
case flBadFormat: default:
/* No valid partition table. */
break; }
return flOK; }
#ifdef FL_INCLUDE_FAT_MONITOR
/* check for FAT update */
if (pd->ffstate == flStateInitialized) {
/* NOTE: We can handle 'write' request that spans disk partition boundaries */
for (iSec = ioreq->irSectorNo; iSec < (ioreq->irSectorNo + ioreq->irSectorCount); iSec++) {
for (iPart = 0; iPart < pd->parts; iPart++) {
pv = pd->part[iPart];
/* we monitor only FAT12/16 partitions */
if ((pv->type != FAT12_PARTIT) && (pv->type != FAT16_PARTIT) && (pv->type != DOS4_PARTIT)) continue;
/* FAT filters can be disabled on individual partitions */
if (pv->ffEnabled != TRUE) continue;
if ((iSec >= (long)pv->firstFATsecNo) && (iSec <= (long)pv->lastFATsecNo)) {
/* compare new and old contents of FAT sectors(s) */
usrBuf = FLBUF( ioreq, (iSec - ioreq->irSectorNo) );
checkStatus( partFreeDelClusters(pv, iSec, usrBuf) ); } } } }
#endif /* FL_INCLUDE_FAT_MONITOR */
return flOK;}
/* --------------------------------------------------------------------------- *
* * * f l f f C o n t r o l * * * * Enable/disable/install FAT filters. See comments inside the routine for * * the list of supported operations. * * * * Parameters: * * handle : TFFS handle * * partNo : partition # (0 .. FL_MAX_PARTS_PER_DISK) * * state : see list of supported operations below * * * * Returns: * * flOK on success, otherwise error code * * * * --------------------------------------------------------------------------- * * * * The following FAT monitor control requests are supported: * * * * state : flStateNotInitialized * * partNo : [0 ... pd->parts-1] * * action : turn off FAT monitor on specified partition * * * * state : flStateNotInitialized * * partNo : < 0 * * action : turn off FAT monitor on all partitions * * * * state : flStateInitialized * * partNo : [0 ... pd->parts-1] * * action : if FAT monitor has been installed on specified partition, * * turn it on * * * * state : flStateInitInProgress * * partNo : ignored * * action : re-read partition table(s), and install FAT filters on all * * partitions * * * * --------------------------------------------------------------------------- */
FLStatus flffControl ( int handle, int partNo, FLState state ){ int socNo, diskNo; FLffDisk * pd; int i; FLStatus status;
/* if module hasn't been reset yet, do it now */
if (resetDone == FALSE) (void) reset();
/* break TFFS handle into socket# and disk#, and do sanity check */
socNo = H2S(handle); diskNo = H2D(handle); if ((socNo >= ((int) noOfSockets)) || (diskNo >= MAX_TL_PARTITIONS)) return flBadDriveHandle;
/* if disk structure hasn't been allocated yet, do it now */
if (ffDisk[socNo][diskNo] == NULL) checkStatus( newDisk(handle) );
pd = ffDisk[socNo][diskNo];
/* abort if disk re-partitioning is in progress */
if (pd->ffstate == flStateInitInProgress) return flDriveNotReady;
/* read partition table(s) and install FAT filters is needed */
if (pd->ffstate == flStateNotInitialized) {
if (state == flStateNotInitialized) return flOK;
checkStatus( parseDisk(handle) ); }
/* check 'partNo' arguement for sanity */ if ((partNo >= pd->parts) || (partNo >= FL_MAX_PARTS_PER_DISK)) return flBadDriveHandle;
/* do requested operation */
status = flBadParameter;
switch (state) {
case flStateInitInProgress:
/* read partition table(s), install FAT filters on all partitions */
pd->ffstate = flStateNotInitialized; status = parseDisk(handle); break;
case flStateNotInitialized:
/* turn off FAT monitor */
if (partNo < 0) { /* all partitions */
for (i = 0; i < FL_MAX_PARTS_PER_DISK; i++) {
if (pd->part[i] != NULL) (pd->part[i])->ffEnabled = FALSE; } } else { /* specified partition */
if (pd->part[partNo] != NULL) (pd->part[partNo])->ffEnabled = FALSE; } status = flOK; break;
#ifdef FL_INCLUDE_FAT_MONITOR
case flStateInitialized:
/* turn on FAT monitor */
if ((pd->ffstate == flStateInitialized) && (partNo >= 0)) {
if (pd->part[partNo] != NULL) {
switch( (pd->part[partNo])->type ) {
case FAT12_PARTIT: case FAT16_PARTIT: case DOS4_PARTIT: (pd->part[partNo])->ffEnabled = TRUE; status = flOK; break;
case FL_RAW_PART: DEBUG_PRINT(("Debug: can't ctrl non-existent partition.\r\n")); break;
default: DEBUG_PRINT(("Debug: can't ctrl non-FAT12/16 partition.\r\n")); break; } } } break;
#endif /* FL_INCLUDE_FAT_MONITOR */
} /* switch(state) */
return status;}
/* --------------------------------------------------------------------------- *
* * * f l f f I n f o * * * * Obtain complete partition info for specified disk. * * * * Parameters: * * handle : TFFS handle * * * * Returns: * * NULL if error, otherwise pointer to partitioning info * * * * --------------------------------------------------------------------------- */
FLffDisk * flffInfo ( int handle ){ int socNo, diskNo; FLffDisk * pd;
/* if module hasn't been reset yet, do it now */
if (resetDone == FALSE) (void) reset();
/* break TFFS handle into socket# and disk#, and do sanity check */
socNo = H2S(handle); diskNo = H2D(handle); if ((socNo >= ((int) noOfSockets)) || (diskNo >= MAX_TL_PARTITIONS)) return NULL;
/* if disk structure hasn't been allocated yet, do it now */
if (ffDisk[socNo][diskNo] == NULL) {
if( newDisk(handle) != flOK ) return NULL; }
pd = ffDisk[socNo][diskNo];
/* read partition table(s) and install FAT filters is needed */
if (pd->ffstate == flStateNotInitialized) {
if( parseDisk(handle) != flOK ) return NULL; }
return pd;}
#endif /* ABS_READ_WRITE && FL_READ_ONLY */
|
