BmMisc.c@ 77662

最後變更在這個檔案從77662是 77662,由 vboxsync 提交於 6 年前
EFI: First step in UDK2018 merge. Does not build yet.
屬性 svn:eol-style 設為 `native`
檔案大小: 18.0 KB

行
1	/** @file
2	Misc library functions.
3
4	Copyright (c) 2011 - 2017, Intel Corporation. All rights reserved.<BR>
5	(C) Copyright 2016 Hewlett Packard Enterprise Development LP<BR>
6	This program and the accompanying materials
7	are licensed and made available under the terms and conditions of the BSD License
8	which accompanies this distribution. The full text of the license may be found at
9	http://opensource.org/licenses/bsd-license.php
10
11	THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
12	WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
13
14	**/
15
16	#include "InternalBm.h"
17
18	/**
19	Delete the instance in Multi which matches partly with Single instance
20
21	@param Multi A pointer to a multi-instance device path data
22	structure.
23	@param Single A pointer to a single-instance device path data
24	structure.
25
26	@return This function will remove the device path instances in Multi which partly
27	match with the Single, and return the result device path. If there is no
28	remaining device path as a result, this function will return NULL.
29
30	**/
31	EFI_DEVICE_PATH_PROTOCOL *
32	BmDelPartMatchInstance (
33	IN EFI_DEVICE_PATH_PROTOCOL *Multi,
34	IN EFI_DEVICE_PATH_PROTOCOL *Single
35	)
36	{
37	EFI_DEVICE_PATH_PROTOCOL *Instance;
38	EFI_DEVICE_PATH_PROTOCOL *NewDevicePath;
39	EFI_DEVICE_PATH_PROTOCOL *TempNewDevicePath;
40	UINTN InstanceSize;
41	UINTN SingleDpSize;
42
43	NewDevicePath = NULL;
44	TempNewDevicePath = NULL;
45
46	if (Multi == NULL \|\| Single == NULL) {
47	return Multi;
48	}
49
50	Instance = GetNextDevicePathInstance (&Multi, &InstanceSize);
51	SingleDpSize = GetDevicePathSize (Single) - END_DEVICE_PATH_LENGTH;
52	InstanceSize -= END_DEVICE_PATH_LENGTH;
53
54	while (Instance != NULL) {
55
56	if (CompareMem (Instance, Single, MIN (SingleDpSize, InstanceSize)) != 0) {
57	//
58	// Append the device path instance which does not match with Single
59	//
60	TempNewDevicePath = NewDevicePath;
61	NewDevicePath = AppendDevicePathInstance (NewDevicePath, Instance);
62	if (TempNewDevicePath != NULL) {
63	FreePool(TempNewDevicePath);
64	}
65	}
66	FreePool(Instance);
67	Instance = GetNextDevicePathInstance (&Multi, &InstanceSize);
68	InstanceSize -= END_DEVICE_PATH_LENGTH;
69	}
70
71	return NewDevicePath;
72	}
73
74	/**
75	Function compares a device path data structure to that of all the nodes of a
76	second device path instance.
77
78	@param Multi A pointer to a multi-instance device path data
79	structure.
80	@param Single A pointer to a single-instance device path data
81	structure.
82
83	@retval TRUE If the Single device path is contained within Multi device path.
84	@retval FALSE The Single device path is not match within Multi device path.
85
86	**/
87	BOOLEAN
88	BmMatchDevicePaths (
89	IN EFI_DEVICE_PATH_PROTOCOL *Multi,
90	IN EFI_DEVICE_PATH_PROTOCOL *Single
91	)
92	{
93	EFI_DEVICE_PATH_PROTOCOL *DevicePath;
94	EFI_DEVICE_PATH_PROTOCOL *DevicePathInst;
95	UINTN Size;
96
97	if (Multi == NULL \|\| Single == NULL) {
98	return FALSE;
99	}
100
101	DevicePath = Multi;
102	DevicePathInst = GetNextDevicePathInstance (&DevicePath, &Size);
103
104	//
105	// Search for the match of 'Single' in 'Multi'
106	//
107	while (DevicePathInst != NULL) {
108	//
109	// If the single device path is found in multiple device paths,
110	// return success
111	//
112	if (CompareMem (Single, DevicePathInst, Size) == 0) {
113	FreePool (DevicePathInst);
114	return TRUE;
115	}
116
117	FreePool (DevicePathInst);
118	DevicePathInst = GetNextDevicePathInstance (&DevicePath, &Size);
119	}
120
121	return FALSE;
122	}
123
124	/**
125	This routine adjust the memory information for different memory type and
126	save them into the variables for next boot. It resets the system when
127	memory information is updated and the current boot option belongs to
128	boot category instead of application category. It doesn't count the
129	reserved memory occupied by RAM Disk.
130
131	@param Boot TRUE if current boot option belongs to boot
132	category instead of application category.
133	**/
134	VOID
135	BmSetMemoryTypeInformationVariable (
136	IN BOOLEAN Boot
137	)
138	{
139	EFI_STATUS Status;
140	EFI_MEMORY_TYPE_INFORMATION *PreviousMemoryTypeInformation;
141	EFI_MEMORY_TYPE_INFORMATION *CurrentMemoryTypeInformation;
142	UINTN VariableSize;
143	UINTN Index;
144	UINTN Index1;
145	UINT32 Previous;
146	UINT32 Current;
147	UINT32 Next;
148	EFI_HOB_GUID_TYPE *GuidHob;
149	BOOLEAN MemoryTypeInformationModified;
150	BOOLEAN MemoryTypeInformationVariableExists;
151	EFI_BOOT_MODE BootMode;
152
153	MemoryTypeInformationModified = FALSE;
154	MemoryTypeInformationVariableExists = FALSE;
155
156
157	BootMode = GetBootModeHob ();
158	//
159	// In BOOT_IN_RECOVERY_MODE, Variable region is not reliable.
160	//
161	if (BootMode == BOOT_IN_RECOVERY_MODE) {
162	return;
163	}
164
165	//
166	// Only check the the Memory Type Information variable in the boot mode
167	// other than BOOT_WITH_DEFAULT_SETTINGS because the Memory Type
168	// Information is not valid in this boot mode.
169	//
170	if (BootMode != BOOT_WITH_DEFAULT_SETTINGS) {
171	VariableSize = 0;
172	Status = gRT->GetVariable (
173	EFI_MEMORY_TYPE_INFORMATION_VARIABLE_NAME,
174	&gEfiMemoryTypeInformationGuid,
175	NULL,
176	&VariableSize,
177	NULL
178	);
179	if (Status == EFI_BUFFER_TOO_SMALL) {
180	MemoryTypeInformationVariableExists = TRUE;
181	}
182	}
183
184	//
185	// Retrieve the current memory usage statistics. If they are not found, then
186	// no adjustments can be made to the Memory Type Information variable.
187	//
188	Status = EfiGetSystemConfigurationTable (
189	&gEfiMemoryTypeInformationGuid,
190	(VOID **) &CurrentMemoryTypeInformation
191	);
192	if (EFI_ERROR (Status) \|\| CurrentMemoryTypeInformation == NULL) {
193	return;
194	}
195
196	//
197	// Get the Memory Type Information settings from Hob if they exist,
198	// PEI is responsible for getting them from variable and build a Hob to save them.
199	// If the previous Memory Type Information is not available, then set defaults
200	//
201	GuidHob = GetFirstGuidHob (&gEfiMemoryTypeInformationGuid);
202	if (GuidHob == NULL) {
203	//
204	// If Platform has not built Memory Type Info into the Hob, just return.
205	//
206	return;
207	}
208	VariableSize = GET_GUID_HOB_DATA_SIZE (GuidHob);
209	PreviousMemoryTypeInformation = AllocateCopyPool (VariableSize, GET_GUID_HOB_DATA (GuidHob));
210	if (PreviousMemoryTypeInformation == NULL) {
211	return;
212	}
213
214	//
215	// Use a heuristic to adjust the Memory Type Information for the next boot
216	//
217	DEBUG ((EFI_D_INFO, "Memory Previous Current Next \n"));
218	DEBUG ((EFI_D_INFO, " Type Pages Pages Pages \n"));
219	DEBUG ((EFI_D_INFO, "====== ======== ======== ========\n"));
220
221	for (Index = 0; PreviousMemoryTypeInformation[Index].Type != EfiMaxMemoryType; Index++) {
222
223	for (Index1 = 0; CurrentMemoryTypeInformation[Index1].Type != EfiMaxMemoryType; Index1++) {
224	if (PreviousMemoryTypeInformation[Index].Type == CurrentMemoryTypeInformation[Index1].Type) {
225	break;
226	}
227	}
228	if (CurrentMemoryTypeInformation[Index1].Type == EfiMaxMemoryType) {
229	continue;
230	}
231
232	//
233	// Previous is the number of pages pre-allocated
234	// Current is the number of pages actually needed
235	//
236	Previous = PreviousMemoryTypeInformation[Index].NumberOfPages;
237	Current = CurrentMemoryTypeInformation[Index1].NumberOfPages;
238	Next = Previous;
239
240	//
241	// Inconsistent Memory Reserved across bootings may lead to S4 fail
242	// Write next varible to 125% * current when the pre-allocated memory is:
243	// 1. More than 150% of needed memory and boot mode is BOOT_WITH_DEFAULT_SETTING
244	// 2. Less than the needed memory
245	//
246	if ((Current + (Current >> 1)) < Previous) {
247	if (BootMode == BOOT_WITH_DEFAULT_SETTINGS) {
248	Next = Current + (Current >> 2);
249	}
250	} else if (Current > Previous) {
251	Next = Current + (Current >> 2);
252	}
253	if (Next > 0 && Next < 4) {
254	Next = 4;
255	}
256
257	if (Next != Previous) {
258	PreviousMemoryTypeInformation[Index].NumberOfPages = Next;
259	MemoryTypeInformationModified = TRUE;
260	}
261
262	DEBUG ((EFI_D_INFO, " %02x %08x %08x %08x\n", PreviousMemoryTypeInformation[Index].Type, Previous, Current, Next));
263	}
264
265	//
266	// If any changes were made to the Memory Type Information settings, then set the new variable value;
267	// Or create the variable in first boot.
268	//
269	if (MemoryTypeInformationModified \|\| !MemoryTypeInformationVariableExists) {
270	Status = BmSetVariableAndReportStatusCodeOnError (
271	EFI_MEMORY_TYPE_INFORMATION_VARIABLE_NAME,
272	&gEfiMemoryTypeInformationGuid,
273	EFI_VARIABLE_NON_VOLATILE \| EFI_VARIABLE_BOOTSERVICE_ACCESS,
274	VariableSize,
275	PreviousMemoryTypeInformation
276	);
277
278	if (!EFI_ERROR (Status)) {
279	//
280	// If the Memory Type Information settings have been modified and the boot option belongs to boot category,
281	// then reset the platform so the new Memory Type Information setting will be used to guarantee that an S4
282	// entry/resume cycle will not fail.
283	//
284	if (MemoryTypeInformationModified) {
285	DEBUG ((EFI_D_INFO, "Memory Type Information settings change.\n"));
286	if (Boot && PcdGetBool (PcdResetOnMemoryTypeInformationChange)) {
287	DEBUG ((EFI_D_INFO, "...Warm Reset!!!\n"));
288	gRT->ResetSystem (EfiResetWarm, EFI_SUCCESS, 0, NULL);
289	}
290	}
291	} else {
292	DEBUG ((EFI_D_ERROR, "Memory Type Information settings cannot be saved. OS S4 may fail!\n"));
293	}
294	}
295	FreePool (PreviousMemoryTypeInformation);
296	}
297
298	/**
299	Set the variable and report the error through status code upon failure.
300
301	@param VariableName A Null-terminated string that is the name of the vendor's variable.
302	Each VariableName is unique for each VendorGuid. VariableName must
303	contain 1 or more characters. If VariableName is an empty string,
304	then EFI_INVALID_PARAMETER is returned.
305	@param VendorGuid A unique identifier for the vendor.
306	@param Attributes Attributes bitmask to set for the variable.
307	@param DataSize The size in bytes of the Data buffer. Unless the EFI_VARIABLE_APPEND_WRITE,
308	or EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS attribute is set, a size of zero
309	causes the variable to be deleted. When the EFI_VARIABLE_APPEND_WRITE attribute is
310	set, then a SetVariable() call with a DataSize of zero will not cause any change to
311	the variable value (the timestamp associated with the variable may be updated however
312	even if no new data value is provided,see the description of the
313	EFI_VARIABLE_AUTHENTICATION_2 descriptor below. In this case the DataSize will not
314	be zero since the EFI_VARIABLE_AUTHENTICATION_2 descriptor will be populated).
315	@param Data The contents for the variable.
316
317	@retval EFI_SUCCESS The firmware has successfully stored the variable and its data as
318	defined by the Attributes.
319	@retval EFI_INVALID_PARAMETER An invalid combination of attribute bits, name, and GUID was supplied, or the
320	DataSize exceeds the maximum allowed.
321	@retval EFI_INVALID_PARAMETER VariableName is an empty string.
322	@retval EFI_OUT_OF_RESOURCES Not enough storage is available to hold the variable and its data.
323	@retval EFI_DEVICE_ERROR The variable could not be retrieved due to a hardware error.
324	@retval EFI_WRITE_PROTECTED The variable in question is read-only.
325	@retval EFI_WRITE_PROTECTED The variable in question cannot be deleted.
326	@retval EFI_SECURITY_VIOLATION The variable could not be written due to EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACESS
327	being set, but the AuthInfo does NOT pass the validation check carried out by the firmware.
328
329	@retval EFI_NOT_FOUND The variable trying to be updated or deleted was not found.
330	**/
331	EFI_STATUS
332	BmSetVariableAndReportStatusCodeOnError (
333	IN CHAR16 *VariableName,
334	IN EFI_GUID *VendorGuid,
335	IN UINT32 Attributes,
336	IN UINTN DataSize,
337	IN VOID *Data
338	)
339	{
340	EFI_STATUS Status;
341	EDKII_SET_VARIABLE_STATUS *SetVariableStatus;
342	UINTN NameSize;
343
344	Status = gRT->SetVariable (
345	VariableName,
346	VendorGuid,
347	Attributes,
348	DataSize,
349	Data
350	);
351	if (EFI_ERROR (Status)) {
352	NameSize = StrSize (VariableName);
353	SetVariableStatus = AllocatePool (sizeof (EDKII_SET_VARIABLE_STATUS) + NameSize + DataSize);
354	if (SetVariableStatus != NULL) {
355	CopyGuid (&SetVariableStatus->Guid, VendorGuid);
356	SetVariableStatus->NameSize = NameSize;
357	SetVariableStatus->DataSize = DataSize;
358	SetVariableStatus->SetStatus = Status;
359	SetVariableStatus->Attributes = Attributes;
360	CopyMem (SetVariableStatus + 1, VariableName, NameSize);
361	CopyMem (((UINT8 *) (SetVariableStatus + 1)) + NameSize, Data, DataSize);
362
363	REPORT_STATUS_CODE_EX (
364	EFI_ERROR_CODE,
365	PcdGet32 (PcdErrorCodeSetVariable),
366	0,
367	NULL,
368	&gEdkiiStatusCodeDataTypeVariableGuid,
369	SetVariableStatus,
370	sizeof (EDKII_SET_VARIABLE_STATUS) + NameSize + DataSize
371	);
372
373	FreePool (SetVariableStatus);
374	}
375	}
376
377	return Status;
378	}
379
380
381	/**
382	Print the device path info.
383
384	@param DevicePath The device path need to print.
385	**/
386	VOID
387	BmPrintDp (
388	EFI_DEVICE_PATH_PROTOCOL *DevicePath
389	)
390	{
391	CHAR16 *Str;
392
393	Str = ConvertDevicePathToText (DevicePath, FALSE, FALSE);
394	DEBUG ((EFI_D_INFO, "%s", Str));
395	if (Str != NULL) {
396	FreePool (Str);
397	}
398	}
399
400	/**
401	Convert a single character to number.
402	It assumes the input Char is in the scope of L'0' ~ L'9' and L'A' ~ L'F'
403
404	@param Char The input char which need to convert to int.
405
406	@return The converted 8-bit number or (UINTN) -1 if conversion failed.
407	**/
408	UINTN
409	BmCharToUint (
410	IN CHAR16 Char
411	)
412	{
413	if ((Char >= L'0') && (Char <= L'9')) {
414	return (Char - L'0');
415	}
416
417	if ((Char >= L'A') && (Char <= L'F')) {
418	return (Char - L'A' + 0xA);
419	}
420
421	return (UINTN) -1;
422	}
423
424	/**
425	Dispatch the deferred images that are returned from all DeferredImageLoad instances.
426
427	@retval EFI_SUCCESS At least one deferred image is loaded successfully and started.
428	@retval EFI_NOT_FOUND There is no deferred image.
429	@retval EFI_ACCESS_DENIED There are deferred images but all of them are failed to load.
430	**/
431	EFI_STATUS
432	EFIAPI
433	EfiBootManagerDispatchDeferredImages (
434	VOID
435	)
436	{
437	EFI_STATUS Status;
438	EFI_DEFERRED_IMAGE_LOAD_PROTOCOL *DeferredImage;
439	UINTN HandleCount;
440	EFI_HANDLE *Handles;
441	UINTN Index;
442	UINTN ImageIndex;
443	EFI_DEVICE_PATH_PROTOCOL *ImageDevicePath;
444	VOID *Image;
445	UINTN ImageSize;
446	BOOLEAN BootOption;
447	EFI_HANDLE ImageHandle;
448	UINTN ExitDataSize;
449	CHAR16 *ExitData;
450	UINTN ImageCount;
451	UINTN LoadCount;
452
453	//
454	// Find all the deferred image load protocols.
455	//
456	HandleCount = 0;
457	Handles = NULL;
458	Status = gBS->LocateHandleBuffer (
459	ByProtocol,
460	&gEfiDeferredImageLoadProtocolGuid,
461	NULL,
462	&HandleCount,
463	&Handles
464	);
465	if (EFI_ERROR (Status)) {
466	return EFI_NOT_FOUND;
467	}
468
469	ImageCount = 0;
470	LoadCount = 0;
471	for (Index = 0; Index < HandleCount; Index++) {
472	Status = gBS->HandleProtocol (Handles[Index], &gEfiDeferredImageLoadProtocolGuid, (VOID **) &DeferredImage);
473	if (EFI_ERROR (Status)) {
474	continue;
475	}
476
477	for (ImageIndex = 0; ;ImageIndex++) {
478	//
479	// Load all the deferred images in this protocol instance.
480	//
481	Status = DeferredImage->GetImageInfo (
482	DeferredImage,
483	ImageIndex,
484	&ImageDevicePath,
485	(VOID **) &Image,
486	&ImageSize,
487	&BootOption
488	);
489	if (EFI_ERROR (Status)) {
490	break;
491	}
492	ImageCount++;
493	//
494	// Load and start the image.
495	//
496	Status = gBS->LoadImage (
497	BootOption,
498	gImageHandle,
499	ImageDevicePath,
500	NULL,
501	0,
502	&ImageHandle
503	);
504	if (!EFI_ERROR (Status)) {
505	LoadCount++;
506	//
507	// Before calling the image, enable the Watchdog Timer for
508	// a 5 Minute period
509	//
510	gBS->SetWatchdogTimer (5 * 60, 0x0000, 0x00, NULL);
511	Status = gBS->StartImage (ImageHandle, &ExitDataSize, &ExitData);
512	if (ExitData != NULL) {
513	FreePool (ExitData);
514	}
515
516	//
517	// Clear the Watchdog Timer after the image returns.
518	//
519	gBS->SetWatchdogTimer (0x0000, 0x0000, 0x0000, NULL);
520	}
521	}
522	}
523	if (Handles != NULL) {
524	FreePool (Handles);
525	}
526
527	if (ImageCount == 0) {
528	return EFI_NOT_FOUND;
529	} else {
530	if (LoadCount == 0) {
531	return EFI_ACCESS_DENIED;
532	} else {
533	return EFI_SUCCESS;
534	}
535	}
536	}

注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

source: vbox/trunk/src/VBox/Devices/EFI/FirmwareNew/MdeModulePkg/Library/UefiBootManagerLib/BmMisc.c@ 77662

以其他格式下載: