xref: /reactos/boot/environ/lib/io/file.c (revision 48cc7814) 
1 /*
2  * COPYRIGHT:       See COPYING.ARM in the top level directory
3  * PROJECT:         ReactOS UEFI Boot Library
4  * FILE:            boot/environ/lib/io/file.c
5  * PURPOSE:         Boot Library File Management Routines
6  * PROGRAMMER:      Alex Ionescu (alex.ionescu@reactos.org)
7  */
8 
9 /* INCLUDES ******************************************************************/
10 
11 #include "bl.h"
12 
13 /* DATA VARIABLES ************************************************************/
14 
15 PVOID* FileTable;
16 ULONG FileEntries;
17 
18 LIST_ENTRY RegisteredFileSystems;
19 BL_FILE_SYSTEM_REGISTRATION_TABLE FatRegisterFunctionTable =
20 {
21     FatInitialize,
22     NULL,
23     FatMount,
24     NULL
25 };
26 BL_FILE_SYSTEM_REGISTRATION_TABLE EtfsRegisterFunctionTable =
27 {
28     EtfsInitialize,
29     NULL,
30     EtfsMount,
31     NULL
32 };
33 
34 extern ULONG DmTableEntries;
35 extern PVOID* DmDeviceTable;
36 
37 /* FUNCTIONS *****************************************************************/
38 
39 PWCHAR
40 FileIoCopyParentDirectoryPath (
41     _In_ PWCHAR FilePath
42     )
43 {
44     SIZE_T PathSize, PathSizeWithNull;
45     PWCHAR Backslash, ParentCopy;
46 
47     PathSize = wcslen(FilePath) * sizeof(WCHAR);
48 
49     PathSizeWithNull = PathSize + sizeof(UNICODE_NULL);
50     if (PathSizeWithNull < PathSize)
51     {
52         return NULL;
53     }
54 
55     ParentCopy = BlMmAllocateHeap(PathSizeWithNull);
56     if (!ParentCopy)
57     {
58         return NULL;
59     }
60     wcsncpy(ParentCopy, FilePath, PathSizeWithNull / sizeof(WCHAR));
61 
62     Backslash = wcsrchr(ParentCopy, '\\');
63     if (!Backslash)
64     {
65         BlMmFreeHeap(ParentCopy);
66         return NULL;
67     }
68 
69     if (Backslash == ParentCopy)
70     {
71         ++Backslash;
72     }
73 
74     *Backslash = UNICODE_NULL;
75     return ParentCopy;
76 }
77 
78 PWCHAR
79 FileIoCopyFileName (
80     _In_ PWCHAR FilePath
81     )
82 {
83     PWCHAR Separator, FileCopy;
84     SIZE_T PathSize;
85 
86     Separator = wcsrchr(FilePath, '\\');
87     if (!Separator)
88     {
89         return NULL;
90     }
91 
92     PathSize = wcslen(Separator) * sizeof(WCHAR);
93 
94     FileCopy = BlMmAllocateHeap(PathSize);
95     if (!FileCopy)
96     {
97         return NULL;
98     }
99 
100     wcsncpy(FileCopy, Separator + 1, PathSize / sizeof(WCHAR));
101     return FileCopy;
102 }
103 
104 BOOLEAN
105 FileTableCompareWithSubsetAttributes (
106     _In_ PVOID Entry,
107     _In_ PVOID Argument1,
108     _In_ PVOID Argument2,
109     _In_ PVOID Argument3,
110     _In_ PVOID Argument4
111     )
112 {
113     PBL_FILE_ENTRY FileEntry = (PBL_FILE_ENTRY)Entry;
114     ULONG DeviceId = *(PULONG)Argument1;
115     PWCHAR FilePath = (PWCHAR)Argument2;
116     ULONG Flags = *(PULONG)Argument3;
117     ULONG Unknown = *(PULONG)Argument4;
118     BOOLEAN Found;
119 
120     Found = FALSE;
121 
122     if ((FileEntry->DeviceId == DeviceId) &&
123         !(_wcsicmp(FileEntry->FilePath, FilePath)) &&
124         (FileEntry->Unknown == Unknown))
125     {
126         if ((!(Flags & 1) || (FileEntry->Flags & 2)) && (!(Flags & 2) || (FileEntry->Flags & 4)))
127         {
128             if ((!(Flags & 4) || (FileEntry->Flags & 0x10000)) && ((Flags & 4) || !(FileEntry->Flags & 0x10000)))
129             {
130                 Found = TRUE;
131             }
132         }
133     }
134     return Found;
135 }
136 
137 BOOLEAN
138 FileTableCompareWithSameAttributes (
139     _In_ PVOID Entry,
140     _In_ PVOID Argument1,
141     _In_ PVOID Argument2,
142     _In_ PVOID Argument3,
143     _In_ PVOID Argument4
144     )
145 {
146     PBL_FILE_ENTRY FileEntry = (PBL_FILE_ENTRY)Entry;
147     ULONG DeviceId = *(PULONG)Argument1;
148     PWCHAR FilePath = (PWCHAR)Argument2;
149     ULONG Flags = *(PULONG)Argument3;
150     ULONG Unknown = *(PULONG)Argument4;
151     BOOLEAN Found;
152 
153     Found = FALSE;
154 
155     if ((FileEntry->DeviceId == DeviceId) &&
156         !(_wcsicmp(FileEntry->FilePath, FilePath)) &&
157         (FileEntry->Unknown == Unknown))
158     {
159         if ((!(Flags & 1) || (FileEntry->Flags & 2)) && ((Flags & 1) || !(FileEntry->Flags & 2)) && (!(Flags & 2) || (FileEntry->Flags & 4)) && ((Flags & 2) || !(FileEntry->Flags & 4)))
160         {
161             if ((!(Flags & 4) || (FileEntry->Flags & 0x10000)) && ((Flags & 4) || !(FileEntry->Flags & 0x10000)))
162             {
163                 Found = TRUE;
164             }
165         }
166     }
167     return Found;
168 }
169 
170 NTSTATUS
171 FileTableDestroyEntry (
172     _In_ PBL_FILE_ENTRY FileEntry,
173     _In_ ULONG Index
174     )
175 {
176     ULONG DeviceId;
177     PBL_DEVICE_ENTRY DeviceEntry;
178     NTSTATUS Status;
179 
180     DeviceId = FileEntry->DeviceId;
181     if (DmTableEntries > DeviceId)
182     {
183         DeviceEntry = DmDeviceTable[DeviceId];
184         if (DeviceEntry)
185         {
186             --DeviceEntry->ReferenceCount;
187         }
188     }
189 
190     Status = FileEntry->Callbacks.Close(FileEntry);
191 
192     BlMmFreeHeap(FileEntry);
193 
194     FileTable[Index] = NULL;
195     return Status;
196 }
197 
198 #define BL_FILE_PURGE_LIMIT 512
199 
200 NTSTATUS
201 FileTablePurgeEntry (
202     _In_ PVOID Entry
203     )
204 {
205     PBL_FILE_ENTRY FileEntry = (PBL_FILE_ENTRY)Entry;
206 
207     /* Don't purge opened files, or if there's less than 512 files cached */
208     if (((FileEntry->Flags & BL_FILE_ENTRY_OPENED) ||
209         (FileEntry->Flags & 0x10000)) &&
210         (FileEntries < BL_FILE_PURGE_LIMIT))
211     {
212         return STATUS_UNSUCCESSFUL;
213     }
214 
215     /* Purge the entry otherwise */
216     return FileTableDestroyEntry(FileEntry, FileEntry->FileId);
217 }
218 
219 NTSTATUS
220 BlFileClose (
221     _In_ ULONG FileId
222     )
223 {
224     PBL_FILE_ENTRY FileEntry;
225 
226     /* Validate the file ID */
227     if (FileEntries <= FileId)
228     {
229         return STATUS_INVALID_PARAMETER;
230     }
231 
232     /* Make sure a file entry actually exists */
233     FileEntry = FileTable[FileId];
234     if (!FileEntry)
235     {
236         return STATUS_INVALID_PARAMETER;
237     }
238 
239     /* And that it's actually open */
240     if (!(FileEntry->Flags & BL_FILE_ENTRY_OPENED))
241     {
242         return STATUS_INVALID_PARAMETER;
243     }
244 
245     /* Drop a reference, check if this was the last one */
246     --FileEntry->ReferenceCount;
247     if (!FileEntry->ReferenceCount)
248     {
249         /* File is no longer open */
250         FileEntry->Flags &= ~BL_FILE_ENTRY_OPENED;
251     }
252 
253     /* All good */
254     return STATUS_SUCCESS;
255 }
256 
257 NTSTATUS
258 FileIoOpen (
259     _In_ ULONG DeviceId,
260     _In_ PWCHAR FileName,
261     _In_ ULONG Flags,
262     _In_ ULONG Unknown,
263     _In_ PBL_TBL_LOOKUP_ROUTINE CompareRoutine,
264     _Out_opt_ PBL_FILE_ENTRY *NewFileEntry
265     )
266 {
267     PWCHAR FileNameCopy, ParentFileName;
268     NTSTATUS Status;
269     PBL_DEVICE_ENTRY DeviceEntry;
270     PBL_FILE_SYSTEM_ENTRY FileSystem;
271     ULONG FileId, CheckFlags;
272     PBL_FILE_ENTRY DirectoryEntry, FileEntry;
273     PLIST_ENTRY NextEntry, ListHead;
274 
275     /* Preinitialize variables for failure */
276     DirectoryEntry = NULL;
277     FileNameCopy = NULL;
278     ParentFileName = NULL;
279     Status = STATUS_SUCCESS;
280 
281     /* Bail out if the device ID is invalid */
282     if (DmTableEntries <= DeviceId)
283     {
284         return STATUS_ACCESS_DENIED;
285     }
286 
287     /* Bail out if there's no device entry */
288     DeviceEntry = DmDeviceTable[DeviceId];
289     if (!DeviceEntry)
290     {
291         return STATUS_ACCESS_DENIED;
292     }
293 
294     /* Read access is always required for touching the device */
295     CheckFlags = Flags | BL_FILE_READ_ACCESS;
296 
297     /* Check if the device is granting us read access */
298     if ((CheckFlags & BL_FILE_READ_ACCESS) &&
299         (!(DeviceEntry->Flags & BL_DEVICE_ENTRY_OPENED) ||
300          !(DeviceEntry->Flags & BL_DEVICE_ENTRY_READ_ACCESS)))
301     {
302         EfiPrintf(L"Access denied\r\n");
303         return STATUS_ACCESS_DENIED;
304     }
305 
306     /* Check if the device is granting us write access */
307     if ((CheckFlags & BL_FILE_WRITE_ACCESS) &&
308         (!(DeviceEntry->Flags & BL_DEVICE_ENTRY_OPENED) ||
309          !(DeviceEntry->Flags & BL_DEVICE_ENTRY_WRITE_ACCESS)))
310     {
311         EfiPrintf(L"Access denied2\r\n");
312         return STATUS_ACCESS_DENIED;
313     }
314 
315     /* Check if we already have this file open */
316     FileEntry = (PBL_FILE_ENTRY )BlTblFindEntry(FileTable,
317                                                 FileEntries,
318                                                 &FileId,
319                                                 CompareRoutine,
320                                                 &DeviceId,
321                                                 FileName,
322                                                 &Flags,
323                                                 &Unknown);
324     if (FileEntry)
325     {
326         goto FileOpened;
327     }
328 
329     /* Check if we are opening the root drive or an actual file/directory */
330     if ((*FileName != OBJ_NAME_PATH_SEPARATOR) || (FileName[1]))
331     {
332         /* Get the name of the directory */
333         ParentFileName = FileIoCopyParentDirectoryPath(FileName);
334         if (!ParentFileName)
335         {
336             Status = STATUS_NO_MEMORY;
337             goto Quickie;
338         }
339 
340         /* Open it */
341         Status = FileIoOpen(DeviceId,
342                             ParentFileName,
343                             BL_FILE_READ_ACCESS | BL_DIRECTORY_ACCESS,
344                             Unknown,
345                             FileTableCompareWithSubsetAttributes,
346                             &DirectoryEntry);
347         if (!NT_SUCCESS(Status))
348         {
349             goto Quickie;
350         }
351 
352         /* Now get the the file name itself */
353         FileNameCopy = FileIoCopyFileName(FileName);
354         if (!FileNameCopy)
355         {
356             Status = STATUS_NO_MEMORY;
357             goto Quickie;
358         }
359 
360         /* Open it */
361         Status = DirectoryEntry->Callbacks.Open(DirectoryEntry,
362                                                 FileNameCopy,
363                                                 Flags,
364                                                 &FileEntry);
365     }
366     else
367     {
368         /* We're opening the root, scan through all the file systems */
369         Status = STATUS_UNSUCCESSFUL;
370         ListHead = &RegisteredFileSystems;
371         NextEntry = ListHead->Flink;
372         while (NextEntry != ListHead)
373         {
374             /* Try to mount this one */
375             FileSystem = CONTAINING_RECORD(NextEntry, BL_FILE_SYSTEM_ENTRY, ListEntry);
376             Status = FileSystem->MountCallback(DeviceId, Unknown, &FileEntry);
377             if (NT_SUCCESS(Status))
378             {
379                 /* Mount successful */
380                 break;
381             }
382 
383             /* Try the next file system */
384             NextEntry = NextEntry->Flink;
385         }
386 
387         /* Nothing to free on this path */
388         FileNameCopy = NULL;
389     }
390 
391     /* Handle failure */
392     if (!NT_SUCCESS(Status))
393     {
394         EfiPrintf(L"Could not open file!: %lx\r\n", Status);
395         goto Quickie;
396     }
397 
398     /* Save the unknown */
399     FileEntry->Unknown = Unknown;
400 
401     /* Convert open flags into entry flags */
402     if (Flags & BL_FILE_READ_ACCESS)
403     {
404         FileEntry->Flags |= BL_FILE_ENTRY_READ_ACCESS;
405     }
406     if (Flags & BL_FILE_WRITE_ACCESS)
407     {
408         FileEntry->Flags |= BL_FILE_ENTRY_WRITE_ACCESS;
409     }
410 
411     /* Save the file into the file table */
412     Status = BlTblSetEntry(&FileTable,
413                            &FileEntries,
414                            (PVOID)FileEntry,
415                            &FileId,
416                            FileTablePurgeEntry);
417     if (!NT_SUCCESS(Status))
418     {
419         /* Close it if that failed */
420         FileEntry->Callbacks.Close(FileEntry);
421         goto Quickie;
422     }
423 
424     /* Add a reference on the device, and save our file ID  */
425     ++DeviceEntry->ReferenceCount;
426     Status = STATUS_SUCCESS;
427     FileEntry->FileId = FileId;
428 
429 FileOpened:
430     /* Add a reference to the file entry, and see if this is the first one */
431     if (++FileEntry->ReferenceCount == 1)
432     {
433         /* Reset unknowns */
434         FileEntry->TotalBytesRead = 0;
435         FileEntry->Unknown2 = 0;
436     }
437 
438     /* Set the file as opened */
439     FileEntry->Flags |= BL_FILE_ENTRY_OPENED;
440 
441     /* Not sure what this flag does */
442     if (Flags & BL_UNKNOWN_ACCESS)
443     {
444         FileEntry->Flags |= BL_FILE_ENTRY_UNKNOWN_ACCESS;
445     }
446 
447     /* If the caller wanted the entry back, return it */
448     if (NewFileEntry)
449     {
450         *NewFileEntry = FileEntry;
451     }
452 
453 Quickie:
454     /* Close the parent */
455     if (DirectoryEntry)
456     {
457         BlFileClose(DirectoryEntry->FileId);
458     }
459 
460     /* Free the parent name copy */
461     if (ParentFileName)
462     {
463         BlMmFreeHeap(ParentFileName);
464     }
465 
466     /* Free the file name copy */
467     if (FileNameCopy)
468     {
469         BlMmFreeHeap(FileNameCopy);
470     }
471 
472     /* Return back to caller */
473     return Status;
474 }
475 
476 NTSTATUS
477 BlFileOpen (
478     _In_ ULONG DeviceId,
479     _In_ PWCHAR FileName,
480     _In_ ULONG Flags,
481     _Out_ PULONG FileId
482     )
483 {
484     NTSTATUS Status;
485     PBL_FILE_ENTRY FileEntry;
486     BL_DEVICE_INFORMATION DeviceInformation;
487 
488     /* Make sure we have a valid file name, access flags and parameters */
489     if (!(FileName) ||
490         (*FileName != OBJ_NAME_PATH_SEPARATOR) ||
491         !(FileId) ||
492         !(Flags & (BL_FILE_READ_ACCESS | BL_FILE_WRITE_ACCESS)))
493     {
494         EfiPrintf(L"Invalid file options\r\n");
495         return STATUS_INVALID_PARAMETER;
496     }
497 
498     /* Get information on the underlying device */
499     Status = BlDeviceGetInformation(DeviceId, &DeviceInformation);
500     if (!NT_SUCCESS(Status))
501     {
502         EfiPrintf(L"Get device info failed: %lx\r\n", Status);
503         return Status;
504     }
505 
506     /* Make sure it's a device that can host files */
507     if ((DeviceInformation.DeviceType != DiskDevice) &&
508         (DeviceInformation.DeviceType != LegacyPartitionDevice) &&
509         (DeviceInformation.DeviceType != UdpDevice))
510     {
511         EfiPrintf(L"Invalid device type\r\n");
512         return STATUS_INVALID_PARAMETER;
513     }
514 
515     /* Open a file on this device, creating one if needed */
516     Status = FileIoOpen(DeviceId,
517                         FileName,
518                         Flags,
519                         0,
520                         FileTableCompareWithSameAttributes,
521                         &FileEntry);
522     if (NT_SUCCESS(Status))
523     {
524         /* Return the file ID back to the caller */
525         *FileId = FileEntry->FileId;
526     }
527 
528     /* All good */
529     return Status;
530 }
531 
532 NTSTATUS
533 BlFileSetInformation (
534     _In_ ULONG FileId,
535     _Out_ PBL_FILE_INFORMATION FileInfo
536     )
537 {
538     PBL_FILE_ENTRY FileEntry;
539 
540     /* Make sure caller passed this in */
541     if (!FileInfo)
542     {
543         return STATUS_INVALID_PARAMETER;
544     }
545 
546     /* Validate file ID */
547     if (FileId > FileEntries)
548     {
549         return STATUS_INVALID_PARAMETER;
550     }
551 
552     /* Make sure an opened file exits with this ID */
553     FileEntry = FileTable[FileId];
554     if (!(FileEntry) || !(FileEntry->Flags & BL_FILE_ENTRY_OPENED))
555     {
556         return STATUS_INVALID_PARAMETER;
557     }
558 
559     /* Do the I/O operation */
560     return FileEntry->Callbacks.SetInfo(FileEntry, FileInfo);
561 }
562 
563 NTSTATUS
564 BlFileGetInformation (
565     _In_ ULONG FileId,
566     _In_ PBL_FILE_INFORMATION FileInfo
567     )
568 {
569     PBL_FILE_ENTRY FileEntry;
570 
571     /* Make sure caller passed this in */
572     if (!FileInfo)
573     {
574         return STATUS_INVALID_PARAMETER;
575     }
576 
577     /* Validate file ID */
578     if (FileId > FileEntries)
579     {
580         return STATUS_INVALID_PARAMETER;
581     }
582 
583     /* Make sure an opened file exits with this ID */
584     FileEntry = FileTable[FileId];
585     if (!(FileEntry) || !(FileEntry->Flags & BL_FILE_ENTRY_OPENED))
586     {
587         return STATUS_INVALID_PARAMETER;
588     }
589 
590     /* Do the I/O operation */
591     return FileEntry->Callbacks.GetInfo(FileEntry, FileInfo);
592 }
593 
594 NTSTATUS
595 FileInformationCheck (
596     _In_ PBL_FILE_INFORMATION FileInformation,
597     _In_ BOOLEAN Write,
598     _In_opt_ PULONG InputSize,
599     _In_opt_ PULONG BytesReturned,
600     _Out_opt_ PULONG RequiredSize
601     )
602 {
603     NTSTATUS Status;
604     ULONG Size;
605 
606     /* Initialize variables */
607     Status = STATUS_SUCCESS;
608     Size = 0;
609 
610     /* Make sure we didn't overshoot */
611     if (FileInformation->Offset > FileInformation->Size)
612     {
613         /* Bail out */
614         Status = STATUS_INVALID_PARAMETER;
615         goto Quickie;
616     }
617 
618     /* Compute the appropriate 32-bit size of this read, based on file size */
619     Size = ULONG_MAX;
620     if ((FileInformation->Size - FileInformation->Offset) <= ULONG_MAX)
621     {
622         Size = (ULONG)(FileInformation->Size) - (ULONG)(FileInformation->Offset);
623     }
624 
625     /* Check if the caller has an input buffer */
626     if (InputSize)
627     {
628         /* Is the size bigger than what the caller can handle? */
629         if (Size >= *InputSize)
630         {
631             /* Yes, so cap it at the size of the caller's buffer */
632             Size = *InputSize;
633         }
634         else if (!(BytesReturned) || (Write))
635         {
636             /* Caller's input buffer is too smaller is fatal for writes */
637             Status = STATUS_INVALID_PARAMETER;
638             goto Quickie;
639         }
640     }
641 
642 Quickie:
643     /* Does the caller want to know how big to make their buffer? */
644     if (RequiredSize)
645     {
646         /* Let them know*/
647         *RequiredSize = Size;
648     }
649 
650     /* Return final status */
651     return Status;
652 }
653 
654 NTSTATUS
655 BlFileReadEx (
656     _In_ ULONG FileId,
657     _Out_ PVOID Buffer,
658     _In_ ULONG Size,
659     _Out_ PULONG BytesReturned,
660     _In_ ULONG Flags
661     )
662 {
663     PBL_FILE_ENTRY FileEntry;
664     NTSTATUS Status;
665     ULONG OldUnknown, RequiredSize;
666     BOOLEAN ChangedUnknown;
667     BL_DEVICE_INFORMATION DeviceInfo;
668     BL_FILE_INFORMATION fileInfo;
669 
670     /* Initialize variables */
671     RtlZeroMemory(&DeviceInfo, sizeof(DeviceInfo));
672     OldUnknown = 0;
673     ChangedUnknown = FALSE;
674 
675     /* Bail out if there's no buffer */
676     if (!Buffer)
677     {
678         return STATUS_INVALID_PARAMETER;
679     }
680 
681     /* Bail out of the file ID is invalid */
682     if (FileId > FileEntries)
683     {
684         return STATUS_INVALID_PARAMETER;
685     }
686 
687     /* Bail out if there's no file opened for read access */
688     FileEntry = FileTable[FileId];
689     if (!(FileEntry) ||
690         !(FileEntry->Flags & (BL_FILE_ENTRY_OPENED | BL_FILE_ENTRY_READ_ACCESS)))
691     {
692         return STATUS_INVALID_PARAMETER;
693     }
694 
695     /* Bail out if we can't read the file's information */
696     Status = BlFileGetInformation(FileId, &fileInfo);
697     if (!NT_SUCCESS(Status))
698     {
699         return Status;
700     }
701 
702     /* Ensure the read attempt is valid, and fix up the size if needed */
703     RequiredSize = Size;
704     Status = FileInformationCheck(&fileInfo,
705                                   FALSE,
706                                   &RequiredSize,
707                                   BytesReturned,
708                                   &RequiredSize);
709     if (!NT_SUCCESS(Status))
710     {
711         /* Invalid or illegal read attempt */
712         return Status;
713     }
714 
715     /* Is there anything left to read after all? */
716     if (RequiredSize)
717     {
718         /* Check if flags 2 or 4 are set */
719         if ((Flags & 2) || (Flags & 4))
720         {
721             /* Check if this is a disk or partition device */
722             BlDeviceGetInformation(FileEntry->DeviceId, &DeviceInfo);
723             if ((DeviceInfo.DeviceType == DiskDevice) ||
724                 (DeviceInfo.DeviceType == LegacyPartitionDevice))
725             {
726                 /* Check if request flags are incompatible with device flags */
727                 if ((!(DeviceInfo.BlockDeviceInfo.Unknown & 1) && (Flags & 2)) ||
728                     (!(DeviceInfo.BlockDeviceInfo.Unknown & 2) && (Flags & 4)))
729                 {
730                     /* We're going to change the device flags */
731                     ChangedUnknown = TRUE;
732 
733                     /* Set unknown flag 1 for request flag 2 */
734                     if (Flags & 2)
735                     {
736                         DeviceInfo.BlockDeviceInfo.Unknown |= 1;
737                     }
738 
739                     /* Set unknown flag 2 for request flag 4 */
740                     if (Flags & 4)
741                     {
742                         DeviceInfo.BlockDeviceInfo.Unknown |= 2;
743                     }
744 
745                     /* Save the new device flags */
746                     BlDeviceSetInformation(FileEntry->DeviceId, &DeviceInfo);
747                 }
748             }
749         }
750 
751         /* Issue the read to the underlying file system */
752         Status = FileEntry->Callbacks.Read(FileEntry,
753                                            Buffer,
754                                            RequiredSize,
755                                            BytesReturned);
756         if (!NT_SUCCESS(Status))
757         {
758             /* Don't update the bytes read on failure */
759             RequiredSize = 0;
760         }
761     }
762     else
763     {
764         /* There's nothing to do, return success and 0 bytes */
765         Status = STATUS_SUCCESS;
766         if (BytesReturned)
767         {
768             *BytesReturned = 0;
769         }
770     }
771 
772     /* Increment the number of bytes read */
773     FileEntry->TotalBytesRead += RequiredSize;
774 
775     /* Check if the unknown flag on the device was changed during this routine */
776     if (ChangedUnknown)
777     {
778         /* Reset it back to its original value */
779         DeviceInfo.BlockDeviceInfo.Unknown = OldUnknown;
780         BlDeviceSetInformation(FileEntry->DeviceId, &DeviceInfo);
781     }
782 
783     /* Return the final status */
784     return Status;
785 }
786 
787 NTSTATUS
788 BlFileReadAtOffsetEx (
789     _In_ ULONG FileId,
790     _In_ ULONG Size,
791     _In_ ULONGLONG ByteOffset,
792     _In_ PVOID Buffer,
793     _Out_ PULONG BytesReturned,
794     _In_ ULONG Flags
795     )
796 {
797     NTSTATUS Status;
798     BL_FILE_INFORMATION FileInfo;
799     ULONG RequiredSize;
800     ULONGLONG FileOffset;
801 
802     /* Get information on the specified file */
803     Status = BlFileGetInformation(FileId, &FileInfo);
804     if (!NT_SUCCESS(Status))
805     {
806         return Status;
807     }
808 
809     /* Save the current offset, and overwrite it with the one we want */
810     FileOffset = FileInfo.Offset;
811     FileInfo.Offset = ByteOffset;
812 
813     /* Check the validity of the read and the actual size to read */
814     RequiredSize = Size;
815     Status = FileInformationCheck(&FileInfo,
816                                   FALSE,
817                                   &RequiredSize,
818                                   BytesReturned,
819                                   &RequiredSize);
820     if (!NT_SUCCESS(Status))
821     {
822         /* Bail out if the read is invalid */
823         EfiPrintf(L"File info check failure: %lx\r\n", Status);
824         return Status;
825     }
826 
827     /* Check if the offset we're requesting is not the current offset */
828     if (FileInfo.Offset != FileOffset)
829     {
830         /* Set the new offset to use */
831         Status = BlFileSetInformation(FileId, &FileInfo);
832         if (!NT_SUCCESS(Status))
833         {
834             /* Can't do much if that failed */
835             return Status;
836         }
837     }
838 
839     /* Do the read at the required offset now */
840     Status = BlFileReadEx(FileId,
841                           Buffer,
842                           RequiredSize,
843                           BytesReturned,
844                           Flags);
845     if (!NT_SUCCESS(Status))
846     {
847         /* The read failed -- had we modified the offset? */
848         if (FileInfo.Offset != FileOffset)
849         {
850             /* Restore the offset back to its original value */
851             FileInfo.Offset = FileOffset;
852             BlFileSetInformation(FileId, &FileInfo);
853         }
854     }
855 
856     /* Return the status of the read */
857     return Status;
858 }
859 
860 NTSTATUS
861 BlpFileRegisterFileSystem (
862     _In_ PBL_FS_INIT_CALLBACK InitCallback,
863     _In_ PBL_FS_DESTROY_CALLBACK DestroyCallback,
864     _In_ PBL_FS_MOUNT_CALLBACK MountCallback,
865     _In_ PBL_FS_PURGE_CALLBACK PurgeCallback,
866     _In_ ULONG Flags
867     )
868 {
869     PBL_FILE_SYSTEM_ENTRY FsEntry;
870     NTSTATUS Status;
871 
872     /* Allocate an entry */
873     FsEntry = BlMmAllocateHeap(sizeof(*FsEntry));
874     if (!FsEntry)
875     {
876         return STATUS_NO_MEMORY;
877     }
878 
879     /* Initialize the file system */
880     Status = InitCallback();
881     if (!NT_SUCCESS(Status))
882     {
883         BlMmFreeHeap(FsEntry);
884         return Status;
885     }
886 
887     /* Register the callbacks */
888     FsEntry->MountCallback = MountCallback;
889     FsEntry->DestroyCallback = DestroyCallback;
890     FsEntry->InitCallback = InitCallback;
891     FsEntry->PurgeCallback = PurgeCallback;
892 
893     /* Insert in the right location in the list */
894     if (Flags & BL_FS_REGISTER_AT_HEAD_FLAG)
895     {
896         InsertHeadList(&RegisteredFileSystems, &FsEntry->ListEntry);
897     }
898     else
899     {
900         InsertTailList(&RegisteredFileSystems, &FsEntry->ListEntry);
901     }
902 
903     /* Return */
904     return STATUS_SUCCESS;
905 }
906 
907 NTSTATUS
908 BlpFileInitialize (
909     VOID
910     )
911 {
912     NTSTATUS Status;
913 
914     /* Allocate the file table */
915     FileEntries = 16;
916     FileTable = BlMmAllocateHeap(sizeof(PBL_FILE_ENTRY) * FileEntries);
917     if (!FileTable)
918     {
919         return STATUS_INVALID_PARAMETER;
920     }
921 
922     /* Initialize it */
923     RtlZeroMemory(FileTable, sizeof(PBL_FILE_ENTRY) * FileEntries);
924     InitializeListHead(&RegisteredFileSystems);
925 
926 #if 0
927     /* Initialize the network file system */
928     Status = BlpFileRegisterFileSystem(NetRegisterFunctionTable.Init,
929                                        NetRegisterFunctionTable.Destroy,
930                                        NetRegisterFunctionTable.Mount,
931                                        NetRegisterFunctionTable.Purge,
932                                        1);
933     if (NT_SUCCESS(Status))
934     {
935         /* Initialize NTFS */
936         Status = BlpFileRegisterFileSystem(NtfsRegisterFunctionTable.Init,
937                                            NtfsRegisterFunctionTable.Destroy,
938                                            NtfsRegisterFunctionTable.Mount,
939                                            NtfsRegisterFunctionTable.Purge,
940                                            0);
941     }
942 
943     if (NT_SUCCESS(Status))
944 #endif
945     {
946         /* Initialize FAT */
947         Status = BlpFileRegisterFileSystem(FatRegisterFunctionTable.Init,
948                                            FatRegisterFunctionTable.Destroy,
949                                            FatRegisterFunctionTable.Mount,
950                                            FatRegisterFunctionTable.Purge,
951                                            0);
952     }
953 
954 #if 0
955     if (NT_SUCCESS(Status))
956     {
957         /* Initialize EXFAT (FatPlus) */
958         Status = BlpFileRegisterFileSystem(FppRegisterFunctionTable.Init,
959                                            FppRegisterFunctionTable.Destroy,
960                                            FppRegisterFunctionTable.Mount,
961                                            FppRegisterFunctionTable.Purge,
962                                            0);
963     }
964 
965     if (NT_SUCCESS(Status))
966     {
967         /* Initialize WIM */
968         Status = BlpFileRegisterFileSystem(WimRegisterFunctionTable.Init,
969                                            WimRegisterFunctionTable.Destroy,
970                                            WimRegisterFunctionTable.Mount,
971                                            WimRegisterFunctionTable.Purge,
972                                            0);
973     }
974 
975     if (NT_SUCCESS(Status))
976     {
977         /* Initialize UDFS */
978         Status = BlpFileRegisterFileSystem(UdfsRegisterFunctionTable.Init,
979                                            UdfsRegisterFunctionTable.Destroy,
980                                            UdfsRegisterFunctionTable.Mount,
981                                            UdfsRegisterFunctionTable.Purge,
982                                            0);
983     }
984 #endif
985     if (NT_SUCCESS(Status))
986     {
987         /* Initialize El-Torito CDFS */
988         Status = BlpFileRegisterFileSystem(EtfsRegisterFunctionTable.Init,
989                                            EtfsRegisterFunctionTable.Destroy,
990                                            EtfsRegisterFunctionTable.Mount,
991                                            EtfsRegisterFunctionTable.Purge,
992                                            0);
993     }
994 
995     /* Destroy the file manager if any of the file systems didn't initialize */
996     if (!NT_SUCCESS(Status))
997     {
998         if (FileTable)
999         {
1000             //BlpFileDestroy();
1001         }
1002     }
1003     return Status;
1004 }
1005