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 - 2013, 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 (DATA_BUFFER_BLOCK_NUM * 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 (DATA_BUFFER_BLOCK_NUM * 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 (DATA_BUFFER_BLOCK_NUM * 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   Link = RemoveEntryList (&Subtask->Link);
 370   if (!Subtask->Blocking) {
 371     if (Subtask->WorkingBuffer != NULL) {
 372       FreeAlignedPages (
 373         Subtask->WorkingBuffer,
 374         Subtask->Length < Instance->BlockIo->Media->BlockSize
 375         ? EFI_SIZE_TO_PAGES (Instance->BlockIo->Media->BlockSize)
 376         : EFI_SIZE_TO_PAGES (Subtask->Length)
 377         );
 378     }
 379     if (Subtask->BlockIo2Token.Event != NULL) {
 380       gBS->CloseEvent (Subtask->BlockIo2Token.Event);
 381     }
 382   }
 383   FreePool (Subtask);
 384
 385   return Link;
 386 }
 387
 388 /**
 389   The callback for the BlockIo2 ReadBlocksEx/WriteBlocksEx.
 390   @param  Event                 Event whose notification function is being invoked.
 391   @param  Context               The pointer to the notification function's context,
 392                                 which points to the DISK_IO_SUBTASK instance.
 393 **/
 394 VOID
 395 EFIAPI
 396 DiskIo2OnReadWriteComplete (
 397   IN EFI_EVENT            Event,
 398   IN VOID                 *Context
 399   )
 400 {
 401   DISK_IO_SUBTASK       *Subtask;
 402   DISK_IO2_TASK         *Task;
 403   EFI_STATUS            TransactionStatus;
 404   DISK_IO_PRIVATE_DATA  *Instance;
 405
 406   Subtask           = (DISK_IO_SUBTASK *) Context;
 407   TransactionStatus = Subtask->BlockIo2Token.TransactionStatus;
 408   Task              = Subtask->Task;
 409   Instance          = Task->Instance;
 410
 411   ASSERT (Subtask->Signature  == DISK_IO_SUBTASK_SIGNATURE);
 412   ASSERT (Instance->Signature == DISK_IO_PRIVATE_DATA_SIGNATURE);
 413   ASSERT (Task->Signature     == DISK_IO2_TASK_SIGNATURE);
 414
 415   if ((Subtask->WorkingBuffer != NULL) && !EFI_ERROR (TransactionStatus) &&
 416       (Task->Token != NULL) && !Subtask->Write
 417      ) {
 418     CopyMem (Subtask->Buffer, Subtask->WorkingBuffer + Subtask->Offset, Subtask->Length);
 419   }
 420
 421   DiskIoDestroySubtask (Instance, Subtask);
 422
 423   if (EFI_ERROR (TransactionStatus) || IsListEmpty (&Task->Subtasks)) {
 424     if (Task->Token != NULL) {
 425       //
 426       // Signal error status once the subtask is failed.
 427       // Or signal the last status once the last subtask is finished.
 428       //
 429       Task->Token->TransactionStatus = TransactionStatus;
 430       gBS->SignalEvent (Task->Token->Event);
 431
 432       //
 433       // Mark token to NULL
 434       //
 435       Task->Token = NULL;
 436     }
 437   }
 438
 439   if (IsListEmpty (&Task->Subtasks)) {
 440     EfiAcquireLock (&Instance->TaskQueueLock);
 441     RemoveEntryList (&Task->Link);
 442     EfiReleaseLock (&Instance->TaskQueueLock);
 443
 444     FreePool (Task);
 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 += DATA_BUFFER_BLOCK_NUM) {
 659           DataBufferSize = MIN (BufferSize, DATA_BUFFER_BLOCK_NUM * 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   Common routine to access the disk.
 757
 758   @param Instance    Pointer to the DISK_IO_PRIVATE_DATA.
 759   @param Write       TRUE: Write operation; FALSE: Read operation.
 760   @param MediaId     ID of the medium to access.
 761   @param Offset      The starting byte offset on the logical block I/O device to access.
 762   @param Token       A pointer to the token associated with the transaction.
 763                      If this field is NULL, synchronous/blocking IO is performed.
 764   @param  BufferSize            The size in bytes of Buffer. The number of bytes to read from the device.
 765   @param  Buffer                A pointer to the destination buffer for the data.
 766                                 The caller is responsible either having implicit or explicit ownership of the buffer.
 767 **/
 768 EFI_STATUS
 769 DiskIo2ReadWriteDisk (
 770   IN DISK_IO_PRIVATE_DATA     *Instance,
 771   IN BOOLEAN                  Write,
 772   IN UINT32                   MediaId,
 773   IN UINT64                   Offset,
 774   IN EFI_DISK_IO2_TOKEN       *Token,
 775   IN UINTN                    BufferSize,
 776   IN UINT8                    *Buffer
 777   )
 778 {
 779   EFI_STATUS             Status;
 780   EFI_BLOCK_IO_PROTOCOL  *BlockIo;
 781   EFI_BLOCK_IO2_PROTOCOL *BlockIo2;
 782   EFI_BLOCK_IO_MEDIA     *Media;
 783   LIST_ENTRY             *Link;
 784   LIST_ENTRY             Subtasks;
 785   DISK_IO_SUBTASK        *Subtask;
 786   DISK_IO2_TASK          *Task;
 787   BOOLEAN                TaskQueueEmpty;
 788   EFI_TPL                OldTpl;
 789   BOOLEAN                Blocking;
 790   LIST_ENTRY             *SubtasksPtr;
 791
 792   Task      = NULL;
 793   BlockIo   = Instance->BlockIo;
 794   BlockIo2  = Instance->BlockIo2;
 795   Media     = BlockIo->Media;
 796   Status    = EFI_SUCCESS;
 797   Blocking  = (BOOLEAN) ((Token == NULL) || (Token->Event == NULL));
 798
 799   if (Media->MediaId != MediaId) {
 800     return EFI_MEDIA_CHANGED;
 801   }
 802
 803   if (Write && Media->ReadOnly) {
 804     return EFI_WRITE_PROTECTED;
 805   }
 806
 807   if (Blocking) {
 808     //
 809     // Wait till pending async task is completed.
 810     //
 811     do {
 812       EfiAcquireLock (&Instance->TaskQueueLock);
 813       TaskQueueEmpty = IsListEmpty (&Instance->TaskQueue);
 814       EfiReleaseLock (&Instance->TaskQueueLock);
 815     } while (!TaskQueueEmpty);
 816
 817     SubtasksPtr = &Subtasks;
 818   } else {
 819     Task = AllocatePool (sizeof (DISK_IO2_TASK));
 820     if (Task == NULL) {
 821       return EFI_OUT_OF_RESOURCES;
 822     }
 823
 824     EfiAcquireLock (&Instance->TaskQueueLock);
 825     InsertTailList (&Instance->TaskQueue, &Task->Link);
 826     EfiReleaseLock (&Instance->TaskQueueLock);
 827
 828     Task->Signature = DISK_IO2_TASK_SIGNATURE;
 829     Task->Instance  = Instance;
 830     Task->Token     = Token;
 831
 832     SubtasksPtr = &Task->Subtasks;
 833   }
 834
 835   InitializeListHead (SubtasksPtr);
 836   if (!DiskIoCreateSubtaskList (Instance, Write, Offset, BufferSize, Buffer, Blocking, Instance->SharedWorkingBuffer, SubtasksPtr)) {
 837     if (Task != NULL) {
 838       FreePool (Task);
 839     }
 840     return EFI_OUT_OF_RESOURCES;
 841   }
 842   ASSERT (!IsListEmpty (SubtasksPtr));
 843
 844   OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 845   for (Link = GetFirstNode (SubtasksPtr); !IsNull (SubtasksPtr, Link); Link = GetNextNode (SubtasksPtr, Link)) {
 846     Subtask = CR (Link, DISK_IO_SUBTASK, Link, DISK_IO_SUBTASK_SIGNATURE);
 847
 848     if (!Subtask->Blocking) {
 849       Subtask->Task = Task;
 850     }
 851
 852     if (Subtask->Write) {
 853       //
 854       // Write
 855       //
 856       if (Subtask->WorkingBuffer != NULL) {
 857         //
 858         // A sub task before this one should be a block read operation, causing the WorkingBuffer filled with the entire one block data.
 859         //
 860         CopyMem (Subtask->WorkingBuffer + Subtask->Offset, Subtask->Buffer, Subtask->Length);
 861       }
 862
 863       if (Subtask->Blocking) {
 864         Status = BlockIo->WriteBlocks (
 865                             BlockIo,
 866                             MediaId,
 867                             Subtask->Lba,
 868                             Subtask->Length < Media->BlockSize ? Media->BlockSize : Subtask->Length,
 869                             (Subtask->WorkingBuffer != NULL) ? Subtask->WorkingBuffer : Subtask->Buffer
 870                             );
 871       } else {
 872         Status = BlockIo2->WriteBlocksEx (
 873                              BlockIo2,
 874                              MediaId,
 875                              Subtask->Lba,
 876                              &Subtask->BlockIo2Token,
 877                              Subtask->Length < Media->BlockSize ? Media->BlockSize : Subtask->Length,
 878                              (Subtask->WorkingBuffer != NULL) ? Subtask->WorkingBuffer : Subtask->Buffer
 879                              );
 880       }
 881
 882     } else {
 883       //
 884       // Read
 885       //
 886       if (Subtask->Blocking) {
 887         Status = BlockIo->ReadBlocks (
 888                             BlockIo,
 889                             MediaId,
 890                             Subtask->Lba,
 891                             Subtask->Length < Media->BlockSize ? Media->BlockSize : Subtask->Length,
 892                             (Subtask->WorkingBuffer != NULL) ? Subtask->WorkingBuffer : Subtask->Buffer
 893                             );
 894         if (!EFI_ERROR (Status) && (Subtask->WorkingBuffer != NULL)) {
 895           CopyMem (Subtask->Buffer, Subtask->WorkingBuffer + Subtask->Offset, Subtask->Length);
 896         }
 897       } else {
 898         Status = BlockIo2->ReadBlocksEx (
 899                              BlockIo2,
 900                              MediaId,
 901                              Subtask->Lba,
 902                              &Subtask->BlockIo2Token,
 903                              Subtask->Length < Media->BlockSize ? Media->BlockSize : Subtask->Length,
 904                              (Subtask->WorkingBuffer != NULL) ? Subtask->WorkingBuffer : Subtask->Buffer
 905                              );
 906       }
 907     }
 908
 909     if (EFI_ERROR (Status)) {
 910       break;
 911     }
 912   }
 913
 914   gBS->RaiseTPL (TPL_NOTIFY);
 915
 916   //
 917   // Remove all the remaining subtasks when failure.
 918   // We shouldn't remove all the tasks because the non-blocking requests have been submitted and cannot be canceled.
 919   //
 920   if (EFI_ERROR (Status)) {
 921     while (!IsNull (SubtasksPtr, Link)) {
 922       Subtask = CR (Link, DISK_IO_SUBTASK, Link, DISK_IO_SUBTASK_SIGNATURE);
 923       Link = DiskIoDestroySubtask (Instance, Subtask);
 924     }
 925   }
 926
 927   //
 928   // Remove all the blocking subtasks because the non-blocking callback only removes the non-blocking subtask.
 929   //
 930   for (Link = GetFirstNode (SubtasksPtr); !IsNull (SubtasksPtr, Link); ) {
 931     Subtask = CR (Link, DISK_IO_SUBTASK, Link, DISK_IO_SUBTASK_SIGNATURE);
 932     if (Subtask->Blocking) {
 933       Link = DiskIoDestroySubtask (Instance, Subtask);
 934     } else {
 935       Link = GetNextNode (SubtasksPtr, Link);
 936     }
 937   }
 938
 939   //
 940   // It's possible that the callback runs before raising TPL to NOTIFY,
 941   // so the subtasks list only contains blocking subtask.
 942   // Remove the Task after the blocking subtasks are removed in above.
 943   //
 944   if (!Blocking && IsListEmpty (SubtasksPtr)) {
 945     EfiAcquireLock (&Instance->TaskQueueLock);
 946     RemoveEntryList (&Task->Link);
 947     EfiReleaseLock (&Instance->TaskQueueLock);
 948
 949     if (!EFI_ERROR (Status) && (Task->Token != NULL)) {
 950       //
 951       // Task->Token should be set to NULL by the DiskIo2OnReadWriteComplete
 952       // It it's not, that means the non-blocking request was downgraded to blocking request.
 953       //
 954       DEBUG ((EFI_D_VERBOSE, "DiskIo: Non-blocking request was downgraded to blocking request, signal event directly.\n"));
 955       Task->Token->TransactionStatus = Status;
 956       gBS->SignalEvent (Task->Token->Event);
 957     }
 958
 959     FreePool (Task);
 960   }
 961
 962   gBS->RestoreTPL (OldTpl);
 963
 964   return Status;
 965 }
 966
 967 /**
 968   Reads a specified number of bytes from a device.
 969
 970   @param This                   Indicates a pointer to the calling context.
 971   @param MediaId                ID of the medium to be read.
 972   @param Offset                 The starting byte offset on the logical block I/O device to read from.
 973   @param Token                  A pointer to the token associated with the transaction.
 974                                 If this field is NULL, synchronous/blocking IO is performed.
 975   @param  BufferSize            The size in bytes of Buffer. The number of bytes to read from the device.
 976   @param  Buffer                A pointer to the destination buffer for the data.
 977                                 The caller is responsible either having implicit or explicit ownership of the buffer.
 978
 979   @retval EFI_SUCCESS           If Event is NULL (blocking I/O): The data was read correctly from the device.
 980                                 If Event is not NULL (asynchronous I/O): The request was successfully queued for processing.
 981                                                                          Event will be signaled upon completion.
 982   @retval EFI_DEVICE_ERROR      The device reported an error while performing the write.
 983   @retval EFI_NO_MEDIA          There is no medium in the device.
 984   @retval EFI_MEDIA_CHNAGED     The MediaId is not for the current medium.
 985   @retval EFI_INVALID_PARAMETER The read request contains device addresses that are not valid for the device.
 986   @retval EFI_OUT_OF_RESOURCES  The request could not be completed due to a lack of resources.
 987
 988 **/
 989 EFI_STATUS
 990 EFIAPI
 991 DiskIo2ReadDiskEx (
 992   IN EFI_DISK_IO2_PROTOCOL        *This,
 993   IN UINT32                       MediaId,
 994   IN UINT64                       Offset,
 995   IN OUT EFI_DISK_IO2_TOKEN       *Token,
 996   IN UINTN                        BufferSize,
 997   OUT VOID                        *Buffer
 998   )
 999 {
1000   return DiskIo2ReadWriteDisk (
1001            DISK_IO_PRIVATE_DATA_FROM_DISK_IO2 (This),
1002            FALSE, MediaId, Offset, Token, BufferSize, (UINT8 *) Buffer
1003            );
1004 }
1005
1006 /**
1007   Writes a specified number of bytes to a device.
1008
1009   @param This        Indicates a pointer to the calling context.
1010   @param MediaId     ID of the medium to be written.
1011   @param Offset      The starting byte offset on the logical block I/O device to write to.
1012   @param Token       A pointer to the token associated with the transaction.
1013                      If this field is NULL, synchronous/blocking IO is performed.
1014   @param BufferSize  The size in bytes of Buffer. The number of bytes to write to the device.
1015   @param Buffer      A pointer to the buffer containing the data to be written.
1016
1017   @retval EFI_SUCCESS           If Event is NULL (blocking I/O): The data was written correctly to the device.
1018                                 If Event is not NULL (asynchronous I/O): The request was successfully queued for processing.
1019                                                                          Event will be signaled upon completion.
1020   @retval EFI_WRITE_PROTECTED   The device cannot be written to.
1021   @retval EFI_DEVICE_ERROR      The device reported an error while performing the write operation.
1022   @retval EFI_NO_MEDIA          There is no medium in the device.
1023   @retval EFI_MEDIA_CHNAGED     The MediaId is not for the current medium.
1024   @retval EFI_INVALID_PARAMETER The write request contains device addresses that are not valid for the device.
1025   @retval EFI_OUT_OF_RESOURCES  The request could not be completed due to a lack of resources.
1026
1027 **/
1028 EFI_STATUS
1029 EFIAPI
1030 DiskIo2WriteDiskEx (
1031   IN EFI_DISK_IO2_PROTOCOL        *This,
1032   IN UINT32                       MediaId,
1033   IN UINT64                       Offset,
1034   IN OUT EFI_DISK_IO2_TOKEN       *Token,
1035   IN UINTN                        BufferSize,
1036   IN VOID                         *Buffer
1037   )
1038 {
1039   return DiskIo2ReadWriteDisk (
1040            DISK_IO_PRIVATE_DATA_FROM_DISK_IO2 (This),
1041            TRUE, MediaId, Offset, Token, BufferSize, (UINT8 *) Buffer
1042            );
1043 }
1044
1045 /**
1046   The callback for the BlockIo2 FlushBlocksEx.
1047   @param  Event                 Event whose notification function is being invoked.
1048   @param  Context               The pointer to the notification function's context,
1049                                 which points to the DISK_IO2_FLUSH_TASK instance.
1050 **/
1051 VOID
1052 EFIAPI
1053 DiskIo2OnFlushComplete (
1054   IN EFI_EVENT                 Event,
1055   IN VOID                      *Context
1056   )
1057 {
1058   DISK_IO2_FLUSH_TASK             *Task;
1059
1060   gBS->CloseEvent (Event);
1061
1062   Task = (DISK_IO2_FLUSH_TASK *) Context;
1063   ASSERT (Task->Signature == DISK_IO2_FLUSH_TASK_SIGNATURE);
1064   Task->Token->TransactionStatus = Task->BlockIo2Token.TransactionStatus;
1065   gBS->SignalEvent (Task->Token->Event);
1066 }
1067
1068 /**
1069   Flushes all modified data to the physical device.
1070
1071   @param This        Indicates a pointer to the calling context.
1072   @param Token       A pointer to the token associated with the transaction.
1073                      If this field is NULL, synchronous/blocking IO is performed.
1074
1075   @retval EFI_SUCCESS           If Event is NULL (blocking I/O): The data was flushed successfully to the device.
1076                                 If Event is not NULL (asynchronous I/O): The request was successfully queued for processing.
1077                                                                          Event will be signaled upon completion.
1078   @retval EFI_WRITE_PROTECTED   The device cannot be written to.
1079   @retval EFI_DEVICE_ERROR      The device reported an error while performing the write operation.
1080   @retval EFI_NO_MEDIA          There is no medium in the device.
1081   @retval EFI_OUT_OF_RESOURCES  The request could not be completed due to a lack of resources.
1082 **/
1083 EFI_STATUS
1084 EFIAPI
1085 DiskIo2FlushDiskEx (
1086   IN EFI_DISK_IO2_PROTOCOL        *This,
1087   IN OUT EFI_DISK_IO2_TOKEN       *Token
1088   )
1089 {
1090   EFI_STATUS                      Status;
1091   DISK_IO2_FLUSH_TASK             *Task;
1092   DISK_IO_PRIVATE_DATA            *Private;
1093
1094   Private = DISK_IO_PRIVATE_DATA_FROM_DISK_IO2 (This);
1095
1096   if ((Token != NULL) && (Token->Event != NULL)) {
1097     Task = AllocatePool (sizeof (DISK_IO2_FLUSH_TASK));
1098     if (Task == NULL) {
1099       return EFI_OUT_OF_RESOURCES;
1100     }
1101
1102     Status = gBS->CreateEvent (
1103                     EVT_NOTIFY_SIGNAL,
1104                     TPL_CALLBACK,
1105                     DiskIo2OnFlushComplete,
1106                     Task,
1107                     &Task->BlockIo2Token.Event
1108                     );
1109     if (EFI_ERROR (Status)) {
1110       FreePool (Task);
1111       return Status;
1112     }
1113     Task->Signature = DISK_IO2_FLUSH_TASK_SIGNATURE;
1114     Task->Token     = Token;
1115     Status = Private->BlockIo2->FlushBlocksEx (Private->BlockIo2, &Task->BlockIo2Token);
1116     if (EFI_ERROR (Status)) {
1117       gBS->CloseEvent (Task->BlockIo2Token.Event);
1118       FreePool (Task);
1119     }
1120   } else {
1121     Status = Private->BlockIo2->FlushBlocksEx (Private->BlockIo2, NULL);
1122   }
1123
1124   return Status;
1125 }
1126
1127 /**
1128   Read BufferSize bytes from Offset into Buffer.
1129   Reads may support reads that are not aligned on
1130   sector boundaries. There are three cases:
1131     UnderRun - The first byte is not on a sector boundary or the read request is
1132                less than a sector in length.
1133     Aligned  - A read of N contiguous sectors.
1134     OverRun  - The last byte is not on a sector boundary.
1135
1136   @param  This                  Protocol instance pointer.
1137   @param  MediaId               Id of the media, changes every time the media is replaced.
1138   @param  Offset                The starting byte offset to read from
1139   @param  BufferSize            Size of Buffer
1140   @param  Buffer                Buffer containing read data
1141
1142   @retval EFI_SUCCESS           The data was read correctly from the device.
1143   @retval EFI_DEVICE_ERROR      The device reported an error while performing the read.
1144   @retval EFI_NO_MEDIA          There is no media in the device.
1145   @retval EFI_MEDIA_CHNAGED     The MediaId does not matched the current device.
1146   @retval EFI_INVALID_PARAMETER The read request contains device addresses that are not
1147                                 valid for the device.
1148
1149 **/
1150 EFI_STATUS
1151 EFIAPI
1152 DiskIoReadDisk (
1153   IN EFI_DISK_IO_PROTOCOL  *This,
1154   IN UINT32                MediaId,
1155   IN UINT64                Offset,
1156   IN UINTN                 BufferSize,
1157   OUT VOID                 *Buffer
1158   )
1159 {
1160   return DiskIo2ReadWriteDisk (
1161            DISK_IO_PRIVATE_DATA_FROM_DISK_IO (This),
1162            FALSE, MediaId, Offset, NULL, BufferSize, (UINT8 *) Buffer
1163            );
1164 }
1165
1166
1167 /**
1168   Writes BufferSize bytes from Buffer into Offset.
1169   Writes may require a read modify write to support writes that are not
1170   aligned on sector boundaries. There are three cases:
1171     UnderRun - The first byte is not on a sector boundary or the write request
1172                is less than a sector in length. Read modify write is required.
1173     Aligned  - A write of N contiguous sectors.
1174     OverRun  - The last byte is not on a sector boundary. Read modified write
1175                required.
1176
1177   @param  This       Protocol instance pointer.
1178   @param  MediaId    Id of the media, changes every time the media is replaced.
1179   @param  Offset     The starting byte offset to read from
1180   @param  BufferSize Size of Buffer
1181   @param  Buffer     Buffer containing read data
1182
1183   @retval EFI_SUCCESS           The data was written correctly to the device.
1184   @retval EFI_WRITE_PROTECTED   The device can not be written to.
1185   @retval EFI_DEVICE_ERROR      The device reported an error while performing the write.
1186   @retval EFI_NO_MEDIA          There is no media in the device.
1187   @retval EFI_MEDIA_CHNAGED     The MediaId does not matched the current device.
1188   @retval EFI_INVALID_PARAMETER The write request contains device addresses that are not
1189                                  valid for the device.
1190
1191 **/
1192 EFI_STATUS
1193 EFIAPI
1194 DiskIoWriteDisk (
1195   IN EFI_DISK_IO_PROTOCOL  *This,
1196   IN UINT32                MediaId,
1197   IN UINT64                Offset,
1198   IN UINTN                 BufferSize,
1199   IN VOID                  *Buffer
1200   )
1201 {
1202   return DiskIo2ReadWriteDisk (
1203            DISK_IO_PRIVATE_DATA_FROM_DISK_IO (This),
1204            TRUE, MediaId, Offset, NULL, BufferSize, (UINT8 *) Buffer
1205            );
1206 }
1207
1208 /**
1209   The user Entry Point for module DiskIo. The user code starts with this function.
1210
1211   @param[in] ImageHandle    The firmware allocated handle for the EFI image.
1212   @param[in] SystemTable    A pointer to the EFI System Table.
1213
1214   @retval EFI_SUCCESS       The entry point is executed successfully.
1215   @retval other             Some error occurs when executing this entry point.
1216
1217 **/
1218 EFI_STATUS
1219 EFIAPI
1220 InitializeDiskIo (
1221   IN EFI_HANDLE           ImageHandle,
1222   IN EFI_SYSTEM_TABLE     *SystemTable
1223   )
1224 {
1225   EFI_STATUS              Status;
1226
1227   //
1228   // Install driver model protocol(s).
1229   //
1230   Status = EfiLibInstallDriverBindingComponentName2 (
1231              ImageHandle,
1232              SystemTable,
1233              &gDiskIoDriverBinding,
1234              ImageHandle,
1235              &gDiskIoComponentName,
1236              &gDiskIoComponentName2
1237              );
1238   ASSERT_EFI_ERROR (Status);
1239
1240   return Status;
1241 }