aboutsummaryrefslogtreecommitdiff
path: root/lib/libc
diff options
context:
space:
mode:
authorKyle Evans <kevans@FreeBSD.org>2020-12-31 18:30:43 +0000
committerKyle Evans <kevans@FreeBSD.org>2020-12-31 18:31:54 +0000
commit1fc421287d5ddbcfba99412cf968ee3490383fe7 (patch)
tree2d172bbb13530854948cc810445d799974f84840 /lib/libc
parent9e1281eabafa4aaf84828e70488c1802717b59af (diff)
downloadsrc-1fc421287d5ddbcfba99412cf968ee3490383fe7.tar.gz
src-1fc421287d5ddbcfba99412cf968ee3490383fe7.zip
libc: tests: add some tests for cpuset(2)
The cpuset(2) tests should be run as root (require.user properly set) with >= 3 cpus for maximum coverage. All tests that want to modify the cpuset don't assume any particular cpu layout (i.e. the first cpu may not be 0, the last may not be first + count) and the following scenarios are tested: 1.) newset: basic execute cpuset() to grab a new cpuset, make sure the assigned cpuset then has a different ID. 2.) transient: create a new cpuset then assign the process its original cpuset, ensuring that the one we created is now gone. 3.) deadlk: test assigning an anonymous mask, then resetting the process base affinity with 1-cpu overlap w.r.t. the anonymous mask and with 0-cpu overlap w.r.t. the anonymous mask. 4.) jail_attach_newbase: process attaches to a jail with its own cpuset+mask (e.g. cpuset -c -l 1,2 jail -c path=/ command=/bin/sh) 5.) jail_attach_newbase_plain: process attaches to a jail with its own cpuset (e.g. cpuset -c jail -c path=/ command=/bin/sh) 6.) jail_attach_prevbase: process attaches to a jail with the containing jail's root cpuset (e.g. jail -c path=/ command=/bin/sh) 7.) jail_attach_plain: process attaches to a jail with the containing jail's root cpuset+mask. 8.) badparent: creates a new cpuset and modifies the anonymous thread mask, then setid's back to the original and checks that cpuset_getid() returns the expected set. Differential Revision: https://reviews.freebsd.org/D27307
Diffstat (limited to 'lib/libc')
-rw-r--r--lib/libc/tests/sys/Makefile1
-rw-r--r--lib/libc/tests/sys/cpuset_test.c493
2 files changed, 494 insertions, 0 deletions
diff --git a/lib/libc/tests/sys/Makefile b/lib/libc/tests/sys/Makefile
index 1aa0443afd8b..e4a1bf30a8f9 100644
--- a/lib/libc/tests/sys/Makefile
+++ b/lib/libc/tests/sys/Makefile
@@ -7,6 +7,7 @@ PACKAGE= tests
.if ${MACHINE_CPUARCH} != "aarch64" && ${MACHINE_CPUARCH} != "riscv"
ATF_TESTS_C+= brk_test
.endif
+ATF_TESTS_C+= cpuset_test
ATF_TESTS_C+= queue_test
ATF_TESTS_C+= sendfile_test
diff --git a/lib/libc/tests/sys/cpuset_test.c b/lib/libc/tests/sys/cpuset_test.c
new file mode 100644
index 000000000000..d6dd69e7e3c1
--- /dev/null
+++ b/lib/libc/tests/sys/cpuset_test.c
@@ -0,0 +1,493 @@
+/*-
+ * SPDX-License-Identifier: BSD-2-Clause
+ *
+ * Copyright (c) 2020 Kyle Evans <kevans@FreeBSD.org>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD");
+
+#include <sys/param.h>
+#include <sys/cpuset.h>
+#include <sys/jail.h>
+#include <sys/socket.h>
+#include <sys/uio.h>
+#include <sys/wait.h>
+
+#include <errno.h>
+#include <stdio.h>
+#include <unistd.h>
+
+#include <atf-c.h>
+
+#define SP_PARENT 0
+#define SP_CHILD 1
+
+struct jail_test_info {
+ cpuset_t jail_tidmask;
+ cpusetid_t jail_cpuset;
+ cpusetid_t jail_child_cpuset;
+};
+
+struct jail_test_cb_params {
+ struct jail_test_info info;
+ cpuset_t mask;
+ cpusetid_t rootid;
+ cpusetid_t setid;
+};
+
+typedef void (*jail_test_cb)(struct jail_test_cb_params *);
+
+#define FAILURE_JAIL 42
+#define FAILURE_MASK 43
+#define FAILURE_JAILSET 44
+#define FAILURE_PIDSET 45
+#define FAILURE_SEND 46
+
+static const char *
+do_jail_errstr(int error)
+{
+
+ switch (error) {
+ case FAILURE_JAIL:
+ return ("jail_set(2) failed");
+ case FAILURE_MASK:
+ return ("Failed to get the thread cpuset mask");
+ case FAILURE_JAILSET:
+ return ("Failed to get the jail setid");
+ case FAILURE_PIDSET:
+ return ("Failed to get the pid setid");
+ case FAILURE_SEND:
+ return ("Failed to send(2) cpuset information");
+ default:
+ return (NULL);
+ }
+}
+
+static void
+skip_ltncpu(int ncpu, cpuset_t *mask)
+{
+
+ CPU_ZERO(mask);
+ ATF_REQUIRE_EQ(0, cpuset_getaffinity(CPU_LEVEL_CPUSET, CPU_WHICH_PID,
+ -1, sizeof(*mask), mask));
+ if (CPU_COUNT(mask) < ncpu)
+ atf_tc_skip("Test requires %d or more cores.", ncpu);
+}
+
+ATF_TC(newset);
+ATF_TC_HEAD(newset, tc)
+{
+ atf_tc_set_md_var(tc, "descr", "Test cpuset(2)");
+}
+ATF_TC_BODY(newset, tc)
+{
+ cpusetid_t nsetid, setid, qsetid;
+
+ /* Obtain our initial set id. */
+ ATF_REQUIRE_EQ(0, cpuset_getid(CPU_LEVEL_CPUSET, CPU_WHICH_TID, -1,
+ &setid));
+
+ /* Create a new one. */
+ ATF_REQUIRE_EQ(0, cpuset(&nsetid));
+ ATF_CHECK(nsetid != setid);
+
+ /* Query id again, make sure it's equal to the one we just got. */
+ ATF_REQUIRE_EQ(0, cpuset_getid(CPU_LEVEL_CPUSET, CPU_WHICH_TID, -1,
+ &qsetid));
+ ATF_CHECK_EQ(nsetid, qsetid);
+}
+
+ATF_TC(transient);
+ATF_TC_HEAD(transient, tc)
+{
+ atf_tc_set_md_var(tc, "descr",
+ "Test that transient cpusets are freed.");
+}
+ATF_TC_BODY(transient, tc)
+{
+ cpusetid_t isetid, scratch, setid;
+
+ ATF_REQUIRE_EQ(0, cpuset_getid(CPU_LEVEL_CPUSET, CPU_WHICH_PID, -1,
+ &isetid));
+
+ ATF_REQUIRE_EQ(0, cpuset(&setid));
+ ATF_REQUIRE_EQ(0, cpuset_getid(CPU_LEVEL_CPUSET, CPU_WHICH_CPUSET,
+ setid, &scratch));
+
+ /*
+ * Return back to our initial cpuset; the kernel should free the cpuset
+ * we just created.
+ */
+ ATF_REQUIRE_EQ(0, cpuset_setid(CPU_WHICH_PID, -1, isetid));
+ ATF_REQUIRE_EQ(-1, cpuset_getid(CPU_LEVEL_CPUSET, CPU_WHICH_CPUSET,
+ setid, &scratch));
+ ATF_CHECK_EQ(ESRCH, errno);
+}
+
+ATF_TC(deadlk);
+ATF_TC_HEAD(deadlk, tc)
+{
+ atf_tc_set_md_var(tc, "descr", "Test against disjoint cpusets.");
+ atf_tc_set_md_var(tc, "require.user", "root");
+}
+ATF_TC_BODY(deadlk, tc)
+{
+ cpusetid_t setid;
+ cpuset_t dismask, mask, omask;
+ int fcpu, i, found, ncpu, second;
+
+ /* Make sure we have 3 cpus, so we test partial overlap. */
+ skip_ltncpu(3, &omask);
+
+ ATF_REQUIRE_EQ(0, cpuset(&setid));
+ CPU_ZERO(&mask);
+ CPU_ZERO(&dismask);
+ CPU_COPY(&omask, &mask);
+ CPU_COPY(&omask, &dismask);
+ fcpu = CPU_FFS(&mask);
+ ncpu = CPU_COUNT(&mask);
+
+ /*
+ * Turn off all but the first two for mask, turn off the first for
+ * dismask and turn them all off for both after the third.
+ */
+ for (i = fcpu - 1, found = 0; i < CPU_MAXSIZE && found != ncpu; i++) {
+ if (CPU_ISSET(i, &omask)) {
+ found++;
+ if (found == 1) {
+ CPU_CLR(i, &dismask);
+ } else if (found == 2) {
+ second = i;
+ } else if (found >= 3) {
+ CPU_CLR(i, &mask);
+ if (found > 3)
+ CPU_CLR(i, &dismask);
+ }
+ }
+ }
+
+ ATF_REQUIRE_EQ(0, cpuset_setaffinity(CPU_LEVEL_CPUSET, CPU_WHICH_PID,
+ -1, sizeof(mask), &mask));
+
+ /* Must be a strict subset! */
+ ATF_REQUIRE_EQ(-1, cpuset_setaffinity(CPU_LEVEL_WHICH, CPU_WHICH_TID,
+ -1, sizeof(dismask), &dismask));
+ ATF_REQUIRE_EQ(EINVAL, errno);
+
+ /*
+ * We'll set our anonymous set to the 0,1 set that currently matches
+ * the process. If we then set the process to the 1,2 set that's in
+ * dismask, we should then personally be restricted down to the single
+ * overlapping CPOU.
+ */
+ ATF_REQUIRE_EQ(0, cpuset_setaffinity(CPU_LEVEL_WHICH, CPU_WHICH_TID,
+ -1, sizeof(mask), &mask));
+ ATF_REQUIRE_EQ(0, cpuset_setaffinity(CPU_LEVEL_CPUSET, CPU_WHICH_PID,
+ -1, sizeof(dismask), &dismask));
+ ATF_REQUIRE_EQ(0, cpuset_getaffinity(CPU_LEVEL_WHICH, CPU_WHICH_TID,
+ -1, sizeof(mask), &mask));
+ ATF_REQUIRE_EQ(1, CPU_COUNT(&mask));
+ ATF_REQUIRE(CPU_ISSET(second, &mask));
+
+ /*
+ * Finally, clearing the overlap and attempting to set the process
+ * cpuset to a completely disjoint mask should fail, because this
+ * process will then not have anything to run on.
+ */
+ CPU_CLR(second, &dismask);
+ ATF_REQUIRE_EQ(-1, cpuset_setaffinity(CPU_LEVEL_CPUSET, CPU_WHICH_PID,
+ -1, sizeof(dismask), &dismask));
+ ATF_REQUIRE_EQ(EDEADLK, errno);
+}
+
+static int
+do_jail(int sock)
+{
+ struct jail_test_info info;
+ struct iovec iov[2];
+ char *name;
+ int error;
+
+ if (asprintf(&name, "cpuset_%d", getpid()) == -1)
+ _exit(42);
+
+ iov[0].iov_base = "name";
+ iov[0].iov_len = 5;
+
+ iov[1].iov_base = name;
+ iov[1].iov_len = strlen(name) + 1;
+
+ if (jail_set(iov, 2, JAIL_CREATE | JAIL_ATTACH) < 0)
+ return (FAILURE_JAIL);
+
+ /* Record parameters, kick them over, then make a swift exit. */
+ CPU_ZERO(&info.jail_tidmask);
+ error = cpuset_getaffinity(CPU_LEVEL_WHICH, CPU_WHICH_TID,
+ -1, sizeof(info.jail_tidmask), &info.jail_tidmask);
+ if (error != 0)
+ return (FAILURE_MASK);
+
+ error = cpuset_getid(CPU_LEVEL_ROOT, CPU_WHICH_TID, -1,
+ &info.jail_cpuset);
+ if (error != 0)
+ return (FAILURE_JAILSET);
+ error = cpuset_getid(CPU_LEVEL_CPUSET, CPU_WHICH_TID, -1,
+ &info.jail_child_cpuset);
+ if (error != 0)
+ return (FAILURE_PIDSET);
+ if (send(sock, &info, sizeof(info), 0) != sizeof(info))
+ return (FAILURE_SEND);
+ return (0);
+}
+
+static void
+do_jail_test(int ncpu, bool newset, jail_test_cb prologue,
+ jail_test_cb epilogue)
+{
+ struct jail_test_cb_params cbp;
+ const char *errstr;
+ pid_t pid;
+ int error, sock, sockpair[2], status;
+
+ memset(&cbp.info, '\0', sizeof(cbp.info));
+
+ skip_ltncpu(ncpu, &cbp.mask);
+
+ ATF_REQUIRE_EQ(0, cpuset_getid(CPU_LEVEL_ROOT, CPU_WHICH_PID, -1,
+ &cbp.rootid));
+ if (newset)
+ ATF_REQUIRE_EQ(0, cpuset(&cbp.setid));
+ else
+ ATF_REQUIRE_EQ(0, cpuset_getid(CPU_LEVEL_CPUSET, CPU_WHICH_PID,
+ -1, &cbp.setid));
+ /* Special hack for prison0; it uses cpuset 1 as the root. */
+ if (cbp.rootid == 0)
+ cbp.rootid = 1;
+
+ /* Not every test needs early setup. */
+ if (prologue != NULL)
+ (*prologue)(&cbp);
+
+ ATF_REQUIRE_EQ(0, socketpair(PF_UNIX, SOCK_STREAM, 0, sockpair));
+ ATF_REQUIRE((pid = fork()) != -1);
+
+ if (pid == 0) {
+ /* Child */
+ close(sockpair[SP_PARENT]);
+ sock = sockpair[SP_CHILD];
+
+ _exit(do_jail(sock));
+ } else {
+ /* Parent */
+ sock = sockpair[SP_PARENT];
+ close(sockpair[SP_CHILD]);
+
+ while ((error = waitpid(pid, &status, 0)) == -1 &&
+ errno == EINTR) {
+ }
+
+ ATF_REQUIRE_EQ(sizeof(cbp.info), recv(sock, &cbp.info,
+ sizeof(cbp.info), 0));
+
+ /* Sanity check the exit info. */
+ ATF_REQUIRE_EQ(pid, error);
+ ATF_REQUIRE(WIFEXITED(status));
+ if (WEXITSTATUS(status) != 0) {
+ errstr = do_jail_errstr(WEXITSTATUS(status));
+ if (errstr != NULL)
+ atf_tc_fail("%s", errstr);
+ else
+ atf_tc_fail("Unknown error '%d'",
+ WEXITSTATUS(status));
+ }
+
+ epilogue(&cbp);
+ }
+}
+
+static void
+jail_attach_mutate_pro(struct jail_test_cb_params *cbp)
+{
+ cpuset_t *mask;
+ int count;
+
+ mask = &cbp->mask;
+
+ /* Knock out the first cpu. */
+ count = CPU_COUNT(mask);
+ CPU_CLR(CPU_FFS(mask) - 1, mask);
+ ATF_REQUIRE_EQ(count - 1, CPU_COUNT(mask));
+ ATF_REQUIRE_EQ(0, cpuset_setaffinity(CPU_LEVEL_WHICH, CPU_WHICH_TID,
+ -1, sizeof(*mask), mask));
+}
+
+static void
+jail_attach_newbase_epi(struct jail_test_cb_params *cbp)
+{
+ struct jail_test_info *info;
+ cpuset_t *mask;
+
+ info = &cbp->info;
+ mask = &cbp->mask;
+
+ /*
+ * The rootid test has been thrown in because a bug was discovered
+ * where any newly derived cpuset during attach would be parented to
+ * the wrong cpuset. Otherwise, we should observe that a new cpuset
+ * has been created for this process.
+ */
+ ATF_REQUIRE(info->jail_cpuset != cbp->rootid);
+ ATF_REQUIRE(info->jail_cpuset != cbp->setid);
+ ATF_REQUIRE(info->jail_cpuset != info->jail_child_cpuset);
+ ATF_REQUIRE_EQ(0, CPU_CMP(mask, &info->jail_tidmask));
+}
+
+ATF_TC(jail_attach_newbase);
+ATF_TC_HEAD(jail_attach_newbase, tc)
+{
+ atf_tc_set_md_var(tc, "descr",
+ "Test jail attachment effect on affinity with a new base cpuset.");
+ atf_tc_set_md_var(tc, "require.user", "root");
+}
+ATF_TC_BODY(jail_attach_newbase, tc)
+{
+
+ /* Need >= 2 cpus to test restriction. */
+ do_jail_test(2, true, &jail_attach_mutate_pro,
+ &jail_attach_newbase_epi);
+}
+
+ATF_TC(jail_attach_newbase_plain);
+ATF_TC_HEAD(jail_attach_newbase_plain, tc)
+{
+ atf_tc_set_md_var(tc, "descr",
+ "Test jail attachment effect on affinity with a new, unmodified base cpuset.");
+ atf_tc_set_md_var(tc, "require.user", "root");
+}
+ATF_TC_BODY(jail_attach_newbase_plain, tc)
+{
+
+ do_jail_test(2, true, NULL, &jail_attach_newbase_epi);
+}
+
+/*
+ * Generic epilogue for tests that are expecting to use the jail's root cpuset
+ * with their own mask, whether that's been modified or not.
+ */
+static void
+jail_attach_jset_epi(struct jail_test_cb_params *cbp)
+{
+ struct jail_test_info *info;
+ cpuset_t *mask;
+
+ info = &cbp->info;
+ mask = &cbp->mask;
+
+ ATF_REQUIRE(info->jail_cpuset != cbp->setid);
+ ATF_REQUIRE_EQ(info->jail_cpuset, info->jail_child_cpuset);
+ ATF_REQUIRE_EQ(0, CPU_CMP(mask, &info->jail_tidmask));
+}
+
+ATF_TC(jail_attach_prevbase);
+ATF_TC_HEAD(jail_attach_prevbase, tc)
+{
+ atf_tc_set_md_var(tc, "descr",
+ "Test jail attachment effect on affinity without a new base.");
+ atf_tc_set_md_var(tc, "require.user", "root");
+}
+ATF_TC_BODY(jail_attach_prevbase, tc)
+{
+
+ do_jail_test(2, false, &jail_attach_mutate_pro, &jail_attach_jset_epi);
+}
+
+static void
+jail_attach_plain_pro(struct jail_test_cb_params *cbp)
+{
+
+ if (cbp->setid != cbp->rootid)
+ atf_tc_skip("Must be running with the root cpuset.");
+}
+
+ATF_TC(jail_attach_plain);
+ATF_TC_HEAD(jail_attach_plain, tc)
+{
+ atf_tc_set_md_var(tc, "descr",
+ "Test jail attachment effect on affinity without specialization.");
+ atf_tc_set_md_var(tc, "require.user", "root");
+}
+ATF_TC_BODY(jail_attach_plain, tc)
+{
+
+ do_jail_test(1, false, &jail_attach_plain_pro, &jail_attach_jset_epi);
+}
+
+ATF_TC(badparent);
+ATF_TC_HEAD(badparent, tc)
+{
+ atf_tc_set_md_var(tc, "descr",
+ "Test parent assignment when assigning a new cpuset.");
+}
+ATF_TC_BODY(badparent, tc)
+{
+ cpuset_t mask;
+ cpusetid_t finalsetid, origsetid, setid;
+
+ /* Need to mask off at least one CPU. */
+ skip_ltncpu(2, &mask);
+
+ ATF_REQUIRE_EQ(0, cpuset_getid(CPU_LEVEL_CPUSET, CPU_WHICH_TID, -1,
+ &origsetid));
+
+ ATF_REQUIRE_EQ(0, cpuset(&setid));
+
+ /*
+ * Mask off the first CPU, then we'll reparent ourselves to our original
+ * set.
+ */
+ CPU_CLR(CPU_FFS(&mask) - 1, &mask);
+ ATF_REQUIRE_EQ(0, cpuset_setaffinity(CPU_LEVEL_WHICH, CPU_WHICH_TID,
+ -1, sizeof(mask), &mask));
+
+ ATF_REQUIRE_EQ(0, cpuset_setid(CPU_WHICH_PID, -1, origsetid));
+ ATF_REQUIRE_EQ(0, cpuset_getid(CPU_LEVEL_CPUSET, CPU_WHICH_TID, -1,
+ &finalsetid));
+
+ ATF_REQUIRE_EQ(finalsetid, origsetid);
+}
+
+ATF_TP_ADD_TCS(tp)
+{
+
+ ATF_TP_ADD_TC(tp, newset);
+ ATF_TP_ADD_TC(tp, transient);
+ ATF_TP_ADD_TC(tp, deadlk);
+ ATF_TP_ADD_TC(tp, jail_attach_newbase);
+ ATF_TP_ADD_TC(tp, jail_attach_newbase_plain);
+ ATF_TP_ADD_TC(tp, jail_attach_prevbase);
+ ATF_TP_ADD_TC(tp, jail_attach_plain);
+ ATF_TP_ADD_TC(tp, badparent);
+ return (atf_no_error());
+}