Lines Matching +full:ats +full:- +full:supported
1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause
136 FEATURE_ADD("compat_freebsd32", "Compatible with 32-bit FreeBSD");
138 "Compatible with 32-bit FreeBSD (legacy feature name)");
231 if (uap->rusage != NULL)
235 error = kern_wait(td, uap->pid, &status, uap->options, rup);
238 if (uap->status != NULL)
239 error = copyout(&status, uap->status, sizeof(status));
240 if (uap->rusage != NULL && error == 0) {
242 error = copyout(&ru32, uap->rusage, sizeof(ru32));
256 if (uap->wrusage != NULL)
260 if (uap->info != NULL) {
265 error = kern_wait6(td, uap->idtype, PAIR32TO64(id_t, uap->id),
266 &status, uap->options, wrup, sip);
269 if (uap->status != NULL)
270 error = copyout(&status, uap->status, sizeof(status));
271 if (uap->wrusage != NULL && error == 0) {
274 error = copyout(&wru32, uap->wrusage, sizeof(wru32));
276 if (uap->info != NULL && error == 0) {
278 error = copyout(&si32, uap->info, sizeof(si32));
291 out->f_iosize = MIN(in->f_iosize, INT32_MAX);
295 out->f_files = MIN(in->f_files, INT32_MAX);
296 out->f_ffree = MIN(in->f_ffree, INT32_MAX);
301 out->f_syncwrites = MIN(in->f_syncwrites, INT32_MAX);
302 out->f_asyncwrites = MIN(in->f_asyncwrites, INT32_MAX);
303 strlcpy(out->f_fstypename,
304 in->f_fstypename, MFSNAMELEN);
305 strlcpy(out->f_mntonname,
306 in->f_mntonname, min(MNAMELEN, FREEBSD4_OMNAMELEN));
307 out->f_syncreads = MIN(in->f_syncreads, INT32_MAX);
308 out->f_asyncreads = MIN(in->f_asyncreads, INT32_MAX);
309 strlcpy(out->f_mntfromname,
310 in->f_mntfromname, min(MNAMELEN, FREEBSD4_OMNAMELEN));
320 if (uap->bufsize < 0 || uap->bufsize > SIZE_MAX)
322 error = kern_getfsstat(td, &uap->buf, uap->bufsize, &count,
323 UIO_USERSPACE, uap->mode);
325 td->td_retval[0] = count;
339 count = uap->bufsize / sizeof(struct ostatfs32);
341 error = kern_getfsstat(td, &buf, size, &count, UIO_SYSSPACE, uap->mode);
347 error = copyout(&stat32, uap->buf, sizeof(stat32));
349 uap->buf++;
350 copycount--;
355 td->td_retval[0] = count;
365 return(kern_freebsd11_getfsstat(td, uap->buf, uap->bufsize,
366 uap->mode));
378 if (uap->ss != NULL) {
379 error = copyin(uap->ss, &s32, sizeof(s32));
389 if (error == 0 && uap->oss != NULL) {
393 error = copyout(&s32, uap->oss, sizeof(s32));
415 * Allocate demand-paged memory for the file name, argument, and
480 error = freebsd32_exec_copyin_args(&eargs, uap->fname, UIO_USERSPACE,
481 uap->argv, uap->envv);
500 uap->argv, uap->envv);
502 eargs.fd = uap->fd;
514 return (kern_mknodat(td, uap->fd, uap->path, UIO_USERSPACE,
515 uap->mode, PAIR32TO64(dev_t, uap->dev)));
523 prot = uap->prot;
528 return (kern_mprotect(td, (uintptr_t)PTRIN(uap->addr), uap->len,
537 prot = uap->prot;
544 .mr_hint = (uintptr_t)uap->addr,
545 .mr_len = uap->len,
547 .mr_flags = uap->flags,
548 .mr_fd = uap->fd,
549 .mr_pos = PAIR32TO64(off_t, uap->pos),
560 prot = uap->prot;
567 .mr_hint = (uintptr_t)uap->addr,
568 .mr_len = uap->len,
570 .mr_flags = uap->flags,
571 .mr_fd = uap->fd,
572 .mr_pos = PAIR32TO64(off_t, uap->pos),
581 return (kern_ommap(td, (uintptr_t)uap->addr, uap->len, uap->prot,
582 uap->flags, uap->fd, uap->pos));
593 if (uap->itv != NULL) {
594 error = copyin(uap->itv, &i32, sizeof(i32));
602 error = kern_setitimer(td, uap->which, itvp, &oitv);
603 if (error || uap->oitv == NULL)
607 return (copyout(&i32, uap->oitv, sizeof(i32)));
617 error = kern_getitimer(td, uap->which, &itv);
618 if (error || uap->itv == NULL)
622 return (copyout(&i32, uap->itv, sizeof(i32)));
632 if (uap->tv != NULL) {
633 error = copyin(uap->tv, &tv32, sizeof(tv32));
644 return (kern_select(td, uap->nd, uap->in, uap->ou, uap->ex, tvp,
657 if (uap->ts != NULL) {
658 error = copyin(uap->ts, &ts32, sizeof(ts32));
667 if (uap->sm != NULL) {
668 error = copyin(uap->sm, &set, sizeof(set));
677 error = kern_pselect(td, uap->nd, uap->in, uap->ou, uap->ex, tvp,
683 * Copy 'count' items into the destination list pointed to by uap->eventlist.
709 for (j = 0; j < nitems(kevp->ext); j++) {
720 error = copyout(ks32, uap->eventlist, count * sizeof *ks32);
722 uap->eventlist += count;
727 * Copy 'count' items from the list pointed to by uap->changelist.
740 error = copyin(uap->changelist, ks32, count * sizeof *ks32);
743 uap->changelist += count;
752 for (j = 0; j < nitems(kevp->ext); j++) {
780 struct kevent32 *eventlist = uap->eventlist;
784 if (uap->timeout) {
785 error = copyin(uap->timeout, &ts32, sizeof(ts32));
795 ktrstructarray("kevent32", UIO_USERSPACE, uap->changelist,
796 uap->nchanges, sizeof(struct kevent32));
798 error = kern_kevent(td, uap->fd, uap->nchanges, uap->nevents,
803 td->td_retval[0], sizeof(struct kevent32));
827 error = copyout(ks32, uap->eventlist, count * sizeof *ks32);
829 uap->eventlist += count;
834 * Copy 'count' items from the list pointed to by uap->changelist.
846 error = copyin(uap->changelist, ks32, count * sizeof *ks32);
849 uap->changelist += count;
858 for (j = 0; j < nitems(kevp->ext); j++)
877 struct freebsd11_kevent32 *eventlist = uap->eventlist;
881 if (uap->timeout) {
882 error = copyin(uap->timeout, &ts32, sizeof(ts32));
893 uap->changelist, uap->nchanges,
896 error = kern_kevent(td, uap->fd, uap->nchanges, uap->nevents,
901 eventlist, td->td_retval[0],
917 if (uap->tp) {
921 error = copyout(&atv32, uap->tp, sizeof (atv32));
923 if (error == 0 && uap->tzp != NULL) {
926 error = copyout(&rtz, uap->tzp, sizeof (rtz));
938 error = kern_getrusage(td, uap->who, &s);
941 error = copyout(&s32, uap->rusage, sizeof(s32));
952 pl32->pl_lwpid = pl->pl_lwpid;
953 pl32->pl_event = pl->pl_event;
954 pl32->pl_flags = pl->pl_flags;
955 pl32->pl_sigmask = pl->pl_sigmask;
956 pl32->pl_siglist = pl->pl_siglist;
957 siginfo_to_siginfo32(&pl->pl_siginfo, &pl32->pl_siginfo);
958 strcpy(pl32->pl_tdname, pl->pl_tdname);
959 pl32->pl_child_pid = pl->pl_child_pid;
960 pl32->pl_syscall_code = pl->pl_syscall_code;
961 pl32->pl_syscall_narg = pl->pl_syscall_narg;
970 psr32->sr_retval[0] = psr->sr_retval[0];
971 psr32->sr_retval[1] = psr->sr_retval[1];
972 psr32->sr_error = psr->sr_error;
988 register_t args[nitems(td->td_sa.args)];
998 uint32_t args[nitems(td->td_sa.args)];
1002 syscallarg_t pscr_args[nitems(td->td_sa.args)];
1003 u_int pscr_args32[nitems(td->td_sa.args)];
1011 AUDIT_ARG_PID(uap->pid);
1012 AUDIT_ARG_CMD(uap->req);
1013 AUDIT_ARG_VALUE(uap->data);
1015 data = uap->data;
1016 switch (uap->req) {
1022 if (uap->data > sizeof(r32.pl))
1030 if (uap->data < offsetof(struct ptrace_lwpinfo32, pl_siginfo) +
1044 error = copyin(uap->addr, &r.reg, sizeof(r.reg));
1047 error = copyin(uap->addr, &r.fpreg, sizeof(r.fpreg));
1050 error = copyin(uap->addr, &r.dbreg, sizeof(r.dbreg));
1054 error = copyin(uap->addr, &r32.vec, sizeof(r32.vec));
1062 if (uap->data != sizeof(r.ptevents))
1065 error = copyin(uap->addr, &r.ptevents, uap->data);
1068 error = copyin(uap->addr, &r32.piod, sizeof(r32.piod));
1077 error = copyin(uap->addr, &r32.pve, sizeof(r32.pve));
1093 if (uap->data != sizeof(r32.pc))
1096 error = copyin(uap->addr, &r32.pc, uap->data);
1103 if (uap->data != sizeof(r32.sr)) {
1107 error = copyin(uap->addr, &r32.sr, uap->data);
1112 if (r.sr.pscr_nargs > nitems(td->td_sa.args)) {
1125 addr = uap->addr;
1131 error = kern_ptrace(td, uap->req, uap->pid, addr, data);
1135 switch (uap->req) {
1146 error = copyout(&r32.pve, uap->addr, sizeof(r32.pve));
1150 error = copyout(&r32.piod, uap->addr, sizeof(r32.piod));
1153 error = copyout(&r.reg, uap->addr, sizeof(r.reg));
1156 error = copyout(&r.fpreg, uap->addr, sizeof(r.fpreg));
1159 error = copyout(&r.dbreg, uap->addr, sizeof(r.dbreg));
1163 error = copyout(&r32.vec, uap->addr, sizeof(r32.vec));
1166 /* NB: The size in uap->data is validated in kern_ptrace(). */
1167 error = copyout(&r.ptevents, uap->addr, uap->data);
1171 error = copyout(&r32.pl, uap->addr, uap->data);
1176 error = copyout(r32.args, uap->addr, MIN(uap->data,
1181 error = copyout(&r32.psr, uap->addr, MIN(uap->data,
1186 error = copyout(&r32.sr.pscr_ret, uap->addr +
1207 iov = uio->uio_iov;
1217 uio->uio_iovcnt = iovcnt;
1218 uio->uio_segflg = UIO_USERSPACE;
1219 uio->uio_offset = -1;
1220 uio->uio_resid = 0;
1222 if (iov->iov_len > INT_MAX - uio->uio_resid) {
1226 uio->uio_resid += iov->iov_len;
1239 error = freebsd32_copyinuio(uap->iovp, uap->iovcnt, &auio);
1242 error = kern_readv(td, uap->fd, auio);
1253 error = freebsd32_copyinuio(uap->iovp, uap->iovcnt, &auio);
1256 error = kern_writev(td, uap->fd, auio);
1267 error = freebsd32_copyinuio(uap->iovp, uap->iovcnt, &auio);
1270 error = kern_preadv(td, uap->fd, auio, PAIR32TO64(off_t,uap->offset));
1281 error = freebsd32_copyinuio(uap->iovp, uap->iovcnt, &auio);
1284 error = kern_pwritev(td, uap->fd, auio, PAIR32TO64(off_t,uap->offset));
1325 msg->msg_name = PTRIN(m32.msg_name);
1326 msg->msg_namelen = m32.msg_namelen;
1327 msg->msg_iov = PTRIN(m32.msg_iov);
1328 msg->msg_iovlen = m32.msg_iovlen;
1329 msg->msg_control = PTRIN(m32.msg_control);
1330 msg->msg_controllen = m32.msg_controllen;
1331 msg->msg_flags = m32.msg_flags;
1341 m32.msg_name = PTROUT(msg->msg_name);
1342 m32.msg_namelen = msg->msg_namelen;
1343 m32.msg_iov = PTROUT(msg->msg_iov);
1344 m32.msg_iovlen = msg->msg_iovlen;
1345 m32.msg_control = PTROUT(msg->msg_control);
1346 m32.msg_controllen = msg->msg_controllen;
1347 m32.msg_flags = msg->msg_flags;
1352 #define FREEBSD32_ALIGNBYTES (sizeof(int) - 1)
1379 switch (cm->cmsg_level) {
1381 switch (cm->cmsg_type) {
1427 len = msg->msg_controllen;
1428 msg->msg_controllen = 0;
1430 ctlbuf = msg->msg_control;
1431 for (m = control; m != NULL && len > 0; m = m->m_next) {
1433 clen = m->m_len;
1436 cm->cmsg_len > clen) {
1442 datalen = (caddr_t)cm + cm->cmsg_len - (caddr_t)data;
1452 msg->msg_flags |= MSG_CTRUNC;
1456 oldclen = cm->cmsg_len;
1457 cm->cmsg_len = FREEBSD32_ALIGN(sizeof(struct cmsghdr)) +
1460 cm->cmsg_len = oldclen;
1465 len -= FREEBSD32_ALIGN(copylen);
1469 msg->msg_flags |= MSG_CTRUNC;
1480 len -= FREEBSD32_ALIGN(copylen);
1483 clen -= CMSG_SPACE(datalen);
1491 msg->msg_controllen +=
1496 msg->msg_flags |= MSG_CTRUNC;
1513 error = freebsd32_copyinmsghdr(uap->msg, &msg);
1520 msg.msg_flags = uap->flags;
1525 error = kern_recvit(td, uap->s, &msg, UIO_USERSPACE, controlp);
1535 error = freebsd32_copyoutmsghdr(&msg, uap->msg);
1557 * Copy-in the array of control messages constructed using alignment
1558 * and padding suitable for a 32-bit environment and construct an
1559 * mbuf using alignment and padding suitable for a 64-bit kernel.
1583 * required for 64 bit-aligned copies of the control messages.
1593 if (cm->cmsg_len < FREEBSD32_ALIGN(sizeof(*cm)) ||
1594 cm->cmsg_len > buflen) {
1598 msglen = FREEBSD32_ALIGN(cm->cmsg_len);
1599 if (msglen < cm->cmsg_len) {
1606 buflen -= msglen;
1610 CMSG_ALIGN(msglen - FREEBSD32_ALIGN(sizeof(*cm)));
1616 * Allocate up to MJUMPAGESIZE space for the re-aligned and
1617 * re-padded control messages. This allows a full MCLBYTES of
1618 * 32-bit sized and aligned messages to fit and avoids an ABI
1626 m->m_len = outlen;
1638 msglen = cm->cmsg_len - FREEBSD32_ALIGN(sizeof(*cm));
1639 cm->cmsg_len = CMSG_ALIGN(sizeof(*cm)) + msglen;
1649 outlen -= CMSG_ALIGN(sizeof(*cm)) + CMSG_ALIGN(msglen);
1667 error = freebsd32_copyinmsghdr(uap->msg, &msg);
1699 error = kern_sendit(td, uap->s, &msg, uap->flags, control,
1727 if (uap->tv) {
1728 error = copyin(uap->tv, &tv32, sizeof(tv32));
1736 if (uap->tzp) {
1737 error = copyin(uap->tzp, &tz, sizeof(tz));
1753 if (uap->tptr != NULL) {
1754 error = copyin(uap->tptr, s32, sizeof(s32));
1764 return (kern_utimesat(td, AT_FDCWD, uap->path, UIO_USERSPACE,
1775 if (uap->tptr != NULL) {
1776 error = copyin(uap->tptr, s32, sizeof(s32));
1786 return (kern_lutimes(td, uap->path, UIO_USERSPACE, sp, UIO_SYSSPACE));
1796 if (uap->tptr != NULL) {
1797 error = copyin(uap->tptr, s32, sizeof(s32));
1807 return (kern_futimes(td, uap->fd, sp, UIO_SYSSPACE));
1817 if (uap->times != NULL) {
1818 error = copyin(uap->times, s32, sizeof(s32));
1828 return (kern_utimesat(td, uap->fd, uap->path, UIO_USERSPACE,
1839 if (uap->times != NULL) {
1840 error = copyin(uap->times, ts32, sizeof(ts32));
1850 return (kern_futimens(td, uap->fd, tsp, UIO_SYSSPACE));
1860 if (uap->times != NULL) {
1861 error = copyin(uap->times, ts32, sizeof(ts32));
1871 return (kern_utimensat(td, uap->fd, uap->path, UIO_USERSPACE,
1872 tsp, UIO_SYSSPACE, uap->flag));
1882 if (uap->delta) {
1883 error = copyin(uap->delta, &tv32, sizeof(tv32));
1892 if (uap->olddelta && error == 0) {
1895 error = copyout(&tv32, uap->olddelta, sizeof(tv32));
1909 error = kern_statfs(td, uap->path, UIO_USERSPACE, sp);
1912 error = copyout(&s32, uap->buf, sizeof(s32));
1928 error = kern_fstatfs(td, uap->fd, sp);
1931 error = copyout(&s32, uap->buf, sizeof(s32));
1947 if ((error = copyin(uap->u_fhp, &fh, sizeof(fhandle_t))) != 0)
1953 error = copyout(&s32, uap->buf, sizeof(s32));
1964 return (kern_pread(td, uap->fd, uap->buf, uap->nbyte,
1965 PAIR32TO64(off_t, uap->offset)));
1972 return (kern_pwrite(td, uap->fd, uap->buf, uap->nbyte,
1973 PAIR32TO64(off_t, uap->offset)));
1981 return (kern_lseek(td, uap->fd, uap->offset, uap->whence));
1991 error = kern_lseek(td, uap->fd, PAIR32TO64(off_t, uap->offset),
1992 uap->whence);
1994 pos = td->td_uretoff.tdu_off;
1995 td->td_retval[RETVAL_LO] = pos & 0xffffffff; /* %eax */
1996 td->td_retval[RETVAL_HI] = pos >> 32; /* %edx */
2004 return (kern_truncate(td, uap->path, UIO_USERSPACE,
2005 PAIR32TO64(off_t, uap->length)));
2012 return (kern_truncate(td, uap->path, UIO_USERSPACE, uap->length));
2020 return (kern_ftruncate(td, uap->fd, PAIR32TO64(off_t, uap->length)));
2027 return (kern_ftruncate(td, uap->fd, uap->length));
2039 ap.fd = uap->fd;
2040 ap.buf = uap->buf;
2041 ap.count = uap->count;
2046 error = copyout(&loff_cut, uap->basep, sizeof(int32_t));
2061 error = freebsd11_kern_getdirentries(td, uap->fd, uap->buf, uap->count,
2065 if (uap->basep != NULL) {
2067 error = copyout(&base32, uap->basep, sizeof(int32_t));
2079 return (kern_pread(td, uap->fd, uap->buf, uap->nbyte,
2080 PAIR32TO64(off_t, uap->offset)));
2087 return (kern_pwrite(td, uap->fd, uap->buf, uap->nbyte,
2088 PAIR32TO64(off_t, uap->offset)));
2097 error = kern_lseek(td, uap->fd, PAIR32TO64(off_t, uap->offset),
2098 uap->whence);
2100 pos = *(off_t *)(td->td_retval);
2101 td->td_retval[RETVAL_LO] = pos & 0xffffffff; /* %eax */
2102 td->td_retval[RETVAL_HI] = pos >> 32; /* %edx */
2110 return (kern_truncate(td, uap->path, UIO_USERSPACE,
2111 PAIR32TO64(off_t, uap->length)));
2118 return (kern_ftruncate(td, uap->fd, PAIR32TO64(off_t, uap->length)));
2142 offset = PAIR32TO64(off_t, uap->offset);
2148 if (uap->hdtr != NULL) {
2149 error = copyin(uap->hdtr, &hdtr32, sizeof(hdtr32));
2170 if (uap->nbytes > hdr_uio->uio_resid)
2171 uap->nbytes -= hdr_uio->uio_resid;
2173 uap->nbytes = 0;
2186 AUDIT_ARG_FD(uap->fd);
2188 if ((error = fget_read(td, uap->fd,
2192 error = fo_sendfile(fp, uap->s, hdr_uio, trl_uio, offset,
2193 uap->nbytes, &sbytes, uap->flags, td);
2196 if (uap->sbytes != NULL)
2197 (void)copyout(&sbytes, uap->sbytes, sizeof(off_t));
2230 * 32-bit architectures other than i386 have 64-bit time_t. This
2234 bzero(&out->st_atim, sizeof(out->st_atim));
2235 bzero(&out->st_mtim, sizeof(out->st_mtim));
2236 bzero(&out->st_ctim, sizeof(out->st_ctim));
2237 bzero(&out->st_birthtim, sizeof(out->st_birthtim));
2256 out->st_padding0 = 0;
2257 out->st_padding1 = 0;
2259 out->st_atim_ext = 0;
2260 out->st_mtim_ext = 0;
2261 out->st_ctim_ext = 0;
2262 out->st_btim_ext = 0;
2264 bzero(out->st_spare, sizeof(out->st_spare));
2280 out->st_size = MIN(in->st_size, INT32_MAX);
2299 error = kern_statat(td, 0, AT_FDCWD, uap->path, UIO_USERSPACE, &sb);
2303 error = copyout(&sb32, uap->ub, sizeof (sb32));
2315 error = kern_fstat(td, uap->fd, &ub);
2319 error = copyout(&ub32, uap->sb, sizeof(ub32));
2331 error = kern_fstat(td, uap->fd, &ub);
2335 error = copyout(&ub32, uap->sb, sizeof(ub32));
2347 error = kern_statat(td, uap->flag, uap->fd, uap->path, UIO_USERSPACE,
2352 error = copyout(&ub32, uap->buf, sizeof(ub32));
2364 error = kern_statat(td, AT_SYMLINK_NOFOLLOW, AT_FDCWD, uap->path,
2369 error = copyout(&sb32, uap->ub, sizeof (sb32));
2382 error = copyin(uap->u_fhp, &fh, sizeof(fhandle_t));
2389 error = copyout(&sb32, uap->sb, sizeof (sb32));
2402 * 32-bit architectures other than i386 have 64-bit time_t. This
2406 bzero(&out->st_atim, sizeof(out->st_atim));
2407 bzero(&out->st_mtim, sizeof(out->st_mtim));
2408 bzero(&out->st_ctim, sizeof(out->st_ctim));
2409 bzero(&out->st_birthtim, sizeof(out->st_birthtim));
2413 if (in->st_ino != out->st_ino) {
2421 out->st_ino = UINT32_MAX;
2426 if (in->st_nlink != out->st_nlink) {
2434 out->st_nlink = UINT16_MAX;
2438 out->st_dev = in->st_dev;
2439 if (out->st_dev != in->st_dev) {
2450 out->st_rdev = in->st_rdev;
2451 if (out->st_rdev != in->st_rdev) {
2468 out->st_lspare = 0;
2469 bzero((char *)&out->st_birthtim + sizeof(out->st_birthtim),
2470 sizeof(*out) - offsetof(struct freebsd11_stat32,
2471 st_birthtim) - sizeof(out->st_birthtim));
2483 error = kern_statat(td, 0, AT_FDCWD, uap->path, UIO_USERSPACE, &sb);
2488 error = copyout(&sb32, uap->ub, sizeof (sb32));
2500 error = kern_fstat(td, uap->fd, &sb);
2505 error = copyout(&sb32, uap->sb, sizeof (sb32));
2517 error = kern_statat(td, uap->flag, uap->fd, uap->path, UIO_USERSPACE,
2523 error = copyout(&sb32, uap->buf, sizeof (sb32));
2535 error = kern_statat(td, AT_SYMLINK_NOFOLLOW, AT_FDCWD, uap->path,
2541 error = copyout(&sb32, uap->ub, sizeof (sb32));
2554 error = copyin(uap->u_fhp, &fh, sizeof(fhandle_t));
2562 error = copyout(&sb32, uap->sb, sizeof (sb32));
2608 error = kern_statat(td, 0, AT_FDCWD, uap->path, UIO_USERSPACE, &sb);
2613 error = copyout(&nsb, uap->ub, sizeof (nsb));
2625 error = kern_statat(td, AT_SYMLINK_NOFOLLOW, AT_FDCWD, uap->path,
2631 error = copyout(&nsb, uap->ub, sizeof (nsb));
2643 error = kern_fstat(td, uap->fd, &ub);
2648 error = copyout(&nub, uap->sb, sizeof(nub));
2660 if (uap->namelen > CTL_MAXNAME || uap->namelen < 2)
2662 error = copyin(uap->name, name, uap->namelen * sizeof(int));
2665 if (uap->oldlenp) {
2666 error = fueword32(uap->oldlenp, &tmp);
2673 error = userland_sysctl(td, name, uap->namelen,
2674 uap->old, &oldlen, 1,
2675 uap->new, uap->newlen, &j, SCTL_MASK32);
2678 if (uap->oldlenp != NULL && suword32(uap->oldlenp, j) != 0)
2691 if (uap->oldlenp != NULL) {
2692 error = fueword32(uap->oldlenp, &tmp);
2699 error = kern___sysctlbyname(td, uap->name, uap->namelen, uap->old,
2700 &oldlen, uap->new, uap->newlen, &rv, SCTL_MASK32, 1);
2703 if (uap->oldlenp != NULL && suword32(uap->oldlenp, rv) != 0)
2715 error = copyin(uap->jail, &version, sizeof(uint32_t));
2726 error = copyin(uap->jail, &j32_v0, sizeof(struct jail32_v0));
2738 * Version 1 was used by multi-IPv4 jail implementations
2745 /* FreeBSD multi-IPv4/IPv6,noIP jails. */
2748 error = copyin(uap->jail, &j32, sizeof(struct jail32));
2763 /* Sci-Fi jails are not supported, sorry. */
2776 if (uap->iovcnt & 1)
2779 error = freebsd32_copyinuio(uap->iovp, uap->iovcnt, &auio);
2782 error = kern_jail_set(td, auio, uap->flags);
2795 if (uap->iovcnt & 1)
2798 error = freebsd32_copyinuio(uap->iovp, uap->iovcnt, &auio);
2801 error = kern_jail_get(td, auio, uap->flags);
2803 for (i = 0; i < uap->iovcnt; i++) {
2804 PTROUT_CP(auio->uio_iov[i], iov32, iov_base);
2805 CP(auio->uio_iov[i], iov32, iov_len);
2806 error = copyout(&iov32, uap->iovp + i, sizeof(iov32));
2821 if (uap->act) {
2822 error = copyin(uap->act, &s32, sizeof(s32));
2831 error = kern_sigaction(td, uap->sig, sap, &osa, 0);
2832 if (error == 0 && uap->oact != NULL) {
2836 error = copyout(&s32, uap->oact, sizeof(s32));
2850 if (uap->act) {
2851 error = copyin(uap->act, &s32, sizeof(s32));
2860 error = kern_sigaction(td, uap->sig, sap, &osa, KSA_FREEBSD4);
2861 if (error == 0 && uap->oact != NULL) {
2865 error = copyout(&s32, uap->oact, sizeof(s32));
2888 if (uap->signum <= 0 || uap->signum >= ONSIG)
2891 if (uap->nsa) {
2892 error = copyin(uap->nsa, &s32, sizeof(s32));
2901 error = kern_sigaction(td, uap->signum, sap, &osa, KSA_OSIGSET);
2902 if (error == 0 && uap->osa != NULL) {
2906 error = copyout(&s32, uap->osa, sizeof(s32));
2925 if (uap->signum <= 0 || uap->signum >= ONSIG)
2928 if (uap->nsv) {
2929 error = copyin(uap->nsv, &vec, sizeof(vec));
2939 error = kern_sigaction(td, uap->signum, sap, &osa, KSA_OSIGSET);
2940 if (error == 0 && uap->osv != NULL) {
2946 error = copyout(&vec, uap->osv, sizeof(vec));
2964 if (uap->nss != NULL) {
2965 error = copyin(uap->nss, &s32, sizeof(s32));
2974 oss.ss_sp = td->td_sigstk.ss_sp;
2977 td->td_sigstk.ss_sp = nss.ss_sp;
2978 td->td_sigstk.ss_size = 0;
2979 td->td_sigstk.ss_flags |= (nss.ss_onstack & SS_ONSTACK);
2980 td->td_pflags |= TDP_ALTSTACK;
2982 if (uap->oss != NULL) {
2985 error = copyout(&s32, uap->oss, sizeof(s32));
2996 TIMER_RELTIME, uap->rqtp, uap->rmtp));
3005 error = freebsd32_user_clock_nanosleep(td, uap->clock_id, uap->flags,
3006 uap->rqtp, uap->rmtp);
3041 struct timespec ats;
3045 error = kern_clock_gettime(td, uap->clock_id, &ats);
3047 CP(ats, ats32, tv_sec);
3048 CP(ats, ats32, tv_nsec);
3049 error = copyout(&ats32, uap->tp, sizeof(ats32));
3058 struct timespec ats;
3062 error = copyin(uap->tp, &ats32, sizeof(ats32));
3065 CP(ats32, ats, tv_sec);
3066 CP(ats32, ats, tv_nsec);
3068 return (kern_clock_settime(td, uap->clock_id, &ats));
3079 if (uap->tp == NULL)
3081 error = kern_clock_getres(td, uap->clock_id, &ts);
3085 error = copyout(&ts32, uap->tp, sizeof(ts32));
3097 if (uap->evp == NULL) {
3101 error = copyin(uap->evp, &ev32, sizeof(ev32));
3108 error = kern_ktimer_create(td, uap->clock_id, evp, &id, -1);
3110 error = copyout(&id, uap->timerid, sizeof(int));
3125 error = copyin(uap->value, &val32, sizeof(val32));
3129 ovalp = uap->ovalue != NULL ? &oval : NULL;
3130 error = kern_ktimer_settime(td, uap->timerid, uap->flags, &val, ovalp);
3131 if (error == 0 && uap->ovalue != NULL) {
3133 error = copyout(&oval32, uap->ovalue, sizeof(oval32));
3146 error = kern_ktimer_gettime(td, uap->timerid, &val);
3149 error = copyout(&val32, uap->value, sizeof(val32));
3162 error = kern_timerfd_gettime(td, uap->fd, &curr_value);
3168 error = copyout(&curr_value32, uap->curr_value,
3183 error = copyin(uap->new_value, &new_value32, sizeof(new_value32));
3190 if (uap->old_value == NULL) {
3191 error = kern_timerfd_settime(td, uap->fd, uap->flags,
3194 error = kern_timerfd_settime(td, uap->fd, uap->flags,
3201 error = copyout(&old_value32, uap->old_value,
3215 error = kern_clock_getcpuclockid2(td, PAIR32TO64(id_t, uap->id),
3216 uap->which, &clk_id);
3218 error = copyout(&clk_id, uap->clock_id, sizeof(clockid_t));
3230 if (uap->param_size < 0 ||
3231 uap->param_size > sizeof(struct thr_param32))
3235 error = copyin(uap->param, ¶m32, uap->param_size);
3264 if (uap->timeout != NULL) {
3265 error = copyin((const void *)uap->timeout, (void *)&ts32,
3280 dst->si_signo = src->si_signo;
3281 dst->si_errno = src->si_errno;
3282 dst->si_code = src->si_code;
3283 dst->si_pid = src->si_pid;
3284 dst->si_uid = src->si_uid;
3285 dst->si_status = src->si_status;
3286 dst->si_addr = (uintptr_t)src->si_addr;
3287 dst->si_value.sival_int = src->si_value.sival_int;
3288 dst->si_timerid = src->si_timerid;
3289 dst->si_overrun = src->si_overrun;
3305 * On 32-bit ABIs, sival_int and sival_ptr are the same.
3306 * On 64-bit little-endian ABIs, the low bits are the same.
3307 * In 64-bit big-endian ABIs, sival_int overlaps with
3313 sv.sival_int = (uint32_t)(uint64_t)uap->value;
3315 return (kern_sigqueue(td, uap->pid, uap->signum, &sv));
3329 if (uap->timeout) {
3330 error = copyin(uap->timeout, &ts32, sizeof(ts32));
3339 error = copyin(uap->set, &set, sizeof(set));
3347 if (uap->info) {
3349 error = copyout(&si32, uap->info, sizeof(struct __siginfo32));
3353 td->td_retval[0] = ksi.ksi_signo;
3368 error = copyin(uap->set, &set, sizeof(set));
3376 if (uap->info) {
3378 error = copyout(&si32, uap->info, sizeof(struct __siginfo32));
3381 td->td_retval[0] = ksi.ksi_signo;
3390 return (kern_cpuset_setid(td, uap->which,
3391 PAIR32TO64(id_t, uap->id), uap->setid));
3399 return (kern_cpuset_getid(td, uap->level, uap->which,
3400 PAIR32TO64(id_t, uap->id), uap->setid));
3415 p = (int *)kb->__bits;
3436 const int *kp = (const int *)kb->__bits;
3437 int *up = (int *)ub->__bits;
3466 return (user_cpuset_getaffinity(td, uap->level, uap->which,
3467 PAIR32TO64(id_t,uap->id), uap->cpusetsize, uap->mask,
3476 return (user_cpuset_setaffinity(td, uap->level, uap->which,
3477 PAIR32TO64(id_t,uap->id), uap->cpusetsize, uap->mask,
3486 return (kern_cpuset_getdomain(td, uap->level, uap->which,
3487 PAIR32TO64(id_t,uap->id), uap->domainsetsize, uap->mask, uap->policy,
3496 return (kern_cpuset_setdomain(td, uap->level, uap->which,
3497 PAIR32TO64(id_t,uap->id), uap->domainsetsize, uap->mask, uap->policy,
3514 * Mount flags are now 64-bits. On 32-bit archtectures only
3515 * 32-bits are passed in, but from here on everything handles
3516 * 64-bit flags correctly.
3518 flags = uap->flags;
3535 if ((uap->iovcnt & 1) || (uap->iovcnt < 4))
3538 error = freebsd32_copyinuio(uap->iovp, uap->iovcnt, &auio);
3556 if (uap->zzz) {
3557 error = copyin(uap->zzz, &s32, sizeof(s32));
3566 if (uap->zzz) {
3609 sysent = imgp->sysent;
3611 arginfo = (struct freebsd32_ps_strings *)PROC_PS_STRINGS(imgp->proc);
3612 imgp->ps_strings = arginfo;
3618 if (!PROC_HAS_SHP(imgp->proc)) {
3619 szsigcode = *sysent->sv_szsigcode;
3620 destp -= szsigcode;
3622 error = copyout(sysent->sv_sigcode, (void *)destp,
3631 if (imgp->execpath != NULL && imgp->auxargs != NULL) {
3632 execpath_len = strlen(imgp->execpath) + 1;
3633 destp -= execpath_len;
3634 imgp->execpathp = (void *)destp;
3635 error = copyout(imgp->execpath, imgp->execpathp, execpath_len);
3644 destp -= sizeof(canary);
3645 imgp->canary = (void *)destp;
3646 error = copyout(canary, imgp->canary, sizeof(canary));
3649 imgp->canarylen = sizeof(canary);
3656 destp -= sizeof(pagesizes32);
3658 imgp->pagesizes = (void *)destp;
3659 error = copyout(pagesizes32, imgp->pagesizes, sizeof(pagesizes32));
3662 imgp->pagesizeslen = sizeof(pagesizes32);
3667 destp -= ARG_MAX - imgp->args->stringspace;
3671 if (imgp->auxargs) {
3676 destp -= AT_COUNT * sizeof(Elf32_Auxinfo);
3686 vectp -= imgp->args->argc + 1 + imgp->args->envc + 1;
3693 stringp = imgp->args->begin_argv;
3694 argc = imgp->args->argc;
3695 envc = imgp->args->envc;
3697 * Copy out strings - arguments and environment.
3700 ARG_MAX - imgp->args->stringspace);
3707 imgp->argv = vectp;
3708 if (suword32(&arginfo->ps_argvstr, (uint32_t)(intptr_t)vectp) != 0 ||
3709 suword32(&arginfo->ps_nargvstr, argc) != 0)
3715 for (; argc > 0; --argc) {
3727 imgp->envv = vectp;
3728 if (suword32(&arginfo->ps_envstr, (uint32_t)(intptr_t)vectp) != 0 ||
3729 suword32(&arginfo->ps_nenvstr, envc) != 0)
3735 for (; envc > 0; --envc) {
3747 if (imgp->auxargs) {
3749 error = imgp->sysent->sv_copyout_auxargs(imgp,
3765 if ((error = copyin(&uap->stat->version, &version, sizeof(version)))
3774 error = kern_kldstat(td, uap->fileid, stat);
3776 bcopy(&stat->name[0], &stat32->name[0], sizeof(stat->name));
3781 bcopy(&stat->pathname[0], &stat32->pathname[0],
3782 sizeof(stat->pathname));
3783 stat32->version = version;
3784 error = copyout(stat32, uap->stat, version);
3797 error = kern_posix_fallocate(td, uap->fd,
3798 PAIR32TO64(off_t, uap->offset), PAIR32TO64(off_t, uap->len));
3808 error = kern_posix_fadvise(td, uap->fd, PAIR32TO64(off_t, uap->offset),
3809 PAIR32TO64(off_t, uap->len), uap->advice);
3818 switch (sig->sigev_notify) {
3853 if (uap->com >= PROC_PROCCTL_MD_MIN)
3854 return (cpu_procctl(td, uap->idtype, PAIR32TO64(id_t, uap->id),
3855 uap->com, PTRIN(uap->data)));
3857 switch (uap->com) {
3867 error = copyin(PTRIN(uap->data), &flags, sizeof(flags));
3874 if (uap->data != NULL)
3882 error = copyin(uap->data, &x32.rp, sizeof(x32.rp));
3890 error = copyin(uap->data, &x.rk, sizeof(x.rk));
3906 error = copyin(uap->data, &signum, sizeof(signum));
3917 error = kern_procctl(td, uap->idtype, PAIR32TO64(id_t, uap->id),
3918 uap->com, data);
3919 switch (uap->com) {
3922 error = copyout(&x.rs, uap->data, sizeof(x.rs));
3925 error1 = copyout(&x.rk, uap->data, sizeof(x.rk));
3938 error = copyout(&flags, uap->data, sizeof(flags));
3942 error = copyout(&signum, uap->data, sizeof(signum));
3953 switch (uap->cmd) {
3968 tmp = (unsigned int)(uap->arg);
3971 tmp = uap->arg;
3974 return (kern_fcntl_freebsd(td, uap->fd, uap->cmd, tmp));
3985 if (uap->ts != NULL) {
3986 error = copyin(uap->ts, &ts32, sizeof(ts32));
3994 if (uap->set != NULL) {
3995 error = copyin(uap->set, &set, sizeof(set));
4002 return (kern_poll(td, uap->fds, uap->nfds, tsp, ssp));
4013 error = kern_sched_rr_get_interval(td, uap->pid, &ts);
4017 error = copyout(&ts32, uap->interval, sizeof(ts32));
4073 error = copyin(uap->tp, &tx32, sizeof(tx32));
4079 error = copyout(&tx32, uap->tp, sizeof(tx32));
4081 td->td_retval[0] = retval;
4104 if ((error = copyin(uap->cest, &cest32,
4149 error = copyout(&cest32, uap->cest, sizeof(struct ffclock_estimate32));
4175 hostid = uap->hostid;
4185 return (user_setcred(td, uap->flags, uap->wcred, uap->size, true));