Alexey Ivanov | cc01a9c | 2019-01-16 09:50:46 -0800 | [diff] [blame] | 1 | #!/usr/bin/python |
Sasha Goldshtein | 8538485 | 2016-02-12 01:29:39 -0800 | [diff] [blame] | 2 | # |
Sasha Goldshtein | 7df65da | 2016-02-14 05:12:27 -0800 | [diff] [blame] | 3 | # argdist Trace a function and display a distribution of its |
Sasha Goldshtein | fd60d55 | 2016-03-01 12:15:34 -0800 | [diff] [blame] | 4 | # parameter values as a histogram or frequency count. |
Sasha Goldshtein | 8538485 | 2016-02-12 01:29:39 -0800 | [diff] [blame] | 5 | # |
Sasha Goldshtein | 4725a72 | 2016-10-18 20:54:47 +0300 | [diff] [blame] | 6 | # USAGE: argdist [-h] [-p PID] [-z STRING_SIZE] [-i INTERVAL] [-n COUNT] [-v] |
| 7 | # [-c] [-T TOP] [-C specifier] [-H specifier] [-I header] |
zhenwei pi | 6677321 | 2021-09-06 18:28:16 +0800 | [diff] [blame] | 8 | # [-t TID] |
Sasha Goldshtein | 8538485 | 2016-02-12 01:29:39 -0800 | [diff] [blame] | 9 | # |
| 10 | # Licensed under the Apache License, Version 2.0 (the "License") |
| 11 | # Copyright (C) 2016 Sasha Goldshtein. |
| 12 | |
Sumanth Korikkar | 306080b | 2020-04-27 04:37:23 -0500 | [diff] [blame] | 13 | from bcc import BPF, USDT, StrcmpRewrite |
Sasha Goldshtein | 8538485 | 2016-02-12 01:29:39 -0800 | [diff] [blame] | 14 | from time import sleep, strftime |
| 15 | import argparse |
Sasha Goldshtein | 392d5c8 | 2016-02-12 11:14:20 -0800 | [diff] [blame] | 16 | import re |
Sasha Goldshtein | c955130 | 2016-02-21 02:21:46 -0800 | [diff] [blame] | 17 | import traceback |
Sasha Goldshtein | fd60d55 | 2016-03-01 12:15:34 -0800 | [diff] [blame] | 18 | import os |
Sasha Goldshtein | c955130 | 2016-02-21 02:21:46 -0800 | [diff] [blame] | 19 | import sys |
Sasha Goldshtein | 8538485 | 2016-02-12 01:29:39 -0800 | [diff] [blame] | 20 | |
Sasha Goldshtein | 3e39a08 | 2016-03-24 08:39:47 -0700 | [diff] [blame] | 21 | class Probe(object): |
Sasha Goldshtein | 8538485 | 2016-02-12 01:29:39 -0800 | [diff] [blame] | 22 | next_probe_index = 0 |
Sasha Goldshtein | c8f752f | 2016-10-17 02:18:43 -0700 | [diff] [blame] | 23 | streq_index = 0 |
Rafael Fonseca | af236e7 | 2017-02-15 17:28:26 +0100 | [diff] [blame] | 24 | aliases = {"$PID": "(bpf_get_current_pid_tgid() >> 32)"} |
Sasha Goldshtein | 5e4e1f4 | 2016-02-12 06:52:19 -0800 | [diff] [blame] | 25 | |
| 26 | def _substitute_aliases(self, expr): |
| 27 | if expr is None: |
| 28 | return expr |
Sasha Goldshtein | 3e39a08 | 2016-03-24 08:39:47 -0700 | [diff] [blame] | 29 | for alias, subst in Probe.aliases.items(): |
Sasha Goldshtein | 5e4e1f4 | 2016-02-12 06:52:19 -0800 | [diff] [blame] | 30 | expr = expr.replace(alias, subst) |
| 31 | return expr |
Sasha Goldshtein | 8538485 | 2016-02-12 01:29:39 -0800 | [diff] [blame] | 32 | |
Sasha Goldshtein | 392d5c8 | 2016-02-12 11:14:20 -0800 | [diff] [blame] | 33 | def _parse_signature(self): |
| 34 | params = map(str.strip, self.signature.split(',')) |
| 35 | self.param_types = {} |
| 36 | for param in params: |
| 37 | # If the type is a pointer, the * can be next to the |
| 38 | # param name. Other complex types like arrays are not |
| 39 | # supported right now. |
| 40 | index = param.rfind('*') |
| 41 | index = index if index != -1 else param.rfind(' ') |
Sasha Goldshtein | f41ae86 | 2016-10-19 01:14:30 +0300 | [diff] [blame] | 42 | param_type = param[0:index + 1].strip() |
| 43 | param_name = param[index + 1:].strip() |
Sasha Goldshtein | 392d5c8 | 2016-02-12 11:14:20 -0800 | [diff] [blame] | 44 | self.param_types[param_name] = param_type |
Sumanth Korikkar | 306080b | 2020-04-27 04:37:23 -0500 | [diff] [blame] | 45 | # Maintain list of user params. Then later decide to |
Sumanth Korikkar | 7f6066d | 2020-05-20 10:49:56 -0500 | [diff] [blame] | 46 | # switch to bpf_probe_read_kernel or bpf_probe_read_user. |
Sumanth Korikkar | 306080b | 2020-04-27 04:37:23 -0500 | [diff] [blame] | 47 | if "__user" in param_type.split(): |
| 48 | self.probe_user_list.add(param_name) |
Sasha Goldshtein | 392d5c8 | 2016-02-12 11:14:20 -0800 | [diff] [blame] | 49 | |
Sasha Goldshtein | 3e39a08 | 2016-03-24 08:39:47 -0700 | [diff] [blame] | 50 | def _generate_entry(self): |
| 51 | self.entry_probe_func = self.probe_func_name + "_entry" |
| 52 | text = """ |
Sasha Goldshtein | 392d5c8 | 2016-02-12 11:14:20 -0800 | [diff] [blame] | 53 | int PROBENAME(struct pt_regs *ctx SIGNATURE) |
| 54 | { |
Rafael Fonseca | af236e7 | 2017-02-15 17:28:26 +0100 | [diff] [blame] | 55 | u64 __pid_tgid = bpf_get_current_pid_tgid(); |
| 56 | u32 __pid = __pid_tgid; // lower 32 bits |
| 57 | u32 __tgid = __pid_tgid >> 32; // upper 32 bits |
Sasha Goldshtein | 392d5c8 | 2016-02-12 11:14:20 -0800 | [diff] [blame] | 58 | PID_FILTER |
zhenwei pi | 6677321 | 2021-09-06 18:28:16 +0800 | [diff] [blame] | 59 | TID_FILTER |
Sasha Goldshtein | 392d5c8 | 2016-02-12 11:14:20 -0800 | [diff] [blame] | 60 | COLLECT |
| 61 | return 0; |
| 62 | } |
| 63 | """ |
Sasha Goldshtein | 392d5c8 | 2016-02-12 11:14:20 -0800 | [diff] [blame] | 64 | text = text.replace("PROBENAME", self.entry_probe_func) |
| 65 | text = text.replace("SIGNATURE", |
| 66 | "" if len(self.signature) == 0 else ", " + self.signature) |
Rafael Fonseca | af236e7 | 2017-02-15 17:28:26 +0100 | [diff] [blame] | 67 | text = text.replace("PID_FILTER", self._generate_pid_filter()) |
zhenwei pi | 6677321 | 2021-09-06 18:28:16 +0800 | [diff] [blame] | 68 | text = text.replace("TID_FILTER", self._generate_tid_filter()) |
Sasha Goldshtein | 392d5c8 | 2016-02-12 11:14:20 -0800 | [diff] [blame] | 69 | collect = "" |
| 70 | for pname in self.args_to_probe: |
Sasha Goldshtein | e350115 | 2016-02-13 03:56:29 -0800 | [diff] [blame] | 71 | param_hash = self.hashname_prefix + pname |
| 72 | if pname == "__latency": |
| 73 | collect += """ |
| 74 | u64 __time = bpf_ktime_get_ns(); |
Rafael Fonseca | af236e7 | 2017-02-15 17:28:26 +0100 | [diff] [blame] | 75 | %s.update(&__pid, &__time); |
Sasha Goldshtein | f41ae86 | 2016-10-19 01:14:30 +0300 | [diff] [blame] | 76 | """ % param_hash |
Sasha Goldshtein | e350115 | 2016-02-13 03:56:29 -0800 | [diff] [blame] | 77 | else: |
Rafael Fonseca | af236e7 | 2017-02-15 17:28:26 +0100 | [diff] [blame] | 78 | collect += "%s.update(&__pid, &%s);\n" % \ |
Sasha Goldshtein | e350115 | 2016-02-13 03:56:29 -0800 | [diff] [blame] | 79 | (param_hash, pname) |
Sasha Goldshtein | 392d5c8 | 2016-02-12 11:14:20 -0800 | [diff] [blame] | 80 | text = text.replace("COLLECT", collect) |
| 81 | return text |
| 82 | |
| 83 | def _generate_entry_probe(self): |
Sasha Goldshtein | 392d5c8 | 2016-02-12 11:14:20 -0800 | [diff] [blame] | 84 | # Any $entry(name) expressions result in saving that argument |
| 85 | # when entering the function. |
| 86 | self.args_to_probe = set() |
| 87 | regex = r"\$entry\((\w+)\)" |
Sasha Goldshtein | cc27edf | 2016-02-14 03:49:01 -0800 | [diff] [blame] | 88 | for expr in self.exprs: |
| 89 | for arg in re.finditer(regex, expr): |
| 90 | self.args_to_probe.add(arg.group(1)) |
Sasha Goldshtein | e350115 | 2016-02-13 03:56:29 -0800 | [diff] [blame] | 91 | for arg in re.finditer(regex, self.filter): |
Sasha Goldshtein | 392d5c8 | 2016-02-12 11:14:20 -0800 | [diff] [blame] | 92 | self.args_to_probe.add(arg.group(1)) |
Sasha Goldshtein | cc27edf | 2016-02-14 03:49:01 -0800 | [diff] [blame] | 93 | if any(map(lambda expr: "$latency" in expr, self.exprs)) or \ |
| 94 | "$latency" in self.filter: |
Sasha Goldshtein | e350115 | 2016-02-13 03:56:29 -0800 | [diff] [blame] | 95 | self.args_to_probe.add("__latency") |
| 96 | self.param_types["__latency"] = "u64" # nanoseconds |
Sasha Goldshtein | 392d5c8 | 2016-02-12 11:14:20 -0800 | [diff] [blame] | 97 | for pname in self.args_to_probe: |
| 98 | if pname not in self.param_types: |
Sasha Goldshtein | f41ae86 | 2016-10-19 01:14:30 +0300 | [diff] [blame] | 99 | raise ValueError("$entry(%s): no such param" % |
| 100 | arg) |
Sasha Goldshtein | 392d5c8 | 2016-02-12 11:14:20 -0800 | [diff] [blame] | 101 | |
| 102 | self.hashname_prefix = "%s_param_" % self.probe_hash_name |
| 103 | text = "" |
| 104 | for pname in self.args_to_probe: |
| 105 | # Each argument is stored in a separate hash that is |
| 106 | # keyed by pid. |
| 107 | text += "BPF_HASH(%s, u32, %s);\n" % \ |
| 108 | (self.hashname_prefix + pname, |
| 109 | self.param_types[pname]) |
| 110 | text += self._generate_entry() |
| 111 | return text |
| 112 | |
| 113 | def _generate_retprobe_prefix(self): |
| 114 | # After we're done here, there are __%s_val variables for each |
| 115 | # argument we needed to probe using $entry(name), and they all |
| 116 | # have values (which isn't necessarily the case if we missed |
| 117 | # the method entry probe). |
Rafael Fonseca | af236e7 | 2017-02-15 17:28:26 +0100 | [diff] [blame] | 118 | text = "" |
Sasha Goldshtein | 392d5c8 | 2016-02-12 11:14:20 -0800 | [diff] [blame] | 119 | self.param_val_names = {} |
| 120 | for pname in self.args_to_probe: |
| 121 | val_name = "__%s_val" % pname |
| 122 | text += "%s *%s = %s.lookup(&__pid);\n" % \ |
| 123 | (self.param_types[pname], val_name, |
| 124 | self.hashname_prefix + pname) |
| 125 | text += "if (%s == 0) { return 0 ; }\n" % val_name |
| 126 | self.param_val_names[pname] = val_name |
| 127 | return text |
| 128 | |
| 129 | def _replace_entry_exprs(self): |
| 130 | for pname, vname in self.param_val_names.items(): |
Sasha Goldshtein | e350115 | 2016-02-13 03:56:29 -0800 | [diff] [blame] | 131 | if pname == "__latency": |
| 132 | entry_expr = "$latency" |
| 133 | val_expr = "(bpf_ktime_get_ns() - *%s)" % vname |
| 134 | else: |
| 135 | entry_expr = "$entry(%s)" % pname |
| 136 | val_expr = "(*%s)" % vname |
Sasha Goldshtein | cc27edf | 2016-02-14 03:49:01 -0800 | [diff] [blame] | 137 | for i in range(0, len(self.exprs)): |
| 138 | self.exprs[i] = self.exprs[i].replace( |
| 139 | entry_expr, val_expr) |
Sasha Goldshtein | e350115 | 2016-02-13 03:56:29 -0800 | [diff] [blame] | 140 | self.filter = self.filter.replace(entry_expr, |
| 141 | val_expr) |
Sasha Goldshtein | 392d5c8 | 2016-02-12 11:14:20 -0800 | [diff] [blame] | 142 | |
| 143 | def _attach_entry_probe(self): |
| 144 | if self.is_user: |
| 145 | self.bpf.attach_uprobe(name=self.library, |
| 146 | sym=self.function, |
| 147 | fn_name=self.entry_probe_func, |
| 148 | pid=self.pid or -1) |
| 149 | else: |
| 150 | self.bpf.attach_kprobe(event=self.function, |
| 151 | fn_name=self.entry_probe_func) |
| 152 | |
Sasha Goldshtein | 7983d6b | 2016-02-13 23:14:18 -0800 | [diff] [blame] | 153 | def _bail(self, error): |
| 154 | raise ValueError("error parsing probe '%s': %s" % |
| 155 | (self.raw_spec, error)) |
| 156 | |
| 157 | def _validate_specifier(self): |
| 158 | # Everything after '#' is the probe label, ignore it |
| 159 | spec = self.raw_spec.split('#')[0] |
| 160 | parts = spec.strip().split(':') |
| 161 | if len(parts) < 3: |
| 162 | self._bail("at least the probe type, library, and " + |
| 163 | "function signature must be specified") |
| 164 | if len(parts) > 6: |
| 165 | self._bail("extraneous ':'-separated parts detected") |
Sasha Goldshtein | 3e39a08 | 2016-03-24 08:39:47 -0700 | [diff] [blame] | 166 | if parts[0] not in ["r", "p", "t", "u"]: |
Sasha Goldshtein | f41ae86 | 2016-10-19 01:14:30 +0300 | [diff] [blame] | 167 | self._bail("probe type must be 'p', 'r', 't', or 'u'" + |
| 168 | " but got '%s'" % parts[0]) |
Sasha Goldshtein | 3fa7ba1 | 2017-01-14 11:17:40 +0000 | [diff] [blame] | 169 | if re.match(r"\S+\(.*\)", parts[2]) is None: |
Sasha Goldshtein | 7983d6b | 2016-02-13 23:14:18 -0800 | [diff] [blame] | 170 | self._bail(("function signature '%s' has an invalid " + |
Sasha Goldshtein | cc27edf | 2016-02-14 03:49:01 -0800 | [diff] [blame] | 171 | "format") % parts[2]) |
| 172 | |
| 173 | def _parse_expr_types(self, expr_types): |
| 174 | if len(expr_types) == 0: |
| 175 | self._bail("no expr types specified") |
| 176 | self.expr_types = expr_types.split(',') |
| 177 | |
| 178 | def _parse_exprs(self, exprs): |
| 179 | if len(exprs) == 0: |
| 180 | self._bail("no exprs specified") |
| 181 | self.exprs = exprs.split(',') |
Sasha Goldshtein | 7983d6b | 2016-02-13 23:14:18 -0800 | [diff] [blame] | 182 | |
Sasha Goldshtein | 3fa7ba1 | 2017-01-14 11:17:40 +0000 | [diff] [blame] | 183 | def _make_valid_identifier(self, ident): |
| 184 | return re.sub(r'[^A-Za-z0-9_]', '_', ident) |
| 185 | |
Sasha Goldshtein | 69e361a | 2016-09-27 19:40:00 +0300 | [diff] [blame] | 186 | def __init__(self, tool, type, specifier): |
| 187 | self.usdt_ctx = None |
Sasha Goldshtein | c8f752f | 2016-10-17 02:18:43 -0700 | [diff] [blame] | 188 | self.streq_functions = "" |
Sasha Goldshtein | 69e361a | 2016-09-27 19:40:00 +0300 | [diff] [blame] | 189 | self.pid = tool.args.pid |
zhenwei pi | 6677321 | 2021-09-06 18:28:16 +0800 | [diff] [blame] | 190 | self.tid = tool.args.tid |
Sasha Goldshtein | d2f4762 | 2016-10-04 18:40:15 +0300 | [diff] [blame] | 191 | self.cumulative = tool.args.cumulative or False |
Sasha Goldshtein | 7983d6b | 2016-02-13 23:14:18 -0800 | [diff] [blame] | 192 | self.raw_spec = specifier |
Sumanth Korikkar | 306080b | 2020-04-27 04:37:23 -0500 | [diff] [blame] | 193 | self.probe_user_list = set() |
| 194 | self.bin_cmp = False |
Sasha Goldshtein | 7983d6b | 2016-02-13 23:14:18 -0800 | [diff] [blame] | 195 | self._validate_specifier() |
Sasha Goldshtein | c955130 | 2016-02-21 02:21:46 -0800 | [diff] [blame] | 196 | |
Sasha Goldshtein | 7983d6b | 2016-02-13 23:14:18 -0800 | [diff] [blame] | 197 | spec_and_label = specifier.split('#') |
Sasha Goldshtein | ed21adf | 2016-02-12 03:04:53 -0800 | [diff] [blame] | 198 | self.label = spec_and_label[1] \ |
| 199 | if len(spec_and_label) == 2 else None |
Sasha Goldshtein | 392d5c8 | 2016-02-12 11:14:20 -0800 | [diff] [blame] | 200 | |
Sasha Goldshtein | ed21adf | 2016-02-12 03:04:53 -0800 | [diff] [blame] | 201 | parts = spec_and_label[0].strip().split(':') |
Sasha Goldshtein | 8538485 | 2016-02-12 01:29:39 -0800 | [diff] [blame] | 202 | self.type = type # hist or freq |
Sasha Goldshtein | fd60d55 | 2016-03-01 12:15:34 -0800 | [diff] [blame] | 203 | self.probe_type = parts[0] |
Sasha Goldshtein | 8538485 | 2016-02-12 01:29:39 -0800 | [diff] [blame] | 204 | fparts = parts[2].split('(') |
Sasha Goldshtein | 7983d6b | 2016-02-13 23:14:18 -0800 | [diff] [blame] | 205 | self.function = fparts[0].strip() |
Sasha Goldshtein | fd60d55 | 2016-03-01 12:15:34 -0800 | [diff] [blame] | 206 | if self.probe_type == "t": |
| 207 | self.library = "" # kernel |
| 208 | self.tp_category = parts[1] |
| 209 | self.tp_event = self.function |
Sasha Goldshtein | 3e39a08 | 2016-03-24 08:39:47 -0700 | [diff] [blame] | 210 | elif self.probe_type == "u": |
| 211 | self.library = parts[1] |
Sasha Goldshtein | 3fa7ba1 | 2017-01-14 11:17:40 +0000 | [diff] [blame] | 212 | self.probe_func_name = self._make_valid_identifier( |
Paul Chaignon | 956ca1c | 2017-03-04 20:07:56 +0100 | [diff] [blame] | 213 | "%s_probe%d" % |
Sasha Goldshtein | 3fa7ba1 | 2017-01-14 11:17:40 +0000 | [diff] [blame] | 214 | (self.function, Probe.next_probe_index)) |
Sasha Goldshtein | 69e361a | 2016-09-27 19:40:00 +0300 | [diff] [blame] | 215 | self._enable_usdt_probe() |
Sasha Goldshtein | fd60d55 | 2016-03-01 12:15:34 -0800 | [diff] [blame] | 216 | else: |
| 217 | self.library = parts[1] |
| 218 | self.is_user = len(self.library) > 0 |
Sasha Goldshtein | 7983d6b | 2016-02-13 23:14:18 -0800 | [diff] [blame] | 219 | self.signature = fparts[1].strip()[:-1] |
Sasha Goldshtein | 392d5c8 | 2016-02-12 11:14:20 -0800 | [diff] [blame] | 220 | self._parse_signature() |
| 221 | |
| 222 | # If the user didn't specify an expression to probe, we probe |
| 223 | # the retval in a ret probe, or simply the value "1" otherwise. |
Sasha Goldshtein | 8538485 | 2016-02-12 01:29:39 -0800 | [diff] [blame] | 224 | self.is_default_expr = len(parts) < 5 |
| 225 | if not self.is_default_expr: |
Sasha Goldshtein | cc27edf | 2016-02-14 03:49:01 -0800 | [diff] [blame] | 226 | self._parse_expr_types(parts[3]) |
| 227 | self._parse_exprs(parts[4]) |
| 228 | if len(self.exprs) != len(self.expr_types): |
| 229 | self._bail("mismatched # of exprs and types") |
| 230 | if self.type == "hist" and len(self.expr_types) > 1: |
| 231 | self._bail("histograms can only have 1 expr") |
Sasha Goldshtein | 8538485 | 2016-02-12 01:29:39 -0800 | [diff] [blame] | 232 | else: |
Sasha Goldshtein | fd60d55 | 2016-03-01 12:15:34 -0800 | [diff] [blame] | 233 | if not self.probe_type == "r" and self.type == "hist": |
Sasha Goldshtein | cc27edf | 2016-02-14 03:49:01 -0800 | [diff] [blame] | 234 | self._bail("histograms must have expr") |
| 235 | self.expr_types = \ |
Sasha Goldshtein | fd60d55 | 2016-03-01 12:15:34 -0800 | [diff] [blame] | 236 | ["u64" if not self.probe_type == "r" else "int"] |
Sasha Goldshtein | cc27edf | 2016-02-14 03:49:01 -0800 | [diff] [blame] | 237 | self.exprs = \ |
Sasha Goldshtein | fd60d55 | 2016-03-01 12:15:34 -0800 | [diff] [blame] | 238 | ["1" if not self.probe_type == "r" else "$retval"] |
Sasha Goldshtein | e350115 | 2016-02-13 03:56:29 -0800 | [diff] [blame] | 239 | self.filter = "" if len(parts) != 6 else parts[5] |
Sasha Goldshtein | 392d5c8 | 2016-02-12 11:14:20 -0800 | [diff] [blame] | 240 | self._substitute_exprs() |
| 241 | |
Sasha Goldshtein | c955130 | 2016-02-21 02:21:46 -0800 | [diff] [blame] | 242 | # Do we need to attach an entry probe so that we can collect an |
Sasha Goldshtein | 392d5c8 | 2016-02-12 11:14:20 -0800 | [diff] [blame] | 243 | # argument that is required for an exit (return) probe? |
Sasha Goldshtein | cc27edf | 2016-02-14 03:49:01 -0800 | [diff] [blame] | 244 | def check(expr): |
| 245 | keywords = ["$entry", "$latency"] |
| 246 | return any(map(lambda kw: kw in expr, keywords)) |
Sasha Goldshtein | fd60d55 | 2016-03-01 12:15:34 -0800 | [diff] [blame] | 247 | self.entry_probe_required = self.probe_type == "r" and \ |
Sasha Goldshtein | cc27edf | 2016-02-14 03:49:01 -0800 | [diff] [blame] | 248 | (any(map(check, self.exprs)) or check(self.filter)) |
Sasha Goldshtein | 392d5c8 | 2016-02-12 11:14:20 -0800 | [diff] [blame] | 249 | |
Sasha Goldshtein | 3fa7ba1 | 2017-01-14 11:17:40 +0000 | [diff] [blame] | 250 | self.probe_func_name = self._make_valid_identifier( |
Paul Chaignon | 956ca1c | 2017-03-04 20:07:56 +0100 | [diff] [blame] | 251 | "%s_probe%d" % |
Sasha Goldshtein | 3fa7ba1 | 2017-01-14 11:17:40 +0000 | [diff] [blame] | 252 | (self.function, Probe.next_probe_index)) |
| 253 | self.probe_hash_name = self._make_valid_identifier( |
Paul Chaignon | 956ca1c | 2017-03-04 20:07:56 +0100 | [diff] [blame] | 254 | "%s_hash%d" % |
Sasha Goldshtein | 3fa7ba1 | 2017-01-14 11:17:40 +0000 | [diff] [blame] | 255 | (self.function, Probe.next_probe_index)) |
Sasha Goldshtein | 3e39a08 | 2016-03-24 08:39:47 -0700 | [diff] [blame] | 256 | Probe.next_probe_index += 1 |
| 257 | |
Sasha Goldshtein | 69e361a | 2016-09-27 19:40:00 +0300 | [diff] [blame] | 258 | def _enable_usdt_probe(self): |
| 259 | self.usdt_ctx = USDT(path=self.library, pid=self.pid) |
| 260 | self.usdt_ctx.enable_probe( |
| 261 | self.function, self.probe_func_name) |
Sasha Goldshtein | 8538485 | 2016-02-12 01:29:39 -0800 | [diff] [blame] | 262 | |
Sasha Goldshtein | 392d5c8 | 2016-02-12 11:14:20 -0800 | [diff] [blame] | 263 | def _substitute_exprs(self): |
Sasha Goldshtein | cc27edf | 2016-02-14 03:49:01 -0800 | [diff] [blame] | 264 | def repl(expr): |
| 265 | expr = self._substitute_aliases(expr) |
Sumanth Korikkar | 306080b | 2020-04-27 04:37:23 -0500 | [diff] [blame] | 266 | rdict = StrcmpRewrite.rewrite_expr(expr, |
| 267 | self.bin_cmp, self.library, |
| 268 | self.probe_user_list, self.streq_functions, |
| 269 | Probe.streq_index) |
| 270 | expr = rdict["expr"] |
| 271 | self.streq_functions = rdict["streq_functions"] |
| 272 | Probe.streq_index = rdict["probeid"] |
Naveen N. Rao | 4afa96a | 2016-05-03 14:54:21 +0530 | [diff] [blame] | 273 | return expr.replace("$retval", "PT_REGS_RC(ctx)") |
Sasha Goldshtein | cc27edf | 2016-02-14 03:49:01 -0800 | [diff] [blame] | 274 | for i in range(0, len(self.exprs)): |
| 275 | self.exprs[i] = repl(self.exprs[i]) |
| 276 | self.filter = repl(self.filter) |
Sasha Goldshtein | 392d5c8 | 2016-02-12 11:14:20 -0800 | [diff] [blame] | 277 | |
Sasha Goldshtein | cc27edf | 2016-02-14 03:49:01 -0800 | [diff] [blame] | 278 | def _is_string(self, expr_type): |
| 279 | return expr_type == "char*" or expr_type == "char *" |
Sasha Goldshtein | 8538485 | 2016-02-12 01:29:39 -0800 | [diff] [blame] | 280 | |
Sasha Goldshtein | cc27edf | 2016-02-14 03:49:01 -0800 | [diff] [blame] | 281 | def _generate_hash_field(self, i): |
| 282 | if self._is_string(self.expr_types[i]): |
| 283 | return "struct __string_t v%d;\n" % i |
| 284 | else: |
| 285 | return "%s v%d;\n" % (self.expr_types[i], i) |
| 286 | |
Sasha Goldshtein | 69e361a | 2016-09-27 19:40:00 +0300 | [diff] [blame] | 287 | def _generate_usdt_arg_assignment(self, i): |
| 288 | expr = self.exprs[i] |
| 289 | if self.probe_type == "u" and expr[0:3] == "arg": |
Sasha Goldshtein | 3a5256f | 2017-02-20 15:42:57 +0000 | [diff] [blame] | 290 | arg_index = int(expr[3]) |
| 291 | arg_ctype = self.usdt_ctx.get_probe_arg_ctype( |
| 292 | self.function, arg_index - 1) |
| 293 | return (" %s %s = 0;\n" + |
Sasha Goldshtein | f41ae86 | 2016-10-19 01:14:30 +0300 | [diff] [blame] | 294 | " bpf_usdt_readarg(%s, ctx, &%s);\n") \ |
Sasha Goldshtein | 3a5256f | 2017-02-20 15:42:57 +0000 | [diff] [blame] | 295 | % (arg_ctype, expr, expr[3], expr) |
Sasha Goldshtein | 69e361a | 2016-09-27 19:40:00 +0300 | [diff] [blame] | 296 | else: |
| 297 | return "" |
| 298 | |
Sasha Goldshtein | cc27edf | 2016-02-14 03:49:01 -0800 | [diff] [blame] | 299 | def _generate_field_assignment(self, i): |
Sasha Goldshtein | 69e361a | 2016-09-27 19:40:00 +0300 | [diff] [blame] | 300 | text = self._generate_usdt_arg_assignment(i) |
Sasha Goldshtein | cc27edf | 2016-02-14 03:49:01 -0800 | [diff] [blame] | 301 | if self._is_string(self.expr_types[i]): |
Sumanth Korikkar | 306080b | 2020-04-27 04:37:23 -0500 | [diff] [blame] | 302 | if self.is_user or \ |
| 303 | self.exprs[i] in self.probe_user_list: |
| 304 | probe_readfunc = "bpf_probe_read_user" |
| 305 | else: |
Sumanth Korikkar | 7f6066d | 2020-05-20 10:49:56 -0500 | [diff] [blame] | 306 | probe_readfunc = "bpf_probe_read_kernel" |
Sumanth Korikkar | 306080b | 2020-04-27 04:37:23 -0500 | [diff] [blame] | 307 | return (text + " %s(&__key.v%d.s," + |
Sasha Goldshtein | 3e39a08 | 2016-03-24 08:39:47 -0700 | [diff] [blame] | 308 | " sizeof(__key.v%d.s), (void *)%s);\n") % \ |
Sumanth Korikkar | 306080b | 2020-04-27 04:37:23 -0500 | [diff] [blame] | 309 | (probe_readfunc, i, i, self.exprs[i]) |
Sasha Goldshtein | cc27edf | 2016-02-14 03:49:01 -0800 | [diff] [blame] | 310 | else: |
Brendan Gregg | 4f88a94 | 2016-07-22 17:11:51 -0700 | [diff] [blame] | 311 | return text + " __key.v%d = %s;\n" % \ |
| 312 | (i, self.exprs[i]) |
Sasha Goldshtein | cc27edf | 2016-02-14 03:49:01 -0800 | [diff] [blame] | 313 | |
| 314 | def _generate_hash_decl(self): |
| 315 | if self.type == "hist": |
| 316 | return "BPF_HISTOGRAM(%s, %s);" % \ |
| 317 | (self.probe_hash_name, self.expr_types[0]) |
| 318 | else: |
| 319 | text = "struct %s_key_t {\n" % self.probe_hash_name |
| 320 | for i in range(0, len(self.expr_types)): |
| 321 | text += self._generate_hash_field(i) |
| 322 | text += "};\n" |
| 323 | text += "BPF_HASH(%s, struct %s_key_t, u64);\n" % \ |
| 324 | (self.probe_hash_name, self.probe_hash_name) |
| 325 | return text |
| 326 | |
| 327 | def _generate_key_assignment(self): |
| 328 | if self.type == "hist": |
Sasha Goldshtein | 69e361a | 2016-09-27 19:40:00 +0300 | [diff] [blame] | 329 | return self._generate_usdt_arg_assignment(0) + \ |
Sasha Goldshtein | f41ae86 | 2016-10-19 01:14:30 +0300 | [diff] [blame] | 330 | ("%s __key = %s;\n" % |
Sasha Goldshtein | 69e361a | 2016-09-27 19:40:00 +0300 | [diff] [blame] | 331 | (self.expr_types[0], self.exprs[0])) |
Sasha Goldshtein | cc27edf | 2016-02-14 03:49:01 -0800 | [diff] [blame] | 332 | else: |
| 333 | text = "struct %s_key_t __key = {};\n" % \ |
| 334 | self.probe_hash_name |
| 335 | for i in range(0, len(self.exprs)): |
Sasha Goldshtein | c955130 | 2016-02-21 02:21:46 -0800 | [diff] [blame] | 336 | text += self._generate_field_assignment(i) |
Sasha Goldshtein | cc27edf | 2016-02-14 03:49:01 -0800 | [diff] [blame] | 337 | return text |
| 338 | |
| 339 | def _generate_hash_update(self): |
| 340 | if self.type == "hist": |
zcy | 80242fb | 2021-07-02 00:12:32 +0800 | [diff] [blame] | 341 | return "%s.atomic_increment(bpf_log2l(__key));" % \ |
Sasha Goldshtein | c955130 | 2016-02-21 02:21:46 -0800 | [diff] [blame] | 342 | self.probe_hash_name |
Sasha Goldshtein | cc27edf | 2016-02-14 03:49:01 -0800 | [diff] [blame] | 343 | else: |
zcy | 80242fb | 2021-07-02 00:12:32 +0800 | [diff] [blame] | 344 | return "%s.atomic_increment(__key);" % \ |
| 345 | self.probe_hash_name |
Sasha Goldshtein | cc27edf | 2016-02-14 03:49:01 -0800 | [diff] [blame] | 346 | |
| 347 | def _generate_pid_filter(self): |
| 348 | # Kernel probes need to explicitly filter pid, because the |
| 349 | # attach interface doesn't support pid filtering |
| 350 | if self.pid is not None and not self.is_user: |
Rafael Fonseca | af236e7 | 2017-02-15 17:28:26 +0100 | [diff] [blame] | 351 | return "if (__tgid != %d) { return 0; }" % self.pid |
Sasha Goldshtein | cc27edf | 2016-02-14 03:49:01 -0800 | [diff] [blame] | 352 | else: |
| 353 | return "" |
| 354 | |
zhenwei pi | 6677321 | 2021-09-06 18:28:16 +0800 | [diff] [blame] | 355 | def _generate_tid_filter(self): |
| 356 | if self.tid is not None and not self.is_user: |
| 357 | return "if (__pid != %d) { return 0; }" % self.tid |
| 358 | else: |
| 359 | return "" |
| 360 | |
Sasha Goldshtein | fd60d55 | 2016-03-01 12:15:34 -0800 | [diff] [blame] | 361 | def generate_text(self): |
Sasha Goldshtein | 392d5c8 | 2016-02-12 11:14:20 -0800 | [diff] [blame] | 362 | program = "" |
Sasha Goldshtein | 3e39a08 | 2016-03-24 08:39:47 -0700 | [diff] [blame] | 363 | probe_text = """ |
| 364 | DATA_DECL |
Sasha Goldshtein | f41ae86 | 2016-10-19 01:14:30 +0300 | [diff] [blame] | 365 | """ + ( |
| 366 | "TRACEPOINT_PROBE(%s, %s)" % |
| 367 | (self.tp_category, self.tp_event) |
| 368 | if self.probe_type == "t" |
| 369 | else "int PROBENAME(struct pt_regs *ctx SIGNATURE)") + """ |
Sasha Goldshtein | 3e39a08 | 2016-03-24 08:39:47 -0700 | [diff] [blame] | 370 | { |
Rafael Fonseca | af236e7 | 2017-02-15 17:28:26 +0100 | [diff] [blame] | 371 | u64 __pid_tgid = bpf_get_current_pid_tgid(); |
| 372 | u32 __pid = __pid_tgid; // lower 32 bits |
| 373 | u32 __tgid = __pid_tgid >> 32; // upper 32 bits |
Sasha Goldshtein | 3e39a08 | 2016-03-24 08:39:47 -0700 | [diff] [blame] | 374 | PID_FILTER |
zhenwei pi | 6677321 | 2021-09-06 18:28:16 +0800 | [diff] [blame] | 375 | TID_FILTER |
Sasha Goldshtein | 3e39a08 | 2016-03-24 08:39:47 -0700 | [diff] [blame] | 376 | PREFIX |
Sasha Goldshtein | 3e39a08 | 2016-03-24 08:39:47 -0700 | [diff] [blame] | 377 | KEY_EXPR |
Akilesh Kailash | b8269aa | 2020-05-11 11:54:26 -0700 | [diff] [blame] | 378 | if (!(FILTER)) return 0; |
Sasha Goldshtein | 3e39a08 | 2016-03-24 08:39:47 -0700 | [diff] [blame] | 379 | COLLECT |
| 380 | return 0; |
| 381 | } |
| 382 | """ |
| 383 | prefix = "" |
Sasha Goldshtein | 3e39a08 | 2016-03-24 08:39:47 -0700 | [diff] [blame] | 384 | signature = "" |
Sasha Goldshtein | 392d5c8 | 2016-02-12 11:14:20 -0800 | [diff] [blame] | 385 | |
| 386 | # If any entry arguments are probed in a ret probe, we need |
| 387 | # to generate an entry probe to collect them |
Sasha Goldshtein | 392d5c8 | 2016-02-12 11:14:20 -0800 | [diff] [blame] | 388 | if self.entry_probe_required: |
Sasha Goldshtein | fd60d55 | 2016-03-01 12:15:34 -0800 | [diff] [blame] | 389 | program += self._generate_entry_probe() |
| 390 | prefix += self._generate_retprobe_prefix() |
Sasha Goldshtein | cc27edf | 2016-02-14 03:49:01 -0800 | [diff] [blame] | 391 | # Replace $entry(paramname) with a reference to the |
| 392 | # value we collected when entering the function: |
Sasha Goldshtein | 392d5c8 | 2016-02-12 11:14:20 -0800 | [diff] [blame] | 393 | self._replace_entry_exprs() |
| 394 | |
Sasha Goldshtein | 376ae5c | 2016-10-04 19:49:57 +0300 | [diff] [blame] | 395 | if self.probe_type == "p" and len(self.signature) > 0: |
Sasha Goldshtein | 3e39a08 | 2016-03-24 08:39:47 -0700 | [diff] [blame] | 396 | # Only entry uprobes/kprobes can have user-specified |
| 397 | # signatures. Other probes force it to (). |
| 398 | signature = ", " + self.signature |
Sasha Goldshtein | fd60d55 | 2016-03-01 12:15:34 -0800 | [diff] [blame] | 399 | |
Sasha Goldshtein | f41ae86 | 2016-10-19 01:14:30 +0300 | [diff] [blame] | 400 | program += probe_text.replace("PROBENAME", |
| 401 | self.probe_func_name) |
Sasha Goldshtein | 8538485 | 2016-02-12 01:29:39 -0800 | [diff] [blame] | 402 | program = program.replace("SIGNATURE", signature) |
Sasha Goldshtein | cc27edf | 2016-02-14 03:49:01 -0800 | [diff] [blame] | 403 | program = program.replace("PID_FILTER", |
| 404 | self._generate_pid_filter()) |
zhenwei pi | 6677321 | 2021-09-06 18:28:16 +0800 | [diff] [blame] | 405 | program = program.replace("TID_FILTER", |
| 406 | self._generate_tid_filter()) |
Sasha Goldshtein | cc27edf | 2016-02-14 03:49:01 -0800 | [diff] [blame] | 407 | |
| 408 | decl = self._generate_hash_decl() |
| 409 | key_expr = self._generate_key_assignment() |
| 410 | collect = self._generate_hash_update() |
Sasha Goldshtein | 8538485 | 2016-02-12 01:29:39 -0800 | [diff] [blame] | 411 | program = program.replace("DATA_DECL", decl) |
Sasha Goldshtein | c955130 | 2016-02-21 02:21:46 -0800 | [diff] [blame] | 412 | program = program.replace("KEY_EXPR", key_expr) |
Sasha Goldshtein | e350115 | 2016-02-13 03:56:29 -0800 | [diff] [blame] | 413 | program = program.replace("FILTER", |
Sasha Goldshtein | c955130 | 2016-02-21 02:21:46 -0800 | [diff] [blame] | 414 | "1" if len(self.filter) == 0 else self.filter) |
Sasha Goldshtein | 8538485 | 2016-02-12 01:29:39 -0800 | [diff] [blame] | 415 | program = program.replace("COLLECT", collect) |
Sasha Goldshtein | 392d5c8 | 2016-02-12 11:14:20 -0800 | [diff] [blame] | 416 | program = program.replace("PREFIX", prefix) |
Sasha Goldshtein | 3e39a08 | 2016-03-24 08:39:47 -0700 | [diff] [blame] | 417 | |
Sasha Goldshtein | c8f752f | 2016-10-17 02:18:43 -0700 | [diff] [blame] | 418 | return self.streq_functions + program |
Sasha Goldshtein | 8538485 | 2016-02-12 01:29:39 -0800 | [diff] [blame] | 419 | |
Sasha Goldshtein | 3e39a08 | 2016-03-24 08:39:47 -0700 | [diff] [blame] | 420 | def _attach_u(self): |
| 421 | libpath = BPF.find_library(self.library) |
| 422 | if libpath is None: |
Sasha Goldshtein | ec67971 | 2016-10-04 18:33:36 +0300 | [diff] [blame] | 423 | libpath = BPF.find_exe(self.library) |
Sasha Goldshtein | 3e39a08 | 2016-03-24 08:39:47 -0700 | [diff] [blame] | 424 | if libpath is None or len(libpath) == 0: |
Sasha Goldshtein | 5a1d2e3 | 2016-03-30 08:14:44 -0700 | [diff] [blame] | 425 | self._bail("unable to find library %s" % self.library) |
Sasha Goldshtein | 3e39a08 | 2016-03-24 08:39:47 -0700 | [diff] [blame] | 426 | |
Brendan Gregg | 4f88a94 | 2016-07-22 17:11:51 -0700 | [diff] [blame] | 427 | if self.probe_type == "r": |
Sasha Goldshtein | 3e39a08 | 2016-03-24 08:39:47 -0700 | [diff] [blame] | 428 | self.bpf.attach_uretprobe(name=libpath, |
| 429 | sym=self.function, |
| 430 | fn_name=self.probe_func_name, |
| 431 | pid=self.pid or -1) |
| 432 | else: |
| 433 | self.bpf.attach_uprobe(name=libpath, |
| 434 | sym=self.function, |
| 435 | fn_name=self.probe_func_name, |
| 436 | pid=self.pid or -1) |
| 437 | |
| 438 | def _attach_k(self): |
Sasha Goldshtein | 376ae5c | 2016-10-04 19:49:57 +0300 | [diff] [blame] | 439 | if self.probe_type == "t": |
| 440 | pass # Nothing to do for tracepoints |
| 441 | elif self.probe_type == "r": |
Sasha Goldshtein | 3e39a08 | 2016-03-24 08:39:47 -0700 | [diff] [blame] | 442 | self.bpf.attach_kretprobe(event=self.function, |
| 443 | fn_name=self.probe_func_name) |
| 444 | else: |
| 445 | self.bpf.attach_kprobe(event=self.function, |
| 446 | fn_name=self.probe_func_name) |
| 447 | |
Sasha Goldshtein | 8538485 | 2016-02-12 01:29:39 -0800 | [diff] [blame] | 448 | def attach(self, bpf): |
| 449 | self.bpf = bpf |
Sasha Goldshtein | f41ae86 | 2016-10-19 01:14:30 +0300 | [diff] [blame] | 450 | if self.probe_type == "u": |
| 451 | return |
Sasha Goldshtein | 8538485 | 2016-02-12 01:29:39 -0800 | [diff] [blame] | 452 | if self.is_user: |
Sasha Goldshtein | 3e39a08 | 2016-03-24 08:39:47 -0700 | [diff] [blame] | 453 | self._attach_u() |
Sasha Goldshtein | 8538485 | 2016-02-12 01:29:39 -0800 | [diff] [blame] | 454 | else: |
Sasha Goldshtein | 3e39a08 | 2016-03-24 08:39:47 -0700 | [diff] [blame] | 455 | self._attach_k() |
Sasha Goldshtein | 392d5c8 | 2016-02-12 11:14:20 -0800 | [diff] [blame] | 456 | if self.entry_probe_required: |
| 457 | self._attach_entry_probe() |
Sasha Goldshtein | 8538485 | 2016-02-12 01:29:39 -0800 | [diff] [blame] | 458 | |
Sasha Goldshtein | cc27edf | 2016-02-14 03:49:01 -0800 | [diff] [blame] | 459 | def _v2s(self, v): |
| 460 | # Most fields can be converted with plain str(), but strings |
| 461 | # are wrapped in a __string_t which has an .s field |
| 462 | if "__string_t" in type(v).__name__: |
| 463 | return str(v.s) |
| 464 | return str(v) |
| 465 | |
| 466 | def _display_expr(self, i): |
| 467 | # Replace ugly latency calculation with $latency |
| 468 | expr = self.exprs[i].replace( |
| 469 | "(bpf_ktime_get_ns() - *____latency_val)", "$latency") |
| 470 | # Replace alias values back with the alias name |
Sasha Goldshtein | 3e39a08 | 2016-03-24 08:39:47 -0700 | [diff] [blame] | 471 | for alias, subst in Probe.aliases.items(): |
Sasha Goldshtein | c955130 | 2016-02-21 02:21:46 -0800 | [diff] [blame] | 472 | expr = expr.replace(subst, alias) |
Sasha Goldshtein | cc27edf | 2016-02-14 03:49:01 -0800 | [diff] [blame] | 473 | # Replace retval expression with $retval |
Naveen N. Rao | 4afa96a | 2016-05-03 14:54:21 +0530 | [diff] [blame] | 474 | expr = expr.replace("PT_REGS_RC(ctx)", "$retval") |
Sasha Goldshtein | cc27edf | 2016-02-14 03:49:01 -0800 | [diff] [blame] | 475 | # Replace ugly (*__param_val) expressions with param name |
| 476 | return re.sub(r"\(\*__(\w+)_val\)", r"\1", expr) |
| 477 | |
| 478 | def _display_key(self, key): |
| 479 | if self.is_default_expr: |
Sasha Goldshtein | fd60d55 | 2016-03-01 12:15:34 -0800 | [diff] [blame] | 480 | if not self.probe_type == "r": |
Sasha Goldshtein | cc27edf | 2016-02-14 03:49:01 -0800 | [diff] [blame] | 481 | return "total calls" |
| 482 | else: |
| 483 | return "retval = %s" % str(key.v0) |
| 484 | else: |
| 485 | # The key object has v0, ..., vk fields containing |
| 486 | # the values of the expressions from self.exprs |
| 487 | def str_i(i): |
| 488 | key_i = self._v2s(getattr(key, "v%d" % i)) |
| 489 | return "%s = %s" % \ |
| 490 | (self._display_expr(i), key_i) |
| 491 | return ", ".join(map(str_i, range(0, len(self.exprs)))) |
| 492 | |
Sasha Goldshtein | 392d5c8 | 2016-02-12 11:14:20 -0800 | [diff] [blame] | 493 | def display(self, top): |
Sasha Goldshtein | 8538485 | 2016-02-12 01:29:39 -0800 | [diff] [blame] | 494 | data = self.bpf.get_table(self.probe_hash_name) |
| 495 | if self.type == "freq": |
Sasha Goldshtein | e350115 | 2016-02-13 03:56:29 -0800 | [diff] [blame] | 496 | print(self.label or self.raw_spec) |
Sasha Goldshtein | 8538485 | 2016-02-12 01:29:39 -0800 | [diff] [blame] | 497 | print("\t%-10s %s" % ("COUNT", "EVENT")) |
Sasha Goldshtein | f41ae86 | 2016-10-19 01:14:30 +0300 | [diff] [blame] | 498 | sdata = sorted(data.items(), key=lambda p: p[1].value) |
Sasha Goldshtein | 392d5c8 | 2016-02-12 11:14:20 -0800 | [diff] [blame] | 499 | if top is not None: |
Sasha Goldshtein | d2f4762 | 2016-10-04 18:40:15 +0300 | [diff] [blame] | 500 | sdata = sdata[-top:] |
| 501 | for key, value in sdata: |
Sasha Goldshtein | 392d5c8 | 2016-02-12 11:14:20 -0800 | [diff] [blame] | 502 | # Print some nice values if the user didn't |
| 503 | # specify an expression to probe |
Sasha Goldshtein | 8538485 | 2016-02-12 01:29:39 -0800 | [diff] [blame] | 504 | if self.is_default_expr: |
Sasha Goldshtein | fd60d55 | 2016-03-01 12:15:34 -0800 | [diff] [blame] | 505 | if not self.probe_type == "r": |
Sasha Goldshtein | 8538485 | 2016-02-12 01:29:39 -0800 | [diff] [blame] | 506 | key_str = "total calls" |
| 507 | else: |
| 508 | key_str = "retval = %s" % \ |
Sasha Goldshtein | cc27edf | 2016-02-14 03:49:01 -0800 | [diff] [blame] | 509 | self._v2s(key.v0) |
Sasha Goldshtein | 8538485 | 2016-02-12 01:29:39 -0800 | [diff] [blame] | 510 | else: |
Sasha Goldshtein | c955130 | 2016-02-21 02:21:46 -0800 | [diff] [blame] | 511 | key_str = self._display_key(key) |
Sasha Goldshtein | f41ae86 | 2016-10-19 01:14:30 +0300 | [diff] [blame] | 512 | print("\t%-10s %s" % |
Sasha Goldshtein | 8538485 | 2016-02-12 01:29:39 -0800 | [diff] [blame] | 513 | (str(value.value), key_str)) |
| 514 | elif self.type == "hist": |
Sasha Goldshtein | cc27edf | 2016-02-14 03:49:01 -0800 | [diff] [blame] | 515 | label = self.label or (self._display_expr(0) |
Sasha Goldshtein | f41ae86 | 2016-10-19 01:14:30 +0300 | [diff] [blame] | 516 | if not self.is_default_expr else "retval") |
Sasha Goldshtein | 8538485 | 2016-02-12 01:29:39 -0800 | [diff] [blame] | 517 | data.print_log2_hist(val_type=label) |
Sasha Goldshtein | d2f4762 | 2016-10-04 18:40:15 +0300 | [diff] [blame] | 518 | if not self.cumulative: |
| 519 | data.clear() |
Sasha Goldshtein | 8538485 | 2016-02-12 01:29:39 -0800 | [diff] [blame] | 520 | |
Sasha Goldshtein | 3e39a08 | 2016-03-24 08:39:47 -0700 | [diff] [blame] | 521 | def __str__(self): |
| 522 | return self.label or self.raw_spec |
| 523 | |
Sasha Goldshtein | c955130 | 2016-02-21 02:21:46 -0800 | [diff] [blame] | 524 | class Tool(object): |
| 525 | examples = """ |
Sasha Goldshtein | 8538485 | 2016-02-12 01:29:39 -0800 | [diff] [blame] | 526 | Probe specifier syntax: |
Sasha Goldshtein | 3e39a08 | 2016-03-24 08:39:47 -0700 | [diff] [blame] | 527 | {p,r,t,u}:{[library],category}:function(signature)[:type[,type...]:expr[,expr...][:filter]][#label] |
Sasha Goldshtein | 8538485 | 2016-02-12 01:29:39 -0800 | [diff] [blame] | 528 | Where: |
Sasha Goldshtein | f41ae86 | 2016-10-19 01:14:30 +0300 | [diff] [blame] | 529 | p,r,t,u -- probe at function entry, function exit, kernel |
| 530 | tracepoint, or USDT probe |
Sasha Goldshtein | e350115 | 2016-02-13 03:56:29 -0800 | [diff] [blame] | 531 | in exit probes: can use $retval, $entry(param), $latency |
Sasha Goldshtein | 8538485 | 2016-02-12 01:29:39 -0800 | [diff] [blame] | 532 | library -- the library that contains the function |
| 533 | (leave empty for kernel functions) |
Sasha Goldshtein | fd60d55 | 2016-03-01 12:15:34 -0800 | [diff] [blame] | 534 | category -- the category of the kernel tracepoint (e.g. net, sched) |
| 535 | function -- the function name to trace (or tracepoint name) |
Sasha Goldshtein | 8538485 | 2016-02-12 01:29:39 -0800 | [diff] [blame] | 536 | signature -- the function's parameters, as in the C header |
Sasha Goldshtein | cc27edf | 2016-02-14 03:49:01 -0800 | [diff] [blame] | 537 | type -- the type of the expression to collect (supports multiple) |
| 538 | expr -- the expression to collect (supports multiple) |
Sasha Goldshtein | ed21adf | 2016-02-12 03:04:53 -0800 | [diff] [blame] | 539 | filter -- the filter that is applied to collected values |
| 540 | label -- the label for this probe in the resulting output |
Sasha Goldshtein | 8538485 | 2016-02-12 01:29:39 -0800 | [diff] [blame] | 541 | |
| 542 | EXAMPLES: |
| 543 | |
Sasha Goldshtein | 7df65da | 2016-02-14 05:12:27 -0800 | [diff] [blame] | 544 | argdist -H 'p::__kmalloc(u64 size):u64:size' |
Sasha Goldshtein | 8538485 | 2016-02-12 01:29:39 -0800 | [diff] [blame] | 545 | Print a histogram of allocation sizes passed to kmalloc |
| 546 | |
Sasha Goldshtein | 7df65da | 2016-02-14 05:12:27 -0800 | [diff] [blame] | 547 | argdist -p 1005 -C 'p:c:malloc(size_t size):size_t:size:size==16' |
Sasha Goldshtein | 8538485 | 2016-02-12 01:29:39 -0800 | [diff] [blame] | 548 | Print a frequency count of how many times process 1005 called malloc |
| 549 | with an allocation size of 16 bytes |
| 550 | |
Sasha Goldshtein | 7df65da | 2016-02-14 05:12:27 -0800 | [diff] [blame] | 551 | argdist -C 'r:c:gets():char*:(char*)$retval#snooped strings' |
Sasha Goldshtein | 8538485 | 2016-02-12 01:29:39 -0800 | [diff] [blame] | 552 | Snoop on all strings returned by gets() |
| 553 | |
Sasha Goldshtein | 7df65da | 2016-02-14 05:12:27 -0800 | [diff] [blame] | 554 | argdist -H 'r::__kmalloc(size_t size):u64:$latency/$entry(size)#ns per byte' |
Sasha Goldshtein | e350115 | 2016-02-13 03:56:29 -0800 | [diff] [blame] | 555 | Print a histogram of nanoseconds per byte from kmalloc allocations |
| 556 | |
Sasha Goldshtein | f41ae86 | 2016-10-19 01:14:30 +0300 | [diff] [blame] | 557 | argdist -C 'p::__kmalloc(size_t sz, gfp_t flags):size_t:sz:flags&GFP_ATOMIC' |
Sasha Goldshtein | 7983d6b | 2016-02-13 23:14:18 -0800 | [diff] [blame] | 558 | Print frequency count of kmalloc allocation sizes that have GFP_ATOMIC |
| 559 | |
Sasha Goldshtein | 7df65da | 2016-02-14 05:12:27 -0800 | [diff] [blame] | 560 | argdist -p 1005 -C 'p:c:write(int fd):int:fd' -T 5 |
Sasha Goldshtein | 8538485 | 2016-02-12 01:29:39 -0800 | [diff] [blame] | 561 | Print frequency counts of how many times writes were issued to a |
Sasha Goldshtein | 392d5c8 | 2016-02-12 11:14:20 -0800 | [diff] [blame] | 562 | particular file descriptor number, in process 1005, but only show |
| 563 | the top 5 busiest fds |
Sasha Goldshtein | 8538485 | 2016-02-12 01:29:39 -0800 | [diff] [blame] | 564 | |
Sasha Goldshtein | 7df65da | 2016-02-14 05:12:27 -0800 | [diff] [blame] | 565 | argdist -p 1005 -H 'r:c:read()' |
Sasha Goldshtein | cc27edf | 2016-02-14 03:49:01 -0800 | [diff] [blame] | 566 | Print a histogram of results (sizes) returned by read() in process 1005 |
Sasha Goldshtein | 8538485 | 2016-02-12 01:29:39 -0800 | [diff] [blame] | 567 | |
Sasha Goldshtein | 7df65da | 2016-02-14 05:12:27 -0800 | [diff] [blame] | 568 | argdist -C 'r::__vfs_read():u32:$PID:$latency > 100000' |
Sasha Goldshtein | e350115 | 2016-02-13 03:56:29 -0800 | [diff] [blame] | 569 | Print frequency of reads by process where the latency was >0.1ms |
| 570 | |
muahao | 852e19b | 2018-08-22 01:17:36 +0800 | [diff] [blame] | 571 | argdist -H 'r::__vfs_read(void *file, void *buf, size_t count):size_t: |
Sasha Goldshtein | f41ae86 | 2016-10-19 01:14:30 +0300 | [diff] [blame] | 572 | $entry(count):$latency > 1000000' |
Sasha Goldshtein | e350115 | 2016-02-13 03:56:29 -0800 | [diff] [blame] | 573 | Print a histogram of read sizes that were longer than 1ms |
| 574 | |
Sasha Goldshtein | 7df65da | 2016-02-14 05:12:27 -0800 | [diff] [blame] | 575 | argdist -H \\ |
Sasha Goldshtein | ed21adf | 2016-02-12 03:04:53 -0800 | [diff] [blame] | 576 | 'p:c:write(int fd, const void *buf, size_t count):size_t:count:fd==1' |
Sasha Goldshtein | 8538485 | 2016-02-12 01:29:39 -0800 | [diff] [blame] | 577 | Print a histogram of buffer sizes passed to write() across all |
| 578 | processes, where the file descriptor was 1 (STDOUT) |
| 579 | |
Sasha Goldshtein | 7df65da | 2016-02-14 05:12:27 -0800 | [diff] [blame] | 580 | argdist -C 'p:c:fork()#fork calls' |
Sasha Goldshtein | 8538485 | 2016-02-12 01:29:39 -0800 | [diff] [blame] | 581 | Count fork() calls in libc across all processes |
Sasha Goldshtein | c955130 | 2016-02-21 02:21:46 -0800 | [diff] [blame] | 582 | Can also use funccount.py, which is easier and more flexible |
Sasha Goldshtein | 8538485 | 2016-02-12 01:29:39 -0800 | [diff] [blame] | 583 | |
Sasha Goldshtein | 376ae5c | 2016-10-04 19:49:57 +0300 | [diff] [blame] | 584 | argdist -H 't:block:block_rq_complete():u32:args->nr_sector' |
Sasha Goldshtein | fd60d55 | 2016-03-01 12:15:34 -0800 | [diff] [blame] | 585 | Print histogram of number of sectors in completing block I/O requests |
| 586 | |
Sasha Goldshtein | 376ae5c | 2016-10-04 19:49:57 +0300 | [diff] [blame] | 587 | argdist -C 't:irq:irq_handler_entry():int:args->irq' |
Sasha Goldshtein | fd60d55 | 2016-03-01 12:15:34 -0800 | [diff] [blame] | 588 | Aggregate interrupts by interrupt request (IRQ) |
| 589 | |
Sasha Goldshtein | 3e39a08 | 2016-03-24 08:39:47 -0700 | [diff] [blame] | 590 | argdist -C 'u:pthread:pthread_start():u64:arg2' -p 1337 |
| 591 | Print frequency of function addresses used as a pthread start function, |
| 592 | relying on the USDT pthread_start probe in process 1337 |
| 593 | |
Sasha Goldshtein | 4725a72 | 2016-10-18 20:54:47 +0300 | [diff] [blame] | 594 | argdist -H 'p:c:sleep(u32 seconds):u32:seconds' \\ |
| 595 | -H 'p:c:nanosleep(struct timespec *req):long:req->tv_nsec' |
Sasha Goldshtein | 8538485 | 2016-02-12 01:29:39 -0800 | [diff] [blame] | 596 | Print histograms of sleep() and nanosleep() parameter values |
| 597 | |
Sasha Goldshtein | 7df65da | 2016-02-14 05:12:27 -0800 | [diff] [blame] | 598 | argdist -p 2780 -z 120 \\ |
Sasha Goldshtein | ed21adf | 2016-02-12 03:04:53 -0800 | [diff] [blame] | 599 | -C 'p:c:write(int fd, char* buf, size_t len):char*:buf:fd==1' |
Sasha Goldshtein | 8538485 | 2016-02-12 01:29:39 -0800 | [diff] [blame] | 600 | Spy on writes to STDOUT performed by process 2780, up to a string size |
Sasha Goldshtein | c955130 | 2016-02-21 02:21:46 -0800 | [diff] [blame] | 601 | of 120 characters |
Yonghong Song | f4470dc | 2017-12-13 14:12:13 -0800 | [diff] [blame] | 602 | |
| 603 | argdist -I 'kernel/sched/sched.h' \\ |
| 604 | -C 'p::__account_cfs_rq_runtime(struct cfs_rq *cfs_rq):s64:cfs_rq->runtime_remaining' |
| 605 | Trace on the cfs scheduling runqueue remaining runtime. The struct cfs_rq is defined |
| 606 | in kernel/sched/sched.h which is in kernel source tree and not in kernel-devel |
| 607 | package. So this command needs to run at the kernel source tree root directory |
| 608 | so that the added header file can be found by the compiler. |
Sasha Goldshtein | 8538485 | 2016-02-12 01:29:39 -0800 | [diff] [blame] | 609 | """ |
| 610 | |
Sasha Goldshtein | c955130 | 2016-02-21 02:21:46 -0800 | [diff] [blame] | 611 | def __init__(self): |
| 612 | parser = argparse.ArgumentParser(description="Trace a " + |
| 613 | "function and display a summary of its parameter values.", |
| 614 | formatter_class=argparse.RawDescriptionHelpFormatter, |
| 615 | epilog=Tool.examples) |
| 616 | parser.add_argument("-p", "--pid", type=int, |
| 617 | help="id of the process to trace (optional)") |
zhenwei pi | 6677321 | 2021-09-06 18:28:16 +0800 | [diff] [blame] | 618 | parser.add_argument("-t", "--tid", type=int, |
| 619 | help="id of the thread to trace (optional)") |
Sasha Goldshtein | c955130 | 2016-02-21 02:21:46 -0800 | [diff] [blame] | 620 | parser.add_argument("-z", "--string-size", default=80, |
| 621 | type=int, |
| 622 | help="maximum string size to read from char* arguments") |
| 623 | parser.add_argument("-i", "--interval", default=1, type=int, |
Akilesh Kailash | 8996719 | 2018-05-18 13:36:54 -0700 | [diff] [blame] | 624 | help="output interval, in seconds (default 1 second)") |
| 625 | parser.add_argument("-d", "--duration", type=int, |
| 626 | help="total duration of trace, in seconds") |
Sasha Goldshtein | c955130 | 2016-02-21 02:21:46 -0800 | [diff] [blame] | 627 | parser.add_argument("-n", "--number", type=int, dest="count", |
| 628 | help="number of outputs") |
| 629 | parser.add_argument("-v", "--verbose", action="store_true", |
| 630 | help="print resulting BPF program code before executing") |
Sasha Goldshtein | d2f4762 | 2016-10-04 18:40:15 +0300 | [diff] [blame] | 631 | parser.add_argument("-c", "--cumulative", action="store_true", |
Sasha Goldshtein | f41ae86 | 2016-10-19 01:14:30 +0300 | [diff] [blame] | 632 | help="do not clear histograms and freq counts at " + |
| 633 | "each interval") |
Sasha Goldshtein | c955130 | 2016-02-21 02:21:46 -0800 | [diff] [blame] | 634 | parser.add_argument("-T", "--top", type=int, |
| 635 | help="number of top results to show (not applicable to " + |
| 636 | "histograms)") |
Sasha Goldshtein | 4725a72 | 2016-10-18 20:54:47 +0300 | [diff] [blame] | 637 | parser.add_argument("-H", "--histogram", action="append", |
Sasha Goldshtein | c955130 | 2016-02-21 02:21:46 -0800 | [diff] [blame] | 638 | dest="histspecifier", metavar="specifier", |
| 639 | help="probe specifier to capture histogram of " + |
| 640 | "(see examples below)") |
Sasha Goldshtein | 4725a72 | 2016-10-18 20:54:47 +0300 | [diff] [blame] | 641 | parser.add_argument("-C", "--count", action="append", |
Sasha Goldshtein | c955130 | 2016-02-21 02:21:46 -0800 | [diff] [blame] | 642 | dest="countspecifier", metavar="specifier", |
| 643 | help="probe specifier to capture count of " + |
| 644 | "(see examples below)") |
Sasha Goldshtein | 4725a72 | 2016-10-18 20:54:47 +0300 | [diff] [blame] | 645 | parser.add_argument("-I", "--include", action="append", |
Sasha Goldshtein | c955130 | 2016-02-21 02:21:46 -0800 | [diff] [blame] | 646 | metavar="header", |
ShelbyFrances | f5dbbdb | 2017-02-08 05:56:52 +0300 | [diff] [blame] | 647 | help="additional header files to include in the BPF program " |
Yonghong Song | f4470dc | 2017-12-13 14:12:13 -0800 | [diff] [blame] | 648 | "as either full path, " |
| 649 | "or relative to relative to current working directory, " |
| 650 | "or relative to default kernel header search path") |
Sasha Goldshtein | c955130 | 2016-02-21 02:21:46 -0800 | [diff] [blame] | 651 | self.args = parser.parse_args() |
Brendan Gregg | 4f88a94 | 2016-07-22 17:11:51 -0700 | [diff] [blame] | 652 | self.usdt_ctx = None |
Sasha Goldshtein | 8538485 | 2016-02-12 01:29:39 -0800 | [diff] [blame] | 653 | |
Sasha Goldshtein | 3e39a08 | 2016-03-24 08:39:47 -0700 | [diff] [blame] | 654 | def _create_probes(self): |
| 655 | self.probes = [] |
Sasha Goldshtein | c955130 | 2016-02-21 02:21:46 -0800 | [diff] [blame] | 656 | for specifier in (self.args.countspecifier or []): |
Brendan Gregg | 4f88a94 | 2016-07-22 17:11:51 -0700 | [diff] [blame] | 657 | self.probes.append(Probe(self, "freq", specifier)) |
Sasha Goldshtein | c955130 | 2016-02-21 02:21:46 -0800 | [diff] [blame] | 658 | for histspecifier in (self.args.histspecifier or []): |
Brendan Gregg | 4f88a94 | 2016-07-22 17:11:51 -0700 | [diff] [blame] | 659 | self.probes.append(Probe(self, "hist", histspecifier)) |
Sasha Goldshtein | 3e39a08 | 2016-03-24 08:39:47 -0700 | [diff] [blame] | 660 | if len(self.probes) == 0: |
Sasha Goldshtein | c955130 | 2016-02-21 02:21:46 -0800 | [diff] [blame] | 661 | print("at least one specifier is required") |
Sasha Goldshtein | f7ab443 | 2017-02-13 18:46:49 -0500 | [diff] [blame] | 662 | exit(1) |
Sasha Goldshtein | 8538485 | 2016-02-12 01:29:39 -0800 | [diff] [blame] | 663 | |
Sasha Goldshtein | c955130 | 2016-02-21 02:21:46 -0800 | [diff] [blame] | 664 | def _generate_program(self): |
| 665 | bpf_source = """ |
Sasha Goldshtein | cc27edf | 2016-02-14 03:49:01 -0800 | [diff] [blame] | 666 | struct __string_t { char s[%d]; }; |
| 667 | |
| 668 | #include <uapi/linux/ptrace.h> |
Sasha Goldshtein | c955130 | 2016-02-21 02:21:46 -0800 | [diff] [blame] | 669 | """ % self.args.string_size |
| 670 | for include in (self.args.include or []): |
ShelbyFrances | f5dbbdb | 2017-02-08 05:56:52 +0300 | [diff] [blame] | 671 | if include.startswith((".", "/")): |
| 672 | include = os.path.abspath(include) |
| 673 | bpf_source += "#include \"%s\"\n" % include |
| 674 | else: |
| 675 | bpf_source += "#include <%s>\n" % include |
| 676 | |
Sasha Goldshtein | b950d6f | 2016-03-21 04:06:15 -0700 | [diff] [blame] | 677 | bpf_source += BPF.generate_auto_includes( |
Sasha Goldshtein | 3e39a08 | 2016-03-24 08:39:47 -0700 | [diff] [blame] | 678 | map(lambda p: p.raw_spec, self.probes)) |
Sasha Goldshtein | 3e39a08 | 2016-03-24 08:39:47 -0700 | [diff] [blame] | 679 | for probe in self.probes: |
| 680 | bpf_source += probe.generate_text() |
Sasha Goldshtein | c955130 | 2016-02-21 02:21:46 -0800 | [diff] [blame] | 681 | if self.args.verbose: |
Sasha Goldshtein | f41ae86 | 2016-10-19 01:14:30 +0300 | [diff] [blame] | 682 | for text in [probe.usdt_ctx.get_text() |
| 683 | for probe in self.probes |
| 684 | if probe.usdt_ctx]: |
Sasha Goldshtein | 69e361a | 2016-09-27 19:40:00 +0300 | [diff] [blame] | 685 | print(text) |
Sasha Goldshtein | c955130 | 2016-02-21 02:21:46 -0800 | [diff] [blame] | 686 | print(bpf_source) |
Sasha Goldshtein | 69e361a | 2016-09-27 19:40:00 +0300 | [diff] [blame] | 687 | usdt_contexts = [probe.usdt_ctx |
| 688 | for probe in self.probes if probe.usdt_ctx] |
| 689 | self.bpf = BPF(text=bpf_source, usdt_contexts=usdt_contexts) |
Sasha Goldshtein | 8538485 | 2016-02-12 01:29:39 -0800 | [diff] [blame] | 690 | |
Sasha Goldshtein | c955130 | 2016-02-21 02:21:46 -0800 | [diff] [blame] | 691 | def _attach(self): |
Sasha Goldshtein | 3e39a08 | 2016-03-24 08:39:47 -0700 | [diff] [blame] | 692 | for probe in self.probes: |
| 693 | probe.attach(self.bpf) |
Sasha Goldshtein | fd60d55 | 2016-03-01 12:15:34 -0800 | [diff] [blame] | 694 | if self.args.verbose: |
yonghong-song | 6070dcb | 2018-06-22 14:23:29 -0700 | [diff] [blame] | 695 | print("open uprobes: %s" % list(self.bpf.uprobe_fds.keys())) |
| 696 | print("open kprobes: %s" % list(self.bpf.kprobe_fds.keys())) |
Sasha Goldshtein | 8538485 | 2016-02-12 01:29:39 -0800 | [diff] [blame] | 697 | |
Sasha Goldshtein | c955130 | 2016-02-21 02:21:46 -0800 | [diff] [blame] | 698 | def _main_loop(self): |
| 699 | count_so_far = 0 |
Akilesh Kailash | 8996719 | 2018-05-18 13:36:54 -0700 | [diff] [blame] | 700 | seconds = 0 |
Sasha Goldshtein | c955130 | 2016-02-21 02:21:46 -0800 | [diff] [blame] | 701 | while True: |
| 702 | try: |
| 703 | sleep(self.args.interval) |
Akilesh Kailash | 8996719 | 2018-05-18 13:36:54 -0700 | [diff] [blame] | 704 | seconds += self.args.interval |
Sasha Goldshtein | c955130 | 2016-02-21 02:21:46 -0800 | [diff] [blame] | 705 | except KeyboardInterrupt: |
| 706 | exit() |
| 707 | print("[%s]" % strftime("%H:%M:%S")) |
Sasha Goldshtein | 3e39a08 | 2016-03-24 08:39:47 -0700 | [diff] [blame] | 708 | for probe in self.probes: |
| 709 | probe.display(self.args.top) |
Sasha Goldshtein | c955130 | 2016-02-21 02:21:46 -0800 | [diff] [blame] | 710 | count_so_far += 1 |
| 711 | if self.args.count is not None and \ |
| 712 | count_so_far >= self.args.count: |
| 713 | exit() |
Akilesh Kailash | 8996719 | 2018-05-18 13:36:54 -0700 | [diff] [blame] | 714 | if self.args.duration and \ |
| 715 | seconds >= self.args.duration: |
| 716 | exit() |
Sasha Goldshtein | 8538485 | 2016-02-12 01:29:39 -0800 | [diff] [blame] | 717 | |
Sasha Goldshtein | c955130 | 2016-02-21 02:21:46 -0800 | [diff] [blame] | 718 | def run(self): |
| 719 | try: |
Sasha Goldshtein | 3e39a08 | 2016-03-24 08:39:47 -0700 | [diff] [blame] | 720 | self._create_probes() |
Sasha Goldshtein | c955130 | 2016-02-21 02:21:46 -0800 | [diff] [blame] | 721 | self._generate_program() |
| 722 | self._attach() |
| 723 | self._main_loop() |
| 724 | except: |
Sasha Goldshtein | f7ab443 | 2017-02-13 18:46:49 -0500 | [diff] [blame] | 725 | exc_info = sys.exc_info() |
| 726 | sys_exit = exc_info[0] is SystemExit |
Sasha Goldshtein | c955130 | 2016-02-21 02:21:46 -0800 | [diff] [blame] | 727 | if self.args.verbose: |
| 728 | traceback.print_exc() |
Sasha Goldshtein | f7ab443 | 2017-02-13 18:46:49 -0500 | [diff] [blame] | 729 | elif not sys_exit: |
| 730 | print(exc_info[1]) |
| 731 | exit(0 if sys_exit else 1) |
Sasha Goldshtein | 8538485 | 2016-02-12 01:29:39 -0800 | [diff] [blame] | 732 | |
Sasha Goldshtein | c955130 | 2016-02-21 02:21:46 -0800 | [diff] [blame] | 733 | if __name__ == "__main__": |
| 734 | Tool().run() |