]>
Commit | Line | Data |
---|---|---|
96d0e26c WG |
1 | /* |
2 | * NUMA parameter parsing routines | |
3 | * | |
4 | * Copyright (c) 2014 Fujitsu Ltd. | |
5 | * | |
6 | * Permission is hereby granted, free of charge, to any person obtaining a copy | |
7 | * of this software and associated documentation files (the "Software"), to deal | |
8 | * in the Software without restriction, including without limitation the rights | |
9 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
10 | * copies of the Software, and to permit persons to whom the Software is | |
11 | * furnished to do so, subject to the following conditions: | |
12 | * | |
13 | * The above copyright notice and this permission notice shall be included in | |
14 | * all copies or substantial portions of the Software. | |
15 | * | |
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | |
19 | * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
21 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
22 | * THE SOFTWARE. | |
23 | */ | |
24 | ||
d38ea87a | 25 | #include "qemu/osdep.h" |
e35704ba | 26 | #include "sysemu/numa.h" |
96d0e26c | 27 | #include "exec/cpu-common.h" |
0987d735 | 28 | #include "exec/ramlist.h" |
96d0e26c WG |
29 | #include "qemu/bitmap.h" |
30 | #include "qom/cpu.h" | |
2b631ec2 | 31 | #include "qemu/error-report.h" |
0042109a WG |
32 | #include "qapi-visit.h" |
33 | #include "qapi/opts-visitor.h" | |
dfabb8b9 | 34 | #include "hw/boards.h" |
7febe36f | 35 | #include "sysemu/hostmem.h" |
76b5d850 | 36 | #include "qmp-commands.h" |
5b009e40 | 37 | #include "hw/mem/pc-dimm.h" |
7dcd1d70 EH |
38 | #include "qemu/option.h" |
39 | #include "qemu/config-file.h" | |
cc001888 | 40 | #include "qemu/cutils.h" |
0042109a WG |
41 | |
42 | QemuOptsList qemu_numa_opts = { | |
43 | .name = "numa", | |
44 | .implied_opt_name = "type", | |
45 | .head = QTAILQ_HEAD_INITIALIZER(qemu_numa_opts.head), | |
46 | .desc = { { 0 } } /* validated with OptsVisitor */ | |
47 | }; | |
48 | ||
7febe36f | 49 | static int have_memdevs = -1; |
25712ffe EH |
50 | static int max_numa_nodeid; /* Highest specified NUMA node ID, plus one. |
51 | * For all nodes, nodeid < max_numa_nodeid | |
52 | */ | |
de1a7c84 | 53 | int nb_numa_nodes; |
0f203430 | 54 | bool have_numa_distance; |
de1a7c84 | 55 | NodeInfo numa_info[MAX_NODES]; |
7febe36f | 56 | |
e75e2a14 | 57 | |
64c2a8f6 | 58 | static void parse_numa_node(MachineState *ms, NumaNodeOptions *node, |
cc001888 | 59 | Error **errp) |
96d0e26c | 60 | { |
0042109a WG |
61 | uint16_t nodenr; |
62 | uint16List *cpus = NULL; | |
64c2a8f6 | 63 | MachineClass *mc = MACHINE_GET_CLASS(ms); |
96d0e26c | 64 | |
0042109a WG |
65 | if (node->has_nodeid) { |
66 | nodenr = node->nodeid; | |
96d0e26c | 67 | } else { |
0042109a | 68 | nodenr = nb_numa_nodes; |
96d0e26c WG |
69 | } |
70 | ||
0042109a WG |
71 | if (nodenr >= MAX_NODES) { |
72 | error_setg(errp, "Max number of NUMA nodes reached: %" | |
01bbbcf4 | 73 | PRIu16 "", nodenr); |
0042109a | 74 | return; |
96d0e26c WG |
75 | } |
76 | ||
1945b9d8 EH |
77 | if (numa_info[nodenr].present) { |
78 | error_setg(errp, "Duplicate NUMA nodeid: %" PRIu16, nodenr); | |
79 | return; | |
80 | } | |
81 | ||
64c2a8f6 IM |
82 | if (!mc->cpu_index_to_instance_props) { |
83 | error_report("NUMA is not supported by this machine-type"); | |
84 | exit(1); | |
85 | } | |
0042109a | 86 | for (cpus = node->cpus; cpus; cpus = cpus->next) { |
7c88e65d | 87 | CpuInstanceProperties props; |
8979c945 EH |
88 | if (cpus->value >= max_cpus) { |
89 | error_setg(errp, | |
90 | "CPU index (%" PRIu16 ")" | |
91 | " should be smaller than maxcpus (%d)", | |
92 | cpus->value, max_cpus); | |
0042109a WG |
93 | return; |
94 | } | |
7c88e65d IM |
95 | props = mc->cpu_index_to_instance_props(ms, cpus->value); |
96 | props.node_id = nodenr; | |
97 | props.has_node_id = true; | |
98 | machine_set_cpu_numa_node(ms, &props, &error_fatal); | |
96d0e26c WG |
99 | } |
100 | ||
7febe36f | 101 | if (node->has_mem && node->has_memdev) { |
d0e31a10 | 102 | error_setg(errp, "cannot specify both mem= and memdev="); |
7febe36f PB |
103 | return; |
104 | } | |
105 | ||
106 | if (have_memdevs == -1) { | |
107 | have_memdevs = node->has_memdev; | |
108 | } | |
109 | if (node->has_memdev != have_memdevs) { | |
d0e31a10 | 110 | error_setg(errp, "memdev option must be specified for either " |
01bbbcf4 | 111 | "all or no nodes"); |
7febe36f PB |
112 | return; |
113 | } | |
114 | ||
0042109a | 115 | if (node->has_mem) { |
cc001888 | 116 | numa_info[nodenr].node_mem = node->mem; |
0042109a | 117 | } |
7febe36f PB |
118 | if (node->has_memdev) { |
119 | Object *o; | |
120 | o = object_resolve_path_type(node->memdev, TYPE_MEMORY_BACKEND, NULL); | |
121 | if (!o) { | |
122 | error_setg(errp, "memdev=%s is ambiguous", node->memdev); | |
123 | return; | |
124 | } | |
125 | ||
126 | object_ref(o); | |
61d7c144 | 127 | numa_info[nodenr].node_mem = object_property_get_uint(o, "size", NULL); |
7febe36f PB |
128 | numa_info[nodenr].node_memdev = MEMORY_BACKEND(o); |
129 | } | |
1af878e0 EH |
130 | numa_info[nodenr].present = true; |
131 | max_numa_nodeid = MAX(max_numa_nodeid, nodenr + 1); | |
7b8be49d | 132 | nb_numa_nodes++; |
96d0e26c WG |
133 | } |
134 | ||
0f203430 HC |
135 | static void parse_numa_distance(NumaDistOptions *dist, Error **errp) |
136 | { | |
137 | uint16_t src = dist->src; | |
138 | uint16_t dst = dist->dst; | |
139 | uint8_t val = dist->val; | |
140 | ||
141 | if (src >= MAX_NODES || dst >= MAX_NODES) { | |
142 | error_setg(errp, | |
f892291e | 143 | "Invalid node %d, max possible could be %d", |
0f203430 HC |
144 | MAX(src, dst), MAX_NODES); |
145 | return; | |
146 | } | |
147 | ||
148 | if (!numa_info[src].present || !numa_info[dst].present) { | |
149 | error_setg(errp, "Source/Destination NUMA node is missing. " | |
150 | "Please use '-numa node' option to declare it first."); | |
151 | return; | |
152 | } | |
153 | ||
154 | if (val < NUMA_DISTANCE_MIN) { | |
155 | error_setg(errp, "NUMA distance (%" PRIu8 ") is invalid, " | |
156 | "it shouldn't be less than %d.", | |
157 | val, NUMA_DISTANCE_MIN); | |
158 | return; | |
159 | } | |
160 | ||
161 | if (src == dst && val != NUMA_DISTANCE_MIN) { | |
162 | error_setg(errp, "Local distance of node %d should be %d.", | |
163 | src, NUMA_DISTANCE_MIN); | |
164 | return; | |
165 | } | |
166 | ||
167 | numa_info[src].distance[dst] = val; | |
168 | have_numa_distance = true; | |
169 | } | |
170 | ||
28d0de7a | 171 | static int parse_numa(void *opaque, QemuOpts *opts, Error **errp) |
96d0e26c | 172 | { |
0042109a | 173 | NumaOptions *object = NULL; |
64c2a8f6 | 174 | MachineState *ms = opaque; |
0042109a | 175 | Error *err = NULL; |
96d0e26c | 176 | |
0042109a | 177 | { |
09204eac EB |
178 | Visitor *v = opts_visitor_new(opts); |
179 | visit_type_NumaOptions(v, NULL, &object, &err); | |
180 | visit_free(v); | |
96d0e26c | 181 | } |
96d0e26c | 182 | |
0042109a | 183 | if (err) { |
157e94e8 | 184 | goto end; |
0042109a | 185 | } |
96d0e26c | 186 | |
cc001888 IM |
187 | /* Fix up legacy suffix-less format */ |
188 | if ((object->type == NUMA_OPTIONS_TYPE_NODE) && object->u.node.has_mem) { | |
189 | const char *mem_str = qemu_opt_get(opts, "mem"); | |
190 | qemu_strtosz_MiB(mem_str, NULL, &object->u.node.mem); | |
191 | } | |
192 | ||
1fd5d4fe | 193 | switch (object->type) { |
d081a49a | 194 | case NUMA_OPTIONS_TYPE_NODE: |
cc001888 | 195 | parse_numa_node(ms, &object->u.node, &err); |
0042109a | 196 | if (err) { |
157e94e8 | 197 | goto end; |
96d0e26c | 198 | } |
0042109a | 199 | break; |
0f203430 HC |
200 | case NUMA_OPTIONS_TYPE_DIST: |
201 | parse_numa_distance(&object->u.dist, &err); | |
202 | if (err) { | |
203 | goto end; | |
204 | } | |
205 | break; | |
419fcdec IM |
206 | case NUMA_OPTIONS_TYPE_CPU: |
207 | if (!object->u.cpu.has_node_id) { | |
208 | error_setg(&err, "Missing mandatory node-id property"); | |
209 | goto end; | |
210 | } | |
211 | if (!numa_info[object->u.cpu.node_id].present) { | |
212 | error_setg(&err, "Invalid node-id=%" PRId64 ", NUMA node must be " | |
213 | "defined with -numa node,nodeid=ID before it's used with " | |
214 | "-numa cpu,node-id=ID", object->u.cpu.node_id); | |
215 | goto end; | |
216 | } | |
217 | ||
218 | machine_set_cpu_numa_node(ms, qapi_NumaCpuOptions_base(&object->u.cpu), | |
219 | &err); | |
220 | break; | |
0042109a WG |
221 | default: |
222 | abort(); | |
223 | } | |
96d0e26c | 224 | |
157e94e8 | 225 | end: |
96a1616c | 226 | qapi_free_NumaOptions(object); |
157e94e8 MAL |
227 | if (err) { |
228 | error_report_err(err); | |
229 | return -1; | |
230 | } | |
0042109a | 231 | |
157e94e8 | 232 | return 0; |
96d0e26c WG |
233 | } |
234 | ||
0f203430 HC |
235 | /* If all node pair distances are symmetric, then only distances |
236 | * in one direction are enough. If there is even one asymmetric | |
237 | * pair, though, then all distances must be provided. The | |
238 | * distance from a node to itself is always NUMA_DISTANCE_MIN, | |
239 | * so providing it is never necessary. | |
240 | */ | |
241 | static void validate_numa_distance(void) | |
3ef71975 | 242 | { |
0f203430 HC |
243 | int src, dst; |
244 | bool is_asymmetrical = false; | |
245 | ||
246 | for (src = 0; src < nb_numa_nodes; src++) { | |
247 | for (dst = src; dst < nb_numa_nodes; dst++) { | |
248 | if (numa_info[src].distance[dst] == 0 && | |
249 | numa_info[dst].distance[src] == 0) { | |
250 | if (src != dst) { | |
251 | error_report("The distance between node %d and %d is " | |
252 | "missing, at least one distance value " | |
253 | "between each nodes should be provided.", | |
254 | src, dst); | |
255 | exit(EXIT_FAILURE); | |
256 | } | |
257 | } | |
3ef71975 | 258 | |
0f203430 HC |
259 | if (numa_info[src].distance[dst] != 0 && |
260 | numa_info[dst].distance[src] != 0 && | |
261 | numa_info[src].distance[dst] != | |
262 | numa_info[dst].distance[src]) { | |
263 | is_asymmetrical = true; | |
264 | } | |
265 | } | |
266 | } | |
267 | ||
268 | if (is_asymmetrical) { | |
269 | for (src = 0; src < nb_numa_nodes; src++) { | |
270 | for (dst = 0; dst < nb_numa_nodes; dst++) { | |
271 | if (src != dst && numa_info[src].distance[dst] == 0) { | |
272 | error_report("At least one asymmetrical pair of " | |
273 | "distances is given, please provide distances " | |
274 | "for both directions of all node pairs."); | |
275 | exit(EXIT_FAILURE); | |
276 | } | |
277 | } | |
278 | } | |
3ef71975 | 279 | } |
3ef71975 EH |
280 | } |
281 | ||
0f203430 | 282 | static void complete_init_numa_distance(void) |
3ef71975 | 283 | { |
0f203430 | 284 | int src, dst; |
3ef71975 | 285 | |
0f203430 HC |
286 | /* Fixup NUMA distance by symmetric policy because if it is an |
287 | * asymmetric distance table, it should be a complete table and | |
288 | * there would not be any missing distance except local node, which | |
289 | * is verified by validate_numa_distance above. | |
290 | */ | |
291 | for (src = 0; src < nb_numa_nodes; src++) { | |
292 | for (dst = 0; dst < nb_numa_nodes; dst++) { | |
293 | if (numa_info[src].distance[dst] == 0) { | |
294 | if (src == dst) { | |
295 | numa_info[src].distance[dst] = NUMA_DISTANCE_MIN; | |
296 | } else { | |
297 | numa_info[src].distance[dst] = numa_info[dst].distance[src]; | |
298 | } | |
299 | } | |
3ef71975 | 300 | } |
3ef71975 | 301 | } |
0f203430 | 302 | } |
549fc54b | 303 | |
3bfe5716 LV |
304 | void numa_legacy_auto_assign_ram(MachineClass *mc, NodeInfo *nodes, |
305 | int nb_nodes, ram_addr_t size) | |
306 | { | |
307 | int i; | |
308 | uint64_t usedmem = 0; | |
309 | ||
310 | /* Align each node according to the alignment | |
311 | * requirements of the machine class | |
312 | */ | |
313 | ||
314 | for (i = 0; i < nb_nodes - 1; i++) { | |
315 | nodes[i].node_mem = (size / nb_nodes) & | |
316 | ~((1 << mc->numa_mem_align_shift) - 1); | |
317 | usedmem += nodes[i].node_mem; | |
549fc54b | 318 | } |
3bfe5716 | 319 | nodes[i].node_mem = size - usedmem; |
3ef71975 EH |
320 | } |
321 | ||
3bfe5716 LV |
322 | void numa_default_auto_assign_ram(MachineClass *mc, NodeInfo *nodes, |
323 | int nb_nodes, ram_addr_t size) | |
96d0e26c | 324 | { |
12d6e464 | 325 | int i; |
3bfe5716 LV |
326 | uint64_t usedmem = 0, node_mem; |
327 | uint64_t granularity = size / nb_nodes; | |
328 | uint64_t propagate = 0; | |
329 | ||
330 | for (i = 0; i < nb_nodes - 1; i++) { | |
331 | node_mem = (granularity + propagate) & | |
332 | ~((1 << mc->numa_mem_align_shift) - 1); | |
333 | propagate = granularity + propagate - node_mem; | |
334 | nodes[i].node_mem = node_mem; | |
335 | usedmem += node_mem; | |
336 | } | |
337 | nodes[i].node_mem = size - usedmem; | |
338 | } | |
12d6e464 | 339 | |
ea089eeb | 340 | void parse_numa_opts(MachineState *ms) |
96d0e26c | 341 | { |
12d6e464 | 342 | int i; |
ea089eeb | 343 | MachineClass *mc = MACHINE_GET_CLASS(ms); |
cdda2018 | 344 | |
64c2a8f6 | 345 | if (qemu_opts_foreach(qemu_find_opts("numa"), parse_numa, ms, NULL)) { |
7dcd1d70 EH |
346 | exit(1); |
347 | } | |
348 | ||
7b8be49d DL |
349 | /* |
350 | * If memory hotplug is enabled (slots > 0) but without '-numa' | |
351 | * options explicitly on CLI, guestes will break. | |
352 | * | |
353 | * Windows: won't enable memory hotplug without SRAT table at all | |
354 | * | |
355 | * Linux: if QEMU is started with initial memory all below 4Gb | |
356 | * and no SRAT table present, guest kernel will use nommu DMA ops, | |
357 | * which breaks 32bit hw drivers when memory is hotplugged and | |
358 | * guest tries to use it with that drivers. | |
359 | * | |
360 | * Enable NUMA implicitly by adding a new NUMA node automatically. | |
361 | */ | |
362 | if (ms->ram_slots > 0 && nb_numa_nodes == 0 && | |
363 | mc->auto_enable_numa_with_memhp) { | |
364 | NumaNodeOptions node = { }; | |
365 | parse_numa_node(ms, &node, NULL); | |
366 | } | |
367 | ||
12d6e464 EH |
368 | assert(max_numa_nodeid <= MAX_NODES); |
369 | ||
370 | /* No support for sparse NUMA node IDs yet: */ | |
371 | for (i = max_numa_nodeid - 1; i >= 0; i--) { | |
372 | /* Report large node IDs first, to make mistakes easier to spot */ | |
373 | if (!numa_info[i].present) { | |
374 | error_report("numa: Node ID missing: %d", i); | |
375 | exit(1); | |
376 | } | |
377 | } | |
378 | ||
379 | /* This must be always true if all nodes are present: */ | |
380 | assert(nb_numa_nodes == max_numa_nodeid); | |
381 | ||
96d0e26c | 382 | if (nb_numa_nodes > 0) { |
2b631ec2 | 383 | uint64_t numa_total; |
96d0e26c WG |
384 | |
385 | if (nb_numa_nodes > MAX_NODES) { | |
386 | nb_numa_nodes = MAX_NODES; | |
387 | } | |
388 | ||
9851d0fe | 389 | /* If no memory size is given for any node, assume the default case |
96d0e26c WG |
390 | * and distribute the available memory equally across all nodes |
391 | */ | |
392 | for (i = 0; i < nb_numa_nodes; i++) { | |
8c85901e | 393 | if (numa_info[i].node_mem != 0) { |
96d0e26c WG |
394 | break; |
395 | } | |
396 | } | |
397 | if (i == nb_numa_nodes) { | |
3bfe5716 LV |
398 | assert(mc->numa_auto_assign_ram); |
399 | mc->numa_auto_assign_ram(mc, numa_info, nb_numa_nodes, ram_size); | |
96d0e26c WG |
400 | } |
401 | ||
2b631ec2 WG |
402 | numa_total = 0; |
403 | for (i = 0; i < nb_numa_nodes; i++) { | |
8c85901e | 404 | numa_total += numa_info[i].node_mem; |
2b631ec2 WG |
405 | } |
406 | if (numa_total != ram_size) { | |
c68233ae HT |
407 | error_report("total memory for NUMA nodes (0x%" PRIx64 ")" |
408 | " should equal RAM size (0x" RAM_ADDR_FMT ")", | |
2b631ec2 WG |
409 | numa_total, ram_size); |
410 | exit(1); | |
411 | } | |
412 | ||
0f203430 HC |
413 | /* QEMU needs at least all unique node pair distances to build |
414 | * the whole NUMA distance table. QEMU treats the distance table | |
415 | * as symmetric by default, i.e. distance A->B == distance B->A. | |
416 | * Thus, QEMU is able to complete the distance table | |
417 | * initialization even though only distance A->B is provided and | |
418 | * distance B->A is not. QEMU knows the distance of a node to | |
419 | * itself is always 10, so A->A distances may be omitted. When | |
420 | * the distances of two nodes of a pair differ, i.e. distance | |
421 | * A->B != distance B->A, then that means the distance table is | |
422 | * asymmetric. In this case, the distances for both directions | |
423 | * of all node pairs are required. | |
424 | */ | |
425 | if (have_numa_distance) { | |
426 | /* Validate enough NUMA distance information was provided. */ | |
427 | validate_numa_distance(); | |
96d0e26c | 428 | |
0f203430 HC |
429 | /* Validation succeeded, now fill in any missing distances. */ |
430 | complete_init_numa_distance(); | |
96d0e26c WG |
431 | } |
432 | } | |
433 | } | |
dfabb8b9 | 434 | |
a0ceb640 IM |
435 | void numa_cpu_pre_plug(const CPUArchId *slot, DeviceState *dev, Error **errp) |
436 | { | |
a0ceb640 IM |
437 | int node_id = object_property_get_int(OBJECT(dev), "node-id", &error_abort); |
438 | ||
a0ceb640 IM |
439 | if (node_id == CPU_UNSET_NUMA_NODE_ID) { |
440 | /* due to bug in libvirt, it doesn't pass node-id from props on | |
441 | * device_add as expected, so we have to fix it up here */ | |
d41f3e75 IM |
442 | if (slot->props.has_node_id) { |
443 | object_property_set_int(OBJECT(dev), slot->props.node_id, | |
444 | "node-id", errp); | |
445 | } | |
446 | } else if (node_id != slot->props.node_id) { | |
a0ceb640 IM |
447 | error_setg(errp, "node-id=%d must match numa node specified " |
448 | "with -numa option", node_id); | |
449 | } | |
450 | } | |
451 | ||
7febe36f PB |
452 | static void allocate_system_memory_nonnuma(MemoryRegion *mr, Object *owner, |
453 | const char *name, | |
454 | uint64_t ram_size) | |
455 | { | |
0b183fc8 PB |
456 | if (mem_path) { |
457 | #ifdef __linux__ | |
7f56e740 | 458 | Error *err = NULL; |
98376843 | 459 | memory_region_init_ram_from_file(mr, owner, name, ram_size, 0, false, |
7f56e740 | 460 | mem_path, &err); |
c3ba3095 | 461 | if (err) { |
29b762f5 | 462 | error_report_err(err); |
fae947b0 LC |
463 | if (mem_prealloc) { |
464 | exit(1); | |
465 | } | |
466 | ||
467 | /* Legacy behavior: if allocation failed, fall back to | |
468 | * regular RAM allocation. | |
469 | */ | |
1cfe48c1 | 470 | memory_region_init_ram_nomigrate(mr, owner, name, ram_size, &error_fatal); |
7f56e740 | 471 | } |
0b183fc8 PB |
472 | #else |
473 | fprintf(stderr, "-mem-path not supported on this host\n"); | |
474 | exit(1); | |
475 | #endif | |
476 | } else { | |
1cfe48c1 | 477 | memory_region_init_ram_nomigrate(mr, owner, name, ram_size, &error_fatal); |
0b183fc8 | 478 | } |
7febe36f PB |
479 | vmstate_register_ram_global(mr); |
480 | } | |
481 | ||
dfabb8b9 PB |
482 | void memory_region_allocate_system_memory(MemoryRegion *mr, Object *owner, |
483 | const char *name, | |
484 | uint64_t ram_size) | |
485 | { | |
7febe36f PB |
486 | uint64_t addr = 0; |
487 | int i; | |
488 | ||
489 | if (nb_numa_nodes == 0 || !have_memdevs) { | |
490 | allocate_system_memory_nonnuma(mr, owner, name, ram_size); | |
491 | return; | |
492 | } | |
493 | ||
494 | memory_region_init(mr, owner, name, ram_size); | |
f51878ba | 495 | for (i = 0; i < nb_numa_nodes; i++) { |
7febe36f PB |
496 | uint64_t size = numa_info[i].node_mem; |
497 | HostMemoryBackend *backend = numa_info[i].node_memdev; | |
498 | if (!backend) { | |
499 | continue; | |
500 | } | |
007b0657 MA |
501 | MemoryRegion *seg = host_memory_backend_get_memory(backend, |
502 | &error_fatal); | |
7febe36f | 503 | |
0462faee HT |
504 | if (memory_region_is_mapped(seg)) { |
505 | char *path = object_get_canonical_path_component(OBJECT(backend)); | |
506 | error_report("memory backend %s is used multiple times. Each " | |
507 | "-numa option must use a different memdev value.", | |
508 | path); | |
509 | exit(1); | |
510 | } | |
511 | ||
0b217571 | 512 | host_memory_backend_set_mapped(backend, true); |
7febe36f PB |
513 | memory_region_add_subregion(mr, addr, seg); |
514 | vmstate_register_ram_global(seg); | |
515 | addr += size; | |
516 | } | |
dfabb8b9 | 517 | } |
76b5d850 | 518 | |
31959e82 | 519 | static void numa_stat_memory_devices(NumaNodeMem node_mem[]) |
5b009e40 HZ |
520 | { |
521 | MemoryDeviceInfoList *info_list = NULL; | |
522 | MemoryDeviceInfoList **prev = &info_list; | |
523 | MemoryDeviceInfoList *info; | |
31959e82 | 524 | PCDIMMDeviceInfo *pcdimm_info; |
5b009e40 HZ |
525 | |
526 | qmp_pc_dimm_device_list(qdev_get_machine(), &prev); | |
527 | for (info = info_list; info; info = info->next) { | |
528 | MemoryDeviceInfo *value = info->value; | |
529 | ||
530 | if (value) { | |
1fd5d4fe | 531 | switch (value->type) { |
31959e82 VG |
532 | case MEMORY_DEVICE_INFO_KIND_DIMM: { |
533 | pcdimm_info = value->u.dimm.data; | |
534 | node_mem[pcdimm_info->node].node_mem += pcdimm_info->size; | |
535 | if (pcdimm_info->hotpluggable && pcdimm_info->hotplugged) { | |
536 | node_mem[pcdimm_info->node].node_plugged_mem += | |
537 | pcdimm_info->size; | |
538 | } | |
5b009e40 | 539 | break; |
31959e82 VG |
540 | } |
541 | ||
5b009e40 HZ |
542 | default: |
543 | break; | |
544 | } | |
545 | } | |
546 | } | |
547 | qapi_free_MemoryDeviceInfoList(info_list); | |
548 | } | |
549 | ||
31959e82 | 550 | void query_numa_node_mem(NumaNodeMem node_mem[]) |
5b009e40 HZ |
551 | { |
552 | int i; | |
553 | ||
554 | if (nb_numa_nodes <= 0) { | |
555 | return; | |
556 | } | |
557 | ||
558 | numa_stat_memory_devices(node_mem); | |
559 | for (i = 0; i < nb_numa_nodes; i++) { | |
31959e82 | 560 | node_mem[i].node_mem += numa_info[i].node_mem; |
5b009e40 HZ |
561 | } |
562 | } | |
563 | ||
76b5d850 HT |
564 | static int query_memdev(Object *obj, void *opaque) |
565 | { | |
566 | MemdevList **list = opaque; | |
b0e90181 | 567 | MemdevList *m = NULL; |
76b5d850 HT |
568 | |
569 | if (object_dynamic_cast(obj, TYPE_MEMORY_BACKEND)) { | |
b0e90181 | 570 | m = g_malloc0(sizeof(*m)); |
76b5d850 HT |
571 | |
572 | m->value = g_malloc0(sizeof(*m->value)); | |
573 | ||
e1ff3c67 IM |
574 | m->value->id = object_property_get_str(obj, "id", NULL); |
575 | m->value->has_id = !!m->value->id; | |
576 | ||
61d7c144 MAL |
577 | m->value->size = object_property_get_uint(obj, "size", |
578 | &error_abort); | |
76b5d850 | 579 | m->value->merge = object_property_get_bool(obj, "merge", |
2f6f826e | 580 | &error_abort); |
76b5d850 | 581 | m->value->dump = object_property_get_bool(obj, "dump", |
2f6f826e | 582 | &error_abort); |
76b5d850 | 583 | m->value->prealloc = object_property_get_bool(obj, |
2f6f826e MA |
584 | "prealloc", |
585 | &error_abort); | |
76b5d850 HT |
586 | m->value->policy = object_property_get_enum(obj, |
587 | "policy", | |
a3590dac | 588 | "HostMemPolicy", |
2f6f826e | 589 | &error_abort); |
76b5d850 | 590 | object_property_get_uint16List(obj, "host-nodes", |
2f6f826e MA |
591 | &m->value->host_nodes, |
592 | &error_abort); | |
76b5d850 HT |
593 | |
594 | m->next = *list; | |
595 | *list = m; | |
596 | } | |
597 | ||
598 | return 0; | |
76b5d850 HT |
599 | } |
600 | ||
601 | MemdevList *qmp_query_memdev(Error **errp) | |
602 | { | |
2f6f826e | 603 | Object *obj = object_get_objects_root(); |
ecaf54a0 | 604 | MemdevList *list = NULL; |
76b5d850 | 605 | |
2f6f826e | 606 | object_child_foreach(obj, query_memdev, &list); |
76b5d850 | 607 | return list; |
76b5d850 | 608 | } |
6bea1ddf | 609 | |
0987d735 PB |
610 | void ram_block_notifier_add(RAMBlockNotifier *n) |
611 | { | |
612 | QLIST_INSERT_HEAD(&ram_list.ramblock_notifiers, n, next); | |
613 | } | |
614 | ||
615 | void ram_block_notifier_remove(RAMBlockNotifier *n) | |
616 | { | |
617 | QLIST_REMOVE(n, next); | |
618 | } | |
619 | ||
620 | void ram_block_notify_add(void *host, size_t size) | |
621 | { | |
622 | RAMBlockNotifier *notifier; | |
623 | ||
624 | QLIST_FOREACH(notifier, &ram_list.ramblock_notifiers, next) { | |
625 | notifier->ram_block_added(notifier, host, size); | |
626 | } | |
627 | } | |
628 | ||
629 | void ram_block_notify_remove(void *host, size_t size) | |
630 | { | |
631 | RAMBlockNotifier *notifier; | |
632 | ||
633 | QLIST_FOREACH(notifier, &ram_list.ramblock_notifiers, next) { | |
634 | notifier->ram_block_removed(notifier, host, size); | |
635 | } | |
636 | } |