[v13,3/3] selftests: Add selftests for cachestat
Commit Message
Test cachestat on a newly created file, /dev/ files, and /proc/ files.
Also test on a shmem file (which can also be tested with huge pages
since tmpfs supports huge pages).
Signed-off-by: Nhat Pham <nphamcs@gmail.com>
---
MAINTAINERS | 7 +
tools/testing/selftests/Makefile | 1 +
tools/testing/selftests/cachestat/.gitignore | 2 +
tools/testing/selftests/cachestat/Makefile | 8 +
.../selftests/cachestat/test_cachestat.c | 258 ++++++++++++++++++
5 files changed, 276 insertions(+)
create mode 100644 tools/testing/selftests/cachestat/.gitignore
create mode 100644 tools/testing/selftests/cachestat/Makefile
create mode 100644 tools/testing/selftests/cachestat/test_cachestat.c
Comments
On Tue, May 02, 2023 at 06:36:08PM -0700, Nhat Pham wrote:
> Test cachestat on a newly created file, /dev/ files, and /proc/ files.
> Also test on a shmem file (which can also be tested with huge pages
> since tmpfs supports huge pages).
>
> Signed-off-by: Nhat Pham <nphamcs@gmail.com>
*and a directory
Looks good to me. It covers a good set of real cases and weird cases.
Acked-by: Johannes Weiner <hannes@cmpxchg.org>
Nhat Pham <nphamcs@gmail.com> writes:
> Test cachestat on a newly created file, /dev/ files, and /proc/ files.
> Also test on a shmem file (which can also be tested with huge pages
> since tmpfs supports huge pages).
>
> Signed-off-by: Nhat Pham <nphamcs@gmail.com>
...
> diff --git a/tools/testing/selftests/cachestat/test_cachestat.c b/tools/testing/selftests/cachestat/test_cachestat.c
> new file mode 100644
> index 000000000000..c3823b809c25
> --- /dev/null
> +++ b/tools/testing/selftests/cachestat/test_cachestat.c
> @@ -0,0 +1,258 @@
> +// SPDX-License-Identifier: GPL-2.0
> +#define _GNU_SOURCE
> +
> +#include <stdio.h>
> +#include <stdbool.h>
> +#include <linux/kernel.h>
> +#include <linux/mman.h>
> +#include <sys/mman.h>
> +#include <sys/shm.h>
> +#include <sys/syscall.h>
> +#include <unistd.h>
> +#include <string.h>
> +#include <fcntl.h>
> +#include <errno.h>
> +
> +#include "../kselftest.h"
> +
> +static const char * const dev_files[] = {
> + "/dev/zero", "/dev/null", "/dev/urandom",
> + "/proc/version", "/proc"
> +};
> +static const int cachestat_nr = 451;
> +
> +void print_cachestat(struct cachestat *cs)
> +{
> + ksft_print_msg(
> + "Using cachestat: Cached: %lu, Dirty: %lu, Writeback: %lu, Evicted: %lu, Recently Evicted: %lu\n",
> + cs->nr_cache, cs->nr_dirty, cs->nr_writeback,
> + cs->nr_evicted, cs->nr_recently_evicted);
> +}
> +
> +bool write_exactly(int fd, size_t filesize)
> +{
> + char data[filesize];
On kernels with 64K pages (powerpc at least), this tries to allocate
64MB on the stack which segfaults.
Allocating data with malloc avoids the problem and allows the test to
pass.
Looks like this commit is still in mm-unstable, so maybe Andrew can
squash the incremental diff below in, if it looks OK to you. The diff is
a bit big because I unindented the body of the function.
cheers
diff --git a/tools/testing/selftests/cachestat/test_cachestat.c b/tools/testing/selftests/cachestat/test_cachestat.c
index 9be2262e5c17..54d09b820ed4 100644
--- a/tools/testing/selftests/cachestat/test_cachestat.c
+++ b/tools/testing/selftests/cachestat/test_cachestat.c
@@ -31,48 +31,59 @@ void print_cachestat(struct cachestat *cs)
bool write_exactly(int fd, size_t filesize)
{
- char data[filesize];
- bool ret = true;
int random_fd = open("/dev/urandom", O_RDONLY);
+ char *cursor, *data;
+ int remained;
+ bool ret;
if (random_fd < 0) {
ksft_print_msg("Unable to access urandom.\n");
ret = false;
goto out;
- } else {
- int remained = filesize;
- char *cursor = data;
+ }
- while (remained) {
- ssize_t read_len = read(random_fd, cursor, remained);
+ data = malloc(filesize);
+ if (!data) {
+ ksft_print_msg("Unable to allocate data.\n");
+ ret = false;
+ goto close_random_fd;
+ }
- if (read_len <= 0) {
- ksft_print_msg("Unable to read from urandom.\n");
- ret = false;
- goto close_random_fd;
- }
+ remained = filesize;
+ cursor = data;
- remained -= read_len;
- cursor += read_len;
+ while (remained) {
+ ssize_t read_len = read(random_fd, cursor, remained);
+
+ if (read_len <= 0) {
+ ksft_print_msg("Unable to read from urandom.\n");
+ ret = false;
+ goto out_free_data;
}
- /* write random data to fd */
- remained = filesize;
- cursor = data;
- while (remained) {
- ssize_t write_len = write(fd, cursor, remained);
+ remained -= read_len;
+ cursor += read_len;
+ }
- if (write_len <= 0) {
- ksft_print_msg("Unable write random data to file.\n");
- ret = false;
- goto close_random_fd;
- }
+ /* write random data to fd */
+ remained = filesize;
+ cursor = data;
+ while (remained) {
+ ssize_t write_len = write(fd, cursor, remained);
- remained -= write_len;
- cursor += write_len;
+ if (write_len <= 0) {
+ ksft_print_msg("Unable write random data to file.\n");
+ ret = false;
+ goto out_free_data;
}
+
+ remained -= write_len;
+ cursor += write_len;
}
+ ret = true;
+out_free_data:
+ free(data);
close_random_fd:
close(random_fd);
out:
On Wed, May 10, 2023 at 8:21 PM Michael Ellerman <mpe@ellerman.id.au> wrote:
>
> Nhat Pham <nphamcs@gmail.com> writes:
> > Test cachestat on a newly created file, /dev/ files, and /proc/ files.
> > Also test on a shmem file (which can also be tested with huge pages
> > since tmpfs supports huge pages).
> >
> > Signed-off-by: Nhat Pham <nphamcs@gmail.com>
> ...
> > diff --git a/tools/testing/selftests/cachestat/test_cachestat.c b/tools/testing/selftests/cachestat/test_cachestat.c
> > new file mode 100644
> > index 000000000000..c3823b809c25
> > --- /dev/null
> > +++ b/tools/testing/selftests/cachestat/test_cachestat.c
> > @@ -0,0 +1,258 @@
> > +// SPDX-License-Identifier: GPL-2.0
> > +#define _GNU_SOURCE
> > +
> > +#include <stdio.h>
> > +#include <stdbool.h>
> > +#include <linux/kernel.h>
> > +#include <linux/mman.h>
> > +#include <sys/mman.h>
> > +#include <sys/shm.h>
> > +#include <sys/syscall.h>
> > +#include <unistd.h>
> > +#include <string.h>
> > +#include <fcntl.h>
> > +#include <errno.h>
> > +
> > +#include "../kselftest.h"
> > +
> > +static const char * const dev_files[] = {
> > + "/dev/zero", "/dev/null", "/dev/urandom",
> > + "/proc/version", "/proc"
> > +};
> > +static const int cachestat_nr = 451;
> > +
> > +void print_cachestat(struct cachestat *cs)
> > +{
> > + ksft_print_msg(
> > + "Using cachestat: Cached: %lu, Dirty: %lu, Writeback: %lu, Evicted: %lu, Recently Evicted: %lu\n",
> > + cs->nr_cache, cs->nr_dirty, cs->nr_writeback,
> > + cs->nr_evicted, cs->nr_recently_evicted);
> > +}
> > +
> > +bool write_exactly(int fd, size_t filesize)
> > +{
> > + char data[filesize];
>
> On kernels with 64K pages (powerpc at least), this tries to allocate
> 64MB on the stack which segfaults.
>
> Allocating data with malloc avoids the problem and allows the test to
> pass.
>
> Looks like this commit is still in mm-unstable, so maybe Andrew can
> squash the incremental diff below in, if it looks OK to you. The diff is
> a bit big because I unindented the body of the function.
>
> cheers
>
>
> diff --git a/tools/testing/selftests/cachestat/test_cachestat.c b/tools/testing/selftests/cachestat/test_cachestat.c
> index 9be2262e5c17..54d09b820ed4 100644
> --- a/tools/testing/selftests/cachestat/test_cachestat.c
> +++ b/tools/testing/selftests/cachestat/test_cachestat.c
> @@ -31,48 +31,59 @@ void print_cachestat(struct cachestat *cs)
>
> bool write_exactly(int fd, size_t filesize)
> {
> - char data[filesize];
> - bool ret = true;
> int random_fd = open("/dev/urandom", O_RDONLY);
> + char *cursor, *data;
> + int remained;
> + bool ret;
>
> if (random_fd < 0) {
> ksft_print_msg("Unable to access urandom.\n");
> ret = false;
> goto out;
> - } else {
> - int remained = filesize;
> - char *cursor = data;
> + }
>
> - while (remained) {
> - ssize_t read_len = read(random_fd, cursor, remained);
> + data = malloc(filesize);
> + if (!data) {
> + ksft_print_msg("Unable to allocate data.\n");
> + ret = false;
> + goto close_random_fd;
> + }
>
> - if (read_len <= 0) {
> - ksft_print_msg("Unable to read from urandom.\n");
> - ret = false;
> - goto close_random_fd;
> - }
> + remained = filesize;
> + cursor = data;
>
> - remained -= read_len;
> - cursor += read_len;
> + while (remained) {
> + ssize_t read_len = read(random_fd, cursor, remained);
> +
> + if (read_len <= 0) {
> + ksft_print_msg("Unable to read from urandom.\n");
> + ret = false;
> + goto out_free_data;
> }
>
> - /* write random data to fd */
> - remained = filesize;
> - cursor = data;
> - while (remained) {
> - ssize_t write_len = write(fd, cursor, remained);
> + remained -= read_len;
> + cursor += read_len;
> + }
>
> - if (write_len <= 0) {
> - ksft_print_msg("Unable write random data to file.\n");
> - ret = false;
> - goto close_random_fd;
> - }
> + /* write random data to fd */
> + remained = filesize;
> + cursor = data;
> + while (remained) {
> + ssize_t write_len = write(fd, cursor, remained);
>
> - remained -= write_len;
> - cursor += write_len;
> + if (write_len <= 0) {
> + ksft_print_msg("Unable write random data to file.\n");
> + ret = false;
> + goto out_free_data;
> }
> +
> + remained -= write_len;
> + cursor += write_len;
> }
>
> + ret = true;
> +out_free_data:
> + free(data);
> close_random_fd:
> close(random_fd);
> out:
>
Oh this is nice! I had to make a similar fix in another test
of mine, but forgot about it in this context.
LGTM. For verification, I have applied the diff and test on
my own local setup. Things still pass.
Acked-by: Nhat Pham <nphamcs@gmail.com>
@@ -4510,6 +4510,13 @@ S: Supported
F: Documentation/filesystems/caching/cachefiles.rst
F: fs/cachefiles/
+CACHESTAT: PAGE CACHE STATS FOR A FILE
+M: Nhat Pham <nphamcs@gmail.com>
+M: Johannes Weiner <hannes@cmpxchg.org>
+L: linux-mm@kvack.org
+S: Maintained
+F: tools/testing/selftests/cachestat/test_cachestat.c
+
CADENCE MIPI-CSI2 BRIDGES
M: Maxime Ripard <mripard@kernel.org>
L: linux-media@vger.kernel.org
@@ -4,6 +4,7 @@ TARGETS += amd-pstate
TARGETS += arm64
TARGETS += bpf
TARGETS += breakpoints
+TARGETS += cachestat
TARGETS += capabilities
TARGETS += cgroup
TARGETS += clone3
new file mode 100644
@@ -0,0 +1,2 @@
+# SPDX-License-Identifier: GPL-2.0-only
+test_cachestat
new file mode 100644
@@ -0,0 +1,8 @@
+# SPDX-License-Identifier: GPL-2.0
+TEST_GEN_PROGS := test_cachestat
+
+CFLAGS += $(KHDR_INCLUDES)
+CFLAGS += -Wall
+CFLAGS += -lrt
+
+include ../lib.mk
new file mode 100644
@@ -0,0 +1,258 @@
+// SPDX-License-Identifier: GPL-2.0
+#define _GNU_SOURCE
+
+#include <stdio.h>
+#include <stdbool.h>
+#include <linux/kernel.h>
+#include <linux/mman.h>
+#include <sys/mman.h>
+#include <sys/shm.h>
+#include <sys/syscall.h>
+#include <unistd.h>
+#include <string.h>
+#include <fcntl.h>
+#include <errno.h>
+
+#include "../kselftest.h"
+
+static const char * const dev_files[] = {
+ "/dev/zero", "/dev/null", "/dev/urandom",
+ "/proc/version", "/proc"
+};
+static const int cachestat_nr = 451;
+
+void print_cachestat(struct cachestat *cs)
+{
+ ksft_print_msg(
+ "Using cachestat: Cached: %lu, Dirty: %lu, Writeback: %lu, Evicted: %lu, Recently Evicted: %lu\n",
+ cs->nr_cache, cs->nr_dirty, cs->nr_writeback,
+ cs->nr_evicted, cs->nr_recently_evicted);
+}
+
+bool write_exactly(int fd, size_t filesize)
+{
+ char data[filesize];
+ bool ret = true;
+ int random_fd = open("/dev/urandom", O_RDONLY);
+
+ if (random_fd < 0) {
+ ksft_print_msg("Unable to access urandom.\n");
+ ret = false;
+ goto out;
+ } else {
+ int remained = filesize;
+ char *cursor = data;
+
+ while (remained) {
+ ssize_t read_len = read(random_fd, cursor, remained);
+
+ if (read_len <= 0) {
+ ksft_print_msg("Unable to read from urandom.\n");
+ ret = false;
+ goto close_random_fd;
+ }
+
+ remained -= read_len;
+ cursor += read_len;
+ }
+
+ /* write random data to fd */
+ remained = filesize;
+ cursor = data;
+ while (remained) {
+ ssize_t write_len = write(fd, cursor, remained);
+
+ if (write_len <= 0) {
+ ksft_print_msg("Unable write random data to file.\n");
+ ret = false;
+ goto close_random_fd;
+ }
+
+ remained -= write_len;
+ cursor += write_len;
+ }
+ }
+
+close_random_fd:
+ close(random_fd);
+out:
+ return ret;
+}
+
+/*
+ * Open/create the file at filename, (optionally) write random data to it
+ * (exactly num_pages), then test the cachestat syscall on this file.
+ *
+ * If test_fsync == true, fsync the file, then check the number of dirty
+ * pages.
+ */
+bool test_cachestat(const char *filename, bool write_random, bool create,
+ bool test_fsync, unsigned long num_pages, int open_flags,
+ mode_t open_mode)
+{
+ size_t PS = sysconf(_SC_PAGESIZE);
+ int filesize = num_pages * PS;
+ bool ret = true;
+ long syscall_ret;
+ struct cachestat cs;
+ struct cachestat_range cs_range = { 0, filesize };
+
+ int fd = open(filename, open_flags, open_mode);
+
+ if (fd == -1) {
+ ksft_print_msg("Unable to create/open file.\n");
+ ret = false;
+ goto out;
+ } else {
+ ksft_print_msg("Create/open %s\n", filename);
+ }
+
+ if (write_random) {
+ if (!write_exactly(fd, filesize)) {
+ ksft_print_msg("Unable to access urandom.\n");
+ ret = false;
+ goto out1;
+ }
+ }
+
+ syscall_ret = syscall(cachestat_nr, fd, &cs_range, &cs, 0);
+
+ ksft_print_msg("Cachestat call returned %ld\n", syscall_ret);
+
+ if (syscall_ret) {
+ ksft_print_msg("Cachestat returned non-zero.\n");
+ ret = false;
+ goto out1;
+
+ } else {
+ print_cachestat(&cs);
+
+ if (write_random) {
+ if (cs.nr_cache + cs.nr_evicted != num_pages) {
+ ksft_print_msg(
+ "Total number of cached and evicted pages is off.\n");
+ ret = false;
+ }
+ }
+ }
+
+ if (test_fsync) {
+ if (fsync(fd)) {
+ ksft_print_msg("fsync fails.\n");
+ ret = false;
+ } else {
+ syscall_ret = syscall(cachestat_nr, fd, &cs_range, &cs, 0);
+
+ ksft_print_msg("Cachestat call (after fsync) returned %ld\n",
+ syscall_ret);
+
+ if (!syscall_ret) {
+ print_cachestat(&cs);
+
+ if (cs.nr_dirty) {
+ ret = false;
+ ksft_print_msg(
+ "Number of dirty should be zero after fsync.\n");
+ }
+ } else {
+ ksft_print_msg("Cachestat (after fsync) returned non-zero.\n");
+ ret = false;
+ goto out1;
+ }
+ }
+ }
+
+out1:
+ close(fd);
+
+ if (create)
+ remove(filename);
+out:
+ return ret;
+}
+
+bool test_cachestat_shmem(void)
+{
+ size_t PS = sysconf(_SC_PAGESIZE);
+ size_t filesize = PS * 512 * 2; /* 2 2MB huge pages */
+ int syscall_ret;
+ size_t compute_len = PS * 512;
+ struct cachestat_range cs_range = { PS, compute_len };
+ char *filename = "tmpshmcstat";
+ struct cachestat cs;
+ bool ret = true;
+ unsigned long num_pages = compute_len / PS;
+ int fd = shm_open(filename, O_CREAT | O_RDWR, 0600);
+
+ if (fd < 0) {
+ ksft_print_msg("Unable to create shmem file.\n");
+ ret = false;
+ goto out;
+ }
+
+ if (ftruncate(fd, filesize)) {
+ ksft_print_msg("Unable to trucate shmem file.\n");
+ ret = false;
+ goto close_fd;
+ }
+
+ if (!write_exactly(fd, filesize)) {
+ ksft_print_msg("Unable to write to shmem file.\n");
+ ret = false;
+ goto close_fd;
+ }
+
+ syscall_ret = syscall(cachestat_nr, fd, &cs_range, &cs, 0);
+
+ if (syscall_ret) {
+ ksft_print_msg("Cachestat returned non-zero.\n");
+ ret = false;
+ goto close_fd;
+ } else {
+ print_cachestat(&cs);
+ if (cs.nr_cache + cs.nr_evicted != num_pages) {
+ ksft_print_msg(
+ "Total number of cached and evicted pages is off.\n");
+ ret = false;
+ }
+ }
+
+close_fd:
+ shm_unlink(filename);
+out:
+ return ret;
+}
+
+int main(void)
+{
+ int ret = 0;
+
+ for (int i = 0; i < 5; i++) {
+ const char *dev_filename = dev_files[i];
+
+ if (test_cachestat(dev_filename, false, false, false,
+ 4, O_RDONLY, 0400))
+ ksft_test_result_pass("cachestat works with %s\n", dev_filename);
+ else {
+ ksft_test_result_fail("cachestat fails with %s\n", dev_filename);
+ ret = 1;
+ }
+ }
+
+ if (test_cachestat("tmpfilecachestat", true, true,
+ true, 4, O_CREAT | O_RDWR, 0400 | 0600))
+ ksft_test_result_pass("cachestat works with a normal file\n");
+ else {
+ ksft_test_result_fail("cachestat fails with normal file\n");
+ ret = 1;
+ }
+
+ if (test_cachestat_shmem())
+ ksft_test_result_pass("cachestat works with a shmem file\n");
+ else {
+ ksft_test_result_fail("cachestat fails with a shmem file\n");
+ ret = 1;
+ }
+
+ return ret;
+}