📄 fatfs.h
字号:
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);
/* 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);
BOOL MatchesWildcard(DWORD lenWild, PCWSTR pchWild, DWORD lenFile, PCWSTR pchFile);
void InitNumericTail(PDIRINFO pdi);
void CheckNumericTail(PDIRINFO pdi, PDWORD pdwBitArray);
void GenerateNumericTail(PDIRINFO pdi, PDWORD pdwBitArray);
int OEMToUniName(PWSTR pws, PCHAR pchOEM);
BOOL UniToOEMName(PCHAR pchOEM, PCWSTR pwsName, int cwName);
/* 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_OidGetInfo(PVOLUME pvol, CEOID oid, CEOIDINFO *poi);
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);
#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
#define SCANERR_REPAIRABLE 0x80000000 // the current error is repairable
#define SCANDATA_NONE 0x00000000
#define SCANDATA_TOODEEP 0x00000001 // set if directory nesting level was too deep
typedef struct _SCANDATA SCANDATA, *PSCANDATA;
typedef BOOL (*PFNSCANFIX)(struct _SCANDATA *psd, PDIRINFO pdi, PWIN32_FIND_DATAW pfd, DWORD dwScanErr);
struct _SCANDATA {
PVOLUME sd_pvol;
DWORD sd_dwScanVol;
PFNSCANFIX sd_pfnScanFix;
PVOID sd_pRefData;
DWORD sd_cFiles;
DWORD sd_cLevels;
DWORD sd_flags;
PDWORD sd_pdwClusArray;
WCHAR sd_wsPath[MAX_PATH];
};
int ScanFixInteractive(PSCANDATA psd, PDIRINFO pdi, PWIN32_FIND_DATAW pfd, DWORD dwScanErr);
DWORD ScanVolume(PVOLUME pvol, DWORD dwScanVol, PFNSCANFIX pfnScanFix, PVOID pRefData);
/* 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);
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);
BOOL CheckStreamSharing(PDSTREAM pstm, int mode);
/* VOLUME.C functions
*/
DWORD ReadVolume(PVOLUME pvol, DWORD block, int cBlocks, PVOID pvBuffer);
DWORD WriteVolume(PVOLUME pvol, DWORD block, int cBlocks, PVOID pvBuffer);
BOOL InitVolume(PVOLUME pvol, PBIGFATBOOTSEC pbgbs);
BOOL ValidateFATSector(PVOLUME pvol, PVOID pvSector);
PVOLUME FindVolume(PDSK pdsk, PBIGFATBOOTSEC pbgbs);
void ProbeVolume(PVOLUME pvol);
DWORD TestVolume(PVOLUME pvol, PBIGFATBOOTSEC *ppbgbs);
void RefreshVolume(PVOLUME pvol);
DWORD LockVolume(PVOLUME pvol, DWORD dwFlags);
void UnlockVolume(PVOLUME pvol);
PVOLUME OpenVolume(PDSK pdsk, PPARTINFO ppi, PBIGFATBOOTSEC *ppbgbs, PDSTREAM pstmParent);
BOOL CloseVolume(PVOLUME pvol, PWSTR pwsVolName);
void QueryVolumeParameters(PVOLUME pvol, PDEVPB pdevpb, BOOL fVolume);
int GetAFSName(int iAFS, CEOIDINFO *poi);
BOOL RegisterVolume(PVOLUME pvol);
void DeregisterVolume(PVOLUME pvol);
PVOLUME MountVolume(PDSK pdsk, PBIGFATBOOTSEC *ppbgbs, PPARTINFO ppi, DWORD flVol);
BOOL UnmountVolume(PVOLUME pvol, BOOL fFrozen);
void CheckCompressedVolume(PVOLUME pvol);
BOOL CheckUnformattedVolume(PVOLUME pvol);
BOOL WarnDirtyVolume(PVOLUME pvol, PWSTR pwsVolName);
#if NUM_FILE_APIS > 13
BOOL WarnErrorVolume(PVOLUME pvol, DWORD dwError);
#endif
PDSK FindDisk(HANDLE hdsk, PCWSTR pwsDisk, PDISK_INFO pdi);
/* FILESYS.C functions (in FILESYS.EXE)
*/
#if !defined(INVALID_AFS) #if OID_FIRST_AFS != 0
#define INVALID_AFS 0
#else
#define INVALID_AFS -1
#endif
#endif
/* Globals in API.C
*/
extern CONST WCHAR awcFATFS[];
extern CONST WCHAR awcCompVolID[];
extern CONST WCHAR awcUpdateAccess[];
extern HINSTANCE hFATFS;
extern int cLoads; // count of DLL_PROCESS_ATTACH's
#ifdef SHELL_MESSAGE_NOTIFICATION
extern HWND hwndShellNotify; // from FAT_RegisterFileSystemNotification
#endif
#ifdef SHELL_CALLBACK_NOTIFICATION
extern SHELLFILECHANGEFUNC_t pfnShell; // from FAT_RegisterFileSystemFunction
#endif
extern DSK_DLINK dlDisks; // keeps track of every open FAT device
extern int flFATFS; // see FATFS_*
extern DWORD cFATThreads;
extern HANDLE hevStartup;
extern HANDLE hevShutdown;
extern CRITICAL_SECTION csFATFS;
#ifdef DEBUG
extern int cbAlloc; // total bytes allocated
extern CRITICAL_SECTION csAlloc;
#endif
/* Globals in BUFFER.C
*/
extern DWORD cbBuf; // buffer size (computed at run-time)
extern DWORD cBufThreads; // number of threads buffer pool can handle
extern DWORD cBufThreadsOrig; // number of threads buffer pool can handle
extern HANDLE hevBufThreads; // auto-reset event signalled when another thread can be handled
extern CRITICAL_SECTION csBuffers; // buffer pool serialization critical section
#ifdef DEBUG // expose these globals for assertion checks
extern DWORD cbufTotal; // total number of buffers
extern DWORD cbufError; // total buffers with outstanding write errors
#endif
#ifdef INCLUDE_FATFS // expose these globals to test harness code only
extern BUF_DLINK dlBufMRU; // MRU list of buffers
#endif
#pragma check_stack(off)
#endif /* FATFS_H */
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -