compat/common/kern_sig_43.c

/*        $NetBSD: kern_sig_43.c,v 1.38 2021/11/01 05:07:16 thorpej Exp $       */

/*-
 * Copyright (c) 1998 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Charles M. Hannum.
 *
 * 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.
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: kern_sig_43.c,v 1.38 2021/11/01 05:07:16 thorpej Exp $");

#if defined(_KERNEL_OPT)
#include "opt_compat_netbsd.h"
#endif

#include <sys/param.h>
#include <sys/signalvar.h>
#include <sys/resourcevar.h>
#include <sys/namei.h>
#include <sys/vnode.h>
#include <sys/proc.h>
#include <sys/systm.h>
#include <sys/timeb.h>
#include <sys/times.h>
#include <sys/buf.h>
#include <sys/acct.h>
#include <sys/file.h>
#include <sys/kernel.h>
#include <sys/wait.h>
#include <sys/ktrace.h>
#include <sys/syslog.h>
#include <sys/stat.h>
#include <sys/core.h>
#include <sys/kauth.h>

#include <sys/syscall.h>
#include <sys/syscallvar.h>
#include <sys/syscallargs.h>
#include <sys/compat_stub.h>

#include <sys/cpu.h>

#include <compat/sys/signal.h>
#include <compat/common/compat_mod.h>

void compat_43_sigmask_to_sigset(const int *, sigset_t *);
void compat_43_sigset_to_sigmask(const sigset_t *, int *);
void compat_43_sigvec_to_sigaction(const struct sigvec *, struct sigaction *);
void compat_43_sigaction_to_sigvec(const struct sigaction *, struct sigvec *);
void compat_43_sigstack_to_sigaltstack(const struct sigstack *, stack_t *);
void compat_43_sigaltstack_to_sigstack(const stack_t *, struct sigstack *);

static struct syscall_package kern_sig_43_syscalls[] = {
          { SYS_compat_43_osigblock, 0, (sy_call_t *)compat_43_sys_sigblock },
          { SYS_compat_43_osigsetmask, 0, (sy_call_t *)compat_43_sys_sigsetmask },
          { SYS_compat_43_osigstack, 0, (sy_call_t *)compat_43_sys_sigstack },
          { SYS_compat_43_osigvec, 0, (sy_call_t *)compat_43_sys_sigvec },
          { SYS_compat_43_okillpg, 0, (sy_call_t *)compat_43_sys_killpg },
          { 0, 0, NULL }
};

void
compat_43_sigmask_to_sigset(const int *sm, sigset_t *ss)
{

          memset(ss, 0, sizeof(*ss));
          ss->__bits[0] = *sm;
          ss->__bits[1] = 0;
          ss->__bits[2] = 0;
          ss->__bits[3] = 0;
}

void
compat_43_sigset_to_sigmask(const sigset_t *ss, int *sm)
{

          *sm = ss->__bits[0];
}

void
compat_43_sigvec_to_sigaction(const struct sigvec *sv, struct sigaction *sa)
{

          memset(sa, 0, sizeof(*sa));
          sa->sa_handler = sv->sv_handler;
          compat_43_sigmask_to_sigset(&sv->sv_mask, &sa->sa_mask);
          sa->sa_flags = sv->sv_flags ^ SA_RESTART;
}

void
compat_43_sigaction_to_sigvec(const struct sigaction *sa, struct sigvec *sv)
{

          memset(sv, 0, sizeof(*sv));
          sv->sv_handler = sa->sa_handler;
          compat_43_sigset_to_sigmask(&sa->sa_mask, &sv->sv_mask);
          sv->sv_flags = sa->sa_flags ^ SA_RESTART;
}

void
compat_43_sigstack_to_sigaltstack(const struct sigstack *ss, stack_t *sa)
{
          memset(sa, 0, sizeof(*sa));
          sa->ss_sp = ss->ss_sp;
          sa->ss_size = SIGSTKSZ;       /* Use the recommended size */
          sa->ss_flags = 0;
          if (ss->ss_onstack)
                    sa->ss_flags |= SS_ONSTACK;
}

void
compat_43_sigaltstack_to_sigstack(const stack_t *sa, struct sigstack *ss)
{
          memset(ss, 0, sizeof(*ss));
          ss->ss_sp = sa->ss_sp;
          if (sa->ss_flags & SS_ONSTACK)
                    ss->ss_onstack = 1;
          else
                    ss->ss_onstack = 0;
}

