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