netbsd32_netbsd.c revision 1.69.2.1
1 /* $NetBSD: netbsd32_netbsd.c,v 1.69.2.1 2002/12/18 01:05:55 gmcgarry Exp $ */ 2 3 /* 4 * Copyright (c) 1998, 2001 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 * 3. The name of the author may not be used to endorse or promote products 16 * derived from this software without specific prior written permission. 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 19 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 20 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 21 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 22 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 23 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 24 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 25 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 26 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 27 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 28 * SUCH DAMAGE. 29 */ 30 31 #include <sys/cdefs.h> 32 __KERNEL_RCSID(0, "$NetBSD: netbsd32_netbsd.c,v 1.69.2.1 2002/12/18 01:05:55 gmcgarry Exp $"); 33 34 #if defined(_KERNEL_OPT) 35 #include "opt_ddb.h" 36 #include "opt_ktrace.h" 37 #include "opt_ntp.h" 38 #include "opt_compat_netbsd.h" 39 #include "opt_compat_43.h" 40 #include "opt_sysv.h" 41 42 #include "fs_lfs.h" 43 #include "fs_nfs.h" 44 #endif 45 46 /* 47 * Though COMPAT_OLDSOCK is needed only for COMPAT_43, SunOS, Linux, 48 * HP-UX, FreeBSD, Ultrix, OSF1, we define it unconditionally so that 49 * this would be LKM-safe. 50 */ 51 #define COMPAT_OLDSOCK /* used by <sys/socket.h> */ 52 53 #include <sys/param.h> 54 #include <sys/systm.h> 55 #include <sys/kernel.h> 56 //#define msg __msg /* Don't ask me! */ 57 #include <sys/malloc.h> 58 #include <sys/mount.h> 59 #include <sys/socket.h> 60 #include <sys/sockio.h> 61 #include <sys/socketvar.h> 62 #include <sys/mbuf.h> 63 #include <sys/stat.h> 64 #include <sys/time.h> 65 #include <sys/signalvar.h> 66 #include <sys/ptrace.h> 67 #include <sys/ktrace.h> 68 #include <sys/trace.h> 69 #include <sys/resourcevar.h> 70 #include <sys/pool.h> 71 #include <sys/vnode.h> 72 #include <sys/file.h> 73 #include <sys/filedesc.h> 74 #include <sys/namei.h> 75 76 #include <uvm/uvm_extern.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_syscall.h> 87 #include <compat/netbsd32/netbsd32_syscallargs.h> 88 #include <compat/netbsd32/netbsd32_conv.h> 89 90 #include <machine/frame.h> 91 92 #if defined(DDB) 93 #include <ddb/ddbvar.h> 94 #endif 95 96 extern char netbsd32_sigcode[], netbsd32_esigcode[]; 97 extern struct sysent netbsd32_sysent[]; 98 #ifdef SYSCALL_DEBUG 99 extern const char * const netbsd32_syscallnames[]; 100 #endif 101 #ifdef __HAVE_SYSCALL_INTERN 102 void netbsd32_syscall_intern __P((struct proc *)); 103 #else 104 void syscall __P((void)); 105 #endif 106 107 const struct emul emul_netbsd32 = { 108 "netbsd32", 109 "/emul/netbsd32", 110 #ifndef __HAVE_MINIMAL_EMUL 111 0, 112 NULL, 113 netbsd32_SYS_syscall, 114 netbsd32_SYS_NSYSENT, 115 #endif 116 netbsd32_sysent, 117 #ifdef SYSCALL_DEBUG 118 netbsd32_syscallnames, 119 #else 120 NULL, 121 #endif 122 netbsd32_sendsig, 123 trapsignal, 124 netbsd32_sigcode, 125 netbsd32_esigcode, 126 netbsd32_setregs, 127 NULL, 128 NULL, 129 NULL, 130 #ifdef __HAVE_SYSCALL_INTERN 131 netbsd32_syscall_intern, 132 #else 133 syscall, 134 #endif 135 NULL, 136 NULL, 137 }; 138 139 /* 140 * below are all the standard NetBSD system calls, in the 32bit 141 * environment, with the necessary conversions to 64bit before 142 * calling the real syscall. anything that needs special 143 * attention is handled elsewhere. 144 */ 145 146 int 147 netbsd32_exit(p, v, retval) 148 struct proc *p; 149 void *v; 150 register_t *retval; 151 { 152 struct netbsd32_exit_args /* { 153 syscallarg(int) rval; 154 } */ *uap = v; 155 struct sys_exit_args ua; 156 157 NETBSD32TO64_UAP(rval); 158 return sys_exit(p, &ua, retval); 159 } 160 161 int 162 netbsd32_read(p, v, retval) 163 struct proc *p; 164 void *v; 165 register_t *retval; 166 { 167 struct netbsd32_read_args /* { 168 syscallarg(int) fd; 169 syscallarg(netbsd32_voidp) buf; 170 syscallarg(netbsd32_size_t) nbyte; 171 } */ *uap = v; 172 struct sys_read_args ua; 173 174 NETBSD32TO64_UAP(fd); 175 NETBSD32TOP_UAP(buf, void *); 176 NETBSD32TOX_UAP(nbyte, size_t); 177 return sys_read(p, &ua, retval); 178 } 179 180 int 181 netbsd32_write(p, v, retval) 182 struct proc *p; 183 void *v; 184 register_t *retval; 185 { 186 struct netbsd32_write_args /* { 187 syscallarg(int) fd; 188 syscallarg(const netbsd32_voidp) buf; 189 syscallarg(netbsd32_size_t) nbyte; 190 } */ *uap = v; 191 struct sys_write_args ua; 192 193 NETBSD32TO64_UAP(fd); 194 NETBSD32TOP_UAP(buf, void *); 195 NETBSD32TOX_UAP(nbyte, size_t); 196 return sys_write(p, &ua, retval); 197 } 198 199 int 200 netbsd32_close(p, v, retval) 201 struct proc *p; 202 void *v; 203 register_t *retval; 204 { 205 struct netbsd32_close_args /* { 206 syscallarg(int) fd; 207 } */ *uap = v; 208 struct sys_close_args ua; 209 210 NETBSD32TO64_UAP(fd); 211 return sys_close(p, &ua, retval); 212 } 213 214 int 215 netbsd32_open(p, v, retval) 216 struct proc *p; 217 void *v; 218 register_t *retval; 219 { 220 struct netbsd32_open_args /* { 221 syscallarg(const netbsd32_charp) path; 222 syscallarg(int) flags; 223 syscallarg(mode_t) mode; 224 } */ *uap = v; 225 struct sys_open_args ua; 226 caddr_t sg; 227 228 NETBSD32TOP_UAP(path, const char); 229 NETBSD32TO64_UAP(flags); 230 NETBSD32TO64_UAP(mode); 231 sg = stackgap_init(p, 0); 232 CHECK_ALT_EXIST(p, &sg, SCARG(&ua, path)); 233 234 return (sys_open(p, &ua, retval)); 235 } 236 237 int 238 netbsd32_link(p, v, retval) 239 struct proc *p; 240 void *v; 241 register_t *retval; 242 { 243 struct netbsd32_link_args /* { 244 syscallarg(const netbsd32_charp) path; 245 syscallarg(const netbsd32_charp) link; 246 } */ *uap = v; 247 struct sys_link_args ua; 248 249 NETBSD32TOP_UAP(path, const char); 250 NETBSD32TOP_UAP(link, const char); 251 return (sys_link(p, &ua, retval)); 252 } 253 254 int 255 netbsd32_unlink(p, v, retval) 256 struct proc *p; 257 void *v; 258 register_t *retval; 259 { 260 struct netbsd32_unlink_args /* { 261 syscallarg(const netbsd32_charp) path; 262 } */ *uap = v; 263 struct sys_unlink_args ua; 264 265 NETBSD32TOP_UAP(path, const char); 266 267 return (sys_unlink(p, &ua, retval)); 268 } 269 270 int 271 netbsd32_chdir(p, v, retval) 272 struct proc *p; 273 void *v; 274 register_t *retval; 275 { 276 struct netbsd32_chdir_args /* { 277 syscallarg(const netbsd32_charp) path; 278 } */ *uap = v; 279 struct sys_chdir_args ua; 280 281 NETBSD32TOP_UAP(path, const char); 282 283 return (sys_chdir(p, &ua, retval)); 284 } 285 286 int 287 netbsd32_fchdir(p, v, retval) 288 struct proc *p; 289 void *v; 290 register_t *retval; 291 { 292 struct netbsd32_fchdir_args /* { 293 syscallarg(int) fd; 294 } */ *uap = v; 295 struct sys_fchdir_args ua; 296 297 NETBSD32TO64_UAP(fd); 298 299 return (sys_fchdir(p, &ua, retval)); 300 } 301 302 int 303 netbsd32_mknod(p, v, retval) 304 struct proc *p; 305 void *v; 306 register_t *retval; 307 { 308 struct netbsd32_mknod_args /* { 309 syscallarg(const netbsd32_charp) path; 310 syscallarg(mode_t) mode; 311 syscallarg(dev_t) dev; 312 } */ *uap = v; 313 struct sys_mknod_args ua; 314 315 NETBSD32TOP_UAP(path, const char); 316 NETBSD32TO64_UAP(dev); 317 NETBSD32TO64_UAP(mode); 318 319 return (sys_mknod(p, &ua, retval)); 320 } 321 322 int 323 netbsd32_chmod(p, v, retval) 324 struct proc *p; 325 void *v; 326 register_t *retval; 327 { 328 struct netbsd32_chmod_args /* { 329 syscallarg(const netbsd32_charp) path; 330 syscallarg(mode_t) mode; 331 } */ *uap = v; 332 struct sys_chmod_args ua; 333 334 NETBSD32TOP_UAP(path, const char); 335 NETBSD32TO64_UAP(mode); 336 337 return (sys_chmod(p, &ua, retval)); 338 } 339 340 int 341 netbsd32_chown(p, v, retval) 342 struct proc *p; 343 void *v; 344 register_t *retval; 345 { 346 struct netbsd32_chown_args /* { 347 syscallarg(const netbsd32_charp) path; 348 syscallarg(uid_t) uid; 349 syscallarg(gid_t) gid; 350 } */ *uap = v; 351 struct sys_chown_args ua; 352 353 NETBSD32TOP_UAP(path, const char); 354 NETBSD32TO64_UAP(uid); 355 NETBSD32TO64_UAP(gid); 356 357 return (sys_chown(p, &ua, retval)); 358 } 359 360 int 361 netbsd32_break(p, v, retval) 362 struct proc *p; 363 void *v; 364 register_t *retval; 365 { 366 struct netbsd32_break_args /* { 367 syscallarg(netbsd32_charp) nsize; 368 } */ *uap = v; 369 struct sys_obreak_args ua; 370 371 SCARG(&ua, nsize) = (char *)NETBSD32PTR64(SCARG(uap, nsize)); 372 NETBSD32TOP_UAP(nsize, char); 373 return (sys_obreak(p, &ua, retval)); 374 } 375 376 int 377 netbsd32_mount(p, v, retval) 378 struct proc *p; 379 void *v; 380 register_t *retval; 381 { 382 struct netbsd32_mount_args /* { 383 syscallarg(const netbsd32_charp) type; 384 syscallarg(const netbsd32_charp) path; 385 syscallarg(int) flags; 386 syscallarg(netbsd32_voidp) data; 387 } */ *uap = v; 388 struct sys_mount_args ua; 389 390 NETBSD32TOP_UAP(type, const char); 391 NETBSD32TOP_UAP(path, const char); 392 NETBSD32TO64_UAP(flags); 393 NETBSD32TOP_UAP(data, void); 394 return (sys_mount(p, &ua, retval)); 395 } 396 397 int 398 netbsd32_unmount(p, v, retval) 399 struct proc *p; 400 void *v; 401 register_t *retval; 402 { 403 struct netbsd32_unmount_args /* { 404 syscallarg(const netbsd32_charp) path; 405 syscallarg(int) flags; 406 } */ *uap = v; 407 struct sys_unmount_args ua; 408 409 NETBSD32TOP_UAP(path, const char); 410 NETBSD32TO64_UAP(flags); 411 return (sys_unmount(p, &ua, retval)); 412 } 413 414 int 415 netbsd32_setuid(p, v, retval) 416 struct proc *p; 417 void *v; 418 register_t *retval; 419 { 420 struct netbsd32_setuid_args /* { 421 syscallarg(uid_t) uid; 422 } */ *uap = v; 423 struct sys_setuid_args ua; 424 425 NETBSD32TO64_UAP(uid); 426 return (sys_setuid(p, &ua, retval)); 427 } 428 429 int 430 netbsd32_ptrace(p, v, retval) 431 struct proc *p; 432 void *v; 433 register_t *retval; 434 { 435 struct netbsd32_ptrace_args /* { 436 syscallarg(int) req; 437 syscallarg(pid_t) pid; 438 syscallarg(netbsd32_caddr_t) addr; 439 syscallarg(int) data; 440 } */ *uap = v; 441 struct sys_ptrace_args ua; 442 443 NETBSD32TO64_UAP(req); 444 NETBSD32TO64_UAP(pid); 445 NETBSD32TOX64_UAP(addr, caddr_t); 446 NETBSD32TO64_UAP(data); 447 return (sys_ptrace(p, &ua, retval)); 448 } 449 450 int 451 netbsd32_accept(p, v, retval) 452 struct proc *p; 453 void *v; 454 register_t *retval; 455 { 456 struct netbsd32_accept_args /* { 457 syscallarg(int) s; 458 syscallarg(netbsd32_sockaddrp_t) name; 459 syscallarg(netbsd32_intp) anamelen; 460 } */ *uap = v; 461 struct sys_accept_args ua; 462 463 NETBSD32TO64_UAP(s); 464 NETBSD32TOP_UAP(name, struct sockaddr); 465 NETBSD32TOP_UAP(anamelen, int); 466 return (sys_accept(p, &ua, retval)); 467 } 468 469 int 470 netbsd32_getpeername(p, v, retval) 471 struct proc *p; 472 void *v; 473 register_t *retval; 474 { 475 struct netbsd32_getpeername_args /* { 476 syscallarg(int) fdes; 477 syscallarg(netbsd32_sockaddrp_t) asa; 478 syscallarg(netbsd32_intp) alen; 479 } */ *uap = v; 480 struct sys_getpeername_args ua; 481 482 NETBSD32TO64_UAP(fdes); 483 NETBSD32TOP_UAP(asa, struct sockaddr); 484 NETBSD32TOP_UAP(alen, int); 485 /* NB: do the protocol specific sockaddrs need to be converted? */ 486 return (sys_getpeername(p, &ua, retval)); 487 } 488 489 int 490 netbsd32_getsockname(p, v, retval) 491 struct proc *p; 492 void *v; 493 register_t *retval; 494 { 495 struct netbsd32_getsockname_args /* { 496 syscallarg(int) fdes; 497 syscallarg(netbsd32_sockaddrp_t) asa; 498 syscallarg(netbsd32_intp) alen; 499 } */ *uap = v; 500 struct sys_getsockname_args ua; 501 502 NETBSD32TO64_UAP(fdes); 503 NETBSD32TOP_UAP(asa, struct sockaddr); 504 NETBSD32TOP_UAP(alen, int); 505 return (sys_getsockname(p, &ua, retval)); 506 } 507 508 int 509 netbsd32_access(p, v, retval) 510 struct proc *p; 511 void *v; 512 register_t *retval; 513 { 514 struct netbsd32_access_args /* { 515 syscallarg(const netbsd32_charp) path; 516 syscallarg(int) flags; 517 } */ *uap = v; 518 struct sys_access_args ua; 519 caddr_t sg; 520 521 NETBSD32TOP_UAP(path, const char); 522 NETBSD32TO64_UAP(flags); 523 sg = stackgap_init(p, 0); 524 CHECK_ALT_EXIST(p, &sg, SCARG(&ua, path)); 525 526 return (sys_access(p, &ua, retval)); 527 } 528 529 int 530 netbsd32_chflags(p, v, retval) 531 struct proc *p; 532 void *v; 533 register_t *retval; 534 { 535 struct netbsd32_chflags_args /* { 536 syscallarg(const netbsd32_charp) path; 537 syscallarg(netbsd32_u_long) flags; 538 } */ *uap = v; 539 struct sys_chflags_args ua; 540 541 NETBSD32TOP_UAP(path, const char); 542 NETBSD32TO64_UAP(flags); 543 544 return (sys_chflags(p, &ua, retval)); 545 } 546 547 int 548 netbsd32_fchflags(p, v, retval) 549 struct proc *p; 550 void *v; 551 register_t *retval; 552 { 553 struct netbsd32_fchflags_args /* { 554 syscallarg(int) fd; 555 syscallarg(netbsd32_u_long) flags; 556 } */ *uap = v; 557 struct sys_fchflags_args ua; 558 559 NETBSD32TO64_UAP(fd); 560 NETBSD32TO64_UAP(flags); 561 562 return (sys_fchflags(p, &ua, retval)); 563 } 564 565 int 566 netbsd32_lchflags(p, v, retval) 567 struct proc *p; 568 void *v; 569 register_t *retval; 570 { 571 struct netbsd32_lchflags_args /* { 572 syscallarg(int) fd; 573 syscallarg(netbsd32_u_long) flags; 574 } */ *uap = v; 575 struct sys_lchflags_args ua; 576 577 NETBSD32TOP_UAP(path, const char); 578 NETBSD32TO64_UAP(flags); 579 580 return (sys_lchflags(p, &ua, retval)); 581 } 582 583 int 584 netbsd32_kill(p, v, retval) 585 struct proc *p; 586 void *v; 587 register_t *retval; 588 { 589 struct netbsd32_kill_args /* { 590 syscallarg(int) pid; 591 syscallarg(int) signum; 592 } */ *uap = v; 593 struct sys_kill_args ua; 594 595 NETBSD32TO64_UAP(pid); 596 NETBSD32TO64_UAP(signum); 597 598 return (sys_kill(p, &ua, retval)); 599 } 600 601 int 602 netbsd32_dup(p, v, retval) 603 struct proc *p; 604 void *v; 605 register_t *retval; 606 { 607 struct netbsd32_dup_args /* { 608 syscallarg(int) fd; 609 } */ *uap = v; 610 struct sys_dup_args ua; 611 612 NETBSD32TO64_UAP(fd); 613 614 return (sys_dup(p, &ua, retval)); 615 } 616 617 int 618 netbsd32_profil(p, v, retval) 619 struct proc *p; 620 void *v; 621 register_t *retval; 622 { 623 struct netbsd32_profil_args /* { 624 syscallarg(netbsd32_caddr_t) samples; 625 syscallarg(netbsd32_size_t) size; 626 syscallarg(netbsd32_u_long) offset; 627 syscallarg(u_int) scale; 628 } */ *uap = v; 629 struct sys_profil_args ua; 630 631 NETBSD32TOX64_UAP(samples, caddr_t); 632 NETBSD32TOX_UAP(size, size_t); 633 NETBSD32TOX_UAP(offset, u_long); 634 NETBSD32TO64_UAP(scale); 635 return (sys_profil(p, &ua, retval)); 636 } 637 638 #ifdef KTRACE 639 int 640 netbsd32_ktrace(p, v, retval) 641 struct proc *p; 642 void *v; 643 register_t *retval; 644 { 645 struct netbsd32_ktrace_args /* { 646 syscallarg(const netbsd32_charp) fname; 647 syscallarg(int) ops; 648 syscallarg(int) facs; 649 syscallarg(int) pid; 650 } */ *uap = v; 651 struct sys_ktrace_args ua; 652 653 NETBSD32TOP_UAP(fname, const char); 654 NETBSD32TO64_UAP(ops); 655 NETBSD32TO64_UAP(facs); 656 NETBSD32TO64_UAP(pid); 657 return (sys_ktrace(p, &ua, retval)); 658 } 659 #endif /* KTRACE */ 660 661 int 662 netbsd32_utrace(p, v, retval) 663 struct proc *p; 664 void *v; 665 register_t *retval; 666 { 667 struct netbsd32_utrace_args /* { 668 syscallarg(const netbsd32_charp) label; 669 syscallarg(netbsd32_voidp) addr; 670 syscallarg(netbsd32_size_t) len; 671 } */ *uap = v; 672 struct sys_utrace_args ua; 673 674 NETBSD32TOP_UAP(label, const char); 675 NETBSD32TOP_UAP(addr, void); 676 NETBSD32TO64_UAP(len); 677 return (sys_utrace(p, &ua, retval)); 678 } 679 680 int 681 netbsd32___getlogin(p, v, retval) 682 struct proc *p; 683 void *v; 684 register_t *retval; 685 { 686 struct netbsd32___getlogin_args /* { 687 syscallarg(netbsd32_charp) namebuf; 688 syscallarg(u_int) namelen; 689 } */ *uap = v; 690 struct sys___getlogin_args ua; 691 692 NETBSD32TOP_UAP(namebuf, char); 693 NETBSD32TO64_UAP(namelen); 694 return (sys___getlogin(p, &ua, retval)); 695 } 696 697 int 698 netbsd32_setlogin(p, v, retval) 699 struct proc *p; 700 void *v; 701 register_t *retval; 702 { 703 struct netbsd32_setlogin_args /* { 704 syscallarg(const netbsd32_charp) namebuf; 705 } */ *uap = v; 706 struct sys_setlogin_args ua; 707 708 NETBSD32TOP_UAP(namebuf, char); 709 return (sys_setlogin(p, &ua, retval)); 710 } 711 712 int 713 netbsd32_acct(p, v, retval) 714 struct proc *p; 715 void *v; 716 register_t *retval; 717 { 718 struct netbsd32_acct_args /* { 719 syscallarg(const netbsd32_charp) path; 720 } */ *uap = v; 721 struct sys_acct_args ua; 722 723 NETBSD32TOP_UAP(path, const char); 724 return (sys_acct(p, &ua, retval)); 725 } 726 727 int 728 netbsd32_revoke(p, v, retval) 729 struct proc *p; 730 void *v; 731 register_t *retval; 732 { 733 struct netbsd32_revoke_args /* { 734 syscallarg(const netbsd32_charp) path; 735 } */ *uap = v; 736 struct sys_revoke_args ua; 737 caddr_t sg; 738 739 NETBSD32TOP_UAP(path, const char); 740 sg = stackgap_init(p, 0); 741 CHECK_ALT_EXIST(p, &sg, SCARG(&ua, path)); 742 743 return (sys_revoke(p, &ua, retval)); 744 } 745 746 int 747 netbsd32_symlink(p, v, retval) 748 struct proc *p; 749 void *v; 750 register_t *retval; 751 { 752 struct netbsd32_symlink_args /* { 753 syscallarg(const netbsd32_charp) path; 754 syscallarg(const netbsd32_charp) link; 755 } */ *uap = v; 756 struct sys_symlink_args ua; 757 758 NETBSD32TOP_UAP(path, const char); 759 NETBSD32TOP_UAP(link, const char); 760 761 return (sys_symlink(p, &ua, retval)); 762 } 763 764 int 765 netbsd32_readlink(p, v, retval) 766 struct proc *p; 767 void *v; 768 register_t *retval; 769 { 770 struct netbsd32_readlink_args /* { 771 syscallarg(const netbsd32_charp) path; 772 syscallarg(netbsd32_charp) buf; 773 syscallarg(netbsd32_size_t) count; 774 } */ *uap = v; 775 struct sys_readlink_args ua; 776 caddr_t sg; 777 778 NETBSD32TOP_UAP(path, const char); 779 NETBSD32TOP_UAP(buf, char); 780 NETBSD32TOX_UAP(count, size_t); 781 sg = stackgap_init(p, 0); 782 CHECK_ALT_SYMLINK(p, &sg, SCARG(&ua, path)); 783 784 return (sys_readlink(p, &ua, retval)); 785 } 786 787 int 788 netbsd32_umask(p, v, retval) 789 struct proc *p; 790 void *v; 791 register_t *retval; 792 { 793 struct netbsd32_umask_args /* { 794 syscallarg(mode_t) newmask; 795 } */ *uap = v; 796 struct sys_umask_args ua; 797 798 NETBSD32TO64_UAP(newmask); 799 return (sys_umask(p, &ua, retval)); 800 } 801 802 int 803 netbsd32_chroot(p, v, retval) 804 struct proc *p; 805 void *v; 806 register_t *retval; 807 { 808 struct netbsd32_chroot_args /* { 809 syscallarg(const netbsd32_charp) path; 810 } */ *uap = v; 811 struct sys_chroot_args ua; 812 813 NETBSD32TOP_UAP(path, const char); 814 return (sys_chroot(p, &ua, retval)); 815 } 816 817 int 818 netbsd32_sbrk(p, v, retval) 819 struct proc *p; 820 void *v; 821 register_t *retval; 822 { 823 struct netbsd32_sbrk_args /* { 824 syscallarg(int) incr; 825 } */ *uap = v; 826 struct sys_sbrk_args ua; 827 828 NETBSD32TO64_UAP(incr); 829 return (sys_sbrk(p, &ua, retval)); 830 } 831 832 int 833 netbsd32_sstk(p, v, retval) 834 struct proc *p; 835 void *v; 836 register_t *retval; 837 { 838 struct netbsd32_sstk_args /* { 839 syscallarg(int) incr; 840 } */ *uap = v; 841 struct sys_sstk_args ua; 842 843 NETBSD32TO64_UAP(incr); 844 return (sys_sstk(p, &ua, retval)); 845 } 846 847 int 848 netbsd32_munmap(p, v, retval) 849 struct proc *p; 850 void *v; 851 register_t *retval; 852 { 853 struct netbsd32_munmap_args /* { 854 syscallarg(netbsd32_voidp) addr; 855 syscallarg(netbsd32_size_t) len; 856 } */ *uap = v; 857 struct sys_munmap_args ua; 858 859 NETBSD32TOP_UAP(addr, void); 860 NETBSD32TOX_UAP(len, size_t); 861 return (sys_munmap(p, &ua, retval)); 862 } 863 864 int 865 netbsd32_mprotect(p, v, retval) 866 struct proc *p; 867 void *v; 868 register_t *retval; 869 { 870 struct netbsd32_mprotect_args /* { 871 syscallarg(netbsd32_voidp) addr; 872 syscallarg(netbsd32_size_t) len; 873 syscallarg(int) prot; 874 } */ *uap = v; 875 struct sys_mprotect_args ua; 876 877 NETBSD32TOP_UAP(addr, void); 878 NETBSD32TOX_UAP(len, size_t); 879 NETBSD32TO64_UAP(prot); 880 return (sys_mprotect(p, &ua, retval)); 881 } 882 883 int 884 netbsd32_madvise(p, v, retval) 885 struct proc *p; 886 void *v; 887 register_t *retval; 888 { 889 struct netbsd32_madvise_args /* { 890 syscallarg(netbsd32_voidp) addr; 891 syscallarg(netbsd32_size_t) len; 892 syscallarg(int) behav; 893 } */ *uap = v; 894 struct sys_madvise_args ua; 895 896 NETBSD32TOP_UAP(addr, void); 897 NETBSD32TOX_UAP(len, size_t); 898 NETBSD32TO64_UAP(behav); 899 return (sys_madvise(p, &ua, retval)); 900 } 901 902 int 903 netbsd32_mincore(p, v, retval) 904 struct proc *p; 905 void *v; 906 register_t *retval; 907 { 908 struct netbsd32_mincore_args /* { 909 syscallarg(netbsd32_caddr_t) addr; 910 syscallarg(netbsd32_size_t) len; 911 syscallarg(netbsd32_charp) vec; 912 } */ *uap = v; 913 struct sys_mincore_args ua; 914 915 NETBSD32TOX64_UAP(addr, caddr_t); 916 NETBSD32TOX_UAP(len, size_t); 917 NETBSD32TOP_UAP(vec, char); 918 return (sys_mincore(p, &ua, retval)); 919 } 920 921 /* XXX MOVE ME XXX ? */ 922 int 923 netbsd32_getgroups(p, v, retval) 924 struct proc *p; 925 void *v; 926 register_t *retval; 927 { 928 struct netbsd32_getgroups_args /* { 929 syscallarg(int) gidsetsize; 930 syscallarg(netbsd32_gid_tp) gidset; 931 } */ *uap = v; 932 int ngrp; 933 int error; 934 935 ngrp = SCARG(uap, gidsetsize); 936 if (ngrp == 0) { 937 *retval = p->p_ucred->cr_ngroups; 938 return (0); 939 } 940 if (ngrp < p->p_ucred->cr_ngroups) 941 return (EINVAL); 942 ngrp = p->p_ucred->cr_ngroups; 943 /* Should convert gid_t to netbsd32_gid_t, but they're the same */ 944 error = copyout((caddr_t)p->p_ucred->cr_groups, 945 (caddr_t)NETBSD32PTR64(SCARG(uap, gidset)), ngrp * sizeof(gid_t)); 946 if (error) 947 return (error); 948 *retval = ngrp; 949 return (0); 950 } 951 952 int 953 netbsd32_setgroups(p, v, retval) 954 struct proc *p; 955 void *v; 956 register_t *retval; 957 { 958 struct netbsd32_setgroups_args /* { 959 syscallarg(int) gidsetsize; 960 syscallarg(const netbsd32_gid_tp) gidset; 961 } */ *uap = v; 962 struct sys_setgroups_args ua; 963 964 NETBSD32TO64_UAP(gidsetsize); 965 NETBSD32TOP_UAP(gidset, gid_t); 966 return (sys_setgroups(p, &ua, retval)); 967 } 968 969 int 970 netbsd32_setpgid(p, v, retval) 971 struct proc *p; 972 void *v; 973 register_t *retval; 974 { 975 struct netbsd32_setpgid_args /* { 976 syscallarg(int) pid; 977 syscallarg(int) pgid; 978 } */ *uap = v; 979 struct sys_setpgid_args ua; 980 981 NETBSD32TO64_UAP(pid); 982 NETBSD32TO64_UAP(pgid); 983 return (sys_setpgid(p, &ua, retval)); 984 } 985 986 int 987 netbsd32_fcntl(p, v, retval) 988 struct proc *p; 989 void *v; 990 register_t *retval; 991 { 992 struct netbsd32_fcntl_args /* { 993 syscallarg(int) fd; 994 syscallarg(int) cmd; 995 syscallarg(netbsd32_voidp) arg; 996 } */ *uap = v; 997 struct sys_fcntl_args ua; 998 999 NETBSD32TO64_UAP(fd); 1000 NETBSD32TO64_UAP(cmd); 1001 NETBSD32TOP_UAP(arg, void); 1002 /* we can do this because `struct flock' doesn't change */ 1003 return (sys_fcntl(p, &ua, retval)); 1004 } 1005 1006 int 1007 netbsd32_dup2(p, v, retval) 1008 struct proc *p; 1009 void *v; 1010 register_t *retval; 1011 { 1012 struct netbsd32_dup2_args /* { 1013 syscallarg(int) from; 1014 syscallarg(int) to; 1015 } */ *uap = v; 1016 struct sys_dup2_args ua; 1017 1018 NETBSD32TO64_UAP(from); 1019 NETBSD32TO64_UAP(to); 1020 return (sys_dup2(p, &ua, retval)); 1021 } 1022 1023 int 1024 netbsd32_fsync(p, v, retval) 1025 struct proc *p; 1026 void *v; 1027 register_t *retval; 1028 { 1029 struct netbsd32_fsync_args /* { 1030 syscallarg(int) fd; 1031 } */ *uap = v; 1032 struct sys_fsync_args ua; 1033 1034 NETBSD32TO64_UAP(fd); 1035 return (sys_fsync(p, &ua, retval)); 1036 } 1037 1038 int 1039 netbsd32_setpriority(p, v, retval) 1040 struct proc *p; 1041 void *v; 1042 register_t *retval; 1043 { 1044 struct netbsd32_setpriority_args /* { 1045 syscallarg(int) which; 1046 syscallarg(int) who; 1047 syscallarg(int) prio; 1048 } */ *uap = v; 1049 struct sys_setpriority_args ua; 1050 1051 NETBSD32TO64_UAP(which); 1052 NETBSD32TO64_UAP(who); 1053 NETBSD32TO64_UAP(prio); 1054 return (sys_setpriority(p, &ua, retval)); 1055 } 1056 1057 int 1058 netbsd32_socket(p, v, retval) 1059 struct proc *p; 1060 void *v; 1061 register_t *retval; 1062 { 1063 struct netbsd32_socket_args /* { 1064 syscallarg(int) domain; 1065 syscallarg(int) type; 1066 syscallarg(int) protocol; 1067 } */ *uap = v; 1068 struct sys_socket_args ua; 1069 1070 NETBSD32TO64_UAP(domain); 1071 NETBSD32TO64_UAP(type); 1072 NETBSD32TO64_UAP(protocol); 1073 return (sys_socket(p, &ua, retval)); 1074 } 1075 1076 int 1077 netbsd32_connect(p, v, retval) 1078 struct proc *p; 1079 void *v; 1080 register_t *retval; 1081 { 1082 struct netbsd32_connect_args /* { 1083 syscallarg(int) s; 1084 syscallarg(const netbsd32_sockaddrp_t) name; 1085 syscallarg(int) namelen; 1086 } */ *uap = v; 1087 struct sys_connect_args ua; 1088 1089 NETBSD32TO64_UAP(s); 1090 NETBSD32TOP_UAP(name, struct sockaddr); 1091 NETBSD32TO64_UAP(namelen); 1092 return (sys_connect(p, &ua, retval)); 1093 } 1094 1095 int 1096 netbsd32_getpriority(p, v, retval) 1097 struct proc *p; 1098 void *v; 1099 register_t *retval; 1100 { 1101 struct netbsd32_getpriority_args /* { 1102 syscallarg(int) which; 1103 syscallarg(int) who; 1104 } */ *uap = v; 1105 struct sys_getpriority_args ua; 1106 1107 NETBSD32TO64_UAP(which); 1108 NETBSD32TO64_UAP(who); 1109 return (sys_getpriority(p, &ua, retval)); 1110 } 1111 1112 int 1113 netbsd32_bind(p, v, retval) 1114 struct proc *p; 1115 void *v; 1116 register_t *retval; 1117 { 1118 struct netbsd32_bind_args /* { 1119 syscallarg(int) s; 1120 syscallarg(const netbsd32_sockaddrp_t) name; 1121 syscallarg(int) namelen; 1122 } */ *uap = v; 1123 struct sys_bind_args ua; 1124 1125 NETBSD32TO64_UAP(s); 1126 NETBSD32TOP_UAP(name, struct sockaddr); 1127 NETBSD32TO64_UAP(namelen); 1128 return (sys_bind(p, &ua, retval)); 1129 } 1130 1131 int 1132 netbsd32_setsockopt(p, v, retval) 1133 struct proc *p; 1134 void *v; 1135 register_t *retval; 1136 { 1137 struct netbsd32_setsockopt_args /* { 1138 syscallarg(int) s; 1139 syscallarg(int) level; 1140 syscallarg(int) name; 1141 syscallarg(const netbsd32_voidp) val; 1142 syscallarg(int) valsize; 1143 } */ *uap = v; 1144 struct sys_setsockopt_args ua; 1145 1146 NETBSD32TO64_UAP(s); 1147 NETBSD32TO64_UAP(level); 1148 NETBSD32TO64_UAP(name); 1149 NETBSD32TOP_UAP(val, void); 1150 NETBSD32TO64_UAP(valsize); 1151 /* may be more efficient to do this inline. */ 1152 return (sys_setsockopt(p, &ua, retval)); 1153 } 1154 1155 int 1156 netbsd32_listen(p, v, retval) 1157 struct proc *p; 1158 void *v; 1159 register_t *retval; 1160 { 1161 struct netbsd32_listen_args /* { 1162 syscallarg(int) s; 1163 syscallarg(int) backlog; 1164 } */ *uap = v; 1165 struct sys_listen_args ua; 1166 1167 NETBSD32TO64_UAP(s); 1168 NETBSD32TO64_UAP(backlog); 1169 return (sys_listen(p, &ua, retval)); 1170 } 1171 1172 int 1173 netbsd32_fchown(p, v, retval) 1174 struct proc *p; 1175 void *v; 1176 register_t *retval; 1177 { 1178 struct netbsd32_fchown_args /* { 1179 syscallarg(int) fd; 1180 syscallarg(uid_t) uid; 1181 syscallarg(gid_t) gid; 1182 } */ *uap = v; 1183 struct sys_fchown_args ua; 1184 1185 NETBSD32TO64_UAP(fd); 1186 NETBSD32TO64_UAP(uid); 1187 NETBSD32TO64_UAP(gid); 1188 return (sys_fchown(p, &ua, retval)); 1189 } 1190 1191 int 1192 netbsd32_fchmod(p, v, retval) 1193 struct proc *p; 1194 void *v; 1195 register_t *retval; 1196 { 1197 struct netbsd32_fchmod_args /* { 1198 syscallarg(int) fd; 1199 syscallarg(mode_t) mode; 1200 } */ *uap = v; 1201 struct sys_fchmod_args ua; 1202 1203 NETBSD32TO64_UAP(fd); 1204 NETBSD32TO64_UAP(mode); 1205 return (sys_fchmod(p, &ua, retval)); 1206 } 1207 1208 int 1209 netbsd32_setreuid(p, v, retval) 1210 struct proc *p; 1211 void *v; 1212 register_t *retval; 1213 { 1214 struct netbsd32_setreuid_args /* { 1215 syscallarg(uid_t) ruid; 1216 syscallarg(uid_t) euid; 1217 } */ *uap = v; 1218 struct sys_setreuid_args ua; 1219 1220 NETBSD32TO64_UAP(ruid); 1221 NETBSD32TO64_UAP(euid); 1222 return (sys_setreuid(p, &ua, retval)); 1223 } 1224 1225 int 1226 netbsd32_setregid(p, v, retval) 1227 struct proc *p; 1228 void *v; 1229 register_t *retval; 1230 { 1231 struct netbsd32_setregid_args /* { 1232 syscallarg(gid_t) rgid; 1233 syscallarg(gid_t) egid; 1234 } */ *uap = v; 1235 struct sys_setregid_args ua; 1236 1237 NETBSD32TO64_UAP(rgid); 1238 NETBSD32TO64_UAP(egid); 1239 return (sys_setregid(p, &ua, retval)); 1240 } 1241 1242 int 1243 netbsd32_getsockopt(p, v, retval) 1244 struct proc *p; 1245 void *v; 1246 register_t *retval; 1247 { 1248 struct netbsd32_getsockopt_args /* { 1249 syscallarg(int) s; 1250 syscallarg(int) level; 1251 syscallarg(int) name; 1252 syscallarg(netbsd32_voidp) val; 1253 syscallarg(netbsd32_intp) avalsize; 1254 } */ *uap = v; 1255 struct sys_getsockopt_args ua; 1256 1257 NETBSD32TO64_UAP(s); 1258 NETBSD32TO64_UAP(level); 1259 NETBSD32TO64_UAP(name); 1260 NETBSD32TOP_UAP(val, void); 1261 NETBSD32TOP_UAP(avalsize, int); 1262 return (sys_getsockopt(p, &ua, retval)); 1263 } 1264 1265 int 1266 netbsd32_rename(p, v, retval) 1267 struct proc *p; 1268 void *v; 1269 register_t *retval; 1270 { 1271 struct netbsd32_rename_args /* { 1272 syscallarg(const netbsd32_charp) from; 1273 syscallarg(const netbsd32_charp) to; 1274 } */ *uap = v; 1275 struct sys_rename_args ua; 1276 1277 NETBSD32TOP_UAP(from, const char); 1278 NETBSD32TOP_UAP(to, const char) 1279 1280 return (sys_rename(p, &ua, retval)); 1281 } 1282 1283 int 1284 netbsd32_flock(p, v, retval) 1285 struct proc *p; 1286 void *v; 1287 register_t *retval; 1288 { 1289 struct netbsd32_flock_args /* { 1290 syscallarg(int) fd; 1291 syscallarg(int) how; 1292 } */ *uap = v; 1293 struct sys_flock_args ua; 1294 1295 NETBSD32TO64_UAP(fd); 1296 NETBSD32TO64_UAP(how) 1297 1298 return (sys_flock(p, &ua, retval)); 1299 } 1300 1301 int 1302 netbsd32_mkfifo(p, v, retval) 1303 struct proc *p; 1304 void *v; 1305 register_t *retval; 1306 { 1307 struct netbsd32_mkfifo_args /* { 1308 syscallarg(const netbsd32_charp) path; 1309 syscallarg(mode_t) mode; 1310 } */ *uap = v; 1311 struct sys_mkfifo_args ua; 1312 1313 NETBSD32TOP_UAP(path, const char) 1314 NETBSD32TO64_UAP(mode); 1315 return (sys_mkfifo(p, &ua, retval)); 1316 } 1317 1318 int 1319 netbsd32_shutdown(p, v, retval) 1320 struct proc *p; 1321 void *v; 1322 register_t *retval; 1323 { 1324 struct netbsd32_shutdown_args /* { 1325 syscallarg(int) s; 1326 syscallarg(int) how; 1327 } */ *uap = v; 1328 struct sys_shutdown_args ua; 1329 1330 NETBSD32TO64_UAP(s) 1331 NETBSD32TO64_UAP(how); 1332 return (sys_shutdown(p, &ua, retval)); 1333 } 1334 1335 int 1336 netbsd32_socketpair(p, v, retval) 1337 struct proc *p; 1338 void *v; 1339 register_t *retval; 1340 { 1341 struct netbsd32_socketpair_args /* { 1342 syscallarg(int) domain; 1343 syscallarg(int) type; 1344 syscallarg(int) protocol; 1345 syscallarg(netbsd32_intp) rsv; 1346 } */ *uap = v; 1347 struct sys_socketpair_args ua; 1348 1349 NETBSD32TO64_UAP(domain); 1350 NETBSD32TO64_UAP(type); 1351 NETBSD32TO64_UAP(protocol); 1352 NETBSD32TOP_UAP(rsv, int); 1353 /* Since we're just copying out two `int's we can do this */ 1354 return (sys_socketpair(p, &ua, retval)); 1355 } 1356 1357 int 1358 netbsd32_mkdir(p, v, retval) 1359 struct proc *p; 1360 void *v; 1361 register_t *retval; 1362 { 1363 struct netbsd32_mkdir_args /* { 1364 syscallarg(const netbsd32_charp) path; 1365 syscallarg(mode_t) mode; 1366 } */ *uap = v; 1367 struct sys_mkdir_args ua; 1368 1369 NETBSD32TOP_UAP(path, const char) 1370 NETBSD32TO64_UAP(mode); 1371 return (sys_mkdir(p, &ua, retval)); 1372 } 1373 1374 int 1375 netbsd32_rmdir(p, v, retval) 1376 struct proc *p; 1377 void *v; 1378 register_t *retval; 1379 { 1380 struct netbsd32_rmdir_args /* { 1381 syscallarg(const netbsd32_charp) path; 1382 } */ *uap = v; 1383 struct sys_rmdir_args ua; 1384 1385 NETBSD32TOP_UAP(path, const char); 1386 return (sys_rmdir(p, &ua, retval)); 1387 } 1388 1389 int 1390 netbsd32_quotactl(p, v, retval) 1391 struct proc *p; 1392 void *v; 1393 register_t *retval; 1394 { 1395 struct netbsd32_quotactl_args /* { 1396 syscallarg(const netbsd32_charp) path; 1397 syscallarg(int) cmd; 1398 syscallarg(int) uid; 1399 syscallarg(netbsd32_caddr_t) arg; 1400 } */ *uap = v; 1401 struct sys_quotactl_args ua; 1402 1403 NETBSD32TOP_UAP(path, const char); 1404 NETBSD32TO64_UAP(cmd); 1405 NETBSD32TO64_UAP(uid); 1406 NETBSD32TOX64_UAP(arg, caddr_t); 1407 return (sys_quotactl(p, &ua, retval)); 1408 } 1409 1410 #if defined(NFS) || defined(NFSSERVER) 1411 int 1412 netbsd32_nfssvc(p, v, retval) 1413 struct proc *p; 1414 void *v; 1415 register_t *retval; 1416 { 1417 #if 0 1418 struct netbsd32_nfssvc_args /* { 1419 syscallarg(int) flag; 1420 syscallarg(netbsd32_voidp) argp; 1421 } */ *uap = v; 1422 struct sys_nfssvc_args ua; 1423 1424 NETBSD32TO64_UAP(flag); 1425 NETBSD32TOP_UAP(argp, void); 1426 return (sys_nfssvc(p, &ua, retval)); 1427 #else 1428 /* Why would we want to support a 32-bit nfsd? */ 1429 return (ENOSYS); 1430 #endif 1431 } 1432 #endif 1433 1434 #if defined(NFS) || defined(NFSSERVER) 1435 int 1436 netbsd32_getfh(p, v, retval) 1437 struct proc *p; 1438 void *v; 1439 register_t *retval; 1440 { 1441 struct netbsd32_getfh_args /* { 1442 syscallarg(const netbsd32_charp) fname; 1443 syscallarg(netbsd32_fhandlep_t) fhp; 1444 } */ *uap = v; 1445 struct sys_getfh_args ua; 1446 1447 NETBSD32TOP_UAP(fname, const char); 1448 NETBSD32TOP_UAP(fhp, struct fhandle); 1449 /* Lucky for us a fhandlep_t doesn't change sizes */ 1450 return (sys_getfh(p, &ua, retval)); 1451 } 1452 #endif 1453 1454 int 1455 netbsd32_pread(p, v, retval) 1456 struct proc *p; 1457 void *v; 1458 register_t *retval; 1459 { 1460 struct netbsd32_pread_args /* { 1461 syscallarg(int) fd; 1462 syscallarg(netbsd32_voidp) buf; 1463 syscallarg(netbsd32_size_t) nbyte; 1464 syscallarg(int) pad; 1465 syscallarg(off_t) offset; 1466 } */ *uap = v; 1467 struct sys_pread_args ua; 1468 ssize_t rt; 1469 int error; 1470 1471 NETBSD32TO64_UAP(fd); 1472 NETBSD32TOP_UAP(buf, void); 1473 NETBSD32TOX_UAP(nbyte, size_t); 1474 NETBSD32TO64_UAP(pad); 1475 NETBSD32TO64_UAP(offset); 1476 error = sys_pread(p, &ua, (register_t *)&rt); 1477 *retval = rt; 1478 return (error); 1479 } 1480 1481 int 1482 netbsd32_pwrite(p, v, retval) 1483 struct proc *p; 1484 void *v; 1485 register_t *retval; 1486 { 1487 struct netbsd32_pwrite_args /* { 1488 syscallarg(int) fd; 1489 syscallarg(const netbsd32_voidp) buf; 1490 syscallarg(netbsd32_size_t) nbyte; 1491 syscallarg(int) pad; 1492 syscallarg(off_t) offset; 1493 } */ *uap = v; 1494 struct sys_pwrite_args ua; 1495 ssize_t rt; 1496 int error; 1497 1498 NETBSD32TO64_UAP(fd); 1499 NETBSD32TOP_UAP(buf, void); 1500 NETBSD32TOX_UAP(nbyte, size_t); 1501 NETBSD32TO64_UAP(pad); 1502 NETBSD32TO64_UAP(offset); 1503 error = sys_pwrite(p, &ua, (register_t *)&rt); 1504 *retval = rt; 1505 return (error); 1506 } 1507 1508 int 1509 netbsd32_setgid(p, v, retval) 1510 struct proc *p; 1511 void *v; 1512 register_t *retval; 1513 { 1514 struct netbsd32_setgid_args /* { 1515 syscallarg(gid_t) gid; 1516 } */ *uap = v; 1517 struct sys_setgid_args ua; 1518 1519 NETBSD32TO64_UAP(gid); 1520 return (sys_setgid(p, v, retval)); 1521 } 1522 1523 int 1524 netbsd32_setegid(p, v, retval) 1525 struct proc *p; 1526 void *v; 1527 register_t *retval; 1528 { 1529 struct netbsd32_setegid_args /* { 1530 syscallarg(gid_t) egid; 1531 } */ *uap = v; 1532 struct sys_setegid_args ua; 1533 1534 NETBSD32TO64_UAP(egid); 1535 return (sys_setegid(p, v, retval)); 1536 } 1537 1538 int 1539 netbsd32_seteuid(p, v, retval) 1540 struct proc *p; 1541 void *v; 1542 register_t *retval; 1543 { 1544 struct netbsd32_seteuid_args /* { 1545 syscallarg(gid_t) euid; 1546 } */ *uap = v; 1547 struct sys_seteuid_args ua; 1548 1549 NETBSD32TO64_UAP(euid); 1550 return (sys_seteuid(p, v, retval)); 1551 } 1552 1553 #ifdef LFS 1554 int 1555 netbsd32_sys_lfs_bmapv(p, v, retval) 1556 struct proc *p; 1557 void *v; 1558 register_t *retval; 1559 { 1560 1561 return (ENOSYS); /* XXX */ 1562 } 1563 1564 int 1565 netbsd32_sys_lfs_markv(p, v, retval) 1566 struct proc *p; 1567 void *v; 1568 register_t *retval; 1569 { 1570 1571 return (ENOSYS); /* XXX */ 1572 } 1573 1574 int 1575 netbsd32_sys_lfs_segclean(p, v, retval) 1576 struct proc *p; 1577 void *v; 1578 register_t *retval; 1579 { 1580 1581 return (ENOSYS); /* XXX */ 1582 } 1583 1584 int 1585 netbsd32_sys_lfs_segwait(p, v, retval) 1586 struct proc *p; 1587 void *v; 1588 register_t *retval; 1589 { 1590 1591 return (ENOSYS); /* XXX */ 1592 } 1593 #endif 1594 1595 int 1596 netbsd32_pathconf(p, v, retval) 1597 struct proc *p; 1598 void *v; 1599 register_t *retval; 1600 { 1601 struct netbsd32_pathconf_args /* { 1602 syscallarg(int) fd; 1603 syscallarg(int) name; 1604 } */ *uap = v; 1605 struct sys_pathconf_args ua; 1606 long rt; 1607 int error; 1608 1609 NETBSD32TOP_UAP(path, const char); 1610 NETBSD32TO64_UAP(name); 1611 error = sys_pathconf(p, &ua, (register_t *)&rt); 1612 *retval = rt; 1613 return (error); 1614 } 1615 1616 int 1617 netbsd32_fpathconf(p, v, retval) 1618 struct proc *p; 1619 void *v; 1620 register_t *retval; 1621 { 1622 struct netbsd32_fpathconf_args /* { 1623 syscallarg(int) fd; 1624 syscallarg(int) name; 1625 } */ *uap = v; 1626 struct sys_fpathconf_args ua; 1627 long rt; 1628 int error; 1629 1630 NETBSD32TO64_UAP(fd); 1631 NETBSD32TO64_UAP(name); 1632 error = sys_fpathconf(p, &ua, (register_t *)&rt); 1633 *retval = rt; 1634 return (error); 1635 } 1636 1637 int 1638 netbsd32_getrlimit(p, v, retval) 1639 struct proc *p; 1640 void *v; 1641 register_t *retval; 1642 { 1643 struct netbsd32_getrlimit_args /* { 1644 syscallarg(int) which; 1645 syscallarg(netbsd32_rlimitp_t) rlp; 1646 } */ *uap = v; 1647 int which = SCARG(uap, which); 1648 1649 if ((u_int)which >= RLIM_NLIMITS) 1650 return (EINVAL); 1651 return (copyout(&p->p_rlimit[which], 1652 (caddr_t)NETBSD32PTR64(SCARG(uap, rlp)), sizeof(struct rlimit))); 1653 } 1654 1655 int 1656 netbsd32_setrlimit(p, v, retval) 1657 struct proc *p; 1658 void *v; 1659 register_t *retval; 1660 { 1661 struct netbsd32_setrlimit_args /* { 1662 syscallarg(int) which; 1663 syscallarg(const netbsd32_rlimitp_t) rlp; 1664 } */ *uap = v; 1665 int which = SCARG(uap, which); 1666 struct rlimit alim; 1667 int error; 1668 1669 error = copyin((caddr_t)NETBSD32PTR64(SCARG(uap, rlp)), &alim, 1670 sizeof(struct rlimit)); 1671 if (error) 1672 return (error); 1673 return (dosetrlimit(p, p->p_ucred, which, &alim)); 1674 } 1675 1676 int 1677 netbsd32_mmap(p, v, retval) 1678 struct proc *p; 1679 void *v; 1680 register_t *retval; 1681 { 1682 struct netbsd32_mmap_args /* { 1683 syscallarg(netbsd32_voidp) addr; 1684 syscallarg(netbsd32_size_t) len; 1685 syscallarg(int) prot; 1686 syscallarg(int) flags; 1687 syscallarg(int) fd; 1688 syscallarg(netbsd32_long) pad; 1689 syscallarg(off_t) pos; 1690 } */ *uap = v; 1691 struct sys_mmap_args ua; 1692 int error; 1693 1694 NETBSD32TOP_UAP(addr, void); 1695 NETBSD32TOX_UAP(len, size_t); 1696 NETBSD32TO64_UAP(prot); 1697 NETBSD32TO64_UAP(flags); 1698 NETBSD32TO64_UAP(fd); 1699 NETBSD32TOX_UAP(pad, long); 1700 NETBSD32TOX_UAP(pos, off_t); 1701 error = sys_mmap(p, &ua, retval); 1702 if ((u_long)*retval > (u_long)UINT_MAX) { 1703 printf("netbsd32_mmap: retval out of range: 0x%lx", 1704 (u_long)*retval); 1705 /* Should try to recover and return an error here. */ 1706 } 1707 return (error); 1708 } 1709 1710 int 1711 netbsd32_lseek(p, v, retval) 1712 struct proc *p; 1713 void *v; 1714 register_t *retval; 1715 { 1716 struct netbsd32_lseek_args /* { 1717 syscallarg(int) fd; 1718 syscallarg(int) pad; 1719 syscallarg(off_t) offset; 1720 syscallarg(int) whence; 1721 } */ *uap = v; 1722 struct sys_lseek_args ua; 1723 1724 NETBSD32TO64_UAP(fd); 1725 NETBSD32TO64_UAP(pad); 1726 NETBSD32TO64_UAP(offset); 1727 NETBSD32TO64_UAP(whence); 1728 return (sys_lseek(p, &ua, retval)); 1729 } 1730 1731 int 1732 netbsd32_truncate(p, v, retval) 1733 struct proc *p; 1734 void *v; 1735 register_t *retval; 1736 { 1737 struct netbsd32_truncate_args /* { 1738 syscallarg(const netbsd32_charp) path; 1739 syscallarg(int) pad; 1740 syscallarg(off_t) length; 1741 } */ *uap = v; 1742 struct sys_truncate_args ua; 1743 1744 NETBSD32TOP_UAP(path, const char); 1745 NETBSD32TO64_UAP(pad); 1746 NETBSD32TO64_UAP(length); 1747 return (sys_truncate(p, &ua, retval)); 1748 } 1749 1750 int 1751 netbsd32_ftruncate(p, v, retval) 1752 struct proc *p; 1753 void *v; 1754 register_t *retval; 1755 { 1756 struct netbsd32_ftruncate_args /* { 1757 syscallarg(int) fd; 1758 syscallarg(int) pad; 1759 syscallarg(off_t) length; 1760 } */ *uap = v; 1761 struct sys_ftruncate_args ua; 1762 1763 NETBSD32TO64_UAP(fd); 1764 NETBSD32TO64_UAP(pad); 1765 NETBSD32TO64_UAP(length); 1766 return (sys_ftruncate(p, &ua, retval)); 1767 } 1768 1769 int 1770 netbsd32_mlock(p, v, retval) 1771 struct proc *p; 1772 void *v; 1773 register_t *retval; 1774 { 1775 struct netbsd32_mlock_args /* { 1776 syscallarg(const netbsd32_voidp) addr; 1777 syscallarg(netbsd32_size_t) len; 1778 } */ *uap = v; 1779 struct sys_mlock_args ua; 1780 1781 NETBSD32TOP_UAP(addr, const void); 1782 NETBSD32TO64_UAP(len); 1783 return (sys_mlock(p, &ua, retval)); 1784 } 1785 1786 int 1787 netbsd32_munlock(p, v, retval) 1788 struct proc *p; 1789 void *v; 1790 register_t *retval; 1791 { 1792 struct netbsd32_munlock_args /* { 1793 syscallarg(const netbsd32_voidp) addr; 1794 syscallarg(netbsd32_size_t) len; 1795 } */ *uap = v; 1796 struct sys_munlock_args ua; 1797 1798 NETBSD32TOP_UAP(addr, const void); 1799 NETBSD32TO64_UAP(len); 1800 return (sys_munlock(p, &ua, retval)); 1801 } 1802 1803 int 1804 netbsd32_undelete(p, v, retval) 1805 struct proc *p; 1806 void *v; 1807 register_t *retval; 1808 { 1809 struct netbsd32_undelete_args /* { 1810 syscallarg(const netbsd32_charp) path; 1811 } */ *uap = v; 1812 struct sys_undelete_args ua; 1813 1814 NETBSD32TOP_UAP(path, const char); 1815 return (sys_undelete(p, &ua, retval)); 1816 } 1817 1818 int 1819 netbsd32_getpgid(p, v, retval) 1820 struct proc *p; 1821 void *v; 1822 register_t *retval; 1823 { 1824 struct netbsd32_getpgid_args /* { 1825 syscallarg(pid_t) pid; 1826 } */ *uap = v; 1827 struct sys_getpgid_args ua; 1828 1829 NETBSD32TO64_UAP(pid); 1830 return (sys_getpgid(p, &ua, retval)); 1831 } 1832 1833 int 1834 netbsd32_reboot(p, v, retval) 1835 struct proc *p; 1836 void *v; 1837 register_t *retval; 1838 { 1839 struct netbsd32_reboot_args /* { 1840 syscallarg(int) opt; 1841 syscallarg(netbsd32_charp) bootstr; 1842 } */ *uap = v; 1843 struct sys_reboot_args ua; 1844 1845 NETBSD32TO64_UAP(opt); 1846 NETBSD32TOP_UAP(bootstr, char); 1847 return (sys_reboot(p, &ua, retval)); 1848 } 1849 1850 int 1851 netbsd32_poll(p, v, retval) 1852 struct proc *p; 1853 void *v; 1854 register_t *retval; 1855 { 1856 struct netbsd32_poll_args /* { 1857 syscallarg(netbsd32_pollfdp_t) fds; 1858 syscallarg(u_int) nfds; 1859 syscallarg(int) timeout; 1860 } */ *uap = v; 1861 struct sys_poll_args ua; 1862 1863 NETBSD32TOP_UAP(fds, struct pollfd); 1864 NETBSD32TO64_UAP(nfds); 1865 NETBSD32TO64_UAP(timeout); 1866 return (sys_poll(p, &ua, retval)); 1867 } 1868 1869 int 1870 netbsd32_fdatasync(p, v, retval) 1871 struct proc *p; 1872 void *v; 1873 register_t *retval; 1874 { 1875 struct netbsd32_fdatasync_args /* { 1876 syscallarg(int) fd; 1877 } */ *uap = v; 1878 struct sys_fdatasync_args ua; 1879 1880 NETBSD32TO64_UAP(fd); 1881 return (sys_fdatasync(p, &ua, retval)); 1882 } 1883 1884 int 1885 netbsd32___posix_rename(p, v, retval) 1886 struct proc *p; 1887 void *v; 1888 register_t *retval; 1889 { 1890 struct netbsd32___posix_rename_args /* { 1891 syscallarg(const netbsd32_charp) from; 1892 syscallarg(const netbsd32_charp) to; 1893 } */ *uap = v; 1894 struct sys___posix_rename_args ua; 1895 1896 NETBSD32TOP_UAP(from, const char); 1897 NETBSD32TOP_UAP(to, const char); 1898 return (sys___posix_rename(p, &ua, retval)); 1899 } 1900 1901 int 1902 netbsd32_swapctl(p, v, retval) 1903 struct proc *p; 1904 void *v; 1905 register_t *retval; 1906 { 1907 struct netbsd32_swapctl_args /* { 1908 syscallarg(int) cmd; 1909 syscallarg(const netbsd32_voidp) arg; 1910 syscallarg(int) misc; 1911 } */ *uap = v; 1912 struct sys_swapctl_args ua; 1913 1914 NETBSD32TO64_UAP(cmd); 1915 NETBSD32TOP_UAP(arg, const void); 1916 NETBSD32TO64_UAP(misc); 1917 return (sys_swapctl(p, &ua, retval)); 1918 } 1919 1920 int 1921 netbsd32_minherit(p, v, retval) 1922 struct proc *p; 1923 void *v; 1924 register_t *retval; 1925 { 1926 struct netbsd32_minherit_args /* { 1927 syscallarg(netbsd32_voidp) addr; 1928 syscallarg(netbsd32_size_t) len; 1929 syscallarg(int) inherit; 1930 } */ *uap = v; 1931 struct sys_minherit_args ua; 1932 1933 NETBSD32TOP_UAP(addr, void); 1934 NETBSD32TOX_UAP(len, size_t); 1935 NETBSD32TO64_UAP(inherit); 1936 return (sys_minherit(p, &ua, retval)); 1937 } 1938 1939 int 1940 netbsd32_lchmod(p, v, retval) 1941 struct proc *p; 1942 void *v; 1943 register_t *retval; 1944 { 1945 struct netbsd32_lchmod_args /* { 1946 syscallarg(const netbsd32_charp) path; 1947 syscallarg(mode_t) mode; 1948 } */ *uap = v; 1949 struct sys_lchmod_args ua; 1950 1951 NETBSD32TOP_UAP(path, const char); 1952 NETBSD32TO64_UAP(mode); 1953 return (sys_lchmod(p, &ua, retval)); 1954 } 1955 1956 int 1957 netbsd32_lchown(p, v, retval) 1958 struct proc *p; 1959 void *v; 1960 register_t *retval; 1961 { 1962 struct netbsd32_lchown_args /* { 1963 syscallarg(const netbsd32_charp) path; 1964 syscallarg(uid_t) uid; 1965 syscallarg(gid_t) gid; 1966 } */ *uap = v; 1967 struct sys_lchown_args ua; 1968 1969 NETBSD32TOP_UAP(path, const char); 1970 NETBSD32TO64_UAP(uid); 1971 NETBSD32TO64_UAP(gid); 1972 return (sys_lchown(p, &ua, retval)); 1973 } 1974 1975 int 1976 netbsd32___msync13(p, v, retval) 1977 struct proc *p; 1978 void *v; 1979 register_t *retval; 1980 { 1981 struct netbsd32___msync13_args /* { 1982 syscallarg(netbsd32_voidp) addr; 1983 syscallarg(netbsd32_size_t) len; 1984 syscallarg(int) flags; 1985 } */ *uap = v; 1986 struct sys___msync13_args ua; 1987 1988 NETBSD32TOP_UAP(addr, void); 1989 NETBSD32TOX_UAP(len, size_t); 1990 NETBSD32TO64_UAP(flags); 1991 return (sys___msync13(p, &ua, retval)); 1992 } 1993 1994 int 1995 netbsd32___posix_chown(p, v, retval) 1996 struct proc *p; 1997 void *v; 1998 register_t *retval; 1999 { 2000 struct netbsd32___posix_chown_args /* { 2001 syscallarg(const netbsd32_charp) path; 2002 syscallarg(uid_t) uid; 2003 syscallarg(gid_t) gid; 2004 } */ *uap = v; 2005 struct sys___posix_chown_args ua; 2006 2007 NETBSD32TOP_UAP(path, const char); 2008 NETBSD32TO64_UAP(uid); 2009 NETBSD32TO64_UAP(gid); 2010 return (sys___posix_chown(p, &ua, retval)); 2011 } 2012 2013 int 2014 netbsd32___posix_fchown(p, v, retval) 2015 struct proc *p; 2016 void *v; 2017 register_t *retval; 2018 { 2019 struct netbsd32___posix_fchown_args /* { 2020 syscallarg(int) fd; 2021 syscallarg(uid_t) uid; 2022 syscallarg(gid_t) gid; 2023 } */ *uap = v; 2024 struct sys___posix_fchown_args ua; 2025 2026 NETBSD32TO64_UAP(fd); 2027 NETBSD32TO64_UAP(uid); 2028 NETBSD32TO64_UAP(gid); 2029 return (sys___posix_fchown(p, &ua, retval)); 2030 } 2031 2032 int 2033 netbsd32___posix_lchown(p, v, retval) 2034 struct proc *p; 2035 void *v; 2036 register_t *retval; 2037 { 2038 struct netbsd32___posix_lchown_args /* { 2039 syscallarg(const netbsd32_charp) path; 2040 syscallarg(uid_t) uid; 2041 syscallarg(gid_t) gid; 2042 } */ *uap = v; 2043 struct sys___posix_lchown_args ua; 2044 2045 NETBSD32TOP_UAP(path, const char); 2046 NETBSD32TO64_UAP(uid); 2047 NETBSD32TO64_UAP(gid); 2048 return (sys___posix_lchown(p, &ua, retval)); 2049 } 2050 2051 int 2052 netbsd32_getsid(p, v, retval) 2053 struct proc *p; 2054 void *v; 2055 register_t *retval; 2056 { 2057 struct netbsd32_getsid_args /* { 2058 syscallarg(pid_t) pid; 2059 } */ *uap = v; 2060 struct sys_getsid_args ua; 2061 2062 NETBSD32TO64_UAP(pid); 2063 return (sys_getsid(p, &ua, retval)); 2064 } 2065 2066 #ifdef KTRACE 2067 int 2068 netbsd32_fktrace(p, v, retval) 2069 struct proc *p; 2070 void *v; 2071 register_t *retval; 2072 { 2073 struct netbsd32_fktrace_args /* { 2074 syscallarg(const int) fd; 2075 syscallarg(int) ops; 2076 syscallarg(int) facs; 2077 syscallarg(int) pid; 2078 } */ *uap = v; 2079 #if 0 2080 struct sys_fktrace_args ua; 2081 #else 2082 /* XXXX */ 2083 struct sys_fktrace_noconst_args { 2084 syscallarg(int) fd; 2085 syscallarg(int) ops; 2086 syscallarg(int) facs; 2087 syscallarg(int) pid; 2088 } ua; 2089 #endif 2090 2091 NETBSD32TOX_UAP(fd, int); 2092 NETBSD32TO64_UAP(ops); 2093 NETBSD32TO64_UAP(facs); 2094 NETBSD32TO64_UAP(pid); 2095 return (sys_fktrace(p, &ua, retval)); 2096 } 2097 #endif /* KTRACE */ 2098 2099 int netbsd32___sigpending14(p, v, retval) 2100 struct proc *p; 2101 void *v; 2102 register_t *retval; 2103 { 2104 struct netbsd32___sigpending14_args /* { 2105 syscallarg(sigset_t *) set; 2106 } */ *uap = v; 2107 struct sys___sigpending14_args ua; 2108 2109 NETBSD32TOP_UAP(set, sigset_t); 2110 return (sys___sigpending14(p, &ua, retval)); 2111 } 2112 2113 int netbsd32___sigprocmask14(p, v, retval) 2114 struct proc *p; 2115 void *v; 2116 register_t *retval; 2117 { 2118 struct netbsd32___sigprocmask14_args /* { 2119 syscallarg(int) how; 2120 syscallarg(const sigset_t *) set; 2121 syscallarg(sigset_t *) oset; 2122 } */ *uap = v; 2123 struct sys___sigprocmask14_args ua; 2124 2125 NETBSD32TO64_UAP(how); 2126 NETBSD32TOP_UAP(set, sigset_t); 2127 NETBSD32TOP_UAP(oset, sigset_t); 2128 return (sys___sigprocmask14(p, &ua, retval)); 2129 } 2130 2131 int netbsd32___sigsuspend14(p, v, retval) 2132 struct proc *p; 2133 void *v; 2134 register_t *retval; 2135 { 2136 struct netbsd32___sigsuspend14_args /* { 2137 syscallarg(const sigset_t *) set; 2138 } */ *uap = v; 2139 struct sys___sigsuspend14_args ua; 2140 2141 NETBSD32TOP_UAP(set, sigset_t); 2142 return (sys___sigsuspend14(p, &ua, retval)); 2143 }; 2144 2145 int netbsd32_fchroot(p, v, retval) 2146 struct proc *p; 2147 void *v; 2148 register_t *retval; 2149 { 2150 struct netbsd32_fchroot_args /* { 2151 syscallarg(int) fd; 2152 } */ *uap = v; 2153 struct sys_fchroot_args ua; 2154 2155 NETBSD32TO64_UAP(fd); 2156 return (sys_fchroot(p, &ua, retval)); 2157 } 2158 2159 /* 2160 * Open a file given a file handle. 2161 * 2162 * Check permissions, allocate an open file structure, 2163 * and call the device open routine if any. 2164 */ 2165 int 2166 netbsd32_fhopen(p, v, retval) 2167 struct proc *p; 2168 void *v; 2169 register_t *retval; 2170 { 2171 struct netbsd32_fhopen_args /* { 2172 syscallarg(const fhandle_t *) fhp; 2173 syscallarg(int) flags; 2174 } */ *uap = v; 2175 struct sys_fhopen_args ua; 2176 2177 NETBSD32TOP_UAP(fhp, fhandle_t); 2178 NETBSD32TO64_UAP(flags); 2179 return (sys_fhopen(p, &ua, retval)); 2180 } 2181 2182 int netbsd32_fhstat(p, v, retval) 2183 struct proc *p; 2184 void *v; 2185 register_t *retval; 2186 { 2187 struct netbsd32_fhstat_args /* { 2188 syscallarg(const netbsd32_fhandlep_t) fhp; 2189 syscallarg(struct stat *) sb; 2190 } */ *uap = v; 2191 struct sys_fhstat_args ua; 2192 2193 NETBSD32TOP_UAP(fhp, const fhandle_t); 2194 NETBSD32TOP_UAP(sb, struct stat); 2195 return (sys_fhstat(p, &ua, retval)); 2196 } 2197 2198 int netbsd32_fhstatfs(p, v, retval) 2199 struct proc *p; 2200 void *v; 2201 register_t *retval; 2202 { 2203 struct netbsd32_fhstatfs_args /* { 2204 syscallarg(const netbsd32_fhandlep_t) fhp; 2205 syscallarg(struct statfs *) buf; 2206 } */ *uap = v; 2207 struct sys_fhstatfs_args ua; 2208 2209 NETBSD32TOP_UAP(fhp, const fhandle_t); 2210 NETBSD32TOP_UAP(buf, struct statfs); 2211 return (sys_fhstatfs(p, &ua, retval)); 2212 } 2213 2214 /* virtual memory syscalls */ 2215 int 2216 netbsd32_ovadvise(p, v, retval) 2217 struct proc *p; 2218 void *v; 2219 register_t *retval; 2220 { 2221 struct netbsd32_ovadvise_args /* { 2222 syscallarg(int) anom; 2223 } */ *uap = v; 2224 struct sys_ovadvise_args ua; 2225 2226 NETBSD32TO64_UAP(anom); 2227 return (sys_ovadvise(p, &ua, retval)); 2228 } 2229 2230
Indexes created Sun Sep 21 19:09:51 GMT 2025