lkml.org 
[lkml]   [2020]   [Sep]   [28]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
/
Date
From
SubjectRe: [PATCH 6/8] selftests/vm: gup_test: introduce the dump_pages() sub-test
On Sun, Sep 27, 2020 at 11:21:57PM -0700, John Hubbard wrote:
> For quite a while, I was doing a quick hack to gup_test.c (previously,
> gup_benchmark.c) whenever I wanted to try out my changes to dump_page().
> This makes that hack unnecessary, and instead allows anyone to easily
> get the same coverage from a user space program. That saves a lot of
> time because you don't have to change the kernel, in order to test
> different pages and options.
>
> The new sub-test takes advantage of the existing gup_test
> infrastructure, which already provides a simple user space program, some
> allocated user space pages, an ioctl call, pinning of those pages (via
> either get_user_pages or pin_user_pages) and a corresponding kernel-side
> test invocation. There's not much more required, mainly just a couple of
> inputs from the user.
>
> In fact, the new test re-uses the existing command line options in order
> to get various helpful combinations (THP or normal, _fast or slow gup,
> gup vs. pup, and more).
>
> New command line options are: which pages to dump, and what type of
> "get/pin" to use.
>
> In order to figure out which pages to dump, the logic is:
>
> * If the user doesn't specify anything, the page 0 (the first page in
> the address range that the program sets up for testing) is dumped.
>
> * Or, the user can type up to 8 page indices anywhere on the command
> line. If you type more than 8, then it uses the first 8 and ignores the
> remaining items.
>
> For example:
>
> ./gup_test -ct -F 1 0 19 0x1000
>
> Meaning:
> -c: dump pages sub-test
> -t: use THP pages
> -F 1: use pin_user_pages() instead of get_user_pages()
> 0 19 0x1000: dump pages 0, 19, and 4096
>
> Also, invoke the new test from run_vmtests.sh. This keeps it in use, and

I don't see a change to run_vmtests.sh?

Ira

