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 - 2014, 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 (Media->MediaId != MediaId) {
 837     return EFI_MEDIA_CHANGED;
 838   }
 839
 840   if (Write && Media->ReadOnly) {
 841     return EFI_WRITE_PROTECTED;
 842   }
 843
 844   if (Blocking) {
 845     //
 846     // Wait till pending async task is completed.
 847     //
 848     while (!DiskIo2RemoveCompletedTask (Instance));
 849
 850     SubtasksPtr = &Subtasks;
 851   } else {
 852     DiskIo2RemoveCompletedTask (Instance);
 853     Task = AllocatePool (sizeof (DISK_IO2_TASK));
 854     if (Task == NULL) {
 855       return EFI_OUT_OF_RESOURCES;
 856     }
 857
 858     EfiAcquireLock (&Instance->TaskQueueLock);
 859     InsertTailList (&Instance->TaskQueue, &Task->Link);
 860     EfiReleaseLock (&Instance->TaskQueueLock);
 861
 862     Task->Signature = DISK_IO2_TASK_SIGNATURE;
 863     Task->Instance  = Instance;
 864     Task->Token     = Token;
 865     EfiInitializeLock (&Task->SubtasksLock, TPL_NOTIFY);
 866
 867     SubtasksPtr = &Task->Subtasks;
 868   }
 869
 870   InitializeListHead (SubtasksPtr);
 871   if (!DiskIoCreateSubtaskList (Instance, Write, Offset, BufferSize, Buffer, Blocking, Instance->SharedWorkingBuffer, SubtasksPtr)) {
 872     if (Task != NULL) {
 873       FreePool (Task);
 874     }
 875     return EFI_OUT_OF_RESOURCES;
 876   }
 877   ASSERT (!IsListEmpty (SubtasksPtr));
 878
 879   OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 880   for ( Link = GetFirstNode (SubtasksPtr), NextLink = GetNextNode (SubtasksPtr, Link)
 881       ; !IsNull (SubtasksPtr, Link)
 882       ; Link = NextLink, NextLink = GetNextNode (SubtasksPtr, NextLink)
 883       ) {
 884     Subtask         = CR (Link, DISK_IO_SUBTASK, Link, DISK_IO_SUBTASK_SIGNATURE);
 885     Subtask->Task   = Task;
 886     SubtaskBlocking = Subtask->Blocking;
 887
 888     ASSERT ((Subtask->Length % Media->BlockSize == 0) || (Subtask->Length < Media->BlockSize));
 889
 890     if (Subtask->Write) {
 891       //
 892       // Write
 893       //
 894       if (Subtask->WorkingBuffer != NULL) {
 895         //
 896         // A sub task before this one should be a block read operation, causing the WorkingBuffer filled with the entire one block data.
 897         //
 898         CopyMem (Subtask->WorkingBuffer + Subtask->Offset, Subtask->Buffer, Subtask->Length);
 899       }
 900
 901       if (SubtaskBlocking) {
 902         Status = BlockIo->WriteBlocks (
 903                             BlockIo,
 904                             MediaId,
 905                             Subtask->Lba,
 906                             (Subtask->Length % Media->BlockSize == 0) ? Subtask->Length : Media->BlockSize,
 907                             (Subtask->WorkingBuffer != NULL) ? Subtask->WorkingBuffer : Subtask->Buffer
 908                             );
 909       } else {
 910         Status = BlockIo2->WriteBlocksEx (
 911                              BlockIo2,
 912                              MediaId,
 913                              Subtask->Lba,
 914                              &Subtask->BlockIo2Token,
 915                              (Subtask->Length % Media->BlockSize == 0) ? Subtask->Length : Media->BlockSize,
 916                              (Subtask->WorkingBuffer != NULL) ? Subtask->WorkingBuffer : Subtask->Buffer
 917                              );
 918       }
 919
 920     } else {
 921       //
 922       // Read
 923       //
 924       if (SubtaskBlocking) {
 925         Status = BlockIo->ReadBlocks (
 926                             BlockIo,
 927                             MediaId,
 928                             Subtask->Lba,
 929                             (Subtask->Length % Media->BlockSize == 0) ? Subtask->Length : Media->BlockSize,
 930                             (Subtask->WorkingBuffer != NULL) ? Subtask->WorkingBuffer : Subtask->Buffer
 931                             );
 932         if (!EFI_ERROR (Status) && (Subtask->WorkingBuffer != NULL)) {
 933           CopyMem (Subtask->Buffer, Subtask->WorkingBuffer + Subtask->Offset, Subtask->Length);
 934         }
 935       } else {
 936         Status = BlockIo2->ReadBlocksEx (
 937                              BlockIo2,
 938                              MediaId,
 939                              Subtask->Lba,
 940                              &Subtask->BlockIo2Token,
 941                              (Subtask->Length % Media->BlockSize == 0) ? Subtask->Length : Media->BlockSize,
 942                              (Subtask->WorkingBuffer != NULL) ? Subtask->WorkingBuffer : Subtask->Buffer
 943                              );
 944       }
 945     }
 946
 947     if (SubtaskBlocking || EFI_ERROR (Status)) {
 948       //
 949       // Make sure the subtask list only contains non-blocking subtasks.
 950       // Remove failed non-blocking subtasks as well because the callback won't be called.
 951       //
 952       DiskIoDestroySubtask (Instance, Subtask);
 953     }
 954
 955     if (EFI_ERROR (Status)) {
 956       break;
 957     }
 958   }
 959
 960   gBS->RaiseTPL (TPL_NOTIFY);
 961
 962   //
 963   // Remove all the remaining subtasks when failure.
 964   // We shouldn't remove all the tasks because the non-blocking requests have been submitted and cannot be canceled.
 965   //
 966   if (EFI_ERROR (Status)) {
 967     while (!IsNull (SubtasksPtr, NextLink)) {
 968       Subtask = CR (NextLink, DISK_IO_SUBTASK, Link, DISK_IO_SUBTASK_SIGNATURE);
 969       NextLink = DiskIoDestroySubtask (Instance, Subtask);
 970     }
 971   }
 972
 973   //
 974   // It's possible that the non-blocking subtasks finish before raising TPL to NOTIFY,
 975   // so the subtasks list might be empty at this point.
 976   //
 977   if (!Blocking && IsListEmpty (SubtasksPtr)) {
 978     EfiAcquireLock (&Instance->TaskQueueLock);
 979     RemoveEntryList (&Task->Link);
 980     EfiReleaseLock (&Instance->TaskQueueLock);
 981
 982     if (!EFI_ERROR (Status) && (Task->Token != NULL)) {
 983       //
 984       // Task->Token should be set to NULL by the DiskIo2OnReadWriteComplete
 985       // It it's not, that means the non-blocking request was downgraded to blocking request.
 986       //
 987       DEBUG ((EFI_D_VERBOSE, "DiskIo: Non-blocking request was downgraded to blocking request, signal event directly.\n"));
 988       Task->Token->TransactionStatus = Status;
 989       gBS->SignalEvent (Task->Token->Event);
 990     }
 991
 992     FreePool (Task);
 993   }
 994
 995   gBS->RestoreTPL (OldTpl);
 996
 997   return Status;
 998 }
 999
