VirtualBox

source: vbox/trunk/src/VBox/Devices/EFI/FirmwareNew/MdeModulePkg/Library/SmmLockBoxLib/SmmLockBoxDxeLib.c@ 85716

最後變更 在這個檔案從85716是 80721,由 vboxsync 提交於 6 年 前

Devices/EFI/FirmwareNew: Start upgrade process to edk2-stable201908 (compiles on Windows and works to some extent), bugref:4643
  • 屬性 svn:eol-style 設為 native
檔案大小: 19.4 KB
行 
1/** @file
2
3Copyright (c) 2010 - 2019, Intel Corporation. All rights reserved.<BR>
4
5SPDX-License-Identifier: BSD-2-Clause-Patent
6
7**/
8
9#include <PiDxe.h>
10#include <Library/UefiBootServicesTableLib.h>
11#include <Library/UefiRuntimeServicesTableLib.h>
12#include <Library/BaseLib.h>
13#include <Library/BaseMemoryLib.h>
14#include <Library/LockBoxLib.h>
15#include <Library/DebugLib.h>
16#include <Library/UefiLib.h>
17#include <Protocol/SmmCommunication.h>
18#include <Guid/SmmLockBox.h>
19#include <Guid/PiSmmCommunicationRegionTable.h>
20
21#include "SmmLockBoxLibPrivate.h"
22
23EFI_SMM_COMMUNICATION_PROTOCOL *mLockBoxSmmCommProtocol = NULL;
24UINT8 *mLockBoxSmmCommBuffer = NULL;
25
26/**
27 Get smm communication protocol for lockbox.
28
29 @return Pointer to smm communication protocol, NULL if not found.
30
31**/
32EFI_SMM_COMMUNICATION_PROTOCOL *
33LockBoxGetSmmCommProtocol (
34 VOID
35 )
36{
37 EFI_STATUS Status;
38
39 //
40 // If the protocol has been got previously, return it.
41 //
42 if (mLockBoxSmmCommProtocol != NULL) {
43 return mLockBoxSmmCommProtocol;
44 }
45
46 Status = gBS->LocateProtocol (
47 &gEfiSmmCommunicationProtocolGuid,
48 NULL,
49 (VOID **)&mLockBoxSmmCommProtocol
50 );
51 if (EFI_ERROR (Status)) {
52 mLockBoxSmmCommProtocol = NULL;
53 }
54 return mLockBoxSmmCommProtocol;
55}
56
57/**
58 Get smm communication buffer for lockbox.
59
60 @return Pointer to smm communication buffer, NULL if not found.
61
62**/
63UINT8 *
64LockBoxGetSmmCommBuffer (
65 VOID
66 )
67{
68 EFI_STATUS Status;
69 UINTN MinimalSizeNeeded;
70 EDKII_PI_SMM_COMMUNICATION_REGION_TABLE *PiSmmCommunicationRegionTable;
71 UINT32 Index;
72 EFI_MEMORY_DESCRIPTOR *Entry;
73 UINTN Size;
74
75 //
76 // If the buffer has been got previously, return it.
77 //
78 if (mLockBoxSmmCommBuffer != NULL) {
79 return mLockBoxSmmCommBuffer;
80 }
81
82 MinimalSizeNeeded = sizeof (EFI_GUID) +
83 sizeof (UINTN) +
84 MAX (sizeof (EFI_SMM_LOCK_BOX_PARAMETER_SAVE),
85 MAX (sizeof (EFI_SMM_LOCK_BOX_PARAMETER_SET_ATTRIBUTES),
86 MAX (sizeof (EFI_SMM_LOCK_BOX_PARAMETER_UPDATE),
87 MAX (sizeof (EFI_SMM_LOCK_BOX_PARAMETER_RESTORE),
88 sizeof (EFI_SMM_LOCK_BOX_PARAMETER_RESTORE_ALL_IN_PLACE)))));
89
90 Status = EfiGetSystemConfigurationTable (
91 &gEdkiiPiSmmCommunicationRegionTableGuid,
92 (VOID **) &PiSmmCommunicationRegionTable
93 );
94 if (EFI_ERROR (Status)) {
95 mLockBoxSmmCommBuffer = NULL;
96 return mLockBoxSmmCommBuffer;
97 }
98 ASSERT (PiSmmCommunicationRegionTable != NULL);
99 Entry = (EFI_MEMORY_DESCRIPTOR *) (PiSmmCommunicationRegionTable + 1);
100 Size = 0;
101 for (Index = 0; Index < PiSmmCommunicationRegionTable->NumberOfEntries; Index++) {
102 if (Entry->Type == EfiConventionalMemory) {
103 Size = EFI_PAGES_TO_SIZE ((UINTN) Entry->NumberOfPages);
104 if (Size >= MinimalSizeNeeded) {
105 break;
106 }
107 }
108 Entry = (EFI_MEMORY_DESCRIPTOR *) ((UINT8 *) Entry + PiSmmCommunicationRegionTable->DescriptorSize);
109 }
110 if (Index >= PiSmmCommunicationRegionTable->NumberOfEntries) {
111 mLockBoxSmmCommBuffer = NULL;
112 } else {
113 mLockBoxSmmCommBuffer = (UINT8 *) (UINTN) Entry->PhysicalStart;
114 }
115 return mLockBoxSmmCommBuffer;
116}
117
118/**
119 This function will save confidential information to lockbox.
120
121 @param Guid the guid to identify the confidential information
122 @param Buffer the address of the confidential information
123 @param Length the length of the confidential information
124
125 @retval RETURN_SUCCESS the information is saved successfully.
126 @retval RETURN_INVALID_PARAMETER the Guid is NULL, or Buffer is NULL, or Length is 0
127 @retval RETURN_ALREADY_STARTED the requested GUID already exist.
128 @retval RETURN_OUT_OF_RESOURCES no enough resource to save the information.
129 @retval RETURN_ACCESS_DENIED it is too late to invoke this interface
130 @retval RETURN_NOT_STARTED it is too early to invoke this interface
131 @retval RETURN_UNSUPPORTED the service is not supported by implementaion.
132**/
133RETURN_STATUS
134EFIAPI
135SaveLockBox (
136 IN GUID *Guid,
137 IN VOID *Buffer,
138 IN UINTN Length
139 )
140{
141 EFI_STATUS Status;
142 EFI_SMM_COMMUNICATION_PROTOCOL *SmmCommunication;
143 EFI_SMM_LOCK_BOX_PARAMETER_SAVE *LockBoxParameterSave;
144 EFI_SMM_COMMUNICATE_HEADER *CommHeader;
145 UINT8 TempCommBuffer[sizeof(EFI_GUID) + sizeof(UINTN) + sizeof(EFI_SMM_LOCK_BOX_PARAMETER_SAVE)];
146 UINT8 *CommBuffer;
147 UINTN CommSize;
148
149 DEBUG ((DEBUG_INFO, "SmmLockBoxDxeLib SaveLockBox - Enter\n"));
150
151 //
152 // Basic check
153 //
154 if ((Guid == NULL) || (Buffer == NULL) || (Length == 0)) {
155 return EFI_INVALID_PARAMETER;
156 }
157
158 SmmCommunication = LockBoxGetSmmCommProtocol ();
159 if (SmmCommunication == NULL) {
160 return EFI_NOT_STARTED;
161 }
162
163 //
164 // Prepare parameter
165 //
166 CommBuffer = LockBoxGetSmmCommBuffer ();
167 if (CommBuffer == NULL) {
168 CommBuffer = &TempCommBuffer[0];
169 }
170 CommHeader = (EFI_SMM_COMMUNICATE_HEADER *)&CommBuffer[0];
171 CopyMem (&CommHeader->HeaderGuid, &gEfiSmmLockBoxCommunicationGuid, sizeof(gEfiSmmLockBoxCommunicationGuid));
172 CommHeader->MessageLength = sizeof(*LockBoxParameterSave);
173
174 LockBoxParameterSave = (EFI_SMM_LOCK_BOX_PARAMETER_SAVE *)&CommBuffer[OFFSET_OF (EFI_SMM_COMMUNICATE_HEADER, Data)];
175 LockBoxParameterSave->Header.Command = EFI_SMM_LOCK_BOX_COMMAND_SAVE;
176 LockBoxParameterSave->Header.DataLength = sizeof(*LockBoxParameterSave);
177 LockBoxParameterSave->Header.ReturnStatus = (UINT64)-1;
178 CopyMem (&LockBoxParameterSave->Guid, Guid, sizeof(*Guid));
179 LockBoxParameterSave->Buffer = (EFI_PHYSICAL_ADDRESS)(UINTN)Buffer;
180 LockBoxParameterSave->Length = (UINT64)Length;
181
182 //
183 // Send command
184 //
185 CommSize = sizeof(EFI_GUID) + sizeof(UINTN) + sizeof(EFI_SMM_LOCK_BOX_PARAMETER_SAVE);
186 Status = SmmCommunication->Communicate (
187 SmmCommunication,
188 &CommBuffer[0],
189 &CommSize
190 );
191 ASSERT_EFI_ERROR (Status);
192
193 Status = (EFI_STATUS)LockBoxParameterSave->Header.ReturnStatus;
194
195 DEBUG ((DEBUG_INFO, "SmmLockBoxDxeLib SaveLockBox - Exit (%r)\n", Status));
196
197 //
198 // Done
199 //
200 return Status;
201}
202
203/**
204 This function will set lockbox attributes.
205
206 @param Guid the guid to identify the confidential information
207 @param Attributes the attributes of the lockbox
208
209 @retval RETURN_SUCCESS the information is saved successfully.
210 @retval RETURN_INVALID_PARAMETER attributes is invalid.
211 @retval RETURN_NOT_FOUND the requested GUID not found.
212 @retval RETURN_ACCESS_DENIED it is too late to invoke this interface
213 @retval RETURN_NOT_STARTED it is too early to invoke this interface
214 @retval RETURN_UNSUPPORTED the service is not supported by implementaion.
215**/
216RETURN_STATUS
217EFIAPI
218SetLockBoxAttributes (
219 IN GUID *Guid,
220 IN UINT64 Attributes
221 )
222{
223 EFI_STATUS Status;
224 EFI_SMM_COMMUNICATION_PROTOCOL *SmmCommunication;
225 EFI_SMM_LOCK_BOX_PARAMETER_SET_ATTRIBUTES *LockBoxParameterSetAttributes;
226 EFI_SMM_COMMUNICATE_HEADER *CommHeader;
227 UINT8 TempCommBuffer[sizeof(EFI_GUID) + sizeof(UINTN) + sizeof(EFI_SMM_LOCK_BOX_PARAMETER_SET_ATTRIBUTES)];
228 UINT8 *CommBuffer;
229 UINTN CommSize;
230
231 DEBUG ((DEBUG_INFO, "SmmLockBoxDxeLib SetLockBoxAttributes - Enter\n"));
232
233 //
234 // Basic check
235 //
236 if ((Guid == NULL) ||
237 ((Attributes & ~(LOCK_BOX_ATTRIBUTE_RESTORE_IN_PLACE | LOCK_BOX_ATTRIBUTE_RESTORE_IN_S3_ONLY)) != 0)) {
238 return EFI_INVALID_PARAMETER;
239 }
240
241 SmmCommunication = LockBoxGetSmmCommProtocol ();
242 if (SmmCommunication == NULL) {
243 return EFI_NOT_STARTED;
244 }
245
246 //
247 // Prepare parameter
248 //
249 CommBuffer = LockBoxGetSmmCommBuffer ();
250 if (CommBuffer == NULL) {
251 CommBuffer = &TempCommBuffer[0];
252 }
253 CommHeader = (EFI_SMM_COMMUNICATE_HEADER *)&CommBuffer[0];
254 CopyMem (&CommHeader->HeaderGuid, &gEfiSmmLockBoxCommunicationGuid, sizeof(gEfiSmmLockBoxCommunicationGuid));
255 CommHeader->MessageLength = sizeof(*LockBoxParameterSetAttributes);
256
257 LockBoxParameterSetAttributes = (EFI_SMM_LOCK_BOX_PARAMETER_SET_ATTRIBUTES *)&CommBuffer[OFFSET_OF (EFI_SMM_COMMUNICATE_HEADER, Data)];
258 LockBoxParameterSetAttributes->Header.Command = EFI_SMM_LOCK_BOX_COMMAND_SET_ATTRIBUTES;
259 LockBoxParameterSetAttributes->Header.DataLength = sizeof(*LockBoxParameterSetAttributes);
260 LockBoxParameterSetAttributes->Header.ReturnStatus = (UINT64)-1;
261 CopyMem (&LockBoxParameterSetAttributes->Guid, Guid, sizeof(*Guid));
262 LockBoxParameterSetAttributes->Attributes = (UINT64)Attributes;
263
264 //
265 // Send command
266 //
267 CommSize = sizeof(EFI_GUID) + sizeof(UINTN) + sizeof(EFI_SMM_LOCK_BOX_PARAMETER_SET_ATTRIBUTES);
268 Status = SmmCommunication->Communicate (
269 SmmCommunication,
270 &CommBuffer[0],
271 &CommSize
272 );
273 ASSERT_EFI_ERROR (Status);
274
275 Status = (EFI_STATUS)LockBoxParameterSetAttributes->Header.ReturnStatus;
276
277 DEBUG ((DEBUG_INFO, "SmmLockBoxDxeLib SetLockBoxAttributes - Exit (%r)\n", Status));
278
279 //
280 // Done
281 //
282 return Status;
283}
284
285/**
286 This function will update confidential information to lockbox.
287
288 @param Guid the guid to identify the original confidential information
289 @param Offset the offset of the original confidential information
290 @param Buffer the address of the updated confidential information
291 @param Length the length of the updated confidential information
292
293 @retval RETURN_SUCCESS the information is saved successfully.
294 @retval RETURN_INVALID_PARAMETER the Guid is NULL, or Buffer is NULL, or Length is 0.
295 @retval RETURN_NOT_FOUND the requested GUID not found.
296 @retval RETURN_BUFFER_TOO_SMALL for lockbox without attribute LOCK_BOX_ATTRIBUTE_RESTORE_IN_S3_ONLY,
297 the original buffer to too small to hold new information.
298 @retval RETURN_OUT_OF_RESOURCES for lockbox with attribute LOCK_BOX_ATTRIBUTE_RESTORE_IN_S3_ONLY,
299 no enough resource to save the information.
300 @retval RETURN_ACCESS_DENIED it is too late to invoke this interface
301 @retval RETURN_NOT_STARTED it is too early to invoke this interface
302 @retval RETURN_UNSUPPORTED the service is not supported by implementaion.
303**/
304RETURN_STATUS
305EFIAPI
306UpdateLockBox (
307 IN GUID *Guid,
308 IN UINTN Offset,
309 IN VOID *Buffer,
310 IN UINTN Length
311 )
312{
313 EFI_STATUS Status;
314 EFI_SMM_COMMUNICATION_PROTOCOL *SmmCommunication;
315 EFI_SMM_LOCK_BOX_PARAMETER_UPDATE *LockBoxParameterUpdate;
316 EFI_SMM_COMMUNICATE_HEADER *CommHeader;
317 UINT8 TempCommBuffer[sizeof(EFI_GUID) + sizeof(UINTN) + sizeof(EFI_SMM_LOCK_BOX_PARAMETER_UPDATE)];
318 UINT8 *CommBuffer;
319 UINTN CommSize;
320
321 DEBUG ((DEBUG_INFO, "SmmLockBoxDxeLib UpdateLockBox - Enter\n"));
322
323 //
324 // Basic check
325 //
326 if ((Guid == NULL) || (Buffer == NULL) || (Length == 0)) {
327 return EFI_INVALID_PARAMETER;
328 }
329
330 SmmCommunication = LockBoxGetSmmCommProtocol ();
331 if (SmmCommunication == NULL) {
332 return EFI_NOT_STARTED;
333 }
334
335 //
336 // Prepare parameter
337 //
338 CommBuffer = LockBoxGetSmmCommBuffer ();
339 if (CommBuffer == NULL) {
340 CommBuffer = &TempCommBuffer[0];
341 }
342 CommHeader = (EFI_SMM_COMMUNICATE_HEADER *)&CommBuffer[0];
343 CopyMem (&CommHeader->HeaderGuid, &gEfiSmmLockBoxCommunicationGuid, sizeof(gEfiSmmLockBoxCommunicationGuid));
344 CommHeader->MessageLength = sizeof(*LockBoxParameterUpdate);
345
346 LockBoxParameterUpdate = (EFI_SMM_LOCK_BOX_PARAMETER_UPDATE *)(UINTN)&CommBuffer[OFFSET_OF (EFI_SMM_COMMUNICATE_HEADER, Data)];
347 LockBoxParameterUpdate->Header.Command = EFI_SMM_LOCK_BOX_COMMAND_UPDATE;
348 LockBoxParameterUpdate->Header.DataLength = sizeof(*LockBoxParameterUpdate);
349 LockBoxParameterUpdate->Header.ReturnStatus = (UINT64)-1;
350 CopyMem (&LockBoxParameterUpdate->Guid, Guid, sizeof(*Guid));
351 LockBoxParameterUpdate->Offset = (UINT64)Offset;
352 LockBoxParameterUpdate->Buffer = (EFI_PHYSICAL_ADDRESS)(UINTN)Buffer;
353 LockBoxParameterUpdate->Length = (UINT64)Length;
354
355 //
356 // Send command
357 //
358 CommSize = sizeof(EFI_GUID) + sizeof(UINTN) + sizeof(EFI_SMM_LOCK_BOX_PARAMETER_UPDATE);
359 Status = SmmCommunication->Communicate (
360 SmmCommunication,
361 &CommBuffer[0],
362 &CommSize
363 );
364 ASSERT_EFI_ERROR (Status);
365
366 Status = (EFI_STATUS)LockBoxParameterUpdate->Header.ReturnStatus;
367
368 DEBUG ((DEBUG_INFO, "SmmLockBoxDxeLib UpdateLockBox - Exit (%r)\n", Status));
369
370 //
371 // Done
372 //
373 return Status;
374}
375
376/**
377 This function will restore confidential information from lockbox.
378
379 @param Guid the guid to identify the confidential information
380 @param Buffer the address of the restored confidential information
381 NULL means restored to original address, Length MUST be NULL at same time.
382 @param Length the length of the restored confidential information
383
384 @retval RETURN_SUCCESS the information is restored successfully.
385 @retval RETURN_INVALID_PARAMETER the Guid is NULL, or one of Buffer and Length is NULL.
386 @retval RETURN_WRITE_PROTECTED Buffer and Length are NULL, but the LockBox has no
387 LOCK_BOX_ATTRIBUTE_RESTORE_IN_PLACE attribute.
388 @retval RETURN_BUFFER_TOO_SMALL the Length is too small to hold the confidential information.
389 @retval RETURN_NOT_FOUND the requested GUID not found.
390 @retval RETURN_NOT_STARTED it is too early to invoke this interface
391 @retval RETURN_ACCESS_DENIED not allow to restore to the address
392 @retval RETURN_UNSUPPORTED the service is not supported by implementaion.
393**/
394RETURN_STATUS
395EFIAPI
396RestoreLockBox (
397 IN GUID *Guid,
398 IN VOID *Buffer, OPTIONAL
399 IN OUT UINTN *Length OPTIONAL
400 )
401{
402 EFI_STATUS Status;
403 EFI_SMM_COMMUNICATION_PROTOCOL *SmmCommunication;
404 EFI_SMM_LOCK_BOX_PARAMETER_RESTORE *LockBoxParameterRestore;
405 EFI_SMM_COMMUNICATE_HEADER *CommHeader;
406 UINT8 TempCommBuffer[sizeof(EFI_GUID) + sizeof(UINTN) + sizeof(EFI_SMM_LOCK_BOX_PARAMETER_RESTORE)];
407 UINT8 *CommBuffer;
408 UINTN CommSize;
409
410 DEBUG ((DEBUG_INFO, "SmmLockBoxDxeLib RestoreLockBox - Enter\n"));
411
412 //
413 // Basic check
414 //
415 if ((Guid == NULL) ||
416 ((Buffer == NULL) && (Length != NULL)) ||
417 ((Buffer != NULL) && (Length == NULL))) {
418 return EFI_INVALID_PARAMETER;
419 }
420
421 SmmCommunication = LockBoxGetSmmCommProtocol ();
422 if (SmmCommunication == NULL) {
423 return EFI_NOT_STARTED;
424 }
425
426 //
427 // Prepare parameter
428 //
429 CommBuffer = LockBoxGetSmmCommBuffer ();
430 if (CommBuffer == NULL) {
431 CommBuffer = &TempCommBuffer[0];
432 }
433 CommHeader = (EFI_SMM_COMMUNICATE_HEADER *)&CommBuffer[0];
434 CopyMem (&CommHeader->HeaderGuid, &gEfiSmmLockBoxCommunicationGuid, sizeof(gEfiSmmLockBoxCommunicationGuid));
435 CommHeader->MessageLength = sizeof(*LockBoxParameterRestore);
436
437 LockBoxParameterRestore = (EFI_SMM_LOCK_BOX_PARAMETER_RESTORE *)&CommBuffer[OFFSET_OF (EFI_SMM_COMMUNICATE_HEADER, Data)];
438 LockBoxParameterRestore->Header.Command = EFI_SMM_LOCK_BOX_COMMAND_RESTORE;
439 LockBoxParameterRestore->Header.DataLength = sizeof(*LockBoxParameterRestore);
440 LockBoxParameterRestore->Header.ReturnStatus = (UINT64)-1;
441 CopyMem (&LockBoxParameterRestore->Guid, Guid, sizeof(*Guid));
442 LockBoxParameterRestore->Buffer = (EFI_PHYSICAL_ADDRESS)(UINTN)Buffer;
443 if (Length != NULL) {
444 LockBoxParameterRestore->Length = (EFI_PHYSICAL_ADDRESS)*Length;
445 } else {
446 LockBoxParameterRestore->Length = 0;
447 }
448
449 //
450 // Send command
451 //
452 CommSize = sizeof(EFI_GUID) + sizeof(UINTN) + sizeof(EFI_SMM_LOCK_BOX_PARAMETER_RESTORE);
453 Status = SmmCommunication->Communicate (
454 SmmCommunication,
455 &CommBuffer[0],
456 &CommSize
457 );
458 ASSERT_EFI_ERROR (Status);
459
460 if (Length != NULL) {
461 *Length = (UINTN)LockBoxParameterRestore->Length;
462 }
463
464 Status = (EFI_STATUS)LockBoxParameterRestore->Header.ReturnStatus;
465
466 DEBUG ((DEBUG_INFO, "SmmLockBoxDxeLib RestoreLockBox - Exit (%r)\n", Status));
467
468 //
469 // Done
470 //
471 return Status;
472}
473
474/**
475 This function will restore confidential information from all lockbox which have RestoreInPlace attribute.
476
477 @retval RETURN_SUCCESS the information is restored successfully.
478 @retval RETURN_NOT_STARTED it is too early to invoke this interface
479 @retval RETURN_UNSUPPORTED the service is not supported by implementaion.
480**/
481RETURN_STATUS
482EFIAPI
483RestoreAllLockBoxInPlace (
484 VOID
485 )
486{
487 EFI_STATUS Status;
488 EFI_SMM_COMMUNICATION_PROTOCOL *SmmCommunication;
489 EFI_SMM_LOCK_BOX_PARAMETER_RESTORE_ALL_IN_PLACE *LockBoxParameterRestoreAllInPlace;
490 EFI_SMM_COMMUNICATE_HEADER *CommHeader;
491 UINT8 TempCommBuffer[sizeof(EFI_GUID) + sizeof(UINTN) + sizeof(EFI_SMM_LOCK_BOX_PARAMETER_RESTORE_ALL_IN_PLACE)];
492 UINT8 *CommBuffer;
493 UINTN CommSize;
494
495 DEBUG ((DEBUG_INFO, "SmmLockBoxDxeLib RestoreAllLockBoxInPlace - Enter\n"));
496
497 SmmCommunication = LockBoxGetSmmCommProtocol ();
498 if (SmmCommunication == NULL) {
499 return EFI_NOT_STARTED;
500 }
501
502 //
503 // Prepare parameter
504 //
505 CommBuffer = LockBoxGetSmmCommBuffer ();
506 if (CommBuffer == NULL) {
507 CommBuffer = &TempCommBuffer[0];
508 }
509 CommHeader = (EFI_SMM_COMMUNICATE_HEADER *)&CommBuffer[0];
510 CopyMem (&CommHeader->HeaderGuid, &gEfiSmmLockBoxCommunicationGuid, sizeof(gEfiSmmLockBoxCommunicationGuid));
511 CommHeader->MessageLength = sizeof(*LockBoxParameterRestoreAllInPlace);
512
513 LockBoxParameterRestoreAllInPlace = (EFI_SMM_LOCK_BOX_PARAMETER_RESTORE_ALL_IN_PLACE *)&CommBuffer[OFFSET_OF (EFI_SMM_COMMUNICATE_HEADER, Data)];
514 LockBoxParameterRestoreAllInPlace->Header.Command = EFI_SMM_LOCK_BOX_COMMAND_RESTORE_ALL_IN_PLACE;
515 LockBoxParameterRestoreAllInPlace->Header.DataLength = sizeof(*LockBoxParameterRestoreAllInPlace);
516 LockBoxParameterRestoreAllInPlace->Header.ReturnStatus = (UINT64)-1;
517
518 //
519 // Send command
520 //
521 CommSize = sizeof(EFI_GUID) + sizeof(UINTN) + sizeof(EFI_SMM_LOCK_BOX_PARAMETER_RESTORE_ALL_IN_PLACE);
522 Status = SmmCommunication->Communicate (
523 SmmCommunication,
524 &CommBuffer[0],
525 &CommSize
526 );
527 ASSERT_EFI_ERROR (Status);
528
529 Status = (EFI_STATUS)LockBoxParameterRestoreAllInPlace->Header.ReturnStatus;
530
531 DEBUG ((DEBUG_INFO, "SmmLockBoxDxeLib RestoreAllLockBoxInPlace - Exit (%r)\n", Status));
532
533 //
534 // Done
535 //
536 return Status;
537}
538
注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

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