fatfs.h

FAT文件系统源代码

/*  DISK.C functions
 */

DWORD   GetDiskInfo(HANDLE hdsk, PDISK_INFO pdi);
DWORD   SetDiskInfo(HANDLE hdsk, PDISK_INFO pdi);
DWORD   ReadWriteDisk(PVOLUME pvol, HANDLE hdsk, DWORD cmd, PDISK_INFO pdi, DWORD sector, int cSectors, PVOID pvBuffer, BOOL fRemapFats);
void    SetupDiskCache(PVOLUME pvol);
DWORD UncachedReadWriteDisk (HDSK hdsk, DWORD cmd, PDISK_INFO pdi, DWORD sector, int cSectors, PVOID pvBuffer);
PDSK    MountDisk(HANDLE hdsk, PCWSTR pwsDisk, DWORD flVol);
BOOL FreeClustersOnDisk (PVOLUME pvol, DWORD dwStartCluster, DWORD dwNumClusters);
BOOL    UnmountDisk(PDSK pdsk, BOOL fFrozen);
DWORD   UnmountAllDisks(BOOL fFrozen);

__inline void FlushDiskCache(PVOLUME pvol)
{
    // Use FATFS_TFAT_NONATOMIC_SECTOR flag to detect if HDD. FATFS_TFAT_NONATOMIC_SECTOR is only used for HDD
    // so it is simple way to detect HDD here.
 
    if (FATFS_TFAT_NONATOMIC_SECTOR & pvol->v_flFATFS) { 
        // Call flush cache on the disk
        FSDMGR_DiskIoControl((HDSK)pvol->v_pdsk->d_hdsk,
            IOCTL_DISK_FLUSH_CACHE, NULL, 0, NULL, 0, NULL, NULL);
    }
}


// Commands for ReadWriteDisk
#define READ_DISK_CMD   0x1     // Do a regular read
#define WRITE_DISK_CMD  0x2    // Do a regular write
#define WRITETHROUGH_DISK_CMD  0x3  // Force write-through if the cache is write-back.

/*  FAT.C functions
 */

void    LockFAT(PVOLUME pvol);
DWORD   GetFAT(PVOLUME pvol, DWORD dwOffset, PVOID *ppvEntry, PVOID *ppvEntryEnd);
void    UnlockFAT(PVOLUME pvol);
DWORD   Unpack12(PVOLUME pvol, DWORD clusIndex, PDWORD pclusData);
DWORD   Pack12(PVOLUME pvol, DWORD clusIndex, DWORD clusData, PDWORD pclusOld);
DWORD   Unpack16(PVOLUME pvol, DWORD clusIndex, PDWORD pclusData);
DWORD   Pack16(PVOLUME pvol, DWORD clusIndex, DWORD clusData, PDWORD pclusOld);
DWORD   Unpack32(PVOLUME pvol, DWORD clusIndex, PDWORD pclusData);
DWORD   Pack32(PVOLUME pvol, DWORD clusIndex, DWORD clusData, PDWORD pclusOld);
DWORD   UnpackRun(PDSTREAM pstm);
DWORD   NewCluster(PVOLUME pvol, DWORD clusPrev, PDWORD pclusNew);
VOID    IncrementFreeClusterCount (PVOLUME pvol, DWORD clusIndex);
VOID    DecrementFreeClusterCount (PVOLUME pvol, DWORD clusIndex);


/*  FILE.C functions
 */

HANDLE  FAT_CreateFileW(PVOLUME pvol, HANDLE hProc, LPCWSTR lpFileName, DWORD dwAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreate, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile);
BOOL    FAT_CloseFile(PFHANDLE pfh);
#if NUM_FILE_APIS == 13
BOOL    FAT_ReadFilePagein(PFHANDLE pfh, LPVOID buffer, DWORD nBytesToRead, LPDWORD lpNumBytesRead, LPOVERLAPPED lpOverlapped);
#else
BOOL    FAT_ReadFileWithSeek(PFHANDLE pfh, LPVOID buffer, DWORD nBytesToRead, LPDWORD lpNumBytesRead, LPOVERLAPPED lpOverlapped, DWORD dwLowOffset, DWORD dwHighOffset);
BOOL    FAT_WriteFileWithSeek(PFHANDLE pfh, LPCVOID buffer, DWORD nBytesToWrite, LPDWORD lpNumBytesWritten, LPOVERLAPPED lpOverlapped, DWORD dwLowOffset, DWORD dwHighOffset);
#endif
BOOL    FAT_ReadFile(PFHANDLE pfh, LPVOID buffer, DWORD nBytesToRead, LPDWORD lpNumBytesRead, LPOVERLAPPED lpOverlapped);
BOOL    FAT_WriteFile(PFHANDLE pfh, LPCVOID buffer, DWORD nBytesToWrite, LPDWORD lpNumBytesWritten, LPOVERLAPPED lpOverlapped);
DWORD   FAT_SetFilePointer(PFHANDLE pfh, LONG lDistanceToMove, PLONG lpDistanceToMoveHigh, DWORD dwMoveMethod);
DWORD   FAT_GetFileSize(PFHANDLE pfh, LPDWORD lpFileSizeHigh);
BOOL    FAT_GetFileInformationByHandle(PFHANDLE pfh, LPBY_HANDLE_FILE_INFORMATION lpFileInfo);
BOOL    FAT_FlushFileBuffers(PFHANDLE pfh);
BOOL    FAT_GetFileTime(PFHANDLE pfh, LPFILETIME lpCreation, LPFILETIME lpLastAccess, LPFILETIME lpLastWrite);
BOOL    FAT_SetFileTime(PFHANDLE pfh, CONST FILETIME *lpCreation, CONST FILETIME *lpLastAccess, CONST FILETIME *lpLastWrite);
BOOL    FAT_SetEndOfFile(PFHANDLE pfh);
BOOL    FAT_DeviceIoControl(PFHANDLE pfh, DWORD dwIoControlCode, LPVOID lpInBuf, DWORD nInBufSize, LPVOID lpOutBuf, DWORD nOutBufSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped);
#ifdef UNDER_CE
DWORD   CopyFileExternal (PDSTREAM pstm, PFILE_COPY_EXTERNAL pInCopyReq,LPVOID lpOutBuf, DWORD numBufOut);
#endif

/*  FILE.C Lock Manager Support functions
 */

BOOL    AcquireFileLockState(DWORD dwPfh, PFILELOCKSTATE *ppFileLockState);
BOOL    ReleaseFileLockState(DWORD dwPfh, PFILELOCKSTATE *ppFileLockState);


/*  FIND.C functions
 */

HANDLE  FAT_FindFirstFileW(PVOLUME pvol, HANDLE hProc, PCWSTR pwsFileSpec, PWIN32_FIND_DATAW pfd);
BOOL    FAT_FindNextFileW(PSHANDLE psh, PWIN32_FIND_DATAW pfd);
BOOL    FAT_FindClose(PSHANDLE psh);

PDSTREAM OpenRoot(PVOLUME pvol);
DWORD    CloseRoot(PVOLUME pvol);
PDSTREAM OpenPath(PVOLUME pvol, PCWSTR pwsPath, PCWSTR *ppwsTail, int *plen, int flName, DWORD clusFail);
PDSTREAM OpenName(PDSTREAM pstmDir, PCWSTR pwsName, int cwName, int *pflName);
DWORD    CreateName(PDSTREAM pstmDir, PCWSTR pwsName, PDIRINFO pdi, PDIRENTRY pdeClone, int flName);
DWORD    DestroyName(PDSTREAM pstmDir, PDIRINFO pdi);
PDSTREAM FindFirst(PVOLUME pvol, PCWSTR pwspath, PSHANDLE psh, PDIRINFO pdi, PWIN32_FIND_DATAW pfd, int flName, DWORD clusFail);
DWORD    FindNext(PSHANDLE psh, PDIRINFO pdi, PWIN32_FIND_DATAW pfd);
void     CreateDirEntry(PDSTREAM pstmDir, PDIRENTRY pde, PDIRENTRY pdeClone, BYTE bAttr, DWORD clusFirst);


/*  FORMAT.C
 */
DWORD   FormatVolume(PVOLUME pvol, PFMTVOLREQ pfv);


/*  MISC.C functions
 */

