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 <signal.h>
   8 #include <stdarg.h>
   9 #include <stdio.h>
  10 #include <stdlib.h>
  11 #include <string.h>
  12 #include <time.h>
  13 #include <unistd.h>
  14 #include <net/if.h>
  15 #include <sys/ioctl.h>
  16 #include <sys/types.h>
  17 #include <sys/stat.h>
  18 #include <sys/syscall.h>
  19
  20 #include <linux/err.h>
  21 #include <linux/perf_event.h>
  22 #include <linux/sizes.h>
  23
  24 #include <bpf/bpf.h>
  25 #include <bpf/btf.h>
  26 #include <bpf/libbpf.h>
  27
  28 #include "cfg.h"
  29 #include "main.h"
  30 #include "xlated_dumper.h"
  31
  32 const char * const prog_type_name[] = {
  33         [BPF_PROG_TYPE_UNSPEC]                  = "unspec",
  34         [BPF_PROG_TYPE_SOCKET_FILTER]           = "socket_filter",
  35         [BPF_PROG_TYPE_KPROBE]                  = "kprobe",
  36         [BPF_PROG_TYPE_SCHED_CLS]               = "sched_cls",
  37         [BPF_PROG_TYPE_SCHED_ACT]               = "sched_act",
  38         [BPF_PROG_TYPE_TRACEPOINT]              = "tracepoint",
  39         [BPF_PROG_TYPE_XDP]                     = "xdp",
  40         [BPF_PROG_TYPE_PERF_EVENT]              = "perf_event",
  41         [BPF_PROG_TYPE_CGROUP_SKB]              = "cgroup_skb",
  42         [BPF_PROG_TYPE_CGROUP_SOCK]             = "cgroup_sock",
  43         [BPF_PROG_TYPE_LWT_IN]                  = "lwt_in",
  44         [BPF_PROG_TYPE_LWT_OUT]                 = "lwt_out",
  45         [BPF_PROG_TYPE_LWT_XMIT]                = "lwt_xmit",
  46         [BPF_PROG_TYPE_SOCK_OPS]                = "sock_ops",
  47         [BPF_PROG_TYPE_SK_SKB]                  = "sk_skb",
  48         [BPF_PROG_TYPE_CGROUP_DEVICE]           = "cgroup_device",
  49         [BPF_PROG_TYPE_SK_MSG]                  = "sk_msg",
  50         [BPF_PROG_TYPE_RAW_TRACEPOINT]          = "raw_tracepoint",
  51         [BPF_PROG_TYPE_CGROUP_SOCK_ADDR]        = "cgroup_sock_addr",
  52         [BPF_PROG_TYPE_LWT_SEG6LOCAL]           = "lwt_seg6local",
  53         [BPF_PROG_TYPE_LIRC_MODE2]              = "lirc_mode2",
  54         [BPF_PROG_TYPE_SK_REUSEPORT]            = "sk_reuseport",
  55         [BPF_PROG_TYPE_FLOW_DISSECTOR]          = "flow_dissector",
  56         [BPF_PROG_TYPE_CGROUP_SYSCTL]           = "cgroup_sysctl",
  57         [BPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLE] = "raw_tracepoint_writable",
  58         [BPF_PROG_TYPE_CGROUP_SOCKOPT]          = "cgroup_sockopt",
  59         [BPF_PROG_TYPE_TRACING]                 = "tracing",
  60         [BPF_PROG_TYPE_STRUCT_OPS]              = "struct_ops",
  61         [BPF_PROG_TYPE_EXT]                     = "ext",
  62         [BPF_PROG_TYPE_LSM]                     = "lsm",
  63         [BPF_PROG_TYPE_SK_LOOKUP]               = "sk_lookup",
  64 };
  65
  66 const size_t prog_type_name_size = ARRAY_SIZE(prog_type_name);
  67
  68 enum dump_mode {
  69         DUMP_JITED,
  70         DUMP_XLATED,
  71 };
  72
  73 static const char * const attach_type_strings[] = {
  74         [BPF_SK_SKB_STREAM_PARSER] = "stream_parser",
  75         [BPF_SK_SKB_STREAM_VERDICT] = "stream_verdict",
  76         [BPF_SK_MSG_VERDICT] = "msg_verdict",
  77         [BPF_FLOW_DISSECTOR] = "flow_dissector",
  78         [__MAX_BPF_ATTACH_TYPE] = NULL,
  79 };
  80
  81 static enum bpf_attach_type parse_attach_type(const char *str)
  82 {
  83         enum bpf_attach_type type;
  84
  85         for (type = 0; type < __MAX_BPF_ATTACH_TYPE; type++) {
  86                 if (attach_type_strings[type] &&
  87                     is_prefix(str, attach_type_strings[type]))
  88                         return type;
  89         }
  90
  91         return __MAX_BPF_ATTACH_TYPE;
  92 }
  93
  94 static void print_boot_time(__u64 nsecs, char *buf, unsigned int size)
  95 {
  96         struct timespec real_time_ts, boot_time_ts;
  97         time_t wallclock_secs;
  98         struct tm load_tm;
  99
 100         buf[--size] = '\0';
 101
 102         if (clock_gettime(CLOCK_REALTIME, &real_time_ts) ||
 103             clock_gettime(CLOCK_BOOTTIME, &boot_time_ts)) {
 104                 perror("Can't read clocks");
 105                 snprintf(buf, size, "%llu", nsecs / 1000000000);
 106                 return;
 107         }
 108
 109         wallclock_secs = (real_time_ts.tv_sec - boot_time_ts.tv_sec) +
 110                 (real_time_ts.tv_nsec - boot_time_ts.tv_nsec + nsecs) /
 111                 1000000000;
 112
 113
 114         if (!localtime_r(&wallclock_secs, &load_tm)) {
 115                 snprintf(buf, size, "%llu", nsecs / 1000000000);
 116                 return;
 117         }
 118
 119         if (json_output)
 120                 strftime(buf, size, "%s", &load_tm);
 121         else
 122                 strftime(buf, size, "%FT%T%z", &load_tm);
 123 }
 124
 125 static void show_prog_maps(int fd, __u32 num_maps)
 126 {
 127         struct bpf_prog_info info = {};
 128         __u32 len = sizeof(info);
 129         __u32 map_ids[num_maps];
 130         unsigned int i;
 131         int err;
 132
 133         info.nr_map_ids = num_maps;
 134         info.map_ids = ptr_to_u64(map_ids);
 135
 136         err = bpf_obj_get_info_by_fd(fd, &info, &len);
 137         if (err || !info.nr_map_ids)
 138                 return;
 139
 140         if (json_output) {
 141                 jsonw_name(json_wtr, "map_ids");
 142                 jsonw_start_array(json_wtr);
 143                 for (i = 0; i < info.nr_map_ids; i++)
 144                         jsonw_uint(json_wtr, map_ids[i]);
 145                 jsonw_end_array(json_wtr);
 146         } else {
 147                 printf("  map_ids ");
 148                 for (i = 0; i < info.nr_map_ids; i++)
 149                         printf("%u%s", map_ids[i],
 150                                i == info.nr_map_ids - 1 ? "" : ",");
 151         }
 152 }
 153
 154 static void print_prog_header_json(struct bpf_prog_info *info)
 155 {
 156         jsonw_uint_field(json_wtr, "id", info->id);
 157         if (info->type < ARRAY_SIZE(prog_type_name))
 158                 jsonw_string_field(json_wtr, "type",
 159                                    prog_type_name[info->type]);
 160         else
 161                 jsonw_uint_field(json_wtr, "type", info->type);
 162
 163         if (*info->name)
 164                 jsonw_string_field(json_wtr, "name", info->name);
 165
 166         jsonw_name(json_wtr, "tag");
 167         jsonw_printf(json_wtr, "\"" BPF_TAG_FMT "\"",
 168                      info->tag[0], info->tag[1], info->tag[2], info->tag[3],
 169                      info->tag[4], info->tag[5], info->tag[6], info->tag[7]);
 170
 171         jsonw_bool_field(json_wtr, "gpl_compatible", info->gpl_compatible);
 172         if (info->run_time_ns) {
 173                 jsonw_uint_field(json_wtr, "run_time_ns", info->run_time_ns);
 174                 jsonw_uint_field(json_wtr, "run_cnt", info->run_cnt);
 175         }
 176 }
 177
 178 static void print_prog_json(struct bpf_prog_info *info, int fd)
 179 {
 180         char *memlock;
 181
 182         jsonw_start_object(json_wtr);
 183         print_prog_header_json(info);
 184         print_dev_json(info->ifindex, info->netns_dev, info->netns_ino);
 185
 186         if (info->load_time) {
 187                 char buf[32];
 188
 189                 print_boot_time(info->load_time, buf, sizeof(buf));
 190
 191                 /* Piggy back on load_time, since 0 uid is a valid one */
 192                 jsonw_name(json_wtr, "loaded_at");
 193                 jsonw_printf(json_wtr, "%s", buf);
 194                 jsonw_uint_field(json_wtr, "uid", info->created_by_uid);
 195         }
 196
 197         jsonw_uint_field(json_wtr, "bytes_xlated", info->xlated_prog_len);
 198
 199         if (info->jited_prog_len) {
 200                 jsonw_bool_field(json_wtr, "jited", true);
 201                 jsonw_uint_field(json_wtr, "bytes_jited", info->jited_prog_len);
 202         } else {
 203                 jsonw_bool_field(json_wtr, "jited", false);
 204         }
 205
 206         memlock = get_fdinfo(fd, "memlock");
 207         if (memlock)
 208                 jsonw_int_field(json_wtr, "bytes_memlock", atoi(memlock));
 209         free(memlock);
 210
 211         if (info->nr_map_ids)
 212                 show_prog_maps(fd, info->nr_map_ids);
 213
 214         if (info->btf_id)
 215                 jsonw_int_field(json_wtr, "btf_id", info->btf_id);
 216
 217         if (!hash_empty(prog_table.table)) {
 218                 struct pinned_obj *obj;
 219
 220                 jsonw_name(json_wtr, "pinned");
 221                 jsonw_start_array(json_wtr);
 222                 hash_for_each_possible(prog_table.table, obj, hash, info->id) {
 223                         if (obj->id == info->id)
 224                                 jsonw_string(json_wtr, obj->path);
 225                 }
 226                 jsonw_end_array(json_wtr);
 227         }
 228
 229         emit_obj_refs_json(&refs_table, info->id, json_wtr);
 230
 231         jsonw_end_object(json_wtr);
 232 }
 233
 234 static void print_prog_header_plain(struct bpf_prog_info *info)
 235 {
 236         printf("%u: ", info->id);
 237         if (info->type < ARRAY_SIZE(prog_type_name))
 238                 printf("%s  ", prog_type_name[info->type]);
 239         else
 240                 printf("type %u  ", info->type);
 241
 242         if (*info->name)
 243                 printf("name %s  ", info->name);
 244
 245         printf("tag ");
 246         fprint_hex(stdout, info->tag, BPF_TAG_SIZE, "");
 247         print_dev_plain(info->ifindex, info->netns_dev, info->netns_ino);
 248         printf("%s", info->gpl_compatible ? "  gpl" : "");
 249         if (info->run_time_ns)
 250                 printf(" run_time_ns %lld run_cnt %lld",
 251                        info->run_time_ns, info->run_cnt);
 252         printf("\n");
 253 }
 254
 255 static void print_prog_plain(struct bpf_prog_info *info, int fd)
 256 {
 257         char *memlock;
 258
 259         print_prog_header_plain(info);
 260
 261         if (info->load_time) {
 262                 char buf[32];
 263
 264                 print_boot_time(info->load_time, buf, sizeof(buf));
 265
 266                 /* Piggy back on load_time, since 0 uid is a valid one */
 267                 printf("\tloaded_at %s  uid %u\n", buf, info->created_by_uid);
 268         }
 269
 270         printf("\txlated %uB", info->xlated_prog_len);
 271
 272         if (info->jited_prog_len)
 273                 printf("  jited %uB", info->jited_prog_len);
 274         else
 275                 printf("  not jited");
 276
 277         memlock = get_fdinfo(fd, "memlock");
 278         if (memlock)
 279                 printf("  memlock %sB", memlock);
 280         free(memlock);
 281
 282         if (info->nr_map_ids)
 283                 show_prog_maps(fd, info->nr_map_ids);
 284
 285         if (!hash_empty(prog_table.table)) {
 286                 struct pinned_obj *obj;
 287
 288                 hash_for_each_possible(prog_table.table, obj, hash, info->id) {
 289                         if (obj->id == info->id)
 290                                 printf("\n\tpinned %s", obj->path);
 291                 }
 292         }
 293
 294         if (info->btf_id)
 295                 printf("\n\tbtf_id %d", info->btf_id);
 296
 297         emit_obj_refs_plain(&refs_table, info->id, "\n\tpids ");
 298
 299         printf("\n");
 300 }
 301
 302 static int show_prog(int fd)
 303 {
 304         struct bpf_prog_info info = {};
 305         __u32 len = sizeof(info);
 306         int err;
 307
 308         err = bpf_obj_get_info_by_fd(fd, &info, &len);
 309         if (err) {
 310                 p_err("can't get prog info: %s", strerror(errno));
 311                 return -1;
 312         }
 313
 314         if (json_output)
 315                 print_prog_json(&info, fd);
 316         else
 317                 print_prog_plain(&info, fd);
 318
 319         return 0;
 320 }
 321
 322 static int do_show_subset(int argc, char **argv)
 323 {
 324         int *fds = NULL;
 325         int nb_fds, i;
 326         int err = -1;
 327
 328         fds = malloc(sizeof(int));
 329         if (!fds) {
 330                 p_err("mem alloc failed");
 331                 return -1;
 332         }
 333         nb_fds = prog_parse_fds(&argc, &argv, &fds);
 334         if (nb_fds < 1)
 335                 goto exit_free;
 336
 337         if (json_output && nb_fds > 1)
 338                 jsonw_start_array(json_wtr);    /* root array */
 339         for (i = 0; i < nb_fds; i++) {
 340                 err = show_prog(fds[i]);
 341                 if (err) {
 342                         for (; i < nb_fds; i++)
 343                                 close(fds[i]);
 344                         break;
 345                 }
 346                 close(fds[i]);
 347         }
 348         if (json_output && nb_fds > 1)
 349                 jsonw_end_array(json_wtr);      /* root array */
 350
 351 exit_free:
 352         free(fds);
 353         return err;
 354 }
 355
 356 static int do_show(int argc, char **argv)
 357 {
 358         __u32 id = 0;
 359         int err;
 360         int fd;
 361
 362         if (show_pinned)
 363                 build_pinned_obj_table(&prog_table, BPF_OBJ_PROG);
 364         build_obj_refs_table(&refs_table, BPF_OBJ_PROG);
 365
 366         if (argc == 2)
 367                 return do_show_subset(argc, argv);
 368
 369         if (argc)
 370                 return BAD_ARG();
 371
 372         if (json_output)
 373                 jsonw_start_array(json_wtr);
 374         while (true) {
 375                 err = bpf_prog_get_next_id(id, &id);
 376                 if (err) {
 377                         if (errno == ENOENT) {
 378                                 err = 0;
 379                                 break;
 380                         }
 381                         p_err("can't get next program: %s%s", strerror(errno),
 382                               errno == EINVAL ? " -- kernel too old?" : "");
 383                         err = -1;
 384                         break;
 385                 }
 386
 387                 fd = bpf_prog_get_fd_by_id(id);
 388                 if (fd < 0) {
 389                         if (errno == ENOENT)
 390                                 continue;
 391                         p_err("can't get prog by id (%u): %s",
 392                               id, strerror(errno));
 393                         err = -1;
 394                         break;
 395                 }
 396
 397                 err = show_prog(fd);
 398                 close(fd);
 399                 if (err)
 400                         break;
 401         }
 402
 403         if (json_output)
 404                 jsonw_end_array(json_wtr);
 405
 406         delete_obj_refs_table(&refs_table);
 407
 408         return err;
 409 }
 410
 411 static int
 412 prog_dump(struct bpf_prog_info *info, enum dump_mode mode,
 413           char *filepath, bool opcodes, bool visual, bool linum)
 414 {
 415         struct bpf_prog_linfo *prog_linfo = NULL;
 416         const char *disasm_opt = NULL;
 417         struct dump_data dd = {};
 418         void *func_info = NULL;
 419         struct btf *btf = NULL;
 420         char func_sig[1024];
 421         unsigned char *buf;
 422         __u32 member_len;
 423         ssize_t n;
 424         int fd;
 425
 426         if (mode == DUMP_JITED) {
 427                 if (info->jited_prog_len == 0 || !info->jited_prog_insns) {
 428                         p_info("no instructions returned");
 429                         return -1;
 430                 }
 431                 buf = u64_to_ptr(info->jited_prog_insns);
 432                 member_len = info->jited_prog_len;
 433         } else {        /* DUMP_XLATED */
 434                 if (info->xlated_prog_len == 0 || !info->xlated_prog_insns) {
 435                         p_err("error retrieving insn dump: kernel.kptr_restrict set?");
 436                         return -1;
 437                 }
 438                 buf = u64_to_ptr(info->xlated_prog_insns);
 439                 member_len = info->xlated_prog_len;
 440         }
 441
 442         if (info->btf_id && btf__get_from_id(info->btf_id, &btf)) {
 443                 p_err("failed to get btf");
 444                 return -1;
 445         }
 446
 447         func_info = u64_to_ptr(info->func_info);
 448
 449         if (info->nr_line_info) {
 450                 prog_linfo = bpf_prog_linfo__new(info);
 451                 if (!prog_linfo)
 452                         p_info("error in processing bpf_line_info.  continue without it.");
 453         }
 454
 455         if (filepath) {
 456                 fd = open(filepath, O_WRONLY | O_CREAT | O_TRUNC, 0600);
 457                 if (fd < 0) {
 458                         p_err("can't open file %s: %s", filepath,
 459                               strerror(errno));
 460                         return -1;
 461                 }
 462
 463                 n = write(fd, buf, member_len);
 464                 close(fd);
 465                 if (n != (ssize_t)member_len) {
 466                         p_err("error writing output file: %s",
 467                               n < 0 ? strerror(errno) : "short write");
 468                         return -1;
 469                 }
 470
 471                 if (json_output)
 472                         jsonw_null(json_wtr);
 473         } else if (mode == DUMP_JITED) {
 474                 const char *name = NULL;
 475
 476                 if (info->ifindex) {
 477                         name = ifindex_to_bfd_params(info->ifindex,
 478                                                      info->netns_dev,
 479                                                      info->netns_ino,
 480                                                      &disasm_opt);
 481                         if (!name)
 482                                 return -1;
 483                 }
 484
 485                 if (info->nr_jited_func_lens && info->jited_func_lens) {
 486                         struct kernel_sym *sym = NULL;
 487                         struct bpf_func_info *record;
 488                         char sym_name[SYM_MAX_NAME];
 489                         unsigned char *img = buf;
 490                         __u64 *ksyms = NULL;
 491                         __u32 *lens;
 492                         __u32 i;
 493                         if (info->nr_jited_ksyms) {
 494                                 kernel_syms_load(&dd);
 495                                 ksyms = u64_to_ptr(info->jited_ksyms);
 496                         }
 497
 498                         if (json_output)
 499                                 jsonw_start_array(json_wtr);
 500
 501                         lens = u64_to_ptr(info->jited_func_lens);
 502                         for (i = 0; i < info->nr_jited_func_lens; i++) {
 503                                 if (ksyms) {
 504                                         sym = kernel_syms_search(&dd, ksyms[i]);
 505                                         if (sym)
 506                                                 sprintf(sym_name, "%s", sym->name);
 507                                         else
 508                                                 sprintf(sym_name, "0x%016llx", ksyms[i]);
 509                                 } else {
 510                                         strcpy(sym_name, "unknown");
 511                                 }
 512
 513                                 if (func_info) {
 514                                         record = func_info + i * info->func_info_rec_size;
 515                                         btf_dumper_type_only(btf, record->type_id,
 516                                                              func_sig,
 517                                                              sizeof(func_sig));
 518                                 }
 519
 520                                 if (json_output) {
 521                                         jsonw_start_object(json_wtr);
 522                                         if (func_info && func_sig[0] != '\0') {
 523                                                 jsonw_name(json_wtr, "proto");
 524                                                 jsonw_string(json_wtr, func_sig);
 525                                         }
 526                                         jsonw_name(json_wtr, "name");
 527                                         jsonw_string(json_wtr, sym_name);
 528                                         jsonw_name(json_wtr, "insns");
 529                                 } else {
 530                                         if (func_info && func_sig[0] != '\0')
 531                                                 printf("%s:\n", func_sig);
 532                                         printf("%s:\n", sym_name);
 533                                 }
 534
 535                                 disasm_print_insn(img, lens[i], opcodes,
 536                                                   name, disasm_opt, btf,
 537                                                   prog_linfo, ksyms[i], i,
 538                                                   linum);
 539
 540                                 img += lens[i];
 541
 542                                 if (json_output)
 543                                         jsonw_end_object(json_wtr);
 544                                 else
 545                                         printf("\n");
 546                         }
 547
 548                         if (json_output)
 549                                 jsonw_end_array(json_wtr);
 550                 } else {
 551                         disasm_print_insn(buf, member_len, opcodes, name,
 552                                           disasm_opt, btf, NULL, 0, 0, false);
 553                 }
 554         } else if (visual) {
 555                 if (json_output)
 556                         jsonw_null(json_wtr);
 557                 else
 558                         dump_xlated_cfg(buf, member_len);
 559         } else {
 560                 kernel_syms_load(&dd);
 561                 dd.nr_jited_ksyms = info->nr_jited_ksyms;
 562                 dd.jited_ksyms = u64_to_ptr(info->jited_ksyms);
 563                 dd.btf = btf;
 564                 dd.func_info = func_info;
 565                 dd.finfo_rec_size = info->func_info_rec_size;
 566                 dd.prog_linfo = prog_linfo;
 567
 568                 if (json_output)
 569                         dump_xlated_json(&dd, buf, member_len, opcodes,
 570                                          linum);
 571                 else
 572                         dump_xlated_plain(&dd, buf, member_len, opcodes,
 573                                           linum);
 574                 kernel_syms_destroy(&dd);
 575         }
 576
 577         return 0;
 578 }
 579
 580 static int do_dump(int argc, char **argv)
 581 {
 582         struct bpf_prog_info_linear *info_linear;
 583         char *filepath = NULL;
 584         bool opcodes = false;
 585         bool visual = false;
 586         enum dump_mode mode;
 587         bool linum = false;
 588         int *fds = NULL;
 589         int nb_fds, i = 0;
 590         int err = -1;
 591         __u64 arrays;
 592
 593         if (is_prefix(*argv, "jited")) {
 594                 if (disasm_init())
 595                         return -1;
 596                 mode = DUMP_JITED;
 597         } else if (is_prefix(*argv, "xlated")) {
 598                 mode = DUMP_XLATED;
 599         } else {
 600                 p_err("expected 'xlated' or 'jited', got: %s", *argv);
 601                 return -1;
 602         }
 603         NEXT_ARG();
 604
 605         if (argc < 2)
 606                 usage();
 607
 608         fds = malloc(sizeof(int));
 609         if (!fds) {
 610                 p_err("mem alloc failed");
 611                 return -1;
 612         }
 613         nb_fds = prog_parse_fds(&argc, &argv, &fds);
 614         if (nb_fds < 1)
 615                 goto exit_free;
 616
 617         if (is_prefix(*argv, "file")) {
 618                 NEXT_ARG();
 619                 if (!argc) {
 620                         p_err("expected file path");
 621                         goto exit_close;
 622                 }
 623                 if (nb_fds > 1) {
 624                         p_err("several programs matched");
 625                         goto exit_close;
 626                 }
 627
 628                 filepath = *argv;
 629                 NEXT_ARG();
 630         } else if (is_prefix(*argv, "opcodes")) {
 631                 opcodes = true;
 632                 NEXT_ARG();
 633         } else if (is_prefix(*argv, "visual")) {
 634                 if (nb_fds > 1) {
 635                         p_err("several programs matched");
 636                         goto exit_close;
 637                 }
 638
 639                 visual = true;
 640                 NEXT_ARG();
 641         } else if (is_prefix(*argv, "linum")) {
 642                 linum = true;
 643                 NEXT_ARG();
 644         }
 645
 646         if (argc) {
 647                 usage();
 648                 goto exit_close;
 649         }
 650
 651         if (mode == DUMP_JITED)
 652                 arrays = 1UL << BPF_PROG_INFO_JITED_INSNS;
 653         else
 654                 arrays = 1UL << BPF_PROG_INFO_XLATED_INSNS;
 655
 656         arrays |= 1UL << BPF_PROG_INFO_JITED_KSYMS;
 657         arrays |= 1UL << BPF_PROG_INFO_JITED_FUNC_LENS;
 658         arrays |= 1UL << BPF_PROG_INFO_FUNC_INFO;
 659         arrays |= 1UL << BPF_PROG_INFO_LINE_INFO;
 660         arrays |= 1UL << BPF_PROG_INFO_JITED_LINE_INFO;
 661
 662         if (json_output && nb_fds > 1)
 663                 jsonw_start_array(json_wtr);    /* root array */
 664         for (i = 0; i < nb_fds; i++) {
 665                 info_linear = bpf_program__get_prog_info_linear(fds[i], arrays);
 666                 if (IS_ERR_OR_NULL(info_linear)) {
 667                         p_err("can't get prog info: %s", strerror(errno));
 668                         break;
 669                 }
 670
 671                 if (json_output && nb_fds > 1) {
 672                         jsonw_start_object(json_wtr);   /* prog object */
 673                         print_prog_header_json(&info_linear->info);
 674                         jsonw_name(json_wtr, "insns");
 675                 } else if (nb_fds > 1) {
 676                         print_prog_header_plain(&info_linear->info);
 677                 }
 678
 679                 err = prog_dump(&info_linear->info, mode, filepath, opcodes,
 680                                 visual, linum);
 681
 682                 if (json_output && nb_fds > 1)
 683                         jsonw_end_object(json_wtr);     /* prog object */
 684                 else if (i != nb_fds - 1 && nb_fds > 1)
 685                         printf("\n");
 686
 687                 free(info_linear);
 688                 if (err)
 689                         break;
 690                 close(fds[i]);
 691         }
 692         if (json_output && nb_fds > 1)
 693                 jsonw_end_array(json_wtr);      /* root array */
 694
 695 exit_close:
 696         for (; i < nb_fds; i++)
 697                 close(fds[i]);
 698 exit_free:
 699         free(fds);
 700         return err;
 701 }
 702
 703 static int do_pin(int argc, char **argv)
 704 {
 705         int err;
 706
 707         err = do_pin_any(argc, argv, prog_parse_fd);
 708         if (!err && json_output)
 709                 jsonw_null(json_wtr);
 710         return err;
 711 }
 712
 713 struct map_replace {
 714         int idx;
 715         int fd;
 716         char *name;
 717 };
 718
 719 static int map_replace_compar(const void *p1, const void *p2)
 720 {
 721         const struct map_replace *a = p1, *b = p2;
 722
 723         return a->idx - b->idx;
 724 }
 725
 726 static int parse_attach_detach_args(int argc, char **argv, int *progfd,
 727                                     enum bpf_attach_type *attach_type,
 728                                     int *mapfd)
 729 {
 730         if (!REQ_ARGS(3))
 731                 return -EINVAL;
 732
 733         *progfd = prog_parse_fd(&argc, &argv);
 734         if (*progfd < 0)
 735                 return *progfd;
 736
 737         *attach_type = parse_attach_type(*argv);
 738         if (*attach_type == __MAX_BPF_ATTACH_TYPE) {
 739                 p_err("invalid attach/detach type");
 740                 return -EINVAL;
 741         }
 742
 743         if (*attach_type == BPF_FLOW_DISSECTOR) {
 744                 *mapfd = -1;
 745                 return 0;
 746         }
 747
 748         NEXT_ARG();
 749         if (!REQ_ARGS(2))
 750                 return -EINVAL;
 751
 752         *mapfd = map_parse_fd(&argc, &argv);
 753         if (*mapfd < 0)
 754                 return *mapfd;
 755
 756         return 0;
 757 }
 758
 759 static int do_attach(int argc, char **argv)
 760 {
 761         enum bpf_attach_type attach_type;
 762         int err, progfd;
 763         int mapfd;
 764
 765         err = parse_attach_detach_args(argc, argv,
 766                                        &progfd, &attach_type, &mapfd);
 767         if (err)
 768                 return err;
 769
 770         err = bpf_prog_attach(progfd, mapfd, attach_type, 0);
 771         if (err) {
 772                 p_err("failed prog attach to map");
 773                 return -EINVAL;
 774         }
 775
 776         if (json_output)
 777                 jsonw_null(json_wtr);
 778         return 0;
 779 }
 780
 781 static int do_detach(int argc, char **argv)
 782 {
 783         enum bpf_attach_type attach_type;
 784         int err, progfd;
 785         int mapfd;
 786
 787         err = parse_attach_detach_args(argc, argv,
 788                                        &progfd, &attach_type, &mapfd);
 789         if (err)
 790                 return err;
 791
 792         err = bpf_prog_detach2(progfd, mapfd, attach_type);
 793         if (err) {
 794                 p_err("failed prog detach from map");
 795                 return -EINVAL;
 796         }
 797
 798         if (json_output)
 799                 jsonw_null(json_wtr);
 800         return 0;
 801 }
 802
 803 static int check_single_stdin(char *file_data_in, char *file_ctx_in)
 804 {
 805         if (file_data_in && file_ctx_in &&
 806             !strcmp(file_data_in, "-") && !strcmp(file_ctx_in, "-")) {
 807                 p_err("cannot use standard input for both data_in and ctx_in");
 808                 return -1;
 809         }
 810
 811         return 0;
 812 }
 813
 814 static int get_run_data(const char *fname, void **data_ptr, unsigned int *size)
 815 {
 816         size_t block_size = 256;
 817         size_t buf_size = block_size;
 818         size_t nb_read = 0;
 819         void *tmp;
 820         FILE *f;
 821
 822         if (!fname) {
 823                 *data_ptr = NULL;
 824                 *size = 0;
 825                 return 0;
 826         }
 827
 828         if (!strcmp(fname, "-"))
 829                 f = stdin;
 830         else
 831                 f = fopen(fname, "r");
 832         if (!f) {
 833                 p_err("failed to open %s: %s", fname, strerror(errno));
 834                 return -1;
 835         }
 836
 837         *data_ptr = malloc(block_size);
 838         if (!*data_ptr) {
 839                 p_err("failed to allocate memory for data_in/ctx_in: %s",
 840                       strerror(errno));
 841                 goto err_fclose;
 842         }
 843
 844         while ((nb_read += fread(*data_ptr + nb_read, 1, block_size, f))) {
 845                 if (feof(f))
 846                         break;
 847                 if (ferror(f)) {
 848                         p_err("failed to read data_in/ctx_in from %s: %s",
 849                               fname, strerror(errno));
 850                         goto err_free;
 851                 }
 852                 if (nb_read > buf_size - block_size) {
 853                         if (buf_size == UINT32_MAX) {
 854                                 p_err("data_in/ctx_in is too long (max: %d)",
 855                                       UINT32_MAX);
 856                                 goto err_free;
 857                         }
 858                         /* No space for fread()-ing next chunk; realloc() */
 859                         buf_size *= 2;
 860                         tmp = realloc(*data_ptr, buf_size);
 861                         if (!tmp) {
 862                                 p_err("failed to reallocate data_in/ctx_in: %s",
 863                                       strerror(errno));
 864                                 goto err_free;
 865                         }
 866                         *data_ptr = tmp;
 867                 }
 868         }
 869         if (f != stdin)
 870                 fclose(f);
 871
 872         *size = nb_read;
 873         return 0;
 874
 875 err_free:
 876         free(*data_ptr);
 877         *data_ptr = NULL;
 878 err_fclose:
 879         if (f != stdin)
 880                 fclose(f);
 881         return -1;
 882 }
 883
 884 static void hex_print(void *data, unsigned int size, FILE *f)
 885 {
 886         size_t i, j;
 887         char c;
 888
 889         for (i = 0; i < size; i += 16) {
 890                 /* Row offset */
 891                 fprintf(f, "%07zx\t", i);
 892
 893                 /* Hexadecimal values */
 894                 for (j = i; j < i + 16 && j < size; j++)
 895                         fprintf(f, "%02x%s", *(uint8_t *)(data + j),
 896                                 j % 2 ? " " : "");
 897                 for (; j < i + 16; j++)
 898                         fprintf(f, "  %s", j % 2 ? " " : "");
 899
 900                 /* ASCII values (if relevant), '.' otherwise */
 901                 fprintf(f, "| ");
 902                 for (j = i; j < i + 16 && j < size; j++) {
 903                         c = *(char *)(data + j);
 904                         if (c < ' ' || c > '~')
 905                                 c = '.';
 906                         fprintf(f, "%c%s", c, j == i + 7 ? " " : "");
 907                 }
 908
 909                 fprintf(f, "\n");
 910         }
 911 }
 912
 913 static int
 914 print_run_output(void *data, unsigned int size, const char *fname,
 915                  const char *json_key)
 916 {
 917         size_t nb_written;
 918         FILE *f;
 919
 920         if (!fname)
 921                 return 0;
 922
 923         if (!strcmp(fname, "-")) {
 924                 f = stdout;
 925                 if (json_output) {
 926                         jsonw_name(json_wtr, json_key);
 927                         print_data_json(data, size);
 928                 } else {
 929                         hex_print(data, size, f);
 930                 }
 931                 return 0;
 932         }
 933
 934         f = fopen(fname, "w");
 935         if (!f) {
 936                 p_err("failed to open %s: %s", fname, strerror(errno));
 937                 return -1;
 938         }
 939
 940         nb_written = fwrite(data, 1, size, f);
 941         fclose(f);
 942         if (nb_written != size) {
 943                 p_err("failed to write output data/ctx: %s", strerror(errno));
 944                 return -1;
 945         }
 946
 947         return 0;
 948 }
 949
 950 static int alloc_run_data(void **data_ptr, unsigned int size_out)
 951 {
 952         *data_ptr = calloc(size_out, 1);
 953         if (!*data_ptr) {
 954                 p_err("failed to allocate memory for output data/ctx: %s",
 955                       strerror(errno));
 956                 return -1;
 957         }
 958
 959         return 0;
 960 }
 961
 962 static int do_run(int argc, char **argv)
 963 {
 964         char *data_fname_in = NULL, *data_fname_out = NULL;
 965         char *ctx_fname_in = NULL, *ctx_fname_out = NULL;
 966         struct bpf_prog_test_run_attr test_attr = {0};
 967         const unsigned int default_size = SZ_32K;
 968         void *data_in = NULL, *data_out = NULL;
 969         void *ctx_in = NULL, *ctx_out = NULL;
 970         unsigned int repeat = 1;
 971         int fd, err;
 972
 973         if (!REQ_ARGS(4))
 974                 return -1;
 975
 976         fd = prog_parse_fd(&argc, &argv);
 977         if (fd < 0)
 978                 return -1;
 979
 980         while (argc) {
 981                 if (detect_common_prefix(*argv, "data_in", "data_out",
 982                                          "data_size_out", NULL))
 983                         return -1;
 984                 if (detect_common_prefix(*argv, "ctx_in", "ctx_out",
 985                                          "ctx_size_out", NULL))
 986                         return -1;
 987
 988                 if (is_prefix(*argv, "data_in")) {
 989                         NEXT_ARG();
 990                         if (!REQ_ARGS(1))
 991                                 return -1;
 992
 993                         data_fname_in = GET_ARG();
 994                         if (check_single_stdin(data_fname_in, ctx_fname_in))
 995                                 return -1;
 996                 } else if (is_prefix(*argv, "data_out")) {
 997                         NEXT_ARG();
 998                         if (!REQ_ARGS(1))
 999                                 return -1;
1000
1001                         data_fname_out = GET_ARG();
1002                 } else if (is_prefix(*argv, "data_size_out")) {
1003                         char *endptr;
1004
1005                         NEXT_ARG();
1006                         if (!REQ_ARGS(1))
1007                                 return -1;
1008
1009                         test_attr.data_size_out = strtoul(*argv, &endptr, 0);
1010                         if (*endptr) {
1011                                 p_err("can't parse %s as output data size",
1012                                       *argv);
1013                                 return -1;
1014                         }
1015                         NEXT_ARG();
1016                 } else if (is_prefix(*argv, "ctx_in")) {
1017                         NEXT_ARG();
1018                         if (!REQ_ARGS(1))
1019                                 return -1;
1020
1021                         ctx_fname_in = GET_ARG();
1022                         if (check_single_stdin(data_fname_in, ctx_fname_in))
1023                                 return -1;
1024                 } else if (is_prefix(*argv, "ctx_out")) {
1025                         NEXT_ARG();
1026                         if (!REQ_ARGS(1))
1027                                 return -1;
1028
1029                         ctx_fname_out = GET_ARG();
1030                 } else if (is_prefix(*argv, "ctx_size_out")) {
1031                         char *endptr;
1032
1033                         NEXT_ARG();
1034                         if (!REQ_ARGS(1))
1035                                 return -1;
1036
1037                         test_attr.ctx_size_out = strtoul(*argv, &endptr, 0);
1038                         if (*endptr) {
1039                                 p_err("can't parse %s as output context size",
1040                                       *argv);
1041                                 return -1;
1042                         }
1043                         NEXT_ARG();
1044                 } else if (is_prefix(*argv, "repeat")) {
1045                         char *endptr;
1046
1047                         NEXT_ARG();
1048                         if (!REQ_ARGS(1))
1049                                 return -1;
1050
1051                         repeat = strtoul(*argv, &endptr, 0);
1052                         if (*endptr) {
1053                                 p_err("can't parse %s as repeat number",
1054                                       *argv);
1055                                 return -1;
1056                         }
1057                         NEXT_ARG();
1058                 } else {
1059                         p_err("expected no more arguments, 'data_in', 'data_out', 'data_size_out', 'ctx_in', 'ctx_out', 'ctx_size_out' or 'repeat', got: '%s'?",
1060                               *argv);
1061                         return -1;
1062                 }
1063         }
1064
1065         err = get_run_data(data_fname_in, &data_in, &test_attr.data_size_in);
1066         if (err)
1067                 return -1;
1068
1069         if (data_in) {
1070                 if (!test_attr.data_size_out)
1071                         test_attr.data_size_out = default_size;
1072                 err = alloc_run_data(&data_out, test_attr.data_size_out);
1073                 if (err)
1074                         goto free_data_in;
1075         }
1076
1077         err = get_run_data(ctx_fname_in, &ctx_in, &test_attr.ctx_size_in);
1078         if (err)
1079                 goto free_data_out;
1080
1081         if (ctx_in) {
1082                 if (!test_attr.ctx_size_out)
1083                         test_attr.ctx_size_out = default_size;
1084                 err = alloc_run_data(&ctx_out, test_attr.ctx_size_out);
1085                 if (err)
1086                         goto free_ctx_in;
1087         }
1088
1089         test_attr.prog_fd       = fd;
1090         test_attr.repeat        = repeat;
1091         test_attr.data_in       = data_in;
1092         test_attr.data_out      = data_out;
1093         test_attr.ctx_in        = ctx_in;
1094         test_attr.ctx_out       = ctx_out;
1095
1096         err = bpf_prog_test_run_xattr(&test_attr);
1097         if (err) {
1098                 p_err("failed to run program: %s", strerror(errno));
1099                 goto free_ctx_out;
1100         }
1101
1102         err = 0;
1103
1104         if (json_output)
1105                 jsonw_start_object(json_wtr);   /* root */
1106
1107         /* Do not exit on errors occurring when printing output data/context,
1108          * we still want to print return value and duration for program run.
1109          */
1110         if (test_attr.data_size_out)
1111                 err += print_run_output(test_attr.data_out,
1112                                         test_attr.data_size_out,
1113                                         data_fname_out, "data_out");
1114         if (test_attr.ctx_size_out)
1115                 err += print_run_output(test_attr.ctx_out,
1116                                         test_attr.ctx_size_out,
1117                                         ctx_fname_out, "ctx_out");
1118
1119         if (json_output) {
1120                 jsonw_uint_field(json_wtr, "retval", test_attr.retval);
1121                 jsonw_uint_field(json_wtr, "duration", test_attr.duration);
1122                 jsonw_end_object(json_wtr);     /* root */
1123         } else {
1124                 fprintf(stdout, "Return value: %u, duration%s: %uns\n",
1125                         test_attr.retval,
1126                         repeat > 1 ? " (average)" : "", test_attr.duration);
1127         }
1128
1129 free_ctx_out:
1130         free(ctx_out);
1131 free_ctx_in:
1132         free(ctx_in);
1133 free_data_out:
1134         free(data_out);
1135 free_data_in:
1136         free(data_in);
1137
1138         return err;
1139 }
1140
1141 static int
1142 get_prog_type_by_name(const char *name, enum bpf_prog_type *prog_type,
1143                       enum bpf_attach_type *expected_attach_type)
1144 {
1145         libbpf_print_fn_t print_backup;
1146         int ret;
1147
1148         ret = libbpf_prog_type_by_name(name, prog_type, expected_attach_type);
1149         if (!ret)
1150                 return ret;
1151
1152         /* libbpf_prog_type_by_name() failed, let's re-run with debug level */
1153         print_backup = libbpf_set_print(print_all_levels);
1154         ret = libbpf_prog_type_by_name(name, prog_type, expected_attach_type);
1155         libbpf_set_print(print_backup);
1156
1157         return ret;
1158 }
1159
1160 static int load_with_options(int argc, char **argv, bool first_prog_only)
1161 {
1162         enum bpf_prog_type common_prog_type = BPF_PROG_TYPE_UNSPEC;
1163         DECLARE_LIBBPF_OPTS(bpf_object_open_opts, open_opts,
1164                 .relaxed_maps = relaxed_maps,
1165         );
1166         struct bpf_object_load_attr load_attr = { 0 };
1167         enum bpf_attach_type expected_attach_type;
1168         struct map_replace *map_replace = NULL;
1169         struct bpf_program *prog = NULL, *pos;
1170         unsigned int old_map_fds = 0;
1171         const char *pinmaps = NULL;
1172         struct bpf_object *obj;
1173         struct bpf_map *map;
1174         const char *pinfile;
1175         unsigned int i, j;
1176         __u32 ifindex = 0;
1177         const char *file;
1178         int idx, err;
1179
1180
1181         if (!REQ_ARGS(2))
1182                 return -1;
1183         file = GET_ARG();
1184         pinfile = GET_ARG();
1185
1186         while (argc) {
1187                 if (is_prefix(*argv, "type")) {
1188                         char *type;
1189
1190                         NEXT_ARG();
1191
1192                         if (common_prog_type != BPF_PROG_TYPE_UNSPEC) {
1193                                 p_err("program type already specified");
1194                                 goto err_free_reuse_maps;
1195                         }
1196                         if (!REQ_ARGS(1))
1197                                 goto err_free_reuse_maps;
1198
1199                         /* Put a '/' at the end of type to appease libbpf */
1200                         type = malloc(strlen(*argv) + 2);
1201                         if (!type) {
1202                                 p_err("mem alloc failed");
1203                                 goto err_free_reuse_maps;
1204                         }
1205                         *type = 0;
1206                         strcat(type, *argv);
1207                         strcat(type, "/");
1208
1209                         err = get_prog_type_by_name(type, &common_prog_type,
1210                                                     &expected_attach_type);
1211                         free(type);
1212                         if (err < 0)
1213                                 goto err_free_reuse_maps;
1214
1215                         NEXT_ARG();
1216                 } else if (is_prefix(*argv, "map")) {
1217                         void *new_map_replace;
1218                         char *endptr, *name;
1219                         int fd;
1220
1221                         NEXT_ARG();
1222
1223                         if (!REQ_ARGS(4))
1224                                 goto err_free_reuse_maps;
1225
1226                         if (is_prefix(*argv, "idx")) {
1227                                 NEXT_ARG();
1228
1229                                 idx = strtoul(*argv, &endptr, 0);
1230                                 if (*endptr) {
1231                                         p_err("can't parse %s as IDX", *argv);
1232                                         goto err_free_reuse_maps;
1233                                 }
1234                                 name = NULL;
1235                         } else if (is_prefix(*argv, "name")) {
1236                                 NEXT_ARG();
1237
1238                                 name = *argv;
1239                                 idx = -1;
1240                         } else {
1241                                 p_err("expected 'idx' or 'name', got: '%s'?",
1242                                       *argv);
1243                                 goto err_free_reuse_maps;
1244                         }
1245                         NEXT_ARG();
1246
1247                         fd = map_parse_fd(&argc, &argv);
1248                         if (fd < 0)
1249                                 goto err_free_reuse_maps;
1250
1251                         new_map_replace = reallocarray(map_replace,
1252                                                        old_map_fds + 1,
1253                                                        sizeof(*map_replace));
1254                         if (!new_map_replace) {
1255                                 p_err("mem alloc failed");
1256                                 goto err_free_reuse_maps;
1257                         }
1258                         map_replace = new_map_replace;
1259
1260                         map_replace[old_map_fds].idx = idx;
1261                         map_replace[old_map_fds].name = name;
1262                         map_replace[old_map_fds].fd = fd;
1263                         old_map_fds++;
1264                 } else if (is_prefix(*argv, "dev")) {
1265                         NEXT_ARG();
1266
1267                         if (ifindex) {
1268                                 p_err("offload device already specified");
1269                                 goto err_free_reuse_maps;
1270                         }
1271                         if (!REQ_ARGS(1))
1272                                 goto err_free_reuse_maps;
1273
1274                         ifindex = if_nametoindex(*argv);
1275                         if (!ifindex) {
1276                                 p_err("unrecognized netdevice '%s': %s",
1277                                       *argv, strerror(errno));
1278                                 goto err_free_reuse_maps;
1279                         }
1280                         NEXT_ARG();
1281                 } else if (is_prefix(*argv, "pinmaps")) {
1282                         NEXT_ARG();
1283
1284                         if (!REQ_ARGS(1))
1285                                 goto err_free_reuse_maps;
1286
1287                         pinmaps = GET_ARG();
1288                 } else {
1289                         p_err("expected no more arguments, 'type', 'map' or 'dev', got: '%s'?",
1290                               *argv);
1291                         goto err_free_reuse_maps;
1292                 }
1293         }
1294
1295         set_max_rlimit();
1296
1297         obj = bpf_object__open_file(file, &open_opts);
1298         if (IS_ERR_OR_NULL(obj)) {
1299                 p_err("failed to open object file");
1300                 goto err_free_reuse_maps;
1301         }
1302
1303         bpf_object__for_each_program(pos, obj) {
1304                 enum bpf_prog_type prog_type = common_prog_type;
1305
1306                 if (prog_type == BPF_PROG_TYPE_UNSPEC) {
1307                         const char *sec_name = bpf_program__title(pos, false);
1308
1309                         err = get_prog_type_by_name(sec_name, &prog_type,
1310                                                     &expected_attach_type);
1311                         if (err < 0)
1312                                 goto err_close_obj;
1313                 }
1314
1315                 bpf_program__set_ifindex(pos, ifindex);
1316                 bpf_program__set_type(pos, prog_type);
1317                 bpf_program__set_expected_attach_type(pos, expected_attach_type);
1318         }
1319
1320         qsort(map_replace, old_map_fds, sizeof(*map_replace),
1321               map_replace_compar);
1322
1323         /* After the sort maps by name will be first on the list, because they
1324          * have idx == -1.  Resolve them.
1325          */
1326         j = 0;
1327         while (j < old_map_fds && map_replace[j].name) {
1328                 i = 0;
1329                 bpf_object__for_each_map(map, obj) {
1330                         if (!strcmp(bpf_map__name(map), map_replace[j].name)) {
1331                                 map_replace[j].idx = i;
1332                                 break;
1333                         }
1334                         i++;
1335                 }
1336                 if (map_replace[j].idx == -1) {
1337                         p_err("unable to find map '%s'", map_replace[j].name);
1338                         goto err_close_obj;
1339                 }
1340                 j++;
1341         }
1342         /* Resort if any names were resolved */
1343         if (j)
1344                 qsort(map_replace, old_map_fds, sizeof(*map_replace),
1345                       map_replace_compar);
1346
1347         /* Set ifindex and name reuse */
1348         j = 0;
1349         idx = 0;
1350         bpf_object__for_each_map(map, obj) {
1351                 if (!bpf_map__is_offload_neutral(map))
1352                         bpf_map__set_ifindex(map, ifindex);
1353
1354                 if (j < old_map_fds && idx == map_replace[j].idx) {
1355                         err = bpf_map__reuse_fd(map, map_replace[j++].fd);
1356                         if (err) {
1357                                 p_err("unable to set up map reuse: %d", err);
1358                                 goto err_close_obj;
1359                         }
1360
1361                         /* Next reuse wants to apply to the same map */
1362                         if (j < old_map_fds && map_replace[j].idx == idx) {
1363                                 p_err("replacement for map idx %d specified more than once",
1364                                       idx);
1365                                 goto err_close_obj;
1366                         }
1367                 }
1368
1369                 idx++;
1370         }
1371         if (j < old_map_fds) {
1372                 p_err("map idx '%d' not used", map_replace[j].idx);
1373                 goto err_close_obj;
1374         }
1375
1376         load_attr.obj = obj;
1377         if (verifier_logs)
1378                 /* log_level1 + log_level2 + stats, but not stable UAPI */
1379                 load_attr.log_level = 1 + 2 + 4;
1380
1381         err = bpf_object__load_xattr(&load_attr);
1382         if (err) {
1383                 p_err("failed to load object file");
1384                 goto err_close_obj;
1385         }
1386
1387         err = mount_bpffs_for_pin(pinfile);
1388         if (err)
1389                 goto err_close_obj;
1390
1391         if (first_prog_only) {
1392                 prog = bpf_program__next(NULL, obj);
1393                 if (!prog) {
1394                         p_err("object file doesn't contain any bpf program");
1395                         goto err_close_obj;
1396                 }
1397
1398                 err = bpf_obj_pin(bpf_program__fd(prog), pinfile);
1399                 if (err) {
1400                         p_err("failed to pin program %s",
1401                               bpf_program__title(prog, false));
1402                         goto err_close_obj;
1403                 }
1404         } else {
1405                 err = bpf_object__pin_programs(obj, pinfile);
1406                 if (err) {
1407                         p_err("failed to pin all programs");
1408                         goto err_close_obj;
1409                 }
1410         }
1411
1412         if (pinmaps) {
1413                 err = bpf_object__pin_maps(obj, pinmaps);
1414                 if (err) {
1415                         p_err("failed to pin all maps");
1416                         goto err_unpin;
1417                 }
1418         }
1419
1420         if (json_output)
1421                 jsonw_null(json_wtr);
1422
1423         bpf_object__close(obj);
1424         for (i = 0; i < old_map_fds; i++)
1425                 close(map_replace[i].fd);
1426         free(map_replace);
1427
1428         return 0;
1429
1430 err_unpin:
1431         if (first_prog_only)
1432                 unlink(pinfile);
1433         else
1434                 bpf_object__unpin_programs(obj, pinfile);
1435 err_close_obj:
1436         bpf_object__close(obj);
1437 err_free_reuse_maps:
1438         for (i = 0; i < old_map_fds; i++)
1439                 close(map_replace[i].fd);
1440         free(map_replace);
1441         return -1;
1442 }
1443
1444 static int do_load(int argc, char **argv)
1445 {
1446         return load_with_options(argc, argv, true);
1447 }
1448
1449 static int do_loadall(int argc, char **argv)
1450 {
1451         return load_with_options(argc, argv, false);
1452 }
1453
1454 #ifdef BPFTOOL_WITHOUT_SKELETONS
1455
1456 static int do_profile(int argc, char **argv)
1457 {
1458         p_err("bpftool prog profile command is not supported. Please build bpftool with clang >= 10.0.0");
1459         return 0;
1460 }
1461
1462 #else /* BPFTOOL_WITHOUT_SKELETONS */
1463
1464 #include "profiler.skel.h"
1465
1466 struct profile_metric {
1467         const char *name;
1468         struct bpf_perf_event_value val;
1469         struct perf_event_attr attr;
1470         bool selected;
1471
1472         /* calculate ratios like instructions per cycle */
1473         const int ratio_metric; /* 0 for N/A, 1 for index 0 (cycles) */
1474         const char *ratio_desc;
1475         const float ratio_mul;
1476 } metrics[] = {
1477         {
1478                 .name = "cycles",
1479                 .attr = {
1480                         .type = PERF_TYPE_HARDWARE,
1481                         .config = PERF_COUNT_HW_CPU_CYCLES,
1482                         .exclude_user = 1,
1483                 },
1484         },
1485         {
1486                 .name = "instructions",
1487                 .attr = {
1488                         .type = PERF_TYPE_HARDWARE,
1489                         .config = PERF_COUNT_HW_INSTRUCTIONS,
1490                         .exclude_user = 1,
1491                 },
1492                 .ratio_metric = 1,
1493                 .ratio_desc = "insns per cycle",
1494                 .ratio_mul = 1.0,
1495         },
1496         {
1497                 .name = "l1d_loads",
1498                 .attr = {
1499                         .type = PERF_TYPE_HW_CACHE,
1500                         .config =
1501                                 PERF_COUNT_HW_CACHE_L1D |
1502                                 (PERF_COUNT_HW_CACHE_OP_READ << 8) |
1503                                 (PERF_COUNT_HW_CACHE_RESULT_ACCESS << 16),
1504                         .exclude_user = 1,
1505                 },
1506         },
1507         {
1508                 .name = "llc_misses",
1509                 .attr = {
1510                         .type = PERF_TYPE_HW_CACHE,
1511                         .config =
1512                                 PERF_COUNT_HW_CACHE_LL |
1513                                 (PERF_COUNT_HW_CACHE_OP_READ << 8) |
1514                                 (PERF_COUNT_HW_CACHE_RESULT_MISS << 16),
1515                         .exclude_user = 1
1516                 },
1517                 .ratio_metric = 2,
1518                 .ratio_desc = "LLC misses per million insns",
1519                 .ratio_mul = 1e6,
1520         },
1521 };
1522
1523 static __u64 profile_total_count;
1524
1525 #define MAX_NUM_PROFILE_METRICS 4
1526
1527 static int profile_parse_metrics(int argc, char **argv)
1528 {
1529         unsigned int metric_cnt;
1530         int selected_cnt = 0;
1531         unsigned int i;
1532
1533         metric_cnt = sizeof(metrics) / sizeof(struct profile_metric);
1534
1535         while (argc > 0) {
1536                 for (i = 0; i < metric_cnt; i++) {
1537                         if (is_prefix(argv[0], metrics[i].name)) {
1538                                 if (!metrics[i].selected)
1539                                         selected_cnt++;
1540                                 metrics[i].selected = true;
1541                                 break;
1542                         }
1543                 }
1544                 if (i == metric_cnt) {
1545                         p_err("unknown metric %s", argv[0]);
1546                         return -1;
1547                 }
1548                 NEXT_ARG();
1549         }
1550         if (selected_cnt > MAX_NUM_PROFILE_METRICS) {
1551                 p_err("too many (%d) metrics, please specify no more than %d metrics at at time",
1552                       selected_cnt, MAX_NUM_PROFILE_METRICS);
1553                 return -1;
1554         }
1555         return selected_cnt;
1556 }
1557
1558 static void profile_read_values(struct profiler_bpf *obj)
1559 {
1560         __u32 m, cpu, num_cpu = obj->rodata->num_cpu;
1561         int reading_map_fd, count_map_fd;
1562         __u64 counts[num_cpu];
1563         __u32 key = 0;
1564         int err;
1565
1566         reading_map_fd = bpf_map__fd(obj->maps.accum_readings);
1567         count_map_fd = bpf_map__fd(obj->maps.counts);
1568         if (reading_map_fd < 0 || count_map_fd < 0) {
1569                 p_err("failed to get fd for map");
1570                 return;
1571         }
1572
1573         err = bpf_map_lookup_elem(count_map_fd, &key, counts);
1574         if (err) {
1575                 p_err("failed to read count_map: %s", strerror(errno));
1576                 return;
1577         }
1578
1579         profile_total_count = 0;
1580         for (cpu = 0; cpu < num_cpu; cpu++)
1581                 profile_total_count += counts[cpu];
1582
1583         for (m = 0; m < ARRAY_SIZE(metrics); m++) {
1584                 struct bpf_perf_event_value values[num_cpu];
1585
1586                 if (!metrics[m].selected)
1587                         continue;
1588
1589                 err = bpf_map_lookup_elem(reading_map_fd, &key, values);
1590                 if (err) {
1591                         p_err("failed to read reading_map: %s",
1592                               strerror(errno));
1593                         return;
1594                 }
1595                 for (cpu = 0; cpu < num_cpu; cpu++) {
1596                         metrics[m].val.counter += values[cpu].counter;
1597                         metrics[m].val.enabled += values[cpu].enabled;
1598                         metrics[m].val.running += values[cpu].running;
1599                 }
1600                 key++;
1601         }
1602 }
1603
1604 static void profile_print_readings_json(void)
1605 {
1606         __u32 m;
1607
1608         jsonw_start_array(json_wtr);
1609         for (m = 0; m < ARRAY_SIZE(metrics); m++) {
1610                 if (!metrics[m].selected)
1611                         continue;
1612                 jsonw_start_object(json_wtr);
1613                 jsonw_string_field(json_wtr, "metric", metrics[m].name);
1614                 jsonw_lluint_field(json_wtr, "run_cnt", profile_total_count);
1615                 jsonw_lluint_field(json_wtr, "value", metrics[m].val.counter);
1616                 jsonw_lluint_field(json_wtr, "enabled", metrics[m].val.enabled);
1617                 jsonw_lluint_field(json_wtr, "running", metrics[m].val.running);
1618
1619                 jsonw_end_object(json_wtr);
1620         }
1621         jsonw_end_array(json_wtr);
1622 }
1623
1624 static void profile_print_readings_plain(void)
1625 {
1626         __u32 m;
1627
1628         printf("\n%18llu %-20s\n", profile_total_count, "run_cnt");
1629         for (m = 0; m < ARRAY_SIZE(metrics); m++) {
1630                 struct bpf_perf_event_value *val = &metrics[m].val;
1631                 int r;
1632
1633                 if (!metrics[m].selected)
1634                         continue;
1635                 printf("%18llu %-20s", val->counter, metrics[m].name);
1636
1637                 r = metrics[m].ratio_metric - 1;
1638                 if (r >= 0 && metrics[r].selected &&
1639                     metrics[r].val.counter > 0) {
1640                         printf("# %8.2f %-30s",
1641                                val->counter * metrics[m].ratio_mul /
1642                                metrics[r].val.counter,
1643                                metrics[m].ratio_desc);
1644                 } else {
1645                         printf("%-41s", "");
1646                 }
1647
1648                 if (val->enabled > val->running)
1649                         printf("(%4.2f%%)",
1650                                val->running * 100.0 / val->enabled);
1651                 printf("\n");
1652         }
1653 }
1654
1655 static void profile_print_readings(void)
1656 {
1657         if (json_output)
1658                 profile_print_readings_json();
1659         else
1660                 profile_print_readings_plain();
1661 }
1662
1663 static char *profile_target_name(int tgt_fd)
1664 {
1665         struct bpf_prog_info_linear *info_linear;
1666         struct bpf_func_info *func_info;
1667         const struct btf_type *t;
1668         char *name = NULL;
1669         struct btf *btf;
1670
1671         info_linear = bpf_program__get_prog_info_linear(
1672                 tgt_fd, 1UL << BPF_PROG_INFO_FUNC_INFO);
1673         if (IS_ERR_OR_NULL(info_linear)) {
1674                 p_err("failed to get info_linear for prog FD %d", tgt_fd);
1675                 return NULL;
1676         }
1677
1678         if (info_linear->info.btf_id == 0 ||
1679             btf__get_from_id(info_linear->info.btf_id, &btf)) {
1680                 p_err("prog FD %d doesn't have valid btf", tgt_fd);
1681                 goto out;
1682         }
1683
1684         func_info = u64_to_ptr(info_linear->info.func_info);
1685         t = btf__type_by_id(btf, func_info[0].type_id);
1686         if (!t) {
1687                 p_err("btf %d doesn't have type %d",
1688                       info_linear->info.btf_id, func_info[0].type_id);
1689                 goto out;
1690         }
1691         name = strdup(btf__name_by_offset(btf, t->name_off));
1692 out:
1693         free(info_linear);
1694         return name;
1695 }
1696
1697 static struct profiler_bpf *profile_obj;
1698 static int profile_tgt_fd = -1;
1699 static char *profile_tgt_name;
1700 static int *profile_perf_events;
1701 static int profile_perf_event_cnt;
1702
1703 static void profile_close_perf_events(struct profiler_bpf *obj)
1704 {
1705         int i;
1706
1707         for (i = profile_perf_event_cnt - 1; i >= 0; i--)
1708                 close(profile_perf_events[i]);
1709
1710         free(profile_perf_events);
1711         profile_perf_event_cnt = 0;
1712 }
1713
1714 static int profile_open_perf_events(struct profiler_bpf *obj)
1715 {
1716         unsigned int cpu, m;
1717         int map_fd, pmu_fd;
1718
1719         profile_perf_events = calloc(
1720                 sizeof(int), obj->rodata->num_cpu * obj->rodata->num_metric);
1721         if (!profile_perf_events) {
1722                 p_err("failed to allocate memory for perf_event array: %s",
1723                       strerror(errno));
1724                 return -1;
1725         }
1726         map_fd = bpf_map__fd(obj->maps.events);
1727         if (map_fd < 0) {
1728                 p_err("failed to get fd for events map");
1729                 return -1;
1730         }
1731
1732         for (m = 0; m < ARRAY_SIZE(metrics); m++) {
1733                 if (!metrics[m].selected)
1734                         continue;
1735                 for (cpu = 0; cpu < obj->rodata->num_cpu; cpu++) {
1736                         pmu_fd = syscall(__NR_perf_event_open, &metrics[m].attr,
1737                                          -1/*pid*/, cpu, -1/*group_fd*/, 0);
1738                         if (pmu_fd < 0 ||
1739                             bpf_map_update_elem(map_fd, &profile_perf_event_cnt,
1740                                                 &pmu_fd, BPF_ANY) ||
1741                             ioctl(pmu_fd, PERF_EVENT_IOC_ENABLE, 0)) {
1742                                 p_err("failed to create event %s on cpu %d",
1743                                       metrics[m].name, cpu);
1744                                 return -1;
1745                         }
1746                         profile_perf_events[profile_perf_event_cnt++] = pmu_fd;
1747                 }
1748         }
1749         return 0;
1750 }
1751
1752 static void profile_print_and_cleanup(void)
1753 {
1754         profile_close_perf_events(profile_obj);
1755         profile_read_values(profile_obj);
1756         profile_print_readings();
1757         profiler_bpf__destroy(profile_obj);
1758
1759         close(profile_tgt_fd);
1760         free(profile_tgt_name);
1761 }
1762
1763 static void int_exit(int signo)
1764 {
1765         profile_print_and_cleanup();
1766         exit(0);
1767 }
1768
1769 static int do_profile(int argc, char **argv)
1770 {
1771         int num_metric, num_cpu, err = -1;
1772         struct bpf_program *prog;
1773         unsigned long duration;
1774         char *endptr;
1775
1776         /* we at least need two args for the prog and one metric */
1777         if (!REQ_ARGS(3))
1778                 return -EINVAL;
1779
1780         /* parse target fd */
1781         profile_tgt_fd = prog_parse_fd(&argc, &argv);
1782         if (profile_tgt_fd < 0) {
1783                 p_err("failed to parse fd");
1784                 return -1;
1785         }
1786
1787         /* parse profiling optional duration */
1788         if (argc > 2 && is_prefix(argv[0], "duration")) {
1789                 NEXT_ARG();
1790                 duration = strtoul(*argv, &endptr, 0);
1791                 if (*endptr)
1792                         usage();
1793                 NEXT_ARG();
1794         } else {
1795                 duration = UINT_MAX;
1796         }
1797
1798         num_metric = profile_parse_metrics(argc, argv);
1799         if (num_metric <= 0)
1800                 goto out;
1801
1802         num_cpu = libbpf_num_possible_cpus();
1803         if (num_cpu <= 0) {
1804                 p_err("failed to identify number of CPUs");
1805                 goto out;
1806         }
1807
1808         profile_obj = profiler_bpf__open();
1809         if (!profile_obj) {
1810                 p_err("failed to open and/or load BPF object");
1811                 goto out;
1812         }
1813
1814         profile_obj->rodata->num_cpu = num_cpu;
1815         profile_obj->rodata->num_metric = num_metric;
1816
1817         /* adjust map sizes */
1818         bpf_map__resize(profile_obj->maps.events, num_metric * num_cpu);
1819         bpf_map__resize(profile_obj->maps.fentry_readings, num_metric);
1820         bpf_map__resize(profile_obj->maps.accum_readings, num_metric);
1821         bpf_map__resize(profile_obj->maps.counts, 1);
1822
1823         /* change target name */
1824         profile_tgt_name = profile_target_name(profile_tgt_fd);
1825         if (!profile_tgt_name)
1826                 goto out;
1827
1828         bpf_object__for_each_program(prog, profile_obj->obj) {
1829                 err = bpf_program__set_attach_target(prog, profile_tgt_fd,
1830                                                      profile_tgt_name);
1831                 if (err) {
1832                         p_err("failed to set attach target\n");
1833                         goto out;
1834                 }
1835         }
1836
1837         set_max_rlimit();
1838         err = profiler_bpf__load(profile_obj);
1839         if (err) {
1840                 p_err("failed to load profile_obj");
1841                 goto out;
1842         }
1843
1844         err = profile_open_perf_events(profile_obj);
1845         if (err)
1846                 goto out;
1847
1848         err = profiler_bpf__attach(profile_obj);
1849         if (err) {
1850                 p_err("failed to attach profile_obj");
1851                 goto out;
1852         }
1853         signal(SIGINT, int_exit);
1854
1855         sleep(duration);
1856         profile_print_and_cleanup();
1857         return 0;
1858
1859 out:
1860         profile_close_perf_events(profile_obj);
1861         if (profile_obj)
1862                 profiler_bpf__destroy(profile_obj);
1863         close(profile_tgt_fd);
1864         free(profile_tgt_name);
1865         return err;
1866 }
1867
1868 #endif /* BPFTOOL_WITHOUT_SKELETONS */
1869
1870 static int do_help(int argc, char **argv)
1871 {
1872         if (json_output) {
1873                 jsonw_null(json_wtr);
1874                 return 0;
1875         }
1876
1877         fprintf(stderr,
1878                 "Usage: %1$s %2$s { show | list } [PROG]\n"
1879                 "       %1$s %2$s dump xlated PROG [{ file FILE | opcodes | visual | linum }]\n"
1880                 "       %1$s %2$s dump jited  PROG [{ file FILE | opcodes | linum }]\n"
1881                 "       %1$s %2$s pin   PROG FILE\n"
1882                 "       %1$s %2$s { load | loadall } OBJ  PATH \\\n"
1883                 "                         [type TYPE] [dev NAME] \\\n"
1884                 "                         [map { idx IDX | name NAME } MAP]\\\n"
1885                 "                         [pinmaps MAP_DIR]\n"
1886                 "       %1$s %2$s attach PROG ATTACH_TYPE [MAP]\n"
1887                 "       %1$s %2$s detach PROG ATTACH_TYPE [MAP]\n"
1888                 "       %1$s %2$s run PROG \\\n"
1889                 "                         data_in FILE \\\n"
1890                 "                         [data_out FILE [data_size_out L]] \\\n"
1891                 "                         [ctx_in FILE [ctx_out FILE [ctx_size_out M]]] \\\n"
1892                 "                         [repeat N]\n"
1893                 "       %1$s %2$s profile PROG [duration DURATION] METRICs\n"
1894                 "       %1$s %2$s tracelog\n"
1895                 "       %1$s %2$s help\n"
1896                 "\n"
1897                 "       " HELP_SPEC_MAP "\n"
1898                 "       " HELP_SPEC_PROGRAM "\n"
1899                 "       TYPE := { socket | kprobe | kretprobe | classifier | action |\n"
1900                 "                 tracepoint | raw_tracepoint | xdp | perf_event | cgroup/skb |\n"
1901                 "                 cgroup/sock | cgroup/dev | lwt_in | lwt_out | lwt_xmit |\n"
1902                 "                 lwt_seg6local | sockops | sk_skb | sk_msg | lirc_mode2 |\n"
1903                 "                 sk_reuseport | flow_dissector | cgroup/sysctl |\n"
1904                 "                 cgroup/bind4 | cgroup/bind6 | cgroup/post_bind4 |\n"
1905                 "                 cgroup/post_bind6 | cgroup/connect4 | cgroup/connect6 |\n"
1906                 "                 cgroup/getpeername4 | cgroup/getpeername6 |\n"
1907                 "                 cgroup/getsockname4 | cgroup/getsockname6 | cgroup/sendmsg4 |\n"
1908                 "                 cgroup/sendmsg6 | cgroup/recvmsg4 | cgroup/recvmsg6 |\n"
1909                 "                 cgroup/getsockopt | cgroup/setsockopt |\n"
1910                 "                 struct_ops | fentry | fexit | freplace | sk_lookup }\n"
1911                 "       ATTACH_TYPE := { msg_verdict | stream_verdict | stream_parser |\n"
1912                 "                        flow_dissector }\n"
1913                 "       METRIC := { cycles | instructions | l1d_loads | llc_misses }\n"
1914                 "       " HELP_SPEC_OPTIONS "\n"
1915                 "",
1916                 bin_name, argv[-2]);
1917
1918         return 0;
1919 }
1920
1921 static const struct cmd cmds[] = {
1922         { "show",       do_show },
1923         { "list",       do_show },
1924         { "help",       do_help },
1925         { "dump",       do_dump },
1926         { "pin",        do_pin },
1927         { "load",       do_load },
1928         { "loadall",    do_loadall },
1929         { "attach",     do_attach },
1930         { "detach",     do_detach },
1931         { "tracelog",   do_tracelog },
1932         { "run",        do_run },
1933         { "profile",    do_profile },
1934         { 0 }
1935 };
1936
1937 int do_prog(int argc, char **argv)
1938 {
1939         return cmd_select(cmds, argc, argv, do_help);
1940 }