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