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