mirror of
git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
synced 2025-09-04 20:19:47 +08:00
0922f54fdd
The dispatch path retries if the local DSQ is still empty after ops.dispatch() either dispatched or consumed a task. This is both out of necessity and for convenience. It has to retry because the dispatch path might lose the tasks to dequeue while the rq lock is released while trying to migrate tasks across CPUs, and the retry mechanism makes ops.dispatch() implementation easier as it only needs to make some forward progress each iteration. However, this makes it possible for ops.dispatch() to stall CPUs by repeatedly dispatching ineligible tasks. If all CPUs are stalled that way, the watchdog or sysrq handler can't run and the system can't be saved. Let's address the issue by breaking out of the dispatch loop after 32 iterations. It is unlikely but not impossible for ops.dispatch() to legitimately go over the iteration limit. We want to come back to the dispatch path in such cases as not doing so risks stalling the CPU by idling with runnable tasks pending. As the previous task is still current in balance_scx(), resched_curr() doesn't do anything - it will just get cleared. Let's instead use scx_kick_bpf() which will trigger reschedule after switching to the next task which will likely be the idle task. Signed-off-by: Tejun Heo <tj@kernel.org> Reviewed-by: David Vernet <dvernet@meta.com>
127 lines
3.5 KiB
C
127 lines
3.5 KiB
C
/* SPDX-License-Identifier: GPL-2.0 */
|
|
/*
|
|
* Copyright (c) 2022 Meta Platforms, Inc. and affiliates.
|
|
* Copyright (c) 2022 Tejun Heo <tj@kernel.org>
|
|
* Copyright (c) 2022 David Vernet <dvernet@meta.com>
|
|
*/
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <unistd.h>
|
|
#include <inttypes.h>
|
|
#include <signal.h>
|
|
#include <libgen.h>
|
|
#include <bpf/bpf.h>
|
|
#include <scx/common.h>
|
|
#include "scx_qmap.bpf.skel.h"
|
|
|
|
const char help_fmt[] =
|
|
"A simple five-level FIFO queue sched_ext scheduler.\n"
|
|
"\n"
|
|
"See the top-level comment in .bpf.c for more details.\n"
|
|
"\n"
|
|
"Usage: %s [-s SLICE_US] [-e COUNT] [-t COUNT] [-T COUNT] [-l COUNT] [-b COUNT]\n"
|
|
" [-d PID] [-D LEN] [-p] [-v]\n"
|
|
"\n"
|
|
" -s SLICE_US Override slice duration\n"
|
|
" -e COUNT Trigger scx_bpf_error() after COUNT enqueues\n"
|
|
" -t COUNT Stall every COUNT'th user thread\n"
|
|
" -T COUNT Stall every COUNT'th kernel thread\n"
|
|
" -l COUNT Trigger dispatch infinite looping after COUNT dispatches\n"
|
|
" -b COUNT Dispatch upto COUNT tasks together\n"
|
|
" -d PID Disallow a process from switching into SCHED_EXT (-1 for self)\n"
|
|
" -D LEN Set scx_exit_info.dump buffer length\n"
|
|
" -S Suppress qmap-specific debug dump\n"
|
|
" -p Switch only tasks on SCHED_EXT policy intead of all\n"
|
|
" -v Print libbpf debug messages\n"
|
|
" -h Display this help and exit\n";
|
|
|
|
static bool verbose;
|
|
static volatile int exit_req;
|
|
|
|
static int libbpf_print_fn(enum libbpf_print_level level, const char *format, va_list args)
|
|
{
|
|
if (level == LIBBPF_DEBUG && !verbose)
|
|
return 0;
|
|
return vfprintf(stderr, format, args);
|
|
}
|
|
|
|
static void sigint_handler(int dummy)
|
|
{
|
|
exit_req = 1;
|
|
}
|
|
|
|
int main(int argc, char **argv)
|
|
{
|
|
struct scx_qmap *skel;
|
|
struct bpf_link *link;
|
|
int opt;
|
|
|
|
libbpf_set_print(libbpf_print_fn);
|
|
signal(SIGINT, sigint_handler);
|
|
signal(SIGTERM, sigint_handler);
|
|
|
|
skel = SCX_OPS_OPEN(qmap_ops, scx_qmap);
|
|
|
|
while ((opt = getopt(argc, argv, "s:e:t:T:l:b:d:D:Spvh")) != -1) {
|
|
switch (opt) {
|
|
case 's':
|
|
skel->rodata->slice_ns = strtoull(optarg, NULL, 0) * 1000;
|
|
break;
|
|
case 'e':
|
|
skel->bss->test_error_cnt = strtoul(optarg, NULL, 0);
|
|
break;
|
|
case 't':
|
|
skel->rodata->stall_user_nth = strtoul(optarg, NULL, 0);
|
|
break;
|
|
case 'T':
|
|
skel->rodata->stall_kernel_nth = strtoul(optarg, NULL, 0);
|
|
break;
|
|
case 'l':
|
|
skel->rodata->dsp_inf_loop_after = strtoul(optarg, NULL, 0);
|
|
break;
|
|
case 'b':
|
|
skel->rodata->dsp_batch = strtoul(optarg, NULL, 0);
|
|
break;
|
|
case 'd':
|
|
skel->rodata->disallow_tgid = strtol(optarg, NULL, 0);
|
|
if (skel->rodata->disallow_tgid < 0)
|
|
skel->rodata->disallow_tgid = getpid();
|
|
break;
|
|
case 'D':
|
|
skel->struct_ops.qmap_ops->exit_dump_len = strtoul(optarg, NULL, 0);
|
|
break;
|
|
case 'S':
|
|
skel->rodata->suppress_dump = true;
|
|
break;
|
|
case 'p':
|
|
skel->struct_ops.qmap_ops->flags |= SCX_OPS_SWITCH_PARTIAL;
|
|
break;
|
|
case 'v':
|
|
verbose = true;
|
|
break;
|
|
default:
|
|
fprintf(stderr, help_fmt, basename(argv[0]));
|
|
return opt != 'h';
|
|
}
|
|
}
|
|
|
|
SCX_OPS_LOAD(skel, qmap_ops, scx_qmap, uei);
|
|
link = SCX_OPS_ATTACH(skel, qmap_ops, scx_qmap);
|
|
|
|
while (!exit_req && !UEI_EXITED(skel, uei)) {
|
|
long nr_enqueued = skel->bss->nr_enqueued;
|
|
long nr_dispatched = skel->bss->nr_dispatched;
|
|
|
|
printf("stats : enq=%lu dsp=%lu delta=%ld deq=%"PRIu64"\n",
|
|
nr_enqueued, nr_dispatched, nr_enqueued - nr_dispatched,
|
|
skel->bss->nr_dequeued);
|
|
fflush(stdout);
|
|
sleep(1);
|
|
}
|
|
|
|
bpf_link__destroy(link);
|
|
UEI_REPORT(skel, uei);
|
|
scx_qmap__destroy(skel);
|
|
return 0;
|
|
}
|