ReactOS  0.4.15-dev-2502-g9f3ed60
partlist.h File Reference
#include <pshpack1.h>
#include <poppack.h>
Include dependency graph for partlist.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

struct  _PARTENTRY
 
struct  _DISKENTRY
 
struct  _BIOSDISKENTRY
 
struct  _PARTLIST
 
struct  _PARTITION
 
struct  _PARTITION_SECTOR
 
struct  BIOS_DISK
 

Macros

#define PARTITION_EISA   0x12
 
#define PARTITION_HIBERNATION   0x84
 
#define PARTITION_DIAGNOSTIC   0xA0
 
#define PARTITION_DELL   0xDE
 
#define PARTITION_IBM   0xFE
 
#define IsOEMPartition(PartitionType)
 
#define PARTITION_TBL_SIZE   4
 
#define PARTITION_MAGIC   0xAA55
 
#define EFI_PMBR_OSTYPE_EFI   0xEE
 

Typedefs

typedef enum _FORMATSTATE FORMATSTATE
 
typedef enum _FORMATSTATEPFORMATSTATE
 
typedef struct _PARTENTRY PARTENTRY
 
typedef struct _PARTENTRYPPARTENTRY
 
typedef struct _DISKENTRY DISKENTRY
 
typedef struct _DISKENTRYPDISKENTRY
 
typedef struct _BIOSDISKENTRY BIOSDISKENTRY
 
typedef struct _BIOSDISKENTRYPBIOSDISKENTRY
 
typedef struct _PARTLIST PARTLIST
 
typedef struct _PARTLISTPPARTLIST
 
typedef struct _PARTITION PARTITION
 
typedef struct _PARTITIONPPARTITION
 
typedef struct _PARTITION_SECTOR PARTITION_SECTOR
 
typedef struct _PARTITION_SECTORPPARTITION_SECTOR
 
typedef struct BIOS_DISKPBIOS_DISK
 

Enumerations

enum  _FORMATSTATE {
  Unformatted, UnformattedOrDamaged, UnknownFormat, Preformatted,
  Formatted, Unformatted, UnformattedOrDamaged, UnknownFormat,
  Preformatted, Formatted
}
 

Functions

ULONGLONG AlignDown (IN ULONGLONG Value, IN ULONG Alignment)
 
ULONGLONG AlignUp (IN ULONGLONG Value, IN ULONG Alignment)
 
ULONGLONG RoundingDivide (IN ULONGLONG Dividend, IN ULONGLONG Divisor)
 
BOOLEAN IsSuperFloppy (IN PDISKENTRY DiskEntry)
 
BOOLEAN IsPartitionActive (IN PPARTENTRY PartEntry)
 
PPARTLIST CreatePartitionList (VOID)
 
VOID DestroyPartitionList (IN PPARTLIST List)
 
PDISKENTRY GetDiskByBiosNumber (IN PPARTLIST List, IN ULONG HwDiskNumber)
 
PDISKENTRY GetDiskByNumber (IN PPARTLIST List, IN ULONG DiskNumber)
 
PDISKENTRY GetDiskBySCSI (IN PPARTLIST List, IN USHORT Port, IN USHORT Bus, IN USHORT Id)
 
PDISKENTRY GetDiskBySignature (IN PPARTLIST List, IN ULONG Signature)
 
PPARTENTRY GetPartition (IN PDISKENTRY DiskEntry, IN ULONG PartitionNumber)
 
BOOLEAN GetDiskOrPartition (IN PPARTLIST List, IN ULONG DiskNumber, IN ULONG PartitionNumber OPTIONAL, OUT PDISKENTRY *pDiskEntry, OUT PPARTENTRY *pPartEntry OPTIONAL)
 
PPARTENTRY SelectPartition (IN PPARTLIST List, IN ULONG DiskNumber, IN ULONG PartitionNumber)
 
PPARTENTRY GetNextPartition (IN PPARTLIST List, IN PPARTENTRY CurrentPart OPTIONAL)
 
PPARTENTRY GetPrevPartition (IN PPARTLIST List, IN PPARTENTRY CurrentPart OPTIONAL)
 
BOOLEAN CreatePrimaryPartition (IN PPARTLIST List, IN OUT PPARTENTRY PartEntry, IN ULONGLONG SectorCount, IN BOOLEAN AutoCreate)
 
BOOLEAN CreateExtendedPartition (IN PPARTLIST List, IN OUT PPARTENTRY PartEntry, IN ULONGLONG SectorCount)
 
BOOLEAN CreateLogicalPartition (IN PPARTLIST List, IN OUT PPARTENTRY PartEntry, IN ULONGLONG SectorCount, IN BOOLEAN AutoCreate)
 
NTSTATUS DismountVolume (IN PPARTENTRY PartEntry)
 
BOOLEAN DeletePartition (IN PPARTLIST List, IN PPARTENTRY PartEntry, OUT PPARTENTRY *FreeRegion OPTIONAL)
 
PPARTENTRY FindSupportedSystemPartition (IN PPARTLIST List, IN BOOLEAN ForceSelect, IN PDISKENTRY AlternativeDisk OPTIONAL, IN PPARTENTRY AlternativePart OPTIONAL)
 
BOOLEAN SetActivePartition (IN PPARTLIST List, IN PPARTENTRY PartEntry, IN PPARTENTRY OldActivePart OPTIONAL)
 
NTSTATUS WritePartitions (IN PDISKENTRY DiskEntry)
 
BOOLEAN WritePartitionsToDisk (IN PPARTLIST List)
 
BOOLEAN SetMountedDeviceValue (IN WCHAR Letter, IN ULONG Signature, IN LARGE_INTEGER StartingOffset)
 
BOOLEAN SetMountedDeviceValues (IN PPARTLIST List)
 
VOID SetMBRPartitionType (IN PPARTENTRY PartEntry, IN UCHAR PartitionType)
 
ERROR_NUMBER PrimaryPartitionCreationChecks (IN PPARTENTRY PartEntry)
 
ERROR_NUMBER ExtendedPartitionCreationChecks (IN PPARTENTRY PartEntry)
 
ERROR_NUMBER LogicalPartitionCreationChecks (IN PPARTENTRY PartEntry)
 
BOOLEAN GetNextUnformattedPartition (IN PPARTLIST List, OUT PDISKENTRY *pDiskEntry OPTIONAL, OUT PPARTENTRY *pPartEntry)
 
BOOLEAN GetNextUncheckedPartition (IN PPARTLIST List, OUT PDISKENTRY *pDiskEntry OPTIONAL, OUT PPARTENTRY *pPartEntry)
 

Macro Definition Documentation

◆ EFI_PMBR_OSTYPE_EFI

#define EFI_PMBR_OSTYPE_EFI   0xEE

Definition at line 175 of file partlist.h.

◆ IsOEMPartition

#define IsOEMPartition (   PartitionType)
Value:
#define PARTITION_EISA
Definition: partlist.h:16
#define PARTITION_IBM
Definition: partlist.h:20
#define PARTITION_HIBERNATION
Definition: partlist.h:17
#define PARTITION_DELL
Definition: partlist.h:19
CHAR PartitionType
Definition: part_xbox.c:32
#define PARTITION_DIAGNOSTIC
Definition: partlist.h:18

Definition at line 22 of file partlist.h.

◆ PARTITION_DELL

#define PARTITION_DELL   0xDE

Definition at line 19 of file partlist.h.

◆ PARTITION_DIAGNOSTIC

#define PARTITION_DIAGNOSTIC   0xA0

Definition at line 18 of file partlist.h.

◆ PARTITION_EISA

#define PARTITION_EISA   0x12

Definition at line 16 of file partlist.h.

◆ PARTITION_HIBERNATION

#define PARTITION_HIBERNATION   0x84

Definition at line 17 of file partlist.h.

◆ PARTITION_IBM

#define PARTITION_IBM   0xFE

Definition at line 20 of file partlist.h.

◆ PARTITION_MAGIC

#define PARTITION_MAGIC   0xAA55

Definition at line 172 of file partlist.h.

◆ PARTITION_TBL_SIZE

#define PARTITION_TBL_SIZE   4

Definition at line 170 of file partlist.h.

Typedef Documentation

◆ BIOSDISKENTRY

◆ DISKENTRY

◆ FORMATSTATE

◆ PARTENTRY

◆ PARTITION

◆ PARTITION_SECTOR

◆ PARTLIST

◆ PBIOS_DISK

◆ PBIOSDISKENTRY

◆ PDISKENTRY

◆ PFORMATSTATE

◆ PPARTENTRY

◆ PPARTITION

◆ PPARTITION_SECTOR

◆ PPARTLIST

Enumeration Type Documentation

◆ _FORMATSTATE

Enumerator
Unformatted 
UnformattedOrDamaged 
UnknownFormat 
Preformatted 
Formatted 
Unformatted 
UnformattedOrDamaged 
UnknownFormat 
Preformatted 
Formatted 

Definition at line 32 of file partlist.h.

