1
2
3
4
5
6
7
8
9
10
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"
26OBJECT_DECLARE_SIMPLE_TYPE(DBusVMState,
27 DBUS_VMSTATE)
28
29
30struct 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
41static const GDBusPropertyInfo vmstate_property_info[] = {
42 { -1, (char *) "Id", (char *) "s",
43 G_DBUS_PROPERTY_INFO_FLAGS_READABLE, NULL },
44};
45
46static const GDBusPropertyInfo * const vmstate_property_info_pointers[] = {
47 &vmstate_property_info[0],
48 NULL
49};
50
51static 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
62static GHashTable *
63get_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
83static GHashTable *
84dbus_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 if (err != NULL && *err != NULL) {
118 warn_report("%s: Failed to create proxy: %s",
119 __func__, (*err)->message);
120 g_clear_error(err);
121 }
122 continue;
123 }
124
125 result = g_dbus_proxy_get_cached_property(proxy, "Id");
126 if (!result) {
127 warn_report("%s: VMState Id property is missing.", __func__);
128 g_clear_object(&proxy);
129 continue;
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
170static int
171dbus_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
192static 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 g_buffered_input_stream_set_buffer_size(G_BUFFERED_INPUT_STREAM(s),
213 DBUS_VMSTATE_SIZE_LIMIT);
214
215 nelem = g_data_input_stream_read_uint32(s, NULL, &err);
216 if (err) {
217 goto error;
218 }
219
220 while (nelem > 0) {
221 GDBusProxy *proxy = NULL;
222 uint32_t len;
223 gsize bytes_read, avail;
224 char id[256];
225
226 len = g_data_input_stream_read_uint32(s, NULL, &err);
227 if (err) {
228 goto error;
229 }
230 if (len >= 256) {
231 error_report("%s: Invalid DBus vmstate proxy name %u",
232 __func__, len);
233 return -1;
234 }
235 if (!g_input_stream_read_all(G_INPUT_STREAM(s), id, len,
236 &bytes_read, NULL, &err)) {
237 goto error;
238 }
239 if (bytes_read != len) {
240 error_report("%s: Short read", __func__);
241 return -1;
242 }
243 id[len] = 0;
244
245 trace_dbus_vmstate_loading(id);
246
247 proxy = g_hash_table_lookup(proxies, id);
248 if (!proxy) {
249 error_report("%s: Failed to find proxy Id '%s'", __func__, id);
250 return -1;
251 }
252
253 len = g_data_input_stream_read_uint32(s, NULL, &err);
254 if (len > DBUS_VMSTATE_SIZE_LIMIT) {
255 error_report("%s: Invalid vmstate size: %u", __func__, len);
256 return -1;
257 }
258
259 g_buffered_input_stream_fill(G_BUFFERED_INPUT_STREAM(s), len, NULL,
260 &err);
261 if (err) {
262 goto error;
263 }
264
265 avail = g_buffered_input_stream_get_available(
266 G_BUFFERED_INPUT_STREAM(s));
267 if (len > avail) {
268 error_report("%s: Not enough data available to load for Id: '%s'. "
269 "Available data size: %zu, Actual vmstate size: %u",
270 __func__, id, avail, len);
271 return -1;
272 }
273
274 if (dbus_load_state_proxy(proxy,
275 g_buffered_input_stream_peek_buffer(G_BUFFERED_INPUT_STREAM(s),
276 NULL),
277 len) < 0) {
278 error_report("%s: Failed to restore Id '%s'", __func__, id);
279 return -1;
280 }
281
282 if (!g_seekable_seek(G_SEEKABLE(s), len, G_SEEK_CUR, NULL, &err)) {
283 goto error;
284 }
285
286 nelem -= 1;
287 }
288
289 return 0;
290
291error:
292 error_report("%s: Failed to read from stream: %s", __func__, err->message);
293 return -1;
294}
295
296static void
297dbus_save_state_proxy(gpointer key,
298 gpointer value,
299 gpointer user_data)
300{
301 GDataOutputStream *s = user_data;
302 const char *id = key;
303 GDBusProxy *proxy = value;
304 g_autoptr(GVariant) result = NULL;
305 g_autoptr(GVariant) child = NULL;
306 g_autoptr(GError) err = NULL;
307 const uint8_t *data;
308 gsize size;
309
310 trace_dbus_vmstate_saving(id);
311
312 result = g_dbus_proxy_call_sync(proxy, "Save",
313 NULL, G_DBUS_CALL_FLAGS_NO_AUTO_START,
314 -1, NULL, &err);
315 if (!result) {
316 error_report("%s: Failed to Save: %s", __func__, err->message);
317 return;
318 }
319
320 child = g_variant_get_child_value(result, 0);
321 data = g_variant_get_fixed_array(child, &size, sizeof(char));
322 if (!data) {
323 error_report("%s: Failed to Save: not a byte array", __func__);
324 return;
325 }
326 if (size > DBUS_VMSTATE_SIZE_LIMIT) {
327 error_report("%s: Too large vmstate data to save: %zu",
328 __func__, (size_t)size);
329 return;
330 }
331
332 if (!g_data_output_stream_put_uint32(s, strlen(id), NULL, &err) ||
333 !g_data_output_stream_put_string(s, id, NULL, &err) ||
334 !g_data_output_stream_put_uint32(s, size, NULL, &err) ||
335 !g_output_stream_write_all(G_OUTPUT_STREAM(s),
336 data, size, NULL, NULL, &err)) {
337 error_report("%s: Failed to write to stream: %s",
338 __func__, err->message);
339 }
340}
341
342static int dbus_vmstate_pre_save(void *opaque)
343{
344 DBusVMState *self = DBUS_VMSTATE(opaque);
345 g_autoptr(GOutputStream) m = NULL;
346 g_autoptr(GDataOutputStream) s = NULL;
347 g_autoptr(GHashTable) proxies = NULL;
348 g_autoptr(GError) err = NULL;
349
350 trace_dbus_vmstate_pre_save();
351
352 proxies = dbus_get_proxies(self, &err);
353 if (!proxies) {
354 error_report("%s: Failed to get proxies: %s", __func__, err->message);
355 return -1;
356 }
357
358 m = g_memory_output_stream_new_resizable();
359 s = g_data_output_stream_new(m);
360 g_data_output_stream_set_byte_order(s, G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN);
361
362 if (!g_data_output_stream_put_uint32(s, g_hash_table_size(proxies),
363 NULL, &err)) {
364 error_report("%s: Failed to write to stream: %s",
365 __func__, err->message);
366 return -1;
367 }
368
369 g_hash_table_foreach(proxies, dbus_save_state_proxy, s);
370
371 if (g_memory_output_stream_get_size(G_MEMORY_OUTPUT_STREAM(m))
372 > UINT32_MAX) {
373 error_report("%s: DBus vmstate buffer is too large", __func__);
374 return -1;
375 }
376
377 if (!g_output_stream_close(G_OUTPUT_STREAM(m), NULL, &err)) {
378 error_report("%s: Failed to close stream: %s", __func__, err->message);
379 return -1;
380 }
381
382 g_free(self->data);
383 self->data_size =
384 g_memory_output_stream_get_size(G_MEMORY_OUTPUT_STREAM(m));
385 self->data =
386 g_memory_output_stream_steal_data(G_MEMORY_OUTPUT_STREAM(m));
387
388 return 0;
389}
390
391static const VMStateDescription dbus_vmstate = {
392 .name = TYPE_DBUS_VMSTATE,
393 .version_id = 0,
394 .pre_save = dbus_vmstate_pre_save,
395 .post_load = dbus_vmstate_post_load,
396 .fields = (VMStateField[]) {
397 VMSTATE_UINT32(data_size, DBusVMState),
398 VMSTATE_VBUFFER_ALLOC_UINT32(data, DBusVMState, 0, 0, data_size),
399 VMSTATE_END_OF_LIST()
400 }
401};
402
403static void
404dbus_vmstate_complete(UserCreatable *uc, Error **errp)
405{
406 DBusVMState *self = DBUS_VMSTATE(uc);
407 g_autoptr(GError) err = NULL;
408
409 if (!object_resolve_path_type("", TYPE_DBUS_VMSTATE, NULL)) {
410 error_setg(errp, "There is already an instance of %s",
411 TYPE_DBUS_VMSTATE);
412 return;
413 }
414
415 if (!self->dbus_addr) {
416 error_setg(errp, QERR_MISSING_PARAMETER, "addr");
417 return;
418 }
419
420 self->bus = g_dbus_connection_new_for_address_sync(self->dbus_addr,
421 G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT |
422 G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION,
423 NULL, NULL, &err);
424 if (err) {
425 error_setg(errp, "failed to connect to DBus: '%s'", err->message);
426 return;
427 }
428
429 if (vmstate_register(VMSTATE_IF(self), VMSTATE_INSTANCE_ID_ANY,
430 &dbus_vmstate, self) < 0) {
431 error_setg(errp, "Failed to register vmstate");
432 }
433}
434
435static void
436dbus_vmstate_finalize(Object *o)
437{
438 DBusVMState *self = DBUS_VMSTATE(o);
439
440 vmstate_unregister(VMSTATE_IF(self), &dbus_vmstate, self);
441
442 g_clear_object(&self->bus);
443 g_free(self->dbus_addr);
444 g_free(self->id_list);
445 g_free(self->data);
446}
447
448static char *
449get_dbus_addr(Object *o, Error **errp)
450{
451 DBusVMState *self = DBUS_VMSTATE(o);
452
453 return g_strdup(self->dbus_addr);
454}
455
456static void
457set_dbus_addr(Object *o, const char *str, Error **errp)
458{
459 DBusVMState *self = DBUS_VMSTATE(o);
460
461 g_free(self->dbus_addr);
462 self->dbus_addr = g_strdup(str);
463}
464
465static char *
466get_id_list(Object *o, Error **errp)
467{
468 DBusVMState *self = DBUS_VMSTATE(o);
469
470 return g_strdup(self->id_list);
471}
472
473static void
474set_id_list(Object *o, const char *str, Error **errp)
475{
476 DBusVMState *self = DBUS_VMSTATE(o);
477
478 g_free(self->id_list);
479 self->id_list = g_strdup(str);
480}
481
482static char *
483dbus_vmstate_get_id(VMStateIf *vmif)
484{
485 return g_strdup(TYPE_DBUS_VMSTATE);
486}
487
488static void
489dbus_vmstate_class_init(ObjectClass *oc, void *data)
490{
491 UserCreatableClass *ucc = USER_CREATABLE_CLASS(oc);
492 VMStateIfClass *vc = VMSTATE_IF_CLASS(oc);
493
494 ucc->complete = dbus_vmstate_complete;
495 vc->get_id = dbus_vmstate_get_id;
496
497 object_class_property_add_str(oc, "addr",
498 get_dbus_addr, set_dbus_addr);
499 object_class_property_add_str(oc, "id-list",
500 get_id_list, set_id_list);
501}
502
503static const TypeInfo dbus_vmstate_info = {
504 .name = TYPE_DBUS_VMSTATE,
505 .parent = TYPE_OBJECT,
506 .instance_size = sizeof(DBusVMState),
507 .instance_finalize = dbus_vmstate_finalize,
508 .class_init = dbus_vmstate_class_init,
509 .interfaces = (InterfaceInfo[]) {
510 { TYPE_USER_CREATABLE },
511 { TYPE_VMSTATE_IF },
512 { }
513 }
514};
515
516static void
517register_types(void)
518{
519 type_register_static(&dbus_vmstate_info);
520}
521
522type_init(register_types);
523
