From nobody Fri Nov 7 14:40:12 2025 Delivered-To: importer@patchew.org Received-SPF: pass (zoho.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; Authentication-Results: mx.zohomail.com; dkim=fail; spf=pass (zoho.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=fail(p=none dis=none) header.from=gmail.com Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 154814618975692.94502234038453; Tue, 22 Jan 2019 00:36:29 -0800 (PST) Received: from localhost ([127.0.0.1]:40730 helo=lists.gnu.org) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1glrXo-0002RN-Kw for importer@patchew.org; Tue, 22 Jan 2019 03:36:28 -0500 Received: from eggs.gnu.org ([209.51.188.92]:46543) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1glrU4-0000ET-UM for qemu-devel@nongnu.org; Tue, 22 Jan 2019 03:32:40 -0500 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1glrTz-0002cv-C1 for qemu-devel@nongnu.org; Tue, 22 Jan 2019 03:32:34 -0500 Received: from mail-pl1-x644.google.com ([2607:f8b0:4864:20::644]:34794) by eggs.gnu.org with esmtps (TLS1.0:RSA_AES_128_CBC_SHA1:16) (Exim 4.71) (envelope-from ) id 1glrTy-0002bR-GY for qemu-devel@nongnu.org; Tue, 22 Jan 2019 03:32:31 -0500 Received: by mail-pl1-x644.google.com with SMTP id w4so11124239plz.1 for ; Tue, 22 Jan 2019 00:32:28 -0800 (PST) Received: from localhost ([116.247.112.152]) by smtp.gmail.com with ESMTPSA id d25sm21146662pfe.40.2019.01.22.00.32.26 (version=TLS1_2 cipher=ECDHE-RSA-CHACHA20-POLY1305 bits=256/256); Tue, 22 Jan 2019 00:32:26 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=oEffMfa6Hd24mTz7pwTsoQTAdByYUHwjLSfnsEAPgEc=; b=PFaX2fWGmElQWOgnPDy77lnZizaYiTbTCPX6EXrskOjyAhBd1x9fzrHGDWaRiNZHwI uDY6zrxOG7atK3Czwg7vsI6zrH2JGhCgY5NHVl1j2WIrdt7yNIUG78cAf1lbVj8oBm1h 20x0zGuUNtMMky/JFIzF89VjvDUeK7AKdEyNXg5fc/RuC9qKBqUPvll2hE0x4ULgBMss 1QfDCtXmCk4wankkZE6RT5JDjAKmc3EuW2M51lsiHP9ZrhdtvMOi7fsqwg24SXU3ibkQ SFRMd/XNHPbCG7O0BLolPy5AX+oR/BYr7vtaHl3WxsWcidf5bGtJ+lS5FYpRd+h9NPZ/ 4xYQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=oEffMfa6Hd24mTz7pwTsoQTAdByYUHwjLSfnsEAPgEc=; b=s9U5Yn627lA3aKNMbAD9wIqRdYj2SHRIEP7QmrnXkw8JqlBqBrGLW65CfzIw5NtALh MxCxhu4qVR/6OfdzDaHfEPYNAOZcRbkDMrgN/6sfOkudIw3cN/BeVoZ9eN25UrzPcv63 f6kGyNOLl/oGJc6+n5p4h8LQgqmW0KYRw6FsB8bZ5v4+NewWPl8wLqJEQn6Uiq23TC+Z Y9ISUWPVlJaHwJ+hwP8ajk/8NQSHoncbH09tl9Hytg5QKoFgT/FZKJww0Img25xMwiDA oAGQVz4JROQMHvOWUmKQssvqkar8V00MbpEY0obnpCs/34B2j8Ma/sMJ4TwxAIzonTH3 I45A== X-Gm-Message-State: AJcUukeNQlPkqyzyMaqxapSJpPYZ3L7bNE71ygVglDhTS2TubibsiLRI pqYVD/6EiyaPZoBn13BihDkp/tYX X-Google-Smtp-Source: ALg8bN6NK70R3bXHT4X+78G6TgZreYdIQ82OYw7zeW78jmY9Z1wZ5x4IsB7XSHvw67lCztuoNtFt6g== X-Received: by 2002:a17:902:583:: with SMTP id f3mr34125684plf.202.1548145947259; Tue, 22 Jan 2019 00:32:27 -0800 (PST) From: elohimes@gmail.com X-Google-Original-From: xieyongji@baidu.com To: mst@redhat.com, stefanha@gmail.com, marcandre.lureau@redhat.com, berrange@redhat.com, jasowang@redhat.com, maxime.coquelin@redhat.com, yury-kotov@yandex-team.ru, wrfsh@yandex-team.ru Date: Tue, 22 Jan 2019 16:31:47 +0800 Message-Id: <20190122083152.10705-2-xieyongji@baidu.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20190122083152.10705-1-xieyongji@baidu.com> References: <20190122083152.10705-1-xieyongji@baidu.com> X-detected-operating-system: by eggs.gnu.org: Genre and OS details not recognized. X-Received-From: 2607:f8b0:4864:20::644 Subject: [Qemu-devel] [PATCH v5 1/6] vhost-user: Support transferring inflight buffer between qemu and backend X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.21 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: nixun@baidu.com, qemu-devel@nongnu.org, lilin24@baidu.com, zhangyu31@baidu.com, chaiwen@baidu.com, Xie Yongji Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: fail (Header signature does not verify) Content-Transfer-Encoding: quoted-printable MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" From: Xie Yongji This patch introduces two new messages VHOST_USER_GET_INFLIGHT_FD and VHOST_USER_SET_INFLIGHT_FD to support transferring a shared buffer between qemu and backend. Firstly, qemu uses VHOST_USER_GET_INFLIGHT_FD to get the shared buffer from backend. Then qemu should send it back through VHOST_USER_SET_INFLIGHT_FD each time we start vhost-user. This shared buffer is used to track inflight I/O by backend. Qemu should clear it when vm reset. Signed-off-by: Xie Yongji Signed-off-by: Chai Wen Signed-off-by: Zhang Yu --- docs/interop/vhost-user.txt | 101 +++++++++++++++++++++++++++ hw/virtio/vhost-user.c | 110 ++++++++++++++++++++++++++++++ hw/virtio/vhost.c | 105 ++++++++++++++++++++++++++++ include/hw/virtio/vhost-backend.h | 10 +++ include/hw/virtio/vhost.h | 19 ++++++ 5 files changed, 345 insertions(+) diff --git a/docs/interop/vhost-user.txt b/docs/interop/vhost-user.txt index c2194711d9..fa470a8fe2 100644 --- a/docs/interop/vhost-user.txt +++ b/docs/interop/vhost-user.txt @@ -142,6 +142,18 @@ Depending on the request type, payload can be: Offset: a 64-bit offset of this area from the start of the supplied file descriptor =20 + * Inflight description + --------------------------------------------------------------- + | mmap size | mmap offset | version | num queues | queue size | + --------------------------------------------------------------- + + mmap size: a 64-bit size of area to track inflight I/O + mmap offset: a 64-bit offset of this area from the start + of the supplied file descriptor + version: a 16-bit version of this area + num queues: a 16-bit number of virtqueues + queue size: a 16-bit size of virtqueues + In QEMU the vhost-user message is implemented with the following struct: =20 typedef struct VhostUserMsg { @@ -157,6 +169,7 @@ typedef struct VhostUserMsg { struct vhost_iotlb_msg iotlb; VhostUserConfig config; VhostUserVringArea area; + VhostUserInflight inflight; }; } QEMU_PACKED VhostUserMsg; =20 @@ -175,6 +188,7 @@ the ones that do: * VHOST_USER_GET_PROTOCOL_FEATURES * VHOST_USER_GET_VRING_BASE * VHOST_USER_SET_LOG_BASE (if VHOST_USER_PROTOCOL_F_LOG_SHMFD) + * VHOST_USER_GET_INFLIGHT_FD (if VHOST_USER_PROTOCOL_F_INFLIGHT_SHMFD) =20 [ Also see the section on REPLY_ACK protocol extension. ] =20 @@ -188,6 +202,7 @@ in the ancillary data: * VHOST_USER_SET_VRING_CALL * VHOST_USER_SET_VRING_ERR * VHOST_USER_SET_SLAVE_REQ_FD + * VHOST_USER_SET_INFLIGHT_FD (if VHOST_USER_PROTOCOL_F_INFLIGHT_SHMFD) =20 If Master is unable to send the full message or receives a wrong reply it = will close the connection. An optional reconnection mechanism can be implemente= d. @@ -382,6 +397,71 @@ If VHOST_USER_PROTOCOL_F_SLAVE_SEND_FD protocol featur= e is negotiated, slave can send file descriptors (at most 8 descriptors in each message) to master via ancillary data using this fd communication channel. =20 +Inflight I/O tracking +--------------------- + +To support reconnecting after restart or crash, slave may need to get +and resubmit inflight I/O. If virtqueue is processed in order, we can +easily achieve that by getting the inflight head-descriptor from avail rin= g. +However, it can't work when we process descriptors out-of-order because +some entries which store inflight head-descriptor in avail ring might be +overrided by new entries. To solve this problem, slave need to allocate a +buffer to track inflight head-descriptor and share it with master for +persistent. VHOST_USER_GET_INFLIGHT_FD and VHOST_USER_SET_INFLIGHT_FD are +used to transfer this buffer between master and slave. And the format of +this buffer is described below: + +------------------------------------------------------- +| queue0 region | queue1 region | ... | queueN region | +------------------------------------------------------- + +N is the number of available virtqueues. Slave could get it from num queues +field of VhostUserInflight. + +Queue region can be implemented as: + +typedef struct DescState { + uint8_t inuse; + uint8_t version; + uint16_t used_idx; + uint16_t avail_idx; + uint16_t reserved; +} DescState; + +typedef struct QueueRegion { + uint8_t valid; + uint16_t desc_num; + DescState desc[0]; +} QueueRegion; + +The struct DescState is used to describe one head-descriptor's state. The +fields have following meanings: + + inuse: Indicate whether the descriptor is inuse or not. + + version: Indicate whether we have an atomic update to used ring and + inflight buffer when slave crash at that point. This field should be + increased by one before and after this two updates. An odd version + indicates an in-progress update. + + used_idx: Store old index of used ring before we update used ring and + inflight buffer so that slave can know whether an odd version inflight + head-descriptor in inflight buffer is processed or not. + + avail_idx: Used to preserve the descriptor's order in avail ring so th= at + slave can resubmit descriptors in order. + + reserved: Reserved for future use. + +An array of struct DescState is maintained to track all head-descriptors' = state +in queue region. The desc_num is the number of those head-descriptors whic= h is +also equal to the queue size of the virtqueue. Slave could get it from que= ue size +field of VhostUserInflight. The valid field is used to specify whether the= region +is valid or not. Slave can use it to detect whether vm is reset because qe= mu will +clear the buffer when the reset happens. + +Note that slave should align each region to cache line size. + Protocol features ----------------- =20 @@ -397,6 +477,7 @@ Protocol features #define VHOST_USER_PROTOCOL_F_CONFIG 9 #define VHOST_USER_PROTOCOL_F_SLAVE_SEND_FD 10 #define VHOST_USER_PROTOCOL_F_HOST_NOTIFIER 11 +#define VHOST_USER_PROTOCOL_F_INFLIGHT_SHMFD 12 =20 Master message types -------------------- @@ -761,6 +842,26 @@ Master message types was previously sent. The value returned is an error indication; 0 is success. =20 + * VHOST_USER_GET_INFLIGHT_FD + Id: 31 + Equivalent ioctl: N/A + Master payload: inflight description + + When VHOST_USER_PROTOCOL_F_INFLIGHT_SHMFD protocol feature has been + successfully negotiated, this message is submitted by master to get + a shared buffer from slave. The shared buffer will be used to track + inflight I/O by slave. QEMU should clear it when vm reset. + + * VHOST_USER_SET_INFLIGHT_FD + Id: 32 + Equivalent ioctl: N/A + Master payload: inflight description + + When VHOST_USER_PROTOCOL_F_INFLIGHT_SHMFD protocol feature has been + successfully negotiated, this message is submitted by master to send + the shared inflight buffer back to slave so that slave could get + inflight I/O after a crash or restart. + Slave message types ------------------- =20 diff --git a/hw/virtio/vhost-user.c b/hw/virtio/vhost-user.c index 564a31d12c..9aa6204c91 100644 --- a/hw/virtio/vhost-user.c +++ b/hw/virtio/vhost-user.c @@ -52,6 +52,7 @@ enum VhostUserProtocolFeature { VHOST_USER_PROTOCOL_F_CONFIG =3D 9, VHOST_USER_PROTOCOL_F_SLAVE_SEND_FD =3D 10, VHOST_USER_PROTOCOL_F_HOST_NOTIFIER =3D 11, + VHOST_USER_PROTOCOL_F_INFLIGHT_SHMFD =3D 12, VHOST_USER_PROTOCOL_F_MAX }; =20 @@ -89,6 +90,8 @@ typedef enum VhostUserRequest { VHOST_USER_POSTCOPY_ADVISE =3D 28, VHOST_USER_POSTCOPY_LISTEN =3D 29, VHOST_USER_POSTCOPY_END =3D 30, + VHOST_USER_GET_INFLIGHT_FD =3D 31, + VHOST_USER_SET_INFLIGHT_FD =3D 32, VHOST_USER_MAX } VhostUserRequest; =20 @@ -147,6 +150,14 @@ typedef struct VhostUserVringArea { uint64_t offset; } VhostUserVringArea; =20 +typedef struct VhostUserInflight { + uint64_t mmap_size; + uint64_t mmap_offset; + uint16_t version; + uint16_t num_queues; + uint16_t queue_size; +} VhostUserInflight; + typedef struct { VhostUserRequest request; =20 @@ -169,6 +180,7 @@ typedef union { VhostUserConfig config; VhostUserCryptoSession session; VhostUserVringArea area; + VhostUserInflight inflight; } VhostUserPayload; =20 typedef struct VhostUserMsg { @@ -1739,6 +1751,102 @@ static bool vhost_user_mem_section_filter(struct vh= ost_dev *dev, return result; } =20 +static int vhost_user_get_inflight_fd(struct vhost_dev *dev, + uint16_t queue_size, + struct vhost_inflight *inflight) +{ + void *addr; + int fd; + struct vhost_user *u =3D dev->opaque; + CharBackend *chr =3D u->user->chr; + VhostUserMsg msg =3D { + .hdr.request =3D VHOST_USER_GET_INFLIGHT_FD, + .hdr.flags =3D VHOST_USER_VERSION, + .payload.inflight.num_queues =3D dev->nvqs, + .payload.inflight.queue_size =3D queue_size, + .hdr.size =3D sizeof(msg.payload.inflight), + }; + + if (!virtio_has_feature(dev->protocol_features, + VHOST_USER_PROTOCOL_F_INFLIGHT_SHMFD)) { + return 0; + } + + if (vhost_user_write(dev, &msg, NULL, 0) < 0) { + return -1; + } + + if (vhost_user_read(dev, &msg) < 0) { + return -1; + } + + if (msg.hdr.request !=3D VHOST_USER_GET_INFLIGHT_FD) { + error_report("Received unexpected msg type. " + "Expected %d received %d", + VHOST_USER_GET_INFLIGHT_FD, msg.hdr.request); + return -1; + } + + if (msg.hdr.size !=3D sizeof(msg.payload.inflight)) { + error_report("Received bad msg size."); + return -1; + } + + if (!msg.payload.inflight.mmap_size) { + return 0; + } + + fd =3D qemu_chr_fe_get_msgfd(chr); + if (fd < 0) { + error_report("Failed to get mem fd"); + return -1; + } + + addr =3D mmap(0, msg.payload.inflight.mmap_size, PROT_READ | PROT_WRIT= E, + MAP_SHARED, fd, msg.payload.inflight.mmap_offset); + + if (addr =3D=3D MAP_FAILED) { + error_report("Failed to mmap mem fd"); + close(fd); + return -1; + } + + inflight->addr =3D addr; + inflight->fd =3D fd; + inflight->size =3D msg.payload.inflight.mmap_size; + inflight->offset =3D msg.payload.inflight.mmap_offset; + inflight->version =3D msg.payload.inflight.version; + inflight->queue_size =3D queue_size; + + return 0; +} + +static int vhost_user_set_inflight_fd(struct vhost_dev *dev, + struct vhost_inflight *inflight) +{ + VhostUserMsg msg =3D { + .hdr.request =3D VHOST_USER_SET_INFLIGHT_FD, + .hdr.flags =3D VHOST_USER_VERSION, + .payload.inflight.mmap_size =3D inflight->size, + .payload.inflight.mmap_offset =3D inflight->offset, + .payload.inflight.version =3D inflight->version, + .payload.inflight.num_queues =3D dev->nvqs, + .payload.inflight.queue_size =3D inflight->queue_size, + .hdr.size =3D sizeof(msg.payload.inflight), + }; + + if (!virtio_has_feature(dev->protocol_features, + VHOST_USER_PROTOCOL_F_INFLIGHT_SHMFD)) { + return 0; + } + + if (vhost_user_write(dev, &msg, &inflight->fd, 1) < 0) { + return -1; + } + + return 0; +} + VhostUserState *vhost_user_init(void) { VhostUserState *user =3D g_new0(struct VhostUserState, 1); @@ -1790,4 +1898,6 @@ const VhostOps user_ops =3D { .vhost_crypto_create_session =3D vhost_user_crypto_create_session, .vhost_crypto_close_session =3D vhost_user_crypto_close_session, .vhost_backend_mem_section_filter =3D vhost_user_mem_section_filte= r, + .vhost_get_inflight_fd =3D vhost_user_get_inflight_fd, + .vhost_set_inflight_fd =3D vhost_user_set_inflight_fd, }; diff --git a/hw/virtio/vhost.c b/hw/virtio/vhost.c index 569c4053ea..0a4de6b91b 100644 --- a/hw/virtio/vhost.c +++ b/hw/virtio/vhost.c @@ -1481,6 +1481,111 @@ void vhost_dev_set_config_notifier(struct vhost_dev= *hdev, hdev->config_ops =3D ops; } =20 +void vhost_dev_reset_inflight(struct vhost_inflight *inflight) +{ + if (inflight->addr) { + memset(inflight->addr, 0, inflight->size); + } +} + +void vhost_dev_free_inflight(struct vhost_inflight *inflight) +{ + if (inflight->addr) { + qemu_memfd_free(inflight->addr, inflight->size, inflight->fd); + inflight->addr =3D NULL; + inflight->fd =3D -1; + } +} + +static int vhost_dev_resize_inflight(struct vhost_inflight *inflight, + uint64_t new_size) +{ + Error *err =3D NULL; + int fd =3D -1; + void *addr =3D qemu_memfd_alloc("vhost-inflight", new_size, + F_SEAL_GROW | F_SEAL_SHRINK | F_SEAL_SEA= L, + &fd, &err); + + if (err) { + error_report_err(err); + return -1; + } + + vhost_dev_free_inflight(inflight); + inflight->offset =3D 0; + inflight->addr =3D addr; + inflight->fd =3D fd; + inflight->size =3D new_size; + + return 0; +} + +void vhost_dev_save_inflight(struct vhost_inflight *inflight, QEMUFile *f) +{ + if (inflight->addr) { + qemu_put_be64(f, inflight->size); + qemu_put_be16(f, inflight->version); + qemu_put_be16(f, inflight->queue_size); + qemu_put_buffer(f, inflight->addr, inflight->size); + } else { + qemu_put_be64(f, 0); + } +} + +int vhost_dev_load_inflight(struct vhost_inflight *inflight, QEMUFile *f) +{ + uint64_t size; + + size =3D qemu_get_be64(f); + if (!size) { + return 0; + } + + if (inflight->size !=3D size) { + if (vhost_dev_resize_inflight(inflight, size)) { + return -1; + } + } + inflight->version =3D qemu_get_be16(f); + inflight->queue_size =3D qemu_get_be16(f); + + qemu_get_buffer(f, inflight->addr, size); + + return 0; +} + +int vhost_dev_set_inflight(struct vhost_dev *dev, + struct vhost_inflight *inflight) +{ + int r; + + if (dev->vhost_ops->vhost_set_inflight_fd && inflight->addr) { + r =3D dev->vhost_ops->vhost_set_inflight_fd(dev, inflight); + if (r) { + VHOST_OPS_DEBUG("vhost_set_inflight_fd failed"); + return -errno; + } + } + + return 0; +} + +int vhost_dev_get_inflight(struct vhost_dev *dev, uint16_t queue_size, + struct vhost_inflight *inflight) +{ + int r; + + if (dev->vhost_ops->vhost_get_inflight_fd) { + r =3D dev->vhost_ops->vhost_get_inflight_fd(dev, queue_size, infli= ght); + if (r) { + VHOST_OPS_DEBUG("vhost_get_inflight_fd failed"); + return -errno; + } + } + + return 0; +} + /* Host notifiers must be enabled at this point. */ int vhost_dev_start(struct vhost_dev *hdev, VirtIODevice *vdev) { diff --git a/include/hw/virtio/vhost-backend.h b/include/hw/virtio/vhost-ba= ckend.h index 81283ec50f..d6632a18e6 100644 --- a/include/hw/virtio/vhost-backend.h +++ b/include/hw/virtio/vhost-backend.h @@ -25,6 +25,7 @@ typedef enum VhostSetConfigType { VHOST_SET_CONFIG_TYPE_MIGRATION =3D 1, } VhostSetConfigType; =20 +struct vhost_inflight; struct vhost_dev; struct vhost_log; struct vhost_memory; @@ -104,6 +105,13 @@ typedef int (*vhost_crypto_close_session_op)(struct vh= ost_dev *dev, typedef bool (*vhost_backend_mem_section_filter_op)(struct vhost_dev *dev, MemoryRegionSection *secti= on); =20 +typedef int (*vhost_get_inflight_fd_op)(struct vhost_dev *dev, + uint16_t queue_size, + struct vhost_inflight *inflight); + +typedef int (*vhost_set_inflight_fd_op)(struct vhost_dev *dev, + struct vhost_inflight *inflight); + typedef struct VhostOps { VhostBackendType backend_type; vhost_backend_init vhost_backend_init; @@ -142,6 +150,8 @@ typedef struct VhostOps { vhost_crypto_create_session_op vhost_crypto_create_session; vhost_crypto_close_session_op vhost_crypto_close_session; vhost_backend_mem_section_filter_op vhost_backend_mem_section_filter; + vhost_get_inflight_fd_op vhost_get_inflight_fd; + vhost_set_inflight_fd_op vhost_set_inflight_fd; } VhostOps; =20 extern const VhostOps user_ops; diff --git a/include/hw/virtio/vhost.h b/include/hw/virtio/vhost.h index a7f449fa87..f44f93f54a 100644 --- a/include/hw/virtio/vhost.h +++ b/include/hw/virtio/vhost.h @@ -7,6 +7,16 @@ #include "exec/memory.h" =20 /* Generic structures common for any vhost based device. */ + +struct vhost_inflight { + int fd; + void *addr; + uint64_t size; + uint64_t offset; + uint16_t version; + uint16_t queue_size; +}; + struct vhost_virtqueue { int kick; int call; @@ -120,4 +130,13 @@ int vhost_dev_set_config(struct vhost_dev *dev, const = uint8_t *data, */ void vhost_dev_set_config_notifier(struct vhost_dev *dev, const VhostDevConfigOps *ops); + +void vhost_dev_reset_inflight(struct vhost_inflight *inflight); +void vhost_dev_free_inflight(struct vhost_inflight *inflight); +void vhost_dev_save_inflight(struct vhost_inflight *inflight, QEMUFile *f); +int vhost_dev_load_inflight(struct vhost_inflight *inflight, QEMUFile *f); +int vhost_dev_set_inflight(struct vhost_dev *dev, + struct vhost_inflight *inflight); +int vhost_dev_get_inflight(struct vhost_dev *dev, uint16_t queue_size, + struct vhost_inflight *inflight); #endif --=20 2.17.1