tools/bpf/bpftool/common.c

   1 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
   2 /* Copyright (C) 2017-2018 Netronome Systems, Inc. */
   3
   4 #ifndef _GNU_SOURCE
   5 #define _GNU_SOURCE
   6 #endif
   7 #include <ctype.h>
   8 #include <errno.h>
   9 #include <fcntl.h>
  10 #include <ftw.h>
  11 #include <libgen.h>
  12 #include <mntent.h>
  13 #include <stdbool.h>
  14 #include <stdio.h>
  15 #include <stdlib.h>
  16 #include <string.h>
  17 #include <unistd.h>
  18 #include <net/if.h>
  19 #include <sys/mount.h>
  20 #include <sys/resource.h>
  21 #include <sys/stat.h>
  22 #include <sys/vfs.h>
  23
  24 #include <linux/filter.h>
  25 #include <linux/limits.h>
  26 #include <linux/magic.h>
  27 #include <linux/unistd.h>
  28
  29 #include <bpf/bpf.h>
  30 #include <bpf/hashmap.h>
  31 #include <bpf/libbpf.h> /* libbpf_num_possible_cpus */
  32 #include <bpf/btf.h>
  33
  34 #include "main.h"
  35
  36 #ifndef BPF_FS_MAGIC
  37 #define BPF_FS_MAGIC            0xcafe4a11
  38 #endif
  39
  40 void p_err(const char *fmt, ...)
  41 {
  42         va_list ap;
  43
  44         va_start(ap, fmt);
  45         if (json_output) {
  46                 jsonw_start_object(json_wtr);
  47                 jsonw_name(json_wtr, "error");
  48                 jsonw_vprintf_enquote(json_wtr, fmt, ap);
  49                 jsonw_end_object(json_wtr);
  50         } else {
  51                 fprintf(stderr, "Error: ");
  52                 vfprintf(stderr, fmt, ap);
  53                 fprintf(stderr, "\n");
  54         }
  55         va_end(ap);
  56 }
  57
  58 void p_info(const char *fmt, ...)
  59 {
  60         va_list ap;
  61
  62         if (json_output)
  63                 return;
  64
  65         va_start(ap, fmt);
  66         vfprintf(stderr, fmt, ap);
  67         fprintf(stderr, "\n");
  68         va_end(ap);
  69 }
  70
  71 static bool is_bpffs(const char *path)
  72 {
  73         struct statfs st_fs;
  74
  75         if (statfs(path, &st_fs) < 0)
  76                 return false;
  77
  78         return (unsigned long)st_fs.f_type == BPF_FS_MAGIC;
  79 }
  80
  81 /* Probe whether kernel switched from memlock-based (RLIMIT_MEMLOCK) to
  82  * memcg-based memory accounting for BPF maps and programs. This was done in
  83  * commit 97306be45fbe ("Merge branch 'switch to memcg-based memory
  84  * accounting'"), in Linux 5.11.
  85  *
  86  * Libbpf also offers to probe for memcg-based accounting vs rlimit, but does
  87  * so by checking for the availability of a given BPF helper and this has
  88  * failed on some kernels with backports in the past, see commit 6b4384ff1088
  89  * ("Revert "bpftool: Use libbpf 1.0 API mode instead of RLIMIT_MEMLOCK"").
  90  * Instead, we can probe by lowering the process-based rlimit to 0, trying to
  91  * load a BPF object, and resetting the rlimit. If the load succeeds then
  92  * memcg-based accounting is supported.
  93  *
  94  * This would be too dangerous to do in the library, because multithreaded
  95  * applications might attempt to load items while the rlimit is at 0. Given
  96  * that bpftool is single-threaded, this is fine to do here.
  97  */
  98 static bool known_to_need_rlimit(void)
  99 {
 100         struct rlimit rlim_init, rlim_cur_zero = {};
 101         struct bpf_insn insns[] = {
 102                 BPF_MOV64_IMM(BPF_REG_0, 0),
 103                 BPF_EXIT_INSN(),
 104         };
 105         size_t insn_cnt = ARRAY_SIZE(insns);
 106         union bpf_attr attr;
 107         int prog_fd, err;
 108
 109         memset(&attr, 0, sizeof(attr));
 110         attr.prog_type = BPF_PROG_TYPE_SOCKET_FILTER;
 111         attr.insns = ptr_to_u64(insns);
 112         attr.insn_cnt = insn_cnt;
 113         attr.license = ptr_to_u64("GPL");
 114
 115         if (getrlimit(RLIMIT_MEMLOCK, &rlim_init))
 116                 return false;
 117
 118         /* Drop the soft limit to zero. We maintain the hard limit to its
 119          * current value, because lowering it would be a permanent operation
 120          * for unprivileged users.
 121          */
 122         rlim_cur_zero.rlim_max = rlim_init.rlim_max;
 123         if (setrlimit(RLIMIT_MEMLOCK, &rlim_cur_zero))
 124                 return false;
 125
 126         /* Do not use bpf_prog_load() from libbpf here, because it calls
 127          * bump_rlimit_memlock(), interfering with the current probe.
 128          */
 129         prog_fd = syscall(__NR_bpf, BPF_PROG_LOAD, &attr, sizeof(attr));
 130         err = errno;
 131
 132         /* reset soft rlimit to its initial value */
 133         setrlimit(RLIMIT_MEMLOCK, &rlim_init);
 134
 135         if (prog_fd < 0)
 136                 return err == EPERM;
 137
 138         close(prog_fd);
 139         return false;
 140 }
 141
 142 void set_max_rlimit(void)
 143 {
 144         struct rlimit rinf = { RLIM_INFINITY, RLIM_INFINITY };
 145
 146         if (known_to_need_rlimit())
 147                 setrlimit(RLIMIT_MEMLOCK, &rinf);
 148 }
 149
 150 static int
 151 mnt_fs(const char *target, const char *type, char *buff, size_t bufflen)
 152 {
 153         bool bind_done = false;
 154
 155         while (mount("", target, "none", MS_PRIVATE | MS_REC, NULL)) {
 156                 if (errno != EINVAL || bind_done) {
 157                         snprintf(buff, bufflen,
 158                                  "mount --make-private %s failed: %s",
 159                                  target, strerror(errno));
 160                         return -1;
 161                 }
 162
 163                 if (mount(target, target, "none", MS_BIND, NULL)) {
 164                         snprintf(buff, bufflen,
 165                                  "mount --bind %s %s failed: %s",
 166                                  target, target, strerror(errno));
 167                         return -1;
 168                 }
 169
 170                 bind_done = true;
 171         }
 172
 173         if (mount(type, target, type, 0, "mode=0700")) {
 174                 snprintf(buff, bufflen, "mount -t %s %s %s failed: %s",
 175                          type, type, target, strerror(errno));
 176                 return -1;
 177         }
 178
 179         return 0;
 180 }
 181
 182 int mount_tracefs(const char *target)
 183 {
 184         char err_str[ERR_MAX_LEN];
 185         int err;
 186
 187         err = mnt_fs(target, "tracefs", err_str, ERR_MAX_LEN);
 188         if (err) {
 189                 err_str[ERR_MAX_LEN - 1] = '\0';
 190                 p_err("can't mount tracefs: %s", err_str);
 191         }
 192
 193         return err;
 194 }
 195
 196 int open_obj_pinned(const char *path, bool quiet)
 197 {
 198         char *pname;
 199         int fd = -1;
 200
 201         pname = strdup(path);
 202         if (!pname) {
 203                 if (!quiet)
 204                         p_err("mem alloc failed");
 205                 goto out_ret;
 206         }
 207
 208         fd = bpf_obj_get(pname);
 209         if (fd < 0) {
 210                 if (!quiet)
 211                         p_err("bpf obj get (%s): %s", pname,
 212                               errno == EACCES && !is_bpffs(dirname(pname)) ?
 213                             "directory not in bpf file system (bpffs)" :
 214                             strerror(errno));
 215                 goto out_free;
 216         }
 217
 218 out_free:
 219         free(pname);
 220 out_ret:
 221         return fd;
 222 }
 223
 224 int open_obj_pinned_any(const char *path, enum bpf_obj_type exp_type)
 225 {
 226         enum bpf_obj_type type;
 227         int fd;
 228
 229         fd = open_obj_pinned(path, false);
 230         if (fd < 0)
 231                 return -1;
 232
 233         type = get_fd_type(fd);
 234         if (type < 0) {
 235                 close(fd);
 236                 return type;
 237         }
 238         if (type != exp_type) {
 239                 p_err("incorrect object type: %s", get_fd_type_name(type));
 240                 close(fd);
 241                 return -1;
 242         }
 243
 244         return fd;
 245 }
 246
 247 int mount_bpffs_for_pin(const char *name, bool is_dir)
 248 {
 249         char err_str[ERR_MAX_LEN];
 250         char *file;
 251         char *dir;
 252         int err = 0;
 253
 254         if (is_dir && is_bpffs(name))
 255                 return err;
 256
 257         file = malloc(strlen(name) + 1);
 258         if (!file) {
 259                 p_err("mem alloc failed");
 260                 return -1;
 261         }
 262
 263         strcpy(file, name);
 264         dir = dirname(file);
 265
 266         if (is_bpffs(dir))
 267                 /* nothing to do if already mounted */
 268                 goto out_free;
 269
 270         if (block_mount) {
 271                 p_err("no BPF file system found, not mounting it due to --nomount option");
 272                 err = -1;
 273                 goto out_free;
 274         }
 275
 276         err = mnt_fs(dir, "bpf", err_str, ERR_MAX_LEN);
 277         if (err) {
 278                 err_str[ERR_MAX_LEN - 1] = '\0';
 279                 p_err("can't mount BPF file system to pin the object (%s): %s",
 280                       name, err_str);
 281         }
 282
 283 out_free:
 284         free(file);
 285         return err;
 286 }
 287
 288 int do_pin_fd(int fd, const char *name)
 289 {
 290         int err;
 291
 292         err = mount_bpffs_for_pin(name, false);
 293         if (err)
 294                 return err;
 295
 296         err = bpf_obj_pin(fd, name);
 297         if (err)
 298                 p_err("can't pin the object (%s): %s", name, strerror(errno));
 299
 300         return err;
 301 }
 302
 303 int do_pin_any(int argc, char **argv, int (*get_fd)(int *, char ***))
 304 {
 305         int err;
 306         int fd;
 307
 308         if (!REQ_ARGS(3))
 309                 return -EINVAL;
 310
 311         fd = get_fd(&argc, &argv);
 312         if (fd < 0)
 313                 return fd;
 314
 315         err = do_pin_fd(fd, *argv);
 316
 317         close(fd);
 318         return err;
 319 }
 320
 321 const char *get_fd_type_name(enum bpf_obj_type type)
 322 {
 323         static const char * const names[] = {
 324                 [BPF_OBJ_UNKNOWN]       = "unknown",
 325                 [BPF_OBJ_PROG]          = "prog",
 326                 [BPF_OBJ_MAP]           = "map",
 327                 [BPF_OBJ_LINK]          = "link",
 328         };
 329
 330         if (type < 0 || type >= ARRAY_SIZE(names) || !names[type])
 331                 return names[BPF_OBJ_UNKNOWN];
 332
 333         return names[type];
 334 }
 335
 336 void get_prog_full_name(const struct bpf_prog_info *prog_info, int prog_fd,
 337                         char *name_buff, size_t buff_len)
 338 {
 339         const char *prog_name = prog_info->name;
 340         const struct btf_type *func_type;
 341         const struct bpf_func_info finfo = {};
 342         struct bpf_prog_info info = {};
 343         __u32 info_len = sizeof(info);
 344         struct btf *prog_btf = NULL;
 345
 346         if (buff_len <= BPF_OBJ_NAME_LEN ||
 347             strlen(prog_info->name) < BPF_OBJ_NAME_LEN - 1)
 348                 goto copy_name;
 349
 350         if (!prog_info->btf_id || prog_info->nr_func_info == 0)
 351                 goto copy_name;
 352
 353         info.nr_func_info = 1;
 354         info.func_info_rec_size = prog_info->func_info_rec_size;
 355         if (info.func_info_rec_size > sizeof(finfo))
 356                 info.func_info_rec_size = sizeof(finfo);
 357         info.func_info = ptr_to_u64(&finfo);
 358
 359         if (bpf_prog_get_info_by_fd(prog_fd, &info, &info_len))
 360                 goto copy_name;
 361
 362         prog_btf = btf__load_from_kernel_by_id(info.btf_id);
 363         if (!prog_btf)
 364                 goto copy_name;
 365
 366         func_type = btf__type_by_id(prog_btf, finfo.type_id);
 367         if (!func_type || !btf_is_func(func_type))
 368                 goto copy_name;
 369
 370         prog_name = btf__name_by_offset(prog_btf, func_type->name_off);
 371
 372 copy_name:
 373         snprintf(name_buff, buff_len, "%s", prog_name);
 374
 375         if (prog_btf)
 376                 btf__free(prog_btf);
 377 }
 378
 379 int get_fd_type(int fd)
 380 {
 381         char path[PATH_MAX];
 382         char buf[512];
 383         ssize_t n;
 384
 385         snprintf(path, sizeof(path), "/proc/self/fd/%d", fd);
 386
 387         n = readlink(path, buf, sizeof(buf));
 388         if (n < 0) {
 389                 p_err("can't read link type: %s", strerror(errno));
 390                 return -1;
 391         }
 392         if (n == sizeof(path)) {
 393                 p_err("can't read link type: path too long!");
 394                 return -1;
 395         }
 396
 397         if (strstr(buf, "bpf-map"))
 398                 return BPF_OBJ_MAP;
 399         else if (strstr(buf, "bpf-prog"))
 400                 return BPF_OBJ_PROG;
 401         else if (strstr(buf, "bpf-link"))
 402                 return BPF_OBJ_LINK;
 403
 404         return BPF_OBJ_UNKNOWN;
 405 }
 406
 407 char *get_fdinfo(int fd, const char *key)
 408 {
 409         char path[PATH_MAX];
 410         char *line = NULL;
 411         size_t line_n = 0;
 412         ssize_t n;
 413         FILE *fdi;
 414
 415         snprintf(path, sizeof(path), "/proc/self/fdinfo/%d", fd);
 416
 417         fdi = fopen(path, "r");
 418         if (!fdi)
 419                 return NULL;
 420
 421         while ((n = getline(&line, &line_n, fdi)) > 0) {
 422                 char *value;
 423                 int len;
 424
 425                 if (!strstr(line, key))
 426                         continue;
 427
 428                 fclose(fdi);
 429
 430                 value = strchr(line, '\t');
 431                 if (!value || !value[1]) {
 432                         free(line);
 433                         return NULL;
 434                 }
 435                 value++;
 436
 437                 len = strlen(value);
 438                 memmove(line, value, len);
 439                 line[len - 1] = '\0';
 440
 441                 return line;
 442         }
 443
 444         free(line);
 445         fclose(fdi);
 446         return NULL;
 447 }
 448
 449 void print_data_json(uint8_t *data, size_t len)
 450 {
 451         unsigned int i;
 452
 453         jsonw_start_array(json_wtr);
 454         for (i = 0; i < len; i++)
 455                 jsonw_printf(json_wtr, "%d", data[i]);
 456         jsonw_end_array(json_wtr);
 457 }
 458
 459 void print_hex_data_json(uint8_t *data, size_t len)
 460 {
 461         unsigned int i;
 462
 463         jsonw_start_array(json_wtr);
 464         for (i = 0; i < len; i++)
 465                 jsonw_printf(json_wtr, "\"0x%02hhx\"", data[i]);
 466         jsonw_end_array(json_wtr);
 467 }
 468
 469 /* extra params for nftw cb */
 470 static struct hashmap *build_fn_table;
 471 static enum bpf_obj_type build_fn_type;
 472
 473 static int do_build_table_cb(const char *fpath, const struct stat *sb,
 474                              int typeflag, struct FTW *ftwbuf)
 475 {
 476         struct bpf_prog_info pinned_info;
 477         __u32 len = sizeof(pinned_info);
 478         enum bpf_obj_type objtype;
 479         int fd, err = 0;
 480         char *path;
 481
 482         if (typeflag != FTW_F)
 483                 goto out_ret;
 484
 485         fd = open_obj_pinned(fpath, true);
 486         if (fd < 0)
 487                 goto out_ret;
 488
 489         objtype = get_fd_type(fd);
 490         if (objtype != build_fn_type)
 491                 goto out_close;
 492
 493         memset(&pinned_info, 0, sizeof(pinned_info));
 494         if (bpf_prog_get_info_by_fd(fd, &pinned_info, &len))
 495                 goto out_close;
 496
 497         path = strdup(fpath);
 498         if (!path) {
 499                 err = -1;
 500                 goto out_close;
 501         }
 502
 503         err = hashmap__append(build_fn_table, pinned_info.id, path);
 504         if (err) {
 505                 p_err("failed to append entry to hashmap for ID %u, path '%s': %s",
 506                       pinned_info.id, path, strerror(errno));
 507                 free(path);
 508                 goto out_close;
 509         }
 510
 511 out_close:
 512         close(fd);
 513 out_ret:
 514         return err;
 515 }
 516
 517 int build_pinned_obj_table(struct hashmap *tab,
 518                            enum bpf_obj_type type)
 519 {
 520         struct mntent *mntent = NULL;
 521         FILE *mntfile = NULL;
 522         int flags = FTW_PHYS;
 523         int nopenfd = 16;
 524         int err = 0;
 525
 526         mntfile = setmntent("/proc/mounts", "r");
 527         if (!mntfile)
 528                 return -1;
 529
 530         build_fn_table = tab;
 531         build_fn_type = type;
 532
 533         while ((mntent = getmntent(mntfile))) {
 534                 char *path = mntent->mnt_dir;
 535
 536                 if (strncmp(mntent->mnt_type, "bpf", 3) != 0)
 537                         continue;
 538                 err = nftw(path, do_build_table_cb, nopenfd, flags);
 539                 if (err)
 540                         break;
 541         }
 542         fclose(mntfile);
 543         return err;
 544 }
 545
 546 void delete_pinned_obj_table(struct hashmap *map)
 547 {
 548         struct hashmap_entry *entry;
 549         size_t bkt;
 550
 551         if (!map)
 552                 return;
 553
 554         hashmap__for_each_entry(map, entry, bkt)
 555                 free(entry->pvalue);
 556
 557         hashmap__free(map);
 558 }
 559
 560 unsigned int get_page_size(void)
 561 {
 562         static int result;
 563
 564         if (!result)
 565                 result = getpagesize();
 566         return result;
 567 }
 568
 569 unsigned int get_possible_cpus(void)
 570 {
 571         int cpus = libbpf_num_possible_cpus();
 572
 573         if (cpus < 0) {
 574                 p_err("Can't get # of possible cpus: %s", strerror(-cpus));
 575                 exit(-1);
 576         }
 577         return cpus;
 578 }
 579
 580 static char *
 581 ifindex_to_name_ns(__u32 ifindex, __u32 ns_dev, __u32 ns_ino, char *buf)
 582 {
 583         struct stat st;
 584         int err;
 585
 586         err = stat("/proc/self/ns/net", &st);
 587         if (err) {
 588                 p_err("Can't stat /proc/self: %s", strerror(errno));
 589                 return NULL;
 590         }
 591
 592         if (st.st_dev != ns_dev || st.st_ino != ns_ino)
 593                 return NULL;
 594
 595         return if_indextoname(ifindex, buf);
 596 }
 597
 598 static int read_sysfs_hex_int(char *path)
 599 {
 600         char vendor_id_buf[8];
 601         int len;
 602         int fd;
 603
 604         fd = open(path, O_RDONLY);
 605         if (fd < 0) {
 606                 p_err("Can't open %s: %s", path, strerror(errno));
 607                 return -1;
 608         }
 609
 610         len = read(fd, vendor_id_buf, sizeof(vendor_id_buf));
 611         close(fd);
 612         if (len < 0) {
 613                 p_err("Can't read %s: %s", path, strerror(errno));
 614                 return -1;
 615         }
 616         if (len >= (int)sizeof(vendor_id_buf)) {
 617                 p_err("Value in %s too long", path);
 618                 return -1;
 619         }
 620
 621         vendor_id_buf[len] = 0;
 622
 623         return strtol(vendor_id_buf, NULL, 0);
 624 }
 625
 626 static int read_sysfs_netdev_hex_int(char *devname, const char *entry_name)
 627 {
 628         char full_path[64];
 629
 630         snprintf(full_path, sizeof(full_path), "/sys/class/net/%s/device/%s",
 631                  devname, entry_name);
 632
 633         return read_sysfs_hex_int(full_path);
 634 }
 635
 636 const char *
 637 ifindex_to_arch(__u32 ifindex, __u64 ns_dev, __u64 ns_ino, const char **opt)
 638 {
 639         __maybe_unused int device_id;
 640         char devname[IF_NAMESIZE];
 641         int vendor_id;
 642
 643         if (!ifindex_to_name_ns(ifindex, ns_dev, ns_ino, devname)) {
 644                 p_err("Can't get net device name for ifindex %d: %s", ifindex,
 645                       strerror(errno));
 646                 return NULL;
 647         }
 648
 649         vendor_id = read_sysfs_netdev_hex_int(devname, "vendor");
 650         if (vendor_id < 0) {
 651                 p_err("Can't get device vendor id for %s", devname);
 652                 return NULL;
 653         }
 654
 655         switch (vendor_id) {
 656 #ifdef HAVE_LIBBFD_SUPPORT
 657         case 0x19ee:
 658                 device_id = read_sysfs_netdev_hex_int(devname, "device");
 659                 if (device_id != 0x4000 &&
 660                     device_id != 0x6000 &&
 661                     device_id != 0x6003)
 662                         p_info("Unknown NFP device ID, assuming it is NFP-6xxx arch");
 663                 *opt = "ctx4";
 664                 return "NFP-6xxx";
 665 #endif /* HAVE_LIBBFD_SUPPORT */
 666         /* No NFP support in LLVM, we have no valid triple to return. */
 667         default:
 668                 p_err("Can't get arch name for device vendor id 0x%04x",
 669                       vendor_id);
 670                 return NULL;
 671         }
 672 }
 673
 674 void print_dev_plain(__u32 ifindex, __u64 ns_dev, __u64 ns_inode)
 675 {
 676         char name[IF_NAMESIZE];
 677
 678         if (!ifindex)
 679                 return;
 680
 681         printf("  offloaded_to ");
 682         if (ifindex_to_name_ns(ifindex, ns_dev, ns_inode, name))
 683                 printf("%s", name);
 684         else
 685                 printf("ifindex %u ns_dev %llu ns_ino %llu",
 686                        ifindex, ns_dev, ns_inode);
 687 }
 688
 689 void print_dev_json(__u32 ifindex, __u64 ns_dev, __u64 ns_inode)
 690 {
 691         char name[IF_NAMESIZE];
 692
 693         if (!ifindex)
 694                 return;
 695
 696         jsonw_name(json_wtr, "dev");
 697         jsonw_start_object(json_wtr);
 698         jsonw_uint_field(json_wtr, "ifindex", ifindex);
 699         jsonw_uint_field(json_wtr, "ns_dev", ns_dev);
 700         jsonw_uint_field(json_wtr, "ns_inode", ns_inode);
 701         if (ifindex_to_name_ns(ifindex, ns_dev, ns_inode, name))
 702                 jsonw_string_field(json_wtr, "ifname", name);
 703         jsonw_end_object(json_wtr);
 704 }
 705
 706 int parse_u32_arg(int *argc, char ***argv, __u32 *val, const char *what)
 707 {
 708         char *endptr;
 709
 710         NEXT_ARGP();
 711
 712         if (*val) {
 713                 p_err("%s already specified", what);
 714                 return -1;
 715         }
 716
 717         *val = strtoul(**argv, &endptr, 0);
 718         if (*endptr) {
 719                 p_err("can't parse %s as %s", **argv, what);
 720                 return -1;
 721         }
 722         NEXT_ARGP();
 723
 724         return 0;
 725 }
 726
 727 int __printf(2, 0)
 728 print_all_levels(__maybe_unused enum libbpf_print_level level,
 729                  const char *format, va_list args)
 730 {
 731         return vfprintf(stderr, format, args);
 732 }
 733
 734 static int prog_fd_by_nametag(void *nametag, int **fds, bool tag)
 735 {
 736         char prog_name[MAX_PROG_FULL_NAME];
 737         unsigned int id = 0;
 738         int fd, nb_fds = 0;
 739         void *tmp;
 740         int err;
 741
 742         while (true) {
 743                 struct bpf_prog_info info = {};
 744                 __u32 len = sizeof(info);
 745
 746                 err = bpf_prog_get_next_id(id, &id);
 747                 if (err) {
 748                         if (errno != ENOENT) {
 749                                 p_err("%s", strerror(errno));
 750                                 goto err_close_fds;
 751                         }
 752                         return nb_fds;
 753                 }
 754
 755                 fd = bpf_prog_get_fd_by_id(id);
 756                 if (fd < 0) {
 757                         p_err("can't get prog by id (%u): %s",
 758                               id, strerror(errno));
 759                         goto err_close_fds;
 760                 }
 761
 762                 err = bpf_prog_get_info_by_fd(fd, &info, &len);
 763                 if (err) {
 764                         p_err("can't get prog info (%u): %s",
 765                               id, strerror(errno));
 766                         goto err_close_fd;
 767                 }
 768
 769                 if (tag && memcmp(nametag, info.tag, BPF_TAG_SIZE)) {
 770                         close(fd);
 771                         continue;
 772                 }
 773
 774                 if (!tag) {
 775                         get_prog_full_name(&info, fd, prog_name,
 776                                            sizeof(prog_name));
 777                         if (strncmp(nametag, prog_name, sizeof(prog_name))) {
 778                                 close(fd);
 779                                 continue;
 780                         }
 781                 }
 782
 783                 if (nb_fds > 0) {
 784                         tmp = realloc(*fds, (nb_fds + 1) * sizeof(int));
 785                         if (!tmp) {
 786                                 p_err("failed to realloc");
 787                                 goto err_close_fd;
 788                         }
 789                         *fds = tmp;
 790                 }
 791                 (*fds)[nb_fds++] = fd;
 792         }
 793
 794 err_close_fd:
 795         close(fd);
 796 err_close_fds:
 797         while (--nb_fds >= 0)
 798                 close((*fds)[nb_fds]);
 799         return -1;
 800 }
 801
 802 int prog_parse_fds(int *argc, char ***argv, int **fds)
 803 {
 804         if (is_prefix(**argv, "id")) {
 805                 unsigned int id;
 806                 char *endptr;
 807
 808                 NEXT_ARGP();
 809
 810                 id = strtoul(**argv, &endptr, 0);
 811                 if (*endptr) {
 812                         p_err("can't parse %s as ID", **argv);
 813                         return -1;
 814                 }
 815                 NEXT_ARGP();
 816
 817                 (*fds)[0] = bpf_prog_get_fd_by_id(id);
 818                 if ((*fds)[0] < 0) {
 819                         p_err("get by id (%u): %s", id, strerror(errno));
 820                         return -1;
 821                 }
 822                 return 1;
 823         } else if (is_prefix(**argv, "tag")) {
 824                 unsigned char tag[BPF_TAG_SIZE];
 825
 826                 NEXT_ARGP();
 827
 828                 if (sscanf(**argv, BPF_TAG_FMT, tag, tag + 1, tag + 2,
 829                            tag + 3, tag + 4, tag + 5, tag + 6, tag + 7)
 830                     != BPF_TAG_SIZE) {
 831                         p_err("can't parse tag");
 832                         return -1;
 833                 }
 834                 NEXT_ARGP();
 835
 836                 return prog_fd_by_nametag(tag, fds, true);
 837         } else if (is_prefix(**argv, "name")) {
 838                 char *name;
 839
 840                 NEXT_ARGP();
 841
 842                 name = **argv;
 843                 if (strlen(name) > MAX_PROG_FULL_NAME - 1) {
 844                         p_err("can't parse name");
 845                         return -1;
 846                 }
 847                 NEXT_ARGP();
 848
 849                 return prog_fd_by_nametag(name, fds, false);
 850         } else if (is_prefix(**argv, "pinned")) {
 851                 char *path;
 852
 853                 NEXT_ARGP();
 854
 855                 path = **argv;
 856                 NEXT_ARGP();
 857
 858                 (*fds)[0] = open_obj_pinned_any(path, BPF_OBJ_PROG);
 859                 if ((*fds)[0] < 0)
 860                         return -1;
 861                 return 1;
 862         }
 863
 864         p_err("expected 'id', 'tag', 'name' or 'pinned', got: '%s'?", **argv);
 865         return -1;
 866 }
 867
 868 int prog_parse_fd(int *argc, char ***argv)
 869 {
 870         int *fds = NULL;
 871         int nb_fds, fd;
 872
 873         fds = malloc(sizeof(int));
 874         if (!fds) {
 875                 p_err("mem alloc failed");
 876                 return -1;
 877         }
 878         nb_fds = prog_parse_fds(argc, argv, &fds);
 879         if (nb_fds != 1) {
 880                 if (nb_fds > 1) {
 881                         p_err("several programs match this handle");
 882                         while (nb_fds--)
 883                                 close(fds[nb_fds]);
 884                 }
 885                 fd = -1;
 886                 goto exit_free;
 887         }
 888
 889         fd = fds[0];
 890 exit_free:
 891         free(fds);
 892         return fd;
 893 }
 894
 895 static int map_fd_by_name(char *name, int **fds)
 896 {
 897         unsigned int id = 0;
 898         int fd, nb_fds = 0;
 899         void *tmp;
 900         int err;
 901
 902         while (true) {
 903                 struct bpf_map_info info = {};
 904                 __u32 len = sizeof(info);
 905
 906                 err = bpf_map_get_next_id(id, &id);
 907                 if (err) {
 908                         if (errno != ENOENT) {
 909                                 p_err("%s", strerror(errno));
 910                                 goto err_close_fds;
 911                         }
 912                         return nb_fds;
 913                 }
 914
 915                 fd = bpf_map_get_fd_by_id(id);
 916                 if (fd < 0) {
 917                         p_err("can't get map by id (%u): %s",
 918                               id, strerror(errno));
 919                         goto err_close_fds;
 920                 }
 921
 922                 err = bpf_map_get_info_by_fd(fd, &info, &len);
 923                 if (err) {
 924                         p_err("can't get map info (%u): %s",
 925                               id, strerror(errno));
 926                         goto err_close_fd;
 927                 }
 928
 929                 if (strncmp(name, info.name, BPF_OBJ_NAME_LEN)) {
 930                         close(fd);
 931                         continue;
 932                 }
 933
 934                 if (nb_fds > 0) {
 935                         tmp = realloc(*fds, (nb_fds + 1) * sizeof(int));
 936                         if (!tmp) {
 937                                 p_err("failed to realloc");
 938                                 goto err_close_fd;
 939                         }
 940                         *fds = tmp;
 941                 }
 942                 (*fds)[nb_fds++] = fd;
 943         }
 944
 945 err_close_fd:
 946         close(fd);
 947 err_close_fds:
 948         while (--nb_fds >= 0)
 949                 close((*fds)[nb_fds]);
 950         return -1;
 951 }
 952
 953 int map_parse_fds(int *argc, char ***argv, int **fds)
 954 {
 955         if (is_prefix(**argv, "id")) {
 956                 unsigned int id;
 957                 char *endptr;
 958
 959                 NEXT_ARGP();
 960
 961                 id = strtoul(**argv, &endptr, 0);
 962                 if (*endptr) {
 963                         p_err("can't parse %s as ID", **argv);
 964                         return -1;
 965                 }
 966                 NEXT_ARGP();
 967
 968                 (*fds)[0] = bpf_map_get_fd_by_id(id);
 969                 if ((*fds)[0] < 0) {
 970                         p_err("get map by id (%u): %s", id, strerror(errno));
 971                         return -1;
 972                 }
 973                 return 1;
 974         } else if (is_prefix(**argv, "name")) {
 975                 char *name;
 976
 977                 NEXT_ARGP();
 978
 979                 name = **argv;
 980                 if (strlen(name) > BPF_OBJ_NAME_LEN - 1) {
 981                         p_err("can't parse name");
 982                         return -1;
 983                 }
 984                 NEXT_ARGP();
 985
 986                 return map_fd_by_name(name, fds);
 987         } else if (is_prefix(**argv, "pinned")) {
 988                 char *path;
 989
 990                 NEXT_ARGP();
 991
 992                 path = **argv;
 993                 NEXT_ARGP();
 994
 995                 (*fds)[0] = open_obj_pinned_any(path, BPF_OBJ_MAP);
 996                 if ((*fds)[0] < 0)
 997                         return -1;
 998                 return 1;
 999         }
1000
1001         p_err("expected 'id', 'name' or 'pinned', got: '%s'?", **argv);
1002         return -1;
1003 }
1004
1005 int map_parse_fd(int *argc, char ***argv)
1006 {
1007         int *fds = NULL;
1008         int nb_fds, fd;
1009
1010         fds = malloc(sizeof(int));
1011         if (!fds) {
1012                 p_err("mem alloc failed");
1013                 return -1;
1014         }
1015         nb_fds = map_parse_fds(argc, argv, &fds);
1016         if (nb_fds != 1) {
1017                 if (nb_fds > 1) {
1018                         p_err("several maps match this handle");
1019                         while (nb_fds--)
1020                                 close(fds[nb_fds]);
1021                 }
1022                 fd = -1;
1023                 goto exit_free;
1024         }
1025
1026         fd = fds[0];
1027 exit_free:
1028         free(fds);
1029         return fd;
1030 }
1031
1032 int map_parse_fd_and_info(int *argc, char ***argv, struct bpf_map_info *info,
1033                           __u32 *info_len)
1034 {
1035         int err;
1036         int fd;
1037
1038         fd = map_parse_fd(argc, argv);
1039         if (fd < 0)
1040                 return -1;
1041
1042         err = bpf_map_get_info_by_fd(fd, info, info_len);
1043         if (err) {
1044                 p_err("can't get map info: %s", strerror(errno));
1045                 close(fd);
1046                 return err;
1047         }
1048
1049         return fd;
1050 }
1051
1052 size_t hash_fn_for_key_as_id(long key, void *ctx)
1053 {
1054         return key;
1055 }
1056
1057 bool equal_fn_for_key_as_id(long k1, long k2, void *ctx)
1058 {
1059         return k1 == k2;
1060 }
1061
1062 const char *bpf_attach_type_input_str(enum bpf_attach_type t)
1063 {
1064         switch (t) {
1065         case BPF_CGROUP_INET_INGRESS:           return "ingress";
1066         case BPF_CGROUP_INET_EGRESS:            return "egress";
1067         case BPF_CGROUP_INET_SOCK_CREATE:       return "sock_create";
1068         case BPF_CGROUP_INET_SOCK_RELEASE:      return "sock_release";
1069         case BPF_CGROUP_SOCK_OPS:               return "sock_ops";
1070         case BPF_CGROUP_DEVICE:                 return "device";
1071         case BPF_CGROUP_INET4_BIND:             return "bind4";
1072         case BPF_CGROUP_INET6_BIND:             return "bind6";
1073         case BPF_CGROUP_INET4_CONNECT:          return "connect4";
1074         case BPF_CGROUP_INET6_CONNECT:          return "connect6";
1075         case BPF_CGROUP_INET4_POST_BIND:        return "post_bind4";
1076         case BPF_CGROUP_INET6_POST_BIND:        return "post_bind6";
1077         case BPF_CGROUP_INET4_GETPEERNAME:      return "getpeername4";
1078         case BPF_CGROUP_INET6_GETPEERNAME:      return "getpeername6";
1079         case BPF_CGROUP_INET4_GETSOCKNAME:      return "getsockname4";
1080         case BPF_CGROUP_INET6_GETSOCKNAME:      return "getsockname6";
1081         case BPF_CGROUP_UDP4_SENDMSG:           return "sendmsg4";
1082         case BPF_CGROUP_UDP6_SENDMSG:           return "sendmsg6";
1083         case BPF_CGROUP_SYSCTL:                 return "sysctl";
1084         case BPF_CGROUP_UDP4_RECVMSG:           return "recvmsg4";
1085         case BPF_CGROUP_UDP6_RECVMSG:           return "recvmsg6";
1086         case BPF_CGROUP_GETSOCKOPT:             return "getsockopt";
1087         case BPF_CGROUP_SETSOCKOPT:             return "setsockopt";
1088         case BPF_TRACE_RAW_TP:                  return "raw_tp";
1089         case BPF_TRACE_FENTRY:                  return "fentry";
1090         case BPF_TRACE_FEXIT:                   return "fexit";
1091         case BPF_MODIFY_RETURN:                 return "mod_ret";
1092         case BPF_SK_REUSEPORT_SELECT:           return "sk_skb_reuseport_select";
1093         case BPF_SK_REUSEPORT_SELECT_OR_MIGRATE:        return "sk_skb_reuseport_select_or_migrate";
1094         default:        return libbpf_bpf_attach_type_str(t);
1095         }
1096 }
1097
1098 int pathname_concat(char *buf, int buf_sz, const char *path,
1099                     const char *name)
1100 {
1101         int len;
1102
1103         len = snprintf(buf, buf_sz, "%s/%s", path, name);
1104         if (len < 0)
1105                 return -EINVAL;
1106         if (len >= buf_sz)
1107                 return -ENAMETOOLONG;
1108
1109         return 0;
1110 }