xref: /openbmc/qemu/backends/dbus-vmstate.c (revision d328fef93ae757a0dd65ed786a4086e27952eef3) 
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 *
get_id_list_set(DBusVMState * self)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 *
dbus_get_proxies(DBusVMState * self,GError ** err)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              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  
170  static int
dbus_load_state_proxy(GDBusProxy * proxy,const uint8_t * data,size_t size)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  
dbus_vmstate_post_load(void * opaque,int version_id)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      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  
291  error:
292      error_report("%s: Failed to read from stream: %s", __func__, err->message);
293      return -1;
294  }
295  
296  static void
dbus_save_state_proxy(gpointer key,gpointer value,gpointer user_data)297  dbus_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  
dbus_vmstate_pre_save(void * opaque)342  static 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  
391  static 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 = (const 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  
403  static void
dbus_vmstate_complete(UserCreatable * uc,Error ** errp)404  dbus_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_any(VMSTATE_IF(self), &dbus_vmstate, self) < 0) {
430          error_setg(errp, "Failed to register vmstate");
431      }
432  }
433  
434  static void
dbus_vmstate_finalize(Object * o)435  dbus_vmstate_finalize(Object *o)
436  {
437      DBusVMState *self = DBUS_VMSTATE(o);
438  
439      vmstate_unregister(VMSTATE_IF(self), &dbus_vmstate, self);
440  
441      g_clear_object(&self->bus);
442      g_free(self->dbus_addr);
443      g_free(self->id_list);
444      g_free(self->data);
445  }
446  
447  static char *
get_dbus_addr(Object * o,Error ** errp)448  get_dbus_addr(Object *o, Error **errp)
449  {
450      DBusVMState *self = DBUS_VMSTATE(o);
451  
452      return g_strdup(self->dbus_addr);
453  }
454  
455  static void
set_dbus_addr(Object * o,const char * str,Error ** errp)456  set_dbus_addr(Object *o, const char *str, Error **errp)
457  {
458      DBusVMState *self = DBUS_VMSTATE(o);
459  
460      g_free(self->dbus_addr);
461      self->dbus_addr = g_strdup(str);
462  }
463  
464  static char *
get_id_list(Object * o,Error ** errp)465  get_id_list(Object *o, Error **errp)
466  {
467      DBusVMState *self = DBUS_VMSTATE(o);
468  
469      return g_strdup(self->id_list);
470  }
471  
472  static void
set_id_list(Object * o,const char * str,Error ** errp)473  set_id_list(Object *o, const char *str, Error **errp)
474  {
475      DBusVMState *self = DBUS_VMSTATE(o);
476  
477      g_free(self->id_list);
478      self->id_list = g_strdup(str);
479  }
480  
481  static char *
dbus_vmstate_get_id(VMStateIf * vmif)482  dbus_vmstate_get_id(VMStateIf *vmif)
483  {
484      return g_strdup(TYPE_DBUS_VMSTATE);
485  }
486  
487  static void
dbus_vmstate_class_init(ObjectClass * oc,void * data)488  dbus_vmstate_class_init(ObjectClass *oc, void *data)
489  {
490      UserCreatableClass *ucc = USER_CREATABLE_CLASS(oc);
491      VMStateIfClass *vc = VMSTATE_IF_CLASS(oc);
492  
493      ucc->complete = dbus_vmstate_complete;
494      vc->get_id = dbus_vmstate_get_id;
495  
496      object_class_property_add_str(oc, "addr",
497                                    get_dbus_addr, set_dbus_addr);
498      object_class_property_add_str(oc, "id-list",
499                                    get_id_list, set_id_list);
500  }
501  
502  static const TypeInfo dbus_vmstate_info = {
503      .name = TYPE_DBUS_VMSTATE,
504      .parent = TYPE_OBJECT,
505      .instance_size = sizeof(DBusVMState),
506      .instance_finalize = dbus_vmstate_finalize,
507      .class_init = dbus_vmstate_class_init,
508      .interfaces = (InterfaceInfo[]) {
509          { TYPE_USER_CREATABLE },
510          { TYPE_VMSTATE_IF },
511          { }
512      }
513  };
514  
515  static void
register_types(void)516  register_types(void)
517  {
518      type_register_static(&dbus_vmstate_info);
519  }
520  
521  type_init(register_types);
522