target-arm: Add arm_boot_info secure_boot control

[qemu.git] / numa.c

diff --git a/numa.c b/numa.c
index 8af9c916ac74042894faef32b370c699fbc56fe9..afd28666b36934b9960d5a42240b1dddf9f05c29 100644 (file)
--- a/numa.c
+++ b/numa.c
@@ -34,6 +34,8 @@
 #include "qapi/qmp/qerror.h"
 #include "hw/boards.h"
 #include "sysemu/hostmem.h"
 #include "qapi/qmp/qerror.h"
 #include "hw/boards.h"
 #include "sysemu/hostmem.h"

+#include "qmp-commands.h"
+#include "hw/mem/pc-dimm.h"

 
 QemuOptsList qemu_numa_opts = {
     .name = "numa",
 
 QemuOptsList qemu_numa_opts = {
     .name = "numa",


@@ -61,6 +63,11 @@ static void numa_node_parse(NumaNodeOptions *node, QemuOpts *opts, Error **errp)
         return;
     }
 
         return;
     }
 

+    if (numa_info[nodenr].present) {
+        error_setg(errp, "Duplicate NUMA nodeid: %" PRIu16, nodenr);
+        return;
+    }
+

     for (cpus = node->cpus; cpus; cpus = cpus->next) {
         if (cpus->value > MAX_CPUMASK_BITS) {
             error_setg(errp, "CPU number %" PRIu16 " is bigger than %d",
     for (cpus = node->cpus; cpus; cpus = cpus->next) {
         if (cpus->value > MAX_CPUMASK_BITS) {
             error_setg(errp, "CPU number %" PRIu16 " is bigger than %d",


@@ -105,6 +112,8 @@ static void numa_node_parse(NumaNodeOptions *node, QemuOpts *opts, Error **errp)
         numa_info[nodenr].node_mem = object_property_get_int(o, "size", NULL);
         numa_info[nodenr].node_memdev = MEMORY_BACKEND(o);
     }
         numa_info[nodenr].node_mem = object_property_get_int(o, "size", NULL);
         numa_info[nodenr].node_memdev = MEMORY_BACKEND(o);
     }

+    numa_info[nodenr].present = true;
+    max_numa_nodeid = MAX(max_numa_nodeid, nodenr + 1);

 }
 
 int numa_init_func(QemuOpts *opts, void *opaque)
 }
 
 int numa_init_func(QemuOpts *opts, void *opaque)


@@ -152,15 +161,30 @@ error:
 
 void set_numa_nodes(void)
 {
 
 void set_numa_nodes(void)
 {

+    int i;
+
+    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: */
+    assert(nb_numa_nodes == max_numa_nodeid);
+

     if (nb_numa_nodes > 0) {
         uint64_t numa_total;
     if (nb_numa_nodes > 0) {
         uint64_t numa_total;

-        int i;

 
         if (nb_numa_nodes > MAX_NODES) {
             nb_numa_nodes = MAX_NODES;
         }
 
 
         if (nb_numa_nodes > MAX_NODES) {
             nb_numa_nodes = MAX_NODES;
         }
 

-        /* If no memory size if given for any node, assume the default case
+        /* If no memory size is given for any node, assume the default case

          * and distribute the available memory equally across all nodes
          */
         for (i = 0; i < nb_numa_nodes; i++) {
          * and distribute the available memory equally across all nodes
          */
         for (i = 0; i < nb_numa_nodes; i++) {


@@ -171,7 +195,7 @@ void set_numa_nodes(void)
         if (i == nb_numa_nodes) {
             uint64_t usedmem = 0;
 
         if (i == nb_numa_nodes) {
             uint64_t usedmem = 0;
 

-            /* On Linux, the each node's border has to be 8MB aligned,
+            /* On Linux, each node's border has to be 8MB aligned,

              * the final node gets the rest.
              */
             for (i = 0; i < nb_numa_nodes - 1; i++) {
              * the final node gets the rest.
              */
             for (i = 0; i < nb_numa_nodes - 1; i++) {


@@ -187,8 +211,8 @@ void set_numa_nodes(void)
             numa_total += numa_info[i].node_mem;
         }
         if (numa_total != ram_size) {
             numa_total += numa_info[i].node_mem;
         }
         if (numa_total != ram_size) {

-            error_report("total memory for NUMA nodes (%" PRIu64 ")"
-                         " should equal RAM size (" RAM_ADDR_FMT ")",
+            error_report("total memory for NUMA nodes (0x%" PRIx64 ")"
+                         " should equal RAM size (0x" RAM_ADDR_FMT ")",

                          numa_total, ram_size);
             exit(1);
         }
                          numa_total, ram_size);
             exit(1);
         }


@@ -231,23 +255,23 @@ static void allocate_system_memory_nonnuma(MemoryRegion *mr, Object *owner,
     if (mem_path) {
 #ifdef __linux__
         Error *err = NULL;
     if (mem_path) {
 #ifdef __linux__
         Error *err = NULL;

-        memory_region_init_ram_from_file(mr, owner, name, ram_size,
+        memory_region_init_ram_from_file(mr, owner, name, ram_size, false,

                                          mem_path, &err);
 
         /* Legacy behavior: if allocation failed, fall back to
          * regular RAM allocation.
          */
                                          mem_path, &err);
 
         /* Legacy behavior: if allocation failed, fall back to
          * regular RAM allocation.
          */

-        if (!memory_region_size(mr)) {
+        if (err) {

             qerror_report_err(err);
             error_free(err);
             qerror_report_err(err);
             error_free(err);

-            memory_region_init_ram(mr, owner, name, ram_size);
+            memory_region_init_ram(mr, owner, name, ram_size, &error_abort);

         }
 #else
         fprintf(stderr, "-mem-path not supported on this host\n");
         exit(1);
 #endif
     } else {
         }
 #else
         fprintf(stderr, "-mem-path not supported on this host\n");
         exit(1);
 #endif
     } else {

-        memory_region_init_ram(mr, owner, name, ram_size);
+        memory_region_init_ram(mr, owner, name, ram_size, &error_abort);

     }
     vmstate_register_ram_global(mr);
 }
     }
     vmstate_register_ram_global(mr);
 }


@@ -278,8 +302,135 @@ void memory_region_allocate_system_memory(MemoryRegion *mr, Object *owner,
             exit(1);
         }
 
             exit(1);
         }
 

+        if (memory_region_is_mapped(seg)) {
+            char *path = object_get_canonical_path_component(OBJECT(backend));
+            error_report("memory backend %s is used multiple times. Each "
+                         "-numa option must use a different memdev value.",
+                         path);
+            exit(1);
+        }
+

         memory_region_add_subregion(mr, addr, seg);
         vmstate_register_ram_global(seg);
         addr += size;
     }
 }
         memory_region_add_subregion(mr, addr, seg);
         vmstate_register_ram_global(seg);
         addr += size;
     }
 }

+
+static void numa_stat_memory_devices(uint64_t node_mem[])
+{
+    MemoryDeviceInfoList *info_list = NULL;
+    MemoryDeviceInfoList **prev = &info_list;
+    MemoryDeviceInfoList *info;
+
+    qmp_pc_dimm_device_list(qdev_get_machine(), &prev);
+    for (info = info_list; info; info = info->next) {
+        MemoryDeviceInfo *value = info->value;
+
+        if (value) {
+            switch (value->kind) {
+            case MEMORY_DEVICE_INFO_KIND_DIMM:
+                node_mem[value->dimm->node] += value->dimm->size;
+                break;
+            default:
+                break;
+            }
+        }
+    }
+    qapi_free_MemoryDeviceInfoList(info_list);
+}
+
+void query_numa_node_mem(uint64_t node_mem[])
+{
+    int i;
+
+    if (nb_numa_nodes <= 0) {
+        return;
+    }
+
+    numa_stat_memory_devices(node_mem);
+    for (i = 0; i < nb_numa_nodes; i++) {
+        node_mem[i] += numa_info[i].node_mem;
+    }
+}
+
+static int query_memdev(Object *obj, void *opaque)
+{
+    MemdevList **list = opaque;
+    MemdevList *m = NULL;
+    Error *err = NULL;
+
+    if (object_dynamic_cast(obj, TYPE_MEMORY_BACKEND)) {
+        m = g_malloc0(sizeof(*m));
+
+        m->value = g_malloc0(sizeof(*m->value));
+
+        m->value->size = object_property_get_int(obj, "size",
+                                                 &err);
+        if (err) {
+            goto error;
+        }
+
+        m->value->merge = object_property_get_bool(obj, "merge",
+                                                   &err);
+        if (err) {
+            goto error;
+        }
+
+        m->value->dump = object_property_get_bool(obj, "dump",
+                                                  &err);
+        if (err) {
+            goto error;
+        }
+
+        m->value->prealloc = object_property_get_bool(obj,
+                                                      "prealloc", &err);
+        if (err) {
+            goto error;
+        }
+
+        m->value->policy = object_property_get_enum(obj,
+                                                    "policy",
+                                                    HostMemPolicy_lookup,
+                                                    &err);
+        if (err) {
+            goto error;
+        }
+
+        object_property_get_uint16List(obj, "host-nodes",
+                                       &m->value->host_nodes, &err);
+        if (err) {
+            goto error;
+        }
+
+        m->next = *list;
+        *list = m;
+    }
+
+    return 0;
+error:
+    g_free(m->value);
+    g_free(m);
+
+    return -1;
+}
+
+MemdevList *qmp_query_memdev(Error **errp)
+{
+    Object *obj;
+    MemdevList *list = NULL;
+
+    obj = object_resolve_path("/objects", NULL);
+    if (obj == NULL) {
+        return NULL;
+    }
+
+    if (object_child_foreach(obj, query_memdev, &list) != 0) {
+        goto error;
+    }
+
+    return list;
+
+error:
+    qapi_free_MemdevList(list);
+    return NULL;
+}