528 lines
16 KiB
C
528 lines
16 KiB
C
/*
|
|
* VMState interpreter
|
|
*
|
|
* Copyright (c) 2009-2017 Red Hat Inc
|
|
*
|
|
* Authors:
|
|
* Juan Quintela <quintela@redhat.com>
|
|
*
|
|
* This work is licensed under the terms of the GNU GPL, version 2 or later.
|
|
* See the COPYING file in the top-level directory.
|
|
*/
|
|
|
|
#include "qemu/osdep.h"
|
|
#include "qemu-common.h"
|
|
#include "migration.h"
|
|
#include "migration/vmstate.h"
|
|
#include "savevm.h"
|
|
#include "qemu-file.h"
|
|
#include "qemu/bitops.h"
|
|
#include "qemu/error-report.h"
|
|
#include "trace.h"
|
|
#include "qjson.h"
|
|
|
|
static int vmstate_subsection_save(QEMUFile *f, const VMStateDescription *vmsd,
|
|
void *opaque, QJSON *vmdesc);
|
|
static int vmstate_subsection_load(QEMUFile *f, const VMStateDescription *vmsd,
|
|
void *opaque);
|
|
|
|
static int vmstate_n_elems(void *opaque, VMStateField *field)
|
|
{
|
|
int n_elems = 1;
|
|
|
|
if (field->flags & VMS_ARRAY) {
|
|
n_elems = field->num;
|
|
} else if (field->flags & VMS_VARRAY_INT32) {
|
|
n_elems = *(int32_t *)(opaque+field->num_offset);
|
|
} else if (field->flags & VMS_VARRAY_UINT32) {
|
|
n_elems = *(uint32_t *)(opaque+field->num_offset);
|
|
} else if (field->flags & VMS_VARRAY_UINT16) {
|
|
n_elems = *(uint16_t *)(opaque+field->num_offset);
|
|
} else if (field->flags & VMS_VARRAY_UINT8) {
|
|
n_elems = *(uint8_t *)(opaque+field->num_offset);
|
|
}
|
|
|
|
if (field->flags & VMS_MULTIPLY_ELEMENTS) {
|
|
n_elems *= field->num;
|
|
}
|
|
|
|
trace_vmstate_n_elems(field->name, n_elems);
|
|
return n_elems;
|
|
}
|
|
|
|
static int vmstate_size(void *opaque, VMStateField *field)
|
|
{
|
|
int size = field->size;
|
|
|
|
if (field->flags & VMS_VBUFFER) {
|
|
size = *(int32_t *)(opaque+field->size_offset);
|
|
if (field->flags & VMS_MULTIPLY) {
|
|
size *= field->size;
|
|
}
|
|
}
|
|
|
|
return size;
|
|
}
|
|
|
|
static void vmstate_handle_alloc(void *ptr, VMStateField *field, void *opaque)
|
|
{
|
|
if (field->flags & VMS_POINTER && field->flags & VMS_ALLOC) {
|
|
gsize size = vmstate_size(opaque, field);
|
|
size *= vmstate_n_elems(opaque, field);
|
|
if (size) {
|
|
*(void **)ptr = g_malloc(size);
|
|
}
|
|
}
|
|
}
|
|
|
|
int vmstate_load_state(QEMUFile *f, const VMStateDescription *vmsd,
|
|
void *opaque, int version_id)
|
|
{
|
|
VMStateField *field = vmsd->fields;
|
|
int ret = 0;
|
|
|
|
trace_vmstate_load_state(vmsd->name, version_id);
|
|
if (version_id > vmsd->version_id) {
|
|
error_report("%s: incoming version_id %d is too new "
|
|
"for local version_id %d",
|
|
vmsd->name, version_id, vmsd->version_id);
|
|
trace_vmstate_load_state_end(vmsd->name, "too new", -EINVAL);
|
|
return -EINVAL;
|
|
}
|
|
if (version_id < vmsd->minimum_version_id) {
|
|
if (vmsd->load_state_old &&
|
|
version_id >= vmsd->minimum_version_id_old) {
|
|
ret = vmsd->load_state_old(f, opaque, version_id);
|
|
trace_vmstate_load_state_end(vmsd->name, "old path", ret);
|
|
return ret;
|
|
}
|
|
error_report("%s: incoming version_id %d is too old "
|
|
"for local minimum version_id %d",
|
|
vmsd->name, version_id, vmsd->minimum_version_id);
|
|
trace_vmstate_load_state_end(vmsd->name, "too old", -EINVAL);
|
|
return -EINVAL;
|
|
}
|
|
if (vmsd->pre_load) {
|
|
int ret = vmsd->pre_load(opaque);
|
|
if (ret) {
|
|
return ret;
|
|
}
|
|
}
|
|
while (field->name) {
|
|
trace_vmstate_load_state_field(vmsd->name, field->name);
|
|
if ((field->field_exists &&
|
|
field->field_exists(opaque, version_id)) ||
|
|
(!field->field_exists &&
|
|
field->version_id <= version_id)) {
|
|
void *first_elem = opaque + field->offset;
|
|
int i, n_elems = vmstate_n_elems(opaque, field);
|
|
int size = vmstate_size(opaque, field);
|
|
|
|
vmstate_handle_alloc(first_elem, field, opaque);
|
|
if (field->flags & VMS_POINTER) {
|
|
first_elem = *(void **)first_elem;
|
|
assert(first_elem || !n_elems || !size);
|
|
}
|
|
for (i = 0; i < n_elems; i++) {
|
|
void *curr_elem = first_elem + size * i;
|
|
|
|
if (field->flags & VMS_ARRAY_OF_POINTER) {
|
|
curr_elem = *(void **)curr_elem;
|
|
}
|
|
if (!curr_elem && size) {
|
|
/* if null pointer check placeholder and do not follow */
|
|
assert(field->flags & VMS_ARRAY_OF_POINTER);
|
|
ret = vmstate_info_nullptr.get(f, curr_elem, size, NULL);
|
|
} else if (field->flags & VMS_STRUCT) {
|
|
ret = vmstate_load_state(f, field->vmsd, curr_elem,
|
|
field->vmsd->version_id);
|
|
} else if (field->flags & VMS_VSTRUCT) {
|
|
ret = vmstate_load_state(f, field->vmsd, curr_elem,
|
|
field->struct_version_id);
|
|
} else {
|
|
ret = field->info->get(f, curr_elem, size, field);
|
|
}
|
|
if (ret >= 0) {
|
|
ret = qemu_file_get_error(f);
|
|
}
|
|
if (ret < 0) {
|
|
qemu_file_set_error(f, ret);
|
|
error_report("Failed to load %s:%s", vmsd->name,
|
|
field->name);
|
|
trace_vmstate_load_field_error(field->name, ret);
|
|
return ret;
|
|
}
|
|
}
|
|
} else if (field->flags & VMS_MUST_EXIST) {
|
|
error_report("Input validation failed: %s/%s",
|
|
vmsd->name, field->name);
|
|
return -1;
|
|
}
|
|
field++;
|
|
}
|
|
ret = vmstate_subsection_load(f, vmsd, opaque);
|
|
if (ret != 0) {
|
|
return ret;
|
|
}
|
|
if (vmsd->post_load) {
|
|
ret = vmsd->post_load(opaque, version_id);
|
|
}
|
|
trace_vmstate_load_state_end(vmsd->name, "end", ret);
|
|
return ret;
|
|
}
|
|
|
|
static int vmfield_name_num(VMStateField *start, VMStateField *search)
|
|
{
|
|
VMStateField *field;
|
|
int found = 0;
|
|
|
|
for (field = start; field->name; field++) {
|
|
if (!strcmp(field->name, search->name)) {
|
|
if (field == search) {
|
|
return found;
|
|
}
|
|
found++;
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
static bool vmfield_name_is_unique(VMStateField *start, VMStateField *search)
|
|
{
|
|
VMStateField *field;
|
|
int found = 0;
|
|
|
|
for (field = start; field->name; field++) {
|
|
if (!strcmp(field->name, search->name)) {
|
|
found++;
|
|
/* name found more than once, so it's not unique */
|
|
if (found > 1) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static const char *vmfield_get_type_name(VMStateField *field)
|
|
{
|
|
const char *type = "unknown";
|
|
|
|
if (field->flags & VMS_STRUCT) {
|
|
type = "struct";
|
|
} else if (field->flags & VMS_VSTRUCT) {
|
|
type = "vstruct";
|
|
} else if (field->info->name) {
|
|
type = field->info->name;
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
static bool vmsd_can_compress(VMStateField *field)
|
|
{
|
|
if (field->field_exists) {
|
|
/* Dynamically existing fields mess up compression */
|
|
return false;
|
|
}
|
|
|
|
if (field->flags & VMS_STRUCT) {
|
|
VMStateField *sfield = field->vmsd->fields;
|
|
while (sfield->name) {
|
|
if (!vmsd_can_compress(sfield)) {
|
|
/* Child elements can't compress, so can't we */
|
|
return false;
|
|
}
|
|
sfield++;
|
|
}
|
|
|
|
if (field->vmsd->subsections) {
|
|
/* Subsections may come and go, better don't compress */
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static void vmsd_desc_field_start(const VMStateDescription *vmsd, QJSON *vmdesc,
|
|
VMStateField *field, int i, int max)
|
|
{
|
|
char *name, *old_name;
|
|
bool is_array = max > 1;
|
|
bool can_compress = vmsd_can_compress(field);
|
|
|
|
if (!vmdesc) {
|
|
return;
|
|
}
|
|
|
|
name = g_strdup(field->name);
|
|
|
|
/* Field name is not unique, need to make it unique */
|
|
if (!vmfield_name_is_unique(vmsd->fields, field)) {
|
|
int num = vmfield_name_num(vmsd->fields, field);
|
|
old_name = name;
|
|
name = g_strdup_printf("%s[%d]", name, num);
|
|
g_free(old_name);
|
|
}
|
|
|
|
json_start_object(vmdesc, NULL);
|
|
json_prop_str(vmdesc, "name", name);
|
|
if (is_array) {
|
|
if (can_compress) {
|
|
json_prop_int(vmdesc, "array_len", max);
|
|
} else {
|
|
json_prop_int(vmdesc, "index", i);
|
|
}
|
|
}
|
|
json_prop_str(vmdesc, "type", vmfield_get_type_name(field));
|
|
|
|
if (field->flags & VMS_STRUCT) {
|
|
json_start_object(vmdesc, "struct");
|
|
}
|
|
|
|
g_free(name);
|
|
}
|
|
|
|
static void vmsd_desc_field_end(const VMStateDescription *vmsd, QJSON *vmdesc,
|
|
VMStateField *field, size_t size, int i)
|
|
{
|
|
if (!vmdesc) {
|
|
return;
|
|
}
|
|
|
|
if (field->flags & VMS_STRUCT) {
|
|
/* We printed a struct in between, close its child object */
|
|
json_end_object(vmdesc);
|
|
}
|
|
|
|
json_prop_int(vmdesc, "size", size);
|
|
json_end_object(vmdesc);
|
|
}
|
|
|
|
|
|
bool vmstate_save_needed(const VMStateDescription *vmsd, void *opaque)
|
|
{
|
|
if (vmsd->needed && !vmsd->needed(opaque)) {
|
|
/* optional section not needed */
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
int vmstate_save_state(QEMUFile *f, const VMStateDescription *vmsd,
|
|
void *opaque, QJSON *vmdesc_id)
|
|
{
|
|
return vmstate_save_state_v(f, vmsd, opaque, vmdesc_id, vmsd->version_id);
|
|
}
|
|
|
|
int vmstate_save_state_v(QEMUFile *f, const VMStateDescription *vmsd,
|
|
void *opaque, QJSON *vmdesc, int version_id)
|
|
{
|
|
int ret = 0;
|
|
VMStateField *field = vmsd->fields;
|
|
|
|
trace_vmstate_save_state_top(vmsd->name);
|
|
|
|
if (vmsd->pre_save) {
|
|
ret = vmsd->pre_save(opaque);
|
|
trace_vmstate_save_state_pre_save_res(vmsd->name, ret);
|
|
if (ret) {
|
|
error_report("pre-save failed: %s", vmsd->name);
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
if (vmdesc) {
|
|
json_prop_str(vmdesc, "vmsd_name", vmsd->name);
|
|
json_prop_int(vmdesc, "version", version_id);
|
|
json_start_array(vmdesc, "fields");
|
|
}
|
|
|
|
while (field->name) {
|
|
if ((field->field_exists &&
|
|
field->field_exists(opaque, version_id)) ||
|
|
(!field->field_exists &&
|
|
field->version_id <= version_id)) {
|
|
void *first_elem = opaque + field->offset;
|
|
int i, n_elems = vmstate_n_elems(opaque, field);
|
|
int size = vmstate_size(opaque, field);
|
|
int64_t old_offset, written_bytes;
|
|
QJSON *vmdesc_loop = vmdesc;
|
|
|
|
trace_vmstate_save_state_loop(vmsd->name, field->name, n_elems);
|
|
if (field->flags & VMS_POINTER) {
|
|
first_elem = *(void **)first_elem;
|
|
assert(first_elem || !n_elems || !size);
|
|
}
|
|
for (i = 0; i < n_elems; i++) {
|
|
void *curr_elem = first_elem + size * i;
|
|
ret = 0;
|
|
|
|
vmsd_desc_field_start(vmsd, vmdesc_loop, field, i, n_elems);
|
|
old_offset = qemu_ftell_fast(f);
|
|
if (field->flags & VMS_ARRAY_OF_POINTER) {
|
|
assert(curr_elem);
|
|
curr_elem = *(void **)curr_elem;
|
|
}
|
|
if (!curr_elem && size) {
|
|
/* if null pointer write placeholder and do not follow */
|
|
assert(field->flags & VMS_ARRAY_OF_POINTER);
|
|
ret = vmstate_info_nullptr.put(f, curr_elem, size, NULL,
|
|
NULL);
|
|
} else if (field->flags & VMS_STRUCT) {
|
|
ret = vmstate_save_state(f, field->vmsd, curr_elem,
|
|
vmdesc_loop);
|
|
} else if (field->flags & VMS_VSTRUCT) {
|
|
ret = vmstate_save_state_v(f, field->vmsd, curr_elem,
|
|
vmdesc_loop,
|
|
field->struct_version_id);
|
|
} else {
|
|
ret = field->info->put(f, curr_elem, size, field,
|
|
vmdesc_loop);
|
|
}
|
|
if (ret) {
|
|
error_report("Save of field %s/%s failed",
|
|
vmsd->name, field->name);
|
|
return ret;
|
|
}
|
|
|
|
written_bytes = qemu_ftell_fast(f) - old_offset;
|
|
vmsd_desc_field_end(vmsd, vmdesc_loop, field, written_bytes, i);
|
|
|
|
/* Compressed arrays only care about the first element */
|
|
if (vmdesc_loop && vmsd_can_compress(field)) {
|
|
vmdesc_loop = NULL;
|
|
}
|
|
}
|
|
} else {
|
|
if (field->flags & VMS_MUST_EXIST) {
|
|
error_report("Output state validation failed: %s/%s",
|
|
vmsd->name, field->name);
|
|
assert(!(field->flags & VMS_MUST_EXIST));
|
|
}
|
|
}
|
|
field++;
|
|
}
|
|
|
|
if (vmdesc) {
|
|
json_end_array(vmdesc);
|
|
}
|
|
|
|
return vmstate_subsection_save(f, vmsd, opaque, vmdesc);
|
|
}
|
|
|
|
static const VMStateDescription *
|
|
vmstate_get_subsection(const VMStateDescription **sub, char *idstr)
|
|
{
|
|
while (sub && *sub && (*sub)->needed) {
|
|
if (strcmp(idstr, (*sub)->name) == 0) {
|
|
return *sub;
|
|
}
|
|
sub++;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
static int vmstate_subsection_load(QEMUFile *f, const VMStateDescription *vmsd,
|
|
void *opaque)
|
|
{
|
|
trace_vmstate_subsection_load(vmsd->name);
|
|
|
|
while (qemu_peek_byte(f, 0) == QEMU_VM_SUBSECTION) {
|
|
char idstr[256], *idstr_ret;
|
|
int ret;
|
|
uint8_t version_id, len, size;
|
|
const VMStateDescription *sub_vmsd;
|
|
|
|
len = qemu_peek_byte(f, 1);
|
|
if (len < strlen(vmsd->name) + 1) {
|
|
/* subsection name has be be "section_name/a" */
|
|
trace_vmstate_subsection_load_bad(vmsd->name, "(short)", "");
|
|
return 0;
|
|
}
|
|
size = qemu_peek_buffer(f, (uint8_t **)&idstr_ret, len, 2);
|
|
if (size != len) {
|
|
trace_vmstate_subsection_load_bad(vmsd->name, "(peek fail)", "");
|
|
return 0;
|
|
}
|
|
memcpy(idstr, idstr_ret, size);
|
|
idstr[size] = 0;
|
|
|
|
if (strncmp(vmsd->name, idstr, strlen(vmsd->name)) != 0) {
|
|
trace_vmstate_subsection_load_bad(vmsd->name, idstr, "(prefix)");
|
|
/* it doesn't have a valid subsection name */
|
|
return 0;
|
|
}
|
|
sub_vmsd = vmstate_get_subsection(vmsd->subsections, idstr);
|
|
if (sub_vmsd == NULL) {
|
|
trace_vmstate_subsection_load_bad(vmsd->name, idstr, "(lookup)");
|
|
return -ENOENT;
|
|
}
|
|
qemu_file_skip(f, 1); /* subsection */
|
|
qemu_file_skip(f, 1); /* len */
|
|
qemu_file_skip(f, len); /* idstr */
|
|
version_id = qemu_get_be32(f);
|
|
|
|
ret = vmstate_load_state(f, sub_vmsd, opaque, version_id);
|
|
if (ret) {
|
|
trace_vmstate_subsection_load_bad(vmsd->name, idstr, "(child)");
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
trace_vmstate_subsection_load_good(vmsd->name);
|
|
return 0;
|
|
}
|
|
|
|
static int vmstate_subsection_save(QEMUFile *f, const VMStateDescription *vmsd,
|
|
void *opaque, QJSON *vmdesc)
|
|
{
|
|
const VMStateDescription **sub = vmsd->subsections;
|
|
bool subsection_found = false;
|
|
int ret = 0;
|
|
|
|
trace_vmstate_subsection_save_top(vmsd->name);
|
|
while (sub && *sub && (*sub)->needed) {
|
|
if ((*sub)->needed(opaque)) {
|
|
const VMStateDescription *vmsdsub = *sub;
|
|
uint8_t len;
|
|
|
|
trace_vmstate_subsection_save_loop(vmsd->name, vmsdsub->name);
|
|
if (vmdesc) {
|
|
/* Only create subsection array when we have any */
|
|
if (!subsection_found) {
|
|
json_start_array(vmdesc, "subsections");
|
|
subsection_found = true;
|
|
}
|
|
|
|
json_start_object(vmdesc, NULL);
|
|
}
|
|
|
|
qemu_put_byte(f, QEMU_VM_SUBSECTION);
|
|
len = strlen(vmsdsub->name);
|
|
qemu_put_byte(f, len);
|
|
qemu_put_buffer(f, (uint8_t *)vmsdsub->name, len);
|
|
qemu_put_be32(f, vmsdsub->version_id);
|
|
ret = vmstate_save_state(f, vmsdsub, opaque, vmdesc);
|
|
if (ret) {
|
|
return ret;
|
|
}
|
|
|
|
if (vmdesc) {
|
|
json_end_object(vmdesc);
|
|
}
|
|
}
|
|
sub++;
|
|
}
|
|
|
|
if (vmdesc && subsection_found) {
|
|
json_end_array(vmdesc);
|
|
}
|
|
|
|
return ret;
|
|
}
|