/*
 * 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
 */

#include <sys/proc.h>
#include <c2/audit.h>
#include <sys/procfs.h>
#include <sys/core.h>

/*
 * This function is meant to be a guaranteed abort that generates a core file
 * that allows up to 1k of data to enter into an elfnote in the process. This is
 * meant to insure that even in the face of other problems, this can get out.
 */

void
upanic(void *addr, size_t len)
{
        kthread_t *t = curthread;
        proc_t *p = curproc;
        klwp_t *lwp = ttolwp(t);
        uint32_t auditing = AU_AUDITING();
        uint32_t upflag = P_UPF_PANICKED;
        void *buf;
        int code;

        /*
         * Before we worry about the data that the user has as a message, go
         * ahead and make sure we try and get all the other threads stopped.
         * That'll help us make sure that nothing else is going on and we don't
         * lose a race.
         */
        mutex_enter(&p->p_lock);
        lwp->lwp_cursig = SIGABRT;
        mutex_exit(&p->p_lock);

        proc_is_exiting(p);
        if (exitlwps(1) != 0) {
                mutex_enter(&p->p_lock);
                lwp_exit();
        }

        /*
         * Copy in the user data. We truncate it to PRUPANIC_BUFLEN no matter
         * what and ensure that the last data was set to zero.
         */
        if (addr != NULL && len > 0) {
                size_t copylen;

                upflag |= P_UPF_HAVEMSG;

                if (len >= PRUPANIC_BUFLEN) {
                        copylen = PRUPANIC_BUFLEN;
                        upflag |= P_UPF_TRUNCMSG;
                } else {
                        copylen = len;
                }

                buf = kmem_zalloc(PRUPANIC_BUFLEN, KM_SLEEP);
                if (copyin(addr, buf, copylen) != 0) {
                        upflag |= P_UPF_INVALMSG;
                        upflag &= ~P_UPF_HAVEMSG;
                } else {
                        mutex_enter(&p->p_lock);
                        ASSERT3P(p->p_upanic, ==, NULL);
                        p->p_upanic = buf;
                        mutex_exit(&p->p_lock);
                }
        }

        mutex_enter(&p->p_lock);
        p->p_upanicflag = upflag;
        mutex_exit(&p->p_lock);

        /*
         * If we're auditing we need to finish the system call itself and then
         * begin the core dump.
         */
        if (auditing) {
                audit_finish(0, SYS_upanic, 0, NULL);
                audit_core_start(SIGABRT);
        }
        code = core(SIGABRT, B_FALSE);
        if (auditing)           /* audit core dump */
                audit_core_finish(code ? CLD_KILLED : CLD_DUMPED);
        exit(code ? CLD_KILLED : CLD_DUMPED, SIGABRT);
}