part_xbox.c File Reference

#include "halxbox.h"
#include <internal/tag.h>
#include <debug.h>

Include dependency graph for part_xbox.c:

Go to the source code of this file.

Macros
#define	NDEBUG
#define	XBOX_SIGNATURE_SECTOR   3
#define	XBOX_SIGNATURE   ('B' | ('R' << 8) | ('F' << 16) | ('R' << 24))
#define	PARTITION_SIGNATURE   0xaa55
#define	XBOX_PARTITION_COUNT   (sizeof(XboxPartitions) / sizeof(XboxPartitions[0]))
#define	HalExamineMBR   HALDISPATCH->HalExamineMBR
#define	HalIoReadPartitionTable   HALDISPATCH->HalIoReadPartitionTable
#define	HalIoSetPartitionInformation   HALDISPATCH->HalIoSetPartitionInformation
#define	HalIoWritePartitionTable   HALDISPATCH->HalIoWritePartitionTable

Functions
static NTSTATUS	HalpXboxReadSector (IN PDEVICE_OBJECT DeviceObject, IN ULONG SectorSize, IN PLARGE_INTEGER SectorOffset, OUT PVOID Sector)
static NTSTATUS FASTCALL	HalpXboxDeviceHasXboxPartitioning (IN PDEVICE_OBJECT DeviceObject, IN ULONG SectorSize, OUT BOOLEAN *HasXboxPartitioning)
static VOID FASTCALL	HalpXboxExamineMBR (IN PDEVICE_OBJECT DeviceObject, IN ULONG SectorSize, IN ULONG MBRTypeIdentifier, OUT PVOID *Buffer)
static NTSTATUS FASTCALL	HalpXboxIoReadPartitionTable (IN PDEVICE_OBJECT DeviceObject, IN ULONG SectorSize, IN BOOLEAN ReturnRecognizedPartitions, OUT PDRIVE_LAYOUT_INFORMATION *PartitionBuffer)
static NTSTATUS FASTCALL	HalpXboxIoSetPartitionInformation (IN PDEVICE_OBJECT DeviceObject, IN ULONG SectorSize, IN ULONG PartitionNumber, IN ULONG PartitionType)
static NTSTATUS FASTCALL	HalpXboxIoWritePartitionTable (IN PDEVICE_OBJECT DeviceObject, IN ULONG SectorSize, IN ULONG SectorsPerTrack, IN ULONG NumberOfHeads, IN PDRIVE_LAYOUT_INFORMATION PartitionBuffer)
void	HalpXboxInitPartIo (void)

Variables
static pHalExamineMBR	NtoskrnlExamineMBR
static pHalIoReadPartitionTable	NtoskrnlIoReadPartitionTable
static pHalIoSetPartitionInformation	NtoskrnlIoSetPartitionInformation
static pHalIoWritePartitionTable	NtoskrnlIoWritePartitionTable
struct {
ULONG   SectorStart
ULONG   SectorCount
CHAR   PartitionType
}	XboxPartitions []

Macro Definition Documentation

HalExamineMBR

#define HalExamineMBR   HALDISPATCH->HalExamineMBR

Definition at line 325 of file part_xbox.c.

HalIoReadPartitionTable

#define HalIoReadPartitionTable   HALDISPATCH->HalIoReadPartitionTable

Definition at line 326 of file part_xbox.c.

HalIoSetPartitionInformation

#define HalIoSetPartitionInformation   HALDISPATCH->HalIoSetPartitionInformation

Definition at line 327 of file part_xbox.c.

HalIoWritePartitionTable

#define HalIoWritePartitionTable   HALDISPATCH->HalIoWritePartitionTable

Definition at line 328 of file part_xbox.c.

NDEBUG

#define NDEBUG

Definition at line 14 of file part_xbox.c.

PARTITION_SIGNATURE

#define PARTITION_SIGNATURE   0xaa55

Definition at line 19 of file part_xbox.c.

XBOX_PARTITION_COUNT

#define XBOX_PARTITION_COUNT   (sizeof(XboxPartitions) / sizeof(XboxPartitions[0]))

Definition at line 43 of file part_xbox.c.

XBOX_SIGNATURE

#define XBOX_SIGNATURE   ('B' | ('R' << 8) | ('F' << 16) | ('R' << 24))

Definition at line 18 of file part_xbox.c.

XBOX_SIGNATURE_SECTOR

#define XBOX_SIGNATURE_SECTOR   3

Definition at line 17 of file part_xbox.c.

Function Documentation

HalpXboxDeviceHasXboxPartitioning()

