vitalif
/
mirror_qemu
mirror of https://github.com/proxmox/mirror_qemu
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

migration/next for 20140623 

-----BEGIN PGP SIGNATURE-----
 Version: GnuPG v1
 
 iQIcBAABCAAGBQJTqGGBAAoJEPSH7xhYctcj+9MQAKyWUh3eC/wVoy+KgtCLz81Y
 kOFTZI2AT0yAunr2ujR6v7DvR1QX5ygYL1rnwmZhwe8/yV3bXr4d7EhzfDRoNrTr
 tPOu13qqBB1i3iNR/dCFAPRopo9dZ/0synYFvJWhzO8EqdFfjJ2xhlE5PD0Slayb
 08qRQsuvkaEgD2Q4iYzqmS/o7pEK3HqBCuTqRYaty0QpIcOKXhUDivImSf1Yhlka
 NJoNuZWL8gMxUqdZZPMMWTh7Hcw1zLrm7ve4ydiBx7EMKSSviBujCpxkAskthYbA
 PYchxQ3kZ36cILxTtimuYayRUDZLu5naoNtlxN79obeRXgZpbZFWr4SwXjWOYAzS
 GBKpaZQLddYWeHDfAChuSNV0ldfrlicabX/rLVBnsJidRlShQBrqIjuh/z2U9Mad
 PKRPyw6QYKZXR8kehCBGgNegOTD+IpLHdI2ea0SrMz8x1sCaiG3NVZk2X5bb0yOa
 X9mvDE35DOOePzbTGzJtTHMCW2w0ZoLBbO/8IL6BViJjvZQoFh/I+dzcVfIlF18j
 mfCi6xPAw3LM7BvQDD/AfFfl40X+O7HYXCeQ0aNksja6eaymuIgMrl3iIPxPYKwz
 vVE4Z073U5YAzEmZrbgB/gag4VCAFCIldDBexUA+eVWpSWPRHXlnzJ+e16JKXTqD
 49oXnzmPeuzJUCSpW9bL
 =2yjp
 -----END PGP SIGNATURE-----

Merge remote-tracking branch 'remotes/juanquintela/tags/migration/20140623' into staging

migration/next for 20140623

# gpg: Signature made Mon 23 Jun 2014 18:18:57 BST using RSA key ID 5872D723
# gpg: Can't check signature: public key not found

* remotes/juanquintela/tags/migration/20140623: (22 commits)
  vmstate: Refactor & increase tests for primitive types
  vmstate: Return error in case of error
  migration: Remove unneeded minimum_version_id_old
  tests: vmstate static checker: add size mismatch inside substructure
  tests: vmstate static checker: add substructure for usb-kbd for hid section
  tests: vmstate static checker: remove Subsections
  tests: vmstate static checker: remove a subsection
  tests: vmstate static checker: remove Description inside Fields
  tests: vmstate static checker: remove Description
  tests: vmstate static checker: remove Fields
  tests: vmstate static checker: change description name
  tests: vmstate static checker: remove last field in a struct
  tests: vmstate static checker: remove a field
  tests: vmstate static checker: remove a section
  tests: vmstate static checker: minimum_version_id check
  tests: vmstate static checker: version mismatch inside a Description
  tests: vmstate static checker: add version error in main section
  tests: vmstate static checker: incompat machine types
  tests: vmstate static checker: add dump1 and dump2 files
  vmstate-static-checker: script to validate vmstate changes
  ...

Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
master
Peter Maydell 2014-06-24 15:33:42 +01:00
parent 089a39486f 4ea7df4e5c
commit 513d80edc1
11 changed files with 2882 additions and 86 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
hw/usb/hcd-ohci.c
View File