33 {
38  Formatted
enum _FORMATSTATE FORMATSTATE
enum _FORMATSTATE * PFORMATSTATE

Function Documentation

◆ AlignDown()

ULONGLONG AlignDown ( IN ULONGLONG  Value,
IN ULONG  Alignment 
)

Definition at line 67 of file partlist.c.

70 {
71  ULONGLONG Temp;
72 
73  Temp = Value / Alignment;
74 
75  return Temp * Alignment;
76 }
union Alignment_ Alignment
_Must_inspect_result_ _In_ WDFKEY _In_ PCUNICODE_STRING _Out_opt_ PUSHORT _Inout_opt_ PUNICODE_STRING Value
Definition: wdfregistry.h:406
uint64_t ULONGLONG
Definition: typedefs.h:67

Referenced by InitializePartitionEntry(), and ScanForUnpartitionedDiskSpace().

◆ AlignUp()

ULONGLONG AlignUp ( IN ULONGLONG  Value,
IN ULONG  Alignment 
)

Definition at line 79 of file partlist.c.

82 {
83  ULONGLONG Temp, Result;
84 
85  Temp = Value / Alignment;
86 
87  Result = Temp * Alignment;
88  if (Value % Alignment)
89  Result += Alignment;
90 
91  return Result;
92 }
union Alignment_ Alignment
_At_(*)(_In_ PWSK_CLIENT Client, _In_opt_ PUNICODE_STRING NodeName, _In_opt_ PUNICODE_STRING ServiceName, _In_opt_ ULONG NameSpace, _In_opt_ GUID *Provider, _In_opt_ PADDRINFOEXW Hints, _Outptr_ PADDRINFOEXW *Result, _In_opt_ PEPROCESS OwningProcess, _In_opt_ PETHREAD OwningThread, _Inout_ PIRP Irp Result)(Mem)) NTSTATUS(WSKAPI *PFN_WSK_GET_ADDRESS_INFO
Definition: wsk.h:426
_Must_inspect_result_ _In_ WDFKEY _In_ PCUNICODE_STRING _Out_opt_ PUSHORT _Inout_opt_ PUNICODE_STRING Value
Definition: wdfregistry.h:406
uint64_t ULONGLONG
Definition: typedefs.h:67

Referenced by PeFmtCreateSection().

◆ CreateExtendedPartition()

BOOLEAN CreateExtendedPartition ( IN PPARTLIST  List,
IN OUT PPARTENTRY  PartEntry,
IN ULONGLONG  SectorCount 
)

Definition at line 2850 of file partlist.c.

2854 {
2856 
2857  DPRINT1("CreateExtendedPartition(%I64u)\n", SectorCount);
2858 
2859  if (List == NULL || PartEntry == NULL ||
2860  PartEntry->DiskEntry == NULL || PartEntry->IsPartitioned)
2861  {
2862  return FALSE;
2863  }
2864 
2866  if (Error != NOT_AN_ERROR)
2867  {
2868  DPRINT1("ExtendedPartitionCreationChecks() failed with error %lu\n", Error);
2869  return FALSE;
2870  }
2871 
2872  /* Initialize the partition entry, inserting a new blank region if needed */
2873  if (!InitializePartitionEntry(PartEntry, SectorCount, FALSE))
2874  return FALSE;
2875 
2876  ASSERT(PartEntry->LogicalPartition == FALSE);
2877 
2878  if (PartEntry->StartSector.QuadPart < 1450560)
2879  {
2880  /* Partition starts below the 8.4GB boundary ==> CHS partition */
2881  PartEntry->PartitionType = PARTITION_EXTENDED;
2882  }
2883  else
2884  {
2885  /* Partition starts above the 8.4GB boundary ==> LBA partition */
2886  PartEntry->PartitionType = PARTITION_XINT13_EXTENDED;
2887  }
2888 
2889  // FIXME? Possibly to make GetNextUnformattedPartition work (i.e. skip the extended partition container)
2890  PartEntry->New = FALSE;
2891  PartEntry->FormatState = Formatted;
2892 
2893  PartEntry->DiskEntry->ExtendedPartition = PartEntry;
2894 
2895  AddLogicalDiskSpace(PartEntry->DiskEntry);
2896 
2897  UpdateDiskLayout(PartEntry->DiskEntry);
2899 
2900  return TRUE;
2901 }
ERROR_NUMBER ExtendedPartitionCreationChecks(IN PPARTENTRY PartEntry)
Definition: partlist.c:3981
#define TRUE
Definition: types.h:120
static BOOLEAN InitializePartitionEntry(IN OUT PPARTENTRY PartEntry, IN ULONGLONG SectorCount, IN BOOLEAN AutoCreate)
Definition: partlist.c:678
#define FALSE
Definition: types.h:117
static VOID UpdateDiskLayout(IN PDISKENTRY DiskEntry)
Definition: partlist.c:2534
#define PARTITION_EXTENDED
Definition: disk.h:91
#define ASSERT(a)
Definition: mode.c:45
BOOL Error
Definition: chkdsk.c:66
enum _ERROR_NUMBER ERROR_NUMBER
_Must_inspect_result_ _In_ WDFCMRESLIST List
Definition: wdfresource.h:550
ULONG SectorCount
Definition: part_xbox.c:31
#define PARTITION_XINT13_EXTENDED
Definition: disk.h:98
#define NULL
Definition: types.h:112
#define DPRINT1
Definition: precomp.h:8
static VOID AddLogicalDiskSpace(IN PDISKENTRY DiskEntry)
Definition: partlist.c:2823
static VOID AssignDriveLetters(IN PPARTLIST List)
Definition: partlist.c:138

Referenced by CreateExtendedPartitionPage().

◆ CreateLogicalPartition()

BOOLEAN CreateLogicalPartition ( IN PPARTLIST  List,
IN OUT PPARTENTRY  PartEntry,
IN ULONGLONG  SectorCount,
IN BOOLEAN  AutoCreate 
)

Definition at line 2904 of file partlist.c.

2909 {
2911 
2912  DPRINT1("CreateLogicalPartition(%I64u)\n", SectorCount);
2913 
2914  if (List == NULL || PartEntry == NULL ||
2915  PartEntry->DiskEntry == NULL || PartEntry->IsPartitioned)
2916  {
2917  return FALSE;
2918  }
2919 
2921  if (Error != NOT_AN_ERROR)
2922  {
2923  DPRINT1("LogicalPartitionCreationChecks() failed with error %lu\n", Error);
2924  return FALSE;
2925  }
2926 
2927  /* Initialize the partition entry, inserting a new blank region if needed */
2928  if (!InitializePartitionEntry(PartEntry, SectorCount, AutoCreate))
2929  return FALSE;
2930 
2931  ASSERT(PartEntry->LogicalPartition == TRUE);
2932 
2933  UpdateDiskLayout(PartEntry->DiskEntry);
2935 
2936  return TRUE;
2937 }
#define TRUE
Definition: types.h:120
ERROR_NUMBER LogicalPartitionCreationChecks(IN PPARTENTRY PartEntry)
Definition: partlist.c:4012
static BOOLEAN InitializePartitionEntry(IN OUT PPARTENTRY PartEntry, IN ULONGLONG SectorCount, IN BOOLEAN AutoCreate)
Definition: partlist.c:678
#define FALSE
Definition: types.h:117
static VOID UpdateDiskLayout(IN PDISKENTRY DiskEntry)
Definition: partlist.c:2534
#define ASSERT(a)
Definition: mode.c:45
BOOL Error
Definition: chkdsk.c:66
enum _ERROR_NUMBER ERROR_NUMBER
_Must_inspect_result_ _In_ WDFCMRESLIST List
Definition: wdfresource.h:550
ULONG SectorCount
Definition: part_xbox.c:31
#define NULL
Definition: types.h:112
#define DPRINT1
Definition: precomp.h:8
static VOID AssignDriveLetters(IN PPARTLIST List)
Definition: partlist.c:138

Referenced by CreateLogicalPartitionPage(), and SelectPartitionPage().

◆ CreatePartitionList()

PPARTLIST CreatePartitionList ( VOID  )

Definition at line 1847 of file partlist.c.

1848 {
1849  PPARTLIST List;
1850  PDISKENTRY SystemDisk;
1854  ULONG ReturnSize;
1855  NTSTATUS Status;
1856  ULONG DiskNumber;
1860 
1862  0,
1863  sizeof(PARTLIST));
1864  if (List == NULL)
1865  return NULL;
1866 
1867  List->SystemPartition = NULL;
1868 
1869  InitializeListHead(&List->DiskListHead);
1870  InitializeListHead(&List->BiosDiskListHead);
1871 
1872  /*
1873  * Enumerate the disks seen by the BIOS; this will be used later
1874  * to map drives seen by NTOS with their corresponding BIOS names.
1875  */
1877 
1878  /* Enumerate disks seen by NTOS */
1880  &Sdi,
1881  sizeof(Sdi),
1882  &ReturnSize);
1883  if (!NT_SUCCESS(Status))
1884  {
1885  DPRINT1("NtQuerySystemInformation() failed, Status 0x%08lx", Status);
1887  return NULL;
1888  }
1889 
1890  for (DiskNumber = 0; DiskNumber < Sdi.NumberOfDisks; DiskNumber++)
1891  {
1893  L"\\Device\\Harddisk%lu\\Partition0",
1894  DiskNumber);
1896 
1898  &Name,
1900  NULL,
1901  NULL);
1902 
1906  &Iosb,
1909  if (NT_SUCCESS(Status))
1910  {
1911  AddDiskToList(FileHandle, DiskNumber, List);
1913  }
1914  }
1915 
1919 
1920  /*
1921  * Retrieve the system partition: the active partition on the system
1922  * disk (the one that will be booted by default by the hardware).
1923  */
1924  SystemDisk = GetSystemDisk(List);
1925  List->SystemPartition = (SystemDisk ? GetActiveDiskPartition(SystemDisk) : NULL);
1926 
1927  return List;
1928 }
IN PUNICODE_STRING IN POBJECT_ATTRIBUTES ObjectAttributes
Definition: conport.c:35
NTSYSAPI NTSTATUS NTAPI NtQuerySystemInformation(IN SYSTEM_INFORMATION_CLASS SystemInfoClass, OUT PVOID SystemInfoBuffer, IN ULONG SystemInfoBufferSize, OUT PULONG BytesReturned OPTIONAL)
struct _PARTLIST * PPARTLIST
#define OBJ_CASE_INSENSITIVE
Definition: winternl.h:228
static PPARTENTRY GetActiveDiskPartition(IN PDISKENTRY DiskEntry)
Definition: partlist.c:1791
NTSTRSAFEVAPI RtlStringCchPrintfW(_Out_writes_(cchDest) _Always_(_Post_z_) NTSTRSAFE_PWSTR pszDest, _In_ size_t cchDest, _In_ _Printf_format_string_ NTSTRSAFE_PCWSTR pszFormat,...)
Definition: ntstrsafe.h:1110
LONG NTSTATUS
Definition: precomp.h:26
BOOLEAN NTAPI RtlFreeHeap(IN PVOID HeapHandle, IN ULONG Flags, IN PVOID HeapBase)
Definition: heap.c:606
#define ARRAYSIZE(array)
Definition: filtermapper.c:47
#define FILE_SHARE_WRITE
Definition: nt_native.h:681
static VOID UpdateDiskSignatures(IN PPARTLIST List)
Definition: partlist.c:1215
#define FILE_SHARE_READ
Definition: compat.h:136
HANDLE FileHandle
Definition: stats.c:38
#define FILE_READ_DATA
Definition: nt_native.h:628
struct NameRec_ * Name
Definition: cdprocs.h:459
Definition: bufpool.h:45
PVOID NTAPI RtlAllocateHeap(IN PVOID HeapHandle, IN ULONG Flags, IN SIZE_T Size)
Definition: heap.c:588
Status
Definition: gdiplustypes.h:24
NTSYSAPI NTSTATUS NTAPI NtOpenFile(OUT PHANDLE phFile, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes, OUT PIO_STATUS_BLOCK pIoStatusBlock, IN ULONG ShareMode, IN ULONG OpenMode)
Definition: file.c:3951
__wchar_t WCHAR
Definition: xmlstorage.h:180
return Iosb
Definition: create.c:4402
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
static VOID UpdateHwDiskNumbers(IN PPARTLIST List)
Definition: partlist.c:1245
#define MAX_PATH
Definition: compat.h:34
NTSTATUS NTAPI NtClose(IN HANDLE Handle)
Definition: obhandle.c:3398
#define FILE_READ_ATTRIBUTES
Definition: nt_native.h:647
static PDISKENTRY GetSystemDisk(IN PPARTLIST List)
Definition: partlist.c:1718
static const WCHAR L[]
Definition: oid.c:1250
_Must_inspect_result_ _In_ WDFCMRESLIST List
Definition: wdfresource.h:550
#define SYNCHRONIZE
Definition: nt_native.h:61
HANDLE ProcessHeap
Definition: servman.c:15
static VOID EnumerateBiosDiskEntries(IN PPARTLIST PartList)
Definition: partlist.c:337
static VOID AddDiskToList(IN HANDLE FileHandle, IN ULONG DiskNumber, IN PPARTLIST List)
Definition: partlist.c:1306
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
#define NULL
Definition: types.h:112
#define DPRINT1
Definition: precomp.h:8
#define FILE_SYNCHRONOUS_IO_NONALERT
Definition: from_kernel.h:31
unsigned int ULONG
Definition: retypes.h:1
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
#define InitializeObjectAttributes(p, n, a, r, s)
Definition: reg.c:106
static VOID AssignDriveLetters(IN PPARTLIST List)
Definition: partlist.c:138

◆ CreatePrimaryPartition()

BOOLEAN CreatePrimaryPartition ( IN PPARTLIST  List,
IN OUT PPARTENTRY  PartEntry,
IN ULONGLONG  SectorCount,
IN BOOLEAN  AutoCreate 
)

Definition at line 2786 of file partlist.c.

2791 {
2793 
2794  DPRINT1("CreatePrimaryPartition(%I64u)\n", SectorCount);
2795 
2796  if (List == NULL || PartEntry == NULL ||
2797  PartEntry->DiskEntry == NULL || PartEntry->IsPartitioned)
2798  {
2799  return FALSE;
2800  }
2801 
2803  if (Error != NOT_AN_ERROR)
2804  {
2805  DPRINT1("PrimaryPartitionCreationChecks() failed with error %lu\n", Error);
2806  return FALSE;
2807  }
2808 
2809  /* Initialize the partition entry, inserting a new blank region if needed */
2810  if (!InitializePartitionEntry(PartEntry, SectorCount, AutoCreate))
2811  return FALSE;
2812 
2813  ASSERT(PartEntry->LogicalPartition == FALSE);
2814 
2815  UpdateDiskLayout(PartEntry->DiskEntry);
2817 
2818  return TRUE;
2819 }
#define TRUE
Definition: types.h:120
static BOOLEAN InitializePartitionEntry(IN OUT PPARTENTRY PartEntry, IN ULONGLONG SectorCount, IN BOOLEAN AutoCreate)
Definition: partlist.c:678
#define FALSE
Definition: types.h:117
static VOID UpdateDiskLayout(IN PDISKENTRY DiskEntry)
Definition: partlist.c:2534
ERROR_NUMBER PrimaryPartitionCreationChecks(IN PPARTENTRY PartEntry)
Definition: partlist.c:3954
#define ASSERT(a)
Definition: mode.c:45
BOOL Error
Definition: chkdsk.c:66
enum _ERROR_NUMBER ERROR_NUMBER
_Must_inspect_result_ _In_ WDFCMRESLIST List
Definition: wdfresource.h:550
ULONG SectorCount
Definition: part_xbox.c:31
#define NULL
Definition: types.h:112
#define DPRINT1
Definition: precomp.h:8
static VOID AssignDriveLetters(IN PPARTLIST List)
Definition: partlist.c:138

Referenced by CreatePrimaryPartitionPage(), SelectFileSystemPage(), and SelectPartitionPage().

◆ DeletePartition()

BOOLEAN DeletePartition ( IN PPARTLIST  List,
IN PPARTENTRY  PartEntry,
OUT PPARTENTRY *FreeRegion  OPTIONAL 
)

Definition at line 3047 of file partlist.c.

3051 {
3052  PDISKENTRY DiskEntry;
3053  PPARTENTRY PrevPartEntry;
3054  PPARTENTRY NextPartEntry;
3055  PPARTENTRY LogicalPartEntry;
3057 
3058  if (List == NULL || PartEntry == NULL ||
3059  PartEntry->DiskEntry == NULL || PartEntry->IsPartitioned == FALSE)
3060  {
3061  return FALSE;
3062  }
3063 
3064  ASSERT(PartEntry->PartitionType != PARTITION_ENTRY_UNUSED);
3065 
3066  /* Clear the system partition if it is being deleted */
3067  if (List->SystemPartition == PartEntry)
3068  {
3069  ASSERT(List->SystemPartition);
3070  List->SystemPartition = NULL;
3071  }
3072 
3073  DiskEntry = PartEntry->DiskEntry;
3074 
3075  /* Check which type of partition (primary/logical or extended) is being deleted */
3076  if (DiskEntry->ExtendedPartition == PartEntry)
3077  {
3078  /* An extended partition is being deleted: delete all logical partition entries */
3079  while (!IsListEmpty(&DiskEntry->LogicalPartListHead))
3080  {
3081  Entry = RemoveHeadList(&DiskEntry->LogicalPartListHead);
3082  LogicalPartEntry = CONTAINING_RECORD(Entry, PARTENTRY, ListEntry);
3083 
3084  /* Dismount the logical partition */
3085  DismountVolume(LogicalPartEntry);
3086 
3087  /* Delete it */
3088  RtlFreeHeap(ProcessHeap, 0, LogicalPartEntry);
3089  }
3090 
3091  DiskEntry->ExtendedPartition = NULL;
3092  }
3093  else
3094  {
3095  /* A primary partition is being deleted: dismount it */
3096  DismountVolume(PartEntry);
3097  }
3098 
3099  /* Adjust the unpartitioned disk space entries */
3100 
3101  /* Get pointer to previous and next unpartitioned entries */
3102  PrevPartEntry = GetPrevUnpartitionedEntry(PartEntry);
3103  NextPartEntry = GetNextUnpartitionedEntry(PartEntry);
3104 
3105  if (PrevPartEntry != NULL && NextPartEntry != NULL)
3106  {
3107  /* Merge the previous, current and next unpartitioned entries */
3108 
3109  /* Adjust the previous entry length */
3110  PrevPartEntry->SectorCount.QuadPart += (PartEntry->SectorCount.QuadPart + NextPartEntry->SectorCount.QuadPart);
3111 
3112  /* Remove the current and next entries */
3113  RemoveEntryList(&PartEntry->ListEntry);
3114  RtlFreeHeap(ProcessHeap, 0, PartEntry);
3115  RemoveEntryList(&NextPartEntry->ListEntry);
3116  RtlFreeHeap(ProcessHeap, 0, NextPartEntry);
3117 
3118  /* Optionally return the freed region */
3119  if (FreeRegion)
3120  *FreeRegion = PrevPartEntry;
3121  }
3122  else if (PrevPartEntry != NULL && NextPartEntry == NULL)
3123  {
3124  /* Merge the current and the previous unpartitioned entries */
3125 
3126  /* Adjust the previous entry length */
3127  PrevPartEntry->SectorCount.QuadPart += PartEntry->SectorCount.QuadPart;
3128 
3129  /* Remove the current entry */
3130  RemoveEntryList(&PartEntry->ListEntry);
3131  RtlFreeHeap(ProcessHeap, 0, PartEntry);
3132 
3133  /* Optionally return the freed region */
3134  if (FreeRegion)
3135  *FreeRegion = PrevPartEntry;
3136  }
3137  else if (PrevPartEntry == NULL && NextPartEntry != NULL)
3138  {
3139  /* Merge the current and the next unpartitioned entries */
3140 
3141  /* Adjust the next entry offset and length */
3142  NextPartEntry->StartSector.QuadPart = PartEntry->StartSector.QuadPart;
3143  NextPartEntry->SectorCount.QuadPart += PartEntry->SectorCount.QuadPart;
3144 
3145  /* Remove the current entry */
3146  RemoveEntryList(&PartEntry->ListEntry);
3147  RtlFreeHeap(ProcessHeap, 0, PartEntry);
3148 
3149  /* Optionally return the freed region */
3150  if (FreeRegion)
3151  *FreeRegion = NextPartEntry;
3152  }
3153  else
3154  {
3155  /* Nothing to merge but change the current entry */
3156  PartEntry->IsPartitioned = FALSE;
3157  PartEntry->OnDiskPartitionNumber = 0;
3158  PartEntry->PartitionNumber = 0;
3159  // PartEntry->PartitionIndex = 0;
3160  PartEntry->BootIndicator = FALSE;
3161  PartEntry->PartitionType = PARTITION_ENTRY_UNUSED;
3162  PartEntry->FormatState = Unformatted;
3163  PartEntry->FileSystem[0] = L'\0';
3164  PartEntry->DriveLetter = 0;
3165  RtlZeroMemory(PartEntry->VolumeLabel, sizeof(PartEntry->VolumeLabel));
3166 
3167  /* Optionally return the freed region */
3168  if (FreeRegion)
3169  *FreeRegion = PartEntry;
3170  }
3171 
3172  UpdateDiskLayout(DiskEntry);
3174 
3175  return TRUE;
3176 }
ULARGE_INTEGER StartSector
Definition: partlist.h:49
struct _Entry Entry
Definition: kefuncs.h:627
#define TRUE
Definition: types.h:120
ULARGE_INTEGER SectorCount
Definition: partlist.h:50
BOOLEAN NTAPI RtlFreeHeap(IN PVOID HeapHandle, IN ULONG Flags, IN PVOID HeapBase)
Definition: heap.c:606
_Must_inspect_result_ FORCEINLINE BOOLEAN IsListEmpty(_In_ const LIST_ENTRY *ListHead)
Definition: rtlfuncs.h:57
PPARTENTRY ExtendedPartition
Definition: partlist.h:135
FORCEINLINE BOOLEAN RemoveEntryList(_In_ PLIST_ENTRY Entry)
Definition: rtlfuncs.h:105
#define PARTITION_ENTRY_UNUSED
Definition: disk.h:86
LIST_ENTRY ListEntry
Definition: partlist.h:43
NTSTATUS DismountVolume(IN PPARTENTRY PartEntry)
Definition: partlist.c:2940
ULONGLONG QuadPart
Definition: ms-dtyp.idl:185
#define FALSE
Definition: types.h:117
FORCEINLINE PLIST_ENTRY RemoveHeadList(_Inout_ PLIST_ENTRY ListHead)
Definition: rtlfuncs.h:128
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
static VOID UpdateDiskLayout(IN PDISKENTRY DiskEntry)
Definition: partlist.c:2534
#define ASSERT(a)
Definition: mode.c:45
static const WCHAR L[]
Definition: oid.c:1250
_Must_inspect_result_ _In_ WDFCMRESLIST List
Definition: wdfresource.h:550
Definition: typedefs.h:119
HANDLE ProcessHeap
Definition: servman.c:15
static PPARTENTRY GetPrevUnpartitionedEntry(IN PPARTENTRY PartEntry)
Definition: partlist.c:2717
#define NULL
Definition: types.h:112
LIST_ENTRY LogicalPartListHead
Definition: partlist.h:132
static PPARTENTRY GetNextUnpartitionedEntry(IN PPARTENTRY PartEntry)
Definition: partlist.c:2752
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
base of all file and directory entries
Definition: entries.h:82
static VOID AssignDriveLetters(IN PPARTLIST List)
Definition: partlist.c:138
BOOLEAN IsPartitioned
Definition: partlist.h:66

