// SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
/* Copyright (C) 2018 Netronome Systems, Inc. */

#ifndef _GNU_SOURCE
#define _GNU_SOURCE
#endif
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <bpf/libbpf.h>
#include <bpf/libbpf_internal.h>

#include "disasm.h"
#include "json_writer.h"
#include "main.h"
#include "xlated_dumper.h"

static int kernel_syms_cmp(const void *sym_a, const void *sym_b)
{
        return ((struct kernel_sym *)sym_a)->address -
               ((struct kernel_sym *)sym_b)->address;
}

void kernel_syms_load(struct dump_data *dd)
{
        struct kernel_sym *sym;
        char buff[256];
        void *tmp, *address;
        FILE *fp;

        fp = fopen("/proc/kallsyms", "r");
        if (!fp)
                return;

        while (fgets(buff, sizeof(buff), fp)) {
                tmp = libbpf_reallocarray(dd->sym_mapping, dd->sym_count + 1,
                                          sizeof(*dd->sym_mapping));
                if (!tmp) {
out:
                        free(dd->sym_mapping);
                        dd->sym_mapping = NULL;
                        fclose(fp);
                        return;
                }
                dd->sym_mapping = tmp;
                sym = &dd->sym_mapping[dd->sym_count];

                /* module is optional */
                sym->module[0] = '\0';
                /* trim the square brackets around the module name */
                if (sscanf(buff, "%p %*c %s [%[^]]s", &address, sym->name, sym->module) < 2)
                        continue;
                sym->address = (unsigned long)address;
                if (!strcmp(sym->name, "__bpf_call_base")) {
                        dd->address_call_base = sym->address;
                        /* sysctl kernel.kptr_restrict was set */
                        if (!sym->address)
                                goto out;
                }
                if (sym->address)
                        dd->sym_count++;
        }

        fclose(fp);

        qsort(dd->sym_mapping, dd->sym_count,
              sizeof(*dd->sym_mapping), kernel_syms_cmp);
}

void kernel_syms_destroy(struct dump_data *dd)
{
        free(dd->sym_mapping);
}

struct kernel_sym *kernel_syms_search(struct dump_data *dd,
                                      unsigned long key)
{
        struct kernel_sym sym = {
                .address = key,
        };

        return dd->sym_mapping ?
               bsearch(&sym, dd->sym_mapping, dd->sym_count,
                       sizeof(*dd->sym_mapping), kernel_syms_cmp) : NULL;
}

static void __printf(2, 3) print_insn(void *private_data, const char *fmt, ...)
{
        va_list args;

        va_start(args, fmt);
        vprintf(fmt, args);
        va_end(args);
}

static void __printf(2, 3)
print_insn_for_graph(void *private_data, const char *fmt, ...)
{
        char buf[64], *p;
        va_list args;

        va_start(args, fmt);
        vsnprintf(buf, sizeof(buf), fmt, args);
        va_end(args);

        p = buf;
        while (*p != '\0') {
                if (*p == '\n') {
                        memmove(p + 3, p, strlen(buf) + 1 - (p - buf));
                        /* Align each instruction dump row left. */
                        *p++ = '\\';
                        *p++ = 'l';
                        /* Output multiline concatenation. */
                        *p++ = '\\';
                } else if (*p == '<' || *p == '>' || *p == '|' || *p == '&') {
                        memmove(p + 1, p, strlen(buf) + 1 - (p - buf));
                        /* Escape special character. */
                        *p++ = '\\';
                }

                p++;
        }

        printf("%s", buf);
}

static void __printf(2, 3)
print_insn_json(void *private_data, const char *fmt, ...)
{
        unsigned int l = strlen(fmt);
        char chomped_fmt[l];
        va_list args;

        va_start(args, fmt);
        if (l > 0) {
                strncpy(chomped_fmt, fmt, l - 1);
                chomped_fmt[l - 1] = '\0';
        }
        jsonw_vprintf_enquote(json_wtr, chomped_fmt, args);
        va_end(args);
}

static const char *print_call_pcrel(struct dump_data *dd,
                                    struct kernel_sym *sym,
                                    unsigned long address,
                                    const struct bpf_insn *insn)
{
        if (!dd->nr_jited_ksyms)
                /* Do not show address for interpreted programs */
                snprintf(dd->scratch_buff, sizeof(dd->scratch_buff),
                        "%+d", insn->off);
        else if (sym)
                snprintf(dd->scratch_buff, sizeof(dd->scratch_buff),
                         "%+d#%s", insn->off, sym->name);
        else
                snprintf(dd->scratch_buff, sizeof(dd->scratch_buff),
                         "%+d#0x%lx", insn->off, address);
        return dd->scratch_buff;
}

