modeco80
/
singrdk
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
singrdk/base/boot/SingLdrPc/blfat.cpp

1538 lines
34 KiB
C++
Raw Permalink Normal View History

RDK 2.0
2008-11-17 18:29:00 -05:00
//++
//
// Copyright (c) Microsoft Corporation
//
// Module Name:
//
// blfat.cpp
//
// Abstract:
//
// This module implements FAT support for the boot loader.
//
//--
#include "bl.h"
//
// MBR definitions.
//
#pragma pack(1)
#define MBR_BOOTABLE 0x80
typedef struct _MBR_PARTITION {
UINT8 Status;
UINT8 FirstSectorCHS[3];
UINT8 Type;
UINT8 LastSectorCHS[3];
UINT32 FirstSector;
UINT32 NumberOfSectors;
} MBR_PARTITION, *PMBR_PARTITION;
C_ASSERT(sizeof(MBR_PARTITION) == 16);
#define MBR_SIGNATURE 0xAA55
typedef struct _MBR {
UINT8 BootCode[446];
MBR_PARTITION Partition[4];
UINT16 Signature;
} MBR, *PMBR;
C_ASSERT(sizeof(MBR) == 512);
#pragma pack()
//
// FAT definitions.
//
#define FAT_SECTOR_SIZE 512
#define FAT_FIRST_DATA_CLUSTER 2
#define FAT16_CLUSTER_MASK 0xFFFF
#define FAT16_LINK_TERMINATOR 0xFFFF
#define FAT32_CLUSTER_MASK 0x0FFFFFFF
#define FAT32_LINK_TERMINATOR 0x0FFFFFFF
#pragma pack(1)
typedef struct __declspec(align(FAT_SECTOR_SIZE)) _FAT_SECTOR {
UINT8 Data[FAT_SECTOR_SIZE];
} FAT_SECTOR, *PFAT_SECTOR;
typedef struct _FAT16_BOOT_SECTOR {
UINT8 JumpInstruction[3];
UINT8 OemName[8];
UINT16 BytesPerSector;
UINT8 SectorsPerCluster;
UINT16 NumberOfReservedSectors;
UINT8 NumberOfFATs;
UINT16 NumberOfRootDirectoryEntries;
UINT16 TotalSectorCount16;
UINT8 Media;
UINT16 SectorsPerFAT;
UINT16 SectorsPerTrack;
UINT16 NumberOfHeads;
UINT32 NumberOfHiddenSectors;
UINT32 TotalSectorCount32;
UINT8 DriveNumber;
UINT8 Reserved1;
UINT8 ExtendedBootSignature;
UINT32 VolumeSerialNumber;
UINT8 VolumeLabel[11];
UINT8 FileSystemType[8];
UINT8 BootCode[448];
UINT16 Signature;
} FAT16_BOOT_SECTOR, *PFAT16_BOOT_SECTOR;
C_ASSERT(sizeof(FAT16_BOOT_SECTOR) == FAT_SECTOR_SIZE);
typedef struct _FAT32_BOOT_SECTOR {
UINT8 JumpInstruction[3];
UINT8 OemName[8];
UINT16 BytesPerSector;
UINT8 SectorsPerCluster;
UINT16 NumberOfReservedSectors;
UINT8 NumberOfFATs;
UINT16 NumberOfRootDirectoryEntries;
UINT16 TotalSectorCount16;
UINT8 Media;
UINT16 SectorsPerFAT16;
UINT16 SectorsPerTrack;
UINT16 NumberOfHeads;
UINT32 NumberOfHiddenSectors;
UINT32 TotalSectorCount32;
UINT32 SectorsPerFAT32;
UINT16 Flags;
UINT16 FileSystemVersion;
UINT32 RootDirectoryFirstCluster;
UINT16 FileSystemInfoSector;
UINT16 BackupBootSector;
UINT8 Reserved[12];
UINT8 DriveNumber;
UINT8 Reserved1;
UINT8 ExtendedBootSignature;
UINT32 VolumeSerialNumber;
UINT8 VolumeLabel[11];
UINT8 FileSystemType[8];
UINT8 BootCode[420];
UINT16 Signature;
} FAT32_BOOT_SECTOR, *PFAT32_BOOT_SECTOR;
C_ASSERT(sizeof(FAT32_BOOT_SECTOR) == FAT_SECTOR_SIZE);
typedef struct _FAT_BOOT_SECTOR {
union {
FAT16_BOOT_SECTOR Fat16;
FAT32_BOOT_SECTOR Fat32;
} u1;
} FAT_BOOT_SECTOR, *PFAT_BOOT_SECTOR;
C_ASSERT(sizeof(FAT_BOOT_SECTOR) == FAT_SECTOR_SIZE);
#define FAT_DIRECTORY_ENTRY_FREE 0xE5
#define FAT_DIRECTORY_ENTRY_LAST 0x00
#define FAT_ATTRIBUTE_READ_ONLY 0x01
#define FAT_ATTRIBUTE_HIDDEN 0x02
#define FAT_ATTRIBUTE_SYSTEM 0x04
#define FAT_ATTRIBUTE_VOLUME_ID 0x08
#define FAT_ATTRIBUTE_DIRECTORY 0x10
#define FAT_ATTRIBUTE_ARCHIVE 0x20
#define FAT_ATTRIBUTE_LONG_NAME (FAT_ATTRIBUTE_READ_ONLY | FAT_ATTRIBUTE_HIDDEN | FAT_ATTRIBUTE_SYSTEM | FAT_ATTRIBUTE_VOLUME_ID)
#define FAT_ATTRIBUTE_MASK 0x3F
#define FAT_LONG_NAME_TERMINATOR 0x40
#define FAT_LONG_NAME_ORDER_MASK 0x3F
typedef struct _FAT_DIRECTORY_ENTRY {
union {
struct {
UINT8 Name[11];
UINT8 Attribute;
UINT8 ReservedForNT;
UINT8 CreationTime[3];
UINT8 CreationDate[2];
UINT8 LastAccessDate[2];
UINT16 FirstClusterHigh;
UINT8 ModificationTime[2];
UINT8 ModificationDate[2];
UINT16 FirstClusterLow;
UINT32 Size;
} Short;
struct {
UINT8 Order;
WCHAR NameW1_5[5];
UINT8 Attribute;
UINT8 Type;
UINT8 Checksum;
WCHAR NameW6_11[6];
UINT16 Zero;
WCHAR NameW12_13[2];
} Long;
} u1;
} FAT_DIRECTORY_ENTRY, *PFAT_DIRECTORY_ENTRY;
C_ASSERT(sizeof(FAT_DIRECTORY_ENTRY) == 32);
#define FAT_MAX_PATH 255
typedef struct _FAT_NAME {
UINT8 ShortName[13];
UINT8 LongName[FAT_MAX_PATH + 1];
} FAT_NAME, *PFAT_NAME;
#pragma pack()
FAT_BOOT_SECTOR BlFatBootSector;
UINT32 BlFatBytesPerCluster;
UINT32 BlFatDataStart;
UINT8 BlFatDriveId;
INT13_DRIVE_PARAMETERS BlFatDriveParameters;
UINT32 BlFatLinkTerminator;
MBR BlFatMbr;
UINT32 BlFatNumberOfDataClusters;
UINT32 BlFatNumberOfRootDirectoryEntries;
UINT32 BlFatPartitionId;
UINT32 BlFatPartitionStart;
UINT32 BlFatPartitionSize;
PFAT_DIRECTORY_ENTRY BlFatRootDirectory;
UINT32 BlFatRootStart;
UINT32 BlFatSectorsPerCluster;
UINT32 BlFatTableStart;
FAT_SECTOR BlFatTemporaryBlock[64];
UINT16 BlFatTemporaryBlockCount = sizeof(BlFatTemporaryBlock) / sizeof(BlFatTemporaryBlock[0]);
UINT32 BlFatTotalSectorCount;
#define FAT_IS_DATA_CLUSTER(X) (((X) >= FAT_FIRST_DATA_CLUSTER) && (((X) - FAT_FIRST_DATA_CLUSTER) < BlFatNumberOfDataClusters))
#define FAT_DATA_CLUSTER_TO_SECTOR(X) (BlFatDataStart + (((X) - 2) * BlFatSectorsPerCluster))
#define FAT_IS_TERMINATOR(X) (((UINT32) (X)) == BlFatLinkTerminator)
#define BlFatHalt() BlFatHaltInternal(__LINE__)
BOOLEAN
(*BlFatGetNextCluster)(
UINT32 Cluster,
PUINT32 NextCluster
);
VOID
BlFatHaltInternal(
UINT32 Line
)
//++
//
// Routine Description:
//
// Prints an error message and halts.
//
//--
{
BlRtlPrintf("FAT: Error reading disk image!\n");
BlRtlHaltInternal(__FILE__, Line);
}
BOOLEAN
BlFatReadSector(
UINT32 FirstSector,
UINT32 NumberOfSectors,
PFAT_SECTOR Buffer
)
//++
//
// Routine Description:
//
// This function reads the specified range of sectors.
//
// Arguments:
//
// FirstSector - Supplies the first sector to read.
//
// NumberOfSectors - Supplies the number of sectors to read.
//
// Buffer - Receives data.
//
// Return Value:
//
// TRUE, if read operation was successful.
// FALSE, otherwise.
//
//--
{
UINT16 StepSize;
BLASSERT_PTR(FirstSector < BlFatTotalSectorCount, FirstSector);
BLASSERT(NumberOfSectors > 0);
BLASSERT(FirstSector + NumberOfSectors > FirstSector);
BLASSERT((FirstSector + NumberOfSectors) < BlFatTotalSectorCount);
while (NumberOfSectors > 0) {
if (NumberOfSectors < BlFatTemporaryBlockCount) {
StepSize = (UINT16) NumberOfSectors;
} else {
StepSize = BlFatTemporaryBlockCount;
}
if (BlRtlReadDrive(BlFatDriveId,
BlFatPartitionStart + FirstSector,
StepSize,
BlFatTemporaryBlock) == FALSE) {
#if FAT_VERBOSE
BlRtlPrintf("FAT: I/O error reading sector %u on drive 0x%02x!\n",
BlFatPartitionStart + FirstSector,
BlFatDriveId);
#endif
return FALSE;
}
BlRtlCopyMemory(Buffer,
BlFatTemporaryBlock,
StepSize * FAT_SECTOR_SIZE);
FirstSector += StepSize;
NumberOfSectors -= StepSize;
Buffer += StepSize;
}
return TRUE;
}
BOOLEAN
BlFatDirectoryEntryToName(
PFAT_DIRECTORY_ENTRY ShortEntry,
PFAT_NAME Name,
PFAT_DIRECTORY_ENTRY TableStart
)
//++
//
// Routine Description:
//
// This function extracts FAT short and long names from the specified directory entry.
//
// Arguments:
//
// ShortEntry - Supplies a pointer to the short name entry.
//
// Name - Receives short and long names.
//
// TableStart - Supplies the start address for the directory table.
//
// Return Value:
//
// TRUE, if names were extracted successfully.
// FALSE, otherwise.
//
//--
{
UINT8 Character;
PFAT_DIRECTORY_ENTRY Entry;
UINT8 LongNameComponentIndex;
UINT32 SourceIndex;
UINT32 TargetIndex;
if ((ShortEntry->u1.Short.Attribute & FAT_ATTRIBUTE_MASK) == FAT_ATTRIBUTE_LONG_NAME) {
return FALSE;
}
//
// Extract short name.
//
TargetIndex = 0;
for (SourceIndex = 0; SourceIndex < 8; SourceIndex += 1) {
Character = ShortEntry->u1.Short.Name[SourceIndex];
if (Character == ' ') {
if (SourceIndex == 0) {
return FALSE;
}
break;
}
if (Character == '.') {
return FALSE;
}
Name->ShortName[TargetIndex] = Character;
TargetIndex += 1;
}
if (ShortEntry->u1.Short.Name[8] != ' ') {
Name->ShortName[TargetIndex] = '.';
TargetIndex += 1;
for (SourceIndex = 8; SourceIndex < 11; SourceIndex += 1) {
Character = ShortEntry->u1.Short.Name[SourceIndex];
if (Character == ' ') {
break;
}
if (Character == '.') {
return FALSE;
}
Name->ShortName[TargetIndex] = Character;
TargetIndex += 1;
}
}
Name->ShortName[TargetIndex] = 0;
//
// If there is a long name, extract it by walking backwards from the short entry.
// Otherwise, set long name to empty string.
//
Name->LongName[0] = 0;
Entry = ShortEntry - 1;
if (Entry < TableStart) {
return TRUE;
}
if ((Entry->u1.Short.Attribute & FAT_ATTRIBUTE_MASK) != FAT_ATTRIBUTE_LONG_NAME) {
return TRUE;
}
LongNameComponentIndex = 1;
TargetIndex = 0;
for (;;) {
if (TargetIndex == FAT_MAX_PATH) {
return FALSE;
}
if (Entry < TableStart) {
return FALSE;
}
if ((Entry->u1.Long.Order & FAT_LONG_NAME_ORDER_MASK) != LongNameComponentIndex) {
return FALSE;
}
#define ADD_CHARACTER(C) \
\
if (TargetIndex == FAT_MAX_PATH) { \
\
return FALSE; \
} \
\
if (((C) != 0) && ((C) != 0xFFFF)) { \
\
Name->LongName[TargetIndex] = (UINT8) (C); \
TargetIndex += 1; \
}
ADD_CHARACTER(Entry->u1.Long.NameW1_5[0]);
ADD_CHARACTER(Entry->u1.Long.NameW1_5[1]);
ADD_CHARACTER(Entry->u1.Long.NameW1_5[2]);
ADD_CHARACTER(Entry->u1.Long.NameW1_5[3]);
ADD_CHARACTER(Entry->u1.Long.NameW1_5[4]);
ADD_CHARACTER(Entry->u1.Long.NameW6_11[0]);
ADD_CHARACTER(Entry->u1.Long.NameW6_11[1]);
ADD_CHARACTER(Entry->u1.Long.NameW6_11[2]);
ADD_CHARACTER(Entry->u1.Long.NameW6_11[3]);
ADD_CHARACTER(Entry->u1.Long.NameW6_11[4]);
ADD_CHARACTER(Entry->u1.Long.NameW6_11[5]);
ADD_CHARACTER(Entry->u1.Long.NameW12_13[0]);
ADD_CHARACTER(Entry->u1.Long.NameW12_13[1]);
#undef ADD_CHARACTER
if ((Entry->u1.Long.Order & FAT_LONG_NAME_TERMINATOR)) {
break;
}
Entry -= 1;
LongNameComponentIndex += 1;
}
Name->LongName[TargetIndex] = 0;
return TRUE;
}
PFAT_DIRECTORY_ENTRY
BlFatFindDirectoryTableEntry(
PFAT_DIRECTORY_ENTRY Table,
UINT32 NumberOfEntries,
PCSTR Name
)
//++
//
// Routine Description:
//
// This function finds the directory table entry matching the specified name.
//
// Arguments:
//
// Table - Supplies a pointer to the table to find in.
//
// NumberOfEntries - Supplies the number of entries in the table.
//
// Name - Supplies the name to look for.
//
// Return Value:
//
// TRUE, if a matching entry was located.
// FALSE, otherwise.
//
//--
{
PFAT_DIRECTORY_ENTRY Entry;
FAT_NAME EntryName;
PFAT_DIRECTORY_ENTRY Limit;
BLASSERT(Name[0] != 0);
Limit = Table + NumberOfEntries;
for (Entry = Table; Entry != Limit; Entry += 1) {
if (Entry->u1.Short.Name[0] == FAT_DIRECTORY_ENTRY_FREE) {
continue;
}
if (Entry->u1.Short.Name[0] == FAT_DIRECTORY_ENTRY_LAST) {
break;
}
if (Entry->u1.Short.Name[0] == '.') {
continue;
}
if ((Entry->u1.Short.Attribute & FAT_ATTRIBUTE_MASK) == FAT_ATTRIBUTE_VOLUME_ID) {
continue;
}
if (BlFatDirectoryEntryToName(Entry,
&EntryName,
Table) != FALSE) {
if ((BlRtlEqualStringI(Name, (PCSTR) EntryName.ShortName) != FALSE) ||
(BlRtlEqualStringI(Name, (PCSTR) EntryName.LongName) != FALSE)) {
return Entry;
}
}
}
return NULL;
}
BOOLEAN
BlFatGetLengthClusterChain(
UINT32 Cluster,
PUINT32 Length
)
//++
//
// Routine Description:
//
// This function queries the length of the specified cluster chain.
//
// Arguments:
//
// Cluster - Supplies the index of the first cluster in the chain.
//
// Length - Receives the length of the chain.
//
// Return Value:
//
// TRUE, if query operation was successful.
// FALSE, otherwise.
//
//--
{
*Length = 0;
do {
if (FAT_IS_DATA_CLUSTER(Cluster) == FALSE) {
return FALSE;
}
if (BlFatGetNextCluster(Cluster, &Cluster) == FALSE) {
return FALSE;
}
*Length += 1;
} while (Cluster != BlFatLinkTerminator);
return TRUE;
}
BOOLEAN
BlFatReadClusterChain(
UINT32 Cluster,
UINT32 BytesToRead,
PVOID Buffer
)
//++
//
// Routine Description:
//
// This function reads from the specified FAT data cluster chain.
//
// Arguments:
//
// Cluster - Supplies the index of the first cluster in the chain.
//
// BytesToRead - Supplies number of bytes to read.
//
// Buffer - Receives data.
//
// Return Value:
//
// TRUE, if read operation was successful.
// FALSE, otherwise.
//
//--
{
PVOID ClusterData;
PUINT8 Next;
UINT32 Sector;
BLASSERT_PTR(FAT_IS_DATA_CLUSTER(Cluster) != FALSE, Cluster);
BLASSERT(BytesToRead > 0);
Next = (PUINT8) Buffer;
for (;;) {
//
// If the cluster number is not within the valid data range, then fail the read operation.
//
if (FAT_IS_DATA_CLUSTER(Cluster) == FALSE) {
#if FAT_VERBOSE
BlRtlPrintf("FAT: ReadClusterChain: Cluster %u is out of range!\n", Cluster);
#endif
return FALSE;
}
//
// Calculate the first sector in the cluster.
//
Sector = FAT_DATA_CLUSTER_TO_SECTOR(Cluster);
//
// If remaining bytes to read is less than the cluster size, then read it using a
// temporary buffer, since the caller provided buffer is not necessarily a multiple
// of cluster size.
//
if (BytesToRead < BlFatBytesPerCluster) {
ClusterData = BlPoolAllocateBlock(BlFatBytesPerCluster);
if (BlFatReadSector(Sector,
ROUND_UP_TO_POWER2(BytesToRead, FAT_SECTOR_SIZE) / FAT_SECTOR_SIZE,
(PFAT_SECTOR) ClusterData) == FALSE) {
BlPoolFreeBlock(ClusterData);
return FALSE;
}
BlRtlCopyMemory(Next,
ClusterData,
BytesToRead);
BlPoolFreeBlock(ClusterData);
return TRUE;
}
//
// Otherwise, read the entire cluster and advance by full cluster size.
//
if (BlFatReadSector(Sector,
BlFatSectorsPerCluster,
(PFAT_SECTOR) Next) == FALSE) {
return FALSE;
}
BytesToRead -= BlFatBytesPerCluster;
Next += BlFatBytesPerCluster;
if (BytesToRead == 0) {
return TRUE;
}
//
// Get the next cluster index.
//
if (BlFatGetNextCluster(Cluster, &Cluster) == FALSE) {
return FALSE;
}
}
}
BOOLEAN
BlFatFindFileEntry(
PCSTR Path,
PFAT_DIRECTORY_ENTRY FileEntry
)
//++
//
// Routine Description:
//
// This function finds the entry matching the specified file path.
//
// Arguments:
//
// Path - Supplies a pointer to the path to look up.
//
// FileEntry - Receives the contents of the entry matching the specified path.
//
// Return Value:
//
// TRUE, if a match was found.
// FALSE, otherwise.
//
//--
{
UINT32 DirectoryCluster;
UINT32 DirectoryClusterCount;
UINT32 Depth;
FAT_DIRECTORY_ENTRY Entry;
PFAT_DIRECTORY_ENTRY Match;
PCSTR Next;
PFAT_DIRECTORY_ENTRY Table;
UINT32 TableSize;
UINT8 Token[FAT_MAX_PATH];
UINT32 TokenIndex;
if ((Path[0] == 0) ||
(Path[0] == '/') ||
(BlRtlStringLength(Path) >= FAT_MAX_PATH)) {
return FALSE;
}
Next = Path;
Depth = 0;
SATISFY_OVERZEALOUS_COMPILER(BlRtlZeroMemory(&Entry, sizeof(Entry)));
for (;;) {
if (*Next == 0) {
if ((Entry.u1.Short.Attribute & FAT_ATTRIBUTE_DIRECTORY) != 0) {
#if FAT_VERBOSE
BlRtlPrintf("FAT: FindFileEntry: %s is a directory!\n", Path);
#endif
return FALSE;
}
*FileEntry = Entry;
return TRUE;
}
//
// If the next token is empty (i.e. back to back separators), then this is a malformed path.
//
if (*Next == '/') {
#if FAT_VERBOSE
BlRtlPrintf("FAT: FindFileEntry: %s is a malformed path!\n", Path);
#endif
return FALSE;
}
//
// Extract the next token.
//
TokenIndex = 0;
for (;;) {
if (*Next == 0) {
break;
}
if (*Next == '/') {
Next += 1;
break;
}
Token[TokenIndex] = *Next;
TokenIndex += 1;
Next += 1;
}
BLASSERT(TokenIndex > 0);
Token[TokenIndex] = 0;
if (Depth == 0) {
Table = BlFatRootDirectory;
TableSize = BlFatNumberOfRootDirectoryEntries;
} else {
DirectoryCluster = Entry.u1.Short.FirstClusterLow;
if (BlFatGetLengthClusterChain(DirectoryCluster, &DirectoryClusterCount) == FALSE) {
return FALSE;
}
Table = (PFAT_DIRECTORY_ENTRY)
BlPoolAllocateBlock(DirectoryClusterCount * BlFatBytesPerCluster);
if (BlFatReadClusterChain(DirectoryCluster,
DirectoryClusterCount * BlFatBytesPerCluster,
Table) == FALSE) {
BlPoolFreeBlock(Table);
return FALSE;
}
TableSize = (DirectoryClusterCount * BlFatBytesPerCluster) / sizeof(FAT_DIRECTORY_ENTRY);
}
//
// Walk the directory table matching the previous token for an entry matching the next token.
//
Match = BlFatFindDirectoryTableEntry(Table,
TableSize,
(PCSTR) Token);
if (Match == NULL) {
#if FAT_VERBOSE
BlRtlPrintf("FAT: FindFileEntry: Unable to find directory entry for token %s.\n", Token);
#endif
if (Table != BlFatRootDirectory) {
BlPoolFreeBlock(Table);
}
return FALSE;
}
Entry = *Match;
if (Table != BlFatRootDirectory) {
BlPoolFreeBlock(Table);
}
Depth += 1;
}
}
BOOLEAN
BlFatGetFileSize(
PCSTR Path,
PUINT32 FileSize
)
//++
//
// Routine Description:
//
// This function queries the size of the specified file.
//
// Arguments:
//
// Path - Supplies the path to the file to query.
//
// FileSize - Receives the size of the file.
//
// Return Value:
//
// TRUE, if the query operation was successful.
// FALSE, otherwise.
//
//--
{
FAT_DIRECTORY_ENTRY Entry;
if (BlFatFindFileEntry(Path, &Entry) == FALSE) {
return FALSE;
}
*FileSize = Entry.u1.Short.Size;
return TRUE;
}
BOOLEAN
BlFatReadFile(
PCSTR Path,
PVOID Buffer,
UINT32 NumberOfBytes
)
//++
//
// Routine Description:
//
// This function reads from the specified file.
//
// Arguments:
//
// Path - Supplies the path to the file to read.
//
// Buffer - Receives data.
//
// NumberOfBytes - Supplies the number of bytes to read.
//
// Return Value:
//
// TRUE, if the read operation was successful.
// FALSE, otherwise.
//
//--
{
FAT_DIRECTORY_ENTRY Entry;
BOOLEAN Result;
if (BlFatFindFileEntry(Path, &Entry) == FALSE) {
return FALSE;
}
if (NumberOfBytes > Entry.u1.Short.Size) {
return FALSE;
}
Result = BlFatReadClusterChain(Entry.u1.Short.FirstClusterLow,
NumberOfBytes,
Buffer);
return Result;
}
BOOLEAN
BlFat16GetNextCluster(
UINT32 Cluster,
PUINT32 NextCluster
)
//++
//
// Routine Description:
//
// This function gets the index of the cluster following the specified cluster.
//
// Arguments:
//
// Cluster - Supplies the index of the cluster.
//
// NextCluster - Receives the index of the next cluster.
//
// Return Value:
//
// TRUE, if query operation was successful.
// FALSE, otherwise.
//
//--
{
UINT32 Offset;
UINT32 Sector;
FAT_SECTOR TablePage;
if (FAT_IS_DATA_CLUSTER(Cluster) == FALSE) {
#if FAT_VERBOSE
BlRtlPrintf("FAT: Fat16GetNextCluster: Cluster %u is out of range!\n", Cluster);
#endif
return FALSE;
}
Sector = BlFatTableStart + (Cluster / 256);
Offset = Cluster % 256;
if (BlFatReadSector(Sector, 1, &TablePage) == FALSE) {
return FALSE;
}
*NextCluster = (UINT32) (((PUINT16) &TablePage)[Offset]);
return TRUE;
}
VOID
BlFat16Initialize(
VOID
)
//++
//
// Routine Description:
//
// This function initializes FAT16 support.
//
//--
{
PFAT16_BOOT_SECTOR BootSector;
BootSector = &BlFatBootSector.u1.Fat16;
BLASSERT(BlFatMbr.Partition[BlFatPartitionId].Type == MBR_FAT16LBA);
//
// Read FAT16 boot sector.
//
if (BlRtlReadDrive(BlFatDriveId,
BlFatPartitionStart,
1,
BootSector) == FALSE) {
#if FAT_VERBOSE
BlRtlPrintf("FAT: Error reading boot sector!\n");
#endif
BlFatHalt();
}
//
// Extract volume geometry.
//
if (BootSector->BytesPerSector != FAT_SECTOR_SIZE) {
#if FAT_VERBOSE
BlRtlPrintf("FAT: Unsupported sector size (%u)!\n", BootSector->BytesPerSector);
#endif
BlFatHalt();
}
BlFatSectorsPerCluster = BootSector->SectorsPerCluster;
if (BlFatSectorsPerCluster == 0) {
#if FAT_VERBOSE
BlRtlPrintf("FAT: SectorsPerCluster == 0!\n");
#endif
BlFatHalt();
}
BlFatBytesPerCluster = BlFatSectorsPerCluster * FAT_SECTOR_SIZE;
if (BootSector->TotalSectorCount32 > 0) {
BlFatTotalSectorCount = BootSector->TotalSectorCount32;
} else {
BlFatTotalSectorCount = BootSector->TotalSectorCount16;
}
if (BlFatTotalSectorCount > BlFatPartitionSize) {
#if FAT_VERBOSE
BlRtlPrintf("FAT: Boot sector claims more sectors than MBR!\n");
#endif
BlFatHalt();
}
if (BootSector->NumberOfFATs == 0) {
#if FAT_VERBOSE
BlRtlPrintf("FAT: NumberOfFATs == 0!\n");
#endif
BlFatHalt();
}
if (BootSector->SectorsPerFAT == 0) {
#if FAT_VERBOSE
BlRtlPrintf("FAT: SectorsPerFAT == 0!\n");
#endif
BlFatHalt();
}
BlFatNumberOfRootDirectoryEntries = BootSector->NumberOfRootDirectoryEntries;
if ((BlFatNumberOfRootDirectoryEntries == 0) ||
((BlFatNumberOfRootDirectoryEntries % 64) != 0)) {
#if FAT_VERBOSE
BlRtlPrintf("FAT: Invalid number of root directory entries (%u)!\n", BlFatNumberOfRootDirectoryEntries);
#endif
BlFatHalt();
}
BlFatTableStart = BootSector->NumberOfReservedSectors;
if (BlFatTotalSectorCount < BlFatTableStart) {
#if FAT_VERBOSE
BlRtlPrintf("FAT: TotalSectorCount < TableStart!\n");
#endif
BlFatHalt();
}
BlFatRootStart = BlFatTableStart + (BootSector->NumberOfFATs * BootSector->SectorsPerFAT);
if (BlFatTotalSectorCount < BlFatRootStart) {
#if FAT_VERBOSE
BlRtlPrintf("FAT: TotalSectorCount < RootStart!\n");
#endif
BlFatHalt();
}
BlFatDataStart = BlFatRootStart + (ROUND_UP_TO_POWER2(BlFatNumberOfRootDirectoryEntries * sizeof(FAT_DIRECTORY_ENTRY), FAT_SECTOR_SIZE) / FAT_SECTOR_SIZE);
if (BlFatTotalSectorCount < BlFatDataStart) {
#if FAT_VERBOSE
BlRtlPrintf("FAT: TotalSectorCount < DataStart!\n");
#endif
BlFatHalt();
}
BlFatNumberOfDataClusters = (BlFatTotalSectorCount - BlFatDataStart) / BlFatSectorsPerCluster;
if (BlFatNumberOfDataClusters == 0) {
#if FAT_VERBOSE
BlRtlPrintf("FAT: NumberOfDataClusters == 0!\n");
#endif
BlFatHalt();
}
BlFatLinkTerminator = FAT16_LINK_TERMINATOR;
BlFatGetNextCluster = BlFat16GetNextCluster;
//
// Read root directory.
//
BlFatRootDirectory = (PFAT_DIRECTORY_ENTRY) BlPoolAllocateBlock((BlFatDataStart - BlFatRootStart) * FAT_SECTOR_SIZE);
if (BlFatReadSector(BlFatRootStart,
BlFatDataStart - BlFatRootStart,
(PFAT_SECTOR) BlFatRootDirectory) == FALSE) {
#if FAT_VERBOSE
BlRtlPrintf("FAT: Error reading root directory!\n");
#endif
BlFatHalt();
}
BLASSERT(FAT_IS_DATA_CLUSTER(FAT16_LINK_TERMINATOR) == FALSE);
return;
}
BOOLEAN
BlFat32GetNextCluster(
UINT32 Cluster,
PUINT32 NextCluster
)
//++
//
// Routine Description:
//
// This function gets the index of the cluster following the specified cluster.
//
// Arguments:
//
// Cluster - Supplies the index of the cluster.
//
// NextCluster - Receives the index of the next cluster.
//
// Return Value:
//
// TRUE, if query operation was successful.
// FALSE, otherwise.
//
//--
{
UINT32 Offset;
UINT32 Sector;
FAT_SECTOR TablePage;
if (FAT_IS_DATA_CLUSTER(Cluster) == FALSE) {
#if FAT_VERBOSE
BlRtlPrintf("FAT: Fat32GetNextCluster: Cluster %u is out of range!\n", Cluster);
#endif
return FALSE;
}
Sector = BlFatTableStart + (Cluster / 128);
Offset = Cluster % 128;
if (BlFatReadSector(Sector, 1, &TablePage) == FALSE) {
return FALSE;
}
*NextCluster = ((PUINT32) &TablePage)[Offset];
return TRUE;
}
VOID
BlFat32Initialize(
VOID
)
//++
//
// Routine Description:
//
// This function initializes FAT32 support.
//
//--
{
PFAT32_BOOT_SECTOR BootSector;
UINT32 RootDirectoryChainLength;
BootSector = &BlFatBootSector.u1.Fat32;
BLASSERT(BlFatMbr.Partition[BlFatPartitionId].Type == MBR_FAT32LBA);
//
// Read FAT32 boot sector.
//
if (BlRtlReadDrive(BlFatDriveId,
BlFatPartitionStart,
1,
BootSector) == FALSE) {
#if FAT_VERBOSE
BlRtlPrintf("FAT: Error reading boot sector!\n");
#endif
BlFatHalt();
}
//
// Extract volume geometry.
//
if (BootSector->BytesPerSector != FAT_SECTOR_SIZE) {
#if FAT_VERBOSE
BlRtlPrintf("FAT: Unsupported sector size (%u)!\n", BootSector->BytesPerSector);
#endif
BlFatHalt();
}
BlFatSectorsPerCluster = BootSector->SectorsPerCluster;
if (BlFatSectorsPerCluster == 0) {
#if FAT_VERBOSE
BlRtlPrintf("FAT: SectorsPerCluster == 0!\n");
#endif
BlFatHalt();
}
BlFatBytesPerCluster = BlFatSectorsPerCluster * FAT_SECTOR_SIZE;
if (BootSector->TotalSectorCount32 > 0) {
BlFatTotalSectorCount = BootSector->TotalSectorCount32;
} else {
BlFatTotalSectorCount = BootSector->TotalSectorCount16;
}
if (BlFatTotalSectorCount > BlFatPartitionSize) {
#if FAT_VERBOSE
BlRtlPrintf("FAT: Boot sector claims more sectors than MBR!\n");
#endif
BlFatHalt();
}
if (BootSector->NumberOfFATs == 0) {
#if FAT_VERBOSE
BlRtlPrintf("FAT: NumberOfFATs == 0!\n");
#endif
BlFatHalt();
}
if (BootSector->SectorsPerFAT32 == 0) {
#if FAT_VERBOSE
BlRtlPrintf("FAT: SectorsPerFAT == 0!\n");
#endif
BlFatHalt();
}
if (BootSector->NumberOfRootDirectoryEntries != 0) {
#if FAT_VERBOSE
BlRtlPrintf("FAT: BootSector->NumberOfRootDirectoryEntries != 0!\n");
#endif
BlFatHalt();
}
BlFatTableStart = BootSector->NumberOfReservedSectors;
if (BlFatTotalSectorCount < BlFatTableStart) {
#if FAT_VERBOSE
BlRtlPrintf("FAT: TotalSectorCount < TableStart!\n");
#endif
BlFatHalt();
}
BlFatDataStart = BlFatTableStart + (BootSector->NumberOfFATs * BootSector->SectorsPerFAT32);
if (BlFatTotalSectorCount < BlFatDataStart) {
#if FAT_VERBOSE
BlRtlPrintf("FAT: TotalSectorCount < DataStart!\n");
#endif
BlFatHalt();
}
BlFatNumberOfDataClusters = (BlFatTotalSectorCount - BlFatDataStart) / BlFatSectorsPerCluster;
if (BlFatNumberOfDataClusters == 0) {
#if FAT_VERBOSE
BlRtlPrintf("FAT: NumberOfDataClusters == 0!\n");
#endif
BlFatHalt();
}
BlFatLinkTerminator = FAT32_LINK_TERMINATOR;
BlFatGetNextCluster = BlFat32GetNextCluster;
//
// Read root directory.
//
if (BlFatGetLengthClusterChain(BootSector->RootDirectoryFirstCluster, &RootDirectoryChainLength) == FALSE) {
#if FAT_VERBOSE
BlRtlPrintf("FAT: Error querying chain length of root directory!\n");
#endif
BlFatHalt();
}
BlFatRootDirectory = (PFAT_DIRECTORY_ENTRY) BlPoolAllocateBlock(RootDirectoryChainLength * BlFatBytesPerCluster);
if (BlFatReadClusterChain(BootSector->RootDirectoryFirstCluster,
RootDirectoryChainLength * BlFatBytesPerCluster,
BlFatRootDirectory) == FALSE) {
#if FAT_VERBOSE
BlRtlPrintf("FAT: Error reading root directory!\n");
#endif
BlFatHalt();
}
BlFatNumberOfRootDirectoryEntries = (RootDirectoryChainLength * BlFatBytesPerCluster) / sizeof(FAT_DIRECTORY_ENTRY);
BLASSERT(FAT_IS_DATA_CLUSTER(FAT32_LINK_TERMINATOR) == FALSE);
return;
}
VOID
BlFatInitialize(
UINT8 DriveId,
UINT8 FatType
)
//++
//
// Routine Description:
//
// This function initializes FAT support.
//
// Arguments:
//
// DriveId - Supplies boot drive ID.
//
// FatType - Supplies the FAT type to look for.
//
//--
{
UINT32 Index;
BLASSERT((FatType == MBR_FAT16LBA) || (FatType == MBR_FAT32LBA));
if (BlRtlGetDriveParameters(DriveId, &BlFatDriveParameters) == FALSE) {
BlRtlPrintf("FAT: Can't get drive info 0x%02x!\n", DriveId);
BlRtlHalt();
}
if (BlFatDriveParameters.BytesPerSector != FAT_SECTOR_SIZE) {
BlRtlPrintf("FAT: Unexpected bytes per sector (%u)!\n", BlFatDriveParameters.BytesPerSector);
BlRtlHalt();
}
if (BlRtlReadDrive(DriveId, 0, 1, &BlFatMbr) == FALSE) {
BlRtlPrintf("FAT: Error reading MBR!\n");
BlRtlHalt();
}
if (BlFatMbr.Signature != MBR_SIGNATURE) {
BlRtlPrintf("FAT: No MBR signature!\n");
}
BlFatPartitionId = (UINT32) -1;
for (Index = 0; Index <= 4; Index += 1) {
if (FatType == BlFatMbr.Partition[Index].Type) {
switch (BlFatMbr.Partition[Index].Type) {
case MBR_FAT16LBA: {
BlFatDriveId = DriveId;
BlFatPartitionId = Index;
BlFatPartitionStart = BlFatMbr.Partition[Index].FirstSector;
BlFatPartitionSize = BlFatMbr.Partition[Index].NumberOfSectors;
BlFat16Initialize();
break;
}
case MBR_FAT32LBA: {
BlFatDriveId = DriveId;
BlFatPartitionId = Index;
BlFatPartitionStart = BlFatMbr.Partition[Index].FirstSector;
BlFatPartitionSize = BlFatMbr.Partition[Index].NumberOfSectors;
BlFat32Initialize();
break;
}
}
}
}
if (BlFatPartitionId == (UINT32) -1) {
BlRtlPrintf("FAT: No %s partitions!\n", FatType == MBR_FAT16LBA ? "FAT16" : "FAT32");
BlRtlHalt();
}
BlFsGetFileSize = BlFatGetFileSize;
BlFsReadFile = BlFatReadFile;
return;
}