/*      $NetBSD: netbsd32_compat_43.c,v 1.65 2024/12/20 16:12:31 mlelstv Exp $  */

/*
 * Copyright (c) 1998, 2001 Matthew R. Green
 * All rights reserved.
 *
 * 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 AUTHOR ``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 AUTHOR 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: netbsd32_compat_43.c,v 1.65 2024/12/20 16:12:31 mlelstv Exp $");

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

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/module.h>
#include <sys/fcntl.h>
#include <sys/filedesc.h>
#include <sys/mbuf.h>
#include <sys/mount.h>
#include <sys/namei.h>
#include <sys/socket.h>
#include <sys/proc.h>
#include <sys/socket.h>
#include <sys/socketvar.h>
#include <sys/stat.h>
#include <sys/syscallvar.h>
#include <sys/syscallargs.h>
#include <sys/time.h>
#include <sys/ucred.h>
#include <sys/vfs_syscalls.h>
#include <uvm/uvm_extern.h>
#include <sys/sysctl.h>
#include <sys/swap.h>

#include <compat/netbsd32/netbsd32.h>
#include <compat/netbsd32/netbsd32_syscall.h>
#include <compat/netbsd32/netbsd32_syscallargs.h>

#include <compat/sys/stat.h>
#include <compat/sys/signal.h>
#include <compat/sys/signalvar.h>
#include <compat/sys/socket.h>

#define SYS_DEF(foo) struct foo##_args; \
    int foo(struct lwp *, const struct foo##_args *, register_t *)

SYS_DEF(compat_43_netbsd32_sethostid);
SYS_DEF(compat_43_netbsd32_killpg);
SYS_DEF(compat_43_netbsd32_sigblock);
SYS_DEF(compat_43_netbsd32_sigsetmask);
#undef SYS_DEF

static void
netbsd32_from_stat(const struct stat *sb, struct netbsd32_stat43 *sp32)
{

        memset(sp32, 0, sizeof(*sp32));
        sp32->st_dev = sb->st_dev;
        sp32->st_ino = sb->st_ino;
        sp32->st_mode = sb->st_mode;
        sp32->st_nlink = sb->st_nlink;
        sp32->st_uid = sb->st_uid;
        sp32->st_gid = sb->st_gid;
        sp32->st_rdev = sb->st_rdev;
        sp32->st_size = sb->st_size < (quad_t)1 << 32 ? sb->st_size : -2;
        sp32->st_atimespec.tv_sec = sb->st_atimespec.tv_sec;
        sp32->st_atimespec.tv_nsec = sb->st_atimespec.tv_nsec;
        sp32->st_mtimespec.tv_sec = sb->st_mtimespec.tv_sec;
        sp32->st_mtimespec.tv_nsec = sb->st_mtimespec.tv_nsec;
        sp32->st_ctimespec.tv_sec = sb->st_ctimespec.tv_sec;
        sp32->st_ctimespec.tv_nsec = sb->st_ctimespec.tv_nsec;
        sp32->st_blksize = sb->st_blksize;
        sp32->st_blocks = sb->st_blocks;
        sp32->st_flags = sb->st_flags;
        sp32->st_gen = sb->st_gen;
}

/* file system syscalls */
int
compat_43_netbsd32_ocreat(struct lwp *l, const struct compat_43_netbsd32_ocreat_args *uap, register_t *retval)
{
        /* {
                syscallarg(const netbsd32_charp) path;
                syscallarg(mode_t) mode;
        } */
        struct sys_open_args  ua;

        NETBSD32TOP_UAP(path, const char);
        NETBSD32TO64_UAP(mode);
        SCARG(&ua, flags) = O_WRONLY | O_CREAT | O_TRUNC;

        return sys_open(l, &ua, retval);
}

