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