[mirror_qemu.git] / backends / dbus-vmstate.c

/*
 * QEMU dbus-vmstate
 *
 * Copyright (C) 2019 Red Hat Inc
 *
 * Authors:
 *  Marc-André Lureau <marcandre.lureau@redhat.com>
 *
 * This work is licensed under the terms of the GNU GPL, version 2 or later.
 * See the COPYING file in the top-level directory.
 */

#include "qemu/osdep.h"
#include "qemu/units.h"
#include "qemu/dbus.h"
#include "qemu/error-report.h"
#include "qapi/error.h"
#include "qom/object_interfaces.h"
#include "qapi/qmp/qerror.h"
#include "migration/vmstate.h"
#include "trace.h"
#include "qom/object.h"

typedef struct DBusVMState DBusVMState;
typedef struct DBusVMStateClass DBusVMStateClass;

#define TYPE_DBUS_VMSTATE "dbus-vmstate"
#define DBUS_VMSTATE(obj)                                \
    OBJECT_CHECK(DBusVMState, (obj), TYPE_DBUS_VMSTATE)
#define DBUS_VMSTATE_GET_CLASS(obj)                              \
    OBJECT_GET_CLASS(DBusVMStateClass, (obj), TYPE_DBUS_VMSTATE)
#define DBUS_VMSTATE_CLASS(klass)                                    \
    OBJECT_CLASS_CHECK(DBusVMStateClass, (klass), TYPE_DBUS_VMSTATE)

struct DBusVMStateClass {
    ObjectClass parent_class;
};

struct DBusVMState {
    Object parent;

    GDBusConnection *bus;
    char *dbus_addr;
    char *id_list;

    uint32_t data_size;
    uint8_t *data;
};

static const GDBusPropertyInfo vmstate_property_info[] = {
    { -1, (char *) "Id", (char *) "s",
      G_DBUS_PROPERTY_INFO_FLAGS_READABLE, NULL },
};

static const GDBusPropertyInfo * const vmstate_property_info_pointers[] = {
    &vmstate_property_info[0],
    NULL
};

static const GDBusInterfaceInfo vmstate1_interface_info = {
    -1,
    (char *) "org.qemu.VMState1",
    (GDBusMethodInfo **) NULL,
    (GDBusSignalInfo **) NULL,
    (GDBusPropertyInfo **) &vmstate_property_info_pointers,
    NULL,
};

#define DBUS_VMSTATE_SIZE_LIMIT (1 * MiB)

static GHashTable *
get_id_list_set(DBusVMState *self)
{
    g_auto(GStrv) ids = NULL;
    g_autoptr(GHashTable) set = NULL;
    int i;

    if (!self->id_list) {
        return NULL;
    }

    ids = g_strsplit(self->id_list, ",", -1);
    set = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);
    for (i = 0; ids[i]; i++) {
        g_hash_table_add(set, ids[i]);
        ids[i] = NULL;
    }

    return g_steal_pointer(&set);
}

static GHashTable *
dbus_get_proxies(DBusVMState *self, GError **err)
{
    g_autoptr(GHashTable) proxies = NULL;
    g_autoptr(GHashTable) ids = NULL;
    g_auto(GStrv) names = NULL;
    Error *error = NULL;
    size_t i;

    ids = get_id_list_set(self);
    proxies = g_hash_table_new_full(g_str_hash, g_str_equal,
                                    g_free, g_object_unref);

    names = qemu_dbus_get_queued_owners(self->bus, "org.qemu.VMState1", &error);
    if (!names) {
        g_set_error(err, G_IO_ERROR, G_IO_ERROR_FAILED, "%s",
                    error_get_pretty(error));
        error_free(error);
        return NULL;
    }

    for (i = 0; names[i]; i++) {
        g_autoptr(GDBusProxy) proxy = NULL;
        g_autoptr(GVariant) result = NULL;
        g_autofree char *id = NULL;
        size_t size;

        proxy = g_dbus_proxy_new_sync(self->bus, G_DBUS_PROXY_FLAGS_NONE,
                    (GDBusInterfaceInfo *) &vmstate1_interface_info,
                    names[i],
                    "/org/qemu/VMState1",
                    "org.qemu.VMState1",
                    NULL, err);
        if (!proxy) {
            return NULL;
        }

        result = g_dbus_proxy_get_cached_property(proxy, "Id");
        if (!result) {
            g_set_error_literal(err, G_IO_ERROR, G_IO_ERROR_FAILED,
                                "VMState Id property is missing.");
            return NULL;
        }

        id = g_variant_dup_string(result, &size);
        if (ids && !g_hash_table_remove(ids, id)) {
            g_clear_pointer(&id, g_free);
            g_clear_object(&proxy);
            continue;
        }
        if (size == 0 || size >= 256) {
            g_set_error(err, G_IO_ERROR, G_IO_ERROR_FAILED,
                        "VMState Id '%s' is invalid.", id);
            return NULL;
        }

        if (!g_hash_table_insert(proxies, id, proxy)) {
            g_set_error(err, G_IO_ERROR, G_IO_ERROR_FAILED,
                        "Duplicated VMState Id '%s'", id);
            return NULL;
        }
        id = NULL;
        proxy = NULL;

        g_clear_pointer(&result, g_variant_unref);
    }

    if (ids) {
        g_autofree char **left = NULL;

        left = (char **)g_hash_table_get_keys_as_array(ids, NULL);
        if (*left) {
            g_autofree char *leftids = g_strjoinv(",", left);
            g_set_error(err, G_IO_ERROR, G_IO_ERROR_FAILED,
                        "Required VMState Id are missing: %s", leftids);
            return NULL;
        }
    }

    return g_steal_pointer(&proxies);
}