static NTSTATUS FASTCALL HalpXboxDeviceHasXboxPartitioning ( IN PDEVICE_OBJECT  DeviceObject, IN ULONG  SectorSize, OUT BOOLEAN *  HasXboxPartitioning  )

static

Definition at line 101 of file part_xbox.c.

{
    PVOID SectorData;
    LARGE_INTEGER Offset;
    NTSTATUS Status;
    BOOLEAN HasMBRPartitioning;
 
    DPRINT("HalpXboxDeviceHasXboxPartitioning(%p %lu %p)\n",
           DeviceObject,
           SectorSize,
           HasXboxPartitioning);
 
    SectorData = ExAllocatePoolWithTag(PagedPool, SectorSize, TAG_HAL_XBOX);
    if (!SectorData)
    {
        return STATUS_NO_MEMORY;
    }
 
    Offset.QuadPart = 0;
    Status = HalpXboxReadSector(DeviceObject, SectorSize, &Offset, SectorData);
    if (!NT_SUCCESS(Status))
    {
        goto Cleanup;
    }
 
    HasMBRPartitioning = (*((USHORT *)SectorData + (SectorSize / sizeof(USHORT)) - 1) == PARTITION_SIGNATURE);
    if (HasMBRPartitioning)
    {
        *HasXboxPartitioning = FALSE;
        goto Cleanup;
    }
 
    Offset.QuadPart = XBOX_SIGNATURE_SECTOR * SectorSize;
    Status = HalpXboxReadSector(DeviceObject, SectorSize, &Offset, SectorData);
    if (!NT_SUCCESS(Status))
    {
        goto Cleanup;
    }
 
    DPRINT("Signature 0x%02x 0x%02x 0x%02x 0x%02x\n",
           *((UCHAR *) SectorData), *((UCHAR *) SectorData + 1), *((UCHAR *) SectorData + 2), *((UCHAR *) SectorData + 3));
    *HasXboxPartitioning = (XBOX_SIGNATURE == *((ULONG *) SectorData));
Cleanup:
    ExFreePoolWithTag(SectorData, TAG_HAL_XBOX);
    if (NT_SUCCESS(Status))
    {
        DPRINT("%s partitioning found\n", *HasXboxPartitioning ? "Xbox" : "MBR");
    }
 
    return Status;
}

Referenced by HalpXboxExamineMBR(), HalpXboxIoReadPartitionTable(), HalpXboxIoSetPartitionInformation(), and HalpXboxIoWritePartitionTable().

HalpXboxExamineMBR()

static VOID FASTCALL HalpXboxExamineMBR ( IN PDEVICE_OBJECT  DeviceObject, IN ULONG  SectorSize, IN ULONG  MBRTypeIdentifier, OUT PVOID *  Buffer  )

static

Definition at line 156 of file part_xbox.c.

{
    BOOLEAN HasXboxPartitioning;
    NTSTATUS Status;
 
    DPRINT("HalpXboxExamineMBR(%p %lu %lx %p)\n",
           DeviceObject,
           SectorSize,
           MBRTypeIdentifier,
           Buffer);
 
    *Buffer = NULL;
 
    Status = HalpXboxDeviceHasXboxPartitioning(DeviceObject, SectorSize, &HasXboxPartitioning);
    if (!NT_SUCCESS(Status))
    {
        return;
    }
 
    if (!HasXboxPartitioning)
    {
        DPRINT("Delegating to standard MBR code\n");
        NtoskrnlExamineMBR(DeviceObject, SectorSize, MBRTypeIdentifier, Buffer);
        return;
    }
 
    /* Buffer already set to NULL */
    return;
}

Referenced by HalpXboxInitPartIo().

HalpXboxInitPartIo()

void HalpXboxInitPartIo

(

void

)

Definition at line 331 of file part_xbox.c.

{
    NtoskrnlExamineMBR = HalExamineMBR;
    HalExamineMBR = HalpXboxExamineMBR;
    NtoskrnlIoReadPartitionTable = HalIoReadPartitionTable;
    HalIoReadPartitionTable = HalpXboxIoReadPartitionTable;
    NtoskrnlIoSetPartitionInformation = HalIoSetPartitionInformation;
    HalIoSetPartitionInformation = HalpXboxIoSetPartitionInformation;
    NtoskrnlIoWritePartitionTable = HalIoWritePartitionTable;
    HalIoWritePartitionTable = HalpXboxIoWritePartitionTable;
}

Referenced by HalpInitPhase0().

HalpXboxIoReadPartitionTable()

static NTSTATUS FASTCALL HalpXboxIoReadPartitionTable ( IN PDEVICE_OBJECT  DeviceObject, IN ULONG  SectorSize, IN BOOLEAN  ReturnRecognizedPartitions, OUT PDRIVE_LAYOUT_INFORMATION *  PartitionBuffer  )

static

Definition at line 190 of file part_xbox.c.

{
    BOOLEAN HasXboxPartitioning;
    NTSTATUS Status;
    ULONG Part;
    PPARTITION_INFORMATION PartInfo;
 
    DPRINT("HalpXboxIoReadPartitionTable(%p %lu %x %p)\n",
           DeviceObject,
           SectorSize,
           ReturnRecognizedPartitions,
           PartitionBuffer);
 
    Status = HalpXboxDeviceHasXboxPartitioning(DeviceObject, SectorSize, &HasXboxPartitioning);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    if (!HasXboxPartitioning)
    {
        DPRINT("Delegating to standard MBR code\n");
        return NtoskrnlIoReadPartitionTable(DeviceObject, SectorSize,
                                            ReturnRecognizedPartitions, PartitionBuffer);
    }
 
    *PartitionBuffer = (PDRIVE_LAYOUT_INFORMATION)ExAllocatePoolWithTag(
                        PagedPool,
                        sizeof(DRIVE_LAYOUT_INFORMATION) +
                        XBOX_PARTITION_COUNT * sizeof(PARTITION_INFORMATION),
                        TAG_FILE_SYSTEM);
    if (*PartitionBuffer == NULL)
    {
        return STATUS_NO_MEMORY;
    }
    (*PartitionBuffer)->PartitionCount = XBOX_PARTITION_COUNT;
    (*PartitionBuffer)->Signature = PARTITION_SIGNATURE;
    for (Part = 0; Part < XBOX_PARTITION_COUNT; Part++)
    {
        PartInfo = (*PartitionBuffer)->PartitionEntry + Part;
        PartInfo->StartingOffset.QuadPart = (ULONGLONG) XboxPartitions[Part].SectorStart *
                                            (ULONGLONG) SectorSize;
        PartInfo->PartitionLength.QuadPart = (ULONGLONG) XboxPartitions[Part].SectorCount *
                                             (ULONGLONG) SectorSize;
        PartInfo->HiddenSectors = 0;
        PartInfo->PartitionNumber = Part + 1;
        PartInfo->PartitionType = XboxPartitions[Part].PartitionType;
        PartInfo->BootIndicator = FALSE;
        PartInfo->RecognizedPartition = TRUE;
        PartInfo->RewritePartition = FALSE;
        DPRINT(" %ld: nr: %d boot: %1x type: %x start: 0x%I64x count: 0x%I64x rec: %d\n",
               Part,
               PartInfo->PartitionNumber,
               PartInfo->BootIndicator,
               PartInfo->PartitionType,
               PartInfo->StartingOffset.QuadPart,
               PartInfo->PartitionLength.QuadPart,
               PartInfo->RecognizedPartition);
    }
 
    return STATUS_SUCCESS;
}

Referenced by HalpXboxInitPartIo().

HalpXboxIoSetPartitionInformation()

static NTSTATUS FASTCALL HalpXboxIoSetPartitionInformation ( IN PDEVICE_OBJECT  DeviceObject, IN ULONG  SectorSize, IN ULONG  PartitionNumber, IN ULONG  PartitionType  )

static

Definition at line 257 of file part_xbox.c.

{
    BOOLEAN HasXboxPartitioning;
    NTSTATUS Status;
 
    DPRINT("HalpXboxIoSetPartitionInformation(%p %lu %lu %lu)\n",
           DeviceObject,
           SectorSize,
           PartitionNumber,
           PartitionType);
 
    Status = HalpXboxDeviceHasXboxPartitioning(DeviceObject, SectorSize, &HasXboxPartitioning);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    if (!HasXboxPartitioning)
    {
        DPRINT("Delegating to standard MBR code\n");
        return NtoskrnlIoSetPartitionInformation(DeviceObject, SectorSize,
                                                 PartitionNumber, PartitionType);
    }
 
    /* Can't change the partitioning */
    DPRINT1("Xbox partitions are fixed, can't change them\n");
    return STATUS_ACCESS_DENIED;
}

Referenced by HalpXboxInitPartIo().

HalpXboxIoWritePartitionTable()

static NTSTATUS FASTCALL HalpXboxIoWritePartitionTable ( IN PDEVICE_OBJECT  DeviceObject, IN ULONG  SectorSize, IN ULONG  SectorsPerTrack, IN ULONG  NumberOfHeads, IN PDRIVE_LAYOUT_INFORMATION  PartitionBuffer  )

static

Definition at line 290 of file part_xbox.c.

