2014-05-14 13:43:05 +04:00
|
|
|
/*
|
|
|
|
* NUMA parameter parsing routines
|
|
|
|
*
|
|
|
|
* Copyright (c) 2014 Fujitsu Ltd.
|
|
|
|
*
|
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
|
|
* in the Software without restriction, including without limitation the rights
|
|
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
|
|
* furnished to do so, subject to the following conditions:
|
|
|
|
*
|
|
|
|
* The above copyright notice and this permission notice shall be included in
|
|
|
|
* all copies or substantial portions of the Software.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
|
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
|
|
* THE SOFTWARE.
|
|
|
|
*/
|
|
|
|
|
2016-01-29 20:50:05 +03:00
|
|
|
#include "qemu/osdep.h"
|
2019-12-13 04:19:23 +03:00
|
|
|
#include "qemu/units.h"
|
2019-08-12 08:23:55 +03:00
|
|
|
#include "sysemu/hostmem.h"
|
2015-02-08 21:51:16 +03:00
|
|
|
#include "sysemu/numa.h"
|
2014-05-14 13:43:05 +04:00
|
|
|
#include "exec/cpu-common.h"
|
2016-12-20 19:31:36 +03:00
|
|
|
#include "exec/ramlist.h"
|
2014-05-14 13:43:05 +04:00
|
|
|
#include "qemu/bitmap.h"
|
2014-05-14 13:43:06 +04:00
|
|
|
#include "qemu/error-report.h"
|
2018-02-01 14:18:31 +03:00
|
|
|
#include "qapi/error.h"
|
2014-05-14 13:43:08 +04:00
|
|
|
#include "qapi/opts-visitor.h"
|
2019-06-19 23:10:41 +03:00
|
|
|
#include "qapi/qapi-visit-machine.h"
|
2019-07-03 00:57:26 +03:00
|
|
|
#include "sysemu/qtest.h"
|
2019-07-09 18:20:52 +03:00
|
|
|
#include "hw/core/cpu.h"
|
2014-11-04 14:49:30 +03:00
|
|
|
#include "hw/mem/pc-dimm.h"
|
2019-08-12 08:23:45 +03:00
|
|
|
#include "migration/vmstate.h"
|
2019-08-12 08:23:52 +03:00
|
|
|
#include "hw/boards.h"
|
2018-04-23 19:51:16 +03:00
|
|
|
#include "hw/mem/memory-device.h"
|
2015-02-08 21:51:20 +03:00
|
|
|
#include "qemu/option.h"
|
|
|
|
#include "qemu/config-file.h"
|
2017-10-12 12:39:58 +03:00
|
|
|
#include "qemu/cutils.h"
|
2014-05-14 13:43:08 +04:00
|
|
|
|
|
|
|
QemuOptsList qemu_numa_opts = {
|
|
|
|
.name = "numa",
|
|
|
|
.implied_opt_name = "type",
|
|
|
|
.head = QTAILQ_HEAD_INITIALIZER(qemu_numa_opts.head),
|
|
|
|
.desc = { { 0 } } /* validated with OptsVisitor */
|
|
|
|
};
|
|
|
|
|
2019-07-02 17:07:44 +03:00
|
|
|
static int have_memdevs;
|
2020-02-19 19:08:39 +03:00
|
|
|
bool numa_uses_legacy_mem(void)
|
|
|
|
{
|
|
|
|
return !have_memdevs;
|
|
|
|
}
|
|
|
|
|
2019-07-02 17:07:44 +03:00
|
|
|
static int have_mem;
|
2015-02-08 21:51:19 +03:00
|
|
|
static int max_numa_nodeid; /* Highest specified NUMA node ID, plus one.
|
|
|
|
* For all nodes, nodeid < max_numa_nodeid
|
|
|
|
*/
|
2015-06-29 11:20:27 +03:00
|
|
|
|
2017-05-10 14:29:49 +03:00
|
|
|
static void parse_numa_node(MachineState *ms, NumaNodeOptions *node,
|
2017-10-12 12:39:58 +03:00
|
|
|
Error **errp)
|
2014-05-14 13:43:05 +04:00
|
|
|
{
|
2018-10-17 11:26:39 +03:00
|
|
|
Error *err = NULL;
|
2014-05-14 13:43:08 +04:00
|
|
|
uint16_t nodenr;
|
|
|
|
uint16List *cpus = NULL;
|
2017-05-10 14:29:49 +03:00
|
|
|
MachineClass *mc = MACHINE_GET_CLASS(ms);
|
2019-05-18 23:54:21 +03:00
|
|
|
unsigned int max_cpus = ms->smp.max_cpus;
|
2019-08-09 09:57:24 +03:00
|
|
|
NodeInfo *numa_info = ms->numa_state->nodes;
|
2014-05-14 13:43:05 +04:00
|
|
|
|
2014-05-14 13:43:08 +04:00
|
|
|
if (node->has_nodeid) {
|
|
|
|
nodenr = node->nodeid;
|
2014-05-14 13:43:05 +04:00
|
|
|
} else {
|
2019-08-09 09:57:22 +03:00
|
|
|
nodenr = ms->numa_state->num_nodes;
|
2014-05-14 13:43:05 +04:00
|
|
|
}
|
|
|
|
|
2014-05-14 13:43:08 +04:00
|
|
|
if (nodenr >= MAX_NODES) {
|
|
|
|
error_setg(errp, "Max number of NUMA nodes reached: %"
|
2015-02-25 07:22:30 +03:00
|
|
|
PRIu16 "", nodenr);
|
2014-05-14 13:43:08 +04:00
|
|
|
return;
|
2014-05-14 13:43:05 +04:00
|
|
|
}
|
|
|
|
|
2014-06-27 01:33:19 +04:00
|
|
|
if (numa_info[nodenr].present) {
|
|
|
|
error_setg(errp, "Duplicate NUMA nodeid: %" PRIu16, nodenr);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
numa: Parse initiator= attribute before cpus= attribute
When parsing cpus= attribute of -numa object couple of checks
is performed, such as correct initiator setting (see the if()
statement at the end of for() loop in
machine_set_cpu_numa_node()).
However, with the current code cpus= attribute is parsed before
initiator= attribute and thus the check may fail even though it
is not obvious why. But since parsing the initiator= attribute
does not depend on the cpus= attribute we can swap the order of
the two.
It's fairly easy to reproduce with the following command line
(snippet of an actual cmd line):
-smp 4,sockets=4,cores=1,threads=1 \
-object '{"qom-type":"memory-backend-ram","id":"ram-node0","size":2147483648}' \
-numa node,nodeid=0,cpus=0-1,initiator=0,memdev=ram-node0 \
-object '{"qom-type":"memory-backend-ram","id":"ram-node1","size":2147483648}' \
-numa node,nodeid=1,cpus=2-3,initiator=1,memdev=ram-node1 \
-numa hmat-lb,initiator=0,target=0,hierarchy=memory,data-type=access-latency,latency=5 \
-numa hmat-lb,initiator=0,target=0,hierarchy=first-level,data-type=access-latency,latency=10 \
-numa hmat-lb,initiator=1,target=1,hierarchy=memory,data-type=access-latency,latency=5 \
-numa hmat-lb,initiator=1,target=1,hierarchy=first-level,data-type=access-latency,latency=10 \
-numa hmat-lb,initiator=0,target=0,hierarchy=memory,data-type=access-bandwidth,bandwidth=204800K \
-numa hmat-lb,initiator=0,target=0,hierarchy=first-level,data-type=access-bandwidth,bandwidth=208896K \
-numa hmat-lb,initiator=1,target=1,hierarchy=memory,data-type=access-bandwidth,bandwidth=204800K \
-numa hmat-lb,initiator=1,target=1,hierarchy=first-level,data-type=access-bandwidth,bandwidth=208896K \
-numa hmat-cache,node-id=0,size=10K,level=1,associativity=direct,policy=write-back,line=8 \
-numa hmat-cache,node-id=1,size=10K,level=1,associativity=direct,policy=write-back,line=8 \
Signed-off-by: Michal Privoznik <mprivozn@redhat.com>
Reviewed-by: Igor Mammedov <imammedo@redhat.com>
Message-Id: <b27a6a88986d63e3f610a728c845e01ff8d92e2e.1625662776.git.mprivozn@redhat.com>
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
2021-07-07 16:40:30 +03:00
|
|
|
/*
|
|
|
|
* If not set the initiator, set it to MAX_NODES. And if
|
|
|
|
* HMAT is enabled and this node has no cpus, QEMU will raise error.
|
|
|
|
*/
|
|
|
|
numa_info[nodenr].initiator = MAX_NODES;
|
|
|
|
if (node->has_initiator) {
|
|
|
|
if (!ms->numa_state->hmat_enabled) {
|
|
|
|
error_setg(errp, "ACPI Heterogeneous Memory Attribute Table "
|
|
|
|
"(HMAT) is disabled, enable it with -machine hmat=on "
|
|
|
|
"before using any of hmat specific options");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (node->initiator >= MAX_NODES) {
|
|
|
|
error_report("The initiator id %" PRIu16 " expects an integer "
|
|
|
|
"between 0 and %d", node->initiator,
|
|
|
|
MAX_NODES - 1);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
numa_info[nodenr].initiator = node->initiator;
|
|
|
|
}
|
|
|
|
|
2014-05-14 13:43:08 +04:00
|
|
|
for (cpus = node->cpus; cpus; cpus = cpus->next) {
|
2017-05-10 14:29:50 +03:00
|
|
|
CpuInstanceProperties props;
|
2015-02-09 22:28:52 +03:00
|
|
|
if (cpus->value >= max_cpus) {
|
|
|
|
error_setg(errp,
|
|
|
|
"CPU index (%" PRIu16 ")"
|
|
|
|
" should be smaller than maxcpus (%d)",
|
|
|
|
cpus->value, max_cpus);
|
2014-05-14 13:43:08 +04:00
|
|
|
return;
|
|
|
|
}
|
2017-05-10 14:29:50 +03:00
|
|
|
props = mc->cpu_index_to_instance_props(ms, cpus->value);
|
|
|
|
props.node_id = nodenr;
|
|
|
|
props.has_node_id = true;
|
2018-10-17 11:26:39 +03:00
|
|
|
machine_set_cpu_numa_node(ms, &props, &err);
|
|
|
|
if (err) {
|
|
|
|
error_propagate(errp, err);
|
|
|
|
return;
|
|
|
|
}
|
2014-05-14 13:43:05 +04:00
|
|
|
}
|
|
|
|
|
2019-07-02 17:07:44 +03:00
|
|
|
have_memdevs = have_memdevs ? : node->has_memdev;
|
|
|
|
have_mem = have_mem ? : node->has_mem;
|
|
|
|
if ((node->has_mem && have_memdevs) || (node->has_memdev && have_mem)) {
|
|
|
|
error_setg(errp, "numa configuration should use either mem= or memdev=,"
|
|
|
|
"mixing both is not allowed");
|
numa: add -numa node,memdev= option
This option provides the infrastructure for binding guest NUMA nodes
to host NUMA nodes. For example:
-object memory-ram,size=1024M,policy=bind,host-nodes=0,id=ram-node0 \
-numa node,nodeid=0,cpus=0,memdev=ram-node0 \
-object memory-ram,size=1024M,policy=interleave,host-nodes=1-3,id=ram-node1 \
-numa node,nodeid=1,cpus=1,memdev=ram-node1
The option replaces "-numa node,mem=".
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Hu Tao <hutao@cn.fujitsu.com>
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
Acked-by: Michael S. Tsirkin <mst@redhat.com>
MST: conflict resolution
2014-05-14 13:43:17 +04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2014-05-14 13:43:08 +04:00
|
|
|
if (node->has_mem) {
|
2020-06-09 16:56:35 +03:00
|
|
|
if (!mc->numa_mem_supported) {
|
|
|
|
error_setg(errp, "Parameter -numa node,mem is not supported by this"
|
|
|
|
" machine type");
|
|
|
|
error_append_hint(errp, "Use -numa node,memdev instead\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2017-10-12 12:39:58 +03:00
|
|
|
numa_info[nodenr].node_mem = node->mem;
|
2019-07-03 00:57:26 +03:00
|
|
|
if (!qtest_enabled()) {
|
|
|
|
warn_report("Parameter -numa node,mem is deprecated,"
|
|
|
|
" use -numa node,memdev instead");
|
|
|
|
}
|
2014-05-14 13:43:08 +04:00
|
|
|
}
|
numa: add -numa node,memdev= option
This option provides the infrastructure for binding guest NUMA nodes
to host NUMA nodes. For example:
-object memory-ram,size=1024M,policy=bind,host-nodes=0,id=ram-node0 \
-numa node,nodeid=0,cpus=0,memdev=ram-node0 \
-object memory-ram,size=1024M,policy=interleave,host-nodes=1-3,id=ram-node1 \
-numa node,nodeid=1,cpus=1,memdev=ram-node1
The option replaces "-numa node,mem=".
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Hu Tao <hutao@cn.fujitsu.com>
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
Acked-by: Michael S. Tsirkin <mst@redhat.com>
MST: conflict resolution
2014-05-14 13:43:17 +04:00
|
|
|
if (node->has_memdev) {
|
|
|
|
Object *o;
|
|
|
|
o = object_resolve_path_type(node->memdev, TYPE_MEMORY_BACKEND, NULL);
|
|
|
|
if (!o) {
|
|
|
|
error_setg(errp, "memdev=%s is ambiguous", node->memdev);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
object_ref(o);
|
2017-06-07 19:36:30 +03:00
|
|
|
numa_info[nodenr].node_mem = object_property_get_uint(o, "size", NULL);
|
numa: add -numa node,memdev= option
This option provides the infrastructure for binding guest NUMA nodes
to host NUMA nodes. For example:
-object memory-ram,size=1024M,policy=bind,host-nodes=0,id=ram-node0 \
-numa node,nodeid=0,cpus=0,memdev=ram-node0 \
-object memory-ram,size=1024M,policy=interleave,host-nodes=1-3,id=ram-node1 \
-numa node,nodeid=1,cpus=1,memdev=ram-node1
The option replaces "-numa node,mem=".
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Hu Tao <hutao@cn.fujitsu.com>
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
Acked-by: Michael S. Tsirkin <mst@redhat.com>
MST: conflict resolution
2014-05-14 13:43:17 +04:00
|
|
|
numa_info[nodenr].node_memdev = MEMORY_BACKEND(o);
|
|
|
|
}
|
2019-12-13 04:19:22 +03:00
|
|
|
|
2014-06-27 01:33:18 +04:00
|
|
|
numa_info[nodenr].present = true;
|
|
|
|
max_numa_nodeid = MAX(max_numa_nodeid, nodenr + 1);
|
2019-08-09 09:57:22 +03:00
|
|
|
ms->numa_state->num_nodes++;
|
2014-05-14 13:43:05 +04:00
|
|
|
}
|
|
|
|
|
2019-08-09 09:57:22 +03:00
|
|
|
static
|
|
|
|
void parse_numa_distance(MachineState *ms, NumaDistOptions *dist, Error **errp)
|
numa: Allow setting NUMA distance for different NUMA nodes
This patch is going to add SLIT table support in QEMU, and provides
additional option `dist` for command `-numa` to allow user set vNUMA
distance by QEMU command.
With this patch, when a user wants to create a guest that contains
several vNUMA nodes and also wants to set distance among those nodes,
the QEMU command would like:
```
-numa node,nodeid=0,cpus=0 \
-numa node,nodeid=1,cpus=1 \
-numa node,nodeid=2,cpus=2 \
-numa node,nodeid=3,cpus=3 \
-numa dist,src=0,dst=1,val=21 \
-numa dist,src=0,dst=2,val=31 \
-numa dist,src=0,dst=3,val=41 \
-numa dist,src=1,dst=2,val=21 \
-numa dist,src=1,dst=3,val=31 \
-numa dist,src=2,dst=3,val=21 \
```
Signed-off-by: He Chen <he.chen@linux.intel.com>
Message-Id: <1493260558-20728-1-git-send-email-he.chen@linux.intel.com>
Reviewed-by: Igor Mammedov <imammedo@redhat.com>
Reviewed-by: Andrew Jones <drjones@redhat.com>
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
2017-04-27 05:35:58 +03:00
|
|
|
{
|
|
|
|
uint16_t src = dist->src;
|
|
|
|
uint16_t dst = dist->dst;
|
|
|
|
uint8_t val = dist->val;
|
2019-08-09 09:57:24 +03:00
|
|
|
NodeInfo *numa_info = ms->numa_state->nodes;
|
numa: Allow setting NUMA distance for different NUMA nodes
This patch is going to add SLIT table support in QEMU, and provides
additional option `dist` for command `-numa` to allow user set vNUMA
distance by QEMU command.
With this patch, when a user wants to create a guest that contains
several vNUMA nodes and also wants to set distance among those nodes,
the QEMU command would like:
```
-numa node,nodeid=0,cpus=0 \
-numa node,nodeid=1,cpus=1 \
-numa node,nodeid=2,cpus=2 \
-numa node,nodeid=3,cpus=3 \
-numa dist,src=0,dst=1,val=21 \
-numa dist,src=0,dst=2,val=31 \
-numa dist,src=0,dst=3,val=41 \
-numa dist,src=1,dst=2,val=21 \
-numa dist,src=1,dst=3,val=31 \
-numa dist,src=2,dst=3,val=21 \
```
Signed-off-by: He Chen <he.chen@linux.intel.com>
Message-Id: <1493260558-20728-1-git-send-email-he.chen@linux.intel.com>
Reviewed-by: Igor Mammedov <imammedo@redhat.com>
Reviewed-by: Andrew Jones <drjones@redhat.com>
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
2017-04-27 05:35:58 +03:00
|
|
|
|
|
|
|
if (src >= MAX_NODES || dst >= MAX_NODES) {
|
2018-05-16 18:06:14 +03:00
|
|
|
error_setg(errp, "Parameter '%s' expects an integer between 0 and %d",
|
|
|
|
src >= MAX_NODES ? "src" : "dst", MAX_NODES - 1);
|
numa: Allow setting NUMA distance for different NUMA nodes
This patch is going to add SLIT table support in QEMU, and provides
additional option `dist` for command `-numa` to allow user set vNUMA
distance by QEMU command.
With this patch, when a user wants to create a guest that contains
several vNUMA nodes and also wants to set distance among those nodes,
the QEMU command would like:
```
-numa node,nodeid=0,cpus=0 \
-numa node,nodeid=1,cpus=1 \
-numa node,nodeid=2,cpus=2 \
-numa node,nodeid=3,cpus=3 \
-numa dist,src=0,dst=1,val=21 \
-numa dist,src=0,dst=2,val=31 \
-numa dist,src=0,dst=3,val=41 \
-numa dist,src=1,dst=2,val=21 \
-numa dist,src=1,dst=3,val=31 \
-numa dist,src=2,dst=3,val=21 \
```
Signed-off-by: He Chen <he.chen@linux.intel.com>
Message-Id: <1493260558-20728-1-git-send-email-he.chen@linux.intel.com>
Reviewed-by: Igor Mammedov <imammedo@redhat.com>
Reviewed-by: Andrew Jones <drjones@redhat.com>
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
2017-04-27 05:35:58 +03:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!numa_info[src].present || !numa_info[dst].present) {
|
|
|
|
error_setg(errp, "Source/Destination NUMA node is missing. "
|
|
|
|
"Please use '-numa node' option to declare it first.");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (val < NUMA_DISTANCE_MIN) {
|
|
|
|
error_setg(errp, "NUMA distance (%" PRIu8 ") is invalid, "
|
|
|
|
"it shouldn't be less than %d.",
|
|
|
|
val, NUMA_DISTANCE_MIN);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (src == dst && val != NUMA_DISTANCE_MIN) {
|
|
|
|
error_setg(errp, "Local distance of node %d should be %d.",
|
|
|
|
src, NUMA_DISTANCE_MIN);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
numa_info[src].distance[dst] = val;
|
2019-08-09 09:57:23 +03:00
|
|
|
ms->numa_state->have_numa_distance = true;
|
numa: Allow setting NUMA distance for different NUMA nodes
This patch is going to add SLIT table support in QEMU, and provides
additional option `dist` for command `-numa` to allow user set vNUMA
distance by QEMU command.
With this patch, when a user wants to create a guest that contains
several vNUMA nodes and also wants to set distance among those nodes,
the QEMU command would like:
```
-numa node,nodeid=0,cpus=0 \
-numa node,nodeid=1,cpus=1 \
-numa node,nodeid=2,cpus=2 \
-numa node,nodeid=3,cpus=3 \
-numa dist,src=0,dst=1,val=21 \
-numa dist,src=0,dst=2,val=31 \
-numa dist,src=0,dst=3,val=41 \
-numa dist,src=1,dst=2,val=21 \
-numa dist,src=1,dst=3,val=31 \
-numa dist,src=2,dst=3,val=21 \
```
Signed-off-by: He Chen <he.chen@linux.intel.com>
Message-Id: <1493260558-20728-1-git-send-email-he.chen@linux.intel.com>
Reviewed-by: Igor Mammedov <imammedo@redhat.com>
Reviewed-by: Andrew Jones <drjones@redhat.com>
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
2017-04-27 05:35:58 +03:00
|
|
|
}
|
|
|
|
|
2019-12-13 04:19:23 +03:00
|
|
|
void parse_numa_hmat_lb(NumaState *numa_state, NumaHmatLBOptions *node,
|
|
|
|
Error **errp)
|
|
|
|
{
|
|
|
|
int i, first_bit, last_bit;
|
|
|
|
uint64_t max_entry, temp_base, bitmap_copy;
|
|
|
|
NodeInfo *numa_info = numa_state->nodes;
|
|
|
|
HMAT_LB_Info *hmat_lb =
|
|
|
|
numa_state->hmat_lb[node->hierarchy][node->data_type];
|
|
|
|
HMAT_LB_Data lb_data = {};
|
|
|
|
HMAT_LB_Data *lb_temp;
|
|
|
|
|
|
|
|
/* Error checking */
|
|
|
|
if (node->initiator > numa_state->num_nodes) {
|
|
|
|
error_setg(errp, "Invalid initiator=%d, it should be less than %d",
|
|
|
|
node->initiator, numa_state->num_nodes);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (node->target > numa_state->num_nodes) {
|
|
|
|
error_setg(errp, "Invalid target=%d, it should be less than %d",
|
|
|
|
node->target, numa_state->num_nodes);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (!numa_info[node->initiator].has_cpu) {
|
|
|
|
error_setg(errp, "Invalid initiator=%d, it isn't an "
|
|
|
|
"initiator proximity domain", node->initiator);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (!numa_info[node->target].present) {
|
|
|
|
error_setg(errp, "The target=%d should point to an existing node",
|
|
|
|
node->target);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!hmat_lb) {
|
|
|
|
hmat_lb = g_malloc0(sizeof(*hmat_lb));
|
|
|
|
numa_state->hmat_lb[node->hierarchy][node->data_type] = hmat_lb;
|
|
|
|
hmat_lb->list = g_array_new(false, true, sizeof(HMAT_LB_Data));
|
|
|
|
}
|
|
|
|
hmat_lb->hierarchy = node->hierarchy;
|
|
|
|
hmat_lb->data_type = node->data_type;
|
|
|
|
lb_data.initiator = node->initiator;
|
|
|
|
lb_data.target = node->target;
|
|
|
|
|
|
|
|
if (node->data_type <= HMATLB_DATA_TYPE_WRITE_LATENCY) {
|
|
|
|
/* Input latency data */
|
|
|
|
|
|
|
|
if (!node->has_latency) {
|
|
|
|
error_setg(errp, "Missing 'latency' option");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (node->has_bandwidth) {
|
|
|
|
error_setg(errp, "Invalid option 'bandwidth' since "
|
|
|
|
"the data type is latency");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Detect duplicate configuration */
|
|
|
|
for (i = 0; i < hmat_lb->list->len; i++) {
|
|
|
|
lb_temp = &g_array_index(hmat_lb->list, HMAT_LB_Data, i);
|
|
|
|
|
|
|
|
if (node->initiator == lb_temp->initiator &&
|
|
|
|
node->target == lb_temp->target) {
|
|
|
|
error_setg(errp, "Duplicate configuration of the latency for "
|
|
|
|
"initiator=%d and target=%d", node->initiator,
|
|
|
|
node->target);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
hmat_lb->base = hmat_lb->base ? hmat_lb->base : UINT64_MAX;
|
|
|
|
|
|
|
|
if (node->latency) {
|
|
|
|
/* Calculate the temporary base and compressed latency */
|
|
|
|
max_entry = node->latency;
|
|
|
|
temp_base = 1;
|
|
|
|
while (QEMU_IS_ALIGNED(max_entry, 10)) {
|
|
|
|
max_entry /= 10;
|
|
|
|
temp_base *= 10;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Calculate the max compressed latency */
|
|
|
|
temp_base = MIN(hmat_lb->base, temp_base);
|
|
|
|
max_entry = node->latency / hmat_lb->base;
|
|
|
|
max_entry = MAX(hmat_lb->range_bitmap, max_entry);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* For latency hmat_lb->range_bitmap record the max compressed
|
|
|
|
* latency which should be less than 0xFFFF (UINT16_MAX)
|
|
|
|
*/
|
|
|
|
if (max_entry >= UINT16_MAX) {
|
|
|
|
error_setg(errp, "Latency %" PRIu64 " between initiator=%d and "
|
|
|
|
"target=%d should not differ from previously entered "
|
|
|
|
"min or max values on more than %d", node->latency,
|
|
|
|
node->initiator, node->target, UINT16_MAX - 1);
|
|
|
|
return;
|
|
|
|
} else {
|
|
|
|
hmat_lb->base = temp_base;
|
|
|
|
hmat_lb->range_bitmap = max_entry;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set lb_info_provided bit 0 as 1,
|
|
|
|
* latency information is provided
|
|
|
|
*/
|
|
|
|
numa_info[node->target].lb_info_provided |= BIT(0);
|
|
|
|
}
|
|
|
|
lb_data.data = node->latency;
|
|
|
|
} else if (node->data_type >= HMATLB_DATA_TYPE_ACCESS_BANDWIDTH) {
|
|
|
|
/* Input bandwidth data */
|
|
|
|
if (!node->has_bandwidth) {
|
|
|
|
error_setg(errp, "Missing 'bandwidth' option");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (node->has_latency) {
|
|
|
|
error_setg(errp, "Invalid option 'latency' since "
|
|
|
|
"the data type is bandwidth");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (!QEMU_IS_ALIGNED(node->bandwidth, MiB)) {
|
|
|
|
error_setg(errp, "Bandwidth %" PRIu64 " between initiator=%d and "
|
|
|
|
"target=%d should be 1MB aligned", node->bandwidth,
|
|
|
|
node->initiator, node->target);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Detect duplicate configuration */
|
|
|
|
for (i = 0; i < hmat_lb->list->len; i++) {
|
|
|
|
lb_temp = &g_array_index(hmat_lb->list, HMAT_LB_Data, i);
|
|
|
|
|
|
|
|
if (node->initiator == lb_temp->initiator &&
|
|
|
|
node->target == lb_temp->target) {
|
|
|
|
error_setg(errp, "Duplicate configuration of the bandwidth for "
|
|
|
|
"initiator=%d and target=%d", node->initiator,
|
|
|
|
node->target);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
hmat_lb->base = hmat_lb->base ? hmat_lb->base : 1;
|
|
|
|
|
|
|
|
if (node->bandwidth) {
|
|
|
|
/* Keep bitmap unchanged when bandwidth out of range */
|
|
|
|
bitmap_copy = hmat_lb->range_bitmap;
|
|
|
|
bitmap_copy |= node->bandwidth;
|
|
|
|
first_bit = ctz64(bitmap_copy);
|
|
|
|
temp_base = UINT64_C(1) << first_bit;
|
|
|
|
max_entry = node->bandwidth / temp_base;
|
|
|
|
last_bit = 64 - clz64(bitmap_copy);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* For bandwidth, first_bit record the base unit of bandwidth bits,
|
|
|
|
* last_bit record the last bit of the max bandwidth. The max
|
|
|
|
* compressed bandwidth should be less than 0xFFFF (UINT16_MAX)
|
|
|
|
*/
|
|
|
|
if ((last_bit - first_bit) > UINT16_BITS ||
|
|
|
|
max_entry >= UINT16_MAX) {
|
|
|
|
error_setg(errp, "Bandwidth %" PRIu64 " between initiator=%d "
|
|
|
|
"and target=%d should not differ from previously "
|
|
|
|
"entered values on more than %d", node->bandwidth,
|
|
|
|
node->initiator, node->target, UINT16_MAX - 1);
|
|
|
|
return;
|
|
|
|
} else {
|
|
|
|
hmat_lb->base = temp_base;
|
|
|
|
hmat_lb->range_bitmap = bitmap_copy;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set lb_info_provided bit 1 as 1,
|
|
|
|
* bandwidth information is provided
|
|
|
|
*/
|
|
|
|
numa_info[node->target].lb_info_provided |= BIT(1);
|
|
|
|
}
|
|
|
|
lb_data.data = node->bandwidth;
|
|
|
|
} else {
|
|
|
|
assert(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
g_array_append_val(hmat_lb->list, lb_data);
|
|
|
|
}
|
|
|
|
|
2019-12-13 04:19:24 +03:00
|
|
|
void parse_numa_hmat_cache(MachineState *ms, NumaHmatCacheOptions *node,
|
|
|
|
Error **errp)
|
|
|
|
{
|
|
|
|
int nb_numa_nodes = ms->numa_state->num_nodes;
|
|
|
|
NodeInfo *numa_info = ms->numa_state->nodes;
|
|
|
|
NumaHmatCacheOptions *hmat_cache = NULL;
|
|
|
|
|
|
|
|
if (node->node_id >= nb_numa_nodes) {
|
|
|
|
error_setg(errp, "Invalid node-id=%" PRIu32 ", it should be less "
|
|
|
|
"than %d", node->node_id, nb_numa_nodes);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (numa_info[node->node_id].lb_info_provided != (BIT(0) | BIT(1))) {
|
|
|
|
error_setg(errp, "The latency and bandwidth information of "
|
|
|
|
"node-id=%" PRIu32 " should be provided before memory side "
|
|
|
|
"cache attributes", node->node_id);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (node->level < 1 || node->level >= HMAT_LB_LEVELS) {
|
|
|
|
error_setg(errp, "Invalid level=%" PRIu8 ", it should be larger than 0 "
|
|
|
|
"and less than or equal to %d", node->level,
|
|
|
|
HMAT_LB_LEVELS - 1);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
assert(node->associativity < HMAT_CACHE_ASSOCIATIVITY__MAX);
|
|
|
|
assert(node->policy < HMAT_CACHE_WRITE_POLICY__MAX);
|
|
|
|
if (ms->numa_state->hmat_cache[node->node_id][node->level]) {
|
|
|
|
error_setg(errp, "Duplicate configuration of the side cache for "
|
|
|
|
"node-id=%" PRIu32 " and level=%" PRIu8,
|
|
|
|
node->node_id, node->level);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((node->level > 1) &&
|
2020-10-06 18:00:02 +03:00
|
|
|
ms->numa_state->hmat_cache[node->node_id][node->level - 1] == NULL) {
|
|
|
|
error_setg(errp, "Cache level=%u shall be defined first",
|
|
|
|
node->level - 1);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((node->level > 1) &&
|
numa: hmat: fix cache size check
when QEMU is started like:
qemu-system-x86_64 -smp 2 -machine hmat=on \
-m 2G \
-object memory-backend-ram,size=1G,id=m0 \
-object memory-backend-ram,size=1G,id=m1 \
-numa node,nodeid=0,memdev=m0 \
-numa node,nodeid=1,memdev=m1,initiator=0 \
-numa cpu,node-id=0,socket-id=0 \
-numa cpu,node-id=0,socket-id=1 \
-numa hmat-lb,initiator=0,target=0,hierarchy=memory,data-type=access-latency,latency=5 \
-numa hmat-lb,initiator=0,target=0,hierarchy=memory,data-type=access-bandwidth,bandwidth=200M \
-numa hmat-lb,initiator=0,target=1,hierarchy=memory,data-type=access-latency,latency=10 \
-numa hmat-lb,initiator=0,target=1,hierarchy=memory,data-type=access-bandwidth,bandwidth=100M \
-numa hmat-cache,node-id=0,size=8K,level=1,associativity=direct,policy=write-back,line=5 \
-numa hmat-cache,node-id=0,size=16K,level=2,associativity=direct,policy=write-back,line=5
it errors out with:
-numa hmat-cache,node-id=0,size=16K,level=2,associativity=direct,policy=write-back,line=5:
Invalid size=16384, the size of level=2 should be less than the size(8192) of level=1
which doesn't look right as one would expect that L1 < L2 < L3 ...
Fix it by sawpping relevant size checks.
Fixes: c412a48d4d91 (numa: Extend CLI to provide memory side cache information)
Signed-off-by: Igor Mammedov <imammedo@redhat.com>
Message-Id: <20200821100519.1325691-1-imammedo@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
2020-08-21 13:05:19 +03:00
|
|
|
(node->size <=
|
2019-12-13 04:19:24 +03:00
|
|
|
ms->numa_state->hmat_cache[node->node_id][node->level - 1]->size)) {
|
|
|
|
error_setg(errp, "Invalid size=%" PRIu64 ", the size of level=%" PRIu8
|
numa: hmat: fix cache size check
when QEMU is started like:
qemu-system-x86_64 -smp 2 -machine hmat=on \
-m 2G \
-object memory-backend-ram,size=1G,id=m0 \
-object memory-backend-ram,size=1G,id=m1 \
-numa node,nodeid=0,memdev=m0 \
-numa node,nodeid=1,memdev=m1,initiator=0 \
-numa cpu,node-id=0,socket-id=0 \
-numa cpu,node-id=0,socket-id=1 \
-numa hmat-lb,initiator=0,target=0,hierarchy=memory,data-type=access-latency,latency=5 \
-numa hmat-lb,initiator=0,target=0,hierarchy=memory,data-type=access-bandwidth,bandwidth=200M \
-numa hmat-lb,initiator=0,target=1,hierarchy=memory,data-type=access-latency,latency=10 \
-numa hmat-lb,initiator=0,target=1,hierarchy=memory,data-type=access-bandwidth,bandwidth=100M \
-numa hmat-cache,node-id=0,size=8K,level=1,associativity=direct,policy=write-back,line=5 \
-numa hmat-cache,node-id=0,size=16K,level=2,associativity=direct,policy=write-back,line=5
it errors out with:
-numa hmat-cache,node-id=0,size=16K,level=2,associativity=direct,policy=write-back,line=5:
Invalid size=16384, the size of level=2 should be less than the size(8192) of level=1
which doesn't look right as one would expect that L1 < L2 < L3 ...
Fix it by sawpping relevant size checks.
Fixes: c412a48d4d91 (numa: Extend CLI to provide memory side cache information)
Signed-off-by: Igor Mammedov <imammedo@redhat.com>
Message-Id: <20200821100519.1325691-1-imammedo@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
2020-08-21 13:05:19 +03:00
|
|
|
" should be larger than the size(%" PRIu64 ") of "
|
2019-12-13 04:19:24 +03:00
|
|
|
"level=%u", node->size, node->level,
|
|
|
|
ms->numa_state->hmat_cache[node->node_id]
|
|
|
|
[node->level - 1]->size,
|
|
|
|
node->level - 1);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((node->level < HMAT_LB_LEVELS - 1) &&
|
|
|
|
ms->numa_state->hmat_cache[node->node_id][node->level + 1] &&
|
numa: hmat: fix cache size check
when QEMU is started like:
qemu-system-x86_64 -smp 2 -machine hmat=on \
-m 2G \
-object memory-backend-ram,size=1G,id=m0 \
-object memory-backend-ram,size=1G,id=m1 \
-numa node,nodeid=0,memdev=m0 \
-numa node,nodeid=1,memdev=m1,initiator=0 \
-numa cpu,node-id=0,socket-id=0 \
-numa cpu,node-id=0,socket-id=1 \
-numa hmat-lb,initiator=0,target=0,hierarchy=memory,data-type=access-latency,latency=5 \
-numa hmat-lb,initiator=0,target=0,hierarchy=memory,data-type=access-bandwidth,bandwidth=200M \
-numa hmat-lb,initiator=0,target=1,hierarchy=memory,data-type=access-latency,latency=10 \
-numa hmat-lb,initiator=0,target=1,hierarchy=memory,data-type=access-bandwidth,bandwidth=100M \
-numa hmat-cache,node-id=0,size=8K,level=1,associativity=direct,policy=write-back,line=5 \
-numa hmat-cache,node-id=0,size=16K,level=2,associativity=direct,policy=write-back,line=5
it errors out with:
-numa hmat-cache,node-id=0,size=16K,level=2,associativity=direct,policy=write-back,line=5:
Invalid size=16384, the size of level=2 should be less than the size(8192) of level=1
which doesn't look right as one would expect that L1 < L2 < L3 ...
Fix it by sawpping relevant size checks.
Fixes: c412a48d4d91 (numa: Extend CLI to provide memory side cache information)
Signed-off-by: Igor Mammedov <imammedo@redhat.com>
Message-Id: <20200821100519.1325691-1-imammedo@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
2020-08-21 13:05:19 +03:00
|
|
|
(node->size >=
|
2019-12-13 04:19:24 +03:00
|
|
|
ms->numa_state->hmat_cache[node->node_id][node->level + 1]->size)) {
|
|
|
|
error_setg(errp, "Invalid size=%" PRIu64 ", the size of level=%" PRIu8
|
numa: hmat: fix cache size check
when QEMU is started like:
qemu-system-x86_64 -smp 2 -machine hmat=on \
-m 2G \
-object memory-backend-ram,size=1G,id=m0 \
-object memory-backend-ram,size=1G,id=m1 \
-numa node,nodeid=0,memdev=m0 \
-numa node,nodeid=1,memdev=m1,initiator=0 \
-numa cpu,node-id=0,socket-id=0 \
-numa cpu,node-id=0,socket-id=1 \
-numa hmat-lb,initiator=0,target=0,hierarchy=memory,data-type=access-latency,latency=5 \
-numa hmat-lb,initiator=0,target=0,hierarchy=memory,data-type=access-bandwidth,bandwidth=200M \
-numa hmat-lb,initiator=0,target=1,hierarchy=memory,data-type=access-latency,latency=10 \
-numa hmat-lb,initiator=0,target=1,hierarchy=memory,data-type=access-bandwidth,bandwidth=100M \
-numa hmat-cache,node-id=0,size=8K,level=1,associativity=direct,policy=write-back,line=5 \
-numa hmat-cache,node-id=0,size=16K,level=2,associativity=direct,policy=write-back,line=5
it errors out with:
-numa hmat-cache,node-id=0,size=16K,level=2,associativity=direct,policy=write-back,line=5:
Invalid size=16384, the size of level=2 should be less than the size(8192) of level=1
which doesn't look right as one would expect that L1 < L2 < L3 ...
Fix it by sawpping relevant size checks.
Fixes: c412a48d4d91 (numa: Extend CLI to provide memory side cache information)
Signed-off-by: Igor Mammedov <imammedo@redhat.com>
Message-Id: <20200821100519.1325691-1-imammedo@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
2020-08-21 13:05:19 +03:00
|
|
|
" should be less than the size(%" PRIu64 ") of "
|
2019-12-13 04:19:24 +03:00
|
|
|
"level=%u", node->size, node->level,
|
|
|
|
ms->numa_state->hmat_cache[node->node_id]
|
|
|
|
[node->level + 1]->size,
|
|
|
|
node->level + 1);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
hmat_cache = g_malloc0(sizeof(*hmat_cache));
|
|
|
|
memcpy(hmat_cache, node, sizeof(*hmat_cache));
|
|
|
|
ms->numa_state->hmat_cache[node->node_id][node->level] = hmat_cache;
|
|
|
|
}
|
|
|
|
|
2018-05-04 11:37:40 +03:00
|
|
|
void set_numa_options(MachineState *ms, NumaOptions *object, Error **errp)
|
2014-05-14 13:43:05 +04:00
|
|
|
{
|
2019-12-12 15:48:55 +03:00
|
|
|
if (!ms->numa_state) {
|
2019-08-09 09:57:22 +03:00
|
|
|
error_setg(errp, "NUMA is not supported by this machine-type");
|
2020-07-07 19:06:04 +03:00
|
|
|
return;
|
2019-08-09 09:57:22 +03:00
|
|
|
}
|
2014-05-14 13:43:05 +04:00
|
|
|
|
2015-10-27 01:34:59 +03:00
|
|
|
switch (object->type) {
|
2017-02-21 23:46:26 +03:00
|
|
|
case NUMA_OPTIONS_TYPE_NODE:
|
2020-07-07 19:06:04 +03:00
|
|
|
parse_numa_node(ms, &object->u.node, errp);
|
2014-05-14 13:43:08 +04:00
|
|
|
break;
|
numa: Allow setting NUMA distance for different NUMA nodes
This patch is going to add SLIT table support in QEMU, and provides
additional option `dist` for command `-numa` to allow user set vNUMA
distance by QEMU command.
With this patch, when a user wants to create a guest that contains
several vNUMA nodes and also wants to set distance among those nodes,
the QEMU command would like:
```
-numa node,nodeid=0,cpus=0 \
-numa node,nodeid=1,cpus=1 \
-numa node,nodeid=2,cpus=2 \
-numa node,nodeid=3,cpus=3 \
-numa dist,src=0,dst=1,val=21 \
-numa dist,src=0,dst=2,val=31 \
-numa dist,src=0,dst=3,val=41 \
-numa dist,src=1,dst=2,val=21 \
-numa dist,src=1,dst=3,val=31 \
-numa dist,src=2,dst=3,val=21 \
```
Signed-off-by: He Chen <he.chen@linux.intel.com>
Message-Id: <1493260558-20728-1-git-send-email-he.chen@linux.intel.com>
Reviewed-by: Igor Mammedov <imammedo@redhat.com>
Reviewed-by: Andrew Jones <drjones@redhat.com>
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
2017-04-27 05:35:58 +03:00
|
|
|
case NUMA_OPTIONS_TYPE_DIST:
|
2020-07-07 19:06:04 +03:00
|
|
|
parse_numa_distance(ms, &object->u.dist, errp);
|
numa: Allow setting NUMA distance for different NUMA nodes
This patch is going to add SLIT table support in QEMU, and provides
additional option `dist` for command `-numa` to allow user set vNUMA
distance by QEMU command.
With this patch, when a user wants to create a guest that contains
several vNUMA nodes and also wants to set distance among those nodes,
the QEMU command would like:
```
-numa node,nodeid=0,cpus=0 \
-numa node,nodeid=1,cpus=1 \
-numa node,nodeid=2,cpus=2 \
-numa node,nodeid=3,cpus=3 \
-numa dist,src=0,dst=1,val=21 \
-numa dist,src=0,dst=2,val=31 \
-numa dist,src=0,dst=3,val=41 \
-numa dist,src=1,dst=2,val=21 \
-numa dist,src=1,dst=3,val=31 \
-numa dist,src=2,dst=3,val=21 \
```
Signed-off-by: He Chen <he.chen@linux.intel.com>
Message-Id: <1493260558-20728-1-git-send-email-he.chen@linux.intel.com>
Reviewed-by: Igor Mammedov <imammedo@redhat.com>
Reviewed-by: Andrew Jones <drjones@redhat.com>
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
2017-04-27 05:35:58 +03:00
|
|
|
break;
|
numa: add '-numa cpu,...' option for property based node mapping
legacy cpu to node mapping is using cpu index values to map
VCPU to node with help of '-numa node,nodeid=node,cpus=x[-y]'
option. However cpu index is internal concept and QEMU users
have to guess /reimplement qemu's logic/ to map it to
a concrete cpu socket/core/thread to make sane CPUs
placement across numa nodes.
This patch allows to map cpu objects to numa nodes using
the same properties as used for cpus with -device/device_add
(socket-id/core-id/thread-id/node-id).
At present valid properties/values to address CPUs could be
fetched using hotpluggable-cpus monitor/qmp command, it will
require user to start qemu twice when creating domain to fetch
possible CPUs for a machine type/-smp layout first and
then the second time with numa explicit mapping for actual
usage. The first step results could be saved and reused to
set/change mapping later as far as machine type/-smp stays
the same.
Proposed impl. supports exact and wildcard matching to
simplify CLI and allow to set mapping for a specific cpu
or group of cpu objects specified by matched properties.
For example:
# exact mapping x86
-numa cpu,node-id=x,socket-id=y,core-id=z,thread-id=n
# exact mapping SPAPR
-numa cpu,node-id=x,core-id=y
# wildcard mapping, all cpu objects that match socket-id=y
# are mapped to node-id=x
-numa cpu,node-id=x,socket-id=y
Signed-off-by: Igor Mammedov <imammedo@redhat.com>
Message-Id: <1494415802-227633-18-git-send-email-imammedo@redhat.com>
Reviewed-by: David Gibson <david@gibson.dropbear.id.au>
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
2017-05-10 14:30:01 +03:00
|
|
|
case NUMA_OPTIONS_TYPE_CPU:
|
|
|
|
if (!object->u.cpu.has_node_id) {
|
2020-07-07 19:06:04 +03:00
|
|
|
error_setg(errp, "Missing mandatory node-id property");
|
|
|
|
return;
|
numa: add '-numa cpu,...' option for property based node mapping
legacy cpu to node mapping is using cpu index values to map
VCPU to node with help of '-numa node,nodeid=node,cpus=x[-y]'
option. However cpu index is internal concept and QEMU users
have to guess /reimplement qemu's logic/ to map it to
a concrete cpu socket/core/thread to make sane CPUs
placement across numa nodes.
This patch allows to map cpu objects to numa nodes using
the same properties as used for cpus with -device/device_add
(socket-id/core-id/thread-id/node-id).
At present valid properties/values to address CPUs could be
fetched using hotpluggable-cpus monitor/qmp command, it will
require user to start qemu twice when creating domain to fetch
possible CPUs for a machine type/-smp layout first and
then the second time with numa explicit mapping for actual
usage. The first step results could be saved and reused to
set/change mapping later as far as machine type/-smp stays
the same.
Proposed impl. supports exact and wildcard matching to
simplify CLI and allow to set mapping for a specific cpu
or group of cpu objects specified by matched properties.
For example:
# exact mapping x86
-numa cpu,node-id=x,socket-id=y,core-id=z,thread-id=n
# exact mapping SPAPR
-numa cpu,node-id=x,core-id=y
# wildcard mapping, all cpu objects that match socket-id=y
# are mapped to node-id=x
-numa cpu,node-id=x,socket-id=y
Signed-off-by: Igor Mammedov <imammedo@redhat.com>
Message-Id: <1494415802-227633-18-git-send-email-imammedo@redhat.com>
Reviewed-by: David Gibson <david@gibson.dropbear.id.au>
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
2017-05-10 14:30:01 +03:00
|
|
|
}
|
2019-08-09 09:57:24 +03:00
|
|
|
if (!ms->numa_state->nodes[object->u.cpu.node_id].present) {
|
2020-07-07 19:06:04 +03:00
|
|
|
error_setg(errp, "Invalid node-id=%" PRId64 ", NUMA node must be "
|
|
|
|
"defined with -numa node,nodeid=ID before it's used with "
|
|
|
|
"-numa cpu,node-id=ID", object->u.cpu.node_id);
|
|
|
|
return;
|
numa: add '-numa cpu,...' option for property based node mapping
legacy cpu to node mapping is using cpu index values to map
VCPU to node with help of '-numa node,nodeid=node,cpus=x[-y]'
option. However cpu index is internal concept and QEMU users
have to guess /reimplement qemu's logic/ to map it to
a concrete cpu socket/core/thread to make sane CPUs
placement across numa nodes.
This patch allows to map cpu objects to numa nodes using
the same properties as used for cpus with -device/device_add
(socket-id/core-id/thread-id/node-id).
At present valid properties/values to address CPUs could be
fetched using hotpluggable-cpus monitor/qmp command, it will
require user to start qemu twice when creating domain to fetch
possible CPUs for a machine type/-smp layout first and
then the second time with numa explicit mapping for actual
usage. The first step results could be saved and reused to
set/change mapping later as far as machine type/-smp stays
the same.
Proposed impl. supports exact and wildcard matching to
simplify CLI and allow to set mapping for a specific cpu
or group of cpu objects specified by matched properties.
For example:
# exact mapping x86
-numa cpu,node-id=x,socket-id=y,core-id=z,thread-id=n
# exact mapping SPAPR
-numa cpu,node-id=x,core-id=y
# wildcard mapping, all cpu objects that match socket-id=y
# are mapped to node-id=x
-numa cpu,node-id=x,socket-id=y
Signed-off-by: Igor Mammedov <imammedo@redhat.com>
Message-Id: <1494415802-227633-18-git-send-email-imammedo@redhat.com>
Reviewed-by: David Gibson <david@gibson.dropbear.id.au>
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
2017-05-10 14:30:01 +03:00
|
|
|
}
|
|
|
|
|
2020-07-07 19:06:04 +03:00
|
|
|
machine_set_cpu_numa_node(ms,
|
|
|
|
qapi_NumaCpuOptions_base(&object->u.cpu),
|
|
|
|
errp);
|
numa: add '-numa cpu,...' option for property based node mapping
legacy cpu to node mapping is using cpu index values to map
VCPU to node with help of '-numa node,nodeid=node,cpus=x[-y]'
option. However cpu index is internal concept and QEMU users
have to guess /reimplement qemu's logic/ to map it to
a concrete cpu socket/core/thread to make sane CPUs
placement across numa nodes.
This patch allows to map cpu objects to numa nodes using
the same properties as used for cpus with -device/device_add
(socket-id/core-id/thread-id/node-id).
At present valid properties/values to address CPUs could be
fetched using hotpluggable-cpus monitor/qmp command, it will
require user to start qemu twice when creating domain to fetch
possible CPUs for a machine type/-smp layout first and
then the second time with numa explicit mapping for actual
usage. The first step results could be saved and reused to
set/change mapping later as far as machine type/-smp stays
the same.
Proposed impl. supports exact and wildcard matching to
simplify CLI and allow to set mapping for a specific cpu
or group of cpu objects specified by matched properties.
For example:
# exact mapping x86
-numa cpu,node-id=x,socket-id=y,core-id=z,thread-id=n
# exact mapping SPAPR
-numa cpu,node-id=x,core-id=y
# wildcard mapping, all cpu objects that match socket-id=y
# are mapped to node-id=x
-numa cpu,node-id=x,socket-id=y
Signed-off-by: Igor Mammedov <imammedo@redhat.com>
Message-Id: <1494415802-227633-18-git-send-email-imammedo@redhat.com>
Reviewed-by: David Gibson <david@gibson.dropbear.id.au>
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
2017-05-10 14:30:01 +03:00
|
|
|
break;
|
2019-12-13 04:19:23 +03:00
|
|
|
case NUMA_OPTIONS_TYPE_HMAT_LB:
|
|
|
|
if (!ms->numa_state->hmat_enabled) {
|
|
|
|
error_setg(errp, "ACPI Heterogeneous Memory Attribute Table "
|
|
|
|
"(HMAT) is disabled, enable it with -machine hmat=on "
|
|
|
|
"before using any of hmat specific options");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2020-07-07 19:06:04 +03:00
|
|
|
parse_numa_hmat_lb(ms->numa_state, &object->u.hmat_lb, errp);
|
2019-12-13 04:19:23 +03:00
|
|
|
break;
|
2019-12-13 04:19:24 +03:00
|
|
|
case NUMA_OPTIONS_TYPE_HMAT_CACHE:
|
|
|
|
if (!ms->numa_state->hmat_enabled) {
|
|
|
|
error_setg(errp, "ACPI Heterogeneous Memory Attribute Table "
|
|
|
|
"(HMAT) is disabled, enable it with -machine hmat=on "
|
|
|
|
"before using any of hmat specific options");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2020-07-07 19:06:04 +03:00
|
|
|
parse_numa_hmat_cache(ms, &object->u.hmat_cache, errp);
|
2019-12-13 04:19:24 +03:00
|
|
|
break;
|
2014-05-14 13:43:08 +04:00
|
|
|
default:
|
|
|
|
abort();
|
|
|
|
}
|
2018-05-04 11:37:40 +03:00
|
|
|
}
|
|
|
|
|
2018-10-17 11:26:52 +03:00
|
|
|
static int parse_numa(void *opaque, QemuOpts *opts, Error **errp)
|
2018-05-04 11:37:40 +03:00
|
|
|
{
|
|
|
|
NumaOptions *object = NULL;
|
|
|
|
MachineState *ms = MACHINE(opaque);
|
|
|
|
Error *err = NULL;
|
|
|
|
Visitor *v = opts_visitor_new(opts);
|
|
|
|
|
2020-07-07 19:06:07 +03:00
|
|
|
visit_type_NumaOptions(v, NULL, &object, errp);
|
2018-05-04 11:37:40 +03:00
|
|
|
visit_free(v);
|
2020-07-07 19:06:07 +03:00
|
|
|
if (!object) {
|
|
|
|
return -1;
|
2018-05-04 11:37:40 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Fix up legacy suffix-less format */
|
|
|
|
if ((object->type == NUMA_OPTIONS_TYPE_NODE) && object->u.node.has_mem) {
|
|
|
|
const char *mem_str = qemu_opt_get(opts, "mem");
|
|
|
|
qemu_strtosz_MiB(mem_str, NULL, &object->u.node.mem);
|
|
|
|
}
|
|
|
|
|
|
|
|
set_numa_options(ms, object, &err);
|
|
|
|
|
2016-02-24 00:14:33 +03:00
|
|
|
qapi_free_NumaOptions(object);
|
2016-07-13 03:39:13 +03:00
|
|
|
if (err) {
|
2018-10-17 11:26:52 +03:00
|
|
|
error_propagate(errp, err);
|
2016-07-13 03:39:13 +03:00
|
|
|
return -1;
|
|
|
|
}
|
2014-05-14 13:43:08 +04:00
|
|
|
|
2016-07-13 03:39:13 +03:00
|
|
|
return 0;
|
2014-05-14 13:43:05 +04:00
|
|
|
}
|
|
|
|
|
numa: Allow setting NUMA distance for different NUMA nodes
This patch is going to add SLIT table support in QEMU, and provides
additional option `dist` for command `-numa` to allow user set vNUMA
distance by QEMU command.
With this patch, when a user wants to create a guest that contains
several vNUMA nodes and also wants to set distance among those nodes,
the QEMU command would like:
```
-numa node,nodeid=0,cpus=0 \
-numa node,nodeid=1,cpus=1 \
-numa node,nodeid=2,cpus=2 \
-numa node,nodeid=3,cpus=3 \
-numa dist,src=0,dst=1,val=21 \
-numa dist,src=0,dst=2,val=31 \
-numa dist,src=0,dst=3,val=41 \
-numa dist,src=1,dst=2,val=21 \
-numa dist,src=1,dst=3,val=31 \
-numa dist,src=2,dst=3,val=21 \
```
Signed-off-by: He Chen <he.chen@linux.intel.com>
Message-Id: <1493260558-20728-1-git-send-email-he.chen@linux.intel.com>
Reviewed-by: Igor Mammedov <imammedo@redhat.com>
Reviewed-by: Andrew Jones <drjones@redhat.com>
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
2017-04-27 05:35:58 +03:00
|
|
|
/* If all node pair distances are symmetric, then only distances
|
|
|
|
* in one direction are enough. If there is even one asymmetric
|
|
|
|
* pair, though, then all distances must be provided. The
|
|
|
|
* distance from a node to itself is always NUMA_DISTANCE_MIN,
|
|
|
|
* so providing it is never necessary.
|
|
|
|
*/
|
2019-08-09 09:57:22 +03:00
|
|
|
static void validate_numa_distance(MachineState *ms)
|
2015-02-09 22:32:04 +03:00
|
|
|
{
|
numa: Allow setting NUMA distance for different NUMA nodes
This patch is going to add SLIT table support in QEMU, and provides
additional option `dist` for command `-numa` to allow user set vNUMA
distance by QEMU command.
With this patch, when a user wants to create a guest that contains
several vNUMA nodes and also wants to set distance among those nodes,
the QEMU command would like:
```
-numa node,nodeid=0,cpus=0 \
-numa node,nodeid=1,cpus=1 \
-numa node,nodeid=2,cpus=2 \
-numa node,nodeid=3,cpus=3 \
-numa dist,src=0,dst=1,val=21 \
-numa dist,src=0,dst=2,val=31 \
-numa dist,src=0,dst=3,val=41 \
-numa dist,src=1,dst=2,val=21 \
-numa dist,src=1,dst=3,val=31 \
-numa dist,src=2,dst=3,val=21 \
```
Signed-off-by: He Chen <he.chen@linux.intel.com>
Message-Id: <1493260558-20728-1-git-send-email-he.chen@linux.intel.com>
Reviewed-by: Igor Mammedov <imammedo@redhat.com>
Reviewed-by: Andrew Jones <drjones@redhat.com>
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
2017-04-27 05:35:58 +03:00
|
|
|
int src, dst;
|
|
|
|
bool is_asymmetrical = false;
|
2019-08-09 09:57:22 +03:00
|
|
|
int nb_numa_nodes = ms->numa_state->num_nodes;
|
2019-08-09 09:57:24 +03:00
|
|
|
NodeInfo *numa_info = ms->numa_state->nodes;
|
numa: Allow setting NUMA distance for different NUMA nodes
This patch is going to add SLIT table support in QEMU, and provides
additional option `dist` for command `-numa` to allow user set vNUMA
distance by QEMU command.
With this patch, when a user wants to create a guest that contains
several vNUMA nodes and also wants to set distance among those nodes,
the QEMU command would like:
```
-numa node,nodeid=0,cpus=0 \
-numa node,nodeid=1,cpus=1 \
-numa node,nodeid=2,cpus=2 \
-numa node,nodeid=3,cpus=3 \
-numa dist,src=0,dst=1,val=21 \
-numa dist,src=0,dst=2,val=31 \
-numa dist,src=0,dst=3,val=41 \
-numa dist,src=1,dst=2,val=21 \
-numa dist,src=1,dst=3,val=31 \
-numa dist,src=2,dst=3,val=21 \
```
Signed-off-by: He Chen <he.chen@linux.intel.com>
Message-Id: <1493260558-20728-1-git-send-email-he.chen@linux.intel.com>
Reviewed-by: Igor Mammedov <imammedo@redhat.com>
Reviewed-by: Andrew Jones <drjones@redhat.com>
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
2017-04-27 05:35:58 +03:00
|
|
|
|
|
|
|
for (src = 0; src < nb_numa_nodes; src++) {
|
|
|
|
for (dst = src; dst < nb_numa_nodes; dst++) {
|
|
|
|
if (numa_info[src].distance[dst] == 0 &&
|
|
|
|
numa_info[dst].distance[src] == 0) {
|
|
|
|
if (src != dst) {
|
|
|
|
error_report("The distance between node %d and %d is "
|
|
|
|
"missing, at least one distance value "
|
|
|
|
"between each nodes should be provided.",
|
|
|
|
src, dst);
|
|
|
|
exit(EXIT_FAILURE);
|
|
|
|
}
|
|
|
|
}
|
2015-02-09 22:32:04 +03:00
|
|
|
|
numa: Allow setting NUMA distance for different NUMA nodes
This patch is going to add SLIT table support in QEMU, and provides
additional option `dist` for command `-numa` to allow user set vNUMA
distance by QEMU command.
With this patch, when a user wants to create a guest that contains
several vNUMA nodes and also wants to set distance among those nodes,
the QEMU command would like:
```
-numa node,nodeid=0,cpus=0 \
-numa node,nodeid=1,cpus=1 \
-numa node,nodeid=2,cpus=2 \
-numa node,nodeid=3,cpus=3 \
-numa dist,src=0,dst=1,val=21 \
-numa dist,src=0,dst=2,val=31 \
-numa dist,src=0,dst=3,val=41 \
-numa dist,src=1,dst=2,val=21 \
-numa dist,src=1,dst=3,val=31 \
-numa dist,src=2,dst=3,val=21 \
```
Signed-off-by: He Chen <he.chen@linux.intel.com>
Message-Id: <1493260558-20728-1-git-send-email-he.chen@linux.intel.com>
Reviewed-by: Igor Mammedov <imammedo@redhat.com>
Reviewed-by: Andrew Jones <drjones@redhat.com>
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
2017-04-27 05:35:58 +03:00
|
|
|
if (numa_info[src].distance[dst] != 0 &&
|
|
|
|
numa_info[dst].distance[src] != 0 &&
|
|
|
|
numa_info[src].distance[dst] !=
|
|
|
|
numa_info[dst].distance[src]) {
|
|
|
|
is_asymmetrical = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (is_asymmetrical) {
|
|
|
|
for (src = 0; src < nb_numa_nodes; src++) {
|
|
|
|
for (dst = 0; dst < nb_numa_nodes; dst++) {
|
|
|
|
if (src != dst && numa_info[src].distance[dst] == 0) {
|
|
|
|
error_report("At least one asymmetrical pair of "
|
|
|
|
"distances is given, please provide distances "
|
|
|
|
"for both directions of all node pairs.");
|
|
|
|
exit(EXIT_FAILURE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2015-02-09 22:32:04 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-08-09 09:57:22 +03:00
|
|
|
static void complete_init_numa_distance(MachineState *ms)
|
2015-02-09 22:32:04 +03:00
|
|
|
{
|
numa: Allow setting NUMA distance for different NUMA nodes
This patch is going to add SLIT table support in QEMU, and provides
additional option `dist` for command `-numa` to allow user set vNUMA
distance by QEMU command.
With this patch, when a user wants to create a guest that contains
several vNUMA nodes and also wants to set distance among those nodes,
the QEMU command would like:
```
-numa node,nodeid=0,cpus=0 \
-numa node,nodeid=1,cpus=1 \
-numa node,nodeid=2,cpus=2 \
-numa node,nodeid=3,cpus=3 \
-numa dist,src=0,dst=1,val=21 \
-numa dist,src=0,dst=2,val=31 \
-numa dist,src=0,dst=3,val=41 \
-numa dist,src=1,dst=2,val=21 \
-numa dist,src=1,dst=3,val=31 \
-numa dist,src=2,dst=3,val=21 \
```
Signed-off-by: He Chen <he.chen@linux.intel.com>
Message-Id: <1493260558-20728-1-git-send-email-he.chen@linux.intel.com>
Reviewed-by: Igor Mammedov <imammedo@redhat.com>
Reviewed-by: Andrew Jones <drjones@redhat.com>
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
2017-04-27 05:35:58 +03:00
|
|
|
int src, dst;
|
2019-08-09 09:57:24 +03:00
|
|
|
NodeInfo *numa_info = ms->numa_state->nodes;
|
2015-02-09 22:32:04 +03:00
|
|
|
|
numa: Allow setting NUMA distance for different NUMA nodes
This patch is going to add SLIT table support in QEMU, and provides
additional option `dist` for command `-numa` to allow user set vNUMA
distance by QEMU command.
With this patch, when a user wants to create a guest that contains
several vNUMA nodes and also wants to set distance among those nodes,
the QEMU command would like:
```
-numa node,nodeid=0,cpus=0 \
-numa node,nodeid=1,cpus=1 \
-numa node,nodeid=2,cpus=2 \
-numa node,nodeid=3,cpus=3 \
-numa dist,src=0,dst=1,val=21 \
-numa dist,src=0,dst=2,val=31 \
-numa dist,src=0,dst=3,val=41 \
-numa dist,src=1,dst=2,val=21 \
-numa dist,src=1,dst=3,val=31 \
-numa dist,src=2,dst=3,val=21 \
```
Signed-off-by: He Chen <he.chen@linux.intel.com>
Message-Id: <1493260558-20728-1-git-send-email-he.chen@linux.intel.com>
Reviewed-by: Igor Mammedov <imammedo@redhat.com>
Reviewed-by: Andrew Jones <drjones@redhat.com>
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
2017-04-27 05:35:58 +03:00
|
|
|
/* Fixup NUMA distance by symmetric policy because if it is an
|
|
|
|
* asymmetric distance table, it should be a complete table and
|
|
|
|
* there would not be any missing distance except local node, which
|
|
|
|
* is verified by validate_numa_distance above.
|
|
|
|
*/
|
2019-08-09 09:57:22 +03:00
|
|
|
for (src = 0; src < ms->numa_state->num_nodes; src++) {
|
|
|
|
for (dst = 0; dst < ms->numa_state->num_nodes; dst++) {
|
numa: Allow setting NUMA distance for different NUMA nodes
This patch is going to add SLIT table support in QEMU, and provides
additional option `dist` for command `-numa` to allow user set vNUMA
distance by QEMU command.
With this patch, when a user wants to create a guest that contains
several vNUMA nodes and also wants to set distance among those nodes,
the QEMU command would like:
```
-numa node,nodeid=0,cpus=0 \
-numa node,nodeid=1,cpus=1 \
-numa node,nodeid=2,cpus=2 \
-numa node,nodeid=3,cpus=3 \
-numa dist,src=0,dst=1,val=21 \
-numa dist,src=0,dst=2,val=31 \
-numa dist,src=0,dst=3,val=41 \
-numa dist,src=1,dst=2,val=21 \
-numa dist,src=1,dst=3,val=31 \
-numa dist,src=2,dst=3,val=21 \
```
Signed-off-by: He Chen <he.chen@linux.intel.com>
Message-Id: <1493260558-20728-1-git-send-email-he.chen@linux.intel.com>
Reviewed-by: Igor Mammedov <imammedo@redhat.com>
Reviewed-by: Andrew Jones <drjones@redhat.com>
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
2017-04-27 05:35:58 +03:00
|
|
|
if (numa_info[src].distance[dst] == 0) {
|
|
|
|
if (src == dst) {
|
|
|
|
numa_info[src].distance[dst] = NUMA_DISTANCE_MIN;
|
|
|
|
} else {
|
|
|
|
numa_info[src].distance[dst] = numa_info[dst].distance[src];
|
|
|
|
}
|
|
|
|
}
|
2015-02-09 22:32:04 +03:00
|
|
|
}
|
|
|
|
}
|
numa: Allow setting NUMA distance for different NUMA nodes
This patch is going to add SLIT table support in QEMU, and provides
additional option `dist` for command `-numa` to allow user set vNUMA
distance by QEMU command.
With this patch, when a user wants to create a guest that contains
several vNUMA nodes and also wants to set distance among those nodes,
the QEMU command would like:
```
-numa node,nodeid=0,cpus=0 \
-numa node,nodeid=1,cpus=1 \
-numa node,nodeid=2,cpus=2 \
-numa node,nodeid=3,cpus=3 \
-numa dist,src=0,dst=1,val=21 \
-numa dist,src=0,dst=2,val=31 \
-numa dist,src=0,dst=3,val=41 \
-numa dist,src=1,dst=2,val=21 \
-numa dist,src=1,dst=3,val=31 \
-numa dist,src=2,dst=3,val=21 \
```
Signed-off-by: He Chen <he.chen@linux.intel.com>
Message-Id: <1493260558-20728-1-git-send-email-he.chen@linux.intel.com>
Reviewed-by: Igor Mammedov <imammedo@redhat.com>
Reviewed-by: Andrew Jones <drjones@redhat.com>
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
2017-04-27 05:35:58 +03:00
|
|
|
}
|
numa: Print warning if no node is assigned to a CPU
We need all possible CPUs (including hotplug ones) to be present in the
SRAT when QEMU starts. QEMU already does that correctly today, the only
problem is that when a CPU is omitted from the NUMA configuration, it is
silently assigned to node 0.
Check if all CPUs up to max_cpus are present in the NUMA configuration
and warn about missing CPUs.
Make it just a warning, to allow management software to be updated if
necessary. In the future we may make it a fatal error instead.
Command-line examples:
* Correct, no warning:
$ qemu-system-x86_64 -smp 2,maxcpus=4
$ qemu-system-x86_64 -smp 2,maxcpus=4 -numa node,cpus=0-3
* Incomplete, with warnings:
$ qemu-system-x86_64 -smp 2,maxcpus=4 -numa node,cpus=0
qemu-system-x86_64: warning: CPU(s) not present in any NUMA nodes: 1 2 3
qemu-system-x86_64: warning: All CPU(s) up to maxcpus should be described in NUMA config
$ qemu-system-x86_64 -smp 2,maxcpus=4 -numa node,cpus=0-2
qemu-system-x86_64: warning: CPU(s) not present in any NUMA nodes: 3
qemu-system-x86_64: warning: All CPU(s) up to maxcpus should be described in NUMA config
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
---
v1 -> v2: (no changes)
v2 -> v3:
* Use enumerate_cpus() and error_report() for error message
* Simplify logic using bitmap_full()
v3 -> v4:
* Clarify error message, mention that all CPUs up to
maxcpus need to be described in NUMA config
v4 -> v5:
* Commit log update, to make problem description clearer
2015-02-09 22:35:04 +03:00
|
|
|
|
2020-02-19 19:08:39 +03:00
|
|
|
static void numa_init_memdev_container(MachineState *ms, MemoryRegion *ram)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
uint64_t addr = 0;
|
|
|
|
|
|
|
|
for (i = 0; i < ms->numa_state->num_nodes; i++) {
|
|
|
|
uint64_t size = ms->numa_state->nodes[i].node_mem;
|
|
|
|
HostMemoryBackend *backend = ms->numa_state->nodes[i].node_memdev;
|
|
|
|
if (!backend) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
MemoryRegion *seg = machine_consume_memdev(ms, backend);
|
|
|
|
memory_region_add_subregion(ram, addr, seg);
|
|
|
|
addr += size;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-05-04 11:37:39 +03:00
|
|
|
void numa_complete_configuration(MachineState *ms)
|
2014-05-14 13:43:05 +04:00
|
|
|
{
|
2014-06-27 01:33:20 +04:00
|
|
|
int i;
|
2017-05-10 14:29:45 +03:00
|
|
|
MachineClass *mc = MACHINE_GET_CLASS(ms);
|
2019-08-09 09:57:24 +03:00
|
|
|
NodeInfo *numa_info = ms->numa_state->nodes;
|
2016-11-18 14:02:54 +03:00
|
|
|
|
2017-11-14 05:34:01 +03:00
|
|
|
/*
|
2020-06-26 10:22:48 +03:00
|
|
|
* If memory hotplug is enabled (slot > 0) or memory devices are enabled
|
2020-10-28 13:24:22 +03:00
|
|
|
* (ms->maxram_size > ms->ram_size) but without '-numa' options explicitly on
|
2020-06-26 10:22:48 +03:00
|
|
|
* CLI, guests will break.
|
2017-11-14 05:34:01 +03:00
|
|
|
*
|
|
|
|
* Windows: won't enable memory hotplug without SRAT table at all
|
|
|
|
*
|
|
|
|
* Linux: if QEMU is started with initial memory all below 4Gb
|
|
|
|
* and no SRAT table present, guest kernel will use nommu DMA ops,
|
|
|
|
* which breaks 32bit hw drivers when memory is hotplugged and
|
|
|
|
* guest tries to use it with that drivers.
|
|
|
|
*
|
|
|
|
* Enable NUMA implicitly by adding a new NUMA node automatically.
|
2019-09-05 11:32:38 +03:00
|
|
|
*
|
|
|
|
* Or if MachineClass::auto_enable_numa is true and no NUMA nodes,
|
|
|
|
* assume there is just one node with whole RAM.
|
2017-11-14 05:34:01 +03:00
|
|
|
*/
|
2019-09-05 11:32:38 +03:00
|
|
|
if (ms->numa_state->num_nodes == 0 &&
|
2020-06-26 10:22:48 +03:00
|
|
|
((ms->ram_slots && mc->auto_enable_numa_with_memhp) ||
|
|
|
|
(ms->maxram_size > ms->ram_size && mc->auto_enable_numa_with_memdev) ||
|
|
|
|
mc->auto_enable_numa)) {
|
2017-11-14 05:34:01 +03:00
|
|
|
NumaNodeOptions node = { };
|
2018-10-17 11:26:39 +03:00
|
|
|
parse_numa_node(ms, &node, &error_abort);
|
2020-10-28 13:24:22 +03:00
|
|
|
numa_info[0].node_mem = ms->ram_size;
|
2017-11-14 05:34:01 +03:00
|
|
|
}
|
|
|
|
|
2014-06-27 01:33:20 +04:00
|
|
|
assert(max_numa_nodeid <= MAX_NODES);
|
|
|
|
|
|
|
|
/* No support for sparse NUMA node IDs yet: */
|
|
|
|
for (i = max_numa_nodeid - 1; i >= 0; i--) {
|
|
|
|
/* Report large node IDs first, to make mistakes easier to spot */
|
|
|
|
if (!numa_info[i].present) {
|
|
|
|
error_report("numa: Node ID missing: %d", i);
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* This must be always true if all nodes are present: */
|
2019-08-09 09:57:22 +03:00
|
|
|
assert(ms->numa_state->num_nodes == max_numa_nodeid);
|
2014-06-27 01:33:20 +04:00
|
|
|
|
2019-08-09 09:57:22 +03:00
|
|
|
if (ms->numa_state->num_nodes > 0) {
|
2014-05-14 13:43:06 +04:00
|
|
|
uint64_t numa_total;
|
2014-05-14 13:43:05 +04:00
|
|
|
|
2014-05-14 13:43:06 +04:00
|
|
|
numa_total = 0;
|
2019-08-09 09:57:22 +03:00
|
|
|
for (i = 0; i < ms->numa_state->num_nodes; i++) {
|
2014-05-14 13:43:07 +04:00
|
|
|
numa_total += numa_info[i].node_mem;
|
2014-05-14 13:43:06 +04:00
|
|
|
}
|
2020-10-28 13:24:22 +03:00
|
|
|
if (numa_total != ms->ram_size) {
|
2014-08-04 12:16:09 +04:00
|
|
|
error_report("total memory for NUMA nodes (0x%" PRIx64 ")"
|
|
|
|
" should equal RAM size (0x" RAM_ADDR_FMT ")",
|
2020-10-28 13:24:22 +03:00
|
|
|
numa_total, ms->ram_size);
|
2014-05-14 13:43:06 +04:00
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
2020-02-19 19:08:39 +03:00
|
|
|
if (!numa_uses_legacy_mem() && mc->default_ram_id) {
|
2020-05-11 17:11:03 +03:00
|
|
|
if (ms->ram_memdev_id) {
|
|
|
|
error_report("'-machine memory-backend' and '-numa memdev'"
|
|
|
|
" properties are mutually exclusive");
|
|
|
|
exit(1);
|
|
|
|
}
|
2020-02-19 19:08:39 +03:00
|
|
|
ms->ram = g_new(MemoryRegion, 1);
|
|
|
|
memory_region_init(ms->ram, OBJECT(ms), mc->default_ram_id,
|
2020-10-28 13:24:22 +03:00
|
|
|
ms->ram_size);
|
2020-02-19 19:08:39 +03:00
|
|
|
numa_init_memdev_container(ms, ms->ram);
|
|
|
|
}
|
numa: Allow setting NUMA distance for different NUMA nodes
This patch is going to add SLIT table support in QEMU, and provides
additional option `dist` for command `-numa` to allow user set vNUMA
distance by QEMU command.
With this patch, when a user wants to create a guest that contains
several vNUMA nodes and also wants to set distance among those nodes,
the QEMU command would like:
```
-numa node,nodeid=0,cpus=0 \
-numa node,nodeid=1,cpus=1 \
-numa node,nodeid=2,cpus=2 \
-numa node,nodeid=3,cpus=3 \
-numa dist,src=0,dst=1,val=21 \
-numa dist,src=0,dst=2,val=31 \
-numa dist,src=0,dst=3,val=41 \
-numa dist,src=1,dst=2,val=21 \
-numa dist,src=1,dst=3,val=31 \
-numa dist,src=2,dst=3,val=21 \
```
Signed-off-by: He Chen <he.chen@linux.intel.com>
Message-Id: <1493260558-20728-1-git-send-email-he.chen@linux.intel.com>
Reviewed-by: Igor Mammedov <imammedo@redhat.com>
Reviewed-by: Andrew Jones <drjones@redhat.com>
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
2017-04-27 05:35:58 +03:00
|
|
|
/* QEMU needs at least all unique node pair distances to build
|
|
|
|
* the whole NUMA distance table. QEMU treats the distance table
|
|
|
|
* as symmetric by default, i.e. distance A->B == distance B->A.
|
|
|
|
* Thus, QEMU is able to complete the distance table
|
|
|
|
* initialization even though only distance A->B is provided and
|
|
|
|
* distance B->A is not. QEMU knows the distance of a node to
|
|
|
|
* itself is always 10, so A->A distances may be omitted. When
|
|
|
|
* the distances of two nodes of a pair differ, i.e. distance
|
|
|
|
* A->B != distance B->A, then that means the distance table is
|
|
|
|
* asymmetric. In this case, the distances for both directions
|
|
|
|
* of all node pairs are required.
|
|
|
|
*/
|
2019-08-09 09:57:23 +03:00
|
|
|
if (ms->numa_state->have_numa_distance) {
|
numa: Allow setting NUMA distance for different NUMA nodes
This patch is going to add SLIT table support in QEMU, and provides
additional option `dist` for command `-numa` to allow user set vNUMA
distance by QEMU command.
With this patch, when a user wants to create a guest that contains
several vNUMA nodes and also wants to set distance among those nodes,
the QEMU command would like:
```
-numa node,nodeid=0,cpus=0 \
-numa node,nodeid=1,cpus=1 \
-numa node,nodeid=2,cpus=2 \
-numa node,nodeid=3,cpus=3 \
-numa dist,src=0,dst=1,val=21 \
-numa dist,src=0,dst=2,val=31 \
-numa dist,src=0,dst=3,val=41 \
-numa dist,src=1,dst=2,val=21 \
-numa dist,src=1,dst=3,val=31 \
-numa dist,src=2,dst=3,val=21 \
```
Signed-off-by: He Chen <he.chen@linux.intel.com>
Message-Id: <1493260558-20728-1-git-send-email-he.chen@linux.intel.com>
Reviewed-by: Igor Mammedov <imammedo@redhat.com>
Reviewed-by: Andrew Jones <drjones@redhat.com>
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
2017-04-27 05:35:58 +03:00
|
|
|
/* Validate enough NUMA distance information was provided. */
|
2019-08-09 09:57:22 +03:00
|
|
|
validate_numa_distance(ms);
|
2014-05-14 13:43:05 +04:00
|
|
|
|
numa: Allow setting NUMA distance for different NUMA nodes
This patch is going to add SLIT table support in QEMU, and provides
additional option `dist` for command `-numa` to allow user set vNUMA
distance by QEMU command.
With this patch, when a user wants to create a guest that contains
several vNUMA nodes and also wants to set distance among those nodes,
the QEMU command would like:
```
-numa node,nodeid=0,cpus=0 \
-numa node,nodeid=1,cpus=1 \
-numa node,nodeid=2,cpus=2 \
-numa node,nodeid=3,cpus=3 \
-numa dist,src=0,dst=1,val=21 \
-numa dist,src=0,dst=2,val=31 \
-numa dist,src=0,dst=3,val=41 \
-numa dist,src=1,dst=2,val=21 \
-numa dist,src=1,dst=3,val=31 \
-numa dist,src=2,dst=3,val=21 \
```
Signed-off-by: He Chen <he.chen@linux.intel.com>
Message-Id: <1493260558-20728-1-git-send-email-he.chen@linux.intel.com>
Reviewed-by: Igor Mammedov <imammedo@redhat.com>
Reviewed-by: Andrew Jones <drjones@redhat.com>
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
2017-04-27 05:35:58 +03:00
|
|
|
/* Validation succeeded, now fill in any missing distances. */
|
2019-08-09 09:57:22 +03:00
|
|
|
complete_init_numa_distance(ms);
|
2014-05-14 13:43:05 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2014-05-14 13:43:15 +04:00
|
|
|
|
2018-05-04 11:37:39 +03:00
|
|
|
void parse_numa_opts(MachineState *ms)
|
|
|
|
{
|
2018-10-17 11:26:52 +03:00
|
|
|
qemu_opts_foreach(qemu_find_opts("numa"), parse_numa, ms, &error_fatal);
|
2018-05-04 11:37:39 +03:00
|
|
|
}
|
|
|
|
|
2017-05-30 19:23:56 +03:00
|
|
|
void numa_cpu_pre_plug(const CPUArchId *slot, DeviceState *dev, Error **errp)
|
|
|
|
{
|
|
|
|
int node_id = object_property_get_int(OBJECT(dev), "node-id", &error_abort);
|
|
|
|
|
|
|
|
if (node_id == CPU_UNSET_NUMA_NODE_ID) {
|
|
|
|
/* due to bug in libvirt, it doesn't pass node-id from props on
|
|
|
|
* device_add as expected, so we have to fix it up here */
|
2017-05-30 19:23:58 +03:00
|
|
|
if (slot->props.has_node_id) {
|
qom: Put name parameter before value / visitor parameter
The object_property_set_FOO() setters take property name and value in
an unusual order:
void object_property_set_FOO(Object *obj, FOO_TYPE value,
const char *name, Error **errp)
Having to pass value before name feels grating. Swap them.
Same for object_property_set(), object_property_get(), and
object_property_parse().
Convert callers with this Coccinelle script:
@@
identifier fun = {
object_property_get, object_property_parse, object_property_set_str,
object_property_set_link, object_property_set_bool,
object_property_set_int, object_property_set_uint, object_property_set,
object_property_set_qobject
};
expression obj, v, name, errp;
@@
- fun(obj, v, name, errp)
+ fun(obj, name, v, errp)
Chokes on hw/arm/musicpal.c's lcd_refresh() with the unhelpful error
message "no position information". Convert that one manually.
Fails to convert hw/arm/armsse.c, because Coccinelle gets confused by
ARMSSE being used both as typedef and function-like macro there.
Convert manually.
Fails to convert hw/rx/rx-gdbsim.c, because Coccinelle gets confused
by RXCPU being used both as typedef and function-like macro there.
Convert manually. The other files using RXCPU that way don't need
conversion.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Message-Id: <20200707160613.848843-27-armbru@redhat.com>
[Straightforwad conflict with commit 2336172d9b "audio: set default
value for pcspk.iobase property" resolved]
2020-07-07 19:05:54 +03:00
|
|
|
object_property_set_int(OBJECT(dev), "node-id",
|
|
|
|
slot->props.node_id, errp);
|
2017-05-30 19:23:58 +03:00
|
|
|
}
|
|
|
|
} else if (node_id != slot->props.node_id) {
|
numa: improve cpu hotplug error message with a wrong node-id
On pseries, core-ids are strongly binded to a node-id by the command
line option. If an user tries to add a CPU to the wrong node, he has
an error but it is not really helpful:
qemu-system-ppc64 ... -smp 1,maxcpus=64,cores=1,threads=1,sockets=1 \
-numa node,nodeid=0 -numa node,nodeid=1 ...
(qemu) device_add power9_v2.0-spapr-cpu-core,core-id=30,node-id=1
Error: node-id=1 must match numa node specified with -numa option
This patch improves this error message by giving to the user the good
node-id to use with the core-id he's providing
Error: invalid node-id, must be 0
Signed-off-by: Laurent Vivier <lvivier@redhat.com>
Message-Id: <20190529160747.778-1-lvivier@redhat.com>
Reviewed-by: Igor Mammedov <imammedo@redhat.com>
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
2019-05-29 19:07:47 +03:00
|
|
|
error_setg(errp, "invalid node-id, must be %"PRId64,
|
|
|
|
slot->props.node_id);
|
2017-05-30 19:23:56 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-08-29 18:30:20 +03:00
|
|
|
static void numa_stat_memory_devices(NumaNodeMem node_mem[])
|
2014-11-04 14:49:30 +03:00
|
|
|
{
|
2018-04-23 19:51:16 +03:00
|
|
|
MemoryDeviceInfoList *info_list = qmp_memory_device_list();
|
2014-11-04 14:49:30 +03:00
|
|
|
MemoryDeviceInfoList *info;
|
2017-08-29 18:30:20 +03:00
|
|
|
PCDIMMDeviceInfo *pcdimm_info;
|
2019-06-19 12:49:06 +03:00
|
|
|
VirtioPMEMDeviceInfo *vpi;
|
2020-06-26 10:22:41 +03:00
|
|
|
VirtioMEMDeviceInfo *vmi;
|
2021-11-10 15:29:03 +03:00
|
|
|
SgxEPCDeviceInfo *se;
|
2014-11-04 14:49:30 +03:00
|
|
|
|
|
|
|
for (info = info_list; info; info = info->next) {
|
|
|
|
MemoryDeviceInfo *value = info->value;
|
|
|
|
|
|
|
|
if (value) {
|
2015-10-27 01:34:59 +03:00
|
|
|
switch (value->type) {
|
2018-03-11 06:02:12 +03:00
|
|
|
case MEMORY_DEVICE_INFO_KIND_DIMM:
|
|
|
|
case MEMORY_DEVICE_INFO_KIND_NVDIMM:
|
2019-06-19 12:49:06 +03:00
|
|
|
pcdimm_info = value->type == MEMORY_DEVICE_INFO_KIND_DIMM ?
|
|
|
|
value->u.dimm.data : value->u.nvdimm.data;
|
2017-08-29 18:30:20 +03:00
|
|
|
node_mem[pcdimm_info->node].node_mem += pcdimm_info->size;
|
numa: report all DIMM/NVDIMMs as plugged memory
Right now, there is some inconsistency between hotplugged and
coldplugged memory. DIMMs added via "-device" result in different stats
than DIMMs added using "device_add".
E.g.
[...]
-numa node,nodeid=0,cpus=0-1 -numa node,nodeid=1,cpus=2-3 \
-m 4G,maxmem=20G,slots=2 \
-object memory-backend-ram,id=mem0,size=8G \
-device pc-dimm,id=dimm0,memdev=mem0 \
-object memory-backend-ram,id=mem1,size=8G \
-device nvdimm,id=dimm1,memdev=mem1,node=1
Results in NUMA info
(qemu) info numa
info numa
2 nodes
node 0 cpus: 0 1
node 0 size: 10240 MB
node 0 plugged: 0 MB
node 1 cpus: 2 3
node 1 size: 10240 MB
node 1 plugged: 0 MB
But in memory size summary:
(qemu) info memory_size_summary
info memory_size_summary
base memory: 4294967296
plugged memory: 17179869184
Make this consistent by reporting all hot and coldplugged
memory a.k.a. DIMM and NVDIMM as "plugged".
Fixes: 31959e82fb0 ("hmp: extend "info numa" with hotplugged memory information")
Signed-off-by: David Hildenbrand <david@redhat.com>
Message-Id: <20180622144045.737-1-david@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2018-06-22 17:40:45 +03:00
|
|
|
node_mem[pcdimm_info->node].node_plugged_mem +=
|
|
|
|
pcdimm_info->size;
|
2019-06-19 12:49:06 +03:00
|
|
|
break;
|
|
|
|
case MEMORY_DEVICE_INFO_KIND_VIRTIO_PMEM:
|
|
|
|
vpi = value->u.virtio_pmem.data;
|
|
|
|
/* TODO: once we support numa, assign to right node */
|
|
|
|
node_mem[0].node_mem += vpi->size;
|
|
|
|
node_mem[0].node_plugged_mem += vpi->size;
|
|
|
|
break;
|
2020-06-26 10:22:41 +03:00
|
|
|
case MEMORY_DEVICE_INFO_KIND_VIRTIO_MEM:
|
|
|
|
vmi = value->u.virtio_mem.data;
|
|
|
|
node_mem[vmi->node].node_mem += vmi->size;
|
|
|
|
node_mem[vmi->node].node_plugged_mem += vmi->size;
|
|
|
|
break;
|
2021-11-10 15:29:03 +03:00
|
|
|
case MEMORY_DEVICE_INFO_KIND_SGX_EPC:
|
|
|
|
se = value->u.sgx_epc.data;
|
numa: Enable numa for SGX EPC sections
The basic SGX did not enable numa for SGX EPC sections, which
result in all EPC sections located in numa node 0. This patch
enable SGX numa function in the guest and the EPC section can
work with RAM as one numa node.
The Guest kernel related log:
[ 0.009981] ACPI: SRAT: Node 0 PXM 0 [mem 0x180000000-0x183ffffff]
[ 0.009982] ACPI: SRAT: Node 1 PXM 1 [mem 0x184000000-0x185bfffff]
The SRAT table can normally show SGX EPC sections menory info in different
numa nodes.
The SGX EPC numa related command:
......
-m 4G,maxmem=20G \
-smp sockets=2,cores=2 \
-cpu host,+sgx-provisionkey \
-object memory-backend-ram,size=2G,host-nodes=0,policy=bind,id=node0 \
-object memory-backend-epc,id=mem0,size=64M,prealloc=on,host-nodes=0,policy=bind \
-numa node,nodeid=0,cpus=0-1,memdev=node0 \
-object memory-backend-ram,size=2G,host-nodes=1,policy=bind,id=node1 \
-object memory-backend-epc,id=mem1,size=28M,prealloc=on,host-nodes=1,policy=bind \
-numa node,nodeid=1,cpus=2-3,memdev=node1 \
-M sgx-epc.0.memdev=mem0,sgx-epc.0.node=0,sgx-epc.1.memdev=mem1,sgx-epc.1.node=1 \
......
Signed-off-by: Yang Zhong <yang.zhong@intel.com>
Message-Id: <20211101162009.62161-2-yang.zhong@intel.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2021-11-01 19:20:05 +03:00
|
|
|
node_mem[se->node].node_mem += se->size;
|
|
|
|
node_mem[se->node].node_plugged_mem = 0;
|
2021-11-10 15:29:03 +03:00
|
|
|
break;
|
2019-06-19 12:49:06 +03:00
|
|
|
default:
|
|
|
|
g_assert_not_reached();
|
2014-11-04 14:49:30 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
qapi_free_MemoryDeviceInfoList(info_list);
|
|
|
|
}
|
|
|
|
|
2019-08-09 09:57:22 +03:00
|
|
|
void query_numa_node_mem(NumaNodeMem node_mem[], MachineState *ms)
|
2014-11-04 14:49:30 +03:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2019-08-09 09:57:22 +03:00
|
|
|
if (ms->numa_state == NULL || ms->numa_state->num_nodes <= 0) {
|
2014-11-04 14:49:30 +03:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
numa_stat_memory_devices(node_mem);
|
2019-08-09 09:57:22 +03:00
|
|
|
for (i = 0; i < ms->numa_state->num_nodes; i++) {
|
2019-08-09 09:57:24 +03:00
|
|
|
node_mem[i].node_mem += ms->numa_state->nodes[i].node_mem;
|
2014-11-04 14:49:30 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-29 14:26:59 +03:00
|
|
|
static int ram_block_notify_add_single(RAMBlock *rb, void *opaque)
|
|
|
|
{
|
|
|
|
const ram_addr_t max_size = qemu_ram_get_max_length(rb);
|
2021-04-29 14:27:00 +03:00
|
|
|
const ram_addr_t size = qemu_ram_get_used_length(rb);
|
2021-04-29 14:26:59 +03:00
|
|
|
void *host = qemu_ram_get_host_addr(rb);
|
|
|
|
RAMBlockNotifier *notifier = opaque;
|
|
|
|
|
|
|
|
if (host) {
|
2021-04-29 14:27:00 +03:00
|
|
|
notifier->ram_block_added(notifier, host, size, max_size);
|
2021-04-29 14:26:59 +03:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-12-20 19:31:36 +03:00
|
|
|
void ram_block_notifier_add(RAMBlockNotifier *n)
|
|
|
|
{
|
|
|
|
QLIST_INSERT_HEAD(&ram_list.ramblock_notifiers, n, next);
|
2021-04-29 14:27:01 +03:00
|
|
|
|
2021-04-29 14:26:59 +03:00
|
|
|
/* Notify about all existing ram blocks. */
|
2021-04-29 14:27:01 +03:00
|
|
|
if (n->ram_block_added) {
|
|
|
|
qemu_ram_foreach_block(ram_block_notify_add_single, n);
|
|
|
|
}
|
2016-12-20 19:31:36 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
void ram_block_notifier_remove(RAMBlockNotifier *n)
|
|
|
|
{
|
|
|
|
QLIST_REMOVE(n, next);
|
|
|
|
}
|
|
|
|
|
2021-04-29 14:27:00 +03:00
|
|
|
void ram_block_notify_add(void *host, size_t size, size_t max_size)
|
2016-12-20 19:31:36 +03:00
|
|
|
{
|
|
|
|
RAMBlockNotifier *notifier;
|
|
|
|
|
|
|
|
QLIST_FOREACH(notifier, &ram_list.ramblock_notifiers, next) {
|
2021-04-29 14:27:01 +03:00
|
|
|
if (notifier->ram_block_added) {
|
|
|
|
notifier->ram_block_added(notifier, host, size, max_size);
|
|
|
|
}
|
2016-12-20 19:31:36 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-29 14:27:00 +03:00
|
|
|
void ram_block_notify_remove(void *host, size_t size, size_t max_size)
|
2016-12-20 19:31:36 +03:00
|
|
|
{
|
|
|
|
RAMBlockNotifier *notifier;
|
|
|
|
|
|
|
|
QLIST_FOREACH(notifier, &ram_list.ramblock_notifiers, next) {
|
2021-04-29 14:27:01 +03:00
|
|
|
if (notifier->ram_block_removed) {
|
|
|
|
notifier->ram_block_removed(notifier, host, size, max_size);
|
|
|
|
}
|
2021-04-29 14:27:00 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void ram_block_notify_resize(void *host, size_t old_size, size_t new_size)
|
|
|
|
{
|
|
|
|
RAMBlockNotifier *notifier;
|
|
|
|
|
|
|
|
QLIST_FOREACH(notifier, &ram_list.ramblock_notifiers, next) {
|
|
|
|
if (notifier->ram_block_resized) {
|
|
|
|
notifier->ram_block_resized(notifier, host, old_size, new_size);
|
|
|
|
}
|
2016-12-20 19:31:36 +03:00
|
|
|
}
|
|
|
|
}
|