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/bootmem.h> 15 #include <linux/ioport.h> 16 #include <linux/string.h> 17 #include <linux/kexec.h> 18 #include <linux/module.h> 19 #include <linux/mm.h> 20 #include <linux/pfn.h> 21 #include <linux/suspend.h> 22 #include <linux/firmware-map.h> 23 24 #include <asm/pgtable.h> 25 #include <asm/page.h> 26 #include <asm/e820.h> 27 #include <asm/proto.h> 28 #include <asm/setup.h> 29 #include <asm/trampoline.h> 30 31 /* 32 * The e820 map is the map that gets modified e.g. with command line parameters 33 * and that is also registered with modifications in the kernel resource tree 34 * with the iomem_resource as parent. 35 * 36 * The e820_saved is directly saved after the BIOS-provided memory map is 37 * copied. It doesn't get modified afterwards. It's registered for the 38 * /sys/firmware/memmap interface. 39 * 40 * That memory map is not modified and is used as base for kexec. The kexec'd 41 * kernel should get the same memory map as the firmware provides. Then the 42 * user can e.g. boot the original kernel with mem=1G while still booting the 43 * next kernel with full memory. 44 */ 45 struct e820map e820; 46 struct e820map e820_saved; 47 48 /* For PCI or other memory-mapped resources */ 49 unsigned long pci_mem_start = 0xaeedbabe; 50 #ifdef CONFIG_PCI 51 EXPORT_SYMBOL(pci_mem_start); 52 #endif 53 54 /* 55 * This function checks if any part of the range <start,end> is mapped 56 * with type. 57 */ 58 int 59 e820_any_mapped(u64 start, u64 end, unsigned type) 60 { 61 int i; 62 63 for (i = 0; i < e820.nr_map; i++) { 64 struct e820entry *ei = &e820.map[i]; 65 66 if (type && ei->type != type) 67 continue; 68 if (ei->addr >= end || ei->addr + ei->size <= start) 69 continue; 70 return 1; 71 } 72 return 0; 73 } 74 EXPORT_SYMBOL_GPL(e820_any_mapped); 75 76 /* 77 * This function checks if the entire range <start,end> is mapped with type. 78 * 79 * Note: this function only works correct if the e820 table is sorted and 80 * not-overlapping, which is the case 81 */ 82 int __init e820_all_mapped(u64 start, u64 end, unsigned type) 83 { 84 int i; 85 86 for (i = 0; i < e820.nr_map; i++) { 87 struct e820entry *ei = &e820.map[i]; 88 89 if (type && ei->type != type) 90 continue; 91 /* is the region (part) in overlap with the current region ?*/ 92 if (ei->addr >= end || ei->addr + ei->size <= start) 93 continue; 94 95 /* if the region is at the beginning of <start,end> we move 96 * start to the end of the region since it's ok until there 97 */ 98 if (ei->addr <= start) 99 start = ei->addr + ei->size; 100 /* 101 * if start is now at or beyond end, we're done, full 102 * coverage 103 */ 104 if (start >= end) 105 return 1; 106 } 107 return 0; 108 } 109 110 /* 111 * Add a memory region to the kernel e820 map. 112 */ 113 static void __init __e820_add_region(struct e820map *e820x, u64 start, u64 size, 114 int type) 115 { 116 int x = e820x->nr_map; 117 118 if (x >= ARRAY_SIZE(e820x->map)) { 119 printk(KERN_ERR "Ooops! Too many entries in the memory map!\n"); 120 return; 121 } 122 123 e820x->map[x].addr = start; 124 e820x->map[x].size = size; 125 e820x->map[x].type = type; 126 e820x->nr_map++; 127 } 128 129 void __init e820_add_region(u64 start, u64 size, int type) 130 { 131 __e820_add_region(&e820, start, size, type); 132 } 133 134 static void __init e820_print_type(u32 type) 135 { 136 switch (type) { 137 case E820_RAM: 138 case E820_RESERVED_KERN: 139 printk(KERN_CONT "(usable)"); 140 break; 141 case E820_RESERVED: 142 printk(KERN_CONT "(reserved)"); 143 break; 144 case E820_ACPI: 145 printk(KERN_CONT "(ACPI data)"); 146 break; 147 case E820_NVS: 148 printk(KERN_CONT "(ACPI NVS)"); 149 break; 150 case E820_UNUSABLE: 151 printk(KERN_CONT "(unusable)"); 152 break; 153 default: 154 printk(KERN_CONT "type %u", type); 155 break; 156 } 157 } 158 159 void __init e820_print_map(char *who) 160 { 161 int i; 162 163 for (i = 0; i < e820.nr_map; i++) { 164 printk(KERN_INFO " %s: %016Lx - %016Lx ", who, 165 (unsigned long long) e820.map[i].addr, 166 (unsigned long long) 167 (e820.map[i].addr + e820.map[i].size)); 168 e820_print_type(e820.map[i].type); 169 printk(KERN_CONT "\n"); 170 } 171 } 172 173 /* 174 * Sanitize the BIOS e820 map. 175 * 176 * Some e820 responses include overlapping entries. The following 177 * replaces the original e820 map with a new one, removing overlaps, 178 * and resolving conflicting memory types in favor of highest 179 * numbered type. 180 * 181 * The input parameter biosmap points to an array of 'struct 182 * e820entry' which on entry has elements in the range [0, *pnr_map) 183 * valid, and which has space for up to max_nr_map entries. 184 * On return, the resulting sanitized e820 map entries will be in 185 * overwritten in the same location, starting at biosmap. 186 * 187 * The integer pointed to by pnr_map must be valid on entry (the 188 * current number of valid entries located at biosmap) and will 189 * be updated on return, with the new number of valid entries 190 * (something no more than max_nr_map.) 191 * 192 * The return value from sanitize_e820_map() is zero if it 193 * successfully 'sanitized' the map entries passed in, and is -1 194 * if it did nothing, which can happen if either of (1) it was 195 * only passed one map entry, or (2) any of the input map entries 196 * were invalid (start + size < start, meaning that the size was 197 * so big the described memory range wrapped around through zero.) 198 * 199 * Visually we're performing the following 200 * (1,2,3,4 = memory types)... 201 * 202 * Sample memory map (w/overlaps): 203 * ____22__________________ 204 * ______________________4_ 205 * ____1111________________ 206 * _44_____________________ 207 * 11111111________________ 208 * ____________________33__ 209 * ___________44___________ 210 * __________33333_________ 211 * ______________22________ 212 * ___________________2222_ 213 * _________111111111______ 214 * _____________________11_ 215 * _________________4______ 216 * 217 * Sanitized equivalent (no overlap): 218 * 1_______________________ 219 * _44_____________________ 220 * ___1____________________ 221 * ____22__________________ 222 * ______11________________ 223 * _________1______________ 224 * __________3_____________ 225 * ___________44___________ 226 * _____________33_________ 227 * _______________2________ 228 * ________________1_______ 229 * _________________4______ 230 * ___________________2____ 231 * ____________________33__ 232 * ______________________4_ 233 */ 234 235 int __init sanitize_e820_map(struct e820entry *biosmap, int max_nr_map, 236 u32 *pnr_map) 237 { 238 struct change_member { 239 struct e820entry *pbios; /* pointer to original bios entry */ 240 unsigned long long addr; /* address for this change point */ 241 }; 242 static struct change_member change_point_list[2*E820_X_MAX] __initdata; 243 static struct change_member *change_point[2*E820_X_MAX] __initdata; 244 static struct e820entry *overlap_list[E820_X_MAX] __initdata; 245 static struct e820entry new_bios[E820_X_MAX] __initdata; 246 struct change_member *change_tmp; 247 unsigned long current_type, last_type; 248 unsigned long long last_addr; 249 int chgidx, still_changing; 250 int overlap_entries; 251 int new_bios_entry; 252 int old_nr, new_nr, chg_nr; 253 int i; 254 255 /* if there's only one memory region, don't bother */ 256 if (*pnr_map < 2) 257 return -1; 258 259 old_nr = *pnr_map; 260 BUG_ON(old_nr > max_nr_map); 261 262 /* bail out if we find any unreasonable addresses in bios map */ 263 for (i = 0; i < old_nr; i++) 264 if (biosmap[i].addr + biosmap[i].size < biosmap[i].addr) 265 return -1; 266 267 /* create pointers for initial change-point information (for sorting) */ 268 for (i = 0; i < 2 * old_nr; i++) 269 change_point[i] = &change_point_list[i]; 270 271 /* record all known change-points (starting and ending addresses), 272 omitting those that are for empty memory regions */ 273 chgidx = 0; 274 for (i = 0; i < old_nr; i++) { 275 if (biosmap[i].size != 0) { 276 change_point[chgidx]->addr = biosmap[i].addr; 277 change_point[chgidx++]->pbios = &biosmap[i]; 278 change_point[chgidx]->addr = biosmap[i].addr + 279 biosmap[i].size; 280 change_point[chgidx++]->pbios = &biosmap[i]; 281 } 282 } 283 chg_nr = chgidx; 284 285 /* sort change-point list by memory addresses (low -> high) */ 286 still_changing = 1; 287 while (still_changing) { 288 still_changing = 0; 289 for (i = 1; i < chg_nr; i++) { 290 unsigned long long curaddr, lastaddr; 291 unsigned long long curpbaddr, lastpbaddr; 292 293 curaddr = change_point[i]->addr; 294 lastaddr = change_point[i - 1]->addr; 295 curpbaddr = change_point[i]->pbios->addr; 296 lastpbaddr = change_point[i - 1]->pbios->addr; 297 298 /* 299 * swap entries, when: 300 * 301 * curaddr > lastaddr or 302 * curaddr == lastaddr and curaddr == curpbaddr and 303 * lastaddr != lastpbaddr 304 */ 305 if (curaddr < lastaddr || 306 (curaddr == lastaddr && curaddr == curpbaddr && 307 lastaddr != lastpbaddr)) { 308 change_tmp = change_point[i]; 309 change_point[i] = change_point[i-1]; 310 change_point[i-1] = change_tmp; 311 still_changing = 1; 312 } 313 } 314 } 315 316 /* create a new bios memory map, removing overlaps */ 317 overlap_entries = 0; /* number of entries in the overlap table */ 318 new_bios_entry = 0; /* index for creating new bios map entries */ 319 last_type = 0; /* start with undefined memory type */ 320 last_addr = 0; /* start with 0 as last starting address */ 321 322 /* loop through change-points, determining affect on the new bios map */ 323 for (chgidx = 0; chgidx < chg_nr; chgidx++) { 324 /* keep track of all overlapping bios entries */ 325 if (change_point[chgidx]->addr == 326 change_point[chgidx]->pbios->addr) { 327 /* 328 * add map entry to overlap list (> 1 entry 329 * implies an overlap) 330 */ 331 overlap_list[overlap_entries++] = 332 change_point[chgidx]->pbios; 333 } else { 334 /* 335 * remove entry from list (order independent, 336 * so swap with last) 337 */ 338 for (i = 0; i < overlap_entries; i++) { 339 if (overlap_list[i] == 340 change_point[chgidx]->pbios) 341 overlap_list[i] = 342 overlap_list[overlap_entries-1]; 343 } 344 overlap_entries--; 345 } 346 /* 347 * if there are overlapping entries, decide which 348 * "type" to use (larger value takes precedence -- 349 * 1=usable, 2,3,4,4+=unusable) 350 */ 351 current_type = 0; 352 for (i = 0; i < overlap_entries; i++) 353 if (overlap_list[i]->type > current_type) 354 current_type = overlap_list[i]->type; 355 /* 356 * continue building up new bios map based on this 357 * information 358 */ 359 if (current_type != last_type) { 360 if (last_type != 0) { 361 new_bios[new_bios_entry].size = 362 change_point[chgidx]->addr - last_addr; 363 /* 364 * move forward only if the new size 365 * was non-zero 366 */ 367 if (new_bios[new_bios_entry].size != 0) 368 /* 369 * no more space left for new 370 * bios entries ? 371 */ 372 if (++new_bios_entry >= max_nr_map) 373 break; 374 } 375 if (current_type != 0) { 376 new_bios[new_bios_entry].addr = 377 change_point[chgidx]->addr; 378 new_bios[new_bios_entry].type = current_type; 379 last_addr = change_point[chgidx]->addr; 380 } 381 last_type = current_type; 382 } 383 } 384 /* retain count for new bios entries */ 385 new_nr = new_bios_entry; 386 387 /* copy new bios mapping into original location */ 388 memcpy(biosmap, new_bios, new_nr * sizeof(struct e820entry)); 389 *pnr_map = new_nr; 390 391 return 0; 392 } 393 394 static int __init __append_e820_map(struct e820entry *biosmap, int nr_map) 395 { 396 while (nr_map) { 397 u64 start = biosmap->addr; 398 u64 size = biosmap->size; 399 u64 end = start + size; 400 u32 type = biosmap->type; 401 402 /* Overflow in 64 bits? Ignore the memory map. */ 403 if (start > end) 404 return -1; 405 406 e820_add_region(start, size, type); 407 408 biosmap++; 409 nr_map--; 410 } 411 return 0; 412 } 413 414 /* 415 * Copy the BIOS e820 map into a safe place. 416 * 417 * Sanity-check it while we're at it.. 418 * 419 * If we're lucky and live on a modern system, the setup code 420 * will have given us a memory map that we can use to properly 421 * set up memory. If we aren't, we'll fake a memory map. 422 */ 423 static int __init append_e820_map(struct e820entry *biosmap, int nr_map) 424 { 425 /* Only one memory region (or negative)? Ignore it */ 426 if (nr_map < 2) 427 return -1; 428 429 return __append_e820_map(biosmap, nr_map); 430 } 431 432 static u64 __init __e820_update_range(struct e820map *e820x, u64 start, 433 u64 size, unsigned old_type, 434 unsigned new_type) 435 { 436 u64 end; 437 unsigned int i; 438 u64 real_updated_size = 0; 439 440 BUG_ON(old_type == new_type); 441 442 if (size > (ULLONG_MAX - start)) 443 size = ULLONG_MAX - start; 444 445 end = start + size; 446 printk(KERN_DEBUG "e820 update range: %016Lx - %016Lx ", 447 (unsigned long long) start, 448 (unsigned long long) end); 449 e820_print_type(old_type); 450 printk(KERN_CONT " ==> "); 451 e820_print_type(new_type); 452 printk(KERN_CONT "\n"); 453 454 for (i = 0; i < e820x->nr_map; i++) { 455 struct e820entry *ei = &e820x->map[i]; 456 u64 final_start, final_end; 457 u64 ei_end; 458 459 if (ei->type != old_type) 460 continue; 461 462 ei_end = ei->addr + ei->size; 463 /* totally covered by new range? */ 464 if (ei->addr >= start && ei_end <= end) { 465 ei->type = new_type; 466 real_updated_size += ei->size; 467 continue; 468 } 469 470 /* new range is totally covered? */ 471 if (ei->addr < start && ei_end > end) { 472 __e820_add_region(e820x, start, size, new_type); 473 __e820_add_region(e820x, end, ei_end - end, ei->type); 474 ei->size = start - ei->addr; 475 real_updated_size += size; 476 continue; 477 } 478 479 /* partially covered */ 480 final_start = max(start, ei->addr); 481 final_end = min(end, ei_end); 482 if (final_start >= final_end) 483 continue; 484 485 __e820_add_region(e820x, final_start, final_end - final_start, 486 new_type); 487 488 real_updated_size += final_end - final_start; 489 490 /* 491 * left range could be head or tail, so need to update 492 * size at first. 493 */ 494 ei->size -= final_end - final_start; 495 if (ei->addr < final_start) 496 continue; 497 ei->addr = final_end; 498 } 499 return real_updated_size; 500 } 501 502 u64 __init e820_update_range(u64 start, u64 size, unsigned old_type, 503 unsigned new_type) 504 { 505 return __e820_update_range(&e820, start, size, old_type, new_type); 506 } 507 508 static u64 __init e820_update_range_saved(u64 start, u64 size, 509 unsigned old_type, unsigned new_type) 510 { 511 return __e820_update_range(&e820_saved, start, size, old_type, 512 new_type); 513 } 514 515 /* make e820 not cover the range */ 516 u64 __init e820_remove_range(u64 start, u64 size, unsigned old_type, 517 int checktype) 518 { 519 int i; 520 u64 end; 521 u64 real_removed_size = 0; 522 523 if (size > (ULLONG_MAX - start)) 524 size = ULLONG_MAX - start; 525 526 end = start + size; 527 printk(KERN_DEBUG "e820 remove range: %016Lx - %016Lx ", 528 (unsigned long long) start, 529 (unsigned long long) end); 530 e820_print_type(old_type); 531 printk(KERN_CONT "\n"); 532 533 for (i = 0; i < e820.nr_map; i++) { 534 struct e820entry *ei = &e820.map[i]; 535 u64 final_start, final_end; 536 537 if (checktype && ei->type != old_type) 538 continue; 539 /* totally covered? */ 540 if (ei->addr >= start && 541 (ei->addr + ei->size) <= (start + size)) { 542 real_removed_size += ei->size; 543 memset(ei, 0, sizeof(struct e820entry)); 544 continue; 545 } 546 /* partially covered */ 547 final_start = max(start, ei->addr); 548 final_end = min(start + size, ei->addr + ei->size); 549 if (final_start >= final_end) 550 continue; 551 real_removed_size += final_end - final_start; 552 553 ei->size -= final_end - final_start; 554 if (ei->addr < final_start) 555 continue; 556 ei->addr = final_end; 557 } 558 return real_removed_size; 559 } 560 561 void __init update_e820(void) 562 { 563 u32 nr_map; 564 565 nr_map = e820.nr_map; 566 if (sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &nr_map)) 567 return; 568 e820.nr_map = nr_map; 569 printk(KERN_INFO "modified physical RAM map:\n"); 570 e820_print_map("modified"); 571 } 572 static void __init update_e820_saved(void) 573 { 574 u32 nr_map; 575 576 nr_map = e820_saved.nr_map; 577 if (sanitize_e820_map(e820_saved.map, ARRAY_SIZE(e820_saved.map), &nr_map)) 578 return; 579 e820_saved.nr_map = nr_map; 580 } 581 #define MAX_GAP_END 0x100000000ull 582 /* 583 * Search for a gap in the e820 memory space from start_addr to end_addr. 584 */ 585 __init int e820_search_gap(unsigned long *gapstart, unsigned long *gapsize, 586 unsigned long start_addr, unsigned long long end_addr) 587 { 588 unsigned long long last; 589 int i = e820.nr_map; 590 int found = 0; 591 592 last = (end_addr && end_addr < MAX_GAP_END) ? end_addr : MAX_GAP_END; 593 594 while (--i >= 0) { 595 unsigned long long start = e820.map[i].addr; 596 unsigned long long end = start + e820.map[i].size; 597 598 if (end < start_addr) 599 continue; 600 601 /* 602 * Since "last" is at most 4GB, we know we'll 603 * fit in 32 bits if this condition is true 604 */ 605 if (last > end) { 606 unsigned long gap = last - end; 607 608 if (gap >= *gapsize) { 609 *gapsize = gap; 610 *gapstart = end; 611 found = 1; 612 } 613 } 614 if (start < last) 615 last = start; 616 } 617 return found; 618 } 619 620 /* 621 * Search for the biggest gap in the low 32 bits of the e820 622 * memory space. We pass this space to PCI to assign MMIO resources 623 * for hotplug or unconfigured devices in. 624 * Hopefully the BIOS let enough space left. 625 */ 626 __init void e820_setup_gap(void) 627 { 628 unsigned long gapstart, gapsize; 629 int found; 630 631 gapstart = 0x10000000; 632 gapsize = 0x400000; 633 found = e820_search_gap(&gapstart, &gapsize, 0, MAX_GAP_END); 634 635 #ifdef CONFIG_X86_64 636 if (!found) { 637 gapstart = (max_pfn << PAGE_SHIFT) + 1024*1024; 638 printk(KERN_ERR 639 "PCI: Warning: Cannot find a gap in the 32bit address range\n" 640 "PCI: Unassigned devices with 32bit resource registers may break!\n"); 641 } 642 #endif 643 644 /* 645 * e820_reserve_resources_late protect stolen RAM already 646 */ 647 pci_mem_start = gapstart; 648 649 printk(KERN_INFO 650 "Allocating PCI resources starting at %lx (gap: %lx:%lx)\n", 651 pci_mem_start, gapstart, gapsize); 652 } 653 654 /** 655 * Because of the size limitation of struct boot_params, only first 656 * 128 E820 memory entries are passed to kernel via 657 * boot_params.e820_map, others are passed via SETUP_E820_EXT node of 658 * linked list of struct setup_data, which is parsed here. 659 */ 660 void __init parse_e820_ext(struct setup_data *sdata, unsigned long pa_data) 661 { 662 u32 map_len; 663 int entries; 664 struct e820entry *extmap; 665 666 entries = sdata->len / sizeof(struct e820entry); 667 map_len = sdata->len + sizeof(struct setup_data); 668 if (map_len > PAGE_SIZE) 669 sdata = early_ioremap(pa_data, map_len); 670 extmap = (struct e820entry *)(sdata->data); 671 __append_e820_map(extmap, entries); 672 sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map); 673 if (map_len > PAGE_SIZE) 674 early_iounmap(sdata, map_len); 675 printk(KERN_INFO "extended physical RAM map:\n"); 676 e820_print_map("extended"); 677 } 678 679 #if defined(CONFIG_X86_64) || \ 680 (defined(CONFIG_X86_32) && defined(CONFIG_HIBERNATION)) 681 /** 682 * Find the ranges of physical addresses that do not correspond to 683 * e820 RAM areas and mark the corresponding pages as nosave for 684 * hibernation (32 bit) or software suspend and suspend to RAM (64 bit). 685 * 686 * This function requires the e820 map to be sorted and without any 687 * overlapping entries and assumes the first e820 area to be RAM. 688 */ 689 void __init e820_mark_nosave_regions(unsigned long limit_pfn) 690 { 691 int i; 692 unsigned long pfn; 693 694 pfn = PFN_DOWN(e820.map[0].addr + e820.map[0].size); 695 for (i = 1; i < e820.nr_map; i++) { 696 struct e820entry *ei = &e820.map[i]; 697 698 if (pfn < PFN_UP(ei->addr)) 699 register_nosave_region(pfn, PFN_UP(ei->addr)); 700 701 pfn = PFN_DOWN(ei->addr + ei->size); 702 if (ei->type != E820_RAM && ei->type != E820_RESERVED_KERN) 703 register_nosave_region(PFN_UP(ei->addr), pfn); 704 705 if (pfn >= limit_pfn) 706 break; 707 } 708 } 709 #endif 710 711 #ifdef CONFIG_HIBERNATION 712 /** 713 * Mark ACPI NVS memory region, so that we can save/restore it during 714 * hibernation and the subsequent resume. 715 */ 716 static int __init e820_mark_nvs_memory(void) 717 { 718 int i; 719 720 for (i = 0; i < e820.nr_map; i++) { 721 struct e820entry *ei = &e820.map[i]; 722 723 if (ei->type == E820_NVS) 724 hibernate_nvs_register(ei->addr, ei->size); 725 } 726 727 return 0; 728 } 729 core_initcall(e820_mark_nvs_memory); 730 #endif 731 732 /* 733 * Early reserved memory areas. 734 */ 735 #define MAX_EARLY_RES 32 736 737 struct early_res { 738 u64 start, end; 739 char name[16]; 740 char overlap_ok; 741 }; 742 static struct early_res early_res[MAX_EARLY_RES] __initdata = { 743 { 0, PAGE_SIZE, "BIOS data page", 1 }, /* BIOS data page */ 744 #if defined(CONFIG_X86_32) && defined(CONFIG_X86_TRAMPOLINE) 745 /* 746 * But first pinch a few for the stack/trampoline stuff 747 * FIXME: Don't need the extra page at 4K, but need to fix 748 * trampoline before removing it. (see the GDT stuff) 749 */ 750 { PAGE_SIZE, PAGE_SIZE + PAGE_SIZE, "EX TRAMPOLINE", 1 }, 751 #endif 752 753 {} 754 }; 755 756 static int __init find_overlapped_early(u64 start, u64 end) 757 { 758 int i; 759 struct early_res *r; 760 761 for (i = 0; i < MAX_EARLY_RES && early_res[i].end; i++) { 762 r = &early_res[i]; 763 if (end > r->start && start < r->end) 764 break; 765 } 766 767 return i; 768 } 769 770 /* 771 * Drop the i-th range from the early reservation map, 772 * by copying any higher ranges down one over it, and 773 * clearing what had been the last slot. 774 */ 775 static void __init drop_range(int i) 776 { 777 int j; 778 779 for (j = i + 1; j < MAX_EARLY_RES && early_res[j].end; j++) 780 ; 781 782 memmove(&early_res[i], &early_res[i + 1], 783 (j - 1 - i) * sizeof(struct early_res)); 784 785 early_res[j - 1].end = 0; 786 } 787 788 /* 789 * Split any existing ranges that: 790 * 1) are marked 'overlap_ok', and 791 * 2) overlap with the stated range [start, end) 792 * into whatever portion (if any) of the existing range is entirely 793 * below or entirely above the stated range. Drop the portion 794 * of the existing range that overlaps with the stated range, 795 * which will allow the caller of this routine to then add that 796 * stated range without conflicting with any existing range. 797 */ 798 static void __init drop_overlaps_that_are_ok(u64 start, u64 end) 799 { 800 int i; 801 struct early_res *r; 802 u64 lower_start, lower_end; 803 u64 upper_start, upper_end; 804 char name[16]; 805 806 for (i = 0; i < MAX_EARLY_RES && early_res[i].end; i++) { 807 r = &early_res[i]; 808 809 /* Continue past non-overlapping ranges */ 810 if (end <= r->start || start >= r->end) 811 continue; 812 813 /* 814 * Leave non-ok overlaps as is; let caller 815 * panic "Overlapping early reservations" 816 * when it hits this overlap. 817 */ 818 if (!r->overlap_ok) 819 return; 820 821 /* 822 * We have an ok overlap. We will drop it from the early 823 * reservation map, and add back in any non-overlapping 824 * portions (lower or upper) as separate, overlap_ok, 825 * non-overlapping ranges. 826 */ 827 828 /* 1. Note any non-overlapping (lower or upper) ranges. */ 829 strncpy(name, r->name, sizeof(name) - 1); 830 831 lower_start = lower_end = 0; 832 upper_start = upper_end = 0; 833 if (r->start < start) { 834 lower_start = r->start; 835 lower_end = start; 836 } 837 if (r->end > end) { 838 upper_start = end; 839 upper_end = r->end; 840 } 841 842 /* 2. Drop the original ok overlapping range */ 843 drop_range(i); 844 845 i--; /* resume for-loop on copied down entry */ 846 847 /* 3. Add back in any non-overlapping ranges. */ 848 if (lower_end) 849 reserve_early_overlap_ok(lower_start, lower_end, name); 850 if (upper_end) 851 reserve_early_overlap_ok(upper_start, upper_end, name); 852 } 853 } 854 855 static void __init __reserve_early(u64 start, u64 end, char *name, 856 int overlap_ok) 857 { 858 int i; 859 struct early_res *r; 860 861 i = find_overlapped_early(start, end); 862 if (i >= MAX_EARLY_RES) 863 panic("Too many early reservations"); 864 r = &early_res[i]; 865 if (r->end) 866 panic("Overlapping early reservations " 867 "%llx-%llx %s to %llx-%llx %s\n", 868 start, end - 1, name?name:"", r->start, 869 r->end - 1, r->name); 870 r->start = start; 871 r->end = end; 872 r->overlap_ok = overlap_ok; 873 if (name) 874 strncpy(r->name, name, sizeof(r->name) - 1); 875 } 876 877 /* 878 * A few early reservtations come here. 879 * 880 * The 'overlap_ok' in the name of this routine does -not- mean it 881 * is ok for these reservations to overlap an earlier reservation. 882 * Rather it means that it is ok for subsequent reservations to 883 * overlap this one. 884 * 885 * Use this entry point to reserve early ranges when you are doing 886 * so out of "Paranoia", reserving perhaps more memory than you need, 887 * just in case, and don't mind a subsequent overlapping reservation 888 * that is known to be needed. 889 * 890 * The drop_overlaps_that_are_ok() call here isn't really needed. 891 * It would be needed if we had two colliding 'overlap_ok' 892 * reservations, so that the second such would not panic on the 893 * overlap with the first. We don't have any such as of this 894 * writing, but might as well tolerate such if it happens in 895 * the future. 896 */ 897 void __init reserve_early_overlap_ok(u64 start, u64 end, char *name) 898 { 899 drop_overlaps_that_are_ok(start, end); 900 __reserve_early(start, end, name, 1); 901 } 902 903 /* 904 * Most early reservations come here. 905 * 906 * We first have drop_overlaps_that_are_ok() drop any pre-existing 907 * 'overlap_ok' ranges, so that we can then reserve this memory 908 * range without risk of panic'ing on an overlapping overlap_ok 909 * early reservation. 910 */ 911 void __init reserve_early(u64 start, u64 end, char *name) 912 { 913 if (start >= end) 914 return; 915 916 drop_overlaps_that_are_ok(start, end); 917 __reserve_early(start, end, name, 0); 918 } 919 920 void __init free_early(u64 start, u64 end) 921 { 922 struct early_res *r; 923 int i; 924 925 i = find_overlapped_early(start, end); 926 r = &early_res[i]; 927 if (i >= MAX_EARLY_RES || r->end != end || r->start != start) 928 panic("free_early on not reserved area: %llx-%llx!", 929 start, end - 1); 930 931 drop_range(i); 932 } 933 934 void __init early_res_to_bootmem(u64 start, u64 end) 935 { 936 int i, count; 937 u64 final_start, final_end; 938 939 count = 0; 940 for (i = 0; i < MAX_EARLY_RES && early_res[i].end; i++) 941 count++; 942 943 printk(KERN_INFO "(%d early reservations) ==> bootmem [%010llx - %010llx]\n", 944 count, start, end); 945 for (i = 0; i < count; i++) { 946 struct early_res *r = &early_res[i]; 947 printk(KERN_INFO " #%d [%010llx - %010llx] %16s", i, 948 r->start, r->end, r->name); 949 final_start = max(start, r->start); 950 final_end = min(end, r->end); 951 if (final_start >= final_end) { 952 printk(KERN_CONT "\n"); 953 continue; 954 } 955 printk(KERN_CONT " ==> [%010llx - %010llx]\n", 956 final_start, final_end); 957 reserve_bootmem_generic(final_start, final_end - final_start, 958 BOOTMEM_DEFAULT); 959 } 960 } 961 962 /* Check for already reserved areas */ 963 static inline int __init bad_addr(u64 *addrp, u64 size, u64 align) 964 { 965 int i; 966 u64 addr = *addrp; 967 int changed = 0; 968 struct early_res *r; 969 again: 970 i = find_overlapped_early(addr, addr + size); 971 r = &early_res[i]; 972 if (i < MAX_EARLY_RES && r->end) { 973 *addrp = addr = round_up(r->end, align); 974 changed = 1; 975 goto again; 976 } 977 return changed; 978 } 979 980 /* Check for already reserved areas */ 981 static inline int __init bad_addr_size(u64 *addrp, u64 *sizep, u64 align) 982 { 983 int i; 984 u64 addr = *addrp, last; 985 u64 size = *sizep; 986 int changed = 0; 987 again: 988 last = addr + size; 989 for (i = 0; i < MAX_EARLY_RES && early_res[i].end; i++) { 990 struct early_res *r = &early_res[i]; 991 if (last > r->start && addr < r->start) { 992 size = r->start - addr; 993 changed = 1; 994 goto again; 995 } 996 if (last > r->end && addr < r->end) { 997 addr = round_up(r->end, align); 998 size = last - addr; 999 changed = 1; 1000 goto again; 1001 } 1002 if (last <= r->end && addr >= r->start) { 1003 (*sizep)++; 1004 return 0; 1005 } 1006 } 1007 if (changed) { 1008 *addrp = addr; 1009 *sizep = size; 1010 } 1011 return changed; 1012 } 1013 1014 /* 1015 * Find a free area with specified alignment in a specific range. 1016 */ 1017 u64 __init find_e820_area(u64 start, u64 end, u64 size, u64 align) 1018 { 1019 int i; 1020 1021 for (i = 0; i < e820.nr_map; i++) { 1022 struct e820entry *ei = &e820.map[i]; 1023 u64 addr, last; 1024 u64 ei_last; 1025 1026 if (ei->type != E820_RAM) 1027 continue; 1028 addr = round_up(ei->addr, align); 1029 ei_last = ei->addr + ei->size; 1030 if (addr < start) 1031 addr = round_up(start, align); 1032 if (addr >= ei_last) 1033 continue; 1034 while (bad_addr(&addr, size, align) && addr+size <= ei_last) 1035 ; 1036 last = addr + size; 1037 if (last > ei_last) 1038 continue; 1039 if (last > end) 1040 continue; 1041 return addr; 1042 } 1043 return -1ULL; 1044 } 1045 1046 /* 1047 * Find next free range after *start 1048 */ 1049 u64 __init find_e820_area_size(u64 start, u64 *sizep, u64 align) 1050 { 1051 int i; 1052 1053 for (i = 0; i < e820.nr_map; i++) { 1054 struct e820entry *ei = &e820.map[i]; 1055 u64 addr, last; 1056 u64 ei_last; 1057 1058 if (ei->type != E820_RAM) 1059 continue; 1060 addr = round_up(ei->addr, align); 1061 ei_last = ei->addr + ei->size; 1062 if (addr < start) 1063 addr = round_up(start, align); 1064 if (addr >= ei_last) 1065 continue; 1066 *sizep = ei_last - addr; 1067 while (bad_addr_size(&addr, sizep, align) && 1068 addr + *sizep <= ei_last) 1069 ; 1070 last = addr + *sizep; 1071 if (last > ei_last) 1072 continue; 1073 return addr; 1074 } 1075 1076 return -1ULL; 1077 } 1078 1079 /* 1080 * pre allocated 4k and reserved it in e820 1081 */ 1082 u64 __init early_reserve_e820(u64 startt, u64 sizet, u64 align) 1083 { 1084 u64 size = 0; 1085 u64 addr; 1086 u64 start; 1087 1088 for (start = startt; ; start += size) { 1089 start = find_e820_area_size(start, &size, align); 1090 if (!(start + 1)) 1091 return 0; 1092 if (size >= sizet) 1093 break; 1094 } 1095 1096 #ifdef CONFIG_X86_32 1097 if (start >= MAXMEM) 1098 return 0; 1099 if (start + size > MAXMEM) 1100 size = MAXMEM - start; 1101 #endif 1102 1103 addr = round_down(start + size - sizet, align); 1104 if (addr < start) 1105 return 0; 1106 e820_update_range(addr, sizet, E820_RAM, E820_RESERVED); 1107 e820_update_range_saved(addr, sizet, E820_RAM, E820_RESERVED); 1108 printk(KERN_INFO "update e820 for early_reserve_e820\n"); 1109 update_e820(); 1110 update_e820_saved(); 1111 1112 return addr; 1113 } 1114 1115 #ifdef CONFIG_X86_32 1116 # ifdef CONFIG_X86_PAE 1117 # define MAX_ARCH_PFN (1ULL<<(36-PAGE_SHIFT)) 1118 # else 1119 # define MAX_ARCH_PFN (1ULL<<(32-PAGE_SHIFT)) 1120 # endif 1121 #else /* CONFIG_X86_32 */ 1122 # define MAX_ARCH_PFN MAXMEM>>PAGE_SHIFT 1123 #endif 1124 1125 /* 1126 * Find the highest page frame number we have available 1127 */ 1128 static unsigned long __init e820_end_pfn(unsigned long limit_pfn, unsigned type) 1129 { 1130 int i; 1131 unsigned long last_pfn = 0; 1132 unsigned long max_arch_pfn = MAX_ARCH_PFN; 1133 1134 for (i = 0; i < e820.nr_map; i++) { 1135 struct e820entry *ei = &e820.map[i]; 1136 unsigned long start_pfn; 1137 unsigned long end_pfn; 1138 1139 if (ei->type != type) 1140 continue; 1141 1142 start_pfn = ei->addr >> PAGE_SHIFT; 1143 end_pfn = (ei->addr + ei->size) >> PAGE_SHIFT; 1144 1145 if (start_pfn >= limit_pfn) 1146 continue; 1147 if (end_pfn > limit_pfn) { 1148 last_pfn = limit_pfn; 1149 break; 1150 } 1151 if (end_pfn > last_pfn) 1152 last_pfn = end_pfn; 1153 } 1154 1155 if (last_pfn > max_arch_pfn) 1156 last_pfn = max_arch_pfn; 1157 1158 printk(KERN_INFO "last_pfn = %#lx max_arch_pfn = %#lx\n", 1159 last_pfn, max_arch_pfn); 1160 return last_pfn; 1161 } 1162 unsigned long __init e820_end_of_ram_pfn(void) 1163 { 1164 return e820_end_pfn(MAX_ARCH_PFN, E820_RAM); 1165 } 1166 1167 unsigned long __init e820_end_of_low_ram_pfn(void) 1168 { 1169 return e820_end_pfn(1UL<<(32 - PAGE_SHIFT), E820_RAM); 1170 } 1171 /* 1172 * Finds an active region in the address range from start_pfn to last_pfn and 1173 * returns its range in ei_startpfn and ei_endpfn for the e820 entry. 1174 */ 1175 int __init e820_find_active_region(const struct e820entry *ei, 1176 unsigned long start_pfn, 1177 unsigned long last_pfn, 1178 unsigned long *ei_startpfn, 1179 unsigned long *ei_endpfn) 1180 { 1181 u64 align = PAGE_SIZE; 1182 1183 *ei_startpfn = round_up(ei->addr, align) >> PAGE_SHIFT; 1184 *ei_endpfn = round_down(ei->addr + ei->size, align) >> PAGE_SHIFT; 1185 1186 /* Skip map entries smaller than a page */ 1187 if (*ei_startpfn >= *ei_endpfn) 1188 return 0; 1189 1190 /* Skip if map is outside the node */ 1191 if (ei->type != E820_RAM || *ei_endpfn <= start_pfn || 1192 *ei_startpfn >= last_pfn) 1193 return 0; 1194 1195 /* Check for overlaps */ 1196 if (*ei_startpfn < start_pfn) 1197 *ei_startpfn = start_pfn; 1198 if (*ei_endpfn > last_pfn) 1199 *ei_endpfn = last_pfn; 1200 1201 return 1; 1202 } 1203 1204 /* Walk the e820 map and register active regions within a node */ 1205 void __init e820_register_active_regions(int nid, unsigned long start_pfn, 1206 unsigned long last_pfn) 1207 { 1208 unsigned long ei_startpfn; 1209 unsigned long ei_endpfn; 1210 int i; 1211 1212 for (i = 0; i < e820.nr_map; i++) 1213 if (e820_find_active_region(&e820.map[i], 1214 start_pfn, last_pfn, 1215 &ei_startpfn, &ei_endpfn)) 1216 add_active_range(nid, ei_startpfn, ei_endpfn); 1217 } 1218 1219 /* 1220 * Find the hole size (in bytes) in the memory range. 1221 * @start: starting address of the memory range to scan 1222 * @end: ending address of the memory range to scan 1223 */ 1224 u64 __init e820_hole_size(u64 start, u64 end) 1225 { 1226 unsigned long start_pfn = start >> PAGE_SHIFT; 1227 unsigned long last_pfn = end >> PAGE_SHIFT; 1228 unsigned long ei_startpfn, ei_endpfn, ram = 0; 1229 int i; 1230 1231 for (i = 0; i < e820.nr_map; i++) { 1232 if (e820_find_active_region(&e820.map[i], 1233 start_pfn, last_pfn, 1234 &ei_startpfn, &ei_endpfn)) 1235 ram += ei_endpfn - ei_startpfn; 1236 } 1237 return end - start - ((u64)ram << PAGE_SHIFT); 1238 } 1239 1240 static void early_panic(char *msg) 1241 { 1242 early_printk(msg); 1243 panic(msg); 1244 } 1245 1246 static int userdef __initdata; 1247 1248 /* "mem=nopentium" disables the 4MB page tables. */ 1249 static int __init parse_memopt(char *p) 1250 { 1251 u64 mem_size; 1252 1253 if (!p) 1254 return -EINVAL; 1255 1256 #ifdef CONFIG_X86_32 1257 if (!strcmp(p, "nopentium")) { 1258 setup_clear_cpu_cap(X86_FEATURE_PSE); 1259 return 0; 1260 } 1261 #endif 1262 1263 userdef = 1; 1264 mem_size = memparse(p, &p); 1265 e820_remove_range(mem_size, ULLONG_MAX - mem_size, E820_RAM, 1); 1266 1267 return 0; 1268 } 1269 early_param("mem", parse_memopt); 1270 1271 static int __init parse_memmap_opt(char *p) 1272 { 1273 char *oldp; 1274 u64 start_at, mem_size; 1275 1276 if (!p) 1277 return -EINVAL; 1278 1279 if (!strncmp(p, "exactmap", 8)) { 1280 #ifdef CONFIG_CRASH_DUMP 1281 /* 1282 * If we are doing a crash dump, we still need to know 1283 * the real mem size before original memory map is 1284 * reset. 1285 */ 1286 saved_max_pfn = e820_end_of_ram_pfn(); 1287 #endif 1288 e820.nr_map = 0; 1289 userdef = 1; 1290 return 0; 1291 } 1292 1293 oldp = p; 1294 mem_size = memparse(p, &p); 1295 if (p == oldp) 1296 return -EINVAL; 1297 1298 userdef = 1; 1299 if (*p == '@') { 1300 start_at = memparse(p+1, &p); 1301 e820_add_region(start_at, mem_size, E820_RAM); 1302 } else if (*p == '#') { 1303 start_at = memparse(p+1, &p); 1304 e820_add_region(start_at, mem_size, E820_ACPI); 1305 } else if (*p == '$') { 1306 start_at = memparse(p+1, &p); 1307 e820_add_region(start_at, mem_size, E820_RESERVED); 1308 } else 1309 e820_remove_range(mem_size, ULLONG_MAX - mem_size, E820_RAM, 1); 1310 1311 return *p == '\0' ? 0 : -EINVAL; 1312 } 1313 early_param("memmap", parse_memmap_opt); 1314 1315 void __init finish_e820_parsing(void) 1316 { 1317 if (userdef) { 1318 u32 nr = e820.nr_map; 1319 1320 if (sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &nr) < 0) 1321 early_panic("Invalid user supplied memory map"); 1322 e820.nr_map = nr; 1323 1324 printk(KERN_INFO "user-defined physical RAM map:\n"); 1325 e820_print_map("user"); 1326 } 1327 } 1328 1329 static inline const char *e820_type_to_string(int e820_type) 1330 { 1331 switch (e820_type) { 1332 case E820_RESERVED_KERN: 1333 case E820_RAM: return "System RAM"; 1334 case E820_ACPI: return "ACPI Tables"; 1335 case E820_NVS: return "ACPI Non-volatile Storage"; 1336 case E820_UNUSABLE: return "Unusable memory"; 1337 default: return "reserved"; 1338 } 1339 } 1340 1341 /* 1342 * Mark e820 reserved areas as busy for the resource manager. 1343 */ 1344 static struct resource __initdata *e820_res; 1345 void __init e820_reserve_resources(void) 1346 { 1347 int i; 1348 struct resource *res; 1349 u64 end; 1350 1351 res = alloc_bootmem(sizeof(struct resource) * e820.nr_map); 1352 e820_res = res; 1353 for (i = 0; i < e820.nr_map; i++) { 1354 end = e820.map[i].addr + e820.map[i].size - 1; 1355 if (end != (resource_size_t)end) { 1356 res++; 1357 continue; 1358 } 1359 res->name = e820_type_to_string(e820.map[i].type); 1360 res->start = e820.map[i].addr; 1361 res->end = end; 1362 1363 res->flags = IORESOURCE_MEM; 1364 1365 /* 1366 * don't register the region that could be conflicted with 1367 * pci device BAR resource and insert them later in 1368 * pcibios_resource_survey() 1369 */ 1370 if (e820.map[i].type != E820_RESERVED || res->start < (1ULL<<20)) { 1371 res->flags |= IORESOURCE_BUSY; 1372 insert_resource(&iomem_resource, res); 1373 } 1374 res++; 1375 } 1376 1377 for (i = 0; i < e820_saved.nr_map; i++) { 1378 struct e820entry *entry = &e820_saved.map[i]; 1379 firmware_map_add_early(entry->addr, 1380 entry->addr + entry->size - 1, 1381 e820_type_to_string(entry->type)); 1382 } 1383 } 1384 1385 /* How much should we pad RAM ending depending on where it is? */ 1386 static unsigned long ram_alignment(resource_size_t pos) 1387 { 1388 unsigned long mb = pos >> 20; 1389 1390 /* To 64kB in the first megabyte */ 1391 if (!mb) 1392 return 64*1024; 1393 1394 /* To 1MB in the first 16MB */ 1395 if (mb < 16) 1396 return 1024*1024; 1397 1398 /* To 64MB for anything above that */ 1399 return 64*1024*1024; 1400 } 1401 1402 #define MAX_RESOURCE_SIZE ((resource_size_t)-1) 1403 1404 void __init e820_reserve_resources_late(void) 1405 { 1406 int i; 1407 struct resource *res; 1408 1409 res = e820_res; 1410 for (i = 0; i < e820.nr_map; i++) { 1411 if (!res->parent && res->end) 1412 insert_resource_expand_to_fit(&iomem_resource, res); 1413 res++; 1414 } 1415 1416 /* 1417 * Try to bump up RAM regions to reasonable boundaries to 1418 * avoid stolen RAM: 1419 */ 1420 for (i = 0; i < e820.nr_map; i++) { 1421 struct e820entry *entry = &e820.map[i]; 1422 u64 start, end; 1423 1424 if (entry->type != E820_RAM) 1425 continue; 1426 start = entry->addr + entry->size; 1427 end = round_up(start, ram_alignment(start)) - 1; 1428 if (end > MAX_RESOURCE_SIZE) 1429 end = MAX_RESOURCE_SIZE; 1430 if (start >= end) 1431 continue; 1432 reserve_region_with_split(&iomem_resource, start, end, 1433 "RAM buffer"); 1434 } 1435 } 1436 1437 char *__init default_machine_specific_memory_setup(void) 1438 { 1439 char *who = "BIOS-e820"; 1440 u32 new_nr; 1441 /* 1442 * Try to copy the BIOS-supplied E820-map. 1443 * 1444 * Otherwise fake a memory map; one section from 0k->640k, 1445 * the next section from 1mb->appropriate_mem_k 1446 */ 1447 new_nr = boot_params.e820_entries; 1448 sanitize_e820_map(boot_params.e820_map, 1449 ARRAY_SIZE(boot_params.e820_map), 1450 &new_nr); 1451 boot_params.e820_entries = new_nr; 1452 if (append_e820_map(boot_params.e820_map, boot_params.e820_entries) 1453 < 0) { 1454 u64 mem_size; 1455 1456 /* compare results from other methods and take the greater */ 1457 if (boot_params.alt_mem_k 1458 < boot_params.screen_info.ext_mem_k) { 1459 mem_size = boot_params.screen_info.ext_mem_k; 1460 who = "BIOS-88"; 1461 } else { 1462 mem_size = boot_params.alt_mem_k; 1463 who = "BIOS-e801"; 1464 } 1465 1466 e820.nr_map = 0; 1467 e820_add_region(0, LOWMEMSIZE(), E820_RAM); 1468 e820_add_region(HIGH_MEMORY, mem_size << 10, E820_RAM); 1469 } 1470 1471 /* In case someone cares... */ 1472 return who; 1473 } 1474 1475 void __init setup_memory_map(void) 1476 { 1477 char *who; 1478 1479 who = x86_init.resources.memory_setup(); 1480 memcpy(&e820_saved, &e820, sizeof(struct e820map)); 1481 printk(KERN_INFO "BIOS-provided physical RAM map:\n"); 1482 e820_print_map(who); 1483 } 1484