tools/bpf/bpftool/prog.c

   1 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
   2 /* Copyright (C) 2017-2018 Netronome Systems, Inc. */
   3
   4 #define _GNU_SOURCE
   5 #include <errno.h>
   6 #include <fcntl.h>
   7 #include <stdarg.h>
   8 #include <stdio.h>
   9 #include <stdlib.h>
  10 #include <string.h>
  11 #include <time.h>
  12 #include <unistd.h>
  13 #include <net/if.h>
  14 #include <sys/types.h>
  15 #include <sys/stat.h>
  16
  17 #include <linux/err.h>
  18
  19 #include <bpf.h>
  20 #include <btf.h>
  21 #include <libbpf.h>
  22
  23 #include "cfg.h"
  24 #include "main.h"
  25 #include "xlated_dumper.h"
  26
  27 static const char * const attach_type_strings[] = {
  28         [BPF_SK_SKB_STREAM_PARSER] = "stream_parser",
  29         [BPF_SK_SKB_STREAM_VERDICT] = "stream_verdict",
  30         [BPF_SK_MSG_VERDICT] = "msg_verdict",
  31         [BPF_FLOW_DISSECTOR] = "flow_dissector",
  32         [__MAX_BPF_ATTACH_TYPE] = NULL,
  33 };
  34
  35 static enum bpf_attach_type parse_attach_type(const char *str)
  36 {
  37         enum bpf_attach_type type;
  38
  39         for (type = 0; type < __MAX_BPF_ATTACH_TYPE; type++) {
  40                 if (attach_type_strings[type] &&
  41                     is_prefix(str, attach_type_strings[type]))
  42                         return type;
  43         }
  44
  45         return __MAX_BPF_ATTACH_TYPE;
  46 }
  47
  48 static void print_boot_time(__u64 nsecs, char *buf, unsigned int size)
  49 {
  50         struct timespec real_time_ts, boot_time_ts;
  51         time_t wallclock_secs;
  52         struct tm load_tm;
  53
  54         buf[--size] = '\0';
  55
  56         if (clock_gettime(CLOCK_REALTIME, &real_time_ts) ||
  57             clock_gettime(CLOCK_BOOTTIME, &boot_time_ts)) {
  58                 perror("Can't read clocks");
  59                 snprintf(buf, size, "%llu", nsecs / 1000000000);
  60                 return;
  61         }
  62
  63         wallclock_secs = (real_time_ts.tv_sec - boot_time_ts.tv_sec) +
  64                 (real_time_ts.tv_nsec - boot_time_ts.tv_nsec + nsecs) /
  65                 1000000000;
  66
  67
  68         if (!localtime_r(&wallclock_secs, &load_tm)) {
  69                 snprintf(buf, size, "%llu", nsecs / 1000000000);
  70                 return;
  71         }
  72
  73         if (json_output)
  74                 strftime(buf, size, "%s", &load_tm);
  75         else
  76                 strftime(buf, size, "%FT%T%z", &load_tm);
  77 }
  78
  79 static int prog_fd_by_tag(unsigned char *tag)
  80 {
  81         struct bpf_prog_info info = {};
  82         __u32 len = sizeof(info);
  83         unsigned int id = 0;
  84         int err;
  85         int fd;
  86
  87         while (true) {
  88                 err = bpf_prog_get_next_id(id, &id);
  89                 if (err) {
  90                         p_err("%s", strerror(errno));
  91                         return -1;
  92                 }
  93
  94                 fd = bpf_prog_get_fd_by_id(id);
  95                 if (fd < 0) {
  96                         p_err("can't get prog by id (%u): %s",
  97                               id, strerror(errno));
  98                         return -1;
  99                 }
 100
 101                 err = bpf_obj_get_info_by_fd(fd, &info, &len);
 102                 if (err) {
 103                         p_err("can't get prog info (%u): %s",
 104                               id, strerror(errno));
 105                         close(fd);
 106                         return -1;
 107                 }
 108
 109                 if (!memcmp(tag, info.tag, BPF_TAG_SIZE))
 110                         return fd;
 111
 112                 close(fd);
 113         }
 114 }
 115
 116 int prog_parse_fd(int *argc, char ***argv)
 117 {
 118         int fd;
 119
 120         if (is_prefix(**argv, "id")) {
 121                 unsigned int id;
 122                 char *endptr;
 123
 124                 NEXT_ARGP();
 125
 126                 id = strtoul(**argv, &endptr, 0);
 127                 if (*endptr) {
 128                         p_err("can't parse %s as ID", **argv);
 129                         return -1;
 130                 }
 131                 NEXT_ARGP();
 132
 133                 fd = bpf_prog_get_fd_by_id(id);
 134                 if (fd < 0)
 135                         p_err("get by id (%u): %s", id, strerror(errno));
 136                 return fd;
 137         } else if (is_prefix(**argv, "tag")) {
 138                 unsigned char tag[BPF_TAG_SIZE];
 139
 140                 NEXT_ARGP();
 141
 142                 if (sscanf(**argv, BPF_TAG_FMT, tag, tag + 1, tag + 2,
 143                            tag + 3, tag + 4, tag + 5, tag + 6, tag + 7)
 144                     != BPF_TAG_SIZE) {
 145                         p_err("can't parse tag");
 146                         return -1;
 147                 }
 148                 NEXT_ARGP();
 149
 150                 return prog_fd_by_tag(tag);
 151         } else if (is_prefix(**argv, "pinned")) {
 152                 char *path;
 153
 154                 NEXT_ARGP();
 155
 156                 path = **argv;
 157                 NEXT_ARGP();
 158
 159                 return open_obj_pinned_any(path, BPF_OBJ_PROG);
 160         }
 161
 162         p_err("expected 'id', 'tag' or 'pinned', got: '%s'?", **argv);
 163         return -1;
 164 }
 165
 166 static void show_prog_maps(int fd, u32 num_maps)
 167 {
 168         struct bpf_prog_info info = {};
 169         __u32 len = sizeof(info);
 170         __u32 map_ids[num_maps];
 171         unsigned int i;
 172         int err;
 173
 174         info.nr_map_ids = num_maps;
 175         info.map_ids = ptr_to_u64(map_ids);
 176
 177         err = bpf_obj_get_info_by_fd(fd, &info, &len);
 178         if (err || !info.nr_map_ids)
 179                 return;
 180
 181         if (json_output) {
 182                 jsonw_name(json_wtr, "map_ids");
 183                 jsonw_start_array(json_wtr);
 184                 for (i = 0; i < info.nr_map_ids; i++)
 185                         jsonw_uint(json_wtr, map_ids[i]);
 186                 jsonw_end_array(json_wtr);
 187         } else {
 188                 printf("  map_ids ");
 189                 for (i = 0; i < info.nr_map_ids; i++)
 190                         printf("%u%s", map_ids[i],
 191                                i == info.nr_map_ids - 1 ? "" : ",");
 192         }
 193 }
 194
 195 static void print_prog_json(struct bpf_prog_info *info, int fd)
 196 {
 197         char *memlock;
 198
 199         jsonw_start_object(json_wtr);
 200         jsonw_uint_field(json_wtr, "id", info->id);
 201         if (info->type < ARRAY_SIZE(prog_type_name))
 202                 jsonw_string_field(json_wtr, "type",
 203                                    prog_type_name[info->type]);
 204         else
 205                 jsonw_uint_field(json_wtr, "type", info->type);
 206
 207         if (*info->name)
 208                 jsonw_string_field(json_wtr, "name", info->name);
 209
 210         jsonw_name(json_wtr, "tag");
 211         jsonw_printf(json_wtr, "\"" BPF_TAG_FMT "\"",
 212                      info->tag[0], info->tag[1], info->tag[2], info->tag[3],
 213                      info->tag[4], info->tag[5], info->tag[6], info->tag[7]);
 214
 215         jsonw_bool_field(json_wtr, "gpl_compatible", info->gpl_compatible);
 216
 217         print_dev_json(info->ifindex, info->netns_dev, info->netns_ino);
 218
 219         if (info->load_time) {
 220                 char buf[32];
 221
 222                 print_boot_time(info->load_time, buf, sizeof(buf));
 223
 224                 /* Piggy back on load_time, since 0 uid is a valid one */
 225                 jsonw_name(json_wtr, "loaded_at");
 226                 jsonw_printf(json_wtr, "%s", buf);
 227                 jsonw_uint_field(json_wtr, "uid", info->created_by_uid);
 228         }
 229
 230         jsonw_uint_field(json_wtr, "bytes_xlated", info->xlated_prog_len);
 231
 232         if (info->jited_prog_len) {
 233                 jsonw_bool_field(json_wtr, "jited", true);
 234                 jsonw_uint_field(json_wtr, "bytes_jited", info->jited_prog_len);
 235         } else {
 236                 jsonw_bool_field(json_wtr, "jited", false);
 237         }
 238
 239         memlock = get_fdinfo(fd, "memlock");
 240         if (memlock)
 241                 jsonw_int_field(json_wtr, "bytes_memlock", atoi(memlock));
 242         free(memlock);
 243
 244         if (info->nr_map_ids)
 245                 show_prog_maps(fd, info->nr_map_ids);
 246
 247         if (!hash_empty(prog_table.table)) {
 248                 struct pinned_obj *obj;
 249
 250                 jsonw_name(json_wtr, "pinned");
 251                 jsonw_start_array(json_wtr);
 252                 hash_for_each_possible(prog_table.table, obj, hash, info->id) {
 253                         if (obj->id == info->id)
 254                                 jsonw_string(json_wtr, obj->path);
 255                 }
 256                 jsonw_end_array(json_wtr);
 257         }
 258
 259         jsonw_end_object(json_wtr);
 260 }
 261
 262 static void print_prog_plain(struct bpf_prog_info *info, int fd)
 263 {
 264         char *memlock;
 265
 266         printf("%u: ", info->id);
 267         if (info->type < ARRAY_SIZE(prog_type_name))
 268                 printf("%s  ", prog_type_name[info->type]);
 269         else
 270                 printf("type %u  ", info->type);
 271
 272         if (*info->name)
 273                 printf("name %s  ", info->name);
 274
 275         printf("tag ");
 276         fprint_hex(stdout, info->tag, BPF_TAG_SIZE, "");
 277         print_dev_plain(info->ifindex, info->netns_dev, info->netns_ino);
 278         printf("%s", info->gpl_compatible ? "  gpl" : "");
 279         printf("\n");
 280
 281         if (info->load_time) {
 282                 char buf[32];
 283
 284                 print_boot_time(info->load_time, buf, sizeof(buf));
 285
 286                 /* Piggy back on load_time, since 0 uid is a valid one */
 287                 printf("\tloaded_at %s  uid %u\n", buf, info->created_by_uid);
 288         }
 289
 290         printf("\txlated %uB", info->xlated_prog_len);
 291
 292         if (info->jited_prog_len)
 293                 printf("  jited %uB", info->jited_prog_len);
 294         else
 295                 printf("  not jited");
 296
 297         memlock = get_fdinfo(fd, "memlock");
 298         if (memlock)
 299                 printf("  memlock %sB", memlock);
 300         free(memlock);
 301
 302         if (info->nr_map_ids)
 303                 show_prog_maps(fd, info->nr_map_ids);
 304
 305         if (!hash_empty(prog_table.table)) {
 306                 struct pinned_obj *obj;
 307
 308                 hash_for_each_possible(prog_table.table, obj, hash, info->id) {
 309                         if (obj->id == info->id)
 310                                 printf("\n\tpinned %s", obj->path);
 311                 }
 312         }
 313
 314         printf("\n");
 315 }
 316
 317 static int show_prog(int fd)
 318 {
 319         struct bpf_prog_info info = {};
 320         __u32 len = sizeof(info);
 321         int err;
 322
 323         err = bpf_obj_get_info_by_fd(fd, &info, &len);
 324         if (err) {
 325                 p_err("can't get prog info: %s", strerror(errno));
 326                 return -1;
 327         }
 328
 329         if (json_output)
 330                 print_prog_json(&info, fd);
 331         else
 332                 print_prog_plain(&info, fd);
 333
 334         return 0;
 335 }
 336
 337 static int do_show(int argc, char **argv)
 338 {
 339         __u32 id = 0;
 340         int err;
 341         int fd;
 342
 343         if (show_pinned)
 344                 build_pinned_obj_table(&prog_table, BPF_OBJ_PROG);
 345
 346         if (argc == 2) {
 347                 fd = prog_parse_fd(&argc, &argv);
 348                 if (fd < 0)
 349                         return -1;
 350
 351                 return show_prog(fd);
 352         }
 353
 354         if (argc)
 355                 return BAD_ARG();
 356
 357         if (json_output)
 358                 jsonw_start_array(json_wtr);
 359         while (true) {
 360                 err = bpf_prog_get_next_id(id, &id);
 361                 if (err) {
 362                         if (errno == ENOENT) {
 363                                 err = 0;
 364                                 break;
 365                         }
 366                         p_err("can't get next program: %s%s", strerror(errno),
 367                               errno == EINVAL ? " -- kernel too old?" : "");
 368                         err = -1;
 369                         break;
 370                 }
 371
 372                 fd = bpf_prog_get_fd_by_id(id);
 373                 if (fd < 0) {
 374                         if (errno == ENOENT)
 375                                 continue;
 376                         p_err("can't get prog by id (%u): %s",
 377                               id, strerror(errno));
 378                         err = -1;
 379                         break;
 380                 }
 381
 382                 err = show_prog(fd);
 383                 close(fd);
 384                 if (err)
 385                         break;
 386         }
 387
 388         if (json_output)
 389                 jsonw_end_array(json_wtr);
 390
 391         return err;
 392 }
 393
 394 static int do_dump(int argc, char **argv)
 395 {
 396         unsigned int finfo_rec_size, linfo_rec_size, jited_linfo_rec_size;
 397         void *func_info = NULL, *linfo = NULL, *jited_linfo = NULL;
 398         unsigned int nr_finfo, nr_linfo = 0, nr_jited_linfo = 0;
 399         struct bpf_prog_linfo *prog_linfo = NULL;
 400         unsigned long *func_ksyms = NULL;
 401         struct bpf_prog_info info = {};
 402         unsigned int *func_lens = NULL;
 403         const char *disasm_opt = NULL;
 404         unsigned int nr_func_ksyms;
 405         unsigned int nr_func_lens;
 406         struct dump_data dd = {};
 407         __u32 len = sizeof(info);
 408         struct btf *btf = NULL;
 409         unsigned int buf_size;
 410         char *filepath = NULL;
 411         bool opcodes = false;
 412         bool visual = false;
 413         char func_sig[1024];
 414         unsigned char *buf;
 415         bool linum = false;
 416         __u32 *member_len;
 417         __u64 *member_ptr;
 418         ssize_t n;
 419         int err;
 420         int fd;
 421
 422         if (is_prefix(*argv, "jited")) {
 423                 if (disasm_init())
 424                         return -1;
 425
 426                 member_len = &info.jited_prog_len;
 427                 member_ptr = &info.jited_prog_insns;
 428         } else if (is_prefix(*argv, "xlated")) {
 429                 member_len = &info.xlated_prog_len;
 430                 member_ptr = &info.xlated_prog_insns;
 431         } else {
 432                 p_err("expected 'xlated' or 'jited', got: %s", *argv);
 433                 return -1;
 434         }
 435         NEXT_ARG();
 436
 437         if (argc < 2)
 438                 usage();
 439
 440         fd = prog_parse_fd(&argc, &argv);
 441         if (fd < 0)
 442                 return -1;
 443
 444         if (is_prefix(*argv, "file")) {
 445                 NEXT_ARG();
 446                 if (!argc) {
 447                         p_err("expected file path");
 448                         return -1;
 449                 }
 450
 451                 filepath = *argv;
 452                 NEXT_ARG();
 453         } else if (is_prefix(*argv, "opcodes")) {
 454                 opcodes = true;
 455                 NEXT_ARG();
 456         } else if (is_prefix(*argv, "visual")) {
 457                 visual = true;
 458                 NEXT_ARG();
 459         } else if (is_prefix(*argv, "linum")) {
 460                 linum = true;
 461                 NEXT_ARG();
 462         }
 463
 464         if (argc) {
 465                 usage();
 466                 return -1;
 467         }
 468
 469         err = bpf_obj_get_info_by_fd(fd, &info, &len);
 470         if (err) {
 471                 p_err("can't get prog info: %s", strerror(errno));
 472                 return -1;
 473         }
 474
 475         if (!*member_len) {
 476                 p_info("no instructions returned");
 477                 close(fd);
 478                 return 0;
 479         }
 480
 481         buf_size = *member_len;
 482
 483         buf = malloc(buf_size);
 484         if (!buf) {
 485                 p_err("mem alloc failed");
 486                 close(fd);
 487                 return -1;
 488         }
 489
 490         nr_func_ksyms = info.nr_jited_ksyms;
 491         if (nr_func_ksyms) {
 492                 func_ksyms = malloc(nr_func_ksyms * sizeof(__u64));
 493                 if (!func_ksyms) {
 494                         p_err("mem alloc failed");
 495                         close(fd);
 496                         goto err_free;
 497                 }
 498         }
 499
 500         nr_func_lens = info.nr_jited_func_lens;
 501         if (nr_func_lens) {
 502                 func_lens = malloc(nr_func_lens * sizeof(__u32));
 503                 if (!func_lens) {
 504                         p_err("mem alloc failed");
 505                         close(fd);
 506                         goto err_free;
 507                 }
 508         }
 509
 510         nr_finfo = info.nr_func_info;
 511         finfo_rec_size = info.func_info_rec_size;
 512         if (nr_finfo && finfo_rec_size) {
 513                 func_info = malloc(nr_finfo * finfo_rec_size);
 514                 if (!func_info) {
 515                         p_err("mem alloc failed");
 516                         close(fd);
 517                         goto err_free;
 518                 }
 519         }
 520
 521         linfo_rec_size = info.line_info_rec_size;
 522         if (info.nr_line_info && linfo_rec_size && info.btf_id) {
 523                 nr_linfo = info.nr_line_info;
 524                 linfo = malloc(nr_linfo * linfo_rec_size);
 525                 if (!linfo) {
 526                         p_err("mem alloc failed");
 527                         close(fd);
 528                         goto err_free;
 529                 }
 530         }
 531
 532         jited_linfo_rec_size = info.jited_line_info_rec_size;
 533         if (info.nr_jited_line_info &&
 534             jited_linfo_rec_size &&
 535             info.nr_jited_ksyms &&
 536             info.nr_jited_func_lens &&
 537             info.btf_id) {
 538                 nr_jited_linfo = info.nr_jited_line_info;
 539                 jited_linfo = malloc(nr_jited_linfo * jited_linfo_rec_size);
 540                 if (!jited_linfo) {
 541                         p_err("mem alloc failed");
 542                         close(fd);
 543                         goto err_free;
 544                 }
 545         }
 546
 547         memset(&info, 0, sizeof(info));
 548
 549         *member_ptr = ptr_to_u64(buf);
 550         *member_len = buf_size;
 551         info.jited_ksyms = ptr_to_u64(func_ksyms);
 552         info.nr_jited_ksyms = nr_func_ksyms;
 553         info.jited_func_lens = ptr_to_u64(func_lens);
 554         info.nr_jited_func_lens = nr_func_lens;
 555         info.nr_func_info = nr_finfo;
 556         info.func_info_rec_size = finfo_rec_size;
 557         info.func_info = ptr_to_u64(func_info);
 558         info.nr_line_info = nr_linfo;
 559         info.line_info_rec_size = linfo_rec_size;
 560         info.line_info = ptr_to_u64(linfo);
 561         info.nr_jited_line_info = nr_jited_linfo;
 562         info.jited_line_info_rec_size = jited_linfo_rec_size;
 563         info.jited_line_info = ptr_to_u64(jited_linfo);
 564
 565         err = bpf_obj_get_info_by_fd(fd, &info, &len);
 566         close(fd);
 567         if (err) {
 568                 p_err("can't get prog info: %s", strerror(errno));
 569                 goto err_free;
 570         }
 571
 572         if (*member_len > buf_size) {
 573                 p_err("too many instructions returned");
 574                 goto err_free;
 575         }
 576
 577         if (info.nr_jited_ksyms > nr_func_ksyms) {
 578                 p_err("too many addresses returned");
 579                 goto err_free;
 580         }
 581
 582         if (info.nr_jited_func_lens > nr_func_lens) {
 583                 p_err("too many values returned");
 584                 goto err_free;
 585         }
 586
 587         if (info.nr_func_info != nr_finfo) {
 588                 p_err("incorrect nr_func_info %d vs. expected %d",
 589                       info.nr_func_info, nr_finfo);
 590                 goto err_free;
 591         }
 592
 593         if (info.func_info_rec_size != finfo_rec_size) {
 594                 p_err("incorrect func_info_rec_size %d vs. expected %d",
 595                       info.func_info_rec_size, finfo_rec_size);
 596                 goto err_free;
 597         }
 598
 599         if (linfo && info.nr_line_info != nr_linfo) {
 600                 p_err("incorrect nr_line_info %u vs. expected %u",
 601                       info.nr_line_info, nr_linfo);
 602                 goto err_free;
 603         }
 604
 605         if (info.line_info_rec_size != linfo_rec_size) {
 606                 p_err("incorrect line_info_rec_size %u vs. expected %u",
 607                       info.line_info_rec_size, linfo_rec_size);
 608                 goto err_free;
 609         }
 610
 611         if (jited_linfo && info.nr_jited_line_info != nr_jited_linfo) {
 612                 p_err("incorrect nr_jited_line_info %u vs. expected %u",
 613                       info.nr_jited_line_info, nr_jited_linfo);
 614                 goto err_free;
 615         }
 616
 617         if (info.jited_line_info_rec_size != jited_linfo_rec_size) {
 618                 p_err("incorrect jited_line_info_rec_size %u vs. expected %u",
 619                       info.jited_line_info_rec_size, jited_linfo_rec_size);
 620                 goto err_free;
 621         }
 622
 623         if ((member_len == &info.jited_prog_len &&
 624              info.jited_prog_insns == 0) ||
 625             (member_len == &info.xlated_prog_len &&
 626              info.xlated_prog_insns == 0)) {
 627                 p_err("error retrieving insn dump: kernel.kptr_restrict set?");
 628                 goto err_free;
 629         }
 630
 631         if (info.btf_id && btf__get_from_id(info.btf_id, &btf)) {
 632                 p_err("failed to get btf");
 633                 goto err_free;
 634         }
 635
 636         if (nr_linfo) {
 637                 prog_linfo = bpf_prog_linfo__new(&info);
 638                 if (!prog_linfo)
 639                         p_info("error in processing bpf_line_info.  continue without it.");
 640         }
 641
 642         if (filepath) {
 643                 fd = open(filepath, O_WRONLY | O_CREAT | O_TRUNC, 0600);
 644                 if (fd < 0) {
 645                         p_err("can't open file %s: %s", filepath,
 646                               strerror(errno));
 647                         goto err_free;
 648                 }
 649
 650                 n = write(fd, buf, *member_len);
 651                 close(fd);
 652                 if (n != *member_len) {
 653                         p_err("error writing output file: %s",
 654                               n < 0 ? strerror(errno) : "short write");
 655                         goto err_free;
 656                 }
 657
 658                 if (json_output)
 659                         jsonw_null(json_wtr);
 660         } else if (member_len == &info.jited_prog_len) {
 661                 const char *name = NULL;
 662
 663                 if (info.ifindex) {
 664                         name = ifindex_to_bfd_params(info.ifindex,
 665                                                      info.netns_dev,
 666                                                      info.netns_ino,
 667                                                      &disasm_opt);
 668                         if (!name)
 669                                 goto err_free;
 670                 }
 671
 672                 if (info.nr_jited_func_lens && info.jited_func_lens) {
 673                         struct kernel_sym *sym = NULL;
 674                         struct bpf_func_info *record;
 675                         char sym_name[SYM_MAX_NAME];
 676                         unsigned char *img = buf;
 677                         __u64 *ksyms = NULL;
 678                         __u32 *lens;
 679                         __u32 i;
 680
 681                         if (info.nr_jited_ksyms) {
 682                                 kernel_syms_load(&dd);
 683                                 ksyms = (__u64 *) info.jited_ksyms;
 684                         }
 685
 686                         if (json_output)
 687                                 jsonw_start_array(json_wtr);
 688
 689                         lens = (__u32 *) info.jited_func_lens;
 690                         for (i = 0; i < info.nr_jited_func_lens; i++) {
 691                                 if (ksyms) {
 692                                         sym = kernel_syms_search(&dd, ksyms[i]);
 693                                         if (sym)
 694                                                 sprintf(sym_name, "%s", sym->name);
 695                                         else
 696                                                 sprintf(sym_name, "0x%016llx", ksyms[i]);
 697                                 } else {
 698                                         strcpy(sym_name, "unknown");
 699                                 }
 700
 701                                 if (func_info) {
 702                                         record = func_info + i * finfo_rec_size;
 703                                         btf_dumper_type_only(btf, record->type_id,
 704                                                              func_sig,
 705                                                              sizeof(func_sig));
 706                                 }
 707
 708                                 if (json_output) {
 709                                         jsonw_start_object(json_wtr);
 710                                         if (func_info && func_sig[0] != '\0') {
 711                                                 jsonw_name(json_wtr, "proto");
 712                                                 jsonw_string(json_wtr, func_sig);
 713                                         }
 714                                         jsonw_name(json_wtr, "name");
 715                                         jsonw_string(json_wtr, sym_name);
 716                                         jsonw_name(json_wtr, "insns");
 717                                 } else {
 718                                         if (func_info && func_sig[0] != '\0')
 719                                                 printf("%s:\n", func_sig);
 720                                         printf("%s:\n", sym_name);
 721                                 }
 722
 723                                 disasm_print_insn(img, lens[i], opcodes,
 724                                                   name, disasm_opt, btf,
 725                                                   prog_linfo, ksyms[i], i,
 726                                                   linum);
 727
 728                                 img += lens[i];
 729
 730                                 if (json_output)
 731                                         jsonw_end_object(json_wtr);
 732                                 else
 733                                         printf("\n");
 734                         }
 735
 736                         if (json_output)
 737                                 jsonw_end_array(json_wtr);
 738                 } else {
 739                         disasm_print_insn(buf, *member_len, opcodes, name,
 740                                           disasm_opt, btf, NULL, 0, 0, false);
 741                 }
 742         } else if (visual) {
 743                 if (json_output)
 744                         jsonw_null(json_wtr);
 745                 else
 746                         dump_xlated_cfg(buf, *member_len);
 747         } else {
 748                 kernel_syms_load(&dd);
 749                 dd.nr_jited_ksyms = info.nr_jited_ksyms;
 750                 dd.jited_ksyms = (__u64 *) info.jited_ksyms;
 751                 dd.btf = btf;
 752                 dd.func_info = func_info;
 753                 dd.finfo_rec_size = finfo_rec_size;
 754                 dd.prog_linfo = prog_linfo;
 755
 756                 if (json_output)
 757                         dump_xlated_json(&dd, buf, *member_len, opcodes,
 758                                          linum);
 759                 else
 760                         dump_xlated_plain(&dd, buf, *member_len, opcodes,
 761                                           linum);
 762                 kernel_syms_destroy(&dd);
 763         }
 764
 765         free(buf);
 766         free(func_ksyms);
 767         free(func_lens);
 768         free(func_info);
 769         free(linfo);
 770         free(jited_linfo);
 771         bpf_prog_linfo__free(prog_linfo);
 772         return 0;
 773
 774 err_free:
 775         free(buf);
 776         free(func_ksyms);
 777         free(func_lens);
 778         free(func_info);
 779         free(linfo);
 780         free(jited_linfo);
 781         bpf_prog_linfo__free(prog_linfo);
 782         return -1;
 783 }
 784
 785 static int do_pin(int argc, char **argv)
 786 {
 787         int err;
 788
 789         err = do_pin_any(argc, argv, bpf_prog_get_fd_by_id);
 790         if (!err && json_output)
 791                 jsonw_null(json_wtr);
 792         return err;
 793 }
 794
 795 struct map_replace {
 796         int idx;
 797         int fd;
 798         char *name;
 799 };
 800
 801 static int map_replace_compar(const void *p1, const void *p2)
 802 {
 803         const struct map_replace *a = p1, *b = p2;
 804
 805         return a->idx - b->idx;
 806 }
 807
 808 static int parse_attach_detach_args(int argc, char **argv, int *progfd,
 809                                     enum bpf_attach_type *attach_type,
 810                                     int *mapfd)
 811 {
 812         if (!REQ_ARGS(3))
 813                 return -EINVAL;
 814
 815         *progfd = prog_parse_fd(&argc, &argv);
 816         if (*progfd < 0)
 817                 return *progfd;
 818
 819         *attach_type = parse_attach_type(*argv);
 820         if (*attach_type == __MAX_BPF_ATTACH_TYPE) {
 821                 p_err("invalid attach/detach type");
 822                 return -EINVAL;
 823         }
 824
 825         if (*attach_type == BPF_FLOW_DISSECTOR) {
 826                 *mapfd = -1;
 827                 return 0;
 828         }
 829
 830         NEXT_ARG();
 831         if (!REQ_ARGS(2))
 832                 return -EINVAL;
 833
 834         *mapfd = map_parse_fd(&argc, &argv);
 835         if (*mapfd < 0)
 836                 return *mapfd;
 837
 838         return 0;
 839 }
 840
 841 static int do_attach(int argc, char **argv)
 842 {
 843         enum bpf_attach_type attach_type;
 844         int err, progfd;
 845         int mapfd;
 846
 847         err = parse_attach_detach_args(argc, argv,
 848                                        &progfd, &attach_type, &mapfd);
 849         if (err)
 850                 return err;
 851
 852         err = bpf_prog_attach(progfd, mapfd, attach_type, 0);
 853         if (err) {
 854                 p_err("failed prog attach to map");
 855                 return -EINVAL;
 856         }
 857
 858         if (json_output)
 859                 jsonw_null(json_wtr);
 860         return 0;
 861 }
 862
 863 static int do_detach(int argc, char **argv)
 864 {
 865         enum bpf_attach_type attach_type;
 866         int err, progfd;
 867         int mapfd;
 868
 869         err = parse_attach_detach_args(argc, argv,
 870                                        &progfd, &attach_type, &mapfd);
 871         if (err)
 872                 return err;
 873
 874         err = bpf_prog_detach2(progfd, mapfd, attach_type);
 875         if (err) {
 876                 p_err("failed prog detach from map");
 877                 return -EINVAL;
 878         }
 879
 880         if (json_output)
 881                 jsonw_null(json_wtr);
 882         return 0;
 883 }
 884
 885 static int load_with_options(int argc, char **argv, bool first_prog_only)
 886 {
 887         enum bpf_attach_type expected_attach_type;
 888         struct bpf_object_open_attr attr = {
 889                 .prog_type      = BPF_PROG_TYPE_UNSPEC,
 890         };
 891         struct map_replace *map_replace = NULL;
 892         struct bpf_program *prog = NULL, *pos;
 893         unsigned int old_map_fds = 0;
 894         const char *pinmaps = NULL;
 895         struct bpf_object *obj;
 896         struct bpf_map *map;
 897         const char *pinfile;
 898         unsigned int i, j;
 899         __u32 ifindex = 0;
 900         int idx, err;
 901
 902         if (!REQ_ARGS(2))
 903                 return -1;
 904         attr.file = GET_ARG();
 905         pinfile = GET_ARG();
 906
 907         while (argc) {
 908                 if (is_prefix(*argv, "type")) {
 909                         char *type;
 910
 911                         NEXT_ARG();
 912
 913                         if (attr.prog_type != BPF_PROG_TYPE_UNSPEC) {
 914                                 p_err("program type already specified");
 915                                 goto err_free_reuse_maps;
 916                         }
 917                         if (!REQ_ARGS(1))
 918                                 goto err_free_reuse_maps;
 919
 920                         /* Put a '/' at the end of type to appease libbpf */
 921                         type = malloc(strlen(*argv) + 2);
 922                         if (!type) {
 923                                 p_err("mem alloc failed");
 924                                 goto err_free_reuse_maps;
 925                         }
 926                         *type = 0;
 927                         strcat(type, *argv);
 928                         strcat(type, "/");
 929
 930                         err = libbpf_prog_type_by_name(type, &attr.prog_type,
 931                                                        &expected_attach_type);
 932                         free(type);
 933                         if (err < 0) {
 934                                 p_err("unknown program type '%s'", *argv);
 935                                 goto err_free_reuse_maps;
 936                         }
 937                         NEXT_ARG();
 938                 } else if (is_prefix(*argv, "map")) {
 939                         void *new_map_replace;
 940                         char *endptr, *name;
 941                         int fd;
 942
 943                         NEXT_ARG();
 944
 945                         if (!REQ_ARGS(4))
 946                                 goto err_free_reuse_maps;
 947
 948                         if (is_prefix(*argv, "idx")) {
 949                                 NEXT_ARG();
 950
 951                                 idx = strtoul(*argv, &endptr, 0);
 952                                 if (*endptr) {
 953                                         p_err("can't parse %s as IDX", *argv);
 954                                         goto err_free_reuse_maps;
 955                                 }
 956                                 name = NULL;
 957                         } else if (is_prefix(*argv, "name")) {
 958                                 NEXT_ARG();
 959
 960                                 name = *argv;
 961                                 idx = -1;
 962                         } else {
 963                                 p_err("expected 'idx' or 'name', got: '%s'?",
 964                                       *argv);
 965                                 goto err_free_reuse_maps;
 966                         }
 967                         NEXT_ARG();
 968
 969                         fd = map_parse_fd(&argc, &argv);
 970                         if (fd < 0)
 971                                 goto err_free_reuse_maps;
 972
 973                         new_map_replace = reallocarray(map_replace,
 974                                                        old_map_fds + 1,
 975                                                        sizeof(*map_replace));
 976                         if (!new_map_replace) {
 977                                 p_err("mem alloc failed");
 978                                 goto err_free_reuse_maps;
 979                         }
 980                         map_replace = new_map_replace;
 981
 982                         map_replace[old_map_fds].idx = idx;
 983                         map_replace[old_map_fds].name = name;
 984                         map_replace[old_map_fds].fd = fd;
 985                         old_map_fds++;
 986                 } else if (is_prefix(*argv, "dev")) {
 987                         NEXT_ARG();
 988
 989                         if (ifindex) {
 990                                 p_err("offload device already specified");
 991                                 goto err_free_reuse_maps;
 992                         }
 993                         if (!REQ_ARGS(1))
 994                                 goto err_free_reuse_maps;
 995
 996                         ifindex = if_nametoindex(*argv);
 997                         if (!ifindex) {
 998                                 p_err("unrecognized netdevice '%s': %s",
 999                                       *argv, strerror(errno));
1000                                 goto err_free_reuse_maps;
1001                         }
1002                         NEXT_ARG();
1003                 } else if (is_prefix(*argv, "pinmaps")) {
1004                         NEXT_ARG();
1005
1006                         if (!REQ_ARGS(1))
1007                                 goto err_free_reuse_maps;
1008
1009                         pinmaps = GET_ARG();
1010                 } else {
1011                         p_err("expected no more arguments, 'type', 'map' or 'dev', got: '%s'?",
1012                               *argv);
1013                         goto err_free_reuse_maps;
1014                 }
1015         }
1016
1017         obj = __bpf_object__open_xattr(&attr, bpf_flags);
1018         if (IS_ERR_OR_NULL(obj)) {
1019                 p_err("failed to open object file");
1020                 goto err_free_reuse_maps;
1021         }
1022
1023         bpf_object__for_each_program(pos, obj) {
1024                 enum bpf_prog_type prog_type = attr.prog_type;
1025
1026                 if (attr.prog_type == BPF_PROG_TYPE_UNSPEC) {
1027                         const char *sec_name = bpf_program__title(pos, false);
1028
1029                         err = libbpf_prog_type_by_name(sec_name, &prog_type,
1030                                                        &expected_attach_type);
1031                         if (err < 0) {
1032                                 p_err("failed to guess program type based on section name %s\n",
1033                                       sec_name);
1034                                 goto err_close_obj;
1035                         }
1036                 }
1037
1038                 bpf_program__set_ifindex(pos, ifindex);
1039                 bpf_program__set_type(pos, prog_type);
1040                 bpf_program__set_expected_attach_type(pos, expected_attach_type);
1041         }
1042
1043         qsort(map_replace, old_map_fds, sizeof(*map_replace),
1044               map_replace_compar);
1045
1046         /* After the sort maps by name will be first on the list, because they
1047          * have idx == -1.  Resolve them.
1048          */
1049         j = 0;
1050         while (j < old_map_fds && map_replace[j].name) {
1051                 i = 0;
1052                 bpf_map__for_each(map, obj) {
1053                         if (!strcmp(bpf_map__name(map), map_replace[j].name)) {
1054                                 map_replace[j].idx = i;
1055                                 break;
1056                         }
1057                         i++;
1058                 }
1059                 if (map_replace[j].idx == -1) {
1060                         p_err("unable to find map '%s'", map_replace[j].name);
1061                         goto err_close_obj;
1062                 }
1063                 j++;
1064         }
1065         /* Resort if any names were resolved */
1066         if (j)
1067                 qsort(map_replace, old_map_fds, sizeof(*map_replace),
1068                       map_replace_compar);
1069
1070         /* Set ifindex and name reuse */
1071         j = 0;
1072         idx = 0;
1073         bpf_map__for_each(map, obj) {
1074                 if (!bpf_map__is_offload_neutral(map))
1075                         bpf_map__set_ifindex(map, ifindex);
1076
1077                 if (j < old_map_fds && idx == map_replace[j].idx) {
1078                         err = bpf_map__reuse_fd(map, map_replace[j++].fd);
1079                         if (err) {
1080                                 p_err("unable to set up map reuse: %d", err);
1081                                 goto err_close_obj;
1082                         }
1083
1084                         /* Next reuse wants to apply to the same map */
1085                         if (j < old_map_fds && map_replace[j].idx == idx) {
1086                                 p_err("replacement for map idx %d specified more than once",
1087                                       idx);
1088                                 goto err_close_obj;
1089                         }
1090                 }
1091
1092                 idx++;
1093         }
1094         if (j < old_map_fds) {
1095                 p_err("map idx '%d' not used", map_replace[j].idx);
1096                 goto err_close_obj;
1097         }
1098
1099         set_max_rlimit();
1100
1101         err = bpf_object__load(obj);
1102         if (err) {
1103                 p_err("failed to load object file");
1104                 goto err_close_obj;
1105         }
1106
1107         err = mount_bpffs_for_pin(pinfile);
1108         if (err)
1109                 goto err_close_obj;
1110
1111         if (first_prog_only) {
1112                 prog = bpf_program__next(NULL, obj);
1113                 if (!prog) {
1114                         p_err("object file doesn't contain any bpf program");
1115                         goto err_close_obj;
1116                 }
1117
1118                 err = bpf_obj_pin(bpf_program__fd(prog), pinfile);
1119                 if (err) {
1120                         p_err("failed to pin program %s",
1121                               bpf_program__title(prog, false));
1122                         goto err_close_obj;
1123                 }
1124         } else {
1125                 err = bpf_object__pin_programs(obj, pinfile);
1126                 if (err) {
1127                         p_err("failed to pin all programs");
1128                         goto err_close_obj;
1129                 }
1130         }
1131
1132         if (pinmaps) {
1133                 err = bpf_object__pin_maps(obj, pinmaps);
1134                 if (err) {
1135                         p_err("failed to pin all maps");
1136                         goto err_unpin;
1137                 }
1138         }
1139
1140         if (json_output)
1141                 jsonw_null(json_wtr);
1142
1143         bpf_object__close(obj);
1144         for (i = 0; i < old_map_fds; i++)
1145                 close(map_replace[i].fd);
1146         free(map_replace);
1147
1148         return 0;
1149
1150 err_unpin:
1151         if (first_prog_only)
1152                 unlink(pinfile);
1153         else
1154                 bpf_object__unpin_programs(obj, pinfile);
1155 err_close_obj:
1156         bpf_object__close(obj);
1157 err_free_reuse_maps:
1158         for (i = 0; i < old_map_fds; i++)
1159                 close(map_replace[i].fd);
1160         free(map_replace);
1161         return -1;
1162 }
1163
1164 static int do_load(int argc, char **argv)
1165 {
1166         return load_with_options(argc, argv, true);
1167 }
1168
1169 static int do_loadall(int argc, char **argv)
1170 {
1171         return load_with_options(argc, argv, false);
1172 }
1173
1174 static int do_help(int argc, char **argv)
1175 {
1176         if (json_output) {
1177                 jsonw_null(json_wtr);
1178                 return 0;
1179         }
1180
1181         fprintf(stderr,
1182                 "Usage: %s %s { show | list } [PROG]\n"
1183                 "       %s %s dump xlated PROG [{ file FILE | opcodes | visual | linum }]\n"
1184                 "       %s %s dump jited  PROG [{ file FILE | opcodes | linum }]\n"
1185                 "       %s %s pin   PROG FILE\n"
1186                 "       %s %s { load | loadall } OBJ  PATH \\\n"
1187                 "                         [type TYPE] [dev NAME] \\\n"
1188                 "                         [map { idx IDX | name NAME } MAP]\\\n"
1189                 "                         [pinmaps MAP_DIR]\n"
1190                 "       %s %s attach PROG ATTACH_TYPE [MAP]\n"
1191                 "       %s %s detach PROG ATTACH_TYPE [MAP]\n"
1192                 "       %s %s tracelog\n"
1193                 "       %s %s help\n"
1194                 "\n"
1195                 "       " HELP_SPEC_MAP "\n"
1196                 "       " HELP_SPEC_PROGRAM "\n"
1197                 "       TYPE := { socket | kprobe | kretprobe | classifier | action |\n"
1198                 "                 tracepoint | raw_tracepoint | xdp | perf_event | cgroup/skb |\n"
1199                 "                 cgroup/sock | cgroup/dev | lwt_in | lwt_out | lwt_xmit |\n"
1200                 "                 lwt_seg6local | sockops | sk_skb | sk_msg | lirc_mode2 |\n"
1201                 "                 sk_reuseport | flow_dissector |\n"
1202                 "                 cgroup/bind4 | cgroup/bind6 | cgroup/post_bind4 |\n"
1203                 "                 cgroup/post_bind6 | cgroup/connect4 | cgroup/connect6 |\n"
1204                 "                 cgroup/sendmsg4 | cgroup/sendmsg6 }\n"
1205                 "       ATTACH_TYPE := { msg_verdict | skb_verdict | skb_parse |\n"
1206                 "                        flow_dissector }\n"
1207                 "       " HELP_SPEC_OPTIONS "\n"
1208                 "",
1209                 bin_name, argv[-2], bin_name, argv[-2], bin_name, argv[-2],
1210                 bin_name, argv[-2], bin_name, argv[-2], bin_name, argv[-2],
1211                 bin_name, argv[-2], bin_name, argv[-2], bin_name, argv[-2]);
1212
1213         return 0;
1214 }
1215
1216 static const struct cmd cmds[] = {
1217         { "show",       do_show },
1218         { "list",       do_show },
1219         { "help",       do_help },
1220         { "dump",       do_dump },
1221         { "pin",        do_pin },
1222         { "load",       do_load },
1223         { "loadall",    do_loadall },
1224         { "attach",     do_attach },
1225         { "detach",     do_detach },
1226         { "tracelog",   do_tracelog },
1227         { 0 }
1228 };
1229
1230 int do_prog(int argc, char **argv)
1231 {
1232         return cmd_select(cmds, argc, argv, do_help);
1233 }