diff --git a/tests/sys/kern/Makefile b/tests/sys/kern/Makefile index f4bf097f9420..e2702d202389 100644 --- a/tests/sys/kern/Makefile +++ b/tests/sys/kern/Makefile @@ -1,107 +1,108 @@ # $FreeBSD$ .include PACKAGE= tests TESTSRC= ${SRCTOP}/contrib/netbsd-tests/kernel .PATH: ${SRCTOP}/sys/kern TESTSDIR= ${TESTSBASE}/sys/kern ATF_TESTS_C+= basic_signal .if ${MACHINE_ARCH} != "i386" && ${MACHINE_ARCH} != "powerpc" && \ ${MACHINE_ARCH} != "powerpcspe" # No support for atomic_load_64 on i386 or (32-bit) powerpc ATF_TESTS_C+= kcov .endif ATF_TESTS_C+= kern_copyin ATF_TESTS_C+= kern_descrip_test ATF_TESTS_C+= fdgrowtable_test ATF_TESTS_C+= kill_zombie .if ${MK_OPENSSL} != "no" ATF_TESTS_C+= ktls_test .endif ATF_TESTS_C+= module_test ATF_TESTS_C+= ptrace_test TEST_METADATA.ptrace_test+= timeout="15" ATF_TESTS_C+= reaper +ATF_TESTS_C+= sched_affinity ATF_TESTS_C+= sigaltstack ATF_TESTS_C+= sigwait .if ${MACHINE_ARCH} != "i386" && ${MACHINE_ARCH:Mpowerpc*} == "" ATF_TESTS_C+= subr_physmem_test .endif PLAIN_TESTS_C+= subr_unit_test ATF_TESTS_C+= sysctl_kern_proc ATF_TESTS_C+= sys_getrandom ATF_TESTS_C+= unix_passfd_test ATF_TESTS_C+= unix_seqpacket_test TEST_METADATA.unix_seqpacket_test+= timeout="15" ATF_TESTS_C+= unix_socketpair_test ATF_TESTS_C+= waitpid_nohang ATF_TESTS_C+= pdeathsig ATF_TESTS_SH+= coredump_phnum_test ATF_TESTS_SH+= sonewconn_overflow TEST_METADATA.sonewconn_overflow+= required_programs="python" TEST_METADATA.sonewconn_overflow+= required_user="root" ATF_TESTS_SH+= sendfile_test ${PACKAGE}FILES+= sonewconn_overflow.py ${PACKAGE}FILESMODE_sonewconn_overflow.py=0555 BINDIR= ${TESTSDIR} PROGS+= coredump_phnum_helper PROGS+= pdeathsig_helper PROGS+= sendfile_helper CFLAGS.sys_getrandom+= -I${SRCTOP}/sys/contrib/zstd/lib LIBADD.sys_getrandom+= zstd LIBADD.sys_getrandom+= c LIBADD.sys_getrandom+= pthread LIBADD.ptrace_test+= pthread LIBADD.unix_seqpacket_test+= pthread LIBADD.kcov+= pthread LIBADD.ktls_test+= crypto LIBADD.sendfile_helper+= pthread LIBADD.fdgrowtable_test+= util pthread kvm procstat LIBADD.sigwait+= rt NETBSD_ATF_TESTS_C+= lockf_test NETBSD_ATF_TESTS_C+= mqueue_test NETBSD_ATF_TESTS_C+= sysv_test CFLAGS.mqueue_test+= -I${SRCTOP}/tests LIBADD.mqueue_test+= rt ATF_TESTS_C+= libkern_crc32 SRCS.libkern_crc32+= libkern_crc32.c .PATH: ${SRCTOP}/sys/libkern SRCS.libkern_crc32+= gsb_crc32.c CFLAGS.libkern_crc32+= -DTESTING .if ${MACHINE_ARCH} == "amd64" || ${MACHINE_ARCH} == "i386" .PATH: ${SRCTOP}/sys/libkern/x86 SRCS.libkern_crc32+= crc32_sse42.c .elif ${MACHINE_CPUARCH} == "aarch64" .PATH: ${SRCTOP}/sys/libkern/arm64 SRCS.libkern_crc32+= crc32c_armv8.S .endif CFLAGS.subr_physmem.c+= -D_WANT_FREEBSD_BITSET SRCS.subr_physmem_test+= subr_physmem_test.c subr_physmem.c # subr_unit.c contains functions whose prototypes lie in headers that cannot be # included in userland. But as far as subr_unit_test goes, they're effectively # static. So it's ok to disable -Wmissing-prototypes for this program. CFLAGS.subr_unit.c+= -Wno-missing-prototypes SRCS.subr_unit_test+= subr_unit.c WARNS?= 3 TESTS_SUBDIRS+= acct TESTS_SUBDIRS+= execve TESTS_SUBDIRS+= pipe .include .include diff --git a/tests/sys/kern/sched_affinity.c b/tests/sys/kern/sched_affinity.c new file mode 100644 index 000000000000..2237acf75f88 --- /dev/null +++ b/tests/sys/kern/sched_affinity.c @@ -0,0 +1,297 @@ +/*- + * Copyright (c) 2022 Dmitry Chagin + * + * SPDX-License-Identifier: BSD-2-Clause + */ +#include +__FBSDID("$FreeBSD$"); + +#include +#include +#include + +#include +#include + +#include + +static uint32_t maxcpuid; +static uint32_t maxcpus; +static uint32_t cpus; + +static uint32_t +support_getcpus(void) +{ + uint32_t val; + size_t sz = sizeof(val); + + ATF_REQUIRE(sysctlbyname("kern.smp.cpus", &val, &sz, NULL, 0) == 0); + return (val); +} + +static uint32_t +support_getmaxcpus(void) +{ + uint32_t val; + size_t sz = sizeof(val); + + ATF_REQUIRE(sysctlbyname("kern.smp.maxcpus", &val, &sz, NULL, 0) == 0); + return (val); +} + +static uint32_t +support_getmaxcpuid(void) +{ + cpuset_t *set; + int setsize, rv; + uint32_t i, id; + + for (i = 1; i < maxcpus; i++) { + setsize = CPU_ALLOC_SIZE(i); + set = CPU_ALLOC(i); + ATF_REQUIRE(set != NULL); + CPU_ZERO_S(i, set); + rv = cpuset_getaffinity(CPU_LEVEL_WHICH, CPU_WHICH_PID, + -1, setsize, set); + if (rv == 0) { + id = __BIT_FLS(i, set) - 1; + CPU_FREE(set); + break; + } + CPU_FREE(set); + } + ATF_REQUIRE(rv == 0); + return (id); +} + +ATF_TC_WITHOUT_HEAD(test_setinvalidcpu); +ATF_TC_BODY(test_setinvalidcpu, tc) +{ + size_t cpusetsize; + cpuset_t *set; + + cpusetsize = CPU_ALLOC_SIZE(maxcpuid + 1); + set = CPU_ALLOC(maxcpuid + 1); + ATF_REQUIRE(set != NULL); + CPU_ZERO_S(maxcpuid + 1, set); + CPU_SET_S(maxcpuid + 1, maxcpuid + 1, set); + CPU_SET_S(maxcpuid - 1, maxcpuid + 1, set); + ATF_REQUIRE(sched_setaffinity(0, cpusetsize, set) == 0); + CPU_FREE(set); + + cpusetsize = CPU_ALLOC_SIZE(maxcpus + 1); + set = CPU_ALLOC(maxcpus + 1); + ATF_REQUIRE(set != NULL); + CPU_ZERO_S(maxcpus + 1, set); + CPU_SET_S(maxcpuid + 1, maxcpus + 1, set); + CPU_SET_S(maxcpuid - 1, maxcpus + 1, set); + ATF_REQUIRE(cpuset_setaffinity(CPU_LEVEL_WHICH, CPU_WHICH_PID, + -1, cpusetsize, set) == -1); + ATF_REQUIRE_EQ(errno, EINVAL); + CPU_FREE(set); +} + +ATF_TC_WITHOUT_HEAD(test_setvalidcpu); +ATF_TC_BODY(test_setvalidcpu, tc) +{ + size_t cpusetsize; + cpuset_t *set; + int cpu; + + ATF_REQUIRE(maxcpuid < maxcpus); + cpu = maxcpuid > 1 ? maxcpuid - 1 : 0; + + cpusetsize = CPU_ALLOC_SIZE(maxcpus + 1); + set = CPU_ALLOC(maxcpus + 1); + ATF_REQUIRE(set != NULL); + CPU_ZERO_S(maxcpus + 1, set); + CPU_SET_S(cpu, maxcpus + 1, set); + ATF_REQUIRE(cpuset_setaffinity(CPU_LEVEL_WHICH, CPU_WHICH_PID, + -1, cpusetsize, set) == 0); + ATF_REQUIRE_EQ(cpu, sched_getcpu()); + CPU_FREE(set); +} + +ATF_TC_WITHOUT_HEAD(test_setzeroset1); +ATF_TC_BODY(test_setzeroset1, tc) +{ + size_t cpusetsize; + cpuset_t *set; + + cpusetsize = CPU_ALLOC_SIZE(maxcpuid + 1); + set = CPU_ALLOC(maxcpuid + 1); + ATF_REQUIRE(set != NULL); + CPU_ZERO_S(maxcpuid + 1, set); + ATF_REQUIRE(sched_setaffinity(0, cpusetsize, set) == -1); + ATF_REQUIRE_EQ(errno, EINVAL); + CPU_FREE(set); +} + +ATF_TC_WITHOUT_HEAD(test_setzeroset2); +ATF_TC_BODY(test_setzeroset2, tc) +{ + size_t cpusetsize; + cpuset_t *set; + + cpusetsize = CPU_ALLOC_SIZE(maxcpuid + 1); + set = CPU_ALLOC(maxcpuid + 1); + ATF_REQUIRE(set != NULL); + CPU_ZERO_S(maxcpuid + 1, set); + ATF_REQUIRE(cpuset_setaffinity(CPU_LEVEL_WHICH, CPU_WHICH_PID, + -1, cpusetsize, set) == -1); + ATF_REQUIRE_EQ(errno, EDEADLK); + CPU_FREE(set); +} + +ATF_TC_WITHOUT_HEAD(test_setmaxsetsize); +ATF_TC_BODY(test_setmaxsetsize, tc) +{ + size_t cpusetsize; + cpuset_t *set; + + cpusetsize = CPU_ALLOC_SIZE(maxcpus * 2); + set = CPU_ALLOC(maxcpus * 2); + ATF_REQUIRE(set != NULL); + CPU_ZERO_S(maxcpus * 2, set); + ATF_REQUIRE(CPU_COUNT_S(maxcpus * 2, set) == 0); + CPU_SET_S(0, maxcpus * 2, set); + ATF_REQUIRE(CPU_COUNT_S(maxcpus * 2, set) == 1); + ATF_REQUIRE(cpuset_setaffinity(CPU_LEVEL_WHICH, CPU_WHICH_PID, + -1, cpusetsize, set) == 0); + + CPU_ZERO_S(maxcpus * 2, set); + CPU_SET_S(maxcpuid, maxcpus * 2, set); + ATF_REQUIRE(cpuset_setaffinity(CPU_LEVEL_WHICH, CPU_WHICH_PID, + -1, cpusetsize, set) == 0); + + CPU_ZERO_S(maxcpus * 2, set); + CPU_SET_S(maxcpuid + 1, maxcpus * 2, set); + ATF_REQUIRE(cpuset_setaffinity(CPU_LEVEL_WHICH, CPU_WHICH_PID, + -1, cpusetsize, set) == -1); + ATF_REQUIRE_EQ(errno, EINVAL); + CPU_FREE(set); +} + +ATF_TC_WITHOUT_HEAD(test_setminsetsize); +ATF_TC_BODY(test_setminsetsize, tc) +{ + size_t cpusetsize = 1; + int8_t set; + + if (cpus <= 8) + return; + + set = 1; + ATF_REQUIRE(cpuset_setaffinity(CPU_LEVEL_WHICH, CPU_WHICH_PID, + -1, cpusetsize, (const cpuset_t *)&set) == 0); + set = 0; + ATF_REQUIRE(cpuset_setaffinity(CPU_LEVEL_WHICH, CPU_WHICH_PID, + -1, cpusetsize, (const cpuset_t *)&set) == -1); + ATF_REQUIRE_EQ(errno, EDEADLK); +} + +ATF_TC_WITHOUT_HEAD(test_getminsetsize); +ATF_TC_BODY(test_getminsetsize, tc) +{ + size_t cpusetsize = 1; + int8_t set = 0; + + if (cpus < 9) + return; + ATF_REQUIRE(cpuset_getaffinity(CPU_LEVEL_WHICH, CPU_WHICH_PID, + -1, cpusetsize, (cpuset_t *)&set) == -1); + ATF_REQUIRE_EQ(errno, ERANGE); +} + +ATF_TC_WITHOUT_HEAD(test_getsetsize); +ATF_TC_BODY(test_getsetsize, tc) +{ + size_t cpusetsize; + cpuset_t *set; + + cpusetsize = CPU_ALLOC_SIZE(maxcpuid + 1); + set = CPU_ALLOC(maxcpuid + 1); + ATF_REQUIRE(set != NULL); + CPU_ZERO_S(maxcpuid + 1, set); + ATF_REQUIRE(cpuset_getaffinity(CPU_LEVEL_WHICH, CPU_WHICH_PID, + -1, cpusetsize, set) == 0); + CPU_FREE(set); +} + +ATF_TC_WITHOUT_HEAD(test_schedgetsetsize); +ATF_TC_BODY(test_schedgetsetsize, tc) +{ + cpuset_t *set; + int cpusetsize; + + cpusetsize = CPU_ALLOC_SIZE(maxcpuid + 1); + set = CPU_ALLOC(maxcpuid + 1); + ATF_REQUIRE(set != NULL); + CPU_ZERO_S(maxcpuid + 1, set); + ATF_REQUIRE(sched_getaffinity(0, cpusetsize, set) == cpusetsize); + CPU_FREE(set); + + set = CPU_ALLOC(CPU_SETSIZE); + ATF_REQUIRE(set != NULL); + cpusetsize = CPU_ALLOC_SIZE(CPU_SETSIZE); + CPU_ZERO(set); + ATF_REQUIRE(sched_getaffinity(0, cpusetsize, set) == cpusetsize); + CPU_FREE(set); +} + +ATF_TC_WITHOUT_HEAD(test_holes); +ATF_TC_BODY(test_holes, tc) +{ + cpuset_t *set; + int cpusetsize; + + cpusetsize = CPU_ALLOC_SIZE(maxcpus * 2); + set = CPU_ALLOC(maxcpus * 2); + ATF_REQUIRE(set != NULL); + CPU_ZERO_S(maxcpus * 2, set); + ATF_REQUIRE(CPU_COUNT_S(maxcpus * 2, set) == 0); + CPU_SET_S(maxcpuid, maxcpus * 2, set); + ATF_REQUIRE(CPU_COUNT_S(maxcpus * 2, set) == 1); + ATF_REQUIRE(cpuset_setaffinity(CPU_LEVEL_WHICH, CPU_WHICH_PID, + -1, cpusetsize, set) == 0); + + CPU_ZERO_S(maxcpus * 2, set); + ATF_REQUIRE(CPU_COUNT_S(maxcpus * 2, set) == 0); + CPU_SET_S(maxcpuid + 1, maxcpus * 2, set); + ATF_REQUIRE(CPU_COUNT_S(maxcpus * 2, set) == 1); + ATF_REQUIRE(cpuset_setaffinity(CPU_LEVEL_WHICH, CPU_WHICH_PID, + -1, cpusetsize, set) == -1); + ATF_REQUIRE_EQ(errno, EINVAL); + + ATF_REQUIRE(CPU_COUNT_S(maxcpus * 2, set) == 1); + ATF_REQUIRE(cpuset_getaffinity(CPU_LEVEL_WHICH, CPU_WHICH_PID, + -1, cpusetsize, set) == 0); + ATF_REQUIRE(CPU_ISSET_S(maxcpuid + 1, maxcpus * 2, set) == false); + ATF_REQUIRE(CPU_ISSET_S(maxcpuid, maxcpus * 2, set) == true); + ATF_REQUIRE_EQ(maxcpuid, (uint32_t)sched_getcpu()); +} + +ATF_TP_ADD_TCS(tp) +{ + + cpus = support_getcpus(); + maxcpus = support_getmaxcpus(); + maxcpuid = support_getmaxcpuid(); + + ATF_TP_ADD_TC(tp, test_setinvalidcpu); + ATF_TP_ADD_TC(tp, test_setvalidcpu); + ATF_TP_ADD_TC(tp, test_setzeroset1); + ATF_TP_ADD_TC(tp, test_setzeroset2); + + ATF_TP_ADD_TC(tp, test_setminsetsize); + ATF_TP_ADD_TC(tp, test_setmaxsetsize); + + ATF_TP_ADD_TC(tp, test_getminsetsize); + ATF_TP_ADD_TC(tp, test_getsetsize); + + ATF_TP_ADD_TC(tp, test_schedgetsetsize); + + ATF_TP_ADD_TC(tp, test_holes); + + return (atf_no_error()); +}