/*
 * This file and its contents are supplied under the terms of the
 * Common Development and Distribution License ("CDDL"), version 1.0.
 * You may only use this file in accordance with the terms of version
 * 1.0 of the CDDL.
 *
 * A full copy of the text of the CDDL should have accompanied this
 * source.  A copy of the CDDL is also available via the Internet at
 * http://www.illumos.org/license/CDDL.
 */

/*
 * Copyright 2021 Oxide Computer Company
 */

/*
 * Check that a given core dump generated as part of our test framework has the
 * sections that we'd expect. We have here the dumper binary. In that, we expect
 * to find the following libraries and sections:
 *
 *   a.out:             symtab, ctf, .debug_* (dwarf)
 *   ld.so.1:           symtab
 *   libc.so:           symtab, ctf
 *   libproc.so:        symtab, ctf
 *   libdumper.so:      symtab, ctf, .debug_* (dwarf)
 *
 * Note, there will also be additional libraries and things here can change over
 * time (e.g. deps of libproc, etc.), but we try to ignore them generally
 * speaking if we can know enough to do so.
 */

#include <err.h>
#include <stdlib.h>
#include <libproc.h>
#include <gelf.h>
#include <libelf.h>
#include <limits.h>
#include <string.h>
#include <libgen.h>

typedef enum {
        SECMAP_CTF,
        SECMAP_SYMTAB,
        SECMAP_DEBUG,
        SECMAP_MAX
} secmap_type_t;

typedef struct secmap_data {
        core_content_t  sd_content;
        const char      *sd_name;
} secmap_data_t;

secmap_data_t secmap_data[SECMAP_MAX] = {
        { CC_CONTENT_CTF, ".SUNW_ctf" },
        { CC_CONTENT_SYMTAB, ".symtab" },
        { CC_CONTENT_DEBUG, ".debug_" }
};

typedef struct {
        uint64_t        sm_addr;
        char            sm_obj[PATH_MAX];
        size_t          sm_nfound[SECMAP_MAX];
        Elf             *sm_elf;
        GElf_Ehdr       sm_ehdr;
        boolean_t       sm_ctf;
        boolean_t       sm_debug;
        boolean_t       sm_symtab;
} secmap_t;

static secmap_t *secmaps;
static size_t secmap_count;
static core_content_t secmap_content;

static int secmap_exit = EXIT_SUCCESS;

static void
secmap_fail(const char *fmt, ...)
{
        va_list ap;

        va_start(ap, fmt);
        vwarnx(fmt, ap);
        va_end(ap);
        secmap_exit = EXIT_FAILURE;
}


static void
check_content(core_content_t content, struct ps_prochandle *Pr)
{
        secmap_content = Pcontent(Pr);

        if (secmap_content == CC_CONTENT_INVALID) {
                secmap_fail("TEST FAILED: failed to get core content");
                return;
        }

        if (secmap_content != content) {
                secmap_fail("TEST FAILED: core file contains different "
                    "content than expected, found 0x%x, expected 0x%x",
                    secmap_content, content);
        }
}

static secmap_t *
secmap_find(uint64_t addr)
{
        for (size_t i = 0; i < secmap_count; i++) {
                if (secmaps[i].sm_addr == addr) {
                        return (&secmaps[i]);
                }
        }

        return (NULL);
}

static void
secmap_matches_content(secmap_type_t type)
{
        boolean_t exist = (secmap_data[type].sd_content & secmap_content) != 0;
        boolean_t found = B_FALSE;

        /*
         * Dumping CTF data implies that some symbol tables will exist for CTF.
         */
        if (type == SECMAP_SYMTAB && (secmap_content & CC_CONTENT_CTF) != 0) {
                exist = B_TRUE;
        }

        for (size_t i = 0; i < secmap_count; i++) {
                if (secmaps[i].sm_nfound[type] != 0) {
                        found = B_TRUE;
                }
        }

        if (exist != found) {
                secmap_fail("content type mismatch for %s: expected %s, but "
                    "found %s", secmap_data[type].sd_name,
                    exist ? "some" : "none",
                    found ? "some" : "none");
        }
}

