~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/x86/kernel/e820.c

Version: ~ [ linux-5.4-rc3 ] ~ [ linux-5.3.6 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.79 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.149 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.196 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.196 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.75 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 unsigned long e820_type_to_iomem_type(int e820_type)
926 {
927         switch (e820_type) {
928         case E820_RESERVED_KERN:
929         case E820_RAM:
930                 return IORESOURCE_SYSTEM_RAM;
931         case E820_ACPI:
932         case E820_NVS:
933         case E820_UNUSABLE:
934         case E820_PRAM:
935         case E820_PMEM:
936         default:
937                 return IORESOURCE_MEM;
938         }
939 }
940 
941 static unsigned long e820_type_to_iores_desc(int e820_type)
942 {
943         switch (e820_type) {
944         case E820_ACPI:
945                 return IORES_DESC_ACPI_TABLES;
946         case E820_NVS:
947                 return IORES_DESC_ACPI_NV_STORAGE;
948         case E820_PMEM:
949                 return IORES_DESC_PERSISTENT_MEMORY;
950         case E820_PRAM:
951                 return IORES_DESC_PERSISTENT_MEMORY_LEGACY;
952         case E820_RESERVED_KERN:
953         case E820_RAM:
954         case E820_UNUSABLE:
955         default:
956                 return IORES_DESC_NONE;
957         }
958 }
959 
960 static bool do_mark_busy(u32 type, struct resource *res)
961 {
962         /* this is the legacy bios/dos rom-shadow + mmio region */
963         if (res->start < (1ULL<<20))
964                 return true;
965 
966         /*
967          * Treat persistent memory like device memory, i.e. reserve it
968          * for exclusive use of a driver
969          */
970         switch (type) {
971         case E820_RESERVED:
972         case E820_PRAM:
973         case E820_PMEM:
974                 return false;
975         default:
976                 return true;
977         }
978 }
979 
980 /*
981  * Mark e820 reserved areas as busy for the resource manager.
982  */
983 static struct resource __initdata *e820_res;
984 void __init e820_reserve_resources(void)
985 {
986         int i;
987         struct resource *res;
988         u64 end;
989 
990         res = alloc_bootmem(sizeof(struct resource) * e820.nr_map);
991         e820_res = res;
992         for (i = 0; i < e820.nr_map; i++) {
993                 end = e820.map[i].addr + e820.map[i].size - 1;
994                 if (end != (resource_size_t)end) {
995                         res++;
996                         continue;
997                 }
998                 res->name = e820_type_to_string(e820.map[i].type);
999                 res->start = e820.map[i].addr;
1000                 res->end = end;
1001 
1002                 res->flags = e820_type_to_iomem_type(e820.map[i].type);
1003                 res->desc = e820_type_to_iores_desc(e820.map[i].type);
1004 
1005                 /*
1006                  * don't register the region that could be conflicted with
1007                  * pci device BAR resource and insert them later in
1008                  * pcibios_resource_survey()
1009                  */
1010                 if (do_mark_busy(e820.map[i].type, res)) {
1011                         res->flags |= IORESOURCE_BUSY;
1012                         insert_resource(&iomem_resource, res);
1013                 }
1014                 res++;
1015         }
1016 
1017         for (i = 0; i < e820_saved.nr_map; i++) {
1018                 struct e820entry *entry = &e820_saved.map[i];
1019                 firmware_map_add_early(entry->addr,
1020                         entry->addr + entry->size,
1021                         e820_type_to_string(entry->type));
1022         }
1023 }
1024 
1025 /* How much should we pad RAM ending depending on where it is? */
1026 static unsigned long ram_alignment(resource_size_t pos)
1027 {
1028         unsigned long mb = pos >> 20;
1029 
1030         /* To 64kB in the first megabyte */
1031         if (!mb)
1032                 return 64*1024;
1033 
1034         /* To 1MB in the first 16MB */
1035         if (mb < 16)
1036                 return 1024*1024;
1037 
1038         /* To 64MB for anything above that */
1039         return 64*1024*1024;
1040 }
1041 
1042 #define MAX_RESOURCE_SIZE ((resource_size_t)-1)
1043 
1044 void __init e820_reserve_resources_late(void)
1045 {
1046         int i;
1047         struct resource *res;
1048 
1049         res = e820_res;
1050         for (i = 0; i < e820.nr_map; i++) {
1051                 if (!res->parent && res->end)
1052                         insert_resource_expand_to_fit(&iomem_resource, res);
1053                 res++;
1054         }
1055 
1056         /*
1057          * Try to bump up RAM regions to reasonable boundaries to
1058          * avoid stolen RAM:
1059          */
1060         for (i = 0; i < e820.nr_map; i++) {
1061                 struct e820entry *entry = &e820.map[i];
1062                 u64 start, end;
1063 
1064                 if (entry->type != E820_RAM)
1065                         continue;
1066                 start = entry->addr + entry->size;
1067                 end = round_up(start, ram_alignment(start)) - 1;
1068                 if (end > MAX_RESOURCE_SIZE)
1069                         end = MAX_RESOURCE_SIZE;
1070                 if (start >= end)
1071                         continue;
1072                 printk(KERN_DEBUG
1073                        "e820: reserve RAM buffer [mem %#010llx-%#010llx]\n",
1074                        start, end);
1075                 reserve_region_with_split(&iomem_resource, start, end,
1076                                           "RAM buffer");
1077         }
1078 }
1079 
1080 char *__init default_machine_specific_memory_setup(void)
1081 {
1082         char *who = "BIOS-e820";
1083         u32 new_nr;
1084         /*
1085          * Try to copy the BIOS-supplied E820-map.
1086          *
1087          * Otherwise fake a memory map; one section from 0k->640k,
1088          * the next section from 1mb->appropriate_mem_k
1089          */
1090         new_nr = boot_params.e820_entries;
1091         sanitize_e820_map(boot_params.e820_map,
1092                         ARRAY_SIZE(boot_params.e820_map),
1093                         &new_nr);
1094         boot_params.e820_entries = new_nr;
1095         if (append_e820_map(boot_params.e820_map, boot_params.e820_entries)
1096           < 0) {
1097                 u64 mem_size;
1098 
1099                 /* compare results from other methods and take the greater */
1100                 if (boot_params.alt_mem_k
1101                     < boot_params.screen_info.ext_mem_k) {
1102                         mem_size = boot_params.screen_info.ext_mem_k;
1103                         who = "BIOS-88";
1104                 } else {
1105                         mem_size = boot_params.alt_mem_k;
1106                         who = "BIOS-e801";
1107                 }
1108 
1109                 e820.nr_map = 0;
1110                 e820_add_region(0, LOWMEMSIZE(), E820_RAM);
1111                 e820_add_region(HIGH_MEMORY, mem_size << 10, E820_RAM);
1112         }
1113 
1114         /* In case someone cares... */
1115         return who;
1116 }
1117 
1118 void __init setup_memory_map(void)
1119 {
1120         char *who;
1121 
1122         who = x86_init.resources.memory_setup();
1123         memcpy(&e820_saved, &e820, sizeof(struct e820map));
1124         printk(KERN_INFO "e820: BIOS-provided physical RAM map:\n");
1125         e820_print_map(who);
1126 }
1127 
1128 void __init memblock_x86_fill(void)
1129 {
1130         int i;
1131         u64 end;
1132 
1133         /*
1134          * EFI may have more than 128 entries
1135          * We are safe to enable resizing, beause memblock_x86_fill()
1136          * is rather later for x86
1137          */
1138         memblock_allow_resize();
1139 
1140         for (i = 0; i < e820.nr_map; i++) {
1141                 struct e820entry *ei = &e820.map[i];
1142 
1143                 end = ei->addr + ei->size;
1144                 if (end != (resource_size_t)end)
1145                         continue;
1146 
1147                 if (ei->type != E820_RAM && ei->type != E820_RESERVED_KERN)
1148                         continue;
1149 
1150                 memblock_add(ei->addr, ei->size);
1151         }
1152 
1153         /* throw away partial pages */
1154         memblock_trim_memory(PAGE_SIZE);
1155 
1156         memblock_dump_all();
1157 }
1158 
1159 void __init memblock_find_dma_reserve(void)
1160 {
1161 #ifdef CONFIG_X86_64
1162         u64 nr_pages = 0, nr_free_pages = 0;
1163         unsigned long start_pfn, end_pfn;
1164         phys_addr_t start, end;
1165         int i;
1166         u64 u;
1167 
1168         /*
1169          * need to find out used area below MAX_DMA_PFN
1170          * need to use memblock to get free size in [0, MAX_DMA_PFN]
1171          * at first, and assume boot_mem will not take below MAX_DMA_PFN
1172          */
1173         for_each_mem_pfn_range(i, MAX_NUMNODES, &start_pfn, &end_pfn, NULL) {
1174                 start_pfn = min(start_pfn, MAX_DMA_PFN);
1175                 end_pfn = min(end_pfn, MAX_DMA_PFN);
1176                 nr_pages += end_pfn - start_pfn;
1177         }
1178 
1179         for_each_free_mem_range(u, NUMA_NO_NODE, MEMBLOCK_NONE, &start, &end,
1180                                 NULL) {
1181                 start_pfn = min_t(unsigned long, PFN_UP(start), MAX_DMA_PFN);
1182                 end_pfn = min_t(unsigned long, PFN_DOWN(end), MAX_DMA_PFN);
1183                 if (start_pfn < end_pfn)
1184                         nr_free_pages += end_pfn - start_pfn;
1185         }
1186 
1187         set_dma_reserve(nr_pages - nr_free_pages);
1188 #endif
1189 }
1190 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp