arch/x86/mm/numa_32.c

   1 /*
   2  * Written by: Patricia Gaughen <gone@us.ibm.com>, IBM Corporation
   3  * August 2002: added remote node KVA remap - Martin J. Bligh
   4  *
   5  * Copyright (C) 2002, IBM Corp.
   6  *
   7  * All rights reserved.
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful, but
  15  * WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
  17  * NON INFRINGEMENT.  See the GNU General Public License for more
  18  * details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  23  */
  24
  25 #include <linux/mm.h>
  26 #include <linux/bootmem.h>
  27 #include <linux/memblock.h>
  28 #include <linux/mmzone.h>
  29 #include <linux/highmem.h>
  30 #include <linux/initrd.h>
  31 #include <linux/nodemask.h>
  32 #include <linux/module.h>
  33 #include <linux/kexec.h>
  34 #include <linux/pfn.h>
  35 #include <linux/swap.h>
  36 #include <linux/acpi.h>
  37
  38 #include <asm/e820.h>
  39 #include <asm/setup.h>
  40 #include <asm/mmzone.h>
  41 #include <asm/bios_ebda.h>
  42 #include <asm/proto.h>
  43
  44 /*
  45  * numa interface - we expect the numa architecture specific code to have
  46  *                  populated the following initialisation.
  47  *
  48  * 1) node_online_map  - the map of all nodes configured (online) in the system
  49  * 2) node_start_pfn   - the starting page frame number for a node
  50  * 3) node_end_pfn     - the ending page fram number for a node
  51  */
  52 unsigned long node_start_pfn[MAX_NUMNODES] __read_mostly;
  53 unsigned long node_end_pfn[MAX_NUMNODES] __read_mostly;
  54
  55
  56 #ifdef CONFIG_DISCONTIGMEM
  57 /*
  58  * 4) physnode_map     - the mapping between a pfn and owning node
  59  * physnode_map keeps track of the physical memory layout of a generic
  60  * numa node on a 64Mb break (each element of the array will
  61  * represent 64Mb of memory and will be marked by the node id.  so,
  62  * if the first gig is on node 0, and the second gig is on node 1
  63  * physnode_map will contain:
  64  *
  65  *     physnode_map[0-15] = 0;
  66  *     physnode_map[16-31] = 1;
  67  *     physnode_map[32- ] = -1;
  68  */
  69 s8 physnode_map[MAX_ELEMENTS] __read_mostly = { [0 ... (MAX_ELEMENTS - 1)] = -1};
  70 EXPORT_SYMBOL(physnode_map);
  71
  72 void memory_present(int nid, unsigned long start, unsigned long end)
  73 {
  74         unsigned long pfn;
  75
  76         printk(KERN_INFO "Node: %d, start_pfn: %lx, end_pfn: %lx\n",
  77                         nid, start, end);
  78         printk(KERN_DEBUG "  Setting physnode_map array to node %d for pfns:\n", nid);
  79         printk(KERN_DEBUG "  ");
  80         for (pfn = start; pfn < end; pfn += PAGES_PER_ELEMENT) {
  81                 physnode_map[pfn / PAGES_PER_ELEMENT] = nid;
  82                 printk(KERN_CONT "%lx ", pfn);
  83         }
  84         printk(KERN_CONT "\n");
  85 }
  86
  87 unsigned long node_memmap_size_bytes(int nid, unsigned long start_pfn,
  88                                               unsigned long end_pfn)
  89 {
  90         unsigned long nr_pages = end_pfn - start_pfn;
  91
  92         if (!nr_pages)
  93                 return 0;
  94
  95         return (nr_pages + 1) * sizeof(struct page);
  96 }
  97 #endif
  98
  99 extern unsigned long find_max_low_pfn(void);
 100 extern unsigned long highend_pfn, highstart_pfn;
 101
 102 #define LARGE_PAGE_BYTES (PTRS_PER_PTE * PAGE_SIZE)
 103
 104 static void *node_remap_start_vaddr[MAX_NUMNODES];
 105 void set_pmd_pfn(unsigned long vaddr, unsigned long pfn, pgprot_t flags);
 106
 107 /*
 108  * FLAT - support for basic PC memory model with discontig enabled, essentially
 109  *        a single node with all available processors in it with a flat
 110  *        memory map.
 111  */
 112 static int __init get_memcfg_numa_flat(void)
 113 {
 114         printk(KERN_DEBUG "NUMA - single node, flat memory mode\n");
 115
 116         node_start_pfn[0] = 0;
 117         node_end_pfn[0] = max_pfn;
 118         memblock_x86_register_active_regions(0, 0, max_pfn);
 119
 120         /* Indicate there is one node available. */
 121         nodes_clear(node_online_map);
 122         node_set_online(0);
 123         return 1;
 124 }
 125
 126 /*
 127  * Find the highest page frame number we have available for the node
 128  */
 129 static void __init propagate_e820_map_node(int nid)
 130 {
 131         if (node_end_pfn[nid] > max_pfn)
 132                 node_end_pfn[nid] = max_pfn;
 133         /*
 134          * if a user has given mem=XXXX, then we need to make sure
 135          * that the node _starts_ before that, too, not just ends
 136          */
 137         if (node_start_pfn[nid] > max_pfn)
 138                 node_start_pfn[nid] = max_pfn;
 139         BUG_ON(node_start_pfn[nid] > node_end_pfn[nid]);
 140 }
 141
 142 /*
 143  * Allocate memory for the pg_data_t for this node via a crude pre-bootmem
 144  * method.  For node zero take this from the bottom of memory, for
 145  * subsequent nodes place them at node_remap_start_vaddr which contains
 146  * node local data in physically node local memory.  See setup_memory()
 147  * for details.
 148  */
 149 static void __init allocate_pgdat(int nid)
 150 {
 151         char buf[16];
 152
 153         NODE_DATA(nid) = alloc_remap(nid, ALIGN(sizeof(pg_data_t), PAGE_SIZE));
 154         if (!NODE_DATA(nid)) {
 155                 unsigned long pgdat_phys;
 156                 pgdat_phys = memblock_find_in_range(min_low_pfn<<PAGE_SHIFT,
 157                                  max_pfn_mapped<<PAGE_SHIFT,
 158                                  sizeof(pg_data_t),
 159                                  PAGE_SIZE);
 160                 NODE_DATA(nid) = (pg_data_t *)(pfn_to_kaddr(pgdat_phys>>PAGE_SHIFT));
 161                 memset(buf, 0, sizeof(buf));
 162                 sprintf(buf, "NODE_DATA %d",  nid);
 163                 memblock_x86_reserve_range(pgdat_phys, pgdat_phys + sizeof(pg_data_t), buf);
 164         }
 165         printk(KERN_DEBUG "allocate_pgdat: node %d NODE_DATA %08lx\n",
 166                 nid, (unsigned long)NODE_DATA(nid));
 167 }
 168
 169 /*
 170  * Remap memory allocator
 171  */
 172 static unsigned long node_remap_start_pfn[MAX_NUMNODES];
 173 static void *node_remap_end_vaddr[MAX_NUMNODES];
 174 static void *node_remap_alloc_vaddr[MAX_NUMNODES];
 175
 176 /**
 177  * alloc_remap - Allocate remapped memory
 178  * @nid: NUMA node to allocate memory from
 179  * @size: The size of allocation
 180  *
 181  * Allocate @size bytes from the remap area of NUMA node @nid.  The
 182  * size of the remap area is predetermined by init_alloc_remap() and
 183  * only the callers considered there should call this function.  For
 184  * more info, please read the comment on top of init_alloc_remap().
 185  *
 186  * The caller must be ready to handle allocation failure from this
 187  * function and fall back to regular memory allocator in such cases.
 188  *
 189  * CONTEXT:
 190  * Single CPU early boot context.
 191  *
 192  * RETURNS:
 193  * Pointer to the allocated memory on success, %NULL on failure.
 194  */
 195 void *alloc_remap(int nid, unsigned long size)
 196 {
 197         void *allocation = node_remap_alloc_vaddr[nid];
 198
 199         size = ALIGN(size, L1_CACHE_BYTES);
 200
 201         if (!allocation || (allocation + size) > node_remap_end_vaddr[nid])
 202                 return NULL;
 203
 204         node_remap_alloc_vaddr[nid] += size;
 205         memset(allocation, 0, size);
 206
 207         return allocation;
 208 }
 209
 210 #ifdef CONFIG_HIBERNATION
 211 /**
 212  * resume_map_numa_kva - add KVA mapping to the temporary page tables created
 213  *                       during resume from hibernation
 214  * @pgd_base - temporary resume page directory
 215  */
 216 void resume_map_numa_kva(pgd_t *pgd_base)
 217 {
 218         int node;
 219
 220         for_each_online_node(node) {
 221                 unsigned long start_va, start_pfn, nr_pages, pfn;
 222
 223                 start_va = (unsigned long)node_remap_start_vaddr[node];
 224                 start_pfn = node_remap_start_pfn[node];
 225                 nr_pages = (node_remap_end_vaddr[node] -
 226                             node_remap_start_vaddr[node]) >> PAGE_SHIFT;
 227
 228                 printk(KERN_DEBUG "%s: node %d\n", __func__, node);
 229
 230                 for (pfn = 0; pfn < nr_pages; pfn += PTRS_PER_PTE) {
 231                         unsigned long vaddr = start_va + (pfn << PAGE_SHIFT);
 232                         pgd_t *pgd = pgd_base + pgd_index(vaddr);
 233                         pud_t *pud = pud_offset(pgd, vaddr);
 234                         pmd_t *pmd = pmd_offset(pud, vaddr);
 235
 236                         set_pmd(pmd, pfn_pmd(start_pfn + pfn,
 237                                                 PAGE_KERNEL_LARGE_EXEC));
 238
 239                         printk(KERN_DEBUG "%s: %08lx -> pfn %08lx\n",
 240                                 __func__, vaddr, start_pfn + pfn);
 241                 }
 242         }
 243 }
 244 #endif
 245
 246 /**
 247  * init_alloc_remap - Initialize remap allocator for a NUMA node
 248  * @nid: NUMA node to initizlie remap allocator for
 249  *
 250  * NUMA nodes may end up without any lowmem.  As allocating pgdat and
 251  * memmap on a different node with lowmem is inefficient, a special
 252  * remap allocator is implemented which can be used by alloc_remap().
 253  *
 254  * For each node, the amount of memory which will be necessary for
 255  * pgdat and memmap is calculated and two memory areas of the size are
 256  * allocated - one in the node and the other in lowmem; then, the area
 257  * in the node is remapped to the lowmem area.
 258  *
 259  * As pgdat and memmap must be allocated in lowmem anyway, this
 260  * doesn't waste lowmem address space; however, the actual lowmem
 261  * which gets remapped over is wasted.  The amount shouldn't be
 262  * problematic on machines this feature will be used.
 263  *
 264  * Initialization failure isn't fatal.  alloc_remap() is used
 265  * opportunistically and the callers will fall back to other memory
 266  * allocation mechanisms on failure.
 267  */
 268 static __init void init_alloc_remap(int nid)
 269 {
 270         unsigned long size, pfn;
 271         u64 node_pa, remap_pa;
 272         void *remap_va;
 273
 274         /*
 275          * The acpi/srat node info can show hot-add memroy zones where
 276          * memory could be added but not currently present.
 277          */
 278         printk(KERN_DEBUG "node %d pfn: [%lx - %lx]\n",
 279                nid, node_start_pfn[nid], node_end_pfn[nid]);
 280         if (node_start_pfn[nid] > max_pfn)
 281                 return;
 282         if (!node_end_pfn[nid])
 283                 return;
 284         if (node_end_pfn[nid] > max_pfn)
 285                 node_end_pfn[nid] = max_pfn;
 286
 287         /* calculate the necessary space aligned to large page size */
 288         size = node_memmap_size_bytes(nid, node_start_pfn[nid],
 289                                       min(node_end_pfn[nid], max_pfn));
 290         size += ALIGN(sizeof(pg_data_t), PAGE_SIZE);
 291         size = ALIGN(size, LARGE_PAGE_BYTES);
 292
 293         /* allocate node memory and the lowmem remap area */
 294         node_pa = memblock_find_in_range(node_start_pfn[nid] << PAGE_SHIFT,
 295                                          (u64)node_end_pfn[nid] << PAGE_SHIFT,
 296                                          size, LARGE_PAGE_BYTES);
 297         if (node_pa == MEMBLOCK_ERROR) {
 298                 pr_warning("remap_alloc: failed to allocate %lu bytes for node %d\n",
 299                            size, nid);
 300                 return;
 301         }
 302         memblock_x86_reserve_range(node_pa, node_pa + size, "KVA RAM");
 303
 304         remap_pa = memblock_find_in_range(min_low_pfn << PAGE_SHIFT,
 305                                           max_low_pfn << PAGE_SHIFT,
 306                                           size, LARGE_PAGE_BYTES);
 307         if (remap_pa == MEMBLOCK_ERROR) {
 308                 pr_warning("remap_alloc: failed to allocate %lu bytes remap area for node %d\n",
 309                            size, nid);
 310                 memblock_x86_free_range(node_pa, node_pa + size);
 311                 return;
 312         }
 313         memblock_x86_reserve_range(remap_pa, remap_pa + size, "KVA PG");
 314         remap_va = phys_to_virt(remap_pa);
 315
 316         /* perform actual remap */
 317         for (pfn = 0; pfn < size >> PAGE_SHIFT; pfn += PTRS_PER_PTE)
 318                 set_pmd_pfn((unsigned long)remap_va + (pfn << PAGE_SHIFT),
 319                             (node_pa >> PAGE_SHIFT) + pfn,
 320                             PAGE_KERNEL_LARGE);
 321
 322         /* initialize remap allocator parameters */
 323         node_remap_start_pfn[nid] = node_pa >> PAGE_SHIFT;
 324         node_remap_start_vaddr[nid] = remap_va;
 325         node_remap_end_vaddr[nid] = remap_va + size;
 326         node_remap_alloc_vaddr[nid] = remap_va;
 327
 328         printk(KERN_DEBUG "remap_alloc: node %d [%08llx-%08llx) -> [%p-%p)\n",
 329                nid, node_pa, node_pa + size, remap_va, remap_va + size);
 330 }
 331
 332 static int get_memcfg_numaq(void)
 333 {
 334 #ifdef CONFIG_X86_NUMAQ
 335         int nid;
 336
 337         if (numa_off)
 338                 return 0;
 339
 340         if (numaq_numa_init() < 0) {
 341                 nodes_clear(numa_nodes_parsed);
 342                 remove_all_active_ranges();
 343                 return 0;
 344         }
 345
 346         for_each_node_mask(nid, numa_nodes_parsed)
 347                 node_set_online(nid);
 348         sort_node_map();
 349         return 1;
 350 #else
 351         return 0;
 352 #endif
 353 }
 354
 355 static int get_memcfg_from_srat(void)
 356 {
 357 #ifdef CONFIG_ACPI_NUMA
 358         int nid;
 359
 360         if (numa_off)
 361                 return 0;
 362
 363         if (x86_acpi_numa_init() < 0) {
 364                 nodes_clear(numa_nodes_parsed);
 365                 remove_all_active_ranges();
 366                 return 0;
 367         }
 368
 369         for_each_node_mask(nid, numa_nodes_parsed)
 370                 node_set_online(nid);
 371         sort_node_map();
 372         return 1;
 373 #else
 374         return 0;
 375 #endif
 376 }
 377
 378 static void get_memcfg_numa(void)
 379 {
 380         if (get_memcfg_numaq())
 381                 return;
 382         if (get_memcfg_from_srat())
 383                 return;
 384         get_memcfg_numa_flat();
 385 }
 386
 387 void __init initmem_init(void)
 388 {
 389         int nid;
 390
 391         get_memcfg_numa();
 392         numa_init_array();
 393
 394         for_each_online_node(nid)
 395                 init_alloc_remap(nid);
 396
 397 #ifdef CONFIG_HIGHMEM
 398         highstart_pfn = highend_pfn = max_pfn;
 399         if (max_pfn > max_low_pfn)
 400                 highstart_pfn = max_low_pfn;
 401         printk(KERN_NOTICE "%ldMB HIGHMEM available.\n",
 402                pages_to_mb(highend_pfn - highstart_pfn));
 403         num_physpages = highend_pfn;
 404         high_memory = (void *) __va(highstart_pfn * PAGE_SIZE - 1) + 1;
 405 #else
 406         num_physpages = max_low_pfn;
 407         high_memory = (void *) __va(max_low_pfn * PAGE_SIZE - 1) + 1;
 408 #endif
 409         printk(KERN_NOTICE "%ldMB LOWMEM available.\n",
 410                         pages_to_mb(max_low_pfn));
 411         printk(KERN_DEBUG "max_low_pfn = %lx, highstart_pfn = %lx\n",
 412                         max_low_pfn, highstart_pfn);
 413
 414         printk(KERN_DEBUG "Low memory ends at vaddr %08lx\n",
 415                         (ulong) pfn_to_kaddr(max_low_pfn));
 416         for_each_online_node(nid)
 417                 allocate_pgdat(nid);
 418
 419         printk(KERN_DEBUG "High memory starts at vaddr %08lx\n",
 420                         (ulong) pfn_to_kaddr(highstart_pfn));
 421         for_each_online_node(nid)
 422                 propagate_e820_map_node(nid);
 423
 424         for_each_online_node(nid) {
 425                 memset(NODE_DATA(nid), 0, sizeof(struct pglist_data));
 426                 NODE_DATA(nid)->node_id = nid;
 427         }
 428
 429         setup_bootmem_allocator();
 430 }
 431
 432 #ifdef CONFIG_MEMORY_HOTPLUG
 433 static int paddr_to_nid(u64 addr)
 434 {
 435         int nid;
 436         unsigned long pfn = PFN_DOWN(addr);
 437
 438         for_each_node(nid)
 439                 if (node_start_pfn[nid] <= pfn &&
 440                     pfn < node_end_pfn[nid])
 441                         return nid;
 442
 443         return -1;
 444 }
 445
 446 /*
 447  * This function is used to ask node id BEFORE memmap and mem_section's
 448  * initialization (pfn_to_nid() can't be used yet).
 449  * If _PXM is not defined on ACPI's DSDT, node id must be found by this.
 450  */
 451 int memory_add_physaddr_to_nid(u64 addr)
 452 {
 453         int nid = paddr_to_nid(addr);
 454         return (nid >= 0) ? nid : 0;
 455 }
 456
 457 EXPORT_SYMBOL_GPL(memory_add_physaddr_to_nid);
 458 #endif
 459
 460 /* temporary shim, will go away soon */
 461 int __init numa_add_memblk(int nid, u64 start, u64 end)
 462 {
 463         unsigned long start_pfn = start >> PAGE_SHIFT;
 464         unsigned long end_pfn = end >> PAGE_SHIFT;
 465
 466         printk(KERN_DEBUG "nid %d start_pfn %08lx end_pfn %08lx\n",
 467                nid, start_pfn, end_pfn);
 468
 469         if (start >= (u64)max_pfn << PAGE_SHIFT) {
 470                 printk(KERN_INFO "Ignoring SRAT pfns: %08lx - %08lx\n",
 471                        start_pfn, end_pfn);
 472                 return 0;
 473         }
 474
 475         node_set_online(nid);
 476         memblock_x86_register_active_regions(nid, start_pfn,
 477                                              min(end_pfn, max_pfn));
 478
 479         if (!node_has_online_mem(nid)) {
 480                 node_start_pfn[nid] = start_pfn;
 481                 node_end_pfn[nid] = end_pfn;
 482         } else {
 483                 node_start_pfn[nid] = min(node_start_pfn[nid], start_pfn);
 484                 node_end_pfn[nid] = max(node_end_pfn[nid], end_pfn);
 485         }
 486         return 0;
 487 }
 488
 489 /* temporary shim, will go away soon */
 490 void __init numa_set_distance(int from, int to, int distance)
 491 {
 492         /* nada */
 493 }