Katyusha's blog

1
// SPDX-License-Identifier: GPL-2.0
2
//
3
// 场景④：锁竞争导致的性能退化 —— 基于 off-CPU 阻塞分析 + 唤醒链。
4
//
5
// 思路（赛题关键证据点：锁等待时间、调度阻塞时间、线程堆栈聚集、futex 热点）：
6
//   1. sched_switch 中 prev_state != 0（非 RUNNING，即"被阻塞切出"而非"被抢占"）时，
7
//      记录该线程的 off-CPU 起点，并抓取其内核调用栈（阻塞点，如 futex_wait/__mutex_lock）。
8
//   2. 该线程重新上 CPU 时，结算阻塞时长，按线程累计 off-CPU 阻塞时间/次数/最大值，并记下阻塞栈 id。
9
//   3. sched_wakeup 中记录"唤醒者"——构成 waker→wakee 唤醒链，定位是谁持锁阻塞了它。
10
// 内核态仅聚合，栈符号化在用户态用 /proc/kallsyms 完成，开销低。
11

12
#include "vmlinux.h"
13
#include <bpf/bpf_helpers.h>
14

15
char LICENSE[] SEC("license") = "GPL";
16

17
#define TASK_COMM_LEN  16
18
#define MAX_STACK_DEPTH 32
19

20
struct lock_stat {
21
  __u64 offcpu_ns;     // 累计阻塞型 off-CPU 时间
22
  __u64 offcpu_count;  // 阻塞次数
23
  __u64 max_offcpu_ns; // 单次最长阻塞
24
  __u32 last_waker;    // 最近一次唤醒者 tid
25
  __s32 stackid;       // 最近一次阻塞的内核栈 id
26
  char  comm[TASK_COMM_LEN];
27
};
28

29
struct offcpu_info {
30
  __u64 ts;
31
  __s32 stackid;
32
  __u32 pad;
33
};
34

35
struct {
36
  __uint(type, BPF_MAP_TYPE_HASH);
37
  __uint(max_entries, 16384);
38
  __type(key, __u32);
39
  __type(value, struct offcpu_info);
40
} offcpu_start SEC(".maps");
41

42
struct {
43
  __uint(type, BPF_MAP_TYPE_HASH);
44
  __uint(max_entries, 16384);
45
  __type(key, __u32);
46
  __type(value, struct lock_stat);
47
} lock_stats SEC(".maps");
48

49
struct {
50
  __uint(type, BPF_MAP_TYPE_STACK_TRACE);
51
  __uint(max_entries, 4096);
52
  __uint(key_size, sizeof(__u32));
53
  __uint(value_size, MAX_STACK_DEPTH * sizeof(__u64));
54
} stackmap SEC(".maps");
55

56
struct sched_switch_tp {
57
  __u64 pad;
58
  char  prev_comm[TASK_COMM_LEN];
59
  __s32 prev_pid;
60
  __s32 prev_prio;
61
  __s64 prev_state;
62
  char  next_comm[TASK_COMM_LEN];
63
  __s32 next_pid;
64
  __s32 next_prio;
65
};
66

67
struct sched_wakeup_tp {
68
  __u64 pad;
69
  char  comm[TASK_COMM_LEN];
70
  __s32 pid;
71
  __s32 prio;
72
  __s32 target_cpu;
73
};
74

75
static __always_inline struct lock_stat *get_stat(__u32 tid)
76
{
77
  struct lock_stat *st = bpf_map_lookup_elem(&lock_stats, &tid);
78
  if (st)
79
    return st;
80
  struct lock_stat zero = {};
81
  bpf_map_update_elem(&lock_stats, &tid, &zero, BPF_NOEXIST);
82
  return bpf_map_lookup_elem(&lock_stats, &tid);
83
}
84

85
SEC("tracepoint/sched/sched_switch")
86
int handle_switch(struct sched_switch_tp *ctx)
87
{
88
  __u64 now = bpf_ktime_get_ns();
89
  __u32 prev = (__u32)ctx->prev_pid;
90
  __u32 next = (__u32)ctx->next_pid;
91

92
  // prev 因阻塞被切出（prev_state != 0 表示非 RUNNING，排除普通抢占）
93
  if (prev != 0 && ctx->prev_state != 0) {
94
    struct offcpu_info info = {};
95
    info.ts = now;
96
    info.stackid = bpf_get_stackid(ctx, &stackmap, 0);
97
    bpf_map_update_elem(&offcpu_start, &prev, &info, BPF_ANY);
98
  }
99

100
  // next 回到 CPU：结算阻塞时长
101
  if (next != 0) {
102
    struct offcpu_info *info = bpf_map_lookup_elem(&offcpu_start, &next);
103
    if (info && now > info->ts) {
104
      __u64 dur = now - info->ts;
105
      struct lock_stat *st = get_stat(next);
106
      if (st) {
107
        st->offcpu_ns += dur;
108
        st->offcpu_count += 1;
109
        if (dur > st->max_offcpu_ns)
110
          st->max_offcpu_ns = dur;
111
        st->stackid = info->stackid;
112
        bpf_probe_read_kernel_str(&st->comm, sizeof(st->comm),
113
                ctx->next_comm);
114
      }
115
      bpf_map_delete_elem(&offcpu_start, &next);
116
    }
117
  }
118
  return 0;
119
}
120

121
SEC("tracepoint/sched/sched_wakeup")
122
int handle_wakeup(struct sched_wakeup_tp *ctx)
123
{
124
  __u32 wakee = (__u32)ctx->pid;
125
  if (wakee == 0)
126
    return 0;
127
  // 唤醒发生在唤醒者上下文：current 即 waker
128
  __u32 waker = (__u32)bpf_get_current_pid_tgid();
129
  struct lock_stat *st = get_stat(wakee);
130
  if (st)
131
    st->last_waker = waker;
132
  return 0;
133
}