From mboxrd@z Thu Jan 1 00:00:00 1970 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=-9.9 required=3.0 tests=DKIMWL_WL_HIGH,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH, MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED, 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 A267DC17447 for ; Tue, 12 Nov 2019 00:08:04 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 76163222CA for ; Tue, 12 Nov 2019 00:08:04 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=nvidia.com header.i=@nvidia.com header.b="INNX4lb1" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727641AbfKLAHb (ORCPT ); Mon, 11 Nov 2019 19:07:31 -0500 Received: from hqemgate14.nvidia.com ([216.228.121.143]:10782 "EHLO hqemgate14.nvidia.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727625AbfKLAHb (ORCPT ); Mon, 11 Nov 2019 19:07:31 -0500 Received: from hqpgpgate101.nvidia.com (Not Verified[216.228.121.13]) by hqemgate14.nvidia.com (using TLS: TLSv1.2, DES-CBC3-SHA) id ; Mon, 11 Nov 2019 16:07:31 -0800 Received: from hqmail.nvidia.com ([172.20.161.6]) by hqpgpgate101.nvidia.com (PGP Universal service); Mon, 11 Nov 2019 16:07:28 -0800 X-PGP-Universal: processed; by hqpgpgate101.nvidia.com on Mon, 11 Nov 2019 16:07:28 -0800 Received: from HQMAIL111.nvidia.com (172.20.187.18) by HQMAIL101.nvidia.com (172.20.187.10) with Microsoft SMTP Server (TLS) id 15.0.1473.3; Tue, 12 Nov 2019 00:07:27 +0000 Received: from rnnvemgw01.nvidia.com (10.128.109.123) by HQMAIL111.nvidia.com (172.20.187.18) with Microsoft SMTP Server (TLS) id 15.0.1473.3 via Frontend Transport; Tue, 12 Nov 2019 00:07:27 +0000 Received: from blueforge.nvidia.com (Not Verified[10.110.48.28]) by rnnvemgw01.nvidia.com with Trustwave SEG (v7,5,8,10121) id ; Mon, 11 Nov 2019 16:07:26 -0800 From: John Hubbard To: Andrew Morton CC: Al Viro , Alex Williamson , Benjamin Herrenschmidt , =?UTF-8?q?Bj=C3=B6rn=20T=C3=B6pel?= , Christoph Hellwig , Dan Williams , Daniel Vetter , Dave Chinner , David Airlie , "David S . Miller" , Ira Weiny , Jan Kara , Jason Gunthorpe , Jens Axboe , Jonathan Corbet , =?UTF-8?q?J=C3=A9r=C3=B4me=20Glisse?= , Magnus Karlsson , Mauro Carvalho Chehab , Michael Ellerman , Michal Hocko , Mike Kravetz , Paul Mackerras , Shuah Khan , Vlastimil Babka , , , , , , , , , , , , , LKML , John Hubbard Subject: [PATCH v3 21/23] mm/gup_benchmark: support pin_user_pages() and related calls Date: Mon, 11 Nov 2019 16:06:58 -0800 Message-ID: <20191112000700.3455038-22-jhubbard@nvidia.com> X-Mailer: git-send-email 2.24.0 In-Reply-To: <20191112000700.3455038-1-jhubbard@nvidia.com> References: <20191112000700.3455038-1-jhubbard@nvidia.com> MIME-Version: 1.0 X-NVConfidentiality: public Content-Transfer-Encoding: quoted-printable Content-Type: text/plain DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=nvidia.com; s=n1; t=1573517251; bh=qDCGllxYSTERl727bBBMP3MdnPP+9frqWZ2/7CRJeGs=; h=X-PGP-Universal:From:To:CC:Subject:Date:Message-ID:X-Mailer: In-Reply-To:References:MIME-Version:X-NVConfidentiality: Content-Transfer-Encoding:Content-Type; b=INNX4lb1n2kX1v/P9PM7wBHYChSdAomLQDogDbvbn82CeqEinhjAwB1rCxnCP79bt zREEFUMmQJCxmeEBySUGdu/xCEDT0HFsAI0lVm2mu4UVM5uwY4o1GHCLYEIops1Obf FlzPaA6vDkMI3yLspyfIQgVAT4OrKXuKScb28X1Nqyc5NdmMoKxG/PQkR2iKVQv+Aw +SC0FLAusBn+ViWOOqzj/2euAMwTny9EdpRQHffb0IWVB4oARQzUo63stjwjIWqDd5 SaqJJMBgrnY5U/MFSmt1wGulCyueGHwHz28ppbvOY3QsF40pmJd1EN/QKj72wd6aR7 LmrU8E9OoDYnA== Sender: linux-block-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-block@vger.kernel.org Up until now, gup_benchmark supported testing of the following kernel functions: * get_user_pages(): via the '-U' command line option * get_user_pages_longterm(): via the '-L' command line option * get_user_pages_fast(): as the default (no options required) Add test coverage for the new corresponding pin_*() functions: * pin_user_pages(): via the '-c' command line option * pin_longterm_pages(): via the '-b' command line option * pin_user_pages_fast(): via the '-a' command line option Also, add an option for clarity: '-u' for what is now (still) the default choice: get_user_pages_fast(). Also, for the three commands that set FOLL_PIN, verify that the pages really are dma-pinned, via the new is_dma_pinned() routine. Those commands are: PIN_FAST_BENCHMARK : calls pin_user_pages_fast() PIN_LONGTERM_BENCHMARK : calls pin_longterm_pages() PIN_BENCHMARK : calls pin_user_pages() In between the calls to pin_*() and put_user_pages(), check each page: if page_dma_pinned() returns false, then WARN and return. Do this outside of the benchmark timestamps, so that it doesn't affect reported times. Signed-off-by: John Hubbard --- mm/gup_benchmark.c | 73 ++++++++++++++++++++-- tools/testing/selftests/vm/gup_benchmark.c | 23 ++++++- 2 files changed, 90 insertions(+), 6 deletions(-) diff --git a/mm/gup_benchmark.c b/mm/gup_benchmark.c index 7fc44d25eca7..8f980d91dbf5 100644 --- a/mm/gup_benchmark.c +++ b/mm/gup_benchmark.c @@ -8,6 +8,9 @@ #define GUP_FAST_BENCHMARK _IOWR('g', 1, struct gup_benchmark) #define GUP_LONGTERM_BENCHMARK _IOWR('g', 2, struct gup_benchmark) #define GUP_BENCHMARK _IOWR('g', 3, struct gup_benchmark) +#define PIN_FAST_BENCHMARK _IOWR('g', 4, struct gup_benchmark) +#define PIN_LONGTERM_BENCHMARK _IOWR('g', 5, struct gup_benchmark) +#define PIN_BENCHMARK _IOWR('g', 6, struct gup_benchmark) =20 struct gup_benchmark { __u64 get_delta_usec; @@ -19,6 +22,44 @@ struct gup_benchmark { __u64 expansion[10]; /* For future use */ }; =20 +static void put_back_pages(int cmd, struct page **pages, unsigned long nr_= pages) +{ + int i; + + switch (cmd) { + case GUP_FAST_BENCHMARK: + case GUP_LONGTERM_BENCHMARK: + case GUP_BENCHMARK: + for (i =3D 0; i < nr_pages; i++) + put_page(pages[i]); + break; + + case PIN_FAST_BENCHMARK: + case PIN_LONGTERM_BENCHMARK: + case PIN_BENCHMARK: + put_user_pages(pages, nr_pages); + break; + } +} + +static void verify_dma_pinned(int cmd, struct page **pages, + unsigned long nr_pages) +{ + int i; + + switch (cmd) { + case PIN_FAST_BENCHMARK: + case PIN_LONGTERM_BENCHMARK: + case PIN_BENCHMARK: + for (i =3D 0; i < nr_pages; i++) { + if (WARN(!page_dma_pinned(pages[i]), + "pages[%d] is NOT dma-pinned\n", i)) + break; + } + break; + } +} + static int __gup_benchmark_ioctl(unsigned int cmd, struct gup_benchmark *gup) { @@ -65,6 +106,18 @@ static int __gup_benchmark_ioctl(unsigned int cmd, nr =3D get_user_pages(addr, nr, gup->flags, pages + i, NULL); break; + case PIN_FAST_BENCHMARK: + nr =3D pin_user_pages_fast(addr, nr, gup->flags, + pages + i); + break; + case PIN_LONGTERM_BENCHMARK: + nr =3D pin_longterm_pages(addr, nr, gup->flags, pages + i, + NULL); + break; + case PIN_BENCHMARK: + nr =3D pin_user_pages(addr, nr, gup->flags, pages + i, + NULL); + break; default: return -1; } @@ -75,15 +128,22 @@ static int __gup_benchmark_ioctl(unsigned int cmd, } end_time =3D ktime_get(); =20 + /* Shifting the meaning of nr_pages: now it is actual number pinned: */ + nr_pages =3D i; + gup->get_delta_usec =3D ktime_us_delta(end_time, start_time); gup->size =3D addr - gup->addr; =20 + /* + * Take an un-benchmark-timed moment to verify DMA pinned + * state: print a warning if any non-dma-pinned pages are found: + */ + verify_dma_pinned(cmd, pages, nr_pages); + start_time =3D ktime_get(); - for (i =3D 0; i < nr_pages; i++) { - if (!pages[i]) - break; - put_page(pages[i]); - } + + put_back_pages(cmd, pages, nr_pages); + end_time =3D ktime_get(); gup->put_delta_usec =3D ktime_us_delta(end_time, start_time); =20 @@ -101,6 +161,9 @@ static long gup_benchmark_ioctl(struct file *filep, uns= igned int cmd, case GUP_FAST_BENCHMARK: case GUP_LONGTERM_BENCHMARK: case GUP_BENCHMARK: + case PIN_FAST_BENCHMARK: + case PIN_LONGTERM_BENCHMARK: + case PIN_BENCHMARK: break; default: return -EINVAL; diff --git a/tools/testing/selftests/vm/gup_benchmark.c b/tools/testing/sel= ftests/vm/gup_benchmark.c index 389327e9b30a..03928e47a86f 100644 --- a/tools/testing/selftests/vm/gup_benchmark.c +++ b/tools/testing/selftests/vm/gup_benchmark.c @@ -18,6 +18,15 @@ #define GUP_LONGTERM_BENCHMARK _IOWR('g', 2, struct gup_benchmark) #define GUP_BENCHMARK _IOWR('g', 3, struct gup_benchmark) =20 +/* + * Similar to above, but use FOLL_PIN instead of FOLL_GET. This is done + * by calling pin_user_pages_fast(), pin_longterm_pages(), and pin_user_pa= ges(), + * respectively. + */ +#define PIN_FAST_BENCHMARK _IOWR('g', 4, struct gup_benchmark) +#define PIN_LONGTERM_BENCHMARK _IOWR('g', 5, struct gup_benchmark) +#define PIN_BENCHMARK _IOWR('g', 6, struct gup_benchmark) + /* Just the flags we need, copied from mm.h: */ #define FOLL_WRITE 0x01 /* check pte is writable */ =20 @@ -40,8 +49,17 @@ int main(int argc, char **argv) char *file =3D "/dev/zero"; char *p; =20 - while ((opt =3D getopt(argc, argv, "m:r:n:f:tTLUwSH")) !=3D -1) { + while ((opt =3D getopt(argc, argv, "m:r:n:f:abctTLUuwSH")) !=3D -1) { switch (opt) { + case 'a': + cmd =3D PIN_FAST_BENCHMARK; + break; + case 'b': + cmd =3D PIN_LONGTERM_BENCHMARK; + break; + case 'c': + cmd =3D PIN_BENCHMARK; + break; case 'm': size =3D atoi(optarg) * MB; break; @@ -63,6 +81,9 @@ int main(int argc, char **argv) case 'U': cmd =3D GUP_BENCHMARK; break; + case 'u': + cmd =3D GUP_FAST_BENCHMARK; + break; case 'w': write =3D 1; break; --=20 2.24.0 From mboxrd@z Thu Jan 1 00:00:00 1970 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=-9.6 required=3.0 tests=DKIM_INVALID,DKIM_SIGNED, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY, SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,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 12770C43331 for ; Tue, 12 Nov 2019 00:55:26 +0000 (UTC) Received: from lists.ozlabs.org (lists.ozlabs.org [203.11.71.2]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id B54A621925 for ; Tue, 12 Nov 2019 00:55:25 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=fail reason="signature verification failed" (2048-bit key) header.d=nvidia.com header.i=@nvidia.com header.b="INNX4lb1" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org B54A621925 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=nvidia.com Authentication-Results: mail.kernel.org; spf=pass smtp.mailfrom=linuxppc-dev-bounces+linuxppc-dev=archiver.kernel.org@lists.ozlabs.org Received: from bilbo.ozlabs.org (lists.ozlabs.org [IPv6:2401:3900:2:1::3]) by lists.ozlabs.org (Postfix) with ESMTP id 47Bq6L4lcdzF4Hd for ; Tue, 12 Nov 2019 11:55:22 +1100 (AEDT) Authentication-Results: lists.ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=nvidia.com (client-ip=216.228.121.143; helo=hqemgate14.nvidia.com; envelope-from=jhubbard@nvidia.com; receiver=) Authentication-Results: lists.ozlabs.org; dmarc=pass (p=none dis=none) header.from=nvidia.com Authentication-Results: lists.ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=nvidia.com header.i=@nvidia.com header.b="INNX4lb1"; dkim-atps=neutral Received: from hqemgate14.nvidia.com (hqemgate14.nvidia.com [216.228.121.143]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by lists.ozlabs.org (Postfix) with ESMTPS id 47Bp3B4FzHzF4Ly for ; Tue, 12 Nov 2019 11:07:33 +1100 (AEDT) Received: from hqpgpgate101.nvidia.com (Not Verified[216.228.121.13]) by hqemgate14.nvidia.com (using TLS: TLSv1.2, DES-CBC3-SHA) id ; Mon, 11 Nov 2019 16:07:31 -0800 Received: from hqmail.nvidia.com ([172.20.161.6]) by hqpgpgate101.nvidia.com (PGP Universal service); Mon, 11 Nov 2019 16:07:28 -0800 X-PGP-Universal: processed; by hqpgpgate101.nvidia.com on Mon, 11 Nov 2019 16:07:28 -0800 Received: from HQMAIL111.nvidia.com (172.20.187.18) by HQMAIL101.nvidia.com (172.20.187.10) with Microsoft SMTP Server (TLS) id 15.0.1473.3; Tue, 12 Nov 2019 00:07:27 +0000 Received: from rnnvemgw01.nvidia.com (10.128.109.123) by HQMAIL111.nvidia.com (172.20.187.18) with Microsoft SMTP Server (TLS) id 15.0.1473.3 via Frontend Transport; Tue, 12 Nov 2019 00:07:27 +0000 Received: from blueforge.nvidia.com (Not Verified[10.110.48.28]) by rnnvemgw01.nvidia.com with Trustwave SEG (v7, 5, 8, 10121) id ; Mon, 11 Nov 2019 16:07:26 -0800 From: John Hubbard To: Andrew Morton Subject: [PATCH v3 21/23] mm/gup_benchmark: support pin_user_pages() and related calls Date: Mon, 11 Nov 2019 16:06:58 -0800 Message-ID: <20191112000700.3455038-22-jhubbard@nvidia.com> X-Mailer: git-send-email 2.24.0 In-Reply-To: <20191112000700.3455038-1-jhubbard@nvidia.com> References: <20191112000700.3455038-1-jhubbard@nvidia.com> MIME-Version: 1.0 X-NVConfidentiality: public Content-Transfer-Encoding: quoted-printable Content-Type: text/plain DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=nvidia.com; s=n1; t=1573517251; bh=qDCGllxYSTERl727bBBMP3MdnPP+9frqWZ2/7CRJeGs=; h=X-PGP-Universal:From:To:CC:Subject:Date:Message-ID:X-Mailer: In-Reply-To:References:MIME-Version:X-NVConfidentiality: Content-Transfer-Encoding:Content-Type; b=INNX4lb1n2kX1v/P9PM7wBHYChSdAomLQDogDbvbn82CeqEinhjAwB1rCxnCP79bt zREEFUMmQJCxmeEBySUGdu/xCEDT0HFsAI0lVm2mu4UVM5uwY4o1GHCLYEIops1Obf FlzPaA6vDkMI3yLspyfIQgVAT4OrKXuKScb28X1Nqyc5NdmMoKxG/PQkR2iKVQv+Aw +SC0FLAusBn+ViWOOqzj/2euAMwTny9EdpRQHffb0IWVB4oARQzUo63stjwjIWqDd5 SaqJJMBgrnY5U/MFSmt1wGulCyueGHwHz28ppbvOY3QsF40pmJd1EN/QKj72wd6aR7 LmrU8E9OoDYnA== X-BeenThere: linuxppc-dev@lists.ozlabs.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Linux on PowerPC Developers Mail List List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Michal Hocko , Jan Kara , kvm@vger.kernel.org, linux-doc@vger.kernel.org, David Airlie , Dave Chinner , dri-devel@lists.freedesktop.org, LKML , linux-mm@kvack.org, Paul Mackerras , linux-kselftest@vger.kernel.org, Ira Weiny , Jonathan Corbet , linux-rdma@vger.kernel.org, Christoph Hellwig , Jason Gunthorpe , Vlastimil Babka , =?UTF-8?q?Bj=C3=B6rn=20T=C3=B6pel?= , linux-media@vger.kernel.org, Shuah Khan , John Hubbard , linux-block@vger.kernel.org, =?UTF-8?q?J=C3=A9r=C3=B4me=20Glisse?= , Al Viro , Dan Williams , Mauro Carvalho Chehab , Magnus Karlsson , Jens Axboe , netdev@vger.kernel.org, Alex Williamson , Daniel Vetter , linux-fsdevel@vger.kernel.org, bpf@vger.kernel.org, linuxppc-dev@lists.ozlabs.org, "David S . Miller" , Mike Kravetz Errors-To: linuxppc-dev-bounces+linuxppc-dev=archiver.kernel.org@lists.ozlabs.org Sender: "Linuxppc-dev" Up until now, gup_benchmark supported testing of the following kernel functions: * get_user_pages(): via the '-U' command line option * get_user_pages_longterm(): via the '-L' command line option * get_user_pages_fast(): as the default (no options required) Add test coverage for the new corresponding pin_*() functions: * pin_user_pages(): via the '-c' command line option * pin_longterm_pages(): via the '-b' command line option * pin_user_pages_fast(): via the '-a' command line option Also, add an option for clarity: '-u' for what is now (still) the default choice: get_user_pages_fast(). Also, for the three commands that set FOLL_PIN, verify that the pages really are dma-pinned, via the new is_dma_pinned() routine. Those commands are: PIN_FAST_BENCHMARK : calls pin_user_pages_fast() PIN_LONGTERM_BENCHMARK : calls pin_longterm_pages() PIN_BENCHMARK : calls pin_user_pages() In between the calls to pin_*() and put_user_pages(), check each page: if page_dma_pinned() returns false, then WARN and return. Do this outside of the benchmark timestamps, so that it doesn't affect reported times. Signed-off-by: John Hubbard --- mm/gup_benchmark.c | 73 ++++++++++++++++++++-- tools/testing/selftests/vm/gup_benchmark.c | 23 ++++++- 2 files changed, 90 insertions(+), 6 deletions(-) diff --git a/mm/gup_benchmark.c b/mm/gup_benchmark.c index 7fc44d25eca7..8f980d91dbf5 100644 --- a/mm/gup_benchmark.c +++ b/mm/gup_benchmark.c @@ -8,6 +8,9 @@ #define GUP_FAST_BENCHMARK _IOWR('g', 1, struct gup_benchmark) #define GUP_LONGTERM_BENCHMARK _IOWR('g', 2, struct gup_benchmark) #define GUP_BENCHMARK _IOWR('g', 3, struct gup_benchmark) +#define PIN_FAST_BENCHMARK _IOWR('g', 4, struct gup_benchmark) +#define PIN_LONGTERM_BENCHMARK _IOWR('g', 5, struct gup_benchmark) +#define PIN_BENCHMARK _IOWR('g', 6, struct gup_benchmark) =20 struct gup_benchmark { __u64 get_delta_usec; @@ -19,6 +22,44 @@ struct gup_benchmark { __u64 expansion[10]; /* For future use */ }; =20 +static void put_back_pages(int cmd, struct page **pages, unsigned long nr_= pages) +{ + int i; + + switch (cmd) { + case GUP_FAST_BENCHMARK: + case GUP_LONGTERM_BENCHMARK: + case GUP_BENCHMARK: + for (i =3D 0; i < nr_pages; i++) + put_page(pages[i]); + break; + + case PIN_FAST_BENCHMARK: + case PIN_LONGTERM_BENCHMARK: + case PIN_BENCHMARK: + put_user_pages(pages, nr_pages); + break; + } +} + +static void verify_dma_pinned(int cmd, struct page **pages, + unsigned long nr_pages) +{ + int i; + + switch (cmd) { + case PIN_FAST_BENCHMARK: + case PIN_LONGTERM_BENCHMARK: + case PIN_BENCHMARK: + for (i =3D 0; i < nr_pages; i++) { + if (WARN(!page_dma_pinned(pages[i]), + "pages[%d] is NOT dma-pinned\n", i)) + break; + } + break; + } +} + static int __gup_benchmark_ioctl(unsigned int cmd, struct gup_benchmark *gup) { @@ -65,6 +106,18 @@ static int __gup_benchmark_ioctl(unsigned int cmd, nr =3D get_user_pages(addr, nr, gup->flags, pages + i, NULL); break; + case PIN_FAST_BENCHMARK: + nr =3D pin_user_pages_fast(addr, nr, gup->flags, + pages + i); + break; + case PIN_LONGTERM_BENCHMARK: + nr =3D pin_longterm_pages(addr, nr, gup->flags, pages + i, + NULL); + break; + case PIN_BENCHMARK: + nr =3D pin_user_pages(addr, nr, gup->flags, pages + i, + NULL); + break; default: return -1; } @@ -75,15 +128,22 @@ static int __gup_benchmark_ioctl(unsigned int cmd, } end_time =3D ktime_get(); =20 + /* Shifting the meaning of nr_pages: now it is actual number pinned: */ + nr_pages =3D i; + gup->get_delta_usec =3D ktime_us_delta(end_time, start_time); gup->size =3D addr - gup->addr; =20 + /* + * Take an un-benchmark-timed moment to verify DMA pinned + * state: print a warning if any non-dma-pinned pages are found: + */ + verify_dma_pinned(cmd, pages, nr_pages); + start_time =3D ktime_get(); - for (i =3D 0; i < nr_pages; i++) { - if (!pages[i]) - break; - put_page(pages[i]); - } + + put_back_pages(cmd, pages, nr_pages); + end_time =3D ktime_get(); gup->put_delta_usec =3D ktime_us_delta(end_time, start_time); =20 @@ -101,6 +161,9 @@ static long gup_benchmark_ioctl(struct file *filep, uns= igned int cmd, case GUP_FAST_BENCHMARK: case GUP_LONGTERM_BENCHMARK: case GUP_BENCHMARK: + case PIN_FAST_BENCHMARK: + case PIN_LONGTERM_BENCHMARK: + case PIN_BENCHMARK: break; default: return -EINVAL; diff --git a/tools/testing/selftests/vm/gup_benchmark.c b/tools/testing/sel= ftests/vm/gup_benchmark.c index 389327e9b30a..03928e47a86f 100644 --- a/tools/testing/selftests/vm/gup_benchmark.c +++ b/tools/testing/selftests/vm/gup_benchmark.c @@ -18,6 +18,15 @@ #define GUP_LONGTERM_BENCHMARK _IOWR('g', 2, struct gup_benchmark) #define GUP_BENCHMARK _IOWR('g', 3, struct gup_benchmark) =20 +/* + * Similar to above, but use FOLL_PIN instead of FOLL_GET. This is done + * by calling pin_user_pages_fast(), pin_longterm_pages(), and pin_user_pa= ges(), + * respectively. + */ +#define PIN_FAST_BENCHMARK _IOWR('g', 4, struct gup_benchmark) +#define PIN_LONGTERM_BENCHMARK _IOWR('g', 5, struct gup_benchmark) +#define PIN_BENCHMARK _IOWR('g', 6, struct gup_benchmark) + /* Just the flags we need, copied from mm.h: */ #define FOLL_WRITE 0x01 /* check pte is writable */ =20 @@ -40,8 +49,17 @@ int main(int argc, char **argv) char *file =3D "/dev/zero"; char *p; =20 - while ((opt =3D getopt(argc, argv, "m:r:n:f:tTLUwSH")) !=3D -1) { + while ((opt =3D getopt(argc, argv, "m:r:n:f:abctTLUuwSH")) !=3D -1) { switch (opt) { + case 'a': + cmd =3D PIN_FAST_BENCHMARK; + break; + case 'b': + cmd =3D PIN_LONGTERM_BENCHMARK; + break; + case 'c': + cmd =3D PIN_BENCHMARK; + break; case 'm': size =3D atoi(optarg) * MB; break; @@ -63,6 +81,9 @@ int main(int argc, char **argv) case 'U': cmd =3D GUP_BENCHMARK; break; + case 'u': + cmd =3D GUP_FAST_BENCHMARK; + break; case 'w': write =3D 1; break; --=20 2.24.0 From mboxrd@z Thu Jan 1 00:00:00 1970 From: John Hubbard Subject: [PATCH v3 21/23] mm/gup_benchmark: support pin_user_pages() and related calls Date: Mon, 11 Nov 2019 16:06:58 -0800 Message-ID: <20191112000700.3455038-22-jhubbard@nvidia.com> References: <20191112000700.3455038-1-jhubbard@nvidia.com> Mime-Version: 1.0 Content-Type: text/plain Content-Transfer-Encoding: quoted-printable Return-path: In-Reply-To: <20191112000700.3455038-1-jhubbard@nvidia.com> Sender: linux-kernel-owner@vger.kernel.org To: Andrew Morton Cc: Al Viro , Alex Williamson , Benjamin Herrenschmidt , =?UTF-8?q?Bj=C3=B6rn=20T=C3=B6pel?= , Christoph Hellwig , Dan Williams , Daniel Vetter , Dave Chinner , David Airlie , "David S . Miller" , Ira Weiny , Jan Kara , Jason Gunthorpe , Jens Axboe , Jonathan Corbet , =?UTF-8?q?J=C3=A9r=C3=B4me=20Glisse?= , Magnus Karlsson , Mauro Carvalho Chehab , Michael Ellerman M List-Id: dri-devel@lists.freedesktop.org Up until now, gup_benchmark supported testing of the following kernel functions: * get_user_pages(): via the '-U' command line option * get_user_pages_longterm(): via the '-L' command line option * get_user_pages_fast(): as the default (no options required) Add test coverage for the new corresponding pin_*() functions: * pin_user_pages(): via the '-c' command line option * pin_longterm_pages(): via the '-b' command line option * pin_user_pages_fast(): via the '-a' command line option Also, add an option for clarity: '-u' for what is now (still) the default choice: get_user_pages_fast(). Also, for the three commands that set FOLL_PIN, verify that the pages really are dma-pinned, via the new is_dma_pinned() routine. Those commands are: PIN_FAST_BENCHMARK : calls pin_user_pages_fast() PIN_LONGTERM_BENCHMARK : calls pin_longterm_pages() PIN_BENCHMARK : calls pin_user_pages() In between the calls to pin_*() and put_user_pages(), check each page: if page_dma_pinned() returns false, then WARN and return. Do this outside of the benchmark timestamps, so that it doesn't affect reported times. Signed-off-by: John Hubbard --- mm/gup_benchmark.c | 73 ++++++++++++++++++++-- tools/testing/selftests/vm/gup_benchmark.c | 23 ++++++- 2 files changed, 90 insertions(+), 6 deletions(-) diff --git a/mm/gup_benchmark.c b/mm/gup_benchmark.c index 7fc44d25eca7..8f980d91dbf5 100644 --- a/mm/gup_benchmark.c +++ b/mm/gup_benchmark.c @@ -8,6 +8,9 @@ #define GUP_FAST_BENCHMARK _IOWR('g', 1, struct gup_benchmark) #define GUP_LONGTERM_BENCHMARK _IOWR('g', 2, struct gup_benchmark) #define GUP_BENCHMARK _IOWR('g', 3, struct gup_benchmark) +#define PIN_FAST_BENCHMARK _IOWR('g', 4, struct gup_benchmark) +#define PIN_LONGTERM_BENCHMARK _IOWR('g', 5, struct gup_benchmark) +#define PIN_BENCHMARK _IOWR('g', 6, struct gup_benchmark) =20 struct gup_benchmark { __u64 get_delta_usec; @@ -19,6 +22,44 @@ struct gup_benchmark { __u64 expansion[10]; /* For future use */ }; =20 +static void put_back_pages(int cmd, struct page **pages, unsigned long nr_= pages) +{ + int i; + + switch (cmd) { + case GUP_FAST_BENCHMARK: + case GUP_LONGTERM_BENCHMARK: + case GUP_BENCHMARK: + for (i =3D 0; i < nr_pages; i++) + put_page(pages[i]); + break; + + case PIN_FAST_BENCHMARK: + case PIN_LONGTERM_BENCHMARK: + case PIN_BENCHMARK: + put_user_pages(pages, nr_pages); + break; + } +} + +static void verify_dma_pinned(int cmd, struct page **pages, + unsigned long nr_pages) +{ + int i; + + switch (cmd) { + case PIN_FAST_BENCHMARK: + case PIN_LONGTERM_BENCHMARK: + case PIN_BENCHMARK: + for (i =3D 0; i < nr_pages; i++) { + if (WARN(!page_dma_pinned(pages[i]), + "pages[%d] is NOT dma-pinned\n", i)) + break; + } + break; + } +} + static int __gup_benchmark_ioctl(unsigned int cmd, struct gup_benchmark *gup) { @@ -65,6 +106,18 @@ static int __gup_benchmark_ioctl(unsigned int cmd, nr =3D get_user_pages(addr, nr, gup->flags, pages + i, NULL); break; + case PIN_FAST_BENCHMARK: + nr =3D pin_user_pages_fast(addr, nr, gup->flags, + pages + i); + break; + case PIN_LONGTERM_BENCHMARK: + nr =3D pin_longterm_pages(addr, nr, gup->flags, pages + i, + NULL); + break; + case PIN_BENCHMARK: + nr =3D pin_user_pages(addr, nr, gup->flags, pages + i, + NULL); + break; default: return -1; } @@ -75,15 +128,22 @@ static int __gup_benchmark_ioctl(unsigned int cmd, } end_time =3D ktime_get(); =20 + /* Shifting the meaning of nr_pages: now it is actual number pinned: */ + nr_pages =3D i; + gup->get_delta_usec =3D ktime_us_delta(end_time, start_time); gup->size =3D addr - gup->addr; =20 + /* + * Take an un-benchmark-timed moment to verify DMA pinned + * state: print a warning if any non-dma-pinned pages are found: + */ + verify_dma_pinned(cmd, pages, nr_pages); + start_time =3D ktime_get(); - for (i =3D 0; i < nr_pages; i++) { - if (!pages[i]) - break; - put_page(pages[i]); - } + + put_back_pages(cmd, pages, nr_pages); + end_time =3D ktime_get(); gup->put_delta_usec =3D ktime_us_delta(end_time, start_time); =20 @@ -101,6 +161,9 @@ static long gup_benchmark_ioctl(struct file *filep, uns= igned int cmd, case GUP_FAST_BENCHMARK: case GUP_LONGTERM_BENCHMARK: case GUP_BENCHMARK: + case PIN_FAST_BENCHMARK: + case PIN_LONGTERM_BENCHMARK: + case PIN_BENCHMARK: break; default: return -EINVAL; diff --git a/tools/testing/selftests/vm/gup_benchmark.c b/tools/testing/sel= ftests/vm/gup_benchmark.c index 389327e9b30a..03928e47a86f 100644 --- a/tools/testing/selftests/vm/gup_benchmark.c +++ b/tools/testing/selftests/vm/gup_benchmark.c @@ -18,6 +18,15 @@ #define GUP_LONGTERM_BENCHMARK _IOWR('g', 2, struct gup_benchmark) #define GUP_BENCHMARK _IOWR('g', 3, struct gup_benchmark) =20 +/* + * Similar to above, but use FOLL_PIN instead of FOLL_GET. This is done + * by calling pin_user_pages_fast(), pin_longterm_pages(), and pin_user_pa= ges(), + * respectively. + */ +#define PIN_FAST_BENCHMARK _IOWR('g', 4, struct gup_benchmark) +#define PIN_LONGTERM_BENCHMARK _IOWR('g', 5, struct gup_benchmark) +#define PIN_BENCHMARK _IOWR('g', 6, struct gup_benchmark) + /* Just the flags we need, copied from mm.h: */ #define FOLL_WRITE 0x01 /* check pte is writable */ =20 @@ -40,8 +49,17 @@ int main(int argc, char **argv) char *file =3D "/dev/zero"; char *p; =20 - while ((opt =3D getopt(argc, argv, "m:r:n:f:tTLUwSH")) !=3D -1) { + while ((opt =3D getopt(argc, argv, "m:r:n:f:abctTLUuwSH")) !=3D -1) { switch (opt) { + case 'a': + cmd =3D PIN_FAST_BENCHMARK; + break; + case 'b': + cmd =3D PIN_LONGTERM_BENCHMARK; + break; + case 'c': + cmd =3D PIN_BENCHMARK; + break; case 'm': size =3D atoi(optarg) * MB; break; @@ -63,6 +81,9 @@ int main(int argc, char **argv) case 'U': cmd =3D GUP_BENCHMARK; break; + case 'u': + cmd =3D GUP_FAST_BENCHMARK; + break; case 'w': write =3D 1; break; --=20 2.24.0 From mboxrd@z Thu Jan 1 00:00:00 1970 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=-9.8 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,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 06269C17447 for ; Tue, 12 Nov 2019 00:08:04 +0000 (UTC) Received: from gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id D882721872 for ; Tue, 12 Nov 2019 00:08:03 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org D882721872 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=nvidia.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=dri-devel-bounces@lists.freedesktop.org Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id 56A716EA12; Tue, 12 Nov 2019 00:07:41 +0000 (UTC) Received: from hqemgate14.nvidia.com (hqemgate14.nvidia.com [216.228.121.143]) by gabe.freedesktop.org (Postfix) with ESMTPS id B2ADB8966B for ; Tue, 12 Nov 2019 00:07:28 +0000 (UTC) Received: from hqpgpgate101.nvidia.com (Not Verified[216.228.121.13]) by hqemgate14.nvidia.com (using TLS: TLSv1.2, DES-CBC3-SHA) id ; Mon, 11 Nov 2019 16:07:31 -0800 Received: from hqmail.nvidia.com ([172.20.161.6]) by hqpgpgate101.nvidia.com (PGP Universal service); Mon, 11 Nov 2019 16:07:28 -0800 X-PGP-Universal: processed; by hqpgpgate101.nvidia.com on Mon, 11 Nov 2019 16:07:28 -0800 Received: from HQMAIL111.nvidia.com (172.20.187.18) by HQMAIL101.nvidia.com (172.20.187.10) with Microsoft SMTP Server (TLS) id 15.0.1473.3; Tue, 12 Nov 2019 00:07:27 +0000 Received: from rnnvemgw01.nvidia.com (10.128.109.123) by HQMAIL111.nvidia.com (172.20.187.18) with Microsoft SMTP Server (TLS) id 15.0.1473.3 via Frontend Transport; Tue, 12 Nov 2019 00:07:27 +0000 Received: from blueforge.nvidia.com (Not Verified[10.110.48.28]) by rnnvemgw01.nvidia.com with Trustwave SEG (v7, 5, 8, 10121) id ; Mon, 11 Nov 2019 16:07:26 -0800 From: John Hubbard To: Andrew Morton Subject: [PATCH v3 21/23] mm/gup_benchmark: support pin_user_pages() and related calls Date: Mon, 11 Nov 2019 16:06:58 -0800 Message-ID: <20191112000700.3455038-22-jhubbard@nvidia.com> X-Mailer: git-send-email 2.24.0 In-Reply-To: <20191112000700.3455038-1-jhubbard@nvidia.com> References: <20191112000700.3455038-1-jhubbard@nvidia.com> MIME-Version: 1.0 X-NVConfidentiality: public X-Mailman-Original-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=nvidia.com; s=n1; t=1573517251; bh=qDCGllxYSTERl727bBBMP3MdnPP+9frqWZ2/7CRJeGs=; h=X-PGP-Universal:From:To:CC:Subject:Date:Message-ID:X-Mailer: In-Reply-To:References:MIME-Version:X-NVConfidentiality: Content-Transfer-Encoding:Content-Type; b=INNX4lb1n2kX1v/P9PM7wBHYChSdAomLQDogDbvbn82CeqEinhjAwB1rCxnCP79bt zREEFUMmQJCxmeEBySUGdu/xCEDT0HFsAI0lVm2mu4UVM5uwY4o1GHCLYEIops1Obf FlzPaA6vDkMI3yLspyfIQgVAT4OrKXuKScb28X1Nqyc5NdmMoKxG/PQkR2iKVQv+Aw +SC0FLAusBn+ViWOOqzj/2euAMwTny9EdpRQHffb0IWVB4oARQzUo63stjwjIWqDd5 SaqJJMBgrnY5U/MFSmt1wGulCyueGHwHz28ppbvOY3QsF40pmJd1EN/QKj72wd6aR7 LmrU8E9OoDYnA== X-BeenThere: dri-devel@lists.freedesktop.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: Direct Rendering Infrastructure - Development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Michal Hocko , Jan Kara , kvm@vger.kernel.org, linux-doc@vger.kernel.org, David Airlie , Dave Chinner , dri-devel@lists.freedesktop.org, LKML , linux-mm@kvack.org, Paul Mackerras , linux-kselftest@vger.kernel.org, Ira Weiny , Jonathan Corbet , linux-rdma@vger.kernel.org, Michael Ellerman , Christoph Hellwig , Jason Gunthorpe , Vlastimil Babka , =?UTF-8?q?Bj=C3=B6rn=20T=C3=B6pel?= , linux-media@vger.kernel.org, Shuah Khan , John Hubbard , linux-block@vger.kernel.org, =?UTF-8?q?J=C3=A9r=C3=B4me=20Glisse?= , Al Viro , Dan Williams , Mauro Carvalho Chehab , Magnus Karlsson , Jens Axboe , netdev@vger.kernel.org, Alex Williamson , linux-fsdevel@vger.kernel.org, bpf@vger.kernel.org, linuxppc-dev@lists.ozlabs.org, "David S . Miller" , Mike Kravetz Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" Message-ID: <20191112000658.YhHjOAdYiV_I9RINEtbpq52qiPhEcuDxcBQlV-Cadl4@z> VXAgdW50aWwgbm93LCBndXBfYmVuY2htYXJrIHN1cHBvcnRlZCB0ZXN0aW5nIG9mIHRoZQpmb2xs b3dpbmcga2VybmVsIGZ1bmN0aW9uczoKCiogZ2V0X3VzZXJfcGFnZXMoKTogdmlhIHRoZSAnLVUn IGNvbW1hbmQgbGluZSBvcHRpb24KKiBnZXRfdXNlcl9wYWdlc19sb25ndGVybSgpOiB2aWEgdGhl ICctTCcgY29tbWFuZCBsaW5lIG9wdGlvbgoqIGdldF91c2VyX3BhZ2VzX2Zhc3QoKTogYXMgdGhl IGRlZmF1bHQgKG5vIG9wdGlvbnMgcmVxdWlyZWQpCgpBZGQgdGVzdCBjb3ZlcmFnZSBmb3IgdGhl IG5ldyBjb3JyZXNwb25kaW5nIHBpbl8qKCkgZnVuY3Rpb25zOgoKKiBwaW5fdXNlcl9wYWdlcygp OiB2aWEgdGhlICctYycgY29tbWFuZCBsaW5lIG9wdGlvbgoqIHBpbl9sb25ndGVybV9wYWdlcygp OiB2aWEgdGhlICctYicgY29tbWFuZCBsaW5lIG9wdGlvbgoqIHBpbl91c2VyX3BhZ2VzX2Zhc3Qo KTogdmlhIHRoZSAnLWEnIGNvbW1hbmQgbGluZSBvcHRpb24KCkFsc28sIGFkZCBhbiBvcHRpb24g Zm9yIGNsYXJpdHk6ICctdScgZm9yIHdoYXQgaXMgbm93IChzdGlsbCkgdGhlCmRlZmF1bHQgY2hv aWNlOiBnZXRfdXNlcl9wYWdlc19mYXN0KCkuCgpBbHNvLCBmb3IgdGhlIHRocmVlIGNvbW1hbmRz IHRoYXQgc2V0IEZPTExfUElOLCB2ZXJpZnkgdGhhdCB0aGUgcGFnZXMKcmVhbGx5IGFyZSBkbWEt cGlubmVkLCB2aWEgdGhlIG5ldyBpc19kbWFfcGlubmVkKCkgcm91dGluZS4KVGhvc2UgY29tbWFu ZHMgYXJlOgoKICAgIFBJTl9GQVNUX0JFTkNITUFSSyAgICAgOiBjYWxscyBwaW5fdXNlcl9wYWdl c19mYXN0KCkKICAgIFBJTl9MT05HVEVSTV9CRU5DSE1BUksgOiBjYWxscyBwaW5fbG9uZ3Rlcm1f cGFnZXMoKQogICAgUElOX0JFTkNITUFSSyAgICAgICAgICA6IGNhbGxzIHBpbl91c2VyX3BhZ2Vz KCkKCkluIGJldHdlZW4gdGhlIGNhbGxzIHRvIHBpbl8qKCkgYW5kIHB1dF91c2VyX3BhZ2VzKCks CmNoZWNrIGVhY2ggcGFnZTogaWYgcGFnZV9kbWFfcGlubmVkKCkgcmV0dXJucyBmYWxzZSwgdGhl bgpXQVJOIGFuZCByZXR1cm4uCgpEbyB0aGlzIG91dHNpZGUgb2YgdGhlIGJlbmNobWFyayB0aW1l c3RhbXBzLCBzbyB0aGF0IGl0IGRvZXNuJ3QKYWZmZWN0IHJlcG9ydGVkIHRpbWVzLgoKU2lnbmVk LW9mZi1ieTogSm9obiBIdWJiYXJkIDxqaHViYmFyZEBudmlkaWEuY29tPgotLS0KIG1tL2d1cF9i ZW5jaG1hcmsuYyAgICAgICAgICAgICAgICAgICAgICAgICB8IDczICsrKysrKysrKysrKysrKysr KysrLS0KIHRvb2xzL3Rlc3Rpbmcvc2VsZnRlc3RzL3ZtL2d1cF9iZW5jaG1hcmsuYyB8IDIzICsr KysrKy0KIDIgZmlsZXMgY2hhbmdlZCwgOTAgaW5zZXJ0aW9ucygrKSwgNiBkZWxldGlvbnMoLSkK CmRpZmYgLS1naXQgYS9tbS9ndXBfYmVuY2htYXJrLmMgYi9tbS9ndXBfYmVuY2htYXJrLmMKaW5k ZXggN2ZjNDRkMjVlY2E3Li44Zjk4MGQ5MWRiZjUgMTAwNjQ0Ci0tLSBhL21tL2d1cF9iZW5jaG1h cmsuYworKysgYi9tbS9ndXBfYmVuY2htYXJrLmMKQEAgLTgsNiArOCw5IEBACiAjZGVmaW5lIEdV UF9GQVNUX0JFTkNITUFSSwlfSU9XUignZycsIDEsIHN0cnVjdCBndXBfYmVuY2htYXJrKQogI2Rl ZmluZSBHVVBfTE9OR1RFUk1fQkVOQ0hNQVJLCV9JT1dSKCdnJywgMiwgc3RydWN0IGd1cF9iZW5j aG1hcmspCiAjZGVmaW5lIEdVUF9CRU5DSE1BUksJCV9JT1dSKCdnJywgMywgc3RydWN0IGd1cF9i ZW5jaG1hcmspCisjZGVmaW5lIFBJTl9GQVNUX0JFTkNITUFSSwlfSU9XUignZycsIDQsIHN0cnVj dCBndXBfYmVuY2htYXJrKQorI2RlZmluZSBQSU5fTE9OR1RFUk1fQkVOQ0hNQVJLCV9JT1dSKCdn JywgNSwgc3RydWN0IGd1cF9iZW5jaG1hcmspCisjZGVmaW5lIFBJTl9CRU5DSE1BUksJCV9JT1dS KCdnJywgNiwgc3RydWN0IGd1cF9iZW5jaG1hcmspCiAKIHN0cnVjdCBndXBfYmVuY2htYXJrIHsK IAlfX3U2NCBnZXRfZGVsdGFfdXNlYzsKQEAgLTE5LDYgKzIyLDQ0IEBAIHN0cnVjdCBndXBfYmVu Y2htYXJrIHsKIAlfX3U2NCBleHBhbnNpb25bMTBdOwkvKiBGb3IgZnV0dXJlIHVzZSAqLwogfTsK IAorc3RhdGljIHZvaWQgcHV0X2JhY2tfcGFnZXMoaW50IGNtZCwgc3RydWN0IHBhZ2UgKipwYWdl cywgdW5zaWduZWQgbG9uZyBucl9wYWdlcykKK3sKKwlpbnQgaTsKKworCXN3aXRjaCAoY21kKSB7 CisJY2FzZSBHVVBfRkFTVF9CRU5DSE1BUks6CisJY2FzZSBHVVBfTE9OR1RFUk1fQkVOQ0hNQVJL OgorCWNhc2UgR1VQX0JFTkNITUFSSzoKKwkJZm9yIChpID0gMDsgaSA8IG5yX3BhZ2VzOyBpKysp CisJCQlwdXRfcGFnZShwYWdlc1tpXSk7CisJCWJyZWFrOworCisJY2FzZSBQSU5fRkFTVF9CRU5D SE1BUks6CisJY2FzZSBQSU5fTE9OR1RFUk1fQkVOQ0hNQVJLOgorCWNhc2UgUElOX0JFTkNITUFS SzoKKwkJcHV0X3VzZXJfcGFnZXMocGFnZXMsIG5yX3BhZ2VzKTsKKwkJYnJlYWs7CisJfQorfQor CitzdGF0aWMgdm9pZCB2ZXJpZnlfZG1hX3Bpbm5lZChpbnQgY21kLCBzdHJ1Y3QgcGFnZSAqKnBh Z2VzLAorCQkJICAgICAgdW5zaWduZWQgbG9uZyBucl9wYWdlcykKK3sKKwlpbnQgaTsKKworCXN3 aXRjaCAoY21kKSB7CisJY2FzZSBQSU5fRkFTVF9CRU5DSE1BUks6CisJY2FzZSBQSU5fTE9OR1RF Uk1fQkVOQ0hNQVJLOgorCWNhc2UgUElOX0JFTkNITUFSSzoKKwkJZm9yIChpID0gMDsgaSA8IG5y X3BhZ2VzOyBpKyspIHsKKwkJCWlmIChXQVJOKCFwYWdlX2RtYV9waW5uZWQocGFnZXNbaV0pLAor CQkJCSAicGFnZXNbJWRdIGlzIE5PVCBkbWEtcGlubmVkXG4iLCBpKSkKKwkJCQlicmVhazsKKwkJ fQorCQlicmVhazsKKwl9Cit9CisKIHN0YXRpYyBpbnQgX19ndXBfYmVuY2htYXJrX2lvY3RsKHVu c2lnbmVkIGludCBjbWQsCiAJCXN0cnVjdCBndXBfYmVuY2htYXJrICpndXApCiB7CkBAIC02NSw2 ICsxMDYsMTggQEAgc3RhdGljIGludCBfX2d1cF9iZW5jaG1hcmtfaW9jdGwodW5zaWduZWQgaW50 IGNtZCwKIAkJCW5yID0gZ2V0X3VzZXJfcGFnZXMoYWRkciwgbnIsIGd1cC0+ZmxhZ3MsIHBhZ2Vz ICsgaSwKIAkJCQkJICAgIE5VTEwpOwogCQkJYnJlYWs7CisJCWNhc2UgUElOX0ZBU1RfQkVOQ0hN QVJLOgorCQkJbnIgPSBwaW5fdXNlcl9wYWdlc19mYXN0KGFkZHIsIG5yLCBndXAtPmZsYWdzLAor CQkJCQkJIHBhZ2VzICsgaSk7CisJCQlicmVhazsKKwkJY2FzZSBQSU5fTE9OR1RFUk1fQkVOQ0hN QVJLOgorCQkJbnIgPSBwaW5fbG9uZ3Rlcm1fcGFnZXMoYWRkciwgbnIsIGd1cC0+ZmxhZ3MsIHBh Z2VzICsgaSwKKwkJCQkJCU5VTEwpOworCQkJYnJlYWs7CisJCWNhc2UgUElOX0JFTkNITUFSSzoK KwkJCW5yID0gcGluX3VzZXJfcGFnZXMoYWRkciwgbnIsIGd1cC0+ZmxhZ3MsIHBhZ2VzICsgaSwK KwkJCQkJICAgIE5VTEwpOworCQkJYnJlYWs7CiAJCWRlZmF1bHQ6CiAJCQlyZXR1cm4gLTE7CiAJ CX0KQEAgLTc1LDE1ICsxMjgsMjIgQEAgc3RhdGljIGludCBfX2d1cF9iZW5jaG1hcmtfaW9jdGwo dW5zaWduZWQgaW50IGNtZCwKIAl9CiAJZW5kX3RpbWUgPSBrdGltZV9nZXQoKTsKIAorCS8qIFNo aWZ0aW5nIHRoZSBtZWFuaW5nIG9mIG5yX3BhZ2VzOiBub3cgaXQgaXMgYWN0dWFsIG51bWJlciBw aW5uZWQ6ICovCisJbnJfcGFnZXMgPSBpOworCiAJZ3VwLT5nZXRfZGVsdGFfdXNlYyA9IGt0aW1l X3VzX2RlbHRhKGVuZF90aW1lLCBzdGFydF90aW1lKTsKIAlndXAtPnNpemUgPSBhZGRyIC0gZ3Vw LT5hZGRyOwogCisJLyoKKwkgKiBUYWtlIGFuIHVuLWJlbmNobWFyay10aW1lZCBtb21lbnQgdG8g dmVyaWZ5IERNQSBwaW5uZWQKKwkgKiBzdGF0ZTogcHJpbnQgYSB3YXJuaW5nIGlmIGFueSBub24t ZG1hLXBpbm5lZCBwYWdlcyBhcmUgZm91bmQ6CisJICovCisJdmVyaWZ5X2RtYV9waW5uZWQoY21k LCBwYWdlcywgbnJfcGFnZXMpOworCiAJc3RhcnRfdGltZSA9IGt0aW1lX2dldCgpOwotCWZvciAo aSA9IDA7IGkgPCBucl9wYWdlczsgaSsrKSB7Ci0JCWlmICghcGFnZXNbaV0pCi0JCQlicmVhazsK LQkJcHV0X3BhZ2UocGFnZXNbaV0pOwotCX0KKworCXB1dF9iYWNrX3BhZ2VzKGNtZCwgcGFnZXMs IG5yX3BhZ2VzKTsKKwogCWVuZF90aW1lID0ga3RpbWVfZ2V0KCk7CiAJZ3VwLT5wdXRfZGVsdGFf dXNlYyA9IGt0aW1lX3VzX2RlbHRhKGVuZF90aW1lLCBzdGFydF90aW1lKTsKIApAQCAtMTAxLDYg KzE2MSw5IEBAIHN0YXRpYyBsb25nIGd1cF9iZW5jaG1hcmtfaW9jdGwoc3RydWN0IGZpbGUgKmZp bGVwLCB1bnNpZ25lZCBpbnQgY21kLAogCWNhc2UgR1VQX0ZBU1RfQkVOQ0hNQVJLOgogCWNhc2Ug R1VQX0xPTkdURVJNX0JFTkNITUFSSzoKIAljYXNlIEdVUF9CRU5DSE1BUks6CisJY2FzZSBQSU5f RkFTVF9CRU5DSE1BUks6CisJY2FzZSBQSU5fTE9OR1RFUk1fQkVOQ0hNQVJLOgorCWNhc2UgUElO X0JFTkNITUFSSzoKIAkJYnJlYWs7CiAJZGVmYXVsdDoKIAkJcmV0dXJuIC1FSU5WQUw7CmRpZmYg LS1naXQgYS90b29scy90ZXN0aW5nL3NlbGZ0ZXN0cy92bS9ndXBfYmVuY2htYXJrLmMgYi90b29s cy90ZXN0aW5nL3NlbGZ0ZXN0cy92bS9ndXBfYmVuY2htYXJrLmMKaW5kZXggMzg5MzI3ZTliMzBh Li4wMzkyOGU0N2E4NmYgMTAwNjQ0Ci0tLSBhL3Rvb2xzL3Rlc3Rpbmcvc2VsZnRlc3RzL3ZtL2d1 cF9iZW5jaG1hcmsuYworKysgYi90b29scy90ZXN0aW5nL3NlbGZ0ZXN0cy92bS9ndXBfYmVuY2ht YXJrLmMKQEAgLTE4LDYgKzE4LDE1IEBACiAjZGVmaW5lIEdVUF9MT05HVEVSTV9CRU5DSE1BUksJ X0lPV1IoJ2cnLCAyLCBzdHJ1Y3QgZ3VwX2JlbmNobWFyaykKICNkZWZpbmUgR1VQX0JFTkNITUFS SwkJX0lPV1IoJ2cnLCAzLCBzdHJ1Y3QgZ3VwX2JlbmNobWFyaykKIAorLyoKKyAqIFNpbWlsYXIg dG8gYWJvdmUsIGJ1dCB1c2UgRk9MTF9QSU4gaW5zdGVhZCBvZiBGT0xMX0dFVC4gVGhpcyBpcyBk b25lCisgKiBieSBjYWxsaW5nIHBpbl91c2VyX3BhZ2VzX2Zhc3QoKSwgcGluX2xvbmd0ZXJtX3Bh Z2VzKCksIGFuZCBwaW5fdXNlcl9wYWdlcygpLAorICogcmVzcGVjdGl2ZWx5LgorICovCisjZGVm aW5lIFBJTl9GQVNUX0JFTkNITUFSSwlfSU9XUignZycsIDQsIHN0cnVjdCBndXBfYmVuY2htYXJr KQorI2RlZmluZSBQSU5fTE9OR1RFUk1fQkVOQ0hNQVJLCV9JT1dSKCdnJywgNSwgc3RydWN0IGd1 cF9iZW5jaG1hcmspCisjZGVmaW5lIFBJTl9CRU5DSE1BUksJCV9JT1dSKCdnJywgNiwgc3RydWN0 IGd1cF9iZW5jaG1hcmspCisKIC8qIEp1c3QgdGhlIGZsYWdzIHdlIG5lZWQsIGNvcGllZCBmcm9t IG1tLmg6ICovCiAjZGVmaW5lIEZPTExfV1JJVEUJMHgwMQkvKiBjaGVjayBwdGUgaXMgd3JpdGFi bGUgKi8KIApAQCAtNDAsOCArNDksMTcgQEAgaW50IG1haW4oaW50IGFyZ2MsIGNoYXIgKiphcmd2 KQogCWNoYXIgKmZpbGUgPSAiL2Rldi96ZXJvIjsKIAljaGFyICpwOwogCi0Jd2hpbGUgKChvcHQg PSBnZXRvcHQoYXJnYywgYXJndiwgIm06cjpuOmY6dFRMVXdTSCIpKSAhPSAtMSkgeworCXdoaWxl ICgob3B0ID0gZ2V0b3B0KGFyZ2MsIGFyZ3YsICJtOnI6bjpmOmFiY3RUTFV1d1NIIikpICE9IC0x KSB7CiAJCXN3aXRjaCAob3B0KSB7CisJCWNhc2UgJ2EnOgorCQkJY21kID0gUElOX0ZBU1RfQkVO Q0hNQVJLOworCQkJYnJlYWs7CisJCWNhc2UgJ2InOgorCQkJY21kID0gUElOX0xPTkdURVJNX0JF TkNITUFSSzsKKwkJCWJyZWFrOworCQljYXNlICdjJzoKKwkJCWNtZCA9IFBJTl9CRU5DSE1BUks7 CisJCQlicmVhazsKIAkJY2FzZSAnbSc6CiAJCQlzaXplID0gYXRvaShvcHRhcmcpICogTUI7CiAJ CQlicmVhazsKQEAgLTYzLDYgKzgxLDkgQEAgaW50IG1haW4oaW50IGFyZ2MsIGNoYXIgKiphcmd2 KQogCQljYXNlICdVJzoKIAkJCWNtZCA9IEdVUF9CRU5DSE1BUks7CiAJCQlicmVhazsKKwkJY2Fz ZSAndSc6CisJCQljbWQgPSBHVVBfRkFTVF9CRU5DSE1BUks7CisJCQlicmVhazsKIAkJY2FzZSAn dyc6CiAJCQl3cml0ZSA9IDE7CiAJCQlicmVhazsKLS0gCjIuMjQuMAoKX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KZHJpLWRldmVsIG1haWxpbmcgbGlzdApk cmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Au b3JnL21haWxtYW4vbGlzdGluZm8vZHJpLWRldmVs