]> git.proxmox.com Git - mirror_edk2.git/blob - IntelFrameworkModulePkg/Library/GenericBdsLib/BdsMisc.c
projects / mirror_edk2.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Update copyright.
[mirror_edk2.git] / IntelFrameworkModulePkg / Library / GenericBdsLib / BdsMisc.c
1 /** @file
2 Misc BDS library function
3
4 Copyright (c) 2004 - 2012, Intel Corporation. All rights reserved.<BR>
5 This program and the accompanying materials
6 are licensed and made available under the terms and conditions of the BSD License
7 which accompanies this distribution. The full text of the license may be found at
8 http://opensource.org/licenses/bsd-license.php
9
10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
12
13 **/
14
15 #include "InternalBdsLib.h"
16
17
18 #define MAX_STRING_LEN 200
19
20 BOOLEAN mFeaturerSwitch = TRUE;
21 BOOLEAN mResetRequired = FALSE;
22
23 extern UINT16 gPlatformBootTimeOutDefault;
24
25 /**
26 The function will go through the driver option link list, load and start
27 every driver the driver option device path point to.
28
29 @param BdsDriverLists The header of the current driver option link list
30
31 **/
32 VOID
33 EFIAPI
34 BdsLibLoadDrivers (
35 IN LIST_ENTRY *BdsDriverLists
36 )
37 {
38 EFI_STATUS Status;
39 LIST_ENTRY *Link;
40 BDS_COMMON_OPTION *Option;
41 EFI_HANDLE ImageHandle;
42 EFI_LOADED_IMAGE_PROTOCOL *ImageInfo;
43 UINTN ExitDataSize;
44 CHAR16 *ExitData;
45 BOOLEAN ReconnectAll;
46
47 ReconnectAll = FALSE;
48
49 //
50 // Process the driver option
51 //
52 for (Link = BdsDriverLists->ForwardLink; Link != BdsDriverLists; Link = Link->ForwardLink) {
53 Option = CR (Link, BDS_COMMON_OPTION, Link, BDS_LOAD_OPTION_SIGNATURE);
54
55 //
56 // If a load option is not marked as LOAD_OPTION_ACTIVE,
57 // the boot manager will not automatically load the option.
58 //
59 if (!IS_LOAD_OPTION_TYPE (Option->Attribute, LOAD_OPTION_ACTIVE)) {
60 continue;
61 }
62
63 //
64 // If a driver load option is marked as LOAD_OPTION_FORCE_RECONNECT,
65 // then all of the EFI drivers in the system will be disconnected and
66 // reconnected after the last driver load option is processed.
67 //
68 if (IS_LOAD_OPTION_TYPE (Option->Attribute, LOAD_OPTION_FORCE_RECONNECT)) {
69 ReconnectAll = TRUE;
70 }
71
72 //
73 // Make sure the driver path is connected.
74 //
75 BdsLibConnectDevicePath (Option->DevicePath);
76
77 //
78 // Load and start the image that Driver#### describes
79 //
80 Status = gBS->LoadImage (
81 FALSE,
82 gImageHandle,
83 Option->DevicePath,
84 NULL,
85 0,
86 &ImageHandle
87 );
88
89 if (!EFI_ERROR (Status)) {
90 gBS->HandleProtocol (ImageHandle, &gEfiLoadedImageProtocolGuid, (VOID **) &ImageInfo);
91
92 //
93 // Verify whether this image is a driver, if not,
94 // exit it and continue to parse next load option
95 //
96 if (ImageInfo->ImageCodeType != EfiBootServicesCode && ImageInfo->ImageCodeType != EfiRuntimeServicesCode) {
97 gBS->Exit (ImageHandle, EFI_INVALID_PARAMETER, 0, NULL);
98 continue;
99 }
100
101 if (Option->LoadOptionsSize != 0) {
102 ImageInfo->LoadOptionsSize = Option->LoadOptionsSize;
103 ImageInfo->LoadOptions = Option->LoadOptions;
104 }
105 //
106 // Before calling the image, enable the Watchdog Timer for
107 // the 5 Minute period
108 //
109 gBS->SetWatchdogTimer (5 * 60, 0x0000, 0x00, NULL);
110
111 Status = gBS->StartImage (ImageHandle, &ExitDataSize, &ExitData);
112 DEBUG ((DEBUG_INFO | DEBUG_LOAD, "Driver Return Status = %r\n", Status));
113
114 //
115 // Clear the Watchdog Timer after the image returns
116 //
117 gBS->SetWatchdogTimer (0x0000, 0x0000, 0x0000, NULL);
118 }
119 }
120
121 //
122 // Process the LOAD_OPTION_FORCE_RECONNECT driver option
123 //
124 if (ReconnectAll) {
125 BdsLibDisconnectAllEfi ();
126 BdsLibConnectAll ();
127 }
128
129 }
130
131 /**
132 Get the Option Number that does not used.
133 Try to locate the specific option variable one by one utile find a free number.
134
135 @param VariableName Indicate if the boot#### or driver#### option
136
137 @return The Minimal Free Option Number
138
139 **/
140 UINT16
141 BdsLibGetFreeOptionNumber (
142 IN CHAR16 *VariableName
143 )
144 {
145 UINTN Index;
146 CHAR16 StrTemp[10];
147 UINT16 *OptionBuffer;
148 UINTN OptionSize;
149
150 //
151 // Try to find the minimum free number from 0, 1, 2, 3....
152 //
153 Index = 0;
154 do {
155 if (*VariableName == 'B') {
156 UnicodeSPrint (StrTemp, sizeof (StrTemp), L"Boot%04x", Index);
157 } else {
158 UnicodeSPrint (StrTemp, sizeof (StrTemp), L"Driver%04x", Index);
159 }
160 //
161 // try if the option number is used
162 //
163 OptionBuffer = BdsLibGetVariableAndSize (
164 StrTemp,
165 &gEfiGlobalVariableGuid,
166 &OptionSize
167 );
168 if (OptionBuffer == NULL) {
169 break;
170 }
171 Index++;
172 } while (TRUE);
173
174 return ((UINT16) Index);
175 }
176
177
178 /**
179 This function will register the new boot#### or driver#### option base on
180 the VariableName. The new registered boot#### or driver#### will be linked
181 to BdsOptionList and also update to the VariableName. After the boot#### or
182 driver#### updated, the BootOrder or DriverOrder will also be updated.
183
184 @param BdsOptionList The header of the boot#### or driver#### link list
185 @param DevicePath The device path which the boot#### or driver####
186 option present
187 @param String The description of the boot#### or driver####
188 @param VariableName Indicate if the boot#### or driver#### option
189
190 @retval EFI_SUCCESS The boot#### or driver#### have been success
191 registered
192 @retval EFI_STATUS Return the status of gRT->SetVariable ().
193
194 **/
195 EFI_STATUS
196 EFIAPI
197 BdsLibRegisterNewOption (
198 IN LIST_ENTRY *BdsOptionList,
199 IN EFI_DEVICE_PATH_PROTOCOL *DevicePath,
200 IN CHAR16 *String,
201 IN CHAR16 *VariableName
202 )
203 {
204 EFI_STATUS Status;
205 UINTN Index;
206 UINT16 RegisterOptionNumber;
207 UINT16 *TempOptionPtr;
208 UINTN TempOptionSize;
209 UINT16 *OptionOrderPtr;
210 VOID *OptionPtr;
211 UINTN OptionSize;
212 UINT8 *TempPtr;
213 EFI_DEVICE_PATH_PROTOCOL *OptionDevicePath;
214 CHAR16 *Description;
215 CHAR16 OptionName[10];
216 BOOLEAN UpdateDescription;
217 UINT16 BootOrderEntry;
218 UINTN OrderItemNum;
219
220
221 OptionPtr = NULL;
222 OptionSize = 0;
223 TempPtr = NULL;
224 OptionDevicePath = NULL;
225 Description = NULL;
226 OptionOrderPtr = NULL;
227 UpdateDescription = FALSE;
228 Status = EFI_SUCCESS;
229 ZeroMem (OptionName, sizeof (OptionName));
230
231 TempOptionSize = 0;
232 TempOptionPtr = BdsLibGetVariableAndSize (
233 VariableName,
234 &gEfiGlobalVariableGuid,
235 &TempOptionSize
236 );
237 //
238 // Compare with current option variable if the previous option is set in global variable.
239 //
240 for (Index = 0; Index < TempOptionSize / sizeof (UINT16); Index++) {
241 //
242 // TempOptionPtr must not be NULL if we have non-zero TempOptionSize.
243 //
244 ASSERT (TempOptionPtr != NULL);
245
246 if (*VariableName == 'B') {
247 UnicodeSPrint (OptionName, sizeof (OptionName), L"Boot%04x", TempOptionPtr[Index]);
248 } else {
249 UnicodeSPrint (OptionName, sizeof (OptionName), L"Driver%04x", TempOptionPtr[Index]);
250 }
251
252 OptionPtr = BdsLibGetVariableAndSize (
253 OptionName,
254 &gEfiGlobalVariableGuid,
255 &OptionSize
256 );
257 if (OptionPtr == NULL) {
258 continue;
259 }
260 TempPtr = OptionPtr;
261 TempPtr += sizeof (UINT32) + sizeof (UINT16);
262 Description = (CHAR16 *) TempPtr;
263 TempPtr += StrSize ((CHAR16 *) TempPtr);
264 OptionDevicePath = (EFI_DEVICE_PATH_PROTOCOL *) TempPtr;
265
266 //
267 // Notes: the description may will change base on the GetStringToken
268 //
269 if (CompareMem (OptionDevicePath, DevicePath, GetDevicePathSize (OptionDevicePath)) == 0) {
270 if (CompareMem (Description, String, StrSize (Description)) == 0) {
271 //
272 // Got the option, so just return
273 //
274 FreePool (OptionPtr);
275 FreePool (TempOptionPtr);
276 return EFI_SUCCESS;
277 } else {
278 //
279 // Option description changed, need update.
280 //
281 UpdateDescription = TRUE;
282 FreePool (OptionPtr);
283 break;
284 }
285 }
286
287 FreePool (OptionPtr);
288 }
289
290 OptionSize = sizeof (UINT32) + sizeof (UINT16) + StrSize (String);
291 OptionSize += GetDevicePathSize (DevicePath);
292 OptionPtr = AllocateZeroPool (OptionSize);
293 ASSERT (OptionPtr != NULL);
294
295 TempPtr = OptionPtr;
296 *(UINT32 *) TempPtr = LOAD_OPTION_ACTIVE;
297 TempPtr += sizeof (UINT32);
298 *(UINT16 *) TempPtr = (UINT16) GetDevicePathSize (DevicePath);
299 TempPtr += sizeof (UINT16);
300 CopyMem (TempPtr, String, StrSize (String));
301 TempPtr += StrSize (String);
302 CopyMem (TempPtr, DevicePath, GetDevicePathSize (DevicePath));
303
304 if (UpdateDescription) {
305 //
306 // The number in option#### to be updated.
307 // In this case, we must have non-NULL TempOptionPtr.
308 //
309 ASSERT (TempOptionPtr != NULL);
310 RegisterOptionNumber = TempOptionPtr[Index];
311 } else {
312 //
313 // The new option#### number
314 //
315 RegisterOptionNumber = BdsLibGetFreeOptionNumber(VariableName);
316 }
317
318 if (*VariableName == 'B') {
319 UnicodeSPrint (OptionName, sizeof (OptionName), L"Boot%04x", RegisterOptionNumber);
320 } else {
321 UnicodeSPrint (OptionName, sizeof (OptionName), L"Driver%04x", RegisterOptionNumber);
322 }
323
324 Status = gRT->SetVariable (
325 OptionName,
326 &gEfiGlobalVariableGuid,
327 EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE,
328 OptionSize,
329 OptionPtr
330 );
331 //
332 // Return if only need to update a changed description or fail to set option.
333 //
334 if (EFI_ERROR (Status) || UpdateDescription) {
335 FreePool (OptionPtr);
336 if (TempOptionPtr != NULL) {
337 FreePool (TempOptionPtr);
338 }
339 return Status;
340 }
341
342 FreePool (OptionPtr);
343
344 //
345 // Update the option order variable
346 //
347
348 //
349 // If no option order
350 //
351 if (TempOptionSize == 0) {
352 BootOrderEntry = 0;
353 Status = gRT->SetVariable (
354 VariableName,
355 &gEfiGlobalVariableGuid,
356 EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE,
357 sizeof (UINT16),
358 &BootOrderEntry
359 );
360 if (TempOptionPtr != NULL) {
361 FreePool (TempOptionPtr);
362 }
363 return Status;
364 }
365
366 //
367 // TempOptionPtr must not be NULL if TempOptionSize is not zero.
368 //
369 ASSERT (TempOptionPtr != NULL);
370 //
371 // Append the new option number to the original option order
372 //
373 OrderItemNum = (TempOptionSize / sizeof (UINT16)) + 1 ;
374 OptionOrderPtr = AllocateZeroPool ( OrderItemNum * sizeof (UINT16));
375 ASSERT (OptionOrderPtr!= NULL);
376 CopyMem (OptionOrderPtr, TempOptionPtr, (OrderItemNum - 1) * sizeof (UINT16));
377
378 OptionOrderPtr[Index] = RegisterOptionNumber;
379
380 Status = gRT->SetVariable (
381 VariableName,
382 &gEfiGlobalVariableGuid,
383 EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE,
384 OrderItemNum * sizeof (UINT16),
385 OptionOrderPtr
386 );
387 FreePool (TempOptionPtr);
388 FreePool (OptionOrderPtr);
389
390 return Status;
391 }
392
393 /**
394 Returns the size of a device path in bytes.
395
396 This function returns the size, in bytes, of the device path data structure
397 specified by DevicePath including the end of device path node. If DevicePath
398 is NULL, then 0 is returned. If the length of the device path is bigger than
399 MaxSize, also return 0 to indicate this is an invalidate device path.
400
401 @param DevicePath A pointer to a device path data structure.
402 @param MaxSize Max valid device path size. If big than this size,
403 return error.
404
405 @retval 0 An invalid device path.
406 @retval Others The size of a device path in bytes.
407
408 **/
409 UINTN
410 GetDevicePathSizeEx (
411 IN CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath,
412 IN UINTN MaxSize
413 )
414 {
415 UINTN Size;
416 UINTN NodeSize;
417
418 if (DevicePath == NULL) {
419 return 0;
420 }
421
422 //
423 // Search for the end of the device path structure
424 //
425 Size = 0;
426 while (!IsDevicePathEnd (DevicePath)) {
427 NodeSize = DevicePathNodeLength (DevicePath);
428 if (NodeSize == 0) {
429 return 0;
430 }
431 Size += NodeSize;
432 if (Size > MaxSize) {
433 return 0;
434 }
435 DevicePath = NextDevicePathNode (DevicePath);
436 }
437 Size += DevicePathNodeLength (DevicePath);
438 if (Size > MaxSize) {
439 return 0;
440 }
441
442 return Size;
443 }
444
445 /**
446 Returns the length of a Null-terminated Unicode string. If the length is
447 bigger than MaxStringLen, return length 0 to indicate that this is an
448 invalidate string.
449
450 This function returns the number of Unicode characters in the Null-terminated
451 Unicode string specified by String.
452
453 If String is NULL, then ASSERT().
454 If String is not aligned on a 16-bit boundary, then ASSERT().
455
456 @param String A pointer to a Null-terminated Unicode string.
457 @param MaxStringLen Max string len in this string.
458
459 @retval 0 An invalid string.
460 @retval Others The length of String.
461
462 **/
463 UINTN
464 StrSizeEx (
465 IN CONST CHAR16 *String,
466 IN UINTN MaxStringLen
467 )
468 {
469 UINTN Length;
470
471 ASSERT (String != NULL && MaxStringLen != 0);
472 ASSERT (((UINTN) String & BIT0) == 0);
473
474 for (Length = 0; *String != L'\0' && MaxStringLen != Length; String++, Length++);
475
476 if (*String != L'\0' && MaxStringLen == Length) {
477 return 0;
478 }
479
480 return (Length + 1) * sizeof (*String);
481 }
482
483 /**
484 Build the boot#### or driver#### option from the VariableName, the
485 build boot#### or driver#### will also be linked to BdsCommonOptionList.
486
487 @param BdsCommonOptionList The header of the boot#### or driver#### option
488 link list
489 @param VariableName EFI Variable name indicate if it is boot#### or
490 driver####
491
492 @retval BDS_COMMON_OPTION Get the option just been created
493 @retval NULL Failed to get the new option
494
495 **/
496 BDS_COMMON_OPTION *
497 EFIAPI
498 BdsLibVariableToOption (
499 IN OUT LIST_ENTRY *BdsCommonOptionList,
500 IN CHAR16 *VariableName
501 )
502 {
503 UINT32 Attribute;
504 UINT16 FilePathSize;
505 UINT8 *Variable;
506 UINT8 *TempPtr;
507 UINTN VariableSize;
508 EFI_DEVICE_PATH_PROTOCOL *DevicePath;
509 EFI_DEVICE_PATH_PROTOCOL *TempPath;
510 BDS_COMMON_OPTION *Option;
511 VOID *LoadOptions;
512 UINT32 LoadOptionsSize;
513 CHAR16 *Description;
514 UINT8 NumOff;
515 UINTN TempSize;
516 //
517 // Read the variable. We will never free this data.
518 //
519 Variable = BdsLibGetVariableAndSize (
520 VariableName,
521 &gEfiGlobalVariableGuid,
522 &VariableSize
523 );
524 if (Variable == NULL) {
525 return NULL;
526 }
527 //
528 // Notes: careful defined the variable of Boot#### or
529 // Driver####, consider use some macro to abstract the code
530 //
531 //
532 // Get the option attribute
533 //
534 TempPtr = Variable;
535 Attribute = *(UINT32 *) Variable;
536 TempPtr += sizeof (UINT32);
537
538 //
539 // Get the option's device path size
540 //
541 FilePathSize = *(UINT16 *) TempPtr;
542 TempPtr += sizeof (UINT16);
543
544 //
545 // Get the option's description string
546 //
547 Description = (CHAR16 *) TempPtr;
548
549 //
550 // Get the option's description string size
551 //
552 TempSize = StrSizeEx ((CHAR16 *) TempPtr, VariableSize);
553 if (TempSize == 0) {
554 return NULL;
555 }
556 TempPtr += TempSize;
557
558 //
559 // Get the option's device path
560 //
561 DevicePath = (EFI_DEVICE_PATH_PROTOCOL *) TempPtr;
562 TempPtr += FilePathSize;
563
564 //
565 // Validation device path.
566 //
567 TempPath = DevicePath;
568 while (FilePathSize > 0) {
569 TempSize = GetDevicePathSizeEx (TempPath, FilePathSize);
570 if (TempSize == 0) {
571 return NULL;
572 }
573 FilePathSize = (UINT16) (FilePathSize - TempSize);
574 TempPath += TempSize;
575 }
576
577 //
578 // Get load opion data.
579 //
580 LoadOptions = TempPtr;
581 if (VariableSize < (UINTN)(TempPtr - Variable)) {
582 return NULL;
583 }
584 LoadOptionsSize = (UINT32) (VariableSize - (UINTN) (TempPtr - Variable));
585
586 //
587 // The Console variables may have multiple device paths, so make
588 // an Entry for each one.
589 //
590 Option = AllocateZeroPool (sizeof (BDS_COMMON_OPTION));
591 if (Option == NULL) {
592 return NULL;
593 }
594
595 Option->Signature = BDS_LOAD_OPTION_SIGNATURE;
596 Option->DevicePath = AllocateZeroPool (GetDevicePathSize (DevicePath));
597 ASSERT(Option->DevicePath != NULL);
598 CopyMem (Option->DevicePath, DevicePath, GetDevicePathSize (DevicePath));
599
600 Option->Attribute = Attribute;
601 Option->Description = AllocateZeroPool (StrSize (Description));
602 ASSERT(Option->Description != NULL);
603 CopyMem (Option->Description, Description, StrSize (Description));
604
605 Option->LoadOptions = AllocateZeroPool (LoadOptionsSize);
606 ASSERT(Option->LoadOptions != NULL);
607 CopyMem (Option->LoadOptions, LoadOptions, LoadOptionsSize);
608 Option->LoadOptionsSize = LoadOptionsSize;
609
610 //
611 // Get the value from VariableName Unicode string
612 // since the ISO standard assumes ASCII equivalent abbreviations, we can be safe in converting this
613 // Unicode stream to ASCII without any loss in meaning.
614 //
615 if (*VariableName == 'B') {
616 NumOff = (UINT8) (sizeof (L"Boot") / sizeof(CHAR16) - 1);
617 Option->BootCurrent = (UINT16) ((VariableName[NumOff] -'0') * 0x1000);
618 Option->BootCurrent = (UINT16) (Option->BootCurrent + ((VariableName[NumOff+1]-'0') * 0x100));
619 Option->BootCurrent = (UINT16) (Option->BootCurrent + ((VariableName[NumOff+2]-'0') * 0x10));
620 Option->BootCurrent = (UINT16) (Option->BootCurrent + ((VariableName[NumOff+3]-'0')));
621 }
622 //
623 // Insert active entry to BdsDeviceList
624 //
625 if ((Option->Attribute & LOAD_OPTION_ACTIVE) == LOAD_OPTION_ACTIVE) {
626 InsertTailList (BdsCommonOptionList, &Option->Link);
627 FreePool (Variable);
628 return Option;
629 }
630
631 FreePool (Variable);
632 FreePool (Option);
633 return NULL;
634
635 }
636
637 /**
638 Process BootOrder, or DriverOrder variables, by calling
639 BdsLibVariableToOption () for each UINT16 in the variables.
640
641 @param BdsCommonOptionList The header of the option list base on variable
642 VariableName
643 @param VariableName EFI Variable name indicate the BootOrder or
644 DriverOrder
645
646 @retval EFI_SUCCESS Success create the boot option or driver option
647 list
648 @retval EFI_OUT_OF_RESOURCES Failed to get the boot option or driver option list
649
650 **/
651 EFI_STATUS
652 EFIAPI
653 BdsLibBuildOptionFromVar (
654 IN LIST_ENTRY *BdsCommonOptionList,
655 IN CHAR16 *VariableName
656 )
657 {
658 UINT16 *OptionOrder;
659 UINTN OptionOrderSize;
660 UINTN Index;
661 BDS_COMMON_OPTION *Option;
662 CHAR16 OptionName[20];
663
664 //
665 // Zero Buffer in order to get all BOOT#### variables
666 //
667 ZeroMem (OptionName, sizeof (OptionName));
668
669 //
670 // Read the BootOrder, or DriverOrder variable.
671 //
672 OptionOrder = BdsLibGetVariableAndSize (
673 VariableName,
674 &gEfiGlobalVariableGuid,
675 &OptionOrderSize
676 );
677 if (OptionOrder == NULL) {
678 return EFI_OUT_OF_RESOURCES;
679 }
680
681 for (Index = 0; Index < OptionOrderSize / sizeof (UINT16); Index++) {
682 if (*VariableName == 'B') {
683 UnicodeSPrint (OptionName, sizeof (OptionName), L"Boot%04x", OptionOrder[Index]);
684 } else {
685 UnicodeSPrint (OptionName, sizeof (OptionName), L"Driver%04x", OptionOrder[Index]);
686 }
687
688 Option = BdsLibVariableToOption (BdsCommonOptionList, OptionName);
689 if (Option != NULL) {
690 Option->BootCurrent = OptionOrder[Index];
691 }
692 }
693
694 FreePool (OptionOrder);
695
696 return EFI_SUCCESS;
697 }
698
699 /**
700 Get boot mode by looking up configuration table and parsing HOB list
701
702 @param BootMode Boot mode from PEI handoff HOB.
703
704 @retval EFI_SUCCESS Successfully get boot mode
705
706 **/
707 EFI_STATUS
708 EFIAPI
709 BdsLibGetBootMode (
710 OUT EFI_BOOT_MODE *BootMode
711 )
712 {
713 *BootMode = GetBootModeHob ();
714
715 return EFI_SUCCESS;
716 }
717
718 /**
719 Read the EFI variable (VendorGuid/Name) and return a dynamically allocated
720 buffer, and the size of the buffer. If failure return NULL.
721
722 @param Name String part of EFI variable name
723 @param VendorGuid GUID part of EFI variable name
724 @param VariableSize Returns the size of the EFI variable that was read
725
726 @return Dynamically allocated memory that contains a copy of the EFI variable
727 Caller is responsible freeing the buffer.
728 @retval NULL Variable was not read
729
730 **/
731 VOID *
732 EFIAPI
733 BdsLibGetVariableAndSize (
734 IN CHAR16 *Name,
735 IN EFI_GUID *VendorGuid,
736 OUT UINTN *VariableSize
737 )
738 {
739 EFI_STATUS Status;
740 UINTN BufferSize;
741 VOID *Buffer;
742
743 Buffer = NULL;
744
745 //
746 // Pass in a zero size buffer to find the required buffer size.
747 //
748 BufferSize = 0;
749 Status = gRT->GetVariable (Name, VendorGuid, NULL, &BufferSize, Buffer);
750 if (Status == EFI_BUFFER_TOO_SMALL) {
751 //
752 // Allocate the buffer to return
753 //
754 Buffer = AllocateZeroPool (BufferSize);
755 if (Buffer == NULL) {
756 return NULL;
757 }
758 //
759 // Read variable into the allocated buffer.
760 //
761 Status = gRT->GetVariable (Name, VendorGuid, NULL, &BufferSize, Buffer);
762 if (EFI_ERROR (Status)) {
763 BufferSize = 0;
764 }
765 }
766
767 *VariableSize = BufferSize;
768 return Buffer;
769 }
770
771 /**
772 Delete the instance in Multi which matches partly with Single instance
773
774 @param Multi A pointer to a multi-instance device path data
775 structure.
776 @param Single A pointer to a single-instance device path data
777 structure.
778
779 @return This function will remove the device path instances in Multi which partly
780 match with the Single, and return the result device path. If there is no
781 remaining device path as a result, this function will return NULL.
782
783 **/
784 EFI_DEVICE_PATH_PROTOCOL *
785 EFIAPI
786 BdsLibDelPartMatchInstance (
787 IN EFI_DEVICE_PATH_PROTOCOL *Multi,
788 IN EFI_DEVICE_PATH_PROTOCOL *Single
789 )
790 {
791 EFI_DEVICE_PATH_PROTOCOL *Instance;
792 EFI_DEVICE_PATH_PROTOCOL *NewDevicePath;
793 EFI_DEVICE_PATH_PROTOCOL *TempNewDevicePath;
794 UINTN InstanceSize;
795 UINTN SingleDpSize;
796 UINTN Size;
797
798 NewDevicePath = NULL;
799 TempNewDevicePath = NULL;
800
801 if (Multi == NULL || Single == NULL) {
802 return Multi;
803 }
804
805 Instance = GetNextDevicePathInstance (&Multi, &InstanceSize);
806 SingleDpSize = GetDevicePathSize (Single) - END_DEVICE_PATH_LENGTH;
807 InstanceSize -= END_DEVICE_PATH_LENGTH;
808
809 while (Instance != NULL) {
810
811 Size = (SingleDpSize < InstanceSize) ? SingleDpSize : InstanceSize;
812
813 if ((CompareMem (Instance, Single, Size) != 0)) {
814 //
815 // Append the device path instance which does not match with Single
816 //
817 TempNewDevicePath = NewDevicePath;
818 NewDevicePath = AppendDevicePathInstance (NewDevicePath, Instance);
819 if (TempNewDevicePath != NULL) {
820 FreePool(TempNewDevicePath);
821 }
822 }
823 FreePool(Instance);
824 Instance = GetNextDevicePathInstance (&Multi, &InstanceSize);
825 InstanceSize -= END_DEVICE_PATH_LENGTH;
826 }
827
828 return NewDevicePath;
829 }
830
831 /**
832 Function compares a device path data structure to that of all the nodes of a
833 second device path instance.
834
835 @param Multi A pointer to a multi-instance device path data
836 structure.
837 @param Single A pointer to a single-instance device path data
838 structure.
839
840 @retval TRUE If the Single device path is contained within Multi device path.
841 @retval FALSE The Single device path is not match within Multi device path.
842
843 **/
844 BOOLEAN
845 EFIAPI
846 BdsLibMatchDevicePaths (
847 IN EFI_DEVICE_PATH_PROTOCOL *Multi,
848 IN EFI_DEVICE_PATH_PROTOCOL *Single
849 )
850 {
851 EFI_DEVICE_PATH_PROTOCOL *DevicePath;
852 EFI_DEVICE_PATH_PROTOCOL *DevicePathInst;
853 UINTN Size;
854
855 if (Multi == NULL || Single == NULL) {
856 return FALSE;
857 }
858
859 DevicePath = Multi;
860 DevicePathInst = GetNextDevicePathInstance (&DevicePath, &Size);
861
862 //
863 // Search for the match of 'Single' in 'Multi'
864 //
865 while (DevicePathInst != NULL) {
866 //
867 // If the single device path is found in multiple device paths,
868 // return success
869 //
870 if (CompareMem (Single, DevicePathInst, Size) == 0) {
871 FreePool (DevicePathInst);
872 return TRUE;
873 }
874
875 FreePool (DevicePathInst);
876 DevicePathInst = GetNextDevicePathInstance (&DevicePath, &Size);
877 }
878
879 return FALSE;
880 }
881
882 /**
883 This function prints a series of strings.
884
885 @param ConOut Pointer to EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL
886 @param ... A variable argument list containing series of
887 strings, the last string must be NULL.
888
889 @retval EFI_SUCCESS Success print out the string using ConOut.
890 @retval EFI_STATUS Return the status of the ConOut->OutputString ().
891
892 **/
893 EFI_STATUS
894 EFIAPI
895 BdsLibOutputStrings (
896 IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *ConOut,
897 ...
898 )
899 {
900 VA_LIST Args;
901 EFI_STATUS Status;
902 CHAR16 *String;
903
904 Status = EFI_SUCCESS;
905 VA_START (Args, ConOut);
906
907 while (!EFI_ERROR (Status)) {
908 //
909 // If String is NULL, then it's the end of the list
910 //
911 String = VA_ARG (Args, CHAR16 *);
912 if (String == NULL) {
913 break;
914 }
915
916 Status = ConOut->OutputString (ConOut, String);
917
918 if (EFI_ERROR (Status)) {
919 break;
920 }
921 }
922
923 VA_END(Args);
924 return Status;
925 }
926
927 //
928 // Following are BDS Lib functions which contain all the code about setup browser reset reminder feature.
929 // Setup Browser reset reminder feature is that an reset reminder will be given before user leaves the setup browser if
930 // user change any option setting which needs a reset to be effective, and the reset will be applied according to the user selection.
931 //
932
933
934 /**
935 Enable the setup browser reset reminder feature.
936 This routine is used in platform tip. If the platform policy need the feature, use the routine to enable it.
937
938 **/
939 VOID
940 EFIAPI
941 EnableResetReminderFeature (
942 VOID
943 )
944 {
945 mFeaturerSwitch = TRUE;
946 }
947
948
949 /**
950 Disable the setup browser reset reminder feature.
951 This routine is used in platform tip. If the platform policy do not want the feature, use the routine to disable it.
952
953 **/
954 VOID
955 EFIAPI
956 DisableResetReminderFeature (
957 VOID
958 )
959 {
960 mFeaturerSwitch = FALSE;
961 }
962
963
964 /**
965 Record the info that a reset is required.
966 A module boolean variable is used to record whether a reset is required.
967
968 **/
969 VOID
970 EFIAPI
971 EnableResetRequired (
972 VOID
973 )
974 {
975 mResetRequired = TRUE;
976 }
977
978
979 /**
980 Record the info that no reset is required.
981 A module boolean variable is used to record whether a reset is required.
982
983 **/
984 VOID
985 EFIAPI
986 DisableResetRequired (
987 VOID
988 )
989 {
990 mResetRequired = FALSE;
991 }
992
993
994 /**
995 Check whether platform policy enable the reset reminder feature. The default is enabled.
996
997 **/
998 BOOLEAN
999 EFIAPI
1000 IsResetReminderFeatureEnable (
1001 VOID
1002 )
1003 {
1004 return mFeaturerSwitch;
1005 }
1006
1007
1008 /**
1009 Check if user changed any option setting which needs a system reset to be effective.
1010
1011 **/
1012 BOOLEAN
1013 EFIAPI
1014 IsResetRequired (
1015 VOID
1016 )
1017 {
1018 return mResetRequired;
1019 }
1020
1021
1022 /**
1023 Check whether a reset is needed, and finish the reset reminder feature.
1024 If a reset is needed, Popup a menu to notice user, and finish the feature
1025 according to the user selection.
1026
1027 **/
1028 VOID
1029 EFIAPI
1030 SetupResetReminder (
1031 VOID
1032 )
1033 {
1034 EFI_INPUT_KEY Key;
1035 CHAR16 *StringBuffer1;
1036 CHAR16 *StringBuffer2;
1037
1038
1039 //
1040 //check any reset required change is applied? if yes, reset system
1041 //
1042 if (IsResetReminderFeatureEnable ()) {
1043 if (IsResetRequired ()) {
1044
1045 StringBuffer1 = AllocateZeroPool (MAX_STRING_LEN * sizeof (CHAR16));
1046 ASSERT (StringBuffer1 != NULL);
1047 StringBuffer2 = AllocateZeroPool (MAX_STRING_LEN * sizeof (CHAR16));
1048 ASSERT (StringBuffer2 != NULL);
1049 StrCpy (StringBuffer1, L"Configuration changed. Reset to apply it Now ? ");
1050 StrCpy (StringBuffer2, L"Enter (YES) / Esc (NO)");
1051 //
1052 // Popup a menu to notice user
1053 //
1054 do {
1055 CreatePopUp (EFI_LIGHTGRAY | EFI_BACKGROUND_BLUE, &Key, StringBuffer1, StringBuffer2, NULL);
1056 } while ((Key.ScanCode != SCAN_ESC) && (Key.UnicodeChar != CHAR_CARRIAGE_RETURN));
1057
1058 FreePool (StringBuffer1);
1059 FreePool (StringBuffer2);
1060 //
1061 // If the user hits the YES Response key, reset
1062 //
1063 if (Key.UnicodeChar == CHAR_CARRIAGE_RETURN) {
1064 gRT->ResetSystem (EfiResetCold, EFI_SUCCESS, 0, NULL);
1065 }
1066 gST->ConOut->ClearScreen (gST->ConOut);
1067 }
1068 }
1069 }
1070
1071 /**
1072 Get the headers (dos, image, optional header) from an image
1073
1074 @param Device SimpleFileSystem device handle
1075 @param FileName File name for the image
1076 @param DosHeader Pointer to dos header
1077 @param Hdr The buffer in which to return the PE32, PE32+, or TE header.
1078
1079 @retval EFI_SUCCESS Successfully get the machine type.
1080 @retval EFI_NOT_FOUND The file is not found.
1081 @retval EFI_LOAD_ERROR File is not a valid image file.
1082
1083 **/
1084 EFI_STATUS
1085 EFIAPI
1086 BdsLibGetImageHeader (
1087 IN EFI_HANDLE Device,
1088 IN CHAR16 *FileName,
1089 OUT EFI_IMAGE_DOS_HEADER *DosHeader,
1090 OUT EFI_IMAGE_OPTIONAL_HEADER_PTR_UNION Hdr
1091 )
1092 {
1093 EFI_STATUS Status;
1094 EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *Volume;
1095 EFI_FILE_HANDLE Root;
1096 EFI_FILE_HANDLE ThisFile;
1097 UINTN BufferSize;
1098 UINT64 FileSize;
1099 EFI_FILE_INFO *Info;
1100
1101 Root = NULL;
1102 ThisFile = NULL;
1103 //
1104 // Handle the file system interface to the device
1105 //
1106 Status = gBS->HandleProtocol (
1107 Device,
1108 &gEfiSimpleFileSystemProtocolGuid,
1109 (VOID *) &Volume
1110 );
1111 if (EFI_ERROR (Status)) {
1112 goto Done;
1113 }
1114
1115 Status = Volume->OpenVolume (
1116 Volume,
1117 &Root
1118 );
1119 if (EFI_ERROR (Status)) {
1120 Root = NULL;
1121 goto Done;
1122 }
1123 ASSERT (Root != NULL);
1124 Status = Root->Open (Root, &ThisFile, FileName, EFI_FILE_MODE_READ, 0);
1125 if (EFI_ERROR (Status)) {
1126 goto Done;
1127 }
1128 ASSERT (ThisFile != NULL);
1129
1130 //
1131 // Get file size
1132 //
1133 BufferSize = SIZE_OF_EFI_FILE_INFO + 200;
1134 do {
1135 Info = NULL;
1136 Status = gBS->AllocatePool (EfiBootServicesData, BufferSize, (VOID **) &Info);
1137 if (EFI_ERROR (Status)) {
1138 goto Done;
1139 }
1140 Status = ThisFile->GetInfo (
1141 ThisFile,
1142 &gEfiFileInfoGuid,
1143 &BufferSize,
1144 Info
1145 );
1146 if (!EFI_ERROR (Status)) {
1147 break;
1148 }
1149 if (Status != EFI_BUFFER_TOO_SMALL) {
1150 FreePool (Info);
1151 goto Done;
1152 }
1153 FreePool (Info);
1154 } while (TRUE);
1155
1156 FileSize = Info->FileSize;
1157 FreePool (Info);
1158
1159 //
1160 // Read dos header
1161 //
1162 BufferSize = sizeof (EFI_IMAGE_DOS_HEADER);
1163 Status = ThisFile->Read (ThisFile, &BufferSize, DosHeader);
1164 if (EFI_ERROR (Status) ||
1165 BufferSize < sizeof (EFI_IMAGE_DOS_HEADER) ||
1166 FileSize <= DosHeader->e_lfanew ||
1167 DosHeader->e_magic != EFI_IMAGE_DOS_SIGNATURE) {
1168 Status = EFI_LOAD_ERROR;
1169 goto Done;
1170 }
1171
1172 //
1173 // Move to PE signature
1174 //
1175 Status = ThisFile->SetPosition (ThisFile, DosHeader->e_lfanew);
1176 if (EFI_ERROR (Status)) {
1177 Status = EFI_LOAD_ERROR;
1178 goto Done;
1179 }
1180
1181 //
1182 // Read and check PE signature
1183 //
1184 BufferSize = sizeof (EFI_IMAGE_OPTIONAL_HEADER_UNION);
1185 Status = ThisFile->Read (ThisFile, &BufferSize, Hdr.Pe32);
1186 if (EFI_ERROR (Status) ||
1187 BufferSize < sizeof (EFI_IMAGE_OPTIONAL_HEADER_UNION) ||
1188 Hdr.Pe32->Signature != EFI_IMAGE_NT_SIGNATURE) {
1189 Status = EFI_LOAD_ERROR;
1190 goto Done;
1191 }
1192
1193 //
1194 // Check PE32 or PE32+ magic
1195 //
1196 if (Hdr.Pe32->OptionalHeader.Magic != EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC &&
1197 Hdr.Pe32->OptionalHeader.Magic != EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC) {
1198 Status = EFI_LOAD_ERROR;
1199 goto Done;
1200 }
1201
1202 Done:
1203 if (ThisFile != NULL) {
1204 ThisFile->Close (ThisFile);
1205 }
1206 if (Root != NULL) {
1207 Root->Close (Root);
1208 }
1209 return Status;
1210 }
1211
1212 /**
1213 This routine adjusts the memory information for different memory type and
1214 saves them into the variables for next boot. It conditionally resets the
1215 system when the memory information changes. Platform can reserve memory
1216 large enough (125% of actual requirement) to avoid the reset in the first boot.
1217 **/
1218 VOID
1219 BdsSetMemoryTypeInformationVariable (
1220 VOID
1221 )
1222 {
1223 EFI_STATUS Status;
1224 EFI_MEMORY_TYPE_INFORMATION *PreviousMemoryTypeInformation;
1225 EFI_MEMORY_TYPE_INFORMATION *CurrentMemoryTypeInformation;
1226 UINTN VariableSize;
1227 UINTN Index;
1228 UINTN Index1;
1229 UINT32 Previous;
1230 UINT32 Current;
1231 UINT32 Next;
1232 EFI_HOB_GUID_TYPE *GuidHob;
1233 BOOLEAN MemoryTypeInformationModified;
1234 BOOLEAN MemoryTypeInformationVariableExists;
1235 EFI_BOOT_MODE BootMode;
1236
1237 MemoryTypeInformationModified = FALSE;
1238 MemoryTypeInformationVariableExists = FALSE;
1239
1240
1241 BootMode = GetBootModeHob ();
1242 //
1243 // In BOOT_IN_RECOVERY_MODE, Variable region is not reliable.
1244 //
1245 if (BootMode == BOOT_IN_RECOVERY_MODE) {
1246 return;
1247 }
1248
1249 //
1250 // Only check the the Memory Type Information variable in the boot mode
1251 // other than BOOT_WITH_DEFAULT_SETTINGS because the Memory Type
1252 // Information is not valid in this boot mode.
1253 //
1254 if (BootMode != BOOT_WITH_DEFAULT_SETTINGS) {
1255 VariableSize = 0;
1256 Status = gRT->GetVariable (
1257 EFI_MEMORY_TYPE_INFORMATION_VARIABLE_NAME,
1258 &gEfiMemoryTypeInformationGuid,
1259 NULL,
1260 &VariableSize,
1261 NULL
1262 );
1263 if (Status == EFI_BUFFER_TOO_SMALL) {
1264 MemoryTypeInformationVariableExists = TRUE;
1265 }
1266 }
1267
1268 //
1269 // Retrieve the current memory usage statistics. If they are not found, then
1270 // no adjustments can be made to the Memory Type Information variable.
1271 //
1272 Status = EfiGetSystemConfigurationTable (
1273 &gEfiMemoryTypeInformationGuid,
1274 (VOID **) &CurrentMemoryTypeInformation
1275 );
1276 if (EFI_ERROR (Status) || CurrentMemoryTypeInformation == NULL) {
1277 return;
1278 }
1279
1280 //
1281 // Get the Memory Type Information settings from Hob if they exist,
1282 // PEI is responsible for getting them from variable and build a Hob to save them.
1283 // If the previous Memory Type Information is not available, then set defaults
1284 //
1285 GuidHob = GetFirstGuidHob (&gEfiMemoryTypeInformationGuid);
1286 if (GuidHob == NULL) {
1287 //
1288 // If Platform has not built Memory Type Info into the Hob, just return.
1289 //
1290 return;
1291 }
1292 PreviousMemoryTypeInformation = GET_GUID_HOB_DATA (GuidHob);
1293 VariableSize = GET_GUID_HOB_DATA_SIZE (GuidHob);
1294
1295 //
1296 // Use a heuristic to adjust the Memory Type Information for the next boot
1297 //
1298 DEBUG ((EFI_D_INFO, "Memory Previous Current Next \n"));
1299 DEBUG ((EFI_D_INFO, " Type Pages Pages Pages \n"));
1300 DEBUG ((EFI_D_INFO, "====== ======== ======== ========\n"));
1301
1302 for (Index = 0; PreviousMemoryTypeInformation[Index].Type != EfiMaxMemoryType; Index++) {
1303
1304 for (Index1 = 0; CurrentMemoryTypeInformation[Index1].Type != EfiMaxMemoryType; Index1++) {
1305 if (PreviousMemoryTypeInformation[Index].Type == CurrentMemoryTypeInformation[Index1].Type) {
1306 break;
1307 }
1308 }
1309 if (CurrentMemoryTypeInformation[Index1].Type == EfiMaxMemoryType) {
1310 continue;
1311 }
1312
1313 //
1314 // Previous is the number of pages pre-allocated
1315 // Current is the number of pages actually needed
1316 //
1317 Previous = PreviousMemoryTypeInformation[Index].NumberOfPages;
1318 Current = CurrentMemoryTypeInformation[Index1].NumberOfPages;
1319 Next = Previous;
1320
1321 //
1322 // Write next varible to 125% * current and Inconsistent Memory Reserved across bootings may lead to S4 fail
1323 //
1324 if (Current < Previous) {
1325 if (BootMode == BOOT_WITH_DEFAULT_SETTINGS) {
1326 Next = Current + (Current >> 2);
1327 } else if (!MemoryTypeInformationVariableExists) {
1328 Next = MAX (Current + (Current >> 2), Previous);
1329 }
1330 } else if (Current > Previous) {
1331 Next = Current + (Current >> 2);
1332 }
1333 if (Next > 0 && Next < 4) {
1334 Next = 4;
1335 }
1336
1337 if (Next != Previous) {
1338 PreviousMemoryTypeInformation[Index].NumberOfPages = Next;
1339 MemoryTypeInformationModified = TRUE;
1340 }
1341
1342 DEBUG ((EFI_D_INFO, " %02x %08x %08x %08x\n", PreviousMemoryTypeInformation[Index].Type, Previous, Current, Next));
1343 }
1344
1345 //
1346 // If any changes were made to the Memory Type Information settings, then set the new variable value;
1347 // Or create the variable in first boot.
1348 //
1349 if (MemoryTypeInformationModified || !MemoryTypeInformationVariableExists) {
1350 Status = gRT->SetVariable (
1351 EFI_MEMORY_TYPE_INFORMATION_VARIABLE_NAME,
1352 &gEfiMemoryTypeInformationGuid,
1353 EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
1354 VariableSize,
1355 PreviousMemoryTypeInformation
1356 );
1357
1358 //
1359 // If the Memory Type Information settings have been modified, then reset the platform
1360 // so the new Memory Type Information setting will be used to guarantee that an S4
1361 // entry/resume cycle will not fail.
1362 //
1363 if (MemoryTypeInformationModified && PcdGetBool (PcdResetOnMemoryTypeInformationChange)) {
1364 DEBUG ((EFI_D_INFO, "Memory Type Information settings change. Warm Reset!!!\n"));
1365 gRT->ResetSystem (EfiResetWarm, EFI_SUCCESS, 0, NULL);
1366 }
1367 }
1368 }
1369
1370 /**
1371 This routine is kept for backward compatibility.
1372 **/
1373 VOID
1374 EFIAPI
1375 BdsLibSaveMemoryTypeInformation (
1376 VOID
1377 )
1378 {
1379 }
1380
1381
1382 /**
1383 Identify a user and, if authenticated, returns the current user profile handle.
1384
1385 @param[out] User Point to user profile handle.
1386
1387 @retval EFI_SUCCESS User is successfully identified, or user identification
1388 is not supported.
1389 @retval EFI_ACCESS_DENIED User is not successfully identified
1390
1391 **/
1392 EFI_STATUS
1393 EFIAPI
1394 BdsLibUserIdentify (
1395 OUT EFI_USER_PROFILE_HANDLE *User
1396 )
1397 {
1398 EFI_STATUS Status;
1399 EFI_USER_MANAGER_PROTOCOL *Manager;
1400
1401 Status = gBS->LocateProtocol (
1402 &gEfiUserManagerProtocolGuid,
1403 NULL,
1404 (VOID **) &Manager
1405 );
1406 if (EFI_ERROR (Status)) {
1407 return EFI_SUCCESS;
1408 }
1409
1410 return Manager->Identify (Manager, User);
1411 }
1412
EFI Development Kit II mirror for PVE