tools/bpf/bpftool/link.c

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