/** @file | |
Copyright (c) 2010 - 2019, Intel Corporation. All rights reserved.<BR> | |
SPDX-License-Identifier: BSD-2-Clause-Patent | |
**/ | |
#include <PiDxe.h> | |
#include <Library/UefiBootServicesTableLib.h> | |
#include <Library/UefiRuntimeServicesTableLib.h> | |
#include <Library/BaseLib.h> | |
#include <Library/BaseMemoryLib.h> | |
#include <Library/LockBoxLib.h> | |
#include <Library/DebugLib.h> | |
#include <Library/UefiLib.h> | |
#include <Protocol/SmmCommunication.h> | |
#include <Guid/SmmLockBox.h> | |
#include <Guid/PiSmmCommunicationRegionTable.h> | |
#include "SmmLockBoxLibPrivate.h" | |
EFI_SMM_COMMUNICATION_PROTOCOL *mLockBoxSmmCommProtocol = NULL; | |
UINT8 *mLockBoxSmmCommBuffer = NULL; | |
/** | |
Get smm communication protocol for lockbox. | |
@return Pointer to smm communication protocol, NULL if not found. | |
**/ | |
EFI_SMM_COMMUNICATION_PROTOCOL * | |
LockBoxGetSmmCommProtocol ( | |
VOID | |
) | |
{ | |
EFI_STATUS Status; | |
// | |
// If the protocol has been got previously, return it. | |
// | |
if (mLockBoxSmmCommProtocol != NULL) { | |
return mLockBoxSmmCommProtocol; | |
} | |
Status = gBS->LocateProtocol ( | |
&gEfiSmmCommunicationProtocolGuid, | |
NULL, | |
(VOID **)&mLockBoxSmmCommProtocol | |
); | |
if (EFI_ERROR (Status)) { | |
mLockBoxSmmCommProtocol = NULL; | |
} | |
return mLockBoxSmmCommProtocol; | |
} | |
/** | |
Get smm communication buffer for lockbox. | |
@return Pointer to smm communication buffer, NULL if not found. | |
**/ | |
UINT8 * | |
LockBoxGetSmmCommBuffer ( | |
VOID | |
) | |
{ | |
EFI_STATUS Status; | |
UINTN MinimalSizeNeeded; | |
EDKII_PI_SMM_COMMUNICATION_REGION_TABLE *PiSmmCommunicationRegionTable; | |
UINT32 Index; | |
EFI_MEMORY_DESCRIPTOR *Entry; | |
UINTN Size; | |
// | |
// If the buffer has been got previously, return it. | |
// | |
if (mLockBoxSmmCommBuffer != NULL) { | |
return mLockBoxSmmCommBuffer; | |
} | |
MinimalSizeNeeded = sizeof (EFI_GUID) + | |
sizeof (UINTN) + | |
MAX (sizeof (EFI_SMM_LOCK_BOX_PARAMETER_SAVE), | |
MAX (sizeof (EFI_SMM_LOCK_BOX_PARAMETER_SET_ATTRIBUTES), | |
MAX (sizeof (EFI_SMM_LOCK_BOX_PARAMETER_UPDATE), | |
MAX (sizeof (EFI_SMM_LOCK_BOX_PARAMETER_RESTORE), | |
sizeof (EFI_SMM_LOCK_BOX_PARAMETER_RESTORE_ALL_IN_PLACE))))); | |
Status = EfiGetSystemConfigurationTable ( | |
&gEdkiiPiSmmCommunicationRegionTableGuid, | |
(VOID **) &PiSmmCommunicationRegionTable | |
); | |
if (EFI_ERROR (Status)) { | |
mLockBoxSmmCommBuffer = NULL; | |
return mLockBoxSmmCommBuffer; | |
} | |
ASSERT (PiSmmCommunicationRegionTable != NULL); | |
Entry = (EFI_MEMORY_DESCRIPTOR *) (PiSmmCommunicationRegionTable + 1); | |
Size = 0; | |
for (Index = 0; Index < PiSmmCommunicationRegionTable->NumberOfEntries; Index++) { | |
if (Entry->Type == EfiConventionalMemory) { | |
Size = EFI_PAGES_TO_SIZE ((UINTN) Entry->NumberOfPages); | |
if (Size >= MinimalSizeNeeded) { | |
break; | |
} | |
} | |
Entry = (EFI_MEMORY_DESCRIPTOR *) ((UINT8 *) Entry + PiSmmCommunicationRegionTable->DescriptorSize); | |
} | |
if (Index >= PiSmmCommunicationRegionTable->NumberOfEntries) { | |
mLockBoxSmmCommBuffer = NULL; | |
} else { | |
mLockBoxSmmCommBuffer = (UINT8 *) (UINTN) Entry->PhysicalStart; | |
} | |
return mLockBoxSmmCommBuffer; | |
} | |
/** | |
This function will save confidential information to lockbox. | |
@param Guid the guid to identify the confidential information | |
@param Buffer the address of the confidential information | |
@param Length the length of the confidential information | |
@retval RETURN_SUCCESS the information is saved successfully. | |
@retval RETURN_INVALID_PARAMETER the Guid is NULL, or Buffer is NULL, or Length is 0 | |
@retval RETURN_ALREADY_STARTED the requested GUID already exist. | |
@retval RETURN_OUT_OF_RESOURCES no enough resource to save the information. | |
@retval RETURN_ACCESS_DENIED it is too late to invoke this interface | |
@retval RETURN_NOT_STARTED it is too early to invoke this interface | |
@retval RETURN_UNSUPPORTED the service is not supported by implementaion. | |
**/ | |
RETURN_STATUS | |
EFIAPI | |
SaveLockBox ( | |
IN GUID *Guid, | |
IN VOID *Buffer, | |
IN UINTN Length | |
) | |
{ | |
EFI_STATUS Status; | |
EFI_SMM_COMMUNICATION_PROTOCOL *SmmCommunication; | |
EFI_SMM_LOCK_BOX_PARAMETER_SAVE *LockBoxParameterSave; | |
EFI_SMM_COMMUNICATE_HEADER *CommHeader; | |
UINT8 TempCommBuffer[sizeof(EFI_GUID) + sizeof(UINTN) + sizeof(EFI_SMM_LOCK_BOX_PARAMETER_SAVE)]; | |
UINT8 *CommBuffer; | |
UINTN CommSize; | |
DEBUG ((DEBUG_INFO, "SmmLockBoxDxeLib SaveLockBox - Enter\n")); | |
// | |
// Basic check | |
// | |
if ((Guid == NULL) || (Buffer == NULL) || (Length == 0)) { | |
return EFI_INVALID_PARAMETER; | |
} | |
SmmCommunication = LockBoxGetSmmCommProtocol (); | |
if (SmmCommunication == NULL) { | |
return EFI_NOT_STARTED; | |
} | |
// | |
// Prepare parameter | |
// | |
CommBuffer = LockBoxGetSmmCommBuffer (); | |
if (CommBuffer == NULL) { | |
CommBuffer = &TempCommBuffer[0]; | |
} | |
CommHeader = (EFI_SMM_COMMUNICATE_HEADER *)&CommBuffer[0]; | |
CopyMem (&CommHeader->HeaderGuid, &gEfiSmmLockBoxCommunicationGuid, sizeof(gEfiSmmLockBoxCommunicationGuid)); | |
CommHeader->MessageLength = sizeof(*LockBoxParameterSave); | |
LockBoxParameterSave = (EFI_SMM_LOCK_BOX_PARAMETER_SAVE *)&CommBuffer[OFFSET_OF (EFI_SMM_COMMUNICATE_HEADER, Data)]; | |
LockBoxParameterSave->Header.Command = EFI_SMM_LOCK_BOX_COMMAND_SAVE; | |
LockBoxParameterSave->Header.DataLength = sizeof(*LockBoxParameterSave); | |
LockBoxParameterSave->Header.ReturnStatus = (UINT64)-1; | |
CopyMem (&LockBoxParameterSave->Guid, Guid, sizeof(*Guid)); | |
LockBoxParameterSave->Buffer = (EFI_PHYSICAL_ADDRESS)(UINTN)Buffer; | |
LockBoxParameterSave->Length = (UINT64)Length; | |
// | |
// Send command | |
// | |
CommSize = sizeof(EFI_GUID) + sizeof(UINTN) + sizeof(EFI_SMM_LOCK_BOX_PARAMETER_SAVE); | |
Status = SmmCommunication->Communicate ( | |
SmmCommunication, | |
&CommBuffer[0], | |
&CommSize | |
); | |
ASSERT_EFI_ERROR (Status); | |
Status = (EFI_STATUS)LockBoxParameterSave->Header.ReturnStatus; | |
DEBUG ((DEBUG_INFO, "SmmLockBoxDxeLib SaveLockBox - Exit (%r)\n", Status)); | |
// | |
// Done | |
// | |
return Status; | |
} | |
/** | |
This function will set lockbox attributes. | |
@param Guid the guid to identify the confidential information | |
@param Attributes the attributes of the lockbox | |
@retval RETURN_SUCCESS the information is saved successfully. | |
@retval RETURN_INVALID_PARAMETER attributes is invalid. | |
@retval RETURN_NOT_FOUND the requested GUID not found. | |
@retval RETURN_ACCESS_DENIED it is too late to invoke this interface | |
@retval RETURN_NOT_STARTED it is too early to invoke this interface | |
@retval RETURN_UNSUPPORTED the service is not supported by implementaion. | |
**/ | |
RETURN_STATUS | |
EFIAPI | |
SetLockBoxAttributes ( | |
IN GUID *Guid, | |
IN UINT64 Attributes | |
) | |
{ | |
EFI_STATUS Status; | |
EFI_SMM_COMMUNICATION_PROTOCOL *SmmCommunication; | |
EFI_SMM_LOCK_BOX_PARAMETER_SET_ATTRIBUTES *LockBoxParameterSetAttributes; | |
EFI_SMM_COMMUNICATE_HEADER *CommHeader; | |
UINT8 TempCommBuffer[sizeof(EFI_GUID) + sizeof(UINTN) + sizeof(EFI_SMM_LOCK_BOX_PARAMETER_SET_ATTRIBUTES)]; | |
UINT8 *CommBuffer; | |
UINTN CommSize; | |
DEBUG ((DEBUG_INFO, "SmmLockBoxDxeLib SetLockBoxAttributes - Enter\n")); | |
// | |
// Basic check | |
// | |
if ((Guid == NULL) || | |
((Attributes & ~(LOCK_BOX_ATTRIBUTE_RESTORE_IN_PLACE | LOCK_BOX_ATTRIBUTE_RESTORE_IN_S3_ONLY)) != 0)) { | |
return EFI_INVALID_PARAMETER; | |
} | |
SmmCommunication = LockBoxGetSmmCommProtocol (); | |
if (SmmCommunication == NULL) { | |
return EFI_NOT_STARTED; | |
} | |
// | |
// Prepare parameter | |
// | |
CommBuffer = LockBoxGetSmmCommBuffer (); | |
if (CommBuffer == NULL) { | |
CommBuffer = &TempCommBuffer[0]; | |
} | |
CommHeader = (EFI_SMM_COMMUNICATE_HEADER *)&CommBuffer[0]; | |
CopyMem (&CommHeader->HeaderGuid, &gEfiSmmLockBoxCommunicationGuid, sizeof(gEfiSmmLockBoxCommunicationGuid)); | |
CommHeader->MessageLength = sizeof(*LockBoxParameterSetAttributes); | |
LockBoxParameterSetAttributes = (EFI_SMM_LOCK_BOX_PARAMETER_SET_ATTRIBUTES *)&CommBuffer[OFFSET_OF (EFI_SMM_COMMUNICATE_HEADER, Data)]; | |
LockBoxParameterSetAttributes->Header.Command = EFI_SMM_LOCK_BOX_COMMAND_SET_ATTRIBUTES; | |
LockBoxParameterSetAttributes->Header.DataLength = sizeof(*LockBoxParameterSetAttributes); | |
LockBoxParameterSetAttributes->Header.ReturnStatus = (UINT64)-1; | |
CopyMem (&LockBoxParameterSetAttributes->Guid, Guid, sizeof(*Guid)); | |
LockBoxParameterSetAttributes->Attributes = (UINT64)Attributes; | |
// | |
// Send command | |
// | |
CommSize = sizeof(EFI_GUID) + sizeof(UINTN) + sizeof(EFI_SMM_LOCK_BOX_PARAMETER_SET_ATTRIBUTES); | |
Status = SmmCommunication->Communicate ( | |
SmmCommunication, | |
&CommBuffer[0], | |
&CommSize | |
); | |
ASSERT_EFI_ERROR (Status); | |
Status = (EFI_STATUS)LockBoxParameterSetAttributes->Header.ReturnStatus; | |
DEBUG ((DEBUG_INFO, "SmmLockBoxDxeLib SetLockBoxAttributes - Exit (%r)\n", Status)); | |
// | |
// Done | |
// | |
return Status; | |
} | |
/** | |
This function will update confidential information to lockbox. | |
@param Guid the guid to identify the original confidential information | |
@param Offset the offset of the original confidential information | |
@param Buffer the address of the updated confidential information | |
@param Length the length of the updated confidential information | |
@retval RETURN_SUCCESS the information is saved successfully. | |
@retval RETURN_INVALID_PARAMETER the Guid is NULL, or Buffer is NULL, or Length is 0. | |
@retval RETURN_NOT_FOUND the requested GUID not found. | |
@retval RETURN_BUFFER_TOO_SMALL for lockbox without attribute LOCK_BOX_ATTRIBUTE_RESTORE_IN_S3_ONLY, | |
the original buffer to too small to hold new information. | |
@retval RETURN_OUT_OF_RESOURCES for lockbox with attribute LOCK_BOX_ATTRIBUTE_RESTORE_IN_S3_ONLY, | |
no enough resource to save the information. | |
@retval RETURN_ACCESS_DENIED it is too late to invoke this interface | |
@retval RETURN_NOT_STARTED it is too early to invoke this interface | |
@retval RETURN_UNSUPPORTED the service is not supported by implementaion. | |
**/ | |
RETURN_STATUS | |
EFIAPI | |
UpdateLockBox ( | |
IN GUID *Guid, | |
IN UINTN Offset, | |
IN VOID *Buffer, | |
IN UINTN Length | |
) | |
{ | |
EFI_STATUS Status; | |
EFI_SMM_COMMUNICATION_PROTOCOL *SmmCommunication; | |
EFI_SMM_LOCK_BOX_PARAMETER_UPDATE *LockBoxParameterUpdate; | |
EFI_SMM_COMMUNICATE_HEADER *CommHeader; | |
UINT8 TempCommBuffer[sizeof(EFI_GUID) + sizeof(UINTN) + sizeof(EFI_SMM_LOCK_BOX_PARAMETER_UPDATE)]; | |
UINT8 *CommBuffer; | |
UINTN CommSize; | |
DEBUG ((DEBUG_INFO, "SmmLockBoxDxeLib UpdateLockBox - Enter\n")); | |
// | |
// Basic check | |
// | |
if ((Guid == NULL) || (Buffer == NULL) || (Length == 0)) { | |
return EFI_INVALID_PARAMETER; | |
} | |
SmmCommunication = LockBoxGetSmmCommProtocol (); | |
if (SmmCommunication == NULL) { | |
return EFI_NOT_STARTED; | |
} | |
// | |
// Prepare parameter | |
// | |
CommBuffer = LockBoxGetSmmCommBuffer (); | |
if (CommBuffer == NULL) { | |
CommBuffer = &TempCommBuffer[0]; | |
} | |
CommHeader = (EFI_SMM_COMMUNICATE_HEADER *)&CommBuffer[0]; | |
CopyMem (&CommHeader->HeaderGuid, &gEfiSmmLockBoxCommunicationGuid, sizeof(gEfiSmmLockBoxCommunicationGuid)); | |
CommHeader->MessageLength = sizeof(*LockBoxParameterUpdate); | |
LockBoxParameterUpdate = (EFI_SMM_LOCK_BOX_PARAMETER_UPDATE *)(UINTN)&CommBuffer[OFFSET_OF (EFI_SMM_COMMUNICATE_HEADER, Data)]; | |
LockBoxParameterUpdate->Header.Command = EFI_SMM_LOCK_BOX_COMMAND_UPDATE; | |
LockBoxParameterUpdate->Header.DataLength = sizeof(*LockBoxParameterUpdate); | |
LockBoxParameterUpdate->Header.ReturnStatus = (UINT64)-1; | |
CopyMem (&LockBoxParameterUpdate->Guid, Guid, sizeof(*Guid)); | |
LockBoxParameterUpdate->Offset = (UINT64)Offset; | |
LockBoxParameterUpdate->Buffer = (EFI_PHYSICAL_ADDRESS)(UINTN)Buffer; | |
LockBoxParameterUpdate->Length = (UINT64)Length; | |
// | |
// Send command | |
// | |
CommSize = sizeof(EFI_GUID) + sizeof(UINTN) + sizeof(EFI_SMM_LOCK_BOX_PARAMETER_UPDATE); | |
Status = SmmCommunication->Communicate ( | |
SmmCommunication, | |
&CommBuffer[0], | |
&CommSize | |
); | |
ASSERT_EFI_ERROR (Status); | |
Status = (EFI_STATUS)LockBoxParameterUpdate->Header.ReturnStatus; | |
DEBUG ((DEBUG_INFO, "SmmLockBoxDxeLib UpdateLockBox - Exit (%r)\n", Status)); | |
// | |
// Done | |
// | |
return Status; | |
} | |
/** | |
This function will restore confidential information from lockbox. | |
@param Guid the guid to identify the confidential information | |
@param Buffer the address of the restored confidential information | |
NULL means restored to original address, Length MUST be NULL at same time. | |
@param Length the length of the restored confidential information | |
@retval RETURN_SUCCESS the information is restored successfully. | |
@retval RETURN_INVALID_PARAMETER the Guid is NULL, or one of Buffer and Length is NULL. | |
@retval RETURN_WRITE_PROTECTED Buffer and Length are NULL, but the LockBox has no | |
LOCK_BOX_ATTRIBUTE_RESTORE_IN_PLACE attribute. | |
@retval RETURN_BUFFER_TOO_SMALL the Length is too small to hold the confidential information. | |
@retval RETURN_NOT_FOUND the requested GUID not found. | |
@retval RETURN_NOT_STARTED it is too early to invoke this interface | |
@retval RETURN_ACCESS_DENIED not allow to restore to the address | |
@retval RETURN_UNSUPPORTED the service is not supported by implementaion. | |
**/ | |
RETURN_STATUS | |
EFIAPI | |
RestoreLockBox ( | |
IN GUID *Guid, | |
IN VOID *Buffer, OPTIONAL | |
IN OUT UINTN *Length OPTIONAL | |
) | |
{ | |
EFI_STATUS Status; | |
EFI_SMM_COMMUNICATION_PROTOCOL *SmmCommunication; | |
EFI_SMM_LOCK_BOX_PARAMETER_RESTORE *LockBoxParameterRestore; | |
EFI_SMM_COMMUNICATE_HEADER *CommHeader; | |
UINT8 TempCommBuffer[sizeof(EFI_GUID) + sizeof(UINTN) + sizeof(EFI_SMM_LOCK_BOX_PARAMETER_RESTORE)]; | |
UINT8 *CommBuffer; | |
UINTN CommSize; | |
DEBUG ((DEBUG_INFO, "SmmLockBoxDxeLib RestoreLockBox - Enter\n")); | |
// | |
// Basic check | |
// | |
if ((Guid == NULL) || | |
((Buffer == NULL) && (Length != NULL)) || | |
((Buffer != NULL) && (Length == NULL))) { | |
return EFI_INVALID_PARAMETER; | |
} | |
SmmCommunication = LockBoxGetSmmCommProtocol (); | |
if (SmmCommunication == NULL) { | |
return EFI_NOT_STARTED; | |
} | |
// | |
// Prepare parameter | |
// | |
CommBuffer = LockBoxGetSmmCommBuffer (); | |
if (CommBuffer == NULL) { | |
CommBuffer = &TempCommBuffer[0]; | |
} | |
CommHeader = (EFI_SMM_COMMUNICATE_HEADER *)&CommBuffer[0]; | |
CopyMem (&CommHeader->HeaderGuid, &gEfiSmmLockBoxCommunicationGuid, sizeof(gEfiSmmLockBoxCommunicationGuid)); | |
CommHeader->MessageLength = sizeof(*LockBoxParameterRestore); | |
LockBoxParameterRestore = (EFI_SMM_LOCK_BOX_PARAMETER_RESTORE *)&CommBuffer[OFFSET_OF (EFI_SMM_COMMUNICATE_HEADER, Data)]; | |
LockBoxParameterRestore->Header.Command = EFI_SMM_LOCK_BOX_COMMAND_RESTORE; | |
LockBoxParameterRestore->Header.DataLength = sizeof(*LockBoxParameterRestore); | |
LockBoxParameterRestore->Header.ReturnStatus = (UINT64)-1; | |
CopyMem (&LockBoxParameterRestore->Guid, Guid, sizeof(*Guid)); | |
LockBoxParameterRestore->Buffer = (EFI_PHYSICAL_ADDRESS)(UINTN)Buffer; | |
if (Length != NULL) { | |
LockBoxParameterRestore->Length = (EFI_PHYSICAL_ADDRESS)*Length; | |
} else { | |
LockBoxParameterRestore->Length = 0; | |
} | |
// | |
// Send command | |
// | |
CommSize = sizeof(EFI_GUID) + sizeof(UINTN) + sizeof(EFI_SMM_LOCK_BOX_PARAMETER_RESTORE); | |
Status = SmmCommunication->Communicate ( | |
SmmCommunication, | |
&CommBuffer[0], | |
&CommSize | |
); | |
ASSERT_EFI_ERROR (Status); | |
if (Length != NULL) { | |
*Length = (UINTN)LockBoxParameterRestore->Length; | |
} | |
Status = (EFI_STATUS)LockBoxParameterRestore->Header.ReturnStatus; | |
DEBUG ((DEBUG_INFO, "SmmLockBoxDxeLib RestoreLockBox - Exit (%r)\n", Status)); | |
// | |
// Done | |
// | |
return Status; | |
} | |
/** | |
This function will restore confidential information from all lockbox which have RestoreInPlace attribute. | |
@retval RETURN_SUCCESS the information is restored successfully. | |
@retval RETURN_NOT_STARTED it is too early to invoke this interface | |
@retval RETURN_UNSUPPORTED the service is not supported by implementaion. | |
**/ | |
RETURN_STATUS | |
EFIAPI | |
RestoreAllLockBoxInPlace ( | |
VOID | |
) | |
{ | |
EFI_STATUS Status; | |
EFI_SMM_COMMUNICATION_PROTOCOL *SmmCommunication; | |
EFI_SMM_LOCK_BOX_PARAMETER_RESTORE_ALL_IN_PLACE *LockBoxParameterRestoreAllInPlace; | |
EFI_SMM_COMMUNICATE_HEADER *CommHeader; | |
UINT8 TempCommBuffer[sizeof(EFI_GUID) + sizeof(UINTN) + sizeof(EFI_SMM_LOCK_BOX_PARAMETER_RESTORE_ALL_IN_PLACE)]; | |
UINT8 *CommBuffer; | |
UINTN CommSize; | |
DEBUG ((DEBUG_INFO, "SmmLockBoxDxeLib RestoreAllLockBoxInPlace - Enter\n")); | |
SmmCommunication = LockBoxGetSmmCommProtocol (); | |
if (SmmCommunication == NULL) { | |
return EFI_NOT_STARTED; | |
} | |
// | |
// Prepare parameter | |
// | |
CommBuffer = LockBoxGetSmmCommBuffer (); | |
if (CommBuffer == NULL) { | |
CommBuffer = &TempCommBuffer[0]; | |
} | |
CommHeader = (EFI_SMM_COMMUNICATE_HEADER *)&CommBuffer[0]; | |
CopyMem (&CommHeader->HeaderGuid, &gEfiSmmLockBoxCommunicationGuid, sizeof(gEfiSmmLockBoxCommunicationGuid)); | |
CommHeader->MessageLength = sizeof(*LockBoxParameterRestoreAllInPlace); | |
LockBoxParameterRestoreAllInPlace = (EFI_SMM_LOCK_BOX_PARAMETER_RESTORE_ALL_IN_PLACE *)&CommBuffer[OFFSET_OF (EFI_SMM_COMMUNICATE_HEADER, Data)]; | |
LockBoxParameterRestoreAllInPlace->Header.Command = EFI_SMM_LOCK_BOX_COMMAND_RESTORE_ALL_IN_PLACE; | |
LockBoxParameterRestoreAllInPlace->Header.DataLength = sizeof(*LockBoxParameterRestoreAllInPlace); | |
LockBoxParameterRestoreAllInPlace->Header.ReturnStatus = (UINT64)-1; | |
// | |
// Send command | |
// | |
CommSize = sizeof(EFI_GUID) + sizeof(UINTN) + sizeof(EFI_SMM_LOCK_BOX_PARAMETER_RESTORE_ALL_IN_PLACE); | |
Status = SmmCommunication->Communicate ( | |
SmmCommunication, | |
&CommBuffer[0], | |
&CommSize | |
); | |
ASSERT_EFI_ERROR (Status); | |
Status = (EFI_STATUS)LockBoxParameterRestoreAllInPlace->Header.ReturnStatus; | |
DEBUG ((DEBUG_INFO, "SmmLockBoxDxeLib RestoreAllLockBoxInPlace - Exit (%r)\n", Status)); | |
// | |
// Done | |
// | |
return Status; | |
} | |