FvSimpleFileSystemEntryPoint.c@ 99396

Last change on this file since 99396 was 80721, checked in by vboxsync, 5 years ago
Devices/EFI/FirmwareNew: Start upgrade process to edk2-stable201908 (compiles on Windows and works to some extent), 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
14	Copyright (c) 2014, ARM Limited. All rights reserved.
15	Copyright (c) 2014 - 2016, Intel Corporation. All rights reserved.<BR>
16
17	SPDX-License-Identifier: BSD-2-Clause-Patent
18
19	**/
20
21	#include "FvSimpleFileSystemInternal.h"
22
23	EFI_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	//
37	EFI_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	//
45	EFI_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	**/
74	EFI_STATUS
75	EFIAPI
76	FvSimpleFileSystemOpenVolume (
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	Root->FvFileInfo->FileInfo.Size = sizeof (EFI_FILE_INFO);
119	Root->FvFileInfo->FileInfo.Attribute = EFI_FILE_DIRECTORY \| EFI_FILE_READ_ONLY;
120
121	//
122	// Populate the instance's list of files. We consider anything a file that
123	// has a UI_SECTION, which we consider to be its filename.
124	//
125	FvProtocol = Instance->FvProtocol;
126	//
127	// Allocate Key
128	//
129	Key = 0;
130
131	do {
132	FileType = EFI_FV_FILETYPE_ALL;
133
134	Status = FvProtocol->GetNextFile (
135	FvProtocol,
136	&Key,
137	&FileType,
138	&NameGuid,
139	&Attributes,
140	&Size
141	);
142	if (EFI_ERROR (Status)) {
143	ASSERT (Status == EFI_NOT_FOUND);
144	break;
145	}
146
147	//
148	// Get a file's name: If it has a UI section, use that, otherwise use
149	// its NameGuid.
150	//
151	UiSection = NULL;
152	Status = FvProtocol->ReadSection (
153	FvProtocol,
154	&NameGuid,
155	EFI_SECTION_USER_INTERFACE,
156	0,
157	(VOID **)&UiSection,
158	&Size,
159	&Authentication
160	);
161	if (!EFI_ERROR (Status)) {
162	Name = UiSection;
163	} else {
164	Name = AllocateZeroPool (GUID_STRING_SIZE);
165	if (Name == NULL) {
166	return EFI_OUT_OF_RESOURCES;
167	}
168	NumChars = UnicodeSPrint (Name, GUID_STRING_SIZE, L"%g", &NameGuid);
169	ASSERT ((NumChars + 1) * sizeof (CHAR16) == GUID_STRING_SIZE);
170	}
171
172	//
173	// Found a file.
174	// Allocate a file structure and populate it.
175	//
176	NameLen = StrSize (Name);
177	if (FV_FILETYPE_IS_EXECUTABLE (FileType)) {
178	NameLen += StrSize (L".efi") - sizeof (CHAR16);
179	}
180
181	FvFileInfo = AllocateZeroPool (sizeof (FV_FILESYSTEM_FILE_INFO) + NameLen - sizeof (CHAR16));
182	if (FvFileInfo == NULL) {
183	return EFI_OUT_OF_RESOURCES;
184	}
185
186	FvFileInfo->Signature = FVFS_FILE_INFO_SIGNATURE;
187	InitializeListHead (&FvFileInfo->Link);
188	CopyMem (&FvFileInfo->NameGuid, &NameGuid, sizeof (EFI_GUID));
189	FvFileInfo->Type = FileType;
190
191	//
192	// Add ".efi" to filenames of drivers and applications.
193	//
194	DestMax = NameLen / sizeof (CHAR16);
195	Status = StrnCpyS (&FvFileInfo->FileInfo.FileName[0], DestMax, Name, StrLen (Name));
196	ASSERT_EFI_ERROR (Status);
197
198	if (FV_FILETYPE_IS_EXECUTABLE (FileType)) {
199	Status = StrnCatS (&FvFileInfo->FileInfo.FileName[0], DestMax, L".efi", StrLen (L".efi"));
200	ASSERT_EFI_ERROR (Status);
201	}
202
203	FvFileInfo->FileInfo.Size = sizeof (EFI_FILE_INFO) + NameLen - sizeof (CHAR16);
204	Status = FvFsGetFileSize (FvProtocol, FvFileInfo);
205	ASSERT_EFI_ERROR (Status);
206	FvFileInfo->FileInfo.PhysicalSize = FvFileInfo->FileInfo.FileSize;
207	FvFileInfo->FileInfo.Attribute = EFI_FILE_READ_ONLY;
208
209	InsertHeadList (&Instance->FileInfoHead, &FvFileInfo->Link);
210
211	FreePool (Name);
212
213	} while (TRUE);
214
215	if (Status == EFI_NOT_FOUND) {
216	Status = EFI_SUCCESS;
217	}
218	}
219
220	Instance->Root->DirReadNext = NULL;
221	if (!IsListEmpty (&Instance->FileInfoHead)) {
222	Instance->Root->DirReadNext = FVFS_GET_FIRST_FILE_INFO (Instance);
223	}
224
225	*RootFile = &Instance->Root->FileProtocol;
226	return Status;
227	}
228
229	/**
230	Worker function to initialize Unicode Collation support.
231
232	It tries to locate Unicode Collation (2) protocol and matches it with current
233	platform language code.
234
235	@param AgentHandle The handle used to open Unicode Collation (2) protocol.
236	@param ProtocolGuid The pointer to Unicode Collation (2) protocol GUID.
237	@param VariableName The name of the RFC 4646 or ISO 639-2 language variable.
238	@param DefaultLanguage The default language in case the RFC 4646 or ISO 639-2 language is absent.
239
240	@retval EFI_SUCCESS The Unicode Collation (2) protocol has been successfully located.
241	@retval Others The Unicode Collation (2) protocol has not been located.
242
243	**/
244	EFI_STATUS
245	InitializeUnicodeCollationSupportWorker (
246	IN EFI_HANDLE AgentHandle,
247	IN EFI_GUID *ProtocolGuid,
248	IN CONST CHAR16 *VariableName,
249	IN CONST CHAR8 *DefaultLanguage
250	)
251	{
252	EFI_STATUS ReturnStatus;
253	EFI_STATUS Status;
254	UINTN NumHandles;
255	UINTN Index;
256	EFI_HANDLE *Handles;
257	EFI_UNICODE_COLLATION_PROTOCOL *Uci;
258	BOOLEAN Iso639Language;
259	CHAR8 *Language;
260	CHAR8 *BestLanguage;
261
262	Status = gBS->LocateHandleBuffer (
263	ByProtocol,
264	ProtocolGuid,
265	NULL,
266	&NumHandles,
267	&Handles
268	);
269	if (EFI_ERROR (Status)) {
270	return Status;
271	}
272
273	Iso639Language = (BOOLEAN) (ProtocolGuid == &gEfiUnicodeCollationProtocolGuid);
274	GetEfiGlobalVariable2 (VariableName, (VOID**) &Language, NULL);
275
276	ReturnStatus = EFI_UNSUPPORTED;
277	for (Index = 0; Index < NumHandles; Index++) {
278	//
279	// Open Unicode Collation Protocol
280	//
281	Status = gBS->OpenProtocol (
282	Handles[Index],
283	ProtocolGuid,
284	(VOID **) &Uci,
285	AgentHandle,
286	NULL,
287	EFI_OPEN_PROTOCOL_GET_PROTOCOL
288	);
289	if (EFI_ERROR (Status)) {
290	continue;
291	}
292
293	//
294	// Find the best matching matching language from the supported languages
295	// of Unicode Collation (2) protocol.
296	//
297	BestLanguage = GetBestLanguage (
298	Uci->SupportedLanguages,
299	Iso639Language,
300	(Language == NULL) ? "" : Language,
301	DefaultLanguage,
302	NULL
303	);
304	if (BestLanguage != NULL) {
305	FreePool (BestLanguage);
306	mUnicodeCollation = Uci;
307	ReturnStatus = EFI_SUCCESS;
308	break;
309	}
310	}
311
312	if (Language != NULL) {
313	FreePool (Language);
314	}
315
316	FreePool (Handles);
317
318	return ReturnStatus;
319	}
320
321	/**
322	Initialize Unicode Collation support.
323
324	It tries to locate Unicode Collation 2 protocol and matches it with current
325	platform language code. If for any reason the first attempt fails, it then tries to
326	use Unicode Collation Protocol.
327
328	@param AgentHandle The handle used to open Unicode Collation (2) protocol.
329
330	@retval EFI_SUCCESS The Unicode Collation (2) protocol has been successfully located.
331	@retval Others The Unicode Collation (2) protocol has not been located.
332
333	**/
334	EFI_STATUS
335	InitializeUnicodeCollationSupport (
336	IN EFI_HANDLE AgentHandle
337	)
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	**/
382	EFI_STATUS
383	EFIAPI
384	FvSimpleFileSystemDriverSupported (
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	**/
414	EFI_STATUS
415	EFIAPI
416	FvSimpleFileSystemDriverStart (
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	// Allocate the volume label
492	//
493	Instance->VolumeLabel = AllocateZeroPool (FVFS_VOLUME_LABEL_SIZE);
494	//
495	// Check the allocation was successful
496	//
497	if (Instance->VolumeLabel != NULL) {
498	//
499	// Extract the FV's guid
500	//
501	FvGuid = &((MEDIA_FW_VOL_DEVICE_PATH *) FvDevicePath)->FvName;
502	//
503	// Build the volume label string
504	//
505	NumChars = UnicodeSPrint (
506	Instance->VolumeLabel,
507	FVFS_VOLUME_LABEL_SIZE,
508	FVFS_VOLUME_LABEL_PREFIX L"%g",
509	FvGuid
510	);
511	ASSERT ((NumChars + 1) * sizeof (CHAR16) == FVFS_VOLUME_LABEL_SIZE);
512	}
513	break;
514	}
515	FvDevicePath = NextDevicePathNode (FvDevicePath);
516	}
517	}
518	//
519	// If we didn't decide on a volume label, set a fallback one
520	//
521	if (Instance->VolumeLabel == NULL) {
522	Instance->VolumeLabel = AllocateCopyPool (
523	sizeof (FVFS_FALLBACK_VOLUME_LABEL),
524	FVFS_FALLBACK_VOLUME_LABEL
525	);
526	}
527
528	return EFI_SUCCESS;
529	}
530
531	/**
532	Stop this driver on ControllerHandle by removing SimpleFileSystem protocol and closing
533	the FV protocol on ControllerHandle.
534
535	@param DriverBinding Protocol instance pointer.
536	@param ControllerHandle Handle of device to stop driver on
537	@param NumberOfChildren Number of Handles in ChildHandleBuffer. If number of
538	children is zero stop the entire bus driver.
539	@param ChildHandleBuffer List of Child Handles to Stop.
540
541	@retval EFI_SUCCESS This driver is removed ControllerHandle
542	@retval other This driver was not removed from this device
543
544	**/
545	EFI_STATUS
546	EFIAPI
547	FvSimpleFileSystemDriverStop (
548	IN EFI_DRIVER_BINDING_PROTOCOL *DriverBinding,
549	IN EFI_HANDLE ControllerHandle,
550	IN UINTN NumberOfChildren,
551	IN EFI_HANDLE *ChildHandleBuffer OPTIONAL
552	)
553	{
554	EFI_STATUS Status;
555	FV_FILESYSTEM_INSTANCE *Instance;
556	FV_FILESYSTEM_FILE_INFO *FvFileInfo;
557	LIST_ENTRY *Entry;
558	LIST_ENTRY *DelEntry;
559	EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *SimpleFile;
560
561	Status = gBS->OpenProtocol (
562	ControllerHandle,
563	&gEfiSimpleFileSystemProtocolGuid,
564	(VOID **) &SimpleFile,
565	DriverBinding->DriverBindingHandle,
566	ControllerHandle,
567	EFI_OPEN_PROTOCOL_GET_PROTOCOL
568	);
569	if (EFI_ERROR (Status)) {
570	return Status;
571	}
572
573	Instance = FVFS_INSTANCE_FROM_SIMPLE_FS_THIS (SimpleFile);
574
575	if (IsListEmpty (&Instance->FileHead) == FALSE) {
576	//
577	// Not all opened files are closed
578	//
579	return EFI_DEVICE_ERROR;
580	}
581
582	//
583	// Close and uninstall protocols.
584	//
585	Status = gBS->CloseProtocol (
586	ControllerHandle,
587	&gEfiFirmwareVolume2ProtocolGuid,
588	gImageHandle,
589	ControllerHandle
590	);
591	ASSERT_EFI_ERROR (Status);
592
593	Status = gBS->UninstallProtocolInterface (
594	ControllerHandle,
595	&gEfiSimpleFileSystemProtocolGuid,
596	&Instance->SimpleFs
597	);
598	ASSERT_EFI_ERROR (Status);
599
600	//
601	// Free file structures
602	//
603	if (!IsListEmpty (&Instance->FileInfoHead)) {
604	//
605	// Free the Subtask list.
606	//
607	for(Entry = Instance->FileInfoHead.ForwardLink;
608	Entry != (&Instance->FileInfoHead);
609	) {
610	DelEntry = Entry;
611	Entry = Entry->ForwardLink;
612	FvFileInfo = FVFS_FILE_INFO_FROM_LINK (DelEntry);
613
614	RemoveEntryList (DelEntry);
615	FreePool (FvFileInfo);
616	}
617	}
618
619	if (Instance->Root != NULL) {
620	//
621	// Root->Name is statically allocated, no need to free.
622	//
623	if (Instance->Root->FvFileInfo != NULL) {
624	FreePool (Instance->Root->FvFileInfo);
625	}
626	FreePool (Instance->Root);
627	}
628
629	//
630	// Free Instance
631	//
632	if (Instance->VolumeLabel != NULL) {
633	FreePool (Instance->VolumeLabel);
634	}
635	FreePool (Instance);
636
637	return EFI_SUCCESS;
638	}
639
640	/**
641	The user Entry Point for module FvSimpleFileSystem. The user code starts with this function.
642
643	@param[in] ImageHandle The firmware allocated handle for the EFI image.
644	@param[in] SystemTable A pointer to the EFI System Table.
645
646	@retval EFI_SUCCESS The entry point is executed successfully.
647	@retval other Some error occurs when executing this entry point.
648
649	**/
650	EFI_STATUS
651	EFIAPI
652	FvSimpleFileSystemEntryPoint (
653	IN EFI_HANDLE ImageHandle,
654	IN EFI_SYSTEM_TABLE *SystemTable
655	)
656	{
657	EFI_STATUS Status;
658
659	//
660	// Install driver model protocol(s).
661	//
662	Status = EfiLibInstallDriverBindingComponentName2 (
663	ImageHandle,
664	SystemTable,
665	&mDriverBinding,
666	ImageHandle,
667	&gFvSimpleFileSystemComponentName,
668	&gFvSimpleFileSystemComponentName2
669	);
670	ASSERT_EFI_ERROR (Status);
671
672	return Status;
673	}

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Devices/EFI/FirmwareNew/MdeModulePkg/Universal/FvSimpleFileSystemDxe/FvSimpleFileSystemEntryPoint.c@ 99396

Download in other formats: