1 /** @file 2 PI SMM MemoryAttributes support 3 4 Copyright (c) 2016, Intel Corporation. All rights reserved.<BR> 5 This program and the accompanying materials 6 are licensed and made available under the terms and conditions of the BSD License 7 which accompanies this distribution. The full text of the license may be found at 8 http://opensource.org/licenses/bsd-license.php 9 10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, 11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. 12 13 **/ 14 15 #include <PiDxe.h> 16 #include <Library/BaseLib.h> 17 #include <Library/BaseMemoryLib.h> 18 #include <Library/MemoryAllocationLib.h> 19 #include <Library/UefiBootServicesTableLib.h> 20 #include <Library/SmmServicesTableLib.h> 21 #include <Library/DebugLib.h> 22 #include <Library/PcdLib.h> 23 24 #include <Library/PeCoffLib.h> 25 #include <Library/PeCoffGetEntryPointLib.h> 26 27 #include <Guid/PiSmmMemoryAttributesTable.h> 28 29 #include "PiSmmCore.h" 30 31 #define PREVIOUS_MEMORY_DESCRIPTOR(MemoryDescriptor, Size) \ 32 ((EFI_MEMORY_DESCRIPTOR *)((UINT8 *)(MemoryDescriptor) - (Size))) 33 34 #define IMAGE_PROPERTIES_RECORD_CODE_SECTION_SIGNATURE SIGNATURE_32 ('I','P','R','C') 35 36 typedef struct { 37 UINT32 Signature; 38 LIST_ENTRY Link; 39 EFI_PHYSICAL_ADDRESS CodeSegmentBase; 40 UINT64 CodeSegmentSize; 41 } IMAGE_PROPERTIES_RECORD_CODE_SECTION; 42 43 #define IMAGE_PROPERTIES_RECORD_SIGNATURE SIGNATURE_32 ('I','P','R','D') 44 45 typedef struct { 46 UINT32 Signature; 47 LIST_ENTRY Link; 48 EFI_PHYSICAL_ADDRESS ImageBase; 49 UINT64 ImageSize; 50 UINTN CodeSegmentCount; 51 LIST_ENTRY CodeSegmentList; 52 } IMAGE_PROPERTIES_RECORD; 53 54 #define IMAGE_PROPERTIES_PRIVATE_DATA_SIGNATURE SIGNATURE_32 ('I','P','P','D') 55 56 typedef struct { 57 UINT32 Signature; 58 UINTN ImageRecordCount; 59 UINTN CodeSegmentCountMax; 60 LIST_ENTRY ImageRecordList; 61 } IMAGE_PROPERTIES_PRIVATE_DATA; 62 63 IMAGE_PROPERTIES_PRIVATE_DATA mImagePropertiesPrivateData = { 64 IMAGE_PROPERTIES_PRIVATE_DATA_SIGNATURE, 65 0, 66 0, 67 INITIALIZE_LIST_HEAD_VARIABLE (mImagePropertiesPrivateData.ImageRecordList) 68 }; 69 70 #define EFI_MEMORY_ATTRIBUTES_RUNTIME_MEMORY_PROTECTION_NON_EXECUTABLE_PE_DATA BIT0 71 72 UINT64 mMemoryProtectionAttribute = EFI_MEMORY_ATTRIBUTES_RUNTIME_MEMORY_PROTECTION_NON_EXECUTABLE_PE_DATA; 73 74 // 75 // Below functions are for MemoryMap 76 // 77 78 /** 79 Converts a number of EFI_PAGEs to a size in bytes. 80 81 NOTE: Do not use EFI_PAGES_TO_SIZE because it handles UINTN only. 82 83 @param[in] Pages The number of EFI_PAGES. 84 85 @return The number of bytes associated with the number of EFI_PAGEs specified 86 by Pages. 87 **/ 88 STATIC 89 UINT64 90 EfiPagesToSize ( 91 IN UINT64 Pages 92 ) 93 { 94 return LShiftU64 (Pages, EFI_PAGE_SHIFT); 95 } 96 97 /** 98 Converts a size, in bytes, to a number of EFI_PAGESs. 99 100 NOTE: Do not use EFI_SIZE_TO_PAGES because it handles UINTN only. 101 102 @param[in] Size A size in bytes. 103 104 @return The number of EFI_PAGESs associated with the number of bytes specified 105 by Size. 106 107 **/ 108 STATIC 109 UINT64 110 EfiSizeToPages ( 111 IN UINT64 Size 112 ) 113 { 114 return RShiftU64 (Size, EFI_PAGE_SHIFT) + ((((UINTN)Size) & EFI_PAGE_MASK) ? 1 : 0); 115 } 116 117 /** 118 Check the consistency of Smm memory attributes table. 119 120 @param[in] MemoryAttributesTable PI SMM memory attributes table 121 **/ 122 VOID 123 SmmMemoryAttributesTableConsistencyCheck ( 124 IN EDKII_PI_SMM_MEMORY_ATTRIBUTES_TABLE *MemoryAttributesTable 125 ) 126 { 127 EFI_MEMORY_DESCRIPTOR *MemoryMap; 128 UINTN MemoryMapEntryCount; 129 UINTN DescriptorSize; 130 UINTN Index; 131 UINT64 Address; 132 133 Address = 0; 134 MemoryMapEntryCount = MemoryAttributesTable->NumberOfEntries; 135 DescriptorSize = MemoryAttributesTable->DescriptorSize; 136 MemoryMap = (EFI_MEMORY_DESCRIPTOR *)(MemoryAttributesTable + 1); 137 for (Index = 0; Index < MemoryMapEntryCount; Index++) { 138 if (Address != 0) { 139 ASSERT (Address == MemoryMap->PhysicalStart); 140 } 141 Address = MemoryMap->PhysicalStart + EfiPagesToSize(MemoryMap->NumberOfPages); 142 MemoryMap = NEXT_MEMORY_DESCRIPTOR(MemoryMap, DescriptorSize); 143 } 144 } 145 146 /** 147 Sort memory map entries based upon PhysicalStart, from low to high. 148 149 @param[in,out] MemoryMap A pointer to the buffer in which firmware places 150 the current memory map. 151 @param[in] MemoryMapSize Size, in bytes, of the MemoryMap buffer. 152 @param[in] DescriptorSize Size, in bytes, of an individual EFI_MEMORY_DESCRIPTOR. 153 **/ 154 STATIC 155 VOID 156 SortMemoryMap ( 157 IN OUT EFI_MEMORY_DESCRIPTOR *MemoryMap, 158 IN UINTN MemoryMapSize, 159 IN UINTN DescriptorSize 160 ) 161 { 162 EFI_MEMORY_DESCRIPTOR *MemoryMapEntry; 163 EFI_MEMORY_DESCRIPTOR *NextMemoryMapEntry; 164 EFI_MEMORY_DESCRIPTOR *MemoryMapEnd; 165 EFI_MEMORY_DESCRIPTOR TempMemoryMap; 166 167 MemoryMapEntry = MemoryMap; 168 NextMemoryMapEntry = NEXT_MEMORY_DESCRIPTOR (MemoryMapEntry, DescriptorSize); 169 MemoryMapEnd = (EFI_MEMORY_DESCRIPTOR *) ((UINT8 *) MemoryMap + MemoryMapSize); 170 while (MemoryMapEntry < MemoryMapEnd) { 171 while (NextMemoryMapEntry < MemoryMapEnd) { 172 if (MemoryMapEntry->PhysicalStart > NextMemoryMapEntry->PhysicalStart) { 173 CopyMem (&TempMemoryMap, MemoryMapEntry, sizeof(EFI_MEMORY_DESCRIPTOR)); 174 CopyMem (MemoryMapEntry, NextMemoryMapEntry, sizeof(EFI_MEMORY_DESCRIPTOR)); 175 CopyMem (NextMemoryMapEntry, &TempMemoryMap, sizeof(EFI_MEMORY_DESCRIPTOR)); 176 } 177 178 NextMemoryMapEntry = NEXT_MEMORY_DESCRIPTOR (NextMemoryMapEntry, DescriptorSize); 179 } 180 181 MemoryMapEntry = NEXT_MEMORY_DESCRIPTOR (MemoryMapEntry, DescriptorSize); 182 NextMemoryMapEntry = NEXT_MEMORY_DESCRIPTOR (MemoryMapEntry, DescriptorSize); 183 } 184 185 return ; 186 } 187 188 /** 189 Merge continous memory map entries whose have same attributes. 190 191 @param[in, out] MemoryMap A pointer to the buffer in which firmware places 192 the current memory map. 193 @param[in, out] MemoryMapSize A pointer to the size, in bytes, of the 194 MemoryMap buffer. On input, this is the size of 195 the current memory map. On output, 196 it is the size of new memory map after merge. 197 @param[in] DescriptorSize Size, in bytes, of an individual EFI_MEMORY_DESCRIPTOR. 198 **/ 199 STATIC 200 VOID 201 MergeMemoryMap ( 202 IN OUT EFI_MEMORY_DESCRIPTOR *MemoryMap, 203 IN OUT UINTN *MemoryMapSize, 204 IN UINTN DescriptorSize 205 ) 206 { 207 EFI_MEMORY_DESCRIPTOR *MemoryMapEntry; 208 EFI_MEMORY_DESCRIPTOR *MemoryMapEnd; 209 UINT64 MemoryBlockLength; 210 EFI_MEMORY_DESCRIPTOR *NewMemoryMapEntry; 211 EFI_MEMORY_DESCRIPTOR *NextMemoryMapEntry; 212 213 MemoryMapEntry = MemoryMap; 214 NewMemoryMapEntry = MemoryMap; 215 MemoryMapEnd = (EFI_MEMORY_DESCRIPTOR *) ((UINT8 *) MemoryMap + *MemoryMapSize); 216 while ((UINTN)MemoryMapEntry < (UINTN)MemoryMapEnd) { 217 CopyMem (NewMemoryMapEntry, MemoryMapEntry, sizeof(EFI_MEMORY_DESCRIPTOR)); 218 NextMemoryMapEntry = NEXT_MEMORY_DESCRIPTOR (MemoryMapEntry, DescriptorSize); 219 220 do { 221 MemoryBlockLength = (UINT64) (EfiPagesToSize (MemoryMapEntry->NumberOfPages)); 222 if (((UINTN)NextMemoryMapEntry < (UINTN)MemoryMapEnd) && 223 (MemoryMapEntry->Type == NextMemoryMapEntry->Type) && 224 (MemoryMapEntry->Attribute == NextMemoryMapEntry->Attribute) && 225 ((MemoryMapEntry->PhysicalStart + MemoryBlockLength) == NextMemoryMapEntry->PhysicalStart)) { 226 MemoryMapEntry->NumberOfPages += NextMemoryMapEntry->NumberOfPages; 227 if (NewMemoryMapEntry != MemoryMapEntry) { 228 NewMemoryMapEntry->NumberOfPages += NextMemoryMapEntry->NumberOfPages; 229 } 230 231 NextMemoryMapEntry = NEXT_MEMORY_DESCRIPTOR (NextMemoryMapEntry, DescriptorSize); 232 continue; 233 } else { 234 MemoryMapEntry = PREVIOUS_MEMORY_DESCRIPTOR (NextMemoryMapEntry, DescriptorSize); 235 break; 236 } 237 } while (TRUE); 238 239 MemoryMapEntry = NEXT_MEMORY_DESCRIPTOR (MemoryMapEntry, DescriptorSize); 240 NewMemoryMapEntry = NEXT_MEMORY_DESCRIPTOR (NewMemoryMapEntry, DescriptorSize); 241 } 242 243 *MemoryMapSize = (UINTN)NewMemoryMapEntry - (UINTN)MemoryMap; 244 245 return ; 246 } 247 248 /** 249 Enforce memory map attributes. 250 This function will set EfiRuntimeServicesData/EfiMemoryMappedIO/EfiMemoryMappedIOPortSpace to be EFI_MEMORY_XP. 251 252 @param[in, out] MemoryMap A pointer to the buffer in which firmware places 253 the current memory map. 254 @param[in] MemoryMapSize Size, in bytes, of the MemoryMap buffer. 255 @param[in] DescriptorSize Size, in bytes, of an individual EFI_MEMORY_DESCRIPTOR. 256 **/ 257 STATIC 258 VOID 259 EnforceMemoryMapAttribute ( 260 IN OUT EFI_MEMORY_DESCRIPTOR *MemoryMap, 261 IN UINTN MemoryMapSize, 262 IN UINTN DescriptorSize 263 ) 264 { 265 EFI_MEMORY_DESCRIPTOR *MemoryMapEntry; 266 EFI_MEMORY_DESCRIPTOR *MemoryMapEnd; 267 268 MemoryMapEntry = MemoryMap; 269 MemoryMapEnd = (EFI_MEMORY_DESCRIPTOR *) ((UINT8 *) MemoryMap + MemoryMapSize); 270 while ((UINTN)MemoryMapEntry < (UINTN)MemoryMapEnd) { 271 if (MemoryMapEntry->Attribute != 0) { 272 // It is PE image, the attribute is already set. 273 } else { 274 switch (MemoryMapEntry->Type) { 275 case EfiRuntimeServicesCode: 276 MemoryMapEntry->Attribute = EFI_MEMORY_RO; 277 break; 278 case EfiRuntimeServicesData: 279 default: 280 MemoryMapEntry->Attribute |= EFI_MEMORY_XP; 281 break; 282 } 283 } 284 MemoryMapEntry = NEXT_MEMORY_DESCRIPTOR (MemoryMapEntry, DescriptorSize); 285 } 286 287 return ; 288 } 289 290 /** 291 Return the first image record, whose [ImageBase, ImageSize] covered by [Buffer, Length]. 292 293 @param[in] Buffer Start Address 294 @param[in] Length Address length 295 296 @return first image record covered by [buffer, length] 297 **/ 298 STATIC 299 IMAGE_PROPERTIES_RECORD * 300 GetImageRecordByAddress ( 301 IN EFI_PHYSICAL_ADDRESS Buffer, 302 IN UINT64 Length 303 ) 304 { 305 IMAGE_PROPERTIES_RECORD *ImageRecord; 306 LIST_ENTRY *ImageRecordLink; 307 LIST_ENTRY *ImageRecordList; 308 309 ImageRecordList = &mImagePropertiesPrivateData.ImageRecordList; 310 311 for (ImageRecordLink = ImageRecordList->ForwardLink; 312 ImageRecordLink != ImageRecordList; 313 ImageRecordLink = ImageRecordLink->ForwardLink) { 314 ImageRecord = CR ( 315 ImageRecordLink, 316 IMAGE_PROPERTIES_RECORD, 317 Link, 318 IMAGE_PROPERTIES_RECORD_SIGNATURE 319 ); 320 321 if ((Buffer <= ImageRecord->ImageBase) && 322 (Buffer + Length >= ImageRecord->ImageBase + ImageRecord->ImageSize)) { 323 return ImageRecord; 324 } 325 } 326 327 return NULL; 328 } 329 330 /** 331 Set the memory map to new entries, according to one old entry, 332 based upon PE code section and data section in image record 333 334 @param[in] ImageRecord An image record whose [ImageBase, ImageSize] covered 335 by old memory map entry. 336 @param[in, out] NewRecord A pointer to several new memory map entries. 337 The caller gurantee the buffer size be 1 + 338 (SplitRecordCount * DescriptorSize) calculated 339 below. 340 @param[in] OldRecord A pointer to one old memory map entry. 341 @param[in] DescriptorSize Size, in bytes, of an individual EFI_MEMORY_DESCRIPTOR. 342 **/ 343 STATIC 344 UINTN 345 SetNewRecord ( 346 IN IMAGE_PROPERTIES_RECORD *ImageRecord, 347 IN OUT EFI_MEMORY_DESCRIPTOR *NewRecord, 348 IN EFI_MEMORY_DESCRIPTOR *OldRecord, 349 IN UINTN DescriptorSize 350 ) 351 { 352 EFI_MEMORY_DESCRIPTOR TempRecord; 353 IMAGE_PROPERTIES_RECORD_CODE_SECTION *ImageRecordCodeSection; 354 LIST_ENTRY *ImageRecordCodeSectionLink; 355 LIST_ENTRY *ImageRecordCodeSectionEndLink; 356 LIST_ENTRY *ImageRecordCodeSectionList; 357 UINTN NewRecordCount; 358 UINT64 PhysicalEnd; 359 UINT64 ImageEnd; 360 361 CopyMem (&TempRecord, OldRecord, sizeof(EFI_MEMORY_DESCRIPTOR)); 362 PhysicalEnd = TempRecord.PhysicalStart + EfiPagesToSize(TempRecord.NumberOfPages); 363 NewRecordCount = 0; 364 365 // 366 // Always create a new entry for non-PE image record 367 // 368 if (ImageRecord->ImageBase > TempRecord.PhysicalStart) { 369 NewRecord->Type = TempRecord.Type; 370 NewRecord->PhysicalStart = TempRecord.PhysicalStart; 371 NewRecord->VirtualStart = 0; 372 NewRecord->NumberOfPages = EfiSizeToPages(ImageRecord->ImageBase - TempRecord.PhysicalStart); 373 NewRecord->Attribute = TempRecord.Attribute; 374 NewRecord = NEXT_MEMORY_DESCRIPTOR (NewRecord, DescriptorSize); 375 NewRecordCount ++; 376 TempRecord.PhysicalStart = ImageRecord->ImageBase; 377 TempRecord.NumberOfPages = EfiSizeToPages(PhysicalEnd - TempRecord.PhysicalStart); 378 } 379 380 ImageRecordCodeSectionList = &ImageRecord->CodeSegmentList; 381 382 ImageRecordCodeSectionLink = ImageRecordCodeSectionList->ForwardLink; 383 ImageRecordCodeSectionEndLink = ImageRecordCodeSectionList; 384 while (ImageRecordCodeSectionLink != ImageRecordCodeSectionEndLink) { 385 ImageRecordCodeSection = CR ( 386 ImageRecordCodeSectionLink, 387 IMAGE_PROPERTIES_RECORD_CODE_SECTION, 388 Link, 389 IMAGE_PROPERTIES_RECORD_CODE_SECTION_SIGNATURE 390 ); 391 ImageRecordCodeSectionLink = ImageRecordCodeSectionLink->ForwardLink; 392 393 if (TempRecord.PhysicalStart <= ImageRecordCodeSection->CodeSegmentBase) { 394 // 395 // DATA 396 // 397 NewRecord->Type = EfiRuntimeServicesData; 398 NewRecord->PhysicalStart = TempRecord.PhysicalStart; 399 NewRecord->VirtualStart = 0; 400 NewRecord->NumberOfPages = EfiSizeToPages(ImageRecordCodeSection->CodeSegmentBase - NewRecord->PhysicalStart); 401 NewRecord->Attribute = TempRecord.Attribute | EFI_MEMORY_XP; 402 if (NewRecord->NumberOfPages != 0) { 403 NewRecord = NEXT_MEMORY_DESCRIPTOR (NewRecord, DescriptorSize); 404 NewRecordCount ++; 405 } 406 407 // 408 // CODE 409 // 410 NewRecord->Type = EfiRuntimeServicesCode; 411 NewRecord->PhysicalStart = ImageRecordCodeSection->CodeSegmentBase; 412 NewRecord->VirtualStart = 0; 413 NewRecord->NumberOfPages = EfiSizeToPages(ImageRecordCodeSection->CodeSegmentSize); 414 NewRecord->Attribute = (TempRecord.Attribute & (~EFI_MEMORY_XP)) | EFI_MEMORY_RO; 415 if (NewRecord->NumberOfPages != 0) { 416 NewRecord = NEXT_MEMORY_DESCRIPTOR (NewRecord, DescriptorSize); 417 NewRecordCount ++; 418 } 419 420 TempRecord.PhysicalStart = ImageRecordCodeSection->CodeSegmentBase + EfiPagesToSize (EfiSizeToPages(ImageRecordCodeSection->CodeSegmentSize)); 421 TempRecord.NumberOfPages = EfiSizeToPages(PhysicalEnd - TempRecord.PhysicalStart); 422 if (TempRecord.NumberOfPages == 0) { 423 break; 424 } 425 } 426 } 427 428 ImageEnd = ImageRecord->ImageBase + ImageRecord->ImageSize; 429 430 // 431 // Final DATA 432 // 433 if (TempRecord.PhysicalStart < ImageEnd) { 434 NewRecord->Type = EfiRuntimeServicesData; 435 NewRecord->PhysicalStart = TempRecord.PhysicalStart; 436 NewRecord->VirtualStart = 0; 437 NewRecord->NumberOfPages = EfiSizeToPages (ImageEnd - TempRecord.PhysicalStart); 438 NewRecord->Attribute = TempRecord.Attribute | EFI_MEMORY_XP; 439 NewRecordCount ++; 440 } 441 442 return NewRecordCount; 443 } 444 445 /** 446 Return the max number of new splitted entries, according to one old entry, 447 based upon PE code section and data section. 448 449 @param[in] OldRecord A pointer to one old memory map entry. 450 451 @retval 0 no entry need to be splitted. 452 @return the max number of new splitted entries 453 **/ 454 STATIC 455 UINTN 456 GetMaxSplitRecordCount ( 457 IN EFI_MEMORY_DESCRIPTOR *OldRecord 458 ) 459 { 460 IMAGE_PROPERTIES_RECORD *ImageRecord; 461 UINTN SplitRecordCount; 462 UINT64 PhysicalStart; 463 UINT64 PhysicalEnd; 464 465 SplitRecordCount = 0; 466 PhysicalStart = OldRecord->PhysicalStart; 467 PhysicalEnd = OldRecord->PhysicalStart + EfiPagesToSize(OldRecord->NumberOfPages); 468 469 do { 470 ImageRecord = GetImageRecordByAddress (PhysicalStart, PhysicalEnd - PhysicalStart); 471 if (ImageRecord == NULL) { 472 break; 473 } 474 SplitRecordCount += (2 * ImageRecord->CodeSegmentCount + 2); 475 PhysicalStart = ImageRecord->ImageBase + ImageRecord->ImageSize; 476 } while ((ImageRecord != NULL) && (PhysicalStart < PhysicalEnd)); 477 478 return SplitRecordCount; 479 } 480 481 /** 482 Split the memory map to new entries, according to one old entry, 483 based upon PE code section and data section. 484 485 @param[in] OldRecord A pointer to one old memory map entry. 486 @param[in, out] NewRecord A pointer to several new memory map entries. 487 The caller gurantee the buffer size be 1 + 488 (SplitRecordCount * DescriptorSize) calculated 489 below. 490 @param[in] MaxSplitRecordCount The max number of splitted entries 491 @param[in] DescriptorSize Size, in bytes, of an individual EFI_MEMORY_DESCRIPTOR. 492 493 @retval 0 no entry is splitted. 494 @return the real number of splitted record. 495 **/ 496 STATIC 497 UINTN 498 SplitRecord ( 499 IN EFI_MEMORY_DESCRIPTOR *OldRecord, 500 IN OUT EFI_MEMORY_DESCRIPTOR *NewRecord, 501 IN UINTN MaxSplitRecordCount, 502 IN UINTN DescriptorSize 503 ) 504 { 505 EFI_MEMORY_DESCRIPTOR TempRecord; 506 IMAGE_PROPERTIES_RECORD *ImageRecord; 507 IMAGE_PROPERTIES_RECORD *NewImageRecord; 508 UINT64 PhysicalStart; 509 UINT64 PhysicalEnd; 510 UINTN NewRecordCount; 511 UINTN TotalNewRecordCount; 512 513 if (MaxSplitRecordCount == 0) { 514 CopyMem (NewRecord, OldRecord, DescriptorSize); 515 return 0; 516 } 517 518 TotalNewRecordCount = 0; 519 520 // 521 // Override previous record 522 // 523 CopyMem (&TempRecord, OldRecord, sizeof(EFI_MEMORY_DESCRIPTOR)); 524 PhysicalStart = TempRecord.PhysicalStart; 525 PhysicalEnd = TempRecord.PhysicalStart + EfiPagesToSize(TempRecord.NumberOfPages); 526 527 ImageRecord = NULL; 528 do { 529 NewImageRecord = GetImageRecordByAddress (PhysicalStart, PhysicalEnd - PhysicalStart); 530 if (NewImageRecord == NULL) { 531 // 532 // No more image covered by this range, stop 533 // 534 if (PhysicalEnd > PhysicalStart) { 535 // 536 // Always create a new entry for non-PE image record 537 // 538 NewRecord->Type = TempRecord.Type; 539 NewRecord->PhysicalStart = TempRecord.PhysicalStart; 540 NewRecord->VirtualStart = 0; 541 NewRecord->NumberOfPages = TempRecord.NumberOfPages; 542 NewRecord->Attribute = TempRecord.Attribute; 543 TotalNewRecordCount ++; 544 } 545 break; 546 } 547 ImageRecord = NewImageRecord; 548 549 // 550 // Set new record 551 // 552 NewRecordCount = SetNewRecord (ImageRecord, NewRecord, &TempRecord, DescriptorSize); 553 TotalNewRecordCount += NewRecordCount; 554 NewRecord = (EFI_MEMORY_DESCRIPTOR *)((UINT8 *)NewRecord + NewRecordCount * DescriptorSize); 555 556 // 557 // Update PhysicalStart, in order to exclude the image buffer already splitted. 558 // 559 PhysicalStart = ImageRecord->ImageBase + ImageRecord->ImageSize; 560 TempRecord.PhysicalStart = PhysicalStart; 561 TempRecord.NumberOfPages = EfiSizeToPages (PhysicalEnd - PhysicalStart); 562 } while ((ImageRecord != NULL) && (PhysicalStart < PhysicalEnd)); 563 564 return TotalNewRecordCount - 1; 565 } 566 567 /** 568 Split the original memory map, and add more entries to describe PE code section and data section. 569 This function will set EfiRuntimeServicesData to be EFI_MEMORY_XP. 570 This function will merge entries with same attributes finally. 571 572 NOTE: It assumes PE code/data section are page aligned. 573 NOTE: It assumes enough entry is prepared for new memory map. 574 575 Split table: 576 +---------------+ 577 | Record X | 578 +---------------+ 579 | Record RtCode | 580 +---------------+ 581 | Record Y | 582 +---------------+ 583 ==> 584 +---------------+ 585 | Record X | 586 +---------------+ 587 | Record RtCode | 588 +---------------+ ---- 589 | Record RtData | | 590 +---------------+ | 591 | Record RtCode | |-> PE/COFF1 592 +---------------+ | 593 | Record RtData | | 594 +---------------+ ---- 595 | Record RtCode | 596 +---------------+ ---- 597 | Record RtData | | 598 +---------------+ | 599 | Record RtCode | |-> PE/COFF2 600 +---------------+ | 601 | Record RtData | | 602 +---------------+ ---- 603 | Record RtCode | 604 +---------------+ 605 | Record Y | 606 +---------------+ 607 608 @param[in, out] MemoryMapSize A pointer to the size, in bytes, of the 609 MemoryMap buffer. On input, this is the size of 610 old MemoryMap before split. The actual buffer 611 size of MemoryMap is MemoryMapSize + 612 (AdditionalRecordCount * DescriptorSize) calculated 613 below. On output, it is the size of new MemoryMap 614 after split. 615 @param[in, out] MemoryMap A pointer to the buffer in which firmware places 616 the current memory map. 617 @param[in] DescriptorSize Size, in bytes, of an individual EFI_MEMORY_DESCRIPTOR. 618 **/ 619 STATIC 620 VOID 621 SplitTable ( 622 IN OUT UINTN *MemoryMapSize, 623 IN OUT EFI_MEMORY_DESCRIPTOR *MemoryMap, 624 IN UINTN DescriptorSize 625 ) 626 { 627 INTN IndexOld; 628 INTN IndexNew; 629 UINTN MaxSplitRecordCount; 630 UINTN RealSplitRecordCount; 631 UINTN TotalSplitRecordCount; 632 UINTN AdditionalRecordCount; 633 634 AdditionalRecordCount = (2 * mImagePropertiesPrivateData.CodeSegmentCountMax + 2) * mImagePropertiesPrivateData.ImageRecordCount; 635 636 TotalSplitRecordCount = 0; 637 // 638 // Let old record point to end of valid MemoryMap buffer. 639 // 640 IndexOld = ((*MemoryMapSize) / DescriptorSize) - 1; 641 // 642 // Let new record point to end of full MemoryMap buffer. 643 // 644 IndexNew = ((*MemoryMapSize) / DescriptorSize) - 1 + AdditionalRecordCount; 645 for (; IndexOld >= 0; IndexOld--) { 646 MaxSplitRecordCount = GetMaxSplitRecordCount ((EFI_MEMORY_DESCRIPTOR *)((UINT8 *)MemoryMap + IndexOld * DescriptorSize)); 647 // 648 // Split this MemoryMap record 649 // 650 IndexNew -= MaxSplitRecordCount; 651 RealSplitRecordCount = SplitRecord ( 652 (EFI_MEMORY_DESCRIPTOR *)((UINT8 *)MemoryMap + IndexOld * DescriptorSize), 653 (EFI_MEMORY_DESCRIPTOR *)((UINT8 *)MemoryMap + IndexNew * DescriptorSize), 654 MaxSplitRecordCount, 655 DescriptorSize 656 ); 657 // 658 // Adjust IndexNew according to real split. 659 // 660 if (MaxSplitRecordCount != RealSplitRecordCount) { 661 CopyMem ( 662 ((UINT8 *)MemoryMap + (IndexNew + MaxSplitRecordCount - RealSplitRecordCount) * DescriptorSize), 663 ((UINT8 *)MemoryMap + IndexNew * DescriptorSize), 664 (RealSplitRecordCount + 1) * DescriptorSize 665 ); 666 } 667 IndexNew = IndexNew + MaxSplitRecordCount - RealSplitRecordCount; 668 TotalSplitRecordCount += RealSplitRecordCount; 669 IndexNew --; 670 } 671 // 672 // Move all records to the beginning. 673 // 674 CopyMem ( 675 MemoryMap, 676 (UINT8 *)MemoryMap + (AdditionalRecordCount - TotalSplitRecordCount) * DescriptorSize, 677 (*MemoryMapSize) + TotalSplitRecordCount * DescriptorSize 678 ); 679 680 *MemoryMapSize = (*MemoryMapSize) + DescriptorSize * TotalSplitRecordCount; 681 682 // 683 // Sort from low to high (Just in case) 684 // 685 SortMemoryMap (MemoryMap, *MemoryMapSize, DescriptorSize); 686 687 // 688 // Set RuntimeData to XP 689 // 690 EnforceMemoryMapAttribute (MemoryMap, *MemoryMapSize, DescriptorSize); 691 692 // 693 // Merge same type to save entry size 694 // 695 MergeMemoryMap (MemoryMap, MemoryMapSize, DescriptorSize); 696 697 return ; 698 } 699 700 /** 701 This function for GetMemoryMap() with memory attributes table. 702 703 It calls original GetMemoryMap() to get the original memory map information. Then 704 plus the additional memory map entries for PE Code/Data seperation. 705 706 @param[in, out] MemoryMapSize A pointer to the size, in bytes, of the 707 MemoryMap buffer. On input, this is the size of 708 the buffer allocated by the caller. On output, 709 it is the size of the buffer returned by the 710 firmware if the buffer was large enough, or the 711 size of the buffer needed to contain the map if 712 the buffer was too small. 713 @param[in, out] MemoryMap A pointer to the buffer in which firmware places 714 the current memory map. 715 @param[out] MapKey A pointer to the location in which firmware 716 returns the key for the current memory map. 717 @param[out] DescriptorSize A pointer to the location in which firmware 718 returns the size, in bytes, of an individual 719 EFI_MEMORY_DESCRIPTOR. 720 @param[out] DescriptorVersion A pointer to the location in which firmware 721 returns the version number associated with the 722 EFI_MEMORY_DESCRIPTOR. 723 724 @retval EFI_SUCCESS The memory map was returned in the MemoryMap 725 buffer. 726 @retval EFI_BUFFER_TOO_SMALL The MemoryMap buffer was too small. The current 727 buffer size needed to hold the memory map is 728 returned in MemoryMapSize. 729 @retval EFI_INVALID_PARAMETER One of the parameters has an invalid value. 730 731 **/ 732 STATIC 733 EFI_STATUS 734 EFIAPI 735 SmmCoreGetMemoryMapMemoryAttributesTable ( 736 IN OUT UINTN *MemoryMapSize, 737 IN OUT EFI_MEMORY_DESCRIPTOR *MemoryMap, 738 OUT UINTN *MapKey, 739 OUT UINTN *DescriptorSize, 740 OUT UINT32 *DescriptorVersion 741 ) 742 { 743 EFI_STATUS Status; 744 UINTN OldMemoryMapSize; 745 UINTN AdditionalRecordCount; 746 747 // 748 // If PE code/data is not aligned, just return. 749 // 750 if ((mMemoryProtectionAttribute & EFI_MEMORY_ATTRIBUTES_RUNTIME_MEMORY_PROTECTION_NON_EXECUTABLE_PE_DATA) == 0) { 751 return SmmCoreGetMemoryMap (MemoryMapSize, MemoryMap, MapKey, DescriptorSize, DescriptorVersion); 752 } 753 754 if (MemoryMapSize == NULL) { 755 return EFI_INVALID_PARAMETER; 756 } 757 758 AdditionalRecordCount = (2 * mImagePropertiesPrivateData.CodeSegmentCountMax + 2) * mImagePropertiesPrivateData.ImageRecordCount; 759 760 OldMemoryMapSize = *MemoryMapSize; 761 Status = SmmCoreGetMemoryMap (MemoryMapSize, MemoryMap, MapKey, DescriptorSize, DescriptorVersion); 762 if (Status == EFI_BUFFER_TOO_SMALL) { 763 *MemoryMapSize = *MemoryMapSize + (*DescriptorSize) * AdditionalRecordCount; 764 } else if (Status == EFI_SUCCESS) { 765 if (OldMemoryMapSize - *MemoryMapSize < (*DescriptorSize) * AdditionalRecordCount) { 766 *MemoryMapSize = *MemoryMapSize + (*DescriptorSize) * AdditionalRecordCount; 767 // 768 // Need update status to buffer too small 769 // 770 Status = EFI_BUFFER_TOO_SMALL; 771 } else { 772 // 773 // Split PE code/data 774 // 775 ASSERT(MemoryMap != NULL); 776 SplitTable (MemoryMapSize, MemoryMap, *DescriptorSize); 777 } 778 } 779 780 return Status; 781 } 782 783 // 784 // Below functions are for ImageRecord 785 // 786 787 /** 788 Set MemoryProtectionAttribute accroding to PE/COFF image section alignment. 789 790 @param[in] SectionAlignment PE/COFF section alignment 791 **/ 792 STATIC 793 VOID 794 SetMemoryAttributesTableSectionAlignment ( 795 IN UINT32 SectionAlignment 796 ) 797 { 798 if (((SectionAlignment & (EFI_ACPI_RUNTIME_PAGE_ALLOCATION_ALIGNMENT - 1)) != 0) && 799 ((mMemoryProtectionAttribute & EFI_MEMORY_ATTRIBUTES_RUNTIME_MEMORY_PROTECTION_NON_EXECUTABLE_PE_DATA) != 0)) { 800 DEBUG ((DEBUG_VERBOSE, "SMM SetMemoryAttributesTableSectionAlignment - Clear\n")); 801 mMemoryProtectionAttribute &= ~((UINT64)EFI_MEMORY_ATTRIBUTES_RUNTIME_MEMORY_PROTECTION_NON_EXECUTABLE_PE_DATA); 802 } 803 } 804 805 /** 806 Swap two code sections in image record. 807 808 @param[in] FirstImageRecordCodeSection first code section in image record 809 @param[in] SecondImageRecordCodeSection second code section in image record 810 **/ 811 STATIC 812 VOID 813 SwapImageRecordCodeSection ( 814 IN IMAGE_PROPERTIES_RECORD_CODE_SECTION *FirstImageRecordCodeSection, 815 IN IMAGE_PROPERTIES_RECORD_CODE_SECTION *SecondImageRecordCodeSection 816 ) 817 { 818 IMAGE_PROPERTIES_RECORD_CODE_SECTION TempImageRecordCodeSection; 819 820 TempImageRecordCodeSection.CodeSegmentBase = FirstImageRecordCodeSection->CodeSegmentBase; 821 TempImageRecordCodeSection.CodeSegmentSize = FirstImageRecordCodeSection->CodeSegmentSize; 822 823 FirstImageRecordCodeSection->CodeSegmentBase = SecondImageRecordCodeSection->CodeSegmentBase; 824 FirstImageRecordCodeSection->CodeSegmentSize = SecondImageRecordCodeSection->CodeSegmentSize; 825 826 SecondImageRecordCodeSection->CodeSegmentBase = TempImageRecordCodeSection.CodeSegmentBase; 827 SecondImageRecordCodeSection->CodeSegmentSize = TempImageRecordCodeSection.CodeSegmentSize; 828 } 829 830 /** 831 Sort code section in image record, based upon CodeSegmentBase from low to high. 832 833 @param[in] ImageRecord image record to be sorted 834 **/ 835 STATIC 836 VOID 837 SortImageRecordCodeSection ( 838 IN IMAGE_PROPERTIES_RECORD *ImageRecord 839 ) 840 { 841 IMAGE_PROPERTIES_RECORD_CODE_SECTION *ImageRecordCodeSection; 842 IMAGE_PROPERTIES_RECORD_CODE_SECTION *NextImageRecordCodeSection; 843 LIST_ENTRY *ImageRecordCodeSectionLink; 844 LIST_ENTRY *NextImageRecordCodeSectionLink; 845 LIST_ENTRY *ImageRecordCodeSectionEndLink; 846 LIST_ENTRY *ImageRecordCodeSectionList; 847 848 ImageRecordCodeSectionList = &ImageRecord->CodeSegmentList; 849 850 ImageRecordCodeSectionLink = ImageRecordCodeSectionList->ForwardLink; 851 NextImageRecordCodeSectionLink = ImageRecordCodeSectionLink->ForwardLink; 852 ImageRecordCodeSectionEndLink = ImageRecordCodeSectionList; 853 while (ImageRecordCodeSectionLink != ImageRecordCodeSectionEndLink) { 854 ImageRecordCodeSection = CR ( 855 ImageRecordCodeSectionLink, 856 IMAGE_PROPERTIES_RECORD_CODE_SECTION, 857 Link, 858 IMAGE_PROPERTIES_RECORD_CODE_SECTION_SIGNATURE 859 ); 860 while (NextImageRecordCodeSectionLink != ImageRecordCodeSectionEndLink) { 861 NextImageRecordCodeSection = CR ( 862 NextImageRecordCodeSectionLink, 863 IMAGE_PROPERTIES_RECORD_CODE_SECTION, 864 Link, 865 IMAGE_PROPERTIES_RECORD_CODE_SECTION_SIGNATURE 866 ); 867 if (ImageRecordCodeSection->CodeSegmentBase > NextImageRecordCodeSection->CodeSegmentBase) { 868 SwapImageRecordCodeSection (ImageRecordCodeSection, NextImageRecordCodeSection); 869 } 870 NextImageRecordCodeSectionLink = NextImageRecordCodeSectionLink->ForwardLink; 871 } 872 873 ImageRecordCodeSectionLink = ImageRecordCodeSectionLink->ForwardLink; 874 NextImageRecordCodeSectionLink = ImageRecordCodeSectionLink->ForwardLink; 875 } 876 } 877 878 /** 879 Check if code section in image record is valid. 880 881 @param[in] ImageRecord image record to be checked 882 883 @retval TRUE image record is valid 884 @retval FALSE image record is invalid 885 **/ 886 STATIC 887 BOOLEAN 888 IsImageRecordCodeSectionValid ( 889 IN IMAGE_PROPERTIES_RECORD *ImageRecord 890 ) 891 { 892 IMAGE_PROPERTIES_RECORD_CODE_SECTION *ImageRecordCodeSection; 893 IMAGE_PROPERTIES_RECORD_CODE_SECTION *LastImageRecordCodeSection; 894 LIST_ENTRY *ImageRecordCodeSectionLink; 895 LIST_ENTRY *ImageRecordCodeSectionEndLink; 896 LIST_ENTRY *ImageRecordCodeSectionList; 897 898 DEBUG ((DEBUG_VERBOSE, "SMM ImageCode SegmentCount - 0x%x\n", ImageRecord->CodeSegmentCount)); 899 900 ImageRecordCodeSectionList = &ImageRecord->CodeSegmentList; 901 902 ImageRecordCodeSectionLink = ImageRecordCodeSectionList->ForwardLink; 903 ImageRecordCodeSectionEndLink = ImageRecordCodeSectionList; 904 LastImageRecordCodeSection = NULL; 905 while (ImageRecordCodeSectionLink != ImageRecordCodeSectionEndLink) { 906 ImageRecordCodeSection = CR ( 907 ImageRecordCodeSectionLink, 908 IMAGE_PROPERTIES_RECORD_CODE_SECTION, 909 Link, 910 IMAGE_PROPERTIES_RECORD_CODE_SECTION_SIGNATURE 911 ); 912 if (ImageRecordCodeSection->CodeSegmentSize == 0) { 913 return FALSE; 914 } 915 if (ImageRecordCodeSection->CodeSegmentBase < ImageRecord->ImageBase) { 916 return FALSE; 917 } 918 if (ImageRecordCodeSection->CodeSegmentBase >= MAX_ADDRESS - ImageRecordCodeSection->CodeSegmentSize) { 919 return FALSE; 920 } 921 if ((ImageRecordCodeSection->CodeSegmentBase + ImageRecordCodeSection->CodeSegmentSize) > (ImageRecord->ImageBase + ImageRecord->ImageSize)) { 922 return FALSE; 923 } 924 if (LastImageRecordCodeSection != NULL) { 925 if ((LastImageRecordCodeSection->CodeSegmentBase + LastImageRecordCodeSection->CodeSegmentSize) > ImageRecordCodeSection->CodeSegmentBase) { 926 return FALSE; 927 } 928 } 929 930 LastImageRecordCodeSection = ImageRecordCodeSection; 931 ImageRecordCodeSectionLink = ImageRecordCodeSectionLink->ForwardLink; 932 } 933 934 return TRUE; 935 } 936 937 /** 938 Swap two image records. 939 940 @param[in] FirstImageRecord first image record. 941 @param[in] SecondImageRecord second image record. 942 **/ 943 STATIC 944 VOID 945 SwapImageRecord ( 946 IN IMAGE_PROPERTIES_RECORD *FirstImageRecord, 947 IN IMAGE_PROPERTIES_RECORD *SecondImageRecord 948 ) 949 { 950 IMAGE_PROPERTIES_RECORD TempImageRecord; 951 952 TempImageRecord.ImageBase = FirstImageRecord->ImageBase; 953 TempImageRecord.ImageSize = FirstImageRecord->ImageSize; 954 TempImageRecord.CodeSegmentCount = FirstImageRecord->CodeSegmentCount; 955 956 FirstImageRecord->ImageBase = SecondImageRecord->ImageBase; 957 FirstImageRecord->ImageSize = SecondImageRecord->ImageSize; 958 FirstImageRecord->CodeSegmentCount = SecondImageRecord->CodeSegmentCount; 959 960 SecondImageRecord->ImageBase = TempImageRecord.ImageBase; 961 SecondImageRecord->ImageSize = TempImageRecord.ImageSize; 962 SecondImageRecord->CodeSegmentCount = TempImageRecord.CodeSegmentCount; 963 964 SwapListEntries (&FirstImageRecord->CodeSegmentList, &SecondImageRecord->CodeSegmentList); 965 } 966 967 /** 968 Sort image record based upon the ImageBase from low to high. 969 **/ 970 STATIC 971 VOID 972 SortImageRecord ( 973 VOID 974 ) 975 { 976 IMAGE_PROPERTIES_RECORD *ImageRecord; 977 IMAGE_PROPERTIES_RECORD *NextImageRecord; 978 LIST_ENTRY *ImageRecordLink; 979 LIST_ENTRY *NextImageRecordLink; 980 LIST_ENTRY *ImageRecordEndLink; 981 LIST_ENTRY *ImageRecordList; 982 983 ImageRecordList = &mImagePropertiesPrivateData.ImageRecordList; 984 985 ImageRecordLink = ImageRecordList->ForwardLink; 986 NextImageRecordLink = ImageRecordLink->ForwardLink; 987 ImageRecordEndLink = ImageRecordList; 988 while (ImageRecordLink != ImageRecordEndLink) { 989 ImageRecord = CR ( 990 ImageRecordLink, 991 IMAGE_PROPERTIES_RECORD, 992 Link, 993 IMAGE_PROPERTIES_RECORD_SIGNATURE 994 ); 995 while (NextImageRecordLink != ImageRecordEndLink) { 996 NextImageRecord = CR ( 997 NextImageRecordLink, 998 IMAGE_PROPERTIES_RECORD, 999 Link, 1000 IMAGE_PROPERTIES_RECORD_SIGNATURE 1001 ); 1002 if (ImageRecord->ImageBase > NextImageRecord->ImageBase) { 1003 SwapImageRecord (ImageRecord, NextImageRecord); 1004 } 1005 NextImageRecordLink = NextImageRecordLink->ForwardLink; 1006 } 1007 1008 ImageRecordLink = ImageRecordLink->ForwardLink; 1009 NextImageRecordLink = ImageRecordLink->ForwardLink; 1010 } 1011 } 1012 1013 /** 1014 Dump image record. 1015 **/ 1016 STATIC 1017 VOID 1018 DumpImageRecord ( 1019 VOID 1020 ) 1021 { 1022 IMAGE_PROPERTIES_RECORD *ImageRecord; 1023 LIST_ENTRY *ImageRecordLink; 1024 LIST_ENTRY *ImageRecordList; 1025 UINTN Index; 1026 1027 ImageRecordList = &mImagePropertiesPrivateData.ImageRecordList; 1028 1029 for (ImageRecordLink = ImageRecordList->ForwardLink, Index= 0; 1030 ImageRecordLink != ImageRecordList; 1031 ImageRecordLink = ImageRecordLink->ForwardLink, Index++) { 1032 ImageRecord = CR ( 1033 ImageRecordLink, 1034 IMAGE_PROPERTIES_RECORD, 1035 Link, 1036 IMAGE_PROPERTIES_RECORD_SIGNATURE 1037 ); 1038 DEBUG ((DEBUG_VERBOSE, "SMM Image[%d]: 0x%016lx - 0x%016lx\n", Index, ImageRecord->ImageBase, ImageRecord->ImageSize)); 1039 } 1040 } 1041 1042 /** 1043 Insert image record. 1044 1045 @param[in] DriverEntry Driver information 1046 **/ 1047 VOID 1048 SmmInsertImageRecord ( 1049 IN EFI_SMM_DRIVER_ENTRY *DriverEntry 1050 ) 1051 { 1052 VOID *ImageAddress; 1053 EFI_IMAGE_DOS_HEADER *DosHdr; 1054 UINT32 PeCoffHeaderOffset; 1055 UINT32 SectionAlignment; 1056 EFI_IMAGE_SECTION_HEADER *Section; 1057 EFI_IMAGE_OPTIONAL_HEADER_PTR_UNION Hdr; 1058 UINT8 *Name; 1059 UINTN Index; 1060 IMAGE_PROPERTIES_RECORD *ImageRecord; 1061 CHAR8 *PdbPointer; 1062 IMAGE_PROPERTIES_RECORD_CODE_SECTION *ImageRecordCodeSection; 1063 UINT16 Magic; 1064 1065 DEBUG ((DEBUG_VERBOSE, "SMM InsertImageRecord - 0x%x\n", DriverEntry)); 1066 DEBUG ((DEBUG_VERBOSE, "SMM InsertImageRecord - 0x%016lx - 0x%08x\n", DriverEntry->ImageBuffer, DriverEntry->NumberOfPage)); 1067 1068 ImageRecord = AllocatePool (sizeof(*ImageRecord)); 1069 if (ImageRecord == NULL) { 1070 return ; 1071 } 1072 ImageRecord->Signature = IMAGE_PROPERTIES_RECORD_SIGNATURE; 1073 1074 DEBUG ((DEBUG_VERBOSE, "SMM ImageRecordCount - 0x%x\n", mImagePropertiesPrivateData.ImageRecordCount)); 1075 1076 // 1077 // Step 1: record whole region 1078 // 1079 ImageRecord->ImageBase = DriverEntry->ImageBuffer; 1080 ImageRecord->ImageSize = EfiPagesToSize(DriverEntry->NumberOfPage); 1081 1082 ImageAddress = (VOID *)(UINTN)DriverEntry->ImageBuffer; 1083 1084 PdbPointer = PeCoffLoaderGetPdbPointer ((VOID*) (UINTN) ImageAddress); 1085 if (PdbPointer != NULL) { 1086 DEBUG ((DEBUG_VERBOSE, "SMM Image - %a\n", PdbPointer)); 1087 } 1088 1089 // 1090 // Check PE/COFF image 1091 // 1092 DosHdr = (EFI_IMAGE_DOS_HEADER *) (UINTN) ImageAddress; 1093 PeCoffHeaderOffset = 0; 1094 if (DosHdr->e_magic == EFI_IMAGE_DOS_SIGNATURE) { 1095 PeCoffHeaderOffset = DosHdr->e_lfanew; 1096 } 1097 1098 Hdr.Pe32 = (EFI_IMAGE_NT_HEADERS32 *)((UINT8 *) (UINTN) ImageAddress + PeCoffHeaderOffset); 1099 if (Hdr.Pe32->Signature != EFI_IMAGE_NT_SIGNATURE) { 1100 DEBUG ((DEBUG_VERBOSE, "SMM Hdr.Pe32->Signature invalid - 0x%x\n", Hdr.Pe32->Signature)); 1101 goto Finish; 1102 } 1103 1104 // 1105 // Get SectionAlignment 1106 // 1107 if (Hdr.Pe32->FileHeader.Machine == IMAGE_FILE_MACHINE_IA64 && Hdr.Pe32->OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) { 1108 // 1109 // NOTE: Some versions of Linux ELILO for Itanium have an incorrect magic value 1110 // in the PE/COFF Header. If the MachineType is Itanium(IA64) and the 1111 // Magic value in the OptionalHeader is EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC 1112 // then override the magic value to EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC 1113 // 1114 Magic = EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC; 1115 } else { 1116 // 1117 // Get the magic value from the PE/COFF Optional Header 1118 // 1119 Magic = Hdr.Pe32->OptionalHeader.Magic; 1120 } 1121 if (Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) { 1122 SectionAlignment = Hdr.Pe32->OptionalHeader.SectionAlignment; 1123 } else { 1124 SectionAlignment = Hdr.Pe32Plus->OptionalHeader.SectionAlignment; 1125 } 1126 1127 SetMemoryAttributesTableSectionAlignment (SectionAlignment); 1128 if ((SectionAlignment & (EFI_ACPI_RUNTIME_PAGE_ALLOCATION_ALIGNMENT - 1)) != 0) { 1129 DEBUG ((DEBUG_WARN, "SMM !!!!!!!! InsertImageRecord - Section Alignment(0x%x) is not %dK !!!!!!!!\n", 1130 SectionAlignment, EFI_ACPI_RUNTIME_PAGE_ALLOCATION_ALIGNMENT >> 10)); 1131 PdbPointer = PeCoffLoaderGetPdbPointer ((VOID*) (UINTN) ImageAddress); 1132 if (PdbPointer != NULL) { 1133 DEBUG ((DEBUG_WARN, "SMM !!!!!!!! Image - %a !!!!!!!!\n", PdbPointer)); 1134 } 1135 goto Finish; 1136 } 1137 1138 Section = (EFI_IMAGE_SECTION_HEADER *) ( 1139 (UINT8 *) (UINTN) ImageAddress + 1140 PeCoffHeaderOffset + 1141 sizeof(UINT32) + 1142 sizeof(EFI_IMAGE_FILE_HEADER) + 1143 Hdr.Pe32->FileHeader.SizeOfOptionalHeader 1144 ); 1145 ImageRecord->CodeSegmentCount = 0; 1146 InitializeListHead (&ImageRecord->CodeSegmentList); 1147 for (Index = 0; Index < Hdr.Pe32->FileHeader.NumberOfSections; Index++) { 1148 Name = Section[Index].Name; 1149 DEBUG (( 1150 DEBUG_VERBOSE, 1151 "SMM Section - '%c%c%c%c%c%c%c%c'\n", 1152 Name[0], 1153 Name[1], 1154 Name[2], 1155 Name[3], 1156 Name[4], 1157 Name[5], 1158 Name[6], 1159 Name[7] 1160 )); 1161 1162 if ((Section[Index].Characteristics & EFI_IMAGE_SCN_CNT_CODE) != 0) { 1163 DEBUG ((DEBUG_VERBOSE, "SMM VirtualSize - 0x%08x\n", Section[Index].Misc.VirtualSize)); 1164 DEBUG ((DEBUG_VERBOSE, "SMM VirtualAddress - 0x%08x\n", Section[Index].VirtualAddress)); 1165 DEBUG ((DEBUG_VERBOSE, "SMM SizeOfRawData - 0x%08x\n", Section[Index].SizeOfRawData)); 1166 DEBUG ((DEBUG_VERBOSE, "SMM PointerToRawData - 0x%08x\n", Section[Index].PointerToRawData)); 1167 DEBUG ((DEBUG_VERBOSE, "SMM PointerToRelocations - 0x%08x\n", Section[Index].PointerToRelocations)); 1168 DEBUG ((DEBUG_VERBOSE, "SMM PointerToLinenumbers - 0x%08x\n", Section[Index].PointerToLinenumbers)); 1169 DEBUG ((DEBUG_VERBOSE, "SMM NumberOfRelocations - 0x%08x\n", Section[Index].NumberOfRelocations)); 1170 DEBUG ((DEBUG_VERBOSE, "SMM NumberOfLinenumbers - 0x%08x\n", Section[Index].NumberOfLinenumbers)); 1171 DEBUG ((DEBUG_VERBOSE, "SMM Characteristics - 0x%08x\n", Section[Index].Characteristics)); 1172 1173 // 1174 // Step 2: record code section 1175 // 1176 ImageRecordCodeSection = AllocatePool (sizeof(*ImageRecordCodeSection)); 1177 if (ImageRecordCodeSection == NULL) { 1178 return ; 1179 } 1180 ImageRecordCodeSection->Signature = IMAGE_PROPERTIES_RECORD_CODE_SECTION_SIGNATURE; 1181 1182 ImageRecordCodeSection->CodeSegmentBase = (UINTN)ImageAddress + Section[Index].VirtualAddress; 1183 ImageRecordCodeSection->CodeSegmentSize = Section[Index].SizeOfRawData; 1184 1185 DEBUG ((DEBUG_VERBOSE, "SMM ImageCode: 0x%016lx - 0x%016lx\n", ImageRecordCodeSection->CodeSegmentBase, ImageRecordCodeSection->CodeSegmentSize)); 1186 1187 InsertTailList (&ImageRecord->CodeSegmentList, &ImageRecordCodeSection->Link); 1188 ImageRecord->CodeSegmentCount++; 1189 } 1190 } 1191 1192 if (ImageRecord->CodeSegmentCount == 0) { 1193 SetMemoryAttributesTableSectionAlignment (1); 1194 DEBUG ((DEBUG_ERROR, "SMM !!!!!!!! InsertImageRecord - CodeSegmentCount is 0 !!!!!!!!\n")); 1195 PdbPointer = PeCoffLoaderGetPdbPointer ((VOID*) (UINTN) ImageAddress); 1196 if (PdbPointer != NULL) { 1197 DEBUG ((DEBUG_ERROR, "SMM !!!!!!!! Image - %a !!!!!!!!\n", PdbPointer)); 1198 } 1199 goto Finish; 1200 } 1201 1202 // 1203 // Final 1204 // 1205 SortImageRecordCodeSection (ImageRecord); 1206 // 1207 // Check overlap all section in ImageBase/Size 1208 // 1209 if (!IsImageRecordCodeSectionValid (ImageRecord)) { 1210 DEBUG ((DEBUG_ERROR, "SMM IsImageRecordCodeSectionValid - FAIL\n")); 1211 goto Finish; 1212 } 1213 1214 InsertTailList (&mImagePropertiesPrivateData.ImageRecordList, &ImageRecord->Link); 1215 mImagePropertiesPrivateData.ImageRecordCount++; 1216 1217 SortImageRecord (); 1218 1219 if (mImagePropertiesPrivateData.CodeSegmentCountMax < ImageRecord->CodeSegmentCount) { 1220 mImagePropertiesPrivateData.CodeSegmentCountMax = ImageRecord->CodeSegmentCount; 1221 } 1222 1223 Finish: 1224 return ; 1225 } 1226 1227 /** 1228 Find image record accroding to image base and size. 1229 1230 @param[in] ImageBase Base of PE image 1231 @param[in] ImageSize Size of PE image 1232 1233 @return image record 1234 **/ 1235 STATIC 1236 IMAGE_PROPERTIES_RECORD * 1237 FindImageRecord ( 1238 IN EFI_PHYSICAL_ADDRESS ImageBase, 1239 IN UINT64 ImageSize 1240 ) 1241 { 1242 IMAGE_PROPERTIES_RECORD *ImageRecord; 1243 LIST_ENTRY *ImageRecordLink; 1244 LIST_ENTRY *ImageRecordList; 1245 1246 ImageRecordList = &mImagePropertiesPrivateData.ImageRecordList; 1247 1248 for (ImageRecordLink = ImageRecordList->ForwardLink; 1249 ImageRecordLink != ImageRecordList; 1250 ImageRecordLink = ImageRecordLink->ForwardLink) { 1251 ImageRecord = CR ( 1252 ImageRecordLink, 1253 IMAGE_PROPERTIES_RECORD, 1254 Link, 1255 IMAGE_PROPERTIES_RECORD_SIGNATURE 1256 ); 1257 1258 if ((ImageBase == ImageRecord->ImageBase) && 1259 (ImageSize == ImageRecord->ImageSize)) { 1260 return ImageRecord; 1261 } 1262 } 1263 1264 return NULL; 1265 } 1266 1267 /** 1268 Remove Image record. 1269 1270 @param[in] DriverEntry Driver information 1271 **/ 1272 VOID 1273 SmmRemoveImageRecord ( 1274 IN EFI_SMM_DRIVER_ENTRY *DriverEntry 1275 ) 1276 { 1277 IMAGE_PROPERTIES_RECORD *ImageRecord; 1278 LIST_ENTRY *CodeSegmentListHead; 1279 IMAGE_PROPERTIES_RECORD_CODE_SECTION *ImageRecordCodeSection; 1280 1281 DEBUG ((DEBUG_VERBOSE, "SMM RemoveImageRecord - 0x%x\n", DriverEntry)); 1282 DEBUG ((DEBUG_VERBOSE, "SMM RemoveImageRecord - 0x%016lx - 0x%016lx\n", DriverEntry->ImageBuffer, DriverEntry->NumberOfPage)); 1283 1284 ImageRecord = FindImageRecord (DriverEntry->ImageBuffer, EfiPagesToSize(DriverEntry->NumberOfPage)); 1285 if (ImageRecord == NULL) { 1286 DEBUG ((DEBUG_ERROR, "SMM !!!!!!!! ImageRecord not found !!!!!!!!\n")); 1287 return ; 1288 } 1289 1290 CodeSegmentListHead = &ImageRecord->CodeSegmentList; 1291 while (!IsListEmpty (CodeSegmentListHead)) { 1292 ImageRecordCodeSection = CR ( 1293 CodeSegmentListHead->ForwardLink, 1294 IMAGE_PROPERTIES_RECORD_CODE_SECTION, 1295 Link, 1296 IMAGE_PROPERTIES_RECORD_CODE_SECTION_SIGNATURE 1297 ); 1298 RemoveEntryList (&ImageRecordCodeSection->Link); 1299 FreePool (ImageRecordCodeSection); 1300 } 1301 1302 RemoveEntryList (&ImageRecord->Link); 1303 FreePool (ImageRecord); 1304 mImagePropertiesPrivateData.ImageRecordCount--; 1305 } 1306 1307 /** 1308 Publish MemoryAttributesTable to SMM configuration table. 1309 **/ 1310 VOID 1311 PublishMemoryAttributesTable ( 1312 VOID 1313 ) 1314 { 1315 UINTN MemoryMapSize; 1316 EFI_MEMORY_DESCRIPTOR *MemoryMap; 1317 UINTN MapKey; 1318 UINTN DescriptorSize; 1319 UINT32 DescriptorVersion; 1320 UINTN Index; 1321 EFI_STATUS Status; 1322 UINTN RuntimeEntryCount; 1323 EDKII_PI_SMM_MEMORY_ATTRIBUTES_TABLE *MemoryAttributesTable; 1324 EFI_MEMORY_DESCRIPTOR *MemoryAttributesEntry; 1325 UINTN MemoryAttributesTableSize; 1326 1327 MemoryMapSize = 0; 1328 MemoryMap = NULL; 1329 Status = SmmCoreGetMemoryMapMemoryAttributesTable ( 1330 &MemoryMapSize, 1331 MemoryMap, 1332 &MapKey, 1333 &DescriptorSize, 1334 &DescriptorVersion 1335 ); 1336 ASSERT (Status == EFI_BUFFER_TOO_SMALL); 1337 1338 do { 1339 DEBUG ((DEBUG_INFO, "MemoryMapSize - 0x%x\n", MemoryMapSize)); 1340 MemoryMap = AllocatePool (MemoryMapSize); 1341 ASSERT (MemoryMap != NULL); 1342 DEBUG ((DEBUG_INFO, "MemoryMap - 0x%x\n", MemoryMap)); 1343 1344 Status = SmmCoreGetMemoryMapMemoryAttributesTable ( 1345 &MemoryMapSize, 1346 MemoryMap, 1347 &MapKey, 1348 &DescriptorSize, 1349 &DescriptorVersion 1350 ); 1351 if (EFI_ERROR (Status)) { 1352 FreePool (MemoryMap); 1353 } 1354 } while (Status == EFI_BUFFER_TOO_SMALL); 1355 1356 // 1357 // Allocate MemoryAttributesTable 1358 // 1359 RuntimeEntryCount = MemoryMapSize/DescriptorSize; 1360 MemoryAttributesTableSize = sizeof(EDKII_PI_SMM_MEMORY_ATTRIBUTES_TABLE) + DescriptorSize * RuntimeEntryCount; 1361 MemoryAttributesTable = AllocatePool (sizeof(EDKII_PI_SMM_MEMORY_ATTRIBUTES_TABLE) + DescriptorSize * RuntimeEntryCount); 1362 ASSERT (MemoryAttributesTable != NULL); 1363 MemoryAttributesTable->Version = EDKII_PI_SMM_MEMORY_ATTRIBUTES_TABLE_VERSION; 1364 MemoryAttributesTable->NumberOfEntries = (UINT32)RuntimeEntryCount; 1365 MemoryAttributesTable->DescriptorSize = (UINT32)DescriptorSize; 1366 MemoryAttributesTable->Reserved = 0; 1367 DEBUG ((DEBUG_INFO, "MemoryAttributesTable:\n")); 1368 DEBUG ((DEBUG_INFO, " Version - 0x%08x\n", MemoryAttributesTable->Version)); 1369 DEBUG ((DEBUG_INFO, " NumberOfEntries - 0x%08x\n", MemoryAttributesTable->NumberOfEntries)); 1370 DEBUG ((DEBUG_INFO, " DescriptorSize - 0x%08x\n", MemoryAttributesTable->DescriptorSize)); 1371 MemoryAttributesEntry = (EFI_MEMORY_DESCRIPTOR *)(MemoryAttributesTable + 1); 1372 for (Index = 0; Index < MemoryMapSize/DescriptorSize; Index++) { 1373 CopyMem (MemoryAttributesEntry, MemoryMap, DescriptorSize); 1374 DEBUG ((DEBUG_INFO, "Entry (0x%x)\n", MemoryAttributesEntry)); 1375 DEBUG ((DEBUG_INFO, " Type - 0x%x\n", MemoryAttributesEntry->Type)); 1376 DEBUG ((DEBUG_INFO, " PhysicalStart - 0x%016lx\n", MemoryAttributesEntry->PhysicalStart)); 1377 DEBUG ((DEBUG_INFO, " VirtualStart - 0x%016lx\n", MemoryAttributesEntry->VirtualStart)); 1378 DEBUG ((DEBUG_INFO, " NumberOfPages - 0x%016lx\n", MemoryAttributesEntry->NumberOfPages)); 1379 DEBUG ((DEBUG_INFO, " Attribute - 0x%016lx\n", MemoryAttributesEntry->Attribute)); 1380 MemoryAttributesEntry = NEXT_MEMORY_DESCRIPTOR(MemoryAttributesEntry, DescriptorSize); 1381 1382 MemoryMap = NEXT_MEMORY_DESCRIPTOR(MemoryMap, DescriptorSize); 1383 } 1384 1385 Status = gSmst->SmmInstallConfigurationTable (gSmst, &gEdkiiPiSmmMemoryAttributesTableGuid, MemoryAttributesTable, MemoryAttributesTableSize); 1386 ASSERT_EFI_ERROR (Status); 1387 } 1388 1389 /** 1390 This function returns if image is inside SMRAM. 1391 1392 @param[in] LoadedImage LoadedImage protocol instance for an image. 1393 1394 @retval TRUE the image is inside SMRAM. 1395 @retval FALSE the image is outside SMRAM. 1396 **/ 1397 BOOLEAN 1398 IsImageInsideSmram ( 1399 IN EFI_LOADED_IMAGE_PROTOCOL *LoadedImage 1400 ) 1401 { 1402 UINTN Index; 1403 1404 for (Index = 0; Index < mFullSmramRangeCount; Index++) { 1405 if ((mFullSmramRanges[Index].PhysicalStart <= (UINTN)LoadedImage->ImageBase)&& 1406 (mFullSmramRanges[Index].PhysicalStart + mFullSmramRanges[Index].PhysicalSize >= (UINTN)LoadedImage->ImageBase + LoadedImage->ImageSize)) { 1407 return TRUE; 1408 } 1409 } 1410 1411 return FALSE; 1412 } 1413 1414 /** 1415 This function installs all SMM image record information. 1416 **/ 1417 VOID 1418 SmmInstallImageRecord ( 1419 VOID 1420 ) 1421 { 1422 EFI_STATUS Status; 1423 UINTN NoHandles; 1424 EFI_HANDLE *HandleBuffer; 1425 EFI_LOADED_IMAGE_PROTOCOL *LoadedImage; 1426 UINTN Index; 1427 EFI_SMM_DRIVER_ENTRY DriverEntry; 1428 1429 Status = SmmLocateHandleBuffer ( 1430 ByProtocol, 1431 &gEfiLoadedImageProtocolGuid, 1432 NULL, 1433 &NoHandles, 1434 &HandleBuffer 1435 ); 1436 if (EFI_ERROR (Status)) { 1437 return ; 1438 } 1439 1440 for (Index = 0; Index < NoHandles; Index++) { 1441 Status = gSmst->SmmHandleProtocol ( 1442 HandleBuffer[Index], 1443 &gEfiLoadedImageProtocolGuid, 1444 (VOID **)&LoadedImage 1445 ); 1446 if (EFI_ERROR (Status)) { 1447 continue; 1448 } 1449 DEBUG ((DEBUG_VERBOSE, "LoadedImage - 0x%x 0x%x ", LoadedImage->ImageBase, LoadedImage->ImageSize)); 1450 { 1451 VOID *PdbPointer; 1452 PdbPointer = PeCoffLoaderGetPdbPointer (LoadedImage->ImageBase); 1453 if (PdbPointer != NULL) { 1454 DEBUG ((DEBUG_VERBOSE, "(%a) ", PdbPointer)); 1455 } 1456 } 1457 DEBUG ((DEBUG_VERBOSE, "\n")); 1458 ZeroMem (&DriverEntry, sizeof(DriverEntry)); 1459 DriverEntry.ImageBuffer = (UINTN)LoadedImage->ImageBase; 1460 DriverEntry.NumberOfPage = EFI_SIZE_TO_PAGES((UINTN)LoadedImage->ImageSize); 1461 SmmInsertImageRecord (&DriverEntry); 1462 } 1463 1464 FreePool (HandleBuffer); 1465 } 1466 1467 /** 1468 Install MemoryAttributesTable. 1469 1470 @param[in] Protocol Points to the protocol's unique identifier. 1471 @param[in] Interface Points to the interface instance. 1472 @param[in] Handle The handle on which the interface was installed. 1473 1474 @retval EFI_SUCCESS Notification runs successfully. 1475 **/ 1476 EFI_STATUS 1477 EFIAPI 1478 SmmInstallMemoryAttributesTable ( 1479 IN CONST EFI_GUID *Protocol, 1480 IN VOID *Interface, 1481 IN EFI_HANDLE Handle 1482 ) 1483 { 1484 SmmInstallImageRecord (); 1485 1486 DEBUG ((DEBUG_INFO, "SMM MemoryProtectionAttribute - 0x%016lx\n", mMemoryProtectionAttribute)); 1487 if ((mMemoryProtectionAttribute & EFI_MEMORY_ATTRIBUTES_RUNTIME_MEMORY_PROTECTION_NON_EXECUTABLE_PE_DATA) == 0) { 1488 return EFI_SUCCESS; 1489 } 1490 1491 DEBUG ((DEBUG_VERBOSE, "SMM Total Image Count - 0x%x\n", mImagePropertiesPrivateData.ImageRecordCount)); 1492 DEBUG ((DEBUG_VERBOSE, "SMM Dump ImageRecord:\n")); 1493 DumpImageRecord (); 1494 1495 PublishMemoryAttributesTable (); 1496 1497 return EFI_SUCCESS; 1498 } 1499 1500 /** 1501 Initialize MemoryAttributesTable support. 1502 **/ 1503 VOID 1504 EFIAPI 1505 SmmCoreInitializeMemoryAttributesTable ( 1506 VOID 1507 ) 1508 { 1509 EFI_STATUS Status; 1510 VOID *Registration; 1511 1512 Status = gSmst->SmmRegisterProtocolNotify ( 1513 &gEfiSmmEndOfDxeProtocolGuid, 1514 SmmInstallMemoryAttributesTable, 1515 &Registration 1516 ); 1517 ASSERT_EFI_ERROR (Status); 1518 1519 return ; 1520 } 1521