int
compat_43_netbsd32_olseek(struct lwp *l, const struct compat_43_netbsd32_olseek_args *uap, register_t *retval)
{
        /* {
                syscallarg(int) fd;
                syscallarg(netbsd32_long) offset;
                syscallarg(int) whence;
        } */
        struct sys_lseek_args ua;

        SCARG(&ua, fd) = SCARG(uap, fd);
        NETBSD32TOX_UAP(offset, long);
        NETBSD32TO64_UAP(whence);
        /* Maybe offsets > 2^32 should generate an error ? */
        return sys_lseek(l, &ua, retval);
}

int
compat_43_netbsd32_stat43(struct lwp *l, const struct compat_43_netbsd32_stat43_args *uap, register_t *retval)
{
        /* {
                syscallarg(const netbsd32_charp) path;
                syscallarg(netbsd32_stat43p_t) ub;
        } */
        struct stat sb;
        struct netbsd32_stat43 sb32;
        int error;

        error = do_sys_stat(SCARG_P32(uap, path), FOLLOW, &sb);
        if (error == 0) {
                netbsd32_from_stat(&sb, &sb32);
                error = copyout(&sb32, SCARG_P32(uap, ub), sizeof(sb32));
        }
        return error;
}

int
compat_43_netbsd32_lstat43(struct lwp *l, const struct compat_43_netbsd32_lstat43_args *uap, register_t *retval)
{
        /* {
                syscallarg(const netbsd32_charp) path;
                syscallarg(netbsd32_stat43p_t) ub;
        } */
        struct stat sb;
        struct netbsd32_stat43 sb32;
        int error;

        error = do_sys_stat(SCARG_P32(uap, path), NOFOLLOW, &sb);
        if (error == 0) {
                netbsd32_from_stat(&sb, &sb32);
                error = copyout(&sb32, SCARG_P32(uap, ub), sizeof(sb32));
        }
        return error;
}

int
compat_43_netbsd32_fstat43(struct lwp *l, const struct compat_43_netbsd32_fstat43_args *uap, register_t *retval)
{
        /* {
                syscallarg(int) fd;
                syscallarg(netbsd32_stat43p_t) sb;
        } */
        struct stat sb;
        struct netbsd32_stat43 sb32;
        int error;

        error = do_sys_fstat(SCARG(uap, fd), &sb);
        if (error == 0) {
                netbsd32_from_stat(&sb, &sb32);
                error = copyout(&sb32, SCARG_P32(uap, sb), sizeof(sb32));
        }
        return error;
}

int
compat_43_netbsd32_otruncate(struct lwp *l, const struct compat_43_netbsd32_otruncate_args *uap, register_t *retval)
{
        /* {
                syscallarg(const netbsd32_charp) path;
                syscallarg(netbsd32_long) length;
        } */
        struct sys_truncate_args ua;

        NETBSD32TOP_UAP(path, const char);
        NETBSD32TO64_UAP(length);
        return sys_truncate(l, &ua, retval);
}

int
compat_43_netbsd32_oftruncate(struct lwp *l, const struct compat_43_netbsd32_oftruncate_args *uap, register_t *retval)
{
        /* {
                syscallarg(int) fd;
                syscallarg(netbsd32_long) length;
        } */
        struct sys_ftruncate_args ua;

        NETBSD32TO64_UAP(fd);
        NETBSD32TO64_UAP(length);
        return sys_ftruncate(l, &ua, retval);
}

int
compat_43_netbsd32_ogetdirentries(struct lwp *l, const struct compat_43_netbsd32_ogetdirentries_args *uap, register_t *retval)
{
        /* {
                syscallarg(int) fd;
                syscallarg(netbsd32_charp) buf;
                syscallarg(u_int) count;
                syscallarg(netbsd32_longp) basep;
        } */
        struct compat_43_sys_getdirentries_args ua;

        NETBSD32TO64_UAP(fd);
        NETBSD32TOP_UAP(buf, char);
        NETBSD32TO64_UAP(count);
        NETBSD32TOP_UAP(basep, long);
        return compat_43_sys_getdirentries(l, &ua, retval);
}

