base/system/diskpart/create.c

   1 /*
   2  * PROJECT:         ReactOS DiskPart
   3  * LICENSE:         GPL - See COPYING in the top level directory
   4  * FILE:            base/system/diskpart/create.c
   5  * PURPOSE:         Manages all the partitions of the OS in an interactive way.
   6  * PROGRAMMERS:     Lee Schroeder
   7  */
   8
   9 #include "diskpart.h"
  10
  11 #define NDEBUG
  12 #include <debug.h>
  13
  14
  15 BOOL
  16 CreateExtendedPartition(
  17     _In_ INT argc,
  18     _In_ PWSTR *argv)
  19 {
  20     PPARTENTRY PartEntry, NewPartEntry;
  21     PLIST_ENTRY ListEntry;
  22     ULONGLONG ullSize = 0ULL;
  23     ULONGLONG ullSectorCount;
  24 #if 0
  25     ULONGLONG ullOffset = 0ULL;
  26     BOOL bNoErr = FALSE;
  27 #endif
  28     INT i;
  29     PWSTR pszSuffix = NULL;
  30     NTSTATUS Status;
  31
  32     if (CurrentDisk == NULL)
  33     {
  34         ConResPuts(StdOut, IDS_SELECT_NO_DISK);
  35         return TRUE;
  36     }
  37
  38     for (i = 3; i < argc; i++)
  39     {
  40         if (HasPrefix(argv[i], L"size=", &pszSuffix))
  41         {
  42             /* size=<N> (MB) */
  43             DPRINT("Size : %s\n", pszSuffix);
  44
  45             ullSize = _wcstoui64(pszSuffix, NULL, 10);
  46             if ((ullSize == 0) && (errno == ERANGE))
  47             {
  48                 ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
  49                 return TRUE;
  50             }
  51         }
  52         else if (HasPrefix(argv[i], L"offset=", &pszSuffix))
  53         {
  54             /* offset=<N> (KB) */
  55             DPRINT("Offset : %s\n", pszSuffix);
  56             ConPuts(StdOut, L"The OFFSET option is not supported yet!\n");
  57 #if 0
  58             ullOffset = _wcstoui64(pszSuffix, NULL, 10);
  59             if ((ullOffset == 0) && (errno == ERANGE))
  60             {
  61                 ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
  62                 return TRUE;
  63             }
  64 #endif
  65         }
  66         else if (HasPrefix(argv[i], L"align=", &pszSuffix))
  67         {
  68             /* align=<N> */
  69             DPRINT("Align : %s\n", pszSuffix);
  70             ConPuts(StdOut, L"The ALIGN option is not supported yet!\n");
  71 #if 0
  72             bAlign = TRUE;
  73 #endif
  74         }
  75         else if (_wcsicmp(argv[i], L"noerr") == 0)
  76         {
  77             /* noerr */
  78             DPRINT("NoErr\n", pszSuffix);
  79             ConPuts(StdOut, L"The NOERR option is not supported yet!\n");
  80 #if 0
  81             bNoErr = TRUE;
  82 #endif
  83         }
  84         else
  85         {
  86             ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
  87             return TRUE;
  88         }
  89     }
  90
  91     DPRINT1("Size: %I64u\n", ullSize);
  92 #if 0
  93     DPRINT1("Offset: %I64u\n", ullOffset);
  94 #endif
  95
  96     if (GetPrimaryPartitionCount(CurrentDisk) >= 4)
  97     {
  98         ConPuts(StdOut, L"No space left for an extended partition!\n");
  99         return TRUE;
 100     }
 101
 102     if (CurrentDisk->ExtendedPartition != NULL)
 103     {
 104         ConPuts(StdOut, L"We already have an extended partition on this disk!\n");
 105         return TRUE;
 106     }
 107
 108     if (ullSize != 0)
 109         ullSectorCount = (ullSize * 1024 * 1024) / CurrentDisk->BytesPerSector;
 110     else
 111         ullSectorCount = 0;
 112
 113     DPRINT1("SectorCount: %I64u\n", ullSectorCount);
 114
 115     ListEntry = CurrentDisk->PrimaryPartListHead.Blink;
 116
 117     PartEntry = CONTAINING_RECORD(ListEntry, PARTENTRY, ListEntry);
 118     if (PartEntry->IsPartitioned)
 119     {
 120         ConPuts(StdOut, L"No disk space left for an extended partition!\n");
 121         return TRUE;
 122     }
 123
 124     if (ullSectorCount == 0)
 125     {
 126         PartEntry->IsPartitioned = TRUE;
 127         PartEntry->New = TRUE;
 128         PartEntry->PartitionType = PARTITION_EXTENDED;
 129         PartEntry->FormatState = Unformatted;
 130         PartEntry->FileSystemName[0] = L'\0';
 131
 132         CurrentPartition = PartEntry;
 133         CurrentDisk->Dirty = TRUE;
 134     }
 135     else
 136     {
 137         if (PartEntry->SectorCount.QuadPart == ullSectorCount)
 138         {
 139             PartEntry->IsPartitioned = TRUE;
 140             PartEntry->New = TRUE;
 141             PartEntry->PartitionType = PARTITION_EXTENDED;
 142             PartEntry->FormatState = Unformatted;
 143             PartEntry->FileSystemName[0] = L'\0';
 144
 145             CurrentPartition = PartEntry;
 146             CurrentDisk->Dirty = TRUE;
 147         }
 148         else if (PartEntry->SectorCount.QuadPart > ullSectorCount)
 149         {
 150             NewPartEntry = RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(PPARTENTRY));
 151             if (NewPartEntry == NULL)
 152             {
 153                 ConPuts(StdOut, L"Memory allocation failed!\n");
 154                 return TRUE;
 155             }
 156
 157             NewPartEntry->DiskEntry = PartEntry->DiskEntry;
 158
 159             NewPartEntry->StartSector.QuadPart = PartEntry->StartSector.QuadPart;
 160             NewPartEntry->SectorCount.QuadPart = ullSectorCount;
 161
 162             NewPartEntry->LogicalPartition = FALSE;
 163             NewPartEntry->IsPartitioned = TRUE;
 164             NewPartEntry->New = TRUE;
 165             NewPartEntry->PartitionType = PARTITION_EXTENDED;
 166             NewPartEntry->FormatState = Unformatted;
 167             NewPartEntry->FileSystemName[0] = L'\0';
 168
 169             PartEntry->StartSector.QuadPart += ullSectorCount;
 170             PartEntry->SectorCount.QuadPart -= ullSectorCount;
 171
 172             InsertTailList(ListEntry, &NewPartEntry->ListEntry);
 173
 174             CurrentPartition = NewPartEntry;
 175             CurrentDisk->Dirty = TRUE;
 176         }
 177     }
 178
 179     UpdateDiskLayout(CurrentDisk);
 180     Status = WritePartitions(CurrentDisk);
 181     if (!NT_SUCCESS(Status))
 182     {
 183         ConResPuts(StdOut, IDS_CREATE_PARTITION_FAIL);
 184         CurrentPartition = NULL;
 185         return TRUE;
 186     }
 187
 188     ConResPuts(StdOut, IDS_CREATE_PARTITION_SUCCESS);
 189
 190     return TRUE;
 191 }
 192
 193
 194 BOOL
 195 CreateLogicalPartition(
 196     _In_ INT argc,
 197     _In_ PWSTR *argv)
 198 {
 199     PPARTENTRY PartEntry, NewPartEntry;
 200     PLIST_ENTRY ListEntry;
 201     ULONGLONG ullSize = 0ULL;
 202     ULONGLONG ullSectorCount;
 203 #if 0
 204     ULONGLONG ullOffset = 0ULL;
 205     BOOL bNoErr = FALSE;
 206 #endif
 207     UCHAR PartitionType = PARTITION_HUGE;
 208     INT i, length;
 209     PWSTR pszSuffix = NULL;
 210     NTSTATUS Status;
 211
 212     if (CurrentDisk == NULL)
 213     {
 214         ConResPuts(StdOut, IDS_SELECT_NO_DISK);
 215         return TRUE;
 216     }
 217
 218     for (i = 3; i < argc; i++)
 219     {
 220         if (HasPrefix(argv[i], L"size=", &pszSuffix))
 221         {
 222             /* size=<N> (MB) */
 223             DPRINT("Size : %s\n", pszSuffix);
 224
 225             ullSize = _wcstoui64(pszSuffix, NULL, 10);
 226             if ((ullSize == 0) && (errno == ERANGE))
 227             {
 228                 ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
 229                 return TRUE;
 230             }
 231         }
 232         else if (HasPrefix(argv[i], L"offset=", &pszSuffix))
 233         {
 234             /* offset=<N> (KB) */
 235             DPRINT("Offset : %s\n", pszSuffix);
 236             ConPuts(StdOut, L"The OFFSET option is not supported yet!\n");
 237 #if 0
 238             ullOffset = _wcstoui64(pszSuffix, NULL, 10);
 239             if ((ullOffset == 0) && (errno == ERANGE))
 240             {
 241                 ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
 242                 return TRUE;
 243             }
 244 #endif
 245         }
 246         else if (HasPrefix(argv[i], L"id=", &pszSuffix))
 247         {
 248             /* id=<Byte>|<GUID> */
 249             DPRINT("Id : %s\n", pszSuffix);
 250
 251             length = wcslen(pszSuffix);
 252             if ((length == 1) || (length == 2))
 253             {
 254                 /* Byte */
 255                 PartitionType = (UCHAR)wcstoul(pszSuffix, NULL, 16);
 256                 if ((PartitionType == 0) && (errno == ERANGE))
 257                 {
 258                     ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
 259                     return TRUE;
 260                 }
 261             }
 262 #if 0
 263             else if ()
 264             {
 265                 /* GUID */
 266             }
 267 #endif
 268             else
 269             {
 270                 ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
 271                 return TRUE;
 272             }
 273         }
 274         else if (HasPrefix(argv[i], L"align=", &pszSuffix))
 275         {
 276             /* align=<N> */
 277             DPRINT("Align : %s\n", pszSuffix);
 278             ConPuts(StdOut, L"The ALIGN option is not supported yet!\n");
 279 #if 0
 280             bAlign = TRUE;
 281 #endif
 282         }
 283         else if (_wcsicmp(argv[i], L"noerr") == 0)
 284         {
 285             /* noerr */
 286             DPRINT("NoErr\n", pszSuffix);
 287             ConPuts(StdOut, L"The NOERR option is not supported yet!\n");
 288 #if 0
 289             bNoErr = TRUE;
 290 #endif
 291         }
 292         else
 293         {
 294             ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
 295             return TRUE;
 296         }
 297     }
 298
 299     DPRINT1("Size: %I64u\n", ullSize);
 300 #if 0
 301     DPRINT1("Offset: %I64u\n", ullOffset);
 302 #endif
 303     DPRINT1("Partition Type: %hx\n", PartitionType);
 304
 305     if (ullSize != 0)
 306         ullSectorCount = (ullSize * 1024 * 1024) / CurrentDisk->BytesPerSector;
 307     else
 308         ullSectorCount = 0;
 309
 310     DPRINT1("SectorCount: %I64u\n", ullSectorCount);
 311
 312     for (ListEntry = CurrentDisk->LogicalPartListHead.Flink;
 313          ListEntry != &CurrentDisk->LogicalPartListHead;
 314          ListEntry = ListEntry->Flink)
 315     {
 316         PartEntry = CONTAINING_RECORD(ListEntry, PARTENTRY, ListEntry);
 317         if (PartEntry->IsPartitioned)
 318             continue;
 319
 320         if (ullSectorCount == 0)
 321         {
 322             PartEntry->IsPartitioned = TRUE;
 323             PartEntry->New = TRUE;
 324             PartEntry->PartitionType = PartitionType;
 325             PartEntry->FormatState = Unformatted;
 326             PartEntry->FileSystemName[0] = L'\0';
 327
 328             CurrentPartition = PartEntry;
 329             CurrentDisk->Dirty = TRUE;
 330             break;
 331         }
 332         else
 333         {
 334             if (PartEntry->SectorCount.QuadPart == ullSectorCount)
 335             {
 336                 PartEntry->IsPartitioned = TRUE;
 337                 PartEntry->New = TRUE;
 338                 PartEntry->PartitionType = PartitionType;
 339                 PartEntry->FormatState = Unformatted;
 340                 PartEntry->FileSystemName[0] = L'\0';
 341
 342                 CurrentPartition = PartEntry;
 343                 CurrentDisk->Dirty = TRUE;
 344                 break;
 345             }
 346             else if (PartEntry->SectorCount.QuadPart > ullSectorCount)
 347             {
 348                 NewPartEntry = RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(PPARTENTRY));
 349                 if (NewPartEntry == NULL)
 350                 {
 351                     ConPuts(StdOut, L"Memory allocation failed!\n");
 352                     return TRUE;
 353                 }
 354
 355                 NewPartEntry->DiskEntry = PartEntry->DiskEntry;
 356
 357                 NewPartEntry->StartSector.QuadPart = PartEntry->StartSector.QuadPart;
 358                 NewPartEntry->SectorCount.QuadPart = ullSectorCount;
 359
 360                 NewPartEntry->LogicalPartition = TRUE;
 361                 NewPartEntry->IsPartitioned = TRUE;
 362                 NewPartEntry->New = TRUE;
 363                 NewPartEntry->PartitionType = PartitionType;
 364                 NewPartEntry->FormatState = Unformatted;
 365                 NewPartEntry->FileSystemName[0] = L'\0';
 366
 367                 PartEntry->StartSector.QuadPart += ullSectorCount;
 368                 PartEntry->SectorCount.QuadPart -= ullSectorCount;
 369
 370                 InsertTailList(ListEntry, &NewPartEntry->ListEntry);
 371
 372                 CurrentPartition = NewPartEntry;
 373                 CurrentDisk->Dirty = TRUE;
 374                 break;
 375             }
 376         }
 377     }
 378
 379     UpdateDiskLayout(CurrentDisk);
 380     Status = WritePartitions(CurrentDisk);
 381     if (!NT_SUCCESS(Status))
 382     {
 383         ConResPuts(StdOut, IDS_CREATE_PARTITION_FAIL);
 384         CurrentPartition = NULL;
 385         return TRUE;
 386     }
 387
 388     ConResPuts(StdOut, IDS_CREATE_PARTITION_SUCCESS);
 389
 390     return TRUE;
 391 }
 392
 393
 394 BOOL
 395 CreatePrimaryPartition(
 396     _In_ INT argc,
 397     _In_ PWSTR *argv)
 398 {
 399     PPARTENTRY PartEntry, NewPartEntry;
 400     PLIST_ENTRY ListEntry;
 401     ULONGLONG ullSize = 0ULL;
 402     ULONGLONG ullSectorCount;
 403 #if 0
 404     ULONGLONG ullOffset = 0ULL;
 405     BOOL bNoErr = FALSE;
 406 #endif
 407     UCHAR PartitionType = PARTITION_HUGE;
 408     INT i, length;
 409     PWSTR pszSuffix = NULL;
 410     NTSTATUS Status;
 411
 412     if (CurrentDisk == NULL)
 413     {
 414         ConResPuts(StdOut, IDS_SELECT_NO_DISK);
 415         return TRUE;
 416     }
 417
 418     for (i = 3; i < argc; i++)
 419     {
 420         if (HasPrefix(argv[i], L"size=", &pszSuffix))
 421         {
 422             /* size=<N> (MB) */
 423             DPRINT("Size : %s\n", pszSuffix);
 424
 425             ullSize = _wcstoui64(pszSuffix, NULL, 10);
 426             if ((ullSize == 0) && (errno == ERANGE))
 427             {
 428                 ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
 429                 return TRUE;
 430             }
 431         }
 432         else if (HasPrefix(argv[i], L"offset=", &pszSuffix))
 433         {
 434             /* offset=<N> (KB) */
 435             DPRINT("Offset : %s\n", pszSuffix);
 436             ConPuts(StdOut, L"The OFFSET option is not supported yet!\n");
 437 #if 0
 438             ullOffset = _wcstoui64(pszSuffix, NULL, 10);
 439             if ((ullOffset == 0) && (errno == ERANGE))
 440             {
 441                 ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
 442                 return TRUE;
 443             }
 444 #endif
 445         }
 446         else if (HasPrefix(argv[i], L"id=", &pszSuffix))
 447         {
 448             /* id=<Byte>|<GUID> */
 449             DPRINT("Id : %s\n", pszSuffix);
 450
 451             length = wcslen(pszSuffix);
 452             if ((length == 1) || (length == 2))
 453             {
 454                 /* Byte */
 455                 PartitionType = (UCHAR)wcstoul(pszSuffix, NULL, 16);
 456                 if ((PartitionType == 0) && (errno == ERANGE))
 457                 {
 458                     ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
 459                     return TRUE;
 460                 }
 461             }
 462 #if 0
 463             else if ()
 464             {
 465                 /* GUID */
 466             }
 467 #endif
 468             else
 469             {
 470                 ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
 471                 return TRUE;
 472             }
 473         }
 474         else if (HasPrefix(argv[i], L"align=", &pszSuffix))
 475         {
 476             /* align=<N> */
 477             DPRINT("Align : %s\n", pszSuffix);
 478             ConPuts(StdOut, L"The ALIGN option is not supported yet!\n");
 479 #if 0
 480             bAlign = TRUE;
 481 #endif
 482         }
 483         else if (_wcsicmp(argv[i], L"noerr") == 0)
 484         {
 485             /* noerr */
 486             DPRINT("NoErr\n", pszSuffix);
 487             ConPuts(StdOut, L"The NOERR option is not supported yet!\n");
 488 #if 0
 489             bNoErr = TRUE;
 490 #endif
 491         }
 492         else
 493         {
 494             ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
 495             return TRUE;
 496         }
 497     }
 498
 499     DPRINT1("Size: %I64u\n", ullSize);
 500 #if 0
 501     DPRINT1("Offset: %I64u\n", ullOffset);
 502 #endif
 503     DPRINT1("Partition Type: %hx\n", PartitionType);
 504
 505     if (GetPrimaryPartitionCount(CurrentDisk) >= 4)
 506     {
 507         ConPuts(StdOut, L"No space left for another primary partition!\n");
 508         return TRUE;
 509     }
 510
 511     if (ullSize != 0)
 512         ullSectorCount = (ullSize * 1024 * 1024) / CurrentDisk->BytesPerSector;
 513     else
 514         ullSectorCount = 0;
 515
 516     DPRINT1("SectorCount: %I64u\n", ullSectorCount);
 517
 518     for (ListEntry = CurrentDisk->PrimaryPartListHead.Flink;
 519          ListEntry != &CurrentDisk->PrimaryPartListHead;
 520          ListEntry = ListEntry->Flink)
 521     {
 522         PartEntry = CONTAINING_RECORD(ListEntry, PARTENTRY, ListEntry);
 523         if (PartEntry->IsPartitioned)
 524             continue;
 525
 526         if (ullSectorCount == 0)
 527         {
 528             PartEntry->IsPartitioned = TRUE;
 529             PartEntry->New = TRUE;
 530             PartEntry->PartitionType = PartitionType;
 531             PartEntry->FormatState = Unformatted;
 532             PartEntry->FileSystemName[0] = L'\0';
 533
 534             CurrentPartition = PartEntry;
 535             CurrentDisk->Dirty = TRUE;
 536             break;
 537         }
 538         else
 539         {
 540             if (PartEntry->SectorCount.QuadPart == ullSectorCount)
 541             {
 542                 PartEntry->IsPartitioned = TRUE;
 543                 PartEntry->New = TRUE;
 544                 PartEntry->PartitionType = PartitionType;
 545                 PartEntry->FormatState = Unformatted;
 546                 PartEntry->FileSystemName[0] = L'\0';
 547
 548                 CurrentPartition = PartEntry;
 549                 CurrentDisk->Dirty = TRUE;
 550                 break;
 551             }
 552             else if (PartEntry->SectorCount.QuadPart > ullSectorCount)
 553             {
 554                 NewPartEntry = RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(PPARTENTRY));
 555                 if (NewPartEntry == NULL)
 556                 {
 557                     ConPuts(StdOut, L"Memory allocation failed!\n");
 558                     return TRUE;
 559                 }
 560
 561                 NewPartEntry->DiskEntry = PartEntry->DiskEntry;
 562
 563                 NewPartEntry->StartSector.QuadPart = PartEntry->StartSector.QuadPart;
 564                 NewPartEntry->SectorCount.QuadPart = ullSectorCount;
 565
 566                 NewPartEntry->LogicalPartition = FALSE;
 567                 NewPartEntry->IsPartitioned = TRUE;
 568                 NewPartEntry->New = TRUE;
 569                 NewPartEntry->PartitionType = PartitionType;
 570                 NewPartEntry->FormatState = Unformatted;
 571                 NewPartEntry->FileSystemName[0] = L'\0';
 572
 573                 PartEntry->StartSector.QuadPart += ullSectorCount;
 574                 PartEntry->SectorCount.QuadPart -= ullSectorCount;
 575
 576                 InsertTailList(ListEntry, &NewPartEntry->ListEntry);
 577
 578                 CurrentPartition = NewPartEntry;
 579                 CurrentDisk->Dirty = TRUE;
 580                 break;
 581             }
 582         }
 583     }
 584
 585     UpdateDiskLayout(CurrentDisk);
 586     Status = WritePartitions(CurrentDisk);
 587     if (!NT_SUCCESS(Status))
 588     {
 589         ConResPuts(StdOut, IDS_CREATE_PARTITION_FAIL);
 590         CurrentPartition = NULL;
 591         return TRUE;
 592     }
 593
 594     ConResPuts(StdOut, IDS_CREATE_PARTITION_SUCCESS);
 595
 596     return TRUE;
 597 }