int     Log2(unsigned int n);
void    InitList(PDLINK pdl);
int     ListIsEmpty(PDLINK pdl);
void    AddItem(PDLINK pdlIns, PDLINK pdlNew);
void    RemoveItem(PDLINK pdl);
int     pchtoi(PCHAR pch, int cchMax);
int     itopch(int i, PCHAR pch);

//  Bit arrays start with two special DWORDs that are not part of
//  of the actual array of bits.  The first DWORD is initialized to
//  the number of bits that can be held, and the second DWORD keeps track
//  of the total number of SET bits.

#define ALLOCA(p,cb) {                                          \
                p = NULL;                                       \
                if (cb <= 32*1024) {                            \
                    __try {                                     \
                        p = _alloca(cb);                        \
                    } __except (EXCEPTION_EXECUTE_HANDLER) {    \
                        ;                                       \
                    }                                           \
                }                                               \
}
#define CreateBitArray(pdwBitArray, cbits) {                    \
            DWORD cb = (((cbits)+31)/32 + 2)*sizeof(DWORD);     \
            pdwBitArray = NULL;                                 \
            if (cb > 2*sizeof(DWORD)) {                         \
                ALLOCA(pdwBitArray, cb);                        \
            }                                                   \
            if (pdwBitArray) {                                  \
                memset(pdwBitArray, 0, cb);                     \
                pdwBitArray[0] = (cbits);                       \
            }                                                   \
}
void    SetBitArray(PDWORD pdwBitArray, int i);
void    ClearBitArray(PDWORD pdwBitArray, int i);
BOOL    TestBitArray(PDWORD pdwBitArray, int i);

BOOL    DOSTimeToFileTime(WORD dosDate, WORD dosTime, BYTE tenMSec, PFILETIME pft);
BOOL    FileTimeToDOSTime(PFILETIME pft, PWORD pdosDate, PWORD pdosTime, PBYTE ptenMSec);
void    SetSizePointer(PSIZEPTR psp, DWORD cb, DWORD c, PVOID pSrc, HANDLE hProc);


/*  NAME.C functions
 */

BYTE    ChkSumName(const BYTE *pchOEM);
void    InitNumericTail(PDIRINFO pdi);
void    CheckNumericTail(PDIRINFO pdi, PDWORD pdwBitArray);
void    GenerateNumericTail(PDIRINFO pdi, PDWORD pdwBitArray);
int     OEMToUniName(PWSTR pws, PCHAR pchOEM, UINT nCodePage);
BOOL    UniToOEMName(PVOLUME pvol, PCHAR pchOEM, PCWSTR pwsName, int cwName, UINT nCodePage);
BOOL    IsUsedAsLeadByte (char string[], int index);

/*  PATH.C functions
 */

BOOL    FAT_CreateDirectoryW(PVOLUME pvol, PCWSTR pwsPathName, LPSECURITY_ATTRIBUTES lpSecurityAttributes);
BOOL    FAT_RemoveDirectoryW(PVOLUME pvol, PCWSTR pwsPathName);
DWORD   FAT_GetFileAttributesW(PVOLUME pvol, PCWSTR pwsFileName);
BOOL    FAT_SetFileAttributesW(PVOLUME pvol, PCWSTR pwsFileName, DWORD dwAttributes);
BOOL    FAT_DeleteFileW(PVOLUME pvol, PCWSTR pwsFileName);
BOOL    FAT_MoveFileW(PVOLUME pvol, PCWSTR pwsOldFileName, PCWSTR pwsNewFileName);
BOOL    FAT_RegisterFileSystemNotification(PVOLUME pvol, HWND hwnd);
BOOL    FAT_RegisterFileSystemFunction(PVOLUME pvol, SHELLFILECHANGEFUNC_t pfn);
BOOL    FAT_PrestoChangoFileName(PVOLUME pvol, PCWSTR pwsOldFile, PCWSTR pwsNewFile);
BOOL    FAT_GetDiskFreeSpaceW(PVOLUME pvol, PCWSTR pwsPathName, PDWORD pSectorsPerCluster, PDWORD pBytesPerSector, PDWORD pFreeClusters, PDWORD pClusters);
DWORD   GetSIDInfo(PVOLUME pvol, PDSID psid, CEOIDINFO *poi);
BOOL    CalculateFreeClustersInRAM(PVOLUME pvol);
DWORD   CalculateFreeClustersFromBuffers(PVOLUME pvol);

#ifdef SHELL_MESSAGE_NOTIFICATION
#ifndef DEBUG
#define POSTFILESYSTEMMESSAGE(pvol, uMsg, psid, psidParent, pwsCaller) \
        PostFileSystemMessage(pvol, uMsg, psid, psidParent)
void    PostFileSystemMessage(PVOLUME pvol, UINT uMsg, PDSID psid, PDSID psidParent);
#else
#define POSTFILESYSTEMMESSAGE(pvol, uMsg, psid, psidParent, pwsCaller) \
        PostFileSystemMessage(pvol, uMsg, psid, psidParent, pwsCaller)
void    PostFileSystemMessage(PVOLUME pvol, UINT uMsg, PDSID psid, PDSID psidParent, PWSTR pwsCaller);
#endif  // DEBUG
#else
#define POSTFILESYSTEMMESSAGE(pvol, uMsg, psid, psidParent, pwsCaller)
#endif  // SHELL_MESSAGE_NOTIFICATION

#ifdef SHELL_CALLBACK_NOTIFICATION
#ifndef DEBUG
#define CALLFILESYSTEMFUNCTION(pvol, dwSHCNE, psid, psidOld, poiOld, pwsCaller) \
        CallFileSystemFunction(pvol, dwSHCNE, psid, psidOld, poiOld)
void    CallFileSystemFunction(PVOLUME pvol, DWORD dwSHCNE, PDSID psid, PDSID psidOld, CEOIDINFO *poiOld);
#else
#define CALLFILESYSTEMFUNCTION(pvol, dwSHCNE, psid, psidOld, poiOld, pwsCaller) \
        CallFileSystemFunction(pvol, dwSHCNE, psid, psidOld, poiOld, pwsCaller)
void    CallFileSystemFunction(PVOLUME pvol, DWORD dwSHCNE, PDSID psid, PDSID psidOld, CEOIDINFO *poiOld, PWSTR pwsCaller);
#endif  // DEBUG
#else
#define CALLFILESYSTEMFUNCTION(pvol, dwSHCNE, psid, psidOld, poiOld, pwsCaller)
#endif  // SHELL_CALLBACK_NOTIFICATION

#define FILESYSTEMNOTIFICATION(pvol, uMsg, uMsgOld, dwSHCNE, psid, psidParent, psidOld, psidParentOld, poiOld, pwsCaller) \
{ \
        if (uMsgOld) { \
            POSTFILESYSTEMMESSAGE(pvol, uMsgOld, psidOld, psidParentOld, pwsCaller); \
        } \
        if (uMsg) { \
            POSTFILESYSTEMMESSAGE(pvol, uMsg, psid, psidParent, pwsCaller); \
        } \
        CALLFILESYSTEMFUNCTION(pvol, dwSHCNE, psid, psidOld, poiOld, pwsCaller); \
}


/*  SCAN.C
 */

// The private set of SCANERR bits listed here augments the public set of bits in FATAPI.H
DWORD ScanVolume(PVOLUME pvol, DWORD dwScanOptions);


/*  STREAM.C functions
 */

//  OpenStream flags (NOTE: the CREATE and REFRESH flags can be combined
//  to *create* a stream if one doesn't exist and *refresh* it if it does,
//  all in one easy-to-use call)

#define OPENSTREAM_NONE         0x00000000
#define OPENSTREAM_CREATE       0x00010000      // create a new stream
#define OPENSTREAM_REFRESH      0x00020000      // refresh an existing stream
#define OPENSTREAM_PRIVATE      STF_PRIVATE     // create/refresh a PRIVATE stream

#define RESIZESTREAM_NONE       0x00000000
#define RESIZESTREAM_SHRINK     0x00000001      // if stream is too large, shrink it
#define RESIZESTREAM_UPDATEFAT  0x00000002      // if stream was resized, update the FAT

