Re: [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