/*      $NetBSD: sys_lwp.c,v 1.89 2023/10/15 10:29:24 riastradh Exp $   */

/*-
 * Copyright (c) 2001, 2006, 2007, 2008, 2019, 2020, 2023
 *     The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Nathan J. Williams, and Andrew Doran.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

/*
 * Lightweight process (LWP) system calls.  See kern_lwp.c for a description
 * of LWPs.
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: sys_lwp.c,v 1.89 2023/10/15 10:29:24 riastradh Exp $");

#include <sys/param.h>

#include <sys/cpu.h>
#include <sys/kauth.h>
#include <sys/kmem.h>
#include <sys/lwpctl.h>
#include <sys/pool.h>
#include <sys/proc.h>
#include <sys/pserialize.h>
#include <sys/ptrace.h>
#include <sys/sleepq.h>
#include <sys/syncobj.h>
#include <sys/syscallargs.h>
#include <sys/systm.h>
#include <sys/types.h>

#include <uvm/uvm_extern.h>

#define LWP_UNPARK_MAX          1024

static const stack_t lwp_ss_init = SS_INIT;

/*
 * Parked LWPs get no priority boost on awakening as they blocked on
 * user space objects.  Maybe revisit?
 */
syncobj_t lwp_park_syncobj = {
        .sobj_name      = "lwp_park",
        .sobj_flag      = SOBJ_SLEEPQ_NULL,
        .sobj_boostpri  = PRI_USER,
        .sobj_unsleep   = sleepq_unsleep,
        .sobj_changepri = sleepq_changepri,
        .sobj_lendpri   = sleepq_lendpri,
        .sobj_owner     = syncobj_noowner,
};

static void
mi_startlwp(void *arg)
{
        struct lwp *l = curlwp;
        struct proc *p = l->l_proc;

        (p->p_emul->e_startlwp)(arg);

        /* If the process is traced, report lwp creation to a debugger */
        if ((p->p_slflag & (PSL_TRACED|PSL_TRACELWP_CREATE)) ==
            (PSL_TRACED|PSL_TRACELWP_CREATE)) {
                /* Paranoid check */
                mutex_enter(&proc_lock);
                if ((p->p_slflag & (PSL_TRACED|PSL_TRACELWP_CREATE)) !=
                    (PSL_TRACED|PSL_TRACELWP_CREATE)) { 
                        mutex_exit(&proc_lock);
                        return;
                }

                mutex_enter(p->p_lock);
                eventswitch(TRAP_LWP, PTRACE_LWP_CREATE, l->l_lid);
        }
}

int
do_lwp_create(lwp_t *l, void *arg, u_long flags, lwp_t **l2,
    const sigset_t *sigmask, const stack_t *sigstk)
{
        struct proc *p = l->l_proc;
        vaddr_t uaddr;
        int error;

        /* XXX check against resource limits */

        uaddr = uvm_uarea_alloc();
        if (__predict_false(uaddr == 0))
                return ENOMEM;

        error = lwp_create(l, p, uaddr, flags & LWP_DETACHED, NULL, 0,
            mi_startlwp, arg, l2, l->l_class, sigmask, &lwp_ss_init);
        if (__predict_false(error)) {
                uvm_uarea_free(uaddr);
                return error;
        }

        return 0;
}

int
sys__lwp_create(struct lwp *l, const struct sys__lwp_create_args *uap,
    register_t *retval)
{
        /* {
                syscallarg(const ucontext_t *) ucp;
                syscallarg(u_long) flags;
                syscallarg(lwpid_t *) new_lwp;
        } */
        struct proc *p = l->l_proc;
        ucontext_t *newuc;
        lwp_t *l2;
        int error;

        newuc = kmem_alloc(sizeof(ucontext_t), KM_SLEEP);
        error = copyin(SCARG(uap, ucp), newuc, p->p_emul->e_ucsize);
        if (error)
                goto fail;

        /* validate the ucontext */
        if ((newuc->uc_flags & _UC_CPU) == 0) {
                error = EINVAL;
                goto fail;
        }
        error = cpu_mcontext_validate(l, &newuc->uc_mcontext);
        if (error)
                goto fail;

        const sigset_t *sigmask = newuc->uc_flags & _UC_SIGMASK ?
            &newuc->uc_sigmask : &l->l_sigmask;
        error = do_lwp_create(l, newuc, SCARG(uap, flags), &l2, sigmask,
            &SS_INIT);
        if (error)
                goto fail;

        error = copyout(&l2->l_lid, SCARG(uap, new_lwp), sizeof(l2->l_lid));
        if (error == 0) {
                lwp_start(l2, SCARG(uap, flags));
                return 0;
        }
        lwp_exit(l2);
 fail:
        kmem_free(newuc, sizeof(ucontext_t));
        return error;
}

