target-arm: Set CPU has_el3 prop during virt init

[qemu.git] / memory.c

diff --git a/memory.c b/memory.c
index 8970081336cd30671ee4a34ba78b9ce84d338a88..15cf9ebd8423b0b04862df77772f147b085d54fd 100644 (file)
--- a/memory.c
+++ b/memory.c
@@ -16,6 +16,7 @@
 #include "exec/memory.h"
 #include "exec/address-spaces.h"
 #include "exec/ioport.h"
 #include "exec/memory.h"
 #include "exec/address-spaces.h"
 #include "exec/ioport.h"

+#include "qapi/visitor.h"

 #include "qemu/bitops.h"
 #include "qom/object.h"
 #include "trace.h"
 #include "qemu/bitops.h"
 #include "qom/object.h"
 #include "trace.h"


@@ -55,8 +56,7 @@ static void memory_init(void)
 typedef struct AddrRange AddrRange;
 
 /*
 typedef struct AddrRange AddrRange;
 
 /*

- * Note using signed integers limits us to physical addresses at most
- * 63 bits wide.  They are needed for negative offsetting in aliases
+ * Note that signed integers are needed for negative offsetting in aliases

  * (large MemoryRegion::alias_offset).
  */
 struct AddrRange {
  * (large MemoryRegion::alias_offset).
  */
 struct AddrRange {


@@ -876,30 +876,6 @@ static char *memory_region_escape_name(const char *name)
     return escaped;
 }
 
     return escaped;
 }
 