/* kernel syscalls */
int
compat_43_netbsd32_ogetkerninfo(struct lwp *l, const struct compat_43_netbsd32_ogetkerninfo_args *uap, register_t *retval)
{
        /* {
                syscallarg(int) op;
                syscallarg(netbsd32_charp) where;
                syscallarg(netbsd32_intp) size;
                syscallarg(int) arg;
        } */
        struct compat_43_sys_getkerninfo_args ua;

        NETBSD32TO64_UAP(op);
        NETBSD32TOP_UAP(where, char);
        NETBSD32TOP_UAP(size, int);
        NETBSD32TO64_UAP(arg);
        return compat_43_sys_getkerninfo(l, &ua, retval);
}

int
compat_43_netbsd32_ogethostname(struct lwp *l, const struct compat_43_netbsd32_ogethostname_args *uap, register_t *retval)
{
        /* {
                syscallarg(netbsd32_charp) hostname;
                syscallarg(u_int) len;
        } */
        int name[2];
        size_t sz;

        name[0] = CTL_KERN;
        name[1] = KERN_HOSTNAME;
        sz = SCARG(uap, len);
        return old_sysctl(&name[0], 2,
            SCARG_P32(uap, hostname), &sz, 0, 0, l);
}

int
compat_43_netbsd32_osethostname(struct lwp *l, const struct compat_43_netbsd32_osethostname_args *uap, register_t *retval)
{
        /* {
                syscallarg(netbsd32_charp) hostname;
                syscallarg(u_int) len;
        } */
        int name[2];

        name[0] = CTL_KERN;
        name[1] = KERN_HOSTNAME;
        return old_sysctl(&name[0], 2, 0, 0, (char *)SCARG_P32(uap,
            hostname), SCARG(uap, len), l);
}

int
compat_43_netbsd32_sethostid(struct lwp *l, const struct compat_43_netbsd32_sethostid_args *uap, register_t *retval)
{
        /* {
                syscallarg(int32_t) hostid;
        } */
        struct compat_43_sys_sethostid_args ua;

        NETBSD32TO64_UAP(hostid);
        return compat_43_sys_sethostid(l, &ua, retval);
}

int
compat_43_netbsd32_ogetrlimit(struct lwp *l, const struct compat_43_netbsd32_ogetrlimit_args *uap, register_t *retval)
{
        /* {
                syscallarg(int) which;
                syscallarg(netbsd32_orlimitp_t) rlp;
        } */
        struct compat_43_sys_getrlimit_args ua;

        NETBSD32TO64_UAP(which);
        NETBSD32TOP_UAP(rlp, struct orlimit);
        return compat_43_sys_getrlimit(l, &ua, retval);
}

int
compat_43_netbsd32_osetrlimit(struct lwp *l, const struct compat_43_netbsd32_osetrlimit_args *uap, register_t *retval)
{
        /* {
                syscallarg(int) which;
                syscallarg(netbsd32_orlimitp_t) rlp;
        } */
        struct compat_43_sys_setrlimit_args ua;

        NETBSD32TO64_UAP(which);
        NETBSD32TOP_UAP(rlp, struct orlimit);
        return compat_43_sys_setrlimit(l, &ua, retval);
}

int
compat_43_netbsd32_killpg(struct lwp *l, const struct compat_43_netbsd32_killpg_args *uap, register_t *retval)
{
        /* {
                syscallarg(int) pgid;
                syscallarg(int) signum;
        } */
        struct compat_43_sys_killpg_args ua;

        NETBSD32TO64_UAP(pgid);
        NETBSD32TO64_UAP(signum);
        return compat_43_sys_killpg(l, &ua, retval);
}

