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