1000 /**
1001   Reads a specified number of bytes from a device.
1002
1003   @param This                   Indicates a pointer to the calling context.
1004   @param MediaId                ID of the medium to be read.
1005   @param Offset                 The starting byte offset on the logical block I/O device to read from.
1006   @param Token                  A pointer to the token associated with the transaction.
1007                                 If this field is NULL, synchronous/blocking IO is performed.
1008   @param  BufferSize            The size in bytes of Buffer. The number of bytes to read from the device.
1009   @param  Buffer                A pointer to the destination buffer for the data.
1010                                 The caller is responsible either having implicit or explicit ownership of the buffer.
1011
1012   @retval EFI_SUCCESS           If Event is NULL (blocking I/O): The data was read correctly from the device.
1013                                 If Event is not NULL (asynchronous I/O): The request was successfully queued for processing.
1014                                                                          Event will be signaled upon completion.
1015   @retval EFI_DEVICE_ERROR      The device reported an error while performing the write.
1016   @retval EFI_NO_MEDIA          There is no medium in the device.
1017   @retval EFI_MEDIA_CHNAGED     The MediaId is not for the current medium.
1018   @retval EFI_INVALID_PARAMETER The read request contains device addresses that are not valid for the device.
1019   @retval EFI_OUT_OF_RESOURCES  The request could not be completed due to a lack of resources.
1020
1021 **/
1022 EFI_STATUS
1023 EFIAPI
1024 DiskIo2ReadDiskEx (
1025   IN EFI_DISK_IO2_PROTOCOL        *This,
1026   IN UINT32                       MediaId,
1027   IN UINT64                       Offset,
1028   IN OUT EFI_DISK_IO2_TOKEN       *Token,
1029   IN UINTN                        BufferSize,
1030   OUT VOID                        *Buffer
1031   )
1032 {
1033   return DiskIo2ReadWriteDisk (
1034            DISK_IO_PRIVATE_DATA_FROM_DISK_IO2 (This),
1035            FALSE, MediaId, Offset, Token, BufferSize, (UINT8 *) Buffer
1036            );
1037 }
1038
1039 /**
1040   Writes a specified number of bytes to a device.
1041
1042   @param This        Indicates a pointer to the calling context.
1043   @param MediaId     ID of the medium to be written.
1044   @param Offset      The starting byte offset on the logical block I/O device to write to.
1045   @param Token       A pointer to the token associated with the transaction.
1046                      If this field is NULL, synchronous/blocking IO is performed.
1047   @param BufferSize  The size in bytes of Buffer. The number of bytes to write to the device.
1048   @param Buffer      A pointer to the buffer containing the data to be written.
1049
1050   @retval EFI_SUCCESS           If Event is NULL (blocking I/O): The data was written correctly to the device.
1051                                 If Event is not NULL (asynchronous I/O): The request was successfully queued for processing.
1052                                                                          Event will be signaled upon completion.
1053   @retval EFI_WRITE_PROTECTED   The device cannot be written to.
1054   @retval EFI_DEVICE_ERROR      The device reported an error while performing the write operation.
1055   @retval EFI_NO_MEDIA          There is no medium in the device.
1056   @retval EFI_MEDIA_CHNAGED     The MediaId is not for the current medium.
1057   @retval EFI_INVALID_PARAMETER The write request contains device addresses that are not valid for the device.
1058   @retval EFI_OUT_OF_RESOURCES  The request could not be completed due to a lack of resources.
1059
1060 **/
1061 EFI_STATUS
1062 EFIAPI
1063 DiskIo2WriteDiskEx (
1064   IN EFI_DISK_IO2_PROTOCOL        *This,
1065   IN UINT32                       MediaId,
1066   IN UINT64                       Offset,
1067   IN OUT EFI_DISK_IO2_TOKEN       *Token,
1068   IN UINTN                        BufferSize,
1069   IN VOID                         *Buffer
1070   )
1071 {
1072   return DiskIo2ReadWriteDisk (
1073            DISK_IO_PRIVATE_DATA_FROM_DISK_IO2 (This),
1074            TRUE, MediaId, Offset, Token, BufferSize, (UINT8 *) Buffer
1075            );
1076 }
1077
1078 /**
1079   The callback for the BlockIo2 FlushBlocksEx.
1080   @param  Event                 Event whose notification function is being invoked.
1081   @param  Context               The pointer to the notification function's context,
1082                                 which points to the DISK_IO2_FLUSH_TASK instance.
1083 **/
1084 VOID
1085 EFIAPI
1086 DiskIo2OnFlushComplete (
1087   IN EFI_EVENT                 Event,
1088   IN VOID                      *Context
1089   )
1090 {
1091   DISK_IO2_FLUSH_TASK             *Task;
1092
1093   gBS->CloseEvent (Event);
1094
1095   Task = (DISK_IO2_FLUSH_TASK *) Context;
1096   ASSERT (Task->Signature == DISK_IO2_FLUSH_TASK_SIGNATURE);
1097   Task->Token->TransactionStatus = Task->BlockIo2Token.TransactionStatus;
1098   gBS->SignalEvent (Task->Token->Event);
1099
1100   FreePool (Task);
1101 }
1102
1103 /**
1104   Flushes all modified data to the physical device.
1105
1106   @param This        Indicates a pointer to the calling context.
1107   @param Token       A pointer to the token associated with the transaction.
1108                      If this field is NULL, synchronous/blocking IO is performed.
1109
1110   @retval EFI_SUCCESS           If Event is NULL (blocking I/O): The data was flushed successfully to the device.
1111                                 If Event is not NULL (asynchronous I/O): The request was successfully queued for processing.
1112                                                                          Event will be signaled upon completion.
1113   @retval EFI_WRITE_PROTECTED   The device cannot be written to.
1114   @retval EFI_DEVICE_ERROR      The device reported an error while performing the write operation.
1115   @retval EFI_NO_MEDIA          There is no medium in the device.
1116   @retval EFI_OUT_OF_RESOURCES  The request could not be completed due to a lack of resources.
1117 **/
1118 EFI_STATUS
1119 EFIAPI
1120 DiskIo2FlushDiskEx (
1121   IN EFI_DISK_IO2_PROTOCOL        *This,
1122   IN OUT EFI_DISK_IO2_TOKEN       *Token
1123   )
1124 {
1125   EFI_STATUS                      Status;
1126   DISK_IO2_FLUSH_TASK             *Task;
1127   DISK_IO_PRIVATE_DATA            *Private;
1128
1129   Private = DISK_IO_PRIVATE_DATA_FROM_DISK_IO2 (This);
1130
1131   if ((Token != NULL) && (Token->Event != NULL)) {
1132     Task = AllocatePool (sizeof (DISK_IO2_FLUSH_TASK));
1133     if (Task == NULL) {
1134       return EFI_OUT_OF_RESOURCES;
1135     }
1136
1137     Status = gBS->CreateEvent (
1138                     EVT_NOTIFY_SIGNAL,
1139                     TPL_CALLBACK,
1140                     DiskIo2OnFlushComplete,
1141                     Task,
1142                     &Task->BlockIo2Token.Event
1143                     );
1144     if (EFI_ERROR (Status)) {
1145       FreePool (Task);
1146       return Status;
1147     }
1148     Task->Signature = DISK_IO2_FLUSH_TASK_SIGNATURE;
1149     Task->Token     = Token;
1150     Status = Private->BlockIo2->FlushBlocksEx (Private->BlockIo2, &Task->BlockIo2Token);
1151     if (EFI_ERROR (Status)) {
1152       gBS->CloseEvent (Task->BlockIo2Token.Event);
1153       FreePool (Task);
1154     }
1155   } else {
1156     Status = Private->BlockIo2->FlushBlocksEx (Private->BlockIo2, NULL);
1157   }
1158
1159   return Status;
1160 }
1161
1162 /**
1163   Read BufferSize bytes from Offset into Buffer.
1164   Reads may support reads that are not aligned on
1165   sector boundaries. There are three cases:
1166     UnderRun - The first byte is not on a sector boundary or the read request is
1167                less than a sector in length.
1168     Aligned  - A read of N contiguous sectors.
1169     OverRun  - The last byte is not on a sector boundary.
1170
1171   @param  This                  Protocol instance pointer.
1172   @param  MediaId               Id of the media, changes every time the media is replaced.
1173   @param  Offset                The starting byte offset to read from
1174   @param  BufferSize            Size of Buffer
1175   @param  Buffer                Buffer containing read data
1176
1177   @retval EFI_SUCCESS           The data was read correctly from the device.
1178   @retval EFI_DEVICE_ERROR      The device reported an error while performing the read.
1179   @retval EFI_NO_MEDIA          There is no media in the device.
1180   @retval EFI_MEDIA_CHNAGED     The MediaId does not matched the current device.
1181   @retval EFI_INVALID_PARAMETER The read request contains device addresses that are not
1182                                 valid for the device.
1183
1184 **/
1185 EFI_STATUS
1186 EFIAPI
1187 DiskIoReadDisk (
1188   IN EFI_DISK_IO_PROTOCOL  *This,
1189   IN UINT32                MediaId,
1190   IN UINT64                Offset,
1191   IN UINTN                 BufferSize,
1192   OUT VOID                 *Buffer
1193   )
1194 {
1195   return DiskIo2ReadWriteDisk (
1196            DISK_IO_PRIVATE_DATA_FROM_DISK_IO (This),
1197            FALSE, MediaId, Offset, NULL, BufferSize, (UINT8 *) Buffer
1198            );
1199 }
1200
1201
1202 /**
1203   Writes BufferSize bytes from Buffer into Offset.
1204   Writes may require a read modify write to support writes that are not
1205   aligned on sector boundaries. There are three cases:
1206     UnderRun - The first byte is not on a sector boundary or the write request
1207                is less than a sector in length. Read modify write is required.
1208     Aligned  - A write of N contiguous sectors.
1209     OverRun  - The last byte is not on a sector boundary. Read modified write
1210                required.
1211
1212   @param  This       Protocol instance pointer.
1213   @param  MediaId    Id of the media, changes every time the media is replaced.
1214   @param  Offset     The starting byte offset to read from
1215   @param  BufferSize Size of Buffer
1216   @param  Buffer     Buffer containing read data
1217
1218   @retval EFI_SUCCESS           The data was written correctly to the device.
1219   @retval EFI_WRITE_PROTECTED   The device can not be written to.
1220   @retval EFI_DEVICE_ERROR      The device reported an error while performing the write.
1221   @retval EFI_NO_MEDIA          There is no media in the device.
1222   @retval EFI_MEDIA_CHNAGED     The MediaId does not matched the current device.
1223   @retval EFI_INVALID_PARAMETER The write request contains device addresses that are not
1224                                  valid for the device.
1225
1226 **/
1227 EFI_STATUS
1228 EFIAPI
1229 DiskIoWriteDisk (
1230   IN EFI_DISK_IO_PROTOCOL  *This,
1231   IN UINT32                MediaId,
1232   IN UINT64                Offset,
1233   IN UINTN                 BufferSize,
1234   IN VOID                  *Buffer
1235   )
1236 {
1237   return DiskIo2ReadWriteDisk (
1238            DISK_IO_PRIVATE_DATA_FROM_DISK_IO (This),
1239            TRUE, MediaId, Offset, NULL, BufferSize, (UINT8 *) Buffer
1240            );
1241 }
1242
1243 /**
1244   The user Entry Point for module DiskIo. The user code starts with this function.
1245
1246   @param[in] ImageHandle    The firmware allocated handle for the EFI image.
1247   @param[in] SystemTable    A pointer to the EFI System Table.
1248
1249   @retval EFI_SUCCESS       The entry point is executed successfully.
1250   @retval other             Some error occurs when executing this entry point.
1251
1252 **/
1253 EFI_STATUS
1254 EFIAPI
1255 InitializeDiskIo (
1256   IN EFI_HANDLE           ImageHandle,
1257   IN EFI_SYSTEM_TABLE     *SystemTable
1258   )
1259 {
1260   EFI_STATUS              Status;
1261
1262   //
1263   // Install driver model protocol(s).
1264   //
1265   Status = EfiLibInstallDriverBindingComponentName2 (
1266              ImageHandle,
1267              SystemTable,
1268              &gDiskIoDriverBinding,
1269              ImageHandle,
1270              &gDiskIoComponentName,
1271              &gDiskIoComponentName2
1272              );
1273   ASSERT_EFI_ERROR (Status);
1274
1275   return Status;
1276 }