Changeset 230


Ignore:
Timestamp:
Apr 7, 2017, 12:24:54 AM (8 years ago)
Author:
Valery V. Sedletski
Message:

Non-512 byte sector compatibility fixes. Now it works with CD's with FAT filesystem too.

Location:
trunk/src
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • TabularUnified trunk/src/ifs/fat32.c

    r229 r230  
    842842         if(!pOpenInfo->fLargeVolume)
    843843            {
    844             pArgDat->sf.psffsi->sfi_size /= SECTOR_SIZE;
     844            struct vpfsi far * pvpfsi;
     845            struct vpfsd far * pvpfsd;
     846
     847            FSH_GETVOLPARM(pArgDat->sf.psffsi->sfi_hVPB, &pvpfsi, &pvpfsd);
     848            pArgDat->sf.psffsi->sfi_size /= pvpfsi->vpi_bsize;
    845849
    846850            if (f32Parms.fLargeFiles)
    847                pArgDat->sf.psffsi->sfi_sizel /= SECTOR_SIZE;
     851               pArgDat->sf.psffsi->sfi_sizel /= pvpfsi->vpi_bsize;
    848852            }
    849853
    … …  
    20632067                  pVolInfo->usRASectors = MAX_RASECTORS;
    20642068#else
    2065                if (pVolInfo->usRASectors > (pVolInfo->ulBlockSize / 512 ) * 4)
    2066                   pVolInfo->usRASectors = (pVolInfo->ulBlockSize / 512 ) * 4;
     2069               if (pVolInfo->usRASectors > (pVolInfo->ulBlockSize / pVolInfo->BootSect.bpb.BytesPerSector ) * 4)
     2070                  pVolInfo->usRASectors = (pVolInfo->ulBlockSize / pVolInfo->BootSect.bpb.BytesPerSector ) * 4;
    20672071#endif
    20682072               *(PUSHORT)pParm = pVolInfo->usRASectors;
    … …  
    22302234                  }
    22312235               pRSD = (PREADSECTORDATA)pParm;
    2232                if ((USHORT)cbData < pRSD->nSectors * SECTOR_SIZE)
     2236               if ((USHORT)cbData < pRSD->nSectors * pVolInfo->BootSect.bpb.BytesPerSector)
    22332237                  {
    22342238                  rc = ERROR_BUFFER_OVERFLOW;
    … …  
    22642268                  }
    22652269               pWSD = (PWRITESECTORDATA)pParm;
    2266                if ((USHORT)cbData < pWSD->nSectors * SECTOR_SIZE)
     2270               if ((USHORT)cbData < pWSD->nSectors * pVolInfo->BootSect.bpb.BytesPerSector)
    22672271                  {
    22682272                  rc = ERROR_INSUFFICIENT_BUFFER;
    … …  
    30813085{
    30823086ULONG ulSector;
    3083 ULONG ulSectorsPerBlock = pVolInfo->ulBlockSize / SECTOR_SIZE;
     3087ULONG ulSectorsPerBlock = pVolInfo->ulBlockSize / pVolInfo->BootSect.bpb.BytesPerSector;
    30843088USHORT rc;
    30853089
    … …  
    31173121{
    31183122ULONG ulSector;
    3119 ULONG ulSectorsPerBlock = pVolInfo->ulBlockSize / SECTOR_SIZE;
     3123ULONG ulSectorsPerBlock = pVolInfo->ulBlockSize / pVolInfo->BootSect.bpb.BytesPerSector;
    31203124USHORT rc;
    31213125
    … …  
    32353239static ULONG GetFatEntrySec(PVOLINFO pVolInfo, ULONG ulCluster)
    32363240{
    3237    return GetFatEntryBlock(pVolInfo, ulCluster, 512 * 3); // in three sector blocks
     3241   return GetFatEntryBlock(pVolInfo, ulCluster, pVolInfo->BootSect.bpb.BytesPerSector * 3); // in three sector blocks
    32383242}
    32393243
    … …  
    32703274static ULONG GetFatEntry(PVOLINFO pVolInfo, ULONG ulCluster)
    32713275{
    3272    return GetFatEntryEx(pVolInfo, pVolInfo->pbFatSector, ulCluster, 512 * 3);
     3276   return GetFatEntryEx(pVolInfo, pVolInfo->pbFatSector, ulCluster, pVolInfo->BootSect.bpb.BytesPerSector * 3);
    32733277}
    32743278
    … …  
    33353339static void SetFatEntry(PVOLINFO pVolInfo, ULONG ulCluster, ULONG ulValue)
    33363340{
    3337    SetFatEntryEx(pVolInfo, pVolInfo->pbFatSector, ulCluster, ulValue, 512 * 3);
     3341   SetFatEntryEx(pVolInfo, pVolInfo->pbFatSector, ulCluster, ulValue, pVolInfo->BootSect.bpb.BytesPerSector * 3);
    33383342}
    33393343
    … …  
    34823486   ReleaseFat(pVolInfo);
    34833487   return ulTotalFree;
    3484 
    34853488}
    34863489/******************************************************************
    … …  
    37413744BOOL UpdateFSInfo(PVOLINFO pVolInfo)
    37423745{
    3743 static BYTE bSector[SECTOR_SIZE] = "";
     3746PBYTE bSector;
    37443747
    37453748   if (f32Parms.fMessageActive & LOG_FUNCS)
    … …  
    37593762      return TRUE;
    37603763
     3764   bSector = malloc(pVolInfo->BootSect.bpb.BytesPerSector);
     3765
    37613766   if (!ReadSector(pVolInfo, pVolInfo->BootSect.bpb.FSinfoSec, 1, bSector, DVIO_OPNCACHE))
    37623767      {
    37633768      memcpy(bSector + FSINFO_OFFSET, pVolInfo->pBootFSInfo, sizeof (BOOTFSINFO));
    37643769      if (!WriteSector(pVolInfo, pVolInfo->BootSect.bpb.FSinfoSec, 1, bSector, DVIO_OPNCACHE | DVIO_OPWRTHRU))
     3770         {
     3771         free(bSector);
    37653772         return TRUE;
     3773         }
    37663774      }
    37673775   CritMessage("UpdateFSInfo for %c: failed!", pVolInfo->bDrive + 'A');
    37683776   Message("ERROR: UpdateFSInfo for %c: failed!", pVolInfo->bDrive + 'A');
    37693777
     3778   free(bSector);
    37703779   return FALSE;
    37713780}
    … …  
    37893798   if (pVolInfo->ulCurFatSector != 0)
    37903799      {
    3791       if (ReadFatSector(pVolInfo, 0)) //// floppy
     3800      if (ReadFatSector(pVolInfo, 0))
    37923801         return FALSE;
    37933802      pVolInfo->ulCurFatSector = 0;
    … …  
    40004009
    40014010   // prevent blocking in FSH_SETVOLUME when remounting after format
    4002    if (! pVolInfo->fFormatInProgress)
     4011   /* if (! pVolInfo->fFormatInProgress && ! pVolInfo->fRemovable)
    40034012      {
    40044013      // check if volume is present
    4005       rc = FSH_SETVOLUME(hVBP, 0); //// hang on diskette insert
     4014      Message("FSH_SETVOLUME");
     4015      rc = FSH_SETVOLUME(hVBP, 0);
    40064016
    40074017      if (rc == ERROR_VOLUME_CHANGED)
    40084018         return NULL;
    4009       }
     4019      } */
    40104020
    40114021   rc = MY_PROBEBUF(PB_OPWRITE, (PBYTE)pVolInfo, sizeof (VOLINFO));

  • TabularUnified trunk/src/ifs/helpers.asm

    r216 r230  
    11.386p
    22
    3 SAS_SEL equ 70h
     3;SAS_SEL equ 70h
    44ERROR_NOT_SUPPORTED        equ 50
    55ERROR_INVALID_PARAMETER    equ 87
    … …  
    106106_TEXT segment word public 'CODE' use16
    107107
    108 public _SaSSel
    109 
    110 SaSSel PROC
    111     mov ax,SAS_SEL
    112     ret
    113 SaSSel ENDP
     108;public _SaSSel
     109
     110;SaSSel PROC
     111;    mov ax,SAS_SEL
     112;    ret
     113;SaSSel ENDP
    114114
    115115_TEXT ends

  • TabularUnified trunk/src/ifs/ifscache.c

    r213 r230  
    4848PRIVATE USHORT WriteCacheSector(PVOLINFO pVolInfo, USHORT usCBIndex, BOOL fSetTime);
    4949PRIVATE VOID   UpdateChain(USHORT usCBIndex);
    50 PRIVATE VOID   vGetSectorFromCache(USHORT usCBIndex, PBYTE pbSector);
    51 PRIVATE VOID   vReplaceSectorInCache(USHORT usCBIndex, PBYTE pbSector, BOOL fDirty);
     50PRIVATE VOID   vGetSectorFromCache(PVOLINFO pVolInfo, USHORT usCBIndex, PBYTE pbSector);
     51PRIVATE VOID   vReplaceSectorInCache(PVOLINFO pVolInfo, USHORT usCBIndex, PBYTE pbSector, BOOL fDirty);
    5252PRIVATE VOID   LockBuffer(PCACHEBASE pBase);
    5353PRIVATE VOID   UnlockBuffer(PCACHEBASE pBase);
    … …  
    225225   */
    226226   fFromCache = TRUE;
    227    for (usIndex = 0,p=pbData; usIndex < nSectors; usIndex++,p += (ULONG)SECTOR_SIZE)
     227   for (usIndex = 0,p=pbData; usIndex < nSectors; usIndex++,p += (ULONG)pVolInfo->BootSect.bpb.BytesPerSector)
    228228      {
    229229      if (!IsSectorInCache(pVolInfo, ulSector + usIndex, p))
    … …  
    254254      if (ulSector + usSectors > pVolInfo->BootSect.bpb.BigTotalSectors)
    255255         usSectors = (USHORT)(pVolInfo->BootSect.bpb.BigTotalSectors - ulSector);
    256       pbSectors = malloc(usSectors * 512);
     256      pbSectors = malloc(usSectors * pVolInfo->BootSect.bpb.BytesPerSector);
    257257      }
    258258   if (!pbSectors)
    … …  
    300300    if (!rc)
    301301       {
    302        for (usIndex = 0,p=pbSectors; usIndex < usSectors; usIndex++,p+= (ULONG)SECTOR_SIZE)
     302       for (usIndex = 0,p=pbSectors; usIndex < usSectors; usIndex++,p+= (ULONG)pVolInfo->BootSect.bpb.BytesPerSector)
    303303          {
    304304          /*
    … …  
    325325                if (rgfDirty[usCBIndex])
    326326                   {
    327                    vGetSectorFromCache(usCBIndex, p);
     327                   vGetSectorFromCache(pVolInfo, usCBIndex, p);
    328328                   }
    329329                   rc2 = FSH_SEMCLEAR(&ulLockSem[usCBIndex]); /* when fFindSector returns with true it has the semaphore requested */
    … …  
    336336       {
    337337       f32Parms.ulTotalRA += usSectors > nSectors ? (usSectors - nSectors) : 0;
    338        memcpy(pbData, pbSectors, min( usSectors, nSectors ) * 512);
     338       memcpy(pbData, pbSectors, min( usSectors, nSectors ) * pVolInfo->BootSect.bpb.BytesPerSector);
    339339       }
    340340
    … …  
    387387   if (!rc)
    388388      {
    389       for (usIndex = 0,p= pbData; usIndex < usSectors; usIndex++,p+= (ULONG)SECTOR_SIZE)
     389      for (usIndex = 0,p= pbData; usIndex < usSectors; usIndex++,p+= (ULONG)pVolInfo->BootSect.bpb.BytesPerSector)
    390390         {
    391391         fSectorInCache =
    … …  
    406406
    407407                  pCache = GetAddress(usCBIndex);
    408                   fIdent = memcmp(p, pCache->bSector, SECTOR_SIZE) == 0;
     408                  fIdent = memcmp(p, pCache->bSector, pVolInfo->BootSect.bpb.BytesPerSector) == 0;
    409409                  }
    410410
    411411               if( !fIdent )
    412                   vReplaceSectorInCache(usCBIndex, p, fDirty);
     412                  vReplaceSectorInCache(pVolInfo, usCBIndex, p, fDirty);
    413413
    414414               rc2 = FSH_SEMCLEAR(&ulLockSem[usCBIndex]); /* when fFindSector returns with true it has the semaphore requested */
    … …  
    435435      return FALSE;
    436436   f32Parms.ulTotalHits++;
    437    vGetSectorFromCache(usIndex, pbSector);
     437   vGetSectorFromCache(pVolInfo, usIndex, pbSector);
    438438
    439439   rc2 = FSH_SEMCLEAR(&ulLockSem[usIndex]); /* when fFindSector returns with true it has the semaphore requested */
    … …  
    445445*
    446446******************************************************************/
    447 VOID vGetSectorFromCache(USHORT usCBIndex, PBYTE pbSector)
     447VOID vGetSectorFromCache(PVOLINFO pVolInfo, USHORT usCBIndex, PBYTE pbSector)
    448448{
    449449PCACHEBASE pBase;
    … …  
    453453
    454454   pCache = GetAddress(usCBIndex);
    455    memcpy(pbSector, pCache->bSector, 512);
     455   memcpy(pbSector, pCache->bSector, pVolInfo->BootSect.bpb.BytesPerSector);
    456456
    457457   pBase->ulAccessTime = GetCurTime();
    … …  
    537537      pBase->bDrive = pVolInfo->bDrive;
    538538
    539       vReplaceSectorInCache(usCBIndex, pbSector, fDirty);
     539      vReplaceSectorInCache(pVolInfo, usCBIndex, pbSector, fDirty);
    540540
    541541      rc2 = FSH_SEMCLEAR(&ulLockSem[usCBIndex]);
    … …  
    625625                    pBase->bDrive = pVolInfo->bDrive;
    626626
    627                     vReplaceSectorInCache(usCBIndex, pbSector, fDirty);
     627                    vReplaceSectorInCache(pVolInfo, usCBIndex, pbSector, fDirty);
    628628
    629629                    leaveFlag = TRUE;
    … …  
    647647*
    648648******************************************************************/
    649 VOID vReplaceSectorInCache(USHORT usCBIndex, PBYTE pbSector, BOOL fDirty)
     649VOID vReplaceSectorInCache(PVOLINFO pVolInfo, USHORT usCBIndex, PBYTE pbSector, BOOL fDirty)
    650650{
    651651PCACHEBASE pBase;
    … …  
    666666      rgfDirty[usCBIndex] = fDirty;
    667667      pCache = GetAddress(usCBIndex);
    668       memcpy(pCache->bSector, pbSector, SECTOR_SIZE);
     668      memcpy(pCache->bSector, pbSector, pVolInfo->BootSect.bpb.BytesPerSector);
    669669      pBase->ulAccessTime = GetCurTime();
    670670      UpdateChain(usCBIndex);
    … …  
    720720   while (usCBIndex != FREE_SLOT)
    721721      {
    722       rc2 = FSH_SEMREQUEST(&ulLockSem[usCBIndex],-1L); //// hang!
     722      rc2 = FSH_SEMREQUEST(&ulLockSem[usCBIndex],-1L);
    723723      pBase = pCacheBase + usCBIndex;
    724724      if (pBase->ulSector == ulSector && pBase->bDrive == bDrive)

  • TabularUnified trunk/src/ifs/ifsfile.c

    r213 r230  
    455455      //size = pVolInfo->BootSect.bpb.BigTotalSectors;
    456456      /* if a less volume than 2GB, do normal IO else sector IO */
    457       size = pVolInfo->BootSect.bpb.BigTotalSectors * SECTOR_SIZE;
     457      size = pVolInfo->BootSect.bpb.BigTotalSectors * pVolInfo->BootSect.bpb.BytesPerSector;
    458458      //if( size < SECTORS_OF_2GB )
    459       //   size *= SECTOR_SIZE;
     459      //   size *= pVolInfo->BootSect.bpb.BytesPerSector;
    460460      //else
    461461      //   pOpenInfo->fLargeVolume = TRUE;

  • TabularUnified trunk/src/ifs/ifsmount.c

    r217 r230  
    248248
    249249         if (usDefaultRASectors == 0xFFFF)
    250             pVolInfo->usRASectors = (pVolInfo->ulBlockSize / SECTOR_SIZE ) * 2;
     250            pVolInfo->usRASectors = (pVolInfo->ulBlockSize / pVolInfo->BootSect.bpb.BytesPerSector ) * 2;
    251251         else
    252252            pVolInfo->usRASectors = usDefaultRASectors;
    … …  
    256256            pVolInfo->usRASectors = MAX_RASECTORS;
    257257#else
    258          if (pVolInfo->usRASectors > (pVolInfo->ulBlockSize / SECTOR_SIZE) * 4)
    259             pVolInfo->usRASectors = (pVolInfo->ulBlockSize / SECTOR_SIZE ) * 4;
     258         if (pVolInfo->usRASectors > (pVolInfo->ulBlockSize / pVolInfo->BootSect.bpb.BytesPerSector) * 4)
     259            pVolInfo->usRASectors = (pVolInfo->ulBlockSize / pVolInfo->BootSect.bpb.BytesPerSector ) * 4;
    260260#endif
    261261
    … …  
    288288            }
    289289
     290         if (! pVolInfo->BootSect.bpb.BigSectorsPerFat)
     291            // if partition is small
     292            pVolInfo->BootSect.bpb.BigSectorsPerFat = pVolInfo->BootSect.bpb.SectorsPerFat;
     293
    290294         pVolInfo->ulTotalClusters =
    291295            (pVolInfo->BootSect.bpb.BigTotalSectors - pVolInfo->ulStartOfData) / pSect->bpb.SectorsPerCluster;
    … …  
    309313            pVolInfo->fWriteProtected = TRUE;
    310314
    311          pVolInfo->fDiskCleanOnMount = pVolInfo->fDiskClean = GetDiskStatus(pVolInfo);
     315         //pVolInfo->fDiskCleanOnMount = pVolInfo->fDiskClean = GetDiskStatus(pVolInfo);
     316
    312317         if (!pVolInfo->fDiskCleanOnMount && f32Parms.fMessageActive & LOG_FS)
    313318            Message("DISK IS DIRTY!");
    … …  
    319324          /*!pVolInfo->fDiskClean ||*/
    320325            pVolInfo->BootSect.bpb.FSinfoSec == 0xFFFF)
    321          GetFreeSpace(pVolInfo);
     326            {
     327            GetFreeSpace(pVolInfo);
     328            }
    322329
    323330         pDevCaps  = pvpfsi->vpi_pDCS;
    … …  
    329336            pDevCaps = ReturnDriverCaps(pvpfsi->vpi_unit);
    330337            }
     338
     339         if ( pVolChars && (pVolChars->VolDescriptor & VC_REMOVABLE_MEDIA) )
     340            pVolInfo->fRemovable = TRUE;
     341
     342         if (! pVolInfo->fRemovable)
     343            pVolInfo->fDiskCleanOnMount = pVolInfo->fDiskClean = GetDiskStatus(pVolInfo);
     344         else
     345            // ignore disk status on floppies
     346            pVolInfo->fDiskCleanOnMount = pVolInfo->fDiskClean = TRUE;
    331347
    332348         if (f32Parms.fMessageActive & LOG_FS)
    … …  
    367383            hDupVBP = 0;
    368384
    369          if (pvpfsi->vpi_bsize != SECTOR_SIZE)
    370             {
    371             rc = ERROR_VOLUME_NOT_MOUNTED;
    372             goto FS_MOUNT_EXIT;
    373             }
     385         //if (pvpfsi->vpi_bsize != SECTOR_SIZE)
     386         //   {
     387         //   rc = ERROR_VOLUME_NOT_MOUNTED;
     388         //   goto FS_MOUNT_EXIT;
     389         //   }
    374390     
    375391         pVolInfo = gdtAlloc(STORAGE_NEEDED, FALSE);
    … …  
    493509         usFlushVolume( pVolInfo, FLUSH_DISCARD, TRUE, PRIO_URGENT );
    494510         UpdateFSInfo(pVolInfo);
    495          MarkDiskStatus(pVolInfo, pVolInfo->fDiskCleanOnMount);
     511
     512         if (! pVolInfo->fRemovable)
     513            {
     514            // ignore dirty status on floppies
     515            MarkDiskStatus(pVolInfo, pVolInfo->fDiskCleanOnMount);
     516            }
    496517
    497518         // delete pVolInfo from the list
    … …  
    594615      }
    595616
    596    if (pbpb->BytesPerSector != SECTOR_SIZE)
    597       {
    598       return FAT_TYPE_NONE;
    599       }
     617   //if (pbpb->BytesPerSector != SECTOR_SIZE)
     618   //   {
     619   //   return FAT_TYPE_NONE;
     620   //   }
    600621
    601622   if (! pbpb->SectorsPerCluster)
    … …  
    672693
    673694#pragma optimize("eglt",off)
     695
     696#define SAS_SEL 0x70
    674697
    675698P_DriverCaps ReturnDriverCaps(UCHAR ucUnit)
    … …  
    684707   struct SysDev far *pDD;
    685708
    686    SAS_selector    = SaSSel();
     709   SAS_selector    = SAS_SEL;
    687710   pSas            = (struct SAS far *)MAKEP(SAS_selector,0);
    688711   pDDSection      = (struct SAS_dd_section far *)MAKEP(SAS_selector,pSas->SAS_dd_data);

  • TabularUnified trunk/src/include/fat32.h

    r229 r230  
    2121PTRACKLAYOUT pTrack;
    2222ULONG  ulStartOfFAT;
    23 PBYTE  pbFATSector[SECTOR_SIZE * 3];
     23PBYTE  pbFATSector[SECTOR_SIZE * 8 * 3];
    2424ULONG  ulCurFATSector;
    2525PBYTE  pbCluster;

  • TabularUnified trunk/src/include/fat32ifs.h

    r229 r230  
    106106typedef struct _Cache
    107107{
    108 BYTE  bSector[SECTOR_SIZE];
     108BYTE  bSector[SECTOR_SIZE * 8];
    109109} CACHE, *PCACHE;
    110110
    … …  
    168168STRATFUNC pfnPriority;
    169169BOOL      fFormatInProgress;
     170BOOL      fRemovable;
    170171UCHAR     bFatType;
    171172ULONG     ulFatEof;
    … …  
    411412
    412413
    413 #define STORAGE_NEEDED (sizeof (VOLINFO) + sizeof (BOOTFSINFO) + SECTOR_SIZE * 3 + 10000)
     414#define STORAGE_NEEDED (sizeof (VOLINFO) + sizeof (BOOTFSINFO) + SECTOR_SIZE * 8 * 3 + 10000)
    414415
    415416

  • TabularUnified trunk/src/ufat32/chkdsk.c

    r229 r230  
    136136ULONG rc = 0;
    137137PCDINFO pCD;
    138 BYTE   bSector[512];
     138BYTE   bSector[SECTOR_SIZE * 8];
    139139struct extbpb dp;
    140140
    … …  
    705705         }
    706706
    707       nSectors = BLOCK_SIZE / 512;
     707      nSectors = BLOCK_SIZE / pCD->BootSect.bpb.BytesPerSector;
    708708      if ((ULONG)nSectors > pCD->BootSect.bpb.BigSectorsPerFat - ulSector)
    709709         nSectors = (USHORT)(pCD->BootSect.bpb.BigSectorsPerFat - ulSector);
    … …  
    19301930      }
    19311931
    1932    if (pbpb->BytesPerSector != SECTOR_SIZE)
    1933       {
    1934       return FAT_TYPE_NONE;
    1935       }
     1932   //if (pbpb->BytesPerSector != SECTOR_SIZE)
     1933   //   {
     1934   //   return FAT_TYPE_NONE;
     1935   //   }
    19361936
    19371937   if (! pbpb->SectorsPerCluster)
    … …  
    20012001ULONG GetFatEntrySec(PCDINFO pCD, ULONG ulCluster)
    20022002{
    2003    return GetFatEntryBlock(pCD, ulCluster, 512 * 3); // in three sector blocks
     2003   return GetFatEntryBlock(pCD, ulCluster, pCD->BootSect.bpb.BytesPerSector * 3); // in three sector blocks
    20042004}
    20052005
    … …  
    20362036ULONG GetFatEntriesPerSec(PCDINFO pCD)
    20372037{
    2038    return GetFatEntriesPerBlock(pCD, 512 * 3);
     2038   return GetFatEntriesPerBlock(pCD, pCD->BootSect.bpb.BytesPerSector * 3);
    20392039}
    20402040
    … …  
    20912091ULONG GetFatEntry(PCDINFO pCD, ULONG ulCluster)
    20922092{
    2093    return GetFatEntryEx(pCD, pCD->pbFATSector, ulCluster, 512 * 3);
     2093   return GetFatEntryEx(pCD, pCD->pbFATSector, ulCluster, pCD->BootSect.bpb.BytesPerSector * 3);
    20942094}
    20952095
    … …  
    21572157void SetFatEntry(PCDINFO pCD, ULONG ulCluster, ULONG ulValue)
    21582158{
    2159    SetFatEntryEx(pCD, pCD->pbFATSector, ulCluster, ulValue, 512 * 3);
     2159   SetFatEntryEx(pCD, pCD->pbFATSector, ulCluster, ulValue, pCD->BootSect.bpb.BytesPerSector * 3);
    21602160}
    21612161

  • TabularUnified trunk/src/ufat32/recover.c

    r213 r230  
    2525   HANDLE  hFile;
    2626   ULONG  ulAction;
    27    BYTE   bSector[512];
     27   BYTE   bSector[SECTOR_SIZE * 8];
    2828   char   szTarget[0x8000];
    2929   ULONG  ulBytes;
Note: See TracChangeset for help on using the changeset viewer.