Referenced by DeletePartitionPage().

◆ DestroyPartitionList()

VOID DestroyPartitionList ( IN PPARTLIST  List)

Definition at line 1931 of file partlist.c.

1933 {
1934  PDISKENTRY DiskEntry;
1935  PBIOSDISKENTRY BiosDiskEntry;
1936  PPARTENTRY PartEntry;
1938 
1939  /* Release disk and partition info */
1940  while (!IsListEmpty(&List->DiskListHead))
1941  {
1942  Entry = RemoveHeadList(&List->DiskListHead);
1943  DiskEntry = CONTAINING_RECORD(Entry, DISKENTRY, ListEntry);
1944 
1945  /* Release driver name */
1946  RtlFreeUnicodeString(&DiskEntry->DriverName);
1947 
1948  /* Release primary partition list */
1949  while (!IsListEmpty(&DiskEntry->PrimaryPartListHead))
1950  {
1951  Entry = RemoveHeadList(&DiskEntry->PrimaryPartListHead);
1952  PartEntry = CONTAINING_RECORD(Entry, PARTENTRY, ListEntry);
1953 
1954  RtlFreeHeap(ProcessHeap, 0, PartEntry);
1955  }
1956 
1957  /* Release logical partition list */
1958  while (!IsListEmpty(&DiskEntry->LogicalPartListHead))
1959  {
1960  Entry = RemoveHeadList(&DiskEntry->LogicalPartListHead);
1961  PartEntry = CONTAINING_RECORD(Entry, PARTENTRY, ListEntry);
1962 
1963  RtlFreeHeap(ProcessHeap, 0, PartEntry);
1964  }
1965 
1966  /* Release layout buffer */
1967  if (DiskEntry->LayoutBuffer != NULL)
1968  RtlFreeHeap(ProcessHeap, 0, DiskEntry->LayoutBuffer);
1969 
1970  /* Release disk entry */
1971  RtlFreeHeap(ProcessHeap, 0, DiskEntry);
1972  }
1973 
1974  /* Release the bios disk info */
1975  while (!IsListEmpty(&List->BiosDiskListHead))
1976  {
1977  Entry = RemoveHeadList(&List->BiosDiskListHead);
1978  BiosDiskEntry = CONTAINING_RECORD(Entry, BIOSDISKENTRY, ListEntry);
1979 
1980  RtlFreeHeap(ProcessHeap, 0, BiosDiskEntry);
1981  }
1982 
1983  /* Release list head */
1985 }
LIST_ENTRY PrimaryPartListHead
Definition: partlist.h:131
struct _Entry Entry
Definition: kefuncs.h:627
BOOLEAN NTAPI RtlFreeHeap(IN PVOID HeapHandle, IN ULONG Flags, IN PVOID HeapBase)
Definition: heap.c:606
_Must_inspect_result_ FORCEINLINE BOOLEAN IsListEmpty(_In_ const LIST_ENTRY *ListHead)
Definition: rtlfuncs.h:57
FORCEINLINE PLIST_ENTRY RemoveHeadList(_Inout_ PLIST_ENTRY ListHead)
Definition: rtlfuncs.h:128
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
UNICODE_STRING DriverName
Definition: partlist.h:123
NTSYSAPI VOID NTAPI RtlFreeUnicodeString(PUNICODE_STRING UnicodeString)
_Must_inspect_result_ _In_ WDFCMRESLIST List
Definition: wdfresource.h:550
Definition: typedefs.h:119
HANDLE ProcessHeap
Definition: servman.c:15
#define NULL
Definition: types.h:112
LIST_ENTRY LogicalPartListHead
Definition: partlist.h:132
PDRIVE_LAYOUT_INFORMATION LayoutBuffer
Definition: partlist.h:125
base of all file and directory entries
Definition: entries.h:82

Referenced by QuitPage(), rescan_main(), SelectPartitionPage(), and wmain().

◆ DismountVolume()

NTSTATUS DismountVolume ( IN PPARTENTRY  PartEntry)

Definition at line 2940 of file partlist.c.

2942 {
2943  NTSTATUS Status;
2944  NTSTATUS LockStatus;
2948  HANDLE PartitionHandle;
2950 
2951  /* Check whether the partition is valid and was mounted by the system */
2952  if (!PartEntry->IsPartitioned ||
2953  IsContainerPartition(PartEntry->PartitionType) ||
2954  !IsRecognizedPartition(PartEntry->PartitionType) ||
2955  PartEntry->FormatState == UnknownFormat ||
2956  // NOTE: If FormatState == Unformatted but *FileSystem != 0 this means
2957  // it has been usually mounted with RawFS and thus needs to be dismounted.
2958  !*PartEntry->FileSystem ||
2959  PartEntry->PartitionNumber == 0)
2960  {
2961  /* The partition is not mounted, so just return success */
2962  return STATUS_SUCCESS;
2963  }
2964 
2965  ASSERT(PartEntry->PartitionType != PARTITION_ENTRY_UNUSED);
2966 
2967  /* Open the volume */
2969  L"\\Device\\Harddisk%lu\\Partition%lu",
2970  PartEntry->DiskEntry->DiskNumber,
2971  PartEntry->PartitionNumber);
2973 
2975  &Name,
2977  NULL,
2978  NULL);
2979 
2980  Status = NtOpenFile(&PartitionHandle,
2983  &IoStatusBlock,
2986  if (!NT_SUCCESS(Status))
2987  {
2988  DPRINT1("ERROR: Cannot open volume %wZ for dismounting! (Status 0x%lx)\n", &Name, Status);
2989  return Status;
2990  }
2991 
2992  /* Lock the volume */
2993  LockStatus = NtFsControlFile(PartitionHandle,
2994  NULL,
2995  NULL,
2996  NULL,
2997  &IoStatusBlock,
2999  NULL,
3000  0,
3001  NULL,
3002  0);
3003  if (!NT_SUCCESS(LockStatus))
3004  {
3005  DPRINT1("WARNING: Failed to lock volume! Operations may fail! (Status 0x%lx)\n", LockStatus);
3006  }
3007 
3008  /* Dismount the volume */
3009  Status = NtFsControlFile(PartitionHandle,
3010  NULL,
3011  NULL,
3012  NULL,
3013  &IoStatusBlock,
3015  NULL,
3016  0,
3017  NULL,
3018  0);
3019  if (!NT_SUCCESS(Status))
3020  {
3021  DPRINT1("Failed to unmount volume (Status 0x%lx)\n", Status);
3022  }
3023 
3024  /* Unlock the volume */
3025  LockStatus = NtFsControlFile(PartitionHandle,
3026  NULL,
3027  NULL,
3028  NULL,
3029  &IoStatusBlock,
3031  NULL,
3032  0,
3033  NULL,
3034  0);
3035  if (!NT_SUCCESS(LockStatus))
3036  {
3037  DPRINT1("Failed to unlock volume (Status 0x%lx)\n", LockStatus);
3038  }
3039 
3040  /* Close the volume */
3041  NtClose(PartitionHandle);
3042 
3043  return Status;
3044 }
IN PUNICODE_STRING IN POBJECT_ATTRIBUTES ObjectAttributes
Definition: conport.c:35
#define FSCTL_UNLOCK_VOLUME
Definition: nt_native.h:833
#define OBJ_CASE_INSENSITIVE
Definition: winternl.h:228
NTSTRSAFEVAPI RtlStringCchPrintfW(_Out_writes_(cchDest) _Always_(_Post_z_) NTSTRSAFE_PWSTR pszDest, _In_ size_t cchDest, _In_ _Printf_format_string_ NTSTRSAFE_PCWSTR pszFormat,...)
Definition: ntstrsafe.h:1110
LONG NTSTATUS
Definition: precomp.h:26
#define ARRAYSIZE(array)
Definition: filtermapper.c:47
#define IsContainerPartition(PartitionType)
Definition: ntdddisk.h:316
NTSYSCALLAPI NTSTATUS NTAPI NtFsControlFile(HANDLE FileHandle, HANDLE Event, PIO_APC_ROUTINE ApcRoutine, PVOID ApcContext, PIO_STATUS_BLOCK IoStatusBlock, ULONG FsControlCode, PVOID InputBuffer, ULONG InputBufferLength, PVOID OutputBuffer, ULONG OutputBufferLength)
#define FILE_SHARE_WRITE
Definition: nt_native.h:681
#define FILE_SHARE_READ
Definition: compat.h:136
#define PARTITION_ENTRY_UNUSED
Definition: disk.h:86
#define GENERIC_WRITE
Definition: nt_native.h:90
struct NameRec_ * Name
Definition: cdprocs.h:459
Definition: bufpool.h:45
#define FSCTL_DISMOUNT_VOLUME
Definition: nt_native.h:834
Status
Definition: gdiplustypes.h:24
NTSYSAPI NTSTATUS NTAPI NtOpenFile(OUT PHANDLE phFile, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes, OUT PIO_STATUS_BLOCK pIoStatusBlock, IN ULONG ShareMode, IN ULONG OpenMode)
Definition: file.c:3951
#define ASSERT(a)
Definition: mode.c:45
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define IsRecognizedPartition(PartitionType)
Definition: ntdddisk.h:342
#define MAX_PATH
Definition: compat.h:34
NTSTATUS NTAPI NtClose(IN HANDLE Handle)
Definition: obhandle.c:3398
static const WCHAR L[]
Definition: oid.c:1250
#define GENERIC_READ
Definition: compat.h:135
#define SYNCHRONIZE
Definition: nt_native.h:61
static OUT PIO_STATUS_BLOCK IoStatusBlock
Definition: pipe.c:75
#define NULL
Definition: types.h:112
#define DPRINT1
Definition: precomp.h:8
#define FILE_SYNCHRONOUS_IO_NONALERT
Definition: from_kernel.h:31
#define FSCTL_LOCK_VOLUME
Definition: nt_native.h:832
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
#define InitializeObjectAttributes(p, n, a, r, s)
Definition: reg.c:106
#define STATUS_SUCCESS
Definition: shellext.h:65

Referenced by AddPartitionToDisk(), and DeletePartition().

◆ ExtendedPartitionCreationChecks()

ERROR_NUMBER ExtendedPartitionCreationChecks ( IN PPARTENTRY  PartEntry)

Definition at line 3981 of file partlist.c.

3983 {
3984  PDISKENTRY DiskEntry = PartEntry->DiskEntry;
3985 
3986  if (DiskEntry->DiskStyle == PARTITION_STYLE_GPT)
3987  {
3988  DPRINT1("GPT-partitioned disk detected, not currently supported by SETUP!\n");
3989  return ERROR_WARN_PARTITION;
3990  }
3991 
3992  /* Fail if the partition is already in use */
3993  if (PartEntry->IsPartitioned)
3994  return ERROR_NEW_PARTITION;
3995 
3996  /* Only one primary partition is allowed on super-floppy */
3997  if (IsSuperFloppy(DiskEntry))
3999 
4000  /* Fail if there are already 4 primary partitions in the list */
4001  if (GetPrimaryPartitionCount(DiskEntry) >= 4)
4003 
4004  /* Fail if there is another extended partition in the list */
4005  if (DiskEntry->ExtendedPartition != NULL)
4006  return ERROR_ONLY_ONE_EXTENDED;
4007 
4008  return ERROR_SUCCESS;
4009 }
#define ERROR_SUCCESS
Definition: deptool.c:10
PPARTENTRY ExtendedPartition
Definition: partlist.h:135
PARTITION_STYLE DiskStyle
Definition: partlist.h:121
static ULONG GetPrimaryPartitionCount(IN PDISKENTRY DiskEntry)
Definition: partlist.c:2428
BOOLEAN IsSuperFloppy(IN PDISKENTRY DiskEntry)
Definition: partlist.c:501
#define NULL
Definition: types.h:112
#define DPRINT1
Definition: precomp.h:8

Referenced by CreateExtendedPartition(), and SelectPartitionPage().

◆ FindSupportedSystemPartition()

