0658299288afa6aad95d56d669f46a712c7513f7
[mirror_edk2.git] / 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 (PcdGet32 (PcdDiskIoDataBufferBlockNum) * Instance->BlockIo->Media->BlockSize),
187 Instance->BlockIo->Media->IoAlign
188 );
189 if (Instance->SharedWorkingBuffer == NULL) {
190 Status = EFI_OUT_OF_RESOURCES;
191 goto ErrorExit;
192 }
193
194 //
195 // Install protocol interfaces for the Disk IO device.
196 //
197 if (Instance->BlockIo2 != NULL) {
198 Status = gBS->InstallMultipleProtocolInterfaces (
199 &ControllerHandle,
200 &gEfiDiskIoProtocolGuid, &Instance->DiskIo,
201 &gEfiDiskIo2ProtocolGuid, &Instance->DiskIo2,
202 NULL
203 );
204 } else {
205 Status = gBS->InstallMultipleProtocolInterfaces (
206 &ControllerHandle,
207 &gEfiDiskIoProtocolGuid, &Instance->DiskIo,
208 NULL
209 );
210 }
211
212 ErrorExit:
213 if (EFI_ERROR (Status)) {
214 if (Instance != NULL && Instance->SharedWorkingBuffer != NULL) {
215 FreeAlignedPages (
216 Instance->SharedWorkingBuffer,
217 EFI_SIZE_TO_PAGES (PcdGet32 (PcdDiskIoDataBufferBlockNum) * Instance->BlockIo->Media->BlockSize)
218 );
219 }
220
221 if (Instance != NULL) {
222 FreePool (Instance);
223 }
224
225 gBS->CloseProtocol (
226 ControllerHandle,
227 &gEfiBlockIoProtocolGuid,
228 This->DriverBindingHandle,
229 ControllerHandle
230 );
231 }
232
233 ErrorExit1:
234 gBS->RestoreTPL (OldTpl);
235 return Status;
236 }
237
238 /**
239 Stop this driver on ControllerHandle by removing Disk IO protocol and closing
240 the Block IO protocol on ControllerHandle.
241
242 @param This Protocol instance pointer.
243 @param ControllerHandle Handle of device to stop driver on
244 @param NumberOfChildren Number of Handles in ChildHandleBuffer. If number of
245 children is zero stop the entire bus driver.
246 @param ChildHandleBuffer List of Child Handles to Stop.
247
248 @retval EFI_SUCCESS This driver is removed ControllerHandle
249 @retval other This driver was not removed from this device
250
251 **/
252 EFI_STATUS
253 EFIAPI
254 DiskIoDriverBindingStop (
255 IN EFI_DRIVER_BINDING_PROTOCOL *This,
256 IN EFI_HANDLE ControllerHandle,
257 IN UINTN NumberOfChildren,
258 IN EFI_HANDLE *ChildHandleBuffer
259 )
260 {
261 EFI_STATUS Status;
262 EFI_DISK_IO_PROTOCOL *DiskIo;
263 EFI_DISK_IO2_PROTOCOL *DiskIo2;
264 DISK_IO_PRIVATE_DATA *Instance;
265 BOOLEAN AllTaskDone;
266
267 //
268 // Get our context back.
269 //
270 Status = gBS->OpenProtocol (
271 ControllerHandle,
272 &gEfiDiskIoProtocolGuid,
273 (VOID **) &DiskIo,
274 This->DriverBindingHandle,
275 ControllerHandle,
276 EFI_OPEN_PROTOCOL_GET_PROTOCOL
277 );
278 if (EFI_ERROR (Status)) {
279 return Status;
280 }
281 Status = gBS->OpenProtocol (
282 ControllerHandle,
283 &gEfiDiskIo2ProtocolGuid,
284 (VOID **) &DiskIo2,
285 This->DriverBindingHandle,
286 ControllerHandle,
287 EFI_OPEN_PROTOCOL_GET_PROTOCOL
288 );
289 if (EFI_ERROR (Status)) {
290 DiskIo2 = NULL;
291 }
292
293 Instance = DISK_IO_PRIVATE_DATA_FROM_DISK_IO (DiskIo);
294
295 if (DiskIo2 != NULL) {
296 //
297 // Call BlockIo2::Reset() to terminate any in-flight non-blocking I/O requests
298 //
299 ASSERT (Instance->BlockIo2 != NULL);
300 Status = Instance->BlockIo2->Reset (Instance->BlockIo2, FALSE);
301 if (EFI_ERROR (Status)) {
302 return Status;
303 }
304 Status = gBS->UninstallMultipleProtocolInterfaces (
305 ControllerHandle,
306 &gEfiDiskIoProtocolGuid, &Instance->DiskIo,
307 &gEfiDiskIo2ProtocolGuid, &Instance->DiskIo2,
308 NULL
309 );
310 } else {
311 Status = gBS->UninstallMultipleProtocolInterfaces (
312 ControllerHandle,
313 &gEfiDiskIoProtocolGuid, &Instance->DiskIo,
314 NULL
315 );
316 }
317 if (!EFI_ERROR (Status)) {
318
319 do {
320 EfiAcquireLock (&Instance->TaskQueueLock);
321 AllTaskDone = IsListEmpty (&Instance->TaskQueue);
322 EfiReleaseLock (&Instance->TaskQueueLock);
323 } while (!AllTaskDone);
324
325 FreeAlignedPages (
326 Instance->SharedWorkingBuffer,
327 EFI_SIZE_TO_PAGES (PcdGet32 (PcdDiskIoDataBufferBlockNum) * Instance->BlockIo->Media->BlockSize)
328 );
329
330 Status = gBS->CloseProtocol (
331 ControllerHandle,
332 &gEfiBlockIoProtocolGuid,
333 This->DriverBindingHandle,
334 ControllerHandle
335 );
336 ASSERT_EFI_ERROR (Status);
337 if (DiskIo2 != NULL) {
338 Status = gBS->CloseProtocol (
339 ControllerHandle,
340 &gEfiBlockIo2ProtocolGuid,
341 This->DriverBindingHandle,
342 ControllerHandle
343 );
344 ASSERT_EFI_ERROR (Status);
345 }
346
347 FreePool (Instance);
348 }
349
350 return Status;
351 }
352
353
354 /**
355 Destroy the sub task.
356
357 @param Instance Pointer to the DISK_IO_PRIVATE_DATA.
358 @param Subtask Subtask.
359
360 @return LIST_ENTRY * Pointer to the next link of subtask.
361 **/
362 LIST_ENTRY *
363 DiskIoDestroySubtask (
364 IN DISK_IO_PRIVATE_DATA *Instance,
365 IN DISK_IO_SUBTASK *Subtask
366 )
367 {
368 LIST_ENTRY *Link;
369 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 += PcdGet32 (PcdDiskIoDataBufferBlockNum)) {
659 DataBufferSize = MIN (BufferSize, PcdGet32 (PcdDiskIoDataBufferBlockNum) * BlockSize);
660
661 Subtask = DiskIoCreateSubtask (Write, Lba, 0, DataBufferSize, SharedWorkingBuffer, BufferPtr, Blocking);
662 if (Subtask == NULL) {
663 goto Done;
664 }
665 InsertTailList (Subtasks, &Subtask->Link);
666
667 BufferPtr += DataBufferSize;
668 Offset += DataBufferSize;
669 BufferSize -= DataBufferSize;
670 }
671 } else {
672 WorkingBuffer = AllocateAlignedPages (EFI_SIZE_TO_PAGES (BufferSize), IoAlign);
673 if (WorkingBuffer == NULL) {
674 //
675 // If there is not enough memory, downgrade to blocking access
676 //
677 DEBUG ((EFI_D_VERBOSE, "DiskIo: No enough memory so downgrade to blocking access\n"));
678 if (!DiskIoCreateSubtaskList (Instance, Write, Offset, BufferSize, BufferPtr, TRUE, SharedWorkingBuffer, Subtasks)) {
679 goto Done;
680 }
681 } else {
682 Subtask = DiskIoCreateSubtask (Write, Lba, 0, BufferSize, WorkingBuffer, BufferPtr, Blocking);
683 if (Subtask == NULL) {
684 goto Done;
685 }
686 InsertTailList (Subtasks, &Subtask->Link);
687 }
688
689 BufferPtr += BufferSize;
690 Offset += BufferSize;
691 BufferSize -= BufferSize;
692 }
693 }
694 }
695
696 ASSERT (BufferSize == 0);
697
698 return TRUE;
699
700 Done:
701 //
702 // Remove all the subtasks.
703 //
704 for (Link = GetFirstNode (Subtasks); !IsNull (Subtasks, Link); ) {
705 Subtask = CR (Link, DISK_IO_SUBTASK, Link, DISK_IO_SUBTASK_SIGNATURE);
706 Link = DiskIoDestroySubtask (Instance, Subtask);
707 }
708 return FALSE;
709 }
710
711 /**
712 Terminate outstanding asynchronous requests to a device.
713
714 @param This Indicates a pointer to the calling context.
715
716 @retval EFI_SUCCESS All outstanding requests were successfully terminated.
717 @retval EFI_DEVICE_ERROR The device reported an error while performing the cancel
718 operation.
719 **/
720 EFI_STATUS
721 EFIAPI
722 DiskIo2Cancel (
723 IN EFI_DISK_IO2_PROTOCOL *This
724 )
725 {
726 DISK_IO_PRIVATE_DATA *Instance;
727 DISK_IO2_TASK *Task;
728 LIST_ENTRY *Link;
729
730 Instance = DISK_IO_PRIVATE_DATA_FROM_DISK_IO2 (This);
731
732 EfiAcquireLock (&Instance->TaskQueueLock);
733
734 for (Link = GetFirstNode (&Instance->TaskQueue)
735 ; !IsNull (&Instance->TaskQueue, Link)
736 ; Link = GetNextNode (&Instance->TaskQueue, Link)
737 ) {
738 Task = CR (Link, DISK_IO2_TASK, Link, DISK_IO2_TASK_SIGNATURE);
739
740 if (Task->Token != NULL) {
741 Task->Token->TransactionStatus = EFI_ABORTED;
742 gBS->SignalEvent (Task->Token->Event);
743 //
744 // Set Token to NULL so that the further BlockIo2 responses will be ignored
745 //
746 Task->Token = NULL;
747 }
748 }
749
750 EfiReleaseLock (&Instance->TaskQueueLock);
751
752 return EFI_SUCCESS;
753 }
754
755 /**
756 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 }