From nobody Thu Mar 28 14:44:16 2024 Delivered-To: importer@patchew.org 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; Authentication-Results: mx.zohomail.com; dkim=fail; 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=fail(p=none dis=none) header.from=gmail.com ARC-Seal: i=1; a=rsa-sha256; t=1578891572; cv=none; d=zohomail.com; s=zohoarc; b=NwH5t4n0YP+nG8qAQ1RYVvitKgL0RWJFS+kVJRIPunbWN5g9ksOtDh4CU9+x8chkeBzJQ9Z7McBlz0B8xQGkPT5JMWhZMKwSukWYdSV8aDhGChM9fd6F7Wc/6ZEEFp4/tEYwyMPcP45UQt3FSYoy4KieWyr9f3WwxO4I1X9hPEo= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1578891572; h=Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=GXYOj+U3hSVlshxwvSlfIFI4FVfmQN4qlRQUjp4L3yQ=; b=ZTI+Ca7moWt8fF6dTNyPwxv3Rc/z1I8aFdp4pqGCZ6nnOwTEKeAAWtrd6ZE01Xp6U0xYArpqq21JSWuvPlb1jqNUCytJaHluxSawvmpRu3mGAUe4dxqgqvxQMAncNXOjdiuk3vXbjAaHBJeKFQ/NGg/fSrK8HgmNjqxT0mfy4hg= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=fail; 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=fail header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1578891572061643.0165142796595; Sun, 12 Jan 2020 20:59:32 -0800 (PST) Received: from localhost ([::1]:45644 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1iqrp4-0000tK-Fv for importer@patchew.org; Sun, 12 Jan 2020 23:59:30 -0500 Received: from eggs.gnu.org ([2001:470:142:3::10]:42111) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1iqrnR-0007F2-Bt for qemu-devel@nongnu.org; Sun, 12 Jan 2020 23:57:52 -0500 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1iqrnO-0006cD-2g for qemu-devel@nongnu.org; Sun, 12 Jan 2020 23:57:49 -0500 Received: from mail-pj1-x1043.google.com ([2607:f8b0:4864:20::1043]:54760) by eggs.gnu.org with esmtps (TLS1.0:RSA_AES_128_CBC_SHA1:16) (Exim 4.71) (envelope-from ) id 1iqrnN-0006aI-P4 for qemu-devel@nongnu.org; Sun, 12 Jan 2020 23:57:46 -0500 Received: by mail-pj1-x1043.google.com with SMTP id kx11so3618499pjb.4 for ; Sun, 12 Jan 2020 20:57:45 -0800 (PST) Received: from localhost.localdomain ([175.124.145.172]) by smtp.googlemail.com with ESMTPSA id o19sm17590552pjr.2.2020.01.12.20.57.39 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 12 Jan 2020 20:57:43 -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 :mime-version:content-transfer-encoding; bh=GXYOj+U3hSVlshxwvSlfIFI4FVfmQN4qlRQUjp4L3yQ=; b=puerb6KJcFk1aQ57eFjoQmj8tk492qOeKGOkVKgiEkf34O/P7fcw+B165J9wbpxwXi JB44ne4vFIsY6CGYQgKRaogaTOzp6yk/voOShpw8AV75hDvp3ta1XDiy6bR30D3n1KLB wgfI3LbJqM5ixRRkfUk6lD8TbSClJUu2gw2pWSlT6vmkv00iu7g9X8wtRb27xwMldlFa Hcl6BxDlkVrCAZZgL2j+oZa0Y/tbcRh/5trCguWPcFOpi1rVdD2BZsu/hEcxkj5WKJk8 65u+IDD0PHaBzhpa6jP1ivDXLHj+fmhomWcZdGruSAZadqJOqMEm4mGND9uitgXO8w+W GgNg== 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:mime-version:content-transfer-encoding; bh=GXYOj+U3hSVlshxwvSlfIFI4FVfmQN4qlRQUjp4L3yQ=; b=GbG+/QPPFAY+ZigWZ049wFnaffiiBvKUgzTy7ATkDsBPLl1vl14W8fvvKvd+f1GDxv hEhaUktiJk1zbHRdBUJL5qeDtLHjy2pgrnwffwU4qiEx9M1O919eJRMKr5e+yjB8Y7st SGjq+i0AnjuxCVIcv0tY9ypfJzeskFYY9VcCgBDZKfrCCFwmjgpOJ12jfJ3NSiqZvbXa c84/kH5vsBbJGwP8CXiSpoR5cVh2XXYSZEoFyvww2JzKNbLTpayw83bWKAkx8qaDIHd7 n0K06X2aszTh88Ejf9VeEUOT1k8JHFteDp0S3QcwNy9eSlPRcEfgnGcJQk16knoVFGrX FXfg== X-Gm-Message-State: APjAAAVJraY1ven5zi1pBgNT/pTsWZ8YBqwocF5bcZHb56L4fa1c6xk+ dPfZ1pBj+stmA4431hp7GtPuOn+8oG3hdw== X-Google-Smtp-Source: APXvYqzG8Do/B3hUiHGX8PmNKY5iXwjrsvdPeonLnfZk6ZQfToXyiRfsQuKnPVaVD4Uj2AnD9zV/UA== X-Received: by 2002:a17:902:9048:: with SMTP id w8mr17952256plz.294.1578891463794; Sun, 12 Jan 2020 20:57:43 -0800 (PST) From: Coiby Xu To: qemu-devel@nongnu.org Subject: [PATCH v1 1/5] vhost-user block device backend Date: Mon, 13 Jan 2020 12:57:00 +0800 Message-Id: <20200113045704.12318-2-coiby.xu@gmail.com> X-Mailer: git-send-email 2.24.1 In-Reply-To: <20200113045704.12318-1-coiby.xu@gmail.com> References: <20200113045704.12318-1-coiby.xu@gmail.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-detected-operating-system: by eggs.gnu.org: Genre and OS details not recognized. X-Received-From: 2607:f8b0:4864:20::1043 X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: kwolf@redhat.com, bharatlkmlkvm@gmail.com, Coiby Xu , stefanha@redhat.com Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: fail (Header signature does not verify) Content-Type: text/plain; charset="utf-8" By making use of libvhost, multiple block device drives can be exported and= each drive can serve multiple clients simultaneously. Since vhost-user-ser= ver needs a block drive to be created first, delay the creation of this obj= ect. Signed-off-by: Coiby Xu --- blockdev-vu.c | 1008 ++++++++++++++++++++++++++++++++++++ include/block/vhost-user.h | 46 ++ vl.c | 4 + 3 files changed, 1058 insertions(+) create mode 100644 blockdev-vu.c create mode 100644 include/block/vhost-user.h diff --git a/blockdev-vu.c b/blockdev-vu.c new file mode 100644 index 0000000000..45f0bb43a7 --- /dev/null +++ b/blockdev-vu.c @@ -0,0 +1,1008 @@ +#include "qemu/osdep.h" +#include "block/vhost-user.h" +#include "qapi/error.h" +#include "qapi/qapi-types-sockets.h" +#include "qapi/qapi-commands-block.h" + +#include "sysemu/block-backend.h" +#include "qemu/main-loop.h" + +#include "qemu/units.h" + +#include "block/block.h" + +#include "qom/object_interfaces.h" + +#include + +#include "hw/qdev-properties.h" +enum { + VHOST_USER_BLK_MAX_QUEUES =3D 8, +}; + +struct virtio_blk_inhdr { + unsigned char status; +}; + + +static QTAILQ_HEAD(, VubDev) vub_devs =3D QTAILQ_HEAD_INITIALIZER(vub_devs= ); + + +typedef struct VubReq { + VuVirtqElement *elem; + int64_t sector_num; + size_t size; + struct virtio_blk_inhdr *in; + struct virtio_blk_outhdr out; + VuClient *client; + struct VuVirtq *vq; +} VubReq; + +static void +remove_watch(VuDev *vu_dev, int fd) +{ + VuClient *client; + + g_assert(vu_dev); + g_assert(fd >=3D 0); + + client =3D container_of(vu_dev, VuClient, parent); + aio_set_fd_handler(client->blk->ctx, fd, false, NULL, NULL, NULL, NULL= ); +} + +static void close_client(VuClient *client) +{ + vu_deinit(&client->parent); + /** g_source_destroy(vub_device->parent.src); */ + client->sioc =3D NULL; + object_unref(OBJECT(client->ioc)); + client->closed =3D true; + +} + +static void vub_panic_cb(VuDev *vu_dev, const char *buf) +{ + if (buf) { + g_warning("vu_panic: %s", buf); + } + + VuClient *client =3D container_of(vu_dev, VuClient, parent); + if (client->blk->exit_panic) { + client->blk->close =3D true; + } + if (!client->closed) { + close_client(client); + } +} + + +static void vub_req_complete(VubReq *req) +{ + VuDev *vu_dev =3D &req->client->parent; + + /* IO size with 1 extra status byte */ + vu_queue_push(vu_dev, req->vq, req->elem, + req->size + 1); + vu_queue_notify(vu_dev, req->vq); + + if (req->elem) { + free(req->elem); + } + + g_free(req); +} + + + +static int +vub_discard_write_zeroes(VubReq *req, struct iovec *iov, uint32_t iovcnt, + uint32_t type) +{ + struct virtio_blk_discard_write_zeroes *desc; + ssize_t size; + void *buf; + + size =3D iov_size(iov, iovcnt); + if (size !=3D sizeof(*desc)) { + fprintf(stderr, "Invalid size %ld, expect %ld\n", size, sizeof(*de= sc)); + return -1; + } + buf =3D g_new0(char, size); + + iov_to_buf_full(iov, iovcnt, 0, buf, size); + + + #if defined(__linux__) && defined(BLKDISCARD) && defined(BLKZEROOUT) + VubDev *vdev_blk; + VuClient *client =3D container_of(dev, VuClient, parent); + vdev_blk =3D client->blk; + desc =3D (struct virtio_blk_discard_write_zeroes *)buf; + uint64_t range[2] =3D { le64toh(desc->sector) << 9, + le32toh(desc->num_sectors) << 9 }; + if (type =3D=3D VIRTIO_BLK_T_DISCARD) { + if (blk_pdiscard(vdev_blk->blk, range[0], range[1]) =3D=3D 0) { + g_free(buf); + return 0; + } + } else if (type =3D=3D VIRTIO_BLK_T_WRITE_ZEROES) { + if (blk_pwrite_zeroes(vdev_blk->blk, range[0], range[1]) =3D=3D 0)= { + g_free(buf); + return 0; + } + } + #endif + + g_free(buf); + return -1; +} + + +static void +vub_flush(VubReq *req) +{ + VuClient *client =3D req->client; + blk_co_flush(client->blk->backend); +} + + +#define NOT_DONE 0x7fffffff /* used while emulated sync operation in progr= ess */ +typedef struct BlkRwCo { + BlockBackend *blk; + int64_t offset; + void *iobuf; + int ret; + BdrvRequestFlags flags; +} BlkRwCo; + +static void blk_read_entry(void *opaque) +{ + BlkRwCo *rwco =3D opaque; + QEMUIOVector *qiov =3D rwco->iobuf; + + rwco->ret =3D blk_co_preadv(rwco->blk, rwco->offset, qiov->size, + qiov, rwco->flags); + aio_wait_kick(); +} + + +static void blk_write_entry(void *opaque) +{ + BlkRwCo *rwco =3D opaque; + QEMUIOVector *qiov =3D rwco->iobuf; + + rwco->ret =3D blk_co_pwritev(rwco->blk, rwco->offset, qiov->size, + qiov, rwco->flags); + aio_wait_kick(); +} + + +static int blk_prw(BlockBackend *blk, QEMUIOVector *qiov, int64_t offset, + CoroutineEntry co_entry, BdrvRequestFlags flags) +{ + + BlkRwCo rwco =3D { + .blk =3D blk, + .offset =3D offset, + .iobuf =3D qiov, + .flags =3D flags, + .ret =3D NOT_DONE, + }; + + if (qemu_in_coroutine()) { + /* Fast-path if already in coroutine context */ + co_entry(&rwco); + } else { + Coroutine *co =3D qemu_coroutine_create(co_entry, &rwco); + bdrv_coroutine_enter(blk_bs(blk), co); + BDRV_POLL_WHILE(blk_bs(blk), rwco.ret =3D=3D NOT_DONE); + } + + return rwco.ret; +} + + +static ssize_t +vub_rwv(VubReq *req, struct iovec *iov, + uint32_t iovcnt, + CoroutineEntry co_entry) +{ + VuClient *client =3D req->client; + ssize_t rc; + + if (!iovcnt) { + fprintf(stderr, "Invalid Read/Write IOV count\n"); + return -1; + } + + int64_t offset =3D req->sector_num * 512; + QEMUIOVector *qiov =3D g_new0(QEMUIOVector, 1); + qemu_iovec_init_external(qiov, iov, iovcnt); + rc =3D blk_prw(client->blk->backend, qiov, offset, co_entry, 0); + + req->size =3D iov_size(iov, iovcnt); + if (rc < 0) { + fprintf(stderr, "%s, Sector %"PRIu64", Size %lu failed with %s\n", + client->blk->name, req->sector_num, req->size, + strerror(errno)); + return -1; + } + + return rc; +} + +static int vub_virtio_process_req(VuClient *client, + VuVirtq *vq) +{ + VuDev *vu_dev =3D &client->parent; + VuVirtqElement *elem; + uint32_t type; + VubReq *req; + + elem =3D vu_queue_pop(vu_dev, vq, sizeof(VuVirtqElement) + sizeof(VubR= eq)); + if (!elem) { + return -1; + } + + struct iovec *in_iov =3D elem->in_sg; + struct iovec *out_iov =3D elem->out_sg; + unsigned in_num =3D elem->in_num; + unsigned out_num =3D elem->out_num; + /* refer to hw/block/virtio_blk.c */ + if (elem->out_num < 1 || elem->in_num < 1) { + fprintf(stderr, "virtio-blk request missing headers\n"); + free(elem); + return -1; + } + + req =3D g_new0(VubReq, 1); + req->client =3D client; + req->vq =3D vq; + req->elem =3D elem; + + if (unlikely(iov_to_buf(out_iov, out_num, 0, &req->out, + sizeof(req->out)) !=3D sizeof(req->out))) { + fprintf(stderr, "virtio-blk request outhdr too short"); + goto err; + } + + iov_discard_front(&out_iov, &out_num, sizeof(req->out)); + + if (in_iov[in_num - 1].iov_len < sizeof(struct virtio_blk_inhdr)) { + fprintf(stderr, "virtio-blk request inhdr too short"); + goto err; + } + + /* We always touch the last byte, so just see how big in_iov is. */ + req->in =3D (void *)in_iov[in_num - 1].iov_base + + in_iov[in_num - 1].iov_len + - sizeof(struct virtio_blk_inhdr); + iov_discard_back(in_iov, &in_num, sizeof(struct virtio_blk_inhdr)); + + + type =3D le32toh(req->out.type); + switch (type & ~VIRTIO_BLK_T_BARRIER) { + case VIRTIO_BLK_T_IN: + case VIRTIO_BLK_T_OUT: { + ssize_t ret =3D 0; + bool is_write =3D type & VIRTIO_BLK_T_OUT; + req->sector_num =3D le64toh(req->out.sector); + if (is_write) { + ret =3D vub_rwv(req, out_iov, out_num, blk_write_entry); + } else { + ret =3D vub_rwv(req, in_iov, in_num, blk_read_entry); + } + if (ret >=3D 0) { + req->in->status =3D VIRTIO_BLK_S_OK; + } else { + req->in->status =3D VIRTIO_BLK_S_IOERR; + } + vub_req_complete(req); + break; + } + case VIRTIO_BLK_T_FLUSH: + vub_flush(req); + req->in->status =3D VIRTIO_BLK_S_OK; + vub_req_complete(req); + break; + case VIRTIO_BLK_T_GET_ID: { + size_t size =3D MIN(iov_size(&elem->in_sg[0], in_num), + VIRTIO_BLK_ID_BYTES); + snprintf(elem->in_sg[0].iov_base, size, "%s", "vhost_user_blk"); + req->in->status =3D VIRTIO_BLK_S_OK; + req->size =3D elem->in_sg[0].iov_len; + vub_req_complete(req); + break; + } + case VIRTIO_BLK_T_DISCARD: + case VIRTIO_BLK_T_WRITE_ZEROES: { + int rc; + rc =3D vub_discard_write_zeroes(req, &elem->out_sg[1], out_num, ty= pe); + if (rc =3D=3D 0) { + req->in->status =3D VIRTIO_BLK_S_OK; + } else { + req->in->status =3D VIRTIO_BLK_S_IOERR; + } + vub_req_complete(req); + break; + } + default: + req->in->status =3D VIRTIO_BLK_S_UNSUPP; + vub_req_complete(req); + break; + } + + return 0; + +err: + free(elem); + g_free(req); + return -1; +} + + +static void vub_process_vq(VuDev *vu_dev, int idx) +{ + VuClient *client; + VuVirtq *vq; + int ret; + + client =3D container_of(vu_dev, VuClient, parent); + assert(client); + + vq =3D vu_get_queue(vu_dev, idx); + assert(vq); + + while (1) { + ret =3D vub_virtio_process_req(client, vq); + if (ret) { + break; + } + } +} + + +static void vub_queue_set_started(VuDev *vu_dev, int idx, bool started) +{ + VuVirtq *vq; + + assert(vu_dev); + + vq =3D vu_get_queue(vu_dev, idx); + vu_set_queue_handler(vu_dev, vq, started ? vub_process_vq : NULL); +} + +static uint64_t +vub_get_features(VuDev *dev) +{ + uint64_t features; + VubDev *vdev_blk; + + VuClient *client =3D container_of(dev, VuClient, parent); + vdev_blk =3D client->blk; + + features =3D 1ull << VIRTIO_BLK_F_SIZE_MAX | + 1ull << VIRTIO_BLK_F_SEG_MAX | + 1ull << VIRTIO_BLK_F_TOPOLOGY | + 1ull << VIRTIO_BLK_F_BLK_SIZE | + 1ull << VIRTIO_BLK_F_FLUSH | + #if defined(__linux__) && defined(BLKDISCARD) && defined(BL= KZEROOUT) + 1ull << VIRTIO_BLK_F_DISCARD | + 1ull << VIRTIO_BLK_F_WRITE_ZEROES | + #endif + 1ull << VIRTIO_BLK_F_CONFIG_WCE | + 1ull << VIRTIO_F_VERSION_1 | + 1ull << VIRTIO_RING_F_INDIRECT_DESC | + 1ull << VIRTIO_RING_F_EVENT_IDX | + 1ull << VHOST_USER_F_PROTOCOL_FEATURES; + + if (!vdev_blk->writable) { + features |=3D 1ull << VIRTIO_BLK_F_RO; + } + + return features; +} + +static uint64_t +vub_get_protocol_features(VuDev *dev) +{ + return 1ull << VHOST_USER_PROTOCOL_F_CONFIG | + 1ull << VHOST_USER_PROTOCOL_F_INFLIGHT_SHMFD; +} + +static int +vub_get_config(VuDev *vu_dev, uint8_t *config, uint32_t len) +{ + VubDev *vdev_blk; + + VuClient *client =3D container_of(vu_dev, VuClient, parent); + vdev_blk =3D client->blk; + memcpy(config, &vdev_blk->blkcfg, len); + + return 0; +} + +static int +vub_set_config(VuDev *vu_dev, const uint8_t *data, + uint32_t offset, uint32_t size, uint32_t flags) +{ + VubDev *vdev_blk; + + VuClient *client =3D container_of(vu_dev, VuClient, parent); + vdev_blk =3D client->blk; + uint8_t wce; + + /* don't support live migration */ + if (flags !=3D VHOST_SET_CONFIG_TYPE_MASTER) { + return -1; + } + + + if (offset !=3D offsetof(struct virtio_blk_config, wce) || + size !=3D 1) { + return -1; + } + + wce =3D *data; + if (wce =3D=3D vdev_blk->blkcfg.wce) { + /* Do nothing as same with old configuration */ + return 0; + } + + vdev_blk->blkcfg.wce =3D wce; + blk_set_enable_write_cache(vdev_blk->backend, true); + return 0; +} + + +/* + * When the client disconnects, it send a VHOST_USER_NONE request + * and vu_process_message will simple call exit which cause the VM + * to exit abruptly. + * To avoid this issue, process VHOST_USER_NONE request ahead + * of vu_process_message. + * + */ +static int vub_process_msg(VuDev *dev, VhostUserMsg *vmsg, int *do_reply) +{ + if (vmsg->request =3D=3D VHOST_USER_NONE) { + dev->panic(dev, "disconnect"); + return true; + } + return false; +} + +static void +vmsg_close_fds(VhostUserMsg *vmsg) +{ + int i; + for (i =3D 0; i < vmsg->fd_num; i++) { + close(vmsg->fds[i]); + } +} + +static bool +vu_message_read_co(VuDev *vu_dev, int conn_fd, VhostUserMsg *vmsg) +{ + char control[CMSG_SPACE(VHOST_MEMORY_MAX_NREGIONS * sizeof(int))] =3D = { }; + struct iovec iov =3D { + .iov_base =3D (char *)vmsg, + .iov_len =3D VHOST_USER_HDR_SIZE, + }; + struct msghdr msg =3D { + .msg_iov =3D &iov, + .msg_iovlen =3D 1, + .msg_control =3D control, + .msg_controllen =3D sizeof(control), + }; + size_t fd_size; + struct cmsghdr *cmsg; + int rc; + char buffer[100]; + VuClient *client =3D container_of(vu_dev, VuClient, parent); + QIOChannel *ioc =3D client->ioc; + do { + rc =3D recvmsg(conn_fd, &msg, 0); + if (rc < 0) { + if (errno =3D=3D EAGAIN) { + if (qemu_in_coroutine()) { + qio_channel_yield(ioc, G_IO_IN); + } else { + qio_channel_wait(ioc, G_IO_IN); + } + continue; + } else if (errno =3D=3D EINTR) { + continue; + } + } + break; + } while (true); + + if (rc < 0) { + sprintf(buffer, "Error while recvmsg: %s", strerror(errno)); + vub_panic_cb(vu_dev, buffer); + return false; + } + + assert(rc =3D=3D VHOST_USER_HDR_SIZE || rc =3D=3D 0); + + vmsg->fd_num =3D 0; + for (cmsg =3D CMSG_FIRSTHDR(&msg); + cmsg !=3D NULL; + cmsg =3D CMSG_NXTHDR(&msg, cmsg)) + { + if (cmsg->cmsg_level =3D=3D SOL_SOCKET && cmsg->cmsg_type =3D=3D S= CM_RIGHTS) { + fd_size =3D cmsg->cmsg_len - CMSG_LEN(0); + vmsg->fd_num =3D fd_size / sizeof(int); + memcpy(vmsg->fds, CMSG_DATA(cmsg), fd_size); + break; + } + } + + if (vmsg->size > sizeof(vmsg->payload)) { + sprintf(buffer, + "Error: too big message request: %d, size: vmsg->size: %u,= " + "while sizeof(vmsg->payload) =3D %zu\n", + vmsg->request, vmsg->size, sizeof(vmsg->payload)); + vub_panic_cb(vu_dev, buffer); + goto fail; + } + + if (vmsg->size) { + do { + rc =3D read(conn_fd, &vmsg->payload, vmsg->size); + if (rc < 0) { + if (errno =3D=3D EAGAIN) { + if (qemu_in_coroutine()) { + qio_channel_yield(ioc, G_IO_IN); + } else { + qio_channel_wait(ioc, G_IO_IN); + } + continue; + } else if (errno =3D=3D EINTR) { + continue; + } + } + break; + } while (true); + + if (rc <=3D 0) { + sprintf(buffer, "Error while reading: %s", strerror(errno)); + vub_panic_cb(vu_dev, buffer); + goto fail; + } + + assert(rc =3D=3D vmsg->size); + } + + return true; + +fail: + vmsg_close_fds(vmsg); + + return false; +} + +static void vub_kick_cb(void *opaque) +{ + vu_watch_cb_data *data =3D (vu_watch_cb_data *) opaque; + int index =3D data->index; + VuDev *dev =3D data->vu_dev; + VuVirtq *vq =3D &dev->vq[index]; + int sock =3D vq->kick_fd; + eventfd_t kick_data; + ssize_t rc; + + rc =3D eventfd_read(sock, &kick_data); + if (rc =3D=3D -1) { + char buffer[100]; + sprintf(buffer, "kick eventfd_read(): %s", strerror(errno)); + vub_panic_cb(dev, buffer); + g_free(data); + dev->remove_watch(dev, dev->vq[index].kick_fd); + } else { + if (vq->handler) { + vq->handler(dev, index); + } + } +} + +static const VuDevIface vub_iface =3D { + .get_features =3D vub_get_features, + .queue_set_started =3D vub_queue_set_started, + .get_protocol_features =3D vub_get_protocol_features, + .get_config =3D vub_get_config, + .set_config =3D vub_set_config, + .process_msg =3D vub_process_msg, + .read_msg =3D vu_message_read_co, + .kick_callback =3D vub_kick_cb, +}; + + +void vub_free(VubDev *vub_dev, bool called_by_QOM) +{ + if (!vub_dev) { + return; + } + + blk_unref(vub_dev->backend); + g_free(vub_dev->name); + g_free(vub_dev->unix_socket); + + if (vub_dev->next.tqe_circ.tql_prev) { + /* + * if vub_dev->next.tqe_circ.tql_prev =3D null, + * vub_dev hasn't been inserted into the queue and + * vub_free is called by obj->instance_finalize. + */ + QTAILQ_REMOVE(&vub_devs, vub_dev, next); + } + /* + * Needn't to free vub_dev if called by QOM + * because QOM will do the clean-up work. + */ + if (!called_by_QOM) { + g_free(vub_dev); + } +} + +static coroutine_fn void vu_client_trip(void *opaque) +{ + VuClient *client =3D opaque; + + while (!client->closed) { + vu_dispatch(&client->parent); + } + + QTAILQ_REMOVE(&client->blk->clients, client, next); + +} + +static void vu_client_start(VuClient *client) +{ + Coroutine *co =3D qemu_coroutine_create(vu_client_trip, client); + qemu_coroutine_enter(co); +} + + +G_STATIC_ASSERT((int)G_IO_IN =3D=3D (int)VU_WATCH_IN); +G_STATIC_ASSERT((int)G_IO_OUT =3D=3D (int)VU_WATCH_OUT); +G_STATIC_ASSERT((int)G_IO_PRI =3D=3D (int)VU_WATCH_PRI); +G_STATIC_ASSERT((int)G_IO_ERR =3D=3D (int)VU_WATCH_ERR); +G_STATIC_ASSERT((int)G_IO_HUP =3D=3D (int)VU_WATCH_HUP); + +static void +set_watch(VuDev *vu_dev, int fd, int vu_evt, + vu_watch_cb_packed_data cb, void *pvt) +{ + /* + * since aio_dispatch can only pass one user data pointer to the + * callback function, pack VuDev, pvt into a struct + */ + VuClient *client; + + g_assert(vu_dev); + g_assert(fd >=3D 0); + g_assert(cb); + client =3D container_of(vu_dev, VuClient, parent); + vu_watch_cb_data *cb_data =3D g_new0(vu_watch_cb_data, 1); + cb_data->index =3D (intptr_t) pvt; + cb_data->vu_dev =3D vu_dev; + aio_set_fd_handler(client->blk->ctx, fd, false, (void *) cb, + NULL, NULL, cb_data); +} + + +void vub_accept(QIONetListener *listener, QIOChannelSocket *sioc, + gpointer opaque) +{ + VuClient *client; + VubDev *vub_device =3D opaque; + client =3D g_new0(VuClient, 1); + + if (!vu_init_packed_data(&client->parent, VHOST_USER_BLK_MAX_QUEUES, + sioc->fd, vub_panic_cb, set_watch, + remove_watch, &vub_iface)) { + fprintf(stderr, "Failed to initialized libvhost-user\n"); + g_free(client); + return; + } + + client->blk =3D vub_device; + client->refcount =3D 1; + client->sioc =3D sioc; + /* + * increase the object reference, so cioc will not freed by + * qio_net_listener_channel_func which will call object_unref(OBJECT(s= ioc)) + */ + object_ref(OBJECT(client->sioc)); + qio_channel_set_name(QIO_CHANNEL(sioc), "vhost-user client"); + client->ioc =3D QIO_CHANNEL(sioc); + object_ref(OBJECT(client->ioc)); + object_ref(OBJECT(sioc)); + + qio_channel_set_blocking(QIO_CHANNEL(client->sioc), false, NULL); + client->closed =3D false; + QTAILQ_INSERT_TAIL(&client->blk->clients, client, next); + vu_client_start(client); +} + + +void +vub_initialize_config(BlockDriverState *bs, struct virtio_blk_config *conf= ig) +{ + config->capacity =3D bdrv_getlength(bs) >> BDRV_SECTOR_BITS; + config->blk_size =3D BDRV_SECTOR_SIZE; + config->size_max =3D 65536; + config->seg_max =3D 128 - 2; + config->min_io_size =3D 1; + config->opt_io_size =3D 1; + config->num_queues =3D 1; + #if defined(__linux__) && defined(BLKDISCARD) && defined(BLKZEROOUT) + config->max_discard_sectors =3D 32768; + config->max_discard_seg =3D 1; + config->discard_sector_alignment =3D config->blk_size >> 9; + config->max_write_zeroes_sectors =3D 32768; + config->max_write_zeroes_seg =3D 1; + #endif +} + + +static VubDev *vub_new(VubDev *vub_device, const char *name, + const char *unix_socket, bool writable, Error **err= p) +{ + + BlockBackend *blk; + + /* + * Don't allow resize while the vhost user server is running, + * otherwise we don't care what happens with the node. + */ + uint64_t perm =3D BLK_PERM_CONSISTENT_READ; + int ret; + + AioContext *ctx; + + BlockDriverState *bs =3D bdrv_lookup_bs(name, + name, + errp); + + if (!bs) { + error_setg(errp, + "No drive with name '%s'." + " Please find the list of names with " + "'info block'", name); + return NULL; + } + + if (bdrv_is_read_only(bs)) { + writable =3D false; + } + + if (writable) { + perm |=3D BLK_PERM_WRITE; + } + + ctx =3D bdrv_get_aio_context(bs); + aio_context_acquire(ctx); + bdrv_invalidate_cache(bs, NULL); + aio_context_release(ctx); + + blk =3D blk_new(bdrv_get_aio_context(bs), perm, + BLK_PERM_CONSISTENT_READ | BLK_PERM_WRITE_UNCHANGED | + BLK_PERM_WRITE | BLK_PERM_GRAPH_MOD); + ret =3D blk_insert_bs(blk, bs, errp); + + if (ret < 0) { + goto fail; + } + + + blk_set_enable_write_cache(blk, false); + + blk_set_allow_aio_context_change(blk, true); + + + vub_device->name =3D g_strdup(name); + vub_device->unix_socket =3D g_strdup(unix_socket); + vub_device->writable =3D writable; + vub_device->blkcfg.wce =3D 0; + vub_device->backend =3D blk; + vub_device->ctx =3D ctx; + vub_initialize_config(bs, &vub_device->blkcfg); + return vub_device; + +fail: + blk_unref(blk); + return NULL; +} + +void vhost_user_server_free(VubDev *vub_device, bool called_by_QOM) +{ + if (!vub_device) { + return; + } + + VuClient *client, *next; + QTAILQ_FOREACH_SAFE(client, &vub_device->clients, next, next) { + if (!client->closed) { + close_client(client); + } + } + + if (vub_device->listener) { + qio_net_listener_disconnect(vub_device->listener); + object_unref(OBJECT(vub_device->listener)); + } + vub_free(vub_device, called_by_QOM); + +} + + +VubDev *vub_dev_find(const char *name) +{ + VubDev *vub_device; + QTAILQ_FOREACH(vub_device, &vub_devs, next) { + if (strcmp(name, vub_device->name) =3D=3D 0) { + return vub_device; + } + } + + return NULL; +} + + +static VubDev *vub_dev_find_by_unix_socket(const char *unix_socket) +{ + VubDev *vub_device; + QTAILQ_FOREACH(vub_device, &vub_devs, next) { + if (strcmp(unix_socket, vub_device->unix_socket) =3D=3D 0) { + return vub_device; + } + } + + return NULL; +} + +static void vhost_user_server_start(VubDev *vub_device, const char *unix_s= ocket, + const char *name, bool writable, + Error **errp) +{ + + if (vub_dev_find(name) || vub_dev_find_by_unix_socket(unix_socket)) { + error_setg(errp, "Vhost user server with name '%s' or " + "with socket_path '%s' has already been started", + name, unix_socket); + return; + } + + + if (!vub_new(vub_device, name, unix_socket, writable, errp)) { + return; + } + + + vub_device->listener =3D qio_net_listener_new(); + + qio_net_listener_set_name(vub_device->listener, + "vhost-user-backend-listener"); + + SocketAddress *addr =3D g_new0(SocketAddress, 1); + addr->u.q_unix.path =3D (char *) unix_socket; + addr->type =3D SOCKET_ADDRESS_TYPE_UNIX; + if (qio_net_listener_open_sync(vub_device->listener, addr, 1, errp) < = 0) { + goto error; + } + + + QTAILQ_INSERT_TAIL(&vub_devs, vub_device, next); + QTAILQ_INIT(&vub_device->clients); + + qio_net_listener_set_client_func(vub_device->listener, + vub_accept, + vub_device, + NULL); + + return; + + error: + vub_free(vub_device, false); +} + +static void vu_set_block_name(Object *obj, const char *value, + Error **errp) +{ + VubDev *vus =3D VHOST_USER_SERVER(obj);; + + if (vus->name) { + error_setg(errp, "evdev property already set"); + return; + } + + vus->name =3D g_strdup(value); +} + +static char *vu_get_block_name(Object *obj, Error **errp) +{ + VubDev *vus =3D VHOST_USER_SERVER(obj); + return g_strdup(vus->name); +} + + +static void vu_set_unix_socket(Object *obj, const char *value, + Error **errp) +{ + VubDev *vus =3D VHOST_USER_SERVER(obj);; + + if (vus->unix_socket) { + error_setg(errp, "unix_socket property already set"); + return; + } + + vus->unix_socket =3D g_strdup(value); + vhost_user_server_start(vus, value, vus->name, + vus->writable, errp); +} + +static char *vu_get_unix_socket(Object *obj, Error **errp) +{ + VubDev *vus =3D VHOST_USER_SERVER(obj);; + return g_strdup(vus->unix_socket); +} + +static bool vu_get_block_writable(Object *obj, Error **errp) +{ + VubDev *vus =3D VHOST_USER_SERVER(obj);; + return vus->writable; +} + +static void vu_set_block_writable(Object *obj, bool value, Error **errp) +{ + VubDev *vus =3D VHOST_USER_SERVER(obj); + + vus->writable =3D value; +} + +static void vhost_user_server_instance_init(Object *obj) +{ + + object_property_add_bool(obj, "writable", + vu_get_block_writable, + vu_set_block_writable, NULL); + + object_property_add_str(obj, "name", + vu_get_block_name, + vu_set_block_name, NULL); + + object_property_add_str(obj, "unix_socket", + vu_get_unix_socket, + vu_set_unix_socket, NULL); + +} + +static void vhost_user_server_instance_finalize(Object *obj) +{ + VubDev *vus =3D VHOST_USER_SERVER(obj); + vhost_user_server_free(vus, true); + /* object_del shouldn't free this object struct */ + obj->free =3D NULL; +} + +static const TypeInfo vhost_user_server_info =3D { + .name =3D TYPE_VHOST_USER_SERVER, + .parent =3D TYPE_OBJECT, + .instance_size =3D sizeof(VuDev), + .instance_init =3D vhost_user_server_instance_init, + .instance_finalize =3D vhost_user_server_instance_finalize, + .interfaces =3D (InterfaceInfo[]) { + {TYPE_USER_CREATABLE}, + {} + }, +}; + +static void vhost_user_server_register_types(void) +{ + type_register_static(&vhost_user_server_info); +} + +type_init(vhost_user_server_register_types) + diff --git a/include/block/vhost-user.h b/include/block/vhost-user.h new file mode 100644 index 0000000000..ef6d695244 --- /dev/null +++ b/include/block/vhost-user.h @@ -0,0 +1,46 @@ +#include "io/channel-socket.h" +#include "io/net-listener.h" +#include "contrib/libvhost-user/libvhost-user.h" +#include "standard-headers/linux/virtio_blk.h" +typedef struct VubDev VubDev; +typedef struct VuClient VuClient; +#define TYPE_VHOST_USER_SERVER "vhost-user-server" + +#define VHOST_USER_SERVER(obj) \ + OBJECT_CHECK(VubDev, obj, TYPE_VHOST_USER_SERVER) +/* vhost user block device */ +struct VubDev { + Object parent_obj; + char *name; + char *unix_socket; + bool exit_panic; + bool close; + BlockBackend *backend; + AioContext *ctx; + QIONetListener *listener; + QIOChannelSocket *sioc; + QTAILQ_HEAD(, VuClient) clients; + QTAILQ_ENTRY(VubDev) next; + struct virtio_blk_config blkcfg; + bool writable; +}; + +struct VuClient { + VuDev parent; + int refcount; + VubDev *blk; + QIOChannelSocket *sioc; /* The underlying data channel */ + QIOChannel *ioc; /* The current I/O channel */ + QTAILQ_ENTRY(VuClient) next; + bool closed; +}; +VubDev *vub_dev_find(const char *name); + +void vhost_user_server_free(VubDev *vub_device, bool called_by_QOM); +void vub_accept(QIONetListener *listener, QIOChannelSocket *sioc, + gpointer opaque); + +void vub_free(VubDev *vub_dev, bool called_by_QOM); + +void vub_initialize_config(BlockDriverState *bs, + struct virtio_blk_config *config); diff --git a/vl.c b/vl.c index 86474a55c9..72ac506342 100644 --- a/vl.c +++ b/vl.c @@ -2553,6 +2553,10 @@ static bool object_create_initial(const char *type, = QemuOpts *opts) } #endif + /* Reason: vhost-user-server property "name" */ + if (g_str_equal(type, "vhost-user-server")) { + return false; + } /* * Reason: filter-* property "netdev" etc. */ -- 2.24.1 From nobody Thu Mar 28 14:44:16 2024 Delivered-To: importer@patchew.org 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; Authentication-Results: mx.zohomail.com; dkim=fail; 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=fail(p=none dis=none) header.from=gmail.com ARC-Seal: i=1; a=rsa-sha256; t=1578891573; cv=none; d=zohomail.com; s=zohoarc; b=Q3rDPIxKL9+bu794kklQNPrZhL+o9gtkBW5y7wAaHmCDSND4KmA7I8/FVSDW6eeoA+7QZkdky7tq6LQ9KP+X5scMzPVtLrRIOspxl6Wo/uXsy7usM3Smk7nQyZIDyn2z8x8ZIL8C1Zh+jct7vxAUG9xsbjLRipzcbW1YddTUAx0= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1578891573; h=Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=Smb5q2JKehl018b2NdA+yhR2A85PIPWYcZo1EvMvLD0=; b=CPA+53GnueGBLjGgvtgL2qEl3WOQrR2CRmhRn7BgOCQAze9LtPtTQv2cWUuOwW015tm3vs0NoM2es1Oszj+pTvecn3bnyiNMONJA3fJO8n1BPuZkq3AC4eZeafj2G2meDduB+Xy7DahrslB91PNYGEZbdGat5V/B7LATHc//sDo= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=fail; 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=fail header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1578891573899951.006709962275; Sun, 12 Jan 2020 20:59:33 -0800 (PST) Received: from localhost ([::1]:45646 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1iqrp6-0000zQ-HD for importer@patchew.org; Sun, 12 Jan 2020 23:59:32 -0500 Received: from eggs.gnu.org ([2001:470:142:3::10]:42138) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1iqrnU-0007IM-1M for qemu-devel@nongnu.org; Sun, 12 Jan 2020 23:57:53 -0500 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1iqrnS-0006kV-Er for qemu-devel@nongnu.org; Sun, 12 Jan 2020 23:57:51 -0500 Received: from mail-pl1-x642.google.com ([2607:f8b0:4864:20::642]:40943) by eggs.gnu.org with esmtps (TLS1.0:RSA_AES_128_CBC_SHA1:16) (Exim 4.71) (envelope-from ) id 1iqrnS-0006jA-5Y for qemu-devel@nongnu.org; Sun, 12 Jan 2020 23:57:50 -0500 Received: by mail-pl1-x642.google.com with SMTP id s21so3339430plr.7 for ; Sun, 12 Jan 2020 20:57:50 -0800 (PST) Received: from localhost.localdomain ([175.124.145.172]) by smtp.googlemail.com with ESMTPSA id o19sm17590552pjr.2.2020.01.12.20.57.44 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 12 Jan 2020 20:57:48 -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 :mime-version:content-transfer-encoding; bh=Smb5q2JKehl018b2NdA+yhR2A85PIPWYcZo1EvMvLD0=; b=E59JNfhk/r1jKFVwN5hcOKWwgcBGyOBh8nrad17AWYEKK1WZvef1lljC74tdL1FbPX He5tOyg87y998r8mxQHG3tkowQtFTfpkEt5Bxviz4fAhSTweEeu7rN2wpB5fDsE5Y/tR viryg+4lWtiBjC+o0MqPX1AJ+E9n3QkvDqFSOArSyi5qrF2lBKTDjwef3P8KJaeaX9fD 2hSDZ+UBvT0+aFaFwT5CB5vYrgh1ZRDoRH7RSrQRfQeLeFSOv6eYZ3cZ15uCQr8LR4qD 4aILm/l6Y58iQV4oWEcnwx43uCCJFLc2zRRQZFLiPwednwrRnw8mx3fyZdXXvvE19opn ay8Q== 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:mime-version:content-transfer-encoding; bh=Smb5q2JKehl018b2NdA+yhR2A85PIPWYcZo1EvMvLD0=; b=LfQJ/4eftwd14Kwt+4FQLeledwavPj0Aic6zdytQPpD47+i61nxTXhatN/rUggpuKW mhVy3gcexlkBDX4p1CPJSpfgEBhw8ccOXUNf7gGWsGrf6hmJ+12XJYoJwHcGqqPzZ94b 08GLSSKv0wb6tOvrfuYabbN1pVSTumY/SYY5x6vZ1EC1xR9QVP1RMwE8PzoXB2XPTivy eVVkenq3CjLsvkxZq4DoWvUkcBrJjUd3PzUjXDmiiC1qzQTZqXYxs7nvThGB3sL49VqC EetUOFNFgTAdsCLFk66GEbHSllvgih8q8ePGlleZCirgez98FzevRC/Gqcxz3yWNhgB3 xmSA== X-Gm-Message-State: APjAAAX11VJ+5JrYvWb0XyycpJ5uo0ur94v3KByG+RSV79ASS/f1n3qK aSk/cFApifn/IDkOXg7yEqFEwwtuKQCMlQ== X-Google-Smtp-Source: APXvYqzWi+DUv9cZ9OMFU0xHUHpQLlUIQPQApqXCo+Cgz2+1/BqmBqrBUL/PJBt2kPengmGXcA4t4w== X-Received: by 2002:a17:902:bd06:: with SMTP id p6mr12487987pls.27.1578891468802; Sun, 12 Jan 2020 20:57:48 -0800 (PST) From: Coiby Xu To: qemu-devel@nongnu.org Subject: [PATCH v1 2/5] extend libvhost to support IOThread Date: Mon, 13 Jan 2020 12:57:01 +0800 Message-Id: <20200113045704.12318-3-coiby.xu@gmail.com> X-Mailer: git-send-email 2.24.1 In-Reply-To: <20200113045704.12318-1-coiby.xu@gmail.com> References: <20200113045704.12318-1-coiby.xu@gmail.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-detected-operating-system: by eggs.gnu.org: Genre and OS details not recognized. X-Received-From: 2607:f8b0:4864:20::642 X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: kwolf@redhat.com, bharatlkmlkvm@gmail.com, Coiby Xu , stefanha@redhat.com Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: fail (Header signature does not verify) Content-Type: text/plain; charset="utf-8" Previously libvhost dispatch events in its own GMainContext. Now vhost-user= client's kick event can be dispatched in block device drive's AioContext t= hus IOThread is supported. Signed-off-by: Coiby Xu --- contrib/libvhost-user/libvhost-user.c | 64 ++++++++++++++++++++++----- contrib/libvhost-user/libvhost-user.h | 36 ++++++++++++++- 2 files changed, 87 insertions(+), 13 deletions(-) diff --git a/contrib/libvhost-user/libvhost-user.c b/contrib/libvhost-user/= libvhost-user.c index ec27b78ff1..cd328c1509 100644 --- a/contrib/libvhost-user/libvhost-user.c +++ b/contrib/libvhost-user/libvhost-user.c @@ -67,7 +67,6 @@ /* The version of inflight buffer */ #define INFLIGHT_VERSION 1 -#define VHOST_USER_HDR_SIZE offsetof(VhostUserMsg, payload.u64) /* The version of the protocol we support */ #define VHOST_USER_VERSION 1 @@ -260,7 +259,7 @@ have_userfault(void) } static bool -vu_message_read(VuDev *dev, int conn_fd, VhostUserMsg *vmsg) +vu_message_read_(VuDev *dev, int conn_fd, VhostUserMsg *vmsg) { char control[CMSG_SPACE(VHOST_MEMORY_MAX_NREGIONS * sizeof(int))] =3D = { }; struct iovec iov =3D { @@ -286,6 +285,8 @@ vu_message_read(VuDev *dev, int conn_fd, VhostUserMsg *= vmsg) return false; } + assert(rc =3D=3D VHOST_USER_HDR_SIZE || rc =3D=3D 0); + vmsg->fd_num =3D 0; for (cmsg =3D CMSG_FIRSTHDR(&msg); cmsg !=3D NULL; @@ -328,6 +329,17 @@ fail: return false; } +static bool vu_message_read(VuDev *dev, int conn_fd, VhostUserMsg *vmsg) +{ + vu_read_msg_cb read_msg; + if (dev->iface->read_msg) { + read_msg =3D dev->iface->read_msg; + } else { + read_msg =3D vu_message_read_; + } + return read_msg(dev, conn_fd, vmsg); +} + static bool vu_message_write(VuDev *dev, int conn_fd, VhostUserMsg *vmsg) { @@ -400,7 +412,6 @@ vu_process_message_reply(VuDev *dev, const VhostUserMsg= *vmsg) if ((vmsg->flags & VHOST_USER_NEED_REPLY_MASK) =3D=3D 0) { return true; } - if (!vu_message_read(dev, dev->slave_fd, &msg_reply)) { return false; } @@ -644,7 +655,8 @@ vu_set_mem_table_exec_postcopy(VuDev *dev, VhostUserMsg= *vmsg) "%s: Failed to madvise(DONTNEED) region %d: %s\n", __func__, i, strerror(errno)); } - /* Turn off transparent hugepages so we dont get lose wakeups + /* + * Turn off transparent hugepages so we don't get lose wakeups * in neighbouring pages. * TODO: Turn this backon later. */ @@ -1047,9 +1059,13 @@ vu_set_vring_kick_exec(VuDev *dev, VhostUserMsg *vms= g) } if (dev->vq[index].kick_fd !=3D -1 && dev->vq[index].handler) { - dev->set_watch(dev, dev->vq[index].kick_fd, VU_WATCH_IN, - vu_kick_cb, (void *)(long)index); - + if (dev->set_watch_packed_data) { + dev->set_watch_packed_data(dev, dev->vq[index].kick_fd, VU_WAT= CH_IN, + dev->iface->kick_callback, (void *)(long)index); + } else { + dev->set_watch(dev, dev->vq[index].kick_fd, VU_WATCH_IN, + vu_kick_cb, (void *)(long)index); + } DPRINT("Waiting for kicks on fd: %d for vq: %d\n", dev->vq[index].kick_fd, index); } @@ -1069,8 +1085,13 @@ void vu_set_queue_handler(VuDev *dev, VuVirtq *vq, vq->handler =3D handler; if (vq->kick_fd >=3D 0) { if (handler) { - dev->set_watch(dev, vq->kick_fd, VU_WATCH_IN, - vu_kick_cb, (void *)(long)qidx); + if (dev->set_watch_packed_data) { + dev->set_watch_packed_data(dev, vq->kick_fd, VU_WATCH_IN, + dev->iface->kick_callback, (void *)(long)qidx); + } else { + dev->set_watch(dev, vq->kick_fd, VU_WATCH_IN, + vu_kick_cb, (void *)(long)qidx); + } } else { dev->remove_watch(dev, vq->kick_fd); } @@ -1596,6 +1617,12 @@ vu_deinit(VuDev *dev) } if (vq->kick_fd !=3D -1) { + /* remove watch for kick_fd + * When client process is running in gdb and + * quit command is run in gdb, QEMU will still dispatch the ev= ent + * which will cause segment fault in the callback function + */ + dev->remove_watch(dev, vq->kick_fd); close(vq->kick_fd); vq->kick_fd =3D -1; } @@ -1647,10 +1674,9 @@ vu_init(VuDev *dev, const VuDevIface *iface) { uint16_t i; - assert(max_queues > 0); assert(socket >=3D 0); - assert(set_watch); + /* assert(set_watch); */ assert(remove_watch); assert(iface); assert(panic); @@ -1682,6 +1708,22 @@ vu_init(VuDev *dev, return true; } +bool +vu_init_packed_data(VuDev *dev, + uint16_t max_queues, + int socket, + vu_panic_cb panic, + vu_set_watch_cb_packed_data set_watch_packed_data, + vu_remove_watch_cb remove_watch, + const VuDevIface *iface) +{ + if (vu_init(dev, max_queues, socket, panic, NULL, remove_watch, iface)= ) { + dev->set_watch_packed_data =3D set_watch_packed_data; + return true; + } + return false; +} + VuVirtq * vu_get_queue(VuDev *dev, int qidx) { diff --git a/contrib/libvhost-user/libvhost-user.h b/contrib/libvhost-user/= libvhost-user.h index 46b600799b..5230d55092 100644 --- a/contrib/libvhost-user/libvhost-user.h +++ b/contrib/libvhost-user/libvhost-user.h @@ -34,6 +34,9 @@ typedef enum VhostSetConfigType { VHOST_SET_CONFIG_TYPE_MIGRATION =3D 1, } VhostSetConfigType; + +#define VHOST_USER_HDR_SIZE offsetof(VhostUserMsg, payload.u64) + /* * Maximum size of virtio device config space */ @@ -200,6 +203,7 @@ typedef uint64_t (*vu_get_features_cb) (VuDev *dev); typedef void (*vu_set_features_cb) (VuDev *dev, uint64_t features); typedef int (*vu_process_msg_cb) (VuDev *dev, VhostUserMsg *vmsg, int *do_reply); +typedef bool (*vu_read_msg_cb) (VuDev *dev, int sock, VhostUserMsg *vmsg); typedef void (*vu_queue_set_started_cb) (VuDev *dev, int qidx, bool starte= d); typedef bool (*vu_queue_is_processed_in_order_cb) (VuDev *dev, int qidx); typedef int (*vu_get_config_cb) (VuDev *dev, uint8_t *config, uint32_t len= ); @@ -207,6 +211,15 @@ typedef int (*vu_set_config_cb) (VuDev *dev, const uin= t8_t *data, uint32_t offset, uint32_t size, uint32_t flags); +typedef struct vu_watch_cb_data { + long index; + VuDev *vu_dev; +} vu_watch_cb_data; +typedef void (*vu_watch_cb_packed_data) (void *packed_data); + +typedef void (*vu_set_watch_cb_packed_data) (VuDev *dev, int fd, int condi= tion, + vu_watch_cb_packed_data cb, void *data); + typedef struct VuDevIface { /* called by VHOST_USER_GET_FEATURES to get the features bitmask */ vu_get_features_cb get_features; @@ -220,8 +233,11 @@ typedef struct VuDevIface { /* process_msg is called for each vhost-user message received */ /* skip libvhost-user processing if return value !=3D 0 */ vu_process_msg_cb process_msg; + vu_read_msg_cb read_msg; + vu_watch_cb_packed_data kick_callback; /* tells when queues can be processed */ vu_queue_set_started_cb queue_set_started; + /* * If the queue is processed in order, in which case it will be * resumed to vring.used->idx. This can help to support resuming @@ -366,7 +382,8 @@ struct VuDev { /* @set_watch: add or update the given fd to the watch set, * call cb when condition is met */ vu_set_watch_cb set_watch; - + /* AIO dispatch will only one data pointer to callback function */ + vu_set_watch_cb_packed_data set_watch_packed_data; /* @remove_watch: remove the given fd from the watch set */ vu_remove_watch_cb remove_watch; @@ -398,7 +415,7 @@ typedef struct VuVirtqElement { * @remove_watch: a remove_watch callback * @iface: a VuDevIface structure with vhost-user device callbacks * - * Intializes a VuDev vhost-user context. + * Initializes a VuDev vhost-user context. * * Returns: true on success, false on failure. **/ @@ -411,6 +428,21 @@ bool vu_init(VuDev *dev, const VuDevIface *iface); +/** + * vu_init_packed_data: + * Same as vu_init except for set_watch_packed_data which will pack + * two parameters into a struct thus QEMU aio_dispatch can pass the + * required data to callback function. + * + * Returns: true on success, false on failure. + **/ +bool vu_init_packed_data(VuDev *dev, + uint16_t max_queues, + int socket, + vu_panic_cb panic, + vu_set_watch_cb_packed_data set_watch_packed_data, + vu_remove_watch_cb remove_watch, + const VuDevIface *iface); /** * vu_deinit: * @dev: a VuDev context -- 2.24.1 From nobody Thu Mar 28 14:44:16 2024 Delivered-To: importer@patchew.org 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; Authentication-Results: mx.zohomail.com; dkim=fail; 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=fail(p=none dis=none) header.from=gmail.com ARC-Seal: i=1; a=rsa-sha256; t=1578891581; cv=none; d=zohomail.com; s=zohoarc; b=mM55A2eg1AeswvruxE4ty16yYBgBKFd/JuZJPW1SOLqE3CO+OsfxpnrTuNnxra0jzFcFsAKPJA9DKB1c4f392xV7gNA+uGXsV4k/VJgiTyeu1ze23LlOV33W/jFaFh9LwSOd9TrVZBHe8q6T5+WhTlaQiZxegkZE+yNxT/aNIa4= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1578891581; h=Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=+o2xLjvifsgfa/4owhRKctXKFUi1fuVO/+UjjYkEsiY=; b=RkPyLHQW8GRGroBB0CBCUY9/23z0woTAmY0cx04xduQxUAtOTOX3y9ygpRqahNIBnb3tmDRqAugd8VO1KkuIzJDeXKJSszh1i57XMEkPCarmF5QotlQbo2qiaw7GtWfqo7rOHnDrJkG5369DIg3vZKMqKwpYVCF6DEMr0pRwVa8= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=fail; 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=fail header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1578891581418155.22517012289347; Sun, 12 Jan 2020 20:59:41 -0800 (PST) Received: from localhost ([::1]:45648 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1iqrpE-00019k-1y for importer@patchew.org; Sun, 12 Jan 2020 23:59:40 -0500 Received: from eggs.gnu.org ([2001:470:142:3::10]:42176) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1iqrnY-0007XG-Vv for qemu-devel@nongnu.org; Sun, 12 Jan 2020 23:57:58 -0500 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1iqrnX-0006sN-82 for qemu-devel@nongnu.org; Sun, 12 Jan 2020 23:57:56 -0500 Received: from mail-pf1-x444.google.com ([2607:f8b0:4864:20::444]:34029) by eggs.gnu.org with esmtps (TLS1.0:RSA_AES_128_CBC_SHA1:16) (Exim 4.71) (envelope-from ) id 1iqrnX-0006qs-05 for qemu-devel@nongnu.org; Sun, 12 Jan 2020 23:57:55 -0500 Received: by mail-pf1-x444.google.com with SMTP id i6so4273058pfc.1 for ; Sun, 12 Jan 2020 20:57:54 -0800 (PST) Received: from localhost.localdomain ([175.124.145.172]) by smtp.googlemail.com with ESMTPSA id o19sm17590552pjr.2.2020.01.12.20.57.49 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 12 Jan 2020 20:57:53 -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 :mime-version:content-transfer-encoding; bh=+o2xLjvifsgfa/4owhRKctXKFUi1fuVO/+UjjYkEsiY=; b=I0UZFnJqegXav2bnw9MIO4RW31ZzUBCjzh9aK4Rgr10kJKhqYqRLRRZDwRpNDdUj5g sJkC4xoCfWTfE03Or58bvIdPO8cc0s4SY9wzr2sKHq5lAZ9j2s3px4SkKrEbkdz9P9zJ zYMsw/t2plVoA8QOcurvNmZyIEFYQLltzXSh4/xS7+M0+fYLsoIqbLBoCGX/2NRApYjf w9cYwpOZZvwhahTnD5bRLXjm4WzGJbQBryNxrb5V4nfrtHx7dndrUEtshpIT4DFrybLZ fFS8ZR+WaEAP1i4b7UaHiuBpdvBptYjGpgrPYdUt3LgCsoCINjKP2COF1ZcFSOToBgkR YR0Q== 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:mime-version:content-transfer-encoding; bh=+o2xLjvifsgfa/4owhRKctXKFUi1fuVO/+UjjYkEsiY=; b=A7mC4xvYmTGQfIIAPdaEldiul0AV/Iejz13I9ZOrRrrJtleiseCIO5+FpvlPIqBa/R T/m8nLuIgjjlhlc6uy9Q2297yK7HjlShA+hgTsbPkwpT+zUA0MrueknRC0MEUmq/63pr R/lFolY2ePVNPHVdGzHTCjA+NA6VoAf8bE5Pd2ElJ8q6anur0jNFcCa4U/WAU36jO9Cg QqMlXX2E6udnHrJzREYQabSwe0woLo6u3mmqE+KJ+93leEraJO0Ek25DGyBLSZlOvNXf wjK65Law4DySKIBvxwwdFInROxitQRuDM6Rwq7mrcVOgoawWgi6pWHrtlzvIBloDo3FJ gptA== X-Gm-Message-State: APjAAAXXI8lD+rruCZ0XmSodmPqTCHwIkcC9esepp5m07L/LP2FBbpHO FeIIiOCOXw5MgBnWfhPybmbuNUhBR4TW+g== X-Google-Smtp-Source: APXvYqwkyoQMSCwLOPFFsJaqTEHD5/9txZbEFiyYeTUo3Jct3f7UAq9IMJppO/TmIkXmeTy9aQ7YEA== X-Received: by 2002:a62:14c4:: with SMTP id 187mr17652681pfu.96.1578891473600; Sun, 12 Jan 2020 20:57:53 -0800 (PST) From: Coiby Xu To: qemu-devel@nongnu.org Subject: [PATCH v1 3/5] a standone-alone tool to directly share disk image file via vhost-user protocol Date: Mon, 13 Jan 2020 12:57:02 +0800 Message-Id: <20200113045704.12318-4-coiby.xu@gmail.com> X-Mailer: git-send-email 2.24.1 In-Reply-To: <20200113045704.12318-1-coiby.xu@gmail.com> References: <20200113045704.12318-1-coiby.xu@gmail.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-detected-operating-system: by eggs.gnu.org: Genre and OS details not recognized. X-Received-From: 2607:f8b0:4864:20::444 X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: kwolf@redhat.com, bharatlkmlkvm@gmail.com, Coiby Xu , stefanha@redhat.com Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: fail (Header signature does not verify) Content-Type: text/plain; charset="utf-8" vhost-user-blk can have played as vhost-user backend but it only supports r= aw file and don't support VIRTIO_BLK_T_DISCARD and VIRTIO_BLK_T_WRITE_ZEROE= S operations on raw file (ioctl(fd, BLKDISCARD) is only valid for real bloc= k device). Signed-off-by: Coiby Xu --- qemu-vu.c | 264 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 264 insertions(+) create mode 100644 qemu-vu.c diff --git a/qemu-vu.c b/qemu-vu.c new file mode 100644 index 0000000000..25c32c2c6d --- /dev/null +++ b/qemu-vu.c @@ -0,0 +1,264 @@ +/* + * Copyright (C) 2020 Coiby Xu + * + * Vhost-user-blk device backend + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; under version 2 of the License. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see . + */ + +#include "qemu/osdep.h" +#include +#include +#include "block/vhost-user.h" +#include "qemu-common.h" +#include "qapi/error.h" +#include "qemu/cutils.h" +#include "sysemu/block-backend.h" +#include "block/block_int.h" +#include "qemu/main-loop.h" +#include "qemu/module.h" +#include "qemu/option.h" +#include "qemu/error-report.h" +#include "qapi/qmp/qdict.h" +#include "qapi/qmp/qstring.h" +#include "qom/object_interfaces.h" +#include "io/net-listener.h" +#include "qemu-version.h" + +#define QEMU_VU_OPT_CACHE 256 + +#define QEMU_VU_OPT_AIO 257 + +static char *srcpath; + +static void usage(const char *name) +{ + (printf) ( +"Usage: %s [OPTIONS] FILE\n" +" or: %s -L [OPTIONS]\n" +"QEMU Vhost-user Server Utility\n" +"\n" +" -h, --help display this help and exit\n" +" -V, --version output version information and exit\n" +"\n" +"Connection properties:\n" +" -k, --socket=3DPATH path to the unix socket\n" +"\n" +"General purpose options:\n" +" -e, -- exit-panic When the panic callback is called, the progra= m\n" +" will exit. Useful for make check-qtest.\n" +"\n" +"Block device options:\n" +" -f, --format=3DFORMAT set image format (raw, qcow2, ...)\n" +" -r, --read-only export read-only\n" +" -n, --nocache disable host cache\n" +" --cache=3DMODE set cache mode (none, writeback, ...)\n" +" --aio=3DMODE set AIO mode (native or threads)\n" +"\n" +QEMU_HELP_BOTTOM "\n" + , name, name); +} + +static void version(const char *name) +{ + printf( +"%s " QEMU_FULL_VERSION "\n" +"Written by Coiby Xu, based on qemu-nbd by Anthony Liguori\n" +"\n" +QEMU_COPYRIGHT "\n" +"This is free software; see the source for copying conditions. There is N= O\n" +"warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOS= E.\n" + , name); +} + +static VubDev *vub_device; + +static void vus_shutdown(void) +{ + job_cancel_sync_all(); + bdrv_close_all(); + vub_free(vub_device, false); +} + +int main(int argc, char **argv) +{ + BlockBackend *blk; + BlockDriverState *bs; + bool readonly =3D false; + char *sockpath =3D NULL; + int64_t fd_size; + const char *sopt =3D "hVrnvek:f:"; + struct option lopt[] =3D { + { "help", no_argument, NULL, 'h' }, + { "version", no_argument, NULL, 'V' }, + { "exit-panic", no_argument, NULL, 'e' }, + { "socket", required_argument, NULL, 'k' }, + { "read-only", no_argument, NULL, 'r' }, + { "nocache", no_argument, NULL, 'n' }, + { "cache", required_argument, NULL, QEMU_VU_OPT_CACHE }, + { "aio", required_argument, NULL, QEMU_VU_OPT_AIO }, + { "format", required_argument, NULL, 'f' }, + { NULL, 0, NULL, 0 } + }; + int ch; + int opt_ind =3D 0; + int flags =3D BDRV_O_RDWR; + bool seen_cache =3D false; + bool seen_aio =3D false; + const char *fmt =3D NULL; + Error *local_err =3D NULL; + QDict *options =3D NULL; + bool writethrough =3D true; + bool exit_panic =3D false; + + error_init(argv[0]); + + module_call_init(MODULE_INIT_QOM); + qemu_init_exec_dir(argv[0]); + + while ((ch =3D getopt_long(argc, argv, sopt, lopt, &opt_ind)) !=3D -1)= { + switch (ch) { + case 'e': + exit_panic =3D true; + break; + case 'n': + optarg =3D (char *) "none"; + /* fallthrough */ + case QEMU_VU_OPT_CACHE: + if (seen_cache) { + error_report("-n and --cache can only be specified once"); + exit(EXIT_FAILURE); + } + seen_cache =3D true; + if (bdrv_parse_cache_mode(optarg, &flags, &writethrough) =3D= =3D -1) { + error_report("Invalid cache mode `%s'", optarg); + exit(EXIT_FAILURE); + } + break; + case QEMU_VU_OPT_AIO: + if (seen_aio) { + error_report("--aio can only be specified once"); + exit(EXIT_FAILURE); + } + seen_aio =3D true; + if (!strcmp(optarg, "native")) { + flags |=3D BDRV_O_NATIVE_AIO; + } else if (!strcmp(optarg, "threads")) { + /* this is the default */ + } else { + error_report("invalid aio mode `%s'", optarg); + exit(EXIT_FAILURE); + } + break; + case 'r': + readonly =3D true; + flags &=3D ~BDRV_O_RDWR; + break; + case 'k': + sockpath =3D optarg; + if (sockpath[0] !=3D '/') { + error_report("socket path must be absolute"); + exit(EXIT_FAILURE); + } + break; + case 'f': + fmt =3D optarg; + break; + case 'V': + version(argv[0]); + exit(0); + break; + case 'h': + usage(argv[0]); + exit(0); + break; + case '?': + error_report("Try `%s --help' for more information.", argv[0]); + exit(EXIT_FAILURE); + } + } + + if ((argc - optind) !=3D 1) { + error_report("Invalid number of arguments"); + error_printf("Try `%s --help' for more information.\n", argv[0]); + exit(EXIT_FAILURE); + } + + if (qemu_init_main_loop(&local_err)) { + error_report_err(local_err); + exit(EXIT_FAILURE); + } + bdrv_init(); + + srcpath =3D argv[optind]; + if (fmt) { + options =3D qdict_new(); + qdict_put_str(options, "driver", fmt); + } + blk =3D blk_new_open(srcpath, NULL, options, flags, &local_err); + + if (!blk) { + error_reportf_err(local_err, "Failed to blk_new_open '%s': ", + argv[optind]); + exit(EXIT_FAILURE); + } + bs =3D blk_bs(blk); + + blk_set_enable_write_cache(blk, !writethrough); + + fd_size =3D blk_getlength(blk); + if (fd_size < 0) { + error_report("Failed to determine the image length: %s", + strerror(-fd_size)); + exit(EXIT_FAILURE); + } + + AioContext *ctx =3D bdrv_get_aio_context(bs); + bdrv_invalidate_cache(bs, NULL); + + vub_device =3D g_new0(VubDev, 1); + vub_device->unix_socket =3D g_strdup(sockpath); + vub_device->writable =3D !readonly; + vub_device->blkcfg.wce =3D !writethrough; + vub_device->backend =3D blk; + vub_device->ctx =3D ctx; + vub_initialize_config(bs, &vub_device->blkcfg); + vub_device->listener =3D qio_net_listener_new(); + vub_device->exit_panic =3D exit_panic; + + qio_net_listener_set_name(vub_device->listener, + "vhost-user-backend-listener"); + + SocketAddress *addr =3D g_new0(SocketAddress, 1); + addr->u.q_unix.path =3D (char *) sockpath; + addr->type =3D SOCKET_ADDRESS_TYPE_UNIX; + Error **errp =3D NULL; + if (qio_net_listener_open_sync(vub_device->listener, addr, 1, errp) < = 0) { + goto error; + } + + qio_net_listener_set_client_func(vub_device->listener, + vub_accept, + vub_device, + NULL); + + QTAILQ_INIT(&vub_device->clients); + + do { + main_loop_wait(false); + } while (!vub_device->exit_panic || !vub_device->close); + + error: + vus_shutdown(); + exit(EXIT_SUCCESS); +} -- 2.24.1 From nobody Thu Mar 28 14:44:16 2024 Delivered-To: importer@patchew.org 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; Authentication-Results: mx.zohomail.com; dkim=fail; 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=fail(p=none dis=none) header.from=gmail.com ARC-Seal: i=1; a=rsa-sha256; t=1578891774; cv=none; d=zohomail.com; s=zohoarc; b=Uw1L+Y5pEhmeZLtpl1E/ud1mjVS31oAioQG21fKJDlO5N9ojn3591w7W0nFPFkpLh4WjchaIYbpuGRMqrOvdxAKTlfboZd2qoWvXcDZbC5a7rn0xUuLH+kQ93F5jkhzCQBGow2yS7+KezTxDH3T6/lFPln9wf8ZRdqSBo6ZvJEs= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1578891774; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=FDXlkBcLpLf9BJh9up3G3wY7P/raOIBTXkdtxoet+D8=; b=IUL3PwZufJek9UBT4b0X4AOvv1mgMI3C1Pels2qFAlunsNKKcQBdQxyXcVzBrttMjOjamW45Cxc0x5VyGj6hpRz5qz1K6y4O8N8FzoJHdbjpTQNTeu6XArygfkSAEq0RbZvBRFjBiCEGPx2ldJn8LRP2wO+slRpyPtQy4onvLIQ= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=fail; 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=fail header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1578891774271154.81358681744575; Sun, 12 Jan 2020 21:02:54 -0800 (PST) Received: from localhost ([::1]:45693 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1iqrsL-0004cK-5H for importer@patchew.org; Mon, 13 Jan 2020 00:02:53 -0500 Received: from eggs.gnu.org ([2001:470:142:3::10]:42240) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1iqrnf-0007lx-Gi for qemu-devel@nongnu.org; Sun, 12 Jan 2020 23:58:07 -0500 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1iqrnc-00073a-3r for qemu-devel@nongnu.org; Sun, 12 Jan 2020 23:58:03 -0500 Received: from mail-pj1-x1043.google.com ([2607:f8b0:4864:20::1043]:35584) by eggs.gnu.org with esmtps (TLS1.0:RSA_AES_128_CBC_SHA1:16) (Exim 4.71) (envelope-from ) id 1iqrnb-00071x-QD for qemu-devel@nongnu.org; Sun, 12 Jan 2020 23:58:00 -0500 Received: by mail-pj1-x1043.google.com with SMTP id s7so3739082pjc.0 for ; Sun, 12 Jan 2020 20:57:59 -0800 (PST) Received: from localhost.localdomain ([175.124.145.172]) by smtp.googlemail.com with ESMTPSA id o19sm17590552pjr.2.2020.01.12.20.57.54 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 12 Jan 2020 20:57:57 -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 :mime-version:content-transfer-encoding; bh=FDXlkBcLpLf9BJh9up3G3wY7P/raOIBTXkdtxoet+D8=; b=HMr7YYSkUWEHpEfZENPZ+1Sd80ztwS8zZDZOq8IM14gLFp2/r1HwEiwdcNSh+z0tTv WB4ePHUjzn8mv8D4r5LLwQ/wpgRh/Z3ZlEP77jeXvsG3hRZlIaFG5JbO1n5GE+TijXOW yYuk+Nj8y6+Gd86YQJk48unfR5lQL+Uw7oU7pxJ65TXx03AJjphz78WQIKivoHhYreES Qa7hjFzBlNaipAcTr7FLAvuVR9LMKIBCppR/WVTtEDlKRtb2Oy9j/qm6Gwxc8tnnFQX4 IadYRIqJGyUiBjWOfW7LqKpkV8ypINbP83LAYL9DajcyLtbZV5uGr4QpxEOLdflzLw1Z IidQ== 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:mime-version:content-transfer-encoding; bh=FDXlkBcLpLf9BJh9up3G3wY7P/raOIBTXkdtxoet+D8=; b=WyrhyM0i6zdpFiqbyCf1z8zL26uJ2dGg98OUWe4P3suCyHlKjRnk/uaqp1wOBxxrp2 qX7+SnwmvXjcj/FRQM81e/d9rAyNaSneVOqR1ZAuQovlDwsVYs+B3RpsUfKSZ25KkKB0 RvsvkpLHedAYhqKT/1K38RkEXLR2SXPSmSxcI+H5A3KfpEdjChcH6pB6AcwXqTvfdd+z jDz8GxzlHy66qHD4bqkIpTlssMIdU+LFAFLdAc6y04YV+/6l5O/xmu3ZhQnI+EQs+Wtn F4gMeAHN5MQnZjVS9KGhcFiZ9uqe6Q1267JaBWhI5G8tgbllKxEXEU69AOPeXwP3TDPq PD2w== X-Gm-Message-State: APjAAAVuxmbIeBuor576Nk6kIksipPgUErg7zFt+7PqFqyc+HnG1Bt4Y cYrVxdxG0hZLpLPuqvVA4iaxIcHiZ9K1Sg== X-Google-Smtp-Source: APXvYqzkif0OS1br4ORiI15pZ9MQxFMDqlpZYNcHNoAhHjVvvaX1cI8D6HfSWEW59eVJwyqXvbmARQ== X-Received: by 2002:a17:90a:fb45:: with SMTP id iq5mr20191013pjb.93.1578891478235; Sun, 12 Jan 2020 20:57:58 -0800 (PST) From: Coiby Xu To: qemu-devel@nongnu.org Subject: [PATCH v1 4/5] new qTest case for the vhost-user-blk device backend Date: Mon, 13 Jan 2020 12:57:03 +0800 Message-Id: <20200113045704.12318-5-coiby.xu@gmail.com> X-Mailer: git-send-email 2.24.1 In-Reply-To: <20200113045704.12318-1-coiby.xu@gmail.com> References: <20200113045704.12318-1-coiby.xu@gmail.com> MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable X-detected-operating-system: by eggs.gnu.org: Genre and OS details not recognized. X-Received-From: 2607:f8b0:4864:20::1043 X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: kwolf@redhat.com, bharatlkmlkvm@gmail.com, Coiby Xu , stefanha@redhat.com Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: fail (Header signature does not verify) This test case has the same tests as tests/virtio-blk-test.c except for tests have block_resize. Signed-off-by: Coiby Xu --- tests/libqos/vhost-user-blk.c | 125 ++++++ tests/libqos/vhost-user-blk.h | 44 +++ tests/vhost-user-blk-test.c | 691 ++++++++++++++++++++++++++++++++++ 3 files changed, 860 insertions(+) create mode 100644 tests/libqos/vhost-user-blk.c create mode 100644 tests/libqos/vhost-user-blk.h create mode 100644 tests/vhost-user-blk-test.c diff --git a/tests/libqos/vhost-user-blk.c b/tests/libqos/vhost-user-blk.c new file mode 100644 index 0000000000..1f8e6eec7e --- /dev/null +++ b/tests/libqos/vhost-user-blk.c @@ -0,0 +1,125 @@ +/* + * libqos driver framework + * + * Copyright (c) 2018 Emanuele Giuseppe Esposito + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2 as published by the Free Software Foundation. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see + */ + +#include "qemu/osdep.h" +#include "libqtest.h" +#include "qemu/module.h" +#include "standard-headers/linux/virtio_blk.h" +#include "libqos/qgraph.h" +#include "libqos/vhost-user-blk.h" + +#define PCI_SLOT 0x04 +#define PCI_FN 0x00 + +/* virtio-blk-device */ +static void *qvhost_user_blk_get_driver(QVhostUserBlk *v_blk, + const char *interface) +{ + if (!g_strcmp0(interface, "vhost-user-blk")) { + return v_blk; + } + if (!g_strcmp0(interface, "virtio")) { + return v_blk->vdev; + } + + fprintf(stderr, "%s not present in vhost-user-blk-device\n", interface= ); + g_assert_not_reached(); +} + +static void *qvhost_user_blk_device_get_driver(void *object, + const char *interface) +{ + QVhostUserBlkDevice *v_blk =3D object; + return qvhost_user_blk_get_driver(&v_blk->blk, interface); +} + +static void *vhost_user_blk_device_create(void *virtio_dev, + QGuestAllocator *t_alloc, + void *addr) +{ + QVhostUserBlkDevice *vhost_user_blk =3D g_new0(QVhostUserBlkDevice, 1); + QVhostUserBlk *interface =3D &vhost_user_blk->blk; + + interface->vdev =3D virtio_dev; + + vhost_user_blk->obj.get_driver =3D qvhost_user_blk_device_get_driver; + + return &vhost_user_blk->obj; +} + +/* virtio-blk-pci */ +static void *qvhost_user_blk_pci_get_driver(void *object, const char *inte= rface) +{ + QVhostUserBlkPCI *v_blk =3D object; + if (!g_strcmp0(interface, "pci-device")) { + return v_blk->pci_vdev.pdev; + } + return qvhost_user_blk_get_driver(&v_blk->blk, interface); +} + +static void *vhost_user_blk_pci_create(void *pci_bus, QGuestAllocator *t_a= lloc, + void *addr) +{ + QVhostUserBlkPCI *vhost_user_blk =3D g_new0(QVhostUserBlkPCI, 1); + QVhostUserBlk *interface =3D &vhost_user_blk->blk; + QOSGraphObject *obj =3D &vhost_user_blk->pci_vdev.obj; + + virtio_pci_init(&vhost_user_blk->pci_vdev, pci_bus, addr); + interface->vdev =3D &vhost_user_blk->pci_vdev.vdev; + + g_assert_cmphex(interface->vdev->device_type, =3D=3D, VIRTIO_ID_BLOCK); + + obj->get_driver =3D qvhost_user_blk_pci_get_driver; + + return obj; +} + +static void vhost_user_blk_register_nodes(void) +{ + /* FIXME: every test using these two nodes needs to setup a + * -drive,id=3Ddrive0 otherwise QEMU is not going to start. + * Therefore, we do not include "produces" edge for virtio + * and pci-device yet. + */ + + char *arg =3D g_strdup_printf("id=3Ddrv0,chardev=3Dchar1,addr=3D%x.%x", + PCI_SLOT, PCI_FN); + + QPCIAddress addr =3D { + .devfn =3D QPCI_DEVFN(PCI_SLOT, PCI_FN), + }; + + QOSGraphEdgeOptions opts =3D { }; + + /* virtio-blk-device */ + /** opts.extra_device_opts =3D "drive=3Ddrive0"; */ + qos_node_create_driver("vhost-user-blk-device", vhost_user_blk_device_= create); + qos_node_consumes("vhost-user-blk-device", "virtio-bus", &opts); + qos_node_produces("vhost-user-blk-device", "vhost-user-blk"); + + /* virtio-blk-pci */ + opts.extra_device_opts =3D arg; + add_qpci_address(&opts, &addr); + qos_node_create_driver("vhost-user-blk-pci", vhost_user_blk_pci_create= ); + qos_node_consumes("vhost-user-blk-pci", "pci-bus", &opts); + qos_node_produces("vhost-user-blk-pci", "vhost-user-blk"); + + g_free(arg); +} + +libqos_init(vhost_user_blk_register_nodes); diff --git a/tests/libqos/vhost-user-blk.h b/tests/libqos/vhost-user-blk.h new file mode 100644 index 0000000000..ef4ef09cca --- /dev/null +++ b/tests/libqos/vhost-user-blk.h @@ -0,0 +1,44 @@ +/* + * libqos driver framework + * + * Copyright (c) 2018 Emanuele Giuseppe Esposito + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2 as published by the Free Software Foundation. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see + */ + +#ifndef TESTS_LIBQOS_VHOST_USER_BLK_H +#define TESTS_LIBQOS_VHOST_USER_BLK_H + +#include "libqos/qgraph.h" +#include "libqos/virtio.h" +#include "libqos/virtio-pci.h" + +typedef struct QVhostUserBlk QVhostUserBlk; +typedef struct QVhostUserBlkPCI QVhostUserBlkPCI; +typedef struct QVhostUserBlkDevice QVhostUserBlkDevice; + +struct QVhostUserBlk { + QVirtioDevice *vdev; +}; + +struct QVhostUserBlkPCI { + QVirtioPCIDevice pci_vdev; + QVhostUserBlk blk; +}; + +struct QVhostUserBlkDevice { + QOSGraphObject obj; + QVhostUserBlk blk; +}; + +#endif diff --git a/tests/vhost-user-blk-test.c b/tests/vhost-user-blk-test.c new file mode 100644 index 0000000000..d54769dd7f --- /dev/null +++ b/tests/vhost-user-blk-test.c @@ -0,0 +1,691 @@ +/* + * QTest testcase for VirtIO Block Device + * + * Copyright (c) 2014 SUSE LINUX Products GmbH + * Copyright (c) 2014 Marc Mar=C3=AD + * + * This work is licensed under the terms of the GNU GPL, version 2 or late= r. + * See the COPYING file in the top-level directory. + */ + +#include "qemu/osdep.h" +#include "libqtest-single.h" +#include "qemu/bswap.h" +#include "qemu/module.h" +#include "standard-headers/linux/virtio_blk.h" +#include "standard-headers/linux/virtio_pci.h" +#include "libqos/qgraph.h" +#include "libqos/vhost-user-blk.h" +#include "libqos/libqos-pc.h" + +/* TODO actually test the results and get rid of this */ +#define qmp_discard_response(...) qobject_unref(qmp(__VA_ARGS__)) + +#define TEST_IMAGE_SIZE (64 * 1024 * 1024) +#define QVIRTIO_BLK_TIMEOUT_US (30 * 1000 * 1000) +#define PCI_SLOT_HP 0x06 + +typedef struct QVirtioBlkReq { + uint32_t type; + uint32_t ioprio; + uint64_t sector; + char *data; + uint8_t status; +} QVirtioBlkReq; + + +#ifdef HOST_WORDS_BIGENDIAN +static const bool host_is_big_endian =3D true; +#else +static const bool host_is_big_endian; /* false */ +#endif + +static inline void virtio_blk_fix_request(QVirtioDevice *d, QVirtioBlkReq = *req) +{ + if (qvirtio_is_big_endian(d) !=3D host_is_big_endian) { + req->type =3D bswap32(req->type); + req->ioprio =3D bswap32(req->ioprio); + req->sector =3D bswap64(req->sector); + } +} + + +static inline void virtio_blk_fix_dwz_hdr(QVirtioDevice *d, + struct virtio_blk_discard_write_zeroes *dwz_hdr) +{ + if (qvirtio_is_big_endian(d) !=3D host_is_big_endian) { + dwz_hdr->sector =3D bswap64(dwz_hdr->sector); + dwz_hdr->num_sectors =3D bswap32(dwz_hdr->num_sectors); + dwz_hdr->flags =3D bswap32(dwz_hdr->flags); + } +} + +static uint64_t virtio_blk_request(QGuestAllocator *alloc, QVirtioDevice *= d, + QVirtioBlkReq *req, uint64_t data_size) +{ + uint64_t addr; + uint8_t status =3D 0xFF; + + switch (req->type) { + case VIRTIO_BLK_T_IN: + case VIRTIO_BLK_T_OUT: + g_assert_cmpuint(data_size % 512, =3D=3D, 0); + break; + case VIRTIO_BLK_T_DISCARD: + case VIRTIO_BLK_T_WRITE_ZEROES: + g_assert_cmpuint(data_size % + sizeof(struct virtio_blk_discard_write_zeroes), = =3D=3D, 0); + break; + default: + g_assert_cmpuint(data_size, =3D=3D, 0); + } + + addr =3D guest_alloc(alloc, sizeof(*req) + data_size); + + virtio_blk_fix_request(d, req); + + memwrite(addr, req, 16); + memwrite(addr + 16, req->data, data_size); + memwrite(addr + 16 + data_size, &status, sizeof(status)); + + return addr; +} + +/* Returns the request virtqueue so the caller can perform further tests */ +static QVirtQueue *test_basic(QVirtioDevice *dev, QGuestAllocator *alloc) +{ + QVirtioBlkReq req; + uint64_t req_addr; + uint64_t capacity; + uint64_t features; + uint32_t free_head; + uint8_t status; + char *data; + QTestState *qts =3D global_qtest; + QVirtQueue *vq; + + features =3D qvirtio_get_features(dev); + features =3D features & ~(QVIRTIO_F_BAD_FEATURE | + (1u << VIRTIO_RING_F_INDIRECT_DESC) | + (1u << VIRTIO_RING_F_EVENT_IDX) | + (1u << VIRTIO_BLK_F_SCSI)); + qvirtio_set_features(dev, features); + + capacity =3D qvirtio_config_readq(dev, 0); + g_assert_cmpint(capacity, =3D=3D, TEST_IMAGE_SIZE / 512); + + vq =3D qvirtqueue_setup(dev, alloc, 0); + + qvirtio_set_driver_ok(dev); + + /* Write and read with 3 descriptor layout */ + /* Write request */ + req.type =3D VIRTIO_BLK_T_OUT; + req.ioprio =3D 1; + req.sector =3D 0; + req.data =3D g_malloc0(512); + strcpy(req.data, "TEST"); + + req_addr =3D virtio_blk_request(alloc, dev, &req, 512); + + g_free(req.data); + + free_head =3D qvirtqueue_add(qts, vq, req_addr, 16, false, true); + qvirtqueue_add(qts, vq, req_addr + 16, 512, false, true); + qvirtqueue_add(qts, vq, req_addr + 528, 1, true, false); + + qvirtqueue_kick(qts, dev, vq, free_head); + + qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL, + QVIRTIO_BLK_TIMEOUT_US); + status =3D readb(req_addr + 528); + g_assert_cmpint(status, =3D=3D, 0); + + guest_free(alloc, req_addr); + + /* Read request */ + req.type =3D VIRTIO_BLK_T_IN; + req.ioprio =3D 1; + req.sector =3D 0; + req.data =3D g_malloc0(512); + + req_addr =3D virtio_blk_request(alloc, dev, &req, 512); + + g_free(req.data); + + free_head =3D qvirtqueue_add(qts, vq, req_addr, 16, false, true); + qvirtqueue_add(qts, vq, req_addr + 16, 512, true, true); + qvirtqueue_add(qts, vq, req_addr + 528, 1, true, false); + + qvirtqueue_kick(qts, dev, vq, free_head); + + qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL, + QVIRTIO_BLK_TIMEOUT_US); + status =3D readb(req_addr + 528); + g_assert_cmpint(status, =3D=3D, 0); + + data =3D g_malloc0(512); + memread(req_addr + 16, data, 512); + g_assert_cmpstr(data, =3D=3D, "TEST"); + g_free(data); + + guest_free(alloc, req_addr); + + if (features & (1u << VIRTIO_BLK_F_WRITE_ZEROES)) { + struct virtio_blk_discard_write_zeroes dwz_hdr; + void *expected; + + /* + * WRITE_ZEROES request on the same sector of previous test where + * we wrote "TEST". + */ + req.type =3D VIRTIO_BLK_T_WRITE_ZEROES; + req.data =3D (char *) &dwz_hdr; + dwz_hdr.sector =3D 0; + dwz_hdr.num_sectors =3D 1; + dwz_hdr.flags =3D 0; + + virtio_blk_fix_dwz_hdr(dev, &dwz_hdr); + + req_addr =3D virtio_blk_request(alloc, dev, &req, sizeof(dwz_hdr)); + + free_head =3D qvirtqueue_add(qts, vq, req_addr, 16, false, true); + qvirtqueue_add(qts, vq, req_addr + 16, sizeof(dwz_hdr), false, tru= e); + qvirtqueue_add(qts, vq, req_addr + 16 + sizeof(dwz_hdr), 1, true, + false); + + qvirtqueue_kick(qts, dev, vq, free_head); + + qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL, + QVIRTIO_BLK_TIMEOUT_US); + status =3D readb(req_addr + 16 + sizeof(dwz_hdr)); + g_assert_cmpint(status, =3D=3D, 0); + + guest_free(alloc, req_addr); + + /* Read request to check if the sector contains all zeroes */ + req.type =3D VIRTIO_BLK_T_IN; + req.ioprio =3D 1; + req.sector =3D 0; + req.data =3D g_malloc0(512); + + req_addr =3D virtio_blk_request(alloc, dev, &req, 512); + + g_free(req.data); + + free_head =3D qvirtqueue_add(qts, vq, req_addr, 16, false, true); + qvirtqueue_add(qts, vq, req_addr + 16, 512, true, true); + qvirtqueue_add(qts, vq, req_addr + 528, 1, true, false); + + qvirtqueue_kick(qts, dev, vq, free_head); + + qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL, + QVIRTIO_BLK_TIMEOUT_US); + status =3D readb(req_addr + 528); + g_assert_cmpint(status, =3D=3D, 0); + + data =3D g_malloc(512); + expected =3D g_malloc0(512); + memread(req_addr + 16, data, 512); + g_assert_cmpmem(data, 512, expected, 512); + g_free(expected); + g_free(data); + + guest_free(alloc, req_addr); + } + + if (features & (1u << VIRTIO_BLK_F_DISCARD)) { + struct virtio_blk_discard_write_zeroes dwz_hdr; + + req.type =3D VIRTIO_BLK_T_DISCARD; + req.data =3D (char *) &dwz_hdr; + dwz_hdr.sector =3D 0; + dwz_hdr.num_sectors =3D 1; + dwz_hdr.flags =3D 0; + + virtio_blk_fix_dwz_hdr(dev, &dwz_hdr); + + req_addr =3D virtio_blk_request(alloc, dev, &req, sizeof(dwz_hdr)); + + free_head =3D qvirtqueue_add(qts, vq, req_addr, 16, false, true); + qvirtqueue_add(qts, vq, req_addr + 16, sizeof(dwz_hdr), false, tru= e); + qvirtqueue_add(qts, vq, req_addr + 16 + sizeof(dwz_hdr), 1, true, = false); + + qvirtqueue_kick(qts, dev, vq, free_head); + + qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL, + QVIRTIO_BLK_TIMEOUT_US); + status =3D readb(req_addr + 16 + sizeof(dwz_hdr)); + g_assert_cmpint(status, =3D=3D, 0); + + guest_free(alloc, req_addr); + } + + if (features & (1u << VIRTIO_F_ANY_LAYOUT)) { + /* Write and read with 2 descriptor layout */ + /* Write request */ + req.type =3D VIRTIO_BLK_T_OUT; + req.ioprio =3D 1; + req.sector =3D 1; + req.data =3D g_malloc0(512); + strcpy(req.data, "TEST"); + + req_addr =3D virtio_blk_request(alloc, dev, &req, 512); + + g_free(req.data); + + free_head =3D qvirtqueue_add(qts, vq, req_addr, 528, false, true); + qvirtqueue_add(qts, vq, req_addr + 528, 1, true, false); + qvirtqueue_kick(qts, dev, vq, free_head); + + qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL, + QVIRTIO_BLK_TIMEOUT_US); + status =3D readb(req_addr + 528); + g_assert_cmpint(status, =3D=3D, 0); + + guest_free(alloc, req_addr); + + /* Read request */ + req.type =3D VIRTIO_BLK_T_IN; + req.ioprio =3D 1; + req.sector =3D 1; + req.data =3D g_malloc0(512); + + req_addr =3D virtio_blk_request(alloc, dev, &req, 512); + + g_free(req.data); + + free_head =3D qvirtqueue_add(qts, vq, req_addr, 16, false, true); + qvirtqueue_add(qts, vq, req_addr + 16, 513, true, false); + + qvirtqueue_kick(qts, dev, vq, free_head); + + qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL, + QVIRTIO_BLK_TIMEOUT_US); + status =3D readb(req_addr + 528); + g_assert_cmpint(status, =3D=3D, 0); + + data =3D g_malloc0(512); + memread(req_addr + 16, data, 512); + g_assert_cmpstr(data, =3D=3D, "TEST"); + g_free(data); + + guest_free(alloc, req_addr); + } + + return vq; +} + +static void basic(void *obj, void *data, QGuestAllocator *t_alloc) +{ + QVhostUserBlk *blk_if =3D obj; + QVirtQueue *vq; + + vq =3D test_basic(blk_if->vdev, t_alloc); + qvirtqueue_cleanup(blk_if->vdev->bus, vq, t_alloc); + +} + +static void indirect(void *obj, void *u_data, QGuestAllocator *t_alloc) +{ + QVirtQueue *vq; + QVhostUserBlk *blk_if =3D obj; + QVirtioDevice *dev =3D blk_if->vdev; + QVirtioBlkReq req; + QVRingIndirectDesc *indirect; + uint64_t req_addr; + uint64_t capacity; + uint64_t features; + uint32_t free_head; + uint8_t status; + char *data; + QTestState *qts =3D global_qtest; + + features =3D qvirtio_get_features(dev); + g_assert_cmphex(features & (1u << VIRTIO_RING_F_INDIRECT_DESC), !=3D, = 0); + features =3D features & ~(QVIRTIO_F_BAD_FEATURE | + (1u << VIRTIO_RING_F_EVENT_IDX) | + (1u << VIRTIO_BLK_F_SCSI)); + qvirtio_set_features(dev, features); + + capacity =3D qvirtio_config_readq(dev, 0); + g_assert_cmpint(capacity, =3D=3D, TEST_IMAGE_SIZE / 512); + + vq =3D qvirtqueue_setup(dev, t_alloc, 0); + qvirtio_set_driver_ok(dev); + + /* Write request */ + req.type =3D VIRTIO_BLK_T_OUT; + req.ioprio =3D 1; + req.sector =3D 0; + req.data =3D g_malloc0(512); + strcpy(req.data, "TEST"); + + req_addr =3D virtio_blk_request(t_alloc, dev, &req, 512); + + g_free(req.data); + + indirect =3D qvring_indirect_desc_setup(qts, dev, t_alloc, 2); + qvring_indirect_desc_add(dev, qts, indirect, req_addr, 528, false); + qvring_indirect_desc_add(dev, qts, indirect, req_addr + 528, 1, true); + free_head =3D qvirtqueue_add_indirect(qts, vq, indirect); + qvirtqueue_kick(qts, dev, vq, free_head); + + qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL, + QVIRTIO_BLK_TIMEOUT_US); + status =3D readb(req_addr + 528); + g_assert_cmpint(status, =3D=3D, 0); + + g_free(indirect); + guest_free(t_alloc, req_addr); + + /* Read request */ + req.type =3D VIRTIO_BLK_T_IN; + req.ioprio =3D 1; + req.sector =3D 0; + req.data =3D g_malloc0(512); + strcpy(req.data, "TEST"); + + req_addr =3D virtio_blk_request(t_alloc, dev, &req, 512); + + g_free(req.data); + + indirect =3D qvring_indirect_desc_setup(qts, dev, t_alloc, 2); + qvring_indirect_desc_add(dev, qts, indirect, req_addr, 16, false); + qvring_indirect_desc_add(dev, qts, indirect, req_addr + 16, 513, true); + free_head =3D qvirtqueue_add_indirect(qts, vq, indirect); + qvirtqueue_kick(qts, dev, vq, free_head); + + qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL, + QVIRTIO_BLK_TIMEOUT_US); + status =3D readb(req_addr + 528); + g_assert_cmpint(status, =3D=3D, 0); + + data =3D g_malloc0(512); + memread(req_addr + 16, data, 512); + g_assert_cmpstr(data, =3D=3D, "TEST"); + g_free(data); + + g_free(indirect); + guest_free(t_alloc, req_addr); + qvirtqueue_cleanup(dev->bus, vq, t_alloc); +} + + +static void idx(void *obj, void *u_data, QGuestAllocator *t_alloc) +{ + QVirtQueue *vq; + QVhostUserBlkPCI *blk =3D obj; + QVirtioPCIDevice *pdev =3D &blk->pci_vdev; + QVirtioDevice *dev =3D &pdev->vdev; + QVirtioBlkReq req; + uint64_t req_addr; + uint64_t capacity; + uint64_t features; + uint32_t free_head; + uint32_t write_head; + uint32_t desc_idx; + uint8_t status; + char *data; + QOSGraphObject *blk_object =3D obj; + QPCIDevice *pci_dev =3D blk_object->get_driver(blk_object, "pci-device= "); + QTestState *qts =3D global_qtest; + + if (qpci_check_buggy_msi(pci_dev)) { + return; + } + + qpci_msix_enable(pdev->pdev); + qvirtio_pci_set_msix_configuration_vector(pdev, t_alloc, 0); + + features =3D qvirtio_get_features(dev); + features =3D features & ~(QVIRTIO_F_BAD_FEATURE | + (1u << VIRTIO_RING_F_INDIRECT_DESC) | + (1u << VIRTIO_F_NOTIFY_ON_EMPTY) | + (1u << VIRTIO_BLK_F_SCSI)); + qvirtio_set_features(dev, features); + + capacity =3D qvirtio_config_readq(dev, 0); + g_assert_cmpint(capacity, =3D=3D, TEST_IMAGE_SIZE / 512); + + vq =3D qvirtqueue_setup(dev, t_alloc, 0); + qvirtqueue_pci_msix_setup(pdev, (QVirtQueuePCI *)vq, t_alloc, 1); + + qvirtio_set_driver_ok(dev); + + /* Write request */ + req.type =3D VIRTIO_BLK_T_OUT; + req.ioprio =3D 1; + req.sector =3D 0; + req.data =3D g_malloc0(512); + strcpy(req.data, "TEST"); + + req_addr =3D virtio_blk_request(t_alloc, dev, &req, 512); + + g_free(req.data); + + free_head =3D qvirtqueue_add(qts, vq, req_addr, 16, false, true); + qvirtqueue_add(qts, vq, req_addr + 16, 512, false, true); + qvirtqueue_add(qts, vq, req_addr + 528, 1, true, false); + qvirtqueue_kick(qts, dev, vq, free_head); + + qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL, + QVIRTIO_BLK_TIMEOUT_US); + + /* Write request */ + req.type =3D VIRTIO_BLK_T_OUT; + req.ioprio =3D 1; + req.sector =3D 1; + req.data =3D g_malloc0(512); + strcpy(req.data, "TEST"); + + req_addr =3D virtio_blk_request(t_alloc, dev, &req, 512); + + g_free(req.data); + + /* Notify after processing the third request */ + qvirtqueue_set_used_event(qts, vq, 2); + free_head =3D qvirtqueue_add(qts, vq, req_addr, 16, false, true); + qvirtqueue_add(qts, vq, req_addr + 16, 512, false, true); + qvirtqueue_add(qts, vq, req_addr + 528, 1, true, false); + qvirtqueue_kick(qts, dev, vq, free_head); + write_head =3D free_head; + + /* No notification expected */ + status =3D qvirtio_wait_status_byte_no_isr(qts, dev, + vq, req_addr + 528, + QVIRTIO_BLK_TIMEOUT_US); + g_assert_cmpint(status, =3D=3D, 0); + + guest_free(t_alloc, req_addr); + + /* Read request */ + req.type =3D VIRTIO_BLK_T_IN; + req.ioprio =3D 1; + req.sector =3D 1; + req.data =3D g_malloc0(512); + + req_addr =3D virtio_blk_request(t_alloc, dev, &req, 512); + + g_free(req.data); + + free_head =3D qvirtqueue_add(qts, vq, req_addr, 16, false, true); + qvirtqueue_add(qts, vq, req_addr + 16, 512, true, true); + qvirtqueue_add(qts, vq, req_addr + 528, 1, true, false); + + qvirtqueue_kick(qts, dev, vq, free_head); + + /* We get just one notification for both requests */ + qvirtio_wait_used_elem(qts, dev, vq, write_head, NULL, + QVIRTIO_BLK_TIMEOUT_US); + g_assert(qvirtqueue_get_buf(qts, vq, &desc_idx, NULL)); + g_assert_cmpint(desc_idx, =3D=3D, free_head); + + status =3D readb(req_addr + 528); + g_assert_cmpint(status, =3D=3D, 0); + + data =3D g_malloc0(512); + memread(req_addr + 16, data, 512); + g_assert_cmpstr(data, =3D=3D, "TEST"); + g_free(data); + + guest_free(t_alloc, req_addr); + + /* End test */ + qpci_msix_disable(pdev->pdev); + + qvirtqueue_cleanup(dev->bus, vq, t_alloc); +} + +static void pci_hotplug(void *obj, void *data, QGuestAllocator *t_alloc) +{ + QVirtioPCIDevice *dev1 =3D obj; + QVirtioPCIDevice *dev; + QTestState *qts =3D dev1->pdev->bus->qts; + + /* plug secondary disk */ + qtest_qmp_device_add(qts, "vhost-user-blk-pci", "drv1", + "{'addr': %s, 'chardev': 'char2'}", + stringify(PCI_SLOT_HP) ".0"); + + dev =3D virtio_pci_new(dev1->pdev->bus, + &(QPCIAddress) { .devfn =3D QPCI_DEVFN(PCI_SLOT_H= P, 0) }); + g_assert_nonnull(dev); + g_assert_cmpint(dev->vdev.device_type, =3D=3D, VIRTIO_ID_BLOCK); + qvirtio_pci_device_disable(dev); + qos_object_destroy((QOSGraphObject *)dev); + + /* unplug secondary disk */ + qpci_unplug_acpi_device_test(qts, "drv1", PCI_SLOT_HP); +} + +/* + * Check that setting the vring addr on a non-existent virtqueue does + * not crash. + */ +static void test_nonexistent_virtqueue(void *obj, void *data, + QGuestAllocator *t_alloc) +{ + QVhostUserBlkPCI *blk =3D obj; + QVirtioPCIDevice *pdev =3D &blk->pci_vdev; + QPCIBar bar0; + QPCIDevice *dev; + + dev =3D qpci_device_find(pdev->pdev->bus, QPCI_DEVFN(4, 0)); + g_assert(dev !=3D NULL); + qpci_device_enable(dev); + + bar0 =3D qpci_iomap(dev, 0, NULL); + + qpci_io_writeb(dev, bar0, VIRTIO_PCI_QUEUE_SEL, 2); + qpci_io_writel(dev, bar0, VIRTIO_PCI_QUEUE_PFN, 1); + + g_free(dev); +} + +static const char *qtest_qemu_vu_binary(void) +{ + const char *qemu_vu_bin; + + qemu_vu_bin =3D getenv("QTEST_QEMU_VU_BINARY"); + if (!qemu_vu_bin) { + fprintf(stderr, "Environment variable QTEST_QEMU_VU_BINARY require= d\n"); + exit(0); + } + + return qemu_vu_bin; +} + +static void drive_destroy(void *path) +{ + unlink(path); + g_free(path); + qos_invalidate_command_line(); +} + + +static char *drive_create(void) +{ + int fd, ret; + /** vhost-user-blk won't recognize drive located in /tmp */ + char *t_path =3D g_strdup("qtest.XXXXXX"); + + /** Create a temporary raw image */ + fd =3D mkstemp(t_path); + g_assert_cmpint(fd, >=3D, 0); + ret =3D ftruncate(fd, TEST_IMAGE_SIZE); + g_assert_cmpint(ret, =3D=3D, 0); + close(fd); + + g_test_queue_destroy(drive_destroy, t_path); + return t_path; +} + + + +static void start_vhost_user_blk(const char *img_path, const char *sock_pa= th) +{ + const char *vhost_user_blk_bin =3D qtest_qemu_vu_binary(); + /* "qemu-vu -e" will exit when the client disconnects thus the launched + * qemu-vu process will not block scripts/tap-driver.pl + */ + gchar *command =3D g_strdup_printf("exec %s " + "-e " + "-k %s " + "-f raw " + "%s", + vhost_user_blk_bin, + sock_path, img_path); + g_test_message("starting vhost-user backend: %s", command); + pid_t pid =3D fork(); + if (pid =3D=3D 0) { + execlp("/bin/sh", "sh", "-c", command, NULL); + exit(1); + } + /* + * make sure qemu-vu i.e. socket server is started before tests + * otherwise qemu will complain, + * "Failed to connect socket ... Connection refused" + */ + g_usleep(G_USEC_PER_SEC); +} + +static void *vhost_user_blk_test_setup(GString *cmd_line, void *arg) +{ + /* create image file */ + const char *img_path =3D drive_create(); + const char *sock_path =3D "/tmp/vhost-user-blk_vhost.socket"; + start_vhost_user_blk(img_path, sock_path); + /* "-chardev socket,id=3Dchar2" is used for pci_hotplug*/ + g_string_append_printf(cmd_line, + " -object memory-backend-memfd,id=3Dmem,size=3D= 128M,share=3Don -numa node,memdev=3Dmem " + "-chardev socket,id=3Dchar1,path=3D%s " + "-chardev socket,id=3Dchar2,path=3D%s", + sock_path, sock_path); + return arg; +} + +static void register_vhost_user_blk_test(void) +{ + QOSGraphTestOptions opts =3D { + .before =3D vhost_user_blk_test_setup, + }; + + /* + * tests for vhost-user-blk and vhost-user-blk-pci + * The tests are borrowed from tests/virtio-blk-test.c. But some tests + * regarding block_resize don't work for vhost-user-blk. + * vhost-user-blk device doesn't have -drive, so tests containing + * block_resize are also abandoned, + * - config + * - resize + */ + qos_add_test("basic", "vhost-user-blk", basic, &opts); + qos_add_test("indirect", "vhost-user-blk", indirect, &opts); + qos_add_test("idx", "vhost-user-blk-pci", idx, &opts); + qos_add_test("nxvirtq", "vhost-user-blk-pci", + test_nonexistent_virtqueue, &opts); + qos_add_test("hotplug", "vhost-user-blk-pci", pci_hotplug, &opts); +} + +libqos_init(register_vhost_user_blk_test); -- 2.24.1 From nobody Thu Mar 28 14:44:16 2024 Delivered-To: importer@patchew.org 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; Authentication-Results: mx.zohomail.com; dkim=fail; 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=fail(p=none dis=none) header.from=gmail.com ARC-Seal: i=1; a=rsa-sha256; t=1578891701; cv=none; d=zohomail.com; s=zohoarc; b=hY3I1LrwZFnRdPrwWhqZGkLTvmK8KJyjj+S79WI/BSHq21jiSeU9AAQdniMOLer3P6ALXw5OQ0wwo2vqpbWkH2H7QrRdagLHjkyhPUmXDDZPIYHi+cy1gM/sQFGdez2HdapokSk6p357eBofOwNiMRPitOyhJFhoj3IEd2mrn2U= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1578891701; h=Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=EQMyzeRthVsHsvanx1IY5iAxlbRqxtmJUNUIngmWAlk=; b=iTolcBnXhGy4lpwyO4nZs/xICkAeg9kaKB/Yf2TWAzaOCV4R9K0yZOZ34hl2BmEqBojBlwPJvGvynO7zKXfTL6rQU/mn9zMTSmPHl7+wZMIuuf3ryMt3F8LNs/Eozs0J5R5xePrRWUik+JqqJ2PR9zpPlUXXoe18cwu60H65XpE= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=fail; 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=fail header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1578891701838319.83441007485044; Sun, 12 Jan 2020 21:01:41 -0800 (PST) Received: from localhost ([::1]:45682 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1iqrrA-0003RL-PV for importer@patchew.org; Mon, 13 Jan 2020 00:01:40 -0500 Received: from eggs.gnu.org ([2001:470:142:3::10]:42253) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1iqrng-0007o2-D8 for qemu-devel@nongnu.org; Sun, 12 Jan 2020 23:58:05 -0500 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1iqrnf-0007AQ-4C for qemu-devel@nongnu.org; Sun, 12 Jan 2020 23:58:04 -0500 Received: from mail-pg1-x535.google.com ([2607:f8b0:4864:20::535]:41011) by eggs.gnu.org with esmtps (TLS1.0:RSA_AES_128_CBC_SHA1:16) (Exim 4.71) (envelope-from ) id 1iqrne-00078G-TK for qemu-devel@nongnu.org; Sun, 12 Jan 2020 23:58:03 -0500 Received: by mail-pg1-x535.google.com with SMTP id x8so4097279pgk.8 for ; Sun, 12 Jan 2020 20:58:02 -0800 (PST) Received: from localhost.localdomain ([175.124.145.172]) by smtp.googlemail.com with ESMTPSA id o19sm17590552pjr.2.2020.01.12.20.57.58 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 12 Jan 2020 20:58:00 -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 :mime-version:content-transfer-encoding; bh=EQMyzeRthVsHsvanx1IY5iAxlbRqxtmJUNUIngmWAlk=; b=h37HcGKpWzAd4VTJVn7G3SKFYITfFU+wzluErHcVOtv1DXaXJw29GC/wJh8FUX8/U0 XaSbl46qJVl8JhU9gDuYm6Q9E1PDWsOPhUu1IqHYcOvn+rgZBGewZwoU+3st/Q3sPiUt EyzZaKLO2lI250RUGR0j6HUw4YISye1thAPgnSvCd7DnmahEAB+GlzFdY0/9YvvjxcB2 ksecZ149Mezh7H8UjPYnaRtg2E560lSmPgEvCylVC4UxBwGTn/zDGlOZ3H2OLzrj1eNs hwsx3S0oeXwsbaKzR/WV2NX9pKiHne40K44/WxerETgHx0U2YsR+ECnPKsLIPF4r2i6a oTCA== 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:mime-version:content-transfer-encoding; bh=EQMyzeRthVsHsvanx1IY5iAxlbRqxtmJUNUIngmWAlk=; b=h+cZgIr67QKfnUyEjzlNZ9qaebF9IOnKvAbNkFZ7rtDXP3ua3yoQppTfERm+aBZYxF UVGHbxsKObEbu9DLtXIqTl26m5f2Qq5yNuhpVjfmj2kj4wJyKJrxdhSb2sj/0FT2Iy45 IbXdxUZfxz9PjTn58S9eOQDnn5p/8bghJD2nMNdyr6mr97p/acfZa90zsoKZV6dS+FcS KKtu9LXG3fnMK939Pcni4quKsUBYl4yIW7nsjp/DLXpnswT5g4/GJn5icznJkExgg3JV DOpeuHlsP42EHFIvvvGXKM0p4xubuP5NsCBfILOyz/wDQSwYp5gOA+CgONWbUvNKRJ0c DR2Q== X-Gm-Message-State: APjAAAW+MOj+x0QqWQwSzXXleL8ajOEKx/8Pd510oNFjsCn6fQyoO6Vo 5iqtu9xmpsO9MGGzlBRb05d7g7JcF6a0Zw== X-Google-Smtp-Source: APXvYqxcZ+1XV2qEA92vZkHoV47Ngmrj8t7C0v9bwb2JMF4IJUYUSwDwiXmpQi5lq1mPmSKsUxl/fA== X-Received: by 2002:a63:cd06:: with SMTP id i6mr19176519pgg.48.1578891481500; Sun, 12 Jan 2020 20:58:01 -0800 (PST) From: Coiby Xu To: qemu-devel@nongnu.org Subject: [PATCH v1 5/5] building configuration files changes Date: Mon, 13 Jan 2020 12:57:04 +0800 Message-Id: <20200113045704.12318-6-coiby.xu@gmail.com> X-Mailer: git-send-email 2.24.1 In-Reply-To: <20200113045704.12318-1-coiby.xu@gmail.com> References: <20200113045704.12318-1-coiby.xu@gmail.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-detected-operating-system: by eggs.gnu.org: Genre and OS details not recognized. X-Received-From: 2607:f8b0:4864:20::535 X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: kwolf@redhat.com, bharatlkmlkvm@gmail.com, Coiby Xu , stefanha@redhat.com Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: fail (Header signature does not verify) Content-Type: text/plain; charset="utf-8" Signed-off-by: Coiby Xu --- Makefile | 1 + Makefile.objs | 2 +- Makefile.target | 1 + configure | 2 +- tests/Makefile.include | 5 ++++- 5 files changed, 8 insertions(+), 3 deletions(-) diff --git a/Makefile b/Makefile index 6b5ad1121b..1b98201d29 100644 --- a/Makefile +++ b/Makefile @@ -558,6 +558,7 @@ qemu-img.o: qemu-img-cmds.h qemu-img$(EXESUF): qemu-img.o $(authz-obj-y) $(block-obj-y) $(crypto-obj-y= ) $(io-obj-y) $(qom-obj-y) $(COMMON_LDADDS) qemu-nbd$(EXESUF): qemu-nbd.o $(authz-obj-y) $(block-obj-y) $(crypto-obj-y= ) $(io-obj-y) $(qom-obj-y) $(COMMON_LDADDS) +qemu-vu$(EXESUF): qemu-vu.o blockdev-vu.o $(authz-obj-y) $(block-obj-y) $(= crypto-obj-y) $(io-obj-y) $(qom-obj-y) $(COMMON_LDADDS) libvhost-user.a qemu-io$(EXESUF): qemu-io.o $(authz-obj-y) $(block-obj-y) $(crypto-obj-y) = $(io-obj-y) $(qom-obj-y) $(COMMON_LDADDS) qemu-bridge-helper$(EXESUF): qemu-bridge-helper.o $(COMMON_LDADDS) diff --git a/Makefile.objs b/Makefile.objs index 7c1e50f9d6..f77b110fc9 100644 --- a/Makefile.objs +++ b/Makefile.objs @@ -42,7 +42,7 @@ io-obj-y =3D io/ # single QEMU executable should support all CPUs and machines. ifeq ($(CONFIG_SOFTMMU),y) -common-obj-y =3D blockdev.o blockdev-nbd.o block/ +common-obj-y =3D blockdev.o blockdev-nbd.o blockdev-vu.o block/ common-obj-y +=3D bootdevice.o iothread.o common-obj-y +=3D dump/ common-obj-y +=3D job-qmp.o diff --git a/Makefile.target b/Makefile.target index 6e61f607b1..51a9a9c349 100644 --- a/Makefile.target +++ b/Makefile.target @@ -159,6 +159,7 @@ obj-y +=3D monitor/ obj-y +=3D qapi/ obj-y +=3D memory.o obj-y +=3D memory_mapping.o +obj-y +=3D ../contrib/libvhost-user/libvhost-user.o obj-y +=3D migration/ram.o LIBS :=3D $(libs_softmmu) $(LIBS) diff --git a/configure b/configure index 0ce2c0354a..b13d4a8da7 100755 --- a/configure +++ b/configure @@ -6165,7 +6165,7 @@ fi tools=3D"" if test "$want_tools" =3D "yes" ; then - tools=3D"qemu-img\$(EXESUF) qemu-io\$(EXESUF) qemu-edid\$(EXESUF) $tools" + tools=3D"qemu-img\$(EXESUF) qemu-vu\$(EXESUF) qemu-io\$(EXESUF) qemu-edi= d\$(EXESUF) $tools" if [ "$linux" =3D "yes" -o "$bsd" =3D "yes" -o "$solaris" =3D "yes" ] ; = then tools=3D"qemu-nbd\$(EXESUF) $tools" fi diff --git a/tests/Makefile.include b/tests/Makefile.include index 49e3b0d319..7d7692734c 100644 --- a/tests/Makefile.include +++ b/tests/Makefile.include @@ -746,6 +746,7 @@ qos-test-obj-y +=3D tests/libqos/virtio.o qos-test-obj-$(CONFIG_VIRTFS) +=3D tests/libqos/virtio-9p.o qos-test-obj-y +=3D tests/libqos/virtio-balloon.o qos-test-obj-y +=3D tests/libqos/virtio-blk.o +qos-test-obj-y +=3D tests/libqos/vhost-user-blk.o qos-test-obj-y +=3D tests/libqos/virtio-mmio.o qos-test-obj-y +=3D tests/libqos/virtio-net.o qos-test-obj-y +=3D tests/libqos/virtio-pci.o @@ -788,6 +789,7 @@ qos-test-obj-$(CONFIG_VHOST_NET_USER) +=3D tests/vhost-= user-test.o $(chardev-obj-y qos-test-obj-y +=3D tests/virtio-test.o qos-test-obj-$(CONFIG_VIRTFS) +=3D tests/virtio-9p-test.o qos-test-obj-y +=3D tests/virtio-blk-test.o +qos-test-obj-y +=3D tests/vhost-user-blk-test.o qos-test-obj-y +=3D tests/virtio-net-test.o qos-test-obj-y +=3D tests/virtio-rng-test.o qos-test-obj-y +=3D tests/virtio-scsi-test.o @@ -935,7 +937,8 @@ endef $(patsubst %, check-qtest-%, $(QTEST_TARGETS)): check-qtest-%: %-softmmu/a= ll $(check-qtest-y) $(call do_test_human,$(check-qtest-$*-y) $(check-qtest-generic-y), \ QTEST_QEMU_BINARY=3D$*-softmmu/qemu-system-$* \ - QTEST_QEMU_IMG=3Dqemu-img$(EXESUF)) + QTEST_QEMU_IMG=3D./qemu-img$(EXESUF) \ + QTEST_QEMU_VU_BINARY=3D./qemu-vu$(EXESUF)) check-unit: $(check-unit-y) $(call do_test_human, $^) -- 2.24.1