1521 lines
50 KiB
C
1521 lines
50 KiB
C
|
|
/*******************************************************************************
|
|
* *
|
|
* 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 */
|
|
|
|
|