int
sys__lwp_exit(struct lwp *l, const void *v, register_t *retval)
{

        lwp_exit(l);
        return 0;
}

int
sys__lwp_self(struct lwp *l, const void *v, register_t *retval)
{

        *retval = l->l_lid;
        return 0;
}

int
sys__lwp_getprivate(struct lwp *l, const void *v, register_t *retval)
{

        *retval = (uintptr_t)l->l_private;
        return 0;
}

int
sys__lwp_setprivate(struct lwp *l, const struct sys__lwp_setprivate_args *uap,
    register_t *retval)
{
        /* {
                syscallarg(void *) ptr;
        } */

        return lwp_setprivate(l, SCARG(uap, ptr));
}

int
sys__lwp_suspend(struct lwp *l, const struct sys__lwp_suspend_args *uap,
    register_t *retval)
{
        /* {
                syscallarg(lwpid_t) target;
        } */
        struct proc *p = l->l_proc;
        struct lwp *t;
        int error;

        mutex_enter(p->p_lock);
        if ((t = lwp_find(p, SCARG(uap, target))) == NULL) {
                mutex_exit(p->p_lock);
                return ESRCH;
        }

        /*
         * Check for deadlock, which is only possible when we're suspending
         * ourself.  XXX There is a short race here, as p_nrlwps is only
         * incremented when an LWP suspends itself on the kernel/user
         * boundary.  It's still possible to kill -9 the process so we
         * don't bother checking further.
         */
        lwp_lock(t);
        if ((t == l && p->p_nrlwps == 1) ||
            (l->l_flag & (LW_WCORE | LW_WEXIT)) != 0) {
                lwp_unlock(t);
                mutex_exit(p->p_lock);
                return EDEADLK;
        }

        /*
         * Suspend the LWP.  XXX If it's on a different CPU, we should wait
         * for it to be preempted, where it will put itself to sleep. 
         *
         * Suspension of the current LWP will happen on return to userspace.
         */
        error = lwp_suspend(l, t);
        if (error) {
                mutex_exit(p->p_lock);
                return error;
        }

        /*
         * Wait for:
         *  o process exiting
         *  o target LWP suspended
         *  o target LWP not suspended and L_WSUSPEND clear
         *  o target LWP exited
         */
        for (;;) {
                error = cv_wait_sig(&p->p_lwpcv, p->p_lock);
                if (error) {
                        error = ERESTART;
                        break;
                }
                if (lwp_find(p, SCARG(uap, target)) == NULL) {
                        error = ESRCH;
                        break;
                }
                if ((l->l_flag | t->l_flag) & (LW_WCORE | LW_WEXIT)) {
                        error = ERESTART;
                        break;
                }
                if (t->l_stat == LSSUSPENDED ||
                    (t->l_flag & LW_WSUSPEND) == 0)
                        break;
        }
        mutex_exit(p->p_lock);

        return error;
}

int
sys__lwp_continue(struct lwp *l, const struct sys__lwp_continue_args *uap,
    register_t *retval)
{
        /* {
                syscallarg(lwpid_t) target;
        } */
        int error;
        struct proc *p = l->l_proc;
        struct lwp *t;

        error = 0;

        mutex_enter(p->p_lock);
        if ((t = lwp_find(p, SCARG(uap, target))) == NULL) {
                mutex_exit(p->p_lock);
                return ESRCH;
        }

        lwp_lock(t);
        lwp_continue(t);
        mutex_exit(p->p_lock);

        return error;
}

