1 /* $NetBSD: netbsd32_netbsd.c,v 1.185 2014/03/22 08:15:25 maxv Exp $ */ 2 3 /* 4 * Copyright (c) 1998, 2001, 2008 Matthew R. Green 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 19 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 21 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 22 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 23 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 24 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 */ 28 29 #include <sys/cdefs.h> 30 __KERNEL_RCSID(0, "$NetBSD: netbsd32_netbsd.c,v 1.185 2014/03/22 08:15:25 maxv Exp $"); 31 32 #if defined(_KERNEL_OPT) 33 #include "opt_ddb.h" 34 #include "opt_ntp.h" 35 #include "opt_compat_netbsd.h" 36 #include "opt_compat_43.h" 37 #include "opt_sysv.h" 38 #include "opt_syscall_debug.h" 39 #endif 40 41 /* 42 * Though COMPAT_OLDSOCK is needed only for COMPAT_43, SunOS, Linux, 43 * HP-UX, FreeBSD, Ultrix, OSF1, we define it unconditionally so that 44 * this would be module-safe. 45 */ 46 #define COMPAT_OLDSOCK /* used by <sys/socket.h> */ 47 48 #include <sys/param.h> 49 #include <sys/systm.h> 50 #include <sys/kernel.h> 51 //#define msg __msg /* Don't ask me! */ 52 #include <sys/mount.h> 53 #include <sys/socket.h> 54 #include <sys/sockio.h> 55 #include <sys/socketvar.h> 56 #include <sys/mbuf.h> 57 #include <sys/mman.h> 58 #include <sys/stat.h> 59 #include <sys/swap.h> 60 #include <sys/time.h> 61 #include <sys/signalvar.h> 62 #include <sys/ptrace.h> 63 #include <sys/ktrace.h> 64 #include <sys/trace.h> 65 #include <sys/resourcevar.h> 66 #include <sys/pool.h> 67 #include <sys/vnode.h> 68 #include <sys/file.h> 69 #include <sys/filedesc.h> 70 #include <sys/namei.h> 71 #include <sys/dirent.h> 72 #include <sys/quotactl.h> 73 #include <sys/kauth.h> 74 #include <sys/vfs_syscalls.h> 75 76 #include <uvm/uvm_extern.h> 77 #include <uvm/uvm_swap.h> 78 79 #include <sys/syscallargs.h> 80 #include <sys/proc.h> 81 #include <sys/acct.h> 82 #include <sys/exec.h> 83 84 #include <net/if.h> 85 86 #include <compat/netbsd32/netbsd32.h> 87 #include <compat/netbsd32/netbsd32_exec.h> 88 #include <compat/netbsd32/netbsd32_syscall.h> 89 #include <compat/netbsd32/netbsd32_syscallargs.h> 90 #include <compat/netbsd32/netbsd32_conv.h> 91 92 #if defined(DDB) 93 #include <ddb/ddbvar.h> 94 #endif 95 96 extern struct sysent netbsd32_sysent[]; 97 #ifdef SYSCALL_DEBUG 98 extern const char * const netbsd32_syscallnames[]; 99 #endif 100 #ifdef __HAVE_SYSCALL_INTERN 101 void netbsd32_syscall_intern(struct proc *); 102 #else 103 void syscall(void); 104 #endif 105 106 #define LIMITCHECK(a, b) ((a) != RLIM_INFINITY && (a) > (b)) 107 108 #ifdef COMPAT_16 109 extern char netbsd32_sigcode[], netbsd32_esigcode[]; 110 struct uvm_object *emul_netbsd32_object; 111 #endif 112 113 extern struct sysctlnode netbsd32_sysctl_root; 114 115 struct emul emul_netbsd32 = { 116 .e_name = "netbsd32", 117 .e_path = "/emul/netbsd32", 118 #ifndef __HAVE_MINIMAL_EMUL 119 .e_flags = 0, 120 .e_errno = NULL, 121 .e_nosys = NETBSD32_SYS_netbsd32_syscall, 122 .e_nsysent = NETBSD32_SYS_NSYSENT, 123 #endif 124 .e_sysent = netbsd32_sysent, 125 #ifdef SYSCALL_DEBUG 126 .e_syscallnames = netbsd32_syscallnames, 127 #else 128 .e_syscallnames = NULL, 129 #endif 130 .e_sendsig = netbsd32_sendsig, 131 .e_trapsignal = trapsignal, 132 .e_tracesig = NULL, 133 #ifdef COMPAT_16 134 .e_sigcode = netbsd32_sigcode, 135 .e_esigcode = netbsd32_esigcode, 136 .e_sigobject = &emul_netbsd32_object, 137 #else 138 .e_sigcode = NULL, 139 .e_esigcode = NULL, 140 .e_sigobject = NULL, 141 #endif 142 .e_setregs = netbsd32_setregs, 143 .e_proc_exec = NULL, 144 .e_proc_fork = NULL, 145 .e_proc_exit = NULL, 146 .e_lwp_fork = NULL, 147 .e_lwp_exit = NULL, 148 #ifdef __HAVE_SYSCALL_INTERN 149 .e_syscall_intern = netbsd32_syscall_intern, 150 #else 151 .e_syscall = syscall, 152 #endif 153 .e_sysctlovly = &netbsd32_sysctl_root, 154 .e_fault = NULL, 155 .e_vm_default_addr = netbsd32_vm_default_addr, 156 .e_usertrap = NULL, 157 .e_ucsize = sizeof(ucontext32_t), 158 .e_startlwp = startlwp32 159 }; 160 161 /* 162 * below are all the standard NetBSD system calls, in the 32bit 163 * environment, with the necessary conversions to 64bit before 164 * calling the real syscall. anything that needs special 165 * attention is handled elsewhere. 166 */ 167 168 int 169 netbsd32_exit(struct lwp *l, const struct netbsd32_exit_args *uap, register_t *retval) 170 { 171 /* { 172 syscallarg(int) rval; 173 } */ 174 struct sys_exit_args ua; 175 176 NETBSD32TO64_UAP(rval); 177 return sys_exit(l, &ua, retval); 178 } 179 180 int 181 netbsd32_read(struct lwp *l, const struct netbsd32_read_args *uap, register_t *retval) 182 { 183 /* { 184 syscallarg(int) fd; 185 syscallarg(netbsd32_voidp) buf; 186 syscallarg(netbsd32_size_t) nbyte; 187 } */ 188 struct sys_read_args ua; 189 190 NETBSD32TO64_UAP(fd); 191 NETBSD32TOP_UAP(buf, void *); 192 NETBSD32TOX_UAP(nbyte, size_t); 193 return sys_read(l, &ua, retval); 194 } 195 196 int 197 netbsd32_write(struct lwp *l, const struct netbsd32_write_args *uap, register_t *retval) 198 { 199 /* { 200 syscallarg(int) fd; 201 syscallarg(const netbsd32_voidp) buf; 202 syscallarg(netbsd32_size_t) nbyte; 203 } */ 204 struct sys_write_args ua; 205 206 NETBSD32TO64_UAP(fd); 207 NETBSD32TOP_UAP(buf, void *); 208 NETBSD32TOX_UAP(nbyte, size_t); 209 return sys_write(l, &ua, retval); 210 } 211 212 int 213 netbsd32_close(struct lwp *l, const struct netbsd32_close_args *uap, register_t *retval) 214 { 215 /* { 216 syscallarg(int) fd; 217 } */ 218 struct sys_close_args ua; 219 220 NETBSD32TO64_UAP(fd); 221 return sys_close(l, &ua, retval); 222 } 223 224 int 225 netbsd32_open(struct lwp *l, const struct netbsd32_open_args *uap, register_t *retval) 226 { 227 /* { 228 syscallarg(const netbsd32_charp) path; 229 syscallarg(int) flags; 230 syscallarg(mode_t) mode; 231 } */ 232 struct sys_open_args ua; 233 struct pathbuf *pb; 234 int error, fd; 235 236 NETBSD32TOP_UAP(path, const char); 237 NETBSD32TO64_UAP(flags); 238 NETBSD32TO64_UAP(mode); 239 240 if (SCARG(&ua, path) != NULL) { 241 error = pathbuf_copyin(SCARG(&ua, path), &pb); 242 if (error) 243 return error; 244 } else { 245 pb = pathbuf_create("."); 246 if (pb == NULL) 247 return ENOMEM; 248 } 249 250 error = do_open(l, NULL, pb, SCARG(&ua, flags), SCARG(&ua, mode), &fd); 251 pathbuf_destroy(pb); 252 if (error == 0) 253 *retval = fd; 254 return error; 255 } 256 257 int 258 netbsd32_link(struct lwp *l, const struct netbsd32_link_args *uap, register_t *retval) 259 { 260 /* { 261 syscallarg(const netbsd32_charp) path; 262 syscallarg(const netbsd32_charp) link; 263 } */ 264 struct sys_link_args ua; 265 266 NETBSD32TOP_UAP(path, const char); 267 NETBSD32TOP_UAP(link, const char); 268 return (sys_link(l, &ua, retval)); 269 } 270 271 int 272 netbsd32_unlink(struct lwp *l, const struct netbsd32_unlink_args *uap, register_t *retval) 273 { 274 /* { 275 syscallarg(const netbsd32_charp) path; 276 } */ 277 struct sys_unlink_args ua; 278 279 NETBSD32TOP_UAP(path, const char); 280 281 return (sys_unlink(l, &ua, retval)); 282 } 283 284 int 285 netbsd32_chdir(struct lwp *l, const struct netbsd32_chdir_args *uap, register_t *retval) 286 { 287 /* { 288 syscallarg(const netbsd32_charp) path; 289 } */ 290 struct sys_chdir_args ua; 291 292 NETBSD32TOP_UAP(path, const char); 293 294 return (sys_chdir(l, &ua, retval)); 295 } 296 297 int 298 netbsd32_fchdir(struct lwp *l, const struct netbsd32_fchdir_args *uap, register_t *retval) 299 { 300 /* { 301 syscallarg(int) fd; 302 } */ 303 struct sys_fchdir_args ua; 304 305 NETBSD32TO64_UAP(fd); 306 307 return (sys_fchdir(l, &ua, retval)); 308 } 309 310 int 311 netbsd32___mknod50(struct lwp *l, const struct netbsd32___mknod50_args *uap, register_t *retval) 312 { 313 /* { 314 syscallarg(const netbsd32_charp) path; 315 syscallarg(mode_t) mode; 316 syscallarg(netbsd32_dev_t) dev; 317 } */ 318 319 return do_sys_mknod(l, SCARG_P32(uap, path), SCARG(uap, mode), 320 SCARG(uap, dev), retval, UIO_USERSPACE); 321 } 322 323 int 324 netbsd32_chmod(struct lwp *l, const struct netbsd32_chmod_args *uap, register_t *retval) 325 { 326 /* { 327 syscallarg(const netbsd32_charp) path; 328 syscallarg(mode_t) mode; 329 } */ 330 struct sys_chmod_args ua; 331 332 NETBSD32TOP_UAP(path, const char); 333 NETBSD32TO64_UAP(mode); 334 335 return (sys_chmod(l, &ua, retval)); 336 } 337 338 int 339 netbsd32_chown(struct lwp *l, const struct netbsd32_chown_args *uap, register_t *retval) 340 { 341 /* { 342 syscallarg(const netbsd32_charp) path; 343 syscallarg(uid_t) uid; 344 syscallarg(gid_t) gid; 345 } */ 346 struct sys_chown_args ua; 347 348 NETBSD32TOP_UAP(path, const char); 349 NETBSD32TO64_UAP(uid); 350 NETBSD32TO64_UAP(gid); 351 352 return (sys_chown(l, &ua, retval)); 353 } 354 355 int 356 netbsd32_break(struct lwp *l, const struct netbsd32_break_args *uap, register_t *retval) 357 { 358 /* { 359 syscallarg(netbsd32_charp) nsize; 360 } */ 361 struct sys_obreak_args ua; 362 363 NETBSD32TOP_UAP(nsize, char); 364 return (sys_obreak(l, &ua, retval)); 365 } 366 367 int 368 netbsd32_mount(struct lwp *l, const struct netbsd32_mount_args *uap, register_t *retval) 369 { 370 #ifdef COMPAT_40 371 /* { 372 syscallarg(const netbsd32_charp) type; 373 syscallarg(const netbsd32_charp) path; 374 syscallarg(int) flags; 375 syscallarg(netbsd32_voidp) data; 376 } */ 377 struct compat_40_sys_mount_args ua; 378 379 NETBSD32TOP_UAP(type, const char); 380 NETBSD32TOP_UAP(path, const char); 381 NETBSD32TO64_UAP(flags); 382 NETBSD32TOP_UAP(data, void); 383 return (compat_40_sys_mount(l, &ua, retval)); 384 #else 385 return ENOSYS; 386 #endif 387 } 388 389 int 390 netbsd32_unmount(struct lwp *l, const struct netbsd32_unmount_args *uap, register_t *retval) 391 { 392 /* { 393 syscallarg(const netbsd32_charp) path; 394 syscallarg(int) flags; 395 } */ 396 struct sys_unmount_args ua; 397 398 NETBSD32TOP_UAP(path, const char); 399 NETBSD32TO64_UAP(flags); 400 return (sys_unmount(l, &ua, retval)); 401 } 402 403 int 404 netbsd32_setuid(struct lwp *l, const struct netbsd32_setuid_args *uap, register_t *retval) 405 { 406 /* { 407 syscallarg(uid_t) uid; 408 } */ 409 struct sys_setuid_args ua; 410 411 NETBSD32TO64_UAP(uid); 412 return (sys_setuid(l, &ua, retval)); 413 } 414 415 int 416 netbsd32_ptrace(struct lwp *l, const struct netbsd32_ptrace_args *uap, register_t *retval) 417 { 418 /* { 419 syscallarg(int) req; 420 syscallarg(pid_t) pid; 421 syscallarg(netbsd32_voidp) addr; 422 syscallarg(int) data; 423 } */ 424 struct sys_ptrace_args ua; 425 426 NETBSD32TO64_UAP(req); 427 NETBSD32TO64_UAP(pid); 428 NETBSD32TOP_UAP(addr, void *); 429 NETBSD32TO64_UAP(data); 430 431 return (*sysent[SYS_ptrace].sy_call)(l, &ua, retval); 432 } 433 434 int 435 netbsd32_accept(struct lwp *l, const struct netbsd32_accept_args *uap, register_t *retval) 436 { 437 /* { 438 syscallarg(int) s; 439 syscallarg(netbsd32_sockaddrp_t) name; 440 syscallarg(netbsd32_intp) anamelen; 441 } */ 442 struct sys_accept_args ua; 443 444 NETBSD32TO64_UAP(s); 445 NETBSD32TOP_UAP(name, struct sockaddr); 446 NETBSD32TOP_UAP(anamelen, socklen_t); 447 return (sys_accept(l, &ua, retval)); 448 } 449 450 int 451 netbsd32_getpeername(struct lwp *l, const struct netbsd32_getpeername_args *uap, register_t *retval) 452 { 453 /* { 454 syscallarg(int) fdes; 455 syscallarg(netbsd32_sockaddrp_t) asa; 456 syscallarg(netbsd32_intp) alen; 457 } */ 458 struct sys_getpeername_args ua; 459 460 NETBSD32TO64_UAP(fdes); 461 NETBSD32TOP_UAP(asa, struct sockaddr); 462 NETBSD32TOP_UAP(alen, socklen_t); 463 /* NB: do the protocol specific sockaddrs need to be converted? */ 464 return (sys_getpeername(l, &ua, retval)); 465 } 466 467 int 468 netbsd32_getsockname(struct lwp *l, const struct netbsd32_getsockname_args *uap, register_t *retval) 469 { 470 /* { 471 syscallarg(int) fdes; 472 syscallarg(netbsd32_sockaddrp_t) asa; 473 syscallarg(netbsd32_intp) alen; 474 } */ 475 struct sys_getsockname_args ua; 476 477 NETBSD32TO64_UAP(fdes); 478 NETBSD32TOP_UAP(asa, struct sockaddr); 479 NETBSD32TOP_UAP(alen, socklen_t); 480 return (sys_getsockname(l, &ua, retval)); 481 } 482 483 int 484 netbsd32_access(struct lwp *l, const struct netbsd32_access_args *uap, register_t *retval) 485 { 486 /* { 487 syscallarg(const netbsd32_charp) path; 488 syscallarg(int) flags; 489 } */ 490 struct sys_access_args ua; 491 492 NETBSD32TOP_UAP(path, const char); 493 NETBSD32TO64_UAP(flags); 494 495 return sys_access(l, &ua, retval); 496 } 497 498 int 499 netbsd32_chflags(struct lwp *l, const struct netbsd32_chflags_args *uap, register_t *retval) 500 { 501 /* { 502 syscallarg(const netbsd32_charp) path; 503 syscallarg(netbsd32_u_long) flags; 504 } */ 505 struct sys_chflags_args ua; 506 507 NETBSD32TOP_UAP(path, const char); 508 NETBSD32TO64_UAP(flags); 509 510 return (sys_chflags(l, &ua, retval)); 511 } 512 513 int 514 netbsd32_fchflags(struct lwp *l, const struct netbsd32_fchflags_args *uap, register_t *retval) 515 { 516 /* { 517 syscallarg(int) fd; 518 syscallarg(netbsd32_u_long) flags; 519 } */ 520 struct sys_fchflags_args ua; 521 522 NETBSD32TO64_UAP(fd); 523 NETBSD32TO64_UAP(flags); 524 525 return (sys_fchflags(l, &ua, retval)); 526 } 527 528 int 529 netbsd32_lchflags(struct lwp *l, const struct netbsd32_lchflags_args *uap, register_t *retval) 530 { 531 /* { 532 syscallarg(const char *) path; 533 syscallarg(netbsd32_u_long) flags; 534 } */ 535 struct sys_lchflags_args ua; 536 537 NETBSD32TOP_UAP(path, const char); 538 NETBSD32TO64_UAP(flags); 539 540 return (sys_lchflags(l, &ua, retval)); 541 } 542 543 int 544 netbsd32_kill(struct lwp *l, const struct netbsd32_kill_args *uap, register_t *retval) 545 { 546 /* { 547 syscallarg(int) pid; 548 syscallarg(int) signum; 549 } */ 550 struct sys_kill_args ua; 551 552 NETBSD32TO64_UAP(pid); 553 NETBSD32TO64_UAP(signum); 554 555 return (sys_kill(l, &ua, retval)); 556 } 557 558 int 559 netbsd32_dup(struct lwp *l, const struct netbsd32_dup_args *uap, register_t *retval) 560 { 561 /* { 562 syscallarg(int) fd; 563 } */ 564 struct sys_dup_args ua; 565 566 NETBSD32TO64_UAP(fd); 567 568 return (sys_dup(l, &ua, retval)); 569 } 570 571 int 572 netbsd32_profil(struct lwp *l, const struct netbsd32_profil_args *uap, register_t *retval) 573 { 574 /* { 575 syscallarg(netbsd32_voidp) samples; 576 syscallarg(netbsd32_size_t) size; 577 syscallarg(netbsd32_u_long) offset; 578 syscallarg(u_int) scale; 579 } */ 580 struct sys_profil_args ua; 581 582 NETBSD32TOP_UAP(samples, void *); 583 NETBSD32TOX_UAP(size, size_t); 584 NETBSD32TOX_UAP(offset, u_long); 585 NETBSD32TO64_UAP(scale); 586 return (sys_profil(l, &ua, retval)); 587 } 588 589 int 590 netbsd32_ktrace(struct lwp *l, const struct netbsd32_ktrace_args *uap, register_t *retval) 591 { 592 /* { 593 syscallarg(const netbsd32_charp) fname; 594 syscallarg(int) ops; 595 syscallarg(int) facs; 596 syscallarg(int) pid; 597 } */ 598 struct sys_ktrace_args ua; 599 600 NETBSD32TOP_UAP(fname, const char); 601 NETBSD32TO64_UAP(ops); 602 NETBSD32TO64_UAP(facs); 603 NETBSD32TO64_UAP(pid); 604 return (sys_ktrace(l, &ua, retval)); 605 } 606 607 int 608 netbsd32_utrace(struct lwp *l, const struct netbsd32_utrace_args *uap, register_t *retval) 609 { 610 /* { 611 syscallarg(const netbsd32_charp) label; 612 syscallarg(netbsd32_voidp) addr; 613 syscallarg(netbsd32_size_t) len; 614 } */ 615 struct sys_utrace_args ua; 616 617 NETBSD32TOP_UAP(label, const char); 618 NETBSD32TOP_UAP(addr, void); 619 NETBSD32TO64_UAP(len); 620 return (sys_utrace(l, &ua, retval)); 621 } 622 623 int 624 netbsd32___getlogin(struct lwp *l, const struct netbsd32___getlogin_args *uap, register_t *retval) 625 { 626 /* { 627 syscallarg(netbsd32_charp) namebuf; 628 syscallarg(u_int) namelen; 629 } */ 630 struct sys___getlogin_args ua; 631 632 NETBSD32TOP_UAP(namebuf, char); 633 NETBSD32TO64_UAP(namelen); 634 return (sys___getlogin(l, &ua, retval)); 635 } 636 637 int 638 netbsd32_setlogin(struct lwp *l, const struct netbsd32_setlogin_args *uap, register_t *retval) 639 { 640 /* { 641 syscallarg(const netbsd32_charp) namebuf; 642 } */ 643 struct sys___setlogin_args ua; 644 645 NETBSD32TOP_UAP(namebuf, char); 646 return (sys___setlogin(l, &ua, retval)); 647 } 648 649 int 650 netbsd32_acct(struct lwp *l, const struct netbsd32_acct_args *uap, register_t *retval) 651 { 652 /* { 653 syscallarg(const netbsd32_charp) path; 654 } */ 655 struct sys_acct_args ua; 656 657 NETBSD32TOP_UAP(path, const char); 658 return (sys_acct(l, &ua, retval)); 659 } 660 661 int 662 netbsd32_revoke(struct lwp *l, const struct netbsd32_revoke_args *uap, register_t *retval) 663 { 664 /* { 665 syscallarg(const netbsd32_charp) path; 666 } */ 667 struct sys_revoke_args ua; 668 669 NETBSD32TOP_UAP(path, const char); 670 671 return (sys_revoke(l, &ua, retval)); 672 } 673 674 int 675 netbsd32_symlink(struct lwp *l, const struct netbsd32_symlink_args *uap, register_t *retval) 676 { 677 /* { 678 syscallarg(const netbsd32_charp) path; 679 syscallarg(const netbsd32_charp) link; 680 } */ 681 struct sys_symlink_args ua; 682 683 NETBSD32TOP_UAP(path, const char); 684 NETBSD32TOP_UAP(link, const char); 685 686 return (sys_symlink(l, &ua, retval)); 687 } 688 689 int 690 netbsd32_readlink(struct lwp *l, const struct netbsd32_readlink_args *uap, register_t *retval) 691 { 692 /* { 693 syscallarg(const netbsd32_charp) path; 694 syscallarg(netbsd32_charp) buf; 695 syscallarg(netbsd32_size_t) count; 696 } */ 697 struct sys_readlink_args ua; 698 699 NETBSD32TOP_UAP(path, const char); 700 NETBSD32TOP_UAP(buf, char); 701 NETBSD32TOX_UAP(count, size_t); 702 703 return (sys_readlink(l, &ua, retval)); 704 } 705 706 int 707 netbsd32_umask(struct lwp *l, const struct netbsd32_umask_args *uap, register_t *retval) 708 { 709 /* { 710 syscallarg(mode_t) newmask; 711 } */ 712 struct sys_umask_args ua; 713 714 NETBSD32TO64_UAP(newmask); 715 return (sys_umask(l, &ua, retval)); 716 } 717 718 int 719 netbsd32_chroot(struct lwp *l, const struct netbsd32_chroot_args *uap, register_t *retval) 720 { 721 /* { 722 syscallarg(const netbsd32_charp) path; 723 } */ 724 struct sys_chroot_args ua; 725 726 NETBSD32TOP_UAP(path, const char); 727 return (sys_chroot(l, &ua, retval)); 728 } 729 730 int 731 netbsd32_sbrk(struct lwp *l, const struct netbsd32_sbrk_args *uap, register_t *retval) 732 { 733 /* { 734 syscallarg(int) incr; 735 } */ 736 struct sys_sbrk_args ua; 737 738 NETBSD32TO64_UAP(incr); 739 return (sys_sbrk(l, &ua, retval)); 740 } 741 742 int 743 netbsd32_sstk(struct lwp *l, const struct netbsd32_sstk_args *uap, register_t *retval) 744 { 745 /* { 746 syscallarg(int) incr; 747 } */ 748 struct sys_sstk_args ua; 749 750 NETBSD32TO64_UAP(incr); 751 return (sys_sstk(l, &ua, retval)); 752 } 753 754 int 755 netbsd32_munmap(struct lwp *l, const struct netbsd32_munmap_args *uap, register_t *retval) 756 { 757 /* { 758 syscallarg(netbsd32_voidp) addr; 759 syscallarg(netbsd32_size_t) len; 760 } */ 761 struct sys_munmap_args ua; 762 763 NETBSD32TOP_UAP(addr, void); 764 NETBSD32TOX_UAP(len, size_t); 765 return (sys_munmap(l, &ua, retval)); 766 } 767 768 int 769 netbsd32_mprotect(struct lwp *l, const struct netbsd32_mprotect_args *uap, register_t *retval) 770 { 771 /* { 772 syscallarg(netbsd32_voidp) addr; 773 syscallarg(netbsd32_size_t) len; 774 syscallarg(int) prot; 775 } */ 776 struct sys_mprotect_args ua; 777 778 NETBSD32TOP_UAP(addr, void); 779 NETBSD32TOX_UAP(len, size_t); 780 NETBSD32TO64_UAP(prot); 781 return (sys_mprotect(l, &ua, retval)); 782 } 783 784 int 785 netbsd32_madvise(struct lwp *l, const struct netbsd32_madvise_args *uap, register_t *retval) 786 { 787 /* { 788 syscallarg(netbsd32_voidp) addr; 789 syscallarg(netbsd32_size_t) len; 790 syscallarg(int) behav; 791 } */ 792 struct sys_madvise_args ua; 793 794 NETBSD32TOP_UAP(addr, void); 795 NETBSD32TOX_UAP(len, size_t); 796 NETBSD32TO64_UAP(behav); 797 return (sys_madvise(l, &ua, retval)); 798 } 799 800 int 801 netbsd32_mincore(struct lwp *l, const struct netbsd32_mincore_args *uap, register_t *retval) 802 { 803 /* { 804 syscallarg(netbsd32_voidp) addr; 805 syscallarg(netbsd32_size_t) len; 806 syscallarg(netbsd32_charp) vec; 807 } */ 808 struct sys_mincore_args ua; 809 810 NETBSD32TOP_UAP(addr, void *); 811 NETBSD32TOX_UAP(len, size_t); 812 NETBSD32TOP_UAP(vec, char); 813 return (sys_mincore(l, &ua, retval)); 814 } 815 816 /* XXX MOVE ME XXX ? */ 817 int 818 netbsd32_getgroups(struct lwp *l, const struct netbsd32_getgroups_args *uap, register_t *retval) 819 { 820 /* { 821 syscallarg(int) gidsetsize; 822 syscallarg(netbsd32_gid_tp) gidset; 823 } */ 824 struct sys_getgroups_args ua; 825 826 /* Since sizeof (gid_t) == sizeof (netbsd32_gid_t) ... */ 827 828 NETBSD32TO64_UAP(gidsetsize); 829 NETBSD32TOP_UAP(gidset, gid_t); 830 return (sys_getgroups(l, &ua, retval)); 831 } 832 833 int 834 netbsd32_setgroups(struct lwp *l, const struct netbsd32_setgroups_args *uap, register_t *retval) 835 { 836 /* { 837 syscallarg(int) gidsetsize; 838 syscallarg(const netbsd32_gid_tp) gidset; 839 } */ 840 struct sys_setgroups_args ua; 841 842 NETBSD32TO64_UAP(gidsetsize); 843 NETBSD32TOP_UAP(gidset, gid_t); 844 return (sys_setgroups(l, &ua, retval)); 845 } 846 847 int 848 netbsd32_setpgid(struct lwp *l, const struct netbsd32_setpgid_args *uap, register_t *retval) 849 { 850 /* { 851 syscallarg(int) pid; 852 syscallarg(int) pgid; 853 } */ 854 struct sys_setpgid_args ua; 855 856 NETBSD32TO64_UAP(pid); 857 NETBSD32TO64_UAP(pgid); 858 return (sys_setpgid(l, &ua, retval)); 859 } 860 861 int 862 netbsd32_fcntl(struct lwp *l, const struct netbsd32_fcntl_args *uap, register_t *retval) 863 { 864 /* { 865 syscallarg(int) fd; 866 syscallarg(int) cmd; 867 syscallarg(netbsd32_voidp) arg; 868 } */ 869 struct sys_fcntl_args ua; 870 871 NETBSD32TO64_UAP(fd); 872 NETBSD32TO64_UAP(cmd); 873 NETBSD32TOP_UAP(arg, void); 874 /* we can do this because `struct flock' doesn't change */ 875 return (sys_fcntl(l, &ua, retval)); 876 } 877 878 int 879 netbsd32_dup2(struct lwp *l, const struct netbsd32_dup2_args *uap, register_t *retval) 880 { 881 /* { 882 syscallarg(int) from; 883 syscallarg(int) to; 884 } */ 885 struct sys_dup2_args ua; 886 887 NETBSD32TO64_UAP(from); 888 NETBSD32TO64_UAP(to); 889 return (sys_dup2(l, &ua, retval)); 890 } 891 892 int 893 netbsd32_fsync(struct lwp *l, const struct netbsd32_fsync_args *uap, register_t *retval) 894 { 895 /* { 896 syscallarg(int) fd; 897 } */ 898 struct sys_fsync_args ua; 899 900 NETBSD32TO64_UAP(fd); 901 return (sys_fsync(l, &ua, retval)); 902 } 903 904 int 905 netbsd32_setpriority(struct lwp *l, const struct netbsd32_setpriority_args *uap, register_t *retval) 906 { 907 /* { 908 syscallarg(int) which; 909 syscallarg(int) who; 910 syscallarg(int) prio; 911 } */ 912 struct sys_setpriority_args ua; 913 914 NETBSD32TO64_UAP(which); 915 NETBSD32TO64_UAP(who); 916 NETBSD32TO64_UAP(prio); 917 return (sys_setpriority(l, &ua, retval)); 918 } 919 920 int 921 netbsd32___socket30(struct lwp *l, const struct netbsd32___socket30_args *uap, register_t *retval) 922 { 923 /* { 924 syscallarg(int) domain; 925 syscallarg(int) type; 926 syscallarg(int) protocol; 927 } */ 928 struct sys___socket30_args ua; 929 930 NETBSD32TO64_UAP(domain); 931 NETBSD32TO64_UAP(type); 932 NETBSD32TO64_UAP(protocol); 933 return (sys___socket30(l, &ua, retval)); 934 } 935 936 int 937 netbsd32_connect(struct lwp *l, const struct netbsd32_connect_args *uap, register_t *retval) 938 { 939 /* { 940 syscallarg(int) s; 941 syscallarg(const netbsd32_sockaddrp_t) name; 942 syscallarg(int) namelen; 943 } */ 944 struct sys_connect_args ua; 945 946 NETBSD32TO64_UAP(s); 947 NETBSD32TOP_UAP(name, struct sockaddr); 948 NETBSD32TO64_UAP(namelen); 949 return (sys_connect(l, &ua, retval)); 950 } 951 952 int 953 netbsd32_getpriority(struct lwp *l, const struct netbsd32_getpriority_args *uap, register_t *retval) 954 { 955 /* { 956 syscallarg(int) which; 957 syscallarg(int) who; 958 } */ 959 struct sys_getpriority_args ua; 960 961 NETBSD32TO64_UAP(which); 962 NETBSD32TO64_UAP(who); 963 return (sys_getpriority(l, &ua, retval)); 964 } 965 966 int 967 netbsd32_bind(struct lwp *l, const struct netbsd32_bind_args *uap, register_t *retval) 968 { 969 /* { 970 syscallarg(int) s; 971 syscallarg(const netbsd32_sockaddrp_t) name; 972 syscallarg(int) namelen; 973 } */ 974 struct sys_bind_args ua; 975 976 NETBSD32TO64_UAP(s); 977 NETBSD32TOP_UAP(name, struct sockaddr); 978 NETBSD32TO64_UAP(namelen); 979 return (sys_bind(l, &ua, retval)); 980 } 981 982 int 983 netbsd32_setsockopt(struct lwp *l, const struct netbsd32_setsockopt_args *uap, register_t *retval) 984 { 985 /* { 986 syscallarg(int) s; 987 syscallarg(int) level; 988 syscallarg(int) name; 989 syscallarg(const netbsd32_voidp) val; 990 syscallarg(int) valsize; 991 } */ 992 struct sys_setsockopt_args ua; 993 994 NETBSD32TO64_UAP(s); 995 NETBSD32TO64_UAP(level); 996 NETBSD32TO64_UAP(name); 997 NETBSD32TOP_UAP(val, void); 998 NETBSD32TO64_UAP(valsize); 999 /* may be more efficient to do this inline. */ 1000 return (sys_setsockopt(l, &ua, retval)); 1001 } 1002 1003 int 1004 netbsd32_listen(struct lwp *l, const struct netbsd32_listen_args *uap, register_t *retval) 1005 { 1006 /* { 1007 syscallarg(int) s; 1008 syscallarg(int) backlog; 1009 } */ 1010 struct sys_listen_args ua; 1011 1012 NETBSD32TO64_UAP(s); 1013 NETBSD32TO64_UAP(backlog); 1014 return (sys_listen(l, &ua, retval)); 1015 } 1016 1017 int 1018 netbsd32_fchown(struct lwp *l, const struct netbsd32_fchown_args *uap, register_t *retval) 1019 { 1020 /* { 1021 syscallarg(int) fd; 1022 syscallarg(uid_t) uid; 1023 syscallarg(gid_t) gid; 1024 } */ 1025 struct sys_fchown_args ua; 1026 1027 NETBSD32TO64_UAP(fd); 1028 NETBSD32TO64_UAP(uid); 1029 NETBSD32TO64_UAP(gid); 1030 return (sys_fchown(l, &ua, retval)); 1031 } 1032 1033 int 1034 netbsd32_fchmod(struct lwp *l, const struct netbsd32_fchmod_args *uap, register_t *retval) 1035 { 1036 /* { 1037 syscallarg(int) fd; 1038 syscallarg(mode_t) mode; 1039 } */ 1040 struct sys_fchmod_args ua; 1041 1042 NETBSD32TO64_UAP(fd); 1043 NETBSD32TO64_UAP(mode); 1044 return (sys_fchmod(l, &ua, retval)); 1045 } 1046 1047 int 1048 netbsd32_setreuid(struct lwp *l, const struct netbsd32_setreuid_args *uap, register_t *retval) 1049 { 1050 /* { 1051 syscallarg(uid_t) ruid; 1052 syscallarg(uid_t) euid; 1053 } */ 1054 struct sys_setreuid_args ua; 1055 1056 NETBSD32TO64_UAP(ruid); 1057 NETBSD32TO64_UAP(euid); 1058 return (sys_setreuid(l, &ua, retval)); 1059 } 1060 1061 int 1062 netbsd32_setregid(struct lwp *l, const struct netbsd32_setregid_args *uap, register_t *retval) 1063 { 1064 /* { 1065 syscallarg(gid_t) rgid; 1066 syscallarg(gid_t) egid; 1067 } */ 1068 struct sys_setregid_args ua; 1069 1070 NETBSD32TO64_UAP(rgid); 1071 NETBSD32TO64_UAP(egid); 1072 return (sys_setregid(l, &ua, retval)); 1073 } 1074 1075 int 1076 netbsd32_getsockopt(struct lwp *l, const struct netbsd32_getsockopt_args *uap, register_t *retval) 1077 { 1078 /* { 1079 syscallarg(int) s; 1080 syscallarg(int) level; 1081 syscallarg(int) name; 1082 syscallarg(netbsd32_voidp) val; 1083 syscallarg(netbsd32_intp) avalsize; 1084 } */ 1085 struct sys_getsockopt_args ua; 1086 1087 NETBSD32TO64_UAP(s); 1088 NETBSD32TO64_UAP(level); 1089 NETBSD32TO64_UAP(name); 1090 NETBSD32TOP_UAP(val, void); 1091 NETBSD32TOP_UAP(avalsize, socklen_t); 1092 return (sys_getsockopt(l, &ua, retval)); 1093 } 1094 1095 int 1096 netbsd32_rename(struct lwp *l, const struct netbsd32_rename_args *uap, register_t *retval) 1097 { 1098 /* { 1099 syscallarg(const netbsd32_charp) from; 1100 syscallarg(const netbsd32_charp) to; 1101 } */ 1102 struct sys_rename_args ua; 1103 1104 NETBSD32TOP_UAP(from, const char); 1105 NETBSD32TOP_UAP(to, const char); 1106 1107 return (sys_rename(l, &ua, retval)); 1108 } 1109 1110 int 1111 netbsd32_flock(struct lwp *l, const struct netbsd32_flock_args *uap, register_t *retval) 1112 { 1113 /* { 1114 syscallarg(int) fd; 1115 syscallarg(int) how; 1116 } */ 1117 struct sys_flock_args ua; 1118 1119 NETBSD32TO64_UAP(fd); 1120 NETBSD32TO64_UAP(how); 1121 1122 return (sys_flock(l, &ua, retval)); 1123 } 1124 1125 int 1126 netbsd32_mkfifo(struct lwp *l, const struct netbsd32_mkfifo_args *uap, register_t *retval) 1127 { 1128 /* { 1129 syscallarg(const netbsd32_charp) path; 1130 syscallarg(mode_t) mode; 1131 } */ 1132 struct sys_mkfifo_args ua; 1133 1134 NETBSD32TOP_UAP(path, const char); 1135 NETBSD32TO64_UAP(mode); 1136 return (sys_mkfifo(l, &ua, retval)); 1137 } 1138 1139 int 1140 netbsd32_shutdown(struct lwp *l, const struct netbsd32_shutdown_args *uap, register_t *retval) 1141 { 1142 /* { 1143 syscallarg(int) s; 1144 syscallarg(int) how; 1145 } */ 1146 struct sys_shutdown_args ua; 1147 1148 NETBSD32TO64_UAP(s); 1149 NETBSD32TO64_UAP(how); 1150 return (sys_shutdown(l, &ua, retval)); 1151 } 1152 1153 int 1154 netbsd32_socketpair(struct lwp *l, const struct netbsd32_socketpair_args *uap, register_t *retval) 1155 { 1156 /* { 1157 syscallarg(int) domain; 1158 syscallarg(int) type; 1159 syscallarg(int) protocol; 1160 syscallarg(netbsd32_intp) rsv; 1161 } */ 1162 struct sys_socketpair_args ua; 1163 1164 NETBSD32TO64_UAP(domain); 1165 NETBSD32TO64_UAP(type); 1166 NETBSD32TO64_UAP(protocol); 1167 NETBSD32TOP_UAP(rsv, int); 1168 /* Since we're just copying out two `int's we can do this */ 1169 return (sys_socketpair(l, &ua, retval)); 1170 } 1171 1172 int 1173 netbsd32_mkdir(struct lwp *l, const struct netbsd32_mkdir_args *uap, register_t *retval) 1174 { 1175 /* { 1176 syscallarg(const netbsd32_charp) path; 1177 syscallarg(mode_t) mode; 1178 } */ 1179 struct sys_mkdir_args ua; 1180 1181 NETBSD32TOP_UAP(path, const char); 1182 NETBSD32TO64_UAP(mode); 1183 return (sys_mkdir(l, &ua, retval)); 1184 } 1185 1186 int 1187 netbsd32_rmdir(struct lwp *l, const struct netbsd32_rmdir_args *uap, register_t *retval) 1188 { 1189 /* { 1190 syscallarg(const netbsd32_charp) path; 1191 } */ 1192 struct sys_rmdir_args ua; 1193 1194 NETBSD32TOP_UAP(path, const char); 1195 return (sys_rmdir(l, &ua, retval)); 1196 } 1197 1198 int 1199 netbsd32___quotactl(struct lwp *l, const struct netbsd32___quotactl_args *uap, register_t *retval) 1200 { 1201 /* { 1202 syscallarg(const netbsd32_charp) path; 1203 syscallarg(netbsd32_voidp) args; 1204 } */ 1205 struct netbsd32_quotactlargs args32; 1206 struct quotactl_args args; 1207 int error; 1208 1209 error = copyin(SCARG_P32(uap, args), &args32, sizeof(args32)); 1210 if (error) { 1211 return error; 1212 } 1213 1214 args.qc_op = args32.qc_op; 1215 switch (args.qc_op) { 1216 case QUOTACTL_STAT: 1217 args.u.stat.qc_info = NETBSD32PTR64(args32.u.stat.qc_info); 1218 break; 1219 case QUOTACTL_IDTYPESTAT: 1220 args.u.idtypestat.qc_idtype = args32.u.idtypestat.qc_idtype; 1221 args.u.idtypestat.qc_info = 1222 NETBSD32PTR64(args32.u.idtypestat.qc_info); 1223 break; 1224 case QUOTACTL_OBJTYPESTAT: 1225 args.u.objtypestat.qc_objtype = 1226 args32.u.objtypestat.qc_objtype; 1227 args.u.objtypestat.qc_info = 1228 NETBSD32PTR64(args32.u.objtypestat.qc_info); 1229 break; 1230 case QUOTACTL_GET: 1231 args.u.get.qc_key = NETBSD32PTR64(args32.u.get.qc_key); 1232 args.u.get.qc_val = NETBSD32PTR64(args32.u.get.qc_val); 1233 break; 1234 case QUOTACTL_PUT: 1235 args.u.put.qc_key = NETBSD32PTR64(args32.u.put.qc_key); 1236 args.u.put.qc_val = NETBSD32PTR64(args32.u.put.qc_val); 1237 break; 1238 case QUOTACTL_DELETE: 1239 args.u.delete.qc_key = NETBSD32PTR64(args32.u.delete.qc_key); 1240 break; 1241 case QUOTACTL_CURSOROPEN: 1242 args.u.cursoropen.qc_cursor = 1243 NETBSD32PTR64(args32.u.cursoropen.qc_cursor); 1244 break; 1245 case QUOTACTL_CURSORCLOSE: 1246 args.u.cursorclose.qc_cursor = 1247 NETBSD32PTR64(args32.u.cursorclose.qc_cursor); 1248 break; 1249 case QUOTACTL_CURSORSKIPIDTYPE: 1250 args.u.cursorskipidtype.qc_cursor = 1251 NETBSD32PTR64(args32.u.cursorskipidtype.qc_cursor); 1252 args.u.cursorskipidtype.qc_idtype = 1253 args32.u.cursorskipidtype.qc_idtype; 1254 break; 1255 case QUOTACTL_CURSORGET: 1256 args.u.cursorget.qc_cursor = 1257 NETBSD32PTR64(args32.u.cursorget.qc_cursor); 1258 args.u.cursorget.qc_keys = 1259 NETBSD32PTR64(args32.u.cursorget.qc_keys); 1260 args.u.cursorget.qc_vals = 1261 NETBSD32PTR64(args32.u.cursorget.qc_vals); 1262 args.u.cursorget.qc_maxnum = 1263 args32.u.cursorget.qc_maxnum; 1264 args.u.cursorget.qc_ret = 1265 NETBSD32PTR64(args32.u.cursorget.qc_ret); 1266 break; 1267 case QUOTACTL_CURSORATEND: 1268 args.u.cursoratend.qc_cursor = 1269 NETBSD32PTR64(args32.u.cursoratend.qc_cursor); 1270 args.u.cursoratend.qc_ret = 1271 NETBSD32PTR64(args32.u.cursoratend.qc_ret); 1272 break; 1273 case QUOTACTL_CURSORREWIND: 1274 args.u.cursorrewind.qc_cursor = 1275 NETBSD32PTR64(args32.u.cursorrewind.qc_cursor); 1276 break; 1277 case QUOTACTL_QUOTAON: 1278 args.u.quotaon.qc_idtype = args32.u.quotaon.qc_idtype; 1279 args.u.quotaon.qc_quotafile = 1280 NETBSD32PTR64(args32.u.quotaon.qc_quotafile); 1281 break; 1282 case QUOTACTL_QUOTAOFF: 1283 args.u.quotaoff.qc_idtype = args32.u.quotaoff.qc_idtype; 1284 break; 1285 default: 1286 return EINVAL; 1287 } 1288 1289 return do_sys_quotactl(SCARG_P32(uap, path), &args); 1290 } 1291 1292 int 1293 netbsd32___getfh30(struct lwp *l, const struct netbsd32___getfh30_args *uap, register_t *retval) 1294 { 1295 /* { 1296 syscallarg(const netbsd32_charp) fname; 1297 syscallarg(netbsd32_fhandlep_t) fhp; 1298 syscallarg(netbsd32_size_tp) fh_size; 1299 } */ 1300 struct vnode *vp; 1301 fhandle_t *fh; 1302 int error; 1303 struct pathbuf *pb; 1304 struct nameidata nd; 1305 netbsd32_size_t sz32; 1306 size_t sz; 1307 1308 /* 1309 * Must be super user 1310 */ 1311 error = kauth_authorize_system(l->l_cred, KAUTH_SYSTEM_FILEHANDLE, 1312 0, NULL, NULL, NULL); 1313 if (error) 1314 return (error); 1315 fh = NULL; 1316 1317 error = pathbuf_copyin(SCARG_P32(uap, fname), &pb); 1318 if (error) { 1319 return error; 1320 } 1321 1322 NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF | TRYEMULROOT, pb); 1323 error = namei(&nd); 1324 if (error) { 1325 pathbuf_destroy(pb); 1326 return error; 1327 } 1328 vp = nd.ni_vp; 1329 pathbuf_destroy(pb); 1330 1331 error = copyin(SCARG_P32(uap, fh_size), &sz32, 1332 sizeof(netbsd32_size_t)); 1333 if (error) { 1334 vput(vp); 1335 return error; 1336 } 1337 fh = kmem_alloc(sz32, KM_SLEEP); 1338 if (fh == NULL) 1339 return EINVAL; 1340 sz = sz32; 1341 error = vfs_composefh(vp, fh, &sz); 1342 vput(vp); 1343 1344 if (error == 0) { 1345 const netbsd32_size_t nsz32 = sz; 1346 error = copyout(&nsz32, SCARG_P32(uap, fh_size), 1347 sizeof(netbsd32_size_t)); 1348 if (!error) { 1349 error = copyout(fh, SCARG_P32(uap, fhp), sz); 1350 } 1351 } else if (error == E2BIG) { 1352 error = copyout(&sz, SCARG_P32(uap, fh_size), sizeof(size_t)); 1353 } 1354 kmem_free(fh, sz32); 1355 return (error); 1356 } 1357 1358 int 1359 netbsd32_pread(struct lwp *l, const struct netbsd32_pread_args *uap, register_t *retval) 1360 { 1361 /* { 1362 syscallarg(int) fd; 1363 syscallarg(netbsd32_voidp) buf; 1364 syscallarg(netbsd32_size_t) nbyte; 1365 syscallarg(int) PAD; 1366 syscallarg(off_t) offset; 1367 } */ 1368 struct sys_pread_args ua; 1369 1370 NETBSD32TO64_UAP(fd); 1371 NETBSD32TOP_UAP(buf, void); 1372 NETBSD32TOX_UAP(nbyte, size_t); 1373 NETBSD32TO64_UAP(PAD); 1374 NETBSD32TO64_UAP(offset); 1375 return sys_pread(l, &ua, retval); 1376 } 1377 1378 int 1379 netbsd32_pwrite(struct lwp *l, const struct netbsd32_pwrite_args *uap, register_t *retval) 1380 { 1381 /* { 1382 syscallarg(int) fd; 1383 syscallarg(const netbsd32_voidp) buf; 1384 syscallarg(netbsd32_size_t) nbyte; 1385 syscallarg(int) PAD; 1386 syscallarg(off_t) offset; 1387 } */ 1388 struct sys_pwrite_args ua; 1389 1390 NETBSD32TO64_UAP(fd); 1391 NETBSD32TOP_UAP(buf, void); 1392 NETBSD32TOX_UAP(nbyte, size_t); 1393 NETBSD32TO64_UAP(PAD); 1394 NETBSD32TO64_UAP(offset); 1395 return sys_pwrite(l, &ua, retval); 1396 } 1397 1398 int 1399 netbsd32_setgid(struct lwp *l, const struct netbsd32_setgid_args *uap, register_t *retval) 1400 { 1401 /* { 1402 syscallarg(gid_t) gid; 1403 } */ 1404 struct sys_setgid_args ua; 1405 1406 NETBSD32TO64_UAP(gid); 1407 return (sys_setgid(l, &ua, retval)); 1408 } 1409 1410 int 1411 netbsd32_setegid(struct lwp *l, const struct netbsd32_setegid_args *uap, register_t *retval) 1412 { 1413 /* { 1414 syscallarg(gid_t) egid; 1415 } */ 1416 struct sys_setegid_args ua; 1417 1418 NETBSD32TO64_UAP(egid); 1419 return (sys_setegid(l, &ua, retval)); 1420 } 1421 1422 int 1423 netbsd32_seteuid(struct lwp *l, const struct netbsd32_seteuid_args *uap, register_t *retval) 1424 { 1425 /* { 1426 syscallarg(gid_t) euid; 1427 } */ 1428 struct sys_seteuid_args ua; 1429 1430 NETBSD32TO64_UAP(euid); 1431 return (sys_seteuid(l, &ua, retval)); 1432 } 1433 1434 int 1435 netbsd32_pathconf(struct lwp *l, const struct netbsd32_pathconf_args *uap, register_t *retval) 1436 { 1437 /* { 1438 syscallarg(int) fd; 1439 syscallarg(int) name; 1440 } */ 1441 struct sys_pathconf_args ua; 1442 1443 NETBSD32TOP_UAP(path, const char); 1444 NETBSD32TO64_UAP(name); 1445 return sys_pathconf(l, &ua, retval); 1446 } 1447 1448 int 1449 netbsd32_fpathconf(struct lwp *l, const struct netbsd32_fpathconf_args *uap, register_t *retval) 1450 { 1451 /* { 1452 syscallarg(int) fd; 1453 syscallarg(int) name; 1454 } */ 1455 struct sys_fpathconf_args ua; 1456 1457 NETBSD32TO64_UAP(fd); 1458 NETBSD32TO64_UAP(name); 1459 return sys_fpathconf(l, &ua, retval); 1460 } 1461 1462 int 1463 netbsd32_getrlimit(struct lwp *l, const struct netbsd32_getrlimit_args *uap, register_t *retval) 1464 { 1465 /* { 1466 syscallarg(int) which; 1467 syscallarg(netbsd32_rlimitp_t) rlp; 1468 } */ 1469 int which = SCARG(uap, which); 1470 1471 if ((u_int)which >= RLIM_NLIMITS) 1472 return (EINVAL); 1473 return (copyout(&l->l_proc->p_rlimit[which], 1474 SCARG_P32(uap, rlp), sizeof(struct rlimit))); 1475 } 1476 1477 int 1478 netbsd32_setrlimit(struct lwp *l, const struct netbsd32_setrlimit_args *uap, register_t *retval) 1479 { 1480 /* { 1481 syscallarg(int) which; 1482 syscallarg(const netbsd32_rlimitp_t) rlp; 1483 } */ 1484 int which = SCARG(uap, which); 1485 struct rlimit alim; 1486 int error; 1487 1488 error = copyin(SCARG_P32(uap, rlp), &alim, sizeof(struct rlimit)); 1489 if (error) 1490 return (error); 1491 1492 switch (which) { 1493 case RLIMIT_DATA: 1494 if (LIMITCHECK(alim.rlim_cur, MAXDSIZ32)) 1495 alim.rlim_cur = MAXDSIZ32; 1496 if (LIMITCHECK(alim.rlim_max, MAXDSIZ32)) 1497 alim.rlim_max = MAXDSIZ32; 1498 break; 1499 1500 case RLIMIT_STACK: 1501 if (LIMITCHECK(alim.rlim_cur, MAXSSIZ32)) 1502 alim.rlim_cur = MAXSSIZ32; 1503 if (LIMITCHECK(alim.rlim_max, MAXSSIZ32)) 1504 alim.rlim_max = MAXSSIZ32; 1505 default: 1506 break; 1507 } 1508 1509 return (dosetrlimit(l, l->l_proc, which, &alim)); 1510 } 1511 1512 int 1513 netbsd32_mmap(struct lwp *l, const struct netbsd32_mmap_args *uap, register_t *retval) 1514 { 1515 /* { 1516 syscallarg(netbsd32_voidp) addr; 1517 syscallarg(netbsd32_size_t) len; 1518 syscallarg(int) prot; 1519 syscallarg(int) flags; 1520 syscallarg(int) fd; 1521 syscallarg(netbsd32_long) PAD; 1522 syscallarg(off_t) pos; 1523 } */ 1524 struct sys_mmap_args ua; 1525 int error; 1526 1527 NETBSD32TOP_UAP(addr, void); 1528 NETBSD32TOX_UAP(len, size_t); 1529 NETBSD32TO64_UAP(prot); 1530 NETBSD32TO64_UAP(flags); 1531 #ifdef __x86_64__ 1532 /* 1533 * Ancient kernel on x86 did not obey PROT_EXEC on i386 at least 1534 * and ld.so did not turn it on! 1535 */ 1536 if (SCARG(&ua, flags) & MAP_COPY) 1537 SCARG(&ua, prot) |= PROT_EXEC; 1538 #endif 1539 NETBSD32TO64_UAP(fd); 1540 NETBSD32TOX_UAP(PAD, long); 1541 NETBSD32TOX_UAP(pos, off_t); 1542 #ifdef DEBUG_MMAP 1543 printf("mmap(addr=0x%lx, len=0x%lx, prot=0x%lx, flags=0x%lx, " 1544 "fd=%ld, pos=0x%lx);\n", 1545 (long)SCARG(&ua, addr), (long)SCARG(&ua, len), 1546 (long)SCARG(&ua, prot), (long)SCARG(&ua, flags), 1547 (long)SCARG(&ua, fd), (long)SCARG(&ua, pos)); 1548 #endif 1549 error = sys_mmap(l, &ua, retval); 1550 if ((u_long)*retval > (u_long)UINT_MAX) { 1551 printf("netbsd32_mmap: retval out of range: 0x%lx", 1552 (u_long)*retval); 1553 /* Should try to recover and return an error here. */ 1554 } 1555 return (error); 1556 } 1557 1558 int 1559 netbsd32_mremap(struct lwp *l, const struct netbsd32_mremap_args *uap, register_t *retval) 1560 { 1561 /* { 1562 syscallarg(void *) old_address; 1563 syscallarg(size_t) old_size; 1564 syscallarg(void *) new_address; 1565 syscallarg(size_t) new_size; 1566 syscallarg(int) flags; 1567 } */ 1568 struct sys_mremap_args ua; 1569 1570 NETBSD32TOP_UAP(old_address, void); 1571 NETBSD32TOX_UAP(old_size, size_t); 1572 NETBSD32TOP_UAP(new_address, void); 1573 NETBSD32TOX_UAP(new_size, size_t); 1574 NETBSD32TO64_UAP(flags); 1575 1576 return sys_mremap(l, &ua, retval); 1577 } 1578 1579 int 1580 netbsd32_lseek(struct lwp *l, const struct netbsd32_lseek_args *uap, register_t *retval) 1581 { 1582 /* { 1583 syscallarg(int) fd; 1584 syscallarg(int) PAD; 1585 syscallarg(off_t) offset; 1586 syscallarg(int) whence; 1587 } */ 1588 struct sys_lseek_args ua; 1589 union { 1590 register_t retval64[2]; 1591 register32_t retval32[4]; 1592 } newpos; 1593 int rv; 1594 1595 NETBSD32TO64_UAP(fd); 1596 NETBSD32TO64_UAP(PAD); 1597 NETBSD32TO64_UAP(offset); 1598 NETBSD32TO64_UAP(whence); 1599 rv = sys_lseek(l, &ua, newpos.retval64); 1600 1601 /* 1602 * We have to split the 64 bit value into 2 halves which will 1603 * end up in separate 32 bit registers. 1604 * This should DTRT on big and little-endian systems provided that 1605 * gcc's 'strict aliasing' tests don't decide that the retval32[] 1606 * entries can't have been assigned to, so need not be read! 1607 */ 1608 retval[0] = newpos.retval32[0]; 1609 retval[1] = newpos.retval32[1]; 1610 1611 return rv; 1612 } 1613 1614 int 1615 netbsd32_truncate(struct lwp *l, const struct netbsd32_truncate_args *uap, register_t *retval) 1616 { 1617 /* { 1618 syscallarg(const netbsd32_charp) path; 1619 syscallarg(int) PAD; 1620 syscallarg(off_t) length; 1621 } */ 1622 struct sys_truncate_args ua; 1623 1624 NETBSD32TOP_UAP(path, const char); 1625 NETBSD32TO64_UAP(PAD); 1626 NETBSD32TO64_UAP(length); 1627 return (sys_truncate(l, &ua, retval)); 1628 } 1629 1630 int 1631 netbsd32_ftruncate(struct lwp *l, const struct netbsd32_ftruncate_args *uap, register_t *retval) 1632 { 1633 /* { 1634 syscallarg(int) fd; 1635 syscallarg(int) PAD; 1636 syscallarg(off_t) length; 1637 } */ 1638 struct sys_ftruncate_args ua; 1639 1640 NETBSD32TO64_UAP(fd); 1641 NETBSD32TO64_UAP(PAD); 1642 NETBSD32TO64_UAP(length); 1643 return (sys_ftruncate(l, &ua, retval)); 1644 } 1645 1646 int 1647 netbsd32_mlock(struct lwp *l, const struct netbsd32_mlock_args *uap, register_t *retval) 1648 { 1649 /* { 1650 syscallarg(const netbsd32_voidp) addr; 1651 syscallarg(netbsd32_size_t) len; 1652 } */ 1653 struct sys_mlock_args ua; 1654 1655 NETBSD32TOP_UAP(addr, const void); 1656 NETBSD32TO64_UAP(len); 1657 return (sys_mlock(l, &ua, retval)); 1658 } 1659 1660 int 1661 netbsd32_munlock(struct lwp *l, const struct netbsd32_munlock_args *uap, register_t *retval) 1662 { 1663 /* { 1664 syscallarg(const netbsd32_voidp) addr; 1665 syscallarg(netbsd32_size_t) len; 1666 } */ 1667 struct sys_munlock_args ua; 1668 1669 NETBSD32TOP_UAP(addr, const void); 1670 NETBSD32TO64_UAP(len); 1671 return (sys_munlock(l, &ua, retval)); 1672 } 1673 1674 int 1675 netbsd32_undelete(struct lwp *l, const struct netbsd32_undelete_args *uap, register_t *retval) 1676 { 1677 /* { 1678 syscallarg(const netbsd32_charp) path; 1679 } */ 1680 struct sys_undelete_args ua; 1681 1682 NETBSD32TOP_UAP(path, const char); 1683 return (sys_undelete(l, &ua, retval)); 1684 } 1685 1686 int 1687 netbsd32_getpgid(struct lwp *l, const struct netbsd32_getpgid_args *uap, register_t *retval) 1688 { 1689 /* { 1690 syscallarg(pid_t) pid; 1691 } */ 1692 struct sys_getpgid_args ua; 1693 1694 NETBSD32TO64_UAP(pid); 1695 return (sys_getpgid(l, &ua, retval)); 1696 } 1697 1698 int 1699 netbsd32_reboot(struct lwp *l, const struct netbsd32_reboot_args *uap, register_t *retval) 1700 { 1701 /* { 1702 syscallarg(int) opt; 1703 syscallarg(netbsd32_charp) bootstr; 1704 } */ 1705 struct sys_reboot_args ua; 1706 1707 NETBSD32TO64_UAP(opt); 1708 NETBSD32TOP_UAP(bootstr, char); 1709 return (sys_reboot(l, &ua, retval)); 1710 } 1711 1712 #include <sys/poll.h> 1713 int 1714 netbsd32_poll(struct lwp *l, const struct netbsd32_poll_args *uap, register_t *retval) 1715 { 1716 /* { 1717 syscallarg(netbsd32_pollfdp_t) fds; 1718 syscallarg(u_int) nfds; 1719 syscallarg(int) timeout; 1720 } */ 1721 struct sys_poll_args ua; 1722 1723 NETBSD32TOP_UAP(fds, struct pollfd); 1724 NETBSD32TO64_UAP(nfds); 1725 NETBSD32TO64_UAP(timeout); 1726 1727 return (sys_poll(l, &ua, retval)); 1728 } 1729 1730 int 1731 netbsd32_fdatasync(struct lwp *l, const struct netbsd32_fdatasync_args *uap, register_t *retval) 1732 { 1733 /* { 1734 syscallarg(int) fd; 1735 } */ 1736 struct sys_fdatasync_args ua; 1737 1738 NETBSD32TO64_UAP(fd); 1739 return (sys_fdatasync(l, &ua, retval)); 1740 } 1741 1742 int 1743 netbsd32___posix_rename(struct lwp *l, const struct netbsd32___posix_rename_args *uap, register_t *retval) 1744 { 1745 /* { 1746 syscallarg(const netbsd32_charp) from; 1747 syscallarg(const netbsd32_charp) to; 1748 } */ 1749 struct sys___posix_rename_args ua; 1750 1751 NETBSD32TOP_UAP(from, const char); 1752 NETBSD32TOP_UAP(to, const char); 1753 return (sys___posix_rename(l, &ua, retval)); 1754 } 1755 1756 static int 1757 netbsd32_swapctl_stats(struct lwp *l, struct sys_swapctl_args *uap, register_t *retval) 1758 { 1759 struct swapent *ksep; 1760 struct netbsd32_swapent *usep32; 1761 struct netbsd32_swapent se32; 1762 int count = SCARG(uap, misc); 1763 int i, error = 0; 1764 size_t ksep_len; 1765 1766 /* Make sure userland cannot exhaust kernel memory */ 1767 if ((size_t)count > (size_t)uvmexp.nswapdev) 1768 count = uvmexp.nswapdev; 1769 1770 ksep_len = sizeof(*ksep) * count; 1771 ksep = kmem_alloc(ksep_len, KM_SLEEP); 1772 usep32 = (struct netbsd32_swapent *)SCARG(uap, arg); 1773 1774 uvm_swap_stats(SWAP_STATS, ksep, count, retval); 1775 count = *retval; 1776 1777 if (count < 1) 1778 goto out; 1779 1780 for (i = 0; i < count; i++) { 1781 se32.se_dev = ksep[i].se_dev; 1782 se32.se_flags = ksep[i].se_flags; 1783 se32.se_nblks = ksep[i].se_nblks; 1784 se32.se_inuse = ksep[i].se_inuse; 1785 se32.se_priority = ksep[i].se_priority; 1786 memcpy(se32.se_path, ksep[i].se_path, 1787 sizeof(se32.se_path)); 1788 1789 error = copyout(&se32, usep32 + i, sizeof(se32)); 1790 if (error) 1791 break; 1792 } 1793 1794 1795 out: 1796 kmem_free(ksep, ksep_len); 1797 1798 return error; 1799 } 1800 1801 int 1802 netbsd32_swapctl(struct lwp *l, const struct netbsd32_swapctl_args *uap, register_t *retval) 1803 { 1804 /* { 1805 syscallarg(int) cmd; 1806 syscallarg(const netbsd32_voidp) arg; 1807 syscallarg(int) misc; 1808 } */ 1809 struct sys_swapctl_args ua; 1810 1811 NETBSD32TO64_UAP(cmd); 1812 NETBSD32TOP_UAP(arg, void); 1813 NETBSD32TO64_UAP(misc); 1814 1815 /* SWAP_STATS50 and SWAP_STATS13 structures need no translation */ 1816 if (SCARG(&ua, cmd) == SWAP_STATS) 1817 return netbsd32_swapctl_stats(l, &ua, retval); 1818 1819 return (sys_swapctl(l, &ua, retval)); 1820 } 1821 1822 int 1823 netbsd32_minherit(struct lwp *l, const struct netbsd32_minherit_args *uap, register_t *retval) 1824 { 1825 /* { 1826 syscallarg(netbsd32_voidp) addr; 1827 syscallarg(netbsd32_size_t) len; 1828 syscallarg(int) inherit; 1829 } */ 1830 struct sys_minherit_args ua; 1831 1832 NETBSD32TOP_UAP(addr, void); 1833 NETBSD32TOX_UAP(len, size_t); 1834 NETBSD32TO64_UAP(inherit); 1835 return (sys_minherit(l, &ua, retval)); 1836 } 1837 1838 int 1839 netbsd32_lchmod(struct lwp *l, const struct netbsd32_lchmod_args *uap, register_t *retval) 1840 { 1841 /* { 1842 syscallarg(const netbsd32_charp) path; 1843 syscallarg(mode_t) mode; 1844 } */ 1845 struct sys_lchmod_args ua; 1846 1847 NETBSD32TOP_UAP(path, const char); 1848 NETBSD32TO64_UAP(mode); 1849 return (sys_lchmod(l, &ua, retval)); 1850 } 1851 1852 int 1853 netbsd32_lchown(struct lwp *l, const struct netbsd32_lchown_args *uap, register_t *retval) 1854 { 1855 /* { 1856 syscallarg(const netbsd32_charp) path; 1857 syscallarg(uid_t) uid; 1858 syscallarg(gid_t) gid; 1859 } */ 1860 struct sys_lchown_args ua; 1861 1862 NETBSD32TOP_UAP(path, const char); 1863 NETBSD32TO64_UAP(uid); 1864 NETBSD32TO64_UAP(gid); 1865 return (sys_lchown(l, &ua, retval)); 1866 } 1867 1868 int 1869 netbsd32___msync13(struct lwp *l, const struct netbsd32___msync13_args *uap, register_t *retval) 1870 { 1871 /* { 1872 syscallarg(netbsd32_voidp) addr; 1873 syscallarg(netbsd32_size_t) len; 1874 syscallarg(int) flags; 1875 } */ 1876 struct sys___msync13_args ua; 1877 1878 NETBSD32TOP_UAP(addr, void); 1879 NETBSD32TOX_UAP(len, size_t); 1880 NETBSD32TO64_UAP(flags); 1881 return (sys___msync13(l, &ua, retval)); 1882 } 1883 1884 int 1885 netbsd32___posix_chown(struct lwp *l, const struct netbsd32___posix_chown_args *uap, register_t *retval) 1886 { 1887 /* { 1888 syscallarg(const netbsd32_charp) path; 1889 syscallarg(uid_t) uid; 1890 syscallarg(gid_t) gid; 1891 } */ 1892 struct sys___posix_chown_args ua; 1893 1894 NETBSD32TOP_UAP(path, const char); 1895 NETBSD32TO64_UAP(uid); 1896 NETBSD32TO64_UAP(gid); 1897 return (sys___posix_chown(l, &ua, retval)); 1898 } 1899 1900 int 1901 netbsd32___posix_fchown(struct lwp *l, const struct netbsd32___posix_fchown_args *uap, register_t *retval) 1902 { 1903 /* { 1904 syscallarg(int) fd; 1905 syscallarg(uid_t) uid; 1906 syscallarg(gid_t) gid; 1907 } */ 1908 struct sys___posix_fchown_args ua; 1909 1910 NETBSD32TO64_UAP(fd); 1911 NETBSD32TO64_UAP(uid); 1912 NETBSD32TO64_UAP(gid); 1913 return (sys___posix_fchown(l, &ua, retval)); 1914 } 1915 1916 int 1917 netbsd32___posix_lchown(struct lwp *l, const struct netbsd32___posix_lchown_args *uap, register_t *retval) 1918 { 1919 /* { 1920 syscallarg(const netbsd32_charp) path; 1921 syscallarg(uid_t) uid; 1922 syscallarg(gid_t) gid; 1923 } */ 1924 struct sys___posix_lchown_args ua; 1925 1926 NETBSD32TOP_UAP(path, const char); 1927 NETBSD32TO64_UAP(uid); 1928 NETBSD32TO64_UAP(gid); 1929 return (sys___posix_lchown(l, &ua, retval)); 1930 } 1931 1932 int 1933 netbsd32_getsid(struct lwp *l, const struct netbsd32_getsid_args *uap, register_t *retval) 1934 { 1935 /* { 1936 syscallarg(pid_t) pid; 1937 } */ 1938 struct sys_getsid_args ua; 1939 1940 NETBSD32TO64_UAP(pid); 1941 return (sys_getsid(l, &ua, retval)); 1942 } 1943 1944 int 1945 netbsd32_fktrace(struct lwp *l, const struct netbsd32_fktrace_args *uap, register_t *retval) 1946 { 1947 /* { 1948 syscallarg(int) fd; 1949 syscallarg(int) ops; 1950 syscallarg(int) facs; 1951 syscallarg(int) pid; 1952 } */ 1953 struct sys_fktrace_args ua; 1954 1955 NETBSD32TOX_UAP(fd, int); 1956 NETBSD32TO64_UAP(ops); 1957 NETBSD32TO64_UAP(facs); 1958 NETBSD32TO64_UAP(pid); 1959 return (sys_fktrace(l, &ua, retval)); 1960 } 1961 1962 int 1963 netbsd32___sigpending14(struct lwp *l, const struct netbsd32___sigpending14_args *uap, register_t *retval) 1964 { 1965 /* { 1966 syscallarg(sigset_t *) set; 1967 } */ 1968 struct sys___sigpending14_args ua; 1969 1970 NETBSD32TOP_UAP(set, sigset_t); 1971 return (sys___sigpending14(l, &ua, retval)); 1972 } 1973 1974 int 1975 netbsd32___sigprocmask14(struct lwp *l, const struct netbsd32___sigprocmask14_args *uap, register_t *retval) 1976 { 1977 /* { 1978 syscallarg(int) how; 1979 syscallarg(const sigset_t *) set; 1980 syscallarg(sigset_t *) oset; 1981 } */ 1982 struct sys___sigprocmask14_args ua; 1983 1984 NETBSD32TO64_UAP(how); 1985 NETBSD32TOP_UAP(set, sigset_t); 1986 NETBSD32TOP_UAP(oset, sigset_t); 1987 return (sys___sigprocmask14(l, &ua, retval)); 1988 } 1989 1990 int 1991 netbsd32___sigsuspend14(struct lwp *l, const struct netbsd32___sigsuspend14_args *uap, register_t *retval) 1992 { 1993 /* { 1994 syscallarg(const sigset_t *) set; 1995 } */ 1996 struct sys___sigsuspend14_args ua; 1997 1998 NETBSD32TOP_UAP(set, sigset_t); 1999 return (sys___sigsuspend14(l, &ua, retval)); 2000 } 2001 2002 int 2003 netbsd32_fchroot(struct lwp *l, const struct netbsd32_fchroot_args *uap, register_t *retval) 2004 { 2005 /* { 2006 syscallarg(int) fd; 2007 } */ 2008 struct sys_fchroot_args ua; 2009 2010 NETBSD32TO64_UAP(fd); 2011 return (sys_fchroot(l, &ua, retval)); 2012 } 2013 2014 /* 2015 * Open a file given a file handle. 2016 * 2017 * Check permissions, allocate an open file structure, 2018 * and call the device open routine if any. 2019 */ 2020 int 2021 netbsd32___fhopen40(struct lwp *l, const struct netbsd32___fhopen40_args *uap, register_t *retval) 2022 { 2023 /* { 2024 syscallarg(const netbsd32_pointer_t *) fhp; 2025 syscallarg(netbsd32_size_t) fh_size; 2026 syscallarg(int) flags; 2027 } */ 2028 struct sys___fhopen40_args ua; 2029 2030 NETBSD32TOP_UAP(fhp, fhandle_t); 2031 NETBSD32TO64_UAP(fh_size); 2032 NETBSD32TO64_UAP(flags); 2033 return (sys___fhopen40(l, &ua, retval)); 2034 } 2035 2036 /* virtual memory syscalls */ 2037 int 2038 netbsd32_ovadvise(struct lwp *l, const struct netbsd32_ovadvise_args *uap, register_t *retval) 2039 { 2040 /* { 2041 syscallarg(int) anom; 2042 } */ 2043 struct sys_ovadvise_args ua; 2044 2045 NETBSD32TO64_UAP(anom); 2046 return (sys_ovadvise(l, &ua, retval)); 2047 } 2048 2049 void 2050 netbsd32_adjust_limits(struct proc *p) 2051 { 2052 static const struct { 2053 int id; 2054 rlim_t lim; 2055 } lm[] = { 2056 { RLIMIT_DATA, MAXDSIZ32 }, 2057 { RLIMIT_STACK, MAXSSIZ32 }, 2058 }; 2059 size_t i; 2060 struct plimit *lim; 2061 struct rlimit *rlim; 2062 2063 /* 2064 * We can only reduce the current limits, we cannot stop external 2065 * processes from changing them (eg via sysctl) later on. 2066 * So there is no point trying to lock out such changes here. 2067 * 2068 * If we assume that rlim_cur/max are accessed using atomic 2069 * operations, we don't need to lock against any other updates 2070 * that might happen if the plimit structure is shared writable 2071 * between multiple processes. 2072 */ 2073 2074 /* Scan to determine is any limits are out of range */ 2075 lim = p->p_limit; 2076 for (i = 0; ; i++) { 2077 if (i >= __arraycount(lm)) 2078 /* All in range */ 2079 return; 2080 rlim = lim->pl_rlimit + lm[i].id; 2081 if (LIMITCHECK(rlim->rlim_cur, lm[i].lim)) 2082 break; 2083 if (LIMITCHECK(rlim->rlim_max, lm[i].lim)) 2084 break; 2085 } 2086 2087 lim_privatise(p); 2088 2089 lim = p->p_limit; 2090 for (i = 0; i < __arraycount(lm); i++) { 2091 rlim = lim->pl_rlimit + lm[i].id; 2092 if (LIMITCHECK(rlim->rlim_cur, lm[i].lim)) 2093 rlim->rlim_cur = lm[i].lim; 2094 if (LIMITCHECK(rlim->rlim_max, lm[i].lim)) 2095 rlim->rlim_max = lm[i].lim; 2096 } 2097 } 2098 2099 int 2100 netbsd32_uuidgen(struct lwp *l, const struct netbsd32_uuidgen_args *uap, register_t *retval) 2101 { 2102 /* { 2103 syscallarg(netbsd32_uuidp_t) store; 2104 syscallarg(int) count; 2105 } */ 2106 struct sys_uuidgen_args ua; 2107 2108 NETBSD32TOP_UAP(store, struct uuid); 2109 NETBSD32TO64_UAP(count); 2110 return (sys_uuidgen(l, &ua, retval)); 2111 } 2112 2113 int 2114 netbsd32_extattrctl(struct lwp *l, const struct netbsd32_extattrctl_args *uap, register_t *retval) 2115 { 2116 /* { 2117 syscallarg(const netbsd32_charp) path; 2118 syscallarg(int) cmd; 2119 syscallarg(const netbsd32_charp) filename; 2120 syscallarg(int) attrnamespace; 2121 syscallarg(const netbsd32_charp) attrname; 2122 } */ 2123 struct sys_extattrctl_args ua; 2124 2125 NETBSD32TOP_UAP(path, const char); 2126 NETBSD32TO64_UAP(cmd); 2127 NETBSD32TOP_UAP(filename, const char); 2128 NETBSD32TO64_UAP(attrnamespace); 2129 NETBSD32TOP_UAP(attrname, const char); 2130 return sys_extattrctl(l, &ua, retval); 2131 } 2132 2133 int 2134 netbsd32_extattr_set_fd(struct lwp *l, const struct netbsd32_extattr_set_fd_args *uap, register_t *retval) 2135 { 2136 /* { 2137 syscallarg(int) fd; 2138 syscallarg(int) attrnamespace; 2139 syscallarg(const netbsd32_charp) attrname; 2140 syscallarg(const netbsd32_voidp) data; 2141 syscallarg(netbsd32_size_t) nbytes; 2142 } */ 2143 struct sys_extattr_set_fd_args ua; 2144 2145 NETBSD32TO64_UAP(fd); 2146 NETBSD32TO64_UAP(attrnamespace); 2147 NETBSD32TOP_UAP(attrname, const char); 2148 NETBSD32TOP_UAP(data, const void); 2149 NETBSD32TOX_UAP(nbytes, size_t); 2150 return sys_extattr_set_fd(l, &ua, retval); 2151 } 2152 2153 int 2154 netbsd32_extattr_set_file(struct lwp *l, const struct netbsd32_extattr_set_file_args *uap, register_t *retval) 2155 { 2156 /* { 2157 syscallarg(const netbsd32_charp) path; 2158 syscallarg(int) attrnamespace; 2159 syscallarg(const netbsd32_charp) attrname; 2160 syscallarg(const netbsd32_voidp) data; 2161 syscallarg(netbsd32_size_t) nbytes; 2162 } */ 2163 struct sys_extattr_set_file_args ua; 2164 2165 NETBSD32TOP_UAP(path, const char); 2166 NETBSD32TO64_UAP(attrnamespace); 2167 NETBSD32TOP_UAP(attrname, const char); 2168 NETBSD32TOP_UAP(data, const void); 2169 NETBSD32TOX_UAP(nbytes, size_t); 2170 return sys_extattr_set_file(l, &ua, retval); 2171 } 2172 2173 int 2174 netbsd32_extattr_set_link(struct lwp *l, const struct netbsd32_extattr_set_link_args *uap, register_t *retval) 2175 { 2176 /* { 2177 syscallarg(const netbsd32_charp) path; 2178 syscallarg(int) attrnamespace; 2179 syscallarg(const netbsd32_charp) attrname; 2180 syscallarg(const netbsd32_voidp) data; 2181 syscallarg(netbsd32_size_t) nbytes; 2182 } */ 2183 struct sys_extattr_set_link_args ua; 2184 2185 NETBSD32TOP_UAP(path, const char); 2186 NETBSD32TO64_UAP(attrnamespace); 2187 NETBSD32TOP_UAP(attrname, const char); 2188 NETBSD32TOP_UAP(data, const void); 2189 NETBSD32TOX_UAP(nbytes, size_t); 2190 return sys_extattr_set_link(l, &ua, retval); 2191 } 2192 2193 int 2194 netbsd32_extattr_get_fd(struct lwp *l, const struct netbsd32_extattr_get_fd_args *uap, register_t *retval) 2195 { 2196 /* { 2197 syscallarg(int) fd; 2198 syscallarg(int) attrnamespace; 2199 syscallarg(const netbsd32_charp) attrname; 2200 syscallarg(netbsd32_voidp) data; 2201 syscallarg(netbsd32_size_t) nbytes; 2202 } */ 2203 struct sys_extattr_get_fd_args ua; 2204 2205 NETBSD32TO64_UAP(fd); 2206 NETBSD32TO64_UAP(attrnamespace); 2207 NETBSD32TOP_UAP(attrname, const char); 2208 NETBSD32TOP_UAP(data, void); 2209 NETBSD32TOX_UAP(nbytes, size_t); 2210 return sys_extattr_get_fd(l, &ua, retval); 2211 } 2212 2213 int 2214 netbsd32_extattr_get_file(struct lwp *l, const struct netbsd32_extattr_get_file_args *uap, register_t *retval) 2215 { 2216 /* { 2217 syscallarg(const netbsd32_charp) path; 2218 syscallarg(int) attrnamespace; 2219 syscallarg(const netbsd32_charp) attrname; 2220 syscallarg(netbsd32_voidp) data; 2221 syscallarg(netbsd32_size_t) nbytes; 2222 } */ 2223 struct sys_extattr_get_file_args ua; 2224 2225 NETBSD32TOP_UAP(path, const char); 2226 NETBSD32TO64_UAP(attrnamespace); 2227 NETBSD32TOP_UAP(attrname, const char); 2228 NETBSD32TOP_UAP(data, void); 2229 NETBSD32TOX_UAP(nbytes, size_t); 2230 return sys_extattr_get_file(l, &ua, retval); 2231 } 2232 2233 int 2234 netbsd32_extattr_get_link(struct lwp *l, const struct netbsd32_extattr_get_link_args *uap, register_t *retval) 2235 { 2236 /* { 2237 syscallarg(const netbsd32_charp) path; 2238 syscallarg(int) attrnamespace; 2239 syscallarg(const netbsd32_charp) attrname; 2240 syscallarg(netbsd32_voidp) data; 2241 syscallarg(netbsd32_size_t) nbytes; 2242 } */ 2243 struct sys_extattr_get_link_args ua; 2244 2245 NETBSD32TOP_UAP(path, const char); 2246 NETBSD32TO64_UAP(attrnamespace); 2247 NETBSD32TOP_UAP(attrname, const char); 2248 NETBSD32TOP_UAP(data, void); 2249 NETBSD32TOX_UAP(nbytes, size_t); 2250 return sys_extattr_get_link(l, &ua, retval); 2251 } 2252 2253 int 2254 netbsd32_extattr_delete_fd(struct lwp *l, const struct netbsd32_extattr_delete_fd_args *uap, register_t *retval) 2255 { 2256 /* { 2257 syscallarg(int) fd; 2258 syscallarg(int) attrnamespace; 2259 syscallarg(const netbsd32_charp) attrname; 2260 } */ 2261 struct sys_extattr_delete_fd_args ua; 2262 2263 NETBSD32TO64_UAP(fd); 2264 NETBSD32TO64_UAP(attrnamespace); 2265 NETBSD32TOP_UAP(attrname, const char); 2266 return sys_extattr_delete_fd(l, &ua, retval); 2267 } 2268 2269 int 2270 netbsd32_extattr_delete_file(struct lwp *l, const struct netbsd32_extattr_delete_file_args *uap, register_t *retval) 2271 { 2272 /* { 2273 syscallarg(const netbsd32_charp) path; 2274 syscallarg(int) attrnamespace; 2275 syscallarg(const netbsd32_charp) attrname; 2276 } */ 2277 struct sys_extattr_delete_file_args ua; 2278 2279 NETBSD32TOP_UAP(path, const char); 2280 NETBSD32TO64_UAP(attrnamespace); 2281 NETBSD32TOP_UAP(attrname, const char); 2282 return sys_extattr_delete_file(l, &ua, retval); 2283 } 2284 2285 int 2286 netbsd32_extattr_delete_link(struct lwp *l, const struct netbsd32_extattr_delete_link_args *uap, register_t *retval) 2287 { 2288 /* { 2289 syscallarg(const netbsd32_charp) path; 2290 syscallarg(int) attrnamespace; 2291 syscallarg(const netbsd32_charp) attrname; 2292 } */ 2293 struct sys_extattr_delete_link_args ua; 2294 2295 NETBSD32TOP_UAP(path, const char); 2296 NETBSD32TO64_UAP(attrnamespace); 2297 NETBSD32TOP_UAP(attrname, const char); 2298 return sys_extattr_delete_link(l, &ua, retval); 2299 } 2300 2301 int 2302 netbsd32_extattr_list_fd(struct lwp *l, const struct netbsd32_extattr_list_fd_args *uap, register_t *retval) 2303 { 2304 /* { 2305 syscallarg(int) fd; 2306 syscallarg(int) attrnamespace; 2307 syscallarg(netbsd32_voidp) data; 2308 syscallarg(netbsd32_size_t) nbytes; 2309 } */ 2310 struct sys_extattr_list_fd_args ua; 2311 2312 NETBSD32TO64_UAP(fd); 2313 NETBSD32TO64_UAP(attrnamespace); 2314 NETBSD32TOP_UAP(data, void); 2315 NETBSD32TOX_UAP(nbytes, size_t); 2316 return sys_extattr_list_fd(l, &ua, retval); 2317 } 2318 2319 int 2320 netbsd32_extattr_list_file(struct lwp *l, const struct netbsd32_extattr_list_file_args *uap, register_t *retval) 2321 { 2322 /* { 2323 syscallarg(const netbsd32_charp) path; 2324 syscallarg(int) attrnamespace; 2325 syscallarg(netbsd32_voidp) data; 2326 syscallarg(netbsd32_size_t) nbytes; 2327 } */ 2328 struct sys_extattr_list_file_args ua; 2329 2330 NETBSD32TOP_UAP(path, const char); 2331 NETBSD32TO64_UAP(attrnamespace); 2332 NETBSD32TOP_UAP(data, void); 2333 NETBSD32TOX_UAP(nbytes, size_t); 2334 return sys_extattr_list_file(l, &ua, retval); 2335 } 2336 2337 int 2338 netbsd32_extattr_list_link(struct lwp *l, const struct netbsd32_extattr_list_link_args *uap, register_t *retval) 2339 { 2340 /* { 2341 syscallarg(const netbsd32_charp) path; 2342 syscallarg(int) attrnamespace; 2343 syscallarg(netbsd32_voidp) data; 2344 syscallarg(netbsd32_size_t) nbytes; 2345 } */ 2346 struct sys_extattr_list_link_args ua; 2347 2348 NETBSD32TOP_UAP(path, const char); 2349 NETBSD32TO64_UAP(attrnamespace); 2350 NETBSD32TOP_UAP(data, void); 2351 NETBSD32TOX_UAP(nbytes, size_t); 2352 return sys_extattr_list_link(l, &ua, retval); 2353 } 2354 2355 int 2356 netbsd32_mlockall(struct lwp *l, const struct netbsd32_mlockall_args *uap, register_t *retval) 2357 { 2358 /* { 2359 syscallarg(int) flags; 2360 } */ 2361 struct sys_mlockall_args ua; 2362 2363 NETBSD32TO64_UAP(flags); 2364 return (sys_mlockall(l, &ua, retval)); 2365 } 2366 2367 int 2368 netbsd32___clone(struct lwp *l, const struct netbsd32___clone_args *uap, register_t *retval) 2369 { 2370 /* { 2371 syscallarg(int) flags; 2372 syscallarg(netbsd32_voidp) stack; 2373 } */ 2374 struct sys___clone_args ua; 2375 2376 NETBSD32TO64_UAP(flags); 2377 NETBSD32TOP_UAP(stack, void); 2378 return sys___clone(l, &ua, retval); 2379 } 2380 2381 int 2382 netbsd32_fsync_range(struct lwp *l, const struct netbsd32_fsync_range_args *uap, register_t *retval) 2383 { 2384 /* { 2385 syscallarg(int) fd; 2386 syscallarg(int) flags; 2387 syscallarg(off_t) start; 2388 syscallarg(off_t) length; 2389 } */ 2390 struct sys_fsync_range_args ua; 2391 2392 NETBSD32TO64_UAP(fd); 2393 NETBSD32TO64_UAP(flags); 2394 NETBSD32TO64_UAP(start); 2395 NETBSD32TO64_UAP(length); 2396 return (sys_fsync_range(l, &ua, retval)); 2397 } 2398 2399 int 2400 netbsd32_rasctl(struct lwp *l, const struct netbsd32_rasctl_args *uap, register_t *retval) 2401 { 2402 /* { 2403 syscallarg(netbsd32_voidp) addr; 2404 syscallarg(netbsd32_size_t) len; 2405 syscallarg(int) op; 2406 } */ 2407 struct sys_rasctl_args ua; 2408 2409 NETBSD32TOP_UAP(addr, void *); 2410 NETBSD32TOX_UAP(len, size_t); 2411 NETBSD32TO64_UAP(op); 2412 return sys_rasctl(l, &ua, retval); 2413 } 2414 2415 int 2416 netbsd32_setxattr(struct lwp *l, const struct netbsd32_setxattr_args *uap, register_t *retval) 2417 { 2418 /* { 2419 syscallarg(const netbsd32_charp) path; 2420 syscallarg(const netbsd32_charp) name; 2421 syscallarg(netbsd32_voidp) value; 2422 syscallarg(netbsd32_size_t) size; 2423 syscallarg(int) flags; 2424 } */ 2425 struct sys_setxattr_args ua; 2426 NETBSD32TOP_UAP(path, const char); 2427 NETBSD32TOP_UAP(name, const char); 2428 NETBSD32TOP_UAP(value, void); 2429 NETBSD32TOX_UAP(size, size_t); 2430 NETBSD32TO64_UAP(flags); 2431 return sys_setxattr(l, &ua, retval); 2432 } 2433 2434 int 2435 netbsd32_lsetxattr(struct lwp *l, const struct netbsd32_lsetxattr_args *uap, register_t *retval) 2436 { 2437 /* { 2438 syscallarg(const netbsd32_charp) path; 2439 syscallarg(const netbsd32_charp) name; 2440 syscallarg(netbsd32_voidp) value; 2441 syscallarg(netbsd32_size_t) size; 2442 syscallarg(int) flags; 2443 } */ 2444 struct sys_lsetxattr_args ua; 2445 NETBSD32TOP_UAP(path, const char); 2446 NETBSD32TOP_UAP(name, const char); 2447 NETBSD32TOP_UAP(value, void); 2448 NETBSD32TOX_UAP(size, size_t); 2449 NETBSD32TO64_UAP(flags); 2450 return sys_lsetxattr(l, &ua, retval); 2451 } 2452 2453 int 2454 netbsd32_fsetxattr(struct lwp *l, const struct netbsd32_fsetxattr_args *uap, register_t *retval) 2455 { 2456 /* { 2457 syscallarg(int) fd; 2458 syscallarg(const netbsd32_charp) name; 2459 syscallarg(netbsd32_voidp) value; 2460 syscallarg(netbsd32_size_t) size; 2461 syscallarg(int) flags; 2462 } */ 2463 struct sys_fsetxattr_args ua; 2464 NETBSD32TO64_UAP(fd); 2465 NETBSD32TOP_UAP(name, const char); 2466 NETBSD32TOP_UAP(value, void); 2467 NETBSD32TOX_UAP(size, size_t); 2468 NETBSD32TO64_UAP(flags); 2469 return sys_fsetxattr(l, &ua, retval); 2470 } 2471 2472 int 2473 netbsd32_getxattr(struct lwp *l, const struct netbsd32_getxattr_args *uap, register_t *retval) 2474 { 2475 /* { 2476 syscallarg(const netbsd32_charp) path; 2477 syscallarg(const netbsd32_charp) name; 2478 syscallarg(netbsd32_voidp) value; 2479 syscallarg(netbsd32_size_t) size; 2480 } */ 2481 struct sys_getxattr_args ua; 2482 NETBSD32TOP_UAP(path, const char); 2483 NETBSD32TOP_UAP(name, const char); 2484 NETBSD32TOP_UAP(value, void); 2485 NETBSD32TOX_UAP(size, size_t); 2486 return sys_getxattr(l, &ua, retval); 2487 } 2488 2489 int 2490 netbsd32_lgetxattr(struct lwp *l, const struct netbsd32_lgetxattr_args *uap, register_t *retval) 2491 { 2492 /* { 2493 syscallarg(const netbsd32_charp) path; 2494 syscallarg(const netbsd32_charp) name; 2495 syscallarg(netbsd32_voidp) value; 2496 syscallarg(netbsd32_size_t) size; 2497 } */ 2498 struct sys_lgetxattr_args ua; 2499 NETBSD32TOP_UAP(path, const char); 2500 NETBSD32TOP_UAP(name, const char); 2501 NETBSD32TOP_UAP(value, void); 2502 NETBSD32TOX_UAP(size, size_t); 2503 return sys_lgetxattr(l, &ua, retval); 2504 } 2505 2506 int 2507 netbsd32_fgetxattr(struct lwp *l, const struct netbsd32_fgetxattr_args *uap, register_t *retval) 2508 { 2509 /* { 2510 syscallarg(int) fd; 2511 syscallarg(const netbsd32_charp) name; 2512 syscallarg(netbsd32_voidp) value; 2513 syscallarg(netbsd32_size_t) size; 2514 } */ 2515 struct sys_fgetxattr_args ua; 2516 NETBSD32TO64_UAP(fd); 2517 NETBSD32TOP_UAP(name, const char); 2518 NETBSD32TOP_UAP(value, void); 2519 NETBSD32TOX_UAP(size, size_t); 2520 return sys_fgetxattr(l, &ua, retval); 2521 } 2522 2523 int 2524 netbsd32_listxattr(struct lwp *l, const struct netbsd32_listxattr_args *uap, register_t *retval) 2525 { 2526 /* { 2527 syscallarg(const netbsd32_charp) path; 2528 syscallarg(netbsd32_charp) list; 2529 syscallarg(netbsd32_size_t) size; 2530 } */ 2531 struct sys_listxattr_args ua; 2532 NETBSD32TOP_UAP(path, const char); 2533 NETBSD32TOP_UAP(list, char); 2534 NETBSD32TOX_UAP(size, size_t); 2535 return sys_listxattr(l, &ua, retval); 2536 } 2537 2538 int 2539 netbsd32_llistxattr(struct lwp *l, const struct netbsd32_llistxattr_args *uap, register_t *retval) 2540 { 2541 /* { 2542 syscallarg(const netbsd32_charp) path; 2543 syscallarg(netbsd32_charp) list; 2544 syscallarg(netbsd32_size_t) size; 2545 } */ 2546 struct sys_llistxattr_args ua; 2547 NETBSD32TOP_UAP(path, const char); 2548 NETBSD32TOP_UAP(list, char); 2549 NETBSD32TOX_UAP(size, size_t); 2550 return sys_llistxattr(l, &ua, retval); 2551 } 2552 2553 int 2554 netbsd32_flistxattr(struct lwp *l, const struct netbsd32_flistxattr_args *uap, register_t *retval) 2555 { 2556 /* { 2557 syscallarg(int) fd; 2558 syscallarg(netbsd32_charp) list; 2559 syscallarg(netbsd32_size_t) size; 2560 } */ 2561 struct sys_flistxattr_args ua; 2562 NETBSD32TO64_UAP(fd); 2563 NETBSD32TOP_UAP(list, char); 2564 NETBSD32TOX_UAP(size, size_t); 2565 return sys_flistxattr(l, &ua, retval); 2566 } 2567 2568 int 2569 netbsd32_removexattr(struct lwp *l, const struct netbsd32_removexattr_args *uap, register_t *retval) 2570 { 2571 /* { 2572 syscallarg(const netbsd32_charp) path; 2573 syscallarg(const netbsd32_charp) name; 2574 } */ 2575 struct sys_removexattr_args ua; 2576 NETBSD32TOP_UAP(path, const char); 2577 NETBSD32TOP_UAP(name, const char); 2578 return sys_removexattr(l, &ua, retval); 2579 } 2580 2581 int 2582 netbsd32_lremovexattr(struct lwp *l, const struct netbsd32_lremovexattr_args *uap, register_t *retval) 2583 { 2584 /* { 2585 syscallarg(const netbsd32_charp) path; 2586 syscallarg(const netbsd32_charp) name; 2587 } */ 2588 struct sys_lremovexattr_args ua; 2589 NETBSD32TOP_UAP(path, const char); 2590 NETBSD32TOP_UAP(name, const char); 2591 return sys_lremovexattr(l, &ua, retval); 2592 } 2593 2594 int 2595 netbsd32_fremovexattr(struct lwp *l, const struct netbsd32_fremovexattr_args *uap, register_t *retval) 2596 { 2597 /* { 2598 syscallarg(int) fd; 2599 syscallarg(const netbsd32_charp) name; 2600 } */ 2601 struct sys_fremovexattr_args ua; 2602 NETBSD32TO64_UAP(fd); 2603 NETBSD32TOP_UAP(name, const char); 2604 return sys_fremovexattr(l, &ua, retval); 2605 } 2606 2607 int 2608 netbsd32___posix_fadvise50(struct lwp *l, 2609 const struct netbsd32___posix_fadvise50_args *uap, register_t *retval) 2610 { 2611 /* { 2612 syscallarg(int) fd; 2613 syscallarg(int) PAD; 2614 syscallarg(off_t) offset; 2615 syscallarg(off_t) len; 2616 syscallarg(int) advice; 2617 } */ 2618 2619 *retval = do_posix_fadvise(SCARG(uap, fd), SCARG(uap, offset), 2620 SCARG(uap, len), SCARG(uap, advice)); 2621 2622 return 0; 2623 } 2624 2625 int 2626 netbsd32__sched_setparam(struct lwp *l, 2627 const struct netbsd32__sched_setparam_args *uap, 2628 register_t *retval) 2629 { 2630 /* { 2631 syscallarg(pid_t) pid; 2632 syscallarg(lwpid_t) lid; 2633 syscallarg(int) policy; 2634 syscallarg(const netbsd32_sched_paramp_t) params; 2635 } */ 2636 struct sys__sched_setparam_args ua; 2637 2638 NETBSD32TO64_UAP(pid); 2639 NETBSD32TO64_UAP(lid); 2640 NETBSD32TO64_UAP(policy); 2641 NETBSD32TOP_UAP(params, const struct sched_param *); 2642 return sys__sched_setparam(l, &ua, retval); 2643 } 2644 2645 int 2646 netbsd32__sched_getparam(struct lwp *l, 2647 const struct netbsd32__sched_getparam_args *uap, 2648 register_t *retval) 2649 { 2650 /* { 2651 syscallarg(pid_t) pid; 2652 syscallarg(lwpid_t) lid; 2653 syscallarg(netbsd32_intp) policy; 2654 syscallarg(netbsd32_sched_paramp_t) params; 2655 } */ 2656 struct sys__sched_getparam_args ua; 2657 2658 NETBSD32TO64_UAP(pid); 2659 NETBSD32TO64_UAP(lid); 2660 NETBSD32TOP_UAP(policy, int *); 2661 NETBSD32TOP_UAP(params, struct sched_param *); 2662 return sys__sched_getparam(l, &ua, retval); 2663 } 2664 2665 int 2666 netbsd32__sched_setaffinity(struct lwp *l, 2667 const struct netbsd32__sched_setaffinity_args *uap, 2668 register_t *retval) 2669 { 2670 /* { 2671 syscallarg(pid_t) pid; 2672 syscallarg(lwpid_t) lid; 2673 syscallarg(netbsd_size_t) size; 2674 syscallarg(const netbsd32_cpusetp_t) cpuset; 2675 } */ 2676 struct sys__sched_setaffinity_args ua; 2677 2678 NETBSD32TO64_UAP(pid); 2679 NETBSD32TO64_UAP(lid); 2680 NETBSD32TOX_UAP(size, size_t); 2681 NETBSD32TOP_UAP(cpuset, const cpuset_t *); 2682 return sys__sched_setaffinity(l, &ua, retval); 2683 } 2684 2685 int 2686 netbsd32__sched_getaffinity(struct lwp *l, 2687 const struct netbsd32__sched_getaffinity_args *uap, 2688 register_t *retval) 2689 { 2690 /* { 2691 syscallarg(pid_t) pid; 2692 syscallarg(lwpid_t) lid; 2693 syscallarg(netbsd_size_t) size; 2694 syscallarg(netbsd32_cpusetp_t) cpuset; 2695 } */ 2696 struct sys__sched_getaffinity_args ua; 2697 2698 NETBSD32TO64_UAP(pid); 2699 NETBSD32TO64_UAP(lid); 2700 NETBSD32TOX_UAP(size, size_t); 2701 NETBSD32TOP_UAP(cpuset, cpuset_t *); 2702 return sys__sched_getaffinity(l, &ua, retval); 2703 } 2704 2705 int 2706 netbsd32_pipe2(struct lwp *l, const struct netbsd32_pipe2_args *uap, 2707 register_t *retval) 2708 { 2709 /* { 2710 syscallarg(netbsd32_intp) fildes; 2711 syscallarg(int) flags; 2712 } */ 2713 int fd[2], error; 2714 2715 error = pipe1(l, retval, SCARG(uap, flags)); 2716 if (error != 0) 2717 return error; 2718 2719 fd[0] = retval[0]; 2720 fd[1] = retval[1]; 2721 2722 error = copyout(fd, SCARG_P32(uap, fildes), sizeof(fd)); 2723 if (error != 0) 2724 return error; 2725 2726 retval[0] = 0; 2727 return 0; 2728 } 2729 2730 int 2731 netbsd32_dup3(struct lwp *l, const struct netbsd32_dup3_args *uap, 2732 register_t *retval) 2733 { 2734 /* { 2735 syscallarg(int) from; 2736 syscallarg(int) to; 2737 syscallarg(int) flags; 2738 } */ 2739 struct sys_dup3_args ua; 2740 2741 NETBSD32TO64_UAP(from); 2742 NETBSD32TO64_UAP(to); 2743 NETBSD32TO64_UAP(flags); 2744 2745 return sys_dup3(l, &ua, retval); 2746 } 2747 2748 int 2749 netbsd32_kqueue1(struct lwp *l, const struct netbsd32_kqueue1_args *uap, 2750 register_t *retval) 2751 { 2752 /* { 2753 syscallarg(int) flags; 2754 } */ 2755 struct sys_kqueue1_args ua; 2756 2757 NETBSD32TO64_UAP(flags); 2758 2759 return sys_kqueue1(l, &ua, retval); 2760 } 2761 2762 int 2763 netbsd32_paccept(struct lwp *l, const struct netbsd32_paccept_args *uap, 2764 register_t *retval) 2765 { 2766 /* { 2767 syscallarg(int) s; 2768 syscallarg(netbsd32_sockaddrp_t) name; 2769 syscallarg(netbsd32_socklenp_t) anamelen; 2770 syscallarg(const netbsd32_sigsetp_t) mask; 2771 syscallarg(int) flags; 2772 } */ 2773 struct sys_paccept_args ua; 2774 2775 NETBSD32TO64_UAP(s); 2776 NETBSD32TOP_UAP(name, struct sockaddr *); 2777 NETBSD32TOP_UAP(anamelen, socklen_t *); 2778 NETBSD32TOP_UAP(mask, const sigset_t *); 2779 NETBSD32TO64_UAP(flags); 2780 2781 return sys_paccept(l, &ua, retval); 2782 } 2783 2784 /* 2785 * MI indirect system call support. 2786 * Only used if the MD netbsd32_syscall.c doesn't intercept the calls. 2787 */ 2788 2789 #define NETBSD32_SYSCALL 2790 #undef SYS_NSYSENT 2791 #define SYS_NSYSENT NETBSD32_SYS_NSYSENT 2792 2793 #define SYS_SYSCALL netbsd32_syscall 2794 #include "../../kern/sys_syscall.c" 2795 #undef SYS_SYSCALL 2796 2797 #define SYS_SYSCALL netbsd32____syscall 2798 #include "../../kern/sys_syscall.c" 2799 #undef SYS_SYSCALL 2800