/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * Copyright 2018 Joyent, Inc.
 * Copyright (c) 2013 by Delphix. All rights reserved.
 * Copyright 2023 Oxide Computer Company
 */

#include <sys/types.h>
#include <sys/uio.h>
#include <string.h>
#include <errno.h>
#include <limits.h>

#include "Pcontrol.h"
#include "P32ton.h"

/*
 * This file implements the routines to read and write per-lwp register
 * information from either a live process or core file opened with libproc.  We
 * build up a few common routines for reading and writing register information,
 * and then the public functions are all trivial calls to these.  It also
 * implements similar logic that is used with an lwp handle.
 *
 * The primary registers and floating point registers (e.g. regs,fpregs) are
 * retreived from the lwp and process status files.  The library caches the
 * values of these files.  When we perorm updates, we ensure that cached copies
 * are refreshed or updated as part of this.
 */

/*
 * Utility function to return a pointer to the structure of cached information
 * about an lwp in the core file, given its lwpid.
 */
static lwp_info_t *
getlwpcore(struct ps_prochandle *P, lwpid_t lwpid)
{
        core_info_t *core = P->data;
        lwp_info_t *lwp;

        for (lwp = list_head(&core->core_lwp_head); lwp != NULL;
            lwp = list_next(&core->core_lwp_head, lwp)) {
                if (lwp->lwp_id == lwpid)
                        return (lwp);
        }

        errno = ENOENT;
        return (NULL);
}

/*
 * Utility function to open and read the contents of a per-lwp /proc file.
 * This function is used to slurp in lwpstatus, lwpname, lwpsinfo, spymaster,
 * and others.
 */
static int
getlwpfile(struct ps_prochandle *P, lwpid_t lwpid,
    const char *fbase, void *rp, size_t n)
{
        char fname[PATH_MAX];
        int fd;

        (void) snprintf(fname, sizeof (fname), "%s/%d/lwp/%d/%s",
            procfs_path, (int)P->status.pr_pid, (int)lwpid, fbase);

        if ((fd = open(fname, O_RDONLY)) >= 0) {
                if (read(fd, rp, n) > 0) {
                        (void) close(fd);
                        return (0);
                }

                int e = errno;
                (void) close(fd);
                errno = e;
        }
        return (-1);
}

/*
 * This is a variant of getlwpfile that has three different semantics:
 *
 *  o It will stat the file to determine the size and allocate that for the
 *    caller.
 *  o If the stat size is zero (e.g. traditional xregs behavior when
 *    unsupported) then it will return the libproc ENODATA error.
 *  o It is an error if not all the data is read.
 *
 * Currently this is just used by xregs.
 */
static int
getlwpfile_alloc(struct ps_prochandle *P, lwpid_t lwpid, const char *fbase,
    void **datap, size_t *sizep)
{
        char fname[PATH_MAX];
        int fd;

        (void) snprintf(fname, sizeof (fname), "%s/%d/lwp/%d/%s",
            procfs_path, (int)P->status.pr_pid, (int)lwpid, fbase);

        if ((fd = open(fname, O_RDONLY)) >= 0) {
                int e;
                struct stat st;

                if (fstat(fd, &st) == 0) {
                        prxregset_t *prx;

                        if (st.st_size == 0) {
                                errno = ENODATA;
                                goto clean;
                        }

                        prx = malloc(st.st_size);
                        if (prx == NULL) {
                                goto clean;
                        }

                        if (read(fd, prx, st.st_size) == st.st_size) {
                                (void) close(fd);
                                *datap = prx;
                                *sizep = st.st_size;
                                return (0);
                        }

                        free(prx);
                }
clean:
                e = errno;
                (void) close(fd);
                errno = e;
        }

        return (-1);
}

/*
 * Get the lwpstatus_t for an lwp from either the live process or our
 * cached information from the core file.  This is used to get the
 * general-purpose registers or floating point registers.
 */
int
getlwpstatus(struct ps_prochandle *P, lwpid_t lwpid, lwpstatus_t *lps)
{
        lwp_info_t *lwp;

        /*
         * For both live processes and cores, our job is easy if the lwpid
         * matches that of the representative lwp:
         */
        if (P->status.pr_lwp.pr_lwpid == lwpid) {
                (void) memcpy(lps, &P->status.pr_lwp, sizeof (lwpstatus_t));
                return (0);
        }

        /*
         * If this is a live process, then just read the information out
         * of the per-lwp status file:
         */
        if (P->state != PS_DEAD) {
                return (getlwpfile(P, lwpid, "lwpstatus",
                    lps, sizeof (lwpstatus_t)));
        }

        /*
         * If this is a core file, we need to iterate through our list of
         * cached lwp information and then copy out the status.
         */
        if (P->data != NULL && (lwp = getlwpcore(P, lwpid)) != NULL) {
                (void) memcpy(lps, &lwp->lwp_status, sizeof (lwpstatus_t));
                return (0);
        }

        return (-1);
}

