Alexey Ivanov | cc01a9c | 2019-01-16 09:50:46 -0800 | [diff] [blame] | 1 | #!/usr/bin/python |
Brendan Gregg | af2b46a | 2016-01-30 11:02:29 -0800 | [diff] [blame] | 2 | # |
| 3 | # offwaketime Summarize blocked time by kernel off-CPU stack + waker stack |
| 4 | # For Linux, uses BCC, eBPF. |
| 5 | # |
ceeaspb | 47cecb6 | 2016-11-26 22:36:10 +0000 | [diff] [blame] | 6 | # USAGE: offwaketime [-h] [-p PID | -u | -k] [-U | -K] [-f] [duration] |
Brendan Gregg | af2b46a | 2016-01-30 11:02:29 -0800 | [diff] [blame] | 7 | # |
| 8 | # Copyright 2016 Netflix, Inc. |
| 9 | # Licensed under the Apache License, Version 2.0 (the "License") |
| 10 | # |
Alexei Starovoitov | 7583a4e | 2016-02-03 21:25:43 -0800 | [diff] [blame] | 11 | # 20-Jan-2016 Brendan Gregg Created this. |
Brendan Gregg | af2b46a | 2016-01-30 11:02:29 -0800 | [diff] [blame] | 12 | |
| 13 | from __future__ import print_function |
| 14 | from bcc import BPF |
Alexei Starovoitov | 7583a4e | 2016-02-03 21:25:43 -0800 | [diff] [blame] | 15 | from time import sleep |
Brendan Gregg | af2b46a | 2016-01-30 11:02:29 -0800 | [diff] [blame] | 16 | import argparse |
| 17 | import signal |
ceeaspb | 47cecb6 | 2016-11-26 22:36:10 +0000 | [diff] [blame] | 18 | import errno |
| 19 | from sys import stderr |
| 20 | |
| 21 | # arg validation |
| 22 | def positive_int(val): |
lorddoskias | 263411b | 2020-06-08 09:33:46 +0300 | [diff] [blame] | 23 | dest = [] |
| 24 | # Filter up to 5 pids, arbitrary |
| 25 | args_list = val.split(",", 5) |
| 26 | pids_to_add = min(len(args_list), 5) |
| 27 | for i in range(pids_to_add): |
| 28 | dest.append(_positive_int(args_list[i])) |
| 29 | |
| 30 | return dest |
| 31 | |
| 32 | def _positive_int(val): |
ceeaspb | 47cecb6 | 2016-11-26 22:36:10 +0000 | [diff] [blame] | 33 | try: |
| 34 | ival = int(val) |
| 35 | except ValueError: |
| 36 | raise argparse.ArgumentTypeError("must be an integer") |
| 37 | |
| 38 | if ival < 0: |
| 39 | raise argparse.ArgumentTypeError("must be positive") |
| 40 | return ival |
| 41 | |
| 42 | def positive_nonzero_int(val): |
lorddoskias | 263411b | 2020-06-08 09:33:46 +0300 | [diff] [blame] | 43 | ival = _positive_int(val) |
ceeaspb | 47cecb6 | 2016-11-26 22:36:10 +0000 | [diff] [blame] | 44 | if ival == 0: |
| 45 | raise argparse.ArgumentTypeError("must be nonzero") |
| 46 | return ival |
Brendan Gregg | af2b46a | 2016-01-30 11:02:29 -0800 | [diff] [blame] | 47 | |
lorddoskias | 263411b | 2020-06-08 09:33:46 +0300 | [diff] [blame] | 48 | def build_filter(filter_name, values): |
| 49 | filter_string = "((%s == %d)" % (filter_name, values[0]) |
| 50 | |
| 51 | for val in values[1:]: |
| 52 | filter_string += " || (%s == %d )" % (filter_name , val) |
| 53 | |
| 54 | filter_string += ")" |
| 55 | |
| 56 | return filter_string |
| 57 | |
Teng Qin | e778db0 | 2018-04-24 16:11:49 -0700 | [diff] [blame] | 58 | def stack_id_err(stack_id): |
Michael Prokop | c14d02a | 2020-01-09 02:29:18 +0100 | [diff] [blame] | 59 | # -EFAULT in get_stackid normally means the stack-trace is not available, |
Teng Qin | e778db0 | 2018-04-24 16:11:49 -0700 | [diff] [blame] | 60 | # Such as getting kernel stack trace in userspace code |
| 61 | return (stack_id < 0) and (stack_id != -errno.EFAULT) |
| 62 | |
Brendan Gregg | af2b46a | 2016-01-30 11:02:29 -0800 | [diff] [blame] | 63 | # arguments |
| 64 | examples = """examples: |
| 65 | ./offwaketime # trace off-CPU + waker stack time until Ctrl-C |
| 66 | ./offwaketime 5 # trace for 5 seconds only |
| 67 | ./offwaketime -f 5 # 5 seconds, and output in folded format |
ceeaspb | 47cecb6 | 2016-11-26 22:36:10 +0000 | [diff] [blame] | 68 | ./offwaketime -m 1000 # trace only events that last more than 1000 usec |
| 69 | ./offwaketime -M 9000 # trace only events that last less than 9000 usec |
| 70 | ./offwaketime -p 185 # only trace threads for PID 185 |
| 71 | ./offwaketime -t 188 # only trace thread 188 |
| 72 | ./offwaketime -u # only trace user threads (no kernel) |
| 73 | ./offwaketime -k # only trace kernel threads (no user) |
| 74 | ./offwaketime -U # only show user space stacks (no kernel) |
| 75 | ./offwaketime -K # only show kernel space stacks (no user) |
Brendan Gregg | af2b46a | 2016-01-30 11:02:29 -0800 | [diff] [blame] | 76 | """ |
| 77 | parser = argparse.ArgumentParser( |
| 78 | description="Summarize blocked time by kernel stack trace + waker stack", |
| 79 | formatter_class=argparse.RawDescriptionHelpFormatter, |
| 80 | epilog=examples) |
ceeaspb | 47cecb6 | 2016-11-26 22:36:10 +0000 | [diff] [blame] | 81 | thread_group = parser.add_mutually_exclusive_group() |
| 82 | # Note: this script provides --pid and --tid flags but their arguments are |
| 83 | # referred to internally using kernel nomenclature: TGID and PID. |
lorddoskias | 263411b | 2020-06-08 09:33:46 +0300 | [diff] [blame] | 84 | thread_group.add_argument("-p", "--pid", metavar="PIDS", dest="tgid", |
| 85 | type=positive_int, |
| 86 | help="trace these PIDS only. Can be a comma separated list of PIDS.") |
| 87 | thread_group.add_argument("-t", "--tid", metavar="TIDS", dest="pid", |
| 88 | type=positive_int, |
| 89 | help="trace these TIDS only. Can be a comma separated list of TIDS.") |
ceeaspb | 47cecb6 | 2016-11-26 22:36:10 +0000 | [diff] [blame] | 90 | thread_group.add_argument("-u", "--user-threads-only", action="store_true", |
Brendan Gregg | af2b46a | 2016-01-30 11:02:29 -0800 | [diff] [blame] | 91 | help="user threads only (no kernel threads)") |
ceeaspb | 47cecb6 | 2016-11-26 22:36:10 +0000 | [diff] [blame] | 92 | thread_group.add_argument("-k", "--kernel-threads-only", action="store_true", |
| 93 | help="kernel threads only (no user threads)") |
| 94 | stack_group = parser.add_mutually_exclusive_group() |
| 95 | stack_group.add_argument("-U", "--user-stacks-only", action="store_true", |
| 96 | help="show stacks from user space only (no kernel space stacks)") |
| 97 | stack_group.add_argument("-K", "--kernel-stacks-only", action="store_true", |
| 98 | help="show stacks from kernel space only (no user space stacks)") |
| 99 | parser.add_argument("-d", "--delimited", action="store_true", |
| 100 | help="insert delimiter between kernel/user stacks") |
Brendan Gregg | af2b46a | 2016-01-30 11:02:29 -0800 | [diff] [blame] | 101 | parser.add_argument("-f", "--folded", action="store_true", |
| 102 | help="output folded format") |
ceeaspb | 47cecb6 | 2016-11-26 22:36:10 +0000 | [diff] [blame] | 103 | parser.add_argument("--stack-storage-size", default=1024, |
| 104 | type=positive_nonzero_int, |
| 105 | help="the number of unique stack traces that can be stored and " |
| 106 | "displayed (default 1024)") |
Brendan Gregg | af2b46a | 2016-01-30 11:02:29 -0800 | [diff] [blame] | 107 | parser.add_argument("duration", nargs="?", default=99999999, |
ceeaspb | 47cecb6 | 2016-11-26 22:36:10 +0000 | [diff] [blame] | 108 | type=positive_nonzero_int, |
Brendan Gregg | af2b46a | 2016-01-30 11:02:29 -0800 | [diff] [blame] | 109 | help="duration of trace, in seconds") |
ceeaspb | 47cecb6 | 2016-11-26 22:36:10 +0000 | [diff] [blame] | 110 | parser.add_argument("-m", "--min-block-time", default=1, |
| 111 | type=positive_nonzero_int, |
| 112 | help="the amount of time in microseconds over which we " + |
| 113 | "store traces (default 1)") |
| 114 | parser.add_argument("-M", "--max-block-time", default=(1 << 64) - 1, |
| 115 | type=positive_nonzero_int, |
| 116 | help="the amount of time in microseconds under which we " + |
| 117 | "store traces (default U64_MAX)") |
lorddoskias | 263411b | 2020-06-08 09:33:46 +0300 | [diff] [blame] | 118 | parser.add_argument("--state", type=_positive_int, |
lorddoskias | b20f5e7 | 2020-05-30 19:17:33 +0300 | [diff] [blame] | 119 | help="filter on this thread state bitmask (eg, 2 == TASK_UNINTERRUPTIBLE" + |
| 120 | ") see include/linux/sched.h") |
Nathan Scott | cf0792f | 2018-02-02 16:56:50 +1100 | [diff] [blame] | 121 | parser.add_argument("--ebpf", action="store_true", |
| 122 | help=argparse.SUPPRESS) |
Brendan Gregg | af2b46a | 2016-01-30 11:02:29 -0800 | [diff] [blame] | 123 | args = parser.parse_args() |
| 124 | folded = args.folded |
| 125 | duration = int(args.duration) |
Brendan Gregg | af2b46a | 2016-01-30 11:02:29 -0800 | [diff] [blame] | 126 | |
| 127 | # signal handler |
| 128 | def signal_ignore(signal, frame): |
| 129 | print() |
| 130 | |
| 131 | # define BPF program |
| 132 | bpf_text = """ |
| 133 | #include <uapi/linux/ptrace.h> |
| 134 | #include <linux/sched.h> |
| 135 | |
ceeaspb | 47cecb6 | 2016-11-26 22:36:10 +0000 | [diff] [blame] | 136 | #define MINBLOCK_US MINBLOCK_US_VALUEULL |
| 137 | #define MAXBLOCK_US MAXBLOCK_US_VALUEULL |
Brendan Gregg | af2b46a | 2016-01-30 11:02:29 -0800 | [diff] [blame] | 138 | |
| 139 | struct key_t { |
| 140 | char waker[TASK_COMM_LEN]; |
| 141 | char target[TASK_COMM_LEN]; |
Hengqi Chen | 08765a9 | 2021-10-31 23:20:10 +0800 | [diff] [blame] | 142 | s64 w_k_stack_id; |
| 143 | s64 w_u_stack_id; |
| 144 | s64 t_k_stack_id; |
| 145 | s64 t_u_stack_id; |
| 146 | u64 t_pid; |
| 147 | u64 t_tgid; |
ceeaspb | 47cecb6 | 2016-11-26 22:36:10 +0000 | [diff] [blame] | 148 | u32 w_pid; |
Teng Qin | e7432d4 | 2018-04-19 14:45:18 -0700 | [diff] [blame] | 149 | u32 w_tgid; |
Brendan Gregg | af2b46a | 2016-01-30 11:02:29 -0800 | [diff] [blame] | 150 | }; |
| 151 | BPF_HASH(counts, struct key_t); |
Teng Qin | e7432d4 | 2018-04-19 14:45:18 -0700 | [diff] [blame] | 152 | |
| 153 | // Key of this hash is PID of waiting Process, |
| 154 | // value is timestamp when it went into waiting |
Brendan Gregg | af2b46a | 2016-01-30 11:02:29 -0800 | [diff] [blame] | 155 | BPF_HASH(start, u32); |
Teng Qin | e7432d4 | 2018-04-19 14:45:18 -0700 | [diff] [blame] | 156 | |
Brendan Gregg | af2b46a | 2016-01-30 11:02:29 -0800 | [diff] [blame] | 157 | struct wokeby_t { |
| 158 | char name[TASK_COMM_LEN]; |
ceeaspb | 47cecb6 | 2016-11-26 22:36:10 +0000 | [diff] [blame] | 159 | int k_stack_id; |
| 160 | int u_stack_id; |
| 161 | int w_pid; |
Teng Qin | e7432d4 | 2018-04-19 14:45:18 -0700 | [diff] [blame] | 162 | int w_tgid; |
Brendan Gregg | af2b46a | 2016-01-30 11:02:29 -0800 | [diff] [blame] | 163 | }; |
Teng Qin | e7432d4 | 2018-04-19 14:45:18 -0700 | [diff] [blame] | 164 | // Key of the hash is PID of the Process to be waken, value is information |
| 165 | // of the Process who wakes it |
Brendan Gregg | af2b46a | 2016-01-30 11:02:29 -0800 | [diff] [blame] | 166 | BPF_HASH(wokeby, u32, struct wokeby_t); |
| 167 | |
Vladislav Bogdanov | 0a7da74 | 2020-02-07 15:22:42 +0300 | [diff] [blame] | 168 | BPF_STACK_TRACE(stack_traces, STACK_STORAGE_SIZE); |
Brendan Gregg | af2b46a | 2016-01-30 11:02:29 -0800 | [diff] [blame] | 169 | |
| 170 | int waker(struct pt_regs *ctx, struct task_struct *p) { |
Teng Qin | e7432d4 | 2018-04-19 14:45:18 -0700 | [diff] [blame] | 171 | // PID and TGID of the target Process to be waken |
Brendan Gregg | af2b46a | 2016-01-30 11:02:29 -0800 | [diff] [blame] | 172 | u32 pid = p->pid; |
ceeaspb | 47cecb6 | 2016-11-26 22:36:10 +0000 | [diff] [blame] | 173 | u32 tgid = p->tgid; |
Brendan Gregg | af2b46a | 2016-01-30 11:02:29 -0800 | [diff] [blame] | 174 | |
lorddoskias | b20f5e7 | 2020-05-30 19:17:33 +0300 | [diff] [blame] | 175 | if (!((THREAD_FILTER) && (STATE_FILTER))) { |
Brendan Gregg | af2b46a | 2016-01-30 11:02:29 -0800 | [diff] [blame] | 176 | return 0; |
ceeaspb | 47cecb6 | 2016-11-26 22:36:10 +0000 | [diff] [blame] | 177 | } |
Brendan Gregg | af2b46a | 2016-01-30 11:02:29 -0800 | [diff] [blame] | 178 | |
Teng Qin | e7432d4 | 2018-04-19 14:45:18 -0700 | [diff] [blame] | 179 | // Construct information about current (the waker) Process |
Brendan Gregg | af2b46a | 2016-01-30 11:02:29 -0800 | [diff] [blame] | 180 | struct wokeby_t woke = {}; |
Brendan Gregg | af2b46a | 2016-01-30 11:02:29 -0800 | [diff] [blame] | 181 | bpf_get_current_comm(&woke.name, sizeof(woke.name)); |
ceeaspb | 47cecb6 | 2016-11-26 22:36:10 +0000 | [diff] [blame] | 182 | woke.k_stack_id = KERNEL_STACK_GET; |
| 183 | woke.u_stack_id = USER_STACK_GET; |
Teng Qin | e7432d4 | 2018-04-19 14:45:18 -0700 | [diff] [blame] | 184 | woke.w_pid = bpf_get_current_pid_tgid(); |
| 185 | woke.w_tgid = bpf_get_current_pid_tgid() >> 32; |
| 186 | |
Brendan Gregg | af2b46a | 2016-01-30 11:02:29 -0800 | [diff] [blame] | 187 | wokeby.update(&pid, &woke); |
| 188 | return 0; |
| 189 | } |
| 190 | |
| 191 | int oncpu(struct pt_regs *ctx, struct task_struct *p) { |
Teng Qin | e7432d4 | 2018-04-19 14:45:18 -0700 | [diff] [blame] | 192 | // PID and TGID of the previous Process (Process going into waiting) |
| 193 | u32 pid = p->pid; |
ceeaspb | 47cecb6 | 2016-11-26 22:36:10 +0000 | [diff] [blame] | 194 | u32 tgid = p->tgid; |
Teng Qin | e7432d4 | 2018-04-19 14:45:18 -0700 | [diff] [blame] | 195 | u64 *tsp; |
| 196 | u64 ts = bpf_ktime_get_ns(); |
Brendan Gregg | af2b46a | 2016-01-30 11:02:29 -0800 | [diff] [blame] | 197 | |
Teng Qin | e7432d4 | 2018-04-19 14:45:18 -0700 | [diff] [blame] | 198 | // Record timestamp for the previous Process (Process going into waiting) |
lorddoskias | b20f5e7 | 2020-05-30 19:17:33 +0300 | [diff] [blame] | 199 | if ((THREAD_FILTER) && (STATE_FILTER)) { |
Brendan Gregg | af2b46a | 2016-01-30 11:02:29 -0800 | [diff] [blame] | 200 | start.update(&pid, &ts); |
| 201 | } |
| 202 | |
Teng Qin | e7432d4 | 2018-04-19 14:45:18 -0700 | [diff] [blame] | 203 | // Calculate current Process's wait time by finding the timestamp of when |
| 204 | // it went into waiting. |
| 205 | // pid and tgid are now the PID and TGID of the current (waking) Process. |
Brendan Gregg | af2b46a | 2016-01-30 11:02:29 -0800 | [diff] [blame] | 206 | pid = bpf_get_current_pid_tgid(); |
ceeaspb | 47cecb6 | 2016-11-26 22:36:10 +0000 | [diff] [blame] | 207 | tgid = bpf_get_current_pid_tgid() >> 32; |
Brendan Gregg | af2b46a | 2016-01-30 11:02:29 -0800 | [diff] [blame] | 208 | tsp = start.lookup(&pid); |
ceeaspb | 47cecb6 | 2016-11-26 22:36:10 +0000 | [diff] [blame] | 209 | if (tsp == 0) { |
Teng Qin | e7432d4 | 2018-04-19 14:45:18 -0700 | [diff] [blame] | 210 | // Missed or filtered when the Process went into waiting |
| 211 | return 0; |
ceeaspb | 47cecb6 | 2016-11-26 22:36:10 +0000 | [diff] [blame] | 212 | } |
Teng Qin | e7432d4 | 2018-04-19 14:45:18 -0700 | [diff] [blame] | 213 | u64 delta = ts - *tsp; |
Brendan Gregg | af2b46a | 2016-01-30 11:02:29 -0800 | [diff] [blame] | 214 | start.delete(&pid); |
| 215 | delta = delta / 1000; |
ceeaspb | 47cecb6 | 2016-11-26 22:36:10 +0000 | [diff] [blame] | 216 | if ((delta < MINBLOCK_US) || (delta > MAXBLOCK_US)) { |
Brendan Gregg | af2b46a | 2016-01-30 11:02:29 -0800 | [diff] [blame] | 217 | return 0; |
ceeaspb | 47cecb6 | 2016-11-26 22:36:10 +0000 | [diff] [blame] | 218 | } |
Brendan Gregg | af2b46a | 2016-01-30 11:02:29 -0800 | [diff] [blame] | 219 | |
| 220 | // create map key |
Brendan Gregg | af2b46a | 2016-01-30 11:02:29 -0800 | [diff] [blame] | 221 | struct key_t key = {}; |
| 222 | struct wokeby_t *woke; |
Brendan Gregg | af2b46a | 2016-01-30 11:02:29 -0800 | [diff] [blame] | 223 | |
Teng Qin | e7432d4 | 2018-04-19 14:45:18 -0700 | [diff] [blame] | 224 | bpf_get_current_comm(&key.target, sizeof(key.target)); |
| 225 | key.t_pid = pid; |
| 226 | key.t_tgid = tgid; |
ceeaspb | 47cecb6 | 2016-11-26 22:36:10 +0000 | [diff] [blame] | 227 | key.t_k_stack_id = KERNEL_STACK_GET; |
| 228 | key.t_u_stack_id = USER_STACK_GET; |
Brendan Gregg | af2b46a | 2016-01-30 11:02:29 -0800 | [diff] [blame] | 229 | |
Brendan Gregg | af2b46a | 2016-01-30 11:02:29 -0800 | [diff] [blame] | 230 | woke = wokeby.lookup(&pid); |
| 231 | if (woke) { |
ceeaspb | 47cecb6 | 2016-11-26 22:36:10 +0000 | [diff] [blame] | 232 | key.w_k_stack_id = woke->k_stack_id; |
| 233 | key.w_u_stack_id = woke->u_stack_id; |
| 234 | key.w_pid = woke->w_pid; |
Teng Qin | e7432d4 | 2018-04-19 14:45:18 -0700 | [diff] [blame] | 235 | key.w_tgid = woke->w_tgid; |
Alexei Starovoitov | 7583a4e | 2016-02-03 21:25:43 -0800 | [diff] [blame] | 236 | __builtin_memcpy(&key.waker, woke->name, TASK_COMM_LEN); |
Brendan Gregg | af2b46a | 2016-01-30 11:02:29 -0800 | [diff] [blame] | 237 | wokeby.delete(&pid); |
| 238 | } |
| 239 | |
Javier Honduvilla Coto | 64bf965 | 2018-08-01 06:50:19 +0200 | [diff] [blame] | 240 | counts.increment(key, delta); |
Brendan Gregg | af2b46a | 2016-01-30 11:02:29 -0800 | [diff] [blame] | 241 | return 0; |
| 242 | } |
| 243 | """ |
ceeaspb | 47cecb6 | 2016-11-26 22:36:10 +0000 | [diff] [blame] | 244 | |
| 245 | # set thread filter |
ceeaspb | 47cecb6 | 2016-11-26 22:36:10 +0000 | [diff] [blame] | 246 | if args.tgid is not None: |
lorddoskias | 263411b | 2020-06-08 09:33:46 +0300 | [diff] [blame] | 247 | thread_filter = build_filter("tgid", args.tgid) |
ceeaspb | 47cecb6 | 2016-11-26 22:36:10 +0000 | [diff] [blame] | 248 | elif args.pid is not None: |
lorddoskias | 263411b | 2020-06-08 09:33:46 +0300 | [diff] [blame] | 249 | thread_filter = build_filter("pid", args.pid) |
ceeaspb | 47cecb6 | 2016-11-26 22:36:10 +0000 | [diff] [blame] | 250 | elif args.user_threads_only: |
ceeaspb | 47cecb6 | 2016-11-26 22:36:10 +0000 | [diff] [blame] | 251 | thread_filter = '!(p->flags & PF_KTHREAD)' |
| 252 | elif args.kernel_threads_only: |
ceeaspb | 47cecb6 | 2016-11-26 22:36:10 +0000 | [diff] [blame] | 253 | thread_filter = 'p->flags & PF_KTHREAD' |
Brendan Gregg | af2b46a | 2016-01-30 11:02:29 -0800 | [diff] [blame] | 254 | else: |
ceeaspb | 47cecb6 | 2016-11-26 22:36:10 +0000 | [diff] [blame] | 255 | thread_filter = '1' |
lorddoskias | b20f5e7 | 2020-05-30 19:17:33 +0300 | [diff] [blame] | 256 | if args.state == 0: |
Hengqi Chen | 08765a9 | 2021-10-31 23:20:10 +0800 | [diff] [blame] | 257 | state_filter = 'p->STATE_FIELD == 0' |
lorddoskias | b20f5e7 | 2020-05-30 19:17:33 +0300 | [diff] [blame] | 258 | elif args.state: |
| 259 | # these states are sometimes bitmask checked |
Hengqi Chen | 08765a9 | 2021-10-31 23:20:10 +0800 | [diff] [blame] | 260 | state_filter = 'p->STATE_FIELD & %d' % args.state |
lorddoskias | b20f5e7 | 2020-05-30 19:17:33 +0300 | [diff] [blame] | 261 | else: |
| 262 | state_filter = '1' |
ceeaspb | 47cecb6 | 2016-11-26 22:36:10 +0000 | [diff] [blame] | 263 | bpf_text = bpf_text.replace('THREAD_FILTER', thread_filter) |
lorddoskias | b20f5e7 | 2020-05-30 19:17:33 +0300 | [diff] [blame] | 264 | bpf_text = bpf_text.replace('STATE_FILTER', state_filter) |
Hengqi Chen | 08765a9 | 2021-10-31 23:20:10 +0800 | [diff] [blame] | 265 | if BPF.kernel_struct_has_field(b'task_struct', b'__state') == 1: |
| 266 | bpf_text = bpf_text.replace('STATE_FIELD', '__state') |
| 267 | else: |
| 268 | bpf_text = bpf_text.replace('STATE_FIELD', 'state') |
ceeaspb | 47cecb6 | 2016-11-26 22:36:10 +0000 | [diff] [blame] | 269 | |
| 270 | # set stack storage size |
| 271 | bpf_text = bpf_text.replace('STACK_STORAGE_SIZE', str(args.stack_storage_size)) |
| 272 | bpf_text = bpf_text.replace('MINBLOCK_US_VALUE', str(args.min_block_time)) |
| 273 | bpf_text = bpf_text.replace('MAXBLOCK_US_VALUE', str(args.max_block_time)) |
| 274 | |
| 275 | # handle stack args |
Teng Qin | e778db0 | 2018-04-24 16:11:49 -0700 | [diff] [blame] | 276 | kernel_stack_get = "stack_traces.get_stackid(ctx, 0)" |
| 277 | user_stack_get = "stack_traces.get_stackid(ctx, BPF_F_USER_STACK)" |
ceeaspb | 47cecb6 | 2016-11-26 22:36:10 +0000 | [diff] [blame] | 278 | stack_context = "" |
| 279 | if args.user_stacks_only: |
| 280 | stack_context = "user" |
| 281 | kernel_stack_get = "-1" |
| 282 | elif args.kernel_stacks_only: |
| 283 | stack_context = "kernel" |
| 284 | user_stack_get = "-1" |
| 285 | else: |
| 286 | stack_context = "user + kernel" |
| 287 | bpf_text = bpf_text.replace('USER_STACK_GET', user_stack_get) |
| 288 | bpf_text = bpf_text.replace('KERNEL_STACK_GET', kernel_stack_get) |
Nathan Scott | cf0792f | 2018-02-02 16:56:50 +1100 | [diff] [blame] | 289 | if args.ebpf: |
| 290 | print(bpf_text) |
| 291 | exit() |
Brendan Gregg | af2b46a | 2016-01-30 11:02:29 -0800 | [diff] [blame] | 292 | |
| 293 | # initialize BPF |
| 294 | b = BPF(text=bpf_text) |
Guodong Xu | 00b72fd | 2021-03-13 02:23:47 +0000 | [diff] [blame] | 295 | b.attach_kprobe(event_re="^finish_task_switch$|^finish_task_switch\.isra\.\d$", |
| 296 | fn_name="oncpu") |
Brendan Gregg | af2b46a | 2016-01-30 11:02:29 -0800 | [diff] [blame] | 297 | b.attach_kprobe(event="try_to_wake_up", fn_name="waker") |
| 298 | matched = b.num_open_kprobes() |
| 299 | if matched == 0: |
| 300 | print("0 functions traced. Exiting.") |
| 301 | exit() |
| 302 | |
| 303 | # header |
| 304 | if not folded: |
ceeaspb | 47cecb6 | 2016-11-26 22:36:10 +0000 | [diff] [blame] | 305 | print("Tracing blocked time (us) by %s off-CPU and waker stack" % |
| 306 | stack_context, end="") |
Brendan Gregg | af2b46a | 2016-01-30 11:02:29 -0800 | [diff] [blame] | 307 | if duration < 99999999: |
| 308 | print(" for %d secs." % duration) |
| 309 | else: |
| 310 | print("... Hit Ctrl-C to end.") |
| 311 | |
jeromemarchand | 09f9d3c | 2018-10-13 01:01:22 +0200 | [diff] [blame] | 312 | try: |
| 313 | sleep(duration) |
| 314 | except KeyboardInterrupt: |
| 315 | # as cleanup can take many seconds, trap Ctrl-C: |
| 316 | # print a newline for folded output on Ctrl-C |
| 317 | signal.signal(signal.SIGINT, signal_ignore) |
Brendan Gregg | af2b46a | 2016-01-30 11:02:29 -0800 | [diff] [blame] | 318 | |
Brendan Gregg | af2b46a | 2016-01-30 11:02:29 -0800 | [diff] [blame] | 319 | |
ceeaspb | 47cecb6 | 2016-11-26 22:36:10 +0000 | [diff] [blame] | 320 | if not folded: |
| 321 | print() |
Brendan Gregg | af2b46a | 2016-01-30 11:02:29 -0800 | [diff] [blame] | 322 | |
ceeaspb | 47cecb6 | 2016-11-26 22:36:10 +0000 | [diff] [blame] | 323 | missing_stacks = 0 |
| 324 | has_enomem = False |
| 325 | counts = b.get_table("counts") |
| 326 | stack_traces = b.get_table("stack_traces") |
Teng Qin | e778db0 | 2018-04-24 16:11:49 -0700 | [diff] [blame] | 327 | need_delimiter = args.delimited and not (args.kernel_stacks_only or |
| 328 | args.user_stacks_only) |
ceeaspb | 47cecb6 | 2016-11-26 22:36:10 +0000 | [diff] [blame] | 329 | for k, v in sorted(counts.items(), key=lambda counts: counts[1].value): |
| 330 | # handle get_stackid errors |
Teng Qin | e778db0 | 2018-04-24 16:11:49 -0700 | [diff] [blame] | 331 | if not args.user_stacks_only: |
| 332 | missing_stacks += int(stack_id_err(k.w_k_stack_id)) |
| 333 | missing_stacks += int(stack_id_err(k.t_k_stack_id)) |
| 334 | has_enomem = has_enomem or (k.w_k_stack_id == -errno.ENOMEM) or \ |
| 335 | (k.t_k_stack_id == -errno.ENOMEM) |
| 336 | if not args.kernel_stacks_only: |
| 337 | missing_stacks += int(stack_id_err(k.w_u_stack_id)) |
| 338 | missing_stacks += int(stack_id_err(k.t_u_stack_id)) |
| 339 | has_enomem = has_enomem or (k.w_u_stack_id == -errno.ENOMEM) or \ |
| 340 | (k.t_u_stack_id == -errno.ENOMEM) |
Brendan Gregg | af2b46a | 2016-01-30 11:02:29 -0800 | [diff] [blame] | 341 | |
ceeaspb | 47cecb6 | 2016-11-26 22:36:10 +0000 | [diff] [blame] | 342 | waker_user_stack = [] if k.w_u_stack_id < 1 else \ |
| 343 | reversed(list(stack_traces.walk(k.w_u_stack_id))[1:]) |
| 344 | waker_kernel_stack = [] if k.w_k_stack_id < 1 else \ |
| 345 | reversed(list(stack_traces.walk(k.w_k_stack_id))[1:]) |
| 346 | target_user_stack = [] if k.t_u_stack_id < 1 else \ |
| 347 | stack_traces.walk(k.t_u_stack_id) |
| 348 | target_kernel_stack = [] if k.t_k_stack_id < 1 else \ |
| 349 | stack_traces.walk(k.t_k_stack_id) |
Brendan Gregg | af2b46a | 2016-01-30 11:02:29 -0800 | [diff] [blame] | 350 | |
ceeaspb | 47cecb6 | 2016-11-26 22:36:10 +0000 | [diff] [blame] | 351 | if folded: |
| 352 | # print folded stack output |
jeromemarchand | b96ebcd | 2018-10-10 01:58:15 +0200 | [diff] [blame] | 353 | line = [k.target.decode('utf-8', 'replace')] |
Teng Qin | e778db0 | 2018-04-24 16:11:49 -0700 | [diff] [blame] | 354 | if not args.kernel_stacks_only: |
| 355 | if stack_id_err(k.t_u_stack_id): |
Jiri Olsa | ac00ac5 | 2019-11-15 12:45:59 +0100 | [diff] [blame] | 356 | line.append("[Missed User Stack] %d" % k.t_u_stack_id) |
Teng Qin | e778db0 | 2018-04-24 16:11:49 -0700 | [diff] [blame] | 357 | else: |
Jerome Marchand | f03beca | 2019-02-15 17:35:37 +0100 | [diff] [blame] | 358 | line.extend([b.sym(addr, k.t_tgid).decode('utf-8', 'replace') |
Teng Qin | e778db0 | 2018-04-24 16:11:49 -0700 | [diff] [blame] | 359 | for addr in reversed(list(target_user_stack)[1:])]) |
| 360 | if not args.user_stacks_only: |
| 361 | line.extend(["-"] if (need_delimiter and k.t_k_stack_id > 0 and k.t_u_stack_id > 0) else []) |
| 362 | if stack_id_err(k.t_k_stack_id): |
| 363 | line.append("[Missed Kernel Stack]") |
| 364 | else: |
Jerome Marchand | f03beca | 2019-02-15 17:35:37 +0100 | [diff] [blame] | 365 | line.extend([b.ksym(addr).decode('utf-8', 'replace') |
Teng Qin | e778db0 | 2018-04-24 16:11:49 -0700 | [diff] [blame] | 366 | for addr in reversed(list(target_kernel_stack)[1:])]) |
| 367 | line.append("--") |
| 368 | if not args.user_stacks_only: |
| 369 | if stack_id_err(k.w_k_stack_id): |
| 370 | line.append("[Missed Kernel Stack]") |
| 371 | else: |
Jerome Marchand | f03beca | 2019-02-15 17:35:37 +0100 | [diff] [blame] | 372 | line.extend([b.ksym(addr).decode('utf-8', 'replace') |
Teng Qin | e778db0 | 2018-04-24 16:11:49 -0700 | [diff] [blame] | 373 | for addr in reversed(list(waker_kernel_stack))]) |
| 374 | if not args.kernel_stacks_only: |
| 375 | line.extend(["-"] if (need_delimiter and k.w_u_stack_id > 0 and k.w_k_stack_id > 0) else []) |
| 376 | if stack_id_err(k.w_u_stack_id): |
Andrea Righi | 7813f8e | 2018-11-20 17:54:46 +0100 | [diff] [blame] | 377 | line.append("[Missed User Stack]") |
Teng Qin | e778db0 | 2018-04-24 16:11:49 -0700 | [diff] [blame] | 378 | else: |
Jerome Marchand | f03beca | 2019-02-15 17:35:37 +0100 | [diff] [blame] | 379 | line.extend([b.sym(addr, k.w_tgid).decode('utf-8', 'replace') |
Teng Qin | e778db0 | 2018-04-24 16:11:49 -0700 | [diff] [blame] | 380 | for addr in reversed(list(waker_user_stack))]) |
jeromemarchand | b96ebcd | 2018-10-10 01:58:15 +0200 | [diff] [blame] | 381 | line.append(k.waker.decode('utf-8', 'replace')) |
ceeaspb | 47cecb6 | 2016-11-26 22:36:10 +0000 | [diff] [blame] | 382 | print("%s %d" % (";".join(line), v.value)) |
ceeaspb | 47cecb6 | 2016-11-26 22:36:10 +0000 | [diff] [blame] | 383 | else: |
| 384 | # print wakeup name then stack in reverse order |
Yohei Ueda | 89bb40a | 2019-08-09 14:12:21 +0900 | [diff] [blame] | 385 | print(" %-16s %s %s" % ("waker:", k.waker.decode('utf-8', 'replace'), k.w_pid)) |
Teng Qin | e778db0 | 2018-04-24 16:11:49 -0700 | [diff] [blame] | 386 | if not args.kernel_stacks_only: |
| 387 | if stack_id_err(k.w_u_stack_id): |
Jiri Olsa | ac00ac5 | 2019-11-15 12:45:59 +0100 | [diff] [blame] | 388 | print(" [Missed User Stack] %d" % k.w_u_stack_id) |
Teng Qin | e778db0 | 2018-04-24 16:11:49 -0700 | [diff] [blame] | 389 | else: |
| 390 | for addr in waker_user_stack: |
| 391 | print(" %s" % b.sym(addr, k.w_tgid)) |
| 392 | if not args.user_stacks_only: |
| 393 | if need_delimiter and k.w_u_stack_id > 0 and k.w_k_stack_id > 0: |
| 394 | print(" -") |
| 395 | if stack_id_err(k.w_k_stack_id): |
| 396 | print(" [Missed Kernel Stack]") |
| 397 | else: |
| 398 | for addr in waker_kernel_stack: |
| 399 | print(" %s" % b.ksym(addr)) |
Brendan Gregg | af2b46a | 2016-01-30 11:02:29 -0800 | [diff] [blame] | 400 | |
ceeaspb | 47cecb6 | 2016-11-26 22:36:10 +0000 | [diff] [blame] | 401 | # print waker/wakee delimiter |
| 402 | print(" %-16s %s" % ("--", "--")) |
Javier Honduvilla Coto | 64bf965 | 2018-08-01 06:50:19 +0200 | [diff] [blame] | 403 | |
Teng Qin | e778db0 | 2018-04-24 16:11:49 -0700 | [diff] [blame] | 404 | if not args.user_stacks_only: |
| 405 | if stack_id_err(k.t_k_stack_id): |
| 406 | print(" [Missed Kernel Stack]") |
| 407 | else: |
| 408 | for addr in target_kernel_stack: |
| 409 | print(" %s" % b.ksym(addr)) |
| 410 | if not args.kernel_stacks_only: |
| 411 | if need_delimiter and k.t_u_stack_id > 0 and k.t_k_stack_id > 0: |
| 412 | print(" -") |
| 413 | if stack_id_err(k.t_u_stack_id): |
| 414 | print(" [Missed User Stack]") |
| 415 | else: |
| 416 | for addr in target_user_stack: |
| 417 | print(" %s" % b.sym(addr, k.t_tgid)) |
Yohei Ueda | 89bb40a | 2019-08-09 14:12:21 +0900 | [diff] [blame] | 418 | print(" %-16s %s %s" % ("target:", k.target.decode('utf-8', 'replace'), k.t_pid)) |
ceeaspb | 47cecb6 | 2016-11-26 22:36:10 +0000 | [diff] [blame] | 419 | print(" %d\n" % v.value) |
| 420 | |
| 421 | if missing_stacks > 0: |
| 422 | enomem_str = " Consider increasing --stack-storage-size." |
Teng Qin | e778db0 | 2018-04-24 16:11:49 -0700 | [diff] [blame] | 423 | print("WARNING: %d stack traces lost and could not be displayed.%s" % |
| 424 | (missing_stacks, (enomem_str if has_enomem else "")), |
ceeaspb | 47cecb6 | 2016-11-26 22:36:10 +0000 | [diff] [blame] | 425 | file=stderr) |