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

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

VxWorks

开发平台：

C/C++

dosChkLib.c：源码内容
  1. /* dosChkLib.c - DOS file system sanity check utility */ 
  3. /* Copyright 1999-2002 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7. modification history
  8. --------------------
  9. 01o,10nov01,jkf  SPR#67890, chkdsk writes to RDONLY device
  10. 01n,18oct01,jkf   warning cleaning.
  11. 01n,18sep00,nrj   Fixed SPR#34108, check the write mode before synchronzing the
  12.                   FAT
  13. 01m,29feb00,jkf   T3 changes
  14. 01l,31aug99,jkf   changes for new CBIO API.  Changed date check logic.
  15.                   Added docs for date check.  Added global for date
  16.                   check.  Default debug global to zero.
  17. 01k,31jul99,jkf   T2 merge, tidiness & spelling.
  18. 01j,28sep98,vld   gnu extensions dropped from DBG_MSG/ERR_MSG macros
  19. 01i,13oct98,vld   fixed message positioning on  screen, - 'b' avoided.
  20. 01h,23sep98,vld   added usage of reserved FAT32 copy for data buffering
  21.   in reduced memory environments, bit map of FAT entries
  22.   is filled in parallel with 4-byte MAP array in this case
  23. 01g,23sep98,vld   fixed bug of backward time setting
  24. 01f,23sep98,vld   disable FAT mirroring while check disk in progress;
  25.   synchronize FAT copies after check disk.
  26. 01e,17sep98,vld   FAT copy number argument added to calls of
  27.   clustValueSet()/clustValueGet();
  28. 01d,08jul98,vld   print64Lib.h moved to h/private directory.
  29. 01c,08jul98,vld   fixed bug in dosFsChkTree() of deletion
  30.   invalid name entry through other file descriptor.
  31. 01b,02jul98,lrn   review doc and messages
  32. 01a,18jan98,vld   written, preliminary
  33. */
  35. /*
  36. DESCRIPTION
  37. This library is part of dosFsLib, it manages the Consistency Checking
  38. procedure, which may be invoked automatically during device mount
  39. procedure, or manual by means of the FIOCHKDSK ioctl.
  41. be checked which is managed by that particular handler.
  43. Check disk requires temporary buffer large enough to store information
  44. on every FAT entry. Memory requirements can be a problem for FAT32
  45. volumes. If no enough available, temporary data is buffered in
  46. second (reserved) FAT copy, that can take extremely long time on a 
  47. slow processors.
  49. The minimum acceptable system time & date is set by the global variable
  50. (time_t) dosChkMinDate.  If the system time is greater than that value, 
  51. it is assumed that a hardware clock mechanism is in place and the time 
  52. setting is honored.  If dosChkLib detects that the system is set to an 
  53. earlier date than dosChkMinDate, the system date will be adjusted to 
  54. either the most recent date found on the file system volume or the minimum 
  55. acceptable system time & date, whichever is later.  A warning indicicating 
  56. the new system time is displayed on the console when this occurs.
  57. Do not set dosChkMinDate prior to 1980!
  59. INTERNAL
  60. */
  62. /* includes */
  64. #include "vxWorks.h"
  65. #include "private/dosFsVerP.h"
  66. #include "stat.h"
  67. #include "time.h"
  68. #include "dirent.h"
  69. #include "stdio.h"
  70. #include "stdlib.h"
  71. #include "string.h"
  72. #include "errnoLib.h"
  73. #include "memLib.h"
  74. #include "taskLib.h"
  75. #include "time.h"
  76. #include "timers.h"
  77. #include "tickLib.h"
  79. #include "dosFsLib.h"
  80. #include "private/print64Lib.h"
  81. #include "private/dosFsLibP.h"
  83. /* defines */
  85. /* macros */
  87. #undef DBG_MSG
  88. #undef ERR_MSG
  89. #undef NDEBUG
  91. #ifdef DEBUG
  92. #   undef LOCAL
  93. #   define LOCAL
  94. #   undef ERR_SET_SELF
  95. #   define ERR_SET_SELF
  96. #   define DBG_MSG( lvl, fmt, arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8 )
  97. { if( (lvl) <= dosChkDebug )
  98.     printErr( "%s : %d : " fmt,
  99.                __FILE__, __LINE__, arg1,arg2,
  100.        arg3,arg4,arg5,arg6,arg7,arg8 ); }
  102. #   define ERR_MSG( lvl, fmt, a1,a2,a3,a4,a5,a6 )
  103.         { logMsg( __FILE__ " : " fmt, (int)(a1), (int)(a2),
  104.   (int)(a3), (int)(a4), (int)(a5), (int)(a6) ); }
  105. #else /* NO DEBUG */
  107. #   define NDEBUG
  108. #   define DBG_MSG(lvl,fmt,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8)  {}
  110. #   define ERR_MSG( lvl, fmt, a1,a2,a3,a4,a5,a6 )
  111. { if( (lvl) <= dosChkDebug ) 
  112.             logMsg( __FILE__ " : " fmt, (int)(a1), (int)(a2),
  113.   (int)(a3), (int)(a4), (int)(a5), (int)(a6) ); }
  115. #endif /* DEBUG */
  117. #include "assert.h"
  119. #define DOSCHKLIB_YEAR_VALUE (((60*60)*24)*365*21)
  121. int dosChkDebug = 0;
  123. time_t dosChkMinDate = (time_t) DOSCHKLIB_YEAR_VALUE;
  126. /* error messages */
  128. #define CHK_CROSS_L_START_MSG ""%s" is cross-linked on first cluster. "
  129. #define CHK_START_MSG "%s  - disk check in progress ..."
  130. #define CHK_NOT_ROOM_MSG "%s - Not enough room to run check disk.n"
  131. #define CHK_LOST_CHAINS_MSG " - lost chains "
  132. #define CHK_DEL_MSG " Entry will be deleted. "
  133. #define CHK_REMAIN_MSG "Entry remains intact. "
  134. #define CHK_CLUST_VAL "(cluster %lu, value %lu)."
  135. #define CHK_SHORT_CHAIN_MSG ""%s" file larger then its chain of clusters"
  136. #define CHK_BAD_DIR_MSG ""%s" directory has invalid structure."
  137. #define CHK_DIR_LVL_OVERFL "directory nesting limit reached, "%s" skipped"
  138. #define CHK_ROOT_CHAIN  "%s - Root directory cluster chain is corrupted.n"
  139. #define CHK_ROOT_TRUNC_MSG "      Root directory truncated. n"
  140. #define CHK_BAD_NAME ""%s" is an illegal name. "
  141. #define CHK_FAIL_MSG "     Check disk failed. n"
  142.                                 "     Disk should be formatted.n"
  143. #define CHK_NOT_REPAIRED "%s  - Errors detected. "
  144. "To correct disk structure, please start "
  145. "check disk with a permission to repair."
  146. #define CHK_RESTORE_FREE "Errors detected. "
  147. "All corrections stored to disk "
  148. "and lost chains recovered."
  149. #define CHK_BAD_START_MSG ""%s" has illegal start cluster"
  150. #define CHK_CROSS_START_MSG ""%s" cross-linked at start"
  151. #define CHK_BAD_CHAIN_MSG ""%s" has illegal cluster in chain"
  152. #define CHK_CROSS_LINK_MSG ""%s" cross-linked with another chain"
  153. #define CHK_LONG_CHAIN_MSG ""%s" too many clusters in file, adjusted."
  154. #define CHK_BAD_CLUST_MSG "illegal cluster"
  155. #define CHK_NO_ERRORS "%s  - Volume is OK "
  157. #define START_CLUST_MASK 0x80000000
  158. #define LOST_CHAIN_MARK 0xc0000000
  160. #define MARK_SET 1
  161. #define MARK_GET 2
  162. #define IS_BUSY 3
  163. #define MARK_BUF_INIT 255
  165. /* typedefs */
  167. /* check disk status */
  168.  
  169. typedef enum {
  170.              CHK_OK=OK, CHK_SIZE_ERROR,
  171.              CHK_RESTART, CHK_BAD_DIR, CHK_BAD_FILE,
  172.              CHK_CROSS_LINK, CHK_BAD_CHAIN, CHK_BAD_START,
  173.              CHK_ERROR=ERROR
  174.              }  CHK_STATUS;
  175.         
  177. /* dosChkMsg() argument */
  179. typedef enum { CURRENT_PATH, GET_PATH } MSG_PATH;
  181. /* dosChkEntryFind() argument */
  183. typedef enum { FIND_BY_CLUST, FIND_BY_NAME } CHK_SEARCH_KEY_TYPE;
  186. /* globals */
  188. /* locals */
  190. /* forward declarations */
  192. LOCAL void dosChkChainUnmark
  193.     (
  194.     DOS_FILE_DESC_ID    pFd             /* pointer to file descriptor */
  195.     );
  197. LOCAL STATUS dosChkChainStartGet
  198.     (
  199.     DOS_FILE_DESC_ID    pFd,            /* pointer to file descriptor */
  200.     uint32_t            entNum,
  201.     uint32_t *          pParDirStartClust,
  202.     uint32_t *          pStartClust
  203.     );
  205. LOCAL CHK_STATUS dosChkChainVerify
  206.     (
  207.     DOS_FILE_DESC_ID    pFd            /* pointer to file descriptor */
  208.     );
  210. LOCAL STATUS dosChkLostFind
  211.     (
  212.     DOS_FILE_DESC_ID    pFd             /* pointer to file descriptor */
  213.     );
  215. LOCAL STATUS dosChkLostFree
  216.     (
  217.     DOS_FILE_DESC_ID    pFd             /* pointer to file descriptor */
  218.     );
  221. /*******************************************************************************
  222. *
  223. * dosChkStatPrint - print statistics.
  224. *
  225. * RETURNS: N/A.
  226. */
  227. LOCAL void dosChkStatPrint
  228.     (
  229.     DOS_FILE_DESC_ID pFd
  230.     )
  231.     {
  232.     DOS_VOLUME_DESC_ID pVolDesc = pFd->pVolDesc;
  233.     CHK_DSK_DESC_ID pChkDesc = pFd->pVolDesc->pChkDesc;
  234.     fsize_t valBuf;
  235.     
  236.     if( pVolDesc->chkVerbLevel < (DOS_CHK_VERB_1 >> 8) )
  237.      return;
  238.     
  239.     /* print statistics */
  240.     
  241.     print64Fine(  "n" "   total # of clusters: ", 
  242. pVolDesc->nFatEnts, "n", 10 );
  244.     print64Fine( "    # of free clusters: ", 
  245. pChkDesc->chkNFreeClusts, "n", 10 );
  247.     print64Fine( "     # of bad clusters: ", 
  248. pChkDesc->chkNBadClusts, "n", 10 );
  249.     
  250.     valBuf = pChkDesc->chkNFreeClusts;
  251.     valBuf = ( valBuf * pVolDesc->secPerClust ) <<
  252.           pVolDesc->secSizeShift;
  253.     print64Mult( "      total free space: ",
  254. valBuf, "n", 10 );
  255.     
  256.     valBuf = (fsize_t)pVolDesc->pFatDesc->maxContig( pFd ) << 
  257.           pVolDesc->secSizeShift;
  258.     print64Fine( "     max contiguous free space:  ",
  259. valBuf, " bytesn", 10 );
  261.     print64Fine( "    # of files: ",
  262. pChkDesc->chkNFiles, "n", 10 );
  264.     print64Fine( "  # of folders: ",
  265. pChkDesc->chkNDirs, "n", 10 );
  267.     print64Mult( "  total bytes in files: ",
  268. pChkDesc->chkTotalFSize, "n", 10 );
  270.     print64Fine( "      # of lost chains: ",
  271. pChkDesc->chkNLostChains, "n", 10 );
  273.     print64Mult( "   total bytes in lost chains:  ",
  274.       pChkDesc->chkTotalBytesInLostChains, "n", 10 );
  275.     }
  276.     
  277. /*******************************************************************************
  278. *
  279. * dosChkFinish - print statistics and deallocate resources.
  280. *
  281. * RETURNS: N/A.
  282. */
  283. LOCAL void dosChkFinish
  284.     (
  285.     DOS_FILE_DESC_ID pFd
  286.     )
  287.     {
  288.     if( pFd->pVolDesc->pChkDesc->chkFatMap != NULL )
  289.      KHEAP_FREE(((char *)pFd->pVolDesc->pChkDesc->chkFatMap));
  291.     KHEAP_FREE(((char *)pFd->pVolDesc->pChkDesc));
  292.     pFd->pVolDesc->pChkDesc = NULL;
  293.     
  294.     return;
  295.     } /* dosChkFinish() */
  296.     
  297. /*******************************************************************************
  298. *
  299. * dosChkEntryMark - set/get FAT entry marker.
  300. *
  301. * RETURNS: marker value on MARK_GET operation, STATUS on MARK_SET
  302. *  and MARK_BUF_INIT operation.
  303. */
  304. uint32_t dosChkEntryMark
  305.     (
  306.     DOS_FILE_DESC_ID pFd,
  307.     u_int operation,         /* MARK_SET/MARK_GET/MARK_BUF_INIT */
  308.     uint32_t entryNum,
  309.     uint32_t mark
  310.     )
  311.     {
  312.     DOS_VOLUME_DESC_ID pVolDesc = pFd->pVolDesc;
  313.     CHK_DSK_DESC_ID pChkDesc = pVolDesc->pChkDesc;
  314.     uint8_t fatCopyNum = 0;
  316.     if (! pChkDesc->bufToDisk)
  317.      {
  318.      switch (operation)
  319.          {
  320.          case MARK_GET :
  321.          case IS_BUSY :
  322.           return pChkDesc->chkFatMap [entryNum];
  323.          case MARK_SET :
  324.           pChkDesc->chkFatMap [entryNum] = mark;
  325.           break;
  326.          case MARK_BUF_INIT :
  327.           bzero ((char *)pChkDesc->chkFatMap,
  328.                pVolDesc->nFatEnts *
  329.                        sizeof( *pVolDesc->pChkDesc->chkFatMap ));
  330.           break;
  331.          default:
  332.           assert (FALSE);
  333.          }
  334.        return OK;
  335.      }
  336.     else /* use reserved FAT copy as buffer */
  337.      {
  338.      fatCopyNum = pVolDesc->pFatDesc->activeCopyNum + 1;
  339.      switch (operation)
  340.          {
  341.          case MARK_GET :
  342.              pVolDesc->pFatDesc->clustValueGet (pFd, fatCopyNum,
  343.    entryNum, &mark );
  344.           return mark;
  346.          case IS_BUSY :
  347.           return pChkDesc->chkFatMap [
  348.                        entryNum / 8 / sizeof(*pChkDesc->chkFatMap)] &
  349.                        (1 <<
  350.                         (entryNum & (sizeof(*pChkDesc->chkFatMap) * 8 - 1)));
  352.          case MARK_SET :
  353.           pChkDesc->chkFatMap [
  354. entryNum / 8 / sizeof(*pChkDesc->chkFatMap)] |=
  355.         1 << (entryNum & (sizeof(*pChkDesc->chkFatMap) * 8 - 1));
  357.              return pVolDesc->pFatDesc->clustValueSet (
  358.     pFd, fatCopyNum, entryNum, DOS_FAT_RAW, mark );
  360.          case MARK_BUF_INIT :
  361.           bzero ((char *)pChkDesc->chkFatMap,
  362.                        pVolDesc->nFatEnts / 8  + 4);
  363.           return pVolDesc->pFatDesc->clustValueSet(
  364.                             pFd, fatCopyNum, 0, DOS_FAT_SET_ALL,  0 );
  366.          default:
  367.           assert (FALSE);
  368.          }
  369.      }
  371.     return ERROR;
  372.     } /* dosChkEntryMark() */
  374. /*******************************************************************************
  375. *
  376. * dosChkEntryFind - find entry in directory.
  377. *
  378. * This routine searches directory, that starts from <dirStartClust>,
  379. * for entry, by entry name or start cluster. File descriptor
  380. * <pFd> is filled for entry found and entry name is placed into
  381. * <pChkDesc->chkDir>.
  382. *
  383. * RETURNS: OK or ERROR if disk access error.
  384. */
  385. LOCAL STATUS dosChkEntryFind
  386.     (
  387.     DOS_FILE_DESC_ID pFd,
  388.     UINT32 dirStartClust,
  389.     void * key, /* start clust value or name buffer */
  390.     CHK_SEARCH_KEY_TYPE keyType
  391.     )
  392.     {
  393.     UINT32 startClust = (UINT32)key;
  394.     DIR * pDir = &pFd->pVolDesc->pChkDesc->chkDir;
  395.     DOS_FILE_DESC fd;
  396.     DOS_FILE_HDL flHdl;
  397.     
  398.     fd = *pFd;
  399.     flHdl = *pFd->pFileHdl;
  400.     fd.pFileHdl = &flHdl;
  401.     
  402.     if( dirStartClust == 0 ) /* parent is root */
  403.      {
  404.      if( pFd->pVolDesc->pDirDesc->pathLkup( &fd, "", 0 ) == ERROR )
  405.          return ERROR;
  406.      }
  407.     else if( dirStartClust == (UINT32)NONE ) /* search for root */
  408.      {
  409.      if( pFd->pVolDesc->pDirDesc->pathLkup( &fd, "", 0 ) == ERROR )
  410.          return ERROR;
  411.      strcpy( pDir->dd_dirent.d_name, pFd->pVolDesc->devHdr.name );
  412.      return OK;
  413.      }
  414.     else
  415.      {
  416.      fd.pFileHdl->startClust = dirStartClust;
  417.      fd.pFileHdl->attrib = DOS_ATTR_DIRECTORY;
  418.      }
  419.     
  420.     /* rewind directory */
  421.     
  422.     pDir->dd_cookie = 0;
  423.     
  424.     while( pFd->pVolDesc->pDirDesc->readDir( &fd, pDir, pFd ) == OK )
  425.      {
  426.      switch( keyType )
  427.          {
  428.          case FIND_BY_CLUST:
  429.           if( pFd->pFileHdl->startClust == startClust )
  430.              return OK;
  431.           break;
  432.          case FIND_BY_NAME:
  433.           if( strcmp( (char *)key, pDir->dd_dirent.d_name ) == 0 )
  434.              return OK;
  435.           break;
  436.          default:
  437.           assert( FALSE );
  438.          }
  439.      }
  440.     assert( FALSE );
  441.     return ERROR;
  442.     } /* dosChkEntryFind() */
  443.     
  444. /*******************************************************************************
  445. *
  446. * dosChkBuildPath - reconstruct file path.
  447. *
  448. * This routine reconstructs full path of the file is described
  449. * by <pFd> and puts it to <pChkDesc->chkPath> buffer.
  450. *
  451. * RETURNS: OK or ERROR if disk access error.
  452. */
  453. LOCAL STATUS dosChkBuildPath
  454.     (
  455.     DOS_FILE_DESC_ID pSrcFd
  456.     )
  457.     {
  458.     DIR * pDir = &pSrcFd->pVolDesc->pChkDesc->chkDir;
  459.     DOS_FILE_DESC fd;
  460.     DOS_FILE_HDL flHdl;
  461.     u_char * pPath;
  462.     u_char * chkPath = pSrcFd->pVolDesc->pChkDesc->chkPath;
  463.     u_short nameLen;
  464.     
  465.     pPath = chkPath + 
  466.             sizeof( pSrcFd->pVolDesc->pChkDesc->chkPath ) - 1;
  468.     bzero( (char *)chkPath,
  469.         sizeof( pSrcFd->pVolDesc->pChkDesc->chkPath ) );
  470.     if( (pSrcFd->pFileHdl->attrib & DOS_ATTR_DIRECTORY) != 0 )
  471.      {
  472.      pPath --;
  473.      *pPath = SLASH;
  474.      }
  475.     
  476.     fd = *pSrcFd;
  477.     flHdl = *pSrcFd->pFileHdl;
  478.     fd.pFileHdl = &flHdl;
  479.     
  480.     FOREVER
  481.      {
  482.      if( dosChkEntryFind( &fd, flHdl.dirHdl.parDirStartCluster,
  483.           (void *)flHdl.startClust,
  484.           FIND_BY_CLUST ) == ERROR )
  485.          {
  486.          return ERROR;
  487.          }
  488.     
  489.      /* insert name to path */
  490.     
  491.      nameLen = strlen( pDir->dd_dirent.d_name );
  492.      if( nameLen > pPath - chkPath )
  493.          {
  494.          do  {
  495.           pPath = memchr( pPath + 1, SLASH, strlen( (char *)pPath ) );
  496.           }
  497.          while( pPath - chkPath < 4 );
  498.          
  499.          pPath -= 4;
  500.          *pPath = DOT, *(pPath + 1) = DOT, *(pPath + 2) = DOT;
  501.          *(pPath + 3) = SLASH;
  502.          break;
  503.          }
  504.     
  505.      pPath -= strlen( pDir->dd_dirent.d_name );
  506.      bcopy( pDir->dd_dirent.d_name, (char *)pPath,
  507.             strlen( pDir->dd_dirent.d_name ) );
  508.     
  509.      if( IS_ROOT( &fd ) )
  510.          break;
  511.     
  512.      pPath --;
  513.      *pPath = SLASH;
  514.     
  515.      /* find cluster containing parent directory */
  516.     
  517.      if( flHdl.dirHdl.parDirStartCluster == 0 )
  518.          { /* current parent directory is root */
  519.          flHdl.dirHdl.parDirStartCluster = (UINT32)NONE;
  520.          }
  521.      else if( dosChkChainStartGet(
  522.      &fd, flHdl.dirHdl.parDirStartCluster, 
  523.      (uint32_t *)&flHdl.dirHdl.parDirStartCluster,
  524.                  (uint32_t *)&flHdl.startClust ) == ERROR )
  525.             {
  526.             assert( FALSE );
  527.             }
  528.      }
  529.     
  530.     memmove( chkPath, pPath, strlen( (char *)pPath ) + 1 );
  531.     return OK;
  532.     } /* dosChkBuildPath() */
  533.     
  534. /*******************************************************************************
  535. *
  536. * dosChkMsg - print message.
  537. *
  538. */
  539. LOCAL void dosChkMsg
  540.     (
  541.     DOS_FILE_DESC_ID pFd,
  542.     char * msgFormat,
  543.     MSG_PATH msgPath, /* whether to build file path or use current path */
  544.     int arg1,
  545.     int arg2,
  546.     int arg3,
  547.     int arg4,
  548.     char * extraMsg
  549.     )
  550.     {
  551.     char * path = NULL;
  552.     
  553.     if( msgPath == CURRENT_PATH )
  554.      path = pFd->pVolDesc->pChkDesc->chkCurPath;
  555.     else if( dosChkBuildPath( pFd ) == OK )
  556.      path = (char *)pFd->pVolDesc->pChkDesc->chkPath;
  557.     else
  558.      return;
  559.     
  560.     printf( "r" );
  562.     printf( msgFormat, path, arg1, arg2, arg3, arg4 );
  564.     if( extraMsg != NULL && *extraMsg != EOS )
  565.      printf("%s", extraMsg );
  567.     printf( "n" );
  569.     return;
  570.     } /* dosChkMsg() */
  571.     
  572. /*******************************************************************************
  573. *
  574. * dosChkEntryDel - delete entry and unmark chain , if required.
  575. *
  576. * This routine deletes entry is described by pFd, unmarks
  577. * associated FAT chain, if <unmark> is TRUE and outputs
  578. * message in accordance with <mess> format string.
  579. *
  580. * RETURNS: CHK_OK, or CHK_ERROR if disk I/O error.
  581. */
  582. LOCAL CHK_STATUS dosChkEntryDel
  583.     (
  584.     DOS_FILE_DESC_ID pFd,
  585.     BOOL unmark,
  586.     u_char * mess,
  587.     MSG_PATH msgPath,
  588.     int msgArg1,
  589.     int msgArg2,
  590.     int msgArg3,
  591.     int msgArg4
  592.     )
  593.     {
  594.     /* put message */
  595.     
  596.     dosChkMsg( pFd, (char *)mess, msgPath, msgArg1, msgArg2, msgArg3, msgArg4,
  597.                CHK_DEL_MSG );
  598.     
  599.     pFd->pVolDesc->pChkDesc->nErrors ++;
  600.     
  601.     if( pFd->pVolDesc->chkLevel > CHK_ONLY )
  602.      {
  603.      if( pFd->pVolDesc->pDirDesc->updateEntry(
  604.      pFd, DH_DELETE, 0 ) == ERROR )
  605.          {
  606.          return CHK_ERROR;
  607.          }
  608.      }
  609.     
  610.     /* unmark chain */
  611.     
  612.     if( unmark )
  613.      dosChkChainUnmark( pFd );
  614.     
  615.     /* mark file descriptor as deleted */
  616.     
  617.     pFd->pFileHdl->deleted = 1;
  618.     
  619.     return CHK_OK;
  620.     } /* dosChkEntryDel() */
  621.     
  622. /*******************************************************************************
  623. *
  624. * dosChkStartCrossProc - process entries are cross linked on start cluster.
  625. *
  626. * This routine deletes entry, that was created earlier.
  627. *
  628. * RETURNS: CHK_OK or CHK_RESTART, if directory has been deleted.
  629. */
  630. LOCAL CHK_STATUS dosChkStartCrossProc
  631.     (
  632.     DOS_FILE_DESC_ID pFd
  633.     )
  634.     {
  635.     DOS_FILE_DESC localFd;
  636.     DOS_FILE_HDL localFlHdl;
  637.     UINT32 entryClust; /* entry location cluster */
  638.     UINT32 startClust; /* file/dir start cluster */
  639.     struct stat fStat; /* used to get creation time */
  640.     time_t creatTime; /* creation time of one of the files */
  641.     BOOL unmark = TRUE; /* whether to unmark chain */
  642.     MSG_PATH msgPath = GET_PATH; /* whether to build file path */
  643.      /* or to use current path */
  644.     
  645.     assert( pFd != NULL && pFd->pVolDesc->magic == DOS_FS_MAGIC );
  646.     
  647.     bzero( (char *)&localFd, sizeof( localFd ) );
  648.     bzero( (char *)&localFlHdl, sizeof( localFlHdl ) );
  649.     
  650.     localFd.busy = 1;
  651.     localFd.pFileHdl = &localFlHdl;
  652.     localFd.pVolDesc = pFd->pVolDesc;
  653.     
  654.     /* find peer entry */
  655.     
  656.     dosChkChainStartGet( pFd, pFd->pFileHdl->startClust,
  657.      (uint32_t *)&entryClust, 
  658.                         (uint32_t *)&startClust );
  659.     
  660.     if( dosChkEntryFind( &localFd, entryClust,
  661.      (void *)startClust, FIND_BY_CLUST ) == ERROR )
  662.      {
  663.      return CHK_ERROR;
  664.      }
  665.     
  666.     assert( pFd->pFileHdl->startClust == localFlHdl.startClust );
  667.     
  668.     /* delete older entry, but never delete ROOT */
  669.     
  670.     pFd->pVolDesc->pDirDesc->dateGet( pFd, &fStat );
  671.     creatTime = fStat.st_ctime;
  672.     pFd->pVolDesc->pDirDesc->dateGet( &localFd, &fStat );
  673.     
  674.     /* let <localFd> describes file to be deleted */
  675.     
  676.     if( IS_ROOT( &localFd ) || creatTime >= fStat.st_ctime )
  677.      {
  678.      dosChkMsg( &localFd, CHK_CROSS_L_START_MSG, GET_PATH,
  679.         0,0,0,0, CHK_REMAIN_MSG );
  680.     
  681.      localFd = *pFd;
  682.      localFlHdl =  *pFd->pFileHdl;
  683.      localFd.pFileHdl = &localFlHdl;
  684.     
  685.      /* the chain already checked. Do not unmark and recheck */
  686.     
  687.      unmark = FALSE;
  688.      msgPath = CURRENT_PATH;
  689.      pFd->pFileHdl->deleted = 1; 
  690.      }
  691.     else
  692.      {
  693.      dosChkMsg( pFd, CHK_CROSS_L_START_MSG, CURRENT_PATH,
  694.         0,0,0,0, CHK_REMAIN_MSG );
  695.      }
  696.     
  697.     /* delete the file */
  698.     
  699.     return dosChkEntryDel( &localFd, unmark, 
  700.         (u_char *)CHK_CROSS_L_START_MSG, msgPath, 0,0,0,0 );
  701.     } /* dosChkStartCrossProc() */
  702.     
  703. /*******************************************************************************
  704. *
  705. * dosChkDirStruct - check internal directory structure.
  706. *
  707. * This routine checks, that directory has valid . and ..
  708. * entries at top of it.
  709. *
  710. * RETURNS: CHK_OK, CHK_RESTART, if the directory has been deleted or
  711. * CHK_ERROR if another error occurred.
  712. */
  713. LOCAL CHK_STATUS dosChkDirStruct
  714.     (
  715.     DOS_FILE_DESC_ID pDirFd,
  716.     DOS_FILE_DESC_ID pLocalFd
  717.     )
  718.     {
  719.     u_char dots;
  720.     DIR * pDir = &pDirFd->pVolDesc->pChkDesc->chkDir;
  721.     
  722.     /* root directory does not contain . and .. entries */
  723.     
  724.     if( IS_ROOT( pDirFd ) )
  725.      return CHK_OK;
  726.     
  727.     for( dots = 1; dots <= 2; dots ++ )
  728.      {
  729.      if( pDirFd->pVolDesc->pDirDesc->readDir(
  730.      pDirFd, pDir, pLocalFd ) != OK )
  731.          {
  732.          break;
  733.          }
  734.      if( *(pDir->dd_dirent.d_name) != '.' ||
  735.          *(pDir->dd_dirent.d_name + dots - 1) != '.' ||
  736.          *(pDir->dd_dirent.d_name + dots) != EOS )
  737.          {
  738.          break;
  739.          }
  740.      if( dots == 1 && /* . */
  741.          pDirFd->pFileHdl->startClust !=
  742.          pLocalFd->pFileHdl->startClust )
  743.          {
  744.          break;
  745.          }
  746.      else if( dots == 2 && /* .. */
  747.              pDirFd->pFileHdl->startClust !=
  748.              pLocalFd->pFileHdl->dirHdl.parDirStartCluster )
  749.          {
  750.          break;
  751.          }
  752.      }
  753.     
  754.     if( dots <= 2 )
  755.      {
  756.      return dosChkEntryDel( pDirFd, TRUE, (u_char *)CHK_BAD_DIR_MSG,
  757.             CURRENT_PATH, 0,0,0,0 );
  758.      }
  759.     
  760.     return CHK_OK;  
  761.     } /* dosChkDirStruct() */
  762.     
  763. /*******************************************************************************
  764. *
  765. * dosFsChkTree - DOS FS sanity check utility.
  766. *
  767. * RETURNS: OK or ERROR if device is not a valid DOS device,
  768. *  corrections can not be written to disk
  769. *  or disk read error.
  770. *
  771. * ERRNO:
  772. * S_dosFsLib_INVALID_PARAMETER
  773. */
  774. CHK_STATUS dosFsChkTree
  775.     (
  776.     DOS_FILE_DESC_ID pFd
  777.     )
  778.     {
  779.     CHK_DSK_DESC_ID pChkDesc = pFd->pVolDesc->pChkDesc;
  780.     DOS_FILE_DESC localFd;
  781.     DOS_FILE_HDL localFlHdl;
  782.     UINT32 work1;
  783.     u_long ddCookie;
  784.     char * pCurPathPos = NULL;
  785.     
  786.     assert( pFd != NULL && pFd->pVolDesc->magic == DOS_FS_MAGIC );
  787.         
  788.     bzero( (char *)&localFd, sizeof( localFd ) );
  789.     bzero( (char *)&localFlHdl, sizeof( localFlHdl ) );
  790.     
  791.     localFd.busy = 1;
  792.     localFd.pFileHdl = &localFlHdl;
  793.     localFd.pVolDesc = pFd->pVolDesc;
  794.     
  795.     /* separately check ROOT directory chain */
  796.     
  797.     if( IS_ROOT( pFd ) )
  798.      {
  799. if( pFd->pFileHdl->startClust != 0 &&
  800.             dosChkChainVerify( pFd ) != CHK_OK )
  801.          {
  802.          return CHK_ERROR;
  803.          }
  804.      }
  805.     
  806.     pCurPathPos = pChkDesc->chkCurPath + 
  807.        strlen( pChkDesc->chkCurPath );
  808.     *pCurPathPos = SLASH;
  809.     pCurPathPos ++;
  810.     
  811.     /* rewind directory */
  812.     
  813.     pChkDesc->chkDir.dd_cookie = 0;
  814.     
  815.     /* check . and .. */
  816.     
  817.     work1 = dosChkDirStruct( pFd, &localFd );
  818.     if( work1 != CHK_OK )
  819.      {
  820.      pChkDesc->nErrors ++;
  821.      return work1;
  822.      }
  823.     
  824.     /* pass directory */
  825.     
  826.     for(  ;
  827.          pFd->pVolDesc->pDirDesc->readDir(
  828.      pFd, &pChkDesc->chkDir, &localFd ) == OK;
  829.       pChkDesc->chkDir.dd_cookie = ddCookie )
  830.      {
  831.      /*
  832.       * backup current position in directory, because
  833.       * other routines use the same DIR structure
  834.       */
  835.      ddCookie = pChkDesc->chkDir.dd_cookie;
  836.     
  837.      work1 = strlen( pCurPathPos );
  838.      strcpy( pCurPathPos, pChkDesc->chkDir.dd_dirent.d_name );
  839.     
  840.      if( pFd->pVolDesc->chkVerbLevel >= (DOS_CHK_VERB_2 >> 8) )
  841.          {
  842.          printf( "r%s", pChkDesc->chkCurPath );
  843.          for(  ; work1 >= strlen( pCurPathPos ); work1 -- )
  844.           printf( " " ); /* clear extra characters */
  845.     
  846.          }
  847.     
  848.      DBG_MSG( 100, "%s : stCl %u, size %u attrib %pn",
  849.      pChkDesc->chkDir.dd_dirent.d_name,
  850.      localFlHdl.startClust, localFlHdl.size,
  851.      (u_int)localFlHdl.attrib,0,0,0,0 );
  852.     
  853.      /* some statistics */
  854.     
  855.      if( (localFlHdl.attrib & DOS_ATTR_DIRECTORY) == 0 )
  856.          pChkDesc->chkNFiles ++;
  857.      else
  858.          pChkDesc->chkNDirs ++;
  859.     
  860.      /* check name */
  861.     
  862.      if( pFd->pVolDesc->pDirDesc->nameChk != NULL &&
  863.          pFd->pVolDesc->pDirDesc->nameChk( pFd->pVolDesc, 
  864.           (u_char *)pChkDesc->chkDir.dd_dirent.d_name) == ERROR)
  865.          {
  866.          if( dosChkEntryDel( &localFd, FALSE, (u_char *)CHK_BAD_NAME, 
  867. CURRENT_PATH, 0,0,0,0 ) == CHK_ERROR )
  868.           {
  869.           return CHK_ERROR;
  870.           }
  871.          
  872.          continue;
  873.          }
  874.     
  875.      /* check chain */
  876.     
  877.      if( dosChkChainVerify( &localFd ) == CHK_ERROR )
  878.          return CHK_ERROR;
  879.     
  880.      if( localFlHdl.deleted )
  881.          {
  882.          if( (localFlHdl.attrib & DOS_ATTR_DIRECTORY) == 0 )
  883.           pChkDesc->chkNFiles --;
  884.          else
  885.           pChkDesc->chkNDirs --;
  887.          continue;
  888.          }
  889.          
  890.     
  891.      /* chain is OK. */
  892.       
  893.      /* total files size */
  894.     
  895.      pChkDesc->chkTotalFSize += localFlHdl.size;
  896.     
  897.      /* absolute max time */
  898.     
  899.      if( pFd->pVolDesc->pDirDesc->dateGet(
  900.      &localFd, &pChkDesc->stat ) == ERROR )
  901.          {
  902.          return CHK_ERROR;
  903.          }
  904.     
  905.      if( pChkDesc->chkMaxCreatTime < pChkDesc->stat.st_ctime )
  906.          pChkDesc->chkMaxCreatTime = pChkDesc->stat.st_ctime;
  907.     
  908.      if( pChkDesc->chkMaxModifTime < pChkDesc->stat.st_mtime )
  909.          pChkDesc->chkMaxModifTime = pChkDesc->stat.st_mtime;
  910.     
  911.      if( pChkDesc->chkMaxAccTime < pChkDesc->stat.st_atime )
  912.          pChkDesc->chkMaxAccTime = pChkDesc->stat.st_atime;
  913.     
  914.      /* recursively check directory */
  915.     
  916.      if( (localFlHdl.attrib & DOS_ATTR_DIRECTORY) != 0 )
  917.          {
  918.          if( pChkDesc->curPathLev ==  DOS_MAX_DIR_LEVELS )
  919.           {
  920.           pChkDesc->nErrors ++;
  921.           dosChkEntryDel( &localFd, TRUE, (u_char *)CHK_DIR_LVL_OVERFL,
  922.           CURRENT_PATH, 0,0,0,0 );
  923.           continue;
  924.           }
  925.          
  926.          pChkDesc->curPathLev ++;
  927.          work1 = dosFsChkTree( &localFd );
  928.          pChkDesc->curPathLev --;
  929.          
  930.          if( work1 != CHK_OK )
  931.           {
  932.           return work1;
  933.           }
  934.          }
  935.      } /* for ... */
  936.     
  937.     
  938.     /* check, that device is OK yet */
  939.     
  940.     if( TRUE == cbioRdyChgdGet (pFd->pVolDesc->pCbio) )
  941.      return CHK_ERROR;
  942.     
  943.     return CHK_OK;
  944.     } /* dosFsChkTree() */
  946. /*******************************************************************************
  947. *
  948. * dosChkInit - allocate resources.
  949. *
  950. * RETURNS: OK or ERROR if KHEAP_ALLOC failed.
  951. */
  952. LOCAL STATUS dosChkInit
  953.     (
  954.     DOS_FILE_DESC_ID pFd
  955.     )
  956.     {
  957.     DOS_VOLUME_DESC_ID pVolDesc = pFd->pVolDesc;
  958.     void * chkFatMap;
  959.     BOOL bufToDisk;
  960.     
  961.     if( pVolDesc->pChkDesc == NULL )
  962.      {
  963.      /* allocate descriptor */
  965.      pVolDesc->pChkDesc = KHEAP_ALLOC((sizeof(*pVolDesc->pChkDesc)));
  966.      if( pVolDesc->pChkDesc == NULL )
  967.          return ERROR;
  968.     
  969.      pVolDesc->pChkDesc->bufToDisk = FALSE;
  971.      /* check memory size and allocate FAT buffer */
  973.      pVolDesc->pChkDesc->chkFatMap = NULL; /* do not remove this string */
  975.      if( ((u_long) (memFindMax())  <=  
  976.      (u_long) (pVolDesc->nFatEnts * sizeof 
  977. (*pVolDesc->pChkDesc->chkFatMap) +32)) ||
  978.     (NULL == (pVolDesc->pChkDesc->chkFatMap = 
  979. KHEAP_ALLOC( ((pVolDesc->nFatEnts) * 
  980. (sizeof(*pVolDesc->pChkDesc->chkFatMap)))))) )
  981.          {
  982.          /*
  983.              * only FAT32 disks can use reserved FAT copy instead
  984.              * of memory buffer
  985.              */
  986.          if( (pVolDesc->fatType != FAT32)      ||
  987.           (pVolDesc->pFatDesc->activeCopyNum == pVolDesc->nFats - 1)  ||
  988.           ((pVolDesc->pChkDesc->chkFatMap = 
  989. KHEAP_ALIGNED_ALLOC(
  990. (sizeof(*pVolDesc->pChkDesc->chkFatMap)),
  991.                                 (pVolDesc->nFatEnts / 8 + 4))) == NULL))
  992.              {
  993.           printf( CHK_NOT_ROOM_MSG, pVolDesc->devHdr.name );
  994.                 dosChkFinish( pFd );
  995.           return ERROR;
  996.           }
  998.          pVolDesc->pChkDesc->bufToDisk = TRUE;
  999.          }
  1001.         if( pVolDesc->chkVerbLevel >= (DOS_CHK_VERB_1 >> 8) )
  1002.          dosChkMsg( pFd, CHK_START_MSG, GET_PATH, 0,0,0,0,  NULL );
  1003.      }
  1004.     
  1005.     chkFatMap = pVolDesc->pChkDesc->chkFatMap;
  1006.     
  1007.     bufToDisk = pVolDesc->pChkDesc->bufToDisk;
  1008.     bzero( (char *) pVolDesc->pChkDesc, sizeof( *pVolDesc->pChkDesc ) );
  1009.     pVolDesc->pChkDesc->chkFatMap = chkFatMap;
  1010.     pVolDesc->pChkDesc->bufToDisk = bufToDisk;
  1012.     /* disable FAT mirroring */
  1013.     
  1014.     pVolDesc->pFatDesc->syncToggle (pVolDesc, FALSE);
  1016.     /* zero FAT buffer */
  1017.     
  1018.     dosChkEntryMark (pFd, MARK_BUF_INIT, 0, 0 );
  1019.     
  1020.     return OK;
  1021.     } /* dosChkInit() */
  1022.     
  1023. /*******************************************************************************
  1024. *
  1025. * dosChkDsk - start disk check procedure.
  1026. *
  1027. * RETURNS: OK or ERROR if device is not a valid DOS device,
  1028. *  corrections can not be written to disk
  1029. *  or disk read error.
  1030. *
  1031. * NOMANUAL
  1032. */
  1033. STATUS dosChkDsk
  1034.     (
  1035.     DOS_FILE_DESC_ID pFd
  1036.     )
  1037.     {
  1038.     CHK_STATUS result;
  1039.     size_t i;
  1040.     struct timespec tv;
  1041.     
  1042.     do
  1043.      {
  1044.      if( dosChkInit( pFd ) == ERROR )
  1045.          return ERROR;
  1046.     
  1047.      pFd->pVolDesc->pChkDesc->curPathLev = 1;
  1048.     
  1049.      /* current path is just a device name */
  1050.     
  1051.      strcpy( pFd->pVolDesc->pChkDesc->chkCurPath,
  1052.      pFd->pVolDesc->devHdr.name );
  1053.     
  1054.      result = dosFsChkTree( pFd );
  1055.      }
  1056.     while( result == CHK_RESTART );
  1057.     
  1058.     /* clear current path from screen */
  1060.     printf( "r" );
  1061.     for( i = 0; i < strlen( pFd->pVolDesc->pChkDesc->chkCurPath ); i ++ )
  1062.      {
  1063.      printf( "%4c", SPACE );
  1064.      }
  1065.     printf( "r" );
  1066.     
  1067.     if( result == CHK_ERROR )
  1068.      goto ret;
  1069.     
  1070.     /*
  1071.      * set system clock to be later, than the last time on volume,
  1072.      * but only in case it seems a Real-Time Clock chip
  1073.      * not present
  1074.      */
  1076.     if( time( NULL ) < dosChkMinDate )
  1077.      {
  1078.      tv.tv_sec = max (dosChkMinDate, 
  1079.  (max(pFd->pVolDesc->pChkDesc->chkMaxCreatTime,
  1080.      max(pFd->pVolDesc->pChkDesc->chkMaxModifTime,
  1081.             pFd->pVolDesc->pChkDesc->chkMaxAccTime))));
  1083.      if( tv.tv_sec > time( NULL ) )
  1084.          {
  1085.          tv.tv_nsec = time( NULL );
  1087.     /* Let the user know we are adjusting the system time */
  1088.     printf ("dosChkLib : ");
  1089.          printf("CLOCK_REALTIME is being reset to %s", 
  1090.    ctime( &tv.tv_sec ) );
  1092.          printf("Value obtained from file system volume "
  1093.    "descriptor pointer: %pn", pFd->pVolDesc);
  1095.          tv.tv_nsec = time( NULL );
  1096.          printf("The old setting was %s", ctime((time_t *)&tv.tv_nsec ) );
  1098.          tv.tv_nsec = dosChkMinDate;
  1099.          printf("Accepted system dates are greater than %s", 
  1100.    ctime((time_t *)&tv.tv_nsec));
  1102.          tv.tv_nsec = 1;
  1103.          clock_settime( CLOCK_REALTIME, &tv );
  1104.          }
  1105.      }
  1107.     /* before deal with lost chains, store all corrections to disk */
  1108.     
  1109.     if(O_RDONLY != cbioModeGet(pFd->pVolDesc->pCbio))
  1110.         {
  1111.         if( cbioIoctl (pFd->pVolDesc->pCbio, CBIO_CACHE_FLUSH,
  1112.      (void *)(-1) ) == ERROR )
  1113.          {
  1114.          result = CHK_ERROR;
  1115.          goto ret;
  1116.          }
  1117.      }
  1118.     
  1119.     /* compose "current path" for attractive messages */
  1120.     
  1121.     strcpy( pFd->pVolDesc->pChkDesc->chkCurPath,
  1122.          pFd->pVolDesc->devHdr.name );
  1123.     strcat( pFd->pVolDesc->pChkDesc->chkCurPath,
  1124.          CHK_LOST_CHAINS_MSG );
  1125.     
  1126.     if( dosChkLostFind( pFd ) == ERROR /* collect lost chains */ ||
  1127.      pFd->pVolDesc->pChkDesc->nErrors > 0 )
  1128.      {
  1129.         dosChkLostFree( pFd ); /* free/ count lost chains */
  1130.         
  1131.      if( pFd->pVolDesc->chkLevel == DOS_CHK_ONLY )
  1132.          {
  1133.          dosChkMsg( pFd, CHK_NOT_REPAIRED, GET_PATH, 0,0,0,0, NULL );
  1134.          result = CHK_ERROR;
  1135.          }
  1136.      else if( pFd->pVolDesc->chkLevel >= DOS_CHK_REPAIR )
  1137.          {
  1138.          dosChkMsg( pFd, CHK_RESTORE_FREE, GET_PATH, 0,0,0,0, NULL );
  1139.          }
  1140.      }
  1141.     else
  1142.      {
  1143.      dosChkMsg( pFd, CHK_NO_ERRORS, GET_PATH, 0,0,0,0,  NULL );
  1144.      }
  1145.     
  1146.     /* set a random volume Id, if this initialized to a bad value */
  1147.     
  1148.     if ((pFd->pVolDesc->chkLevel > DOS_CHK_ONLY) &&
  1149.         ((pFd->pVolDesc->volId == 0) || 
  1150.          (pFd->pVolDesc->volId == (u_int)(-1))) &&
  1151.         (O_RDONLY != cbioModeGet(pFd->pVolDesc->pCbio)))
  1152.      {
  1153.      printf("Change volume Id from %p ", (void *)pFd->pVolDesc->volId );
  1155.      VX_TO_DISK_32( tickGet(), &pFd->pVolDesc->volId );
  1157.      cbioBytesRW (pFd->pVolDesc->pCbio, pFd->pVolDesc->bootSecNum,
  1158.           pFd->pVolDesc->volIdOff, (void *)&pFd->pVolDesc->volId,
  1159.           sizeof( pFd->pVolDesc->volId ), CBIO_WRITE, NULL );
  1161.      pFd->pVolDesc->volId = DISK_TO_VX_32( &pFd->pVolDesc->volId );
  1162.     
  1163.      printf("to %pn", (void *)pFd->pVolDesc->volId );
  1164.      }
  1165.     
  1166.     dosChkStatPrint( pFd );
  1167.     
  1168. ret:
  1169.     dosChkFinish( pFd );
  1170.     
  1171.      /* If not write protected enable FAT mirroring and synchronize copies */
  1173.     if ((pFd->pVolDesc->chkLevel > DOS_CHK_ONLY) && 
  1174.         (O_RDONLY != cbioModeGet(pFd->pVolDesc->pCbio)))
  1175.        {
  1176.        pFd->pVolDesc->pFatDesc->syncToggle (pFd->pVolDesc, TRUE);
  1177.        }
  1179.     /*
  1180.      * !!! do not set cbioReadyChanged to TRUE here,
  1181.      *    because dosFsLib has to synchronize cache before it
  1182.      */
  1184.     
  1185.     return ( result == CHK_OK )? OK : ERROR;
  1186.     } /* dosChkDsk() */
  1187.     
  1188. /*******************************************************************************
  1189. *
  1190. * dosChkLibInit - install dos sanity check utility.
  1191. *
  1192. * RETURNS: N/A.
  1193. *
  1194. * NOMANUAL
  1195. */
  1196. void dosChkLibInit( void )
  1197.     {
  1198.     dosFsChkRtn = dosChkDsk;
  1199.     }
  1201. /*******************************************************************************
  1202. *
  1203. * dosChkEntryMarkSet - mark entry if it is not market yet
  1204. *
  1205. * RETURNS: if failed to mark the entry
  1206. */
  1208. LOCAL STATUS dosChkEntryMarkSet
  1209.     (
  1210.     DOS_FILE_DESC_ID pFd, /* pointer to file descriptor */
  1211.     uint32_t entryNum, /*  */
  1212.     uint32_t markValue /*  */
  1213.     )
  1214.     {
  1215.     uint32_t mark;
  1217.    /* Check entry status */
  1219.     mark = dosChkEntryMark (pFd, MARK_GET, entryNum, 0);
  1221.     if (mark != 0) /* already marked entry */
  1222.         return ERROR;
  1224.     /* Mark entry */
  1226.     dosChkEntryMark (pFd, MARK_SET, entryNum, markValue);
  1228.     return OK;
  1229.     } /* dosChkEntryMarkSet */
  1231. /*******************************************************************************
  1232. *
  1233. * dosChkChainMark - mark an entire chain
  1234. *
  1235. * RETURNS: size of file represented by this chain
  1236. */
  1238. LOCAL uint32_t dosChkChainMark
  1239.     (
  1240.     DOS_FILE_DESC_ID pFd, /* pointer to file descriptor */
  1241.     uint32_t startClust, /* start cluster of chain */
  1242.     uint32_t entNum, /* valid entry number */
  1243.     uint32_t entCont /* entry contents */
  1244.     )
  1245.     {
  1246.     DOS_VOLUME_DESC_ID pVolDesc = pFd->pVolDesc;
  1247.     DOS_FAT_DESC_ID pFatDesc = pVolDesc->pFatDesc;
  1248.     uint32_t fileSize;
  1249.     uint32_t clustSize;
  1250.     uint32_t entValue; /* sense of entry contents */
  1251.     uint32_t nextEntCont; /* next entry content, if current entry 
  1252.    contents valid cluster number */
  1253.     uint32_t prevEnt; /*  */
  1254.     uint32_t numClusts; /* size of chain in clusters */
  1255.     uint32_t eofClust;
  1256.     char * errMsg;
  1258.     errMsg   = NULL;
  1259.     eofClust = 0;
  1261.     numClusts = 1; /* start cluster */
  1263.     if ( (pFd->pFileHdl->attrib & DOS_ATTR_DIRECTORY) == 0 )
  1264.         {
  1265.         clustSize = pVolDesc->secPerClust * pVolDesc->bytesPerSec;
  1266.         fileSize = (pFd->pFileHdl->size + clustSize - 1) / clustSize;
  1267.         }
  1268.     else /* this is a directory */
  1269.         fileSize = 0xffffffff;
  1271.     nextEntCont = entCont;
  1272.     entCont     = entNum;
  1273.     entNum      = startClust;
  1274.     entValue    = DOS_FAT_ALLOC;
  1276.     do  {
  1277.         /* Proceed with next entry */
  1279.         prevEnt = entNum; /* previous entry */
  1280.         entNum  = entCont;      /* entry to check */
  1281.         entCont = nextEntCont;  /* contents of the entry to check */
  1283.         if (fileSize == numClusts)
  1284.             {        /* file size is reached */
  1285.             errMsg = CHK_LONG_CHAIN_MSG;
  1286.             eofClust = prevEnt;
  1287.             break;
  1288.             }
  1290.         /* Check for cross link and mark entry */
  1292.         if (dosChkEntryMarkSet (pFd, entNum, startClust) != OK)
  1293.             {       /* cross-link */
  1294.             if (dosChkEntryMark (pFd, MARK_GET, entNum, 0) == LOST_CHAIN_MARK)
  1295.                 dosChkEntryMark (pFd, MARK_SET, entNum, startClust);
  1296.             else
  1297.                 {
  1298.                 errMsg = CHK_CROSS_LINK_MSG;
  1299.                 eofClust = prevEnt;
  1300.                 }
  1302.             break;
  1303.             }
  1305.         numClusts += 1;  /* increase number of clusters in chain */
  1306.        }  /* while entry content is next entry number */
  1307.        while (( entValue = pFatDesc->clustValueGet (
  1308. pFd, pFatDesc->activeCopyNum,
  1309.                                 entCont, &nextEntCont) ) == DOS_FAT_ALLOC);
  1311.     switch (entValue)
  1312.         {
  1313.         case DOS_FAT_BAD:
  1314.             errMsg = CHK_BAD_CHAIN_MSG; /* ??? */
  1315.             eofClust = prevEnt;
  1316.             numClusts -= 1;
  1317.             break;
  1319.         case DOS_FAT_AVAIL:
  1320.         case DOS_FAT_INVAL:
  1321.         case DOS_FAT_RESERV:
  1322.             errMsg = CHK_BAD_CHAIN_MSG; /* ??? */
  1323.             eofClust = entNum;
  1324.             break;
  1326.         case DOS_FAT_ALLOC:
  1327.         case DOS_FAT_EOF:
  1328. default:
  1329.     break;
  1330.         }
  1332.     if (errMsg != NULL)
  1333.         {
  1334.         dosChkMsg (pFd, errMsg, CURRENT_PATH, 0, 0, 0, 0, NULL);
  1335.         pVolDesc->pChkDesc->nErrors++;
  1336.         }
  1338.     if ( (eofClust != 0) && (pVolDesc->chkLevel >= DOS_CHK_REPAIR) )
  1339.          {
  1340.             pFatDesc->clustValueSet (pFd, pFatDesc->activeCopyNum,
  1341.      eofClust, DOS_FAT_EOF, 0);
  1342.          }
  1344.     if ( ((pFd->pFileHdl->attrib & DOS_ATTR_DIRECTORY) == 0) && 
  1345.          (fileSize > numClusts) )
  1346.         dosChkEntryDel (pFd, TRUE, (u_char *)CHK_SHORT_CHAIN_MSG, 
  1347. CURRENT_PATH, 0, 0, 0, 0);
  1349.     return numClusts;
  1350.     } /* dosChkChainMark */
  1352. /*******************************************************************************
  1353. *
  1354. * dosChkChainVerify - verify a cluster chain
  1355. *
  1356. * RETURNS: special status representing the state of this chain
  1357. */
  1359. LOCAL CHK_STATUS dosChkChainVerify
  1360.     (
  1361.     DOS_FILE_DESC_ID pFd /* pointer to file descriptor */
  1362.     )
  1363.     {
  1364.     DOS_VOLUME_DESC_ID pVolDesc = pFd->pVolDesc;
  1365.     DOS_FAT_DESC_ID pFatDesc = pVolDesc->pFatDesc;
  1366.     DOS_FILE_HDL_ID pFileHdl = pFd->pFileHdl;
  1367.     uint32_t parDirStartClust;
  1368.     uint32_t startClust;
  1369.     uint32_t nextEnt;
  1370.     uint32_t nextEntCont = 0;
  1371.     uint32_t entValue; /* sense of entry contents */
  1373.     parDirStartClust = pFd->pFileHdl->dirHdl.parDirStartCluster;
  1375.     startClust = pFileHdl->startClust;
  1377.     /* Check start cluster pointer */
  1379.     entValue = pFatDesc->clustValueGet (pFd, pFatDesc->activeCopyNum,
  1380. startClust, &nextEnt);
  1381.     if (entValue != DOS_FAT_ALLOC)
  1382.         {
  1383.         if ( (entValue == DOS_FAT_AVAIL) && /* start cluster is 0 */
  1384.              ((pFileHdl->attrib & DOS_ATTR_DIRECTORY) == 0) && /* a file */
  1385.              (pFileHdl->size == 0) ) /* size is 0 */
  1386.             return CHK_OK;
  1388.         return dosChkEntryDel (pFd, FALSE, (u_char *)CHK_BAD_START_MSG, 
  1389.        CURRENT_PATH, 0, 0, 0, 0);
  1390.         }
  1392.     /* Check start cluster contents */
  1394.     entValue = pFatDesc->clustValueGet (pFd, pFatDesc->activeCopyNum,
  1395.                                         nextEnt, &nextEntCont);
  1396.     if ( (entValue & (DOS_FAT_ALLOC | DOS_FAT_EOF)) == 0 )
  1397.         {
  1398.         if (entValue == DOS_FAT_BAD)
  1399.             return dosChkEntryDel (pFd, FALSE, (u_char *)CHK_BAD_START_MSG, 
  1400.    CURRENT_PATH, 0, 0, 0, 0); /* ??? */
  1401.         else
  1402.             {
  1403.             /* ??? */
  1404.             dosChkMsg (pFd, CHK_BAD_START_MSG, CURRENT_PATH, 0, 0, 0, 0, NULL);
  1405.             pVolDesc->pChkDesc->nErrors++;
  1407.             if (pVolDesc->chkLevel >= DOS_CHK_REPAIR)
  1408.           {
  1409.                 pFatDesc->clustValueSet (pFd, pFatDesc->activeCopyNum,
  1410.                                          startClust, DOS_FAT_EOF, 0);
  1411.           }
  1412.             }
  1413.         }
  1415.     if (entValue != DOS_FAT_ALLOC)
  1416.         {
  1417.         /* File consists of 1 start cluster only */
  1419.         if ( ((pFileHdl->attrib & DOS_ATTR_DIRECTORY) == 0) &&
  1420.              (pFileHdl->size > pVolDesc->secPerClust * pVolDesc->bytesPerSec) )
  1421.             return dosChkEntryDel (pFd, FALSE, (u_char *)CHK_SHORT_CHAIN_MSG, 
  1422.                                    CURRENT_PATH, 0, 0, 0, 0);
  1423.         }
  1425.     /* Mark start cluster as file's chain start */
  1427.     if (dosChkEntryMarkSet (pFd, startClust,
  1428.     parDirStartClust | START_CLUST_MASK) 
  1429. != OK)
  1430.         {
  1431.         if ( (dosChkEntryMark (pFd, MARK_GET, startClust, 0) &
  1432.       START_CLUST_MASK) == 0)
  1433.             return dosChkEntryDel (pFd, FALSE, (u_char *)CHK_CROSS_LINK_MSG, 
  1434.    CURRENT_PATH, 0, 0, 0, 0); /* ??? */
  1436.         dosChkStartCrossProc (pFd);
  1438.         if (pFileHdl->deleted)
  1439.             return CHK_OK;
  1441.         dosChkEntryMark (pFd, MARK_SET, startClust,
  1442.       parDirStartClust | START_CLUST_MASK);
  1443.         }
  1445.     if (entValue == DOS_FAT_ALLOC)
  1446.         if (dosChkChainMark (pFd, startClust, nextEnt, nextEntCont) == 
  1447. (uint32_t)CHK_ERROR)
  1448.         return CHK_ERROR;
  1450.     return CHK_OK;
  1451.     } /* dosChkChainVerify */
  1453. /*******************************************************************************
  1454. *
  1455. * dosChkChainStartGet - find where is beginning of a chain
  1456. *
  1457. * RETURNS: OK
  1458. */
  1460. LOCAL STATUS dosChkChainStartGet
  1461.     (
  1462.     DOS_FILE_DESC_ID pFd, /* pointer to file descriptor */
  1463.     uint32_t entNum, /* FAT entry number */
  1464.     uint32_t * pParDirStartClust, /* where to return start cluster
  1465. number of parent directory */
  1466.     uint32_t * pStartClust /* where to return start cluster
  1467. number of chain */
  1468.     )
  1469.     {
  1470.     uint32_t mark;
  1472.     mark = dosChkEntryMark (pFd, MARK_GET, entNum, 0);
  1474.     if ((mark & START_CLUST_MASK) == 0) /* not start cluster */
  1475.         { /* go to start cluster */
  1476.         entNum = mark;
  1477.         mark   = dosChkEntryMark (pFd, MARK_GET, entNum, 0);
  1478.         }
  1480.     *pStartClust       = entNum;
  1482.     *pParDirStartClust = mark & (~START_CLUST_MASK);
  1484.     return OK;
  1485.     } /* dosChkChainStartGet */
  1487. /*******************************************************************************
  1488. *
  1489. * dosChkChainUnmark - Un-mark an entire chain
  1490. *
  1491. * RETURNS:
  1492. */
  1494. LOCAL void dosChkChainUnmark
  1495.     (
  1496.     DOS_FILE_DESC_ID pFd /* pointer to file descriptor */
  1497.     )
  1498.     {
  1499.     DOS_FAT_DESC_ID pFatDesc = pFd->pVolDesc->pFatDesc;
  1500.     uint32_t entNum;
  1501.     uint32_t nextEnt;
  1503.     entNum = pFd->pFileHdl->startClust; 
  1505.     while ( (pFatDesc->clustValueGet (pFd, pFatDesc->activeCopyNum,
  1506.                                       entNum, &nextEnt) == DOS_FAT_ALLOC) &&
  1507.             (dosChkEntryMark (pFd, MARK_GET, entNum, 0) != 0) )
  1508.         {
  1509.         dosChkEntryMark (pFd, MARK_SET, entNum, 0);
  1510.         entNum = nextEnt;
  1511.         }
  1512.     } /* dosChkChainUnmark */
  1514. /*******************************************************************************
  1515. *
  1516. * dosChkLostFind - find lost chains in the FAT
  1517. *
  1518. * RETURNS:OK or ERROR if any of the chains contained an illegal value
  1519. */
  1521. LOCAL STATUS dosChkLostFind
  1522.     (
  1523.     DOS_FILE_DESC_ID pFd /* pointer to file descriptor */
  1524.     )
  1525.     {
  1526.     DOS_VOLUME_DESC_ID  pVolDesc = pFd->pVolDesc;
  1527.     DOS_FAT_DESC_ID pFatDesc = pVolDesc->pFatDesc;
  1528.     CHK_DSK_DESC_ID pChkDesc = pVolDesc->pChkDesc;
  1529.     uint32_t entNum;
  1530.     uint32_t entCont;
  1531.     uint32_t nextEntCont;
  1532.     uint32_t entValue;
  1533.     uint32_t retVal = OK;
  1534.     uint32_t lostClusts = 0;
  1535.     cookie_t bufCookie = (cookie_t) NULL, fatCookie = (cookie_t) NULL;
  1537.     for (entNum = DOS_MIN_CLUST; entNum < pFd->pVolDesc->nFatEnts; entNum++)
  1538.         {
  1539.         if (dosChkEntryMark (pFd, IS_BUSY, entNum, 0) == 0)
  1540.             {
  1541.     /* Get content of the entry */
  1543.          bufCookie = pFd->fatHdl.cbioCookie;
  1544.          pFd->fatHdl.cbioCookie = fatCookie;
  1545.             pFatDesc->clustValueGet (pFd, pFatDesc->activeCopyNum,
  1546.                                      entNum, &entCont);
  1548.             /* Value the entry content */
  1550.             entValue = pFatDesc->clustValueGet (pFd, pFatDesc->activeCopyNum,
  1551.                                                 entCont, &nextEntCont);
  1552.          fatCookie = pFd->fatHdl.cbioCookie;
  1553.          pFd->fatHdl.cbioCookie = bufCookie;
  1555.             switch (entValue)
  1556.                 {
  1557.                 case DOS_FAT_ALLOC:
  1558.                 case DOS_FAT_EOF:
  1559.                 case DOS_FAT_INVAL:
  1560.                 case DOS_FAT_RESERV:
  1561.                     pChkDesc->chkNLostChains++;/* Count number of lost chains */
  1562.                     pChkDesc->nErrors++; /* Count number of errors */
  1563.                     retVal = ERROR;
  1564.                     dosChkEntryMark (pFd, MARK_SET, entNum, LOST_CHAIN_MARK);
  1566.                     if (entValue == DOS_FAT_ALLOC)
  1567.                         lostClusts += dosChkChainMark (pFd, entNum, entCont, 
  1568.                                                        nextEntCont);
  1569.                     else
  1570.                         lostClusts += 1;
  1572.                     break;
  1574.                 case DOS_FAT_BAD:
  1575.                     pChkDesc->chkNBadClusts++;
  1576.                     break;
  1578.                 case DOS_FAT_AVAIL:
  1579.                     pChkDesc->chkNFreeClusts++;
  1580.                     break;
  1582.                 } /* switch */
  1583.             }
  1584.         } /* for */
  1586.     pChkDesc->chkTotalBytesInLostChains = lostClusts * pVolDesc->secPerClust *
  1587.                                           pVolDesc->bytesPerSec;;
  1589.     return retVal;
  1590.     } /* dosChkLostFind */
  1592. /*******************************************************************************
  1593. *
  1594. * dosChkLostFree - free all lost chains in the FAT
  1595. *
  1596. * RETURNS: OK.
  1597. */
  1599. LOCAL STATUS dosChkLostFree
  1600.     (
  1601.     DOS_FILE_DESC_ID pFd /* pointer to file descriptor */
  1602.     )
  1603.     {
  1604.     DOS_VOLUME_DESC_ID  pVolDesc = pFd->pVolDesc;
  1605.     DOS_FAT_DESC_ID pFatDesc = pVolDesc->pFatDesc;
  1606.     uint32_t entNum;
  1607.     uint32_t nextEnt;
  1608.     uint32_t nextEntCont;
  1609.     uint32_t entVal;
  1610.     uint32_t i;
  1612.     if (pVolDesc->chkLevel < DOS_CHK_REPAIR)
  1613.         return OK;
  1615.     for (i = DOS_MIN_CLUST; i < pFd->pVolDesc->nFatEnts; i++)
  1616.         {
  1617.         entNum = i;
  1619.         if (dosChkEntryMark (pFd, MARK_GET, entNum, 0) == LOST_CHAIN_MARK)
  1620.             {
  1621.             /* Follow lost chain and free clusters */
  1623.             pFatDesc->clustValueGet (pFd, pFatDesc->activeCopyNum,
  1624.                                      entNum, &nextEnt);
  1626.             /* While entry content is next cluster number */
  1628.             while ( (entVal = pFatDesc->clustValueGet (
  1629. pFd, pFatDesc->activeCopyNum,
  1630.                                 nextEnt, &nextEntCont)) == DOS_FAT_ALLOC )
  1631.                 {
  1632.                 pFatDesc->clustValueSet (pFd, pFatDesc->activeCopyNum,
  1633.                                          entNum, DOS_FAT_AVAIL, 0);
  1635.                 entNum  = nextEnt;
  1636.                 nextEnt = nextEntCont;
  1637.                 }
  1639.             /* For end of file */
  1641.             pFatDesc->clustValueSet (pFd, pFatDesc->activeCopyNum,
  1642.                                      entNum, DOS_FAT_AVAIL, 0);
  1643.             }
  1644.         } /* for */
  1646.     return OK;
  1647.     } /* dosChkLostFree */
  1649. /* End of File */