/*
 * libproc caches information about the registers for representative LWPs and
 * threads which we have the thread handle for. When we do a write to certain
 * files, we need to refresh state and take care of both the process and the
 * representative LWP's info. Because the xregs may or may not mutate the state
 * of the other regsiters, we just always do a refresh of the entire cached
 * psinfo.
 */
static void
refresh_status(struct ps_prochandle *P, lwpid_t lwpid, struct ps_lwphandle *L,
    long cmd, const void *rp, size_t n)
{
        if (P->status.pr_lwp.pr_lwpid == lwpid) {
                if (cmd == PCSREG)
                        (void) memcpy(P->status.pr_lwp.pr_reg, rp, n);
                else if (cmd == PCSFPREG)
                        (void) memcpy(&P->status.pr_lwp.pr_fpreg, rp, n);
                else if (cmd == PCSXREG)
                        (void) Pstopstatus(P, PCNULL, 0);
        }

        if (L != NULL) {
                if (cmd == PCSREG)
                        (void) memcpy(&L->lwp_status.pr_reg, rp, n);
                else if (cmd == PCSFPREG)
                        (void) memcpy(&L->lwp_status.pr_fpreg, rp, n);
                else if (cmd == PCSXREG)
                        (void) Lstopstatus(L, PCNULL, 0);
        }
}

/*
 * Utility function to modify lwp registers.  This is done using either the
 * process control file or per-lwp control file as necessary.  This assumes that
 * we have a process-level hold on things, which may not always be true.
 */
static int
setlwpregs_proc(struct ps_prochandle *P, lwpid_t lwpid, long cmd,
    const void *rp, size_t n)
{
        iovec_t iov[2];
        char fname[PATH_MAX];
        struct ps_lwphandle *L;
        int fd = -1;

        if (P->state != PS_STOP) {
                errno = EBUSY;
                return (-1);
        }

        iov[0].iov_base = (caddr_t)&cmd;
        iov[0].iov_len = sizeof (long);
        iov[1].iov_base = (caddr_t)rp;
        iov[1].iov_len = n;

        /*
         * If we have an lwp handle for this thread, then make sure that we use
         * that to update the state so cached information is updated.  We sync
         * the thread ahead of the process.
         */
        if ((L = Lfind(P, lwpid)) != NULL) {
                Lsync(L);
                fd = L->lwp_ctlfd;
        }

        /*
         * Writing the process control file writes the representative lwp.
         * Psync before we write to make sure we are consistent with the
         * primary interfaces.  Similarly, make sure to update P->status
         * afterward if we are modifying one of its register sets.  On some
         * platforms the xregs cover the base integer or floating point
         * registers.  As a result, always refresh the representative LWP's
         * status.
         */
        if (P->status.pr_lwp.pr_lwpid == lwpid) {
                Psync(P);
                fd = P->ctlfd;
        }

        if (fd > -1) {
                if (writev(fd, iov, 2) == -1)
                        return (-1);
                refresh_status(P, lwpid, L, cmd, rp, n);
                return (0);
        }

        /*
         * If the lwp we want is not the representative lwp, we need to
         * open the ctl file for that specific lwp.
         */
        (void) snprintf(fname, sizeof (fname), "%s/%d/lwp/%d/lwpctl",
            procfs_path, (int)P->status.pr_pid, (int)lwpid);

        if ((fd = open(fname, O_WRONLY)) >= 0) {
                if (writev(fd, iov, 2) > 0) {
                        (void) close(fd);
                        return (0);
                }
                int e = errno;
                (void) close(fd);
                errno = e;
        }
        return (-1);
}

/*
 * This is a variant of the above that only assumes we have a hold on the thread
 * as opposed to a process.
 */
static int
setlwpregs_lwp(struct ps_lwphandle *L, long cmd, const void *rp, size_t n)
{
        iovec_t iov[2];

        if (L->lwp_state != PS_STOP) {
                errno = EBUSY;
                return (-1);
        }

        iov[0].iov_base = (caddr_t)&cmd;
        iov[0].iov_len = sizeof (long);
        iov[1].iov_base = (caddr_t)rp;
        iov[1].iov_len = n;

        Lsync(L);
        if (writev(L->lwp_ctlfd, iov, 2) == -1)
                return (-1);
        refresh_status(L->lwp_proc, L->lwp_id, L, cmd, rp, n);

        return (0);
}