/* virtual memory syscalls */
int
compat_43_netbsd32_ommap(struct lwp *l, const struct compat_43_netbsd32_ommap_args *uap, register_t *retval)
{
        /* {
                syscallarg(netbsd32_voidp) addr;
                syscallarg(netbsd32_size_t) len;
                syscallarg(int) prot;
                syscallarg(int) flags;
                syscallarg(int) fd;
                syscallarg(netbsd32_long) pos;
        } */
        struct compat_43_sys_mmap_args ua;

        NETBSD32TOP_UAP(addr, void *);
        NETBSD32TOX_UAP(len, size_t);
        NETBSD32TO64_UAP(prot);
        NETBSD32TO64_UAP(flags);
        NETBSD32TO64_UAP(fd);
        NETBSD32TOX_UAP(pos, long);
        return compat_43_sys_mmap(l, &ua, retval);
}

/* network syscalls */
int
compat_43_netbsd32_oaccept(struct lwp *l, const struct compat_43_netbsd32_oaccept_args *uap, register_t *retval)
{
        /* {
                syscallarg(int) s;
                syscallarg(netbsd32_voidp) name;
                syscallarg(netbsd32_intp) anamelen;
        } */
        struct compat_43_sys_accept_args ua;

        NETBSD32TOX_UAP(s, int);
        NETBSD32TOP_UAP(name, void *);
        NETBSD32TOP_UAP(anamelen, int);
        return compat_43_sys_accept(l, &ua, retval);
}

int
compat_43_netbsd32_osend(struct lwp *l, const struct compat_43_netbsd32_osend_args *uap, register_t *retval)
{
        /* {
                syscallarg(int) s;
                syscallarg(netbsd32_voidp) buf;
                syscallarg(int) len;
                syscallarg(int) flags;
        } */
        struct compat_43_sys_send_args ua;

        NETBSD32TO64_UAP(s);
        NETBSD32TOP_UAP(buf, void *);
        NETBSD32TO64_UAP(len);
        NETBSD32TO64_UAP(flags);
        return compat_43_sys_send(l, &ua, retval);
}

int
compat_43_netbsd32_orecv(struct lwp *l, const struct compat_43_netbsd32_orecv_args *uap, register_t *retval)
{
        /* {
                syscallarg(int) s;
                syscallarg(netbsd32_voidp) buf;
                syscallarg(int) len;
                syscallarg(int) flags;
        } */
        struct compat_43_sys_recv_args ua;

        NETBSD32TO64_UAP(s);
        NETBSD32TOP_UAP(buf, void *);
        NETBSD32TO64_UAP(len);
        NETBSD32TO64_UAP(flags);
        return compat_43_sys_recv(l, &ua, retval);
}

/*
 * This is a brutal clone of compat_43_sys_recvmsg().
 */
