/*
 * 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 2019 Joyent, Inc.
 * Copyright 2020 OmniOS Community Edition (OmniOSce) Association.
 */

/*
 * Create CTF from extant debugging information
 */

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdarg.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <libelf.h>
#include <libctf.h>
#include <string.h>
#include <libgen.h>
#include <limits.h>
#include <strings.h>
#include <sys/debug.h>

#define CTFCONVERT_OK           0
#define CTFCONVERT_FATAL        1
#define CTFCONVERT_USAGE        2

static char *ctfconvert_progname;

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

        (void) fprintf(stderr, "%s: ", ctfconvert_progname);
        va_start(ap, fmt);
        (void) vfprintf(stderr, fmt, ap);
        va_end(ap);

        exit(CTFCONVERT_FATAL);
}

static void
ctfconvert_warning(void *arg, const char *fmt, ...)
{
        va_list ap;
        char *buf;

        va_start(ap, fmt);
        if (vasprintf(&buf, fmt, ap) != -1) {
                (void) fprintf(stderr, "%s: WARNING: %s", ctfconvert_progname,
                    buf);
                free(buf);
        }
        va_end(ap);
}

static void
ctfconvert_usage(const char *fmt, ...)
{
        if (fmt != NULL) {
                va_list ap;

                (void) fprintf(stderr, "%s: ", ctfconvert_progname);
                va_start(ap, fmt);
                (void) vfprintf(stderr, fmt, ap);
                va_end(ap);
        }

        (void) fprintf(stderr, "Usage: %s [-fikms] [-j nthrs] [-l label | "
            "-L labelenv] [-b batchsize]\n"
            "                  [-o outfile] [-M ignorefile] input\n"
            "\n"
            "\t-b  batch process this many dies at a time (default %d)\n"
            "\t-f  always attempt to convert files\n"
            "\t-i  ignore files not built partially from C sources\n"
            "\t-j  use nthrs threads to perform the merge (default %d)\n"
            "\t-k  keep around original input file on failure\n"
            "\t-l  set output container's label to specified value\n"
            "\t-L  set output container's label to value from environment\n"
            "\t-m  allow input to have missing debug info\n"
            "\t-M  allow files listed in ignorefile to have missing debug\n"
            "\t-o  copy input to outfile and add CTF\n"
            "\t-s  allow truncation of data that cannot be fully converted\n",
            ctfconvert_progname,
            CTF_CONVERT_DEFAULT_BATCHSIZE,
            CTF_CONVERT_DEFAULT_NTHREADS);
}

/*
 * This is a bit unfortunate. Traditionally we do type uniquification across all
 * modules in the kernel, including ip and unix against genunix. However, when
 * _MACHDEP is defined, then the cpu_t ends up having an additional member
 * (cpu_m), thus changing the ability for us to uniquify against it. This in
 * turn causes a lot of type sprawl, as there's a lot of things that end up
 * referring to the cpu_t and it chains out from there.
 *
 * So, if we find that a cpu_t has been defined and it has a couple of useful
 * sentinel members and it does *not* have the cpu_m member, then we will try
 * and lookup or create a forward declaration to the machcpu, append it to the
 * end, and update the file.
 *
 * This currently is only invoked if an undocumented option -X is passed. This
 * value is private to illumos and it can be changed at any time inside of it,
 * so if -X wants to be used for something, it should be. The ability to rely on
 * -X for others is strictly not an interface in any way, shape, or form.
 *
 * The following struct contains most of the information that we care about and
 * that we want to validate exists before we decide what to do.
 */

typedef struct ctfconvert_fixup {
        boolean_t       cf_cyclic;      /* Do we have a cpu_cyclic member */
        boolean_t       cf_mcpu;        /* We have a cpu_m member */
        boolean_t       cf_lastpad;     /* Is the pad member the last entry */
        ulong_t         cf_padoff;      /* offset of the pad */
} ctfconvert_fixup_t;