PPARTENTRY FindSupportedSystemPartition ( IN PPARTLIST  List,
IN BOOLEAN  ForceSelect,
IN PDISKENTRY AlternativeDisk  OPTIONAL,
IN PPARTENTRY AlternativePart  OPTIONAL 
)

Definition at line 3260 of file partlist.c.

3265 {
3266  PLIST_ENTRY ListEntry;
3267  PDISKENTRY DiskEntry;
3268  PPARTENTRY PartEntry;
3269  PPARTENTRY ActivePartition;
3270  PPARTENTRY CandidatePartition = NULL;
3271 
3272  /* Check for empty disk list */
3273  if (IsListEmpty(&List->DiskListHead))
3274  {
3275  /* No system partition! */
3276  ASSERT(List->SystemPartition == NULL);
3277  goto NoSystemPartition;
3278  }
3279 
3280  /* Adjust the optional alternative disk if needed */
3281  if (!AlternativeDisk && AlternativePart)
3282  AlternativeDisk = AlternativePart->DiskEntry;
3283 
3284  /* Ensure that the alternative partition is on the alternative disk */
3285  if (AlternativePart)
3286  ASSERT(AlternativeDisk && (AlternativePart->DiskEntry == AlternativeDisk));
3287 
3288  /* Ensure that the alternative disk is in the list */
3289  if (AlternativeDisk)
3290  ASSERT(AlternativeDisk->PartList == List);
3291 
3292  /* Start fresh */
3293  CandidatePartition = NULL;
3294 
3295 //
3296 // Step 1 : Check the system disk.
3297 //
3298 
3299  /*
3300  * First, check whether the system disk, i.e. the one that will be booted
3301  * by default by the hardware, contains an active partition. If so this
3302  * should be our system partition.
3303  */
3304  DiskEntry = GetSystemDisk(List);
3305 
3306  if (DiskEntry->DiskStyle == PARTITION_STYLE_GPT)
3307  {
3308  DPRINT1("System disk -- GPT-partitioned disk detected, not currently supported by SETUP!\n");
3309  goto UseAlternativeDisk;
3310  }
3311 
3312  /* If we have a system partition (in the system disk), validate it */
3313  ActivePartition = List->SystemPartition;
3314  if (ActivePartition && IsSupportedActivePartition(ActivePartition))
3315  {
3316  CandidatePartition = ActivePartition;
3317 
3318  DPRINT1("Use the current system partition %lu in disk %lu, drive letter %C\n",
3319  CandidatePartition->PartitionNumber,
3320  CandidatePartition->DiskEntry->DiskNumber,
3321  (CandidatePartition->DriveLetter == 0) ? L'-' : CandidatePartition->DriveLetter);
3322 
3323  /* Return the candidate system partition */
3324  return CandidatePartition;
3325  }
3326 
3327  /* If the system disk is not the optional alternative disk, perform the minimal checks */
3328  if (DiskEntry != AlternativeDisk)
3329  {
3330  /*
3331  * No active partition has been recognized. Enumerate all the (primary)
3332  * partitions in the system disk, excluding the possible current active
3333  * partition, to find a new candidate.
3334  */
3335  for (ListEntry = DiskEntry->PrimaryPartListHead.Flink;
3336  ListEntry != &DiskEntry->PrimaryPartListHead;
3337  ListEntry = ListEntry->Flink)
3338  {
3339  /* Retrieve the partition */
3340  PartEntry = CONTAINING_RECORD(ListEntry, PARTENTRY, ListEntry);
3341 
3342  /* Skip the current active partition */
3343  if (PartEntry == ActivePartition)
3344  continue;
3345 
3346  /* Check if the partition is partitioned and used */
3347  if (PartEntry->IsPartitioned &&
3348  !IsContainerPartition(PartEntry->PartitionType))
3349  {
3351 
3352  /* If we get a candidate active partition in the disk, validate it */
3353  if (IsSupportedActivePartition(PartEntry))
3354  {
3355  CandidatePartition = PartEntry;
3356  goto UseAlternativePartition;
3357  }
3358  }
3359 
3360 #if 0
3361  /* Check if the partition is partitioned and used */
3362  if (!PartEntry->IsPartitioned)
3363  {
3365 
3366  // TODO: Check for minimal size!!
3367  CandidatePartition = PartEntry;
3368  goto UseAlternativePartition;
3369  }
3370 #endif
3371  }
3372 
3373  /*
3374  * Still nothing, look whether there is some free space that we can use
3375  * for the new system partition. We must be sure that the total number
3376  * of partition is less than the maximum allowed, and that the minimal
3377  * size is fine.
3378  */
3379 //
3380 // TODO: Fix the handling of system partition being created in unpartitioned space!!
3381 // --> When to partition it? etc...
3382 //
3383  if (GetPrimaryPartitionCount(DiskEntry) < 4)
3384  {
3385  for (ListEntry = DiskEntry->PrimaryPartListHead.Flink;
3386  ListEntry != &DiskEntry->PrimaryPartListHead;
3387  ListEntry = ListEntry->Flink)
3388  {
3389  /* Retrieve the partition */
3390  PartEntry = CONTAINING_RECORD(ListEntry, PARTENTRY, ListEntry);
3391 
3392  /* Skip the current active partition */
3393  if (PartEntry == ActivePartition)
3394  continue;
3395 
3396  /* Check for unpartitioned space */
3397  if (!PartEntry->IsPartitioned)
3398  {
3400 
3401  // TODO: Check for minimal size!!
3402  CandidatePartition = PartEntry;
3403  goto UseAlternativePartition;
3404  }
3405  }
3406  }
3407  }
3408 
3409 
3410 //
3411 // Step 2 : No active partition found: Check the alternative disk if specified.
3412 //
3413 
3414 UseAlternativeDisk:
3415  if (!AlternativeDisk || (!ForceSelect && (DiskEntry != AlternativeDisk)))
3416  goto NoSystemPartition;
3417 
3418  if (AlternativeDisk->DiskStyle == PARTITION_STYLE_GPT)
3419  {
3420  DPRINT1("Alternative disk -- GPT-partitioned disk detected, not currently supported by SETUP!\n");
3421  goto NoSystemPartition;
3422  }
3423 
3424  if (DiskEntry != AlternativeDisk)
3425  {
3426  /* Choose the alternative disk */
3427  DiskEntry = AlternativeDisk;
3428 
3429  /* If we get a candidate active partition, validate it */
3430  ActivePartition = GetActiveDiskPartition(DiskEntry);
3431  if (ActivePartition && IsSupportedActivePartition(ActivePartition))
3432  {
3433  CandidatePartition = ActivePartition;
3434  goto UseAlternativePartition;
3435  }
3436  }
3437 
3438  /* We now may have an unsupported active partition, or none */
3439 
3440 /***
3441  *** TODO: Improve the selection:
3442  *** - If we want a really separate system partition from the partition where
3443  *** we install, do something similar to what's done below in the code.
3444  *** - Otherwise if we allow for the system partition to be also the partition
3445  *** where we install, just directly fall down to using AlternativePart.
3446  ***/
3447 
3448  /* Retrieve the first partition of the disk */
3449  PartEntry = CONTAINING_RECORD(DiskEntry->PrimaryPartListHead.Flink,
3450  PARTENTRY, ListEntry);
3451  ASSERT(DiskEntry == PartEntry->DiskEntry);
3452 
3453  CandidatePartition = PartEntry;
3454 
3455  //
3456  // See: https://svn.reactos.org/svn/reactos/trunk/reactos/base/setup/usetup/partlist.c?r1=63355&r2=63354&pathrev=63355#l2318
3457  //
3458 
3459  /* Check if the disk is new and if so, use its first partition as the active system partition */
3460  if (DiskEntry->NewDisk)
3461  {
3462  // !IsContainerPartition(PartEntry->PartitionType);
3463  if (!CandidatePartition->IsPartitioned || !CandidatePartition->BootIndicator) /* CandidatePartition != ActivePartition */
3464  {
3465  ASSERT(DiskEntry == CandidatePartition->DiskEntry);
3466 
3467  DPRINT1("Use new first active system partition %lu in disk %lu, drive letter %C\n",
3468  CandidatePartition->PartitionNumber,
3469  CandidatePartition->DiskEntry->DiskNumber,
3470  (CandidatePartition->DriveLetter == 0) ? L'-' : CandidatePartition->DriveLetter);
3471 
3472  /* Return the candidate system partition */
3473  return CandidatePartition;
3474  }
3475 
3476  // FIXME: What to do??
3477  DPRINT1("NewDisk TRUE but first partition is used?\n");
3478  }
3479 
3480  /*
3481  * The disk is not new, check if any partition is initialized;
3482  * if not, the first one becomes the system partition.
3483  */
3484  for (ListEntry = DiskEntry->PrimaryPartListHead.Flink;
3485  ListEntry != &DiskEntry->PrimaryPartListHead;
3486  ListEntry = ListEntry->Flink)
3487  {
3488  /* Retrieve the partition */
3489  PartEntry = CONTAINING_RECORD(ListEntry, PARTENTRY, ListEntry);
3490 
3491  /* Check if the partition is partitioned and is used */
3492  // !IsContainerPartition(PartEntry->PartitionType);
3493  if (/* PartEntry->IsPartitioned && */
3494  PartEntry->PartitionType != PARTITION_ENTRY_UNUSED || PartEntry->BootIndicator)
3495  {
3496  break;
3497  }
3498  }
3499  if (ListEntry == &DiskEntry->PrimaryPartListHead)
3500  {
3501  /*
3502  * OK we haven't encountered any used and active partition,
3503  * so use the first one as the system partition.
3504  */
3505  ASSERT(DiskEntry == CandidatePartition->DiskEntry);
3506 
3507  DPRINT1("Use first active system partition %lu in disk %lu, drive letter %C\n",
3508  CandidatePartition->PartitionNumber,
3509  CandidatePartition->DiskEntry->DiskNumber,
3510  (CandidatePartition->DriveLetter == 0) ? L'-' : CandidatePartition->DriveLetter);
3511 
3512  /* Return the candidate system partition */
3513  return CandidatePartition;
3514  }
3515 
3516  /*
3517  * The disk is not new, we did not find any actual active partition,
3518  * or the one we found was not supported, or any possible other candidate
3519  * is not supported. We then use the alternative partition if specified.
3520  */
3521  if (AlternativePart)
3522  {
3523  DPRINT1("No valid or supported system partition has been found, use the alternative partition!\n");
3524  CandidatePartition = AlternativePart;
3525  goto UseAlternativePartition;
3526  }
3527  else
3528  {
3529 NoSystemPartition:
3530  DPRINT1("No valid or supported system partition has been found on this system!\n");
3531  return NULL;
3532  }
3533 
3534 UseAlternativePartition:
3535  /*
3536  * We are here because we did not find any (active) candidate system
3537  * partition that we know how to support. What we are going to do is
3538  * to change the existing system partition and use the alternative partition
3539  * (e.g. on which we install ReactOS) as the new system partition.
3540  * Then we will need to add in FreeLdr's boot menu an entry for booting
3541  * from the original system partition.
3542  */
3543  ASSERT(CandidatePartition);
3544 
3545  DPRINT1("Use alternative active system partition %lu in disk %lu, drive letter %C\n",
3546  CandidatePartition->PartitionNumber,
3547  CandidatePartition->DiskEntry->DiskNumber,
3548  (CandidatePartition->DriveLetter == 0) ? L'-' : CandidatePartition->DriveLetter);
3549 
3550  /* Return the candidate system partition */
3551  return CandidatePartition;
3552 }
LIST_ENTRY PrimaryPartListHead
Definition: partlist.h:131
WCHAR DriveLetter
Definition: partlist.h:58
ULONG PartitionNumber
Definition: partlist.h:55
static PPARTENTRY GetActiveDiskPartition(IN PDISKENTRY DiskEntry)
Definition: partlist.c:1791
static BOOLEAN IsSupportedActivePartition(IN PPARTENTRY PartEntry)
Definition: partlist.c:3180
#define IsContainerPartition(PartitionType)
Definition: ntdddisk.h:316
_Must_inspect_result_ FORCEINLINE BOOLEAN IsListEmpty(_In_ const LIST_ENTRY *ListHead)
Definition: rtlfuncs.h:57
#define PARTITION_ENTRY_UNUSED
Definition: disk.h:86
PARTITION_STYLE DiskStyle
Definition: partlist.h:121
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
struct _LIST_ENTRY * Flink
Definition: typedefs.h:121
UCHAR PartitionType
Definition: partlist.h:53
struct _DISKENTRY * DiskEntry
Definition: partlist.h:46
#define ASSERT(a)
Definition: mode.c:45
static ULONG GetPrimaryPartitionCount(IN PDISKENTRY DiskEntry)
Definition: partlist.c:2428
static PDISKENTRY GetSystemDisk(IN PPARTLIST List)
Definition: partlist.c:1718
static const WCHAR L[]
Definition: oid.c:1250
_Must_inspect_result_ _In_ WDFCMRESLIST List
Definition: wdfresource.h:550
Definition: typedefs.h:119
#define NULL
Definition: types.h:112
#define DPRINT1
Definition: precomp.h:8
BOOLEAN BootIndicator
Definition: partlist.h:52
BOOLEAN NewDisk
Definition: partlist.h:120
BOOLEAN IsPartitioned
Definition: partlist.h:66

Referenced by SelectFileSystemPage().

◆ GetDiskByBiosNumber()

PDISKENTRY GetDiskByBiosNumber ( IN PPARTLIST  List,
IN ULONG  HwDiskNumber 
)

Definition at line 1988 of file partlist.c.

1991 {
1992  PDISKENTRY DiskEntry;
1994 
1995  /* Loop over the disks and find the correct one */
1996  for (Entry = List->DiskListHead.Flink;
1997  Entry != &List->DiskListHead;
1998  Entry = Entry->Flink)
1999  {
2000  DiskEntry = CONTAINING_RECORD(Entry, DISKENTRY, ListEntry);
2001 
2002  if (DiskEntry->HwDiskNumber == HwDiskNumber)
2003  {
2004  /* Disk found */
2005  return DiskEntry;
2006  }
2007  }
2008 
2009  /* Disk not found, stop there */
2010  return NULL;
2011 }
struct _Entry Entry
Definition: kefuncs.h:627
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
ULONG HwDiskNumber
Definition: partlist.h:105
_Must_inspect_result_ _In_ WDFCMRESLIST List
Definition: wdfresource.h:550
Definition: typedefs.h:119
#define NULL
Definition: types.h:112
base of all file and directory entries
Definition: entries.h:82

◆ GetDiskByNumber()

PDISKENTRY GetDiskByNumber ( IN PPARTLIST  List,
IN ULONG  DiskNumber 
)

Definition at line 2014 of file partlist.c.

2017 {
2018  PDISKENTRY DiskEntry;
2020 
2021  /* Loop over the disks and find the correct one */
2022  for (Entry = List->DiskListHead.Flink;
2023  Entry != &List->DiskListHead;
2024  Entry = Entry->Flink)
2025  {
2026  DiskEntry = CONTAINING_RECORD(Entry, DISKENTRY, ListEntry);
2027 
2028  if (DiskEntry->DiskNumber == DiskNumber)
2029  {
2030  /* Disk found */
2031  return DiskEntry;
2032  }
2033  }
2034 
2035  /* Disk not found, stop there */
2036  return NULL;
2037 }
struct _Entry Entry
Definition: kefuncs.h:627
ULONG DiskNumber
Definition: partlist.h:111
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
_Must_inspect_result_ _In_ WDFCMRESLIST List
Definition: wdfresource.h:550
Definition: typedefs.h:119
#define NULL
Definition: types.h:112
base of all file and directory entries
Definition: entries.h:82

Referenced by GetDiskOrPartition(), and SelectPartition().

◆ GetDiskBySCSI()

PDISKENTRY GetDiskBySCSI ( IN PPARTLIST  List,
IN USHORT  Port,
IN USHORT  Bus,
IN USHORT  Id 
)

Definition at line 2040 of file partlist.c.

2045 {
2046  PDISKENTRY DiskEntry;
2048 
2049  /* Loop over the disks and find the correct one */
2050  for (Entry = List->DiskListHead.Flink;
2051  Entry != &List->DiskListHead;
2052  Entry = Entry->Flink)
2053  {
2054  DiskEntry = CONTAINING_RECORD(Entry, DISKENTRY, ListEntry);
2055 
2056  if (DiskEntry->Port == Port &&
2057  DiskEntry->Bus == Bus &&
2058  DiskEntry->Id == Id)
2059  {
2060  /* Disk found */
2061  return DiskEntry;
2062  }
2063  }
2064 
2065  /* Disk not found, stop there */
2066  return NULL;
2067 }
CPPORT Port[4]
Definition: headless.c:35
USHORT Id
Definition: partlist.h:115
struct _Entry Entry
Definition: kefuncs.h:627
USHORT Bus
Definition: partlist.h:114
DWORD Id
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
_Must_inspect_result_ _In_ WDFCMRESLIST List
Definition: wdfresource.h:550
Definition: typedefs.h:119
USHORT Port
Definition: partlist.h:113
#define NULL
Definition: types.h:112
base of all file and directory entries
Definition: entries.h:82

Referenced by ResolveArcNameManually().

◆ GetDiskBySignature()

PDISKENTRY GetDiskBySignature ( IN PPARTLIST  List,
IN ULONG  Signature 
)

Definition at line 2070 of file partlist.c.

2073 {
2074  PDISKENTRY DiskEntry;
2076 
2077  /* Loop over the disks and find the correct one */
2078  for (Entry = List->DiskListHead.Flink;
2079  Entry != &List->DiskListHead;
2080  Entry = Entry->Flink)
2081  {
2082  DiskEntry = CONTAINING_RECORD(Entry, DISKENTRY, ListEntry);
2083 
2084  if (DiskEntry->LayoutBuffer->Signature == Signature)
2085  {
2086  /* Disk found */
2087  return DiskEntry;
2088  }
2089  }
2090 
2091  /* Disk not found, stop there */
2092  return NULL;
2093 }
struct _Entry Entry
Definition: kefuncs.h:627
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
_Must_inspect_result_ _In_ WDFCMRESLIST List
Definition: wdfresource.h:550
Definition: typedefs.h:119
#define NULL
Definition: types.h:112
static const WCHAR Signature[]
Definition: parser.c:141
PDRIVE_LAYOUT_INFORMATION LayoutBuffer
Definition: partlist.h:125
base of all file and directory entries
Definition: entries.h:82

Referenced by ResolveArcNameManually().

◆ GetDiskOrPartition()

BOOLEAN GetDiskOrPartition ( IN PPARTLIST  List,
IN ULONG  DiskNumber,
IN ULONG PartitionNumber  OPTIONAL,
OUT PDISKENTRY pDiskEntry,
OUT PPARTENTRY *pPartEntry  OPTIONAL 
)

Definition at line 2143 of file partlist.c.

2149 {
2150  PDISKENTRY DiskEntry;
2151  PPARTENTRY PartEntry = NULL;
2152 
2153  /* Find the disk */
2154  DiskEntry = GetDiskByNumber(List, DiskNumber);
2155  if (!DiskEntry)
2156  return FALSE;
2157 
2158  /* If we have a partition (PartitionNumber != 0), find it */
2159  if (PartitionNumber != 0)
2160  {
2161  if (DiskEntry->DiskStyle == PARTITION_STYLE_GPT)
2162  {
2163  DPRINT("GPT-partitioned disk detected, not currently supported by SETUP!\n");
2164  return FALSE;
2165  }
2166 
2167  PartEntry = GetPartition(/*List,*/ DiskEntry, PartitionNumber);
2168  if (!PartEntry)
2169  return FALSE;
2170  ASSERT(PartEntry->DiskEntry == DiskEntry);
2171  }
2172 
2173  /* Return the disk (and optionally the partition) */
2174  *pDiskEntry = DiskEntry;
2175  if (pPartEntry) *pPartEntry = PartEntry;
2176  return TRUE;
2177 }
#define TRUE
Definition: types.h:120
_In_ ULONG _In_ ULONG PartitionNumber
Definition: iofuncs.h:2056
PPARTENTRY GetPartition(IN PDISKENTRY DiskEntry, IN ULONG PartitionNumber)
Definition: partlist.c:2096
PARTITION_STYLE DiskStyle
Definition: partlist.h:121
#define FALSE
Definition: types.h:117
PDISKENTRY GetDiskByNumber(IN PPARTLIST List, IN ULONG DiskNumber)
Definition: partlist.c:2014
struct _DISKENTRY * DiskEntry
Definition: partlist.h:46
#define ASSERT(a)
Definition: mode.c:45
_Must_inspect_result_ _In_ WDFCMRESLIST List
Definition: wdfresource.h:550
#define NULL
Definition: types.h:112
#define DPRINT
Definition: sndvol32.h:71

Referenced by EnumerateInstallations().

◆ GetNextPartition()

PPARTENTRY GetNextPartition ( IN PPARTLIST  List,
IN PPARTENTRY CurrentPart  OPTIONAL 
)

Definition at line 2207 of file partlist.c.

2210 {
2211  PLIST_ENTRY DiskListEntry;
2212  PLIST_ENTRY PartListEntry;
2214 
2215  /* Fail if no disks are available */
2216  if (IsListEmpty(&List->DiskListHead))
2217  return NULL;
2218 
2219  /* Check for the next usable entry on the current partition's disk */
2220  if (CurrentPart != NULL)
2221  {
2222  CurrentDisk = CurrentPart->DiskEntry;
2223 
2224  if (CurrentPart->LogicalPartition)
2225  {
2226  /* Logical partition */
2227 
2228  PartListEntry = CurrentPart->ListEntry.Flink;
2229  if (PartListEntry != &CurrentDisk->LogicalPartListHead)
2230  {
2231  /* Next logical partition */
2232  CurrentPart = CONTAINING_RECORD(PartListEntry, PARTENTRY, ListEntry);
2233  return CurrentPart;
2234  }
2235  else
2236  {
2237  PartListEntry = CurrentDisk->ExtendedPartition->ListEntry.Flink;
2238  if (PartListEntry != &CurrentDisk->PrimaryPartListHead)
2239  {
2240  CurrentPart = CONTAINING_RECORD(PartListEntry, PARTENTRY, ListEntry);
2241  return CurrentPart;
2242  }
2243  }
2244  }
2245  else
2246  {
2247  /* Primary or extended partition */
2248 
2249  if (CurrentPart->IsPartitioned &&
2250  IsContainerPartition(CurrentPart->PartitionType))
2251  {
2252  /* First logical partition */
2253  PartListEntry = CurrentDisk->LogicalPartListHead.Flink;
2254  if (PartListEntry != &CurrentDisk->LogicalPartListHead)
2255  {
2256  CurrentPart = CONTAINING_RECORD(PartListEntry, PARTENTRY, ListEntry);
2257  return CurrentPart;
2258  }
2259  }
2260  else
2261  {
2262  /* Next primary partition */
2263  PartListEntry = CurrentPart->ListEntry.Flink;
2264  if (PartListEntry != &CurrentDisk->PrimaryPartListHead)
2265  {
2266  CurrentPart = CONTAINING_RECORD(PartListEntry, PARTENTRY, ListEntry);
2267  return CurrentPart;
2268  }
2269  }
2270  }
2271  }
2272 
2273  /* Search for the first partition entry on the next disk */
2274  for (DiskListEntry = (CurrentPart ? CurrentDisk->ListEntry.Flink
2275  : List->DiskListHead.Flink);
2276  DiskListEntry != &List->DiskListHead;
2277  DiskListEntry = DiskListEntry->Flink)
2278  {
2279  CurrentDisk = CONTAINING_RECORD(DiskListEntry, DISKENTRY, ListEntry);
2280 
2282  {
2283  DPRINT("GPT-partitioned disk detected, not currently supported by SETUP!\n");
2284  continue;
2285  }
2286 
2287  PartListEntry = CurrentDisk->PrimaryPartListHead.Flink;
2288  if (PartListEntry != &CurrentDisk->PrimaryPartListHead)
2289  {
2290  CurrentPart = CONTAINING_RECORD(PartListEntry, PARTENTRY, ListEntry);
2291  return CurrentPart;
2292  }
2293  }
2294 
2295  return NULL;
2296 }
LIST_ENTRY PrimaryPartListHead
Definition: partlist.h:131
PDISKENTRY CurrentDisk
Definition: partlist.c:73
#define IsContainerPartition(PartitionType)
Definition: ntdddisk.h:316
_Must_inspect_result_ FORCEINLINE BOOLEAN IsListEmpty(_In_ const LIST_ENTRY *ListHead)
Definition: rtlfuncs.h:57
PPARTENTRY ExtendedPartition
Definition: partlist.h:135
LIST_ENTRY ListEntry
Definition: partlist.h:43
PARTITION_STYLE DiskStyle
Definition: partlist.h:121
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
struct _LIST_ENTRY * Flink
Definition: typedefs.h:121
LIST_ENTRY ListEntry
Definition: partlist.h:83
_Must_inspect_result_ _In_ WDFCMRESLIST List
Definition: wdfresource.h:550
Definition: typedefs.h:119
#define NULL
Definition: types.h:112
LIST_ENTRY LogicalPartListHead
Definition: partlist.h:132
#define DPRINT
Definition: sndvol32.h:71

Referenced by ScrollDownPartitionList().

◆ GetNextUncheckedPartition()

BOOLEAN GetNextUncheckedPartition ( IN PPARTLIST  List,
OUT PDISKENTRY *pDiskEntry  OPTIONAL,
OUT PPARTENTRY pPartEntry 
)

Definition at line 4094 of file partlist.c.

4098 {
4099  PLIST_ENTRY Entry1, Entry2;
4100  PDISKENTRY DiskEntry;
4101  PPARTENTRY PartEntry;
4102 
4103  for (Entry1 = List->DiskListHead.Flink;
4104  Entry1 != &List->DiskListHead;
4105  Entry1 = Entry1->Flink)
4106  {
4107  DiskEntry = CONTAINING_RECORD(Entry1,
4108  DISKENTRY,
4109  ListEntry);
4110 
4111  if (DiskEntry->DiskStyle == PARTITION_STYLE_GPT)
4112  {
4113  DPRINT("GPT-partitioned disk detected, not currently supported by SETUP!\n");
4114  continue;
4115  }
4116 
4117  for (Entry2 = DiskEntry->PrimaryPartListHead.Flink;
4118  Entry2 != &DiskEntry->PrimaryPartListHead;
4119  Entry2 = Entry2->Flink)
4120  {
4121  PartEntry = CONTAINING_RECORD(Entry2, PARTENTRY, ListEntry);
4122  if (PartEntry->IsPartitioned && PartEntry->NeedsCheck)
4123  {
4124  ASSERT(DiskEntry == PartEntry->DiskEntry);
4125  if (pDiskEntry) *pDiskEntry = DiskEntry;
4126  *pPartEntry = PartEntry;
4127  return TRUE;
4128  }
4129  }
4130 
4131  for (Entry2 = DiskEntry->LogicalPartListHead.Flink;
4132  Entry2 != &DiskEntry->LogicalPartListHead;
4133  Entry2 = Entry2->Flink)
4134  {
4135  PartEntry = CONTAINING_RECORD(Entry2, PARTENTRY, ListEntry);
4136  if (PartEntry->IsPartitioned && PartEntry->NeedsCheck)
4137  {
4138  ASSERT(DiskEntry == PartEntry->DiskEntry);
4139  if (pDiskEntry) *pDiskEntry = DiskEntry;
4140  *pPartEntry = PartEntry;
4141  return TRUE;
4142  }
4143  }
4144  }
4145 
4146  if (pDiskEntry) *pDiskEntry = NULL;
4147  *pPartEntry = NULL;
4148 
4149  return FALSE;
4150 }
LIST_ENTRY PrimaryPartListHead
Definition: partlist.h:131
#define TRUE
Definition: types.h:120
PARTITION_STYLE DiskStyle
Definition: partlist.h:121
#define FALSE
Definition: types.h:117
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
struct _LIST_ENTRY * Flink
Definition: typedefs.h:121
struct _DISKENTRY * DiskEntry
Definition: partlist.h:46
#define ASSERT(a)
Definition: mode.c:45
_Must_inspect_result_ _In_ WDFCMRESLIST List
Definition: wdfresource.h:550
Definition: typedefs.h:119
BOOLEAN NeedsCheck
Definition: partlist.h:77
#define NULL
Definition: types.h:112
LIST_ENTRY LogicalPartListHead
Definition: partlist.h:132
#define DPRINT
Definition: sndvol32.h:71
BOOLEAN IsPartitioned
Definition: partlist.h:66

Referenced by CheckFileSystemPage().

◆ GetNextUnformattedPartition()

BOOLEAN GetNextUnformattedPartition ( IN PPARTLIST  List,
OUT PDISKENTRY *pDiskEntry  OPTIONAL,
OUT PPARTENTRY pPartEntry 
)

Definition at line 4035 of file partlist.c.

4039 {
4040  PLIST_ENTRY Entry1, Entry2;
4041  PDISKENTRY DiskEntry;
4042  PPARTENTRY PartEntry;
4043 
4044  for (Entry1 = List->DiskListHead.Flink;
4045  Entry1 != &List->DiskListHead;
4046  Entry1 = Entry1->Flink)
4047  {
4048  DiskEntry = CONTAINING_RECORD(Entry1,
4049  DISKENTRY,
4050  ListEntry);
4051 
4052  if (DiskEntry->DiskStyle == PARTITION_STYLE_GPT)
4053  {
4054  DPRINT("GPT-partitioned disk detected, not currently supported by SETUP!\n");
4055  continue;
4056  }
4057 
4058  for (Entry2 = DiskEntry->PrimaryPartListHead.Flink;
4059  Entry2 != &DiskEntry->PrimaryPartListHead;
4060  Entry2 = Entry2->Flink)
4061  {
4062  PartEntry = CONTAINING_RECORD(Entry2, PARTENTRY, ListEntry);
4063  if (PartEntry->IsPartitioned && PartEntry->New)
4064  {
4065  ASSERT(DiskEntry == PartEntry->DiskEntry);
4066  if (pDiskEntry) *pDiskEntry = DiskEntry;
4067  *pPartEntry = PartEntry;
4068  return TRUE;
4069  }
4070  }
4071 
4072  for (Entry2 = DiskEntry->LogicalPartListHead.Flink;
4073  Entry2 != &DiskEntry->LogicalPartListHead;
4074  Entry2 = Entry2->Flink)
4075  {
4076  PartEntry = CONTAINING_RECORD(Entry2, PARTENTRY, ListEntry);
4077  if (PartEntry->IsPartitioned && PartEntry->New)
4078  {
4079  ASSERT(DiskEntry == PartEntry->DiskEntry);
4080  if (pDiskEntry) *pDiskEntry = DiskEntry;
4081  *pPartEntry = PartEntry;
4082  return TRUE;
4083  }
4084  }
4085  }
4086 
4087  if (pDiskEntry) *pDiskEntry = NULL;
4088  *pPartEntry = NULL;
4089 
4090  return FALSE;
4091 }
LIST_ENTRY PrimaryPartListHead
Definition: partlist.h:131
#define TRUE
Definition: types.h:120
PARTITION_STYLE DiskStyle
Definition: partlist.h:121
#define FALSE
Definition: types.h:117
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
struct _LIST_ENTRY * Flink
Definition: typedefs.h:121
struct _DISKENTRY * DiskEntry
Definition: partlist.h:46
#define ASSERT(a)
Definition: mode.c:45
_Must_inspect_result_ _In_ WDFCMRESLIST List
Definition: wdfresource.h:550
Definition: typedefs.h:119
BOOLEAN New
Definition: partlist.h:71
#define NULL
Definition: types.h:112
LIST_ENTRY LogicalPartListHead
Definition: partlist.h:132
#define DPRINT
Definition: sndvol32.h:71
BOOLEAN IsPartitioned
Definition: partlist.h:66

Referenced by SelectFileSystemPage().

◆ GetPartition()

PPARTENTRY GetPartition ( IN PDISKENTRY  DiskEntry,
IN ULONG  PartitionNumber 
)

Definition at line 2096 of file partlist.c.

2100 {
2101  PPARTENTRY PartEntry;
2103 
2104  if (DiskEntry->DiskStyle == PARTITION_STYLE_GPT)
2105  {
2106  DPRINT("GPT-partitioned disk detected, not currently supported by SETUP!\n");
2107  return NULL;
2108  }
2109 
2110  /* Disk found, loop over the primary partitions first... */
2111  for (Entry = DiskEntry->PrimaryPartListHead.Flink;
2112  Entry != &DiskEntry->PrimaryPartListHead;
2113  Entry = Entry->Flink)
2114  {
2115  PartEntry = CONTAINING_RECORD(Entry, PARTENTRY, ListEntry);
2116 
2117  if (PartEntry->PartitionNumber == PartitionNumber)
2118  {
2119  /* Partition found */
2120  return PartEntry;
2121  }
2122  }
2123 
2124  /* ... then over the logical partitions if needed */
2125  for (Entry = DiskEntry->LogicalPartListHead.Flink;
2126  Entry != &DiskEntry->LogicalPartListHead;
2127  Entry = Entry->Flink)
2128  {
2129  PartEntry = CONTAINING_RECORD(Entry, PARTENTRY, ListEntry);
2130 
2131  if (PartEntry->PartitionNumber == PartitionNumber)
2132  {
2133  /* Partition found */
2134  return PartEntry;
2135  }
2136  }
2137 
2138  /* The partition was not found on the disk, stop there */
2139  return NULL;
2140 }
ULONG PartitionNumber
Definition: partlist.h:55
struct _Entry Entry
Definition: kefuncs.h:627
_In_ ULONG _In_ ULONG PartitionNumber
Definition: iofuncs.h:2056
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
Definition: typedefs.h:119
#define NULL
Definition: types.h:112
#define DPRINT
Definition: sndvol32.h:71
base of all file and directory entries
Definition: entries.h:82

Referenced by GetDiskOrPartition(), ResolveArcNameManually(), and SelectPartition().

◆ GetPrevPartition()

PPARTENTRY GetPrevPartition ( IN PPARTLIST  List,
IN PPARTENTRY CurrentPart  OPTIONAL 
)

Definition at line 2299 of file partlist.c.

2302 {
2303  PLIST_ENTRY DiskListEntry;
2304  PLIST_ENTRY PartListEntry;
2306 
2307  /* Fail if no disks are available */
2308  if (IsListEmpty(&List->DiskListHead))
2309  return NULL;
2310 
2311  /* Check for the previous usable entry on the current partition's disk */
2312  if (CurrentPart != NULL)
2313  {
2314  CurrentDisk = CurrentPart->DiskEntry;
2315 
2316  if (CurrentPart->LogicalPartition)
2317  {
2318  /* Logical partition */
2319 
2320  PartListEntry = CurrentPart->ListEntry.Blink;
2321  if (PartListEntry != &CurrentDisk->LogicalPartListHead)
2322  {
2323  /* Previous logical partition */
2324  CurrentPart = CONTAINING_RECORD(PartListEntry, PARTENTRY, ListEntry);
2325  }
2326  else
2327  {
2328  /* Extended partition */
2329  CurrentPart = CurrentDisk->ExtendedPartition;
2330  }
2331  return CurrentPart;
2332  }
2333  else
2334  {
2335  /* Primary or extended partition */
2336 
2337  PartListEntry = CurrentPart->ListEntry.Blink;
2338  if (PartListEntry != &CurrentDisk->PrimaryPartListHead)
2339  {
2340  CurrentPart = CONTAINING_RECORD(PartListEntry, PARTENTRY, ListEntry);
2341 
2342  if (CurrentPart->IsPartitioned &&
2343  IsContainerPartition(CurrentPart->PartitionType))
2344  {
2345  PartListEntry = CurrentDisk->LogicalPartListHead.Blink;
2346  CurrentPart = CONTAINING_RECORD(PartListEntry, PARTENTRY, ListEntry);
2347  }
2348 
2349  return CurrentPart;
2350  }
2351  }
2352  }
2353 
2354  /* Search for the last partition entry on the previous disk */
2355  for (DiskListEntry = (CurrentPart ? CurrentDisk->ListEntry.Blink
2356  : List->DiskListHead.Blink);
2357  DiskListEntry != &List->DiskListHead;
2358  DiskListEntry = DiskListEntry->Blink)
2359  {
2360  CurrentDisk = CONTAINING_RECORD(DiskListEntry, DISKENTRY, ListEntry);
2361 
2363  {
2364  DPRINT("GPT-partitioned disk detected, not currently supported by SETUP!\n");
2365  continue;
2366  }
2367 
2368  PartListEntry = CurrentDisk->PrimaryPartListHead.Blink;
2369  if (PartListEntry != &CurrentDisk->PrimaryPartListHead)
2370  {
2371  CurrentPart = CONTAINING_RECORD(PartListEntry, PARTENTRY, ListEntry);
2372 
2373  if (CurrentPart->IsPartitioned &&
2374  IsContainerPartition(CurrentPart->PartitionType))
2375  {
2376  PartListEntry = CurrentDisk->LogicalPartListHead.Blink;
2377  if (PartListEntry != &CurrentDisk->LogicalPartListHead)
2378  {
2379  CurrentPart = CONTAINING_RECORD(PartListEntry, PARTENTRY, ListEntry);
2380  return CurrentPart;
2381  }
2382  }
2383  else
2384  {
2385  return CurrentPart;
2386  }
2387  }
2388  }
2389 
2390  return NULL;
2391 }
LIST_ENTRY PrimaryPartListHead
Definition: partlist.h:131
PDISKENTRY CurrentDisk
Definition: partlist.c:73
struct _LIST_ENTRY * Blink
Definition: typedefs.h:122
#define IsContainerPartition(PartitionType)
Definition: ntdddisk.h:316
_Must_inspect_result_ FORCEINLINE BOOLEAN IsListEmpty(_In_ const LIST_ENTRY *ListHead)
Definition: rtlfuncs.h:57
PPARTENTRY ExtendedPartition
Definition: partlist.h:135
PARTITION_STYLE DiskStyle
Definition: partlist.h:121
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
LIST_ENTRY ListEntry
Definition: partlist.h:83
_Must_inspect_result_ _In_ WDFCMRESLIST List
Definition: wdfresource.h:550
Definition: typedefs.h:119
#define NULL
Definition: types.h:112
LIST_ENTRY LogicalPartListHead
Definition: partlist.h:132
#define DPRINT
Definition: sndvol32.h:71

Referenced by ScrollUpPartitionList().

◆ IsPartitionActive()

BOOLEAN IsPartitionActive ( IN PPARTENTRY  PartEntry)

Definition at line 1768 of file partlist.c.

1770 {
1771  // TODO: Support for GPT disks!
1772 
1773  if (IsContainerPartition(PartEntry->PartitionType))
1774  return FALSE;
1775 
1776  /* Check if the partition is partitioned, used and active */
1777  if (PartEntry->IsPartitioned &&
1778  // !IsContainerPartition(PartEntry->PartitionType) &&
1779  PartEntry->BootIndicator)
1780  {
1781  /* Yes it is */
1782  ASSERT(PartEntry->PartitionType != PARTITION_ENTRY_UNUSED);
1783  return TRUE;
1784  }
1785 
1786  return FALSE;
1787 }
#define TRUE
Definition: types.h:120
#define IsContainerPartition(PartitionType)
Definition: ntdddisk.h:316
#define PARTITION_ENTRY_UNUSED
Definition: disk.h:86
#define FALSE
Definition: types.h:117
#define ASSERT(a)
Definition: mode.c:45

Referenced by GetActiveDiskPartition(), SelectPartitionPage(), and SetActivePartition().

◆ IsSuperFloppy()

BOOLEAN IsSuperFloppy ( IN PDISKENTRY  DiskEntry)

Definition at line 501 of file partlist.c.

503 {
505  ULONGLONG PartitionLengthEstimate;
506 
507  /* No layout buffer: we cannot say anything yet */
508  if (DiskEntry->LayoutBuffer == NULL)
509  return FALSE;
510 
511  /* We must have only one partition */
512  if (DiskEntry->LayoutBuffer->PartitionCount != 1)
513  return FALSE;
514 
515  /* Get the single partition entry */
516  PartitionInfo = DiskEntry->LayoutBuffer->PartitionEntry;
517 
518  /* The single partition must start at the beginning of the disk */
519  if (!(PartitionInfo->StartingOffset.QuadPart == 0 &&
520  PartitionInfo->HiddenSectors == 0))
521  {
522  return FALSE;
523  }
524 
525  /* The disk signature is usually set to one; warn in case it's not */
526  if (DiskEntry->LayoutBuffer->Signature != 1)
527  {
528  DPRINT1("Super-Floppy disk %lu signature %08x != 1!\n",
529  DiskEntry->DiskNumber, DiskEntry->LayoutBuffer->Signature);
530  }
531 
532  /*
533  * The partition number must be zero or one, be recognized,
534  * have FAT16 type and report as non-bootable.
535  */
536  if ((PartitionInfo->PartitionNumber != 0 &&
537  PartitionInfo->PartitionNumber != 1) ||
538  PartitionInfo->RecognizedPartition != TRUE ||
539  PartitionInfo->PartitionType != PARTITION_FAT_16 ||
540  PartitionInfo->BootIndicator != FALSE)
541  {
542  DPRINT1("Super-Floppy disk %lu does not return default settings!\n"
543  " PartitionNumber = %lu, expected 0\n"
544  " RecognizedPartition = %s, expected TRUE\n"
545  " PartitionType = 0x%02x, expected 0x04 (PARTITION_FAT_16)\n"
546  " BootIndicator = %s, expected FALSE\n",
547  DiskEntry->DiskNumber,
548  PartitionInfo->PartitionNumber,
549  PartitionInfo->RecognizedPartition ? "TRUE" : "FALSE",
550  PartitionInfo->PartitionType,
551  PartitionInfo->BootIndicator ? "TRUE" : "FALSE");
552  }
553 
554  /* The partition lengths should agree */
555  PartitionLengthEstimate = DiskEntry->SectorCount.QuadPart * DiskEntry->BytesPerSector;
556  if (PartitionInfo->PartitionLength.QuadPart != PartitionLengthEstimate)
557  {
558  DPRINT1("PartitionLength = %I64u is different from PartitionLengthEstimate = %I64u\n",
559  PartitionInfo->PartitionLength.QuadPart, PartitionLengthEstimate);
560  }
561 
562  return TRUE;
563 }
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
uint64_t ULONGLONG
Definition: typedefs.h:67
_In_ ULONG _In_ struct _SET_PARTITION_INFORMATION_EX * PartitionInfo
Definition: iofuncs.h:2101
#define PARTITION_FAT_16
Definition: disk.h:90
#define NULL
Definition: types.h:112
#define DPRINT1
Definition: precomp.h:8

Referenced by AddDiskToList(), BootLoaderInstallationPage(), ExtendedPartitionCreationChecks(), LogicalPartitionCreationChecks(), PrimaryPartitionCreationChecks(), and xHalIoWritePartitionTable().

◆ LogicalPartitionCreationChecks()

ERROR_NUMBER LogicalPartitionCreationChecks ( IN PPARTENTRY  PartEntry)

Definition at line 4012 of file partlist.c.

4014 {
4015  PDISKENTRY DiskEntry = PartEntry->DiskEntry;
4016 
4017  if (DiskEntry->DiskStyle == PARTITION_STYLE_GPT)
4018  {
4019  DPRINT1("GPT-partitioned disk detected, not currently supported by SETUP!\n");
4020  return ERROR_WARN_PARTITION;
4021  }
4022 
4023  /* Fail if the partition is already in use */
4024  if (PartEntry->IsPartitioned)
4025  return ERROR_NEW_PARTITION;
4026 
4027  /* Only one primary partition is allowed on super-floppy */
4028  if (IsSuperFloppy(DiskEntry))
4030 
4031  return ERROR_SUCCESS;
4032 }
#define ERROR_SUCCESS
Definition: deptool.c:10
PARTITION_STYLE DiskStyle
Definition: partlist.h:121
BOOLEAN IsSuperFloppy(IN PDISKENTRY DiskEntry)
Definition: partlist.c:501
#define DPRINT1
Definition: precomp.h:8

Referenced by CreateLogicalPartition(), and SelectPartitionPage().

◆ PrimaryPartitionCreationChecks()

ERROR_NUMBER PrimaryPartitionCreationChecks ( IN PPARTENTRY  PartEntry)

Definition at line 3954 of file partlist.c.

3956 {
3957  PDISKENTRY DiskEntry = PartEntry->DiskEntry;
3958 
3959  if (DiskEntry->DiskStyle == PARTITION_STYLE_GPT)
3960  {
3961  DPRINT1("GPT-partitioned disk detected, not currently supported by SETUP!\n");
3962  return ERROR_WARN_PARTITION;
3963  }
3964 
3965  /* Fail if the partition is already in use */
3966  if (PartEntry->IsPartitioned)
3967  return ERROR_NEW_PARTITION;
3968 
3969  /* Only one primary partition is allowed on super-floppy */
3970  if (IsSuperFloppy(DiskEntry))
3972 
3973  /* Fail if there are already 4 primary partitions in the list */
3974  if (GetPrimaryPartitionCount(DiskEntry) >= 4)
3976 
3977  return ERROR_SUCCESS;
3978 }
#define ERROR_SUCCESS
Definition: deptool.c:10
PARTITION_STYLE DiskStyle
Definition: partlist.h:121
static ULONG GetPrimaryPartitionCount(IN PDISKENTRY DiskEntry)
Definition: partlist.c:2428
BOOLEAN IsSuperFloppy(IN PDISKENTRY DiskEntry)
Definition: partlist.c:501
#define DPRINT1
Definition: precomp.h:8

Referenced by CreatePrimaryPartition(), and SelectPartitionPage().

◆ RoundingDivide()

ULONGLONG RoundingDivide ( IN ULONGLONG  Dividend,
IN ULONGLONG  Divisor 
)

Definition at line 95 of file partlist.c.

98 {
99  return (Dividend + Divisor / 2) / Divisor;
100 }
_In_ LARGE_INTEGER Divisor
Definition: rtlfuncs.h:3046

Referenced by PrettifySize1(), PrettifySize2(), PrintDiskData(), and PrintPartitionData().

◆ SelectPartition()

PPARTENTRY SelectPartition ( IN PPARTLIST  List,
IN ULONG  DiskNumber,
IN ULONG  PartitionNumber 
)

Definition at line 2183 of file partlist.c.

2187 {
2188  PDISKENTRY DiskEntry;
2189  PPARTENTRY PartEntry;
2190 
2191  DiskEntry = GetDiskByNumber(List, DiskNumber);
2192  if (!DiskEntry)
2193  return NULL;
2194 
2195  PartEntry = GetPartition(/*List,*/ DiskEntry, PartitionNumber);
2196  if (!PartEntry)
2197  return NULL;
2198 
2199  ASSERT(PartEntry->DiskEntry == DiskEntry);
2200  ASSERT(DiskEntry->DiskNumber == DiskNumber);
2201  ASSERT(PartEntry->PartitionNumber == PartitionNumber);
2202 
2203  return PartEntry;
2204 }
ULONG PartitionNumber
Definition: partlist.h:55
ULONG DiskNumber
Definition: partlist.h:111
_In_ ULONG _In_ ULONG PartitionNumber
Definition: iofuncs.h:2056
PPARTENTRY GetPartition(IN PDISKENTRY DiskEntry, IN ULONG PartitionNumber)
Definition: partlist.c:2096
PDISKENTRY GetDiskByNumber(IN PPARTLIST List, IN ULONG DiskNumber)
Definition: partlist.c:2014
struct _DISKENTRY * DiskEntry
Definition: partlist.h:46
#define ASSERT(a)
Definition: mode.c:45
_Must_inspect_result_ _In_ WDFCMRESLIST List
Definition: wdfresource.h:550
#define NULL
Definition: types.h:112

Referenced by SelectPartitionPage().

◆ SetActivePartition()

BOOLEAN SetActivePartition ( IN PPARTLIST  List,
IN PPARTENTRY  PartEntry,
IN PPARTENTRY OldActivePart  OPTIONAL 
)

Definition at line 3555 of file partlist.c.

3559 {
3560  /* Check for empty disk list */
3561  if (IsListEmpty(&List->DiskListHead))
3562  return FALSE;
3563 
3564  /* Validate the partition entry */
3565  if (!PartEntry)
3566  return FALSE;
3567 
3568  /*
3569  * If the partition entry is already the system partition, or if it is
3570  * the same as the old active partition hint the user provided (and if
3571  * it is already active), just return success.
3572  */
3573  if ((PartEntry == List->SystemPartition) ||
3574  ((PartEntry == OldActivePart) && IsPartitionActive(OldActivePart)))
3575  {
3576  return TRUE;
3577  }
3578 
3579  ASSERT(PartEntry->DiskEntry);
3580 
3581  /* Ensure that the partition's disk is in the list */
3582  ASSERT(PartEntry->DiskEntry->PartList == List);
3583 
3584  /*
3585  * If the user provided an old active partition hint, verify that it is
3586  * indeeed active and belongs to the same disk where the new partition
3587  * belongs. Otherwise determine the current active partition on the disk
3588  * where the new partition belongs.
3589  */
3590  if (!(OldActivePart && IsPartitionActive(OldActivePart) && (OldActivePart->DiskEntry == PartEntry->DiskEntry)))
3591  {
3592  /* It's not, determine the current active partition for the disk */
3593  OldActivePart = GetActiveDiskPartition(PartEntry->DiskEntry);
3594  }
3595 
3596  /* Unset the old active partition if it exists */
3597  if (OldActivePart)
3598  {
3599  OldActivePart->BootIndicator = FALSE;
3600  OldActivePart->DiskEntry->LayoutBuffer->PartitionEntry[OldActivePart->PartitionIndex].BootIndicator = FALSE;
3601  OldActivePart->DiskEntry->LayoutBuffer->PartitionEntry[OldActivePart->PartitionIndex].RewritePartition = TRUE;
3602  OldActivePart->DiskEntry->Dirty = TRUE;
3603  }
3604 
3605  /* Modify the system partition if the new partition is on the system disk */
3606  if (PartEntry->DiskEntry == GetSystemDisk(List))
3607  List->SystemPartition = PartEntry;
3608 
3609  /* Set the new active partition */
3610  PartEntry->BootIndicator = TRUE;
3611  PartEntry->DiskEntry->LayoutBuffer->PartitionEntry[PartEntry->PartitionIndex].BootIndicator = TRUE;
3612  PartEntry->DiskEntry->LayoutBuffer->PartitionEntry[PartEntry->PartitionIndex].RewritePartition = TRUE;
3613  PartEntry->DiskEntry->Dirty = TRUE;
3614 
3615  return TRUE;
3616 }
static PPARTENTRY GetActiveDiskPartition(IN PDISKENTRY DiskEntry)
Definition: partlist.c:1791
#define TRUE
Definition: types.h:120
_Must_inspect_result_ FORCEINLINE BOOLEAN IsListEmpty(_In_ const LIST_ENTRY *ListHead)
Definition: rtlfuncs.h:57
#define FALSE
Definition: types.h:117
#define ASSERT(a)
Definition: mode.c:45
static PDISKENTRY GetSystemDisk(IN PPARTLIST List)
Definition: partlist.c:1718
_Must_inspect_result_ _In_ WDFCMRESLIST List
Definition: wdfresource.h:550
BOOLEAN IsPartitionActive(IN PPARTENTRY PartEntry)
Definition: partlist.c:1768

Referenced by SelectFileSystemPage().

◆ SetMBRPartitionType()

VOID SetMBRPartitionType ( IN PPARTENTRY  PartEntry,
IN UCHAR  PartitionType 
)

Definition at line 3937 of file partlist.c.

3940 {
3941  PDISKENTRY DiskEntry = PartEntry->DiskEntry;
3942 
3943  ASSERT(DiskEntry->DiskStyle == PARTITION_STYLE_MBR);
3944 
3945  PartEntry->PartitionType = PartitionType;
3946 
3947  DiskEntry->Dirty = TRUE;
3948  DiskEntry->LayoutBuffer->PartitionEntry[PartEntry->PartitionIndex].PartitionType = PartitionType;
3949  DiskEntry->LayoutBuffer->PartitionEntry[PartEntry->PartitionIndex].RecognizedPartition = IsRecognizedPartition(PartitionType);
3950  DiskEntry->LayoutBuffer->PartitionEntry[PartEntry->PartitionIndex].RewritePartition = TRUE;
3951 }
#define TRUE
Definition: types.h:120
PARTITION_STYLE DiskStyle
Definition: partlist.h:121
BOOLEAN Dirty
Definition: partlist.h:118
PARTITION_INFORMATION PartitionEntry[1]
Definition: ntdddisk.h:426
#define ASSERT(a)
Definition: mode.c:45
#define IsRecognizedPartition(PartitionType)
Definition: ntdddisk.h:342
BOOLEAN RewritePartition
Definition: ntdddisk.h:420
CHAR PartitionType
Definition: part_xbox.c:32
BOOLEAN RecognizedPartition
Definition: ntdddisk.h:419
PDRIVE_LAYOUT_INFORMATION LayoutBuffer
Definition: partlist.h:125

Referenced by FormatPartition().

◆ SetMountedDeviceValue()

BOOLEAN SetMountedDeviceValue ( IN WCHAR  Letter,
IN ULONG  Signature,
IN LARGE_INTEGER  StartingOffset 
)

Definition at line 3800 of file partlist.c.

3804 {
3805  NTSTATUS Status;
3807  UNICODE_STRING KeyName = RTL_CONSTANT_STRING(L"SYSTEM\\MountedDevices");
3809  WCHAR ValueNameBuffer[16];
3810  HANDLE KeyHandle;
3811  REG_DISK_MOUNT_INFO MountInfo;
3812 
3813  RtlStringCchPrintfW(ValueNameBuffer, ARRAYSIZE(ValueNameBuffer),
3814  L"\\DosDevices\\%c:", Letter);
3815  RtlInitUnicodeString(&ValueName, ValueNameBuffer);
3816 
3818  &KeyName,
3821  NULL);
3822 
3825  &ObjectAttributes);
3826  if (!NT_SUCCESS(Status))
3827  {
3831  0,
3832  NULL,
3834  NULL);
3835  }
3836  if (!NT_SUCCESS(Status))
3837  {
3838  DPRINT1("NtCreateKey() failed (Status %lx)\n", Status);
3839  return FALSE;
3840  }
3841 
3842  MountInfo.Signature = Signature;
3843  MountInfo.StartingOffset = StartingOffset;
3845  &ValueName,
3846  0,
3847  REG_BINARY,
3848  (PVOID)&MountInfo,
3849  sizeof(MountInfo));
3850  NtClose(KeyHandle);
3851  if (!NT_SUCCESS(Status))
3852  {
3853  DPRINT1("NtSetValueKey() failed (Status %lx)\n", Status);
3854  return FALSE;
3855  }
3856 
3857  return TRUE;
3858 }
IN PUNICODE_STRING IN POBJECT_ATTRIBUTES ObjectAttributes
Definition: conport.c:35
LARGE_INTEGER StartingOffset
Definition: partlist.c:26
NTSTATUS NTAPI NtCreateKey(OUT PHANDLE KeyHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes, IN ULONG TitleIndex, IN PUNICODE_STRING Class OPTIONAL, IN ULONG CreateOptions, OUT PULONG Disposition OPTIONAL)
Definition: ntapi.c:240
_In_ PFCB _In_ LONGLONG StartingOffset
Definition: cdprocs.h:290
#define OBJ_CASE_INSENSITIVE
Definition: winternl.h:228
_Must_inspect_result_ _Out_ PNDIS_STATUS _In_ NDIS_HANDLE _In_ ULONG _Out_ PNDIS_STRING _Out_ PNDIS_HANDLE KeyHandle
Definition: ndis.h:4711
#define REG_BINARY
Definition: nt_native.h:1496
#define TRUE
Definition: types.h:120
NTSTRSAFEVAPI RtlStringCchPrintfW(_Out_writes_(cchDest) _Always_(_Post_z_) NTSTRSAFE_PWSTR pszDest, _In_ size_t cchDest, _In_ _Printf_format_string_ NTSTRSAFE_PCWSTR pszFormat,...)
Definition: ntstrsafe.h:1110
LONG NTSTATUS
Definition: precomp.h:26
#define ARRAYSIZE(array)
Definition: filtermapper.c:47
#define FALSE
Definition: types.h:117
_Must_inspect_result_ _In_ WDFDEVICE _In_ PCUNICODE_STRING KeyName
Definition: wdfdevice.h:2697
Status
Definition: gdiplustypes.h:24
#define REG_OPTION_NON_VOLATILE
Definition: nt_native.h:1057
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
NTSTATUS NTAPI NtClose(IN HANDLE Handle)
Definition: obhandle.c:3398
_Must_inspect_result_ _In_ WDFKEY _In_ PCUNICODE_STRING ValueName
Definition: wdfregistry.h:240
static const WCHAR L[]
Definition: oid.c:1250
WCHAR Letter
HANDLE GetRootKeyByPredefKey(IN HANDLE KeyHandle, OUT PCWSTR *RootKeyMountPoint OPTIONAL)
Definition: registry.c:90
#define KEY_ALL_ACCESS
Definition: nt_native.h:1041
#define NULL
Definition: types.h:112
NTSYSAPI NTSTATUS NTAPI NtSetValueKey(IN HANDLE KeyHandle, IN PUNICODE_STRING ValueName, IN ULONG TitleIndex OPTIONAL, IN ULONG Type, IN PVOID Data, IN ULONG DataSize)
Definition: ntapi.c:859
#define DPRINT1
Definition: precomp.h:8
NTSYSAPI NTSTATUS NTAPI NtOpenKey(OUT PHANDLE KeyHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes)
Definition: ntapi.c:336
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
#define InitializeObjectAttributes(p, n, a, r, s)
Definition: reg.c:106
static const WCHAR Signature[]
Definition: parser.c:141
#define HKEY_LOCAL_MACHINE
Definition: winreg.h:12
#define RTL_CONSTANT_STRING(s)
Definition: tunneltest.c:14

Referenced by SetMountedDeviceValues().

◆ SetMountedDeviceValues()

BOOLEAN SetMountedDeviceValues ( IN PPARTLIST  List)

Definition at line 3861 of file partlist.c.

3863 {
3864  PLIST_ENTRY Entry1, Entry2;
3865  PDISKENTRY DiskEntry;
3866  PPARTENTRY PartEntry;
3868 
3869  if (List == NULL)
3870  return FALSE;
3871 
3872  for (Entry1 = List->DiskListHead.Flink;
3873  Entry1 != &List->DiskListHead;
3874  Entry1 = Entry1->Flink)
3875  {
3876  DiskEntry = CONTAINING_RECORD(Entry1,
3877  DISKENTRY,
3878  ListEntry);
3879 
3880  if (DiskEntry->DiskStyle == PARTITION_STYLE_GPT)
3881  {
3882  DPRINT("GPT-partitioned disk detected, not currently supported by SETUP!\n");
3883  continue;
3884  }
3885 
3886  for (Entry2 = DiskEntry->PrimaryPartListHead.Flink;
3887  Entry2 != &DiskEntry->PrimaryPartListHead;
3888  Entry2 = Entry2->Flink)
3889  {
3890  PartEntry = CONTAINING_RECORD(Entry2, PARTENTRY, ListEntry);
3891  if (PartEntry->IsPartitioned) // && !IsContainerPartition(PartEntry->PartitionType)
3892  {
3894 
3895  /* Assign a "\DosDevices\#:" mount point to this partition */
3896  if (PartEntry->DriveLetter)
3897  {
3898  StartingOffset.QuadPart = PartEntry->StartSector.QuadPart * DiskEntry->BytesPerSector;
3899  if (!SetMountedDeviceValue(PartEntry->DriveLetter,
3900  DiskEntry->LayoutBuffer->Signature,
3901  StartingOffset))
3902  {
3903  return FALSE;
3904  }
3905  }
3906  }
3907  }
3908 
3909  for (Entry2 = DiskEntry->LogicalPartListHead.Flink;
3910  Entry2 != &DiskEntry->LogicalPartListHead;
3911  Entry2 = Entry2->Flink)
3912  {
3913  PartEntry = CONTAINING_RECORD(Entry2, PARTENTRY, ListEntry);
3914  if (PartEntry->IsPartitioned) // && !IsContainerPartition(PartEntry->PartitionType)
3915  {
3917 
3918  /* Assign a "\DosDevices\#:" mount point to this partition */
3919  if (PartEntry->DriveLetter)
3920  {
3921  StartingOffset.QuadPart = PartEntry->StartSector.QuadPart * DiskEntry->BytesPerSector;
3922  if (!SetMountedDeviceValue(PartEntry->DriveLetter,
3923  DiskEntry->LayoutBuffer->Signature,
3924  StartingOffset))
3925  {
3926  return FALSE;
3927  }
3928  }
3929  }
3930  }
3931  }
3932 
3933  return TRUE;
3934 }
LIST_ENTRY PrimaryPartListHead
Definition: partlist.h:131
WCHAR DriveLetter
Definition: partlist.h:58
ULARGE_INTEGER StartSector
Definition: partlist.h:49
_In_ PFCB _In_ LONGLONG StartingOffset
Definition: cdprocs.h:290
#define TRUE
Definition: types.h:120
BOOLEAN SetMountedDeviceValue(IN WCHAR Letter, IN ULONG Signature, IN LARGE_INTEGER StartingOffset)
Definition: partlist.c:3800
#define PARTITION_ENTRY_UNUSED
Definition: disk.h:86
PARTITION_STYLE DiskStyle
Definition: partlist.h:121
ULONGLONG QuadPart
Definition: ms-dtyp.idl:185
#define FALSE
Definition: types.h:117
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
struct _LIST_ENTRY * Flink
Definition: typedefs.h:121
UCHAR PartitionType
Definition: partlist.h:53
ULONG BytesPerSector
Definition: partlist.h:95
#define ASSERT(a)
Definition: mode.c:45
_Must_inspect_result_ _In_ WDFCMRESLIST List
Definition: wdfresource.h:550
Definition: typedefs.h:119
#define NULL
Definition: types.h:112
LIST_ENTRY LogicalPartListHead
Definition: partlist.h:132
#define DPRINT
Definition: sndvol32.h:71
PDRIVE_LAYOUT_INFORMATION LayoutBuffer
Definition: partlist.h:125
BOOLEAN IsPartitioned
Definition: partlist.h:66

Referenced by UpdateRegistry().

◆ WritePartitions()

NTSTATUS WritePartitions ( IN PDISKENTRY  DiskEntry)

Definition at line 3619 of file partlist.c.

3621 {
3622  NTSTATUS Status;
3627  ULONG BufferSize;
3629  ULONG PartitionCount;
3630  PLIST_ENTRY ListEntry;
3631  PPARTENTRY PartEntry;
3633 
3634  DPRINT("WritePartitions() Disk: %lu\n", DiskEntry->DiskNumber);
3635 
3636  /* If the disk is not dirty, there is nothing to do */
3637  if (!DiskEntry->Dirty)
3638  return STATUS_SUCCESS;
3639 
3641  L"\\Device\\Harddisk%lu\\Partition0",
3642  DiskEntry->DiskNumber);
3644 
3646  &Name,
3648  NULL,
3649  NULL);
3650 
3654  &Iosb,
3655  0,
3657  if (!NT_SUCCESS(Status))
3658  {
3659  DPRINT1("NtOpenFile() failed (Status %lx)\n", Status);
3660  return Status;
3661  }
3662 
3663 #ifdef DUMP_PARTITION_TABLE
3664  DumpPartitionTable(DiskEntry);
3665 #endif
3666 
3667  //
3668  // FIXME: We first *MUST* use IOCTL_DISK_CREATE_DISK to initialize
3669  // the disk in MBR or GPT format in case the disk was not initialized!!
3670  // For this we must ask the user which format to use.
3671  //
3672 
3673  /* Save the original partition count to be restored later (see comment below) */
3674  PartitionCount = DiskEntry->LayoutBuffer->PartitionCount;
3675 
3676  /* Set the new disk layout and retrieve its updated version with possibly modified partition numbers */
3678  ((PartitionCount - 1) * sizeof(PARTITION_INFORMATION));
3680  NULL,
3681  NULL,
3682  NULL,
3683  &Iosb,
3685  DiskEntry->LayoutBuffer,
3686  BufferSize,
3687  DiskEntry->LayoutBuffer,
3688  BufferSize);
3690 
3691  /*
3692  * IOCTL_DISK_SET_DRIVE_LAYOUT calls IoWritePartitionTable(), which converts
3693  * DiskEntry->LayoutBuffer->PartitionCount into a partition *table* count,
3694  * where such a table is expected to enumerate up to 4 partitions:
3695  * partition *table* count == ROUND_UP(PartitionCount, 4) / 4 .
3696  * Due to this we need to restore the original PartitionCount number.
3697  */
3698  DiskEntry->LayoutBuffer->PartitionCount = PartitionCount;
3699 
3700  /* Check whether the IOCTL_DISK_SET_DRIVE_LAYOUT call succeeded */
3701  if (!NT_SUCCESS(Status))
3702  {
3703  DPRINT1("IOCTL_DISK_SET_DRIVE_LAYOUT failed (Status 0x%08lx)\n", Status);
3704  return Status;
3705  }
3706 
3707 #ifdef DUMP_PARTITION_TABLE
3708  DumpPartitionTable(DiskEntry);
3709 #endif
3710 
3711  /* Update the partition numbers */
3712 
3713  /* Update the primary partition table */
3714  for (ListEntry = DiskEntry->PrimaryPartListHead.Flink;
3715  ListEntry != &DiskEntry->PrimaryPartListHead;
3716  ListEntry = ListEntry->Flink)
3717  {
3718  PartEntry = CONTAINING_RECORD(ListEntry, PARTENTRY, ListEntry);
3719 
3720  if (PartEntry->IsPartitioned)
3721  {
3723  PartitionInfo = &DiskEntry->LayoutBuffer->PartitionEntry[PartEntry->PartitionIndex];
3724  PartEntry->PartitionNumber = PartitionInfo->PartitionNumber;
3725  }
3726  }
3727 
3728  /* Update the logical partition table */
3729  for (ListEntry = DiskEntry->LogicalPartListHead.Flink;
3730  ListEntry != &DiskEntry->LogicalPartListHead;
3731  ListEntry = ListEntry->Flink)
3732  {
3733  PartEntry = CONTAINING_RECORD(ListEntry, PARTENTRY, ListEntry);
3734 
3735  if (PartEntry->IsPartitioned)
3736  {
3738  PartitionInfo = &DiskEntry->LayoutBuffer->PartitionEntry[PartEntry->PartitionIndex];
3739  PartEntry->PartitionNumber = PartitionInfo->PartitionNumber;
3740  }
3741  }
3742 
3743  //
3744  // NOTE: Originally (see r40437), we used to install here also a new MBR
3745  // for this disk (by calling InstallMbrBootCodeToDisk), only if:
3746  // DiskEntry->NewDisk == TRUE and DiskEntry->HwDiskNumber == 0.
3747  // Then after that, both DiskEntry->NewDisk and DiskEntry->NoMbr were set
3748  // to FALSE. In the other place (in usetup.c) where InstallMbrBootCodeToDisk
3749  // was called too, the installation test was modified by checking whether
3750  // DiskEntry->NoMbr was TRUE (instead of NewDisk).
3751  //
3752 
3753  // HACK: Parts of FIXMEs described above: (Re)set the PartitionStyle to MBR.
3754  DiskEntry->DiskStyle = PARTITION_STYLE_MBR;
3755 
3756  /* The layout has been successfully updated, the disk is not dirty anymore */
3757  DiskEntry->Dirty = FALSE;
3758 
3759  return Status;
3760 }
IN PUNICODE_STRING IN POBJECT_ATTRIBUTES ObjectAttributes
Definition: conport.c:35
ULONG PartitionNumber
Definition: partlist.h:55
#define OBJ_CASE_INSENSITIVE
Definition: winternl.h:228
NTSTRSAFEVAPI RtlStringCchPrintfW(_Out_writes_(cchDest) _Always_(_Post_z_) NTSTRSAFE_PWSTR pszDest, _In_ size_t cchDest, _In_ _Printf_format_string_ NTSTRSAFE_PCWSTR pszFormat,...)
Definition: ntstrsafe.h:1110
LONG NTSTATUS
Definition: precomp.h:26
#define ARRAYSIZE(array)
Definition: filtermapper.c:47
NTSYSAPI NTSTATUS NTAPI NtDeviceIoControlFile(IN HANDLE hFile, IN HANDLE hEvent OPTIONAL, IN PIO_APC_ROUTINE IoApcRoutine OPTIONAL, IN PVOID IoApcContext OPTIONAL, OUT PIO_STATUS_BLOCK pIoStatusBlock, IN ULONG DeviceIoControlCode, IN PVOID InBuffer OPTIONAL, IN ULONG InBufferLength, OUT PVOID OutBuffer OPTIONAL, IN ULONG OutBufferLength)
struct _PARTITION_INFORMATION PARTITION_INFORMATION
#define PARTITION_ENTRY_UNUSED
Definition: disk.h:86
HANDLE FileHandle
Definition: stats.c:38
#define FALSE
Definition: types.h:117
IN HANDLE DstPath
Definition: fsutil.h:75
#define GENERIC_WRITE
Definition: nt_native.h:90
struct _DRIVE_LAYOUT_INFORMATION DRIVE_LAYOUT_INFORMATION
struct NameRec_ * Name
Definition: cdprocs.h:459
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
Status
Definition: gdiplustypes.h:24
struct _LIST_ENTRY * Flink
Definition: typedefs.h:121
NTSYSAPI NTSTATUS NTAPI NtOpenFile(OUT PHANDLE phFile, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes, OUT PIO_STATUS_BLOCK pIoStatusBlock, IN ULONG ShareMode, IN ULONG OpenMode)
Definition: file.c:3951
UCHAR PartitionType
Definition: partlist.h:53
#define ASSERT(a)
Definition: mode.c:45
__wchar_t WCHAR
Definition: xmlstorage.h:180
return Iosb
Definition: create.c:4402
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define MAX_PATH
Definition: compat.h:34
_In_ ULONG _In_ struct _SET_PARTITION_INFORMATION_EX * PartitionInfo
Definition: iofuncs.h:2101
NTSTATUS NTAPI NtClose(IN HANDLE Handle)
Definition: obhandle.c:3398
static const WCHAR L[]
Definition: oid.c:1250
#define GENERIC_READ
Definition: compat.h:135
Definition: typedefs.h:119
#define SYNCHRONIZE
Definition: nt_native.h:61
#define NULL
Definition: types.h:112
#define DPRINT1
Definition: precomp.h:8
#define FILE_SYNCHRONOUS_IO_NONALERT
Definition: from_kernel.h:31
unsigned int ULONG
Definition: retypes.h:1
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
#define InitializeObjectAttributes(p, n, a, r, s)
Definition: reg.c:106
#define IOCTL_DISK_SET_DRIVE_LAYOUT
Definition: ntdddisk.h:205
#define STATUS_SUCCESS
Definition: shellext.h:65
#define DPRINT
Definition: sndvol32.h:71
#define BufferSize
Definition: mmc.h:75
_In_ WDFMEMORY _Out_opt_ size_t * BufferSize
Definition: wdfmemory.h:251
BOOLEAN IsPartitioned
Definition: partlist.h:66
ULONG PartitionIndex
Definition: partlist.h:56

Referenced by FormatPartition(), and WritePartitionsToDisk().

◆ WritePartitionsToDisk()

BOOLEAN WritePartitionsToDisk ( IN PPARTLIST  List)

Definition at line 3763 of file partlist.c.

3765 {
3766  NTSTATUS Status;
3768  PDISKENTRY DiskEntry;
3769 
3770  if (List == NULL)
3771  return TRUE;
3772 
3773  for (Entry = List->DiskListHead.Flink;
3774  Entry != &List->DiskListHead;
3775  Entry = Entry->Flink)
3776  {
3777  DiskEntry = CONTAINING_RECORD(Entry, DISKENTRY, ListEntry);
3778 
3779  if (DiskEntry->DiskStyle == PARTITION_STYLE_GPT)
3780  {
3781  DPRINT("GPT-partitioned disk detected, not currently supported by SETUP!\n");
3782  continue;
3783  }
3784 
3785  if (DiskEntry->Dirty != FALSE)
3786  {
3787  Status = WritePartitions(DiskEntry);
3788  if (!NT_SUCCESS(Status))
3789  {
3790  DPRINT1("WritePartitionsToDisk() failed to update disk %lu, Status 0x%08lx\n",
3791  DiskEntry->DiskNumber, Status);
3792  }
3793  }
3794  }
3795 
3796  return TRUE;
3797 }
struct _Entry Entry
Definition: kefuncs.h:627
#define TRUE
Definition: types.h:120
LONG NTSTATUS
Definition: precomp.h:26
ULONG DiskNumber
Definition: partlist.h:111
PARTITION_STYLE DiskStyle
Definition: partlist.h:121
#define FALSE
Definition: types.h:117
BOOLEAN Dirty
Definition: partlist.h:118
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
Status
Definition: gdiplustypes.h:24
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
_Must_inspect_result_ _In_ WDFCMRESLIST List
Definition: wdfresource.h:550
Definition: typedefs.h:119
#define NULL
Definition: types.h:112
#define DPRINT1
Definition: precomp.h:8
NTSTATUS WritePartitions(IN PDISKENTRY DiskEntry)
Definition: partlist.c:3619
#define DPRINT
Definition: sndvol32.h:71
base of all file and directory entries
Definition: entries.h:82

Referenced by SelectFileSystemPage().