src/add-ons/kernel/partitioning_systems/gpt/efi_gpt.cpp

   1 /*
   2  * Copyright 2009, Michael Lotz, mmlr@mlotz.ch. All rights reserved.
   3  * Copyright 2007-2013, Axel Dörfler, axeld@pinc-software.de.
   4  *
   5  * Distributed under the terms of the MIT License.
   6  */
   7
   8
   9 #include "efi_gpt.h"
  10
  11 #include <KernelExport.h>
  12 #include <disk_device_manager/ddm_modules.h>
  13 #include <disk_device_types.h>
  14 #ifdef _BOOT_MODE
  15 #       include <boot/partitions.h>
  16 #else
  17 #       include <DiskDeviceTypes.h>
  18 #       include "PartitionLocker.h"
  19 #endif
  20 #include <util/kernel_cpp.h>
  21
  22 #include <errno.h>
  23 #include <unistd.h>
  24 #include <stdio.h>
  25 #include <string.h>
  26
  27 #ifndef _BOOT_MODE
  28 #include "uuid.h"
  29 #endif
  30
  31 #include "Header.h"
  32 #include "utility.h"
  33
  34
  35 #define TRACE_EFI_GPT
  36 #ifdef TRACE_EFI_GPT
  37 #       define TRACE(x) dprintf x
  38 #else
  39 #       define TRACE(x) ;
  40 #endif
  41
  42
  43 #define EFI_PARTITION_MODULE_NAME "partitioning_systems/efi_gpt/v1"
  44
  45
  46 #ifndef _BOOT_MODE
  47 static off_t
  48 block_align(partition_data* partition, off_t offset, bool upwards)
  49 {
  50         // Take HDs into account that hide the fact they are using a
  51         // block size of 4096 bytes, and round to that.
  52         uint32 blockSize = max_c(partition->block_size, 4096);
  53         if (upwards)
  54                 return ((offset + blockSize - 1) / blockSize) * blockSize;
  55
  56         return (offset / blockSize) * blockSize;
  57 }
  58 #endif // !_BOOT_MODE
  59
  60
  61 //      #pragma mark - public module interface
  62
  63
  64 static status_t
  65 efi_gpt_std_ops(int32 op, ...)
  66 {
  67         switch (op) {
  68                 case B_MODULE_INIT:
  69                 case B_MODULE_UNINIT:
  70                         return B_OK;
  71         }
  72
  73         return B_ERROR;
  74 }
  75
  76
  77 static float
  78 efi_gpt_identify_partition(int fd, partition_data* partition, void** _cookie)
  79 {
  80         EFI::Header* header = new (std::nothrow) EFI::Header(fd,
  81                 (partition->size - 1) / partition->block_size, partition->block_size);
  82         status_t status = header->InitCheck();
  83         if (status != B_OK) {
  84                 delete header;
  85                 return -1;
  86         }
  87
  88         *_cookie = header;
  89         if (header->IsDirty()) {
  90                 // Either the main or the backup table is missing, it looks like someone
  91                 // tried to erase the GPT with something else. Let's lower the priority,
  92                 // so that other partitioning systems which use either only the start or
  93                 // only the end of the drive, have a chance to run instead.
  94                 return 0.75;
  95         }
  96         return 0.96;
  97                 // This must be higher as Intel partitioning, as EFI can contain this
  98                 // partitioning for compatibility
  99 }
 100
 101
 102 static status_t
 103 efi_gpt_scan_partition(int fd, partition_data* partition, void* _cookie)
 104 {
 105         TRACE(("efi_gpt_scan_partition(cookie = %p)\n", _cookie));
 106         EFI::Header* header = (EFI::Header*)_cookie;
 107
 108         partition->status = B_PARTITION_VALID;
 109         partition->flags |= B_PARTITION_PARTITIONING_SYSTEM;
 110         partition->content_size = partition->size;
 111         partition->content_cookie = header;
 112
 113         // scan all children
 114
 115         uint32 index = 0;
 116
 117         for (uint32 i = 0; i < header->EntryCount(); i++) {
 118                 const efi_partition_entry& entry = header->EntryAt(i);
 119
 120                 if (entry.partition_type == kEmptyGUID)
 121                         continue;
 122
 123                 if (entry.EndBlock() * partition->block_size
 124                                 > (uint64)partition->size) {
 125                         TRACE(("efi_gpt: child partition exceeds existing space (ends at "
 126                                 "block %" B_PRIu64 ")\n", entry.EndBlock()));
 127                         continue;
 128                 }
 129
 130                 if (entry.StartBlock() * partition->block_size == 0) {
 131                         TRACE(("efi_gpt: child partition starts at 0 (recursive entry)\n"));
 132                         continue;
 133                 }
 134
 135                 partition_data* child = create_child_partition(partition->id, index++,
 136                         partition->offset + entry.StartBlock() * partition->block_size,
 137                         entry.BlockCount() * partition->block_size, -1);
 138                 if (child == NULL) {
 139                         TRACE(("efi_gpt: Creating child at index %" B_PRIu32 " failed\n",
 140                                 index - 1));
 141                         return B_ERROR;
 142                 }
 143
 144                 char name[B_OS_NAME_LENGTH];
 145                 to_utf8(entry.name, EFI_PARTITION_NAME_LENGTH, name, sizeof(name));
 146                 child->name = strdup(name);
 147                 child->type = strdup(get_partition_type(entry.partition_type));
 148                 child->block_size = partition->block_size;
 149                 child->cookie = (void*)(addr_t)i;
 150                 child->content_cookie = header;
 151         }
 152
 153         return B_OK;
 154 }
 155
 156
 157 static void
 158 efi_gpt_free_identify_partition_cookie(partition_data* partition, void* _cookie)
 159 {
 160         // Cookie is freed in efi_gpt_free_partition_content_cookie().
 161 }
 162
 163
 164 static void
 165 efi_gpt_free_partition_content_cookie(partition_data* partition)
 166 {
 167         delete (EFI::Header*)partition->content_cookie;
 168 }
 169
 170
 171 #ifndef _BOOT_MODE
 172 static uint32
 173 efi_gpt_get_supported_operations(partition_data* partition, uint32 mask)
 174 {
 175         uint32 flags = B_DISK_SYSTEM_SUPPORTS_INITIALIZING
 176                 | B_DISK_SYSTEM_SUPPORTS_SETTING_CONTENT_NAME
 177                 | B_DISK_SYSTEM_SUPPORTS_MOVING
 178                 | B_DISK_SYSTEM_SUPPORTS_RESIZING
 179                 | B_DISK_SYSTEM_SUPPORTS_CREATING_CHILD;
 180                 // TODO: check for available entries and partitionable space and only
 181                 // add creating child support if both is valid
 182
 183         return flags;
 184 }
 185
 186
 187 static uint32
 188 efi_gpt_get_supported_child_operations(partition_data* partition,
 189         partition_data* child, uint32 mask)
 190 {
 191         return B_DISK_SYSTEM_SUPPORTS_MOVING_CHILD
 192                 | B_DISK_SYSTEM_SUPPORTS_RESIZING_CHILD
 193                 | B_DISK_SYSTEM_SUPPORTS_SETTING_TYPE
 194                 | B_DISK_SYSTEM_SUPPORTS_DELETING_CHILD;
 195 }
 196
 197
 198 static bool
 199 efi_gpt_is_sub_system_for(partition_data* partition)
 200 {
 201         // a GUID Partition Table doesn't usually live inside another partition
 202         return false;
 203 }
 204
 205
 206 static bool
 207 efi_gpt_validate_resize(partition_data* partition, off_t* size)
 208 {
 209         off_t newSize = *size;
 210         if (newSize == partition->size)
 211                 return true;
 212
 213         if (newSize < 0)
 214                 newSize = 0;
 215         else
 216                 newSize = block_align(partition, newSize, false);
 217
 218         // growing
 219         if (newSize > partition->size) {
 220                 *size = newSize;
 221                 return true;
 222         }
 223
 224         // shrinking, only so that no child would be truncated
 225         off_t newEnd = partition->offset + newSize;
 226         for (int32 i = 0; i < partition->child_count; i++) {
 227                 partition_data* child = get_child_partition(partition->id, i);
 228                 if (child == NULL)
 229                         continue;
 230
 231                 if (child->offset + child->size > newEnd)
 232                         newEnd = child->offset + child->size;
 233         }
 234
 235         newSize = block_align(partition, newEnd - partition->offset, true);
 236         *size = newSize;
 237         return true;
 238 }
 239
 240
 241 static bool
 242 efi_gpt_validate_resize_child(partition_data* partition, partition_data* child,
 243         off_t* size)
 244 {
 245         off_t newSize = *size;
 246         if (newSize == child->size)
 247                 return true;
 248
 249         // shrinking
 250         if (newSize < child->size) {
 251                 if (newSize < 0)
 252                         newSize = 0;
 253
 254                 *size = block_align(partition, newSize, false);
 255                 return true;
 256         }
 257
 258         // growing, but only so much that the child doesn't get bigger than
 259         // the parent
 260         if (child->offset + newSize > partition->offset + partition->size)
 261                 newSize = partition->offset + partition->size - child->offset;
 262
 263         // make sure that the child doesn't overlap any sibling partitions
 264         off_t newEnd = child->offset + newSize;
 265         for (int32 i = 0; i < partition->child_count; i++) {
 266                 partition_data* other = get_child_partition(partition->id, i);
 267                 if (other == NULL || other->id == child->id
 268                         || other->offset < child->offset)
 269                         continue;
 270
 271                 if (newEnd > other->offset)
 272                         newEnd = other->offset;
 273         }
 274
 275         *size = block_align(partition, newEnd - child->offset, false);
 276         return true;
 277 }
 278
 279
 280 static bool
 281 efi_gpt_validate_move(partition_data* partition, off_t* start)
 282 {
 283         // nothing to do
 284         return true;
 285 }
 286
 287
 288 static bool
 289 efi_gpt_validate_move_child(partition_data* partition, partition_data* child,
 290         off_t* start)
 291 {
 292         off_t newStart = *start;
 293         if (newStart < 0)
 294                 newStart = 0;
 295
 296         if (newStart + child->size > partition->size)
 297                 newStart = partition->size - child->size;
 298
 299         newStart = block_align(partition, newStart, false);
 300         if (newStart > child->offset) {
 301                 for (int32 i = 0; i < partition->child_count; i++) {
 302                         partition_data* other = get_child_partition(partition->id, i);
 303                         if (other == NULL || other->id == child->id
 304                                 || other->offset < child->offset)
 305                                 continue;
 306
 307                         if (other->offset < newStart + child->size)
 308                                 newStart = other->offset - child->size;
 309                 }
 310
 311                 newStart = block_align(partition, newStart, false);
 312         } else {
 313                 for (int32 i = 0; i < partition->child_count; i++) {
 314                         partition_data* other = get_child_partition(partition->id, i);
 315                         if (other == NULL || other->id == child->id
 316                                 || other->offset > child->offset)
 317                                 continue;
 318
 319                         if (other->offset + other->size > newStart)
 320                                 newStart = other->offset + other->size;
 321                 }
 322
 323                 newStart = block_align(partition, newStart, true);
 324         }
 325
 326         *start = newStart;
 327         return true;
 328 }
 329
 330
 331 static bool
 332 efi_gpt_validate_set_name(partition_data* partition, char* name)
 333 {
 334         // TODO: should validate that the utf-8 -> ucs-2 is valid
 335         // TODO: should count actual utf-8 chars
 336         if (strlen(name) > EFI_PARTITION_NAME_LENGTH)
 337                 name[EFI_PARTITION_NAME_LENGTH - 1] = 0;
 338         return true;
 339 }
 340
 341
 342 static bool
 343 efi_gpt_validate_set_type(partition_data* partition, const char* type)
 344 {
 345         guid_t typeGUID;
 346         return get_guid_for_partition_type(type, typeGUID);
 347 }
 348
 349
 350 static bool
 351 efi_gpt_validate_initialize(partition_data* partition, char* name,
 352         const char* parameters)
 353 {
 354         if ((efi_gpt_get_supported_operations(partition, ~0)
 355                 & B_DISK_SYSTEM_SUPPORTS_INITIALIZING) == 0)
 356                 return false;
 357
 358         // name and parameters are ignored
 359         if (name != NULL)
 360                 name[0] = 0;
 361
 362         return true;
 363 }
 364
 365
 366 static bool
 367 efi_gpt_validate_create_child(partition_data* partition, off_t* start,
 368         off_t* size, const char* type, const char* name, const char* parameters,
 369         int32* index)
 370 {
 371         if ((efi_gpt_get_supported_operations(partition, ~0)
 372                         & B_DISK_SYSTEM_SUPPORTS_CREATING_CHILD) == 0)
 373                 return false;
 374
 375         if (!efi_gpt_validate_set_type(partition, type))
 376                 return false;
 377
 378         EFI::Header* header = (EFI::Header*)partition->content_cookie;
 379         int32 entryIndex = -1;
 380         for (uint32 i = 0; i < header->EntryCount(); i++) {
 381                 const efi_partition_entry& entry = header->EntryAt(i);
 382                 if (entry.partition_type == kEmptyGUID) {
 383                         entryIndex = i;
 384                         break;
 385                 }
 386         }
 387
 388         if (entryIndex < 0)
 389                 return false;
 390
 391         *index = entryIndex;
 392
 393         // ensure that child lies between first and last usable block
 394         off_t firstUsable = header->FirstUsableBlock() * partition->block_size;
 395         if (*start < firstUsable)
 396                 *start = firstUsable;
 397
 398         off_t lastUsable = header->LastUsableBlock() * partition->block_size;
 399         if (*start + *size > lastUsable) {
 400                 if (*start > lastUsable)
 401                         return false;
 402
 403                 *size = lastUsable - *start;
 404         }
 405
 406         // ensure that we don't overlap any siblings
 407         for (int32 i = 0; i < partition->child_count; i++) {
 408                 partition_data* other = get_child_partition(partition->id, i);
 409                 if (other == NULL)
 410                         continue;
 411
 412                 if (other->offset < *start && other->offset + other->size > *start)
 413                         *start = other->offset + other->size;
 414
 415                 if (other->offset > *start && other->offset < *start + *size)
 416                         *size = other->offset - *start;
 417         }
 418
 419         *start = block_align(partition, *start, true);
 420         *size = block_align(partition, *size, false);
 421
 422         // TODO: support parameters
 423         return true;
 424 }
 425
 426
 427 static status_t
 428 efi_gpt_get_partitionable_spaces(partition_data* partition,
 429         partitionable_space_data* buffer, int32 count, int32* actualCount)
 430 {
 431         // TODO: implement
 432         return B_ERROR;
 433 }
 434
 435
 436 static status_t
 437 efi_gpt_get_next_supported_type(partition_data* partition, int32* cookie,
 438         char* type)
 439 {
 440         // TODO: implement
 441         return B_ERROR;
 442 }
 443
 444
 445 static status_t
 446 efi_gpt_shadow_changed(partition_data* partition, partition_data* child,
 447         uint32 operation)
 448 {
 449         // TODO: implement
 450         return B_ERROR;
 451 }
 452
 453
 454 static status_t
 455 efi_gpt_repair(int fd, partition_id partition, bool checkOnly, disk_job_id job)
 456 {
 457         // TODO: implement, validate CRCs and restore from backup area if corrupt
 458         return B_ERROR;
 459 }
 460
 461
 462 static status_t
 463 efi_gpt_resize(int fd, partition_id partitionID, off_t size, disk_job_id job)
 464 {
 465         if (fd < 0)
 466                 return B_ERROR;
 467
 468         PartitionWriteLocker locker(partitionID);
 469         if (!locker.IsLocked())
 470                 return B_ERROR;
 471
 472         partition_data* partition = get_partition(partitionID);
 473         if (partition == NULL)
 474                 return B_BAD_VALUE;
 475
 476         off_t validatedSize = size;
 477         if (!efi_gpt_validate_resize(partition, &validatedSize))
 478                 return B_BAD_VALUE;
 479
 480         update_disk_device_job_progress(job, 0.0);
 481
 482         partition->size = validatedSize;
 483         partition->content_size = validatedSize;
 484
 485         update_disk_device_job_progress(job, 1.0);
 486         partition_modified(partitionID);
 487         return B_OK;
 488 }
 489
 490
 491 static status_t
 492 efi_gpt_resize_child(int fd, partition_id partitionID, off_t size,
 493         disk_job_id job)
 494 {
 495         if (fd < 0)
 496                 return B_ERROR;
 497
 498         PartitionWriteLocker locker(partitionID);
 499         if (!locker.IsLocked())
 500                 return B_ERROR;
 501
 502         partition_data* child = get_partition(partitionID);
 503         if (child == NULL)
 504                 return B_BAD_VALUE;
 505
 506         partition_data* partition = get_parent_partition(partitionID);
 507         if (partition == NULL)
 508                 return B_BAD_VALUE;
 509
 510         EFI::Header* header = (EFI::Header*)partition->content_cookie;
 511         if (header == NULL)
 512                 return B_BAD_VALUE;
 513
 514         uint32 entryIndex = (uint32)(addr_t)child->cookie;
 515         if (entryIndex >= header->EntryCount())
 516                 return B_BAD_VALUE;
 517
 518         off_t validatedSize = size;
 519         if (!efi_gpt_validate_resize_child(partition, child, &validatedSize))
 520                 return B_BAD_VALUE;
 521
 522         if (child->size == validatedSize)
 523                 return B_OK;
 524
 525         update_disk_device_job_progress(job, 0.0);
 526
 527         efi_partition_entry& entry = header->EntryAt(entryIndex);
 528         entry.SetBlockCount(validatedSize / partition->block_size);
 529
 530         status_t result = header->WriteEntry(fd, entryIndex);
 531         if (result != B_OK) {
 532                 entry.SetBlockCount(child->size / partition->block_size);
 533                 return result;
 534         }
 535
 536         child->size = validatedSize;
 537
 538         update_disk_device_job_progress(job, 1.0);
 539         partition_modified(partitionID);
 540         return B_OK;
 541 }
 542
 543
 544 static status_t
 545 efi_gpt_move(int fd, partition_id partition, off_t offset, disk_job_id job)
 546 {
 547         // nothing to do here
 548         return B_OK;
 549 }
 550
 551
 552 static status_t
 553 efi_gpt_move_child(int fd, partition_id partitionID, partition_id childID,
 554         off_t offset, disk_job_id job)
 555 {
 556         if (fd < 0)
 557                 return B_ERROR;
 558
 559         PartitionWriteLocker locker(partitionID);
 560         if (!locker.IsLocked())
 561                 return B_ERROR;
 562
 563         partition_data* partition = get_partition(partitionID);
 564         if (partition == NULL)
 565                 return B_BAD_VALUE;
 566
 567         partition_data* child = get_partition(childID);
 568         if (child == NULL)
 569                 return B_BAD_VALUE;
 570
 571         EFI::Header* header = (EFI::Header*)partition->content_cookie;
 572         if (header == NULL)
 573                 return B_BAD_VALUE;
 574
 575         uint32 entryIndex = (uint32)(addr_t)child->cookie;
 576         if (entryIndex >= header->EntryCount())
 577                 return B_BAD_VALUE;
 578
 579         off_t validatedOffset = offset;
 580         if (!efi_gpt_validate_move_child(partition, child, &validatedOffset))
 581                 return B_BAD_VALUE;
 582
 583         if (child->offset == validatedOffset)
 584                 return B_OK;
 585
 586         // TODO: implement actual moving, need to move the partition content
 587         // (the raw data) here and need to take overlap into account
 588         return B_ERROR;
 589
 590         update_disk_device_job_progress(job, 0.0);
 591
 592         efi_partition_entry& entry = header->EntryAt(entryIndex);
 593         uint64 blockCount = entry.BlockCount();
 594         entry.SetStartBlock((validatedOffset - partition->offset)
 595                 / partition->block_size);
 596         entry.SetBlockCount(blockCount);
 597
 598         status_t result = header->WriteEntry(fd, entryIndex);
 599         if (result != B_OK) {
 600                 // fatal error: the data has been moved but the partition table could
 601                 // not be updated to reflect that change!
 602                 return result;
 603         }
 604
 605         child->offset = validatedOffset;
 606
 607         update_disk_device_job_progress(job, 1.0);
 608         partition_modified(childID);
 609         return B_OK;
 610 }
 611
 612
 613 static status_t
 614 efi_gpt_set_name(int fd, partition_id partitionID, const char* name,
 615         disk_job_id job)
 616 {
 617         if (fd < 0)
 618                 return B_ERROR;
 619
 620         PartitionWriteLocker locker(partitionID);
 621         if (!locker.IsLocked())
 622                 return B_ERROR;
 623
 624         partition_data* child = get_partition(partitionID);
 625         if (child == NULL)
 626                 return B_BAD_VALUE;
 627
 628         partition_data* partition = get_parent_partition(partitionID);
 629         if (partition == NULL)
 630                 return B_BAD_VALUE;
 631
 632         EFI::Header* header = (EFI::Header*)partition->content_cookie;
 633         if (header == NULL)
 634                 return B_BAD_VALUE;
 635
 636         uint32 entryIndex = (uint32)(addr_t)child->cookie;
 637         if (entryIndex >= header->EntryCount())
 638                 return B_BAD_VALUE;
 639
 640         update_disk_device_job_progress(job, 0.0);
 641
 642         efi_partition_entry& entry = header->EntryAt(entryIndex);
 643         to_ucs2(name, strlen(name), entry.name, EFI_PARTITION_NAME_LENGTH);
 644
 645         status_t result = header->WriteEntry(fd, entryIndex);
 646         if (result != B_OK)
 647                 return result;
 648
 649         char newName[B_OS_NAME_LENGTH];
 650         to_utf8(entry.name, EFI_PARTITION_NAME_LENGTH, newName, sizeof(newName));
 651         child->name = strdup(newName);
 652
 653         update_disk_device_job_progress(job, 1.0);
 654         partition_modified(partitionID);
 655         return B_OK;
 656 }
 657
 658
 659 static status_t
 660 efi_gpt_set_type(int fd, partition_id partitionID, const char* type,
 661         disk_job_id job)
 662 {
 663         if (fd < 0)
 664                 return B_ERROR;
 665
 666         PartitionWriteLocker locker(partitionID);
 667         if (!locker.IsLocked())
 668                 return B_ERROR;
 669
 670         partition_data* child = get_partition(partitionID);
 671         if (child == NULL)
 672                 return B_BAD_VALUE;
 673
 674         partition_data* partition = get_parent_partition(partitionID);
 675         if (partition == NULL)
 676                 return B_BAD_VALUE;
 677
 678         EFI::Header* header = (EFI::Header*)partition->content_cookie;
 679         if (header == NULL)
 680                 return B_BAD_VALUE;
 681
 682         uint32 entryIndex = (uint32)(addr_t)child->cookie;
 683         if (entryIndex >= header->EntryCount())
 684                 return B_BAD_VALUE;
 685
 686         guid_t typeGUID;
 687         if (!get_guid_for_partition_type(type, typeGUID))
 688                 return B_BAD_VALUE;
 689
 690         update_disk_device_job_progress(job, 0.0);
 691
 692         efi_partition_entry& entry = header->EntryAt(entryIndex);
 693         entry.partition_type = typeGUID;
 694
 695         status_t result = header->WriteEntry(fd, entryIndex);
 696         if (result != B_OK)
 697                 return result;
 698
 699         child->type = strdup(type);
 700
 701         update_disk_device_job_progress(job, 1.0);
 702         partition_modified(partitionID);
 703         return B_OK;
 704 }
 705
 706
 707 static status_t
 708 efi_gpt_initialize(int fd, partition_id partitionID, const char* name,
 709         const char* parameters, off_t partitionSize, disk_job_id job)
 710 {
 711         if (fd < 0)
 712                 return B_ERROR;
 713
 714         partition_data* partition = get_partition(partitionID);
 715         if (partition == NULL)
 716                 return B_BAD_VALUE;
 717
 718         update_disk_device_job_progress(job, 0.0);
 719
 720         EFI::Header header((partitionSize - 1) / partition->block_size,
 721                 partition->block_size);
 722         status_t result = header.InitCheck();
 723         if (result != B_OK)
 724                 return result;
 725
 726         result = header.Write(fd);
 727         if (result != B_OK)
 728                 return result;
 729
 730         result = scan_partition(partitionID);
 731         if (result != B_OK)
 732                 return result;
 733
 734         update_disk_device_job_progress(job, 1.0);
 735         partition_modified(partitionID);
 736         return B_OK;
 737 }
 738
 739
 740 static status_t
 741 efi_gpt_uninitialize(int fd, partition_id partitionID, off_t partitionSize,
 742         uint32 blockSize, disk_job_id job)
 743 {
 744         if (fd < 0)
 745                 return B_ERROR;
 746
 747         partition_data* partition = get_partition(partitionID);
 748         if (partition == NULL)
 749                 return B_BAD_VALUE;
 750
 751         update_disk_device_job_progress(job, 0.0);
 752
 753         const int headerSize = partition->block_size * 3;
 754         // The first block is the protective MBR
 755         // The second block is the GPT header
 756         // The third block is the start of the partition list (it can span more
 757         // blocks, but that doesn't matter as soon as the header is erased).
 758
 759         uint8 buffer[headerSize];
 760         memset(buffer, 0xE5, sizeof(buffer));
 761
 762         // Erase the first blocks
 763         if (write_pos(fd, 0, &buffer, headerSize) < 0)
 764                 return errno;
 765
 766         // Erase the last blocks
 767         // Only 2 blocks, as there is no protective MBR
 768         if (write_pos(fd, partitionSize - 2 * partition->block_size,
 769                         &buffer, 2 * partition->block_size) < 0) {
 770                 return errno;
 771         }
 772
 773         update_disk_device_job_progress(job, 1.0);
 774
 775         return B_OK;
 776 }
 777
 778
 779 static status_t
 780 efi_gpt_create_child(int fd, partition_id partitionID, off_t offset,
 781         off_t size, const char* type, const char* name, const char* parameters,
 782         disk_job_id job, partition_id* childID)
 783 {
 784         if (fd < 0)
 785                 return B_ERROR;
 786
 787         PartitionWriteLocker locker(partitionID);
 788         if (!locker.IsLocked())
 789                 return B_ERROR;
 790
 791         partition_data* partition = get_partition(partitionID);
 792         if (partition == NULL)
 793                 return B_BAD_VALUE;
 794
 795         EFI::Header* header = (EFI::Header*)partition->content_cookie;
 796         if (header == NULL)
 797                 return B_BAD_VALUE;
 798
 799         off_t validatedOffset = offset;
 800         off_t validatedSize = size;
 801         uint32 entryIndex = 0;
 802
 803         if (!efi_gpt_validate_create_child(partition, &validatedOffset,
 804                         &validatedSize, type, name, parameters, (int32*)&entryIndex))
 805                 return B_BAD_VALUE;
 806
 807         guid_t typeGUID;
 808         if (!get_guid_for_partition_type(type, typeGUID))
 809                 return B_BAD_VALUE;
 810
 811         update_disk_device_job_progress(job, 0.0);
 812
 813         partition_data* child = create_child_partition(partition->id, entryIndex,
 814                 validatedOffset, validatedSize, *childID);
 815         if (child == NULL)
 816                 return B_ERROR;
 817
 818         efi_partition_entry& entry = header->EntryAt(entryIndex);
 819         entry.partition_type = typeGUID;
 820         uuid_t uuid;
 821         uuid_generate_random(uuid);
 822         memcpy((uint8*)&entry.unique_guid, uuid, sizeof(guid_t));
 823         to_ucs2(name, strlen(name), entry.name, EFI_PARTITION_NAME_LENGTH);
 824         entry.SetStartBlock((validatedOffset - partition->offset)
 825                 / partition->block_size);
 826         entry.SetBlockCount(validatedSize / partition->block_size);
 827         entry.SetAttributes(0); // TODO
 828
 829         status_t result = header->WriteEntry(fd, entryIndex);
 830         if (result != B_OK) {
 831                 delete_partition(child->id);
 832                 return result;
 833         }
 834
 835         *childID = child->id;
 836         child->block_size = partition->block_size;
 837         child->name = strdup(name);
 838         child->type = strdup(type);
 839         child->parameters = strdup(parameters);
 840         child->cookie = (void*)(addr_t)entryIndex;
 841
 842         if (child->type == NULL || child->parameters == NULL) {
 843                 delete_partition(child->id);
 844                 return B_NO_MEMORY;
 845         }
 846
 847         update_disk_device_job_progress(job, 1.0);
 848         partition_modified(partitionID);
 849         return B_OK;
 850 }
 851
 852
 853 static status_t
 854 efi_gpt_delete_child(int fd, partition_id partitionID, partition_id childID,
 855         disk_job_id job)
 856 {
 857         if (fd < 0)
 858                 return B_ERROR;
 859
 860         PartitionWriteLocker locker(partitionID);
 861         if (!locker.IsLocked())
 862                 return B_ERROR;
 863
 864         partition_data* partition = get_partition(partitionID);
 865         if (partition == NULL)
 866                 return B_BAD_VALUE;
 867
 868         partition_data* child = get_partition(childID);
 869         if (child == NULL)
 870                 return B_BAD_VALUE;
 871
 872         EFI::Header* header = (EFI::Header*)partition->content_cookie;
 873         if (header == NULL)
 874                 return B_BAD_VALUE;
 875
 876         uint32 entryIndex = (uint32)(addr_t)child->cookie;
 877         if (entryIndex >= header->EntryCount())
 878                 return B_BAD_VALUE;
 879
 880         update_disk_device_job_progress(job, 0.0);
 881
 882         if (!delete_partition(childID))
 883                 return B_ERROR;
 884
 885         efi_partition_entry& entry = header->EntryAt(entryIndex);
 886         memset(&entry, 0, sizeof(efi_partition_entry));
 887         entry.partition_type = kEmptyGUID;
 888
 889         status_t result = header->WriteEntry(fd, entryIndex);
 890         if (result != B_OK)
 891                 return result;
 892
 893         update_disk_device_job_progress(job, 1.0);
 894         partition_modified(partitionID);
 895         return B_OK;
 896 }
 897 #endif // !_BOOT_MODE
 898
 899
 900 #ifndef _BOOT_MODE
 901 static partition_module_info sEFIPartitionModule = {
 902 #else
 903 partition_module_info gEFIPartitionModule = {
 904 #endif
 905         {
 906                 EFI_PARTITION_MODULE_NAME,
 907                 0,
 908                 efi_gpt_std_ops
 909         },
 910         "gpt",                                                                  // short_name
 911         EFI_PARTITION_NAME,                                             // pretty_name
 912         0                                                                               // flags
 913         | B_DISK_SYSTEM_SUPPORTS_INITIALIZING
 914         | B_DISK_SYSTEM_SUPPORTS_MOVING
 915         | B_DISK_SYSTEM_SUPPORTS_RESIZING
 916         | B_DISK_SYSTEM_SUPPORTS_SETTING_TYPE
 917         | B_DISK_SYSTEM_SUPPORTS_MOVING_CHILD
 918         | B_DISK_SYSTEM_SUPPORTS_RESIZING_CHILD
 919         | B_DISK_SYSTEM_SUPPORTS_CREATING_CHILD
 920         | B_DISK_SYSTEM_SUPPORTS_DELETING_CHILD
 921         | B_DISK_SYSTEM_SUPPORTS_SETTING_NAME
 922         | B_DISK_SYSTEM_SUPPORTS_NAME
 923         ,
 924
 925         // scanning
 926         efi_gpt_identify_partition,
 927         efi_gpt_scan_partition,
 928         efi_gpt_free_identify_partition_cookie,
 929         NULL, // free_partition_cookie
 930         efi_gpt_free_partition_content_cookie,
 931
 932 #ifndef _BOOT_MODE
 933         // querying
 934         efi_gpt_get_supported_operations,
 935         efi_gpt_get_supported_child_operations,
 936         NULL, // supports_initializing_child
 937         efi_gpt_is_sub_system_for,
 938
 939         efi_gpt_validate_resize,
 940         efi_gpt_validate_resize_child,
 941         efi_gpt_validate_move,
 942         efi_gpt_validate_move_child,
 943         efi_gpt_validate_set_name,
 944         NULL, // validate_set_content_name
 945         efi_gpt_validate_set_type,
 946         NULL, // validate_set_parameters
 947         NULL, // validate_set_content_parameters
 948         efi_gpt_validate_initialize,
 949         efi_gpt_validate_create_child,
 950         efi_gpt_get_partitionable_spaces,
 951         efi_gpt_get_next_supported_type,
 952         NULL, // get_type_for_content_type
 953
 954         // shadow partition modification
 955         efi_gpt_shadow_changed,
 956
 957         // writing
 958         efi_gpt_repair,
 959         efi_gpt_resize,
 960         efi_gpt_resize_child,
 961         efi_gpt_move,
 962         efi_gpt_move_child,
 963         efi_gpt_set_name,
 964         NULL, // set_content_name
 965         efi_gpt_set_type,
 966         NULL, // set_parameters
 967         NULL, // set_content_parameters
 968         efi_gpt_initialize,
 969         efi_gpt_uninitialize,
 970         efi_gpt_create_child,
 971         efi_gpt_delete_child
 972 #else
 973         NULL
 974 #endif // _BOOT_MODE
 975 };
 976
 977 #ifndef _BOOT_MODE
 978 partition_module_info* modules[] = {
 979         &sEFIPartitionModule,
 980         NULL
 981 };
 982 #endif