Changeset 289

Timestamp:

Jul 6, 2017, 9:53:56 AM (8 years ago)

Author:

Valery V. Sedletski

Message:

• Fix skipping 2nd cluster on exFAT when cluster size is 128+ KB when reading and writing files.
• Make FORMAT create FS'es with 128 KB or more clusters. Support the case with a very small (1kb or so) clusters, when the allocation bitmap uses many clusters, so they don't fit into one FAT sector.
• Add support for adding timestamps for files created by CHKDSK.

Location:

trunk/src

Files:

• ifs/fat32a.c (modified) (1 diff)
• ifs/ifsfile.c (modified) (8 diffs)
• include/fat32c.h (modified) (1 diff)
• ufat32/fatfunc.c (modified) (6 diffs)
• ufat32/format.c (modified) (22 diffs)
• ufat32/os2.c (modified) (2 diffs)
• ufat32/win32.c (modified) (2 diffs)

trunk/src/ifs/fat32a.c ¶

@@ -6031 +6031 @@
          pNew1->u.File.ulLastModifiedTimestp.month = pGI->month;
          pNew1->u.File.ulLastModifiedTimestp.day = pGI->day;
-         pNew1->u.File.ulLastModifiedTimestp.hour = pGI->day;
+         pNew1->u.File.ulLastModifiedTimestp.hour = pGI->hour;
          pNew1->u.File.ulLastModifiedTimestp.minutes = pGI->minutes;
          pNew1->u.File.ulLastModifiedTimestp.seconds = pGI->seconds;

trunk/src/ifs/ifsfile.c ¶

@@ -1249 +1249 @@
 PBYTE  pbCluster;
 ULONG  ulClusterSector;
-USHORT usClusterOffset;
+ULONG  ulClusterOffset;
 USHORT usBlockOffset;
 ULONG  ulBytesPerCluster;
@@ -1518 +1518 @@
         ulBytesPerBlock   = pVolInfo->ulBlockSize;
 #ifdef INCL_LONGLONG
-        usClusterOffset   = (USHORT)(pos % ulBytesPerCluster); /* get remainder */
+        ulClusterOffset   = (ULONG)(pos % ulBytesPerCluster); /* get remainder */
         usBlockOffset     = (USHORT)(pos % ulBytesPerBlock);   /* get remainder */
 #else
@@ -1525 +1525 @@
 
         llRes = iModUL(pos, ulBytesPerCluster);
-        usClusterOffset = (USHORT)llRes.ulLo;
+        ulClusterOffset = (ULONG)llRes.ulLo;
         llRes = iModUL(pos, ulBytesPerBlock);
         usBlockOffset   = (USHORT)llRes.ulLo; 
@@ -1589 +1589 @@
             }
 
-            if (((ULONG)usClusterOffset + ulCurrBytesToRead) >= ulBytesPerCluster)
+            if (ulClusterOffset + ulCurrBytesToRead >= ulBytesPerCluster)
             {
                 pOpenInfo->ulCurCluster     = GetNextCluster(pVolInfo, pOpenInfo->pSHInfo, pOpenInfo->ulCurCluster);
@@ -1870 +1870 @@
 PBYTE  pbCluster;
 ULONG  ulClusterSector;
-USHORT usClusterOffset;
+ULONG  ulClusterOffset;
 USHORT usBlockOffset;
 ULONG  ulBytesPerCluster;
@@ -2299 +2299 @@
         ulBytesPerBlock   = pVolInfo->ulBlockSize;
 #ifdef INCL_LONGLONG
-        usClusterOffset   = (USHORT)(pos % ulBytesPerCluster); /* get remainder */
+        ulClusterOffset   = (ULONG)(pos % ulBytesPerCluster); /* get remainder */
         usBlockOffset     = (USHORT)(pos % ulBytesPerBlock);   /* get remainder */
 #else
@@ -2306 +2306 @@
 
         llRes = iModUL(pos, ulBytesPerCluster);
-        usClusterOffset   = (USHORT)llRes.ulLo;
+        ulClusterOffset   = (ULONG)llRes.ulLo;
         llRes = iModUL(pos, ulBytesPerBlock);
         usBlockOffset     = (USHORT)llRes.ulLo; 
@@ -2376 +2376 @@
             }
 
