dosfsfat.c

vxworks操作系统的文件系统部分原代码

    assert ( copyNum < pVolDesc->nFats);
    assert ( (cluster >= DOS_MIN_CLUST) && (cluster < pFatDesc->nFatEnts) );
    assert ( copyNum != pVolDesc->pFatDesc->activeCopyNum ||
             ( (value == pFatDesc->dos_fat_avail) || 
               ((value >= DOS_MIN_CLUST) && (value < pFatDesc->nFatEnts)) || 
               (value == pFatDesc->dos_fat_eof) ) );

    cookie = pFd->fatHdl.cbioCookie;

    /* Offset of the entry in the FAT in bytes */

    fatOff = cluster + (cluster >> 1);	/* index = cluster * 1.5 */

    /* Number of sector containing the entry */

    secNum = pFatDesc->fatStartSec + copyNum * pVolDesc->secPerFat +
            (fatOff >> pVolDesc->secSizeShift);

    /* Mirror last modified FAT sector if entry is situated in other sector */

    if (pFd->pFileHdl->fatSector != secNum &&
        copyNum == pVolDesc->pFatDesc->activeCopyNum)
        {
        fat16MirrorSect (pFd);
        pFd->pFileHdl->fatSector = secNum;
        }

    /* Offset of the entry in the sector */

    secOff = fatOff & (pVolDesc->bytesPerSec - 1);

    /* Number of bytes to write */

    nBytes = pVolDesc->bytesPerSec - secOff;
    if (nBytes > 2)
        nBytes = 2;

    /* Read previous entry value */

    if (cbioBytesRW (pCbio, secNum, secOff,(addr_t) valBuf, nBytes, 
			CBIO_READ, &cookie) != OK)
        return ERROR;				/* read error */

    if (nBytes == 1)
        if (cbioBytesRW (pCbio, secNum + 1, 0,(addr_t) (&valBuf[1]), 1, 
				CBIO_READ, &pFd->fatHdl.cbioCookie) != OK)
            return ERROR;			/* read error */

    if (cluster & 0x1)				/* if cluster number is ODD */
        {
        valBuf [0] &= 0x0f;			/* clear high order 4 bits */
        valBuf [0] |= (value << 4);		/* put in low bits of value */
        valBuf [1]  = (value >> 4);		/* next byte is high bits */
        }
    else					/* if cluster number is EVEN */
        {
        valBuf [0]  = value;			/* this byte gets low bits */
        valBuf [1] &= 0xf0;			/* clear low bits next byte */
        valBuf [1] |= (value >> 8) & 0x0f;	/* put in high bits */
        }

    /* Write entry to disk */

    if (cbioBytesRW (pCbio, secNum, secOff,(addr_t)valBuf, nBytes, CBIO_WRITE, 
				&cookie) != OK)
        return ERROR;

    if (nBytes == 1)
        if (cbioBytesRW (pCbio, secNum + 1, 0, (addr_t)(&valBuf [1]), 1, 
				CBIO_WRITE, &pFd->fatHdl.cbioCookie) != OK)
        return ERROR;

    return OK;
    } /* fat12EntWrite */

/*******************************************************************************
* 
* fat16EntRead - read FAT entry from disk
* 
* This routine reads the file allocation table (FAT) entry from a dosFs
* volume.
*
* This routine only reads from the first copy of the FAT on disk, even if
* other copies exist.
* 
* RETURNS: Contents of the entry, or FAT_CBIO_ERR if error accessing disk.
*/

