| Message ID | 20240129224542.162599-4-nphamcs@gmail.com (mailing list archive) |
|---|---|
| State | New |
| Headers | show |
| Series | fix and extend zswap kselftests | expand |
On Mon, Jan 29, 2024 at 02:45:42PM -0800, Nhat Pham wrote: > We recently encountered a kernel crash on the zswapin path in our > internal kernel, which went undetected because of a lack of test > coverage for this path. Add a selftest to cover this code path, > allocating more memories than the cgroup limit to trigger s/memories/memory > swapout/zswapout, then reading the pages back in memories several times. > > Also add a variant of this test that runs with zswap disabled, to verify > swapin correctness as well. > > Suggested-by: Rik van Riel <riel@surriel.com> > Signed-off-by: Nhat Pham <nphamcs@gmail.com> > --- > tools/testing/selftests/cgroup/test_zswap.c | 67 ++++++++++++++++++++- > 1 file changed, 65 insertions(+), 2 deletions(-) > > diff --git a/tools/testing/selftests/cgroup/test_zswap.c b/tools/testing/selftests/cgroup/test_zswap.c > index 32ce975b21d1..86231c86dc89 100644 > --- a/tools/testing/selftests/cgroup/test_zswap.c > +++ b/tools/testing/selftests/cgroup/test_zswap.c > @@ -60,17 +60,39 @@ static long get_zswpout(const char *cgroup) > return cg_read_key_long(cgroup, "memory.stat", "zswpout "); > } > > -static int allocate_bytes(const char *cgroup, void *arg) > +static int allocate_bytes_and_read(const char *cgroup, void *arg, bool read) > { > size_t size = (size_t)arg; > char *mem = (char *)malloc(size); > + int ret = 0; > > if (!mem) > return -1; > for (int i = 0; i < size; i += 4095) > mem[i] = 'a'; > + > + if (read) { > + /* cycle through the allocated memory to (z)swap in and out pages */ > + for (int t = 0; t < 5; t++) { What benefit does the iteration serve here? I would guess one iteration is enough to swap everything in at least once, no? > + for (int i = 0; i < size; i += 4095) { > + if (mem[i] != 'a') > + ret = -1; > + } > + } > + } > + > free(mem); > - return 0; > + return ret; > +} > + > +static int allocate_bytes(const char *cgroup, void *arg) > +{ > + return allocate_bytes_and_read(cgroup, arg, false); > +} > + > +static int read_bytes(const char *cgroup, void *arg) > +{ > + return allocate_bytes_and_read(cgroup, arg, true); > } I don't like how we reuse allocate_bytes_and_read(), we are not saving much. Let's keep allocate_bytes() as-is and add a separate helper. Also, I think allocate_and_read_bytes() is easier to read. > > static char *setup_test_group_1M(const char *root, const char *name) > @@ -133,6 +155,45 @@ static int test_zswap_usage(const char *root) > return ret; > } > > +/* Simple test to verify the (z)swapin code paths */ > +static int test_zswapin_size(const char *root, char *zswap_size) > +{ > + int ret = KSFT_FAIL; > + char *test_group; > + > + /* Set up */ > + test_group = cg_name(root, "zswapin_test"); > + if (!test_group) > + goto out; > + if (cg_create(test_group)) > + goto out; > + if (cg_write(test_group, "memory.max", "8M")) > + goto out; > + if (cg_write(test_group, "memory.zswap.max", zswap_size)) > + goto out; > + > + /* Allocate and read more than memory.max to trigger (z)swap in */ > + if (cg_run(test_group, read_bytes, (void *)MB(32))) > + goto out; > + > + ret = KSFT_PASS; > + > +out: > + cg_destroy(test_group); > + free(test_group); > + return ret; > +} > + > +static int test_swapin(const char *root) > +{ > + return test_zswapin_size(root, "0"); > +} Why are we testing the no zswap case? I am all for testing but it seems out of scope here. It would have been understandable if we are testing memory.zswap.max itself, but we are not doing that. FWIW, I think the tests here should really be separated from cgroup tests, but I understand why they were added here. There is a lot of testing for memcg interface and control for zswap, and a lot of nice helpers present.
On Mon, Jan 29, 2024 at 5:24 PM Yosry Ahmed <yosryahmed@google.com> wrote: > > On Mon, Jan 29, 2024 at 02:45:42PM -0800, Nhat Pham wrote: > > We recently encountered a kernel crash on the zswapin path in our > > internal kernel, which went undetected because of a lack of test > > coverage for this path. Add a selftest to cover this code path, > > allocating more memories than the cgroup limit to trigger > > s/memories/memory > > > swapout/zswapout, then reading the pages back in memories several times. > > > > Also add a variant of this test that runs with zswap disabled, to verify > > swapin correctness as well. > > > > Suggested-by: Rik van Riel <riel@surriel.com> > > Signed-off-by: Nhat Pham <nphamcs@gmail.com> > > --- > > tools/testing/selftests/cgroup/test_zswap.c | 67 ++++++++++++++++++++- > > 1 file changed, 65 insertions(+), 2 deletions(-) > > > > diff --git a/tools/testing/selftests/cgroup/test_zswap.c b/tools/testing/selftests/cgroup/test_zswap.c > > index 32ce975b21d1..86231c86dc89 100644 > > --- a/tools/testing/selftests/cgroup/test_zswap.c > > +++ b/tools/testing/selftests/cgroup/test_zswap.c > > @@ -60,17 +60,39 @@ static long get_zswpout(const char *cgroup) > > return cg_read_key_long(cgroup, "memory.stat", "zswpout "); > > } > > > > -static int allocate_bytes(const char *cgroup, void *arg) > > +static int allocate_bytes_and_read(const char *cgroup, void *arg, bool read) > > { > > size_t size = (size_t)arg; > > char *mem = (char *)malloc(size); > > + int ret = 0; > > > > if (!mem) > > return -1; > > for (int i = 0; i < size; i += 4095) > > mem[i] = 'a'; > > + > > + if (read) { > > + /* cycle through the allocated memory to (z)swap in and out pages */ > > + for (int t = 0; t < 5; t++) { > > What benefit does the iteration serve here? I would guess one iteration > is enough to swap everything in at least once, no? There might be data races etc. that might not appear in one iteration. Running multiple iterations increases the probability of these bugs cropping up. Admittedly, the same effect could, perhaps, also be achieved by running the same test multiple times, so this is not a hill I will die on :) This is just a bit more convenient - CI infra often runs these tests once every time a new kernel is built. > > > + for (int i = 0; i < size; i += 4095) { > > + if (mem[i] != 'a') > > + ret = -1; > > + } > > + } > > + } > > + > > free(mem); > > - return 0; > > + return ret; > > +} > > + > > +static int allocate_bytes(const char *cgroup, void *arg) > > +{ > > + return allocate_bytes_and_read(cgroup, arg, false); > > +} > > + > > +static int read_bytes(const char *cgroup, void *arg) > > +{ > > + return allocate_bytes_and_read(cgroup, arg, true); > > } > > I don't like how we reuse allocate_bytes_and_read(), we are not saving > much. Let's keep allocate_bytes() as-is and add a separate helper. Also, > I think allocate_and_read_bytes() is easier to read. Fair! > > > > > static char *setup_test_group_1M(const char *root, const char *name) > > @@ -133,6 +155,45 @@ static int test_zswap_usage(const char *root) > > return ret; > > } > > > > +/* Simple test to verify the (z)swapin code paths */ > > +static int test_zswapin_size(const char *root, char *zswap_size) > > +{ > > + int ret = KSFT_FAIL; > > + char *test_group; > > + > > + /* Set up */ > > + test_group = cg_name(root, "zswapin_test"); > > + if (!test_group) > > + goto out; > > + if (cg_create(test_group)) > > + goto out; > > + if (cg_write(test_group, "memory.max", "8M")) > > + goto out; > > + if (cg_write(test_group, "memory.zswap.max", zswap_size)) > > + goto out; > > + > > + /* Allocate and read more than memory.max to trigger (z)swap in */ > > + if (cg_run(test_group, read_bytes, (void *)MB(32))) > > + goto out; > > + > > + ret = KSFT_PASS; > > + > > +out: > > + cg_destroy(test_group); > > + free(test_group); > > + return ret; > > +} > > + > > +static int test_swapin(const char *root) > > +{ > > + return test_zswapin_size(root, "0"); > > +} > > Why are we testing the no zswap case? I am all for testing but it seems > out of scope here. It would have been understandable if we are testing > memory.zswap.max itself, but we are not doing that. Eh it's just by convenience. We already have the workload - any test for zswap can pretty much be turned into a test for swap by disabling zswap (and enabling swap), so I was trying to kill two birds with one stone and cover a bit more of the codebase. > > FWIW, I think the tests here should really be separated from cgroup > tests, but I understand why they were added here. There is a lot of > testing for memcg interface and control for zswap, and a lot of nice > helpers present. Yeah FWIW, I agree :) I wonder if there's an easy way to inherit helpers from one test suite to another. Some sort of kselftest dependency? Or maybe move these cgroup helpers up the hierarchy (so that it can be shared by multiple selftest suites). >
On Tue, Jan 30, 2024 at 10:31:24AM -0800, Nhat Pham wrote: > On Mon, Jan 29, 2024 at 5:24 PM Yosry Ahmed <yosryahmed@google.com> wrote: > > [..] > > > -static int allocate_bytes(const char *cgroup, void *arg) > > > +static int allocate_bytes_and_read(const char *cgroup, void *arg, bool read) > > > { > > > size_t size = (size_t)arg; > > > char *mem = (char *)malloc(size); > > > + int ret = 0; > > > > > > if (!mem) > > > return -1; > > > for (int i = 0; i < size; i += 4095) > > > mem[i] = 'a'; > > > + > > > + if (read) { > > > + /* cycle through the allocated memory to (z)swap in and out pages */ > > > + for (int t = 0; t < 5; t++) { > > > > What benefit does the iteration serve here? I would guess one iteration > > is enough to swap everything in at least once, no? > > There might be data races etc. that might not appear in one iteration. > Running multiple iterations increases the probability of these bugs > cropping up. Hmm this is a test running in a single process, and I assume the rest of the system would be idle (at least from a zswap perspective). Did the iterations actually catch problems in this scenario (not specifically in this test, but generally in similar testing)? > > Admittedly, the same effect could, perhaps, also be achieved by > running the same test multiple times, so this is not a hill I will die > on :) This is just a bit more convenient - CI infra often runs these > tests once every time a new kernel is built. > [..] > > > + > > > +static int test_swapin(const char *root) > > > +{ > > > + return test_zswapin_size(root, "0"); > > > +} > > > > Why are we testing the no zswap case? I am all for testing but it seems > > out of scope here. It would have been understandable if we are testing > > memory.zswap.max itself, but we are not doing that. > > Eh it's just by convenience. We already have the workload - any test > for zswap can pretty much be turned into a test for swap by disabling > zswap (and enabling swap), so I was trying to kill two birds with one > stone and cover a bit more of the codebase. We can check that no data is actually in zswap after test_zswapin_size(root, "0"), in which case it becomes more of a zswap test and we get a sanity check for memory.zswap.max == 0. WDYT? Perhaps we can rename it to test_swpain_nozswap() or so. > > > > > FWIW, I think the tests here should really be separated from cgroup > > tests, but I understand why they were added here. There is a lot of > > testing for memcg interface and control for zswap, and a lot of nice > > helpers present. > > Yeah FWIW, I agree :) I wonder if there's an easy way to inherit > helpers from one test suite to another. Some sort of kselftest > dependency? Or maybe move these cgroup helpers up the hierarchy (so > that it can be shared by multiple selftest suites). I am not fluent in kselftest so I can't claim to know the answer here. There are a lot of things to do testing-wise for zswap, but I am not asking anyone to do it because I don't have the time to do it myself. It would be nice though :)
diff --git a/tools/testing/selftests/cgroup/test_zswap.c b/tools/testing/selftests/cgroup/test_zswap.c index 32ce975b21d1..86231c86dc89 100644 --- a/tools/testing/selftests/cgroup/test_zswap.c +++ b/tools/testing/selftests/cgroup/test_zswap.c @@ -60,17 +60,39 @@ static long get_zswpout(const char *cgroup) return cg_read_key_long(cgroup, "memory.stat", "zswpout "); } -static int allocate_bytes(const char *cgroup, void *arg) +static int allocate_bytes_and_read(const char *cgroup, void *arg, bool read) { size_t size = (size_t)arg; char *mem = (char *)malloc(size); + int ret = 0; if (!mem) return -1; for (int i = 0; i < size; i += 4095) mem[i] = 'a'; + + if (read) { + /* cycle through the allocated memory to (z)swap in and out pages */ + for (int t = 0; t < 5; t++) { + for (int i = 0; i < size; i += 4095) { + if (mem[i] != 'a') + ret = -1; + } + } + } + free(mem); - return 0; + return ret; +} + +static int allocate_bytes(const char *cgroup, void *arg) +{ + return allocate_bytes_and_read(cgroup, arg, false); +} + +static int read_bytes(const char *cgroup, void *arg) +{ + return allocate_bytes_and_read(cgroup, arg, true); } static char *setup_test_group_1M(const char *root, const char *name) @@ -133,6 +155,45 @@ static int test_zswap_usage(const char *root) return ret; } +/* Simple test to verify the (z)swapin code paths */ +static int test_zswapin_size(const char *root, char *zswap_size) +{ + int ret = KSFT_FAIL; + char *test_group; + + /* Set up */ + test_group = cg_name(root, "zswapin_test"); + if (!test_group) + goto out; + if (cg_create(test_group)) + goto out; + if (cg_write(test_group, "memory.max", "8M")) + goto out; + if (cg_write(test_group, "memory.zswap.max", zswap_size)) + goto out; + + /* Allocate and read more than memory.max to trigger (z)swap in */ + if (cg_run(test_group, read_bytes, (void *)MB(32))) + goto out; + + ret = KSFT_PASS; + +out: + cg_destroy(test_group); + free(test_group); + return ret; +} + +static int test_swapin(const char *root) +{ + return test_zswapin_size(root, "0"); +} + +static int test_zswapin_no_limit(const char *root) +{ + return test_zswapin_size(root, "max"); +} + /* * When trying to store a memcg page in zswap, if the memcg hits its memory * limit in zswap, writeback should affect only the zswapped pages of that @@ -309,6 +370,8 @@ struct zswap_test { const char *name; } tests[] = { T(test_zswap_usage), + T(test_swapin), + T(test_zswapin_no_limit), T(test_no_kmem_bypass), T(test_no_invasive_cgroup_shrink), };
We recently encountered a kernel crash on the zswapin path in our internal kernel, which went undetected because of a lack of test coverage for this path. Add a selftest to cover this code path, allocating more memories than the cgroup limit to trigger swapout/zswapout, then reading the pages back in memories several times. Also add a variant of this test that runs with zswap disabled, to verify swapin correctness as well. Suggested-by: Rik van Riel <riel@surriel.com> Signed-off-by: Nhat Pham <nphamcs@gmail.com> --- tools/testing/selftests/cgroup/test_zswap.c | 67 ++++++++++++++++++++- 1 file changed, 65 insertions(+), 2 deletions(-)