arch/x86/kernel/e820_64.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/bootmem.h>
  15 #include <linux/ioport.h>
  16 #include <linux/string.h>
  17 #include <linux/kexec.h>
  18 #include <linux/module.h>
  19 #include <linux/mm.h>
  20 #include <linux/suspend.h>
  21 #include <linux/pfn.h>
  22 #include <linux/pci.h>
  23
  24 #include <asm/pgtable.h>
  25 #include <asm/page.h>
  26 #include <asm/e820.h>
  27 #include <asm/proto.h>
  28 #include <asm/setup.h>
  29 #include <asm/sections.h>
  30 #include <asm/kdebug.h>
  31 #include <asm/trampoline.h>
  32
  33 /*
  34  * PFN of last memory page.
  35  */
  36 unsigned long end_pfn;
  37
  38 /*
  39  * end_pfn only includes RAM, while max_pfn_mapped includes all e820 entries.
  40  * The direct mapping extends to max_pfn_mapped, so that we can directly access
  41  * apertures, ACPI and other tables without having to play with fixmaps.
  42  */
  43 unsigned long max_pfn_mapped;
  44
  45 /*
  46  * Last pfn which the user wants to use.
  47  */
  48 static unsigned long __initdata end_user_pfn = MAXMEM>>PAGE_SHIFT;
  49
  50 /*
  51  * Find the highest page frame number we have available
  52  */
  53 unsigned long __init e820_end_of_ram(void)
  54 {
  55         unsigned long last_pfn;
  56
  57         last_pfn = find_max_pfn_with_active_regions();
  58
  59         if (last_pfn > max_pfn_mapped)
  60                 max_pfn_mapped = last_pfn;
  61         if (max_pfn_mapped > MAXMEM>>PAGE_SHIFT)
  62                 max_pfn_mapped = MAXMEM>>PAGE_SHIFT;
  63         if (last_pfn > end_user_pfn)
  64                 last_pfn = end_user_pfn;
  65         if (last_pfn > max_pfn_mapped)
  66                 last_pfn = max_pfn_mapped;
  67
  68         printk(KERN_INFO "max_pfn_mapped = %lu\n", max_pfn_mapped);
  69         return last_pfn;
  70 }
  71
  72 /*
  73  * Mark e820 reserved areas as busy for the resource manager.
  74  */
  75 void __init e820_reserve_resources(void)
  76 {
  77         int i;
  78         struct resource *res;
  79
  80         res = alloc_bootmem_low(sizeof(struct resource) * e820.nr_map);
  81         for (i = 0; i < e820.nr_map; i++) {
  82                 switch (e820.map[i].type) {
  83                 case E820_RAM:  res->name = "System RAM"; break;
  84                 case E820_ACPI: res->name = "ACPI Tables"; break;
  85                 case E820_NVS:  res->name = "ACPI Non-volatile Storage"; break;
  86                 default:        res->name = "reserved";
  87                 }
  88                 res->start = e820.map[i].addr;
  89                 res->end = res->start + e820.map[i].size - 1;
  90                 res->flags = IORESOURCE_MEM | IORESOURCE_BUSY;
  91                 insert_resource(&iomem_resource, res);
  92                 res++;
  93         }
  94 }
  95
  96 /*
  97  * Find the ranges of physical addresses that do not correspond to
  98  * e820 RAM areas and mark the corresponding pages as nosave for software
  99  * suspend and suspend to RAM.
 100  *
 101  * This function requires the e820 map to be sorted and without any
 102  * overlapping entries and assumes the first e820 area to be RAM.
 103  */
 104 void __init e820_mark_nosave_regions(void)
 105 {
 106         int i;
 107         unsigned long paddr;
 108
 109         paddr = round_down(e820.map[0].addr + e820.map[0].size, PAGE_SIZE);
 110         for (i = 1; i < e820.nr_map; i++) {
 111                 struct e820entry *ei = &e820.map[i];
 112
 113                 if (paddr < ei->addr)
 114                         register_nosave_region(PFN_DOWN(paddr),
 115                                                 PFN_UP(ei->addr));
 116
 117                 paddr = round_down(ei->addr + ei->size, PAGE_SIZE);
 118                 if (ei->type != E820_RAM)
 119                         register_nosave_region(PFN_UP(ei->addr),
 120                                                 PFN_DOWN(paddr));
 121
 122                 if (paddr >= (end_pfn << PAGE_SHIFT))
 123                         break;
 124         }
 125 }
 126
 127 /*
 128  * Finds an active region in the address range from start_pfn to last_pfn and
 129  * returns its range in ei_startpfn and ei_endpfn for the e820 entry.
 130  */
 131 static int __init e820_find_active_region(const struct e820entry *ei,
 132                                           unsigned long start_pfn,
 133                                           unsigned long last_pfn,
 134                                           unsigned long *ei_startpfn,
 135                                           unsigned long *ei_endpfn)
 136 {
 137         *ei_startpfn = round_up(ei->addr, PAGE_SIZE) >> PAGE_SHIFT;
 138         *ei_endpfn = round_down(ei->addr + ei->size, PAGE_SIZE) >> PAGE_SHIFT;
 139
 140         /* Skip map entries smaller than a page */
 141         if (*ei_startpfn >= *ei_endpfn)
 142                 return 0;
 143
 144         /* Check if max_pfn_mapped should be updated */
 145         if (ei->type != E820_RAM && *ei_endpfn > max_pfn_mapped)
 146                 max_pfn_mapped = *ei_endpfn;
 147
 148         /* Skip if map is outside the node */
 149         if (ei->type != E820_RAM || *ei_endpfn <= start_pfn ||
 150                                     *ei_startpfn >= last_pfn)
 151                 return 0;
 152
 153         /* Check for overlaps */
 154         if (*ei_startpfn < start_pfn)
 155                 *ei_startpfn = start_pfn;
 156         if (*ei_endpfn > last_pfn)
 157                 *ei_endpfn = last_pfn;
 158
 159         /* Obey end_user_pfn to save on memmap */
 160         if (*ei_startpfn >= end_user_pfn)
 161                 return 0;
 162         if (*ei_endpfn > end_user_pfn)
 163                 *ei_endpfn = end_user_pfn;
 164
 165         return 1;
 166 }
 167
 168 /* Walk the e820 map and register active regions within a node */
 169 void __init
 170 e820_register_active_regions(int nid, unsigned long start_pfn,
 171                                                         unsigned long last_pfn)
 172 {
 173         unsigned long ei_startpfn;
 174         unsigned long ei_endpfn;
 175         int i;
 176
 177         for (i = 0; i < e820.nr_map; i++)
 178                 if (e820_find_active_region(&e820.map[i],
 179                                             start_pfn, last_pfn,
 180                                             &ei_startpfn, &ei_endpfn))
 181                         add_active_range(nid, ei_startpfn, ei_endpfn);
 182 }
 183
 184 /*
 185  * Find the hole size (in bytes) in the memory range.
 186  * @start: starting address of the memory range to scan
 187  * @end: ending address of the memory range to scan
 188  */
 189 unsigned long __init e820_hole_size(unsigned long start, unsigned long end)
 190 {
 191         unsigned long start_pfn = start >> PAGE_SHIFT;
 192         unsigned long last_pfn = end >> PAGE_SHIFT;
 193         unsigned long ei_startpfn, ei_endpfn, ram = 0;
 194         int i;
 195
 196         for (i = 0; i < e820.nr_map; i++) {
 197                 if (e820_find_active_region(&e820.map[i],
 198                                             start_pfn, last_pfn,
 199                                             &ei_startpfn, &ei_endpfn))
 200                         ram += ei_endpfn - ei_startpfn;
 201         }
 202         return end - start - (ram << PAGE_SHIFT);
 203 }
 204
 205 static void early_panic(char *msg)
 206 {
 207         early_printk(msg);
 208         panic(msg);
 209 }
 210
 211 /* We're not void only for x86 32-bit compat */
 212 char *__init machine_specific_memory_setup(void)
 213 {
 214         char *who = "BIOS-e820";
 215         int new_nr;
 216         /*
 217          * Try to copy the BIOS-supplied E820-map.
 218          *
 219          * Otherwise fake a memory map; one section from 0k->640k,
 220          * the next section from 1mb->appropriate_mem_k
 221          */
 222         new_nr = boot_params.e820_entries;
 223         sanitize_e820_map(boot_params.e820_map,
 224                         ARRAY_SIZE(boot_params.e820_map),
 225                         &new_nr);
 226         boot_params.e820_entries = new_nr;
 227         if (copy_e820_map(boot_params.e820_map, boot_params.e820_entries) < 0)
 228                 early_panic("Cannot find a valid memory map");
 229         printk(KERN_INFO "BIOS-provided physical RAM map:\n");
 230         e820_print_map(who);
 231
 232         /* In case someone cares... */
 233         return who;
 234 }
 235
 236 static int __init parse_memopt(char *p)
 237 {
 238         if (!p)
 239                 return -EINVAL;
 240         end_user_pfn = memparse(p, &p);
 241         end_user_pfn >>= PAGE_SHIFT;
 242         return 0;
 243 }
 244 early_param("mem", parse_memopt);
 245
 246 static int userdef __initdata;
 247
 248 static int __init parse_memmap_opt(char *p)
 249 {
 250         char *oldp;
 251         unsigned long long start_at, mem_size;
 252
 253         if (!strcmp(p, "exactmap")) {
 254 #ifdef CONFIG_CRASH_DUMP
 255                 /*
 256                  * If we are doing a crash dump, we still need to know
 257                  * the real mem size before original memory map is
 258                  * reset.
 259                  */
 260                 e820_register_active_regions(0, 0, -1UL);
 261                 saved_max_pfn = e820_end_of_ram();
 262                 remove_all_active_ranges();
 263 #endif
 264                 max_pfn_mapped = 0;
 265                 e820.nr_map = 0;
 266                 userdef = 1;
 267                 return 0;
 268         }
 269
 270         oldp = p;
 271         mem_size = memparse(p, &p);
 272         if (p == oldp)
 273                 return -EINVAL;
 274
 275         userdef = 1;
 276         if (*p == '@') {
 277                 start_at = memparse(p+1, &p);
 278                 add_memory_region(start_at, mem_size, E820_RAM);
 279         } else if (*p == '#') {
 280                 start_at = memparse(p+1, &p);
 281                 add_memory_region(start_at, mem_size, E820_ACPI);
 282         } else if (*p == '$') {
 283                 start_at = memparse(p+1, &p);
 284                 add_memory_region(start_at, mem_size, E820_RESERVED);
 285         } else {
 286                 end_user_pfn = (mem_size >> PAGE_SHIFT);
 287         }
 288         return *p == '\0' ? 0 : -EINVAL;
 289 }
 290 early_param("memmap", parse_memmap_opt);
 291
 292 void __init finish_e820_parsing(void)
 293 {
 294         if (userdef) {
 295                 int nr = e820.nr_map;
 296
 297                 if (sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &nr) < 0)
 298                         early_panic("Invalid user supplied memory map");
 299                 e820.nr_map = nr;
 300
 301                 printk(KERN_INFO "user-defined physical RAM map:\n");
 302                 e820_print_map("user");
 303         }
 304 }
 305
 306 int __init arch_get_ram_range(int slot, u64 *addr, u64 *size)
 307 {
 308         int i;
 309
 310         if (slot < 0 || slot >= e820.nr_map)
 311                 return -1;
 312         for (i = slot; i < e820.nr_map; i++) {
 313                 if (e820.map[i].type != E820_RAM)
 314                         continue;
 315                 break;
 316         }
 317         if (i == e820.nr_map || e820.map[i].addr > (max_pfn << PAGE_SHIFT))
 318                 return -1;
 319         *addr = e820.map[i].addr;
 320         *size = min_t(u64, e820.map[i].size + e820.map[i].addr,
 321                 max_pfn << PAGE_SHIFT) - *addr;
 322         return i + 1;
 323 }