pair RaiseTPL with RestoreTPL
[mirror_edk2.git] / EdkNt32Pkg / Dxe / WinNtThunk / Bus / BlockIo / WinNtBlockIo.c
1 /*++
2
3 Copyright (c) 2006 - 2007, Intel Corporation
4 All rights reserved. This program and the accompanying materials
5 are licensed and made available under the terms and conditions of the BSD License
6 which accompanies this distribution. The full text of the license may be found at
7 http://opensource.org/licenses/bsd-license.php
8
9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
11
12 Module Name:
13
14 WinNtBlockIo.c
15
16 Abstract:
17
18 Produce block IO abstractions for real devices on your PC using Win32 APIs.
19 The configuration of what devices to mount or emulate comes from NT
20 environment variables. The variables must be visible to the Microsoft*
21 Developer Studio for them to work.
22
23 <F>ixed - Fixed disk like a hard drive.
24 <R>emovable - Removable media like a floppy or CD-ROM.
25 Read <O>nly - Write protected device.
26 Read <W>rite - Read write device.
27 <block count> - Decimal number of blocks a device supports.
28 <block size> - Decimal number of bytes per block.
29
30 NT envirnonment variable contents. '<' and '>' are not part of the variable,
31 they are just used to make this help more readable. There should be no
32 spaces between the ';'. Extra spaces will break the variable. A '!' is
33 used to seperate multiple devices in a variable.
34
35 EFI_WIN_NT_VIRTUAL_DISKS =
36 <F | R><O | W>;<block count>;<block size>[!...]
37
38 EFI_WIN_NT_PHYSICAL_DISKS =
39 <drive letter>:<F | R><O | W>;<block count>;<block size>[!...]
40
41 Virtual Disks: These devices use a file to emulate a hard disk or removable
42 media device.
43
44 Thus a 20 MB emulated hard drive would look like:
45 EFI_WIN_NT_VIRTUAL_DISKS=FW;40960;512
46
47 A 1.44MB emulated floppy with a block size of 1024 would look like:
48 EFI_WIN_NT_VIRTUAL_DISKS=RW;1440;1024
49
50 Physical Disks: These devices use NT to open a real device in your system
51
52 Thus a 120 MB floppy would look like:
53 EFI_WIN_NT_PHYSICAL_DISKS=B:RW;245760;512
54
55 Thus a standard CD-ROM floppy would look like:
56 EFI_WIN_NT_PHYSICAL_DISKS=Z:RO;307200;2048
57
58
59 * Other names and brands may be claimed as the property of others.
60
61 --*/
62
63 #include "WinNtBlockIo.h"
64
65 EFI_DRIVER_BINDING_PROTOCOL gWinNtBlockIoDriverBinding = {
66 WinNtBlockIoDriverBindingSupported,
67 WinNtBlockIoDriverBindingStart,
68 WinNtBlockIoDriverBindingStop,
69 0xa,
70 NULL,
71 NULL
72 };
73
74
75 EFI_STATUS
76 EFIAPI
77 WinNtBlockIoDriverBindingSupported (
78 IN EFI_DRIVER_BINDING_PROTOCOL *This,
79 IN EFI_HANDLE Handle,
80 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
81 )
82 /*++
83
84 Routine Description:
85
86 Arguments:
87
88 Returns:
89
90 None
91
92 --*/
93 // TODO: This - add argument and description to function comment
94 // TODO: Handle - add argument and description to function comment
95 // TODO: RemainingDevicePath - add argument and description to function comment
96 {
97 EFI_STATUS Status;
98 EFI_WIN_NT_IO_PROTOCOL *WinNtIo;
99
100 //
101 // Open the IO Abstraction(s) needed to perform the supported test
102 //
103 Status = gBS->OpenProtocol (
104 Handle,
105 &gEfiWinNtIoProtocolGuid,
106 &WinNtIo,
107 This->DriverBindingHandle,
108 Handle,
109 EFI_OPEN_PROTOCOL_BY_DRIVER
110 );
111 if (EFI_ERROR (Status)) {
112 return Status;
113 }
114
115 //
116 // Make sure the WinNtThunkProtocol is valid
117 //
118 Status = EFI_UNSUPPORTED;
119 if (WinNtIo->WinNtThunk->Signature == EFI_WIN_NT_THUNK_PROTOCOL_SIGNATURE) {
120
121 //
122 // Check the GUID to see if this is a handle type the driver supports
123 //
124 if (CompareGuid (WinNtIo->TypeGuid, &gEfiWinNtVirtualDisksGuid) ||
125 CompareGuid (WinNtIo->TypeGuid, &gEfiWinNtPhysicalDisksGuid) ) {
126 Status = EFI_SUCCESS;
127 }
128 }
129
130 //
131 // Close the I/O Abstraction(s) used to perform the supported test
132 //
133 gBS->CloseProtocol (
134 Handle,
135 &gEfiWinNtIoProtocolGuid,
136 This->DriverBindingHandle,
137 Handle
138 );
139
140 return Status;
141 }
142
143 EFI_STATUS
144 EFIAPI
145 WinNtBlockIoDriverBindingStart (
146 IN EFI_DRIVER_BINDING_PROTOCOL *This,
147 IN EFI_HANDLE Handle,
148 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
149 )
150 /*++
151
152 Routine Description:
153
154 Arguments:
155
156 Returns:
157
158 None
159
160 --*/
161 // TODO: This - add argument and description to function comment
162 // TODO: Handle - add argument and description to function comment
163 // TODO: RemainingDevicePath - add argument and description to function comment
164 {
165 EFI_STATUS Status;
166 EFI_WIN_NT_IO_PROTOCOL *WinNtIo;
167 WIN_NT_RAW_DISK_DEVICE_TYPE DiskType;
168 UINT16 Buffer[FILENAME_BUFFER_SIZE];
169 CHAR16 *Str;
170 BOOLEAN RemovableMedia;
171 BOOLEAN WriteProtected;
172 UINTN NumberOfBlocks;
173 UINTN BlockSize;
174
175 //
176 // Grab the protocols we need
177 //
178 Status = gBS->OpenProtocol (
179 Handle,
180 &gEfiWinNtIoProtocolGuid,
181 &WinNtIo,
182 This->DriverBindingHandle,
183 Handle,
184 EFI_OPEN_PROTOCOL_BY_DRIVER
185 );
186 if (EFI_ERROR (Status)) {
187 return Status;
188 }
189
190 //
191 // Set DiskType
192 //
193 if (CompareGuid (WinNtIo->TypeGuid, &gEfiWinNtVirtualDisksGuid)) {
194 DiskType = EfiWinNtVirtualDisks;
195 } else if (CompareGuid (WinNtIo->TypeGuid, &gEfiWinNtPhysicalDisksGuid)) {
196 DiskType = EfiWinNtPhysicalDisks;
197 } else {
198 Status = EFI_UNSUPPORTED;
199 goto Done;
200 }
201
202 Status = EFI_NOT_FOUND;
203 Str = WinNtIo->EnvString;
204 if (DiskType == EfiWinNtVirtualDisks) {
205 WinNtIo->WinNtThunk->SPrintf (
206 Buffer,
207 sizeof (Buffer),
208 L"Diskfile%d",
209 WinNtIo->InstanceNumber
210 );
211 } else {
212 if (*Str >= 'A' && *Str <= 'Z' || *Str >= 'a' && *Str <= 'z') {
213 WinNtIo->WinNtThunk->SPrintf (Buffer, sizeof (Buffer), L"\\\\.\\%c:", *Str);
214 } else {
215 WinNtIo->WinNtThunk->SPrintf (Buffer, sizeof (Buffer), L"\\\\.\\PHYSICALDRIVE%c", *Str);
216 }
217
218 Str++;
219 if (*Str != ':') {
220 Status = EFI_NOT_FOUND;
221 goto Done;
222 }
223
224 Str++;
225 }
226
227 if (*Str == 'R' || *Str == 'F') {
228 RemovableMedia = (BOOLEAN) (*Str == 'R');
229 Str++;
230 if (*Str == 'O' || *Str == 'W') {
231 WriteProtected = (BOOLEAN) (*Str == 'O');
232 Str = GetNextElementPastTerminator (Str, ';');
233
234 NumberOfBlocks = Atoi (Str);
235 if (NumberOfBlocks != 0) {
236 Str = GetNextElementPastTerminator (Str, ';');
237 BlockSize = Atoi (Str);
238 if (BlockSize != 0) {
239 //
240 // If we get here the variable is valid so do the work.
241 //
242 Status = WinNtBlockIoCreateMapping (
243 WinNtIo,
244 Handle,
245 Buffer,
246 WriteProtected,
247 RemovableMedia,
248 NumberOfBlocks,
249 BlockSize,
250 DiskType
251 );
252
253 }
254 }
255 }
256 }
257
258 Done:
259 if (EFI_ERROR (Status)) {
260 gBS->CloseProtocol (
261 Handle,
262 &gEfiWinNtIoProtocolGuid,
263 This->DriverBindingHandle,
264 Handle
265 );
266 }
267
268 return Status;
269 }
270
271 EFI_STATUS
272 EFIAPI
273 WinNtBlockIoDriverBindingStop (
274 IN EFI_DRIVER_BINDING_PROTOCOL *This,
275 IN EFI_HANDLE Handle,
276 IN UINTN NumberOfChildren,
277 IN EFI_HANDLE *ChildHandleBuffer
278 )
279 /*++
280
281 Routine Description:
282
283 TODO: Add function description
284
285 Arguments:
286
287 This - TODO: add argument description
288 Handle - TODO: add argument description
289 NumberOfChildren - TODO: add argument description
290 ChildHandleBuffer - TODO: add argument description
291
292 Returns:
293
294 EFI_UNSUPPORTED - TODO: Add description for return value
295
296 --*/
297 {
298 EFI_BLOCK_IO_PROTOCOL *BlockIo;
299 EFI_STATUS Status;
300 WIN_NT_BLOCK_IO_PRIVATE *Private;
301
302 //
303 // Get our context back
304 //
305 Status = gBS->OpenProtocol (
306 Handle,
307 &gEfiBlockIoProtocolGuid,
308 &BlockIo,
309 This->DriverBindingHandle,
310 Handle,
311 EFI_OPEN_PROTOCOL_GET_PROTOCOL
312 );
313 if (EFI_ERROR (Status)) {
314 return EFI_UNSUPPORTED;
315 }
316
317 Private = WIN_NT_BLOCK_IO_PRIVATE_DATA_FROM_THIS (BlockIo);
318
319 //
320 // BugBug: If we need to kick people off, we need to make Uninstall Close the handles.
321 // We could pass in our image handle or FLAG our open to be closed via
322 // Unistall (== to saying any CloseProtocol will close our open)
323 //
324 Status = gBS->UninstallMultipleProtocolInterfaces (
325 Private->EfiHandle,
326 &gEfiBlockIoProtocolGuid,
327 &Private->BlockIo,
328 NULL
329 );
330 if (!EFI_ERROR (Status)) {
331
332 Status = gBS->CloseProtocol (
333 Handle,
334 &gEfiWinNtIoProtocolGuid,
335 This->DriverBindingHandle,
336 Handle
337 );
338
339 //
340 // Shut down our device
341 //
342 Private->WinNtThunk->CloseHandle (Private->NtHandle);
343
344 //
345 // Free our instance data
346 //
347 FreeUnicodeStringTable (Private->ControllerNameTable);
348
349 gBS->FreePool (Private);
350 }
351
352 return Status;
353 }
354
355 STATIC
356 CHAR16 *
357 GetNextElementPastTerminator (
358 IN CHAR16 *EnvironmentVariable,
359 IN CHAR16 Terminator
360 )
361 /*++
362
363 Routine Description:
364
365 Worker function to parse environment variables.
366
367 Arguments:
368 EnvironmentVariable - Envirnment variable to parse.
369
370 Terminator - Terminator to parse for.
371
372 Returns:
373
374 Pointer to next eliment past the first occurence of Terminator or the '\0'
375 at the end of the string.
376
377 --*/
378 {
379 CHAR16 *Ptr;
380
381 for (Ptr = EnvironmentVariable; *Ptr != '\0'; Ptr++) {
382 if (*Ptr == Terminator) {
383 Ptr++;
384 break;
385 }
386 }
387
388 return Ptr;
389 }
390
391 STATIC
392 EFI_STATUS
393 WinNtBlockIoCreateMapping (
394 IN EFI_WIN_NT_IO_PROTOCOL *WinNtIo,
395 IN EFI_HANDLE EfiDeviceHandle,
396 IN CHAR16 *Filename,
397 IN BOOLEAN ReadOnly,
398 IN BOOLEAN RemovableMedia,
399 IN UINTN NumberOfBlocks,
400 IN UINTN BlockSize,
401 IN WIN_NT_RAW_DISK_DEVICE_TYPE DeviceType
402 )
403 /*++
404
405 Routine Description:
406
407 TODO: Add function description
408
409 Arguments:
410
411 WinNtIo - TODO: add argument description
412 EfiDeviceHandle - TODO: add argument description
413 Filename - TODO: add argument description
414 ReadOnly - TODO: add argument description
415 RemovableMedia - TODO: add argument description
416 NumberOfBlocks - TODO: add argument description
417 BlockSize - TODO: add argument description
418 DeviceType - TODO: add argument description
419
420 Returns:
421
422 TODO: add return values
423
424 --*/
425 {
426 EFI_STATUS Status;
427 EFI_BLOCK_IO_PROTOCOL *BlockIo;
428 WIN_NT_BLOCK_IO_PRIVATE *Private;
429 UINTN Index;
430
431 WinNtIo->WinNtThunk->SetErrorMode (SEM_FAILCRITICALERRORS);
432
433 Status = gBS->AllocatePool (
434 EfiBootServicesData,
435 sizeof (WIN_NT_BLOCK_IO_PRIVATE),
436 &Private
437 );
438 ASSERT_EFI_ERROR (Status);
439
440 EfiInitializeLock (&Private->Lock, EFI_TPL_NOTIFY);
441
442 Private->WinNtThunk = WinNtIo->WinNtThunk;
443
444 Private->Signature = WIN_NT_BLOCK_IO_PRIVATE_SIGNATURE;
445 Private->LastBlock = NumberOfBlocks - 1;
446 Private->BlockSize = BlockSize;
447
448 for (Index = 0; Filename[Index] != 0; Index++) {
449 Private->Filename[Index] = Filename[Index];
450 }
451
452 Private->Filename[Index] = 0;
453
454 Private->ReadMode = GENERIC_READ | (ReadOnly ? 0 : GENERIC_WRITE);
455 Private->ShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE;
456
457 Private->NumberOfBlocks = NumberOfBlocks;
458 Private->DeviceType = DeviceType;
459 Private->NtHandle = INVALID_HANDLE_VALUE;
460
461 Private->ControllerNameTable = NULL;
462
463 AddUnicodeString (
464 "eng",
465 gWinNtBlockIoComponentName.SupportedLanguages,
466 &Private->ControllerNameTable,
467 Private->Filename
468 );
469
470 BlockIo = &Private->BlockIo;
471 BlockIo->Revision = EFI_BLOCK_IO_PROTOCOL_REVISION;
472 BlockIo->Media = &Private->Media;
473 BlockIo->Media->BlockSize = Private->BlockSize;
474 BlockIo->Media->LastBlock = Private->NumberOfBlocks - 1;
475 BlockIo->Media->MediaId = 0;;
476
477 BlockIo->Reset = WinNtBlockIoResetBlock;
478 BlockIo->ReadBlocks = WinNtBlockIoReadBlocks;
479 BlockIo->WriteBlocks = WinNtBlockIoWriteBlocks;
480 BlockIo->FlushBlocks = WinNtBlockIoFlushBlocks;
481
482 BlockIo->Media->ReadOnly = ReadOnly;
483 BlockIo->Media->RemovableMedia = RemovableMedia;
484 BlockIo->Media->LogicalPartition = FALSE;
485 BlockIo->Media->MediaPresent = TRUE;
486 BlockIo->Media->WriteCaching = FALSE;
487
488 if (DeviceType == EfiWinNtVirtualDisks) {
489 BlockIo->Media->IoAlign = 1;
490
491 //
492 // Create a file to use for a virtual disk even if it does not exist.
493 //
494 Private->OpenMode = OPEN_ALWAYS;
495 } else if (DeviceType == EfiWinNtPhysicalDisks) {
496 //
497 // Physical disk and floppy devices require 4 byte alignment.
498 //
499 BlockIo->Media->IoAlign = 4;
500
501 //
502 // You can only open a physical device if it exists.
503 //
504 Private->OpenMode = OPEN_EXISTING;
505 } else {
506 ASSERT (FALSE);
507 }
508
509 Private->EfiHandle = EfiDeviceHandle;
510 Status = WinNtBlockIoOpenDevice (Private);
511 if (!EFI_ERROR (Status)) {
512
513 Status = gBS->InstallMultipleProtocolInterfaces (
514 &Private->EfiHandle,
515 &gEfiBlockIoProtocolGuid,
516 &Private->BlockIo,
517 NULL
518 );
519 if (EFI_ERROR (Status)) {
520 FreeUnicodeStringTable (Private->ControllerNameTable);
521 gBS->FreePool (Private);
522 }
523
524 DEBUG ((EFI_D_INIT, "BlockDevice added: %s\n", Filename));
525 }
526
527 return Status;
528 }
529
530 STATIC
531 EFI_STATUS
532 WinNtBlockIoOpenDevice (
533 WIN_NT_BLOCK_IO_PRIVATE *Private
534 )
535 /*++
536
537 Routine Description:
538
539 TODO: Add function description
540
541 Arguments:
542
543 Private - TODO: add argument description
544
545 Returns:
546
547 TODO: add return values
548
549 --*/
550 {
551 EFI_STATUS Status;
552 UINT64 FileSize;
553 UINT64 EndOfFile;
554 EFI_BLOCK_IO_PROTOCOL *BlockIo;
555
556 BlockIo = &Private->BlockIo;
557 EfiAcquireLock (&Private->Lock);
558
559 //
560 // If the device is already opened, close it
561 //
562 if (Private->NtHandle != INVALID_HANDLE_VALUE) {
563 BlockIo->Reset (BlockIo, FALSE);
564 }
565
566 //
567 // Open the device
568 //
569 Private->NtHandle = Private->WinNtThunk->CreateFile (
570 Private->Filename,
571 Private->ReadMode,
572 Private->ShareMode,
573 NULL,
574 Private->OpenMode,
575 0,
576 NULL
577 );
578
579 Status = Private->WinNtThunk->GetLastError ();
580
581 if (Private->NtHandle == INVALID_HANDLE_VALUE) {
582 DEBUG ((EFI_D_INFO, "PlOpenBlock: Could not open %s, %x\n", Private->Filename, Private->WinNtThunk->GetLastError ()));
583 BlockIo->Media->MediaPresent = FALSE;
584 Status = EFI_NO_MEDIA;
585 goto Done;
586 }
587
588 if (!BlockIo->Media->MediaPresent) {
589 //
590 // BugBug: try to emulate if a CD appears - notify drivers to check it out
591 //
592 BlockIo->Media->MediaPresent = TRUE;
593 EfiReleaseLock (&Private->Lock);
594 EfiAcquireLock (&Private->Lock);
595 }
596
597 //
598 // get the size of the file
599 //
600 Status = SetFilePointer64 (Private, 0, &FileSize, FILE_END);
601
602 if (EFI_ERROR (Status)) {
603 FileSize = MultU64x32 (Private->NumberOfBlocks, Private->BlockSize);
604 if (Private->DeviceType == EfiWinNtVirtualDisks) {
605 DEBUG ((EFI_D_ERROR, "PlOpenBlock: Could not get filesize of %s\n", Private->Filename));
606 Status = EFI_UNSUPPORTED;
607 goto Done;
608 }
609 }
610
611 if (Private->NumberOfBlocks == 0) {
612 Private->NumberOfBlocks = DivU64x32 (FileSize, Private->BlockSize);
613 }
614
615 EndOfFile = MultU64x32 (Private->NumberOfBlocks, Private->BlockSize);
616
617 if (FileSize != EndOfFile) {
618 //
619 // file is not the proper size, change it
620 //
621 DEBUG ((EFI_D_INIT, "PlOpenBlock: Initializing block device: %hs\n", Private->Filename));
622
623 //
624 // first set it to 0
625 //
626 SetFilePointer64 (Private, 0, NULL, FILE_BEGIN);
627 Private->WinNtThunk->SetEndOfFile (Private->NtHandle);
628
629 //
630 // then set it to the needed file size (OS will zero fill it)
631 //
632 SetFilePointer64 (Private, EndOfFile, NULL, FILE_BEGIN);
633 Private->WinNtThunk->SetEndOfFile (Private->NtHandle);
634 }
635
636 DEBUG ((EFI_D_INIT, "%HPlOpenBlock: opened %s%N\n", Private->Filename));
637 Status = EFI_SUCCESS;
638
639 Done:
640 if (EFI_ERROR (Status)) {
641 if (Private->NtHandle != INVALID_HANDLE_VALUE) {
642 BlockIo->Reset (BlockIo, FALSE);
643 }
644 }
645
646 EfiReleaseLock (&Private->Lock);
647 return Status;
648 }
649
650 STATIC
651 EFI_STATUS
652 WinNtBlockIoError (
653 IN WIN_NT_BLOCK_IO_PRIVATE *Private
654 )
655 /*++
656
657 Routine Description:
658
659 TODO: Add function description
660
661 Arguments:
662
663 Private - TODO: add argument description
664
665 Returns:
666
667 TODO: add return values
668
669 --*/
670 {
671 EFI_BLOCK_IO_PROTOCOL *BlockIo;
672 EFI_STATUS Status;
673 BOOLEAN ReinstallBlockIoFlag;
674
675 BlockIo = &Private->BlockIo;
676
677 switch (Private->WinNtThunk->GetLastError ()) {
678
679 case ERROR_NOT_READY:
680 Status = EFI_NO_MEDIA;
681 BlockIo->Media->ReadOnly = FALSE;
682 BlockIo->Media->MediaPresent = FALSE;
683 ReinstallBlockIoFlag = FALSE;
684 break;
685
686 case ERROR_WRONG_DISK:
687 BlockIo->Media->ReadOnly = FALSE;
688 BlockIo->Media->MediaPresent = TRUE;
689 BlockIo->Media->MediaId += 1;
690 ReinstallBlockIoFlag = TRUE;
691 Status = EFI_MEDIA_CHANGED;
692 break;
693
694 case ERROR_WRITE_PROTECT:
695 BlockIo->Media->ReadOnly = TRUE;
696 ReinstallBlockIoFlag = FALSE;
697 Status = EFI_WRITE_PROTECTED;
698 break;
699
700 default:
701 ReinstallBlockIoFlag = FALSE;
702 Status = EFI_DEVICE_ERROR;
703 break;
704 }
705
706 if (ReinstallBlockIoFlag) {
707 BlockIo->Reset (BlockIo, FALSE);
708
709 gBS->ReinstallProtocolInterface (
710 Private->EfiHandle,
711 &gEfiBlockIoProtocolGuid,
712 BlockIo,
713 BlockIo
714 );
715 }
716
717 return Status;
718 }
719
720 STATIC
721 EFI_STATUS
722 WinNtBlockIoReadWriteCommon (
723 IN WIN_NT_BLOCK_IO_PRIVATE *Private,
724 IN UINT32 MediaId,
725 IN EFI_LBA Lba,
726 IN UINTN BufferSize,
727 IN VOID *Buffer,
728 IN CHAR8 *CallerName
729 )
730 /*++
731
732 Routine Description:
733
734 TODO: Add function description
735
736 Arguments:
737
738 Private - TODO: add argument description
739 MediaId - TODO: add argument description
740 Lba - TODO: add argument description
741 BufferSize - TODO: add argument description
742 Buffer - TODO: add argument description
743 CallerName - TODO: add argument description
744
745 Returns:
746
747 EFI_NO_MEDIA - TODO: Add description for return value
748 EFI_MEDIA_CHANGED - TODO: Add description for return value
749 EFI_INVALID_PARAMETER - TODO: Add description for return value
750 EFI_SUCCESS - TODO: Add description for return value
751 EFI_BAD_BUFFER_SIZE - TODO: Add description for return value
752 EFI_INVALID_PARAMETER - TODO: Add description for return value
753 EFI_SUCCESS - TODO: Add description for return value
754
755 --*/
756 {
757 EFI_STATUS Status;
758 UINTN BlockSize;
759 UINT64 LastBlock;
760 INT64 DistanceToMove;
761 UINT64 DistanceMoved;
762
763 if (Private->NtHandle == INVALID_HANDLE_VALUE) {
764 Status = WinNtBlockIoOpenDevice (Private);
765 if (EFI_ERROR (Status)) {
766 return Status;
767 }
768 }
769
770 if (!Private->Media.MediaPresent) {
771 DEBUG ((EFI_D_INIT, "%s: No Media\n", CallerName));
772 return EFI_NO_MEDIA;
773 }
774
775 if (Private->Media.MediaId != MediaId) {
776 return EFI_MEDIA_CHANGED;
777 }
778
779 if ((UINT32) Buffer % Private->Media.IoAlign != 0) {
780 return EFI_INVALID_PARAMETER;
781 }
782
783 //
784 // Verify buffer size
785 //
786 BlockSize = Private->BlockSize;
787 if (BufferSize == 0) {
788 DEBUG ((EFI_D_INIT, "%s: Zero length read\n", CallerName));
789 return EFI_SUCCESS;
790 }
791
792 if ((BufferSize % BlockSize) != 0) {
793 DEBUG ((EFI_D_INIT, "%s: Invalid read size\n", CallerName));
794 return EFI_BAD_BUFFER_SIZE;
795 }
796
797 LastBlock = Lba + (BufferSize / BlockSize) - 1;
798 if (LastBlock > Private->LastBlock) {
799 DEBUG ((EFI_D_INIT, "ReadBlocks: Attempted to read off end of device\n"));
800 return EFI_INVALID_PARAMETER;
801 }
802 //
803 // Seek to End of File
804 //
805 DistanceToMove = MultU64x32 (Lba, BlockSize);
806 Status = SetFilePointer64 (Private, DistanceToMove, &DistanceMoved, FILE_BEGIN);
807
808 if (EFI_ERROR (Status)) {
809 DEBUG ((EFI_D_INIT, "WriteBlocks: SetFilePointer failed\n"));
810 return WinNtBlockIoError (Private);
811 }
812
813 return EFI_SUCCESS;
814 }
815
816 STATIC
817 EFI_STATUS
818 EFIAPI
819 WinNtBlockIoReadBlocks (
820 IN EFI_BLOCK_IO_PROTOCOL *This,
821 IN UINT32 MediaId,
822 IN EFI_LBA Lba,
823 IN UINTN BufferSize,
824 OUT VOID *Buffer
825 )
826 /*++
827
828 Routine Description:
829 Read BufferSize bytes from Lba into Buffer.
830
831 Arguments:
832 This - Protocol instance pointer.
833 MediaId - Id of the media, changes every time the media is replaced.
834 Lba - The starting Logical Block Address to read from
835 BufferSize - Size of Buffer, must be a multiple of device block size.
836 Buffer - Buffer containing read data
837
838 Returns:
839 EFI_SUCCESS - The data was read correctly from the device.
840 EFI_DEVICE_ERROR - The device reported an error while performing the read.
841 EFI_NO_MEDIA - There is no media in the device.
842 EFI_MEDIA_CHANGED - The MediaId does not matched the current device.
843 EFI_BAD_BUFFER_SIZE - The Buffer was not a multiple of the block size of the
844 device.
845 EFI_INVALID_PARAMETER - The read request contains device addresses that are not
846 valid for the device.
847
848 --*/
849 {
850 WIN_NT_BLOCK_IO_PRIVATE *Private;
851 BOOL Flag;
852 EFI_STATUS Status;
853 DWORD BytesRead;
854 EFI_TPL OldTpl;
855
856 OldTpl = gBS->RaiseTPL (EFI_TPL_CALLBACK);
857
858 Private = WIN_NT_BLOCK_IO_PRIVATE_DATA_FROM_THIS (This);
859
860 Status = WinNtBlockIoReadWriteCommon (Private, MediaId, Lba, BufferSize, Buffer, "WinNtReadBlocks");
861 if (EFI_ERROR (Status)) {
862 goto Done;
863 }
864
865 Flag = Private->WinNtThunk->ReadFile (Private->NtHandle, Buffer, (DWORD) BufferSize, (LPDWORD) &BytesRead, NULL);
866 if (!Flag || (BytesRead != BufferSize)) {
867 DEBUG ((EFI_D_INIT, "ReadBlocks: ReadFile failed. (%d)\n", Private->WinNtThunk->GetLastError ()));
868 Status = WinNtBlockIoError (Private);
869 goto Done;
870 }
871
872 //
873 // If we wrote then media is present.
874 //
875 This->Media->MediaPresent = TRUE;
876 Status = EFI_SUCCESS;
877
878 Done:
879 gBS->RestoreTPL (OldTpl);
880 return Status;
881 }
882
883 STATIC
884 EFI_STATUS
885 EFIAPI
886 WinNtBlockIoWriteBlocks (
887 IN EFI_BLOCK_IO_PROTOCOL *This,
888 IN UINT32 MediaId,
889 IN EFI_LBA Lba,
890 IN UINTN BufferSize,
891 IN VOID *Buffer
892 )
893 /*++
894
895 Routine Description:
896 Write BufferSize bytes from Lba into Buffer.
897
898 Arguments:
899 This - Protocol instance pointer.
900 MediaId - Id of the media, changes every time the media is replaced.
901 Lba - The starting Logical Block Address to read from
902 BufferSize - Size of Buffer, must be a multiple of device block size.
903 Buffer - Buffer containing read data
904
905 Returns:
906 EFI_SUCCESS - The data was written correctly to the device.
907 EFI_WRITE_PROTECTED - The device can not be written to.
908 EFI_DEVICE_ERROR - The device reported an error while performing the write.
909 EFI_NO_MEDIA - There is no media in the device.
910 EFI_MEDIA_CHNAGED - The MediaId does not matched the current device.
911 EFI_BAD_BUFFER_SIZE - The Buffer was not a multiple of the block size of the
912 device.
913 EFI_INVALID_PARAMETER - The write request contains a LBA that is not
914 valid for the device.
915
916 --*/
917 {
918 WIN_NT_BLOCK_IO_PRIVATE *Private;
919 UINTN BytesWritten;
920 BOOL Flag;
921 EFI_STATUS Status;
922 EFI_TPL OldTpl;
923
924 OldTpl = gBS->RaiseTPL (EFI_TPL_CALLBACK);
925
926 Private = WIN_NT_BLOCK_IO_PRIVATE_DATA_FROM_THIS (This);
927
928 Status = WinNtBlockIoReadWriteCommon (Private, MediaId, Lba, BufferSize, Buffer, "WinNtWriteBlocks");
929 if (EFI_ERROR (Status)) {
930 goto Done;
931 }
932
933 Flag = Private->WinNtThunk->WriteFile (Private->NtHandle, Buffer, (DWORD) BufferSize, (LPDWORD) &BytesWritten, NULL);
934 if (!Flag || (BytesWritten != BufferSize)) {
935 DEBUG ((EFI_D_INIT, "ReadBlocks: WriteFile failed. (%d)\n", Private->WinNtThunk->GetLastError ()));
936 Status = WinNtBlockIoError (Private);
937 goto Done;
938 }
939
940 //
941 // If the write succeeded, we are not write protected and media is present.
942 //
943 This->Media->MediaPresent = TRUE;
944 This->Media->ReadOnly = FALSE;
945 Status = EFI_SUCCESS;
946
947 Done:
948 gBS->RestoreTPL (OldTpl);
949 return Status;
950
951 }
952
953 STATIC
954 EFI_STATUS
955 EFIAPI
956 WinNtBlockIoFlushBlocks (
957 IN EFI_BLOCK_IO_PROTOCOL *This
958 )
959 /*++
960
961 Routine Description:
962 Flush the Block Device.
963
964 Arguments:
965 This - Protocol instance pointer.
966
967 Returns:
968 EFI_SUCCESS - All outstanding data was written to the device
969 EFI_DEVICE_ERROR - The device reported an error while writting back the data
970 EFI_NO_MEDIA - There is no media in the device.
971
972 --*/
973 {
974 return EFI_SUCCESS;
975 }
976
977 STATIC
978 EFI_STATUS
979 EFIAPI
980 WinNtBlockIoResetBlock (
981 IN EFI_BLOCK_IO_PROTOCOL *This,
982 IN BOOLEAN ExtendedVerification
983 )
984 /*++
985
986 Routine Description:
987 Reset the Block Device.
988
989 Arguments:
990 This - Protocol instance pointer.
991 ExtendedVerification - Driver may perform diagnostics on reset.
992
993 Returns:
994 EFI_SUCCESS - The device was reset.
995 EFI_DEVICE_ERROR - The device is not functioning properly and could
996 not be reset.
997
998 --*/
999 {
1000 WIN_NT_BLOCK_IO_PRIVATE *Private;
1001 EFI_TPL OldTpl;
1002
1003 OldTpl = gBS->RaiseTPL (EFI_TPL_CALLBACK);
1004
1005 Private = WIN_NT_BLOCK_IO_PRIVATE_DATA_FROM_THIS (This);
1006
1007 if (Private->NtHandle != INVALID_HANDLE_VALUE) {
1008 Private->WinNtThunk->CloseHandle (Private->NtHandle);
1009 Private->NtHandle = INVALID_HANDLE_VALUE;
1010 }
1011
1012 gBS->RestoreTPL (OldTpl);
1013
1014 return EFI_SUCCESS;
1015 }
1016
1017 UINTN
1018 Atoi (
1019 CHAR16 *String
1020 )
1021 /*++
1022
1023 Routine Description:
1024
1025 Convert a unicode string to a UINTN
1026
1027 Arguments:
1028
1029 String - Unicode string.
1030
1031 Returns:
1032
1033 UINTN of the number represented by String.
1034
1035 --*/
1036 {
1037 UINTN Number;
1038 CHAR16 *Str;
1039
1040 //
1041 // skip preceeding white space
1042 //
1043 Str = String;
1044 while ((*Str) && (*Str == ' ')) {
1045 Str++;
1046 }
1047 //
1048 // Convert ot a Number
1049 //
1050 Number = 0;
1051 while (*Str != '\0') {
1052 if ((*Str >= '0') && (*Str <= '9')) {
1053 Number = (Number * 10) +*Str - '0';
1054 } else {
1055 break;
1056 }
1057
1058 Str++;
1059 }
1060
1061 return Number;
1062 }
1063
1064 EFI_STATUS
1065 SetFilePointer64 (
1066 IN WIN_NT_BLOCK_IO_PRIVATE *Private,
1067 IN INT64 DistanceToMove,
1068 OUT UINT64 *NewFilePointer,
1069 IN DWORD MoveMethod
1070 )
1071 /*++
1072
1073 This function extends the capability of SetFilePointer to accept 64 bit parameters
1074
1075 --*/
1076 // TODO: function comment is missing 'Routine Description:'
1077 // TODO: function comment is missing 'Arguments:'
1078 // TODO: function comment is missing 'Returns:'
1079 // TODO: Private - add argument and description to function comment
1080 // TODO: DistanceToMove - add argument and description to function comment
1081 // TODO: NewFilePointer - add argument and description to function comment
1082 // TODO: MoveMethod - add argument and description to function comment
1083 {
1084 EFI_STATUS Status;
1085 LARGE_INTEGER LargeInt;
1086 UINT32 ErrorCode;
1087
1088 LargeInt.QuadPart = DistanceToMove;
1089 Status = EFI_SUCCESS;
1090
1091 LargeInt.LowPart = Private->WinNtThunk->SetFilePointer (
1092 Private->NtHandle,
1093 LargeInt.LowPart,
1094 &LargeInt.HighPart,
1095 MoveMethod
1096 );
1097
1098 if (LargeInt.LowPart == -1 &&
1099 (ErrorCode = Private->WinNtThunk->GetLastError ()) != NO_ERROR) {
1100 Status = EFI_INVALID_PARAMETER;
1101 }
1102
1103 if (NewFilePointer != NULL) {
1104 *NewFilePointer = LargeInt.QuadPart;
1105 }
1106
1107 return Status;
1108 }