MdeModulePkg/Universal/Disk/DiskIoDxe/DiskIo.c

   1 /** @file
   2   DiskIo driver that lays on every BlockIo protocol in the system.
   3   DiskIo converts a block oriented device to a byte oriented device.
   4
   5   Disk access may have to handle unaligned request about sector boundaries.
   6   There are three cases:
   7     UnderRun - The first byte is not on a sector boundary or the read request is
   8                less than a sector in length.
   9     Aligned  - A read of N contiguous sectors.
  10     OverRun  - The last byte is not on a sector boundary.
  11
  12 Copyright (c) 2006 - 2018, Intel Corporation. All rights reserved.<BR>
  13 This program and the accompanying materials
  14 are licensed and made available under the terms and conditions of the BSD License
  15 which accompanies this distribution.  The full text of the license may be found at
  16 http://opensource.org/licenses/bsd-license.php
  17
  18 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  19 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  20
  21 **/
  22
  23 #include "DiskIo.h"
  24
  25 //
  26 // Driver binding protocol implementation for DiskIo driver.
  27 //
  28 EFI_DRIVER_BINDING_PROTOCOL gDiskIoDriverBinding = {
  29   DiskIoDriverBindingSupported,
  30   DiskIoDriverBindingStart,
  31   DiskIoDriverBindingStop,
  32   0xa,
  33   NULL,
  34   NULL
  35 };
  36
  37 //
  38 // Template for DiskIo private data structure.
  39 // The pointer to BlockIo protocol interface is assigned dynamically.
  40 //
  41 DISK_IO_PRIVATE_DATA        gDiskIoPrivateDataTemplate = {
  42   DISK_IO_PRIVATE_DATA_SIGNATURE,
  43   {
  44     EFI_DISK_IO_PROTOCOL_REVISION,
  45     DiskIoReadDisk,
  46     DiskIoWriteDisk
  47   },
  48   {
  49     EFI_DISK_IO2_PROTOCOL_REVISION,
  50     DiskIo2Cancel,
  51     DiskIo2ReadDiskEx,
  52     DiskIo2WriteDiskEx,
  53     DiskIo2FlushDiskEx
  54   }
  55 };
  56
  57 /**
  58   Test to see if this driver supports ControllerHandle.
  59
  60   @param  This                Protocol instance pointer.
  61   @param  ControllerHandle    Handle of device to test
  62   @param  RemainingDevicePath Optional parameter use to pick a specific child
  63                               device to start.
  64
  65   @retval EFI_SUCCESS         This driver supports this device
  66   @retval EFI_ALREADY_STARTED This driver is already running on this device
  67   @retval other               This driver does not support this device
  68
  69 **/
  70 EFI_STATUS
  71 EFIAPI
  72 DiskIoDriverBindingSupported (
  73   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
  74   IN EFI_HANDLE                   ControllerHandle,
  75   IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath OPTIONAL
  76   )
  77 {
  78   EFI_STATUS            Status;
  79   EFI_BLOCK_IO_PROTOCOL *BlockIo;
  80
  81   //
  82   // Open the IO Abstraction(s) needed to perform the supported test.
  83   //
  84   Status = gBS->OpenProtocol (
  85                   ControllerHandle,
  86                   &gEfiBlockIoProtocolGuid,
  87                   (VOID **) &BlockIo,
  88                   This->DriverBindingHandle,
  89                   ControllerHandle,
  90                   EFI_OPEN_PROTOCOL_BY_DRIVER
  91                   );
  92   if (EFI_ERROR (Status)) {
  93     return Status;
  94   }
  95
  96   //
  97   // Close the I/O Abstraction(s) used to perform the supported test.
  98   //
  99   gBS->CloseProtocol (
 100          ControllerHandle,
 101          &gEfiBlockIoProtocolGuid,
 102          This->DriverBindingHandle,
 103          ControllerHandle
 104          );
 105   return EFI_SUCCESS;
 106 }
 107
 108
 109 /**
 110   Start this driver on ControllerHandle by opening a Block IO protocol and
 111   installing a Disk IO protocol on ControllerHandle.
 112
 113   @param  This                 Protocol instance pointer.
 114   @param  ControllerHandle     Handle of device to bind driver to
 115   @param  RemainingDevicePath  Optional parameter use to pick a specific child
 116                                device to start.
 117
 118   @retval EFI_SUCCESS          This driver is added to ControllerHandle
 119   @retval EFI_ALREADY_STARTED  This driver is already running on ControllerHandle
 120   @retval other                This driver does not support this device
 121
 122 **/
 123 EFI_STATUS
 124 EFIAPI
 125 DiskIoDriverBindingStart (
 126   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
 127   IN EFI_HANDLE                   ControllerHandle,
 128   IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath OPTIONAL
 129   )
 130 {
 131   EFI_STATUS            Status;
 132   DISK_IO_PRIVATE_DATA  *Instance;
 133   EFI_TPL               OldTpl;
 134
 135   Instance = NULL;
 136
 137   OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 138
 139   //
 140   // Connect to the Block IO and Block IO2 interface on ControllerHandle.
 141   //
 142   Status = gBS->OpenProtocol (
 143                   ControllerHandle,
 144                   &gEfiBlockIoProtocolGuid,
 145                   (VOID **) &gDiskIoPrivateDataTemplate.BlockIo,
 146                   This->DriverBindingHandle,
 147                   ControllerHandle,
 148                   EFI_OPEN_PROTOCOL_BY_DRIVER
 149                   );
 150   if (EFI_ERROR (Status)) {
 151     goto ErrorExit1;
 152   }
 153
 154   Status = gBS->OpenProtocol (
 155                   ControllerHandle,
 156                   &gEfiBlockIo2ProtocolGuid,
 157                   (VOID **) &gDiskIoPrivateDataTemplate.BlockIo2,
 158                   This->DriverBindingHandle,
 159                   ControllerHandle,
 160                   EFI_OPEN_PROTOCOL_BY_DRIVER
 161                   );
 162   if (EFI_ERROR (Status)) {
 163     gDiskIoPrivateDataTemplate.BlockIo2 = NULL;
 164   }
 165
 166   //
 167   // Initialize the Disk IO device instance.
 168   //
 169   Instance = AllocateCopyPool (sizeof (DISK_IO_PRIVATE_DATA), &gDiskIoPrivateDataTemplate);
 170   if (Instance == NULL) {
 171     Status = EFI_OUT_OF_RESOURCES;
 172     goto ErrorExit;
 173   }
 174
 175   //
 176   // The BlockSize and IoAlign of BlockIo and BlockIo2 should equal.
 177   //
 178   ASSERT ((Instance->BlockIo2 == NULL) ||
 179           ((Instance->BlockIo->Media->IoAlign == Instance->BlockIo2->Media->IoAlign) &&
 180            (Instance->BlockIo->Media->BlockSize == Instance->BlockIo2->Media->BlockSize)
 181           ));
 182
 183   InitializeListHead (&Instance->TaskQueue);
 184   EfiInitializeLock (&Instance->TaskQueueLock, TPL_NOTIFY);
 185   Instance->SharedWorkingBuffer = AllocateAlignedPages (
 186                                     EFI_SIZE_TO_PAGES (PcdGet32 (PcdDiskIoDataBufferBlockNum) * Instance->BlockIo->Media->BlockSize),
 187                                     Instance->BlockIo->Media->IoAlign
 188                                     );
 189   if (Instance->SharedWorkingBuffer == NULL) {
 190     Status = EFI_OUT_OF_RESOURCES;
 191     goto ErrorExit;
 192   }
 193
 194   //
 195   // Install protocol interfaces for the Disk IO device.
 196   //
 197   if (Instance->BlockIo2 != NULL) {
 198     Status = gBS->InstallMultipleProtocolInterfaces (
 199                     &ControllerHandle,
 200                     &gEfiDiskIoProtocolGuid,  &Instance->DiskIo,
 201                     &gEfiDiskIo2ProtocolGuid, &Instance->DiskIo2,
 202                     NULL
 203                     );
 204   } else {
 205     Status = gBS->InstallMultipleProtocolInterfaces (
 206                     &ControllerHandle,
 207                     &gEfiDiskIoProtocolGuid,  &Instance->DiskIo,
 208                     NULL
 209                     );
 210   }
 211
 212 ErrorExit:
 213   if (EFI_ERROR (Status)) {
 214     if (Instance != NULL && Instance->SharedWorkingBuffer != NULL) {
 215       FreeAlignedPages (
 216         Instance->SharedWorkingBuffer,
 217         EFI_SIZE_TO_PAGES (PcdGet32 (PcdDiskIoDataBufferBlockNum) * Instance->BlockIo->Media->BlockSize)
 218         );
 219     }
 220
 221     if (Instance != NULL) {
 222       FreePool (Instance);
 223     }
 224
 225     gBS->CloseProtocol (
 226            ControllerHandle,
 227            &gEfiBlockIoProtocolGuid,
 228            This->DriverBindingHandle,
 229            ControllerHandle
 230            );
 231   }
 232
 233 ErrorExit1:
 234   gBS->RestoreTPL (OldTpl);
 235   return Status;
 236 }
 237
 238 /**
 239   Stop this driver on ControllerHandle by removing Disk IO protocol and closing
 240   the Block IO protocol on ControllerHandle.
 241
 242   @param  This              Protocol instance pointer.
 243   @param  ControllerHandle  Handle of device to stop driver on
 244   @param  NumberOfChildren  Number of Handles in ChildHandleBuffer. If number of
 245                             children is zero stop the entire bus driver.
 246   @param  ChildHandleBuffer List of Child Handles to Stop.
 247
 248   @retval EFI_SUCCESS       This driver is removed ControllerHandle
 249   @retval other             This driver was not removed from this device
 250
 251 **/
 252 EFI_STATUS
 253 EFIAPI
 254 DiskIoDriverBindingStop (
 255   IN  EFI_DRIVER_BINDING_PROTOCOL    *This,
 256   IN  EFI_HANDLE                     ControllerHandle,
 257   IN  UINTN                          NumberOfChildren,
 258   IN  EFI_HANDLE                     *ChildHandleBuffer
 259   )
 260 {
 261   EFI_STATUS            Status;
 262   EFI_DISK_IO_PROTOCOL  *DiskIo;
 263   EFI_DISK_IO2_PROTOCOL *DiskIo2;
 264   DISK_IO_PRIVATE_DATA  *Instance;
 265   BOOLEAN               AllTaskDone;
 266
 267   //
 268   // Get our context back.
 269   //
 270   Status = gBS->OpenProtocol (
 271                   ControllerHandle,
 272                   &gEfiDiskIoProtocolGuid,
 273                   (VOID **) &DiskIo,
 274                   This->DriverBindingHandle,
 275                   ControllerHandle,
 276                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
 277                   );
 278   if (EFI_ERROR (Status)) {
 279     return Status;
 280   }
 281   Status = gBS->OpenProtocol (
 282                   ControllerHandle,
 283                   &gEfiDiskIo2ProtocolGuid,
 284                   (VOID **) &DiskIo2,
 285                   This->DriverBindingHandle,
 286                   ControllerHandle,
 287                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
 288                   );
 289   if (EFI_ERROR (Status)) {
 290     DiskIo2 = NULL;
 291   }
 292
 293   Instance = DISK_IO_PRIVATE_DATA_FROM_DISK_IO (DiskIo);
 294
 295   if (DiskIo2 != NULL) {
 296     //
 297     // Call BlockIo2::Reset() to terminate any in-flight non-blocking I/O requests
 298     //
 299     ASSERT (Instance->BlockIo2 != NULL);
 300     Status = Instance->BlockIo2->Reset (Instance->BlockIo2, FALSE);
 301     if (EFI_ERROR (Status)) {
 302       return Status;
 303     }
 304     Status = gBS->UninstallMultipleProtocolInterfaces (
 305                     ControllerHandle,
 306                     &gEfiDiskIoProtocolGuid,  &Instance->DiskIo,
 307                     &gEfiDiskIo2ProtocolGuid, &Instance->DiskIo2,
 308                     NULL
 309                     );
 310   } else {
 311     Status = gBS->UninstallMultipleProtocolInterfaces (
 312                     ControllerHandle,
 313                     &gEfiDiskIoProtocolGuid,  &Instance->DiskIo,
 314                     NULL
 315                     );
 316   }
 317   if (!EFI_ERROR (Status)) {
 318
 319     do {
 320       EfiAcquireLock (&Instance->TaskQueueLock);
 321       AllTaskDone = IsListEmpty (&Instance->TaskQueue);
 322       EfiReleaseLock (&Instance->TaskQueueLock);
 323     } while (!AllTaskDone);
 324
 325     FreeAlignedPages (
 326       Instance->SharedWorkingBuffer,
 327       EFI_SIZE_TO_PAGES (PcdGet32 (PcdDiskIoDataBufferBlockNum) * Instance->BlockIo->Media->BlockSize)
 328       );
 329
 330     Status = gBS->CloseProtocol (
 331                     ControllerHandle,
 332                     &gEfiBlockIoProtocolGuid,
 333                     This->DriverBindingHandle,
 334                     ControllerHandle
 335                     );
 336     ASSERT_EFI_ERROR (Status);
 337     if (DiskIo2 != NULL) {
 338       Status = gBS->CloseProtocol (
 339                       ControllerHandle,
 340                       &gEfiBlockIo2ProtocolGuid,
 341                       This->DriverBindingHandle,
 342                       ControllerHandle
 343                       );
 344       ASSERT_EFI_ERROR (Status);
 345     }
 346
 347     FreePool (Instance);
 348   }
 349
 350   return Status;
 351 }
 352
 353
 354 /**
 355   Destroy the sub task.
 356
 357   @param Instance     Pointer to the DISK_IO_PRIVATE_DATA.
 358   @param Subtask      Subtask.
 359
 360   @return LIST_ENTRY *  Pointer to the next link of subtask.
 361 **/
 362 LIST_ENTRY *
 363 DiskIoDestroySubtask (
 364   IN DISK_IO_PRIVATE_DATA     *Instance,
 365   IN DISK_IO_SUBTASK          *Subtask
 366   )
 367 {
 368   LIST_ENTRY               *Link;
 369
 370   if (Subtask->Task != NULL) {
 371     EfiAcquireLock (&Subtask->Task->SubtasksLock);
 372   }
 373   Link = RemoveEntryList (&Subtask->Link);
 374   if (Subtask->Task != NULL) {
 375     EfiReleaseLock (&Subtask->Task->SubtasksLock);
 376   }
 377
 378   if (!Subtask->Blocking) {
 379     if (Subtask->WorkingBuffer != NULL) {
 380       FreeAlignedPages (
 381         Subtask->WorkingBuffer,
 382         Subtask->Length < Instance->BlockIo->Media->BlockSize
 383         ? EFI_SIZE_TO_PAGES (Instance->BlockIo->Media->BlockSize)
 384         : EFI_SIZE_TO_PAGES (Subtask->Length)
 385         );
 386     }
 387     if (Subtask->BlockIo2Token.Event != NULL) {
 388       gBS->CloseEvent (Subtask->BlockIo2Token.Event);
 389     }
 390   }
 391   FreePool (Subtask);
 392
 393   return Link;
 394 }
 395
 396 /**
 397   The callback for the BlockIo2 ReadBlocksEx/WriteBlocksEx.
 398   @param  Event                 Event whose notification function is being invoked.
 399   @param  Context               The pointer to the notification function's context,
 400                                 which points to the DISK_IO_SUBTASK instance.
 401 **/
 402 VOID
 403 EFIAPI
 404 DiskIo2OnReadWriteComplete (
 405   IN EFI_EVENT            Event,
 406   IN VOID                 *Context
 407   )
 408 {
 409   DISK_IO_SUBTASK       *Subtask;
 410   DISK_IO2_TASK         *Task;
 411   EFI_STATUS            TransactionStatus;
 412   DISK_IO_PRIVATE_DATA  *Instance;
 413
 414   Subtask           = (DISK_IO_SUBTASK *) Context;
 415   TransactionStatus = Subtask->BlockIo2Token.TransactionStatus;
 416   Task              = Subtask->Task;
 417   Instance          = Task->Instance;
 418
 419   ASSERT (Subtask->Signature  == DISK_IO_SUBTASK_SIGNATURE);
 420   ASSERT (Instance->Signature == DISK_IO_PRIVATE_DATA_SIGNATURE);
 421   ASSERT (Task->Signature     == DISK_IO2_TASK_SIGNATURE);
 422
 423   if ((Subtask->WorkingBuffer != NULL) && !EFI_ERROR (TransactionStatus) &&
 424       (Task->Token != NULL) && !Subtask->Write
 425      ) {
 426     CopyMem (Subtask->Buffer, Subtask->WorkingBuffer + Subtask->Offset, Subtask->Length);
 427   }
 428
 429   DiskIoDestroySubtask (Instance, Subtask);
 430
 431   if (EFI_ERROR (TransactionStatus) || IsListEmpty (&Task->Subtasks)) {
 432     if (Task->Token != NULL) {
 433       //
 434       // Signal error status once the subtask is failed.
 435       // Or signal the last status once the last subtask is finished.
 436       //
 437       Task->Token->TransactionStatus = TransactionStatus;
 438       gBS->SignalEvent (Task->Token->Event);
 439
 440       //
 441       // Mark token to NULL indicating the Task is a dead task.
 442       //
 443       Task->Token = NULL;
 444     }
 445   }
 446 }
 447
 448 /**
 449   Create the subtask.
 450
 451   @param Write         TRUE: Write request; FALSE: Read request.
 452   @param Lba           The starting logical block address to read from on the device.
 453   @param Offset        The starting byte offset to read from the LBA.
 454   @param Length        The number of bytes to read from the device.
 455   @param WorkingBuffer The aligned buffer to hold the data for reading or writing.
 456   @param Buffer        The buffer to hold the data for reading or writing.
 457   @param Blocking      TRUE: Blocking request; FALSE: Non-blocking request.
 458
 459   @return A pointer to the created subtask.
 460 **/
 461 DISK_IO_SUBTASK *
 462 DiskIoCreateSubtask (
 463   IN BOOLEAN          Write,
 464   IN UINT64           Lba,
 465   IN UINT32           Offset,
 466   IN UINTN            Length,
 467   IN VOID             *WorkingBuffer,  OPTIONAL
 468   IN VOID             *Buffer,
 469   IN BOOLEAN          Blocking
 470   )
 471 {
 472   DISK_IO_SUBTASK       *Subtask;
 473   EFI_STATUS            Status;
 474
 475   Subtask = AllocateZeroPool (sizeof (DISK_IO_SUBTASK));
 476   if (Subtask == NULL) {
 477     return NULL;
 478   }
 479   Subtask->Signature     = DISK_IO_SUBTASK_SIGNATURE;
 480   Subtask->Write         = Write;
 481   Subtask->Lba           = Lba;
 482   Subtask->Offset        = Offset;
 483   Subtask->Length        = Length;
 484   Subtask->WorkingBuffer = WorkingBuffer;
 485   Subtask->Buffer        = Buffer;
 486   Subtask->Blocking      = Blocking;
 487   if (!Blocking) {
 488     Status = gBS->CreateEvent (
 489                     EVT_NOTIFY_SIGNAL,
 490                     TPL_NOTIFY,
 491                     DiskIo2OnReadWriteComplete,
 492                     Subtask,
 493                     &Subtask->BlockIo2Token.Event
 494                     );
 495     if (EFI_ERROR (Status)) {
 496       FreePool (Subtask);
 497       return NULL;
 498     }
 499   }
 500   DEBUG ((
 501     EFI_D_BLKIO,
 502     "  %c:Lba/Offset/Length/WorkingBuffer/Buffer = %016lx/%08x/%08x/%08x/%08x\n",
 503     Write ? 'W': 'R', Lba, Offset, Length, WorkingBuffer, Buffer
 504     ));
 505
 506   return Subtask;
 507 }
 508
 509 /**
 510   Create the subtask list.
 511
 512   @param Instance            Pointer to the DISK_IO_PRIVATE_DATA.
 513   @param Write               TRUE: Write request; FALSE: Read request.
 514   @param Offset              The starting byte offset to read from the device.
 515   @param BufferSize          The size in bytes of Buffer. The number of bytes to read from the device.
 516   @param Buffer              A pointer to the buffer for the data.
 517   @param Blocking            TRUE: Blocking request; FALSE: Non-blocking request.
 518   @param SharedWorkingBuffer The aligned buffer to hold the data for reading or writing.
 519   @param Subtasks            The subtask list header.
 520
 521   @retval TRUE  The subtask list is created successfully.
 522   @retval FALSE The subtask list is not created.
 523 **/
 524 BOOLEAN
 525 DiskIoCreateSubtaskList (
 526   IN DISK_IO_PRIVATE_DATA  *Instance,
 527   IN BOOLEAN               Write,
 528   IN UINT64                Offset,
 529   IN UINTN                 BufferSize,
 530   IN VOID                  *Buffer,
 531   IN BOOLEAN               Blocking,
 532   IN VOID                  *SharedWorkingBuffer,
 533   IN OUT LIST_ENTRY        *Subtasks
 534   )
 535 {
 536   UINT32                BlockSize;
 537   UINT32                IoAlign;
 538   UINT64                Lba;
 539   UINT64                OverRunLba;
 540   UINT32                UnderRun;
 541   UINT32                OverRun;
 542   UINT8                 *BufferPtr;
 543   UINTN                 Length;
 544   UINTN                 DataBufferSize;
 545   DISK_IO_SUBTASK       *Subtask;
 546   VOID                  *WorkingBuffer;
 547   LIST_ENTRY            *Link;
 548
 549   DEBUG ((EFI_D_BLKIO, "DiskIo: Create subtasks for task: Offset/BufferSize/Buffer = %016lx/%08x/%08x\n", Offset, BufferSize, Buffer));
 550
 551   BlockSize = Instance->BlockIo->Media->BlockSize;
 552   IoAlign   = Instance->BlockIo->Media->IoAlign;
 553   if (IoAlign == 0) {
 554     IoAlign = 1;
 555   }
 556
 557   Lba       = DivU64x32Remainder (Offset, BlockSize, &UnderRun);
 558   BufferPtr = (UINT8 *) Buffer;
 559
 560   //
 561   // Special handling for zero BufferSize
 562   //
 563   if (BufferSize == 0) {
 564     Subtask = DiskIoCreateSubtask (Write, Lba, UnderRun, 0, NULL, BufferPtr, Blocking);
 565     if (Subtask == NULL) {
 566       goto Done;
 567     }
 568     InsertTailList (Subtasks, &Subtask->Link);
 569     return TRUE;
 570   }
 571
 572   if (UnderRun != 0) {
 573     Length = MIN (BlockSize - UnderRun, BufferSize);
 574     if (Blocking) {
 575       WorkingBuffer = SharedWorkingBuffer;
 576     } else {
 577       WorkingBuffer = AllocateAlignedPages (EFI_SIZE_TO_PAGES (BlockSize), IoAlign);
 578       if (WorkingBuffer == NULL) {
 579         goto Done;
 580       }
 581     }
 582     if (Write) {
 583       //
 584       // A half write operation can be splitted to a blocking block-read and half write operation
 585       // This can simplify the sub task processing logic
 586       //
 587       Subtask = DiskIoCreateSubtask (FALSE, Lba, 0, BlockSize, NULL, WorkingBuffer, TRUE);
 588       if (Subtask == NULL) {
 589         goto Done;
 590       }
 591       InsertTailList (Subtasks, &Subtask->Link);
 592     }
 593
 594     Subtask = DiskIoCreateSubtask (Write, Lba, UnderRun, Length, WorkingBuffer, BufferPtr, Blocking);
 595     if (Subtask == NULL) {
 596       goto Done;
 597     }
 598     InsertTailList (Subtasks, &Subtask->Link);
 599
 600     BufferPtr  += Length;
 601     Offset     += Length;
 602     BufferSize -= Length;
 603     Lba ++;
 604   }
 605
 606   OverRunLba  = Lba + DivU64x32Remainder (BufferSize, BlockSize, &OverRun);
 607   BufferSize -= OverRun;
 608
 609   if (OverRun != 0) {
 610     if (Blocking) {
 611       WorkingBuffer = SharedWorkingBuffer;
 612     } else {
 613       WorkingBuffer = AllocateAlignedPages (EFI_SIZE_TO_PAGES (BlockSize), IoAlign);
 614       if (WorkingBuffer == NULL) {
 615         goto Done;
 616       }
 617     }
 618     if (Write) {
 619       //
 620       // A half write operation can be splitted to a blocking block-read and half write operation
 621       // This can simplify the sub task processing logic
 622       //
 623       Subtask = DiskIoCreateSubtask (FALSE, OverRunLba, 0, BlockSize, NULL, WorkingBuffer, TRUE);
 624       if (Subtask == NULL) {
 625         goto Done;
 626       }
 627       InsertTailList (Subtasks, &Subtask->Link);
 628     }
 629
 630     Subtask = DiskIoCreateSubtask (Write, OverRunLba, 0, OverRun, WorkingBuffer, BufferPtr + BufferSize, Blocking);
 631     if (Subtask == NULL) {
 632       goto Done;
 633     }
 634     InsertTailList (Subtasks, &Subtask->Link);
 635   }
 636
 637   if (OverRunLba > Lba) {
 638     //
 639     // If the DiskIo maps directly to a BlockIo device do the read.
 640     //
 641     if (ALIGN_POINTER (BufferPtr, IoAlign) == BufferPtr) {
 642       Subtask = DiskIoCreateSubtask (Write, Lba, 0, BufferSize, NULL, BufferPtr, Blocking);
 643       if (Subtask == NULL) {
 644         goto Done;
 645       }
 646       InsertTailList (Subtasks, &Subtask->Link);
 647
 648       BufferPtr  += BufferSize;
 649       Offset     += BufferSize;
 650       BufferSize -= BufferSize;
 651
 652     } else {
 653       if (Blocking) {
 654         //
 655         // Use the allocated buffer instead of the original buffer
 656         // to avoid alignment issue.
 657         //
 658         for (; Lba < OverRunLba; Lba += PcdGet32 (PcdDiskIoDataBufferBlockNum)) {
 659           DataBufferSize = MIN (BufferSize, PcdGet32 (PcdDiskIoDataBufferBlockNum) * BlockSize);
 660
 661           Subtask = DiskIoCreateSubtask (Write, Lba, 0, DataBufferSize, SharedWorkingBuffer, BufferPtr, Blocking);
 662           if (Subtask == NULL) {
 663             goto Done;
 664           }
 665           InsertTailList (Subtasks, &Subtask->Link);
 666
 667           BufferPtr  += DataBufferSize;
 668           Offset     += DataBufferSize;
 669           BufferSize -= DataBufferSize;
 670         }
 671       } else {
 672         WorkingBuffer = AllocateAlignedPages (EFI_SIZE_TO_PAGES (BufferSize), IoAlign);
 673         if (WorkingBuffer == NULL) {
 674           //
 675           // If there is not enough memory, downgrade to blocking access
 676           //
 677           DEBUG ((EFI_D_VERBOSE, "DiskIo: No enough memory so downgrade to blocking access\n"));
 678           if (!DiskIoCreateSubtaskList (Instance, Write, Offset, BufferSize, BufferPtr, TRUE, SharedWorkingBuffer, Subtasks)) {
 679             goto Done;
 680           }
 681         } else {
 682           Subtask = DiskIoCreateSubtask (Write, Lba, 0, BufferSize, WorkingBuffer, BufferPtr, Blocking);
 683           if (Subtask == NULL) {
 684             goto Done;
 685           }
 686           InsertTailList (Subtasks, &Subtask->Link);
 687         }
 688
 689         BufferPtr  += BufferSize;
 690         Offset     += BufferSize;
 691         BufferSize -= BufferSize;
 692       }
 693     }
 694   }
 695
 696   ASSERT (BufferSize == 0);
 697
 698   return TRUE;
 699
 700 Done:
 701   //
 702   // Remove all the subtasks.
 703   //
 704   for (Link = GetFirstNode (Subtasks); !IsNull (Subtasks, Link); ) {
 705     Subtask = CR (Link, DISK_IO_SUBTASK, Link, DISK_IO_SUBTASK_SIGNATURE);
 706     Link = DiskIoDestroySubtask (Instance, Subtask);
 707   }
 708   return FALSE;
 709 }
 710
 711 /**
 712   Terminate outstanding asynchronous requests to a device.
 713
 714   @param This                   Indicates a pointer to the calling context.
 715
 716   @retval EFI_SUCCESS           All outstanding requests were successfully terminated.
 717   @retval EFI_DEVICE_ERROR      The device reported an error while performing the cancel
 718                                 operation.
 719 **/
 720 EFI_STATUS
 721 EFIAPI
 722 DiskIo2Cancel (
 723   IN EFI_DISK_IO2_PROTOCOL *This
 724   )
 725 {
 726   DISK_IO_PRIVATE_DATA  *Instance;
 727   DISK_IO2_TASK         *Task;
 728   LIST_ENTRY            *Link;
 729
 730   Instance = DISK_IO_PRIVATE_DATA_FROM_DISK_IO2 (This);
 731
 732   EfiAcquireLock (&Instance->TaskQueueLock);
 733
 734   for (Link = GetFirstNode (&Instance->TaskQueue)
 735     ; !IsNull (&Instance->TaskQueue, Link)
 736     ; Link = GetNextNode (&Instance->TaskQueue, Link)
 737     ) {
 738     Task = CR (Link, DISK_IO2_TASK, Link, DISK_IO2_TASK_SIGNATURE);
 739
 740     if (Task->Token != NULL) {
 741       Task->Token->TransactionStatus = EFI_ABORTED;
 742       gBS->SignalEvent (Task->Token->Event);
 743       //
 744       // Set Token to NULL so that the further BlockIo2 responses will be ignored
 745       //
 746       Task->Token = NULL;
 747     }
 748   }
 749
 750   EfiReleaseLock (&Instance->TaskQueueLock);
 751
 752   return EFI_SUCCESS;
 753 }
 754
 755 /**
 756   Remove the completed tasks from Instance->TaskQueue. Completed tasks are those who don't have any subtasks.
 757
 758   @param Instance    Pointer to the DISK_IO_PRIVATE_DATA.
 759
 760   @retval TRUE       The Instance->TaskQueue is empty after the completed tasks are removed.
 761   @retval FALSE      The Instance->TaskQueue is not empty after the completed tasks are removed.
 762 **/
 763 BOOLEAN
 764 DiskIo2RemoveCompletedTask (
 765   IN DISK_IO_PRIVATE_DATA     *Instance
 766   )
 767 {
 768   BOOLEAN                     QueueEmpty;
 769   LIST_ENTRY                  *Link;
 770   DISK_IO2_TASK               *Task;
 771
 772   QueueEmpty = TRUE;
 773
 774   EfiAcquireLock (&Instance->TaskQueueLock);
 775   for (Link = GetFirstNode (&Instance->TaskQueue); !IsNull (&Instance->TaskQueue, Link); ) {
 776     Task = CR (Link, DISK_IO2_TASK, Link, DISK_IO2_TASK_SIGNATURE);
 777     if (IsListEmpty (&Task->Subtasks)) {
 778       Link = RemoveEntryList (&Task->Link);
 779       ASSERT (Task->Token == NULL);
 780       FreePool (Task);
 781     } else {
 782       Link = GetNextNode (&Instance->TaskQueue, Link);
 783       QueueEmpty = FALSE;
 784     }
 785   }
 786   EfiReleaseLock (&Instance->TaskQueueLock);
 787
 788   return QueueEmpty;
 789 }
 790
 791 /**
 792   Common routine to access the disk.
 793
 794   @param Instance    Pointer to the DISK_IO_PRIVATE_DATA.
 795   @param Write       TRUE: Write operation; FALSE: Read operation.
 796   @param MediaId     ID of the medium to access.
 797   @param Offset      The starting byte offset on the logical block I/O device to access.
 798   @param Token       A pointer to the token associated with the transaction.
 799                      If this field is NULL, synchronous/blocking IO is performed.
 800   @param  BufferSize            The size in bytes of Buffer. The number of bytes to read from the device.
 801   @param  Buffer                A pointer to the destination buffer for the data.
 802                                 The caller is responsible either having implicit or explicit ownership of the buffer.
 803 **/
 804 EFI_STATUS
 805 DiskIo2ReadWriteDisk (
 806   IN DISK_IO_PRIVATE_DATA     *Instance,
 807   IN BOOLEAN                  Write,
 808   IN UINT32                   MediaId,
 809   IN UINT64                   Offset,
 810   IN EFI_DISK_IO2_TOKEN       *Token,
 811   IN UINTN                    BufferSize,
 812   IN UINT8                    *Buffer
 813   )
 814 {
 815   EFI_STATUS             Status;
 816   EFI_BLOCK_IO_PROTOCOL  *BlockIo;
 817   EFI_BLOCK_IO2_PROTOCOL *BlockIo2;
 818   EFI_BLOCK_IO_MEDIA     *Media;
 819   LIST_ENTRY             *Link;
 820   LIST_ENTRY             *NextLink;
 821   LIST_ENTRY             Subtasks;
 822   DISK_IO_SUBTASK        *Subtask;
 823   DISK_IO2_TASK          *Task;
 824   EFI_TPL                OldTpl;
 825   BOOLEAN                Blocking;
 826   BOOLEAN                SubtaskBlocking;
 827   LIST_ENTRY             *SubtasksPtr;
 828
 829   Task      = NULL;
 830   BlockIo   = Instance->BlockIo;
 831   BlockIo2  = Instance->BlockIo2;
 832   Media     = BlockIo->Media;
 833   Status    = EFI_SUCCESS;
 834   Blocking  = (BOOLEAN) ((Token == NULL) || (Token->Event == NULL));
 835
 836   if (Blocking) {
 837     //
 838     // Wait till pending async task is completed.
 839     //
 840     while (!DiskIo2RemoveCompletedTask (Instance));
 841
 842     SubtasksPtr = &Subtasks;
 843   } else {
 844     DiskIo2RemoveCompletedTask (Instance);
 845     Task = AllocatePool (sizeof (DISK_IO2_TASK));
 846     if (Task == NULL) {
 847       return EFI_OUT_OF_RESOURCES;
 848     }
 849
 850     EfiAcquireLock (&Instance->TaskQueueLock);
 851     InsertTailList (&Instance->TaskQueue, &Task->Link);
 852     EfiReleaseLock (&Instance->TaskQueueLock);
 853
 854     Task->Signature = DISK_IO2_TASK_SIGNATURE;
 855     Task->Instance  = Instance;
 856     Task->Token     = Token;
 857     EfiInitializeLock (&Task->SubtasksLock, TPL_NOTIFY);
 858
 859     SubtasksPtr = &Task->Subtasks;
 860   }
 861
 862   InitializeListHead (SubtasksPtr);
 863   if (!DiskIoCreateSubtaskList (Instance, Write, Offset, BufferSize, Buffer, Blocking, Instance->SharedWorkingBuffer, SubtasksPtr)) {
 864     if (Task != NULL) {
 865       FreePool (Task);
 866     }
 867     return EFI_OUT_OF_RESOURCES;
 868   }
 869   ASSERT (!IsListEmpty (SubtasksPtr));
 870
 871   OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 872   for ( Link = GetFirstNode (SubtasksPtr), NextLink = GetNextNode (SubtasksPtr, Link)
 873       ; !IsNull (SubtasksPtr, Link)
 874       ; Link = NextLink, NextLink = GetNextNode (SubtasksPtr, NextLink)
 875       ) {
 876     Subtask         = CR (Link, DISK_IO_SUBTASK, Link, DISK_IO_SUBTASK_SIGNATURE);
 877     Subtask->Task   = Task;
 878     SubtaskBlocking = Subtask->Blocking;
 879
 880     ASSERT ((Subtask->Length % Media->BlockSize == 0) || (Subtask->Length < Media->BlockSize));
 881
 882     if (Subtask->Write) {
 883       //
 884       // Write
 885       //
 886       if (Subtask->WorkingBuffer != NULL) {
 887         //
 888         // A sub task before this one should be a block read operation, causing the WorkingBuffer filled with the entire one block data.
 889         //
 890         CopyMem (Subtask->WorkingBuffer + Subtask->Offset, Subtask->Buffer, Subtask->Length);
 891       }
 892
 893       if (SubtaskBlocking) {
 894         Status = BlockIo->WriteBlocks (
 895                             BlockIo,
 896                             MediaId,
 897                             Subtask->Lba,
 898                             (Subtask->Length % Media->BlockSize == 0) ? Subtask->Length : Media->BlockSize,
 899                             (Subtask->WorkingBuffer != NULL) ? Subtask->WorkingBuffer : Subtask->Buffer
 900                             );
 901       } else {
 902         Status = BlockIo2->WriteBlocksEx (
 903                              BlockIo2,
 904                              MediaId,
 905                              Subtask->Lba,
 906                              &Subtask->BlockIo2Token,
 907                              (Subtask->Length % Media->BlockSize == 0) ? Subtask->Length : Media->BlockSize,
 908                              (Subtask->WorkingBuffer != NULL) ? Subtask->WorkingBuffer : Subtask->Buffer
 909                              );
 910       }
 911
 912     } else {
 913       //
 914       // Read
 915       //
 916       if (SubtaskBlocking) {
 917         Status = BlockIo->ReadBlocks (
 918                             BlockIo,
 919                             MediaId,
 920                             Subtask->Lba,
 921                             (Subtask->Length % Media->BlockSize == 0) ? Subtask->Length : Media->BlockSize,
 922                             (Subtask->WorkingBuffer != NULL) ? Subtask->WorkingBuffer : Subtask->Buffer
 923                             );
 924         if (!EFI_ERROR (Status) && (Subtask->WorkingBuffer != NULL)) {
 925           CopyMem (Subtask->Buffer, Subtask->WorkingBuffer + Subtask->Offset, Subtask->Length);
 926         }
 927       } else {
 928         Status = BlockIo2->ReadBlocksEx (
 929                              BlockIo2,
 930                              MediaId,
 931                              Subtask->Lba,
 932                              &Subtask->BlockIo2Token,
 933                              (Subtask->Length % Media->BlockSize == 0) ? Subtask->Length : Media->BlockSize,
 934                              (Subtask->WorkingBuffer != NULL) ? Subtask->WorkingBuffer : Subtask->Buffer
 935                              );
 936       }
 937     }
 938
 939     if (SubtaskBlocking || EFI_ERROR (Status)) {
 940       //
 941       // Make sure the subtask list only contains non-blocking subtasks.
 942       // Remove failed non-blocking subtasks as well because the callback won't be called.
 943       //
 944       DiskIoDestroySubtask (Instance, Subtask);
 945     }
 946
 947     if (EFI_ERROR (Status)) {
 948       break;
 949     }
 950   }
 951
 952   gBS->RaiseTPL (TPL_NOTIFY);
 953
 954   //
 955   // Remove all the remaining subtasks when failure.
 956   // We shouldn't remove all the tasks because the non-blocking requests have been submitted and cannot be canceled.
 957   //
 958   if (EFI_ERROR (Status)) {
 959     while (!IsNull (SubtasksPtr, NextLink)) {
 960       Subtask = CR (NextLink, DISK_IO_SUBTASK, Link, DISK_IO_SUBTASK_SIGNATURE);
 961       NextLink = DiskIoDestroySubtask (Instance, Subtask);
 962     }
 963   }
 964
 965   //
 966   // It's possible that the non-blocking subtasks finish before raising TPL to NOTIFY,
 967   // so the subtasks list might be empty at this point.
 968   //
 969   if (!Blocking && IsListEmpty (SubtasksPtr)) {
 970     EfiAcquireLock (&Instance->TaskQueueLock);
 971     RemoveEntryList (&Task->Link);
 972     EfiReleaseLock (&Instance->TaskQueueLock);
 973
 974     if (!EFI_ERROR (Status) && (Task->Token != NULL)) {
 975       //
 976       // Task->Token should be set to NULL by the DiskIo2OnReadWriteComplete
 977       // It it's not, that means the non-blocking request was downgraded to blocking request.
 978       //
 979       DEBUG ((EFI_D_VERBOSE, "DiskIo: Non-blocking request was downgraded to blocking request, signal event directly.\n"));
 980       Task->Token->TransactionStatus = Status;
 981       gBS->SignalEvent (Task->Token->Event);
 982     }
 983
 984     FreePool (Task);
 985   }
 986
 987   gBS->RestoreTPL (OldTpl);
 988
 989   return Status;
 990 }
 991
 992 /**
 993   Reads a specified number of bytes from a device.
 994
 995   @param This                   Indicates a pointer to the calling context.
 996   @param MediaId                ID of the medium to be read.
 997   @param Offset                 The starting byte offset on the logical block I/O device to read from.
 998   @param Token                  A pointer to the token associated with the transaction.
 999                                 If this field is NULL, synchronous/blocking IO is performed.
1000   @param  BufferSize            The size in bytes of Buffer. The number of bytes to read from the device.
1001   @param  Buffer                A pointer to the destination buffer for the data.
1002                                 The caller is responsible either having implicit or explicit ownership of the buffer.
1003
1004   @retval EFI_SUCCESS           If Event is NULL (blocking I/O): The data was read correctly from the device.
1005                                 If Event is not NULL (asynchronous I/O): The request was successfully queued for processing.
1006                                                                          Event will be signaled upon completion.
1007   @retval EFI_DEVICE_ERROR      The device reported an error while performing the write.
1008   @retval EFI_NO_MEDIA          There is no medium in the device.
1009   @retval EFI_MEDIA_CHNAGED     The MediaId is not for the current medium.
1010   @retval EFI_INVALID_PARAMETER The read request contains device addresses that are not valid for the device.
1011   @retval EFI_OUT_OF_RESOURCES  The request could not be completed due to a lack of resources.
1012
1013 **/
1014 EFI_STATUS
1015 EFIAPI
1016 DiskIo2ReadDiskEx (
1017   IN EFI_DISK_IO2_PROTOCOL        *This,
1018   IN UINT32                       MediaId,
1019   IN UINT64                       Offset,
1020   IN OUT EFI_DISK_IO2_TOKEN       *Token,
1021   IN UINTN                        BufferSize,
1022   OUT VOID                        *Buffer
1023   )
1024 {
1025   return DiskIo2ReadWriteDisk (
1026            DISK_IO_PRIVATE_DATA_FROM_DISK_IO2 (This),
1027            FALSE, MediaId, Offset, Token, BufferSize, (UINT8 *) Buffer
1028            );
1029 }
1030
1031 /**
1032   Writes a specified number of bytes to a device.
1033
1034   @param This        Indicates a pointer to the calling context.
1035   @param MediaId     ID of the medium to be written.
1036   @param Offset      The starting byte offset on the logical block I/O device to write to.
1037   @param Token       A pointer to the token associated with the transaction.
1038                      If this field is NULL, synchronous/blocking IO is performed.
1039   @param BufferSize  The size in bytes of Buffer. The number of bytes to write to the device.
1040   @param Buffer      A pointer to the buffer containing the data to be written.
1041
1042   @retval EFI_SUCCESS           If Event is NULL (blocking I/O): The data was written correctly to the device.
1043                                 If Event is not NULL (asynchronous I/O): The request was successfully queued for processing.
1044                                                                          Event will be signaled upon completion.
1045   @retval EFI_WRITE_PROTECTED   The device cannot be written to.
1046   @retval EFI_DEVICE_ERROR      The device reported an error while performing the write operation.
1047   @retval EFI_NO_MEDIA          There is no medium in the device.
1048   @retval EFI_MEDIA_CHNAGED     The MediaId is not for the current medium.
1049   @retval EFI_INVALID_PARAMETER The write request contains device addresses that are not valid for the device.
1050   @retval EFI_OUT_OF_RESOURCES  The request could not be completed due to a lack of resources.
1051
1052 **/
1053 EFI_STATUS
1054 EFIAPI
1055 DiskIo2WriteDiskEx (
1056   IN EFI_DISK_IO2_PROTOCOL        *This,
1057   IN UINT32                       MediaId,
1058   IN UINT64                       Offset,
1059   IN OUT EFI_DISK_IO2_TOKEN       *Token,
1060   IN UINTN                        BufferSize,
1061   IN VOID                         *Buffer
1062   )
1063 {
1064   return DiskIo2ReadWriteDisk (
1065            DISK_IO_PRIVATE_DATA_FROM_DISK_IO2 (This),
1066            TRUE, MediaId, Offset, Token, BufferSize, (UINT8 *) Buffer
1067            );
1068 }
1069
1070 /**
1071   The callback for the BlockIo2 FlushBlocksEx.
1072   @param  Event                 Event whose notification function is being invoked.
1073   @param  Context               The pointer to the notification function's context,
1074                                 which points to the DISK_IO2_FLUSH_TASK instance.
1075 **/
1076 VOID
1077 EFIAPI
1078 DiskIo2OnFlushComplete (
1079   IN EFI_EVENT                 Event,
1080   IN VOID                      *Context
1081   )
1082 {
1083   DISK_IO2_FLUSH_TASK             *Task;
1084
1085   gBS->CloseEvent (Event);
1086
1087   Task = (DISK_IO2_FLUSH_TASK *) Context;
1088   ASSERT (Task->Signature == DISK_IO2_FLUSH_TASK_SIGNATURE);
1089   Task->Token->TransactionStatus = Task->BlockIo2Token.TransactionStatus;
1090   gBS->SignalEvent (Task->Token->Event);
1091
1092   FreePool (Task);
1093 }
1094
1095 /**
1096   Flushes all modified data to the physical device.
1097
1098   @param This        Indicates a pointer to the calling context.
1099   @param Token       A pointer to the token associated with the transaction.
1100                      If this field is NULL, synchronous/blocking IO is performed.
1101
1102   @retval EFI_SUCCESS           If Event is NULL (blocking I/O): The data was flushed successfully to the device.
1103                                 If Event is not NULL (asynchronous I/O): The request was successfully queued for processing.
1104                                                                          Event will be signaled upon completion.
1105   @retval EFI_WRITE_PROTECTED   The device cannot be written to.
1106   @retval EFI_DEVICE_ERROR      The device reported an error while performing the write operation.
1107   @retval EFI_NO_MEDIA          There is no medium in the device.
1108   @retval EFI_OUT_OF_RESOURCES  The request could not be completed due to a lack of resources.
1109 **/
1110 EFI_STATUS
1111 EFIAPI
1112 DiskIo2FlushDiskEx (
1113   IN EFI_DISK_IO2_PROTOCOL        *This,
1114   IN OUT EFI_DISK_IO2_TOKEN       *Token
1115   )
1116 {
1117   EFI_STATUS                      Status;
1118   DISK_IO2_FLUSH_TASK             *Task;
1119   DISK_IO_PRIVATE_DATA            *Private;
1120
1121   Private = DISK_IO_PRIVATE_DATA_FROM_DISK_IO2 (This);
1122
1123   if ((Token != NULL) && (Token->Event != NULL)) {
1124     Task = AllocatePool (sizeof (DISK_IO2_FLUSH_TASK));
1125     if (Task == NULL) {
1126       return EFI_OUT_OF_RESOURCES;
1127     }
1128
1129     Status = gBS->CreateEvent (
1130                     EVT_NOTIFY_SIGNAL,
1131                     TPL_CALLBACK,
1132                     DiskIo2OnFlushComplete,
1133                     Task,
1134                     &Task->BlockIo2Token.Event
1135                     );
1136     if (EFI_ERROR (Status)) {
1137       FreePool (Task);
1138       return Status;
1139     }
1140     Task->Signature = DISK_IO2_FLUSH_TASK_SIGNATURE;
1141     Task->Token     = Token;
1142     Status = Private->BlockIo2->FlushBlocksEx (Private->BlockIo2, &Task->BlockIo2Token);
1143     if (EFI_ERROR (Status)) {
1144       gBS->CloseEvent (Task->BlockIo2Token.Event);
1145       FreePool (Task);
1146     }
1147   } else {
1148     Status = Private->BlockIo2->FlushBlocksEx (Private->BlockIo2, NULL);
1149   }
1150
1151   return Status;
1152 }
1153
1154 /**
1155   Read BufferSize bytes from Offset into Buffer.
1156   Reads may support reads that are not aligned on
1157   sector boundaries. There are three cases:
1158     UnderRun - The first byte is not on a sector boundary or the read request is
1159                less than a sector in length.
1160     Aligned  - A read of N contiguous sectors.
1161     OverRun  - The last byte is not on a sector boundary.
1162
1163   @param  This                  Protocol instance pointer.
1164   @param  MediaId               Id of the media, changes every time the media is replaced.
1165   @param  Offset                The starting byte offset to read from
1166   @param  BufferSize            Size of Buffer
1167   @param  Buffer                Buffer containing read data
1168
1169   @retval EFI_SUCCESS           The data was read correctly from the device.
1170   @retval EFI_DEVICE_ERROR      The device reported an error while performing the read.
1171   @retval EFI_NO_MEDIA          There is no media in the device.
1172   @retval EFI_MEDIA_CHNAGED     The MediaId does not matched the current device.
1173   @retval EFI_INVALID_PARAMETER The read request contains device addresses that are not
1174                                 valid for the device.
1175
1176 **/
1177 EFI_STATUS
1178 EFIAPI
1179 DiskIoReadDisk (
1180   IN EFI_DISK_IO_PROTOCOL  *This,
1181   IN UINT32                MediaId,
1182   IN UINT64                Offset,
1183   IN UINTN                 BufferSize,
1184   OUT VOID                 *Buffer
1185   )
1186 {
1187   return DiskIo2ReadWriteDisk (
1188            DISK_IO_PRIVATE_DATA_FROM_DISK_IO (This),
1189            FALSE, MediaId, Offset, NULL, BufferSize, (UINT8 *) Buffer
1190            );
1191 }
1192
1193
1194 /**
1195   Writes BufferSize bytes from Buffer into Offset.
1196   Writes may require a read modify write to support writes that are not
1197   aligned on sector boundaries. There are three cases:
1198     UnderRun - The first byte is not on a sector boundary or the write request
1199                is less than a sector in length. Read modify write is required.
1200     Aligned  - A write of N contiguous sectors.
1201     OverRun  - The last byte is not on a sector boundary. Read modified write
1202                required.
1203
1204   @param  This       Protocol instance pointer.
1205   @param  MediaId    Id of the media, changes every time the media is replaced.
1206   @param  Offset     The starting byte offset to read from
1207   @param  BufferSize Size of Buffer
1208   @param  Buffer     Buffer containing read data
1209
1210   @retval EFI_SUCCESS           The data was written correctly to the device.
1211   @retval EFI_WRITE_PROTECTED   The device can not be written to.
1212   @retval EFI_DEVICE_ERROR      The device reported an error while performing the write.
1213   @retval EFI_NO_MEDIA          There is no media in the device.
1214   @retval EFI_MEDIA_CHNAGED     The MediaId does not matched the current device.
1215   @retval EFI_INVALID_PARAMETER The write request contains device addresses that are not
1216                                  valid for the device.
1217
1218 **/
1219 EFI_STATUS
1220 EFIAPI
1221 DiskIoWriteDisk (
1222   IN EFI_DISK_IO_PROTOCOL  *This,
1223   IN UINT32                MediaId,
1224   IN UINT64                Offset,
1225   IN UINTN                 BufferSize,
1226   IN VOID                  *Buffer
1227   )
1228 {
1229   return DiskIo2ReadWriteDisk (
1230            DISK_IO_PRIVATE_DATA_FROM_DISK_IO (This),
1231            TRUE, MediaId, Offset, NULL, BufferSize, (UINT8 *) Buffer
1232            );
1233 }
1234
1235 /**
1236   The user Entry Point for module DiskIo. The user code starts with this function.
1237
1238   @param[in] ImageHandle    The firmware allocated handle for the EFI image.
1239   @param[in] SystemTable    A pointer to the EFI System Table.
1240
1241   @retval EFI_SUCCESS       The entry point is executed successfully.
1242   @retval other             Some error occurs when executing this entry point.
1243
1244 **/
1245 EFI_STATUS
1246 EFIAPI
1247 InitializeDiskIo (
1248   IN EFI_HANDLE           ImageHandle,
1249   IN EFI_SYSTEM_TABLE     *SystemTable
1250   )
1251 {
1252   EFI_STATUS              Status;
1253
1254   //
1255   // Install driver model protocol(s).
1256   //
1257   Status = EfiLibInstallDriverBindingComponentName2 (
1258              ImageHandle,
1259              SystemTable,
1260              &gDiskIoDriverBinding,
1261              ImageHandle,
1262              &gDiskIoComponentName,
1263              &gDiskIoComponentName2
1264              );
1265   ASSERT_EFI_ERROR (Status);
1266
1267   return Status;
1268 }