-            if (((ULONG)usClusterOffset + ulCurrBytesToWrite) >= ulBytesPerCluster)
+            if (ulClusterOffset + ulCurrBytesToWrite >= ulBytesPerCluster)
             {
                 pOpenInfo->ulCurCluster     = GetNextCluster(pVolInfo, pOpenInfo->pSHInfo, pOpenInfo->ulCurCluster);

trunk/src/include/fat32c.h ¶

@@ -259 +259 @@
 ULONG query_vol_label(char *path, char *pszVolLabel, int cbVolLabel);
 void set_datetime(DIRENTRY *pDir);
+void set_datetime1(DIRENTRY1 *pDir);
 char *get_error(USHORT rc);
 void query_current_disk(char *pszDrive);

trunk/src/ufat32/fatfunc.c ¶

@@ -94 +94 @@
 
 void set_datetime(DIRENTRY *pDir);
+void set_datetime1(DIRENTRY1 *pDir);
 
 /******************************************************************
@@ -1675 +1676 @@
             return ERROR_FILE_EXISTS;
             }
+         set_datetime1(&DirNew);
          memcpy(pNew, &DirNew, sizeof (DIRENTRY));
 
@@ -1843 +1845 @@
                      //   Message(" Updating cluster");
                      memcpy(pWorkFile, pNew, sizeof (DIRENTRY1));
+                     set_datetime1(pWorkFile);
                      if (pStreamNew)
                         {
@@ -3363 +3366 @@
       memcpy(DirEntry.bExtention, szFileName + 6, 3);
 
-   set_datetime(&DirEntry);
+
+#ifdef EXFAT
+   if (pCD->bFatType < FAT_TYPE_EXFAT)
+#endif
+      set_datetime(&DirEntry);
+#ifdef EXFAT
+   else
+      set_datetime1((PDIRENTRY1)&DirEntry);
+#endif
+
    if (!ulDirCluster)
       ulDirCluster = MakeDir(pCD, pCD->BootSect.bpb.RootDirStrtClus, &DirEntry, szFileName);
@@ -3402 +3414 @@
       strncpy(pData, szFileName, cbData);
 
-   set_datetime(&DirEntry);
+#ifdef EXFAT
+   if (pCD->bFatType < FAT_TYPE_EXFAT)
+#endif
+      set_datetime(&DirEntry);
+#ifdef EXFAT
+   else
+      set_datetime1((PDIRENTRY1)&DirEntry);
+#endif
 
 #ifdef EXFAT
@@ -3455 +3474 @@
                     PDIRENTRY pNew, PDIRENTRY1 pNewStream, PSZ pszName)
 {
+#ifdef EXFAT
+   if (pCD->bFatType < FAT_TYPE_EXFAT)
+      {
+#endif
+      set_datetime(pNew);
+#ifdef EXFAT
+      }
+   else
+      {
+      set_datetime1((PDIRENTRY1)pNew);
+      }
+#endif
+
    return ModifyDirectory(pCD, ulDirCluster, pDirSHInfo, MODIFY_DIR_INSERT, 
       NULL, pNew, NULL, pNewStream, pszName);

trunk/src/ufat32/format.c ¶

@@ -196 +196 @@
 #ifdef EXFAT
     case FAT_TYPE_EXFAT:
-        // 7 MB to 256 MB - 4 KB
-        if ( DiskSizeMB > 7 )
+        // 256 MB to 512 MB - 1 KB
+        if ( DiskSizeMB > 256 )
+            ret = get_spc( 1, BytesPerSect );  // ret = 0x2;
+
+        // 512 MB to 1,024 MB - 2 KB
+        if ( DiskSizeMB > 512 )
+            ret = get_spc( 2, BytesPerSect );  // ret = 0x4;
+
+        // 1,024 MB to 2,048 MB - 4 KB
+        if ( DiskSizeMB > 1024 )
             ret = get_spc( 4, BytesPerSect );  // ret = 0x8;
 
-        // 256 MB to 1,024 MB - 32 KB
-        if ( DiskSizeMB > 256 )
+        // 2,048 MB to 4,096 MB - 8 KB
+        if ( DiskSizeMB > 2048 )
+            ret = get_spc( 8, BytesPerSect );  // ret = 0x10;
+
+        // 4,096 MB to 8,192 MB - 16 KB
+        if ( DiskSizeMB > 4096 )
+            ret = get_spc( 16, BytesPerSect );  // ret = 0x20;
+
+        // 8,192 MB to 16,384 MB - 32 KB
+        if ( DiskSizeMB > 8192 )
             ret = get_spc( 32, BytesPerSect );  // ret = 0x40;
+
+        // 16,384 MB to 32,768 MB - 64 KB
+        if ( DiskSizeMB > 16384 )
+            ret = get_spc( 64, BytesPerSect );  // ret = 0x80;
 
         // Larger than 32,784 MB - 128 KB
         if ( DiskSizeMB > 32784 )
-            ret = get_spc( 128, BytesPerSect );  // ret = 0x80;
+            ret = get_spc( 128, BytesPerSect );  // ret = 0x100;
 #endif
     }
@@ -382 +402 @@
     FAT_FSINFO *pFAT32FsInfo;
     DWORD *pFirstSectOfFat;
+    DWORD FatSize;
 
 #ifdef EXFAT
@@ -466 +487 @@
         dp.SectorsPerCluster = get_sectors_per_cluster( params, ((LONGLONG)dp.TotalSectors) * dp.BytesPerSect, dp.BytesPerSect );
 
-    dp.FatSize = get_fat_size_sectors ( params, dp.TotalSectors, 
-        dp.ReservedSectCount, dp.SectorsPerCluster,
+    FatSize = get_fat_size_sectors ( params, dp.TotalSectors, 
+        dp.ReservedSectCount, params->sectors_per_cluster,
         dp.NumFATs, dp.BytesPerSect );
 
-    UserAreaSize = dp.TotalSectors - dp.ReservedSectCount - (dp.NumFATs*dp.FatSize);
+    UserAreaSize = dp.TotalSectors - dp.ReservedSectCount - ((DWORD)dp.NumFATs*FatSize);
 
     if (params->bFatType < FAT_TYPE_FAT32)
         // root dir is excluded from user area on FAT12/FAT16
-        UserAreaSize -= dp.SectorsPerCluster;
-
-    ClusterCount = UserAreaSize / dp.SectorsPerCluster;
+        UserAreaSize -= params->sectors_per_cluster; // ???!
+
+    ClusterCount = UserAreaSize / params->sectors_per_cluster;
 
     if ( (ClusterCount >= FAT12_BAD_CLUSTER && params->bFatType == FAT_TYPE_FAT12) ||
@@ -542 +563 @@
     FatNeeded /= dp.BytesPerSect;
 
-    if ( FatNeeded > dp.FatSize )
+    if ( FatNeeded > FatSize )
     {
         die ( "This drive is too big for this version\n"
@@ -606 +627 @@
         pFATBootSect->wBytsPerSec = (WORD) dp.BytesPerSect;
 
-        pFATBootSect->bSecPerClus = (BYTE) dp.SectorsPerCluster;
+        pFATBootSect->bSecPerClus = (BYTE) params->sectors_per_cluster;
         pFATBootSect->wRsvdSecCnt = (WORD) dp.ReservedSectCount;
         pFATBootSect->bNumFATs = (BYTE) dp.NumFATs;
-        pFATBootSect->wRootEntCnt = (dp.SectorsPerCluster * dp.BytesPerSect) /
+        pFATBootSect->wRootEntCnt = (params->sectors_per_cluster * dp.BytesPerSect) /
             sizeof(DIRENTRY); // number of dir entries per cluster
 
@@ -618 +639 @@
 
         pFATBootSect->bMedia = 0xF8;
-        pFATBootSect->wFATSz16 = dp.FatSize;
+        pFATBootSect->wFATSz16 = (WORD)FatSize;
         pFATBootSect->wSecPerTrk = (WORD) dp.SectorsPerTrack;
         pFATBootSect->wNumHeads = (WORD) dp.TracksPerCylinder;
@@ -653 +674 @@
         pFAT32BootSect->wBytsPerSec = (WORD) dp.BytesPerSect;
 
-        pFAT32BootSect->bSecPerClus = (BYTE) dp.SectorsPerCluster;
+        pFAT32BootSect->bSecPerClus = (BYTE) params->sectors_per_cluster;
         pFAT32BootSect->wRsvdSecCnt = (WORD) dp.ReservedSectCount;
         pFAT32BootSect->bNumFATs = (BYTE) dp.NumFATs;
@@ -666 +687 @@
         pFAT32BootSect->dTotSec32 = dp.TotalSectors;
     
-        pFAT32BootSect->dFATSz32 = dp.FatSize;
+        pFAT32BootSect->dFATSz32 = (WORD)FatSize;
         pFAT32BootSect->wExtFlags = 0;
         pFAT32BootSect->wFSVer = 0;
@@ -687 +708 @@
     {
         USHORT usSectorSize  = (USHORT)dp.BytesPerSect;
-        USHORT usClusterSize = (USHORT)dp.SectorsPerCluster;
+        USHORT usClusterSize = (USHORT)params->sectors_per_cluster;
 
         // fill out the boot sector and fs info
@@ -698 +719 @@
         pEXFATBootSect->ullVolumeLength = (ULONGLONG)dp.TotalSectors;
         pEXFATBootSect->ulFatOffset = (WORD) dp.ReservedSectCount;
-        pEXFATBootSect->ulFatLength = dp.FatSize;
+        pEXFATBootSect->ulFatLength = FatSize;
         pEXFATBootSect->ulClusterHeapOffset = pEXFATBootSect->ulFatOffset + pEXFATBootSect->ulFatLength;
-        pEXFATBootSect->ulClusterCount = (ULONG)((dp.TotalSectors - dp.FatSize
-            - dp.ReservedSectCount) / dp.SectorsPerCluster);
+        pEXFATBootSect->ulClusterCount = (ULONG)((dp.TotalSectors - FatSize
+            - dp.ReservedSectCount) / params->sectors_per_cluster);
         ulExfatBitmapLen = (pEXFATBootSect->ulClusterCount / 8) +
            (pEXFATBootSect->ulClusterCount % 8 ? 1 : 0);
-        ulExfatBitmapClusters = ulExfatBitmapLen / (dp.SectorsPerCluster * dp.BytesPerSect);
-        ulExfatBitmapClusters = (ulExfatBitmapLen % (dp.SectorsPerCluster * dp.BytesPerSect)) ?
+        ulExfatBitmapClusters = ulExfatBitmapLen / (params->sectors_per_cluster * dp.BytesPerSect);
+        ulExfatBitmapClusters = (ulExfatBitmapLen % (params->sectors_per_cluster * dp.BytesPerSect)) ?
             ulExfatBitmapClusters + 1 : ulExfatBitmapClusters;
         ulExfatUpCaseLen = sizeof(pUpCase);
-        ulExfatUpCaseClusters = ulExfatUpCaseLen / (dp.SectorsPerCluster * dp.BytesPerSect);
-        ulExfatUpCaseClusters = (ulExfatUpCaseLen % (dp.SectorsPerCluster * dp.BytesPerSect)) ?
+        ulExfatUpCaseClusters = ulExfatUpCaseLen / (params->sectors_per_cluster * dp.BytesPerSect);
+        ulExfatUpCaseClusters = (ulExfatUpCaseLen % (params->sectors_per_cluster * dp.BytesPerSect)) ?
             ulExfatUpCaseClusters + 1 : ulExfatUpCaseClusters;
         pEXFATBootSect->RootDirStrtClus = 2 + ulExfatBitmapClusters + ulExfatUpCaseClusters;
@@ -741 +762 @@
         pEXFATBootSect->usBootSig = 0xaa55;
 
-        mem_alloc ( (void **)&pBitmap,  ulExfatBitmapClusters * dp.SectorsPerCluster * dp.BytesPerSect);
+        mem_alloc ( (void **)&pBitmap,  ulExfatBitmapClusters * params->sectors_per_cluster * dp.BytesPerSect);
 
         if ( !pBitmap )
              die ( "Failed to allocate memory", -2 );
 
-        mem_alloc ( (void **)&pRootDir,  dp.SectorsPerCluster * dp.BytesPerSect);
+        mem_alloc ( (void **)&pRootDir,  params->sectors_per_cluster * dp.BytesPerSect);
 
         if ( !pRootDir )
              die ( "Failed to allocate memory", -2 );
 
-        mem_alloc ( (void **)&pUpCaseTbl,  ulExfatUpCaseClusters * dp.SectorsPerCluster * dp.BytesPerSect);
+        mem_alloc ( (void **)&pUpCaseTbl,  ulExfatUpCaseClusters * params->sectors_per_cluster * dp.BytesPerSect);
 
         if ( !pRootDir )
@@ -797 +818 @@
         pFirstSectOfFat[2] = 0x0fffffff;  // end of cluster chain for root dir
     }
-#ifdef EXFAT
-    else if (params->bFatType == FAT_TYPE_EXFAT)
-    {
-        pFirstSectOfFat[0] = 0xfffffff8;  // Reserved cluster 1 media id in low byte
-        pFirstSectOfFat[1] = 0xffffffff;  // Reserved cluster 2 EOC
-
-        for (i = 0; i < ulExfatBitmapClusters - 1; i++)
-        {
-            // next cluster for alloc bitmap
-            pFirstSectOfFat[2 + i] = 3 + i;
-        }
-        // end of cluster chain for alloc bitmap
-        pFirstSectOfFat[2 + i++] = 0xffffffff;
-
-        for (i = 0; i < ulExfatUpCaseClusters - 1; i++)
-        {
-            // next cluster for upcase table
-            pFirstSectOfFat[2 + ulExfatBitmapClusters + i] = 3 + ulExfatBitmapClusters + i;
-        }
-        // end of cluster chain for upcase table
-        pFirstSectOfFat[2 + ulExfatBitmapClusters + i++] = 0xffffffff;
-
-        // root dir
-        pFirstSectOfFat[2 + ulExfatBitmapClusters + i++] = 0xffffffff;
-    }
-#endif
 
     // Write boot sector, fats
@@ -842 +837 @@
     // Now we're commited - print some info first
     show_message ( "Size: %g MB %u sectors.\n", 0, 0, 2, (double) ((dp.TotalSectors / (1024*1024)) * dp.BytesPerSect), dp.TotalSectors );
-    show_message ( "%d Bytes Per Sector, Cluster size %d bytes.\n", 0, 0, 2, dp.BytesPerSect, dp.SectorsPerCluster * dp.BytesPerSect );
+    show_message ( "%d Bytes Per Sector, Cluster size %d bytes.\n", 0, 0, 2, dp.BytesPerSect, params->sectors_per_cluster * dp.BytesPerSect );
 
     show_message ( "Volume label is %1.\n", 0, 1375, 1, TYPE_STRING, vol );
@@ -848 +843 @@
     show_message ( "The Volume Serial Number is %1.\n", 0, 1243, 1, TYPE_STRING, szString);
 
-    show_message ( "%d Reserved Sectors, %d Sectors per FAT, %d fats.\n", 0, 0, 3, dp.ReservedSectCount, dp.FatSize, dp.NumFATs );
+    show_message ( "%d Reserved Sectors, %lu Sectors per FAT, %d fats.\n", 0, 0, 3, dp.ReservedSectCount, FatSize, dp.NumFATs );
 
     // Work out the Cluster count
@@ -856 +851 @@
     
     // fix up the FSInfo sector
-    pFAT32FsInfo->dFree_Count = (UserAreaSize/dp.SectorsPerCluster)-1;
+    pFAT32FsInfo->dFree_Count = (UserAreaSize/params->sectors_per_cluster)-1;
     pFAT32FsInfo->dNxt_Free = 3; // clusters 0-1 resered, we used cluster 2 for the root dir
 
-    sprintf(szString, "%lu", (pFAT32FsInfo->dFree_Count / 1024) * (dp.SectorsPerCluster * dp.BytesPerSect));
+    sprintf(szString, "%lu", (pFAT32FsInfo->dFree_Count / 1024) * (params->sectors_per_cluster * dp.BytesPerSect));
     show_message ( "%1 kilobytes are available.\n", 0, 537, 1, TYPE_STRING, szString);
 
@@ -870 +865 @@
 
     // First zero out ReservedSect + FatSize * NumFats + SectorsPerCluster
-    SystemAreaSize = (dp.ReservedSectCount+(dp.NumFATs*dp.FatSize) + dp.SectorsPerCluster);
+    SystemAreaSize = (dp.ReservedSectCount+((DWORD)dp.NumFATs*FatSize) + params->sectors_per_cluster);
 
 #ifdef EXFAT
@@ -935 +930 @@
 #endif
 
-    // Write the first fat sector in the right places
-    for ( i=0; i<dp.NumFATs; i++ )
-    {
-        int SectorStart = dp.ReservedSectCount + (i * dp.FatSize );
-        write_sect ( hDevice, SectorStart, dp.BytesPerSect, pFirstSectOfFat, 1 );
-    }
+#ifdef EXFAT
+    if (params->bFatType < FAT_TYPE_EXFAT)
+    {
+#endif
+       // Write the first fat sector in the right places
+       for ( i = 0; i < dp.NumFATs; i++ )
+       {
+          int SectorStart = dp.ReservedSectCount + (i * FatSize );
+          write_sect ( hDevice, SectorStart, dp.BytesPerSect, pFirstSectOfFat, 1 );
+       }
+#ifdef EXFAT
+    }
+   else
+   {
+      int j;
+
+      for ( j = 0; j < dp.NumFATs; j++ )
+      {
+         int SectorStart = dp.ReservedSectCount + (j * FatSize);
+         int EntriesPerSec = dp.BytesPerSect / 4;
+
+         pFirstSectOfFat[0] = 0xfffffff8;  // Reserved cluster 1 media id in low byte
+         pFirstSectOfFat[1] = 0xffffffff;  // Reserved cluster 2 EOC
+
+         for (i = 2; i < ulExfatBitmapClusters + 2; i++)
+         {
+            if (!(i % EntriesPerSec))
+            {
+               // next sector
+               if (i / EntriesPerSec)
+               {
+                  // write previous sector
+                  write_sect ( hDevice,
+                               SectorStart + (i / EntriesPerSec - 1),
+                               dp.BytesPerSect,
+                               pFirstSectOfFat,
+                               1 );
+               }
+               memset(pFirstSectOfFat, 0, dp.BytesPerSect);
+            }
+
+            if (i == ulExfatBitmapClusters + 1)
+            {
+               // end of cluster chain for alloc bitmap
+               pFirstSectOfFat[i % EntriesPerSec] = 0xffffffff;
+            }
+            else
+               // next cluster for alloc bitmap
+               pFirstSectOfFat[i % EntriesPerSec] = i + 1;
+         }
+
+         for (i = 0; i < ulExfatUpCaseClusters; i++)
+         {
+            int k = 2 + ulExfatBitmapClusters + i;
+
+            if (!(k % EntriesPerSec))
+            {
+               // next sector
+               if (k / EntriesPerSec)
+               {
+                  write_sect ( hDevice,
+                               SectorStart + (k / EntriesPerSec - 1),
+                               dp.BytesPerSect,
+                               pFirstSectOfFat,
+                               1 );
+               }
+               memset(pFirstSectOfFat, 0, dp.BytesPerSect);
+            }
+
+            if (i == ulExfatUpCaseClusters - 1)
+            {
+               // end of cluster chain for alloc bitmap
+               pFirstSectOfFat[k % EntriesPerSec] = 0xffffffff;
+            }
+            else
+               // next cluster for alloc bitmap
+               pFirstSectOfFat[k % EntriesPerSec] = k + 1;
+         }
+
+         // root dir
+         pFirstSectOfFat[(2 + ulExfatBitmapClusters + ulExfatUpCaseClusters) % EntriesPerSec] = 0xffffffff;
+
+         // write last sector
+         write_sect ( hDevice,
+                      SectorStart + ((2 + ulExfatBitmapClusters + ulExfatUpCaseClusters) / EntriesPerSec),
+                      dp.BytesPerSect,
+                      pFirstSectOfFat,
+                      1 );
+      }
+   }
+#endif
 
 #ifdef EXFAT
@@ -950 +1030 @@
 
         // write bitmap
-        memset( pBitmap, 0, ulExfatBitmapClusters * dp.SectorsPerCluster * dp.BytesPerSect );
+        memset( pBitmap, 0, ulExfatBitmapClusters * params->sectors_per_cluster * dp.BytesPerSect );
         // bitmap clusters
         for ( i = 0; i < ulExfatBitmapClusters; i++)
@@ -963 +1043 @@
         // root dir cluster
         SetBmpEntry2(pBitmap, &dp, 2 + ulExfatBitmapClusters + i, 1);
-        write_sect ( hDevice, SectorStart, dp.BytesPerSect, pBitmap, ulExfatBitmapClusters * dp.SectorsPerCluster );
+        write_sect ( hDevice, SectorStart, dp.BytesPerSect, pBitmap, ulExfatBitmapClusters * params->sectors_per_cluster );
 
         // write upcase table
-        memset( pUpCaseTbl, 0, ulExfatUpCaseClusters * dp.SectorsPerCluster * dp.BytesPerSect );
+        memset( pUpCaseTbl, 0, ulExfatUpCaseClusters * params->sectors_per_cluster * dp.BytesPerSect );
         memcpy( pUpCaseTbl, pUpCase, ulExfatUpCaseLen );
-        SectorStart += ulExfatBitmapClusters * dp.SectorsPerCluster;
-        write_sect ( hDevice, SectorStart, dp.BytesPerSect, pUpCaseTbl, ulExfatUpCaseClusters * dp.SectorsPerCluster );
+        SectorStart += ulExfatBitmapClusters * params->sectors_per_cluster;
+        write_sect ( hDevice, SectorStart, dp.BytesPerSect, pUpCaseTbl, ulExfatUpCaseClusters * params->sectors_per_cluster );
 
         // write root dir
-        memset( pRootDir, 0, dp.SectorsPerCluster * dp.BytesPerSect );
+        memset( pRootDir, 0, params->sectors_per_cluster * dp.BytesPerSect );
         // volume label
         pDir->bEntryType = ENTRY_TYPE_VOLUME_LABEL;
@@ -989 +1069 @@
         pDir->u.UpCaseTbl.ulTblCheckSum = GetChkSum2((char *)pUpCase, ulExfatUpCaseLen);
         //
-        SectorStart += ulExfatUpCaseClusters * dp.SectorsPerCluster;
-        write_sect ( hDevice, SectorStart, dp.BytesPerSect, pRootDir, dp.SectorsPerCluster );
+        SectorStart += ulExfatUpCaseClusters * params->sectors_per_cluster;
+        write_sect ( hDevice, SectorStart, dp.BytesPerSect, pRootDir, params->sectors_per_cluster );
     }
 #endif
@@ -1056 +1136 @@
     {
         mem_free ( (void *)pEXFATBootSect, dp.BytesPerSect );
-        mem_free ( (void *)pBitmap,  dp.SectorsPerCluster * dp.BytesPerSect );
-        mem_free ( (void *)pRootDir, dp.SectorsPerCluster * dp.BytesPerSect );
+        mem_free ( (void *)pBitmap,  params->sectors_per_cluster * dp.BytesPerSect );
+        mem_free ( (void *)pRootDir, params->sectors_per_cluster * dp.BytesPerSect );
     }
 #endif
@@ -1247 +1327 @@
         case 'C':
                 p.sectors_per_cluster = atol(val);
-                if (  (p.sectors_per_cluster != 1) &&  // 512 bytes, 0.5k
-                   (p.sectors_per_cluster != 2)    &&  // 1K
-                   (p.sectors_per_cluster != 4)    &&  // 2K
-                   (p.sectors_per_cluster != 8)    &&  // 4K
-                   (p.sectors_per_cluster != 16)   &&  // 8K
-                   (p.sectors_per_cluster != 32)   &&  // 16K
-                   (p.sectors_per_cluster != 64)   &&  // 32K 
-                   (p.sectors_per_cluster != 128)      // 64K ( Microsoft say don't use 64K or bigger);               
-                   )
-                {
-                    show_message ( "Ignoring bad cluster size %d\n", 0, 0, 1, p.sectors_per_cluster );
-                    p.sectors_per_cluster = 0;
-                    usage( argv[0] );
-                }
+                if (p.bFatType < FAT_TYPE_EXFAT)
+                   {
+                   if (  (p.sectors_per_cluster != 1) &&  // 512 bytes, 0.5k
+                      (p.sectors_per_cluster != 2)    &&  // 1K
+                      (p.sectors_per_cluster != 4)    &&  // 2K
+                      (p.sectors_per_cluster != 8)    &&  // 4K
+                      (p.sectors_per_cluster != 16)   &&  // 8K
+                      (p.sectors_per_cluster != 32)   &&  // 16K
+                      (p.sectors_per_cluster != 64)   &&  // 32K 
+                      (p.sectors_per_cluster != 128)      // 64K ( Microsoft say don't use 64K or bigger);
+                      )
+                      {
+                      show_message ( "Ignoring bad cluster size %d\n", 0, 0, 1, p.sectors_per_cluster );
+                      p.sectors_per_cluster = 0;
+                      usage( argv[0] );
+                      }
+                   }
                 continue;
         case 'R':

trunk/src/ufat32/os2.c ¶

@@ -678 +678 @@
 void set_datetime(DIRENTRY *pDir)
 {
+   // FAT12/FAT16/FAT32
    DATETIME datetime;
 
@@ -692 +693 @@
    pDir->wCreateTime = pDir->wLastWriteTime;
    pDir->wAccessDate = pDir->wLastWriteDate;
+}
+
+void set_datetime1(DIRENTRY1 *pDir)
+{
+   // exFAT
+   DATETIME datetime;
+
+   DosGetDateTime(&datetime);
+
+   pDir->u.File.ulLastModifiedTimestp.year = datetime.year - 1980;
+   pDir->u.File.ulLastModifiedTimestp.month = datetime.month;
+   pDir->u.File.ulLastModifiedTimestp.day = datetime.day;
+   pDir->u.File.ulLastModifiedTimestp.hour = datetime.hours;
+   pDir->u.File.ulLastModifiedTimestp.minutes = datetime.minutes;
+   pDir->u.File.ulLastModifiedTimestp.seconds = datetime.seconds;
+
+   pDir->u.File.ulCreateTimestp = pDir->u.File.ulLastModifiedTimestp;
+   pDir->u.File.ulLastAccessedTimestp = pDir->u.File.ulLastModifiedTimestp;
 }
 

trunk/src/ufat32/win32.c ¶

@@ -378 +378 @@
 void set_datetime(DIRENTRY *pDir)
 {
+    // FAT12/FAT16/FAT32
     SYSTEMTIME datetime;
 
@@ -394 +395 @@
 }
 
+
+void set_datetime1(DIRENTRY1 *pDir)
+{
+   // exFAT
+   SYSTEMTIME datetime;
+
+   GetSystemTime(&datetime);
+
+   pDir->u.File.ulLastModifiedTimestp.year = datetime.wYear - 1980;
+   pDir->u.File.ulLastModifiedTimestp.month = datetime.wMonth;
+   pDir->u.File.ulLastModifiedTimestp.day = datetime.wDay;
+   pDir->u.File.ulLastModifiedTimestp.hour = datetime.wHour;
+   pDir->u.File.ulLastModifiedTimestp.minutes = datetime.wMinute;
+   pDir->u.File.ulLastModifiedTimestp.seconds = datetime.wSecond / 2;
+
+   pDir->u.File.ulCreateTimestp = pDir->u.File.ulLastModifiedTimestp;
+   pDir->u.File.ulLastAccessedTimestp = pDir->u.File.ulLastModifiedTimestp;
+}
 
 char *get_error(USHORT rc)