From nobody Sun Apr 19 05:33:33 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id D652DC43334 for ; Wed, 6 Jul 2022 05:06:01 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S230078AbiGFFGA (ORCPT ); Wed, 6 Jul 2022 01:06:00 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:36784 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229968AbiGFFFz (ORCPT ); Wed, 6 Jul 2022 01:05:55 -0400 Received: from mail-pj1-x1029.google.com (mail-pj1-x1029.google.com [IPv6:2607:f8b0:4864:20::1029]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 8C27B1F61D for ; Tue, 5 Jul 2022 22:05:53 -0700 (PDT) Received: by mail-pj1-x1029.google.com with SMTP id ju17so9054208pjb.3 for ; Tue, 05 Jul 2022 22:05:53 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bytedance-com.20210112.gappssmtp.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=o6/JsOlJwlIJxWGuLjrTTVjd1qaroq7QICLqgjCEkQg=; b=ZOBwMLDCW8TQOuiBDT7xIpALiB5pwsgp+tumUSis4KgrjYMS4v3Q4hxudiuYpj1YWE eHiraxIGGwWSFE03924fxggxMsWhGp7NSTKj65Uk5BGb55uIYYX36CIPIYdD+uvNsXh7 PNPJ5D4wd18CslZctrEDT/jlrWxWfcvTsLYxnNg+5ljxBuL3M9Gha0gGKraCAwnlIvEb oFueA6fVfE37MzegZkf9hgb5galoCgflHXM4g1Auf8kUZfTKIICEyxfyxH9QXpqABKqA /wydchhLnUAUmSf4qOjD6+vJB8nmtnQ98Ol6Xhm3kqQDY3m+3sDocfrSAMloPAH6qw0u txDQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=o6/JsOlJwlIJxWGuLjrTTVjd1qaroq7QICLqgjCEkQg=; b=wem+6slRPwkkokFBoKsPT2iey3DsJEYPKwRn9QWfD2yc/klm8m6fMnfCjuxIDm0czU R7RPKWl14Z6z+pVtgzd+O3E6f8T0gRtdQHKWrK1IOpra4ktXRxuX9spii0/cmJP9aSMI uU6lZVZ3cZV4tW6T9JqwLJ+J69qdyQ/3vQT2YJJF8ZE2tMvFIRa2gweWE2ad2tXI13U4 kTzLvzGrjSZFhF5IgOeAueF47yk0WTamBB1DAXiS7m3vjs9lVVKSdtFFWxD565BXPLxu oBjWZeLkKZX1pyVz3rWU3etnszoOYpDWNqKc/PdS3LY4FeE9ElFXKu6lFTzUEWJecrk2 j5hw== X-Gm-Message-State: AJIora+NumgWAumhVRhFACBKXaQPHewE2Ev677VmfkHOKFvhGDc8C1sH Lh96s+KXNc53k8Eo5KYrIZhk X-Google-Smtp-Source: AGRyM1sogqpRRtujxKDNjXnDQqRwcoIPbG3B3VsEgpuMRhEhFZp0hIBA6KGw047PaJPkEk+35aii0g== X-Received: by 2002:a17:902:9693:b0:16b:d0d1:e16b with SMTP id n19-20020a170902969300b0016bd0d1e16bmr22773753plp.69.1657083953122; Tue, 05 Jul 2022 22:05:53 -0700 (PDT) Received: from localhost ([139.177.225.253]) by smtp.gmail.com with ESMTPSA id ay21-20020a17090b031500b001efaae21663sm785478pjb.28.2022.07.05.22.05.52 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 05 Jul 2022 22:05:52 -0700 (PDT) From: Xie Yongji To: mst@redhat.com, jasowang@redhat.com, xiaodong.liu@intel.com, maxime.coquelin@redhat.com, stefanha@redhat.com Cc: songmuchun@bytedance.com, virtualization@lists.linux-foundation.org, linux-kernel@vger.kernel.org Subject: [PATCH v2 1/5] vduse: Remove unnecessary spin lock protection Date: Wed, 6 Jul 2022 13:04:59 +0800 Message-Id: <20220706050503.171-2-xieyongji@bytedance.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20220706050503.171-1-xieyongji@bytedance.com> References: <20220706050503.171-1-xieyongji@bytedance.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" Taking iotlb lock to access bounce page in page fault handler is meaningless since vduse_domain_free_bounce_pages() would only be called during file release. Signed-off-by: Xie Yongji --- drivers/vdpa/vdpa_user/iova_domain.c | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/drivers/vdpa/vdpa_user/iova_domain.c b/drivers/vdpa/vdpa_user/= iova_domain.c index 6daa3978d290..bca1f0b8850c 100644 --- a/drivers/vdpa/vdpa_user/iova_domain.c +++ b/drivers/vdpa/vdpa_user/iova_domain.c @@ -211,17 +211,14 @@ static struct page * vduse_domain_get_bounce_page(struct vduse_iova_domain *domain, u64 iova) { struct vduse_bounce_map *map; - struct page *page =3D NULL; + struct page *page; =20 - spin_lock(&domain->iotlb_lock); map =3D &domain->bounce_maps[iova >> PAGE_SHIFT]; if (!map->bounce_page) - goto out; + return NULL; =20 page =3D map->bounce_page; get_page(page); -out: - spin_unlock(&domain->iotlb_lock); =20 return page; } --=20 2.20.1 From nobody Sun Apr 19 05:33:33 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 482C6C433EF for ; Wed, 6 Jul 2022 05:06:04 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S230131AbiGFFGC (ORCPT ); Wed, 6 Jul 2022 01:06:02 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:36842 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S230100AbiGFFF6 (ORCPT ); Wed, 6 Jul 2022 01:05:58 -0400 Received: from mail-pj1-x1033.google.com (mail-pj1-x1033.google.com [IPv6:2607:f8b0:4864:20::1033]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 590991B792 for ; Tue, 5 Jul 2022 22:05:57 -0700 (PDT) Received: by mail-pj1-x1033.google.com with SMTP id x18-20020a17090a8a9200b001ef83b332f5so8847289pjn.0 for ; Tue, 05 Jul 2022 22:05:57 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bytedance-com.20210112.gappssmtp.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=z1U879wVoKQgC+VVp5dSPlJ1DI5JNILGgmGyf1KCySs=; b=jtP2p/aSSZbB9SXA3VbtkDj9O8wB+KrZpRWQrndcYnad8nX0i3ffu9aoua+H7Skw+x rlc0GMe2N9PX/SzDImhd8umzF4Zdg2GT0o+EAqVKHXnWE5gBRjLLOHMFhD3PCPNp55fW dkQooq0Pqbd10G/gewX4bjz5a51ODX+B25a2dbzxMV52gtdmCgB0wJfSV0u9fRZJwM6j l2km4CS+WGaMGUkiy8cL2Z2SHOGjrA4sVZkDf9/+w3oVo+dwJU4VKeJd5x0A5IWgv7BN welT8+s8aZM36koSgwtLNyIy0ZBJwIqVDLkIi2r9J1FxzRR/kTTHPIDFlFyiplWwa0cE KIkg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=z1U879wVoKQgC+VVp5dSPlJ1DI5JNILGgmGyf1KCySs=; b=sQiGrbiqz1L7jG6JRy5ziJHg4S1ql6SNXYh5x2qlSy2O341kZtWwZ1jSfwKGnESezn bL/1+4Rz80rkJwV1DDOaA5SpINDcbXuOS9l60E30pzJ6QAN4ex3gr/L8qu606TZOcssv 7NYgxYaXsqP7/toEOFnU3A17jBRgHGpJ1PzKz34lUjj1Ev1iteguBNWDDXGhXNoyWr+A 2dBKtQ8is5ZW9cARuxex7Qd0BXbiOqDStP7M7TMry7Bd52Ils+odmHVVzsCF3PSBLyhm AbR5PmiPrNgiLtt/ZcgBns9eDzEJSQpPoBqr33FS9NxitQnpCGNSWbrFc4FtdA9OFIVV QDZA== X-Gm-Message-State: AJIora+tdAUFR6y1WC43FZUSOfvR6KNyiQ0lDds6c+EGKQHMSizC4yzS 70kqaC4Vp90AiYHUkT1Hirhd X-Google-Smtp-Source: AGRyM1uGO6hDXem1gjCyCJgwOMjwiLCEHm0bzbw74D8COK5kqMJuCy28Eaj8nAGEqQ7EWPbvxII4AA== X-Received: by 2002:a17:902:f646:b0:168:e2da:8931 with SMTP id m6-20020a170902f64600b00168e2da8931mr44666522plg.84.1657083956892; Tue, 05 Jul 2022 22:05:56 -0700 (PDT) Received: from localhost ([139.177.225.253]) by smtp.gmail.com with ESMTPSA id c20-20020a656754000000b003fcf1279c84sm22834363pgu.33.2022.07.05.22.05.55 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 05 Jul 2022 22:05:56 -0700 (PDT) From: Xie Yongji To: mst@redhat.com, jasowang@redhat.com, xiaodong.liu@intel.com, maxime.coquelin@redhat.com, stefanha@redhat.com Cc: songmuchun@bytedance.com, virtualization@lists.linux-foundation.org, linux-kernel@vger.kernel.org Subject: [PATCH v2 2/5] vduse: Use memcpy_{to,from}_page() in do_bounce() Date: Wed, 6 Jul 2022 13:05:00 +0800 Message-Id: <20220706050503.171-3-xieyongji@bytedance.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20220706050503.171-1-xieyongji@bytedance.com> References: <20220706050503.171-1-xieyongji@bytedance.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" kmap_atomic() is being deprecated in favor of kmap_local_page(). The use of kmap_atomic() in do_bounce() is all thread local therefore kmap_local_page() is a sufficient replacement. Convert to kmap_local_page() but, instead of open coding it, use the helpers memcpy_to_page() and memcpy_from_page(). Signed-off-by: Xie Yongji Acked-by: Jason Wang --- drivers/vdpa/vdpa_user/iova_domain.c | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/drivers/vdpa/vdpa_user/iova_domain.c b/drivers/vdpa/vdpa_user/= iova_domain.c index bca1f0b8850c..50d7c08d5450 100644 --- a/drivers/vdpa/vdpa_user/iova_domain.c +++ b/drivers/vdpa/vdpa_user/iova_domain.c @@ -138,18 +138,17 @@ static void do_bounce(phys_addr_t orig, void *addr, s= ize_t size, { unsigned long pfn =3D PFN_DOWN(orig); unsigned int offset =3D offset_in_page(orig); - char *buffer; + struct page *page; unsigned int sz =3D 0; =20 while (size) { sz =3D min_t(size_t, PAGE_SIZE - offset, size); =20 - buffer =3D kmap_atomic(pfn_to_page(pfn)); + page =3D pfn_to_page(pfn); if (dir =3D=3D DMA_TO_DEVICE) - memcpy(addr, buffer + offset, sz); + memcpy_from_page(addr, page, offset, sz); else - memcpy(buffer + offset, addr, sz); - kunmap_atomic(buffer); + memcpy_to_page(page, offset, addr, sz); =20 size -=3D sz; pfn++; --=20 2.20.1 From nobody Sun Apr 19 05:33:33 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 4EE47C433EF for ; Wed, 6 Jul 2022 05:06:10 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S230298AbiGFFGI (ORCPT ); Wed, 6 Jul 2022 01:06:08 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:36918 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S230184AbiGFFGC (ORCPT ); Wed, 6 Jul 2022 01:06:02 -0400 Received: from mail-pj1-x102b.google.com (mail-pj1-x102b.google.com [IPv6:2607:f8b0:4864:20::102b]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 1F9EC192A6 for ; Tue, 5 Jul 2022 22:06:01 -0700 (PDT) Received: by mail-pj1-x102b.google.com with SMTP id o5-20020a17090a3d4500b001ef76490983so10164273pjf.2 for ; Tue, 05 Jul 2022 22:06:01 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bytedance-com.20210112.gappssmtp.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=QhASuSf86HbeQ+sQa6ckHpYaDHR8uGVnKtFMqMlSbWE=; b=qcWqV3VkYF3MqYwNMEVHm0iHHIyXGMupi8rCrBULB+y0HCFpzCxHfVfdNpu0noUbkH 50SbmiNeeusRxdiBT9HpiVbgg6Z9rCogucIAr1Hg8xJtmRTM2cXFIrlGpOXS4eKS7NSC jxHuMVRVOgjvkqZ78+4ANyNXDuntycbvgqFIDNVoQUsKS971b680/ES2N7iDDj0B+4l8 sYRTvrun2wDP3GrZ3XOG8QlP8P4nYdgBZom79XPvJlUq3zEL4VWB+4o7NtZhA2E+W3/0 YCLCWEWhbwSfkSHo8rqUubPMlNauPq5GKaXPZXrBvPmte1wX5youDLwS0kjY42TTsScK 0f3g== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=QhASuSf86HbeQ+sQa6ckHpYaDHR8uGVnKtFMqMlSbWE=; b=B6cmkIH1Vsw8ypZ4AQkWFQJbz69XnFbAqeTNmPmBTU+e5xXxmZ7FpzzUyFjTSm9i/n ItwD3vSxoMhr7DpSZVl1M67C8MTI+tmGIcmqsdjL0B615GPEzscEZO5YeMvoF+aO5rG2 bBBlShnHxNjjIkyX328X7Nz/Tq9TcbgczQEtl5OSflxQ6myOm5LzCtrQ/X2bT6Juo5FN lLffImSM3H+A9tO9CEWohcQcIC/5iM06C/2E0ZGiDkybFgjQh7Vb38n1BSninzHz5/Mr RpZ2m8JC3RE7kVMnxFn1uEGJMGBxJeHKR0+k6TZixtCRyAuPYxZCg25q8jU8U8yGbVcD 1adg== X-Gm-Message-State: AJIora+XILU0ujLVAVNGRZe9dFqZLBHhhzSrGDTsS3vcddpQiyBeLNUA DQvtppZAcoQ1qod6z0uCyXQv X-Google-Smtp-Source: AGRyM1spsXCY1vRAQAPIsn23qYYe27tbJyTeDk4DEuDnW4xeHA4ouJ9+jI4AUq8mlaH3zu33skfujw== X-Received: by 2002:a17:902:f683:b0:16a:6456:5369 with SMTP id l3-20020a170902f68300b0016a64565369mr43483414plg.136.1657083960652; Tue, 05 Jul 2022 22:06:00 -0700 (PDT) Received: from localhost ([139.177.225.253]) by smtp.gmail.com with ESMTPSA id o13-20020a170902d4cd00b0016be527753bsm5217757plg.264.2022.07.05.22.05.59 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 05 Jul 2022 22:06:00 -0700 (PDT) From: Xie Yongji To: mst@redhat.com, jasowang@redhat.com, xiaodong.liu@intel.com, maxime.coquelin@redhat.com, stefanha@redhat.com Cc: songmuchun@bytedance.com, virtualization@lists.linux-foundation.org, linux-kernel@vger.kernel.org Subject: [PATCH v2 3/5] vduse: Support using userspace pages as bounce buffer Date: Wed, 6 Jul 2022 13:05:01 +0800 Message-Id: <20220706050503.171-4-xieyongji@bytedance.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20220706050503.171-1-xieyongji@bytedance.com> References: <20220706050503.171-1-xieyongji@bytedance.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" Introduce two APIs: vduse_domain_add_user_bounce_pages() and vduse_domain_remove_user_bounce_pages() to support adding and removing userspace pages for bounce buffers. During adding and removing, the DMA data would be copied from the kernel bounce pages to the userspace bounce pages and back. Signed-off-by: Xie Yongji --- drivers/vdpa/vdpa_user/iova_domain.c | 128 +++++++++++++++++++++++++-- drivers/vdpa/vdpa_user/iova_domain.h | 9 ++ 2 files changed, 129 insertions(+), 8 deletions(-) diff --git a/drivers/vdpa/vdpa_user/iova_domain.c b/drivers/vdpa/vdpa_user/= iova_domain.c index 50d7c08d5450..2ae29341228e 100644 --- a/drivers/vdpa/vdpa_user/iova_domain.c +++ b/drivers/vdpa/vdpa_user/iova_domain.c @@ -178,8 +178,9 @@ static void vduse_domain_bounce(struct vduse_iova_domai= n *domain, map->orig_phys =3D=3D INVALID_PHYS_ADDR)) return; =20 - addr =3D page_address(map->bounce_page) + offset; - do_bounce(map->orig_phys + offset, addr, sz, dir); + addr =3D kmap_local_page(map->bounce_page); + do_bounce(map->orig_phys + offset, addr + offset, sz, dir); + kunmap_local(addr); size -=3D sz; iova +=3D sz; } @@ -210,20 +211,23 @@ static struct page * vduse_domain_get_bounce_page(struct vduse_iova_domain *domain, u64 iova) { struct vduse_bounce_map *map; - struct page *page; + struct page *page =3D NULL; =20 + read_lock(&domain->bounce_lock); map =3D &domain->bounce_maps[iova >> PAGE_SHIFT]; - if (!map->bounce_page) - return NULL; + if (domain->user_bounce_pages || !map->bounce_page) + goto out; =20 page =3D map->bounce_page; get_page(page); +out: + read_unlock(&domain->bounce_lock); =20 return page; } =20 static void -vduse_domain_free_bounce_pages(struct vduse_iova_domain *domain) +vduse_domain_free_kernel_bounce_pages(struct vduse_iova_domain *domain) { struct vduse_bounce_map *map; unsigned long pfn, bounce_pfns; @@ -243,6 +247,81 @@ vduse_domain_free_bounce_pages(struct vduse_iova_domai= n *domain) } } =20 +int vduse_domain_add_user_bounce_pages(struct vduse_iova_domain *domain, + struct page **pages, int count) +{ + struct vduse_bounce_map *map; + int i, ret; + + /* Now we don't support partial mapping */ + if (count !=3D (domain->bounce_size >> PAGE_SHIFT)) + return -EINVAL; + + write_lock(&domain->bounce_lock); + ret =3D -EEXIST; + if (domain->user_bounce_pages) + goto out; + + ret =3D -EBUSY; + /* + * Make sure nobody maps the kernel bounce pages, + * then we can free them. + */ + if (domain->mapped) + goto out; + + for (i =3D 0; i < count; i++) { + map =3D &domain->bounce_maps[i]; + if (map->bounce_page) { + /* Copy kernel page to user page if it's in use */ + if (map->orig_phys !=3D INVALID_PHYS_ADDR) + memcpy_to_page(pages[i], 0, + page_address(map->bounce_page), + PAGE_SIZE); + __free_page(map->bounce_page); + } + map->bounce_page =3D pages[i]; + get_page(pages[i]); + } + domain->user_bounce_pages =3D true; + ret =3D 0; +out: + write_unlock(&domain->bounce_lock); + + return ret; +} + +void vduse_domain_remove_user_bounce_pages(struct vduse_iova_domain *domai= n) +{ + struct vduse_bounce_map *map; + unsigned long i, count; + + write_lock(&domain->bounce_lock); + if (!domain->user_bounce_pages) + goto out; + + count =3D domain->bounce_size >> PAGE_SHIFT; + for (i =3D 0; i < count; i++) { + struct page *page =3D NULL; + + map =3D &domain->bounce_maps[i]; + if (WARN_ON(!map->bounce_page)) + continue; + + /* Copy user page to kernel page if it's in use */ + if (map->orig_phys !=3D INVALID_PHYS_ADDR) { + page =3D alloc_page(GFP_ATOMIC | __GFP_NOFAIL); + memcpy_from_page(page_address(page), + map->bounce_page, 0, PAGE_SIZE); + } + put_page(map->bounce_page); + map->bounce_page =3D page; + } + domain->user_bounce_pages =3D false; +out: + write_unlock(&domain->bounce_lock); +} + void vduse_domain_reset_bounce_map(struct vduse_iova_domain *domain) { if (!domain->bounce_map) @@ -318,13 +397,18 @@ dma_addr_t vduse_domain_map_page(struct vduse_iova_do= main *domain, if (vduse_domain_init_bounce_map(domain)) goto err; =20 + read_lock(&domain->bounce_lock); if (vduse_domain_map_bounce_page(domain, (u64)iova, (u64)size, pa)) - goto err; + goto err_unlock; =20 if (dir =3D=3D DMA_TO_DEVICE || dir =3D=3D DMA_BIDIRECTIONAL) vduse_domain_bounce(domain, iova, size, DMA_TO_DEVICE); =20 + read_unlock(&domain->bounce_lock); + return iova; +err_unlock: + read_unlock(&domain->bounce_lock); err: vduse_domain_free_iova(iovad, iova, size); return DMA_MAPPING_ERROR; @@ -336,10 +420,12 @@ void vduse_domain_unmap_page(struct vduse_iova_domain= *domain, { struct iova_domain *iovad =3D &domain->stream_iovad; =20 + read_lock(&domain->bounce_lock); if (dir =3D=3D DMA_FROM_DEVICE || dir =3D=3D DMA_BIDIRECTIONAL) vduse_domain_bounce(domain, dma_addr, size, DMA_FROM_DEVICE); =20 vduse_domain_unmap_bounce_page(domain, (u64)dma_addr, (u64)size); + read_unlock(&domain->bounce_lock); vduse_domain_free_iova(iovad, dma_addr, size); } =20 @@ -404,6 +490,24 @@ void vduse_domain_free_coherent(struct vduse_iova_doma= in *domain, size_t size, free_pages_exact(phys_to_virt(pa), size); } =20 +static void vduse_domain_mmap_open(struct vm_area_struct *vma) +{ + struct vduse_iova_domain *domain =3D vma->vm_private_data; + + write_lock(&domain->bounce_lock); + domain->mapped++; + write_unlock(&domain->bounce_lock); +} + +static void vduse_domain_mmap_close(struct vm_area_struct *vma) +{ + struct vduse_iova_domain *domain =3D vma->vm_private_data; + + write_lock(&domain->bounce_lock); + domain->mapped--; + write_unlock(&domain->bounce_lock); +} + static vm_fault_t vduse_domain_mmap_fault(struct vm_fault *vmf) { struct vduse_iova_domain *domain =3D vmf->vma->vm_private_data; @@ -427,6 +531,8 @@ static vm_fault_t vduse_domain_mmap_fault(struct vm_fau= lt *vmf) } =20 static const struct vm_operations_struct vduse_domain_mmap_ops =3D { + .open =3D vduse_domain_mmap_open, + .close =3D vduse_domain_mmap_close, .fault =3D vduse_domain_mmap_fault, }; =20 @@ -438,6 +544,10 @@ static int vduse_domain_mmap(struct file *file, struct= vm_area_struct *vma) vma->vm_private_data =3D domain; vma->vm_ops =3D &vduse_domain_mmap_ops; =20 + write_lock(&domain->bounce_lock); + domain->mapped++; + write_unlock(&domain->bounce_lock); + return 0; } =20 @@ -447,7 +557,8 @@ static int vduse_domain_release(struct inode *inode, st= ruct file *file) =20 spin_lock(&domain->iotlb_lock); vduse_iotlb_del_range(domain, 0, ULLONG_MAX); - vduse_domain_free_bounce_pages(domain); + vduse_domain_remove_user_bounce_pages(domain); + vduse_domain_free_kernel_bounce_pages(domain); spin_unlock(&domain->iotlb_lock); put_iova_domain(&domain->stream_iovad); put_iova_domain(&domain->consistent_iovad); @@ -507,6 +618,7 @@ vduse_domain_create(unsigned long iova_limit, size_t bo= unce_size) goto err_file; =20 domain->file =3D file; + rwlock_init(&domain->bounce_lock); spin_lock_init(&domain->iotlb_lock); init_iova_domain(&domain->stream_iovad, PAGE_SIZE, IOVA_START_PFN); diff --git a/drivers/vdpa/vdpa_user/iova_domain.h b/drivers/vdpa/vdpa_user/= iova_domain.h index 2722d9b8e21a..4a47615346ac 100644 --- a/drivers/vdpa/vdpa_user/iova_domain.h +++ b/drivers/vdpa/vdpa_user/iova_domain.h @@ -14,6 +14,7 @@ #include #include #include +#include =20 #define IOVA_START_PFN 1 =20 @@ -34,6 +35,9 @@ struct vduse_iova_domain { struct vhost_iotlb *iotlb; spinlock_t iotlb_lock; struct file *file; + int mapped; + bool user_bounce_pages; + rwlock_t bounce_lock; }; =20 int vduse_domain_set_map(struct vduse_iova_domain *domain, @@ -61,6 +65,11 @@ void vduse_domain_free_coherent(struct vduse_iova_domain= *domain, size_t size, =20 void vduse_domain_reset_bounce_map(struct vduse_iova_domain *domain); =20 +int vduse_domain_add_user_bounce_pages(struct vduse_iova_domain *domain, + struct page **pages, int count); + +void vduse_domain_remove_user_bounce_pages(struct vduse_iova_domain *domai= n); + void vduse_domain_destroy(struct vduse_iova_domain *domain); =20 struct vduse_iova_domain *vduse_domain_create(unsigned long iova_limit, --=20 2.20.1 From nobody Sun Apr 19 05:33:33 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 6B694C43334 for ; Wed, 6 Jul 2022 05:06:12 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S230359AbiGFFGJ (ORCPT ); Wed, 6 Jul 2022 01:06:09 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:36958 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S230301AbiGFFGH (ORCPT ); Wed, 6 Jul 2022 01:06:07 -0400 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 0680F1F61D for ; Tue, 5 Jul 2022 22:06:05 -0700 (PDT) Received: by mail-pf1-x42a.google.com with SMTP id e16so604267pfm.11 for ; Tue, 05 Jul 2022 22:06:05 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bytedance-com.20210112.gappssmtp.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=G3nmW2W5f1Ags3bIprl9TznXZAGwoHC4aKKQYqLLiCg=; b=n7uEfOwsq5qFDVeWprIqk1KtV0v6owA0bqRupKBSPiKqr1WaL2/1F8NHjeJyRFFvIU 9HrTPjY5oKceBj9vp6hh2aJS9DvJei2JNd8j/5vPdzXFQeicp9+l+pTsjEuf96P1UMoW MsaiV8ApH1r302AlLcYHQhP2yDxMIGOlAI9Sfu5fTnqI4VEOEsWU9aoskpTBM0LGvwLg qsJethNZE0uv1tUs/fsF5o1V84IHSACVcs6mpxLS5OLB4j6mDUng+1HsQ2GL5B3AzHUx D9Fi4C1dMn0wpZSE/yW/EWaN/B/rsbOFnzR0sykP0sZAzEF0tory0H5xNVHD2+mKdhFw nzQw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=G3nmW2W5f1Ags3bIprl9TznXZAGwoHC4aKKQYqLLiCg=; b=IBhDSb+bGsekdkecjYEJyM1VrEhZpexA4gfQDreWZ9Q3mVF3S5PPxqNmC7VG0GzkU9 ZJA5odcE7X2I3FwilRsXRA53x7il6Hf/xerdmabRGTNKedQbdJC00VYHndVEc+MeiRDZ Ppe0wToJynB6To4OGANZ52koh7xWgIg1qcMT8DZKr39k36DA46xd4ZBBxR/XlGYlohCy v3k37uWFczf2Mnb4qTBCD1jh6XmGMmcbdoWPtvFY1jqlcsteLoGl9ei60k6/FI0fxvR2 eCnjPh07JEHv1bMDLAEjYwQxATN0WTZV1H6fL3PP+mfHmF0vXkL1s8GKw/G1f/zERA1R pNJQ== X-Gm-Message-State: AJIora8A6ewhQV8zXRiO17e9Ro5vrD0gT/U01nfAbq9PHJVR5u6yZc9O dh3eoY5jHpWbmjoWC7xHaRJj X-Google-Smtp-Source: AGRyM1stEPseYajiuoOqqCaxCJvv46n9hdAVXLo3g0VdzKfYo1mQdWhiwo7qQXQ14ZCWen5L+gS71w== X-Received: by 2002:aa7:8b51:0:b0:525:5132:8a84 with SMTP id i17-20020aa78b51000000b0052551328a84mr45047050pfd.45.1657083964436; Tue, 05 Jul 2022 22:06:04 -0700 (PDT) Received: from localhost ([139.177.225.253]) by smtp.gmail.com with ESMTPSA id m10-20020a170902f64a00b0016bf01394e1sm2938332plg.124.2022.07.05.22.06.03 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 05 Jul 2022 22:06:03 -0700 (PDT) From: Xie Yongji To: mst@redhat.com, jasowang@redhat.com, xiaodong.liu@intel.com, maxime.coquelin@redhat.com, stefanha@redhat.com Cc: songmuchun@bytedance.com, virtualization@lists.linux-foundation.org, linux-kernel@vger.kernel.org Subject: [PATCH v2 4/5] vduse: Support querying IOLTB information Date: Wed, 6 Jul 2022 13:05:02 +0800 Message-Id: <20220706050503.171-5-xieyongji@bytedance.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20220706050503.171-1-xieyongji@bytedance.com> References: <20220706050503.171-1-xieyongji@bytedance.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" This introduces a new ioctl: VDUSE_IOTLB_GET_INFO to support querying IOLTB information such as bounce buffer size. Signed-off-by: Xie Yongji --- drivers/vdpa/vdpa_user/vduse_dev.c | 13 +++++++++++++ include/uapi/linux/vduse.h | 17 +++++++++++++++++ 2 files changed, 30 insertions(+) diff --git a/drivers/vdpa/vdpa_user/vduse_dev.c b/drivers/vdpa/vdpa_user/vd= use_dev.c index 3bc27de58f46..c47a5d9765cf 100644 --- a/drivers/vdpa/vdpa_user/vduse_dev.c +++ b/drivers/vdpa/vdpa_user/vduse_dev.c @@ -1089,6 +1089,19 @@ static long vduse_dev_ioctl(struct file *file, unsig= ned int cmd, ret =3D vduse_dev_queue_irq_work(dev, &dev->vqs[index].inject); break; } + case VDUSE_IOTLB_GET_INFO: { + struct vduse_iotlb_info iotlb; + + iotlb.bounce_iova =3D 0; + iotlb.bounce_size =3D dev->domain->bounce_size; + + ret =3D -EFAULT; + if (copy_to_user(argp, &iotlb, sizeof(iotlb))) + break; + + ret =3D 0; + break; + } default: ret =3D -ENOIOCTLCMD; break; diff --git a/include/uapi/linux/vduse.h b/include/uapi/linux/vduse.h index 7cfe1c1280c0..c201b7a77c2c 100644 --- a/include/uapi/linux/vduse.h +++ b/include/uapi/linux/vduse.h @@ -210,6 +210,23 @@ struct vduse_vq_eventfd { */ #define VDUSE_VQ_INJECT_IRQ _IOW(VDUSE_BASE, 0x17, __u32) =20 +/** + * struct vduse_iotlb_info - IOTLB information + * @bounce_iova: start IOVA of bounce buffer + * @bounce_size: bounce buffer size + * @reserved: for future use, needs to be initialized to zero + * + * Structure used by VDUSE_IOTLB_GET_INFO ioctl to get IOTLB information. + */ +struct vduse_iotlb_info { + __u64 bounce_iova; + __u64 bounce_size; + __u64 reserved[2]; +}; + +/* Get IOTLB information, e.g. bounce buffer size */ +#define VDUSE_IOTLB_GET_INFO _IOR(VDUSE_BASE, 0x18, struct vduse_iotlb_= info) + /* The control messages definition for read(2)/write(2) on /dev/vduse/$NAM= E */ =20 /** --=20 2.20.1 From nobody Sun Apr 19 05:33:33 2026 Return-Path: Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 124C1C433EF for ; Wed, 6 Jul 2022 05:06:24 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S230445AbiGFFGV (ORCPT ); Wed, 6 Jul 2022 01:06:21 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:37056 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S230363AbiGFFGK (ORCPT ); Wed, 6 Jul 2022 01:06:10 -0400 Received: from mail-pl1-x631.google.com (mail-pl1-x631.google.com [IPv6:2607:f8b0:4864:20::631]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 092FB1FCE9 for ; Tue, 5 Jul 2022 22:06:09 -0700 (PDT) Received: by mail-pl1-x631.google.com with SMTP id p9so2583324plr.11 for ; Tue, 05 Jul 2022 22:06:09 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bytedance-com.20210112.gappssmtp.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=K71BXIB29TSxmp583YvnKLnBPlPdaNaleq0jqbOgPqc=; b=cZs0yLCFAFEgpEsE0XZn78t/YsdMKqaWjqPs3/uUoINAR6VTEFOFYwpsYLQTNnVcXT pLa/DezgI83VWxsxeWYifRmNqwFr04TxgV3lqaSnIgg/Y/Uwu++sc4PyVG83mHUGC+uQ Kw80OuaEZJxZ2w2RO/d9Rygcmy7epIvxyHlq9mpQPfdelXKSFH3RoxdaL4+5LBB6JBKb ylzGZDcpX8UfV15ewzTwqYe/5wLJkLN/qRZWoXLKuRRkpkOwTbMCmiGNBVmI2+sZ68C1 UF8GrydjSjF4sxbBL13/oQGTCozBC+AXJ0hrhFZXSAs2ZFdO4eIkzWdb6faVIkw1Z6H9 cmfw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=K71BXIB29TSxmp583YvnKLnBPlPdaNaleq0jqbOgPqc=; b=cATmjsv5j2NcJvm64MzD4uKlKCHtBQRkAuIm6Q0b8bKX7tn3XAbDEU3YPjYn0Bk1/w sn9RvKx4eq/Ei92rY7PtG6MZKQM1sPLOElxv3NWbmkapM860VD580TSM8MyJ8eWchxfc YeH4WfrM9sAPlbnVZEGqpJ/bmbf/lyli8HN3liaOui/2w24rwX/It2Yg13yqJk8kezdM qaEMJ5Or4yQEgVpNkks8zmdrJQhjAmYqT0KLGO5USkxCxKdr+Da3pyMjvw2lLdjv0878 PhgkqY0c6guMSLzI0ONcK9mmjp/QfQz1oQ4+pfYSK2o1/CjkYvoQrWtr+70XzPMZj+wD KKLQ== X-Gm-Message-State: AJIora9tJ2f2ymaME4N3tLy0OJX1EzsUjjuXvQZP/IKHEQmbzXdDXMce 07uS475pmBnJ5MYt3KFfnGWI X-Google-Smtp-Source: AGRyM1t1CBpZvfaLhWYDBrD+dvEY2mYcYWFzrDIb99Wfu0THy+6Ygn76dPmdLnJIQeXKXZoXB0IgYA== X-Received: by 2002:a17:90a:710a:b0:1ef:991c:dc67 with SMTP id h10-20020a17090a710a00b001ef991cdc67mr9402227pjk.110.1657083968558; Tue, 05 Jul 2022 22:06:08 -0700 (PDT) Received: from localhost ([139.177.225.253]) by smtp.gmail.com with ESMTPSA id n10-20020a170902e54a00b0016191b843e2sm24477461plf.235.2022.07.05.22.06.07 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 05 Jul 2022 22:06:08 -0700 (PDT) From: Xie Yongji To: mst@redhat.com, jasowang@redhat.com, xiaodong.liu@intel.com, maxime.coquelin@redhat.com, stefanha@redhat.com Cc: songmuchun@bytedance.com, virtualization@lists.linux-foundation.org, linux-kernel@vger.kernel.org Subject: [PATCH v2 5/5] vduse: Support registering userspace memory for IOTLB Date: Wed, 6 Jul 2022 13:05:03 +0800 Message-Id: <20220706050503.171-6-xieyongji@bytedance.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20220706050503.171-1-xieyongji@bytedance.com> References: <20220706050503.171-1-xieyongji@bytedance.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Spam-Status: No, score=-1.9 required=5.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,RCVD_IN_DNSWL_NONE,SPF_HELO_NONE,SPF_PASS, T_SCC_BODY_TEXT_LINE autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on lindbergh.monkeyblade.net Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" Introduce two ioctls: VDUSE_IOTLB_REG_UMEM and VDUSE_IOTLB_DEREG_UMEM to support registering and de-registering userspace memory for IOTLB in virtio-vdpa case. Now it only supports registering userspace memory for IOTLB as bounce buffer. Signed-off-by: Xie Yongji Reported-by: kernel test robot --- drivers/vdpa/vdpa_user/vduse_dev.c | 139 +++++++++++++++++++++++++++++ include/uapi/linux/vduse.h | 28 ++++++ 2 files changed, 167 insertions(+) diff --git a/drivers/vdpa/vdpa_user/vduse_dev.c b/drivers/vdpa/vdpa_user/vd= use_dev.c index c47a5d9765cf..4467ae2381bb 100644 --- a/drivers/vdpa/vdpa_user/vduse_dev.c +++ b/drivers/vdpa/vdpa_user/vduse_dev.c @@ -21,6 +21,7 @@ #include #include #include +#include #include #include #include @@ -64,6 +65,13 @@ struct vduse_vdpa { struct vduse_dev *dev; }; =20 +struct vduse_iotlb_mem { + unsigned long iova; + unsigned long npages; + struct page **pages; + struct mm_struct *mm; +}; + struct vduse_dev { struct vduse_vdpa *vdev; struct device *dev; @@ -95,6 +103,8 @@ struct vduse_dev { u8 status; u32 vq_num; u32 vq_align; + struct vduse_iotlb_mem *iotlb_mem; + struct mutex mem_lock; }; =20 struct vduse_dev_msg { @@ -917,6 +927,101 @@ static int vduse_dev_queue_irq_work(struct vduse_dev = *dev, return ret; } =20 +static int vduse_dev_dereg_iotlb_mem(struct vduse_dev *dev, + u64 iova, u64 size) +{ + int ret; + + mutex_lock(&dev->mem_lock); + ret =3D -ENOENT; + if (!dev->iotlb_mem) + goto unlock; + + ret =3D -EINVAL; + if (dev->iotlb_mem->iova !=3D iova || size !=3D dev->domain->bounce_size) + goto unlock; + + vduse_domain_remove_user_bounce_pages(dev->domain); + unpin_user_pages_dirty_lock(dev->iotlb_mem->pages, + dev->iotlb_mem->npages, true); + atomic64_sub(dev->iotlb_mem->npages, &dev->iotlb_mem->mm->pinned_vm); + mmdrop(dev->iotlb_mem->mm); + vfree(dev->iotlb_mem->pages); + kfree(dev->iotlb_mem); + dev->iotlb_mem =3D NULL; + ret =3D 0; +unlock: + mutex_unlock(&dev->mem_lock); + return ret; +} + +static int vduse_dev_reg_iotlb_mem(struct vduse_dev *dev, + u64 iova, u64 uaddr, u64 size) +{ + struct page **page_list =3D NULL; + struct vduse_iotlb_mem *mem =3D NULL; + long pinned =3D 0; + unsigned long npages, lock_limit; + int ret; + + if (size !=3D dev->domain->bounce_size || + iova !=3D 0 || uaddr & ~PAGE_MASK) + return -EINVAL; + + mutex_lock(&dev->mem_lock); + ret =3D -EEXIST; + if (dev->iotlb_mem) + goto unlock; + + ret =3D -ENOMEM; + npages =3D size >> PAGE_SHIFT; + page_list =3D __vmalloc(array_size(npages, sizeof(struct page *)), + GFP_KERNEL_ACCOUNT); + mem =3D kzalloc(sizeof(*mem), GFP_KERNEL); + if (!page_list || !mem) + goto unlock; + + mmap_read_lock(current->mm); + + lock_limit =3D PFN_DOWN(rlimit(RLIMIT_MEMLOCK)); + if (npages + atomic64_read(¤t->mm->pinned_vm) > lock_limit) + goto out; + + pinned =3D pin_user_pages(uaddr, npages, FOLL_LONGTERM | FOLL_WRITE, + page_list, NULL); + if (pinned !=3D npages) { + ret =3D pinned < 0 ? pinned : -ENOMEM; + goto out; + } + + ret =3D vduse_domain_add_user_bounce_pages(dev->domain, + page_list, pinned); + if (ret) + goto out; + + atomic64_add(npages, ¤t->mm->pinned_vm); + + mem->pages =3D page_list; + mem->npages =3D pinned; + mem->iova =3D iova; + mem->mm =3D current->mm; + mmgrab(current->mm); + + dev->iotlb_mem =3D mem; +out: + if (ret && pinned > 0) + unpin_user_pages(page_list, pinned); + + mmap_read_unlock(current->mm); +unlock: + if (ret) { + vfree(page_list); + kfree(mem); + } + mutex_unlock(&dev->mem_lock); + return ret; +} + static long vduse_dev_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { @@ -943,6 +1048,16 @@ static long vduse_dev_ioctl(struct file *file, unsign= ed int cmd, if (entry.start > entry.last) break; =20 + if (domain->bounce_map && dev->iotlb_mem) { + ret =3D -EEXIST; + if (entry.start >=3D 0 && + entry.last < domain->bounce_size) + break; + + if (entry.start < domain->bounce_size) + entry.start =3D domain->bounce_size; + } + spin_lock(&domain->iotlb_lock); map =3D vhost_iotlb_itree_first(domain->iotlb, entry.start, entry.last); @@ -1102,6 +1217,28 @@ static long vduse_dev_ioctl(struct file *file, unsig= ned int cmd, ret =3D 0; break; } + case VDUSE_IOTLB_REG_UMEM: { + struct vduse_iotlb_umem umem; + + ret =3D -EFAULT; + if (copy_from_user(&umem, argp, sizeof(umem))) + break; + + ret =3D vduse_dev_reg_iotlb_mem(dev, umem.iova, + umem.uaddr, umem.size); + break; + } + case VDUSE_IOTLB_DEREG_UMEM: { + struct vduse_iotlb_umem umem; + + ret =3D -EFAULT; + if (copy_from_user(&umem, argp, sizeof(umem))) + break; + + ret =3D vduse_dev_dereg_iotlb_mem(dev, umem.iova, + umem.size); + break; + } default: ret =3D -ENOIOCTLCMD; break; @@ -1114,6 +1251,7 @@ static int vduse_dev_release(struct inode *inode, str= uct file *file) { struct vduse_dev *dev =3D file->private_data; =20 + vduse_dev_dereg_iotlb_mem(dev, 0, dev->domain->bounce_size); spin_lock(&dev->msg_lock); /* Make sure the inflight messages can processed after reconncection */ list_splice_init(&dev->recv_list, &dev->send_list); @@ -1176,6 +1314,7 @@ static struct vduse_dev *vduse_dev_create(void) return NULL; =20 mutex_init(&dev->lock); + mutex_init(&dev->mem_lock); spin_lock_init(&dev->msg_lock); INIT_LIST_HEAD(&dev->send_list); INIT_LIST_HEAD(&dev->recv_list); diff --git a/include/uapi/linux/vduse.h b/include/uapi/linux/vduse.h index c201b7a77c2c..1b17391e228f 100644 --- a/include/uapi/linux/vduse.h +++ b/include/uapi/linux/vduse.h @@ -227,6 +227,34 @@ struct vduse_iotlb_info { /* Get IOTLB information, e.g. bounce buffer size */ #define VDUSE_IOTLB_GET_INFO _IOR(VDUSE_BASE, 0x18, struct vduse_iotlb_= info) =20 +/** + * struct vduse_iotlb_umem - userspace memory configuration + * @uaddr: start address of userspace memory, it must be aligned to page s= ize + * @iova: IOVA of userspace memory, it must be equal to bounce iova return= ed + * by VDUSE_IOTLB_GET_INFO now + * @size: size of userspace memory, it must be equal to bounce size return= ed + * by VDUSE_IOTLB_GET_INFO now + * @reserved: for future use, needs to be initialized to zero + * + * Structure used by VDUSE_IOTLB_REG_UMEM and VDUSE_IOTLB_DEREG_UMEM + * ioctls to register/de-register userspace memory for IOTLB. + */ +struct vduse_iotlb_umem { + __u64 uaddr; + __u64 iova; + __u64 size; + __u64 reserved[3]; +}; + +/* + * Register userspace memory for IOTLB. Now we only support registering + * userspace memory as bounce buffer. + */ +#define VDUSE_IOTLB_REG_UMEM _IOW(VDUSE_BASE, 0x19, struct vduse_iotlb_ume= m) + +/* De-register the userspace memory. Caller should set iova and size field= . */ +#define VDUSE_IOTLB_DEREG_UMEM _IOW(VDUSE_BASE, 0x1a, struct vduse_iotlb_u= mem) + /* The control messages definition for read(2)/write(2) on /dev/vduse/$NAM= E */ =20 /** --=20 2.20.1