[PATCH v2 38/40] conf: convert virDomain*Private to GObject

Tuesday, 21 April 2020

Signed-off-by: Rafael Fonseca <r4f4rfs(a)gmail.com&gt;
---
 src/conf/domain_conf.c    |  21 ++-
 src/conf/domain_conf.h    |  18 +-
 src/qemu/qemu_domain.c    | 359 +++++++++++++++++---------------------
 src/qemu/qemu_domain.h    | 145 ++++++++++-----
 src/util/virstoragefile.c |   2 +-
 src/util/virstoragefile.h |   3 +-
 6 files changed, 286 insertions(+), 262 deletions(-)

diff --git a/src/conf/domain_conf.c b/src/conf/domain_conf.c
index fa87fb0590..15a0c2d881 100644
--- a/src/conf/domain_conf.c
+++ b/src/conf/domain_conf.c
@@ -1785,7 +1785,7 @@ void virDomainGraphicsDefFree(virDomainGraphicsDefPtr def)
         virDomainGraphicsListenDefClear(&def->listens[i]);
     VIR_FREE(def->listens);
 
-    virObjectUnref(def->privateData);
+    g_clear_object(&def->privateData);
     VIR_FREE(def);
 }
 
@@ -1833,7 +1833,7 @@ static virDomainVcpuDefPtr
 virDomainVcpuDefNew(virDomainXMLOptionPtr xmlopt)
 {
     virDomainVcpuDefPtr ret = NULL;
-    g_autoptr(virObject) priv = NULL;
+    g_autoptr(GObject) priv = NULL;
 
     if (xmlopt && xmlopt->privateData.vcpuNew &&
         !(priv = xmlopt->privateData.vcpuNew()))
@@ -1856,7 +1856,7 @@ virDomainVcpuDefFree(virDomainVcpuDefPtr info)
 
     virBitmapFree(info->cpumask);
     info->cpumask = NULL;
-    virObjectUnref(info->privateData);
+    g_clear_object(&info->privateData);
     VIR_FREE(info);
 }
 
@@ -2158,7 +2158,7 @@ virDomainDiskDefFree(virDomainDiskDefPtr def)
     VIR_FREE(def->blkdeviotune.group_name);
     VIR_FREE(def->virtio);
     virDomainDeviceInfoClear(&def->info);
-    virObjectUnref(def->privateData);
+    g_clear_object(&def->privateData);
 
     VIR_FREE(def);
 }
@@ -2361,7 +2361,7 @@ void virDomainFSDefFree(virDomainFSDefPtr def)
     VIR_FREE(def->dst);
     virDomainDeviceInfoClear(&def->info);
     VIR_FREE(def->virtio);
-    virObjectUnref(def->privateData);
+    g_clear_object(&def->privateData);
     VIR_FREE(def->binary);
 
     VIR_FREE(def);
@@ -2422,7 +2422,7 @@ virDomainVsockDefFree(virDomainVsockDefPtr vsock)
     if (!vsock)
         return;
 
-    virObjectUnref(vsock->privateData);
+    g_clear_object(&vsock->privateData);
     virDomainDeviceInfoClear(&vsock->info);
     VIR_FREE(vsock);
 }
@@ -2510,7 +2510,7 @@ virDomainNetDefFree(virDomainNetDefPtr def)
     if (!def)
         return;
     virDomainNetDefClear(def);
-    virObjectUnref(def->privateData);
+    g_clear_object(&def->privateData);
     VIR_FREE(def);
 }
 
@@ -2651,8 +2651,7 @@ virDomainChrSourceDefDispose(GObject *obj)
 {
     virDomainChrSourceDefPtr def = VIR_DOMAIN_CHR_SOURCE_DEF(obj);
 
-    virObjectUnref(def->privateData);
-    def->privateData = NULL;
+    g_clear_object(&def->privateData);
 
     G_OBJECT_CLASS(vir_domain_chr_source_def_parent_class)->dispose(obj);
 }
@@ -2909,7 +2908,7 @@ virDomainVideoDefClear(virDomainVideoDefPtr def)
     if (def->driver)
         VIR_FREE(def->driver->vhost_user_binary);
     VIR_FREE(def->driver);
-    virObjectUnref(def->privateData);
+    g_clear_object(&def->privateData);
 
     memset(def, 0, sizeof(*def));
 }
@@ -27098,7 +27097,7 @@ virDomainRNGDefFree(virDomainRNGDefPtr def)
         VIR_FREE(def->source.file);
         break;
     case VIR_DOMAIN_RNG_BACKEND_EGD:
-        virObjectUnref(def->source.chardev);
+        g_clear_object(&def->source.chardev);
         break;
     case VIR_DOMAIN_RNG_BACKEND_BUILTIN:
     case VIR_DOMAIN_RNG_BACKEND_LAST:
diff --git a/src/conf/domain_conf.h b/src/conf/domain_conf.h
index c9a44ecfd8..ae9a064106 100644
--- a/src/conf/domain_conf.h
+++ b/src/conf/domain_conf.h
@@ -528,7 +528,7 @@ typedef enum {
 struct _virDomainDiskDef {
     virStorageSourcePtr src; /* non-NULL.  XXX Allow NULL for empty cdrom? */
 
-    virObjectPtr privateData;
+    GObject *privateData;
 
     int device; /* enum virDomainDiskDevice */
     int bus; /* enum virDomainDiskBus */
@@ -852,7 +852,7 @@ struct _virDomainFSDef {
     virTristateSwitch posix_lock;
     virTristateSwitch flock;
     virDomainVirtioOptionsPtr virtio;
-    virObjectPtr privateData;
+    GObject *privateData;
 };
 
 
@@ -1071,7 +1071,7 @@ struct _virDomainNetDef {
     unsigned int mtu;
     virNetDevCoalescePtr coalesce;
     virDomainVirtioOptionsPtr virtio;
-    virObjectPtr privateData;
+    GObject *privateData;
 };
 
 typedef enum {
@@ -1190,7 +1190,7 @@ struct _virDomainChrSourceReconnectDef {
 struct _virDomainChrSourceDef {
     GObject parent;
     int type; /* virDomainChrType */
-    virObjectPtr privateData;
+    GObject *privateData;
     union {
         /* no <source> for null, vc, stdio */
         struct {
@@ -1493,7 +1493,7 @@ struct _virDomainVideoDriverDef {
 };
 
 struct _virDomainVideoDef {
-    virObjectPtr privateData;
+    GObject *privateData;
 
     int type;   /* enum virDomainVideoType */
     unsigned int ram;  /* kibibytes (multiples of 1024) */
@@ -1640,7 +1640,7 @@ struct _virDomainGraphicsListenDef {
 };
 
 struct _virDomainGraphicsDef {
-    virObjectPtr privateData;
+    GObject *privateData;
 
     /* Port value discipline:
      * Value -1 is legacy syntax indicating that it should be auto-allocated.
@@ -2318,7 +2318,7 @@ struct _virDomainVcpuDef {
 
     virDomainThreadSchedParam sched;
 
-    virObjectPtr privateData;
+    GObject *privateData;
 };
 
 struct _virDomainBlkiotune {
@@ -2416,7 +2416,7 @@ typedef enum {
 } virDomainVsockModel;
 
 struct _virDomainVsockDef {
-    virObjectPtr privateData;
+    GObject *privateData;
 
     virDomainVsockModel model;
     unsigned int guest_cid;
@@ -2774,7 +2774,7 @@ struct _virDomainDefParserConfig {
 
 typedef void *(*virDomainXMLPrivateDataAllocFunc)(void *);
 typedef void (*virDomainXMLPrivateDataFreeFunc)(void *);
-typedef virObjectPtr (*virDomainXMLPrivateDataNewFunc)(void);
+typedef GObject* (*virDomainXMLPrivateDataNewFunc)(void);
 typedef int (*virDomainXMLPrivateDataFormatFunc)(virBufferPtr,
                                                  virDomainObjPtr);
 typedef int (*virDomainXMLPrivateDataParseFunc)(xmlXPathContextPtr,
diff --git a/src/qemu/qemu_domain.c b/src/qemu/qemu_domain.c
index 99478890b6..7f6ac10659 100644
--- a/src/qemu/qemu_domain.c
+++ b/src/qemu/qemu_domain.c
@@ -1130,362 +1130,329 @@ qemuDomainSecretInfoDestroy(qemuDomainSecretInfoPtr secinfo)
 }
 
 
-static virClassPtr qemuDomainDiskPrivateClass;
-static void qemuDomainDiskPrivateDispose(void *obj);
+G_DEFINE_TYPE(qemuDomainDiskPrivate, qemu_domain_disk_private, G_TYPE_OBJECT);
+static void qemuDomainDiskPrivateDispose(GObject *obj);
+static void qemuDomainDiskPrivateFinalize(GObject *obj);
 
-static int
-qemuDomainDiskPrivateOnceInit(void)
+static void
+qemu_domain_disk_private_init(qemuDomainDiskPrivate *priv G_GNUC_UNUSED)
 {
-    if (!VIR_CLASS_NEW(qemuDomainDiskPrivate, virClassForObject()))
-        return -1;
-
-    return 0;
 }
 
-VIR_ONCE_GLOBAL_INIT(qemuDomainDiskPrivate);
+static void
+qemu_domain_disk_private_class_init(qemuDomainDiskPrivateClass *klass)
+{
+    GObjectClass *obj = G_OBJECT_CLASS(klass);
+
+    obj->dispose = qemuDomainDiskPrivateDispose;
+    obj->finalize = qemuDomainDiskPrivateFinalize;
+}
 
-static virObjectPtr
+static GObject *
 qemuDomainDiskPrivateNew(void)
 {
-    qemuDomainDiskPrivatePtr priv;
+    return g_object_new(QEMU_TYPE_DOMAIN_DISK_PRIVATE, NULL);
+}
 
-    if (qemuDomainDiskPrivateInitialize() < 0)
-        return NULL;
+static void
+qemuDomainDiskPrivateDispose(GObject *obj)
+{
+    qemuDomainDiskPrivatePtr priv = QEMU_DOMAIN_DISK(obj);
 
-    if (!(priv = virObjectNew(qemuDomainDiskPrivateClass)))
-        return NULL;
+    virObjectUnref(priv->migrSource);
+    priv->migrSource = NULL;
+    g_clear_object(&priv->blockjob);
 
-    return (virObjectPtr) priv;
+    G_OBJECT_CLASS(qemu_domain_disk_private_parent_class)->dispose(obj);
 }
 
 static void
-qemuDomainDiskPrivateDispose(void *obj)
+qemuDomainDiskPrivateFinalize(GObject *obj)
 {
-    qemuDomainDiskPrivatePtr priv = obj;
+    qemuDomainDiskPrivatePtr priv = QEMU_DOMAIN_DISK(obj);
 
-    virObjectUnref(priv->migrSource);
     VIR_FREE(priv->qomName);
     VIR_FREE(priv->nodeCopyOnRead);
-    g_clear_object(&priv->blockjob);
+
+    G_OBJECT_CLASS(qemu_domain_disk_private_parent_class)->finalize(obj);
 }
 
-static virClassPtr qemuDomainStorageSourcePrivateClass;
-static void qemuDomainStorageSourcePrivateDispose(void *obj);
+G_DEFINE_TYPE(qemuDomainStorageSourcePrivate, qemu_domain_storage_source_private,
G_TYPE_OBJECT);
+static void qemuDomainStorageSourcePrivateFinalize(GObject *obj);
 
-static int
-qemuDomainStorageSourcePrivateOnceInit(void)
+static void
+qemu_domain_storage_source_private_init(qemuDomainStorageSourcePrivate *priv
G_GNUC_UNUSED)
 {
-    if (!VIR_CLASS_NEW(qemuDomainStorageSourcePrivate, virClassForObject()))
-        return -1;
-
-    return 0;
 }
 
-VIR_ONCE_GLOBAL_INIT(qemuDomainStorageSourcePrivate);
-
-virObjectPtr
-qemuDomainStorageSourcePrivateNew(void)
+static void
+qemu_domain_storage_source_private_class_init(qemuDomainStorageSourcePrivateClass
*klass)
 {
-    qemuDomainStorageSourcePrivatePtr priv;
-
-    if (qemuDomainStorageSourcePrivateInitialize() < 0)
-        return NULL;
+    GObjectClass *obj = G_OBJECT_CLASS(klass);
 
-    if (!(priv = virObjectNew(qemuDomainStorageSourcePrivateClass)))
-        return NULL;
+    obj->finalize = qemuDomainStorageSourcePrivateFinalize;
+}
 
-    return (virObjectPtr) priv;
+GObject *
+qemuDomainStorageSourcePrivateNew(void)
+{
+    return g_object_new(QEMU_TYPE_DOMAIN_STORAGE_SOURCE_PRIVATE, NULL);
 }
 
 
 static void
-qemuDomainStorageSourcePrivateDispose(void *obj)
+qemuDomainStorageSourcePrivateFinalize(GObject *obj)
 {
-    qemuDomainStorageSourcePrivatePtr priv = obj;
+    qemuDomainStorageSourcePrivatePtr priv = QEMU_DOMAIN_STORAGE_SOURCE(obj);
 
     g_clear_pointer(&priv->secinfo, qemuDomainSecretInfoFree);
     g_clear_pointer(&priv->encinfo, qemuDomainSecretInfoFree);
+
+    G_OBJECT_CLASS(qemu_domain_storage_source_private_parent_class)->finalize(obj);
 }
 
 
-static virClassPtr qemuDomainVcpuPrivateClass;
-static void qemuDomainVcpuPrivateDispose(void *obj);
+G_DEFINE_TYPE(qemuDomainVcpuPrivate, qemu_domain_vcpu_private, G_TYPE_OBJECT);
+static void qemuDomainVcpuPrivateFinalize(GObject *obj);
 
-static int
-qemuDomainVcpuPrivateOnceInit(void)
+static void
+qemu_domain_vcpu_private_init(qemuDomainVcpuPrivate *priv G_GNUC_UNUSED)
 {
-    if (!VIR_CLASS_NEW(qemuDomainVcpuPrivate, virClassForObject()))
-        return -1;
-
-    return 0;
 }
 
-VIR_ONCE_GLOBAL_INIT(qemuDomainVcpuPrivate);
-
-static virObjectPtr
-qemuDomainVcpuPrivateNew(void)
+static void
+qemu_domain_vcpu_private_class_init(qemuDomainVcpuPrivateClass *klass)
 {
-    qemuDomainVcpuPrivatePtr priv;
-
-    if (qemuDomainVcpuPrivateInitialize() < 0)
-        return NULL;
+    GObjectClass *obj = G_OBJECT_CLASS(klass);
 
-    if (!(priv = virObjectNew(qemuDomainVcpuPrivateClass)))
-        return NULL;
+    obj->finalize = qemuDomainVcpuPrivateFinalize;
+}
 
-    return (virObjectPtr) priv;
+static GObject *
+qemuDomainVcpuPrivateNew(void)
+{
+    return g_object_new(QEMU_TYPE_DOMAIN_VCPU_PRIVATE, NULL);
 }
 
 
 static void
-qemuDomainVcpuPrivateDispose(void *obj)
+qemuDomainVcpuPrivateFinalize(GObject *obj)
 {
-    qemuDomainVcpuPrivatePtr priv = obj;
+    qemuDomainVcpuPrivatePtr priv = QEMU_DOMAIN_VCPU(obj);
 
     VIR_FREE(priv->type);
     VIR_FREE(priv->alias);
     virJSONValueFree(priv->props);
-    return;
+
+    G_OBJECT_CLASS(qemu_domain_vcpu_private_parent_class)->finalize(obj);
 }
 
 
-static virClassPtr qemuDomainChrSourcePrivateClass;
-static void qemuDomainChrSourcePrivateDispose(void *obj);
+G_DEFINE_TYPE(qemuDomainChrSourcePrivate, qemu_domain_chr_source_private,
G_TYPE_OBJECT);
+static void qemuDomainChrSourcePrivateFinalize(GObject *obj);
 
-static int
-qemuDomainChrSourcePrivateOnceInit(void)
+static void
+qemu_domain_chr_source_private_init(qemuDomainChrSourcePrivate *priv G_GNUC_UNUSED)
 {
-    if (!VIR_CLASS_NEW(qemuDomainChrSourcePrivate, virClassForObject()))
-        return -1;
-
-    return 0;
 }
 
-VIR_ONCE_GLOBAL_INIT(qemuDomainChrSourcePrivate);
-
-static virObjectPtr
-qemuDomainChrSourcePrivateNew(void)
+static void
+qemu_domain_chr_source_private_class_init(qemuDomainChrSourcePrivateClass *klass)
 {
-    qemuDomainChrSourcePrivatePtr priv;
-
-    if (qemuDomainChrSourcePrivateInitialize() < 0)
-        return NULL;
+    GObjectClass *obj = G_OBJECT_CLASS(klass);
 
-    if (!(priv = virObjectNew(qemuDomainChrSourcePrivateClass)))
-        return NULL;
+    obj->finalize = qemuDomainChrSourcePrivateFinalize;
+}
 
-    return (virObjectPtr) priv;
+static GObject *
+qemuDomainChrSourcePrivateNew(void)
+{
+    return g_object_new(QEMU_TYPE_DOMAIN_CHR_SOURCE_PRIVATE, NULL);
 }
 
 
 static void
-qemuDomainChrSourcePrivateDispose(void *obj)
+qemuDomainChrSourcePrivateFinalize(GObject *obj)
 {
-    qemuDomainChrSourcePrivatePtr priv = obj;
+    qemuDomainChrSourcePrivatePtr priv = QEMU_DOMAIN_CHR_SOURCE(obj);
 
     g_clear_pointer(&priv->secinfo, qemuDomainSecretInfoFree);
+
+    G_OBJECT_CLASS(qemu_domain_chr_source_private_parent_class)->finalize(obj);
 }
 
 
-static virClassPtr qemuDomainVsockPrivateClass;
-static void qemuDomainVsockPrivateDispose(void *obj);
+G_DEFINE_TYPE(qemuDomainVsockPrivate, qemu_domain_vsock_private, G_TYPE_OBJECT);
+static void qemuDomainVsockPrivateFinalize(GObject *obj);
 
-static int
-qemuDomainVsockPrivateOnceInit(void)
+static void
+qemu_domain_vsock_private_init(qemuDomainVsockPrivate *priv)
 {
-    if (!VIR_CLASS_NEW(qemuDomainVsockPrivate, virClassForObject()))
-        return -1;
-
-    return 0;
+    priv->vhostfd = -1;
 }
 
-VIR_ONCE_GLOBAL_INIT(qemuDomainVsockPrivate);
-
-static virObjectPtr
-qemuDomainVsockPrivateNew(void)
+static void
+qemu_domain_vsock_private_class_init(qemuDomainVsockPrivateClass *klass)
 {
-    qemuDomainVsockPrivatePtr priv;
-
-    if (qemuDomainVsockPrivateInitialize() < 0)
-        return NULL;
-
-    if (!(priv = virObjectNew(qemuDomainVsockPrivateClass)))
-        return NULL;
+    GObjectClass *obj = G_OBJECT_CLASS(klass);
 
-    priv->vhostfd = -1;
+    obj->finalize = qemuDomainVsockPrivateFinalize;
+}
 
-    return (virObjectPtr) priv;
+static GObject *
+qemuDomainVsockPrivateNew(void)
+{
+    return g_object_new(QEMU_TYPE_DOMAIN_VSOCK_PRIVATE, NULL);
 }
 
 
 static void
-qemuDomainVsockPrivateDispose(void *obj G_GNUC_UNUSED)
+qemuDomainVsockPrivateFinalize(GObject *obj)
 {
-    qemuDomainVsockPrivatePtr priv = obj;
+    qemuDomainVsockPrivatePtr priv = QEMU_DOMAIN_VSOCK(obj);
 
     VIR_FORCE_CLOSE(priv->vhostfd);
+
+    G_OBJECT_CLASS(qemu_domain_vsock_private_parent_class)->finalize(obj);
 }
 
 
-static virClassPtr qemuDomainGraphicsPrivateClass;
-static void qemuDomainGraphicsPrivateDispose(void *obj);
+G_DEFINE_TYPE(qemuDomainGraphicsPrivate, qemu_domain_graphics_private, G_TYPE_OBJECT);
+static void qemuDomainGraphicsPrivateFinalize(GObject *obj);
 
-static int
-qemuDomainGraphicsPrivateOnceInit(void)
+static void
+qemu_domain_graphics_private_init(qemuDomainGraphicsPrivate *priv G_GNUC_UNUSED)
 {
-    if (!VIR_CLASS_NEW(qemuDomainGraphicsPrivate, virClassForObject()))
-        return -1;
-
-    return 0;
 }
 
-VIR_ONCE_GLOBAL_INIT(qemuDomainGraphicsPrivate);
-
-static virObjectPtr
-qemuDomainGraphicsPrivateNew(void)
+static void
+qemu_domain_graphics_private_class_init(qemuDomainGraphicsPrivateClass *klass)
 {
-    qemuDomainGraphicsPrivatePtr priv;
-
-    if (qemuDomainGraphicsPrivateInitialize() < 0)
-        return NULL;
+    GObjectClass *obj = G_OBJECT_CLASS(klass);
 
-    if (!(priv = virObjectNew(qemuDomainGraphicsPrivateClass)))
-        return NULL;
+    obj->finalize = qemuDomainGraphicsPrivateFinalize;
+}
 
-    return (virObjectPtr) priv;
+static GObject *
+qemuDomainGraphicsPrivateNew(void)
+{
+    return g_object_new(QEMU_TYPE_DOMAIN_GRAPHICS_PRIVATE, NULL);
 }
 
 
 static void
-qemuDomainGraphicsPrivateDispose(void *obj)
+qemuDomainGraphicsPrivateFinalize(GObject *obj)
 {
-    qemuDomainGraphicsPrivatePtr priv = obj;
+    qemuDomainGraphicsPrivatePtr priv = QEMU_DOMAIN_GRAPHICS(obj);
 
     VIR_FREE(priv->tlsAlias);
     g_clear_pointer(&priv->secinfo, qemuDomainSecretInfoFree);
-}
 
+    G_OBJECT_CLASS(qemu_domain_graphics_private_parent_class)->finalize(obj);
+}
 
-static virClassPtr qemuDomainNetworkPrivateClass;
-static void qemuDomainNetworkPrivateDispose(void *obj);
 
+G_DEFINE_TYPE(qemuDomainNetworkPrivate, qemu_domain_network_private, G_TYPE_OBJECT);
+static void qemuDomainNetworkPrivateFinalize(GObject *obj);
 
-static int
-qemuDomainNetworkPrivateOnceInit(void)
+static void
+qemu_domain_network_private_init(qemuDomainNetworkPrivate *priv G_GNUC_UNUSED)
 {
-    if (!VIR_CLASS_NEW(qemuDomainNetworkPrivate, virClassForObject()))
-        return -1;
-
-    return 0;
 }
 
+static void
+qemu_domain_network_private_class_init(qemuDomainNetworkPrivateClass *klass)
+{
+    GObjectClass *obj = G_OBJECT_CLASS(klass);
 
-VIR_ONCE_GLOBAL_INIT(qemuDomainNetworkPrivate);
+    obj->finalize = qemuDomainNetworkPrivateFinalize;
+}
 
 
-static virObjectPtr
+static GObject *
 qemuDomainNetworkPrivateNew(void)
 {
-    qemuDomainNetworkPrivatePtr priv;
-
-    if (qemuDomainNetworkPrivateInitialize() < 0)
-        return NULL;
-
-    if (!(priv = virObjectNew(qemuDomainNetworkPrivateClass)))
-        return NULL;
-
-    return (virObjectPtr) priv;
+    return g_object_new(QEMU_TYPE_DOMAIN_NETWORK_PRIVATE, NULL);
 }
 
 
 static void
-qemuDomainNetworkPrivateDispose(void *obj G_GNUC_UNUSED)
+qemuDomainNetworkPrivateFinalize(GObject *obj)
 {
-    qemuDomainNetworkPrivatePtr priv = obj;
+    qemuDomainNetworkPrivatePtr priv = QEMU_DOMAIN_NETWORK(obj);
 
     qemuSlirpFree(priv->slirp);
-}
 
+    G_OBJECT_CLASS(qemu_domain_network_private_parent_class)->finalize(obj);
+}
 
-static virClassPtr qemuDomainFSPrivateClass;
-static void qemuDomainFSPrivateDispose(void *obj);
 
+G_DEFINE_TYPE(qemuDomainFSPrivate, qemu_domain_fs_private, G_TYPE_OBJECT);
+static void qemuDomainFSPrivateFinalize(GObject *obj);
 
-static int
-qemuDomainFSPrivateOnceInit(void)
+static void
+qemu_domain_fs_private_init(qemuDomainFSPrivate *priv G_GNUC_UNUSED)
 {
-    if (!VIR_CLASS_NEW(qemuDomainFSPrivate, virClassForObject()))
-        return -1;
-
-    return 0;
 }
 
+static void
+qemu_domain_fs_private_class_init(qemuDomainFSPrivateClass *klass)
+{
+    GObjectClass *obj = G_OBJECT_CLASS(klass);
 
-VIR_ONCE_GLOBAL_INIT(qemuDomainFSPrivate);
-
+    obj->finalize = qemuDomainFSPrivateFinalize;
+}
 
-static virObjectPtr
+static GObject *
 qemuDomainFSPrivateNew(void)
 {
-    qemuDomainFSPrivatePtr priv;
-
-    if (qemuDomainFSPrivateInitialize() < 0)
-        return NULL;
-
-    if (!(priv = virObjectNew(qemuDomainFSPrivateClass)))
-        return NULL;
-
-    return (virObjectPtr) priv;
+    return g_object_new(QEMU_TYPE_DOMAIN_FS_PRIVATE, NULL);
 }
 
 
 static void
-qemuDomainFSPrivateDispose(void *obj)
+qemuDomainFSPrivateFinalize(GObject *obj)
 {
-    qemuDomainFSPrivatePtr priv = obj;
+    qemuDomainFSPrivatePtr priv = QEMU_DOMAIN_FS(obj);
 
     g_free(priv->vhostuser_fs_sock);
+
+    G_OBJECT_CLASS(qemu_domain_fs_private_parent_class)->finalize(obj);
 }
 
-static virClassPtr qemuDomainVideoPrivateClass;
-static void qemuDomainVideoPrivateDispose(void *obj);
+G_DEFINE_TYPE(qemuDomainVideoPrivate, qemu_domain_video_private, G_TYPE_OBJECT);
+static void qemuDomainVideoPrivateFinalize(GObject *obj);
 
+static void
+qemu_domain_video_private_init(qemuDomainVideoPrivate *priv)
+{
+    priv->vhost_user_fd = -1;
+}
 
-static int
-qemuDomainVideoPrivateOnceInit(void)
+static void
+qemu_domain_video_private_class_init(qemuDomainVideoPrivateClass *klass)
 {
-    if (!VIR_CLASS_NEW(qemuDomainVideoPrivate, virClassForObject()))
-        return -1;
+    GObjectClass *obj = G_OBJECT_CLASS(klass);
 
-    return 0;
+    obj->finalize = qemuDomainVideoPrivateFinalize;
 }
 
-VIR_ONCE_GLOBAL_INIT(qemuDomainVideoPrivate);
 
-
-static virObjectPtr
+static GObject *
 qemuDomainVideoPrivateNew(void)
 {
-    qemuDomainVideoPrivatePtr priv;
-
-    if (qemuDomainVideoPrivateInitialize() < 0)
-        return NULL;
-
-    if (!(priv = virObjectNew(qemuDomainVideoPrivateClass)))
-        return NULL;
-
-    priv->vhost_user_fd = -1;
-
-    return (virObjectPtr) priv;
+    return g_object_new(QEMU_TYPE_DOMAIN_VIDEO_PRIVATE, NULL);
 }
 
 
 static void
-qemuDomainVideoPrivateDispose(void *obj)
+qemuDomainVideoPrivateFinalize(GObject *obj)
 {
-    qemuDomainVideoPrivatePtr priv = obj;
+    qemuDomainVideoPrivatePtr priv = QEMU_DOMAIN_VIDEO(obj);
 
     VIR_FORCE_CLOSE(priv->vhost_user_fd);
+
+    G_OBJECT_CLASS(qemu_domain_video_private_parent_class)->finalize(obj);
 }
 
 
diff --git a/src/qemu/qemu_domain.h b/src/qemu/qemu_domain.h
index cf19f4d101..7dbd3ffc69 100644
--- a/src/qemu/qemu_domain.h
+++ b/src/qemu/qemu_domain.h
@@ -433,13 +433,8 @@ struct _qemuDomainObjPrivate {
 #define QEMU_DOMAIN_PRIVATE(vm) \
     ((qemuDomainObjPrivatePtr) (vm)->privateData)
 
-#define QEMU_DOMAIN_DISK_PRIVATE(disk) \
-    ((qemuDomainDiskPrivatePtr) (disk)->privateData)
-
-typedef struct _qemuDomainDiskPrivate qemuDomainDiskPrivate;
-typedef qemuDomainDiskPrivate *qemuDomainDiskPrivatePtr;
 struct _qemuDomainDiskPrivate {
-    virObject parent;
+    GObject parent;
 
     /* ideally we want a smarter way to interlock block jobs on single qemu disk
      * in the future, but for now we just disallow any concurrent job on a
@@ -457,13 +452,20 @@ struct _qemuDomainDiskPrivate {
     char *nodeCopyOnRead; /* nodename of the disk-wide copy-on-read blockdev layer */
 };
 
-#define QEMU_DOMAIN_STORAGE_SOURCE_PRIVATE(src) \
-    ((qemuDomainStorageSourcePrivatePtr) (src)->privateData)
+#define QEMU_TYPE_DOMAIN_DISK_PRIVATE qemu_domain_disk_private_get_type()
+G_DECLARE_FINAL_TYPE(qemuDomainDiskPrivate,
+                     qemu_domain_disk_private,
+                     QEMU,
+                     DOMAIN_DISK,
+                     GObject);
+typedef qemuDomainDiskPrivate *qemuDomainDiskPrivatePtr;
+
+#define QEMU_DOMAIN_DISK_PRIVATE(disk) \
+    ((qemuDomainDiskPrivatePtr) (disk)->privateData)
+
 
-typedef struct _qemuDomainStorageSourcePrivate qemuDomainStorageSourcePrivate;
-typedef qemuDomainStorageSourcePrivate *qemuDomainStorageSourcePrivatePtr;
 struct _qemuDomainStorageSourcePrivate {
-    virObject parent;
+    GObject parent;
 
     /* data required for authentication to the storage source */
     qemuDomainSecretInfoPtr secinfo;
@@ -475,12 +477,23 @@ struct _qemuDomainStorageSourcePrivate {
     qemuDomainSecretInfoPtr httpcookie;
 };
 
-virObjectPtr qemuDomainStorageSourcePrivateNew(void);
+#define QEMU_TYPE_DOMAIN_STORAGE_SOURCE_PRIVATE
qemu_domain_storage_source_private_get_type()
+G_DECLARE_FINAL_TYPE(qemuDomainStorageSourcePrivate,
+                     qemu_domain_storage_source_private,
+                     QEMU,
+                     DOMAIN_STORAGE_SOURCE,
+                     GObject);
+typedef qemuDomainStorageSourcePrivate *qemuDomainStorageSourcePrivatePtr;
+
+#define QEMU_DOMAIN_STORAGE_SOURCE_PRIVATE(src) \
+    ((qemuDomainStorageSourcePrivatePtr) (src)->privateData)
+
+
+GObject *qemuDomainStorageSourcePrivateNew(void);
+
 
-typedef struct _qemuDomainVcpuPrivate qemuDomainVcpuPrivate;
-typedef qemuDomainVcpuPrivate *qemuDomainVcpuPrivatePtr;
 struct _qemuDomainVcpuPrivate {
-    virObject parent;
+    GObject parent;
 
     pid_t tid; /* vcpu thread id */
     int enable_id; /* order in which the vcpus were enabled in qemu */
@@ -500,6 +513,14 @@ struct _qemuDomainVcpuPrivate {
     int vcpus;
 };
 
+#define QEMU_TYPE_DOMAIN_VCPU_PRIVATE qemu_domain_vcpu_private_get_type()
+G_DECLARE_FINAL_TYPE(qemuDomainVcpuPrivate,
+                     qemu_domain_vcpu_private,
+                     QEMU,
+                     DOMAIN_VCPU,
+                     GObject);
+typedef qemuDomainVcpuPrivate *qemuDomainVcpuPrivatePtr;
+
 #define QEMU_DOMAIN_VCPU_PRIVATE(vcpu) \
     ((qemuDomainVcpuPrivatePtr) (vcpu)->privateData)
 
@@ -513,77 +534,113 @@ struct qemuDomainDiskInfo {
     char *nodename;
 };
 
-#define QEMU_DOMAIN_CHR_SOURCE_PRIVATE(dev) \
-    ((qemuDomainChrSourcePrivatePtr) (dev)->privateData)
-
-typedef struct _qemuDomainChrSourcePrivate qemuDomainChrSourcePrivate;
-typedef qemuDomainChrSourcePrivate *qemuDomainChrSourcePrivatePtr;
 struct _qemuDomainChrSourcePrivate {
-    virObject parent;
+    GObject parent;
 
     /* for char devices using secret
      * NB: *not* to be written to qemu domain object XML */
     qemuDomainSecretInfoPtr secinfo;
 };
 
+#define QEMU_TYPE_DOMAIN_CHR_SOURCE_PRIVATE qemu_domain_chr_source_private_get_type()
+G_DECLARE_FINAL_TYPE(qemuDomainChrSourcePrivate,
+                     qemu_domain_chr_source_private,
+                     QEMU,
+                     DOMAIN_CHR_SOURCE,
+                     GObject);
+typedef qemuDomainChrSourcePrivate *qemuDomainChrSourcePrivatePtr;
+
+#define QEMU_DOMAIN_CHR_SOURCE_PRIVATE(dev) \
+    ((qemuDomainChrSourcePrivatePtr) (dev)->privateData)
+
 
-typedef struct _qemuDomainVsockPrivate qemuDomainVsockPrivate;
-typedef qemuDomainVsockPrivate *qemuDomainVsockPrivatePtr;
 struct _qemuDomainVsockPrivate {
-    virObject parent;
+    GObject parent;
 
     int vhostfd;
 };
 
+#define QEMU_TYPE_DOMAIN_VSOCK_PRIVATE qemu_domain_vsock_private_get_type()
+G_DECLARE_FINAL_TYPE(qemuDomainVsockPrivate,
+                     qemu_domain_vsock_private,
+                     QEMU,
+                     DOMAIN_VSOCK,
+                     GObject);
+typedef qemuDomainVsockPrivate *qemuDomainVsockPrivatePtr;
 
-#define QEMU_DOMAIN_VIDEO_PRIVATE(dev) \
-    ((qemuDomainVideoPrivatePtr) (dev)->privateData)
 
-typedef struct _qemuDomainVideoPrivate qemuDomainVideoPrivate;
-typedef qemuDomainVideoPrivate *qemuDomainVideoPrivatePtr;
 struct _qemuDomainVideoPrivate {
-    virObject parent;
+    GObject parent;
 
     int vhost_user_fd;
 };
 
+#define QEMU_TYPE_DOMAIN_VIDEO_PRIVATE qemu_domain_video_private_get_type()
+G_DECLARE_FINAL_TYPE(qemuDomainVideoPrivate,
+                     qemu_domain_video_private,
+                     QEMU,
+                     DOMAIN_VIDEO,
+                     GObject);
+typedef qemuDomainVideoPrivate *qemuDomainVideoPrivatePtr;
+
+#define QEMU_DOMAIN_VIDEO_PRIVATE(dev) \
+    ((qemuDomainVideoPrivatePtr) (dev)->privateData)
 
-#define QEMU_DOMAIN_GRAPHICS_PRIVATE(dev) \
-    ((qemuDomainGraphicsPrivatePtr) (dev)->privateData)
 
-typedef struct _qemuDomainGraphicsPrivate qemuDomainGraphicsPrivate;
-typedef qemuDomainGraphicsPrivate *qemuDomainGraphicsPrivatePtr;
 struct _qemuDomainGraphicsPrivate {
-    virObject parent;
+    GObject parent;
 
     char *tlsAlias;
     qemuDomainSecretInfoPtr secinfo;
 };
 
+#define QEMU_TYPE_DOMAIN_GRAPHICS_PRIVATE qemu_domain_graphics_private_get_type()
+G_DECLARE_FINAL_TYPE(qemuDomainGraphicsPrivate,
+                     qemu_domain_graphics_private,
+                     QEMU,
+                     DOMAIN_GRAPHICS,
+                     GObject);
+typedef qemuDomainGraphicsPrivate *qemuDomainGraphicsPrivatePtr;
+
+#define QEMU_DOMAIN_GRAPHICS_PRIVATE(dev) \
+    ((qemuDomainGraphicsPrivatePtr) (dev)->privateData)
 
-#define QEMU_DOMAIN_NETWORK_PRIVATE(dev) \
-    ((qemuDomainNetworkPrivatePtr) (dev)->privateData)
 
-typedef struct _qemuDomainNetworkPrivate qemuDomainNetworkPrivate;
-typedef qemuDomainNetworkPrivate *qemuDomainNetworkPrivatePtr;
 struct _qemuDomainNetworkPrivate {
-    virObject parent;
+    GObject parent;
 
     qemuSlirpPtr slirp;
 };
 
+#define QEMU_TYPE_DOMAIN_NETWORK_PRIVATE qemu_domain_network_private_get_type()
+G_DECLARE_FINAL_TYPE(qemuDomainNetworkPrivate,
+                     qemu_domain_network_private,
+                     QEMU,
+                     DOMAIN_NETWORK,
+                     GObject);
+typedef qemuDomainNetworkPrivate *qemuDomainNetworkPrivatePtr;
+
+#define QEMU_DOMAIN_NETWORK_PRIVATE(dev) \
+    ((qemuDomainNetworkPrivatePtr) (dev)->privateData)
 
-#define QEMU_DOMAIN_FS_PRIVATE(dev) \
-    ((qemuDomainFSPrivatePtr) (dev)->privateData)
 
-typedef struct _qemuDomainFSPrivate qemuDomainFSPrivate;
-typedef qemuDomainFSPrivate *qemuDomainFSPrivatePtr;
 struct _qemuDomainFSPrivate {
-    virObject parent;
+    GObject parent;
 
     char *vhostuser_fs_sock;
 };
 
+#define QEMU_TYPE_DOMAIN_FS_PRIVATE qemu_domain_fs_private_get_type()
+G_DECLARE_FINAL_TYPE(qemuDomainFSPrivate,
+                     qemu_domain_fs_private,
+                     QEMU,
+                     DOMAIN_FS,
+                     GObject);
+typedef qemuDomainFSPrivate *qemuDomainFSPrivatePtr;
+
+#define QEMU_DOMAIN_FS_PRIVATE(dev) \
+    ((qemuDomainFSPrivatePtr) (dev)->privateData)
+
 
 typedef enum {
     QEMU_PROCESS_EVENT_WATCHDOG = 0,
diff --git a/src/util/virstoragefile.c b/src/util/virstoragefile.c
index ffc8bdb344..0f26a81391 100644
--- a/src/util/virstoragefile.c
+++ b/src/util/virstoragefile.c
@@ -2717,7 +2717,7 @@ virStorageSourceClear(virStorageSourcePtr def)
 
     virStorageNetHostDefFree(def->nhosts, def->hosts);
     virStorageAuthDefFree(def->auth);
-    virObjectUnref(def->privateData);
+    g_clear_object(&def->privateData);
 
     VIR_FREE(def->nodestorage);
     VIR_FREE(def->nodeformat);
diff --git a/src/util/virstoragefile.h b/src/util/virstoragefile.h
index 7939c09cd5..a744bcbf5c 100644
--- a/src/util/virstoragefile.h
+++ b/src/util/virstoragefile.h
@@ -30,6 +30,7 @@
 #include "virsecret.h"
 #include "virenum.h"
 #include "virpci.h"
+#include <glib-object.h>
 
 /* Minimum header size required to probe all known formats with
  * virStorageFileProbeFormat, or obtain metadata from a known format.
@@ -304,7 +305,7 @@ struct _virStorageSource {
 
     virStorageSourceInitiatorDef initiator;
 
-    virObjectPtr privateData;
+    GObject *privateData;
 
     int format; /* virStorageFileFormat in domain backing chains, but
                  * pool-specific enum for storage volumes */
-- 
2.25.3



    

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

[PATCH v2 38/40] conf: convert virDomain*Private to GObject