static int
dbus_load_state_proxy(GDBusProxy *proxy, const uint8_t *data, size_t size)
{
    g_autoptr(GError) err = NULL;
    g_autoptr(GVariant) result = NULL;
    g_autoptr(GVariant) value = NULL;

    value = g_variant_new_fixed_array(G_VARIANT_TYPE_BYTE,
                                      data, size, sizeof(char));
    result = g_dbus_proxy_call_sync(proxy, "Load",
                                    g_variant_new("(@ay)",
                                                  g_steal_pointer(&value)),
                                    G_DBUS_CALL_FLAGS_NO_AUTO_START,
                                    -1, NULL, &err);
    if (!result) {
        error_report("%s: Failed to Load: %s", __func__, err->message);
        return -1;
    }

    return 0;
}

static int dbus_vmstate_post_load(void *opaque, int version_id)
{
    DBusVMState *self = DBUS_VMSTATE(opaque);
    g_autoptr(GInputStream) m = NULL;
    g_autoptr(GDataInputStream) s = NULL;
    g_autoptr(GError) err = NULL;
    g_autoptr(GHashTable) proxies = NULL;
    uint32_t nelem;

    trace_dbus_vmstate_post_load(version_id);

    proxies = dbus_get_proxies(self, &err);
    if (!proxies) {
        error_report("%s: Failed to get proxies: %s", __func__, err->message);
        return -1;
    }

    m = g_memory_input_stream_new_from_data(self->data, self->data_size, NULL);
    s = g_data_input_stream_new(m);
    g_data_input_stream_set_byte_order(s, G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN);

    nelem = g_data_input_stream_read_uint32(s, NULL, &err);
    if (err) {
        goto error;
    }

    while (nelem > 0) {
        GDBusProxy *proxy = NULL;
        uint32_t len;
        gsize bytes_read, avail;
        char id[256];

        len = g_data_input_stream_read_uint32(s, NULL, &err);
        if (err) {
            goto error;
        }
        if (len >= 256) {
            error_report("%s: Invalid DBus vmstate proxy name %u",
                         __func__, len);
            return -1;
        }
        if (!g_input_stream_read_all(G_INPUT_STREAM(s), id, len,
                                     &bytes_read, NULL, &err)) {
            goto error;
        }
        g_return_val_if_fail(bytes_read == len, -1);
        id[len] = 0;

        trace_dbus_vmstate_loading(id);

        proxy = g_hash_table_lookup(proxies, id);
        if (!proxy) {
            error_report("%s: Failed to find proxy Id '%s'", __func__, id);
            return -1;
        }

        len = g_data_input_stream_read_uint32(s, NULL, &err);
        avail = g_buffered_input_stream_get_available(
            G_BUFFERED_INPUT_STREAM(s));

        if (len > DBUS_VMSTATE_SIZE_LIMIT || len > avail) {
            error_report("%s: Invalid vmstate size: %u", __func__, len);
            return -1;
        }

        if (dbus_load_state_proxy(proxy,
                g_buffered_input_stream_peek_buffer(G_BUFFERED_INPUT_STREAM(s),
                                                    NULL),
                len) < 0) {
            error_report("%s: Failed to restore Id '%s'", __func__, id);
            return -1;
        }

        if (!g_seekable_seek(G_SEEKABLE(s), len, G_SEEK_CUR, NULL, &err)) {
            goto error;
        }

        nelem -= 1;
    }

    return 0;

error:
    error_report("%s: Failed to read from stream: %s", __func__, err->message);
    return -1;
}

static void
dbus_save_state_proxy(gpointer key,
                      gpointer value,
                      gpointer user_data)
{
    GDataOutputStream *s = user_data;
    const char *id = key;
    GDBusProxy *proxy = value;
    g_autoptr(GVariant) result = NULL;
    g_autoptr(GVariant) child = NULL;
    g_autoptr(GError) err = NULL;
    const uint8_t *data;
    gsize size;

    trace_dbus_vmstate_saving(id);

    result = g_dbus_proxy_call_sync(proxy, "Save",
                                    NULL, G_DBUS_CALL_FLAGS_NO_AUTO_START,
                                    -1, NULL, &err);
    if (!result) {
        error_report("%s: Failed to Save: %s", __func__, err->message);
        return;
    }

    child = g_variant_get_child_value(result, 0);
    data = g_variant_get_fixed_array(child, &size, sizeof(char));
    if (!data) {
        error_report("%s: Failed to Save: not a byte array", __func__);
        return;
    }
    if (size > DBUS_VMSTATE_SIZE_LIMIT) {
        error_report("%s: Too large vmstate data to save: %zu",
                     __func__, (size_t)size);
        return;
    }

    if (!g_data_output_stream_put_uint32(s, strlen(id), NULL, &err) ||
        !g_data_output_stream_put_string(s, id, NULL, &err) ||
        !g_data_output_stream_put_uint32(s, size, NULL, &err) ||
        !g_output_stream_write_all(G_OUTPUT_STREAM(s),
                                   data, size, NULL, NULL, &err)) {
        error_report("%s: Failed to write to stream: %s",
                     __func__, err->message);
    }
}

static int dbus_vmstate_pre_save(void *opaque)
{
    DBusVMState *self = DBUS_VMSTATE(opaque);
    g_autoptr(GOutputStream) m = NULL;
    g_autoptr(GDataOutputStream) s = NULL;
    g_autoptr(GHashTable) proxies = NULL;
    g_autoptr(GError) err = NULL;

    trace_dbus_vmstate_pre_save();

    proxies = dbus_get_proxies(self, &err);
    if (!proxies) {
        error_report("%s: Failed to get proxies: %s", __func__, err->message);
        return -1;
    }

    m = g_memory_output_stream_new_resizable();
    s = g_data_output_stream_new(m);
    g_data_output_stream_set_byte_order(s, G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN);

    if (!g_data_output_stream_put_uint32(s, g_hash_table_size(proxies),
                                         NULL, &err)) {
        error_report("%s: Failed to write to stream: %s",
                     __func__, err->message);
        return -1;
    }

    g_hash_table_foreach(proxies, dbus_save_state_proxy, s);

    if (g_memory_output_stream_get_size(G_MEMORY_OUTPUT_STREAM(m))
        > UINT32_MAX) {
        error_report("%s: DBus vmstate buffer is too large", __func__);
        return -1;
    }

    if (!g_output_stream_close(G_OUTPUT_STREAM(m), NULL, &err)) {
        error_report("%s: Failed to close stream: %s", __func__, err->message);
        return -1;
    }

    g_free(self->data);
    self->data_size =
        g_memory_output_stream_get_size(G_MEMORY_OUTPUT_STREAM(m));
    self->data =
        g_memory_output_stream_steal_data(G_MEMORY_OUTPUT_STREAM(m));

    return 0;
}

static const VMStateDescription dbus_vmstate = {
    .name = TYPE_DBUS_VMSTATE,
    .version_id = 0,
    .pre_save = dbus_vmstate_pre_save,
    .post_load = dbus_vmstate_post_load,
    .fields = (VMStateField[]) {
        VMSTATE_UINT32(data_size, DBusVMState),
        VMSTATE_VBUFFER_ALLOC_UINT32(data, DBusVMState, 0, 0, data_size),
        VMSTATE_END_OF_LIST()
    }
};

