From nobody Sat Apr 27 06:57:47 2024 Delivered-To: importer@patchew.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=1600416681; cv=none; d=zohomail.com; s=zohoarc; b=a0o7b+FBnXcgjX4Dp6pH6i9AZadaoDG6rbyulzE3h/Sy2MDx2ew4xpPw5QRM5+KedVhPvA+j7GvtgGUpkcGGKkRDe2nqJaFLh5vwYv43SDXVzbuXyYPfY8Sd51DzWnHPnJYXRaFH/Jwh+GQj8Ch78EgVe4D6RvcXpD94H8fnF+c= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1600416681; 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=H44SjkvjfzSidhnIMnrWf5qrjXNq+aKE1JXm4N92uiY=; b=I6pyW49hXsdfnS+lws9mG+uy0HQKOzkIzktkf6fpCZAY5ZzwWbnmslq/9RwR+CNCPMrQv2nTqvegDGgnS2AhgWasevfTP0d2yA1wZZIOx40abzv7Un5TTWnse4Q7E1e33O9dj5/rshWNLUaXrk8NAPzhJsBwEoaEdzlzYmpIFwo= 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 1600416681641742.7552207199187; Fri, 18 Sep 2020 01:11:21 -0700 (PDT) Received: from localhost ([::1]:34054 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1kJBUG-0001i2-6Q for importer@patchew.org; Fri, 18 Sep 2020 04:11:20 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:56906) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1kJBSY-0008Iv-QF for qemu-devel@nongnu.org; Fri, 18 Sep 2020 04:09:36 -0400 Received: from mail-pf1-x444.google.com ([2607:f8b0:4864:20::444]:45673) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1kJBSU-0003Gc-EN for qemu-devel@nongnu.org; Fri, 18 Sep 2020 04:09:34 -0400 Received: by mail-pf1-x444.google.com with SMTP id k15so2935420pfc.12 for ; Fri, 18 Sep 2020 01:09:28 -0700 (PDT) Received: from localhost ([2001:e42:102:1532:160:16:113:140]) by smtp.gmail.com with ESMTPSA id gb19sm1907542pjb.38.2020.09.18.01.09.26 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 18 Sep 2020 01:09:26 -0700 (PDT) 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=H44SjkvjfzSidhnIMnrWf5qrjXNq+aKE1JXm4N92uiY=; b=H6a/3COB70xb5XuicfLutNKKGptmBWSFNOQKkxCipsneNuRe+Dt/uxsCKCqH7HEJ+1 VduKYudvA/vOx/v0Lb28D9EtTRtdujn71C+maDBGjLyLh0RbQfmT5sKNcY5Wf5bF0iGx LdNooVVug+yu1XfRncT6M9cbvS9UEtOPF7oC4BnS9lVonpnJBZih72ydoabInc4Bx+uP rmV2HCANqEMj65axCFEoQrqX3rVAxNQlTvw5UgNsx+59kca9AwJt3lsziF9DtSZhmrMk plSfJeUqfPMiNmn5obfcu//tWY06u5RB2gkn3JD7E8EY+Qg7cdagi/afSOse72ypLJSP aOvw== 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=H44SjkvjfzSidhnIMnrWf5qrjXNq+aKE1JXm4N92uiY=; b=MCtREv4j1+oKywa09j5Dt1kMqLmYQt4pVDsWdk7zuIvwY2Bw7apenQxxjXvRcMh0my OD04Jv4WLCu+mT6AYfa/sFNtbhysT00Eeh7Ira9Vjuj7zI+QY0r5saV5AxAQXzUkIL13 +tDt6Py58mmAfqvJFJjJccqpa2UbN/fGUes00sjOfJtPkbhTonn0VqhZ3V4xEApe540l LyufUI8ziS/rCxB1TGKCtjgiQls7fRH02WtsSHG81uoUe9zQUm3qppCnOWMBmu7IMhKd NKP5xea3Dzz/C21BlkazB0Z+19HJHbTAXtVjEncrih/FxRc9nFxLXVBs8Hf7FT6p9cLj Pt9w== X-Gm-Message-State: AOAM533Bo3V01hYzFS6wdMe1Rj/4obeSsYUO2AHQ9Ra5h4x6Ox2grnAd NelSwHRpDnf0+JbRik0BvYAPcQlizrLaHA== X-Google-Smtp-Source: ABdhPJyXf10MoT1U2xshkbeXqXcSSzGByeyZs+11FZMJQIGiXjiWUws+KogHqOULfLF4CJ/lwb5SdA== X-Received: by 2002:a62:2c8:0:b029:13e:9ee9:5b25 with SMTP id 191-20020a6202c80000b029013e9ee95b25mr31298605pfc.1.1600416567297; Fri, 18 Sep 2020 01:09:27 -0700 (PDT) From: Coiby Xu To: qemu-devel@nongnu.org Subject: [PATCH v10 1/7] libvhost-user: Allow vu_message_read to be replaced Date: Fri, 18 Sep 2020 16:09:06 +0800 Message-Id: <20200918080912.321299-2-coiby.xu@gmail.com> X-Mailer: git-send-email 2.28.0 In-Reply-To: <20200918080912.321299-1-coiby.xu@gmail.com> References: <20200918080912.321299-1-coiby.xu@gmail.com> MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2607:f8b0:4864:20::444; envelope-from=coiby.xu@gmail.com; helo=mail-pf1-x444.google.com X-detected-operating-system: by eggs.gnu.org: No matching host in p0f cache. That's all we know. X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, FREEMAIL_FROM=0.001, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: kwolf@redhat.com, bharatlkmlkvm@gmail.com, "Dr. David Alan Gilbert" , stefanha@redhat.com, =?UTF-8?q?Marc-Andr=C3=A9=20Lureau?= Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: fail (Header signature does not verify) Allow vu_message_read to be replaced by one which will make use of the QIOChannel functions. Thus reading vhost-user message won't stall the guest. For slave channel, we still use the default vu_message_read. Reviewed-by: Marc-Andr=C3=A9 Lureau Signed-off-by: Coiby Xu Reviewed-by: Stefan Hajnoczi --- contrib/libvhost-user/libvhost-user-glib.c | 2 +- contrib/libvhost-user/libvhost-user.c | 14 +++++++------- contrib/libvhost-user/libvhost-user.h | 21 +++++++++++++++++++++ tests/vhost-user-bridge.c | 2 ++ tools/virtiofsd/fuse_virtio.c | 4 ++-- 5 files changed, 33 insertions(+), 10 deletions(-) diff --git a/contrib/libvhost-user/libvhost-user-glib.c b/contrib/libvhost-= user/libvhost-user-glib.c index 53f1ca4cdd..0df2ec9271 100644 --- a/contrib/libvhost-user/libvhost-user-glib.c +++ b/contrib/libvhost-user/libvhost-user-glib.c @@ -147,7 +147,7 @@ vug_init(VugDev *dev, uint16_t max_queues, int socket, g_assert(dev); g_assert(iface); =20 - if (!vu_init(&dev->parent, max_queues, socket, panic, set_watch, + if (!vu_init(&dev->parent, max_queues, socket, panic, NULL, set_watch, remove_watch, iface)) { return false; } diff --git a/contrib/libvhost-user/libvhost-user.c b/contrib/libvhost-user/= libvhost-user.c index 53f16bdf08..73732b928f 100644 --- a/contrib/libvhost-user/libvhost-user.c +++ b/contrib/libvhost-user/libvhost-user.c @@ -67,8 +67,6 @@ /* The version of inflight buffer */ #define INFLIGHT_VERSION 1 =20 -#define VHOST_USER_HDR_SIZE offsetof(VhostUserMsg, payload.u64) - /* The version of the protocol we support */ #define VHOST_USER_VERSION 1 #define LIBVHOST_USER_DEBUG 0 @@ -267,7 +265,7 @@ have_userfault(void) } =20 static bool -vu_message_read(VuDev *dev, int conn_fd, VhostUserMsg *vmsg) +vu_message_read_default(VuDev *dev, int conn_fd, VhostUserMsg *vmsg) { char control[CMSG_SPACE(VHOST_MEMORY_BASELINE_NREGIONS * sizeof(int))]= =3D {}; struct iovec iov =3D { @@ -415,7 +413,7 @@ vu_process_message_reply(VuDev *dev, const VhostUserMsg= *vmsg) goto out; } =20 - if (!vu_message_read(dev, dev->slave_fd, &msg_reply)) { + if (!vu_message_read_default(dev, dev->slave_fd, &msg_reply)) { goto out; } =20 @@ -898,7 +896,7 @@ vu_set_mem_table_exec_postcopy(VuDev *dev, VhostUserMsg= *vmsg) /* Wait for QEMU to confirm that it's registered the handler for the * faults. */ - if (!vu_message_read(dev, dev->sock, vmsg) || + if (!dev->read_msg(dev, dev->sock, vmsg) || vmsg->size !=3D sizeof(vmsg->payload.u64) || vmsg->payload.u64 !=3D 0) { vu_panic(dev, "failed to receive valid ack for postcopy set-mem-ta= ble"); @@ -1860,7 +1858,7 @@ vu_dispatch(VuDev *dev) int reply_requested; bool need_reply, success =3D false; =20 - if (!vu_message_read(dev, dev->sock, &vmsg)) { + if (!dev->read_msg(dev, dev->sock, &vmsg)) { goto end; } =20 @@ -1958,6 +1956,7 @@ vu_init(VuDev *dev, uint16_t max_queues, int socket, vu_panic_cb panic, + vu_read_msg_cb read_msg, vu_set_watch_cb set_watch, vu_remove_watch_cb remove_watch, const VuDevIface *iface) @@ -1975,6 +1974,7 @@ vu_init(VuDev *dev, =20 dev->sock =3D socket; dev->panic =3D panic; + dev->read_msg =3D read_msg ? read_msg : vu_message_read_default; dev->set_watch =3D set_watch; dev->remove_watch =3D remove_watch; dev->iface =3D iface; @@ -2340,7 +2340,7 @@ static void _vu_queue_notify(VuDev *dev, VuVirtq *vq,= bool sync) =20 vu_message_write(dev, dev->slave_fd, &vmsg); if (ack) { - vu_message_read(dev, dev->slave_fd, &vmsg); + vu_message_read_default(dev, dev->slave_fd, &vmsg); } return; } diff --git a/contrib/libvhost-user/libvhost-user.h b/contrib/libvhost-user/= libvhost-user.h index 844c37c648..fe27831395 100644 --- a/contrib/libvhost-user/libvhost-user.h +++ b/contrib/libvhost-user/libvhost-user.h @@ -36,6 +36,8 @@ */ #define VHOST_USER_MAX_RAM_SLOTS 32 =20 +#define VHOST_USER_HDR_SIZE offsetof(VhostUserMsg, payload.u64) + typedef enum VhostSetConfigType { VHOST_SET_CONFIG_TYPE_MASTER =3D 0, VHOST_SET_CONFIG_TYPE_MIGRATION =3D 1, @@ -221,6 +223,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= ); @@ -389,6 +392,23 @@ struct VuDev { bool broken; uint16_t max_queues; =20 + /* @read_msg: custom method to read vhost-user message + * + * Read data from vhost_user socket fd and fill up + * the passed VhostUserMsg *vmsg struct. + * + * If reading fails, it should close the received set of file + * descriptors as socket message's auxiliary data. + * + * For the details, please refer to vu_message_read in libvhost-user.c + * which will be used by default if not custom method is provided when + * calling vu_init + * + * Returns: true if vhost-user message successfully received, + * otherwise return false. + * + */ + vu_read_msg_cb read_msg; /* @set_watch: add or update the given fd to the watch set, * call cb when condition is met */ vu_set_watch_cb set_watch; @@ -432,6 +452,7 @@ bool vu_init(VuDev *dev, uint16_t max_queues, int socket, vu_panic_cb panic, + vu_read_msg_cb read_msg, vu_set_watch_cb set_watch, vu_remove_watch_cb remove_watch, const VuDevIface *iface); diff --git a/tests/vhost-user-bridge.c b/tests/vhost-user-bridge.c index 6c3d490611..bd43607a4d 100644 --- a/tests/vhost-user-bridge.c +++ b/tests/vhost-user-bridge.c @@ -520,6 +520,7 @@ vubr_accept_cb(int sock, void *ctx) VHOST_USER_BRIDGE_MAX_QUEUES, conn_fd, vubr_panic, + NULL, vubr_set_watch, vubr_remove_watch, &vuiface)) { @@ -573,6 +574,7 @@ vubr_new(const char *path, bool client) VHOST_USER_BRIDGE_MAX_QUEUES, dev->sock, vubr_panic, + NULL, vubr_set_watch, vubr_remove_watch, &vuiface)) { diff --git a/tools/virtiofsd/fuse_virtio.c b/tools/virtiofsd/fuse_virtio.c index 9e5537506c..f7da358d4a 100644 --- a/tools/virtiofsd/fuse_virtio.c +++ b/tools/virtiofsd/fuse_virtio.c @@ -996,8 +996,8 @@ int virtio_session_mount(struct fuse_session *se) se->vu_socketfd =3D data_sock; se->virtio_dev->se =3D se; pthread_rwlock_init(&se->virtio_dev->vu_dispatch_rwlock, NULL); - vu_init(&se->virtio_dev->dev, 2, se->vu_socketfd, fv_panic, fv_set_wat= ch, - fv_remove_watch, &fv_iface); + vu_init(&se->virtio_dev->dev, 2, se->vu_socketfd, fv_panic, NULL, + fv_set_watch, fv_remove_watch, &fv_iface); =20 return 0; } --=20 2.28.0 From nobody Sat Apr 27 06:57:47 2024 Delivered-To: importer@patchew.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=1600416682; cv=none; d=zohomail.com; s=zohoarc; b=ChpXqOx6/Fgi7vXZG/m77WyZPaEz08r0g/LRzo54miStgxFJC4YNF4tbu8ddfkVvKODurnu5U6fRIoa0HNOxxtjJ5Tag8VeVVSrU30/XflsbXZIq4Bh8eK2IvzRLHmgzdvpvQRDYx7N7XwAV3XTw/M7n/22QaE7ZTazam7M4wrU= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1600416682; 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=R2K3zektrII7VfrfNzLt01qEnMNNGVHrgK9BV7adSRc=; b=UC8xNSoCzfMP/09bEjhHyuj9/5fe+zzs9eENT2x/t/9EmOIIvY7SCVl7jT67Bfkkd+vizobnUoeJUYZcFx+zG3At/EaA9nvFhCKbyDDmV336SoyvnVSwD5PdUMUt3MMe8oTFBI0qEBoWf0uH2XGPAqob17krp5D1fzPMfTipvkM= 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 1600416682451840.2798951979349; Fri, 18 Sep 2020 01:11:22 -0700 (PDT) Received: from localhost ([::1]:34188 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1kJBUH-0001lH-3e for importer@patchew.org; Fri, 18 Sep 2020 04:11:21 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:56926) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1kJBSc-0008ML-JR for qemu-devel@nongnu.org; Fri, 18 Sep 2020 04:09:38 -0400 Received: from mail-pj1-x1042.google.com ([2607:f8b0:4864:20::1042]:39461) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1kJBSb-0003H2-2m for qemu-devel@nongnu.org; Fri, 18 Sep 2020 04:09:38 -0400 Received: by mail-pj1-x1042.google.com with SMTP id v14so2610899pjd.4 for ; Fri, 18 Sep 2020 01:09:36 -0700 (PDT) Received: from localhost ([2001:e42:102:1532:160:16:113:140]) by smtp.gmail.com with ESMTPSA id j4sm2308784pfd.101.2020.09.18.01.09.34 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 18 Sep 2020 01:09:34 -0700 (PDT) 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=R2K3zektrII7VfrfNzLt01qEnMNNGVHrgK9BV7adSRc=; b=KSvrD8vdYzJxWS5xzhBF0drtgM0OPz+BC/KpRGNq96z/t7QyiYXPFaND8Oh+kCkL1R /m693pd2qxRAJh5HVwTlvgIA4tqXDGEI6KFX9OoBOGODy+2CKs8HujAdaXRIPiXs3uGw XnNnYJqUY1EL2m9Z9EkoXSDZrv42FKJP3+bsEIqDiOf2FnjkBqyH+qcFGuPfPqJuS501 lw+yUZgBU7azu+QNQgOiwwgxUVCNuFOK/tbyNXBhFc1v6bVX90NUTkGjYfS/YPNvQgTY VX8cPVmY9gPuthwOEDnl6LZUllU/qIbyKhj2s5PdRn6Z0QAmoX9j4y+t8FIDTnUxRN3n p4qg== 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=R2K3zektrII7VfrfNzLt01qEnMNNGVHrgK9BV7adSRc=; b=V956EVF0SOwWFRIFFIzVht146CC1LZs0LAGZPQNYlrrpa9WKx0QbNqeVeqpQOo6jCU VepX8pfBfpMarYdBbhsX/6YgvNwgwMknOra4VM21beYiZpnBeip+dcqMgw+fAoLhId1c LVhY7FIwUYF4Ej/4MX+I5x3YR5nS7Ov/+HWDBayWXyKmCYlBBlmUOyrE+xXcpFO0lmWa /Y7i4GcjhHL5SB0l0igLzqjr+py2BndGnnrs1T/KA0PVRJD6zTyP1LFwowvsZDN7Mqvr FmRorEcVpIOYWuU1gOZOd5YRP1lTB0lZlAFVlWYLU/qv+0Sim+kVCyql1UHdGg8UPPcF Vxyg== X-Gm-Message-State: AOAM531bLhFAIXavAXz8fdjB96UI4+NgRhJQXcuYjxX+5uecLcboqKCJ X8zfWiHmYoXzdl9D10eh+6TuI1IgrKFm5g== X-Google-Smtp-Source: ABdhPJxGaYR6NkiO1ld0vL/Dc5DO7E7tZuvcN+oud0qHyLVZR2rT2Kabc03hb0s/Z6TqE0d4NQ+JIA== X-Received: by 2002:a17:90a:8588:: with SMTP id m8mr11403776pjn.91.1600416575196; Fri, 18 Sep 2020 01:09:35 -0700 (PDT) From: Coiby Xu To: qemu-devel@nongnu.org Subject: [PATCH v10 2/7] libvhost-user: remove watch for kick_fd when de-initialize vu-dev Date: Fri, 18 Sep 2020 16:09:07 +0800 Message-Id: <20200918080912.321299-3-coiby.xu@gmail.com> X-Mailer: git-send-email 2.28.0 In-Reply-To: <20200918080912.321299-1-coiby.xu@gmail.com> References: <20200918080912.321299-1-coiby.xu@gmail.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2607:f8b0:4864:20::1042; envelope-from=coiby.xu@gmail.com; helo=mail-pj1-x1042.google.com X-detected-operating-system: by eggs.gnu.org: No matching host in p0f cache. That's all we know. X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, FREEMAIL_FROM=0.001, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: kwolf@redhat.com, bharatlkmlkvm@gmail.com, 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" When the client is running in gdb and quit command is run in gdb, QEMU will still dispatch the event which will cause segment fault in the callback function. Signed-off-by: Coiby Xu Reviewed-by: Stefan Hajnoczi --- contrib/libvhost-user/libvhost-user.c | 1 + 1 file changed, 1 insertion(+) diff --git a/contrib/libvhost-user/libvhost-user.c b/contrib/libvhost-user/= libvhost-user.c index 73732b928f..5fdfa64294 100644 --- a/contrib/libvhost-user/libvhost-user.c +++ b/contrib/libvhost-user/libvhost-user.c @@ -1909,6 +1909,7 @@ vu_deinit(VuDev *dev) } =20 if (vq->kick_fd !=3D -1) { + dev->remove_watch(dev, vq->kick_fd); close(vq->kick_fd); vq->kick_fd =3D -1; } --=20 2.28.0 From nobody Sat Apr 27 06:57:47 2024 Delivered-To: importer@patchew.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=1600416793; cv=none; d=zohomail.com; s=zohoarc; b=m4F4DfrobrnpnjO6fP1ZnQ0MM2+6wknev4FsQ09JYC4dsGe3sF95qJPUROyEw6QfObVdCBosRE7If8xNO1BpqmhE14rl/Dv1SLTN3NEY7uvlxh+1/bMfgyEPXakUiKHsfZ/seG+8P1ryx4l7uqpqjlO/n24TEN1Ig/nqcN0XAp8= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1600416793; 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=4zyRE+PLFJ59iQlzfMElbeubCVfyJK8cQ7dZ8TMcYeg=; b=ZN69A+hcsni/gvSbHsjmdUIUkwft98NLMvWgmAD529aqvIkCCrboFqwaMATxLZt2bh4e/q7nFaWNYQTDAet7PfMRaJVL/rcFwYSKGx6XrD9BkYrrcBbSKXu4cbxe5opp+sjW8y/MXi90f0UOuyDqFLbBcaxJiYryfYN8GHmCAXM= 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 1600416793904194.81892172411722; Fri, 18 Sep 2020 01:13:13 -0700 (PDT) Received: from localhost ([::1]:42466 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1kJBW4-00052w-HV for importer@patchew.org; Fri, 18 Sep 2020 04:13:12 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:56956) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1kJBSl-00007q-Jr for qemu-devel@nongnu.org; Fri, 18 Sep 2020 04:09:47 -0400 Received: from mail-pj1-x1041.google.com ([2607:f8b0:4864:20::1041]:38259) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1kJBSj-0003HJ-38 for qemu-devel@nongnu.org; Fri, 18 Sep 2020 04:09:47 -0400 Received: by mail-pj1-x1041.google.com with SMTP id u3so2616924pjr.3 for ; Fri, 18 Sep 2020 01:09:42 -0700 (PDT) Received: from localhost ([2001:e42:102:1532:160:16:113:140]) by smtp.gmail.com with ESMTPSA id gd14sm2027707pjb.0.2020.09.18.01.09.39 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 18 Sep 2020 01:09:40 -0700 (PDT) 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=4zyRE+PLFJ59iQlzfMElbeubCVfyJK8cQ7dZ8TMcYeg=; b=NDH0J6t5Vap8ZIh1grxUMjP1zERnBqsyFjYO1u945NpEZAHHWTMfZ5iKWt4LJqgiWZ NuVDsnVJsOdeYSeYlPyRYdHcqtfr+mBYVo5iUquBkLC8fh9Klf/HzG043IJvs8gp3Vbk he3DGEfP9VKSjaboJdoIOKqN+mZtqmUh0CCQ2dRUTTCaIyVksuWiqIbtLxq/dBPnIQkc zu1rsI24l80EeRwpfpJxAyNEKuhnPTfKfZ1otBOUpyGQkvXlWram9dckG0RuDOefgXWk 8fkhh+X/sSaxDjXax+LNc00DOSYEvZpOWoUMvvM6Yc3kWyKMzCLSiG+NDHgje4XNLNtG mFsg== 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=4zyRE+PLFJ59iQlzfMElbeubCVfyJK8cQ7dZ8TMcYeg=; b=M/mtaK3z9KilfOXNRET5R0TYg6B6t6JyRGKHk+YTaksfY9agbtHFiIt+1PWqvHWW4+ iEA3E01XzMghbomBBDCjzw6ViSScSRyXtiyDYKhK5k0GSm4L98+iAguHLICZB3XHlzcG L3LcO/HDBbEFX7SJTYQ2dO460rHhAgO8J6f8EkuiiTCBj0UpSG4X4A0qQ7iE+MGWrmig 6uZj+kbmiWX3+uXGBZJmDzcI9iDmjMPHWBvKQ0NZRTXSAGIbp6cJ9NW3L20LZizsMioO cxy4R2qikhAY7PppCEAaAPTTZWh71RvPeg6qeP4DpiMznyxbL2g0TcP+413PP7u/2Pxf 0S+A== X-Gm-Message-State: AOAM532Msj7qeQ518fQbjeBLf1S0fn49uxLp+nBlqQS5Df21/LXVS2HS ldcVL/7+U36C2N9Aaqw+24kvkmpArsDAZg== X-Google-Smtp-Source: ABdhPJyuihqgXL3RGSTdvkR8MGdgJ/qSQagkZLXAClMY7XVjjiZCWRdUK9WkwnoQdO/18qwgNiSk+A== X-Received: by 2002:a17:902:7d8f:b029:d1:bafa:baf3 with SMTP id a15-20020a1709027d8fb02900d1bafabaf3mr28230072plm.17.1600416581304; Fri, 18 Sep 2020 01:09:41 -0700 (PDT) From: Coiby Xu To: qemu-devel@nongnu.org Subject: [PATCH v10 3/7] util/vhost-user-server: generic vhost user server Date: Fri, 18 Sep 2020 16:09:08 +0800 Message-Id: <20200918080912.321299-4-coiby.xu@gmail.com> X-Mailer: git-send-email 2.28.0 In-Reply-To: <20200918080912.321299-1-coiby.xu@gmail.com> References: <20200918080912.321299-1-coiby.xu@gmail.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2607:f8b0:4864:20::1041; envelope-from=coiby.xu@gmail.com; helo=mail-pj1-x1041.google.com X-detected-operating-system: by eggs.gnu.org: No matching host in p0f cache. That's all we know. X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, FREEMAIL_FROM=0.001, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.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" Sharing QEMU devices via vhost-user protocol. Only one vhost-user client can connect to the server one time. Suggested-by: Kevin Wolf Signed-off-by: Stefan Hajnoczi Signed-off-by: Coiby Xu Reviewed-by: Stefan Hajnoczi --- util/meson.build | 1 + util/vhost-user-server.c | 428 +++++++++++++++++++++++++++++++++++++++ util/vhost-user-server.h | 65 ++++++ 3 files changed, 494 insertions(+) create mode 100644 util/vhost-user-server.c create mode 100644 util/vhost-user-server.h diff --git a/util/meson.build b/util/meson.build index e6b207a99e..3921981ccf 100644 --- a/util/meson.build +++ b/util/meson.build @@ -66,6 +66,7 @@ if have_block util_ss.add(files('main-loop.c')) util_ss.add(files('nvdimm-utils.c')) util_ss.add(files('qemu-coroutine.c', 'qemu-coroutine-lock.c', 'qemu-cor= outine-io.c')) + util_ss.add(when: 'CONFIG_LINUX', if_true: files('vhost-user-server.c')) util_ss.add(files('qemu-coroutine-sleep.c')) util_ss.add(files('qemu-co-shared-resource.c')) util_ss.add(files('thread-pool.c', 'qemu-timer.c')) diff --git a/util/vhost-user-server.c b/util/vhost-user-server.c new file mode 100644 index 0000000000..7b50a2b1fd --- /dev/null +++ b/util/vhost-user-server.c @@ -0,0 +1,428 @@ +/* + * Sharing QEMU devices via vhost-user protocol + * + * Copyright (c) Coiby Xu . + * Copyright (c) 2020 Red Hat, Inc. + * + * This work is licensed under the terms of the GNU GPL, version 2 or + * later. See the COPYING file in the top-level directory. + */ +#include "qemu/osdep.h" +#include "qemu/main-loop.h" +#include "vhost-user-server.h" + +static void vmsg_close_fds(VhostUserMsg *vmsg) +{ + int i; + for (i =3D 0; i < vmsg->fd_num; i++) { + close(vmsg->fds[i]); + } +} + +static void vmsg_unblock_fds(VhostUserMsg *vmsg) +{ + int i; + for (i =3D 0; i < vmsg->fd_num; i++) { + qemu_set_nonblock(vmsg->fds[i]); + } +} + +static void vu_accept(QIONetListener *listener, QIOChannelSocket *sioc, + gpointer opaque); + +static void close_client(VuServer *server) +{ + /* + * Before closing the client + * + * 1. Let vu_client_trip stop processing new vhost-user msg + * + * 2. remove kick_handler + * + * 3. wait for the kick handler to be finished + * + * 4. wait for the current vhost-user msg to be finished processing + */ + + QIOChannelSocket *sioc =3D server->sioc; + /* When this is set vu_client_trip will stop new processing vhost-user= message */ + server->sioc =3D NULL; + + VuFdWatch *vu_fd_watch, *next; + QTAILQ_FOREACH_SAFE(vu_fd_watch, &server->vu_fd_watches, next, next) { + aio_set_fd_handler(server->ioc->ctx, vu_fd_watch->fd, true, NULL, + NULL, NULL, NULL); + } + + while (!QTAILQ_EMPTY(&server->vu_fd_watches)) { + QTAILQ_FOREACH_SAFE(vu_fd_watch, &server->vu_fd_watches, next, nex= t) { + if (!vu_fd_watch->processing) { + QTAILQ_REMOVE(&server->vu_fd_watches, vu_fd_watch, next); + g_free(vu_fd_watch); + } + } + } + + while (server->processing_msg) { + if (server->ioc->read_coroutine) { + server->ioc->read_coroutine =3D NULL; + qio_channel_set_aio_fd_handler(server->ioc, server->ioc->ctx, = NULL, + NULL, server->ioc); + server->processing_msg =3D false; + } + } + + vu_deinit(&server->vu_dev); + object_unref(OBJECT(sioc)); + object_unref(OBJECT(server->ioc)); +} + +static void panic_cb(VuDev *vu_dev, const char *buf) +{ + VuServer *server =3D container_of(vu_dev, VuServer, vu_dev); + + /* avoid while loop in close_client */ + server->processing_msg =3D false; + + if (buf) { + error_report("vu_panic: %s", buf); + } + + if (server->sioc) { + close_client(server); + } + + if (server->device_panic_notifier) { + server->device_panic_notifier(server); + } + + /* + * Set the callback function for network listener so another + * vhost-user client can connect to this server + */ + qio_net_listener_set_client_func(server->listener, + vu_accept, + server, + NULL); +} + +static bool coroutine_fn +vu_message_read(VuDev *vu_dev, int conn_fd, VhostUserMsg *vmsg) +{ + struct iovec iov =3D { + .iov_base =3D (char *)vmsg, + .iov_len =3D VHOST_USER_HDR_SIZE, + }; + int rc, read_bytes =3D 0; + Error *local_err =3D NULL; + /* + * Store fds/nfds returned from qio_channel_readv_full into + * temporary variables. + * + * VhostUserMsg is a packed structure, gcc will complain about passing + * pointer to a packed structure member if we pass &VhostUserMsg.fd_num + * and &VhostUserMsg.fds directly when calling qio_channel_readv_full, + * thus two temporary variables nfds and fds are used here. + */ + size_t nfds =3D 0, nfds_t =3D 0; + const size_t max_fds =3D G_N_ELEMENTS(vmsg->fds); + int *fds_t =3D NULL; + VuServer *server =3D container_of(vu_dev, VuServer, vu_dev); + QIOChannel *ioc =3D server->ioc; + + if (!ioc) { + error_report_err(local_err); + goto fail; + } + + assert(qemu_in_coroutine()); + do { + /* + * qio_channel_readv_full may have short reads, keeping calling it + * until getting VHOST_USER_HDR_SIZE or 0 bytes in total + */ + rc =3D qio_channel_readv_full(ioc, &iov, 1, &fds_t, &nfds_t, &loca= l_err); + if (rc < 0) { + if (rc =3D=3D QIO_CHANNEL_ERR_BLOCK) { + qio_channel_yield(ioc, G_IO_IN); + continue; + } else { + error_report_err(local_err); + return false; + } + } + read_bytes +=3D rc; + if (nfds_t > 0) { + if (nfds + nfds_t > max_fds) { + error_report("A maximum of %zu fds are allowed, " + "however got %lu fds now", + max_fds, nfds + nfds_t); + goto fail; + } + memcpy(vmsg->fds + nfds, fds_t, + nfds_t *sizeof(vmsg->fds[0])); + nfds +=3D nfds_t; + g_free(fds_t); + } + if (read_bytes =3D=3D VHOST_USER_HDR_SIZE || rc =3D=3D 0) { + break; + } + iov.iov_base =3D (char *)vmsg + read_bytes; + iov.iov_len =3D VHOST_USER_HDR_SIZE - read_bytes; + } while (true); + + vmsg->fd_num =3D nfds; + /* qio_channel_readv_full will make socket fds blocking, unblock them = */ + vmsg_unblock_fds(vmsg); + if (vmsg->size > sizeof(vmsg->payload)) { + error_report("Error: too big message request: %d, " + "size: vmsg->size: %u, " + "while sizeof(vmsg->payload) =3D %zu", + vmsg->request, vmsg->size, sizeof(vmsg->payload)); + goto fail; + } + + struct iovec iov_payload =3D { + .iov_base =3D (char *)&vmsg->payload, + .iov_len =3D vmsg->size, + }; + if (vmsg->size) { + rc =3D qio_channel_readv_all_eof(ioc, &iov_payload, 1, &local_err); + if (rc =3D=3D -1) { + error_report_err(local_err); + goto fail; + } + } + + return true; + +fail: + vmsg_close_fds(vmsg); + + return false; +} + + +static void vu_client_start(VuServer *server); +static coroutine_fn void vu_client_trip(void *opaque) +{ + VuServer *server =3D opaque; + + while (!server->aio_context_changed && server->sioc) { + server->processing_msg =3D true; + vu_dispatch(&server->vu_dev); + server->processing_msg =3D false; + } + + if (server->aio_context_changed && server->sioc) { + server->aio_context_changed =3D false; + vu_client_start(server); + } +} + +static void vu_client_start(VuServer *server) +{ + server->co_trip =3D qemu_coroutine_create(vu_client_trip, server); + aio_co_enter(server->ctx, server->co_trip); +} + +/* + * a wrapper for vu_kick_cb + * + * since aio_dispatch can only pass one user data pointer to the + * callback function, pack VuDev and pvt into a struct. Then unpack it + * and pass them to vu_kick_cb + */ +static void kick_handler(void *opaque) +{ + VuFdWatch *vu_fd_watch =3D opaque; + vu_fd_watch->processing =3D true; + vu_fd_watch->cb(vu_fd_watch->vu_dev, 0, vu_fd_watch->pvt); + vu_fd_watch->processing =3D false; +} + + +static VuFdWatch *find_vu_fd_watch(VuServer *server, int fd) +{ + + VuFdWatch *vu_fd_watch, *next; + QTAILQ_FOREACH_SAFE(vu_fd_watch, &server->vu_fd_watches, next, next) { + if (vu_fd_watch->fd =3D=3D fd) { + return vu_fd_watch; + } + } + return NULL; +} + +static void +set_watch(VuDev *vu_dev, int fd, int vu_evt, + vu_watch_cb cb, void *pvt) +{ + + VuServer *server =3D container_of(vu_dev, VuServer, vu_dev); + g_assert(vu_dev); + g_assert(fd >=3D 0); + g_assert(cb); + + VuFdWatch *vu_fd_watch =3D find_vu_fd_watch(server, fd); + + if (!vu_fd_watch) { + VuFdWatch *vu_fd_watch =3D g_new0(VuFdWatch, 1); + + QTAILQ_INSERT_TAIL(&server->vu_fd_watches, vu_fd_watch, next); + + vu_fd_watch->fd =3D fd; + vu_fd_watch->cb =3D cb; + qemu_set_nonblock(fd); + aio_set_fd_handler(server->ioc->ctx, fd, true, kick_handler, + NULL, NULL, vu_fd_watch); + vu_fd_watch->vu_dev =3D vu_dev; + vu_fd_watch->pvt =3D pvt; + } +} + + +static void remove_watch(VuDev *vu_dev, int fd) +{ + VuServer *server; + g_assert(vu_dev); + g_assert(fd >=3D 0); + + server =3D container_of(vu_dev, VuServer, vu_dev); + + VuFdWatch *vu_fd_watch =3D find_vu_fd_watch(server, fd); + + if (!vu_fd_watch) { + return; + } + aio_set_fd_handler(server->ioc->ctx, fd, true, NULL, NULL, NULL, NULL); + + QTAILQ_REMOVE(&server->vu_fd_watches, vu_fd_watch, next); + g_free(vu_fd_watch); +} + + +static void vu_accept(QIONetListener *listener, QIOChannelSocket *sioc, + gpointer opaque) +{ + VuServer *server =3D opaque; + + if (server->sioc) { + warn_report("Only one vhost-user client is allowed to " + "connect the server one time"); + return; + } + + if (!vu_init(&server->vu_dev, server->max_queues, sioc->fd, panic_cb, + vu_message_read, set_watch, remove_watch, server->vu_ifac= e)) { + error_report("Failed to initialize libvhost-user"); + return; + } + + /* + * Unset the callback function for network listener to make another + * vhost-user client keeping waiting until this client disconnects + */ + qio_net_listener_set_client_func(server->listener, + NULL, + NULL, + NULL); + server->sioc =3D sioc; + /* + * Increase the object reference, so sioc will not freed by + * qio_net_listener_channel_func which will call object_unref(OBJECT(s= ioc)) + */ + object_ref(OBJECT(server->sioc)); + qio_channel_set_name(QIO_CHANNEL(sioc), "vhost-user client"); + server->ioc =3D QIO_CHANNEL(sioc); + object_ref(OBJECT(server->ioc)); + qio_channel_attach_aio_context(server->ioc, server->ctx); + qio_channel_set_blocking(QIO_CHANNEL(server->sioc), false, NULL); + vu_client_start(server); +} + + +void vhost_user_server_stop(VuServer *server) +{ + if (server->sioc) { + close_client(server); + } + + if (server->listener) { + qio_net_listener_disconnect(server->listener); + object_unref(OBJECT(server->listener)); + } + +} + +void vhost_user_server_set_aio_context(VuServer *server, AioContext *ctx) +{ + VuFdWatch *vu_fd_watch, *next; + void *opaque =3D NULL; + IOHandler *io_read =3D NULL; + bool attach; + + server->ctx =3D ctx ? ctx : qemu_get_aio_context(); + + if (!server->sioc) { + /* not yet serving any client*/ + return; + } + + if (ctx) { + qio_channel_attach_aio_context(server->ioc, ctx); + server->aio_context_changed =3D true; + io_read =3D kick_handler; + attach =3D true; + } else { + qio_channel_detach_aio_context(server->ioc); + /* server->ioc->ctx keeps the old AioConext */ + ctx =3D server->ioc->ctx; + attach =3D false; + } + + QTAILQ_FOREACH_SAFE(vu_fd_watch, &server->vu_fd_watches, next, next) { + if (vu_fd_watch->cb) { + opaque =3D attach ? vu_fd_watch : NULL; + aio_set_fd_handler(ctx, vu_fd_watch->fd, true, + io_read, NULL, NULL, + opaque); + } + } +} + + +bool vhost_user_server_start(VuServer *server, + SocketAddress *socket_addr, + AioContext *ctx, + uint16_t max_queues, + DevicePanicNotifierFn *device_panic_notifier, + const VuDevIface *vu_iface, + Error **errp) +{ + QIONetListener *listener =3D qio_net_listener_new(); + if (qio_net_listener_open_sync(listener, socket_addr, 1, + errp) < 0) { + object_unref(OBJECT(listener)); + return false; + } + + /* zero out unspecified fileds */ + *server =3D (VuServer) { + .listener =3D listener, + .vu_iface =3D vu_iface, + .max_queues =3D max_queues, + .ctx =3D ctx, + .device_panic_notifier =3D device_panic_notifier, + }; + + qio_net_listener_set_name(server->listener, "vhost-user-backend-listen= er"); + + qio_net_listener_set_client_func(server->listener, + vu_accept, + server, + NULL); + + QTAILQ_INIT(&server->vu_fd_watches); + return true; +} diff --git a/util/vhost-user-server.h b/util/vhost-user-server.h new file mode 100644 index 0000000000..5232f96718 --- /dev/null +++ b/util/vhost-user-server.h @@ -0,0 +1,65 @@ +/* + * Sharing QEMU devices via vhost-user protocol + * + * Copyright (c) Coiby Xu . + * Copyright (c) 2020 Red Hat, Inc. + * + * This work is licensed under the terms of the GNU GPL, version 2 or + * later. See the COPYING file in the top-level directory. + */ + +#ifndef VHOST_USER_SERVER_H +#define VHOST_USER_SERVER_H + +#include "contrib/libvhost-user/libvhost-user.h" +#include "io/channel-socket.h" +#include "io/channel-file.h" +#include "io/net-listener.h" +#include "qemu/error-report.h" +#include "qapi/error.h" +#include "standard-headers/linux/virtio_blk.h" + +typedef struct VuFdWatch { + VuDev *vu_dev; + int fd; /*kick fd*/ + void *pvt; + vu_watch_cb cb; + bool processing; + QTAILQ_ENTRY(VuFdWatch) next; +} VuFdWatch; + +typedef struct VuServer VuServer; +typedef void DevicePanicNotifierFn(VuServer *server); + +struct VuServer { + QIONetListener *listener; + AioContext *ctx; + DevicePanicNotifierFn *device_panic_notifier; + int max_queues; + const VuDevIface *vu_iface; + VuDev vu_dev; + QIOChannel *ioc; /* The I/O channel with the client */ + QIOChannelSocket *sioc; /* The underlying data channel with the client= */ + /* IOChannel for fd provided via VHOST_USER_SET_SLAVE_REQ_FD */ + QIOChannel *ioc_slave; + QIOChannelSocket *sioc_slave; + Coroutine *co_trip; /* coroutine for processing VhostUserMsg */ + QTAILQ_HEAD(, VuFdWatch) vu_fd_watches; + /* restart coroutine co_trip if AIOContext is changed */ + bool aio_context_changed; + bool processing_msg; +}; + +bool vhost_user_server_start(VuServer *server, + SocketAddress *unix_socket, + AioContext *ctx, + uint16_t max_queues, + DevicePanicNotifierFn *device_panic_notifier, + const VuDevIface *vu_iface, + Error **errp); + +void vhost_user_server_stop(VuServer *server); + +void vhost_user_server_set_aio_context(VuServer *server, AioContext *ctx); + +#endif /* VHOST_USER_SERVER_H */ --=20 2.28.0 From nobody Sat Apr 27 06:57:47 2024 Delivered-To: importer@patchew.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=1600416826; cv=none; d=zohomail.com; s=zohoarc; b=JBJ+7jfv7F+dlKn76QMEGgSnfwlZtfmLwTd+TPfjAn5la7sIIJUUdrwcBnN9sdWjgogNAXIvuP5R+DaD68CC2RASWENJw+5dNDxGR0lTwKqm/YRYdVEw1Fq/piSMND0x4XKpnCEAHLULXUGdioerBjNMWMqm00HlVN7LhRqEj/g= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1600416826; 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=yUm7gzqU0gkfA8vc3e03aOvHIouNKIgGnZpyrZReg0k=; b=ZUWdT4qp+ilca3uPzskit+rBlrQfbkGoPKOXWZcq+M4ElpHojsqDKIIbncsaoHoGd0rnymeElD5+/wGCWWFPOoEAZUFeRNypUEIvmOtCAA49H5ineEr5IhfeNV0iUwHGxxaHndYAFQ1gAtYAQEoMXRSwnGJtPJyY1gyTQVmZBMc= 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 1600416826567753.11458053716; Fri, 18 Sep 2020 01:13:46 -0700 (PDT) Received: from localhost ([::1]:44146 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1kJBWb-0005jq-Ah for importer@patchew.org; Fri, 18 Sep 2020 04:13:45 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:56976) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1kJBSo-0000EZ-5w for qemu-devel@nongnu.org; Fri, 18 Sep 2020 04:09:50 -0400 Received: from mail-pj1-x1042.google.com ([2607:f8b0:4864:20::1042]:56094) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1kJBSm-0003Hc-2o for qemu-devel@nongnu.org; Fri, 18 Sep 2020 04:09:49 -0400 Received: by mail-pj1-x1042.google.com with SMTP id q4so2747603pjh.5 for ; Fri, 18 Sep 2020 01:09:47 -0700 (PDT) Received: from localhost ([2001:e42:102:1532:160:16:113:140]) by smtp.gmail.com with ESMTPSA id 84sm2238565pfw.14.2020.09.18.01.09.45 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 18 Sep 2020 01:09:46 -0700 (PDT) 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=yUm7gzqU0gkfA8vc3e03aOvHIouNKIgGnZpyrZReg0k=; b=azVw8s3PGlgUQCwoBI10t9OTwGuza4p599/kR29GLkHfn/rr5HtsRc913GgHbveOL1 BwXzZlMBmrXyykoHTfl+bSdbMdrUIujnPH4evrF9FwX0t60mgW9cSHD7a6IeCmW88GY+ nn3gIdntvxVrCcjDMFB9ML853OpmLtX9Aj+07L7AP7cvg0sQDvZWYlsaxdAiY+efvuDS e1wxnMA6+Q6PbzpSPQ6zQKb9P23sMkEeCyraYK9607wGkOinMYdONrSTNxzezp9l+5Sj x1FdlzIZIMLDVtJDP4uzmmMm4OqWqvIjvL2C00ebda+5ehsO2dd8RPmNHD98GvIdVrgY 5RhQ== 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=yUm7gzqU0gkfA8vc3e03aOvHIouNKIgGnZpyrZReg0k=; b=W7zG5KpLwxMdh9tDfgD20HrUJA/7WhdNtunUHxDYL1okHa4o4UmARC5CTsXUNTN5YZ skBiuyGRMfMshOdJKvYCjXGWQhQ4hUDAY8n1DRF9FFF0Dv6Q9HyCnQx3jtgLl3skwSMk uSVjINPI/QdramxnqgvH2cKyDxEyqmitgZTWjuWqv2tXWXy5DKJGNKJGnUz2tR33QxKC ftV+thcJFo8RbVZSqaBAvR0vvnYxnPNLEGffqmdl/2D1rFRXe+PiRgyPnfpr68D3XmTf pBlwznCowgBtz9Hun2DSE/SQHTi5JffFLLohCEDOlFUn76M5V9rwLFOVc5GFcYj4dmsj +Vgw== X-Gm-Message-State: AOAM530uR9rGww4650e+eDNF9Dg/5czdv1ex0tW6Cs8uDY8bSGVnzD6v Kp5eAfxDTAN3jUDAciz3F0xNk8sGKrG/OARe X-Google-Smtp-Source: ABdhPJyg95Xe2gACiSCCRtRuWRWQLNIeIUzBaPIZl060vfwjAyMVAOcNG6L6WaMcyrku2KTjh92ieA== X-Received: by 2002:a17:90a:c20f:: with SMTP id e15mr11498187pjt.163.1600416586513; Fri, 18 Sep 2020 01:09:46 -0700 (PDT) From: Coiby Xu To: qemu-devel@nongnu.org Subject: [PATCH v10 4/7] block: move logical block size check function to a common utility function Date: Fri, 18 Sep 2020 16:09:09 +0800 Message-Id: <20200918080912.321299-5-coiby.xu@gmail.com> X-Mailer: git-send-email 2.28.0 In-Reply-To: <20200918080912.321299-1-coiby.xu@gmail.com> References: <20200918080912.321299-1-coiby.xu@gmail.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2607:f8b0:4864:20::1042; envelope-from=coiby.xu@gmail.com; helo=mail-pj1-x1042.google.com X-detected-operating-system: by eggs.gnu.org: No matching host in p0f cache. That's all we know. X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, FREEMAIL_FROM=0.001, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: kwolf@redhat.com, =?UTF-8?q?Daniel=20P=2E=20Berrang=C3=A9?= , Eduardo Habkost , bharatlkmlkvm@gmail.com, stefanha@redhat.com, Paolo Bonzini 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" Move the constants from hw/core/qdev-properties.c to util/block-helpers.h so that knowledge of the min/max values is Signed-off-by: Stefan Hajnoczi Signed-off-by: Coiby Xu Acked-by: Eduardo Habkost Reviewed-by: Stefan Hajnoczi --- hw/core/qdev-properties.c | 31 +++++--------------------- util/block-helpers.c | 46 +++++++++++++++++++++++++++++++++++++++ util/block-helpers.h | 19 ++++++++++++++++ util/meson.build | 1 + 4 files changed, 71 insertions(+), 26 deletions(-) create mode 100644 util/block-helpers.c create mode 100644 util/block-helpers.h diff --git a/hw/core/qdev-properties.c b/hw/core/qdev-properties.c index 098298c78e..e6ffd80b36 100644 --- a/hw/core/qdev-properties.c +++ b/hw/core/qdev-properties.c @@ -16,6 +16,7 @@ #include "qemu/uuid.h" #include "qemu/units.h" #include "qemu/cutils.h" +#include "util/block-helpers.h" =20 void qdev_prop_set_after_realize(DeviceState *dev, const char *name, Error **errp) @@ -851,16 +852,6 @@ const PropertyInfo qdev_prop_size32 =3D { =20 /* --- blocksize --- */ =20 -/* lower limit is sector size */ -#define MIN_BLOCK_SIZE 512 -#define MIN_BLOCK_SIZE_STR "512 B" -/* - * upper limit is arbitrary, 2 MiB looks sufficient for all sensible uses,= and - * matches qcow2 cluster size limit - */ -#define MAX_BLOCK_SIZE (2 * MiB) -#define MAX_BLOCK_SIZE_STR "2 MiB" - static void set_blocksize(Object *obj, Visitor *v, const char *name, void *opaque, Error **errp) { @@ -868,6 +859,7 @@ static void set_blocksize(Object *obj, Visitor *v, cons= t char *name, Property *prop =3D opaque; uint32_t *ptr =3D qdev_get_prop_ptr(dev, prop); uint64_t value; + Error *local_err =3D NULL; =20 if (dev->realized) { qdev_prop_set_after_realize(dev, name, errp); @@ -877,24 +869,11 @@ static void set_blocksize(Object *obj, Visitor *v, co= nst char *name, if (!visit_type_size(v, name, &value, errp)) { return; } - /* value of 0 means "unset" */ - if (value && (value < MIN_BLOCK_SIZE || value > MAX_BLOCK_SIZE)) { - error_setg(errp, - "Property %s.%s doesn't take value %" PRIu64 - " (minimum: " MIN_BLOCK_SIZE_STR - ", maximum: " MAX_BLOCK_SIZE_STR ")", - dev->id ? : "", name, value); - return; - } - - /* We rely on power-of-2 blocksizes for bitmasks */ - if ((value & (value - 1)) !=3D 0) { - error_setg(errp, - "Property %s.%s doesn't take value '%" PRId64 "', it's n= ot a power of 2", - dev->id ?: "", name, (int64_t)value); + check_block_size(dev->id ? : "", name, value, &local_err); + if (local_err) { + error_propagate(errp, local_err); return; } - *ptr =3D value; } =20 diff --git a/util/block-helpers.c b/util/block-helpers.c new file mode 100644 index 0000000000..c4851432f5 --- /dev/null +++ b/util/block-helpers.c @@ -0,0 +1,46 @@ +/* + * Block utility functions + * + * Copyright IBM, Corp. 2011 + * Copyright (c) 2020 Coiby Xu + * + * 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 "qapi/error.h" +#include "qapi/qmp/qerror.h" +#include "block-helpers.h" + +/** + * check_block_size: + * @id: The unique ID of the object + * @name: The name of the property being validated + * @value: The block size in bytes + * @errp: A pointer to an area to store an error + * + * This function checks that the block size meets the following conditions: + * 1. At least MIN_BLOCK_SIZE + * 2. No larger than MAX_BLOCK_SIZE + * 3. A power of 2 + */ +void check_block_size(const char *id, const char *name, int64_t value, + Error **errp) +{ + /* value of 0 means "unset" */ + if (value && (value < MIN_BLOCK_SIZE || value > MAX_BLOCK_SIZE)) { + error_setg(errp, QERR_PROPERTY_VALUE_OUT_OF_RANGE, + id, name, value, MIN_BLOCK_SIZE, MAX_BLOCK_SIZE); + return; + } + + /* We rely on power-of-2 blocksizes for bitmasks */ + if ((value & (value - 1)) !=3D 0) { + error_setg(errp, + "Property %s.%s doesn't take value '%" PRId64 + "', it's not a power of 2", + id, name, value); + return; + } +} diff --git a/util/block-helpers.h b/util/block-helpers.h new file mode 100644 index 0000000000..b53295a529 --- /dev/null +++ b/util/block-helpers.h @@ -0,0 +1,19 @@ +#ifndef BLOCK_HELPERS_H +#define BLOCK_HELPERS_H + +#include "qemu/units.h" + +/* lower limit is sector size */ +#define MIN_BLOCK_SIZE INT64_C(512) +#define MIN_BLOCK_SIZE_STR "512 B" +/* + * upper limit is arbitrary, 2 MiB looks sufficient for all sensible uses,= and + * matches qcow2 cluster size limit + */ +#define MAX_BLOCK_SIZE (2 * MiB) +#define MAX_BLOCK_SIZE_STR "2 MiB" + +void check_block_size(const char *id, const char *name, int64_t value, + Error **errp); + +#endif /* BLOCK_HELPERS_H */ diff --git a/util/meson.build b/util/meson.build index 3921981ccf..2296e81b34 100644 --- a/util/meson.build +++ b/util/meson.build @@ -67,6 +67,7 @@ if have_block util_ss.add(files('nvdimm-utils.c')) util_ss.add(files('qemu-coroutine.c', 'qemu-coroutine-lock.c', 'qemu-cor= outine-io.c')) util_ss.add(when: 'CONFIG_LINUX', if_true: files('vhost-user-server.c')) + util_ss.add(files('block-helpers.c')) util_ss.add(files('qemu-coroutine-sleep.c')) util_ss.add(files('qemu-co-shared-resource.c')) util_ss.add(files('thread-pool.c', 'qemu-timer.c')) --=20 2.28.0 From nobody Sat Apr 27 06:57:47 2024 Delivered-To: importer@patchew.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=1600416869; cv=none; d=zohomail.com; s=zohoarc; b=GA74YuI8pUeMsxPl4pQJu5AdO9W+IkOFdPbsMNU7wtNo4/hYG5F52WUwkAHq5m8Yu/VFWrq2Nlljhp/5nmdj89/EKq4oB6Ue//GgPrtSldkADo49BEzaBPGvlSTSUkqa/ZthD4jJ2e0YfT68F52e4qKpFgaeYDi7Jv41ciKHdtc= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1600416869; 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=sB5Ctj0l7wFscHPpq7CgzTDJHloGrNgiu9Jnr13cFTc=; b=Tn7wBwAGNfmu8p6BrvroCSn3B3N8BsygNgmcRjSZ0YXf9zZITezmo0Itn+RZsgIvOAGhzgo6WwClGSuWPacI9R6g2udy4GOceEW70ZfXAOszUUEc7zqWnJUt3Gjtjo/LfYox0Cq8fOlKy8r23RBA7itkQ9aUumNUwjJ8UNfmc8Y= 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 1600416869066912.6251917739352; Fri, 18 Sep 2020 01:14:29 -0700 (PDT) Received: from localhost ([::1]:47294 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1kJBXF-00070q-Er for importer@patchew.org; Fri, 18 Sep 2020 04:14:25 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:56988) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1kJBSw-0000X9-3A; Fri, 18 Sep 2020 04:10:01 -0400 Received: from mail-pl1-x62f.google.com ([2607:f8b0:4864:20::62f]:34213) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1kJBSt-0003IB-6X; Fri, 18 Sep 2020 04:09:57 -0400 Received: by mail-pl1-x62f.google.com with SMTP id r19so2605054pls.1; Fri, 18 Sep 2020 01:09:54 -0700 (PDT) Received: from localhost ([2001:e42:102:1532:160:16:113:140]) by smtp.gmail.com with ESMTPSA id v204sm2177314pfc.10.2020.09.18.01.09.51 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 18 Sep 2020 01:09:52 -0700 (PDT) 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=sB5Ctj0l7wFscHPpq7CgzTDJHloGrNgiu9Jnr13cFTc=; b=GTjaI2XdqFZJ3E+80w3YCA291+Mo2B07evQ5AQ1Y5KxU9YjAETm4PFoZVa90gGaNZZ KOwx4QwEp0YJfCg2oAXvLc9pZs2hb2iTk8hJ1ANDRSK3OowYJfZy21T5UFv0pPVC9Gn0 trvTWJG6IpPO+XdOX9xaBu4+XQLtAAEAYrBxYCcsmmdEk3qhL5mhlz38eK1fcCgo6/gi 3QkTXq7iZlEVqOroY1oms0cuuA2LPqxhD6EEqF7aN/YuMnC3nUDBjn5d8uHQ5N9XTvkG JfPPjPb4HEC5RdyiOos7XJrasrCGKv+m4348oJWv6cgGEGvqlRLEJ2XGsAadEO1NjfPB POhA== 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=sB5Ctj0l7wFscHPpq7CgzTDJHloGrNgiu9Jnr13cFTc=; b=JVO86IoBRp9T2vz21x25ZJ9pag39Gw3PSJooH8BhRdywed/5fCMdsIhWipmGs2Zbca ea/k2pRzxj5rqKH6EnyAO02s/x70xVVAlE5FfQjMccAt9dKBfveTvA9ZVB2JEeaqQkrv c7S6jcalyI5qwpYX2U6iZeezEM86TTWxzICItd6A82FgWR2to8mh2nP11ilJcS6idfOz R3NP+cmfDy5ca1I+TZfySjV1kBHyVqHlCLSW7gOVOIHffpZtRQgw/o5E3qao1cB6um1/ 3nVd2TRjNCJG7YynBmRQVuF6HAES9i3DYlxYxVLYpkGc9vAoxUAgjLpNqJN+nJMu/yAi XD/Q== X-Gm-Message-State: AOAM5319leFfAvI7fZyShq0EXmGxbyf7p2RcSG8J5gbxTwuCQMpI27QZ nE9qP1ZD+ttsZzdNl6fYZbqY1qMdZUn2wL58 X-Google-Smtp-Source: ABdhPJzxph+VihBiu9+J26jxS+nMt9FMgDDVxT0dxQGpol3wQ0BN+WFgudyGdpbPcCaKoZwYq8RKYQ== X-Received: by 2002:a17:90a:eac5:: with SMTP id ev5mr11404177pjb.200.1600416592959; Fri, 18 Sep 2020 01:09:52 -0700 (PDT) From: Coiby Xu To: qemu-devel@nongnu.org Subject: [PATCH v10 5/7] block/export: vhost-user block device backend server Date: Fri, 18 Sep 2020 16:09:10 +0800 Message-Id: <20200918080912.321299-6-coiby.xu@gmail.com> X-Mailer: git-send-email 2.28.0 In-Reply-To: <20200918080912.321299-1-coiby.xu@gmail.com> References: <20200918080912.321299-1-coiby.xu@gmail.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2607:f8b0:4864:20::62f; envelope-from=coiby.xu@gmail.com; helo=mail-pl1-x62f.google.com X-detected-operating-system: by eggs.gnu.org: No matching host in p0f cache. That's all we know. X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, FREEMAIL_FROM=0.001, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: kwolf@redhat.com, "open list:Block layer core" , Coiby Xu , Max Reitz , bharatlkmlkvm@gmail.com, stefanha@redhat.com, Paolo Bonzini 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-user, block device drive can be shared to the connected vhost-user client. Only one client can connect to the server one time. Since vhost-user-server needs a block drive to be created first, delay the creation of this object. Suggested-by: Kevin Wolf Signed-off-by: Stefan Hajnoczi Signed-off-by: Coiby Xu Reviewed-by: Stefan Hajnoczi --- block/export/vhost-user-blk-server.c | 661 +++++++++++++++++++++++++++ block/export/vhost-user-blk-server.h | 36 ++ block/meson.build | 1 + softmmu/vl.c | 4 + 4 files changed, 702 insertions(+) create mode 100644 block/export/vhost-user-blk-server.c create mode 100644 block/export/vhost-user-blk-server.h diff --git a/block/export/vhost-user-blk-server.c b/block/export/vhost-user= -blk-server.c new file mode 100644 index 0000000000..ec78130f09 --- /dev/null +++ b/block/export/vhost-user-blk-server.c @@ -0,0 +1,661 @@ +/* + * Sharing QEMU block devices via vhost-user protocal + * + * Parts of the code based on nbd/server.c. + * + * Copyright (c) Coiby Xu . + * Copyright (c) 2020 Red Hat, Inc. + * + * This work is licensed under the terms of the GNU GPL, version 2 or + * later. See the COPYING file in the top-level directory. + */ +#include "qemu/osdep.h" +#include "block/block.h" +#include "vhost-user-blk-server.h" +#include "qapi/error.h" +#include "qom/object_interfaces.h" +#include "sysemu/block-backend.h" +#include "util/block-helpers.h" + +enum { + VHOST_USER_BLK_MAX_QUEUES =3D 1, +}; +struct virtio_blk_inhdr { + unsigned char status; +}; + +typedef struct VuBlockReq { + VuVirtqElement *elem; + int64_t sector_num; + size_t size; + struct virtio_blk_inhdr *in; + struct virtio_blk_outhdr out; + VuServer *server; + struct VuVirtq *vq; +} VuBlockReq; + +static void vu_block_req_complete(VuBlockReq *req) +{ + VuDev *vu_dev =3D &req->server->vu_dev; + + /* 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 VuBlockDev *get_vu_block_device_by_server(VuServer *server) +{ + return container_of(server, VuBlockDev, vu_server); +} + +static int coroutine_fn +vu_block_discard_write_zeroes(VuBlockReq *req, struct iovec *iov, + uint32_t iovcnt, uint32_t type) +{ + struct virtio_blk_discard_write_zeroes desc; + ssize_t size =3D iov_to_buf(iov, iovcnt, 0, &desc, sizeof(desc)); + if (unlikely(size !=3D sizeof(desc))) { + error_report("Invalid size %ld, expect %ld", size, sizeof(desc)); + return -EINVAL; + } + + VuBlockDev *vdev_blk =3D get_vu_block_device_by_server(req->server); + uint64_t range[2] =3D { le64_to_cpu(desc.sector) << 9, + le32_to_cpu(desc.num_sectors) << 9 }; + if (type =3D=3D VIRTIO_BLK_T_DISCARD) { + if (blk_co_pdiscard(vdev_blk->backend, range[0], range[1]) =3D=3D = 0) { + return 0; + } + } else if (type =3D=3D VIRTIO_BLK_T_WRITE_ZEROES) { + if (blk_co_pwrite_zeroes(vdev_blk->backend, + range[0], range[1], 0) =3D=3D 0) { + return 0; + } + } + + return -EINVAL; +} + +static void coroutine_fn vu_block_flush(VuBlockReq *req) +{ + VuBlockDev *vdev_blk =3D get_vu_block_device_by_server(req->server); + BlockBackend *backend =3D vdev_blk->backend; + blk_co_flush(backend); +} + +struct req_data { + VuServer *server; + VuVirtq *vq; + VuVirtqElement *elem; +}; + +static void coroutine_fn vu_block_virtio_process_req(void *opaque) +{ + struct req_data *data =3D opaque; + VuServer *server =3D data->server; + VuVirtq *vq =3D data->vq; + VuVirtqElement *elem =3D data->elem; + uint32_t type; + VuBlockReq *req; + + VuBlockDev *vdev_blk =3D get_vu_block_device_by_server(server); + BlockBackend *backend =3D vdev_blk->backend; + + 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) { + error_report("virtio-blk request missing headers"); + free(elem); + return; + } + + req =3D g_new0(VuBlockReq, 1); + req->server =3D server; + 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))) { + error_report("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)) { + error_report("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 le32_to_cpu(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 le64_to_cpu(req->out.sector); + + int64_t offset =3D req->sector_num * vdev_blk->blk_size; + QEMUIOVector qiov; + if (is_write) { + qemu_iovec_init_external(&qiov, out_iov, out_num); + ret =3D blk_co_pwritev(backend, offset, qiov.size, + &qiov, 0); + } else { + qemu_iovec_init_external(&qiov, in_iov, in_num); + ret =3D blk_co_preadv(backend, offset, qiov.size, + &qiov, 0); + } + if (ret >=3D 0) { + req->in->status =3D VIRTIO_BLK_S_OK; + } else { + req->in->status =3D VIRTIO_BLK_S_IOERR; + } + break; + } + case VIRTIO_BLK_T_FLUSH: + vu_block_flush(req); + req->in->status =3D VIRTIO_BLK_S_OK; + 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_serv= er"); + req->in->status =3D VIRTIO_BLK_S_OK; + req->size =3D elem->in_sg[0].iov_len; + break; + } + case VIRTIO_BLK_T_DISCARD: + case VIRTIO_BLK_T_WRITE_ZEROES: { + int rc; + rc =3D vu_block_discard_write_zeroes(req, &elem->out_sg[1], + out_num, type); + if (rc =3D=3D 0) { + req->in->status =3D VIRTIO_BLK_S_OK; + } else { + req->in->status =3D VIRTIO_BLK_S_IOERR; + } + break; + } + default: + req->in->status =3D VIRTIO_BLK_S_UNSUPP; + break; + } + + vu_block_req_complete(req); + return; + +err: + free(elem); + g_free(req); + return; +} + +static void vu_block_process_vq(VuDev *vu_dev, int idx) +{ + VuServer *server; + VuVirtq *vq; + struct req_data *req_data; + + server =3D container_of(vu_dev, VuServer, vu_dev); + assert(server); + + vq =3D vu_get_queue(vu_dev, idx); + assert(vq); + VuVirtqElement *elem; + while (1) { + elem =3D vu_queue_pop(vu_dev, vq, sizeof(VuVirtqElement) + + sizeof(VuBlockReq)); + if (elem) { + req_data =3D g_new0(struct req_data, 1); + req_data->server =3D server; + req_data->vq =3D vq; + req_data->elem =3D elem; + Coroutine *co =3D qemu_coroutine_create(vu_block_virtio_proces= s_req, + req_data); + aio_co_enter(server->ioc->ctx, co); + } else { + break; + } + } +} + +static void vu_block_queue_set_started(VuDev *vu_dev, int idx, bool starte= d) +{ + VuVirtq *vq; + + assert(vu_dev); + + vq =3D vu_get_queue(vu_dev, idx); + vu_set_queue_handler(vu_dev, vq, started ? vu_block_process_vq : NULL); +} + +static uint64_t vu_block_get_features(VuDev *dev) +{ + uint64_t features; + VuServer *server =3D container_of(dev, VuServer, vu_dev); + VuBlockDev *vdev_blk =3D get_vu_block_device_by_server(server); + 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 | + 1ull << VIRTIO_BLK_F_DISCARD | + 1ull << VIRTIO_BLK_F_WRITE_ZEROES | + 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 vu_block_get_protocol_features(VuDev *dev) +{ + return 1ull << VHOST_USER_PROTOCOL_F_CONFIG | + 1ull << VHOST_USER_PROTOCOL_F_INFLIGHT_SHMFD; +} + +static int +vu_block_get_config(VuDev *vu_dev, uint8_t *config, uint32_t len) +{ + VuServer *server =3D container_of(vu_dev, VuServer, vu_dev); + VuBlockDev *vdev_blk =3D get_vu_block_device_by_server(server); + memcpy(config, &vdev_blk->blkcfg, len); + + return 0; +} + +static int +vu_block_set_config(VuDev *vu_dev, const uint8_t *data, + uint32_t offset, uint32_t size, uint32_t flags) +{ + VuServer *server =3D container_of(vu_dev, VuServer, vu_dev); + VuBlockDev *vdev_blk =3D get_vu_block_device_by_server(server); + uint8_t wce; + + /* don't support live migration */ + if (flags !=3D VHOST_SET_CONFIG_TYPE_MASTER) { + return -EINVAL; + } + + if (offset !=3D offsetof(struct virtio_blk_config, wce) || + size !=3D 1) { + return -EINVAL; + } + + wce =3D *data; + vdev_blk->blkcfg.wce =3D wce; + blk_set_enable_write_cache(vdev_blk->backend, wce); + return 0; +} + +/* + * When the client disconnects, it sends 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 vu_block_process_msg(VuDev *dev, VhostUserMsg *vmsg, int *do_re= ply) +{ + if (vmsg->request =3D=3D VHOST_USER_NONE) { + dev->panic(dev, "disconnect"); + return true; + } + return false; +} + +static const VuDevIface vu_block_iface =3D { + .get_features =3D vu_block_get_features, + .queue_set_started =3D vu_block_queue_set_started, + .get_protocol_features =3D vu_block_get_protocol_features, + .get_config =3D vu_block_get_config, + .set_config =3D vu_block_set_config, + .process_msg =3D vu_block_process_msg, +}; + +static void blk_aio_attached(AioContext *ctx, void *opaque) +{ + VuBlockDev *vub_dev =3D opaque; + aio_context_acquire(ctx); + vhost_user_server_set_aio_context(&vub_dev->vu_server, ctx); + aio_context_release(ctx); +} + +static void blk_aio_detach(void *opaque) +{ + VuBlockDev *vub_dev =3D opaque; + AioContext *ctx =3D vub_dev->vu_server.ctx; + aio_context_acquire(ctx); + vhost_user_server_set_aio_context(&vub_dev->vu_server, NULL); + aio_context_release(ctx); +} + +static void +vu_block_initialize_config(BlockDriverState *bs, + struct virtio_blk_config *config, uint32_t blk_= size) +{ + config->capacity =3D bdrv_getlength(bs) >> BDRV_SECTOR_BITS; + config->blk_size =3D blk_size; + config->size_max =3D 0; + config->seg_max =3D 128 - 2; + config->min_io_size =3D 1; + config->opt_io_size =3D 1; + config->num_queues =3D VHOST_USER_BLK_MAX_QUEUES; + 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; +} + +static VuBlockDev *vu_block_init(VuBlockDev *vu_block_device, Error **errp) +{ + + BlockBackend *blk; + Error *local_error =3D NULL; + const char *node_name =3D vu_block_device->node_name; + bool writable =3D vu_block_device->writable; + uint64_t perm =3D BLK_PERM_CONSISTENT_READ; + int ret; + + AioContext *ctx; + + BlockDriverState *bs =3D bdrv_lookup_bs(node_name, node_name, &local_e= rror); + + if (!bs) { + error_propagate(errp, local_error); + 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); + + /* + * Don't allow resize while the vhost user server is running, + * otherwise we don't care what happens with the node. + */ + 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); + + vu_block_device->blkcfg.wce =3D 0; + vu_block_device->backend =3D blk; + if (!vu_block_device->blk_size) { + vu_block_device->blk_size =3D BDRV_SECTOR_SIZE; + } + vu_block_device->blkcfg.blk_size =3D vu_block_device->blk_size; + blk_set_guest_block_size(blk, vu_block_device->blk_size); + vu_block_initialize_config(bs, &vu_block_device->blkcfg, + vu_block_device->blk_size); + return vu_block_device; + +fail: + blk_unref(blk); + return NULL; +} + +static void vu_block_deinit(VuBlockDev *vu_block_device) +{ + if (vu_block_device->backend) { + blk_remove_aio_context_notifier(vu_block_device->backend, blk_aio_= attached, + blk_aio_detach, vu_block_device); + } + + blk_unref(vu_block_device->backend); +} + +static void vhost_user_blk_server_stop(VuBlockDev *vu_block_device) +{ + vhost_user_server_stop(&vu_block_device->vu_server); + vu_block_deinit(vu_block_device); +} + +static void vhost_user_blk_server_start(VuBlockDev *vu_block_device, + Error **errp) +{ + AioContext *ctx; + SocketAddress *addr =3D vu_block_device->addr; + + if (!vu_block_init(vu_block_device, errp)) { + return; + } + + ctx =3D bdrv_get_aio_context(blk_bs(vu_block_device->backend)); + + if (!vhost_user_server_start(&vu_block_device->vu_server, addr, ctx, + VHOST_USER_BLK_MAX_QUEUES, + NULL, &vu_block_iface, + errp)) { + goto error; + } + + blk_add_aio_context_notifier(vu_block_device->backend, blk_aio_attache= d, + blk_aio_detach, vu_block_device); + vu_block_device->running =3D true; + return; + + error: + vu_block_deinit(vu_block_device); +} + +static bool vu_prop_modifiable(VuBlockDev *vus, Error **errp) +{ + if (vus->running) { + error_setg(errp, "The property can't be modified " + "while the server is running"); + return false; + } + return true; +} + +static void vu_set_node_name(Object *obj, const char *value, Error **errp) +{ + VuBlockDev *vus =3D VHOST_USER_BLK_SERVER(obj); + + if (!vu_prop_modifiable(vus, errp)) { + return; + } + + if (vus->node_name) { + g_free(vus->node_name); + } + + vus->node_name =3D g_strdup(value); +} + +static char *vu_get_node_name(Object *obj, Error **errp) +{ + VuBlockDev *vus =3D VHOST_USER_BLK_SERVER(obj); + return g_strdup(vus->node_name); +} + +static void free_socket_addr(SocketAddress *addr) +{ + g_free(addr->u.q_unix.path); + g_free(addr); +} + +static void vu_set_unix_socket(Object *obj, const char *value, + Error **errp) +{ + VuBlockDev *vus =3D VHOST_USER_BLK_SERVER(obj); + + if (!vu_prop_modifiable(vus, errp)) { + return; + } + + if (vus->addr) { + free_socket_addr(vus->addr); + } + + SocketAddress *addr =3D g_new0(SocketAddress, 1); + addr->type =3D SOCKET_ADDRESS_TYPE_UNIX; + addr->u.q_unix.path =3D g_strdup(value); + vus->addr =3D addr; +} + +static char *vu_get_unix_socket(Object *obj, Error **errp) +{ + VuBlockDev *vus =3D VHOST_USER_BLK_SERVER(obj); + return g_strdup(vus->addr->u.q_unix.path); +} + +static bool vu_get_block_writable(Object *obj, Error **errp) +{ + VuBlockDev *vus =3D VHOST_USER_BLK_SERVER(obj); + return vus->writable; +} + +static void vu_set_block_writable(Object *obj, bool value, Error **errp) +{ + VuBlockDev *vus =3D VHOST_USER_BLK_SERVER(obj); + + if (!vu_prop_modifiable(vus, errp)) { + return; + } + + vus->writable =3D value; +} + +static void vu_get_blk_size(Object *obj, Visitor *v, const char *name, + void *opaque, Error **errp) +{ + VuBlockDev *vus =3D VHOST_USER_BLK_SERVER(obj); + uint32_t value =3D vus->blk_size; + + visit_type_uint32(v, name, &value, errp); +} + +static void vu_set_blk_size(Object *obj, Visitor *v, const char *name, + void *opaque, Error **errp) +{ + VuBlockDev *vus =3D VHOST_USER_BLK_SERVER(obj); + + Error *local_err =3D NULL; + uint32_t value; + + if (!vu_prop_modifiable(vus, errp)) { + return; + } + + visit_type_uint32(v, name, &value, &local_err); + if (local_err) { + goto out; + } + + check_block_size(object_get_typename(obj), name, value, &local_err); + if (local_err) { + goto out; + } + + vus->blk_size =3D value; + +out: + error_propagate(errp, local_err); +} + +static void vhost_user_blk_server_instance_finalize(Object *obj) +{ + VuBlockDev *vub =3D VHOST_USER_BLK_SERVER(obj); + + vhost_user_blk_server_stop(vub); + + /* + * Unlike object_property_add_str, object_class_property_add_str + * doesn't have a release method. Thus manual memory freeing is + * needed. + */ + free_socket_addr(vub->addr); + g_free(vub->node_name); +} + +static void vhost_user_blk_server_complete(UserCreatable *obj, Error **err= p) +{ + VuBlockDev *vub =3D VHOST_USER_BLK_SERVER(obj); + + vhost_user_blk_server_start(vub, errp); +} + +static void vhost_user_blk_server_class_init(ObjectClass *klass, + void *class_data) +{ + UserCreatableClass *ucc =3D USER_CREATABLE_CLASS(klass); + ucc->complete =3D vhost_user_blk_server_complete; + + object_class_property_add_bool(klass, "writable", + vu_get_block_writable, + vu_set_block_writable); + + object_class_property_add_str(klass, "node-name", + vu_get_node_name, + vu_set_node_name); + + object_class_property_add_str(klass, "unix-socket", + vu_get_unix_socket, + vu_set_unix_socket); + + object_class_property_add(klass, "logical-block-size", "uint32", + vu_get_blk_size, vu_set_blk_size, + NULL, NULL); +} + +static const TypeInfo vhost_user_blk_server_info =3D { + .name =3D TYPE_VHOST_USER_BLK_SERVER, + .parent =3D TYPE_OBJECT, + .instance_size =3D sizeof(VuBlockDev), + .instance_finalize =3D vhost_user_blk_server_instance_finalize, + .class_init =3D vhost_user_blk_server_class_init, + .interfaces =3D (InterfaceInfo[]) { + {TYPE_USER_CREATABLE}, + {} + }, +}; + +static void vhost_user_blk_server_register_types(void) +{ + type_register_static(&vhost_user_blk_server_info); +} + +type_init(vhost_user_blk_server_register_types) diff --git a/block/export/vhost-user-blk-server.h b/block/export/vhost-user= -blk-server.h new file mode 100644 index 0000000000..f06f37c4c8 --- /dev/null +++ b/block/export/vhost-user-blk-server.h @@ -0,0 +1,36 @@ +/* + * Sharing QEMU block devices via vhost-user protocal + * + * Copyright (c) Coiby Xu . + * Copyright (c) 2020 Red Hat, Inc. + * + * This work is licensed under the terms of the GNU GPL, version 2 or + * later. See the COPYING file in the top-level directory. + */ + +#ifndef VHOST_USER_BLK_SERVER_H +#define VHOST_USER_BLK_SERVER_H +#include "util/vhost-user-server.h" + +typedef struct VuBlockDev VuBlockDev; +#define TYPE_VHOST_USER_BLK_SERVER "vhost-user-blk-server" +#define VHOST_USER_BLK_SERVER(obj) \ + OBJECT_CHECK(VuBlockDev, obj, TYPE_VHOST_USER_BLK_SERVER) + +/* vhost user block device */ +struct VuBlockDev { + Object parent_obj; + char *node_name; + SocketAddress *addr; + AioContext *ctx; + VuServer vu_server; + bool running; + uint32_t blk_size; + BlockBackend *backend; + QIOChannelSocket *sioc; + QTAILQ_ENTRY(VuBlockDev) next; + struct virtio_blk_config blkcfg; + bool writable; +}; + +#endif /* VHOST_USER_BLK_SERVER_H */ diff --git a/block/meson.build b/block/meson.build index a3e56b7cd1..6c7d9400e4 100644 --- a/block/meson.build +++ b/block/meson.build @@ -60,6 +60,7 @@ block_ss.add(when: 'CONFIG_WIN32', if_true: files('file-w= in32.c', 'win32-aio.c') block_ss.add(when: 'CONFIG_POSIX', if_true: [files('file-posix.c'), coref,= iokit]) block_ss.add(when: 'CONFIG_LIBISCSI', if_true: files('iscsi-opts.c')) block_ss.add(when: 'CONFIG_LINUX', if_true: files('nvme.c')) +block_ss.add(when: 'CONFIG_LINUX', if_true: files('export/vhost-user-blk-s= erver.c', '../contrib/libvhost-user/libvhost-user.c')) block_ss.add(when: 'CONFIG_REPLICATION', if_true: files('replication.c')) block_ss.add(when: 'CONFIG_SHEEPDOG', if_true: files('sheepdog.c')) block_ss.add(when: ['CONFIG_LINUX_AIO', libaio], if_true: files('linux-aio= .c')) diff --git a/softmmu/vl.c b/softmmu/vl.c index f7b103467c..5128b81d40 100644 --- a/softmmu/vl.c +++ b/softmmu/vl.c @@ -2537,6 +2537,10 @@ static bool object_create_initial(const char *type, = QemuOpts *opts) } #endif =20 + /* Reason: vhost-user-blk-server property "node-name" */ + if (g_str_equal(type, "vhost-user-blk-server")) { + return false; + } /* * Reason: filter-* property "netdev" etc. */ --=20 2.28.0 From nobody Sat Apr 27 06:57:47 2024 Delivered-To: importer@patchew.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=1600416797; cv=none; d=zohomail.com; s=zohoarc; b=lQuy8RvgOsQlAi5lBzQpI4IHsugvudB3qddtmCdipi1ofnWV+D27cHCzRYURhy97Xlx8/kIJEaBU1Kx94c284rxmRfNRPpJukMAlyud4ShXgU/OTbAxhH/eX3Q/djTagzP7SOBpcxwA51+cSX887s7cMD7amD/AU52agX1OS5zQ= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1600416797; 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=JxOFM1l5IaT2r68oU1BvNASgHDlr4aohTALckm47hdM=; b=eBdqdMVdUjKe3r7gx44pINQIaFx/rKNvXW4qOnVuJ2WdjU/CcgUylWZHea4RKZAxHbxFkkHTdYVjOsLIoN5JiWQN7/A11NkMDxV1iP3Dfue2H5+zQ+NMNKeCKHBpLAU348nTdmdyMKSxGl3kJLM+FDegKzcF/di9sc44pwqgpns= 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 1600416797292322.238128139694; Fri, 18 Sep 2020 01:13:17 -0700 (PDT) Received: from localhost ([::1]:42754 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1kJBW7-0005AU-Q8 for importer@patchew.org; Fri, 18 Sep 2020 04:13:15 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:57016) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1kJBT3-0000iS-AZ for qemu-devel@nongnu.org; Fri, 18 Sep 2020 04:10:05 -0400 Received: from mail-pj1-x1035.google.com ([2607:f8b0:4864:20::1035]:38163) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1kJBSy-0003Io-Ux for qemu-devel@nongnu.org; Fri, 18 Sep 2020 04:10:04 -0400 Received: by mail-pj1-x1035.google.com with SMTP id u3so2617312pjr.3 for ; Fri, 18 Sep 2020 01:10:00 -0700 (PDT) Received: from localhost ([2001:e42:102:1532:160:16:113:140]) by smtp.gmail.com with ESMTPSA id w19sm2281911pfq.60.2020.09.18.01.09.56 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 18 Sep 2020 01:09:58 -0700 (PDT) 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=JxOFM1l5IaT2r68oU1BvNASgHDlr4aohTALckm47hdM=; b=t/hGb9RrSYF7vq1KBgEX660zLx2h4ZFbIsMUWMvt6QJ3zOEtdHF/i+YY7nlEDUfgNw GrP0fxVsQkKusmzKzno10lO8eFvem0n5Mfa/RW0y6IvCb0UvBs6FGtK5xoLexLuMAtva lPR2fuGh6u+HT3qjjuB2lPelD0tuU6v8/FG0VUI/synT8aRqzl+8r68wsknWV+DTjlee 1GIg8pZt3KVLRch7R4q3dgUFN8ka+kAMCYX5XNipy59zrFXboWSK3PQ9VVDLcmtjj8zb jFl/WkdUcN9PyAaku3Tki7n5jpcKzvNLJQ+8+cVb1nQhRSb+5eO0/ESWJBGyLk+eBoPr PrsA== 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=JxOFM1l5IaT2r68oU1BvNASgHDlr4aohTALckm47hdM=; b=fnbDO3Bk6QK/mjw1M7/VaoN55W6RewKR0r/luJyHrIL71jWrxgCodSBoMBuPqpLy5o i6nZOUyn0sLc1Ezft8fl3V5AAB7bUBVzShBZ2JoRKRH9cIvAMbZ6prdNuomabyCDlUz+ unsRRLwDDrU8D0wTyqwDYVN74PXjWv0X6tlnOnNj5XXuRufBNpTWUVw5sRhl0xJfXSvM 8VKsGP3O5L6Ry/txbfWUUPwHuK+plq1TmEFKo5b7jqk4hJyA70EmHLBCin0+s5WX5bAo FH5lxKprgrits9gU9A+fI5RBN133sLgDR/NuB8mqfNQc9U3iIsuC4H3oKEiPxFHjW7Wl krhg== X-Gm-Message-State: AOAM530KmSFnIJg2zXk3CPey/+CaizsMA6Lu4ZyEPVNsZp7N9cVAE9t4 JHatM85MJfg607ijQtNKY1ygNbf+v2y1EPH2 X-Google-Smtp-Source: ABdhPJy28dqmxN5ZbNTqWlAFz1ZT0oLoXKOt8LTRI+3pX/Kf87Fg8exZlxXLlbNvpFbM/CKzTbTitg== X-Received: by 2002:a17:90b:4b0b:: with SMTP id lx11mr12014051pjb.104.1600416598365; Fri, 18 Sep 2020 01:09:58 -0700 (PDT) From: Coiby Xu To: qemu-devel@nongnu.org Subject: [PATCH v10 6/7] test: new qTest case to test the vhost-user-blk-server Date: Fri, 18 Sep 2020 16:09:11 +0800 Message-Id: <20200918080912.321299-7-coiby.xu@gmail.com> X-Mailer: git-send-email 2.28.0 In-Reply-To: <20200918080912.321299-1-coiby.xu@gmail.com> References: <20200918080912.321299-1-coiby.xu@gmail.com> MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2607:f8b0:4864:20::1035; envelope-from=coiby.xu@gmail.com; helo=mail-pj1-x1035.google.com X-detected-operating-system: by eggs.gnu.org: No matching host in p0f cache. That's all we know. X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, FREEMAIL_FROM=0.001, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: kwolf@redhat.com, Laurent Vivier , Thomas Huth , Coiby Xu , bharatlkmlkvm@gmail.com, stefanha@redhat.com, Paolo Bonzini 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. Since vhost-user server can only server one client one time, two instances of vhost-user-blk-server are started by qemu-storage-daemon for the hotplug test. In order to not block scripts/tap-driver.pl, vhost-user-blk-server will send "quit" command to qemu-storage-daemon's QMP monitor. So a function is added to libqtest.c to establish socket connection with socket server. Suggested-by: Thomas Huth Signed-off-by: Coiby Xu Reviewed-by: Stefan Hajnoczi --- tests/qtest/libqos/libqtest.h | 17 + tests/qtest/libqos/meson.build | 1 + tests/qtest/libqos/vhost-user-blk.c | 129 +++++ tests/qtest/libqos/vhost-user-blk.h | 48 ++ tests/qtest/libqtest.c | 36 +- tests/qtest/meson.build | 4 +- tests/qtest/vhost-user-blk-test.c | 751 ++++++++++++++++++++++++++++ 7 files changed, 983 insertions(+), 3 deletions(-) create mode 100644 tests/qtest/libqos/vhost-user-blk.c create mode 100644 tests/qtest/libqos/vhost-user-blk.h create mode 100644 tests/qtest/vhost-user-blk-test.c diff --git a/tests/qtest/libqos/libqtest.h b/tests/qtest/libqos/libqtest.h index a6ee1654f2..2c20381cee 100644 --- a/tests/qtest/libqos/libqtest.h +++ b/tests/qtest/libqos/libqtest.h @@ -132,6 +132,23 @@ void qtest_qmp_send(QTestState *s, const char *fmt, ..= .) void qtest_qmp_send_raw(QTestState *s, const char *fmt, ...) GCC_FMT_ATTR(2, 3); =20 +/** + * qtest_socket_client: + * @server_socket_path: the socket server's path + * + * Connect to a socket server. + */ +int qtest_socket_client(char *server_socket_path); + +/** + * qtest_create_state_with_qmp_fd: + * @fd: socket fd + * + * Wrap socket fd in QTestState to make use of qtest_qmp* + * functions + */ +QTestState *qtest_create_state_with_qmp_fd(int fd); + /** * qtest_vqmp_fds: * @s: #QTestState instance to operate on. diff --git a/tests/qtest/libqos/meson.build b/tests/qtest/libqos/meson.build index 1cddf5bdaa..1f5c8f1053 100644 --- a/tests/qtest/libqos/meson.build +++ b/tests/qtest/libqos/meson.build @@ -32,6 +32,7 @@ libqos_srcs =3D files('../libqtest.c', 'virtio-9p.c', 'virtio-balloon.c', 'virtio-blk.c', + 'vhost-user-blk.c', 'virtio-mmio.c', 'virtio-net.c', 'virtio-pci.c', diff --git a/tests/qtest/libqos/vhost-user-blk.c b/tests/qtest/libqos/vhost= -user-blk.c new file mode 100644 index 0000000000..58c7e1eb69 --- /dev/null +++ b/tests/qtest/libqos/vhost-user-blk.c @@ -0,0 +1,129 @@ +/* + * libqos driver framework + * + * Based on tests/qtest/libqos/virtio-blk.c + * + * Copyright (c) 2020 Coiby Xu + * + * 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.1 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 "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/qtest/libqos/vhost-user-blk.h b/tests/qtest/libqos/vhost= -user-blk.h new file mode 100644 index 0000000000..2a03456a45 --- /dev/null +++ b/tests/qtest/libqos/vhost-user-blk.h @@ -0,0 +1,48 @@ +/* + * libqos driver framework + * + * Based on tests/qtest/libqos/virtio-blk.c + * + * Copyright (c) 2020 Coiby Xu + * + * 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 "qgraph.h" +#include "virtio.h" +#include "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/qtest/libqtest.c b/tests/qtest/libqtest.c index 58f58e1ece..ba19011737 100644 --- a/tests/qtest/libqtest.c +++ b/tests/qtest/libqtest.c @@ -4,11 +4,13 @@ * Copyright IBM, Corp. 2012 * Copyright Red Hat, Inc. 2012 * Copyright SUSE LINUX Products GmbH 2013 + * Copyright Copyright (c) Coiby Xu * * Authors: * Anthony Liguori * Paolo Bonzini * Andreas F=C3=A4rber + * Coiby Xu * * 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. @@ -52,8 +54,7 @@ typedef struct QTestClientTransportOps { QTestRecvFn recv_line; /* for receiving qtest command responses */ } QTestTransportOps; =20 -struct QTestState -{ +struct QTestState { int fd; int qmp_fd; pid_t qemu_pid; /* our child QEMU process */ @@ -608,6 +609,37 @@ QDict *qtest_qmp_receive(QTestState *s) return qmp_fd_receive(s->qmp_fd); } =20 +QTestState *qtest_create_state_with_qmp_fd(int fd) +{ + QTestState *qmp_test_state =3D g_new0(QTestState, 1); + qmp_test_state->qmp_fd =3D fd; + return qmp_test_state; +} + +int qtest_socket_client(char *server_socket_path) +{ + struct sockaddr_un serv_addr; + int sock; + int ret; + int retries =3D 0; + sock =3D socket(PF_UNIX, SOCK_STREAM, 0); + g_assert_cmpint(sock, !=3D, -1); + serv_addr.sun_family =3D AF_UNIX; + snprintf(serv_addr.sun_path, sizeof(serv_addr.sun_path), "%s", + server_socket_path); + + for (retries =3D 0; retries < 3; retries++) { + ret =3D connect(sock, (struct sockaddr *)&serv_addr, sizeof(serv_a= ddr)); + if (ret =3D=3D 0) { + break; + } + g_usleep(G_USEC_PER_SEC); + } + + g_assert_cmpint(ret, =3D=3D, 0); + return sock; +} + /** * Allow users to send a message without waiting for the reply, * in the case that they choose to discard all replies up until diff --git a/tests/qtest/meson.build b/tests/qtest/meson.build index 874b5be62b..c72821b09a 100644 --- a/tests/qtest/meson.build +++ b/tests/qtest/meson.build @@ -191,6 +191,7 @@ qos_test_ss.add( ) qos_test_ss.add(when: 'CONFIG_VIRTFS', if_true: files('virtio-9p-test.c')) qos_test_ss.add(when: 'CONFIG_VHOST_USER', if_true: files('vhost-user-test= .c')) +qos_test_ss.add(when: 'CONFIG_LINUX', if_true: files('vhost-user-blk-test.= c')) =20 extra_qtest_deps =3D { 'bios-tables-test': [io], @@ -234,7 +235,8 @@ foreach dir : target_dirs qtest_env.set('QTEST_QEMU_IMG', './qemu-img') qtest_env.set('G_TEST_DBUS_DAEMON', meson.source_root() / 'tests/dbus-vm= state-daemon.sh') qtest_env.set('QTEST_QEMU_BINARY', './qemu-system-' + target_base) - =20 + qtest_env.set('QTEST_QEMU_STORAGE_DAEMON_BINARY', './storage-daemon/qemu= -storage-daemon') + foreach test : qtests # Executables are shared across targets, declare them only the first t= ime we # encounter them diff --git a/tests/qtest/vhost-user-blk-test.c b/tests/qtest/vhost-user-blk= -test.c new file mode 100644 index 0000000000..d4ccac6b54 --- /dev/null +++ b/tests/qtest/vhost-user-blk-test.c @@ -0,0 +1,751 @@ +/* + * QTest testcase for Vhost-user Block Device + * + * Based on tests/qtest//virtio-blk-test.c + + * Copyright (c) 2014 SUSE LINUX Products GmbH + * Copyright (c) 2014 Marc Mar=C3=AD + * Copyright (c) 2020 Coiby Xu + * + * 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" + +#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; + QTestState *qts =3D global_qtest; + + 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); + + qtest_memwrite(qts, addr, req, 16); + qtest_memwrite(qts, addr + 16, req->data, data_size); + qtest_memwrite(qts, 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); + qtest_memread(qts, 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); + qtest_memread(qts, 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); + qtest_memread(qts, 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); + qtest_memread(qts, 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); + qtest_memread(qts, 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_storage_daemon_binary(void) +{ + const char *qemu_storage_daemon_bin; + + qemu_storage_daemon_bin =3D getenv("QTEST_QEMU_STORAGE_DAEMON_BINARY"); + if (!qemu_storage_daemon_bin) { + fprintf(stderr, "Environment variable " + "QTEST_QEMU_STORAGE_DAEMON_BINARY required\n"); + exit(0); + } + + return qemu_storage_daemon_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 char sock_path_tempate[] =3D "/tmp/qtest.vhost_user_blk.XXXXXX"; +static char qmp_sock_path_tempate[] =3D "/tmp/qtest.vhost_user_blk.qmp.XXX= XXX"; + +static void quit_storage_daemon(void *qmp_test_state) +{ + const char quit_str[] =3D "{ 'execute': 'quit' }"; + + /* Before quiting storate-daemon, quit qemu to avoid dubious messages = */ + qobject_unref(qtest_qmp(global_qtest, quit_str)); + + /* + * Give storage-daemon enough time to wake up&terminate + * vu_client_trip coroutine so the Coroutine object could + * be cleaned up. Otherwise LeakSanitizer would complain + * about memory leaks. + */ + g_usleep(1000); + + qobject_unref(qtest_qmp((QTestState *)qmp_test_state, quit_str)); + g_free(qmp_test_state); +} + +static char *start_vhost_user_blk(GString *cmd_line, int vus_instances) +{ + const char *vhost_user_blk_bin =3D qtest_qemu_storage_daemon_binary(); + int fd, qmp_fd, i; + QTestState *qmp_test_state; + gchar *img_path; + char *sock_path =3D NULL; + char *qmp_sock_path =3D g_strdup(qmp_sock_path_tempate); + GString *storage_daemon_command =3D g_string_new(NULL); + + qmp_fd =3D mkstemp(qmp_sock_path); + g_assert_cmpint(qmp_fd, >=3D, 0); + g_test_queue_destroy(drive_destroy, qmp_sock_path); + + g_string_append_printf(storage_daemon_command, + "exec %s " + "--chardev socket,id=3Dqmp,path=3D%s,server,nowait --monitor c= hardev=3Dqmp ", + vhost_user_blk_bin, qmp_sock_path); + + g_string_append_printf(cmd_line, + " -object memory-backend-memfd,id=3Dmem,size=3D128M,share=3Don= -numa node,memdev=3Dmem "); + + for (i =3D 0; i < vus_instances; i++) { + sock_path =3D g_strdup(sock_path_tempate); + fd =3D mkstemp(sock_path); + g_assert_cmpint(fd, >=3D, 0); + g_test_queue_destroy(drive_destroy, sock_path); + /* create image file */ + img_path =3D drive_create(); + g_string_append_printf(storage_daemon_command, + "--blockdev driver=3Dfile,node-name=3Ddisk%d,filename=3D%s " + "--object vhost-user-blk-server,id=3Ddisk%d,unix-socket=3D%s," + "node-name=3Ddisk%i,writable=3Don ", + i, img_path, i, sock_path, i); + + g_string_append_printf(cmd_line, "-chardev socket,id=3Dchar%d,path= =3D%s ", + i + 1, sock_path); + } + + g_test_message("starting vhost-user backend: %s", + storage_daemon_command->str); + pid_t pid =3D fork(); + if (pid =3D=3D 0) { + execlp("/bin/sh", "sh", "-c", storage_daemon_command->str, NULL); + exit(1); + } + g_string_free(storage_daemon_command, true); + + qmp_test_state =3D qtest_create_state_with_qmp_fd( + qtest_socket_client(qmp_sock_path)); + /* + * Ask qemu-storage-daemon to quit so it + * will not block scripts/tap-driver.pl. + */ + g_test_queue_destroy(quit_storage_daemon, qmp_test_state); + + qobject_unref(qtest_qmp(qmp_test_state, "{'execute': 'qmp_capabilities= '}")); + return sock_path; +} + +static void *vhost_user_blk_test_setup(GString *cmd_line, void *arg) +{ + start_vhost_user_blk(cmd_line, 1); + return arg; +} + +/* + * Setup for hotplug. + * + * Since vhost-user server only serves one vhost-user client one time, + * another exprot + * + */ +static void *vhost_user_blk_hotplug_test_setup(GString *cmd_line, void *ar= g) +{ + /* "-chardev socket,id=3Dchar2" is used for pci_hotplug*/ + start_vhost_user_blk(cmd_line, 2); + 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); + + opts.before =3D vhost_user_blk_hotplug_test_setup; + qos_add_test("hotplug", "vhost-user-blk-pci", pci_hotplug, &opts); +} + +libqos_init(register_vhost_user_blk_test); --=20 2.28.0 From nobody Sat Apr 27 06:57:47 2024 Delivered-To: importer@patchew.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=1600416898; cv=none; d=zohomail.com; s=zohoarc; b=fIEGhebtW22EaDHgsuUOuupZnYt0Qv6v8IsfEuNLp9WnH5i6uTkwJl4IS94IKktGvoQeC8QLbCrNJMtO9s0vUPFyDnr+wicMA3FYlNtepc6Wu2guM/uTn4rjLVOsKOKQKW9gfCqZ2mrsGqD0tlTjjuU2TbIrmWDje8tNnyyX+v4= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1600416898; 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=q6ED8Pqb2lsI90yHCr1MVM7nMQWDcI+eL8vWSv3hJzM=; b=izULUlAM+cufGjQpIjttBpfN/hhRaflokgVYrk9jKkWTn4naPksCTks8qY6nNHq/g86Q2p1+axAdTkn4IZGjEcKg/8QYjxQ7zHNipmIxQqJbKKoI1Zy0RCfWsVvIUrZzyZdkTzmQx+KH8xpvSVHq618n3wvhy/k2U01ZxogOXZE= 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 1600416898773947.5215328003727; Fri, 18 Sep 2020 01:14:58 -0700 (PDT) Received: from localhost ([::1]:50108 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1kJBXl-00088G-Ez for importer@patchew.org; Fri, 18 Sep 2020 04:14:57 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:57028) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1kJBT5-0000nU-6F for qemu-devel@nongnu.org; Fri, 18 Sep 2020 04:10:07 -0400 Received: from mail-pl1-x62b.google.com ([2607:f8b0:4864:20::62b]:42325) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1kJBT2-0003L5-SM for qemu-devel@nongnu.org; Fri, 18 Sep 2020 04:10:06 -0400 Received: by mail-pl1-x62b.google.com with SMTP id y6so2582319plt.9 for ; Fri, 18 Sep 2020 01:10:04 -0700 (PDT) Received: from localhost ([2001:e42:102:1532:160:16:113:140]) by smtp.gmail.com with ESMTPSA id f4sm2045455pfj.147.2020.09.18.01.10.02 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 18 Sep 2020 01:10:03 -0700 (PDT) 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=q6ED8Pqb2lsI90yHCr1MVM7nMQWDcI+eL8vWSv3hJzM=; b=a3tR8JvftmE8mDb6McQSn2QNTEfeIbXJ+yUT+EiPcPbPxekPwnI6sFoa1owBGbSvR5 +XoN6mO2yMWa7Rzqodg5wQIkWZhBs8jI7SVt00ERmRwjrFxHLvwq5aZ2CW7Id93As+L3 dgdFwDP6/j5uJ0PGpMb0HMyZRSpIz4SieMIyOUOAC6bE1BGxvvJou66vBOrYvr3qPu55 4+FtUf1mAYQXCLf9dX6xNFONrDzaj6woaDKpv0vxqx2Zni4r0E6XGVaq5GYTS9p+WmFM S7Tad3GA9pGXiNWA7fFeI+pkvEnLk1mO6OTevop73LH8jThD3zPs0E/74OAgO8MuZkqY Vpfg== 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=q6ED8Pqb2lsI90yHCr1MVM7nMQWDcI+eL8vWSv3hJzM=; b=oBXXZQAIyifD2dqsIJyGtYtvF18qjbv1VBfaOOIwbMD3a3ZlKDlS4JCG/RD8sPPJPc 6YrfgWOkNzS0cPjKdvDp7xqgnhqkL4soBm5B7RvIY2447sRA4wtKuWduBKp6lpYlI/hX DUFo6zzgXp/XmEnITN6qUlHmnlMcYTqYfN5EYu53pMl/NUydGCOeos5eC1vMc2ICE4xo 1hnaxE4wyzwn5f83dTEvyIOYyBTRXqvdP51+6MkYi7KqvA7Rz8LItRK/AlI5FzWs48KC xTAOtY01TpcQ9fP1i2k3br3mynpKEilxkVfAklUH/P0M0VbHVn2zLlwrE1JUYLw8W6Af sjMQ== X-Gm-Message-State: AOAM531WTr8XQ5RzW4jqIE+fgbs7Rg77r83P/B3o6oZP1kpQ/QnL2QcJ /FC7E8MluyB5yFQA4bOSJvbj0nvi7LpbLWCR X-Google-Smtp-Source: ABdhPJxwnc9bDzar6qBpepl1c8vboO854CUnJ84S65cJwbTvzMRATyBng1Qyv8JqgkuDSD4lNjWcOg== X-Received: by 2002:a17:90a:67cb:: with SMTP id g11mr11981858pjm.56.1600416603310; Fri, 18 Sep 2020 01:10:03 -0700 (PDT) From: Coiby Xu To: qemu-devel@nongnu.org Subject: [PATCH v10 7/7] MAINTAINERS: Add vhost-user block device backend server maintainer Date: Fri, 18 Sep 2020 16:09:12 +0800 Message-Id: <20200918080912.321299-8-coiby.xu@gmail.com> X-Mailer: git-send-email 2.28.0 In-Reply-To: <20200918080912.321299-1-coiby.xu@gmail.com> References: <20200918080912.321299-1-coiby.xu@gmail.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2607:f8b0:4864:20::62b; envelope-from=coiby.xu@gmail.com; helo=mail-pl1-x62b.google.com X-detected-operating-system: by eggs.gnu.org: No matching host in p0f cache. That's all we know. X-Spam_score_int: -20 X-Spam_score: -2.1 X-Spam_bar: -- X-Spam_report: (-2.1 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, FREEMAIL_FROM=0.001, RCVD_IN_DNSWL_NONE=-0.0001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: kwolf@redhat.com, bharatlkmlkvm@gmail.com, stefanha@redhat.com, Stefano Garzarella 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" Suggested-by: Stefano Garzarella Signed-off-by: Coiby Xu Reviewed-by: Stefan Hajnoczi --- MAINTAINERS | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/MAINTAINERS b/MAINTAINERS index 3d17cad19a..55ad6abe73 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -3039,6 +3039,14 @@ L: qemu-block@nongnu.org S: Supported F: tests/image-fuzzer/ =20 +Vhost-user block device backend server +M: Coiby Xu +S: Maintained +F: block/export/vhost-user-blk-server.c +F: util/vhost-user-server.c +F: tests/qtest/vhost-user-blk-test.c +F: tests/qtest/libqos/vhost-user-blk.c + Replication M: Wen Congyang M: Xie Changlong --=20 2.28.0