LOCAL uint32_t fat16EntRead
    (
    FAST DOS_FILE_DESC_ID	pFd,	/* pointer to file descriptor */
    FAST uint32_t		copyNum,/* fat copy number */
    FAST uint32_t		entry	/* entry number */
    )
    {
    FAST DOS_VOLUME_DESC_ID	pVolDesc = pFd->pVolDesc;
					/* pointer to volume descriptor */
    FAST CBIO_DEV_ID		pCbio = pVolDesc->pCbio;
					/* pointer to CBIO device */
    FAST MS_FAT_DESC_ID	pFatDesc = (void *) pVolDesc->pFatDesc;
					/* pointer to FAT descriptor */
    FAST block_t		secNum;	/* sector number to read/write */
    FAST off_t			secOff;	/* offset in the sector */
         uint8_t		valBuf [2];
					/* buffer for value in the entry */

    assert ( copyNum < pVolDesc->nFats);
    assert ( (entry >= DOS_MIN_CLUST) && (entry < pFatDesc->nFatEnts) );

    /* Offset of the entry in the FAT in bytes */

    entry <<= 1;

    /* Number of sector containing the entry */

    secNum = pFatDesc->fatStartSec + copyNum * pVolDesc->secPerFat +
            (entry >> pVolDesc->secSizeShift);

    /* Offset of the entry in the sector */

    secOff = entry & (pVolDesc->bytesPerSec - 1);

    /* Read entry from disk */

    if (cbioBytesRW (pCbio, secNum, secOff, (addr_t)valBuf, 2, CBIO_READ, 
				&pFd->fatHdl.cbioCookie) != OK)
        {
        pFd->fatHdl.errCode = FAT_CBIO_ERR;
        return FAT_CBIO_ERR;				/* read error */
        }

    return (valBuf [0] | (valBuf [1] << 8));
					/* copy word, swapping bytes */
    } /* fat16EntRead */

/*******************************************************************************
* 
* fat16EntWrite - write FAT entry to disk
* 
* This routine writes the file allocation table (FAT) entry to a dosFs
* volume.
*
* This routine only writes to the first copy of the FAT on disk, even if
* other copies exist.
* 
* RETURNS: OK, or ERROR if error accessing disk.
*/

LOCAL STATUS fat16EntWrite
    (
    FAST DOS_FILE_DESC_ID	pFd,	/* pointer to file descriptor */
    FAST uint32_t		copyNum,/* fat copy number */
    FAST uint32_t		entry,	/* entry number */
    FAST uint32_t		value	/* value to write */
    )
    {
    FAST DOS_VOLUME_DESC_ID	pVolDesc = pFd->pVolDesc;
					/* pointer to volume descriptor */
    FAST CBIO_DEV_ID		pCbio = pVolDesc->pCbio;
					/* pointer to CBIO device */
    FAST MS_FAT_DESC_ID	pFatDesc = (void *) pVolDesc->pFatDesc;
					/* pointer to FAT descriptor */
    FAST block_t		secNum;	/* sector number to read/write */
    FAST off_t			secOff;	/* offset in the sector */
         uint8_t		valBuf [2];
					/* buffer for value in the entry */

    assert ( copyNum < pVolDesc->nFats);
    assert ( (entry >= DOS_MIN_CLUST) && (entry < pFatDesc->nFatEnts) );
    assert ( copyNum != pVolDesc->pFatDesc->activeCopyNum ||
             ( (value == pFatDesc->dos_fat_avail) || 
               ((value >= DOS_MIN_CLUST) && (value < pFatDesc->nFatEnts)) || 
               (value == pFatDesc->dos_fat_eof) ) );

    /* Offset of the entry in the FAT in bytes */

    entry <<= 1;

    /* Number of sector containing the entry */

    secNum = pFatDesc->fatStartSec + copyNum * pVolDesc->secPerFat +
            (entry >> pVolDesc->secSizeShift);

    /* Mirror last modified FAT sector if entry is situated in other sector */

    if (pFd->pFileHdl->fatSector != secNum &&
        copyNum == pVolDesc->pFatDesc->activeCopyNum)
        {
        fat16MirrorSect (pFd);
        pFd->pFileHdl->fatSector = secNum;
        }

    /* Offset of the entry in the sector */

    secOff = entry & (pVolDesc->bytesPerSec - 1);

    valBuf [0] = value        & 0xff;	/* this byte gets low bits */
    valBuf [1] = (value >> 8) & 0xff;	/* next byte gets high bits */

    /* Write entry to disk */

    return cbioBytesRW (pCbio, secNum, secOff, (addr_t)valBuf, 2, CBIO_WRITE, 
				&pFd->fatHdl.cbioCookie);
    } /* fat16EntWrite */

/*******************************************************************************
* 
* fat32EntRead - read FAT entry from disk
* 
* This routine reads the file allocation table (FAT) entry from a dosFs
* volume.
*
* This routine only reads from the first copy of the FAT on disk, even if
* other copies exist.
* 
* RETURNS: Contents of the entry, or FAT_CBIO_ERR if error accessing disk.
*/

LOCAL uint32_t fat32EntRead
    (
    FAST DOS_FILE_DESC_ID	pFd,	/* pointer to file descriptor */
    FAST uint32_t		copyNum,/* fat copy number */
    FAST uint32_t		entry	/* entry number */
    )
    {
    FAST DOS_VOLUME_DESC_ID	pVolDesc = pFd->pVolDesc;
					/* pointer to volume descriptor */
    FAST CBIO_DEV_ID		pCbio = pVolDesc->pCbio;
					/* pointer to CBIO device */
    FAST MS_FAT_DESC_ID	pFatDesc = (void *) pVolDesc->pFatDesc;
					/* pointer to FAT descriptor */
    FAST block_t		secNum;	/* sector number to read/write */
    FAST off_t			secOff;	/* offset in the sector */
         uint8_t		valBuf [4];
         uint8_t		highByteMask = 0x0f;

    /* do not mask high bits when non active copy is being written */

    if (copyNum != pVolDesc->pFatDesc->activeCopyNum)
    	highByteMask = 0xff;
					/* buffer for value in the entry */

    assert ( copyNum < pVolDesc->nFats);
    assert ( (entry >= DOS_MIN_CLUST) && (entry < pFatDesc->nFatEnts) );

    /* Offset of the entry in the FAT in bytes */

    entry <<= 2;

    /* Number of sector containing the entry */

    secNum = pFatDesc->fatStartSec + copyNum * pVolDesc->secPerFat +
            (entry >> pVolDesc->secSizeShift);

    /* Offset of the entry in the sector */

    secOff = entry & (pVolDesc->bytesPerSec - 1);

    /* Read entry from disk */

    if (cbioBytesRW (pCbio, secNum, secOff, (addr_t)valBuf, 4, CBIO_READ, 
			     &pFd->fatHdl.cbioCookie) != OK)
        {
        pFd->fatHdl.errCode = FAT_CBIO_ERR;
        return FAT_CBIO_ERR;				/* read error */
        }

    return (valBuf [0] | (valBuf [1] << 8) | (valBuf [2] << 16) | 
            ((valBuf [3] & highByteMask) << 24));/* mask highest 4 bits */
    } /* fat32EntRead */

/*******************************************************************************
* 
* fat32EntWrite - write FAT entry to disk
* 
* This routine writes the file allocation table (FAT) entry to a dosFs
* volume.
*
* This routine only writes to the first copy of the FAT on disk, even if
* other copies exist.
* 
* RETURNS: OK, or ERROR if error accessing disk.
*/

