Commit | Line | Data |
---|---|---|
3a368f74 PH |
1 | /* |
2 | * NUMA support for s390 | |
3 | * | |
4 | * Implement NUMA core code. | |
5 | * | |
6 | * Copyright IBM Corp. 2015 | |
7 | */ | |
8 | ||
9 | #define KMSG_COMPONENT "numa" | |
10 | #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt | |
11 | ||
12 | #include <linux/kernel.h> | |
13 | #include <linux/mmzone.h> | |
14 | #include <linux/cpumask.h> | |
15 | #include <linux/bootmem.h> | |
16 | #include <linux/memblock.h> | |
17 | #include <linux/slab.h> | |
18 | #include <linux/node.h> | |
19 | ||
20 | #include <asm/numa.h> | |
21 | #include "numa_mode.h" | |
22 | ||
23 | pg_data_t *node_data[MAX_NUMNODES]; | |
24 | EXPORT_SYMBOL(node_data); | |
25 | ||
22be9cd9 | 26 | cpumask_t node_to_cpumask_map[MAX_NUMNODES]; |
3a368f74 PH |
27 | EXPORT_SYMBOL(node_to_cpumask_map); |
28 | ||
29 | const struct numa_mode numa_mode_plain = { | |
30 | .name = "plain", | |
31 | }; | |
32 | ||
33 | static const struct numa_mode *mode = &numa_mode_plain; | |
34 | ||
35 | int numa_pfn_to_nid(unsigned long pfn) | |
36 | { | |
37 | return mode->__pfn_to_nid ? mode->__pfn_to_nid(pfn) : 0; | |
38 | } | |
39 | ||
40 | void numa_update_cpu_topology(void) | |
41 | { | |
42 | if (mode->update_cpu_topology) | |
43 | mode->update_cpu_topology(); | |
44 | } | |
45 | ||
46 | int __node_distance(int a, int b) | |
47 | { | |
48 | return mode->distance ? mode->distance(a, b) : 0; | |
49 | } | |
50 | ||
51 | int numa_debug_enabled; | |
52 | ||
53 | /* | |
54 | * alloc_node_data() - Allocate node data | |
55 | */ | |
56 | static __init pg_data_t *alloc_node_data(void) | |
57 | { | |
58 | pg_data_t *res; | |
59 | ||
ef1f7fd7 | 60 | res = (pg_data_t *) memblock_alloc(sizeof(pg_data_t), 8); |
3a368f74 PH |
61 | if (!res) |
62 | panic("Could not allocate memory for node data!\n"); | |
63 | memset(res, 0, sizeof(pg_data_t)); | |
64 | return res; | |
65 | } | |
66 | ||
67 | /* | |
68 | * numa_setup_memory() - Assign bootmem to nodes | |
69 | * | |
70 | * The memory is first added to memblock without any respect to nodes. | |
71 | * This is fixed before remaining memblock memory is handed over to the | |
72 | * buddy allocator. | |
73 | * An important side effect is that large bootmem allocations might easily | |
74 | * cross node boundaries, which can be needed for large allocations with | |
75 | * smaller memory stripes in each node (i.e. when using NUMA emulation). | |
76 | * | |
77 | * Memory defines nodes: | |
78 | * Therefore this routine also sets the nodes online with memory. | |
79 | */ | |
80 | static void __init numa_setup_memory(void) | |
81 | { | |
82 | unsigned long cur_base, align, end_of_dram; | |
83 | int nid = 0; | |
84 | ||
85 | end_of_dram = memblock_end_of_DRAM(); | |
86 | align = mode->align ? mode->align() : ULONG_MAX; | |
87 | ||
88 | /* | |
89 | * Step through all available memory and assign it to the nodes | |
90 | * indicated by the mode implementation. | |
91 | * All nodes which are seen here will be set online. | |
92 | */ | |
93 | cur_base = 0; | |
94 | do { | |
95 | nid = numa_pfn_to_nid(PFN_DOWN(cur_base)); | |
96 | node_set_online(nid); | |
97 | memblock_set_node(cur_base, align, &memblock.memory, nid); | |
98 | cur_base += align; | |
99 | } while (cur_base < end_of_dram); | |
100 | ||
101 | /* Allocate and fill out node_data */ | |
102 | for (nid = 0; nid < MAX_NUMNODES; nid++) | |
103 | NODE_DATA(nid) = alloc_node_data(); | |
104 | ||
105 | for_each_online_node(nid) { | |
106 | unsigned long start_pfn, end_pfn; | |
107 | unsigned long t_start, t_end; | |
108 | int i; | |
109 | ||
110 | start_pfn = ULONG_MAX; | |
111 | end_pfn = 0; | |
112 | for_each_mem_pfn_range(i, nid, &t_start, &t_end, NULL) { | |
113 | if (t_start < start_pfn) | |
114 | start_pfn = t_start; | |
115 | if (t_end > end_pfn) | |
116 | end_pfn = t_end; | |
117 | } | |
118 | NODE_DATA(nid)->node_spanned_pages = end_pfn - start_pfn; | |
119 | NODE_DATA(nid)->node_id = nid; | |
120 | } | |
121 | } | |
122 | ||
123 | /* | |
124 | * numa_setup() - Earliest initialization | |
125 | * | |
126 | * Assign the mode and call the mode's setup routine. | |
127 | */ | |
128 | void __init numa_setup(void) | |
129 | { | |
130 | pr_info("NUMA mode: %s\n", mode->name); | |
131 | if (mode->setup) | |
132 | mode->setup(); | |
133 | numa_setup_memory(); | |
134 | memblock_dump_all(); | |
135 | } | |
136 | ||
137 | ||
138 | /* | |
139 | * numa_init_early() - Initialization initcall | |
140 | * | |
141 | * This runs when only one CPU is online and before the first | |
142 | * topology update is called for by the scheduler. | |
143 | */ | |
144 | static int __init numa_init_early(void) | |
145 | { | |
146 | /* Attach all possible CPUs to node 0 for now. */ | |
22be9cd9 | 147 | cpumask_copy(&node_to_cpumask_map[0], cpu_possible_mask); |
3a368f74 PH |
148 | return 0; |
149 | } | |
150 | early_initcall(numa_init_early); | |
151 | ||
152 | /* | |
153 | * numa_init_late() - Initialization initcall | |
154 | * | |
155 | * Register NUMA nodes. | |
156 | */ | |
157 | static int __init numa_init_late(void) | |
158 | { | |
159 | int nid; | |
160 | ||
161 | for_each_online_node(nid) | |
162 | register_one_node(nid); | |
163 | return 0; | |
164 | } | |
165 | device_initcall(numa_init_late); | |
166 | ||
167 | static int __init parse_debug(char *parm) | |
168 | { | |
169 | numa_debug_enabled = 1; | |
170 | return 0; | |
171 | } | |
172 | early_param("numa_debug", parse_debug); | |
173 | ||
174 | static int __init parse_numa(char *parm) | |
175 | { | |
176 | if (strcmp(parm, numa_mode_plain.name) == 0) | |
177 | mode = &numa_mode_plain; | |
c29a7baf MH |
178 | #ifdef CONFIG_NUMA_EMU |
179 | if (strcmp(parm, numa_mode_emu.name) == 0) | |
180 | mode = &numa_mode_emu; | |
181 | #endif | |
3a368f74 PH |
182 | return 0; |
183 | } | |
184 | early_param("numa", parse_numa); |