int
Plwp_getregs(struct ps_prochandle *P, lwpid_t lwpid, prgregset_t gregs)
{
        lwpstatus_t lps;

        if (getlwpstatus(P, lwpid, &lps) == -1)
                return (-1);

        (void) memcpy(gregs, lps.pr_reg, sizeof (prgregset_t));
        return (0);
}

int
Lgetregs(struct ps_lwphandle *L, prgregset_t *gregs)
{
        (void) memcpy(gregs, L->lwp_status.pr_reg, sizeof (prgregset_t));
        return (0);
}

int
Plwp_setregs(struct ps_prochandle *P, lwpid_t lwpid, const prgregset_t gregs)
{
        return (setlwpregs_proc(P, lwpid, PCSREG, gregs, sizeof (prgregset_t)));
}

int
Lsetregs(struct ps_lwphandle *L, const prgregset_t *gregs)
{
        return (setlwpregs_lwp(L, PCSREG, gregs, sizeof (prgregset_t)));
}

int
Plwp_getfpregs(struct ps_prochandle *P, lwpid_t lwpid, prfpregset_t *fpregs)
{
        lwpstatus_t lps;

        if (getlwpstatus(P, lwpid, &lps) == -1)
                return (-1);

        (void) memcpy(fpregs, &lps.pr_fpreg, sizeof (prfpregset_t));
        return (0);
}

int
Lgetfpregs(struct ps_lwphandle *L, prfpregset_t *fpregs)
{
        (void) memcpy(fpregs, &L->lwp_status.pr_fpreg, sizeof (prfpregset_t));
        return (0);
}

int
Plwp_setfpregs(struct ps_prochandle *P, lwpid_t lwpid,
    const prfpregset_t *fpregs)
{
        return (setlwpregs_proc(P, lwpid, PCSFPREG, fpregs,
            sizeof (prfpregset_t)));
}

int
Lsetfpregs(struct ps_lwphandle *L, const prfpregset_t *fpregs)
{
        return (setlwpregs_lwp(L, PCSFPREG, fpregs, sizeof (prfpregset_t)));
}

/*
 * The reason that this is structured to take both the size and the process
 * handle is so that way we have enough information to tie this back to its
 * underlying source and we can eventually use umem with this.
 */
void
Plwp_freexregs(struct ps_prochandle *P __unused, prxregset_t *prx,
    size_t size __unused)
{
        free(prx);
}

/*
 * Get a given thread's lwp registers. If this is a core file, we read it from
 * the cache. If this is a live process, we always read it from the underlying
 * file system because we do not currently cache xregs in libproc. sizep is the
 * resulting size of data we've allocated and for a live process is filled in
 * based on the /proc stat(2) information.
 */
int
Plwp_getxregs(struct ps_prochandle *P, lwpid_t lwpid, prxregset_t **xregs,
    size_t *sizep)
{
        lwp_info_t *lwp;

        if (P->state == PS_IDLE) {
                errno = ENODATA;
                return (-1);
        }

        if (P->state != PS_DEAD) {
                if (P->state != PS_STOP) {
                        errno = EBUSY;
                        return (-1);
                }

                return (getlwpfile_alloc(P, lwpid, "xregs",
                    (void **)xregs, sizep));
        }

        if ((lwp = getlwpcore(P, lwpid)) != NULL && lwp->lwp_xregs != NULL &&
            lwp->lwp_xregsize > 0) {
                *xregs = malloc(lwp->lwp_xregsize);
                if (*xregs == NULL)
                        return (-1);
                (void) memcpy(*xregs, lwp->lwp_xregs, lwp->lwp_xregsize);
                *sizep = lwp->lwp_xregsize;
                return (0);
        }

        if (lwp != NULL)
                errno = ENODATA;
        return (-1);
}

int
Lgetxregs(struct ps_lwphandle *L, prxregset_t **xregs, size_t *sizep)
{
        lwp_info_t *lwp;

        if (L->lwp_state != PS_DEAD) {
                if (L->lwp_state != PS_STOP) {
                        errno = EBUSY;
                        return (-1);
                }
                return (getlwpfile_alloc(L->lwp_proc, L->lwp_id, "xregs",
                    (void **)xregs, sizep));
        }

        if ((lwp = getlwpcore(L->lwp_proc, L->lwp_id)) != NULL &&
            lwp->lwp_xregs != NULL && lwp->lwp_xregsize > 0) {
                *xregs = malloc(lwp->lwp_xregsize);
                if (*xregs == NULL)
                        return (-1);
                (void) memcpy(*xregs, lwp->lwp_xregs, lwp->lwp_xregsize);
                *sizep = lwp->lwp_xregsize;
                return (0);
        }

        if (lwp != NULL)
                errno = ENODATA;
        return (-1);
}