-static void object_property_add_child_array(Object *owner,
-                                            const char *name,
-                                            Object *child)
-{
-    int i;
-    char *base_name = memory_region_escape_name(name);
-
-    for (i = 0; ; i++) {
-        char *full_name = g_strdup_printf("%s[%d]", base_name, i);
-        Error *local_err = NULL;
-
-        object_property_add_child(owner, full_name, child, &local_err);
-        g_free(full_name);
-        if (!local_err) {
-            break;
-        }
-
-        error_free(local_err);
-    }
-
-    g_free(base_name);
-}
-        
-

 void memory_region_init(MemoryRegion *mr,
                         Object *owner,
                         const char *name,
 void memory_region_init(MemoryRegion *mr,
                         Object *owner,
                         const char *name,


@@ -917,14 +893,76 @@ void memory_region_init(MemoryRegion *mr,
     mr->name = g_strdup(name);
 
     if (name) {
     mr->name = g_strdup(name);
 
     if (name) {

-        object_property_add_child_array(owner, name, OBJECT(mr));
+        char *escaped_name = memory_region_escape_name(name);
+        char *name_array = g_strdup_printf("%s[*]", escaped_name);
+        object_property_add_child(owner, name_array, OBJECT(mr), &error_abort);

         object_unref(OBJECT(mr));
         object_unref(OBJECT(mr));

+        g_free(name_array);
+        g_free(escaped_name);
+    }
+}
+
+static void memory_region_get_addr(Object *obj, Visitor *v, void *opaque,
+                                   const char *name, Error **errp)
+{
+    MemoryRegion *mr = MEMORY_REGION(obj);
+    uint64_t value = mr->addr;
+
+    visit_type_uint64(v, &value, name, errp);
+}
+
+static void memory_region_get_container(Object *obj, Visitor *v, void *opaque,
+                                        const char *name, Error **errp)
+{
+    MemoryRegion *mr = MEMORY_REGION(obj);
+    gchar *path = (gchar *)"";
+
+    if (mr->container) {
+        path = object_get_canonical_path(OBJECT(mr->container));
+    }
+    visit_type_str(v, &path, name, errp);
+    if (mr->container) {
+        g_free(path);

     }
 }
 
     }
 }
 

+static Object *memory_region_resolve_container(Object *obj, void *opaque,
+                                               const char *part)
+{
+    MemoryRegion *mr = MEMORY_REGION(obj);
+
+    return OBJECT(mr->container);
+}
+
+static void memory_region_get_priority(Object *obj, Visitor *v, void *opaque,
+                                       const char *name, Error **errp)
+{
+    MemoryRegion *mr = MEMORY_REGION(obj);
+    int32_t value = mr->priority;
+
+    visit_type_int32(v, &value, name, errp);
+}
+
+static bool memory_region_get_may_overlap(Object *obj, Error **errp)
+{
+    MemoryRegion *mr = MEMORY_REGION(obj);
+
+    return mr->may_overlap;
+}
+
+static void memory_region_get_size(Object *obj, Visitor *v, void *opaque,
+                                   const char *name, Error **errp)
+{
+    MemoryRegion *mr = MEMORY_REGION(obj);
+    uint64_t value = memory_region_size(mr);
+
+    visit_type_uint64(v, &value, name, errp);
+}
+

 static void memory_region_initfn(Object *obj)
 {
     MemoryRegion *mr = MEMORY_REGION(obj);
 static void memory_region_initfn(Object *obj)
 {
     MemoryRegion *mr = MEMORY_REGION(obj);

+    ObjectProperty *op;

 
     mr->ops = &unassigned_mem_ops;
     mr->enabled = true;
 
     mr->ops = &unassigned_mem_ops;
     mr->enabled = true;


@@ -932,6 +970,30 @@ static void memory_region_initfn(Object *obj)
     mr->destructor = memory_region_destructor_none;
     QTAILQ_INIT(&mr->subregions);
     QTAILQ_INIT(&mr->coalesced);
     mr->destructor = memory_region_destructor_none;
     QTAILQ_INIT(&mr->subregions);
     QTAILQ_INIT(&mr->coalesced);

+
+    op = object_property_add(OBJECT(mr), "container",
+                             "link<" TYPE_MEMORY_REGION ">",
+                             memory_region_get_container,
+                             NULL, /* memory_region_set_container */
+                             NULL, NULL, &error_abort);
+    op->resolve = memory_region_resolve_container;
+
+    object_property_add(OBJECT(mr), "addr", "uint64",
+                        memory_region_get_addr,
+                        NULL, /* memory_region_set_addr */
+                        NULL, NULL, &error_abort);
+    object_property_add(OBJECT(mr), "priority", "uint32",
+                        memory_region_get_priority,
+                        NULL, /* memory_region_set_priority */
+                        NULL, NULL, &error_abort);
+    object_property_add_bool(OBJECT(mr), "may-overlap",
+                             memory_region_get_may_overlap,
+                             NULL, /* memory_region_set_may_overlap */
+                             &error_abort);
+    object_property_add(OBJECT(mr), "size", "uint64",
+                        memory_region_get_size,
+                        NULL, /* memory_region_set_size, */
+                        NULL, NULL, &error_abort);

 }
 
 static uint64_t unassigned_mem_read(void *opaque, hwaddr addr,
 }
 
 static uint64_t unassigned_mem_read(void *opaque, hwaddr addr,


@@ -1080,13 +1142,14 @@ void memory_region_init_io(MemoryRegion *mr,
 void memory_region_init_ram(MemoryRegion *mr,
                             Object *owner,
                             const char *name,
 void memory_region_init_ram(MemoryRegion *mr,
                             Object *owner,
                             const char *name,

-                            uint64_t size)
+                            uint64_t size,
+                            Error **errp)

 {
     memory_region_init(mr, owner, name, size);
     mr->ram = true;
     mr->terminates = true;
     mr->destructor = memory_region_destructor_ram;
 {
     memory_region_init(mr, owner, name, size);
     mr->ram = true;
     mr->terminates = true;
     mr->destructor = memory_region_destructor_ram;

-    mr->ram_addr = qemu_ram_alloc(size, mr);
+    mr->ram_addr = qemu_ram_alloc(size, mr, errp);

 }
 
 #ifdef __linux__
 }
 
 #ifdef __linux__


@@ -1116,7 +1179,15 @@ void memory_region_init_ram_ptr(MemoryRegion *mr,
     mr->ram = true;
     mr->terminates = true;
     mr->destructor = memory_region_destructor_ram_from_ptr;
     mr->ram = true;
     mr->terminates = true;
     mr->destructor = memory_region_destructor_ram_from_ptr;

-    mr->ram_addr = qemu_ram_alloc_from_ptr(size, ptr, mr);
+
+    /* qemu_ram_alloc_from_ptr cannot fail with ptr != NULL.  */
+    assert(ptr != NULL);
+    mr->ram_addr = qemu_ram_alloc_from_ptr(size, ptr, mr, &error_abort);
+}
+
+void memory_region_set_skip_dump(MemoryRegion *mr)
+{
+    mr->skip_dump = true;

 }
 
 void memory_region_init_alias(MemoryRegion *mr,
 }
 
 void memory_region_init_alias(MemoryRegion *mr,


@@ -1138,7 +1209,8 @@ void memory_region_init_rom_device(MemoryRegion *mr,
                                    const MemoryRegionOps *ops,
                                    void *opaque,
                                    const char *name,
                                    const MemoryRegionOps *ops,
                                    void *opaque,
                                    const char *name,

-                                   uint64_t size)
+                                   uint64_t size,
+                                   Error **errp)

 {
     memory_region_init(mr, owner, name, size);
     mr->ops = ops;
 {
     memory_region_init(mr, owner, name, size);
     mr->ops = ops;


@@ -1146,7 +1218,7 @@ void memory_region_init_rom_device(MemoryRegion *mr,
     mr->terminates = true;
     mr->rom_device = true;
     mr->destructor = memory_region_destructor_rom_device;
     mr->terminates = true;
     mr->rom_device = true;
     mr->destructor = memory_region_destructor_rom_device;

-    mr->ram_addr = qemu_ram_alloc(size, mr);
+    mr->ram_addr = qemu_ram_alloc(size, mr, errp);

 }
 
 void memory_region_init_iommu(MemoryRegion *mr,
 }
 
 void memory_region_init_iommu(MemoryRegion *mr,


@@ -1181,12 +1253,6 @@ static void memory_region_finalize(Object *obj)
     g_free(mr->ioeventfds);
 }
 
     g_free(mr->ioeventfds);
 }
 

-void memory_region_destroy(MemoryRegion *mr)
-{
-    object_unparent(OBJECT(mr));
-}
-
-

 Object *memory_region_owner(MemoryRegion *mr)
 {
     Object *obj = OBJECT(mr);
 Object *memory_region_owner(MemoryRegion *mr)
 {
     Object *obj = OBJECT(mr);


@@ -1231,8 +1297,12 @@ uint64_t memory_region_size(MemoryRegion *mr)
     return int128_get64(mr->size);
 }
 
     return int128_get64(mr->size);
 }
 

-const char *memory_region_name(MemoryRegion *mr)
+const char *memory_region_name(const MemoryRegion *mr)

 {
 {

+    if (!mr->name) {
+        ((MemoryRegion *)mr)->name =
+            object_get_canonical_path_component(OBJECT(mr));
+    }

     return mr->name;
 }
 
     return mr->name;
 }
 


@@ -1241,6 +1311,11 @@ bool memory_region_is_ram(MemoryRegion *mr)
     return mr->ram;
 }
 
     return mr->ram;
 }
 

+bool memory_region_is_skip_dump(MemoryRegion *mr)
+{
+    return mr->skip_dump;
+}
+

 bool memory_region_is_logging(MemoryRegion *mr)
 {
     return mr->dirty_log_mask;
 bool memory_region_is_logging(MemoryRegion *mr)
 {
     return mr->dirty_log_mask;


@@ -1674,6 +1749,11 @@ ram_addr_t memory_region_get_ram_addr(MemoryRegion *mr)
     return mr->ram_addr;
 }
 
     return mr->ram_addr;
 }
 

+uint64_t memory_region_get_alignment(const MemoryRegion *mr)
+{
+    return mr->align;
+}
+

 static int cmp_flatrange_addr(const void *addr_, const void *fr_)
 {
     const AddrRange *addr = addr_;
 static int cmp_flatrange_addr(const void *addr_, const void *fr_)
 {
     const AddrRange *addr = addr_;


@@ -1897,7 +1977,6 @@ typedef struct MemoryRegionList MemoryRegionList;
 
 struct MemoryRegionList {
     const MemoryRegion *mr;
 
 struct MemoryRegionList {
     const MemoryRegion *mr;

-    bool printed;

     QTAILQ_ENTRY(MemoryRegionList) queue;
 };
 
     QTAILQ_ENTRY(MemoryRegionList) queue;
 };
 


@@ -1927,7 +2006,7 @@ static void mtree_print_mr(fprintf_function mon_printf, void *f,
 
         /* check if the alias is already in the queue */
         QTAILQ_FOREACH(ml, alias_print_queue, queue) {
 
         /* check if the alias is already in the queue */
         QTAILQ_FOREACH(ml, alias_print_queue, queue) {

-            if (ml->mr == mr->alias && !ml->printed) {
+            if (ml->mr == mr->alias) {

                 found = true;
             }
         }
                 found = true;
             }
         }


@@ -1935,7 +2014,6 @@ static void mtree_print_mr(fprintf_function mon_printf, void *f,
         if (!found) {
             ml = g_new(MemoryRegionList, 1);
             ml->mr = mr->alias;
         if (!found) {
             ml = g_new(MemoryRegionList, 1);
             ml->mr = mr->alias;

-            ml->printed = false;

             QTAILQ_INSERT_TAIL(alias_print_queue, ml, queue);
         }
         mon_printf(f, TARGET_FMT_plx "-" TARGET_FMT_plx
             QTAILQ_INSERT_TAIL(alias_print_queue, ml, queue);
         }
         mon_printf(f, TARGET_FMT_plx "-" TARGET_FMT_plx


@@ -1950,8 +2028,8 @@ static void mtree_print_mr(fprintf_function mon_printf, void *f,
                    mr->romd_mode ? 'R' : '-',
                    !mr->readonly && !(mr->rom_device && mr->romd_mode) ? 'W'
                                                                        : '-',
                    mr->romd_mode ? 'R' : '-',
                    !mr->readonly && !(mr->rom_device && mr->romd_mode) ? 'W'
                                                                        : '-',

-                   mr->name,
-                   mr->alias->name,
+                   memory_region_name(mr),
+                   memory_region_name(mr->alias),

                    mr->alias_offset,
                    mr->alias_offset
                    + (int128_nz(mr->size) ?
                    mr->alias_offset,
                    mr->alias_offset
                    + (int128_nz(mr->size) ?


@@ -1969,7 +2047,7 @@ static void mtree_print_mr(fprintf_function mon_printf, void *f,
                    mr->romd_mode ? 'R' : '-',
                    !mr->readonly && !(mr->rom_device && mr->romd_mode) ? 'W'
                                                                        : '-',
                    mr->romd_mode ? 'R' : '-',
                    !mr->readonly && !(mr->rom_device && mr->romd_mode) ? 'W'
                                                                        : '-',

-                   mr->name);
+                   memory_region_name(mr));

     }
 
     QTAILQ_INIT(&submr_print_queue);
     }
 
     QTAILQ_INIT(&submr_print_queue);


@@ -2017,10 +2095,8 @@ void mtree_info(fprintf_function mon_printf, void *f)
     mon_printf(f, "aliases\n");
     /* print aliased regions */
     QTAILQ_FOREACH(ml, &ml_head, queue) {
     mon_printf(f, "aliases\n");
     /* print aliased regions */
     QTAILQ_FOREACH(ml, &ml_head, queue) {

-        if (!ml->printed) {
-            mon_printf(f, "%s\n", ml->mr->name);
-            mtree_print_mr(mon_printf, f, ml->mr, 0, 0, &ml_head);
-        }
+        mon_printf(f, "%s\n", memory_region_name(ml->mr));
+        mtree_print_mr(mon_printf, f, ml->mr, 0, 0, &ml_head);

     }
 
     QTAILQ_FOREACH_SAFE(ml, &ml_head, queue, ml2) {
     }
 
     QTAILQ_FOREACH_SAFE(ml, &ml_head, queue, ml2) {