int
compat_43_netbsd32_orecvmsg(struct lwp *l, const struct compat_43_netbsd32_orecvmsg_args *uap, register_t *retval)
{
        /* {
                syscallarg(int) s;
                syscallarg(netbsd32_omsghdrp_t) msg;
                syscallarg(int) flags;
        } */
        struct netbsd32_omsghdr omsg;
        struct msghdr msg;
        struct mbuf *from, *control;
        struct iovec *iov, aiov[UIO_SMALLIOV];
        int error;

        error = copyin(SCARG_P32(uap, msg), &omsg, sizeof(omsg));
        if (error)
                return error;

        if (NETBSD32PTR64(omsg.msg_accrights) == NULL)
                omsg.msg_accrightslen = 0;
        /* it was this way in 4.4BSD */
        if (omsg.msg_accrightslen > MLEN)
                return EINVAL;

        iov = netbsd32_get_iov(NETBSD32PTR64(omsg.msg_iov), omsg.msg_iovlen,
            aiov, __arraycount(aiov));
        if (iov == NULL)
                return EFAULT;

        msg.msg_name    = NETBSD32PTR64(omsg.msg_name);
        msg.msg_namelen = omsg.msg_namelen;
        msg.msg_iovlen  = omsg.msg_iovlen;
        msg.msg_iov     = iov;
        msg.msg_flags   = SCARG(uap, flags) & MSG_USERFLAGS;

        error = do_sys_recvmsg(l, SCARG(uap, s), &msg, &from,
            NETBSD32PTR64(omsg.msg_accrights) != NULL ? &control : NULL,
            retval);
        if (error != 0)
                goto out;

        /*
         * If there is any control information and it's SCM_RIGHTS,
         * pass it back to the program.
         * XXX: maybe there can be more than one chunk of control data?
         */
        if (NETBSD32PTR64(omsg.msg_accrights) != NULL && control != NULL) {
                struct cmsghdr *cmsg = mtod(control, void *);

                if (cmsg->cmsg_level == SOL_SOCKET
                    && cmsg->cmsg_type == SCM_RIGHTS
                    && cmsg->cmsg_len < omsg.msg_accrightslen
                    && copyout(CMSG_DATA(cmsg),
                            NETBSD32PTR64(omsg.msg_accrights),
                            cmsg->cmsg_len) == 0) {
                        omsg.msg_accrightslen = cmsg->cmsg_len;
                        free_control_mbuf(l, control, control->m_next);
                } else {
                        omsg.msg_accrightslen = 0;
                        free_control_mbuf(l, control, control);
                }
        } else
                omsg.msg_accrightslen = 0;

        if (from != NULL)
                /* convert from sockaddr sa_family to osockaddr one here */
                mtod(from, struct osockaddr *)->sa_family =
                                    mtod(from, struct sockaddr *)->sa_family;

        error = copyout_sockname(NETBSD32PTR64(omsg.msg_name),
            &omsg.msg_namelen, 0, from);
        if (from != NULL)
                m_free(from);

        if (error != 0)
                 error = copyout(&omsg, SCARG_P32(uap, msg), sizeof(omsg));
out:
        if (iov != aiov) {
                kmem_free(iov, omsg.msg_iovlen * sizeof(*iov));
        }
        return error;
}

int
compat_43_netbsd32_osendmsg(struct lwp *l, const struct compat_43_netbsd32_osendmsg_args *uap, register_t *retval)
{
        /* {
                syscallarg(int) s;
                syscallarg(netbsd32_voidp) msg;
                syscallarg(int) flags;
        } */
        struct iovec *iov, aiov[UIO_SMALLIOV];
        struct netbsd32_omsghdr omsg;
        struct msghdr msg;
        struct mbuf *nam;
        struct osockaddr *osa;
        struct sockaddr *sa;
        int error;

        error = copyin(SCARG_P32(uap, msg), &omsg, sizeof(omsg));
        if (error != 0)
                return error;

        iov = netbsd32_get_iov(NETBSD32PTR64(omsg.msg_iov), omsg.msg_iovlen,
            aiov, __arraycount(aiov));
        if (iov == NULL)
                return EFAULT;

        msg.msg_iovlen = omsg.msg_iovlen;
        msg.msg_iov = iov;
        msg.msg_flags = MSG_NAMEMBUF;

        error = sockargs(&nam, NETBSD32PTR64(omsg.msg_name), omsg.msg_namelen,
            UIO_USERSPACE, MT_SONAME);
        if (error != 0)
                goto out;

        sa = mtod(nam, void *);
        osa = mtod(nam, void *);
        sa->sa_family = osa->sa_family;
        sa->sa_len = omsg.msg_namelen;

        msg.msg_name = nam;
        msg.msg_namelen = omsg.msg_namelen;
        error = compat43_set_accrights(&msg, NETBSD32PTR64(omsg.msg_accrights),
            omsg.msg_accrightslen);
        if (error != 0) {
                m_free(nam);
                goto out;
        }

        error = do_sys_sendmsg(l, SCARG(uap, s), &msg, SCARG(uap, flags),
            retval);

    out:
        if (iov != aiov)
                kmem_free(iov, omsg.msg_iovlen * sizeof(*iov));
        return error;
}

