From patchwork Tue Jan 19 04:59:10 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Yongji Xie X-Patchwork-Id: 12029567 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-16.8 required=3.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,USER_AGENT_GIT autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 3AEF4C433E0 for ; Tue, 19 Jan 2021 08:42:00 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id EA2ED23121 for ; Tue, 19 Jan 2021 08:41:59 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727933AbhASFVr (ORCPT ); Tue, 19 Jan 2021 00:21:47 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:44342 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S2388564AbhASFGL (ORCPT ); Tue, 19 Jan 2021 00:06:11 -0500 Received: from mail-pf1-x42a.google.com (mail-pf1-x42a.google.com [IPv6:2607:f8b0:4864:20::42a]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 83368C0613CF for ; Mon, 18 Jan 2021 21:04:38 -0800 (PST) Received: by mail-pf1-x42a.google.com with SMTP id i63so4441357pfg.7 for ; Mon, 18 Jan 2021 21:04:38 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bytedance-com.20150623.gappssmtp.com; s=20150623; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=hq6cLGhX+YOdloZCBCv76n2UjaYC8NZfkFs6/p+ZtOg=; b=W8y876Dbq8gZuEg5QYXKhKTizoMMwtFxcmKeIZtDQdx+XEt3dW/eHtSMhQvknQYW4K DnsCpn+GirhCRLFyk/uVDaIJoXZgyWsH6gU53zdrGPud9lsener1pfIQEwdiCZRktfE+ Ne1ZR7dli2HUDcE+3V2rbyvftav5V4WgBCwhpQ0bHoynV0GboyaGO/cjnRSZdzh0GmFw r/A5ZX/PxqxanTpbUqh+VaClMqoh4p4eePPZY6MRWFJ7BiyHJsTxQWwUiwGliuSOKvLc PCreg4kS3gTI+lm3d0KE5HrHAWJ4B0/fMhjVOWrn+u+7Kwg0P9wxlbpTSDhJDbdRaU+G Y9Jg== 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=hq6cLGhX+YOdloZCBCv76n2UjaYC8NZfkFs6/p+ZtOg=; b=CDJzaNB9y3wPQ8I8u97aaGnxL/8KfrXqCw1VOQLosxFy9WhCX3HJjgcdzdgDlBJi8q WhxyP6njlfH4yooV660b/F8GHAvchYzgbNlexnjPgODClNTOcMIJzYcanvArpS45dKKE WTOqrIHTxEqgF0tudAZcRszTnV3jNb02Jh6WrK4NE0tXDW6pC1mexk/U9jfA5O9g+rqq CFANBzjkSGszG3fpAmLfazwcXuSBAJe4c4xz4ycUuVnGz//SztJ2n7APLDC04b6PQ/KF ZqGz7TYqnbVQVt94z411KR1hXC8iqoSJEoto9CJtSX4NSAr81n0jyecukj1jIETdQ2eo OjlQ== X-Gm-Message-State: AOAM533kiUO/CuHUxcVdBW8/PjZZ20zZ6Wr1u7Rle/BJR24o2t7JIjx/ Bpe+fiIewRd39LUpeI7Knt2T X-Google-Smtp-Source: ABdhPJwhMmXGRAF9exzwdYFbs4DDh7HaNjaSgRVmLvyUt1TO1CzzbUW14r26LDKrseM7tbJ/BRrzFA== X-Received: by 2002:a62:ddcd:0:b029:1a6:99ff:a75e with SMTP id w196-20020a62ddcd0000b02901a699ffa75emr2486197pff.42.1611032678076; Mon, 18 Jan 2021 21:04:38 -0800 (PST) Received: from localhost ([139.177.225.243]) by smtp.gmail.com with ESMTPSA id gv22sm1047509pjb.56.2021.01.18.21.04.36 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 18 Jan 2021 21:04:37 -0800 (PST) From: Xie Yongji To: mst@redhat.com, jasowang@redhat.com, stefanha@redhat.com, sgarzare@redhat.com, parav@nvidia.com, bob.liu@oracle.com, hch@infradead.org, rdunlap@infradead.org, willy@infradead.org, viro@zeniv.linux.org.uk, axboe@kernel.dk, bcrl@kvack.org, corbet@lwn.net Cc: virtualization@lists.linux-foundation.org, netdev@vger.kernel.org, kvm@vger.kernel.org, linux-aio@kvack.org, linux-fsdevel@vger.kernel.org Subject: [RFC v3 01/11] eventfd: track eventfd_signal() recursion depth separately in different cases Date: Tue, 19 Jan 2021 12:59:10 +0800 Message-Id: <20210119045920.447-2-xieyongji@bytedance.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210119045920.447-1-xieyongji@bytedance.com> References: <20210119045920.447-1-xieyongji@bytedance.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: kvm@vger.kernel.org Now we have a global percpu counter to limit the recursion depth of eventfd_signal(). This can avoid deadlock or stack overflow. But in stack overflow case, it should be OK to increase the recursion depth if needed. So we add a percpu counter in eventfd_ctx to limit the recursion depth for deadlock case. Then it could be fine to increase the global percpu counter later. Signed-off-by: Xie Yongji --- fs/aio.c | 3 ++- fs/eventfd.c | 20 +++++++++++++++++++- include/linux/eventfd.h | 5 +---- 3 files changed, 22 insertions(+), 6 deletions(-) diff --git a/fs/aio.c b/fs/aio.c index 1f32da13d39e..5d82903161f5 100644 --- a/fs/aio.c +++ b/fs/aio.c @@ -1698,7 +1698,8 @@ static int aio_poll_wake(struct wait_queue_entry *wait, unsigned mode, int sync, list_del(&iocb->ki_list); iocb->ki_res.res = mangle_poll(mask); req->done = true; - if (iocb->ki_eventfd && eventfd_signal_count()) { + if (iocb->ki_eventfd && + eventfd_signal_count(iocb->ki_eventfd)) { iocb = NULL; INIT_WORK(&req->work, aio_poll_put_work); schedule_work(&req->work); diff --git a/fs/eventfd.c b/fs/eventfd.c index e265b6dd4f34..2df24f9bada3 100644 --- a/fs/eventfd.c +++ b/fs/eventfd.c @@ -25,6 +25,8 @@ #include #include +#define EVENTFD_WAKE_DEPTH 0 + DEFINE_PER_CPU(int, eventfd_wake_count); static DEFINE_IDA(eventfd_ida); @@ -42,9 +44,17 @@ struct eventfd_ctx { */ __u64 count; unsigned int flags; + int __percpu *wake_count; int id; }; +bool eventfd_signal_count(struct eventfd_ctx *ctx) +{ + return (this_cpu_read(*ctx->wake_count) || + this_cpu_read(eventfd_wake_count) > EVENTFD_WAKE_DEPTH); +} +EXPORT_SYMBOL_GPL(eventfd_signal_count); + /** * eventfd_signal - Adds @n to the eventfd counter. * @ctx: [in] Pointer to the eventfd context. @@ -71,17 +81,19 @@ __u64 eventfd_signal(struct eventfd_ctx *ctx, __u64 n) * it returns true, the eventfd_signal() call should be deferred to a * safe context. */ - if (WARN_ON_ONCE(this_cpu_read(eventfd_wake_count))) + if (WARN_ON_ONCE(eventfd_signal_count(ctx))) return 0; spin_lock_irqsave(&ctx->wqh.lock, flags); this_cpu_inc(eventfd_wake_count); + this_cpu_inc(*ctx->wake_count); if (ULLONG_MAX - ctx->count < n) n = ULLONG_MAX - ctx->count; ctx->count += n; if (waitqueue_active(&ctx->wqh)) wake_up_locked_poll(&ctx->wqh, EPOLLIN); this_cpu_dec(eventfd_wake_count); + this_cpu_dec(*ctx->wake_count); spin_unlock_irqrestore(&ctx->wqh.lock, flags); return n; @@ -92,6 +104,7 @@ static void eventfd_free_ctx(struct eventfd_ctx *ctx) { if (ctx->id >= 0) ida_simple_remove(&eventfd_ida, ctx->id); + free_percpu(ctx->wake_count); kfree(ctx); } @@ -423,6 +436,11 @@ static int do_eventfd(unsigned int count, int flags) kref_init(&ctx->kref); init_waitqueue_head(&ctx->wqh); + ctx->wake_count = alloc_percpu(int); + if (!ctx->wake_count) { + kfree(ctx); + return -ENOMEM; + } ctx->count = count; ctx->flags = flags; ctx->id = ida_simple_get(&eventfd_ida, 0, 0, GFP_KERNEL); diff --git a/include/linux/eventfd.h b/include/linux/eventfd.h index fa0a524baed0..1a11ebbd74a9 100644 --- a/include/linux/eventfd.h +++ b/include/linux/eventfd.h @@ -45,10 +45,7 @@ void eventfd_ctx_do_read(struct eventfd_ctx *ctx, __u64 *cnt); DECLARE_PER_CPU(int, eventfd_wake_count); -static inline bool eventfd_signal_count(void) -{ - return this_cpu_read(eventfd_wake_count); -} +bool eventfd_signal_count(struct eventfd_ctx *ctx); #else /* CONFIG_EVENTFD */ From patchwork Tue Jan 19 04:59:11 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Yongji Xie X-Patchwork-Id: 12029545 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-16.8 required=3.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,USER_AGENT_GIT autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id D9970C433E0 for ; Tue, 19 Jan 2021 08:40:11 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id B386823121 for ; Tue, 19 Jan 2021 08:40:09 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727420AbhASFWU (ORCPT ); Tue, 19 Jan 2021 00:22:20 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:44356 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S2388937AbhASFGN (ORCPT ); Tue, 19 Jan 2021 00:06:13 -0500 Received: from mail-pl1-x62e.google.com (mail-pl1-x62e.google.com [IPv6:2607:f8b0:4864:20::62e]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 2F74EC0613ED for ; Mon, 18 Jan 2021 21:04:42 -0800 (PST) Received: by mail-pl1-x62e.google.com with SMTP id g3so9841764plp.2 for ; Mon, 18 Jan 2021 21:04:42 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bytedance-com.20150623.gappssmtp.com; s=20150623; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=WpzztgDjuirSaoCm4Y9iwgLXbmOFGv5bSk1ou8troPs=; b=qst643HflCVIEfriJwFNkoqnsyAa5ZihDHq5MY2p+sCG7pvdwgfVfWzDs7CyLXzUd+ X5uFyzZCSZ64/Hp2K0p+C+NqylNT+3OiWFg2Ej65miParVF8OeJLkwoS9jnaFI+wtI0Q lXnOrClMEjsYSBLjzze08LxElrkh9rDDFZG4NpZj1vBBw0KYdlW9EiU1Oqdd7abo8655 YHy2xoK2ETSc2On6BciBqVp5jFgbCsIs1R3h9DY01PpB87KzpOEMy5avoFjp/pmcioUN +x7E/3nOu6rB2x31lmd8Bdb+nLCMZYSnKtcS8EPFLa7M6DLN4bahTjy5UUUFTb1aGyef ogCA== 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=WpzztgDjuirSaoCm4Y9iwgLXbmOFGv5bSk1ou8troPs=; b=BTYeE0GOIUBkV8i9J0BRlGYK6S9TgkNBWqpFCYMpjv6dYfIVOdl1XpT/AsElvQkFR6 HGrvOHgEHiJ4G3aeHE/i+BBey5oWhgucOp/BWmoeu3anDIXcSp1GgLAOOCbsM7PApeyE h1vmxfTFLMUTyfPVBxSmoJyXQA4dA+dFZ9LN39Oi873yji0KDCjzlwD44KLvHoi7di/m wUv3RCzGMwArzDfay2V2BIyhjzZ/jmb2rsjLaPK2LyqIFbccAW9wFJ1dwYYl6vGmNBNf ndHNBdHzsILxOdUxh3RGVh17EJ3s1ZpZnFegLgWP5qIlB59TtOM0KruKEQaEGkemFsyJ TmiA== X-Gm-Message-State: AOAM532UV+fQv00gWBwb8wtPOFpcympLiYYo17DHNN3Hl6XGSJ5UxzCB gptZ6HYowRfpuNCPXNvqsN2L X-Google-Smtp-Source: ABdhPJw7CNS8s3U6DU1iDibWMlmFKz5BWY5qR5AaOZK841X966zGeE7AOSATjocWL+j9RMwjLVZkkg== X-Received: by 2002:a17:90a:2e88:: with SMTP id r8mr3289055pjd.84.1611032681770; Mon, 18 Jan 2021 21:04:41 -0800 (PST) Received: from localhost ([139.177.225.243]) by smtp.gmail.com with ESMTPSA id p187sm17220675pfp.60.2021.01.18.21.04.40 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 18 Jan 2021 21:04:41 -0800 (PST) From: Xie Yongji To: mst@redhat.com, jasowang@redhat.com, stefanha@redhat.com, sgarzare@redhat.com, parav@nvidia.com, bob.liu@oracle.com, hch@infradead.org, rdunlap@infradead.org, willy@infradead.org, viro@zeniv.linux.org.uk, axboe@kernel.dk, bcrl@kvack.org, corbet@lwn.net Cc: virtualization@lists.linux-foundation.org, netdev@vger.kernel.org, kvm@vger.kernel.org, linux-aio@kvack.org, linux-fsdevel@vger.kernel.org Subject: [RFC v3 02/11] eventfd: Increase the recursion depth of eventfd_signal() Date: Tue, 19 Jan 2021 12:59:11 +0800 Message-Id: <20210119045920.447-3-xieyongji@bytedance.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210119045920.447-1-xieyongji@bytedance.com> References: <20210119045920.447-1-xieyongji@bytedance.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: kvm@vger.kernel.org Increase the recursion depth of eventfd_signal() to 1. This will be used in VDUSE case later. Signed-off-by: Xie Yongji --- fs/eventfd.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/fs/eventfd.c b/fs/eventfd.c index 2df24f9bada3..478cdc175949 100644 --- a/fs/eventfd.c +++ b/fs/eventfd.c @@ -25,7 +25,7 @@ #include #include -#define EVENTFD_WAKE_DEPTH 0 +#define EVENTFD_WAKE_DEPTH 1 DEFINE_PER_CPU(int, eventfd_wake_count); From patchwork Tue Jan 19 04:59:12 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Yongji Xie X-Patchwork-Id: 12028735 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-16.8 required=3.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 4EF2AC433DB for ; Tue, 19 Jan 2021 05:23:16 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 26B7922BE9 for ; Tue, 19 Jan 2021 05:23:16 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S2388568AbhASFWo (ORCPT ); Tue, 19 Jan 2021 00:22:44 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:44438 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S2389108AbhASFGj (ORCPT ); Tue, 19 Jan 2021 00:06:39 -0500 Received: from mail-pj1-x1030.google.com (mail-pj1-x1030.google.com [IPv6:2607:f8b0:4864:20::1030]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id D339AC061794 for ; Mon, 18 Jan 2021 21:04:45 -0800 (PST) Received: by mail-pj1-x1030.google.com with SMTP id lw17so899548pjb.0 for ; Mon, 18 Jan 2021 21:04:45 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bytedance-com.20150623.gappssmtp.com; s=20150623; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=rk3Zr0O5adDtcKDEPjgvkHO0z8gks3DD0R510gfQviI=; b=znqS6hnVz6dahC+EHSdB87OaGtNUKXPEDPbv9BRfgHji1a4LjR1Je/PDQuHlonctZF BP3HHtdI7HAmXp2j9UIXS71yX5sjsnmx3oWoNSBurhnSzFh3+uNgFfSimf5NJppJkcBE lffuKp+ndrCAqjbI1YojLoCRIRhYAi2iNTIoZhhAWPGuJHRAd4u4+V3Z4hADLjaCZAUp KBNTvPpMIAhbPnbyCy1TUIwX9PhLzsLsbSG8I7cDhr7s+6FB3q+5AAr26cU+sPyWpScL Ks+Cl6Ua+C+cHunJTJzSGIJRu0qpdaRLAnOFPWvP0p1uIY81jddpKM3iBbLcHN5FMt/T 1XWQ== 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=rk3Zr0O5adDtcKDEPjgvkHO0z8gks3DD0R510gfQviI=; b=qlsJUSGuMRREEVT1ccOdMwlD7Zc+N5lkaWWpvuZuMzF+Rx03TqyCpQIA3wxj4DCG1V ex7xGHQ+58lPiPeYOHAKZncFVgy5NOq/wo/QMpkT8M4xsgQjT/M3MoKq+jhpIxJVY5WK 39pyu3iT4hNJrI7/hNPdyNpytfrX4I51bIsGPEzP3/qgJZ+T26ucAxzT2aRbaFZtxf3q k/6Ra2tkqZqoNcjREM14U3GV/OTJB73SZY7BCgWcTYGIFp7nJ9bgrP/liRAn3b7+Abj7 zYN3WKfeD7AXUhB/kPiCVYabFMIVcfEkJHeV0HCsnX0P3aHNXCvBN7m9BSTzOzoUWe0Y sF5Q== X-Gm-Message-State: AOAM532KVtBuOFLQ2qDw7YxZ++gjYtuLrMME6TyRRyFaQqLumCytFBUd r06g+aYXxATTcFLbY9se30BN X-Google-Smtp-Source: ABdhPJwaZBIZPAe2wVJ2M5FYpu2+mBkdly7m6W4Agcx3j+WJGeyF0X6mqSRoroO3c0uR8pMGJhBAcw== X-Received: by 2002:a17:902:e885:b029:de:abac:f9c4 with SMTP id w5-20020a170902e885b02900deabacf9c4mr2753168plg.30.1611032685396; Mon, 18 Jan 2021 21:04:45 -0800 (PST) Received: from localhost ([139.177.225.243]) by smtp.gmail.com with ESMTPSA id d2sm1089669pjd.29.2021.01.18.21.04.44 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 18 Jan 2021 21:04:44 -0800 (PST) From: Xie Yongji To: mst@redhat.com, jasowang@redhat.com, stefanha@redhat.com, sgarzare@redhat.com, parav@nvidia.com, bob.liu@oracle.com, hch@infradead.org, rdunlap@infradead.org, willy@infradead.org, viro@zeniv.linux.org.uk, axboe@kernel.dk, bcrl@kvack.org, corbet@lwn.net Cc: virtualization@lists.linux-foundation.org, netdev@vger.kernel.org, kvm@vger.kernel.org, linux-aio@kvack.org, linux-fsdevel@vger.kernel.org Subject: [RFC v3 03/11] vdpa: Remove the restriction that only supports virtio-net devices Date: Tue, 19 Jan 2021 12:59:12 +0800 Message-Id: <20210119045920.447-4-xieyongji@bytedance.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210119045920.447-1-xieyongji@bytedance.com> References: <20210119045920.447-1-xieyongji@bytedance.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: kvm@vger.kernel.org With VDUSE, we should be able to support all kinds of virtio devices. Signed-off-by: Xie Yongji --- drivers/vhost/vdpa.c | 29 +++-------------------------- 1 file changed, 3 insertions(+), 26 deletions(-) diff --git a/drivers/vhost/vdpa.c b/drivers/vhost/vdpa.c index 29ed4173f04e..448be7875b6d 100644 --- a/drivers/vhost/vdpa.c +++ b/drivers/vhost/vdpa.c @@ -22,6 +22,7 @@ #include #include #include +#include #include "vhost.h" @@ -185,26 +186,6 @@ static long vhost_vdpa_set_status(struct vhost_vdpa *v, u8 __user *statusp) return 0; } -static int vhost_vdpa_config_validate(struct vhost_vdpa *v, - struct vhost_vdpa_config *c) -{ - long size = 0; - - switch (v->virtio_id) { - case VIRTIO_ID_NET: - size = sizeof(struct virtio_net_config); - break; - } - - if (c->len == 0) - return -EINVAL; - - if (c->len > size - c->off) - return -E2BIG; - - return 0; -} - static long vhost_vdpa_get_config(struct vhost_vdpa *v, struct vhost_vdpa_config __user *c) { @@ -215,7 +196,7 @@ static long vhost_vdpa_get_config(struct vhost_vdpa *v, if (copy_from_user(&config, c, size)) return -EFAULT; - if (vhost_vdpa_config_validate(v, &config)) + if (config.len == 0) return -EINVAL; buf = kvzalloc(config.len, GFP_KERNEL); if (!buf) @@ -243,7 +224,7 @@ static long vhost_vdpa_set_config(struct vhost_vdpa *v, if (copy_from_user(&config, c, size)) return -EFAULT; - if (vhost_vdpa_config_validate(v, &config)) + if (config.len == 0) return -EINVAL; buf = kvzalloc(config.len, GFP_KERNEL); if (!buf) @@ -1025,10 +1006,6 @@ static int vhost_vdpa_probe(struct vdpa_device *vdpa) int minor; int r; - /* Currently, we only accept the network devices. */ - if (ops->get_device_id(vdpa) != VIRTIO_ID_NET) - return -ENOTSUPP; - v = kzalloc(sizeof(*v), GFP_KERNEL | __GFP_RETRY_MAYFAIL); if (!v) return -ENOMEM; From patchwork Tue Jan 19 04:59:13 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Yongji Xie X-Patchwork-Id: 12028733 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-16.8 required=3.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id AE3ECC433DB for ; Tue, 19 Jan 2021 05:22:59 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 63D9F22B49 for ; Tue, 19 Jan 2021 05:22:59 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S2388314AbhASFWi (ORCPT ); Tue, 19 Jan 2021 00:22:38 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:44440 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S2389119AbhASFGj (ORCPT ); Tue, 19 Jan 2021 00:06:39 -0500 Received: from mail-pl1-x62b.google.com (mail-pl1-x62b.google.com [IPv6:2607:f8b0:4864:20::62b]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 83249C061795 for ; Mon, 18 Jan 2021 21:04:49 -0800 (PST) Received: by mail-pl1-x62b.google.com with SMTP id y8so9830076plp.8 for ; Mon, 18 Jan 2021 21:04:49 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bytedance-com.20150623.gappssmtp.com; s=20150623; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=N9j+IrVlTXg9S1haunx/u+0liG07Ca/vG3BAfTTRth0=; b=c0lyfDzoS5QB6OBrKysFm/8ri6zOlvieJn8PK4hMjXVxXJVepylfobD8qrU/efAP+8 uxzJUp2XXpUNM9vHpFBqdG1ny23yuIw6VXqGQ09j2KVBOxh8UZIUffJwQs1I79SPA6ZR et1ER1BhrBRSQSzxSN377DwkEP+mzYVKCmnN2Q5x/2L0dx1mzo6VQy6AMn3BGX7J+KAR kbB01iNMvc9O6hfDzpM8BYwecLzj5ahKiOFQSrFiv5DV1NrzqoxoXC/7EnVK1zE6Tk61 ys6ucMWwrfuNPw7UpMQNfKiBv7Vuvd3K7JE5j1VuUahfpbZG+klHnewhTwhXKNN7ULdY iqZQ== 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=N9j+IrVlTXg9S1haunx/u+0liG07Ca/vG3BAfTTRth0=; b=JWEzj+NEwQ7s5IydFIllGc2NxdOMKC96s/hGHSQzsGJFCFAXJ4al9ukTIjJ6xL9klq Zm2AKmLJJS2RO1nc4UguWgBiu5zkaM3oezMTsV9FQ57z4KtPUyGpo6rcUcdfRQ+oelll g21DfBi39rXd9yohlCwQRVvW7y4aIwd7Oj19puns45ECqBNGk/rG4M/w/ntFzxD9FTqk gs+tTu6i+P8JXKjyDOFMKaNQ+og04TyTjmIce0RZaIP+scmOmioHbmgs14Q5P46lmBaI 7De/50l0iSCG66nINE6fzHYqP+IkDijwvyeuXSHkRcKpMesi84Fej9CrTIgLVjNvLu11 8+IQ== X-Gm-Message-State: AOAM530eOfoCck3HBpMDAmcd3ou1QeZwqqobFheKb7zMORNZ3fkLymH/ DNc8lCZ+AsINxDeHFVB1pW12 X-Google-Smtp-Source: ABdhPJxCgeMC/Vp9b1Ucmz89KU0Ng1jFwBXGSGBKRDk7q1sBsQ76nH4litH5FKUFM0pgi1pzDUNObg== X-Received: by 2002:a17:902:848e:b029:dc:b38:98f0 with SMTP id c14-20020a170902848eb02900dc0b3898f0mr2732883plo.82.1611032689158; Mon, 18 Jan 2021 21:04:49 -0800 (PST) Received: from localhost ([139.177.225.243]) by smtp.gmail.com with ESMTPSA id j15sm17627186pfn.180.2021.01.18.21.04.47 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 18 Jan 2021 21:04:48 -0800 (PST) From: Xie Yongji To: mst@redhat.com, jasowang@redhat.com, stefanha@redhat.com, sgarzare@redhat.com, parav@nvidia.com, bob.liu@oracle.com, hch@infradead.org, rdunlap@infradead.org, willy@infradead.org, viro@zeniv.linux.org.uk, axboe@kernel.dk, bcrl@kvack.org, corbet@lwn.net Cc: virtualization@lists.linux-foundation.org, netdev@vger.kernel.org, kvm@vger.kernel.org, linux-aio@kvack.org, linux-fsdevel@vger.kernel.org Subject: [RFC v3 04/11] vhost-vdpa: protect concurrent access to vhost device iotlb Date: Tue, 19 Jan 2021 12:59:13 +0800 Message-Id: <20210119045920.447-5-xieyongji@bytedance.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210119045920.447-1-xieyongji@bytedance.com> References: <20210119045920.447-1-xieyongji@bytedance.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: kvm@vger.kernel.org Introduce a mutex to protect vhost device iotlb from concurrent access. Fixes: 4c8cf318("vhost: introduce vDPA-based backend") Signed-off-by: Xie Yongji --- drivers/vhost/vdpa.c | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/drivers/vhost/vdpa.c b/drivers/vhost/vdpa.c index 448be7875b6d..4a241d380c40 100644 --- a/drivers/vhost/vdpa.c +++ b/drivers/vhost/vdpa.c @@ -49,6 +49,7 @@ struct vhost_vdpa { struct eventfd_ctx *config_ctx; int in_batch; struct vdpa_iova_range range; + struct mutex mutex; }; static DEFINE_IDA(vhost_vdpa_ida); @@ -728,6 +729,7 @@ static int vhost_vdpa_process_iotlb_msg(struct vhost_dev *dev, if (r) return r; + mutex_lock(&v->mutex); switch (msg->type) { case VHOST_IOTLB_UPDATE: r = vhost_vdpa_process_iotlb_update(v, msg); @@ -747,6 +749,7 @@ static int vhost_vdpa_process_iotlb_msg(struct vhost_dev *dev, r = -EINVAL; break; } + mutex_unlock(&v->mutex); return r; } @@ -1017,6 +1020,7 @@ static int vhost_vdpa_probe(struct vdpa_device *vdpa) return minor; } + mutex_init(&v->mutex); atomic_set(&v->opened, 0); v->minor = minor; v->vdpa = vdpa; From patchwork Tue Jan 19 04:59:14 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Yongji Xie X-Patchwork-Id: 12028737 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-16.8 required=3.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 641A9C433E0 for ; Tue, 19 Jan 2021 05:23:37 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 31C1822C9D for ; Tue, 19 Jan 2021 05:23:37 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S2388389AbhASFXP (ORCPT ); Tue, 19 Jan 2021 00:23:15 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:44614 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S2389519AbhASFHW (ORCPT ); Tue, 19 Jan 2021 00:07:22 -0500 Received: from mail-pf1-x435.google.com (mail-pf1-x435.google.com [IPv6:2607:f8b0:4864:20::435]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 5B6EAC06179A for ; Mon, 18 Jan 2021 21:04:53 -0800 (PST) Received: by mail-pf1-x435.google.com with SMTP id 11so11509967pfu.4 for ; Mon, 18 Jan 2021 21:04:53 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bytedance-com.20150623.gappssmtp.com; s=20150623; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=U0120iNFu1UQ+XQP2804t9yWUT9nyzP1s7JWVirZ0CQ=; b=tT/tmNAi6NU57xmHjfGmqHgX95hCN5stlPBS4x34MDgSRzGJgUPlWjosZg+6PyfxjO IlCL7iHuRliYzhRIUJwqVTWRZl33hJvmOwmriMEbSe8wcZxoyWzpiSsyMJjN59tnB6yK PPMsjJIyNWtdFwH4fXQAEjDjWjDvv/QoSFx+BpJjhKLG5bk2eHnhh3/IMNIoj7J3zH/U kQegq2euiTFuF9uqisspaevugD1zMGgphJ3VAW+xVbApOGXlsUBgHcU+0uBphjIjnbvF 99auMuVMqsaT7A8eptrh9JDdjA7uJnYlGEhuScmBxfPlLzwx4zdrr4WesSpAulQibsru 5Lcw== 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=U0120iNFu1UQ+XQP2804t9yWUT9nyzP1s7JWVirZ0CQ=; b=dLxu9j3hb2GrXnNslt1/E5WflYO8d+8j00kqswOFZELgPPXzmrVlAqimplVz8HL9/o U1bfx6Kc4pR3Cy2ZjHBNCxu2/QqtLlFHZBwmcQ5rgx03oyThA7DOJZtZFKrskYXcbvDc 8IXqQcG6pWgvYAg0kHk1oa1glP6yZN+Z5fmyKQloqtNxMGn554CugT7qa9Ydcezjs24C WeFV5zqeWU5C/cn91EHh/87DQ3rIIidCTQB7U0pgNDHOiq68zwGZrRp7gowMieVcWsQx 6q5SAcc6XIJ1YxPQRGaBsrHwXIwW619geTCmcog7J48zEr/02uUyYI5GYoKNAK5lL2Yi I0Dw== X-Gm-Message-State: AOAM530XlmQFMJFV4byBvvB51035UgnCk2NBST+uPOptkUfUcyQACEOH VnzavA2o0PHwVsQmMw3Wn6aw X-Google-Smtp-Source: ABdhPJz29+5qkk0tFpBdHE1YKxTcsaEJOC9RJCsgQpfbCkBSRwz57KBR46or6uBk7ojXObygUicQrg== X-Received: by 2002:a63:d601:: with SMTP id q1mr2833194pgg.417.1611032692863; Mon, 18 Jan 2021 21:04:52 -0800 (PST) Received: from localhost ([139.177.225.243]) by smtp.gmail.com with ESMTPSA id ob6sm1047360pjb.30.2021.01.18.21.04.51 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 18 Jan 2021 21:04:52 -0800 (PST) From: Xie Yongji To: mst@redhat.com, jasowang@redhat.com, stefanha@redhat.com, sgarzare@redhat.com, parav@nvidia.com, bob.liu@oracle.com, hch@infradead.org, rdunlap@infradead.org, willy@infradead.org, viro@zeniv.linux.org.uk, axboe@kernel.dk, bcrl@kvack.org, corbet@lwn.net Cc: virtualization@lists.linux-foundation.org, netdev@vger.kernel.org, kvm@vger.kernel.org, linux-aio@kvack.org, linux-fsdevel@vger.kernel.org Subject: [RFC v3 05/11] vdpa: shared virtual addressing support Date: Tue, 19 Jan 2021 12:59:14 +0800 Message-Id: <20210119045920.447-6-xieyongji@bytedance.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210119045920.447-1-xieyongji@bytedance.com> References: <20210119045920.447-1-xieyongji@bytedance.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: kvm@vger.kernel.org This patches introduces SVA (Shared Virtual Addressing) support for vDPA device. During vDPA device allocation, vDPA device driver needs to indicate whether SVA is supported by the device. Then vhost-vdpa bus driver will not pin user page and transfer userspace virtual address instead of physical address during DMA mapping. Suggested-by: Jason Wang Signed-off-by: Xie Yongji --- drivers/vdpa/ifcvf/ifcvf_main.c | 2 +- drivers/vdpa/mlx5/net/mlx5_vnet.c | 2 +- drivers/vdpa/vdpa.c | 5 ++++- drivers/vdpa/vdpa_sim/vdpa_sim.c | 3 ++- drivers/vhost/vdpa.c | 35 +++++++++++++++++++++++------------ include/linux/vdpa.h | 10 +++++++--- 6 files changed, 38 insertions(+), 19 deletions(-) diff --git a/drivers/vdpa/ifcvf/ifcvf_main.c b/drivers/vdpa/ifcvf/ifcvf_main.c index 23474af7da40..95c4601f82f5 100644 --- a/drivers/vdpa/ifcvf/ifcvf_main.c +++ b/drivers/vdpa/ifcvf/ifcvf_main.c @@ -439,7 +439,7 @@ static int ifcvf_probe(struct pci_dev *pdev, const struct pci_device_id *id) adapter = vdpa_alloc_device(struct ifcvf_adapter, vdpa, dev, &ifc_vdpa_ops, - IFCVF_MAX_QUEUE_PAIRS * 2, NULL); + IFCVF_MAX_QUEUE_PAIRS * 2, NULL, false); if (adapter == NULL) { IFCVF_ERR(pdev, "Failed to allocate vDPA structure"); return -ENOMEM; diff --git a/drivers/vdpa/mlx5/net/mlx5_vnet.c b/drivers/vdpa/mlx5/net/mlx5_vnet.c index 77595c81488d..05988d6907f2 100644 --- a/drivers/vdpa/mlx5/net/mlx5_vnet.c +++ b/drivers/vdpa/mlx5/net/mlx5_vnet.c @@ -1959,7 +1959,7 @@ static int mlx5v_probe(struct auxiliary_device *adev, max_vqs = min_t(u32, max_vqs, MLX5_MAX_SUPPORTED_VQS); ndev = vdpa_alloc_device(struct mlx5_vdpa_net, mvdev.vdev, mdev->device, &mlx5_vdpa_ops, - 2 * mlx5_vdpa_max_qps(max_vqs), NULL); + 2 * mlx5_vdpa_max_qps(max_vqs), NULL, false); if (IS_ERR(ndev)) return PTR_ERR(ndev); diff --git a/drivers/vdpa/vdpa.c b/drivers/vdpa/vdpa.c index 32bd48baffab..50cab930b2e5 100644 --- a/drivers/vdpa/vdpa.c +++ b/drivers/vdpa/vdpa.c @@ -72,6 +72,7 @@ static void vdpa_release_dev(struct device *d) * @nvqs: number of virtqueues supported by this device * @size: size of the parent structure that contains private data * @name: name of the vdpa device; optional. + * @sva: indicate whether SVA (Shared Virtual Addressing) is supported * * Driver should use vdpa_alloc_device() wrapper macro instead of * using this directly. @@ -81,7 +82,8 @@ static void vdpa_release_dev(struct device *d) */ struct vdpa_device *__vdpa_alloc_device(struct device *parent, const struct vdpa_config_ops *config, - int nvqs, size_t size, const char *name) + int nvqs, size_t size, const char *name, + bool sva) { struct vdpa_device *vdev; int err = -EINVAL; @@ -108,6 +110,7 @@ struct vdpa_device *__vdpa_alloc_device(struct device *parent, vdev->config = config; vdev->features_valid = false; vdev->nvqs = nvqs; + vdev->sva = sva; if (name) err = dev_set_name(&vdev->dev, "%s", name); diff --git a/drivers/vdpa/vdpa_sim/vdpa_sim.c b/drivers/vdpa/vdpa_sim/vdpa_sim.c index 85776e4e6749..03c796873a6b 100644 --- a/drivers/vdpa/vdpa_sim/vdpa_sim.c +++ b/drivers/vdpa/vdpa_sim/vdpa_sim.c @@ -367,7 +367,8 @@ static struct vdpasim *vdpasim_create(const char *name) else ops = &vdpasim_net_config_ops; - vdpasim = vdpa_alloc_device(struct vdpasim, vdpa, NULL, ops, VDPASIM_VQ_NUM, name); + vdpasim = vdpa_alloc_device(struct vdpasim, vdpa, NULL, ops, + VDPASIM_VQ_NUM, name, false); if (!vdpasim) goto err_alloc; diff --git a/drivers/vhost/vdpa.c b/drivers/vhost/vdpa.c index 4a241d380c40..36b6950ba37f 100644 --- a/drivers/vhost/vdpa.c +++ b/drivers/vhost/vdpa.c @@ -486,21 +486,25 @@ static long vhost_vdpa_unlocked_ioctl(struct file *filep, static void vhost_vdpa_iotlb_unmap(struct vhost_vdpa *v, u64 start, u64 last) { struct vhost_dev *dev = &v->vdev; + struct vdpa_device *vdpa = v->vdpa; struct vhost_iotlb *iotlb = dev->iotlb; struct vhost_iotlb_map *map; struct page *page; unsigned long pfn, pinned; while ((map = vhost_iotlb_itree_first(iotlb, start, last)) != NULL) { - pinned = map->size >> PAGE_SHIFT; - for (pfn = map->addr >> PAGE_SHIFT; - pinned > 0; pfn++, pinned--) { - page = pfn_to_page(pfn); - if (map->perm & VHOST_ACCESS_WO) - set_page_dirty_lock(page); - unpin_user_page(page); + if (!vdpa->sva) { + pinned = map->size >> PAGE_SHIFT; + for (pfn = map->addr >> PAGE_SHIFT; + pinned > 0; pfn++, pinned--) { + page = pfn_to_page(pfn); + if (map->perm & VHOST_ACCESS_WO) + set_page_dirty_lock(page); + unpin_user_page(page); + } + atomic64_sub(map->size >> PAGE_SHIFT, + &dev->mm->pinned_vm); } - atomic64_sub(map->size >> PAGE_SHIFT, &dev->mm->pinned_vm); vhost_iotlb_map_free(iotlb, map); } } @@ -558,13 +562,15 @@ static int vhost_vdpa_map(struct vhost_vdpa *v, r = iommu_map(v->domain, iova, pa, size, perm_to_iommu_flags(perm)); } - - if (r) + if (r) { vhost_iotlb_del_range(dev->iotlb, iova, iova + size - 1); - else + return r; + } + + if (!vdpa->sva) atomic64_add(size >> PAGE_SHIFT, &dev->mm->pinned_vm); - return r; + return 0; } static void vhost_vdpa_unmap(struct vhost_vdpa *v, u64 iova, u64 size) @@ -589,6 +595,7 @@ static int vhost_vdpa_process_iotlb_update(struct vhost_vdpa *v, struct vhost_iotlb_msg *msg) { struct vhost_dev *dev = &v->vdev; + struct vdpa_device *vdpa = v->vdpa; struct vhost_iotlb *iotlb = dev->iotlb; struct page **page_list; unsigned long list_size = PAGE_SIZE / sizeof(struct page *); @@ -607,6 +614,10 @@ static int vhost_vdpa_process_iotlb_update(struct vhost_vdpa *v, msg->iova + msg->size - 1)) return -EEXIST; + if (vdpa->sva) + return vhost_vdpa_map(v, msg->iova, msg->size, + msg->uaddr, msg->perm); + /* Limit the use of memory for bookkeeping */ page_list = (struct page **) __get_free_page(GFP_KERNEL); if (!page_list) diff --git a/include/linux/vdpa.h b/include/linux/vdpa.h index cb5a3d847af3..f86869651614 100644 --- a/include/linux/vdpa.h +++ b/include/linux/vdpa.h @@ -44,6 +44,7 @@ struct vdpa_parent_dev; * @config: the configuration ops for this device. * @index: device index * @features_valid: were features initialized? for legacy guests + * @sva: indicate whether SVA (Shared Virtual Addressing) is supported * @nvqs: maximum number of supported virtqueues * @pdev: parent device pointer; caller must setup when registering device as part * of dev_add() parentdev ops callback before invoking _vdpa_register_device(). @@ -54,6 +55,7 @@ struct vdpa_device { const struct vdpa_config_ops *config; unsigned int index; bool features_valid; + bool sva; int nvqs; struct vdpa_parent_dev *pdev; }; @@ -250,14 +252,16 @@ struct vdpa_config_ops { struct vdpa_device *__vdpa_alloc_device(struct device *parent, const struct vdpa_config_ops *config, - int nvqs, size_t size, const char *name); + int nvqs, size_t size, + const char *name, bool sva); -#define vdpa_alloc_device(dev_struct, member, parent, config, nvqs, name) \ +#define vdpa_alloc_device(dev_struct, member, parent, config, \ + nvqs, name, sva) \ container_of(__vdpa_alloc_device( \ parent, config, nvqs, \ sizeof(dev_struct) + \ BUILD_BUG_ON_ZERO(offsetof( \ - dev_struct, member)), name), \ + dev_struct, member)), name, sva), \ dev_struct, member) int vdpa_register_device(struct vdpa_device *vdev); From patchwork Tue Jan 19 04:59:15 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Yongji Xie X-Patchwork-Id: 12029543 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-16.8 required=3.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,USER_AGENT_GIT autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 61F4EC43381 for ; Tue, 19 Jan 2021 08:37:17 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 30BB023133 for ; Tue, 19 Jan 2021 08:37:17 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S2388890AbhASFX0 (ORCPT ); Tue, 19 Jan 2021 00:23:26 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:44620 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S2389520AbhASFHY (ORCPT ); Tue, 19 Jan 2021 00:07:24 -0500 Received: from mail-pj1-x1036.google.com (mail-pj1-x1036.google.com [IPv6:2607:f8b0:4864:20::1036]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 0E6CEC06179C for ; Mon, 18 Jan 2021 21:04:57 -0800 (PST) Received: by mail-pj1-x1036.google.com with SMTP id md11so10989305pjb.0 for ; Mon, 18 Jan 2021 21:04:57 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bytedance-com.20150623.gappssmtp.com; s=20150623; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=0BQoH5e6Vo5VKCH7jA0/hn3YTplKrX7vVJZ+TW7uaHc=; b=K3k9qs+WXjOyCB8k3DeH7IByz/uin6qD6OIudWLS1ha3Z8PRpAjOjBDpsSL+d03lFz BaP3UCSIlJzrxZDdwqU1jbUoS433o82gkxC6+OVQeudTLuY1D31eMPIwtpVOr4RTnAMf 2+aYLFv2VYgCEwUmL6mReu0kt6Dsl6Bw3RKm6L6MSm4XK4uKHpoaUEEjY+3RueLJS91E P/jEemmTTp7V5+WtJWg7Ill7MxNhj95VAl9/GDkW18m4ntW6T7KtZ0ShuPu44ziTjr+B JglCozsMGr5ZN8kngs8xDgQ4ydeIHlKbYsYvOdWB5Lr9GgQGsrn1dXziQRQOD44SrNgP agUg== 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=0BQoH5e6Vo5VKCH7jA0/hn3YTplKrX7vVJZ+TW7uaHc=; b=awY+NKJ2L/GydXJ87e7UCSn6vCVImNe6H5LO77tP99NnQZDp9m1hFlLOxgtBcXJcKx FeUETY+sxEd+AnkaDaS84cNKt88PBobY/a7cGFh4IZ2CcEUP4hm4aqrxLn6FgPUkUrN/ Z29Wdu4TKAu/pMXQ1ZVHYJF+O1OVV+oTHguwIfdRz8PpPUIa+TWe4OH1svBUnzffuTHG fX29xU9cunR9XEopgHotA/f+NDNhvdcMEObwQEyFkgdbgfKiWjAKWoEi78LFTD9dBeQI A92VCCz4hAyEbvQmm4uGFbTxc2399abv45H7Gxv1Uu43Oaq3u7Y971RESkdh8ZxFjn3Z W5VA== X-Gm-Message-State: AOAM532IUTN25TriMry9w7NQaIisjhP5fuQ+a5UTNkfOrOcrADYhh6wM y0pXq5iy607fwkx4kTxO3N6l X-Google-Smtp-Source: ABdhPJyHdlGs0VLY6eFat3mjD+9C9MAxndXPX0Va3DV4XryieB4S9NGP/Q3yK5UUFLJm7wemV3wgcA== X-Received: by 2002:a17:902:c94d:b029:de:9b70:d886 with SMTP id i13-20020a170902c94db02900de9b70d886mr2851805pla.5.1611032696610; Mon, 18 Jan 2021 21:04:56 -0800 (PST) Received: from localhost ([139.177.225.243]) by smtp.gmail.com with ESMTPSA id gf23sm1052752pjb.48.2021.01.18.21.04.55 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 18 Jan 2021 21:04:56 -0800 (PST) From: Xie Yongji To: mst@redhat.com, jasowang@redhat.com, stefanha@redhat.com, sgarzare@redhat.com, parav@nvidia.com, bob.liu@oracle.com, hch@infradead.org, rdunlap@infradead.org, willy@infradead.org, viro@zeniv.linux.org.uk, axboe@kernel.dk, bcrl@kvack.org, corbet@lwn.net Cc: virtualization@lists.linux-foundation.org, netdev@vger.kernel.org, kvm@vger.kernel.org, linux-aio@kvack.org, linux-fsdevel@vger.kernel.org Subject: [RFC v3 06/11] vhost-vdpa: Add an opaque pointer for vhost IOTLB Date: Tue, 19 Jan 2021 12:59:15 +0800 Message-Id: <20210119045920.447-7-xieyongji@bytedance.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210119045920.447-1-xieyongji@bytedance.com> References: <20210119045920.447-1-xieyongji@bytedance.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: kvm@vger.kernel.org Add an opaque pointer for vhost IOTLB to store the corresponding vma->vm_file and offset on the DMA mapping. It will be used in VDUSE case later. Suggested-by: Jason Wang Signed-off-by: Xie Yongji --- drivers/vdpa/vdpa_sim/vdpa_sim.c | 11 ++++--- drivers/vhost/iotlb.c | 5 ++- drivers/vhost/vdpa.c | 66 +++++++++++++++++++++++++++++++++++----- drivers/vhost/vhost.c | 4 +-- include/linux/vdpa.h | 3 +- include/linux/vhost_iotlb.h | 8 ++++- 6 files changed, 79 insertions(+), 18 deletions(-) diff --git a/drivers/vdpa/vdpa_sim/vdpa_sim.c b/drivers/vdpa/vdpa_sim/vdpa_sim.c index 03c796873a6b..1ffcef67954f 100644 --- a/drivers/vdpa/vdpa_sim/vdpa_sim.c +++ b/drivers/vdpa/vdpa_sim/vdpa_sim.c @@ -279,7 +279,7 @@ static dma_addr_t vdpasim_map_page(struct device *dev, struct page *page, */ spin_lock(&vdpasim->iommu_lock); ret = vhost_iotlb_add_range(iommu, pa, pa + size - 1, - pa, dir_to_perm(dir)); + pa, dir_to_perm(dir), NULL); spin_unlock(&vdpasim->iommu_lock); if (ret) return DMA_MAPPING_ERROR; @@ -317,7 +317,7 @@ static void *vdpasim_alloc_coherent(struct device *dev, size_t size, ret = vhost_iotlb_add_range(iommu, (u64)pa, (u64)pa + size - 1, - pa, VHOST_MAP_RW); + pa, VHOST_MAP_RW, NULL); if (ret) { *dma_addr = DMA_MAPPING_ERROR; kfree(addr); @@ -625,7 +625,8 @@ static int vdpasim_set_map(struct vdpa_device *vdpa, for (map = vhost_iotlb_itree_first(iotlb, start, last); map; map = vhost_iotlb_itree_next(map, start, last)) { ret = vhost_iotlb_add_range(vdpasim->iommu, map->start, - map->last, map->addr, map->perm); + map->last, map->addr, + map->perm, NULL); if (ret) goto err; } @@ -639,14 +640,14 @@ static int vdpasim_set_map(struct vdpa_device *vdpa, } static int vdpasim_dma_map(struct vdpa_device *vdpa, u64 iova, u64 size, - u64 pa, u32 perm) + u64 pa, u32 perm, void *opaque) { struct vdpasim *vdpasim = vdpa_to_sim(vdpa); int ret; spin_lock(&vdpasim->iommu_lock); ret = vhost_iotlb_add_range(vdpasim->iommu, iova, iova + size - 1, pa, - perm); + perm, NULL); spin_unlock(&vdpasim->iommu_lock); return ret; diff --git a/drivers/vhost/iotlb.c b/drivers/vhost/iotlb.c index 0fd3f87e913c..3bd5bd06cdbc 100644 --- a/drivers/vhost/iotlb.c +++ b/drivers/vhost/iotlb.c @@ -42,13 +42,15 @@ EXPORT_SYMBOL_GPL(vhost_iotlb_map_free); * @last: last of IOVA range * @addr: the address that is mapped to @start * @perm: access permission of this range + * @opaque: the opaque pointer for the IOTLB mapping * * Returns an error last is smaller than start or memory allocation * fails */ int vhost_iotlb_add_range(struct vhost_iotlb *iotlb, u64 start, u64 last, - u64 addr, unsigned int perm) + u64 addr, unsigned int perm, + void *opaque) { struct vhost_iotlb_map *map; @@ -71,6 +73,7 @@ int vhost_iotlb_add_range(struct vhost_iotlb *iotlb, map->last = last; map->addr = addr; map->perm = perm; + map->opaque = opaque; iotlb->nmaps++; vhost_iotlb_itree_insert(map, &iotlb->root); diff --git a/drivers/vhost/vdpa.c b/drivers/vhost/vdpa.c index 36b6950ba37f..e83e5be7cec8 100644 --- a/drivers/vhost/vdpa.c +++ b/drivers/vhost/vdpa.c @@ -488,6 +488,7 @@ static void vhost_vdpa_iotlb_unmap(struct vhost_vdpa *v, u64 start, u64 last) struct vhost_dev *dev = &v->vdev; struct vdpa_device *vdpa = v->vdpa; struct vhost_iotlb *iotlb = dev->iotlb; + struct vhost_iotlb_file *iotlb_file; struct vhost_iotlb_map *map; struct page *page; unsigned long pfn, pinned; @@ -504,6 +505,10 @@ static void vhost_vdpa_iotlb_unmap(struct vhost_vdpa *v, u64 start, u64 last) } atomic64_sub(map->size >> PAGE_SHIFT, &dev->mm->pinned_vm); + } else if (map->opaque) { + iotlb_file = (struct vhost_iotlb_file *)map->opaque; + fput(iotlb_file->file); + kfree(iotlb_file); } vhost_iotlb_map_free(iotlb, map); } @@ -540,8 +545,8 @@ static int perm_to_iommu_flags(u32 perm) return flags | IOMMU_CACHE; } -static int vhost_vdpa_map(struct vhost_vdpa *v, - u64 iova, u64 size, u64 pa, u32 perm) +static int vhost_vdpa_map(struct vhost_vdpa *v, u64 iova, + u64 size, u64 pa, u32 perm, void *opaque) { struct vhost_dev *dev = &v->vdev; struct vdpa_device *vdpa = v->vdpa; @@ -549,12 +554,12 @@ static int vhost_vdpa_map(struct vhost_vdpa *v, int r = 0; r = vhost_iotlb_add_range(dev->iotlb, iova, iova + size - 1, - pa, perm); + pa, perm, opaque); if (r) return r; if (ops->dma_map) { - r = ops->dma_map(vdpa, iova, size, pa, perm); + r = ops->dma_map(vdpa, iova, size, pa, perm, opaque); } else if (ops->set_map) { if (!v->in_batch) r = ops->set_map(vdpa, dev->iotlb); @@ -591,6 +596,51 @@ static void vhost_vdpa_unmap(struct vhost_vdpa *v, u64 iova, u64 size) } } +static int vhost_vdpa_sva_map(struct vhost_vdpa *v, + u64 iova, u64 size, u64 uaddr, u32 perm) +{ + u64 offset, map_size, map_iova = iova; + struct vhost_iotlb_file *iotlb_file; + struct vm_area_struct *vma; + int ret; + + while (size) { + vma = find_vma(current->mm, uaddr); + if (!vma) { + ret = -EINVAL; + goto err; + } + map_size = min(size, vma->vm_end - uaddr); + offset = (vma->vm_pgoff << PAGE_SHIFT) + uaddr - vma->vm_start; + iotlb_file = NULL; + if (vma->vm_file && (vma->vm_flags & VM_SHARED)) { + iotlb_file = kmalloc(sizeof(*iotlb_file), GFP_KERNEL); + if (!iotlb_file) { + ret = -ENOMEM; + goto err; + } + iotlb_file->file = get_file(vma->vm_file); + iotlb_file->offset = offset; + } + ret = vhost_vdpa_map(v, map_iova, map_size, uaddr, + perm, iotlb_file); + if (ret) { + if (iotlb_file) { + fput(iotlb_file->file); + kfree(iotlb_file); + } + goto err; + } + size -= map_size; + uaddr += map_size; + map_iova += map_size; + } + return 0; +err: + vhost_vdpa_unmap(v, iova, map_iova - iova); + return ret; +} + static int vhost_vdpa_process_iotlb_update(struct vhost_vdpa *v, struct vhost_iotlb_msg *msg) { @@ -615,8 +665,8 @@ static int vhost_vdpa_process_iotlb_update(struct vhost_vdpa *v, return -EEXIST; if (vdpa->sva) - return vhost_vdpa_map(v, msg->iova, msg->size, - msg->uaddr, msg->perm); + return vhost_vdpa_sva_map(v, msg->iova, msg->size, + msg->uaddr, msg->perm); /* Limit the use of memory for bookkeeping */ page_list = (struct page **) __get_free_page(GFP_KERNEL); @@ -671,7 +721,7 @@ static int vhost_vdpa_process_iotlb_update(struct vhost_vdpa *v, csize = (last_pfn - map_pfn + 1) << PAGE_SHIFT; ret = vhost_vdpa_map(v, iova, csize, map_pfn << PAGE_SHIFT, - msg->perm); + msg->perm, NULL); if (ret) { /* * Unpin the pages that are left unmapped @@ -700,7 +750,7 @@ static int vhost_vdpa_process_iotlb_update(struct vhost_vdpa *v, /* Pin the rest chunk */ ret = vhost_vdpa_map(v, iova, (last_pfn - map_pfn + 1) << PAGE_SHIFT, - map_pfn << PAGE_SHIFT, msg->perm); + map_pfn << PAGE_SHIFT, msg->perm, NULL); out: if (ret) { if (nchunks) { diff --git a/drivers/vhost/vhost.c b/drivers/vhost/vhost.c index a262e12c6dc2..120dd5b3c119 100644 --- a/drivers/vhost/vhost.c +++ b/drivers/vhost/vhost.c @@ -1104,7 +1104,7 @@ static int vhost_process_iotlb_msg(struct vhost_dev *dev, vhost_vq_meta_reset(dev); if (vhost_iotlb_add_range(dev->iotlb, msg->iova, msg->iova + msg->size - 1, - msg->uaddr, msg->perm)) { + msg->uaddr, msg->perm, NULL)) { ret = -ENOMEM; break; } @@ -1450,7 +1450,7 @@ static long vhost_set_memory(struct vhost_dev *d, struct vhost_memory __user *m) region->guest_phys_addr + region->memory_size - 1, region->userspace_addr, - VHOST_MAP_RW)) + VHOST_MAP_RW, NULL)) goto err; } diff --git a/include/linux/vdpa.h b/include/linux/vdpa.h index f86869651614..b264c627e94b 100644 --- a/include/linux/vdpa.h +++ b/include/linux/vdpa.h @@ -189,6 +189,7 @@ struct vdpa_iova_range { * @size: size of the area * @pa: physical address for the map * @perm: device access permission (VHOST_MAP_XX) + * @opaque: the opaque pointer for the mapping * Returns integer: success (0) or error (< 0) * @dma_unmap: Unmap an area of IOVA (optional but * must be implemented with dma_map) @@ -243,7 +244,7 @@ struct vdpa_config_ops { /* DMA ops */ int (*set_map)(struct vdpa_device *vdev, struct vhost_iotlb *iotlb); int (*dma_map)(struct vdpa_device *vdev, u64 iova, u64 size, - u64 pa, u32 perm); + u64 pa, u32 perm, void *opaque); int (*dma_unmap)(struct vdpa_device *vdev, u64 iova, u64 size); /* Free device resources */ diff --git a/include/linux/vhost_iotlb.h b/include/linux/vhost_iotlb.h index 6b09b786a762..66a50c11c8ca 100644 --- a/include/linux/vhost_iotlb.h +++ b/include/linux/vhost_iotlb.h @@ -4,6 +4,11 @@ #include +struct vhost_iotlb_file { + struct file *file; + u64 offset; +}; + struct vhost_iotlb_map { struct rb_node rb; struct list_head link; @@ -17,6 +22,7 @@ struct vhost_iotlb_map { u32 perm; u32 flags_padding; u64 __subtree_last; + void *opaque; }; #define VHOST_IOTLB_FLAG_RETIRE 0x1 @@ -30,7 +36,7 @@ struct vhost_iotlb { }; int vhost_iotlb_add_range(struct vhost_iotlb *iotlb, u64 start, u64 last, - u64 addr, unsigned int perm); + u64 addr, unsigned int perm, void *opaque); void vhost_iotlb_del_range(struct vhost_iotlb *iotlb, u64 start, u64 last); struct vhost_iotlb *vhost_iotlb_alloc(unsigned int limit, unsigned int flags); From patchwork Tue Jan 19 05:07:52 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Yongji Xie X-Patchwork-Id: 12029503 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-16.8 required=3.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,USER_AGENT_GIT autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 9EE1EC433E0 for ; Tue, 19 Jan 2021 08:34:32 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 4B8F12312E for ; Tue, 19 Jan 2021 08:34:32 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S2388982AbhASFXb (ORCPT ); Tue, 19 Jan 2021 00:23:31 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:44952 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727142AbhASFJH (ORCPT ); Tue, 19 Jan 2021 00:09:07 -0500 Received: from mail-pj1-x102c.google.com (mail-pj1-x102c.google.com [IPv6:2607:f8b0:4864:20::102c]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 28D25C061573 for ; Mon, 18 Jan 2021 21:08:17 -0800 (PST) Received: by mail-pj1-x102c.google.com with SMTP id l23so11377038pjg.1 for ; Mon, 18 Jan 2021 21:08:17 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bytedance-com.20150623.gappssmtp.com; s=20150623; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=RrnaBA59g8hmY68FB0uGiq3ZH+VPCQ5FzAHu8kuBTi0=; b=z29oA79dAO5Eg7HZO4XMx7s4Ru1t6D4M4NVANOro1w57eBqbuK5z40d+Qfh6c0LbgC Y3SzDl9749VBiVqMUEhWNpnv6VXOKn4EbZGzPoP6p3zJNYcEoPiwNKGbZYp//xWpgCnt pcWIqCz/aqP67Alc6pvRiSfhwkrdZG5lEqALPS5umJQawGjAsoAUkm33kyib9HD3bZ0T xlXGOdq1d1gKgS5o7raqJgDN8e3wJWBej+6sG0IlKUBBLHf2n1dzUGy+NIWlJHaq0Rws emd0ei9stYdWFRjReNAbLbab0FE/1bD5BjdzyG2fHGjUXREk6M9UHhqEaF+Kbc3vLimJ bCJA== 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=RrnaBA59g8hmY68FB0uGiq3ZH+VPCQ5FzAHu8kuBTi0=; b=f3HNd4n0OtkcH3wSEXBBOu2mE4k+KNT7C2dYPzmI6SRntxKN2PI0babRGVMoyBfjVh VeYrFgk2B2rjkvbRV0jvzZ6xUWU+2kibSazNV40Uo4T1ZCJ+/PGV+8sLUM7jS1TctL17 oxb9O3l50iBYtMlgNSBAcylIzsNoFdmTFrHxECghuOVWCMiOtuzRN0taD9Hlr9Ljt4DZ U2e8nOOHNrRX9QNDgFMTyGCVwT7VYh2PJc+SNgGDBTnvWwTaE4LhiYJ50Tj7cpcvV6KV +LVM0W4UmiwN0Awv/rUWEMRnyq37YRvcxKmB6ZsHbZl/jjp0WNn6Wv2il2ezrdwqJ3qM 8h7Q== X-Gm-Message-State: AOAM530CHMIpXR0gn6E/8qCq3LUXjV6di3RgngaUHfglsOsEp7TiG5qq m5i12scFIcExrUl+hWsq+Py5 X-Google-Smtp-Source: ABdhPJw4iOZN6+kzePO+c/3w2zGQ9FmnKraKZf5KGu+Sgb+AzphhRcL6QARmaJLEVogXeAFcq0yGgg== X-Received: by 2002:a17:902:ba89:b029:dd:7fe3:ddf5 with SMTP id k9-20020a170902ba89b02900dd7fe3ddf5mr2695697pls.33.1611032896783; Mon, 18 Jan 2021 21:08:16 -0800 (PST) Received: from localhost ([139.177.225.243]) by smtp.gmail.com with ESMTPSA id j6sm1101822pjd.33.2021.01.18.21.08.15 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 18 Jan 2021 21:08:16 -0800 (PST) From: Xie Yongji To: mst@redhat.com, jasowang@redhat.com, stefanha@redhat.com, sgarzare@redhat.com, parav@nvidia.com, bob.liu@oracle.com, hch@infradead.org, rdunlap@infradead.org, willy@infradead.org, viro@zeniv.linux.org.uk, axboe@kernel.dk, bcrl@kvack.org, corbet@lwn.net Cc: virtualization@lists.linux-foundation.org, netdev@vger.kernel.org, kvm@vger.kernel.org, linux-aio@kvack.org, linux-fsdevel@vger.kernel.org Subject: [RFC v3 07/11] vdpa: Pass the netlink attributes to ops.dev_add() Date: Tue, 19 Jan 2021 13:07:52 +0800 Message-Id: <20210119050756.600-1-xieyongji@bytedance.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210119045920.447-1-xieyongji@bytedance.com> References: <20210119045920.447-1-xieyongji@bytedance.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: kvm@vger.kernel.org Pass the netlink attributes to ops.dev_add() so that we could get some device specific attributes when creating a vdpa device. Signed-off-by: Xie Yongji --- drivers/vdpa/vdpa.c | 2 +- drivers/vdpa/vdpa_sim/vdpa_sim.c | 3 ++- include/linux/vdpa.h | 4 +++- 3 files changed, 6 insertions(+), 3 deletions(-) diff --git a/drivers/vdpa/vdpa.c b/drivers/vdpa/vdpa.c index 50cab930b2e5..81a099ec390e 100644 --- a/drivers/vdpa/vdpa.c +++ b/drivers/vdpa/vdpa.c @@ -443,7 +443,7 @@ static int vdpa_nl_cmd_dev_add_set_doit(struct sk_buff *skb, struct genl_info *i goto err; } - vdev = pdev->ops->dev_add(pdev, name, device_id); + vdev = pdev->ops->dev_add(pdev, name, device_id, info->attrs); if (IS_ERR(vdev)) goto err; diff --git a/drivers/vdpa/vdpa_sim/vdpa_sim.c b/drivers/vdpa/vdpa_sim/vdpa_sim.c index 1ffcef67954f..ce24a40f5b00 100644 --- a/drivers/vdpa/vdpa_sim/vdpa_sim.c +++ b/drivers/vdpa/vdpa_sim/vdpa_sim.c @@ -728,7 +728,8 @@ static const struct vdpa_config_ops vdpasim_net_batch_config_ops = { }; static struct vdpa_device * -vdpa_dev_add(struct vdpa_parent_dev *pdev, const char *name, u32 device_id) +vdpa_dev_add(struct vdpa_parent_dev *pdev, const char *name, + u32 device_id, struct nlattr **attrs) { struct vdpasim *simdev; diff --git a/include/linux/vdpa.h b/include/linux/vdpa.h index b264c627e94b..7b84badc6741 100644 --- a/include/linux/vdpa.h +++ b/include/linux/vdpa.h @@ -6,6 +6,7 @@ #include #include #include +#include /** * vDPA callback definition. @@ -354,6 +355,7 @@ static inline void vdpa_get_config(struct vdpa_device *vdev, unsigned offset, * @pdev: parent device to use for device addition * @name: name of the new vdpa device * @device_id: device id of the new vdpa device + * @attrs: device specific attributes * Driver need to add a new device using vdpa_register_device() after * fully initializing the vdpa device. On successful addition driver * must return a valid pointer of vdpa device or ERR_PTR for the error. @@ -364,7 +366,7 @@ static inline void vdpa_get_config(struct vdpa_device *vdev, unsigned offset, */ struct vdpa_dev_ops { struct vdpa_device* (*dev_add)(struct vdpa_parent_dev *pdev, const char *name, - u32 device_id); + u32 device_id, struct nlattr **attrs); void (*dev_del)(struct vdpa_parent_dev *pdev, struct vdpa_device *dev); }; From patchwork Tue Jan 19 05:07:53 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Yongji Xie X-Patchwork-Id: 12029501 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-16.8 required=3.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,USER_AGENT_GIT autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 256DEC433DB for ; Tue, 19 Jan 2021 08:33:53 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id B8A712312D for ; Tue, 19 Jan 2021 08:33:52 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S2389052AbhASFXh (ORCPT ); Tue, 19 Jan 2021 00:23:37 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:44976 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727339AbhASFJH (ORCPT ); Tue, 19 Jan 2021 00:09:07 -0500 Received: from mail-pg1-x535.google.com (mail-pg1-x535.google.com [IPv6:2607:f8b0:4864:20::535]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id C7C9AC061757 for ; Mon, 18 Jan 2021 21:08:21 -0800 (PST) Received: by mail-pg1-x535.google.com with SMTP id n10so12270631pgl.10 for ; Mon, 18 Jan 2021 21:08:21 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bytedance-com.20150623.gappssmtp.com; s=20150623; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=X3RPlMFEPCGJ4YEaPIHbmxjgX2R+e2jG8nVJe1O91Ko=; b=xMayhPyLCGGp3uWxmdCS/QBjfbB86PV5GUw4nC7GKwyLa9QKIgQDSLN2DCRVg0uaQL Lq/uCIrJOi4ITHNf90tr0c2AKjIm+jHBghnPyf3IbjFxXVWktPNTa6eP85rlnXvt7zYf 8LspAr8jmwp74QKHRfAELSHDoCYYk2qMC0QOYTlTm2o5rObTXCJqc2LKtSdZPey+L02F u79xeKR//NrKyf8RFAN/h/iNiOrqxRACvUZFY/60Sg2S+JOFiRqHq8Sr0+8oi5UoLNNA 3FDHPO4VOZ69P4VkPLT/Sjeh0Z0lvM0ii4hHqBIYi7AARhVyqp15mLGACsthA+ofNtGQ nzxQ== 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=X3RPlMFEPCGJ4YEaPIHbmxjgX2R+e2jG8nVJe1O91Ko=; b=Z5Uxi0T4Z4Mtcqag4a8fR1ozZTC8iXQzVO0IXo+/R4voQ7Knfv4s/69XuYDkPirN2U UwXmF8jQKxo9W/nHQawc/tZli3qDYFawJaLbey+1vcv6B4aKW/QzAIQPYLlmKXGRUCeY NxHYhVov/hx1EQodSHkGZJeZUv48TbsXbUQVaDkUud2jkpKv4hSHKZQrVpilVa3a/DU+ PO7ZMoMDF4/PQMdK0/dSlP90CkUl2N6fXThqnlq6lGdaJp8DkPVyBrnpeYghy9b6gfh8 CvhiizUZl1W194s8kiLV+kQ04SD56LAiRtjMtsYl7fplJpb/bP8Gag7aKo1ji1+eaxim tWTA== X-Gm-Message-State: AOAM531ECJ/kDY+WKua35nm8wSASY3nli9kir61sPQ2OwWGgwzDfQYH8 fneRZo1WZrGyuQmD2VAWiYCa X-Google-Smtp-Source: ABdhPJwgiEvqMUDb8p/SlDvdrPbGREy3CLngIuLcB2KRSohppgSWX/PrCq5qTgBlN71lbJBdKoXLXg== X-Received: by 2002:a62:844b:0:b029:19e:62a0:ca18 with SMTP id k72-20020a62844b0000b029019e62a0ca18mr2782394pfd.46.1611032900857; Mon, 18 Jan 2021 21:08:20 -0800 (PST) Received: from localhost ([139.177.225.243]) by smtp.gmail.com with ESMTPSA id o14sm17958539pgr.44.2021.01.18.21.08.19 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 18 Jan 2021 21:08:20 -0800 (PST) From: Xie Yongji To: mst@redhat.com, jasowang@redhat.com, stefanha@redhat.com, sgarzare@redhat.com, parav@nvidia.com, bob.liu@oracle.com, hch@infradead.org, rdunlap@infradead.org, willy@infradead.org, viro@zeniv.linux.org.uk, axboe@kernel.dk, bcrl@kvack.org, corbet@lwn.net Cc: virtualization@lists.linux-foundation.org, netdev@vger.kernel.org, kvm@vger.kernel.org, linux-aio@kvack.org, linux-fsdevel@vger.kernel.org Subject: [RFC v3 08/11] vduse: Introduce VDUSE - vDPA Device in Userspace Date: Tue, 19 Jan 2021 13:07:53 +0800 Message-Id: <20210119050756.600-2-xieyongji@bytedance.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210119050756.600-1-xieyongji@bytedance.com> References: <20210119045920.447-1-xieyongji@bytedance.com> <20210119050756.600-1-xieyongji@bytedance.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: kvm@vger.kernel.org This VDUSE driver enables implementing vDPA devices in userspace. Both control path and data path of vDPA devices will be able to be handled in userspace. In the control path, the VDUSE driver will make use of message mechnism to forward the config operation from vdpa bus driver to userspace. Userspace can use read()/write() to receive/reply those control messages. In the data path, VDUSE_IOTLB_GET_FD ioctl will be used to get the file descriptors referring to vDPA device's iova regions. Then userspace can use mmap() to access those iova regions. Besides, the eventfd mechanism is used to trigger interrupt callbacks and receive virtqueue kicks in userspace. Signed-off-by: Xie Yongji --- Documentation/driver-api/vduse.rst | 85 ++ Documentation/userspace-api/ioctl/ioctl-number.rst | 1 + drivers/vdpa/Kconfig | 7 + drivers/vdpa/Makefile | 1 + drivers/vdpa/vdpa_user/Makefile | 5 + drivers/vdpa/vdpa_user/eventfd.c | 221 ++++ drivers/vdpa/vdpa_user/eventfd.h | 48 + drivers/vdpa/vdpa_user/iova_domain.c | 426 +++++++ drivers/vdpa/vdpa_user/iova_domain.h | 68 ++ drivers/vdpa/vdpa_user/vduse.h | 62 + drivers/vdpa/vdpa_user/vduse_dev.c | 1217 ++++++++++++++++++++ include/uapi/linux/vdpa.h | 1 + include/uapi/linux/vduse.h | 125 ++ 13 files changed, 2267 insertions(+) create mode 100644 Documentation/driver-api/vduse.rst create mode 100644 drivers/vdpa/vdpa_user/Makefile create mode 100644 drivers/vdpa/vdpa_user/eventfd.c create mode 100644 drivers/vdpa/vdpa_user/eventfd.h create mode 100644 drivers/vdpa/vdpa_user/iova_domain.c create mode 100644 drivers/vdpa/vdpa_user/iova_domain.h create mode 100644 drivers/vdpa/vdpa_user/vduse.h create mode 100644 drivers/vdpa/vdpa_user/vduse_dev.c create mode 100644 include/uapi/linux/vduse.h diff --git a/Documentation/driver-api/vduse.rst b/Documentation/driver-api/vduse.rst new file mode 100644 index 000000000000..9418a7f6646b --- /dev/null +++ b/Documentation/driver-api/vduse.rst @@ -0,0 +1,85 @@ +================================== +VDUSE - "vDPA Device in Userspace" +================================== + +vDPA (virtio data path acceleration) device is a device that uses a +datapath which complies with the virtio specifications with vendor +specific control path. vDPA devices can be both physically located on +the hardware or emulated by software. VDUSE is a framework that makes it +possible to implement software-emulated vDPA devices in userspace. + +How VDUSE works +------------ +Each userspace vDPA device is created by the VDUSE_CREATE_DEV ioctl on +the VDUSE character device (/dev/vduse). Then a file descriptor pointing +to the new resources will be returned, which can be used to implement the +userspace vDPA device's control path and data path. + +To implement control path, the read/write operations to the file descriptor +will be used to receive/reply the control messages from/to VDUSE driver. +Those control messages are mostly based on the vdpa_config_ops which defines +a unified interface to control different types of vDPA device. + +The following types of messages are provided by the VDUSE framework now: + +- VDUSE_SET_VQ_ADDR: Set the addresses of the different aspects of virtqueue. + +- VDUSE_SET_VQ_NUM: Set the size of virtqueue + +- VDUSE_SET_VQ_READY: Set ready status of virtqueue + +- VDUSE_GET_VQ_READY: Get ready status of virtqueue + +- VDUSE_SET_VQ_STATE: Set the state (last_avail_idx) for virtqueue + +- VDUSE_GET_VQ_STATE: Get the state (last_avail_idx) for virtqueue + +- VDUSE_SET_FEATURES: Set virtio features supported by the driver + +- VDUSE_GET_FEATURES: Get virtio features supported by the device + +- VDUSE_SET_STATUS: Set the device status + +- VDUSE_GET_STATUS: Get the device status + +- VDUSE_SET_CONFIG: Write to device specific configuration space + +- VDUSE_GET_CONFIG: Read from device specific configuration space + +- VDUSE_UPDATE_IOTLB: Notify userspace to update the memory mapping in device IOTLB + +Please see include/linux/vdpa.h for details. + +In the data path, vDPA device's iova regions will be mapped into userspace with +the help of VDUSE_IOTLB_GET_FD ioctl on the userspace vDPA device fd: + +- VDUSE_IOTLB_GET_FD: get the file descriptor to iova region. Userspace can + access this iova region by passing the fd to mmap(2). + +Besides, the eventfd mechanism is used to trigger interrupt callbacks and +receive virtqueue kicks in userspace. The following ioctls on the userspace +vDPA device fd are provided to support that: + +- VDUSE_VQ_SETUP_KICKFD: set the kickfd for virtqueue, this eventfd is used + by VDUSE driver to notify userspace to consume the vring. + +- VDUSE_VQ_SETUP_IRQFD: set the irqfd for virtqueue, this eventfd is used + by userspace to notify VDUSE driver to trigger interrupt callbacks. + +MMU-based IOMMU Driver +---------------------- +In virtio-vdpa case, VDUSE framework implements a MMU-based on-chip IOMMU +driver to support mapping the kernel dma buffer into the userspace iova +region dynamically. + +The basic idea behind this driver is treating MMU (VA->PA) as IOMMU (IOVA->PA). +The driver will set up MMU mapping instead of IOMMU mapping for the DMA transfer +so that the userspace process is able to use its virtual address to access +the dma buffer in kernel. + +And to avoid security issue, a bounce-buffering mechanism is introduced to +prevent userspace accessing the original buffer directly which may contain other +kernel data. During the mapping, unmapping, the driver will copy the data from +the original buffer to the bounce buffer and back, depending on the direction of +the transfer. And the bounce-buffer addresses will be mapped into the user address +space instead of the original one. diff --git a/Documentation/userspace-api/ioctl/ioctl-number.rst b/Documentation/userspace-api/ioctl/ioctl-number.rst index a4c75a28c839..71722e6f8f23 100644 --- a/Documentation/userspace-api/ioctl/ioctl-number.rst +++ b/Documentation/userspace-api/ioctl/ioctl-number.rst @@ -300,6 +300,7 @@ Code Seq# Include File Comments 'z' 10-4F drivers/s390/crypto/zcrypt_api.h conflict! '|' 00-7F linux/media.h 0x80 00-1F linux/fb.h +0x81 00-1F linux/vduse.h 0x89 00-06 arch/x86/include/asm/sockios.h 0x89 0B-DF linux/sockios.h 0x89 E0-EF linux/sockios.h SIOCPROTOPRIVATE range diff --git a/drivers/vdpa/Kconfig b/drivers/vdpa/Kconfig index 4be7be39be26..667354309bf4 100644 --- a/drivers/vdpa/Kconfig +++ b/drivers/vdpa/Kconfig @@ -21,6 +21,13 @@ config VDPA_SIM to RX. This device is used for testing, prototyping and development of vDPA. +config VDPA_USER + tristate "VDUSE (vDPA Device in Userspace) support" + depends on EVENTFD && MMU && HAS_DMA + help + With VDUSE it is possible to emulate a vDPA Device + in a userspace program. + config IFCVF tristate "Intel IFC VF vDPA driver" depends on PCI_MSI diff --git a/drivers/vdpa/Makefile b/drivers/vdpa/Makefile index d160e9b63a66..66e97778ad03 100644 --- a/drivers/vdpa/Makefile +++ b/drivers/vdpa/Makefile @@ -1,5 +1,6 @@ # SPDX-License-Identifier: GPL-2.0 obj-$(CONFIG_VDPA) += vdpa.o obj-$(CONFIG_VDPA_SIM) += vdpa_sim/ +obj-$(CONFIG_VDPA_USER) += vdpa_user/ obj-$(CONFIG_IFCVF) += ifcvf/ obj-$(CONFIG_MLX5_VDPA) += mlx5/ diff --git a/drivers/vdpa/vdpa_user/Makefile b/drivers/vdpa/vdpa_user/Makefile new file mode 100644 index 000000000000..b7645e36992b --- /dev/null +++ b/drivers/vdpa/vdpa_user/Makefile @@ -0,0 +1,5 @@ +# SPDX-License-Identifier: GPL-2.0 + +vduse-y := vduse_dev.o iova_domain.o eventfd.o + +obj-$(CONFIG_VDPA_USER) += vduse.o diff --git a/drivers/vdpa/vdpa_user/eventfd.c b/drivers/vdpa/vdpa_user/eventfd.c new file mode 100644 index 000000000000..dbffddb08908 --- /dev/null +++ b/drivers/vdpa/vdpa_user/eventfd.c @@ -0,0 +1,221 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Eventfd support for VDUSE + * + * Copyright (C) 2020 Bytedance Inc. and/or its affiliates. All rights reserved. + * + * Author: Xie Yongji + * + */ + +#include +#include +#include +#include +#include +#include + +#include "eventfd.h" + +static struct workqueue_struct *vduse_irqfd_cleanup_wq; + +static void vduse_virqfd_shutdown(struct work_struct *work) +{ + u64 cnt; + struct vduse_virqfd *virqfd = container_of(work, + struct vduse_virqfd, shutdown); + + eventfd_ctx_remove_wait_queue(virqfd->ctx, &virqfd->wait, &cnt); + flush_work(&virqfd->inject); + eventfd_ctx_put(virqfd->ctx); + kfree(virqfd); +} + +static void vduse_virqfd_inject(struct work_struct *work) +{ + struct vduse_virqfd *virqfd = container_of(work, + struct vduse_virqfd, inject); + struct vduse_virtqueue *vq = virqfd->vq; + + spin_lock_irq(&vq->irq_lock); + if (vq->ready && vq->cb) + vq->cb(vq->private); + spin_unlock_irq(&vq->irq_lock); +} + +static void virqfd_deactivate(struct vduse_virqfd *virqfd) +{ + queue_work(vduse_irqfd_cleanup_wq, &virqfd->shutdown); +} + +static int vduse_virqfd_wakeup(wait_queue_entry_t *wait, unsigned int mode, + int sync, void *key) +{ + struct vduse_virqfd *virqfd = container_of(wait, struct vduse_virqfd, wait); + struct vduse_virtqueue *vq = virqfd->vq; + + __poll_t flags = key_to_poll(key); + + if (flags & EPOLLIN) + schedule_work(&virqfd->inject); + + if (flags & EPOLLHUP) { + spin_lock(&vq->irq_lock); + if (vq->virqfd == virqfd) { + vq->virqfd = NULL; + virqfd_deactivate(virqfd); + } + spin_unlock(&vq->irq_lock); + } + + return 0; +} + +static void vduse_virqfd_ptable_queue_proc(struct file *file, + wait_queue_head_t *wqh, poll_table *pt) +{ + struct vduse_virqfd *virqfd = container_of(pt, struct vduse_virqfd, pt); + + add_wait_queue(wqh, &virqfd->wait); +} + +int vduse_virqfd_setup(struct vduse_dev *dev, + struct vduse_vq_eventfd *eventfd) +{ + struct vduse_virqfd *virqfd; + struct fd irqfd; + struct eventfd_ctx *ctx; + struct vduse_virtqueue *vq; + __poll_t events; + int ret; + + if (eventfd->index >= dev->vq_num) + return -EINVAL; + + vq = &dev->vqs[eventfd->index]; + virqfd = kzalloc(sizeof(*virqfd), GFP_KERNEL); + if (!virqfd) + return -ENOMEM; + + INIT_WORK(&virqfd->shutdown, vduse_virqfd_shutdown); + INIT_WORK(&virqfd->inject, vduse_virqfd_inject); + + ret = -EBADF; + irqfd = fdget(eventfd->fd); + if (!irqfd.file) + goto err_fd; + + ctx = eventfd_ctx_fileget(irqfd.file); + if (IS_ERR(ctx)) { + ret = PTR_ERR(ctx); + goto err_ctx; + } + + virqfd->vq = vq; + virqfd->ctx = ctx; + spin_lock(&vq->irq_lock); + if (vq->virqfd) + virqfd_deactivate(virqfd); + vq->virqfd = virqfd; + spin_unlock(&vq->irq_lock); + + init_waitqueue_func_entry(&virqfd->wait, vduse_virqfd_wakeup); + init_poll_funcptr(&virqfd->pt, vduse_virqfd_ptable_queue_proc); + + events = vfs_poll(irqfd.file, &virqfd->pt); + + /* + * Check if there was an event already pending on the eventfd + * before we registered and trigger it as if we didn't miss it. + */ + if (events & EPOLLIN) + schedule_work(&virqfd->inject); + + fdput(irqfd); + + return 0; +err_ctx: + fdput(irqfd); +err_fd: + kfree(virqfd); + return ret; +} + +void vduse_virqfd_release(struct vduse_dev *dev) +{ + int i; + + for (i = 0; i < dev->vq_num; i++) { + struct vduse_virtqueue *vq = &dev->vqs[i]; + + spin_lock(&vq->irq_lock); + if (vq->virqfd) { + virqfd_deactivate(vq->virqfd); + vq->virqfd = NULL; + } + spin_unlock(&vq->irq_lock); + } + flush_workqueue(vduse_irqfd_cleanup_wq); +} + +int vduse_virqfd_init(void) +{ + vduse_irqfd_cleanup_wq = alloc_workqueue("vduse-irqfd-cleanup", + WQ_UNBOUND, 0); + if (!vduse_irqfd_cleanup_wq) + return -ENOMEM; + + return 0; +} + +void vduse_virqfd_exit(void) +{ + destroy_workqueue(vduse_irqfd_cleanup_wq); +} + +void vduse_vq_kick(struct vduse_virtqueue *vq) +{ + spin_lock(&vq->kick_lock); + if (vq->ready && vq->kickfd) + eventfd_signal(vq->kickfd, 1); + spin_unlock(&vq->kick_lock); +} + +int vduse_kickfd_setup(struct vduse_dev *dev, + struct vduse_vq_eventfd *eventfd) +{ + struct eventfd_ctx *ctx; + struct vduse_virtqueue *vq; + + if (eventfd->index >= dev->vq_num) + return -EINVAL; + + vq = &dev->vqs[eventfd->index]; + ctx = eventfd_ctx_fdget(eventfd->fd); + if (IS_ERR(ctx)) + return PTR_ERR(ctx); + + spin_lock(&vq->kick_lock); + if (vq->kickfd) + eventfd_ctx_put(vq->kickfd); + vq->kickfd = ctx; + spin_unlock(&vq->kick_lock); + + return 0; +} + +void vduse_kickfd_release(struct vduse_dev *dev) +{ + int i; + + for (i = 0; i < dev->vq_num; i++) { + struct vduse_virtqueue *vq = &dev->vqs[i]; + + spin_lock(&vq->kick_lock); + if (vq->kickfd) { + eventfd_ctx_put(vq->kickfd); + vq->kickfd = NULL; + } + spin_unlock(&vq->kick_lock); + } +} diff --git a/drivers/vdpa/vdpa_user/eventfd.h b/drivers/vdpa/vdpa_user/eventfd.h new file mode 100644 index 000000000000..14269ff27f47 --- /dev/null +++ b/drivers/vdpa/vdpa_user/eventfd.h @@ -0,0 +1,48 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* + * Eventfd support for VDUSE + * + * Copyright (C) 2020 Bytedance Inc. and/or its affiliates. All rights reserved. + * + * Author: Xie Yongji + * + */ + +#ifndef _VDUSE_EVENTFD_H +#define _VDUSE_EVENTFD_H + +#include +#include +#include +#include + +#include "vduse.h" + +struct vduse_dev; + +struct vduse_virqfd { + struct eventfd_ctx *ctx; + struct vduse_virtqueue *vq; + struct work_struct inject; + struct work_struct shutdown; + wait_queue_entry_t wait; + poll_table pt; +}; + +int vduse_virqfd_setup(struct vduse_dev *dev, + struct vduse_vq_eventfd *eventfd); + +void vduse_virqfd_release(struct vduse_dev *dev); + +int vduse_virqfd_init(void); + +void vduse_virqfd_exit(void); + +void vduse_vq_kick(struct vduse_virtqueue *vq); + +int vduse_kickfd_setup(struct vduse_dev *dev, + struct vduse_vq_eventfd *eventfd); + +void vduse_kickfd_release(struct vduse_dev *dev); + +#endif /* _VDUSE_EVENTFD_H */ diff --git a/drivers/vdpa/vdpa_user/iova_domain.c b/drivers/vdpa/vdpa_user/iova_domain.c new file mode 100644 index 000000000000..cdfef8e9f9d6 --- /dev/null +++ b/drivers/vdpa/vdpa_user/iova_domain.c @@ -0,0 +1,426 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * MMU-based IOMMU implementation + * + * Copyright (C) 2020 Bytedance Inc. and/or its affiliates. All rights reserved. + * + * Author: Xie Yongji + * + */ + +#include +#include +#include + +#include "iova_domain.h" + +#define IOVA_START_PFN 1 +#define IOVA_ALLOC_ORDER 12 +#define IOVA_ALLOC_SIZE (1 << IOVA_ALLOC_ORDER) + +#define CONSISTENT_DMA_SIZE (1024 * 1024 * 1024) + +static inline struct page * +vduse_domain_get_bounce_page(struct vduse_iova_domain *domain, + unsigned long iova) +{ + unsigned long index = iova >> PAGE_SHIFT; + + return domain->bounce_pages[index]; +} + +static inline void +vduse_domain_set_bounce_page(struct vduse_iova_domain *domain, + unsigned long iova, struct page *page) +{ + unsigned long index = iova >> PAGE_SHIFT; + + domain->bounce_pages[index] = page; +} + +static struct vduse_iova_map * +vduse_domain_alloc_iova_map(struct vduse_iova_domain *domain, + unsigned long iova, unsigned long orig, + size_t size, enum dma_data_direction dir) +{ + struct vduse_iova_map *map; + + map = kzalloc(sizeof(struct vduse_iova_map), GFP_ATOMIC); + if (!map) + return NULL; + + map->iova.start = iova; + map->iova.last = iova + size - 1; + map->orig = orig; + map->size = size; + map->dir = dir; + + return map; +} + +static struct page * +vduse_domain_get_mapping_page(struct vduse_iova_domain *domain, + unsigned long iova) +{ + unsigned long start = iova & PAGE_MASK; + unsigned long last = start + PAGE_SIZE - 1; + struct vduse_iova_map *map; + struct interval_tree_node *node; + struct page *page = NULL; + + spin_lock(&domain->map_lock); + node = interval_tree_iter_first(&domain->mappings, start, last); + if (!node) + goto out; + + map = container_of(node, struct vduse_iova_map, iova); + page = virt_to_page(map->orig + iova - map->iova.start); + get_page(page); +out: + spin_unlock(&domain->map_lock); + + return page; +} + +static struct page * +vduse_domain_alloc_bounce_page(struct vduse_iova_domain *domain, + unsigned long iova) +{ + unsigned long start = iova & PAGE_MASK; + unsigned long last = start + PAGE_SIZE - 1; + struct vduse_iova_map *map; + struct interval_tree_node *node; + struct page *page = NULL, *new_page = alloc_page(GFP_KERNEL); + + if (!new_page) + return NULL; + + spin_lock(&domain->map_lock); + node = interval_tree_iter_first(&domain->mappings, start, last); + if (!node) { + __free_page(new_page); + goto out; + } + page = vduse_domain_get_bounce_page(domain, iova); + if (page) { + get_page(page); + __free_page(new_page); + goto out; + } + vduse_domain_set_bounce_page(domain, iova, new_page); + get_page(new_page); + page = new_page; + + while (node) { + unsigned int src_offset = 0, dst_offset = 0; + void *src, *dst; + size_t copy_len; + + map = container_of(node, struct vduse_iova_map, iova); + node = interval_tree_iter_next(node, start, last); + if (map->dir == DMA_FROM_DEVICE) + continue; + + if (start > map->iova.start) + src_offset = start - map->iova.start; + else + dst_offset = map->iova.start - start; + + src = (void *)(map->orig + src_offset); + dst = page_address(page) + dst_offset; + copy_len = min_t(size_t, map->size - src_offset, + PAGE_SIZE - dst_offset); + memcpy(dst, src, copy_len); + } +out: + spin_unlock(&domain->map_lock); + + return page; +} + +static void +vduse_domain_free_bounce_pages(struct vduse_iova_domain *domain, + unsigned long iova, size_t size) +{ + struct page *page; + struct interval_tree_node *node; + unsigned long last = iova + size - 1; + + spin_lock(&domain->map_lock); + node = interval_tree_iter_first(&domain->mappings, iova, last); + if (WARN_ON(node)) + goto out; + + while (size > 0) { + page = vduse_domain_get_bounce_page(domain, iova); + if (page) { + vduse_domain_set_bounce_page(domain, iova, NULL); + __free_page(page); + } + size -= PAGE_SIZE; + iova += PAGE_SIZE; + } +out: + spin_unlock(&domain->map_lock); +} + +static void vduse_domain_bounce(struct vduse_iova_domain *domain, + unsigned long iova, unsigned long orig, + size_t size, enum dma_data_direction dir) +{ + unsigned int offset = offset_in_page(iova); + + while (size) { + struct page *p = vduse_domain_get_bounce_page(domain, iova); + size_t copy_len = min_t(size_t, PAGE_SIZE - offset, size); + void *addr; + + WARN_ON(!p && dir == DMA_FROM_DEVICE); + + if (p) { + addr = page_address(p) + offset; + if (dir == DMA_TO_DEVICE) + memcpy(addr, (void *)orig, copy_len); + else if (dir == DMA_FROM_DEVICE) + memcpy((void *)orig, addr, copy_len); + } + + size -= copy_len; + orig += copy_len; + iova += copy_len; + offset = 0; + } +} + +static unsigned long vduse_domain_alloc_iova(struct iova_domain *iovad, + unsigned long size, unsigned long limit) +{ + unsigned long shift = iova_shift(iovad); + unsigned long iova_len = iova_align(iovad, size) >> shift; + unsigned long iova_pfn; + + if (iova_len < (1 << (IOVA_RANGE_CACHE_MAX_SIZE - 1))) + iova_len = roundup_pow_of_two(iova_len); + iova_pfn = alloc_iova_fast(iovad, iova_len, limit >> shift, true); + + return iova_pfn << shift; +} + +static void vduse_domain_free_iova(struct iova_domain *iovad, + unsigned long iova, size_t size) +{ + unsigned long shift = iova_shift(iovad); + unsigned long iova_len = iova_align(iovad, size) >> shift; + + free_iova_fast(iovad, iova >> shift, iova_len); +} + +dma_addr_t vduse_domain_map_page(struct vduse_iova_domain *domain, + struct page *page, unsigned long offset, + size_t size, enum dma_data_direction dir, + unsigned long attrs) +{ + struct iova_domain *iovad = &domain->stream_iovad; + unsigned long limit = domain->bounce_size - 1; + unsigned long iova = vduse_domain_alloc_iova(iovad, size, limit); + unsigned long orig = (unsigned long)page_address(page) + offset; + struct vduse_iova_map *map; + + if (!iova) + return DMA_MAPPING_ERROR; + + map = vduse_domain_alloc_iova_map(domain, iova, orig, size, dir); + if (!map) { + vduse_domain_free_iova(iovad, iova, size); + return DMA_MAPPING_ERROR; + } + + spin_lock(&domain->map_lock); + interval_tree_insert(&map->iova, &domain->mappings); + spin_unlock(&domain->map_lock); + + if (dir == DMA_TO_DEVICE || dir == DMA_BIDIRECTIONAL) + vduse_domain_bounce(domain, iova, orig, size, DMA_TO_DEVICE); + + return (dma_addr_t)iova; +} + +void vduse_domain_unmap_page(struct vduse_iova_domain *domain, + dma_addr_t dma_addr, size_t size, + enum dma_data_direction dir, unsigned long attrs) +{ + struct iova_domain *iovad = &domain->stream_iovad; + unsigned long iova = (unsigned long)dma_addr; + struct interval_tree_node *node; + struct vduse_iova_map *map; + + spin_lock(&domain->map_lock); + node = interval_tree_iter_first(&domain->mappings, iova, iova + 1); + if (WARN_ON(!node)) { + spin_unlock(&domain->map_lock); + return; + } + interval_tree_remove(node, &domain->mappings); + spin_unlock(&domain->map_lock); + + map = container_of(node, struct vduse_iova_map, iova); + if (dir == DMA_FROM_DEVICE || dir == DMA_BIDIRECTIONAL) + vduse_domain_bounce(domain, iova, map->orig, + size, DMA_FROM_DEVICE); + vduse_domain_free_iova(iovad, iova, size); + kfree(map); +} + +void *vduse_domain_alloc_coherent(struct vduse_iova_domain *domain, + size_t size, dma_addr_t *dma_addr, + gfp_t flag, unsigned long attrs) +{ + struct iova_domain *iovad = &domain->consistent_iovad; + unsigned long limit = domain->bounce_size + CONSISTENT_DMA_SIZE - 1; + unsigned long iova = vduse_domain_alloc_iova(iovad, size, limit); + void *orig = alloc_pages_exact(size, flag); + struct vduse_iova_map *map; + + if (!iova || !orig) + goto err; + + map = vduse_domain_alloc_iova_map(domain, iova, (unsigned long)orig, + size, DMA_BIDIRECTIONAL); + if (!map) + goto err; + + spin_lock(&domain->map_lock); + interval_tree_insert(&map->iova, &domain->mappings); + spin_unlock(&domain->map_lock); + *dma_addr = (dma_addr_t)iova; + + return orig; +err: + *dma_addr = DMA_MAPPING_ERROR; + if (orig) + free_pages_exact(orig, size); + if (iova) + vduse_domain_free_iova(iovad, iova, size); + + return NULL; +} + +void vduse_domain_free_coherent(struct vduse_iova_domain *domain, size_t size, + void *vaddr, dma_addr_t dma_addr, + unsigned long attrs) +{ + struct iova_domain *iovad = &domain->consistent_iovad; + unsigned long iova = (unsigned long)dma_addr; + struct interval_tree_node *node; + struct vduse_iova_map *map; + + spin_lock(&domain->map_lock); + node = interval_tree_iter_first(&domain->mappings, iova, iova + 1); + if (WARN_ON(!node)) { + spin_unlock(&domain->map_lock); + return; + } + interval_tree_remove(node, &domain->mappings); + spin_unlock(&domain->map_lock); + + map = container_of(node, struct vduse_iova_map, iova); + vduse_domain_free_iova(iovad, iova, size); + free_pages_exact(vaddr, size); + kfree(map); +} + +static vm_fault_t vduse_domain_mmap_fault(struct vm_fault *vmf) +{ + struct vduse_iova_domain *domain = vmf->vma->vm_private_data; + unsigned long iova = vmf->pgoff << PAGE_SHIFT; + struct page *page; + + if (!domain) + return VM_FAULT_SIGBUS; + + if (iova < domain->bounce_size) + page = vduse_domain_alloc_bounce_page(domain, iova); + else + page = vduse_domain_get_mapping_page(domain, iova); + + if (!page) + return VM_FAULT_SIGBUS; + + vmf->page = page; + + return 0; +} + +static const struct vm_operations_struct vduse_domain_mmap_ops = { + .fault = vduse_domain_mmap_fault, +}; + +static int vduse_domain_mmap(struct file *file, struct vm_area_struct *vma) +{ + struct vduse_iova_domain *domain = file->private_data; + + vma->vm_flags |= VM_DONTCOPY | VM_DONTDUMP | VM_DONTEXPAND; + vma->vm_private_data = domain; + vma->vm_ops = &vduse_domain_mmap_ops; + + return 0; +} + +static int vduse_domain_release(struct inode *inode, struct file *file) +{ + struct vduse_iova_domain *domain = file->private_data; + + vduse_domain_free_bounce_pages(domain, 0, domain->bounce_size); + put_iova_domain(&domain->stream_iovad); + put_iova_domain(&domain->consistent_iovad); + vfree(domain->bounce_pages); + kfree(domain); + + return 0; +} + +static const struct file_operations vduse_domain_fops = { + .mmap = vduse_domain_mmap, + .release = vduse_domain_release, +}; + +void vduse_domain_destroy(struct vduse_iova_domain *domain) +{ + fput(domain->file); +} + +struct vduse_iova_domain *vduse_domain_create(size_t bounce_size) +{ + struct vduse_iova_domain *domain; + struct file *file; + unsigned long bounce_pfns = PAGE_ALIGN(bounce_size) >> PAGE_SHIFT; + + domain = kzalloc(sizeof(*domain), GFP_KERNEL); + if (!domain) + return NULL; + + domain->bounce_size = PAGE_ALIGN(bounce_size); + domain->bounce_pages = vzalloc(bounce_pfns * sizeof(struct page *)); + if (!domain->bounce_pages) + goto err_page; + + file = anon_inode_getfile("[vduse-domain]", &vduse_domain_fops, + domain, O_RDWR); + if (IS_ERR(file)) + goto err_file; + + domain->file = file; + spin_lock_init(&domain->map_lock); + domain->mappings = RB_ROOT_CACHED; + init_iova_domain(&domain->stream_iovad, + IOVA_ALLOC_SIZE, IOVA_START_PFN); + init_iova_domain(&domain->consistent_iovad, + PAGE_SIZE, bounce_pfns); + + return domain; +err_file: + vfree(domain->bounce_pages); +err_page: + kfree(domain); + return NULL; +} diff --git a/drivers/vdpa/vdpa_user/iova_domain.h b/drivers/vdpa/vdpa_user/iova_domain.h new file mode 100644 index 000000000000..cc61866acb56 --- /dev/null +++ b/drivers/vdpa/vdpa_user/iova_domain.h @@ -0,0 +1,68 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* + * MMU-based IOMMU implementation + * + * Copyright (C) 2020 Bytedance Inc. and/or its affiliates. All rights reserved. + * + * Author: Xie Yongji + * + */ + +#ifndef _VDUSE_IOVA_DOMAIN_H +#define _VDUSE_IOVA_DOMAIN_H + +#include +#include +#include + +struct vduse_iova_map { + struct interval_tree_node iova; + unsigned long orig; + size_t size; + enum dma_data_direction dir; +}; + +struct vduse_iova_domain { + struct iova_domain stream_iovad; + struct iova_domain consistent_iovad; + struct page **bounce_pages; + size_t bounce_size; + struct rb_root_cached mappings; + spinlock_t map_lock; + struct file *file; +}; + +static inline struct file * +vduse_domain_file(struct vduse_iova_domain *domain) +{ + return domain->file; +} + +static inline unsigned long +vduse_domain_get_offset(struct vduse_iova_domain *domain, unsigned long iova) +{ + return iova; +} + +dma_addr_t vduse_domain_map_page(struct vduse_iova_domain *domain, + struct page *page, unsigned long offset, + size_t size, enum dma_data_direction dir, + unsigned long attrs); + +void vduse_domain_unmap_page(struct vduse_iova_domain *domain, + dma_addr_t dma_addr, size_t size, + enum dma_data_direction dir, unsigned long attrs); + +void *vduse_domain_alloc_coherent(struct vduse_iova_domain *domain, + size_t size, dma_addr_t *dma_addr, + gfp_t flag, unsigned long attrs); + +void vduse_domain_free_coherent(struct vduse_iova_domain *domain, size_t size, + void *vaddr, dma_addr_t dma_addr, + unsigned long attrs); + +void vduse_domain_destroy(struct vduse_iova_domain *domain); + +struct vduse_iova_domain *vduse_domain_create(size_t bounce_size); + +#endif /* _VDUSE_IOVA_DOMAIN_H */ diff --git a/drivers/vdpa/vdpa_user/vduse.h b/drivers/vdpa/vdpa_user/vduse.h new file mode 100644 index 000000000000..3566d229382e --- /dev/null +++ b/drivers/vdpa/vdpa_user/vduse.h @@ -0,0 +1,62 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* + * VDUSE: vDPA Device in Userspace + * + * Copyright (C) 2020 Bytedance Inc. and/or its affiliates. All rights reserved. + * + * Author: Xie Yongji + * + */ + +#ifndef _VDUSE_H +#define _VDUSE_H + +#include +#include +#include + +#include "iova_domain.h" +#include "eventfd.h" + +struct vduse_virtqueue { + u16 index; + bool ready; + spinlock_t kick_lock; + spinlock_t irq_lock; + struct eventfd_ctx *kickfd; + struct vduse_virqfd *virqfd; + void *private; + irqreturn_t (*cb)(void *data); +}; + +struct vduse_dev; + +struct vduse_vdpa { + struct vdpa_device vdpa; + struct vduse_dev *dev; +}; + +struct vduse_dev { + struct vduse_vdpa *vdev; + struct mutex lock; + struct vduse_virtqueue *vqs; + struct vduse_iova_domain *domain; + struct vhost_iotlb *iommu; + spinlock_t iommu_lock; + atomic_t bounce_map; + spinlock_t msg_lock; + atomic64_t msg_unique; + wait_queue_head_t waitq; + struct list_head send_list; + struct list_head recv_list; + struct list_head list; + bool connected; + u32 id; + u16 vq_size_max; + u16 vq_num; + u32 vq_align; + u32 device_id; + u32 vendor_id; +}; + +#endif /* _VDUSE_H_ */ diff --git a/drivers/vdpa/vdpa_user/vduse_dev.c b/drivers/vdpa/vdpa_user/vduse_dev.c new file mode 100644 index 000000000000..1cf759bc5914 --- /dev/null +++ b/drivers/vdpa/vdpa_user/vduse_dev.c @@ -0,0 +1,1217 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * VDUSE: vDPA Device in Userspace + * + * Copyright (C) 2020 Bytedance Inc. and/or its affiliates. All rights reserved. + * + * Author: Xie Yongji + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "vduse.h" + +#define DRV_VERSION "1.0" +#define DRV_AUTHOR "Yongji Xie " +#define DRV_DESC "vDPA Device in Userspace" +#define DRV_LICENSE "GPL v2" + +struct vduse_dev_msg { + struct vduse_dev_request req; + struct vduse_dev_response resp; + struct list_head list; + wait_queue_head_t waitq; + bool completed; + refcount_t refcnt; +}; + +static struct workqueue_struct *vduse_vdpa_wq; +static DEFINE_MUTEX(vduse_lock); +static LIST_HEAD(vduse_devs); + +static inline struct vduse_dev *vdpa_to_vduse(struct vdpa_device *vdpa) +{ + struct vduse_vdpa *vdev = container_of(vdpa, struct vduse_vdpa, vdpa); + + return vdev->dev; +} + +static inline struct vduse_dev *dev_to_vduse(struct device *dev) +{ + struct vdpa_device *vdpa = dev_to_vdpa(dev); + + return vdpa_to_vduse(vdpa); +} + +static struct vduse_dev_msg *vduse_dev_new_msg(struct vduse_dev *dev, int type) +{ + struct vduse_dev_msg *msg = kzalloc(sizeof(*msg), + GFP_KERNEL | __GFP_NOFAIL); + + msg->req.type = type; + msg->req.unique = atomic64_fetch_inc(&dev->msg_unique); + init_waitqueue_head(&msg->waitq); + refcount_set(&msg->refcnt, 1); + + return msg; +} + +static void vduse_dev_msg_get(struct vduse_dev_msg *msg) +{ + refcount_inc(&msg->refcnt); +} + +static void vduse_dev_msg_put(struct vduse_dev_msg *msg) +{ + if (refcount_dec_and_test(&msg->refcnt)) + kfree(msg); +} + +static struct vduse_dev_msg *vduse_dev_find_msg(struct vduse_dev *dev, + struct list_head *head, + uint32_t unique) +{ + struct vduse_dev_msg *tmp, *msg = NULL; + + spin_lock(&dev->msg_lock); + list_for_each_entry(tmp, head, list) { + if (tmp->req.unique == unique) { + msg = tmp; + list_del(&tmp->list); + break; + } + } + spin_unlock(&dev->msg_lock); + + return msg; +} + +static struct vduse_dev_msg *vduse_dev_dequeue_msg(struct vduse_dev *dev, + struct list_head *head) +{ + struct vduse_dev_msg *msg = NULL; + + spin_lock(&dev->msg_lock); + if (!list_empty(head)) { + msg = list_first_entry(head, struct vduse_dev_msg, list); + list_del(&msg->list); + } + spin_unlock(&dev->msg_lock); + + return msg; +} + +static void vduse_dev_enqueue_msg(struct vduse_dev *dev, + struct vduse_dev_msg *msg, struct list_head *head) +{ + spin_lock(&dev->msg_lock); + list_add_tail(&msg->list, head); + spin_unlock(&dev->msg_lock); +} + +static int vduse_dev_msg_sync(struct vduse_dev *dev, struct vduse_dev_msg *msg) +{ + int ret; + + vduse_dev_enqueue_msg(dev, msg, &dev->send_list); + wake_up(&dev->waitq); + wait_event(msg->waitq, msg->completed); + /* coupled with smp_wmb() in vduse_dev_msg_complete() */ + smp_rmb(); + ret = msg->resp.result; + + return ret; +} + +static void vduse_dev_msg_complete(struct vduse_dev_msg *msg, + struct vduse_dev_response *resp) +{ + vduse_dev_msg_get(msg); + memcpy(&msg->resp, resp, sizeof(*resp)); + /* coupled with smp_rmb() in vduse_dev_msg_sync() */ + smp_wmb(); + msg->completed = 1; + wake_up(&msg->waitq); + vduse_dev_msg_put(msg); +} + +static u64 vduse_dev_get_features(struct vduse_dev *dev) +{ + struct vduse_dev_msg *msg = vduse_dev_new_msg(dev, VDUSE_GET_FEATURES); + u64 features; + + vduse_dev_msg_sync(dev, msg); + features = msg->resp.features; + vduse_dev_msg_put(msg); + + return features; +} + +static int vduse_dev_set_features(struct vduse_dev *dev, u64 features) +{ + struct vduse_dev_msg *msg = vduse_dev_new_msg(dev, VDUSE_SET_FEATURES); + int ret; + + msg->req.size = sizeof(features); + msg->req.features = features; + + ret = vduse_dev_msg_sync(dev, msg); + vduse_dev_msg_put(msg); + + return ret; +} + +static u8 vduse_dev_get_status(struct vduse_dev *dev) +{ + struct vduse_dev_msg *msg = vduse_dev_new_msg(dev, VDUSE_GET_STATUS); + u8 status; + + vduse_dev_msg_sync(dev, msg); + status = msg->resp.status; + vduse_dev_msg_put(msg); + + return status; +} + +static void vduse_dev_set_status(struct vduse_dev *dev, u8 status) +{ + struct vduse_dev_msg *msg = vduse_dev_new_msg(dev, VDUSE_SET_STATUS); + + msg->req.size = sizeof(status); + msg->req.status = status; + + vduse_dev_msg_sync(dev, msg); + vduse_dev_msg_put(msg); +} + +static void vduse_dev_get_config(struct vduse_dev *dev, unsigned int offset, + void *buf, unsigned int len) +{ + struct vduse_dev_msg *msg = vduse_dev_new_msg(dev, VDUSE_GET_CONFIG); + + WARN_ON(len > sizeof(msg->req.config.data)); + + msg->req.size = sizeof(struct vduse_dev_config_data); + msg->req.config.offset = offset; + msg->req.config.len = len; + vduse_dev_msg_sync(dev, msg); + memcpy(buf, msg->resp.config.data, len); + vduse_dev_msg_put(msg); +} + +static void vduse_dev_set_config(struct vduse_dev *dev, unsigned int offset, + const void *buf, unsigned int len) +{ + struct vduse_dev_msg *msg = vduse_dev_new_msg(dev, VDUSE_SET_CONFIG); + + WARN_ON(len > sizeof(msg->req.config.data)); + + msg->req.size = sizeof(struct vduse_dev_config_data); + msg->req.config.offset = offset; + msg->req.config.len = len; + memcpy(msg->req.config.data, buf, len); + vduse_dev_msg_sync(dev, msg); + vduse_dev_msg_put(msg); +} + +static void vduse_dev_set_vq_num(struct vduse_dev *dev, + struct vduse_virtqueue *vq, u32 num) +{ + struct vduse_dev_msg *msg = vduse_dev_new_msg(dev, VDUSE_SET_VQ_NUM); + + msg->req.size = sizeof(struct vduse_vq_num); + msg->req.vq_num.index = vq->index; + msg->req.vq_num.num = num; + + vduse_dev_msg_sync(dev, msg); + vduse_dev_msg_put(msg); +} + +static int vduse_dev_set_vq_addr(struct vduse_dev *dev, + struct vduse_virtqueue *vq, u64 desc_addr, + u64 driver_addr, u64 device_addr) +{ + struct vduse_dev_msg *msg = vduse_dev_new_msg(dev, VDUSE_SET_VQ_ADDR); + int ret; + + msg->req.size = sizeof(struct vduse_vq_addr); + msg->req.vq_addr.index = vq->index; + msg->req.vq_addr.desc_addr = desc_addr; + msg->req.vq_addr.driver_addr = driver_addr; + msg->req.vq_addr.device_addr = device_addr; + + ret = vduse_dev_msg_sync(dev, msg); + vduse_dev_msg_put(msg); + + return ret; +} + +static void vduse_dev_set_vq_ready(struct vduse_dev *dev, + struct vduse_virtqueue *vq, bool ready) +{ + struct vduse_dev_msg *msg = vduse_dev_new_msg(dev, VDUSE_SET_VQ_READY); + + msg->req.size = sizeof(struct vduse_vq_ready); + msg->req.vq_ready.index = vq->index; + msg->req.vq_ready.ready = ready; + + vduse_dev_msg_sync(dev, msg); + vduse_dev_msg_put(msg); +} + +static bool vduse_dev_get_vq_ready(struct vduse_dev *dev, + struct vduse_virtqueue *vq) +{ + struct vduse_dev_msg *msg = vduse_dev_new_msg(dev, VDUSE_GET_VQ_READY); + bool ready; + + msg->req.size = sizeof(struct vduse_vq_ready); + msg->req.vq_ready.index = vq->index; + + vduse_dev_msg_sync(dev, msg); + ready = msg->resp.vq_ready.ready; + vduse_dev_msg_put(msg); + + return ready; +} + +static int vduse_dev_get_vq_state(struct vduse_dev *dev, + struct vduse_virtqueue *vq, + struct vdpa_vq_state *state) +{ + struct vduse_dev_msg *msg = vduse_dev_new_msg(dev, VDUSE_GET_VQ_STATE); + int ret; + + msg->req.size = sizeof(struct vduse_vq_state); + msg->req.vq_state.index = vq->index; + + ret = vduse_dev_msg_sync(dev, msg); + state->avail_index = msg->resp.vq_state.avail_idx; + vduse_dev_msg_put(msg); + + return ret; +} + +static int vduse_dev_set_vq_state(struct vduse_dev *dev, + struct vduse_virtqueue *vq, + const struct vdpa_vq_state *state) +{ + struct vduse_dev_msg *msg = vduse_dev_new_msg(dev, VDUSE_SET_VQ_STATE); + int ret; + + msg->req.size = sizeof(struct vduse_vq_state); + msg->req.vq_state.index = vq->index; + msg->req.vq_state.avail_idx = state->avail_index; + + ret = vduse_dev_msg_sync(dev, msg); + vduse_dev_msg_put(msg); + + return ret; +} + +static int vduse_dev_update_iotlb(struct vduse_dev *dev, + u64 start, u64 last) +{ + struct vduse_dev_msg *msg; + int ret; + + if (last < start) + return -EINVAL; + + msg = vduse_dev_new_msg(dev, VDUSE_UPDATE_IOTLB); + msg->req.size = sizeof(struct vduse_iova_range); + msg->req.iova.start = start; + msg->req.iova.last = last; + + ret = vduse_dev_msg_sync(dev, msg); + vduse_dev_msg_put(msg); + + return ret; +} + +static ssize_t vduse_dev_read_iter(struct kiocb *iocb, struct iov_iter *to) +{ + struct file *file = iocb->ki_filp; + struct vduse_dev *dev = file->private_data; + struct vduse_dev_msg *msg; + int size = sizeof(struct vduse_dev_request); + ssize_t ret = 0; + + if (iov_iter_count(to) < size) + return 0; + + while (1) { + msg = vduse_dev_dequeue_msg(dev, &dev->send_list); + if (msg) + break; + + if (file->f_flags & O_NONBLOCK) + return -EAGAIN; + + ret = wait_event_interruptible_exclusive(dev->waitq, + !list_empty(&dev->send_list)); + if (ret) + return ret; + } + ret = copy_to_iter(&msg->req, size, to); + if (ret != size) { + vduse_dev_enqueue_msg(dev, msg, &dev->send_list); + return -EFAULT; + } + vduse_dev_enqueue_msg(dev, msg, &dev->recv_list); + + return ret; +} + +static ssize_t vduse_dev_write_iter(struct kiocb *iocb, struct iov_iter *from) +{ + struct file *file = iocb->ki_filp; + struct vduse_dev *dev = file->private_data; + struct vduse_dev_response resp; + struct vduse_dev_msg *msg; + size_t ret; + + ret = copy_from_iter(&resp, sizeof(resp), from); + if (ret != sizeof(resp)) + return -EINVAL; + + msg = vduse_dev_find_msg(dev, &dev->recv_list, resp.unique); + if (!msg) + return -EINVAL; + + vduse_dev_msg_complete(msg, &resp); + + return ret; +} + +static __poll_t vduse_dev_poll(struct file *file, poll_table *wait) +{ + struct vduse_dev *dev = file->private_data; + __poll_t mask = 0; + + poll_wait(file, &dev->waitq, wait); + + if (!list_empty(&dev->send_list)) + mask |= EPOLLIN | EPOLLRDNORM; + + return mask; +} + +static int vduse_iotlb_add_range(struct vduse_dev *dev, + u64 start, u64 last, + u64 addr, unsigned int perm, + struct file *file, u64 offset) +{ + struct vhost_iotlb_file *iotlb_file; + int ret; + + iotlb_file = kmalloc(sizeof(*iotlb_file), GFP_ATOMIC); + if (!iotlb_file) + return -ENOMEM; + + iotlb_file->file = get_file(file); + iotlb_file->offset = offset; + + spin_lock(&dev->iommu_lock); + ret = vhost_iotlb_add_range(dev->iommu, start, last, + addr, perm, iotlb_file); + spin_unlock(&dev->iommu_lock); + if (ret) { + fput(iotlb_file->file); + kfree(iotlb_file); + return ret; + } + return 0; +} + +static void vduse_iotlb_del_range(struct vduse_dev *dev, u64 start, u64 last) +{ + struct vhost_iotlb_file *iotlb_file; + struct vhost_iotlb_map *map; + + spin_lock(&dev->iommu_lock); + while ((map = vhost_iotlb_itree_first(dev->iommu, start, last))) { + iotlb_file = (struct vhost_iotlb_file *)map->opaque; + fput(iotlb_file->file); + kfree(iotlb_file); + vhost_iotlb_map_free(dev->iommu, map); + } + spin_unlock(&dev->iommu_lock); +} + +static void vduse_dev_reset(struct vduse_dev *dev) +{ + int i; + + atomic_set(&dev->bounce_map, 0); + vduse_iotlb_del_range(dev, 0ULL, 0ULL - 1); + vduse_dev_update_iotlb(dev, 0ULL, 0ULL - 1); + + for (i = 0; i < dev->vq_num; i++) { + struct vduse_virtqueue *vq = &dev->vqs[i]; + + spin_lock(&vq->irq_lock); + vq->ready = false; + vq->cb = NULL; + vq->private = NULL; + spin_unlock(&vq->irq_lock); + } +} + +static int vduse_vdpa_set_vq_address(struct vdpa_device *vdpa, u16 idx, + u64 desc_area, u64 driver_area, + u64 device_area) +{ + struct vduse_dev *dev = vdpa_to_vduse(vdpa); + struct vduse_virtqueue *vq = &dev->vqs[idx]; + + return vduse_dev_set_vq_addr(dev, vq, desc_area, + driver_area, device_area); +} + +static void vduse_vdpa_kick_vq(struct vdpa_device *vdpa, u16 idx) +{ + struct vduse_dev *dev = vdpa_to_vduse(vdpa); + struct vduse_virtqueue *vq = &dev->vqs[idx]; + + vduse_vq_kick(vq); +} + +static void vduse_vdpa_set_vq_cb(struct vdpa_device *vdpa, u16 idx, + struct vdpa_callback *cb) +{ + struct vduse_dev *dev = vdpa_to_vduse(vdpa); + struct vduse_virtqueue *vq = &dev->vqs[idx]; + + vq->cb = cb->callback; + vq->private = cb->private; +} + +static void vduse_vdpa_set_vq_num(struct vdpa_device *vdpa, u16 idx, u32 num) +{ + struct vduse_dev *dev = vdpa_to_vduse(vdpa); + struct vduse_virtqueue *vq = &dev->vqs[idx]; + + vduse_dev_set_vq_num(dev, vq, num); +} + +static void vduse_vdpa_set_vq_ready(struct vdpa_device *vdpa, + u16 idx, bool ready) +{ + struct vduse_dev *dev = vdpa_to_vduse(vdpa); + struct vduse_virtqueue *vq = &dev->vqs[idx]; + + vduse_dev_set_vq_ready(dev, vq, ready); + vq->ready = ready; +} + +static bool vduse_vdpa_get_vq_ready(struct vdpa_device *vdpa, u16 idx) +{ + struct vduse_dev *dev = vdpa_to_vduse(vdpa); + struct vduse_virtqueue *vq = &dev->vqs[idx]; + + vq->ready = vduse_dev_get_vq_ready(dev, vq); + + return vq->ready; +} + +static int vduse_vdpa_set_vq_state(struct vdpa_device *vdpa, u16 idx, + const struct vdpa_vq_state *state) +{ + struct vduse_dev *dev = vdpa_to_vduse(vdpa); + struct vduse_virtqueue *vq = &dev->vqs[idx]; + + return vduse_dev_set_vq_state(dev, vq, state); +} + +static int vduse_vdpa_get_vq_state(struct vdpa_device *vdpa, u16 idx, + struct vdpa_vq_state *state) +{ + struct vduse_dev *dev = vdpa_to_vduse(vdpa); + struct vduse_virtqueue *vq = &dev->vqs[idx]; + + return vduse_dev_get_vq_state(dev, vq, state); +} + +static u32 vduse_vdpa_get_vq_align(struct vdpa_device *vdpa) +{ + struct vduse_dev *dev = vdpa_to_vduse(vdpa); + + return dev->vq_align; +} + +static u64 vduse_vdpa_get_features(struct vdpa_device *vdpa) +{ + struct vduse_dev *dev = vdpa_to_vduse(vdpa); + u64 fixed = (1ULL << VIRTIO_F_ACCESS_PLATFORM); + + return (vduse_dev_get_features(dev) | fixed); +} + +static int vduse_vdpa_set_features(struct vdpa_device *vdpa, u64 features) +{ + struct vduse_dev *dev = vdpa_to_vduse(vdpa); + + return vduse_dev_set_features(dev, features); +} + +static void vduse_vdpa_set_config_cb(struct vdpa_device *vdpa, + struct vdpa_callback *cb) +{ + /* We don't support config interrupt */ +} + +static u16 vduse_vdpa_get_vq_num_max(struct vdpa_device *vdpa) +{ + struct vduse_dev *dev = vdpa_to_vduse(vdpa); + + return dev->vq_size_max; +} + +static u32 vduse_vdpa_get_device_id(struct vdpa_device *vdpa) +{ + struct vduse_dev *dev = vdpa_to_vduse(vdpa); + + return dev->device_id; +} + +static u32 vduse_vdpa_get_vendor_id(struct vdpa_device *vdpa) +{ + struct vduse_dev *dev = vdpa_to_vduse(vdpa); + + return dev->vendor_id; +} + +static u8 vduse_vdpa_get_status(struct vdpa_device *vdpa) +{ + struct vduse_dev *dev = vdpa_to_vduse(vdpa); + + return vduse_dev_get_status(dev); +} + +static void vduse_vdpa_set_status(struct vdpa_device *vdpa, u8 status) +{ + struct vduse_dev *dev = vdpa_to_vduse(vdpa); + + if (status == 0) + vduse_dev_reset(dev); + else + vduse_dev_update_iotlb(dev, 0ULL, 0ULL - 1); + + vduse_dev_set_status(dev, status); +} + +static void vduse_vdpa_get_config(struct vdpa_device *vdpa, unsigned int offset, + void *buf, unsigned int len) +{ + struct vduse_dev *dev = vdpa_to_vduse(vdpa); + + vduse_dev_get_config(dev, offset, buf, len); +} + +static void vduse_vdpa_set_config(struct vdpa_device *vdpa, unsigned int offset, + const void *buf, unsigned int len) +{ + struct vduse_dev *dev = vdpa_to_vduse(vdpa); + + vduse_dev_set_config(dev, offset, buf, len); +} + +static int vduse_vdpa_set_map(struct vdpa_device *vdpa, + struct vhost_iotlb *iotlb) +{ + struct vduse_dev *dev = vdpa_to_vduse(vdpa); + struct vhost_iotlb_map *map; + struct vhost_iotlb_file *iotlb_file; + u64 start = 0ULL, last = 0ULL - 1; + int ret = 0; + + vduse_iotlb_del_range(dev, start, last); + + for (map = vhost_iotlb_itree_first(iotlb, start, last); map; + map = vhost_iotlb_itree_next(map, start, last)) { + if (!map->opaque) + continue; + + iotlb_file = (struct vhost_iotlb_file *)map->opaque; + ret = vduse_iotlb_add_range(dev, map->start, map->last, + map->addr, map->perm, + iotlb_file->file, + iotlb_file->offset); + if (ret) + break; + } + vduse_dev_update_iotlb(dev, start, last); + + return ret; +} + +static void vduse_vdpa_free(struct vdpa_device *vdpa) +{ + struct vduse_dev *dev = vdpa_to_vduse(vdpa); + + WARN_ON(!list_empty(&dev->send_list)); + WARN_ON(!list_empty(&dev->recv_list)); + dev->vdev = NULL; +} + +static const struct vdpa_config_ops vduse_vdpa_config_ops = { + .set_vq_address = vduse_vdpa_set_vq_address, + .kick_vq = vduse_vdpa_kick_vq, + .set_vq_cb = vduse_vdpa_set_vq_cb, + .set_vq_num = vduse_vdpa_set_vq_num, + .set_vq_ready = vduse_vdpa_set_vq_ready, + .get_vq_ready = vduse_vdpa_get_vq_ready, + .set_vq_state = vduse_vdpa_set_vq_state, + .get_vq_state = vduse_vdpa_get_vq_state, + .get_vq_align = vduse_vdpa_get_vq_align, + .get_features = vduse_vdpa_get_features, + .set_features = vduse_vdpa_set_features, + .set_config_cb = vduse_vdpa_set_config_cb, + .get_vq_num_max = vduse_vdpa_get_vq_num_max, + .get_device_id = vduse_vdpa_get_device_id, + .get_vendor_id = vduse_vdpa_get_vendor_id, + .get_status = vduse_vdpa_get_status, + .set_status = vduse_vdpa_set_status, + .get_config = vduse_vdpa_get_config, + .set_config = vduse_vdpa_set_config, + .set_map = vduse_vdpa_set_map, + .free = vduse_vdpa_free, +}; + +static dma_addr_t vduse_dev_map_page(struct device *dev, struct page *page, + unsigned long offset, size_t size, + enum dma_data_direction dir, + unsigned long attrs) +{ + struct vduse_dev *vdev = dev_to_vduse(dev); + struct vduse_iova_domain *domain = vdev->domain; + + if (atomic_xchg(&vdev->bounce_map, 1) == 0 && + vduse_iotlb_add_range(vdev, 0, domain->bounce_size - 1, + 0, VDUSE_ACCESS_RW, + vduse_domain_file(domain), + vduse_domain_get_offset(domain, 0))) { + atomic_set(&vdev->bounce_map, 0); + return DMA_MAPPING_ERROR; + } + + return vduse_domain_map_page(domain, page, offset, size, dir, attrs); +} + +static void vduse_dev_unmap_page(struct device *dev, dma_addr_t dma_addr, + size_t size, enum dma_data_direction dir, + unsigned long attrs) +{ + struct vduse_dev *vdev = dev_to_vduse(dev); + struct vduse_iova_domain *domain = vdev->domain; + + return vduse_domain_unmap_page(domain, dma_addr, size, dir, attrs); +} + +static void *vduse_dev_alloc_coherent(struct device *dev, size_t size, + dma_addr_t *dma_addr, gfp_t flag, + unsigned long attrs) +{ + struct vduse_dev *vdev = dev_to_vduse(dev); + struct vduse_iova_domain *domain = vdev->domain; + unsigned long iova; + void *addr; + + *dma_addr = DMA_MAPPING_ERROR; + addr = vduse_domain_alloc_coherent(domain, size, + (dma_addr_t *)&iova, flag, attrs); + if (!addr) + return NULL; + + if (vduse_iotlb_add_range(vdev, iova, iova + size - 1, + iova, VDUSE_ACCESS_RW, + vduse_domain_file(domain), + vduse_domain_get_offset(domain, iova))) { + vduse_domain_free_coherent(domain, size, addr, iova, attrs); + return NULL; + } + *dma_addr = (dma_addr_t)iova; + + return addr; +} + +static void vduse_dev_free_coherent(struct device *dev, size_t size, + void *vaddr, dma_addr_t dma_addr, + unsigned long attrs) +{ + struct vduse_dev *vdev = dev_to_vduse(dev); + struct vduse_iova_domain *domain = vdev->domain; + unsigned long start = (unsigned long)dma_addr; + unsigned long last = start + size - 1; + + vduse_iotlb_del_range(vdev, start, last); + vduse_dev_update_iotlb(vdev, start, last); + vduse_domain_free_coherent(domain, size, vaddr, dma_addr, attrs); +} + +static const struct dma_map_ops vduse_dev_dma_ops = { + .map_page = vduse_dev_map_page, + .unmap_page = vduse_dev_unmap_page, + .alloc = vduse_dev_alloc_coherent, + .free = vduse_dev_free_coherent, +}; + +static unsigned int perm_to_file_flags(u8 perm) +{ + unsigned int flags = 0; + + switch (perm) { + case VDUSE_ACCESS_WO: + flags |= O_WRONLY; + break; + case VDUSE_ACCESS_RO: + flags |= O_RDONLY; + break; + case VDUSE_ACCESS_RW: + flags |= O_RDWR; + break; + default: + WARN(1, "invalidate vhost IOTLB permission\n"); + break; + } + + return flags; +} + +static long vduse_dev_ioctl(struct file *file, unsigned int cmd, + unsigned long arg) +{ + struct vduse_dev *dev = file->private_data; + void __user *argp = (void __user *)arg; + int ret; + + mutex_lock(&dev->lock); + switch (cmd) { + case VDUSE_IOTLB_GET_FD: { + struct vduse_iotlb_entry entry; + struct vhost_iotlb_map *map; + struct vhost_iotlb_file *iotlb_file; + struct file *f = NULL; + + ret = -EFAULT; + if (copy_from_user(&entry, argp, sizeof(entry))) + break; + + spin_lock(&dev->iommu_lock); + map = vhost_iotlb_itree_first(dev->iommu, entry.start, + entry.last); + if (map) { + iotlb_file = (struct vhost_iotlb_file *)map->opaque; + f = get_file(iotlb_file->file); + entry.offset = iotlb_file->offset; + entry.start = map->start; + entry.last = map->last; + entry.perm = map->perm; + } + spin_unlock(&dev->iommu_lock); + if (!f) { + ret = -EINVAL; + break; + } + if (copy_to_user(argp, &entry, sizeof(entry))) { + fput(f); + ret = -EFAULT; + break; + } + ret = get_unused_fd_flags(perm_to_file_flags(entry.perm)); + if (ret < 0) { + fput(f); + break; + } + fd_install(ret, f); + break; + } + case VDUSE_VQ_SETUP_KICKFD: { + struct vduse_vq_eventfd eventfd; + + ret = -EFAULT; + if (copy_from_user(&eventfd, argp, sizeof(eventfd))) + break; + + ret = vduse_kickfd_setup(dev, &eventfd); + break; + } + case VDUSE_VQ_SETUP_IRQFD: { + struct vduse_vq_eventfd eventfd; + + ret = -EFAULT; + if (copy_from_user(&eventfd, argp, sizeof(eventfd))) + break; + + ret = vduse_virqfd_setup(dev, &eventfd); + break; + } + } + mutex_unlock(&dev->lock); + + return ret; +} + +static int vduse_dev_release(struct inode *inode, struct file *file) +{ + struct vduse_dev *dev = file->private_data; + + vduse_kickfd_release(dev); + vduse_virqfd_release(dev); + dev->connected = false; + + return 0; +} + +static const struct file_operations vduse_dev_fops = { + .owner = THIS_MODULE, + .release = vduse_dev_release, + .read_iter = vduse_dev_read_iter, + .write_iter = vduse_dev_write_iter, + .poll = vduse_dev_poll, + .unlocked_ioctl = vduse_dev_ioctl, + .compat_ioctl = compat_ptr_ioctl, + .llseek = noop_llseek, +}; + +static struct vduse_dev *vduse_dev_create(void) +{ + struct vduse_dev *dev = kzalloc(sizeof(*dev), GFP_KERNEL); + + if (!dev) + return NULL; + + dev->iommu = vhost_iotlb_alloc(2048, 0); + if (!dev->iommu) { + kfree(dev); + return NULL; + } + + mutex_init(&dev->lock); + spin_lock_init(&dev->msg_lock); + INIT_LIST_HEAD(&dev->send_list); + INIT_LIST_HEAD(&dev->recv_list); + atomic64_set(&dev->msg_unique, 0); + spin_lock_init(&dev->iommu_lock); + atomic_set(&dev->bounce_map, 0); + + init_waitqueue_head(&dev->waitq); + + return dev; +} + +static void vduse_dev_destroy(struct vduse_dev *dev) +{ + vhost_iotlb_free(dev->iommu); + mutex_destroy(&dev->lock); + kfree(dev); +} + +static struct vduse_dev *vduse_find_dev(u32 id) +{ + struct vduse_dev *tmp, *dev = NULL; + + list_for_each_entry(tmp, &vduse_devs, list) { + if (tmp->id == id) { + dev = tmp; + break; + } + } + return dev; +} + +static int vduse_destroy_dev(u32 id) +{ + struct vduse_dev *dev = vduse_find_dev(id); + + if (!dev) + return -EINVAL; + + if (dev->vdev || dev->connected) + return -EBUSY; + + list_del(&dev->list); + kfree(dev->vqs); + vduse_domain_destroy(dev->domain); + vduse_dev_destroy(dev); + + return 0; +} + +static int vduse_create_dev(struct vduse_dev_config *config) +{ + int i, fd; + struct vduse_dev *dev; + char name[64]; + + if (vduse_find_dev(config->id)) + return -EEXIST; + + dev = vduse_dev_create(); + if (!dev) + return -ENOMEM; + + dev->id = config->id; + dev->device_id = config->device_id; + dev->vendor_id = config->vendor_id; + dev->domain = vduse_domain_create(config->bounce_size); + if (!dev->domain) + goto err_domain; + + dev->vq_align = config->vq_align; + dev->vq_size_max = config->vq_size_max; + dev->vq_num = config->vq_num; + dev->vqs = kcalloc(dev->vq_num, sizeof(*dev->vqs), GFP_KERNEL); + if (!dev->vqs) + goto err_vqs; + + for (i = 0; i < dev->vq_num; i++) { + dev->vqs[i].index = i; + spin_lock_init(&dev->vqs[i].kick_lock); + spin_lock_init(&dev->vqs[i].irq_lock); + } + + snprintf(name, sizeof(name), "[vduse-dev:%u]", config->id); + fd = anon_inode_getfd(name, &vduse_dev_fops, dev, O_RDWR | O_CLOEXEC); + if (fd < 0) + goto err_fd; + + dev->connected = true; + list_add(&dev->list, &vduse_devs); + + return fd; +err_fd: + kfree(dev->vqs); +err_vqs: + vduse_domain_destroy(dev->domain); +err_domain: + vduse_dev_destroy(dev); + return fd; +} + +static long vduse_ioctl(struct file *file, unsigned int cmd, + unsigned long arg) +{ + int ret; + void __user *argp = (void __user *)arg; + + mutex_lock(&vduse_lock); + switch (cmd) { + case VDUSE_CREATE_DEV: { + struct vduse_dev_config config; + + ret = -EFAULT; + if (copy_from_user(&config, argp, sizeof(config))) + break; + + ret = vduse_create_dev(&config); + break; + } + case VDUSE_DESTROY_DEV: + ret = vduse_destroy_dev(arg); + break; + default: + ret = -EINVAL; + break; + } + mutex_unlock(&vduse_lock); + + return ret; +} + +static const struct file_operations vduse_fops = { + .owner = THIS_MODULE, + .unlocked_ioctl = vduse_ioctl, + .compat_ioctl = compat_ptr_ioctl, + .llseek = noop_llseek, +}; + +static struct miscdevice vduse_misc = { + .fops = &vduse_fops, + .minor = MISC_DYNAMIC_MINOR, + .name = "vduse", +}; + +static void vduse_parent_release(struct device *dev) +{ +} + +static struct device vduse_parent = { + .init_name = "vduse", + .release = vduse_parent_release, +}; + +static struct vdpa_parent_dev parent_dev; + +static int vduse_dev_add_vdpa(struct vduse_dev *dev, const char *name) +{ + struct vduse_vdpa *vdev = dev->vdev; + int ret; + + if (vdev) + return -EEXIST; + + vdev = vdpa_alloc_device(struct vduse_vdpa, vdpa, NULL, + &vduse_vdpa_config_ops, + dev->vq_num, name, true); + if (!vdev) + return -ENOMEM; + + vdev->dev = dev; + vdev->vdpa.dev.dma_mask = &vdev->vdpa.dev.coherent_dma_mask; + ret = dma_set_mask_and_coherent(&vdev->vdpa.dev, DMA_BIT_MASK(64)); + if (ret) + goto err; + + set_dma_ops(&vdev->vdpa.dev, &vduse_dev_dma_ops); + vdev->vdpa.dma_dev = &vdev->vdpa.dev; + vdev->vdpa.pdev = &parent_dev; + + ret = _vdpa_register_device(&vdev->vdpa); + if (ret) + goto err; + + dev->vdev = vdev; + + return 0; +err: + put_device(&vdev->vdpa.dev); + return ret; +} + +static struct vdpa_device *vdpa_dev_add(struct vdpa_parent_dev *pdev, + const char *name, u32 device_id, + struct nlattr **attrs) +{ + u32 vduse_id; + struct vduse_dev *dev; + int ret = -EINVAL; + + if (!attrs[VDPA_ATTR_BACKEND_ID]) + return ERR_PTR(-EINVAL); + + mutex_lock(&vduse_lock); + vduse_id = nla_get_u32(attrs[VDPA_ATTR_BACKEND_ID]); + dev = vduse_find_dev(vduse_id); + if (!dev) + goto unlock; + + if (dev->device_id != device_id) + goto unlock; + + ret = vduse_dev_add_vdpa(dev, name); +unlock: + mutex_unlock(&vduse_lock); + if (ret) + return ERR_PTR(ret); + + return &dev->vdev->vdpa; +} + +static void vdpa_dev_del(struct vdpa_parent_dev *pdev, struct vdpa_device *dev) +{ + _vdpa_unregister_device(dev); +} + +static const struct vdpa_dev_ops vdpa_dev_parent_ops = { + .dev_add = vdpa_dev_add, + .dev_del = vdpa_dev_del +}; + +static struct virtio_device_id id_table[] = { + { VIRTIO_DEV_ANY_ID, VIRTIO_DEV_ANY_ID }, + { 0 }, +}; + +static struct vdpa_parent_dev parent_dev = { + .device = &vduse_parent, + .id_table = id_table, + .ops = &vdpa_dev_parent_ops, +}; + +static int vduse_parentdev_init(void) +{ + int ret; + + ret = device_register(&vduse_parent); + if (ret) + return ret; + + ret = vdpa_parentdev_register(&parent_dev); + if (ret) + goto err; + + return 0; +err: + device_unregister(&vduse_parent); + return ret; +} + +static void vduse_parentdev_exit(void) +{ + vdpa_parentdev_unregister(&parent_dev); + device_unregister(&vduse_parent); +} + +static int vduse_init(void) +{ + int ret; + + ret = misc_register(&vduse_misc); + if (ret) + return ret; + + ret = -ENOMEM; + vduse_vdpa_wq = alloc_workqueue("vduse-vdpa", WQ_UNBOUND, 1); + if (!vduse_vdpa_wq) + goto err_vdpa_wq; + + ret = vduse_virqfd_init(); + if (ret) + goto err_irqfd; + + ret = vduse_parentdev_init(); + if (ret) + goto err_parentdev; + + return 0; +err_parentdev: + vduse_virqfd_exit(); +err_irqfd: + destroy_workqueue(vduse_vdpa_wq); +err_vdpa_wq: + misc_deregister(&vduse_misc); + return ret; +} +module_init(vduse_init); + +static void vduse_exit(void) +{ + misc_deregister(&vduse_misc); + destroy_workqueue(vduse_vdpa_wq); + vduse_virqfd_exit(); + vduse_parentdev_exit(); +} +module_exit(vduse_exit); + +MODULE_VERSION(DRV_VERSION); +MODULE_LICENSE(DRV_LICENSE); +MODULE_AUTHOR(DRV_AUTHOR); +MODULE_DESCRIPTION(DRV_DESC); diff --git a/include/uapi/linux/vdpa.h b/include/uapi/linux/vdpa.h index bba8b83a94b5..a7a841e5ffc7 100644 --- a/include/uapi/linux/vdpa.h +++ b/include/uapi/linux/vdpa.h @@ -33,6 +33,7 @@ enum vdpa_attr { VDPA_ATTR_DEV_VENDOR_ID, /* u32 */ VDPA_ATTR_DEV_MAX_VQS, /* u32 */ VDPA_ATTR_DEV_MAX_VQ_SIZE, /* u16 */ + VDPA_ATTR_BACKEND_ID, /* u32 */ /* new attributes must be added above here */ VDPA_ATTR_MAX, diff --git a/include/uapi/linux/vduse.h b/include/uapi/linux/vduse.h new file mode 100644 index 000000000000..9fb555ddcfbd --- /dev/null +++ b/include/uapi/linux/vduse.h @@ -0,0 +1,125 @@ +/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */ +#ifndef _UAPI_VDUSE_H_ +#define _UAPI_VDUSE_H_ + +#include + +/* the control messages definition for read/write */ + +#define VDUSE_CONFIG_DATA_LEN 256 + +enum vduse_req_type { + VDUSE_SET_VQ_NUM, + VDUSE_SET_VQ_ADDR, + VDUSE_SET_VQ_READY, + VDUSE_GET_VQ_READY, + VDUSE_SET_VQ_STATE, + VDUSE_GET_VQ_STATE, + VDUSE_SET_FEATURES, + VDUSE_GET_FEATURES, + VDUSE_SET_STATUS, + VDUSE_GET_STATUS, + VDUSE_SET_CONFIG, + VDUSE_GET_CONFIG, + VDUSE_UPDATE_IOTLB, +}; + +struct vduse_vq_num { + __u32 index; + __u32 num; +}; + +struct vduse_vq_addr { + __u32 index; + __u64 desc_addr; + __u64 driver_addr; + __u64 device_addr; +}; + +struct vduse_vq_ready { + __u32 index; + __u8 ready; +}; + +struct vduse_vq_state { + __u32 index; + __u16 avail_idx; +}; + +struct vduse_dev_config_data { + __u32 offset; + __u32 len; + __u8 data[VDUSE_CONFIG_DATA_LEN]; +}; + +struct vduse_iova_range { + __u64 start; + __u64 last; +}; + +struct vduse_dev_request { + __u32 type; /* request type */ + __u32 unique; /* request id */ + __u32 flags; /* request flags */ + __u32 size; /* the payload size */ + union { + struct vduse_vq_num vq_num; /* virtqueue num */ + struct vduse_vq_addr vq_addr; /* virtqueue address */ + struct vduse_vq_ready vq_ready; /* virtqueue ready status */ + struct vduse_vq_state vq_state; /* virtqueue state */ + struct vduse_dev_config_data config; /* virtio device config space */ + struct vduse_iova_range iova; /* iova range for updating */ + __u64 features; /* virtio features */ + __u8 status; /* device status */ + }; +}; + +struct vduse_dev_response { + __u32 unique; /* corresponding request id */ + __s32 result; /* the result of request */ + union { + struct vduse_vq_ready vq_ready; /* virtqueue ready status */ + struct vduse_vq_state vq_state; /* virtqueue state */ + struct vduse_dev_config_data config; /* virtio device config space */ + __u64 features; /* virtio features */ + __u8 status; /* device status */ + }; +}; + +/* ioctls */ + +struct vduse_dev_config { + __u32 id; /* vduse device id */ + __u32 vendor_id; /* virtio vendor id */ + __u32 device_id; /* virtio device id */ + __u64 bounce_size; /* bounce buffer size for iommu */ + __u16 vq_num; /* the number of virtqueues */ + __u16 vq_size_max; /* the max size of virtqueue */ + __u32 vq_align; /* the allocation alignment of virtqueue's metadata */ +}; + +struct vduse_iotlb_entry { + __u64 offset; /* the mmap offset on fd */ + __u64 start; /* start of the IOVA range */ + __u64 last; /* last of the IOVA range */ +#define VDUSE_ACCESS_RO 0x1 +#define VDUSE_ACCESS_WO 0x2 +#define VDUSE_ACCESS_RW 0x3 + __u8 perm; /* access permission of this range */ +}; + +struct vduse_vq_eventfd { + __u32 index; /* virtqueue index */ + __u32 fd; /* eventfd */ +}; + +#define VDUSE_BASE 0x81 + +#define VDUSE_CREATE_DEV _IOW(VDUSE_BASE, 0x01, struct vduse_dev_config) +#define VDUSE_DESTROY_DEV _IO(VDUSE_BASE, 0x02) + +#define VDUSE_IOTLB_GET_FD _IOWR(VDUSE_BASE, 0x04, struct vduse_iotlb_entry) +#define VDUSE_VQ_SETUP_KICKFD _IOW(VDUSE_BASE, 0x05, struct vduse_vq_eventfd) +#define VDUSE_VQ_SETUP_IRQFD _IOW(VDUSE_BASE, 0x06, struct vduse_vq_eventfd) + +#endif /* _UAPI_VDUSE_H_ */ From patchwork Tue Jan 19 05:07:54 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Yongji Xie X-Patchwork-Id: 12028739 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-16.8 required=3.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id BF13DC433E6 for ; Tue, 19 Jan 2021 05:24:19 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 7CE2F22D6F for ; Tue, 19 Jan 2021 05:24:19 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S2388491AbhASFYE (ORCPT ); Tue, 19 Jan 2021 00:24:04 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:45228 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S2387667AbhASFKM (ORCPT ); Tue, 19 Jan 2021 00:10:12 -0500 Received: from mail-pg1-x529.google.com (mail-pg1-x529.google.com [IPv6:2607:f8b0:4864:20::529]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id F26A8C0613D6 for ; Mon, 18 Jan 2021 21:08:24 -0800 (PST) Received: by mail-pg1-x529.google.com with SMTP id g15so12281069pgu.9 for ; Mon, 18 Jan 2021 21:08:24 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bytedance-com.20150623.gappssmtp.com; s=20150623; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=l78+ic827fPeMtI4N3ruxnowwLavtkMdAQhrpxNvn10=; b=oLZ/lu9L9mSnnZyW00ltwHXyo44TYvX+ccpYXJTgwbiOiMXgHoMO3elQD5sQez2Sny ZrfOE/n85EPsc0U/9VpAgeIEA3Bcl8zawvPFtB5Y4kE1S2fBT//UvJjqi9ZqS/WlGhou qPeifQuk6xDi/b1qB/VrpXDIZcZ4x21hH7SLerZvvs+3QaAWVUkX4ggU7otSMaD3NF6N MM8TX7MrijhH3YO8q6l7lJym+s52rruIvIx1XhXorEqEXSF2k/V5Npl6vr4kcHngP8sq 8JGHk470/POpPqUVzGcbHTKpIjWt8zPdr0PBjgDCyGUsX7I/oymzLxsqaClwVfX5WZU3 4qGQ== 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=l78+ic827fPeMtI4N3ruxnowwLavtkMdAQhrpxNvn10=; b=Dr+x5NiHFE+7AJodJVzvuFEaxxbQhtoez90g4zG7QtSnvZoMKIiESUMusgZKPcMRma fIvo840SWAIzxYwxSZMmMaR+bDJL+MhV24M6g76VAk1mRJ3L2e2ifM7O2hcrkSUf+5Xa jbZuke8HEM9NNXP8D6WsGvsJWWJ73lrd49yEEaOMk+33mMlvQYd6/qSuBSNrQT/TpBKD RUAPznv6to41mXDC16639QdYjc9P/6z8nYU1JuGxyy/L1Qmd0QTH9mCsw5IzpRD9vKkT saLHwg73MHqmalEFdRcfs83kH0V4/anEEOzqSB6E/2jABm5H13a3tKpGW2GVaj+k1ze1 eGxA== X-Gm-Message-State: AOAM531LJ/pxuzIwXcNCdlWJvQqocBw4JBiHHiZjO8VRJ2hGI1JAT648 EGUUhvNeh2yU1NclzCQgjhp9 X-Google-Smtp-Source: ABdhPJz/fxwy4DYXVrnw1qnj25AW0O26rp73QlbMoxmwaU+d+WKNpvYSFfXNGAXSbsWGK45vrdkKRw== X-Received: by 2002:a62:160d:0:b029:1b3:fc7b:9237 with SMTP id 13-20020a62160d0000b02901b3fc7b9237mr2578724pfw.35.1611032904596; Mon, 18 Jan 2021 21:08:24 -0800 (PST) Received: from localhost ([139.177.225.243]) by smtp.gmail.com with ESMTPSA id b11sm17087042pfr.38.2021.01.18.21.08.23 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 18 Jan 2021 21:08:24 -0800 (PST) From: Xie Yongji To: mst@redhat.com, jasowang@redhat.com, stefanha@redhat.com, sgarzare@redhat.com, parav@nvidia.com, bob.liu@oracle.com, hch@infradead.org, rdunlap@infradead.org, willy@infradead.org, viro@zeniv.linux.org.uk, axboe@kernel.dk, bcrl@kvack.org, corbet@lwn.net Cc: virtualization@lists.linux-foundation.org, netdev@vger.kernel.org, kvm@vger.kernel.org, linux-aio@kvack.org, linux-fsdevel@vger.kernel.org Subject: [RFC v3 09/11] vduse: Add VDUSE_GET_DEV ioctl Date: Tue, 19 Jan 2021 13:07:54 +0800 Message-Id: <20210119050756.600-3-xieyongji@bytedance.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210119050756.600-1-xieyongji@bytedance.com> References: <20210119045920.447-1-xieyongji@bytedance.com> <20210119050756.600-1-xieyongji@bytedance.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: kvm@vger.kernel.org This new ioctl will be used to retrieve the file descriptor referring to userspace vDPA device to support reconnecting. Signed-off-by: Xie Yongji --- drivers/vdpa/vdpa_user/vduse_dev.c | 30 ++++++++++++++++++++++++++++++ include/uapi/linux/vduse.h | 1 + 2 files changed, 31 insertions(+) diff --git a/drivers/vdpa/vdpa_user/vduse_dev.c b/drivers/vdpa/vdpa_user/vduse_dev.c index 1cf759bc5914..4d21203da5b6 100644 --- a/drivers/vdpa/vdpa_user/vduse_dev.c +++ b/drivers/vdpa/vdpa_user/vduse_dev.c @@ -872,9 +872,14 @@ static long vduse_dev_ioctl(struct file *file, unsigned int cmd, static int vduse_dev_release(struct inode *inode, struct file *file) { struct vduse_dev *dev = file->private_data; + struct vduse_dev_msg *msg; vduse_kickfd_release(dev); vduse_virqfd_release(dev); + + while ((msg = vduse_dev_dequeue_msg(dev, &dev->recv_list))) + vduse_dev_enqueue_msg(dev, msg, &dev->send_list); + dev->connected = false; return 0; @@ -937,6 +942,28 @@ static struct vduse_dev *vduse_find_dev(u32 id) return dev; } +static int vduse_get_dev(u32 id) +{ + int fd; + char name[64]; + struct vduse_dev *dev = vduse_find_dev(id); + + if (!dev) + return -EINVAL; + + if (dev->connected) + return -EBUSY; + + snprintf(name, sizeof(name), "[vduse-dev:%u]", dev->id); + fd = anon_inode_getfd(name, &vduse_dev_fops, dev, O_RDWR | O_CLOEXEC); + if (fd < 0) + return fd; + + dev->connected = true; + + return fd; +} + static int vduse_destroy_dev(u32 id) { struct vduse_dev *dev = vduse_find_dev(id); @@ -1024,6 +1051,9 @@ static long vduse_ioctl(struct file *file, unsigned int cmd, ret = vduse_create_dev(&config); break; } + case VDUSE_GET_DEV: + ret = vduse_get_dev(arg); + break; case VDUSE_DESTROY_DEV: ret = vduse_destroy_dev(arg); break; diff --git a/include/uapi/linux/vduse.h b/include/uapi/linux/vduse.h index 9fb555ddcfbd..b3694f0d3b77 100644 --- a/include/uapi/linux/vduse.h +++ b/include/uapi/linux/vduse.h @@ -117,6 +117,7 @@ struct vduse_vq_eventfd { #define VDUSE_CREATE_DEV _IOW(VDUSE_BASE, 0x01, struct vduse_dev_config) #define VDUSE_DESTROY_DEV _IO(VDUSE_BASE, 0x02) +#define VDUSE_GET_DEV _IO(VDUSE_BASE, 0x03) #define VDUSE_IOTLB_GET_FD _IOWR(VDUSE_BASE, 0x04, struct vduse_iotlb_entry) #define VDUSE_VQ_SETUP_KICKFD _IOW(VDUSE_BASE, 0x05, struct vduse_vq_eventfd) From patchwork Tue Jan 19 05:07:55 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Yongji Xie X-Patchwork-Id: 12028741 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-16.8 required=3.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 17E6DC4332B for ; Tue, 19 Jan 2021 05:24:20 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id EBE3322ADC for ; Tue, 19 Jan 2021 05:24:19 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S2389239AbhASFYQ (ORCPT ); Tue, 19 Jan 2021 00:24:16 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:45272 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S2389032AbhASFKY (ORCPT ); Tue, 19 Jan 2021 00:10:24 -0500 Received: from mail-pj1-x1030.google.com (mail-pj1-x1030.google.com [IPv6:2607:f8b0:4864:20::1030]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id AABCEC061793 for ; Mon, 18 Jan 2021 21:08:28 -0800 (PST) Received: by mail-pj1-x1030.google.com with SMTP id m5so11369378pjv.5 for ; Mon, 18 Jan 2021 21:08:28 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bytedance-com.20150623.gappssmtp.com; s=20150623; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=t3cY7CxP1IBzVsJGjcj8blqMZcQjokVEop4ReGoC7JE=; b=TEg+IOYZST+7tYQUg1/prfYMdgJIbYGfE5jH4E7BZIml0/hSPCz3KbwjSxXpiQsRZl Q8l81z+hVG6Xt72wYh15Fo9jMa24fzcmQCqN0jO7hAIdtR0TT33wJSAbVOWl9nN8CbeH wthbRRKu8tL9b6om9Gse2Y+8qcuWq6CPO464iUnoiGhSclGpRl6VRQRui7JsBJKTiryh nT2XiZjYh14ExYSPwYhUXBdjgi2iXgBRnrc8XAJ6hUI7UtJJEdnVGAiHrblWDqwaLew/ +hAHfdNaVBy4QKfKFunM1DoBJJsowjZWgC/OW7bwcXDqwZCi3+nYNwcXHJCSeBVyWGXo T6bg== 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=t3cY7CxP1IBzVsJGjcj8blqMZcQjokVEop4ReGoC7JE=; b=ma3SVv8Lz2yZPDBLn2NqKHwI/pyP1se9j2uoDhdnrXJB9ONSQPZpr79JgInEsWoJ44 0S1qyR3Be2QZ8PwM/jBoZgY5lH/7UFAqNAJlmysEUSm0/Po+dIkd+DNmKoDxcQjS9gZ2 3IRJg1sgea+Zaei6zOC8hCZcRyVbAteMj1DRSL/NVgpw+C0ojp1WpMnBF/1TMuvvpn1L XsKEOHfV/hGQAEMRODh8laPNYx2mlMmiFQsh568Qsi5M8ivESvvaoeNgetiHCDsn6aiW E1DgOFWNArGHLxJ9nvy/gpjM6FupFSA7HvepWoM8PKU0iwbhxDyvhB7/+UEV5P9BHKHr zu5w== X-Gm-Message-State: AOAM532zgg4csQYFrgaXidMpxZtbEpvW6BNZs/GbF+Vvbc2x7hA92kou gSfiA3AlQkAB7OoJjHQH3J1e X-Google-Smtp-Source: ABdhPJzuUPBsbXsliQWe6YeR9pV9Pcl1Qlp+OOESCFCSFdZxLsSlgkaLNNMDIGMzQUlolElY5qtofw== X-Received: by 2002:a17:903:230b:b029:dd:7cf1:8c33 with SMTP id d11-20020a170903230bb02900dd7cf18c33mr2894021plh.31.1611032908304; Mon, 18 Jan 2021 21:08:28 -0800 (PST) Received: from localhost ([139.177.225.243]) by smtp.gmail.com with ESMTPSA id i2sm1125169pjd.21.2021.01.18.21.08.27 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 18 Jan 2021 21:08:27 -0800 (PST) From: Xie Yongji To: mst@redhat.com, jasowang@redhat.com, stefanha@redhat.com, sgarzare@redhat.com, parav@nvidia.com, bob.liu@oracle.com, hch@infradead.org, rdunlap@infradead.org, willy@infradead.org, viro@zeniv.linux.org.uk, axboe@kernel.dk, bcrl@kvack.org, corbet@lwn.net Cc: virtualization@lists.linux-foundation.org, netdev@vger.kernel.org, kvm@vger.kernel.org, linux-aio@kvack.org, linux-fsdevel@vger.kernel.org Subject: [RFC v3 10/11] vduse: grab the module's references until there is no vduse device Date: Tue, 19 Jan 2021 13:07:55 +0800 Message-Id: <20210119050756.600-4-xieyongji@bytedance.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210119050756.600-1-xieyongji@bytedance.com> References: <20210119045920.447-1-xieyongji@bytedance.com> <20210119050756.600-1-xieyongji@bytedance.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: kvm@vger.kernel.org The module should not be unloaded if any vduse device exists. So increase the module's reference count when creating vduse device. And the reference count is kept until the device is destroyed. Signed-off-by: Xie Yongji --- drivers/vdpa/vdpa_user/vduse_dev.c | 2 ++ 1 file changed, 2 insertions(+) diff --git a/drivers/vdpa/vdpa_user/vduse_dev.c b/drivers/vdpa/vdpa_user/vduse_dev.c index 4d21203da5b6..003aeb281bce 100644 --- a/drivers/vdpa/vdpa_user/vduse_dev.c +++ b/drivers/vdpa/vdpa_user/vduse_dev.c @@ -978,6 +978,7 @@ static int vduse_destroy_dev(u32 id) kfree(dev->vqs); vduse_domain_destroy(dev->domain); vduse_dev_destroy(dev); + module_put(THIS_MODULE); return 0; } @@ -1022,6 +1023,7 @@ static int vduse_create_dev(struct vduse_dev_config *config) dev->connected = true; list_add(&dev->list, &vduse_devs); + __module_get(THIS_MODULE); return fd; err_fd: From patchwork Tue Jan 19 05:07:56 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Yongji Xie X-Patchwork-Id: 12029489 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-16.8 required=3.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,USER_AGENT_GIT autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id DB807C433E9 for ; Tue, 19 Jan 2021 08:30:09 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id AE5CE23131 for ; Tue, 19 Jan 2021 08:30:09 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1729183AbhASFYT (ORCPT ); Tue, 19 Jan 2021 00:24:19 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:45342 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S2388204AbhASFKo (ORCPT ); Tue, 19 Jan 2021 00:10:44 -0500 Received: from mail-pl1-x62c.google.com (mail-pl1-x62c.google.com [IPv6:2607:f8b0:4864:20::62c]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 5AB55C061796 for ; Mon, 18 Jan 2021 21:08:32 -0800 (PST) Received: by mail-pl1-x62c.google.com with SMTP id y8so9834411plp.8 for ; Mon, 18 Jan 2021 21:08:32 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bytedance-com.20150623.gappssmtp.com; s=20150623; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=RADXly6HG+PYDpCqLXRZWwmhkpi+THQigpZFKjj79E0=; b=hdIVRGDx1eZ2GZAUtF9TXfCjHL0A61xJ7yUIPcaxGXzr+C+jwd44tFOdwvMbWgIhZa 46OBX8LK/+MRRJosbjtmwJ+4Rzcgfgm3THj5W1yNejXzksIkbsIJDWWlUk9becxuqvtM HYjgArsRYUr5YTHXEhqwSGR0pENLTqqeGyPt+aLnTWsY/mGhD4VJ+/V8boVopz1HSeb5 uUObLphRA1+I0VbYcKC/b9e2hmvSp4BDFXM3DD5l2eZYegM2L13niYRzcPJRfNmV7POK eplsd8nG5Vx0qHr/1M2JyLAZXyoaWipUPWyfgwHJrXzyWP+7+8GexAI+EvVj/vY2eFsm KuDw== 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=RADXly6HG+PYDpCqLXRZWwmhkpi+THQigpZFKjj79E0=; b=H6v0JRHau0XpabHlAgCtKzyVT6XGoYqZoUmt/Dnsrp7L9TjQLPzkp3gTLn0EyYp7eO oakyktDM45cK7V+9RGKa9MC2Q3trjXq+rCmkAvrWpWTo1i2xbTeNUyFDO+cFtugEM3xC UbHhVNc44g4AswkbjMNkUXTmPjR1Pz5gy7F/CYJ5iXZcpVfg4SjAiw4EpcNrcnl3AGe+ uyviMfopd9LQ+EfT8V75gRXY1RHIgNw6gOOdGhrnhou/DuzXuYmqGOxF/QKVt53bafFo WtIk/ktoINV16G0ra0zIDc7I+dR/vTSnfwvFFp9GM2LxcrD7YFjTLqMn5zVAsTr4Vk7D 96Nw== X-Gm-Message-State: AOAM533Fu9WxV5sTXJpRTrQhWmSxgITQs/XeGmnSDrmrUX3E7iKGOQHc vugP53DFusru2X/CwHLxHP3z X-Google-Smtp-Source: ABdhPJysogckolByLTKMcr/MxZWQSFurvpfGyyWGzWHvCzD/JKR8cENOWIzhEm94G+0EqqY2cZ1ADQ== X-Received: by 2002:a17:902:7202:b029:de:8483:506c with SMTP id ba2-20020a1709027202b02900de8483506cmr2934737plb.52.1611032911992; Mon, 18 Jan 2021 21:08:31 -0800 (PST) Received: from localhost ([139.177.225.243]) by smtp.gmail.com with ESMTPSA id u68sm16497823pfb.70.2021.01.18.21.08.30 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 18 Jan 2021 21:08:31 -0800 (PST) From: Xie Yongji To: mst@redhat.com, jasowang@redhat.com, stefanha@redhat.com, sgarzare@redhat.com, parav@nvidia.com, bob.liu@oracle.com, hch@infradead.org, rdunlap@infradead.org, willy@infradead.org, viro@zeniv.linux.org.uk, axboe@kernel.dk, bcrl@kvack.org, corbet@lwn.net Cc: virtualization@lists.linux-foundation.org, netdev@vger.kernel.org, kvm@vger.kernel.org, linux-aio@kvack.org, linux-fsdevel@vger.kernel.org Subject: [RFC v3 11/11] vduse: Introduce a workqueue for irq injection Date: Tue, 19 Jan 2021 13:07:56 +0800 Message-Id: <20210119050756.600-5-xieyongji@bytedance.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210119050756.600-1-xieyongji@bytedance.com> References: <20210119045920.447-1-xieyongji@bytedance.com> <20210119050756.600-1-xieyongji@bytedance.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: kvm@vger.kernel.org This patch introduces a dedicated workqueue for irq injection so that we are able to do some performance tuning for it. Signed-off-by: Xie Yongji --- drivers/vdpa/vdpa_user/eventfd.c | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/drivers/vdpa/vdpa_user/eventfd.c b/drivers/vdpa/vdpa_user/eventfd.c index dbffddb08908..caf7d8d68ac0 100644 --- a/drivers/vdpa/vdpa_user/eventfd.c +++ b/drivers/vdpa/vdpa_user/eventfd.c @@ -18,6 +18,7 @@ #include "eventfd.h" static struct workqueue_struct *vduse_irqfd_cleanup_wq; +static struct workqueue_struct *vduse_irq_wq; static void vduse_virqfd_shutdown(struct work_struct *work) { @@ -57,7 +58,7 @@ static int vduse_virqfd_wakeup(wait_queue_entry_t *wait, unsigned int mode, __poll_t flags = key_to_poll(key); if (flags & EPOLLIN) - schedule_work(&virqfd->inject); + queue_work(vduse_irq_wq, &virqfd->inject); if (flags & EPOLLHUP) { spin_lock(&vq->irq_lock); @@ -165,11 +166,18 @@ int vduse_virqfd_init(void) if (!vduse_irqfd_cleanup_wq) return -ENOMEM; + vduse_irq_wq = alloc_workqueue("vduse-irq", WQ_SYSFS | WQ_UNBOUND, 0); + if (!vduse_irq_wq) { + destroy_workqueue(vduse_irqfd_cleanup_wq); + return -ENOMEM; + } + return 0; } void vduse_virqfd_exit(void) { + destroy_workqueue(vduse_irq_wq); destroy_workqueue(vduse_irqfd_cleanup_wq); }