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
 200                 snprintf(dd->scratch_buff, sizeof(dd->scratch_buff),
 201                          "0x%llx", (unsigned long long)full_imm);
 202         return dd->scratch_buff;
 203 }
 204
 205 void dump_xlated_json(struct dump_data *dd, void *buf, unsigned int len,
 206                       bool opcodes, bool linum)
 207 {
 208         const struct bpf_prog_linfo *prog_linfo = dd->prog_linfo;
 209         const struct bpf_insn_cbs cbs = {
 210                 .cb_print       = print_insn_json,
 211                 .cb_call        = print_call,
 212                 .cb_imm         = print_imm,
 213                 .private_data   = dd,
 214         };
 215         struct bpf_func_info *record;
 216         struct bpf_insn *insn = buf;
 217         struct btf *btf = dd->btf;
 218         bool double_insn = false;
 219         unsigned int nr_skip = 0;
 220         char func_sig[1024];
 221         unsigned int i;
 222
 223         jsonw_start_array(json_wtr);
 224         record = dd->func_info;
 225         for (i = 0; i < len / sizeof(*insn); i++) {
 226                 if (double_insn) {
 227                         double_insn = false;
 228                         continue;
 229                 }
 230                 double_insn = insn[i].code == (BPF_LD | BPF_IMM | BPF_DW);
 231
 232                 jsonw_start_object(json_wtr);
 233
 234                 if (btf && record) {
 235                         if (record->insn_off == i) {
 236                                 btf_dumper_type_only(btf, record->type_id,
 237                                                      func_sig,
 238                                                      sizeof(func_sig));
 239                                 if (func_sig[0] != '\0') {
 240                                         jsonw_name(json_wtr, "proto");
 241                                         jsonw_string(json_wtr, func_sig);
 242                                 }
 243                                 record = (void *)record + dd->finfo_rec_size;
 244                         }
 245                 }
 246
 247                 if (prog_linfo) {
 248                         const struct bpf_line_info *linfo;
 249
 250                         linfo = bpf_prog_linfo__lfind(prog_linfo, i, nr_skip);
 251                         if (linfo) {
 252                                 btf_dump_linfo_json(btf, linfo, linum);
 253                                 nr_skip++;
 254                         }
 255                 }
 256
 257                 jsonw_name(json_wtr, "disasm");
 258                 print_bpf_insn(&cbs, insn + i, true);
 259
 260                 if (opcodes) {
 261                         jsonw_name(json_wtr, "opcodes");
 262                         jsonw_start_object(json_wtr);
 263
 264                         jsonw_name(json_wtr, "code");
 265                         jsonw_printf(json_wtr, "\"0x%02hhx\"", insn[i].code);
 266
 267                         jsonw_name(json_wtr, "src_reg");
 268                         jsonw_printf(json_wtr, "\"0x%hhx\"", insn[i].src_reg);
 269
 270                         jsonw_name(json_wtr, "dst_reg");
 271                         jsonw_printf(json_wtr, "\"0x%hhx\"", insn[i].dst_reg);
 272
 273                         jsonw_name(json_wtr, "off");
 274                         print_hex_data_json((uint8_t *)(&insn[i].off), 2);
 275
 276                         jsonw_name(json_wtr, "imm");
 277                         if (double_insn && i < len - 1)
 278                                 print_hex_data_json((uint8_t *)(&insn[i].imm),
 279                                                     12);
 280                         else
 281                                 print_hex_data_json((uint8_t *)(&insn[i].imm),
 282                                                     4);
 283                         jsonw_end_object(json_wtr);
 284                 }
 285                 jsonw_end_object(json_wtr);
 286         }
 287         jsonw_end_array(json_wtr);
 288 }
 289
 290 void dump_xlated_plain(struct dump_data *dd, void *buf, unsigned int len,
 291                        bool opcodes, bool linum)
 292 {
 293         const struct bpf_prog_linfo *prog_linfo = dd->prog_linfo;
 294         const struct bpf_insn_cbs cbs = {
 295                 .cb_print       = print_insn,
 296                 .cb_call        = print_call,
 297                 .cb_imm         = print_imm,
 298                 .private_data   = dd,
 299         };
 300         struct bpf_func_info *record;
 301         struct bpf_insn *insn = buf;
 302         struct btf *btf = dd->btf;
 303         unsigned int nr_skip = 0;
 304         bool double_insn = false;
 305         char func_sig[1024];
 306         unsigned int i;
 307
 308         record = dd->func_info;
 309         for (i = 0; i < len / sizeof(*insn); i++) {
 310                 if (double_insn) {
 311                         double_insn = false;
 312                         continue;
 313                 }
 314
 315                 if (btf && record) {
 316                         if (record->insn_off == i) {
 317                                 btf_dumper_type_only(btf, record->type_id,
 318                                                      func_sig,
 319                                                      sizeof(func_sig));
 320                                 if (func_sig[0] != '\0')
 321                                         printf("%s:\n", func_sig);
 322                                 record = (void *)record + dd->finfo_rec_size;
 323                         }
 324                 }
 325
 326                 if (prog_linfo) {
 327                         const struct bpf_line_info *linfo;
 328
 329                         linfo = bpf_prog_linfo__lfind(prog_linfo, i, nr_skip);
 330                         if (linfo) {
 331                                 btf_dump_linfo_plain(btf, linfo, "; ",
 332                                                      linum);
 333                                 nr_skip++;
 334                         }
 335                 }
 336
 337                 double_insn = insn[i].code == (BPF_LD | BPF_IMM | BPF_DW);
 338
 339                 printf("% 4d: ", i);
 340                 print_bpf_insn(&cbs, insn + i, true);
 341
 342                 if (opcodes) {
 343                         printf("       ");
 344                         fprint_hex(stdout, insn + i, 8, " ");
 345                         if (double_insn && i < len - 1) {
 346                                 printf(" ");
 347                                 fprint_hex(stdout, insn + i + 1, 8, " ");
 348                         }
 349                         printf("\n");
 350                 }
 351         }
 352 }
 353
 354 void dump_xlated_for_graph(struct dump_data *dd, void *buf_start, void *buf_end,
 355                            unsigned int start_idx)
 356 {
 357         const struct bpf_insn_cbs cbs = {
 358                 .cb_print       = print_insn_for_graph,
 359                 .cb_call        = print_call,
 360                 .cb_imm         = print_imm,
 361                 .private_data   = dd,
 362         };
 363         struct bpf_insn *insn_start = buf_start;
 364         struct bpf_insn *insn_end = buf_end;
 365         struct bpf_insn *cur = insn_start;
 366
 367         for (; cur <= insn_end; cur++) {
 368                 printf("% 4d: ", (int)(cur - insn_start + start_idx));
 369                 print_bpf_insn(&cbs, cur, true);
 370                 if (cur != insn_end)
 371                         printf(" | ");
 372         }
 373 }