static secmap_t *
secmap_alloc(struct ps_prochandle *Pr, uint64_t addr)
{
        int fd;
        secmap_t *sm;
        char *base;

        sm = recallocarray(secmaps, secmap_count, secmap_count + 1,
            sizeof (secmap_t));
        if (sm == NULL) {
                err(EXIT_FAILURE, "TEST FAILED: failed to allocate memory for "
                    "secmap %zu", secmap_count + 1);
        }

        secmaps = sm;
        sm = &secmaps[secmap_count];
        sm->sm_addr = addr;
        secmap_count++;

        /*
         * We also have some tests that we don't expect to have anything here
         * because we only include the relevant sections. Experimentally, we
         * know that libproc needs both anon and data mappings for this to work.
         * So if we don't have both, then we'll not warn on that.
         */
        if (Pobjname(Pr, addr, sm->sm_obj, sizeof (sm->sm_obj)) == NULL) {
                core_content_t need = CC_CONTENT_ANON | CC_CONTENT_DATA;

                if ((secmap_content & need) == need) {
                        secmap_fail("TEST FAILURE: object at address 0x%lx "
                            "has no name", addr);
                }

                return (sm);
        }

        /*
         * Since we have a name, we should be able to open this elf object and
         * identify it as well.
         */
        fd = open(sm->sm_obj, O_RDONLY);
        if (fd < 0) {
                err(EXIT_FAILURE, "failed to open object %s", sm->sm_obj);
        }

        sm->sm_elf = elf_begin(fd, ELF_C_READ, NULL);
        if (sm->sm_elf == NULL) {
                err(EXIT_FAILURE, "failed to find open elf object %s: %s",
                    sm->sm_obj, elf_errmsg(elf_errno()));
        }

        if (gelf_getehdr(sm->sm_elf, &sm->sm_ehdr) == NULL) {
                err(EXIT_FAILURE, "failed to get ehdr for %s: %s",
                    sm->sm_obj, elf_errmsg(elf_errno()));
        }

        base = basename(sm->sm_obj);
        if (strcmp(base, "dumper.32") == 0 || strcmp(base, "dumper.64") == 0) {
                sm->sm_debug = sm->sm_symtab = sm->sm_ctf = B_TRUE;
        } else if (strcmp(base, "libc.so.1") == 0) {
                sm->sm_symtab = sm->sm_ctf = B_TRUE;
        } else if (strcmp(base, "ld.so.1") == 0) {
                sm->sm_symtab = B_TRUE;
        } else if (strcmp(base, "libproc.so.1") == 0) {
                sm->sm_symtab = sm->sm_ctf = B_TRUE;
        } else if (strcmp(base,  "libdumper.so.1") == 0) {
                sm->sm_debug = sm->sm_symtab = sm->sm_ctf = B_TRUE;
        } else {
                sm->sm_symtab = B_TRUE;
        }

        return (sm);
}

static void
secmap_data_cmp(secmap_t *sm, const char *sname, Elf_Scn *scn, GElf_Shdr *shdr)
{
        for (Elf_Scn *comp_scn = elf_nextscn(sm->sm_elf, NULL);
            comp_scn != NULL; comp_scn = elf_nextscn(sm->sm_elf, comp_scn)) {
                GElf_Shdr comp_shdr;
                const char *comp_name;
                Elf_Data *src_data, *comp_data;

                if (gelf_getshdr(comp_scn, &comp_shdr) == NULL) {
                        secmap_fail("failed to load section header from %s "
                            "during data comparison", sm->sm_obj);
                        return;
                }

                comp_name = elf_strptr(sm->sm_elf, sm->sm_ehdr.e_shstrndx,
                    comp_shdr.sh_name);
                if (comp_name == NULL) {
                        secmap_fail("failed to load section name from %s "
                            "with index %lu", sm->sm_obj, comp_shdr.sh_name);
                        return;
                }

                if (strcmp(comp_name, sname) != 0)
                        continue;

                if (comp_shdr.sh_type != shdr->sh_type ||
                    comp_shdr.sh_addralign != shdr->sh_addralign ||
                    comp_shdr.sh_size != shdr->sh_size ||
                    comp_shdr.sh_entsize != shdr->sh_entsize) {
                        continue;
                }

                if ((src_data = elf_getdata(scn, NULL)) == NULL) {
                        secmap_fail("failed to load section data from "
                            "source to compare to %s %s", sm->sm_obj, sname);
                        return;
                }

                if ((comp_data = elf_getdata(comp_scn, NULL)) == NULL) {
                        secmap_fail("failed to load section data from "
                            "source to compare to %s %s", sm->sm_obj, sname);
                        return;
                }

                if (comp_data->d_size != src_data->d_size) {
                        secmap_fail("data size mismatch for %s: %s, core: "
                            "%zu, file: %zu", sm->sm_obj, sname,
                            src_data->d_size, comp_data->d_size);
                        return;
                }

                if (memcmp(comp_data->d_buf, src_data->d_buf,
                    comp_data->d_size) != 0) {
                        secmap_fail("data mismatch between core and source "
                            "in %s: %s", sm->sm_obj, sname);
                        return;
                }

                return;
        }

        secmap_fail("failed to find matching section for %s in %s",
            sname, sm->sm_obj);
}

