1 /* $NetBSD: netbsd32_netbsd.c,v 1.192 2014/06/28 22:27:50 dholland 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.192 2014/06/28 22:27:50 dholland 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_DEL: 1239 args.u.del.qc_key = NETBSD32PTR64(args32.u.del.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 usz32, 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 1316 error = pathbuf_copyin(SCARG_P32(uap, fname), &pb); 1317 if (error) { 1318 return error; 1319 } 1320 1321 NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF | TRYEMULROOT, pb); 1322 error = namei(&nd); 1323 if (error) { 1324 pathbuf_destroy(pb); 1325 return error; 1326 } 1327 vp = nd.ni_vp; 1328 pathbuf_destroy(pb); 1329 1330 error = vfs_composefh_alloc(vp, &fh); 1331 vput(vp); 1332 if (error != 0) { 1333 return error; 1334 } 1335 error = copyin(SCARG_P32(uap, fh_size), &usz32, sizeof(usz32)); 1336 if (error != 0) { 1337 goto out; 1338 } 1339 sz = FHANDLE_SIZE(fh); 1340 sz32 = sz; 1341 1342 error = copyout(&sz32, SCARG_P32(uap, fh_size), sizeof(sz32)); 1343 if (error != 0) { 1344 goto out; 1345 } 1346 if (usz32 >= sz32) { 1347 error = copyout(fh, SCARG_P32(uap, fhp), sz); 1348 } else { 1349 error = E2BIG; 1350 } 1351 out: 1352 vfs_composefh_free(fh); 1353 return (error); 1354 } 1355 1356 int 1357 netbsd32_pread(struct lwp *l, const struct netbsd32_pread_args *uap, register_t *retval) 1358 { 1359 /* { 1360 syscallarg(int) fd; 1361 syscallarg(netbsd32_voidp) buf; 1362 syscallarg(netbsd32_size_t) nbyte; 1363 syscallarg(int) PAD; 1364 syscallarg(netbsd32_off_t) offset; 1365 } */ 1366 struct sys_pread_args ua; 1367 1368 NETBSD32TO64_UAP(fd); 1369 NETBSD32TOP_UAP(buf, void); 1370 NETBSD32TOX_UAP(nbyte, size_t); 1371 NETBSD32TO64_UAP(PAD); 1372 NETBSD32TO64_UAP(offset); 1373 return sys_pread(l, &ua, retval); 1374 } 1375 1376 int 1377 netbsd32_pwrite(struct lwp *l, const struct netbsd32_pwrite_args *uap, register_t *retval) 1378 { 1379 /* { 1380 syscallarg(int) fd; 1381 syscallarg(const netbsd32_voidp) buf; 1382 syscallarg(netbsd32_size_t) nbyte; 1383 syscallarg(int) PAD; 1384 syscallarg(netbsd32_off_t) offset; 1385 } */ 1386 struct sys_pwrite_args ua; 1387 1388 NETBSD32TO64_UAP(fd); 1389 NETBSD32TOP_UAP(buf, void); 1390 NETBSD32TOX_UAP(nbyte, size_t); 1391 NETBSD32TO64_UAP(PAD); 1392 NETBSD32TO64_UAP(offset); 1393 return sys_pwrite(l, &ua, retval); 1394 } 1395 1396 int 1397 netbsd32_setgid(struct lwp *l, const struct netbsd32_setgid_args *uap, register_t *retval) 1398 { 1399 /* { 1400 syscallarg(gid_t) gid; 1401 } */ 1402 struct sys_setgid_args ua; 1403 1404 NETBSD32TO64_UAP(gid); 1405 return (sys_setgid(l, &ua, retval)); 1406 } 1407 1408 int 1409 netbsd32_setegid(struct lwp *l, const struct netbsd32_setegid_args *uap, register_t *retval) 1410 { 1411 /* { 1412 syscallarg(gid_t) egid; 1413 } */ 1414 struct sys_setegid_args ua; 1415 1416 NETBSD32TO64_UAP(egid); 1417 return (sys_setegid(l, &ua, retval)); 1418 } 1419 1420 int 1421 netbsd32_seteuid(struct lwp *l, const struct netbsd32_seteuid_args *uap, register_t *retval) 1422 { 1423 /* { 1424 syscallarg(gid_t) euid; 1425 } */ 1426 struct sys_seteuid_args ua; 1427 1428 NETBSD32TO64_UAP(euid); 1429 return (sys_seteuid(l, &ua, retval)); 1430 } 1431 1432 int 1433 netbsd32_pathconf(struct lwp *l, const struct netbsd32_pathconf_args *uap, register_t *retval) 1434 { 1435 /* { 1436 syscallarg(int) fd; 1437 syscallarg(int) name; 1438 } */ 1439 struct sys_pathconf_args ua; 1440 1441 NETBSD32TOP_UAP(path, const char); 1442 NETBSD32TO64_UAP(name); 1443 return sys_pathconf(l, &ua, retval); 1444 } 1445 1446 int 1447 netbsd32_fpathconf(struct lwp *l, const struct netbsd32_fpathconf_args *uap, register_t *retval) 1448 { 1449 /* { 1450 syscallarg(int) fd; 1451 syscallarg(int) name; 1452 } */ 1453 struct sys_fpathconf_args ua; 1454 1455 NETBSD32TO64_UAP(fd); 1456 NETBSD32TO64_UAP(name); 1457 return sys_fpathconf(l, &ua, retval); 1458 } 1459 1460 int 1461 netbsd32_getrlimit(struct lwp *l, const struct netbsd32_getrlimit_args *uap, register_t *retval) 1462 { 1463 /* { 1464 syscallarg(int) which; 1465 syscallarg(netbsd32_rlimitp_t) rlp; 1466 } */ 1467 int which = SCARG(uap, which); 1468 1469 if ((u_int)which >= RLIM_NLIMITS) 1470 return (EINVAL); 1471 return (copyout(&l->l_proc->p_rlimit[which], 1472 SCARG_P32(uap, rlp), sizeof(struct rlimit))); 1473 } 1474 1475 int 1476 netbsd32_setrlimit(struct lwp *l, const struct netbsd32_setrlimit_args *uap, register_t *retval) 1477 { 1478 /* { 1479 syscallarg(int) which; 1480 syscallarg(const netbsd32_rlimitp_t) rlp; 1481 } */ 1482 int which = SCARG(uap, which); 1483 struct rlimit alim; 1484 int error; 1485 1486 error = copyin(SCARG_P32(uap, rlp), &alim, sizeof(struct rlimit)); 1487 if (error) 1488 return (error); 1489 1490 switch (which) { 1491 case RLIMIT_DATA: 1492 if (LIMITCHECK(alim.rlim_cur, MAXDSIZ32)) 1493 alim.rlim_cur = MAXDSIZ32; 1494 if (LIMITCHECK(alim.rlim_max, MAXDSIZ32)) 1495 alim.rlim_max = MAXDSIZ32; 1496 break; 1497 1498 case RLIMIT_STACK: 1499 if (LIMITCHECK(alim.rlim_cur, MAXSSIZ32)) 1500 alim.rlim_cur = MAXSSIZ32; 1501 if (LIMITCHECK(alim.rlim_max, MAXSSIZ32)) 1502 alim.rlim_max = MAXSSIZ32; 1503 default: 1504 break; 1505 } 1506 1507 return (dosetrlimit(l, l->l_proc, which, &alim)); 1508 } 1509 1510 int 1511 netbsd32_mmap(struct lwp *l, const struct netbsd32_mmap_args *uap, register_t *retval) 1512 { 1513 /* { 1514 syscallarg(netbsd32_voidp) addr; 1515 syscallarg(netbsd32_size_t) len; 1516 syscallarg(int) prot; 1517 syscallarg(int) flags; 1518 syscallarg(int) fd; 1519 syscallarg(netbsd32_long) PAD; 1520 syscallarg(netbsd32_off_t) pos; 1521 } */ 1522 struct sys_mmap_args ua; 1523 int error; 1524 1525 NETBSD32TOP_UAP(addr, void); 1526 NETBSD32TOX_UAP(len, size_t); 1527 NETBSD32TO64_UAP(prot); 1528 NETBSD32TO64_UAP(flags); 1529 #ifdef __x86_64__ 1530 /* 1531 * Ancient kernel on x86 did not obey PROT_EXEC on i386 at least 1532 * and ld.so did not turn it on! 1533 */ 1534 if (SCARG(&ua, flags) & MAP_COPY) 1535 SCARG(&ua, prot) |= PROT_EXEC; 1536 #endif 1537 NETBSD32TO64_UAP(fd); 1538 NETBSD32TOX_UAP(PAD, long); 1539 NETBSD32TOX_UAP(pos, off_t); 1540 #ifdef DEBUG_MMAP 1541 printf("mmap(addr=0x%lx, len=0x%lx, prot=0x%lx, flags=0x%lx, " 1542 "fd=%ld, pos=0x%lx);\n", 1543 (long)SCARG(&ua, addr), (long)SCARG(&ua, len), 1544 (long)SCARG(&ua, prot), (long)SCARG(&ua, flags), 1545 (long)SCARG(&ua, fd), (long)SCARG(&ua, pos)); 1546 #endif 1547 error = sys_mmap(l, &ua, retval); 1548 if ((u_long)*retval > (u_long)UINT_MAX) { 1549 printf("netbsd32_mmap: retval out of range: 0x%lx", 1550 (u_long)*retval); 1551 /* Should try to recover and return an error here. */ 1552 } 1553 return (error); 1554 } 1555 1556 int 1557 netbsd32_mremap(struct lwp *l, const struct netbsd32_mremap_args *uap, register_t *retval) 1558 { 1559 /* { 1560 syscallarg(void *) old_address; 1561 syscallarg(size_t) old_size; 1562 syscallarg(void *) new_address; 1563 syscallarg(size_t) new_size; 1564 syscallarg(int) flags; 1565 } */ 1566 struct sys_mremap_args ua; 1567 1568 NETBSD32TOP_UAP(old_address, void); 1569 NETBSD32TOX_UAP(old_size, size_t); 1570 NETBSD32TOP_UAP(new_address, void); 1571 NETBSD32TOX_UAP(new_size, size_t); 1572 NETBSD32TO64_UAP(flags); 1573 1574 return sys_mremap(l, &ua, retval); 1575 } 1576 1577 int 1578 netbsd32_lseek(struct lwp *l, const struct netbsd32_lseek_args *uap, register_t *retval) 1579 { 1580 /* { 1581 syscallarg(int) fd; 1582 syscallarg(int) PAD; 1583 syscallarg(netbsd32_off_t) offset; 1584 syscallarg(int) whence; 1585 } */ 1586 struct sys_lseek_args ua; 1587 union { 1588 register_t retval64[2]; 1589 register32_t retval32[4]; 1590 } newpos; 1591 int rv; 1592 1593 NETBSD32TO64_UAP(fd); 1594 NETBSD32TO64_UAP(PAD); 1595 NETBSD32TO64_UAP(offset); 1596 NETBSD32TO64_UAP(whence); 1597 rv = sys_lseek(l, &ua, newpos.retval64); 1598 1599 /* 1600 * We have to split the 64 bit value into 2 halves which will 1601 * end up in separate 32 bit registers. 1602 * This should DTRT on big and little-endian systems provided that 1603 * gcc's 'strict aliasing' tests don't decide that the retval32[] 1604 * entries can't have been assigned to, so need not be read! 1605 */ 1606 retval[0] = newpos.retval32[0]; 1607 retval[1] = newpos.retval32[1]; 1608 1609 return rv; 1610 } 1611 1612 int 1613 netbsd32_truncate(struct lwp *l, const struct netbsd32_truncate_args *uap, register_t *retval) 1614 { 1615 /* { 1616 syscallarg(const netbsd32_charp) path; 1617 syscallarg(int) PAD; 1618 syscallarg(netbsd32_off_t) length; 1619 } */ 1620 struct sys_truncate_args ua; 1621 1622 NETBSD32TOP_UAP(path, const char); 1623 NETBSD32TO64_UAP(PAD); 1624 NETBSD32TO64_UAP(length); 1625 return (sys_truncate(l, &ua, retval)); 1626 } 1627 1628 int 1629 netbsd32_ftruncate(struct lwp *l, const struct netbsd32_ftruncate_args *uap, register_t *retval) 1630 { 1631 /* { 1632 syscallarg(int) fd; 1633 syscallarg(int) PAD; 1634 syscallarg(netbsd32_off_t) length; 1635 } */ 1636 struct sys_ftruncate_args ua; 1637 1638 NETBSD32TO64_UAP(fd); 1639 NETBSD32TO64_UAP(PAD); 1640 NETBSD32TO64_UAP(length); 1641 return (sys_ftruncate(l, &ua, retval)); 1642 } 1643 1644 int 1645 netbsd32_mlock(struct lwp *l, const struct netbsd32_mlock_args *uap, register_t *retval) 1646 { 1647 /* { 1648 syscallarg(const netbsd32_voidp) addr; 1649 syscallarg(netbsd32_size_t) len; 1650 } */ 1651 struct sys_mlock_args ua; 1652 1653 NETBSD32TOP_UAP(addr, const void); 1654 NETBSD32TO64_UAP(len); 1655 return (sys_mlock(l, &ua, retval)); 1656 } 1657 1658 int 1659 netbsd32_munlock(struct lwp *l, const struct netbsd32_munlock_args *uap, register_t *retval) 1660 { 1661 /* { 1662 syscallarg(const netbsd32_voidp) addr; 1663 syscallarg(netbsd32_size_t) len; 1664 } */ 1665 struct sys_munlock_args ua; 1666 1667 NETBSD32TOP_UAP(addr, const void); 1668 NETBSD32TO64_UAP(len); 1669 return (sys_munlock(l, &ua, retval)); 1670 } 1671 1672 int 1673 netbsd32_undelete(struct lwp *l, const struct netbsd32_undelete_args *uap, register_t *retval) 1674 { 1675 /* { 1676 syscallarg(const netbsd32_charp) path; 1677 } */ 1678 struct sys_undelete_args ua; 1679 1680 NETBSD32TOP_UAP(path, const char); 1681 return (sys_undelete(l, &ua, retval)); 1682 } 1683 1684 int 1685 netbsd32_getpgid(struct lwp *l, const struct netbsd32_getpgid_args *uap, register_t *retval) 1686 { 1687 /* { 1688 syscallarg(pid_t) pid; 1689 } */ 1690 struct sys_getpgid_args ua; 1691 1692 NETBSD32TO64_UAP(pid); 1693 return (sys_getpgid(l, &ua, retval)); 1694 } 1695 1696 int 1697 netbsd32_reboot(struct lwp *l, const struct netbsd32_reboot_args *uap, register_t *retval) 1698 { 1699 /* { 1700 syscallarg(int) opt; 1701 syscallarg(netbsd32_charp) bootstr; 1702 } */ 1703 struct sys_reboot_args ua; 1704 1705 NETBSD32TO64_UAP(opt); 1706 NETBSD32TOP_UAP(bootstr, char); 1707 return (sys_reboot(l, &ua, retval)); 1708 } 1709 1710 #include <sys/poll.h> 1711 int 1712 netbsd32_poll(struct lwp *l, const struct netbsd32_poll_args *uap, register_t *retval) 1713 { 1714 /* { 1715 syscallarg(netbsd32_pollfdp_t) fds; 1716 syscallarg(u_int) nfds; 1717 syscallarg(int) timeout; 1718 } */ 1719 struct sys_poll_args ua; 1720 1721 NETBSD32TOP_UAP(fds, struct pollfd); 1722 NETBSD32TO64_UAP(nfds); 1723 NETBSD32TO64_UAP(timeout); 1724 1725 return (sys_poll(l, &ua, retval)); 1726 } 1727 1728 int 1729 netbsd32_fdatasync(struct lwp *l, const struct netbsd32_fdatasync_args *uap, register_t *retval) 1730 { 1731 /* { 1732 syscallarg(int) fd; 1733 } */ 1734 struct sys_fdatasync_args ua; 1735 1736 NETBSD32TO64_UAP(fd); 1737 return (sys_fdatasync(l, &ua, retval)); 1738 } 1739 1740 int 1741 netbsd32___posix_rename(struct lwp *l, const struct netbsd32___posix_rename_args *uap, register_t *retval) 1742 { 1743 /* { 1744 syscallarg(const netbsd32_charp) from; 1745 syscallarg(const netbsd32_charp) to; 1746 } */ 1747 struct sys___posix_rename_args ua; 1748 1749 NETBSD32TOP_UAP(from, const char); 1750 NETBSD32TOP_UAP(to, const char); 1751 return (sys___posix_rename(l, &ua, retval)); 1752 } 1753 1754 static int 1755 netbsd32_swapctl_stats(struct lwp *l, struct sys_swapctl_args *uap, register_t *retval) 1756 { 1757 struct swapent *ksep; 1758 struct netbsd32_swapent *usep32; 1759 struct netbsd32_swapent se32; 1760 int count = SCARG(uap, misc); 1761 int i, error = 0; 1762 size_t ksep_len; 1763 1764 if (count < 0) 1765 return EINVAL; 1766 if (count == 0 || uvmexp.nswapdev == 0) 1767 return 0; 1768 /* Make sure userland cannot exhaust kernel memory */ 1769 if ((size_t)count > (size_t)uvmexp.nswapdev) 1770 count = uvmexp.nswapdev; 1771 1772 ksep_len = sizeof(*ksep) * count; 1773 ksep = kmem_alloc(ksep_len, KM_SLEEP); 1774 usep32 = (struct netbsd32_swapent *)SCARG(uap, arg); 1775 1776 uvm_swap_stats(SWAP_STATS, ksep, count, retval); 1777 count = *retval; 1778 1779 for (i = 0; i < count; i++) { 1780 se32.se_dev = ksep[i].se_dev; 1781 se32.se_flags = ksep[i].se_flags; 1782 se32.se_nblks = ksep[i].se_nblks; 1783 se32.se_inuse = ksep[i].se_inuse; 1784 se32.se_priority = ksep[i].se_priority; 1785 memcpy(se32.se_path, ksep[i].se_path, 1786 sizeof(se32.se_path)); 1787 1788 error = copyout(&se32, usep32 + i, sizeof(se32)); 1789 if (error) 1790 break; 1791 } 1792 1793 kmem_free(ksep, ksep_len); 1794 1795 return error; 1796 } 1797 1798 int 1799 netbsd32_swapctl(struct lwp *l, const struct netbsd32_swapctl_args *uap, register_t *retval) 1800 { 1801 /* { 1802 syscallarg(int) cmd; 1803 syscallarg(const netbsd32_voidp) arg; 1804 syscallarg(int) misc; 1805 } */ 1806 struct sys_swapctl_args ua; 1807 1808 NETBSD32TO64_UAP(cmd); 1809 NETBSD32TOP_UAP(arg, void); 1810 NETBSD32TO64_UAP(misc); 1811 1812 /* SWAP_STATS50 and SWAP_STATS13 structures need no translation */ 1813 if (SCARG(&ua, cmd) == SWAP_STATS) 1814 return netbsd32_swapctl_stats(l, &ua, retval); 1815 1816 return (sys_swapctl(l, &ua, retval)); 1817 } 1818 1819 int 1820 netbsd32_minherit(struct lwp *l, const struct netbsd32_minherit_args *uap, register_t *retval) 1821 { 1822 /* { 1823 syscallarg(netbsd32_voidp) addr; 1824 syscallarg(netbsd32_size_t) len; 1825 syscallarg(int) inherit; 1826 } */ 1827 struct sys_minherit_args ua; 1828 1829 NETBSD32TOP_UAP(addr, void); 1830 NETBSD32TOX_UAP(len, size_t); 1831 NETBSD32TO64_UAP(inherit); 1832 return (sys_minherit(l, &ua, retval)); 1833 } 1834 1835 int 1836 netbsd32_lchmod(struct lwp *l, const struct netbsd32_lchmod_args *uap, register_t *retval) 1837 { 1838 /* { 1839 syscallarg(const netbsd32_charp) path; 1840 syscallarg(mode_t) mode; 1841 } */ 1842 struct sys_lchmod_args ua; 1843 1844 NETBSD32TOP_UAP(path, const char); 1845 NETBSD32TO64_UAP(mode); 1846 return (sys_lchmod(l, &ua, retval)); 1847 } 1848 1849 int 1850 netbsd32_lchown(struct lwp *l, const struct netbsd32_lchown_args *uap, register_t *retval) 1851 { 1852 /* { 1853 syscallarg(const netbsd32_charp) path; 1854 syscallarg(uid_t) uid; 1855 syscallarg(gid_t) gid; 1856 } */ 1857 struct sys_lchown_args ua; 1858 1859 NETBSD32TOP_UAP(path, const char); 1860 NETBSD32TO64_UAP(uid); 1861 NETBSD32TO64_UAP(gid); 1862 return (sys_lchown(l, &ua, retval)); 1863 } 1864 1865 int 1866 netbsd32___msync13(struct lwp *l, const struct netbsd32___msync13_args *uap, register_t *retval) 1867 { 1868 /* { 1869 syscallarg(netbsd32_voidp) addr; 1870 syscallarg(netbsd32_size_t) len; 1871 syscallarg(int) flags; 1872 } */ 1873 struct sys___msync13_args ua; 1874 1875 NETBSD32TOP_UAP(addr, void); 1876 NETBSD32TOX_UAP(len, size_t); 1877 NETBSD32TO64_UAP(flags); 1878 return (sys___msync13(l, &ua, retval)); 1879 } 1880 1881 int 1882 netbsd32___posix_chown(struct lwp *l, const struct netbsd32___posix_chown_args *uap, register_t *retval) 1883 { 1884 /* { 1885 syscallarg(const netbsd32_charp) path; 1886 syscallarg(uid_t) uid; 1887 syscallarg(gid_t) gid; 1888 } */ 1889 struct sys___posix_chown_args ua; 1890 1891 NETBSD32TOP_UAP(path, const char); 1892 NETBSD32TO64_UAP(uid); 1893 NETBSD32TO64_UAP(gid); 1894 return (sys___posix_chown(l, &ua, retval)); 1895 } 1896 1897 int 1898 netbsd32___posix_fchown(struct lwp *l, const struct netbsd32___posix_fchown_args *uap, register_t *retval) 1899 { 1900 /* { 1901 syscallarg(int) fd; 1902 syscallarg(uid_t) uid; 1903 syscallarg(gid_t) gid; 1904 } */ 1905 struct sys___posix_fchown_args ua; 1906 1907 NETBSD32TO64_UAP(fd); 1908 NETBSD32TO64_UAP(uid); 1909 NETBSD32TO64_UAP(gid); 1910 return (sys___posix_fchown(l, &ua, retval)); 1911 } 1912 1913 int 1914 netbsd32___posix_lchown(struct lwp *l, const struct netbsd32___posix_lchown_args *uap, register_t *retval) 1915 { 1916 /* { 1917 syscallarg(const netbsd32_charp) path; 1918 syscallarg(uid_t) uid; 1919 syscallarg(gid_t) gid; 1920 } */ 1921 struct sys___posix_lchown_args ua; 1922 1923 NETBSD32TOP_UAP(path, const char); 1924 NETBSD32TO64_UAP(uid); 1925 NETBSD32TO64_UAP(gid); 1926 return (sys___posix_lchown(l, &ua, retval)); 1927 } 1928 1929 int 1930 netbsd32_getsid(struct lwp *l, const struct netbsd32_getsid_args *uap, register_t *retval) 1931 { 1932 /* { 1933 syscallarg(pid_t) pid; 1934 } */ 1935 struct sys_getsid_args ua; 1936 1937 NETBSD32TO64_UAP(pid); 1938 return (sys_getsid(l, &ua, retval)); 1939 } 1940 1941 int 1942 netbsd32_fktrace(struct lwp *l, const struct netbsd32_fktrace_args *uap, register_t *retval) 1943 { 1944 /* { 1945 syscallarg(int) fd; 1946 syscallarg(int) ops; 1947 syscallarg(int) facs; 1948 syscallarg(int) pid; 1949 } */ 1950 struct sys_fktrace_args ua; 1951 1952 NETBSD32TOX_UAP(fd, int); 1953 NETBSD32TO64_UAP(ops); 1954 NETBSD32TO64_UAP(facs); 1955 NETBSD32TO64_UAP(pid); 1956 return (sys_fktrace(l, &ua, retval)); 1957 } 1958 1959 int 1960 netbsd32___sigpending14(struct lwp *l, const struct netbsd32___sigpending14_args *uap, register_t *retval) 1961 { 1962 /* { 1963 syscallarg(sigset_t *) set; 1964 } */ 1965 struct sys___sigpending14_args ua; 1966 1967 NETBSD32TOP_UAP(set, sigset_t); 1968 return (sys___sigpending14(l, &ua, retval)); 1969 } 1970 1971 int 1972 netbsd32___sigprocmask14(struct lwp *l, const struct netbsd32___sigprocmask14_args *uap, register_t *retval) 1973 { 1974 /* { 1975 syscallarg(int) how; 1976 syscallarg(const sigset_t *) set; 1977 syscallarg(sigset_t *) oset; 1978 } */ 1979 struct sys___sigprocmask14_args ua; 1980 1981 NETBSD32TO64_UAP(how); 1982 NETBSD32TOP_UAP(set, sigset_t); 1983 NETBSD32TOP_UAP(oset, sigset_t); 1984 return (sys___sigprocmask14(l, &ua, retval)); 1985 } 1986 1987 int 1988 netbsd32___sigsuspend14(struct lwp *l, const struct netbsd32___sigsuspend14_args *uap, register_t *retval) 1989 { 1990 /* { 1991 syscallarg(const sigset_t *) set; 1992 } */ 1993 struct sys___sigsuspend14_args ua; 1994 1995 NETBSD32TOP_UAP(set, sigset_t); 1996 return (sys___sigsuspend14(l, &ua, retval)); 1997 } 1998 1999 int 2000 netbsd32_fchroot(struct lwp *l, const struct netbsd32_fchroot_args *uap, register_t *retval) 2001 { 2002 /* { 2003 syscallarg(int) fd; 2004 } */ 2005 struct sys_fchroot_args ua; 2006 2007 NETBSD32TO64_UAP(fd); 2008 return (sys_fchroot(l, &ua, retval)); 2009 } 2010 2011 /* 2012 * Open a file given a file handle. 2013 * 2014 * Check permissions, allocate an open file structure, 2015 * and call the device open routine if any. 2016 */ 2017 int 2018 netbsd32___fhopen40(struct lwp *l, const struct netbsd32___fhopen40_args *uap, register_t *retval) 2019 { 2020 /* { 2021 syscallarg(const netbsd32_pointer_t *) fhp; 2022 syscallarg(netbsd32_size_t) fh_size; 2023 syscallarg(int) flags; 2024 } */ 2025 struct sys___fhopen40_args ua; 2026 2027 NETBSD32TOP_UAP(fhp, fhandle_t); 2028 NETBSD32TO64_UAP(fh_size); 2029 NETBSD32TO64_UAP(flags); 2030 return (sys___fhopen40(l, &ua, retval)); 2031 } 2032 2033 /* virtual memory syscalls */ 2034 int 2035 netbsd32_ovadvise(struct lwp *l, const struct netbsd32_ovadvise_args *uap, register_t *retval) 2036 { 2037 /* { 2038 syscallarg(int) anom; 2039 } */ 2040 struct sys_ovadvise_args ua; 2041 2042 NETBSD32TO64_UAP(anom); 2043 return (sys_ovadvise(l, &ua, retval)); 2044 } 2045 2046 void 2047 netbsd32_adjust_limits(struct proc *p) 2048 { 2049 static const struct { 2050 int id; 2051 rlim_t lim; 2052 } lm[] = { 2053 { RLIMIT_DATA, MAXDSIZ32 }, 2054 { RLIMIT_STACK, MAXSSIZ32 }, 2055 }; 2056 size_t i; 2057 struct plimit *lim; 2058 struct rlimit *rlim; 2059 2060 /* 2061 * We can only reduce the current limits, we cannot stop external 2062 * processes from changing them (eg via sysctl) later on. 2063 * So there is no point trying to lock out such changes here. 2064 * 2065 * If we assume that rlim_cur/max are accessed using atomic 2066 * operations, we don't need to lock against any other updates 2067 * that might happen if the plimit structure is shared writable 2068 * between multiple processes. 2069 */ 2070 2071 /* Scan to determine is any limits are out of range */ 2072 lim = p->p_limit; 2073 for (i = 0; ; i++) { 2074 if (i >= __arraycount(lm)) 2075 /* All in range */ 2076 return; 2077 rlim = lim->pl_rlimit + lm[i].id; 2078 if (LIMITCHECK(rlim->rlim_cur, lm[i].lim)) 2079 break; 2080 if (LIMITCHECK(rlim->rlim_max, lm[i].lim)) 2081 break; 2082 } 2083 2084 lim_privatise(p); 2085 2086 lim = p->p_limit; 2087 for (i = 0; i < __arraycount(lm); i++) { 2088 rlim = lim->pl_rlimit + lm[i].id; 2089 if (LIMITCHECK(rlim->rlim_cur, lm[i].lim)) 2090 rlim->rlim_cur = lm[i].lim; 2091 if (LIMITCHECK(rlim->rlim_max, lm[i].lim)) 2092 rlim->rlim_max = lm[i].lim; 2093 } 2094 } 2095 2096 int 2097 netbsd32_uuidgen(struct lwp *l, const struct netbsd32_uuidgen_args *uap, register_t *retval) 2098 { 2099 /* { 2100 syscallarg(netbsd32_uuidp_t) store; 2101 syscallarg(int) count; 2102 } */ 2103 struct sys_uuidgen_args ua; 2104 2105 NETBSD32TOP_UAP(store, struct uuid); 2106 NETBSD32TO64_UAP(count); 2107 return (sys_uuidgen(l, &ua, retval)); 2108 } 2109 2110 int 2111 netbsd32_extattrctl(struct lwp *l, const struct netbsd32_extattrctl_args *uap, register_t *retval) 2112 { 2113 /* { 2114 syscallarg(const netbsd32_charp) path; 2115 syscallarg(int) cmd; 2116 syscallarg(const netbsd32_charp) filename; 2117 syscallarg(int) attrnamespace; 2118 syscallarg(const netbsd32_charp) attrname; 2119 } */ 2120 struct sys_extattrctl_args ua; 2121 2122 NETBSD32TOP_UAP(path, const char); 2123 NETBSD32TO64_UAP(cmd); 2124 NETBSD32TOP_UAP(filename, const char); 2125 NETBSD32TO64_UAP(attrnamespace); 2126 NETBSD32TOP_UAP(attrname, const char); 2127 return sys_extattrctl(l, &ua, retval); 2128 } 2129 2130 int 2131 netbsd32_extattr_set_fd(struct lwp *l, const struct netbsd32_extattr_set_fd_args *uap, register_t *retval) 2132 { 2133 /* { 2134 syscallarg(int) fd; 2135 syscallarg(int) attrnamespace; 2136 syscallarg(const netbsd32_charp) attrname; 2137 syscallarg(const netbsd32_voidp) data; 2138 syscallarg(netbsd32_size_t) nbytes; 2139 } */ 2140 struct sys_extattr_set_fd_args ua; 2141 2142 NETBSD32TO64_UAP(fd); 2143 NETBSD32TO64_UAP(attrnamespace); 2144 NETBSD32TOP_UAP(attrname, const char); 2145 NETBSD32TOP_UAP(data, const void); 2146 NETBSD32TOX_UAP(nbytes, size_t); 2147 return sys_extattr_set_fd(l, &ua, retval); 2148 } 2149 2150 int 2151 netbsd32_extattr_set_file(struct lwp *l, const struct netbsd32_extattr_set_file_args *uap, register_t *retval) 2152 { 2153 /* { 2154 syscallarg(const netbsd32_charp) path; 2155 syscallarg(int) attrnamespace; 2156 syscallarg(const netbsd32_charp) attrname; 2157 syscallarg(const netbsd32_voidp) data; 2158 syscallarg(netbsd32_size_t) nbytes; 2159 } */ 2160 struct sys_extattr_set_file_args ua; 2161 2162 NETBSD32TOP_UAP(path, const char); 2163 NETBSD32TO64_UAP(attrnamespace); 2164 NETBSD32TOP_UAP(attrname, const char); 2165 NETBSD32TOP_UAP(data, const void); 2166 NETBSD32TOX_UAP(nbytes, size_t); 2167 return sys_extattr_set_file(l, &ua, retval); 2168 } 2169 2170 int 2171 netbsd32_extattr_set_link(struct lwp *l, const struct netbsd32_extattr_set_link_args *uap, register_t *retval) 2172 { 2173 /* { 2174 syscallarg(const netbsd32_charp) path; 2175 syscallarg(int) attrnamespace; 2176 syscallarg(const netbsd32_charp) attrname; 2177 syscallarg(const netbsd32_voidp) data; 2178 syscallarg(netbsd32_size_t) nbytes; 2179 } */ 2180 struct sys_extattr_set_link_args ua; 2181 2182 NETBSD32TOP_UAP(path, const char); 2183 NETBSD32TO64_UAP(attrnamespace); 2184 NETBSD32TOP_UAP(attrname, const char); 2185 NETBSD32TOP_UAP(data, const void); 2186 NETBSD32TOX_UAP(nbytes, size_t); 2187 return sys_extattr_set_link(l, &ua, retval); 2188 } 2189 2190 int 2191 netbsd32_extattr_get_fd(struct lwp *l, const struct netbsd32_extattr_get_fd_args *uap, register_t *retval) 2192 { 2193 /* { 2194 syscallarg(int) fd; 2195 syscallarg(int) attrnamespace; 2196 syscallarg(const netbsd32_charp) attrname; 2197 syscallarg(netbsd32_voidp) data; 2198 syscallarg(netbsd32_size_t) nbytes; 2199 } */ 2200 struct sys_extattr_get_fd_args ua; 2201 2202 NETBSD32TO64_UAP(fd); 2203 NETBSD32TO64_UAP(attrnamespace); 2204 NETBSD32TOP_UAP(attrname, const char); 2205 NETBSD32TOP_UAP(data, void); 2206 NETBSD32TOX_UAP(nbytes, size_t); 2207 return sys_extattr_get_fd(l, &ua, retval); 2208 } 2209 2210 int 2211 netbsd32_extattr_get_file(struct lwp *l, const struct netbsd32_extattr_get_file_args *uap, register_t *retval) 2212 { 2213 /* { 2214 syscallarg(const netbsd32_charp) path; 2215 syscallarg(int) attrnamespace; 2216 syscallarg(const netbsd32_charp) attrname; 2217 syscallarg(netbsd32_voidp) data; 2218 syscallarg(netbsd32_size_t) nbytes; 2219 } */ 2220 struct sys_extattr_get_file_args ua; 2221 2222 NETBSD32TOP_UAP(path, const char); 2223 NETBSD32TO64_UAP(attrnamespace); 2224 NETBSD32TOP_UAP(attrname, const char); 2225 NETBSD32TOP_UAP(data, void); 2226 NETBSD32TOX_UAP(nbytes, size_t); 2227 return sys_extattr_get_file(l, &ua, retval); 2228 } 2229 2230 int 2231 netbsd32_extattr_get_link(struct lwp *l, const struct netbsd32_extattr_get_link_args *uap, register_t *retval) 2232 { 2233 /* { 2234 syscallarg(const netbsd32_charp) path; 2235 syscallarg(int) attrnamespace; 2236 syscallarg(const netbsd32_charp) attrname; 2237 syscallarg(netbsd32_voidp) data; 2238 syscallarg(netbsd32_size_t) nbytes; 2239 } */ 2240 struct sys_extattr_get_link_args ua; 2241 2242 NETBSD32TOP_UAP(path, const char); 2243 NETBSD32TO64_UAP(attrnamespace); 2244 NETBSD32TOP_UAP(attrname, const char); 2245 NETBSD32TOP_UAP(data, void); 2246 NETBSD32TOX_UAP(nbytes, size_t); 2247 return sys_extattr_get_link(l, &ua, retval); 2248 } 2249 2250 int 2251 netbsd32_extattr_delete_fd(struct lwp *l, const struct netbsd32_extattr_delete_fd_args *uap, register_t *retval) 2252 { 2253 /* { 2254 syscallarg(int) fd; 2255 syscallarg(int) attrnamespace; 2256 syscallarg(const netbsd32_charp) attrname; 2257 } */ 2258 struct sys_extattr_delete_fd_args ua; 2259 2260 NETBSD32TO64_UAP(fd); 2261 NETBSD32TO64_UAP(attrnamespace); 2262 NETBSD32TOP_UAP(attrname, const char); 2263 return sys_extattr_delete_fd(l, &ua, retval); 2264 } 2265 2266 int 2267 netbsd32_extattr_delete_file(struct lwp *l, const struct netbsd32_extattr_delete_file_args *uap, register_t *retval) 2268 { 2269 /* { 2270 syscallarg(const netbsd32_charp) path; 2271 syscallarg(int) attrnamespace; 2272 syscallarg(const netbsd32_charp) attrname; 2273 } */ 2274 struct sys_extattr_delete_file_args ua; 2275 2276 NETBSD32TOP_UAP(path, const char); 2277 NETBSD32TO64_UAP(attrnamespace); 2278 NETBSD32TOP_UAP(attrname, const char); 2279 return sys_extattr_delete_file(l, &ua, retval); 2280 } 2281 2282 int 2283 netbsd32_extattr_delete_link(struct lwp *l, const struct netbsd32_extattr_delete_link_args *uap, register_t *retval) 2284 { 2285 /* { 2286 syscallarg(const netbsd32_charp) path; 2287 syscallarg(int) attrnamespace; 2288 syscallarg(const netbsd32_charp) attrname; 2289 } */ 2290 struct sys_extattr_delete_link_args ua; 2291 2292 NETBSD32TOP_UAP(path, const char); 2293 NETBSD32TO64_UAP(attrnamespace); 2294 NETBSD32TOP_UAP(attrname, const char); 2295 return sys_extattr_delete_link(l, &ua, retval); 2296 } 2297 2298 int 2299 netbsd32_extattr_list_fd(struct lwp *l, const struct netbsd32_extattr_list_fd_args *uap, register_t *retval) 2300 { 2301 /* { 2302 syscallarg(int) fd; 2303 syscallarg(int) attrnamespace; 2304 syscallarg(netbsd32_voidp) data; 2305 syscallarg(netbsd32_size_t) nbytes; 2306 } */ 2307 struct sys_extattr_list_fd_args ua; 2308 2309 NETBSD32TO64_UAP(fd); 2310 NETBSD32TO64_UAP(attrnamespace); 2311 NETBSD32TOP_UAP(data, void); 2312 NETBSD32TOX_UAP(nbytes, size_t); 2313 return sys_extattr_list_fd(l, &ua, retval); 2314 } 2315 2316 int 2317 netbsd32_extattr_list_file(struct lwp *l, const struct netbsd32_extattr_list_file_args *uap, register_t *retval) 2318 { 2319 /* { 2320 syscallarg(const netbsd32_charp) path; 2321 syscallarg(int) attrnamespace; 2322 syscallarg(netbsd32_voidp) data; 2323 syscallarg(netbsd32_size_t) nbytes; 2324 } */ 2325 struct sys_extattr_list_file_args ua; 2326 2327 NETBSD32TOP_UAP(path, const char); 2328 NETBSD32TO64_UAP(attrnamespace); 2329 NETBSD32TOP_UAP(data, void); 2330 NETBSD32TOX_UAP(nbytes, size_t); 2331 return sys_extattr_list_file(l, &ua, retval); 2332 } 2333 2334 int 2335 netbsd32_extattr_list_link(struct lwp *l, const struct netbsd32_extattr_list_link_args *uap, register_t *retval) 2336 { 2337 /* { 2338 syscallarg(const netbsd32_charp) path; 2339 syscallarg(int) attrnamespace; 2340 syscallarg(netbsd32_voidp) data; 2341 syscallarg(netbsd32_size_t) nbytes; 2342 } */ 2343 struct sys_extattr_list_link_args ua; 2344 2345 NETBSD32TOP_UAP(path, const char); 2346 NETBSD32TO64_UAP(attrnamespace); 2347 NETBSD32TOP_UAP(data, void); 2348 NETBSD32TOX_UAP(nbytes, size_t); 2349 return sys_extattr_list_link(l, &ua, retval); 2350 } 2351 2352 int 2353 netbsd32_mlockall(struct lwp *l, const struct netbsd32_mlockall_args *uap, register_t *retval) 2354 { 2355 /* { 2356 syscallarg(int) flags; 2357 } */ 2358 struct sys_mlockall_args ua; 2359 2360 NETBSD32TO64_UAP(flags); 2361 return (sys_mlockall(l, &ua, retval)); 2362 } 2363 2364 int 2365 netbsd32___clone(struct lwp *l, const struct netbsd32___clone_args *uap, register_t *retval) 2366 { 2367 /* { 2368 syscallarg(int) flags; 2369 syscallarg(netbsd32_voidp) stack; 2370 } */ 2371 struct sys___clone_args ua; 2372 2373 NETBSD32TO64_UAP(flags); 2374 NETBSD32TOP_UAP(stack, void); 2375 return sys___clone(l, &ua, retval); 2376 } 2377 2378 int 2379 netbsd32_fsync_range(struct lwp *l, const struct netbsd32_fsync_range_args *uap, register_t *retval) 2380 { 2381 /* { 2382 syscallarg(int) fd; 2383 syscallarg(int) flags; 2384 syscallarg(off_t) start; 2385 syscallarg(off_t) length; 2386 } */ 2387 struct sys_fsync_range_args ua; 2388 2389 NETBSD32TO64_UAP(fd); 2390 NETBSD32TO64_UAP(flags); 2391 NETBSD32TO64_UAP(start); 2392 NETBSD32TO64_UAP(length); 2393 return (sys_fsync_range(l, &ua, retval)); 2394 } 2395 2396 int 2397 netbsd32_rasctl(struct lwp *l, const struct netbsd32_rasctl_args *uap, register_t *retval) 2398 { 2399 /* { 2400 syscallarg(netbsd32_voidp) addr; 2401 syscallarg(netbsd32_size_t) len; 2402 syscallarg(int) op; 2403 } */ 2404 struct sys_rasctl_args ua; 2405 2406 NETBSD32TOP_UAP(addr, void *); 2407 NETBSD32TOX_UAP(len, size_t); 2408 NETBSD32TO64_UAP(op); 2409 return sys_rasctl(l, &ua, retval); 2410 } 2411 2412 int 2413 netbsd32_setxattr(struct lwp *l, const struct netbsd32_setxattr_args *uap, register_t *retval) 2414 { 2415 /* { 2416 syscallarg(const netbsd32_charp) path; 2417 syscallarg(const netbsd32_charp) name; 2418 syscallarg(netbsd32_voidp) value; 2419 syscallarg(netbsd32_size_t) size; 2420 syscallarg(int) flags; 2421 } */ 2422 struct sys_setxattr_args ua; 2423 NETBSD32TOP_UAP(path, const char); 2424 NETBSD32TOP_UAP(name, const char); 2425 NETBSD32TOP_UAP(value, void); 2426 NETBSD32TOX_UAP(size, size_t); 2427 NETBSD32TO64_UAP(flags); 2428 return sys_setxattr(l, &ua, retval); 2429 } 2430 2431 int 2432 netbsd32_lsetxattr(struct lwp *l, const struct netbsd32_lsetxattr_args *uap, register_t *retval) 2433 { 2434 /* { 2435 syscallarg(const netbsd32_charp) path; 2436 syscallarg(const netbsd32_charp) name; 2437 syscallarg(netbsd32_voidp) value; 2438 syscallarg(netbsd32_size_t) size; 2439 syscallarg(int) flags; 2440 } */ 2441 struct sys_lsetxattr_args ua; 2442 NETBSD32TOP_UAP(path, const char); 2443 NETBSD32TOP_UAP(name, const char); 2444 NETBSD32TOP_UAP(value, void); 2445 NETBSD32TOX_UAP(size, size_t); 2446 NETBSD32TO64_UAP(flags); 2447 return sys_lsetxattr(l, &ua, retval); 2448 } 2449 2450 int 2451 netbsd32_fsetxattr(struct lwp *l, const struct netbsd32_fsetxattr_args *uap, register_t *retval) 2452 { 2453 /* { 2454 syscallarg(int) fd; 2455 syscallarg(const netbsd32_charp) name; 2456 syscallarg(netbsd32_voidp) value; 2457 syscallarg(netbsd32_size_t) size; 2458 syscallarg(int) flags; 2459 } */ 2460 struct sys_fsetxattr_args ua; 2461 NETBSD32TO64_UAP(fd); 2462 NETBSD32TOP_UAP(name, const char); 2463 NETBSD32TOP_UAP(value, void); 2464 NETBSD32TOX_UAP(size, size_t); 2465 NETBSD32TO64_UAP(flags); 2466 return sys_fsetxattr(l, &ua, retval); 2467 } 2468 2469 int 2470 netbsd32_getxattr(struct lwp *l, const struct netbsd32_getxattr_args *uap, register_t *retval) 2471 { 2472 /* { 2473 syscallarg(const netbsd32_charp) path; 2474 syscallarg(const netbsd32_charp) name; 2475 syscallarg(netbsd32_voidp) value; 2476 syscallarg(netbsd32_size_t) size; 2477 } */ 2478 struct sys_getxattr_args ua; 2479 NETBSD32TOP_UAP(path, const char); 2480 NETBSD32TOP_UAP(name, const char); 2481 NETBSD32TOP_UAP(value, void); 2482 NETBSD32TOX_UAP(size, size_t); 2483 return sys_getxattr(l, &ua, retval); 2484 } 2485 2486 int 2487 netbsd32_lgetxattr(struct lwp *l, const struct netbsd32_lgetxattr_args *uap, register_t *retval) 2488 { 2489 /* { 2490 syscallarg(const netbsd32_charp) path; 2491 syscallarg(const netbsd32_charp) name; 2492 syscallarg(netbsd32_voidp) value; 2493 syscallarg(netbsd32_size_t) size; 2494 } */ 2495 struct sys_lgetxattr_args ua; 2496 NETBSD32TOP_UAP(path, const char); 2497 NETBSD32TOP_UAP(name, const char); 2498 NETBSD32TOP_UAP(value, void); 2499 NETBSD32TOX_UAP(size, size_t); 2500 return sys_lgetxattr(l, &ua, retval); 2501 } 2502 2503 int 2504 netbsd32_fgetxattr(struct lwp *l, const struct netbsd32_fgetxattr_args *uap, register_t *retval) 2505 { 2506 /* { 2507 syscallarg(int) fd; 2508 syscallarg(const netbsd32_charp) name; 2509 syscallarg(netbsd32_voidp) value; 2510 syscallarg(netbsd32_size_t) size; 2511 } */ 2512 struct sys_fgetxattr_args ua; 2513 NETBSD32TO64_UAP(fd); 2514 NETBSD32TOP_UAP(name, const char); 2515 NETBSD32TOP_UAP(value, void); 2516 NETBSD32TOX_UAP(size, size_t); 2517 return sys_fgetxattr(l, &ua, retval); 2518 } 2519 2520 int 2521 netbsd32_listxattr(struct lwp *l, const struct netbsd32_listxattr_args *uap, register_t *retval) 2522 { 2523 /* { 2524 syscallarg(const netbsd32_charp) path; 2525 syscallarg(netbsd32_charp) list; 2526 syscallarg(netbsd32_size_t) size; 2527 } */ 2528 struct sys_listxattr_args ua; 2529 NETBSD32TOP_UAP(path, const char); 2530 NETBSD32TOP_UAP(list, char); 2531 NETBSD32TOX_UAP(size, size_t); 2532 return sys_listxattr(l, &ua, retval); 2533 } 2534 2535 int 2536 netbsd32_llistxattr(struct lwp *l, const struct netbsd32_llistxattr_args *uap, register_t *retval) 2537 { 2538 /* { 2539 syscallarg(const netbsd32_charp) path; 2540 syscallarg(netbsd32_charp) list; 2541 syscallarg(netbsd32_size_t) size; 2542 } */ 2543 struct sys_llistxattr_args ua; 2544 NETBSD32TOP_UAP(path, const char); 2545 NETBSD32TOP_UAP(list, char); 2546 NETBSD32TOX_UAP(size, size_t); 2547 return sys_llistxattr(l, &ua, retval); 2548 } 2549 2550 int 2551 netbsd32_flistxattr(struct lwp *l, const struct netbsd32_flistxattr_args *uap, register_t *retval) 2552 { 2553 /* { 2554 syscallarg(int) fd; 2555 syscallarg(netbsd32_charp) list; 2556 syscallarg(netbsd32_size_t) size; 2557 } */ 2558 struct sys_flistxattr_args ua; 2559 NETBSD32TO64_UAP(fd); 2560 NETBSD32TOP_UAP(list, char); 2561 NETBSD32TOX_UAP(size, size_t); 2562 return sys_flistxattr(l, &ua, retval); 2563 } 2564 2565 int 2566 netbsd32_removexattr(struct lwp *l, const struct netbsd32_removexattr_args *uap, register_t *retval) 2567 { 2568 /* { 2569 syscallarg(const netbsd32_charp) path; 2570 syscallarg(const netbsd32_charp) name; 2571 } */ 2572 struct sys_removexattr_args ua; 2573 NETBSD32TOP_UAP(path, const char); 2574 NETBSD32TOP_UAP(name, const char); 2575 return sys_removexattr(l, &ua, retval); 2576 } 2577 2578 int 2579 netbsd32_lremovexattr(struct lwp *l, const struct netbsd32_lremovexattr_args *uap, register_t *retval) 2580 { 2581 /* { 2582 syscallarg(const netbsd32_charp) path; 2583 syscallarg(const netbsd32_charp) name; 2584 } */ 2585 struct sys_lremovexattr_args ua; 2586 NETBSD32TOP_UAP(path, const char); 2587 NETBSD32TOP_UAP(name, const char); 2588 return sys_lremovexattr(l, &ua, retval); 2589 } 2590 2591 int 2592 netbsd32_fremovexattr(struct lwp *l, const struct netbsd32_fremovexattr_args *uap, register_t *retval) 2593 { 2594 /* { 2595 syscallarg(int) fd; 2596 syscallarg(const netbsd32_charp) name; 2597 } */ 2598 struct sys_fremovexattr_args ua; 2599 NETBSD32TO64_UAP(fd); 2600 NETBSD32TOP_UAP(name, const char); 2601 return sys_fremovexattr(l, &ua, retval); 2602 } 2603 2604 int 2605 netbsd32___posix_fadvise50(struct lwp *l, 2606 const struct netbsd32___posix_fadvise50_args *uap, register_t *retval) 2607 { 2608 /* { 2609 syscallarg(int) fd; 2610 syscallarg(int) PAD; 2611 syscallarg(netbsd32_off_t) offset; 2612 syscallarg(netbsd32_off_t) len; 2613 syscallarg(int) advice; 2614 } */ 2615 2616 *retval = do_posix_fadvise(SCARG(uap, fd), SCARG(uap, offset), 2617 SCARG(uap, len), SCARG(uap, advice)); 2618 2619 return 0; 2620 } 2621 2622 int 2623 netbsd32__sched_setparam(struct lwp *l, 2624 const struct netbsd32__sched_setparam_args *uap, 2625 register_t *retval) 2626 { 2627 /* { 2628 syscallarg(pid_t) pid; 2629 syscallarg(lwpid_t) lid; 2630 syscallarg(int) policy; 2631 syscallarg(const netbsd32_sched_paramp_t) params; 2632 } */ 2633 struct sys__sched_setparam_args ua; 2634 2635 NETBSD32TO64_UAP(pid); 2636 NETBSD32TO64_UAP(lid); 2637 NETBSD32TO64_UAP(policy); 2638 NETBSD32TOP_UAP(params, const struct sched_param *); 2639 return sys__sched_setparam(l, &ua, retval); 2640 } 2641 2642 int 2643 netbsd32__sched_getparam(struct lwp *l, 2644 const struct netbsd32__sched_getparam_args *uap, 2645 register_t *retval) 2646 { 2647 /* { 2648 syscallarg(pid_t) pid; 2649 syscallarg(lwpid_t) lid; 2650 syscallarg(netbsd32_intp) policy; 2651 syscallarg(netbsd32_sched_paramp_t) params; 2652 } */ 2653 struct sys__sched_getparam_args ua; 2654 2655 NETBSD32TO64_UAP(pid); 2656 NETBSD32TO64_UAP(lid); 2657 NETBSD32TOP_UAP(policy, int *); 2658 NETBSD32TOP_UAP(params, struct sched_param *); 2659 return sys__sched_getparam(l, &ua, retval); 2660 } 2661 2662 int 2663 netbsd32__sched_setaffinity(struct lwp *l, 2664 const struct netbsd32__sched_setaffinity_args *uap, 2665 register_t *retval) 2666 { 2667 /* { 2668 syscallarg(pid_t) pid; 2669 syscallarg(lwpid_t) lid; 2670 syscallarg(netbsd_size_t) size; 2671 syscallarg(const netbsd32_cpusetp_t) cpuset; 2672 } */ 2673 struct sys__sched_setaffinity_args ua; 2674 2675 NETBSD32TO64_UAP(pid); 2676 NETBSD32TO64_UAP(lid); 2677 NETBSD32TOX_UAP(size, size_t); 2678 NETBSD32TOP_UAP(cpuset, const cpuset_t *); 2679 return sys__sched_setaffinity(l, &ua, retval); 2680 } 2681 2682 int 2683 netbsd32__sched_getaffinity(struct lwp *l, 2684 const struct netbsd32__sched_getaffinity_args *uap, 2685 register_t *retval) 2686 { 2687 /* { 2688 syscallarg(pid_t) pid; 2689 syscallarg(lwpid_t) lid; 2690 syscallarg(netbsd_size_t) size; 2691 syscallarg(netbsd32_cpusetp_t) cpuset; 2692 } */ 2693 struct sys__sched_getaffinity_args ua; 2694 2695 NETBSD32TO64_UAP(pid); 2696 NETBSD32TO64_UAP(lid); 2697 NETBSD32TOX_UAP(size, size_t); 2698 NETBSD32TOP_UAP(cpuset, cpuset_t *); 2699 return sys__sched_getaffinity(l, &ua, retval); 2700 } 2701 2702 int 2703 netbsd32_pipe2(struct lwp *l, const struct netbsd32_pipe2_args *uap, 2704 register_t *retval) 2705 { 2706 /* { 2707 syscallarg(netbsd32_intp) fildes; 2708 syscallarg(int) flags; 2709 } */ 2710 int fd[2], error; 2711 2712 error = pipe1(l, retval, SCARG(uap, flags)); 2713 if (error != 0) 2714 return error; 2715 2716 fd[0] = retval[0]; 2717 fd[1] = retval[1]; 2718 2719 error = copyout(fd, SCARG_P32(uap, fildes), sizeof(fd)); 2720 if (error != 0) 2721 return error; 2722 2723 retval[0] = 0; 2724 return 0; 2725 } 2726 2727 int 2728 netbsd32_dup3(struct lwp *l, const struct netbsd32_dup3_args *uap, 2729 register_t *retval) 2730 { 2731 /* { 2732 syscallarg(int) from; 2733 syscallarg(int) to; 2734 syscallarg(int) flags; 2735 } */ 2736 struct sys_dup3_args ua; 2737 2738 NETBSD32TO64_UAP(from); 2739 NETBSD32TO64_UAP(to); 2740 NETBSD32TO64_UAP(flags); 2741 2742 return sys_dup3(l, &ua, retval); 2743 } 2744 2745 int 2746 netbsd32_kqueue1(struct lwp *l, const struct netbsd32_kqueue1_args *uap, 2747 register_t *retval) 2748 { 2749 /* { 2750 syscallarg(int) flags; 2751 } */ 2752 struct sys_kqueue1_args ua; 2753 2754 NETBSD32TO64_UAP(flags); 2755 2756 return sys_kqueue1(l, &ua, retval); 2757 } 2758 2759 int 2760 netbsd32_paccept(struct lwp *l, const struct netbsd32_paccept_args *uap, 2761 register_t *retval) 2762 { 2763 /* { 2764 syscallarg(int) s; 2765 syscallarg(netbsd32_sockaddrp_t) name; 2766 syscallarg(netbsd32_socklenp_t) anamelen; 2767 syscallarg(const netbsd32_sigsetp_t) mask; 2768 syscallarg(int) flags; 2769 } */ 2770 struct sys_paccept_args ua; 2771 2772 NETBSD32TO64_UAP(s); 2773 NETBSD32TOP_UAP(name, struct sockaddr *); 2774 NETBSD32TOP_UAP(anamelen, socklen_t *); 2775 NETBSD32TOP_UAP(mask, const sigset_t *); 2776 NETBSD32TO64_UAP(flags); 2777 2778 return sys_paccept(l, &ua, retval); 2779 } 2780 2781 /* 2782 * MI indirect system call support. 2783 * Only used if the MD netbsd32_syscall.c doesn't intercept the calls. 2784 */ 2785 2786 #define NETBSD32_SYSCALL 2787 #undef SYS_NSYSENT 2788 #define SYS_NSYSENT NETBSD32_SYS_NSYSENT 2789 2790 #define SYS_SYSCALL netbsd32_syscall 2791 #include "../../kern/sys_syscall.c" 2792 #undef SYS_SYSCALL 2793 2794 #define SYS_SYSCALL netbsd32____syscall 2795 #include "../../kern/sys_syscall.c" 2796 #undef SYS_SYSCALL 2797