@ -1988,8 +1988,7 @@ static const VMStateDescription vmstate_ohci_state_port = {
.name = "ohci-core/port",
.version_id = 1,
.minimum_version_id = 1,
.minimum_version_id_old = 1,
.fields = (VMStateField []) {
.fields = (VMStateField[]) {
VMSTATE_UINT32(ctrl, OHCIPort),
VMSTATE_END_OF_LIST()
},
@ -2015,9 +2014,8 @@ static const VMStateDescription vmstate_ohci_eof_timer = {
.name = "ohci-core/eof-timer",
.version_id = 1,
.minimum_version_id = 1,
.minimum_version_id_old = 1,
.pre_load = ohci_eof_timer_pre_load,
.fields = (VMStateField []) {
.fields = (VMStateField[]) {
VMSTATE_TIMER(eof_timer, OHCIState),
VMSTATE_END_OF_LIST()
},
@ -2078,7 +2076,6 @@ static const VMStateDescription vmstate_ohci = {
.name = "ohci",
.version_id = 1,
.minimum_version_id = 1,
.minimum_version_id_old = 1,
.fields = (VMStateField[]) {
VMSTATE_PCI_DEVICE(parent_obj, OHCIPCIState),
VMSTATE_STRUCT(state, OHCIPCIState, 1, vmstate_ohci_state, OHCIState),

2
include/migration/vmstate.h
View File

@ -788,4 +788,6 @@ int64_t self_announce_delay(int round)
return 50 + (SELF_ANNOUNCE_ROUNDS - round - 1) * 100;
}
void dump_vmstate_json_to_file(FILE *out_fp);
#endif

20
migration-rdma.c
View File

@ -1590,13 +1590,11 @@ static int qemu_rdma_post_send_control(RDMAContext *rdma, uint8_t *buf,
}
if (ibv_post_send(rdma->qp, &send_wr, &bad_wr)) {
return -1;
}
ret = ibv_post_send(rdma->qp, &send_wr, &bad_wr);
if (ret < 0) {
if (ret > 0) {
fprintf(stderr, "Failed to use post IB SEND for control!\n");
return ret;
return -ret;
}
ret = qemu_rdma_block_for_wrid(rdma, RDMA_WRID_SEND_CONTROL, NULL);
@ -2238,10 +2236,6 @@ static void qemu_rdma_cleanup(RDMAContext *rdma)
}
}
if (rdma->qp) {
rdma_destroy_qp(rdma->cm_id);
rdma->qp = NULL;
}
if (rdma->cq) {
ibv_destroy_cq(rdma->cq);
rdma->cq = NULL;
@ -2259,6 +2253,10 @@ static void qemu_rdma_cleanup(RDMAContext *rdma)
rdma->listen_id = NULL;
}
if (rdma->cm_id) {
if (rdma->qp) {
rdma_destroy_qp(rdma->cm_id);
rdma->qp = NULL;
}
rdma_destroy_id(rdma->cm_id);
rdma->cm_id = NULL;
}
@ -2513,8 +2511,10 @@ static void *qemu_rdma_data_init(const char *host_port, Error **errp)
} else {
ERROR(errp, "bad RDMA migration address '%s'", host_port);
g_free(rdma);
return NULL;
rdma = NULL;
}
qapi_free_InetSocketAddress(addr);
}
return rdma;

14
qemu-options.hx
View File

@ -3252,6 +3252,20 @@ STEXI
prepend a timestamp to each log message.(default:on)
ETEXI
DEF("dump-vmstate", HAS_ARG, QEMU_OPTION_dump_vmstate,
"-dump-vmstate <file>\n"
" Output vmstate information in JSON format to file.\n"
" Use the scripts/vmstate-static-checker.py file to\n"
" check for possible regressions in migration code\n"
" by comparing two such vmstate dumps.",
QEMU_ARCH_ALL)
STEXI
@item -dump-vmstate @var{file}
@findex -dump-vmstate
Dump json-encoded vmstate information for current machine type to file
in @var{file}
ETEXI
HXCOMM This is the last statement. Insert new options before this line!
STEXI
@end table

139
savevm.c
View File

@ -24,6 +24,7 @@
#include "config-host.h"
#include "qemu-common.h"
#include "hw/boards.h"
#include "hw/hw.h"
#include "hw/qdev.h"
#include "net/net.h"
@ -240,6 +241,144 @@ static QTAILQ_HEAD(savevm_handlers, SaveStateEntry) savevm_handlers =
QTAILQ_HEAD_INITIALIZER(savevm_handlers);
static int global_section_id;
static void dump_vmstate_vmsd(FILE *out_file,
const VMStateDescription *vmsd, int indent,
bool is_subsection);
static void dump_vmstate_vmsf(FILE *out_file, const VMStateField *field,
int indent)
{
fprintf(out_file, "%*s{\n", indent, "");
indent += 2;
fprintf(out_file, "%*s\"field\": \"%s\",\n", indent, "", field->name);
fprintf(out_file, "%*s\"version_id\": %d,\n", indent, "",
field->version_id);
fprintf(out_file, "%*s\"field_exists\": %s,\n", indent, "",
field->field_exists ? "true" : "false");
fprintf(out_file, "%*s\"size\": %zu", indent, "", field->size);
if (field->vmsd != NULL) {
fprintf(out_file, ",\n");
dump_vmstate_vmsd(out_file, field->vmsd, indent, false);
}
fprintf(out_file, "\n%*s}", indent - 2, "");
}
static void dump_vmstate_vmss(FILE *out_file,
const VMStateSubsection *subsection,
int indent)
{
if (subsection->vmsd != NULL) {
dump_vmstate_vmsd(out_file, subsection->vmsd, indent, true);
}
}
static void dump_vmstate_vmsd(FILE *out_file,
const VMStateDescription *vmsd, int indent,
bool is_subsection)
{
if (is_subsection) {
fprintf(out_file, "%*s{\n", indent, "");
} else {
fprintf(out_file, "%*s\"%s\": {\n", indent, "", "Description");
}
indent += 2;
fprintf(out_file, "%*s\"name\": \"%s\",\n", indent, "", vmsd->name);
fprintf(out_file, "%*s\"version_id\": %d,\n", indent, "",
vmsd->version_id);
fprintf(out_file, "%*s\"minimum_version_id\": %d", indent, "",
vmsd->minimum_version_id);
if (vmsd->fields != NULL) {
const VMStateField *field = vmsd->fields;
bool first;
fprintf(out_file, ",\n%*s\"Fields\": [\n", indent, "");
first = true;
while (field->name != NULL) {
if (field->flags & VMS_MUST_EXIST) {
/* Ignore VMSTATE_VALIDATE bits; these don't get migrated */
field++;
continue;
}
if (!first) {
fprintf(out_file, ",\n");
}
dump_vmstate_vmsf(out_file, field, indent + 2);
field++;
first = false;
}
fprintf(out_file, "\n%*s]", indent, "");
}
if (vmsd->subsections != NULL) {
const VMStateSubsection *subsection = vmsd->subsections;
bool first;
fprintf(out_file, ",\n%*s\"Subsections\": [\n", indent, "");
first = true;
while (subsection->vmsd != NULL) {
if (!first) {
fprintf(out_file, ",\n");
}
dump_vmstate_vmss(out_file, subsection, indent + 2);
subsection++;
first = false;
}
fprintf(out_file, "\n%*s]", indent, "");
}
fprintf(out_file, "\n%*s}", indent - 2, "");
}
static void dump_machine_type(FILE *out_file)
{
MachineClass *mc;
mc = MACHINE_GET_CLASS(current_machine);
fprintf(out_file, " \"vmschkmachine\": {\n");
fprintf(out_file, " \"Name\": \"%s\"\n", mc->name);
fprintf(out_file, " },\n");
}
void dump_vmstate_json_to_file(FILE *out_file)
{
GSList *list, *elt;
bool first;
fprintf(out_file, "{\n");
dump_machine_type(out_file);
first = true;
list = object_class_get_list(TYPE_DEVICE, true);
for (elt = list; elt; elt = elt->next) {
DeviceClass *dc = OBJECT_CLASS_CHECK(DeviceClass, elt->data,
TYPE_DEVICE);
const char *name;
int indent = 2;
if (!dc->vmsd) {
continue;
}
if (!first) {
fprintf(out_file, ",\n");
}
name = object_class_get_name(OBJECT_CLASS(dc));
fprintf(out_file, "%*s\"%s\": {\n", indent, "", name);
indent += 2;
fprintf(out_file, "%*s\"Name\": \"%s\",\n", indent, "", name);
fprintf(out_file, "%*s\"version_id\": %d,\n", indent, "",
dc->vmsd->version_id);
fprintf(out_file, "%*s\"minimum_version_id\": %d,\n", indent, "",
dc->vmsd->minimum_version_id);
dump_vmstate_vmsd(out_file, dc->vmsd, indent, false);
fprintf(out_file, "\n%*s}", indent - 2, "");
first = false;
}
fprintf(out_file, "\n}\n");
fclose(out_file);
}
static int calculate_new_instance_id(const char *idstr)
{
SaveStateEntry *se;

345
scripts/vmstate-static-checker.py Executable file
View File

@ -0,0 +1,345 @@
#!/usr/bin/python
#
# Compares vmstate information stored in JSON format, obtained from
# the -dump-vmstate QEMU command.
#
# Copyright 2014 Amit Shah <amit.shah@redhat.com>
# Copyright 2014 Red Hat, Inc.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along
# with this program; if not, see <http://www.gnu.org/licenses/>.
import argparse
import json
import sys
# Count the number of errors found
taint = 0
def bump_taint():
global taint
# Ensure we don't wrap around or reset to 0 -- the shell only has
# an 8-bit return value.
if taint < 255:
taint = taint + 1
def check_fields_match(name, s_field, d_field):
if s_field == d_field:
return True
# Some fields changed names between qemu versions. This list
# is used to whitelist such changes in each section / description.
changed_names = {
'e1000': ['dev', 'parent_obj'],
'ehci': ['dev', 'pcidev'],
'I440FX': ['dev', 'parent_obj'],
'ich9_ahci': ['card', 'parent_obj'],
'ioh-3240-express-root-port': ['port.br.dev',
'parent_obj.parent_obj.parent_obj',
'port.br.dev.exp.aer_log',
'parent_obj.parent_obj.parent_obj.exp.aer_log'],
'mch': ['d', 'parent_obj'],
'pci_bridge': ['bridge.dev', 'parent_obj', 'bridge.dev.shpc', 'shpc'],
'pcnet': ['pci_dev', 'parent_obj'],
'PIIX3': ['pci_irq_levels', 'pci_irq_levels_vmstate'],
'piix4_pm': ['dev', 'parent_obj', 'pci0_status',
'acpi_pci_hotplug.acpi_pcihp_pci_status[0x0]'],
'rtl8139': ['dev', 'parent_obj'],
'qxl': ['num_surfaces', 'ssd.num_surfaces'],
'usb-host': ['dev', 'parent_obj'],
'usb-mouse': ['usb-ptr-queue', 'HIDPointerEventQueue'],
'usb-tablet': ['usb-ptr-queue', 'HIDPointerEventQueue'],
'xhci': ['pci_dev', 'parent_obj'],
'xio3130-express-downstream-port': ['port.br.dev',
'parent_obj.parent_obj.parent_obj',
'port.br.dev.exp.aer_log',
'parent_obj.parent_obj.parent_obj.exp.aer_log'],
'xio3130-express-upstream-port': ['br.dev', 'parent_obj.parent_obj',
'br.dev.exp.aer_log',
'parent_obj.parent_obj.exp.aer_log'],
}
if not name in changed_names:
return False
if s_field in changed_names[name] and d_field in changed_names[name]:
return True
return False
def exists_in_substruct(fields, item):
# Some QEMU versions moved a few fields inside a substruct. This
# kept the on-wire format the same. This function checks if
# something got shifted inside a substruct. For example, the
# change in commit 1f42d22233b4f3d1a2933ff30e8d6a6d9ee2d08f
if not "Description" in fields:
return False
if not "Fields" in fields["Description"]:
return False
substruct_fields = fields["Description"]["Fields"]
if substruct_fields == []:
return False
return check_fields_match(fields["Description"]["name"],
substruct_fields[0]["field"], item)
def check_fields(src_fields, dest_fields, desc, sec):
# This function checks for all the fields in a section. If some
# fields got embedded into a substruct, this function will also
# attempt to check inside the substruct.
d_iter = iter(dest_fields)
s_iter = iter(src_fields)
# Using these lists as stacks to store previous value of s_iter
# and d_iter, so that when time comes to exit out of a substruct,
# we can go back one level up and continue from where we left off.
s_iter_list = []
d_iter_list = []
advance_src = True
advance_dest = True
while True:
if advance_src:
try:
s_item = s_iter.next()
except StopIteration:
if s_iter_list == []:
break
s_iter = s_iter_list.pop()
continue
else:
# We want to avoid advancing just once -- when entering a
# dest substruct, or when exiting one.
advance_src = True
if advance_dest:
try:
d_item = d_iter.next()
except StopIteration:
if d_iter_list == []:
# We were not in a substruct
print "Section \"" + sec + "\",",
print "Description " + "\"" + desc + "\":",
print "expected field \"" + s_item["field"] + "\",",
print "while dest has no further fields"
bump_taint()
break
d_iter = d_iter_list.pop()
advance_src = False
continue
else:
advance_dest = True
if not check_fields_match(desc, s_item["field"], d_item["field"]):
# Some fields were put in substructs, keeping the
# on-wire format the same, but breaking static tools
# like this one.
# First, check if dest has a new substruct.
if exists_in_substruct(d_item, s_item["field"]):
# listiterators don't have a prev() function, so we
# have to store our current location, descend into the
# substruct, and ensure we come out as if nothing
# happened when the substruct is over.
#
# Essentially we're opening the substructs that got
# added which didn't change the wire format.
d_iter_list.append(d_iter)
substruct_fields = d_item["Description"]["Fields"]
d_iter = iter(substruct_fields)
advance_src = False
continue
# Next, check if src has substruct that dest removed
# (can happen in backward migration: 2.0 -> 1.5)
if exists_in_substruct(s_item, d_item["field"]):
s_iter_list.append(s_iter)
substruct_fields = s_item["Description"]["Fields"]
s_iter = iter(substruct_fields)
advance_dest = False
continue
print "Section \"" + sec + "\",",
print "Description \"" + desc + "\":",
print "expected field \"" + s_item["field"] + "\",",
print "got \"" + d_item["field"] + "\"; skipping rest"
bump_taint()
break
check_version(s_item, d_item, sec, desc)
if not "Description" in s_item:
# Check size of this field only if it's not a VMSTRUCT entry
check_size(s_item, d_item, sec, desc, s_item["field"])
check_description_in_list(s_item, d_item, sec, desc)
def check_subsections(src_sub, dest_sub, desc, sec):
for s_item in src_sub:
found = False
for d_item in dest_sub:
if s_item["name"] != d_item["name"]:
continue
found = True
check_descriptions(s_item, d_item, sec)
if not found:
print "Section \"" + sec + "\", Description \"" + desc + "\":",
print "Subsection \"" + s_item["name"] + "\" not found"
bump_taint()
def check_description_in_list(s_item, d_item, sec, desc):
if not "Description" in s_item:
return
if not "Description" in d_item:
print "Section \"" + sec + "\", Description \"" + desc + "\",",
print "Field \"" + s_item["field"] + "\": missing description"
bump_taint()
return
check_descriptions(s_item["Description"], d_item["Description"], sec)
def check_descriptions(src_desc, dest_desc, sec):
check_version(src_desc, dest_desc, sec, src_desc["name"])
if not check_fields_match(sec, src_desc["name"], dest_desc["name"]):
print "Section \"" + sec + "\":",
print "Description \"" + src_desc["name"] + "\"",
print "missing, got \"" + dest_desc["name"] + "\" instead; skipping"
bump_taint()
return
for f in src_desc:
if not f in dest_desc:
print "Section \"" + sec + "\"",
print "Description \"" + src_desc["name"] + "\":",
print "Entry \"" + f + "\" missing"
bump_taint()
continue
if f == 'Fields':
check_fields(src_desc[f], dest_desc[f], src_desc["name"], sec)
if f == 'Subsections':
check_subsections(src_desc[f], dest_desc[f], src_desc["name"], sec)
def check_version(s, d, sec, desc=None):
if s["version_id"] > d["version_id"]:
print "Section \"" + sec + "\"",
if desc:
print "Description \"" + desc + "\":",
print "version error:", s["version_id"], ">", d["version_id"]
bump_taint()
if not "minimum_version_id" in d:
return
if s["version_id"] < d["minimum_version_id"]:
print "Section \"" + sec + "\"",
if desc:
print "Description \"" + desc + "\":",
print "minimum version error:", s["version_id"], "<",
print d["minimum_version_id"]
bump_taint()
def check_size(s, d, sec, desc=None, field=None):
if s["size"] != d["size"]:
print "Section \"" + sec + "\"",
if desc:
print "Description \"" + desc + "\"",
if field:
print "Field \"" + field + "\"",
print "size mismatch:", s["size"], ",", d["size"]
bump_taint()
def check_machine_type(s, d):
if s["Name"] != d["Name"]:
print "Warning: checking incompatible machine types:",
print "\"" + s["Name"] + "\", \"" + d["Name"] + "\""
return
def main():
help_text = "Parse JSON-formatted vmstate dumps from QEMU in files SRC and DEST. Checks whether migration from SRC to DEST QEMU versions would break based on the VMSTATE information contained within the JSON outputs. The JSON output is created from a QEMU invocation with the -dump-vmstate parameter and a filename argument to it. Other parameters to QEMU do not matter, except the -M (machine type) parameter."
parser = argparse.ArgumentParser(description=help_text)
parser.add_argument('-s', '--src', type=file, required=True,
help='json dump from src qemu')
parser.add_argument('-d', '--dest', type=file, required=True,
help='json dump from dest qemu')
parser.add_argument('--reverse', required=False, default=False,
action='store_true',
help='reverse the direction')
args = parser.parse_args()
src_data = json.load(args.src)
dest_data = json.load(args.dest)
args.src.close()
args.dest.close()
if args.reverse:
temp = src_data
src_data = dest_data
dest_data = temp
for sec in src_data:
if not sec in dest_data:
print "Section \"" + sec + "\" does not exist in dest"
bump_taint()
continue
s = src_data[sec]
d = dest_data[sec]
if sec == "vmschkmachine":
check_machine_type(s, d)
continue
check_version(s, d, sec)
for entry in s:
if not entry in d:
print "Section \"" + sec + "\": Entry \"" + entry + "\"",
print "missing"
bump_taint()
continue
if entry == "Description":
check_descriptions(s[entry], d[entry], sec)
return taint
if __name__ == '__main__':
sys.exit(main())

293
tests/test-vmstate.c
View File

@ -54,80 +54,232 @@ static QEMUFile *open_test_file(bool write)
return qemu_fdopen(fd, write ? "wb" : "rb");
}
typedef struct TestSruct {
#define SUCCESS(val) \
g_assert_cmpint((val), ==, 0)
#define FAILURE(val) \
g_assert_cmpint((val), !=, 0)
static void save_vmstate(const VMStateDescription *desc, void *obj)
{
QEMUFile *f = open_test_file(true);
/* Save file with vmstate */
vmstate_save_state(f, desc, obj);
qemu_put_byte(f, QEMU_VM_EOF);
g_assert(!qemu_file_get_error(f));
qemu_fclose(f);
}
static void compare_vmstate(uint8_t *wire, size_t size)
{
QEMUFile *f = open_test_file(false);
uint8_t result[size];
/* read back as binary */
g_assert_cmpint(qemu_get_buffer(f, result, sizeof(result)), ==,
sizeof(result));
g_assert(!qemu_file_get_error(f));
/* Compare that what is on the file is the same that what we
expected to be there */
SUCCESS(memcmp(result, wire, sizeof(result)));
/* Must reach EOF */
qemu_get_byte(f);
g_assert_cmpint(qemu_file_get_error(f), ==, -EIO);
qemu_fclose(f);
}
static int load_vmstate_one(const VMStateDescription *desc, void *obj,
int version, uint8_t *wire, size_t size)
{
QEMUFile *f;
int ret;
f = open_test_file(true);
qemu_put_buffer(f, wire, size);
qemu_fclose(f);
f = open_test_file(false);
ret = vmstate_load_state(f, desc, obj, version);
if (ret) {
g_assert(qemu_file_get_error(f));
} else{
g_assert(!qemu_file_get_error(f));
}
qemu_fclose(f);
return ret;
}
static int load_vmstate(const VMStateDescription *desc,
void *obj, void *obj_clone,
void (*obj_copy)(void *, void*),
int version, uint8_t *wire, size_t size)
{
/* We test with zero size */
obj_copy(obj_clone, obj);
FAILURE(load_vmstate_one(desc, obj, version, wire, 0));
/* Stream ends with QEMU_EOF, so we need at least 3 bytes to be
* able to test in the middle */
if (size > 3) {
/* We test with size - 2. We can't test size - 1 due to EOF tricks */
obj_copy(obj, obj_clone);
FAILURE(load_vmstate_one(desc, obj, version, wire, size - 2));
/* Test with size/2, first half of real state */
obj_copy(obj, obj_clone);
FAILURE(load_vmstate_one(desc, obj, version, wire, size/2));
/* Test with size/2, second half of real state */
obj_copy(obj, obj_clone);
FAILURE(load_vmstate_one(desc, obj, version, wire + (size/2), size/2));
}
obj_copy(obj, obj_clone);
return load_vmstate_one(desc, obj, version, wire, size);
}
/* Test struct that we are going to use for our tests */
typedef struct TestSimple {
bool b_1, b_2;
uint8_t u8_1;
uint16_t u16_1;
uint32_t u32_1;
uint64_t u64_1;
int8_t i8_1, i8_2;
int16_t i16_1, i16_2;
int32_t i32_1, i32_2;
int64_t i64_1, i64_2;
} TestSimple;
/* Object instantiation, we are going to use it in more than one test */
TestSimple obj_simple = {
.b_1 = true,
.b_2 = false,
.u8_1 = 130,
.u16_1 = 512,
.u32_1 = 70000,
.u64_1 = 12121212,
.i8_1 = 65,
.i8_2 = -65,
.i16_1 = 512,
.i16_2 = -512,
.i32_1 = 70000,
.i32_2 = -70000,
.i64_1 = 12121212,
.i64_2 = -12121212,
};
/* Description of the values. If you add a primitive type
you are expected to add a test here */
static const VMStateDescription vmstate_simple_primitive = {
.name = "simple/primitive",
.version_id = 1,
.minimum_version_id = 1,
.fields = (VMStateField[]) {
VMSTATE_BOOL(b_1, TestSimple),
VMSTATE_BOOL(b_2, TestSimple),
VMSTATE_UINT8(u8_1, TestSimple),
VMSTATE_UINT16(u16_1, TestSimple),
VMSTATE_UINT32(u32_1, TestSimple),
VMSTATE_UINT64(u64_1, TestSimple),
VMSTATE_INT8(i8_1, TestSimple),
VMSTATE_INT8(i8_2, TestSimple),
VMSTATE_INT16(i16_1, TestSimple),
VMSTATE_INT16(i16_2, TestSimple),
VMSTATE_INT32(i32_1, TestSimple),
VMSTATE_INT32(i32_2, TestSimple),
VMSTATE_INT64(i64_1, TestSimple),
VMSTATE_INT64(i64_2, TestSimple),
VMSTATE_END_OF_LIST()
}
};
/* It describes what goes through the wire. Our tests are basically:
* save test
- save a struct a vmstate to a file
- read that file back (binary read, no vmstate)
- compare it with what we expect to be on the wire
* load test
- save to the file what we expect to be on the wire
- read struct back with vmstate in a different
- compare back with the original struct
*/
uint8_t wire_simple_primitive[] = {
/* b_1 */ 0x01,
/* b_2 */ 0x00,
/* u8_1 */ 0x82,
/* u16_1 */ 0x02, 0x00,
/* u32_1 */ 0x00, 0x01, 0x11, 0x70,
/* u64_1 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0xb8, 0xf4, 0x7c,
/* i8_1 */ 0x41,
/* i8_2 */ 0xbf,
/* i16_1 */ 0x02, 0x00,
/* i16_2 */ 0xfe, 0x0,
/* i32_1 */ 0x00, 0x01, 0x11, 0x70,
/* i32_2 */ 0xff, 0xfe, 0xee, 0x90,
/* i64_1 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0xb8, 0xf4, 0x7c,
/* i64_2 */ 0xff, 0xff, 0xff, 0xff, 0xff, 0x47, 0x0b, 0x84,
QEMU_VM_EOF, /* just to ensure we won't get EOF reported prematurely */
};
static void obj_simple_copy(void *target, void *source)
{
memcpy(target, source, sizeof(TestSimple));
}
static void test_simple_primitive(void)
{
TestSimple obj, obj_clone;
memset(&obj, 0, sizeof(obj));
save_vmstate(&vmstate_simple_primitive, &obj_simple);
compare_vmstate(wire_simple_primitive, sizeof(wire_simple_primitive));
SUCCESS(load_vmstate(&vmstate_simple_primitive, &obj, &obj_clone,
obj_simple_copy, 1, wire_simple_primitive,
sizeof(wire_simple_primitive)));
#define FIELD_EQUAL(name) g_assert_cmpint(obj.name, ==, obj_simple.name)
FIELD_EQUAL(b_1);
FIELD_EQUAL(b_2);
FIELD_EQUAL(u8_1);
FIELD_EQUAL(u16_1);
FIELD_EQUAL(u32_1);
FIELD_EQUAL(u64_1);
FIELD_EQUAL(i8_1);
FIELD_EQUAL(i8_2);
FIELD_EQUAL(i16_1);
FIELD_EQUAL(i16_2);
FIELD_EQUAL(i32_1);
FIELD_EQUAL(i32_2);
FIELD_EQUAL(i64_1);
FIELD_EQUAL(i64_2);
}
#undef FIELD_EQUAL
typedef struct TestStruct {
uint32_t a, b, c, e;
uint64_t d, f;
bool skip_c_e;
} TestStruct;
static const VMStateDescription vmstate_simple = {
.name = "test",
.version_id = 1,
.minimum_version_id = 1,
.fields = (VMStateField[]) {
VMSTATE_UINT32(a, TestStruct),
VMSTATE_UINT32(b, TestStruct),
VMSTATE_UINT32(c, TestStruct),
VMSTATE_UINT64(d, TestStruct),
VMSTATE_END_OF_LIST()
}
};
static void test_simple_save(void)
{
QEMUFile *fsave = open_test_file(true);
TestStruct obj = { .a = 1, .b = 2, .c = 3, .d = 4 };
vmstate_save_state(fsave, &vmstate_simple, &obj);
g_assert(!qemu_file_get_error(fsave));
qemu_fclose(fsave);
QEMUFile *loading = open_test_file(false);
uint8_t expected[] = {
0, 0, 0, 1, /* a */
0, 0, 0, 2, /* b */
0, 0, 0, 3, /* c */
0, 0, 0, 0, 0, 0, 0, 4, /* d */
};
uint8_t result[sizeof(expected)];
g_assert_cmpint(qemu_get_buffer(loading, result, sizeof(result)), ==,
sizeof(result));
g_assert(!qemu_file_get_error(loading));
g_assert_cmpint(memcmp(result, expected, sizeof(result)), ==, 0);
/* Must reach EOF */
qemu_get_byte(loading);
g_assert_cmpint(qemu_file_get_error(loading), ==, -EIO);
qemu_fclose(loading);
}
static void test_simple_load(void)
{
QEMUFile *fsave = open_test_file(true);
uint8_t buf[] = {
0, 0, 0, 10, /* a */
0, 0, 0, 20, /* b */
0, 0, 0, 30, /* c */
0, 0, 0, 0, 0, 0, 0, 40, /* d */
QEMU_VM_EOF, /* just to ensure we won't get EOF reported prematurely */
};
qemu_put_buffer(fsave, buf, sizeof(buf));
qemu_fclose(fsave);
QEMUFile *loading = open_test_file(false);
TestStruct obj;
vmstate_load_state(loading, &vmstate_simple, &obj, 1);
g_assert(!qemu_file_get_error(loading));
g_assert_cmpint(obj.a, ==, 10);
g_assert_cmpint(obj.b, ==, 20);
g_assert_cmpint(obj.c, ==, 30);
g_assert_cmpint(obj.d, ==, 40);
qemu_fclose(loading);
}
static const VMStateDescription vmstate_versioned = {
.name = "test",
.name = "test/versioned",
.version_id = 2,
.minimum_version_id = 1,
.fields = (VMStateField[]) {
@ -202,7 +354,7 @@ static bool test_skip(void *opaque, int version_id)
}
static const VMStateDescription vmstate_skipping = {
.name = "test",
.name = "test/skip",
.version_id = 2,
.minimum_version_id = 1,
.fields = (VMStateField[]) {
@ -337,8 +489,7 @@ int main(int argc, char **argv)
temp_fd = mkstemp(temp_file);
g_test_init(&argc, &argv, NULL);
g_test_add_func("/vmstate/simple/save", test_simple_save);
g_test_add_func("/vmstate/simple/load", test_simple_load);
g_test_add_func("/vmstate/simple/primitive", test_simple_primitive);
g_test_add_func("/vmstate/versioned/load/v1", test_load_v1);
g_test_add_func("/vmstate/versioned/load/v2", test_load_v2);
g_test_add_func("/vmstate/field_exists/load/noskip", test_load_noskip);

1163
tests/vmstate-static-checker-data/dump1.json Normal file
View File

File diff suppressed because it is too large Load Diff

968
tests/vmstate-static-checker-data/dump2.json Normal file
View File

@ -0,0 +1,968 @@
{
"vmschkmachine": {
"Name": "pc-i440fx-2.2"
},
"fw_cfg2": {
"Name": "fw_cfg",
"version_id": 2,
"minimum_version_id": 1,
"Description": {
"name": "fw_cfg",
"version_id": 2,
"minimum_version_id": 1,
"Fields": [
{
"field": "cur_entry",
"version_id": 0,
"field_exists": false,
"size": 2
},
{
"field": "cur_offset",
"version_id": 0,
"field_exists": true,
"size": 4
},
{
"field": "cur_offset",
"version_id": 2,
"field_exists": false,
"size": 4
}
]
}
},
"fusbh200-ehci-usb": {
"Name": "fusbh200-ehci-usb",
"version_id": 1,
"minimum_version_id": 1,
"Description": {
"name": "ehci-sysbus",
"version_id": 2,
"minimum_version_id": 1,
"Fields": [
{
"field": "ehci",
"version_id": 2,
"field_exists": false,
"size": 1880,
"Description": {
"name": "ehci-core",
"version_id": 2,
"minimum_version_id": 1,
"Fields": [
{
"field": "usbcmd",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "usbsts_pending",
"version_id": 2,
"field_exists": false,
"size": 4
},
{
"field": "usbsts_frindex",
"version_id": 2,
"field_exists": false,
"size": 4
},
{
"field": "usbintr",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "frindex",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "ctrldssegment",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "periodiclistbase",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "asynclistaddr",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "configflag",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "portsc[0]",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "portsc[1]",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "portsc[2]",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "portsc[3]",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "portsc[4]",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "portsc[5]",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "frame_timer",
"version_id": 0,
"field_exists": false,
"size": 8
},
{
"field": "last_run_ns",
"version_id": 0,
"field_exists": false,
"size": 8
},
{
"field": "async_stepdown",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "astate",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "pstate",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "a_fetch_addr",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "p_fetch_addr",
"version_id": 0,
"field_exists": false,
"size": 4
}
]
}
}
]
}
},
"pci-serial-4x": {
"Name": "pci-serial-4x",
"version_id": 1,
"minimum_version_id": 1,
"Description": {
"name": "pci-serial-multi",
"version_id": 1,
"minimum_version_id": 1
}
},
"intel-hda-generic": {
"Name": "intel-hda-generic",
"version_id": 1,
"minimum_version_id": 0,
"Description": {
"name": "intel-hda",
"version_id": 1,
"minimum_version_id": 0,
"Fields": [
{
"field": "pci",
"version_id": 0,
"field_exists": false,
"size": 1944
},
{
"field": "g_ctl",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "wake_en",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "state_sts",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "int_ctl",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "int_sts",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "wall_clk",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "corb_lbase",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "corb_ubase",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "corb_rp",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "corb_wp",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "corb_ctl",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "corb_sts",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "corb_size",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "rirb_lbase",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "rirb_ubase",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "rirb_wp",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "rirb_cnt",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "rirb_ctl",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "rirb_sts",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "rirb_size",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "dp_lbase",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "dp_ubase",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "icw",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "irr",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "ics",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "st",
"version_id": 0,
"field_exists": false,
"size": 56,
"Description": {
"name": "intel-hda-stream",
"version_id": 1,
"minimum_version_id": 0,
"Fields": [
{
"field": "ctl",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "lpib",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "cbl",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "lvi",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "fmt",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "bdlp_lbase",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "bdlp_ubase",
"version_id": 0,
"field_exists": false,
"size": 4
}
]
}
},
{
"field": "rirb_count",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "wall_base_ns",
"version_id": 0,
"field_exists": false,
"size": 8
}
]
}
},
"cfi.pflash01": {
"Name": "cfi.pflash01",
"version_id": 1,
"minimum_version_id": 1
},
"megasas": {
"Name": "megasas",
"version_id": 0,
"minimum_version_id": 0,
"Description": {
"name": "megasas",
"version_id": 0,
"minimum_version_id": 0,
"Fields": [
{
"field": "parent_obj",
"version_id": 0,
"field_exists": false,
"size": 1944,
"Description": {
"name": "PCIDevice",
"version_id": 2,
"minimum_version_id": 1,
"Fields": [
{
"field": "version_id",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "config",
"version_id": 0,
"field_exists": false,
"size": 256
}
]
}
},
{
"field": "fw_state",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "intr_mask",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "doorbell",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "reply_queue_pa",
"version_id": 0,
"field_exists": false,
"size": 8
},
{
"field": "consumer_pa",
"version_id": 0,
"field_exists": false,
"size": 8
},
{
"field": "producer_pa",
"version_id": 0,
"field_exists": false,
"size": 8
}
]
}
},
"PIIX3-xen": {
"Name": "PIIX3-xen",
"version_id": 3,
"minimum_version_id": 2,
"Description": {
"name": "PIIX3",
"version_id": 3,
"minimum_version_id": 2,
"Fields": [
{
"field": "dev",
"version_id": 0,
"field_exists": false,
"size": 1944,
"Description": {
"name": "PCIDevice",
"version_id": 2,
"minimum_version_id": 1,
"Fields": [
{
"field": "version_id",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "config",
"version_id": 0,
"field_exists": false,
"size": 256
},
{
"field": "irq_state",
"version_id": 2,
"field_exists": false,
"size": 16
}
]
}
},
{
"field": "pci_irq_levels_vmstate",
"version_id": 3,
"field_exists": false,
"size": 4
}
]
}
},
"tpci200": {
"Name": "tpci200",
"version_id": 1,
"minimum_version_id": 1,
"Description": {
"name": "tpci2002",
"version_id": 1,
"minimum_version_id": 1,
"Fields": [
{
"field": "dev",
"version_id": 0,
"field_exists": false,
"size": 1944,
"Description": {
"name": "PCIDevice",
"version_id": 2,
"minimum_version_id": 1,
"Fields": [
{
"field": "version_id",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "config",
"version_id": 0,
"field_exists": false,
"size": 256
},
{
"field": "irq_state",
"version_id": 2,
"field_exists": false,
"size": 16
}
]
}
},
{
"field": "big_endian",
"version_id": 0,
"field_exists": false,
"size": 1
},
{
"field": "ctrl",
"version_id": 0,
"field_exists": false,
"size": 1
},
{
"field": "status",
"version_id": 0,
"field_exists": false,
"size": 2
},
{
"field": "int_set",
"version_id": 0,
"field_exists": false,
"size": 1
}
]
}
},
"SUNW,fdtwo": {
"Name": "SUNW,fdtwo",
"version_id": 2,
"minimum_version_id": 2,
"Description": {
"name": "fdc",
"version_id": 1,
"minimum_version_id": 2,
"Fields": [
{
"field": "state",
"version_id": 0,
"field_exists": false,
"size": 360,
"Description": {
"name": "fdc",
"version_id": 2,
"minimum_version_id": 2,
"Fields": [
{
"field": "sra",
"version_id": 0,
"field_exists": false,
"size": 1
},
{
"field": "srb",
"version_id": 0,
"field_exists": false,
"size": 1
},
{
"field": "dor_vmstate",
"version_id": 0,
"field_exists": false,
"size": 1
},
{
"field": "tdr",
"version_id": 0,
"field_exists": false,
"size": 1
},
{
"field": "dsr",
"version_id": 0,
"field_exists": false,
"size": 1
},
{
"field": "msr",
"version_id": 0,
"field_exists": false,
"size": 1
},
{
"field": "status0",
"version_id": 0,
"field_exists": false,
"size": 1
},
{
"field": "status1",
"version_id": 0,
"field_exists": false,
"size": 1
},
{
"field": "status2",
"version_id": 0,
"field_exists": false,
"size": 1
},
{
"field": "fifo",
"version_id": 0,
"field_exists": false,
"size": 1
},
{
"field": "data_pos",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "data_len",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "data_state",
"version_id": 0,
"field_exists": false,
"size": 1
},
{
"field": "data_dir",
"version_id": 0,
"field_exists": false,
"size": 1
},
{
"field": "eot",
"version_id": 0,
"field_exists": false,
"size": 1
},
{
"field": "timer0",
"version_id": 0,
"field_exists": false,
"size": 1
},
{
"field": "timer1",
"version_id": 0,
"field_exists": false,
"size": 1
},
{
"field": "precomp_trk",
"version_id": 0,
"field_exists": false,
"size": 1
},
{
"field": "config",
"version_id": 0,
"field_exists": false,
"size": 1
},
{
"field": "lock",
"version_id": 0,
"field_exists": false,
"size": 1
},
{
"field": "pwrd",
"version_id": 0,
"field_exists": false,
"size": 1
},
{
"field": "num_floppies",
"version_id": 0,
"field_exists": false,
"size": 1
},
{
"field": "drives",
"version_id": 1,
"field_exists": false,
"size": 40,
"Description": {
"name": "fdrive",
"version_id": 1,
"minimum_version_id": 1,
"Fields": [
{
"field": "head",
"version_id": 0,
"field_exists": false,
"size": 1
},
{
"field": "track",
"version_id": 0,
"field_exists": false,
"size": 1
},
{
"field": "sect",
"version_id": 0,
"field_exists": false,
"size": 1
}
],
"Subsections": [
{
"name": "fdrive/media_changed",
"version_id": 1,
"minimum_version_id": 1,
"Fields": [
{
"field": "media_changed",
"version_id": 0,
"field_exists": false,
"size": 1
}
]
}
]
}
}
]
}
}
]
}
},
"usb-kbd": {
"Name": "usb-kbd",
"version_id": 1,
"minimum_version_id": 1,
"Description": {
"name": "usb-kbd",
"version_id": 1,
"minimum_version_id": 1,
"Fields": [
{
"field": "dev",
"version_id": 0,
"field_exists": false,
"size": 5832,
"Description": {
"name": "USBDevice",
"version_id": 1,
"minimum_version_id": 1,
"Fields": [
{
"field": "addr",
"version_id": 0,
"field_exists": false,
"size": 1
},
{
"field": "state",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "remote_wakeup",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "setup_state",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "setup_len",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "setup_index",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "setup_buf",
"version_id": 0,
"field_exists": false,
"size": 1
}
]
}
},
{
"field": "hid",
"version_id": 0,
"field_exists": false,
"size": 312,
"Description": {
"name": "HIDKeyboardDevice",
"version_id": 1,
"minimum_version_id": 1,
"Fields": [
{
"field": "kbd.keycodes",
"version_id": 0,
"field_exists": false,
"size": 2
},
{
"field": "head",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "n",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "kbd.modifiers",
"version_id": 0,
"field_exists": false,
"size": 2
},
{
"field": "kbd.leds",
"version_id": 0,
"field_exists": false,
"size": 1
},
{
"field": "kbd.key",
"version_id": 0,
"field_exists": false,
"size": 1
},
{
"field": "kbd.keys",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "protocol",
"version_id": 0,
"field_exists": false,
"size": 4
},
{
"field": "idle",
"version_id": 0,
"field_exists": false,
"size": 1
}
]
}
}
]
}
}
}

13
vl.c
View File

@ -2931,6 +2931,7 @@ int main(int argc, char **argv, char **envp)
1024 * 1024;
ram_addr_t maxram_size = default_ram_size;
uint64_t ram_slots = 0;
FILE *vmstate_dump_file = NULL;
atexit(qemu_run_exit_notifiers);
error_set_progname(argv[0]);
@ -3937,6 +3938,13 @@ int main(int argc, char **argv, char **envp)
}
configure_msg(opts);
break;
case QEMU_OPTION_dump_vmstate:
vmstate_dump_file = fopen(optarg, "w");
if (vmstate_dump_file == NULL) {
fprintf(stderr, "open %s: %s\n", optarg, strerror(errno));
exit(1);
}
break;
default:
os_parse_cmd_args(popt->index, optarg);
}
@ -4488,6 +4496,11 @@ int main(int argc, char **argv, char **envp)
}
qdev_prop_check_global();
if (vmstate_dump_file) {
/* dump and exit */
dump_vmstate_json_to_file(vmstate_dump_file);
return 0;
}
if (incoming) {
Error *local_err = NULL;

4
vmstate.c
View File

@ -98,7 +98,11 @@ int vmstate_load_state(QEMUFile *f, const VMStateDescription *vmsd,
ret = field->info->get(f, addr, size);
}
if (ret >= 0) {
ret = qemu_file_get_error(f);
}
if (ret < 0) {
qemu_file_set_error(f, ret);
trace_vmstate_load_field_error(field->name, ret);
return ret;
}