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