int
Plwp_setxregs(struct ps_prochandle *P, lwpid_t lwpid, const prxregset_t *xregs,
    size_t len)
{
        return (setlwpregs_proc(P, lwpid, PCSXREG, xregs, len));
}

int
Lsetxregs(struct ps_lwphandle *L, const prxregset_t *xregs, size_t len)
{
        return (setlwpregs_lwp(L, PCSXREG, xregs, len));
}

#if defined(sparc) || defined(__sparc)
int
Plwp_getgwindows(struct ps_prochandle *P, lwpid_t lwpid, gwindows_t *gwins)
{
        lwp_info_t *lwp;

        if (P->state == PS_IDLE) {
                errno = ENODATA;
                return (-1);
        }

        if (P->state != PS_DEAD) {
                if (P->state != PS_STOP) {
                        errno = EBUSY;
                        return (-1);
                }

                return (getlwpfile(P, lwpid, "gwindows",
                    gwins, sizeof (gwindows_t)));
        }

        if ((lwp = getlwpcore(P, lwpid)) != NULL && lwp->lwp_gwins != NULL) {
                *gwins = *lwp->lwp_gwins;
                return (0);
        }

        if (lwp != NULL)
                errno = ENODATA;
        return (-1);
}

#if defined(__sparcv9)
int
Plwp_getasrs(struct ps_prochandle *P, lwpid_t lwpid, asrset_t asrs)
{
        lwp_info_t *lwp;

        if (P->state == PS_IDLE) {
                errno = ENODATA;
                return (-1);
        }

        if (P->state != PS_DEAD) {
                if (P->state != PS_STOP) {
                        errno = EBUSY;
                        return (-1);
                }

                return (getlwpfile(P, lwpid, "asrs", asrs, sizeof (asrset_t)));
        }

        if ((lwp = getlwpcore(P, lwpid)) != NULL && lwp->lwp_asrs != NULL) {
                (void) memcpy(asrs, lwp->lwp_asrs, sizeof (asrset_t));
                return (0);
        }

        if (lwp != NULL)
                errno = ENODATA;
        return (-1);

}

int
Plwp_setasrs(struct ps_prochandle *P, lwpid_t lwpid, const asrset_t asrs)
{
        return (setlwpregs_proc(P, lwpid, PCSASRS, asrs, sizeof (asrset_t)));
}
#endif  /* __sparcv9 */
#endif  /* __sparc */

int
Plwp_getpsinfo(struct ps_prochandle *P, lwpid_t lwpid, lwpsinfo_t *lps)
{
        lwp_info_t *lwp;

        if (P->state == PS_IDLE) {
                errno = ENODATA;
                return (-1);
        }

        if (P->state != PS_DEAD) {
                return (getlwpfile(P, lwpid, "lwpsinfo",
                    lps, sizeof (lwpsinfo_t)));
        }

        if ((lwp = getlwpcore(P, lwpid)) != NULL) {
                (void) memcpy(lps, &lwp->lwp_psinfo, sizeof (lwpsinfo_t));
                return (0);
        }

        return (-1);
}

int
Plwp_getname(struct ps_prochandle *P, lwpid_t lwpid,
    char *buf, size_t bufsize)
{
        char lwpname[THREAD_NAME_MAX];
        char *from = NULL;
        lwp_info_t *lwp;

        if (P->state == PS_IDLE) {
                errno = ENODATA;
                return (-1);
        }

        if (P->state != PS_DEAD) {
                if (getlwpfile(P, lwpid, "lwpname",
                    lwpname, sizeof (lwpname)) != 0)
                        return (-1);
                from = lwpname;
        } else {
                if ((lwp = getlwpcore(P, lwpid)) == NULL)
                        return (-1);
                from = lwp->lwp_name;
        }

        if (strlcpy(buf, from, bufsize) >= bufsize) {
                errno = ENAMETOOLONG;
                return (-1);
        }

        return (0);
}

int
Plwp_getspymaster(struct ps_prochandle *P, lwpid_t lwpid, psinfo_t *ps)
{
        lwpstatus_t lps;

        if (P->state == PS_IDLE) {
                errno = ENODATA;
                return (-1);
        }

        if (getlwpstatus(P, lwpid, &lps) != 0)
                return (-1);

        if (!(lps.pr_flags & PR_AGENT)) {
                errno = EINVAL;
                return (-1);
        }

        if (P->state != PS_DEAD) {
                return (getlwpfile(P, lwpid, "spymaster",
                    ps, sizeof (psinfo_t)));
        }

        if (P->spymaster.pr_nlwp != 0) {
                (void) memcpy(ps, &P->spymaster, sizeof (psinfo_t));
                return (0);
        }

        errno = ENODATA;

        return (-1);
}