{
    BOOLEAN HasXboxPartitioning;
    NTSTATUS Status;
 
    DPRINT("HalpXboxIoWritePartitionTable(%p %lu %lu %lu %p)\n",
           DeviceObject,
           SectorSize,
           SectorsPerTrack,
           NumberOfHeads,
           PartitionBuffer);
 
    Status = HalpXboxDeviceHasXboxPartitioning(DeviceObject, SectorSize, &HasXboxPartitioning);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    if (!HasXboxPartitioning)
    {
        DPRINT("Delegating to standard MBR code\n");
        return NtoskrnlIoWritePartitionTable(DeviceObject, SectorSize,
                                             SectorsPerTrack, NumberOfHeads,
                                             PartitionBuffer);
    }
 
    /* Can't change the partitioning */
    DPRINT1("Xbox partitions are fixed, can't change them\n");
    return STATUS_ACCESS_DENIED;
}

Referenced by HalpXboxInitPartIo().

HalpXboxReadSector()

static NTSTATUS HalpXboxReadSector ( IN PDEVICE_OBJECT  DeviceObject, IN ULONG  SectorSize, IN PLARGE_INTEGER  SectorOffset, OUT PVOID  Sector  )

static

Definition at line 49 of file part_xbox.c.

{
    IO_STATUS_BLOCK StatusBlock;
    KEVENT Event;
    PIRP Irp;
    NTSTATUS Status;
 
    DPRINT("HalpXboxReadSector(%p %lu 0x%08x%08x %p)\n",
           DeviceObject, SectorSize, SectorOffset->u.HighPart, SectorOffset->u.LowPart, Sector);
 
    ASSERT(DeviceObject);
    ASSERT(Sector);
 
    KeInitializeEvent(&Event,
                      NotificationEvent,
                      FALSE);
 
    /* Read the sector */
    Irp = IoBuildSynchronousFsdRequest(IRP_MJ_READ,
                                       DeviceObject,
                                       Sector,
                                       SectorSize,
                                       SectorOffset,
                                       &Event,
                                       &StatusBlock);
    if (!Irp) return STATUS_INSUFFICIENT_RESOURCES;
 
    Status = IoCallDriver(DeviceObject,
                          Irp);
    if (Status == STATUS_PENDING)
    {
        KeWaitForSingleObject(&Event,
                              Executive,
                              KernelMode,
                              FALSE,
                              NULL);
        Status = StatusBlock.Status;
    }
 
    if (!NT_SUCCESS(Status))
    {
        DPRINT("Reading sector failed (Status 0x%08lx)\n", Status);
        return Status;
    }
 
    return Status;
}

Referenced by HalpXboxDeviceHasXboxPartitioning().

Variable Documentation

NtoskrnlExamineMBR

pHalExamineMBR NtoskrnlExamineMBR

static

Definition at line 23 of file part_xbox.c.

Referenced by HalpXboxExamineMBR(), and HalpXboxInitPartIo().

NtoskrnlIoReadPartitionTable

pHalIoReadPartitionTable NtoskrnlIoReadPartitionTable

static

Definition at line 24 of file part_xbox.c.

Referenced by HalpXboxInitPartIo(), and HalpXboxIoReadPartitionTable().

NtoskrnlIoSetPartitionInformation

pHalIoSetPartitionInformation NtoskrnlIoSetPartitionInformation

static

Definition at line 25 of file part_xbox.c.

Referenced by HalpXboxInitPartIo(), and HalpXboxIoSetPartitionInformation().

NtoskrnlIoWritePartitionTable

pHalIoWritePartitionTable NtoskrnlIoWritePartitionTable

static

Definition at line 26 of file part_xbox.c.

Referenced by HalpXboxInitPartIo(), and HalpXboxIoWritePartitionTable().

PartitionType

CHAR PartitionType

Definition at line 32 of file part_xbox.c.

Referenced by HalpXboxIoSetPartitionInformation().

SectorCount

ULONG SectorCount

Definition at line 31 of file part_xbox.c.

Referenced by HalpXboxIoReadPartitionTable().

SectorStart

ULONG SectorStart

Definition at line 30 of file part_xbox.c.

Referenced by HalpXboxIoReadPartitionTable().

struct { ... } XboxPartitions[]

Initial value:

=
{
    
    { 0x0055F400, 0x0098f800, PARTITION_FAT32  }, 
    { 0x00465400, 0x000FA000, PARTITION_FAT_16 }, 
    { 0x00000400, 0x00177000, PARTITION_FAT_16 }, 
    { 0x00177400, 0x00177000, PARTITION_FAT_16 }, 
    { 0x002EE400, 0x00177000, PARTITION_FAT_16 }  
}

Referenced by HalpXboxIoReadPartitionTable().