VirtualBox

source: vbox/trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/FvSimpleFileSystemDxe/FvSimpleFileSystemEntryPoint.c

Last change on this file was 99404, checked in by vboxsync, 22 months ago

Devices/EFI/FirmwareNew: Update to edk2-stable202302 and make it build, bugref:4643
  • Property svn:eol-style set to native
File size: 21.1 KB
Line 
1/** @file
2 This driver uses the EFI_FIRMWARE_VOLUME2_PROTOCOL to expose files in firmware
3 volumes via the the EFI_SIMPLE_FILESYSTEM_PROTOCOL and EFI_FILE_PROTOCOL.
4
5 It will expose a single directory, containing one file for each file in the firmware
6 volume. If a file has a UI section, its contents will be used as a filename.
7 Otherwise, a string representation of the GUID will be used.
8 Files of an executable type (That is PEIM, DRIVER, COMBINED_PEIM_DRIVER and APPLICATION)
9 will have ".efi" added to their filename.
10
11 Its primary intended use is to be able to start EFI applications embedded in FVs
12 from the UEFI shell. It is entirely read-only.
13
14Copyright (c) 2014, ARM Limited. All rights reserved.
15Copyright (c) 2014 - 2016, Intel Corporation. All rights reserved.<BR>
16
17SPDX-License-Identifier: BSD-2-Clause-Patent
18
19**/
20
21#include "FvSimpleFileSystemInternal.h"
22
23EFI_UNICODE_COLLATION_PROTOCOL *mUnicodeCollation = NULL;
24
25//
26// A Guid string is 32 hex characters with 4 hyphens and a NULL-terminated char: 37 characters total
27//
28#define GUID_STRING_SIZE (37 * sizeof (CHAR16))
29
30#define FVFS_VOLUME_LABEL_PREFIX L"Firmware Volume: "
31#define FVFS_VOLUME_LABEL_SIZE (sizeof (FVFS_VOLUME_LABEL_PREFIX) + GUID_STRING_SIZE - sizeof (CHAR16))
32#define FVFS_FALLBACK_VOLUME_LABEL L"Firmware Volume"
33
34//
35// Template for EFI_SIMPLE_FILE_SYSTEM_PROTOCOL data structure.
36//
37EFI_SIMPLE_FILE_SYSTEM_PROTOCOL mSimpleFsTemplate = {
38 EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_REVISION,
39 FvSimpleFileSystemOpenVolume
40};
41
42//
43// Template for EFI_DRIVER_BINDING_PROTOCOL data structure.
44//
45EFI_DRIVER_BINDING_PROTOCOL mDriverBinding = {
46 FvSimpleFileSystemDriverSupported,
47 FvSimpleFileSystemDriverStart,
48 FvSimpleFileSystemDriverStop,
49 0,
50 NULL,
51 NULL
52};
53
54/**
55 Open the root directory on a volume.
56
57 @param This A pointer to the volume to open the root directory.
58 @param RootFile A pointer to the location to return the opened file handle for the
59 root directory.
60
61 @retval EFI_SUCCESS The device was opened.
62 @retval EFI_UNSUPPORTED This volume does not support the requested file system type.
63 @retval EFI_NO_MEDIA The device has no medium.
64 @retval EFI_DEVICE_ERROR The device reported an error.
65 @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
66 @retval EFI_ACCESS_DENIED The service denied access to the file.
67 @retval EFI_OUT_OF_RESOURCES The volume was not opened due to lack of resources.
68 @retval EFI_MEDIA_CHANGED The device has a different medium in it or the medium is no
69 longer supported. Any existing file handles for this volume are
70 no longer valid. To access the files on the new medium, the
71 volume must be reopened with OpenVolume().
72
73**/
74EFI_STATUS
75EFIAPI
76FvSimpleFileSystemOpenVolume (
77 IN EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *This,
78 OUT EFI_FILE_PROTOCOL **RootFile
79 )
80{
81 EFI_STATUS Status;
82 FV_FILESYSTEM_FILE *Root;
83 CHAR16 *UiSection;
84 EFI_GUID NameGuid;
85 EFI_FV_FILE_ATTRIBUTES Attributes;
86 UINT32 Authentication;
87 UINTN Key;
88 EFI_FV_FILETYPE FileType;
89 UINTN Size;
90 FV_FILESYSTEM_INSTANCE *Instance;
91 FV_FILESYSTEM_FILE_INFO *FvFileInfo;
92 EFI_FIRMWARE_VOLUME2_PROTOCOL *FvProtocol;
93 CHAR16 *Name;
94 UINTN NameLen;
95 UINTN NumChars;
96 UINTN DestMax;
97
98 Instance = FVFS_INSTANCE_FROM_SIMPLE_FS_THIS (This);
99 Status = EFI_SUCCESS;
100
101 if (Instance->Root == NULL) {
102 //
103 // Allocate file structure for root file
104 //
105 Root = AllocateZeroPool (sizeof (FV_FILESYSTEM_FILE));
106 if (Root == NULL) {
107 return EFI_OUT_OF_RESOURCES;
108 }
109
110 Instance->Root = Root;
111 Root->Instance = Instance;
112 Root->Signature = FVFS_FILE_SIGNATURE;
113 CopyMem (&Root->FileProtocol, &mFileSystemTemplate, sizeof (mFileSystemTemplate));
114 Root->FvFileInfo = AllocateZeroPool (sizeof (FV_FILESYSTEM_FILE_INFO));
115 if (Root->FvFileInfo == NULL) {
116 return EFI_OUT_OF_RESOURCES;
117 }
118
119 Root->FvFileInfo->FileInfo.Size = sizeof (EFI_FILE_INFO);
120 Root->FvFileInfo->FileInfo.Attribute = EFI_FILE_DIRECTORY | EFI_FILE_READ_ONLY;
121
122 //
123 // Populate the instance's list of files. We consider anything a file that
124 // has a UI_SECTION, which we consider to be its filename.
125 //
126 FvProtocol = Instance->FvProtocol;
127 //
128 // Allocate Key
129 //
130 Key = 0;
131
132 do {
133 FileType = EFI_FV_FILETYPE_ALL;
134
135 Status = FvProtocol->GetNextFile (
136 FvProtocol,
137 &Key,
138 &FileType,
139 &NameGuid,
140 &Attributes,
141 &Size
142 );
143 if (EFI_ERROR (Status)) {
144 ASSERT (Status == EFI_NOT_FOUND);
145 break;
146 }
147
148 //
149 // Get a file's name: If it has a UI section, use that, otherwise use
150 // its NameGuid.
151 //
152 UiSection = NULL;
153 Status = FvProtocol->ReadSection (
154 FvProtocol,
155 &NameGuid,
156 EFI_SECTION_USER_INTERFACE,
157 0,
158 (VOID **)&UiSection,
159 &Size,
160 &Authentication
161 );
162 if (!EFI_ERROR (Status)) {
163 Name = UiSection;
164 } else {
165 Name = AllocateZeroPool (GUID_STRING_SIZE);
166 if (Name == NULL) {
167 return EFI_OUT_OF_RESOURCES;
168 }
169
170 NumChars = UnicodeSPrint (Name, GUID_STRING_SIZE, L"%g", &NameGuid);
171 ASSERT ((NumChars + 1) * sizeof (CHAR16) == GUID_STRING_SIZE);
172 }
173
174 //
175 // Found a file.
176 // Allocate a file structure and populate it.
177 //
178 NameLen = StrSize (Name);
179 if (FV_FILETYPE_IS_EXECUTABLE (FileType)) {
180 NameLen += StrSize (L".efi") - sizeof (CHAR16);
181 }
182
183 FvFileInfo = AllocateZeroPool (sizeof (FV_FILESYSTEM_FILE_INFO) + NameLen - sizeof (CHAR16));
184 if (FvFileInfo == NULL) {
185 return EFI_OUT_OF_RESOURCES;
186 }
187
188 FvFileInfo->Signature = FVFS_FILE_INFO_SIGNATURE;
189 InitializeListHead (&FvFileInfo->Link);
190 CopyMem (&FvFileInfo->NameGuid, &NameGuid, sizeof (EFI_GUID));
191 FvFileInfo->Type = FileType;
192
193 //
194 // Add ".efi" to filenames of drivers and applications.
195 //
196 DestMax = NameLen / sizeof (CHAR16);
197 Status = StrnCpyS (&FvFileInfo->FileInfo.FileName[0], DestMax, Name, StrLen (Name));
198 ASSERT_EFI_ERROR (Status);
199
200 if (FV_FILETYPE_IS_EXECUTABLE (FileType)) {
201 Status = StrnCatS (&FvFileInfo->FileInfo.FileName[0], DestMax, L".efi", StrLen (L".efi"));
202 ASSERT_EFI_ERROR (Status);
203 }
204
205 FvFileInfo->FileInfo.Size = sizeof (EFI_FILE_INFO) + NameLen - sizeof (CHAR16);
206 Status = FvFsGetFileSize (FvProtocol, FvFileInfo);
207 ASSERT_EFI_ERROR (Status);
208 FvFileInfo->FileInfo.PhysicalSize = FvFileInfo->FileInfo.FileSize;
209 FvFileInfo->FileInfo.Attribute = EFI_FILE_READ_ONLY;
210
211 InsertHeadList (&Instance->FileInfoHead, &FvFileInfo->Link);
212
213 FreePool (Name);
214 } while (TRUE);
215
216 if (Status == EFI_NOT_FOUND) {
217 Status = EFI_SUCCESS;
218 }
219 }
220
221 Instance->Root->DirReadNext = NULL;
222 if (!IsListEmpty (&Instance->FileInfoHead)) {
223 Instance->Root->DirReadNext = FVFS_GET_FIRST_FILE_INFO (Instance);
224 }
225
226 *RootFile = &Instance->Root->FileProtocol;
227 return Status;
228}
229
230/**
231 Worker function to initialize Unicode Collation support.
232
233 It tries to locate Unicode Collation (2) protocol and matches it with current
234 platform language code.
235
236 @param AgentHandle The handle used to open Unicode Collation (2) protocol.
237 @param ProtocolGuid The pointer to Unicode Collation (2) protocol GUID.
238 @param VariableName The name of the RFC 4646 or ISO 639-2 language variable.
239 @param DefaultLanguage The default language in case the RFC 4646 or ISO 639-2 language is absent.
240
241 @retval EFI_SUCCESS The Unicode Collation (2) protocol has been successfully located.
242 @retval Others The Unicode Collation (2) protocol has not been located.
243
244**/
245EFI_STATUS
246InitializeUnicodeCollationSupportWorker (
247 IN EFI_HANDLE AgentHandle,
248 IN EFI_GUID *ProtocolGuid,
249 IN CONST CHAR16 *VariableName,
250 IN CONST CHAR8 *DefaultLanguage
251 )
252{
253 EFI_STATUS ReturnStatus;
254 EFI_STATUS Status;
255 UINTN NumHandles;
256 UINTN Index;
257 EFI_HANDLE *Handles;
258 EFI_UNICODE_COLLATION_PROTOCOL *Uci;
259 BOOLEAN Iso639Language;
260 CHAR8 *Language;
261 CHAR8 *BestLanguage;
262
263 Status = gBS->LocateHandleBuffer (
264 ByProtocol,
265 ProtocolGuid,
266 NULL,
267 &NumHandles,
268 &Handles
269 );
270 if (EFI_ERROR (Status)) {
271 return Status;
272 }
273
274 Iso639Language = (BOOLEAN)(ProtocolGuid == &gEfiUnicodeCollationProtocolGuid);
275 GetEfiGlobalVariable2 (VariableName, (VOID **)&Language, NULL);
276
277 ReturnStatus = EFI_UNSUPPORTED;
278 for (Index = 0; Index < NumHandles; Index++) {
279 //
280 // Open Unicode Collation Protocol
281 //
282 Status = gBS->OpenProtocol (
283 Handles[Index],
284 ProtocolGuid,
285 (VOID **)&Uci,
286 AgentHandle,
287 NULL,
288 EFI_OPEN_PROTOCOL_GET_PROTOCOL
289 );
290 if (EFI_ERROR (Status)) {
291 continue;
292 }
293
294 //
295 // Find the best matching matching language from the supported languages
296 // of Unicode Collation (2) protocol.
297 //
298 BestLanguage = GetBestLanguage (
299 Uci->SupportedLanguages,
300 Iso639Language,
301 (Language == NULL) ? "" : Language,
302 DefaultLanguage,
303 NULL
304 );
305 if (BestLanguage != NULL) {
306 FreePool (BestLanguage);
307 mUnicodeCollation = Uci;
308 ReturnStatus = EFI_SUCCESS;
309 break;
310 }
311 }
312
313 if (Language != NULL) {
314 FreePool (Language);
315 }
316
317 FreePool (Handles);
318
319 return ReturnStatus;
320}
321
322/**
323 Initialize Unicode Collation support.
324
325 It tries to locate Unicode Collation 2 protocol and matches it with current
326 platform language code. If for any reason the first attempt fails, it then tries to
327 use Unicode Collation Protocol.
328
329 @param AgentHandle The handle used to open Unicode Collation (2) protocol.
330
331 @retval EFI_SUCCESS The Unicode Collation (2) protocol has been successfully located.
332 @retval Others The Unicode Collation (2) protocol has not been located.
333
334**/
335EFI_STATUS
336InitializeUnicodeCollationSupport (
337 IN EFI_HANDLE AgentHandle
338 )
339{
340 EFI_STATUS Status;
341
342 Status = EFI_UNSUPPORTED;
343
344 //
345 // First try to use RFC 4646 Unicode Collation 2 Protocol.
346 //
347 Status = InitializeUnicodeCollationSupportWorker (
348 AgentHandle,
349 &gEfiUnicodeCollation2ProtocolGuid,
350 L"PlatformLang",
351 (CONST CHAR8 *)PcdGetPtr (PcdUefiVariableDefaultPlatformLang)
352 );
353 //
354 // If the attempt to use Unicode Collation 2 Protocol fails, then we fall back
355 // on the ISO 639-2 Unicode Collation Protocol.
356 //
357 if (EFI_ERROR (Status)) {
358 Status = InitializeUnicodeCollationSupportWorker (
359 AgentHandle,
360 &gEfiUnicodeCollationProtocolGuid,
361 L"Lang",
362 (CONST CHAR8 *)PcdGetPtr (PcdUefiVariableDefaultLang)
363 );
364 }
365
366 return Status;
367}
368
369/**
370 Test to see if this driver supports ControllerHandle.
371
372 @param DriverBinding Protocol instance pointer.
373 @param ControllerHandle Handle of device to test
374 @param RemainingDevicePath Optional parameter use to pick a specific child
375 device to start.
376
377 @retval EFI_SUCCESS This driver supports this device
378 @retval EFI_ALREADY_STARTED This driver is already running on this device
379 @retval other This driver does not support this device
380
381**/
382EFI_STATUS
383EFIAPI
384FvSimpleFileSystemDriverSupported (
385 IN EFI_DRIVER_BINDING_PROTOCOL *DriverBinding,
386 IN EFI_HANDLE ControllerHandle,
387 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath OPTIONAL
388 )
389{
390 return gBS->OpenProtocol (
391 ControllerHandle,
392 &gEfiFirmwareVolume2ProtocolGuid,
393 NULL,
394 gImageHandle,
395 ControllerHandle,
396 EFI_OPEN_PROTOCOL_TEST_PROTOCOL
397 );
398}
399
400/**
401 Start this driver on ControllerHandle by opening a FV protocol and
402 installing a SimpleFileSystem protocol on ControllerHandle.
403
404 @param DriverBinding Protocol instance pointer.
405 @param ControllerHandle Handle of device to bind driver to
406 @param RemainingDevicePath Optional parameter use to pick a specific child
407 device to start.
408
409 @retval EFI_SUCCESS This driver is added to ControllerHandle
410 @retval EFI_ALREADY_STARTED This driver is already running on ControllerHandle
411 @retval other This driver does not support this device
412
413**/
414EFI_STATUS
415EFIAPI
416FvSimpleFileSystemDriverStart (
417 IN EFI_DRIVER_BINDING_PROTOCOL *DriverBinding,
418 IN EFI_HANDLE ControllerHandle,
419 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath OPTIONAL
420 )
421{
422 EFI_STATUS Status;
423 EFI_FIRMWARE_VOLUME2_PROTOCOL *FvProtocol;
424 FV_FILESYSTEM_INSTANCE *Instance;
425 EFI_DEVICE_PATH_PROTOCOL *FvDevicePath;
426 EFI_GUID *FvGuid;
427 UINTN NumChars;
428
429 Status = InitializeUnicodeCollationSupport (DriverBinding->DriverBindingHandle);
430 if (EFI_ERROR (Status)) {
431 return Status;
432 }
433
434 //
435 // Open FV protocol
436 //
437 Status = gBS->OpenProtocol (
438 ControllerHandle,
439 &gEfiFirmwareVolume2ProtocolGuid,
440 (VOID **)&FvProtocol,
441 gImageHandle,
442 ControllerHandle,
443 EFI_OPEN_PROTOCOL_BY_DRIVER
444 );
445 if (EFI_ERROR (Status)) {
446 return Status;
447 }
448
449 //
450 // Create an instance
451 //
452 Instance = AllocateZeroPool (sizeof (FV_FILESYSTEM_INSTANCE));
453 ASSERT (Instance != NULL);
454
455 Instance->Root = NULL;
456 Instance->FvProtocol = FvProtocol;
457 Instance->Signature = FVFS_INSTANCE_SIGNATURE;
458 InitializeListHead (&Instance->FileInfoHead);
459 InitializeListHead (&Instance->FileHead);
460 CopyMem (&Instance->SimpleFs, &mSimpleFsTemplate, sizeof (mSimpleFsTemplate));
461
462 Status = gBS->InstallProtocolInterface (
463 &ControllerHandle,
464 &gEfiSimpleFileSystemProtocolGuid,
465 EFI_NATIVE_INTERFACE,
466 &Instance->SimpleFs
467 );
468 ASSERT_EFI_ERROR (Status);
469
470 //
471 // Decide on a filesystem volume label, which will include the FV's guid.
472 // Get the device path to find the FV's GUID
473 //
474 Instance->VolumeLabel = NULL;
475 Status = gBS->OpenProtocol (
476 ControllerHandle,
477 &gEfiDevicePathProtocolGuid,
478 (VOID **)&FvDevicePath,
479 gImageHandle,
480 ControllerHandle,
481 EFI_OPEN_PROTOCOL_GET_PROTOCOL
482 );
483 if (!EFI_ERROR (Status)) {
484 //
485 // Iterate over device path until we find a firmware volume node
486 //
487 while (!IsDevicePathEndType (FvDevicePath)) {
488 if ((DevicePathType (FvDevicePath) == MEDIA_DEVICE_PATH) &&
489 (DevicePathSubType (FvDevicePath) == MEDIA_PIWG_FW_VOL_DP))
490 {
491 //
492 // Allocate the volume label
493 //
494 Instance->VolumeLabel = AllocateZeroPool (FVFS_VOLUME_LABEL_SIZE);
495 //
496 // Check the allocation was successful
497 //
498 if (Instance->VolumeLabel != NULL) {
499 //
500 // Extract the FV's guid
501 //
502 FvGuid = &((MEDIA_FW_VOL_DEVICE_PATH *)FvDevicePath)->FvName;
503 //
504 // Build the volume label string
505 //
506 NumChars = UnicodeSPrint (
507 Instance->VolumeLabel,
508 FVFS_VOLUME_LABEL_SIZE,
509 FVFS_VOLUME_LABEL_PREFIX L"%g",
510 FvGuid
511 );
512 ASSERT ((NumChars + 1) * sizeof (CHAR16) == FVFS_VOLUME_LABEL_SIZE);
513 }
514
515 break;
516 }
517
518 FvDevicePath = NextDevicePathNode (FvDevicePath);
519 }
520 }
521
522 //
523 // If we didn't decide on a volume label, set a fallback one
524 //
525 if (Instance->VolumeLabel == NULL) {
526 Instance->VolumeLabel = AllocateCopyPool (
527 sizeof (FVFS_FALLBACK_VOLUME_LABEL),
528 FVFS_FALLBACK_VOLUME_LABEL
529 );
530 }
531
532 return EFI_SUCCESS;
533}
534
535/**
536 Stop this driver on ControllerHandle by removing SimpleFileSystem protocol and closing
537 the FV protocol on ControllerHandle.
538
539 @param DriverBinding Protocol instance pointer.
540 @param ControllerHandle Handle of device to stop driver on
541 @param NumberOfChildren Number of Handles in ChildHandleBuffer. If number of
542 children is zero stop the entire bus driver.
543 @param ChildHandleBuffer List of Child Handles to Stop.
544
545 @retval EFI_SUCCESS This driver is removed ControllerHandle
546 @retval other This driver was not removed from this device
547
548**/
549EFI_STATUS
550EFIAPI
551FvSimpleFileSystemDriverStop (
552 IN EFI_DRIVER_BINDING_PROTOCOL *DriverBinding,
553 IN EFI_HANDLE ControllerHandle,
554 IN UINTN NumberOfChildren,
555 IN EFI_HANDLE *ChildHandleBuffer OPTIONAL
556 )
557{
558 EFI_STATUS Status;
559 FV_FILESYSTEM_INSTANCE *Instance;
560 FV_FILESYSTEM_FILE_INFO *FvFileInfo;
561 LIST_ENTRY *Entry;
562 LIST_ENTRY *DelEntry;
563 EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *SimpleFile;
564
565 Status = gBS->OpenProtocol (
566 ControllerHandle,
567 &gEfiSimpleFileSystemProtocolGuid,
568 (VOID **)&SimpleFile,
569 DriverBinding->DriverBindingHandle,
570 ControllerHandle,
571 EFI_OPEN_PROTOCOL_GET_PROTOCOL
572 );
573 if (EFI_ERROR (Status)) {
574 return Status;
575 }
576
577 Instance = FVFS_INSTANCE_FROM_SIMPLE_FS_THIS (SimpleFile);
578
579 if (IsListEmpty (&Instance->FileHead) == FALSE) {
580 //
581 // Not all opened files are closed
582 //
583 return EFI_DEVICE_ERROR;
584 }
585
586 //
587 // Close and uninstall protocols.
588 //
589 Status = gBS->CloseProtocol (
590 ControllerHandle,
591 &gEfiFirmwareVolume2ProtocolGuid,
592 gImageHandle,
593 ControllerHandle
594 );
595 ASSERT_EFI_ERROR (Status);
596
597 Status = gBS->UninstallProtocolInterface (
598 ControllerHandle,
599 &gEfiSimpleFileSystemProtocolGuid,
600 &Instance->SimpleFs
601 );
602 ASSERT_EFI_ERROR (Status);
603
604 //
605 // Free file structures
606 //
607 if (!IsListEmpty (&Instance->FileInfoHead)) {
608 //
609 // Free the Subtask list.
610 //
611 for (Entry = Instance->FileInfoHead.ForwardLink;
612 Entry != (&Instance->FileInfoHead);
613 )
614 {
615 DelEntry = Entry;
616 Entry = Entry->ForwardLink;
617 FvFileInfo = FVFS_FILE_INFO_FROM_LINK (DelEntry);
618
619 RemoveEntryList (DelEntry);
620 FreePool (FvFileInfo);
621 }
622 }
623
624 if (Instance->Root != NULL) {
625 //
626 // Root->Name is statically allocated, no need to free.
627 //
628 if (Instance->Root->FvFileInfo != NULL) {
629 FreePool (Instance->Root->FvFileInfo);
630 }
631
632 FreePool (Instance->Root);
633 }
634
635 //
636 // Free Instance
637 //
638 if (Instance->VolumeLabel != NULL) {
639 FreePool (Instance->VolumeLabel);
640 }
641
642 FreePool (Instance);
643
644 return EFI_SUCCESS;
645}
646
647/**
648 The user Entry Point for module FvSimpleFileSystem. The user code starts with this function.
649
650 @param[in] ImageHandle The firmware allocated handle for the EFI image.
651 @param[in] SystemTable A pointer to the EFI System Table.
652
653 @retval EFI_SUCCESS The entry point is executed successfully.
654 @retval other Some error occurs when executing this entry point.
655
656**/
657EFI_STATUS
658EFIAPI
659FvSimpleFileSystemEntryPoint (
660 IN EFI_HANDLE ImageHandle,
661 IN EFI_SYSTEM_TABLE *SystemTable
662 )
663{
664 EFI_STATUS Status;
665
666 //
667 // Install driver model protocol(s).
668 //
669 Status = EfiLibInstallDriverBindingComponentName2 (
670 ImageHandle,
671 SystemTable,
672 &mDriverBinding,
673 ImageHandle,
674 &gFvSimpleFileSystemComponentName,
675 &gFvSimpleFileSystemComponentName2
676 );
677 ASSERT_EFI_ERROR (Status);
678
679 return Status;
680}
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette