VirtualBox

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

Last change on this file was 99404, checked in by vboxsync, 2 years ago

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

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