1
2
3
4
5#include <linux/kernel.h>
6#include <linux/errno.h>
7#include <linux/topology.h>
8#include <linux/memblock.h>
9#include <linux/bootmem.h>
10#include <asm/dma.h>
11
12#include "numa_internal.h"
13
14static int emu_nid_to_phys[MAX_NUMNODES];
15static char *emu_cmdline __initdata;
16
17void __init numa_emu_cmdline(char *str)
18{
19 emu_cmdline = str;
20}
21
22static int __init emu_find_memblk_by_nid(int nid, const struct numa_meminfo *mi)
23{
24 int i;
25
26 for (i = 0; i < mi->nr_blks; i++)
27 if (mi->blk[i].nid == nid)
28 return i;
29 return -ENOENT;
30}
31
32static u64 __init mem_hole_size(u64 start, u64 end)
33{
34 unsigned long start_pfn = PFN_UP(start);
35 unsigned long end_pfn = PFN_DOWN(end);
36
37 if (start_pfn < end_pfn)
38 return PFN_PHYS(absent_pages_in_range(start_pfn, end_pfn));
39 return 0;
40}
41
42
43
44
45
46static int __init emu_setup_memblk(struct numa_meminfo *ei,
47 struct numa_meminfo *pi,
48 int nid, int phys_blk, u64 size)
49{
50 struct numa_memblk *eb = &ei->blk[ei->nr_blks];
51 struct numa_memblk *pb = &pi->blk[phys_blk];
52
53 if (ei->nr_blks >= NR_NODE_MEMBLKS) {
54 pr_err("NUMA: Too many emulated memblks, failing emulation\n");
55 return -EINVAL;
56 }
57
58 ei->nr_blks++;
59 eb->start = pb->start;
60 eb->end = pb->start + size;
61 eb->nid = nid;
62
63 if (emu_nid_to_phys[nid] == NUMA_NO_NODE)
64 emu_nid_to_phys[nid] = nid;
65
66 pb->start += size;
67 if (pb->start >= pb->end) {
68 WARN_ON_ONCE(pb->start > pb->end);
69 numa_remove_memblk_from(phys_blk, pi);
70 }
71
72 printk(KERN_INFO "Faking node %d at [mem %#018Lx-%#018Lx] (%LuMB)\n",
73 nid, eb->start, eb->end - 1, (eb->end - eb->start) >> 20);
74 return 0;
75}
76
77
78
79
80
81
82
83static int __init split_nodes_interleave(struct numa_meminfo *ei,
84 struct numa_meminfo *pi,
85 u64 addr, u64 max_addr, int nr_nodes)
86{
87 nodemask_t physnode_mask = numa_nodes_parsed;
88 u64 size;
89 int big;
90 int nid = 0;
91 int i, ret;
92
93 if (nr_nodes <= 0)
94 return -1;
95 if (nr_nodes > MAX_NUMNODES) {
96 pr_info("numa=fake=%d too large, reducing to %d\n",
97 nr_nodes, MAX_NUMNODES);
98 nr_nodes = MAX_NUMNODES;
99 }
100
101
102
103
104
105 size = max_addr - addr - mem_hole_size(addr, max_addr);
106 size = PFN_PHYS((unsigned long)(size >> PAGE_SHIFT) / nr_nodes);
107
108
109
110
111
112 big = ((size & ~FAKE_NODE_MIN_HASH_MASK) * nr_nodes) /
113 FAKE_NODE_MIN_SIZE;
114
115 size &= FAKE_NODE_MIN_HASH_MASK;
116 if (!size) {
117 pr_err("Not enough memory for each node. "
118 "NUMA emulation disabled.\n");
119 return -1;
120 }
121
122
123
124
125
126 while (nodes_weight(physnode_mask)) {
127 for_each_node_mask(i, physnode_mask) {
128 u64 dma32_end = PFN_PHYS(MAX_DMA32_PFN);
129 u64 start, limit, end;
130 int phys_blk;
131
132 phys_blk = emu_find_memblk_by_nid(i, pi);
133 if (phys_blk < 0) {
134 node_clear(i, physnode_mask);
135 continue;
136 }
137 start = pi->blk[phys_blk].start;
138 limit = pi->blk[phys_blk].end;
139 end = start + size;
140
141 if (nid < big)
142 end += FAKE_NODE_MIN_SIZE;
143
144
145
146
147
148 while (end - start - mem_hole_size(start, end) < size) {
149 end += FAKE_NODE_MIN_SIZE;
150 if (end > limit) {
151 end = limit;
152 break;
153 }
154 }
155
156
157
158
159
160
161 if (end < dma32_end && dma32_end - end -
162 mem_hole_size(end, dma32_end) < FAKE_NODE_MIN_SIZE)
163 end = dma32_end;
164
165
166
167
168
169
170 if (limit - end - mem_hole_size(end, limit) < size)
171 end = limit;
172
173 ret = emu_setup_memblk(ei, pi, nid++ % nr_nodes,
174 phys_blk,
175 min(end, limit) - start);
176 if (ret < 0)
177 return ret;
178 }
179 }
180 return 0;
181}
182
183
184
185
186
187static u64 __init find_end_of_node(u64 start, u64 max_addr, u64 size)
188{
189 u64 end = start + size;
190
191 while (end - start - mem_hole_size(start, end) < size) {
192 end += FAKE_NODE_MIN_SIZE;
193 if (end > max_addr) {
194 end = max_addr;
195 break;
196 }
197 }
198 return end;
199}
200
201
202
203
204
205
206
207static int __init split_nodes_size_interleave(struct numa_meminfo *ei,
208 struct numa_meminfo *pi,
209 u64 addr, u64 max_addr, u64 size)
210{
211 nodemask_t physnode_mask = numa_nodes_parsed;
212 u64 min_size;
213 int nid = 0;
214 int i, ret;
215
216 if (!size)
217 return -1;
218
219
220
221
222
223
224 min_size = (max_addr - addr - mem_hole_size(addr, max_addr)) / MAX_NUMNODES;
225 min_size = max(min_size, FAKE_NODE_MIN_SIZE);
226 if ((min_size & FAKE_NODE_MIN_HASH_MASK) < min_size)
227 min_size = (min_size + FAKE_NODE_MIN_SIZE) &
228 FAKE_NODE_MIN_HASH_MASK;
229 if (size < min_size) {
230 pr_err("Fake node size %LuMB too small, increasing to %LuMB\n",
231 size >> 20, min_size >> 20);
232 size = min_size;
233 }
234 size &= FAKE_NODE_MIN_HASH_MASK;
235
236
237
238
239
240 while (nodes_weight(physnode_mask)) {
241 for_each_node_mask(i, physnode_mask) {
242 u64 dma32_end = PFN_PHYS(MAX_DMA32_PFN);
243 u64 start, limit, end;
244 int phys_blk;
245
246 phys_blk = emu_find_memblk_by_nid(i, pi);
247 if (phys_blk < 0) {
248 node_clear(i, physnode_mask);
249 continue;
250 }
251 start = pi->blk[phys_blk].start;
252 limit = pi->blk[phys_blk].end;
253
254 end = find_end_of_node(start, limit, size);
255
256
257
258
259
260 if (end < dma32_end && dma32_end - end -
261 mem_hole_size(end, dma32_end) < FAKE_NODE_MIN_SIZE)
262 end = dma32_end;
263
264
265
266
267
268
269 if (limit - end - mem_hole_size(end, limit) < size)
270 end = limit;
271
272 ret = emu_setup_memblk(ei, pi, nid++ % MAX_NUMNODES,
273 phys_blk,
274 min(end, limit) - start);
275 if (ret < 0)
276 return ret;
277 }
278 }
279 return 0;
280}
281
282int __init setup_emu2phys_nid(int *dfl_phys_nid)
283{
284 int i, max_emu_nid = 0;
285
286 *dfl_phys_nid = NUMA_NO_NODE;
287 for (i = 0; i < ARRAY_SIZE(emu_nid_to_phys); i++) {
288 if (emu_nid_to_phys[i] != NUMA_NO_NODE) {
289 max_emu_nid = i;
290 if (*dfl_phys_nid == NUMA_NO_NODE)
291 *dfl_phys_nid = emu_nid_to_phys[i];
292 }
293 }
294
295 return max_emu_nid;
296}
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325void __init numa_emulation(struct numa_meminfo *numa_meminfo, int numa_dist_cnt)
326{
327 static struct numa_meminfo ei __initdata;
328 static struct numa_meminfo pi __initdata;
329 const u64 max_addr = PFN_PHYS(max_pfn);
330 u8 *phys_dist = NULL;
331 size_t phys_size = numa_dist_cnt * numa_dist_cnt * sizeof(phys_dist[0]);
332 int max_emu_nid, dfl_phys_nid;
333 int i, j, ret;
334
335 if (!emu_cmdline)
336 goto no_emu;
337
338 memset(&ei, 0, sizeof(ei));
339 pi = *numa_meminfo;
340
341 for (i = 0; i < MAX_NUMNODES; i++)
342 emu_nid_to_phys[i] = NUMA_NO_NODE;
343
344
345
346
347
348
349 if (strchr(emu_cmdline, 'M') || strchr(emu_cmdline, 'G')) {
350 u64 size;
351
352 size = memparse(emu_cmdline, &emu_cmdline);
353 ret = split_nodes_size_interleave(&ei, &pi, 0, max_addr, size);
354 } else {
355 unsigned long n;
356
357 n = simple_strtoul(emu_cmdline, &emu_cmdline, 0);
358 ret = split_nodes_interleave(&ei, &pi, 0, max_addr, n);
359 }
360 if (*emu_cmdline == ':')
361 emu_cmdline++;
362
363 if (ret < 0)
364 goto no_emu;
365
366 if (numa_cleanup_meminfo(&ei) < 0) {
367 pr_warning("NUMA: Warning: constructed meminfo invalid, disabling emulation\n");
368 goto no_emu;
369 }
370
371
372 if (numa_dist_cnt) {
373 u64 phys;
374
375 phys = memblock_find_in_range(0, PFN_PHYS(max_pfn_mapped),
376 phys_size, PAGE_SIZE);
377 if (!phys) {
378 pr_warning("NUMA: Warning: can't allocate copy of distance table, disabling emulation\n");
379 goto no_emu;
380 }
381 memblock_reserve(phys, phys_size);
382 phys_dist = __va(phys);
383
384 for (i = 0; i < numa_dist_cnt; i++)
385 for (j = 0; j < numa_dist_cnt; j++)
386 phys_dist[i * numa_dist_cnt + j] =
387 node_distance(i, j);
388 }
389
390
391
392
393
394 max_emu_nid = setup_emu2phys_nid(&dfl_phys_nid);
395
396
397 *numa_meminfo = ei;
398
399
400 nodes_clear(numa_nodes_parsed);
401 for (i = 0; i < ARRAY_SIZE(ei.blk); i++)
402 if (ei.blk[i].start != ei.blk[i].end &&
403 ei.blk[i].nid != NUMA_NO_NODE)
404 node_set(ei.blk[i].nid, numa_nodes_parsed);
405
406
407
408
409
410
411 for (i = 0; i < ARRAY_SIZE(__apicid_to_node); i++) {
412 if (__apicid_to_node[i] == NUMA_NO_NODE)
413 continue;
414 for (j = 0; j < ARRAY_SIZE(emu_nid_to_phys); j++)
415 if (__apicid_to_node[i] == emu_nid_to_phys[j])
416 break;
417 __apicid_to_node[i] = j < ARRAY_SIZE(emu_nid_to_phys) ? j : 0;
418 }
419
420
421 for (i = 0; i < ARRAY_SIZE(emu_nid_to_phys); i++)
422 if (emu_nid_to_phys[i] == NUMA_NO_NODE)
423 emu_nid_to_phys[i] = dfl_phys_nid;
424
425
426 numa_reset_distance();
427 for (i = 0; i < max_emu_nid + 1; i++) {
428 for (j = 0; j < max_emu_nid + 1; j++) {
429 int physi = emu_nid_to_phys[i];
430 int physj = emu_nid_to_phys[j];
431 int dist;
432
433 if (get_option(&emu_cmdline, &dist) == 2)
434 ;
435 else if (physi >= numa_dist_cnt || physj >= numa_dist_cnt)
436 dist = physi == physj ?
437 LOCAL_DISTANCE : REMOTE_DISTANCE;
438 else
439 dist = phys_dist[physi * numa_dist_cnt + physj];
440
441 numa_set_distance(i, j, dist);
442 }
443 }
444
445
446 if (phys_dist)
447 memblock_free(__pa(phys_dist), phys_size);
448 return;
449
450no_emu:
451
452 for (i = 0; i < ARRAY_SIZE(emu_nid_to_phys); i++)
453 emu_nid_to_phys[i] = i;
454}
455
456#ifndef CONFIG_DEBUG_PER_CPU_MAPS
457void numa_add_cpu(int cpu)
458{
459 int physnid, nid;
460
461 nid = early_cpu_to_node(cpu);
462 BUG_ON(nid == NUMA_NO_NODE || !node_online(nid));
463
464 physnid = emu_nid_to_phys[nid];
465
466
467
468
469
470 for_each_online_node(nid)
471 if (emu_nid_to_phys[nid] == physnid)
472 cpumask_set_cpu(cpu, node_to_cpumask_map[nid]);
473}
474
475void numa_remove_cpu(int cpu)
476{
477 int i;
478
479 for_each_online_node(i)
480 cpumask_clear_cpu(cpu, node_to_cpumask_map[i]);
481}
482#else
483static void numa_set_cpumask(int cpu, bool enable)
484{
485 int nid, physnid;
486
487 nid = early_cpu_to_node(cpu);
488 if (nid == NUMA_NO_NODE) {
489
490 return;
491 }
492
493 physnid = emu_nid_to_phys[nid];
494
495 for_each_online_node(nid) {
496 if (emu_nid_to_phys[nid] != physnid)
497 continue;
498
499 debug_cpumask_set_cpu(cpu, nid, enable);
500 }
501}
502
503void numa_add_cpu(int cpu)
504{
505 numa_set_cpumask(cpu, true);
506}
507
508void numa_remove_cpu(int cpu)
509{
510 numa_set_cpumask(cpu, false);
511}
512#endif
513