?? fatfs.h
字號:
/* 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?? 快捷鍵說明
復制代碼
Ctrl + C
搜索代碼
Ctrl + F
全屏模式
F11
切換主題
Ctrl + Shift + D
顯示快捷鍵
?
增大字號
Ctrl + =
減小字號
Ctrl + -