static const char *print_call_helper(struct dump_data *dd,
                                     struct kernel_sym *sym,
                                     unsigned long address)
{
        if (sym)
                snprintf(dd->scratch_buff, sizeof(dd->scratch_buff),
                         "%s", sym->name);
        else
                snprintf(dd->scratch_buff, sizeof(dd->scratch_buff),
                         "0x%lx", address);
        return dd->scratch_buff;
}

static const char *print_call(void *private_data,
                              const struct bpf_insn *insn)
{
        struct dump_data *dd = private_data;
        unsigned long address = dd->address_call_base + insn->imm;
        struct kernel_sym *sym;

        if (insn->src_reg == BPF_PSEUDO_CALL &&
            (__u32) insn->imm < dd->nr_jited_ksyms && dd->jited_ksyms)
                address = dd->jited_ksyms[insn->imm];

        sym = kernel_syms_search(dd, address);
        if (insn->src_reg == BPF_PSEUDO_CALL)
                return print_call_pcrel(dd, sym, address, insn);
        else
                return print_call_helper(dd, sym, address);
}

static const char *print_imm(void *private_data,
                             const struct bpf_insn *insn,
                             __u64 full_imm)
{
        struct dump_data *dd = private_data;

        if (insn->src_reg == BPF_PSEUDO_MAP_FD)
                snprintf(dd->scratch_buff, sizeof(dd->scratch_buff),
                         "map[id:%d]", insn->imm);
        else if (insn->src_reg == BPF_PSEUDO_MAP_VALUE)
                snprintf(dd->scratch_buff, sizeof(dd->scratch_buff),
                         "map[id:%d][0]+%d", insn->imm, (insn + 1)->imm);
        else if (insn->src_reg == BPF_PSEUDO_MAP_IDX_VALUE)
                snprintf(dd->scratch_buff, sizeof(dd->scratch_buff),
                         "map[idx:%d]+%d", insn->imm, (insn + 1)->imm);
        else if (insn->src_reg == BPF_PSEUDO_FUNC)
                snprintf(dd->scratch_buff, sizeof(dd->scratch_buff),
                         "subprog[%+d]", insn->imm);
        else
                snprintf(dd->scratch_buff, sizeof(dd->scratch_buff),
                         "0x%llx", (unsigned long long)full_imm);
        return dd->scratch_buff;
}

void dump_xlated_json(struct dump_data *dd, void *buf, unsigned int len,
                      bool opcodes, bool linum)
{
        const struct bpf_prog_linfo *prog_linfo = dd->prog_linfo;
        const struct bpf_insn_cbs cbs = {
                .cb_print       = print_insn_json,
                .cb_call        = print_call,
                .cb_imm         = print_imm,
                .private_data   = dd,
        };
        struct bpf_func_info *record;
        struct bpf_insn *insn = buf;
        struct btf *btf = dd->btf;
        bool double_insn = false;
        unsigned int nr_skip = 0;
        char func_sig[1024];
        unsigned int i;

        jsonw_start_array(json_wtr);
        record = dd->func_info;
        for (i = 0; i < len / sizeof(*insn); i++) {
                if (double_insn) {
                        double_insn = false;
                        continue;
                }
                double_insn = insn[i].code == (BPF_LD | BPF_IMM | BPF_DW);

                jsonw_start_object(json_wtr);

                if (btf && record) {
                        if (record->insn_off == i) {
                                btf_dumper_type_only(btf, record->type_id,
                                                     func_sig,
                                                     sizeof(func_sig));
                                if (func_sig[0] != '\0') {
                                        jsonw_name(json_wtr, "proto");
                                        jsonw_string(json_wtr, func_sig);
                                }
                                record = (void *)record + dd->finfo_rec_size;
                        }
                }

                if (prog_linfo) {
                        const struct bpf_line_info *linfo;

                        linfo = bpf_prog_linfo__lfind(prog_linfo, i, nr_skip);
                        if (linfo) {
                                btf_dump_linfo_json(btf, linfo, linum);
                                nr_skip++;
                        }
                }

                jsonw_name(json_wtr, "disasm");
                print_bpf_insn(&cbs, insn + i, true);

                if (opcodes) {
                        jsonw_name(json_wtr, "opcodes");
                        jsonw_start_object(json_wtr);

                        jsonw_name(json_wtr, "code");
                        jsonw_printf(json_wtr, "\"0x%02hhx\"", insn[i].code);

                        jsonw_name(json_wtr, "src_reg");
                        jsonw_printf(json_wtr, "\"0x%hhx\"", insn[i].src_reg);

                        jsonw_name(json_wtr, "dst_reg");
                        jsonw_printf(json_wtr, "\"0x%hhx\"", insn[i].dst_reg);

                        jsonw_name(json_wtr, "off");
                        print_hex_data_json((uint8_t *)(&insn[i].off), 2);

                        jsonw_name(json_wtr, "imm");
                        if (double_insn && i < len - 1)
                                print_hex_data_json((uint8_t *)(&insn[i].imm),
                                                    12);
                        else
                                print_hex_data_json((uint8_t *)(&insn[i].imm),
                                                    4);
                        jsonw_end_object(json_wtr);
                }
                jsonw_end_object(json_wtr);
        }
        jsonw_end_array(json_wtr);
}

