1 /* 2 * Handle the memory map. 3 * The functions here do the job until bootmem takes over. 4 * 5 * Getting sanitize_e820_map() in sync with i386 version by applying change: 6 * - Provisions for empty E820 memory regions (reported by certain BIOSes). 7 * Alex Achenbach <xela@slit.de>, December 2002. 8 * Venkatesh Pallipadi <venkatesh.pallipadi@intel.com> 9 * 10 */ 11 #include <linux/kernel.h> 12 #include <linux/types.h> 13 #include <linux/init.h> 14 #include <linux/crash_dump.h> 15 #include <linux/export.h> 16 #include <linux/bootmem.h> 17 #include <linux/pfn.h> 18 #include <linux/suspend.h> 19 #include <linux/acpi.h> 20 #include <linux/firmware-map.h> 21 #include <linux/memblock.h> 22 23 #include <asm/e820.h> 24 #include <asm/proto.h> 25 #include <asm/setup.h> 26 27 /* 28 * The e820 map is the map that gets modified e.g. with command line parameters 29 * and that is also registered with modifications in the kernel resource tree 30 * with the iomem_resource as parent. 31 * 32 * The e820_saved is directly saved after the BIOS-provided memory map is 33 * copied. It doesn't get modified afterwards. It's registered for the 34 * /sys/firmware/memmap interface. 35 * 36 * That memory map is not modified and is used as base for kexec. The kexec'd 37 * kernel should get the same memory map as the firmware provides. Then the 38 * user can e.g. boot the original kernel with mem=1G while still booting the 39 * next kernel with full memory. 40 */ 41 struct e820map e820; 42 struct e820map e820_saved; 43 44 /* For PCI or other memory-mapped resources */ 45 unsigned long pci_mem_start = 0xaeedbabe; 46 #ifdef CONFIG_PCI 47 EXPORT_SYMBOL(pci_mem_start); 48 #endif 49 50 /* 51 * This function checks if any part of the range <start,end> is mapped 52 * with type. 53 */ 54 int 55 e820_any_mapped(u64 start, u64 end, unsigned type) 56 { 57 int i; 58 59 for (i = 0; i < e820.nr_map; i++) { 60 struct e820entry *ei = &e820.map[i]; 61 62 if (type && ei->type != type) 63 continue; 64 if (ei->addr >= end || ei->addr + ei->size <= start) 65 continue; 66 return 1; 67 } 68 return 0; 69 } 70 EXPORT_SYMBOL_GPL(e820_any_mapped); 71 72 /* 73 * This function checks if the entire range <start,end> is mapped with type. 74 * 75 * Note: this function only works correct if the e820 table is sorted and 76 * not-overlapping, which is the case 77 */ 78 int __init e820_all_mapped(u64 start, u64 end, unsigned type) 79 { 80 int i; 81 82 for (i = 0; i < e820.nr_map; i++) { 83 struct e820entry *ei = &e820.map[i]; 84 85 if (type && ei->type != type) 86 continue; 87 /* is the region (part) in overlap with the current region ?*/ 88 if (ei->addr >= end || ei->addr + ei->size <= start) 89 continue; 90 91 /* if the region is at the beginning of <start,end> we move 92 * start to the end of the region since it's ok until there 93 */ 94 if (ei->addr <= start) 95 start = ei->addr + ei->size; 96 /* 97 * if start is now at or beyond end, we're done, full 98 * coverage 99 */ 100 if (start >= end) 101 return 1; 102 } 103 return 0; 104 } 105 106 /* 107 * Add a memory region to the kernel e820 map. 108 */ 109 static void __init __e820_add_region(struct e820map *e820x, u64 start, u64 size, 110 int type) 111 { 112 int x = e820x->nr_map; 113 114 if (x >= ARRAY_SIZE(e820x->map)) { 115 printk(KERN_ERR "Ooops! Too many entries in the memory map!\n"); 116 return; 117 } 118 119 e820x->map[x].addr = start; 120 e820x->map[x].size = size; 121 e820x->map[x].type = type; 122 e820x->nr_map++; 123 } 124 125 void __init e820_add_region(u64 start, u64 size, int type) 126 { 127 __e820_add_region(&e820, start, size, type); 128 } 129 130 static void __init e820_print_type(u32 type) 131 { 132 switch (type) { 133 case E820_RAM: 134 case E820_RESERVED_KERN: 135 printk(KERN_CONT "(usable)"); 136 break; 137 case E820_RESERVED: 138 printk(KERN_CONT "(reserved)"); 139 break; 140 case E820_ACPI: 141 printk(KERN_CONT "(ACPI data)"); 142 break; 143 case E820_NVS: 144 printk(KERN_CONT "(ACPI NVS)"); 145 break; 146 case E820_UNUSABLE: 147 printk(KERN_CONT "(unusable)"); 148 break; 149 default: 150 printk(KERN_CONT "type %u", type); 151 break; 152 } 153 } 154 155 void __init e820_print_map(char *who) 156 { 157 int i; 158 159 for (i = 0; i < e820.nr_map; i++) { 160 printk(KERN_INFO " %s: %016Lx - %016Lx ", who, 161 (unsigned long long) e820.map[i].addr, 162 (unsigned long long) 163 (e820.map[i].addr + e820.map[i].size)); 164 e820_print_type(e820.map[i].type); 165 printk(KERN_CONT "\n"); 166 } 167 } 168 169 /* 170 * Sanitize the BIOS e820 map. 171 * 172 * Some e820 responses include overlapping entries. The following 173 * replaces the original e820 map with a new one, removing overlaps, 174 * and resolving conflicting memory types in favor of highest 175 * numbered type. 176 * 177 * The input parameter biosmap points to an array of 'struct 178 * e820entry' which on entry has elements in the range [0, *pnr_map) 179 * valid, and which has space for up to max_nr_map entries. 180 * On return, the resulting sanitized e820 map entries will be in 181 * overwritten in the same location, starting at biosmap. 182 * 183 * The integer pointed to by pnr_map must be valid on entry (the 184 * current number of valid entries located at biosmap) and will 185 * be updated on return, with the new number of valid entries 186 * (something no more than max_nr_map.) 187 * 188 * The return value from sanitize_e820_map() is zero if it 189 * successfully 'sanitized' the map entries passed in, and is -1 190 * if it did nothing, which can happen if either of (1) it was 191 * only passed one map entry, or (2) any of the input map entries 192 * were invalid (start + size < start, meaning that the size was 193 * so big the described memory range wrapped around through zero.) 194 * 195 * Visually we're performing the following 196 * (1,2,3,4 = memory types)... 197 * 198 * Sample memory map (w/overlaps): 199 * ____22__________________ 200 * ______________________4_ 201 * ____1111________________ 202 * _44_____________________ 203 * 11111111________________ 204 * ____________________33__ 205 * ___________44___________ 206 * __________33333_________ 207 * ______________22________ 208 * ___________________2222_ 209 * _________111111111______ 210 * _____________________11_ 211 * _________________4______ 212 * 213 * Sanitized equivalent (no overlap): 214 * 1_______________________ 215 * _44_____________________ 216 * ___1____________________ 217 * ____22__________________ 218 * ______11________________ 219 * _________1______________ 220 * __________3_____________ 221 * ___________44___________ 222 * _____________33_________ 223 * _______________2________ 224 * ________________1_______ 225 * _________________4______ 226 * ___________________2____ 227 * ____________________33__ 228 * ______________________4_ 229 */ 230 231 int __init sanitize_e820_map(struct e820entry *biosmap, int max_nr_map, 232 u32 *pnr_map) 233 { 234 struct change_member { 235 struct e820entry *pbios; /* pointer to original bios entry */ 236 unsigned long long addr; /* address for this change point */ 237 }; 238 static struct change_member change_point_list[2*E820_X_MAX] __initdata; 239 static struct change_member *change_point[2*E820_X_MAX] __initdata; 240 static struct e820entry *overlap_list[E820_X_MAX] __initdata; 241 static struct e820entry new_bios[E820_X_MAX] __initdata; 242 struct change_member *change_tmp; 243 unsigned long current_type, last_type; 244 unsigned long long last_addr; 245 int chgidx, still_changing; 246 int overlap_entries; 247 int new_bios_entry; 248 int old_nr, new_nr, chg_nr; 249 int i; 250 251 /* if there's only one memory region, don't bother */ 252 if (*pnr_map < 2) 253 return -1; 254 255 old_nr = *pnr_map; 256 BUG_ON(old_nr > max_nr_map); 257 258 /* bail out if we find any unreasonable addresses in bios map */ 259 for (i = 0; i < old_nr; i++) 260 if (biosmap[i].addr + biosmap[i].size < biosmap[i].addr) 261 return -1; 262 263 /* create pointers for initial change-point information (for sorting) */ 264 for (i = 0; i < 2 * old_nr; i++) 265 change_point[i] = &change_point_list[i]; 266 267 /* record all known change-points (starting and ending addresses), 268 omitting those that are for empty memory regions */ 269 chgidx = 0; 270 for (i = 0; i < old_nr; i++) { 271 if (biosmap[i].size != 0) { 272 change_point[chgidx]->addr = biosmap[i].addr; 273 change_point[chgidx++]->pbios = &biosmap[i]; 274 change_point[chgidx]->addr = biosmap[i].addr + 275 biosmap[i].size; 276 change_point[chgidx++]->pbios = &biosmap[i]; 277 } 278 } 279 chg_nr = chgidx; 280 281 /* sort change-point list by memory addresses (low -> high) */ 282 still_changing = 1; 283 while (still_changing) { 284 still_changing = 0; 285 for (i = 1; i < chg_nr; i++) { 286 unsigned long long curaddr, lastaddr; 287 unsigned long long curpbaddr, lastpbaddr; 288 289 curaddr = change_point[i]->addr; 290 lastaddr = change_point[i - 1]->addr; 291 curpbaddr = change_point[i]->pbios->addr; 292 lastpbaddr = change_point[i - 1]->pbios->addr; 293 294 /* 295 * swap entries, when: 296 * 297 * curaddr > lastaddr or 298 * curaddr == lastaddr and curaddr == curpbaddr and 299 * lastaddr != lastpbaddr 300 */ 301 if (curaddr < lastaddr || 302 (curaddr == lastaddr && curaddr == curpbaddr && 303 lastaddr != lastpbaddr)) { 304 change_tmp = change_point[i]; 305 change_point[i] = change_point[i-1]; 306 change_point[i-1] = change_tmp; 307 still_changing = 1; 308 } 309 } 310 } 311 312 /* create a new bios memory map, removing overlaps */ 313 overlap_entries = 0; /* number of entries in the overlap table */ 314 new_bios_entry = 0; /* index for creating new bios map entries */ 315 last_type = 0; /* start with undefined memory type */ 316 last_addr = 0; /* start with 0 as last starting address */ 317 318 /* loop through change-points, determining affect on the new bios map */ 319 for (chgidx = 0; chgidx < chg_nr; chgidx++) { 320 /* keep track of all overlapping bios entries */ 321 if (change_point[chgidx]->addr == 322 change_point[chgidx]->pbios->addr) { 323 /* 324 * add map entry to overlap list (> 1 entry 325 * implies an overlap) 326 */ 327 overlap_list[overlap_entries++] = 328 change_point[chgidx]->pbios; 329 } else { 330 /* 331 * remove entry from list (order independent, 332 * so swap with last) 333 */ 334 for (i = 0; i < overlap_entries; i++) { 335 if (overlap_list[i] == 336 change_point[chgidx]->pbios) 337 overlap_list[i] = 338 overlap_list[overlap_entries-1]; 339 } 340 overlap_entries--; 341 } 342 /* 343 * if there are overlapping entries, decide which 344 * "type" to use (larger value takes precedence -- 345 * 1=usable, 2,3,4,4+=unusable) 346 */ 347 current_type = 0; 348 for (i = 0; i < overlap_entries; i++) 349 if (overlap_list[i]->type > current_type) 350 current_type = overlap_list[i]->type; 351 /* 352 * continue building up new bios map based on this 353 * information 354 */ 355 if (current_type != last_type) { 356 if (last_type != 0) { 357 new_bios[new_bios_entry].size = 358 change_point[chgidx]->addr - last_addr; 359 /* 360 * move forward only if the new size 361 * was non-zero 362 */ 363 if (new_bios[new_bios_entry].size != 0) 364 /* 365 * no more space left for new 366 * bios entries ? 367 */ 368 if (++new_bios_entry >= max_nr_map) 369 break; 370 } 371 if (current_type != 0) { 372 new_bios[new_bios_entry].addr = 373 change_point[chgidx]->addr; 374 new_bios[new_bios_entry].type = current_type; 375 last_addr = change_point[chgidx]->addr; 376 } 377 last_type = current_type; 378 } 379 } 380 /* retain count for new bios entries */ 381 new_nr = new_bios_entry; 382 383 /* copy new bios mapping into original location */ 384 memcpy(biosmap, new_bios, new_nr * sizeof(struct e820entry)); 385 *pnr_map = new_nr; 386 387 return 0; 388 } 389 390 static int __init __append_e820_map(struct e820entry *biosmap, int nr_map) 391 { 392 while (nr_map) { 393 u64 start = biosmap->addr; 394 u64 size = biosmap->size; 395 u64 end = start + size; 396 u32 type = biosmap->type; 397 398 /* Overflow in 64 bits? Ignore the memory map. */ 399 if (start > end) 400 return -1; 401 402 e820_add_region(start, size, type); 403 404 biosmap++; 405 nr_map--; 406 } 407 return 0; 408 } 409 410 /* 411 * Copy the BIOS e820 map into a safe place. 412 * 413 * Sanity-check it while we're at it.. 414 * 415 * If we're lucky and live on a modern system, the setup code 416 * will have given us a memory map that we can use to properly 417 * set up memory. If we aren't, we'll fake a memory map. 418 */ 419 static int __init append_e820_map(struct e820entry *biosmap, int nr_map) 420 { 421 /* Only one memory region (or negative)? Ignore it */ 422 if (nr_map < 2) 423 return -1; 424 425 return __append_e820_map(biosmap, nr_map); 426 } 427 428 static u64 __init __e820_update_range(struct e820map *e820x, u64 start, 429 u64 size, unsigned old_type, 430 unsigned new_type) 431 { 432 u64 end; 433 unsigned int i; 434 u64 real_updated_size = 0; 435 436 BUG_ON(old_type == new_type); 437 438 if (size > (ULLONG_MAX - start)) 439 size = ULLONG_MAX - start; 440 441 end = start + size; 442 printk(KERN_DEBUG "e820 update range: %016Lx - %016Lx ", 443 (unsigned long long) start, 444 (unsigned long long) end); 445 e820_print_type(old_type); 446 printk(KERN_CONT " ==> "); 447 e820_print_type(new_type); 448 printk(KERN_CONT "\n"); 449 450 for (i = 0; i < e820x->nr_map; i++) { 451 struct e820entry *ei = &e820x->map[i]; 452 u64 final_start, final_end; 453 u64 ei_end; 454 455 if (ei->type != old_type) 456 continue; 457 458 ei_end = ei->addr + ei->size; 459 /* totally covered by new range? */ 460 if (ei->addr >= start && ei_end <= end) { 461 ei->type = new_type; 462 real_updated_size += ei->size; 463 continue; 464 } 465 466 /* new range is totally covered? */ 467 if (ei->addr < start && ei_end > end) { 468 __e820_add_region(e820x, start, size, new_type); 469 __e820_add_region(e820x, end, ei_end - end, ei->type); 470 ei->size = start - ei->addr; 471 real_updated_size += size; 472 continue; 473 } 474 475 /* partially covered */ 476 final_start = max(start, ei->addr); 477 final_end = min(end, ei_end); 478 if (final_start >= final_end) 479 continue; 480 481 __e820_add_region(e820x, final_start, final_end - final_start, 482 new_type); 483 484 real_updated_size += final_end - final_start; 485 486 /* 487 * left range could be head or tail, so need to update 488 * size at first. 489 */ 490 ei->size -= final_end - final_start; 491 if (ei->addr < final_start) 492 continue; 493 ei->addr = final_end; 494 } 495 return real_updated_size; 496 } 497 498 u64 __init e820_update_range(u64 start, u64 size, unsigned old_type, 499 unsigned new_type) 500 { 501 return __e820_update_range(&e820, start, size, old_type, new_type); 502 } 503 504 static u64 __init e820_update_range_saved(u64 start, u64 size, 505 unsigned old_type, unsigned new_type) 506 { 507 return __e820_update_range(&e820_saved, start, size, old_type, 508 new_type); 509 } 510 511 /* make e820 not cover the range */ 512 u64 __init e820_remove_range(u64 start, u64 size, unsigned old_type, 513 int checktype) 514 { 515 int i; 516 u64 end; 517 u64 real_removed_size = 0; 518 519 if (size > (ULLONG_MAX - start)) 520 size = ULLONG_MAX - start; 521 522 end = start + size; 523 printk(KERN_DEBUG "e820 remove range: %016Lx - %016Lx ", 524 (unsigned long long) start, 525 (unsigned long long) end); 526 if (checktype) 527 e820_print_type(old_type); 528 printk(KERN_CONT "\n"); 529 530 for (i = 0; i < e820.nr_map; i++) { 531 struct e820entry *ei = &e820.map[i]; 532 u64 final_start, final_end; 533 u64 ei_end; 534 535 if (checktype && ei->type != old_type) 536 continue; 537 538 ei_end = ei->addr + ei->size; 539 /* totally covered? */ 540 if (ei->addr >= start && ei_end <= end) { 541 real_removed_size += ei->size; 542 memset(ei, 0, sizeof(struct e820entry)); 543 continue; 544 } 545 546 /* new range is totally covered? */ 547 if (ei->addr < start && ei_end > end) { 548 e820_add_region(end, ei_end - end, ei->type); 549 ei->size = start - ei->addr; 550 real_removed_size += size; 551 continue; 552 } 553 554 /* partially covered */ 555 final_start = max(start, ei->addr); 556 final_end = min(end, ei_end); 557 if (final_start >= final_end) 558 continue; 559 real_removed_size += final_end - final_start; 560 561 /* 562 * left range could be head or tail, so need to update 563 * size at first. 564 */ 565 ei->size -= final_end - final_start; 566 if (ei->addr < final_start) 567 continue; 568 ei->addr = final_end; 569 } 570 return real_removed_size; 571 } 572 573 void __init update_e820(void) 574 { 575 u32 nr_map; 576 577 nr_map = e820.nr_map; 578 if (sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &nr_map)) 579 return; 580 e820.nr_map = nr_map; 581 printk(KERN_INFO "modified physical RAM map:\n"); 582 e820_print_map("modified"); 583 } 584 static void __init update_e820_saved(void) 585 { 586 u32 nr_map; 587 588 nr_map = e820_saved.nr_map; 589 if (sanitize_e820_map(e820_saved.map, ARRAY_SIZE(e820_saved.map), &nr_map)) 590 return; 591 e820_saved.nr_map = nr_map; 592 } 593 #define MAX_GAP_END 0x100000000ull 594 /* 595 * Search for a gap in the e820 memory space from start_addr to end_addr. 596 */ 597 __init int e820_search_gap(unsigned long *gapstart, unsigned long *gapsize, 598 unsigned long start_addr, unsigned long long end_addr) 599 { 600 unsigned long long last; 601 int i = e820.nr_map; 602 int found = 0; 603 604 last = (end_addr && end_addr < MAX_GAP_END) ? end_addr : MAX_GAP_END; 605 606 while (--i >= 0) { 607 unsigned long long start = e820.map[i].addr; 608 unsigned long long end = start + e820.map[i].size; 609 610 if (end < start_addr) 611 continue; 612 613 /* 614 * Since "last" is at most 4GB, we know we'll 615 * fit in 32 bits if this condition is true 616 */ 617 if (last > end) { 618 unsigned long gap = last - end; 619 620 if (gap >= *gapsize) { 621 *gapsize = gap; 622 *gapstart = end; 623 found = 1; 624 } 625 } 626 if (start < last) 627 last = start; 628 } 629 return found; 630 } 631 632 /* 633 * Search for the biggest gap in the low 32 bits of the e820 634 * memory space. We pass this space to PCI to assign MMIO resources 635 * for hotplug or unconfigured devices in. 636 * Hopefully the BIOS let enough space left. 637 */ 638 __init void e820_setup_gap(void) 639 { 640 unsigned long gapstart, gapsize; 641 int found; 642 643 gapstart = 0x10000000; 644 gapsize = 0x400000; 645 found = e820_search_gap(&gapstart, &gapsize, 0, MAX_GAP_END); 646 647 #ifdef CONFIG_X86_64 648 if (!found) { 649 gapstart = (max_pfn << PAGE_SHIFT) + 1024*1024; 650 printk(KERN_ERR 651 "PCI: Warning: Cannot find a gap in the 32bit address range\n" 652 "PCI: Unassigned devices with 32bit resource registers may break!\n"); 653 } 654 #endif 655 656 /* 657 * e820_reserve_resources_late protect stolen RAM already 658 */ 659 pci_mem_start = gapstart; 660 661 printk(KERN_INFO 662 "Allocating PCI resources starting at %lx (gap: %lx:%lx)\n", 663 pci_mem_start, gapstart, gapsize); 664 } 665 666 /** 667 * Because of the size limitation of struct boot_params, only first 668 * 128 E820 memory entries are passed to kernel via 669 * boot_params.e820_map, others are passed via SETUP_E820_EXT node of 670 * linked list of struct setup_data, which is parsed here. 671 */ 672 void __init parse_e820_ext(struct setup_data *sdata) 673 { 674 int entries; 675 struct e820entry *extmap; 676 677 entries = sdata->len / sizeof(struct e820entry); 678 extmap = (struct e820entry *)(sdata->data); 679 __append_e820_map(extmap, entries); 680 sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map); 681 printk(KERN_INFO "extended physical RAM map:\n"); 682 e820_print_map("extended"); 683 } 684 685 #if defined(CONFIG_X86_64) || \ 686 (defined(CONFIG_X86_32) && defined(CONFIG_HIBERNATION)) 687 /** 688 * Find the ranges of physical addresses that do not correspond to 689 * e820 RAM areas and mark the corresponding pages as nosave for 690 * hibernation (32 bit) or software suspend and suspend to RAM (64 bit). 691 * 692 * This function requires the e820 map to be sorted and without any 693 * overlapping entries and assumes the first e820 area to be RAM. 694 */ 695 void __init e820_mark_nosave_regions(unsigned long limit_pfn) 696 { 697 int i; 698 unsigned long pfn; 699 700 pfn = PFN_DOWN(e820.map[0].addr + e820.map[0].size); 701 for (i = 1; i < e820.nr_map; i++) { 702 struct e820entry *ei = &e820.map[i]; 703 704 if (pfn < PFN_UP(ei->addr)) 705 register_nosave_region(pfn, PFN_UP(ei->addr)); 706 707 pfn = PFN_DOWN(ei->addr + ei->size); 708 if (ei->type != E820_RAM && ei->type != E820_RESERVED_KERN) 709 register_nosave_region(PFN_UP(ei->addr), pfn); 710 711 if (pfn >= limit_pfn) 712 break; 713 } 714 } 715 #endif 716 717 #ifdef CONFIG_HIBERNATION 718 /** 719 * Mark ACPI NVS memory region, so that we can save/restore it during 720 * hibernation and the subsequent resume. 721 */ 722 static int __init e820_mark_nvs_memory(void) 723 { 724 int i; 725 726 for (i = 0; i < e820.nr_map; i++) { 727 struct e820entry *ei = &e820.map[i]; 728 729 if (ei->type == E820_NVS) 730 suspend_nvs_register(ei->addr, ei->size); 731 } 732 733 return 0; 734 } 735 core_initcall(e820_mark_nvs_memory); 736 #endif 737 738 /* 739 * pre allocated 4k and reserved it in memblock and e820_saved 740 */ 741 u64 __init early_reserve_e820(u64 startt, u64 sizet, u64 align) 742 { 743 u64 size = 0; 744 u64 addr; 745 u64 start; 746 747 for (start = startt; ; start += size) { 748 start = memblock_x86_find_in_range_size(start, &size, align); 749 if (start == MEMBLOCK_ERROR) 750 return 0; 751 if (size >= sizet) 752 break; 753 } 754 755 #ifdef CONFIG_X86_32 756 if (start >= MAXMEM) 757 return 0; 758 if (start + size > MAXMEM) 759 size = MAXMEM - start; 760 #endif 761 762 addr = round_down(start + size - sizet, align); 763 if (addr < start) 764 return 0; 765 memblock_x86_reserve_range(addr, addr + sizet, "new next"); 766 e820_update_range_saved(addr, sizet, E820_RAM, E820_RESERVED); 767 printk(KERN_INFO "update e820_saved for early_reserve_e820\n"); 768 update_e820_saved(); 769 770 return addr; 771 } 772 773 #ifdef CONFIG_X86_32 774 # ifdef CONFIG_X86_PAE 775 # define MAX_ARCH_PFN (1ULL<<(36-PAGE_SHIFT)) 776 # else 777 # define MAX_ARCH_PFN (1ULL<<(32-PAGE_SHIFT)) 778 # endif 779 #else /* CONFIG_X86_32 */ 780 # define MAX_ARCH_PFN MAXMEM>>PAGE_SHIFT 781 #endif 782 783 /* 784 * Find the highest page frame number we have available 785 */ 786 static unsigned long __init e820_end_pfn(unsigned long limit_pfn, unsigned type) 787 { 788 int i; 789 unsigned long last_pfn = 0; 790 unsigned long max_arch_pfn = MAX_ARCH_PFN; 791 792 for (i = 0; i < e820.nr_map; i++) { 793 struct e820entry *ei = &e820.map[i]; 794 unsigned long start_pfn; 795 unsigned long end_pfn; 796 797 if (ei->type != type) 798 continue; 799 800 start_pfn = ei->addr >> PAGE_SHIFT; 801 end_pfn = (ei->addr + ei->size) >> PAGE_SHIFT; 802 803 if (start_pfn >= limit_pfn) 804 continue; 805 if (end_pfn > limit_pfn) { 806 last_pfn = limit_pfn; 807 break; 808 } 809 if (end_pfn > last_pfn) 810 last_pfn = end_pfn; 811 } 812 813 if (last_pfn > max_arch_pfn) 814 last_pfn = max_arch_pfn; 815 816 printk(KERN_INFO "last_pfn = %#lx max_arch_pfn = %#lx\n", 817 last_pfn, max_arch_pfn); 818 return last_pfn; 819 } 820 unsigned long __init e820_end_of_ram_pfn(void) 821 { 822 return e820_end_pfn(MAX_ARCH_PFN, E820_RAM); 823 } 824 825 unsigned long __init e820_end_of_low_ram_pfn(void) 826 { 827 return e820_end_pfn(1UL<<(32 - PAGE_SHIFT), E820_RAM); 828 } 829 830 static void early_panic(char *msg) 831 { 832 early_printk(msg); 833 panic(msg); 834 } 835 836 static int userdef __initdata; 837 838 /* "mem=nopentium" disables the 4MB page tables. */ 839 static int __init parse_memopt(char *p) 840 { 841 u64 mem_size; 842 843 if (!p) 844 return -EINVAL; 845 846 if (!strcmp(p, "nopentium")) { 847 #ifdef CONFIG_X86_32 848 setup_clear_cpu_cap(X86_FEATURE_PSE); 849 return 0; 850 #else 851 printk(KERN_WARNING "mem=nopentium ignored! (only supported on x86_32)\n"); 852 return -EINVAL; 853 #endif 854 } 855 856 userdef = 1; 857 mem_size = memparse(p, &p); 858 /* don't remove all of memory when handling "mem={invalid}" param */ 859 if (mem_size == 0) 860 return -EINVAL; 861 e820_remove_range(mem_size, ULLONG_MAX - mem_size, E820_RAM, 1); 862 863 return 0; 864 } 865 early_param("mem", parse_memopt); 866 867 static int __init parse_memmap_opt(char *p) 868 { 869 char *oldp; 870 u64 start_at, mem_size; 871 872 if (!p) 873 return -EINVAL; 874 875 if (!strncmp(p, "exactmap", 8)) { 876 #ifdef CONFIG_CRASH_DUMP 877 /* 878 * If we are doing a crash dump, we still need to know 879 * the real mem size before original memory map is 880 * reset. 881 */ 882 saved_max_pfn = e820_end_of_ram_pfn(); 883 #endif 884 e820.nr_map = 0; 885 userdef = 1; 886 return 0; 887 } 888 889 oldp = p; 890 mem_size = memparse(p, &p); 891 if (p == oldp) 892 return -EINVAL; 893 894 userdef = 1; 895 if (*p == '@') { 896 start_at = memparse(p+1, &p); 897 e820_add_region(start_at, mem_size, E820_RAM); 898 } else if (*p == '#') { 899 start_at = memparse(p+1, &p); 900 e820_add_region(start_at, mem_size, E820_ACPI); 901 } else if (*p == '$') { 902 start_at = memparse(p+1, &p); 903 e820_add_region(start_at, mem_size, E820_RESERVED); 904 } else 905 e820_remove_range(mem_size, ULLONG_MAX - mem_size, E820_RAM, 1); 906 907 return *p == '\0' ? 0 : -EINVAL; 908 } 909 early_param("memmap", parse_memmap_opt); 910 911 void __init finish_e820_parsing(void) 912 { 913 if (userdef) { 914 u32 nr = e820.nr_map; 915 916 if (sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &nr) < 0) 917 early_panic("Invalid user supplied memory map"); 918 e820.nr_map = nr; 919 920 printk(KERN_INFO "user-defined physical RAM map:\n"); 921 e820_print_map("user"); 922 } 923 } 924 925 static inline const char *e820_type_to_string(int e820_type) 926 { 927 switch (e820_type) { 928 case E820_RESERVED_KERN: 929 case E820_RAM: return "System RAM"; 930 case E820_ACPI: return "ACPI Tables"; 931 case E820_NVS: return "ACPI Non-volatile Storage"; 932 case E820_UNUSABLE: return "Unusable memory"; 933 default: return "reserved"; 934 } 935 } 936 937 /* 938 * Mark e820 reserved areas as busy for the resource manager. 939 */ 940 static struct resource __initdata *e820_res; 941 void __init e820_reserve_resources(void) 942 { 943 int i; 944 struct resource *res; 945 u64 end; 946 947 res = alloc_bootmem(sizeof(struct resource) * e820.nr_map); 948 e820_res = res; 949 for (i = 0; i < e820.nr_map; i++) { 950 end = e820.map[i].addr + e820.map[i].size - 1; 951 if (end != (resource_size_t)end) { 952 res++; 953 continue; 954 } 955 res->name = e820_type_to_string(e820.map[i].type); 956 res->start = e820.map[i].addr; 957 res->end = end; 958 959 res->flags = IORESOURCE_MEM; 960 961 /* 962 * don't register the region that could be conflicted with 963 * pci device BAR resource and insert them later in 964 * pcibios_resource_survey() 965 */ 966 if (e820.map[i].type != E820_RESERVED || res->start < (1ULL<<20)) { 967 res->flags |= IORESOURCE_BUSY; 968 insert_resource(&iomem_resource, res); 969 } 970 res++; 971 } 972 973 for (i = 0; i < e820_saved.nr_map; i++) { 974 struct e820entry *entry = &e820_saved.map[i]; 975 firmware_map_add_early(entry->addr, 976 entry->addr + entry->size - 1, 977 e820_type_to_string(entry->type)); 978 } 979 } 980 981 /* How much should we pad RAM ending depending on where it is? */ 982 static unsigned long ram_alignment(resource_size_t pos) 983 { 984 unsigned long mb = pos >> 20; 985 986 /* To 64kB in the first megabyte */ 987 if (!mb) 988 return 64*1024; 989 990 /* To 1MB in the first 16MB */ 991 if (mb < 16) 992 return 1024*1024; 993 994 /* To 64MB for anything above that */ 995 return 64*1024*1024; 996 } 997 998 #define MAX_RESOURCE_SIZE ((resource_size_t)-1) 999 1000 void __init e820_reserve_resources_late(void) 1001 { 1002 int i; 1003 struct resource *res; 1004 1005 res = e820_res; 1006 for (i = 0; i < e820.nr_map; i++) { 1007 if (!res->parent && res->end) 1008 insert_resource_expand_to_fit(&iomem_resource, res); 1009 res++; 1010 } 1011 1012 /* 1013 * Try to bump up RAM regions to reasonable boundaries to 1014 * avoid stolen RAM: 1015 */ 1016 for (i = 0; i < e820.nr_map; i++) { 1017 struct e820entry *entry = &e820.map[i]; 1018 u64 start, end; 1019 1020 if (entry->type != E820_RAM) 1021 continue; 1022 start = entry->addr + entry->size; 1023 end = round_up(start, ram_alignment(start)) - 1; 1024 if (end > MAX_RESOURCE_SIZE) 1025 end = MAX_RESOURCE_SIZE; 1026 if (start >= end) 1027 continue; 1028 printk(KERN_DEBUG "reserve RAM buffer: %016llx - %016llx ", 1029 start, end); 1030 reserve_region_with_split(&iomem_resource, start, end, 1031 "RAM buffer"); 1032 } 1033 } 1034 1035 char *__init default_machine_specific_memory_setup(void) 1036 { 1037 char *who = "BIOS-e820"; 1038 u32 new_nr; 1039 /* 1040 * Try to copy the BIOS-supplied E820-map. 1041 * 1042 * Otherwise fake a memory map; one section from 0k->640k, 1043 * the next section from 1mb->appropriate_mem_k 1044 */ 1045 new_nr = boot_params.e820_entries; 1046 sanitize_e820_map(boot_params.e820_map, 1047 ARRAY_SIZE(boot_params.e820_map), 1048 &new_nr); 1049 boot_params.e820_entries = new_nr; 1050 if (append_e820_map(boot_params.e820_map, boot_params.e820_entries) 1051 < 0) { 1052 u64 mem_size; 1053 1054 /* compare results from other methods and take the greater */ 1055 if (boot_params.alt_mem_k 1056 < boot_params.screen_info.ext_mem_k) { 1057 mem_size = boot_params.screen_info.ext_mem_k; 1058 who = "BIOS-88"; 1059 } else { 1060 mem_size = boot_params.alt_mem_k; 1061 who = "BIOS-e801"; 1062 } 1063 1064 e820.nr_map = 0; 1065 e820_add_region(0, LOWMEMSIZE(), E820_RAM); 1066 e820_add_region(HIGH_MEMORY, mem_size << 10, E820_RAM); 1067 } 1068 1069 /* In case someone cares... */ 1070 return who; 1071 } 1072 1073 void __init setup_memory_map(void) 1074 { 1075 char *who; 1076 1077 who = x86_init.resources.memory_setup(); 1078 memcpy(&e820_saved, &e820, sizeof(struct e820map)); 1079 printk(KERN_INFO "BIOS-provided physical RAM map:\n"); 1080 e820_print_map(who); 1081 } 1082 1083 void __init memblock_x86_fill(void) 1084 { 1085 int i; 1086 u64 end; 1087 1088 /* 1089 * EFI may have more than 128 entries 1090 * We are safe to enable resizing, beause memblock_x86_fill() 1091 * is rather later for x86 1092 */ 1093 memblock_can_resize = 1; 1094 1095 for (i = 0; i < e820.nr_map; i++) { 1096 struct e820entry *ei = &e820.map[i]; 1097 1098 end = ei->addr + ei->size; 1099 if (end != (resource_size_t)end) 1100 continue; 1101 1102 if (ei->type != E820_RAM && ei->type != E820_RESERVED_KERN) 1103 continue; 1104 1105 memblock_add(ei->addr, ei->size); 1106 } 1107 1108 memblock_analyze(); 1109 memblock_dump_all(); 1110 } 1111 1112 void __init memblock_find_dma_reserve(void) 1113 { 1114 #ifdef CONFIG_X86_64 1115 u64 free_size_pfn; 1116 u64 mem_size_pfn; 1117 /* 1118 * need to find out used area below MAX_DMA_PFN 1119 * need to use memblock to get free size in [0, MAX_DMA_PFN] 1120 * at first, and assume boot_mem will not take below MAX_DMA_PFN 1121 */ 1122 mem_size_pfn = memblock_x86_memory_in_range(0, MAX_DMA_PFN << PAGE_SHIFT) >> PAGE_SHIFT; 1123 free_size_pfn = memblock_x86_free_memory_in_range(0, MAX_DMA_PFN << PAGE_SHIFT) >> PAGE_SHIFT; 1124 set_dma_reserve(mem_size_pfn - free_size_pfn); 1125 #endif 1126 } 1127