int
sys__lwp_wakeup(struct lwp *l, const struct sys__lwp_wakeup_args *uap,
    register_t *retval)
{
        /* {
                syscallarg(lwpid_t) target;
        } */
        struct lwp *t;
        struct proc *p;
        int error;

        p = l->l_proc;
        mutex_enter(p->p_lock);

        if ((t = lwp_find(p, SCARG(uap, target))) == NULL) {
                mutex_exit(p->p_lock);
                return ESRCH;
        }

        lwp_lock(t);
        t->l_flag |= (LW_CANCELLED | LW_UNPARKED);

        if (t->l_stat != LSSLEEP) {
                lwp_unlock(t);
                error = ENODEV;
        } else if ((t->l_flag & LW_SINTR) == 0) {
                lwp_unlock(t);
                error = EBUSY;
        } else {
                /* Wake it up.  lwp_unsleep() will release the LWP lock. */
                lwp_unsleep(t, true);
                error = 0;
        }

        mutex_exit(p->p_lock);

        return error;
}

int
sys__lwp_wait(struct lwp *l, const struct sys__lwp_wait_args *uap,
    register_t *retval)
{
        /* {
                syscallarg(lwpid_t) wait_for;
                syscallarg(lwpid_t *) departed;
        } */
        struct proc *p = l->l_proc;
        int error;
        lwpid_t dep;

        mutex_enter(p->p_lock);
        error = lwp_wait(l, SCARG(uap, wait_for), &dep, false);
        mutex_exit(p->p_lock);

        if (!error && SCARG(uap, departed)) {
                error = copyout(&dep, SCARG(uap, departed), sizeof(dep));
        }

        return error;
}

int
sys__lwp_kill(struct lwp *l, const struct sys__lwp_kill_args *uap,
    register_t *retval)
{
        /* {
                syscallarg(lwpid_t)     target;
                syscallarg(int)         signo;
        } */
        struct proc *p = l->l_proc;
        struct lwp *t;
        ksiginfo_t ksi;
        int signo = SCARG(uap, signo);
        int error = 0;

        if ((u_int)signo >= NSIG)
                return EINVAL;

        KSI_INIT(&ksi);
        ksi.ksi_signo = signo;
        ksi.ksi_code = SI_LWP;
        ksi.ksi_pid = p->p_pid;
        ksi.ksi_uid = kauth_cred_geteuid(l->l_cred);
        ksi.ksi_lid = SCARG(uap, target);

        mutex_enter(&proc_lock);
        mutex_enter(p->p_lock);
        if ((t = lwp_find(p, ksi.ksi_lid)) == NULL)
                error = ESRCH;
        else if (signo != 0)
                kpsignal2(p, &ksi);
        mutex_exit(p->p_lock);
        mutex_exit(&proc_lock);

        return error;
}

int
sys__lwp_detach(struct lwp *l, const struct sys__lwp_detach_args *uap,
    register_t *retval)
{
        /* {
                syscallarg(lwpid_t)     target;
        } */
        struct proc *p;
        struct lwp *t;
        lwpid_t target;
        int error;

        target = SCARG(uap, target);
        p = l->l_proc;

        mutex_enter(p->p_lock);

        if (l->l_lid == target)
                t = l;
        else {
                /*
                 * We can't use lwp_find() here because the target might
                 * be a zombie.
                 */
                t = proc_find_lwp(p, target);
                KASSERT(t == NULL || t->l_lid == target);
        }

        /*
         * If the LWP is already detached, there's nothing to do.
         * If it's a zombie, we need to clean up after it.  LSZOMB
         * is visible with the proc mutex held.
         *
         * After we have detached or released the LWP, kick any
         * other LWPs that may be sitting in _lwp_wait(), waiting
         * for the target LWP to exit.
         */
        if (t != NULL && t->l_stat != LSIDL) {
                if ((t->l_prflag & LPR_DETACHED) == 0) {
                        p->p_ndlwps++;
                        t->l_prflag |= LPR_DETACHED;
                        if (t->l_stat == LSZOMB) {
                                /* Releases proc mutex. */
                                lwp_free(t, false, false);
                                return 0;
                        }
                        error = 0;

                        /*
                         * Have any LWPs sleeping in lwp_wait() recheck
                         * for deadlock.
                         */
                        cv_broadcast(&p->p_lwpcv);
                } else
                        error = EINVAL;
        } else
                error = ESRCH;

        mutex_exit(p->p_lock);

        return error;
}

