sys/compat/freebsd32/freebsd32_misc.c

   1 /*-
   2  * Copyright (c) 2002 Doug Rabson
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  */
  26
  27 #include <sys/cdefs.h>
  28 __FBSDID("$FreeBSD$");
  29
  30 #include "opt_compat.h"
  31 #include "opt_inet.h"
  32 #include "opt_inet6.h"
  33
  34 #include <sys/param.h>
  35 #include <sys/bus.h>
  36 #include <sys/clock.h>
  37 #include <sys/exec.h>
  38 #include <sys/fcntl.h>
  39 #include <sys/filedesc.h>
  40 #include <sys/imgact.h>
  41 #include <sys/jail.h>
  42 #include <sys/kernel.h>
  43 #include <sys/limits.h>
  44 #include <sys/lock.h>
  45 #include <sys/malloc.h>
  46 #include <sys/file.h>           /* Must come after sys/malloc.h */
  47 #include <sys/mbuf.h>
  48 #include <sys/mman.h>
  49 #include <sys/module.h>
  50 #include <sys/mount.h>
  51 #include <sys/mutex.h>
  52 #include <sys/namei.h>
  53 #include <sys/proc.h>
  54 #include <sys/reboot.h>
  55 #include <sys/resource.h>
  56 #include <sys/resourcevar.h>
  57 #include <sys/selinfo.h>
  58 #include <sys/eventvar.h>       /* Must come after sys/selinfo.h */
  59 #include <sys/pipe.h>           /* Must come after sys/selinfo.h */
  60 #include <sys/signal.h>
  61 #include <sys/signalvar.h>
  62 #include <sys/socket.h>
  63 #include <sys/socketvar.h>
  64 #include <sys/stat.h>
  65 #include <sys/syscall.h>
  66 #include <sys/syscallsubr.h>
  67 #include <sys/sysctl.h>
  68 #include <sys/sysent.h>
  69 #include <sys/sysproto.h>
  70 #include <sys/systm.h>
  71 #include <sys/thr.h>
  72 #include <sys/unistd.h>
  73 #include <sys/ucontext.h>
  74 #include <sys/vnode.h>
  75 #include <sys/wait.h>
  76 #include <sys/ipc.h>
  77 #include <sys/msg.h>
  78 #include <sys/sem.h>
  79 #include <sys/shm.h>
  80
  81 #ifdef INET
  82 #include <netinet/in.h>
  83 #endif
  84
  85 #include <vm/vm.h>
  86 #include <vm/vm_kern.h>
  87 #include <vm/vm_param.h>
  88 #include <vm/pmap.h>
  89 #include <vm/vm_map.h>
  90 #include <vm/vm_object.h>
  91 #include <vm/vm_extern.h>
  92
  93 #include <machine/cpu.h>
  94
  95 #include <security/audit/audit.h>
  96
  97 #include <compat/freebsd32/freebsd32_util.h>
  98 #include <compat/freebsd32/freebsd32.h>
  99 #include <compat/freebsd32/freebsd32_ipc.h>
 100 #include <compat/freebsd32/freebsd32_signal.h>
 101 #include <compat/freebsd32/freebsd32_proto.h>
 102
 103 CTASSERT(sizeof(struct timeval32) == 8);
 104 CTASSERT(sizeof(struct timespec32) == 8);
 105 CTASSERT(sizeof(struct itimerval32) == 16);
 106 CTASSERT(sizeof(struct statfs32) == 256);
 107 CTASSERT(sizeof(struct rusage32) == 72);
 108 CTASSERT(sizeof(struct sigaltstack32) == 12);
 109 CTASSERT(sizeof(struct kevent32) == 20);
 110 CTASSERT(sizeof(struct iovec32) == 8);
 111 CTASSERT(sizeof(struct msghdr32) == 28);
 112 CTASSERT(sizeof(struct stat32) == 96);
 113 CTASSERT(sizeof(struct sigaction32) == 24);
 114
 115 static int freebsd32_kevent_copyout(void *arg, struct kevent *kevp, int count);
 116 static int freebsd32_kevent_copyin(void *arg, struct kevent *kevp, int count);
 117
 118 int
 119 freebsd32_wait4(struct thread *td, struct freebsd32_wait4_args *uap)
 120 {
 121         int error, status;
 122         struct rusage32 ru32;
 123         struct rusage ru, *rup;
 124
 125         if (uap->rusage != NULL)
 126                 rup = &ru;
 127         else
 128                 rup = NULL;
 129         error = kern_wait(td, uap->pid, &status, uap->options, rup);
 130         if (error)
 131                 return (error);
 132         if (uap->status != NULL)
 133                 error = copyout(&status, uap->status, sizeof(status));
 134         if (uap->rusage != NULL && error == 0) {
 135                 TV_CP(ru, ru32, ru_utime);
 136                 TV_CP(ru, ru32, ru_stime);
 137                 CP(ru, ru32, ru_maxrss);
 138                 CP(ru, ru32, ru_ixrss);
 139                 CP(ru, ru32, ru_idrss);
 140                 CP(ru, ru32, ru_isrss);
 141                 CP(ru, ru32, ru_minflt);
 142                 CP(ru, ru32, ru_majflt);
 143                 CP(ru, ru32, ru_nswap);
 144                 CP(ru, ru32, ru_inblock);
 145                 CP(ru, ru32, ru_oublock);
 146                 CP(ru, ru32, ru_msgsnd);
 147                 CP(ru, ru32, ru_msgrcv);
 148                 CP(ru, ru32, ru_nsignals);
 149                 CP(ru, ru32, ru_nvcsw);
 150                 CP(ru, ru32, ru_nivcsw);
 151                 error = copyout(&ru32, uap->rusage, sizeof(ru32));
 152         }
 153         return (error);
 154 }
 155
 156 #ifdef COMPAT_FREEBSD4
 157 static void
 158 copy_statfs(struct statfs *in, struct statfs32 *out)
 159 {
 160
 161         statfs_scale_blocks(in, INT32_MAX);
 162         bzero(out, sizeof(*out));
 163         CP(*in, *out, f_bsize);
 164         out->f_iosize = MIN(in->f_iosize, INT32_MAX);
 165         CP(*in, *out, f_blocks);
 166         CP(*in, *out, f_bfree);
 167         CP(*in, *out, f_bavail);
 168         out->f_files = MIN(in->f_files, INT32_MAX);
 169         out->f_ffree = MIN(in->f_ffree, INT32_MAX);
 170         CP(*in, *out, f_fsid);
 171         CP(*in, *out, f_owner);
 172         CP(*in, *out, f_type);
 173         CP(*in, *out, f_flags);
 174         out->f_syncwrites = MIN(in->f_syncwrites, INT32_MAX);
 175         out->f_asyncwrites = MIN(in->f_asyncwrites, INT32_MAX);
 176         strlcpy(out->f_fstypename,
 177               in->f_fstypename, MFSNAMELEN);
 178         strlcpy(out->f_mntonname,
 179               in->f_mntonname, min(MNAMELEN, FREEBSD4_MNAMELEN));
 180         out->f_syncreads = MIN(in->f_syncreads, INT32_MAX);
 181         out->f_asyncreads = MIN(in->f_asyncreads, INT32_MAX);
 182         strlcpy(out->f_mntfromname,
 183               in->f_mntfromname, min(MNAMELEN, FREEBSD4_MNAMELEN));
 184 }
 185 #endif
 186
 187 #ifdef COMPAT_FREEBSD4
 188 int
 189 freebsd4_freebsd32_getfsstat(struct thread *td, struct freebsd4_freebsd32_getfsstat_args *uap)
 190 {
 191         struct statfs *buf, *sp;
 192         struct statfs32 stat32;
 193         size_t count, size;
 194         int error;
 195
 196         count = uap->bufsize / sizeof(struct statfs32);
 197         size = count * sizeof(struct statfs);
 198         error = kern_getfsstat(td, &buf, size, UIO_SYSSPACE, uap->flags);
 199         if (size > 0) {
 200                 count = td->td_retval[0];
 201                 sp = buf;
 202                 while (count > 0 && error == 0) {
 203                         copy_statfs(sp, &stat32);
 204                         error = copyout(&stat32, uap->buf, sizeof(stat32));
 205                         sp++;
 206                         uap->buf++;
 207                         count--;
 208                 }
 209                 free(buf, M_TEMP);
 210         }
 211         return (error);
 212 }
 213 #endif
 214
 215 int
 216 freebsd32_sigaltstack(struct thread *td,
 217                       struct freebsd32_sigaltstack_args *uap)
 218 {
 219         struct sigaltstack32 s32;
 220         struct sigaltstack ss, oss, *ssp;
 221         int error;
 222
 223         if (uap->ss != NULL) {
 224                 error = copyin(uap->ss, &s32, sizeof(s32));
 225                 if (error)
 226                         return (error);
 227                 PTRIN_CP(s32, ss, ss_sp);
 228                 CP(s32, ss, ss_size);
 229                 CP(s32, ss, ss_flags);
 230                 ssp = &ss;
 231         } else
 232                 ssp = NULL;
 233         error = kern_sigaltstack(td, ssp, &oss);
 234         if (error == 0 && uap->oss != NULL) {
 235                 PTROUT_CP(oss, s32, ss_sp);
 236                 CP(oss, s32, ss_size);
 237                 CP(oss, s32, ss_flags);
 238                 error = copyout(&s32, uap->oss, sizeof(s32));
 239         }
 240         return (error);
 241 }
 242
 243 /*
 244  * Custom version of exec_copyin_args() so that we can translate
 245  * the pointers.
 246  */
 247 static int
 248 freebsd32_exec_copyin_args(struct image_args *args, char *fname,
 249     enum uio_seg segflg, u_int32_t *argv, u_int32_t *envv)
 250 {
 251         char *argp, *envp;
 252         u_int32_t *p32, arg;
 253         size_t length;
 254         int error;
 255
 256         bzero(args, sizeof(*args));
 257         if (argv == NULL)
 258                 return (EFAULT);
 259
 260         /*
 261          * Allocate temporary demand zeroed space for argument and
 262          *      environment strings
 263          */
 264         args->buf = (char *) kmem_alloc_wait(exec_map,
 265             PATH_MAX + ARG_MAX + MAXSHELLCMDLEN);
 266         if (args->buf == NULL)
 267                 return (ENOMEM);
 268         args->begin_argv = args->buf;
 269         args->endp = args->begin_argv;
 270         args->stringspace = ARG_MAX;
 271
 272         /*
 273          * Copy the file name.
 274          */
 275         if (fname != NULL) {
 276                 args->fname = args->buf + ARG_MAX;
 277                 error = (segflg == UIO_SYSSPACE) ?
 278                     copystr(fname, args->fname, PATH_MAX, &length) :
 279                     copyinstr(fname, args->fname, PATH_MAX, &length);
 280                 if (error != 0)
 281                         goto err_exit;
 282         } else
 283                 args->fname = NULL;
 284
 285         /*
 286          * extract arguments first
 287          */
 288         p32 = argv;
 289         for (;;) {
 290                 error = copyin(p32++, &arg, sizeof(arg));
 291                 if (error)
 292                         goto err_exit;
 293                 if (arg == 0)
 294                         break;
 295                 argp = PTRIN(arg);
 296                 error = copyinstr(argp, args->endp, args->stringspace, &length);
 297                 if (error) {
 298                         if (error == ENAMETOOLONG)
 299                                 error = E2BIG;
 300                         goto err_exit;
 301                 }
 302                 args->stringspace -= length;
 303                 args->endp += length;
 304                 args->argc++;
 305         }
 306
 307         args->begin_envv = args->endp;
 308
 309         /*
 310          * extract environment strings
 311          */
 312         if (envv) {
 313                 p32 = envv;
 314                 for (;;) {
 315                         error = copyin(p32++, &arg, sizeof(arg));
 316                         if (error)
 317                                 goto err_exit;
 318                         if (arg == 0)
 319                                 break;
 320                         envp = PTRIN(arg);
 321                         error = copyinstr(envp, args->endp, args->stringspace,
 322                             &length);
 323                         if (error) {
 324                                 if (error == ENAMETOOLONG)
 325                                         error = E2BIG;
 326                                 goto err_exit;
 327                         }
 328                         args->stringspace -= length;
 329                         args->endp += length;
 330                         args->envc++;
 331                 }
 332         }
 333
 334         return (0);
 335
 336 err_exit:
 337         kmem_free_wakeup(exec_map, (vm_offset_t)args->buf,
 338             PATH_MAX + ARG_MAX + MAXSHELLCMDLEN);
 339         args->buf = NULL;
 340         return (error);
 341 }
 342
 343 int
 344 freebsd32_execve(struct thread *td, struct freebsd32_execve_args *uap)
 345 {
 346         struct image_args eargs;
 347         int error;
 348
 349         error = freebsd32_exec_copyin_args(&eargs, uap->fname, UIO_USERSPACE,
 350             uap->argv, uap->envv);
 351         if (error == 0)
 352                 error = kern_execve(td, &eargs, NULL);
 353         return (error);
 354 }
 355
 356 int
 357 freebsd32_fexecve(struct thread *td, struct freebsd32_fexecve_args *uap)
 358 {
 359         struct image_args eargs;
 360         int error;
 361
 362         error = freebsd32_exec_copyin_args(&eargs, NULL, UIO_SYSSPACE,
 363             uap->argv, uap->envv);
 364         if (error == 0) {
 365                 eargs.fd = uap->fd;
 366                 error = kern_execve(td, &eargs, NULL);
 367         }
 368         return (error);
 369 }
 370
 371 #ifdef __ia64__
 372 static int
 373 freebsd32_mmap_partial(struct thread *td, vm_offset_t start, vm_offset_t end,
 374                        int prot, int fd, off_t pos)
 375 {
 376         vm_map_t map;
 377         vm_map_entry_t entry;
 378         int rv;
 379
 380         map = &td->td_proc->p_vmspace->vm_map;
 381         if (fd != -1)
 382                 prot |= VM_PROT_WRITE;
 383
 384         if (vm_map_lookup_entry(map, start, &entry)) {
 385                 if ((entry->protection & prot) != prot) {
 386                         rv = vm_map_protect(map,
 387                                             trunc_page(start),
 388                                             round_page(end),
 389                                             entry->protection | prot,
 390                                             FALSE);
 391                         if (rv != KERN_SUCCESS)
 392                                 return (EINVAL);
 393                 }
 394         } else {
 395                 vm_offset_t addr = trunc_page(start);
 396                 rv = vm_map_find(map, 0, 0,
 397                                  &addr, PAGE_SIZE, FALSE, prot,
 398                                  VM_PROT_ALL, 0);
 399                 if (rv != KERN_SUCCESS)
 400                         return (EINVAL);
 401         }
 402
 403         if (fd != -1) {
 404                 struct pread_args r;
 405                 r.fd = fd;
 406                 r.buf = (void *) start;
 407                 r.nbyte = end - start;
 408                 r.offset = pos;
 409                 return (pread(td, &r));
 410         } else {
 411                 while (start < end) {
 412                         subyte((void *) start, 0);
 413                         start++;
 414                 }
 415                 return (0);
 416         }
 417 }
 418 #endif
 419
 420 int
 421 freebsd32_mmap(struct thread *td, struct freebsd32_mmap_args *uap)
 422 {
 423         struct mmap_args ap;
 424         vm_offset_t addr = (vm_offset_t) uap->addr;
 425         vm_size_t len    = uap->len;
 426         int prot         = uap->prot;
 427         int flags        = uap->flags;
 428         int fd           = uap->fd;
 429         off_t pos        = (uap->poslo
 430                             | ((off_t)uap->poshi << 32));
 431 #ifdef __ia64__
 432         vm_size_t pageoff;
 433         int error;
 434
 435         /*
 436          * Attempt to handle page size hassles.
 437          */
 438         pageoff = (pos & PAGE_MASK);
 439         if (flags & MAP_FIXED) {
 440                 vm_offset_t start, end;
 441                 start = addr;
 442                 end = addr + len;
 443
 444                 if (start != trunc_page(start)) {
 445                         error = freebsd32_mmap_partial(td, start,
 446                                                        round_page(start), prot,
 447                                                        fd, pos);
 448                         if (fd != -1)
 449                                 pos += round_page(start) - start;
 450                         start = round_page(start);
 451                 }
 452                 if (end != round_page(end)) {
 453                         vm_offset_t t = trunc_page(end);
 454                         error = freebsd32_mmap_partial(td, t, end,
 455                                                   prot, fd,
 456                                                   pos + t - start);
 457                         end = trunc_page(end);
 458                 }
 459                 if (end > start && fd != -1 && (pos & PAGE_MASK)) {
 460                         /*
 461                          * We can't map this region at all. The specified
 462                          * address doesn't have the same alignment as the file
 463                          * position. Fake the mapping by simply reading the
 464                          * entire region into memory. First we need to make
 465                          * sure the region exists.
 466                          */
 467                         vm_map_t map;
 468                         struct pread_args r;
 469                         int rv;
 470
 471                         prot |= VM_PROT_WRITE;
 472                         map = &td->td_proc->p_vmspace->vm_map;
 473                         rv = vm_map_remove(map, start, end);
 474                         if (rv != KERN_SUCCESS)
 475                                 return (EINVAL);
 476                         rv = vm_map_find(map, 0, 0,
 477                                          &start, end - start, FALSE,
 478                                          prot, VM_PROT_ALL, 0);
 479                         if (rv != KERN_SUCCESS)
 480                                 return (EINVAL);
 481                         r.fd = fd;
 482                         r.buf = (void *) start;
 483                         r.nbyte = end - start;
 484                         r.offset = pos;
 485                         error = pread(td, &r);
 486                         if (error)
 487                                 return (error);
 488
 489                         td->td_retval[0] = addr;
 490                         return (0);
 491                 }
 492                 if (end == start) {
 493                         /*
 494                          * After dealing with the ragged ends, there
 495                          * might be none left.
 496                          */
 497                         td->td_retval[0] = addr;
 498                         return (0);
 499                 }
 500                 addr = start;
 501                 len = end - start;
 502         }
 503 #endif
 504
 505         ap.addr = (void *) addr;
 506         ap.len = len;
 507         ap.prot = prot;
 508         ap.flags = flags;
 509         ap.fd = fd;
 510         ap.pos = pos;
 511
 512         return (mmap(td, &ap));
 513 }
 514
 515 #ifdef COMPAT_FREEBSD6
 516 int
 517 freebsd6_freebsd32_mmap(struct thread *td, struct freebsd6_freebsd32_mmap_args *uap)
 518 {
 519         struct freebsd32_mmap_args ap;
 520
 521         ap.addr = uap->addr;
 522         ap.len = uap->len;
 523         ap.prot = uap->prot;
 524         ap.flags = uap->flags;
 525         ap.fd = uap->fd;
 526         ap.poslo = uap->poslo;
 527         ap.poshi = uap->poshi;
 528
 529         return (freebsd32_mmap(td, &ap));
 530 }
 531 #endif
 532
 533 int
 534 freebsd32_setitimer(struct thread *td, struct freebsd32_setitimer_args *uap)
 535 {
 536         struct itimerval itv, oitv, *itvp;
 537         struct itimerval32 i32;
 538         int error;
 539
 540         if (uap->itv != NULL) {
 541                 error = copyin(uap->itv, &i32, sizeof(i32));
 542                 if (error)
 543                         return (error);
 544                 TV_CP(i32, itv, it_interval);
 545                 TV_CP(i32, itv, it_value);
 546                 itvp = &itv;
 547         } else
 548                 itvp = NULL;
 549         error = kern_setitimer(td, uap->which, itvp, &oitv);
 550         if (error || uap->oitv == NULL)
 551                 return (error);
 552         TV_CP(oitv, i32, it_interval);
 553         TV_CP(oitv, i32, it_value);
 554         return (copyout(&i32, uap->oitv, sizeof(i32)));
 555 }
 556
 557 int
 558 freebsd32_getitimer(struct thread *td, struct freebsd32_getitimer_args *uap)
 559 {
 560         struct itimerval itv;
 561         struct itimerval32 i32;
 562         int error;
 563
 564         error = kern_getitimer(td, uap->which, &itv);
 565         if (error || uap->itv == NULL)
 566                 return (error);
 567         TV_CP(itv, i32, it_interval);
 568         TV_CP(itv, i32, it_value);
 569         return (copyout(&i32, uap->itv, sizeof(i32)));
 570 }
 571
 572 int
 573 freebsd32_select(struct thread *td, struct freebsd32_select_args *uap)
 574 {
 575         struct timeval32 tv32;
 576         struct timeval tv, *tvp;
 577         int error;
 578
 579         if (uap->tv != NULL) {
 580                 error = copyin(uap->tv, &tv32, sizeof(tv32));
 581                 if (error)
 582                         return (error);
 583                 CP(tv32, tv, tv_sec);
 584                 CP(tv32, tv, tv_usec);
 585                 tvp = &tv;
 586         } else
 587                 tvp = NULL;
 588         /*
 589          * XXX big-endian needs to convert the fd_sets too.
 590          * XXX Do pointers need PTRIN()?
 591          */
 592         return (kern_select(td, uap->nd, uap->in, uap->ou, uap->ex, tvp));
 593 }
 594
 595 /*
 596  * Copy 'count' items into the destination list pointed to by uap->eventlist.
 597  */
 598 static int
 599 freebsd32_kevent_copyout(void *arg, struct kevent *kevp, int count)
 600 {
 601         struct freebsd32_kevent_args *uap;
 602         struct kevent32 ks32[KQ_NEVENTS];
 603         int i, error = 0;
 604
 605         KASSERT(count <= KQ_NEVENTS, ("count (%d) > KQ_NEVENTS", count));
 606         uap = (struct freebsd32_kevent_args *)arg;
 607
 608         for (i = 0; i < count; i++) {
 609                 CP(kevp[i], ks32[i], ident);
 610                 CP(kevp[i], ks32[i], filter);
 611                 CP(kevp[i], ks32[i], flags);
 612                 CP(kevp[i], ks32[i], fflags);
 613                 CP(kevp[i], ks32[i], data);
 614                 PTROUT_CP(kevp[i], ks32[i], udata);
 615         }
 616         error = copyout(ks32, uap->eventlist, count * sizeof *ks32);
 617         if (error == 0)
 618                 uap->eventlist += count;
 619         return (error);
 620 }
 621
 622 /*
 623  * Copy 'count' items from the list pointed to by uap->changelist.
 624  */
 625 static int
 626 freebsd32_kevent_copyin(void *arg, struct kevent *kevp, int count)
 627 {
 628         struct freebsd32_kevent_args *uap;
 629         struct kevent32 ks32[KQ_NEVENTS];
 630         int i, error = 0;
 631
 632         KASSERT(count <= KQ_NEVENTS, ("count (%d) > KQ_NEVENTS", count));
 633         uap = (struct freebsd32_kevent_args *)arg;
 634
 635         error = copyin(uap->changelist, ks32, count * sizeof *ks32);
 636         if (error)
 637                 goto done;
 638         uap->changelist += count;
 639
 640         for (i = 0; i < count; i++) {
 641                 CP(ks32[i], kevp[i], ident);
 642                 CP(ks32[i], kevp[i], filter);
 643                 CP(ks32[i], kevp[i], flags);
 644                 CP(ks32[i], kevp[i], fflags);
 645                 CP(ks32[i], kevp[i], data);
 646                 PTRIN_CP(ks32[i], kevp[i], udata);
 647         }
 648 done:
 649         return (error);
 650 }
 651
 652 int
 653 freebsd32_kevent(struct thread *td, struct freebsd32_kevent_args *uap)
 654 {
 655         struct timespec32 ts32;
 656         struct timespec ts, *tsp;
 657         struct kevent_copyops k_ops = { uap,
 658                                         freebsd32_kevent_copyout,
 659                                         freebsd32_kevent_copyin};
 660         int error;
 661
 662
 663         if (uap->timeout) {
 664                 error = copyin(uap->timeout, &ts32, sizeof(ts32));
 665                 if (error)
 666                         return (error);
 667                 CP(ts32, ts, tv_sec);
 668                 CP(ts32, ts, tv_nsec);
 669                 tsp = &ts;
 670         } else
 671                 tsp = NULL;
 672         error = kern_kevent(td, uap->fd, uap->nchanges, uap->nevents,
 673             &k_ops, tsp);
 674         return (error);
 675 }
 676
 677 int
 678 freebsd32_gettimeofday(struct thread *td,
 679                        struct freebsd32_gettimeofday_args *uap)
 680 {
 681         struct timeval atv;
 682         struct timeval32 atv32;
 683         struct timezone rtz;
 684         int error = 0;
 685
 686         if (uap->tp) {
 687                 microtime(&atv);
 688                 CP(atv, atv32, tv_sec);
 689                 CP(atv, atv32, tv_usec);
 690                 error = copyout(&atv32, uap->tp, sizeof (atv32));
 691         }
 692         if (error == 0 && uap->tzp != NULL) {
 693                 rtz.tz_minuteswest = tz_minuteswest;
 694                 rtz.tz_dsttime = tz_dsttime;
 695                 error = copyout(&rtz, uap->tzp, sizeof (rtz));
 696         }
 697         return (error);
 698 }
 699
 700 int
 701 freebsd32_getrusage(struct thread *td, struct freebsd32_getrusage_args *uap)
 702 {
 703         struct rusage32 s32;
 704         struct rusage s;
 705         int error;
 706
 707         error = kern_getrusage(td, uap->who, &s);
 708         if (error)
 709                 return (error);
 710         if (uap->rusage != NULL) {
 711                 TV_CP(s, s32, ru_utime);
 712                 TV_CP(s, s32, ru_stime);
 713                 CP(s, s32, ru_maxrss);
 714                 CP(s, s32, ru_ixrss);
 715                 CP(s, s32, ru_idrss);
 716                 CP(s, s32, ru_isrss);
 717                 CP(s, s32, ru_minflt);
 718                 CP(s, s32, ru_majflt);
 719                 CP(s, s32, ru_nswap);
 720                 CP(s, s32, ru_inblock);
 721                 CP(s, s32, ru_oublock);
 722                 CP(s, s32, ru_msgsnd);
 723                 CP(s, s32, ru_msgrcv);
 724                 CP(s, s32, ru_nsignals);
 725                 CP(s, s32, ru_nvcsw);
 726                 CP(s, s32, ru_nivcsw);
 727                 error = copyout(&s32, uap->rusage, sizeof(s32));
 728         }
 729         return (error);
 730 }
 731
 732 static int
 733 freebsd32_copyinuio(struct iovec32 *iovp, u_int iovcnt, struct uio **uiop)
 734 {
 735         struct iovec32 iov32;
 736         struct iovec *iov;
 737         struct uio *uio;
 738         u_int iovlen;
 739         int error, i;
 740
 741         *uiop = NULL;
 742         if (iovcnt > UIO_MAXIOV)
 743                 return (EINVAL);
 744         iovlen = iovcnt * sizeof(struct iovec);
 745         uio = malloc(iovlen + sizeof *uio, M_IOV, M_WAITOK);
 746         iov = (struct iovec *)(uio + 1);
 747         for (i = 0; i < iovcnt; i++) {
 748                 error = copyin(&iovp[i], &iov32, sizeof(struct iovec32));
 749                 if (error) {
 750                         free(uio, M_IOV);
 751                         return (error);
 752                 }
 753                 iov[i].iov_base = PTRIN(iov32.iov_base);
 754                 iov[i].iov_len = iov32.iov_len;
 755         }
 756         uio->uio_iov = iov;
 757         uio->uio_iovcnt = iovcnt;
 758         uio->uio_segflg = UIO_USERSPACE;
 759         uio->uio_offset = -1;
 760         uio->uio_resid = 0;
 761         for (i = 0; i < iovcnt; i++) {
 762                 if (iov->iov_len > INT_MAX - uio->uio_resid) {
 763                         free(uio, M_IOV);
 764                         return (EINVAL);
 765                 }
 766                 uio->uio_resid += iov->iov_len;
 767                 iov++;
 768         }
 769         *uiop = uio;
 770         return (0);
 771 }
 772
 773 int
 774 freebsd32_readv(struct thread *td, struct freebsd32_readv_args *uap)
 775 {
 776         struct uio *auio;
 777         int error;
 778
 779         error = freebsd32_copyinuio(uap->iovp, uap->iovcnt, &auio);
 780         if (error)
 781                 return (error);
 782         error = kern_readv(td, uap->fd, auio);
 783         free(auio, M_IOV);
 784         return (error);
 785 }
 786
 787 int
 788 freebsd32_writev(struct thread *td, struct freebsd32_writev_args *uap)
 789 {
 790         struct uio *auio;
 791         int error;
 792
 793         error = freebsd32_copyinuio(uap->iovp, uap->iovcnt, &auio);
 794         if (error)
 795                 return (error);
 796         error = kern_writev(td, uap->fd, auio);
 797         free(auio, M_IOV);
 798         return (error);
 799 }
 800
 801 int
 802 freebsd32_preadv(struct thread *td, struct freebsd32_preadv_args *uap)
 803 {
 804         struct uio *auio;
 805         int error;
 806
 807         error = freebsd32_copyinuio(uap->iovp, uap->iovcnt, &auio);
 808         if (error)
 809                 return (error);
 810         error = kern_preadv(td, uap->fd, auio, uap->offset);
 811         free(auio, M_IOV);
 812         return (error);
 813 }
 814
 815 int
 816 freebsd32_pwritev(struct thread *td, struct freebsd32_pwritev_args *uap)
 817 {
 818         struct uio *auio;
 819         int error;
 820
 821         error = freebsd32_copyinuio(uap->iovp, uap->iovcnt, &auio);
 822         if (error)
 823                 return (error);
 824         error = kern_pwritev(td, uap->fd, auio, uap->offset);
 825         free(auio, M_IOV);
 826         return (error);
 827 }
 828
 829 static int
 830 freebsd32_copyiniov(struct iovec32 *iovp32, u_int iovcnt, struct iovec **iovp,
 831     int error)
 832 {
 833         struct iovec32 iov32;
 834         struct iovec *iov;
 835         u_int iovlen;
 836         int i;
 837
 838         *iovp = NULL;
 839         if (iovcnt > UIO_MAXIOV)
 840                 return (error);
 841         iovlen = iovcnt * sizeof(struct iovec);
 842         iov = malloc(iovlen, M_IOV, M_WAITOK);
 843         for (i = 0; i < iovcnt; i++) {
 844                 error = copyin(&iovp32[i], &iov32, sizeof(struct iovec32));
 845                 if (error) {
 846                         free(iov, M_IOV);
 847                         return (error);
 848                 }
 849                 iov[i].iov_base = PTRIN(iov32.iov_base);
 850                 iov[i].iov_len = iov32.iov_len;
 851         }
 852         *iovp = iov;
 853         return (0);
 854 }
 855
 856 static int
 857 freebsd32_copyinmsghdr(struct msghdr32 *msg32, struct msghdr *msg)
 858 {
 859         struct msghdr32 m32;
 860         int error;
 861
 862         error = copyin(msg32, &m32, sizeof(m32));
 863         if (error)
 864                 return (error);
 865         msg->msg_name = PTRIN(m32.msg_name);
 866         msg->msg_namelen = m32.msg_namelen;
 867         msg->msg_iov = PTRIN(m32.msg_iov);
 868         msg->msg_iovlen = m32.msg_iovlen;
 869         msg->msg_control = PTRIN(m32.msg_control);
 870         msg->msg_controllen = m32.msg_controllen;
 871         msg->msg_flags = m32.msg_flags;
 872         return (0);
 873 }
 874
 875 static int
 876 freebsd32_copyoutmsghdr(struct msghdr *msg, struct msghdr32 *msg32)
 877 {
 878         struct msghdr32 m32;
 879         int error;
 880
 881         m32.msg_name = PTROUT(msg->msg_name);
 882         m32.msg_namelen = msg->msg_namelen;
 883         m32.msg_iov = PTROUT(msg->msg_iov);
 884         m32.msg_iovlen = msg->msg_iovlen;
 885         m32.msg_control = PTROUT(msg->msg_control);
 886         m32.msg_controllen = msg->msg_controllen;
 887         m32.msg_flags = msg->msg_flags;
 888         error = copyout(&m32, msg32, sizeof(m32));
 889         return (error);
 890 }
 891
 892 #define FREEBSD32_ALIGNBYTES    (sizeof(int) - 1)
 893 #define FREEBSD32_ALIGN(p)      \
 894         (((u_long)(p) + FREEBSD32_ALIGNBYTES) & ~FREEBSD32_ALIGNBYTES)
 895 #define FREEBSD32_CMSG_SPACE(l) \
 896         (FREEBSD32_ALIGN(sizeof(struct cmsghdr)) + FREEBSD32_ALIGN(l))
 897
 898 #define FREEBSD32_CMSG_DATA(cmsg)       ((unsigned char *)(cmsg) + \
 899                                  FREEBSD32_ALIGN(sizeof(struct cmsghdr)))
 900 static int
 901 freebsd32_copy_msg_out(struct msghdr *msg, struct mbuf *control)
 902 {
 903         struct cmsghdr *cm;
 904         void *data;
 905         socklen_t clen, datalen;
 906         int error;
 907         caddr_t ctlbuf;
 908         int len, maxlen, copylen;
 909         struct mbuf *m;
 910         error = 0;
 911
 912         len    = msg->msg_controllen;
 913         maxlen = msg->msg_controllen;
 914         msg->msg_controllen = 0;
 915
 916         m = control;
 917         ctlbuf = msg->msg_control;
 918
 919         while (m && len > 0) {
 920                 cm = mtod(m, struct cmsghdr *);
 921                 clen = m->m_len;
 922
 923                 while (cm != NULL) {
 924
 925                         if (sizeof(struct cmsghdr) > clen ||
 926                             cm->cmsg_len > clen) {
 927                                 error = EINVAL;
 928                                 break;
 929                         }
 930
 931                         data   = CMSG_DATA(cm);
 932                         datalen = (caddr_t)cm + cm->cmsg_len - (caddr_t)data;
 933
 934                         /* Adjust message length */
 935                         cm->cmsg_len = FREEBSD32_ALIGN(sizeof(struct cmsghdr)) +
 936                             datalen;
 937
 938
 939                         /* Copy cmsghdr */
 940                         copylen = sizeof(struct cmsghdr);
 941                         if (len < copylen) {
 942                                 msg->msg_flags |= MSG_CTRUNC;
 943                                 copylen = len;
 944                         }
 945
 946                         error = copyout(cm,ctlbuf,copylen);
 947                         if (error)
 948                                 goto exit;
 949
 950                         ctlbuf += FREEBSD32_ALIGN(copylen);
 951                         len    -= FREEBSD32_ALIGN(copylen);
 952
 953                         if (len <= 0)
 954                                 break;
 955
 956                         /* Copy data */
 957                         copylen = datalen;
 958                         if (len < copylen) {
 959                                 msg->msg_flags |= MSG_CTRUNC;
 960                                 copylen = len;
 961                         }
 962
 963                         error = copyout(data,ctlbuf,copylen);
 964                         if (error)
 965                                 goto exit;
 966
 967                         ctlbuf += FREEBSD32_ALIGN(copylen);
 968                         len    -= FREEBSD32_ALIGN(copylen);
 969
 970                         if (CMSG_SPACE(datalen) < clen) {
 971                                 clen -= CMSG_SPACE(datalen);
 972                                 cm = (struct cmsghdr *)
 973                                         ((caddr_t)cm + CMSG_SPACE(datalen));
 974                         } else {
 975                                 clen = 0;
 976                                 cm = NULL;
 977                         }
 978                 }
 979                 m = m->m_next;
 980         }
 981
 982         msg->msg_controllen = (len <= 0) ? maxlen :  ctlbuf - (caddr_t)msg->msg_control;
 983
 984 exit:
 985         return (error);
 986
 987 }
 988
 989 int
 990 freebsd32_recvmsg(td, uap)
 991         struct thread *td;
 992         struct freebsd32_recvmsg_args /* {
 993                 int     s;
 994                 struct  msghdr32 *msg;
 995                 int     flags;
 996         } */ *uap;
 997 {
 998         struct msghdr msg;
 999         struct msghdr32 m32;
1000         struct iovec *uiov, *iov;
1001         struct mbuf *control = NULL;
1002         struct mbuf **controlp;
1003
1004         int error;
1005         error = copyin(uap->msg, &m32, sizeof(m32));
1006         if (error)
1007                 return (error);
1008         error = freebsd32_copyinmsghdr(uap->msg, &msg);
1009         if (error)
1010                 return (error);
1011         error = freebsd32_copyiniov(PTRIN(m32.msg_iov), m32.msg_iovlen, &iov,
1012             EMSGSIZE);
1013         if (error)
1014                 return (error);
1015         msg.msg_flags = uap->flags;
1016         uiov = msg.msg_iov;
1017         msg.msg_iov = iov;
1018
1019         controlp = (msg.msg_control != NULL) ?  &control : NULL;
1020         error = kern_recvit(td, uap->s, &msg, UIO_USERSPACE, controlp);
1021         if (error == 0) {
1022                 msg.msg_iov = uiov;
1023
1024                 if (control != NULL)
1025                         error = freebsd32_copy_msg_out(&msg, control);
1026
1027                 if (error == 0)
1028                         error = freebsd32_copyoutmsghdr(&msg, uap->msg);
1029         }
1030         free(iov, M_IOV);
1031
1032         if (control != NULL)
1033                 m_freem(control);
1034
1035         return (error);
1036 }
1037
1038
1039 static int
1040 freebsd32_convert_msg_in(struct mbuf **controlp)
1041 {
1042         struct mbuf *control = *controlp;
1043         struct cmsghdr *cm = mtod(control, struct cmsghdr *);
1044         void *data;
1045         socklen_t clen = control->m_len, datalen;
1046         int error;
1047
1048         error = 0;
1049         *controlp = NULL;
1050
1051         while (cm != NULL) {
1052                 if (sizeof(struct cmsghdr) > clen || cm->cmsg_len > clen) {
1053                         error = EINVAL;
1054                         break;
1055                 }
1056
1057                 data = FREEBSD32_CMSG_DATA(cm);
1058                 datalen = (caddr_t)cm + cm->cmsg_len - (caddr_t)data;
1059
1060                 *controlp = sbcreatecontrol(data, datalen, cm->cmsg_type,
1061                     cm->cmsg_level);
1062                 controlp = &(*controlp)->m_next;
1063
1064                 if (FREEBSD32_CMSG_SPACE(datalen) < clen) {
1065                         clen -= FREEBSD32_CMSG_SPACE(datalen);
1066                         cm = (struct cmsghdr *)
1067                                 ((caddr_t)cm + FREEBSD32_CMSG_SPACE(datalen));
1068                 } else {
1069                         clen = 0;
1070                         cm = NULL;
1071                 }
1072         }
1073
1074         m_freem(control);
1075         return (error);
1076 }
1077
1078
1079 int
1080 freebsd32_sendmsg(struct thread *td,
1081                   struct freebsd32_sendmsg_args *uap)
1082 {
1083         struct msghdr msg;
1084         struct msghdr32 m32;
1085         struct iovec *iov;
1086         struct mbuf *control = NULL;
1087         struct sockaddr *to = NULL;
1088         int error;
1089
1090         error = copyin(uap->msg, &m32, sizeof(m32));
1091         if (error)
1092                 return (error);
1093         error = freebsd32_copyinmsghdr(uap->msg, &msg);
1094         if (error)
1095                 return (error);
1096         error = freebsd32_copyiniov(PTRIN(m32.msg_iov), m32.msg_iovlen, &iov,
1097             EMSGSIZE);
1098         if (error)
1099                 return (error);
1100         msg.msg_iov = iov;
1101         if (msg.msg_name != NULL) {
1102                 error = getsockaddr(&to, msg.msg_name, msg.msg_namelen);
1103                 if (error) {
1104                         to = NULL;
1105                         goto out;
1106                 }
1107                 msg.msg_name = to;
1108         }
1109
1110         if (msg.msg_control) {
1111                 if (msg.msg_controllen < sizeof(struct cmsghdr)) {
1112                         error = EINVAL;
1113                         goto out;
1114                 }
1115
1116                 error = sockargs(&control, msg.msg_control,
1117                     msg.msg_controllen, MT_CONTROL);
1118                 if (error)
1119                         goto out;
1120
1121                 error = freebsd32_convert_msg_in(&control);
1122                 if (error)
1123                         goto out;
1124         }
1125
1126         error = kern_sendit(td, uap->s, &msg, uap->flags, control,
1127             UIO_USERSPACE);
1128
1129 out:
1130         free(iov, M_IOV);
1131         if (to)
1132                 free(to, M_SONAME);
1133         return (error);
1134 }
1135
1136 int
1137 freebsd32_recvfrom(struct thread *td,
1138                    struct freebsd32_recvfrom_args *uap)
1139 {
1140         struct msghdr msg;
1141         struct iovec aiov;
1142         int error;
1143
1144         if (uap->fromlenaddr) {
1145                 error = copyin(PTRIN(uap->fromlenaddr), &msg.msg_namelen,
1146                     sizeof(msg.msg_namelen));
1147                 if (error)
1148                         return (error);
1149         } else {
1150                 msg.msg_namelen = 0;
1151         }
1152
1153         msg.msg_name = PTRIN(uap->from);
1154         msg.msg_iov = &aiov;
1155         msg.msg_iovlen = 1;
1156         aiov.iov_base = PTRIN(uap->buf);
1157         aiov.iov_len = uap->len;
1158         msg.msg_control = NULL;
1159         msg.msg_flags = uap->flags;
1160         error = kern_recvit(td, uap->s, &msg, UIO_USERSPACE, NULL);
1161         if (error == 0 && uap->fromlenaddr)
1162                 error = copyout(&msg.msg_namelen, PTRIN(uap->fromlenaddr),
1163                     sizeof (msg.msg_namelen));
1164         return (error);
1165 }
1166
1167 int
1168 freebsd32_settimeofday(struct thread *td,
1169                        struct freebsd32_settimeofday_args *uap)
1170 {
1171         struct timeval32 tv32;
1172         struct timeval tv, *tvp;
1173         struct timezone tz, *tzp;
1174         int error;
1175
1176         if (uap->tv) {
1177                 error = copyin(uap->tv, &tv32, sizeof(tv32));
1178                 if (error)
1179                         return (error);
1180                 CP(tv32, tv, tv_sec);
1181                 CP(tv32, tv, tv_usec);
1182                 tvp = &tv;
1183         } else
1184                 tvp = NULL;
1185         if (uap->tzp) {
1186                 error = copyin(uap->tzp, &tz, sizeof(tz));
1187                 if (error)
1188                         return (error);
1189                 tzp = &tz;
1190         } else
1191                 tzp = NULL;
1192         return (kern_settimeofday(td, tvp, tzp));
1193 }
1194
1195 int
1196 freebsd32_utimes(struct thread *td, struct freebsd32_utimes_args *uap)
1197 {
1198         struct timeval32 s32[2];
1199         struct timeval s[2], *sp;
1200         int error;
1201
1202         if (uap->tptr != NULL) {
1203                 error = copyin(uap->tptr, s32, sizeof(s32));
1204                 if (error)
1205                         return (error);
1206                 CP(s32[0], s[0], tv_sec);
1207                 CP(s32[0], s[0], tv_usec);
1208                 CP(s32[1], s[1], tv_sec);
1209                 CP(s32[1], s[1], tv_usec);
1210                 sp = s;
1211         } else
1212                 sp = NULL;
1213         return (kern_utimes(td, uap->path, UIO_USERSPACE, sp, UIO_SYSSPACE));
1214 }
1215
1216 int
1217 freebsd32_lutimes(struct thread *td, struct freebsd32_lutimes_args *uap)
1218 {
1219         struct timeval32 s32[2];
1220         struct timeval s[2], *sp;
1221         int error;
1222
1223         if (uap->tptr != NULL) {
1224                 error = copyin(uap->tptr, s32, sizeof(s32));
1225                 if (error)
1226                         return (error);
1227                 CP(s32[0], s[0], tv_sec);
1228                 CP(s32[0], s[0], tv_usec);
1229                 CP(s32[1], s[1], tv_sec);
1230                 CP(s32[1], s[1], tv_usec);
1231                 sp = s;
1232         } else
1233                 sp = NULL;
1234         return (kern_lutimes(td, uap->path, UIO_USERSPACE, sp, UIO_SYSSPACE));
1235 }
1236
1237 int
1238 freebsd32_futimes(struct thread *td, struct freebsd32_futimes_args *uap)
1239 {
1240         struct timeval32 s32[2];
1241         struct timeval s[2], *sp;
1242         int error;
1243
1244         if (uap->tptr != NULL) {
1245                 error = copyin(uap->tptr, s32, sizeof(s32));
1246                 if (error)
1247                         return (error);
1248                 CP(s32[0], s[0], tv_sec);
1249                 CP(s32[0], s[0], tv_usec);
1250                 CP(s32[1], s[1], tv_sec);
1251                 CP(s32[1], s[1], tv_usec);
1252                 sp = s;
1253         } else
1254                 sp = NULL;
1255         return (kern_futimes(td, uap->fd, sp, UIO_SYSSPACE));
1256 }
1257
1258 int
1259 freebsd32_futimesat(struct thread *td, struct freebsd32_futimesat_args *uap)
1260 {
1261         struct timeval32 s32[2];
1262         struct timeval s[2], *sp;
1263         int error;
1264
1265         if (uap->times != NULL) {
1266                 error = copyin(uap->times, s32, sizeof(s32));
1267                 if (error)
1268                         return (error);
1269                 CP(s32[0], s[0], tv_sec);
1270                 CP(s32[0], s[0], tv_usec);
1271                 CP(s32[1], s[1], tv_sec);
1272                 CP(s32[1], s[1], tv_usec);
1273                 sp = s;
1274         } else
1275                 sp = NULL;
1276         return (kern_utimesat(td, uap->fd, uap->path, UIO_USERSPACE,
1277                 sp, UIO_SYSSPACE));
1278 }
1279
1280 int
1281 freebsd32_adjtime(struct thread *td, struct freebsd32_adjtime_args *uap)
1282 {
1283         struct timeval32 tv32;
1284         struct timeval delta, olddelta, *deltap;
1285         int error;
1286
1287         if (uap->delta) {
1288                 error = copyin(uap->delta, &tv32, sizeof(tv32));
1289                 if (error)
1290                         return (error);
1291                 CP(tv32, delta, tv_sec);
1292                 CP(tv32, delta, tv_usec);
1293                 deltap = &delta;
1294         } else
1295                 deltap = NULL;
1296         error = kern_adjtime(td, deltap, &olddelta);
1297         if (uap->olddelta && error == 0) {
1298                 CP(olddelta, tv32, tv_sec);
1299                 CP(olddelta, tv32, tv_usec);
1300                 error = copyout(&tv32, uap->olddelta, sizeof(tv32));
1301         }
1302         return (error);
1303 }
1304
1305 #ifdef COMPAT_FREEBSD4
1306 int
1307 freebsd4_freebsd32_statfs(struct thread *td, struct freebsd4_freebsd32_statfs_args *uap)
1308 {
1309         struct statfs32 s32;
1310         struct statfs s;
1311         int error;
1312
1313         error = kern_statfs(td, uap->path, UIO_USERSPACE, &s);
1314         if (error)
1315                 return (error);
1316         copy_statfs(&s, &s32);
1317         return (copyout(&s32, uap->buf, sizeof(s32)));
1318 }
1319 #endif
1320
1321 #ifdef COMPAT_FREEBSD4
1322 int
1323 freebsd4_freebsd32_fstatfs(struct thread *td, struct freebsd4_freebsd32_fstatfs_args *uap)
1324 {
1325         struct statfs32 s32;
1326         struct statfs s;
1327         int error;
1328
1329         error = kern_fstatfs(td, uap->fd, &s);
1330         if (error)
1331                 return (error);
1332         copy_statfs(&s, &s32);
1333         return (copyout(&s32, uap->buf, sizeof(s32)));
1334 }
1335 #endif
1336
1337 #ifdef COMPAT_FREEBSD4
1338 int
1339 freebsd4_freebsd32_fhstatfs(struct thread *td, struct freebsd4_freebsd32_fhstatfs_args *uap)
1340 {
1341         struct statfs32 s32;
1342         struct statfs s;
1343         fhandle_t fh;
1344         int error;
1345
1346         if ((error = copyin(uap->u_fhp, &fh, sizeof(fhandle_t))) != 0)
1347                 return (error);
1348         error = kern_fhstatfs(td, fh, &s);
1349         if (error)
1350                 return (error);
1351         copy_statfs(&s, &s32);
1352         return (copyout(&s32, uap->buf, sizeof(s32)));
1353 }
1354 #endif
1355
1356 #if defined(COMPAT_FREEBSD4) || defined(COMPAT_FREEBSD5) || \
1357     defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD7)
1358 static void
1359 freebsd32_ipcperm_old_in(struct ipc_perm32_old *ip32, struct ipc_perm *ip)
1360 {
1361
1362         CP(*ip32, *ip, cuid);
1363         CP(*ip32, *ip, cgid);
1364         CP(*ip32, *ip, uid);
1365         CP(*ip32, *ip, gid);
1366         CP(*ip32, *ip, mode);
1367         CP(*ip32, *ip, seq);
1368         CP(*ip32, *ip, key);
1369 }
1370
1371 static void
1372 freebsd32_ipcperm_old_out(struct ipc_perm *ip, struct ipc_perm32_old *ip32)
1373 {
1374
1375         CP(*ip, *ip32, cuid);
1376         CP(*ip, *ip32, cgid);
1377         CP(*ip, *ip32, uid);
1378         CP(*ip, *ip32, gid);
1379         CP(*ip, *ip32, mode);
1380         CP(*ip, *ip32, seq);
1381         CP(*ip, *ip32, key);
1382 }
1383 #endif
1384
1385 static void
1386 freebsd32_ipcperm_in(struct ipc_perm32 *ip32, struct ipc_perm *ip)
1387 {
1388
1389         CP(*ip32, *ip, cuid);
1390         CP(*ip32, *ip, cgid);
1391         CP(*ip32, *ip, uid);
1392         CP(*ip32, *ip, gid);
1393         CP(*ip32, *ip, mode);
1394         CP(*ip32, *ip, seq);
1395         CP(*ip32, *ip, key);
1396 }
1397
1398 static void
1399 freebsd32_ipcperm_out(struct ipc_perm *ip, struct ipc_perm32 *ip32)
1400 {
1401
1402         CP(*ip, *ip32, cuid);
1403         CP(*ip, *ip32, cgid);
1404         CP(*ip, *ip32, uid);
1405         CP(*ip, *ip32, gid);
1406         CP(*ip, *ip32, mode);
1407         CP(*ip, *ip32, seq);
1408         CP(*ip, *ip32, key);
1409 }
1410
1411 int
1412 freebsd32_semsys(struct thread *td, struct freebsd32_semsys_args *uap)
1413 {
1414
1415 #if defined(COMPAT_FREEBSD4) || defined(COMPAT_FREEBSD5) || \
1416     defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD7)
1417         switch (uap->which) {
1418         case 0:
1419                 return (freebsd7_freebsd32_semctl(td,
1420                     (struct freebsd7_freebsd32_semctl_args *)&uap->a2));
1421         default:
1422                 return (semsys(td, (struct semsys_args *)uap));
1423         }
1424 #else
1425         return (nosys(td, NULL));
1426 #endif
1427 }
1428
1429 #if defined(COMPAT_FREEBSD4) || defined(COMPAT_FREEBSD5) || \
1430     defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD7)
1431 int
1432 freebsd7_freebsd32_semctl(struct thread *td,
1433     struct freebsd7_freebsd32_semctl_args *uap)
1434 {
1435         struct semid_ds32_old dsbuf32;
1436         struct semid_ds dsbuf;
1437         union semun semun;
1438         union semun32 arg;
1439         register_t rval;
1440         int error;
1441
1442         switch (uap->cmd) {
1443         case SEM_STAT:
1444         case IPC_SET:
1445         case IPC_STAT:
1446         case GETALL:
1447         case SETVAL:
1448         case SETALL:
1449                 error = copyin(uap->arg, &arg, sizeof(arg));
1450                 if (error)
1451                         return (error);
1452                 break;
1453         }
1454
1455         switch (uap->cmd) {
1456         case SEM_STAT:
1457         case IPC_STAT:
1458                 semun.buf = &dsbuf;
1459                 break;
1460         case IPC_SET:
1461                 error = copyin(PTRIN(arg.buf), &dsbuf32, sizeof(dsbuf32));
1462                 if (error)
1463                         return (error);
1464                 freebsd32_ipcperm_old_in(&dsbuf32.sem_perm, &dsbuf.sem_perm);
1465                 PTRIN_CP(dsbuf32, dsbuf, sem_base);
1466                 CP(dsbuf32, dsbuf, sem_nsems);
1467                 CP(dsbuf32, dsbuf, sem_otime);
1468                 CP(dsbuf32, dsbuf, sem_ctime);
1469                 semun.buf = &dsbuf;
1470                 break;
1471         case GETALL:
1472         case SETALL:
1473                 semun.array = PTRIN(arg.array);
1474                 break;
1475         case SETVAL:
1476                 semun.val = arg.val;
1477                 break;
1478         }
1479
1480         error = kern_semctl(td, uap->semid, uap->semnum, uap->cmd, &semun,
1481             &rval);
1482         if (error)
1483                 return (error);
1484
1485         switch (uap->cmd) {
1486         case SEM_STAT:
1487         case IPC_STAT:
1488                 bzero(&dsbuf32, sizeof(dsbuf32));
1489                 freebsd32_ipcperm_old_out(&dsbuf.sem_perm, &dsbuf32.sem_perm);
1490                 PTROUT_CP(dsbuf, dsbuf32, sem_base);
1491                 CP(dsbuf, dsbuf32, sem_nsems);
1492                 CP(dsbuf, dsbuf32, sem_otime);
1493                 CP(dsbuf, dsbuf32, sem_ctime);
1494                 error = copyout(&dsbuf32, PTRIN(arg.buf), sizeof(dsbuf32));
1495                 break;
1496         }
1497
1498         if (error == 0)
1499                 td->td_retval[0] = rval;
1500         return (error);
1501 }
1502 #endif
1503
1504 int
1505 freebsd32_semctl(struct thread *td, struct freebsd32_semctl_args *uap)
1506 {
1507         struct semid_ds32 dsbuf32;
1508         struct semid_ds dsbuf;
1509         union semun semun;
1510         union semun32 arg;
1511         register_t rval;
1512         int error;
1513
1514         switch (uap->cmd) {
1515         case SEM_STAT:
1516         case IPC_SET:
1517         case IPC_STAT:
1518         case GETALL:
1519         case SETVAL:
1520         case SETALL:
1521                 error = copyin(uap->arg, &arg, sizeof(arg));
1522                 if (error)
1523                         return (error);
1524                 break;
1525         }
1526
1527         switch (uap->cmd) {
1528         case SEM_STAT:
1529         case IPC_STAT:
1530                 semun.buf = &dsbuf;
1531                 break;
1532         case IPC_SET:
1533                 error = copyin(PTRIN(arg.buf), &dsbuf32, sizeof(dsbuf32));
1534                 if (error)
1535                         return (error);
1536                 freebsd32_ipcperm_in(&dsbuf32.sem_perm, &dsbuf.sem_perm);
1537                 PTRIN_CP(dsbuf32, dsbuf, sem_base);
1538                 CP(dsbuf32, dsbuf, sem_nsems);
1539                 CP(dsbuf32, dsbuf, sem_otime);
1540                 CP(dsbuf32, dsbuf, sem_ctime);
1541                 semun.buf = &dsbuf;
1542                 break;
1543         case GETALL:
1544         case SETALL:
1545                 semun.array = PTRIN(arg.array);
1546                 break;
1547         case SETVAL:
1548                 semun.val = arg.val;
1549                 break;
1550         }
1551
1552         error = kern_semctl(td, uap->semid, uap->semnum, uap->cmd, &semun,
1553             &rval);
1554         if (error)
1555                 return (error);
1556
1557         switch (uap->cmd) {
1558         case SEM_STAT:
1559         case IPC_STAT:
1560                 bzero(&dsbuf32, sizeof(dsbuf32));
1561                 freebsd32_ipcperm_out(&dsbuf.sem_perm, &dsbuf32.sem_perm);
1562                 PTROUT_CP(dsbuf, dsbuf32, sem_base);
1563                 CP(dsbuf, dsbuf32, sem_nsems);
1564                 CP(dsbuf, dsbuf32, sem_otime);
1565                 CP(dsbuf, dsbuf32, sem_ctime);
1566                 error = copyout(&dsbuf32, PTRIN(arg.buf), sizeof(dsbuf32));
1567                 break;
1568         }
1569
1570         if (error == 0)
1571                 td->td_retval[0] = rval;
1572         return (error);
1573 }
1574
1575 int
1576 freebsd32_msgsys(struct thread *td, struct freebsd32_msgsys_args *uap)
1577 {
1578
1579 #if defined(COMPAT_FREEBSD4) || defined(COMPAT_FREEBSD5) || \
1580     defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD7)
1581         switch (uap->which) {
1582         case 0:
1583                 return (freebsd7_freebsd32_msgctl(td,
1584                     (struct freebsd7_freebsd32_msgctl_args *)&uap->a2));
1585         case 2:
1586                 return (freebsd32_msgsnd(td,
1587                     (struct freebsd32_msgsnd_args *)&uap->a2));
1588         case 3:
1589                 return (freebsd32_msgrcv(td,
1590                     (struct freebsd32_msgrcv_args *)&uap->a2));
1591         default:
1592                 return (msgsys(td, (struct msgsys_args *)uap));
1593         }
1594 #else
1595         return (nosys(td, NULL));
1596 #endif
1597 }
1598
1599 #if defined(COMPAT_FREEBSD4) || defined(COMPAT_FREEBSD5) || \
1600     defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD7)
1601 int
1602 freebsd7_freebsd32_msgctl(struct thread *td,
1603     struct freebsd7_freebsd32_msgctl_args *uap)
1604 {
1605         struct msqid_ds msqbuf;
1606         struct msqid_ds32_old msqbuf32;
1607         int error;
1608
1609         if (uap->cmd == IPC_SET) {
1610                 error = copyin(uap->buf, &msqbuf32, sizeof(msqbuf32));
1611                 if (error)
1612                         return (error);
1613                 freebsd32_ipcperm_old_in(&msqbuf32.msg_perm, &msqbuf.msg_perm);
1614                 PTRIN_CP(msqbuf32, msqbuf, msg_first);
1615                 PTRIN_CP(msqbuf32, msqbuf, msg_last);
1616                 CP(msqbuf32, msqbuf, msg_cbytes);
1617                 CP(msqbuf32, msqbuf, msg_qnum);
1618                 CP(msqbuf32, msqbuf, msg_qbytes);
1619                 CP(msqbuf32, msqbuf, msg_lspid);
1620                 CP(msqbuf32, msqbuf, msg_lrpid);
1621                 CP(msqbuf32, msqbuf, msg_stime);
1622                 CP(msqbuf32, msqbuf, msg_rtime);
1623                 CP(msqbuf32, msqbuf, msg_ctime);
1624         }
1625         error = kern_msgctl(td, uap->msqid, uap->cmd, &msqbuf);
1626         if (error)
1627                 return (error);
1628         if (uap->cmd == IPC_STAT) {
1629                 bzero(&msqbuf32, sizeof(msqbuf32));
1630                 freebsd32_ipcperm_old_out(&msqbuf.msg_perm, &msqbuf32.msg_perm);
1631                 PTROUT_CP(msqbuf, msqbuf32, msg_first);
1632                 PTROUT_CP(msqbuf, msqbuf32, msg_last);
1633                 CP(msqbuf, msqbuf32, msg_cbytes);
1634                 CP(msqbuf, msqbuf32, msg_qnum);
1635                 CP(msqbuf, msqbuf32, msg_qbytes);
1636                 CP(msqbuf, msqbuf32, msg_lspid);
1637                 CP(msqbuf, msqbuf32, msg_lrpid);
1638                 CP(msqbuf, msqbuf32, msg_stime);
1639                 CP(msqbuf, msqbuf32, msg_rtime);
1640                 CP(msqbuf, msqbuf32, msg_ctime);
1641                 error = copyout(&msqbuf32, uap->buf, sizeof(struct msqid_ds32));
1642         }
1643         return (error);
1644 }
1645 #endif
1646
1647 int
1648 freebsd32_msgctl(struct thread *td, struct freebsd32_msgctl_args *uap)
1649 {
1650         struct msqid_ds msqbuf;
1651         struct msqid_ds32 msqbuf32;
1652         int error;
1653
1654         if (uap->cmd == IPC_SET) {
1655                 error = copyin(uap->buf, &msqbuf32, sizeof(msqbuf32));
1656                 if (error)
1657                         return (error);
1658                 freebsd32_ipcperm_in(&msqbuf32.msg_perm, &msqbuf.msg_perm);
1659                 PTRIN_CP(msqbuf32, msqbuf, msg_first);
1660                 PTRIN_CP(msqbuf32, msqbuf, msg_last);
1661                 CP(msqbuf32, msqbuf, msg_cbytes);
1662                 CP(msqbuf32, msqbuf, msg_qnum);
1663                 CP(msqbuf32, msqbuf, msg_qbytes);
1664                 CP(msqbuf32, msqbuf, msg_lspid);
1665                 CP(msqbuf32, msqbuf, msg_lrpid);
1666                 CP(msqbuf32, msqbuf, msg_stime);
1667                 CP(msqbuf32, msqbuf, msg_rtime);
1668                 CP(msqbuf32, msqbuf, msg_ctime);
1669         }
1670         error = kern_msgctl(td, uap->msqid, uap->cmd, &msqbuf);
1671         if (error)
1672                 return (error);
1673         if (uap->cmd == IPC_STAT) {
1674                 freebsd32_ipcperm_out(&msqbuf.msg_perm, &msqbuf32.msg_perm);
1675                 PTROUT_CP(msqbuf, msqbuf32, msg_first);
1676                 PTROUT_CP(msqbuf, msqbuf32, msg_last);
1677                 CP(msqbuf, msqbuf32, msg_cbytes);
1678                 CP(msqbuf, msqbuf32, msg_qnum);
1679                 CP(msqbuf, msqbuf32, msg_qbytes);
1680                 CP(msqbuf, msqbuf32, msg_lspid);
1681                 CP(msqbuf, msqbuf32, msg_lrpid);
1682                 CP(msqbuf, msqbuf32, msg_stime);
1683                 CP(msqbuf, msqbuf32, msg_rtime);
1684                 CP(msqbuf, msqbuf32, msg_ctime);
1685                 error = copyout(&msqbuf32, uap->buf, sizeof(struct msqid_ds32));
1686         }
1687         return (error);
1688 }
1689
1690 int
1691 freebsd32_msgsnd(struct thread *td, struct freebsd32_msgsnd_args *uap)
1692 {
1693         const void *msgp;
1694         long mtype;
1695         int32_t mtype32;
1696         int error;
1697
1698         msgp = PTRIN(uap->msgp);
1699         if ((error = copyin(msgp, &mtype32, sizeof(mtype32))) != 0)
1700                 return (error);
1701         mtype = mtype32;
1702         return (kern_msgsnd(td, uap->msqid,
1703             (const char *)msgp + sizeof(mtype32),
1704             uap->msgsz, uap->msgflg, mtype));
1705 }
1706
1707 int
1708 freebsd32_msgrcv(struct thread *td, struct freebsd32_msgrcv_args *uap)
1709 {
1710         void *msgp;
1711         long mtype;
1712         int32_t mtype32;
1713         int error;
1714
1715         msgp = PTRIN(uap->msgp);
1716         if ((error = kern_msgrcv(td, uap->msqid,
1717             (char *)msgp + sizeof(mtype32), uap->msgsz,
1718             uap->msgtyp, uap->msgflg, &mtype)) != 0)
1719                 return (error);
1720         mtype32 = (int32_t)mtype;
1721         return (copyout(&mtype32, msgp, sizeof(mtype32)));
1722 }
1723
1724 int
1725 freebsd32_shmsys(struct thread *td, struct freebsd32_shmsys_args *uap)
1726 {
1727
1728 #if defined(COMPAT_FREEBSD4) || defined(COMPAT_FREEBSD5) || \
1729     defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD7)
1730         switch (uap->which) {
1731         case 0: {       /* shmat */
1732                 struct shmat_args ap;
1733
1734                 ap.shmid = uap->a2;
1735                 ap.shmaddr = PTRIN(uap->a3);
1736                 ap.shmflg = uap->a4;
1737                 return (sysent[SYS_shmat].sy_call(td, &ap));
1738         }
1739         case 2: {       /* shmdt */
1740                 struct shmdt_args ap;
1741
1742                 ap.shmaddr = PTRIN(uap->a2);
1743                 return (sysent[SYS_shmdt].sy_call(td, &ap));
1744         }
1745         case 3: {       /* shmget */
1746                 struct shmget_args ap;
1747
1748                 ap.key = uap->a2;
1749                 ap.size = uap->a3;
1750                 ap.shmflg = uap->a4;
1751                 return (sysent[SYS_shmget].sy_call(td, &ap));
1752         }
1753         case 4: {       /* shmctl */
1754                 struct freebsd7_freebsd32_shmctl_args ap;
1755
1756                 ap.shmid = uap->a2;
1757                 ap.cmd = uap->a3;
1758                 ap.buf = PTRIN(uap->a4);
1759                 return (freebsd7_freebsd32_shmctl(td, &ap));
1760         }
1761         case 1:         /* oshmctl */
1762         default:
1763                 return (EINVAL);
1764         }
1765 #else
1766         return (nosys(td, NULL));
1767 #endif
1768 }
1769
1770 #if defined(COMPAT_FREEBSD4) || defined(COMPAT_FREEBSD5) || \
1771     defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD7)
1772 int
1773 freebsd7_freebsd32_shmctl(struct thread *td,
1774     struct freebsd7_freebsd32_shmctl_args *uap)
1775 {
1776         int error = 0;
1777         union {
1778                 struct shmid_ds shmid_ds;
1779                 struct shm_info shm_info;
1780                 struct shminfo shminfo;
1781         } u;
1782         union {
1783                 struct shmid_ds32_old shmid_ds32;
1784                 struct shm_info32 shm_info32;
1785                 struct shminfo32 shminfo32;
1786         } u32;
1787         size_t sz;
1788
1789         if (uap->cmd == IPC_SET) {
1790                 if ((error = copyin(uap->buf, &u32.shmid_ds32,
1791                     sizeof(u32.shmid_ds32))))
1792                         goto done;
1793                 freebsd32_ipcperm_old_in(&u32.shmid_ds32.shm_perm,
1794                     &u.shmid_ds.shm_perm);
1795                 CP(u32.shmid_ds32, u.shmid_ds, shm_segsz);
1796                 CP(u32.shmid_ds32, u.shmid_ds, shm_lpid);
1797                 CP(u32.shmid_ds32, u.shmid_ds, shm_cpid);
1798                 CP(u32.shmid_ds32, u.shmid_ds, shm_nattch);
1799                 CP(u32.shmid_ds32, u.shmid_ds, shm_atime);
1800                 CP(u32.shmid_ds32, u.shmid_ds, shm_dtime);
1801                 CP(u32.shmid_ds32, u.shmid_ds, shm_ctime);
1802         }
1803
1804         error = kern_shmctl(td, uap->shmid, uap->cmd, (void *)&u, &sz);
1805         if (error)
1806                 goto done;
1807
1808         /* Cases in which we need to copyout */
1809         switch (uap->cmd) {
1810         case IPC_INFO:
1811                 CP(u.shminfo, u32.shminfo32, shmmax);
1812                 CP(u.shminfo, u32.shminfo32, shmmin);
1813                 CP(u.shminfo, u32.shminfo32, shmmni);
1814                 CP(u.shminfo, u32.shminfo32, shmseg);
1815                 CP(u.shminfo, u32.shminfo32, shmall);
1816                 error = copyout(&u32.shminfo32, uap->buf,
1817                     sizeof(u32.shminfo32));
1818                 break;
1819         case SHM_INFO:
1820                 CP(u.shm_info, u32.shm_info32, used_ids);
1821                 CP(u.shm_info, u32.shm_info32, shm_rss);
1822                 CP(u.shm_info, u32.shm_info32, shm_tot);
1823                 CP(u.shm_info, u32.shm_info32, shm_swp);
1824                 CP(u.shm_info, u32.shm_info32, swap_attempts);
1825                 CP(u.shm_info, u32.shm_info32, swap_successes);
1826                 error = copyout(&u32.shm_info32, uap->buf,
1827                     sizeof(u32.shm_info32));
1828                 break;
1829         case SHM_STAT:
1830         case IPC_STAT:
1831                 freebsd32_ipcperm_old_out(&u.shmid_ds.shm_perm,
1832                     &u32.shmid_ds32.shm_perm);
1833                 if (u.shmid_ds.shm_segsz > INT32_MAX)
1834                         u32.shmid_ds32.shm_segsz = INT32_MAX;
1835                 else
1836                         CP(u.shmid_ds, u32.shmid_ds32, shm_segsz);
1837                 CP(u.shmid_ds, u32.shmid_ds32, shm_lpid);
1838                 CP(u.shmid_ds, u32.shmid_ds32, shm_cpid);
1839                 CP(u.shmid_ds, u32.shmid_ds32, shm_nattch);
1840                 CP(u.shmid_ds, u32.shmid_ds32, shm_atime);
1841                 CP(u.shmid_ds, u32.shmid_ds32, shm_dtime);
1842                 CP(u.shmid_ds, u32.shmid_ds32, shm_ctime);
1843                 u32.shmid_ds32.shm_internal = 0;
1844                 error = copyout(&u32.shmid_ds32, uap->buf,
1845                     sizeof(u32.shmid_ds32));
1846                 break;
1847         }
1848
1849 done:
1850         if (error) {
1851                 /* Invalidate the return value */
1852                 td->td_retval[0] = -1;
1853         }
1854         return (error);
1855 }
1856 #endif
1857
1858 int
1859 freebsd32_shmctl(struct thread *td, struct freebsd32_shmctl_args *uap)
1860 {
1861         int error = 0;
1862         union {
1863                 struct shmid_ds shmid_ds;
1864                 struct shm_info shm_info;
1865                 struct shminfo shminfo;
1866         } u;
1867         union {
1868                 struct shmid_ds32 shmid_ds32;
1869                 struct shm_info32 shm_info32;
1870                 struct shminfo32 shminfo32;
1871         } u32;
1872         size_t sz;
1873
1874         if (uap->cmd == IPC_SET) {
1875                 if ((error = copyin(uap->buf, &u32.shmid_ds32,
1876                     sizeof(u32.shmid_ds32))))
1877                         goto done;
1878                 freebsd32_ipcperm_in(&u32.shmid_ds32.shm_perm,
1879                     &u.shmid_ds.shm_perm);
1880                 CP(u32.shmid_ds32, u.shmid_ds, shm_segsz);
1881                 CP(u32.shmid_ds32, u.shmid_ds, shm_lpid);
1882                 CP(u32.shmid_ds32, u.shmid_ds, shm_cpid);
1883                 CP(u32.shmid_ds32, u.shmid_ds, shm_nattch);
1884                 CP(u32.shmid_ds32, u.shmid_ds, shm_atime);
1885                 CP(u32.shmid_ds32, u.shmid_ds, shm_dtime);
1886                 CP(u32.shmid_ds32, u.shmid_ds, shm_ctime);
1887         }
1888
1889         error = kern_shmctl(td, uap->shmid, uap->cmd, (void *)&u, &sz);
1890         if (error)
1891                 goto done;
1892
1893         /* Cases in which we need to copyout */
1894         switch (uap->cmd) {
1895         case IPC_INFO:
1896                 CP(u.shminfo, u32.shminfo32, shmmax);
1897                 CP(u.shminfo, u32.shminfo32, shmmin);
1898                 CP(u.shminfo, u32.shminfo32, shmmni);
1899                 CP(u.shminfo, u32.shminfo32, shmseg);
1900                 CP(u.shminfo, u32.shminfo32, shmall);
1901                 error = copyout(&u32.shminfo32, uap->buf,
1902                     sizeof(u32.shminfo32));
1903                 break;
1904         case SHM_INFO:
1905                 CP(u.shm_info, u32.shm_info32, used_ids);
1906                 CP(u.shm_info, u32.shm_info32, shm_rss);
1907                 CP(u.shm_info, u32.shm_info32, shm_tot);
1908                 CP(u.shm_info, u32.shm_info32, shm_swp);
1909                 CP(u.shm_info, u32.shm_info32, swap_attempts);
1910                 CP(u.shm_info, u32.shm_info32, swap_successes);
1911                 error = copyout(&u32.shm_info32, uap->buf,
1912                     sizeof(u32.shm_info32));
1913                 break;
1914         case SHM_STAT:
1915         case IPC_STAT:
1916                 freebsd32_ipcperm_out(&u.shmid_ds.shm_perm,
1917                     &u32.shmid_ds32.shm_perm);
1918                 if (u.shmid_ds.shm_segsz > INT32_MAX)
1919                         u32.shmid_ds32.shm_segsz = INT32_MAX;
1920                 else
1921                         CP(u.shmid_ds, u32.shmid_ds32, shm_segsz);
1922                 CP(u.shmid_ds, u32.shmid_ds32, shm_lpid);
1923                 CP(u.shmid_ds, u32.shmid_ds32, shm_cpid);
1924                 CP(u.shmid_ds, u32.shmid_ds32, shm_nattch);
1925                 CP(u.shmid_ds, u32.shmid_ds32, shm_atime);
1926                 CP(u.shmid_ds, u32.shmid_ds32, shm_dtime);
1927                 CP(u.shmid_ds, u32.shmid_ds32, shm_ctime);
1928                 error = copyout(&u32.shmid_ds32, uap->buf,
1929                     sizeof(u32.shmid_ds32));
1930                 break;
1931         }
1932
1933 done:
1934         if (error) {
1935                 /* Invalidate the return value */
1936                 td->td_retval[0] = -1;
1937         }
1938         return (error);
1939 }
1940
1941 int
1942 freebsd32_pread(struct thread *td, struct freebsd32_pread_args *uap)
1943 {
1944         struct pread_args ap;
1945
1946         ap.fd = uap->fd;
1947         ap.buf = uap->buf;
1948         ap.nbyte = uap->nbyte;
1949         ap.offset = (uap->offsetlo | ((off_t)uap->offsethi << 32));
1950         return (pread(td, &ap));
1951 }
1952
1953 int
1954 freebsd32_pwrite(struct thread *td, struct freebsd32_pwrite_args *uap)
1955 {
1956         struct pwrite_args ap;
1957
1958         ap.fd = uap->fd;
1959         ap.buf = uap->buf;
1960         ap.nbyte = uap->nbyte;
1961         ap.offset = (uap->offsetlo | ((off_t)uap->offsethi << 32));
1962         return (pwrite(td, &ap));
1963 }
1964
1965 int
1966 freebsd32_lseek(struct thread *td, struct freebsd32_lseek_args *uap)
1967 {
1968         int error;
1969         struct lseek_args ap;
1970         off_t pos;
1971
1972         ap.fd = uap->fd;
1973         ap.offset = (uap->offsetlo | ((off_t)uap->offsethi << 32));
1974         ap.whence = uap->whence;
1975         error = lseek(td, &ap);
1976         /* Expand the quad return into two parts for eax and edx */
1977         pos = *(off_t *)(td->td_retval);
1978         td->td_retval[0] = pos & 0xffffffff;    /* %eax */
1979         td->td_retval[1] = pos >> 32;           /* %edx */
1980         return error;
1981 }
1982
1983 int
1984 freebsd32_truncate(struct thread *td, struct freebsd32_truncate_args *uap)
1985 {
1986         struct truncate_args ap;
1987
1988         ap.path = uap->path;
1989         ap.length = (uap->lengthlo | ((off_t)uap->lengthhi << 32));
1990         return (truncate(td, &ap));
1991 }
1992
1993 int
1994 freebsd32_ftruncate(struct thread *td, struct freebsd32_ftruncate_args *uap)
1995 {
1996         struct ftruncate_args ap;
1997
1998         ap.fd = uap->fd;
1999         ap.length = (uap->lengthlo | ((off_t)uap->lengthhi << 32));
2000         return (ftruncate(td, &ap));
2001 }
2002
2003 int
2004 freebsd32_getdirentries(struct thread *td,
2005     struct freebsd32_getdirentries_args *uap)
2006 {
2007         long base;
2008         int32_t base32;
2009         int error;
2010
2011         error = kern_getdirentries(td, uap->fd, uap->buf, uap->count, &base);
2012         if (error)
2013                 return (error);
2014         if (uap->basep != NULL) {
2015                 base32 = base;
2016                 error = copyout(&base32, uap->basep, sizeof(int32_t));
2017         }
2018         return (error);
2019 }
2020
2021 #ifdef COMPAT_FREEBSD6
2022 /* versions with the 'int pad' argument */
2023 int
2024 freebsd6_freebsd32_pread(struct thread *td, struct freebsd6_freebsd32_pread_args *uap)
2025 {
2026         struct pread_args ap;
2027
2028         ap.fd = uap->fd;
2029         ap.buf = uap->buf;
2030         ap.nbyte = uap->nbyte;
2031         ap.offset = (uap->offsetlo | ((off_t)uap->offsethi << 32));
2032         return (pread(td, &ap));
2033 }
2034
2035 int
2036 freebsd6_freebsd32_pwrite(struct thread *td, struct freebsd6_freebsd32_pwrite_args *uap)
2037 {
2038         struct pwrite_args ap;
2039
2040         ap.fd = uap->fd;
2041         ap.buf = uap->buf;
2042         ap.nbyte = uap->nbyte;
2043         ap.offset = (uap->offsetlo | ((off_t)uap->offsethi << 32));
2044         return (pwrite(td, &ap));
2045 }
2046
2047 int
2048 freebsd6_freebsd32_lseek(struct thread *td, struct freebsd6_freebsd32_lseek_args *uap)
2049 {
2050         int error;
2051         struct lseek_args ap;
2052         off_t pos;
2053
2054         ap.fd = uap->fd;
2055         ap.offset = (uap->offsetlo | ((off_t)uap->offsethi << 32));
2056         ap.whence = uap->whence;
2057         error = lseek(td, &ap);
2058         /* Expand the quad return into two parts for eax and edx */
2059         pos = *(off_t *)(td->td_retval);
2060         td->td_retval[0] = pos & 0xffffffff;    /* %eax */
2061         td->td_retval[1] = pos >> 32;           /* %edx */
2062         return error;
2063 }
2064
2065 int
2066 freebsd6_freebsd32_truncate(struct thread *td, struct freebsd6_freebsd32_truncate_args *uap)
2067 {
2068         struct truncate_args ap;
2069
2070         ap.path = uap->path;
2071         ap.length = (uap->lengthlo | ((off_t)uap->lengthhi << 32));
2072         return (truncate(td, &ap));
2073 }
2074
2075 int
2076 freebsd6_freebsd32_ftruncate(struct thread *td, struct freebsd6_freebsd32_ftruncate_args *uap)
2077 {
2078         struct ftruncate_args ap;
2079
2080         ap.fd = uap->fd;
2081         ap.length = (uap->lengthlo | ((off_t)uap->lengthhi << 32));
2082         return (ftruncate(td, &ap));
2083 }
2084 #endif /* COMPAT_FREEBSD6 */
2085
2086 struct sf_hdtr32 {
2087         uint32_t headers;
2088         int hdr_cnt;
2089         uint32_t trailers;
2090         int trl_cnt;
2091 };
2092
2093 static int
2094 freebsd32_do_sendfile(struct thread *td,
2095     struct freebsd32_sendfile_args *uap, int compat)
2096 {
2097         struct sendfile_args ap;
2098         struct sf_hdtr32 hdtr32;
2099         struct sf_hdtr hdtr;
2100         struct uio *hdr_uio, *trl_uio;
2101         struct iovec32 *iov32;
2102         int error;
2103
2104         hdr_uio = trl_uio = NULL;
2105
2106         ap.fd = uap->fd;
2107         ap.s = uap->s;
2108         ap.offset = (uap->offsetlo | ((off_t)uap->offsethi << 32));
2109         ap.nbytes = uap->nbytes;
2110         ap.hdtr = (struct sf_hdtr *)uap->hdtr;          /* XXX not used */
2111         ap.sbytes = uap->sbytes;
2112         ap.flags = uap->flags;
2113
2114         if (uap->hdtr != NULL) {
2115                 error = copyin(uap->hdtr, &hdtr32, sizeof(hdtr32));
2116                 if (error)
2117                         goto out;
2118                 PTRIN_CP(hdtr32, hdtr, headers);
2119                 CP(hdtr32, hdtr, hdr_cnt);
2120                 PTRIN_CP(hdtr32, hdtr, trailers);
2121                 CP(hdtr32, hdtr, trl_cnt);
2122
2123                 if (hdtr.headers != NULL) {
2124                         iov32 = PTRIN(hdtr32.headers);
2125                         error = freebsd32_copyinuio(iov32,
2126                             hdtr32.hdr_cnt, &hdr_uio);
2127                         if (error)
2128                                 goto out;
2129                 }
2130                 if (hdtr.trailers != NULL) {
2131                         iov32 = PTRIN(hdtr32.trailers);
2132                         error = freebsd32_copyinuio(iov32,
2133                             hdtr32.trl_cnt, &trl_uio);
2134                         if (error)
2135                                 goto out;
2136                 }
2137         }
2138
2139         error = kern_sendfile(td, &ap, hdr_uio, trl_uio, compat);
2140 out:
2141         if (hdr_uio)
2142                 free(hdr_uio, M_IOV);
2143         if (trl_uio)
2144                 free(trl_uio, M_IOV);
2145         return (error);
2146 }
2147
2148 #ifdef COMPAT_FREEBSD4
2149 int
2150 freebsd4_freebsd32_sendfile(struct thread *td,
2151     struct freebsd4_freebsd32_sendfile_args *uap)
2152 {
2153         return (freebsd32_do_sendfile(td,
2154             (struct freebsd32_sendfile_args *)uap, 1));
2155 }
2156 #endif
2157
2158 int
2159 freebsd32_sendfile(struct thread *td, struct freebsd32_sendfile_args *uap)
2160 {
2161
2162         return (freebsd32_do_sendfile(td, uap, 0));
2163 }
2164
2165 static void
2166 copy_stat( struct stat *in, struct stat32 *out)
2167 {
2168         CP(*in, *out, st_dev);
2169         CP(*in, *out, st_ino);
2170         CP(*in, *out, st_mode);
2171         CP(*in, *out, st_nlink);
2172         CP(*in, *out, st_uid);
2173         CP(*in, *out, st_gid);
2174         CP(*in, *out, st_rdev);
2175         TS_CP(*in, *out, st_atimespec);
2176         TS_CP(*in, *out, st_mtimespec);
2177         TS_CP(*in, *out, st_ctimespec);
2178         CP(*in, *out, st_size);
2179         CP(*in, *out, st_blocks);
2180         CP(*in, *out, st_blksize);
2181         CP(*in, *out, st_flags);
2182         CP(*in, *out, st_gen);
2183 }
2184
2185 int
2186 freebsd32_stat(struct thread *td, struct freebsd32_stat_args *uap)
2187 {
2188         struct stat sb;
2189         struct stat32 sb32;
2190         int error;
2191
2192         error = kern_stat(td, uap->path, UIO_USERSPACE, &sb);
2193         if (error)
2194                 return (error);
2195         copy_stat(&sb, &sb32);
2196         error = copyout(&sb32, uap->ub, sizeof (sb32));
2197         return (error);
2198 }
2199
2200 int
2201 freebsd32_fstat(struct thread *td, struct freebsd32_fstat_args *uap)
2202 {
2203         struct stat ub;
2204         struct stat32 ub32;
2205         int error;
2206
2207         error = kern_fstat(td, uap->fd, &ub);
2208         if (error)
2209                 return (error);
2210         copy_stat(&ub, &ub32);
2211         error = copyout(&ub32, uap->ub, sizeof(ub32));
2212         return (error);
2213 }
2214
2215 int
2216 freebsd32_fstatat(struct thread *td, struct freebsd32_fstatat_args *uap)
2217 {
2218         struct stat ub;
2219         struct stat32 ub32;
2220         int error;
2221
2222         error = kern_statat(td, uap->flag, uap->fd, uap->path, UIO_USERSPACE, &ub);
2223         if (error)
2224                 return (error);
2225         copy_stat(&ub, &ub32);
2226         error = copyout(&ub32, uap->buf, sizeof(ub32));
2227         return (error);
2228 }
2229
2230 int
2231 freebsd32_lstat(struct thread *td, struct freebsd32_lstat_args *uap)
2232 {
2233         struct stat sb;
2234         struct stat32 sb32;
2235         int error;
2236
2237         error = kern_lstat(td, uap->path, UIO_USERSPACE, &sb);
2238         if (error)
2239                 return (error);
2240         copy_stat(&sb, &sb32);
2241         error = copyout(&sb32, uap->ub, sizeof (sb32));
2242         return (error);
2243 }
2244
2245 /*
2246  * MPSAFE
2247  */
2248 int
2249 freebsd32_sysctl(struct thread *td, struct freebsd32_sysctl_args *uap)
2250 {
2251         int error, name[CTL_MAXNAME];
2252         size_t j, oldlen;
2253
2254         if (uap->namelen > CTL_MAXNAME || uap->namelen < 2)
2255                 return (EINVAL);
2256         error = copyin(uap->name, name, uap->namelen * sizeof(int));
2257         if (error)
2258                 return (error);
2259         if (uap->oldlenp)
2260                 oldlen = fuword32(uap->oldlenp);
2261         else
2262                 oldlen = 0;
2263         error = userland_sysctl(td, name, uap->namelen,
2264                 uap->old, &oldlen, 1,
2265                 uap->new, uap->newlen, &j, SCTL_MASK32);
2266         if (error && error != ENOMEM)
2267                 return (error);
2268         if (uap->oldlenp)
2269                 suword32(uap->oldlenp, j);
2270         return (0);
2271 }
2272
2273 int
2274 freebsd32_jail(struct thread *td, struct freebsd32_jail_args *uap)
2275 {
2276         uint32_t version;
2277         int error;
2278         struct jail j;
2279
2280         error = copyin(uap->jail, &version, sizeof(uint32_t));
2281         if (error)
2282                 return (error);
2283
2284         switch (version) {
2285         case 0:
2286         {
2287                 /* FreeBSD single IPv4 jails. */
2288                 struct jail32_v0 j32_v0;
2289
2290                 bzero(&j, sizeof(struct jail));
2291                 error = copyin(uap->jail, &j32_v0, sizeof(struct jail32_v0));
2292                 if (error)
2293                         return (error);
2294                 CP(j32_v0, j, version);
2295                 PTRIN_CP(j32_v0, j, path);
2296                 PTRIN_CP(j32_v0, j, hostname);
2297                 j.ip4s = j32_v0.ip_number;
2298                 break;
2299         }
2300
2301         case 1:
2302                 /*
2303                  * Version 1 was used by multi-IPv4 jail implementations
2304                  * that never made it into the official kernel.
2305                  */
2306                 return (EINVAL);
2307
2308         case 2: /* JAIL_API_VERSION */
2309         {
2310                 /* FreeBSD multi-IPv4/IPv6,noIP jails. */
2311                 struct jail32 j32;
2312
2313                 error = copyin(uap->jail, &j32, sizeof(struct jail32));
2314                 if (error)
2315                         return (error);
2316                 CP(j32, j, version);
2317                 PTRIN_CP(j32, j, path);
2318                 PTRIN_CP(j32, j, hostname);
2319                 PTRIN_CP(j32, j, jailname);
2320                 CP(j32, j, ip4s);
2321                 CP(j32, j, ip6s);
2322                 PTRIN_CP(j32, j, ip4);
2323                 PTRIN_CP(j32, j, ip6);
2324                 break;
2325         }
2326
2327         default:
2328                 /* Sci-Fi jails are not supported, sorry. */
2329                 return (EINVAL);
2330         }
2331         return (kern_jail(td, &j));
2332 }
2333
2334 int
2335 freebsd32_jail_set(struct thread *td, struct freebsd32_jail_set_args *uap)
2336 {
2337         struct uio *auio;
2338         int error;
2339
2340         /* Check that we have an even number of iovecs. */
2341         if (uap->iovcnt & 1)
2342                 return (EINVAL);
2343
2344         error = freebsd32_copyinuio(uap->iovp, uap->iovcnt, &auio);
2345         if (error)
2346                 return (error);
2347         error = kern_jail_set(td, auio, uap->flags);
2348         free(auio, M_IOV);
2349         return (error);
2350 }
2351
2352 int
2353 freebsd32_jail_get(struct thread *td, struct freebsd32_jail_get_args *uap)
2354 {
2355         struct iovec32 iov32;
2356         struct uio *auio;
2357         int error, i;
2358
2359         /* Check that we have an even number of iovecs. */
2360         if (uap->iovcnt & 1)
2361                 return (EINVAL);
2362
2363         error = freebsd32_copyinuio(uap->iovp, uap->iovcnt, &auio);
2364         if (error)
2365                 return (error);
2366         error = kern_jail_get(td, auio, uap->flags);
2367         if (error == 0)
2368                 for (i = 0; i < uap->iovcnt; i++) {
2369                         PTROUT_CP(auio->uio_iov[i], iov32, iov_base);
2370                         CP(auio->uio_iov[i], iov32, iov_len);
2371                         error = copyout(&iov32, uap->iovp + i, sizeof(iov32));
2372                         if (error != 0)
2373                                 break;
2374                 }
2375         free(auio, M_IOV);
2376         return (error);
2377 }
2378
2379 int
2380 freebsd32_sigaction(struct thread *td, struct freebsd32_sigaction_args *uap)
2381 {
2382         struct sigaction32 s32;
2383         struct sigaction sa, osa, *sap;
2384         int error;
2385
2386         if (uap->act) {
2387                 error = copyin(uap->act, &s32, sizeof(s32));
2388                 if (error)
2389                         return (error);
2390                 sa.sa_handler = PTRIN(s32.sa_u);
2391                 CP(s32, sa, sa_flags);
2392                 CP(s32, sa, sa_mask);
2393                 sap = &sa;
2394         } else
2395                 sap = NULL;
2396         error = kern_sigaction(td, uap->sig, sap, &osa, 0);
2397         if (error == 0 && uap->oact != NULL) {
2398                 s32.sa_u = PTROUT(osa.sa_handler);
2399                 CP(osa, s32, sa_flags);
2400                 CP(osa, s32, sa_mask);
2401                 error = copyout(&s32, uap->oact, sizeof(s32));
2402         }
2403         return (error);
2404 }
2405
2406 #ifdef COMPAT_FREEBSD4
2407 int
2408 freebsd4_freebsd32_sigaction(struct thread *td,
2409                              struct freebsd4_freebsd32_sigaction_args *uap)
2410 {
2411         struct sigaction32 s32;
2412         struct sigaction sa, osa, *sap;
2413         int error;
2414
2415         if (uap->act) {
2416                 error = copyin(uap->act, &s32, sizeof(s32));
2417                 if (error)
2418                         return (error);
2419                 sa.sa_handler = PTRIN(s32.sa_u);
2420                 CP(s32, sa, sa_flags);
2421                 CP(s32, sa, sa_mask);
2422                 sap = &sa;
2423         } else
2424                 sap = NULL;
2425         error = kern_sigaction(td, uap->sig, sap, &osa, KSA_FREEBSD4);
2426         if (error == 0 && uap->oact != NULL) {
2427                 s32.sa_u = PTROUT(osa.sa_handler);
2428                 CP(osa, s32, sa_flags);
2429                 CP(osa, s32, sa_mask);
2430                 error = copyout(&s32, uap->oact, sizeof(s32));
2431         }
2432         return (error);
2433 }
2434 #endif
2435
2436 #ifdef COMPAT_43
2437 struct osigaction32 {
2438         u_int32_t       sa_u;
2439         osigset_t       sa_mask;
2440         int             sa_flags;
2441 };
2442
2443 #define ONSIG   32
2444
2445 int
2446 ofreebsd32_sigaction(struct thread *td,
2447                              struct ofreebsd32_sigaction_args *uap)
2448 {
2449         struct osigaction32 s32;
2450         struct sigaction sa, osa, *sap;
2451         int error;
2452
2453         if (uap->signum <= 0 || uap->signum >= ONSIG)
2454                 return (EINVAL);
2455
2456         if (uap->nsa) {
2457                 error = copyin(uap->nsa, &s32, sizeof(s32));
2458                 if (error)
2459                         return (error);
2460                 sa.sa_handler = PTRIN(s32.sa_u);
2461                 CP(s32, sa, sa_flags);
2462                 OSIG2SIG(s32.sa_mask, sa.sa_mask);
2463                 sap = &sa;
2464         } else
2465                 sap = NULL;
2466         error = kern_sigaction(td, uap->signum, sap, &osa, KSA_OSIGSET);
2467         if (error == 0 && uap->osa != NULL) {
2468                 s32.sa_u = PTROUT(osa.sa_handler);
2469                 CP(osa, s32, sa_flags);
2470                 SIG2OSIG(osa.sa_mask, s32.sa_mask);
2471                 error = copyout(&s32, uap->osa, sizeof(s32));
2472         }
2473         return (error);
2474 }
2475
2476 int
2477 ofreebsd32_sigprocmask(struct thread *td,
2478                                struct ofreebsd32_sigprocmask_args *uap)
2479 {
2480         sigset_t set, oset;
2481         int error;
2482
2483         OSIG2SIG(uap->mask, set);
2484         error = kern_sigprocmask(td, uap->how, &set, &oset, 1);
2485         SIG2OSIG(oset, td->td_retval[0]);
2486         return (error);
2487 }
2488
2489 int
2490 ofreebsd32_sigpending(struct thread *td,
2491                               struct ofreebsd32_sigpending_args *uap)
2492 {
2493         struct proc *p = td->td_proc;
2494         sigset_t siglist;
2495
2496         PROC_LOCK(p);
2497         siglist = p->p_siglist;
2498         SIGSETOR(siglist, td->td_siglist);
2499         PROC_UNLOCK(p);
2500         SIG2OSIG(siglist, td->td_retval[0]);
2501         return (0);
2502 }
2503
2504 struct sigvec32 {
2505         u_int32_t       sv_handler;
2506         int             sv_mask;
2507         int             sv_flags;
2508 };
2509
2510 int
2511 ofreebsd32_sigvec(struct thread *td,
2512                           struct ofreebsd32_sigvec_args *uap)
2513 {
2514         struct sigvec32 vec;
2515         struct sigaction sa, osa, *sap;
2516         int error;
2517
2518         if (uap->signum <= 0 || uap->signum >= ONSIG)
2519                 return (EINVAL);
2520
2521         if (uap->nsv) {
2522                 error = copyin(uap->nsv, &vec, sizeof(vec));
2523                 if (error)
2524                         return (error);
2525                 sa.sa_handler = PTRIN(vec.sv_handler);
2526                 OSIG2SIG(vec.sv_mask, sa.sa_mask);
2527                 sa.sa_flags = vec.sv_flags;
2528                 sa.sa_flags ^= SA_RESTART;
2529                 sap = &sa;
2530         } else
2531                 sap = NULL;
2532         error = kern_sigaction(td, uap->signum, sap, &osa, KSA_OSIGSET);
2533         if (error == 0 && uap->osv != NULL) {
2534                 vec.sv_handler = PTROUT(osa.sa_handler);
2535                 SIG2OSIG(osa.sa_mask, vec.sv_mask);
2536                 vec.sv_flags = osa.sa_flags;
2537                 vec.sv_flags &= ~SA_NOCLDWAIT;
2538                 vec.sv_flags ^= SA_RESTART;
2539                 error = copyout(&vec, uap->osv, sizeof(vec));
2540         }
2541         return (error);
2542 }
2543
2544 int
2545 ofreebsd32_sigblock(struct thread *td,
2546                             struct ofreebsd32_sigblock_args *uap)
2547 {
2548         struct proc *p = td->td_proc;
2549         sigset_t set;
2550
2551         OSIG2SIG(uap->mask, set);
2552         SIG_CANTMASK(set);
2553         PROC_LOCK(p);
2554         SIG2OSIG(td->td_sigmask, td->td_retval[0]);
2555         SIGSETOR(td->td_sigmask, set);
2556         PROC_UNLOCK(p);
2557         return (0);
2558 }
2559
2560 int
2561 ofreebsd32_sigsetmask(struct thread *td,
2562                               struct ofreebsd32_sigsetmask_args *uap)
2563 {
2564         struct proc *p = td->td_proc;
2565         sigset_t set;
2566
2567         OSIG2SIG(uap->mask, set);
2568         SIG_CANTMASK(set);
2569         PROC_LOCK(p);
2570         SIG2OSIG(td->td_sigmask, td->td_retval[0]);
2571         SIGSETLO(td->td_sigmask, set);
2572         signotify(td);
2573         PROC_UNLOCK(p);
2574         return (0);
2575 }
2576
2577 int
2578 ofreebsd32_sigsuspend(struct thread *td,
2579                               struct ofreebsd32_sigsuspend_args *uap)
2580 {
2581         struct proc *p = td->td_proc;
2582         sigset_t mask;
2583
2584         PROC_LOCK(p);
2585         td->td_oldsigmask = td->td_sigmask;
2586         td->td_pflags |= TDP_OLDMASK;
2587         OSIG2SIG(uap->mask, mask);
2588         SIG_CANTMASK(mask);
2589         SIGSETLO(td->td_sigmask, mask);
2590         signotify(td);
2591         while (msleep(&p->p_sigacts, &p->p_mtx, PPAUSE|PCATCH, "opause", 0) == 0)
2592                 /* void */;
2593         PROC_UNLOCK(p);
2594         /* always return EINTR rather than ERESTART... */
2595         return (EINTR);
2596 }
2597
2598 struct sigstack32 {
2599         u_int32_t       ss_sp;
2600         int             ss_onstack;
2601 };
2602
2603 int
2604 ofreebsd32_sigstack(struct thread *td,
2605                             struct ofreebsd32_sigstack_args *uap)
2606 {
2607         struct sigstack32 s32;
2608         struct sigstack nss, oss;
2609         int error = 0, unss;
2610
2611         if (uap->nss != NULL) {
2612                 error = copyin(uap->nss, &s32, sizeof(s32));
2613                 if (error)
2614                         return (error);
2615                 nss.ss_sp = PTRIN(s32.ss_sp);
2616                 CP(s32, nss, ss_onstack);
2617                 unss = 1;
2618         } else {
2619                 unss = 0;
2620         }
2621         oss.ss_sp = td->td_sigstk.ss_sp;
2622         oss.ss_onstack = sigonstack(cpu_getstack(td));
2623         if (unss) {
2624                 td->td_sigstk.ss_sp = nss.ss_sp;
2625                 td->td_sigstk.ss_size = 0;
2626                 td->td_sigstk.ss_flags |= (nss.ss_onstack & SS_ONSTACK);
2627                 td->td_pflags |= TDP_ALTSTACK;
2628         }
2629         if (uap->oss != NULL) {
2630                 s32.ss_sp = PTROUT(oss.ss_sp);
2631                 CP(oss, s32, ss_onstack);
2632                 error = copyout(&s32, uap->oss, sizeof(s32));
2633         }
2634         return (error);
2635 }
2636 #endif
2637
2638 int
2639 freebsd32_nanosleep(struct thread *td, struct freebsd32_nanosleep_args *uap)
2640 {
2641         struct timespec32 rmt32, rqt32;
2642         struct timespec rmt, rqt;
2643         int error;
2644
2645         error = copyin(uap->rqtp, &rqt32, sizeof(rqt32));
2646         if (error)
2647                 return (error);
2648
2649         CP(rqt32, rqt, tv_sec);
2650         CP(rqt32, rqt, tv_nsec);
2651
2652         if (uap->rmtp &&
2653             !useracc((caddr_t)uap->rmtp, sizeof(rmt), VM_PROT_WRITE))
2654                 return (EFAULT);
2655         error = kern_nanosleep(td, &rqt, &rmt);
2656         if (error && uap->rmtp) {
2657                 int error2;
2658
2659                 CP(rmt, rmt32, tv_sec);
2660                 CP(rmt, rmt32, tv_nsec);
2661
2662                 error2 = copyout(&rmt32, uap->rmtp, sizeof(rmt32));
2663                 if (error2)
2664                         error = error2;
2665         }
2666         return (error);
2667 }
2668
2669 int
2670 freebsd32_clock_gettime(struct thread *td,
2671                         struct freebsd32_clock_gettime_args *uap)
2672 {
2673         struct timespec ats;
2674         struct timespec32 ats32;
2675         int error;
2676
2677         error = kern_clock_gettime(td, uap->clock_id, &ats);
2678         if (error == 0) {
2679                 CP(ats, ats32, tv_sec);
2680                 CP(ats, ats32, tv_nsec);
2681                 error = copyout(&ats32, uap->tp, sizeof(ats32));
2682         }
2683         return (error);
2684 }
2685
2686 int
2687 freebsd32_clock_settime(struct thread *td,
2688                         struct freebsd32_clock_settime_args *uap)
2689 {
2690         struct timespec ats;
2691         struct timespec32 ats32;
2692         int error;
2693
2694         error = copyin(uap->tp, &ats32, sizeof(ats32));
2695         if (error)
2696                 return (error);
2697         CP(ats32, ats, tv_sec);
2698         CP(ats32, ats, tv_nsec);
2699
2700         return (kern_clock_settime(td, uap->clock_id, &ats));
2701 }
2702
2703 int
2704 freebsd32_clock_getres(struct thread *td,
2705                        struct freebsd32_clock_getres_args *uap)
2706 {
2707         struct timespec ts;
2708         struct timespec32 ts32;
2709         int error;
2710
2711         if (uap->tp == NULL)
2712                 return (0);
2713         error = kern_clock_getres(td, uap->clock_id, &ts);
2714         if (error == 0) {
2715                 CP(ts, ts32, tv_sec);
2716                 CP(ts, ts32, tv_nsec);
2717                 error = copyout(&ts32, uap->tp, sizeof(ts32));
2718         }
2719         return (error);
2720 }
2721
2722 int
2723 freebsd32_thr_new(struct thread *td,
2724                   struct freebsd32_thr_new_args *uap)
2725 {
2726         struct thr_param32 param32;
2727         struct thr_param param;
2728         int error;
2729
2730         if (uap->param_size < 0 ||
2731             uap->param_size > sizeof(struct thr_param32))
2732                 return (EINVAL);
2733         bzero(&param, sizeof(struct thr_param));
2734         bzero(&param32, sizeof(struct thr_param32));
2735         error = copyin(uap->param, &param32, uap->param_size);
2736         if (error != 0)
2737                 return (error);
2738         param.start_func = PTRIN(param32.start_func);
2739         param.arg = PTRIN(param32.arg);
2740         param.stack_base = PTRIN(param32.stack_base);
2741         param.stack_size = param32.stack_size;
2742         param.tls_base = PTRIN(param32.tls_base);
2743         param.tls_size = param32.tls_size;
2744         param.child_tid = PTRIN(param32.child_tid);
2745         param.parent_tid = PTRIN(param32.parent_tid);
2746         param.flags = param32.flags;
2747         param.rtp = PTRIN(param32.rtp);
2748         param.spare[0] = PTRIN(param32.spare[0]);
2749         param.spare[1] = PTRIN(param32.spare[1]);
2750         param.spare[2] = PTRIN(param32.spare[2]);
2751
2752         return (kern_thr_new(td, &param));
2753 }
2754
2755 int
2756 freebsd32_thr_suspend(struct thread *td, struct freebsd32_thr_suspend_args *uap)
2757 {
2758         struct timespec32 ts32;
2759         struct timespec ts, *tsp;
2760         int error;
2761
2762         error = 0;
2763         tsp = NULL;
2764         if (uap->timeout != NULL) {
2765                 error = copyin((const void *)uap->timeout, (void *)&ts32,
2766                     sizeof(struct timespec32));
2767                 if (error != 0)
2768                         return (error);
2769                 ts.tv_sec = ts32.tv_sec;
2770                 ts.tv_nsec = ts32.tv_nsec;
2771                 tsp = &ts;
2772         }
2773         return (kern_thr_suspend(td, tsp));
2774 }
2775
2776 void
2777 siginfo_to_siginfo32(siginfo_t *src, struct siginfo32 *dst)
2778 {
2779         bzero(dst, sizeof(*dst));
2780         dst->si_signo = src->si_signo;
2781         dst->si_errno = src->si_errno;
2782         dst->si_code = src->si_code;
2783         dst->si_pid = src->si_pid;
2784         dst->si_uid = src->si_uid;
2785         dst->si_status = src->si_status;
2786         dst->si_addr = (uintptr_t)src->si_addr;
2787         dst->si_value.sigval_int = src->si_value.sival_int;
2788         dst->si_timerid = src->si_timerid;
2789         dst->si_overrun = src->si_overrun;
2790 }
2791
2792 int
2793 freebsd32_sigtimedwait(struct thread *td, struct freebsd32_sigtimedwait_args *uap)
2794 {
2795         struct timespec32 ts32;
2796         struct timespec ts;
2797         struct timespec *timeout;
2798         sigset_t set;
2799         ksiginfo_t ksi;
2800         struct siginfo32 si32;
2801         int error;
2802
2803         if (uap->timeout) {
2804                 error = copyin(uap->timeout, &ts32, sizeof(ts32));
2805                 if (error)
2806                         return (error);
2807                 ts.tv_sec = ts32.tv_sec;
2808                 ts.tv_nsec = ts32.tv_nsec;
2809                 timeout = &ts;
2810         } else
2811                 timeout = NULL;
2812
2813         error = copyin(uap->set, &set, sizeof(set));
2814         if (error)
2815                 return (error);
2816
2817         error = kern_sigtimedwait(td, set, &ksi, timeout);
2818         if (error)
2819                 return (error);
2820
2821         if (uap->info) {
2822                 siginfo_to_siginfo32(&ksi.ksi_info, &si32);
2823                 error = copyout(&si32, uap->info, sizeof(struct siginfo32));
2824         }
2825
2826         if (error == 0)
2827                 td->td_retval[0] = ksi.ksi_signo;
2828         return (error);
2829 }
2830
2831 /*
2832  * MPSAFE
2833  */
2834 int
2835 freebsd32_sigwaitinfo(struct thread *td, struct freebsd32_sigwaitinfo_args *uap)
2836 {
2837         ksiginfo_t ksi;
2838         struct siginfo32 si32;
2839         sigset_t set;
2840         int error;
2841
2842         error = copyin(uap->set, &set, sizeof(set));
2843         if (error)
2844                 return (error);
2845
2846         error = kern_sigtimedwait(td, set, &ksi, NULL);
2847         if (error)
2848                 return (error);
2849
2850         if (uap->info) {
2851                 siginfo_to_siginfo32(&ksi.ksi_info, &si32);
2852                 error = copyout(&si32, uap->info, sizeof(struct siginfo32));
2853         }
2854         if (error == 0)
2855                 td->td_retval[0] = ksi.ksi_signo;
2856         return (error);
2857 }
2858
2859 int
2860 freebsd32_cpuset_setid(struct thread *td,
2861     struct freebsd32_cpuset_setid_args *uap)
2862 {
2863         struct cpuset_setid_args ap;
2864
2865         ap.which = uap->which;
2866         ap.id = (uap->idlo | ((id_t)uap->idhi << 32));
2867         ap.setid = uap->setid;
2868
2869         return (cpuset_setid(td, &ap));
2870 }
2871
2872 int
2873 freebsd32_cpuset_getid(struct thread *td,
2874     struct freebsd32_cpuset_getid_args *uap)
2875 {
2876         struct cpuset_getid_args ap;
2877
2878         ap.level = uap->level;
2879         ap.which = uap->which;
2880         ap.id = (uap->idlo | ((id_t)uap->idhi << 32));
2881         ap.setid = uap->setid;
2882
2883         return (cpuset_getid(td, &ap));
2884 }
2885
2886 int
2887 freebsd32_cpuset_getaffinity(struct thread *td,
2888     struct freebsd32_cpuset_getaffinity_args *uap)
2889 {
2890         struct cpuset_getaffinity_args ap;
2891
2892         ap.level = uap->level;
2893         ap.which = uap->which;
2894         ap.id = (uap->idlo | ((id_t)uap->idhi << 32));
2895         ap.cpusetsize = uap->cpusetsize;
2896         ap.mask = uap->mask;
2897
2898         return (cpuset_getaffinity(td, &ap));
2899 }
2900
2901 int
2902 freebsd32_cpuset_setaffinity(struct thread *td,
2903     struct freebsd32_cpuset_setaffinity_args *uap)
2904 {
2905         struct cpuset_setaffinity_args ap;
2906
2907         ap.level = uap->level;
2908         ap.which = uap->which;
2909         ap.id = (uap->idlo | ((id_t)uap->idhi << 32));
2910         ap.cpusetsize = uap->cpusetsize;
2911         ap.mask = uap->mask;
2912
2913         return (cpuset_setaffinity(td, &ap));
2914 }
2915
2916 int
2917 freebsd32_nmount(struct thread *td,
2918     struct freebsd32_nmount_args /* {
2919         struct iovec *iovp;
2920         unsigned int iovcnt;
2921         int flags;
2922     } */ *uap)
2923 {
2924         struct uio *auio;
2925         int error;
2926
2927         AUDIT_ARG_FFLAGS(uap->flags);
2928
2929         /*
2930          * Filter out MNT_ROOTFS.  We do not want clients of nmount() in
2931          * userspace to set this flag, but we must filter it out if we want
2932          * MNT_UPDATE on the root file system to work.
2933          * MNT_ROOTFS should only be set in the kernel in vfs_mountroot_try().
2934          */
2935         uap->flags &= ~MNT_ROOTFS;
2936
2937         /*
2938          * check that we have an even number of iovec's
2939          * and that we have at least two options.
2940          */
2941         if ((uap->iovcnt & 1) || (uap->iovcnt < 4))
2942                 return (EINVAL);
2943
2944         error = freebsd32_copyinuio(uap->iovp, uap->iovcnt, &auio);
2945         if (error)
2946                 return (error);
2947         error = vfs_donmount(td, uap->flags, auio);
2948
2949         free(auio, M_IOV);
2950         return error;
2951 }
2952
2953 #if 0
2954 int
2955 freebsd32_xxx(struct thread *td, struct freebsd32_xxx_args *uap)
2956 {
2957         struct yyy32 *p32, s32;
2958         struct yyy *p = NULL, s;
2959         struct xxx_arg ap;
2960         int error;
2961
2962         if (uap->zzz) {
2963                 error = copyin(uap->zzz, &s32, sizeof(s32));
2964                 if (error)
2965                         return (error);
2966                 /* translate in */
2967                 p = &s;
2968         }
2969         error = kern_xxx(td, p);
2970         if (error)
2971                 return (error);
2972         if (uap->zzz) {
2973                 /* translate out */
2974                 error = copyout(&s32, p32, sizeof(s32));
2975         }
2976         return (error);
2977 }
2978 #endif
2979
2980 int
2981 syscall32_register(int *offset, struct sysent *new_sysent,
2982     struct sysent *old_sysent)
2983 {
2984         if (*offset == NO_SYSCALL) {
2985                 int i;
2986
2987                 for (i = 1; i < SYS_MAXSYSCALL; ++i)
2988                         if (freebsd32_sysent[i].sy_call ==
2989                             (sy_call_t *)lkmnosys)
2990                                 break;
2991                 if (i == SYS_MAXSYSCALL)
2992                         return (ENFILE);
2993                 *offset = i;
2994         } else if (*offset < 0 || *offset >= SYS_MAXSYSCALL)
2995                 return (EINVAL);
2996         else if (freebsd32_sysent[*offset].sy_call != (sy_call_t *)lkmnosys &&
2997             freebsd32_sysent[*offset].sy_call != (sy_call_t *)lkmressys)
2998                 return (EEXIST);
2999
3000         *old_sysent = freebsd32_sysent[*offset];
3001         freebsd32_sysent[*offset] = *new_sysent;
3002         return 0;
3003 }
3004
3005 int
3006 syscall32_deregister(int *offset, struct sysent *old_sysent)
3007 {
3008
3009         if (*offset)
3010                 freebsd32_sysent[*offset] = *old_sysent;
3011         return 0;
3012 }
3013
3014 int
3015 syscall32_module_handler(struct module *mod, int what, void *arg)
3016 {
3017         struct syscall_module_data *data = (struct syscall_module_data*)arg;
3018         modspecific_t ms;
3019         int error;
3020
3021         switch (what) {
3022         case MOD_LOAD:
3023                 error = syscall32_register(data->offset, data->new_sysent,
3024                     &data->old_sysent);
3025                 if (error) {
3026                         /* Leave a mark so we know to safely unload below. */
3027                         data->offset = NULL;
3028                         return error;
3029                 }
3030                 ms.intval = *data->offset;
3031                 MOD_XLOCK;
3032                 module_setspecific(mod, &ms);
3033                 MOD_XUNLOCK;
3034                 if (data->chainevh)
3035                         error = data->chainevh(mod, what, data->chainarg);
3036                 return (error);
3037         case MOD_UNLOAD:
3038                 /*
3039                  * MOD_LOAD failed, so just return without calling the
3040                  * chained handler since we didn't pass along the MOD_LOAD
3041                  * event.
3042                  */
3043                 if (data->offset == NULL)
3044                         return (0);
3045                 if (data->chainevh) {
3046                         error = data->chainevh(mod, what, data->chainarg);
3047                         if (error)
3048                                 return (error);
3049                 }
3050                 error = syscall32_deregister(data->offset, &data->old_sysent);
3051                 return (error);
3052         default:
3053                 error = EOPNOTSUPP;
3054                 if (data->chainevh)
3055                         error = data->chainevh(mod, what, data->chainarg);
3056                 return (error);
3057         }
3058 }