From nobody Fri Mar 27 04:54:24 2026 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass(p=none dis=none) header.from=yandex-team.ru ARC-Seal: i=1; a=rsa-sha256; t=1772659543; cv=none; d=zohomail.com; s=zohoarc; b=bjwR4FX3ZypkSgHkk9YoFd+8RLu9VR0jsLhh0FlAkAES97BIO7MUfMy6m5z1GqpSqtRXDJEdAozgxRTNhR2dLRXRSOP2xvlldKQTj9cZcO4Ps1oWML0TOxzNKCR1x7P/UVGh8b1zXio79prPjDH5ktCV1TSuaQsVr3Cp+cZ7TNo= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1772659543; h=Content-Transfer-Encoding:Cc:Cc:Date:Date:From:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:Subject:To:To:Message-Id:Reply-To; bh=UtnHbDk48f1TJXfXCu1SF3bXPtua/RuWDioyi3p5LQE=; b=nVPuJ2dplx450TC6pu0lNbvFlPt0GGBwZT3klcsjRhWKlJfzMQvBO2Ec/+zszprNZgIbbDVLM6Bc8UbmMaEy3VqHz6iLuN4BoWOOlaE5WkJ90GOB5cb58hIQ9IAXBygdDgX+NZ5gVqewaDMjxtRvLz+yopOFywfwIz98psGVKJY= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=pass; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=pass header.from= (p=none dis=none) Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 177265954218892.32682687498959; Wed, 4 Mar 2026 13:25:42 -0800 (PST) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1vxth8-0004r8-JK; Wed, 04 Mar 2026 16:23:50 -0500 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1vxtgk-0004mI-Da for qemu-devel@nongnu.org; Wed, 04 Mar 2026 16:23:28 -0500 Received: from forwardcorp1d.mail.yandex.net ([178.154.239.200]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1vxtgg-0003Vb-PJ for qemu-devel@nongnu.org; Wed, 04 Mar 2026 16:23:26 -0500 Received: from mail-nwsmtp-smtp-corp-main-66.iva.yp-c.yandex.net (mail-nwsmtp-smtp-corp-main-66.iva.yp-c.yandex.net [IPv6:2a02:6b8:c0c:bf1f:0:640:c739:0]) by forwardcorp1d.mail.yandex.net (Yandex) with ESMTPS id 7CAF9807E8; Thu, 05 Mar 2026 00:23:21 +0300 (MSK) Received: from vsementsov-lin (unknown [2a02:6bf:8080:921::1:1b]) by mail-nwsmtp-smtp-corp-main-66.iva.yp-c.yandex.net (smtpcorp/Yandex) with ESMTPSA id 5NwBA90AmW20-etuaX0gZ; Thu, 05 Mar 2026 00:23:20 +0300 X-Yandex-Fwd: 1 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=yandex-team.ru; s=default; t=1772659400; bh=UtnHbDk48f1TJXfXCu1SF3bXPtua/RuWDioyi3p5LQE=; h=Message-ID:Date:In-Reply-To:Cc:Subject:References:To:From; b=JSAQp8CTkTfRL21RASPAgHmbXjVTaUEVVdXNvIDhTMs+0YuSsxWnjuU0BdbMgPCzn Ha3Np04LOL6KbIYxyLyeaeT9YCdNh1SnMIA5EDe5FVYb8/22y+22mjc2I7DMMgjTgs zQITExP2f1PiaOk5bQj2E3gzJq/9Qt/IlIQURnvE= Authentication-Results: mail-nwsmtp-smtp-corp-main-66.iva.yp-c.yandex.net; dkim=pass header.i=@yandex-team.ru From: Vladimir Sementsov-Ogievskiy To: peterx@redhat.com Cc: farosas@suse.de, vsementsov@yandex-team.ru, qemu-devel@nongnu.org Subject: [PATCH v3 18/18] migration/vmstate-types: move to new migration APIs Date: Thu, 5 Mar 2026 00:23:02 +0300 Message-ID: <20260304212303.667141-19-vsementsov@yandex-team.ru> X-Mailer: git-send-email 2.52.0 In-Reply-To: <20260304212303.667141-1-vsementsov@yandex-team.ru> References: <20260304212303.667141-1-vsementsov@yandex-team.ru> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=178.154.239.200; envelope-from=vsementsov@yandex-team.ru; helo=forwardcorp1d.mail.yandex.net X-Spam_score_int: 0 X-Spam_score: -0.0 X-Spam_bar: / X-Spam_report: (-0.0 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_VALIDITY_RPBL_BLOCKED=0.703, RCVD_IN_VALIDITY_SAFE_BLOCKED=1.386, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=no autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: qemu development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: qemu-devel-bounces+importer=patchew.org@nongnu.org X-ZohoMail-DKIM: pass (identity @yandex-team.ru) X-ZM-MESSAGEID: 1772659546206139100 Content-Type: text/plain; charset="utf-8" Signed-off-by: Vladimir Sementsov-Ogievskiy Reviewed-by: Peter Xu --- migration/trace-events | 24 +- migration/vmstate-types.c | 627 +++++++++++++++++++------------------- 2 files changed, 327 insertions(+), 324 deletions(-) diff --git a/migration/trace-events b/migration/trace-events index 0b3f759ccc4..5fe3cc59c01 100644 --- a/migration/trace-events +++ b/migration/trace-events @@ -73,20 +73,20 @@ vmstate_subsection_save_top(const char *idstr) "%s" vmstate_field_exists(const char *vmsd, const char *name, int field_version= , int version, int result) "%s:%s field_version %d version %d result %d" =20 # vmstate-types.c -get_qtailq(const char *name, int version_id) "%s v%d" -get_qtailq_end(const char *name, const char *reason, int val) "%s %s/%d" -put_qtailq(const char *name, int version_id) "%s v%d" -put_qtailq_end(const char *name, const char *reason) "%s %s" +load_qtailq(const char *name, int version_id) "%s v%d" +load_qtailq_end(const char *name) "%s" +save_qtailq(const char *name, int version_id) "%s v%d" +save_qtailq_end(const char *name) "%s" =20 -get_gtree(const char *field_name, const char *key_vmsd_name, const char *v= al_vmsd_name, uint32_t nnodes) "%s(%s/%s) nnodes=3D%d" -get_gtree_end(const char *field_name, const char *key_vmsd_name, const cha= r *val_vmsd_name, int ret) "%s(%s/%s) %d" -put_gtree(const char *field_name, const char *key_vmsd_name, const char *v= al_vmsd_name, uint32_t nnodes) "%s(%s/%s) nnodes=3D%d" -put_gtree_end(const char *field_name, const char *key_vmsd_name, const cha= r *val_vmsd_name, int ret) "%s(%s/%s) %d" +load_gtree(const char *field_name, const char *key_vmsd_name, const char *= val_vmsd_name, uint32_t nnodes) "%s(%s/%s) nnodes=3D%d" +load_gtree_end(const char *field_name, const char *key_vmsd_name, const ch= ar *val_vmsd_name) "%s(%s/%s)" +save_gtree(const char *field_name, const char *key_vmsd_name, const char *= val_vmsd_name, uint32_t nnodes) "%s(%s/%s) nnodes=3D%d" +save_gtree_end(const char *field_name, const char *key_vmsd_name, const ch= ar *val_vmsd_name) "%s(%s/%s)" =20 -get_qlist(const char *field_name, const char *vmsd_name, int version_id) "= %s(%s v%d)" -get_qlist_end(const char *field_name, const char *vmsd_name) "%s(%s)" -put_qlist(const char *field_name, const char *vmsd_name, int version_id) "= %s(%s v%d)" -put_qlist_end(const char *field_name, const char *vmsd_name) "%s(%s)" +load_qlist(const char *field_name, const char *vmsd_name, int version_id) = "%s(%s v%d)" +load_qlist_end(const char *field_name, const char *vmsd_name) "%s(%s)" +save_qlist(const char *field_name, const char *vmsd_name, int version_id) = "%s(%s v%d)" +save_qlist_end(const char *field_name, const char *vmsd_name) "%s(%s)" =20 # qemu-file.c qemu_file_fclose(void) "" diff --git a/migration/vmstate-types.c b/migration/vmstate-types.c index 033a2685c8f..23f34336964 100644 --- a/migration/vmstate-types.c +++ b/migration/vmstate-types.c @@ -23,129 +23,135 @@ =20 /* bool */ =20 -static int get_bool(QEMUFile *f, void *pv, size_t size, - const VMStateField *field) +static bool load_bool(QEMUFile *f, void *pv, size_t size, + const VMStateField *field, Error **errp) { bool *v =3D pv; *v =3D qemu_get_byte(f); - return 0; + return true; } =20 -static int put_bool(QEMUFile *f, void *pv, size_t size, - const VMStateField *field, JSONWriter *vmdesc) +static bool save_bool(QEMUFile *f, void *pv, size_t size, + const VMStateField *field, JSONWriter *vmdesc, + Error **errp) { bool *v =3D pv; qemu_put_byte(f, *v); - return 0; + return true; } =20 const VMStateInfo vmstate_info_bool =3D { .name =3D "bool", - .get =3D get_bool, - .put =3D put_bool, + .load =3D load_bool, + .save =3D save_bool, }; =20 /* 8 bit int */ =20 -static int get_int8(QEMUFile *f, void *pv, size_t size, - const VMStateField *field) +static bool load_int8(QEMUFile *f, void *pv, size_t size, + const VMStateField *field, Error **errp) { int8_t *v =3D pv; qemu_get_s8s(f, v); - return 0; + return true; } =20 -static int put_int8(QEMUFile *f, void *pv, size_t size, - const VMStateField *field, JSONWriter *vmdesc) +static bool save_int8(QEMUFile *f, void *pv, size_t size, + const VMStateField *field, JSONWriter *vmdesc, + Error **errp) { int8_t *v =3D pv; qemu_put_s8s(f, v); - return 0; + return true; } =20 const VMStateInfo vmstate_info_int8 =3D { .name =3D "int8", - .get =3D get_int8, - .put =3D put_int8, + .load =3D load_int8, + .save =3D save_int8, }; =20 /* 16 bit int */ =20 -static int get_int16(QEMUFile *f, void *pv, size_t size, - const VMStateField *field) +static bool load_int16(QEMUFile *f, void *pv, size_t size, + const VMStateField *field, Error **errp) { int16_t *v =3D pv; qemu_get_sbe16s(f, v); - return 0; + return true; } =20 -static int put_int16(QEMUFile *f, void *pv, size_t size, - const VMStateField *field, JSONWriter *vmdesc) +static bool save_int16(QEMUFile *f, void *pv, size_t size, + const VMStateField *field, JSONWriter *vmdesc, + Error **errp) { int16_t *v =3D pv; qemu_put_sbe16s(f, v); - return 0; + return true; } =20 const VMStateInfo vmstate_info_int16 =3D { .name =3D "int16", - .get =3D get_int16, - .put =3D put_int16, + .load =3D load_int16, + .save =3D save_int16, }; =20 /* 32 bit int */ =20 -static int get_int32(QEMUFile *f, void *pv, size_t size, - const VMStateField *field) +static bool load_int32(QEMUFile *f, void *pv, size_t size, + const VMStateField *field, Error **errp) { int32_t *v =3D pv; qemu_get_sbe32s(f, v); - return 0; + return true; } =20 -static int put_int32(QEMUFile *f, void *pv, size_t size, - const VMStateField *field, JSONWriter *vmdesc) +static bool save_int32(QEMUFile *f, void *pv, size_t size, + const VMStateField *field, JSONWriter *vmdesc, + Error **errp) { int32_t *v =3D pv; qemu_put_sbe32s(f, v); - return 0; + return true; } =20 const VMStateInfo vmstate_info_int32 =3D { .name =3D "int32", - .get =3D get_int32, - .put =3D put_int32, + .load =3D load_int32, + .save =3D save_int32, }; =20 /* 32 bit int. See that the received value is the same than the one in the field */ =20 -static int get_int32_equal(QEMUFile *f, void *pv, size_t size, - const VMStateField *field) +static bool load_int32_equal(QEMUFile *f, void *pv, size_t size, + const VMStateField *field, Error **errp) { + ERRP_GUARD(); int32_t *v =3D pv; int32_t v2; qemu_get_sbe32s(f, &v2); =20 if (*v =3D=3D v2) { - return 0; + return true; } - error_report("%" PRIx32 " !=3D %" PRIx32, *v, v2); - return -EINVAL; + + error_setg(errp, "%" PRIx32 " !=3D %" PRIx32, *v, v2); + return false; } =20 const VMStateInfo vmstate_info_int32_equal =3D { .name =3D "int32 equal", - .get =3D get_int32_equal, - .put =3D put_int32, + .load =3D load_int32_equal, + .save =3D save_int32, }; =20 /* 32 bit int. Check that the received value is non-negative * and less than or equal to the one in the field. */ =20 -static int get_int32_le(QEMUFile *f, void *pv, size_t size, - const VMStateField *field) +static bool load_int32_le(QEMUFile *f, void *pv, size_t size, + const VMStateField *field, Error **errp) { int32_t *cur =3D pv; int32_t loaded; @@ -153,348 +159,373 @@ static int get_int32_le(QEMUFile *f, void *pv, size= _t size, =20 if (loaded >=3D 0 && loaded <=3D *cur) { *cur =3D loaded; - return 0; + return true; } - error_report("Invalid value %" PRId32 - " expecting positive value <=3D %" PRId32, - loaded, *cur); - return -EINVAL; + + error_setg(errp, "Invalid value %" PRId32 + " expecting positive value <=3D %" PRId32, + loaded, *cur); + return false; } =20 const VMStateInfo vmstate_info_int32_le =3D { .name =3D "int32 le", - .get =3D get_int32_le, - .put =3D put_int32, + .load =3D load_int32_le, + .save =3D save_int32, }; =20 /* 64 bit int */ =20 -static int get_int64(QEMUFile *f, void *pv, size_t size, - const VMStateField *field) +static bool load_int64(QEMUFile *f, void *pv, size_t size, + const VMStateField *field, Error **errp) { int64_t *v =3D pv; qemu_get_sbe64s(f, v); - return 0; + return true; } =20 -static int put_int64(QEMUFile *f, void *pv, size_t size, - const VMStateField *field, JSONWriter *vmdesc) +static bool save_int64(QEMUFile *f, void *pv, size_t size, + const VMStateField *field, JSONWriter *vmdesc, + Error **errp) { int64_t *v =3D pv; qemu_put_sbe64s(f, v); - return 0; + return true; } =20 const VMStateInfo vmstate_info_int64 =3D { .name =3D "int64", - .get =3D get_int64, - .put =3D put_int64, + .load =3D load_int64, + .save =3D save_int64, }; =20 /* 8 bit unsigned int */ =20 -static int get_uint8(QEMUFile *f, void *pv, size_t size, - const VMStateField *field) +static bool load_uint8(QEMUFile *f, void *pv, size_t size, + const VMStateField *field, Error **errp) { uint8_t *v =3D pv; qemu_get_8s(f, v); - return 0; + return true; } =20 -static int put_uint8(QEMUFile *f, void *pv, size_t size, - const VMStateField *field, JSONWriter *vmdesc) +static bool save_uint8(QEMUFile *f, void *pv, size_t size, + const VMStateField *field, JSONWriter *vmdesc, + Error **errp) { uint8_t *v =3D pv; qemu_put_8s(f, v); - return 0; + return true; } =20 const VMStateInfo vmstate_info_uint8 =3D { .name =3D "uint8", - .get =3D get_uint8, - .put =3D put_uint8, + .load =3D load_uint8, + .save =3D save_uint8, }; =20 /* 16 bit unsigned int */ =20 -static int get_uint16(QEMUFile *f, void *pv, size_t size, - const VMStateField *field) +static bool load_uint16(QEMUFile *f, void *pv, size_t size, + const VMStateField *field, Error **errp) { uint16_t *v =3D pv; qemu_get_be16s(f, v); - return 0; + return true; } =20 -static int put_uint16(QEMUFile *f, void *pv, size_t size, - const VMStateField *field, JSONWriter *vmdesc) +static bool save_uint16(QEMUFile *f, void *pv, size_t size, + const VMStateField *field, JSONWriter *vmdesc, + Error **errp) { uint16_t *v =3D pv; qemu_put_be16s(f, v); - return 0; + return true; } =20 const VMStateInfo vmstate_info_uint16 =3D { .name =3D "uint16", - .get =3D get_uint16, - .put =3D put_uint16, + .load =3D load_uint16, + .save =3D save_uint16, }; =20 /* 32 bit unsigned int */ =20 -static int get_uint32(QEMUFile *f, void *pv, size_t size, - const VMStateField *field) +static bool load_uint32(QEMUFile *f, void *pv, size_t size, + const VMStateField *field, Error **errp) { uint32_t *v =3D pv; qemu_get_be32s(f, v); - return 0; + return true; } =20 -static int put_uint32(QEMUFile *f, void *pv, size_t size, - const VMStateField *field, JSONWriter *vmdesc) +static bool save_uint32(QEMUFile *f, void *pv, size_t size, + const VMStateField *field, JSONWriter *vmdesc, + Error **errp) { uint32_t *v =3D pv; qemu_put_be32s(f, v); - return 0; + return true; } =20 const VMStateInfo vmstate_info_uint32 =3D { .name =3D "uint32", - .get =3D get_uint32, - .put =3D put_uint32, + .load =3D load_uint32, + .save =3D save_uint32, }; =20 /* 32 bit uint. See that the received value is the same than the one in the field */ =20 -static int get_uint32_equal(QEMUFile *f, void *pv, size_t size, - const VMStateField *field) +static bool load_uint32_equal(QEMUFile *f, void *pv, size_t size, + const VMStateField *field, Error **errp) { + ERRP_GUARD(); uint32_t *v =3D pv; uint32_t v2; qemu_get_be32s(f, &v2); =20 if (*v =3D=3D v2) { - return 0; + return true; } - error_report("%" PRIx32 " !=3D %" PRIx32, *v, v2); - return -EINVAL; + + error_setg(errp, "%" PRIx32 " !=3D %" PRIx32, *v, v2); + return false; } =20 const VMStateInfo vmstate_info_uint32_equal =3D { .name =3D "uint32 equal", - .get =3D get_uint32_equal, - .put =3D put_uint32, + .load =3D load_uint32_equal, + .save =3D save_uint32, }; =20 /* 64 bit unsigned int */ =20 -static int get_uint64(QEMUFile *f, void *pv, size_t size, - const VMStateField *field) +static bool load_uint64(QEMUFile *f, void *pv, size_t size, + const VMStateField *field, Error **errp) { uint64_t *v =3D pv; qemu_get_be64s(f, v); - return 0; + return true; } =20 -static int put_uint64(QEMUFile *f, void *pv, size_t size, - const VMStateField *field, JSONWriter *vmdesc) +static bool save_uint64(QEMUFile *f, void *pv, size_t size, + const VMStateField *field, JSONWriter *vmdesc, + Error **errp) { uint64_t *v =3D pv; qemu_put_be64s(f, v); - return 0; + return true; } =20 const VMStateInfo vmstate_info_uint64 =3D { .name =3D "uint64", - .get =3D get_uint64, - .put =3D put_uint64, + .load =3D load_uint64, + .save =3D save_uint64, }; =20 /* File descriptor communicated via SCM_RIGHTS */ =20 -static int get_fd(QEMUFile *f, void *pv, size_t size, - const VMStateField *field) +static bool load_fd(QEMUFile *f, void *pv, size_t size, + const VMStateField *field, Error **errp) { int32_t *v =3D pv; =20 if (migrate_mode() =3D=3D MIG_MODE_CPR_EXEC) { qemu_get_sbe32s(f, v); - return 0; + return true; } =20 - return qemu_file_get_fd(f, v); + return qemu_file_get_fd(f, v) >=3D 0; } =20 -static int put_fd(QEMUFile *f, void *pv, size_t size, - const VMStateField *field, JSONWriter *vmdesc) +static bool save_fd(QEMUFile *f, void *pv, size_t size, + const VMStateField *field, JSONWriter *vmdesc, + Error **errp) { int32_t *v =3D pv; + if (migrate_mode() =3D=3D MIG_MODE_CPR_EXEC) { qemu_put_sbe32s(f, v); - return 0; + return true; } - return qemu_file_put_fd(f, *v); + + return qemu_file_put_fd(f, *v) >=3D 0; } =20 const VMStateInfo vmstate_info_fd =3D { .name =3D "fd", - .get =3D get_fd, - .put =3D put_fd, + .load =3D load_fd, + .save =3D save_fd, }; =20 -static int get_nullptr(QEMUFile *f, void *pv, size_t size, - const VMStateField *field) +static bool load_nullptr(QEMUFile *f, void *pv, size_t size, + const VMStateField *field, Error **errp) =20 { if (qemu_get_byte(f) =3D=3D VMS_NULLPTR_MARKER) { - return 0; + return true; } - error_report("vmstate: get_nullptr expected VMS_NULLPTR_MARKER"); - return -EINVAL; + + error_setg(errp, "vmstate: load_nullptr expected VMS_NULLPTR_MARKER"); + return false; } =20 -static int put_nullptr(QEMUFile *f, void *pv, size_t size, - const VMStateField *field, JSONWriter *vmdesc) +static bool save_nullptr(QEMUFile *f, void *pv, size_t size, + const VMStateField *field, JSONWriter *vmdesc, + Error **errp) =20 { if (pv =3D=3D NULL) { qemu_put_byte(f, VMS_NULLPTR_MARKER); - return 0; + return true; } - error_report("vmstate: put_nullptr must be called with pv =3D=3D NULL"= ); - return -EINVAL; + + error_setg(errp, "vmstate: save_nullptr must be called with pv =3D=3D = NULL"); + return false; } =20 const VMStateInfo vmstate_info_nullptr =3D { .name =3D "nullptr", - .get =3D get_nullptr, - .put =3D put_nullptr, + .load =3D load_nullptr, + .save =3D save_nullptr, }; =20 /* 64 bit unsigned int. See that the received value is the same than the o= ne in the field */ =20 -static int get_uint64_equal(QEMUFile *f, void *pv, size_t size, - const VMStateField *field) +static bool load_uint64_equal(QEMUFile *f, void *pv, size_t size, + const VMStateField *field, Error **errp) { + ERRP_GUARD(); uint64_t *v =3D pv; uint64_t v2; + qemu_get_be64s(f, &v2); =20 if (*v =3D=3D v2) { - return 0; + return true; } - error_report("%" PRIx64 " !=3D %" PRIx64, *v, v2); - return -EINVAL; + + error_setg(errp, "%" PRIx64 " !=3D %" PRIx64, *v, v2); + return false; } =20 const VMStateInfo vmstate_info_uint64_equal =3D { .name =3D "int64 equal", - .get =3D get_uint64_equal, - .put =3D put_uint64, + .load =3D load_uint64_equal, + .save =3D save_uint64, }; =20 /* 8 bit int. See that the received value is the same than the one in the field */ =20 -static int get_uint8_equal(QEMUFile *f, void *pv, size_t size, - const VMStateField *field) +static bool load_uint8_equal(QEMUFile *f, void *pv, size_t size, + const VMStateField *field, Error **errp) { + ERRP_GUARD(); uint8_t *v =3D pv; uint8_t v2; + qemu_get_8s(f, &v2); =20 if (*v =3D=3D v2) { - return 0; + return true; } - error_report("%x !=3D %x", *v, v2); - return -EINVAL; + + error_setg(errp, "%x !=3D %x", *v, v2); + return false; } =20 const VMStateInfo vmstate_info_uint8_equal =3D { .name =3D "uint8 equal", - .get =3D get_uint8_equal, - .put =3D put_uint8, + .load =3D load_uint8_equal, + .save =3D save_uint8, }; =20 /* 16 bit unsigned int int. See that the received value is the same than t= he one in the field */ =20 -static int get_uint16_equal(QEMUFile *f, void *pv, size_t size, - const VMStateField *field) +static bool load_uint16_equal(QEMUFile *f, void *pv, size_t size, + const VMStateField *field, Error **errp) { + ERRP_GUARD(); uint16_t *v =3D pv; uint16_t v2; + qemu_get_be16s(f, &v2); =20 if (*v =3D=3D v2) { - return 0; + return true; } - error_report("%x !=3D %x", *v, v2); - return -EINVAL; + + error_setg(errp, "%x !=3D %x", *v, v2); + return false; } =20 const VMStateInfo vmstate_info_uint16_equal =3D { .name =3D "uint16 equal", - .get =3D get_uint16_equal, - .put =3D put_uint16, + .load =3D load_uint16_equal, + .save =3D save_uint16, }; =20 /* CPU_DoubleU type */ =20 -static int get_cpudouble(QEMUFile *f, void *pv, size_t size, - const VMStateField *field) +static bool load_cpudouble(QEMUFile *f, void *pv, size_t size, + const VMStateField *field, Error **errp) { CPU_DoubleU *v =3D pv; qemu_get_be32s(f, &v->l.upper); qemu_get_be32s(f, &v->l.lower); - return 0; + return true; } =20 -static int put_cpudouble(QEMUFile *f, void *pv, size_t size, - const VMStateField *field, JSONWriter *vmdesc) +static bool save_cpudouble(QEMUFile *f, void *pv, size_t size, + const VMStateField *field, JSONWriter *vmdesc, + Error **errp) { CPU_DoubleU *v =3D pv; qemu_put_be32s(f, &v->l.upper); qemu_put_be32s(f, &v->l.lower); - return 0; + return true; } =20 const VMStateInfo vmstate_info_cpudouble =3D { .name =3D "CPU_Double_U", - .get =3D get_cpudouble, - .put =3D put_cpudouble, + .load =3D load_cpudouble, + .save =3D save_cpudouble, }; =20 /* uint8_t buffers */ =20 -static int get_buffer(QEMUFile *f, void *pv, size_t size, - const VMStateField *field) +static bool load_buffer(QEMUFile *f, void *pv, size_t size, + const VMStateField *field, Error **errp) { uint8_t *v =3D pv; qemu_get_buffer(f, v, size); - return 0; + return true; } =20 -static int put_buffer(QEMUFile *f, void *pv, size_t size, - const VMStateField *field, JSONWriter *vmdesc) +static bool save_buffer(QEMUFile *f, void *pv, size_t size, + const VMStateField *field, JSONWriter *vmdesc, + Error **errp) { uint8_t *v =3D pv; qemu_put_buffer(f, v, size); - return 0; + return true; } =20 const VMStateInfo vmstate_info_buffer =3D { .name =3D "buffer", - .get =3D get_buffer, - .put =3D put_buffer, + .load =3D load_buffer, + .save =3D save_buffer, }; =20 /* unused buffers: space that was used for some fields that are not useful anymore */ =20 -static int get_unused_buffer(QEMUFile *f, void *pv, size_t size, - const VMStateField *field) +static bool load_unused_buffer(QEMUFile *f, void *pv, size_t size, + const VMStateField *field, Error **errp) { uint8_t buf[1024]; int block_len; @@ -504,11 +535,13 @@ static int get_unused_buffer(QEMUFile *f, void *pv, s= ize_t size, size -=3D block_len; qemu_get_buffer(f, buf, block_len); } - return 0; + + return true; } =20 -static int put_unused_buffer(QEMUFile *f, void *pv, size_t size, - const VMStateField *field, JSONWriter *vmdesc) +static bool save_unused_buffer(QEMUFile *f, void *pv, size_t size, + const VMStateField *field, JSONWriter *vmde= sc, + Error **errp) { static const uint8_t buf[1024]; int block_len; @@ -519,13 +552,13 @@ static int put_unused_buffer(QEMUFile *f, void *pv, s= ize_t size, qemu_put_buffer(f, buf, block_len); } =20 - return 0; + return true; } =20 const VMStateInfo vmstate_info_unused_buffer =3D { .name =3D "unused_buffer", - .get =3D get_unused_buffer, - .put =3D put_unused_buffer, + .load =3D load_unused_buffer, + .save =3D save_unused_buffer, }; =20 /* vmstate_info_tmp, see VMSTATE_WITH_TMP, the idea is that we allocate @@ -534,48 +567,34 @@ const VMStateInfo vmstate_info_unused_buffer =3D { * in fields that don't really exist in the parent but need to be in the * stream. */ -static int get_tmp(QEMUFile *f, void *pv, size_t size, - const VMStateField *field) +static bool load_tmp(QEMUFile *f, void *pv, size_t size, + const VMStateField *field, Error **errp) { - int ret; - Error *local_err =3D NULL; const VMStateDescription *vmsd =3D field->vmsd; int version_id =3D field->version_id; - void *tmp =3D g_malloc(size); + g_autofree void *tmp =3D g_malloc(size); =20 /* Writes the parent field which is at the start of the tmp */ *(void **)tmp =3D pv; - ret =3D vmstate_load_state(f, vmsd, tmp, version_id, &local_err); - if (ret < 0) { - error_report_err(local_err); - } - g_free(tmp); - return ret; + return vmstate_load_vmsd(f, vmsd, tmp, version_id, errp); } =20 -static int put_tmp(QEMUFile *f, void *pv, size_t size, - const VMStateField *field, JSONWriter *vmdesc) +static bool save_tmp(QEMUFile *f, void *pv, size_t size, + const VMStateField *field, JSONWriter *vmdesc, + Error **errp) { const VMStateDescription *vmsd =3D field->vmsd; - void *tmp =3D g_malloc(size); - int ret; - Error *local_err =3D NULL; + g_autofree void *tmp =3D g_malloc(size); =20 /* Writes the parent field which is at the start of the tmp */ *(void **)tmp =3D pv; - ret =3D vmstate_save_state(f, vmsd, tmp, vmdesc, &local_err); - if (ret) { - error_report_err(local_err); - } - g_free(tmp); - - return ret; + return vmstate_save_vmsd(f, vmsd, tmp, vmdesc, errp); } =20 const VMStateInfo vmstate_info_tmp =3D { .name =3D "tmp", - .get =3D get_tmp, - .put =3D put_tmp, + .load =3D load_tmp, + .save =3D save_tmp, }; =20 /* bitmaps (as defined by bitmap.h). Note that size here is the size @@ -585,11 +604,12 @@ const VMStateInfo vmstate_info_tmp =3D { */ /* This is the number of 64 bit words sent over the wire */ #define BITS_TO_U64S(nr) DIV_ROUND_UP(nr, 64) -static int get_bitmap(QEMUFile *f, void *pv, size_t size, - const VMStateField *field) +static bool load_bitmap(QEMUFile *f, void *pv, size_t size, + const VMStateField *field, Error **errp) { unsigned long *bmp =3D pv; int i, idx =3D 0; + for (i =3D 0; i < BITS_TO_U64S(size); i++) { uint64_t w =3D qemu_get_be64(f); bmp[idx++] =3D w; @@ -597,14 +617,17 @@ static int get_bitmap(QEMUFile *f, void *pv, size_t s= ize, bmp[idx++] =3D w >> 32; } } - return 0; + + return true; } =20 -static int put_bitmap(QEMUFile *f, void *pv, size_t size, - const VMStateField *field, JSONWriter *vmdesc) +static bool save_bitmap(QEMUFile *f, void *pv, size_t size, + const VMStateField *field, JSONWriter *vmdesc, + Error **errp) { unsigned long *bmp =3D pv; int i, idx =3D 0; + for (i =3D 0; i < BITS_TO_U64S(size); i++) { uint64_t w =3D bmp[idx++]; if (sizeof(unsigned long) =3D=3D 4 && idx < BITS_TO_LONGS(size)) { @@ -613,23 +636,21 @@ static int put_bitmap(QEMUFile *f, void *pv, size_t s= ize, qemu_put_be64(f, w); } =20 - return 0; + return true; } =20 const VMStateInfo vmstate_info_bitmap =3D { .name =3D "bitmap", - .get =3D get_bitmap, - .put =3D put_bitmap, + .load =3D load_bitmap, + .save =3D save_bitmap, }; =20 /* get for QTAILQ * meta data about the QTAILQ is encoded in a VMStateField structure */ -static int get_qtailq(QEMUFile *f, void *pv, size_t unused_size, - const VMStateField *field) +static bool load_qtailq(QEMUFile *f, void *pv, size_t unused_size, + const VMStateField *field, Error **errp) { - int ret =3D 0; - Error *local_err =3D NULL; const VMStateDescription *vmsd =3D field->vmsd; /* size of a QTAILQ element */ size_t size =3D field->size; @@ -638,80 +659,76 @@ static int get_qtailq(QEMUFile *f, void *pv, size_t u= nused_size, int version_id =3D field->version_id; void *elm; =20 - trace_get_qtailq(vmsd->name, version_id); + trace_load_qtailq(vmsd->name, version_id); if (version_id > vmsd->version_id) { - error_report("%s %s", vmsd->name, "too new"); - trace_get_qtailq_end(vmsd->name, "too new", -EINVAL); - - return -EINVAL; + error_setg(errp, "%s %s", vmsd->name, "too new"); + return false; } if (version_id < vmsd->minimum_version_id) { - error_report("%s %s", vmsd->name, "too old"); - trace_get_qtailq_end(vmsd->name, "too old", -EINVAL); - return -EINVAL; + error_setg(errp, "%s %s", vmsd->name, "too old"); + return false; } =20 while (qemu_get_byte(f)) { elm =3D g_malloc(size); - ret =3D vmstate_load_state(f, vmsd, elm, version_id, &local_err); - if (ret) { - error_report_err(local_err); - return ret; + if (!vmstate_load_vmsd(f, vmsd, elm, version_id, errp)) { + g_free(elm); + return false; } QTAILQ_RAW_INSERT_TAIL(pv, elm, entry_offset); } =20 - trace_get_qtailq_end(vmsd->name, "end", ret); - return ret; + trace_load_qtailq_end(vmsd->name); + return true; } =20 -/* put for QTAILQ */ -static int put_qtailq(QEMUFile *f, void *pv, size_t unused_size, - const VMStateField *field, JSONWriter *vmdesc) +/* save for QTAILQ */ +static bool save_qtailq(QEMUFile *f, void *pv, size_t unused_size, + const VMStateField *field, JSONWriter *vmdesc, + Error **errp) { const VMStateDescription *vmsd =3D field->vmsd; /* offset of the QTAILQ entry in a QTAILQ element*/ size_t entry_offset =3D field->start; void *elm; - int ret; - Error *local_err =3D NULL; =20 - trace_put_qtailq(vmsd->name, vmsd->version_id); + trace_save_qtailq(vmsd->name, vmsd->version_id); =20 QTAILQ_RAW_FOREACH(elm, pv, entry_offset) { qemu_put_byte(f, true); - ret =3D vmstate_save_state(f, vmsd, elm, vmdesc, &local_err); - if (ret) { - error_report_err(local_err); - return ret; + if (!vmstate_save_vmsd(f, vmsd, elm, vmdesc, errp)) { + return false; } } qemu_put_byte(f, false); =20 - trace_put_qtailq_end(vmsd->name, "end"); + trace_save_qtailq_end(vmsd->name); =20 - return 0; + return true; } const VMStateInfo vmstate_info_qtailq =3D { .name =3D "qtailq", - .get =3D get_qtailq, - .put =3D put_qtailq, + .load =3D load_qtailq, + .save =3D save_qtailq, }; =20 -struct put_gtree_data { +struct save_gtree_data { QEMUFile *f; const VMStateDescription *key_vmsd; const VMStateDescription *val_vmsd; JSONWriter *vmdesc; - int ret; + Error **errp; + bool failed; }; =20 -static gboolean put_gtree_elem(gpointer key, gpointer value, gpointer data) +/* + * save_gtree_elem - func for g_tree_foreach, return true to stop + * iteration. + */ +static gboolean save_gtree_elem(gpointer key, gpointer value, gpointer dat= a) { - struct put_gtree_data *capsule =3D (struct put_gtree_data *)data; + struct save_gtree_data *capsule =3D (struct save_gtree_data *)data; QEMUFile *f =3D capsule->f; - int ret; - Error *local_err =3D NULL; =20 qemu_put_byte(f, true); =20 @@ -719,58 +736,56 @@ static gboolean put_gtree_elem(gpointer key, gpointer= value, gpointer data) if (!capsule->key_vmsd) { qemu_put_be64(f, (uint64_t)(uintptr_t)(key)); /* direct key */ } else { - ret =3D vmstate_save_state(f, capsule->key_vmsd, key, capsule->vmd= esc, - &local_err); - if (ret) { - error_report_err(local_err); - capsule->ret =3D ret; + if (!vmstate_save_vmsd(f, capsule->key_vmsd, key, capsule->vmdesc, + capsule->errp)) { + capsule->failed =3D true; return true; } } =20 /* put the data */ - ret =3D vmstate_save_state(f, capsule->val_vmsd, value, capsule->vmdes= c, - &local_err); - if (ret) { - error_report_err(local_err); - capsule->ret =3D ret; + if (!vmstate_save_vmsd(f, capsule->val_vmsd, value, capsule->vmdesc, + capsule->errp)) { + capsule->failed =3D true; return true; } return false; } =20 -static int put_gtree(QEMUFile *f, void *pv, size_t unused_size, - const VMStateField *field, JSONWriter *vmdesc) +static bool save_gtree(QEMUFile *f, void *pv, size_t unused_size, + const VMStateField *field, JSONWriter *vmdesc, + Error **errp) { bool direct_key =3D (!field->start); const VMStateDescription *key_vmsd =3D direct_key ? NULL : &field->vms= d[1]; const VMStateDescription *val_vmsd =3D &field->vmsd[0]; const char *key_vmsd_name =3D direct_key ? "direct" : key_vmsd->name; - struct put_gtree_data capsule =3D { + struct save_gtree_data capsule =3D { .f =3D f, .key_vmsd =3D key_vmsd, .val_vmsd =3D val_vmsd, .vmdesc =3D vmdesc, - .ret =3D 0}; + .errp =3D errp, + .failed =3D false}; GTree **pval =3D pv; GTree *tree =3D *pval; uint32_t nnodes =3D g_tree_nnodes(tree); - int ret; =20 - trace_put_gtree(field->name, key_vmsd_name, val_vmsd->name, nnodes); + trace_save_gtree(field->name, key_vmsd_name, val_vmsd->name, nnodes); qemu_put_be32(f, nnodes); - g_tree_foreach(tree, put_gtree_elem, (gpointer)&capsule); + g_tree_foreach(tree, save_gtree_elem, (gpointer)&capsule); qemu_put_byte(f, false); - ret =3D capsule.ret; - if (ret) { - error_report("%s : failed to save gtree (%d)", field->name, ret); + if (capsule.failed) { + trace_save_gtree_end(field->name, key_vmsd_name, val_vmsd->name); + return false; } - trace_put_gtree_end(field->name, key_vmsd_name, val_vmsd->name, ret); - return ret; + + trace_save_gtree_end(field->name, key_vmsd_name, val_vmsd->name); + return true; } =20 -static int get_gtree(QEMUFile *f, void *pv, size_t unused_size, - const VMStateField *field) +static bool load_gtree(QEMUFile *f, void *pv, size_t unused_size, + const VMStateField *field, Error **errp) { bool direct_key =3D (!field->start); const VMStateDescription *key_vmsd =3D direct_key ? NULL : &field->vms= d[1]; @@ -783,107 +798,97 @@ static int get_gtree(QEMUFile *f, void *pv, size_t u= nused_size, GTree **pval =3D pv; GTree *tree =3D *pval; void *key, *val; - int ret =3D 0; - Error *local_err =3D NULL; =20 /* in case of direct key, the key vmsd can be {}, ie. check fields */ if (!direct_key && version_id > key_vmsd->version_id) { - error_report("%s %s", key_vmsd->name, "too new"); - return -EINVAL; + error_setg(errp, "%s %s", key_vmsd->name, "too new"); + return false; } if (!direct_key && version_id < key_vmsd->minimum_version_id) { - error_report("%s %s", key_vmsd->name, "too old"); - return -EINVAL; + error_setg(errp, "%s %s", key_vmsd->name, "too old"); + return false; } if (version_id > val_vmsd->version_id) { - error_report("%s %s", val_vmsd->name, "too new"); - return -EINVAL; + error_setg(errp, "%s %s", val_vmsd->name, "too new"); + return false; } if (version_id < val_vmsd->minimum_version_id) { - error_report("%s %s", val_vmsd->name, "too old"); - return -EINVAL; + error_setg(errp, "%s %s", val_vmsd->name, "too old"); + return false; } =20 nnodes =3D qemu_get_be32(f); - trace_get_gtree(field->name, key_vmsd_name, val_vmsd->name, nnodes); + trace_load_gtree(field->name, key_vmsd_name, val_vmsd->name, nnodes); =20 while (qemu_get_byte(f)) { if ((++count) > nnodes) { - ret =3D -EINVAL; break; } if (direct_key) { key =3D (void *)(uintptr_t)qemu_get_be64(f); } else { key =3D g_malloc0(key_size); - ret =3D vmstate_load_state(f, key_vmsd, key, version_id, &loca= l_err); - if (ret) { - error_report_err(local_err); + if (!vmstate_load_vmsd(f, key_vmsd, key, version_id, errp)) { goto key_error; } } val =3D g_malloc0(val_size); - ret =3D vmstate_load_state(f, val_vmsd, val, version_id, &local_er= r); - if (ret) { - error_report_err(local_err); + if (!vmstate_load_vmsd(f, val_vmsd, val, version_id, errp)) { goto val_error; } g_tree_insert(tree, key, val); } if (count !=3D nnodes) { - error_report("%s inconsistent stream when loading the gtree", - field->name); - return -EINVAL; + error_setg(errp, "%s inconsistent stream when loading the gtree", + field->name); + return false; } - trace_get_gtree_end(field->name, key_vmsd_name, val_vmsd->name, ret); - return ret; + + trace_load_gtree_end(field->name, key_vmsd_name, val_vmsd->name); + return true; + val_error: g_free(val); + key_error: if (!direct_key) { g_free(key); } - trace_get_gtree_end(field->name, key_vmsd_name, val_vmsd->name, ret); - return ret; + return false; } =20 =20 const VMStateInfo vmstate_info_gtree =3D { .name =3D "gtree", - .get =3D get_gtree, - .put =3D put_gtree, + .load =3D load_gtree, + .save =3D save_gtree, }; =20 -static int put_qlist(QEMUFile *f, void *pv, size_t unused_size, - const VMStateField *field, JSONWriter *vmdesc) +static bool save_qlist(QEMUFile *f, void *pv, size_t unused_size, + const VMStateField *field, JSONWriter *vmdesc, + Error **errp) { const VMStateDescription *vmsd =3D field->vmsd; /* offset of the QTAILQ entry in a QTAILQ element*/ size_t entry_offset =3D field->start; void *elm; - int ret; - Error *local_err =3D NULL; =20 - trace_put_qlist(field->name, vmsd->name, vmsd->version_id); + trace_save_qlist(field->name, vmsd->name, vmsd->version_id); QLIST_RAW_FOREACH(elm, pv, entry_offset) { qemu_put_byte(f, true); - ret =3D vmstate_save_state(f, vmsd, elm, vmdesc, &local_err); - if (ret) { - error_report_err(local_err); - return ret; + if (!vmstate_save_vmsd(f, vmsd, elm, vmdesc, errp)) { + return false; } } qemu_put_byte(f, false); - trace_put_qlist_end(field->name, vmsd->name); + trace_save_qlist_end(field->name, vmsd->name); =20 - return 0; + return true; } =20 -static int get_qlist(QEMUFile *f, void *pv, size_t unused_size, - const VMStateField *field) +static bool load_qlist(QEMUFile *f, void *pv, size_t unused_size, + const VMStateField *field, Error **errp) { - int ret =3D 0; - Error *local_err =3D NULL; const VMStateDescription *vmsd =3D field->vmsd; /* size of a QLIST element */ size_t size =3D field->size; @@ -892,23 +897,21 @@ static int get_qlist(QEMUFile *f, void *pv, size_t un= used_size, int version_id =3D field->version_id; void *elm, *prev =3D NULL; =20 - trace_get_qlist(field->name, vmsd->name, vmsd->version_id); + trace_load_qlist(field->name, vmsd->name, vmsd->version_id); if (version_id > vmsd->version_id) { - error_report("%s %s", vmsd->name, "too new"); - return -EINVAL; + error_setg(errp, "%s %s", vmsd->name, "too new"); + return false; } if (version_id < vmsd->minimum_version_id) { - error_report("%s %s", vmsd->name, "too old"); - return -EINVAL; + error_setg(errp, "%s %s", vmsd->name, "too old"); + return false; } =20 while (qemu_get_byte(f)) { elm =3D g_malloc(size); - ret =3D vmstate_load_state(f, vmsd, elm, version_id, &local_err); - if (ret) { - error_report_err(local_err); + if (!vmstate_load_vmsd(f, vmsd, elm, version_id, errp)) { g_free(elm); - return ret; + return false; } if (!prev) { QLIST_RAW_INSERT_HEAD(pv, elm, entry_offset); @@ -917,13 +920,13 @@ static int get_qlist(QEMUFile *f, void *pv, size_t un= used_size, } prev =3D elm; } - trace_get_qlist_end(field->name, vmsd->name); + trace_load_qlist_end(field->name, vmsd->name); =20 - return ret; + return true; } =20 const VMStateInfo vmstate_info_qlist =3D { .name =3D "qlist", - .get =3D get_qlist, - .put =3D put_qlist, + .load =3D load_qlist, + .save =3D save_qlist, }; --=20 2.52.0