arch/x86/kernel/e820.c

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