static void
dbus_vmstate_complete(UserCreatable *uc, Error **errp)
{
    DBusVMState *self = DBUS_VMSTATE(uc);
    g_autoptr(GError) err = NULL;

    if (!object_resolve_path_type("", TYPE_DBUS_VMSTATE, NULL)) {
        error_setg(errp, "There is already an instance of %s",
                   TYPE_DBUS_VMSTATE);
        return;
    }

    if (!self->dbus_addr) {
        error_setg(errp, QERR_MISSING_PARAMETER, "addr");
        return;
    }

    self->bus = g_dbus_connection_new_for_address_sync(self->dbus_addr,
                    G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT |
                    G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION,
                    NULL, NULL, &err);
    if (err) {
        error_setg(errp, "failed to connect to DBus: '%s'", err->message);
        return;
    }

    if (vmstate_register(VMSTATE_IF(self), VMSTATE_INSTANCE_ID_ANY,
                         &dbus_vmstate, self) < 0) {
        error_setg(errp, "Failed to register vmstate");
    }
}

static void
dbus_vmstate_finalize(Object *o)
{
    DBusVMState *self = DBUS_VMSTATE(o);

    vmstate_unregister(VMSTATE_IF(self), &dbus_vmstate, self);

    g_clear_object(&self->bus);
    g_free(self->dbus_addr);
    g_free(self->id_list);
    g_free(self->data);
}

static char *
get_dbus_addr(Object *o, Error **errp)
{
    DBusVMState *self = DBUS_VMSTATE(o);

    return g_strdup(self->dbus_addr);
}

static void
set_dbus_addr(Object *o, const char *str, Error **errp)
{
    DBusVMState *self = DBUS_VMSTATE(o);

    g_free(self->dbus_addr);
    self->dbus_addr = g_strdup(str);
}

static char *
get_id_list(Object *o, Error **errp)
{
    DBusVMState *self = DBUS_VMSTATE(o);

    return g_strdup(self->id_list);
}

static void
set_id_list(Object *o, const char *str, Error **errp)
{
    DBusVMState *self = DBUS_VMSTATE(o);

    g_free(self->id_list);
    self->id_list = g_strdup(str);
}

static char *
dbus_vmstate_get_id(VMStateIf *vmif)
{
    return g_strdup(TYPE_DBUS_VMSTATE);
}

static void
dbus_vmstate_class_init(ObjectClass *oc, void *data)
{
    UserCreatableClass *ucc = USER_CREATABLE_CLASS(oc);
    VMStateIfClass *vc = VMSTATE_IF_CLASS(oc);

    ucc->complete = dbus_vmstate_complete;
    vc->get_id = dbus_vmstate_get_id;

    object_class_property_add_str(oc, "addr",
                                  get_dbus_addr, set_dbus_addr);
    object_class_property_add_str(oc, "id-list",
                                  get_id_list, set_id_list);
}

static const TypeInfo dbus_vmstate_info = {
    .name = TYPE_DBUS_VMSTATE,
    .parent = TYPE_OBJECT,
    .instance_size = sizeof(DBusVMState),
    .instance_finalize = dbus_vmstate_finalize,
    .class_size = sizeof(DBusVMStateClass),
    .class_init = dbus_vmstate_class_init,
    .interfaces = (InterfaceInfo[]) {
        { TYPE_USER_CREATABLE },
        { TYPE_VMSTATE_IF },
        { }
    }
};

static void
register_types(void)
{
    type_register_static(&dbus_vmstate_info);
}

type_init(register_types);
Commit	Line	Data
5010cec2 MAL	1	/*
	2	* QEMU dbus-vmstate
	3	*
	4	* Copyright (C) 2019 Red Hat Inc
	5	*
	6	* Authors:
	7	* Marc-André Lureau <marcandre.lureau@redhat.com>
	8	*
	9	* This work is licensed under the terms of the GNU GPL, version 2 or later.
	10	* See the COPYING file in the top-level directory.
	11	*/
	12
	13	#include "qemu/osdep.h"
	14	#include "qemu/units.h"
	15	#include "qemu/dbus.h"
	16	#include "qemu/error-report.h"
	17	#include "qapi/error.h"
	18	#include "qom/object_interfaces.h"
	19	#include "qapi/qmp/qerror.h"
	20	#include "migration/vmstate.h"
	21	#include "trace.h"
