GNU Linux-libre 4.14.266-gnu1
[releases.git] / arch / x86 / mm / numa_emulation.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * NUMA emulation
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
14 static int emu_nid_to_phys[MAX_NUMNODES];
15 static char *emu_cmdline __initdata;
16
17 void __init numa_emu_cmdline(char *str)
18 {
19         emu_cmdline = str;
20 }
21
22 static 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
32 static 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  * Sets up nid to range from @start to @end.  The return value is -errno if
44  * something went wrong, 0 otherwise.
45  */
46 static 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] = pb->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  * Sets up nr_nodes fake nodes interleaved over physical nodes ranging from addr
79  * to max_addr.
80  *
81  * Returns zero on success or negative on error.
82  */
83 static 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          * Calculate target node size.  x86_32 freaks on __udivdi3() so do
103          * the division in ulong number of pages and convert back.
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          * Calculate the number of big nodes that can be allocated as a result
110          * of consolidating the remainder.
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          * Continue to fill physical nodes with fake nodes until there is no
124          * memory left on any of them.
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                          * Continue to add memory to this fake node if its
146                          * non-reserved memory is less than the per-node size.
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                          * If there won't be at least FAKE_NODE_MIN_SIZE of
158                          * non-reserved memory in ZONE_DMA32 for the next node,
159                          * this one must extend to the boundary.
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                          * If there won't be enough non-reserved memory for the
167                          * next node, this one must extend to the end of the
168                          * physical node.
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  * Returns the end address of a node so that there is at least `size' amount of
185  * non-reserved memory or `max_addr' is reached.
186  */
187 static 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  * Sets up fake nodes of `size' interleaved over physical nodes ranging from
203  * `addr' to `max_addr'.
204  *
205  * Returns zero on success or negative on error.
206  */
207 static 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          * The limit on emulated nodes is MAX_NUMNODES, so the size per node is
220          * increased accordingly if the requested size is too small.  This
221          * creates a uniform distribution of node sizes across the entire
222          * machine (but not necessarily over physical nodes).
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          * Fill physical nodes with fake nodes of size until there is no memory
238          * left on any of them.
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                          * If there won't be at least FAKE_NODE_MIN_SIZE of
257                          * non-reserved memory in ZONE_DMA32 for the next node,
258                          * this one must extend to the boundary.
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                          * If there won't be enough non-reserved memory for the
266                          * next node, this one must extend to the end of the
267                          * physical node.
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
282 int __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  * numa_emulation - Emulate NUMA nodes
300  * @numa_meminfo: NUMA configuration to massage
301  * @numa_dist_cnt: The size of the physical NUMA distance table
302  *
303  * Emulate NUMA nodes according to the numa=fake kernel parameter.
304  * @numa_meminfo contains the physical memory configuration and is modified
305  * to reflect the emulated configuration on success.  @numa_dist_cnt is
306  * used to determine the size of the physical distance table.
307  *
308  * On success, the following modifications are made.
309  *
310  * - @numa_meminfo is updated to reflect the emulated nodes.
311  *
312  * - __apicid_to_node[] is updated such that APIC IDs are mapped to the
313  *   emulated nodes.
314  *
315  * - NUMA distance table is rebuilt to represent distances between emulated
316  *   nodes.  The distances are determined considering how emulated nodes
317  *   are mapped to physical nodes and match the actual distances.
318  *
319  * - emu_nid_to_phys[] reflects how emulated nodes are mapped to physical
320  *   nodes.  This is used by numa_add_cpu() and numa_remove_cpu().
321  *
322  * If emulation is not enabled or fails, emu_nid_to_phys[] is filled with
323  * identity mapping and no other modification is made.
324  */
325 void __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          * If the numa=fake command-line contains a 'M' or 'G', it represents
346          * the fixed node size.  Otherwise, if it is just a single number N,
347          * split the system RAM into N fake nodes.
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         /* copy the physical distance table */
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          * Determine the max emulated nid and the default phys nid to use
392          * for unmapped nodes.
393          */
394         max_emu_nid = setup_emu2phys_nid(&dfl_phys_nid);
395
396         /* commit */
397         *numa_meminfo = ei;
398
399         /* Make sure numa_nodes_parsed only contains emulated nodes */
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          * Transform __apicid_to_node table to use emulated nids by
408          * reverse-mapping phys_nid.  The maps should always exist but fall
409          * back to zero just in case.
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         /* make sure all emulated nodes are mapped to a physical node */
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         /* transform distance table */
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         /* free the copied physical distance table */
446         if (phys_dist)
447                 memblock_free(__pa(phys_dist), phys_size);
448         return;
449
450 no_emu:
451         /* No emulation.  Build identity emu_nid_to_phys[] for numa_add_cpu() */
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
457 void 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          * Map the cpu to each emulated node that is allocated on the physical
468          * node of the cpu's apic id.
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
475 void 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   /* !CONFIG_DEBUG_PER_CPU_MAPS */
483 static 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                 /* early_cpu_to_node() already emits a warning and trace */
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
503 void numa_add_cpu(int cpu)
504 {
505         numa_set_cpumask(cpu, true);
506 }
507
508 void numa_remove_cpu(int cpu)
509 {
510         numa_set_cpumask(cpu, false);
511 }
512 #endif  /* !CONFIG_DEBUG_PER_CPU_MAPS */