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