VirtualBox

source: vbox/trunk/src/VBox/Devices/EFI/FirmwareNew/MdePkg/Library/SmmMemLib/SmmMemLib.c@ 77662

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

EFI: First step in UDK2018 merge. Does not build yet.
  • 屬性 svn:eol-style 設為 native
檔案大小: 21.5 KB
行 
1/** @file
2 Instance of SMM memory check library.
3
4 SMM memory check library library implementation. This library consumes SMM_ACCESS2_PROTOCOL
5 to get SMRAM information. In order to use this library instance, the platform should produce
6 all SMRAM range via SMM_ACCESS2_PROTOCOL, including the range for firmware (like SMM Core
7 and SMM driver) and/or specific dedicated hardware.
8
9 Copyright (c) 2015 - 2017, Intel Corporation. All rights reserved.<BR>
10 This program and the accompanying materials
11 are licensed and made available under the terms and conditions of the BSD License
12 which accompanies this distribution. The full text of the license may be found at
13 http://opensource.org/licenses/bsd-license.php
14
15 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
16 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
17
18**/
19
20
21#include <PiSmm.h>
22
23#include <Library/BaseLib.h>
24#include <Library/BaseMemoryLib.h>
25#include <Library/DebugLib.h>
26#include <Library/MemoryAllocationLib.h>
27#include <Library/UefiBootServicesTableLib.h>
28#include <Library/DxeServicesTableLib.h>
29#include <Library/SmmServicesTableLib.h>
30#include <Library/UefiLib.h>
31#include <Library/HobLib.h>
32#include <Protocol/SmmAccess2.h>
33#include <Protocol/SmmReadyToLock.h>
34#include <Protocol/SmmEndOfDxe.h>
35#include <Guid/MemoryAttributesTable.h>
36
37//
38// attributes for reserved memory before it is promoted to system memory
39//
40#define EFI_MEMORY_PRESENT 0x0100000000000000ULL
41#define EFI_MEMORY_INITIALIZED 0x0200000000000000ULL
42#define EFI_MEMORY_TESTED 0x0400000000000000ULL
43
44EFI_SMRAM_DESCRIPTOR *mSmmMemLibInternalSmramRanges;
45UINTN mSmmMemLibInternalSmramCount;
46
47//
48// Maximum support address used to check input buffer
49//
50EFI_PHYSICAL_ADDRESS mSmmMemLibInternalMaximumSupportAddress = 0;
51
52UINTN mMemoryMapEntryCount;
53EFI_MEMORY_DESCRIPTOR *mMemoryMap;
54UINTN mDescriptorSize;
55
56EFI_GCD_MEMORY_SPACE_DESCRIPTOR *mSmmMemLibGcdMemSpace = NULL;
57UINTN mSmmMemLibGcdMemNumberOfDesc = 0;
58
59EFI_MEMORY_ATTRIBUTES_TABLE *mSmmMemLibMemoryAttributesTable = NULL;
60
61VOID *mRegistrationEndOfDxe;
62VOID *mRegistrationReadyToLock;
63
64BOOLEAN mSmmMemLibSmmReadyToLock = FALSE;
65
66/**
67 Calculate and save the maximum support address.
68
69**/
70VOID
71SmmMemLibInternalCalculateMaximumSupportAddress (
72 VOID
73 )
74{
75 VOID *Hob;
76 UINT32 RegEax;
77 UINT8 PhysicalAddressBits;
78
79 //
80 // Get physical address bits supported.
81 //
82 Hob = GetFirstHob (EFI_HOB_TYPE_CPU);
83 if (Hob != NULL) {
84 PhysicalAddressBits = ((EFI_HOB_CPU *) Hob)->SizeOfMemorySpace;
85 } else {
86 AsmCpuid (0x80000000, &RegEax, NULL, NULL, NULL);
87 if (RegEax >= 0x80000008) {
88 AsmCpuid (0x80000008, &RegEax, NULL, NULL, NULL);
89 PhysicalAddressBits = (UINT8) RegEax;
90 } else {
91 PhysicalAddressBits = 36;
92 }
93 }
94 //
95 // IA-32e paging translates 48-bit linear addresses to 52-bit physical addresses.
96 //
97 ASSERT (PhysicalAddressBits <= 52);
98 if (PhysicalAddressBits > 48) {
99 PhysicalAddressBits = 48;
100 }
101
102 //
103 // Save the maximum support address in one global variable
104 //
105 mSmmMemLibInternalMaximumSupportAddress = (EFI_PHYSICAL_ADDRESS)(UINTN)(LShiftU64 (1, PhysicalAddressBits) - 1);
106 DEBUG ((EFI_D_INFO, "mSmmMemLibInternalMaximumSupportAddress = 0x%lx\n", mSmmMemLibInternalMaximumSupportAddress));
107}
108
109/**
110 This function check if the buffer is valid per processor architecture and not overlap with SMRAM.
111
112 @param Buffer The buffer start address to be checked.
113 @param Length The buffer length to be checked.
114
115 @retval TRUE This buffer is valid per processor architecture and not overlap with SMRAM.
116 @retval FALSE This buffer is not valid per processor architecture or overlap with SMRAM.
117**/
118BOOLEAN
119EFIAPI
120SmmIsBufferOutsideSmmValid (
121 IN EFI_PHYSICAL_ADDRESS Buffer,
122 IN UINT64 Length
123 )
124{
125 UINTN Index;
126
127 //
128 // Check override.
129 // NOTE: (B:0->L:4G) is invalid for IA32, but (B:1->L:4G-1)/(B:4G-1->L:1) is valid.
130 //
131 if ((Length > mSmmMemLibInternalMaximumSupportAddress) ||
132 (Buffer > mSmmMemLibInternalMaximumSupportAddress) ||
133 ((Length != 0) && (Buffer > (mSmmMemLibInternalMaximumSupportAddress - (Length - 1)))) ) {
134 //
135 // Overflow happen
136 //
137 DEBUG ((
138 EFI_D_ERROR,
139 "SmmIsBufferOutsideSmmValid: Overflow: Buffer (0x%lx) - Length (0x%lx), MaximumSupportAddress (0x%lx)\n",
140 Buffer,
141 Length,
142 mSmmMemLibInternalMaximumSupportAddress
143 ));
144 return FALSE;
145 }
146
147 for (Index = 0; Index < mSmmMemLibInternalSmramCount; Index ++) {
148 if (((Buffer >= mSmmMemLibInternalSmramRanges[Index].CpuStart) && (Buffer < mSmmMemLibInternalSmramRanges[Index].CpuStart + mSmmMemLibInternalSmramRanges[Index].PhysicalSize)) ||
149 ((mSmmMemLibInternalSmramRanges[Index].CpuStart >= Buffer) && (mSmmMemLibInternalSmramRanges[Index].CpuStart < Buffer + Length))) {
150 DEBUG ((
151 EFI_D_ERROR,
152 "SmmIsBufferOutsideSmmValid: Overlap: Buffer (0x%lx) - Length (0x%lx), ",
153 Buffer,
154 Length
155 ));
156 DEBUG ((
157 EFI_D_ERROR,
158 "CpuStart (0x%lx) - PhysicalSize (0x%lx)\n",
159 mSmmMemLibInternalSmramRanges[Index].CpuStart,
160 mSmmMemLibInternalSmramRanges[Index].PhysicalSize
161 ));
162 return FALSE;
163 }
164 }
165
166 //
167 // Check override for Valid Communication Region
168 //
169 if (mSmmMemLibSmmReadyToLock) {
170 EFI_MEMORY_DESCRIPTOR *MemoryMap;
171 BOOLEAN InValidCommunicationRegion;
172
173 InValidCommunicationRegion = FALSE;
174 MemoryMap = mMemoryMap;
175 for (Index = 0; Index < mMemoryMapEntryCount; Index++) {
176 if ((Buffer >= MemoryMap->PhysicalStart) &&
177 (Buffer + Length <= MemoryMap->PhysicalStart + LShiftU64 (MemoryMap->NumberOfPages, EFI_PAGE_SHIFT))) {
178 InValidCommunicationRegion = TRUE;
179 }
180 MemoryMap = NEXT_MEMORY_DESCRIPTOR(MemoryMap, mDescriptorSize);
181 }
182
183 if (!InValidCommunicationRegion) {
184 DEBUG ((
185 EFI_D_ERROR,
186 "SmmIsBufferOutsideSmmValid: Not in ValidCommunicationRegion: Buffer (0x%lx) - Length (0x%lx)\n",
187 Buffer,
188 Length
189 ));
190 return FALSE;
191 }
192
193 //
194 // Check untested memory as invalid communication buffer.
195 //
196 for (Index = 0; Index < mSmmMemLibGcdMemNumberOfDesc; Index++) {
197 if (((Buffer >= mSmmMemLibGcdMemSpace[Index].BaseAddress) && (Buffer < mSmmMemLibGcdMemSpace[Index].BaseAddress + mSmmMemLibGcdMemSpace[Index].Length)) ||
198 ((mSmmMemLibGcdMemSpace[Index].BaseAddress >= Buffer) && (mSmmMemLibGcdMemSpace[Index].BaseAddress < Buffer + Length))) {
199 DEBUG ((
200 EFI_D_ERROR,
201 "SmmIsBufferOutsideSmmValid: In Untested Memory Region: Buffer (0x%lx) - Length (0x%lx)\n",
202 Buffer,
203 Length
204 ));
205 return FALSE;
206 }
207 }
208
209 //
210 // Check UEFI runtime memory with EFI_MEMORY_RO as invalid communication buffer.
211 //
212 if (mSmmMemLibMemoryAttributesTable != NULL) {
213 EFI_MEMORY_DESCRIPTOR *Entry;
214
215 Entry = (EFI_MEMORY_DESCRIPTOR *)(mSmmMemLibMemoryAttributesTable + 1);
216 for (Index = 0; Index < mSmmMemLibMemoryAttributesTable->NumberOfEntries; Index++) {
217 if (Entry->Type == EfiRuntimeServicesCode || Entry->Type == EfiRuntimeServicesData) {
218 if ((Entry->Attribute & EFI_MEMORY_RO) != 0) {
219 if (((Buffer >= Entry->PhysicalStart) && (Buffer < Entry->PhysicalStart + LShiftU64 (Entry->NumberOfPages, EFI_PAGE_SHIFT))) ||
220 ((Entry->PhysicalStart >= Buffer) && (Entry->PhysicalStart < Buffer + Length))) {
221 DEBUG ((
222 EFI_D_ERROR,
223 "SmmIsBufferOutsideSmmValid: In RuntimeCode Region: Buffer (0x%lx) - Length (0x%lx)\n",
224 Buffer,
225 Length
226 ));
227 return FALSE;
228 }
229 }
230 }
231 Entry = NEXT_MEMORY_DESCRIPTOR (Entry, mSmmMemLibMemoryAttributesTable->DescriptorSize);
232 }
233 }
234 }
235 return TRUE;
236}
237
238/**
239 Copies a source buffer (non-SMRAM) to a destination buffer (SMRAM).
240
241 This function copies a source buffer (non-SMRAM) to a destination buffer (SMRAM).
242 It checks if source buffer is valid per processor architecture and not overlap with SMRAM.
243 If the check passes, it copies memory and returns EFI_SUCCESS.
244 If the check fails, it return EFI_SECURITY_VIOLATION.
245 The implementation must be reentrant.
246
247 @param DestinationBuffer The pointer to the destination buffer of the memory copy.
248 @param SourceBuffer The pointer to the source buffer of the memory copy.
249 @param Length The number of bytes to copy from SourceBuffer to DestinationBuffer.
250
251 @retval EFI_SECURITY_VIOLATION The SourceBuffer is invalid per processor architecture or overlap with SMRAM.
252 @retval EFI_SUCCESS Memory is copied.
253
254**/
255EFI_STATUS
256EFIAPI
257SmmCopyMemToSmram (
258 OUT VOID *DestinationBuffer,
259 IN CONST VOID *SourceBuffer,
260 IN UINTN Length
261 )
262{
263 if (!SmmIsBufferOutsideSmmValid ((EFI_PHYSICAL_ADDRESS)(UINTN)SourceBuffer, Length)) {
264 DEBUG ((EFI_D_ERROR, "SmmCopyMemToSmram: Security Violation: Source (0x%x), Length (0x%x)\n", SourceBuffer, Length));
265 return EFI_SECURITY_VIOLATION;
266 }
267 CopyMem (DestinationBuffer, SourceBuffer, Length);
268 return EFI_SUCCESS;
269}
270
271/**
272 Copies a source buffer (SMRAM) to a destination buffer (NON-SMRAM).
273
274 This function copies a source buffer (non-SMRAM) to a destination buffer (SMRAM).
275 It checks if destination buffer is valid per processor architecture and not overlap with SMRAM.
276 If the check passes, it copies memory and returns EFI_SUCCESS.
277 If the check fails, it returns EFI_SECURITY_VIOLATION.
278 The implementation must be reentrant.
279
280 @param DestinationBuffer The pointer to the destination buffer of the memory copy.
281 @param SourceBuffer The pointer to the source buffer of the memory copy.
282 @param Length The number of bytes to copy from SourceBuffer to DestinationBuffer.
283
284 @retval EFI_SECURITY_VIOLATION The DesinationBuffer is invalid per processor architecture or overlap with SMRAM.
285 @retval EFI_SUCCESS Memory is copied.
286
287**/
288EFI_STATUS
289EFIAPI
290SmmCopyMemFromSmram (
291 OUT VOID *DestinationBuffer,
292 IN CONST VOID *SourceBuffer,
293 IN UINTN Length
294 )
295{
296 if (!SmmIsBufferOutsideSmmValid ((EFI_PHYSICAL_ADDRESS)(UINTN)DestinationBuffer, Length)) {
297 DEBUG ((EFI_D_ERROR, "SmmCopyMemFromSmram: Security Violation: Destination (0x%x), Length (0x%x)\n", DestinationBuffer, Length));
298 return EFI_SECURITY_VIOLATION;
299 }
300 CopyMem (DestinationBuffer, SourceBuffer, Length);
301 return EFI_SUCCESS;
302}
303
304/**
305 Copies a source buffer (NON-SMRAM) to a destination buffer (NON-SMRAM).
306
307 This function copies a source buffer (non-SMRAM) to a destination buffer (SMRAM).
308 It checks if source buffer and destination buffer are valid per processor architecture and not overlap with SMRAM.
309 If the check passes, it copies memory and returns EFI_SUCCESS.
310 If the check fails, it returns EFI_SECURITY_VIOLATION.
311 The implementation must be reentrant, and it must handle the case where source buffer overlaps destination buffer.
312
313 @param DestinationBuffer The pointer to the destination buffer of the memory copy.
314 @param SourceBuffer The pointer to the source buffer of the memory copy.
315 @param Length The number of bytes to copy from SourceBuffer to DestinationBuffer.
316
317 @retval EFI_SECURITY_VIOLATION The DesinationBuffer is invalid per processor architecture or overlap with SMRAM.
318 @retval EFI_SECURITY_VIOLATION The SourceBuffer is invalid per processor architecture or overlap with SMRAM.
319 @retval EFI_SUCCESS Memory is copied.
320
321**/
322EFI_STATUS
323EFIAPI
324SmmCopyMem (
325 OUT VOID *DestinationBuffer,
326 IN CONST VOID *SourceBuffer,
327 IN UINTN Length
328 )
329{
330 if (!SmmIsBufferOutsideSmmValid ((EFI_PHYSICAL_ADDRESS)(UINTN)DestinationBuffer, Length)) {
331 DEBUG ((EFI_D_ERROR, "SmmCopyMem: Security Violation: Destination (0x%x), Length (0x%x)\n", DestinationBuffer, Length));
332 return EFI_SECURITY_VIOLATION;
333 }
334 if (!SmmIsBufferOutsideSmmValid ((EFI_PHYSICAL_ADDRESS)(UINTN)SourceBuffer, Length)) {
335 DEBUG ((EFI_D_ERROR, "SmmCopyMem: Security Violation: Source (0x%x), Length (0x%x)\n", SourceBuffer, Length));
336 return EFI_SECURITY_VIOLATION;
337 }
338 CopyMem (DestinationBuffer, SourceBuffer, Length);
339 return EFI_SUCCESS;
340}
341
342/**
343 Fills a target buffer (NON-SMRAM) with a byte value.
344
345 This function fills a target buffer (non-SMRAM) with a byte value.
346 It checks if target buffer is valid per processor architecture and not overlap with SMRAM.
347 If the check passes, it fills memory and returns EFI_SUCCESS.
348 If the check fails, it returns EFI_SECURITY_VIOLATION.
349
350 @param Buffer The memory to set.
351 @param Length The number of bytes to set.
352 @param Value The value with which to fill Length bytes of Buffer.
353
354 @retval EFI_SECURITY_VIOLATION The Buffer is invalid per processor architecture or overlap with SMRAM.
355 @retval EFI_SUCCESS Memory is set.
356
357**/
358EFI_STATUS
359EFIAPI
360SmmSetMem (
361 OUT VOID *Buffer,
362 IN UINTN Length,
363 IN UINT8 Value
364 )
365{
366 if (!SmmIsBufferOutsideSmmValid ((EFI_PHYSICAL_ADDRESS)(UINTN)Buffer, Length)) {
367 DEBUG ((EFI_D_ERROR, "SmmSetMem: Security Violation: Source (0x%x), Length (0x%x)\n", Buffer, Length));
368 return EFI_SECURITY_VIOLATION;
369 }
370 SetMem (Buffer, Length, Value);
371 return EFI_SUCCESS;
372}
373
374/**
375 Get GCD memory map.
376 Only record untested memory as invalid communication buffer.
377**/
378VOID
379SmmMemLibInternalGetGcdMemoryMap (
380 VOID
381 )
382{
383 UINTN NumberOfDescriptors;
384 EFI_GCD_MEMORY_SPACE_DESCRIPTOR *MemSpaceMap;
385 EFI_STATUS Status;
386 UINTN Index;
387
388 Status = gDS->GetMemorySpaceMap (&NumberOfDescriptors, &MemSpaceMap);
389 if (EFI_ERROR (Status)) {
390 return ;
391 }
392
393 mSmmMemLibGcdMemNumberOfDesc = 0;
394 for (Index = 0; Index < NumberOfDescriptors; Index++) {
395 if (MemSpaceMap[Index].GcdMemoryType == EfiGcdMemoryTypeReserved &&
396 (MemSpaceMap[Index].Capabilities & (EFI_MEMORY_PRESENT | EFI_MEMORY_INITIALIZED | EFI_MEMORY_TESTED)) ==
397 (EFI_MEMORY_PRESENT | EFI_MEMORY_INITIALIZED)
398 ) {
399 mSmmMemLibGcdMemNumberOfDesc++;
400 }
401 }
402
403 mSmmMemLibGcdMemSpace = AllocateZeroPool (mSmmMemLibGcdMemNumberOfDesc * sizeof (EFI_GCD_MEMORY_SPACE_DESCRIPTOR));
404 ASSERT (mSmmMemLibGcdMemSpace != NULL);
405 if (mSmmMemLibGcdMemSpace == NULL) {
406 mSmmMemLibGcdMemNumberOfDesc = 0;
407 gBS->FreePool (MemSpaceMap);
408 return ;
409 }
410
411 mSmmMemLibGcdMemNumberOfDesc = 0;
412 for (Index = 0; Index < NumberOfDescriptors; Index++) {
413 if (MemSpaceMap[Index].GcdMemoryType == EfiGcdMemoryTypeReserved &&
414 (MemSpaceMap[Index].Capabilities & (EFI_MEMORY_PRESENT | EFI_MEMORY_INITIALIZED | EFI_MEMORY_TESTED)) ==
415 (EFI_MEMORY_PRESENT | EFI_MEMORY_INITIALIZED)
416 ) {
417 CopyMem (
418 &mSmmMemLibGcdMemSpace[mSmmMemLibGcdMemNumberOfDesc],
419 &MemSpaceMap[Index],
420 sizeof(EFI_GCD_MEMORY_SPACE_DESCRIPTOR)
421 );
422 mSmmMemLibGcdMemNumberOfDesc++;
423 }
424 }
425
426 gBS->FreePool (MemSpaceMap);
427}
428
429/**
430 Get UEFI MemoryAttributesTable.
431**/
432VOID
433SmmMemLibInternalGetUefiMemoryAttributesTable (
434 VOID
435 )
436{
437 EFI_STATUS Status;
438 EFI_MEMORY_ATTRIBUTES_TABLE *MemoryAttributesTable;
439 UINTN MemoryAttributesTableSize;
440
441 Status = EfiGetSystemConfigurationTable (&gEfiMemoryAttributesTableGuid, (VOID **)&MemoryAttributesTable);
442 if (!EFI_ERROR (Status) && (MemoryAttributesTable != NULL)) {
443 MemoryAttributesTableSize = sizeof(EFI_MEMORY_ATTRIBUTES_TABLE) + MemoryAttributesTable->DescriptorSize * MemoryAttributesTable->NumberOfEntries;
444 mSmmMemLibMemoryAttributesTable = AllocateCopyPool (MemoryAttributesTableSize, MemoryAttributesTable);
445 ASSERT (mSmmMemLibMemoryAttributesTable != NULL);
446 }
447}
448
449/**
450 Notification for SMM EndOfDxe protocol.
451
452 @param[in] Protocol Points to the protocol's unique identifier.
453 @param[in] Interface Points to the interface instance.
454 @param[in] Handle The handle on which the interface was installed.
455
456 @retval EFI_SUCCESS Notification runs successfully.
457**/
458EFI_STATUS
459EFIAPI
460SmmLibInternalEndOfDxeNotify (
461 IN CONST EFI_GUID *Protocol,
462 IN VOID *Interface,
463 IN EFI_HANDLE Handle
464 )
465{
466 EFI_STATUS Status;
467 UINTN MapKey;
468 UINTN MemoryMapSize;
469 EFI_MEMORY_DESCRIPTOR *MemoryMap;
470 EFI_MEMORY_DESCRIPTOR *MemoryMapStart;
471 EFI_MEMORY_DESCRIPTOR *SmmMemoryMapStart;
472 UINTN MemoryMapEntryCount;
473 UINTN DescriptorSize;
474 UINT32 DescriptorVersion;
475 UINTN Index;
476
477 MemoryMapSize = 0;
478 MemoryMap = NULL;
479 Status = gBS->GetMemoryMap (
480 &MemoryMapSize,
481 MemoryMap,
482 &MapKey,
483 &DescriptorSize,
484 &DescriptorVersion
485 );
486 ASSERT (Status == EFI_BUFFER_TOO_SMALL);
487
488 do {
489 Status = gBS->AllocatePool (EfiBootServicesData, MemoryMapSize, (VOID **)&MemoryMap);
490 ASSERT (MemoryMap != NULL);
491
492 Status = gBS->GetMemoryMap (
493 &MemoryMapSize,
494 MemoryMap,
495 &MapKey,
496 &DescriptorSize,
497 &DescriptorVersion
498 );
499 if (EFI_ERROR (Status)) {
500 gBS->FreePool (MemoryMap);
501 }
502 } while (Status == EFI_BUFFER_TOO_SMALL);
503
504 //
505 // Get Count
506 //
507 mDescriptorSize = DescriptorSize;
508 MemoryMapEntryCount = MemoryMapSize/DescriptorSize;
509 MemoryMapStart = MemoryMap;
510 mMemoryMapEntryCount = 0;
511 for (Index = 0; Index < MemoryMapEntryCount; Index++) {
512 switch (MemoryMap->Type) {
513 case EfiReservedMemoryType:
514 case EfiRuntimeServicesCode:
515 case EfiRuntimeServicesData:
516 case EfiACPIMemoryNVS:
517 mMemoryMapEntryCount++;
518 break;
519 }
520 MemoryMap = NEXT_MEMORY_DESCRIPTOR(MemoryMap, DescriptorSize);
521 }
522 MemoryMap = MemoryMapStart;
523
524 //
525 // Get Data
526 //
527 mMemoryMap = AllocatePool (mMemoryMapEntryCount*DescriptorSize);
528 ASSERT (mMemoryMap != NULL);
529 SmmMemoryMapStart = mMemoryMap;
530 for (Index = 0; Index < MemoryMapEntryCount; Index++) {
531 switch (MemoryMap->Type) {
532 case EfiReservedMemoryType:
533 case EfiRuntimeServicesCode:
534 case EfiRuntimeServicesData:
535 case EfiACPIMemoryNVS:
536 CopyMem (mMemoryMap, MemoryMap, DescriptorSize);
537 mMemoryMap = NEXT_MEMORY_DESCRIPTOR(mMemoryMap, DescriptorSize);
538 break;
539 }
540 MemoryMap = NEXT_MEMORY_DESCRIPTOR(MemoryMap, DescriptorSize);
541 }
542 mMemoryMap = SmmMemoryMapStart;
543 MemoryMap = MemoryMapStart;
544
545 gBS->FreePool (MemoryMap);
546
547 //
548 // Get additional information from GCD memory map.
549 //
550 SmmMemLibInternalGetGcdMemoryMap ();
551
552 //
553 // Get UEFI memory attributes table.
554 //
555 SmmMemLibInternalGetUefiMemoryAttributesTable ();
556
557 return EFI_SUCCESS;
558}
559
560/**
561 Notification for SMM ReadyToLock protocol.
562
563 @param[in] Protocol Points to the protocol's unique identifier.
564 @param[in] Interface Points to the interface instance.
565 @param[in] Handle The handle on which the interface was installed.
566
567 @retval EFI_SUCCESS Notification runs successfully.
568**/
569EFI_STATUS
570EFIAPI
571SmmLibInternalReadyToLockNotify (
572 IN CONST EFI_GUID *Protocol,
573 IN VOID *Interface,
574 IN EFI_HANDLE Handle
575 )
576{
577 mSmmMemLibSmmReadyToLock = TRUE;
578 return EFI_SUCCESS;
579}
580/**
581 The constructor function initializes the Smm Mem library
582
583 @param ImageHandle The firmware allocated handle for the EFI image.
584 @param SystemTable A pointer to the EFI System Table.
585
586 @retval EFI_SUCCESS The constructor always returns EFI_SUCCESS.
587
588**/
589EFI_STATUS
590EFIAPI
591SmmMemLibConstructor (
592 IN EFI_HANDLE ImageHandle,
593 IN EFI_SYSTEM_TABLE *SystemTable
594 )
595{
596 EFI_STATUS Status;
597 EFI_SMM_ACCESS2_PROTOCOL *SmmAccess;
598 UINTN Size;
599
600 //
601 // Get SMRAM information
602 //
603 Status = gBS->LocateProtocol (&gEfiSmmAccess2ProtocolGuid, NULL, (VOID **)&SmmAccess);
604 ASSERT_EFI_ERROR (Status);
605
606 Size = 0;
607 Status = SmmAccess->GetCapabilities (SmmAccess, &Size, NULL);
608 ASSERT (Status == EFI_BUFFER_TOO_SMALL);
609
610 mSmmMemLibInternalSmramRanges = AllocatePool (Size);
611 ASSERT (mSmmMemLibInternalSmramRanges != NULL);
612
613 Status = SmmAccess->GetCapabilities (SmmAccess, &Size, mSmmMemLibInternalSmramRanges);
614 ASSERT_EFI_ERROR (Status);
615
616 mSmmMemLibInternalSmramCount = Size / sizeof (EFI_SMRAM_DESCRIPTOR);
617
618 //
619 // Calculate and save maximum support address
620 //
621 SmmMemLibInternalCalculateMaximumSupportAddress ();
622
623 //
624 // Register EndOfDxe to get UEFI memory map
625 //
626 Status = gSmst->SmmRegisterProtocolNotify (&gEfiSmmEndOfDxeProtocolGuid, SmmLibInternalEndOfDxeNotify, &mRegistrationEndOfDxe);
627 ASSERT_EFI_ERROR (Status);
628
629 //
630 // Register ready to lock so that we can know when to check valid SMRAM region
631 //
632 Status = gSmst->SmmRegisterProtocolNotify (&gEfiSmmReadyToLockProtocolGuid, SmmLibInternalReadyToLockNotify, &mRegistrationReadyToLock);
633 ASSERT_EFI_ERROR (Status);
634
635 return EFI_SUCCESS;
636}
637
638/**
639 The destructor function frees resource used in the Smm Mem library
640
641 @param[in] ImageHandle The firmware allocated handle for the EFI image.
642 @param[in] SystemTable A pointer to the EFI System Table.
643
644 @retval EFI_SUCCESS The deconstructor always returns EFI_SUCCESS.
645**/
646EFI_STATUS
647EFIAPI
648SmmMemLibDestructor (
649 IN EFI_HANDLE ImageHandle,
650 IN EFI_SYSTEM_TABLE *SystemTable
651 )
652{
653 FreePool (mSmmMemLibInternalSmramRanges);
654
655 gSmst->SmmRegisterProtocolNotify (&gEfiSmmEndOfDxeProtocolGuid, NULL, &mRegistrationEndOfDxe);
656 gSmst->SmmRegisterProtocolNotify (&gEfiSmmReadyToLockProtocolGuid, NULL, &mRegistrationReadyToLock);
657 return EFI_SUCCESS;
658}
注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

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