projects / reactos.git / blob
? search:


47065e6cd09a38a2c7b972dc16886a912f72bf24
[reactos.git] / reactos / subsys / system / usetup / partlist.c
1 /*
2 * ReactOS kernel
3 * Copyright (C) 2002, 2003 ReactOS Team
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18 */
19 /* $Id: partlist.c,v 1.23 2003/08/29 11:27:16 ekohl Exp $
20 * COPYRIGHT: See COPYING in the top level directory
21 * PROJECT: ReactOS text-mode setup
22 * FILE: subsys/system/usetup/partlist.c
23 * PURPOSE: Partition list functions
24 * PROGRAMMER: Eric Kohl
25 * Casper S. Hornstrup (chorns@users.sourceforge.net)
26 */
27
28 #include <ddk/ntddk.h>
29 #include <ddk/ntddscsi.h>
30
31 #include <ntdll/rtl.h>
32
33 #include <ntos/minmax.h>
34
35 #include "usetup.h"
36 #include "console.h"
37 #include "partlist.h"
38 #include "drivesup.h"
39
40
41 /* FUNCTIONS ****************************************************************/
42
43 static VOID
44 GetDriverName (PDISKENTRY DiskEntry)
45 {
46 RTL_QUERY_REGISTRY_TABLE QueryTable[2];
47 WCHAR KeyName[32];
48 NTSTATUS Status;
49
50 RtlInitUnicodeString (&DiskEntry->DriverName,
51 NULL);
52
53 swprintf (KeyName,
54 L"\\Scsi\\Scsi Port %lu",
55 DiskEntry->Port);
56
57 RtlZeroMemory (&QueryTable,
58 sizeof(QueryTable));
59
60 QueryTable[0].Name = L"Driver";
61 QueryTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT;
62 QueryTable[0].EntryContext = &DiskEntry->DriverName;
63
64 Status = RtlQueryRegistryValues (RTL_REGISTRY_DEVICEMAP,
65 KeyName,
66 QueryTable,
67 NULL,
68 NULL);
69 if (!NT_SUCCESS (Status))
70 {
71 DPRINT1 ("RtlQueryRegistryValues() failed (Status %lx)\n", Status);
72 }
73 }
74
75
76 static VOID
77 AssignDriverLetters (PPARTLIST List)
78 {
79 PDISKENTRY DiskEntry;
80 PPARTENTRY PartEntry;
81 PLIST_ENTRY Entry1;
82 PLIST_ENTRY Entry2;
83 CHAR Letter;
84
85 Letter = 'C';
86
87 /* Assign drive letters to primary partitions */
88 Entry1 = List->DiskListHead.Flink;
89 while (Entry1 != &List->DiskListHead)
90 {
91 DiskEntry = CONTAINING_RECORD (Entry1, DISKENTRY, ListEntry);
92
93 if (!IsListEmpty (&DiskEntry->PartListHead))
94 {
95 PartEntry = CONTAINING_RECORD (DiskEntry->PartListHead.Flink,
96 PARTENTRY,
97 ListEntry);
98
99 PartEntry->DriveLetter = 0;
100
101 if (PartEntry->Unpartitioned == FALSE &&
102 !IsContainerPartition (PartEntry->PartInfo[0].PartitionType))
103 {
104 if (IsRecognizedPartition (PartEntry->PartInfo[0].PartitionType) ||
105 (PartEntry->PartInfo[0].PartitionType == PARTITION_ENTRY_UNUSED &&
106 PartEntry->PartInfo[0].PartitionLength.QuadPart != 0LL))
107 {
108 if (Letter <= 'Z')
109 {
110 PartEntry->DriveLetter = Letter;
111 Letter++;
112 }
113 }
114 }
115 }
116
117 Entry1 = Entry1->Flink;
118 }
119
120
121 /* Assign drive letters to logical drives */
122 Entry1 = List->DiskListHead.Flink;
123 while (Entry1 != &List->DiskListHead)
124 {
125 DiskEntry = CONTAINING_RECORD (Entry1, DISKENTRY, ListEntry);
126
127 Entry2 = DiskEntry->PartListHead.Flink;
128 if (Entry2 != &DiskEntry->PartListHead)
129 {
130 Entry2 = Entry2->Flink;
131 while (Entry2 != &DiskEntry->PartListHead)
132 {
133 PartEntry = CONTAINING_RECORD (Entry2,
134 PARTENTRY,
135 ListEntry);
136
137 PartEntry->DriveLetter = 0;
138
139 if (PartEntry->Unpartitioned == FALSE &&
140 !IsContainerPartition (PartEntry->PartInfo[0].PartitionType))
141 {
142 if (IsRecognizedPartition (PartEntry->PartInfo[0].PartitionType) ||
143 (PartEntry->PartInfo[0].PartitionType == PARTITION_ENTRY_UNUSED &&
144 PartEntry->PartInfo[0].PartitionLength.QuadPart != 0LL))
145 {
146 if (Letter <= 'Z')
147 {
148 PartEntry->DriveLetter = Letter;
149 Letter++;
150 }
151 }
152 }
153
154 Entry2 = Entry2->Flink;
155 }
156 }
157
158 Entry1 = Entry1->Flink;
159 }
160 }
161
162
163 static VOID
164 UpdatePartitionNumbers (PDISKENTRY DiskEntry)
165 {
166 PPARTENTRY PartEntry;
167 PLIST_ENTRY Entry;
168 ULONG PartNumber;
169 ULONG i;
170
171 PartNumber = 1;
172 Entry = DiskEntry->PartListHead.Flink;
173 while (Entry != &DiskEntry->PartListHead)
174 {
175 PartEntry = CONTAINING_RECORD (Entry,
176 PARTENTRY,
177 ListEntry);
178
179 if (PartEntry->Unpartitioned == TRUE)
180 {
181 for (i = 0; i < 4; i++)
182 {
183 PartEntry->PartInfo[i].PartitionNumber = 0;
184 }
185 }
186 else
187 {
188 for (i = 0; i < 4; i++)
189 {
190 if (IsContainerPartition (PartEntry->PartInfo[i].PartitionType))
191 {
192 PartEntry->PartInfo[i].PartitionNumber = 0;
193 }
194 else if (PartEntry->PartInfo[i].PartitionType == PARTITION_ENTRY_UNUSED &&
195 PartEntry->PartInfo[i].PartitionLength.QuadPart == 0ULL)
196 {
197 PartEntry->PartInfo[i].PartitionNumber = 0;
198 }
199 else
200 {
201 PartEntry->PartInfo[i].PartitionNumber = PartNumber;
202 PartNumber++;
203 }
204 }
205 }
206
207 Entry = Entry->Flink;
208 }
209 }
210
211
212 static VOID
213 AddPartitionToList (ULONG DiskNumber,
214 PDISKENTRY DiskEntry,
215 DRIVE_LAYOUT_INFORMATION *LayoutBuffer)
216 {
217 PPARTENTRY PartEntry;
218 ULONG i;
219 ULONG j;
220
221 for (i = 0; i < LayoutBuffer->PartitionCount; i += 4)
222 {
223 for (j = 0; j < 4; j++)
224 {
225 if (LayoutBuffer->PartitionEntry[j].PartitionType != PARTITION_ENTRY_UNUSED ||
226 LayoutBuffer->PartitionEntry[j].PartitionLength.QuadPart != 0ULL)
227 {
228 break;
229 }
230 }
231 if (j >= 4)
232 {
233 continue;
234 }
235
236 PartEntry = (PPARTENTRY)RtlAllocateHeap (ProcessHeap,
237 0,
238 sizeof(PARTENTRY));
239 if (PartEntry == NULL)
240 {
241 return;
242 }
243
244 RtlZeroMemory (PartEntry,
245 sizeof(PARTENTRY));
246
247 PartEntry->Unpartitioned = FALSE;
248
249 for (j = 0; j < 4; j++)
250 {
251 RtlCopyMemory (&PartEntry->PartInfo[j],
252 &LayoutBuffer->PartitionEntry[i+j],
253 sizeof(PARTITION_INFORMATION));
254 }
255
256 if (IsContainerPartition(PartEntry->PartInfo[0].PartitionType))
257 {
258 PartEntry->FormatState = Unformatted;
259 }
260 else if ((PartEntry->PartInfo[0].PartitionType == PARTITION_FAT_12) ||
261 (PartEntry->PartInfo[0].PartitionType == PARTITION_FAT_16) ||
262 (PartEntry->PartInfo[0].PartitionType == PARTITION_HUGE) ||
263 (PartEntry->PartInfo[0].PartitionType == PARTITION_XINT13) ||
264 (PartEntry->PartInfo[0].PartitionType == PARTITION_FAT32) ||
265 (PartEntry->PartInfo[0].PartitionType == PARTITION_FAT32_XINT13))
266 {
267 #if 0
268 if (CheckFatFormat())
269 {
270 PartEntry->FormatState = Preformatted;
271 }
272 else
273 {
274 PartEntry->FormatState = Unformatted;
275 }
276 #endif
277 PartEntry->FormatState = Preformatted;
278 }
279 else if (PartEntry->PartInfo[0].PartitionType == PARTITION_IFS)
280 {
281 #if 0
282 if (CheckNtfsFormat())
283 {
284 PartEntry->FormatState = Preformatted;
285 }
286 else if (CheckHpfsFormat())
287 {
288 PartEntry->FormatState = Preformatted;
289 }
290 else
291 {
292 PartEntry->FormatState = Unformatted;
293 }
294 #endif
295 PartEntry->FormatState = Preformatted;
296 }
297 else
298 {
299 PartEntry->FormatState = Unknown;
300 }
301
302 InsertTailList (&DiskEntry->PartListHead,
303 &PartEntry->ListEntry);
304 }
305 }
306
307
308 static VOID
309 ScanForUnpartitionedDiskSpace (PDISKENTRY DiskEntry)
310 {
311 ULONGLONG LastStartingOffset;
312 ULONGLONG LastPartitionLength;
313 ULONGLONG LastUnusedPartitionLength;
314 PPARTENTRY PartEntry;
315 PPARTENTRY NewPartEntry;
316 PLIST_ENTRY Entry;
317 ULONG i;
318 ULONG j;
319
320 if (IsListEmpty (&DiskEntry->PartListHead))
321 {
322 /* Create a partition table that represents the empty disk */
323 PartEntry = (PPARTENTRY)RtlAllocateHeap (ProcessHeap,
324 0,
325 sizeof(PARTENTRY));
326 if (PartEntry == NULL)
327 return;
328
329 RtlZeroMemory (PartEntry,
330 sizeof(PARTENTRY));
331
332 PartEntry->Unpartitioned = TRUE;
333 PartEntry->UnpartitionedOffset = 0ULL;
334 PartEntry->UnpartitionedLength = DiskEntry->DiskSize;
335
336 PartEntry->FormatState = Unformatted;
337
338 InsertTailList (&DiskEntry->PartListHead,
339 &PartEntry->ListEntry);
340 }
341 else
342 {
343 /* Start partition at head 1, cylinder 0 */
344 LastStartingOffset = DiskEntry->TrackSize;
345 LastPartitionLength = 0ULL;
346 LastUnusedPartitionLength = 0ULL;
347
348 i = 0;
349 Entry = DiskEntry->PartListHead.Flink;
350 while (Entry != &DiskEntry->PartListHead)
351 {
352 PartEntry = CONTAINING_RECORD (Entry, PARTENTRY, ListEntry);
353
354 for (j = 0; j < 4; j++)
355 {
356 if ((!IsContainerPartition (PartEntry->PartInfo[j].PartitionType)) &&
357 (PartEntry->PartInfo[j].PartitionType != PARTITION_ENTRY_UNUSED ||
358 PartEntry->PartInfo[j].PartitionLength.QuadPart != 0LL))
359 {
360 LastUnusedPartitionLength =
361 PartEntry->PartInfo[j].StartingOffset.QuadPart -
362 (LastStartingOffset + LastPartitionLength);
363
364 if (LastUnusedPartitionLength >= DiskEntry->CylinderSize)
365 {
366 DPRINT ("Unpartitioned disk space %I64u\n", LastUnusedPartitionLength);
367
368 NewPartEntry = (PPARTENTRY)RtlAllocateHeap (ProcessHeap,
369 0,
370 sizeof(PARTENTRY));
371 if (NewPartEntry == NULL)
372 return;
373
374 RtlZeroMemory (NewPartEntry,
375 sizeof(PARTENTRY));
376
377 NewPartEntry->Unpartitioned = TRUE;
378 NewPartEntry->UnpartitionedOffset = LastStartingOffset + LastPartitionLength;
379 NewPartEntry->UnpartitionedLength = LastUnusedPartitionLength;
380 if (j == 0)
381 NewPartEntry->UnpartitionedLength -= DiskEntry->TrackSize;
382
383 NewPartEntry->FormatState = Unformatted;
384
385 /* Insert the table into the list */
386 InsertTailList (&PartEntry->ListEntry,
387 &NewPartEntry->ListEntry);
388 }
389
390 LastStartingOffset = PartEntry->PartInfo[j].StartingOffset.QuadPart;
391 LastPartitionLength = PartEntry->PartInfo[j].PartitionLength.QuadPart;
392 }
393 }
394
395 i += 4;
396 Entry = Entry->Flink;
397 }
398
399 /* Check for trailing unpartitioned disk space */
400 if (DiskEntry->DiskSize > (LastStartingOffset + LastPartitionLength))
401 {
402 /* Round-down to cylinder size */
403 LastUnusedPartitionLength =
404 ROUND_DOWN (DiskEntry->DiskSize - (LastStartingOffset + LastPartitionLength),
405 DiskEntry->CylinderSize);
406
407 if (LastUnusedPartitionLength >= DiskEntry->CylinderSize)
408 {
409 DPRINT ("Unpartitioned disk space %I64u\n", LastUnusedPartitionLength);
410
411 NewPartEntry = (PPARTENTRY)RtlAllocateHeap (ProcessHeap,
412 0,
413 sizeof(PARTENTRY));
414 if (NewPartEntry == NULL)
415 return;
416
417 RtlZeroMemory (NewPartEntry,
418 sizeof(PARTENTRY));
419
420 NewPartEntry->Unpartitioned = TRUE;
421 NewPartEntry->UnpartitionedOffset = LastStartingOffset + LastPartitionLength;
422 NewPartEntry->UnpartitionedLength = LastUnusedPartitionLength;
423
424 /* Append the table to the list */
425 InsertTailList (&DiskEntry->PartListHead,
426 &NewPartEntry->ListEntry);
427 }
428 }
429 }
430 }
431
432
433 static VOID
434 AddDiskToList (HANDLE FileHandle,
435 ULONG DiskNumber,
436 PPARTLIST List)
437 {
438 DRIVE_LAYOUT_INFORMATION *LayoutBuffer;
439 DISK_GEOMETRY DiskGeometry;
440 SCSI_ADDRESS ScsiAddress;
441 PDISKENTRY DiskEntry;
442 IO_STATUS_BLOCK Iosb;
443 NTSTATUS Status;
444
445 Status = NtDeviceIoControlFile (FileHandle,
446 NULL,
447 NULL,
448 NULL,
449 &Iosb,
450 IOCTL_DISK_GET_DRIVE_GEOMETRY,
451 NULL,
452 0,
453 &DiskGeometry,
454 sizeof(DISK_GEOMETRY));
455 if (!NT_SUCCESS (Status))
456 {
457 return;
458 }
459
460 if (DiskGeometry.MediaType != FixedMedia)
461 {
462 return;
463 }
464
465 Status = NtDeviceIoControlFile (FileHandle,
466 NULL,
467 NULL,
468 NULL,
469 &Iosb,
470 IOCTL_SCSI_GET_ADDRESS,
471 NULL,
472 0,
473 &ScsiAddress,
474 sizeof(SCSI_ADDRESS));
475 if (!NT_SUCCESS(Status))
476 {
477 return;
478 }
479
480 DiskEntry = (PDISKENTRY)RtlAllocateHeap (ProcessHeap,
481 0,
482 sizeof(DISKENTRY));
483 if (DiskEntry == NULL)
484 {
485 return;
486 }
487
488 InitializeListHead (&DiskEntry->PartListHead);
489
490 DiskEntry->Cylinders = DiskGeometry.Cylinders.QuadPart;
491 DiskEntry->TracksPerCylinder = DiskGeometry.TracksPerCylinder;
492 DiskEntry->SectorsPerTrack = DiskGeometry.SectorsPerTrack;
493 DiskEntry->BytesPerSector = DiskGeometry.BytesPerSector;
494
495 DPRINT ("Cylinders %d\n", DiskEntry->Cylinders);
496 DPRINT ("TracksPerCylinder %d\n", DiskEntry->TracksPerCylinder);
497 DPRINT ("SectorsPerTrack %d\n", DiskEntry->SectorsPerTrack);
498 DPRINT ("BytesPerSector %d\n", DiskEntry->BytesPerSector);
499
500 DiskEntry->DiskSize =
501 DiskGeometry.Cylinders.QuadPart *
502 (ULONGLONG)DiskGeometry.TracksPerCylinder *
503 (ULONGLONG)DiskGeometry.SectorsPerTrack *
504 (ULONGLONG)DiskGeometry.BytesPerSector;
505 DiskEntry->CylinderSize =
506 (ULONGLONG)DiskGeometry.TracksPerCylinder *
507 (ULONGLONG)DiskGeometry.SectorsPerTrack *
508 (ULONGLONG)DiskGeometry.BytesPerSector;
509 DiskEntry->TrackSize =
510 (ULONGLONG)DiskGeometry.SectorsPerTrack *
511 (ULONGLONG)DiskGeometry.BytesPerSector;
512
513 DiskEntry->DiskNumber = DiskNumber;
514 DiskEntry->Port = ScsiAddress.PortNumber;
515 DiskEntry->Bus = ScsiAddress.PathId;
516 DiskEntry->Id = ScsiAddress.TargetId;
517
518 GetDriverName (DiskEntry);
519
520 InsertTailList (&List->DiskListHead,
521 &DiskEntry->ListEntry);
522
523 LayoutBuffer = (DRIVE_LAYOUT_INFORMATION*)RtlAllocateHeap (ProcessHeap,
524 0,
525 8192);
526 if (LayoutBuffer == NULL)
527 {
528 return;
529 }
530
531 Status = NtDeviceIoControlFile (FileHandle,
532 NULL,
533 NULL,
534 NULL,
535 &Iosb,
536 IOCTL_DISK_GET_DRIVE_LAYOUT,
537 NULL,
538 0,
539 LayoutBuffer,
540 8192);
541 if (NT_SUCCESS (Status))
542 {
543 if (LayoutBuffer->PartitionCount == 0)
544 {
545 DiskEntry->NewDisk = TRUE;
546 }
547
548 AddPartitionToList (DiskNumber,
549 DiskEntry,
550 LayoutBuffer);
551
552 ScanForUnpartitionedDiskSpace (DiskEntry);
553 }
554
555 RtlFreeHeap (ProcessHeap,
556 0,
557 LayoutBuffer);
558 }
559
560
561 PPARTLIST
562 CreatePartitionList (SHORT Left,
563 SHORT Top,
564 SHORT Right,
565 SHORT Bottom)
566 {
567 PPARTLIST List;
568 OBJECT_ATTRIBUTES ObjectAttributes;
569 SYSTEM_DEVICE_INFORMATION Sdi;
570 DISK_GEOMETRY DiskGeometry;
571 IO_STATUS_BLOCK Iosb;
572 ULONG ReturnSize;
573 NTSTATUS Status;
574 ULONG DiskNumber;
575 WCHAR Buffer[MAX_PATH];
576 UNICODE_STRING Name;
577 HANDLE FileHandle;
578
579 List = (PPARTLIST)RtlAllocateHeap (ProcessHeap,
580 0,
581 sizeof (PARTLIST));
582 if (List == NULL)
583 return NULL;
584
585 List->Left = Left;
586 List->Top = Top;
587 List->Right = Right;
588 List->Bottom = Bottom;
589
590 List->Line = 0;
591
592 List->TopDisk = (ULONG)-1;
593 List->TopPartition = (ULONG)-1;
594
595 List->CurrentDisk = NULL;
596 List->CurrentPartition = NULL;
597
598 InitializeListHead (&List->DiskListHead);
599
600 Status = NtQuerySystemInformation (SystemDeviceInformation,
601 &Sdi,
602 sizeof(SYSTEM_DEVICE_INFORMATION),
603 &ReturnSize);
604 if (!NT_SUCCESS (Status))
605 {
606 RtlFreeHeap (ProcessHeap, 0, List);
607 return NULL;
608 }
609
610 for (DiskNumber = 0; DiskNumber < Sdi.NumberOfDisks; DiskNumber++)
611 {
612 swprintf (Buffer,
613 L"\\Device\\Harddisk%d\\Partition0",
614 DiskNumber);
615 RtlInitUnicodeString (&Name,
616 Buffer);
617
618 InitializeObjectAttributes (&ObjectAttributes,
619 &Name,
620 0,
621 NULL,
622 NULL);
623
624 Status = NtOpenFile (&FileHandle,
625 FILE_GENERIC_READ,
626 &ObjectAttributes,
627 &Iosb,
628 FILE_SHARE_READ,
629 FILE_SYNCHRONOUS_IO_NONALERT);
630 if (NT_SUCCESS(Status))
631 {
632 AddDiskToList (FileHandle,
633 DiskNumber,
634 List);
635
636 NtClose(FileHandle);
637 }
638 }
639
640 AssignDriverLetters (List);
641
642 List->TopDisk = 0;
643 List->TopPartition = 0;
644
645 /* Search for first usable disk and partition */
646 if (IsListEmpty (&List->DiskListHead))
647 {
648 List->CurrentDisk = NULL;
649 List->CurrentPartition = NULL;
650 }
651 else
652 {
653 List->CurrentDisk =
654 CONTAINING_RECORD (List->DiskListHead.Flink,
655 DISKENTRY,
656 ListEntry);
657
658 if (IsListEmpty (&List->CurrentDisk->PartListHead))
659 {
660 List->CurrentPartition = 0;
661 }
662 else
663 {
664 List->CurrentPartition =
665 CONTAINING_RECORD (List->CurrentDisk->PartListHead.Flink,
666 PARTENTRY,
667 ListEntry);
668 }
669 }
670
671 return List;
672 }
673
674
675 VOID
676 DestroyPartitionList (PPARTLIST List)
677 {
678 PDISKENTRY DiskEntry;
679 PPARTENTRY PartEntry;
680 PLIST_ENTRY Entry;
681
682 /* Release disk and partition info */
683 while (!IsListEmpty (&List->DiskListHead))
684 {
685 Entry = RemoveHeadList (&List->DiskListHead);
686 DiskEntry = CONTAINING_RECORD (Entry, DISKENTRY, ListEntry);
687
688 /* Release driver name */
689 RtlFreeUnicodeString(&DiskEntry->DriverName);
690
691 /* Release partition array */
692 while (!IsListEmpty (&DiskEntry->PartListHead))
693 {
694 Entry = RemoveHeadList (&DiskEntry->PartListHead);
695 PartEntry = CONTAINING_RECORD (Entry, PARTENTRY, ListEntry);
696
697 RtlFreeHeap (ProcessHeap,
698 0,
699 PartEntry);
700 }
701
702 /* Release disk entry */
703 RtlFreeHeap (ProcessHeap, 0, DiskEntry);
704 }
705
706 /* Release list head */
707 RtlFreeHeap (ProcessHeap, 0, List);
708 }
709
710
711 static VOID
712 PrintEmptyLine (PPARTLIST List)
713 {
714 COORD coPos;
715 ULONG Written;
716 USHORT Width;
717 USHORT Height;
718
719 Width = List->Right - List->Left - 1;
720 Height = List->Bottom - List->Top - 1;
721
722 if (List->Line < 0 || List->Line > Height)
723 return;
724
725 coPos.X = List->Left + 1;
726 coPos.Y = List->Top + 1 + List->Line;
727
728 FillConsoleOutputAttribute (0x17,
729 Width,
730 coPos,
731 &Written);
732
733 FillConsoleOutputCharacter (' ',
734 Width,
735 coPos,
736 &Written);
737
738 List->Line++;
739 }
740
741
742 static VOID
743 PrintPartitionData (PPARTLIST List,
744 PDISKENTRY DiskEntry,
745 PPARTENTRY PartEntry)
746 {
747 CHAR LineBuffer[128];
748 COORD coPos;
749 ULONG Written;
750 USHORT Width;
751 USHORT Height;
752
753 ULONGLONG PartSize;
754 PCHAR Unit;
755 UCHAR Attribute;
756 PCHAR PartType;
757
758 Width = List->Right - List->Left - 1;
759 Height = List->Bottom - List->Top - 1;
760
761 if (List->Line < 0 || List->Line > Height)
762 return;
763
764 coPos.X = List->Left + 1;
765 coPos.Y = List->Top + 1 + List->Line;
766
767 if (PartEntry->Unpartitioned == TRUE)
768 {
769 #if 0
770 if (PartEntry->UnpartitionledLength >= 0x280000000ULL) /* 10 GB */
771 {
772 PartSize = (PartEntry->UnpartitionedLength + (1 << 29)) >> 30;
773 Unit = "GB";
774 }
775 else
776 #endif
777 if (PartEntry->UnpartitionedLength >= 0xA00000ULL) /* 10 MB */
778 {
779 PartSize = (PartEntry->UnpartitionedLength + (1 << 19)) >> 20;
780 Unit = "MB";
781 }
782 else
783 {
784 PartSize = (PartEntry->UnpartitionedLength + (1 << 9)) >> 10;
785 Unit = "KB";
786 }
787
788 sprintf (LineBuffer,
789 " Unpartitioned space %6I64u %s",
790 PartSize,
791 Unit);
792 }
793 else
794 {
795 /* Determine partition type */
796 PartType = NULL;
797 if (PartEntry->New == TRUE)
798 {
799 PartType = "New (Unformatted)";
800 }
801 else if (PartEntry->Unpartitioned == FALSE)
802 {
803 if ((PartEntry->PartInfo[0].PartitionType == PARTITION_FAT_12) ||
804 (PartEntry->PartInfo[0].PartitionType == PARTITION_FAT_16) ||
805 (PartEntry->PartInfo[0].PartitionType == PARTITION_HUGE) ||
806 (PartEntry->PartInfo[0].PartitionType == PARTITION_XINT13))
807 {
808 PartType = "FAT";
809 }
810 else if ((PartEntry->PartInfo[0].PartitionType == PARTITION_FAT32) ||
811 (PartEntry->PartInfo[0].PartitionType == PARTITION_FAT32_XINT13))
812 {
813 PartType = "FAT32";
814 }
815 else if (PartEntry->PartInfo[0].PartitionType == PARTITION_IFS)
816 {
817 PartType = "NTFS"; /* FIXME: Not quite correct! */
818 }
819 }
820
821 #if 0
822 if (PartEntry->PartInfo[0].PartitionLength.QuadPart >= 0x280000000ULL) /* 10 GB */
823 {
824 PartSize = (PartEntry->PartInfo[0].PartitionLength.QuadPart + (1 << 29)) >> 30;
825 Unit = "GB";
826 }
827 else
828 #endif
829 if (PartEntry->PartInfo[0].PartitionLength.QuadPart >= 0xA00000ULL) /* 10 MB */
830 {
831 PartSize = (PartEntry->PartInfo[0].PartitionLength.QuadPart + (1 << 19)) >> 20;
832 Unit = "MB";
833 }
834 else
835 {
836 PartSize = (PartEntry->PartInfo[0].PartitionLength.QuadPart + (1 << 9)) >> 10;
837 Unit = "KB";
838 }
839
840 if (PartType == NULL)
841 {
842 sprintf (LineBuffer,
843 "%c%c Type %-3lu %6I64u %s",
844 (PartEntry->DriveLetter == 0) ? '-' : PartEntry->DriveLetter,
845 (PartEntry->DriveLetter == 0) ? '-' : ':',
846 PartEntry->PartInfo[0].PartitionType,
847 PartSize,
848 Unit);
849 }
850 else
851 {
852 sprintf (LineBuffer,
853 "%c%c %-24s %6I64u %s",
854 (PartEntry->DriveLetter == 0) ? '-' : PartEntry->DriveLetter,
855 (PartEntry->DriveLetter == 0) ? '-' : ':',
856 PartType,
857 PartSize,
858 Unit);
859 }
860 }
861
862 Attribute = (List->CurrentDisk == DiskEntry &&
863 List->CurrentPartition == PartEntry) ? 0x71 : 0x17;
864
865 FillConsoleOutputCharacter (' ',
866 Width,
867 coPos,
868 &Written);
869
870 coPos.X += 4;
871 Width -= 8;
872 FillConsoleOutputAttribute (Attribute,
873 Width,
874 coPos,
875 &Written);
876
877 coPos.X++;
878 Width -= 2;
879 WriteConsoleOutputCharacters (LineBuffer,
880 min (strlen (LineBuffer), Width),
881 coPos);
882
883 List->Line++;
884 }
885
886
887 static VOID
888 PrintDiskData (PPARTLIST List,
889 PDISKENTRY DiskEntry)
890 {
891 PPARTENTRY PartEntry;
892 PLIST_ENTRY Entry;
893 CHAR LineBuffer[128];
894 COORD coPos;
895 ULONG Written;
896 USHORT Width;
897 USHORT Height;
898 ULONGLONG DiskSize;
899 PCHAR Unit;
900 SHORT PartIndex;
901
902 Width = List->Right - List->Left - 1;
903 Height = List->Bottom - List->Top - 1;
904
905 if (List->Line < 0 || List->Line > Height)
906 return;
907
908 coPos.X = List->Left + 1;
909 coPos.Y = List->Top + 1 + List->Line;
910
911 #if 0
912 if (DiskEntry->DiskSize >= 0x280000000ULL) /* 10 GB */
913 {
914 DiskSize = (DiskEntry->DiskSize + (1 << 29)) >> 30;
915 Unit = "GB";
916 }
917 else
918 #endif
919 {
920 DiskSize = (DiskEntry->DiskSize + (1 << 19)) >> 20;
921 if (DiskSize == 0)
922 DiskSize = 1;
923 Unit = "MB";
924 }
925
926 if (DiskEntry->DriverName.Length > 0)
927 {
928 sprintf (LineBuffer,
929 "%6I64u %s Harddisk %lu (Port=%hu, Bus=%hu, Id=%hu) on %wZ",
930 DiskSize,
931 Unit,
932 DiskEntry->DiskNumber,
933 DiskEntry->Port,
934 DiskEntry->Bus,
935 DiskEntry->Id,
936 &DiskEntry->DriverName);
937 }
938 else
939 {
940 sprintf (LineBuffer,
941 "%6I64u %s Harddisk %lu (Port=%hu, Bus=%hu, Id=%hu)",
942 DiskSize,
943 Unit,
944 DiskEntry->DiskNumber,
945 DiskEntry->Port,
946 DiskEntry->Bus,
947 DiskEntry->Id);
948 }
949
950 FillConsoleOutputAttribute (0x17,
951 Width,
952 coPos,
953 &Written);
954
955 FillConsoleOutputCharacter (' ',
956 Width,
957 coPos,
958 &Written);
959
960 coPos.X++;
961 WriteConsoleOutputCharacters (LineBuffer,
962 min (strlen (LineBuffer), Width - 2),
963 coPos);
964
965 List->Line++;
966
967 /* Print separator line */
968 PrintEmptyLine (List);
969
970 /* Print partition lines*/
971 Entry = DiskEntry->PartListHead.Flink;
972 while (Entry != &DiskEntry->PartListHead)
973 {
974 PartEntry = CONTAINING_RECORD (Entry, PARTENTRY, ListEntry);
975
976 /* Print disk entry */
977 PrintPartitionData (List,
978 DiskEntry,
979 PartEntry);
980
981 Entry = Entry->Flink;
982 }
983
984 /* Print separator line */
985 PrintEmptyLine (List);
986 }
987
988
989 VOID
990 DrawPartitionList (PPARTLIST List)
991 {
992 PLIST_ENTRY Entry;
993 PDISKENTRY DiskEntry;
994 CHAR LineBuffer[128];
995 COORD coPos;
996 ULONG Written;
997 SHORT i;
998 SHORT DiskIndex;
999
1000 /* draw upper left corner */
1001 coPos.X = List->Left;
1002 coPos.Y = List->Top;
1003 FillConsoleOutputCharacter (0xDA, // '+',
1004 1,
1005 coPos,
1006 &Written);
1007
1008 /* draw upper edge */
1009 coPos.X = List->Left + 1;
1010 coPos.Y = List->Top;
1011 FillConsoleOutputCharacter (0xC4, // '-',
1012 List->Right - List->Left - 1,
1013 coPos,
1014 &Written);
1015
1016 /* draw upper right corner */
1017 coPos.X = List->Right;
1018 coPos.Y = List->Top;
1019 FillConsoleOutputCharacter (0xBF, // '+',
1020 1,
1021 coPos,
1022 &Written);
1023
1024 /* draw left and right edge */
1025 for (i = List->Top + 1; i < List->Bottom; i++)
1026 {
1027 coPos.X = List->Left;
1028 coPos.Y = i;
1029 FillConsoleOutputCharacter (0xB3, // '|',
1030 1,
1031 coPos,
1032 &Written);
1033
1034 coPos.X = List->Right;
1035 FillConsoleOutputCharacter (0xB3, //'|',
1036 1,
1037 coPos,
1038 &Written);
1039 }
1040
1041 /* draw lower left corner */
1042 coPos.X = List->Left;
1043 coPos.Y = List->Bottom;
1044 FillConsoleOutputCharacter (0xC0, // '+',
1045 1,
1046 coPos,
1047 &Written);
1048
1049 /* draw lower edge */
1050 coPos.X = List->Left + 1;
1051 coPos.Y = List->Bottom;
1052 FillConsoleOutputCharacter (0xC4, // '-',
1053 List->Right - List->Left - 1,
1054 coPos,
1055 &Written);
1056
1057 /* draw lower right corner */
1058 coPos.X = List->Right;
1059 coPos.Y = List->Bottom;
1060 FillConsoleOutputCharacter (0xD9, // '+',
1061 1,
1062 coPos,
1063 &Written);
1064
1065 /* print list entries */
1066 List->Line = 0;
1067
1068 Entry = List->DiskListHead.Flink;
1069 while (Entry != &List->DiskListHead)
1070 {
1071 DiskEntry = CONTAINING_RECORD (Entry, DISKENTRY, ListEntry);
1072
1073 /* Print disk entry */
1074 PrintDiskData (List,
1075 DiskEntry);
1076
1077 Entry = Entry->Flink;
1078 }
1079 }
1080
1081
1082 VOID
1083 ScrollDownPartitionList (PPARTLIST List)
1084 {
1085 PDISKENTRY DiskEntry;
1086 PPARTENTRY PartEntry;
1087 PLIST_ENTRY Entry1;
1088 PLIST_ENTRY Entry2;
1089
1090 /* Check for empty disks */
1091 if (IsListEmpty (&List->DiskListHead))
1092 return;
1093
1094 /* Check for next usable entry on current disk */
1095 if (List->CurrentPartition != NULL)
1096 {
1097 Entry2 = List->CurrentPartition->ListEntry.Flink;
1098 while (Entry2 != &List->CurrentDisk->PartListHead)
1099 {
1100 PartEntry = CONTAINING_RECORD (Entry2, PARTENTRY, ListEntry);
1101
1102 // if (PartEntry->HidePartEntry == FALSE)
1103 {
1104 List->CurrentPartition = PartEntry;
1105 DrawPartitionList (List);
1106 return;
1107 }
1108 Entry2 = Entry2->Flink;
1109 }
1110 }
1111
1112 /* Check for first usable entry on next disk */
1113 if (List->CurrentDisk != NULL)
1114 {
1115 Entry1 = List->CurrentDisk->ListEntry.Flink;
1116 while (Entry1 != &List->DiskListHead)
1117 {
1118 DiskEntry = CONTAINING_RECORD (Entry1, DISKENTRY, ListEntry);
1119
1120 Entry2 = DiskEntry->PartListHead.Flink;
1121 while (Entry2 != &DiskEntry->PartListHead)
1122 {
1123 PartEntry = CONTAINING_RECORD (Entry2, PARTENTRY, ListEntry);
1124
1125 // if (PartEntry->HidePartEntry == FALSE)
1126 {
1127 List->CurrentDisk = DiskEntry;
1128 List->CurrentPartition = PartEntry;
1129 DrawPartitionList (List);
1130 return;
1131 }
1132
1133 Entry2 = Entry2->Flink;
1134 }
1135
1136 Entry1 = Entry1->Flink;
1137 }
1138 }
1139 }
1140
1141
1142 VOID
1143 ScrollUpPartitionList (PPARTLIST List)
1144 {
1145 PDISKENTRY DiskEntry;
1146 PPARTENTRY PartEntry;
1147 PLIST_ENTRY Entry1;
1148 PLIST_ENTRY Entry2;
1149 ULONG i;
1150
1151 /* Check for empty disks */
1152 if (IsListEmpty (&List->DiskListHead))
1153 return;
1154
1155 /* check for previous usable entry on current disk */
1156 if (List->CurrentPartition != NULL)
1157 {
1158 Entry2 = List->CurrentPartition->ListEntry.Blink;
1159 while (Entry2 != &List->CurrentDisk->PartListHead)
1160 {
1161 PartEntry = CONTAINING_RECORD (Entry2, PARTENTRY, ListEntry);
1162
1163 // if (PartEntry->HidePartEntry == FALSE)
1164 {
1165 List->CurrentPartition = PartEntry;
1166 DrawPartitionList (List);
1167 return;
1168 }
1169 Entry2 = Entry2->Blink;
1170 }
1171 }
1172
1173
1174 /* check for last usable entry on previous disk */
1175 if (List->CurrentDisk != NULL)
1176 {
1177 Entry1 = List->CurrentDisk->ListEntry.Blink;
1178 while (Entry1 != &List->DiskListHead)
1179 {
1180 DiskEntry = CONTAINING_RECORD (Entry1, DISKENTRY, ListEntry);
1181
1182 Entry2 = DiskEntry->PartListHead.Blink;
1183 while (Entry2 != &DiskEntry->PartListHead)
1184 {
1185 PartEntry = CONTAINING_RECORD (Entry2, PARTENTRY, ListEntry);
1186
1187 // if (PartEntry->HidePartEntry == FALSE)
1188 {
1189 List->CurrentDisk = DiskEntry;
1190 List->CurrentPartition = PartEntry;
1191 DrawPartitionList (List);
1192 return;
1193 }
1194
1195 Entry2 = Entry2->Blink;
1196 }
1197
1198 Entry1 = Entry1->Blink;
1199 }
1200 }
1201 }
1202
1203
1204 static PPARTENTRY
1205 GetPrevPartitionedEntry (PDISKENTRY DiskEntry,
1206 PPARTENTRY CurrentEntry)
1207 {
1208 PPARTENTRY PrevEntry;
1209 PLIST_ENTRY Entry;
1210
1211 if (CurrentEntry->ListEntry.Blink == &DiskEntry->PartListHead)
1212 return NULL;
1213
1214 Entry = CurrentEntry->ListEntry.Blink;
1215 while (Entry != &DiskEntry->PartListHead)
1216 {
1217 PrevEntry = CONTAINING_RECORD (Entry,
1218 PARTENTRY,
1219 ListEntry);
1220 if (PrevEntry->Unpartitioned == FALSE)
1221 return PrevEntry;
1222
1223 Entry = Entry->Blink;
1224 }
1225
1226 return NULL;
1227 }
1228
1229
1230 static PPARTENTRY
1231 GetNextPartitionedEntry (PDISKENTRY DiskEntry,
1232 PPARTENTRY CurrentEntry)
1233 {
1234 PPARTENTRY NextEntry;
1235 PLIST_ENTRY Entry;
1236
1237 if (CurrentEntry->ListEntry.Flink == &DiskEntry->PartListHead)
1238 return NULL;
1239
1240 Entry = CurrentEntry->ListEntry.Flink;
1241 while (Entry != &DiskEntry->PartListHead)
1242 {
1243 NextEntry = CONTAINING_RECORD (Entry,
1244 PARTENTRY,
1245 ListEntry);
1246 if (NextEntry->Unpartitioned == FALSE)
1247 return NextEntry;
1248
1249 Entry = Entry->Flink;
1250 }
1251
1252 return NULL;
1253 }
1254
1255
1256 static PPARTENTRY
1257 GetPrevUnpartitionedEntry (PDISKENTRY DiskEntry,
1258 PPARTENTRY PartEntry)
1259 {
1260 PPARTENTRY PrevPartEntry;
1261
1262 if (PartEntry->ListEntry.Blink != &DiskEntry->PartListHead)
1263 {
1264 PrevPartEntry = CONTAINING_RECORD (PartEntry->ListEntry.Blink,
1265 PARTENTRY,
1266 ListEntry);
1267 if (PrevPartEntry->Unpartitioned == TRUE)
1268 return PrevPartEntry;
1269 }
1270
1271 return NULL;
1272 }
1273
1274
1275 static PPARTENTRY
1276 GetNextUnpartitionedEntry (PDISKENTRY DiskEntry,
1277 PPARTENTRY PartEntry)
1278 {
1279 PPARTENTRY NextPartEntry;
1280
1281 if (PartEntry->ListEntry.Flink != &DiskEntry->PartListHead)
1282 {
1283 NextPartEntry = CONTAINING_RECORD (PartEntry->ListEntry.Flink,
1284 PARTENTRY,
1285 ListEntry);
1286 if (NextPartEntry->Unpartitioned == TRUE)
1287 return NextPartEntry;
1288 }
1289
1290 return NULL;
1291 }
1292
1293
1294 VOID
1295 CreateNewPartition (PPARTLIST List,
1296 ULONGLONG PartitionSize,
1297 BOOLEAN AutoCreate)
1298 {
1299 PDISKENTRY DiskEntry;
1300 PPARTENTRY PartEntry;
1301 PPARTENTRY PrevPartEntry;
1302 PPARTENTRY NextPartEntry;
1303 PPARTENTRY NewPartEntry;
1304
1305 if (List == NULL ||
1306 List->CurrentDisk == NULL ||
1307 List->CurrentPartition == NULL ||
1308 List->CurrentPartition->Unpartitioned == FALSE)
1309 {
1310 return;
1311 }
1312
1313 DiskEntry = List->CurrentDisk;
1314 PartEntry = List->CurrentPartition;
1315
1316 if (AutoCreate == TRUE ||
1317 PartitionSize == PartEntry->UnpartitionedLength)
1318 {
1319 /* Convert current entry to 'new (unformatted)' */
1320 PartEntry->FormatState = Unformatted;
1321 PartEntry->PartInfo[0].StartingOffset.QuadPart =
1322 PartEntry->UnpartitionedOffset + DiskEntry->TrackSize;
1323 PartEntry->PartInfo[0].PartitionLength.QuadPart =
1324 PartEntry->UnpartitionedLength - DiskEntry->TrackSize;
1325 PartEntry->PartInfo[0].PartitionType = PARTITION_ENTRY_UNUSED;
1326 PartEntry->PartInfo[0].BootIndicator = FALSE; /* FIXME */
1327 PartEntry->PartInfo[0].RewritePartition = TRUE;
1328 PartEntry->PartInfo[1].RewritePartition = TRUE;
1329 PartEntry->PartInfo[2].RewritePartition = TRUE;
1330 PartEntry->PartInfo[3].RewritePartition = TRUE;
1331
1332 /* Get previous and next partition entries */
1333 PrevPartEntry = GetPrevPartitionedEntry (DiskEntry,
1334 PartEntry);
1335 NextPartEntry = GetNextPartitionedEntry (DiskEntry,
1336 PartEntry);
1337
1338 if (PrevPartEntry != NULL && NextPartEntry != NULL)
1339 {
1340 /* Current entry is in the middle of the list */
1341
1342 /* Copy previous container partition data to current entry */
1343 RtlCopyMemory (&PartEntry->PartInfo[1],
1344 &PrevPartEntry->PartInfo[1],
1345 sizeof(PARTITION_INFORMATION));
1346 PartEntry->PartInfo[1].RewritePartition = TRUE;
1347
1348 /* Update previous container partition data */
1349
1350 PrevPartEntry->PartInfo[1].StartingOffset.QuadPart =
1351 PartEntry->PartInfo[0].StartingOffset.QuadPart - DiskEntry->TrackSize;
1352
1353 if (DiskEntry->PartListHead.Flink == &PrevPartEntry->ListEntry)
1354 {
1355 /* Special case - previous partition is first partition */
1356 PrevPartEntry->PartInfo[1].PartitionLength.QuadPart =
1357 DiskEntry->DiskSize - PrevPartEntry->PartInfo[1].StartingOffset.QuadPart;
1358 }
1359 else
1360 {
1361 PrevPartEntry->PartInfo[1].PartitionLength.QuadPart =
1362 PartEntry->PartInfo[0].PartitionLength.QuadPart + DiskEntry->TrackSize;
1363 }
1364
1365 PrevPartEntry->PartInfo[1].RewritePartition = TRUE;
1366 }
1367 else if (PrevPartEntry == NULL && NextPartEntry != NULL)
1368 {
1369 /* Current entry is the first entry */
1370 return;
1371 }
1372 else if (PrevPartEntry != NULL && NextPartEntry == NULL)
1373 {
1374 /* Current entry is the last entry */
1375
1376 PrevPartEntry->PartInfo[1].StartingOffset.QuadPart =
1377 PartEntry->PartInfo[0].StartingOffset.QuadPart - DiskEntry->TrackSize;
1378
1379 if (DiskEntry->PartListHead.Flink == &PrevPartEntry->ListEntry)
1380 {
1381 /* Special case - previous partition is first partition */
1382 PrevPartEntry->PartInfo[1].PartitionLength.QuadPart =
1383 DiskEntry->DiskSize - PrevPartEntry->PartInfo[1].StartingOffset.QuadPart;
1384 }
1385 else
1386 {
1387 PrevPartEntry->PartInfo[1].PartitionLength.QuadPart =
1388 PartEntry->PartInfo[0].PartitionLength.QuadPart + DiskEntry->TrackSize;
1389 }
1390
1391 if ((PartEntry->PartInfo[1].StartingOffset.QuadPart +
1392 PartEntry->PartInfo[1].PartitionLength.QuadPart) <
1393 (1024ULL * 255ULL * 63ULL * 512ULL))
1394 {
1395 PrevPartEntry->PartInfo[1].PartitionType = PARTITION_EXTENDED;
1396 }
1397 else
1398 {
1399 PrevPartEntry->PartInfo[1].PartitionType = PARTITION_XINT13_EXTENDED;
1400 }
1401
1402 PrevPartEntry->PartInfo[1].BootIndicator = FALSE;
1403 PrevPartEntry->PartInfo[1].RewritePartition = TRUE;
1404 }
1405
1406 PartEntry->AutoCreate = AutoCreate;
1407 PartEntry->New = TRUE;
1408 PartEntry->Unpartitioned = FALSE;
1409 PartEntry->UnpartitionedOffset = 0ULL;
1410 PartEntry->UnpartitionedLength = 0ULL;
1411 }
1412 else
1413 {
1414 /* Insert an initialize a new partition entry */
1415 NewPartEntry = (PPARTENTRY)RtlAllocateHeap (ProcessHeap,
1416 0,
1417 sizeof(PARTENTRY));
1418 if (NewPartEntry == NULL)
1419 return;
1420
1421 RtlZeroMemory (NewPartEntry,
1422 sizeof(PARTENTRY));
1423
1424 /* Insert the new entry into the list */
1425 InsertTailList (&PartEntry->ListEntry,
1426 &NewPartEntry->ListEntry);
1427
1428 NewPartEntry->New = TRUE;
1429
1430 NewPartEntry->FormatState = Unformatted;
1431 NewPartEntry->PartInfo[0].StartingOffset.QuadPart =
1432 PartEntry->UnpartitionedOffset + DiskEntry->TrackSize;
1433 NewPartEntry->PartInfo[0].PartitionLength.QuadPart =
1434 PartitionSize - DiskEntry->TrackSize;
1435 NewPartEntry->PartInfo[0].PartitionType = PARTITION_ENTRY_UNUSED;
1436 NewPartEntry->PartInfo[0].BootIndicator = FALSE; /* FIXME */
1437 NewPartEntry->PartInfo[0].RewritePartition = TRUE;
1438 NewPartEntry->PartInfo[1].RewritePartition = TRUE;
1439 NewPartEntry->PartInfo[2].RewritePartition = TRUE;
1440 NewPartEntry->PartInfo[3].RewritePartition = TRUE;
1441
1442 /* Get previous and next partition entries */
1443 PrevPartEntry = GetPrevPartitionedEntry (DiskEntry,
1444 NewPartEntry);
1445 NextPartEntry = GetNextPartitionedEntry (DiskEntry,
1446 NewPartEntry);
1447
1448 if (PrevPartEntry != NULL && NextPartEntry != NULL)
1449 {
1450 /* Current entry is in the middle of the list */
1451
1452 /* Copy previous container partition data to current entry */
1453 RtlCopyMemory (&NewPartEntry->PartInfo[1],
1454 &PrevPartEntry->PartInfo[1],
1455 sizeof(PARTITION_INFORMATION));
1456 NewPartEntry->PartInfo[1].RewritePartition = TRUE;
1457
1458 /* Update previous container partition data */
1459
1460 PrevPartEntry->PartInfo[1].StartingOffset.QuadPart =
1461 NewPartEntry->PartInfo[0].StartingOffset.QuadPart - DiskEntry->TrackSize;
1462
1463 if (DiskEntry->PartListHead.Flink == &PrevPartEntry->ListEntry)
1464 {
1465 /* Special case - previous partition is first partition */
1466 PrevPartEntry->PartInfo[1].PartitionLength.QuadPart =
1467 DiskEntry->DiskSize - PrevPartEntry->PartInfo[1].StartingOffset.QuadPart;
1468 }
1469 else
1470 {
1471 PrevPartEntry->PartInfo[1].PartitionLength.QuadPart =
1472 NewPartEntry->PartInfo[0].PartitionLength.QuadPart + DiskEntry->TrackSize;
1473 }
1474
1475 PrevPartEntry->PartInfo[1].RewritePartition = TRUE;
1476 }
1477 else if (PrevPartEntry == NULL && NextPartEntry != NULL)
1478 {
1479 /* Current entry is the first entry */
1480 return;
1481 }
1482 else if (PrevPartEntry != NULL && NextPartEntry == NULL)
1483 {
1484 /* Current entry is the last entry */
1485
1486 PrevPartEntry->PartInfo[1].StartingOffset.QuadPart =
1487 NewPartEntry->PartInfo[0].StartingOffset.QuadPart - DiskEntry->TrackSize;
1488
1489 if (DiskEntry->PartListHead.Flink == &PrevPartEntry->ListEntry)
1490 {
1491 /* Special case - previous partition is first partition */
1492 PrevPartEntry->PartInfo[1].PartitionLength.QuadPart =
1493 DiskEntry->DiskSize - PrevPartEntry->PartInfo[1].StartingOffset.QuadPart;
1494 }
1495 else
1496 {
1497 PrevPartEntry->PartInfo[1].PartitionLength.QuadPart =
1498 NewPartEntry->PartInfo[0].PartitionLength.QuadPart + DiskEntry->TrackSize;
1499 }
1500
1501 if ((PartEntry->PartInfo[1].StartingOffset.QuadPart +
1502 PartEntry->PartInfo[1].PartitionLength.QuadPart) <
1503 (1024ULL * 255ULL * 63ULL * 512ULL))
1504 {
1505 PrevPartEntry->PartInfo[1].PartitionType = PARTITION_EXTENDED;
1506 }
1507 else
1508 {
1509 PrevPartEntry->PartInfo[1].PartitionType = PARTITION_XINT13_EXTENDED;
1510 }
1511
1512 PrevPartEntry->PartInfo[1].BootIndicator = FALSE;
1513 PrevPartEntry->PartInfo[1].RewritePartition = TRUE;
1514 }
1515
1516 /* Update offset and size of the remaining unpartitioned disk space */
1517 PartEntry->UnpartitionedOffset += PartitionSize;
1518 PartEntry->UnpartitionedLength -= PartitionSize;
1519 }
1520
1521 DiskEntry->Modified = TRUE;
1522
1523 UpdatePartitionNumbers (DiskEntry);
1524
1525 AssignDriverLetters (List);
1526 }
1527
1528
1529 VOID
1530 DeleteCurrentPartition (PPARTLIST List)
1531 {
1532 PDISKENTRY DiskEntry;
1533 PPARTENTRY PartEntry;
1534 PPARTENTRY PrevPartEntry;
1535 PPARTENTRY NextPartEntry;
1536
1537 if (List == NULL ||
1538 List->CurrentDisk == NULL ||
1539 List->CurrentPartition == NULL ||
1540 List->CurrentPartition->Unpartitioned == TRUE)
1541 {
1542 return;
1543 }
1544
1545 DiskEntry = List->CurrentDisk;
1546 PartEntry = List->CurrentPartition;
1547
1548 /* Adjust container partition entries */
1549
1550 /* Get previous and next partition entries */
1551 PrevPartEntry = GetPrevPartitionedEntry (DiskEntry,
1552 PartEntry);
1553 NextPartEntry = GetNextPartitionedEntry (DiskEntry,
1554 PartEntry);
1555
1556 if (PrevPartEntry != NULL && NextPartEntry != NULL)
1557 {
1558 /* Current entry is in the middle of the list */
1559
1560 /*
1561 * The first extended partition can not be deleted
1562 * as long as other extended partitions are present.
1563 */
1564 if (PrevPartEntry->ListEntry.Blink == &DiskEntry->PartListHead)
1565 return;
1566
1567 /* Copy previous container partition data to current entry */
1568 RtlCopyMemory (&PrevPartEntry->PartInfo[1],
1569 &PartEntry->PartInfo[1],
1570 sizeof(PARTITION_INFORMATION));
1571 PrevPartEntry->PartInfo[1].RewritePartition = TRUE;
1572 }
1573 else if (PrevPartEntry == NULL && NextPartEntry != NULL)
1574 {
1575 /*
1576 * A primary partition can not be deleted as long as
1577 * extended partitions are present.
1578 */
1579 return;
1580 }
1581 else if (PrevPartEntry != NULL && NextPartEntry == NULL)
1582 {
1583 /* Current entry is the last entry */
1584 RtlZeroMemory (&PrevPartEntry->PartInfo[1],
1585 sizeof(PARTITION_INFORMATION));
1586 PrevPartEntry->PartInfo[1].RewritePartition = TRUE;
1587 }
1588
1589
1590 /* Adjust unpartitioned disk space entries */
1591
1592 /* Get pointer to previous and next unpartitioned entries */
1593 PrevPartEntry = GetPrevUnpartitionedEntry (DiskEntry,
1594 PartEntry);
1595
1596 NextPartEntry = GetNextUnpartitionedEntry (DiskEntry,
1597 PartEntry);
1598
1599 if (PrevPartEntry != NULL && NextPartEntry != NULL)
1600 {
1601 /* Merge previous, current and next unpartitioned entry */
1602
1603 /* Adjust the previous entries length */
1604 PrevPartEntry->UnpartitionedLength +=
1605 (PartEntry->PartInfo[0].PartitionLength.QuadPart + DiskEntry->TrackSize +
1606 NextPartEntry->UnpartitionedLength);
1607
1608 /* Remove the current entry */
1609 RemoveEntryList (&PartEntry->ListEntry);
1610 RtlFreeHeap (ProcessHeap,
1611 0,
1612 PartEntry);
1613
1614 /* Remove the next entry */
1615 RemoveEntryList (&NextPartEntry->ListEntry);
1616 RtlFreeHeap (ProcessHeap,
1617 0,
1618 NextPartEntry);
1619
1620 /* Update current partition */
1621 List->CurrentPartition = PrevPartEntry;
1622 }
1623 else if (PrevPartEntry != NULL && NextPartEntry == NULL)
1624 {
1625 /* Merge current and previous unpartitioned entry */
1626
1627 /* Adjust the previous entries length */
1628 PrevPartEntry->UnpartitionedLength +=
1629 (PartEntry->PartInfo[0].PartitionLength.QuadPart + DiskEntry->TrackSize);
1630
1631 /* Remove the current entry */
1632 RemoveEntryList (&PartEntry->ListEntry);
1633 RtlFreeHeap (ProcessHeap,
1634 0,
1635 PartEntry);
1636
1637 /* Update current partition */
1638 List->CurrentPartition = PrevPartEntry;
1639 }
1640 else if (PrevPartEntry == NULL && NextPartEntry != NULL)
1641 {
1642 /* Merge current and next unpartitioned entry */
1643
1644 /* Adjust the next entries offset and length */
1645 NextPartEntry->UnpartitionedOffset =
1646 PartEntry->PartInfo[0].StartingOffset.QuadPart - DiskEntry->TrackSize;
1647 NextPartEntry->UnpartitionedLength +=
1648 (PartEntry->PartInfo[0].PartitionLength.QuadPart + DiskEntry->TrackSize);
1649
1650 /* Remove the current entry */
1651 RemoveEntryList (&PartEntry->ListEntry);
1652 RtlFreeHeap (ProcessHeap,
1653 0,
1654 PartEntry);
1655
1656 /* Update current partition */
1657 List->CurrentPartition = NextPartEntry;
1658 }
1659 else
1660 {
1661 /* Nothing to merge but change current entry */
1662 PartEntry->New = FALSE;
1663 PartEntry->Unpartitioned = TRUE;
1664 PartEntry->UnpartitionedOffset =
1665 PartEntry->PartInfo[0].StartingOffset.QuadPart - DiskEntry->TrackSize;
1666 PartEntry->UnpartitionedLength =
1667 PartEntry->PartInfo[0].PartitionLength.QuadPart + DiskEntry->TrackSize;
1668
1669 /* Wipe the partition table */
1670 RtlZeroMemory (&PartEntry->PartInfo,
1671 sizeof(PartEntry->PartInfo));
1672 }
1673
1674 DiskEntry->Modified = TRUE;
1675
1676 UpdatePartitionNumbers (DiskEntry);
1677
1678 AssignDriverLetters (List);
1679 }
1680
1681
1682 VOID
1683 CheckActiveBootPartition (PPARTLIST List)
1684 {
1685 PDISKENTRY DiskEntry;
1686 PPARTENTRY PartEntry;
1687
1688 /* Check for empty disk list */
1689 if (IsListEmpty (&List->DiskListHead))
1690 {
1691 List->ActiveBootDisk = NULL;
1692 List->ActiveBootPartition = NULL;
1693 return;
1694 }
1695
1696 #if 0
1697 if (List->ActiveBootDisk != NULL &&
1698 List->ActiveBootPartition != NULL)
1699 {
1700 /* We already have an active boot partition */
1701 return;
1702 }
1703 #endif
1704
1705 DiskEntry = CONTAINING_RECORD (List->DiskListHead.Flink,
1706 DISKENTRY,
1707 ListEntry);
1708
1709 /* Check for empty partition list */
1710 if (IsListEmpty (&DiskEntry->PartListHead))
1711 {
1712 List->ActiveBootDisk = NULL;
1713 List->ActiveBootPartition = NULL;
1714 return;
1715 }
1716
1717 PartEntry = CONTAINING_RECORD (DiskEntry->PartListHead.Flink,
1718 PARTENTRY,
1719 ListEntry);
1720
1721 /* Set active boot partition */
1722 if ((DiskEntry->NewDisk == TRUE) ||
1723 (PartEntry->PartInfo[0].BootIndicator == FALSE &&
1724 PartEntry->PartInfo[1].BootIndicator == FALSE &&
1725 PartEntry->PartInfo[2].BootIndicator == FALSE &&
1726 PartEntry->PartInfo[3].BootIndicator == FALSE))
1727 {
1728 PartEntry->PartInfo[0].BootIndicator = TRUE;
1729 PartEntry->PartInfo[0].RewritePartition = TRUE;
1730 DiskEntry->Modified = TRUE;
1731 }
1732
1733 /* FIXME: Might be incorrect if partitions were created by Linux FDISK */
1734 List->ActiveBootDisk = DiskEntry;
1735 List->ActiveBootPartition = PartEntry;
1736 }
1737
1738
1739 BOOLEAN
1740 CheckForLinuxFdiskPartitions (PPARTLIST List)
1741 {
1742 PDISKENTRY DiskEntry;
1743 PPARTENTRY PartEntry;
1744 PLIST_ENTRY Entry1;
1745 PLIST_ENTRY Entry2;
1746 ULONG PartitionCount;
1747 ULONG i;
1748
1749 Entry1 = List->DiskListHead.Flink;
1750 while (Entry1 != &List->DiskListHead)
1751 {
1752 DiskEntry = CONTAINING_RECORD (Entry1,
1753 DISKENTRY,
1754 ListEntry);
1755
1756 Entry2 = DiskEntry->PartListHead.Flink;
1757 while (Entry2 != &DiskEntry->PartListHead)
1758 {
1759 PartEntry = CONTAINING_RECORD (Entry2,
1760 PARTENTRY,
1761 ListEntry);
1762
1763 if (PartEntry->Unpartitioned == FALSE)
1764 {
1765 PartitionCount = 0;
1766
1767 for (i = 0; i < 4; i++)
1768 {
1769 if (!IsContainerPartition (PartEntry->PartInfo[i].PartitionType) &&
1770 PartEntry->PartInfo[i].PartitionLength.QuadPart != 0ULL)
1771 {
1772 PartitionCount++;
1773 }
1774 }
1775
1776 if (PartitionCount > 1)
1777 {
1778 return TRUE;
1779 }
1780 }
1781
1782 Entry2 = Entry2->Flink;
1783 }
1784
1785 Entry1 = Entry1->Flink;
1786 }
1787
1788 return FALSE;
1789 }
1790
1791
1792 BOOLEAN
1793 WritePartitionsToDisk (PPARTLIST List)
1794 {
1795 PDRIVE_LAYOUT_INFORMATION DriveLayout;
1796 OBJECT_ATTRIBUTES ObjectAttributes;
1797 IO_STATUS_BLOCK Iosb;
1798 WCHAR SrcPath[MAX_PATH];
1799 WCHAR DstPath[MAX_PATH];
1800 UNICODE_STRING Name;
1801 HANDLE FileHandle;
1802 PDISKENTRY DiskEntry;
1803 PPARTENTRY PartEntry;
1804 PLIST_ENTRY Entry1;
1805 PLIST_ENTRY Entry2;
1806 ULONG PartitionCount;
1807 ULONG DriveLayoutSize;
1808 ULONG Index;
1809 NTSTATUS Status;
1810
1811 if (List == NULL)
1812 {
1813 return TRUE;
1814 }
1815
1816 Entry1 = List->DiskListHead.Flink;
1817 while (Entry1 != &List->DiskListHead)
1818 {
1819 DiskEntry = CONTAINING_RECORD (Entry1,
1820 DISKENTRY,
1821 ListEntry);
1822
1823 if (DiskEntry->Modified == TRUE)
1824 {
1825 /* Count partitioned entries */
1826 PartitionCount = 0;
1827 Entry2 = DiskEntry->PartListHead.Flink;
1828 while (Entry2 != &DiskEntry->PartListHead)
1829 {
1830 PartEntry = CONTAINING_RECORD (Entry2,
1831 PARTENTRY,
1832 ListEntry);
1833 if (PartEntry->Unpartitioned == FALSE)
1834 {
1835 PartitionCount += 4;
1836 }
1837
1838 Entry2 = Entry2->Flink;
1839 }
1840
1841 if (PartitionCount > 0)
1842 {
1843 DriveLayoutSize = sizeof (DRIVE_LAYOUT_INFORMATION) +
1844 ((PartitionCount - 1) * sizeof (PARTITION_INFORMATION));
1845 DriveLayout = (PDRIVE_LAYOUT_INFORMATION)RtlAllocateHeap (ProcessHeap,
1846 0,
1847 DriveLayoutSize);
1848 if (DriveLayout == NULL)
1849 {
1850 DPRINT1 ("RtlAllocateHeap() failed\n");
1851 return FALSE;
1852 }
1853
1854 RtlZeroMemory (DriveLayout,
1855 DriveLayoutSize);
1856
1857 DriveLayout->PartitionCount = PartitionCount;
1858
1859 Index = 0;
1860 Entry2 = DiskEntry->PartListHead.Flink;
1861 while (Entry2 != &DiskEntry->PartListHead)
1862 {
1863 PartEntry = CONTAINING_RECORD (Entry2,
1864 PARTENTRY,
1865 ListEntry);
1866 if (PartEntry->Unpartitioned == FALSE)
1867 {
1868 RtlCopyMemory (&DriveLayout->PartitionEntry[Index],
1869 &PartEntry->PartInfo[0],
1870 4 * sizeof (PARTITION_INFORMATION));
1871 Index += 4;
1872 }
1873
1874 Entry2 = Entry2->Flink;
1875 }
1876
1877 swprintf (DstPath,
1878 L"\\Device\\Harddisk%d\\Partition0",
1879 DiskEntry->DiskNumber);
1880 RtlInitUnicodeString (&Name,
1881 DstPath);
1882 InitializeObjectAttributes (&ObjectAttributes,
1883 &Name,
1884 0,
1885 NULL,
1886 NULL);
1887
1888 Status = NtOpenFile (&FileHandle,
1889 FILE_ALL_ACCESS,
1890 &ObjectAttributes,
1891 &Iosb,
1892 0,
1893 FILE_SYNCHRONOUS_IO_NONALERT);
1894 if (!NT_SUCCESS (Status))
1895 {
1896 DPRINT1 ("NtOpenFile() failed (Status %lx)\n", Status);
1897 return FALSE;
1898 }
1899
1900 Status = NtDeviceIoControlFile (FileHandle,
1901 NULL,
1902 NULL,
1903 NULL,
1904 &Iosb,
1905 IOCTL_DISK_SET_DRIVE_LAYOUT,
1906 DriveLayout,
1907 DriveLayoutSize,
1908 NULL,
1909 0);
1910 if (!NT_SUCCESS (Status))
1911 {
1912 DPRINT1 ("NtDeviceIoControlFile() failed (Status %lx)\n", Status);
1913 NtClose (FileHandle);
1914 return FALSE;
1915 }
1916
1917 RtlFreeHeap (ProcessHeap,
1918 0,
1919 DriveLayout);
1920
1921 NtClose (FileHandle);
1922
1923 /* Install MBR code if the disk is new */
1924 if (DiskEntry->NewDisk == TRUE)
1925 {
1926 wcscpy (SrcPath, SourceRootPath.Buffer);
1927 wcscat (SrcPath, L"\\loader\\dosmbr.bin");
1928
1929 DPRINT1 ("Install MBR bootcode: %S ==> %S\n",
1930 SrcPath, DstPath);
1931
1932 /* Install MBR bootcode */
1933 Status = InstallMbrBootCodeToDisk (SrcPath,
1934 DstPath);
1935 if (!NT_SUCCESS (Status))
1936 {
1937 DPRINT1 ("InstallMbrBootCodeToDisk() failed (Status %lx)\n",
1938 Status);
1939 return FALSE;
1940 }
1941
1942 DiskEntry->NewDisk = FALSE;
1943 }
1944 }
1945 }
1946
1947 Entry1 = Entry1->Flink;
1948 }
1949
1950 return TRUE;
1951 }
1952
1953 /* EOF */
A free Windows-compatible Operating System