1 /* 2 * VMState interpreter 3 * 4 * Copyright (c) 2009-2017 Red Hat Inc 5 * 6 * Authors: 7 * Juan Quintela <quintela@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 "migration.h" 15 #include "migration/vmstate.h" 16 #include "savevm.h" 17 #include "qapi/qmp/json-writer.h" 18 #include "qemu-file.h" 19 #include "qemu/bitops.h" 20 #include "qemu/error-report.h" 21 #include "trace.h" 22 23 static int vmstate_subsection_save(QEMUFile *f, const VMStateDescription *vmsd, 24 void *opaque, JSONWriter *vmdesc); 25 static int vmstate_subsection_load(QEMUFile *f, const VMStateDescription *vmsd, 26 void *opaque); 27 28 static int vmstate_n_elems(void *opaque, const VMStateField *field) 29 { 30 int n_elems = 1; 31 32 if (field->flags & VMS_ARRAY) { 33 n_elems = field->num; 34 } else if (field->flags & VMS_VARRAY_INT32) { 35 n_elems = *(int32_t *)(opaque + field->num_offset); 36 } else if (field->flags & VMS_VARRAY_UINT32) { 37 n_elems = *(uint32_t *)(opaque + field->num_offset); 38 } else if (field->flags & VMS_VARRAY_UINT16) { 39 n_elems = *(uint16_t *)(opaque + field->num_offset); 40 } else if (field->flags & VMS_VARRAY_UINT8) { 41 n_elems = *(uint8_t *)(opaque + field->num_offset); 42 } 43 44 if (field->flags & VMS_MULTIPLY_ELEMENTS) { 45 n_elems *= field->num; 46 } 47 48 trace_vmstate_n_elems(field->name, n_elems); 49 return n_elems; 50 } 51 52 static int vmstate_size(void *opaque, const VMStateField *field) 53 { 54 int size = field->size; 55 56 if (field->flags & VMS_VBUFFER) { 57 size = *(int32_t *)(opaque + field->size_offset); 58 if (field->flags & VMS_MULTIPLY) { 59 size *= field->size; 60 } 61 } 62 63 return size; 64 } 65 66 static void vmstate_handle_alloc(void *ptr, const VMStateField *field, 67 void *opaque) 68 { 69 if (field->flags & VMS_POINTER && field->flags & VMS_ALLOC) { 70 gsize size = vmstate_size(opaque, field); 71 size *= vmstate_n_elems(opaque, field); 72 if (size) { 73 *(void **)ptr = g_malloc(size); 74 } 75 } 76 } 77 78 int vmstate_load_state(QEMUFile *f, const VMStateDescription *vmsd, 79 void *opaque, int version_id) 80 { 81 const VMStateField *field = vmsd->fields; 82 int ret = 0; 83 84 trace_vmstate_load_state(vmsd->name, version_id); 85 if (version_id > vmsd->version_id) { 86 error_report("%s: incoming version_id %d is too new " 87 "for local version_id %d", 88 vmsd->name, version_id, vmsd->version_id); 89 trace_vmstate_load_state_end(vmsd->name, "too new", -EINVAL); 90 return -EINVAL; 91 } 92 if (version_id < vmsd->minimum_version_id) { 93 error_report("%s: incoming version_id %d is too old " 94 "for local minimum version_id %d", 95 vmsd->name, version_id, vmsd->minimum_version_id); 96 trace_vmstate_load_state_end(vmsd->name, "too old", -EINVAL); 97 return -EINVAL; 98 } 99 if (vmsd->pre_load) { 100 int ret = vmsd->pre_load(opaque); 101 if (ret) { 102 return ret; 103 } 104 } 105 while (field->name) { 106 trace_vmstate_load_state_field(vmsd->name, field->name); 107 if ((field->field_exists && 108 field->field_exists(opaque, version_id)) || 109 (!field->field_exists && 110 field->version_id <= version_id)) { 111 void *first_elem = opaque + field->offset; 112 int i, n_elems = vmstate_n_elems(opaque, field); 113 int size = vmstate_size(opaque, field); 114 115 vmstate_handle_alloc(first_elem, field, opaque); 116 if (field->flags & VMS_POINTER) { 117 first_elem = *(void **)first_elem; 118 assert(first_elem || !n_elems || !size); 119 } 120 for (i = 0; i < n_elems; i++) { 121 void *curr_elem = first_elem + size * i; 122 123 if (field->flags & VMS_ARRAY_OF_POINTER) { 124 curr_elem = *(void **)curr_elem; 125 } 126 if (!curr_elem && size) { 127 /* if null pointer check placeholder and do not follow */ 128 assert(field->flags & VMS_ARRAY_OF_POINTER); 129 ret = vmstate_info_nullptr.get(f, curr_elem, size, NULL); 130 } else if (field->flags & VMS_STRUCT) { 131 ret = vmstate_load_state(f, field->vmsd, curr_elem, 132 field->vmsd->version_id); 133 } else if (field->flags & VMS_VSTRUCT) { 134 ret = vmstate_load_state(f, field->vmsd, curr_elem, 135 field->struct_version_id); 136 } else { 137 ret = field->info->get(f, curr_elem, size, field); 138 } 139 if (ret >= 0) { 140 ret = qemu_file_get_error(f); 141 } 142 if (ret < 0) { 143 qemu_file_set_error(f, ret); 144 error_report("Failed to load %s:%s", vmsd->name, 145 field->name); 146 trace_vmstate_load_field_error(field->name, ret); 147 return ret; 148 } 149 } 150 } else if (field->flags & VMS_MUST_EXIST) { 151 error_report("Input validation failed: %s/%s", 152 vmsd->name, field->name); 153 return -1; 154 } 155 field++; 156 } 157 assert(field->flags == VMS_END); 158 ret = vmstate_subsection_load(f, vmsd, opaque); 159 if (ret != 0) { 160 return ret; 161 } 162 if (vmsd->post_load) { 163 ret = vmsd->post_load(opaque, version_id); 164 } 165 trace_vmstate_load_state_end(vmsd->name, "end", ret); 166 return ret; 167 } 168 169 static int vmfield_name_num(const VMStateField *start, 170 const VMStateField *search) 171 { 172 const VMStateField *field; 173 int found = 0; 174 175 for (field = start; field->name; field++) { 176 if (!strcmp(field->name, search->name)) { 177 if (field == search) { 178 return found; 179 } 180 found++; 181 } 182 } 183 184 return -1; 185 } 186 187 static bool vmfield_name_is_unique(const VMStateField *start, 188 const VMStateField *search) 189 { 190 const VMStateField *field; 191 int found = 0; 192 193 for (field = start; field->name; field++) { 194 if (!strcmp(field->name, search->name)) { 195 found++; 196 /* name found more than once, so it's not unique */ 197 if (found > 1) { 198 return false; 199 } 200 } 201 } 202 203 return true; 204 } 205 206 static const char *vmfield_get_type_name(const VMStateField *field) 207 { 208 const char *type = "unknown"; 209 210 if (field->flags & VMS_STRUCT) { 211 type = "struct"; 212 } else if (field->flags & VMS_VSTRUCT) { 213 type = "vstruct"; 214 } else if (field->info->name) { 215 type = field->info->name; 216 } 217 218 return type; 219 } 220 221 static bool vmsd_can_compress(const VMStateField *field) 222 { 223 if (field->field_exists) { 224 /* Dynamically existing fields mess up compression */ 225 return false; 226 } 227 228 if (field->flags & VMS_STRUCT) { 229 const VMStateField *sfield = field->vmsd->fields; 230 while (sfield->name) { 231 if (!vmsd_can_compress(sfield)) { 232 /* Child elements can't compress, so can't we */ 233 return false; 234 } 235 sfield++; 236 } 237 238 if (field->vmsd->subsections) { 239 /* Subsections may come and go, better don't compress */ 240 return false; 241 } 242 } 243 244 return true; 245 } 246 247 static void vmsd_desc_field_start(const VMStateDescription *vmsd, 248 JSONWriter *vmdesc, 249 const VMStateField *field, int i, int max) 250 { 251 char *name, *old_name; 252 bool is_array = max > 1; 253 bool can_compress = vmsd_can_compress(field); 254 255 if (!vmdesc) { 256 return; 257 } 258 259 name = g_strdup(field->name); 260 261 /* Field name is not unique, need to make it unique */ 262 if (!vmfield_name_is_unique(vmsd->fields, field)) { 263 int num = vmfield_name_num(vmsd->fields, field); 264 old_name = name; 265 name = g_strdup_printf("%s[%d]", name, num); 266 g_free(old_name); 267 } 268 269 json_writer_start_object(vmdesc, NULL); 270 json_writer_str(vmdesc, "name", name); 271 if (is_array) { 272 if (can_compress) { 273 json_writer_int64(vmdesc, "array_len", max); 274 } else { 275 json_writer_int64(vmdesc, "index", i); 276 } 277 } 278 json_writer_str(vmdesc, "type", vmfield_get_type_name(field)); 279 280 if (field->flags & VMS_STRUCT) { 281 json_writer_start_object(vmdesc, "struct"); 282 } 283 284 g_free(name); 285 } 286 287 static void vmsd_desc_field_end(const VMStateDescription *vmsd, 288 JSONWriter *vmdesc, 289 const VMStateField *field, size_t size, int i) 290 { 291 if (!vmdesc) { 292 return; 293 } 294 295 if (field->flags & VMS_STRUCT) { 296 /* We printed a struct in between, close its child object */ 297 json_writer_end_object(vmdesc); 298 } 299 300 json_writer_int64(vmdesc, "size", size); 301 json_writer_end_object(vmdesc); 302 } 303 304 305 bool vmstate_save_needed(const VMStateDescription *vmsd, void *opaque) 306 { 307 if (vmsd->needed && !vmsd->needed(opaque)) { 308 /* optional section not needed */ 309 return false; 310 } 311 return true; 312 } 313 314 315 int vmstate_save_state(QEMUFile *f, const VMStateDescription *vmsd, 316 void *opaque, JSONWriter *vmdesc_id) 317 { 318 return vmstate_save_state_v(f, vmsd, opaque, vmdesc_id, vmsd->version_id); 319 } 320 321 int vmstate_save_state_v(QEMUFile *f, const VMStateDescription *vmsd, 322 void *opaque, JSONWriter *vmdesc, int version_id) 323 { 324 int ret = 0; 325 const VMStateField *field = vmsd->fields; 326 327 trace_vmstate_save_state_top(vmsd->name); 328 329 if (vmsd->pre_save) { 330 ret = vmsd->pre_save(opaque); 331 trace_vmstate_save_state_pre_save_res(vmsd->name, ret); 332 if (ret) { 333 error_report("pre-save failed: %s", vmsd->name); 334 return ret; 335 } 336 } 337 338 if (vmdesc) { 339 json_writer_str(vmdesc, "vmsd_name", vmsd->name); 340 json_writer_int64(vmdesc, "version", version_id); 341 json_writer_start_array(vmdesc, "fields"); 342 } 343 344 while (field->name) { 345 if ((field->field_exists && 346 field->field_exists(opaque, version_id)) || 347 (!field->field_exists && 348 field->version_id <= version_id)) { 349 void *first_elem = opaque + field->offset; 350 int i, n_elems = vmstate_n_elems(opaque, field); 351 int size = vmstate_size(opaque, field); 352 uint64_t old_offset, written_bytes; 353 JSONWriter *vmdesc_loop = vmdesc; 354 355 trace_vmstate_save_state_loop(vmsd->name, field->name, n_elems); 356 if (field->flags & VMS_POINTER) { 357 first_elem = *(void **)first_elem; 358 assert(first_elem || !n_elems || !size); 359 } 360 for (i = 0; i < n_elems; i++) { 361 void *curr_elem = first_elem + size * i; 362 363 vmsd_desc_field_start(vmsd, vmdesc_loop, field, i, n_elems); 364 old_offset = qemu_file_total_transferred_fast(f); 365 if (field->flags & VMS_ARRAY_OF_POINTER) { 366 assert(curr_elem); 367 curr_elem = *(void **)curr_elem; 368 } 369 if (!curr_elem && size) { 370 /* if null pointer write placeholder and do not follow */ 371 assert(field->flags & VMS_ARRAY_OF_POINTER); 372 ret = vmstate_info_nullptr.put(f, curr_elem, size, NULL, 373 NULL); 374 } else if (field->flags & VMS_STRUCT) { 375 ret = vmstate_save_state(f, field->vmsd, curr_elem, 376 vmdesc_loop); 377 } else if (field->flags & VMS_VSTRUCT) { 378 ret = vmstate_save_state_v(f, field->vmsd, curr_elem, 379 vmdesc_loop, 380 field->struct_version_id); 381 } else { 382 ret = field->info->put(f, curr_elem, size, field, 383 vmdesc_loop); 384 } 385 if (ret) { 386 error_report("Save of field %s/%s failed", 387 vmsd->name, field->name); 388 if (vmsd->post_save) { 389 vmsd->post_save(opaque); 390 } 391 return ret; 392 } 393 394 written_bytes = qemu_file_total_transferred_fast(f) - 395 old_offset; 396 vmsd_desc_field_end(vmsd, vmdesc_loop, field, written_bytes, i); 397 398 /* Compressed arrays only care about the first element */ 399 if (vmdesc_loop && vmsd_can_compress(field)) { 400 vmdesc_loop = NULL; 401 } 402 } 403 } else { 404 if (field->flags & VMS_MUST_EXIST) { 405 error_report("Output state validation failed: %s/%s", 406 vmsd->name, field->name); 407 assert(!(field->flags & VMS_MUST_EXIST)); 408 } 409 } 410 field++; 411 } 412 assert(field->flags == VMS_END); 413 414 if (vmdesc) { 415 json_writer_end_array(vmdesc); 416 } 417 418 ret = vmstate_subsection_save(f, vmsd, opaque, vmdesc); 419 420 if (vmsd->post_save) { 421 int ps_ret = vmsd->post_save(opaque); 422 if (!ret) { 423 ret = ps_ret; 424 } 425 } 426 return ret; 427 } 428 429 static const VMStateDescription * 430 vmstate_get_subsection(const VMStateDescription **sub, char *idstr) 431 { 432 while (sub && *sub) { 433 if (strcmp(idstr, (*sub)->name) == 0) { 434 return *sub; 435 } 436 sub++; 437 } 438 return NULL; 439 } 440 441 static int vmstate_subsection_load(QEMUFile *f, const VMStateDescription *vmsd, 442 void *opaque) 443 { 444 trace_vmstate_subsection_load(vmsd->name); 445 446 while (qemu_peek_byte(f, 0) == QEMU_VM_SUBSECTION) { 447 char idstr[256], *idstr_ret; 448 int ret; 449 uint8_t version_id, len, size; 450 const VMStateDescription *sub_vmsd; 451 452 len = qemu_peek_byte(f, 1); 453 if (len < strlen(vmsd->name) + 1) { 454 /* subsection name has be be "section_name/a" */ 455 trace_vmstate_subsection_load_bad(vmsd->name, "(short)", ""); 456 return 0; 457 } 458 size = qemu_peek_buffer(f, (uint8_t **)&idstr_ret, len, 2); 459 if (size != len) { 460 trace_vmstate_subsection_load_bad(vmsd->name, "(peek fail)", ""); 461 return 0; 462 } 463 memcpy(idstr, idstr_ret, size); 464 idstr[size] = 0; 465 466 if (strncmp(vmsd->name, idstr, strlen(vmsd->name)) != 0) { 467 trace_vmstate_subsection_load_bad(vmsd->name, idstr, "(prefix)"); 468 /* it doesn't have a valid subsection name */ 469 return 0; 470 } 471 sub_vmsd = vmstate_get_subsection(vmsd->subsections, idstr); 472 if (sub_vmsd == NULL) { 473 trace_vmstate_subsection_load_bad(vmsd->name, idstr, "(lookup)"); 474 return -ENOENT; 475 } 476 qemu_file_skip(f, 1); /* subsection */ 477 qemu_file_skip(f, 1); /* len */ 478 qemu_file_skip(f, len); /* idstr */ 479 version_id = qemu_get_be32(f); 480 481 ret = vmstate_load_state(f, sub_vmsd, opaque, version_id); 482 if (ret) { 483 trace_vmstate_subsection_load_bad(vmsd->name, idstr, "(child)"); 484 return ret; 485 } 486 } 487 488 trace_vmstate_subsection_load_good(vmsd->name); 489 return 0; 490 } 491 492 static int vmstate_subsection_save(QEMUFile *f, const VMStateDescription *vmsd, 493 void *opaque, JSONWriter *vmdesc) 494 { 495 const VMStateDescription **sub = vmsd->subsections; 496 bool vmdesc_has_subsections = false; 497 int ret = 0; 498 499 trace_vmstate_subsection_save_top(vmsd->name); 500 while (sub && *sub) { 501 if (vmstate_save_needed(*sub, opaque)) { 502 const VMStateDescription *vmsdsub = *sub; 503 uint8_t len; 504 505 trace_vmstate_subsection_save_loop(vmsd->name, vmsdsub->name); 506 if (vmdesc) { 507 /* Only create subsection array when we have any */ 508 if (!vmdesc_has_subsections) { 509 json_writer_start_array(vmdesc, "subsections"); 510 vmdesc_has_subsections = true; 511 } 512 513 json_writer_start_object(vmdesc, NULL); 514 } 515 516 qemu_put_byte(f, QEMU_VM_SUBSECTION); 517 len = strlen(vmsdsub->name); 518 qemu_put_byte(f, len); 519 qemu_put_buffer(f, (uint8_t *)vmsdsub->name, len); 520 qemu_put_be32(f, vmsdsub->version_id); 521 ret = vmstate_save_state(f, vmsdsub, opaque, vmdesc); 522 if (ret) { 523 return ret; 524 } 525 526 if (vmdesc) { 527 json_writer_end_object(vmdesc); 528 } 529 } 530 sub++; 531 } 532 533 if (vmdesc_has_subsections) { 534 json_writer_end_array(vmdesc); 535 } 536 537 return ret; 538 } 539