/// <summary>
/// Create new inctanse of the <see cref="Partition"/> class.
/// </summary>
/// <param name="aHost">A hosting device.</param>
/// <param name="aStartingSector">A starting sector.</param>
/// <param name="aSectorCount">A sector count.</param>
public Partition(BlockDevice aHost, UInt64 aStartingSector, UInt64 aSectorCount)
{
mHost = aHost;
mStartingSector = aStartingSector;
mBlockCount = aSectorCount;
mBlockSize = aHost.BlockSize;
}
/// <summary>
/// Create new instance of the <see cref="Partition"/> class.
/// </summary>
/// <param name="aHost">A hosting device.</param>
/// <param name="aStartingSector">A starting sector.</param>
/// <param name="aSectorCount">A sector count.</param>
public Partition(BlockDevice aHost, ulong StartingSector, ulong SectorCount)
{
Host = aHost;
this.StartingSector = StartingSector;
mBlockCount = SectorCount;
mBlockSize = Host.BlockSize;
}
public Partition(BlockDevice aHost, UInt64 aStartingSector, UInt64 aSectorCount)
{
mHost = aHost;
mStartingSector = aStartingSector;
mBlockCount = aSectorCount;
mBlockSize = aHost.BlockSize;
}
private static void InitAta(BlockDevice.Ata.ControllerIdEnum aControllerID,
BlockDevice.Ata.BusPositionEnum aBusPosition)
{
var xIO = aControllerID == BlockDevice.Ata.ControllerIdEnum.Primary
? Cosmos.Core.Global.BaseIOGroups.ATA1
: Cosmos.Core.Global.BaseIOGroups.ATA2;
var xATA = new BlockDevice.AtaPio(xIO, aControllerID, aBusPosition);
if (xATA.DriveType == BlockDevice.AtaPio.SpecLevel.Null)
{
return;
}
if (xATA.DriveType == BlockDevice.AtaPio.SpecLevel.ATA)
{
BlockDevice.BlockDevice.Devices.Add(xATA);
Ata.AtaDebugger.Send("ATA device with speclevel ATA found.");
}
else
{
Ata.AtaDebugger.Send("ATA device with spec level " + (int) xATA.DriveType +
" found, which is not supported!");
return;
}
var xMbrData = new byte[512];
xATA.ReadBlock(0UL, 1U, xMbrData);
var xMBR = new BlockDevice.MBR(xMbrData);
if (xMBR.EBRLocation != 0)
{
//EBR Detected
var xEbrData = new byte[512];
xATA.ReadBlock(xMBR.EBRLocation, 1U, xEbrData);
var xEBR = new BlockDevice.EBR(xEbrData);
for (int i = 0; i < xEBR.Partitions.Count; i++)
{
//var xPart = xEBR.Partitions[i];
//var xPartDevice = new BlockDevice.Partition(xATA, xPart.StartSector, xPart.SectorCount);
//BlockDevice.BlockDevice.Devices.Add(xPartDevice);
}
}
// TODO Change this to foreach when foreach is supported
Ata.AtaDebugger.Send("Number of MBR partitions found: " + xMBR.Partitions.Count);
for (int i = 0; i < xMBR.Partitions.Count; i++)
{
var xPart = xMBR.Partitions[i];
if (xPart == null)
{
Console.WriteLine("Null partition found at idx " + i);
}
else
{
var xPartDevice = new BlockDevice.Partition(xATA, xPart.StartSector, xPart.SectorCount);
BlockDevice.BlockDevice.Devices.Add(xPartDevice);
Console.WriteLine("Found partition at idx " + i);
}
}
}
public static bool IsGPTPartition(BlockDevice aBlockDevice)
{
byte[] GPTHeader = new byte[512];
aBlockDevice.ReadBlock(1, 1, ref GPTHeader);
ulong signature = BitConverter.ToUInt64(GPTHeader, 0);
return(signature == EFIParitionSignature);
}
public MBR(BlockDevice device)
{
var aMBR = device.NewBlockArray(1);
device.ReadBlock(0, 1, ref aMBR);
ParsePartition(aMBR, 446);
ParsePartition(aMBR, 462);
ParsePartition(aMBR, 478);
ParsePartition(aMBR, 494);
}
internal static void ScanAndInitPartitions(BlockDevice device)
{
if (GPT.IsGPTPartition(device))
{
var xGPT = new GPT(device);
Ata.AtaDebugger.Send("Number of GPT partitions found:");
Ata.AtaDebugger.SendNumber(xGPT.Partitions.Count);
int i = 0;
foreach (var part in xGPT.Partitions)
{
Partition.Partitions.Add(new Partition(device, part.StartSector, part.SectorCount));
i++;
}
}
else
{
var mbr = new MBR(device);
if (mbr.EBRLocation != 0)
{
//EBR Detected
var xEbrData = new byte[512];
device.ReadBlock(mbr.EBRLocation, 1U, ref xEbrData);
var xEBR = new EBR(xEbrData);
for (int i = 0; i < xEBR.Partitions.Count; i++)
{
//var xPart = xEBR.Partitions[i];
//var xPartDevice = new BlockDevice.Partition(xATA, xPart.StartSector, xPart.SectorCount);
//Partition.Partitions.Add(xATA, xPartDevice);
}
}
int c = 0;
foreach (var part in mbr.Partitions)
{
Partition.Partitions.Add(new Partition(device, part.StartSector, part.SectorCount));
c++;
}
}
}
public GPT(BlockDevice aBlockDevice)
{
byte[] GPTHeader = new byte[512];
aBlockDevice.ReadBlock(1, 1, ref GPTHeader);
// Start of parition entries
ulong partEntryStart = BitConverter.ToUInt64(GPTHeader, 72);
uint numParitions = BitConverter.ToUInt32(GPTHeader, 80);
uint partSize = BitConverter.ToUInt32(GPTHeader, 84);
uint paritionsPerSector = 512 / partSize;
for (ulong i = 0; i < numParitions / paritionsPerSector; i++)
{
byte[] partData = new byte[512];
aBlockDevice.ReadBlock(partEntryStart + i, 1, ref partData);
for (uint j = 0; j < paritionsPerSector; j++)
{
ParseParition(partData, j * partSize);
}
}
}
public FatFileSystem(BlockDevice aDevice)
{
mDevice = aDevice;
byte[] xBPB = mDevice.NewBlockArray(1);
mDevice.ReadBlock(0UL, 1U, xBPB);
UInt16 xSig = xBPB.ToUInt16(510);
if (xSig != 0xAA55)
{
throw new Exception("FAT signature not found.");
}
BytesPerSector = xBPB.ToUInt16(11);
SectorsPerCluster = xBPB[13];
BytesPerCluster = BytesPerSector * SectorsPerCluster;
ReservedSectorCount = xBPB.ToUInt16(14);
NumberOfFATs = xBPB[16];
RootEntryCount = xBPB.ToUInt16(17);
TotalSectorCount = xBPB.ToUInt16(19);
if (TotalSectorCount == 0)
{
TotalSectorCount = xBPB.ToUInt32(32);
}
// FATSz
FatSectorCount = xBPB.ToUInt16(22);
if (FatSectorCount == 0)
{
FatSectorCount = xBPB.ToUInt32(36);
}
//Global.Dbg.Send("FAT Sector Count: " + FatSectorCount);
DataSectorCount = TotalSectorCount - (ReservedSectorCount + (NumberOfFATs * FatSectorCount) + ReservedSectorCount);
// Computation rounds down.
ClusterCount = DataSectorCount / SectorsPerCluster;
// Determine the FAT type. Do not use another method - this IS the official and
// proper way to determine FAT type.
// Comparisons are purposefully < and not <=
// FAT16 starts at 4085, FAT32 starts at 65525
if (ClusterCount < 4085)
{
FatType = FatTypeEnum.Fat12;
}
else if (ClusterCount < 65525)
{
FatType = FatTypeEnum.Fat16;
}
else
{
FatType = FatTypeEnum.Fat32;
}
if (FatType == FatTypeEnum.Fat32)
{
RootCluster = xBPB.ToUInt32(44);
}
else
{
RootSector = ReservedSectorCount + (NumberOfFATs * FatSectorCount);
RootSectorCount = (RootEntryCount * 32 + (BytesPerSector - 1)) / BytesPerSector;
}
DataSector = ReservedSectorCount + (NumberOfFATs * FatSectorCount) + RootSectorCount;
}
public FatFileSystem(Cosmos.HAL.BlockDevice.BlockDevice aDevice)
{
mDevice = aDevice;
byte[] xBPB = mDevice.NewBlockArray(1);
mDevice.ReadBlock(0UL, 1U, xBPB);
UInt16 xSig = xBPB.ToUInt16(510);
if (xSig != 0xAA55)
{
throw new Exception("FAT signature not found.");
}
BytesPerSector = xBPB.ToUInt16(11);
SectorsPerCluster = xBPB[13];
BytesPerCluster = BytesPerSector * SectorsPerCluster;
ReservedSectorCount = xBPB.ToUInt16(14);
NumberOfFATs = xBPB[16];
RootEntryCount = xBPB.ToUInt16(17);
TotalSectorCount = xBPB.ToUInt16(19);
if (TotalSectorCount == 0)
{
TotalSectorCount = xBPB.ToUInt32(32);
}
// FATSz
FatSectorCount = xBPB.ToUInt16(22);
if (FatSectorCount == 0)
{
FatSectorCount = xBPB.ToUInt32(36);
}
//Global.Dbg.Send("FAT Sector Count: " + FatSectorCount);
DataSectorCount = TotalSectorCount - (ReservedSectorCount + (NumberOfFATs * FatSectorCount) + ReservedSectorCount);
// Computation rounds down.
ClusterCount = DataSectorCount / SectorsPerCluster;
// Determine the FAT type. Do not use another method - this IS the official and
// proper way to determine FAT type.
// Comparisons are purposefully < and not <=
// FAT16 starts at 4085, FAT32 starts at 65525
if (ClusterCount < 4085)
{
FatType = FatTypeEnum.Fat12;
}
else if (ClusterCount < 65525)
{
FatType = FatTypeEnum.Fat16;
}
else
{
FatType = FatTypeEnum.Fat32;
}
if (FatType == FatTypeEnum.Fat32)
{
RootCluster = xBPB.ToUInt32(44);
}
else
{
RootSector = ReservedSectorCount + (NumberOfFATs * FatSectorCount);
RootSectorCount = (RootEntryCount * 32 + (BytesPerSector - 1)) / BytesPerSector;
}
DataSector = ReservedSectorCount + (NumberOfFATs * FatSectorCount) + RootSectorCount;
}
