Merge tag 'ide-pull-request' of https://gitlab.com/jsnow/qemu into staging
[qemu.git] / hw / ppc / spapr_numa.c
1 /*
2 * QEMU PowerPC pSeries Logical Partition NUMA associativity handling
3 *
4 * Copyright IBM Corp. 2020
5 *
6 * Authors:
7 * Daniel Henrique Barboza <danielhb413@gmail.com>
8 *
9 * This work is licensed under the terms of the GNU GPL, version 2 or later.
10 * See the COPYING file in the top-level directory.
11 */
12
13 #include "qemu/osdep.h"
14 #include "qemu-common.h"
15 #include "hw/ppc/spapr_numa.h"
16 #include "hw/pci-host/spapr.h"
17 #include "hw/ppc/fdt.h"
18
19 /* Moved from hw/ppc/spapr_pci_nvlink2.c */
20 #define SPAPR_GPU_NUMA_ID (cpu_to_be32(1))
21
22 static bool spapr_machine_using_legacy_numa(SpaprMachineState *spapr)
23 {
24 MachineState *machine = MACHINE(spapr);
25 SpaprMachineClass *smc = SPAPR_MACHINE_GET_CLASS(machine);
26
27 return smc->pre_5_2_numa_associativity ||
28 machine->numa_state->num_nodes <= 1;
29 }
30
31 static bool spapr_numa_is_symmetrical(MachineState *ms)
32 {
33 int src, dst;
34 int nb_numa_nodes = ms->numa_state->num_nodes;
35 NodeInfo *numa_info = ms->numa_state->nodes;
36
37 for (src = 0; src < nb_numa_nodes; src++) {
38 for (dst = src; dst < nb_numa_nodes; dst++) {
39 if (numa_info[src].distance[dst] !=
40 numa_info[dst].distance[src]) {
41 return false;
42 }
43 }
44 }
45
46 return true;
47 }
48
49 /*
50 * NVLink2-connected GPU RAM needs to be placed on a separate NUMA node.
51 * We assign a new numa ID per GPU in spapr_pci_collect_nvgpu() which is
52 * called from vPHB reset handler so we initialize the counter here.
53 * If no NUMA is configured from the QEMU side, we start from 1 as GPU RAM
54 * must be equally distant from any other node.
55 * The final value of spapr->gpu_numa_id is going to be written to
56 * max-associativity-domains in spapr_build_fdt().
57 */
58 unsigned int spapr_numa_initial_nvgpu_numa_id(MachineState *machine)
59 {
60 return MAX(1, machine->numa_state->num_nodes);
61 }
62
63 /*
64 * This function will translate the user distances into
65 * what the kernel understand as possible values: 10
66 * (local distance), 20, 40, 80 and 160, and return the equivalent
67 * NUMA level for each. Current heuristic is:
68 * - local distance (10) returns numa_level = 0x4, meaning there is
69 * no rounding for local distance
70 * - distances between 11 and 30 inclusive -> rounded to 20,
71 * numa_level = 0x3
72 * - distances between 31 and 60 inclusive -> rounded to 40,
73 * numa_level = 0x2
74 * - distances between 61 and 120 inclusive -> rounded to 80,
75 * numa_level = 0x1
76 * - everything above 120 returns numa_level = 0 to indicate that
77 * there is no match. This will be calculated as disntace = 160
78 * by the kernel (as of v5.9)
79 */
80 static uint8_t spapr_numa_get_numa_level(uint8_t distance)
81 {
82 if (distance == 10) {
83 return 0x4;
84 } else if (distance > 11 && distance <= 30) {
85 return 0x3;
86 } else if (distance > 31 && distance <= 60) {
87 return 0x2;
88 } else if (distance > 61 && distance <= 120) {
89 return 0x1;
90 }
91
92 return 0;
93 }
94
95 static void spapr_numa_define_associativity_domains(SpaprMachineState *spapr)
96 {
97 MachineState *ms = MACHINE(spapr);
98 NodeInfo *numa_info = ms->numa_state->nodes;
99 int nb_numa_nodes = ms->numa_state->num_nodes;
100 int src, dst, i;
101
102 for (src = 0; src < nb_numa_nodes; src++) {
103 for (dst = src; dst < nb_numa_nodes; dst++) {
104 /*
105 * This is how the associativity domain between A and B
106 * is calculated:
107 *
108 * - get the distance D between them
109 * - get the correspondent NUMA level 'n_level' for D
110 * - all associativity arrays were initialized with their own
111 * numa_ids, and we're calculating the distance in node_id
112 * ascending order, starting from node id 0 (the first node
113 * retrieved by numa_state). This will have a cascade effect in
114 * the algorithm because the associativity domains that node 0
115 * defines will be carried over to other nodes, and node 1
116 * associativities will be carried over after taking node 0
117 * associativities into account, and so on. This happens because
118 * we'll assign assoc_src as the associativity domain of dst
119 * as well, for all NUMA levels beyond and including n_level.
120 *
121 * The PPC kernel expects the associativity domains of node 0 to
122 * be always 0, and this algorithm will grant that by default.
123 */
124 uint8_t distance = numa_info[src].distance[dst];
125 uint8_t n_level = spapr_numa_get_numa_level(distance);
126 uint32_t assoc_src;
127
128 /*
129 * n_level = 0 means that the distance is greater than our last
130 * rounded value (120). In this case there is no NUMA level match
131 * between src and dst and we can skip the remaining of the loop.
132 *
133 * The Linux kernel will assume that the distance between src and
134 * dst, in this case of no match, is 10 (local distance) doubled
135 * for each NUMA it didn't match. We have MAX_DISTANCE_REF_POINTS
136 * levels (4), so this gives us 10*2*2*2*2 = 160.
137 *
138 * This logic can be seen in the Linux kernel source code, as of
139 * v5.9, in arch/powerpc/mm/numa.c, function __node_distance().
140 */
141 if (n_level == 0) {
142 continue;
143 }
144
145 /*
146 * We must assign all assoc_src to dst, starting from n_level
147 * and going up to 0x1.
148 */
149 for (i = n_level; i > 0; i--) {
150 assoc_src = spapr->numa_assoc_array[src][i];
151 spapr->numa_assoc_array[dst][i] = assoc_src;
152 }
153 }
154 }
155
156 }
157
158 void spapr_numa_associativity_init(SpaprMachineState *spapr,
159 MachineState *machine)
160 {
161 SpaprMachineClass *smc = SPAPR_MACHINE_GET_CLASS(spapr);
162 int nb_numa_nodes = machine->numa_state->num_nodes;
163 int i, j, max_nodes_with_gpus;
164 bool using_legacy_numa = spapr_machine_using_legacy_numa(spapr);
165
166 /*
167 * For all associativity arrays: first position is the size,
168 * position MAX_DISTANCE_REF_POINTS is always the numa_id,
169 * represented by the index 'i'.
170 *
171 * This will break on sparse NUMA setups, when/if QEMU starts
172 * to support it, because there will be no more guarantee that
173 * 'i' will be a valid node_id set by the user.
174 */
175 for (i = 0; i < nb_numa_nodes; i++) {
176 spapr->numa_assoc_array[i][0] = cpu_to_be32(MAX_DISTANCE_REF_POINTS);
177 spapr->numa_assoc_array[i][MAX_DISTANCE_REF_POINTS] = cpu_to_be32(i);
178
179 /*
180 * Fill all associativity domains of non-zero NUMA nodes with
181 * node_id. This is required because the default value (0) is
182 * considered a match with associativity domains of node 0.
183 */
184 if (!using_legacy_numa && i != 0) {
185 for (j = 1; j < MAX_DISTANCE_REF_POINTS; j++) {
186 spapr->numa_assoc_array[i][j] = cpu_to_be32(i);
187 }
188 }
189 }
190
191 /*
192 * Initialize NVLink GPU associativity arrays. We know that
193 * the first GPU will take the first available NUMA id, and
194 * we'll have a maximum of NVGPU_MAX_NUM GPUs in the machine.
195 * At this point we're not sure if there are GPUs or not, but
196 * let's initialize the associativity arrays and allow NVLink
197 * GPUs to be handled like regular NUMA nodes later on.
198 */
199 max_nodes_with_gpus = nb_numa_nodes + NVGPU_MAX_NUM;
200
201 for (i = nb_numa_nodes; i < max_nodes_with_gpus; i++) {
202 spapr->numa_assoc_array[i][0] = cpu_to_be32(MAX_DISTANCE_REF_POINTS);
203
204 for (j = 1; j < MAX_DISTANCE_REF_POINTS; j++) {
205 uint32_t gpu_assoc = smc->pre_5_1_assoc_refpoints ?
206 SPAPR_GPU_NUMA_ID : cpu_to_be32(i);
207 spapr->numa_assoc_array[i][j] = gpu_assoc;
208 }
209
210 spapr->numa_assoc_array[i][MAX_DISTANCE_REF_POINTS] = cpu_to_be32(i);
211 }
212
213 /*
214 * Legacy NUMA guests (pseries-5.1 and older, or guests with only
215 * 1 NUMA node) will not benefit from anything we're going to do
216 * after this point.
217 */
218 if (using_legacy_numa) {
219 return;
220 }
221
222 if (!spapr_numa_is_symmetrical(machine)) {
223 error_report("Asymmetrical NUMA topologies aren't supported "
224 "in the pSeries machine");
225 exit(EXIT_FAILURE);
226 }
227
228 spapr_numa_define_associativity_domains(spapr);
229 }
230
231 void spapr_numa_write_associativity_dt(SpaprMachineState *spapr, void *fdt,
232 int offset, int nodeid)
233 {
234 _FDT((fdt_setprop(fdt, offset, "ibm,associativity",
235 spapr->numa_assoc_array[nodeid],
236 sizeof(spapr->numa_assoc_array[nodeid]))));
237 }
238
239 static uint32_t *spapr_numa_get_vcpu_assoc(SpaprMachineState *spapr,
240 PowerPCCPU *cpu)
241 {
242 uint32_t *vcpu_assoc = g_new(uint32_t, VCPU_ASSOC_SIZE);
243 int index = spapr_get_vcpu_id(cpu);
244
245 /*
246 * VCPUs have an extra 'cpu_id' value in ibm,associativity
247 * compared to other resources. Increment the size at index
248 * 0, put cpu_id last, then copy the remaining associativity
249 * domains.
250 */
251 vcpu_assoc[0] = cpu_to_be32(MAX_DISTANCE_REF_POINTS + 1);
252 vcpu_assoc[VCPU_ASSOC_SIZE - 1] = cpu_to_be32(index);
253 memcpy(vcpu_assoc + 1, spapr->numa_assoc_array[cpu->node_id] + 1,
254 (VCPU_ASSOC_SIZE - 2) * sizeof(uint32_t));
255
256 return vcpu_assoc;
257 }
258
259 int spapr_numa_fixup_cpu_dt(SpaprMachineState *spapr, void *fdt,
260 int offset, PowerPCCPU *cpu)
261 {
262 g_autofree uint32_t *vcpu_assoc = NULL;
263
264 vcpu_assoc = spapr_numa_get_vcpu_assoc(spapr, cpu);
265
266 /* Advertise NUMA via ibm,associativity */
267 return fdt_setprop(fdt, offset, "ibm,associativity", vcpu_assoc,
268 VCPU_ASSOC_SIZE * sizeof(uint32_t));
269 }
270
271
272 int spapr_numa_write_assoc_lookup_arrays(SpaprMachineState *spapr, void *fdt,
273 int offset)
274 {
275 MachineState *machine = MACHINE(spapr);
276 int nb_numa_nodes = machine->numa_state->num_nodes;
277 int nr_nodes = nb_numa_nodes ? nb_numa_nodes : 1;
278 uint32_t *int_buf, *cur_index, buf_len;
279 int ret, i;
280
281 /* ibm,associativity-lookup-arrays */
282 buf_len = (nr_nodes * MAX_DISTANCE_REF_POINTS + 2) * sizeof(uint32_t);
283 cur_index = int_buf = g_malloc0(buf_len);
284 int_buf[0] = cpu_to_be32(nr_nodes);
285 /* Number of entries per associativity list */
286 int_buf[1] = cpu_to_be32(MAX_DISTANCE_REF_POINTS);
287 cur_index += 2;
288 for (i = 0; i < nr_nodes; i++) {
289 /*
290 * For the lookup-array we use the ibm,associativity array,
291 * from numa_assoc_array. without the first element (size).
292 */
293 uint32_t *associativity = spapr->numa_assoc_array[i];
294 memcpy(cur_index, ++associativity,
295 sizeof(uint32_t) * MAX_DISTANCE_REF_POINTS);
296 cur_index += MAX_DISTANCE_REF_POINTS;
297 }
298 ret = fdt_setprop(fdt, offset, "ibm,associativity-lookup-arrays", int_buf,
299 (cur_index - int_buf) * sizeof(uint32_t));
300 g_free(int_buf);
301
302 return ret;
303 }
304
305 /*
306 * Helper that writes ibm,associativity-reference-points and
307 * max-associativity-domains in the RTAS pointed by @rtas
308 * in the DT @fdt.
309 */
310 void spapr_numa_write_rtas_dt(SpaprMachineState *spapr, void *fdt, int rtas)
311 {
312 MachineState *ms = MACHINE(spapr);
313 SpaprMachineClass *smc = SPAPR_MACHINE_GET_CLASS(spapr);
314 uint32_t number_nvgpus_nodes = spapr->gpu_numa_id -
315 spapr_numa_initial_nvgpu_numa_id(ms);
316 uint32_t refpoints[] = {
317 cpu_to_be32(0x4),
318 cpu_to_be32(0x3),
319 cpu_to_be32(0x2),
320 cpu_to_be32(0x1),
321 };
322 uint32_t nr_refpoints = ARRAY_SIZE(refpoints);
323 uint32_t maxdomain = ms->numa_state->num_nodes + number_nvgpus_nodes;
324 uint32_t maxdomains[] = {
325 cpu_to_be32(4),
326 cpu_to_be32(maxdomain),
327 cpu_to_be32(maxdomain),
328 cpu_to_be32(maxdomain),
329 cpu_to_be32(maxdomain)
330 };
331
332 if (spapr_machine_using_legacy_numa(spapr)) {
333 uint32_t legacy_refpoints[] = {
334 cpu_to_be32(0x4),
335 cpu_to_be32(0x4),
336 cpu_to_be32(0x2),
337 };
338 uint32_t legacy_maxdomain = spapr->gpu_numa_id > 1 ? 1 : 0;
339 uint32_t legacy_maxdomains[] = {
340 cpu_to_be32(4),
341 cpu_to_be32(legacy_maxdomain),
342 cpu_to_be32(legacy_maxdomain),
343 cpu_to_be32(legacy_maxdomain),
344 cpu_to_be32(spapr->gpu_numa_id),
345 };
346
347 G_STATIC_ASSERT(sizeof(legacy_refpoints) <= sizeof(refpoints));
348 G_STATIC_ASSERT(sizeof(legacy_maxdomains) <= sizeof(maxdomains));
349
350 nr_refpoints = 3;
351
352 memcpy(refpoints, legacy_refpoints, sizeof(legacy_refpoints));
353 memcpy(maxdomains, legacy_maxdomains, sizeof(legacy_maxdomains));
354
355 /* pseries-5.0 and older reference-points array is {0x4, 0x4} */
356 if (smc->pre_5_1_assoc_refpoints) {
357 nr_refpoints = 2;
358 }
359 }
360
361 _FDT(fdt_setprop(fdt, rtas, "ibm,associativity-reference-points",
362 refpoints, nr_refpoints * sizeof(refpoints[0])));
363
364 _FDT(fdt_setprop(fdt, rtas, "ibm,max-associativity-domains",
365 maxdomains, sizeof(maxdomains)));
366 }
367
368 static target_ulong h_home_node_associativity(PowerPCCPU *cpu,
369 SpaprMachineState *spapr,
370 target_ulong opcode,
371 target_ulong *args)
372 {
373 g_autofree uint32_t *vcpu_assoc = NULL;
374 target_ulong flags = args[0];
375 target_ulong procno = args[1];
376 PowerPCCPU *tcpu;
377 int idx, assoc_idx;
378
379 /* only support procno from H_REGISTER_VPA */
380 if (flags != 0x1) {
381 return H_FUNCTION;
382 }
383
384 tcpu = spapr_find_cpu(procno);
385 if (tcpu == NULL) {
386 return H_P2;
387 }
388
389 /*
390 * Given that we want to be flexible with the sizes and indexes,
391 * we must consider that there is a hard limit of how many
392 * associativities domain we can fit in R4 up to R9, which would be
393 * 12 associativity domains for vcpus. Assert and bail if that's
394 * not the case.
395 */
396 G_STATIC_ASSERT((VCPU_ASSOC_SIZE - 1) <= 12);
397
398 vcpu_assoc = spapr_numa_get_vcpu_assoc(spapr, tcpu);
399 /* assoc_idx starts at 1 to skip associativity size */
400 assoc_idx = 1;
401
402 #define ASSOCIATIVITY(a, b) (((uint64_t)(a) << 32) | \
403 ((uint64_t)(b) & 0xffffffff))
404
405 for (idx = 0; idx < 6; idx++) {
406 int32_t a, b;
407
408 /*
409 * vcpu_assoc[] will contain the associativity domains for tcpu,
410 * including tcpu->node_id and procno, meaning that we don't
411 * need to use these variables here.
412 *
413 * We'll read 2 values at a time to fill up the ASSOCIATIVITY()
414 * macro. The ternary will fill the remaining registers with -1
415 * after we went through vcpu_assoc[].
416 */
417 a = assoc_idx < VCPU_ASSOC_SIZE ?
418 be32_to_cpu(vcpu_assoc[assoc_idx++]) : -1;
419 b = assoc_idx < VCPU_ASSOC_SIZE ?
420 be32_to_cpu(vcpu_assoc[assoc_idx++]) : -1;
421
422 args[idx] = ASSOCIATIVITY(a, b);
423 }
424 #undef ASSOCIATIVITY
425
426 return H_SUCCESS;
427 }
428
429 static void spapr_numa_register_types(void)
430 {
431 /* Virtual Processor Home Node */
432 spapr_register_hypercall(H_HOME_NODE_ASSOCIATIVITY,
433 h_home_node_associativity);
434 }
435
436 type_init(spapr_numa_register_types)