Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
e820.c
Go to the documentation of this file.
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 <[email protected]>, December 2002.
8  * Venkatesh Pallipadi <[email protected]>
9  *
10  */
11 #include <linux/kernel.h>
12 #include <linux/types.h>
13 #include <linux/init.h>
14 #include <linux/crash_dump.h>
15 #include <linux/export.h>
16 #include <linux/bootmem.h>
17 #include <linux/pfn.h>
18 #include <linux/suspend.h>
19 #include <linux/acpi.h>
20 #include <linux/firmware-map.h>
21 #include <linux/memblock.h>
22 #include <linux/sort.h>
23 
24 #include <asm/e820.h>
25 #include <asm/proto.h>
26 #include <asm/setup.h>
27 
28 /*
29  * The e820 map is the map that gets modified e.g. with command line parameters
30  * and that is also registered with modifications in the kernel resource tree
31  * with the iomem_resource as parent.
32  *
33  * The e820_saved is directly saved after the BIOS-provided memory map is
34  * copied. It doesn't get modified afterwards. It's registered for the
35  * /sys/firmware/memmap interface.
36  *
37  * That memory map is not modified and is used as base for kexec. The kexec'd
38  * kernel should get the same memory map as the firmware provides. Then the
39  * user can e.g. boot the original kernel with mem=1G while still booting the
40  * next kernel with full memory.
41  */
42 struct e820map e820;
44 
45 /* For PCI or other memory-mapped resources */
46 unsigned long pci_mem_start = 0xaeedbabe;
47 #ifdef CONFIG_PCI
49 #endif
50 
51 /*
52  * This function checks if any part of the range <start,end> is mapped
53  * with type.
54  */
55 int
57 {
58  int i;
59 
60  for (i = 0; i < e820.nr_map; i++) {
61  struct e820entry *ei = &e820.map[i];
62 
63  if (type && ei->type != type)
64  continue;
65  if (ei->addr >= end || ei->addr + ei->size <= start)
66  continue;
67  return 1;
68  }
69  return 0;
70 }
72 
73 /*
74  * This function checks if the entire range <start,end> is mapped with type.
75  *
76  * Note: this function only works correct if the e820 table is sorted and
77  * not-overlapping, which is the case
78  */
80 {
81  int i;
82 
83  for (i = 0; i < e820.nr_map; i++) {
84  struct e820entry *ei = &e820.map[i];
85 
86  if (type && ei->type != type)
87  continue;
88  /* is the region (part) in overlap with the current region ?*/
89  if (ei->addr >= end || ei->addr + ei->size <= start)
90  continue;
91 
92  /* if the region is at the beginning of <start,end> we move
93  * start to the end of the region since it's ok until there
94  */
95  if (ei->addr <= start)
96  start = ei->addr + ei->size;
97  /*
98  * if start is now at or beyond end, we're done, full
99  * coverage
100  */
101  if (start >= end)
102  return 1;
103  }
104  return 0;
105 }
106 
107 /*
108  * Add a memory region to the kernel e820 map.
109  */
110 static void __init __e820_add_region(struct e820map *e820x, u64 start, u64 size,
111  int type)
112 {
113  int x = e820x->nr_map;
114 
115  if (x >= ARRAY_SIZE(e820x->map)) {
116  printk(KERN_ERR "e820: too many entries; ignoring [mem %#010llx-%#010llx]\n",
117  (unsigned long long) start,
118  (unsigned long long) (start + size - 1));
119  return;
120  }
121 
122  e820x->map[x].addr = start;
123  e820x->map[x].size = size;
124  e820x->map[x].type = type;
125  e820x->nr_map++;
126 }
127 
128 void __init e820_add_region(u64 start, u64 size, int type)
129 {
130  __e820_add_region(&e820, start, size, type);
131 }
132 
133 static void __init e820_print_type(u32 type)
134 {
135  switch (type) {
136  case E820_RAM:
137  case E820_RESERVED_KERN:
138  printk(KERN_CONT "usable");
139  break;
140  case E820_RESERVED:
141  printk(KERN_CONT "reserved");
142  break;
143  case E820_ACPI:
144  printk(KERN_CONT "ACPI data");
145  break;
146  case E820_NVS:
147  printk(KERN_CONT "ACPI NVS");
148  break;
149  case E820_UNUSABLE:
150  printk(KERN_CONT "unusable");
151  break;
152  default:
153  printk(KERN_CONT "type %u", type);
154  break;
155  }
156 }
157 
158 void __init e820_print_map(char *who)
159 {
160  int i;
161 
162  for (i = 0; i < e820.nr_map; i++) {
163  printk(KERN_INFO "%s: [mem %#018Lx-%#018Lx] ", who,
164  (unsigned long long) e820.map[i].addr,
165  (unsigned long long)
166  (e820.map[i].addr + e820.map[i].size - 1));
167  e820_print_type(e820.map[i].type);
168  printk(KERN_CONT "\n");
169  }
170 }
171 
172 /*
173  * Sanitize the BIOS e820 map.
174  *
175  * Some e820 responses include overlapping entries. The following
176  * replaces the original e820 map with a new one, removing overlaps,
177  * and resolving conflicting memory types in favor of highest
178  * numbered type.
179  *
180  * The input parameter biosmap points to an array of 'struct
181  * e820entry' which on entry has elements in the range [0, *pnr_map)
182  * valid, and which has space for up to max_nr_map entries.
183  * On return, the resulting sanitized e820 map entries will be in
184  * overwritten in the same location, starting at biosmap.
185  *
186  * The integer pointed to by pnr_map must be valid on entry (the
187  * current number of valid entries located at biosmap) and will
188  * be updated on return, with the new number of valid entries
189  * (something no more than max_nr_map.)
190  *
191  * The return value from sanitize_e820_map() is zero if it
192  * successfully 'sanitized' the map entries passed in, and is -1
193  * if it did nothing, which can happen if either of (1) it was
194  * only passed one map entry, or (2) any of the input map entries
195  * were invalid (start + size < start, meaning that the size was
196  * so big the described memory range wrapped around through zero.)
197  *
198  * Visually we're performing the following
199  * (1,2,3,4 = memory types)...
200  *
201  * Sample memory map (w/overlaps):
202  * ____22__________________
203  * ______________________4_
204  * ____1111________________
205  * _44_____________________
206  * 11111111________________
207  * ____________________33__
208  * ___________44___________
209  * __________33333_________
210  * ______________22________
211  * ___________________2222_
212  * _________111111111______
213  * _____________________11_
214  * _________________4______
215  *
216  * Sanitized equivalent (no overlap):
217  * 1_______________________
218  * _44_____________________
219  * ___1____________________
220  * ____22__________________
221  * ______11________________
222  * _________1______________
223  * __________3_____________
224  * ___________44___________
225  * _____________33_________
226  * _______________2________
227  * ________________1_______
228  * _________________4______
229  * ___________________2____
230  * ____________________33__
231  * ______________________4_
232  */
233 struct change_member {
234  struct e820entry *pbios; /* pointer to original bios entry */
235  unsigned long long addr; /* address for this change point */
236 };
237 
238 static int __init cpcompare(const void *a, const void *b)
239 {
240  struct change_member * const *app = a, * const *bpp = b;
241  const struct change_member *ap = *app, *bp = *bpp;
242 
243  /*
244  * Inputs are pointers to two elements of change_point[]. If their
245  * addresses are unequal, their difference dominates. If the addresses
246  * are equal, then consider one that represents the end of its region
247  * to be greater than one that does not.
248  */
249  if (ap->addr != bp->addr)
250  return ap->addr > bp->addr ? 1 : -1;
251 
252  return (ap->addr != ap->pbios->addr) - (bp->addr != bp->pbios->addr);
253 }
254 
255 int __init sanitize_e820_map(struct e820entry *biosmap, int max_nr_map,
256  u32 *pnr_map)
257 {
258  static struct change_member change_point_list[2*E820_X_MAX] __initdata;
259  static struct change_member *change_point[2*E820_X_MAX] __initdata;
260  static struct e820entry *overlap_list[E820_X_MAX] __initdata;
261  static struct e820entry new_bios[E820_X_MAX] __initdata;
262  unsigned long current_type, last_type;
263  unsigned long long last_addr;
264  int chgidx;
265  int overlap_entries;
266  int new_bios_entry;
267  int old_nr, new_nr, chg_nr;
268  int i;
269 
270  /* if there's only one memory region, don't bother */
271  if (*pnr_map < 2)
272  return -1;
273 
274  old_nr = *pnr_map;
275  BUG_ON(old_nr > max_nr_map);
276 
277  /* bail out if we find any unreasonable addresses in bios map */
278  for (i = 0; i < old_nr; i++)
279  if (biosmap[i].addr + biosmap[i].size < biosmap[i].addr)
280  return -1;
281 
282  /* create pointers for initial change-point information (for sorting) */
283  for (i = 0; i < 2 * old_nr; i++)
284  change_point[i] = &change_point_list[i];
285 
286  /* record all known change-points (starting and ending addresses),
287  omitting those that are for empty memory regions */
288  chgidx = 0;
289  for (i = 0; i < old_nr; i++) {
290  if (biosmap[i].size != 0) {
291  change_point[chgidx]->addr = biosmap[i].addr;
292  change_point[chgidx++]->pbios = &biosmap[i];
293  change_point[chgidx]->addr = biosmap[i].addr +
294  biosmap[i].size;
295  change_point[chgidx++]->pbios = &biosmap[i];
296  }
297  }
298  chg_nr = chgidx;
299 
300  /* sort change-point list by memory addresses (low -> high) */
301  sort(change_point, chg_nr, sizeof *change_point, cpcompare, NULL);
302 
303  /* create a new bios memory map, removing overlaps */
304  overlap_entries = 0; /* number of entries in the overlap table */
305  new_bios_entry = 0; /* index for creating new bios map entries */
306  last_type = 0; /* start with undefined memory type */
307  last_addr = 0; /* start with 0 as last starting address */
308 
309  /* loop through change-points, determining affect on the new bios map */
310  for (chgidx = 0; chgidx < chg_nr; chgidx++) {
311  /* keep track of all overlapping bios entries */
312  if (change_point[chgidx]->addr ==
313  change_point[chgidx]->pbios->addr) {
314  /*
315  * add map entry to overlap list (> 1 entry
316  * implies an overlap)
317  */
318  overlap_list[overlap_entries++] =
319  change_point[chgidx]->pbios;
320  } else {
321  /*
322  * remove entry from list (order independent,
323  * so swap with last)
324  */
325  for (i = 0; i < overlap_entries; i++) {
326  if (overlap_list[i] ==
327  change_point[chgidx]->pbios)
328  overlap_list[i] =
329  overlap_list[overlap_entries-1];
330  }
331  overlap_entries--;
332  }
333  /*
334  * if there are overlapping entries, decide which
335  * "type" to use (larger value takes precedence --
336  * 1=usable, 2,3,4,4+=unusable)
337  */
338  current_type = 0;
339  for (i = 0; i < overlap_entries; i++)
340  if (overlap_list[i]->type > current_type)
341  current_type = overlap_list[i]->type;
342  /*
343  * continue building up new bios map based on this
344  * information
345  */
346  if (current_type != last_type) {
347  if (last_type != 0) {
348  new_bios[new_bios_entry].size =
349  change_point[chgidx]->addr - last_addr;
350  /*
351  * move forward only if the new size
352  * was non-zero
353  */
354  if (new_bios[new_bios_entry].size != 0)
355  /*
356  * no more space left for new
357  * bios entries ?
358  */
359  if (++new_bios_entry >= max_nr_map)
360  break;
361  }
362  if (current_type != 0) {
363  new_bios[new_bios_entry].addr =
364  change_point[chgidx]->addr;
365  new_bios[new_bios_entry].type = current_type;
366  last_addr = change_point[chgidx]->addr;
367  }
368  last_type = current_type;
369  }
370  }
371  /* retain count for new bios entries */
372  new_nr = new_bios_entry;
373 
374  /* copy new bios mapping into original location */
375  memcpy(biosmap, new_bios, new_nr * sizeof(struct e820entry));
376  *pnr_map = new_nr;
377 
378  return 0;
379 }
380 
381 static int __init __append_e820_map(struct e820entry *biosmap, int nr_map)
382 {
383  while (nr_map) {
384  u64 start = biosmap->addr;
385  u64 size = biosmap->size;
386  u64 end = start + size;
387  u32 type = biosmap->type;
388 
389  /* Overflow in 64 bits? Ignore the memory map. */
390  if (start > end)
391  return -1;
392 
393  e820_add_region(start, size, type);
394 
395  biosmap++;
396  nr_map--;
397  }
398  return 0;
399 }
400 
401 /*
402  * Copy the BIOS e820 map into a safe place.
403  *
404  * Sanity-check it while we're at it..
405  *
406  * If we're lucky and live on a modern system, the setup code
407  * will have given us a memory map that we can use to properly
408  * set up memory. If we aren't, we'll fake a memory map.
409  */
410 static int __init append_e820_map(struct e820entry *biosmap, int nr_map)
411 {
412  /* Only one memory region (or negative)? Ignore it */
413  if (nr_map < 2)
414  return -1;
415 
416  return __append_e820_map(biosmap, nr_map);
417 }
418 
419 static u64 __init __e820_update_range(struct e820map *e820x, u64 start,
420  u64 size, unsigned old_type,
421  unsigned new_type)
422 {
423  u64 end;
424  unsigned int i;
425  u64 real_updated_size = 0;
426 
427  BUG_ON(old_type == new_type);
428 
429  if (size > (ULLONG_MAX - start))
430  size = ULLONG_MAX - start;
431 
432  end = start + size;
433  printk(KERN_DEBUG "e820: update [mem %#010Lx-%#010Lx] ",
434  (unsigned long long) start, (unsigned long long) (end - 1));
435  e820_print_type(old_type);
436  printk(KERN_CONT " ==> ");
437  e820_print_type(new_type);
438  printk(KERN_CONT "\n");
439 
440  for (i = 0; i < e820x->nr_map; i++) {
441  struct e820entry *ei = &e820x->map[i];
442  u64 final_start, final_end;
443  u64 ei_end;
444 
445  if (ei->type != old_type)
446  continue;
447 
448  ei_end = ei->addr + ei->size;
449  /* totally covered by new range? */
450  if (ei->addr >= start && ei_end <= end) {
451  ei->type = new_type;
452  real_updated_size += ei->size;
453  continue;
454  }
455 
456  /* new range is totally covered? */
457  if (ei->addr < start && ei_end > end) {
458  __e820_add_region(e820x, start, size, new_type);
459  __e820_add_region(e820x, end, ei_end - end, ei->type);
460  ei->size = start - ei->addr;
461  real_updated_size += size;
462  continue;
463  }
464 
465  /* partially covered */
466  final_start = max(start, ei->addr);
467  final_end = min(end, ei_end);
468  if (final_start >= final_end)
469  continue;
470 
471  __e820_add_region(e820x, final_start, final_end - final_start,
472  new_type);
473 
474  real_updated_size += final_end - final_start;
475 
476  /*
477  * left range could be head or tail, so need to update
478  * size at first.
479  */
480  ei->size -= final_end - final_start;
481  if (ei->addr < final_start)
482  continue;
483  ei->addr = final_end;
484  }
485  return real_updated_size;
486 }
487 
488 u64 __init e820_update_range(u64 start, u64 size, unsigned old_type,
489  unsigned new_type)
490 {
491  return __e820_update_range(&e820, start, size, old_type, new_type);
492 }
493 
494 static u64 __init e820_update_range_saved(u64 start, u64 size,
495  unsigned old_type, unsigned new_type)
496 {
497  return __e820_update_range(&e820_saved, start, size, old_type,
498  new_type);
499 }
500 
501 /* make e820 not cover the range */
502 u64 __init e820_remove_range(u64 start, u64 size, unsigned old_type,
503  int checktype)
504 {
505  int i;
506  u64 end;
507  u64 real_removed_size = 0;
508 
509  if (size > (ULLONG_MAX - start))
510  size = ULLONG_MAX - start;
511 
512  end = start + size;
513  printk(KERN_DEBUG "e820: remove [mem %#010Lx-%#010Lx] ",
514  (unsigned long long) start, (unsigned long long) (end - 1));
515  if (checktype)
516  e820_print_type(old_type);
517  printk(KERN_CONT "\n");
518 
519  for (i = 0; i < e820.nr_map; i++) {
520  struct e820entry *ei = &e820.map[i];
521  u64 final_start, final_end;
522  u64 ei_end;
523 
524  if (checktype && ei->type != old_type)
525  continue;
526 
527  ei_end = ei->addr + ei->size;
528  /* totally covered? */
529  if (ei->addr >= start && ei_end <= end) {
530  real_removed_size += ei->size;
531  memset(ei, 0, sizeof(struct e820entry));
532  continue;
533  }
534 
535  /* new range is totally covered? */
536  if (ei->addr < start && ei_end > end) {
537  e820_add_region(end, ei_end - end, ei->type);
538  ei->size = start - ei->addr;
539  real_removed_size += size;
540  continue;
541  }
542 
543  /* partially covered */
544  final_start = max(start, ei->addr);
545  final_end = min(end, ei_end);
546  if (final_start >= final_end)
547  continue;
548  real_removed_size += final_end - final_start;
549 
550  /*
551  * left range could be head or tail, so need to update
552  * size at first.
553  */
554  ei->size -= final_end - final_start;
555  if (ei->addr < final_start)
556  continue;
557  ei->addr = final_end;
558  }
559  return real_removed_size;
560 }
561 
562 void __init update_e820(void)
563 {
564  u32 nr_map;
565 
566  nr_map = e820.nr_map;
567  if (sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &nr_map))
568  return;
569  e820.nr_map = nr_map;
570  printk(KERN_INFO "e820: modified physical RAM map:\n");
571  e820_print_map("modified");
572 }
573 static void __init update_e820_saved(void)
574 {
575  u32 nr_map;
576 
577  nr_map = e820_saved.nr_map;
578  if (sanitize_e820_map(e820_saved.map, ARRAY_SIZE(e820_saved.map), &nr_map))
579  return;
580  e820_saved.nr_map = nr_map;
581 }
582 #define MAX_GAP_END 0x100000000ull
583 /*
584  * Search for a gap in the e820 memory space from start_addr to end_addr.
585  */
586 __init int e820_search_gap(unsigned long *gapstart, unsigned long *gapsize,
587  unsigned long start_addr, unsigned long long end_addr)
588 {
589  unsigned long long last;
590  int i = e820.nr_map;
591  int found = 0;
592 
593  last = (end_addr && end_addr < MAX_GAP_END) ? end_addr : MAX_GAP_END;
594 
595  while (--i >= 0) {
596  unsigned long long start = e820.map[i].addr;
597  unsigned long long end = start + e820.map[i].size;
598 
599  if (end < start_addr)
600  continue;
601 
602  /*
603  * Since "last" is at most 4GB, we know we'll
604  * fit in 32 bits if this condition is true
605  */
606  if (last > end) {
607  unsigned long gap = last - end;
608 
609  if (gap >= *gapsize) {
610  *gapsize = gap;
611  *gapstart = end;
612  found = 1;
613  }
614  }
615  if (start < last)
616  last = start;
617  }
618  return found;
619 }
620 
621 /*
622  * Search for the biggest gap in the low 32 bits of the e820
623  * memory space. We pass this space to PCI to assign MMIO resources
624  * for hotplug or unconfigured devices in.
625  * Hopefully the BIOS let enough space left.
626  */
628 {
629  unsigned long gapstart, gapsize;
630  int found;
631 
632  gapstart = 0x10000000;
633  gapsize = 0x400000;
634  found = e820_search_gap(&gapstart, &gapsize, 0, MAX_GAP_END);
635 
636 #ifdef CONFIG_X86_64
637  if (!found) {
638  gapstart = (max_pfn << PAGE_SHIFT) + 1024*1024;
640  "e820: cannot find a gap in the 32bit address range\n"
641  "e820: PCI devices with unassigned 32bit BARs may break!\n");
642  }
643 #endif
644 
645  /*
646  * e820_reserve_resources_late protect stolen RAM already
647  */
648  pci_mem_start = gapstart;
649 
651  "e820: [mem %#010lx-%#010lx] available for PCI devices\n",
652  gapstart, gapstart + gapsize - 1);
653 }
654 
662 {
663  int entries;
664  struct e820entry *extmap;
665 
666  entries = sdata->len / sizeof(struct e820entry);
667  extmap = (struct e820entry *)(sdata->data);
668  __append_e820_map(extmap, entries);
669  sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map);
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 
684 void __init e820_mark_nosave_regions(unsigned long limit_pfn)
685 {
686  int i;
687  unsigned long pfn;
688 
689  pfn = PFN_DOWN(e820.map[0].addr + e820.map[0].size);
690  for (i = 1; i < e820.nr_map; i++) {
691  struct e820entry *ei = &e820.map[i];
692 
693  if (pfn < PFN_UP(ei->addr))
694  register_nosave_region(pfn, PFN_UP(ei->addr));
695 
696  pfn = PFN_DOWN(ei->addr + ei->size);
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 
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  */
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_opt(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  */
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
876  e820_remove_range(mem_size, ULLONG_MAX - mem_size, E820_RAM, 1);
877 
878  return *p == '\0' ? 0 : -EINVAL;
879 }
880 early_param("memmap", parse_memmap_opt);
881 
883 {
884  if (userdef) {
885  u32 nr = e820.nr_map;
886 
887  if (sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &nr) < 0)
888  early_panic("Invalid user supplied memory map");
889  e820.nr_map = nr;
890 
891  printk(KERN_INFO "e820: user-defined physical RAM map:\n");
892  e820_print_map("user");
893  }
894 }
895 
896 static inline const char *e820_type_to_string(int e820_type)
897 {
898  switch (e820_type) {
899  case E820_RESERVED_KERN:
900  case E820_RAM: return "System RAM";
901  case E820_ACPI: return "ACPI Tables";
902  case E820_NVS: return "ACPI Non-volatile Storage";
903  case E820_UNUSABLE: return "Unusable memory";
904  default: return "reserved";
905  }
906 }
907 
908 /*
909  * Mark e820 reserved areas as busy for the resource manager.
910  */
911 static struct resource __initdata *e820_res;
913 {
914  int i;
915  struct resource *res;
916  u64 end;
917 
918  res = alloc_bootmem(sizeof(struct resource) * e820.nr_map);
919  e820_res = res;
920  for (i = 0; i < e820.nr_map; i++) {
921  end = e820.map[i].addr + e820.map[i].size - 1;
922  if (end != (resource_size_t)end) {
923  res++;
924  continue;
925  }
926  res->name = e820_type_to_string(e820.map[i].type);
927  res->start = e820.map[i].addr;
928  res->end = end;
929 
930  res->flags = IORESOURCE_MEM;
931 
932  /*
933  * don't register the region that could be conflicted with
934  * pci device BAR resource and insert them later in
935  * pcibios_resource_survey()
936  */
937  if (e820.map[i].type != E820_RESERVED || res->start < (1ULL<<20)) {
938  res->flags |= IORESOURCE_BUSY;
940  }
941  res++;
942  }
943 
944  for (i = 0; i < e820_saved.nr_map; i++) {
945  struct e820entry *entry = &e820_saved.map[i];
947  entry->addr + entry->size,
948  e820_type_to_string(entry->type));
949  }
950 }
951 
952 /* How much should we pad RAM ending depending on where it is? */
953 static unsigned long ram_alignment(resource_size_t pos)
954 {
955  unsigned long mb = pos >> 20;
956 
957  /* To 64kB in the first megabyte */
958  if (!mb)
959  return 64*1024;
960 
961  /* To 1MB in the first 16MB */
962  if (mb < 16)
963  return 1024*1024;
964 
965  /* To 64MB for anything above that */
966  return 64*1024*1024;
967 }
968 
969 #define MAX_RESOURCE_SIZE ((resource_size_t)-1)
970 
972 {
973  int i;
974  struct resource *res;
975 
976  res = e820_res;
977  for (i = 0; i < e820.nr_map; i++) {
978  if (!res->parent && res->end)
980  res++;
981  }
982 
983  /*
984  * Try to bump up RAM regions to reasonable boundaries to
985  * avoid stolen RAM:
986  */
987  for (i = 0; i < e820.nr_map; i++) {
988  struct e820entry *entry = &e820.map[i];
989  u64 start, end;
990 
991  if (entry->type != E820_RAM)
992  continue;
993  start = entry->addr + entry->size;
994  end = round_up(start, ram_alignment(start)) - 1;
995  if (end > MAX_RESOURCE_SIZE)
996  end = MAX_RESOURCE_SIZE;
997  if (start >= end)
998  continue;
1000  "e820: reserve RAM buffer [mem %#010llx-%#010llx]\n",
1001  start, end);
1003  "RAM buffer");
1004  }
1005 }
1006 
1008 {
1009  char *who = "BIOS-e820";
1010  u32 new_nr;
1011  /*
1012  * Try to copy the BIOS-supplied E820-map.
1013  *
1014  * Otherwise fake a memory map; one section from 0k->640k,
1015  * the next section from 1mb->appropriate_mem_k
1016  */
1017  new_nr = boot_params.e820_entries;
1020  &new_nr);
1021  boot_params.e820_entries = new_nr;
1022  if (append_e820_map(boot_params.e820_map, boot_params.e820_entries)
1023  < 0) {
1024  u64 mem_size;
1025 
1026  /* compare results from other methods and take the greater */
1028  < boot_params.screen_info.ext_mem_k) {
1029  mem_size = boot_params.screen_info.ext_mem_k;
1030  who = "BIOS-88";
1031  } else {
1032  mem_size = boot_params.alt_mem_k;
1033  who = "BIOS-e801";
1034  }
1035 
1036  e820.nr_map = 0;
1037  e820_add_region(0, LOWMEMSIZE(), E820_RAM);
1038  e820_add_region(HIGH_MEMORY, mem_size << 10, E820_RAM);
1039  }
1040 
1041  /* In case someone cares... */
1042  return who;
1043 }
1044 
1046 {
1047  char *who;
1048 
1049  who = x86_init.resources.memory_setup();
1050  memcpy(&e820_saved, &e820, sizeof(struct e820map));
1051  printk(KERN_INFO "e820: BIOS-provided physical RAM map:\n");
1052  e820_print_map(who);
1053 }
1054 
1056 {
1057  int i;
1058  u64 end;
1059 
1060  /*
1061  * EFI may have more than 128 entries
1062  * We are safe to enable resizing, beause memblock_x86_fill()
1063  * is rather later for x86
1064  */
1066 
1067  for (i = 0; i < e820.nr_map; i++) {
1068  struct e820entry *ei = &e820.map[i];
1069 
1070  end = ei->addr + ei->size;
1071  if (end != (resource_size_t)end)
1072  continue;
1073 
1074  if (ei->type != E820_RAM && ei->type != E820_RESERVED_KERN)
1075  continue;
1076 
1077  memblock_add(ei->addr, ei->size);
1078  }
1079 
1080  /* throw away partial pages */
1082 
1083  memblock_dump_all();
1084 }
1085 
1087 {
1088 #ifdef CONFIG_X86_64
1089  u64 nr_pages = 0, nr_free_pages = 0;
1090  unsigned long start_pfn, end_pfn;
1092  int i;
1093  u64 u;
1094 
1095  /*
1096  * need to find out used area below MAX_DMA_PFN
1097  * need to use memblock to get free size in [0, MAX_DMA_PFN]
1098  * at first, and assume boot_mem will not take below MAX_DMA_PFN
1099  */
1100  for_each_mem_pfn_range(i, MAX_NUMNODES, &start_pfn, &end_pfn, NULL) {
1101  start_pfn = min_t(unsigned long, start_pfn, MAX_DMA_PFN);
1102  end_pfn = min_t(unsigned long, end_pfn, MAX_DMA_PFN);
1103  nr_pages += end_pfn - start_pfn;
1104  }
1105 
1106  for_each_free_mem_range(u, MAX_NUMNODES, &start, &end, NULL) {
1107  start_pfn = min_t(unsigned long, PFN_UP(start), MAX_DMA_PFN);
1108  end_pfn = min_t(unsigned long, PFN_DOWN(end), MAX_DMA_PFN);
1109  if (start_pfn < end_pfn)
1110  nr_free_pages += end_pfn - start_pfn;
1111  }
1112 
1113  set_dma_reserve(nr_pages - nr_free_pages);
1114 #endif
1115 }