SmmLockBoxPeiLib.c@ 81344

Last change on this file since 81344 was 80721, checked in by vboxsync, 5 years ago
Devices/EFI/FirmwareNew: Start upgrade process to edk2-stable201908 (compiles on Windows and works to some extent), bugref:4643
Property svn:eol-style set to `native`
File size: 23.9 KB

Line
1	/** @file
2
3	Copyright (c) 2010 - 2019, Intel Corporation. All rights reserved.<BR>
4
5	SPDX-License-Identifier: BSD-2-Clause-Patent
6
7	**/
8
9	#include <PiPei.h>
10	#include <PiDxe.h>
11	#include <PiSmm.h>
12	#include <Library/PeiServicesTablePointerLib.h>
13	#include <Library/PeiServicesLib.h>
14	#include <Library/BaseLib.h>
15	#include <Library/BaseMemoryLib.h>
16	#include <Library/LockBoxLib.h>
17	#include <Library/HobLib.h>
18	#include <Library/DebugLib.h>
19	#include <Library/PcdLib.h>
20	#include <Protocol/SmmCommunication.h>
21	#include <Ppi/SmmCommunication.h>
22	#include <Ppi/SmmAccess.h>
23	#include <Guid/AcpiS3Context.h>
24	#include <Guid/SmmLockBox.h>
25
26	#include "SmmLockBoxLibPrivate.h"
27
28	#if defined (MDE_CPU_IA32)
29	typedef struct _LIST_ENTRY64 LIST_ENTRY64;
30	struct _LIST_ENTRY64 {
31	LIST_ENTRY64 *ForwardLink;
32	UINT32 Reserved1;
33	LIST_ENTRY64 *BackLink;
34	UINT32 Reserved2;
35	};
36
37	typedef struct {
38	EFI_TABLE_HEADER Hdr;
39	UINT64 SmmFirmwareVendor;
40	UINT64 SmmFirmwareRevision;
41	UINT64 SmmInstallConfigurationTable;
42	UINT64 SmmIoMemRead;
43	UINT64 SmmIoMemWrite;
44	UINT64 SmmIoIoRead;
45	UINT64 SmmIoIoWrite;
46	UINT64 SmmAllocatePool;
47	UINT64 SmmFreePool;
48	UINT64 SmmAllocatePages;
49	UINT64 SmmFreePages;
50	UINT64 SmmStartupThisAp;
51	UINT64 CurrentlyExecutingCpu;
52	UINT64 NumberOfCpus;
53	UINT64 CpuSaveStateSize;
54	UINT64 CpuSaveState;
55	UINT64 NumberOfTableEntries;
56	UINT64 SmmConfigurationTable;
57	} EFI_SMM_SYSTEM_TABLE2_64;
58
59	typedef struct {
60	EFI_GUID VendorGuid;
61	UINT64 VendorTable;
62	} EFI_CONFIGURATION_TABLE64;
63	#endif
64
65	#if defined (MDE_CPU_X64)
66	typedef LIST_ENTRY LIST_ENTRY64;
67	typedef EFI_SMM_SYSTEM_TABLE2 EFI_SMM_SYSTEM_TABLE2_64;
68	typedef EFI_CONFIGURATION_TABLE EFI_CONFIGURATION_TABLE64;
69	#endif
70
71	/**
72	This function return first node of LinkList queue.
73
74	@param LockBoxQueue LinkList queue
75
76	@return first node of LinkList queue
77	**/
78	LIST_ENTRY *
79	InternalInitLinkDxe (
80	IN LIST_ENTRY *LinkList
81	)
82	{
83	if ((sizeof(UINTN) == sizeof(UINT32)) && (FeaturePcdGet (PcdDxeIplSwitchToLongMode)) ) {
84	//
85	// 32 PEI + 64 DXE
86	//
87	return (LIST_ENTRY )(((LIST_ENTRY64 )LinkList)->ForwardLink);
88	} else {
89	return LinkList->ForwardLink;
90	}
91	}
92
93	/**
94	This function return next node of LinkList.
95
96	@param Link LinkList node
97
98	@return next node of LinkList
99	**/
100	LIST_ENTRY *
101	InternalNextLinkDxe (
102	IN LIST_ENTRY *Link
103	)
104	{
105	if ((sizeof(UINTN) == sizeof(UINT32)) && (FeaturePcdGet (PcdDxeIplSwitchToLongMode)) ) {
106	//
107	// 32 PEI + 64 DXE
108	//
109	return (LIST_ENTRY )(((LIST_ENTRY64 )Link)->ForwardLink);
110	} else {
111	return Link->ForwardLink;
112	}
113	}
114
115	/**
116	This function find LockBox by GUID from SMRAM.
117
118	@param LockBoxQueue The LockBox queue in SMRAM
119	@param Guid The guid to indentify the LockBox
120
121	@return LockBoxData
122	**/
123	SMM_LOCK_BOX_DATA *
124	InternalFindLockBoxByGuidFromSmram (
125	IN LIST_ENTRY *LockBoxQueue,
126	IN EFI_GUID *Guid
127	)
128	{
129	LIST_ENTRY *Link;
130	SMM_LOCK_BOX_DATA *LockBox;
131
132	for (Link = InternalInitLinkDxe (LockBoxQueue);
133	Link != LockBoxQueue;
134	Link = InternalNextLinkDxe (Link)) {
135	LockBox = BASE_CR (
136	Link,
137	SMM_LOCK_BOX_DATA,
138	Link
139	);
140	if (CompareGuid (&LockBox->Guid, Guid)) {
141	return LockBox;
142	}
143	}
144	return NULL;
145	}
146
147	/**
148	Get VendorTable by VendorGuid in Smst.
149
150	@param Signature Signature of SMM_S3_RESUME_STATE
151	@param Smst SMM system table
152	@param VendorGuid vendor guid
153
154	@return vendor table.
155	**/
156	VOID *
157	InternalSmstGetVendorTableByGuid (
158	IN UINT64 Signature,
159	IN EFI_SMM_SYSTEM_TABLE2 *Smst,
160	IN EFI_GUID *VendorGuid
161	)
162	{
163	EFI_CONFIGURATION_TABLE *SmmConfigurationTable;
164	UINTN NumberOfTableEntries;
165	UINTN Index;
166	EFI_SMM_SYSTEM_TABLE2_64 *Smst64;
167	EFI_CONFIGURATION_TABLE64 *SmmConfigurationTable64;
168
169	if ((sizeof(UINTN) == sizeof(UINT32)) && (FeaturePcdGet (PcdDxeIplSwitchToLongMode))) {
170	//
171	// 32 PEI + 64 DXE
172	//
173	Smst64 = (EFI_SMM_SYSTEM_TABLE2_64 *)Smst;
174	SmmConfigurationTable64 = (EFI_CONFIGURATION_TABLE64 *)(UINTN)Smst64->SmmConfigurationTable;
175	NumberOfTableEntries = (UINTN)Smst64->NumberOfTableEntries;
176	for (Index = 0; Index < NumberOfTableEntries; Index++) {
177	if (CompareGuid (&SmmConfigurationTable64[Index].VendorGuid, VendorGuid)) {
178	return (VOID *)(UINTN)SmmConfigurationTable64[Index].VendorTable;
179	}
180	}
181	return NULL;
182	} else {
183	SmmConfigurationTable = Smst->SmmConfigurationTable;
184	NumberOfTableEntries = Smst->NumberOfTableEntries;
185	for (Index = 0; Index < NumberOfTableEntries; Index++) {
186	if (CompareGuid (&SmmConfigurationTable[Index].VendorGuid, VendorGuid)) {
187	return (VOID *)SmmConfigurationTable[Index].VendorTable;
188	}
189	}
190	return NULL;
191	}
192	}
193
194	/**
195	Get SMM LockBox context.
196
197	@return SMM LockBox context.
198	**/
199	SMM_LOCK_BOX_CONTEXT *
200	InternalGetSmmLockBoxContext (
201	VOID
202	)
203	{
204	EFI_SMRAM_DESCRIPTOR *SmramDescriptor;
205	SMM_S3_RESUME_STATE *SmmS3ResumeState;
206	VOID *GuidHob;
207	SMM_LOCK_BOX_CONTEXT *SmmLockBoxContext;
208
209	GuidHob = GetFirstGuidHob (&gEfiAcpiVariableGuid);
210	ASSERT (GuidHob != NULL);
211	SmramDescriptor = (EFI_SMRAM_DESCRIPTOR *) GET_GUID_HOB_DATA (GuidHob);
212	SmmS3ResumeState = (SMM_S3_RESUME_STATE *)(UINTN)SmramDescriptor->CpuStart;
213
214	SmmLockBoxContext = (SMM_LOCK_BOX_CONTEXT *)InternalSmstGetVendorTableByGuid (
215	SmmS3ResumeState->Signature,
216	(EFI_SMM_SYSTEM_TABLE2 *)(UINTN)SmmS3ResumeState->Smst,
217	&gEfiSmmLockBoxCommunicationGuid
218	);
219	ASSERT (SmmLockBoxContext != NULL);
220
221	return SmmLockBoxContext;
222	}
223
224	/**
225	This function will restore confidential information from lockbox in SMRAM directly.
226
227	@param Guid the guid to identify the confidential information
228	@param Buffer the address of the restored confidential information
229	NULL means restored to original address, Length MUST be NULL at same time.
230	@param Length the length of the restored confidential information
231
232	@retval RETURN_SUCCESS the information is restored successfully.
233	@retval RETURN_WRITE_PROTECTED Buffer and Length are NULL, but the LockBox has no
234	LOCK_BOX_ATTRIBUTE_RESTORE_IN_PLACE attribute.
235	@retval RETURN_BUFFER_TOO_SMALL the Length is too small to hold the confidential information.
236	@retval RETURN_NOT_FOUND the requested GUID not found.
237	**/
238	EFI_STATUS
239	InternalRestoreLockBoxFromSmram (
240	IN GUID *Guid,
241	IN VOID *Buffer, OPTIONAL
242	IN OUT UINTN *Length OPTIONAL
243	)
244	{
245	PEI_SMM_ACCESS_PPI *SmmAccess;
246	UINTN Index;
247	EFI_STATUS Status;
248	SMM_LOCK_BOX_CONTEXT *SmmLockBoxContext;
249	LIST_ENTRY *LockBoxQueue;
250	SMM_LOCK_BOX_DATA *LockBox;
251	VOID *RestoreBuffer;
252
253	//
254	// Get needed resource
255	//
256	Status = PeiServicesLocatePpi (
257	&gPeiSmmAccessPpiGuid,
258	0,
259	NULL,
260	(VOID **)&SmmAccess
261	);
262	if (!EFI_ERROR (Status)) {
263	for (Index = 0; !EFI_ERROR (Status); Index++) {
264	Status = SmmAccess->Open ((EFI_PEI_SERVICES **)GetPeiServicesTablePointer (), SmmAccess, Index);
265	}
266	}
267
268	//
269	// Get LockBox context
270	//
271	SmmLockBoxContext = InternalGetSmmLockBoxContext ();
272	LockBoxQueue = (LIST_ENTRY *)(UINTN)SmmLockBoxContext->LockBoxDataAddress;
273
274	//
275	// We do NOT check Buffer address in SMRAM, because if SMRAM not locked, we trust the caller.
276	//
277
278	//
279	// Restore this, Buffer and Length MUST be both NULL or both non-NULL
280	//
281
282	//
283	// Find LockBox
284	//
285	LockBox = InternalFindLockBoxByGuidFromSmram (LockBoxQueue, Guid);
286	if (LockBox == NULL) {
287	//
288	// Not found
289	//
290	return EFI_NOT_FOUND;
291	}
292
293	//
294	// Set RestoreBuffer
295	//
296	if (Buffer != NULL) {
297	//
298	// restore to new buffer
299	//
300	RestoreBuffer = Buffer;
301	} else {
302	//
303	// restore to original buffer
304	//
305	if ((LockBox->Attributes & LOCK_BOX_ATTRIBUTE_RESTORE_IN_PLACE) == 0) {
306	return EFI_WRITE_PROTECTED;
307	}
308	RestoreBuffer = (VOID *)(UINTN)LockBox->Buffer;
309	}
310
311	//
312	// Set RestoreLength
313	//
314	if (Length != NULL) {
315	if (*Length < (UINTN)LockBox->Length) {
316	//
317	// Input buffer is too small to hold all data.
318	//
319	*Length = (UINTN)LockBox->Length;
320	return EFI_BUFFER_TOO_SMALL;
321	}
322	*Length = (UINTN)LockBox->Length;
323	}
324
325	//
326	// Restore data
327	//
328	CopyMem (RestoreBuffer, (VOID *)(UINTN)LockBox->SmramBuffer, (UINTN)LockBox->Length);
329
330	//
331	// Done
332	//
333	return EFI_SUCCESS;
334	}
335
336	/**
337	This function will restore confidential information from all lockbox which have RestoreInPlace attribute.
338
339	@retval RETURN_SUCCESS the information is restored successfully.
340	**/
341	EFI_STATUS
342	InternalRestoreAllLockBoxInPlaceFromSmram (
343	VOID
344	)
345	{
346	PEI_SMM_ACCESS_PPI *SmmAccess;
347	UINTN Index;
348	EFI_STATUS Status;
349	SMM_LOCK_BOX_CONTEXT *SmmLockBoxContext;
350	LIST_ENTRY *LockBoxQueue;
351	SMM_LOCK_BOX_DATA *LockBox;
352	LIST_ENTRY *Link;
353
354	//
355	// Get needed resource
356	//
357	Status = PeiServicesLocatePpi (
358	&gPeiSmmAccessPpiGuid,
359	0,
360	NULL,
361	(VOID **)&SmmAccess
362	);
363	if (!EFI_ERROR (Status)) {
364	for (Index = 0; !EFI_ERROR (Status); Index++) {
365	Status = SmmAccess->Open ((EFI_PEI_SERVICES **)GetPeiServicesTablePointer (), SmmAccess, Index);
366	}
367	}
368
369	//
370	// Get LockBox context
371	//
372	SmmLockBoxContext = InternalGetSmmLockBoxContext ();
373	LockBoxQueue = (LIST_ENTRY *)(UINTN)SmmLockBoxContext->LockBoxDataAddress;
374
375	//
376	// We do NOT check Buffer address in SMRAM, because if SMRAM not locked, we trust the caller.
377	//
378
379	//
380	// Restore all, Buffer and Length MUST be NULL
381	//
382	for (Link = InternalInitLinkDxe (LockBoxQueue);
383	Link != LockBoxQueue;
384	Link = InternalNextLinkDxe (Link)) {
385	LockBox = BASE_CR (
386	Link,
387	SMM_LOCK_BOX_DATA,
388	Link
389	);
390	if ((LockBox->Attributes & LOCK_BOX_ATTRIBUTE_RESTORE_IN_PLACE) != 0) {
391	//
392	// Restore data
393	//
394	CopyMem ((VOID )(UINTN)LockBox->Buffer, (VOID )(UINTN)LockBox->SmramBuffer, (UINTN)LockBox->Length);
395	}
396	}
397	//
398	// Done
399	//
400	return EFI_SUCCESS;
401	}
402
403	/**
404	This function will save confidential information to lockbox.
405
406	@param Guid the guid to identify the confidential information
407	@param Buffer the address of the confidential information
408	@param Length the length of the confidential information
409
410	@retval RETURN_SUCCESS the information is saved successfully.
411	@retval RETURN_INVALID_PARAMETER the Guid is NULL, or Buffer is NULL, or Length is 0
412	@retval RETURN_ALREADY_STARTED the requested GUID already exist.
413	@retval RETURN_OUT_OF_RESOURCES no enough resource to save the information.
414	@retval RETURN_ACCESS_DENIED it is too late to invoke this interface
415	@retval RETURN_NOT_STARTED it is too early to invoke this interface
416	@retval RETURN_UNSUPPORTED the service is not supported by implementaion.
417	**/
418	RETURN_STATUS
419	EFIAPI
420	SaveLockBox (
421	IN GUID *Guid,
422	IN VOID *Buffer,
423	IN UINTN Length
424	)
425	{
426	ASSERT (FALSE);
427
428	//
429	// No support to save at PEI phase
430	//
431	return RETURN_UNSUPPORTED;
432	}
433
434	/**
435	This function will set lockbox attributes.
436
437	@param Guid the guid to identify the confidential information
438	@param Attributes the attributes of the lockbox
439
440	@retval RETURN_SUCCESS the information is saved successfully.
441	@retval RETURN_INVALID_PARAMETER attributes is invalid.
442	@retval RETURN_NOT_FOUND the requested GUID not found.
443	@retval RETURN_ACCESS_DENIED it is too late to invoke this interface
444	@retval RETURN_NOT_STARTED it is too early to invoke this interface
445	@retval RETURN_UNSUPPORTED the service is not supported by implementaion.
446	**/
447	RETURN_STATUS
448	EFIAPI
449	SetLockBoxAttributes (
450	IN GUID *Guid,
451	IN UINT64 Attributes
452	)
453	{
454	ASSERT (FALSE);
455
456	//
457	// No support to save at PEI phase
458	//
459	return RETURN_UNSUPPORTED;
460	}
461
462	/**
463	This function will update confidential information to lockbox.
464
465	@param Guid the guid to identify the original confidential information
466	@param Offset the offset of the original confidential information
467	@param Buffer the address of the updated confidential information
468	@param Length the length of the updated confidential information
469
470	@retval RETURN_SUCCESS the information is saved successfully.
471	@retval RETURN_INVALID_PARAMETER the Guid is NULL, or Buffer is NULL, or Length is 0.
472	@retval RETURN_NOT_FOUND the requested GUID not found.
473	@retval RETURN_BUFFER_TOO_SMALL for lockbox without attribute LOCK_BOX_ATTRIBUTE_RESTORE_IN_S3_ONLY,
474	the original buffer to too small to hold new information.
475	@retval RETURN_OUT_OF_RESOURCES for lockbox with attribute LOCK_BOX_ATTRIBUTE_RESTORE_IN_S3_ONLY,
476	no enough resource to save the information.
477	@retval RETURN_ACCESS_DENIED it is too late to invoke this interface
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	**/
481	RETURN_STATUS
482	EFIAPI
483	UpdateLockBox (
484	IN GUID *Guid,
485	IN UINTN Offset,
486	IN VOID *Buffer,
487	IN UINTN Length
488	)
489	{
490	ASSERT (FALSE);
491
492	//
493	// No support to update at PEI phase
494	//
495	return RETURN_UNSUPPORTED;
496	}
497
498	/**
499	This function will restore confidential information from lockbox.
500
501	@param Guid the guid to identify the confidential information
502	@param Buffer the address of the restored confidential information
503	NULL means restored to original address, Length MUST be NULL at same time.
504	@param Length the length of the restored confidential information
505
506	@retval RETURN_SUCCESS the information is restored successfully.
507	@retval RETURN_INVALID_PARAMETER the Guid is NULL, or one of Buffer and Length is NULL.
508	@retval RETURN_WRITE_PROTECTED Buffer and Length are NULL, but the LockBox has no
509	LOCK_BOX_ATTRIBUTE_RESTORE_IN_PLACE attribute.
510	@retval RETURN_BUFFER_TOO_SMALL the Length is too small to hold the confidential information.
511	@retval RETURN_NOT_FOUND the requested GUID not found.
512	@retval RETURN_NOT_STARTED it is too early to invoke this interface
513	@retval RETURN_ACCESS_DENIED not allow to restore to the address
514	@retval RETURN_UNSUPPORTED the service is not supported by implementaion.
515	**/
516	RETURN_STATUS
517	EFIAPI
518	RestoreLockBox (
519	IN GUID *Guid,
520	IN VOID *Buffer, OPTIONAL
521	IN OUT UINTN *Length OPTIONAL
522	)
523	{
524	EFI_STATUS Status;
525	EFI_PEI_SMM_COMMUNICATION_PPI *SmmCommunicationPpi;
526	EFI_SMM_LOCK_BOX_PARAMETER_RESTORE *LockBoxParameterRestore;
527	EFI_SMM_COMMUNICATE_HEADER *CommHeader;
528	UINT8 CommBuffer[sizeof(EFI_GUID) + sizeof(UINT64) + sizeof(EFI_SMM_LOCK_BOX_PARAMETER_RESTORE)];
529	UINTN CommSize;
530	UINT64 MessageLength;
531
532	//
533	// Please aware that there is UINTN in EFI_SMM_COMMUNICATE_HEADER. It might be UINT64 in DXE, while it is UINT32 in PEI.
534	// typedef struct {
535	// EFI_GUID HeaderGuid;
536	// UINTN MessageLength;
537	// UINT8 Data[1];
538	// } EFI_SMM_COMMUNICATE_HEADER;
539	//
540
541	DEBUG ((DEBUG_INFO, "SmmLockBoxPeiLib RestoreLockBox - Enter\n"));
542
543	//
544	// Basic check
545	//
546	if ((Guid == NULL) \|\|
547	((Buffer == NULL) && (Length != NULL)) \|\|
548	((Buffer != NULL) && (Length == NULL))) {
549	return EFI_INVALID_PARAMETER;
550	}
551
552	//
553	// Get needed resource
554	//
555	Status = PeiServicesLocatePpi (
556	&gEfiPeiSmmCommunicationPpiGuid,
557	0,
558	NULL,
559	(VOID **)&SmmCommunicationPpi
560	);
561	if (EFI_ERROR (Status)) {
562	DEBUG ((DEBUG_INFO, "SmmLockBoxPeiLib LocatePpi - (%r)\n", Status));
563	Status = InternalRestoreLockBoxFromSmram (Guid, Buffer, Length);
564	DEBUG ((DEBUG_INFO, "SmmLockBoxPeiLib RestoreLockBox - Exit (%r)\n", Status));
565	return Status;
566	}
567
568	//
569	// Prepare parameter
570	//
571	CommHeader = (EFI_SMM_COMMUNICATE_HEADER *)&CommBuffer[0];
572	CopyMem (&CommHeader->HeaderGuid, &gEfiSmmLockBoxCommunicationGuid, sizeof(gEfiSmmLockBoxCommunicationGuid));
573	if ((sizeof(UINTN) == sizeof(UINT32)) && (FeaturePcdGet (PcdDxeIplSwitchToLongMode)) ) {
574	MessageLength = sizeof(*LockBoxParameterRestore);
575	CopyMem (&CommBuffer[OFFSET_OF (EFI_SMM_COMMUNICATE_HEADER, MessageLength)], &MessageLength, sizeof(MessageLength));
576	} else {
577	CommHeader->MessageLength = sizeof(*LockBoxParameterRestore);
578	}
579
580	DEBUG ((DEBUG_INFO, "SmmLockBoxPeiLib CommBuffer - %x\n", &CommBuffer[0]));
581	if ((sizeof(UINTN) == sizeof(UINT32)) && (FeaturePcdGet (PcdDxeIplSwitchToLongMode)) ) {
582	LockBoxParameterRestore = (EFI_SMM_LOCK_BOX_PARAMETER_RESTORE *)&CommBuffer[OFFSET_OF (EFI_SMM_COMMUNICATE_HEADER, MessageLength) + sizeof(UINT64)];
583	} else {
584	LockBoxParameterRestore = (EFI_SMM_LOCK_BOX_PARAMETER_RESTORE *)&CommBuffer[OFFSET_OF (EFI_SMM_COMMUNICATE_HEADER, MessageLength) + sizeof(UINTN)];
585	}
586	DEBUG ((DEBUG_INFO, "SmmLockBoxPeiLib LockBoxParameterRestore - %x\n", LockBoxParameterRestore));
587	LockBoxParameterRestore->Header.Command = EFI_SMM_LOCK_BOX_COMMAND_RESTORE;
588	LockBoxParameterRestore->Header.DataLength = sizeof(*LockBoxParameterRestore);
589	LockBoxParameterRestore->Header.ReturnStatus = (UINT64)-1;
590	if (Guid != 0) {
591	CopyMem (&LockBoxParameterRestore->Guid, Guid, sizeof(*Guid));
592	} else {
593	ZeroMem (&LockBoxParameterRestore->Guid, sizeof(*Guid));
594	}
595	LockBoxParameterRestore->Buffer = (EFI_PHYSICAL_ADDRESS)(UINTN)Buffer;
596	if (Length != NULL) {
597	LockBoxParameterRestore->Length = (EFI_PHYSICAL_ADDRESS)*Length;
598	} else {
599	LockBoxParameterRestore->Length = 0;
600	}
601
602	//
603	// Send command
604	//
605	CommSize = sizeof(CommBuffer);
606	Status = SmmCommunicationPpi->Communicate (
607	SmmCommunicationPpi,
608	&CommBuffer[0],
609	&CommSize
610	);
611	if (Status == EFI_NOT_STARTED) {
612	//
613	// Pei SMM communication not ready yet, so we access SMRAM directly
614	//
615	DEBUG ((DEBUG_INFO, "SmmLockBoxPeiLib Communicate - (%r)\n", Status));
616	Status = InternalRestoreLockBoxFromSmram (Guid, Buffer, Length);
617	LockBoxParameterRestore->Header.ReturnStatus = (UINT64)Status;
618	if (Length != NULL) {
619	LockBoxParameterRestore->Length = (UINT64)*Length;
620	}
621	}
622
623	if (Length != NULL) {
624	*Length = (UINTN)LockBoxParameterRestore->Length;
625	}
626
627	Status = (EFI_STATUS)LockBoxParameterRestore->Header.ReturnStatus;
628	if (Status != EFI_SUCCESS) {
629	// Need or MAX_BIT, because there might be case that SMM is X64 while PEI is IA32.
630	Status \|= MAX_BIT;
631	}
632
633	DEBUG ((DEBUG_INFO, "SmmLockBoxPeiLib RestoreLockBox - Exit (%r)\n", Status));
634
635	//
636	// Done
637	//
638	return Status;
639	}
640
641	/**
642	This function will restore confidential information from all lockbox which have RestoreInPlace attribute.
643
644	@retval RETURN_SUCCESS the information is restored successfully.
645	@retval RETURN_NOT_STARTED it is too early to invoke this interface
646	@retval RETURN_UNSUPPORTED the service is not supported by implementaion.
647	**/
648	RETURN_STATUS
649	EFIAPI
650	RestoreAllLockBoxInPlace (
651	VOID
652	)
653	{
654	EFI_STATUS Status;
655	EFI_PEI_SMM_COMMUNICATION_PPI *SmmCommunicationPpi;
656	EFI_SMM_LOCK_BOX_PARAMETER_RESTORE_ALL_IN_PLACE *LockBoxParameterRestoreAllInPlace;
657	EFI_SMM_COMMUNICATE_HEADER *CommHeader;
658	UINT8 CommBuffer[sizeof(EFI_GUID) + sizeof(UINT64) + sizeof(EFI_SMM_LOCK_BOX_PARAMETER_RESTORE_ALL_IN_PLACE)];
659	UINTN CommSize;
660	UINT64 MessageLength;
661
662	//
663	// Please aware that there is UINTN in EFI_SMM_COMMUNICATE_HEADER. It might be UINT64 in DXE, while it is UINT32 in PEI.
664	// typedef struct {
665	// EFI_GUID HeaderGuid;
666	// UINTN MessageLength;
667	// UINT8 Data[1];
668	// } EFI_SMM_COMMUNICATE_HEADER;
669	//
670
671	DEBUG ((DEBUG_INFO, "SmmLockBoxPeiLib RestoreAllLockBoxInPlace - Enter\n"));
672
673	//
674	// Get needed resource
675	//
676	Status = PeiServicesLocatePpi (
677	&gEfiPeiSmmCommunicationPpiGuid,
678	0,
679	NULL,
680	(VOID **)&SmmCommunicationPpi
681	);
682	if (EFI_ERROR (Status)) {
683	DEBUG ((DEBUG_INFO, "SmmLockBoxPeiLib LocatePpi - (%r)\n", Status));
684	Status = InternalRestoreAllLockBoxInPlaceFromSmram ();
685	DEBUG ((DEBUG_INFO, "SmmLockBoxPeiLib RestoreAllLockBoxInPlace - Exit (%r)\n", Status));
686	return Status;
687	}
688
689	//
690	// Prepare parameter
691	//
692	CommHeader = (EFI_SMM_COMMUNICATE_HEADER *)&CommBuffer[0];
693	CopyMem (&CommHeader->HeaderGuid, &gEfiSmmLockBoxCommunicationGuid, sizeof(gEfiSmmLockBoxCommunicationGuid));
694	if ((sizeof(UINTN) == sizeof(UINT32)) && (FeaturePcdGet (PcdDxeIplSwitchToLongMode)) ) {
695	MessageLength = sizeof(*LockBoxParameterRestoreAllInPlace);
696	CopyMem (&CommBuffer[OFFSET_OF (EFI_SMM_COMMUNICATE_HEADER, MessageLength)], &MessageLength, sizeof(MessageLength));
697	} else {
698	CommHeader->MessageLength = sizeof(*LockBoxParameterRestoreAllInPlace);
699	}
700
701	if ((sizeof(UINTN) == sizeof(UINT32)) && (FeaturePcdGet (PcdDxeIplSwitchToLongMode)) ) {
702	LockBoxParameterRestoreAllInPlace = (EFI_SMM_LOCK_BOX_PARAMETER_RESTORE_ALL_IN_PLACE *)&CommBuffer[OFFSET_OF (EFI_SMM_COMMUNICATE_HEADER, MessageLength) + sizeof(UINT64)];
703	} else {
704	LockBoxParameterRestoreAllInPlace = (EFI_SMM_LOCK_BOX_PARAMETER_RESTORE_ALL_IN_PLACE *)&CommBuffer[OFFSET_OF (EFI_SMM_COMMUNICATE_HEADER, MessageLength) + sizeof(UINTN)];
705	}
706	LockBoxParameterRestoreAllInPlace->Header.Command = EFI_SMM_LOCK_BOX_COMMAND_RESTORE_ALL_IN_PLACE;
707	LockBoxParameterRestoreAllInPlace->Header.DataLength = sizeof(*LockBoxParameterRestoreAllInPlace);
708	LockBoxParameterRestoreAllInPlace->Header.ReturnStatus = (UINT64)-1;
709
710	//
711	// Send command
712	//
713	CommSize = sizeof(CommBuffer);
714	Status = SmmCommunicationPpi->Communicate (
715	SmmCommunicationPpi,
716	&CommBuffer[0],
717	&CommSize
718	);
719	if (Status == EFI_NOT_STARTED) {
720	//
721	// Pei SMM communication not ready yet, so we access SMRAM directly
722	//
723	DEBUG ((DEBUG_INFO, "SmmLockBoxPeiLib Communicate - (%r)\n", Status));
724	Status = InternalRestoreAllLockBoxInPlaceFromSmram ();
725	LockBoxParameterRestoreAllInPlace->Header.ReturnStatus = (UINT64)Status;
726	}
727	ASSERT_EFI_ERROR (Status);
728
729	Status = (EFI_STATUS)LockBoxParameterRestoreAllInPlace->Header.ReturnStatus;
730	if (Status != EFI_SUCCESS) {
731	// Need or MAX_BIT, because there might be case that SMM is X64 while PEI is IA32.
732	Status \|= MAX_BIT;
733	}
734
735	DEBUG ((DEBUG_INFO, "SmmLockBoxPeiLib RestoreAllLockBoxInPlace - Exit (%r)\n", Status));
736
737	//
738	// Done
739	//
740	return Status;
741	}
742

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Library/SmmLockBoxLib/SmmLockBoxPeiLib.c@ 81344

Download in other formats: