2 * Copyright (c) 2000, 2003 Silicon Graphics, Inc. All rights reserved.
3 * Copyright (c) 2001 Intel Corp.
4 * Copyright (c) 2001 Tony Luck <tony.luck@intel.com>
5 * Copyright (c) 2002 NEC Corp.
6 * Copyright (c) 2002 Kimio Suganuma <k-suganuma@da.jp.nec.com>
7 * Copyright (c) 2004 Silicon Graphics, Inc
8 * Russ Anderson <rja@sgi.com>
9 * Jesse Barnes <jbarnes@sgi.com>
10 * Jack Steiner <steiner@sgi.com>
14 * Platform initialization for Discontig Memory
17 #include <linux/kernel.h>
19 #include <linux/nmi.h>
20 #include <linux/swap.h>
21 #include <linux/bootmem.h>
22 #include <linux/acpi.h>
23 #include <linux/efi.h>
24 #include <linux/nodemask.h>
25 #include <asm/pgalloc.h>
27 #include <asm/meminit.h>
29 #include <asm/sections.h>
32 * Track per-node information needed to setup the boot memory allocator, the
33 * per-node areas, and the real VM.
35 struct early_node_data
{
36 struct ia64_node_data
*node_data
;
37 unsigned long pernode_addr
;
38 unsigned long pernode_size
;
39 unsigned long num_physpages
;
40 #ifdef CONFIG_ZONE_DMA
41 unsigned long num_dma_physpages
;
43 unsigned long min_pfn
;
44 unsigned long max_pfn
;
47 static struct early_node_data mem_data
[MAX_NUMNODES
] __initdata
;
48 static nodemask_t memory_less_mask __initdata
;
50 pg_data_t
*pgdat_list
[MAX_NUMNODES
];
53 * To prevent cache aliasing effects, align per-node structures so that they
54 * start at addresses that are strided by node number.
56 #define MAX_NODE_ALIGN_OFFSET (32 * 1024 * 1024)
57 #define NODEDATA_ALIGN(addr, node) \
58 ((((addr) + 1024*1024-1) & ~(1024*1024-1)) + \
59 (((node)*PERCPU_PAGE_SIZE) & (MAX_NODE_ALIGN_OFFSET - 1)))
62 * build_node_maps - callback to setup bootmem structs for each node
63 * @start: physical start of range
64 * @len: length of range
65 * @node: node where this range resides
67 * We allocate a struct bootmem_data for each piece of memory that we wish to
68 * treat as a virtually contiguous block (i.e. each node). Each such block
69 * must start on an %IA64_GRANULE_SIZE boundary, so we round the address down
70 * if necessary. Any non-existent pages will simply be part of the virtual
71 * memmap. We also update min_low_pfn and max_low_pfn here as we receive
72 * memory ranges from the caller.
74 static int __init
build_node_maps(unsigned long start
, unsigned long len
,
77 unsigned long spfn
, epfn
, end
= start
+ len
;
78 struct bootmem_data
*bdp
= &bootmem_node_data
[node
];
80 epfn
= GRANULEROUNDUP(end
) >> PAGE_SHIFT
;
81 spfn
= GRANULEROUNDDOWN(start
) >> PAGE_SHIFT
;
83 if (!bdp
->node_low_pfn
) {
84 bdp
->node_min_pfn
= spfn
;
85 bdp
->node_low_pfn
= epfn
;
87 bdp
->node_min_pfn
= min(spfn
, bdp
->node_min_pfn
);
88 bdp
->node_low_pfn
= max(epfn
, bdp
->node_low_pfn
);
95 * early_nr_cpus_node - return number of cpus on a given node
96 * @node: node to check
98 * Count the number of cpus on @node. We can't use nr_cpus_node() yet because
99 * acpi_boot_init() (which builds the node_to_cpu_mask array) hasn't been
100 * called yet. Note that node 0 will also count all non-existent cpus.
102 static int __meminit
early_nr_cpus_node(int node
)
106 for_each_possible_early_cpu(cpu
)
107 if (node
== node_cpuid
[cpu
].nid
)
114 * compute_pernodesize - compute size of pernode data
115 * @node: the node id.
117 static unsigned long __meminit
compute_pernodesize(int node
)
119 unsigned long pernodesize
= 0, cpus
;
121 cpus
= early_nr_cpus_node(node
);
122 pernodesize
+= PERCPU_PAGE_SIZE
* cpus
;
123 pernodesize
+= node
* L1_CACHE_BYTES
;
124 pernodesize
+= L1_CACHE_ALIGN(sizeof(pg_data_t
));
125 pernodesize
+= L1_CACHE_ALIGN(sizeof(struct ia64_node_data
));
126 pernodesize
+= L1_CACHE_ALIGN(sizeof(pg_data_t
));
127 pernodesize
= PAGE_ALIGN(pernodesize
);
132 * per_cpu_node_setup - setup per-cpu areas on each node
133 * @cpu_data: per-cpu area on this node
134 * @node: node to setup
136 * Copy the static per-cpu data into the region we just set aside and then
137 * setup __per_cpu_offset for each CPU on this node. Return a pointer to
138 * the end of the area.
140 static void *per_cpu_node_setup(void *cpu_data
, int node
)
145 for_each_possible_early_cpu(cpu
) {
146 void *src
= cpu
== 0 ? __cpu0_per_cpu
: __phys_per_cpu_start
;
148 if (node
!= node_cpuid
[cpu
].nid
)
151 memcpy(__va(cpu_data
), src
, __per_cpu_end
- __per_cpu_start
);
152 __per_cpu_offset
[cpu
] = (char *)__va(cpu_data
) -
156 * percpu area for cpu0 is moved from the __init area
157 * which is setup by head.S and used till this point.
158 * Update ar.k3. This move is ensures that percpu
159 * area for cpu0 is on the correct node and its
160 * virtual address isn't insanely far from other
161 * percpu areas which is important for congruent
165 ia64_set_kr(IA64_KR_PER_CPU_DATA
,
166 (unsigned long)cpu_data
-
167 (unsigned long)__per_cpu_start
);
169 cpu_data
+= PERCPU_PAGE_SIZE
;
176 * fill_pernode - initialize pernode data.
177 * @node: the node id.
178 * @pernode: physical address of pernode data
179 * @pernodesize: size of the pernode data
181 static void __init
fill_pernode(int node
, unsigned long pernode
,
182 unsigned long pernodesize
)
185 int cpus
= early_nr_cpus_node(node
);
186 struct bootmem_data
*bdp
= &bootmem_node_data
[node
];
188 mem_data
[node
].pernode_addr
= pernode
;
189 mem_data
[node
].pernode_size
= pernodesize
;
190 memset(__va(pernode
), 0, pernodesize
);
192 cpu_data
= (void *)pernode
;
193 pernode
+= PERCPU_PAGE_SIZE
* cpus
;
194 pernode
+= node
* L1_CACHE_BYTES
;
196 pgdat_list
[node
] = __va(pernode
);
197 pernode
+= L1_CACHE_ALIGN(sizeof(pg_data_t
));
199 mem_data
[node
].node_data
= __va(pernode
);
200 pernode
+= L1_CACHE_ALIGN(sizeof(struct ia64_node_data
));
202 pgdat_list
[node
]->bdata
= bdp
;
203 pernode
+= L1_CACHE_ALIGN(sizeof(pg_data_t
));
205 cpu_data
= per_cpu_node_setup(cpu_data
, node
);
211 * find_pernode_space - allocate memory for memory map and per-node structures
212 * @start: physical start of range
213 * @len: length of range
214 * @node: node where this range resides
216 * This routine reserves space for the per-cpu data struct, the list of
217 * pg_data_ts and the per-node data struct. Each node will have something like
218 * the following in the first chunk of addr. space large enough to hold it.
220 * ________________________
222 * |~~~~~~~~~~~~~~~~~~~~~~~~| <-- NODEDATA_ALIGN(start, node) for the first
223 * | PERCPU_PAGE_SIZE * | start and length big enough
224 * | cpus_on_this_node | Node 0 will also have entries for all non-existent cpus.
225 * |------------------------|
226 * | local pg_data_t * |
227 * |------------------------|
228 * | local ia64_node_data |
229 * |------------------------|
231 * |________________________|
233 * Once this space has been set aside, the bootmem maps are initialized. We
234 * could probably move the allocation of the per-cpu and ia64_node_data space
235 * outside of this function and use alloc_bootmem_node(), but doing it here
236 * is straightforward and we get the alignments we want so...
238 static int __init
find_pernode_space(unsigned long start
, unsigned long len
,
241 unsigned long spfn
, epfn
;
242 unsigned long pernodesize
= 0, pernode
, pages
, mapsize
;
243 struct bootmem_data
*bdp
= &bootmem_node_data
[node
];
245 spfn
= start
>> PAGE_SHIFT
;
246 epfn
= (start
+ len
) >> PAGE_SHIFT
;
248 pages
= bdp
->node_low_pfn
- bdp
->node_min_pfn
;
249 mapsize
= bootmem_bootmap_pages(pages
) << PAGE_SHIFT
;
252 * Make sure this memory falls within this node's usable memory
253 * since we may have thrown some away in build_maps().
255 if (spfn
< bdp
->node_min_pfn
|| epfn
> bdp
->node_low_pfn
)
258 /* Don't setup this node's local space twice... */
259 if (mem_data
[node
].pernode_addr
)
263 * Calculate total size needed, incl. what's necessary
264 * for good alignment and alias prevention.
266 pernodesize
= compute_pernodesize(node
);
267 pernode
= NODEDATA_ALIGN(start
, node
);
269 /* Is this range big enough for what we want to store here? */
270 if (start
+ len
> (pernode
+ pernodesize
+ mapsize
))
271 fill_pernode(node
, pernode
, pernodesize
);
277 * free_node_bootmem - free bootmem allocator memory for use
278 * @start: physical start of range
279 * @len: length of range
280 * @node: node where this range resides
282 * Simply calls the bootmem allocator to free the specified ranged from
283 * the given pg_data_t's bdata struct. After this function has been called
284 * for all the entries in the EFI memory map, the bootmem allocator will
285 * be ready to service allocation requests.
287 static int __init
free_node_bootmem(unsigned long start
, unsigned long len
,
290 free_bootmem_node(pgdat_list
[node
], start
, len
);
296 * reserve_pernode_space - reserve memory for per-node space
298 * Reserve the space used by the bootmem maps & per-node space in the boot
299 * allocator so that when we actually create the real mem maps we don't
302 static void __init
reserve_pernode_space(void)
304 unsigned long base
, size
, pages
;
305 struct bootmem_data
*bdp
;
308 for_each_online_node(node
) {
309 pg_data_t
*pdp
= pgdat_list
[node
];
311 if (node_isset(node
, memory_less_mask
))
316 /* First the bootmem_map itself */
317 pages
= bdp
->node_low_pfn
- bdp
->node_min_pfn
;
318 size
= bootmem_bootmap_pages(pages
) << PAGE_SHIFT
;
319 base
= __pa(bdp
->node_bootmem_map
);
320 reserve_bootmem_node(pdp
, base
, size
, BOOTMEM_DEFAULT
);
322 /* Now the per-node space */
323 size
= mem_data
[node
].pernode_size
;
324 base
= __pa(mem_data
[node
].pernode_addr
);
325 reserve_bootmem_node(pdp
, base
, size
, BOOTMEM_DEFAULT
);
329 static void __meminit
scatter_node_data(void)
335 * for_each_online_node() can't be used at here.
336 * node_online_map is not set for hot-added nodes at this time,
337 * because we are halfway through initialization of the new node's
338 * structures. If for_each_online_node() is used, a new node's
339 * pg_data_ptrs will be not initialized. Instead of using it,
340 * pgdat_list[] is checked.
342 for_each_node(node
) {
343 if (pgdat_list
[node
]) {
344 dst
= LOCAL_DATA_ADDR(pgdat_list
[node
])->pg_data_ptrs
;
345 memcpy(dst
, pgdat_list
, sizeof(pgdat_list
));
351 * initialize_pernode_data - fixup per-cpu & per-node pointers
353 * Each node's per-node area has a copy of the global pg_data_t list, so
354 * we copy that to each node here, as well as setting the per-cpu pointer
355 * to the local node data structure. The active_cpus field of the per-node
356 * structure gets setup by the platform_cpu_init() function later.
358 static void __init
initialize_pernode_data(void)
365 /* Set the node_data pointer for each per-cpu struct */
366 for_each_possible_early_cpu(cpu
) {
367 node
= node_cpuid
[cpu
].nid
;
368 per_cpu(cpu_info
, cpu
).node_data
= mem_data
[node
].node_data
;
372 struct cpuinfo_ia64
*cpu0_cpu_info
;
374 node
= node_cpuid
[cpu
].nid
;
375 cpu0_cpu_info
= (struct cpuinfo_ia64
*)(__phys_per_cpu_start
+
376 ((char *)&per_cpu__cpu_info
- __per_cpu_start
));
377 cpu0_cpu_info
->node_data
= mem_data
[node
].node_data
;
379 #endif /* CONFIG_SMP */
383 * memory_less_node_alloc - * attempt to allocate memory on the best NUMA slit
384 * node but fall back to any other node when __alloc_bootmem_node fails
387 * @pernodesize: size of this node's pernode data
389 static void __init
*memory_less_node_alloc(int nid
, unsigned long pernodesize
)
393 int bestnode
= -1, node
, anynode
= 0;
395 for_each_online_node(node
) {
396 if (node_isset(node
, memory_less_mask
))
398 else if (node_distance(nid
, node
) < best
) {
399 best
= node_distance(nid
, node
);
408 ptr
= __alloc_bootmem_node(pgdat_list
[bestnode
], pernodesize
,
409 PERCPU_PAGE_SIZE
, __pa(MAX_DMA_ADDRESS
));
415 * memory_less_nodes - allocate and initialize CPU only nodes pernode
418 static void __init
memory_less_nodes(void)
420 unsigned long pernodesize
;
424 for_each_node_mask(node
, memory_less_mask
) {
425 pernodesize
= compute_pernodesize(node
);
426 pernode
= memory_less_node_alloc(node
, pernodesize
);
427 fill_pernode(node
, __pa(pernode
), pernodesize
);
434 * find_memory - walk the EFI memory map and setup the bootmem allocator
436 * Called early in boot to setup the bootmem allocator, and to
437 * allocate the per-cpu and per-node structures.
439 void __init
find_memory(void)
445 if (num_online_nodes() == 0) {
446 printk(KERN_ERR
"node info missing!\n");
450 nodes_or(memory_less_mask
, memory_less_mask
, node_online_map
);
454 /* These actually end up getting called by call_pernode_memory() */
455 efi_memmap_walk(filter_rsvd_memory
, build_node_maps
);
456 efi_memmap_walk(filter_rsvd_memory
, find_pernode_space
);
457 efi_memmap_walk(find_max_min_low_pfn
, NULL
);
459 for_each_online_node(node
)
460 if (bootmem_node_data
[node
].node_low_pfn
) {
461 node_clear(node
, memory_less_mask
);
462 mem_data
[node
].min_pfn
= ~0UL;
465 efi_memmap_walk(filter_memory
, register_active_ranges
);
468 * Initialize the boot memory maps in reverse order since that's
469 * what the bootmem allocator expects
471 for (node
= MAX_NUMNODES
- 1; node
>= 0; node
--) {
472 unsigned long pernode
, pernodesize
, map
;
473 struct bootmem_data
*bdp
;
475 if (!node_online(node
))
477 else if (node_isset(node
, memory_less_mask
))
480 bdp
= &bootmem_node_data
[node
];
481 pernode
= mem_data
[node
].pernode_addr
;
482 pernodesize
= mem_data
[node
].pernode_size
;
483 map
= pernode
+ pernodesize
;
485 init_bootmem_node(pgdat_list
[node
],
491 efi_memmap_walk(filter_rsvd_memory
, free_node_bootmem
);
493 reserve_pernode_space();
495 initialize_pernode_data();
497 max_pfn
= max_low_pfn
;
504 * per_cpu_init - setup per-cpu variables
506 * find_pernode_space() does most of this already, we just need to set
507 * local_per_cpu_offset
509 void __cpuinit
*per_cpu_init(void)
512 static int first_time
= 1;
516 for_each_possible_early_cpu(cpu
)
517 per_cpu(local_per_cpu_offset
, cpu
) = __per_cpu_offset
[cpu
];
520 return __per_cpu_start
+ __per_cpu_offset
[smp_processor_id()];
522 #endif /* CONFIG_SMP */
525 * show_mem - give short summary of memory stats
527 * Shows a simple page count of reserved and used pages in the system.
528 * For discontig machines, it does this on a per-pgdat basis.
532 int i
, total_reserved
= 0;
533 int total_shared
= 0, total_cached
= 0;
534 unsigned long total_present
= 0;
537 printk(KERN_INFO
"Mem-info:\n");
539 printk(KERN_INFO
"Node memory in pages:\n");
540 for_each_online_pgdat(pgdat
) {
541 unsigned long present
;
543 int shared
= 0, cached
= 0, reserved
= 0;
545 pgdat_resize_lock(pgdat
, &flags
);
546 present
= pgdat
->node_present_pages
;
547 for(i
= 0; i
< pgdat
->node_spanned_pages
; i
++) {
549 if (unlikely(i
% MAX_ORDER_NR_PAGES
== 0))
550 touch_nmi_watchdog();
551 if (pfn_valid(pgdat
->node_start_pfn
+ i
))
552 page
= pfn_to_page(pgdat
->node_start_pfn
+ i
);
554 i
= vmemmap_find_next_valid_pfn(pgdat
->node_id
,
558 if (PageReserved(page
))
560 else if (PageSwapCache(page
))
562 else if (page_count(page
))
563 shared
+= page_count(page
)-1;
565 pgdat_resize_unlock(pgdat
, &flags
);
566 total_present
+= present
;
567 total_reserved
+= reserved
;
568 total_cached
+= cached
;
569 total_shared
+= shared
;
570 printk(KERN_INFO
"Node %4d: RAM: %11ld, rsvd: %8d, "
571 "shrd: %10d, swpd: %10d\n", pgdat
->node_id
,
572 present
, reserved
, shared
, cached
);
574 printk(KERN_INFO
"%ld pages of RAM\n", total_present
);
575 printk(KERN_INFO
"%d reserved pages\n", total_reserved
);
576 printk(KERN_INFO
"%d pages shared\n", total_shared
);
577 printk(KERN_INFO
"%d pages swap cached\n", total_cached
);
578 printk(KERN_INFO
"Total of %ld pages in page table cache\n",
579 quicklist_total_size());
580 printk(KERN_INFO
"%d free buffer pages\n", nr_free_buffer_pages());
584 * call_pernode_memory - use SRAT to call callback functions with node info
585 * @start: physical start of range
586 * @len: length of range
587 * @arg: function to call for each range
589 * efi_memmap_walk() knows nothing about layout of memory across nodes. Find
590 * out to which node a block of memory belongs. Ignore memory that we cannot
591 * identify, and split blocks that run across multiple nodes.
593 * Take this opportunity to round the start address up and the end address
594 * down to page boundaries.
596 void call_pernode_memory(unsigned long start
, unsigned long len
, void *arg
)
598 unsigned long rs
, re
, end
= start
+ len
;
599 void (*func
)(unsigned long, unsigned long, int);
602 start
= PAGE_ALIGN(start
);
609 if (!num_node_memblks
) {
610 /* No SRAT table, so assume one node (node 0) */
612 (*func
)(start
, end
- start
, 0);
616 for (i
= 0; i
< num_node_memblks
; i
++) {
617 rs
= max(start
, node_memblk
[i
].start_paddr
);
618 re
= min(end
, node_memblk
[i
].start_paddr
+
619 node_memblk
[i
].size
);
622 (*func
)(rs
, re
- rs
, node_memblk
[i
].nid
);
630 * count_node_pages - callback to build per-node memory info structures
631 * @start: physical start of range
632 * @len: length of range
633 * @node: node where this range resides
635 * Each node has it's own number of physical pages, DMAable pages, start, and
636 * end page frame number. This routine will be called by call_pernode_memory()
637 * for each piece of usable memory and will setup these values for each node.
638 * Very similar to build_maps().
640 static __init
int count_node_pages(unsigned long start
, unsigned long len
, int node
)
642 unsigned long end
= start
+ len
;
644 mem_data
[node
].num_physpages
+= len
>> PAGE_SHIFT
;
645 #ifdef CONFIG_ZONE_DMA
646 if (start
<= __pa(MAX_DMA_ADDRESS
))
647 mem_data
[node
].num_dma_physpages
+=
648 (min(end
, __pa(MAX_DMA_ADDRESS
)) - start
) >>PAGE_SHIFT
;
650 start
= GRANULEROUNDDOWN(start
);
651 end
= GRANULEROUNDUP(end
);
652 mem_data
[node
].max_pfn
= max(mem_data
[node
].max_pfn
,
654 mem_data
[node
].min_pfn
= min(mem_data
[node
].min_pfn
,
655 start
>> PAGE_SHIFT
);
661 * paging_init - setup page tables
663 * paging_init() sets up the page tables for each node of the system and frees
664 * the bootmem allocator memory for general use.
666 void __init
paging_init(void)
668 unsigned long max_dma
;
669 unsigned long pfn_offset
= 0;
670 unsigned long max_pfn
= 0;
672 unsigned long max_zone_pfns
[MAX_NR_ZONES
];
674 max_dma
= virt_to_phys((void *) MAX_DMA_ADDRESS
) >> PAGE_SHIFT
;
676 efi_memmap_walk(filter_rsvd_memory
, count_node_pages
);
678 sparse_memory_present_with_active_regions(MAX_NUMNODES
);
681 #ifdef CONFIG_VIRTUAL_MEM_MAP
682 VMALLOC_END
-= PAGE_ALIGN(ALIGN(max_low_pfn
, MAX_ORDER_NR_PAGES
) *
683 sizeof(struct page
));
684 vmem_map
= (struct page
*) VMALLOC_END
;
685 efi_memmap_walk(create_mem_map_page_table
, NULL
);
686 printk("Virtual mem_map starts at 0x%p\n", vmem_map
);
689 for_each_online_node(node
) {
690 num_physpages
+= mem_data
[node
].num_physpages
;
691 pfn_offset
= mem_data
[node
].min_pfn
;
693 #ifdef CONFIG_VIRTUAL_MEM_MAP
694 NODE_DATA(node
)->node_mem_map
= vmem_map
+ pfn_offset
;
696 if (mem_data
[node
].max_pfn
> max_pfn
)
697 max_pfn
= mem_data
[node
].max_pfn
;
700 memset(max_zone_pfns
, 0, sizeof(max_zone_pfns
));
701 #ifdef CONFIG_ZONE_DMA
702 max_zone_pfns
[ZONE_DMA
] = max_dma
;
704 max_zone_pfns
[ZONE_NORMAL
] = max_pfn
;
705 free_area_init_nodes(max_zone_pfns
);
707 zero_page_memmap_ptr
= virt_to_page(ia64_imva(empty_zero_page
));
710 #ifdef CONFIG_MEMORY_HOTPLUG
711 pg_data_t
*arch_alloc_nodedata(int nid
)
713 unsigned long size
= compute_pernodesize(nid
);
715 return kzalloc(size
, GFP_KERNEL
);
718 void arch_free_nodedata(pg_data_t
*pgdat
)
723 void arch_refresh_nodedata(int update_node
, pg_data_t
*update_pgdat
)
725 pgdat_list
[update_node
] = update_pgdat
;
730 #ifdef CONFIG_SPARSEMEM_VMEMMAP
731 int __meminit
vmemmap_populate(struct page
*start_page
,
732 unsigned long size
, int node
)
734 return vmemmap_populate_basepages(start_page
, size
, node
);