MdeModulePkg/Universal/Disk/Partition/Dxe/Partition.c

   1 /** @file
   2   Partition driver that produces logical BlockIo devices from a physical
   3   BlockIo device. The logical BlockIo devices are based on the format
   4   of the raw block devices media. Currently "El Torito CD-ROM", Legacy
   5   MBR, and GPT partition schemes are supported.
   6
   7   Copyright (c) 2006 - 2007, Intel Corporation
   8   All rights reserved. This program and the accompanying materials
   9   are licensed and made available under the terms and conditions of the BSD License
  10   which accompanies this distribution.  The full text of the license may be found at
  11   http://opensource.org/licenses/bsd-license.php
  12
  13   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  14   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  15
  16 **/
  17
  18
  19 //
  20 // Include common header file for this module.
  21 //
  22 #include "CommonHeader.h"
  23
  24 #include "Partition.h"
  25
  26 //
  27 // Partition Driver Global Variables
  28 //
  29 EFI_DRIVER_BINDING_PROTOCOL gPartitionDriverBinding = {
  30   PartitionDriverBindingSupported,
  31   PartitionDriverBindingStart,
  32   PartitionDriverBindingStop,
  33   0xa,
  34   NULL,
  35   NULL
  36 };
  37
  38 STATIC
  39 PARTITION_DETECT_ROUTINE mPartitionDetectRoutineTable[] = {
  40   PartitionInstallGptChildHandles,
  41   PartitionInstallElToritoChildHandles,
  42   PartitionInstallMbrChildHandles,
  43   NULL
  44 };
  45
  46
  47
  48 /**
  49   Test to see if this driver supports ControllerHandle. Any ControllerHandle
  50   than contains a BlockIo and DiskIo protocol can be supported.
  51
  52   @param  This                Protocol instance pointer.
  53   @param  ControllerHandle    Handle of device to test
  54   @param  RemainingDevicePath Optional parameter use to pick a specific child
  55                               device to start.
  56
  57   @retval EFI_SUCCESS         This driver supports this device
  58   @retval EFI_ALREADY_STARTED This driver is already running on this device
  59   @retval other               This driver does not support this device
  60
  61 **/
  62 EFI_STATUS
  63 EFIAPI
  64 PartitionDriverBindingSupported (
  65   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
  66   IN EFI_HANDLE                   ControllerHandle,
  67   IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath
  68   )
  69 {
  70   EFI_STATUS                Status;
  71   EFI_DEVICE_PATH_PROTOCOL  *ParentDevicePath;
  72   EFI_DISK_IO_PROTOCOL      *DiskIo;
  73   EFI_DEV_PATH              *Node;
  74
  75   if (RemainingDevicePath != NULL) {
  76     Node = (EFI_DEV_PATH *) RemainingDevicePath;
  77     if (Node->DevPath.Type != MEDIA_DEVICE_PATH ||
  78         Node->DevPath.SubType != MEDIA_HARDDRIVE_DP ||
  79         DevicePathNodeLength (&Node->DevPath) != sizeof (HARDDRIVE_DEVICE_PATH)
  80         ) {
  81       return EFI_UNSUPPORTED;
  82     }
  83   }
  84   //
  85   // Open the IO Abstraction(s) needed to perform the supported test
  86   //
  87   Status = gBS->OpenProtocol (
  88                   ControllerHandle,
  89                   &gEfiDevicePathProtocolGuid,
  90                   (VOID **) &ParentDevicePath,
  91                   This->DriverBindingHandle,
  92                   ControllerHandle,
  93                   EFI_OPEN_PROTOCOL_BY_DRIVER
  94                   );
  95   if (Status == EFI_ALREADY_STARTED) {
  96     return EFI_SUCCESS;
  97   }
  98
  99   if (EFI_ERROR (Status)) {
 100     return Status;
 101   }
 102   //
 103   // Close the I/O Abstraction(s) used to perform the supported test
 104   //
 105   gBS->CloseProtocol (
 106         ControllerHandle,
 107         &gEfiDevicePathProtocolGuid,
 108         This->DriverBindingHandle,
 109         ControllerHandle
 110         );
 111
 112   //
 113   // Open the IO Abstraction(s) needed to perform the supported test
 114   //
 115   Status = gBS->OpenProtocol (
 116                   ControllerHandle,
 117                   &gEfiDiskIoProtocolGuid,
 118                   (VOID **) &DiskIo,
 119                   This->DriverBindingHandle,
 120                   ControllerHandle,
 121                   EFI_OPEN_PROTOCOL_BY_DRIVER
 122                   );
 123   if (Status == EFI_ALREADY_STARTED) {
 124     return EFI_SUCCESS;
 125   }
 126
 127   if (EFI_ERROR (Status)) {
 128     return Status;
 129   }
 130   //
 131   // Close the I/O Abstraction(s) used to perform the supported test
 132   //
 133   gBS->CloseProtocol (
 134         ControllerHandle,
 135         &gEfiDiskIoProtocolGuid,
 136         This->DriverBindingHandle,
 137         ControllerHandle
 138         );
 139
 140   //
 141   // Open the IO Abstraction(s) needed to perform the supported test
 142   //
 143   Status = gBS->OpenProtocol (
 144                   ControllerHandle,
 145                   &gEfiBlockIoProtocolGuid,
 146                   NULL,
 147                   This->DriverBindingHandle,
 148                   ControllerHandle,
 149                   EFI_OPEN_PROTOCOL_TEST_PROTOCOL
 150                   );
 151
 152   return Status;
 153 }
 154
 155
 156 /**
 157   Start this driver on ControllerHandle by opening a Block IO and Disk IO
 158   protocol, reading Device Path, and creating a child handle with a
 159   Disk IO and device path protocol.
 160
 161   @param  This                 Protocol instance pointer.
 162   @param  ControllerHandle     Handle of device to bind driver to
 163   @param  RemainingDevicePath  Optional parameter use to pick a specific child
 164                                device to start.
 165
 166   @retval EFI_SUCCESS          This driver is added to ControllerHandle
 167   @retval EFI_ALREADY_STARTED  This driver is already running on ControllerHandle
 168   @retval other                This driver does not support this device
 169
 170 **/
 171 EFI_STATUS
 172 EFIAPI
 173 PartitionDriverBindingStart (
 174   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
 175   IN EFI_HANDLE                   ControllerHandle,
 176   IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath
 177   )
 178 {
 179   EFI_STATUS                Status;
 180   EFI_STATUS                OpenStatus;
 181   EFI_BLOCK_IO_PROTOCOL     *BlockIo;
 182   EFI_DISK_IO_PROTOCOL      *DiskIo;
 183   EFI_DEVICE_PATH_PROTOCOL  *ParentDevicePath;
 184   PARTITION_DETECT_ROUTINE  *Routine;
 185
 186   Status = gBS->OpenProtocol (
 187                   ControllerHandle,
 188                   &gEfiBlockIoProtocolGuid,
 189                   (VOID **) &BlockIo,
 190                   This->DriverBindingHandle,
 191                   ControllerHandle,
 192                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
 193                   );
 194   if (EFI_ERROR (Status)) {
 195     return Status;
 196   }
 197   //
 198   // Get the Device Path Protocol on ControllerHandle's handle
 199   //
 200   Status = gBS->OpenProtocol (
 201                   ControllerHandle,
 202                   &gEfiDevicePathProtocolGuid,
 203                   (VOID **) &ParentDevicePath,
 204                   This->DriverBindingHandle,
 205                   ControllerHandle,
 206                   EFI_OPEN_PROTOCOL_BY_DRIVER
 207                   );
 208   if (EFI_ERROR (Status) && Status != EFI_ALREADY_STARTED) {
 209     return Status;
 210   }
 211
 212   Status = gBS->OpenProtocol (
 213                   ControllerHandle,
 214                   &gEfiDiskIoProtocolGuid,
 215                   (VOID **) &DiskIo,
 216                   This->DriverBindingHandle,
 217                   ControllerHandle,
 218                   EFI_OPEN_PROTOCOL_BY_DRIVER
 219                   );
 220   if (EFI_ERROR (Status) && Status != EFI_ALREADY_STARTED) {
 221     gBS->CloseProtocol (
 222           ControllerHandle,
 223           &gEfiDevicePathProtocolGuid,
 224           This->DriverBindingHandle,
 225           ControllerHandle
 226           );
 227     return Status;
 228   }
 229
 230   OpenStatus = Status;
 231
 232   //
 233   // If no media is present, do nothing here.
 234   //
 235   Status = EFI_UNSUPPORTED;
 236   if (BlockIo->Media->MediaPresent) {
 237     //
 238     // Try for GPT, then El Torito, and then legacy MBR partition types. If the
 239     // media supports a given partition type install child handles to represent
 240     // the partitions described by the media.
 241     //
 242     Routine = &mPartitionDetectRoutineTable[0];
 243     while (*Routine != NULL) {
 244       Status = (*Routine) (
 245                    This,
 246                    ControllerHandle,
 247                    DiskIo,
 248                    BlockIo,
 249                    ParentDevicePath
 250                    );
 251       if (!EFI_ERROR (Status) || Status == EFI_MEDIA_CHANGED) {
 252         break;
 253       }
 254       Routine++;
 255     }
 256   }
 257   //
 258   // In the case that the driver is already started (OpenStatus == EFI_ALREADY_STARTED),
 259   // the DevicePathProtocol and the DiskIoProtocol are not actually opened by the
 260   // driver. So don't try to close them. Otherwise, we will break the dependency
 261   // between the controller and the driver set up before.
 262   //
 263   if (EFI_ERROR (Status) && !EFI_ERROR (OpenStatus) && Status != EFI_MEDIA_CHANGED) {
 264     gBS->CloseProtocol (
 265           ControllerHandle,
 266           &gEfiDiskIoProtocolGuid,
 267           This->DriverBindingHandle,
 268           ControllerHandle
 269           );
 270
 271     gBS->CloseProtocol (
 272           ControllerHandle,
 273           &gEfiDevicePathProtocolGuid,
 274           This->DriverBindingHandle,
 275           ControllerHandle
 276           );
 277   }
 278
 279   return Status;
 280 }
 281
 282
 283 /**
 284   Stop this driver on ControllerHandle. Support stoping any child handles
 285   created by this driver.
 286
 287   @param  This              Protocol instance pointer.
 288   @param  ControllerHandle  Handle of device to stop driver on
 289   @param  NumberOfChildren  Number of Handles in ChildHandleBuffer. If number of
 290                             children is zero stop the entire bus driver.
 291   @param  ChildHandleBuffer List of Child Handles to Stop.
 292
 293   @retval EFI_SUCCESS       This driver is removed ControllerHandle
 294   @retval other             This driver was not removed from this device
 295
 296 **/
 297 EFI_STATUS
 298 EFIAPI
 299 PartitionDriverBindingStop (
 300   IN  EFI_DRIVER_BINDING_PROTOCOL   *This,
 301   IN  EFI_HANDLE                    ControllerHandle,
 302   IN  UINTN                         NumberOfChildren,
 303   IN  EFI_HANDLE                    *ChildHandleBuffer
 304   )
 305 {
 306   EFI_STATUS              Status;
 307   UINTN                   Index;
 308   EFI_BLOCK_IO_PROTOCOL   *BlockIo;
 309   BOOLEAN                 AllChildrenStopped;
 310   PARTITION_PRIVATE_DATA  *Private;
 311   EFI_DISK_IO_PROTOCOL    *DiskIo;
 312
 313   if (NumberOfChildren == 0) {
 314     //
 315     // Close the bus driver
 316     //
 317     gBS->CloseProtocol (
 318           ControllerHandle,
 319           &gEfiDiskIoProtocolGuid,
 320           This->DriverBindingHandle,
 321           ControllerHandle
 322           );
 323
 324     gBS->CloseProtocol (
 325           ControllerHandle,
 326           &gEfiDevicePathProtocolGuid,
 327           This->DriverBindingHandle,
 328           ControllerHandle
 329           );
 330
 331     return EFI_SUCCESS;
 332   }
 333
 334   AllChildrenStopped = TRUE;
 335   for (Index = 0; Index < NumberOfChildren; Index++) {
 336     Status = gBS->OpenProtocol (
 337                     ChildHandleBuffer[Index],
 338                     &gEfiBlockIoProtocolGuid,
 339                     (VOID **) &BlockIo,
 340                     This->DriverBindingHandle,
 341                     ControllerHandle,
 342                     EFI_OPEN_PROTOCOL_GET_PROTOCOL
 343                     );
 344     if (!EFI_ERROR (Status)) {
 345
 346       Private = PARTITION_DEVICE_FROM_BLOCK_IO_THIS (BlockIo);
 347
 348       //
 349       // All Software protocols have be freed from the handle so remove it.
 350       //
 351       BlockIo->FlushBlocks (BlockIo);
 352
 353       Status = gBS->CloseProtocol (
 354                       ControllerHandle,
 355                       &gEfiDiskIoProtocolGuid,
 356                       This->DriverBindingHandle,
 357                       ChildHandleBuffer[Index]
 358                       );
 359
 360       Status = gBS->UninstallMultipleProtocolInterfaces (
 361                       ChildHandleBuffer[Index],
 362                       &gEfiDevicePathProtocolGuid,
 363                       Private->DevicePath,
 364                       &gEfiBlockIoProtocolGuid,
 365                       &Private->BlockIo,
 366                       Private->EspGuid,
 367                       NULL,
 368                       NULL
 369                       );
 370       if (EFI_ERROR (Status)) {
 371         gBS->OpenProtocol (
 372               ControllerHandle,
 373               &gEfiDiskIoProtocolGuid,
 374               (VOID **) &DiskIo,
 375               This->DriverBindingHandle,
 376               ChildHandleBuffer[Index],
 377               EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
 378               );
 379       } else {
 380         FreePool (Private->DevicePath);
 381         FreePool (Private);
 382       }
 383
 384     }
 385
 386     if (EFI_ERROR (Status)) {
 387       AllChildrenStopped = FALSE;
 388     }
 389   }
 390
 391   if (!AllChildrenStopped) {
 392     return EFI_DEVICE_ERROR;
 393   }
 394
 395   return EFI_SUCCESS;
 396 }
 397
 398
 399 /**
 400   Reset the Block Device.
 401
 402   @param  This                 Protocol instance pointer.
 403   @param  ExtendedVerification Driver may perform diagnostics on reset.
 404
 405   @retval EFI_SUCCESS          The device was reset.
 406   @retval EFI_DEVICE_ERROR     The device is not functioning properly and could
 407                                not be reset.
 408
 409 **/
 410 STATIC
 411 EFI_STATUS
 412 EFIAPI
 413 PartitionReset (
 414   IN EFI_BLOCK_IO_PROTOCOL  *This,
 415   IN BOOLEAN                ExtendedVerification
 416   )
 417 {
 418   PARTITION_PRIVATE_DATA  *Private;
 419
 420   Private = PARTITION_DEVICE_FROM_BLOCK_IO_THIS (This);
 421
 422   return Private->ParentBlockIo->Reset (
 423                                   Private->ParentBlockIo,
 424                                   ExtendedVerification
 425                                   );
 426 }
 427
 428
 429 /**
 430   Read by using the Disk IO protocol on the parent device. Lba addresses
 431   must be converted to byte offsets.
 432
 433   @param  This       Protocol instance pointer.
 434   @param  MediaId    Id of the media, changes every time the media is replaced.
 435   @param  Lba        The starting Logical Block Address to read from
 436   @param  BufferSize Size of Buffer, must be a multiple of device block size.
 437   @param  Buffer     Buffer containing read data
 438
 439   @retval EFI_SUCCESS           The data was read correctly from the device.
 440   @retval EFI_DEVICE_ERROR      The device reported an error while performing the read.
 441   @retval EFI_NO_MEDIA          There is no media in the device.
 442   @retval EFI_MEDIA_CHANGED     The MediaId does not matched the current device.
 443   @retval EFI_BAD_BUFFER_SIZE   The Buffer was not a multiple of the block size of the device.
 444   @retval EFI_INVALID_PARAMETER The read request contains device addresses that are not
 445                                 valid for the device.
 446
 447 **/
 448 STATIC
 449 EFI_STATUS
 450 EFIAPI
 451 PartitionReadBlocks (
 452   IN EFI_BLOCK_IO_PROTOCOL  *This,
 453   IN UINT32                 MediaId,
 454   IN EFI_LBA                Lba,
 455   IN UINTN                  BufferSize,
 456   OUT VOID                  *Buffer
 457   )
 458 {
 459   PARTITION_PRIVATE_DATA  *Private;
 460   UINT64                  Offset;
 461
 462   Private = PARTITION_DEVICE_FROM_BLOCK_IO_THIS (This);
 463
 464   if (BufferSize % Private->BlockSize != 0) {
 465     return EFI_BAD_BUFFER_SIZE;
 466   }
 467
 468   Offset = MultU64x32 (Lba, Private->BlockSize) + Private->Start;
 469   if (Offset + BufferSize > Private->End) {
 470     return EFI_INVALID_PARAMETER;
 471   }
 472   //
 473   // Because some kinds of partition have different block size from their parent
 474   // device, we call the Disk IO protocol on the parent device, not the Block IO
 475   // protocol
 476   //
 477   return Private->DiskIo->ReadDisk (Private->DiskIo, MediaId, Offset, BufferSize, Buffer);
 478 }
 479
 480 /**
 481   Write by using the Disk IO protocol on the parent device. Lba addresses
 482   must be converted to byte offsets.
 483
 484   @param  This       Protocol instance pointer.
 485   @param  MediaId    Id of the media, changes every time the media is replaced.
 486   @param  Lba        The starting Logical Block Address to read from
 487   @param  BufferSize Size of Buffer, must be a multiple of device block size.
 488   @param  Buffer     Buffer containing read data
 489
 490   @retval EFI_SUCCESS           The data was written correctly to the device.
 491   @retval EFI_WRITE_PROTECTED   The device can not be written to.
 492   @retval EFI_DEVICE_ERROR      The device reported an error while performing the write.
 493   @retval EFI_NO_MEDIA          There is no media in the device.
 494   @retval EFI_MEDIA_CHNAGED     The MediaId does not matched the current device.
 495   @retval EFI_BAD_BUFFER_SIZE   The Buffer was not a multiple of the block size of the device.
 496   @retval EFI_INVALID_PARAMETER The write request contains a LBA that is not
 497                                 valid for the device.
 498
 499 **/
 500 STATIC
 501 EFI_STATUS
 502 EFIAPI
 503 PartitionWriteBlocks (
 504   IN EFI_BLOCK_IO_PROTOCOL  *This,
 505   IN UINT32                 MediaId,
 506   IN EFI_LBA                Lba,
 507   IN UINTN                  BufferSize,
 508   OUT VOID                  *Buffer
 509   )
 510 {
 511   PARTITION_PRIVATE_DATA  *Private;
 512   UINT64                  Offset;
 513
 514   Private = PARTITION_DEVICE_FROM_BLOCK_IO_THIS (This);
 515
 516   if (BufferSize % Private->BlockSize != 0) {
 517     return EFI_BAD_BUFFER_SIZE;
 518   }
 519
 520   Offset = MultU64x32 (Lba, Private->BlockSize) + Private->Start;
 521   if (Offset + BufferSize > Private->End) {
 522     return EFI_INVALID_PARAMETER;
 523   }
 524   //
 525   // Because some kinds of partition have different block size from their parent
 526   // device, we call the Disk IO protocol on the parent device, not the Block IO
 527   // protocol
 528   //
 529   return Private->DiskIo->WriteDisk (Private->DiskIo, MediaId, Offset, BufferSize, Buffer);
 530 }
 531
 532
 533 /**
 534   Flush the parent Block Device.
 535
 536   @param  This              Protocol instance pointer.
 537
 538   @retval EFI_SUCCESS       All outstanding data was written to the device
 539   @retval EFI_DEVICE_ERROR  The device reported an error while writting back the data
 540   @retval EFI_NO_MEDIA      There is no media in the device.
 541
 542 **/
 543 STATIC
 544 EFI_STATUS
 545 EFIAPI
 546 PartitionFlushBlocks (
 547   IN EFI_BLOCK_IO_PROTOCOL  *This
 548   )
 549 {
 550   PARTITION_PRIVATE_DATA  *Private;
 551
 552   Private = PARTITION_DEVICE_FROM_BLOCK_IO_THIS (This);
 553
 554   return Private->ParentBlockIo->FlushBlocks (Private->ParentBlockIo);
 555 }
 556
 557
 558
 559 /**
 560   Create a child handle for a logical block device that represents the
 561   bytes Start to End of the Parent Block IO device.
 562
 563   @param[in]  This              Protocol instance pointer.
 564   @param[in]  This              Calling context.
 565   @param[in]  ParentHandle      Parent Handle for new child
 566   @param[in]  ParentDiskIo      Parent DiskIo interface
 567   @param[in]  ParentBlockIo     Parent BlockIo interface
 568   @param[in]  ParentDevicePath  Parent Device Path
 569   @param[in]  DevicePathNode    Child Device Path node
 570   @param[in]  Start             Start Block
 571   @param[in]  End               End Block
 572   @param[in]  BlockSize         Child block size
 573   @param[in]  InstallEspGuid    Flag to install EFI System Partition GUID on handle
 574
 575   @retval EFI_SUCCESS       A child handle was added
 576   @retval other             A child handle was not added
 577
 578 **/
 579 EFI_STATUS
 580 PartitionInstallChildHandle (
 581   IN  EFI_DRIVER_BINDING_PROTOCOL  *This,
 582   IN  EFI_HANDLE                   ParentHandle,
 583   IN  EFI_DISK_IO_PROTOCOL         *ParentDiskIo,
 584   IN  EFI_BLOCK_IO_PROTOCOL        *ParentBlockIo,
 585   IN  EFI_DEVICE_PATH_PROTOCOL     *ParentDevicePath,
 586   IN  EFI_DEVICE_PATH_PROTOCOL     *DevicePathNode,
 587   IN  EFI_LBA                      Start,
 588   IN  EFI_LBA                      End,
 589   IN  UINT32                       BlockSize,
 590   IN  BOOLEAN                      InstallEspGuid
 591   )
 592 {
 593   EFI_STATUS              Status;
 594   PARTITION_PRIVATE_DATA  *Private;
 595
 596   Private = AllocateZeroPool (sizeof (PARTITION_PRIVATE_DATA));
 597   if (Private == NULL) {
 598     return EFI_OUT_OF_RESOURCES;
 599   }
 600
 601   Private->Signature        = PARTITION_PRIVATE_DATA_SIGNATURE;
 602
 603   Private->Start            = MultU64x32 (Start, ParentBlockIo->Media->BlockSize);
 604   Private->End              = MultU64x32 (End + 1, ParentBlockIo->Media->BlockSize);
 605
 606   Private->BlockSize        = BlockSize;
 607   Private->ParentBlockIo    = ParentBlockIo;
 608   Private->DiskIo           = ParentDiskIo;
 609
 610   Private->BlockIo.Revision = EFI_BLOCK_IO_PROTOCOL_REVISION;
 611
 612   Private->BlockIo.Media    = &Private->Media;
 613   CopyMem (Private->BlockIo.Media, ParentBlockIo->Media, sizeof (EFI_BLOCK_IO_MEDIA));
 614   Private->Media.LogicalPartition = TRUE;
 615   Private->Media.LastBlock = DivU64x32 (
 616                                MultU64x32 (
 617                                  End - Start + 1,
 618                                  ParentBlockIo->Media->BlockSize
 619                                  ),
 620                                BlockSize
 621                                ) - 1;
 622
 623   Private->Media.BlockSize      = (UINT32) BlockSize;
 624
 625   Private->BlockIo.Reset        = PartitionReset;
 626   Private->BlockIo.ReadBlocks   = PartitionReadBlocks;
 627   Private->BlockIo.WriteBlocks  = PartitionWriteBlocks;
 628   Private->BlockIo.FlushBlocks  = PartitionFlushBlocks;
 629
 630   Private->DevicePath           = AppendDevicePathNode (ParentDevicePath, DevicePathNode);
 631
 632   if (Private->DevicePath == NULL) {
 633     FreePool (Private);
 634     return EFI_OUT_OF_RESOURCES;
 635   }
 636
 637   if (InstallEspGuid) {
 638     Private->EspGuid = &gEfiPartTypeSystemPartGuid;
 639   } else {
 640     //
 641     // If NULL InstallMultipleProtocolInterfaces will ignore it.
 642     //
 643     Private->EspGuid = NULL;
 644   }
 645   //
 646   // Create the new handle
 647   //
 648   Private->Handle = NULL;
 649   Status = gBS->InstallMultipleProtocolInterfaces (
 650                   &Private->Handle,
 651                   &gEfiDevicePathProtocolGuid,
 652                   Private->DevicePath,
 653                   &gEfiBlockIoProtocolGuid,
 654                   &Private->BlockIo,
 655                   Private->EspGuid,
 656                   NULL,
 657                   NULL
 658                   );
 659
 660   if (!EFI_ERROR (Status)) {
 661     //
 662     // Open the Parent Handle for the child
 663     //
 664     Status = gBS->OpenProtocol (
 665                     ParentHandle,
 666                     &gEfiDiskIoProtocolGuid,
 667                     (VOID **) &ParentDiskIo,
 668                     This->DriverBindingHandle,
 669                     Private->Handle,
 670                     EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
 671                     );
 672   } else {
 673     FreePool (Private->DevicePath);
 674     FreePool (Private);
 675   }
 676
 677   return Status;
 678 }
 679
 680
 681 /**
 682   The user Entry Point for module Partition. The user code starts with this function.
 683
 684   @param[in] ImageHandle    The firmware allocated handle for the EFI image.
 685   @param[in] SystemTable    A pointer to the EFI System Table.
 686
 687   @retval EFI_SUCCESS       The entry point is executed successfully.
 688   @retval other             Some error occurs when executing this entry point.
 689
 690 **/
 691 EFI_STATUS
 692 EFIAPI
 693 InitializePartition (
 694   IN EFI_HANDLE           ImageHandle,
 695   IN EFI_SYSTEM_TABLE     *SystemTable
 696   )
 697 {
 698   EFI_STATUS              Status;
 699
 700   //
 701   // Install driver model protocol(s).
 702   //
 703   Status = EfiLibInstallAllDriverProtocols (
 704              ImageHandle,
 705              SystemTable,
 706              &gPartitionDriverBinding,
 707              ImageHandle,
 708              &gPartitionComponentName,
 709              NULL,
 710              NULL
 711              );
 712   ASSERT_EFI_ERROR (Status);
 713
 714
 715   return Status;
 716 }
 717