> also provides a good example of how to invoke it.
>
> Signed-off-by: John Hubbard <jhubbard@nvidia.com>
> ---
> mm/Kconfig | 6 +++
> mm/gup_test.c | 54 ++++++++++++++++++++++++++-
> mm/gup_test.h | 10 +++++
> tools/testing/selftests/vm/gup_test.c | 47 +++++++++++++++++++++--
> 4 files changed, 112 insertions(+), 5 deletions(-)
>
> diff --git a/mm/Kconfig b/mm/Kconfig
> index 588984ee5fb4..f7c4c21e5cb1 100644
> --- a/mm/Kconfig
> +++ b/mm/Kconfig
> @@ -845,6 +845,12 @@ config GUP_TEST
> get_user_pages*() and pin_user_pages*(), as well as smoke tests of
> the non-_fast variants.
>
> + There is also a sub-test that allows running dump_page() on any
> + of up to eight pages (selected by command line args) within the
> + range of user-space addresses. These pages are either pinned via
> + pin_user_pages*(), or pinned via get_user_pages*(), as specified
> + by other command line arguments.
> +
> See tools/testing/selftests/vm/gup_test.c
>
> config GUP_GET_PTE_LOW_HIGH
> diff --git a/mm/gup_test.c b/mm/gup_test.c
> index a980c4a194f0..e79dc364eafb 100644
> --- a/mm/gup_test.c
> +++ b/mm/gup_test.c
> @@ -7,7 +7,7 @@
> #include "gup_test.h"
>
> static void put_back_pages(unsigned int cmd, struct page **pages,
> - unsigned long nr_pages)
> + unsigned long nr_pages, unsigned int gup_test_flags)
> {
> unsigned long i;
>
> @@ -23,6 +23,15 @@ static void put_back_pages(unsigned int cmd, struct page **pages,
> case PIN_LONGTERM_BENCHMARK:
> unpin_user_pages(pages, nr_pages);
> break;
> + case DUMP_USER_PAGES_TEST:
> + if (gup_test_flags & GUP_TEST_FLAG_DUMP_PAGES_USE_PIN) {
> + unpin_user_pages(pages, nr_pages);
> + } else {
> + for (i = 0; i < nr_pages; i++)
> + put_page(pages[i]);
> +
> + }
> + break;
> }
> }
>
> @@ -49,6 +58,37 @@ static void verify_dma_pinned(unsigned int cmd, struct page **pages,
> }
> }
>
> +static void dump_pages_test(struct gup_test *gup, struct page **pages,
> + unsigned long nr_pages)
> +{
> + unsigned int index_to_dump;
> + unsigned int i;
> +
> + /*
> + * Zero out any user-supplied page index that is out of range. Remember:
> + * .which_pages[] contains a 1-based set of page indices.
> + */
> + for (i = 0; i < GUP_TEST_MAX_PAGES_TO_DUMP; i++) {
> + if (gup->which_pages[i] > nr_pages) {
> + pr_warn("ZEROING due to out of range: .which_pages[%u]: %u\n",
> + i, gup->which_pages[i]);
> + gup->which_pages[i] = 0;
> + }
> + }
> +
> + for (i = 0; i < GUP_TEST_MAX_PAGES_TO_DUMP; i++) {
> + index_to_dump = gup->which_pages[i];
> +
> + if (index_to_dump) {
> + index_to_dump--; // Decode from 1-based, to 0-based
> + pr_info("---- page #%u, starting from user virt addr: 0x%llx\n",
> + index_to_dump, gup->addr);
> + dump_page(pages[index_to_dump],
> + "gup_test: dump_pages() test");
> + }
> + }
> +}
> +
> static int __gup_test_ioctl(unsigned int cmd,
> struct gup_test *gup)
> {
> @@ -104,6 +144,14 @@ static int __gup_test_ioctl(unsigned int cmd,
> gup->flags | FOLL_LONGTERM,
> pages + i, NULL);
> break;
> + case DUMP_USER_PAGES_TEST:
> + if (gup->flags & GUP_TEST_FLAG_DUMP_PAGES_USE_PIN)
> + nr = pin_user_pages(addr, nr, gup->flags,
> + pages + i, NULL);
> + else
> + nr = get_user_pages(addr, nr, gup->flags,
> + pages + i, NULL);
> + break;
> default:
> kvfree(pages);
> ret = -EINVAL;
> @@ -127,10 +175,11 @@ static int __gup_test_ioctl(unsigned int cmd,
> * state: print a warning if any non-dma-pinned pages are found:
> */
> verify_dma_pinned(cmd, pages, nr_pages);
> + dump_pages_test(gup, pages, nr_pages);
>
> start_time = ktime_get();
>
> - put_back_pages(cmd, pages, nr_pages);
> + put_back_pages(cmd, pages, nr_pages, gup->flags);
>
> end_time = ktime_get();
> gup->put_delta_usec = ktime_us_delta(end_time, start_time);
> @@ -152,6 +201,7 @@ static long gup_test_ioctl(struct file *filep, unsigned int cmd,
> case PIN_LONGTERM_BENCHMARK:
> case GUP_BASIC_TEST:
> case PIN_BASIC_TEST:
> + case DUMP_USER_PAGES_TEST:
> break;
> default:
> return -EINVAL;
> diff --git a/mm/gup_test.h b/mm/gup_test.h
> index 921b4caad8ef..90a6713d50eb 100644
> --- a/mm/gup_test.h
> +++ b/mm/gup_test.h
> @@ -9,6 +9,11 @@
> #define PIN_LONGTERM_BENCHMARK _IOWR('g', 3, struct gup_test)
> #define GUP_BASIC_TEST _IOWR('g', 4, struct gup_test)
> #define PIN_BASIC_TEST _IOWR('g', 5, struct gup_test)
> +#define DUMP_USER_PAGES_TEST _IOWR('g', 6, struct gup_test)
> +
> +#define GUP_TEST_MAX_PAGES_TO_DUMP 8
> +
> +#define GUP_TEST_FLAG_DUMP_PAGES_USE_PIN 0x1
>
> struct gup_test {
> __u64 get_delta_usec;
> @@ -17,6 +22,11 @@ struct gup_test {
> __u64 size;
> __u32 nr_pages_per_call;
> __u32 flags;
> + /*
> + * Each non-zero entry is the number of the page (1-based: first page is
> + * page 1, so that zero entries mean "do nothing") from the .addr base.
> + */
> + __u32 which_pages[GUP_TEST_MAX_PAGES_TO_DUMP];
> };
>
> #endif /* __GUP_TEST_H */
> diff --git a/tools/testing/selftests/vm/gup_test.c b/tools/testing/selftests/vm/gup_test.c
> index 67d57a1cc8b6..68137b337114 100644
> --- a/tools/testing/selftests/vm/gup_test.c
> +++ b/tools/testing/selftests/vm/gup_test.c
> @@ -27,21 +27,23 @@ static char *cmd_to_str(unsigned long cmd)
> return "GUP_BASIC_TEST";
> case PIN_BASIC_TEST:
> return "PIN_BASIC_TEST";
> + case DUMP_USER_PAGES_TEST:
> + return "DUMP_USER_PAGES_TEST";
> }
> return "Unknown command";
> }
>
> int main(int argc, char **argv)
> {
> - struct gup_test gup;
> + struct gup_test gup = { 0 };
> unsigned long size = 128 * MB;
> int i, fd, filed, opt, nr_pages = 1, thp = -1, repeats = 1, write = 0;
> - int cmd = GUP_FAST_BENCHMARK;
> + unsigned long cmd = GUP_FAST_BENCHMARK;
> int flags = MAP_PRIVATE;
> char *file = "/dev/zero";
> char *p;
>
> - while ((opt = getopt(argc, argv, "m:r:n:f:abtTLUuwSH")) != -1) {
> + while ((opt = getopt(argc, argv, "m:r:n:F:f:abctTLUuwSH")) != -1) {
> switch (opt) {
> case 'a':
> cmd = PIN_FAST_BENCHMARK;
> @@ -52,6 +54,21 @@ int main(int argc, char **argv)
> case 'L':
> cmd = PIN_LONGTERM_BENCHMARK;
> break;
> + case 'c':
> + cmd = DUMP_USER_PAGES_TEST;
> + /*
> + * Dump page 0 (index 1). May be overridden later, by
> + * user's non-option arguments.
> + *
> + * .which_pages is zero-based, so that zero can mean "do
> + * nothing".
> + */
> + gup.which_pages[0] = 1;
> + break;
> + case 'F':
> + /* strtol, so you can pass flags in hex form */
> + gup.flags = strtol(optarg, 0, 0);
> + break;
> case 'm':
> size = atoi(optarg) * MB;
> break;
> @@ -91,6 +108,30 @@ int main(int argc, char **argv)
> }
> }
>
> + if (optind < argc) {
> + int extra_arg_count = 0;
> + /*
> + * For example:
> + *
> + * ./gup_test -c 0 1 0x1001
> + *
> + * ...to dump pages 0, 1, and 4097
> + */
> +
> + while ((optind < argc) &&
> + (extra_arg_count < GUP_TEST_MAX_PAGES_TO_DUMP)) {
> + /*
> + * Do the 1-based indexing here, so that the user can
> + * use normal 0-based indexing on the command line.
> + */
> + long page_index = strtol(argv[optind], 0, 0) + 1;
> +
> + gup.which_pages[extra_arg_count] = page_index;
> + extra_arg_count++;
> + optind++;
> + }
> + }
> +
> filed = open(file, O_RDWR|O_CREAT);
> if (filed < 0) {
> perror("open");
> --
> 2.28.0
>
>

\
 
 \ /
  Last update: 2020-09-28 21:25    [W:0.101 / U:0.328 seconds]
©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site