Blog

# 6.12 커널: sched_ext + BPF 관련 옵션을 켜고 빌드
scripts/config --file $O/.config \
    -e BPF_SYSCALL -e BPF_JIT -e DEBUG_INFO_BTF \
    -e SCHED_CLASS_EXT -e SCHED_DEBUG

# QEMU로 부팅 (~/ebpf를 9p로 게스트에 그대로 노출)
qemu-system-x86_64 -machine q35 -cpu max -m 2048 -smp 2 \
  -kernel build/arch/x86/boot/bzImage -initrd ir.cpio.gz \
  -append "console=ttyS0 tsc=reliable clocksource=tsc" \
  -virtfs local,path=$HOME/ebpf,mount_tag=ebpf,security_model=none \
  -nographic -no-reboot

/* scx_min: 전역 FIFO 하나로 동작하는 최소 sched_ext 스케줄러 */
#include <scx/common.bpf.h>

char _license[] SEC("license") = "GPL";

/* 로드 전에 유저 공간에서 정한다 */
const volatile __u64 slice_ns = SCX_SLICE_DFL;	/* 기본 20ms */
const volatile bool no_dispatch;		/* dispatch를 비워 두는 고장 모드 */

#define SHARED_DSQ 0

__u64 nr_local, nr_queued, nr_consumed;
__u32 exit_kind;

/* 깨어난 태스크를 어느 CPU에 올릴지 고른다. 유휴 CPU가 있으면 그 CPU의
 * 로컬 DSQ로 바로 넣어 공용 큐를 거치지 않는다. */
s32 BPF_STRUCT_OPS(min_select_cpu, struct task_struct *p, s32 prev_cpu, u64 wake_flags)
{
	bool is_idle = false;
	s32 cpu;

	cpu = scx_bpf_select_cpu_dfl(p, prev_cpu, wake_flags, &is_idle);
	if (is_idle) {
		__sync_fetch_and_add(&nr_local, 1);
		scx_bpf_dispatch(p, SCX_DSQ_LOCAL, slice_ns, 0);
	}
	return cpu;
}

/* 로컬로 못 간 태스크는 전부 공용 DSQ 하나에 FIFO로 줄 세운다.
 * nice도 vtime도 보지 않는다. */
void BPF_STRUCT_OPS(min_enqueue, struct task_struct *p, u64 enq_flags)
{
	__sync_fetch_and_add(&nr_queued, 1);
	scx_bpf_dispatch(p, SHARED_DSQ, slice_ns, enq_flags);
}

/* CPU가 비면 공용 DSQ에서 하나 꺼내 준다. */
void BPF_STRUCT_OPS(min_dispatch, s32 cpu, struct task_struct *prev)
{
	if (no_dispatch)	/* 아무것도 꺼내지 않으면 어떻게 되는지 보기 위한 모드 */
		return;
	if (scx_bpf_consume(SHARED_DSQ))
		__sync_fetch_and_add(&nr_consumed, 1);
}

s32 BPF_STRUCT_OPS_SLEEPABLE(min_init)
{
	return scx_bpf_create_dsq(SHARED_DSQ, -1);
}

/* 커널이 스케줄러를 내릴 때 이유를 남긴다 */
void BPF_STRUCT_OPS(min_exit, struct scx_exit_info *ei)
{
	exit_kind = ei->kind;
}

SEC(".struct_ops.link")
struct sched_ext_ops min_ops = {
	.select_cpu	= (void *)min_select_cpu,
	.enqueue	= (void *)min_enqueue,
	.dispatch	= (void *)min_dispatch,
	.init		= (void *)min_init,
	.exit		= (void *)min_exit,
	.name		= "min",
};

/* scx_min 로더: BPF 스케줄러를 커널에 붙이고 통계를 출력한다 */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <bpf/libbpf.h>
#include "scx_min.bpf.skel.h"

static volatile int exit_req;

static void sigint_handler(int sig)
{
	exit_req = 1;
}

