freebsd32_misc.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    1 /*-
    2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
    3  *
    4  * Copyright (c) 2002 Doug Rabson
    5  * All rights reserved.
    6  *
    7  * Redistribution and use in source and binary forms, with or without
    8  * modification, are permitted provided that the following conditions
    9  * are met:
   10  * 1. Redistributions of source code must retain the above copyright
   11  *    notice, this list of conditions and the following disclaimer.
   12  * 2. Redistributions in binary form must reproduce the above copyright
   13  *    notice, this list of conditions and the following disclaimer in the
   14  *    documentation and/or other materials provided with the distribution.
   15  *
   16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
   17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
   20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   26  * SUCH DAMAGE.
   27  */
   28 
   29 #include <sys/cdefs.h>
   30 __FBSDID("$FreeBSD$");
   31 
   32 #include "opt_inet.h"
   33 #include "opt_inet6.h"
   34 #include "opt_ktrace.h"
   35 
   36 #define __ELF_WORD_SIZE 32
   37 
   38 #ifdef COMPAT_FREEBSD11
   39 #define _WANT_FREEBSD11_KEVENT
   40 #endif
   41 
   42 #include <sys/param.h>
   43 #include <sys/bus.h>
   44 #include <sys/capsicum.h>
   45 #include <sys/clock.h>
   46 #include <sys/exec.h>
   47 #include <sys/fcntl.h>
   48 #include <sys/filedesc.h>
   49 #include <sys/imgact.h>
   50 #include <sys/jail.h>
   51 #include <sys/kernel.h>
   52 #include <sys/limits.h>
   53 #include <sys/linker.h>
   54 #include <sys/lock.h>
   55 #include <sys/malloc.h>
   56 #include <sys/file.h>           /* Must come after sys/malloc.h */
   57 #include <sys/imgact.h>
   58 #include <sys/mbuf.h>
   59 #include <sys/mman.h>
   60 #include <sys/module.h>
   61 #include <sys/mount.h>
   62 #include <sys/mutex.h>
   63 #include <sys/namei.h>
   64 #include <sys/proc.h>
   65 #include <sys/procctl.h>
   66 #include <sys/ptrace.h>
   67 #include <sys/reboot.h>
   68 #include <sys/resource.h>
   69 #include <sys/resourcevar.h>
   70 #include <sys/selinfo.h>
   71 #include <sys/eventvar.h>       /* Must come after sys/selinfo.h */
   72 #include <sys/pipe.h>           /* Must come after sys/selinfo.h */
   73 #include <sys/signal.h>
   74 #include <sys/signalvar.h>
   75 #include <sys/socket.h>
   76 #include <sys/socketvar.h>
   77 #include <sys/stat.h>
   78 #include <sys/syscall.h>
   79 #include <sys/syscallsubr.h>
   80 #include <sys/sysctl.h>
   81 #include <sys/sysent.h>
   82 #include <sys/sysproto.h>
   83 #include <sys/systm.h>
   84 #include <sys/thr.h>
   85 #include <sys/timex.h>
   86 #include <sys/unistd.h>
   87 #include <sys/ucontext.h>
   88 #include <sys/umtx.h>
   89 #include <sys/vnode.h>
   90 #include <sys/wait.h>
   91 #include <sys/ipc.h>
   92 #include <sys/msg.h>
   93 #include <sys/sem.h>
   94 #include <sys/shm.h>
   95 #ifdef KTRACE
   96 #include <sys/ktrace.h>
   97 #endif
   98 
   99 #ifdef INET
  100 #include <netinet/in.h>
  101 #endif
  102 
  103 #include <vm/vm.h>
  104 #include <vm/vm_param.h>
  105 #include <vm/pmap.h>
  106 #include <vm/vm_map.h>
  107 #include <vm/vm_object.h>
  108 #include <vm/vm_extern.h>
  109 
  110 #include <machine/cpu.h>
  111 #include <machine/elf.h>
  112 #ifdef __amd64__
  113 #include <machine/md_var.h>
  114 #endif
  115 
  116 #include <security/audit/audit.h>
  117 
  118 #include <compat/freebsd32/freebsd32_util.h>
  119 #include <compat/freebsd32/freebsd32.h>
  120 #include <compat/freebsd32/freebsd32_ipc.h>
  121 #include <compat/freebsd32/freebsd32_misc.h>
  122 #include <compat/freebsd32/freebsd32_signal.h>
  123 #include <compat/freebsd32/freebsd32_proto.h>
  124 
  125 FEATURE(compat_freebsd_32bit, "Compatible with 32-bit FreeBSD");
  126 
  127 struct ptrace_io_desc32 {
  128         int             piod_op;
  129         uint32_t        piod_offs;
  130         uint32_t        piod_addr;
  131         uint32_t        piod_len;
  132 };
  133 
  134 struct ptrace_sc_ret32 {
  135         uint32_t        sr_retval[2];
  136         int             sr_error;
  137 };
  138 
  139 struct ptrace_vm_entry32 {
  140         int             pve_entry;
  141         int             pve_timestamp;
  142         uint32_t        pve_start;
  143         uint32_t        pve_end;
  144         uint32_t        pve_offset;
  145         u_int           pve_prot;
  146         u_int           pve_pathlen;
  147         int32_t         pve_fileid;
  148         u_int           pve_fsid;
  149         uint32_t        pve_path;
  150 };
  151 
  152 #ifdef __amd64__
  153 CTASSERT(sizeof(struct timeval32) == 8);
  154 CTASSERT(sizeof(struct timespec32) == 8);
  155 CTASSERT(sizeof(struct itimerval32) == 16);
  156 CTASSERT(sizeof(struct bintime32) == 12);
  157 #endif
  158 CTASSERT(sizeof(struct statfs32) == 256);
  159 #ifdef __amd64__
  160 CTASSERT(sizeof(struct rusage32) == 72);
  161 #endif
  162 CTASSERT(sizeof(struct sigaltstack32) == 12);
  163 #ifdef __amd64__
  164 CTASSERT(sizeof(struct kevent32) == 56);
  165 #else
  166 CTASSERT(sizeof(struct kevent32) == 64);
  167 #endif
  168 CTASSERT(sizeof(struct iovec32) == 8);
  169 CTASSERT(sizeof(struct msghdr32) == 28);
  170 #ifdef __amd64__
  171 CTASSERT(sizeof(struct stat32) == 208);
  172 CTASSERT(sizeof(struct freebsd11_stat32) == 96);
  173 #endif
  174 CTASSERT(sizeof(struct sigaction32) == 24);
  175 
  176 static int freebsd32_kevent_copyout(void *arg, struct kevent *kevp, int count);
  177 static int freebsd32_kevent_copyin(void *arg, struct kevent *kevp, int count);
  178 static int freebsd32_user_clock_nanosleep(struct thread *td, clockid_t clock_id,
  179     int flags, const struct timespec32 *ua_rqtp, struct timespec32 *ua_rmtp);
  180 
  181 void
  182 freebsd32_rusage_out(const struct rusage *s, struct rusage32 *s32)
  183 {
  184 
  185         TV_CP(*s, *s32, ru_utime);
  186         TV_CP(*s, *s32, ru_stime);
  187         CP(*s, *s32, ru_maxrss);
  188         CP(*s, *s32, ru_ixrss);
  189         CP(*s, *s32, ru_idrss);
  190         CP(*s, *s32, ru_isrss);
  191         CP(*s, *s32, ru_minflt);
  192         CP(*s, *s32, ru_majflt);
  193         CP(*s, *s32, ru_nswap);
  194         CP(*s, *s32, ru_inblock);
  195         CP(*s, *s32, ru_oublock);
  196         CP(*s, *s32, ru_msgsnd);
  197         CP(*s, *s32, ru_msgrcv);
  198         CP(*s, *s32, ru_nsignals);
  199         CP(*s, *s32, ru_nvcsw);
  200         CP(*s, *s32, ru_nivcsw);
  201 }
  202 
  203 int
  204 freebsd32_wait4(struct thread *td, struct freebsd32_wait4_args *uap)
  205 {
  206         int error, status;
  207         struct rusage32 ru32;
  208         struct rusage ru, *rup;
  209 
  210         if (uap->rusage != NULL)
  211                 rup = &ru;
  212         else
  213                 rup = NULL;
  214         error = kern_wait(td, uap->pid, &status, uap->options, rup);
  215         if (error)
  216                 return (error);
  217         if (uap->status != NULL)
  218                 error = copyout(&status, uap->status, sizeof(status));
  219         if (uap->rusage != NULL && error == 0) {
  220                 freebsd32_rusage_out(&ru, &ru32);
  221                 error = copyout(&ru32, uap->rusage, sizeof(ru32));
  222         }
  223         return (error);
  224 }
  225 
  226 int
  227 freebsd32_wait6(struct thread *td, struct freebsd32_wait6_args *uap)
  228 {
  229         struct wrusage32 wru32;
  230         struct __wrusage wru, *wrup;
  231         struct siginfo32 si32;
  232         struct __siginfo si, *sip;
  233         int error, status;
  234 
  235         if (uap->wrusage != NULL)
  236                 wrup = &wru;
  237         else
  238                 wrup = NULL;
  239         if (uap->info != NULL) {
  240                 sip = &si;
  241                 bzero(sip, sizeof(*sip));
  242         } else
  243                 sip = NULL;
  244         error = kern_wait6(td, uap->idtype, PAIR32TO64(id_t, uap->id),
  245             &status, uap->options, wrup, sip);
  246         if (error != 0)
  247                 return (error);
  248         if (uap->status != NULL)
  249                 error = copyout(&status, uap->status, sizeof(status));
  250         if (uap->wrusage != NULL && error == 0) {
  251                 freebsd32_rusage_out(&wru.wru_self, &wru32.wru_self);
  252                 freebsd32_rusage_out(&wru.wru_children, &wru32.wru_children);
  253                 error = copyout(&wru32, uap->wrusage, sizeof(wru32));
  254         }
  255         if (uap->info != NULL && error == 0) {
  256                 siginfo_to_siginfo32 (&si, &si32);
  257                 error = copyout(&si32, uap->info, sizeof(si32));
  258         }
  259         return (error);
  260 }
  261 
  262 #ifdef COMPAT_FREEBSD4
  263 static void
  264 copy_statfs(struct statfs *in, struct statfs32 *out)
  265 {
  266 
  267         statfs_scale_blocks(in, INT32_MAX);
  268         bzero(out, sizeof(*out));
  269         CP(*in, *out, f_bsize);
  270         out->f_iosize = MIN(in->f_iosize, INT32_MAX);
  271         CP(*in, *out, f_blocks);
  272         CP(*in, *out, f_bfree);
  273         CP(*in, *out, f_bavail);
  274         out->f_files = MIN(in->f_files, INT32_MAX);
  275         out->f_ffree = MIN(in->f_ffree, INT32_MAX);
  276         CP(*in, *out, f_fsid);
  277         CP(*in, *out, f_owner);
  278         CP(*in, *out, f_type);
  279         CP(*in, *out, f_flags);
  280         out->f_syncwrites = MIN(in->f_syncwrites, INT32_MAX);
  281         out->f_asyncwrites = MIN(in->f_asyncwrites, INT32_MAX);
  282         strlcpy(out->f_fstypename,
  283               in->f_fstypename, MFSNAMELEN);
  284         strlcpy(out->f_mntonname,
  285               in->f_mntonname, min(MNAMELEN, FREEBSD4_MNAMELEN));
  286         out->f_syncreads = MIN(in->f_syncreads, INT32_MAX);
  287         out->f_asyncreads = MIN(in->f_asyncreads, INT32_MAX);
  288         strlcpy(out->f_mntfromname,
  289               in->f_mntfromname, min(MNAMELEN, FREEBSD4_MNAMELEN));
  290 }
  291 #endif
  292 
  293 #ifdef COMPAT_FREEBSD4
  294 int
  295 freebsd4_freebsd32_getfsstat(struct thread *td,
  296     struct freebsd4_freebsd32_getfsstat_args *uap)
  297 {
  298         struct statfs *buf, *sp;
  299         struct statfs32 stat32;
  300         size_t count, size, copycount;
  301         int error;
  302 
  303         count = uap->bufsize / sizeof(struct statfs32);
  304         size = count * sizeof(struct statfs);
  305         error = kern_getfsstat(td, &buf, size, &count, UIO_SYSSPACE, uap->mode);
  306         if (size > 0) {
  307                 sp = buf;
  308                 copycount = count;
  309                 while (copycount > 0 && error == 0) {
  310                         copy_statfs(sp, &stat32);
  311                         error = copyout(&stat32, uap->buf, sizeof(stat32));
  312                         sp++;
  313                         uap->buf++;
  314                         copycount--;
  315                 }
  316                 free(buf, M_STATFS);
  317         }
  318         if (error == 0)
  319                 td->td_retval[0] = count;
  320         return (error);
  321 }
  322 #endif
  323 
  324 #ifdef COMPAT_FREEBSD10
  325 int
  326 freebsd10_freebsd32_pipe(struct thread *td,
  327     struct freebsd10_freebsd32_pipe_args *uap) {
  328         return (freebsd10_pipe(td, (struct freebsd10_pipe_args*)uap));
  329 }
  330 #endif
  331 
  332 int
  333 freebsd32_sigaltstack(struct thread *td,
  334                       struct freebsd32_sigaltstack_args *uap)
  335 {
  336         struct sigaltstack32 s32;
  337         struct sigaltstack ss, oss, *ssp;
  338         int error;
  339 
  340         if (uap->ss != NULL) {
  341                 error = copyin(uap->ss, &s32, sizeof(s32));
  342                 if (error)
  343                         return (error);
  344                 PTRIN_CP(s32, ss, ss_sp);
  345                 CP(s32, ss, ss_size);
  346                 CP(s32, ss, ss_flags);
  347                 ssp = &ss;
  348         } else
  349                 ssp = NULL;
  350         error = kern_sigaltstack(td, ssp, &oss);
  351         if (error == 0 && uap->oss != NULL) {
  352                 PTROUT_CP(oss, s32, ss_sp);
  353                 CP(oss, s32, ss_size);
  354                 CP(oss, s32, ss_flags);
  355                 error = copyout(&s32, uap->oss, sizeof(s32));
  356         }
  357         return (error);
  358 }
  359 
  360 /*
  361  * Custom version of exec_copyin_args() so that we can translate
  362  * the pointers.
  363  */
  364 int
  365 freebsd32_exec_copyin_args(struct image_args *args, const char *fname,
  366     enum uio_seg segflg, u_int32_t *argv, u_int32_t *envv)
  367 {
  368         char *argp, *envp;
  369         u_int32_t *p32, arg;
  370         int error;
  371 
  372         bzero(args, sizeof(*args));
  373         if (argv == NULL)
  374                 return (EFAULT);
  375 
  376         /*
  377          * Allocate demand-paged memory for the file name, argument, and
  378          * environment strings.
  379          */
  380         error = exec_alloc_args(args);
  381         if (error != 0)
  382                 return (error);
  383 
  384         /*
  385          * Copy the file name.
  386          */
  387         error = exec_args_add_fname(args, fname, segflg);
  388         if (error != 0)
  389                 goto err_exit;
  390 
  391         /*
  392          * extract arguments first
  393          */
  394         p32 = argv;
  395         for (;;) {
  396                 error = copyin(p32++, &arg, sizeof(arg));
  397                 if (error)
  398                         goto err_exit;
  399                 if (arg == 0)
  400                         break;
  401                 argp = PTRIN(arg);
  402                 error = exec_args_add_arg(args, argp, UIO_USERSPACE);
  403                 if (error != 0)
  404                         goto err_exit;
  405         }
  406                         
  407         /*
  408          * extract environment strings
  409          */
  410         if (envv) {
  411                 p32 = envv;
  412                 for (;;) {
  413                         error = copyin(p32++, &arg, sizeof(arg));
  414                         if (error)
  415                                 goto err_exit;
  416                         if (arg == 0)
  417                                 break;
  418                         envp = PTRIN(arg);
  419                         error = exec_args_add_env(args, envp, UIO_USERSPACE);
  420                         if (error != 0)
  421                                 goto err_exit;
  422                 }
  423         }
  424 
  425         return (0);
  426 
  427 err_exit:
  428         exec_free_args(args);
  429         return (error);
  430 }
  431 
  432 int
  433 freebsd32_execve(struct thread *td, struct freebsd32_execve_args *uap)
  434 {
  435         struct image_args eargs;
  436         struct vmspace *oldvmspace;
  437         int error;
  438 
  439         error = pre_execve(td, &oldvmspace);
  440         if (error != 0)
  441                 return (error);
  442         error = freebsd32_exec_copyin_args(&eargs, uap->fname, UIO_USERSPACE,
  443             uap->argv, uap->envv);
  444         if (error == 0)
  445                 error = kern_execve(td, &eargs, NULL, oldvmspace);
  446         post_execve(td, error, oldvmspace);
  447         AUDIT_SYSCALL_EXIT(error == EJUSTRETURN ? 0 : error, td);
  448         return (error);
  449 }
  450 
  451 int
  452 freebsd32_fexecve(struct thread *td, struct freebsd32_fexecve_args *uap)
  453 {
  454         struct image_args eargs;
  455         struct vmspace *oldvmspace;
  456         int error;
  457 
  458         error = pre_execve(td, &oldvmspace);
  459         if (error != 0)
  460                 return (error);
  461         error = freebsd32_exec_copyin_args(&eargs, NULL, UIO_SYSSPACE,
  462             uap->argv, uap->envv);
  463         if (error == 0) {
  464                 eargs.fd = uap->fd;
  465                 error = kern_execve(td, &eargs, NULL, oldvmspace);
  466         }
  467         post_execve(td, error, oldvmspace);
  468         AUDIT_SYSCALL_EXIT(error == EJUSTRETURN ? 0 : error, td);
  469         return (error);
  470 }
  471 
  472 int
  473 freebsd32_mknodat(struct thread *td, struct freebsd32_mknodat_args *uap)
  474 {
  475 
  476         return (kern_mknodat(td, uap->fd, uap->path, UIO_USERSPACE,
  477             uap->mode, PAIR32TO64(dev_t, uap->dev)));
  478 }
  479 
  480 int
  481 freebsd32_mprotect(struct thread *td, struct freebsd32_mprotect_args *uap)
  482 {
  483         int prot;
  484 
  485         prot = uap->prot;
  486 #if defined(__amd64__)
  487         if (i386_read_exec && (prot & PROT_READ) != 0)
  488                 prot |= PROT_EXEC;
  489 #endif
  490         return (kern_mprotect(td, (uintptr_t)PTRIN(uap->addr), uap->len,
  491             prot));
  492 }
  493 
  494 int
  495 freebsd32_mmap(struct thread *td, struct freebsd32_mmap_args *uap)
  496 {
  497         int prot;
  498 
  499         prot = uap->prot;
  500 #if defined(__amd64__)
  501         if (i386_read_exec && (prot & PROT_READ))
  502                 prot |= PROT_EXEC;
  503 #endif
  504 
  505         return (kern_mmap(td, (uintptr_t)uap->addr, uap->len, prot,
  506             uap->flags, uap->fd, PAIR32TO64(off_t, uap->pos)));
  507 }
  508 
  509 #ifdef COMPAT_FREEBSD6
  510 int
  511 freebsd6_freebsd32_mmap(struct thread *td,
  512     struct freebsd6_freebsd32_mmap_args *uap)
  513 {
  514         int prot;
  515 
  516         prot = uap->prot;
  517 #if defined(__amd64__)
  518         if (i386_read_exec && (prot & PROT_READ))
  519                 prot |= PROT_EXEC;
  520 #endif
  521 
  522         return (kern_mmap(td, (uintptr_t)uap->addr, uap->len, prot,
  523             uap->flags, uap->fd, PAIR32TO64(off_t, uap->pos)));
  524 }
  525 #endif
  526 
  527 int
  528 freebsd32_setitimer(struct thread *td, struct freebsd32_setitimer_args *uap)
  529 {
  530         struct itimerval itv, oitv, *itvp;      
  531         struct itimerval32 i32;
  532         int error;
  533 
  534         if (uap->itv != NULL) {
  535                 error = copyin(uap->itv, &i32, sizeof(i32));
  536                 if (error)
  537                         return (error);
  538                 TV_CP(i32, itv, it_interval);
  539                 TV_CP(i32, itv, it_value);
  540                 itvp = &itv;
  541         } else
  542                 itvp = NULL;
  543         error = kern_setitimer(td, uap->which, itvp, &oitv);
  544         if (error || uap->oitv == NULL)
  545                 return (error);
  546         TV_CP(oitv, i32, it_interval);
  547         TV_CP(oitv, i32, it_value);
  548         return (copyout(&i32, uap->oitv, sizeof(i32)));
  549 }
  550 
  551 int
  552 freebsd32_getitimer(struct thread *td, struct freebsd32_getitimer_args *uap)
  553 {
  554         struct itimerval itv;
  555         struct itimerval32 i32;
  556         int error;
  557 
  558         error = kern_getitimer(td, uap->which, &itv);
  559         if (error || uap->itv == NULL)
  560                 return (error);
  561         TV_CP(itv, i32, it_interval);
  562         TV_CP(itv, i32, it_value);
  563         return (copyout(&i32, uap->itv, sizeof(i32)));
  564 }
  565 
  566 int
  567 freebsd32_select(struct thread *td, struct freebsd32_select_args *uap)
  568 {
  569         struct timeval32 tv32;
  570         struct timeval tv, *tvp;
  571         int error;
  572 
  573         if (uap->tv != NULL) {
  574                 error = copyin(uap->tv, &tv32, sizeof(tv32));
  575                 if (error)
  576                         return (error);
  577                 CP(tv32, tv, tv_sec);
  578                 CP(tv32, tv, tv_usec);
  579                 tvp = &tv;
  580         } else
  581                 tvp = NULL;
  582         /*
  583          * XXX Do pointers need PTRIN()?
  584          */
  585         return (kern_select(td, uap->nd, uap->in, uap->ou, uap->ex, tvp,
  586             sizeof(int32_t) * 8));
  587 }
  588 
  589 int
  590 freebsd32_pselect(struct thread *td, struct freebsd32_pselect_args *uap)
  591 {
  592         struct timespec32 ts32;
  593         struct timespec ts;
  594         struct timeval tv, *tvp;
  595         sigset_t set, *uset;
  596         int error;
  597 
  598         if (uap->ts != NULL) {
  599                 error = copyin(uap->ts, &ts32, sizeof(ts32));
  600                 if (error != 0)
  601                         return (error);
  602                 CP(ts32, ts, tv_sec);
  603                 CP(ts32, ts, tv_nsec);
  604                 TIMESPEC_TO_TIMEVAL(&tv, &ts);
  605                 tvp = &tv;
  606         } else
  607                 tvp = NULL;
  608         if (uap->sm != NULL) {
  609                 error = copyin(uap->sm, &set, sizeof(set));
  610                 if (error != 0)
  611                         return (error);
  612                 uset = &set;
  613         } else
  614                 uset = NULL;
  615         /*
  616          * XXX Do pointers need PTRIN()?
  617          */
  618         error = kern_pselect(td, uap->nd, uap->in, uap->ou, uap->ex, tvp,
  619             uset, sizeof(int32_t) * 8);
  620         return (error);
  621 }
  622 
  623 /*
  624  * Copy 'count' items into the destination list pointed to by uap->eventlist.
  625  */
  626 static int
  627 freebsd32_kevent_copyout(void *arg, struct kevent *kevp, int count)
  628 {
  629         struct freebsd32_kevent_args *uap;
  630         struct kevent32 ks32[KQ_NEVENTS];
  631         uint64_t e;
  632         int i, j, error;
  633 
  634         KASSERT(count <= KQ_NEVENTS, ("count (%d) > KQ_NEVENTS", count));
  635         uap = (struct freebsd32_kevent_args *)arg;
  636 
  637         for (i = 0; i < count; i++) {
  638                 CP(kevp[i], ks32[i], ident);
  639                 CP(kevp[i], ks32[i], filter);
  640                 CP(kevp[i], ks32[i], flags);
  641                 CP(kevp[i], ks32[i], fflags);
  642 #if BYTE_ORDER == LITTLE_ENDIAN
  643                 ks32[i].data1 = kevp[i].data;
  644                 ks32[i].data2 = kevp[i].data >> 32;
  645 #else
  646                 ks32[i].data1 = kevp[i].data >> 32;
  647                 ks32[i].data2 = kevp[i].data;
  648 #endif
  649                 PTROUT_CP(kevp[i], ks32[i], udata);
  650                 for (j = 0; j < nitems(kevp->ext); j++) {
  651                         e = kevp[i].ext[j];
  652 #if BYTE_ORDER == LITTLE_ENDIAN
  653                         ks32[i].ext64[2 * j] = e;
  654                         ks32[i].ext64[2 * j + 1] = e >> 32;
  655 #else
  656                         ks32[i].ext64[2 * j] = e >> 32;
  657                         ks32[i].ext64[2 * j + 1] = e;
  658 #endif
  659                 }
  660         }
  661         error = copyout(ks32, uap->eventlist, count * sizeof *ks32);
  662         if (error == 0)
  663                 uap->eventlist += count;
  664         return (error);
  665 }
  666 
  667 /*
  668  * Copy 'count' items from the list pointed to by uap->changelist.
  669  */
  670 static int
  671 freebsd32_kevent_copyin(void *arg, struct kevent *kevp, int count)
  672 {
  673         struct freebsd32_kevent_args *uap;
  674         struct kevent32 ks32[KQ_NEVENTS];
  675         uint64_t e;
  676         int i, j, error;
  677 
  678         KASSERT(count <= KQ_NEVENTS, ("count (%d) > KQ_NEVENTS", count));
  679         uap = (struct freebsd32_kevent_args *)arg;
  680 
  681         error = copyin(uap->changelist, ks32, count * sizeof *ks32);
  682         if (error)
  683                 goto done;
  684         uap->changelist += count;
  685 
  686         for (i = 0; i < count; i++) {
  687                 CP(ks32[i], kevp[i], ident);
  688                 CP(ks32[i], kevp[i], filter);
  689                 CP(ks32[i], kevp[i], flags);
  690                 CP(ks32[i], kevp[i], fflags);
  691                 kevp[i].data = PAIR32TO64(uint64_t, ks32[i].data);
  692                 PTRIN_CP(ks32[i], kevp[i], udata);
  693                 for (j = 0; j < nitems(kevp->ext); j++) {
  694 #if BYTE_ORDER == LITTLE_ENDIAN
  695                         e = ks32[i].ext64[2 * j + 1];
  696                         e <<= 32;
  697                         e += ks32[i].ext64[2 * j];
  698 #else
  699                         e = ks32[i].ext64[2 * j];
  700                         e <<= 32;
  701                         e += ks32[i].ext64[2 * j + 1];
  702 #endif
  703                         kevp[i].ext[j] = e;
  704                 }
  705         }
  706 done:
  707         return (error);
  708 }
  709 
  710 int
  711 freebsd32_kevent(struct thread *td, struct freebsd32_kevent_args *uap)
  712 {
  713         struct timespec32 ts32;
  714         struct timespec ts, *tsp;
  715         struct kevent_copyops k_ops = {
  716                 .arg = uap,
  717                 .k_copyout = freebsd32_kevent_copyout,
  718                 .k_copyin = freebsd32_kevent_copyin,
  719         };
  720 #ifdef KTRACE
  721         struct kevent32 *eventlist = uap->eventlist;
  722 #endif
  723         int error;
  724 
  725         if (uap->timeout) {
  726                 error = copyin(uap->timeout, &ts32, sizeof(ts32));
  727                 if (error)
  728                         return (error);
  729                 CP(ts32, ts, tv_sec);
  730                 CP(ts32, ts, tv_nsec);
  731                 tsp = &ts;
  732         } else
  733                 tsp = NULL;
  734 #ifdef KTRACE
  735         if (KTRPOINT(td, KTR_STRUCT_ARRAY))
  736                 ktrstructarray("kevent32", UIO_USERSPACE, uap->changelist,
  737                     uap->nchanges, sizeof(struct kevent32));
  738 #endif
  739         error = kern_kevent(td, uap->fd, uap->nchanges, uap->nevents,
  740             &k_ops, tsp);
  741 #ifdef KTRACE
  742         if (error == 0 && KTRPOINT(td, KTR_STRUCT_ARRAY))
  743                 ktrstructarray("kevent32", UIO_USERSPACE, eventlist,
  744                     td->td_retval[0], sizeof(struct kevent32));
  745 #endif
  746         return (error);
  747 }
  748 
  749 #ifdef COMPAT_FREEBSD11
  750 static int
  751 freebsd32_kevent11_copyout(void *arg, struct kevent *kevp, int count)
  752 {
  753         struct freebsd11_freebsd32_kevent_args *uap;
  754         struct kevent32_freebsd11 ks32[KQ_NEVENTS];
  755         int i, error;
  756 
  757         KASSERT(count <= KQ_NEVENTS, ("count (%d) > KQ_NEVENTS", count));
  758         uap = (struct freebsd11_freebsd32_kevent_args *)arg;
  759 
  760         for (i = 0; i < count; i++) {
  761                 CP(kevp[i], ks32[i], ident);
  762                 CP(kevp[i], ks32[i], filter);
  763                 CP(kevp[i], ks32[i], flags);
  764                 CP(kevp[i], ks32[i], fflags);
  765                 CP(kevp[i], ks32[i], data);
  766                 PTROUT_CP(kevp[i], ks32[i], udata);
  767         }
  768         error = copyout(ks32, uap->eventlist, count * sizeof *ks32);
  769         if (error == 0)
  770                 uap->eventlist += count;
  771         return (error);
  772 }
  773 
  774 /*
  775  * Copy 'count' items from the list pointed to by uap->changelist.
  776  */
  777 static int
  778 freebsd32_kevent11_copyin(void *arg, struct kevent *kevp, int count)
  779 {
  780         struct freebsd11_freebsd32_kevent_args *uap;
  781         struct kevent32_freebsd11 ks32[KQ_NEVENTS];
  782         int i, j, error;
  783 
  784         KASSERT(count <= KQ_NEVENTS, ("count (%d) > KQ_NEVENTS", count));
  785         uap = (struct freebsd11_freebsd32_kevent_args *)arg;
  786 
  787         error = copyin(uap->changelist, ks32, count * sizeof *ks32);
  788         if (error)
  789                 goto done;
  790         uap->changelist += count;
  791 
  792         for (i = 0; i < count; i++) {
  793                 CP(ks32[i], kevp[i], ident);
  794                 CP(ks32[i], kevp[i], filter);
  795                 CP(ks32[i], kevp[i], flags);
  796                 CP(ks32[i], kevp[i], fflags);
  797                 CP(ks32[i], kevp[i], data);
  798                 PTRIN_CP(ks32[i], kevp[i], udata);
  799                 for (j = 0; j < nitems(kevp->ext); j++)
  800                         kevp[i].ext[j] = 0;
  801         }
  802 done:
  803         return (error);
  804 }
  805 
  806 int
  807 freebsd11_freebsd32_kevent(struct thread *td,
  808     struct freebsd11_freebsd32_kevent_args *uap)
  809 {
  810         struct timespec32 ts32;
  811         struct timespec ts, *tsp;
  812         struct kevent_copyops k_ops = {
  813                 .arg = uap,
  814                 .k_copyout = freebsd32_kevent11_copyout,
  815                 .k_copyin = freebsd32_kevent11_copyin,
  816         };
  817 #ifdef KTRACE
  818         struct kevent32_freebsd11 *eventlist = uap->eventlist;
  819 #endif
  820         int error;
  821 
  822         if (uap->timeout) {
  823                 error = copyin(uap->timeout, &ts32, sizeof(ts32));
  824                 if (error)
  825                         return (error);
  826                 CP(ts32, ts, tv_sec);
  827                 CP(ts32, ts, tv_nsec);
  828                 tsp = &ts;
  829         } else
  830                 tsp = NULL;
  831 #ifdef KTRACE
  832         if (KTRPOINT(td, KTR_STRUCT_ARRAY))
  833                 ktrstructarray("kevent32_freebsd11", UIO_USERSPACE,
  834                     uap->changelist, uap->nchanges,
  835                     sizeof(struct kevent32_freebsd11));
  836 #endif
  837         error = kern_kevent(td, uap->fd, uap->nchanges, uap->nevents,
  838             &k_ops, tsp);
  839 #ifdef KTRACE
  840         if (error == 0 && KTRPOINT(td, KTR_STRUCT_ARRAY))
  841                 ktrstructarray("kevent32_freebsd11", UIO_USERSPACE,
  842                     eventlist, td->td_retval[0],
  843                     sizeof(struct kevent32_freebsd11));
  844 #endif
  845         return (error);
  846 }
  847 #endif
  848 
  849 int
  850 freebsd32_gettimeofday(struct thread *td,
  851                        struct freebsd32_gettimeofday_args *uap)
  852 {
  853         struct timeval atv;
  854         struct timeval32 atv32;
  855         struct timezone rtz;
  856         int error = 0;
  857 
  858         if (uap->tp) {
  859                 microtime(&atv);
  860                 CP(atv, atv32, tv_sec);
  861                 CP(atv, atv32, tv_usec);
  862                 error = copyout(&atv32, uap->tp, sizeof (atv32));
  863         }
  864         if (error == 0 && uap->tzp != NULL) {
  865                 rtz.tz_minuteswest = 0;
  866                 rtz.tz_dsttime = 0;
  867                 error = copyout(&rtz, uap->tzp, sizeof (rtz));
  868         }
  869         return (error);
  870 }
  871 
  872 int
  873 freebsd32_getrusage(struct thread *td, struct freebsd32_getrusage_args *uap)
  874 {
  875         struct rusage32 s32;
  876         struct rusage s;
  877         int error;
  878 
  879         error = kern_getrusage(td, uap->who, &s);
  880         if (error == 0) {
  881                 freebsd32_rusage_out(&s, &s32);
  882                 error = copyout(&s32, uap->rusage, sizeof(s32));
  883         }
  884         return (error);
  885 }
  886 
  887 static void
  888 ptrace_lwpinfo_to32(const struct ptrace_lwpinfo *pl,
  889     struct ptrace_lwpinfo32 *pl32)
  890 {
  891 
  892         bzero(pl32, sizeof(*pl32));
  893         pl32->pl_lwpid = pl->pl_lwpid;
  894         pl32->pl_event = pl->pl_event;
  895         pl32->pl_flags = pl->pl_flags;
  896         pl32->pl_sigmask = pl->pl_sigmask;
  897         pl32->pl_siglist = pl->pl_siglist;
  898         siginfo_to_siginfo32(&pl->pl_siginfo, &pl32->pl_siginfo);
  899         strcpy(pl32->pl_tdname, pl->pl_tdname);
  900         pl32->pl_child_pid = pl->pl_child_pid;
  901         pl32->pl_syscall_code = pl->pl_syscall_code;
  902         pl32->pl_syscall_narg = pl->pl_syscall_narg;
  903 }
  904 
  905 static void
  906 ptrace_sc_ret_to32(const struct ptrace_sc_ret *psr,
  907     struct ptrace_sc_ret32 *psr32)
  908 {
  909 
  910         bzero(psr32, sizeof(*psr32));
  911         psr32->sr_retval[0] = psr->sr_retval[0];
  912         psr32->sr_retval[1] = psr->sr_retval[1];
  913         psr32->sr_error = psr->sr_error;
  914 }
  915 
  916 int
  917 freebsd32_ptrace(struct thread *td, struct freebsd32_ptrace_args *uap)
  918 {
  919         union {
  920                 struct ptrace_io_desc piod;
  921                 struct ptrace_lwpinfo pl;
  922                 struct ptrace_vm_entry pve;
  923                 struct ptrace_coredump pc;
  924                 struct dbreg32 dbreg;
  925                 struct fpreg32 fpreg;
  926                 struct reg32 reg;
  927                 register_t args[nitems(td->td_sa.args)];
  928                 struct ptrace_sc_ret psr;
  929                 int ptevents;
  930         } r;
  931         union {
  932                 struct ptrace_io_desc32 piod;
  933                 struct ptrace_lwpinfo32 pl;
  934                 struct ptrace_vm_entry32 pve;
  935                 struct ptrace_coredump32 pc;
  936                 uint32_t args[nitems(td->td_sa.args)];
  937                 struct ptrace_sc_ret32 psr;
  938         } r32;
  939         void *addr;
  940         int data, error = 0, i;
  941 
  942         AUDIT_ARG_PID(uap->pid);
  943         AUDIT_ARG_CMD(uap->req);
  944         AUDIT_ARG_VALUE(uap->data);
  945         addr = &r;
  946         data = uap->data;
  947         switch (uap->req) {
  948         case PT_GET_EVENT_MASK:
  949         case PT_GET_SC_ARGS:
  950         case PT_GET_SC_RET:
  951                 break;
  952         case PT_LWPINFO:
  953                 if (uap->data > sizeof(r32.pl))
  954                         return (EINVAL);
  955 
  956                 /*
  957                  * Pass size of native structure in 'data'.  Truncate
  958                  * if necessary to avoid siginfo.
  959                  */
  960                 data = sizeof(r.pl);
  961                 if (uap->data < offsetof(struct ptrace_lwpinfo32, pl_siginfo) +
  962                     sizeof(struct siginfo32))
  963                         data = offsetof(struct ptrace_lwpinfo, pl_siginfo);
  964                 break;
  965         case PT_GETREGS:
  966                 bzero(&r.reg, sizeof(r.reg));
  967                 break;
  968         case PT_GETFPREGS:
  969                 bzero(&r.fpreg, sizeof(r.fpreg));
  970                 break;
  971         case PT_GETDBREGS:
  972                 bzero(&r.dbreg, sizeof(r.dbreg));
  973                 break;
  974         case PT_SETREGS:
  975                 error = copyin(uap->addr, &r.reg, sizeof(r.reg));
  976                 break;
  977         case PT_SETFPREGS:
  978                 error = copyin(uap->addr, &r.fpreg, sizeof(r.fpreg));
  979                 break;
  980         case PT_SETDBREGS:
  981                 error = copyin(uap->addr, &r.dbreg, sizeof(r.dbreg));
  982                 break;
  983         case PT_SET_EVENT_MASK:
  984                 if (uap->data != sizeof(r.ptevents))
  985                         error = EINVAL;
  986                 else
  987                         error = copyin(uap->addr, &r.ptevents, uap->data);
  988                 break;
  989         case PT_IO:
  990                 error = copyin(uap->addr, &r32.piod, sizeof(r32.piod));
  991                 if (error)
  992                         break;
  993                 CP(r32.piod, r.piod, piod_op);
  994                 PTRIN_CP(r32.piod, r.piod, piod_offs);
  995                 PTRIN_CP(r32.piod, r.piod, piod_addr);
  996                 CP(r32.piod, r.piod, piod_len);
  997                 break;
  998         case PT_VM_ENTRY:
  999                 error = copyin(uap->addr, &r32.pve, sizeof(r32.pve));
 1000                 if (error)
 1001                         break;
 1002 
 1003                 CP(r32.pve, r.pve, pve_entry);
 1004                 CP(r32.pve, r.pve, pve_timestamp);
 1005                 CP(r32.pve, r.pve, pve_start);
 1006                 CP(r32.pve, r.pve, pve_end);
 1007                 CP(r32.pve, r.pve, pve_offset);
 1008                 CP(r32.pve, r.pve, pve_prot);
 1009                 CP(r32.pve, r.pve, pve_pathlen);
 1010                 CP(r32.pve, r.pve, pve_fileid);
 1011                 CP(r32.pve, r.pve, pve_fsid);
 1012                 PTRIN_CP(r32.pve, r.pve, pve_path);
 1013                 break;
 1014         case PT_COREDUMP:
 1015                 if (uap->data != sizeof(r32.pc))
 1016                         error = EINVAL;
 1017                 else
 1018                         error = copyin(uap->addr, &r32.pc, uap->data);
 1019                 CP(r32.pc, r.pc, pc_fd);
 1020                 CP(r32.pc, r.pc, pc_flags);
 1021                 r.pc.pc_limit = PAIR32TO64(off_t, r32.pc.pc_limit);
 1022                 data = sizeof(r.pc);
 1023                 break;
 1024         default:
 1025                 addr = uap->addr;
 1026                 break;
 1027         }
 1028         if (error)
 1029                 return (error);
 1030 
 1031         error = kern_ptrace(td, uap->req, uap->pid, addr, data);
 1032         if (error)
 1033                 return (error);
 1034 
 1035         switch (uap->req) {
 1036         case PT_VM_ENTRY:
 1037                 CP(r.pve, r32.pve, pve_entry);
 1038                 CP(r.pve, r32.pve, pve_timestamp);
 1039                 CP(r.pve, r32.pve, pve_start);
 1040                 CP(r.pve, r32.pve, pve_end);
 1041                 CP(r.pve, r32.pve, pve_offset);
 1042                 CP(r.pve, r32.pve, pve_prot);
 1043                 CP(r.pve, r32.pve, pve_pathlen);
 1044                 CP(r.pve, r32.pve, pve_fileid);
 1045                 CP(r.pve, r32.pve, pve_fsid);
 1046                 error = copyout(&r32.pve, uap->addr, sizeof(r32.pve));
 1047                 break;
 1048         case PT_IO:
 1049                 CP(r.piod, r32.piod, piod_len);
 1050                 error = copyout(&r32.piod, uap->addr, sizeof(r32.piod));
 1051                 break;
 1052         case PT_GETREGS:
 1053                 error = copyout(&r.reg, uap->addr, sizeof(r.reg));
 1054                 break;
 1055         case PT_GETFPREGS:
 1056                 error = copyout(&r.fpreg, uap->addr, sizeof(r.fpreg));
 1057                 break;
 1058         case PT_GETDBREGS:
 1059                 error = copyout(&r.dbreg, uap->addr, sizeof(r.dbreg));
 1060                 break;
 1061         case PT_GET_EVENT_MASK:
 1062                 /* NB: The size in uap->data is validated in kern_ptrace(). */
 1063                 error = copyout(&r.ptevents, uap->addr, uap->data);
 1064                 break;
 1065         case PT_LWPINFO:
 1066                 ptrace_lwpinfo_to32(&r.pl, &r32.pl);
 1067                 error = copyout(&r32.pl, uap->addr, uap->data);
 1068                 break;
 1069         case PT_GET_SC_ARGS:
 1070                 for (i = 0; i < nitems(r.args); i++)
 1071                         r32.args[i] = (uint32_t)r.args[i];
 1072                 error = copyout(r32.args, uap->addr, MIN(uap->data,
 1073                     sizeof(r32.args)));
 1074                 break;
 1075         case PT_GET_SC_RET:
 1076                 ptrace_sc_ret_to32(&r.psr, &r32.psr);
 1077                 error = copyout(&r32.psr, uap->addr, MIN(uap->data,
 1078                     sizeof(r32.psr)));
 1079                 break;
 1080         }
 1081 
 1082         return (error);
 1083 }
 1084 
 1085 int
 1086 freebsd32_copyinuio(struct iovec32 *iovp, u_int iovcnt, struct uio **uiop)
 1087 {
 1088         struct iovec32 iov32;
 1089         struct iovec *iov;
 1090         struct uio *uio;
 1091         u_int iovlen;
 1092         int error, i;
 1093 
 1094         *uiop = NULL;
 1095         if (iovcnt > UIO_MAXIOV)
 1096                 return (EINVAL);
 1097         iovlen = iovcnt * sizeof(struct iovec);
 1098         uio = malloc(iovlen + sizeof *uio, M_IOV, M_WAITOK);
 1099         iov = (struct iovec *)(uio + 1);
 1100         for (i = 0; i < iovcnt; i++) {
 1101                 error = copyin(&iovp[i], &iov32, sizeof(struct iovec32));
 1102                 if (error) {
 1103                         free(uio, M_IOV);
 1104                         return (error);
 1105                 }
 1106                 iov[i].iov_base = PTRIN(iov32.iov_base);
 1107                 iov[i].iov_len = iov32.iov_len;
 1108         }
 1109         uio->uio_iov = iov;
 1110         uio->uio_iovcnt = iovcnt;
 1111         uio->uio_segflg = UIO_USERSPACE;
 1112         uio->uio_offset = -1;
 1113         uio->uio_resid = 0;
 1114         for (i = 0; i < iovcnt; i++) {
 1115                 if (iov->iov_len > INT_MAX - uio->uio_resid) {
 1116                         free(uio, M_IOV);
 1117                         return (EINVAL);
 1118                 }
 1119                 uio->uio_resid += iov->iov_len;
 1120                 iov++;
 1121         }
 1122         *uiop = uio;
 1123         return (0);
 1124 }
 1125 
 1126 int
 1127 freebsd32_readv(struct thread *td, struct freebsd32_readv_args *uap)
 1128 {
 1129         struct uio *auio;
 1130         int error;
 1131 
 1132         error = freebsd32_copyinuio(uap->iovp, uap->iovcnt, &auio);
 1133         if (error)
 1134                 return (error);
 1135         error = kern_readv(td, uap->fd, auio);
 1136         free(auio, M_IOV);
 1137         return (error);
 1138 }
 1139 
 1140 int
 1141 freebsd32_writev(struct thread *td, struct freebsd32_writev_args *uap)
 1142 {
 1143         struct uio *auio;
 1144         int error;
 1145 
 1146         error = freebsd32_copyinuio(uap->iovp, uap->iovcnt, &auio);
 1147         if (error)
 1148                 return (error);
 1149         error = kern_writev(td, uap->fd, auio);
 1150         free(auio, M_IOV);
 1151         return (error);
 1152 }
 1153 
 1154 int
 1155 freebsd32_preadv(struct thread *td, struct freebsd32_preadv_args *uap)
 1156 {
 1157         struct uio *auio;
 1158         int error;
 1159 
 1160         error = freebsd32_copyinuio(uap->iovp, uap->iovcnt, &auio);
 1161         if (error)
 1162                 return (error);
 1163         error = kern_preadv(td, uap->fd, auio, PAIR32TO64(off_t,uap->offset));
 1164         free(auio, M_IOV);
 1165         return (error);
 1166 }
 1167 
 1168 int
 1169 freebsd32_pwritev(struct thread *td, struct freebsd32_pwritev_args *uap)
 1170 {
 1171         struct uio *auio;
 1172         int error;
 1173 
 1174         error = freebsd32_copyinuio(uap->iovp, uap->iovcnt, &auio);
 1175         if (error)
 1176                 return (error);
 1177         error = kern_pwritev(td, uap->fd, auio, PAIR32TO64(off_t,uap->offset));
 1178         free(auio, M_IOV);
 1179         return (error);
 1180 }
 1181 
 1182 int
 1183 freebsd32_copyiniov(struct iovec32 *iovp32, u_int iovcnt, struct iovec **iovp,
 1184     int error)
 1185 {
 1186         struct iovec32 iov32;
 1187         struct iovec *iov;
 1188         u_int iovlen;
 1189         int i;
 1190 
 1191         *iovp = NULL;
 1192         if (iovcnt > UIO_MAXIOV)
 1193                 return (error);
 1194         iovlen = iovcnt * sizeof(struct iovec);
 1195         iov = malloc(iovlen, M_IOV, M_WAITOK);
 1196         for (i = 0; i < iovcnt; i++) {
 1197                 error = copyin(&iovp32[i], &iov32, sizeof(struct iovec32));
 1198                 if (error) {
 1199                         free(iov, M_IOV);
 1200                         return (error);
 1201                 }
 1202                 iov[i].iov_base = PTRIN(iov32.iov_base);
 1203                 iov[i].iov_len = iov32.iov_len;
 1204         }
 1205         *iovp = iov;
 1206         return (0);
 1207 }
 1208 
 1209 static int
 1210 freebsd32_copyinmsghdr(struct msghdr32 *msg32, struct msghdr *msg)
 1211 {
 1212         struct msghdr32 m32;
 1213         int error;
 1214 
 1215         error = copyin(msg32, &m32, sizeof(m32));
 1216         if (error)
 1217                 return (error);
 1218         msg->msg_name = PTRIN(m32.msg_name);
 1219         msg->msg_namelen = m32.msg_namelen;
 1220         msg->msg_iov = PTRIN(m32.msg_iov);
 1221         msg->msg_iovlen = m32.msg_iovlen;
 1222         msg->msg_control = PTRIN(m32.msg_control);
 1223         msg->msg_controllen = m32.msg_controllen;
 1224         msg->msg_flags = m32.msg_flags;
 1225         return (0);
 1226 }
 1227 
 1228 static int
 1229 freebsd32_copyoutmsghdr(struct msghdr *msg, struct msghdr32 *msg32)
 1230 {
 1231         struct msghdr32 m32;
 1232         int error;
 1233 
 1234         m32.msg_name = PTROUT(msg->msg_name);
 1235         m32.msg_namelen = msg->msg_namelen;
 1236         m32.msg_iov = PTROUT(msg->msg_iov);
 1237         m32.msg_iovlen = msg->msg_iovlen;
 1238         m32.msg_control = PTROUT(msg->msg_control);
 1239         m32.msg_controllen = msg->msg_controllen;
 1240         m32.msg_flags = msg->msg_flags;
 1241         error = copyout(&m32, msg32, sizeof(m32));
 1242         return (error);
 1243 }
 1244 
 1245 #ifndef __mips__
 1246 #define FREEBSD32_ALIGNBYTES    (sizeof(int) - 1)
 1247 #else
 1248 #define FREEBSD32_ALIGNBYTES    (sizeof(long) - 1)
 1249 #endif
 1250 #define FREEBSD32_ALIGN(p)      \
 1251         (((u_long)(p) + FREEBSD32_ALIGNBYTES) & ~FREEBSD32_ALIGNBYTES)
 1252 #define FREEBSD32_CMSG_SPACE(l) \
 1253         (FREEBSD32_ALIGN(sizeof(struct cmsghdr)) + FREEBSD32_ALIGN(l))
 1254 
 1255 #define FREEBSD32_CMSG_DATA(cmsg)       ((unsigned char *)(cmsg) + \
 1256                                  FREEBSD32_ALIGN(sizeof(struct cmsghdr)))
 1257 
 1258 static size_t
 1259 freebsd32_cmsg_convert(const struct cmsghdr *cm, void *data, socklen_t datalen)
 1260 {
 1261         size_t copylen;
 1262         union {
 1263                 struct timespec32 ts;
 1264                 struct timeval32 tv;
 1265                 struct bintime32 bt;
 1266         } tmp32;
 1267 
 1268         union {
 1269                 struct timespec ts;
 1270                 struct timeval tv;
 1271                 struct bintime bt;
 1272         } *in;
 1273 
 1274         in = data;
 1275         copylen = 0;
 1276         switch (cm->cmsg_level) {
 1277         case SOL_SOCKET:
 1278                 switch (cm->cmsg_type) {
 1279                 case SCM_TIMESTAMP:
 1280                         TV_CP(*in, tmp32, tv);
 1281                         copylen = sizeof(tmp32.tv);
 1282                         break;
 1283 
 1284                 case SCM_BINTIME:
 1285                         BT_CP(*in, tmp32, bt);
 1286                         copylen = sizeof(tmp32.bt);
 1287                         break;
 1288 
 1289                 case SCM_REALTIME:
 1290                 case SCM_MONOTONIC:
 1291                         TS_CP(*in, tmp32, ts);
 1292                         copylen = sizeof(tmp32.ts);
 1293                         break;
 1294 
 1295                 default:
 1296                         break;
 1297                 }
 1298 
 1299         default:
 1300                 break;
 1301         }
 1302 
 1303         if (copylen == 0)
 1304                 return (datalen);
 1305 
 1306         KASSERT((datalen >= copylen), ("corrupted cmsghdr"));
 1307 
 1308         bcopy(&tmp32, data, copylen);
 1309         return (copylen);
 1310 }
 1311 
 1312 static int
 1313 freebsd32_copy_msg_out(struct msghdr *msg, struct mbuf *control)
 1314 {
 1315         struct cmsghdr *cm;
 1316         void *data;
 1317         socklen_t clen, datalen, datalen_out, oldclen;
 1318         int error;
 1319         caddr_t ctlbuf;
 1320         int len, maxlen, copylen;
 1321         struct mbuf *m;
 1322         error = 0;
 1323 
 1324         len    = msg->msg_controllen;
 1325         maxlen = msg->msg_controllen;
 1326         msg->msg_controllen = 0;
 1327 
 1328         ctlbuf = msg->msg_control;
 1329         for (m = control; m != NULL && len > 0; m = m->m_next) {
 1330                 cm = mtod(m, struct cmsghdr *);
 1331                 clen = m->m_len;
 1332                 while (cm != NULL) {
 1333                         if (sizeof(struct cmsghdr) > clen ||
 1334                             cm->cmsg_len > clen) {
 1335                                 error = EINVAL;
 1336                                 break;
 1337                         }
 1338 
 1339                         data   = CMSG_DATA(cm);
 1340                         datalen = (caddr_t)cm + cm->cmsg_len - (caddr_t)data;
 1341                         datalen_out = freebsd32_cmsg_convert(cm, data, datalen);
 1342 
 1343                         /*
 1344                          * Copy out the message header.  Preserve the native
 1345                          * message size in case we need to inspect the message
 1346                          * contents later.
 1347                          */
 1348                         copylen = sizeof(struct cmsghdr);
 1349                         if (len < copylen) {
 1350                                 msg->msg_flags |= MSG_CTRUNC;
 1351                                 m_dispose_extcontrolm(m);
 1352                                 goto exit;
 1353                         }
 1354                         oldclen = cm->cmsg_len;
 1355                         cm->cmsg_len = FREEBSD32_ALIGN(sizeof(struct cmsghdr)) +
 1356                             datalen_out;
 1357                         error = copyout(cm, ctlbuf, copylen);
 1358                         cm->cmsg_len = oldclen;
 1359                         if (error != 0)
 1360                                 goto exit;
 1361 
 1362                         ctlbuf += FREEBSD32_ALIGN(copylen);
 1363                         len    -= FREEBSD32_ALIGN(copylen);
 1364 
 1365                         copylen = datalen_out;
 1366                         if (len < copylen) {
 1367                                 msg->msg_flags |= MSG_CTRUNC;
 1368                                 m_dispose_extcontrolm(m);
 1369                                 break;
 1370                         }
 1371 
 1372                         /* Copy out the message data. */
 1373                         error = copyout(data, ctlbuf, copylen);
 1374                         if (error)
 1375                                 goto exit;
 1376 
 1377                         ctlbuf += FREEBSD32_ALIGN(copylen);
 1378                         len    -= FREEBSD32_ALIGN(copylen);
 1379 
 1380                         if (CMSG_SPACE(datalen) < clen) {
 1381                                 clen -= CMSG_SPACE(datalen);
 1382                                 cm = (struct cmsghdr *)
 1383                                     ((caddr_t)cm + CMSG_SPACE(datalen));
 1384                         } else {
 1385                                 clen = 0;
 1386                                 cm = NULL;
 1387                         }
 1388 
 1389                         msg->msg_controllen +=
 1390                             FREEBSD32_CMSG_SPACE(datalen_out);
 1391                 }
 1392         }
 1393         if (len == 0 && m != NULL) {
 1394                 msg->msg_flags |= MSG_CTRUNC;
 1395                 m_dispose_extcontrolm(m);
 1396         }
 1397 
 1398 exit:
 1399         return (error);
 1400 }
 1401 
 1402 int
 1403 freebsd32_recvmsg(struct thread *td, struct freebsd32_recvmsg_args *uap)
 1404 {
 1405         struct msghdr msg;
 1406         struct iovec *uiov, *iov;
 1407         struct mbuf *control = NULL;
 1408         struct mbuf **controlp;
 1409         int error;
 1410 
 1411         error = freebsd32_copyinmsghdr(uap->msg, &msg);
 1412         if (error)
 1413                 return (error);
 1414         error = freebsd32_copyiniov((void *)msg.msg_iov, msg.msg_iovlen, &iov,
 1415             EMSGSIZE);
 1416         if (error)
 1417                 return (error);
 1418         msg.msg_flags = uap->flags;
 1419         uiov = msg.msg_iov;
 1420         msg.msg_iov = iov;
 1421 
 1422         controlp = (msg.msg_control != NULL) ?  &control : NULL;
 1423         error = kern_recvit(td, uap->s, &msg, UIO_USERSPACE, controlp);
 1424         if (error == 0) {
 1425                 msg.msg_iov = uiov;
 1426 
 1427                 if (control != NULL)
 1428                         error = freebsd32_copy_msg_out(&msg, control);
 1429                 else
 1430                         msg.msg_controllen = 0;
 1431 
 1432                 if (error == 0)
 1433                         error = freebsd32_copyoutmsghdr(&msg, uap->msg);
 1434         }
 1435         free(iov, M_IOV);
 1436 
 1437         if (control != NULL) {
 1438                 if (error != 0)
 1439                         m_dispose_extcontrolm(control);
 1440                 m_freem(control);
 1441         }
 1442 
 1443         return (error);
 1444 }
 1445 
 1446 /*
 1447  * Copy-in the array of control messages constructed using alignment
 1448  * and padding suitable for a 32-bit environment and construct an
 1449  * mbuf using alignment and padding suitable for a 64-bit kernel.
 1450  * The alignment and padding are defined indirectly by CMSG_DATA(),
 1451  * CMSG_SPACE() and CMSG_LEN().
 1452  */
 1453 static int
 1454 freebsd32_copyin_control(struct mbuf **mp, caddr_t buf, u_int buflen)
 1455 {
 1456         struct cmsghdr *cm;
 1457         struct mbuf *m;
 1458         void *in, *in1, *md;
 1459         u_int msglen, outlen;
 1460         int error;
 1461 
 1462         if (buflen > MCLBYTES)
 1463                 return (EINVAL);
 1464 
 1465         in = malloc(buflen, M_TEMP, M_WAITOK);
 1466         error = copyin(buf, in, buflen);
 1467         if (error != 0)
 1468                 goto out;
 1469 
 1470         /*
 1471          * Make a pass over the input buffer to determine the amount of space
 1472          * required for 64 bit-aligned copies of the control messages.
 1473          */
 1474         in1 = in;
 1475         outlen = 0;
 1476         while (buflen > 0) {
 1477                 if (buflen < sizeof(*cm)) {
 1478                         error = EINVAL;
 1479                         break;
 1480                 }
 1481                 cm = (struct cmsghdr *)in1;
 1482                 if (cm->cmsg_len < FREEBSD32_ALIGN(sizeof(*cm))) {
 1483                         error = EINVAL;
 1484                         break;
 1485                 }
 1486                 msglen = FREEBSD32_ALIGN(cm->cmsg_len);
 1487                 if (msglen > buflen || msglen < cm->cmsg_len) {
 1488                         error = EINVAL;
 1489                         break;
 1490                 }
 1491                 buflen -= msglen;
 1492 
 1493                 in1 = (char *)in1 + msglen;
 1494                 outlen += CMSG_ALIGN(sizeof(*cm)) +
 1495                     CMSG_ALIGN(msglen - FREEBSD32_ALIGN(sizeof(*cm)));
 1496         }
 1497         if (error == 0 && outlen > MCLBYTES) {
 1498                 /*
 1499                  * XXXMJ This implies that the upper limit on 32-bit aligned
 1500                  * control messages is less than MCLBYTES, and so we are not
 1501                  * perfectly compatible.  However, there is no platform
 1502                  * guarantee that mbuf clusters larger than MCLBYTES can be
 1503                  * allocated.
 1504                  */
 1505                 error = EINVAL;
 1506         }
 1507         if (error != 0)
 1508                 goto out;
 1509 
 1510         m = m_get2(outlen, M_WAITOK, MT_CONTROL, 0);
 1511         m->m_len = outlen;
 1512         md = mtod(m, void *);
 1513 
 1514         /*
 1515          * Make a second pass over input messages, copying them into the output
 1516          * buffer.
 1517          */
 1518         in1 = in;
 1519         while (outlen > 0) {
 1520                 /* Copy the message header and align the length field. */
 1521                 cm = md;
 1522                 memcpy(cm, in1, sizeof(*cm));
 1523                 msglen = cm->cmsg_len - FREEBSD32_ALIGN(sizeof(*cm));
 1524                 cm->cmsg_len = CMSG_ALIGN(sizeof(*cm)) + msglen;
 1525 
 1526                 /* Copy the message body. */
 1527                 in1 = (char *)in1 + FREEBSD32_ALIGN(sizeof(*cm));
 1528                 md = (char *)md + CMSG_ALIGN(sizeof(*cm));
 1529                 memcpy(md, in1, msglen);
 1530                 in1 = (char *)in1 + FREEBSD32_ALIGN(msglen);
 1531                 md = (char *)md + CMSG_ALIGN(msglen);
 1532                 KASSERT(outlen >= CMSG_ALIGN(sizeof(*cm)) + CMSG_ALIGN(msglen),
 1533                     ("outlen %u underflow, msglen %u", outlen, msglen));
 1534                 outlen -= CMSG_ALIGN(sizeof(*cm)) + CMSG_ALIGN(msglen);
 1535         }
 1536 
 1537         *mp = m;
 1538 out:
 1539         free(in, M_TEMP);
 1540         return (error);
 1541 }
 1542 
 1543 int
 1544 freebsd32_sendmsg(struct thread *td, struct freebsd32_sendmsg_args *uap)
 1545 {
 1546         struct msghdr msg;
 1547         struct iovec *iov;
 1548         struct mbuf *control = NULL;
 1549         struct sockaddr *to = NULL;
 1550         int error;
 1551 
 1552         error = freebsd32_copyinmsghdr(uap->msg, &msg);
 1553         if (error)
 1554                 return (error);
 1555         error = freebsd32_copyiniov((void *)msg.msg_iov, msg.msg_iovlen, &iov,
 1556             EMSGSIZE);
 1557         if (error)
 1558                 return (error);
 1559         msg.msg_iov = iov;
 1560         if (msg.msg_name != NULL) {
 1561                 error = getsockaddr(&to, msg.msg_name, msg.msg_namelen);
 1562                 if (error) {
 1563                         to = NULL;
 1564                         goto out;
 1565                 }
 1566                 msg.msg_name = to;
 1567         }
 1568 
 1569         if (msg.msg_control) {
 1570                 if (msg.msg_controllen < sizeof(struct cmsghdr)) {
 1571                         error = EINVAL;
 1572                         goto out;
 1573                 }
 1574 
 1575                 error = freebsd32_copyin_control(&control, msg.msg_control,
 1576                     msg.msg_controllen);
 1577                 if (error)
 1578                         goto out;
 1579 
 1580                 msg.msg_control = NULL;
 1581                 msg.msg_controllen = 0;
 1582         }
 1583 
 1584         error = kern_sendit(td, uap->s, &msg, uap->flags, control,
 1585             UIO_USERSPACE);
 1586 
 1587 out:
 1588         free(iov, M_IOV);
 1589         if (to)
 1590                 free(to, M_SONAME);
 1591         return (error);
 1592 }
 1593 
 1594 int
 1595 freebsd32_recvfrom(struct thread *td,
 1596                    struct freebsd32_recvfrom_args *uap)
 1597 {
 1598         struct msghdr msg;
 1599         struct iovec aiov;
 1600         int error;
 1601 
 1602         if (uap->fromlenaddr) {
 1603                 error = copyin(PTRIN(uap->fromlenaddr), &msg.msg_namelen,
 1604                     sizeof(msg.msg_namelen));
 1605                 if (error)
 1606                         return (error);
 1607         } else {
 1608                 msg.msg_namelen = 0;
 1609         }
 1610 
 1611         msg.msg_name = PTRIN(uap->from);
 1612         msg.msg_iov = &aiov;
 1613         msg.msg_iovlen = 1;
 1614         aiov.iov_base = PTRIN(uap->buf);
 1615         aiov.iov_len = uap->len;
 1616         msg.msg_control = NULL;
 1617         msg.msg_flags = uap->flags;
 1618         error = kern_recvit(td, uap->s, &msg, UIO_USERSPACE, NULL);
 1619         if (error == 0 && uap->fromlenaddr)
 1620                 error = copyout(&msg.msg_namelen, PTRIN(uap->fromlenaddr),
 1621                     sizeof (msg.msg_namelen));
 1622         return (error);
 1623 }
 1624 
 1625 int
 1626 freebsd32_settimeofday(struct thread *td,
 1627                        struct freebsd32_settimeofday_args *uap)
 1628 {
 1629         struct timeval32 tv32;
 1630         struct timeval tv, *tvp;
 1631         struct timezone tz, *tzp;
 1632         int error;
 1633 
 1634         if (uap->tv) {
 1635                 error = copyin(uap->tv, &tv32, sizeof(tv32));
 1636                 if (error)
 1637                         return (error);
 1638                 CP(tv32, tv, tv_sec);
 1639                 CP(tv32, tv, tv_usec);
 1640                 tvp = &tv;
 1641         } else
 1642                 tvp = NULL;
 1643         if (uap->tzp) {
 1644                 error = copyin(uap->tzp, &tz, sizeof(tz));
 1645                 if (error)
 1646                         return (error);
 1647                 tzp = &tz;
 1648         } else
 1649                 tzp = NULL;
 1650         return (kern_settimeofday(td, tvp, tzp));
 1651 }
 1652 
 1653 int
 1654 freebsd32_utimes(struct thread *td, struct freebsd32_utimes_args *uap)
 1655 {
 1656         struct timeval32 s32[2];
 1657         struct timeval s[2], *sp;
 1658         int error;
 1659 
 1660         if (uap->tptr != NULL) {
 1661                 error = copyin(uap->tptr, s32, sizeof(s32));
 1662                 if (error)
 1663                         return (error);
 1664                 CP(s32[0], s[0], tv_sec);
 1665                 CP(s32[0], s[0], tv_usec);
 1666                 CP(s32[1], s[1], tv_sec);
 1667                 CP(s32[1], s[1], tv_usec);
 1668                 sp = s;
 1669         } else
 1670                 sp = NULL;
 1671         return (kern_utimesat(td, AT_FDCWD, uap->path, UIO_USERSPACE,
 1672             sp, UIO_SYSSPACE));
 1673 }
 1674 
 1675 int
 1676 freebsd32_lutimes(struct thread *td, struct freebsd32_lutimes_args *uap)
 1677 {
 1678         struct timeval32 s32[2];
 1679         struct timeval s[2], *sp;
 1680         int error;
 1681 
 1682         if (uap->tptr != NULL) {
 1683                 error = copyin(uap->tptr, s32, sizeof(s32));
 1684                 if (error)
 1685                         return (error);
 1686                 CP(s32[0], s[0], tv_sec);
 1687                 CP(s32[0], s[0], tv_usec);
 1688                 CP(s32[1], s[1], tv_sec);
 1689                 CP(s32[1], s[1], tv_usec);
 1690                 sp = s;
 1691         } else
 1692                 sp = NULL;
 1693         return (kern_lutimes(td, uap->path, UIO_USERSPACE, sp, UIO_SYSSPACE));
 1694 }
 1695 
 1696 int
 1697 freebsd32_futimes(struct thread *td, struct freebsd32_futimes_args *uap)
 1698 {
 1699         struct timeval32 s32[2];
 1700         struct timeval s[2], *sp;
 1701         int error;
 1702 
 1703         if (uap->tptr != NULL) {
 1704                 error = copyin(uap->tptr, s32, sizeof(s32));
 1705                 if (error)
 1706                         return (error);
 1707                 CP(s32[0], s[0], tv_sec);
 1708                 CP(s32[0], s[0], tv_usec);
 1709                 CP(s32[1], s[1], tv_sec);
 1710                 CP(s32[1], s[1], tv_usec);
 1711                 sp = s;
 1712         } else
 1713                 sp = NULL;
 1714         return (kern_futimes(td, uap->fd, sp, UIO_SYSSPACE));
 1715 }
 1716 
 1717 int
 1718 freebsd32_futimesat(struct thread *td, struct freebsd32_futimesat_args *uap)
 1719 {
 1720         struct timeval32 s32[2];
 1721         struct timeval s[2], *sp;
 1722         int error;
 1723 
 1724         if (uap->times != NULL) {
 1725                 error = copyin(uap->times, s32, sizeof(s32));
 1726                 if (error)
 1727                         return (error);
 1728                 CP(s32[0], s[0], tv_sec);
 1729                 CP(s32[0], s[0], tv_usec);
 1730                 CP(s32[1], s[1], tv_sec);
 1731                 CP(s32[1], s[1], tv_usec);
 1732                 sp = s;
 1733         } else
 1734                 sp = NULL;
 1735         return (kern_utimesat(td, uap->fd, uap->path, UIO_USERSPACE,
 1736                 sp, UIO_SYSSPACE));
 1737 }
 1738 
 1739 int
 1740 freebsd32_futimens(struct thread *td, struct freebsd32_futimens_args *uap)
 1741 {
 1742         struct timespec32 ts32[2];
 1743         struct timespec ts[2], *tsp;
 1744         int error;
 1745 
 1746         if (uap->times != NULL) {
 1747                 error = copyin(uap->times, ts32, sizeof(ts32));
 1748                 if (error)
 1749                         return (error);
 1750                 CP(ts32[0], ts[0], tv_sec);
 1751                 CP(ts32[0], ts[0], tv_nsec);
 1752                 CP(ts32[1], ts[1], tv_sec);
 1753                 CP(ts32[1], ts[1], tv_nsec);
 1754                 tsp = ts;
 1755         } else
 1756                 tsp = NULL;
 1757         return (kern_futimens(td, uap->fd, tsp, UIO_SYSSPACE));
 1758 }
 1759 
 1760 int
 1761 freebsd32_utimensat(struct thread *td, struct freebsd32_utimensat_args *uap)
 1762 {
 1763         struct timespec32 ts32[2];
 1764         struct timespec ts[2], *tsp;
 1765         int error;
 1766 
 1767         if (uap->times != NULL) {
 1768                 error = copyin(uap->times, ts32, sizeof(ts32));
 1769                 if (error)
 1770                         return (error);
 1771                 CP(ts32[0], ts[0], tv_sec);
 1772                 CP(ts32[0], ts[0], tv_nsec);
 1773                 CP(ts32[1], ts[1], tv_sec);
 1774                 CP(ts32[1], ts[1], tv_nsec);
 1775                 tsp = ts;
 1776         } else
 1777                 tsp = NULL;
 1778         return (kern_utimensat(td, uap->fd, uap->path, UIO_USERSPACE,
 1779             tsp, UIO_SYSSPACE, uap->flag));
 1780 }
 1781 
 1782 int
 1783 freebsd32_adjtime(struct thread *td, struct freebsd32_adjtime_args *uap)
 1784 {
 1785         struct timeval32 tv32;
 1786         struct timeval delta, olddelta, *deltap;
 1787         int error;
 1788 
 1789         if (uap->delta) {
 1790                 error = copyin(uap->delta, &tv32, sizeof(tv32));
 1791                 if (error)
 1792                         return (error);
 1793                 CP(tv32, delta, tv_sec);
 1794                 CP(tv32, delta, tv_usec);
 1795                 deltap = &delta;
 1796         } else
 1797                 deltap = NULL;
 1798         error = kern_adjtime(td, deltap, &olddelta);
 1799         if (uap->olddelta && error == 0) {
 1800                 CP(olddelta, tv32, tv_sec);
 1801                 CP(olddelta, tv32, tv_usec);
 1802                 error = copyout(&tv32, uap->olddelta, sizeof(tv32));
 1803         }
 1804         return (error);
 1805 }
 1806 
 1807 #ifdef COMPAT_FREEBSD4
 1808 int
 1809 freebsd4_freebsd32_statfs(struct thread *td, struct freebsd4_freebsd32_statfs_args *uap)
 1810 {
 1811         struct statfs32 s32;
 1812         struct statfs *sp;
 1813         int error;
 1814 
 1815         sp = malloc(sizeof(struct statfs), M_STATFS, M_WAITOK);
 1816         error = kern_statfs(td, uap->path, UIO_USERSPACE, sp);
 1817         if (error == 0) {
 1818                 copy_statfs(sp, &s32);
 1819                 error = copyout(&s32, uap->buf, sizeof(s32));
 1820         }
 1821         free(sp, M_STATFS);
 1822         return (error);
 1823 }
 1824 #endif
 1825 
 1826 #ifdef COMPAT_FREEBSD4
 1827 int
 1828 freebsd4_freebsd32_fstatfs(struct thread *td, struct freebsd4_freebsd32_fstatfs_args *uap)
 1829 {
 1830         struct statfs32 s32;
 1831         struct statfs *sp;
 1832         int error;
 1833 
 1834         sp = malloc(sizeof(struct statfs), M_STATFS, M_WAITOK);
 1835         error = kern_fstatfs(td, uap->fd, sp);
 1836         if (error == 0) {
 1837                 copy_statfs(sp, &s32);
 1838                 error = copyout(&s32, uap->buf, sizeof(s32));
 1839         }
 1840         free(sp, M_STATFS);
 1841         return (error);
 1842 }
 1843 #endif
 1844 
 1845 #ifdef COMPAT_FREEBSD4
 1846 int
 1847 freebsd4_freebsd32_fhstatfs(struct thread *td, struct freebsd4_freebsd32_fhstatfs_args *uap)
 1848 {
 1849         struct statfs32 s32;
 1850         struct statfs *sp;
 1851         fhandle_t fh;
 1852         int error;
 1853 
 1854         if ((error = copyin(uap->u_fhp, &fh, sizeof(fhandle_t))) != 0)
 1855                 return (error);
 1856         sp = malloc(sizeof(struct statfs), M_STATFS, M_WAITOK);
 1857         error = kern_fhstatfs(td, fh, sp);
 1858         if (error == 0) {
 1859                 copy_statfs(sp, &s32);
 1860                 error = copyout(&s32, uap->buf, sizeof(s32));
 1861         }
 1862         free(sp, M_STATFS);
 1863         return (error);
 1864 }
 1865 #endif
 1866 
 1867 int
 1868 freebsd32_pread(struct thread *td, struct freebsd32_pread_args *uap)
 1869 {
 1870 
 1871         return (kern_pread(td, uap->fd, uap->buf, uap->nbyte,
 1872             PAIR32TO64(off_t, uap->offset)));
 1873 }
 1874 
 1875 int
 1876 freebsd32_pwrite(struct thread *td, struct freebsd32_pwrite_args *uap)
 1877 {
 1878 
 1879         return (kern_pwrite(td, uap->fd, uap->buf, uap->nbyte,
 1880             PAIR32TO64(off_t, uap->offset)));
 1881 }
 1882 
 1883 #ifdef COMPAT_43
 1884 int
 1885 ofreebsd32_lseek(struct thread *td, struct ofreebsd32_lseek_args *uap)
 1886 {
 1887 
 1888         return (kern_lseek(td, uap->fd, uap->offset, uap->whence));
 1889 }
 1890 #endif
 1891 
 1892 int
 1893 freebsd32_lseek(struct thread *td, struct freebsd32_lseek_args *uap)
 1894 {
 1895         int error;
 1896         off_t pos;
 1897 
 1898         error = kern_lseek(td, uap->fd, PAIR32TO64(off_t, uap->offset),
 1899             uap->whence);
 1900         /* Expand the quad return into two parts for eax and edx */
 1901         pos = td->td_uretoff.tdu_off;
 1902         td->td_retval[RETVAL_LO] = pos & 0xffffffff;    /* %eax */
 1903         td->td_retval[RETVAL_HI] = pos >> 32;           /* %edx */
 1904         return error;
 1905 }
 1906 
 1907 int
 1908 freebsd32_truncate(struct thread *td, struct freebsd32_truncate_args *uap)
 1909 {
 1910 
 1911         return (kern_truncate(td, uap->path, UIO_USERSPACE,
 1912             PAIR32TO64(off_t, uap->length)));
 1913 }
 1914 
 1915 int
 1916 freebsd32_ftruncate(struct thread *td, struct freebsd32_ftruncate_args *uap)
 1917 {
 1918 
 1919         return (kern_ftruncate(td, uap->fd, PAIR32TO64(off_t, uap->length)));
 1920 }
 1921 
 1922 #ifdef COMPAT_43
 1923 int
 1924 ofreebsd32_getdirentries(struct thread *td,
 1925     struct ofreebsd32_getdirentries_args *uap)
 1926 {
 1927         struct ogetdirentries_args ap;
 1928         int error;
 1929         long loff;
 1930         int32_t loff_cut;
 1931 
 1932         ap.fd = uap->fd;
 1933         ap.buf = uap->buf;
 1934         ap.count = uap->count;
 1935         ap.basep = NULL;
 1936         error = kern_ogetdirentries(td, &ap, &loff);
 1937         if (error == 0) {
 1938                 loff_cut = loff;
 1939                 error = copyout(&loff_cut, uap->basep, sizeof(int32_t));
 1940         }
 1941         return (error);
 1942 }
 1943 #endif
 1944 
 1945 #if defined(COMPAT_FREEBSD11)
 1946 int
 1947 freebsd11_freebsd32_getdirentries(struct thread *td,
 1948     struct freebsd11_freebsd32_getdirentries_args *uap)
 1949 {
 1950         long base;
 1951         int32_t base32;
 1952         int error;
 1953 
 1954         error = freebsd11_kern_getdirentries(td, uap->fd, uap->buf, uap->count,
 1955             &base, NULL);
 1956         if (error)
 1957                 return (error);
 1958         if (uap->basep != NULL) {
 1959                 base32 = base;
 1960                 error = copyout(&base32, uap->basep, sizeof(int32_t));
 1961         }
 1962         return (error);
 1963 }
 1964 
 1965 int
 1966 freebsd11_freebsd32_getdents(struct thread *td,
 1967     struct freebsd11_freebsd32_getdents_args *uap)
 1968 {
 1969         struct freebsd11_freebsd32_getdirentries_args ap;
 1970 
 1971         ap.fd = uap->fd;
 1972         ap.buf = uap->buf;
 1973         ap.count = uap->count;
 1974         ap.basep = NULL;
 1975         return (freebsd11_freebsd32_getdirentries(td, &ap));
 1976 }
 1977 #endif /* COMPAT_FREEBSD11 */
 1978 
 1979 #ifdef COMPAT_FREEBSD6
 1980 /* versions with the 'int pad' argument */
 1981 int
 1982 freebsd6_freebsd32_pread(struct thread *td, struct freebsd6_freebsd32_pread_args *uap)
 1983 {
 1984 
 1985         return (kern_pread(td, uap->fd, uap->buf, uap->nbyte,
 1986             PAIR32TO64(off_t, uap->offset)));
 1987 }
 1988 
 1989 int
 1990 freebsd6_freebsd32_pwrite(struct thread *td, struct freebsd6_freebsd32_pwrite_args *uap)
 1991 {
 1992 
 1993         return (kern_pwrite(td, uap->fd, uap->buf, uap->nbyte,
 1994             PAIR32TO64(off_t, uap->offset)));
 1995 }
 1996 
 1997 int
 1998 freebsd6_freebsd32_lseek(struct thread *td, struct freebsd6_freebsd32_lseek_args *uap)
 1999 {
 2000         int error;
 2001         off_t pos;
 2002 
 2003         error = kern_lseek(td, uap->fd, PAIR32TO64(off_t, uap->offset),
 2004             uap->whence);
 2005         /* Expand the quad return into two parts for eax and edx */
 2006         pos = *(off_t *)(td->td_retval);
 2007         td->td_retval[RETVAL_LO] = pos & 0xffffffff;    /* %eax */
 2008         td->td_retval[RETVAL_HI] = pos >> 32;           /* %edx */
 2009         return error;
 2010 }
 2011 
 2012 int
 2013 freebsd6_freebsd32_truncate(struct thread *td, struct freebsd6_freebsd32_truncate_args *uap)
 2014 {
 2015 
 2016         return (kern_truncate(td, uap->path, UIO_USERSPACE,
 2017             PAIR32TO64(off_t, uap->length)));
 2018 }
 2019 
 2020 int
 2021 freebsd6_freebsd32_ftruncate(struct thread *td, struct freebsd6_freebsd32_ftruncate_args *uap)
 2022 {
 2023 
 2024         return (kern_ftruncate(td, uap->fd, PAIR32TO64(off_t, uap->length)));
 2025 }
 2026 #endif /* COMPAT_FREEBSD6 */
 2027 
 2028 struct sf_hdtr32 {
 2029         uint32_t headers;
 2030         int hdr_cnt;
 2031         uint32_t trailers;
 2032         int trl_cnt;
 2033 };
 2034 
 2035 static int
 2036 freebsd32_do_sendfile(struct thread *td,
 2037     struct freebsd32_sendfile_args *uap, int compat)
 2038 {
 2039         struct sf_hdtr32 hdtr32;
 2040         struct sf_hdtr hdtr;
 2041         struct uio *hdr_uio, *trl_uio;
 2042         struct file *fp;
 2043         cap_rights_t rights;
 2044         struct iovec32 *iov32;
 2045         off_t offset, sbytes;
 2046         int error;
 2047 
 2048         offset = PAIR32TO64(off_t, uap->offset);
 2049         if (offset < 0)
 2050                 return (EINVAL);
 2051 
 2052         hdr_uio = trl_uio = NULL;
 2053 
 2054         if (uap->hdtr != NULL) {
 2055                 error = copyin(uap->hdtr, &hdtr32, sizeof(hdtr32));
 2056                 if (error)
 2057                         goto out;
 2058                 PTRIN_CP(hdtr32, hdtr, headers);
 2059                 CP(hdtr32, hdtr, hdr_cnt);
 2060                 PTRIN_CP(hdtr32, hdtr, trailers);
 2061                 CP(hdtr32, hdtr, trl_cnt);
 2062 
 2063                 if (hdtr.headers != NULL) {
 2064                         iov32 = PTRIN(hdtr32.headers);
 2065                         error = freebsd32_copyinuio(iov32,
 2066                             hdtr32.hdr_cnt, &hdr_uio);
 2067                         if (error)
 2068                                 goto out;
 2069 #ifdef COMPAT_FREEBSD4
 2070                         /*
 2071                          * In FreeBSD < 5.0 the nbytes to send also included
 2072                          * the header.  If compat is specified subtract the
 2073                          * header size from nbytes.
 2074                          */
 2075                         if (compat) {
 2076                                 if (uap->nbytes > hdr_uio->uio_resid)
 2077                                         uap->nbytes -= hdr_uio->uio_resid;
 2078                                 else
 2079                                         uap->nbytes = 0;
 2080                         }
 2081 #endif
 2082                 }
 2083                 if (hdtr.trailers != NULL) {
 2084                         iov32 = PTRIN(hdtr32.trailers);
 2085                         error = freebsd32_copyinuio(iov32,
 2086                             hdtr32.trl_cnt, &trl_uio);
 2087                         if (error)
 2088                                 goto out;
 2089                 }
 2090         }
 2091 
 2092         AUDIT_ARG_FD(uap->fd);
 2093 
 2094         if ((error = fget_read(td, uap->fd,
 2095             cap_rights_init_one(&rights, CAP_PREAD), &fp)) != 0)
 2096                 goto out;
 2097 
 2098         error = fo_sendfile(fp, uap->s, hdr_uio, trl_uio, offset,
 2099             uap->nbytes, &sbytes, uap->flags, td);
 2100         fdrop(fp, td);
 2101 
 2102         if (uap->sbytes != NULL)
 2103                 copyout(&sbytes, uap->sbytes, sizeof(off_t));
 2104 
 2105 out:
 2106         if (hdr_uio)
 2107                 free(hdr_uio, M_IOV);
 2108         if (trl_uio)
 2109                 free(trl_uio, M_IOV);
 2110         return (error);
 2111 }
 2112 
 2113 #ifdef COMPAT_FREEBSD4
 2114 int
 2115 freebsd4_freebsd32_sendfile(struct thread *td,
 2116     struct freebsd4_freebsd32_sendfile_args *uap)
 2117 {
 2118         return (freebsd32_do_sendfile(td,
 2119             (struct freebsd32_sendfile_args *)uap, 1));
 2120 }
 2121 #endif
 2122 
 2123 int
 2124 freebsd32_sendfile(struct thread *td, struct freebsd32_sendfile_args *uap)
 2125 {
 2126 
 2127         return (freebsd32_do_sendfile(td, uap, 0));
 2128 }
 2129 
 2130 static void
 2131 copy_stat(struct stat *in, struct stat32 *out)
 2132 {
 2133 
 2134         CP(*in, *out, st_dev);
 2135         CP(*in, *out, st_ino);
 2136         CP(*in, *out, st_mode);
 2137         CP(*in, *out, st_nlink);
 2138         CP(*in, *out, st_uid);
 2139         CP(*in, *out, st_gid);
 2140         CP(*in, *out, st_rdev);
 2141         TS_CP(*in, *out, st_atim);
 2142         TS_CP(*in, *out, st_mtim);
 2143         TS_CP(*in, *out, st_ctim);
 2144         CP(*in, *out, st_size);
 2145         CP(*in, *out, st_blocks);
 2146         CP(*in, *out, st_blksize);
 2147         CP(*in, *out, st_flags);
 2148         CP(*in, *out, st_gen);
 2149         TS_CP(*in, *out, st_birthtim);
 2150         out->st_padding0 = 0;
 2151         out->st_padding1 = 0;
 2152 #ifdef __STAT32_TIME_T_EXT
 2153         out->st_atim_ext = 0;
 2154         out->st_mtim_ext = 0;
 2155         out->st_ctim_ext = 0;
 2156         out->st_btim_ext = 0;
 2157 #endif
 2158         bzero(out->st_spare, sizeof(out->st_spare));
 2159 }
 2160 
 2161 #ifdef COMPAT_43
 2162 static void
 2163 copy_ostat(struct stat *in, struct ostat32 *out)
 2164 {
 2165 
 2166         bzero(out, sizeof(*out));
 2167         CP(*in, *out, st_dev);
 2168         CP(*in, *out, st_ino);
 2169         CP(*in, *out, st_mode);
 2170         CP(*in, *out, st_nlink);
 2171         CP(*in, *out, st_uid);
 2172         CP(*in, *out, st_gid);
 2173         CP(*in, *out, st_rdev);
 2174         out->st_size = MIN(in->st_size, INT32_MAX);
 2175         TS_CP(*in, *out, st_atim);
 2176         TS_CP(*in, *out, st_mtim);
 2177         TS_CP(*in, *out, st_ctim);
 2178         CP(*in, *out, st_blksize);
 2179         CP(*in, *out, st_blocks);
 2180         CP(*in, *out, st_flags);
 2181         CP(*in, *out, st_gen);
 2182 }
 2183 #endif
 2184 
 2185 #ifdef COMPAT_43
 2186 int
 2187 ofreebsd32_stat(struct thread *td, struct ofreebsd32_stat_args *uap)
 2188 {
 2189         struct stat sb;
 2190         struct ostat32 sb32;
 2191         int error;
 2192 
 2193         error = kern_statat(td, 0, AT_FDCWD, uap->path, UIO_USERSPACE,
 2194             &sb, NULL);
 2195         if (error)
 2196                 return (error);
 2197         copy_ostat(&sb, &sb32);
 2198         error = copyout(&sb32, uap->ub, sizeof (sb32));
 2199         return (error);
 2200 }
 2201 #endif
 2202 
 2203 int
 2204 freebsd32_fstat(struct thread *td, struct freebsd32_fstat_args *uap)
 2205 {
 2206         struct stat ub;
 2207         struct stat32 ub32;
 2208         int error;
 2209 
 2210         error = kern_fstat(td, uap->fd, &ub);
 2211         if (error)
 2212                 return (error);
 2213         copy_stat(&ub, &ub32);
 2214         error = copyout(&ub32, uap->ub, sizeof(ub32));
 2215         return (error);
 2216 }
 2217 
 2218 #ifdef COMPAT_43
 2219 int
 2220 ofreebsd32_fstat(struct thread *td, struct ofreebsd32_fstat_args *uap)
 2221 {
 2222         struct stat ub;
 2223         struct ostat32 ub32;
 2224         int error;
 2225 
 2226         error = kern_fstat(td, uap->fd, &ub);
 2227         if (error)
 2228                 return (error);
 2229         copy_ostat(&ub, &ub32);
 2230         error = copyout(&ub32, uap->ub, sizeof(ub32));
 2231         return (error);
 2232 }
 2233 #endif
 2234 
 2235 int
 2236 freebsd32_fstatat(struct thread *td, struct freebsd32_fstatat_args *uap)
 2237 {
 2238         struct stat ub;
 2239         struct stat32 ub32;
 2240         int error;
 2241 
 2242         error = kern_statat(td, uap->flag, uap->fd, uap->path, UIO_USERSPACE,
 2243             &ub, NULL);
 2244         if (error)
 2245                 return (error);
 2246         copy_stat(&ub, &ub32);
 2247         error = copyout(&ub32, uap->buf, sizeof(ub32));
 2248         return (error);
 2249 }
 2250 
 2251 #ifdef COMPAT_43
 2252 int
 2253 ofreebsd32_lstat(struct thread *td, struct ofreebsd32_lstat_args *uap)
 2254 {
 2255         struct stat sb;
 2256         struct ostat32 sb32;
 2257         int error;
 2258 
 2259         error = kern_statat(td, AT_SYMLINK_NOFOLLOW, AT_FDCWD, uap->path,
 2260             UIO_USERSPACE, &sb, NULL);
 2261         if (error)
 2262                 return (error);
 2263         copy_ostat(&sb, &sb32);
 2264         error = copyout(&sb32, uap->ub, sizeof (sb32));
 2265         return (error);
 2266 }
 2267 #endif
 2268 
 2269 int
 2270 freebsd32_fhstat(struct thread *td, struct freebsd32_fhstat_args *uap)
 2271 {
 2272         struct stat sb;
 2273         struct stat32 sb32;
 2274         struct fhandle fh;
 2275         int error;
 2276 
 2277         error = copyin(uap->u_fhp, &fh, sizeof(fhandle_t));
 2278         if (error != 0)
 2279                 return (error);
 2280         error = kern_fhstat(td, fh, &sb);
 2281         if (error != 0)
 2282                 return (error);
 2283         copy_stat(&sb, &sb32);
 2284         error = copyout(&sb32, uap->sb, sizeof (sb32));
 2285         return (error);
 2286 }
 2287 
 2288 #if defined(COMPAT_FREEBSD11)
 2289 extern int ino64_trunc_error;
 2290 
 2291 static int
 2292 freebsd11_cvtstat32(struct stat *in, struct freebsd11_stat32 *out)
 2293 {
 2294 
 2295         CP(*in, *out, st_ino);
 2296         if (in->st_ino != out->st_ino) {
 2297                 switch (ino64_trunc_error) {
 2298                 default:
 2299                 case 0:
 2300                         break;
 2301                 case 1:
 2302                         return (EOVERFLOW);
 2303                 case 2:
 2304                         out->st_ino = UINT32_MAX;
 2305                         break;
 2306                 }
 2307         }
 2308         CP(*in, *out, st_nlink);
 2309         if (in->st_nlink != out->st_nlink) {
 2310                 switch (ino64_trunc_error) {
 2311                 default:
 2312                 case 0:
 2313                         break;
 2314                 case 1:
 2315                         return (EOVERFLOW);
 2316                 case 2:
 2317                         out->st_nlink = UINT16_MAX;
 2318                         break;
 2319                 }
 2320         }
 2321         out->st_dev = in->st_dev;
 2322         if (out->st_dev != in->st_dev) {
 2323                 switch (ino64_trunc_error) {
 2324                 default:
 2325                         break;
 2326                 case 1:
 2327                         return (EOVERFLOW);
 2328                 }
 2329         }
 2330         CP(*in, *out, st_mode);
 2331         CP(*in, *out, st_uid);
 2332         CP(*in, *out, st_gid);
 2333         out->st_rdev = in->st_rdev;
 2334         if (out->st_rdev != in->st_rdev) {
 2335                 switch (ino64_trunc_error) {
 2336                 default:
 2337                         break;
 2338                 case 1:
 2339                         return (EOVERFLOW);
 2340                 }
 2341         }
 2342         TS_CP(*in, *out, st_atim);
 2343         TS_CP(*in, *out, st_mtim);
 2344         TS_CP(*in, *out, st_ctim);
 2345         CP(*in, *out, st_size);
 2346         CP(*in, *out, st_blocks);
 2347         CP(*in, *out, st_blksize);
 2348         CP(*in, *out, st_flags);
 2349         CP(*in, *out, st_gen);
 2350         TS_CP(*in, *out, st_birthtim);
 2351         out->st_lspare = 0;
 2352         bzero((char *)&out->st_birthtim + sizeof(out->st_birthtim),
 2353             sizeof(*out) - offsetof(struct freebsd11_stat32,
 2354             st_birthtim) - sizeof(out->st_birthtim));
 2355         return (0);
 2356 }
 2357 
 2358 int
 2359 freebsd11_freebsd32_stat(struct thread *td,
 2360     struct freebsd11_freebsd32_stat_args *uap)
 2361 {
 2362         struct stat sb;
 2363         struct freebsd11_stat32 sb32;
 2364         int error;
 2365 
 2366         error = kern_statat(td, 0, AT_FDCWD, uap->path, UIO_USERSPACE,
 2367             &sb, NULL);
 2368         if (error != 0)
 2369                 return (error);
 2370         error = freebsd11_cvtstat32(&sb, &sb32);
 2371         if (error == 0)
 2372                 error = copyout(&sb32, uap->ub, sizeof (sb32));
 2373         return (error);
 2374 }
 2375 
 2376 int
 2377 freebsd11_freebsd32_fstat(struct thread *td,
 2378     struct freebsd11_freebsd32_fstat_args *uap)
 2379 {
 2380         struct stat sb;
 2381         struct freebsd11_stat32 sb32;
 2382         int error;
 2383 
 2384         error = kern_fstat(td, uap->fd, &sb);
 2385         if (error != 0)
 2386                 return (error);
 2387         error = freebsd11_cvtstat32(&sb, &sb32);
 2388         if (error == 0)
 2389                 error = copyout(&sb32, uap->ub, sizeof (sb32));
 2390         return (error);
 2391 }
 2392 
 2393 int
 2394 freebsd11_freebsd32_fstatat(struct thread *td,
 2395     struct freebsd11_freebsd32_fstatat_args *uap)
 2396 {
 2397         struct stat sb;
 2398         struct freebsd11_stat32 sb32;
 2399         int error;
 2400 
 2401         error = kern_statat(td, uap->flag, uap->fd, uap->path, UIO_USERSPACE,
 2402             &sb, NULL);
 2403         if (error != 0)
 2404                 return (error);
 2405         error = freebsd11_cvtstat32(&sb, &sb32);
 2406         if (error == 0)
 2407                 error = copyout(&sb32, uap->buf, sizeof (sb32));
 2408         return (error);
 2409 }
 2410 
 2411 int
 2412 freebsd11_freebsd32_lstat(struct thread *td,
 2413     struct freebsd11_freebsd32_lstat_args *uap)
 2414 {
 2415         struct stat sb;
 2416         struct freebsd11_stat32 sb32;
 2417         int error;
 2418 
 2419         error = kern_statat(td, AT_SYMLINK_NOFOLLOW, AT_FDCWD, uap->path,
 2420             UIO_USERSPACE, &sb, NULL);
 2421         if (error != 0)
 2422                 return (error);
 2423         error = freebsd11_cvtstat32(&sb, &sb32);
 2424         if (error == 0)
 2425                 error = copyout(&sb32, uap->ub, sizeof (sb32));
 2426         return (error);
 2427 }
 2428 
 2429 int
 2430 freebsd11_freebsd32_fhstat(struct thread *td,
 2431     struct freebsd11_freebsd32_fhstat_args *uap)
 2432 {
 2433         struct stat sb;
 2434         struct freebsd11_stat32 sb32;
 2435         struct fhandle fh;
 2436         int error;
 2437 
 2438         error = copyin(uap->u_fhp, &fh, sizeof(fhandle_t));
 2439         if (error != 0)
 2440                 return (error);
 2441         error = kern_fhstat(td, fh, &sb);
 2442         if (error != 0)
 2443                 return (error);
 2444         error = freebsd11_cvtstat32(&sb, &sb32);
 2445         if (error == 0)
 2446                 error = copyout(&sb32, uap->sb, sizeof (sb32));
 2447         return (error);
 2448 }
 2449 #endif
 2450 
 2451 int
 2452 freebsd32___sysctl(struct thread *td, struct freebsd32___sysctl_args *uap)
 2453 {
 2454         int error, name[CTL_MAXNAME];
 2455         size_t j, oldlen;
 2456         uint32_t tmp;
 2457 
 2458         if (uap->namelen > CTL_MAXNAME || uap->namelen < 2)
 2459                 return (EINVAL);
 2460         error = copyin(uap->name, name, uap->namelen * sizeof(int));
 2461         if (error)
 2462                 return (error);
 2463         if (uap->oldlenp) {
 2464                 error = fueword32(uap->oldlenp, &tmp);
 2465                 oldlen = tmp;
 2466         } else {
 2467                 oldlen = 0;
 2468         }
 2469         if (error != 0)
 2470                 return (EFAULT);
 2471         error = userland_sysctl(td, name, uap->namelen,
 2472                 uap->old, &oldlen, 1,
 2473                 uap->new, uap->newlen, &j, SCTL_MASK32);
 2474         if (error)
 2475                 return (error);
 2476         if (uap->oldlenp)
 2477                 suword32(uap->oldlenp, j);
 2478         return (0);
 2479 }
 2480 
 2481 int
 2482 freebsd32___sysctlbyname(struct thread *td,
 2483     struct freebsd32___sysctlbyname_args *uap)
 2484 {
 2485         size_t oldlen, rv;
 2486         int error;
 2487         uint32_t tmp;
 2488 
 2489         if (uap->oldlenp != NULL) {
 2490                 error = fueword32(uap->oldlenp, &tmp);
 2491                 oldlen = tmp;
 2492         } else {
 2493                 error = oldlen = 0;
 2494         }
 2495         if (error != 0)
 2496                 return (EFAULT);
 2497         error = kern___sysctlbyname(td, uap->name, uap->namelen, uap->old,
 2498             &oldlen, uap->new, uap->newlen, &rv, SCTL_MASK32, 1);
 2499         if (error != 0)
 2500                 return (error);
 2501         if (uap->oldlenp != NULL)
 2502                 error = suword32(uap->oldlenp, rv);
 2503 
 2504         return (error);
 2505 }
 2506 
 2507 int
 2508 freebsd32_jail(struct thread *td, struct freebsd32_jail_args *uap)
 2509 {
 2510         uint32_t version;
 2511         int error;
 2512         struct jail j;
 2513 
 2514         error = copyin(uap->jail, &version, sizeof(uint32_t));
 2515         if (error)
 2516                 return (error);
 2517 
 2518         switch (version) {
 2519         case 0:
 2520         {
 2521                 /* FreeBSD single IPv4 jails. */
 2522                 struct jail32_v0 j32_v0;
 2523 
 2524                 bzero(&j, sizeof(struct jail));
 2525                 error = copyin(uap->jail, &j32_v0, sizeof(struct jail32_v0));
 2526                 if (error)
 2527                         return (error);
 2528                 CP(j32_v0, j, version);
 2529                 PTRIN_CP(j32_v0, j, path);
 2530                 PTRIN_CP(j32_v0, j, hostname);
 2531                 j.ip4s = htonl(j32_v0.ip_number);       /* jail_v0 is host order */
 2532                 break;
 2533         }
 2534 
 2535         case 1:
 2536                 /*
 2537                  * Version 1 was used by multi-IPv4 jail implementations
 2538                  * that never made it into the official kernel.
 2539                  */
 2540                 return (EINVAL);
 2541 
 2542         case 2: /* JAIL_API_VERSION */
 2543         {
 2544                 /* FreeBSD multi-IPv4/IPv6,noIP jails. */
 2545                 struct jail32 j32;
 2546 
 2547                 error = copyin(uap->jail, &j32, sizeof(struct jail32));
 2548                 if (error)
 2549                         return (error);
 2550                 CP(j32, j, version);
 2551                 PTRIN_CP(j32, j, path);
 2552                 PTRIN_CP(j32, j, hostname);
 2553                 PTRIN_CP(j32, j, jailname);
 2554                 CP(j32, j, ip4s);
 2555                 CP(j32, j, ip6s);
 2556                 PTRIN_CP(j32, j, ip4);
 2557                 PTRIN_CP(j32, j, ip6);
 2558                 break;
 2559         }
 2560 
 2561         default:
 2562                 /* Sci-Fi jails are not supported, sorry. */
 2563                 return (EINVAL);
 2564         }
 2565         return (kern_jail(td, &j));
 2566 }
 2567 
 2568 int
 2569 freebsd32_jail_set(struct thread *td, struct freebsd32_jail_set_args *uap)
 2570 {
 2571         struct uio *auio;
 2572         int error;
 2573 
 2574         /* Check that we have an even number of iovecs. */
 2575         if (uap->iovcnt & 1)
 2576                 return (EINVAL);
 2577 
 2578         error = freebsd32_copyinuio(uap->iovp, uap->iovcnt, &auio);
 2579         if (error)
 2580                 return (error);
 2581         error = kern_jail_set(td, auio, uap->flags);
 2582         free(auio, M_IOV);
 2583         return (error);
 2584 }
 2585 
 2586 int
 2587 freebsd32_jail_get(struct thread *td, struct freebsd32_jail_get_args *uap)
 2588 {
 2589         struct iovec32 iov32;
 2590         struct uio *auio;
 2591         int error, i;
 2592 
 2593         /* Check that we have an even number of iovecs. */
 2594         if (uap->iovcnt & 1)
 2595                 return (EINVAL);
 2596 
 2597         error = freebsd32_copyinuio(uap->iovp, uap->iovcnt, &auio);
 2598         if (error)
 2599                 return (error);
 2600         error = kern_jail_get(td, auio, uap->flags);
 2601         if (error == 0)
 2602                 for (i = 0; i < uap->iovcnt; i++) {
 2603                         PTROUT_CP(auio->uio_iov[i], iov32, iov_base);
 2604                         CP(auio->uio_iov[i], iov32, iov_len);
 2605                         error = copyout(&iov32, uap->iovp + i, sizeof(iov32));
 2606                         if (error != 0)
 2607                                 break;
 2608                 }
 2609         free(auio, M_IOV);
 2610         return (error);
 2611 }
 2612 
 2613 int
 2614 freebsd32_sigaction(struct thread *td, struct freebsd32_sigaction_args *uap)
 2615 {
 2616         struct sigaction32 s32;
 2617         struct sigaction sa, osa, *sap;
 2618         int error;
 2619 
 2620         if (uap->act) {
 2621                 error = copyin(uap->act, &s32, sizeof(s32));
 2622                 if (error)
 2623                         return (error);
 2624                 sa.sa_handler = PTRIN(s32.sa_u);
 2625                 CP(s32, sa, sa_flags);
 2626                 CP(s32, sa, sa_mask);
 2627                 sap = &sa;
 2628         } else
 2629                 sap = NULL;
 2630         error = kern_sigaction(td, uap->sig, sap, &osa, 0);
 2631         if (error == 0 && uap->oact != NULL) {
 2632                 s32.sa_u = PTROUT(osa.sa_handler);
 2633                 CP(osa, s32, sa_flags);
 2634                 CP(osa, s32, sa_mask);
 2635                 error = copyout(&s32, uap->oact, sizeof(s32));
 2636         }
 2637         return (error);
 2638 }
 2639 
 2640 #ifdef COMPAT_FREEBSD4
 2641 int
 2642 freebsd4_freebsd32_sigaction(struct thread *td,
 2643                              struct freebsd4_freebsd32_sigaction_args *uap)
 2644 {
 2645         struct sigaction32 s32;
 2646         struct sigaction sa, osa, *sap;
 2647         int error;
 2648 
 2649         if (uap->act) {
 2650                 error = copyin(uap->act, &s32, sizeof(s32));
 2651                 if (error)
 2652                         return (error);
 2653                 sa.sa_handler = PTRIN(s32.sa_u);
 2654                 CP(s32, sa, sa_flags);
 2655                 CP(s32, sa, sa_mask);
 2656                 sap = &sa;
 2657         } else
 2658                 sap = NULL;
 2659         error = kern_sigaction(td, uap->sig, sap, &osa, KSA_FREEBSD4);
 2660         if (error == 0 && uap->oact != NULL) {
 2661                 s32.sa_u = PTROUT(osa.sa_handler);
 2662                 CP(osa, s32, sa_flags);
 2663                 CP(osa, s32, sa_mask);
 2664                 error = copyout(&s32, uap->oact, sizeof(s32));
 2665         }
 2666         return (error);
 2667 }
 2668 #endif
 2669 
 2670 #ifdef COMPAT_43
 2671 struct osigaction32 {
 2672         u_int32_t       sa_u;
 2673         osigset_t       sa_mask;
 2674         int             sa_flags;
 2675 };
 2676 
 2677 #define ONSIG   32
 2678 
 2679 int
 2680 ofreebsd32_sigaction(struct thread *td,
 2681                              struct ofreebsd32_sigaction_args *uap)
 2682 {
 2683         struct osigaction32 s32;
 2684         struct sigaction sa, osa, *sap;
 2685         int error;
 2686 
 2687         if (uap->signum <= 0 || uap->signum >= ONSIG)
 2688                 return (EINVAL);
 2689 
 2690         if (uap->nsa) {
 2691                 error = copyin(uap->nsa, &s32, sizeof(s32));
 2692                 if (error)
 2693                         return (error);
 2694                 sa.sa_handler = PTRIN(s32.sa_u);
 2695                 CP(s32, sa, sa_flags);
 2696                 OSIG2SIG(s32.sa_mask, sa.sa_mask);
 2697                 sap = &sa;
 2698         } else
 2699                 sap = NULL;
 2700         error = kern_sigaction(td, uap->signum, sap, &osa, KSA_OSIGSET);
 2701         if (error == 0 && uap->osa != NULL) {
 2702                 s32.sa_u = PTROUT(osa.sa_handler);
 2703                 CP(osa, s32, sa_flags);
 2704                 SIG2OSIG(osa.sa_mask, s32.sa_mask);
 2705                 error = copyout(&s32, uap->osa, sizeof(s32));
 2706         }
 2707         return (error);
 2708 }
 2709 
 2710 int
 2711 ofreebsd32_sigprocmask(struct thread *td,
 2712                                struct ofreebsd32_sigprocmask_args *uap)
 2713 {
 2714         sigset_t set, oset;
 2715         int error;
 2716 
 2717         OSIG2SIG(uap->mask, set);
 2718         error = kern_sigprocmask(td, uap->how, &set, &oset, SIGPROCMASK_OLD);
 2719         SIG2OSIG(oset, td->td_retval[0]);
 2720         return (error);
 2721 }
 2722 
 2723 int
 2724 ofreebsd32_sigpending(struct thread *td,
 2725                               struct ofreebsd32_sigpending_args *uap)
 2726 {
 2727         struct proc *p = td->td_proc;
 2728         sigset_t siglist;
 2729 
 2730         PROC_LOCK(p);
 2731         siglist = p->p_siglist;
 2732         SIGSETOR(siglist, td->td_siglist);
 2733         PROC_UNLOCK(p);
 2734         SIG2OSIG(siglist, td->td_retval[0]);
 2735         return (0);
 2736 }
 2737 
 2738 struct sigvec32 {
 2739         u_int32_t       sv_handler;
 2740         int             sv_mask;
 2741         int             sv_flags;
 2742 };
 2743 
 2744 int
 2745 ofreebsd32_sigvec(struct thread *td,
 2746                           struct ofreebsd32_sigvec_args *uap)
 2747 {
 2748         struct sigvec32 vec;
 2749         struct sigaction sa, osa, *sap;
 2750         int error;
 2751 
 2752         if (uap->signum <= 0 || uap->signum >= ONSIG)
 2753                 return (EINVAL);
 2754 
 2755         if (uap->nsv) {
 2756                 error = copyin(uap->nsv, &vec, sizeof(vec));
 2757                 if (error)
 2758                         return (error);
 2759                 sa.sa_handler = PTRIN(vec.sv_handler);
 2760                 OSIG2SIG(vec.sv_mask, sa.sa_mask);
 2761                 sa.sa_flags = vec.sv_flags;
 2762                 sa.sa_flags ^= SA_RESTART;
 2763                 sap = &sa;
 2764         } else
 2765                 sap = NULL;
 2766         error = kern_sigaction(td, uap->signum, sap, &osa, KSA_OSIGSET);
 2767         if (error == 0 && uap->osv != NULL) {
 2768                 vec.sv_handler = PTROUT(osa.sa_handler);
 2769                 SIG2OSIG(osa.sa_mask, vec.sv_mask);
 2770                 vec.sv_flags = osa.sa_flags;
 2771                 vec.sv_flags &= ~SA_NOCLDWAIT;
 2772                 vec.sv_flags ^= SA_RESTART;
 2773                 error = copyout(&vec, uap->osv, sizeof(vec));
 2774         }
 2775         return (error);
 2776 }
 2777 
 2778 int
 2779 ofreebsd32_sigblock(struct thread *td,
 2780                             struct ofreebsd32_sigblock_args *uap)
 2781 {
 2782         sigset_t set, oset;
 2783 
 2784         OSIG2SIG(uap->mask, set);
 2785         kern_sigprocmask(td, SIG_BLOCK, &set, &oset, 0);
 2786         SIG2OSIG(oset, td->td_retval[0]);
 2787         return (0);
 2788 }
 2789 
 2790 int
 2791 ofreebsd32_sigsetmask(struct thread *td,
 2792                               struct ofreebsd32_sigsetmask_args *uap)
 2793 {
 2794         sigset_t set, oset;
 2795 
 2796         OSIG2SIG(uap->mask, set);
 2797         kern_sigprocmask(td, SIG_SETMASK, &set, &oset, 0);
 2798         SIG2OSIG(oset, td->td_retval[0]);
 2799         return (0);
 2800 }
 2801 
 2802 int
 2803 ofreebsd32_sigsuspend(struct thread *td,
 2804                               struct ofreebsd32_sigsuspend_args *uap)
 2805 {
 2806         sigset_t mask;
 2807 
 2808         OSIG2SIG(uap->mask, mask);
 2809         return (kern_sigsuspend(td, mask));
 2810 }
 2811 
 2812 struct sigstack32 {
 2813         u_int32_t       ss_sp;
 2814         int             ss_onstack;
 2815 };
 2816 
 2817 int
 2818 ofreebsd32_sigstack(struct thread *td,
 2819                             struct ofreebsd32_sigstack_args *uap)
 2820 {
 2821         struct sigstack32 s32;
 2822         struct sigstack nss, oss;
 2823         int error = 0, unss;
 2824 
 2825         if (uap->nss != NULL) {
 2826                 error = copyin(uap->nss, &s32, sizeof(s32));
 2827                 if (error)
 2828                         return (error);
 2829                 nss.ss_sp = PTRIN(s32.ss_sp);
 2830                 CP(s32, nss, ss_onstack);
 2831                 unss = 1;
 2832         } else {
 2833                 unss = 0;
 2834         }
 2835         oss.ss_sp = td->td_sigstk.ss_sp;
 2836         oss.ss_onstack = sigonstack(cpu_getstack(td));
 2837         if (unss) {
 2838                 td->td_sigstk.ss_sp = nss.ss_sp;
 2839                 td->td_sigstk.ss_size = 0;
 2840                 td->td_sigstk.ss_flags |= (nss.ss_onstack & SS_ONSTACK);
 2841                 td->td_pflags |= TDP_ALTSTACK;
 2842         }
 2843         if (uap->oss != NULL) {
 2844                 s32.ss_sp = PTROUT(oss.ss_sp);
 2845                 CP(oss, s32, ss_onstack);
 2846                 error = copyout(&s32, uap->oss, sizeof(s32));
 2847         }
 2848         return (error);
 2849 }
 2850 #endif
 2851 
 2852 int
 2853 freebsd32_nanosleep(struct thread *td, struct freebsd32_nanosleep_args *uap)
 2854 {
 2855 
 2856         return (freebsd32_user_clock_nanosleep(td, CLOCK_REALTIME,
 2857             TIMER_RELTIME, uap->rqtp, uap->rmtp));
 2858 }
 2859 
 2860 int
 2861 freebsd32_clock_nanosleep(struct thread *td,
 2862     struct freebsd32_clock_nanosleep_args *uap)
 2863 {
 2864         int error;
 2865 
 2866         error = freebsd32_user_clock_nanosleep(td, uap->clock_id, uap->flags,
 2867             uap->rqtp, uap->rmtp);
 2868         return (kern_posix_error(td, error));
 2869 }
 2870 
 2871 static int
 2872 freebsd32_user_clock_nanosleep(struct thread *td, clockid_t clock_id,
 2873     int flags, const struct timespec32 *ua_rqtp, struct timespec32 *ua_rmtp)
 2874 {
 2875         struct timespec32 rmt32, rqt32;
 2876         struct timespec rmt, rqt;
 2877         int error, error2;
 2878 
 2879         error = copyin(ua_rqtp, &rqt32, sizeof(rqt32));
 2880         if (error)
 2881                 return (error);
 2882 
 2883         CP(rqt32, rqt, tv_sec);
 2884         CP(rqt32, rqt, tv_nsec);
 2885 
 2886         error = kern_clock_nanosleep(td, clock_id, flags, &rqt, &rmt);
 2887         if (error == EINTR && ua_rmtp != NULL && (flags & TIMER_ABSTIME) == 0) {
 2888                 CP(rmt, rmt32, tv_sec);
 2889                 CP(rmt, rmt32, tv_nsec);
 2890 
 2891                 error2 = copyout(&rmt32, ua_rmtp, sizeof(rmt32));
 2892                 if (error2 != 0)
 2893                         error = error2;
 2894         }
 2895         return (error);
 2896 }
 2897 
 2898 int
 2899 freebsd32_clock_gettime(struct thread *td,
 2900                         struct freebsd32_clock_gettime_args *uap)
 2901 {
 2902         struct timespec ats;
 2903         struct timespec32 ats32;
 2904         int error;
 2905 
 2906         error = kern_clock_gettime(td, uap->clock_id, &ats);
 2907         if (error == 0) {
 2908                 CP(ats, ats32, tv_sec);
 2909                 CP(ats, ats32, tv_nsec);
 2910                 error = copyout(&ats32, uap->tp, sizeof(ats32));
 2911         }
 2912         return (error);
 2913 }
 2914 
 2915 int
 2916 freebsd32_clock_settime(struct thread *td,
 2917                         struct freebsd32_clock_settime_args *uap)
 2918 {
 2919         struct timespec ats;
 2920         struct timespec32 ats32;
 2921         int error;
 2922 
 2923         error = copyin(uap->tp, &ats32, sizeof(ats32));
 2924         if (error)
 2925                 return (error);
 2926         CP(ats32, ats, tv_sec);
 2927         CP(ats32, ats, tv_nsec);
 2928 
 2929         return (kern_clock_settime(td, uap->clock_id, &ats));
 2930 }
 2931 
 2932 int
 2933 freebsd32_clock_getres(struct thread *td,
 2934                        struct freebsd32_clock_getres_args *uap)
 2935 {
 2936         struct timespec ts;
 2937         struct timespec32 ts32;
 2938         int error;
 2939 
 2940         if (uap->tp == NULL)
 2941                 return (0);
 2942         error = kern_clock_getres(td, uap->clock_id, &ts);
 2943         if (error == 0) {
 2944                 CP(ts, ts32, tv_sec);
 2945                 CP(ts, ts32, tv_nsec);
 2946                 error = copyout(&ts32, uap->tp, sizeof(ts32));
 2947         }
 2948         return (error);
 2949 }
 2950 
 2951 int freebsd32_ktimer_create(struct thread *td,
 2952     struct freebsd32_ktimer_create_args *uap)
 2953 {
 2954         struct sigevent32 ev32;
 2955         struct sigevent ev, *evp;
 2956         int error, id;
 2957 
 2958         if (uap->evp == NULL) {
 2959                 evp = NULL;
 2960         } else {
 2961                 evp = &ev;
 2962                 error = copyin(uap->evp, &ev32, sizeof(ev32));
 2963                 if (error != 0)
 2964                         return (error);
 2965                 error = convert_sigevent32(&ev32, &ev);
 2966                 if (error != 0)
 2967                         return (error);
 2968         }
 2969         error = kern_ktimer_create(td, uap->clock_id, evp, &id, -1);
 2970         if (error == 0) {
 2971                 error = copyout(&id, uap->timerid, sizeof(int));
 2972                 if (error != 0)
 2973                         kern_ktimer_delete(td, id);
 2974         }
 2975         return (error);
 2976 }
 2977 
 2978 int
 2979 freebsd32_ktimer_settime(struct thread *td,
 2980     struct freebsd32_ktimer_settime_args *uap)
 2981 {
 2982         struct itimerspec32 val32, oval32;
 2983         struct itimerspec val, oval, *ovalp;
 2984         int error;
 2985 
 2986         error = copyin(uap->value, &val32, sizeof(val32));
 2987         if (error != 0)
 2988                 return (error);
 2989         ITS_CP(val32, val);
 2990         ovalp = uap->ovalue != NULL ? &oval : NULL;
 2991         error = kern_ktimer_settime(td, uap->timerid, uap->flags, &val, ovalp);
 2992         if (error == 0 && uap->ovalue != NULL) {
 2993                 ITS_CP(oval, oval32);
 2994                 error = copyout(&oval32, uap->ovalue, sizeof(oval32));
 2995         }
 2996         return (error);
 2997 }
 2998 
 2999 int
 3000 freebsd32_ktimer_gettime(struct thread *td,
 3001     struct freebsd32_ktimer_gettime_args *uap)
 3002 {
 3003         struct itimerspec32 val32;
 3004         struct itimerspec val;
 3005         int error;
 3006 
 3007         error = kern_ktimer_gettime(td, uap->timerid, &val);
 3008         if (error == 0) {
 3009                 ITS_CP(val, val32);
 3010                 error = copyout(&val32, uap->value, sizeof(val32));
 3011         }
 3012         return (error);
 3013 }
 3014 
 3015 int
 3016 freebsd32_clock_getcpuclockid2(struct thread *td,
 3017     struct freebsd32_clock_getcpuclockid2_args *uap)
 3018 {
 3019         clockid_t clk_id;
 3020         int error;
 3021 
 3022         error = kern_clock_getcpuclockid2(td, PAIR32TO64(id_t, uap->id),
 3023             uap->which, &clk_id);
 3024         if (error == 0)
 3025                 error = copyout(&clk_id, uap->clock_id, sizeof(clockid_t));
 3026         return (error);
 3027 }
 3028 
 3029 int
 3030 freebsd32_thr_new(struct thread *td,
 3031                   struct freebsd32_thr_new_args *uap)
 3032 {
 3033         struct thr_param32 param32;
 3034         struct thr_param param;
 3035         int error;
 3036 
 3037         if (uap->param_size < 0 ||
 3038             uap->param_size > sizeof(struct thr_param32))
 3039                 return (EINVAL);
 3040         bzero(&param, sizeof(struct thr_param));
 3041         bzero(&param32, sizeof(struct thr_param32));
 3042         error = copyin(uap->param, &param32, uap->param_size);
 3043         if (error != 0)
 3044                 return (error);
 3045         param.start_func = PTRIN(param32.start_func);
 3046         param.arg = PTRIN(param32.arg);
 3047         param.stack_base = PTRIN(param32.stack_base);
 3048         param.stack_size = param32.stack_size;
 3049         param.tls_base = PTRIN(param32.tls_base);
 3050         param.tls_size = param32.tls_size;
 3051         param.child_tid = PTRIN(param32.child_tid);
 3052         param.parent_tid = PTRIN(param32.parent_tid);
 3053         param.flags = param32.flags;
 3054         param.rtp = PTRIN(param32.rtp);
 3055         param.spare[0] = PTRIN(param32.spare[0]);
 3056         param.spare[1] = PTRIN(param32.spare[1]);
 3057         param.spare[2] = PTRIN(param32.spare[2]);
 3058 
 3059         return (kern_thr_new(td, &param));
 3060 }
 3061 
 3062 int
 3063 freebsd32_thr_suspend(struct thread *td, struct freebsd32_thr_suspend_args *uap)
 3064 {
 3065         struct timespec32 ts32;
 3066         struct timespec ts, *tsp;
 3067         int error;
 3068 
 3069         error = 0;
 3070         tsp = NULL;
 3071         if (uap->timeout != NULL) {
 3072                 error = copyin((const void *)uap->timeout, (void *)&ts32,
 3073                     sizeof(struct timespec32));
 3074                 if (error != 0)
 3075                         return (error);
 3076                 ts.tv_sec = ts32.tv_sec;
 3077                 ts.tv_nsec = ts32.tv_nsec;
 3078                 tsp = &ts;
 3079         }
 3080         return (kern_thr_suspend(td, tsp));
 3081 }
 3082 
 3083 void
 3084 siginfo_to_siginfo32(const siginfo_t *src, struct siginfo32 *dst)
 3085 {
 3086         bzero(dst, sizeof(*dst));
 3087         dst->si_signo = src->si_signo;
 3088         dst->si_errno = src->si_errno;
 3089         dst->si_code = src->si_code;
 3090         dst->si_pid = src->si_pid;
 3091         dst->si_uid = src->si_uid;
 3092         dst->si_status = src->si_status;
 3093         dst->si_addr = (uintptr_t)src->si_addr;
 3094         dst->si_value.sival_int = src->si_value.sival_int;
 3095         dst->si_timerid = src->si_timerid;
 3096         dst->si_overrun = src->si_overrun;
 3097 }
 3098 
 3099 #ifndef _FREEBSD32_SYSPROTO_H_
 3100 struct freebsd32_sigqueue_args {
 3101         pid_t pid;
 3102         int signum;
 3103         /* union sigval32 */ int value;
 3104 };
 3105 #endif
 3106 int
 3107 freebsd32_sigqueue(struct thread *td, struct freebsd32_sigqueue_args *uap)
 3108 {
 3109         union sigval sv;
 3110 
 3111         /*
 3112          * On 32-bit ABIs, sival_int and sival_ptr are the same.
 3113          * On 64-bit little-endian ABIs, the low bits are the same.
 3114          * In 64-bit big-endian ABIs, sival_int overlaps with
 3115          * sival_ptr's HIGH bits.  We choose to support sival_int
 3116          * rather than sival_ptr in this case as it seems to be
 3117          * more common.
 3118          */
 3119         bzero(&sv, sizeof(sv));
 3120         sv.sival_int = uap->value;
 3121 
 3122         return (kern_sigqueue(td, uap->pid, uap->signum, &sv));
 3123 }
 3124 
 3125 int
 3126 freebsd32_sigtimedwait(struct thread *td, struct freebsd32_sigtimedwait_args *uap)
 3127 {
 3128         struct timespec32 ts32;
 3129         struct timespec ts;
 3130         struct timespec *timeout;
 3131         sigset_t set;
 3132         ksiginfo_t ksi;
 3133         struct siginfo32 si32;
 3134         int error;
 3135 
 3136         if (uap->timeout) {
 3137                 error = copyin(uap->timeout, &ts32, sizeof(ts32));
 3138                 if (error)
 3139                         return (error);
 3140                 ts.tv_sec = ts32.tv_sec;
 3141                 ts.tv_nsec = ts32.tv_nsec;
 3142                 timeout = &ts;
 3143         } else
 3144                 timeout = NULL;
 3145 
 3146         error = copyin(uap->set, &set, sizeof(set));
 3147         if (error)
 3148                 return (error);
 3149 
 3150         error = kern_sigtimedwait(td, set, &ksi, timeout);
 3151         if (error)
 3152                 return (error);
 3153 
 3154         if (uap->info) {
 3155                 siginfo_to_siginfo32(&ksi.ksi_info, &si32);
 3156                 error = copyout(&si32, uap->info, sizeof(struct siginfo32));
 3157         }
 3158 
 3159         if (error == 0)
 3160                 td->td_retval[0] = ksi.ksi_signo;
 3161         return (error);
 3162 }
 3163 
 3164 /*
 3165  * MPSAFE
 3166  */
 3167 int
 3168 freebsd32_sigwaitinfo(struct thread *td, struct freebsd32_sigwaitinfo_args *uap)
 3169 {
 3170         ksiginfo_t ksi;
 3171         struct siginfo32 si32;
 3172         sigset_t set;
 3173         int error;
 3174 
 3175         error = copyin(uap->set, &set, sizeof(set));
 3176         if (error)
 3177                 return (error);
 3178 
 3179         error = kern_sigtimedwait(td, set, &ksi, NULL);
 3180         if (error)
 3181                 return (error);
 3182 
 3183         if (uap->info) {
 3184                 siginfo_to_siginfo32(&ksi.ksi_info, &si32);
 3185                 error = copyout(&si32, uap->info, sizeof(struct siginfo32));
 3186         }       
 3187         if (error == 0)
 3188                 td->td_retval[0] = ksi.ksi_signo;
 3189         return (error);
 3190 }
 3191 
 3192 int
 3193 freebsd32_cpuset_setid(struct thread *td,
 3194     struct freebsd32_cpuset_setid_args *uap)
 3195 {
 3196 
 3197         return (kern_cpuset_setid(td, uap->which,
 3198             PAIR32TO64(id_t, uap->id), uap->setid));
 3199 }
 3200 
 3201 int
 3202 freebsd32_cpuset_getid(struct thread *td,
 3203     struct freebsd32_cpuset_getid_args *uap)
 3204 {
 3205 
 3206         return (kern_cpuset_getid(td, uap->level, uap->which,
 3207             PAIR32TO64(id_t, uap->id), uap->setid));
 3208 }
 3209 
 3210 int
 3211 freebsd32_cpuset_getaffinity(struct thread *td,
 3212     struct freebsd32_cpuset_getaffinity_args *uap)
 3213 {
 3214 
 3215         return (kern_cpuset_getaffinity(td, uap->level, uap->which,
 3216             PAIR32TO64(id_t,uap->id), uap->cpusetsize, uap->mask));
 3217 }
 3218 
 3219 int
 3220 freebsd32_cpuset_setaffinity(struct thread *td,
 3221     struct freebsd32_cpuset_setaffinity_args *uap)
 3222 {
 3223 
 3224         return (kern_cpuset_setaffinity(td, uap->level, uap->which,
 3225             PAIR32TO64(id_t,uap->id), uap->cpusetsize, uap->mask));
 3226 }
 3227 
 3228 int
 3229 freebsd32_cpuset_getdomain(struct thread *td,
 3230     struct freebsd32_cpuset_getdomain_args *uap)
 3231 {
 3232 
 3233         return (kern_cpuset_getdomain(td, uap->level, uap->which,
 3234             PAIR32TO64(id_t,uap->id), uap->domainsetsize, uap->mask, uap->policy));
 3235 }
 3236 
 3237 int
 3238 freebsd32_cpuset_setdomain(struct thread *td,
 3239     struct freebsd32_cpuset_setdomain_args *uap)
 3240 {
 3241 
 3242         return (kern_cpuset_setdomain(td, uap->level, uap->which,
 3243             PAIR32TO64(id_t,uap->id), uap->domainsetsize, uap->mask, uap->policy));
 3244 }
 3245 
 3246 int
 3247 freebsd32_nmount(struct thread *td,
 3248     struct freebsd32_nmount_args /* {
 3249         struct iovec *iovp;
 3250         unsigned int iovcnt;
 3251         int flags;
 3252     } */ *uap)
 3253 {
 3254         struct uio *auio;
 3255         uint64_t flags;
 3256         int error;
 3257 
 3258         /*
 3259          * Mount flags are now 64-bits. On 32-bit archtectures only
 3260          * 32-bits are passed in, but from here on everything handles
 3261          * 64-bit flags correctly.
 3262          */
 3263         flags = uap->flags;
 3264 
 3265         AUDIT_ARG_FFLAGS(flags);
 3266 
 3267         /*
 3268          * Filter out MNT_ROOTFS.  We do not want clients of nmount() in
 3269          * userspace to set this flag, but we must filter it out if we want
 3270          * MNT_UPDATE on the root file system to work.
 3271          * MNT_ROOTFS should only be set by the kernel when mounting its
 3272          * root file system.
 3273          */
 3274         flags &= ~MNT_ROOTFS;
 3275 
 3276         /*
 3277          * check that we have an even number of iovec's
 3278          * and that we have at least two options.
 3279          */
 3280         if ((uap->iovcnt & 1) || (uap->iovcnt < 4))
 3281                 return (EINVAL);
 3282 
 3283         error = freebsd32_copyinuio(uap->iovp, uap->iovcnt, &auio);
 3284         if (error)
 3285                 return (error);
 3286         error = vfs_donmount(td, flags, auio);
 3287 
 3288         free(auio, M_IOV);
 3289         return error;
 3290 }
 3291 
 3292 #if 0
 3293 int
 3294 freebsd32_xxx(struct thread *td, struct freebsd32_xxx_args *uap)
 3295 {
 3296         struct yyy32 *p32, s32;
 3297         struct yyy *p = NULL, s;
 3298         struct xxx_arg ap;
 3299         int error;
 3300 
 3301         if (uap->zzz) {
 3302                 error = copyin(uap->zzz, &s32, sizeof(s32));
 3303                 if (error)
 3304                         return (error);
 3305                 /* translate in */
 3306                 p = &s;
 3307         }
 3308         error = kern_xxx(td, p);
 3309         if (error)
 3310                 return (error);
 3311         if (uap->zzz) {
 3312                 /* translate out */
 3313                 error = copyout(&s32, p32, sizeof(s32));
 3314         }
 3315         return (error);
 3316 }
 3317 #endif
 3318 
 3319 int
 3320 syscall32_module_handler(struct module *mod, int what, void *arg)
 3321 {
 3322 
 3323         return (kern_syscall_module_handler(freebsd32_sysent, mod, what, arg));
 3324 }
 3325 
 3326 int
 3327 syscall32_helper_register(struct syscall_helper_data *sd, int flags)
 3328 {
 3329 
 3330         return (kern_syscall_helper_register(freebsd32_sysent, sd, flags));
 3331 }
 3332 
 3333 int
 3334 syscall32_helper_unregister(struct syscall_helper_data *sd)
 3335 {
 3336 
 3337         return (kern_syscall_helper_unregister(freebsd32_sysent, sd));
 3338 }
 3339 
 3340 int
 3341 freebsd32_copyout_strings(struct image_params *imgp, uintptr_t *stack_base)
 3342 {
 3343         int argc, envc, i;
 3344         u_int32_t *vectp;
 3345         char *stringp;
 3346         uintptr_t destp, ustringp;
 3347         struct freebsd32_ps_strings *arginfo;
 3348         char canary[sizeof(long) * 8];
 3349         int32_t pagesizes32[MAXPAGESIZES];
 3350         size_t execpath_len;
 3351         int error, szsigcode;
 3352 
 3353         /*
 3354          * Calculate string base and vector table pointers.
 3355          * Also deal with signal trampoline code for this exec type.
 3356          */
 3357         if (imgp->execpath != NULL && imgp->auxargs != NULL)
 3358                 execpath_len = strlen(imgp->execpath) + 1;
 3359         else
 3360                 execpath_len = 0;
 3361         arginfo = (struct freebsd32_ps_strings *)curproc->p_sysent->
 3362             sv_psstrings;
 3363         imgp->ps_strings = arginfo;
 3364         if (imgp->proc->p_sysent->sv_sigcode_base == 0)
 3365                 szsigcode = *(imgp->proc->p_sysent->sv_szsigcode);
 3366         else
 3367                 szsigcode = 0;
 3368         destp = (uintptr_t)arginfo;
 3369 
 3370         /*
 3371          * install sigcode
 3372          */
 3373         if (szsigcode != 0) {
 3374                 destp -= szsigcode;
 3375                 destp = rounddown2(destp, sizeof(uint32_t));
 3376                 error = copyout(imgp->proc->p_sysent->sv_sigcode, (void *)destp,
 3377                     szsigcode);
 3378                 if (error != 0)
 3379                         return (error);
 3380         }
 3381 
 3382         /*
 3383          * Copy the image path for the rtld.
 3384          */
 3385         if (execpath_len != 0) {
 3386                 destp -= execpath_len;
 3387                 imgp->execpathp = (void *)destp;
 3388                 error = copyout(imgp->execpath, imgp->execpathp, execpath_len);
 3389                 if (error != 0)
 3390                         return (error);
 3391         }
 3392 
 3393         /*
 3394          * Prepare the canary for SSP.
 3395          */
 3396         arc4rand(canary, sizeof(canary), 0);
 3397         destp -= sizeof(canary);
 3398         imgp->canary = (void *)destp;
 3399         error = copyout(canary, imgp->canary, sizeof(canary));
 3400         if (error != 0)
 3401                 return (error);
 3402         imgp->canarylen = sizeof(canary);
 3403 
 3404         /*
 3405          * Prepare the pagesizes array.
 3406          */
 3407         for (i = 0; i < MAXPAGESIZES; i++)
 3408                 pagesizes32[i] = (uint32_t)pagesizes[i];
 3409         destp -= sizeof(pagesizes32);
 3410         destp = rounddown2(destp, sizeof(uint32_t));
 3411         imgp->pagesizes = (void *)destp;
 3412         error = copyout(pagesizes32, imgp->pagesizes, sizeof(pagesizes32));
 3413         if (error != 0)
 3414                 return (error);
 3415         imgp->pagesizeslen = sizeof(pagesizes32);
 3416 
 3417         /*
 3418          * Allocate room for the argument and environment strings.
 3419          */
 3420         destp -= ARG_MAX - imgp->args->stringspace;
 3421         destp = rounddown2(destp, sizeof(uint32_t));
 3422         ustringp = destp;
 3423 
 3424         exec_stackgap(imgp, &destp);
 3425 
 3426         if (imgp->auxargs) {
 3427                 /*
 3428                  * Allocate room on the stack for the ELF auxargs
 3429                  * array.  It has up to AT_COUNT entries.
 3430                  */
 3431                 destp -= AT_COUNT * sizeof(Elf32_Auxinfo);
 3432                 destp = rounddown2(destp, sizeof(uint32_t));
 3433         }
 3434 
 3435         vectp = (uint32_t *)destp;
 3436 
 3437         /*
 3438          * Allocate room for the argv[] and env vectors including the
 3439          * terminating NULL pointers.
 3440          */
 3441         vectp -= imgp->args->argc + 1 + imgp->args->envc + 1;
 3442 
 3443         /*
 3444          * vectp also becomes our initial stack base
 3445          */
 3446         *stack_base = (uintptr_t)vectp;
 3447 
 3448         stringp = imgp->args->begin_argv;
 3449         argc = imgp->args->argc;
 3450         envc = imgp->args->envc;
 3451         /*
 3452          * Copy out strings - arguments and environment.
 3453          */
 3454         error = copyout(stringp, (void *)ustringp,
 3455             ARG_MAX - imgp->args->stringspace);
 3456         if (error != 0)
 3457                 return (error);
 3458 
 3459         /*
 3460          * Fill in "ps_strings" struct for ps, w, etc.
 3461          */
 3462         imgp->argv = vectp;
 3463         if (suword32(&arginfo->ps_argvstr, (u_int32_t)(intptr_t)vectp) != 0 ||
 3464             suword32(&arginfo->ps_nargvstr, argc) != 0)
 3465                 return (EFAULT);
 3466 
 3467         /*
 3468          * Fill in argument portion of vector table.
 3469          */
 3470         for (; argc > 0; --argc) {
 3471                 if (suword32(vectp++, ustringp) != 0)
 3472                         return (EFAULT);
 3473                 while (*stringp++ != 0)
 3474                         ustringp++;
 3475                 ustringp++;
 3476         }
 3477 
 3478         /* a null vector table pointer separates the argp's from the envp's */
 3479         if (suword32(vectp++, 0) != 0)
 3480                 return (EFAULT);
 3481 
 3482         imgp->envv = vectp;
 3483         if (suword32(&arginfo->ps_envstr, (u_int32_t)(intptr_t)vectp) != 0 ||
 3484             suword32(&arginfo->ps_nenvstr, envc) != 0)
 3485                 return (EFAULT);
 3486 
 3487         /*
 3488          * Fill in environment portion of vector table.
 3489          */
 3490         for (; envc > 0; --envc) {
 3491                 if (suword32(vectp++, ustringp) != 0)
 3492                         return (EFAULT);
 3493                 while (*stringp++ != 0)
 3494                         ustringp++;
 3495                 ustringp++;
 3496         }
 3497 
 3498         /* end of vector table is a null pointer */
 3499         if (suword32(vectp, 0) != 0)
 3500                 return (EFAULT);
 3501 
 3502         if (imgp->auxargs) {
 3503                 vectp++;
 3504                 error = imgp->sysent->sv_copyout_auxargs(imgp,
 3505                     (uintptr_t)vectp);
 3506                 if (error != 0)
 3507                         return (error);
 3508         }
 3509 
 3510         return (0);
 3511 }
 3512 
 3513 int
 3514 freebsd32_kldstat(struct thread *td, struct freebsd32_kldstat_args *uap)
 3515 {
 3516         struct kld_file_stat *stat;
 3517         struct kld32_file_stat *stat32;
 3518         int error, version;
 3519 
 3520         if ((error = copyin(&uap->stat->version, &version, sizeof(version)))
 3521             != 0)
 3522                 return (error);
 3523         if (version != sizeof(struct kld32_file_stat_1) &&
 3524             version != sizeof(struct kld32_file_stat))
 3525                 return (EINVAL);
 3526 
 3527         stat = malloc(sizeof(*stat), M_TEMP, M_WAITOK | M_ZERO);
 3528         stat32 = malloc(sizeof(*stat32), M_TEMP, M_WAITOK | M_ZERO);
 3529         error = kern_kldstat(td, uap->fileid, stat);
 3530         if (error == 0) {
 3531                 bcopy(&stat->name[0], &stat32->name[0], sizeof(stat->name));
 3532                 CP(*stat, *stat32, refs);
 3533                 CP(*stat, *stat32, id);
 3534                 PTROUT_CP(*stat, *stat32, address);
 3535                 CP(*stat, *stat32, size);
 3536                 bcopy(&stat->pathname[0], &stat32->pathname[0],
 3537                     sizeof(stat->pathname));
 3538                 stat32->version  = version;
 3539                 error = copyout(stat32, uap->stat, version);
 3540         }
 3541         free(stat, M_TEMP);
 3542         free(stat32, M_TEMP);
 3543         return (error);
 3544 }
 3545 
 3546 int
 3547 freebsd32_posix_fallocate(struct thread *td,
 3548     struct freebsd32_posix_fallocate_args *uap)
 3549 {
 3550         int error;
 3551 
 3552         error = kern_posix_fallocate(td, uap->fd,
 3553             PAIR32TO64(off_t, uap->offset), PAIR32TO64(off_t, uap->len));
 3554         return (kern_posix_error(td, error));
 3555 }
 3556 
 3557 int
 3558 freebsd32_posix_fadvise(struct thread *td,
 3559     struct freebsd32_posix_fadvise_args *uap)
 3560 {
 3561         int error;
 3562 
 3563         error = kern_posix_fadvise(td, uap->fd, PAIR32TO64(off_t, uap->offset),
 3564             PAIR32TO64(off_t, uap->len), uap->advice);
 3565         return (kern_posix_error(td, error));
 3566 }
 3567 
 3568 int
 3569 convert_sigevent32(struct sigevent32 *sig32, struct sigevent *sig)
 3570 {
 3571 
 3572         CP(*sig32, *sig, sigev_notify);
 3573         switch (sig->sigev_notify) {
 3574         case SIGEV_NONE:
 3575                 break;
 3576         case SIGEV_THREAD_ID:
 3577                 CP(*sig32, *sig, sigev_notify_thread_id);
 3578                 /* FALLTHROUGH */
 3579         case SIGEV_SIGNAL:
 3580                 CP(*sig32, *sig, sigev_signo);
 3581                 PTRIN_CP(*sig32, *sig, sigev_value.sival_ptr);
 3582                 break;
 3583         case SIGEV_KEVENT:
 3584                 CP(*sig32, *sig, sigev_notify_kqueue);
 3585                 CP(*sig32, *sig, sigev_notify_kevent_flags);
 3586                 PTRIN_CP(*sig32, *sig, sigev_value.sival_ptr);
 3587                 break;
 3588         default:
 3589                 return (EINVAL);
 3590         }
 3591         return (0);
 3592 }
 3593 
 3594 int
 3595 freebsd32_procctl(struct thread *td, struct freebsd32_procctl_args *uap)
 3596 {
 3597         void *data;
 3598         union {
 3599                 struct procctl_reaper_status rs;
 3600                 struct procctl_reaper_pids rp;
 3601                 struct procctl_reaper_kill rk;
 3602         } x;
 3603         union {
 3604                 struct procctl_reaper_pids32 rp;
 3605         } x32;
 3606         int error, error1, flags, signum;
 3607 
 3608         if (uap->com >= PROC_PROCCTL_MD_MIN)
 3609                 return (cpu_procctl(td, uap->idtype, PAIR32TO64(id_t, uap->id),
 3610                     uap->com, PTRIN(uap->data)));
 3611 
 3612         switch (uap->com) {
 3613         case PROC_ASLR_CTL:
 3614         case PROC_PROTMAX_CTL:
 3615         case PROC_SPROTECT:
 3616         case PROC_STACKGAP_CTL:
 3617         case PROC_TRACE_CTL:
 3618         case PROC_TRAPCAP_CTL:
 3619         case PROC_NO_NEW_PRIVS_CTL:
 3620         case PROC_WXMAP_CTL:
 3621                 error = copyin(PTRIN(uap->data), &flags, sizeof(flags));
 3622                 if (error != 0)
 3623                         return (error);
 3624                 data = &flags;
 3625                 break;
 3626         case PROC_REAP_ACQUIRE:
 3627         case PROC_REAP_RELEASE:
 3628                 if (uap->data != NULL)
 3629                         return (EINVAL);
 3630                 data = NULL;
 3631                 break;
 3632         case PROC_REAP_STATUS:
 3633                 data = &x.rs;
 3634                 break;
 3635         case PROC_REAP_GETPIDS:
 3636                 error = copyin(uap->data, &x32.rp, sizeof(x32.rp));
 3637                 if (error != 0)
 3638                         return (error);
 3639                 CP(x32.rp, x.rp, rp_count);
 3640                 PTRIN_CP(x32.rp, x.rp, rp_pids);
 3641                 data = &x.rp;
 3642                 break;
 3643         case PROC_REAP_KILL:
 3644                 error = copyin(uap->data, &x.rk, sizeof(x.rk));
 3645                 if (error != 0)
 3646                         return (error);
 3647                 data = &x.rk;
 3648                 break;
 3649         case PROC_ASLR_STATUS:
 3650         case PROC_PROTMAX_STATUS:
 3651         case PROC_STACKGAP_STATUS:
 3652         case PROC_TRACE_STATUS:
 3653         case PROC_TRAPCAP_STATUS:
 3654         case PROC_NO_NEW_PRIVS_STATUS:
 3655         case PROC_WXMAP_STATUS:
 3656                 data = &flags;
 3657                 break;
 3658         case PROC_PDEATHSIG_CTL:
 3659                 error = copyin(uap->data, &signum, sizeof(signum));
 3660                 if (error != 0)
 3661                         return (error);
 3662                 data = &signum;
 3663                 break;
 3664         case PROC_PDEATHSIG_STATUS:
 3665                 data = &signum;
 3666                 break;
 3667         default:
 3668                 return (EINVAL);
 3669         }
 3670         error = kern_procctl(td, uap->idtype, PAIR32TO64(id_t, uap->id),
 3671             uap->com, data);
 3672         switch (uap->com) {
 3673         case PROC_REAP_STATUS:
 3674                 if (error == 0)
 3675                         error = copyout(&x.rs, uap->data, sizeof(x.rs));
 3676                 break;
 3677         case PROC_REAP_KILL:
 3678                 error1 = copyout(&x.rk, uap->data, sizeof(x.rk));
 3679                 if (error == 0)
 3680                         error = error1;
 3681                 break;
 3682         case PROC_ASLR_STATUS:
 3683         case PROC_PROTMAX_STATUS:
 3684         case PROC_STACKGAP_STATUS:
 3685         case PROC_TRACE_STATUS:
 3686         case PROC_TRAPCAP_STATUS:
 3687         case PROC_NO_NEW_PRIVS_STATUS:
 3688         case PROC_WXMAP_STATUS:
 3689                 if (error == 0)
 3690                         error = copyout(&flags, uap->data, sizeof(flags));
 3691                 break;
 3692         case PROC_PDEATHSIG_STATUS:
 3693                 if (error == 0)
 3694                         error = copyout(&signum, uap->data, sizeof(signum));
 3695                 break;
 3696         }
 3697         return (error);
 3698 }
 3699 
 3700 int
 3701 freebsd32_fcntl(struct thread *td, struct freebsd32_fcntl_args *uap)
 3702 {
 3703         long tmp;
 3704 
 3705         switch (uap->cmd) {
 3706         /*
 3707          * Do unsigned conversion for arg when operation
 3708          * interprets it as flags or pointer.
 3709          */
 3710         case F_SETLK_REMOTE:
 3711         case F_SETLKW:
 3712         case F_SETLK:
 3713         case F_GETLK:
 3714         case F_SETFD:
 3715         case F_SETFL:
 3716         case F_OGETLK:
 3717         case F_OSETLK:
 3718         case F_OSETLKW:
 3719         case F_KINFO:
 3720                 tmp = (unsigned int)(uap->arg);
 3721                 break;
 3722         default:
 3723                 tmp = uap->arg;
 3724                 break;
 3725         }
 3726         return (kern_fcntl_freebsd(td, uap->fd, uap->cmd, tmp));
 3727 }
 3728 
 3729 int
 3730 freebsd32_ppoll(struct thread *td, struct freebsd32_ppoll_args *uap)
 3731 {
 3732         struct timespec32 ts32;
 3733         struct timespec ts, *tsp;
 3734         sigset_t set, *ssp;
 3735         int error;
 3736 
 3737         if (uap->ts != NULL) {
 3738                 error = copyin(uap->ts, &ts32, sizeof(ts32));
 3739                 if (error != 0)
 3740                         return (error);
 3741                 CP(ts32, ts, tv_sec);
 3742                 CP(ts32, ts, tv_nsec);
 3743                 tsp = &ts;
 3744         } else
 3745                 tsp = NULL;
 3746         if (uap->set != NULL) {
 3747                 error = copyin(uap->set, &set, sizeof(set));
 3748                 if (error != 0)
 3749                         return (error);
 3750                 ssp = &set;
 3751         } else
 3752                 ssp = NULL;
 3753 
 3754         return (kern_poll(td, uap->fds, uap->nfds, tsp, ssp));
 3755 }
 3756 
 3757 int
 3758 freebsd32_sched_rr_get_interval(struct thread *td,
 3759     struct freebsd32_sched_rr_get_interval_args *uap)
 3760 {
 3761         struct timespec ts;
 3762         struct timespec32 ts32;
 3763         int error;
 3764 
 3765         error = kern_sched_rr_get_interval(td, uap->pid, &ts);
 3766         if (error == 0) {
 3767                 CP(ts, ts32, tv_sec);
 3768                 CP(ts, ts32, tv_nsec);
 3769                 error = copyout(&ts32, uap->interval, sizeof(ts32));
 3770         }
 3771         return (error);
 3772 }
 3773 
 3774 static void
 3775 timex_to_32(struct timex32 *dst, struct timex *src)
 3776 {
 3777         CP(*src, *dst, modes);
 3778         CP(*src, *dst, offset);
 3779         CP(*src, *dst, freq);
 3780         CP(*src, *dst, maxerror);
 3781         CP(*src, *dst, esterror);
 3782         CP(*src, *dst, status);
 3783         CP(*src, *dst, constant);
 3784         CP(*src, *dst, precision);
 3785         CP(*src, *dst, tolerance);
 3786         CP(*src, *dst, ppsfreq);
 3787         CP(*src, *dst, jitter);
 3788         CP(*src, *dst, shift);
 3789         CP(*src, *dst, stabil);
 3790         CP(*src, *dst, jitcnt);
 3791         CP(*src, *dst, calcnt);
 3792         CP(*src, *dst, errcnt);
 3793         CP(*src, *dst, stbcnt);
 3794 }
 3795 
 3796 static void
 3797 timex_from_32(struct timex *dst, struct timex32 *src)
 3798 {
 3799         CP(*src, *dst, modes);
 3800         CP(*src, *dst, offset);
 3801         CP(*src, *dst, freq);
 3802         CP(*src, *dst, maxerror);
 3803         CP(*src, *dst, esterror);
 3804         CP(*src, *dst, status);
 3805         CP(*src, *dst, constant);
 3806         CP(*src, *dst, precision);
 3807         CP(*src, *dst, tolerance);
 3808         CP(*src, *dst, ppsfreq);
 3809         CP(*src, *dst, jitter);
 3810         CP(*src, *dst, shift);
 3811         CP(*src, *dst, stabil);
 3812         CP(*src, *dst, jitcnt);
 3813         CP(*src, *dst, calcnt);
 3814         CP(*src, *dst, errcnt);
 3815         CP(*src, *dst, stbcnt);
 3816 }
 3817 
 3818 int
 3819 freebsd32_ntp_adjtime(struct thread *td, struct freebsd32_ntp_adjtime_args *uap)
 3820 {
 3821         struct timex tx;
 3822         struct timex32 tx32;
 3823         int error, retval;
 3824 
 3825         error = copyin(uap->tp, &tx32, sizeof(tx32));
 3826         if (error == 0) {
 3827                 timex_from_32(&tx, &tx32);
 3828                 error = kern_ntp_adjtime(td, &tx, &retval);
 3829                 if (error == 0) {
 3830                         timex_to_32(&tx32, &tx);
 3831                         error = copyout(&tx32, uap->tp, sizeof(tx32));
 3832                         if (error == 0)
 3833                                 td->td_retval[0] = retval;
 3834                 }
 3835         }
 3836         return (error);
 3837 }
Cache object: 1da1c4fbfe68edffa19e995b0d7b094c
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/compat/freebsd32/freebsd32_misc.c

FreeBSD/Linux Kernel Cross Reference
sys/compat/freebsd32/freebsd32_misc.c
