From nobody Fri Nov 14 21:05:50 2025 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=1761693503; cv=none; d=zohomail.com; s=zohoarc; b=VoHix7dK2tCUGcHhPvr5r9Am+xG78OBAqTmMLGlSOIvV9id5BV7Q54gAwOGrxD2QIwvSvyi5G5ajaAkc9QSFp5g02/7ElO8IVAVxCoT4EqxkeNB3TzKSPOydV6fkDmLN/ZnTVYeIclfXfcThNTu8OpKIF0kuRLbHAZqs8O6lGPw= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1761693503; 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=NzlRVQ6wK9/3jkzrGEhWeF+eDOyfrMkHZSOrIRNGoLA=; b=E4kLN+z+TZbACOfpMdZkPhI0R/9E9Wz63d7/jzzPwWbUYUDmKE/24E646uekitr6okNNPKKyDvb9bW/MIj3HDHramVHnSC5MKhFJVS0FTylb9FU40jJe5EqDKXnnBDWDE85Ik78QAwwc/bKHPGaWZguvY8sRn5TDtG2FM3bnTS8= 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 1761693503832837.4719042525458; Tue, 28 Oct 2025 16:18:23 -0700 (PDT) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1vDstk-00034m-Tc; Tue, 28 Oct 2025 19:14:40 -0400 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 1vDsth-00033A-BZ for qemu-devel@nongnu.org; Tue, 28 Oct 2025 19:14:37 -0400 Received: from forwardcorp1b.mail.yandex.net ([178.154.239.136]) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1vDstO-00018N-5N for qemu-devel@nongnu.org; Tue, 28 Oct 2025 19:14:36 -0400 Received: from mail-nwsmtp-smtp-corp-canary-81.sas.yp-c.yandex.net (mail-nwsmtp-smtp-corp-canary-81.sas.yp-c.yandex.net [IPv6:2a02:6b8:c10:49f:0:640:b99a:0]) by forwardcorp1b.mail.yandex.net (Yandex) with ESMTPS id A3AB68177B; Wed, 29 Oct 2025 02:14:05 +0300 (MSK) Received: from vsementsov-lin.. (unknown [2a02:6bf:8080:582::1:19]) by mail-nwsmtp-smtp-corp-canary-81.sas.yp-c.yandex.net (smtpcorp/Yandex) with ESMTPSA id oDnXpg2bCW20-z3lyrqwK; Wed, 29 Oct 2025 02:14:04 +0300 X-Yandex-Fwd: 1 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=yandex-team.ru; s=default; t=1761693245; bh=NzlRVQ6wK9/3jkzrGEhWeF+eDOyfrMkHZSOrIRNGoLA=; h=Message-ID:Date:In-Reply-To:Cc:Subject:References:To:From; b=WPaezdIZawF0l4hLcvDxVs6FZ230xH65lcs2euROc8BYLQ0kuCBbPocAS6PwH7mi5 4mNYL6GkP9ceEDtW1VIydebCrrqeZpMgbM4ZNtwYMiulfmSLQ21IQPBRA5PwU5LjFG HX1x843YAGhhdGOCQClFgU8HjbkZtDmi8pEIcoxg= Authentication-Results: mail-nwsmtp-smtp-corp-canary-81.sas.yp-c.yandex.net; dkim=pass header.i=@yandex-team.ru From: Vladimir Sementsov-Ogievskiy To: peterx@redhat.com Cc: armbru@redhat.com, vsementsov@yandex-team.ru, qemu-devel@nongnu.org Subject: [RFC 19/22] migration/vmstate-types: move to new migration APIs Date: Wed, 29 Oct 2025 02:13:43 +0300 Message-ID: <20251028231347.194844-20-vsementsov@yandex-team.ru> X-Mailer: git-send-email 2.48.1 In-Reply-To: <20251028231347.194844-1-vsementsov@yandex-team.ru> References: <20251028231347.194844-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.136; envelope-from=vsementsov@yandex-team.ru; helo=forwardcorp1b.mail.yandex.net X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 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_CERTIFIED_BLOCKED=0.001, RCVD_IN_VALIDITY_RPBL_BLOCKED=0.001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: 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: 1761693505116154100 Content-Type: text/plain; charset="utf-8" Signed-off-by: Vladimir Sementsov-Ogievskiy --- migration/vmstate-types.c | 584 ++++++++++++++++++-------------------- 1 file changed, 283 insertions(+), 301 deletions(-) diff --git a/migration/vmstate-types.c b/migration/vmstate-types.c index 4b01dc19c2..a06b7dd478 100644 --- a/migration/vmstate-types.c +++ b/migration/vmstate-types.c @@ -23,132 +23,136 @@ =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) { 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); + error_setg(errp, "%" PRIx32 " !=3D %" PRIx32, *v, v2); if (field->err_hint) { - error_printf("%s\n", field->err_hint); + error_append_hint(errp, "%s\n", field->err_hint); } - return -EINVAL; + 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; @@ -156,359 +160,368 @@ 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) { 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); + error_setg(errp, "%" PRIx32 " !=3D %" PRIx32, *v, v2); if (field->err_hint) { - error_printf("%s\n", field->err_hint); + error_append_hint(errp, "%s\n", field->err_hint); } - return -EINVAL; + 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; if (migrate_mode() =3D=3D MIG_MODE_CPR_EXEC) { qemu_get_sbe32s(f, v); - return 0; + return true; } *v =3D qemu_file_get_fd(f); - return 0; + return true; } =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=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) { 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); + error_setg(errp, "%" PRIx64 " !=3D %" PRIx64, *v, v2); if (field->err_hint) { - error_printf("%s\n", field->err_hint); + error_append_hint(errp, "%s\n", field->err_hint); } - return -EINVAL; + 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) { 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); + error_setg(errp, "%x !=3D %x", *v, v2); if (field->err_hint) { - error_printf("%s\n", field->err_hint); + error_append_hint(errp, "%s\n", field->err_hint); } - return -EINVAL; + 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) { 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); + error_setg(errp, "%x !=3D %x", *v, v2); if (field->err_hint) { - error_printf("%s\n", field->err_hint); + error_append_hint(errp, "%s\n", field->err_hint); } - return -EINVAL; + 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; @@ -518,11 +531,12 @@ 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; @@ -533,13 +547,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 @@ -548,48 +562,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 @@ -599,8 +599,8 @@ 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; @@ -611,11 +611,12 @@ 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; @@ -627,23 +628,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; @@ -654,78 +653,76 @@ static int get_qtailq(QEMUFile *f, void *pv, size_t u= nused_size, =20 trace_get_qtailq(vmsd->name, version_id); if (version_id > vmsd->version_id) { - error_report("%s %s", vmsd->name, "too new"); + error_setg(errp, "%s %s", vmsd->name, "too new"); trace_get_qtailq_end(vmsd->name, "too new", -EINVAL); - - return -EINVAL; + return false; } if (version_id < vmsd->minimum_version_id) { - error_report("%s %s", vmsd->name, "too old"); + error_setg(errp, "%s %s", vmsd->name, "too old"); trace_get_qtailq_end(vmsd->name, "too old", -EINVAL); - return -EINVAL; + 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_get_qtailq_end(vmsd->name, "end", 0); + 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); =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"); =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 @@ -733,58 +730,55 @@ 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); 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_put_gtree_end(field->name, key_vmsd_name, val_vmsd->name, -1= ); + return false; } - trace_put_gtree_end(field->name, key_vmsd_name, val_vmsd->name, ret); - return ret; + trace_put_gtree_end(field->name, key_vmsd_name, val_vmsd->name, 0); + 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]; @@ -798,24 +792,23 @@ static int get_gtree(QEMUFile *f, void *pv, size_t un= used_size, 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); @@ -830,24 +823,20 @@ static int get_gtree(QEMUFile *f, void *pv, size_t un= used_size, 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; @@ -858,46 +847,41 @@ key_error: g_free(key); } trace_get_gtree_end(field->name, key_vmsd_name, val_vmsd->name, ret); - return ret; + return ret >=3D 0; } =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); 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); =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; @@ -908,21 +892,19 @@ static int get_qlist(QEMUFile *f, void *pv, size_t un= used_size, =20 trace_get_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); @@ -933,11 +915,11 @@ static int get_qlist(QEMUFile *f, void *pv, size_t un= used_size, } trace_get_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.48.1