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