int
lwp_unpark(const lwpid_t *tp, const u_int ntargets)
{
        u_int target;
        kmutex_t *mp;
        int error, s;
        proc_t *p;
        lwp_t *t;

        p = curproc;
        error = 0;

        s = pserialize_read_enter();
        for (target = 0; target < ntargets; target++) {
                t = proc_find_lwp_unlocked(p, tp[target]);
                if (__predict_false(t == NULL)) {
                        error = ESRCH;
                        continue;
                }

                KASSERT(lwp_locked(t, NULL));

                if (__predict_true(t->l_syncobj == &lwp_park_syncobj)) {
                        /* As expected it's parked, so wake it up. */
                        mp = t->l_mutex;
                        sleepq_remove(NULL, t, true);
                        mutex_spin_exit(mp);
                } else if (__predict_false(t->l_stat == LSZOMB)) {
                        lwp_unlock(t);
                        error = ESRCH;
                } else {
                        /*
                         * It hasn't parked yet because the wakeup side won
                         * the race, or something else has happened to make
                         * the thread not park.  Why doesn't really matter. 
                         * Set the operation pending, so that the next call
                         * to _lwp_park() in the LWP returns early.  If it
                         * turns out to be a spurious wakeup, no harm done.
                         */
                        t->l_flag |= LW_UNPARKED;
                        lwp_unlock(t);
                }
        }
        pserialize_read_exit(s);

        return error;
}

int
lwp_park(clockid_t clock_id, int flags, struct timespec *ts)
{
        int timo, error;
        struct timespec start;
        lwp_t *l;
        bool timeremain = !(flags & TIMER_ABSTIME) && ts;

        if (ts != NULL) {
                if ((error = ts2timo(clock_id, flags, ts, &timo, 
                    timeremain ? &start : NULL)) != 0)
                        return error;
                KASSERT(timo != 0);
        } else {
                timo = 0;
        }

        /*
         * Before going the full route and blocking, check to see if an
         * unpark op is pending.
         */
        l = curlwp;
        lwp_lock(l);
        if ((l->l_flag & (LW_CANCELLED | LW_UNPARKED)) != 0) {
                l->l_flag &= ~(LW_CANCELLED | LW_UNPARKED);
                lwp_unlock(l);
                return EALREADY;
        }
        sleepq_enqueue(NULL, l, "parked", &lwp_park_syncobj, true);
        error = sleepq_block(timo, true, &lwp_park_syncobj, 0);
        switch (error) {
        case EWOULDBLOCK:
                error = ETIMEDOUT;
                if (timeremain)
                        memset(ts, 0, sizeof(*ts));
                break;
        case ERESTART:
                error = EINTR;
                /*FALLTHROUGH*/
        default:
                if (timeremain)
                        clock_timeleft(clock_id, ts, &start);
                break;
        }
        return error;
}

/*
 * 'park' an LWP waiting on a user-level synchronisation object.  The LWP
 * will remain parked until another LWP in the same process calls in and
 * requests that it be unparked.
 */
int
sys____lwp_park60(struct lwp *l, const struct sys____lwp_park60_args *uap,
    register_t *retval)
{
        /* {
                syscallarg(clockid_t)                   clock_id;
                syscallarg(int)                         flags;
                syscallarg(struct timespec *)           ts;
                syscallarg(lwpid_t)                     unpark;
                syscallarg(const void *)                hint;
                syscallarg(const void *)                unparkhint;
        } */
        struct timespec ts, *tsp;
        int error;

        if (SCARG(uap, ts) == NULL)
                tsp = NULL;
        else {
                error = copyin(SCARG(uap, ts), &ts, sizeof(ts));
                if (error != 0)
                        return error;
                tsp = &ts;
        }

        if (SCARG(uap, unpark) != 0) {
                error = lwp_unpark(&SCARG(uap, unpark), 1);
                if (error != 0)
                        return error;
        }

        error = lwp_park(SCARG(uap, clock_id), SCARG(uap, flags), tsp);
        if (SCARG(uap, ts) != NULL && (SCARG(uap, flags) & TIMER_ABSTIME) == 0)
                (void)copyout(tsp, SCARG(uap, ts), sizeof(*tsp));
        return error;
}

int
sys__lwp_unpark(struct lwp *l, const struct sys__lwp_unpark_args *uap,
    register_t *retval)
{
        /* {
                syscallarg(lwpid_t)             target;
                syscallarg(const void *)        hint;
        } */

        return lwp_unpark(&SCARG(uap, target), 1);
}