/* ARGSUSED */
static int
ctfconvert_fixup_genunix_cb(const char *name, ctf_id_t tid, ulong_t off,
    void *arg)
{
        ctfconvert_fixup_t *cfp = arg;

        cfp->cf_lastpad = B_FALSE;
        if (strcmp(name, "cpu_cyclic") == 0) {
                cfp->cf_cyclic = B_TRUE;
                return (0);
        }

        if (strcmp(name, "cpu_m") == 0) {
                cfp->cf_mcpu = B_TRUE;
                return (0);
        }

        if (strcmp(name, "cpu_m_pad") == 0) {
                cfp->cf_lastpad = B_TRUE;
                cfp->cf_padoff = off;
                return (0);
        }

        return (0);
}

static void
ctfconvert_fixup_genunix(ctf_file_t *fp)
{
        ctf_id_t cpuid, mcpu;
        ssize_t sz;
        ctfconvert_fixup_t cf;
        int model, ptrsz;

        cpuid = ctf_lookup_by_name(fp, "struct cpu");
        if (cpuid == CTF_ERR)
                return;

        if (ctf_type_kind(fp, cpuid) != CTF_K_STRUCT)
                return;

        if ((sz = ctf_type_size(fp, cpuid)) == CTF_ERR)
                return;

        model = ctf_getmodel(fp);
        VERIFY(model == CTF_MODEL_ILP32 || model == CTF_MODEL_LP64);
        ptrsz = model == CTF_MODEL_ILP32 ? 4 : 8;

        bzero(&cf, sizeof (ctfconvert_fixup_t));
        if (ctf_member_iter(fp, cpuid, ctfconvert_fixup_genunix_cb, &cf) ==
            CTF_ERR)
                return;

        /*
         * Finally, we want to verify that the cpu_m is actually the last member
         * that we have here.
         */
        if (cf.cf_cyclic == B_FALSE || cf.cf_mcpu == B_TRUE ||
            cf.cf_lastpad == B_FALSE) {
                return;
        }

        if (cf.cf_padoff + ptrsz * NBBY != sz * NBBY) {
                return;
        }

        /*
         * Okay, we're going to do this, try to find a struct machcpu. We either
         * want a forward or a struct. If we find something else, error. If we
         * find nothing, add a forward and then add the member.
         */
        mcpu = ctf_lookup_by_name(fp, "struct machcpu");
        if (mcpu == CTF_ERR) {
                mcpu = ctf_add_forward(fp, CTF_ADD_NONROOT, "machcpu",
                    CTF_K_STRUCT);
                if (mcpu == CTF_ERR) {
                        ctfconvert_fatal("failed to add 'struct machcpu' "
                            "forward: %s\n", ctf_errmsg(ctf_errno(fp)));
                }
        } else {
                int kind;
                if ((kind = ctf_type_kind(fp, mcpu)) == CTF_ERR) {
                        ctfconvert_fatal("failed to get the type kind for "
                            "the struct machcpu: %s\n",
                            ctf_errmsg(ctf_errno(fp)));
                }

                if (kind != CTF_K_STRUCT && kind != CTF_K_FORWARD)
                        ctfconvert_fatal("encountered a struct machcpu of the "
                            "wrong type, found type kind %d\n", kind);
        }

        if (ctf_update(fp) == CTF_ERR) {
                ctfconvert_fatal("failed to update output file: %s\n",
                    ctf_errmsg(ctf_errno(fp)));
        }

        if (ctf_add_member(fp, cpuid, "cpu_m", mcpu, sz * NBBY) == CTF_ERR) {
                ctfconvert_fatal("failed to add the m_cpu member: %s\n",
                    ctf_errmsg(ctf_errno(fp)));
        }

        if (ctf_update(fp) == CTF_ERR) {
                ctfconvert_fatal("failed to update output file: %s\n",
                    ctf_errmsg(ctf_errno(fp)));
        }

        VERIFY(ctf_type_size(fp, cpuid) == sz);
}

