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