int
compat_43_netbsd32_orecvfrom(struct lwp *l, const struct compat_43_netbsd32_orecvfrom_args *uap, register_t *retval)
{
        /* {
                syscallarg(int) s;
                syscallarg(netbsd32_voidp) buf;
                syscallarg(netbsd32_size_t) len;
                syscallarg(int) flags;
                syscallarg(netbsd32_voidp) from;
                syscallarg(netbsd32_intp) fromlenaddr;
        } */
        struct compat_43_sys_recvfrom_args ua;

        NETBSD32TO64_UAP(s);
        NETBSD32TOP_UAP(buf, void *);
        NETBSD32TOX_UAP(len, size_t);
        NETBSD32TO64_UAP(flags);
        NETBSD32TOP_UAP(from, void *);
        NETBSD32TOP_UAP(fromlenaddr, int);
        return compat_43_sys_recvfrom(l, &ua, retval);
}

int
compat_43_netbsd32_ogetsockname(struct lwp *l, const struct compat_43_netbsd32_ogetsockname_args *uap, register_t *retval)
{
        /* {
                syscallarg(int) fdec;
                syscallarg(netbsd32_voidp) asa;
                syscallarg(netbsd32_intp) alen;
        } */
        struct compat_43_sys_getsockname_args ua;

        NETBSD32TO64_UAP(fdec);
        NETBSD32TOP_UAP(asa, void *);
        NETBSD32TOP_UAP(alen, int *);
        return compat_43_sys_getsockname(l, &ua, retval);
}

int
compat_43_netbsd32_ogetpeername(struct lwp *l, const struct compat_43_netbsd32_ogetpeername_args *uap, register_t *retval)
{
        /* {
                syscallarg(int) fdes;
                syscallarg(netbsd32_voidp) asa;
                syscallarg(netbsd32_intp) alen;
        } */
        struct compat_43_sys_getpeername_args ua;

        NETBSD32TO64_UAP(fdes);
        NETBSD32TOP_UAP(asa, void *);
        NETBSD32TOP_UAP(alen, int *);
        return compat_43_sys_getpeername(l, &ua, retval);
}

/* signal syscalls */
int
compat_43_netbsd32_osigvec(struct lwp *l, const struct compat_43_netbsd32_osigvec_args *uap, register_t *retval)
{
        /* {
                syscallarg(int) signum;
                syscallarg(netbsd32_sigvecp_t) nsv;
                syscallarg(netbsd32_sigvecp_t) osv;
        } */
        struct netbsd32_sigvec sv32;
        struct sigaction nsa, osa;
        int error;

        if (SCARG(uap, signum) >= 32)
                return EINVAL;

        if (SCARG_P32(uap, nsv)) {
                error = copyin(SCARG_P32(uap, nsv), &sv32, sizeof(sv32));
                if (error)
                        return error;
                nsa.sa_handler = NETBSD32PTR64(sv32.sv_handler);
                nsa.sa_mask.__bits[0] = sv32.sv_mask;
                nsa.sa_mask.__bits[1] = 0;
                nsa.sa_mask.__bits[2] = 0;
                nsa.sa_mask.__bits[3] = 0;
                nsa.sa_flags = sv32.sv_flags ^ SA_RESTART;
                error = sigaction1(l, SCARG(uap, signum), &nsa, &osa, NULL, 0);
        } else
                error = sigaction1(l, SCARG(uap, signum), NULL, &osa, NULL, 0);
        if (error)
                return error;

        if (SCARG_P32(uap, osv)) {
                memset(&sv32, 0, sizeof(sv32));
                NETBSD32PTR32(sv32.sv_handler, osa.sa_handler);
                sv32.sv_mask = osa.sa_mask.__bits[0];
                sv32.sv_flags = osa.sa_flags ^ SA_RESTART;
                error = copyout(&sv32, SCARG_P32(uap, osv), sizeof(sv32));
        }

        return error;
}