void dump_xlated_plain(struct dump_data *dd, void *buf, unsigned int len,
                       bool opcodes, bool linum)
{
        const struct bpf_prog_linfo *prog_linfo = dd->prog_linfo;
        const struct bpf_insn_cbs cbs = {
                .cb_print       = print_insn,
                .cb_call        = print_call,
                .cb_imm         = print_imm,
                .private_data   = dd,
        };
        struct bpf_func_info *record;
        struct bpf_insn *insn = buf;
        struct btf *btf = dd->btf;
        unsigned int nr_skip = 0;
        bool double_insn = false;
        char func_sig[1024];
        unsigned int i;

        record = dd->func_info;
        for (i = 0; i < len / sizeof(*insn); i++) {
                if (double_insn) {
                        double_insn = false;
                        continue;
                }

                if (btf && record) {
                        if (record->insn_off == i) {
                                btf_dumper_type_only(btf, record->type_id,
                                                     func_sig,
                                                     sizeof(func_sig));
                                if (func_sig[0] != '\0')
                                        printf("%s:\n", func_sig);
                                record = (void *)record + dd->finfo_rec_size;
                        }
                }

                if (prog_linfo) {
                        const struct bpf_line_info *linfo;

                        linfo = bpf_prog_linfo__lfind(prog_linfo, i, nr_skip);
                        if (linfo) {
                                btf_dump_linfo_plain(btf, linfo, "; ",
                                                     linum);
                                nr_skip++;
                        }
                }

                double_insn = insn[i].code == (BPF_LD | BPF_IMM | BPF_DW);

                printf("%4u: ", i);
                print_bpf_insn(&cbs, insn + i, true);

                if (opcodes) {
                        printf("       ");
                        fprint_hex(stdout, insn + i, 8, " ");
                        if (double_insn && i < len - 1) {
                                printf(" ");
                                fprint_hex(stdout, insn + i + 1, 8, " ");
                        }
                        printf("\n");
                }
        }
}

void dump_xlated_for_graph(struct dump_data *dd, void *buf_start, void *buf_end,
                           unsigned int start_idx,
                           bool opcodes, bool linum)
{
        const struct bpf_insn_cbs cbs = {
                .cb_print       = print_insn_for_graph,
                .cb_call        = print_call,
                .cb_imm         = print_imm,
                .private_data   = dd,
        };
        const struct bpf_prog_linfo *prog_linfo = dd->prog_linfo;
        const struct bpf_line_info *last_linfo = NULL;
        struct bpf_func_info *record = dd->func_info;
        struct bpf_insn *insn_start = buf_start;
        struct bpf_insn *insn_end = buf_end;
        struct bpf_insn *cur = insn_start;
        struct btf *btf = dd->btf;
        bool double_insn = false;
        char func_sig[1024];

        for (; cur <= insn_end; cur++) {
                unsigned int insn_off;

                if (double_insn) {
                        double_insn = false;
                        continue;
                }
                double_insn = cur->code == (BPF_LD | BPF_IMM | BPF_DW);

                insn_off = (unsigned int)(cur - insn_start + start_idx);
                if (btf && record) {
                        if (record->insn_off == insn_off) {
                                btf_dumper_type_only(btf, record->type_id,
                                                     func_sig,
                                                     sizeof(func_sig));
                                if (func_sig[0] != '\0')
                                        printf("; %s:\\l\\\n", func_sig);
                                record = (void *)record + dd->finfo_rec_size;
                        }
                }

                if (prog_linfo) {
                        const struct bpf_line_info *linfo;

                        linfo = bpf_prog_linfo__lfind(prog_linfo, insn_off, 0);
                        if (linfo && linfo != last_linfo) {
                                btf_dump_linfo_dotlabel(btf, linfo, linum);
                                last_linfo = linfo;
                        }
                }

                printf("%u: ", insn_off);
                print_bpf_insn(&cbs, cur, true);

                if (opcodes) {
                        printf("\\ \\ \\ \\ ");
                        fprint_hex(stdout, cur, 8, " ");
                        if (double_insn && cur <= insn_end - 1) {
                                printf(" ");
                                fprint_hex(stdout, cur + 1, 8, " ");
                        }
                        printf("\\l\\\n");
                }

                if (cur != insn_end)
                        printf("| ");
        }
}