netbsd32_netbsd.c revision 1.60.2.4
1 /* $NetBSD: netbsd32_netbsd.c,v 1.60.2.4 2002/10/10 18:38:06 jdolecek 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.60.2.4 2002/10/10 18:38:06 jdolecek 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_MAXSYSCALL, 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 *)(u_long)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 struct pcred *pc = p->p_cred; 933 int ngrp; 934 int error; 935 936 ngrp = SCARG(uap, gidsetsize); 937 if (ngrp == 0) { 938 *retval = pc->pc_ucred->cr_ngroups; 939 return (0); 940 } 941 if (ngrp < pc->pc_ucred->cr_ngroups) 942 return (EINVAL); 943 ngrp = pc->pc_ucred->cr_ngroups; 944 /* Should convert gid_t to netbsd32_gid_t, but they're the same */ 945 error = copyout((caddr_t)pc->pc_ucred->cr_groups, 946 (caddr_t)(u_long)SCARG(uap, gidset), 947 ngrp * sizeof(gid_t)); 948 if (error) 949 return (error); 950 *retval = ngrp; 951 return (0); 952 } 953 954 int 955 netbsd32_setgroups(p, v, retval) 956 struct proc *p; 957 void *v; 958 register_t *retval; 959 { 960 struct netbsd32_setgroups_args /* { 961 syscallarg(int) gidsetsize; 962 syscallarg(const netbsd32_gid_tp) gidset; 963 } */ *uap = v; 964 struct sys_setgroups_args ua; 965 966 NETBSD32TO64_UAP(gidsetsize); 967 NETBSD32TOP_UAP(gidset, gid_t); 968 return (sys_setgroups(p, &ua, retval)); 969 } 970 971 int 972 netbsd32_setpgid(p, v, retval) 973 struct proc *p; 974 void *v; 975 register_t *retval; 976 { 977 struct netbsd32_setpgid_args /* { 978 syscallarg(int) pid; 979 syscallarg(int) pgid; 980 } */ *uap = v; 981 struct sys_setpgid_args ua; 982 983 NETBSD32TO64_UAP(pid); 984 NETBSD32TO64_UAP(pgid); 985 return (sys_setpgid(p, &ua, retval)); 986 } 987 988 int 989 netbsd32_fcntl(p, v, retval) 990 struct proc *p; 991 void *v; 992 register_t *retval; 993 { 994 struct netbsd32_fcntl_args /* { 995 syscallarg(int) fd; 996 syscallarg(int) cmd; 997 syscallarg(netbsd32_voidp) arg; 998 } */ *uap = v; 999 struct sys_fcntl_args ua; 1000 1001 NETBSD32TO64_UAP(fd); 1002 NETBSD32TO64_UAP(cmd); 1003 NETBSD32TOP_UAP(arg, void); 1004 /* we can do this because `struct flock' doesn't change */ 1005 return (sys_fcntl(p, &ua, retval)); 1006 } 1007 1008 int 1009 netbsd32_dup2(p, v, retval) 1010 struct proc *p; 1011 void *v; 1012 register_t *retval; 1013 { 1014 struct netbsd32_dup2_args /* { 1015 syscallarg(int) from; 1016 syscallarg(int) to; 1017 } */ *uap = v; 1018 struct sys_dup2_args ua; 1019 1020 NETBSD32TO64_UAP(from); 1021 NETBSD32TO64_UAP(to); 1022 return (sys_dup2(p, &ua, retval)); 1023 } 1024 1025 int 1026 netbsd32_fsync(p, v, retval) 1027 struct proc *p; 1028 void *v; 1029 register_t *retval; 1030 { 1031 struct netbsd32_fsync_args /* { 1032 syscallarg(int) fd; 1033 } */ *uap = v; 1034 struct sys_fsync_args ua; 1035 1036 NETBSD32TO64_UAP(fd); 1037 return (sys_fsync(p, &ua, retval)); 1038 } 1039 1040 int 1041 netbsd32_setpriority(p, v, retval) 1042 struct proc *p; 1043 void *v; 1044 register_t *retval; 1045 { 1046 struct netbsd32_setpriority_args /* { 1047 syscallarg(int) which; 1048 syscallarg(int) who; 1049 syscallarg(int) prio; 1050 } */ *uap = v; 1051 struct sys_setpriority_args ua; 1052 1053 NETBSD32TO64_UAP(which); 1054 NETBSD32TO64_UAP(who); 1055 NETBSD32TO64_UAP(prio); 1056 return (sys_setpriority(p, &ua, retval)); 1057 } 1058 1059 int 1060 netbsd32_socket(p, v, retval) 1061 struct proc *p; 1062 void *v; 1063 register_t *retval; 1064 { 1065 struct netbsd32_socket_args /* { 1066 syscallarg(int) domain; 1067 syscallarg(int) type; 1068 syscallarg(int) protocol; 1069 } */ *uap = v; 1070 struct sys_socket_args ua; 1071 1072 NETBSD32TO64_UAP(domain); 1073 NETBSD32TO64_UAP(type); 1074 NETBSD32TO64_UAP(protocol); 1075 return (sys_socket(p, &ua, retval)); 1076 } 1077 1078 int 1079 netbsd32_connect(p, v, retval) 1080 struct proc *p; 1081 void *v; 1082 register_t *retval; 1083 { 1084 struct netbsd32_connect_args /* { 1085 syscallarg(int) s; 1086 syscallarg(const netbsd32_sockaddrp_t) name; 1087 syscallarg(int) namelen; 1088 } */ *uap = v; 1089 struct sys_connect_args ua; 1090 1091 NETBSD32TO64_UAP(s); 1092 NETBSD32TOP_UAP(name, struct sockaddr); 1093 NETBSD32TO64_UAP(namelen); 1094 return (sys_connect(p, &ua, retval)); 1095 } 1096 1097 int 1098 netbsd32_getpriority(p, v, retval) 1099 struct proc *p; 1100 void *v; 1101 register_t *retval; 1102 { 1103 struct netbsd32_getpriority_args /* { 1104 syscallarg(int) which; 1105 syscallarg(int) who; 1106 } */ *uap = v; 1107 struct sys_getpriority_args ua; 1108 1109 NETBSD32TO64_UAP(which); 1110 NETBSD32TO64_UAP(who); 1111 return (sys_getpriority(p, &ua, retval)); 1112 } 1113 1114 int 1115 netbsd32_bind(p, v, retval) 1116 struct proc *p; 1117 void *v; 1118 register_t *retval; 1119 { 1120 struct netbsd32_bind_args /* { 1121 syscallarg(int) s; 1122 syscallarg(const netbsd32_sockaddrp_t) name; 1123 syscallarg(int) namelen; 1124 } */ *uap = v; 1125 struct sys_bind_args ua; 1126 1127 NETBSD32TO64_UAP(s); 1128 NETBSD32TOP_UAP(name, struct sockaddr); 1129 NETBSD32TO64_UAP(namelen); 1130 return (sys_bind(p, &ua, retval)); 1131 } 1132 1133 int 1134 netbsd32_setsockopt(p, v, retval) 1135 struct proc *p; 1136 void *v; 1137 register_t *retval; 1138 { 1139 struct netbsd32_setsockopt_args /* { 1140 syscallarg(int) s; 1141 syscallarg(int) level; 1142 syscallarg(int) name; 1143 syscallarg(const netbsd32_voidp) val; 1144 syscallarg(int) valsize; 1145 } */ *uap = v; 1146 struct sys_setsockopt_args ua; 1147 1148 NETBSD32TO64_UAP(s); 1149 NETBSD32TO64_UAP(level); 1150 NETBSD32TO64_UAP(name); 1151 NETBSD32TOP_UAP(val, void); 1152 NETBSD32TO64_UAP(valsize); 1153 /* may be more efficient to do this inline. */ 1154 return (sys_setsockopt(p, &ua, retval)); 1155 } 1156 1157 int 1158 netbsd32_listen(p, v, retval) 1159 struct proc *p; 1160 void *v; 1161 register_t *retval; 1162 { 1163 struct netbsd32_listen_args /* { 1164 syscallarg(int) s; 1165 syscallarg(int) backlog; 1166 } */ *uap = v; 1167 struct sys_listen_args ua; 1168 1169 NETBSD32TO64_UAP(s); 1170 NETBSD32TO64_UAP(backlog); 1171 return (sys_listen(p, &ua, retval)); 1172 } 1173 1174 int 1175 netbsd32_fchown(p, v, retval) 1176 struct proc *p; 1177 void *v; 1178 register_t *retval; 1179 { 1180 struct netbsd32_fchown_args /* { 1181 syscallarg(int) fd; 1182 syscallarg(uid_t) uid; 1183 syscallarg(gid_t) gid; 1184 } */ *uap = v; 1185 struct sys_fchown_args ua; 1186 1187 NETBSD32TO64_UAP(fd); 1188 NETBSD32TO64_UAP(uid); 1189 NETBSD32TO64_UAP(gid); 1190 return (sys_fchown(p, &ua, retval)); 1191 } 1192 1193 int 1194 netbsd32_fchmod(p, v, retval) 1195 struct proc *p; 1196 void *v; 1197 register_t *retval; 1198 { 1199 struct netbsd32_fchmod_args /* { 1200 syscallarg(int) fd; 1201 syscallarg(mode_t) mode; 1202 } */ *uap = v; 1203 struct sys_fchmod_args ua; 1204 1205 NETBSD32TO64_UAP(fd); 1206 NETBSD32TO64_UAP(mode); 1207 return (sys_fchmod(p, &ua, retval)); 1208 } 1209 1210 int 1211 netbsd32_setreuid(p, v, retval) 1212 struct proc *p; 1213 void *v; 1214 register_t *retval; 1215 { 1216 struct netbsd32_setreuid_args /* { 1217 syscallarg(uid_t) ruid; 1218 syscallarg(uid_t) euid; 1219 } */ *uap = v; 1220 struct sys_setreuid_args ua; 1221 1222 NETBSD32TO64_UAP(ruid); 1223 NETBSD32TO64_UAP(euid); 1224 return (sys_setreuid(p, &ua, retval)); 1225 } 1226 1227 int 1228 netbsd32_setregid(p, v, retval) 1229 struct proc *p; 1230 void *v; 1231 register_t *retval; 1232 { 1233 struct netbsd32_setregid_args /* { 1234 syscallarg(gid_t) rgid; 1235 syscallarg(gid_t) egid; 1236 } */ *uap = v; 1237 struct sys_setregid_args ua; 1238 1239 NETBSD32TO64_UAP(rgid); 1240 NETBSD32TO64_UAP(egid); 1241 return (sys_setregid(p, &ua, retval)); 1242 } 1243 1244 int 1245 netbsd32_getsockopt(p, v, retval) 1246 struct proc *p; 1247 void *v; 1248 register_t *retval; 1249 { 1250 struct netbsd32_getsockopt_args /* { 1251 syscallarg(int) s; 1252 syscallarg(int) level; 1253 syscallarg(int) name; 1254 syscallarg(netbsd32_voidp) val; 1255 syscallarg(netbsd32_intp) avalsize; 1256 } */ *uap = v; 1257 struct sys_getsockopt_args ua; 1258 1259 NETBSD32TO64_UAP(s); 1260 NETBSD32TO64_UAP(level); 1261 NETBSD32TO64_UAP(name); 1262 NETBSD32TOP_UAP(val, void); 1263 NETBSD32TOP_UAP(avalsize, int); 1264 return (sys_getsockopt(p, &ua, retval)); 1265 } 1266 1267 int 1268 netbsd32_rename(p, v, retval) 1269 struct proc *p; 1270 void *v; 1271 register_t *retval; 1272 { 1273 struct netbsd32_rename_args /* { 1274 syscallarg(const netbsd32_charp) from; 1275 syscallarg(const netbsd32_charp) to; 1276 } */ *uap = v; 1277 struct sys_rename_args ua; 1278 1279 NETBSD32TOP_UAP(from, const char); 1280 NETBSD32TOP_UAP(to, const char) 1281 1282 return (sys_rename(p, &ua, retval)); 1283 } 1284 1285 int 1286 netbsd32_flock(p, v, retval) 1287 struct proc *p; 1288 void *v; 1289 register_t *retval; 1290 { 1291 struct netbsd32_flock_args /* { 1292 syscallarg(int) fd; 1293 syscallarg(int) how; 1294 } */ *uap = v; 1295 struct sys_flock_args ua; 1296 1297 NETBSD32TO64_UAP(fd); 1298 NETBSD32TO64_UAP(how) 1299 1300 return (sys_flock(p, &ua, retval)); 1301 } 1302 1303 int 1304 netbsd32_mkfifo(p, v, retval) 1305 struct proc *p; 1306 void *v; 1307 register_t *retval; 1308 { 1309 struct netbsd32_mkfifo_args /* { 1310 syscallarg(const netbsd32_charp) path; 1311 syscallarg(mode_t) mode; 1312 } */ *uap = v; 1313 struct sys_mkfifo_args ua; 1314 1315 NETBSD32TOP_UAP(path, const char) 1316 NETBSD32TO64_UAP(mode); 1317 return (sys_mkfifo(p, &ua, retval)); 1318 } 1319 1320 int 1321 netbsd32_shutdown(p, v, retval) 1322 struct proc *p; 1323 void *v; 1324 register_t *retval; 1325 { 1326 struct netbsd32_shutdown_args /* { 1327 syscallarg(int) s; 1328 syscallarg(int) how; 1329 } */ *uap = v; 1330 struct sys_shutdown_args ua; 1331 1332 NETBSD32TO64_UAP(s) 1333 NETBSD32TO64_UAP(how); 1334 return (sys_shutdown(p, &ua, retval)); 1335 } 1336 1337 int 1338 netbsd32_socketpair(p, v, retval) 1339 struct proc *p; 1340 void *v; 1341 register_t *retval; 1342 { 1343 struct netbsd32_socketpair_args /* { 1344 syscallarg(int) domain; 1345 syscallarg(int) type; 1346 syscallarg(int) protocol; 1347 syscallarg(netbsd32_intp) rsv; 1348 } */ *uap = v; 1349 struct sys_socketpair_args ua; 1350 1351 NETBSD32TO64_UAP(domain); 1352 NETBSD32TO64_UAP(type); 1353 NETBSD32TO64_UAP(protocol); 1354 NETBSD32TOP_UAP(rsv, int); 1355 /* Since we're just copying out two `int's we can do this */ 1356 return (sys_socketpair(p, &ua, retval)); 1357 } 1358 1359 int 1360 netbsd32_mkdir(p, v, retval) 1361 struct proc *p; 1362 void *v; 1363 register_t *retval; 1364 { 1365 struct netbsd32_mkdir_args /* { 1366 syscallarg(const netbsd32_charp) path; 1367 syscallarg(mode_t) mode; 1368 } */ *uap = v; 1369 struct sys_mkdir_args ua; 1370 1371 NETBSD32TOP_UAP(path, const char) 1372 NETBSD32TO64_UAP(mode); 1373 return (sys_mkdir(p, &ua, retval)); 1374 } 1375 1376 int 1377 netbsd32_rmdir(p, v, retval) 1378 struct proc *p; 1379 void *v; 1380 register_t *retval; 1381 { 1382 struct netbsd32_rmdir_args /* { 1383 syscallarg(const netbsd32_charp) path; 1384 } */ *uap = v; 1385 struct sys_rmdir_args ua; 1386 1387 NETBSD32TOP_UAP(path, const char); 1388 return (sys_rmdir(p, &ua, retval)); 1389 } 1390 1391 int 1392 netbsd32_quotactl(p, v, retval) 1393 struct proc *p; 1394 void *v; 1395 register_t *retval; 1396 { 1397 struct netbsd32_quotactl_args /* { 1398 syscallarg(const netbsd32_charp) path; 1399 syscallarg(int) cmd; 1400 syscallarg(int) uid; 1401 syscallarg(netbsd32_caddr_t) arg; 1402 } */ *uap = v; 1403 struct sys_quotactl_args ua; 1404 1405 NETBSD32TOP_UAP(path, const char); 1406 NETBSD32TO64_UAP(cmd); 1407 NETBSD32TO64_UAP(uid); 1408 NETBSD32TOX64_UAP(arg, caddr_t); 1409 return (sys_quotactl(p, &ua, retval)); 1410 } 1411 1412 #if defined(NFS) || defined(NFSSERVER) 1413 int 1414 netbsd32_nfssvc(p, v, retval) 1415 struct proc *p; 1416 void *v; 1417 register_t *retval; 1418 { 1419 #if 0 1420 struct netbsd32_nfssvc_args /* { 1421 syscallarg(int) flag; 1422 syscallarg(netbsd32_voidp) argp; 1423 } */ *uap = v; 1424 struct sys_nfssvc_args ua; 1425 1426 NETBSD32TO64_UAP(flag); 1427 NETBSD32TOP_UAP(argp, void); 1428 return (sys_nfssvc(p, &ua, retval)); 1429 #else 1430 /* Why would we want to support a 32-bit nfsd? */ 1431 return (ENOSYS); 1432 #endif 1433 } 1434 #endif 1435 1436 #if defined(NFS) || defined(NFSSERVER) 1437 int 1438 netbsd32_getfh(p, v, retval) 1439 struct proc *p; 1440 void *v; 1441 register_t *retval; 1442 { 1443 struct netbsd32_getfh_args /* { 1444 syscallarg(const netbsd32_charp) fname; 1445 syscallarg(netbsd32_fhandlep_t) fhp; 1446 } */ *uap = v; 1447 struct sys_getfh_args ua; 1448 1449 NETBSD32TOP_UAP(fname, const char); 1450 NETBSD32TOP_UAP(fhp, struct fhandle); 1451 /* Lucky for us a fhandlep_t doesn't change sizes */ 1452 return (sys_getfh(p, &ua, retval)); 1453 } 1454 #endif 1455 1456 int 1457 netbsd32_pread(p, v, retval) 1458 struct proc *p; 1459 void *v; 1460 register_t *retval; 1461 { 1462 struct netbsd32_pread_args /* { 1463 syscallarg(int) fd; 1464 syscallarg(netbsd32_voidp) buf; 1465 syscallarg(netbsd32_size_t) nbyte; 1466 syscallarg(int) pad; 1467 syscallarg(off_t) offset; 1468 } */ *uap = v; 1469 struct sys_pread_args ua; 1470 ssize_t rt; 1471 int error; 1472 1473 NETBSD32TO64_UAP(fd); 1474 NETBSD32TOP_UAP(buf, void); 1475 NETBSD32TOX_UAP(nbyte, size_t); 1476 NETBSD32TO64_UAP(pad); 1477 NETBSD32TO64_UAP(offset); 1478 error = sys_pread(p, &ua, (register_t *)&rt); 1479 *retval = rt; 1480 return (error); 1481 } 1482 1483 int 1484 netbsd32_pwrite(p, v, retval) 1485 struct proc *p; 1486 void *v; 1487 register_t *retval; 1488 { 1489 struct netbsd32_pwrite_args /* { 1490 syscallarg(int) fd; 1491 syscallarg(const netbsd32_voidp) buf; 1492 syscallarg(netbsd32_size_t) nbyte; 1493 syscallarg(int) pad; 1494 syscallarg(off_t) offset; 1495 } */ *uap = v; 1496 struct sys_pwrite_args ua; 1497 ssize_t rt; 1498 int error; 1499 1500 NETBSD32TO64_UAP(fd); 1501 NETBSD32TOP_UAP(buf, void); 1502 NETBSD32TOX_UAP(nbyte, size_t); 1503 NETBSD32TO64_UAP(pad); 1504 NETBSD32TO64_UAP(offset); 1505 error = sys_pwrite(p, &ua, (register_t *)&rt); 1506 *retval = rt; 1507 return (error); 1508 } 1509 1510 int 1511 netbsd32_setgid(p, v, retval) 1512 struct proc *p; 1513 void *v; 1514 register_t *retval; 1515 { 1516 struct netbsd32_setgid_args /* { 1517 syscallarg(gid_t) gid; 1518 } */ *uap = v; 1519 struct sys_setgid_args ua; 1520 1521 NETBSD32TO64_UAP(gid); 1522 return (sys_setgid(p, v, retval)); 1523 } 1524 1525 int 1526 netbsd32_setegid(p, v, retval) 1527 struct proc *p; 1528 void *v; 1529 register_t *retval; 1530 { 1531 struct netbsd32_setegid_args /* { 1532 syscallarg(gid_t) egid; 1533 } */ *uap = v; 1534 struct sys_setegid_args ua; 1535 1536 NETBSD32TO64_UAP(egid); 1537 return (sys_setegid(p, v, retval)); 1538 } 1539 1540 int 1541 netbsd32_seteuid(p, v, retval) 1542 struct proc *p; 1543 void *v; 1544 register_t *retval; 1545 { 1546 struct netbsd32_seteuid_args /* { 1547 syscallarg(gid_t) euid; 1548 } */ *uap = v; 1549 struct sys_seteuid_args ua; 1550 1551 NETBSD32TO64_UAP(euid); 1552 return (sys_seteuid(p, v, retval)); 1553 } 1554 1555 #ifdef LFS 1556 int 1557 netbsd32_sys_lfs_bmapv(p, v, retval) 1558 struct proc *p; 1559 void *v; 1560 register_t *retval; 1561 { 1562 1563 return (ENOSYS); /* XXX */ 1564 } 1565 1566 int 1567 netbsd32_sys_lfs_markv(p, v, retval) 1568 struct proc *p; 1569 void *v; 1570 register_t *retval; 1571 { 1572 1573 return (ENOSYS); /* XXX */ 1574 } 1575 1576 int 1577 netbsd32_sys_lfs_segclean(p, v, retval) 1578 struct proc *p; 1579 void *v; 1580 register_t *retval; 1581 { 1582 1583 return (ENOSYS); /* XXX */ 1584 } 1585 1586 int 1587 netbsd32_sys_lfs_segwait(p, v, retval) 1588 struct proc *p; 1589 void *v; 1590 register_t *retval; 1591 { 1592 1593 return (ENOSYS); /* XXX */ 1594 } 1595 #endif 1596 1597 int 1598 netbsd32_pathconf(p, v, retval) 1599 struct proc *p; 1600 void *v; 1601 register_t *retval; 1602 { 1603 struct netbsd32_pathconf_args /* { 1604 syscallarg(int) fd; 1605 syscallarg(int) name; 1606 } */ *uap = v; 1607 struct sys_pathconf_args ua; 1608 long rt; 1609 int error; 1610 1611 NETBSD32TOP_UAP(path, const char); 1612 NETBSD32TO64_UAP(name); 1613 error = sys_pathconf(p, &ua, (register_t *)&rt); 1614 *retval = rt; 1615 return (error); 1616 } 1617 1618 int 1619 netbsd32_fpathconf(p, v, retval) 1620 struct proc *p; 1621 void *v; 1622 register_t *retval; 1623 { 1624 struct netbsd32_fpathconf_args /* { 1625 syscallarg(int) fd; 1626 syscallarg(int) name; 1627 } */ *uap = v; 1628 struct sys_fpathconf_args ua; 1629 long rt; 1630 int error; 1631 1632 NETBSD32TO64_UAP(fd); 1633 NETBSD32TO64_UAP(name); 1634 error = sys_fpathconf(p, &ua, (register_t *)&rt); 1635 *retval = rt; 1636 return (error); 1637 } 1638 1639 int 1640 netbsd32_getrlimit(p, v, retval) 1641 struct proc *p; 1642 void *v; 1643 register_t *retval; 1644 { 1645 struct netbsd32_getrlimit_args /* { 1646 syscallarg(int) which; 1647 syscallarg(netbsd32_rlimitp_t) rlp; 1648 } */ *uap = v; 1649 int which = SCARG(uap, which); 1650 1651 if ((u_int)which >= RLIM_NLIMITS) 1652 return (EINVAL); 1653 return (copyout(&p->p_rlimit[which], (caddr_t)(u_long)SCARG(uap, rlp), 1654 sizeof(struct rlimit))); 1655 } 1656 1657 int 1658 netbsd32_setrlimit(p, v, retval) 1659 struct proc *p; 1660 void *v; 1661 register_t *retval; 1662 { 1663 struct netbsd32_setrlimit_args /* { 1664 syscallarg(int) which; 1665 syscallarg(const netbsd32_rlimitp_t) rlp; 1666 } */ *uap = v; 1667 int which = SCARG(uap, which); 1668 struct rlimit alim; 1669 int error; 1670 1671 error = copyin((caddr_t)(u_long)SCARG(uap, rlp), &alim, sizeof(struct rlimit)); 1672 if (error) 1673 return (error); 1674 return (dosetrlimit(p, p->p_cred, which, &alim)); 1675 } 1676 1677 int 1678 netbsd32_mmap(p, v, retval) 1679 struct proc *p; 1680 void *v; 1681 register_t *retval; 1682 { 1683 struct netbsd32_mmap_args /* { 1684 syscallarg(netbsd32_voidp) addr; 1685 syscallarg(netbsd32_size_t) len; 1686 syscallarg(int) prot; 1687 syscallarg(int) flags; 1688 syscallarg(int) fd; 1689 syscallarg(netbsd32_long) pad; 1690 syscallarg(off_t) pos; 1691 } */ *uap = v; 1692 struct sys_mmap_args ua; 1693 void *rt; 1694 int error; 1695 1696 NETBSD32TOP_UAP(addr, void); 1697 NETBSD32TOX_UAP(len, size_t); 1698 NETBSD32TO64_UAP(prot); 1699 NETBSD32TO64_UAP(flags); 1700 NETBSD32TO64_UAP(fd); 1701 NETBSD32TOX_UAP(pad, long); 1702 NETBSD32TOX_UAP(pos, off_t); 1703 error = sys_mmap(p, &ua, (register_t *)&rt); 1704 if ((u_long)rt > (u_long)UINT_MAX) { 1705 printf("netbsd32_mmap: retval out of range: %p", rt); 1706 /* Should try to recover and return an error here. */ 1707 } 1708 *retval = (netbsd32_voidp)(u_long)rt; 1709 return (error); 1710 } 1711 1712 int 1713 netbsd32_lseek(p, v, retval) 1714 struct proc *p; 1715 void *v; 1716 register_t *retval; 1717 { 1718 struct netbsd32_lseek_args /* { 1719 syscallarg(int) fd; 1720 syscallarg(int) pad; 1721 syscallarg(off_t) offset; 1722 syscallarg(int) whence; 1723 } */ *uap = v; 1724 struct sys_lseek_args ua; 1725 1726 NETBSD32TO64_UAP(fd); 1727 NETBSD32TO64_UAP(pad); 1728 NETBSD32TO64_UAP(offset); 1729 NETBSD32TO64_UAP(whence); 1730 return (sys_lseek(p, &ua, retval)); 1731 } 1732 1733 int 1734 netbsd32_truncate(p, v, retval) 1735 struct proc *p; 1736 void *v; 1737 register_t *retval; 1738 { 1739 struct netbsd32_truncate_args /* { 1740 syscallarg(const netbsd32_charp) path; 1741 syscallarg(int) pad; 1742 syscallarg(off_t) length; 1743 } */ *uap = v; 1744 struct sys_truncate_args ua; 1745 1746 NETBSD32TOP_UAP(path, const char); 1747 NETBSD32TO64_UAP(pad); 1748 NETBSD32TO64_UAP(length); 1749 return (sys_truncate(p, &ua, retval)); 1750 } 1751 1752 int 1753 netbsd32_ftruncate(p, v, retval) 1754 struct proc *p; 1755 void *v; 1756 register_t *retval; 1757 { 1758 struct netbsd32_ftruncate_args /* { 1759 syscallarg(int) fd; 1760 syscallarg(int) pad; 1761 syscallarg(off_t) length; 1762 } */ *uap = v; 1763 struct sys_ftruncate_args ua; 1764 1765 NETBSD32TO64_UAP(fd); 1766 NETBSD32TO64_UAP(pad); 1767 NETBSD32TO64_UAP(length); 1768 return (sys_ftruncate(p, &ua, retval)); 1769 } 1770 1771 int 1772 netbsd32_mlock(p, v, retval) 1773 struct proc *p; 1774 void *v; 1775 register_t *retval; 1776 { 1777 struct netbsd32_mlock_args /* { 1778 syscallarg(const netbsd32_voidp) addr; 1779 syscallarg(netbsd32_size_t) len; 1780 } */ *uap = v; 1781 struct sys_mlock_args ua; 1782 1783 NETBSD32TOP_UAP(addr, const void); 1784 NETBSD32TO64_UAP(len); 1785 return (sys_mlock(p, &ua, retval)); 1786 } 1787 1788 int 1789 netbsd32_munlock(p, v, retval) 1790 struct proc *p; 1791 void *v; 1792 register_t *retval; 1793 { 1794 struct netbsd32_munlock_args /* { 1795 syscallarg(const netbsd32_voidp) addr; 1796 syscallarg(netbsd32_size_t) len; 1797 } */ *uap = v; 1798 struct sys_munlock_args ua; 1799 1800 NETBSD32TOP_UAP(addr, const void); 1801 NETBSD32TO64_UAP(len); 1802 return (sys_munlock(p, &ua, retval)); 1803 } 1804 1805 int 1806 netbsd32_undelete(p, v, retval) 1807 struct proc *p; 1808 void *v; 1809 register_t *retval; 1810 { 1811 struct netbsd32_undelete_args /* { 1812 syscallarg(const netbsd32_charp) path; 1813 } */ *uap = v; 1814 struct sys_undelete_args ua; 1815 1816 NETBSD32TOP_UAP(path, const char); 1817 return (sys_undelete(p, &ua, retval)); 1818 } 1819 1820 int 1821 netbsd32_getpgid(p, v, retval) 1822 struct proc *p; 1823 void *v; 1824 register_t *retval; 1825 { 1826 struct netbsd32_getpgid_args /* { 1827 syscallarg(pid_t) pid; 1828 } */ *uap = v; 1829 struct sys_getpgid_args ua; 1830 1831 NETBSD32TO64_UAP(pid); 1832 return (sys_getpgid(p, &ua, retval)); 1833 } 1834 1835 int 1836 netbsd32_reboot(p, v, retval) 1837 struct proc *p; 1838 void *v; 1839 register_t *retval; 1840 { 1841 struct netbsd32_reboot_args /* { 1842 syscallarg(int) opt; 1843 syscallarg(netbsd32_charp) bootstr; 1844 } */ *uap = v; 1845 struct sys_reboot_args ua; 1846 1847 NETBSD32TO64_UAP(opt); 1848 NETBSD32TOP_UAP(bootstr, char); 1849 return (sys_reboot(p, &ua, retval)); 1850 } 1851 1852 int 1853 netbsd32_poll(p, v, retval) 1854 struct proc *p; 1855 void *v; 1856 register_t *retval; 1857 { 1858 struct netbsd32_poll_args /* { 1859 syscallarg(netbsd32_pollfdp_t) fds; 1860 syscallarg(u_int) nfds; 1861 syscallarg(int) timeout; 1862 } */ *uap = v; 1863 struct sys_poll_args ua; 1864 1865 NETBSD32TOP_UAP(fds, struct pollfd); 1866 NETBSD32TO64_UAP(nfds); 1867 NETBSD32TO64_UAP(timeout); 1868 return (sys_poll(p, &ua, retval)); 1869 } 1870 1871 int 1872 netbsd32_fdatasync(p, v, retval) 1873 struct proc *p; 1874 void *v; 1875 register_t *retval; 1876 { 1877 struct netbsd32_fdatasync_args /* { 1878 syscallarg(int) fd; 1879 } */ *uap = v; 1880 struct sys_fdatasync_args ua; 1881 1882 NETBSD32TO64_UAP(fd); 1883 return (sys_fdatasync(p, &ua, retval)); 1884 } 1885 1886 int 1887 netbsd32___posix_rename(p, v, retval) 1888 struct proc *p; 1889 void *v; 1890 register_t *retval; 1891 { 1892 struct netbsd32___posix_rename_args /* { 1893 syscallarg(const netbsd32_charp) from; 1894 syscallarg(const netbsd32_charp) to; 1895 } */ *uap = v; 1896 struct sys___posix_rename_args ua; 1897 1898 NETBSD32TOP_UAP(from, const char); 1899 NETBSD32TOP_UAP(to, const char); 1900 return (sys___posix_rename(p, &ua, retval)); 1901 } 1902 1903 int 1904 netbsd32_swapctl(p, v, retval) 1905 struct proc *p; 1906 void *v; 1907 register_t *retval; 1908 { 1909 struct netbsd32_swapctl_args /* { 1910 syscallarg(int) cmd; 1911 syscallarg(const netbsd32_voidp) arg; 1912 syscallarg(int) misc; 1913 } */ *uap = v; 1914 struct sys_swapctl_args ua; 1915 1916 NETBSD32TO64_UAP(cmd); 1917 NETBSD32TOP_UAP(arg, const void); 1918 NETBSD32TO64_UAP(misc); 1919 return (sys_swapctl(p, &ua, retval)); 1920 } 1921 1922 int 1923 netbsd32_minherit(p, v, retval) 1924 struct proc *p; 1925 void *v; 1926 register_t *retval; 1927 { 1928 struct netbsd32_minherit_args /* { 1929 syscallarg(netbsd32_voidp) addr; 1930 syscallarg(netbsd32_size_t) len; 1931 syscallarg(int) inherit; 1932 } */ *uap = v; 1933 struct sys_minherit_args ua; 1934 1935 NETBSD32TOP_UAP(addr, void); 1936 NETBSD32TOX_UAP(len, size_t); 1937 NETBSD32TO64_UAP(inherit); 1938 return (sys_minherit(p, &ua, retval)); 1939 } 1940 1941 int 1942 netbsd32_lchmod(p, v, retval) 1943 struct proc *p; 1944 void *v; 1945 register_t *retval; 1946 { 1947 struct netbsd32_lchmod_args /* { 1948 syscallarg(const netbsd32_charp) path; 1949 syscallarg(mode_t) mode; 1950 } */ *uap = v; 1951 struct sys_lchmod_args ua; 1952 1953 NETBSD32TOP_UAP(path, const char); 1954 NETBSD32TO64_UAP(mode); 1955 return (sys_lchmod(p, &ua, retval)); 1956 } 1957 1958 int 1959 netbsd32_lchown(p, v, retval) 1960 struct proc *p; 1961 void *v; 1962 register_t *retval; 1963 { 1964 struct netbsd32_lchown_args /* { 1965 syscallarg(const netbsd32_charp) path; 1966 syscallarg(uid_t) uid; 1967 syscallarg(gid_t) gid; 1968 } */ *uap = v; 1969 struct sys_lchown_args ua; 1970 1971 NETBSD32TOP_UAP(path, const char); 1972 NETBSD32TO64_UAP(uid); 1973 NETBSD32TO64_UAP(gid); 1974 return (sys_lchown(p, &ua, retval)); 1975 } 1976 1977 int 1978 netbsd32___msync13(p, v, retval) 1979 struct proc *p; 1980 void *v; 1981 register_t *retval; 1982 { 1983 struct netbsd32___msync13_args /* { 1984 syscallarg(netbsd32_voidp) addr; 1985 syscallarg(netbsd32_size_t) len; 1986 syscallarg(int) flags; 1987 } */ *uap = v; 1988 struct sys___msync13_args ua; 1989 1990 NETBSD32TOP_UAP(addr, void); 1991 NETBSD32TOX_UAP(len, size_t); 1992 NETBSD32TO64_UAP(flags); 1993 return (sys___msync13(p, &ua, retval)); 1994 } 1995 1996 int 1997 netbsd32___posix_chown(p, v, retval) 1998 struct proc *p; 1999 void *v; 2000 register_t *retval; 2001 { 2002 struct netbsd32___posix_chown_args /* { 2003 syscallarg(const netbsd32_charp) path; 2004 syscallarg(uid_t) uid; 2005 syscallarg(gid_t) gid; 2006 } */ *uap = v; 2007 struct sys___posix_chown_args ua; 2008 2009 NETBSD32TOP_UAP(path, const char); 2010 NETBSD32TO64_UAP(uid); 2011 NETBSD32TO64_UAP(gid); 2012 return (sys___posix_chown(p, &ua, retval)); 2013 } 2014 2015 int 2016 netbsd32___posix_fchown(p, v, retval) 2017 struct proc *p; 2018 void *v; 2019 register_t *retval; 2020 { 2021 struct netbsd32___posix_fchown_args /* { 2022 syscallarg(int) fd; 2023 syscallarg(uid_t) uid; 2024 syscallarg(gid_t) gid; 2025 } */ *uap = v; 2026 struct sys___posix_fchown_args ua; 2027 2028 NETBSD32TO64_UAP(fd); 2029 NETBSD32TO64_UAP(uid); 2030 NETBSD32TO64_UAP(gid); 2031 return (sys___posix_fchown(p, &ua, retval)); 2032 } 2033 2034 int 2035 netbsd32___posix_lchown(p, v, retval) 2036 struct proc *p; 2037 void *v; 2038 register_t *retval; 2039 { 2040 struct netbsd32___posix_lchown_args /* { 2041 syscallarg(const netbsd32_charp) path; 2042 syscallarg(uid_t) uid; 2043 syscallarg(gid_t) gid; 2044 } */ *uap = v; 2045 struct sys___posix_lchown_args ua; 2046 2047 NETBSD32TOP_UAP(path, const char); 2048 NETBSD32TO64_UAP(uid); 2049 NETBSD32TO64_UAP(gid); 2050 return (sys___posix_lchown(p, &ua, retval)); 2051 } 2052 2053 int 2054 netbsd32_getsid(p, v, retval) 2055 struct proc *p; 2056 void *v; 2057 register_t *retval; 2058 { 2059 struct netbsd32_getsid_args /* { 2060 syscallarg(pid_t) pid; 2061 } */ *uap = v; 2062 struct sys_getsid_args ua; 2063 2064 NETBSD32TO64_UAP(pid); 2065 return (sys_getsid(p, &ua, retval)); 2066 } 2067 2068 #ifdef KTRACE 2069 int 2070 netbsd32_fktrace(p, v, retval) 2071 struct proc *p; 2072 void *v; 2073 register_t *retval; 2074 { 2075 struct netbsd32_fktrace_args /* { 2076 syscallarg(const int) fd; 2077 syscallarg(int) ops; 2078 syscallarg(int) facs; 2079 syscallarg(int) pid; 2080 } */ *uap = v; 2081 #if 0 2082 struct sys_fktrace_args ua; 2083 #else 2084 /* XXXX */ 2085 struct sys_fktrace_noconst_args { 2086 syscallarg(int) fd; 2087 syscallarg(int) ops; 2088 syscallarg(int) facs; 2089 syscallarg(int) pid; 2090 } ua; 2091 #endif 2092 2093 NETBSD32TOX_UAP(fd, int); 2094 NETBSD32TO64_UAP(ops); 2095 NETBSD32TO64_UAP(facs); 2096 NETBSD32TO64_UAP(pid); 2097 return (sys_fktrace(p, &ua, retval)); 2098 } 2099 #endif /* KTRACE */ 2100 2101 int netbsd32___sigpending14(p, v, retval) 2102 struct proc *p; 2103 void *v; 2104 register_t *retval; 2105 { 2106 struct netbsd32___sigpending14_args /* { 2107 syscallarg(sigset_t *) set; 2108 } */ *uap = v; 2109 struct sys___sigpending14_args ua; 2110 2111 NETBSD32TOP_UAP(set, sigset_t); 2112 return (sys___sigpending14(p, &ua, retval)); 2113 } 2114 2115 int netbsd32___sigprocmask14(p, v, retval) 2116 struct proc *p; 2117 void *v; 2118 register_t *retval; 2119 { 2120 struct netbsd32___sigprocmask14_args /* { 2121 syscallarg(int) how; 2122 syscallarg(const sigset_t *) set; 2123 syscallarg(sigset_t *) oset; 2124 } */ *uap = v; 2125 struct sys___sigprocmask14_args ua; 2126 2127 NETBSD32TO64_UAP(how); 2128 NETBSD32TOP_UAP(set, sigset_t); 2129 NETBSD32TOP_UAP(oset, sigset_t); 2130 return (sys___sigprocmask14(p, &ua, retval)); 2131 } 2132 2133 int netbsd32___sigsuspend14(p, v, retval) 2134 struct proc *p; 2135 void *v; 2136 register_t *retval; 2137 { 2138 struct netbsd32___sigsuspend14_args /* { 2139 syscallarg(const sigset_t *) set; 2140 } */ *uap = v; 2141 struct sys___sigsuspend14_args ua; 2142 2143 NETBSD32TOP_UAP(set, sigset_t); 2144 return (sys___sigsuspend14(p, &ua, retval)); 2145 }; 2146 2147 int netbsd32_fchroot(p, v, retval) 2148 struct proc *p; 2149 void *v; 2150 register_t *retval; 2151 { 2152 struct netbsd32_fchroot_args /* { 2153 syscallarg(int) fd; 2154 } */ *uap = v; 2155 struct sys_fchroot_args ua; 2156 2157 NETBSD32TO64_UAP(fd); 2158 return (sys_fchroot(p, &ua, retval)); 2159 } 2160 2161 /* 2162 * Open a file given a file handle. 2163 * 2164 * Check permissions, allocate an open file structure, 2165 * and call the device open routine if any. 2166 */ 2167 int 2168 netbsd32_fhopen(p, v, retval) 2169 struct proc *p; 2170 void *v; 2171 register_t *retval; 2172 { 2173 struct netbsd32_fhopen_args /* { 2174 syscallarg(const fhandle_t *) fhp; 2175 syscallarg(int) flags; 2176 } */ *uap = v; 2177 struct sys_fhopen_args ua; 2178 2179 NETBSD32TOP_UAP(fhp, fhandle_t); 2180 NETBSD32TO64_UAP(flags); 2181 return (sys_fhopen(p, &ua, retval)); 2182 } 2183 2184 int netbsd32_fhstat(p, v, retval) 2185 struct proc *p; 2186 void *v; 2187 register_t *retval; 2188 { 2189 struct netbsd32_fhstat_args /* { 2190 syscallarg(const netbsd32_fhandlep_t) fhp; 2191 syscallarg(struct stat *) sb; 2192 } */ *uap = v; 2193 struct sys_fhstat_args ua; 2194 2195 NETBSD32TOP_UAP(fhp, const fhandle_t); 2196 NETBSD32TOP_UAP(sb, struct stat); 2197 return (sys_fhstat(p, &ua, retval)); 2198 } 2199 2200 int netbsd32_fhstatfs(p, v, retval) 2201 struct proc *p; 2202 void *v; 2203 register_t *retval; 2204 { 2205 struct netbsd32_fhstatfs_args /* { 2206 syscallarg(const netbsd32_fhandlep_t) fhp; 2207 syscallarg(struct statfs *) buf; 2208 } */ *uap = v; 2209 struct sys_fhstatfs_args ua; 2210 2211 NETBSD32TOP_UAP(fhp, const fhandle_t); 2212 NETBSD32TOP_UAP(buf, struct statfs); 2213 return (sys_fhstatfs(p, &ua, retval)); 2214 } 2215 2216 /* virtual memory syscalls */ 2217 int 2218 netbsd32_ovadvise(p, v, retval) 2219 struct proc *p; 2220 void *v; 2221 register_t *retval; 2222 { 2223 struct netbsd32_ovadvise_args /* { 2224 syscallarg(int) anom; 2225 } */ *uap = v; 2226 struct sys_ovadvise_args ua; 2227 2228 NETBSD32TO64_UAP(anom); 2229 return (sys_ovadvise(p, &ua, retval)); 2230 } 2231 2232
Indexes created Sun Sep 21 16:09:51 GMT 2025