Changeset 291


Ignore:
Timestamp:
Jul 16, 2017, 6:38:37 PM (3 years ago)
Author:
Valery V. Sedletski
Message:

fat32.ifs: Some minor fixes

  • Initialize several variables to NULL. So that, no error occurs when it tries to free() these variables. This fixes ERROR_NOT_COPY returned in FM/2 and the file manager copies everything well between two FAT drives.
  • Trying to fix errors with swapping
  • Minimize FAT access semaphore acquiring time. So, less probability for timeouts on the semaphore.
Location:
trunk/src/ifs
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/ifs/fat32a.c

    r290 r291  
    4040
    4141USHORT NameHash(USHORT *pszFilename, int NameLen);
    42 USHORT GetChkSum16(const char *data, int bytes);
    43 ULONG GetChkSum32(const char *data, int bytes);
    4442static BOOL ClusterInUse(PVOLINFO pVolInfo, ULONG ulCluster);
    4543static ULONG GetFreeCluster(PVOLINFO pVolInfo);
     
    146144POPENINFO pOpenInfo = NULL;
    147145//BYTE     szSrcLongName[ FAT32MAXPATH ];
    148 PSZ      szSrcLongName;
     146PSZ      szSrcLongName = NULL;
    149147//BYTE     szDstLongName[ FAT32MAXPATH ];
    150 PSZ      szDstLongName;
     148PSZ      szDstLongName = NULL;
    151149
    152150   _asm push es;
     
    32653263PSHOPENINFO pDirSrcSHInfo = NULL, pDirDstSHInfo = NULL;
    32663264//BYTE     szSrcLongName[ FAT32MAXPATH ];
    3267 PSZ      szSrcLongName;
     3265PSZ      szSrcLongName = NULL;
    32683266//BYTE     szDstLongName[ FAT32MAXPATH ];
    3269 PSZ      szDstLongName;
     3267PSZ      szDstLongName = NULL;
    32703268
    32713269   _asm push es;
     
    48944892            ulReturn = ulFirstCluster;
    48954893
    4896          if (MakeChain(pVolInfo, pSHInfo, ulFirstCluster, ulClustersRequested)) ////
     4894         if (MakeChain(pVolInfo, pSHInfo, ulFirstCluster, ulClustersRequested))
    48974895            goto MakeFatChain_Error;
    48984896
     
    49034901            }
    49044902
    4905          ////ReleaseFat(pVolInfo);
    49064903         if (f32Parms.fMessageActive & LOG_FUNCS)
    49074904            {
     
    49634960ULONG ulBmpSector = 0;
    49644961ULONG ulLastCluster = 0;
    4965 ULONG  ulCluster = 0;
     4962ULONG ulCluster = 0;
    49664963ULONG ulNewCluster = 0;
    49674964#ifdef EXFAT
     
    49754972   ulLastCluster = ulFirstCluster + ulSize - 1;
    49764973
    4977    if (GetFatAccess(pVolInfo, "MakeFatChain"))
    4978       return 1;
    4979 
    4980    ulSector = GetFatEntrySec(pVolInfo, ulFirstCluster);
    4981    if (ulSector != pVolInfo->ulCurFatSector)
    4982       ReadFatSector(pVolInfo, ulSector);
     4974   if (!GetFatAccess(pVolInfo, "MakeChain"))
     4975      {
     4976      ulSector = GetFatEntrySec(pVolInfo, ulFirstCluster);
     4977      if (ulSector != pVolInfo->ulCurFatSector)
     4978         ReadFatSector(pVolInfo, ulSector);
     4979      ReleaseFat(pVolInfo);
     4980      }
    49834981
    49844982#ifdef EXFAT
    49854983   if (pVolInfo->bFatType == FAT_TYPE_EXFAT)
    49864984      {
    4987       ulBmpSector = GetAllocBitmapSec(pVolInfo, ulFirstCluster);
    4988       if (ulBmpSector != pVolInfo->ulCurBmpSector)
    4989          ReadBmpSector(pVolInfo, ulBmpSector);
     4985      if (!GetFatAccess(pVolInfo, "MakeChain"))
     4986         {
     4987         ulBmpSector = GetAllocBitmapSec(pVolInfo, ulFirstCluster);
     4988         if (ulBmpSector != pVolInfo->ulCurBmpSector)
     4989            ReadBmpSector(pVolInfo, ulBmpSector);
     4990         ReleaseFat(pVolInfo);
     4991         }
    49904992      }
    49914993#endif
     
    49944996      {
    49954997      if (! pSHInfo || ! pSHInfo->fNoFatChain)
     4998         {
     4999         if (!GetFatAccess(pVolInfo, "MakeChain"))
     5000            {
     5001            ulSector = GetFatEntrySec(pVolInfo, ulCluster);
     5002            if (ulSector != pVolInfo->ulCurFatSector)
     5003               {
     5004               rc = WriteFatSector(pVolInfo, pVolInfo->ulCurFatSector);
     5005               if (rc)
     5006                  return rc;
     5007               ReadFatSector(pVolInfo, ulSector);
     5008               }
     5009            ulNewCluster = GetFatEntry(pVolInfo, ulCluster);
     5010#ifdef EXFAT
     5011            if (ulNewCluster && pVolInfo->bFatType < FAT_TYPE_EXFAT)
     5012#else
     5013            if (ulNewCluster)
     5014#endif
     5015               {
     5016               CritMessage("FAT32:MakeChain:Cluster %lx is not free!", ulCluster);
     5017               Message("ERROR:MakeChain:Cluster %lx is not free!", ulCluster);
     5018               return ERROR_SECTOR_NOT_FOUND;
     5019               }
     5020            SetFatEntry(pVolInfo, ulCluster, ulCluster + 1);
     5021            ReleaseFat(pVolInfo);
     5022            }
     5023         }
     5024#ifdef EXFAT
     5025      if (pVolInfo->bFatType == FAT_TYPE_EXFAT)
     5026         {
     5027         if (!GetFatAccess(pVolInfo, "MakeChain"))
     5028            {
     5029            ulBmpSector = GetAllocBitmapSec(pVolInfo, ulCluster);
     5030            if (ulBmpSector != pVolInfo->ulCurBmpSector)
     5031               {
     5032               rc = WriteBmpSector(pVolInfo, pVolInfo->ulCurBmpSector);
     5033               if (rc)
     5034                  return rc;
     5035               ReadBmpSector(pVolInfo, ulBmpSector);
     5036               }
     5037            fStatus = GetBmpEntry(pVolInfo, ulCluster);
     5038            if (fStatus)
     5039               {
     5040               CritMessage("FAT32:MakeChain:Cluster %lx is not free!", ulCluster);
     5041               Message("ERROR:MakeChain:Cluster %lx is not free!", ulCluster);
     5042               return ERROR_SECTOR_NOT_FOUND;
     5043               }
     5044            SetBmpEntry(pVolInfo, ulCluster, 1);
     5045            ReleaseFat(pVolInfo);
     5046            }
     5047         }
     5048#endif
     5049      }
     5050
     5051#ifdef EXFAT
     5052   if (! pSHInfo || ! pSHInfo->fNoFatChain)
     5053#endif
     5054      {
     5055      if (!GetFatAccess(pVolInfo, "MakeChain"))
    49965056         {
    49975057         ulSector = GetFatEntrySec(pVolInfo, ulCluster);
     
    50005060            rc = WriteFatSector(pVolInfo, pVolInfo->ulCurFatSector);
    50015061            if (rc)
    5002                {
    5003                ReleaseFat(pVolInfo);
    50045062               return rc;
    5005                }
    50065063            ReadFatSector(pVolInfo, ulSector);
    50075064            }
    50085065         ulNewCluster = GetFatEntry(pVolInfo, ulCluster);
    5009 #ifdef EXFAT
    50105066         if (ulNewCluster && pVolInfo->bFatType < FAT_TYPE_EXFAT)
    5011 #else
    5012          if (ulNewCluster)
    5013 #endif
    50145067            {
    50155068            CritMessage("FAT32:MakeChain:Cluster %lx is not free!", ulCluster);
    50165069            Message("ERROR:MakeChain:Cluster %lx is not free!", ulCluster);
    5017             ReleaseFat(pVolInfo);
    50185070            return ERROR_SECTOR_NOT_FOUND;
    50195071            }
    5020          SetFatEntry(pVolInfo, ulCluster, ulCluster + 1);
    5021          }
    5022 #ifdef EXFAT
    5023       if (pVolInfo->bFatType == FAT_TYPE_EXFAT)
     5072
     5073         SetFatEntry(pVolInfo, ulCluster, pVolInfo->ulFatEof);
     5074         rc = WriteFatSector(pVolInfo, pVolInfo->ulCurFatSector);
     5075         if (rc)
     5076            return rc;
     5077         ReleaseFat(pVolInfo);
     5078         }
     5079      }
     5080
     5081#ifdef EXFAT
     5082   if (pVolInfo->bFatType == FAT_TYPE_EXFAT)
     5083      {
     5084      if (!GetFatAccess(pVolInfo, "MakeChain"))
    50245085         {
    50255086         ulBmpSector = GetAllocBitmapSec(pVolInfo, ulCluster);
     
    50285089            rc = WriteBmpSector(pVolInfo, pVolInfo->ulCurBmpSector);
    50295090            if (rc)
    5030                {
    5031                ReleaseFat(pVolInfo);
    50325091               return rc;
    5033                }
    50345092            ReadBmpSector(pVolInfo, ulBmpSector);
    50355093            }
     
    50395097            CritMessage("FAT32:MakeChain:Cluster %lx is not free!", ulCluster);
    50405098            Message("ERROR:MakeChain:Cluster %lx is not free!", ulCluster);
    5041             ReleaseFat(pVolInfo);
    50425099            return ERROR_SECTOR_NOT_FOUND;
    50435100            }
     5101
    50445102         SetBmpEntry(pVolInfo, ulCluster, 1);
    5045          }
    5046 #endif
    5047       }
    5048 
    5049 #ifdef EXFAT
    5050    if (! pSHInfo || ! pSHInfo->fNoFatChain)
    5051 #endif
    5052       {
    5053       ulSector = GetFatEntrySec(pVolInfo, ulCluster);
    5054       if (ulSector != pVolInfo->ulCurFatSector)
    5055          {
    5056          rc = WriteFatSector(pVolInfo, pVolInfo->ulCurFatSector);
    5057          if (rc)
    5058             {
    5059             ReleaseFat(pVolInfo);
    5060             return rc;
    5061             }
    5062          ReadFatSector(pVolInfo, ulSector);
    5063          }
    5064       ulNewCluster = GetFatEntry(pVolInfo, ulCluster);
    5065       if (ulNewCluster && pVolInfo->bFatType < FAT_TYPE_EXFAT)
    5066          {
    5067          CritMessage("FAT32:MakeChain:Cluster %lx is not free!", ulCluster);
    5068          Message("ERROR:MakeChain:Cluster %lx is not free!", ulCluster);
    5069          ReleaseFat(pVolInfo);
    5070          return ERROR_SECTOR_NOT_FOUND;
    5071          }
    5072 
    5073       SetFatEntry(pVolInfo, ulCluster, pVolInfo->ulFatEof);
    5074       rc = WriteFatSector(pVolInfo, pVolInfo->ulCurFatSector);
    5075       if (rc)
    5076          {
    5077          ReleaseFat(pVolInfo);
    5078          return rc;
    5079          }
    5080       }
    5081 
    5082 #ifdef EXFAT
    5083    if (pVolInfo->bFatType == FAT_TYPE_EXFAT)
    5084       {
    5085       ulBmpSector = GetAllocBitmapSec(pVolInfo, ulCluster);
    5086       if (ulBmpSector != pVolInfo->ulCurBmpSector)
    5087          {
    50885103         rc = WriteBmpSector(pVolInfo, pVolInfo->ulCurBmpSector);
    50895104         if (rc)
    5090             {
    5091             ReleaseFat(pVolInfo);
    50925105            return rc;
    5093             }
    5094          ReadBmpSector(pVolInfo, ulBmpSector);
    5095          }
    5096       fStatus = GetBmpEntry(pVolInfo, ulCluster);
    5097       if (fStatus)
    5098          {
    5099          CritMessage("FAT32:MakeChain:Cluster %lx is not free!", ulCluster);
    5100          Message("ERROR:MakeChain:Cluster %lx is not free!", ulCluster);
    51015106         ReleaseFat(pVolInfo);
    5102          return ERROR_SECTOR_NOT_FOUND;
    5103          }
    5104 
    5105       SetBmpEntry(pVolInfo, ulCluster, 1);
    5106       rc = WriteBmpSector(pVolInfo, pVolInfo->ulCurBmpSector);
    5107       if (rc)
    5108          {
    5109          ReleaseFat(pVolInfo);
    5110          return rc;
    51115107         }
    51125108      }
     
    51175113   pVolInfo->pBootFSInfo->ulFreeClusters   -= ulSize;
    51185114
    5119    ReleaseFat(pVolInfo);
    51205115   return 0;
    51215116}
     
    60376032         pNew1->u.File.ulCreateTimestp = pNew1->u.File.ulLastModifiedTimestp;
    60386033         pNew1->u.File.ulLastAccessedTimestp = pNew1->u.File.ulLastModifiedTimestp;
     6034         pNew1->u.File.bCreate10msIncrement = 0;
     6035         pNew1->u.File.bLastModified10msIncrement = 0;
     6036         pNew1->u.File.bCreateTimezoneOffset = 0;
     6037         pNew1->u.File.bLastModifiedTimezoneOffset = 0;
     6038         pNew1->u.File.bLastAccessedTimezoneOffset = 0;
     6039         memset(pNew1->u.File.bResvd2, 0, sizeof(pNew1->u.File.bResvd2));
    60396040         }
    60406041#endif
     
    63186319      }
    63196320
    6320    if (GetFatAccess(pVolInfo, "DeleteFatChain"))
    6321       return FALSE;
    6322 
    6323    ulSector = GetFatEntrySec(pVolInfo, ulCluster);
    6324    ReadFatSector(pVolInfo, ulSector);
     6321   if (!GetFatAccess(pVolInfo, "DeleteFatChain"))
     6322      {
     6323      ulSector = GetFatEntrySec(pVolInfo, ulCluster);
     6324      ReadFatSector(pVolInfo, ulSector);
     6325      ReleaseFat(pVolInfo);
     6326      }
    63256327
    63266328#ifdef EXFAT
    63276329   if (pVolInfo->bFatType == FAT_TYPE_EXFAT)
    63286330      {
    6329       ulBmpSector = GetAllocBitmapSec(pVolInfo, ulCluster);
    6330       ReadBmpSector(pVolInfo, ulSector);
     6331      if (!GetFatAccess(pVolInfo, "DeleteFatChain"))
     6332         {
     6333         ulBmpSector = GetAllocBitmapSec(pVolInfo, ulCluster);
     6334         ReadBmpSector(pVolInfo, ulSector);
     6335         ReleaseFat(pVolInfo);
     6336         }
    63316337      }
    63326338#endif
     
    63466352         }
    63476353
    6348       ulSector = GetFatEntrySec(pVolInfo, ulCluster);
    6349       if (ulSector != pVolInfo->ulCurFatSector)
    6350          {
    6351          rc = WriteFatSector(pVolInfo, pVolInfo->ulCurFatSector);
    6352          if (rc)
    6353             {
     6354      if (!GetFatAccess(pVolInfo, "DeleteFatChain"))
     6355         {
     6356         ulSector = GetFatEntrySec(pVolInfo, ulCluster);
     6357         if (ulSector != pVolInfo->ulCurFatSector)
     6358            {
     6359            rc = WriteFatSector(pVolInfo, pVolInfo->ulCurFatSector);
     6360
     6361            if (rc)
     6362               return FALSE;
     6363            ReadFatSector(pVolInfo, ulSector);
     6364            }
     6365         ulNextCluster = GetFatEntry(pVolInfo, ulCluster);
     6366         SetFatEntry(pVolInfo, ulCluster, 0L);
     6367         ReleaseFat(pVolInfo);
     6368         }
     6369
     6370#ifdef EXFAT
     6371      if (pVolInfo->bFatType == FAT_TYPE_EXFAT)
     6372         {
     6373         if (!GetFatAccess(pVolInfo, "DeleteFatChain"))
     6374            {
     6375            // modify exFAT allocation bitmap as well
     6376            ulBmpSector = GetAllocBitmapSec(pVolInfo, ulCluster);
     6377            if (ulBmpSector != pVolInfo->ulCurBmpSector)
     6378               {
     6379               rc = WriteBmpSector(pVolInfo, pVolInfo->ulCurBmpSector);
     6380
     6381               if (rc)
     6382                  return FALSE;
     6383               ReadBmpSector(pVolInfo, ulBmpSector);
     6384               }
     6385            SetBmpEntry(pVolInfo, ulCluster, 0);
    63546386            ReleaseFat(pVolInfo);
    6355             return FALSE;
    6356             }
    6357          ReadFatSector(pVolInfo, ulSector);
    6358          }
    6359       ulNextCluster = GetFatEntry(pVolInfo, ulCluster);
    6360       SetFatEntry(pVolInfo, ulCluster, 0L);
    6361 
    6362 #ifdef EXFAT
    6363       if (pVolInfo->bFatType == FAT_TYPE_EXFAT)
    6364          {
    6365          // modify exFAT allocation bitmap as well
    6366          ulBmpSector = GetAllocBitmapSec(pVolInfo, ulCluster);
    6367          if (ulBmpSector != pVolInfo->ulCurBmpSector)
    6368             {
    6369             rc = WriteBmpSector(pVolInfo, pVolInfo->ulCurBmpSector);
    6370             if (rc)
    6371                {
    6372                ReleaseFat(pVolInfo);
    6373                return FALSE;
    6374                }
    6375             ReadBmpSector(pVolInfo, ulBmpSector);
    6376             }
    6377          SetBmpEntry(pVolInfo, ulCluster, 0);
     6387            }
    63786388         }
    63796389#endif
     
    63826392      ulCluster = ulNextCluster;
    63836393      }
    6384    rc = WriteFatSector(pVolInfo, pVolInfo->ulCurFatSector);
    6385 
    6386    if (rc)
    6387       {
     6394
     6395   if (!GetFatAccess(pVolInfo, "DeleteFatChain"))
     6396      {
     6397      rc = WriteFatSector(pVolInfo, pVolInfo->ulCurFatSector);
     6398
     6399      if (rc)
     6400         return FALSE;
     6401
     6402#ifdef EXFAT
     6403      if (pVolInfo->bFatType == FAT_TYPE_EXFAT)
     6404         {
     6405         rc = WriteBmpSector(pVolInfo, pVolInfo->ulCurBmpSector);
     6406
     6407         if (rc)
     6408            return FALSE;
     6409         }
     6410#endif
    63886411      ReleaseFat(pVolInfo);
    6389       return FALSE;
    6390       }
    6391 
    6392 #ifdef EXFAT
    6393    if (pVolInfo->bFatType == FAT_TYPE_EXFAT)
    6394       {
    6395       rc = WriteBmpSector(pVolInfo, pVolInfo->ulCurBmpSector);
    6396 
    6397       if (rc)
    6398          {
    6399          ReleaseFat(pVolInfo);
    6400          return FALSE;
    6401          }
    6402       }
    6403 #endif
     6412      }
    64046413
    64056414   pVolInfo->pBootFSInfo->ulFreeClusters += ulClustersFreed;
    64066415/*   UpdateFSInfo(pVolInfo);*/
    6407 
    6408    ReleaseFat(pVolInfo);
    64096416
    64106417   return TRUE;
     
    64436450      }
    64446451#endif
    6445 
    6446    if (GetFatAccess(pVolInfo, "SeekToCluster"))
    6447       return pVolInfo->ulFatEof;
    64486452
    64496453   while (ulCluster != pVolInfo->ulFatEof &&
     
    64546458#endif
    64556459      {
     6460      if (GetFatAccess(pVolInfo, "SeekToCluster"))
     6461         return pVolInfo->ulFatEof;
     6462
    64566463      ulSector = GetFatEntrySec(pVolInfo, ulCluster);
    64576464
     
    64696476      llPosition = iSubUL(llPosition, pVolInfo->ulClusterSize);
    64706477#endif
    6471       }
    6472    ReleaseFat(pVolInfo);
     6478      ReleaseFat(pVolInfo);
     6479      }
    64736480
    64746481   return ulCluster;
  • trunk/src/ifs/fat32b.c

    r284 r291  
    1414
    1515USHORT NameHash(USHORT *pszFilename, int NameLen);
    16 USHORT GetChkSum16(const char *data, int bytes);
    17 ULONG GetChkSum32(const char *data, int bytes);
     16USHORT GetChkSum16(const UCHAR *data, int bytes);
     17ULONG  GetChkSum32(const UCHAR *data, int bytes);
    1818
    1919VOID MarkFreeEntries(PDIRENTRY pDirBlock, ULONG ulSize);
     
    895895}
    896896
    897 USHORT GetChkSum16(const char *data, int bytes)
     897USHORT GetChkSum16(const UCHAR *data, int bytes)
    898898{
    899899   USHORT chksum = 0;
     
    902902   for (i = 0; i < bytes; i++)
    903903      {
    904       if (i == 2)
    905          // skip checksum field
    906          i++;
    907       else
    908          chksum = (chksum << 15) | (chksum >> 1) + data[i];
     904      if (i == 2 || i == 3)
     905         continue;
     906
     907      chksum = (chksum << 15) | (chksum >> 1) + (USHORT)data[i];
    909908      }
    910909
     
    912911}
    913912
    914 ULONG GetChkSum32(const char *data, int bytes)
     913ULONG GetChkSum32(const UCHAR *data, int bytes)
    915914{
    916915   ULONG chksum = 0;
     
    918917
    919918   for (i = 0; i < bytes; i++)
    920       chksum = (chksum << 31) | (chksum >> 1) + data[i];
     919      chksum = (chksum << 31) | (chksum >> 1) + (ULONG)data[i];
    921920
    922921   return chksum;
     
    16421641                              memcpy(pWorkStream, pStreamNew, sizeof (DIRENTRY1));
    16431642                              }
    1644                            pWorkFile->u.File.usSetCheckSum = GetChkSum16((char *)pWorkFile,
     1643                           pWorkFile->u.File.usSetCheckSum = GetChkSum16((UCHAR *)pWorkFile,
    16451644                              sizeof(DIRENTRY1) * (pWorkFile->u.File.bSecondaryCount + 1));
    16461645                           //if (ulCluster == 1)
     
    17511750                     pStreamNew->u.Stream.bNameLen = (BYTE)strlen(pszLongName);
    17521751                     memcpy(pWork++, pStreamNew, sizeof (DIRENTRY1));
    1753                      (pWork-2)->u.File.usSetCheckSum = GetChkSum16((char *)(pWork-2),
     1752                     (pWork-2)->u.File.usSetCheckSum = GetChkSum16((UCHAR *)(pWork-2),
    17541753                        sizeof(DIRENTRY1) * ((pWork-2)->u.File.bSecondaryCount + 1));
    17551754
     
    17971796                     pStreamNew->u.Stream.bNameLen = (BYTE)strlen(pszLongName);
    17981797                     memcpy(pWork++, pStreamNew, sizeof (DIRENTRY1));
    1799                      (pWork-2)->u.File.usSetCheckSum = GetChkSum16((char *)(pWork-2),
     1798                     (pWork-2)->u.File.usSetCheckSum = GetChkSum16((UCHAR *)(pWork-2),
    18001799                        sizeof(DIRENTRY1) * ((pWork-2)->u.File.bSecondaryCount + 1));
    18011800                     //if (ulCluster == 1)
  • trunk/src/ifs/ifsattr.c

    r284 r291  
    196196            else
    197197               pDirNew1->u.File.usFileAttr = (BYTE)*pAttr;
     198
     199            pDirNew1->u.File.bCreate10msIncrement = 0;
     200            pDirNew1->u.File.bLastModified10msIncrement = 0;
     201            pDirNew1->u.File.bCreateTimezoneOffset = 0;
     202            pDirNew1->u.File.bLastModifiedTimezoneOffset = 0;
     203            pDirNew1->u.File.bLastAccessedTimezoneOffset = 0;
     204            memset(pDirNew1->u.File.bResvd2, 0, sizeof(pDirNew1->u.File.bResvd2));
     205
    198206            rc = ModifyDirectory(pVolInfo, ulDirCluster, pDirSHInfo, MODIFY_DIR_UPDATE,
    199207               pDirEntry, (PDIRENTRY)pDirNew1, pDirEntryStream, NULL, NULL, 0);
     
    934942               else
    935943                  pDirNew1->u.File.usFileAttr = (BYTE)pfStatus->attrFile;
     944
     945               pDirNew1->u.File.bCreate10msIncrement = 0;
     946               pDirNew1->u.File.bLastModified10msIncrement = 0;
     947               pDirNew1->u.File.bCreateTimezoneOffset = 0;
     948               pDirNew1->u.File.bLastModifiedTimezoneOffset = 0;
     949               pDirNew1->u.File.bLastAccessedTimezoneOffset = 0;
     950               memset(pDirNew1->u.File.bResvd2, 0, sizeof(pDirNew1->u.File.bResvd2));
    936951               }
    937952#endif
     
    10581073               else
    10591074                  pDirNew1->u.File.usFileAttr = (BYTE)pfStatus->attrFile;
     1075
     1076               pDirNew1->u.File.bCreate10msIncrement = 0;
     1077               pDirNew1->u.File.bLastModified10msIncrement = 0;
     1078               pDirNew1->u.File.bCreateTimezoneOffset = 0;
     1079               pDirNew1->u.File.bLastModifiedTimezoneOffset = 0;
     1080               pDirNew1->u.File.bLastAccessedTimezoneOffset = 0;
     1081               memset(pDirNew1->u.File.bResvd2, 0, sizeof(pDirNew1->u.File.bResvd2));
    10601082               }
    10611083#endif
  • trunk/src/ifs/ifscache.c

    r286 r291  
    268268
    269269   /* check bad cluster (moved to ReadBlock) */
    270    if( ulSector >= pVolInfo->ulStartOfData )
     270   /* if( ulSector >= pVolInfo->ulStartOfData )
    271271   {
    272272        ULONG ulStartCluster = Sector2Cluster( ulSector );
     
    275275        ULONG ulCluster;
    276276
    277         /* for( ulCluster = ulStartCluster; ulCluster <= ulEndCluster; ulCluster++ )
     277        for( ulCluster = ulStartCluster; ulCluster <= ulEndCluster; ulCluster++ )
    278278        {
    279279            //ulNextCluster = GetNextCluster2( pVolInfo, NULL, ulCluster );
     
    291291        if (usSectors == 0)
    292292            // avoid reading zero sectors
    293             return ERROR_SECTOR_NOT_FOUND; */
    294    }
     293            return ERROR_SECTOR_NOT_FOUND;
     294   } */
    295295
    296296   usIOMode &= ~DVIO_OPWRITE;
  • trunk/src/ifs/ifsfile.c

    r290 r291  
    849849            memcpy(&psffsi->sfi_mtime, &pDirEntry->wLastWriteTime, sizeof (USHORT));
    850850            memcpy(&psffsi->sfi_mdate, &pDirEntry->wLastWriteDate, sizeof (USHORT));
     851
     852            *pfGenFlag = ( HAS_CRITICAL_EAS( pDirEntry->fEAS ) ? 1 : 0);
    851853#ifdef EXFAT
    852854            }
     
    866868            memcpy(&psffsi->sfi_mtime, &time, sizeof (USHORT));
    867869            memcpy(&psffsi->sfi_mdate, &date, sizeof (USHORT));
     870
     871            *pfGenFlag = ( HAS_CRITICAL_EAS( pDirEntry1->u.File.fEAS ) ? 1 : 0);
    868872            }
    869873#endif
     
    871875         psffsi->sfi_tstamp = 0;
    872876         *pAction = FILE_EXISTED;
    873          *pfGenFlag = ( HAS_CRITICAL_EAS( pDirEntry->fEAS ) ? 1 : 0);
    874877         }
    875878
     
    30763079            ts = SetTimeStamp(*(FDATE *)&psffsi->sfi_mdate, *(FTIME *)&psffsi->sfi_mtime);
    30773080            memcpy(&pDirEntry1->u.File.ulLastModifiedTimestp, &ts, sizeof(TIMESTAMP));
     3081
     3082            pDirEntry1->u.File.bCreate10msIncrement = 0;
     3083            pDirEntry1->u.File.bLastModified10msIncrement = 0;
     3084            pDirEntry1->u.File.bCreateTimezoneOffset = 0;
     3085            pDirEntry1->u.File.bLastModifiedTimezoneOffset = 0;
     3086            pDirEntry1->u.File.bLastAccessedTimezoneOffset = 0;
     3087            memset(pDirEntry1->u.File.bResvd2, 0, sizeof(pDirEntry1->u.File.bResvd2));
    30783088
    30793089#ifdef INCL_LONGLONG
  • trunk/src/ifs/ifsfind.c

    r290 r291  
    18221822{
    18231823   TIMESTAMP ts;
     1824   memset(&ts, 0, sizeof(ts));
    18241825
    18251826   ts.twosecs = time.twosecs;
  • trunk/src/ifs/ifsswap.c

    r260 r291  
    2020
    2121#define PSIZE           4096
    22 #define MAXPGREQ        8
     22#define MAXPGREQ        16 // 8
     23
     24// swap file open count
     25USHORT swap_open_count = 0;
     26// hVPB of volume with a swap file
     27unsigned short swap_hVPB = 0;
    2328
    2429RQLIST pgreq;
     
    7075    * to be quiesced.
    7176    */
    72    ////page_hVPB = psffsi->sfi_hVPB;
     77   swap_hVPB = psffsi->sfi_hVPB;
    7378
    7479   /* pathlookup needs the hVPB in the current directory structure
     
    8691   if (rc == 0)
    8792      {
    88       if (pVolInfo->pfnStrategy)
    89          {
    90             /*   Strat2 is supported.
    91              *   set return information:
    92              *   pageio requests require physical addresses;
    93              *   maximum request is 16 pages;
    94              */
    95             *pFlags = PGIO_PADDR;
    96             *pcMaxReq = MAXPGREQ;
    97          }
    98       else
    99          {
    100             // no Strat2
    101             *pFlags = PGIO_VADDR;
     93      swap_open_count++;
     94
     95      //if (pVolInfo->pfnStrategy)
     96      //   {
     97      //      /*   Strat2 is supported.
     98      //       *   set return information:
     99      //       *   pageio requests require physical addresses;
     100      //       *   maximum request is 16 pages;
     101      //       */
     102      //      *pFlags |= PGIO_PADDR;
     103      //      *pcMaxReq = MAXPGREQ;
     104      //   }
     105      //else
     106      //   {
     107      //      // no Strat2
     108            *pFlags |= PGIO_VADDR;
    102109            *pcMaxReq = 0;
    103          }
     110      //   }
     111
     112      //if ((*pFlags & PGIO_FIRSTOPEN) && (swap_open_count == 1))
     113      //   {
     114      //   // make swap file zero-aligned
     115      //   rc = FS_NEWSIZEL (psffsi, psffsd, 0LL, 0);
     116
     117      //   if (rc)
     118      //      {
     119      //      goto FS_OPENPAGEFILE_EXIT;
     120      //      }
     121      //   }
    104122      }
    105123
     
    121139    struct sffsd far *psffsd,       /* ptr to fs dependent SFT   */
    122140    unsigned long     ulSize,       /* new size          */
    123     unsigned long     lWantContig   /* contiguous chunk size     */
     141    unsigned long     ulWantContig   /* contiguous chunk size     */
    124142)
    125143{
    126144   int rc;
    127145   ULONGLONG ullSize;
     146   PVOLINFO  pVolInfo;
    128147
    129148#ifdef INCL_LONGLONG
     
    134153
    135154   if (f32Parms.fMessageActive & LOG_FS)
    136       Message("FS_ALLOCATEPAGESPACE  size=%lu contig=%lu", ulSize, lWantContig);
     155      Message("FS_ALLOCATEPAGESPACE  size=%lu contig=%lu", ulSize, ulWantContig);
    137156
    138157   _asm push es;
     158
     159   pVolInfo = GetVolInfo(psffsi->sfi_hVPB);
     160
     161   if (! pVolInfo)
     162      {
     163      rc = ERROR_INVALID_DRIVE;
     164      goto FS_ALLOCATEPAGESPACE_EXIT;
     165      }
     166
     167   if (pVolInfo->fFormatInProgress)
     168      {
     169      rc = ERROR_ACCESS_DENIED;
     170      goto FS_ALLOCATEPAGESPACE_EXIT;
     171      }
     172
     173   if (ulWantContig > pVolInfo->ulClusterSize)
     174      {
     175      rc = ERROR_DISK_FULL;
     176      goto FS_ALLOCATEPAGESPACE_EXIT;
     177      }
    139178
    140179   rc = FS_NEWSIZEL(psffsi, psffsd, ullSize, 0x10);
     
    147186         {
    148187#ifdef INCL_LONGLONG
    149          psffsi->sfi_sizel = (ULONGLONG)ulSize;
     188         psffsi->sfi_sizel = ullSize;
    150189#else
    151          iAssignUL(&psffsi->sfi_sizel, ulSize);
     190         iAssign(&psffsi->sfi_sizel, *(PLONGLONG)&ullSize);
    152191#endif
    153192         }
    154193      }
    155194
     195FS_ALLOCATEPAGESPACE_EXIT:
    156196   if (f32Parms.fMessageActive & LOG_FS)
    157197      Message("FS_ALLOCATEPAGESPACE returned %u\n", rc);
Note: See TracChangeset for help on using the changeset viewer.