int
compat_43_sys_sigblock(struct lwp *l, const struct compat_43_sys_sigblock_args *uap, register_t *retval)
{
          /* {
                    syscallarg(int) mask;
          } */
          struct proc *p = l->l_proc;
          int nsm, osm;
          sigset_t nss, oss;
          int error;

          nsm = SCARG(uap, mask);
          compat_43_sigmask_to_sigset(&nsm, &nss);
          mutex_enter(p->p_lock);
          error = sigprocmask1(l, SIG_BLOCK, &nss, &oss);
          mutex_exit(p->p_lock);
          if (error)
                    return (error);
          compat_43_sigset_to_sigmask(&oss, &osm);
          *retval = osm;
          return (0);
}

int
compat_43_sys_sigsetmask(struct lwp *l, const struct compat_43_sys_sigsetmask_args *uap, register_t *retval)
{
          /* {
                    syscallarg(int) mask;
          } */
          struct proc *p = l->l_proc;
          int nsm, osm;
          sigset_t nss, oss;
          int error;

          nsm = SCARG(uap, mask);
          compat_43_sigmask_to_sigset(&nsm, &nss);
          mutex_enter(p->p_lock);
          error = sigprocmask1(l, SIG_SETMASK, &nss, &oss);
          mutex_exit(p->p_lock);
          if (error)
                    return (error);
          compat_43_sigset_to_sigmask(&oss, &osm);
          *retval = osm;
          return (0);
}

/* ARGSUSED */
int
compat_43_sys_sigstack(struct lwp *l, const struct compat_43_sys_sigstack_args *uap, register_t *retval)
{
          /* {
                    syscallarg(struct sigstack *) nss;
                    syscallarg(struct sigstack *) oss;
          } */
          struct sigstack nss, oss;
          stack_t nsa, osa;
          int error;

          if (SCARG(uap, nss)) {
                    error = copyin(SCARG(uap, nss), &nss, sizeof(nss));
                    if (error)
                              return (error);
                    compat_43_sigstack_to_sigaltstack(&nss, &nsa);
          }
          error = sigaltstack1(l,
              SCARG(uap, nss) ? &nsa : 0, SCARG(uap, oss) ? &osa : 0);
          if (error)
                    return (error);
          if (SCARG(uap, oss)) {
                    compat_43_sigaltstack_to_sigstack(&osa, &oss);
                    error = copyout(&oss, SCARG(uap, oss), sizeof(oss));
                    if (error)
                              return (error);
          }
          return (0);
}

/*
 * Generalized interface signal handler, 4.3-compatible.
 */
/* ARGSUSED */
int
compat_43_sys_sigvec(struct lwp *l, const struct compat_43_sys_sigvec_args *uap, register_t *retval)
{
          /* {
                    syscallarg(int) signum;
                    syscallarg(const struct sigvec *) nsv;
                    syscallarg(struct sigvec *) osv;
          } */
          struct sigvec nsv, osv;
          struct sigaction nsa, osa;
          int error;

          if (SCARG(uap, nsv)) {
                    error = copyin(SCARG(uap, nsv), &nsv, sizeof(nsv));
                    if (error)
                              return (error);
                    compat_43_sigvec_to_sigaction(&nsv, &nsa);
          }
          error = sigaction1(l, SCARG(uap, signum),
              SCARG(uap, nsv) ? &nsa : 0, SCARG(uap, osv) ? &osa : 0,
              NULL, 0);
          if (error)
                    return (error);
          if (SCARG(uap, osv)) {
                    compat_43_sigaction_to_sigvec(&osa, &osv);
                    error = copyout(&osv, SCARG(uap, osv), sizeof(osv));
                    if (error)
                              return (error);
          }
          return (0);
}


/* ARGSUSED */
int
compat_43_sys_killpg(struct lwp *l, const struct compat_43_sys_killpg_args *uap, register_t *retval)
{
          /* {
                    syscallarg(int) pgid;
                    syscallarg(int) signum;
          } */
          ksiginfo_t ksi;
          int pgid = SCARG(uap, pgid);

          pgid &= kern_sig_43_pgid_mask;

          if ((u_int)SCARG(uap, signum) >= NSIG)
                    return (EINVAL);
          memset(&ksi, 0, sizeof(ksi));
          ksi.ksi_signo = SCARG(uap, signum);
          ksi.ksi_code = SI_USER;
          ksi.ksi_pid = l->l_proc->p_pid;
          ksi.ksi_uid = kauth_cred_geteuid(l->l_cred);
          return killpg1(l, &ksi, pgid, 0);
}

int
kern_sig_43_init(void)
{

          return syscall_establish(NULL, kern_sig_43_syscalls);
}

int
kern_sig_43_fini(void)
{

          return syscall_disestablish(NULL, kern_sig_43_syscalls);
}