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; }