sys/compat/freebsd32/freebsd32_misc.c

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