tools/bpf/bpftool/xlated_dumper.c

   1 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
   2 /* Copyright (C) 2018 Netronome Systems, Inc. */
   3
   4 #define _GNU_SOURCE
   5 #include <stdarg.h>
   6 #include <stdio.h>
   7 #include <stdlib.h>
   8 #include <string.h>
   9 #include <sys/types.h>
  10 #include <bpf/libbpf.h>
  11
  12 #include "disasm.h"
  13 #include "json_writer.h"
  14 #include "main.h"
  15 #include "xlated_dumper.h"
  16
  17 static int kernel_syms_cmp(const void *sym_a, const void *sym_b)
  18 {
  19         return ((struct kernel_sym *)sym_a)->address -
  20                ((struct kernel_sym *)sym_b)->address;
  21 }
  22
  23 void kernel_syms_load(struct dump_data *dd)
  24 {
  25         struct kernel_sym *sym;
  26         char buff[256];
  27         void *tmp, *address;
  28         FILE *fp;
  29
  30         fp = fopen("/proc/kallsyms", "r");
  31         if (!fp)
  32                 return;
  33
  34         while (fgets(buff, sizeof(buff), fp)) {
  35                 tmp = reallocarray(dd->sym_mapping, dd->sym_count + 1,
  36                                    sizeof(*dd->sym_mapping));
  37                 if (!tmp) {
  38 out:
  39                         free(dd->sym_mapping);
  40                         dd->sym_mapping = NULL;
  41                         fclose(fp);
  42                         return;
  43                 }
  44                 dd->sym_mapping = tmp;
  45                 sym = &dd->sym_mapping[dd->sym_count];
  46                 if (sscanf(buff, "%p %*c %s", &address, sym->name) != 2)
  47                         continue;
  48                 sym->address = (unsigned long)address;
  49                 if (!strcmp(sym->name, "__bpf_call_base")) {
  50                         dd->address_call_base = sym->address;
  51                         /* sysctl kernel.kptr_restrict was set */
  52                         if (!sym->address)
  53                                 goto out;
  54                 }
  55                 if (sym->address)
  56                         dd->sym_count++;
  57         }
  58
  59         fclose(fp);
  60
  61         qsort(dd->sym_mapping, dd->sym_count,
  62               sizeof(*dd->sym_mapping), kernel_syms_cmp);
  63 }
  64
  65 void kernel_syms_destroy(struct dump_data *dd)
  66 {
  67         free(dd->sym_mapping);
  68 }
  69
  70 struct kernel_sym *kernel_syms_search(struct dump_data *dd,
  71                                       unsigned long key)
  72 {
  73         struct kernel_sym sym = {
  74                 .address = key,
  75         };
  76
  77         return dd->sym_mapping ?
  78                bsearch(&sym, dd->sym_mapping, dd->sym_count,
  79                        sizeof(*dd->sym_mapping), kernel_syms_cmp) : NULL;
  80 }
  81
  82 static void __printf(2, 3) print_insn(void *private_data, const char *fmt, ...)
  83 {
  84         va_list args;
  85
  86         va_start(args, fmt);
  87         vprintf(fmt, args);
  88         va_end(args);
  89 }
  90
  91 static void __printf(2, 3)
  92 print_insn_for_graph(void *private_data, const char *fmt, ...)
  93 {
  94         char buf[64], *p;
  95         va_list args;
  96
  97         va_start(args, fmt);
  98         vsnprintf(buf, sizeof(buf), fmt, args);
  99         va_end(args);
 100
 101         p = buf;
 102         while (*p != '\0') {
 103                 if (*p == '\n') {
 104                         memmove(p + 3, p, strlen(buf) + 1 - (p - buf));
 105                         /* Align each instruction dump row left. */
 106                         *p++ = '\\';
 107                         *p++ = 'l';
 108                         /* Output multiline concatenation. */
 109                         *p++ = '\\';
 110                 } else if (*p == '<' || *p == '>' || *p == '|' || *p == '&') {
 111                         memmove(p + 1, p, strlen(buf) + 1 - (p - buf));
 112                         /* Escape special character. */
 113                         *p++ = '\\';
 114                 }
 115
 116                 p++;
 117         }
 118
 119         printf("%s", buf);
 120 }
 121
 122 static void __printf(2, 3)
 123 print_insn_json(void *private_data, const char *fmt, ...)
 124 {
 125         unsigned int l = strlen(fmt);
 126         char chomped_fmt[l];
 127         va_list args;
 128
 129         va_start(args, fmt);
 130         if (l > 0) {
 131                 strncpy(chomped_fmt, fmt, l - 1);
 132                 chomped_fmt[l - 1] = '\0';
 133         }
 134         jsonw_vprintf_enquote(json_wtr, chomped_fmt, args);
 135         va_end(args);
 136 }
 137
 138 static const char *print_call_pcrel(struct dump_data *dd,
 139                                     struct kernel_sym *sym,
 140                                     unsigned long address,
 141                                     const struct bpf_insn *insn)
 142 {
 143         if (!dd->nr_jited_ksyms)
 144                 /* Do not show address for interpreted programs */
 145                 snprintf(dd->scratch_buff, sizeof(dd->scratch_buff),
 146                         "%+d", insn->off);
 147         else if (sym)
 148                 snprintf(dd->scratch_buff, sizeof(dd->scratch_buff),
 149                          "%+d#%s", insn->off, sym->name);
 150         else
 151                 snprintf(dd->scratch_buff, sizeof(dd->scratch_buff),
 152                          "%+d#0x%lx", insn->off, address);
 153         return dd->scratch_buff;
 154 }
 155
 156 static const char *print_call_helper(struct dump_data *dd,
 157                                      struct kernel_sym *sym,
 158                                      unsigned long address)
 159 {
 160         if (sym)
 161                 snprintf(dd->scratch_buff, sizeof(dd->scratch_buff),
 162                          "%s", sym->name);
 163         else
 164                 snprintf(dd->scratch_buff, sizeof(dd->scratch_buff),
 165                          "0x%lx", address);
 166         return dd->scratch_buff;
 167 }
 168
 169 static const char *print_call(void *private_data,
 170                               const struct bpf_insn *insn)
 171 {
 172         struct dump_data *dd = private_data;
 173         unsigned long address = dd->address_call_base + insn->imm;
 174         struct kernel_sym *sym;
 175
 176         if (insn->src_reg == BPF_PSEUDO_CALL &&
 177             (__u32) insn->imm < dd->nr_jited_ksyms && dd->jited_ksyms)
 178                 address = dd->jited_ksyms[insn->imm];
 179
 180         sym = kernel_syms_search(dd, address);
 181         if (insn->src_reg == BPF_PSEUDO_CALL)
 182                 return print_call_pcrel(dd, sym, address, insn);
 183         else
 184                 return print_call_helper(dd, sym, address);
 185 }
 186
 187 static const char *print_imm(void *private_data,
 188                              const struct bpf_insn *insn,
 189                              __u64 full_imm)
 190 {
 191         struct dump_data *dd = private_data;
 192
 193         if (insn->src_reg == BPF_PSEUDO_MAP_FD)
 194                 snprintf(dd->scratch_buff, sizeof(dd->scratch_buff),
 195                          "map[id:%u]", insn->imm);
 196         else if (insn->src_reg == BPF_PSEUDO_MAP_VALUE)
 197                 snprintf(dd->scratch_buff, sizeof(dd->scratch_buff),
 198                          "map[id:%u][0]+%u", insn->imm, (insn + 1)->imm);
 199         else if (insn->src_reg == BPF_PSEUDO_MAP_IDX_VALUE)
 200                 snprintf(dd->scratch_buff, sizeof(dd->scratch_buff),
 201                          "map[idx:%u]+%u", insn->imm, (insn + 1)->imm);
 202         else if (insn->src_reg == BPF_PSEUDO_FUNC)
 203                 snprintf(dd->scratch_buff, sizeof(dd->scratch_buff),
 204                          "subprog[%+d]", insn->imm);
 205         else
 206                 snprintf(dd->scratch_buff, sizeof(dd->scratch_buff),
 207                          "0x%llx", (unsigned long long)full_imm);
 208         return dd->scratch_buff;
 209 }
 210
 211 void dump_xlated_json(struct dump_data *dd, void *buf, unsigned int len,
 212                       bool opcodes, bool linum)
 213 {
 214         const struct bpf_prog_linfo *prog_linfo = dd->prog_linfo;
 215         const struct bpf_insn_cbs cbs = {
 216                 .cb_print       = print_insn_json,
 217                 .cb_call        = print_call,
 218                 .cb_imm         = print_imm,
 219                 .private_data   = dd,
 220         };
 221         struct bpf_func_info *record;
 222         struct bpf_insn *insn = buf;
 223         struct btf *btf = dd->btf;
 224         bool double_insn = false;
 225         unsigned int nr_skip = 0;
 226         char func_sig[1024];
 227         unsigned int i;
 228
 229         jsonw_start_array(json_wtr);
 230         record = dd->func_info;
 231         for (i = 0; i < len / sizeof(*insn); i++) {
 232                 if (double_insn) {
 233                         double_insn = false;
 234                         continue;
 235                 }
 236                 double_insn = insn[i].code == (BPF_LD | BPF_IMM | BPF_DW);
 237
 238                 jsonw_start_object(json_wtr);
 239
 240                 if (btf && record) {
 241                         if (record->insn_off == i) {
 242                                 btf_dumper_type_only(btf, record->type_id,
 243                                                      func_sig,
 244                                                      sizeof(func_sig));
 245                                 if (func_sig[0] != '\0') {
 246                                         jsonw_name(json_wtr, "proto");
 247                                         jsonw_string(json_wtr, func_sig);
 248                                 }
 249                                 record = (void *)record + dd->finfo_rec_size;
 250                         }
 251                 }
 252
 253                 if (prog_linfo) {
 254                         const struct bpf_line_info *linfo;
 255
 256                         linfo = bpf_prog_linfo__lfind(prog_linfo, i, nr_skip);
 257                         if (linfo) {
 258                                 btf_dump_linfo_json(btf, linfo, linum);
 259                                 nr_skip++;
 260                         }
 261                 }
 262
 263                 jsonw_name(json_wtr, "disasm");
 264                 print_bpf_insn(&cbs, insn + i, true);
 265
 266                 if (opcodes) {
 267                         jsonw_name(json_wtr, "opcodes");
 268                         jsonw_start_object(json_wtr);
 269
 270                         jsonw_name(json_wtr, "code");
 271                         jsonw_printf(json_wtr, "\"0x%02hhx\"", insn[i].code);
 272
 273                         jsonw_name(json_wtr, "src_reg");
 274                         jsonw_printf(json_wtr, "\"0x%hhx\"", insn[i].src_reg);
 275
 276                         jsonw_name(json_wtr, "dst_reg");
 277                         jsonw_printf(json_wtr, "\"0x%hhx\"", insn[i].dst_reg);
 278
 279                         jsonw_name(json_wtr, "off");
 280                         print_hex_data_json((uint8_t *)(&insn[i].off), 2);
 281
 282                         jsonw_name(json_wtr, "imm");
 283                         if (double_insn && i < len - 1)
 284                                 print_hex_data_json((uint8_t *)(&insn[i].imm),
 285                                                     12);
 286                         else
 287                                 print_hex_data_json((uint8_t *)(&insn[i].imm),
 288                                                     4);
 289                         jsonw_end_object(json_wtr);
 290                 }
 291                 jsonw_end_object(json_wtr);
 292         }
 293         jsonw_end_array(json_wtr);
 294 }
 295
 296 void dump_xlated_plain(struct dump_data *dd, void *buf, unsigned int len,
 297                        bool opcodes, bool linum)
 298 {
 299         const struct bpf_prog_linfo *prog_linfo = dd->prog_linfo;
 300         const struct bpf_insn_cbs cbs = {
 301                 .cb_print       = print_insn,
 302                 .cb_call        = print_call,
 303                 .cb_imm         = print_imm,
 304                 .private_data   = dd,
 305         };
 306         struct bpf_func_info *record;
 307         struct bpf_insn *insn = buf;
 308         struct btf *btf = dd->btf;
 309         unsigned int nr_skip = 0;
 310         bool double_insn = false;
 311         char func_sig[1024];
 312         unsigned int i;
 313
 314         record = dd->func_info;
 315         for (i = 0; i < len / sizeof(*insn); i++) {
 316                 if (double_insn) {
 317                         double_insn = false;
 318                         continue;
 319                 }
 320
 321                 if (btf && record) {
 322                         if (record->insn_off == i) {
 323                                 btf_dumper_type_only(btf, record->type_id,
 324                                                      func_sig,
 325                                                      sizeof(func_sig));
 326                                 if (func_sig[0] != '\0')
 327                                         printf("%s:\n", func_sig);
 328                                 record = (void *)record + dd->finfo_rec_size;
 329                         }
 330                 }
 331
 332                 if (prog_linfo) {
 333                         const struct bpf_line_info *linfo;
 334
 335                         linfo = bpf_prog_linfo__lfind(prog_linfo, i, nr_skip);
 336                         if (linfo) {
 337                                 btf_dump_linfo_plain(btf, linfo, "; ",
 338                                                      linum);
 339                                 nr_skip++;
 340                         }
 341                 }
 342
 343                 double_insn = insn[i].code == (BPF_LD | BPF_IMM | BPF_DW);
 344
 345                 printf("% 4d: ", i);
 346                 print_bpf_insn(&cbs, insn + i, true);
 347
 348                 if (opcodes) {
 349                         printf("       ");
 350                         fprint_hex(stdout, insn + i, 8, " ");
 351                         if (double_insn && i < len - 1) {
 352                                 printf(" ");
 353                                 fprint_hex(stdout, insn + i + 1, 8, " ");
 354                         }
 355                         printf("\n");
 356                 }
 357         }
 358 }
 359
 360 void dump_xlated_for_graph(struct dump_data *dd, void *buf_start, void *buf_end,
 361                            unsigned int start_idx)
 362 {
 363         const struct bpf_insn_cbs cbs = {
 364                 .cb_print       = print_insn_for_graph,
 365                 .cb_call        = print_call,
 366                 .cb_imm         = print_imm,
 367                 .private_data   = dd,
 368         };
 369         struct bpf_insn *insn_start = buf_start;
 370         struct bpf_insn *insn_end = buf_end;
 371         struct bpf_insn *cur = insn_start;
 372
 373         for (; cur <= insn_end; cur++) {
 374                 printf("% 4d: ", (int)(cur - insn_start + start_idx));
 375                 print_bpf_insn(&cbs, cur, true);
 376                 if (cur != insn_end)
 377                         printf(" | ");
 378         }
 379 }