hostmem-file and hostmem-memfd use the whole object path for the
memory region name, and hostname-ram uses only the path component (the
object id, or canonical path basename):
qemu -m 1024 -object memory-backend-file,id=mem,size=1G,mem-path=/tmp/foo -numa node,memdev=mem -monitor stdio
(qemu) info ramblock
Block Name PSize Offset Used Total
/objects/mem 4 KiB 0x0000000000000000 0x0000000040000000 0x0000000040000000
qemu -m 1024 -object memory-backend-memfd,id=mem,size=1G -numa node,memdev=mem -monitor stdio
(qemu) info ramblock
Block Name PSize Offset Used Total
/objects/mem 4 KiB 0x0000000000000000 0x0000000040000000 0x0000000040000000
qemu -m 1024 -object memory-backend-ram,id=mem,size=1G -numa node,memdev=mem -monitor stdio
(qemu) info ramblock
Block Name PSize Offset Used Total
mem 4 KiB 0x0000000000000000 0x0000000040000000 0x0000000040000000
Use the object id for -file and -memfd with >= 3.1 for consistency.
Having a consistent naming allow to migrate to different hostmem
backends.
Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com>
---
include/hw/compat.h | 11 ++++++++++-
include/sysemu/hostmem.h | 3 ++-
backends/hostmem-file.c | 8 ++++----
backends/hostmem-memfd.c | 2 +-
backends/hostmem-ram.c | 9 ++++-----
backends/hostmem.c | 30 ++++++++++++++++++++++++++++++
6 files changed, 51 insertions(+), 12 deletions(-)
diff --git a/include/hw/compat.h b/include/hw/compat.h
index 6f4d5fc647..60f4a939a7 100644
--- a/include/hw/compat.h
+++ b/include/hw/compat.h
@@ -2,7 +2,16 @@
#define HW_COMPAT_H
#define HW_COMPAT_3_0 \
- /* empty */
+ {\
+ .driver = "memory-backend-file",\
+ .property = "x-use-canonical-path-for-ramblock-id",\
+ .value = "true",\
+ },\
+ {\
+ .driver = "memory-backend-memfd",\
+ .property = "x-use-canonical-path-for-ramblock-id",\
+ .value = "true",\
+ },
#define HW_COMPAT_2_12 \
{\
diff --git a/include/sysemu/hostmem.h b/include/sysemu/hostmem.h
index 6e6bd2c1cb..a023b372a4 100644
--- a/include/sysemu/hostmem.h
+++ b/include/sysemu/hostmem.h
@@ -53,7 +53,7 @@ struct HostMemoryBackend {
/* protected */
uint64_t size;
- bool merge, dump;
+ bool merge, dump, use_canonical_path;
bool prealloc, force_prealloc, is_mapped, share;
DECLARE_BITMAP(host_nodes, MAX_NODES + 1);
HostMemPolicy policy;
@@ -67,5 +67,6 @@ MemoryRegion *host_memory_backend_get_memory(HostMemoryBackend *backend);
void host_memory_backend_set_mapped(HostMemoryBackend *backend, bool mapped);
bool host_memory_backend_is_mapped(HostMemoryBackend *backend);
size_t host_memory_backend_pagesize(HostMemoryBackend *memdev);
+char *host_memory_backend_get_name(HostMemoryBackend *backend);
#endif
diff --git a/backends/hostmem-file.c b/backends/hostmem-file.c
index 639c8d4307..c01a7cdf8d 100644
--- a/backends/hostmem-file.c
+++ b/backends/hostmem-file.c
@@ -55,16 +55,16 @@ file_backend_memory_alloc(HostMemoryBackend *backend, Error **errp)
error_setg(errp, "-mem-path not supported on this host");
#else
if (!host_memory_backend_mr_inited(backend)) {
- gchar *path;
+ gchar *name;
backend->force_prealloc = mem_prealloc;
- path = object_get_canonical_path(OBJECT(backend));
+ name = host_memory_backend_get_name(backend);
memory_region_init_ram_from_file(&backend->mr, OBJECT(backend),
- path,
+ name,
backend->size, fb->align,
(backend->share ? RAM_SHARED : 0) |
(fb->is_pmem ? RAM_PMEM : 0),
fb->mem_path, errp);
- g_free(path);
+ g_free(name);
}
#endif
}
diff --git a/backends/hostmem-memfd.c b/backends/hostmem-memfd.c
index b6836b28e5..c5a4a9b530 100644
--- a/backends/hostmem-memfd.c
+++ b/backends/hostmem-memfd.c
@@ -57,7 +57,7 @@ memfd_backend_memory_alloc(HostMemoryBackend *backend, Error **errp)
return;
}
- name = object_get_canonical_path(OBJECT(backend));
+ name = host_memory_backend_get_name(backend);
memory_region_init_ram_from_fd(&backend->mr, OBJECT(backend),
name, backend->size, true, fd, errp);
g_free(name);
diff --git a/backends/hostmem-ram.c b/backends/hostmem-ram.c
index 7ddd08d370..24b65d9ae3 100644
--- a/backends/hostmem-ram.c
+++ b/backends/hostmem-ram.c
@@ -16,21 +16,20 @@
#define TYPE_MEMORY_BACKEND_RAM "memory-backend-ram"
-
static void
ram_backend_memory_alloc(HostMemoryBackend *backend, Error **errp)
{
- char *path;
+ char *name;
if (!backend->size) {
error_setg(errp, "can't create backend with size 0");
return;
}
- path = object_get_canonical_path_component(OBJECT(backend));
- memory_region_init_ram_shared_nomigrate(&backend->mr, OBJECT(backend), path,
+ name = host_memory_backend_get_name(backend);
+ memory_region_init_ram_shared_nomigrate(&backend->mr, OBJECT(backend), name,
backend->size, backend->share, errp);
- g_free(path);
+ g_free(name);
}
static void
diff --git a/backends/hostmem.c b/backends/hostmem.c
index 1a89342039..0032232866 100644
--- a/backends/hostmem.c
+++ b/backends/hostmem.c
@@ -28,6 +28,16 @@ QEMU_BUILD_BUG_ON(HOST_MEM_POLICY_BIND != MPOL_BIND);
QEMU_BUILD_BUG_ON(HOST_MEM_POLICY_INTERLEAVE != MPOL_INTERLEAVE);
#endif
+char *
+host_memory_backend_get_name(HostMemoryBackend *self)
+{
+ if (!self->use_canonical_path) {
+ return object_get_canonical_path_component(OBJECT(self));
+ }
+
+ return object_get_canonical_path(OBJECT(self));
+}
+
static void
host_memory_backend_get_size(Object *obj, Visitor *v, const char *name,
void *opaque, Error **errp)
@@ -386,6 +396,23 @@ static void host_memory_backend_set_share(Object *o, bool value, Error **errp)
backend->share = value;
}
+static bool
+host_memory_backend_get_use_canonical_path(Object *obj, Error **errp)
+{
+ HostMemoryBackend *self = MEMORY_BACKEND(obj);
+
+ return self->use_canonical_path;
+}
+
+static void
+host_memory_backend_set_use_canonical_path(Object *obj, bool value,
+ Error **errp)
+{
+ HostMemoryBackend *self = MEMORY_BACKEND(obj);
+
+ self->use_canonical_path = value;
+}
+
static void
host_memory_backend_class_init(ObjectClass *oc, void *data)
{
@@ -432,6 +459,9 @@ host_memory_backend_class_init(ObjectClass *oc, void *data)
&error_abort);
object_class_property_set_description(oc, "share",
"Mark the memory as private to QEMU or shared", &error_abort);
+ object_class_property_add_bool(oc, "x-use-canonical-path-for-ramblock-id",
+ host_memory_backend_get_use_canonical_path,
+ host_memory_backend_set_use_canonical_path, &error_abort);
}
static const TypeInfo host_memory_backend_info = {
--
2.19.0.271.gfe8321ec05
On Tue, Oct 30, 2018 at 07:04:53PM +0400, Marc-André Lureau wrote: > hostmem-file and hostmem-memfd use the whole object path for the > memory region name, and hostname-ram uses only the path component (the > object id, or canonical path basename): > > qemu -m 1024 -object memory-backend-file,id=mem,size=1G,mem-path=/tmp/foo -numa node,memdev=mem -monitor stdio > (qemu) info ramblock > Block Name PSize Offset Used Total > /objects/mem 4 KiB 0x0000000000000000 0x0000000040000000 0x0000000040000000 > > qemu -m 1024 -object memory-backend-memfd,id=mem,size=1G -numa node,memdev=mem -monitor stdio > (qemu) info ramblock > Block Name PSize Offset Used Total > /objects/mem 4 KiB 0x0000000000000000 0x0000000040000000 0x0000000040000000 > > qemu -m 1024 -object memory-backend-ram,id=mem,size=1G -numa node,memdev=mem -monitor stdio > (qemu) info ramblock > Block Name PSize Offset Used Total > mem 4 KiB 0x0000000000000000 0x0000000040000000 0x0000000040000000 > > Use the object id for -file and -memfd with >= 3.1 for consistency. > Having a consistent naming allow to migrate to different hostmem > backends. > > Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com> I don't want to make you feel like you wasted your time on the global property system refactor, but: Maybe it would be simpler to add a bool MachineClass::canonical_path_for_ramblock_id field, instead of refactoring the global property system, considering that we're past soft freeze? Sometimes I think the global property system was a mistake, and that we should avoid spreading it to other subsystems. -- Eduardo
On Wed, 31 Oct 2018 17:27:57 -0300 Eduardo Habkost <ehabkost@redhat.com> wrote: > On Tue, Oct 30, 2018 at 07:04:53PM +0400, Marc-André Lureau wrote: > > hostmem-file and hostmem-memfd use the whole object path for the > > memory region name, and hostname-ram uses only the path component (the > > object id, or canonical path basename): > > > > qemu -m 1024 -object memory-backend-file,id=mem,size=1G,mem-path=/tmp/foo -numa node,memdev=mem -monitor stdio > > (qemu) info ramblock > > Block Name PSize Offset Used Total > > /objects/mem 4 KiB 0x0000000000000000 0x0000000040000000 0x0000000040000000 > > > > qemu -m 1024 -object memory-backend-memfd,id=mem,size=1G -numa node,memdev=mem -monitor stdio > > (qemu) info ramblock > > Block Name PSize Offset Used Total > > /objects/mem 4 KiB 0x0000000000000000 0x0000000040000000 0x0000000040000000 > > > > qemu -m 1024 -object memory-backend-ram,id=mem,size=1G -numa node,memdev=mem -monitor stdio > > (qemu) info ramblock > > Block Name PSize Offset Used Total > > mem 4 KiB 0x0000000000000000 0x0000000040000000 0x0000000040000000 > > > > Use the object id for -file and -memfd with >= 3.1 for consistency. > > Having a consistent naming allow to migrate to different hostmem > > backends. > > > > Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com> > > I don't want to make you feel like you wasted your time on the > global property system refactor, but: > > Maybe it would be simpler to add a > bool MachineClass::canonical_path_for_ramblock_id I dislike adding compat flags in random places in this case it has nothing to do with machine. > field, instead of refactoring the global property system, > considering that we're past soft freeze? We can merge it for 3.2, I have another potential usage for Mark's work, converting initial memory to memory devices (so far only ARM), where we would need to keep ramblock id's compatible across different machine versions and a different way we were creating initial memory memory regions so migration would not fail. > Sometimes I think the global property system was a mistake, and > that we should avoid spreading it to other subsystems. Well user accessible globals might be a mistake, but it's quite useful/convenient API to fix compatibility parameters for different machines/versions in uniform way without hacking unrelated code.
On Thu, Nov 01, 2018 at 04:16:12PM +0100, Igor Mammedov wrote: > On Wed, 31 Oct 2018 17:27:57 -0300 > Eduardo Habkost <ehabkost@redhat.com> wrote: > > > On Tue, Oct 30, 2018 at 07:04:53PM +0400, Marc-André Lureau wrote: > > > hostmem-file and hostmem-memfd use the whole object path for the > > > memory region name, and hostname-ram uses only the path component (the > > > object id, or canonical path basename): > > > > > > qemu -m 1024 -object memory-backend-file,id=mem,size=1G,mem-path=/tmp/foo -numa node,memdev=mem -monitor stdio > > > (qemu) info ramblock > > > Block Name PSize Offset Used Total > > > /objects/mem 4 KiB 0x0000000000000000 0x0000000040000000 0x0000000040000000 > > > > > > qemu -m 1024 -object memory-backend-memfd,id=mem,size=1G -numa node,memdev=mem -monitor stdio > > > (qemu) info ramblock > > > Block Name PSize Offset Used Total > > > /objects/mem 4 KiB 0x0000000000000000 0x0000000040000000 0x0000000040000000 > > > > > > qemu -m 1024 -object memory-backend-ram,id=mem,size=1G -numa node,memdev=mem -monitor stdio > > > (qemu) info ramblock > > > Block Name PSize Offset Used Total > > > mem 4 KiB 0x0000000000000000 0x0000000040000000 0x0000000040000000 > > > > > > Use the object id for -file and -memfd with >= 3.1 for consistency. > > > Having a consistent naming allow to migrate to different hostmem > > > backends. > > > > > > Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com> > > > > I don't want to make you feel like you wasted your time on the > > global property system refactor, but: > > > > Maybe it would be simpler to add a > > bool MachineClass::canonical_path_for_ramblock_id > I dislike adding compat flags in random places in this case > it has nothing to do with machine. I don't see why it would be a problem. If you really believe this compat flag doesn't belong to a MachineClass field, it would not belong to MachineClass::compat_props either. > > > field, instead of refactoring the global property system, > > considering that we're past soft freeze? > We can merge it for 3.2, > I have another potential usage for Mark's work, > converting initial memory to memory devices (so far only ARM), > where we would need to keep ramblock id's compatible across > different machine versions and a different way we were creating > initial memory memory regions so migration would not fail. Right, so allowing backend objects to be affected by MachineClass::compat_props would be nice to have, long term. > > > Sometimes I think the global property system was a mistake, and > > that we should avoid spreading it to other subsystems. > Well user accessible globals might be a mistake, > but it's quite useful/convenient API to fix compatibility parameters > for different machines/versions in uniform way without hacking > unrelated code. Agreed. Having compat_props is nice. Mixing -global and MachineClass::compat_props was a mistake, and I want to revert that. See the suggestion on the reply to 05/10 on how we could do this. -- Eduardo
© 2016 - 2025 Red Hat, Inc.