1 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) 2 /* Copyright (C) 2020 Facebook */ 3 4 #include <errno.h> 5 #include <linux/err.h> 6 #include <net/if.h> 7 #include <stdio.h> 8 #include <unistd.h> 9 10 #include <bpf/bpf.h> 11 #include <bpf/hashmap.h> 12 13 #include "json_writer.h" 14 #include "main.h" 15 16 static struct hashmap *link_table; 17 18 static int link_parse_fd(int *argc, char ***argv) 19 { 20 int fd; 21 22 if (is_prefix(**argv, "id")) { 23 unsigned int id; 24 char *endptr; 25 26 NEXT_ARGP(); 27 28 id = strtoul(**argv, &endptr, 0); 29 if (*endptr) { 30 p_err("can't parse %s as ID", **argv); 31 return -1; 32 } 33 NEXT_ARGP(); 34 35 fd = bpf_link_get_fd_by_id(id); 36 if (fd < 0) 37 p_err("failed to get link with ID %d: %s", id, strerror(errno)); 38 return fd; 39 } else if (is_prefix(**argv, "pinned")) { 40 char *path; 41 42 NEXT_ARGP(); 43 44 path = **argv; 45 NEXT_ARGP(); 46 47 return open_obj_pinned_any(path, BPF_OBJ_LINK); 48 } 49 50 p_err("expected 'id' or 'pinned', got: '%s'?", **argv); 51 return -1; 52 } 53 54 static void 55 show_link_header_json(struct bpf_link_info *info, json_writer_t *wtr) 56 { 57 const char *link_type_str; 58 59 jsonw_uint_field(wtr, "id", info->id); 60 link_type_str = libbpf_bpf_link_type_str(info->type); 61 if (link_type_str) 62 jsonw_string_field(wtr, "type", link_type_str); 63 else 64 jsonw_uint_field(wtr, "type", info->type); 65 66 jsonw_uint_field(json_wtr, "prog_id", info->prog_id); 67 } 68 69 static void show_link_attach_type_json(__u32 attach_type, json_writer_t *wtr) 70 { 71 const char *attach_type_str; 72 73 attach_type_str = libbpf_bpf_attach_type_str(attach_type); 74 if (attach_type_str) 75 jsonw_string_field(wtr, "attach_type", attach_type_str); 76 else 77 jsonw_uint_field(wtr, "attach_type", attach_type); 78 } 79 80 static bool is_iter_map_target(const char *target_name) 81 { 82 return strcmp(target_name, "bpf_map_elem") == 0 || 83 strcmp(target_name, "bpf_sk_storage_map") == 0; 84 } 85 86 static bool is_iter_cgroup_target(const char *target_name) 87 { 88 return strcmp(target_name, "cgroup") == 0; 89 } 90 91 static const char *cgroup_order_string(__u32 order) 92 { 93 switch (order) { 94 case BPF_CGROUP_ITER_ORDER_UNSPEC: 95 return "order_unspec"; 96 case BPF_CGROUP_ITER_SELF_ONLY: 97 return "self_only"; 98 case BPF_CGROUP_ITER_DESCENDANTS_PRE: 99 return "descendants_pre"; 100 case BPF_CGROUP_ITER_DESCENDANTS_POST: 101 return "descendants_post"; 102 case BPF_CGROUP_ITER_ANCESTORS_UP: 103 return "ancestors_up"; 104 default: /* won't happen */ 105 return "unknown"; 106 } 107 } 108 109 static bool is_iter_task_target(const char *target_name) 110 { 111 return strcmp(target_name, "task") == 0 || 112 strcmp(target_name, "task_file") == 0 || 113 strcmp(target_name, "task_vma") == 0; 114 } 115 116 static void show_iter_json(struct bpf_link_info *info, json_writer_t *wtr) 117 { 118 const char *target_name = u64_to_ptr(info->iter.target_name); 119 120 jsonw_string_field(wtr, "target_name", target_name); 121 122 if (is_iter_map_target(target_name)) 123 jsonw_uint_field(wtr, "map_id", info->iter.map.map_id); 124 else if (is_iter_task_target(target_name)) { 125 if (info->iter.task.tid) 126 jsonw_uint_field(wtr, "tid", info->iter.task.tid); 127 else if (info->iter.task.pid) 128 jsonw_uint_field(wtr, "pid", info->iter.task.pid); 129 } 130 131 if (is_iter_cgroup_target(target_name)) { 132 jsonw_lluint_field(wtr, "cgroup_id", info->iter.cgroup.cgroup_id); 133 jsonw_string_field(wtr, "order", 134 cgroup_order_string(info->iter.cgroup.order)); 135 } 136 } 137 138 static int get_prog_info(int prog_id, struct bpf_prog_info *info) 139 { 140 __u32 len = sizeof(*info); 141 int err, prog_fd; 142 143 prog_fd = bpf_prog_get_fd_by_id(prog_id); 144 if (prog_fd < 0) 145 return prog_fd; 146 147 memset(info, 0, sizeof(*info)); 148 err = bpf_obj_get_info_by_fd(prog_fd, info, &len); 149 if (err) 150 p_err("can't get prog info: %s", strerror(errno)); 151 close(prog_fd); 152 return err; 153 } 154 155 static int show_link_close_json(int fd, struct bpf_link_info *info) 156 { 157 struct bpf_prog_info prog_info; 158 const char *prog_type_str; 159 int err; 160 161 jsonw_start_object(json_wtr); 162 163 show_link_header_json(info, json_wtr); 164 165 switch (info->type) { 166 case BPF_LINK_TYPE_RAW_TRACEPOINT: 167 jsonw_string_field(json_wtr, "tp_name", 168 u64_to_ptr(info->raw_tracepoint.tp_name)); 169 break; 170 case BPF_LINK_TYPE_TRACING: 171 err = get_prog_info(info->prog_id, &prog_info); 172 if (err) 173 return err; 174 175 prog_type_str = libbpf_bpf_prog_type_str(prog_info.type); 176 /* libbpf will return NULL for variants unknown to it. */ 177 if (prog_type_str) 178 jsonw_string_field(json_wtr, "prog_type", prog_type_str); 179 else 180 jsonw_uint_field(json_wtr, "prog_type", prog_info.type); 181 182 show_link_attach_type_json(info->tracing.attach_type, 183 json_wtr); 184 break; 185 case BPF_LINK_TYPE_CGROUP: 186 jsonw_lluint_field(json_wtr, "cgroup_id", 187 info->cgroup.cgroup_id); 188 show_link_attach_type_json(info->cgroup.attach_type, json_wtr); 189 break; 190 case BPF_LINK_TYPE_ITER: 191 show_iter_json(info, json_wtr); 192 break; 193 case BPF_LINK_TYPE_NETNS: 194 jsonw_uint_field(json_wtr, "netns_ino", 195 info->netns.netns_ino); 196 show_link_attach_type_json(info->netns.attach_type, json_wtr); 197 break; 198 default: 199 break; 200 } 201 202 if (!hashmap__empty(link_table)) { 203 struct hashmap_entry *entry; 204 205 jsonw_name(json_wtr, "pinned"); 206 jsonw_start_array(json_wtr); 207 hashmap__for_each_key_entry(link_table, entry, 208 u32_as_hash_field(info->id)) 209 jsonw_string(json_wtr, entry->value); 210 jsonw_end_array(json_wtr); 211 } 212 213 emit_obj_refs_json(refs_table, info->id, json_wtr); 214 215 jsonw_end_object(json_wtr); 216 217 return 0; 218 } 219 220 static void show_link_header_plain(struct bpf_link_info *info) 221 { 222 const char *link_type_str; 223 224 printf("%u: ", info->id); 225 link_type_str = libbpf_bpf_link_type_str(info->type); 226 if (link_type_str) 227 printf("%s ", link_type_str); 228 else 229 printf("type %u ", info->type); 230 231 printf("prog %u ", info->prog_id); 232 } 233 234 static void show_link_attach_type_plain(__u32 attach_type) 235 { 236 const char *attach_type_str; 237 238 attach_type_str = libbpf_bpf_attach_type_str(attach_type); 239 if (attach_type_str) 240 printf("attach_type %s ", attach_type_str); 241 else 242 printf("attach_type %u ", attach_type); 243 } 244 245 static void show_iter_plain(struct bpf_link_info *info) 246 { 247 const char *target_name = u64_to_ptr(info->iter.target_name); 248 249 printf("target_name %s ", target_name); 250 251 if (is_iter_map_target(target_name)) 252 printf("map_id %u ", info->iter.map.map_id); 253 else if (is_iter_task_target(target_name)) { 254 if (info->iter.task.tid) 255 printf("tid %u ", info->iter.task.tid); 256 else if (info->iter.task.pid) 257 printf("pid %u ", info->iter.task.pid); 258 } 259 260 if (is_iter_cgroup_target(target_name)) { 261 printf("cgroup_id %llu ", info->iter.cgroup.cgroup_id); 262 printf("order %s ", 263 cgroup_order_string(info->iter.cgroup.order)); 264 } 265 } 266 267 static int show_link_close_plain(int fd, struct bpf_link_info *info) 268 { 269 struct bpf_prog_info prog_info; 270 const char *prog_type_str; 271 int err; 272 273 show_link_header_plain(info); 274 275 switch (info->type) { 276 case BPF_LINK_TYPE_RAW_TRACEPOINT: 277 printf("\n\ttp '%s' ", 278 (const char *)u64_to_ptr(info->raw_tracepoint.tp_name)); 279 break; 280 case BPF_LINK_TYPE_TRACING: 281 err = get_prog_info(info->prog_id, &prog_info); 282 if (err) 283 return err; 284 285 prog_type_str = libbpf_bpf_prog_type_str(prog_info.type); 286 /* libbpf will return NULL for variants unknown to it. */ 287 if (prog_type_str) 288 printf("\n\tprog_type %s ", prog_type_str); 289 else 290 printf("\n\tprog_type %u ", prog_info.type); 291 292 show_link_attach_type_plain(info->tracing.attach_type); 293 break; 294 case BPF_LINK_TYPE_CGROUP: 295 printf("\n\tcgroup_id %zu ", (size_t)info->cgroup.cgroup_id); 296 show_link_attach_type_plain(info->cgroup.attach_type); 297 break; 298 case BPF_LINK_TYPE_ITER: 299 show_iter_plain(info); 300 break; 301 case BPF_LINK_TYPE_NETNS: 302 printf("\n\tnetns_ino %u ", info->netns.netns_ino); 303 show_link_attach_type_plain(info->netns.attach_type); 304 break; 305 default: 306 break; 307 } 308 309 if (!hashmap__empty(link_table)) { 310 struct hashmap_entry *entry; 311 312 hashmap__for_each_key_entry(link_table, entry, 313 u32_as_hash_field(info->id)) 314 printf("\n\tpinned %s", (char *)entry->value); 315 } 316 emit_obj_refs_plain(refs_table, info->id, "\n\tpids "); 317 318 printf("\n"); 319 320 return 0; 321 } 322 323 static int do_show_link(int fd) 324 { 325 struct bpf_link_info info; 326 __u32 len = sizeof(info); 327 char buf[256]; 328 int err; 329 330 memset(&info, 0, sizeof(info)); 331 again: 332 err = bpf_obj_get_info_by_fd(fd, &info, &len); 333 if (err) { 334 p_err("can't get link info: %s", 335 strerror(errno)); 336 close(fd); 337 return err; 338 } 339 if (info.type == BPF_LINK_TYPE_RAW_TRACEPOINT && 340 !info.raw_tracepoint.tp_name) { 341 info.raw_tracepoint.tp_name = (unsigned long)&buf; 342 info.raw_tracepoint.tp_name_len = sizeof(buf); 343 goto again; 344 } 345 if (info.type == BPF_LINK_TYPE_ITER && 346 !info.iter.target_name) { 347 info.iter.target_name = (unsigned long)&buf; 348 info.iter.target_name_len = sizeof(buf); 349 goto again; 350 } 351 352 if (json_output) 353 show_link_close_json(fd, &info); 354 else 355 show_link_close_plain(fd, &info); 356 357 close(fd); 358 return 0; 359 } 360 361 static int do_show(int argc, char **argv) 362 { 363 __u32 id = 0; 364 int err, fd; 365 366 if (show_pinned) { 367 link_table = hashmap__new(hash_fn_for_key_as_id, 368 equal_fn_for_key_as_id, NULL); 369 if (IS_ERR(link_table)) { 370 p_err("failed to create hashmap for pinned paths"); 371 return -1; 372 } 373 build_pinned_obj_table(link_table, BPF_OBJ_LINK); 374 } 375 build_obj_refs_table(&refs_table, BPF_OBJ_LINK); 376 377 if (argc == 2) { 378 fd = link_parse_fd(&argc, &argv); 379 if (fd < 0) 380 return fd; 381 return do_show_link(fd); 382 } 383 384 if (argc) 385 return BAD_ARG(); 386 387 if (json_output) 388 jsonw_start_array(json_wtr); 389 while (true) { 390 err = bpf_link_get_next_id(id, &id); 391 if (err) { 392 if (errno == ENOENT) 393 break; 394 p_err("can't get next link: %s%s", strerror(errno), 395 errno == EINVAL ? " -- kernel too old?" : ""); 396 break; 397 } 398 399 fd = bpf_link_get_fd_by_id(id); 400 if (fd < 0) { 401 if (errno == ENOENT) 402 continue; 403 p_err("can't get link by id (%u): %s", 404 id, strerror(errno)); 405 break; 406 } 407 408 err = do_show_link(fd); 409 if (err) 410 break; 411 } 412 if (json_output) 413 jsonw_end_array(json_wtr); 414 415 delete_obj_refs_table(refs_table); 416 417 if (show_pinned) 418 delete_pinned_obj_table(link_table); 419 420 return errno == ENOENT ? 0 : -1; 421 } 422 423 static int do_pin(int argc, char **argv) 424 { 425 int err; 426 427 err = do_pin_any(argc, argv, link_parse_fd); 428 if (!err && json_output) 429 jsonw_null(json_wtr); 430 return err; 431 } 432 433 static int do_detach(int argc, char **argv) 434 { 435 int err, fd; 436 437 if (argc != 2) { 438 p_err("link specifier is invalid or missing\n"); 439 return 1; 440 } 441 442 fd = link_parse_fd(&argc, &argv); 443 if (fd < 0) 444 return 1; 445 446 err = bpf_link_detach(fd); 447 if (err) 448 err = -errno; 449 close(fd); 450 if (err) { 451 p_err("failed link detach: %s", strerror(-err)); 452 return 1; 453 } 454 455 if (json_output) 456 jsonw_null(json_wtr); 457 458 return 0; 459 } 460 461 static int do_help(int argc, char **argv) 462 { 463 if (json_output) { 464 jsonw_null(json_wtr); 465 return 0; 466 } 467 468 fprintf(stderr, 469 "Usage: %1$s %2$s { show | list } [LINK]\n" 470 " %1$s %2$s pin LINK FILE\n" 471 " %1$s %2$s detach LINK\n" 472 " %1$s %2$s help\n" 473 "\n" 474 " " HELP_SPEC_LINK "\n" 475 " " HELP_SPEC_OPTIONS " |\n" 476 " {-f|--bpffs} | {-n|--nomount} }\n" 477 "", 478 bin_name, argv[-2]); 479 480 return 0; 481 } 482 483 static const struct cmd cmds[] = { 484 { "show", do_show }, 485 { "list", do_show }, 486 { "help", do_help }, 487 { "pin", do_pin }, 488 { "detach", do_detach }, 489 { 0 } 490 }; 491 492 int do_link(int argc, char **argv) 493 { 494 return cmd_select(cmds, argc, argv, do_help); 495 } 496