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