#include "precomp.h"
#pragma hdrstop
#include <bootmbr.h>
ARC_STATUS
LowOpenDisk(
IN PCHAR DevicePath,
OUT PULONG DiskId
)
/*++
Routine Description:
This routine opens the supplied device for DASD access.
Arguments:
DevicePath - Supplies the device path to be opened.
DiskId - Returns the disk id.
Return Value:
ArcOpen
--*/
{
char buffer[256];
sprintf(buffer,"%spartition(0)",DevicePath);
return ArcOpen(buffer, ArcOpenReadWrite, DiskId);
}
ARC_STATUS
LowCloseDisk(
IN ULONG DiskId
)
/*++
Routine Description:
This routine closes the supplied device.
Arguments:
DiskId - Supplies the disk id.
Return Value:
ArcClose
--*/
{
return ArcClose(DiskId);
}
ARC_STATUS
LowGetDriveGeometry(
IN PCHAR DevicePath,
OUT PULONG TotalSectorCount,
OUT PULONG SectorSize,
OUT PULONG SectorsPerTrack,
OUT PULONG Heads
)
{
char Buffer[256];
sprintf(Buffer,"%spartition(0)",DevicePath);
return(LowGetPartitionGeometry(Buffer,TotalSectorCount,SectorSize,SectorsPerTrack,Heads));
}
ARC_STATUS
LowGetPartitionGeometry(
IN PCHAR PartitionPath,
OUT PULONG TotalSectorCount,
OUT PULONG SectorSize,
OUT PULONG SectorsPerTrack,
OUT PULONG Heads
)
/*++
Routine Description:
This routine computes the drive geometry for the given partition or
physical disk.
Arguments:
PartitionPath - Supplies a path to the partition or physical disk.
NumberOfSectors - Returns the number of sectors.
SectorSize - Returns the sector size.
SectorsPerTrack - Returns the number of sectors per track.
Heads - Returns the number of heads.
Return Value:
ArcOpen, ArcGetFileInformation, ArcClose, E2BIG, ESUCCESS
--*/
{
FILE_INFORMATION file_info;
ARC_STATUS r;
ULONG fileid;
LARGE_INTEGER l;
CM_DISK_GEOMETRY_DEVICE_DATA *DiskGeometry;
CONFIGURATION_COMPONENT *DiskComponent;
CM_PARTIAL_RESOURCE_LIST *DiskConfiguration;
CHAR DataBuffer[sizeof(CM_PARTIAL_RESOURCE_LIST) +
sizeof(CM_DISK_GEOMETRY_DEVICE_DATA)];
CM_PARTIAL_RESOURCE_DESCRIPTOR *DiskData;
// Always assume 512 bytes per sector.
*SectorSize = 512;
// Assume the SCSI default values for number of heads and sectors per track
*SectorsPerTrack = 32;
*Heads = 64;
// See if there is device specific data describing the geometry of
// the drive. If there is none, then just use the default SCSI
// values.
DiskComponent = ArcGetComponent(PartitionPath);
if (DiskComponent == NULL) {
return EINVAL;
}
//
// See if the ConfigurationDataLength is correct
// It should contain one DeviceSpecific resource descriptor
//
if (DiskComponent->ConfigurationDataLength == sizeof(CM_PARTIAL_RESOURCE_LIST) +
sizeof(CM_DISK_GEOMETRY_DEVICE_DATA) ) {
DiskConfiguration = (CM_PARTIAL_RESOURCE_LIST *)DataBuffer;
r = ArcGetConfigurationData(DiskConfiguration,DiskComponent);
if (r == ESUCCESS) {
//
// See if the Configuration Data has ARC version 1.3 or greater
//
if ( (DiskConfiguration->Version == 1 && DiskConfiguration->Revision >=3 ) ||
(DiskConfiguration->Version > 1) ) {
DiskData = &(DiskConfiguration->PartialDescriptors[DiskConfiguration->Count-1]);
if (DiskData->Type == CmResourceTypeDeviceSpecific) {
if (DiskData->u.DeviceSpecificData.DataSize == sizeof(CM_DISK_GEOMETRY_DEVICE_DATA)) {
DiskGeometry = (CM_DISK_GEOMETRY_DEVICE_DATA *)
&(DiskConfiguration->PartialDescriptors[DiskConfiguration->Count]);
*SectorsPerTrack = DiskGeometry->SectorsPerTrack;
*Heads = DiskGeometry->NumberOfHeads;
*SectorSize = DiskGeometry->BytesPerSector;
}
}
}
}
}
// PrintError("SectorSize = %08x",*SectorSize);
// PrintError("SectorsPerTrack = %08x",*SectorsPerTrack);
// PrintError("Heads = %08x",*Heads);
r = ArcOpen(PartitionPath, ArcOpenReadOnly, &fileid);
if (r != ESUCCESS) {
return r;
}
r = ArcGetFileInformation(fileid, &file_info);
if (r != ESUCCESS) {
return r;
}
r = ArcClose(fileid);
if (r != ESUCCESS) {
return r;
}
l.QuadPart = file_info.EndingAddress.QuadPart -
file_info.StartingAddress.QuadPart;
l.QuadPart = ((ULONGLONG)l.QuadPart) / ((ULONGLONG)(*SectorSize));
if (l.HighPart) {
return E2BIG;
}
*TotalSectorCount = l.LowPart;
return ESUCCESS;
}
#define MAX_TRANSFER 65536
ARC_STATUS
LowReadSectors(
IN ULONG VolumeId,
IN ULONG SectorSize,
IN ULONG StartingSector,
IN ULONG NumberOfSectors,
OUT PVOID Buffer
)
/*++
Routine Description:
This routine reads 'NumberOfSectors' sectors starting at sector
'StartingSector' on the volume with ID 'VolumeId'.
Arguments:
VolumeId - Supplies the ID for the volume.
SectorSize - Supplies the number of bytes per sector.
StartingSector - Supplies the starting sector for the read.
NumberOfSectors - Supplies the number of sectors to read.
Buffer - Returns the read in sectors.
Return Value:
ArcSeek, ArcRead, EIO, ESUCCESS
--*/
{
ARC_STATUS r;
ULONG c;
LARGE_INTEGER l;
ULONG i;
ULONG transfer;
PCHAR buf;
ULONG total;
l.QuadPart = UInt32x32To64(StartingSector,SectorSize);
buf = (PCHAR) Buffer;
r = ArcSeek(VolumeId, &l, SeekAbsolute);
if (r != ESUCCESS) {
return r;
}
total = SectorSize*NumberOfSectors;
for (i = 0; i < total; i += MAX_TRANSFER) {
transfer = min(MAX_TRANSFER, total - i);
r = ArcRead(VolumeId, &buf[i], transfer, &c);
if (r != ESUCCESS) {
return r;
}
if (c != transfer) {
return EIO;
}
}
return ESUCCESS;
}
ARC_STATUS
LowWriteSectors(
IN ULONG VolumeId,
IN ULONG SectorSize,
IN ULONG StartingSector,
IN ULONG NumberOfSectors,
IN PVOID Buffer
)
/*++
Routine Description:
This routine write 'NumberOfSectors' sectors starting at sector
'StartingSector' on the volume with ID 'VolumeId'.
Arguments:
VolumeId - Supplies the ID for the volume.
SectorSize - Supplies the number of bytes per sector.
StartingSector - Supplies the starting sector for the write.
NumberOfSectors - Supplies the number of sectors to write.
Buffer - Supplies the sectors to write.
Return Value:
ArcSeek, ArcWrite, EIO, ESUCCESS
--*/
{
ARC_STATUS r;
ULONG c;
LARGE_INTEGER l;
ULONG i;
ULONG transfer;
PCHAR buf;
ULONG total;
l.QuadPart = UInt32x32To64(StartingSector,SectorSize);
buf = (PCHAR) Buffer;
r = ArcSeek(VolumeId, &l, SeekAbsolute);
if (r != ESUCCESS) {
return r;
}
total = SectorSize*NumberOfSectors;
for (i = 0; i < total; i += MAX_TRANSFER) {
transfer = min(MAX_TRANSFER, total - i);
r = ArcWrite(VolumeId, &buf[i], transfer, &c);
if (r != ESUCCESS) {
return r;
}
if (c != transfer) {
return EIO;
}
}
return ESUCCESS;
}
/******************** DAVIDRO CODE *************************************/
/*++
Copyright (c) 1991 Microsoft Corporation
Module Name:
alpath.c
Abstract:
This module provides ARC pathname functions.
Author:
David M. Robinson (davidro) 13-November-1991
Revision History:
--*/
//
// Define the ARC pathname mnemonics.
//
PCHAR MnemonicTable[] = {
"arc",
"cpu",
"fpu",
"pic",
"pdc",
"sic",
"sdc",
"sc",
"eisa",
"tc",
"scsi",
"dti",
"multi",
"disk",
"tape",
"cdrom",
"worm",
"serial",
"net",
"video",
"par",
"point",
"key",
"audio",
"other",
"rdisk",
"fdisk",
"tape",
"modem",
"monitor",
"print",
"pointer",
"keyboard",
"term",
"other",
"line",
"netper",
"memory"
};
//
// Static storage for the pathname return value.
//
CHAR Pathname[256];
PCHAR
AlGetPathnameFromComponent (
IN PCONFIGURATION_COMPONENT Component
)
/*++
Routine Description:
This function builds an ARC pathname for the specified component.
Arguments:
Component - Supplies a pointer to a configuration component.
Return Value:
Returns a pointer to a string which contains the ARC pathname for the
component. NOTE: The string is stored in static storage, and must be
copied by the user before another call to this routine.
--*/
{
PCONFIGURATION_COMPONENT ParentComponent;
CHAR NewSegment[16];
CHAR Tempname[256];
Pathname[0] = 0;
//
// Loop while not at the root component.
//
while ((ParentComponent = ArcGetParent(Component)) != NULL) {
//
// Build new pathname segment from the Component type and key.
//
sprintf(NewSegment,
"%s(%d)",
MnemonicTable[Component->Type],
Component->Key);
//
// Add the new segment as a prefix of the current pathname.
//
strcpy(Tempname, Pathname);
strcpy(Pathname, NewSegment);
strcat(Pathname, Tempname);
//
// Move to the parent component.
//
Component = ParentComponent;
}
return Pathname;
}
/******************* END OF DAVIDRO CODE *********************************/
ARC_STATUS
LowQueryPathFromComponent(
IN PCONFIGURATION_COMPONENT Component,
OUT PCHAR* Path
)
/*++
Routine Description:
This routine computes a path from a component. The resulting
path is allocated on the heap.
Arguments:
Component - Supplies a component.
Path - Returns the path corresponding to that component.
Return Value:
ENOMEM, ESUCCESS
--*/
{
PCHAR p;
PCHAR path;
p = AlGetPathnameFromComponent(Component);
path = AllocateMemory(strlen(p) + 1);
if (!path) {
return ENOMEM;
}
strcpy(path, p);
*Path = path;
return ESUCCESS;
}
ARC_STATUS
LowTraverseChildren(
IN PCONFIGURATION_COMPONENT Parent,
IN CONFIGURATION_CLASS* ConfigClass OPTIONAL,
IN CONFIGURATION_TYPE* ConfigType OPTIONAL,
IN OUT PCONFIGURATION_COMPONENT* MatchingArray OPTIONAL,
IN OUT PULONG CurrentLength
)
/*++
Routine Description:
This routine traverses the trees whose parent is 'Parent'.
If the Matching array is provided then it will be filled
with pointers to all of the components whose type and class
match 'ConfigType' and 'ConfigClass'. Also, the 'CurrentLength'
is incremented by the number of nodes that match.
Arguments:
Parent - Supplies the root of the tree.
ConfigClass - Supplies the class to search for.
ConfigType - Supplies the type to search for.
CurrentLength - Supplies the current count.
Return Value:
ESUCCESS
--*/
{
PCONFIGURATION_COMPONENT pc;
ARC_STATUS r;
if (!(pc = ArcGetChild(Parent))) {
return ESUCCESS;
}
for (;;) {
if ((!ConfigClass || pc->Class == *ConfigClass) &&
(!ConfigType || pc->Type == *ConfigType)) {
if (MatchingArray) {
MatchingArray[*CurrentLength] = pc;
}
(*CurrentLength)++;
}
r = LowTraverseChildren(pc, ConfigClass, ConfigType,
MatchingArray, CurrentLength);
if (r != ESUCCESS) {
return r;
}
if (!(pc = ArcGetPeer(pc))) {
break;
}
}
return ESUCCESS;
}
ARC_STATUS
LowQueryComponentList(
IN CONFIGURATION_CLASS* ConfigClass OPTIONAL,
IN CONFIGURATION_TYPE* ConfigType OPTIONAL,
OUT PCONFIGURATION_COMPONENT** ComponentList,
OUT PULONG ListLength
)
/*++
Routine Description:
This routine returns an array of components whose class and
type match the ones given. (Since each parameter is optional,
you can do type-only and class-only searches.)
The array is allocated on the heap and contains pointers to
the actual components (NOT copies).
Arguments:
ConfigClass - Supplies the configuation class to search for.
ConfigType - Supplies the configuration type to search for.
ComponentList - Returns a list of pointers to components whose
class and type match 'ConfigClass' and
'ConfigType'.
ListLength - Returns the number of components in the list.
Return Value:
LowTraverseChildren, ENOMEM
--*/
{
ARC_STATUS r;
*ListLength = 0;
r = LowTraverseChildren(NULL, ConfigClass, ConfigType, NULL, ListLength);
if (r != ESUCCESS) {
return r;
}
if (!(*ComponentList = (PCONFIGURATION_COMPONENT*) AllocateMemory(
(*ListLength)*sizeof(PCONFIGURATION_COMPONENT)))) {
return ENOMEM;
}
*ListLength = 0;
return LowTraverseChildren(NULL, ConfigClass, ConfigType,
*ComponentList, ListLength);
}
ARC_STATUS
LowQueryPathList(
IN CONFIGURATION_CLASS* ConfigClass OPTIONAL,
IN CONFIGURATION_TYPE* ConfigType OPTIONAL,
OUT PCHAR** PathList,
OUT PULONG ListLength
)
/*++
Routine Description:
This routine returns a list of paths to the components that are
of class ConfigClass and of type ConfigType.
Arguments:
ConfigClass - Supplies the configuation class to search for.
ConfigType - Supplies the configuration type to search for.
PathList - Returns a list of paths to the components.
ListLength - Returns the number of components in the list.
Return Value:
LowQueryComponentList, LowQueryPathFromComponent
--*/
{
PCONFIGURATION_COMPONENT* component_list;
ULONG list_length;
ARC_STATUS r;
ULONG i;
PCHAR* path_list;
r = LowQueryComponentList(ConfigClass, ConfigType,
&component_list, &list_length);
if (r != ESUCCESS) {
return r;
}
if (!(path_list = (PCHAR*) AllocateMemory(list_length*sizeof(PCHAR)))) {
FreeMemory(component_list);
return ENOMEM;
}
for (i = 0; i < list_length; i++) {
path_list[i] = NULL;
}
for (i = 0; i < list_length; i++) {
r = LowQueryPathFromComponent(component_list[i], &path_list[i]);
if (r != ESUCCESS) {
FreeMemory(component_list);
LowFreePathList(path_list, list_length);
return r;
}
}
FreeMemory(component_list);
*PathList = path_list;
*ListLength = list_length;
return ESUCCESS;
}
ARC_STATUS
LowFreePathList(
IN PCHAR* PathList,
IN ULONG ListLength
)
/*++
Routine Description:
This routine frees up the space taken by the path lists.
Arguments:
PathList - Supplies the paths.
ListLength - Supplies the number of paths.
Return Value:
ESUCCESS
--*/
{
ULONG i;
for (i = 0; i < ListLength; i++) {
if (PathList[i]) {
FreeMemory(PathList[i]);
}
}
FreeMemory(PathList);
return ESUCCESS;
}
ARC_STATUS
LowQueryFdiskPathList(
OUT PCHAR** PathList,
OUT PULONG ListLength
)
/*++
Routine Description:
This routine returns a list of paths to all the devices of interest
to FDISK.
Arguments:
PathList - Returns a list of paths.
ListLength - Returns the length of the list.
Return Value:
LowQueryComponentList, LowQueryPathFromComponent, ESUCCESS
--*/
{
CONFIGURATION_TYPE config_type;
config_type = DiskPeripheral;
return LowQueryPathList(NULL, &config_type, PathList, ListLength);
}
ARC_STATUS
LowFreeFdiskPathList(
IN OUT PCHAR* PathList,
IN ULONG ListLength
)
/*++
Routine Description:
This routine frees up the space taken by the path lists.
Arguments:
PathList - Supplies the paths.
ListLength - Supplies the number of paths.
Return Value:
ESUCCESS
--*/
{
return LowFreePathList(PathList, ListLength);
}
ARC_STATUS
LowGetDiskLayout(
IN PCHAR Path,
OUT PDRIVE_LAYOUT_INFORMATION* DriveLayout
)
{
ARC_STATUS status;
ULONG Handle;
ULONG i,ExtendedStart,BootSector,Entry;
ULONG dummy,bps;
BOOLEAN Link,mbr;
PDRIVE_LAYOUT_INFORMATION DriveInfo;
PPARTITION_INFORMATION p;
PCHAR SectorBuffer;
PPARTITION_DESCRIPTOR ptable;
#define PSTART(p) ( \
(ULONG) ((p)->StartingSectorLsb0) + \
(ULONG) ((p)->StartingSectorLsb1 << 8) + \
(ULONG) ((p)->StartingSectorMsb0 << 16) + \
(ULONG) ((p)->StartingSectorMsb1 << 24) )
#define PLENGTH(p) ( \
(ULONG) ((p)->PartitionLengthLsb0) + \
(ULONG) ((p)->PartitionLengthLsb1 << 8) + \
(ULONG) ((p)->PartitionLengthMsb0 << 16) + \
(ULONG) ((p)->PartitionLengthMsb1 << 24) )
if((DriveInfo = AlAllocateHeap(sizeof(DRIVE_LAYOUT_INFORMATION) + (500*sizeof(PARTITION_INFORMATION)))) == NULL) {
return(ENOMEM);
}
p = &DriveInfo->PartitionEntry[0];
if((status = LowGetDriveGeometry(Path,&dummy,&bps,&dummy,&dummy)) != ESUCCESS) {
AlDeallocateHeap(DriveInfo);
return(status);
}
if((SectorBuffer = AlAllocateHeap(bps)) == NULL) {
AlDeallocateHeap(DriveInfo);
return(ENOMEM);
}
ptable = (PPARTITION_DESCRIPTOR)(SectorBuffer + (2*PARTITION_TABLE_OFFSET));
if((status = LowOpenDisk(Path,&Handle)) != ESUCCESS) {
AlDeallocateHeap(SectorBuffer);
AlDeallocateHeap(DriveInfo);
return(status);
}
mbr = TRUE;
Entry = 0;
BootSector = 0;
ExtendedStart = 0;
status = ESUCCESS;
do {
if((status = LowReadSectors(Handle,bps,BootSector,1,SectorBuffer)) != ESUCCESS) {
break;
}
// This is to catch the case where there is no MBR yet.
if(((PUSHORT)SectorBuffer)[BOOT_SIGNATURE_OFFSET] != BOOT_RECORD_SIGNATURE) {
break;
}
Link = FALSE;
for(i=0; i<NUM_PARTITION_TABLE_ENTRIES; i++) {
if(ptable[i].PartitionType == SYSID_UNUSED) {
// set as unused.
p[Entry].PartitionType = SYSID_UNUSED;
p[Entry].BootIndicator = FALSE;
p[Entry].RewritePartition = FALSE;
p[Entry].PartitionLength.QuadPart = 0;
p[Entry].HiddenSectors = 0;
p[Entry].StartingOffset.QuadPart = 0;
p[Entry].RecognizedPartition = FALSE;
} else {
LARGE_INTEGER Result1, Result2;
p[Entry].PartitionType = ptable[i].PartitionType;
p[Entry].BootIndicator = ptable[i].ActiveFlag;
p[Entry].RewritePartition = FALSE;
p[Entry].PartitionLength.QuadPart = UInt32x32To64(PLENGTH(ptable + i),bps);
// BUGBUG (tedm) the following are not correct for link
// entries in the extended partition.
// But fdisk does not use these values in
// this case so blow it off. As of
// 11/13/91, IoReadPartitionTable has the
// same bug.
p[Entry].HiddenSectors = PSTART(ptable + i);
Result1.QuadPart = UInt32x32To64(PSTART(ptable + i),bps);
Result2.QuadPart = UInt32x32To64(BootSector,bps);
p[Entry].StartingOffset.QuadPart = Result1.QuadPart + Result2.QuadPart;
p[Entry].RecognizedPartition = TRUE; // BUGBUG this is broken
if(p[Entry].PartitionType == SYSID_EXTENDED) {
Link = TRUE;
if(mbr) {
mbr = FALSE;
BootSector = PSTART(ptable + i);
ExtendedStart = BootSector;
} else {
BootSector = ExtendedStart + PSTART(ptable + i);
}
}
}
Entry++;
}
} while(Link);
LowCloseDisk(Handle);
AlDeallocateHeap(SectorBuffer);
if(status != ESUCCESS) {
AlDeallocateHeap(DriveInfo);
return(status);
}
// reallocate DriveInfo, set PartitionCount field.
// DriveInfo is shrinking.
DriveInfo = AlReallocateHeap(DriveInfo,
sizeof(DRIVE_LAYOUT_INFORMATION)
+ ((Entry - 1) * sizeof(PARTITION_INFORMATION))
);
DriveInfo->PartitionCount = Entry;
*DriveLayout = DriveInfo;
return(ESUCCESS);
}
//
// cylinder/head/sector stuff placed in partition table
//
typedef struct _tagCHS {
USHORT StartCylinder;
UCHAR StartHead;
UCHAR StartSector;
USHORT EndCylinder;
UCHAR EndHead;
UCHAR EndSector;
} CHS, *PCHS;
VOID
CalculateCHSVals(
IN ULONG Start,
IN ULONG Size,
IN ULONG spt,
IN ULONG h,
OUT PCHS chs
)
{
ULONG spc = spt * h; // sectors per cylinder
ULONG r;
ULONG End = Start+Size-1;
chs->StartCylinder = (USHORT)(Start/spc);
r = Start % spc;
chs->StartHead = (UCHAR)(r / spt);
chs->StartSector = (UCHAR)((r % spt) + 1); // sector is 1-based
chs->EndCylinder = (USHORT)(End/spc);
r = End % spc;
chs->EndHead = (UCHAR)(r / spt);
chs->EndSector = (UCHAR)((r % spt) + 1); // sector is 1-based
}
VOID
SetPartitionTableEntry(
IN OUT PPARTITION_DESCRIPTOR p,
IN UCHAR Active,
IN UCHAR SysID,
IN ULONG RelativeSector,
IN ULONG SectorCount,
IN PCHS chs
)
{
// first get the easy ones out of the way.
p->ActiveFlag = Active;
p->PartitionType = SysID;
if(chs) {
p->StartingTrack = chs->StartHead;
p->EndingTrack = chs->EndHead;
} else {
p->StartingTrack = 0;
p->EndingTrack = 0;
}
if(chs) {
// pack sector/cyl values
p->StartingCylinderLsb = (chs->StartSector & 0x3f) | ((chs->StartCylinder >> 2) & 0xc0);
p->StartingCylinderMsb = (UCHAR)chs->StartCylinder;
p->EndingCylinderLsb = (chs->EndSector & 0x3f) | ((chs->EndCylinder >> 2) & 0xc0);
p->EndingCylinderMsb = (UCHAR)chs->EndCylinder;
} else {
p->StartingCylinderLsb = 0;
p->StartingCylinderMsb = 0;
p->EndingCylinderLsb = 0;
p->EndingCylinderMsb = 0;
}
// now handle the relative and total sector counts
p->StartingSectorLsb0 = (UCHAR)(RelativeSector >> 0 );
p->StartingSectorLsb1 = (UCHAR)(RelativeSector >> 8 );
p->StartingSectorMsb0 = (UCHAR)(RelativeSector >> 16);
p->StartingSectorMsb1 = (UCHAR)(RelativeSector >> 24);
p->PartitionLengthLsb0 = (UCHAR)(SectorCount >> 0 );
p->PartitionLengthLsb1 = (UCHAR)(SectorCount >> 8 );
p->PartitionLengthMsb0 = (UCHAR)(SectorCount >> 16);
p->PartitionLengthMsb1 = (UCHAR)(SectorCount >> 24);
}
#define ZeroPartitionTableEntry(p) SetPartitionTableEntry(p,0,SYSID_UNUSED,0,0,NULL);
VOID
ZeroPartitionTable(
PPARTITION_DESCRIPTOR PartitionTable
)
{
ULONG i;
for(i=0; i<ENTRIES_PER_BOOTSECTOR; i++) {
ZeroPartitionTableEntry(PartitionTable+i);
}
}
ARC_STATUS
LowSetDiskLayout(
IN PCHAR Path,
IN PDRIVE_LAYOUT_INFORMATION DriveLayout
)
{
ARC_STATUS status;
ULONG dummy,bps,spt,h;
PCHAR SectorBuffer;
ULONG Handle;
PPARTITION_DESCRIPTOR PartitionTable;
PPARTITION_INFORMATION p;
BOOLEAN mbr = TRUE,Update;
ULONG BootSector = 0,ExtendedPartitionStart = 0,
NextBootSector;
ULONG i,j,UsedCount;
CHS chs;
#define SECCNT(l) ((ULONG)(((ULONGLONG)l.QuadPart)/((ULONGLONG)bps)))
ASRT(DriveLayout->PartitionCount);
if((status = LowGetDriveGeometry(Path,&dummy,&bps,&spt,&h)) != ESUCCESS) {
return(status);
}
// allocate a buffer for sector I/O
if((SectorBuffer = AlAllocateHeap(bps)) == NULL) {
return(ENOMEM);
}
//
// Use x86 bootcode as a template so the disk will boot an x86
// if it is moved to disk0 on an x86 machine.
//
RtlMoveMemory(SectorBuffer,x86BootCode,min(X86BOOTCODE_SIZE,bps));
((PUSHORT)SectorBuffer)[BOOT_SIGNATURE_OFFSET] = BOOT_RECORD_SIGNATURE;
PartitionTable = (PPARTITION_DESCRIPTOR)(&(((PUSHORT)SectorBuffer)[PARTITION_TABLE_OFFSET]));
if((status = LowOpenDisk(Path,&Handle)) != ESUCCESS) {
AlDeallocateHeap(SectorBuffer);
return(status);
}
ASRT(!(DriveLayout->PartitionCount % ENTRIES_PER_BOOTSECTOR));
for(i=0; i<DriveLayout->PartitionCount; i+=ENTRIES_PER_BOOTSECTOR) {
Update = FALSE;
UsedCount = 0;
ZeroPartitionTable(PartitionTable);
for(j=0; j<ENTRIES_PER_BOOTSECTOR; j++) {
p = &DriveLayout->PartitionEntry[i+j];
switch(p->PartitionType) {
case SYSID_UNUSED:
ZeroPartitionTableEntry(PartitionTable+j);
break;
case SYSID_EXTENDED:
NextBootSector = SECCNT(p->StartingOffset);
CalculateCHSVals(NextBootSector,SECCNT(p->PartitionLength),spt,h,&chs);
SetPartitionTableEntry(PartitionTable+j,
p->BootIndicator,
SYSID_EXTENDED,
SECCNT(p->StartingOffset) - ExtendedPartitionStart,
SECCNT(p->PartitionLength),
&chs
);
if(mbr) {
mbr = FALSE;
ExtendedPartitionStart = NextBootSector;
}
break;
default:
CalculateCHSVals(SECCNT(p->StartingOffset),SECCNT(p->PartitionLength),spt,h,&chs);
SetPartitionTableEntry(PartitionTable+j,
p->BootIndicator,
p->PartitionType,
SECCNT(p->StartingOffset) - BootSector,
SECCNT(p->PartitionLength),
&chs
);
break;
}
Update = Update || p->RewritePartition;
if(p->PartitionType != SYSID_UNUSED) {
UsedCount++;
}
}
if(Update || !UsedCount) {
if((status = LowWriteSectors(Handle,bps,BootSector,1,SectorBuffer)) != ESUCCESS) {
LowCloseDisk(Handle);
AlDeallocateHeap(SectorBuffer);
return(status);
}
}
BootSector = NextBootSector;
}
LowCloseDisk(Handle);
AlDeallocateHeap(SectorBuffer);
return(ESUCCESS);
}