static void
secmap_file_check(secmap_t *sm)
{
        if (sm->sm_ctf && (secmap_content & CC_CONTENT_CTF) != 0 &&
            sm->sm_nfound[SECMAP_CTF] == 0) {
                secmap_fail("expected object %s to have CTF, but it doesn't",
                    sm->sm_obj);
        }

        if (sm->sm_symtab && (secmap_content & CC_CONTENT_SYMTAB) != 0 &&
            sm->sm_nfound[SECMAP_SYMTAB] == 0) {
                secmap_fail("expected object %s to have a symbol table, "
                    "but it doesn't", sm->sm_obj);
        }

        if (sm->sm_debug && (secmap_content & CC_CONTENT_DEBUG) != 0 &&
            sm->sm_nfound[SECMAP_DEBUG] == 0) {
                secmap_fail("expected object %s to have debug sections, "
                    "but it doesn't", sm->sm_obj);
        }
}

int
main(int argc, char *argv[])
{
        core_content_t content;
        struct ps_prochandle *Pr;
        int perr, fd;
        Elf *elf;
        Elf_Scn *scn;
        GElf_Ehdr ehdr;

        if (argc != 3) {
                warnx("missing required file and core content");
                (void) fprintf(stderr, "Usage: secmapper file content\n");
                exit(EXIT_FAILURE);
        }

        if (elf_version(EV_CURRENT) == EV_NONE) {
                errx(EXIT_FAILURE, "failed to init libelf");
        }

        Pr = Pgrab_core(argv[1], NULL, PGRAB_RDONLY, &perr);
        if (Pr == NULL) {
                errx(EXIT_FAILURE, "failed to open %s: %s", argv[1],
                    Pgrab_error(perr));
        }

        if ((fd = open(argv[1], O_RDONLY)) < 0) {
                err(EXIT_FAILURE, "failed to open %s\n", argv[1]);
        }

        if ((elf = elf_begin(fd, ELF_C_READ, NULL)) == NULL) {
                errx(EXIT_FAILURE, "failed to open elf file %s: %s", argv[1],
                    elf_errmsg(elf_errno()));
        }

        if (proc_str2content(argv[2], &content) != 0) {
                err(EXIT_FAILURE, "failed to parse content %s", argv[2]);
        }

        if (gelf_getehdr(elf, &ehdr) == NULL) {
                errx(EXIT_FAILURE, "failed to get edr: %s",
                    elf_errmsg(elf_errno()));
        }

        /*
         * Before we go futher, make sure that we have the content in this file
         * that we expect.
         */
        check_content(content, Pr);

        for (scn = elf_nextscn(elf, NULL); scn != NULL;
            scn = elf_nextscn(elf, scn)) {
                const char *sname;
                GElf_Shdr shdr;
                size_t index;
                secmap_t *secmap;

                index = elf_ndxscn(scn);
                if (gelf_getshdr(scn, &shdr) ==  NULL) {
                        errx(EXIT_FAILURE, "failed to get section header for "
                            "shdr %zu: %s", index, elf_errmsg(elf_errno()));
                }

                /*
                 * Skip the strtab.
                 */
                if (shdr.sh_type == SHT_STRTAB) {
                        continue;
                }

                sname = elf_strptr(elf, ehdr.e_shstrndx, shdr.sh_name);
                if (sname == NULL) {
                        secmap_fail("TEST FAILURE: string name missing for "
                            "shdr %zu", index);
                        continue;
                }

                /*
                 * Find or cons up a new secmap for this object.
                 */
                secmap = secmap_find(shdr.sh_addr);
                if (secmap == NULL) {
                        secmap = secmap_alloc(Pr, shdr.sh_addr);
                }

                if (strcmp(sname, ".symtab") == 0) {
                        secmap->sm_nfound[SECMAP_SYMTAB]++;
                } else if (strcmp(sname, ".SUNW_ctf") == 0) {
                        secmap->sm_nfound[SECMAP_CTF]++;
                } else if (strncmp(sname, ".debug_", strlen(".debug_")) == 0) {
                        secmap->sm_nfound[SECMAP_DEBUG]++;
                } else {
                        continue;
                }

                /*
                 * For one of our three primary sections, make sure that the
                 * data that is in the core file that we find in it actually
                 * matches the underlying object. That is, if the secmap
                 * actually has something here.
                 */
                if (secmap->sm_elf != NULL) {
                        secmap_data_cmp(secmap, sname, scn, &shdr);
                }
        }

        /*
         * Now that we have iterated over all of these sections, check and make
         * sure certain things are true of them. In particular, go through some
         * of the various types of data and make sure it exists at all or
         * doesn't based on our core content.
         */
        secmap_matches_content(SECMAP_CTF);
        secmap_matches_content(SECMAP_SYMTAB);
        secmap_matches_content(SECMAP_DEBUG);

        /*
         * Finally, if we have enough information to know that we've found
         * a file that we know it should at least have a given type of data,
         * check for it. Here, it is OK for data to be present we don't expect
         * (assuming the core content allows it). This makes this test less
         * prone to broader changes in the system.
         */
        for (size_t i = 0; i < secmap_count; i++) {
                secmap_file_check(&secmaps[i]);
        }

        return (secmap_exit);
}