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