开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > VxWorks > 查看源码
dosFsFat.c
资源名称：vxwork_src.rar　[点击查看]
上传用户：nvosite88
上传日期：2007-01-17
资源大小：4983k
文件大小：62k
源码类别：

VxWorks

开发平台：

C/C++

dosFsFat.c：源码内容
  1. /* dosFsFat.c - DOS file system File Allocation Table Handler */
  3. /* Copyright 1987-2002 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7. modification history
  8. --------------------
  9. 01q,10jan02,chn  Renamed some functions to clear up sector/cluster confusion
  10. 01p,10dec01,jkf  SPR#72039, various fixes from Mr. T. Johnson.
  11. 01o,12oct01,jkf  adapted debugging code to be more portable. 
  12. 01n,02oct01,jkf  replaced diab changes lost in 01m.
  13. 01m,20sep01,jkf  SPR#69031, common code for both AE & 5.x.
  14. 01l,08oct99,jkf  added ifdef for HP native tools to ignore GNUish debug macro's
  15. 01k,31aug99,jkf  changes for new CBIO API.
  16. 01j,31jul99,jkf  T2 merge, tidiness & spelling.
  17. 01i,21dec98,mjc  fixed bug in fat16Seek(), changed name of <contigEnd> 
  18.                  field in structure <DOS_FILE_HDL> to <contigEndPlus1>
  19. 01h,23nov98,mjc  avoided disk access for seek within contiguous file area;
  20. 01j,23sep98,vld  added FAT mirroring disabling;
  21.  added routine fat16SyncToggle()
  22. 01f,20sep98,mjc  descriptor structure name changed from DOS_FAT16_DESC
  23.                  to MS_FAT_DESC
  24. 01e,17sep98,vld  added argument "number of FAT copy" to cluster read/write
  25.                  routines;
  26. cluster writing routines extended with a"raw" data
  27.  write to FAT copies other, then active one;
  28.            routine fat16ClustValueSet() extended to support
  29.                  FAT copy initialization;
  30. 01d,12jul98,mjc  cluster group allocation factor changed from
  31.                  constant to global variable fatClugFac.
  32.                  Assert header files including was moved 
  33.                  to be after #ifdef DEBUG statement to allow
  34.                  NDEBUG definition  in case when DEBUG is undefined.
  35.                  fat16ContigAlloc() algorithm was changed to 1st fit.
  36. 01c,01jul98,lrn  doc reviewed
  37. 01b,29jun98,mjc  added FAT32, tested
  38. 01a,23feb98,mjc  initially written written.
  39. */
  41. /*
  42. DESCRIPTION
  43. This module is part of dosFsLib and is designed to manage the three
  44. different File Allocation Table formats: FAT12, FAT16 and FAT32.
  45. These formats are similar thus are implemented in a single module
  46. without the ability to scale out one of these formats for systems which
  47. do not intend to use them.
  49. IMPLEMENTATION
  50. This FAT handler does not keep any part of the File Allocation Table in
  51. memory, depending entirely on the underlying CBIO module, typically the
  52. Disk Cache for the ability to access any FAT entry of any size, i.e.
  53. byte-wise access to any particular disk sector.
  55. INITIALIZATION
  56. */
  58. /* includes */
  60. #include "vxWorks.h"
  61. #include "private/dosFsVerP.h"
  62. #include "semLib.h"
  63. #include "errnoLib.h"
  64. #include "logLib.h"
  65. #include "string.h"
  66. #include "memLib.h"
  67. #include "stdlib.h"
  68. #include "stdio.h"
  69. #include "taskLib.h"
  71. #include "private/print64Lib.h"
  72. #include "private/dosFsLibP.h"
  73. #include "private/dosFsFatP.h"
  75. /* macros */
  77. #define _TO_STR(z) _TO_TMP(z)
  78. #define _TO_TMP(z) #z
  80. #undef ERR_MSG
  81. #undef DBG_MSG
  82. #undef ERR_PRINT
  84. #ifdef DEBUG
  86. #   undef  LOCAL
  87. #   define LOCAL
  89. #   define ERR_PRINT /* include errnoSetOut() */
  90. #   define errnoSet( err ) errnoSetOut( __FILE__, __LINE__, #err, (err) )
  92. #   define DBG_MSG(lvl, fmt, a1, a2, a3, a4, a5, a6)                       
  93.         { if ((lvl) <= fat16Debug)                                         
  94.             printErr (__FILE__" : "_TO_STR(__LINE__)" : "fmt, a1, a2,      
  95.                       a3, a4, a5, a6); }
  97. #   define ERR_MSG(lvl, fmt, a1, a2, a3, a4, a5, a6)    
  98.         { logMsg (__FILE__" : "_TO_STR(__LINE__)" : "fmt, (int)(a1),       
  99.                   (int)(a2), (int)(a3), (int)(a4), (int)(a5), (int)(a6)); }
  101. #else   /* NO DEBUG */
  103. #   undef  NDEBUG
  104. #   define NDEBUG
  107. /* fixme: quick dirty hack for native HP native tools build, HP simulator */
  108. #   if (CPU == SIMHPPA)
  109.     /* Allow TOOL=hp to build, will cause no effect warnings when TOOL=gnu */
  110. #        define DBG_MSG
  111. #        define ERR_MSG
  112. #   else
  113. #        define DBG_MSG(lvl, fmt, a1, a2, a3, a4, a5, a6) {}
  114. #        define ERR_MSG(lvl, fmt, a1, a2, a3, a4, a5, a6)                    
  115.              { if ((lvl) <= fat16Debug)                                      
  116.                  logMsg (__FILE__" : "_TO_STR(__LINE__)" : %s : "fmt,        
  117.                  (int)(a1), (int)(a2), (int)(a3), (int)(a4), (int)(a5),      
  118.  (int)(a6)); }
  119. #   endif /* (CPU == SIMHPPA) */
  120. #endif /* DEBUG */
  121.                                                                              
  122. #include "assert.h"
  125. /* defines */
  127. /* File System Information Sector number */
  129. #define FSINFO_SEC_NUM 1
  131. /* Offset of free clusters count field in the File System Information Sector */
  133. #define FSINFO_SIGN 484
  134. #define FSINFO_FREE_CLUSTS 488
  135. #define FSINFO_NEXT_FREE        492
  137. /* Read FAT entry error code */
  139. #define FAT_CBIO_ERR 1
  141. /* Mutex semaphore options */
  143. #define ALLOC_SEM_OPTIONS SEM_Q_PRIORITY | SEM_DELETE_SAFE | 
  144. SEM_INVERSION_SAFE
  146. #define ENTRY_READ(pFd, copy, entry)
  147. pFatDesc->entryRead ((pFd), (copy), (entry))
  149. #define ENTRY_WRITE(pFd, copy, entry, value)
  150. pFatDesc->entryWrite ((pFd), (copy), (entry), (value))
  153. /* typedefs */
  156. /* globals */
  158. int     fat16Debug = 0; /* debug level */
  160. int fatClugFac = 10000; /* cluster allocation group size factor */
  163. /* locals */
  167. #ifdef ERR_PRINT
  168. /*******************************************************************************
  169. * errnoSetOut - put error message
  170. *
  171. * This routine is called instead errnoSet during debugging.
  172. */
  173. LOCAL VOID errnoSetOut(char * pFile, int line, const char * pStr, int errCode )
  174.     {
  175.     /* If it is not errno clearing or setting to previously stored value 
  176.      * (in <errnoBuf> variable), print the error information.
  177.      */
  179.     if( errCode != OK  && strcmp( pStr, "errnoBuf" ) != 0 )
  180.         printf( "ERROR from %s : line %d : %s = %p, task %pn",
  181.                 pFile, line, pStr, (void *)errCode, (void *)taskIdSelf() );
  182.     errno = errCode;
  183.     }
  184. #endif  /* ERR_PRINT */
  186. /*******************************************************************************
  187. *
  188. * fat16MirrorSect - mirror FAT sector
  189. *
  190. * This routine copies last modified sector of Primary FAT copy to appropriate 
  191. * sectors of another FAT copies.
  192. *
  193. * RETURNS: OK or ERROR.
  194. */
  196. LOCAL STATUS fat16MirrorSect
  197.     (
  198.     FAST DOS_FILE_DESC_ID pFd /* pointer to file descriptor */
  199.     )
  200.     {
  201.     FAST DOS_VOLUME_DESC_ID pVolDesc = pFd->pVolDesc;
  202. /* pointer to volume descriptor */
  203.     FAST MS_FAT_DESC_ID pFatDesc = (void *) pVolDesc->pFatDesc;
  204. /* pointer to FAT descriptor */
  205.     FAST CBIO_DEV_ID pCbio = pVolDesc->pCbio;
  206. /* pointer to CBIO device */
  207.     FAST uint32_t srcSecNum = pFd->pFileHdl->fatSector;
  208.     FAST uint32_t dstSecNum;
  209.     FAST int fatNum; /* FAT copy number */
  210.          uint8_t fsinfoBuf [8];
  212.     if (srcSecNum == 0)
  213.         return OK;
  215.     /* FAT copies synchronization might be disabled */
  217.     if ( ! pFatDesc->syncEnabled)
  218.      return OK;
  220.     /* 
  221.      * TBD: mirroring disabled (FAT32)
  222.      * ? Maybe it is worth adding callbacks to process CBIO write errors ?
  223.      */
  225.     for (fatNum = 1, dstSecNum = srcSecNum + pVolDesc->secPerFat; 
  226.          fatNum < pVolDesc->nFats; 
  227.          fatNum++, dstSecNum += pVolDesc->secPerFat)
  228.         {
  229.         if (cbioBlkCopy (pCbio, srcSecNum, dstSecNum, 1) != OK)
  230.             return ERROR;
  231.         /* ...??? */
  232.         }
  234.     if (pVolDesc->fatType == FAT32)
  235.         {
  236.         VX_TO_DISK_32 (pFatDesc->fatEntFreeCnt, &fsinfoBuf[0]);
  237.         VX_TO_DISK_32 (pFatDesc->groupAllocStart, &fsinfoBuf[4]);
  239.         if (OK != cbioBytesRW (pCbio, FSINFO_SEC_NUM, FSINFO_FREE_CLUSTS, 
  240. (addr_t)fsinfoBuf, sizeof (fsinfoBuf), CBIO_WRITE, NULL))
  241.             return ERROR;
  242.         }
  244.     return OK;
  245.     } /* fat16MirrorSect */
  247. /*******************************************************************************
  248. *
  249. * fat16SyncToggle - toggle FAT copies mirroring.
  250. * 
  251. * This routine enables/disables FAT copes mirroring. When mirroring
  252. * is enabled all reserved FAT copes are synchronized with active one.
  253. * 
  254. * RETURNES: N/A.
  255. */
  256. LOCAL void fat16SyncToggle
  257.     (
  258.     DOS_VOLUME_DESC_ID pVolDesc,
  259.     BOOL syncEnable
  260.     )
  261.     {
  262.     MS_FAT_DESC_ID pFatDesc = (MS_FAT_DESC_ID)pVolDesc->pFatDesc;
  263.     block_t srcSec, dstSec, secNum;
  264.     uint8_t copyNum;
  265.     
  266.     pFatDesc->syncEnabled = syncEnable;
  267.     
  268.     if (! syncEnable)
  269.      return;
  270.     
  271.     /* synchronize FAT copies */
  272.     
  273.     /* copy by one sector. It permits always one read - multi write */
  275.     srcSec = pFatDesc->fatStartSec +
  276.              pVolDesc->pFatDesc->activeCopyNum * pVolDesc->secPerFat;
  277.     for (secNum = 0; secNum < pVolDesc->secPerFat; secNum ++, srcSec ++ )
  278.      {
  279.      for (dstSec = pFatDesc->fatStartSec + secNum, copyNum = 0;
  280.      copyNum < pVolDesc->nFats;
  281.      dstSec += pVolDesc->secPerFat, copyNum ++ )
  282.          {
  283.          if (copyNum == pVolDesc->pFatDesc->activeCopyNum)
  284.           continue;
  285.          
  286.          cbioBlkCopy (pVolDesc->pCbio, srcSec, dstSec, 1);
  287.          }
  288.      }
  289.     } /* fat16SyncToggle() */
  291. /*******************************************************************************
  292. *
  293. * fat12EntRead - read FAT entry from disk
  294. * 
  295. * This routine reads the file allocation table (FAT) entry from a dosFs
  296. * volume.
  297. *
  298. * This routine only reads from the first copy of the FAT on disk, even if
  299. * other copies exist.
  300. * 
  301. * RETURNS: Contents of the entry, or FAT_CBIO_ERR if error accessing disk.
  302. */
  304. LOCAL uint32_t fat12EntRead
  305.     (
  306.     FAST DOS_FILE_DESC_ID pFd, /* pointer to file descriptor */
  307.     FAST uint32_t copyNum,/* fat copy number */
  308.     FAST uint32_t cluster /* entry number */
  309.     )
  310.     {
  311.     FAST DOS_VOLUME_DESC_ID pVolDesc = pFd->pVolDesc;
  312. /* pointer to volume descriptor */
  313.     FAST CBIO_DEV_ID pCbio = pVolDesc->pCbio;
  314. /* pointer to CBIO device */
  315.     FAST MS_FAT_DESC_ID pFatDesc = (void *) pVolDesc->pFatDesc;
  316. /* pointer to FAT descriptor */
  317.     FAST uint32_t fatEntry;/* FAT entry */
  318.     FAST uint32_t fatOff; /* offset in the FAT */
  319.     FAST block_t secNum; /* sector number to read/write */
  320.     FAST off_t secOff; /* offset in the sector */
  321.     FAST uint32_t nBytes; /* number of bytes */
  322.          uint8_t valBuf [2];
  323. /* buffer for value in the entry */
  325.     assert ( copyNum < pVolDesc->nFats);
  326.     assert ( (cluster >= DOS_MIN_CLUST) && (cluster < pFatDesc->nFatEnts) );
  328.     /* Offset of the entry in the FAT in bytes */
  330.     fatOff = cluster + (cluster >> 1); /* index = cluster * 1.5 */
  332.     /* Number of sector containing the entry */
  334.     secNum = pFatDesc->fatStartSec + copyNum * pVolDesc->secPerFat +
  335.             (fatOff >> pVolDesc->secSizeShift);
  337.     /* Offset of the entry in the sector */
  339.     secOff = fatOff & (pVolDesc->bytesPerSec - 1);
  341.     /* Number of bytes to read */
  343.     nBytes = pVolDesc->bytesPerSec - secOff;
  344.     if (nBytes > 2)
  345.         nBytes = 2;
  347.     /* Read entry from disk */
  349.     if (cbioBytesRW (pCbio, secNum, secOff, (addr_t)valBuf, nBytes, CBIO_READ, 
  350. &pFd->fatHdl.cbioCookie) != OK)
  351.         {
  352.         pFd->fatHdl.errCode = FAT_CBIO_ERR;
  353.         return FAT_CBIO_ERR; /* read error */
  354.         }
  356.     if (nBytes == 1)
  357.         if (cbioBytesRW (pCbio, secNum + 1, 0, (addr_t)(&valBuf[1]), 1, 
  358. CBIO_READ, &pFd->fatHdl.cbioCookie) != OK)
  359.             {
  360.             pFd->fatHdl.errCode = FAT_CBIO_ERR;
  361.             return FAT_CBIO_ERR; /* read error */
  362.             }
  364.     fatEntry = valBuf [0] | (valBuf [1] << 8);
  365. /* copy word, swapping bytes */
  366.     if (cluster & 0x1) /* if cluster number is ODD */
  367.         fatEntry = (fatEntry >> 4) & 0xfff; /*  keep high order 12 bits */
  368.     else /* if cluster number is EVEN */
  369.         fatEntry &= 0xfff; /*  keep low order 12 bits */
  371.     return fatEntry;
  372.     } /* fat12EntRead */
  374. /*******************************************************************************
  375. *
  376. * fat12EntWrite - write FAT entry to disk
  377. * 
  378. * This routine writes the file allocation table (FAT) entry to a dosFs
  379. * volume.
  380. *
  381. * This routine reads the file allocation table (FAT) entry for the
  382. * specified cluster and returns it to the caller.
  383. *
  384. * If the value to be written is too large to fit in a FAT entry
  385. * (12 bits), it is truncated (high order bits are discarded).
  386. *
  387. * This routine only writes to the first copy of the FAT on disk, even if
  388. * other copies exist.
  389. * 
  390. * RETURNS: OK, or ERROR if error accessing disk.
  391. */
  393. LOCAL STATUS fat12EntWrite
  394.     (
  395.     FAST DOS_FILE_DESC_ID pFd, /* pointer to file descriptor */
  396.     FAST uint32_t copyNum,/* fat copy number */
  397.     FAST uint32_t cluster,/* entry number */
  398.     FAST uint32_t value /* value to write */
  399.     )
  400.     {
  401.     FAST DOS_VOLUME_DESC_ID pVolDesc = pFd->pVolDesc;
  402. /* pointer to volume descriptor */
  403.     FAST CBIO_DEV_ID pCbio = pVolDesc->pCbio;
  404. /* pointer to CBIO device */
  405.     FAST MS_FAT_DESC_ID pFatDesc = (void *) pVolDesc->pFatDesc;
  406. /* pointer to FAT descriptor */
  407.     FAST uint32_t fatOff; /* offset in the FAT */
  408.     FAST block_t secNum; /* sector number to read/write */
  409.     FAST off_t secOff; /* offset in the sector */
  410.     FAST uint32_t nBytes; /* number of bytes */
  411.          cookie_t     cookie; /* CBIO dev. cookie */
  412.          uint8_t valBuf [2];
  413. /* buffer for value in the entry */
  415.     assert ( copyNum < pVolDesc->nFats);
  416.     assert ( (cluster >= DOS_MIN_CLUST) && (cluster < pFatDesc->nFatEnts) );
  417.     assert ( copyNum != pVolDesc->pFatDesc->activeCopyNum ||
  418.              ( (value == pFatDesc->dos_fat_avail) || 
  419.                ((value >= DOS_MIN_CLUST) && (value < pFatDesc->nFatEnts)) || 
  420.                (value == pFatDesc->dos_fat_eof) ) );
  422.     cookie = pFd->fatHdl.cbioCookie;
  424.     /* Offset of the entry in the FAT in bytes */
  426.     fatOff = cluster + (cluster >> 1); /* index = cluster * 1.5 */
  428.     /* Number of sector containing the entry */
  430.     secNum = pFatDesc->fatStartSec + copyNum * pVolDesc->secPerFat +
  431.             (fatOff >> pVolDesc->secSizeShift);
  433.     /* Mirror last modified FAT sector if entry is situated in other sector */
  435.     if (pFd->pFileHdl->fatSector != secNum &&
  436.         copyNum == pVolDesc->pFatDesc->activeCopyNum)
  437.         {
  438.         fat16MirrorSect (pFd);
  439.         pFd->pFileHdl->fatSector = secNum;
  440.         }
  442.     /* Offset of the entry in the sector */
  444.     secOff = fatOff & (pVolDesc->bytesPerSec - 1);
  446.     /* Number of bytes to write */
  448.     nBytes = pVolDesc->bytesPerSec - secOff;
  449.     if (nBytes > 2)
  450.         nBytes = 2;
  452.     /* Read previous entry value */
  454.     if (cbioBytesRW (pCbio, secNum, secOff,(addr_t) valBuf, nBytes, 
  455. CBIO_READ, &cookie) != OK)
  456.         return ERROR; /* read error */
  458.     if (nBytes == 1)
  459.         if (cbioBytesRW (pCbio, secNum + 1, 0,(addr_t) (&valBuf[1]), 1, 
  460. CBIO_READ, &pFd->fatHdl.cbioCookie) != OK)
  461.             return ERROR; /* read error */
  463.     if (cluster & 0x1) /* if cluster number is ODD */
  464.         {
  465.         valBuf [0] &= 0x0f; /* clear high order 4 bits */
  466.         valBuf [0] |= (value << 4); /* put in low bits of value */
  467.         valBuf [1]  = (value >> 4); /* next byte is high bits */
  468.         }
  469.     else /* if cluster number is EVEN */
  470.         {
  471.         valBuf [0]  = value; /* this byte gets low bits */
  472.         valBuf [1] &= 0xf0; /* clear low bits next byte */
  473.         valBuf [1] |= (value >> 8) & 0x0f; /* put in high bits */
  474.         }
  476.     /* Write entry to disk */
  478.     if (cbioBytesRW (pCbio, secNum, secOff,(addr_t)valBuf, nBytes, CBIO_WRITE, 
  479. &cookie) != OK)
  480.         return ERROR;
  482.     if (nBytes == 1)
  483.         if (cbioBytesRW (pCbio, secNum + 1, 0, (addr_t)(&valBuf [1]), 1, 
  484. CBIO_WRITE, &pFd->fatHdl.cbioCookie) != OK)
  485.         return ERROR;
  487.     return OK;
  488.     } /* fat12EntWrite */
  490. /*******************************************************************************
  491. * 
  492. * fat16EntRead - read FAT entry from disk
  493. * 
  494. * This routine reads the file allocation table (FAT) entry from a dosFs
  495. * volume.
  496. *
  497. * This routine only reads from the first copy of the FAT on disk, even if
  498. * other copies exist.
  499. * 
  500. * RETURNS: Contents of the entry, or FAT_CBIO_ERR if error accessing disk.
  501. */
  503. LOCAL uint32_t fat16EntRead
  504.     (
  505.     FAST DOS_FILE_DESC_ID pFd, /* pointer to file descriptor */
  506.     FAST uint32_t copyNum,/* fat copy number */
  507.     FAST uint32_t entry /* entry number */
  508.     )
  509.     {
  510.     FAST DOS_VOLUME_DESC_ID pVolDesc = pFd->pVolDesc;
  511. /* pointer to volume descriptor */
  512.     FAST CBIO_DEV_ID pCbio = pVolDesc->pCbio;
  513. /* pointer to CBIO device */
  514.     FAST MS_FAT_DESC_ID pFatDesc = (void *) pVolDesc->pFatDesc;
  515. /* pointer to FAT descriptor */
  516.     FAST block_t secNum; /* sector number to read/write */
  517.     FAST off_t secOff; /* offset in the sector */
  518.          uint8_t valBuf [2];
  519. /* buffer for value in the entry */
  521.     assert ( copyNum < pVolDesc->nFats);
  522.     assert ( (entry >= DOS_MIN_CLUST) && (entry < pFatDesc->nFatEnts) );
  524.     /* Offset of the entry in the FAT in bytes */
  526.     entry <<= 1;
  528.     /* Number of sector containing the entry */
  530.     secNum = pFatDesc->fatStartSec + copyNum * pVolDesc->secPerFat +
  531.             (entry >> pVolDesc->secSizeShift);
  533.     /* Offset of the entry in the sector */
  535.     secOff = entry & (pVolDesc->bytesPerSec - 1);
  537.     /* Read entry from disk */
  539.     if (cbioBytesRW (pCbio, secNum, secOff, (addr_t)valBuf, 2, CBIO_READ, 
  540. &pFd->fatHdl.cbioCookie) != OK)
  541.         {
  542.         pFd->fatHdl.errCode = FAT_CBIO_ERR;
  543.         return FAT_CBIO_ERR; /* read error */
  544.         }
  546.     return (valBuf [0] | (valBuf [1] << 8));
  547. /* copy word, swapping bytes */
  548.     } /* fat16EntRead */
  550. /*******************************************************************************
  551. * 
  552. * fat16EntWrite - write FAT entry to disk
  553. * 
  554. * This routine writes the file allocation table (FAT) entry to a dosFs
  555. * volume.
  556. *
  557. * This routine only writes to the first copy of the FAT on disk, even if
  558. * other copies exist.
  559. * 
  560. * RETURNS: OK, or ERROR if error accessing disk.
  561. */
  563. LOCAL STATUS fat16EntWrite
  564.     (
  565.     FAST DOS_FILE_DESC_ID pFd, /* pointer to file descriptor */
  566.     FAST uint32_t copyNum,/* fat copy number */
  567.     FAST uint32_t entry, /* entry number */
  568.     FAST uint32_t value /* value to write */
  569.     )
  570.     {
  571.     FAST DOS_VOLUME_DESC_ID pVolDesc = pFd->pVolDesc;
  572. /* pointer to volume descriptor */
  573.     FAST CBIO_DEV_ID pCbio = pVolDesc->pCbio;
  574. /* pointer to CBIO device */
  575.     FAST MS_FAT_DESC_ID pFatDesc = (void *) pVolDesc->pFatDesc;
  576. /* pointer to FAT descriptor */
  577.     FAST block_t secNum; /* sector number to read/write */
  578.     FAST off_t secOff; /* offset in the sector */
  579.          uint8_t valBuf [2];
  580. /* buffer for value in the entry */
  582.     assert ( copyNum < pVolDesc->nFats);
  583.     assert ( (entry >= DOS_MIN_CLUST) && (entry < pFatDesc->nFatEnts) );
  584.     assert ( copyNum != pVolDesc->pFatDesc->activeCopyNum ||
  585.              ( (value == pFatDesc->dos_fat_avail) || 
  586.                ((value >= DOS_MIN_CLUST) && (value < pFatDesc->nFatEnts)) || 
  587.                (value == pFatDesc->dos_fat_eof) ) );
  589.     /* Offset of the entry in the FAT in bytes */
  591.     entry <<= 1;
  593.     /* Number of sector containing the entry */
  595.     secNum = pFatDesc->fatStartSec + copyNum * pVolDesc->secPerFat +
  596.             (entry >> pVolDesc->secSizeShift);
  598.     /* Mirror last modified FAT sector if entry is situated in other sector */
  600.     if (pFd->pFileHdl->fatSector != secNum &&
  601.         copyNum == pVolDesc->pFatDesc->activeCopyNum)
  602.         {
  603.         fat16MirrorSect (pFd);
  604.         pFd->pFileHdl->fatSector = secNum;
  605.         }
  607.     /* Offset of the entry in the sector */
  609.     secOff = entry & (pVolDesc->bytesPerSec - 1);
  611.     valBuf [0] = value        & 0xff; /* this byte gets low bits */
  612.     valBuf [1] = (value >> 8) & 0xff; /* next byte gets high bits */
  614.     /* Write entry to disk */
  616.     return cbioBytesRW (pCbio, secNum, secOff, (addr_t)valBuf, 2, CBIO_WRITE, 
  617. &pFd->fatHdl.cbioCookie);
  618.     } /* fat16EntWrite */
  620. /*******************************************************************************
  621. * 
  622. * fat32EntRead - read FAT entry from disk
  623. * 
  624. * This routine reads the file allocation table (FAT) entry from a dosFs
  625. * volume.
  626. *
  627. * This routine only reads from the first copy of the FAT on disk, even if
  628. * other copies exist.
  629. * 
  630. * RETURNS: Contents of the entry, or FAT_CBIO_ERR if error accessing disk.
  631. */
  633. LOCAL uint32_t fat32EntRead
  634.     (
  635.     FAST DOS_FILE_DESC_ID pFd, /* pointer to file descriptor */
  636.     FAST uint32_t copyNum,/* fat copy number */
  637.     FAST uint32_t entry /* entry number */
  638.     )
  639.     {
  640.     FAST DOS_VOLUME_DESC_ID pVolDesc = pFd->pVolDesc;
  641. /* pointer to volume descriptor */
  642.     FAST CBIO_DEV_ID pCbio = pVolDesc->pCbio;
  643. /* pointer to CBIO device */
  644.     FAST MS_FAT_DESC_ID pFatDesc = (void *) pVolDesc->pFatDesc;
  645. /* pointer to FAT descriptor */
  646.     FAST block_t secNum; /* sector number to read/write */
  647.     FAST off_t secOff; /* offset in the sector */
  648.          uint8_t valBuf [4];
  649.          uint8_t highByteMask = 0x0f;
  651.     /* do not mask high bits when non active copy is being written */
  653.     if (copyNum != pVolDesc->pFatDesc->activeCopyNum)
  654.      highByteMask = 0xff;
  655. /* buffer for value in the entry */
  657.     assert ( copyNum < pVolDesc->nFats);
  658.     assert ( (entry >= DOS_MIN_CLUST) && (entry < pFatDesc->nFatEnts) );
  660.     /* Offset of the entry in the FAT in bytes */
  662.     entry <<= 2;
  664.     /* Number of sector containing the entry */
  666.     secNum = pFatDesc->fatStartSec + copyNum * pVolDesc->secPerFat +
  667.             (entry >> pVolDesc->secSizeShift);
  669.     /* Offset of the entry in the sector */
  671.     secOff = entry & (pVolDesc->bytesPerSec - 1);
  673.     /* Read entry from disk */
  675.     if (cbioBytesRW (pCbio, secNum, secOff, (addr_t)valBuf, 4, CBIO_READ, 
  676.      &pFd->fatHdl.cbioCookie) != OK)
  677.         {
  678.         pFd->fatHdl.errCode = FAT_CBIO_ERR;
  679.         return FAT_CBIO_ERR; /* read error */
  680.         }
  682.     return (valBuf [0] | (valBuf [1] << 8) | (valBuf [2] << 16) | 
  683.             ((valBuf [3] & highByteMask) << 24));/* mask highest 4 bits */
  684.     } /* fat32EntRead */
  686. /*******************************************************************************
  687. * 
  688. * fat32EntWrite - write FAT entry to disk
  689. * 
  690. * This routine writes the file allocation table (FAT) entry to a dosFs
  691. * volume.
  692. *
  693. * This routine only writes to the first copy of the FAT on disk, even if
  694. * other copies exist.
  695. * 
  696. * RETURNS: OK, or ERROR if error accessing disk.
  697. */
  699. LOCAL STATUS fat32EntWrite
  700.     (
  701.     FAST DOS_FILE_DESC_ID pFd, /* pointer to file descriptor */
  702.     FAST uint32_t copyNum,/* fat copy number */
  703.     FAST uint32_t entry, /* entry number */
  704.     FAST uint32_t value /* value to write */
  705.     )
  706.     {
  707.     FAST DOS_VOLUME_DESC_ID pVolDesc = pFd->pVolDesc;
  708. /* pointer to volume descriptor */
  709.     FAST CBIO_DEV_ID pCbio = pVolDesc->pCbio;
  710. /* pointer to CBIO device */
  711.     FAST MS_FAT_DESC_ID pFatDesc = (void *) pVolDesc->pFatDesc;
  712. /* pointer to FAT descriptor */
  713.     FAST block_t secNum; /* sector number to read/write */
  714.     FAST off_t secOff; /* offset in the sector */
  715.          uint8_t valBuf [4];
  716. /* buffer for value in the entry */
  717.          uint8_t highByteMask = 0x0f;
  719.     /* do not mask high bits when non active copy is being written */
  721.     if (copyNum != pVolDesc->pFatDesc->activeCopyNum)
  722.      highByteMask = 0xff;
  724.     assert ( copyNum < pVolDesc->nFats);
  725.     assert ( (entry >= DOS_MIN_CLUST) && (entry < pFatDesc->nFatEnts) );
  726.     assert ( highByteMask == 0xff ||
  727.              ( (value == pFatDesc->dos_fat_avail) || 
  728.                ((value >= DOS_MIN_CLUST) && (value < pFatDesc->nFatEnts)) || 
  729.                (value == pFatDesc->dos_fat_eof) ) );
  731.     /* Offset of the entry in the FAT in bytes */
  733.     entry <<= 2;
  735.     /* Number of sector containing the entry */
  737.     secNum = pFatDesc->fatStartSec + copyNum * pVolDesc->secPerFat +
  738.             (entry >> pVolDesc->secSizeShift);
  740.     /* Mirror last modified FAT sector if entry is situated in other sector */
  742.     if (pFd->pFileHdl->fatSector != secNum && highByteMask != 0xff )
  743.         {
  744.         fat16MirrorSect (pFd);
  745.         pFd->pFileHdl->fatSector = secNum;
  746.         }
  748.     /* Offset of the entry in the sector */
  750.     secOff = entry & (pVolDesc->bytesPerSec - 1);
  752.     valBuf [0] = value         & 0xff; /*  */
  753.     valBuf [1] = (value >> 8)  & 0xff; /*  */
  754.     valBuf [2] = (value >> 16) & 0xff; /*  */
  755.     valBuf [3] = (value >> 24) & highByteMask; /*  */
  757.     /* Write entry to disk */
  759.     return cbioBytesRW (pCbio, secNum, secOff, (addr_t)valBuf, 4, CBIO_WRITE, 
  760. &pFd->fatHdl.cbioCookie);
  761.     } /* fat32EntWrite */
  763. /*******************************************************************************
  764. *
  765. * fat16ContigGet - get next section of contiguous clusters in file chain
  766. * 
  767. * This routine reads FAT entries starting from the passed cluster number, and 
  768. * returns number of contiguous clusters in the file chain starting from the 
  769. * passed one up to number of clusters requested.
  770. *
  771. * If starting cluster number is out of legal cluster number range, a 0 is 
  772. * returned, except of the following 2 cases:
  773. *
  774. * 1) If start cluster number is 0 .
  775. *
  776. * 2) If start cluster number is end of file .
  777. *
  778. * This routine checks the File Allocation Table (FAT) to determine the
  779. * length, in clusters, of a contiguous section of a file.  The starting
  780. * cluster to check is passed as an input parameter.  The number of
  781. * contiguous clusters beginning with that cluster (including the starting
  782. * cluster itself) is returned.  The minimum returned value is 1.
  783. *
  784. * RETURNS: Number of contiguous clusters in chain starting from the passed one,
  785. *          or 0 if starting cluster number is illegal or disk access error.
  786. */
  788. LOCAL STATUS fat16ContigGet
  789.     (
  790.     FAST DOS_FILE_DESC_ID pFd, /* pointer to file descriptor */
  791.     FAST uint32_t   numClusts /* num. of clusters to follow */
  792.     )
  793.     {
  794.     FAST DOS_FILE_HDL_ID pFileHdl = pFd->pFileHdl;
  795. /* pointer to file handle */
  796.     FAST DOS_FAT_HDL_ID pFatHdl = &(pFd->fatHdl);
  797. /* pointer to FAT handle */
  798.     FAST DOS_VOLUME_DESC_ID pVolDesc = pFd->pVolDesc;
  799. /* pointer to volume descriptor */
  800.     FAST MS_FAT_DESC_ID pFatDesc = (void *) pVolDesc->pFatDesc;
  801. /* pointer to FAT handler descriptor */
  802.     FAST uint32_t startClust; /* starting cluster number */
  803.     FAST uint32_t nextClust; /* next cluster number */
  804.     FAST uint32_t cluster; /* cluster number */
  805.     FAST uint32_t maxClust; /* maximum cluster number */
  807.     startClust = nextClust = pFatHdl->nextClust;
  808.     cluster    = pFatHdl->lastClust;
  810.     if ((startClust < DOS_MIN_CLUST) || (startClust >= pFatDesc->nFatEnts))
  811.         {
  812.         if ((startClust == 0) && (cluster == 0)) /* file just open */
  813.             startClust = pFileHdl->startClust;
  815.         if (startClust > pFatDesc->dos_fat_bad) /* end of file chain */
  816.          {
  817.             startClust = ENTRY_READ (pFd, pFatDesc->dosFatDesc.activeCopyNum,
  818.                                      cluster);
  819.          }
  821.         if ((startClust < DOS_MIN_CLUST) || (startClust >= pFatDesc->nFatEnts))
  822.             {
  823.             assert ((startClust == 0) || (startClust > pFatDesc->dos_fat_bad));
  824.             pFatHdl->nextClust = startClust;
  825.             return ERROR;
  826.             }
  827.         }
  829.     if ( (startClust < pFileHdl->contigEndPlus1) && 
  830.          (startClust >= pFileHdl->startClust) )
  831.         { /* in contiguous area */
  832.         cluster = startClust + numClusts; /* lastClust + 1 */
  833. /* numClusts can be avoided in the function calls and changed 
  834.  * to pFatDesc->fatGroupSize inside the function 
  835.  */
  837.         if (cluster >= pFileHdl->contigEndPlus1)
  838.             {
  839.             cluster = pFileHdl->contigEndPlus1; /* lastClust + 1 */
  840.             nextClust = pFatDesc->dos_fat_eof;
  841.             }
  842.         else
  843.             nextClust = cluster;
  845.         DBG_MSG (2, "Get from contiguous area.n", 1,2,3,4,5,6);
  846.         }
  847.     else
  848.         { /* out of contiguous area */
  850.         /* Count number of contiguous clusters starting from <startClust> */
  852.         maxClust = startClust + numClusts;
  853.         if (maxClust > pFatDesc->nFatEnts)
  854.             maxClust = pFatDesc->nFatEnts;
  855.         cluster = startClust; /* initialize cluster number */
  857.         while (cluster < maxClust)
  858.             {
  859.             nextClust = ENTRY_READ (pFd, pFatDesc->dosFatDesc.activeCopyNum,
  860.                                     cluster); /* follow chain */
  862.             if (nextClust != ++cluster)
  863.                 break; /* end of contiguous area */
  864.             }
  866.         if (pFatHdl->errCode == FAT_CBIO_ERR)
  867.             return ERROR;
  868.         }
  869. #ifdef __unused
  870.     assert ( ((nextClust >= DOS_MIN_CLUST)&&
  871.               (nextClust < pFatDesc->nFatEnts)) ||
  872.              ((nextClust > pFatDesc->dos_fat_bad) && 
  873.               (nextClust <= pFatDesc->dos_fat_eof)) );
  874. #endif
  875.     /* Store contents of last entry in contiguous section */
  877.     pFatHdl->nextClust = nextClust;
  879.     pFatHdl->lastClust = cluster - 1;
  881.     pFd->curSec = CLUST_TO_SEC (pVolDesc, startClust);
  883.     pFd->nSec   = (cluster - startClust) * pVolDesc->secPerClust;
  885.     DBG_MSG (2, "Get %ld clusters starting from cluster %ldn", 
  886.              cluster - startClust, startClust,3,4,5,6);
  888.     return OK;
  889.     } /* fat16ContigGet */
  891. /*******************************************************************************
  892. *
  893. * fat16MarkAlloc - allocate a contiguous set of clusters
  894. *
  895. *
  896. * RETURNS: ERROR if was unable to allocate requested amount of space
  897. */
  899. LOCAL STATUS fat16MarkAlloc
  900.     (
  901.     FAST DOS_FILE_DESC_ID pFd, /* pointer to file descriptor */
  902.     FAST uint32_t firstClust, /* initial cluster to search */
  903.     FAST uint32_t numClusts /* number of clusters needed */
  904.     )
  905.     {
  906.     FAST MS_FAT_DESC_ID pFatDesc = (void *) pFd->pVolDesc->pFatDesc;
  907. /* pointer to FAT descriptor */
  908.     FAST uint32_t curClust; /* current cluster number */
  910.     assert ((firstClust >= DOS_MIN_CLUST) && 
  911.             (firstClust < pFatDesc->nFatEnts));
  912.     assert (numClusts <= (pFatDesc->nFatEnts - DOS_MIN_CLUST));
  914.     /* Build cluster chain in FAT */
  916.     for (curClust = firstClust; 
  917.          curClust < (firstClust + numClusts - 1); 
  918.          curClust++)
  919.         {
  921.         /* Each entry = next clust. num. */
  923.         if (ENTRY_WRITE (pFd, pFatDesc->dosFatDesc.activeCopyNum,
  924.                          curClust, curClust + 1) != OK)
  925.             return ERROR; /* disk access error */
  927.         /* Update free clusters counter */
  929.         pFatDesc->fatEntFreeCnt--;
  930.         }
  932.     /* Mark last entry as end of file cluster chain */
  934.     if (ENTRY_WRITE (pFd, pFatDesc->dosFatDesc.activeCopyNum, curClust,
  935.                      pFatDesc->dos_fat_eof) != OK)
  936.         return ERROR; /* disk access error */
  938.     pFatDesc->fatEntFreeCnt--;
  940.     return OK;
  941.     } /* fat16MarkAlloc */
  943. /*******************************************************************************
  944. *
  945. * fat16GetNext - get/allocate next cluster for file
  946. *
  947. * This routine searches the File Allocation Table (FAT) for a sequence
  948. * of contiguous free clusters, and allocates clusters to extend the
  949. * current chain if requested to do so.
  950. *
  951. * RETURNS: resulting chain of sectors in the File Descriptor structure.
  952. */
  954. LOCAL STATUS fat16GetNext
  955.     (
  956.     FAST DOS_FILE_DESC_ID pFd, /* pointer to file descriptor */
  957.     FAST uint_t   allocPolicy /* allocation policy */
  958.     )
  959.     {
  960.     FAST DOS_FILE_HDL_ID pFileHdl = pFd->pFileHdl;
  961. /* pointer to file handle */
  962.     FAST DOS_FAT_HDL_ID pFatHdl = &pFd->fatHdl;
  963. /* pointer to FAT handle */
  964.     FAST DOS_VOLUME_DESC_ID pVolDesc = pFd->pVolDesc;
  965. /* pointer to volume descriptor */
  966.     FAST MS_FAT_DESC_ID pFatDesc = (void *) pVolDesc->pFatDesc;
  967. /* pointer to FAT descriptor */
  968.     FAST uint32_t startClust; /*  */
  969.     FAST uint32_t numClusts; /*  */
  970.     FAST uint32_t prevClust; /*  */
  971.     FAST uint32_t firstClust; /*  */
  972.     FAST uint32_t contigCount; /* count of fit clusters */
  973.     FAST uint32_t curClust; /* current cluster number */
  974.     FAST uint32_t fatEntry; /* FAT entry */
  975.     FAST uint32_t maxClust; /* maximum cluster number */
  976.     FAST uint32_t pass; /*  */
  978.     /* Try to follow file chain */
  980.     if (fat16ContigGet (pFd, pFatDesc->fatGroupSize) == OK)
  981.         return OK;
  983.     if (pFatHdl->errCode == FAT_CBIO_ERR)
  984.         return ERROR;
  986.     /* Can't follow file chain */
  988.     if ((allocPolicy & FAT_ALLOC) == 0) /* not alloc */
  989.         return ERROR;
  991.     firstClust = pFatHdl->nextClust;
  992.     prevClust  = pFatHdl->lastClust;
  993.     startClust = 0;
  995.     /* Set number of clusters to allocate.
  996.      */
  998.     if (pFatDesc->groupAllocStart == 0) /* no free groups in prev. alloc. */
  999.         allocPolicy = FAT_ALLOC_ONE;
  1001.     numClusts = (allocPolicy == (uint_t)FAT_ALLOC_ONE) ? 
  1002. 1 : pFatDesc->fatGroupSize;
  1004.     /* Set initial cluster number to try allocation from.
  1005.      */
  1007.     if (firstClust > pFatDesc->dos_fat_bad) /* end of file chain */
  1008.         startClust = prevClust;
  1010.     else if ((firstClust == 0) && (prevClust == 0)) /* it is a new file */
  1011.         startClust = (allocPolicy == (uint_t)FAT_ALLOC_ONE) ?
  1012.                      pFatDesc->clustAllocStart : pFatDesc->groupAllocStart;
  1014.     if (startClust == 0)
  1015.         {
  1016.         errnoSet (S_dosFsLib_ILLEGAL_CLUSTER_NUMBER);
  1017.         return ERROR;
  1018.         }
  1020.     /* Try finding a set of clusters starting at or after the initial one.
  1021.      *   Continue searching upwards until end of FAT.
  1022.      */
  1024.     maxClust    = pFatDesc->nFatEnts - 1;
  1025.     curClust    = startClust; /* start from initial cluster number */
  1026.     firstClust  = 0;
  1027.     contigCount = 0;
  1029.     semTake (pFatDesc->allocSem, WAIT_FOREVER);
  1031.     for (pass = 0; pass < 2; pass++)
  1032.         {
  1033.         while (curClust <= maxClust)
  1034.             {
  1035.             fatEntry = ENTRY_READ (pFd, pFatDesc->dosFatDesc.activeCopyNum,
  1036.                                    curClust);
  1038.             if ((fatEntry == FAT_CBIO_ERR)&&(pFatHdl->errCode == FAT_CBIO_ERR))
  1039.                 goto group_alloc_error;
  1041.             if (fatEntry == pFatDesc->dos_fat_avail)
  1042.                 { /* free space */
  1043.                 if (contigCount == 0)
  1044.                     firstClust = curClust;/* this one will be new start */
  1046.                 if (++contigCount == numClusts) /* one more found */
  1047.                     goto group_alloc; /* quit if enough found */
  1048.                 }
  1049.             else /* allocated space */
  1050.                 {
  1051.                 contigCount = 0;
  1052.                 }
  1054.             curClust++;
  1055.             } /* while */
  1057.         /* 
  1058.  * Try finding a contiguous area starting before the current cluster
  1059.          * Note that the new contiguous area could include the initial cluster
  1060.          */
  1062.         maxClust    = startClust - 1;
  1063.         curClust    = DOS_MIN_CLUST; /* start from lowest cluster number */
  1064.         contigCount = 0;
  1065.         } /* for */
  1067.     if (firstClust == 0)
  1068.         {
  1069.         errnoSet (S_dosFsLib_DISK_FULL);
  1070.         ERR_MSG (1, "!!! DISK FULL !!!n", 1,2,3,4,5,6);
  1071.         goto group_alloc_error; /* could not find space */
  1072.         }
  1074.     pFatDesc->groupAllocStart = 0;
  1076.     numClusts = 1;
  1078. group_alloc: /* Allocate the found chain */
  1080.     if (fat16MarkAlloc (pFd, firstClust, numClusts) != OK)
  1081.         goto group_alloc_error;
  1083.     semGive (pFatDesc->allocSem);
  1084.     DBG_MSG (1, "Allocated %ld clusters starting from cluster %ldn", 
  1085.              contigCount, firstClust,3,4,5,6);
  1087.     /*  */
  1089.     if (startClust == prevClust)
  1090.         {
  1091.         /* Add just allocated contiguous section to the file chain */
  1093.         if (ENTRY_WRITE (pFd, pFatDesc->dosFatDesc.activeCopyNum,
  1094.                         prevClust, firstClust) != OK)
  1095.             return ERROR;
  1097.         if (firstClust == pFileHdl->contigEndPlus1)
  1098.             pFileHdl->contigEndPlus1 = firstClust + numClusts;
  1100.         DBG_MSG (1, " ----- Old end %ld -----n", prevClust,2,3,4,5,6);
  1101.         }
  1102.     else
  1103.         {
  1104.         /* Advance start allocation cluster number */
  1106.         if (allocPolicy == (uint_t)FAT_ALLOC_ONE)
  1107.             pFatDesc->clustAllocStart = firstClust + 1;
  1108.         else
  1109.             if (pFatDesc->groupAllocStart != 0)
  1110.                 pFatDesc->groupAllocStart = firstClust + numClusts;
  1112.         DBG_MSG (1, " ----- Old start %ld -----n", startClust,2,3,4,5,6);
  1113.         DBG_MSG (1, " ----- New start %ld -----n", firstClust,2,3,4,5,6);
  1115.         pFileHdl->startClust = firstClust;
  1116.         pFileHdl->contigEndPlus1  = firstClust + numClusts;
  1117.         }
  1119.     pFatHdl->nextClust = pFatDesc->dos_fat_eof;
  1121.     pFatHdl->lastClust = firstClust + numClusts - 1;
  1123.     pFd->curSec = CLUST_TO_SEC (pVolDesc, firstClust);
  1125.     pFd->nSec   = numClusts * pVolDesc->secPerClust;
  1127.     return OK;
  1129. group_alloc_error:
  1130.     semGive (pFatDesc->allocSem);
  1131.     return ERROR;
  1132.     } /* fat16GetNext */
  1134. /*******************************************************************************
  1135. *
  1136. * fat16Truncate - truncate chain starting from cluster
  1137. *
  1138. * This routine is used when removing files and directories as well as
  1139. * when truncating files. It will follow
  1140. * a chain of cluster entries in the file allocation table (FAT), freeing each
  1141. * as it goes.
  1142. *
  1143. * RETURNS: OK or ERROR if invalid cluster encountered in chain
  1144. */
  1146. LOCAL STATUS fat16Truncate
  1147.     (
  1148.     FAST DOS_FILE_DESC_ID pFd, /* pointer to file descriptor */
  1149.     FAST uint32_t sector, /* sector to truncate from */
  1150.     FAST uint32_t flag /* FH_INCLUDE or FH_EXCLUDE */
  1151.     )
  1152.     {
  1153.     FAST DOS_FILE_HDL_ID pFileHdl = pFd->pFileHdl;
  1154. /* pointer to file handle */
  1155.     FAST DOS_VOLUME_DESC_ID pVolDesc = pFd->pVolDesc;
  1156. /* pointer to volume descriptor */
  1157.     FAST MS_FAT_DESC_ID pFatDesc = (void *) pVolDesc->pFatDesc;
  1158. /* pointer to FAT descriptor */
  1159.     FAST uint32_t curClust; /* current cluster */
  1160.     FAST uint32_t nextClust; /* next cluster in chain */
  1161.     FAST uint32_t cluster; /* cluster to truncate from */
  1163.     if (sector == FH_FILE_START)
  1164.         {
  1165.         cluster = pFileHdl->startClust;
  1166.         pFileHdl->contigEndPlus1 = 0;
  1168.         if (cluster < DOS_MIN_CLUST)
  1169.             {
  1170.             errnoSet (S_dosFsLib_INVALID_PARAMETER); /* ??? */
  1171.             return ERROR;
  1172.             }
  1173.         }
  1174.     else
  1175.         {
  1176.         if (sector < pVolDesc->dataStartSec)
  1177.             {
  1178.             errnoSet (S_dosFsLib_INVALID_PARAMETER);
  1179.             return ERROR;
  1180.             }
  1182.         cluster = SEC_TO_CLUST (pVolDesc, sector);
  1183.         }
  1185.     if (cluster >= pFatDesc->nFatEnts)
  1186.         {
  1187.         errnoSet (S_dosFsLib_INVALID_PARAMETER); /* ??? */
  1188.         return ERROR;
  1189.         }
  1191.     switch (flag )
  1192.         {
  1193.         case FH_INCLUDE:
  1194.             if ((sector == FH_FILE_START) || 
  1195.                (((sector - pVolDesc->dataStartSec) % 
  1196.                     pVolDesc->secPerClust) == 0))
  1197.                 {
  1198.                 curClust = cluster;
  1199.                 break;
  1200.                 }
  1202.         case FH_EXCLUDE:
  1203.             /* Read cluster to truncate from, including this one */
  1204.     
  1205.             curClust = ENTRY_READ (pFd, pFatDesc->dosFatDesc.activeCopyNum,
  1206.                                    cluster);
  1207.     
  1208.             if (curClust > pFatDesc->dos_fat_bad)
  1209.                 return OK; /* end of file */
  1211.             if ((curClust < DOS_MIN_CLUST) || (curClust >= pFatDesc->nFatEnts))
  1212.                 return ERROR; /*  */
  1213.     
  1214.             /* Mark passed cluster as end of file */
  1215.     
  1216.             if (ENTRY_WRITE (pFd, pFatDesc->dosFatDesc.activeCopyNum,
  1217.                              cluster, pFatDesc->dos_fat_eof) != OK)
  1218.                 return ERROR; /* disk access error */
  1220.             break;
  1222.         default:
  1223.             {
  1224.             errnoSet (S_dosFsLib_INVALID_PARAMETER);
  1225.             return ERROR;
  1226.             }
  1227.         }
  1229.     if ( (curClust < pFileHdl->contigEndPlus1) && 
  1230.          (curClust >= pFileHdl->startClust) )
  1231.         pFileHdl->contigEndPlus1 = curClust;
  1233.     if (pFatDesc->groupAllocStart == 0)
  1234.         pFatDesc->groupAllocStart = curClust;
  1236.    /* Adjust single cluster allocation start point to start of the disk */
  1238.     if (pFatDesc->clustAllocStart > curClust)
  1239.         pFatDesc->clustAllocStart = curClust;
  1241.     /* Free a chain of clusters */
  1243.     while ((curClust >= DOS_MIN_CLUST) && (curClust < pFatDesc->nFatEnts))
  1244.         {
  1245.         /* get next cluster in chain */
  1247.         nextClust = ENTRY_READ (pFd, pFatDesc->dosFatDesc.activeCopyNum,
  1248.                                 curClust);
  1250.         /* free current cluster (mark cluster in FAT as available) */
  1252.         if (ENTRY_WRITE (pFd, pFatDesc->dosFatDesc.activeCopyNum,
  1253.                          curClust, pFatDesc->dos_fat_avail) != OK)
  1254.             return ERROR;
  1256.         /* Update free clusters counter */
  1258.         pFatDesc->fatEntFreeCnt++;
  1260.         curClust = nextClust; /* do next cluster */
  1261.         }
  1263.     if (curClust <= pFatDesc->dos_fat_bad) /* If not end of file */
  1264.         return ERROR;
  1266.     return OK;
  1267.     } /* fat16Truncate */
  1269. /*******************************************************************************
  1270. *
  1271. * fat16Seek - seek cluster within file chain
  1272. *
  1273. * Returns a particular cluster relative to the cluster chain beginning
  1274. * which is noted in the file descriptor structure.
  1275. * It is used to seek in to a file.
  1276. *
  1277. * RETURNS: requested position is returned in the file descriptor structure
  1278. */
  1280. LOCAL STATUS fat16Seek
  1281.     (
  1282.     FAST DOS_FILE_DESC_ID pFd, /* pointer to file descriptor */
  1283.     FAST uint32_t sector, /* sector to seek from */
  1284.     FAST uint32_t sectOff /* sector offset within file */
  1285.     )
  1286.     {
  1287.     FAST DOS_VOLUME_DESC_ID pVolDesc = pFd->pVolDesc;
  1288. /* pointer to volume descriptor */
  1289.     FAST MS_FAT_DESC_ID pFatDesc = (void *) pVolDesc->pFatDesc;
  1290. /* pointer to FAT descriptor */
  1291.     FAST uint32_t nextClust; /* next cluster number */
  1292.     FAST uint32_t count; /* count of clusters */
  1293.     FAST uint32_t cluster; /* cluster to seek from */
  1294.     FAST uint32_t clustOff; /*  */
  1296.     if (sector == FH_FILE_START)
  1297.         {
  1298.         pFd->fatHdl.nextClust  = 0;
  1299.         pFd->fatHdl.lastClust  = 0;
  1300.         pFd->fatHdl.cbioCookie = 0;
  1302.         pFd->curSec = 0;
  1303.         pFd->nSec   = 0;
  1305.         cluster = pFd->pFileHdl->startClust;
  1307.         if (cluster == 0)
  1308.             return OK;
  1310.         if (cluster < DOS_MIN_CLUST)
  1311.             return ERROR;
  1312.         }
  1313.     else
  1314.         {
  1315.         if (sector < pVolDesc->dataStartSec)
  1316.             return ERROR;
  1318.         /* cluster to seek from */
  1320.         cluster = SEC_TO_CLUST (pVolDesc, sector);
  1322.         /* offset from start of cluster */
  1324.         sectOff += (sector - pVolDesc->dataStartSec) % pVolDesc->secPerClust;
  1325.         }
  1327.     if (cluster >= pFatDesc->nFatEnts)
  1328.         return ERROR;
  1330.     clustOff = sectOff / pVolDesc->secPerClust;
  1332.     sectOff %= pVolDesc->secPerClust;
  1334.     /* Skip contiguous area */
  1336.     if ( (cluster < pFd->pFileHdl->contigEndPlus1) && 
  1337.          (cluster >= pFd->pFileHdl->startClust) )
  1338.         {
  1339.         count = min (clustOff, pFd->pFileHdl->contigEndPlus1 - cluster - 1);
  1340.         cluster += count;
  1341.         clustOff -= count;
  1342.         }
  1344.     for (count = 0; count < clustOff; count++)
  1345.         {
  1346.         nextClust = ENTRY_READ (pFd, pFatDesc->dosFatDesc.activeCopyNum,
  1347.                                 cluster); /* follow chain */
  1349.         /* If end of cluster chain, bad cluster number or disk access error */
  1351.         if ((nextClust < DOS_MIN_CLUST) || (nextClust >= pFatDesc->nFatEnts))
  1352.             return ERROR;
  1354.         cluster = nextClust; /* do next cluster */
  1355.         }
  1357.     pFd->fatHdl.nextClust = cluster;
  1359.     if (fat16ContigGet (pFd, pFatDesc->fatGroupSize) != OK)
  1360.         return ERROR;
  1362.     pFd->curSec += sectOff;
  1364.     pFd->nSec   -= sectOff;
  1366.     return OK;
  1367.     } /* fat16Seek */
  1369. /*******************************************************************************
  1370. *
  1371. * fat16NFree - count number of free bytes on disk
  1372. *
  1373. *
  1374. * RETURNS: amount of free space is returned in file descriptor handle
  1375. */
  1377. LOCAL fsize_t fat16NFree
  1378.     (
  1379.     FAST DOS_FILE_DESC_ID pFd /* pointer to file descriptor */
  1380.     )
  1381.     {
  1382.     FAST DOS_VOLUME_DESC_ID pVolDesc = pFd->pVolDesc;
  1383. /* pointer to volume descriptor */
  1384.     FAST MS_FAT_DESC_ID pFatDesc = (void *) pVolDesc->pFatDesc;
  1385. /* pointer to FAT descriptor */
  1386.     FAST uint32_t clustNum; /* cluster number */
  1387.     FAST uint32_t fatEntry; /*  */
  1388.     FAST uint32_t freeCount; /*  */
  1390.     freeCount = pFatDesc->fatEntFreeCnt;
  1392.     if(freeCount == 0xffffffff)
  1393.         {
  1394.         freeCount = 0;
  1396.         /* Read file allocation table (FAT) to find unused clusters */
  1398.         for (clustNum=DOS_MIN_CLUST; clustNum < pFatDesc->nFatEnts; clustNum++)
  1399.             {
  1400.             fatEntry = ENTRY_READ (pFd, pFatDesc->dosFatDesc.activeCopyNum,
  1401.                                    clustNum);
  1403.             if ((fatEntry == FAT_CBIO_ERR)&&
  1404.                 (pFd->fatHdl.errCode == FAT_CBIO_ERR))
  1405.                 return ERROR;
  1407.             if (fatEntry == pFatDesc->dos_fat_avail)
  1408.                 freeCount++;
  1409.             }
  1411.         pFatDesc->fatEntFreeCnt = freeCount;
  1412.         }
  1414.     return ( (((fsize_t)freeCount) * pVolDesc->secPerClust) << 
  1415.              pVolDesc->secSizeShift );
  1416.     } /* fat16NFree */
  1418. /*******************************************************************************
  1419. *
  1420. * fat16ContigChk - check file chain for contiguity
  1421. *
  1422. * RETURNS: ERROR if an illegal cluster number is encountered
  1423. */
  1425. LOCAL STATUS fat16ContigChk
  1426.     (
  1427.     FAST DOS_FILE_DESC_ID pFd /* pointer to file descriptor */
  1428.     )
  1429.     {
  1430.     FAST DOS_FILE_HDL_ID pFileHdl = pFd->pFileHdl;
  1431. /* pointer to file handle */
  1432.     FAST MS_FAT_DESC_ID pFatDesc = (void *) pFd->pVolDesc->pFatDesc;
  1433. /* pointer to FAT handler descriptor */
  1434.     FAST uint32_t nextClust; /* next cluster number */
  1435.     FAST uint32_t cluster; /* cluster number */
  1437.     cluster = pFileHdl->startClust;
  1439.     if (cluster == 0)
  1440.         return OK;
  1442.     if ((cluster < DOS_MIN_CLUST) || (cluster >= pFatDesc->nFatEnts))
  1443.         {
  1444.         errnoSet (S_dosFsLib_ILLEGAL_CLUSTER_NUMBER);
  1445.         return ERROR;
  1446.         }
  1448.     FOREVER
  1449.         {
  1450.         nextClust = ENTRY_READ (pFd, pFatDesc->dosFatDesc.activeCopyNum,
  1451.                                 cluster); /* follow chain */
  1453.         if (nextClust != ++cluster)
  1454.             break; /* end of contiguous area */
  1455.         }
  1457.     if (pFd->fatHdl.errCode == FAT_CBIO_ERR)
  1458.         return ERROR;
  1460.     pFileHdl->contigEndPlus1 = cluster;
  1462.     if (nextClust > pFatDesc->dos_fat_bad) /* end of file chain */
  1463.         return OK;
  1465.     if ((nextClust < DOS_MIN_CLUST) || (nextClust >= pFatDesc->nFatEnts))
  1466. {
  1467.         errnoSet (S_dosFsLib_ILLEGAL_CLUSTER_NUMBER);
  1468. }
  1470.     return ERROR;
  1471.     } /* fat16ContigChk */
  1473. /*******************************************************************************
  1474. *
  1475. * fat16MaxContigClustersGet - return size of largest contiguous space on disk
  1476. * 
  1477. * RETURNS: max contiguous space in clusters
  1478. */ 
  1479.  
  1480. LOCAL size_t fat16MaxContigClustersGet
  1481.     (
  1482.     FAST DOS_FILE_DESC_ID pFd, /* pointer to file descriptor */
  1483.     FAST uint32_t * pMaxStart /* were to return start clust */
  1484.     )
  1485.     {
  1486.     FAST MS_FAT_DESC_ID pFatDesc = (void *) pFd->pVolDesc->pFatDesc;
  1487. /* pointer to FAT handler descriptor */
  1488.     FAST uint32_t fatEntry; /*  */
  1489.     FAST uint32_t curClust; /*  */
  1490.     FAST uint32_t firstContig; /* 1st clust. of contig area */
  1491.     FAST uint32_t contigCount; /* count of fit clusters */
  1492.     FAST uint32_t maxStart; /*  */
  1493.     FAST uint32_t maxCount; /*  */
  1495.     firstContig = DOS_MIN_CLUST;
  1496.     contigCount = 0;
  1497.     maxStart    = 0;
  1498.     maxCount    = 0;
  1500.     for (curClust = DOS_MIN_CLUST; curClust < pFatDesc->nFatEnts; curClust++)
  1501.         {
  1502.         fatEntry = ENTRY_READ (pFd, pFatDesc->dosFatDesc.activeCopyNum,
  1503.                                curClust);
  1505.         if ((fatEntry == FAT_CBIO_ERR)&&(pFd->fatHdl.errCode == FAT_CBIO_ERR))
  1506.             return 0;
  1508.         if (fatEntry == pFatDesc->dos_fat_avail)
  1509.             { /* free space */
  1510.             contigCount++; /* one more found */
  1511.             }
  1512.         else
  1513.             {
  1514.             /* Check for maximum */
  1516.             if (contigCount > maxCount)
  1517.                 {
  1518.                 maxStart = firstContig;
  1519.                 maxCount = contigCount;
  1520.                 }
  1522.             firstContig = curClust + 1; /* next one will be new start */
  1524.             contigCount = 0;
  1525.             }
  1526.         } /* for */
  1528.     if (contigCount > maxCount)
  1529.         {
  1530.         maxStart = firstContig;
  1531.         maxCount = contigCount;
  1532.         }
  1534.     *pMaxStart = maxStart;
  1535.     return (maxCount);
  1536.     } /* fat16MaxContigClustersGet */
  1538. /*******************************************************************************
  1539. *
  1540. * fat16ContigAlloc - allocate <numSect> contiguous chain
  1541. *
  1542. * This function employs the Best Fit algorithm to locate a
  1543. * contiguous fragment of space for the requested size
  1544. *
  1545. * RETURNS: ERROR if requested space is not available
  1546. */
  1548. LOCAL STATUS fat16ContigAlloc
  1549.     (
  1550.     FAST DOS_FILE_DESC_ID pFd, /* pointer to file descriptor */
  1551.     FAST uint32_t number /* number of sectors needed */
  1552.     )
  1553.     {
  1554.     FAST DOS_FILE_HDL_ID pFileHdl = pFd->pFileHdl;
  1555. /* pointer to file handle */
  1556.     FAST DOS_VOLUME_DESC_ID pVolDesc = pFd->pVolDesc;
  1557. /* pointer to volume descriptor */
  1558.     FAST MS_FAT_DESC_ID pFatDesc = (void *) pVolDesc->pFatDesc;
  1559. /* pointer to FAT handler descriptor */
  1560.     FAST uint32_t fatEntry; /*  */
  1561.     FAST uint32_t curClust; /*  */
  1562.     FAST uint32_t firstContig; /* 1st clust. of contig area */
  1563.     FAST uint32_t contigCount; /* count of fit clusters */
  1564.     FAST uint32_t bestCount; /*  */
  1565.          uint32_t bestStart; /*  */
  1567.     if (number == (uint32_t)CONTIG_MAX)
  1568.         {
  1569.         semTake (pFatDesc->allocSem, WAIT_FOREVER);
  1571.         number = fat16MaxContigClustersGet (pFd, &bestStart);
  1572.         if (number == 0)
  1573.             {
  1574.             errnoSet (S_dosFsLib_DISK_FULL);
  1575.             goto contig_alloc_error;
  1576.             }
  1578.         goto contig_alloc;
  1579.         }
  1581.     /* Convert number of sectors needed to number of clusters */
  1583.     number = (number + pVolDesc->secPerClust - 1) / pVolDesc->secPerClust;
  1585.     firstContig = DOS_MIN_CLUST;
  1586.     contigCount = 0;
  1587.     bestStart   = 0;
  1588.     bestCount   = pFatDesc->nFatEnts;
  1590.     semTake (pFatDesc->allocSem, WAIT_FOREVER);
  1592.     for (curClust = DOS_MIN_CLUST; 
  1593.     /* firstContig <= (pFatDesc->nFatEnts - number); ??? for 1st fit ??? */
  1594.          curClust < (pFatDesc->nFatEnts - number);
  1595.          curClust++)
  1596.         {
  1597.         fatEntry = ENTRY_READ (pFd, pFatDesc->dosFatDesc.activeCopyNum,
  1598.                                curClust);
  1600.         if ((fatEntry == FAT_CBIO_ERR)&&(pFd->fatHdl.errCode == FAT_CBIO_ERR))
  1601.             goto contig_alloc_error;
  1603. #if FALSE /* best fit */
  1605.         if (fatEntry == pFatDesc->dos_fat_avail)
  1606.             { /* free space */
  1607.             contigCount++; /* one more found */
  1608.             }
  1609.         else
  1610.             {
  1611.             /* Check for best fit */
  1613.             if ((contigCount >= number) && (contigCount < bestCount))
  1614.                 { /* most close from above */
  1615.                 bestStart = firstContig;
  1616.                 bestCount = contigCount;
  1618.                 if (contigCount == number)
  1619.                     break; /* fit exactly */
  1620.                 }
  1622.             firstContig = curClust + 1; /* next one will be new start */
  1624.             contigCount = 0;
  1625.             }
  1627. #else /* 1st fit */
  1629.         if (fatEntry == pFatDesc->dos_fat_avail)
  1630.             { /* free space */
  1631.             if (++contigCount == number) /* one more found */
  1632.                 {
  1633.                 bestStart = firstContig; /* ??? temporary solution */
  1634.                 bestCount = contigCount; /* ??? temporary solution */
  1635.                 goto contig_alloc; /* quit if enough found */
  1636.                 }
  1637.             }
  1638.         else /* allocated space */
  1639.             {
  1640.             firstContig = curClust + 1; /* next one will be new start */
  1641.             contigCount = 0;
  1642.             }
  1643. #endif /* FALSE */
  1644.         } /* for */
  1646.     if (bestStart == 0)
  1647.         {
  1648.         if (contigCount < number)
  1649.             {
  1650.             errnoSet (S_dosFsLib_NO_CONTIG_SPACE);
  1651.             goto contig_alloc_error;
  1652.             }
  1654.         bestStart = firstContig;
  1655.         }
  1657. contig_alloc:
  1659.     if (fat16MarkAlloc (pFd, bestStart, number) != OK)
  1660.         goto contig_alloc_error;
  1662.     semGive (pFatDesc->allocSem);
  1664.     DBG_MSG (1, "Allocated %ld clusters starting from cluster %ldn", 
  1665.              number, bestStart,3,4,5,6);
  1667.     pFileHdl->startClust = bestStart;
  1668.     pFileHdl->contigEndPlus1 = bestStart + number;
  1670.     return OK;
  1672. contig_alloc_error:
  1673.     semGive (pFatDesc->allocSem);
  1674.     return ERROR;
  1675.     } /* fat16ContigAlloc */
  1677. /*******************************************************************************
  1678. *
  1679. * fat16MaxContigSectors - max free contiguous chain length in sectors
  1680. * 
  1681. * RETURNS: size of the max contiguous free space in sectors
  1682. */ 
  1683.  
  1684. static size_t fat16MaxContigSectors
  1685.     (
  1686.     FAST DOS_FILE_DESC_ID pFd /* pointer to file descriptor */
  1687.     )
  1688.     {
  1689.     uint32_t maxStart;
  1691.     return (fat16MaxContigClustersGet (pFd, &maxStart) * pFd->pVolDesc->secPerClust);
  1692.     } /* fat16MaxContigSectors */
  1694. /*******************************************************************************
  1695. *
  1696. * fat16Show - display handler specific data
  1697. *
  1698. * RETURNS: N/A.
  1699. */
  1701. LOCAL void fat16Show 
  1702.     (
  1703.     DOS_VOLUME_DESC_ID pVolDesc /* pointer to volume descriptor */
  1704.     )
  1705.     {
  1706.     MS_FAT_DESC_ID pFatDesc = (MS_FAT_DESC_ID) pVolDesc->pFatDesc;
  1707.     DOS_FILE_DESC fileDesc = { 0 }; /* pointer to file descriptor */
  1709.     fileDesc.pVolDesc = pVolDesc;
  1711.     printf ("FAT handler information:n");
  1712.     printf ("------------------------n");
  1714.     printf      (" - allocation group size: %ld clustersn", 
  1715. pFatDesc->fatGroupSize);
  1717.     print64Fine (" - free space on volume: ", fat16NFree (&fileDesc), 
  1718.                 " bytesn", 10);
  1719.     } /* fat16Show */
  1721. /*******************************************************************************
  1722. *
  1723. * fat16ClustValueSet - set value to a particular FAT entry
  1724. *
  1725. * RETURNS: OK or ERROR
  1726. */
  1728. STATUS fat16ClustValueSet
  1729.     (
  1730.     DOS_FILE_DESC_ID pFd, /* pointer to file descriptor */
  1731.     uint32_t copyNum, /* fat copy number */
  1732.     uint32_t clustNum, /* cluster number to check */
  1733.     uint32_t value,
  1734.     uint32_t nextClust
  1735.     )
  1736.     {
  1737.     DOS_VOLUME_DESC_ID pVolDesc = pFd->pVolDesc;
  1738.     MS_FAT_DESC_ID pFatDesc = (void *) pVolDesc->pFatDesc;
  1739.     
  1740.     switch (value)
  1741.         {
  1742.         case DOS_FAT_AVAIL:
  1743.             value = pFatDesc->dos_fat_avail;
  1744.             break;
  1746.         case DOS_FAT_EOF:
  1747.             value = pFatDesc->dos_fat_eof;
  1748.             break;
  1750.         case DOS_FAT_BAD:
  1751.             assert (FALSE);
  1752.             value = pFatDesc->dos_fat_bad;
  1753.             break;
  1755.         case DOS_FAT_RESERV:
  1756.             assert (FALSE);
  1757.             value = pFatDesc->dos_fat_reserv;
  1758.             break;
  1760.         case DOS_FAT_ALLOC:
  1761.             assert ((nextClust >= DOS_MIN_CLUST) &&
  1762.                     (nextClust < pFd->pVolDesc->nFatEnts));
  1763.             value = nextClust;
  1764.             break;
  1765.     
  1766.       case DOS_FAT_RAW:
  1767.          value = nextClust;
  1768.          break;
  1770.       case DOS_FAT_SET_ALL:
  1771.          {
  1772.          CBIO_DEV_ID pCbio = pVolDesc->pCbio;
  1773.          cookie_t cookie = (cookie_t) NULL;
  1774.          uint8_t wBuf [64];
  1776.          /* fill one sector (<value> = sector number) */
  1778.          value = pFatDesc->fatStartSec + (copyNum * pVolDesc->secPerFat);
  1780.          bfill ((char *)wBuf, sizeof (wBuf), nextClust );
  1782.          for ( clustNum = 0;
  1783.   clustNum < pFd->pVolDesc->bytesPerSec;
  1784.                   clustNum += sizeof (wBuf) )
  1785.           {
  1786.           if (cbioBytesRW (pCbio, value, clustNum, (addr_t)wBuf,
  1787.                                          sizeof (wBuf), CBIO_WRITE,
  1788.                                          &cookie) != OK)
  1789.               {
  1790.               return ERROR;
  1791.               }
  1792.           }
  1794.          /* copy first sector to other FAT sectors */
  1796.          for ( nextClust = value++;
  1797.                   value < nextClust + pVolDesc->secPerFat;
  1798.             value ++ )
  1799.           {
  1800.           if (cbioBlkCopy (pCbio, nextClust, value, 1) != OK)
  1801.               return ERROR;
  1802.           }
  1804.          return (OK);
  1805.          }
  1807.         case DOS_FAT_INVAL:
  1808.         default:
  1809.             assert (FALSE);
  1810.         }
  1812.     return ENTRY_WRITE (pFd, copyNum, clustNum, value);
  1813.     } /* fat16ClustValueSet */
  1815. /*******************************************************************************
  1816. *
  1817. * fat16ClustValueGet - get value corresponding to this cluster number in FAT
  1818. *
  1819. * Get the value of a particular FAT entry, resulting in the
  1820. * number of the next cluster in chain, or one of the following:
  1821. *
  1822. * DOS_FAT_AVAIL  - available cluster
  1823. * DOS_FAT_EOF    - end of file's cluster chain
  1824. * DOS_FAT_BAD    - bad cluster (damaged media)
  1825. * DOS_FAT_ALLOC  - allocated cluster
  1826. * DOS_FAT_INVAL  - invalid cluster (illegal value)
  1827. * DOS_FAT_RESERV - reserved cluster
  1828. *
  1829. * RETURNS: cluster number or special value above
  1830. */
  1832. uint32_t fat16ClustValueGet 
  1833.     (
  1834.     DOS_FILE_DESC_ID pFd, /* pointer to file descriptor */
  1835.     uint32_t copyNum, /* fat copy number */
  1836.     uint32_t clustNum, /* cluster number to check */
  1837.     uint32_t * pNextClust /*  */
  1838.     )
  1839.     {
  1840.     MS_FAT_DESC_ID pFatDesc = (void *) pFd->pVolDesc->pFatDesc;
  1842.     clustNum &= 0x0fffffff; /* high 4 bits in FAT32 are reserved */
  1844.     if (clustNum == 0)
  1845.         return DOS_FAT_AVAIL;
  1847.     if (clustNum > pFatDesc->dos_fat_bad)
  1848.         return DOS_FAT_EOF;
  1850.     if (clustNum == pFatDesc->dos_fat_bad)
  1851.         return DOS_FAT_BAD;
  1853.     if (clustNum >= pFatDesc->dos_fat_reserv)
  1854.         return DOS_FAT_RESERV;
  1856.     if ((clustNum < DOS_MIN_CLUST) || (clustNum >= pFd->pVolDesc->nFatEnts))
  1857.         return DOS_FAT_INVAL;
  1859.     *pNextClust = ENTRY_READ (pFd, copyNum, clustNum);
  1861.     if (pFd->fatHdl.errCode == FAT_CBIO_ERR)
  1862.         return DOS_FAT_ERROR;
  1864.     return DOS_FAT_ALLOC;
  1865.     } /* fat16ClustValueGet */
  1867. /*******************************************************************************
  1868. *
  1869. * fat16VolUnmount - unmount volume
  1870. *
  1871. * This routine frees all resources, that were allocated for the volume.
  1872. *
  1873. * RETURNS: N/A
  1874. */
  1876. LOCAL void fat16VolUnmount 
  1877.     (
  1878.     DOS_VOLUME_DESC_ID pVolDesc /*  */
  1879.     )
  1880.     {
  1881.     return;
  1882.     } /* fat16VolUnmount */
  1884. /*******************************************************************************
  1885. *
  1886. * fat16VolMount - mount volume
  1887. *
  1888. * Initialize a new volume
  1889. *
  1890. * RETURNS: ERROR if FAT is illegal
  1891. */
  1893. STATUS fat16VolMount 
  1894.     (
  1895.     DOS_VOLUME_DESC_ID pVolDesc, /*  */
  1896.     void * arg /* unused */
  1897.     )
  1898.     {
  1899.     FAST CBIO_DEV_ID pCbio = pVolDesc->pCbio;
  1900. /* pointer to CBIO device */
  1901.     MS_FAT_DESC_ID pFat16Desc;
  1902.     DOS_FILE_DESC fileDesc = { 0 }; /* file descriptor */
  1903.     uint8_t fsinfoBuf [8]; /* FSINFO sector data */
  1905.     /*
  1906.      * if previous volume had alternative FAT structure,
  1907.      * unmount previous FAT handler and
  1908.      * allocate FAT handler descriptor
  1909.      */
  1911.     if (pVolDesc->pFatDesc != NULL &&
  1912.         pVolDesc->pFatDesc->volUnmount != fat16VolUnmount &&
  1913.         pVolDesc->pFatDesc->volUnmount != NULL)
  1914.         {
  1915.         /* Unmount previous FAT handler */
  1917.         pVolDesc->pFatDesc->volUnmount( pVolDesc );
  1918.         }
  1920.     /* Allocate FAT handler descriptor */
  1922.     pVolDesc->pFatDesc = 
  1923. KHEAP_REALLOC((char *)pVolDesc->pFatDesc, sizeof( *pFat16Desc));
  1925.     if (pVolDesc->pFatDesc == NULL)
  1926.         return ERROR;
  1928.     pFat16Desc = (void *)pVolDesc->pFatDesc;
  1929.     bzero( (void *)pFat16Desc, sizeof( *pFat16Desc) ); 
  1931.     fileDesc.pVolDesc = pVolDesc; /* for fat16NFree() */
  1932.  
  1933.     /* Number of FAT entries = count of clusters available for files + 2 */
  1935.     pVolDesc->nFatEnts = pFat16Desc->nFatEnts = 
  1936. ( ((pVolDesc->totalSec - pVolDesc->dataStartSec) / 
  1937. pVolDesc->secPerClust) + DOS_MIN_CLUST );
  1939.     if (pVolDesc->fatType == FAT32)
  1940.         {
  1941.         /* activeFatStart ??? */
  1943.         if (cbioBytesRW (pCbio, FSINFO_SEC_NUM, FSINFO_FREE_CLUSTS, 
  1944. (addr_t)fsinfoBuf, sizeof (fsinfoBuf), CBIO_READ, NULL) != OK)
  1945.             goto mount_error;
  1947.         /* Fill free FAT entries count */
  1949.         pFat16Desc->fatEntFreeCnt   = DISK_TO_VX_32 (&fsinfoBuf[0]);
  1951.         /* Fill start cluster for cluster groups allocation */
  1953.         pFat16Desc->groupAllocStart = DISK_TO_VX_32 (&fsinfoBuf[4]);
  1955.         if ( (pFat16Desc->groupAllocStart < DOS_MIN_CLUST) ||
  1956.              (pFat16Desc->groupAllocStart >= pFat16Desc->nFatEnts) )
  1957.             pFat16Desc->groupAllocStart = DOS_MIN_CLUST;
  1959.         pFat16Desc->entryRead       = fat32EntRead;
  1960.         pFat16Desc->entryWrite      = fat32EntWrite;
  1961.         pFat16Desc->dos_fat_reserv  = 0x0ffffff0;
  1962.         pFat16Desc->dos_fat_bad     = 0x0ffffff7;
  1963.         pFat16Desc->dos_fat_eof     = 0x0fffffff;
  1964.         }
  1965.     else
  1966.         {
  1967.         /* activeFatStart ??? */
  1969.         /* -1 in fatEntFreeCnt cause fat16NFree() to fill this field */
  1971.         pFat16Desc->fatEntFreeCnt = -1;
  1973.         /* Fill cluster groups allocation start cluster */
  1975.         pFat16Desc->groupAllocStart = DOS_MIN_CLUST;
  1976.  
  1977.         if (pVolDesc->fatType == FAT16)
  1978.             {
  1979.             pFat16Desc->entryRead       = fat16EntRead;
  1980.             pFat16Desc->entryWrite      = fat16EntWrite;
  1981.             pFat16Desc->dos_fat_reserv  = 0xfff0;
  1982.             pFat16Desc->dos_fat_bad     = 0xfff7;
  1983.             pFat16Desc->dos_fat_eof     = 0xffff;
  1984.             }
  1985.         else if (pVolDesc->fatType == FAT12)
  1986.             {
  1987.             pFat16Desc->entryRead       = fat12EntRead;
  1988.             pFat16Desc->entryWrite      = fat12EntWrite;
  1989.             pFat16Desc->dos_fat_reserv  = 0xff0;
  1990.             pFat16Desc->dos_fat_bad     = 0xff7;
  1991.             pFat16Desc->dos_fat_eof     = 0xfff;
  1992.             }
  1993.         else
  1994.             goto mount_error;
  1995.         }
  1997.     pFat16Desc->dosFatDesc.volUnmount  = fat16VolUnmount;
  1998.     pFat16Desc->dosFatDesc.getNext     = fat16GetNext;
  1999.     pFat16Desc->dosFatDesc.contigChk   = fat16ContigChk;
  2000.     pFat16Desc->dosFatDesc.show        = fat16Show;
  2001.     pFat16Desc->dosFatDesc.truncate    = fat16Truncate;   /*FIOTRUNC*/
  2002.     pFat16Desc->dosFatDesc.seek        = fat16Seek;       /*FIOSEEK*/
  2003.     pFat16Desc->dosFatDesc.contigAlloc = fat16ContigAlloc;/*FIOCONTIG*/
  2004.     pFat16Desc->dosFatDesc.maxContig   
  2005.                                  = fat16MaxContigSectors; /*FIONCONTIG*/
  2006.     pFat16Desc->dosFatDesc.nFree       = fat16NFree;      /*FIONFREE*/
  2007.     pFat16Desc->dosFatDesc.flush       = fat16MirrorSect; /*FIOFLUSH*/
  2008.     pFat16Desc->dosFatDesc.syncToggle  = fat16SyncToggle;
  2009.     pFat16Desc->dosFatDesc.clustValueSet = fat16ClustValueSet;
  2010.     pFat16Desc->dosFatDesc.clustValueGet = fat16ClustValueGet;
  2012.     pFat16Desc->fatStartSec     = pVolDesc->nReservedSecs;
  2014.     /* current version uses only fat copy 0 as active */
  2015.     
  2016.     pFat16Desc->dosFatDesc.activeCopyNum = 0;
  2018.     /* Number of clusters in allocation group = ??? 
  2019.      * must be calculated in future
  2020.      */
  2022.     pFat16Desc->fatGroupSize    = pFat16Desc->nFatEnts / fatClugFac + 1;
  2024.     pFat16Desc->dos_fat_avail   = 0x00000000;
  2026.     pFat16Desc->syncEnabled = TRUE; /* enable FAT copies mirroring */
  2028.     pFat16Desc->allocSem = semMCreate (ALLOC_SEM_OPTIONS);
  2030.     if (NULL == pFat16Desc->allocSem)
  2031. {
  2032.         goto mount_error;
  2033. }
  2035.     pFat16Desc->clustAllocStart = DOS_MIN_CLUST;
  2036.     
  2037.     fat16NFree (&fileDesc); /* fill 'fatEntFreeCnt' if it equals -1 */
  2039.     return OK;
  2041. mount_error:
  2042.     fat16VolUnmount (pVolDesc);
  2043.     return ERROR;
  2044.     } /* fat16VolMount */
  2046. /*****************************************************************************
  2047. *
  2048. * dosFsFatInit - init handler and install it into dosFsLib
  2049. *
  2050. * This function must be called to install the FAT handler,
  2051. * which is mandatory, once during system initialization.
  2052. *
  2053. * RETURNS: OK or ERROR if failed to install
  2054. */
  2055. STATUS dosFsFatInit ( void )
  2056.     {
  2057.     DOS_HDLR_DESC hdlr;
  2059.     hdlr.id       = DOS_FATALL_HDLR_ID;
  2060.     hdlr.mountRtn = fat16VolMount;
  2061.     hdlr.arg      = NULL;
  2063.     return dosFsHdlrInstall (dosFatHdlrsList, &hdlr);
  2064.     } /* dosFsFatInit() */