db1015e9	22	#include "qom/object.h"
5010cec2 MAL	23
	24	typedef struct DBusVMState DBusVMState;
	25	typedef struct DBusVMStateClass DBusVMStateClass;
	26
	27	#define TYPE_DBUS_VMSTATE "dbus-vmstate"
	28	#define DBUS_VMSTATE(obj) \
	29	OBJECT_CHECK(DBusVMState, (obj), TYPE_DBUS_VMSTATE)
	30	#define DBUS_VMSTATE_GET_CLASS(obj) \
	31	OBJECT_GET_CLASS(DBusVMStateClass, (obj), TYPE_DBUS_VMSTATE)
	32	#define DBUS_VMSTATE_CLASS(klass) \
	33	OBJECT_CLASS_CHECK(DBusVMStateClass, (klass), TYPE_DBUS_VMSTATE)
	34
	35	struct DBusVMStateClass {
	36	ObjectClass parent_class;
	37	};
	38
	39	struct DBusVMState {
	40	Object parent;
	41
	42	GDBusConnection *bus;
	43	char *dbus_addr;
	44	char *id_list;
	45
	46	uint32_t data_size;
	47	uint8_t *data;
	48	};
	49
	50	static const GDBusPropertyInfo vmstate_property_info[] = {
	51	{ -1, (char ) "Id", (char ) "s",
	52	G_DBUS_PROPERTY_INFO_FLAGS_READABLE, NULL },
	53	};
	54
	55	static const GDBusPropertyInfo * const vmstate_property_info_pointers[] = {
	56	&vmstate_property_info[0],
	57	NULL
	58	};
	59
	60	static const GDBusInterfaceInfo vmstate1_interface_info = {
	61	-1,
	62	(char *) "org.qemu.VMState1",
	63	(GDBusMethodInfo **) NULL,
	64	(GDBusSignalInfo **) NULL,
	65	(GDBusPropertyInfo **) &vmstate_property_info_pointers,
	66	NULL,
	67	};
	68
	69	#define DBUS_VMSTATE_SIZE_LIMIT (1 * MiB)
	70
	71	static GHashTable *
	72	get_id_list_set(DBusVMState *self)
	73	{
	74	g_auto(GStrv) ids = NULL;
	75	g_autoptr(GHashTable) set = NULL;
	76	int i;
	77
	78	if (!self->id_list) {
	79	return NULL;
	80	}
	81
	82	ids = g_strsplit(self->id_list, ",", -1);
	83	set = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);
	84	for (i = 0; ids[i]; i++) {
	85	g_hash_table_add(set, ids[i]);
	86	ids[i] = NULL;
87	}
88
89	return g_steal_pointer(&set);
90	}
91
92	static GHashTable *
93	dbus_get_proxies(DBusVMState self, GError *err)
94	{
95	g_autoptr(GHashTable) proxies = NULL;
96	g_autoptr(GHashTable) ids = NULL;
97	g_auto(GStrv) names = NULL;
98	Error *error = NULL;
99	size_t i;
100
101	ids = get_id_list_set(self);
102	proxies = g_hash_table_new_full(g_str_hash, g_str_equal,
103	g_free, g_object_unref);
104
105	names = qemu_dbus_get_queued_owners(self->bus, "org.qemu.VMState1", &error);
106	if (!names) {
107	g_set_error(err, G_IO_ERROR, G_IO_ERROR_FAILED, "%s",
108	error_get_pretty(error));
109	error_free(error);
110	return NULL;
111	}
112
113	for (i = 0; names[i]; i++) {
114	g_autoptr(GDBusProxy) proxy = NULL;
115	g_autoptr(GVariant) result = NULL;
116	g_autofree char *id = NULL;
117	size_t size;
118
119	proxy = g_dbus_proxy_new_sync(self->bus, G_DBUS_PROXY_FLAGS_NONE,
120	(GDBusInterfaceInfo *) &vmstate1_interface_info,
121	names[i],
122	"/org/qemu/VMState1",
123	"org.qemu.VMState1",
124	NULL, err);
125	if (!proxy) {
126	return NULL;
127	}
128
129	result = g_dbus_proxy_get_cached_property(proxy, "Id");
130	if (!result) {
131	g_set_error_literal(err, G_IO_ERROR, G_IO_ERROR_FAILED,
132	"VMState Id property is missing.");
133	return NULL;
134	}
135
136	id = g_variant_dup_string(result, &size);
137	if (ids && !g_hash_table_remove(ids, id)) {
138	g_clear_pointer(&id, g_free);
139	g_clear_object(&proxy);
140	continue;
141	}
142	if (size == 0 \|\| size >= 256) {
143	g_set_error(err, G_IO_ERROR, G_IO_ERROR_FAILED,
144	"VMState Id '%s' is invalid.", id);
145	return NULL;
146	}
147
148	if (!g_hash_table_insert(proxies, id, proxy)) {
149	g_set_error(err, G_IO_ERROR, G_IO_ERROR_FAILED,
150	"Duplicated VMState Id '%s'", id);
151	return NULL;
152	}
153	id = NULL;
154	proxy = NULL;
155
156	g_clear_pointer(&result, g_variant_unref);
157	}
158
159	if (ids) {
160	g_autofree char **left = NULL;
161
162	left = (char **)g_hash_table_get_keys_as_array(ids, NULL);
163	if (*left) {
164	g_autofree char *leftids = g_strjoinv(",", left);
165	g_set_error(err, G_IO_ERROR, G_IO_ERROR_FAILED,
166	"Required VMState Id are missing: %s", leftids);
167	return NULL;
168	}
169	}
170
171	return g_steal_pointer(&proxies);
172	}
173
174	static int
175	dbus_load_state_proxy(GDBusProxy proxy, const uint8_t data, size_t size)
176	{
177	g_autoptr(GError) err = NULL;
178	g_autoptr(GVariant) result = NULL;
179	g_autoptr(GVariant) value = NULL;
180
181	value = g_variant_new_fixed_array(G_VARIANT_TYPE_BYTE,
182	data, size, sizeof(char));
183	result = g_dbus_proxy_call_sync(proxy, "Load",
184	g_variant_new("(@ay)",
185	g_steal_pointer(&value)),
186	G_DBUS_CALL_FLAGS_NO_AUTO_START,
187	-1, NULL, &err);
188	if (!result) {
189	error_report("%s: Failed to Load: %s", __func__, err->message);
190	return -1;
191	}
192
193	return 0;
194	}
195
196	static int dbus_vmstate_post_load(void *opaque, int version_id)
197	{
198	DBusVMState *self = DBUS_VMSTATE(opaque);
199	g_autoptr(GInputStream) m = NULL;
200	g_autoptr(GDataInputStream) s = NULL;
201	g_autoptr(GError) err = NULL;
202	g_autoptr(GHashTable) proxies = NULL;
203	uint32_t nelem;
204
205	trace_dbus_vmstate_post_load(version_id);
206
207	proxies = dbus_get_proxies(self, &err);
208	if (!proxies) {
209	error_report("%s: Failed to get proxies: %s", __func__, err->message);
210	return -1;
211	}
212
213	m = g_memory_input_stream_new_from_data(self->data, self->data_size, NULL);
214	s = g_data_input_stream_new(m);
215	g_data_input_stream_set_byte_order(s, G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN);
216
217	nelem = g_data_input_stream_read_uint32(s, NULL, &err);
218	if (err) {
219	goto error;
220	}
221
222	while (nelem > 0) {
223	GDBusProxy *proxy = NULL;
224	uint32_t len;
225	gsize bytes_read, avail;
226	char id[256];
227
228	len = g_data_input_stream_read_uint32(s, NULL, &err);
229	if (err) {
230	goto error;
231	}
232	if (len >= 256) {
233	error_report("%s: Invalid DBus vmstate proxy name %u",
234	__func__, len);
235	return -1;
236	}
237	if (!g_input_stream_read_all(G_INPUT_STREAM(s), id, len,
238	&bytes_read, NULL, &err)) {
239	goto error;
240	}
241	g_return_val_if_fail(bytes_read == len, -1);
242	id[len] = 0;
243
244	trace_dbus_vmstate_loading(id);
245
246	proxy = g_hash_table_lookup(proxies, id);
247	if (!proxy) {
248	error_report("%s: Failed to find proxy Id '%s'", __func__, id);
249	return -1;
250	}
251
252	len = g_data_input_stream_read_uint32(s, NULL, &err);
253	avail = g_buffered_input_stream_get_available(
254	G_BUFFERED_INPUT_STREAM(s));
255
256	if (len > DBUS_VMSTATE_SIZE_LIMIT \|\| len > avail) {
257	error_report("%s: Invalid vmstate size: %u", __func__, len);
258	return -1;
259	}
260
261	if (dbus_load_state_proxy(proxy,
262	g_buffered_input_stream_peek_buffer(G_BUFFERED_INPUT_STREAM(s),
263	NULL),
264	len) < 0) {
265	error_report("%s: Failed to restore Id '%s'", __func__, id);
266	return -1;
267	}
268
269	if (!g_seekable_seek(G_SEEKABLE(s), len, G_SEEK_CUR, NULL, &err)) {
270	goto error;
271	}
272
273	nelem -= 1;
274	}
275
276	return 0;
277
278	error:
279	error_report("%s: Failed to read from stream: %s", __func__, err->message);
280	return -1;
281	}
282
283	static void
284	dbus_save_state_proxy(gpointer key,
285	gpointer value,
286	gpointer user_data)
287	{
288	GDataOutputStream *s = user_data;
289	const char *id = key;
290	GDBusProxy *proxy = value;
291	g_autoptr(GVariant) result = NULL;
292	g_autoptr(GVariant) child = NULL;
293	g_autoptr(GError) err = NULL;
294	const uint8_t *data;
295	gsize size;
296
297	trace_dbus_vmstate_saving(id);
298
299	result = g_dbus_proxy_call_sync(proxy, "Save",
300	NULL, G_DBUS_CALL_FLAGS_NO_AUTO_START,
301	-1, NULL, &err);
302	if (!result) {
303	error_report("%s: Failed to Save: %s", __func__, err->message);
304	return;
305	}
306
307	child = g_variant_get_child_value(result, 0);
308	data = g_variant_get_fixed_array(child, &size, sizeof(char));
309	if (!data) {
310	error_report("%s: Failed to Save: not a byte array", __func__);
311	return;
312	}
313	if (size > DBUS_VMSTATE_SIZE_LIMIT) {
314	error_report("%s: Too large vmstate data to save: %zu",
315	__func__, (size_t)size);
316	return;
317	}
318
319	if (!g_data_output_stream_put_uint32(s, strlen(id), NULL, &err) \|\|
320	!g_data_output_stream_put_string(s, id, NULL, &err) \|\|
321	!g_data_output_stream_put_uint32(s, size, NULL, &err) \|\|
322	!g_output_stream_write_all(G_OUTPUT_STREAM(s),
323	data, size, NULL, NULL, &err)) {
324	error_report("%s: Failed to write to stream: %s",
325	__func__, err->message);
326	}
327	}
328
329	static int dbus_vmstate_pre_save(void *opaque)
330	{
331	DBusVMState *self = DBUS_VMSTATE(opaque);
332	g_autoptr(GOutputStream) m = NULL;
333	g_autoptr(GDataOutputStream) s = NULL;
334	g_autoptr(GHashTable) proxies = NULL;
335	g_autoptr(GError) err = NULL;
336
337	trace_dbus_vmstate_pre_save();
338
339	proxies = dbus_get_proxies(self, &err);
340	if (!proxies) {
341	error_report("%s: Failed to get proxies: %s", __func__, err->message);
342	return -1;
343	}
344
345	m = g_memory_output_stream_new_resizable();
346	s = g_data_output_stream_new(m);
347	g_data_output_stream_set_byte_order(s, G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN);
348
349	if (!g_data_output_stream_put_uint32(s, g_hash_table_size(proxies),
350	NULL, &err)) {
351	error_report("%s: Failed to write to stream: %s",
352	__func__, err->message);
353	return -1;
354	}
355
356	g_hash_table_foreach(proxies, dbus_save_state_proxy, s);
357
358	if (g_memory_output_stream_get_size(G_MEMORY_OUTPUT_STREAM(m))
359	> UINT32_MAX) {
360	error_report("%s: DBus vmstate buffer is too large", __func__);
361	return -1;
362	}
363
364	if (!g_output_stream_close(G_OUTPUT_STREAM(m), NULL, &err)) {
365	error_report("%s: Failed to close stream: %s", __func__, err->message);
366	return -1;
367	}
368
369	g_free(self->data);
370	self->data_size =
371	g_memory_output_stream_get_size(G_MEMORY_OUTPUT_STREAM(m));
372	self->data =
373	g_memory_output_stream_steal_data(G_MEMORY_OUTPUT_STREAM(m));
374
375	return 0;
376	}
377
378	static const VMStateDescription dbus_vmstate = {
379	.name = TYPE_DBUS_VMSTATE,
380	.version_id = 0,
381	.pre_save = dbus_vmstate_pre_save,
382	.post_load = dbus_vmstate_post_load,
383	.fields = (VMStateField[]) {
384	VMSTATE_UINT32(data_size, DBusVMState),
385	VMSTATE_VBUFFER_ALLOC_UINT32(data, DBusVMState, 0, 0, data_size),
386	VMSTATE_END_OF_LIST()
387	}
388	};
389
390	static void
391	dbus_vmstate_complete(UserCreatable uc, Error *errp)
392	{
393	DBusVMState *self = DBUS_VMSTATE(uc);
394	g_autoptr(GError) err = NULL;
395
396	if (!object_resolve_path_type("", TYPE_DBUS_VMSTATE, NULL)) {
397	error_setg(errp, "There is already an instance of %s",
398	TYPE_DBUS_VMSTATE);
399	return;
400	}
401
402	if (!self->dbus_addr) {
403	error_setg(errp, QERR_MISSING_PARAMETER, "addr");
404	return;
405	}
406
407	self->bus = g_dbus_connection_new_for_address_sync(self->dbus_addr,
408	G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT \|
409	G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION,
410	NULL, NULL, &err);
411	if (err) {
412	error_setg(errp, "failed to connect to DBus: '%s'", err->message);
413	return;
414	}
415
1df2c9a2 PX	416	if (vmstate_register(VMSTATE_IF(self), VMSTATE_INSTANCE_ID_ANY,
1df2c9a2 PX	417	&dbus_vmstate, self) < 0) {
5010cec2 MAL	418	error_setg(errp, "Failed to register vmstate");
	419	}
	420	}
	421
	422	static void
	423	dbus_vmstate_finalize(Object *o)
	424	{
	425	DBusVMState *self = DBUS_VMSTATE(o);
	426
	427	vmstate_unregister(VMSTATE_IF(self), &dbus_vmstate, self);
	428
	429	g_clear_object(&self->bus);
	430	g_free(self->dbus_addr);
	431	g_free(self->id_list);
	432	g_free(self->data);
	433	}
	434
	435	static char *
	436	get_dbus_addr(Object o, Error *errp)
	437	{
	438	DBusVMState *self = DBUS_VMSTATE(o);
	439
	440	return g_strdup(self->dbus_addr);
	441	}
	442
	443	static void
	444	set_dbus_addr(Object o, const char str, Error **errp)
	445	{
	446	DBusVMState *self = DBUS_VMSTATE(o);
	447
	448	g_free(self->dbus_addr);
	449	self->dbus_addr = g_strdup(str);
	450	}
	451
	452	static char *
	453	get_id_list(Object o, Error *errp)
	454	{
	455	DBusVMState *self = DBUS_VMSTATE(o);
	456
	457	return g_strdup(self->id_list);
	458	}
	459
	460	static void
	461	set_id_list(Object o, const char str, Error **errp)
	462	{
	463	DBusVMState *self = DBUS_VMSTATE(o);
	464
	465	g_free(self->id_list);
	466	self->id_list = g_strdup(str);
	467	}
	468
	469	static char *
	470	dbus_vmstate_get_id(VMStateIf *vmif)
	471	{
	472	return g_strdup(TYPE_DBUS_VMSTATE);
	473	}
	474
	475	static void
	476	dbus_vmstate_class_init(ObjectClass oc, void data)
	477	{
	478	UserCreatableClass *ucc = USER_CREATABLE_CLASS(oc);
	479	VMStateIfClass *vc = VMSTATE_IF_CLASS(oc);
	480
	481	ucc->complete = dbus_vmstate_complete;
482	vc->get_id = dbus_vmstate_get_id;
483
484	object_class_property_add_str(oc, "addr",
d2623129	485	get_dbus_addr, set_dbus_addr);
5010cec2	486	object_class_property_add_str(oc, "id-list",
d2623129	487	get_id_list, set_id_list);
5010cec2 MAL	488	}
	489
	490	static const TypeInfo dbus_vmstate_info = {
	491	.name = TYPE_DBUS_VMSTATE,
	492	.parent = TYPE_OBJECT,
	493	.instance_size = sizeof(DBusVMState),
	494	.instance_finalize = dbus_vmstate_finalize,
	495	.class_size = sizeof(DBusVMStateClass),
	496	.class_init = dbus_vmstate_class_init,
	497	.interfaces = (InterfaceInfo[]) {
	498	{ TYPE_USER_CREATABLE },
	499	{ TYPE_VMSTATE_IF },
	500	{ }
	501	}
	502	};
	503
	504	static void
	505	register_types(void)
	506	{
	507	type_register_static(&dbus_vmstate_info);
	508	}
	509
	510	type_init(register_types);