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