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