int
Plwp_stack(struct ps_prochandle *P, lwpid_t lwpid, stack_t *stkp)
{
        uintptr_t addr;

        if (P->state == PS_IDLE) {
                errno = ENODATA;
                return (-1);
        }

        if (P->state != PS_DEAD) {
                lwpstatus_t ls;
                if (getlwpfile(P, lwpid, "lwpstatus", &ls, sizeof (ls)) != 0)
                        return (-1);
                addr = ls.pr_ustack;
        } else {
                lwp_info_t *lwp;
                if ((lwp = getlwpcore(P, lwpid)) == NULL)
                        return (-1);
                addr = lwp->lwp_status.pr_ustack;
        }


        if (P->status.pr_dmodel == PR_MODEL_NATIVE) {
                if (Pread(P, stkp, sizeof (*stkp), addr) != sizeof (*stkp))
                        return (-1);
#ifdef _LP64
        } else {
                stack32_t stk32;

                if (Pread(P, &stk32, sizeof (stk32), addr) != sizeof (stk32))
                        return (-1);

                stack_32_to_n(&stk32, stkp);
#endif
        }

        return (0);
}

int
Plwp_main_stack(struct ps_prochandle *P, lwpid_t lwpid, stack_t *stkp)
{
        uintptr_t addr;
        lwpstatus_t ls;

        if (P->state == PS_IDLE) {
                errno = ENODATA;
                return (-1);
        }

        if (P->state != PS_DEAD) {
                if (getlwpfile(P, lwpid, "lwpstatus", &ls, sizeof (ls)) != 0)
                        return (-1);
        } else {
                lwp_info_t *lwp;
                if ((lwp = getlwpcore(P, lwpid)) == NULL)
                        return (-1);
                ls = lwp->lwp_status;
        }

        addr = ls.pr_ustack;

        /*
         * Read out the current stack; if the SS_ONSTACK flag is set then
         * this LWP is operating on the alternate signal stack. We can
         * recover the original stack from pr_oldcontext.
         */
        if (P->status.pr_dmodel == PR_MODEL_NATIVE) {
                if (Pread(P, stkp, sizeof (*stkp), addr) != sizeof (*stkp))
                        return (-1);

                if (stkp->ss_flags & SS_ONSTACK)
                        goto on_altstack;
#ifdef _LP64
        } else {
                stack32_t stk32;

                if (Pread(P, &stk32, sizeof (stk32), addr) != sizeof (stk32))
                        return (-1);

                if (stk32.ss_flags & SS_ONSTACK)
                        goto on_altstack;

                stack_32_to_n(&stk32, stkp);
#endif
        }

        return (0);

on_altstack:

        if (P->status.pr_dmodel == PR_MODEL_NATIVE) {
                ucontext_t *ctxp = (void *)ls.pr_oldcontext;

                if (Pread(P, stkp, sizeof (*stkp),
                    (uintptr_t)&ctxp->uc_stack) != sizeof (*stkp))
                        return (-1);
#ifdef _LP64
        } else {
                ucontext32_t *ctxp = (void *)ls.pr_oldcontext;
                stack32_t stk32;

                if (Pread(P, &stk32, sizeof (stk32),
                    (uintptr_t)&ctxp->uc_stack) != sizeof (stk32))
                        return (-1);

                stack_32_to_n(&stk32, stkp);
#endif
        }

        return (0);
}

int
Plwp_alt_stack(struct ps_prochandle *P, lwpid_t lwpid, stack_t *stkp)
{
        if (P->state == PS_IDLE) {
                errno = ENODATA;
                return (-1);
        }

        if (P->state != PS_DEAD) {
                lwpstatus_t ls;

                if (getlwpfile(P, lwpid, "lwpstatus", &ls, sizeof (ls)) != 0)
                        return (-1);

                if (ls.pr_altstack.ss_flags & SS_DISABLE) {
                        errno = ENODATA;
                        return (-1);
                }

                *stkp = ls.pr_altstack;
        } else {
                lwp_info_t *lwp;

                if ((lwp = getlwpcore(P, lwpid)) == NULL)
                        return (-1);

                if (lwp->lwp_status.pr_altstack.ss_flags & SS_DISABLE) {
                        errno = ENODATA;
                        return (-1);
                }

                *stkp = lwp->lwp_status.pr_altstack;
        }

        return (0);
}