Katyusha's blog

1
// SPDX-License-Identifier: GPL-2.0
2
//
3
// 场景②：I/O 延迟抖动 / 阻塞等待 —— 基于块层 tracepoint 的请求时延分析。
4
//
5
// 思路（赛题关键证据点：IOPS、平均时延、P99 时延、队列深度、热点设备）：
6
//   block_rq_issue   ：请求下发到设备时记录起点（按 dev+sector 索引），队列深度++。
7
//   block_rq_complete：请求完成时按 dev+sector 匹配起点，算单次时延；按设备累计
8
//                      次数/总时延/最大时延/字节数，并落入 log2 时延直方图(供算 P99)，队列深度--。
9
// 内核态仅聚合，用户态按窗口差分并从直方图估算 P99，开销低。
10
//
11
// 注意：tracepoint 字段偏移随内核版本可能变化。如遇异常，请用
12
//   cat /sys/kernel/tracing/events/block/block_rq_issue/format
13
// 核对 dev/sector/nr_sector 的布局。
14

15
#include "vmlinux.h"
16
#include <bpf/bpf_helpers.h>
17

18
char LICENSE[] SEC("license") = "GPL";
19

20
#define NSLOTS 32 // log2(ns) 直方图槽位，2^31 ns ≈ 2.1s
21

22
struct dev_stat {
23
  __u64 count;        // 完成请求数
24
  __u64 total_lat_ns; // 累计时延
25
  __u64 max_lat_ns;   // 最大时延
26
  __u64 bytes;        // 累计字节数(吞吐)
27
  __s64 inflight;     // 当前在途请求数(队列深度,gauge)
28
  __u64 slots[NSLOTS];// 时延 log2 直方图
29
};
30

31
struct rq_key {
32
  __u32 dev;
33
  __u32 _pad;
34
  __u64 sector;
35
};
36

37
struct {
38
  __uint(type, BPF_MAP_TYPE_HASH);
39
  __uint(max_entries, 65536);
40
  __type(key, struct rq_key);
41
  __type(value, __u64);
42
} start SEC(".maps");
43

44
struct {
45
  __uint(type, BPF_MAP_TYPE_HASH);
46
  __uint(max_entries, 256);
47
  __type(key, __u32);
48
  __type(value, struct dev_stat);
49
} dev_stats SEC(".maps");
50

51
// block_rq_issue tracepoint 上下文（含 common 头 8 字节）
52
struct block_rq_issue_tp {
53
  __u64 pad;
54
  __u32 dev;
55
  __u32 _pad0;
56
  __u64 sector;
57
  __u32 nr_sector;
58
  __u32 bytes;
59
  char  rwbs[8];
60
  char  comm[16];
61
};
62

63
// block_rq_complete tracepoint 上下文
64
struct block_rq_complete_tp {
65
  __u64 pad;
66
  __u32 dev;
67
  __u32 _pad0;
68
  __u64 sector;
69
  __u32 nr_sector;
70
  __s32 error;
71
  char  rwbs[8];
72
};
73

74
static __always_inline __u32 log2_u64(__u64 v)
75
{
76
  __u32 r = 0;
77
#pragma unroll
78
  for (int i = 0; i < 64; i++) {
79
    if (v <= 1)
80
      break;
81
    v >>= 1;
82
    r++;
83
  }
84
  return r;
85
}
86

87
static __always_inline struct dev_stat *get_dev(__u32 dev)
88
{
89
  struct dev_stat *d = bpf_map_lookup_elem(&dev_stats, &dev);
90
  if (d)
91
    return d;
92
  struct dev_stat zero = {};
93
  bpf_map_update_elem(&dev_stats, &dev, &zero, BPF_NOEXIST);
94
  return bpf_map_lookup_elem(&dev_stats, &dev);
95
}
96

97
SEC("tracepoint/block/block_rq_issue")
98
int handle_issue(struct block_rq_issue_tp *ctx)
99
{
100
  struct rq_key k = {};
101
  k.dev = ctx->dev;
102
  k.sector = ctx->sector;
103
  __u64 ts = bpf_ktime_get_ns();
104
  bpf_map_update_elem(&start, &k, &ts, BPF_ANY);
105

106
  struct dev_stat *d = get_dev(ctx->dev);
107
  if (d)
108
    __sync_fetch_and_add(&d->inflight, 1);
109
  return 0;
110
}
111

112
SEC("tracepoint/block/block_rq_complete")
113
int handle_complete(struct block_rq_complete_tp *ctx)
114
{
115
  struct dev_stat *d = get_dev(ctx->dev);
116
  if (d)
117
    __sync_fetch_and_add(&d->inflight, -1);
118

119
  struct rq_key k = {};
120
  k.dev = ctx->dev;
121
  k.sector = ctx->sector;
122
  __u64 *tsp = bpf_map_lookup_elem(&start, &k);
123
  if (!tsp || !d)
124
    return 0;
125

126
  __u64 now = bpf_ktime_get_ns();
127
  __u64 delta = now - *tsp;
128
  bpf_map_delete_elem(&start, &k);
129

130
  __sync_fetch_and_add(&d->count, 1);
131
  __sync_fetch_and_add(&d->total_lat_ns, delta);
132
  __sync_fetch_and_add(&d->bytes, (__u64)ctx->nr_sector * 512);
133
  if (delta > d->max_lat_ns)
134
    d->max_lat_ns = delta; // best-effort gauge
135

136
  __u32 slot = log2_u64(delta);
137
  if (slot >= NSLOTS)
138
    slot = NSLOTS - 1;
139
  __sync_fetch_and_add(&d->slots[slot], 1);
140
  return 0;
141
}