int main(int argc, char **argv)
{
	struct scx_min *skel;
	struct bpf_link *link;
	int opt, secs = 0;
	unsigned long long slice_us = 20000;
	bool no_dispatch = false;

	signal(SIGINT, sigint_handler);
	signal(SIGTERM, sigint_handler);

	while ((opt = getopt(argc, argv, "s:t:b")) != -1) {
		switch (opt) {
		case 's': slice_us = strtoull(optarg, NULL, 10); break;
		case 't': secs = atoi(optarg); break;
		case 'b': no_dispatch = true; break;
		default:
			fprintf(stderr, "usage: %s [-s slice_us] [-t seconds] [-b]\n", argv[0]);
			return 1;
		}
	}

	skel = scx_min__open();
	if (!skel)
		return 1;
	skel->rodata->slice_ns = slice_us * 1000;
	skel->rodata->no_dispatch = no_dispatch;

	if (scx_min__load(skel)) {
		fprintf(stderr, "load failed\n");
		return 1;
	}
	link = bpf_map__attach_struct_ops(skel->maps.min_ops);
	if (!link) {
		fprintf(stderr, "attach failed: %m\n");
		return 1;
	}
	printf("attached: slice=%lluus no_dispatch=%d\n", slice_us, no_dispatch);
	fflush(stdout);

	for (int i = 0; !exit_req && !skel->bss->exit_kind && (!secs || i < secs); i++) {
		sleep(1);
		printf("local=%llu queued=%llu consumed=%llu\n",
		       skel->bss->nr_local, skel->bss->nr_queued, skel->bss->nr_consumed);
		fflush(stdout);
	}
	if (skel->bss->exit_kind)
		printf("scheduler ejected by kernel: exit_kind=%u\n", skel->bss->exit_kind);

	bpf_link__destroy(link);
	scx_min__destroy(skel);
	return 0;
}

KSRC  ?= $(HOME)/kbuild/linux-6.12
SCX   := $(KSRC)/tools/sched_ext
ARCH  := $(shell uname -m | sed 's/x86_64/x86/')
INCS  := -I. -I$(SCX)/include -I$(SCX)/include/bpf-compat

all: scx_min spin_nice

spin_nice: spin_nice.c
	cc -O2 -Wall $< -o $@

vmlinux.h:
	bpftool btf dump file $(HOME)/ebpf/kernel/build/vmlinux format c > $@

scx_min.bpf.o: scx_min.bpf.c vmlinux.h
	clang -g -O2 -target bpf -mcpu=v3 -D__TARGET_ARCH_$(ARCH) $(INCS) -c $< -o $@

scx_min.bpf.skel.h: scx_min.bpf.o
	bpftool gen skeleton $< name scx_min > $@

scx_min: scx_min.c scx_min.bpf.skel.h
	cc -g -O2 -Wall $(INCS) $< -o $@ -lbpf -lelf -lz

clean:
	rm -f scx_min scx_min.bpf.o scx_min.bpf.skel.h vmlinux.h

/* spin_nice <nice> <초>: 지정한 nice 값으로 주어진 시간 동안 루프를 돌고
 * 실제로 돈 횟수를 출력한다. 틱 기반 utime 대신 이 횟수로 받은 CPU를 비교한다. */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <sys/resource.h>

static volatile sig_atomic_t stop;
static unsigned long long iters;
static int nice_val;

static void on_alarm(int sig)
{
	stop = 1;
}

int main(int argc, char **argv)
{
	nice_val = argc > 1 ? atoi(argv[1]) : 0;
	int sec = argc > 2 ? atoi(argv[2]) : 5;

	if (setpriority(PRIO_PROCESS, 0, nice_val))
		perror("setpriority");
	signal(SIGALRM, on_alarm);
	alarm(sec);
	while (!stop)
		for (volatile int i = 0; i < 1000 && !stop; i++)
			iters++;
	printf("nice=%-3d iters=%llu\n", nice_val, iters);
	return 0;
}