int
compat_43_netbsd32_sigblock(struct lwp *l, const struct compat_43_netbsd32_sigblock_args *uap, register_t *retval)
{
        /* {
                syscallarg(int) mask;
        } */
        struct compat_43_sys_sigblock_args ua;

        NETBSD32TO64_UAP(mask);
        return compat_43_sys_sigblock(l, &ua, retval);
}

int
compat_43_netbsd32_sigsetmask(struct lwp *l, const struct compat_43_netbsd32_sigsetmask_args *uap, register_t *retval)
{
        /* {
                syscallarg(int) mask;
        } */
        struct compat_43_sys_sigsetmask_args ua;

        NETBSD32TO64_UAP(mask);
        return compat_43_sys_sigsetmask(l, &ua, retval);
}

int
compat_43_netbsd32_osigstack(struct lwp *l, const struct compat_43_netbsd32_osigstack_args *uap, register_t *retval)
{
        /* {
                syscallarg(netbsd32_sigstackp_t) nss;
                syscallarg(netbsd32_sigstackp_t) oss;
        } */
        struct netbsd32_sigstack ss32;
        stack_t nsa, osa;
        int error;

        if (SCARG_P32(uap, nss)) {
                error = copyin(SCARG_P32(uap, nss), &ss32, sizeof(ss32));
                if (error)
                        return error;
                nsa.ss_sp = NETBSD32PTR64(ss32.ss_sp);
                nsa.ss_size = SIGSTKSZ; /* Use the recommended size */
                nsa.ss_flags = ss32.ss_onstack ? SS_ONSTACK : 0;
                error = sigaltstack1(l, &nsa, &osa);
        } else
                error = sigaltstack1(l, NULL, &osa);
        if (error)
                return error;

        if (SCARG_P32(uap, oss)) {
                memset(&ss32, 0, sizeof(ss32));
                NETBSD32PTR32(ss32.ss_sp, osa.ss_sp);
                ss32.ss_onstack = (osa.ss_flags & SS_ONSTACK) != 0;
                error = copyout(&ss32, SCARG_P32(uap, oss), sizeof(ss32));
        }

        return error;
}