int
main(int argc, char *argv[])
{
        int c, ifd, err;
        boolean_t keep = B_FALSE;
        ctf_convert_flag_t flags = 0;
        uint_t bsize = CTF_CONVERT_DEFAULT_BATCHSIZE;
        uint_t nthreads = CTF_CONVERT_DEFAULT_NTHREADS;
        const char *outfile = NULL;
        const char *label = NULL;
        const char *infile = NULL;
        const char *ignorefile = NULL;
        char *tmpfile;
        ctf_file_t *ofp;
        char buf[4096] = "";
        boolean_t optx = B_FALSE;
        boolean_t ignore_non_c = B_FALSE;
        ctf_convert_t *cch;

        ctfconvert_progname = basename(argv[0]);

        while ((c = getopt(argc, argv, ":b:fij:kl:L:mM:o:sX")) != -1) {
                switch (c) {
                case 'b': {
                        long argno;
                        const char *errstr;

                        argno = strtonum(optarg, 1, UINT_MAX, &errstr);
                        if (errstr != NULL) {
                                ctfconvert_fatal("invalid argument for -b: "
                                    "%s - %s\n", optarg, errstr);
                        }
                        bsize = (uint_t)argno;
                        break;
                }
                case 'f':
                        flags |= CTF_FORCE_CONVERSION;
                        break;
                case 'i':
                        ignore_non_c = B_TRUE;
                        break;
                case 'j': {
                        long argno;
                        const char *errstr;

                        argno = strtonum(optarg, 1, 1024, &errstr);
                        if (errstr != NULL) {
                                ctfconvert_fatal("invalid argument for -j: "
                                    "%s - %s\n", optarg, errstr);
                        }
                        nthreads = (uint_t)argno;
                        break;
                }
                case 'k':
                        keep = B_TRUE;
                        break;
                case 'l':
                        label = optarg;
                        break;
                case 'L':
                        label = getenv(optarg);
                        break;
                case 'm':
                        flags |= CTF_ALLOW_MISSING_DEBUG;
                        break;
                case 'M':
                        ignorefile = optarg;
                        break;
                case 'o':
                        outfile = optarg;
                        break;
                case 's':
                        flags |= CTF_ALLOW_TRUNCATION;
                        break;
                case 'X':
                        optx = B_TRUE;
                        break;
                case ':':
                        ctfconvert_usage("Option -%c requires an operand\n",
                            optopt);
                        return (CTFCONVERT_USAGE);
                case '?':
                        ctfconvert_usage("Unknown option: -%c\n", optopt);
                        return (CTFCONVERT_USAGE);
                }
        }

        argv += optind;
        argc -= optind;

        if (argc != 1) {
                ctfconvert_usage("Exactly one input file is required\n");
                return (CTFCONVERT_USAGE);
        }
        infile = argv[0];

        if (elf_version(EV_CURRENT) == EV_NONE)
                ctfconvert_fatal("failed to initialize libelf: library is "
                    "out of date\n");

        ifd = open(infile, O_RDONLY);
        if (ifd < 0) {
                ctfconvert_fatal("failed to open input file %s: %s\n", infile,
                    strerror(errno));
        }

        /*
         * By default we remove the input file on failure unless we've been
         * given an output file or -k has been specified.
         */
        if (outfile != NULL && strcmp(infile, outfile) != 0)
                keep = B_TRUE;

        cch = ctf_convert_init(&err);
        if (cch == NULL) {
                ctfconvert_fatal(
                    "failed to create libctf conversion handle: %s\n",
                    strerror(err));
        }
        if ((err = ctf_convert_set_nthreads(cch, nthreads)) != 0)
                ctfconvert_fatal("Could not set number of threads: %s\n",
                    strerror(err));
        if ((err = ctf_convert_set_batchsize(cch, bsize)) != 0)
                ctfconvert_fatal("Could not set batch size: %s\n",
                    strerror(err));
        if ((err = ctf_convert_set_flags(cch, flags)) != 0)
                ctfconvert_fatal("Could not set conversion flags: %s\n",
                    strerror(err));
        if (label != NULL && (err = ctf_convert_set_label(cch, label)) != 0)
                ctfconvert_fatal("Could not set label: %s\n",
                    strerror(err));
        if ((err = ctf_convert_set_warncb(cch, ctfconvert_warning, NULL)) != 0)
                ctfconvert_fatal("Could not set warning callback: %s\n",
                    strerror(err));

        if (ignorefile != NULL) {
                char *buf = NULL;
                ssize_t cnt;
                size_t len = 0;
                FILE *fp;

                if ((fp = fopen(ignorefile, "r")) == NULL) {
                        ctfconvert_fatal("Could not open ignorefile '%s': %s\n",
                            ignorefile, strerror(errno));
                }

                while ((cnt = getline(&buf, &len, fp)) != -1) {
                        char *p = buf;

                        if (cnt == 0 || *p == '#')
                                continue;

                        (void) strsep(&p, "\n");
                        if ((err = ctf_convert_add_ignore(cch, buf)) != 0) {
                                ctfconvert_fatal(
                                    "Failed to add '%s' to ignore list: %s\n",
                                    buf, strerror(err));
                        }
                }
                free(buf);
                if (cnt == -1 && ferror(fp) != 0) {
                        ctfconvert_fatal(
                            "Error reading from ignorefile '%s': %s\n",
                            ignorefile, strerror(errno));
                }

                (void) fclose(fp);
        }

        ofp = ctf_fdconvert(cch, ifd, &err, buf, sizeof (buf));

        ctf_convert_fini(cch);

        if (ofp == NULL) {
                /*
                 * Normally, ctfconvert requires that its input file has at
                 * least one C-source compilation unit, and that every C-source
                 * compilation unit has DWARF. This is to avoid accidentally
                 * leaving out useful CTF.
                 *
                 * However, for the benefit of intransigent build environments,
                 * the -i and -m options can be used to relax this.
                 */
                if (err == ECTF_CONVNOCSRC && ignore_non_c) {
                        exit(CTFCONVERT_OK);
                }

                if (err == ECTF_CONVNODEBUG &&
                    (flags & CTF_ALLOW_MISSING_DEBUG) != 0) {
                        exit(CTFCONVERT_OK);
                }

                if (keep == B_FALSE)
                        (void) unlink(infile);

                /*
                 * Note, we expect libctf to include a newline it all of its
                 * error messages right now (though it perhaps shouldn't).
                 */
                switch (err) {
                case ECTF_CONVBKERR:
                        ctfconvert_fatal("CTF conversion failed: %s", buf);
                        break;
                case ECTF_CONVNODEBUG:
                        ctfconvert_fatal("CTF conversion failed due to "
                            "missing debug data; use -m to override\n");
                        break;
                default:
                        if (*buf != '\0') {
                                (void) fprintf(stderr, "%s: %s",
                                    ctfconvert_progname, buf);
                        }
                        ctfconvert_fatal("CTF conversion failed: %s\n",
                            ctf_errmsg(err));
                }
        }

        if (optx == B_TRUE)
                ctfconvert_fixup_genunix(ofp);

        tmpfile = NULL;
        if (outfile == NULL || strcmp(infile, outfile) == 0) {
                if (asprintf(&tmpfile, "%s.ctf", infile) == -1) {
                        if (keep == B_FALSE)
                                (void) unlink(infile);
                        ctfconvert_fatal("failed to allocate memory for "
                            "temporary file: %s\n", strerror(errno));
                }
                outfile = tmpfile;
        }
        err = ctf_elfwrite(ofp, infile, outfile, CTF_ELFWRITE_F_COMPRESS);
        if (err == CTF_ERR) {
                (void) unlink(outfile);
                if (keep == B_FALSE)
                        (void) unlink(infile);
                ctfconvert_fatal("failed to write CTF section to output file: "
                    "%s\n", ctf_errmsg(ctf_errno(ofp)));
        }
        ctf_close(ofp);

        if (tmpfile != NULL) {
                if (rename(tmpfile, infile) != 0) {
                        int e = errno;
                        (void) unlink(outfile);
                        if (keep == B_FALSE)
                                (void) unlink(infile);
                        ctfconvert_fatal("failed to rename temporary file: "
                            "%s\n", strerror(e));
                }
        }
        free(tmpfile);

        return (CTFCONVERT_OK);
}