// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES
*
* Exercise a priority inversion with the owner and donor first pinned to the
* same CPU, then with each on a different CPU. A high-priority donor blocks on
* a mutex held by a low-priority owner while one medium-priority contender per
* available CPU keeps the system busy. A weighted-vruntime BPF scheduler runs
* both CPU placement configurations with SCX_OPS_ENQ_BLOCKED first disabled
* and then enabled. The test validates blocked-donor admission and reports the
* average mutex hold and wait times, plus their enabled-minus-disabled deltas,
* for each configuration. The timing data is informational.
*
* CONFIG_SCHED_PROXY_EXEC=y is required to exercise the proxy-execution paths.
*/
#define _GNU_SOURCE
#include <bpf/bpf.h>
#include <errno.h>
#include <fcntl.h>
#include <limits.h>
#include <pthread.h>
#include <sched.h>
#include <scx/common.h>
#include <stdatomic.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/resource.h>
#include <sys/syscall.h>
#include <time.h>
#include <unistd.h>
#include "enq_blocked.bpf.skel.h"
#include "enq_blocked.h"
#include "scx_test.h"
#define MODULE_NAME "scx_enq_blocked_test"
#define MODULE_FILE "test_modules/" MODULE_NAME ".ko"
#define DEVICE_PATH "/dev/scx_enq_blocked"
#define WAIT_STEP_US 1000
#define WAIT_TIMEOUT_MS 2000
#define NR_WARMUP_TRIALS 1
#define NR_MEASURED_TRIALS 10
#define NR_TRIALS (NR_WARMUP_TRIALS + NR_MEASURED_TRIALS)
#define JOIN_TIMEOUT_MS ((NR_TRIALS + 1) * WAIT_TIMEOUT_MS)
#define OWNER_NICE 19
#define DONOR_NICE -20
#define CONTENDER_NICE 0
struct thread_ctx {
atomic_bool start_donor;
atomic_bool abort;
atomic_bool stop_contender;
atomic_bool measurement_ready;
atomic_int donor_pid;
atomic_int donor_completed;
int fd;
int donor_cpu;
int owner_cpu;
};
struct contender_ctx {
struct thread_ctx *thread_ctx;
atomic_int status;
int cpu;
};
struct run_result {
struct enq_blocked_stats stats;
u64 nr_blocked_enqueues;
u64 nr_blocked_enqueues_donor_cpu;
u64 nr_blocked_enqueues_owner_cpu;
u64 nr_blocked_enqueues_other_cpu;
u64 nr_blocked_wakeups;
};
static bool parse_bool(const char *value, bool *result)
{
if (!strcasecmp(value, "1") || !strcasecmp(value, "y") ||
!strcasecmp(value, "yes") || !strcasecmp(value, "on") ||
!strcasecmp(value, "true")) {
*result = true;
return true;
}
if (!strcasecmp(value, "0") || !strcasecmp(value, "n") ||
!strcasecmp(value, "no") || !strcasecmp(value, "off") ||
!strcasecmp(value, "false")) {
*result = false;
return true;
}
return false;
}
static bool cmdline_bool(const char *name, bool default_value)
{
char cmdline[4096], *newline, *saveptr = NULL, *token;
size_t name_len = strlen(name);
bool value = default_value;
FILE *file;
file = fopen("/proc/cmdline", "r");
if (!file)
return default_value;
if (!fgets(cmdline, sizeof(cmdline), file)) {
fclose(file);
return default_value;
}
fclose(file);
newline = strchr(cmdline, '\n');
if (newline)
*newline = '\0';
for (token = strtok_r(cmdline, " ", &saveptr); token;
token = strtok_r(NULL, " ", &saveptr)) {
bool parsed;
if (strncmp(token, name, name_len) || token[name_len] != '=')
continue;
if (parse_bool(token + name_len + 1, &parsed))
value = parsed;
}
return value;
}
static int module_path(char *path, size_t size)
{
ssize_t len;
char *slash;
len = readlink("/proc/self/exe", path, size - 1);
if (len < 0)
return -errno;
path[len] = '\0';
slash = strrchr(path, '/');
if (!slash)
return -EINVAL;
*slash = '\0';
if (snprintf(slash, size - (slash - path), "/%s", MODULE_FILE) >=
size - (slash - path))
return -ENAMETOOLONG;
return 0;
}
static int load_test_module(bool *loaded_here)
{
char path[PATH_MAX];
int fd, err;
err = module_path(path, sizeof(path));
if (err)
return err;
fd = open(path, O_RDONLY | O_CLOEXEC);
if (fd < 0)
return -errno;
if (syscall(SYS_finit_module, fd, "", 0)) {
err = errno;
close(fd);
if (err == EEXIST)
return 0;
return -err;
}
close(fd);
*loaded_here = true;
return 0;
}
static void unload_test_module(bool loaded_here)
{
if (loaded_here && syscall(SYS_delete_module, MODULE_NAME, O_NONBLOCK))
SCX_ERR("Failed to unload %s (%d)", MODULE_NAME, errno);
}
static int pin_to_cpu(int cpu)
{
cpu_set_t mask;
CPU_ZERO(&mask);
CPU_SET(cpu, &mask);
return sched_setaffinity(0, sizeof(mask), &mask) ? errno : 0;
}
static int select_test_cpus(bool cross_cpu, cpu_set_t *mask, int *donor_cpu,
int *owner_cpu)
{
int cpu, first = -1;
if (sched_getaffinity(0, sizeof(*mask), mask))
return -errno;
for (cpu = 0; cpu < CPU_SETSIZE; cpu++) {
if (!CPU_ISSET(cpu, mask))
continue;
if (first < 0) {
first = cpu;
if (!cross_cpu)
break;
} else {
*donor_cpu = first;
*owner_cpu = cpu;
return 0;
}
}
if (first < 0)
return -ENODEV;
if (cross_cpu)
return -EAGAIN;
*donor_cpu = first;
*owner_cpu = first;
return 0;
}
static int set_nice(int nice)
{
return setpriority(PRIO_PROCESS, 0, nice) ? errno : 0;
}
static bool wait_for_pid(atomic_int *pid)
{
int waited_ms;
for (waited_ms = 0; waited_ms < WAIT_TIMEOUT_MS; waited_ms++) {
if (atomic_load_explicit(pid, memory_order_acquire) > 0)
return true;
usleep(WAIT_STEP_US);
}
return false;
}
static int wait_for_contenders(struct contender_ctx *contenders,
size_t nr_contenders)
{
size_t i, nr_ready;
int status, waited_ms;
for (waited_ms = 0; waited_ms < WAIT_TIMEOUT_MS; waited_ms++) {
nr_ready = 0;
for (i = 0; i < nr_contenders; i++) {
status = atomic_load_explicit(&contenders[i].status,
memory_order_acquire);
if (status < 0)
return status;
if (status > 0)
nr_ready++;
}
if (nr_ready == nr_contenders)
return 1;
usleep(WAIT_STEP_US);
}
return -ETIMEDOUT;
}
static int wait_for_donor_state(struct thread_ctx *ctx, int expected)
{
int state, waited_ms;
for (waited_ms = 0; waited_ms < WAIT_TIMEOUT_MS; waited_ms++) {
state = ioctl(ctx->fd, ENQ_BLOCKED_IOCTL_DONOR_STATE);
if (state == expected)
return state;
if (state < 0 && errno != ENOENT)
return -errno;
usleep(WAIT_STEP_US);
}
return -ETIMEDOUT;
}
static bool wait_for_donor(struct thread_ctx *ctx, int trial)
{
int waited_ms;
for (waited_ms = 0; waited_ms < WAIT_TIMEOUT_MS; waited_ms++) {
if (atomic_load_explicit(&ctx->donor_completed,
memory_order_acquire) >= trial)
return true;
if (atomic_load_explicit(&ctx->abort, memory_order_relaxed))
return false;
usleep(WAIT_STEP_US);
}
return false;
}
static bool wait_for_measurement(struct thread_ctx *ctx)
{
while (!atomic_load_explicit(&ctx->measurement_ready,
memory_order_acquire) &&
!atomic_load_explicit(&ctx->abort, memory_order_relaxed))
sched_yield();
return !atomic_load_explicit(&ctx->abort, memory_order_relaxed);
}
static void *contender_fn(void *arg)
{
struct contender_ctx *contender = arg;
struct thread_ctx *ctx = contender->thread_ctx;
int err;
err = pin_to_cpu(contender->cpu);
if (!err)
err = set_nice(CONTENDER_NICE);
atomic_store_explicit(&contender->status, err ? -err : 1,
memory_order_release);
if (err)
return (void *)(uintptr_t)err;
while (!atomic_load_explicit(&ctx->stop_contender,
memory_order_relaxed))
;
return NULL;
}
static void *owner_fn(void *arg)
{
struct thread_ctx *ctx = arg;
int err, i;
err = pin_to_cpu(ctx->owner_cpu);
if (err)
return (void *)(uintptr_t)err;
err = set_nice(OWNER_NICE);
if (err)
return (void *)(uintptr_t)err;
for (i = 0; i < NR_TRIALS; i++) {
if (ioctl(ctx->fd, ENQ_BLOCKED_IOCTL_OWNER))
return (void *)(uintptr_t)errno;
if (!wait_for_donor(ctx, i + 1))
return (void *)(uintptr_t)ETIMEDOUT;
if (i + 1 == NR_WARMUP_TRIALS && !wait_for_measurement(ctx))
return NULL;
}
return NULL;
}
static int run_donor_trial(struct thread_ctx *ctx)
{
int waited_ms;
for (waited_ms = 0; waited_ms < WAIT_TIMEOUT_MS; waited_ms++) {
if (!ioctl(ctx->fd, ENQ_BLOCKED_IOCTL_DONOR))
return 0;
if (errno != EAGAIN)
return -errno;
usleep(WAIT_STEP_US);
}
return -ETIMEDOUT;
}
static void *donor_fn(void *arg)
{
struct thread_ctx *ctx = arg;
int err, i;
err = pin_to_cpu(ctx->donor_cpu);
if (err)
return (void *)(uintptr_t)err;
err = set_nice(DONOR_NICE);
if (err)
return (void *)(uintptr_t)err;
atomic_store_explicit(&ctx->donor_pid, syscall(SYS_gettid),
memory_order_release);
while (!atomic_load_explicit(&ctx->start_donor, memory_order_acquire) &&
!atomic_load_explicit(&ctx->abort, memory_order_relaxed))
sched_yield();
if (atomic_load_explicit(&ctx->abort, memory_order_relaxed))
return NULL;
for (i = 0; i < NR_TRIALS; i++) {
err = run_donor_trial(ctx);
if (err)
return (void *)(uintptr_t)-err;
atomic_store_explicit(&ctx->donor_completed, i + 1,
memory_order_release);
}
return NULL;
}
static void print_avg_time(const char *name, u64 total_ns, u64 samples)
{
u64 avg_ns = samples ? total_ns / samples : 0;
printf(" %s_avg_ns=%llu (%llu.%03llu ms, samples=%llu)\n", name,
(unsigned long long)avg_ns,
(unsigned long long)(avg_ns / 1000000),
(unsigned long long)((avg_ns / 1000) % 1000),
(unsigned long long)samples);
}
static void print_avg_delta(const char *name, u64 disabled_total,
u64 disabled_samples, u64 enabled_total,
u64 enabled_samples)
{
u64 disabled_avg, enabled_avg;
s64 delta_ns;
double delta_pct;
if (!disabled_samples || !enabled_samples)
return;
disabled_avg = disabled_total / disabled_samples;
enabled_avg = enabled_total / enabled_samples;
delta_ns = (s64)enabled_avg - (s64)disabled_avg;
delta_pct = disabled_avg ? 100.0 * delta_ns / disabled_avg : 0.0;
printf(" %s_delta_ns=%+lld (%+.2f%%)\n", name,
(long long)delta_ns, delta_pct);
}
static int join_thread(pthread_t thread, const struct timespec *deadline,
int *thread_err)
{
void *result;
int err;
err = pthread_timedjoin_np(thread, &result, deadline);
if (err)
return err;
*thread_err = (int)(uintptr_t)result;
return 0;
}
static void set_join_deadline(struct timespec *deadline)
{
clock_gettime(CLOCK_REALTIME, deadline);
deadline->tv_sec += JOIN_TIMEOUT_MS / 1000;
deadline->tv_nsec += (JOIN_TIMEOUT_MS % 1000) * 1000000;
if (deadline->tv_nsec >= 1000000000) {
deadline->tv_sec++;
deadline->tv_nsec -= 1000000000;
}
}
static enum scx_test_status setup(void **ctx)
{
struct enq_blocked *skel;
u64 flag;
skel = enq_blocked__open();
SCX_FAIL_IF(!skel, "Failed to open skel");
SCX_ENUM_INIT(skel);
flag = SCX_OPS_ENQ_BLOCKED;
if (!flag) {
enq_blocked__destroy(skel);
fprintf(stderr, "SKIP: SCX_OPS_ENQ_BLOCKED is unavailable\n");
return SCX_TEST_SKIP;
}
enq_blocked__destroy(skel);
*ctx = NULL;
return SCX_TEST_PASS;
}
static enum scx_test_status run_one(bool enq_blocked, bool cross_cpu,
struct run_result *result)
{
struct enq_blocked *skel;
struct thread_ctx thread_ctx = {};
struct contender_ctx *contender_ctxs = NULL;
struct bpf_link *link = NULL;
pthread_t owner, donor, *contenders = NULL;
struct timespec join_deadline;
cpu_set_t allowed_cpus;
bool module_loaded = false;
bool owner_started = false, donor_started = false;
bool join_timed_out = false;
bool proxy_enabled;
enum scx_test_status status = SCX_TEST_PASS;
int cpu, donor_pid, donor_state, err, thread_err;
size_t i, nr_contenders, nr_contenders_started = 0;
size_t nr_contenders_joined = 0;
u64 nr_blocked, nr_blocked_donor_cpu, nr_blocked_owner_cpu;
u64 nr_blocked_other_cpu, nr_blocked_wakeups;
struct enq_blocked_stats stats;
err = select_test_cpus(cross_cpu, &allowed_cpus, &thread_ctx.donor_cpu,
&thread_ctx.owner_cpu);
if (err == -EAGAIN) {
fprintf(stderr, "SKIP: cross-CPU case requires two allowed CPUs\n");
return SCX_TEST_SKIP;
}
if (err) {
SCX_ERR("Failed to select test CPUs (%d)", -err);
return SCX_TEST_FAIL;
}
nr_contenders = CPU_COUNT(&allowed_cpus);
contenders = calloc(nr_contenders, sizeof(*contenders));
contender_ctxs = calloc(nr_contenders, sizeof(*contender_ctxs));
if (!contenders || !contender_ctxs) {
SCX_ERR("Failed to allocate %zu contender threads", nr_contenders);
status = SCX_TEST_FAIL;
goto out_contenders;
}
skel = enq_blocked__open();
if (!skel) {
SCX_ERR("Failed to open skel");
status = SCX_TEST_FAIL;
goto out_contenders;
}
SCX_ENUM_INIT(skel);
skel->struct_ops.enq_blocked_ops->flags =
SCX_OPS_ENQ_LAST |
(enq_blocked ? SCX_OPS_ENQ_BLOCKED : 0);
if (enq_blocked__load(skel)) {
SCX_ERR("Failed to load skel");
status = SCX_TEST_FAIL;
goto out_skel;
}
err = load_test_module(&module_loaded);
if (err == -EPERM || err == -ENOENT) {
fprintf(stderr, "SKIP: cannot load mutex fixture (%d)\n", -err);
status = SCX_TEST_SKIP;
goto out_skel;
}
if (err) {
SCX_ERR("Failed to load mutex fixture (%d)", -err);
status = SCX_TEST_FAIL;
goto out_skel;
}
thread_ctx.fd = open(DEVICE_PATH, O_RDONLY | O_CLOEXEC);
if (thread_ctx.fd < 0) {
SCX_ERR("Failed to open %s (%d)", DEVICE_PATH, errno);
status = SCX_TEST_FAIL;
goto out_module;
}
err = ioctl(thread_ctx.fd, ENQ_BLOCKED_IOCTL_PROXY_SUPPORTED);
if (err < 0) {
SCX_ERR("Failed to query proxy-exec support (%d)", errno);
status = SCX_TEST_FAIL;
goto out_fd;
}
proxy_enabled = err && cmdline_bool("sched_proxy_exec", true);
if (!proxy_enabled) {
fprintf(stderr, "SKIP: proxy execution is not enabled\n");
status = SCX_TEST_SKIP;
goto out_fd;
}
if (ioctl(thread_ctx.fd, ENQ_BLOCKED_IOCTL_RESET_STATS)) {
SCX_ERR("Failed to reset mutex statistics (%d)", errno);
status = SCX_TEST_FAIL;
goto out_fd;
}
if (ioctl(thread_ctx.fd, ENQ_BLOCKED_IOCTL_PREP_ATTACH)) {
SCX_ERR("Failed to prepare scheduler attachment (%d)", errno);
status = SCX_TEST_FAIL;
goto out_fd;
}
err = pthread_create(&owner, NULL, owner_fn, &thread_ctx);
if (err) {
SCX_ERR("Failed to create owner thread (%d)", err);
status = SCX_TEST_FAIL;
goto out;
}
owner_started = true;
err = pthread_create(&donor, NULL, donor_fn, &thread_ctx);
if (err) {
SCX_ERR("Failed to create donor thread (%d)", err);
status = SCX_TEST_FAIL;
goto out;
}
donor_started = true;
if (!wait_for_pid(&thread_ctx.donor_pid)) {
SCX_ERR("Timed out waiting for donor thread");
status = SCX_TEST_FAIL;
goto out;
}
donor_pid = atomic_load_explicit(&thread_ctx.donor_pid,
memory_order_acquire);
skel->bss->donor_pid = donor_pid;
skel->data->donor_cpu = thread_ctx.donor_cpu;
skel->data->owner_cpu = thread_ctx.owner_cpu;
atomic_store_explicit(&thread_ctx.start_donor, true,
memory_order_release);
donor_state = ENQ_BLOCKED_DONOR_SLEEPING;
if (proxy_enabled)
donor_state |= ENQ_BLOCKED_DONOR_ON_RQ;
err = wait_for_donor_state(&thread_ctx, donor_state);
if (err < 0) {
SCX_ERR("Donor did not block before scheduler attachment (%d)", -err);
status = SCX_TEST_FAIL;
goto out;
}
link = bpf_map__attach_struct_ops(skel->maps.enq_blocked_ops);
if (!link) {
SCX_ERR("Failed to attach scheduler");
status = SCX_TEST_FAIL;
goto out;
}
/* Scheduler ownership changes start from a fully blocked donor. */
donor_state = ENQ_BLOCKED_DONOR_SLEEPING;
err = wait_for_donor_state(&thread_ctx, donor_state);
if (err < 0) {
SCX_ERR("Unexpected donor state after scheduler attachment (%d)",
-err);
status = SCX_TEST_FAIL;
goto out;
}
if (ioctl(thread_ctx.fd, ENQ_BLOCKED_IOCTL_ATTACH_DONE)) {
SCX_ERR("Failed to complete scheduler attachment (%d)", errno);
status = SCX_TEST_FAIL;
goto out;
}
i = 0;
for (cpu = 0; cpu < CPU_SETSIZE; cpu++) {
if (!CPU_ISSET(cpu, &allowed_cpus))
continue;
contender_ctxs[i].thread_ctx = &thread_ctx;
contender_ctxs[i].cpu = cpu;
atomic_init(&contender_ctxs[i].status, 0);
err = pthread_create(&contenders[i], NULL, contender_fn,
&contender_ctxs[i]);
if (err) {
SCX_ERR("Failed to create contender for CPU %d (%d)",
cpu, err);
status = SCX_TEST_FAIL;
goto out;
}
nr_contenders_started++;
i++;
}
err = wait_for_contenders(contender_ctxs, nr_contenders);
if (err != 1) {
SCX_ERR("Contender threads failed (%d)", -err);
status = SCX_TEST_FAIL;
goto out;
}
/*
* The first trial spans scheduler attachment and validates the state
* transition, but including it would skew scheduling latency. Exclude it
* from both the mutex and BPF enqueue measurements.
*/
if (!wait_for_donor(&thread_ctx, NR_WARMUP_TRIALS)) {
SCX_ERR("Timed out waiting for warm-up trial");
status = SCX_TEST_FAIL;
goto out;
}
if (ioctl(thread_ctx.fd, ENQ_BLOCKED_IOCTL_RESET_STATS)) {
SCX_ERR("Failed to reset mutex statistics after warm-up (%d)",
errno);
status = SCX_TEST_FAIL;
goto out;
}
skel->bss->nr_blocked_enqueues = 0;
skel->bss->nr_blocked_enqueues_donor_cpu = 0;
skel->bss->nr_blocked_enqueues_owner_cpu = 0;
skel->bss->nr_blocked_enqueues_other_cpu = 0;
skel->bss->nr_blocked_wakeups = 0;
atomic_store_explicit(&thread_ctx.measurement_ready, true,
memory_order_release);
out:
ioctl(thread_ctx.fd, ENQ_BLOCKED_IOCTL_ATTACH_DONE);
if (status != SCX_TEST_PASS) {
atomic_store_explicit(&thread_ctx.abort, true, memory_order_release);
atomic_store_explicit(&thread_ctx.start_donor, true,
memory_order_release);
atomic_store_explicit(&thread_ctx.measurement_ready, true,
memory_order_release);
}
set_join_deadline(&join_deadline);
if (donor_started) {
err = join_thread(donor, &join_deadline, &thread_err);
if (err == ETIMEDOUT) {
SCX_ERR("Timed out waiting for donor thread");
join_timed_out = true;
status = SCX_TEST_FAIL;
} else if (err) {
SCX_ERR("Failed to join donor thread (%d)", err);
status = SCX_TEST_FAIL;
} else {
donor_started = false;
if (thread_err) {
SCX_ERR("Donor thread failed (%d)", thread_err);
status = SCX_TEST_FAIL;
}
}
}
if (!join_timed_out && owner_started) {
err = join_thread(owner, &join_deadline, &thread_err);
if (err == ETIMEDOUT) {
SCX_ERR("Timed out waiting for owner thread");
join_timed_out = true;
status = SCX_TEST_FAIL;
} else if (err) {
SCX_ERR("Failed to join owner thread (%d)", err);
status = SCX_TEST_FAIL;
} else {
owner_started = false;
if (thread_err) {
SCX_ERR("Owner thread failed (%d)", thread_err);
status = SCX_TEST_FAIL;
}
}
}
atomic_store_explicit(&thread_ctx.stop_contender, true,
memory_order_release);
for (i = 0; !join_timed_out && i < nr_contenders_started; i++) {
err = join_thread(contenders[i], &join_deadline, &thread_err);
if (err == ETIMEDOUT) {
SCX_ERR("Timed out waiting for contender on CPU %d",
contender_ctxs[i].cpu);
join_timed_out = true;
status = SCX_TEST_FAIL;
} else if (err) {
SCX_ERR("Failed to join contender on CPU %d (%d)",
contender_ctxs[i].cpu, err);
status = SCX_TEST_FAIL;
} else {
nr_contenders_joined++;
if (thread_err) {
SCX_ERR("Contender on CPU %d failed (%d)",
contender_ctxs[i].cpu, thread_err);
status = SCX_TEST_FAIL;
}
}
}
/* Restore the fair scheduler before waiting for any stranded thread. */
if (join_timed_out) {
atomic_store_explicit(&thread_ctx.abort, true,
memory_order_release);
if (link) {
bpf_link__destroy(link);
link = NULL;
}
if (donor_started)
pthread_join(donor, NULL);
if (owner_started)
pthread_join(owner, NULL);
for (i = nr_contenders_joined;
i < nr_contenders_started; i++)
pthread_join(contenders[i], NULL);
}
if (ioctl(thread_ctx.fd, ENQ_BLOCKED_IOCTL_GET_STATS, &stats)) {
SCX_ERR("Failed to read mutex statistics (%d)", errno);
status = SCX_TEST_FAIL;
} else {
result->stats = stats;
printf("\n[topology=%s SCX_OPS_ENQ_BLOCKED=%s]\n",
cross_cpu ? "cross-cpu" : "same-cpu",
enq_blocked ? "enabled" : "disabled");
printf(" proxy_exec=%s\n",
proxy_enabled ? "enabled" : "disabled");
printf(" donor_cpu=%d\n", thread_ctx.donor_cpu);
printf(" owner_cpu=%d\n", thread_ctx.owner_cpu);
printf(" nr_contenders=%zu\n", nr_contenders);
printf(" measured_trials=%d\n", NR_MEASURED_TRIALS);
printf(" owner_nice=%d\n", OWNER_NICE);
printf(" donor_nice=%d\n", DONOR_NICE);
printf(" contender_nice=%d\n", CONTENDER_NICE);
print_avg_time("mutex_hold", stats.hold_time_ns, stats.nr_holds);
print_avg_time("mutex_wait", stats.wait_time_ns, stats.nr_waits);
if (stats.nr_holds != NR_MEASURED_TRIALS ||
stats.nr_waits != NR_MEASURED_TRIALS) {
SCX_ERR("Expected %d measured trials, got %llu holds and %llu waits",
NR_MEASURED_TRIALS,
(unsigned long long)stats.nr_holds,
(unsigned long long)stats.nr_waits);
status = SCX_TEST_FAIL;
}
}
nr_blocked = skel->bss->nr_blocked_enqueues;
nr_blocked_donor_cpu = skel->bss->nr_blocked_enqueues_donor_cpu;
nr_blocked_owner_cpu = skel->bss->nr_blocked_enqueues_owner_cpu;
nr_blocked_other_cpu = skel->bss->nr_blocked_enqueues_other_cpu;
nr_blocked_wakeups = skel->bss->nr_blocked_wakeups;
result->nr_blocked_enqueues = nr_blocked;
result->nr_blocked_enqueues_donor_cpu = nr_blocked_donor_cpu;
result->nr_blocked_enqueues_owner_cpu = nr_blocked_owner_cpu;
result->nr_blocked_enqueues_other_cpu = nr_blocked_other_cpu;
result->nr_blocked_wakeups = nr_blocked_wakeups;
printf(" nr_blocked_enqueues=%llu\n",
(unsigned long long)nr_blocked);
printf(" nr_blocked_enqueues_donor_cpu=%llu\n",
(unsigned long long)nr_blocked_donor_cpu);
printf(" nr_blocked_enqueues_owner_cpu=%llu\n",
(unsigned long long)nr_blocked_owner_cpu);
printf(" nr_blocked_enqueues_other_cpu=%llu\n",
(unsigned long long)nr_blocked_other_cpu);
printf(" nr_blocked_wakeups=%llu\n",
(unsigned long long)nr_blocked_wakeups);
if (status == SCX_TEST_PASS) {
if (enq_blocked && proxy_enabled && !nr_blocked) {
SCX_ERR("ops.enqueue() did not receive the blocked donor");
status = SCX_TEST_FAIL;
} else if ((!enq_blocked || !proxy_enabled) && nr_blocked) {
SCX_ERR("ops.enqueue() unexpectedly received %llu blocked donors",
(unsigned long long)nr_blocked);
status = SCX_TEST_FAIL;
} else if (nr_blocked_wakeups) {
SCX_ERR("Ordinary wakeups received %llu blocked enqueue flags",
(unsigned long long)nr_blocked_wakeups);
status = SCX_TEST_FAIL;
} else if (nr_blocked_other_cpu) {
SCX_ERR("Blocked donor had %llu enqueues on unexpected CPUs",
(unsigned long long)nr_blocked_other_cpu);
status = SCX_TEST_FAIL;
}
}
if (UEI_EXITED(skel, uei)) {
SCX_ERR("Scheduler exited unexpectedly (kind=%llu code=%lld)",
(unsigned long long)skel->data->uei.kind,
(long long)skel->data->uei.exit_code);
status = SCX_TEST_FAIL;
}
if (link)
bpf_link__destroy(link);
out_fd:
close(thread_ctx.fd);
out_module:
unload_test_module(module_loaded);
out_skel:
enq_blocked__destroy(skel);
out_contenders:
free(contender_ctxs);
free(contenders);
return status;
}
static enum scx_test_status run_topology(bool cross_cpu)
{
struct run_result disabled = {}, enabled = {};
enum scx_test_status status;
status = run_one(false, cross_cpu, &disabled);
if (status != SCX_TEST_PASS)
return status;
status = run_one(true, cross_cpu, &enabled);
if (status != SCX_TEST_PASS)
return status;
printf("\n[topology=%s delta: enabled - disabled]\n",
cross_cpu ? "cross-cpu" : "same-cpu");
print_avg_delta("mutex_hold", disabled.stats.hold_time_ns,
disabled.stats.nr_holds, enabled.stats.hold_time_ns,
enabled.stats.nr_holds);
print_avg_delta("mutex_wait", disabled.stats.wait_time_ns,
disabled.stats.nr_waits, enabled.stats.wait_time_ns,
enabled.stats.nr_waits);
return SCX_TEST_PASS;
}
static enum scx_test_status run(void *ctx)
{
enum scx_test_status status;
(void)ctx;
status = run_topology(false);
if (status != SCX_TEST_PASS)
return status;
status = run_topology(true);
if (status == SCX_TEST_SKIP)
return SCX_TEST_PASS;
return status;
}
struct scx_test enq_blocked = {
.name = "enq_blocked",
.description = "Verify proxy donor admission under CPU-wide contention",
.setup = setup,
.run = run,
};
REGISTER_SCX_TEST(&enq_blocked)