int
sys__lwp_unpark_all(struct lwp *l, const struct sys__lwp_unpark_all_args *uap,
    register_t *retval)
{
        /* {
                syscallarg(const lwpid_t *)     targets;
                syscallarg(size_t)              ntargets;
                syscallarg(const void *)        hint;
        } */
        lwpid_t targets[32], *tp;
        int error;
        u_int ntargets;
        size_t sz;

        ntargets = SCARG(uap, ntargets);
        if (SCARG(uap, targets) == NULL) {
                /*
                 * Let the caller know how much we are willing to do, and
                 * let it unpark the LWPs in blocks.
                 */
                *retval = LWP_UNPARK_MAX;
                return 0;
        }
        if (ntargets > LWP_UNPARK_MAX || ntargets == 0)
                return EINVAL;

        /*
         * Copy in the target array.  If it's a small number of LWPs, then
         * place the numbers on the stack.
         */
        sz = sizeof(lwpid_t) * ntargets;
        if (sz <= sizeof(targets))
                tp = targets;
        else
                tp = kmem_alloc(sz, KM_SLEEP);
        error = copyin(SCARG(uap, targets), tp, sz);
        if (error != 0) {
                if (tp != targets) {
                        kmem_free(tp, sz);
                }
                return error;
        }
        error = lwp_unpark(tp, ntargets);
        if (tp != targets)
                kmem_free(tp, sz);
        return error;
}

int
sys__lwp_setname(struct lwp *l, const struct sys__lwp_setname_args *uap,
    register_t *retval)
{
        /* {
                syscallarg(lwpid_t)             target;
                syscallarg(const char *)        name;
        } */
        char *name, *oname;
        lwpid_t target;
        proc_t *p;
        lwp_t *t;
        int error;

        if ((target = SCARG(uap, target)) == 0)
                target = l->l_lid;

        name = kmem_alloc(MAXCOMLEN, KM_SLEEP);
        error = copyinstr(SCARG(uap, name), name, MAXCOMLEN, NULL);
        switch (error) {
        case ENAMETOOLONG:
        case 0:
                name[MAXCOMLEN - 1] = '\0';
                break;
        default:
                kmem_free(name, MAXCOMLEN);
                return error;
        }

        p = curproc;
        mutex_enter(p->p_lock);
        if ((t = lwp_find(p, target)) == NULL) {
                mutex_exit(p->p_lock);
                kmem_free(name, MAXCOMLEN);
                return ESRCH;
        }
        lwp_lock(t);
        oname = t->l_name;
        t->l_name = name;
        lwp_unlock(t);
        mutex_exit(p->p_lock);

        if (oname != NULL)
                kmem_free(oname, MAXCOMLEN);

        return 0;
}

int
sys__lwp_getname(struct lwp *l, const struct sys__lwp_getname_args *uap,
    register_t *retval)
{
        /* {
                syscallarg(lwpid_t)             target;
                syscallarg(char *)              name;
                syscallarg(size_t)              len;
        } */
        char name[MAXCOMLEN];
        lwpid_t target;
        size_t len;
        proc_t *p;
        lwp_t *t;

        if ((target = SCARG(uap, target)) == 0)
                target = l->l_lid;

        p = curproc;
        mutex_enter(p->p_lock);
        if ((t = lwp_find(p, target)) == NULL) {
                mutex_exit(p->p_lock);
                return ESRCH;
        }
        lwp_lock(t);
        if (t->l_name == NULL)
                name[0] = '\0';
        else
                strlcpy(name, t->l_name, sizeof(name));
        lwp_unlock(t);
        mutex_exit(p->p_lock);

        len = uimin(SCARG(uap, len), sizeof(name));

        return copyoutstr(name, SCARG(uap, name), len, NULL);
}

int
sys__lwp_ctl(struct lwp *l, const struct sys__lwp_ctl_args *uap,
    register_t *retval)
{
        /* {
                syscallarg(int)                 features;
                syscallarg(struct lwpctl **)    address;
        } */
        int error, features;
        vaddr_t vaddr;

        features = SCARG(uap, features);
        features &= ~(LWPCTL_FEATURE_CURCPU | LWPCTL_FEATURE_PCTR);
        if (features != 0)
                return ENODEV;
        if ((error = lwp_ctl_alloc(&vaddr)) != 0)
                return error;
        return copyout(&vaddr, SCARG(uap, address), sizeof(void *));
}