PDSTREAM OpenStream(PVOLUME pvol, DWORD clusFirst, PDSID psid, PDSTREAM pstmParent, PDIRINFO pdi, DWORD dwFlags);
DWORD   CloseStream(PDSTREAM pstm);
DWORD   CommitStream(PDSTREAM pstm, BOOL fAll);
void    RewindStream(PDSTREAM pstm, DWORD pos);
DWORD   SeekStream(PDSTREAM pstm, DWORD pos);
DWORD   PositionStream(PDSTREAM pstm, DWORD pos, PDWORD pdwClus);
DWORD   ReadStream(PDSTREAM pstm, DWORD pos, PVOID *ppvStart, PVOID *ppvEnd);
DWORD   ReadStreamData(PDSTREAM pstm, DWORD pos, PVOID pvData, DWORD len, PDWORD plenRead);
DWORD   WriteStreamData(PDSTREAM pstm, DWORD pos, PCVOID pvData, DWORD len, PDWORD plenWritten, BOOL fCommit);
DWORD   ResizeStream(PDSTREAM pstm, DWORD cbNew, DWORD dwResizeFlags);
BOOL    CheckStreamHandles(PVOLUME pvol, PDSID psid);
VOID UpdateSourceStream (PVOLUME pvol, PDSID psidSrc, PDIRINFO pdiDst, PDSTREAM pstmDstParent);
BOOL    StreamOpenedForExclAccess(PVOLUME pvol, PDSID psid);
BOOL    CheckStreamSharing(PDSTREAM pstm, int mode, BOOL fTruncate);


/*  VOLUME.C functions
 */

DWORD   ReadVolume(PVOLUME pvol, DWORD block, int cBlocks, PVOID pvBuffer);
DWORD   WriteVolume(PVOLUME pvol, DWORD block, int cBlocks, PVOID pvBuffer, BOOL fWriteThrough);
BOOL    InitVolume(PVOLUME pvol, PBIGFATBOOTSEC pbgbs);
BOOL    ValidateFATSector(PVOLUME pvol, PVOID pvSector);
PVOLUME FindVolume(PDSK pdsk, PBIGFATBOOTSEC pbgbs);
DWORD   TestVolume(PVOLUME pvol, PBIGFATBOOTSEC *ppbgbs);
void    RefreshVolume(PVOLUME pvol);
DWORD   LockVolume(PVOLUME pvol, DWORD dwFlags);
void    UnlockVolume(PVOLUME pvol);
PVOLUME OpenVolume(PDSK pdsk, PBIGFATBOOTSEC *ppbgbs, PDSTREAM pstmParent);
BOOL    CloseVolume(PVOLUME pvol, PWSTR pwsVolName);
void    QueryVolumeParameters(PVOLUME pvol, PDEVPB pdevpb, BOOL fVolume);
BOOL    RegisterVolume(PVOLUME pvol);
void    DeregisterVolume(PVOLUME pvol);
PVOLUME MountVolume(PDSK pdsk, PBIGFATBOOTSEC *ppbgbs, DWORD flVol);
BOOL    UnmountVolume(PVOLUME pvol, BOOL fFrozen);
BOOL    CheckUnformattedVolume(PVOLUME pvol);
PDSK    FindDisk(HANDLE hdsk, PCWSTR pwsDisk, PDISK_INFO pdi);
DWORD   SetSecureWipeFlag (PVOLUME pvol);


/*  TRANSACT.C functions
 */
 #ifdef TFAT
BOOL    InitFATs(PVOLUME pvol);
DWORD   SyncFATs(PVOLUME pvol);
void	FreezeClusters( PVOLUME pvol, DWORD clusFirst, DWORD clusLast); 
DWORD	FreeFrozenClusters( PVOLUME pvol ); 
BOOL	IsNewCluster( PVOLUME pvol, DWORD clus); 
DWORD   CloneDirCluster( PVOLUME pvol, PDSTREAM pstm, DWORD blkOld, PDWORD clusNew );
DWORD   UpdateStreamDirBlk( PDSTREAM pstm, DWORD oldBlk, DWORD newBlk );
DWORD   ReplaceCluster( PVOLUME pvol, DWORD clusOld, DWORD clusNew, DWORD clusFirst);
DWORD	CloneStream(PDSTREAM pstm, DWORD pos, DWORD len);
DWORD   ChangeTransactionStatus(PVOLUME pvol, WORD ts);
DWORD   Com