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 #include <asm/cpufeature.h> 28 29 /* 30 * The e820 map is the map that gets modified e.g. with command line parameters 31 * and that is also registered with modifications in the kernel resource tree 32 * with the iomem_resource as parent. 33 * 34 * The e820_saved is directly saved after the BIOS-provided memory map is 35 * copied. It doesn't get modified afterwards. It's registered for the 36 * /sys/firmware/memmap interface. 37 * 38 * That memory map is not modified and is used as base for kexec. The kexec'd 39 * kernel should get the same memory map as the firmware provides. Then the 40 * user can e.g. boot the original kernel with mem=1G while still booting the 41 * next kernel with full memory. 42 */ 43 static struct e820map initial_e820 __initdata; 44 static struct e820map initial_e820_saved __initdata; 45 struct e820map *e820 __refdata = &initial_e820; 46 struct e820map *e820_saved __refdata = &initial_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 "e820: too many entries; ignoring [mem %#010llx-%#010llx]\n", 120 (unsigned long long) start, 121 (unsigned long long) (start + size - 1)); 122 return; 123 } 124 125 e820x->map[x].addr = start; 126 e820x->map[x].size = size; 127 e820x->map[x].type = type; 128 e820x->nr_map++; 129 } 130 131 void __init e820_add_region(u64 start, u64 size, int type) 132 { 133 __e820_add_region(e820, start, size, type); 134 } 135 136 static void __init e820_print_type(u32 type) 137 { 138 switch (type) { 139 case E820_RAM: 140 case E820_RESERVED_KERN: 141 printk(KERN_CONT "usable"); 142 break; 143 case E820_RESERVED: 144 printk(KERN_CONT "reserved"); 145 break; 146 case E820_ACPI: 147 printk(KERN_CONT "ACPI data"); 148 break; 149 case E820_NVS: 150 printk(KERN_CONT "ACPI NVS"); 151 break; 152 case E820_UNUSABLE: 153 printk(KERN_CONT "unusable"); 154 break; 155 case E820_PMEM: 156 case E820_PRAM: 157 printk(KERN_CONT "persistent (type %u)", type); 158 break; 159 default: 160 printk(KERN_CONT "type %u", type); 161 break; 162 } 163 } 164 165 void __init e820_print_map(char *who) 166 { 167 int i; 168 169 for (i = 0; i < e820->nr_map; i++) { 170 printk(KERN_INFO "%s: [mem %#018Lx-%#018Lx] ", who, 171 (unsigned long long) e820->map[i].addr, 172 (unsigned long long) 173 (e820->map[i].addr + e820->map[i].size - 1)); 174 e820_print_type(e820->map[i].type); 175 printk(KERN_CONT "\n"); 176 } 177 } 178 179 /* 180 * Sanitize the BIOS e820 map. 181 * 182 * Some e820 responses include overlapping entries. The following 183 * replaces the original e820 map with a new one, removing overlaps, 184 * and resolving conflicting memory types in favor of highest 185 * numbered type. 186 * 187 * The input parameter biosmap points to an array of 'struct 188 * e820entry' which on entry has elements in the range [0, *pnr_map) 189 * valid, and which has space for up to max_nr_map entries. 190 * On return, the resulting sanitized e820 map entries will be in 191 * overwritten in the same location, starting at biosmap. 192 * 193 * The integer pointed to by pnr_map must be valid on entry (the 194 * current number of valid entries located at biosmap). If the 195 * sanitizing succeeds the *pnr_map will be updated with the new 196 * number of valid entries (something no more than max_nr_map). 197 * 198 * The return value from sanitize_e820_map() is zero if it 199 * successfully 'sanitized' the map entries passed in, and is -1 200 * if it did nothing, which can happen if either of (1) it was 201 * only passed one map entry, or (2) any of the input map entries 202 * were invalid (start + size < start, meaning that the size was 203 * so big the described memory range wrapped around through zero.) 204 * 205 * Visually we're performing the following 206 * (1,2,3,4 = memory types)... 207 * 208 * Sample memory map (w/overlaps): 209 * ____22__________________ 210 * ______________________4_ 211 * ____1111________________ 212 * _44_____________________ 213 * 11111111________________ 214 * ____________________33__ 215 * ___________44___________ 216 * __________33333_________ 217 * ______________22________ 218 * ___________________2222_ 219 * _________111111111______ 220 * _____________________11_ 221 * _________________4______ 222 * 223 * Sanitized equivalent (no overlap): 224 * 1_______________________ 225 * _44_____________________ 226 * ___1____________________ 227 * ____22__________________ 228 * ______11________________ 229 * _________1______________ 230 * __________3_____________ 231 * ___________44___________ 232 * _____________33_________ 233 * _______________2________ 234 * ________________1_______ 235 * _________________4______ 236 * ___________________2____ 237 * ____________________33__ 238 * ______________________4_ 239 */ 240 struct change_member { 241 struct e820entry *pbios; /* pointer to original bios entry */ 242 unsigned long long addr; /* address for this change point */ 243 }; 244 245 static int __init cpcompare(const void *a, const void *b) 246 { 247 struct change_member * const *app = a, * const *bpp = b; 248 const struct change_member *ap = *app, *bp = *bpp; 249 250 /* 251 * Inputs are pointers to two elements of change_point[]. If their 252 * addresses are unequal, their difference dominates. If the addresses 253 * are equal, then consider one that represents the end of its region 254 * to be greater than one that does not. 255 */ 256 if (ap->addr != bp->addr) 257 return ap->addr > bp->addr ? 1 : -1; 258 259 return (ap->addr != ap->pbios->addr) - (bp->addr != bp->pbios->addr); 260 } 261 262 int __init sanitize_e820_map(struct e820entry *biosmap, int max_nr_map, 263 u32 *pnr_map) 264 { 265 static struct change_member change_point_list[2*E820_X_MAX] __initdata; 266 static struct change_member *change_point[2*E820_X_MAX] __initdata; 267 static struct e820entry *overlap_list[E820_X_MAX] __initdata; 268 static struct e820entry new_bios[E820_X_MAX] __initdata; 269 unsigned long current_type, last_type; 270 unsigned long long last_addr; 271 int chgidx; 272 int overlap_entries; 273 int new_bios_entry; 274 int old_nr, new_nr, chg_nr; 275 int i; 276 277 /* if there's only one memory region, don't bother */ 278 if (*pnr_map < 2) 279 return -1; 280 281 old_nr = *pnr_map; 282 BUG_ON(old_nr > max_nr_map); 283 284 /* bail out if we find any unreasonable addresses in bios map */ 285 for (i = 0; i < old_nr; i++) 286 if (biosmap[i].addr + biosmap[i].size < biosmap[i].addr) 287 return -1; 288 289 /* create pointers for initial change-point information (for sorting) */ 290 for (i = 0; i < 2 * old_nr; i++) 291 change_point[i] = &change_point_list[i]; 292 293 /* record all known change-points (starting and ending addresses), 294 omitting those that are for empty memory regions */ 295 chgidx = 0; 296 for (i = 0; i < old_nr; i++) { 297 if (biosmap[i].size != 0) { 298 change_point[chgidx]->addr = biosmap[i].addr; 299 change_point[chgidx++]->pbios = &biosmap[i]; 300 change_point[chgidx]->addr = biosmap[i].addr + 301 biosmap[i].size; 302 change_point[chgidx++]->pbios = &biosmap[i]; 303 } 304 } 305 chg_nr = chgidx; 306 307 /* sort change-point list by memory addresses (low -> high) */ 308 sort(change_point, chg_nr, sizeof *change_point, cpcompare, NULL); 309 310 /* create a new bios memory map, removing overlaps */ 311 overlap_entries = 0; /* number of entries in the overlap table */ 312 new_bios_entry = 0; /* index for creating new bios map entries */ 313 last_type = 0; /* start with undefined memory type */ 314 last_addr = 0; /* start with 0 as last starting address */ 315 316 /* loop through change-points, determining affect on the new bios map */ 317 for (chgidx = 0; chgidx < chg_nr; chgidx++) { 318 /* keep track of all overlapping bios entries */ 319 if (change_point[chgidx]->addr == 320 change_point[chgidx]->pbios->addr) { 321 /* 322 * add map entry to overlap list (> 1 entry 323 * implies an overlap) 324 */ 325 overlap_list[overlap_entries++] = 326 change_point[chgidx]->pbios; 327 } else { 328 /* 329 * remove entry from list (order independent, 330 * so swap with last) 331 */ 332 for (i = 0; i < overlap_entries; i++) { 333 if (overlap_list[i] == 334 change_point[chgidx]->pbios) 335 overlap_list[i] = 336 overlap_list[overlap_entries-1]; 337 } 338 overlap_entries--; 339 } 340 /* 341 * if there are overlapping entries, decide which 342 * "type" to use (larger value takes precedence -- 343 * 1=usable, 2,3,4,4+=unusable) 344 */ 345 current_type = 0; 346 for (i = 0; i < overlap_entries; i++) 347 if (overlap_list[i]->type > current_type) 348 current_type = overlap_list[i]->type; 349 /* 350 * continue building up new bios map based on this 351 * information 352 */ 353 if (current_type != last_type || current_type == E820_PRAM) { 354 if (last_type != 0) { 355 new_bios[new_bios_entry].size = 356 change_point[chgidx]->addr - last_addr; 357 /* 358 * move forward only if the new size 359 * was non-zero 360 */ 361 if (new_bios[new_bios_entry].size != 0) 362 /* 363 * no more space left for new 364 * bios entries ? 365 */ 366 if (++new_bios_entry >= max_nr_map) 367 break; 368 } 369 if (current_type != 0) { 370 new_bios[new_bios_entry].addr = 371 change_point[chgidx]->addr; 372 new_bios[new_bios_entry].type = current_type; 373 last_addr = change_point[chgidx]->addr; 374 } 375 last_type = current_type; 376 } 377 } 378 /* retain count for new bios entries */ 379 new_nr = new_bios_entry; 380 381 /* copy new bios mapping into original location */ 382 memcpy(biosmap, new_bios, new_nr * sizeof(struct e820entry)); 383 *pnr_map = new_nr; 384 385 return 0; 386 } 387 388 static int __init __append_e820_map(struct e820entry *biosmap, int nr_map) 389 { 390 while (nr_map) { 391 u64 start = biosmap->addr; 392 u64 size = biosmap->size; 393 u64 end = start + size - 1; 394 u32 type = biosmap->type; 395 396 /* Overflow in 64 bits? Ignore the memory map. */ 397 if (start > end && likely(size)) 398 return -1; 399 400 e820_add_region(start, size, type); 401 402 biosmap++; 403 nr_map--; 404 } 405 return 0; 406 } 407 408 /* 409 * Copy the BIOS e820 map into a safe place. 410 * 411 * Sanity-check it while we're at it.. 412 * 413 * If we're lucky and live on a modern system, the setup code 414 * will have given us a memory map that we can use to properly 415 * set up memory. If we aren't, we'll fake a memory map. 416 */ 417 static int __init append_e820_map(struct e820entry *biosmap, int nr_map) 418 { 419 /* Only one memory region (or negative)? Ignore it */ 420 if (nr_map < 2) 421 return -1; 422 423 return __append_e820_map(biosmap, nr_map); 424 } 425 426 static u64 __init __e820_update_range(struct e820map *e820x, u64 start, 427 u64 size, unsigned old_type, 428 unsigned new_type) 429 { 430 u64 end; 431 unsigned int i; 432 u64 real_updated_size = 0; 433 434 BUG_ON(old_type == new_type); 435 436 if (size > (ULLONG_MAX - start)) 437 size = ULLONG_MAX - start; 438 439 end = start + size; 440 printk(KERN_DEBUG "e820: update [mem %#010Lx-%#010Lx] ", 441 (unsigned long long) start, (unsigned long long) (end - 1)); 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 [mem %#010Lx-%#010Lx] ", 521 (unsigned long long) start, (unsigned long long) (end - 1)); 522 if (checktype) 523 e820_print_type(old_type); 524 printk(KERN_CONT "\n"); 525 526 for (i = 0; i < e820->nr_map; i++) { 527 struct e820entry *ei = &e820->map[i]; 528 u64 final_start, final_end; 529 u64 ei_end; 530 531 if (checktype && ei->type != old_type) 532 continue; 533 534 ei_end = ei->addr + ei->size; 535 /* totally covered? */ 536 if (ei->addr >= start && ei_end <= end) { 537 real_removed_size += ei->size; 538 memset(ei, 0, sizeof(struct e820entry)); 539 continue; 540 } 541 542 /* new range is totally covered? */ 543 if (ei->addr < start && ei_end > end) { 544 e820_add_region(end, ei_end - end, ei->type); 545 ei->size = start - ei->addr; 546 real_removed_size += size; 547 continue; 548 } 549 550 /* partially covered */ 551 final_start = max(start, ei->addr); 552 final_end = min(end, ei_end); 553 if (final_start >= final_end) 554 continue; 555 real_removed_size += final_end - final_start; 556 557 /* 558 * left range could be head or tail, so need to update 559 * size at first. 560 */ 561 ei->size -= final_end - final_start; 562 if (ei->addr < final_start) 563 continue; 564 ei->addr = final_end; 565 } 566 return real_removed_size; 567 } 568 569 void __init update_e820(void) 570 { 571 if (sanitize_e820_map(e820->map, ARRAY_SIZE(e820->map), &e820->nr_map)) 572 return; 573 printk(KERN_INFO "e820: modified physical RAM map:\n"); 574 e820_print_map("modified"); 575 } 576 static void __init update_e820_saved(void) 577 { 578 sanitize_e820_map(e820_saved->map, ARRAY_SIZE(e820_saved->map), 579 &e820_saved->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 "e820: cannot find a gap in the 32bit address range\n" 640 "e820: PCI devices with unassigned 32bit BARs 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 "e820: [mem %#010lx-%#010lx] available for PCI devices\n", 651 gapstart, gapstart + gapsize - 1); 652 } 653 654 /* 655 * Called late during init, in free_initmem(). 656 * 657 * Initial e820 and e820_saved are largish __initdata arrays. 658 * Copy them to (usually much smaller) dynamically allocated area. 659 * This is done after all tweaks we ever do to them: 660 * all functions which modify them are __init functions, 661 * they won't exist after this point. 662 */ 663 __init void e820_reallocate_tables(void) 664 { 665 struct e820map *n; 666 int size; 667 668 size = offsetof(struct e820map, map) + sizeof(struct e820entry) * e820->nr_map; 669 n = kmalloc(size, GFP_KERNEL); 670 BUG_ON(!n); 671 memcpy(n, e820, size); 672 e820 = n; 673 674 size = offsetof(struct e820map, map) + sizeof(struct e820entry) * e820_saved->nr_map; 675 n = kmalloc(size, GFP_KERNEL); 676 BUG_ON(!n); 677 memcpy(n, e820_saved, size); 678 e820_saved = n; 679 } 680 681 /** 682 * Because of the size limitation of struct boot_params, only first 683 * 128 E820 memory entries are passed to kernel via 684 * boot_params.e820_map, others are passed via SETUP_E820_EXT node of 685 * linked list of struct setup_data, which is parsed here. 686 */ 687 void __init parse_e820_ext(u64 phys_addr, u32 data_len) 688 { 689 int entries; 690 struct e820entry *extmap; 691 struct setup_data *sdata; 692 693 sdata = early_memremap(phys_addr, data_len); 694 entries = sdata->len / sizeof(struct e820entry); 695 extmap = (struct e820entry *)(sdata->data); 696 __append_e820_map(extmap, entries); 697 sanitize_e820_map(e820->map, ARRAY_SIZE(e820->map), &e820->nr_map); 698 early_memunmap(sdata, data_len); 699 printk(KERN_INFO "e820: extended physical RAM map:\n"); 700 e820_print_map("extended"); 701 } 702 703 #if defined(CONFIG_X86_64) || \ 704 (defined(CONFIG_X86_32) && defined(CONFIG_HIBERNATION)) 705 /** 706 * Find the ranges of physical addresses that do not correspond to 707 * e820 RAM areas and mark the corresponding pages as nosave for 708 * hibernation (32 bit) or software suspend and suspend to RAM (64 bit). 709 * 710 * This function requires the e820 map to be sorted and without any 711 * overlapping entries. 712 */ 713 void __init e820_mark_nosave_regions(unsigned long limit_pfn) 714 { 715 int i; 716 unsigned long pfn = 0; 717 718 for (i = 0; i < e820->nr_map; i++) { 719 struct e820entry *ei = &e820->map[i]; 720 721 if (pfn < PFN_UP(ei->addr)) 722 register_nosave_region(pfn, PFN_UP(ei->addr)); 723 724 pfn = PFN_DOWN(ei->addr + ei->size); 725 726 if (ei->type != E820_RAM && ei->type != E820_RESERVED_KERN) 727 register_nosave_region(PFN_UP(ei->addr), pfn); 728 729 if (pfn >= limit_pfn) 730 break; 731 } 732 } 733 #endif 734 735 #ifdef CONFIG_ACPI 736 /** 737 * Mark ACPI NVS memory region, so that we can save/restore it during 738 * hibernation and the subsequent resume. 739 */ 740 static int __init e820_mark_nvs_memory(void) 741 { 742 int i; 743 744 for (i = 0; i < e820->nr_map; i++) { 745 struct e820entry *ei = &e820->map[i]; 746 747 if (ei->type == E820_NVS) 748 acpi_nvs_register(ei->addr, ei->size); 749 } 750 751 return 0; 752 } 753 core_initcall(e820_mark_nvs_memory); 754 #endif 755 756 /* 757 * pre allocated 4k and reserved it in memblock and e820_saved 758 */ 759 u64 __init early_reserve_e820(u64 size, u64 align) 760 { 761 u64 addr; 762 763 addr = __memblock_alloc_base(size, align, MEMBLOCK_ALLOC_ACCESSIBLE); 764 if (addr) { 765 e820_update_range_saved(addr, size, E820_RAM, E820_RESERVED); 766 printk(KERN_INFO "e820: update e820_saved for early_reserve_e820\n"); 767 update_e820_saved(); 768 } 769 770 return addr; 771 } 772 773 #ifdef CONFIG_X86_32 774 # ifdef CONFIG_X86_PAE 775 # define MAX_ARCH_PFN (1ULL<<(36-PAGE_SHIFT)) 776 # else 777 # define MAX_ARCH_PFN (1ULL<<(32-PAGE_SHIFT)) 778 # endif 779 #else /* CONFIG_X86_32 */ 780 # define MAX_ARCH_PFN MAXMEM>>PAGE_SHIFT 781 #endif 782 783 /* 784 * Find the highest page frame number we have available 785 */ 786 static unsigned long __init e820_end_pfn(unsigned long limit_pfn, unsigned type) 787 { 788 int i; 789 unsigned long last_pfn = 0; 790 unsigned long max_arch_pfn = MAX_ARCH_PFN; 791 792 for (i = 0; i < e820->nr_map; i++) { 793 struct e820entry *ei = &e820->map[i]; 794 unsigned long start_pfn; 795 unsigned long end_pfn; 796 797 if (ei->type != type) 798 continue; 799 800 start_pfn = ei->addr >> PAGE_SHIFT; 801 end_pfn = (ei->addr + ei->size) >> PAGE_SHIFT; 802 803 if (start_pfn >= limit_pfn) 804 continue; 805 if (end_pfn > limit_pfn) { 806 last_pfn = limit_pfn; 807 break; 808 } 809 if (end_pfn > last_pfn) 810 last_pfn = end_pfn; 811 } 812 813 if (last_pfn > max_arch_pfn) 814 last_pfn = max_arch_pfn; 815 816 printk(KERN_INFO "e820: last_pfn = %#lx max_arch_pfn = %#lx\n", 817 last_pfn, max_arch_pfn); 818 return last_pfn; 819 } 820 unsigned long __init e820_end_of_ram_pfn(void) 821 { 822 return e820_end_pfn(MAX_ARCH_PFN, E820_RAM); 823 } 824 825 unsigned long __init e820_end_of_low_ram_pfn(void) 826 { 827 return e820_end_pfn(1UL << (32 - PAGE_SHIFT), E820_RAM); 828 } 829 830 static void __init early_panic(char *msg) 831 { 832 early_printk(msg); 833 panic(msg); 834 } 835 836 static int userdef __initdata; 837 838 /* "mem=nopentium" disables the 4MB page tables. */ 839 static int __init parse_memopt(char *p) 840 { 841 u64 mem_size; 842 843 if (!p) 844 return -EINVAL; 845 846 if (!strcmp(p, "nopentium")) { 847 #ifdef CONFIG_X86_32 848 setup_clear_cpu_cap(X86_FEATURE_PSE); 849 return 0; 850 #else 851 printk(KERN_WARNING "mem=nopentium ignored! (only supported on x86_32)\n"); 852 return -EINVAL; 853 #endif 854 } 855 856 userdef = 1; 857 mem_size = memparse(p, &p); 858 /* don't remove all of memory when handling "mem={invalid}" param */ 859 if (mem_size == 0) 860 return -EINVAL; 861 e820_remove_range(mem_size, ULLONG_MAX - mem_size, E820_RAM, 1); 862 863 return 0; 864 } 865 early_param("mem", parse_memopt); 866 867 static int __init parse_memmap_one(char *p) 868 { 869 char *oldp; 870 u64 start_at, mem_size; 871 872 if (!p) 873 return -EINVAL; 874 875 if (!strncmp(p, "exactmap", 8)) { 876 #ifdef CONFIG_CRASH_DUMP 877 /* 878 * If we are doing a crash dump, we still need to know 879 * the real mem size before original memory map is 880 * reset. 881 */ 882 saved_max_pfn = e820_end_of_ram_pfn(); 883 #endif 884 e820->nr_map = 0; 885 userdef = 1; 886 return 0; 887 } 888 889 oldp = p; 890 mem_size = memparse(p, &p); 891 if (p == oldp) 892 return -EINVAL; 893 894 userdef = 1; 895 if (*p == '@') { 896 start_at = memparse(p+1, &p); 897 e820_add_region(start_at, mem_size, E820_RAM); 898 } else if (*p == '#') { 899 start_at = memparse(p+1, &p); 900 e820_add_region(start_at, mem_size, E820_ACPI); 901 } else if (*p == '$') { 902 start_at = memparse(p+1, &p); 903 e820_add_region(start_at, mem_size, E820_RESERVED); 904 } else if (*p == '!') { 905 start_at = memparse(p+1, &p); 906 e820_add_region(start_at, mem_size, E820_PRAM); 907 } else 908 e820_remove_range(mem_size, ULLONG_MAX - mem_size, E820_RAM, 1); 909 910 return *p == '\0' ? 0 : -EINVAL; 911 } 912 static int __init parse_memmap_opt(char *str) 913 { 914 while (str) { 915 char *k = strchr(str, ','); 916 917 if (k) 918 *k++ = 0; 919 920 parse_memmap_one(str); 921 str = k; 922 } 923 924 return 0; 925 } 926 early_param("memmap", parse_memmap_opt); 927 928 void __init finish_e820_parsing(void) 929 { 930 if (userdef) { 931 if (sanitize_e820_map(e820->map, ARRAY_SIZE(e820->map), 932 &e820->nr_map) < 0) 933 early_panic("Invalid user supplied memory map"); 934 935 printk(KERN_INFO "e820: user-defined physical RAM map:\n"); 936 e820_print_map("user"); 937 } 938 } 939 940 static const char *__init e820_type_to_string(int e820_type) 941 { 942 switch (e820_type) { 943 case E820_RESERVED_KERN: 944 case E820_RAM: return "System RAM"; 945 case E820_ACPI: return "ACPI Tables"; 946 case E820_NVS: return "ACPI Non-volatile Storage"; 947 case E820_UNUSABLE: return "Unusable memory"; 948 case E820_PRAM: return "Persistent Memory (legacy)"; 949 case E820_PMEM: return "Persistent Memory"; 950 default: return "reserved"; 951 } 952 } 953 954 static unsigned long __init e820_type_to_iomem_type(int e820_type) 955 { 956 switch (e820_type) { 957 case E820_RESERVED_KERN: 958 case E820_RAM: 959 return IORESOURCE_SYSTEM_RAM; 960 case E820_ACPI: 961 case E820_NVS: 962 case E820_UNUSABLE: 963 case E820_PRAM: 964 case E820_PMEM: 965 default: 966 return IORESOURCE_MEM; 967 } 968 } 969 970 static unsigned long __init e820_type_to_iores_desc(int e820_type) 971 { 972 switch (e820_type) { 973 case E820_ACPI: 974 return IORES_DESC_ACPI_TABLES; 975 case E820_NVS: 976 return IORES_DESC_ACPI_NV_STORAGE; 977 case E820_PMEM: 978 return IORES_DESC_PERSISTENT_MEMORY; 979 case E820_PRAM: 980 return IORES_DESC_PERSISTENT_MEMORY_LEGACY; 981 case E820_RESERVED_KERN: 982 case E820_RAM: 983 case E820_UNUSABLE: 984 default: 985 return IORES_DESC_NONE; 986 } 987 } 988 989 static bool __init do_mark_busy(u32 type, struct resource *res) 990 { 991 /* this is the legacy bios/dos rom-shadow + mmio region */ 992 if (res->start < (1ULL<<20)) 993 return true; 994 995 /* 996 * Treat persistent memory like device memory, i.e. reserve it 997 * for exclusive use of a driver 998 */ 999 switch (type) { 1000 case E820_RESERVED: 1001 case E820_PRAM: 1002 case E820_PMEM: 1003 return false; 1004 default: 1005 return true; 1006 } 1007 } 1008 1009 /* 1010 * Mark e820 reserved areas as busy for the resource manager. 1011 */ 1012 static struct resource __initdata *e820_res; 1013 void __init e820_reserve_resources(void) 1014 { 1015 int i; 1016 struct resource *res; 1017 u64 end; 1018 1019 res = alloc_bootmem(sizeof(struct resource) * e820->nr_map); 1020 e820_res = res; 1021 for (i = 0; i < e820->nr_map; i++) { 1022 end = e820->map[i].addr + e820->map[i].size - 1; 1023 if (end != (resource_size_t)end) { 1024 res++; 1025 continue; 1026 } 1027 res->name = e820_type_to_string(e820->map[i].type); 1028 res->start = e820->map[i].addr; 1029 res->end = end; 1030 1031 res->flags = e820_type_to_iomem_type(e820->map[i].type); 1032 res->desc = e820_type_to_iores_desc(e820->map[i].type); 1033 1034 /* 1035 * don't register the region that could be conflicted with 1036 * pci device BAR resource and insert them later in 1037 * pcibios_resource_survey() 1038 */ 1039 if (do_mark_busy(e820->map[i].type, res)) { 1040 res->flags |= IORESOURCE_BUSY; 1041 insert_resource(&iomem_resource, res); 1042 } 1043 res++; 1044 } 1045 1046 for (i = 0; i < e820_saved->nr_map; i++) { 1047 struct e820entry *entry = &e820_saved->map[i]; 1048 firmware_map_add_early(entry->addr, 1049 entry->addr + entry->size, 1050 e820_type_to_string(entry->type)); 1051 } 1052 } 1053 1054 /* How much should we pad RAM ending depending on where it is? */ 1055 static unsigned long __init ram_alignment(resource_size_t pos) 1056 { 1057 unsigned long mb = pos >> 20; 1058 1059 /* To 64kB in the first megabyte */ 1060 if (!mb) 1061 return 64*1024; 1062 1063 /* To 1MB in the first 16MB */ 1064 if (mb < 16) 1065 return 1024*1024; 1066 1067 /* To 64MB for anything above that */ 1068 return 64*1024*1024; 1069 } 1070 1071 #define MAX_RESOURCE_SIZE ((resource_size_t)-1) 1072 1073 void __init e820_reserve_resources_late(void) 1074 { 1075 int i; 1076 struct resource *res; 1077 1078 res = e820_res; 1079 for (i = 0; i < e820->nr_map; i++) { 1080 if (!res->parent && res->end) 1081 insert_resource_expand_to_fit(&iomem_resource, res); 1082 res++; 1083 } 1084 1085 /* 1086 * Try to bump up RAM regions to reasonable boundaries to 1087 * avoid stolen RAM: 1088 */ 1089 for (i = 0; i < e820->nr_map; i++) { 1090 struct e820entry *entry = &e820->map[i]; 1091 u64 start, end; 1092 1093 if (entry->type != E820_RAM) 1094 continue; 1095 start = entry->addr + entry->size; 1096 end = round_up(start, ram_alignment(start)) - 1; 1097 if (end > MAX_RESOURCE_SIZE) 1098 end = MAX_RESOURCE_SIZE; 1099 if (start >= end) 1100 continue; 1101 printk(KERN_DEBUG 1102 "e820: reserve RAM buffer [mem %#010llx-%#010llx]\n", 1103 start, end); 1104 reserve_region_with_split(&iomem_resource, start, end, 1105 "RAM buffer"); 1106 } 1107 } 1108 1109 char *__init default_machine_specific_memory_setup(void) 1110 { 1111 char *who = "BIOS-e820"; 1112 u32 new_nr; 1113 /* 1114 * Try to copy the BIOS-supplied E820-map. 1115 * 1116 * Otherwise fake a memory map; one section from 0k->640k, 1117 * the next section from 1mb->appropriate_mem_k 1118 */ 1119 new_nr = boot_params.e820_entries; 1120 sanitize_e820_map(boot_params.e820_map, 1121 ARRAY_SIZE(boot_params.e820_map), 1122 &new_nr); 1123 boot_params.e820_entries = new_nr; 1124 if (append_e820_map(boot_params.e820_map, boot_params.e820_entries) 1125 < 0) { 1126 u64 mem_size; 1127 1128 /* compare results from other methods and take the greater */ 1129 if (boot_params.alt_mem_k 1130 < boot_params.screen_info.ext_mem_k) { 1131 mem_size = boot_params.screen_info.ext_mem_k; 1132 who = "BIOS-88"; 1133 } else { 1134 mem_size = boot_params.alt_mem_k; 1135 who = "BIOS-e801"; 1136 } 1137 1138 e820->nr_map = 0; 1139 e820_add_region(0, LOWMEMSIZE(), E820_RAM); 1140 e820_add_region(HIGH_MEMORY, mem_size << 10, E820_RAM); 1141 } 1142 1143 /* In case someone cares... */ 1144 return who; 1145 } 1146 1147 void __init setup_memory_map(void) 1148 { 1149 char *who; 1150 1151 who = x86_init.resources.memory_setup(); 1152 memcpy(e820_saved, e820, sizeof(struct e820map)); 1153 printk(KERN_INFO "e820: BIOS-provided physical RAM map:\n"); 1154 e820_print_map(who); 1155 } 1156 1157 void __init memblock_x86_fill(void) 1158 { 1159 int i; 1160 u64 end; 1161 1162 /* 1163 * EFI may have more than 128 entries 1164 * We are safe to enable resizing, beause memblock_x86_fill() 1165 * is rather later for x86 1166 */ 1167 memblock_allow_resize(); 1168 1169 for (i = 0; i < e820->nr_map; i++) { 1170 struct e820entry *ei = &e820->map[i]; 1171 1172 end = ei->addr + ei->size; 1173 if (end != (resource_size_t)end) 1174 continue; 1175 1176 if (ei->type != E820_RAM && ei->type != E820_RESERVED_KERN) 1177 continue; 1178 1179 memblock_add(ei->addr, ei->size); 1180 } 1181 1182 /* throw away partial pages */ 1183 memblock_trim_memory(PAGE_SIZE); 1184 1185 memblock_dump_all(); 1186 } 1187 1188 void __init memblock_find_dma_reserve(void) 1189 { 1190 #ifdef CONFIG_X86_64 1191 u64 nr_pages = 0, nr_free_pages = 0; 1192 unsigned long start_pfn, end_pfn; 1193 phys_addr_t start, end; 1194 int i; 1195 u64 u; 1196 1197 /* 1198 * need to find out used area below MAX_DMA_PFN 1199 * need to use memblock to get free size in [0, MAX_DMA_PFN] 1200 * at first, and assume boot_mem will not take below MAX_DMA_PFN 1201 */ 1202 for_each_mem_pfn_range(i, MAX_NUMNODES, &start_pfn, &end_pfn, NULL) { 1203 start_pfn = min(start_pfn, MAX_DMA_PFN); 1204 end_pfn = min(end_pfn, MAX_DMA_PFN); 1205 nr_pages += end_pfn - start_pfn; 1206 } 1207 1208 for_each_free_mem_range(u, NUMA_NO_NODE, MEMBLOCK_NONE, &start, &end, 1209 NULL) { 1210 start_pfn = min_t(unsigned long, PFN_UP(start), MAX_DMA_PFN); 1211 end_pfn = min_t(unsigned long, PFN_DOWN(end), MAX_DMA_PFN); 1212 if (start_pfn < end_pfn) 1213 nr_free_pages += end_pfn - start_pfn; 1214 } 1215 1216 set_dma_reserve(nr_pages - nr_free_pages); 1217 #endif 1218 } 1219