LOCAL STATUS fat32EntWrite
    (
    FAST DOS_FILE_DESC_ID	pFd,	/* pointer to file descriptor */
    FAST uint32_t		copyNum,/* fat copy number */
    FAST uint32_t		entry,	/* entry number */
    FAST uint32_t		value	/* value to write */
    )
    {
    FAST DOS_VOLUME_DESC_ID	pVolDesc = pFd->pVolDesc;
					/* pointer to volume descriptor */
    FAST CBIO_DEV_ID		pCbio = pVolDesc->pCbio;
					/* pointer to CBIO device */
    FAST MS_FAT_DESC_ID	pFatDesc = (void *) pVolDesc->pFatDesc;
					/* pointer to FAT descriptor */
    FAST block_t		secNum;	/* sector number to read/write */
    FAST off_t			secOff;	/* offset in the sector */
         uint8_t		valBuf [4];
					/* buffer for value in the entry */
         uint8_t		highByteMask = 0x0f;

    /* do not mask high bits when non active copy is being written */

    if (copyNum != pVolDesc->pFatDesc->activeCopyNum)
    	highByteMask = 0xff;

    assert ( copyNum < pVolDesc->nFats);
    assert ( (entry >= DOS_MIN_CLUST) && (entry < pFatDesc->nFatEnts) );
    assert ( highByteMask == 0xff ||
             ( (value == pFatDesc->dos_fat_avail) || 
               ((value >= DOS_MIN_CLUST) && (value < pFatDesc->nFatEnts)) || 
               (value == pFatDesc->dos_fat_eof) ) );

    /* Offset of the entry in the FAT in bytes */

    entry <<= 2;

    /* Number of sector containing the entry */

    secNum = pFatDesc->fatStartSec + copyNum * pVolDesc->secPerFat +
            (entry >> pVolDesc->secSizeShift);

    /* Mirror last modified FAT sector if entry is situated in other sector */

    if (pFd->pFileHdl->fatSector != secNum && highByteMask != 0xff )
        {
        fat16MirrorSect (pFd);
        pFd->pFileHdl->fatSector = secNum;
        }

    /* Offset of the entry in the sector */

    secOff = entry & (pVolDesc->bytesPerSec - 1);

    valBuf [0] = value         & 0xff;	/*  */
    valBuf [1] = (value >> 8)  & 0xff;	/*  */
    valBuf [2] = (value >> 16) & 0xff;	/*  */
    valBuf [3] = (value >> 24) & highByteMask;	/*  */

    /* Write entry to disk */

    return cbioBytesRW (pCbio, secNum, secOff, (addr_t)valBuf, 4, CBIO_WRITE, 
				&pFd->fatHdl.cbioCookie);
    } /* fat32EntWrite */

/*******************************************************************************
*
* fat16ContigGet - get next section of contiguous clusters in file chain
* 
* This routine reads FAT entries starting from the passed cluster number, and 
* returns number of contiguous clusters in the file chain starting from the 
* passed one up to number of clusters requested.
*
* If starting cluster number is out of legal cluster number range, a 0 is 
* returned, except of the following 2 cases:
*
* 1) If start cluster number is 0 .
*
* 2) If start cluster number is end of file .
*
* This routine checks the File Allocation Table (FAT) to determine the
* length, in clusters, of a contiguous section of a file.  The starting
* cluster to check is passed as an input parameter.  The number of
* contiguous clusters beginning with that cluster (including the starting
* cluster itself) is returned.  The minimum returned value is 1.
*
* RETURNS: Number of contiguous clusters in chain starting from the passed one,
*          or 0 if starting cluster number is illegal or disk access error.
*/

LOCAL STATUS fat16ContigGet
    (
    FAST DOS_FILE_DESC_ID pFd,		/* pointer to file descriptor */
    FAST uint32_t	  numClusts	/* num. of clusters to follow */
    )
    {
    FAST DOS_FILE_HDL_ID	pFileHdl = pFd->pFileHdl;
					/* pointer to file handle */
    FAST DOS_FAT_HDL_ID		pFatHdl = &(pFd->fatHdl);
					/* pointer to FAT handle */
    FAST DOS_VOLUME_DESC_ID	pVolDesc = pFd->pVolDesc;
					/* pointer to volume descriptor */
    FAST MS_FAT_DESC_ID	pFatDesc = (void *) pVolDesc->pFatDesc;
				/* pointer to FAT handler descriptor */
    FAST uint32_t		startClust;	/* starting cluster number */
    FAST uint32_t		nextClust;	/* next cluster number */
    FAST uint32_t		cluster;	/* cluster number */
    FAST uint32_t		maxClust;	/* maximum cluster number */

    startClust = nextClust = pFatHdl->nextClust;
    cluster    = pFatHdl->lastClust;

    if ((startClust < DOS_MIN_CLUST) || (startClust >= pFatDesc->nFatEnts))
        {
        if ((startClust == 0) && (cluster == 0))	/* file just open */
            startClust = pFileHdl->startClust;

        if (startClust > pFatDesc->dos_fat_bad)		/* end of file chain */
    	    {
            startClust = ENTRY_READ (pFd, pFatDesc->dosFatDesc.activeCopyNum,
                                     cluster);
    	    }

        if ((startClust < DOS_MIN_CLUST) || (startClust >= pFatDesc->nFatEnts))
            {
            assert ((startClust == 0) || (startClust > pFatDesc->dos_fat_bad));
            pFatHdl->nextClust = startClust;
            return ERROR;
            }