static struct syscall_package compat_netbsd32_43_syscalls[] = {
        { NETBSD32_SYS_compat_43_netbsd32_ocreat, 0,
            (sy_call_t *)compat_43_netbsd32_ocreat },
        { NETBSD32_SYS_compat_43_netbsd32_olseek, 0,
            (sy_call_t *)compat_43_netbsd32_olseek },
        { NETBSD32_SYS_compat_43_netbsd32_stat43, 0,
            (sy_call_t *)compat_43_netbsd32_stat43 },
        { NETBSD32_SYS_compat_43_netbsd32_lstat43, 0,
            (sy_call_t *)compat_43_netbsd32_lstat43 },
        { NETBSD32_SYS_compat_43_netbsd32_fstat43, 0,
            (sy_call_t *)compat_43_netbsd32_fstat43 },
        { NETBSD32_SYS_compat_43_netbsd32_otruncate, 0,
            (sy_call_t *)compat_43_netbsd32_otruncate },
        { NETBSD32_SYS_compat_43_netbsd32_oftruncate, 0,
            (sy_call_t *)compat_43_netbsd32_oftruncate },
        { NETBSD32_SYS_compat_43_netbsd32_ogetdirentries, 0,
            (sy_call_t *)compat_43_netbsd32_ogetdirentries },
        { NETBSD32_SYS_compat_43_netbsd32_ogetkerninfo, 0,
            (sy_call_t *)compat_43_netbsd32_ogetkerninfo },
        { NETBSD32_SYS_compat_43_netbsd32_ogethostname, 0,
            (sy_call_t *)compat_43_netbsd32_ogethostname },
        { NETBSD32_SYS_compat_43_netbsd32_osethostname, 0,
            (sy_call_t *)compat_43_netbsd32_osethostname },
        { NETBSD32_SYS_compat_43_netbsd32_sethostid, 0,
            (sy_call_t *)compat_43_netbsd32_sethostid },
        { NETBSD32_SYS_compat_43_netbsd32_ogetrlimit, 0,
            (sy_call_t *)compat_43_netbsd32_ogetrlimit },
        { NETBSD32_SYS_compat_43_netbsd32_osetrlimit, 0,
            (sy_call_t *)compat_43_netbsd32_osetrlimit },
        { NETBSD32_SYS_compat_43_netbsd32_killpg, 0,
            (sy_call_t *)compat_43_netbsd32_killpg },
        { NETBSD32_SYS_compat_43_netbsd32_ommap, 0,
            (sy_call_t *)compat_43_netbsd32_ommap },
        { NETBSD32_SYS_compat_43_netbsd32_oaccept, 0,
            (sy_call_t *)compat_43_netbsd32_oaccept },
        { NETBSD32_SYS_compat_43_netbsd32_osend, 0,
            (sy_call_t *)compat_43_netbsd32_osend },
        { NETBSD32_SYS_compat_43_netbsd32_orecv, 0,
            (sy_call_t *)compat_43_netbsd32_orecv },
        { NETBSD32_SYS_compat_43_netbsd32_orecvmsg, 0,
            (sy_call_t *)compat_43_netbsd32_orecvmsg },
        { NETBSD32_SYS_compat_43_netbsd32_osendmsg, 0,
            (sy_call_t *)compat_43_netbsd32_osendmsg },
        { NETBSD32_SYS_compat_43_netbsd32_orecvfrom, 0,
            (sy_call_t *)compat_43_netbsd32_orecvfrom },
        { NETBSD32_SYS_compat_43_netbsd32_ogetsockname, 0,
            (sy_call_t *)compat_43_netbsd32_ogetsockname },
        { NETBSD32_SYS_compat_43_netbsd32_ogetpeername, 0,
            (sy_call_t *)compat_43_netbsd32_ogetpeername },
        { NETBSD32_SYS_compat_43_netbsd32_osigvec, 0,
            (sy_call_t *)compat_43_netbsd32_osigvec },
        { NETBSD32_SYS_compat_43_netbsd32_sigblock, 0,
            (sy_call_t *)compat_43_netbsd32_sigblock },
        { NETBSD32_SYS_compat_43_netbsd32_sigsetmask, 0,
            (sy_call_t *)compat_43_netbsd32_sigsetmask },
        { NETBSD32_SYS_compat_43_netbsd32_osigstack, 0,
            (sy_call_t *)compat_43_netbsd32_osigstack },
/*
 * These syscalls are provided by emul_netbsd compat_43 code, but their
 * entry points must still be loaded in the emul_netbsd32 disatch table
 */
        { NETBSD32_SYS_compat_43_ogetpagesize, 0,
            (sy_call_t *)compat_43_sys_getpagesize },
        { NETBSD32_SYS_compat_43_ogetdtablesize, 0,
            (sy_call_t *)compat_43_sys_getdtablesize},
        { NETBSD32_SYS_compat_43_ogethostid, 0,
            (sy_call_t *)compat_43_sys_gethostid },
        { NETBSD32_SYS_compat_43_owait, 0,
            (sy_call_t *)compat_43_sys_wait },
/*
 * Skip oquota since it isn't part of compat_43
 *      { NETBSD32_SYS_compat_43_oquota, 0,
 *          (sy_call_t *)compat_43_sys_quota },
 */

/* End of compat_43 syscalls */

        { 0, 0, NULL }
}; 

MODULE(MODULE_CLASS_EXEC, compat_netbsd32_43, "compat_netbsd32,compat_43");

static int
compat_netbsd32_43_modcmd(modcmd_t cmd, void *arg)
{

        switch (cmd) {
        case MODULE_CMD_INIT:
                return syscall_establish(&emul_netbsd32,
                    compat_netbsd32_43_syscalls);

        case MODULE_CMD_FINI:
                return syscall_disestablish(&emul_netbsd32,
                    compat_netbsd32_43_syscalls);

        default:
                return ENOTTY;
        }
}