int
linux32_sys_futex(struct lwp *l,
const struct linux32_sys_futex_args *uap, register_t *retval)
{
/* {
syscallarg(linux32_intp_t) uaddr;
syscallarg(int) op;
syscallarg(int) val;
syscallarg(linux32_timespecp_t) timeout;
syscallarg(linux32_intp_t) uaddr2;
syscallarg(int) val3;
} */
struct linux_sys_futex_args ua;
struct linux32_timespec lts;
struct timespec ts = { 0, 0 };
int error;
NETBSD32TOP_UAP(uaddr, int);
NETBSD32TO64_UAP(op);
NETBSD32TO64_UAP(val);
NETBSD32TOP_UAP(timeout, struct linux_timespec);
NETBSD32TOP_UAP(uaddr2, int);
NETBSD32TO64_UAP(val3);
if ((SCARG(uap, op) & ~LINUX_FUTEX_PRIVATE_FLAG) == LINUX_FUTEX_WAIT &&
SCARG_P32(uap, timeout) != NULL) {
if ((error = copyin((void *)SCARG_P32(uap, timeout),
<s, sizeof(lts))) != 0) {
return error;
}
linux32_to_native_timespec(&ts, <s);
}
return linux_do_futex(l, &ua, retval, &ts);
}
int
netbsd32___setitimer50(struct lwp *l, const struct netbsd32___setitimer50_args *uap, register_t *retval)
{
/* {
syscallarg(int) which;
syscallarg(const netbsd32_itimervalp_t) itv;
syscallarg(netbsd32_itimervalp_t) oitv;
} */
struct proc *p = l->l_proc;
struct netbsd32_itimerval s32it, *itv32;
int which = SCARG(uap, which);
struct netbsd32___getitimer50_args getargs;
struct itimerval aitv;
int error;
if ((u_int)which > ITIMER_PROF)
return (EINVAL);
itv32 = SCARG_P32(uap, itv);
if (itv32) {
if ((error = copyin(itv32, &s32it, sizeof(s32it))))
return (error);
netbsd32_to_itimerval(&s32it, &aitv);
}
if (SCARG_P32(uap, oitv) != 0) {
SCARG(&getargs, which) = which;
SCARG(&getargs, itv) = SCARG(uap, oitv);
if ((error = netbsd32___getitimer50(l, &getargs, retval)) != 0)
return (error);
}
if (itv32 == 0)
return 0;
return dosetitimer(p, which, &aitv);
}
int
linux32_sys_fstatat64(struct lwp *l, const struct linux32_sys_fstatat64_args *uap, register_t *retval)
{
/* {
syscallarg(int) fd;
syscallarg(netbsd32_charp) path;
syscallarg(linux32_stat64p) sp;
syscallarg(int) flag;
} */
int error, nd_flag;
struct stat st;
struct linux32_stat64 st32;
if (SCARG(uap, flag) & LINUX_AT_SYMLINK_NOFOLLOW)
nd_flag = NOFOLLOW;
else
nd_flag = FOLLOW;
error = do_sys_statat(l, SCARG(uap, fd), SCARG_P32(uap, path), nd_flag, &st);
if (error != 0)
return error;
bsd_to_linux32_stat64(&st, &st32);
return copyout(&st32, SCARG_P32(uap, sp), sizeof st32);
}
int
compat_50_netbsd32_mq_timedsend(struct lwp *l,
const struct compat_50_netbsd32_mq_timedsend_args *uap,
register_t *retval)
{
/* {
syscallarg(mqd_t) mqdes;
syscallarg(const netbsd32_charp) msg_ptr;
syscallarg(netbsd32_size_t) msg_len;
syscallarg(unsigned) msg_prio;
syscallarg(const netbsd32_timespec50p_t) abs_timeout;
} */
struct timespec ts, *tsp;
struct netbsd32_timespec50 ts32;
int error;
/* Get and convert time value */
if (SCARG_P32(uap, abs_timeout)) {
error = copyin(SCARG_P32(uap, abs_timeout), &ts32,
sizeof(ts32));
if (error)
return error;
netbsd32_to_timespec50(&ts32, &ts);
tsp = &ts;
} else {
tsp = NULL;
}
return mq_send1(SCARG(uap, mqdes), SCARG_P32(uap, msg_ptr),
SCARG(uap, msg_len), SCARG(uap, msg_prio), tsp);
}
int
compat_50_netbsd32_nanosleep(struct lwp *l,
const struct compat_50_netbsd32_nanosleep_args *uap, register_t *retval)
{
/* {
syscallarg(const netbsd32_timespec50p_t) rqtp;
syscallarg(netbsd32_timespecp_t) rmtp;
} */
struct netbsd32_timespec50 ts32;
struct timespec rqt, rmt;
int error, error1;
error = copyin(SCARG_P32(uap, rqtp), &ts32, sizeof(ts32));
if (error)
return (error);
netbsd32_to_timespec50(&ts32, &rqt);
error = nanosleep1(l, CLOCK_MONOTONIC, 0, &rqt,
SCARG_P32(uap, rmtp) ? &rmt : NULL);
if (SCARG_P32(uap, rmtp) == NULL || (error != 0 && error != EINTR))
return error;
netbsd32_from_timespec50(&rmt, &ts32);
error1 = copyout(&ts32, SCARG_P32(uap,rmtp), sizeof(ts32));
return error1 ? error1 : error;
}
int
netbsd32_mq_open(struct lwp *l, const struct netbsd32_mq_open_args *uap,
register_t *retval)
{
/* {
syscallarg(const netbsd32_charp) name;
syscallarg(int) oflag;
syscallarg(mode_t) mode;
syscallarg(struct netbsd32_mq_attrp_t) attr;
} */
struct netbsd32_mq_attr attr32;
struct mq_attr *attr = NULL, a;
int error;
if ((SCARG(uap, oflag) & O_CREAT) && SCARG_P32(uap, attr) != NULL) {
error = copyin(SCARG_P32(uap, attr), &attr32, sizeof(attr32));
if (error)
return error;
netbsd32_to_mq_attr(&attr32, &a);
attr = &a;
}
return mq_handle_open(l, SCARG_P32(uap, name), SCARG(uap, oflag),
SCARG(uap, mode), attr, retval);
}
int
compat_20_netbsd32_statfs(struct lwp *l, const struct compat_20_netbsd32_statfs_args *uap, register_t *retval)
{
/* {
syscallarg(const netbsd32_charp) path;
syscallarg(netbsd32_statfsp_t) buf;
} */
struct mount *mp;
struct statvfs *sp;
struct netbsd32_statfs s32;
int error;
struct nameidata nd;
NDINIT(&nd, LOOKUP, FOLLOW | TRYEMULROOT, UIO_USERSPACE,
SCARG_P32(uap, path));
if ((error = namei(&nd)) != 0)
return (error);
mp = nd.ni_vp->v_mount;
sp = &mp->mnt_stat;
vrele(nd.ni_vp);
if ((error = VFS_STATVFS(mp, sp)) != 0)
return (error);
sp->f_flag = mp->mnt_flag & MNT_VISFLAGMASK;
compat_20_netbsd32_from_statvfs(sp, &s32);
return copyout(&s32, SCARG_P32(uap, buf), sizeof(s32));
}
int
netbsd32_clock_nanosleep(struct lwp *l, const struct netbsd32_clock_nanosleep_args *uap, register_t *retval)
{
/* {
clockid_t clock_id;
int flags;
syscallarg(const netbsd32_timespecp_t) rqtp;
syscallarg(netbsd32_timespecp_t) rmtp;
} */
struct netbsd32_timespec ts32;
struct timespec rqt, rmt;
int error, error1;
error = copyin(SCARG_P32(uap, rqtp), &ts32, sizeof(ts32));
if (error)
return (error);
netbsd32_to_timespec(&ts32, &rqt);
error = nanosleep1(l, SCARG(uap, clock_id), SCARG(uap, flags),
&rqt, SCARG_P32(uap, rmtp) ? &rmt : NULL);
if (SCARG_P32(uap, rmtp) == NULL || (error != 0 && error != EINTR))
return error;
netbsd32_from_timespec(&rmt, &ts32);
error1 = copyout(&ts32, SCARG_P32(uap, rmtp), sizeof(ts32));
return error1 ? error1 : error;
}
int
compat_60_netbsd32__lwp_park(struct lwp *l,
const struct compat_60_netbsd32__lwp_park_args *uap, register_t *retval)
{
/* {
syscallarg(const netbsd32_timespecp) ts;
syscallarg(lwpid_t) unpark;
syscallarg(netbsd32_voidp) hint;
syscallarg(netbsd32_voidp) unparkhint;
} */
struct timespec ts, *tsp;
struct netbsd32_timespec ts32;
int error;
if (SCARG_P32(uap, ts) == NULL)
tsp = NULL;
else {
error = copyin(SCARG_P32(uap, ts), &ts32, sizeof ts32);
if (error != 0)
return error;
tsp = &ts;
}
if (SCARG(uap, unpark) != 0) {
error = lwp_unpark(SCARG(uap, unpark),
SCARG_P32(uap, unparkhint));
if (error != 0)
return error;
}
return lwp_park(CLOCK_REALTIME, TIMER_ABSTIME, tsp,
SCARG_P32(uap, hint));
}
int
compat_50_netbsd32_ntp_gettime(struct lwp *l,
const struct compat_50_netbsd32_ntp_gettime_args *uap, register_t *retval)
{
/* {
syscallarg(netbsd32_ntptimeval50p_t) ntvp;
} */
struct netbsd32_ntptimeval50 ntv32;
struct ntptimeval ntv;
int error = 0;
if (SCARG_P32(uap, ntvp)) {
ntp_gettime(&ntv);
ntv32.time.tv_sec = (int32_t)ntv.time.tv_sec;
ntv32.time.tv_nsec = ntv.time.tv_nsec;
ntv32.maxerror = (netbsd32_long)ntv.maxerror;
ntv32.esterror = (netbsd32_long)ntv.esterror;
ntv32.tai = (netbsd32_long)ntv.tai;
ntv32.time_state = ntv.time_state;
error = copyout(&ntv32, SCARG_P32(uap, ntvp), sizeof(ntv32));
}
if (!error) {
*retval = ntp_timestatus();
}
return (error);
}
int
netbsd32___shmctl13(struct lwp *l, const struct netbsd32___shmctl13_args *uap, register_t *retval)
{
/* {
syscallarg(int) shmid;
syscallarg(int) cmd;
syscallarg(netbsd32_shmid_dsp_t) buf;
} */
struct shmid_ds ds;
struct netbsd32_shmid_ds ds32;
int error, cmd;
cmd = SCARG(uap, cmd);
if (cmd == IPC_SET) {
error = copyin(SCARG_P32(uap, buf), &ds32, sizeof(ds32));
if (error)
return error;
netbsd32_to_shmid_ds(&ds32, &ds);
}
error = shmctl1(l, SCARG(uap, shmid), cmd,
(cmd == IPC_SET || cmd == IPC_STAT) ? &ds : NULL);
if (error == 0 && cmd == IPC_STAT) {
netbsd32_from_shmid_ds(&ds, &ds32);
error = copyout(&ds32, SCARG_P32(uap, buf), sizeof(ds32));
}
return error;
}
int
compat_30_netbsd32_fhstatvfs1(struct lwp *l, const struct compat_30_netbsd32_fhstatvfs1_args *uap, register_t *retval)
{
/* {
syscallarg(const netbsd32_fhandlep_t) fhp;
syscallarg(netbsd32_statvfsp_t) buf;
syscallarg(int) flags;
} */
struct statvfs *sbuf;
struct netbsd32_statvfs *s32;
int error;
sbuf = STATVFSBUF_GET();
error = do_fhstatvfs(l, SCARG_P32(uap, fhp), FHANDLE_SIZE_COMPAT, sbuf,
SCARG(uap, flags));
if (error != 0) {
s32 = kmem_alloc(sizeof(*s32), KM_SLEEP);
netbsd32_from_statvfs(sbuf, s32);
error = copyout(s32, SCARG_P32(uap, buf), sizeof *s32);
kmem_free(s32, sizeof(*s32));
}
STATVFSBUF_PUT(sbuf);
return (error);
}
int
compat_50_netbsd32_timer_settime(struct lwp *l,
const struct compat_50_netbsd32_timer_settime_args *uap, register_t *retval)
{
/* {
syscallarg(netbsd32_timer_t) timerid;
syscallarg(int) flags;
syscallarg(const netbsd32_itimerspec50p_t) value;
syscallarg(netbsd32_itimerspec50p_t) ovalue;
} */
int error;
struct itimerspec value, ovalue, *ovp = NULL;
struct netbsd32_itimerspec50 its32;
if ((error = copyin(SCARG_P32(uap, value), &its32, sizeof(its32))) != 0)
return (error);
netbsd32_to_timespec50(&its32.it_interval, &value.it_interval);
netbsd32_to_timespec50(&its32.it_value, &value.it_value);
if (SCARG_P32(uap, ovalue))
ovp = &ovalue;
if ((error = dotimer_settime(SCARG(uap, timerid), &value, ovp,
SCARG(uap, flags), l->l_proc)) != 0)
return error;
if (ovp) {
netbsd32_from_timespec50(&ovp->it_interval, &its32.it_interval);
netbsd32_from_timespec50(&ovp->it_value, &its32.it_value);
return copyout(&its32, SCARG_P32(uap, ovalue), sizeof(its32));
}
return 0;
}
int
netbsd32___mq_timedreceive50(struct lwp *l,
const struct netbsd32___mq_timedreceive50_args *uap, register_t *retval)
{
/* {
syscallarg(mqd_t) mqdes;
syscallarg(netbsd32_charp) msg_ptr;
syscallarg(netbsd32_size_t) msg_len;
syscallarg(netbsd32_uintp) msg_prio;
syscallarg(const netbsd32_timespecp_t) abs_timeout;
} */
struct timespec ts, *tsp;
struct netbsd32_timespec ts32;
ssize_t mlen;
int error;
/* Get and convert time value */
if (SCARG_P32(uap, abs_timeout)) {
error = copyin(SCARG_P32(uap, abs_timeout), &ts32,
sizeof(ts32));
if (error)
return error;
netbsd32_to_timespec(&ts32, &ts);
tsp = &ts;
} else {
tsp = NULL;
}
error = mq_recv1(SCARG(uap, mqdes), SCARG_P32(uap, msg_ptr),
SCARG(uap, msg_len), SCARG_P32(uap, msg_prio), tsp, &mlen);
if (error == 0)
*retval = mlen;
return error;
}
int
compat_20_netbsd32_statfs(struct lwp *l, const struct compat_20_netbsd32_statfs_args *uap, register_t *retval)
{
/* {
syscallarg(const netbsd32_charp) path;
syscallarg(netbsd32_statfsp_t) buf;
} */
struct mount *mp;
struct statvfs *sp;
struct netbsd32_statfs s32;
int error;
struct vnode *vp;
error = namei_simple_user(SCARG_P32(uap, path),
NSM_FOLLOW_TRYEMULROOT, &vp);
if (error != 0)
return (error);
mp = vp->v_mount;
sp = &mp->mnt_stat;
vrele(vp);
if ((error = VFS_STATVFS(mp, sp)) != 0)
return (error);
sp->f_flag = mp->mnt_flag & MNT_VISFLAGMASK;
compat_20_netbsd32_from_statvfs(sp, &s32);
return copyout(&s32, SCARG_P32(uap, buf), sizeof(s32));
}
int
compat_50_netbsd32_settimeofday(struct lwp *l,
const struct compat_50_netbsd32_settimeofday_args *uap, register_t *retval)
{
/* {
syscallarg(const netbsd32_timeval50p_t) tv;
syscallarg(const netbsd32_timezonep_t) tzp;
} */
struct netbsd32_timeval50 atv32;
struct timeval atv;
struct timespec ats;
int error;
struct proc *p = l->l_proc;
/* Verify all parameters before changing time. */
/*
* NetBSD has no kernel notion of time zone, and only an
* obsolete program would try to set it, so we log a warning.
*/
if (SCARG_P32(uap, tzp))
printf("pid %d attempted to set the "
"(obsolete) kernel time zone\n", p->p_pid);
if (SCARG_P32(uap, tv) == 0)
return 0;
if ((error = copyin(SCARG_P32(uap, tv), &atv32, sizeof(atv32))) != 0)
return error;
netbsd32_to_timeval50(&atv32, &atv);
TIMEVAL_TO_TIMESPEC(&atv, &ats);
return settime(p, &ats);
}
int
compat_50_netbsd32_gettimeofday(struct lwp *l,
const struct compat_50_netbsd32_gettimeofday_args *uap, register_t *retval)
{
/* {
syscallarg(netbsd32_timeval50p_t) tp;
syscallarg(netbsd32_timezonep_t) tzp;
} */
struct timeval atv;
struct netbsd32_timeval50 tv32;
int error = 0;
struct netbsd32_timezone tzfake;
if (SCARG_P32(uap, tp)) {
microtime(&atv);
netbsd32_from_timeval50(&atv, &tv32);
error = copyout(&tv32, SCARG_P32(uap, tp), sizeof(tv32));
if (error)
return error;
}
if (SCARG_P32(uap, tzp)) {
/*
* NetBSD has no kernel notion of time zone, so we just
* fake up a timezone struct and return it if demanded.
*/
tzfake.tz_minuteswest = 0;
tzfake.tz_dsttime = 0;
error = copyout(&tzfake, SCARG_P32(uap, tzp), sizeof(tzfake));
}
return error;
}
int
compat_50_netbsd32_select(struct lwp *l,
const struct compat_50_netbsd32_select_args *uap, register_t *retval)
{
/* {
syscallarg(int) nd;
syscallarg(netbsd32_fd_setp_t) in;
syscallarg(netbsd32_fd_setp_t) ou;
syscallarg(netbsd32_fd_setp_t) ex;
syscallarg(netbsd32_timeval50p_t) tv;
} */
int error;
struct netbsd32_timeval50 tv32;
struct timespec ats, *ts = NULL;
if (SCARG_P32(uap, tv)) {
error = copyin(SCARG_P32(uap, tv), &tv32, sizeof(tv32));
if (error != 0)
return error;
ats.tv_sec = tv32.tv_sec;
ats.tv_nsec = tv32.tv_usec * 1000;
ts = &ats;
}
return selcommon(retval, SCARG(uap, nd), SCARG_P32(uap, in),
SCARG_P32(uap, ou), SCARG_P32(uap, ex), ts, NULL);
return 0;
}
static int
linux32_shmctl(struct lwp *l, const struct linux32_sys_ipc_args *uap,
register_t *retval)
{
int shmid, cmd, error;
struct shmid_ds bs;
struct linux32_shmid_ds ls;
struct linux32_shmid64_ds ls64;
shmid = SCARG(uap, a1);
cmd = SCARG(uap, a2);
switch (cmd & ~LINUX32_IPC_64) {
case LINUX32_SHM_STAT:
return ENOSYS;
case LINUX32_IPC_STAT:
error = shmctl1(l, shmid, IPC_STAT, &bs);
if (error != 0)
return error;
if (cmd & LINUX32_IPC_64) {
bsd_to_linux32_shmid64_ds(&bs, &ls64);
error = copyout(&ls64, SCARG_P32(uap, ptr), sizeof ls64);
} else {
bsd_to_linux32_shmid_ds(&bs, &ls);
error = copyout(&ls, SCARG_P32(uap, ptr), sizeof ls);
}
return error;
case LINUX32_IPC_SET:
if (cmd & LINUX32_IPC_64) {
error = copyin(SCARG_P32(uap, ptr), &ls64, sizeof ls64);
linux32_to_bsd_shmid64_ds(&ls64, &bs);
} else {
error = copyin(SCARG_P32(uap, ptr), &ls, sizeof ls);
linux32_to_bsd_shmid_ds(&ls, &bs);
}
if (error != 0)
return error;
return shmctl1(l, shmid, IPC_SET, &bs);
case LINUX32_IPC_RMID:
return shmctl1(l, shmid, IPC_RMID, NULL);
case LINUX32_SHM_LOCK:
return shmctl1(l, shmid, SHM_LOCK, NULL);
case LINUX32_SHM_UNLOCK:
return shmctl1(l, shmid, SHM_UNLOCK, NULL);
case LINUX32_IPC_INFO:
case LINUX32_SHM_INFO:
return ENOSYS;
default:
return EINVAL;
}
}
int
svr4_32_sys_utimes(struct lwp *l, const struct svr4_32_sys_utimes_args *uap, register_t *retval)
{
struct sys_utimes_args ua;
SCARG(&ua, path) = SCARG_P32(uap, path);
SCARG(&ua, tptr) = SCARG_P32(uap, tptr);
return sys_utimes(l, &ua, retval);
}
int
linux32_sys_wait4(struct lwp *l, const struct linux32_sys_wait4_args *uap, register_t *retval)
{
/* {
syscallarg(int) pid;
syscallarg(netbsd32_intp) status;
syscallarg(int) options;
syscallarg(netbsd32_rusage50p_t) rusage;
} */
int error, status, linux_options, options, pid;
struct netbsd32_rusage50 ru32;
struct rusage ru;
proc_t *p;
linux_options = SCARG(uap, options);
options = WOPTSCHECKED;
if (linux_options & ~(LINUX_WAIT4_KNOWNFLAGS))
return EINVAL;
if (linux_options & LINUX_WAIT4_WNOHANG)
options |= WNOHANG;
if (linux_options & LINUX_WAIT4_WUNTRACED)
options |= WUNTRACED;
if (linux_options & LINUX_WAIT4_WALL)
options |= WALLSIG;
if (linux_options & LINUX_WAIT4_WCLONE)
options |= WALTSIG;
pid = SCARG(uap, pid);
error = do_sys_wait(&pid, &status, options,
SCARG_P32(uap, rusage) != NULL ? &ru : NULL);
retval[0] = pid;
if (pid == 0)
return error;
p = curproc;
mutex_enter(p->p_lock);
sigdelset(&p->p_sigpend.sp_set, SIGCHLD); /* XXXAD ksiginfo leak */
mutex_exit(p->p_lock);
if (SCARG_P32(uap, rusage) != NULL) {
netbsd32_from_rusage50(&ru, &ru32);
error = copyout(&ru32, SCARG_P32(uap, rusage), sizeof(ru32));
}
if (error == 0 && SCARG_P32(uap, status) != NULL) {
status = bsd_to_linux_wstat(status);
error = copyout(&status, SCARG_P32(uap, status), sizeof(status));
}
return error;
}
int
netbsd32_execve(struct lwp *l, const struct netbsd32_execve_args *uap, register_t *retval)
{
/* {
syscallarg(const netbsd32_charp) path;
syscallarg(netbsd32_charpp) argp;
syscallarg(netbsd32_charpp) envp;
} */
const char *path = SCARG_P32(uap, path);
return execve1(l, path, SCARG_P32(uap, argp),
SCARG_P32(uap, envp), netbsd32_execve_fetch_element);
}
int
netbsd32_timer_create(struct lwp *l, const struct netbsd32_timer_create_args *uap, register_t *retval)
{
/* {
syscallarg(netbsd32_clockid_t) clock_id;
syscallarg(netbsd32_sigeventp_t) evp;
syscallarg(netbsd32_timerp_t) timerid;
} */
return timer_create1(SCARG_P32(uap, timerid),
SCARG(uap, clock_id), SCARG_P32(uap, evp),
netbsd32_timer_create_fetch, l);
}
int
netbsd32_mq_setattr(struct lwp *l, const struct netbsd32_mq_setattr_args *uap,
register_t *retval)
{
/* {
syscallarg(mqd_t) mqdes;
syscallarg(const netbsd32_mq_attrp_t) mqstat;
syscallarg(netbsd32_mq_attrp_t) omqstat;
} */
struct mqueue *mq;
struct netbsd32_mq_attr attr32;
struct mq_attr attr;
int error, nonblock;
error = copyin(SCARG_P32(uap, mqstat), &attr32, sizeof(attr32));
if (error)
return error;
netbsd32_to_mq_attr(&attr32, &attr);
nonblock = (attr.mq_flags & O_NONBLOCK);
error = mqueue_get(SCARG(uap, mqdes), 0, &mq);
if (error)
return error;
/* Copy the old attributes, if needed */
if (SCARG_P32(uap, omqstat))
memcpy(&attr, &mq->mq_attrib, sizeof(struct mq_attr));
/* Ignore everything, except O_NONBLOCK */
if (nonblock)
mq->mq_attrib.mq_flags |= O_NONBLOCK;
else
mq->mq_attrib.mq_flags &= ~O_NONBLOCK;
mutex_exit(&mq->mq_mtx);
fd_putfile((int)SCARG(uap, mqdes));
/*
* Copy the data to the user-space.
* Note: According to POSIX, the new attributes should not be set in
* case of fail - this would be violated.
*/
if (SCARG_P32(uap, omqstat)) {
netbsd32_from_mq_attr(&attr, &attr32);
error = copyout(&attr32, SCARG_P32(uap, omqstat),
sizeof(attr32));
}
return error;
}
int
netbsd32__ksem_open(struct lwp *l, const struct netbsd32__ksem_open_args *uap, register_t *retval)
{
/* {
syscallarg(const netbsd32_charp) name;
syscallarg(int) oflag;
syscallarg(mode_t) mode;
syscallarg(unsigned int) value;
syscallarg(netbsd32_semidp_t) idp;
} */
return do_ksem_open(l, SCARG_P32(uap, name),
SCARG(uap, oflag), SCARG(uap, mode), SCARG(uap, value),
SCARG_P32(uap, idp), netbsd32_ksem_copyout);
}
int
compat_50_netbsd32_adjtime(struct lwp *l,
const struct compat_50_netbsd32_adjtime_args *uap, register_t *retval)
{
/* {
syscallarg(const netbsd32_timeval50p_t) delta;
syscallarg(netbsd32_timeval50p_t) olddelta;
} */
struct netbsd32_timeval50 atv;
int error;
extern int time_adjusted; /* in kern_ntptime.c */
extern int64_t time_adjtime; /* in kern_ntptime.c */
if ((error = kauth_authorize_system(l->l_cred,
KAUTH_SYSTEM_TIME, KAUTH_REQ_SYSTEM_TIME_ADJTIME, NULL, NULL,
NULL)) != 0)
return (error);
if (SCARG_P32(uap, olddelta)) {
atv.tv_sec = time_adjtime / 1000000;
atv.tv_usec = time_adjtime % 1000000;
if (atv.tv_usec < 0) {
atv.tv_usec += 1000000;
atv.tv_sec--;
}
(void) copyout(&atv,
SCARG_P32(uap, olddelta),
sizeof(atv));
if (error)
return (error);
}
if (SCARG_P32(uap, delta)) {
error = copyin(SCARG_P32(uap, delta), &atv,
sizeof(struct timeval));
if (error)
return (error);
time_adjtime = (int64_t)atv.tv_sec * 1000000 + atv.tv_usec;
if (time_adjtime)
/* We need to save the system time during shutdown */
time_adjusted |= 1;
}
return 0;
}
int
linux32_sys_signal(struct lwp *l, const struct linux32_sys_signal_args *uap, register_t *retval)
{
/* {
syscallarg(int) signum;
syscallarg(linux32_handlerp_t) handler;
} */
struct sigaction nbsa, obsa;
int error, sig;
*retval = -1;
sig = SCARG(uap, signum);
if (sig < 0 || sig >= LINUX32__NSIG)
return EINVAL;
nbsa.sa_handler = SCARG_P32(uap, handler);
sigemptyset(&nbsa.sa_mask);
nbsa.sa_flags = SA_RESETHAND | SA_NODEFER;
if ((error = sigaction1(l, linux32_to_native_signo[sig],
&nbsa, &obsa, NULL, 0)) != 0)
return error;
*retval = (int)(long)obsa.sa_handler;
return 0;
}
int
compat_20_netbsd32_fstatfs(struct lwp *l, const struct compat_20_netbsd32_fstatfs_args *uap, register_t *retval)
{
/* {
syscallarg(int) fd;
syscallarg(netbsd32_statfsp_t) buf;
} */
file_t *fp;
struct mount *mp;
struct statvfs *sp;
struct netbsd32_statfs s32;
int error;
/* fd_getvnode() will use the descriptor for us */
if ((error = fd_getvnode(SCARG(uap, fd), &fp)) != 0)
return (error);
mp = ((struct vnode *)fp->f_data)->v_mount;
sp = &mp->mnt_stat;
if ((error = VFS_STATVFS(mp, sp)) != 0)
goto out;
sp->f_flag = mp->mnt_flag & MNT_VISFLAGMASK;
compat_20_netbsd32_from_statvfs(sp, &s32);
error = copyout(&s32, SCARG_P32(uap, buf), sizeof(s32));
out:
fd_putfile(SCARG(uap, fd));
return (error);
}
int
compat_30_netbsd32_getdents(struct lwp *l, const struct compat_30_netbsd32_getdents_args *uap, register_t *retval)
{
/* {
syscallarg(int) fd;
syscallarg(netbsd32_charp) buf;
syscallarg(netbsd32_size_t) count;
} */
file_t *fp;
int error, done;
char *buf;
netbsd32_size_t count;
/* Limit the size on any kernel buffers used by VOP_READDIR */
count = min(MAXBSIZE, SCARG(uap, count));
/* fd_getvnode() will use the descriptor for us */
if ((error = fd_getvnode(SCARG(uap, fd), &fp)) != 0)
return (error);
if ((fp->f_flag & FREAD) == 0) {
error = EBADF;
goto out;
}
buf = kmem_alloc(count, KM_SLEEP);
error = vn_readdir(fp, buf, UIO_SYSSPACE, count, &done, l, 0, 0);
if (error == 0) {
*retval = netbsd32_to_dirent12(buf, done);
error = copyout(buf, SCARG_P32(uap, buf), *retval);
}
kmem_free(buf, count);
out:
fd_putfile(SCARG(uap, fd));
return (error);
}
int
svr4_32_sys_utssys(struct lwp *l, const struct svr4_32_sys_utssys_args *uap, register_t *retval)
{
switch (SCARG(uap, sel)) {
case 0: /* uname(2) */
{
struct svr4_32_sys_uname_args ua;
SCARG(&ua, name) = SCARG(uap, a1);
return svr4_32_sys_uname(l, &ua, retval);
}
case 2: /* ustat(2) */
{
struct svr4_32_ustat_args ua;
SCARG(&ua, dev) = (uintptr_t)SCARG_P32(uap, a2);
SCARG(&ua, name) = SCARG(uap, a1);
return svr4_32_ustat(l, &ua, retval);
}
case 3: /* fusers(2) */
return ENOSYS;
default:
return ENOSYS;
}
return ENOSYS;
}
