From 9c84f229268fa229e250b7225611d0eb7094fea0 Mon Sep 17 00:00:00 2001 From: John Hubbard Date: Mon, 14 Dec 2020 19:05:05 -0800 Subject: mm/gup_benchmark: rename to mm/gup_test MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Patch series "selftests/vm: gup_test, hmm-tests, assorted improvements", v3. Summary: This series provides two main things, and a number of smaller supporting goodies. The two main points are: 1) Add a new sub-test to gup_test, which in turn is a renamed version of gup_benchmark. This sub-test allows nicer testing of dump_pages(), at least on user-space pages. For quite a while, I was doing a quick hack to gup_test.c whenever I wanted to try out changes to dump_page(). Then Matthew Wilcox asked me what I meant when I said "I used my dump_page() unit test", and I realized that it might be nice to check in a polished up version of that. Details about how it works and how to use it are in the commit description for patch #6 ("selftests/vm: gup_test: introduce the dump_pages() sub-test"). 2) Fixes a limitation of hmm-tests: these tests are incredibly useful, but only if people actually build and run them. And it turns out that libhugetlbfs is a little too effective at throwing a wrench in the works, there. So I've added a little configuration check that removes just two of the 21 hmm-tests, if libhugetlbfs is not available. Further details in the commit description of patch #8 ("selftests/vm: hmm-tests: remove the libhugetlbfs dependency"). Other smaller things that this series does: a) Remove code duplication by creating gup_test.h. b) Clear up the sub-test organization, and their invocation within run_vmtests.sh. c) Other minor assorted improvements. [1] v2 is here: https://lore.kernel.org/linux-doc/20200929212747.251804-1-jhubbard@nvidia.com/ [2] https://lore.kernel.org/r/CAHk-=wgh-TMPHLY3jueHX7Y2fWh3D+nMBqVS__AZm6-oorquWA@mail.gmail.com This patch (of 9): Rename nearly every "gup_benchmark" reference and file name to "gup_test". The one exception is for the actual gup benchmark test itself. The current code already does a *little* bit more than benchmarking, and definitely covers more than get_user_pages_fast(). More importantly, however, subsequent patches are about to add some functionality that is non-benchmark related. Closely related changes: * Kconfig: in addition to renaming the options from GUP_BENCHMARK to GUP_TEST, update the help text to reflect that it's no longer a benchmark-only test. Link: https://lkml.kernel.org/r/20201026064021.3545418-1-jhubbard@nvidia.com Link: https://lkml.kernel.org/r/20201026064021.3545418-2-jhubbard@nvidia.com Signed-off-by: John Hubbard Cc: Jonathan Corbet Cc: Jérôme Glisse Cc: Ralph Campbell Cc: Shuah Khan Signed-off-by: Andrew Morton Signed-off-by: Linus Torvalds --- mm/Kconfig | 15 ++-- mm/Makefile | 2 +- mm/gup_benchmark.c | 210 ----------------------------------------------------- mm/gup_test.c | 210 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 221 insertions(+), 216 deletions(-) delete mode 100644 mm/gup_benchmark.c create mode 100644 mm/gup_test.c (limited to 'mm') diff --git a/mm/Kconfig b/mm/Kconfig index 390165ffbb0f..e25e5cb2989f 100644 --- a/mm/Kconfig +++ b/mm/Kconfig @@ -821,13 +821,18 @@ config PERCPU_STATS information includes global and per chunk statistics, which can be used to help understand percpu memory usage. -config GUP_BENCHMARK - bool "Enable infrastructure for get_user_pages() and related calls benchmarking" +config GUP_TEST + bool "Enable infrastructure for get_user_pages()-related unit tests" help - Provides /sys/kernel/debug/gup_benchmark that helps with testing - performance of get_user_pages() and related calls. + Provides /sys/kernel/debug/gup_test, which in turn provides a way + to make ioctl calls that can launch kernel-based unit tests for + the get_user_pages*() and pin_user_pages*() family of API calls. - See tools/testing/selftests/vm/gup_benchmark.c + These tests include benchmark testing of the _fast variants of + get_user_pages*() and pin_user_pages*(), as well as smoke tests of + the non-_fast variants. + + See tools/testing/selftests/vm/gup_test.c config GUP_GET_PTE_LOW_HIGH bool diff --git a/mm/Makefile b/mm/Makefile index d73aed0fc99c..069f216e109e 100644 --- a/mm/Makefile +++ b/mm/Makefile @@ -90,7 +90,7 @@ obj-$(CONFIG_PAGE_COUNTER) += page_counter.o obj-$(CONFIG_MEMCG) += memcontrol.o vmpressure.o obj-$(CONFIG_MEMCG_SWAP) += swap_cgroup.o obj-$(CONFIG_CGROUP_HUGETLB) += hugetlb_cgroup.o -obj-$(CONFIG_GUP_BENCHMARK) += gup_benchmark.o +obj-$(CONFIG_GUP_TEST) += gup_test.o obj-$(CONFIG_MEMORY_FAILURE) += memory-failure.o obj-$(CONFIG_HWPOISON_INJECT) += hwpoison-inject.o obj-$(CONFIG_DEBUG_KMEMLEAK) += kmemleak.o diff --git a/mm/gup_benchmark.c b/mm/gup_benchmark.c deleted file mode 100644 index 8b3e5b5cd8fa..000000000000 --- a/mm/gup_benchmark.c +++ /dev/null @@ -1,210 +0,0 @@ -#include -#include -#include -#include -#include -#include - -#define GUP_FAST_BENCHMARK _IOWR('g', 1, struct gup_benchmark) -#define GUP_BENCHMARK _IOWR('g', 2, struct gup_benchmark) -#define PIN_FAST_BENCHMARK _IOWR('g', 3, struct gup_benchmark) -#define PIN_BENCHMARK _IOWR('g', 4, struct gup_benchmark) -#define PIN_LONGTERM_BENCHMARK _IOWR('g', 5, struct gup_benchmark) - -struct gup_benchmark { - __u64 get_delta_usec; - __u64 put_delta_usec; - __u64 addr; - __u64 size; - __u32 nr_pages_per_call; - __u32 flags; - __u64 expansion[10]; /* For future use */ -}; - -static void put_back_pages(unsigned int cmd, struct page **pages, - unsigned long nr_pages) -{ - unsigned long i; - - switch (cmd) { - case GUP_FAST_BENCHMARK: - case GUP_BENCHMARK: - for (i = 0; i < nr_pages; i++) - put_page(pages[i]); - break; - - case PIN_FAST_BENCHMARK: - case PIN_BENCHMARK: - case PIN_LONGTERM_BENCHMARK: - unpin_user_pages(pages, nr_pages); - break; - } -} - -static void verify_dma_pinned(unsigned int cmd, struct page **pages, - unsigned long nr_pages) -{ - unsigned long i; - struct page *page; - - switch (cmd) { - case PIN_FAST_BENCHMARK: - case PIN_BENCHMARK: - case PIN_LONGTERM_BENCHMARK: - for (i = 0; i < nr_pages; i++) { - page = pages[i]; - if (WARN(!page_maybe_dma_pinned(page), - "pages[%lu] is NOT dma-pinned\n", i)) { - - dump_page(page, "gup_benchmark failure"); - break; - } - } - break; - } -} - -static int __gup_benchmark_ioctl(unsigned int cmd, - struct gup_benchmark *gup) -{ - ktime_t start_time, end_time; - unsigned long i, nr_pages, addr, next; - int nr; - struct page **pages; - int ret = 0; - bool needs_mmap_lock = - cmd != GUP_FAST_BENCHMARK && cmd != PIN_FAST_BENCHMARK; - - if (gup->size > ULONG_MAX) - return -EINVAL; - - nr_pages = gup->size / PAGE_SIZE; - pages = kvcalloc(nr_pages, sizeof(void *), GFP_KERNEL); - if (!pages) - return -ENOMEM; - - if (needs_mmap_lock && mmap_read_lock_killable(current->mm)) { - ret = -EINTR; - goto free_pages; - } - - i = 0; - nr = gup->nr_pages_per_call; - start_time = ktime_get(); - for (addr = gup->addr; addr < gup->addr + gup->size; addr = next) { - if (nr != gup->nr_pages_per_call) - break; - - next = addr + nr * PAGE_SIZE; - if (next > gup->addr + gup->size) { - next = gup->addr + gup->size; - nr = (next - addr) / PAGE_SIZE; - } - - /* Filter out most gup flags: only allow a tiny subset here: */ - gup->flags &= FOLL_WRITE; - - switch (cmd) { - case GUP_FAST_BENCHMARK: - nr = get_user_pages_fast(addr, nr, gup->flags, - pages + i); - break; - case GUP_BENCHMARK: - nr = get_user_pages(addr, nr, gup->flags, pages + i, - NULL); - break; - case PIN_FAST_BENCHMARK: - nr = pin_user_pages_fast(addr, nr, gup->flags, - pages + i); - break; - case PIN_BENCHMARK: - nr = pin_user_pages(addr, nr, gup->flags, pages + i, - NULL); - break; - case PIN_LONGTERM_BENCHMARK: - nr = pin_user_pages(addr, nr, - gup->flags | FOLL_LONGTERM, - pages + i, NULL); - break; - default: - ret = -EINVAL; - goto unlock; - } - - if (nr <= 0) - break; - i += nr; - } - end_time = ktime_get(); - - /* Shifting the meaning of nr_pages: now it is actual number pinned: */ - nr_pages = i; - - gup->get_delta_usec = ktime_us_delta(end_time, start_time); - gup->size = addr - gup->addr; - - /* - * 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 = ktime_get(); - - put_back_pages(cmd, pages, nr_pages); - - end_time = ktime_get(); - gup->put_delta_usec = ktime_us_delta(end_time, start_time); - -unlock: - if (needs_mmap_lock) - mmap_read_unlock(current->mm); -free_pages: - kvfree(pages); - return ret; -} - -static long gup_benchmark_ioctl(struct file *filep, unsigned int cmd, - unsigned long arg) -{ - struct gup_benchmark gup; - int ret; - - switch (cmd) { - case GUP_FAST_BENCHMARK: - case GUP_BENCHMARK: - case PIN_FAST_BENCHMARK: - case PIN_BENCHMARK: - case PIN_LONGTERM_BENCHMARK: - break; - default: - return -EINVAL; - } - - if (copy_from_user(&gup, (void __user *)arg, sizeof(gup))) - return -EFAULT; - - ret = __gup_benchmark_ioctl(cmd, &gup); - if (ret) - return ret; - - if (copy_to_user((void __user *)arg, &gup, sizeof(gup))) - return -EFAULT; - - return 0; -} - -static const struct file_operations gup_benchmark_fops = { - .open = nonseekable_open, - .unlocked_ioctl = gup_benchmark_ioctl, -}; - -static int gup_benchmark_init(void) -{ - debugfs_create_file_unsafe("gup_benchmark", 0600, NULL, NULL, - &gup_benchmark_fops); - - return 0; -} - -late_initcall(gup_benchmark_init); diff --git a/mm/gup_test.c b/mm/gup_test.c new file mode 100644 index 000000000000..59472ea6aa39 --- /dev/null +++ b/mm/gup_test.c @@ -0,0 +1,210 @@ +#include +#include +#include +#include +#include +#include + +#define GUP_FAST_BENCHMARK _IOWR('g', 1, struct gup_test) +#define GUP_BENCHMARK _IOWR('g', 2, struct gup_test) +#define PIN_FAST_BENCHMARK _IOWR('g', 3, struct gup_test) +#define PIN_BENCHMARK _IOWR('g', 4, struct gup_test) +#define PIN_LONGTERM_BENCHMARK _IOWR('g', 5, struct gup_test) + +struct gup_test { + __u64 get_delta_usec; + __u64 put_delta_usec; + __u64 addr; + __u64 size; + __u32 nr_pages_per_call; + __u32 flags; + __u64 expansion[10]; /* For future use */ +}; + +static void put_back_pages(unsigned int cmd, struct page **pages, + unsigned long nr_pages) +{ + unsigned long i; + + switch (cmd) { + case GUP_FAST_BENCHMARK: + case GUP_BENCHMARK: + for (i = 0; i < nr_pages; i++) + put_page(pages[i]); + break; + + case PIN_FAST_BENCHMARK: + case PIN_BENCHMARK: + case PIN_LONGTERM_BENCHMARK: + unpin_user_pages(pages, nr_pages); + break; + } +} + +static void verify_dma_pinned(unsigned int cmd, struct page **pages, + unsigned long nr_pages) +{ + unsigned long i; + struct page *page; + + switch (cmd) { + case PIN_FAST_BENCHMARK: + case PIN_BENCHMARK: + case PIN_LONGTERM_BENCHMARK: + for (i = 0; i < nr_pages; i++) { + page = pages[i]; + if (WARN(!page_maybe_dma_pinned(page), + "pages[%lu] is NOT dma-pinned\n", i)) { + + dump_page(page, "gup_test failure"); + break; + } + } + break; + } +} + +static int __gup_test_ioctl(unsigned int cmd, + struct gup_test *gup) +{ + ktime_t start_time, end_time; + unsigned long i, nr_pages, addr, next; + int nr; + struct page **pages; + int ret = 0; + bool needs_mmap_lock = + cmd != GUP_FAST_BENCHMARK && cmd != PIN_FAST_BENCHMARK; + + if (gup->size > ULONG_MAX) + return -EINVAL; + + nr_pages = gup->size / PAGE_SIZE; + pages = kvcalloc(nr_pages, sizeof(void *), GFP_KERNEL); + if (!pages) + return -ENOMEM; + + if (needs_mmap_lock && mmap_read_lock_killable(current->mm)) { + ret = -EINTR; + goto free_pages; + } + + i = 0; + nr = gup->nr_pages_per_call; + start_time = ktime_get(); + for (addr = gup->addr; addr < gup->addr + gup->size; addr = next) { + if (nr != gup->nr_pages_per_call) + break; + + next = addr + nr * PAGE_SIZE; + if (next > gup->addr + gup->size) { + next = gup->addr + gup->size; + nr = (next - addr) / PAGE_SIZE; + } + + /* Filter out most gup flags: only allow a tiny subset here: */ + gup->flags &= FOLL_WRITE; + + switch (cmd) { + case GUP_FAST_BENCHMARK: + nr = get_user_pages_fast(addr, nr, gup->flags, + pages + i); + break; + case GUP_BENCHMARK: + nr = get_user_pages(addr, nr, gup->flags, pages + i, + NULL); + break; + case PIN_FAST_BENCHMARK: + nr = pin_user_pages_fast(addr, nr, gup->flags, + pages + i); + break; + case PIN_BENCHMARK: + nr = pin_user_pages(addr, nr, gup->flags, pages + i, + NULL); + break; + case PIN_LONGTERM_BENCHMARK: + nr = pin_user_pages(addr, nr, + gup->flags | FOLL_LONGTERM, + pages + i, NULL); + break; + default: + ret = -EINVAL; + goto unlock; + } + + if (nr <= 0) + break; + i += nr; + } + end_time = ktime_get(); + + /* Shifting the meaning of nr_pages: now it is actual number pinned: */ + nr_pages = i; + + gup->get_delta_usec = ktime_us_delta(end_time, start_time); + gup->size = addr - gup->addr; + + /* + * 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 = ktime_get(); + + put_back_pages(cmd, pages, nr_pages); + + end_time = ktime_get(); + gup->put_delta_usec = ktime_us_delta(end_time, start_time); + +unlock: + if (needs_mmap_lock) + mmap_read_unlock(current->mm); +free_pages: + kvfree(pages); + return ret; +} + +static long gup_test_ioctl(struct file *filep, unsigned int cmd, + unsigned long arg) +{ + struct gup_test gup; + int ret; + + switch (cmd) { + case GUP_FAST_BENCHMARK: + case GUP_BENCHMARK: + case PIN_FAST_BENCHMARK: + case PIN_BENCHMARK: + case PIN_LONGTERM_BENCHMARK: + break; + default: + return -EINVAL; + } + + if (copy_from_user(&gup, (void __user *)arg, sizeof(gup))) + return -EFAULT; + + ret = __gup_test_ioctl(cmd, &gup); + if (ret) + return ret; + + if (copy_to_user((void __user *)arg, &gup, sizeof(gup))) + return -EFAULT; + + return 0; +} + +static const struct file_operations gup_test_fops = { + .open = nonseekable_open, + .unlocked_ioctl = gup_test_ioctl, +}; + +static int gup_test_init(void) +{ + debugfs_create_file_unsafe("gup_test", 0600, NULL, NULL, + &gup_test_fops); + + return 0; +} + +late_initcall(gup_test_init); -- cgit v1.2.3-58-ga151