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