Wang Nan | 69d262a | 2015-10-14 12:41:13 +0000 | [diff] [blame] | 1 | /* |
| 2 | * bpf-loader.c |
| 3 | * |
| 4 | * Copyright (C) 2015 Wang Nan <wangnan0@huawei.com> |
| 5 | * Copyright (C) 2015 Huawei Inc. |
| 6 | */ |
| 7 | |
| 8 | #include <bpf/libbpf.h> |
| 9 | #include <linux/err.h> |
| 10 | #include "perf.h" |
| 11 | #include "debug.h" |
| 12 | #include "bpf-loader.h" |
Wang Nan | aa3abf3 | 2015-10-14 12:41:15 +0000 | [diff] [blame] | 13 | #include "probe-event.h" |
| 14 | #include "probe-finder.h" // for MAX_PROBES |
Wang Nan | d509db0 | 2015-10-14 12:41:20 +0000 | [diff] [blame] | 15 | #include "llvm-utils.h" |
Wang Nan | 69d262a | 2015-10-14 12:41:13 +0000 | [diff] [blame] | 16 | |
| 17 | #define DEFINE_PRINT_FN(name, level) \ |
| 18 | static int libbpf_##name(const char *fmt, ...) \ |
| 19 | { \ |
| 20 | va_list args; \ |
| 21 | int ret; \ |
| 22 | \ |
| 23 | va_start(args, fmt); \ |
| 24 | ret = veprintf(level, verbose, pr_fmt(fmt), args);\ |
| 25 | va_end(args); \ |
| 26 | return ret; \ |
| 27 | } |
| 28 | |
Wang Nan | 7a01194 | 2015-11-03 10:44:43 +0000 | [diff] [blame] | 29 | DEFINE_PRINT_FN(warning, 1) |
| 30 | DEFINE_PRINT_FN(info, 1) |
Wang Nan | 69d262a | 2015-10-14 12:41:13 +0000 | [diff] [blame] | 31 | DEFINE_PRINT_FN(debug, 1) |
| 32 | |
Wang Nan | aa3abf3 | 2015-10-14 12:41:15 +0000 | [diff] [blame] | 33 | struct bpf_prog_priv { |
| 34 | struct perf_probe_event pev; |
| 35 | }; |
| 36 | |
Wang Nan | d509db0 | 2015-10-14 12:41:20 +0000 | [diff] [blame] | 37 | struct bpf_object *bpf__prepare_load(const char *filename, bool source) |
Wang Nan | 69d262a | 2015-10-14 12:41:13 +0000 | [diff] [blame] | 38 | { |
| 39 | struct bpf_object *obj; |
| 40 | static bool libbpf_initialized; |
| 41 | |
| 42 | if (!libbpf_initialized) { |
| 43 | libbpf_set_print(libbpf_warning, |
| 44 | libbpf_info, |
| 45 | libbpf_debug); |
| 46 | libbpf_initialized = true; |
| 47 | } |
| 48 | |
Wang Nan | d509db0 | 2015-10-14 12:41:20 +0000 | [diff] [blame] | 49 | if (source) { |
| 50 | int err; |
| 51 | void *obj_buf; |
| 52 | size_t obj_buf_sz; |
| 53 | |
| 54 | err = llvm__compile_bpf(filename, &obj_buf, &obj_buf_sz); |
| 55 | if (err) |
| 56 | return ERR_PTR(err); |
| 57 | obj = bpf_object__open_buffer(obj_buf, obj_buf_sz, filename); |
| 58 | free(obj_buf); |
| 59 | } else |
| 60 | obj = bpf_object__open(filename); |
| 61 | |
Wang Nan | 69d262a | 2015-10-14 12:41:13 +0000 | [diff] [blame] | 62 | if (!obj) { |
| 63 | pr_debug("bpf: failed to load %s\n", filename); |
| 64 | return ERR_PTR(-EINVAL); |
| 65 | } |
| 66 | |
| 67 | return obj; |
| 68 | } |
| 69 | |
| 70 | void bpf__clear(void) |
| 71 | { |
| 72 | struct bpf_object *obj, *tmp; |
| 73 | |
Wang Nan | aa3abf3 | 2015-10-14 12:41:15 +0000 | [diff] [blame] | 74 | bpf_object__for_each_safe(obj, tmp) { |
| 75 | bpf__unprobe(obj); |
Wang Nan | 69d262a | 2015-10-14 12:41:13 +0000 | [diff] [blame] | 76 | bpf_object__close(obj); |
Wang Nan | aa3abf3 | 2015-10-14 12:41:15 +0000 | [diff] [blame] | 77 | } |
| 78 | } |
| 79 | |
| 80 | static void |
| 81 | bpf_prog_priv__clear(struct bpf_program *prog __maybe_unused, |
| 82 | void *_priv) |
| 83 | { |
| 84 | struct bpf_prog_priv *priv = _priv; |
| 85 | |
| 86 | cleanup_perf_probe_events(&priv->pev, 1); |
| 87 | free(priv); |
| 88 | } |
| 89 | |
| 90 | static int |
| 91 | config_bpf_program(struct bpf_program *prog) |
| 92 | { |
| 93 | struct perf_probe_event *pev = NULL; |
| 94 | struct bpf_prog_priv *priv = NULL; |
| 95 | const char *config_str; |
| 96 | int err; |
| 97 | |
| 98 | config_str = bpf_program__title(prog, false); |
| 99 | if (!config_str) { |
| 100 | pr_debug("bpf: unable to get title for program\n"); |
| 101 | return -EINVAL; |
| 102 | } |
| 103 | |
| 104 | priv = calloc(sizeof(*priv), 1); |
| 105 | if (!priv) { |
| 106 | pr_debug("bpf: failed to alloc priv\n"); |
| 107 | return -ENOMEM; |
| 108 | } |
| 109 | pev = &priv->pev; |
| 110 | |
| 111 | pr_debug("bpf: config program '%s'\n", config_str); |
| 112 | err = parse_perf_probe_command(config_str, pev); |
| 113 | if (err < 0) { |
| 114 | pr_debug("bpf: '%s' is not a valid config string\n", |
| 115 | config_str); |
| 116 | err = -EINVAL; |
| 117 | goto errout; |
| 118 | } |
| 119 | |
| 120 | if (pev->group && strcmp(pev->group, PERF_BPF_PROBE_GROUP)) { |
| 121 | pr_debug("bpf: '%s': group for event is set and not '%s'.\n", |
| 122 | config_str, PERF_BPF_PROBE_GROUP); |
| 123 | err = -EINVAL; |
| 124 | goto errout; |
| 125 | } else if (!pev->group) |
| 126 | pev->group = strdup(PERF_BPF_PROBE_GROUP); |
| 127 | |
| 128 | if (!pev->group) { |
| 129 | pr_debug("bpf: strdup failed\n"); |
| 130 | err = -ENOMEM; |
| 131 | goto errout; |
| 132 | } |
| 133 | |
| 134 | if (!pev->event) { |
| 135 | pr_debug("bpf: '%s': event name is missing\n", |
| 136 | config_str); |
| 137 | err = -EINVAL; |
| 138 | goto errout; |
| 139 | } |
| 140 | pr_debug("bpf: config '%s' is ok\n", config_str); |
| 141 | |
| 142 | err = bpf_program__set_private(prog, priv, bpf_prog_priv__clear); |
| 143 | if (err) { |
| 144 | pr_debug("Failed to set priv for program '%s'\n", config_str); |
| 145 | goto errout; |
| 146 | } |
| 147 | |
| 148 | return 0; |
| 149 | |
| 150 | errout: |
| 151 | if (pev) |
| 152 | clear_perf_probe_event(pev); |
| 153 | free(priv); |
| 154 | return err; |
| 155 | } |
| 156 | |
| 157 | static int bpf__prepare_probe(void) |
| 158 | { |
| 159 | static int err = 0; |
| 160 | static bool initialized = false; |
| 161 | |
| 162 | /* |
| 163 | * Make err static, so if init failed the first, bpf__prepare_probe() |
| 164 | * fails each time without calling init_probe_symbol_maps multiple |
| 165 | * times. |
| 166 | */ |
| 167 | if (initialized) |
| 168 | return err; |
| 169 | |
| 170 | initialized = true; |
| 171 | err = init_probe_symbol_maps(false); |
| 172 | if (err < 0) |
| 173 | pr_debug("Failed to init_probe_symbol_maps\n"); |
| 174 | probe_conf.max_probes = MAX_PROBES; |
| 175 | return err; |
| 176 | } |
| 177 | |
| 178 | int bpf__probe(struct bpf_object *obj) |
| 179 | { |
| 180 | int err = 0; |
| 181 | struct bpf_program *prog; |
| 182 | struct bpf_prog_priv *priv; |
| 183 | struct perf_probe_event *pev; |
| 184 | |
| 185 | err = bpf__prepare_probe(); |
| 186 | if (err) { |
| 187 | pr_debug("bpf__prepare_probe failed\n"); |
| 188 | return err; |
| 189 | } |
| 190 | |
| 191 | bpf_object__for_each_program(prog, obj) { |
| 192 | err = config_bpf_program(prog); |
| 193 | if (err) |
| 194 | goto out; |
| 195 | |
| 196 | err = bpf_program__get_private(prog, (void **)&priv); |
| 197 | if (err || !priv) |
| 198 | goto out; |
| 199 | pev = &priv->pev; |
| 200 | |
| 201 | err = convert_perf_probe_events(pev, 1); |
| 202 | if (err < 0) { |
| 203 | pr_debug("bpf_probe: failed to convert perf probe events"); |
| 204 | goto out; |
| 205 | } |
| 206 | |
| 207 | err = apply_perf_probe_events(pev, 1); |
| 208 | if (err < 0) { |
| 209 | pr_debug("bpf_probe: failed to apply perf probe events"); |
| 210 | goto out; |
| 211 | } |
| 212 | } |
| 213 | out: |
| 214 | return err < 0 ? err : 0; |
| 215 | } |
| 216 | |
| 217 | #define EVENTS_WRITE_BUFSIZE 4096 |
| 218 | int bpf__unprobe(struct bpf_object *obj) |
| 219 | { |
| 220 | int err, ret = 0; |
| 221 | struct bpf_program *prog; |
| 222 | struct bpf_prog_priv *priv; |
| 223 | |
| 224 | bpf_object__for_each_program(prog, obj) { |
| 225 | int i; |
| 226 | |
| 227 | err = bpf_program__get_private(prog, (void **)&priv); |
| 228 | if (err || !priv) |
| 229 | continue; |
| 230 | |
| 231 | for (i = 0; i < priv->pev.ntevs; i++) { |
| 232 | struct probe_trace_event *tev = &priv->pev.tevs[i]; |
| 233 | char name_buf[EVENTS_WRITE_BUFSIZE]; |
| 234 | struct strfilter *delfilter; |
| 235 | |
| 236 | snprintf(name_buf, EVENTS_WRITE_BUFSIZE, |
| 237 | "%s:%s", tev->group, tev->event); |
| 238 | name_buf[EVENTS_WRITE_BUFSIZE - 1] = '\0'; |
| 239 | |
| 240 | delfilter = strfilter__new(name_buf, NULL); |
| 241 | if (!delfilter) { |
| 242 | pr_debug("Failed to create filter for unprobing\n"); |
| 243 | ret = -ENOMEM; |
| 244 | continue; |
| 245 | } |
| 246 | |
| 247 | err = del_perf_probe_events(delfilter); |
| 248 | strfilter__delete(delfilter); |
| 249 | if (err) { |
| 250 | pr_debug("Failed to delete %s\n", name_buf); |
| 251 | ret = err; |
| 252 | continue; |
| 253 | } |
| 254 | } |
| 255 | } |
| 256 | return ret; |
| 257 | } |
| 258 | |
Wang Nan | 1e5e3ee | 2015-10-14 12:41:16 +0000 | [diff] [blame] | 259 | int bpf__load(struct bpf_object *obj) |
| 260 | { |
| 261 | int err; |
| 262 | |
| 263 | err = bpf_object__load(obj); |
| 264 | if (err) { |
| 265 | pr_debug("bpf: load objects failed\n"); |
| 266 | return err; |
| 267 | } |
| 268 | return 0; |
| 269 | } |
| 270 | |
Wang Nan | 4edf30e | 2015-10-14 12:41:17 +0000 | [diff] [blame] | 271 | int bpf__foreach_tev(struct bpf_object *obj, |
| 272 | bpf_prog_iter_callback_t func, |
| 273 | void *arg) |
| 274 | { |
| 275 | struct bpf_program *prog; |
| 276 | int err; |
| 277 | |
| 278 | bpf_object__for_each_program(prog, obj) { |
| 279 | struct probe_trace_event *tev; |
| 280 | struct perf_probe_event *pev; |
| 281 | struct bpf_prog_priv *priv; |
| 282 | int i, fd; |
| 283 | |
| 284 | err = bpf_program__get_private(prog, |
| 285 | (void **)&priv); |
| 286 | if (err || !priv) { |
| 287 | pr_debug("bpf: failed to get private field\n"); |
| 288 | return -EINVAL; |
| 289 | } |
| 290 | |
| 291 | pev = &priv->pev; |
| 292 | for (i = 0; i < pev->ntevs; i++) { |
| 293 | tev = &pev->tevs[i]; |
| 294 | |
| 295 | fd = bpf_program__fd(prog); |
| 296 | if (fd < 0) { |
| 297 | pr_debug("bpf: failed to get file descriptor\n"); |
| 298 | return fd; |
| 299 | } |
| 300 | |
| 301 | err = (*func)(tev, fd, arg); |
| 302 | if (err) { |
| 303 | pr_debug("bpf: call back failed, stop iterate\n"); |
| 304 | return err; |
| 305 | } |
| 306 | } |
| 307 | } |
| 308 | return 0; |
| 309 | } |
| 310 | |
Wang Nan | aa3abf3 | 2015-10-14 12:41:15 +0000 | [diff] [blame] | 311 | #define bpf__strerror_head(err, buf, size) \ |
| 312 | char sbuf[STRERR_BUFSIZE], *emsg;\ |
| 313 | if (!size)\ |
| 314 | return 0;\ |
| 315 | if (err < 0)\ |
| 316 | err = -err;\ |
| 317 | emsg = strerror_r(err, sbuf, sizeof(sbuf));\ |
| 318 | switch (err) {\ |
| 319 | default:\ |
| 320 | scnprintf(buf, size, "%s", emsg);\ |
| 321 | break; |
| 322 | |
| 323 | #define bpf__strerror_entry(val, fmt...)\ |
| 324 | case val: {\ |
| 325 | scnprintf(buf, size, fmt);\ |
| 326 | break;\ |
| 327 | } |
| 328 | |
| 329 | #define bpf__strerror_end(buf, size)\ |
| 330 | }\ |
| 331 | buf[size - 1] = '\0'; |
| 332 | |
| 333 | int bpf__strerror_probe(struct bpf_object *obj __maybe_unused, |
| 334 | int err, char *buf, size_t size) |
| 335 | { |
| 336 | bpf__strerror_head(err, buf, size); |
| 337 | bpf__strerror_entry(EEXIST, "Probe point exist. Try use 'perf probe -d \"*\"'"); |
| 338 | bpf__strerror_entry(EPERM, "You need to be root, and /proc/sys/kernel/kptr_restrict should be 0\n"); |
| 339 | bpf__strerror_entry(ENOENT, "You need to check probing points in BPF file\n"); |
| 340 | bpf__strerror_end(buf, size); |
| 341 | return 0; |
Wang Nan | 69d262a | 2015-10-14 12:41:13 +0000 | [diff] [blame] | 342 | } |
Wang Nan | 1e5e3ee | 2015-10-14 12:41:16 +0000 | [diff] [blame] | 343 | |
| 344 | int bpf__strerror_load(struct bpf_object *obj __maybe_unused, |
| 345 | int err, char *buf, size_t size) |
| 346 | { |
| 347 | bpf__strerror_head(err, buf, size); |
| 348 | bpf__strerror_entry(EINVAL, "%s: Are you root and runing a CONFIG_BPF_SYSCALL kernel?", |
| 349 | emsg) |
| 350 | bpf__strerror_end(buf, size); |
| 351 | return 0; |
| 352 | } |