rump_syscalls.c revision 1.94
1 /* $NetBSD: rump_syscalls.c,v 1.94 2013/12/09 17:15:11 pooka Exp $ */ 2 3 /* 4 * System call vector and marshalling for rump. 5 * 6 * DO NOT EDIT-- this file is automatically generated. 7 * created from NetBSD: syscalls.master,v 1.265 2013/12/09 17:13:17 pooka Exp 8 */ 9 10 #ifdef RUMP_CLIENT 11 #include <rump/rumpuser_port.h> 12 #endif /* RUMP_CLIENT */ 13 14 #include <sys/param.h> 15 16 #ifdef __NetBSD__ 17 #include <sys/cdefs.h> 18 __KERNEL_RCSID(0, "$NetBSD: rump_syscalls.c,v 1.94 2013/12/09 17:15:11 pooka Exp $"); 19 20 #include <sys/fstypes.h> 21 #include <sys/proc.h> 22 #endif /* __NetBSD__ */ 23 24 #ifdef RUMP_CLIENT 25 #include <errno.h> 26 #include <stdint.h> 27 #include <stdlib.h> 28 29 #include <srcsys/syscall.h> 30 #include <srcsys/syscallargs.h> 31 32 #include <rump/rumpclient.h> 33 34 #define rsys_syscall(num, data, dlen, retval) \ 35 rumpclient_syscall(num, data, dlen, retval) 36 #define rsys_seterrno(error) errno = error 37 #define rsys_define(nam) 38 #else 39 #include <sys/syscall.h> 40 #include <sys/syscallargs.h> 41 42 #include <sys/syscallvar.h> 43 44 #include <rump/rumpuser.h> 45 #include "rump_private.h" 46 47 #define rsys_syscall(num, data, dlen, retval) \ 48 rump_syscall(num, data, dlen, retval) 49 50 #define rsys_seterrno(error) rumpuser_seterrno(error) 51 #define rsys_define(nam) \ 52 int nam(struct lwp *, const void *, register_t *); \ 53 __weak_alias(nam,rump_enosys); 54 #endif 55 56 #ifdef RUMP_KERNEL_IS_LIBC 57 #define rsys_aliases(what,where) \ 58 __strong_alias(what,where); \ 59 __strong_alias(_##what,where); 60 #else 61 #define rsys_aliases(a,b) 62 #endif 63 64 #if BYTE_ORDER == BIG_ENDIAN 65 #define SPARG(p,k) ((p)->k.be.datum) 66 #else /* LITTLE_ENDIAN, I hope dearly */ 67 #define SPARG(p,k) ((p)->k.le.datum) 68 #endif 69 70 #ifndef RUMP_CLIENT 71 int rump_enosys(void); 72 int 73 rump_enosys() 74 { 75 76 return ENOSYS; 77 } 78 #endif 79 80 void rumpns_sys_nomodule(void); 81 82 ssize_t rump___sysimpl_read(int, void *, size_t); 83 ssize_t 84 rump___sysimpl_read(int fd, void * buf, size_t nbyte) 85 { 86 register_t retval[2]; 87 int error = 0; 88 ssize_t rv = -1; 89 struct sys_read_args callarg; 90 91 SPARG(&callarg, fd) = fd; 92 SPARG(&callarg, buf) = buf; 93 SPARG(&callarg, nbyte) = nbyte; 94 95 error = rsys_syscall(SYS_read, &callarg, sizeof(callarg), retval); 96 rsys_seterrno(error); 97 if (error == 0) { 98 if (sizeof(ssize_t) > sizeof(register_t)) 99 rv = *(ssize_t *)retval; 100 else 101 rv = *retval; 102 } 103 return rv; 104 } 105 rsys_define(rumpns_sys_read); 106 rsys_aliases(read,rump___sysimpl_read); 107 108 ssize_t rump___sysimpl_write(int, const void *, size_t); 109 ssize_t 110 rump___sysimpl_write(int fd, const void * buf, size_t nbyte) 111 { 112 register_t retval[2]; 113 int error = 0; 114 ssize_t rv = -1; 115 struct sys_write_args callarg; 116 117 SPARG(&callarg, fd) = fd; 118 SPARG(&callarg, buf) = buf; 119 SPARG(&callarg, nbyte) = nbyte; 120 121 error = rsys_syscall(SYS_write, &callarg, sizeof(callarg), retval); 122 rsys_seterrno(error); 123 if (error == 0) { 124 if (sizeof(ssize_t) > sizeof(register_t)) 125 rv = *(ssize_t *)retval; 126 else 127 rv = *retval; 128 } 129 return rv; 130 } 131 rsys_define(rumpns_sys_write); 132 rsys_aliases(write,rump___sysimpl_write); 133 134 int rump___sysimpl_open(const char *, int, mode_t); 135 int 136 rump___sysimpl_open(const char * path, int flags, mode_t mode) 137 { 138 register_t retval[2]; 139 int error = 0; 140 int rv = -1; 141 struct sys_open_args callarg; 142 143 SPARG(&callarg, path) = path; 144 SPARG(&callarg, flags) = flags; 145 SPARG(&callarg, mode) = mode; 146 147 error = rsys_syscall(SYS_open, &callarg, sizeof(callarg), retval); 148 rsys_seterrno(error); 149 if (error == 0) { 150 if (sizeof(int) > sizeof(register_t)) 151 rv = *(int *)retval; 152 else 153 rv = *retval; 154 } 155 return rv; 156 } 157 rsys_define(rumpns_sys_open); 158 rsys_aliases(open,rump___sysimpl_open); 159 160 int rump___sysimpl_close(int); 161 int 162 rump___sysimpl_close(int fd) 163 { 164 register_t retval[2]; 165 int error = 0; 166 int rv = -1; 167 struct sys_close_args callarg; 168 169 SPARG(&callarg, fd) = fd; 170 171 error = rsys_syscall(SYS_close, &callarg, sizeof(callarg), retval); 172 rsys_seterrno(error); 173 if (error == 0) { 174 if (sizeof(int) > sizeof(register_t)) 175 rv = *(int *)retval; 176 else 177 rv = *retval; 178 } 179 return rv; 180 } 181 rsys_define(rumpns_sys_close); 182 rsys_aliases(close,rump___sysimpl_close); 183 184 int rump___sysimpl_link(const char *, const char *); 185 int 186 rump___sysimpl_link(const char * path, const char * link) 187 { 188 register_t retval[2]; 189 int error = 0; 190 int rv = -1; 191 struct sys_link_args callarg; 192 193 SPARG(&callarg, path) = path; 194 SPARG(&callarg, link) = link; 195 196 error = rsys_syscall(SYS_link, &callarg, sizeof(callarg), retval); 197 rsys_seterrno(error); 198 if (error == 0) { 199 if (sizeof(int) > sizeof(register_t)) 200 rv = *(int *)retval; 201 else 202 rv = *retval; 203 } 204 return rv; 205 } 206 rsys_define(rumpns_sys_link); 207 rsys_aliases(link,rump___sysimpl_link); 208 209 int rump___sysimpl_unlink(const char *); 210 int 211 rump___sysimpl_unlink(const char * path) 212 { 213 register_t retval[2]; 214 int error = 0; 215 int rv = -1; 216 struct sys_unlink_args callarg; 217 218 SPARG(&callarg, path) = path; 219 220 error = rsys_syscall(SYS_unlink, &callarg, sizeof(callarg), retval); 221 rsys_seterrno(error); 222 if (error == 0) { 223 if (sizeof(int) > sizeof(register_t)) 224 rv = *(int *)retval; 225 else 226 rv = *retval; 227 } 228 return rv; 229 } 230 rsys_define(rumpns_sys_unlink); 231 rsys_aliases(unlink,rump___sysimpl_unlink); 232 233 int rump___sysimpl_chdir(const char *); 234 int 235 rump___sysimpl_chdir(const char * path) 236 { 237 register_t retval[2]; 238 int error = 0; 239 int rv = -1; 240 struct sys_chdir_args callarg; 241 242 SPARG(&callarg, path) = path; 243 244 error = rsys_syscall(SYS_chdir, &callarg, sizeof(callarg), retval); 245 rsys_seterrno(error); 246 if (error == 0) { 247 if (sizeof(int) > sizeof(register_t)) 248 rv = *(int *)retval; 249 else 250 rv = *retval; 251 } 252 return rv; 253 } 254 rsys_define(rumpns_sys_chdir); 255 rsys_aliases(chdir,rump___sysimpl_chdir); 256 257 int rump___sysimpl_fchdir(int); 258 int 259 rump___sysimpl_fchdir(int fd) 260 { 261 register_t retval[2]; 262 int error = 0; 263 int rv = -1; 264 struct sys_fchdir_args callarg; 265 266 SPARG(&callarg, fd) = fd; 267 268 error = rsys_syscall(SYS_fchdir, &callarg, sizeof(callarg), retval); 269 rsys_seterrno(error); 270 if (error == 0) { 271 if (sizeof(int) > sizeof(register_t)) 272 rv = *(int *)retval; 273 else 274 rv = *retval; 275 } 276 return rv; 277 } 278 rsys_define(rumpns_sys_fchdir); 279 rsys_aliases(fchdir,rump___sysimpl_fchdir); 280 281 int rump___sysimpl_mknod(const char *, mode_t, uint32_t); 282 int 283 rump___sysimpl_mknod(const char * path, mode_t mode, uint32_t dev) 284 { 285 register_t retval[2]; 286 int error = 0; 287 int rv = -1; 288 struct compat_50_sys_mknod_args callarg; 289 290 SPARG(&callarg, path) = path; 291 SPARG(&callarg, mode) = mode; 292 SPARG(&callarg, dev) = dev; 293 294 error = rsys_syscall(SYS_compat_50_mknod, &callarg, sizeof(callarg), retval); 295 rsys_seterrno(error); 296 if (error == 0) { 297 if (sizeof(int) > sizeof(register_t)) 298 rv = *(int *)retval; 299 else 300 rv = *retval; 301 } 302 return rv; 303 } 304 rsys_define(rumpns_compat_50_sys_mknod); 305 rsys_aliases(compat_50_mknod,rump___sysimpl_mknod); 306 307 int rump___sysimpl_chmod(const char *, mode_t); 308 int 309 rump___sysimpl_chmod(const char * path, mode_t mode) 310 { 311 register_t retval[2]; 312 int error = 0; 313 int rv = -1; 314 struct sys_chmod_args callarg; 315 316 SPARG(&callarg, path) = path; 317 SPARG(&callarg, mode) = mode; 318 319 error = rsys_syscall(SYS_chmod, &callarg, sizeof(callarg), retval); 320 rsys_seterrno(error); 321 if (error == 0) { 322 if (sizeof(int) > sizeof(register_t)) 323 rv = *(int *)retval; 324 else 325 rv = *retval; 326 } 327 return rv; 328 } 329 rsys_define(rumpns_sys_chmod); 330 rsys_aliases(chmod,rump___sysimpl_chmod); 331 332 int rump___sysimpl_chown(const char *, uid_t, gid_t); 333 int 334 rump___sysimpl_chown(const char * path, uid_t uid, gid_t gid) 335 { 336 register_t retval[2]; 337 int error = 0; 338 int rv = -1; 339 struct sys_chown_args callarg; 340 341 SPARG(&callarg, path) = path; 342 SPARG(&callarg, uid) = uid; 343 SPARG(&callarg, gid) = gid; 344 345 error = rsys_syscall(SYS_chown, &callarg, sizeof(callarg), retval); 346 rsys_seterrno(error); 347 if (error == 0) { 348 if (sizeof(int) > sizeof(register_t)) 349 rv = *(int *)retval; 350 else 351 rv = *retval; 352 } 353 return rv; 354 } 355 rsys_define(rumpns_sys_chown); 356 rsys_aliases(chown,rump___sysimpl_chown); 357 358 pid_t rump___sysimpl_getpid(void); 359 pid_t 360 rump___sysimpl_getpid(void ) 361 { 362 register_t retval[2]; 363 pid_t rv = -1; 364 365 rsys_syscall(SYS_getpid, NULL, 0, retval); 366 if (sizeof(pid_t) > sizeof(register_t)) 367 rv = *(pid_t *)retval; 368 else 369 rv = *retval; 370 return rv; 371 } 372 rsys_define(rumpns_sys_getpid_with_ppid); 373 rsys_aliases(getpid,rump___sysimpl_getpid); 374 375 int rump___sysimpl_unmount(const char *, int); 376 int 377 rump___sysimpl_unmount(const char * path, int flags) 378 { 379 register_t retval[2]; 380 int error = 0; 381 int rv = -1; 382 struct sys_unmount_args callarg; 383 384 SPARG(&callarg, path) = path; 385 SPARG(&callarg, flags) = flags; 386 387 error = rsys_syscall(SYS_unmount, &callarg, sizeof(callarg), retval); 388 rsys_seterrno(error); 389 if (error == 0) { 390 if (sizeof(int) > sizeof(register_t)) 391 rv = *(int *)retval; 392 else 393 rv = *retval; 394 } 395 return rv; 396 } 397 rsys_define(rumpns_sys_unmount); 398 rsys_aliases(unmount,rump___sysimpl_unmount); 399 400 int rump___sysimpl_setuid(uid_t); 401 int 402 rump___sysimpl_setuid(uid_t uid) 403 { 404 register_t retval[2]; 405 int error = 0; 406 int rv = -1; 407 struct sys_setuid_args callarg; 408 409 SPARG(&callarg, uid) = uid; 410 411 error = rsys_syscall(SYS_setuid, &callarg, sizeof(callarg), retval); 412 rsys_seterrno(error); 413 if (error == 0) { 414 if (sizeof(int) > sizeof(register_t)) 415 rv = *(int *)retval; 416 else 417 rv = *retval; 418 } 419 return rv; 420 } 421 rsys_define(rumpns_sys_setuid); 422 rsys_aliases(setuid,rump___sysimpl_setuid); 423 424 uid_t rump___sysimpl_getuid(void); 425 uid_t 426 rump___sysimpl_getuid(void ) 427 { 428 register_t retval[2]; 429 uid_t rv = -1; 430 431 rsys_syscall(SYS_getuid, NULL, 0, retval); 432 if (sizeof(uid_t) > sizeof(register_t)) 433 rv = *(uid_t *)retval; 434 else 435 rv = *retval; 436 return rv; 437 } 438 rsys_define(rumpns_sys_getuid_with_euid); 439 rsys_aliases(getuid,rump___sysimpl_getuid); 440 441 uid_t rump___sysimpl_geteuid(void); 442 uid_t 443 rump___sysimpl_geteuid(void ) 444 { 445 register_t retval[2]; 446 uid_t rv = -1; 447 448 rsys_syscall(SYS_geteuid, NULL, 0, retval); 449 if (sizeof(uid_t) > sizeof(register_t)) 450 rv = *(uid_t *)retval; 451 else 452 rv = *retval; 453 return rv; 454 } 455 rsys_define(rumpns_sys_geteuid); 456 rsys_aliases(geteuid,rump___sysimpl_geteuid); 457 458 ssize_t rump___sysimpl_recvmsg(int, struct msghdr *, int); 459 ssize_t 460 rump___sysimpl_recvmsg(int s, struct msghdr * msg, int flags) 461 { 462 register_t retval[2]; 463 int error = 0; 464 ssize_t rv = -1; 465 struct sys_recvmsg_args callarg; 466 467 SPARG(&callarg, s) = s; 468 SPARG(&callarg, msg) = msg; 469 SPARG(&callarg, flags) = flags; 470 471 error = rsys_syscall(SYS_recvmsg, &callarg, sizeof(callarg), retval); 472 rsys_seterrno(error); 473 if (error == 0) { 474 if (sizeof(ssize_t) > sizeof(register_t)) 475 rv = *(ssize_t *)retval; 476 else 477 rv = *retval; 478 } 479 return rv; 480 } 481 rsys_define(rumpns_sys_recvmsg); 482 rsys_aliases(recvmsg,rump___sysimpl_recvmsg); 483 484 ssize_t rump___sysimpl_sendmsg(int, const struct msghdr *, int); 485 ssize_t 486 rump___sysimpl_sendmsg(int s, const struct msghdr * msg, int flags) 487 { 488 register_t retval[2]; 489 int error = 0; 490 ssize_t rv = -1; 491 struct sys_sendmsg_args callarg; 492 493 SPARG(&callarg, s) = s; 494 SPARG(&callarg, msg) = msg; 495 SPARG(&callarg, flags) = flags; 496 497 error = rsys_syscall(SYS_sendmsg, &callarg, sizeof(callarg), retval); 498 rsys_seterrno(error); 499 if (error == 0) { 500 if (sizeof(ssize_t) > sizeof(register_t)) 501 rv = *(ssize_t *)retval; 502 else 503 rv = *retval; 504 } 505 return rv; 506 } 507 rsys_define(rumpns_sys_sendmsg); 508 rsys_aliases(sendmsg,rump___sysimpl_sendmsg); 509 510 ssize_t rump___sysimpl_recvfrom(int, void *, size_t, int, struct sockaddr *, socklen_t *); 511 ssize_t 512 rump___sysimpl_recvfrom(int s, void * buf, size_t len, int flags, struct sockaddr * from, socklen_t * fromlenaddr) 513 { 514 register_t retval[2]; 515 int error = 0; 516 ssize_t rv = -1; 517 struct sys_recvfrom_args callarg; 518 519 SPARG(&callarg, s) = s; 520 SPARG(&callarg, buf) = buf; 521 SPARG(&callarg, len) = len; 522 SPARG(&callarg, flags) = flags; 523 SPARG(&callarg, from) = from; 524 SPARG(&callarg, fromlenaddr) = fromlenaddr; 525 526 error = rsys_syscall(SYS_recvfrom, &callarg, sizeof(callarg), retval); 527 rsys_seterrno(error); 528 if (error == 0) { 529 if (sizeof(ssize_t) > sizeof(register_t)) 530 rv = *(ssize_t *)retval; 531 else 532 rv = *retval; 533 } 534 return rv; 535 } 536 rsys_define(rumpns_sys_recvfrom); 537 rsys_aliases(recvfrom,rump___sysimpl_recvfrom); 538 539 int rump___sysimpl_accept(int, struct sockaddr *, socklen_t *); 540 int 541 rump___sysimpl_accept(int s, struct sockaddr * name, socklen_t * anamelen) 542 { 543 register_t retval[2]; 544 int error = 0; 545 int rv = -1; 546 struct sys_accept_args callarg; 547 548 SPARG(&callarg, s) = s; 549 SPARG(&callarg, name) = name; 550 SPARG(&callarg, anamelen) = anamelen; 551 552 error = rsys_syscall(SYS_accept, &callarg, sizeof(callarg), retval); 553 rsys_seterrno(error); 554 if (error == 0) { 555 if (sizeof(int) > sizeof(register_t)) 556 rv = *(int *)retval; 557 else 558 rv = *retval; 559 } 560 return rv; 561 } 562 rsys_define(rumpns_sys_accept); 563 rsys_aliases(accept,rump___sysimpl_accept); 564 565 int rump___sysimpl_getpeername(int, struct sockaddr *, socklen_t *); 566 int 567 rump___sysimpl_getpeername(int fdes, struct sockaddr * asa, socklen_t * alen) 568 { 569 register_t retval[2]; 570 int error = 0; 571 int rv = -1; 572 struct sys_getpeername_args callarg; 573 574 SPARG(&callarg, fdes) = fdes; 575 SPARG(&callarg, asa) = asa; 576 SPARG(&callarg, alen) = alen; 577 578 error = rsys_syscall(SYS_getpeername, &callarg, sizeof(callarg), retval); 579 rsys_seterrno(error); 580 if (error == 0) { 581 if (sizeof(int) > sizeof(register_t)) 582 rv = *(int *)retval; 583 else 584 rv = *retval; 585 } 586 return rv; 587 } 588 rsys_define(rumpns_sys_getpeername); 589 rsys_aliases(getpeername,rump___sysimpl_getpeername); 590 591 int rump___sysimpl_getsockname(int, struct sockaddr *, socklen_t *); 592 int 593 rump___sysimpl_getsockname(int fdes, struct sockaddr * asa, socklen_t * alen) 594 { 595 register_t retval[2]; 596 int error = 0; 597 int rv = -1; 598 struct sys_getsockname_args callarg; 599 600 SPARG(&callarg, fdes) = fdes; 601 SPARG(&callarg, asa) = asa; 602 SPARG(&callarg, alen) = alen; 603 604 error = rsys_syscall(SYS_getsockname, &callarg, sizeof(callarg), retval); 605 rsys_seterrno(error); 606 if (error == 0) { 607 if (sizeof(int) > sizeof(register_t)) 608 rv = *(int *)retval; 609 else 610 rv = *retval; 611 } 612 return rv; 613 } 614 rsys_define(rumpns_sys_getsockname); 615 rsys_aliases(getsockname,rump___sysimpl_getsockname); 616 617 int rump___sysimpl_access(const char *, int); 618 int 619 rump___sysimpl_access(const char * path, int flags) 620 { 621 register_t retval[2]; 622 int error = 0; 623 int rv = -1; 624 struct sys_access_args callarg; 625 626 SPARG(&callarg, path) = path; 627 SPARG(&callarg, flags) = flags; 628 629 error = rsys_syscall(SYS_access, &callarg, sizeof(callarg), retval); 630 rsys_seterrno(error); 631 if (error == 0) { 632 if (sizeof(int) > sizeof(register_t)) 633 rv = *(int *)retval; 634 else 635 rv = *retval; 636 } 637 return rv; 638 } 639 rsys_define(rumpns_sys_access); 640 rsys_aliases(access,rump___sysimpl_access); 641 642 int rump___sysimpl_chflags(const char *, u_long); 643 int 644 rump___sysimpl_chflags(const char * path, u_long flags) 645 { 646 register_t retval[2]; 647 int error = 0; 648 int rv = -1; 649 struct sys_chflags_args callarg; 650 651 SPARG(&callarg, path) = path; 652 SPARG(&callarg, flags) = flags; 653 654 error = rsys_syscall(SYS_chflags, &callarg, sizeof(callarg), retval); 655 rsys_seterrno(error); 656 if (error == 0) { 657 if (sizeof(int) > sizeof(register_t)) 658 rv = *(int *)retval; 659 else 660 rv = *retval; 661 } 662 return rv; 663 } 664 rsys_define(rumpns_sys_chflags); 665 rsys_aliases(chflags,rump___sysimpl_chflags); 666 667 int rump___sysimpl_fchflags(int, u_long); 668 int 669 rump___sysimpl_fchflags(int fd, u_long flags) 670 { 671 register_t retval[2]; 672 int error = 0; 673 int rv = -1; 674 struct sys_fchflags_args callarg; 675 676 SPARG(&callarg, fd) = fd; 677 SPARG(&callarg, flags) = flags; 678 679 error = rsys_syscall(SYS_fchflags, &callarg, sizeof(callarg), retval); 680 rsys_seterrno(error); 681 if (error == 0) { 682 if (sizeof(int) > sizeof(register_t)) 683 rv = *(int *)retval; 684 else 685 rv = *retval; 686 } 687 return rv; 688 } 689 rsys_define(rumpns_sys_fchflags); 690 rsys_aliases(fchflags,rump___sysimpl_fchflags); 691 692 void rump___sysimpl_sync(void); 693 void 694 rump___sysimpl_sync(void ) 695 { 696 register_t retval[2]; 697 698 rsys_syscall(SYS_sync, NULL, 0, retval); 699 } 700 rsys_define(rumpns_sys_sync); 701 rsys_aliases(sync,rump___sysimpl_sync); 702 703 pid_t rump___sysimpl_getppid(void); 704 pid_t 705 rump___sysimpl_getppid(void ) 706 { 707 register_t retval[2]; 708 pid_t rv = -1; 709 710 rsys_syscall(SYS_getppid, NULL, 0, retval); 711 if (sizeof(pid_t) > sizeof(register_t)) 712 rv = *(pid_t *)retval; 713 else 714 rv = *retval; 715 return rv; 716 } 717 rsys_define(rumpns_sys_getppid); 718 rsys_aliases(getppid,rump___sysimpl_getppid); 719 720 int rump___sysimpl_dup(int); 721 int 722 rump___sysimpl_dup(int fd) 723 { 724 register_t retval[2]; 725 int error = 0; 726 int rv = -1; 727 struct sys_dup_args callarg; 728 729 SPARG(&callarg, fd) = fd; 730 731 error = rsys_syscall(SYS_dup, &callarg, sizeof(callarg), retval); 732 rsys_seterrno(error); 733 if (error == 0) { 734 if (sizeof(int) > sizeof(register_t)) 735 rv = *(int *)retval; 736 else 737 rv = *retval; 738 } 739 return rv; 740 } 741 rsys_define(rumpns_sys_dup); 742 rsys_aliases(dup,rump___sysimpl_dup); 743 744 gid_t rump___sysimpl_getegid(void); 745 gid_t 746 rump___sysimpl_getegid(void ) 747 { 748 register_t retval[2]; 749 gid_t rv = -1; 750 751 rsys_syscall(SYS_getegid, NULL, 0, retval); 752 if (sizeof(gid_t) > sizeof(register_t)) 753 rv = *(gid_t *)retval; 754 else 755 rv = *retval; 756 return rv; 757 } 758 rsys_define(rumpns_sys_getegid); 759 rsys_aliases(getegid,rump___sysimpl_getegid); 760 761 int rump___sysimpl_ktrace(const char *, int, int, pid_t); 762 int 763 rump___sysimpl_ktrace(const char * fname, int ops, int facs, pid_t pid) 764 { 765 register_t retval[2]; 766 int error = 0; 767 int rv = -1; 768 struct sys_ktrace_args callarg; 769 770 SPARG(&callarg, fname) = fname; 771 SPARG(&callarg, ops) = ops; 772 SPARG(&callarg, facs) = facs; 773 SPARG(&callarg, pid) = pid; 774 775 error = rsys_syscall(SYS_ktrace, &callarg, sizeof(callarg), retval); 776 rsys_seterrno(error); 777 if (error == 0) { 778 if (sizeof(int) > sizeof(register_t)) 779 rv = *(int *)retval; 780 else 781 rv = *retval; 782 } 783 return rv; 784 } 785 rsys_define(rumpns_sys_ktrace); 786 rsys_aliases(ktrace,rump___sysimpl_ktrace); 787 788 gid_t rump___sysimpl_getgid(void); 789 gid_t 790 rump___sysimpl_getgid(void ) 791 { 792 register_t retval[2]; 793 gid_t rv = -1; 794 795 rsys_syscall(SYS_getgid, NULL, 0, retval); 796 if (sizeof(gid_t) > sizeof(register_t)) 797 rv = *(gid_t *)retval; 798 else 799 rv = *retval; 800 return rv; 801 } 802 rsys_define(rumpns_sys_getgid_with_egid); 803 rsys_aliases(getgid,rump___sysimpl_getgid); 804 805 int rump___sysimpl___getlogin(char *, size_t); 806 int 807 rump___sysimpl___getlogin(char * namebuf, size_t namelen) 808 { 809 register_t retval[2]; 810 int error = 0; 811 int rv = -1; 812 struct sys___getlogin_args callarg; 813 814 SPARG(&callarg, namebuf) = namebuf; 815 SPARG(&callarg, namelen) = namelen; 816 817 error = rsys_syscall(SYS___getlogin, &callarg, sizeof(callarg), retval); 818 rsys_seterrno(error); 819 if (error == 0) { 820 if (sizeof(int) > sizeof(register_t)) 821 rv = *(int *)retval; 822 else 823 rv = *retval; 824 } 825 return rv; 826 } 827 rsys_define(rumpns_sys___getlogin); 828 rsys_aliases(__getlogin,rump___sysimpl___getlogin); 829 830 int rump___sysimpl___setlogin(const char *); 831 int 832 rump___sysimpl___setlogin(const char * namebuf) 833 { 834 register_t retval[2]; 835 int error = 0; 836 int rv = -1; 837 struct sys___setlogin_args callarg; 838 839 SPARG(&callarg, namebuf) = namebuf; 840 841 error = rsys_syscall(SYS___setlogin, &callarg, sizeof(callarg), retval); 842 rsys_seterrno(error); 843 if (error == 0) { 844 if (sizeof(int) > sizeof(register_t)) 845 rv = *(int *)retval; 846 else 847 rv = *retval; 848 } 849 return rv; 850 } 851 rsys_define(rumpns_sys___setlogin); 852 rsys_aliases(__setlogin,rump___sysimpl___setlogin); 853 854 int rump___sysimpl_ioctl(int, u_long, void *); 855 int 856 rump___sysimpl_ioctl(int fd, u_long com, void * data) 857 { 858 register_t retval[2]; 859 int error = 0; 860 int rv = -1; 861 struct sys_ioctl_args callarg; 862 863 SPARG(&callarg, fd) = fd; 864 SPARG(&callarg, com) = com; 865 SPARG(&callarg, data) = data; 866 867 error = rsys_syscall(SYS_ioctl, &callarg, sizeof(callarg), retval); 868 rsys_seterrno(error); 869 if (error == 0) { 870 if (sizeof(int) > sizeof(register_t)) 871 rv = *(int *)retval; 872 else 873 rv = *retval; 874 } 875 return rv; 876 } 877 rsys_define(rumpns_sys_ioctl); 878 rsys_aliases(ioctl,rump___sysimpl_ioctl); 879 880 int rump___sysimpl_revoke(const char *); 881 int 882 rump___sysimpl_revoke(const char * path) 883 { 884 register_t retval[2]; 885 int error = 0; 886 int rv = -1; 887 struct sys_revoke_args callarg; 888 889 SPARG(&callarg, path) = path; 890 891 error = rsys_syscall(SYS_revoke, &callarg, sizeof(callarg), retval); 892 rsys_seterrno(error); 893 if (error == 0) { 894 if (sizeof(int) > sizeof(register_t)) 895 rv = *(int *)retval; 896 else 897 rv = *retval; 898 } 899 return rv; 900 } 901 rsys_define(rumpns_sys_revoke); 902 rsys_aliases(revoke,rump___sysimpl_revoke); 903 904 int rump___sysimpl_symlink(const char *, const char *); 905 int 906 rump___sysimpl_symlink(const char * path, const char * link) 907 { 908 register_t retval[2]; 909 int error = 0; 910 int rv = -1; 911 struct sys_symlink_args callarg; 912 913 SPARG(&callarg, path) = path; 914 SPARG(&callarg, link) = link; 915 916 error = rsys_syscall(SYS_symlink, &callarg, sizeof(callarg), retval); 917 rsys_seterrno(error); 918 if (error == 0) { 919 if (sizeof(int) > sizeof(register_t)) 920 rv = *(int *)retval; 921 else 922 rv = *retval; 923 } 924 return rv; 925 } 926 rsys_define(rumpns_sys_symlink); 927 rsys_aliases(symlink,rump___sysimpl_symlink); 928 929 ssize_t rump___sysimpl_readlink(const char *, char *, size_t); 930 ssize_t 931 rump___sysimpl_readlink(const char * path, char * buf, size_t count) 932 { 933 register_t retval[2]; 934 int error = 0; 935 ssize_t rv = -1; 936 struct sys_readlink_args callarg; 937 938 SPARG(&callarg, path) = path; 939 SPARG(&callarg, buf) = buf; 940 SPARG(&callarg, count) = count; 941 942 error = rsys_syscall(SYS_readlink, &callarg, sizeof(callarg), retval); 943 rsys_seterrno(error); 944 if (error == 0) { 945 if (sizeof(ssize_t) > sizeof(register_t)) 946 rv = *(ssize_t *)retval; 947 else 948 rv = *retval; 949 } 950 return rv; 951 } 952 rsys_define(rumpns_sys_readlink); 953 rsys_aliases(readlink,rump___sysimpl_readlink); 954 955 mode_t rump___sysimpl_umask(mode_t); 956 mode_t 957 rump___sysimpl_umask(mode_t newmask) 958 { 959 register_t retval[2]; 960 int error = 0; 961 mode_t rv = -1; 962 struct sys_umask_args callarg; 963 964 SPARG(&callarg, newmask) = newmask; 965 966 error = rsys_syscall(SYS_umask, &callarg, sizeof(callarg), retval); 967 rsys_seterrno(error); 968 if (error == 0) { 969 if (sizeof(mode_t) > sizeof(register_t)) 970 rv = *(mode_t *)retval; 971 else 972 rv = *retval; 973 } 974 return rv; 975 } 976 rsys_define(rumpns_sys_umask); 977 rsys_aliases(umask,rump___sysimpl_umask); 978 979 int rump___sysimpl_chroot(const char *); 980 int 981 rump___sysimpl_chroot(const char * path) 982 { 983 register_t retval[2]; 984 int error = 0; 985 int rv = -1; 986 struct sys_chroot_args callarg; 987 988 SPARG(&callarg, path) = path; 989 990 error = rsys_syscall(SYS_chroot, &callarg, sizeof(callarg), retval); 991 rsys_seterrno(error); 992 if (error == 0) { 993 if (sizeof(int) > sizeof(register_t)) 994 rv = *(int *)retval; 995 else 996 rv = *retval; 997 } 998 return rv; 999 } 1000 rsys_define(rumpns_sys_chroot); 1001 rsys_aliases(chroot,rump___sysimpl_chroot); 1002 1003 int rump___sysimpl_getgroups(int, gid_t *); 1004 int 1005 rump___sysimpl_getgroups(int gidsetsize, gid_t * gidset) 1006 { 1007 register_t retval[2]; 1008 int error = 0; 1009 int rv = -1; 1010 struct sys_getgroups_args callarg; 1011 1012 SPARG(&callarg, gidsetsize) = gidsetsize; 1013 SPARG(&callarg, gidset) = gidset; 1014 1015 error = rsys_syscall(SYS_getgroups, &callarg, sizeof(callarg), retval); 1016 rsys_seterrno(error); 1017 if (error == 0) { 1018 if (sizeof(int) > sizeof(register_t)) 1019 rv = *(int *)retval; 1020 else 1021 rv = *retval; 1022 } 1023 return rv; 1024 } 1025 rsys_define(rumpns_sys_getgroups); 1026 rsys_aliases(getgroups,rump___sysimpl_getgroups); 1027 1028 int rump___sysimpl_setgroups(int, const gid_t *); 1029 int 1030 rump___sysimpl_setgroups(int gidsetsize, const gid_t * gidset) 1031 { 1032 register_t retval[2]; 1033 int error = 0; 1034 int rv = -1; 1035 struct sys_setgroups_args callarg; 1036 1037 SPARG(&callarg, gidsetsize) = gidsetsize; 1038 SPARG(&callarg, gidset) = gidset; 1039 1040 error = rsys_syscall(SYS_setgroups, &callarg, sizeof(callarg), retval); 1041 rsys_seterrno(error); 1042 if (error == 0) { 1043 if (sizeof(int) > sizeof(register_t)) 1044 rv = *(int *)retval; 1045 else 1046 rv = *retval; 1047 } 1048 return rv; 1049 } 1050 rsys_define(rumpns_sys_setgroups); 1051 rsys_aliases(setgroups,rump___sysimpl_setgroups); 1052 1053 int rump___sysimpl_getpgrp(void); 1054 int 1055 rump___sysimpl_getpgrp(void ) 1056 { 1057 register_t retval[2]; 1058 int error = 0; 1059 int rv = -1; 1060 1061 error = rsys_syscall(SYS_getpgrp, NULL, 0, retval); 1062 rsys_seterrno(error); 1063 if (error == 0) { 1064 if (sizeof(int) > sizeof(register_t)) 1065 rv = *(int *)retval; 1066 else 1067 rv = *retval; 1068 } 1069 return rv; 1070 } 1071 rsys_define(rumpns_sys_getpgrp); 1072 rsys_aliases(getpgrp,rump___sysimpl_getpgrp); 1073 1074 int rump___sysimpl_setpgid(pid_t, pid_t); 1075 int 1076 rump___sysimpl_setpgid(pid_t pid, pid_t pgid) 1077 { 1078 register_t retval[2]; 1079 int error = 0; 1080 int rv = -1; 1081 struct sys_setpgid_args callarg; 1082 1083 SPARG(&callarg, pid) = pid; 1084 SPARG(&callarg, pgid) = pgid; 1085 1086 error = rsys_syscall(SYS_setpgid, &callarg, sizeof(callarg), retval); 1087 rsys_seterrno(error); 1088 if (error == 0) { 1089 if (sizeof(int) > sizeof(register_t)) 1090 rv = *(int *)retval; 1091 else 1092 rv = *retval; 1093 } 1094 return rv; 1095 } 1096 rsys_define(rumpns_sys_setpgid); 1097 rsys_aliases(setpgid,rump___sysimpl_setpgid); 1098 1099 int rump___sysimpl_dup2(int, int); 1100 int 1101 rump___sysimpl_dup2(int from, int to) 1102 { 1103 register_t retval[2]; 1104 int error = 0; 1105 int rv = -1; 1106 struct sys_dup2_args callarg; 1107 1108 SPARG(&callarg, from) = from; 1109 SPARG(&callarg, to) = to; 1110 1111 error = rsys_syscall(SYS_dup2, &callarg, sizeof(callarg), retval); 1112 rsys_seterrno(error); 1113 if (error == 0) { 1114 if (sizeof(int) > sizeof(register_t)) 1115 rv = *(int *)retval; 1116 else 1117 rv = *retval; 1118 } 1119 return rv; 1120 } 1121 rsys_define(rumpns_sys_dup2); 1122 rsys_aliases(dup2,rump___sysimpl_dup2); 1123 1124 int rump___sysimpl_fcntl(int, int, void *); 1125 int 1126 rump___sysimpl_fcntl(int fd, int cmd, void * arg) 1127 { 1128 register_t retval[2]; 1129 int error = 0; 1130 int rv = -1; 1131 struct sys_fcntl_args callarg; 1132 1133 SPARG(&callarg, fd) = fd; 1134 SPARG(&callarg, cmd) = cmd; 1135 SPARG(&callarg, arg) = arg; 1136 1137 error = rsys_syscall(SYS_fcntl, &callarg, sizeof(callarg), retval); 1138 rsys_seterrno(error); 1139 if (error == 0) { 1140 if (sizeof(int) > sizeof(register_t)) 1141 rv = *(int *)retval; 1142 else 1143 rv = *retval; 1144 } 1145 return rv; 1146 } 1147 rsys_define(rumpns_sys_fcntl); 1148 rsys_aliases(fcntl,rump___sysimpl_fcntl); 1149 1150 int rump___sysimpl_select(int, fd_set *, fd_set *, fd_set *, struct timeval *); 1151 int 1152 rump___sysimpl_select(int nd, fd_set * in, fd_set * ou, fd_set * ex, struct timeval * tv) 1153 { 1154 register_t retval[2]; 1155 int error = 0; 1156 int rv = -1; 1157 struct compat_50_sys_select_args callarg; 1158 1159 SPARG(&callarg, nd) = nd; 1160 SPARG(&callarg, in) = in; 1161 SPARG(&callarg, ou) = ou; 1162 SPARG(&callarg, ex) = ex; 1163 SPARG(&callarg, tv) = (struct timeval50 *)tv; 1164 1165 error = rsys_syscall(SYS_compat_50_select, &callarg, sizeof(callarg), retval); 1166 rsys_seterrno(error); 1167 if (error == 0) { 1168 if (sizeof(int) > sizeof(register_t)) 1169 rv = *(int *)retval; 1170 else 1171 rv = *retval; 1172 } 1173 return rv; 1174 } 1175 rsys_define(rumpns_compat_50_sys_select); 1176 rsys_aliases(compat_50_select,rump___sysimpl_select); 1177 1178 int rump___sysimpl_fsync(int); 1179 int 1180 rump___sysimpl_fsync(int fd) 1181 { 1182 register_t retval[2]; 1183 int error = 0; 1184 int rv = -1; 1185 struct sys_fsync_args callarg; 1186 1187 SPARG(&callarg, fd) = fd; 1188 1189 error = rsys_syscall(SYS_fsync, &callarg, sizeof(callarg), retval); 1190 rsys_seterrno(error); 1191 if (error == 0) { 1192 if (sizeof(int) > sizeof(register_t)) 1193 rv = *(int *)retval; 1194 else 1195 rv = *retval; 1196 } 1197 return rv; 1198 } 1199 rsys_define(rumpns_sys_fsync); 1200 rsys_aliases(fsync,rump___sysimpl_fsync); 1201 1202 int rump___sysimpl_connect(int, const struct sockaddr *, socklen_t); 1203 int 1204 rump___sysimpl_connect(int s, const struct sockaddr * name, socklen_t namelen) 1205 { 1206 register_t retval[2]; 1207 int error = 0; 1208 int rv = -1; 1209 struct sys_connect_args callarg; 1210 1211 SPARG(&callarg, s) = s; 1212 SPARG(&callarg, name) = name; 1213 SPARG(&callarg, namelen) = namelen; 1214 1215 error = rsys_syscall(SYS_connect, &callarg, sizeof(callarg), retval); 1216 rsys_seterrno(error); 1217 if (error == 0) { 1218 if (sizeof(int) > sizeof(register_t)) 1219 rv = *(int *)retval; 1220 else 1221 rv = *retval; 1222 } 1223 return rv; 1224 } 1225 rsys_define(rumpns_sys_connect); 1226 rsys_aliases(connect,rump___sysimpl_connect); 1227 1228 int rump___sysimpl_bind(int, const struct sockaddr *, socklen_t); 1229 int 1230 rump___sysimpl_bind(int s, const struct sockaddr * name, socklen_t namelen) 1231 { 1232 register_t retval[2]; 1233 int error = 0; 1234 int rv = -1; 1235 struct sys_bind_args callarg; 1236 1237 SPARG(&callarg, s) = s; 1238 SPARG(&callarg, name) = name; 1239 SPARG(&callarg, namelen) = namelen; 1240 1241 error = rsys_syscall(SYS_bind, &callarg, sizeof(callarg), retval); 1242 rsys_seterrno(error); 1243 if (error == 0) { 1244 if (sizeof(int) > sizeof(register_t)) 1245 rv = *(int *)retval; 1246 else 1247 rv = *retval; 1248 } 1249 return rv; 1250 } 1251 rsys_define(rumpns_sys_bind); 1252 rsys_aliases(bind,rump___sysimpl_bind); 1253 1254 int rump___sysimpl_setsockopt(int, int, int, const void *, socklen_t); 1255 int 1256 rump___sysimpl_setsockopt(int s, int level, int name, const void * val, socklen_t valsize) 1257 { 1258 register_t retval[2]; 1259 int error = 0; 1260 int rv = -1; 1261 struct sys_setsockopt_args callarg; 1262 1263 SPARG(&callarg, s) = s; 1264 SPARG(&callarg, level) = level; 1265 SPARG(&callarg, name) = name; 1266 SPARG(&callarg, val) = val; 1267 SPARG(&callarg, valsize) = valsize; 1268 1269 error = rsys_syscall(SYS_setsockopt, &callarg, sizeof(callarg), retval); 1270 rsys_seterrno(error); 1271 if (error == 0) { 1272 if (sizeof(int) > sizeof(register_t)) 1273 rv = *(int *)retval; 1274 else 1275 rv = *retval; 1276 } 1277 return rv; 1278 } 1279 rsys_define(rumpns_sys_setsockopt); 1280 rsys_aliases(setsockopt,rump___sysimpl_setsockopt); 1281 1282 int rump___sysimpl_listen(int, int); 1283 int 1284 rump___sysimpl_listen(int s, int backlog) 1285 { 1286 register_t retval[2]; 1287 int error = 0; 1288 int rv = -1; 1289 struct sys_listen_args callarg; 1290 1291 SPARG(&callarg, s) = s; 1292 SPARG(&callarg, backlog) = backlog; 1293 1294 error = rsys_syscall(SYS_listen, &callarg, sizeof(callarg), retval); 1295 rsys_seterrno(error); 1296 if (error == 0) { 1297 if (sizeof(int) > sizeof(register_t)) 1298 rv = *(int *)retval; 1299 else 1300 rv = *retval; 1301 } 1302 return rv; 1303 } 1304 rsys_define(rumpns_sys_listen); 1305 rsys_aliases(listen,rump___sysimpl_listen); 1306 1307 int rump___sysimpl_getsockopt(int, int, int, void *, socklen_t *); 1308 int 1309 rump___sysimpl_getsockopt(int s, int level, int name, void * val, socklen_t * avalsize) 1310 { 1311 register_t retval[2]; 1312 int error = 0; 1313 int rv = -1; 1314 struct sys_getsockopt_args callarg; 1315 1316 SPARG(&callarg, s) = s; 1317 SPARG(&callarg, level) = level; 1318 SPARG(&callarg, name) = name; 1319 SPARG(&callarg, val) = val; 1320 SPARG(&callarg, avalsize) = avalsize; 1321 1322 error = rsys_syscall(SYS_getsockopt, &callarg, sizeof(callarg), retval); 1323 rsys_seterrno(error); 1324 if (error == 0) { 1325 if (sizeof(int) > sizeof(register_t)) 1326 rv = *(int *)retval; 1327 else 1328 rv = *retval; 1329 } 1330 return rv; 1331 } 1332 rsys_define(rumpns_sys_getsockopt); 1333 rsys_aliases(getsockopt,rump___sysimpl_getsockopt); 1334 1335 ssize_t rump___sysimpl_readv(int, const struct iovec *, int); 1336 ssize_t 1337 rump___sysimpl_readv(int fd, const struct iovec * iovp, int iovcnt) 1338 { 1339 register_t retval[2]; 1340 int error = 0; 1341 ssize_t rv = -1; 1342 struct sys_readv_args callarg; 1343 1344 SPARG(&callarg, fd) = fd; 1345 SPARG(&callarg, iovp) = iovp; 1346 SPARG(&callarg, iovcnt) = iovcnt; 1347 1348 error = rsys_syscall(SYS_readv, &callarg, sizeof(callarg), retval); 1349 rsys_seterrno(error); 1350 if (error == 0) { 1351 if (sizeof(ssize_t) > sizeof(register_t)) 1352 rv = *(ssize_t *)retval; 1353 else 1354 rv = *retval; 1355 } 1356 return rv; 1357 } 1358 rsys_define(rumpns_sys_readv); 1359 rsys_aliases(readv,rump___sysimpl_readv); 1360 1361 ssize_t rump___sysimpl_writev(int, const struct iovec *, int); 1362 ssize_t 1363 rump___sysimpl_writev(int fd, const struct iovec * iovp, int iovcnt) 1364 { 1365 register_t retval[2]; 1366 int error = 0; 1367 ssize_t rv = -1; 1368 struct sys_writev_args callarg; 1369 1370 SPARG(&callarg, fd) = fd; 1371 SPARG(&callarg, iovp) = iovp; 1372 SPARG(&callarg, iovcnt) = iovcnt; 1373 1374 error = rsys_syscall(SYS_writev, &callarg, sizeof(callarg), retval); 1375 rsys_seterrno(error); 1376 if (error == 0) { 1377 if (sizeof(ssize_t) > sizeof(register_t)) 1378 rv = *(ssize_t *)retval; 1379 else 1380 rv = *retval; 1381 } 1382 return rv; 1383 } 1384 rsys_define(rumpns_sys_writev); 1385 rsys_aliases(writev,rump___sysimpl_writev); 1386 1387 int rump___sysimpl_fchown(int, uid_t, gid_t); 1388 int 1389 rump___sysimpl_fchown(int fd, uid_t uid, gid_t gid) 1390 { 1391 register_t retval[2]; 1392 int error = 0; 1393 int rv = -1; 1394 struct sys_fchown_args callarg; 1395 1396 SPARG(&callarg, fd) = fd; 1397 SPARG(&callarg, uid) = uid; 1398 SPARG(&callarg, gid) = gid; 1399 1400 error = rsys_syscall(SYS_fchown, &callarg, sizeof(callarg), retval); 1401 rsys_seterrno(error); 1402 if (error == 0) { 1403 if (sizeof(int) > sizeof(register_t)) 1404 rv = *(int *)retval; 1405 else 1406 rv = *retval; 1407 } 1408 return rv; 1409 } 1410 rsys_define(rumpns_sys_fchown); 1411 rsys_aliases(fchown,rump___sysimpl_fchown); 1412 1413 int rump___sysimpl_fchmod(int, mode_t); 1414 int 1415 rump___sysimpl_fchmod(int fd, mode_t mode) 1416 { 1417 register_t retval[2]; 1418 int error = 0; 1419 int rv = -1; 1420 struct sys_fchmod_args callarg; 1421 1422 SPARG(&callarg, fd) = fd; 1423 SPARG(&callarg, mode) = mode; 1424 1425 error = rsys_syscall(SYS_fchmod, &callarg, sizeof(callarg), retval); 1426 rsys_seterrno(error); 1427 if (error == 0) { 1428 if (sizeof(int) > sizeof(register_t)) 1429 rv = *(int *)retval; 1430 else 1431 rv = *retval; 1432 } 1433 return rv; 1434 } 1435 rsys_define(rumpns_sys_fchmod); 1436 rsys_aliases(fchmod,rump___sysimpl_fchmod); 1437 1438 int rump___sysimpl_setreuid(uid_t, uid_t); 1439 int 1440 rump___sysimpl_setreuid(uid_t ruid, uid_t euid) 1441 { 1442 register_t retval[2]; 1443 int error = 0; 1444 int rv = -1; 1445 struct sys_setreuid_args callarg; 1446 1447 SPARG(&callarg, ruid) = ruid; 1448 SPARG(&callarg, euid) = euid; 1449 1450 error = rsys_syscall(SYS_setreuid, &callarg, sizeof(callarg), retval); 1451 rsys_seterrno(error); 1452 if (error == 0) { 1453 if (sizeof(int) > sizeof(register_t)) 1454 rv = *(int *)retval; 1455 else 1456 rv = *retval; 1457 } 1458 return rv; 1459 } 1460 rsys_define(rumpns_sys_setreuid); 1461 rsys_aliases(setreuid,rump___sysimpl_setreuid); 1462 1463 int rump___sysimpl_setregid(gid_t, gid_t); 1464 int 1465 rump___sysimpl_setregid(gid_t rgid, gid_t egid) 1466 { 1467 register_t retval[2]; 1468 int error = 0; 1469 int rv = -1; 1470 struct sys_setregid_args callarg; 1471 1472 SPARG(&callarg, rgid) = rgid; 1473 SPARG(&callarg, egid) = egid; 1474 1475 error = rsys_syscall(SYS_setregid, &callarg, sizeof(callarg), retval); 1476 rsys_seterrno(error); 1477 if (error == 0) { 1478 if (sizeof(int) > sizeof(register_t)) 1479 rv = *(int *)retval; 1480 else 1481 rv = *retval; 1482 } 1483 return rv; 1484 } 1485 rsys_define(rumpns_sys_setregid); 1486 rsys_aliases(setregid,rump___sysimpl_setregid); 1487 1488 int rump___sysimpl_rename(const char *, const char *); 1489 int 1490 rump___sysimpl_rename(const char * from, const char * to) 1491 { 1492 register_t retval[2]; 1493 int error = 0; 1494 int rv = -1; 1495 struct sys_rename_args callarg; 1496 1497 SPARG(&callarg, from) = from; 1498 SPARG(&callarg, to) = to; 1499 1500 error = rsys_syscall(SYS_rename, &callarg, sizeof(callarg), retval); 1501 rsys_seterrno(error); 1502 if (error == 0) { 1503 if (sizeof(int) > sizeof(register_t)) 1504 rv = *(int *)retval; 1505 else 1506 rv = *retval; 1507 } 1508 return rv; 1509 } 1510 rsys_define(rumpns_sys_rename); 1511 rsys_aliases(rename,rump___sysimpl_rename); 1512 1513 int rump___sysimpl_flock(int, int); 1514 int 1515 rump___sysimpl_flock(int fd, int how) 1516 { 1517 register_t retval[2]; 1518 int error = 0; 1519 int rv = -1; 1520 struct sys_flock_args callarg; 1521 1522 SPARG(&callarg, fd) = fd; 1523 SPARG(&callarg, how) = how; 1524 1525 error = rsys_syscall(SYS_flock, &callarg, sizeof(callarg), retval); 1526 rsys_seterrno(error); 1527 if (error == 0) { 1528 if (sizeof(int) > sizeof(register_t)) 1529 rv = *(int *)retval; 1530 else 1531 rv = *retval; 1532 } 1533 return rv; 1534 } 1535 rsys_define(rumpns_sys_flock); 1536 rsys_aliases(flock,rump___sysimpl_flock); 1537 1538 int rump___sysimpl_mkfifo(const char *, mode_t); 1539 int 1540 rump___sysimpl_mkfifo(const char * path, mode_t mode) 1541 { 1542 register_t retval[2]; 1543 int error = 0; 1544 int rv = -1; 1545 struct sys_mkfifo_args callarg; 1546 1547 SPARG(&callarg, path) = path; 1548 SPARG(&callarg, mode) = mode; 1549 1550 error = rsys_syscall(SYS_mkfifo, &callarg, sizeof(callarg), retval); 1551 rsys_seterrno(error); 1552 if (error == 0) { 1553 if (sizeof(int) > sizeof(register_t)) 1554 rv = *(int *)retval; 1555 else 1556 rv = *retval; 1557 } 1558 return rv; 1559 } 1560 rsys_define(rumpns_sys_mkfifo); 1561 rsys_aliases(mkfifo,rump___sysimpl_mkfifo); 1562 1563 ssize_t rump___sysimpl_sendto(int, const void *, size_t, int, const struct sockaddr *, socklen_t); 1564 ssize_t 1565 rump___sysimpl_sendto(int s, const void * buf, size_t len, int flags, const struct sockaddr * to, socklen_t tolen) 1566 { 1567 register_t retval[2]; 1568 int error = 0; 1569 ssize_t rv = -1; 1570 struct sys_sendto_args callarg; 1571 1572 SPARG(&callarg, s) = s; 1573 SPARG(&callarg, buf) = buf; 1574 SPARG(&callarg, len) = len; 1575 SPARG(&callarg, flags) = flags; 1576 SPARG(&callarg, to) = to; 1577 SPARG(&callarg, tolen) = tolen; 1578 1579 error = rsys_syscall(SYS_sendto, &callarg, sizeof(callarg), retval); 1580 rsys_seterrno(error); 1581 if (error == 0) { 1582 if (sizeof(ssize_t) > sizeof(register_t)) 1583 rv = *(ssize_t *)retval; 1584 else 1585 rv = *retval; 1586 } 1587 return rv; 1588 } 1589 rsys_define(rumpns_sys_sendto); 1590 rsys_aliases(sendto,rump___sysimpl_sendto); 1591 1592 int rump___sysimpl_shutdown(int, int); 1593 int 1594 rump___sysimpl_shutdown(int s, int how) 1595 { 1596 register_t retval[2]; 1597 int error = 0; 1598 int rv = -1; 1599 struct sys_shutdown_args callarg; 1600 1601 SPARG(&callarg, s) = s; 1602 SPARG(&callarg, how) = how; 1603 1604 error = rsys_syscall(SYS_shutdown, &callarg, sizeof(callarg), retval); 1605 rsys_seterrno(error); 1606 if (error == 0) { 1607 if (sizeof(int) > sizeof(register_t)) 1608 rv = *(int *)retval; 1609 else 1610 rv = *retval; 1611 } 1612 return rv; 1613 } 1614 rsys_define(rumpns_sys_shutdown); 1615 rsys_aliases(shutdown,rump___sysimpl_shutdown); 1616 1617 int rump___sysimpl_socketpair(int, int, int, int *); 1618 int 1619 rump___sysimpl_socketpair(int domain, int type, int protocol, int * rsv) 1620 { 1621 register_t retval[2]; 1622 int error = 0; 1623 int rv = -1; 1624 struct sys_socketpair_args callarg; 1625 1626 SPARG(&callarg, domain) = domain; 1627 SPARG(&callarg, type) = type; 1628 SPARG(&callarg, protocol) = protocol; 1629 SPARG(&callarg, rsv) = rsv; 1630 1631 error = rsys_syscall(SYS_socketpair, &callarg, sizeof(callarg), retval); 1632 rsys_seterrno(error); 1633 if (error == 0) { 1634 if (sizeof(int) > sizeof(register_t)) 1635 rv = *(int *)retval; 1636 else 1637 rv = *retval; 1638 } 1639 return rv; 1640 } 1641 rsys_define(rumpns_sys_socketpair); 1642 rsys_aliases(socketpair,rump___sysimpl_socketpair); 1643 1644 int rump___sysimpl_mkdir(const char *, mode_t); 1645 int 1646 rump___sysimpl_mkdir(const char * path, mode_t mode) 1647 { 1648 register_t retval[2]; 1649 int error = 0; 1650 int rv = -1; 1651 struct sys_mkdir_args callarg; 1652 1653 SPARG(&callarg, path) = path; 1654 SPARG(&callarg, mode) = mode; 1655 1656 error = rsys_syscall(SYS_mkdir, &callarg, sizeof(callarg), retval); 1657 rsys_seterrno(error); 1658 if (error == 0) { 1659 if (sizeof(int) > sizeof(register_t)) 1660 rv = *(int *)retval; 1661 else 1662 rv = *retval; 1663 } 1664 return rv; 1665 } 1666 rsys_define(rumpns_sys_mkdir); 1667 rsys_aliases(mkdir,rump___sysimpl_mkdir); 1668 1669 int rump___sysimpl_rmdir(const char *); 1670 int 1671 rump___sysimpl_rmdir(const char * path) 1672 { 1673 register_t retval[2]; 1674 int error = 0; 1675 int rv = -1; 1676 struct sys_rmdir_args callarg; 1677 1678 SPARG(&callarg, path) = path; 1679 1680 error = rsys_syscall(SYS_rmdir, &callarg, sizeof(callarg), retval); 1681 rsys_seterrno(error); 1682 if (error == 0) { 1683 if (sizeof(int) > sizeof(register_t)) 1684 rv = *(int *)retval; 1685 else 1686 rv = *retval; 1687 } 1688 return rv; 1689 } 1690 rsys_define(rumpns_sys_rmdir); 1691 rsys_aliases(rmdir,rump___sysimpl_rmdir); 1692 1693 int rump___sysimpl_utimes(const char *, const struct timeval *); 1694 int 1695 rump___sysimpl_utimes(const char * path, const struct timeval * tptr) 1696 { 1697 register_t retval[2]; 1698 int error = 0; 1699 int rv = -1; 1700 struct compat_50_sys_utimes_args callarg; 1701 1702 SPARG(&callarg, path) = path; 1703 SPARG(&callarg, tptr) = (const struct timeval50 *)tptr; 1704 1705 error = rsys_syscall(SYS_compat_50_utimes, &callarg, sizeof(callarg), retval); 1706 rsys_seterrno(error); 1707 if (error == 0) { 1708 if (sizeof(int) > sizeof(register_t)) 1709 rv = *(int *)retval; 1710 else 1711 rv = *retval; 1712 } 1713 return rv; 1714 } 1715 rsys_define(rumpns_compat_50_sys_utimes); 1716 rsys_aliases(compat_50_utimes,rump___sysimpl_utimes); 1717 1718 int rump___sysimpl_setsid(void); 1719 int 1720 rump___sysimpl_setsid(void ) 1721 { 1722 register_t retval[2]; 1723 int error = 0; 1724 int rv = -1; 1725 1726 error = rsys_syscall(SYS_setsid, NULL, 0, retval); 1727 rsys_seterrno(error); 1728 if (error == 0) { 1729 if (sizeof(int) > sizeof(register_t)) 1730 rv = *(int *)retval; 1731 else 1732 rv = *retval; 1733 } 1734 return rv; 1735 } 1736 rsys_define(rumpns_sys_setsid); 1737 rsys_aliases(setsid,rump___sysimpl_setsid); 1738 1739 int rump___sysimpl_nfssvc(int, void *); 1740 int 1741 rump___sysimpl_nfssvc(int flag, void * argp) 1742 { 1743 register_t retval[2]; 1744 int error = 0; 1745 int rv = -1; 1746 struct sys_nfssvc_args callarg; 1747 1748 SPARG(&callarg, flag) = flag; 1749 SPARG(&callarg, argp) = argp; 1750 1751 error = rsys_syscall(SYS_nfssvc, &callarg, sizeof(callarg), retval); 1752 rsys_seterrno(error); 1753 if (error == 0) { 1754 if (sizeof(int) > sizeof(register_t)) 1755 rv = *(int *)retval; 1756 else 1757 rv = *retval; 1758 } 1759 return rv; 1760 } 1761 rsys_define(rumpns_sys_nfssvc); 1762 rsys_aliases(nfssvc,rump___sysimpl_nfssvc); 1763 1764 ssize_t rump___sysimpl_pread(int, void *, size_t, off_t); 1765 ssize_t 1766 rump___sysimpl_pread(int fd, void * buf, size_t nbyte, off_t offset) 1767 { 1768 register_t retval[2]; 1769 int error = 0; 1770 ssize_t rv = -1; 1771 struct sys_pread_args callarg; 1772 1773 SPARG(&callarg, fd) = fd; 1774 SPARG(&callarg, buf) = buf; 1775 SPARG(&callarg, nbyte) = nbyte; 1776 SPARG(&callarg, PAD) = 0; 1777 SPARG(&callarg, offset) = offset; 1778 1779 error = rsys_syscall(SYS_pread, &callarg, sizeof(callarg), retval); 1780 rsys_seterrno(error); 1781 if (error == 0) { 1782 if (sizeof(ssize_t) > sizeof(register_t)) 1783 rv = *(ssize_t *)retval; 1784 else 1785 rv = *retval; 1786 } 1787 return rv; 1788 } 1789 rsys_define(rumpns_sys_pread); 1790 rsys_aliases(pread,rump___sysimpl_pread); 1791 1792 ssize_t rump___sysimpl_pwrite(int, const void *, size_t, off_t); 1793 ssize_t 1794 rump___sysimpl_pwrite(int fd, const void * buf, size_t nbyte, off_t offset) 1795 { 1796 register_t retval[2]; 1797 int error = 0; 1798 ssize_t rv = -1; 1799 struct sys_pwrite_args callarg; 1800 1801 SPARG(&callarg, fd) = fd; 1802 SPARG(&callarg, buf) = buf; 1803 SPARG(&callarg, nbyte) = nbyte; 1804 SPARG(&callarg, PAD) = 0; 1805 SPARG(&callarg, offset) = offset; 1806 1807 error = rsys_syscall(SYS_pwrite, &callarg, sizeof(callarg), retval); 1808 rsys_seterrno(error); 1809 if (error == 0) { 1810 if (sizeof(ssize_t) > sizeof(register_t)) 1811 rv = *(ssize_t *)retval; 1812 else 1813 rv = *retval; 1814 } 1815 return rv; 1816 } 1817 rsys_define(rumpns_sys_pwrite); 1818 rsys_aliases(pwrite,rump___sysimpl_pwrite); 1819 1820 int rump___sysimpl_setgid(gid_t); 1821 int 1822 rump___sysimpl_setgid(gid_t gid) 1823 { 1824 register_t retval[2]; 1825 int error = 0; 1826 int rv = -1; 1827 struct sys_setgid_args callarg; 1828 1829 SPARG(&callarg, gid) = gid; 1830 1831 error = rsys_syscall(SYS_setgid, &callarg, sizeof(callarg), retval); 1832 rsys_seterrno(error); 1833 if (error == 0) { 1834 if (sizeof(int) > sizeof(register_t)) 1835 rv = *(int *)retval; 1836 else 1837 rv = *retval; 1838 } 1839 return rv; 1840 } 1841 rsys_define(rumpns_sys_setgid); 1842 rsys_aliases(setgid,rump___sysimpl_setgid); 1843 1844 int rump___sysimpl_setegid(gid_t); 1845 int 1846 rump___sysimpl_setegid(gid_t egid) 1847 { 1848 register_t retval[2]; 1849 int error = 0; 1850 int rv = -1; 1851 struct sys_setegid_args callarg; 1852 1853 SPARG(&callarg, egid) = egid; 1854 1855 error = rsys_syscall(SYS_setegid, &callarg, sizeof(callarg), retval); 1856 rsys_seterrno(error); 1857 if (error == 0) { 1858 if (sizeof(int) > sizeof(register_t)) 1859 rv = *(int *)retval; 1860 else 1861 rv = *retval; 1862 } 1863 return rv; 1864 } 1865 rsys_define(rumpns_sys_setegid); 1866 rsys_aliases(setegid,rump___sysimpl_setegid); 1867 1868 int rump___sysimpl_seteuid(uid_t); 1869 int 1870 rump___sysimpl_seteuid(uid_t euid) 1871 { 1872 register_t retval[2]; 1873 int error = 0; 1874 int rv = -1; 1875 struct sys_seteuid_args callarg; 1876 1877 SPARG(&callarg, euid) = euid; 1878 1879 error = rsys_syscall(SYS_seteuid, &callarg, sizeof(callarg), retval); 1880 rsys_seterrno(error); 1881 if (error == 0) { 1882 if (sizeof(int) > sizeof(register_t)) 1883 rv = *(int *)retval; 1884 else 1885 rv = *retval; 1886 } 1887 return rv; 1888 } 1889 rsys_define(rumpns_sys_seteuid); 1890 rsys_aliases(seteuid,rump___sysimpl_seteuid); 1891 1892 long rump___sysimpl_pathconf(const char *, int); 1893 long 1894 rump___sysimpl_pathconf(const char * path, int name) 1895 { 1896 register_t retval[2]; 1897 int error = 0; 1898 long rv = -1; 1899 struct sys_pathconf_args callarg; 1900 1901 SPARG(&callarg, path) = path; 1902 SPARG(&callarg, name) = name; 1903 1904 error = rsys_syscall(SYS_pathconf, &callarg, sizeof(callarg), retval); 1905 rsys_seterrno(error); 1906 if (error == 0) { 1907 if (sizeof(long) > sizeof(register_t)) 1908 rv = *(long *)retval; 1909 else 1910 rv = *retval; 1911 } 1912 return rv; 1913 } 1914 rsys_define(rumpns_sys_pathconf); 1915 rsys_aliases(pathconf,rump___sysimpl_pathconf); 1916 1917 long rump___sysimpl_fpathconf(int, int); 1918 long 1919 rump___sysimpl_fpathconf(int fd, int name) 1920 { 1921 register_t retval[2]; 1922 int error = 0; 1923 long rv = -1; 1924 struct sys_fpathconf_args callarg; 1925 1926 SPARG(&callarg, fd) = fd; 1927 SPARG(&callarg, name) = name; 1928 1929 error = rsys_syscall(SYS_fpathconf, &callarg, sizeof(callarg), retval); 1930 rsys_seterrno(error); 1931 if (error == 0) { 1932 if (sizeof(long) > sizeof(register_t)) 1933 rv = *(long *)retval; 1934 else 1935 rv = *retval; 1936 } 1937 return rv; 1938 } 1939 rsys_define(rumpns_sys_fpathconf); 1940 rsys_aliases(fpathconf,rump___sysimpl_fpathconf); 1941 1942 int rump___sysimpl_getrlimit(int, struct rlimit *); 1943 int 1944 rump___sysimpl_getrlimit(int which, struct rlimit * rlp) 1945 { 1946 register_t retval[2]; 1947 int error = 0; 1948 int rv = -1; 1949 struct sys_getrlimit_args callarg; 1950 1951 SPARG(&callarg, which) = which; 1952 SPARG(&callarg, rlp) = rlp; 1953 1954 error = rsys_syscall(SYS_getrlimit, &callarg, sizeof(callarg), retval); 1955 rsys_seterrno(error); 1956 if (error == 0) { 1957 if (sizeof(int) > sizeof(register_t)) 1958 rv = *(int *)retval; 1959 else 1960 rv = *retval; 1961 } 1962 return rv; 1963 } 1964 rsys_define(rumpns_sys_getrlimit); 1965 rsys_aliases(getrlimit,rump___sysimpl_getrlimit); 1966 1967 int rump___sysimpl_setrlimit(int, const struct rlimit *); 1968 int 1969 rump___sysimpl_setrlimit(int which, const struct rlimit * rlp) 1970 { 1971 register_t retval[2]; 1972 int error = 0; 1973 int rv = -1; 1974 struct sys_setrlimit_args callarg; 1975 1976 SPARG(&callarg, which) = which; 1977 SPARG(&callarg, rlp) = rlp; 1978 1979 error = rsys_syscall(SYS_setrlimit, &callarg, sizeof(callarg), retval); 1980 rsys_seterrno(error); 1981 if (error == 0) { 1982 if (sizeof(int) > sizeof(register_t)) 1983 rv = *(int *)retval; 1984 else 1985 rv = *retval; 1986 } 1987 return rv; 1988 } 1989 rsys_define(rumpns_sys_setrlimit); 1990 rsys_aliases(setrlimit,rump___sysimpl_setrlimit); 1991 1992 off_t rump___sysimpl_lseek(int, off_t, int); 1993 off_t 1994 rump___sysimpl_lseek(int fd, off_t offset, int whence) 1995 { 1996 register_t retval[2]; 1997 int error = 0; 1998 off_t rv = -1; 1999 struct sys_lseek_args callarg; 2000 2001 SPARG(&callarg, fd) = fd; 2002 SPARG(&callarg, PAD) = 0; 2003 SPARG(&callarg, offset) = offset; 2004 SPARG(&callarg, whence) = whence; 2005 2006 error = rsys_syscall(SYS_lseek, &callarg, sizeof(callarg), retval); 2007 rsys_seterrno(error); 2008 if (error == 0) { 2009 if (sizeof(off_t) > sizeof(register_t)) 2010 rv = *(off_t *)retval; 2011 else 2012 rv = *retval; 2013 } 2014 return rv; 2015 } 2016 rsys_define(rumpns_sys_lseek); 2017 rsys_aliases(lseek,rump___sysimpl_lseek); 2018 2019 int rump___sysimpl_truncate(const char *, off_t); 2020 int 2021 rump___sysimpl_truncate(const char * path, off_t length) 2022 { 2023 register_t retval[2]; 2024 int error = 0; 2025 int rv = -1; 2026 struct sys_truncate_args callarg; 2027 2028 SPARG(&callarg, path) = path; 2029 SPARG(&callarg, PAD) = 0; 2030 SPARG(&callarg, length) = length; 2031 2032 error = rsys_syscall(SYS_truncate, &callarg, sizeof(callarg), retval); 2033 rsys_seterrno(error); 2034 if (error == 0) { 2035 if (sizeof(int) > sizeof(register_t)) 2036 rv = *(int *)retval; 2037 else 2038 rv = *retval; 2039 } 2040 return rv; 2041 } 2042 rsys_define(rumpns_sys_truncate); 2043 rsys_aliases(truncate,rump___sysimpl_truncate); 2044 2045 int rump___sysimpl_ftruncate(int, off_t); 2046 int 2047 rump___sysimpl_ftruncate(int fd, off_t length) 2048 { 2049 register_t retval[2]; 2050 int error = 0; 2051 int rv = -1; 2052 struct sys_ftruncate_args callarg; 2053 2054 SPARG(&callarg, fd) = fd; 2055 SPARG(&callarg, PAD) = 0; 2056 SPARG(&callarg, length) = length; 2057 2058 error = rsys_syscall(SYS_ftruncate, &callarg, sizeof(callarg), retval); 2059 rsys_seterrno(error); 2060 if (error == 0) { 2061 if (sizeof(int) > sizeof(register_t)) 2062 rv = *(int *)retval; 2063 else 2064 rv = *retval; 2065 } 2066 return rv; 2067 } 2068 rsys_define(rumpns_sys_ftruncate); 2069 rsys_aliases(ftruncate,rump___sysimpl_ftruncate); 2070 2071 int rump___sysimpl___sysctl(const int *, u_int, void *, size_t *, const void *, size_t); 2072 int 2073 rump___sysimpl___sysctl(const int * name, u_int namelen, void * old, size_t * oldlenp, const void * new, size_t newlen) 2074 { 2075 register_t retval[2]; 2076 int error = 0; 2077 int rv = -1; 2078 struct sys___sysctl_args callarg; 2079 2080 SPARG(&callarg, name) = name; 2081 SPARG(&callarg, namelen) = namelen; 2082 SPARG(&callarg, old) = old; 2083 SPARG(&callarg, oldlenp) = oldlenp; 2084 SPARG(&callarg, new) = new; 2085 SPARG(&callarg, newlen) = newlen; 2086 2087 error = rsys_syscall(SYS___sysctl, &callarg, sizeof(callarg), retval); 2088 rsys_seterrno(error); 2089 if (error == 0) { 2090 if (sizeof(int) > sizeof(register_t)) 2091 rv = *(int *)retval; 2092 else 2093 rv = *retval; 2094 } 2095 return rv; 2096 } 2097 rsys_define(rumpns_sys___sysctl); 2098 rsys_aliases(__sysctl,rump___sysimpl___sysctl); 2099 2100 int rump___sysimpl_futimes(int, const struct timeval *); 2101 int 2102 rump___sysimpl_futimes(int fd, const struct timeval * tptr) 2103 { 2104 register_t retval[2]; 2105 int error = 0; 2106 int rv = -1; 2107 struct compat_50_sys_futimes_args callarg; 2108 2109 SPARG(&callarg, fd) = fd; 2110 SPARG(&callarg, tptr) = (const struct timeval50 *)tptr; 2111 2112 error = rsys_syscall(SYS_compat_50_futimes, &callarg, sizeof(callarg), retval); 2113 rsys_seterrno(error); 2114 if (error == 0) { 2115 if (sizeof(int) > sizeof(register_t)) 2116 rv = *(int *)retval; 2117 else 2118 rv = *retval; 2119 } 2120 return rv; 2121 } 2122 rsys_define(rumpns_compat_50_sys_futimes); 2123 rsys_aliases(compat_50_futimes,rump___sysimpl_futimes); 2124 2125 pid_t rump___sysimpl_getpgid(pid_t); 2126 pid_t 2127 rump___sysimpl_getpgid(pid_t pid) 2128 { 2129 register_t retval[2]; 2130 int error = 0; 2131 pid_t rv = -1; 2132 struct sys_getpgid_args callarg; 2133 2134 SPARG(&callarg, pid) = pid; 2135 2136 error = rsys_syscall(SYS_getpgid, &callarg, sizeof(callarg), retval); 2137 rsys_seterrno(error); 2138 if (error == 0) { 2139 if (sizeof(pid_t) > sizeof(register_t)) 2140 rv = *(pid_t *)retval; 2141 else 2142 rv = *retval; 2143 } 2144 return rv; 2145 } 2146 rsys_define(rumpns_sys_getpgid); 2147 rsys_aliases(getpgid,rump___sysimpl_getpgid); 2148 2149 int rump___sysimpl_reboot(int, char *); 2150 int 2151 rump___sysimpl_reboot(int opt, char * bootstr) 2152 { 2153 register_t retval[2]; 2154 int error = 0; 2155 int rv = -1; 2156 struct sys_reboot_args callarg; 2157 2158 SPARG(&callarg, opt) = opt; 2159 SPARG(&callarg, bootstr) = bootstr; 2160 2161 error = rsys_syscall(SYS_reboot, &callarg, sizeof(callarg), retval); 2162 rsys_seterrno(error); 2163 if (error == 0) { 2164 if (sizeof(int) > sizeof(register_t)) 2165 rv = *(int *)retval; 2166 else 2167 rv = *retval; 2168 } 2169 return rv; 2170 } 2171 rsys_define(rumpns_sys_reboot); 2172 rsys_aliases(reboot,rump___sysimpl_reboot); 2173 2174 int rump___sysimpl_poll(struct pollfd *, u_int, int); 2175 int 2176 rump___sysimpl_poll(struct pollfd * fds, u_int nfds, int timeout) 2177 { 2178 register_t retval[2]; 2179 int error = 0; 2180 int rv = -1; 2181 struct sys_poll_args callarg; 2182 2183 SPARG(&callarg, fds) = fds; 2184 SPARG(&callarg, nfds) = nfds; 2185 SPARG(&callarg, timeout) = timeout; 2186 2187 error = rsys_syscall(SYS_poll, &callarg, sizeof(callarg), retval); 2188 rsys_seterrno(error); 2189 if (error == 0) { 2190 if (sizeof(int) > sizeof(register_t)) 2191 rv = *(int *)retval; 2192 else 2193 rv = *retval; 2194 } 2195 return rv; 2196 } 2197 rsys_define(rumpns_sys_poll); 2198 rsys_aliases(poll,rump___sysimpl_poll); 2199 2200 int rump___sysimpl_fdatasync(int); 2201 int 2202 rump___sysimpl_fdatasync(int fd) 2203 { 2204 register_t retval[2]; 2205 int error = 0; 2206 int rv = -1; 2207 struct sys_fdatasync_args callarg; 2208 2209 SPARG(&callarg, fd) = fd; 2210 2211 error = rsys_syscall(SYS_fdatasync, &callarg, sizeof(callarg), retval); 2212 rsys_seterrno(error); 2213 if (error == 0) { 2214 if (sizeof(int) > sizeof(register_t)) 2215 rv = *(int *)retval; 2216 else 2217 rv = *retval; 2218 } 2219 return rv; 2220 } 2221 rsys_define(rumpns_sys_fdatasync); 2222 rsys_aliases(fdatasync,rump___sysimpl_fdatasync); 2223 2224 int rump___sysimpl_modctl(int, void *); 2225 int 2226 rump___sysimpl_modctl(int cmd, void * arg) 2227 { 2228 register_t retval[2]; 2229 int error = 0; 2230 int rv = -1; 2231 struct sys_modctl_args callarg; 2232 2233 SPARG(&callarg, cmd) = cmd; 2234 SPARG(&callarg, arg) = arg; 2235 2236 error = rsys_syscall(SYS_modctl, &callarg, sizeof(callarg), retval); 2237 rsys_seterrno(error); 2238 if (error == 0) { 2239 if (sizeof(int) > sizeof(register_t)) 2240 rv = *(int *)retval; 2241 else 2242 rv = *retval; 2243 } 2244 return rv; 2245 } 2246 rsys_define(rumpns_sys_modctl); 2247 rsys_aliases(modctl,rump___sysimpl_modctl); 2248 2249 int rump___sysimpl__ksem_init(unsigned int, intptr_t *); 2250 int 2251 rump___sysimpl__ksem_init(unsigned int value, intptr_t * idp) 2252 { 2253 register_t retval[2]; 2254 int error = 0; 2255 int rv = -1; 2256 struct sys__ksem_init_args callarg; 2257 2258 SPARG(&callarg, value) = value; 2259 SPARG(&callarg, idp) = idp; 2260 2261 error = rsys_syscall(SYS__ksem_init, &callarg, sizeof(callarg), retval); 2262 rsys_seterrno(error); 2263 if (error == 0) { 2264 if (sizeof(int) > sizeof(register_t)) 2265 rv = *(int *)retval; 2266 else 2267 rv = *retval; 2268 } 2269 return rv; 2270 } 2271 rsys_define(rumpns_sys__ksem_init); 2272 rsys_aliases(_ksem_init,rump___sysimpl__ksem_init); 2273 2274 int rump___sysimpl__ksem_open(const char *, int, mode_t, unsigned int, intptr_t *); 2275 int 2276 rump___sysimpl__ksem_open(const char * name, int oflag, mode_t mode, unsigned int value, intptr_t * idp) 2277 { 2278 register_t retval[2]; 2279 int error = 0; 2280 int rv = -1; 2281 struct sys__ksem_open_args callarg; 2282 2283 SPARG(&callarg, name) = name; 2284 SPARG(&callarg, oflag) = oflag; 2285 SPARG(&callarg, mode) = mode; 2286 SPARG(&callarg, value) = value; 2287 SPARG(&callarg, idp) = idp; 2288 2289 error = rsys_syscall(SYS__ksem_open, &callarg, sizeof(callarg), retval); 2290 rsys_seterrno(error); 2291 if (error == 0) { 2292 if (sizeof(int) > sizeof(register_t)) 2293 rv = *(int *)retval; 2294 else 2295 rv = *retval; 2296 } 2297 return rv; 2298 } 2299 rsys_define(rumpns_sys__ksem_open); 2300 rsys_aliases(_ksem_open,rump___sysimpl__ksem_open); 2301 2302 int rump___sysimpl__ksem_unlink(const char *); 2303 int 2304 rump___sysimpl__ksem_unlink(const char * name) 2305 { 2306 register_t retval[2]; 2307 int error = 0; 2308 int rv = -1; 2309 struct sys__ksem_unlink_args callarg; 2310 2311 SPARG(&callarg, name) = name; 2312 2313 error = rsys_syscall(SYS__ksem_unlink, &callarg, sizeof(callarg), retval); 2314 rsys_seterrno(error); 2315 if (error == 0) { 2316 if (sizeof(int) > sizeof(register_t)) 2317 rv = *(int *)retval; 2318 else 2319 rv = *retval; 2320 } 2321 return rv; 2322 } 2323 rsys_define(rumpns_sys__ksem_unlink); 2324 rsys_aliases(_ksem_unlink,rump___sysimpl__ksem_unlink); 2325 2326 int rump___sysimpl__ksem_close(intptr_t); 2327 int 2328 rump___sysimpl__ksem_close(intptr_t id) 2329 { 2330 register_t retval[2]; 2331 int error = 0; 2332 int rv = -1; 2333 struct sys__ksem_close_args callarg; 2334 2335 SPARG(&callarg, id) = id; 2336 2337 error = rsys_syscall(SYS__ksem_close, &callarg, sizeof(callarg), retval); 2338 rsys_seterrno(error); 2339 if (error == 0) { 2340 if (sizeof(int) > sizeof(register_t)) 2341 rv = *(int *)retval; 2342 else 2343 rv = *retval; 2344 } 2345 return rv; 2346 } 2347 rsys_define(rumpns_sys__ksem_close); 2348 rsys_aliases(_ksem_close,rump___sysimpl__ksem_close); 2349 2350 int rump___sysimpl__ksem_post(intptr_t); 2351 int 2352 rump___sysimpl__ksem_post(intptr_t id) 2353 { 2354 register_t retval[2]; 2355 int error = 0; 2356 int rv = -1; 2357 struct sys__ksem_post_args callarg; 2358 2359 SPARG(&callarg, id) = id; 2360 2361 error = rsys_syscall(SYS__ksem_post, &callarg, sizeof(callarg), retval); 2362 rsys_seterrno(error); 2363 if (error == 0) { 2364 if (sizeof(int) > sizeof(register_t)) 2365 rv = *(int *)retval; 2366 else 2367 rv = *retval; 2368 } 2369 return rv; 2370 } 2371 rsys_define(rumpns_sys__ksem_post); 2372 rsys_aliases(_ksem_post,rump___sysimpl__ksem_post); 2373 2374 int rump___sysimpl__ksem_wait(intptr_t); 2375 int 2376 rump___sysimpl__ksem_wait(intptr_t id) 2377 { 2378 register_t retval[2]; 2379 int error = 0; 2380 int rv = -1; 2381 struct sys__ksem_wait_args callarg; 2382 2383 SPARG(&callarg, id) = id; 2384 2385 error = rsys_syscall(SYS__ksem_wait, &callarg, sizeof(callarg), retval); 2386 rsys_seterrno(error); 2387 if (error == 0) { 2388 if (sizeof(int) > sizeof(register_t)) 2389 rv = *(int *)retval; 2390 else 2391 rv = *retval; 2392 } 2393 return rv; 2394 } 2395 rsys_define(rumpns_sys__ksem_wait); 2396 rsys_aliases(_ksem_wait,rump___sysimpl__ksem_wait); 2397 2398 int rump___sysimpl__ksem_trywait(intptr_t); 2399 int 2400 rump___sysimpl__ksem_trywait(intptr_t id) 2401 { 2402 register_t retval[2]; 2403 int error = 0; 2404 int rv = -1; 2405 struct sys__ksem_trywait_args callarg; 2406 2407 SPARG(&callarg, id) = id; 2408 2409 error = rsys_syscall(SYS__ksem_trywait, &callarg, sizeof(callarg), retval); 2410 rsys_seterrno(error); 2411 if (error == 0) { 2412 if (sizeof(int) > sizeof(register_t)) 2413 rv = *(int *)retval; 2414 else 2415 rv = *retval; 2416 } 2417 return rv; 2418 } 2419 rsys_define(rumpns_sys__ksem_trywait); 2420 rsys_aliases(_ksem_trywait,rump___sysimpl__ksem_trywait); 2421 2422 int rump___sysimpl__ksem_getvalue(intptr_t, unsigned int *); 2423 int 2424 rump___sysimpl__ksem_getvalue(intptr_t id, unsigned int * value) 2425 { 2426 register_t retval[2]; 2427 int error = 0; 2428 int rv = -1; 2429 struct sys__ksem_getvalue_args callarg; 2430 2431 SPARG(&callarg, id) = id; 2432 SPARG(&callarg, value) = value; 2433 2434 error = rsys_syscall(SYS__ksem_getvalue, &callarg, sizeof(callarg), retval); 2435 rsys_seterrno(error); 2436 if (error == 0) { 2437 if (sizeof(int) > sizeof(register_t)) 2438 rv = *(int *)retval; 2439 else 2440 rv = *retval; 2441 } 2442 return rv; 2443 } 2444 rsys_define(rumpns_sys__ksem_getvalue); 2445 rsys_aliases(_ksem_getvalue,rump___sysimpl__ksem_getvalue); 2446 2447 int rump___sysimpl__ksem_destroy(intptr_t); 2448 int 2449 rump___sysimpl__ksem_destroy(intptr_t id) 2450 { 2451 register_t retval[2]; 2452 int error = 0; 2453 int rv = -1; 2454 struct sys__ksem_destroy_args callarg; 2455 2456 SPARG(&callarg, id) = id; 2457 2458 error = rsys_syscall(SYS__ksem_destroy, &callarg, sizeof(callarg), retval); 2459 rsys_seterrno(error); 2460 if (error == 0) { 2461 if (sizeof(int) > sizeof(register_t)) 2462 rv = *(int *)retval; 2463 else 2464 rv = *retval; 2465 } 2466 return rv; 2467 } 2468 rsys_define(rumpns_sys__ksem_destroy); 2469 rsys_aliases(_ksem_destroy,rump___sysimpl__ksem_destroy); 2470 2471 int rump___sysimpl__ksem_timedwait(intptr_t, const struct timespec *); 2472 int 2473 rump___sysimpl__ksem_timedwait(intptr_t id, const struct timespec * abstime) 2474 { 2475 register_t retval[2]; 2476 int error = 0; 2477 int rv = -1; 2478 struct sys__ksem_timedwait_args callarg; 2479 2480 SPARG(&callarg, id) = id; 2481 SPARG(&callarg, abstime) = abstime; 2482 2483 error = rsys_syscall(SYS__ksem_timedwait, &callarg, sizeof(callarg), retval); 2484 rsys_seterrno(error); 2485 if (error == 0) { 2486 if (sizeof(int) > sizeof(register_t)) 2487 rv = *(int *)retval; 2488 else 2489 rv = *retval; 2490 } 2491 return rv; 2492 } 2493 rsys_define(rumpns_sys__ksem_timedwait); 2494 rsys_aliases(_ksem_timedwait,rump___sysimpl__ksem_timedwait); 2495 2496 int rump___sysimpl_lchmod(const char *, mode_t); 2497 int 2498 rump___sysimpl_lchmod(const char * path, mode_t mode) 2499 { 2500 register_t retval[2]; 2501 int error = 0; 2502 int rv = -1; 2503 struct sys_lchmod_args callarg; 2504 2505 SPARG(&callarg, path) = path; 2506 SPARG(&callarg, mode) = mode; 2507 2508 error = rsys_syscall(SYS_lchmod, &callarg, sizeof(callarg), retval); 2509 rsys_seterrno(error); 2510 if (error == 0) { 2511 if (sizeof(int) > sizeof(register_t)) 2512 rv = *(int *)retval; 2513 else 2514 rv = *retval; 2515 } 2516 return rv; 2517 } 2518 rsys_define(rumpns_sys_lchmod); 2519 rsys_aliases(lchmod,rump___sysimpl_lchmod); 2520 2521 int rump___sysimpl_lchown(const char *, uid_t, gid_t); 2522 int 2523 rump___sysimpl_lchown(const char * path, uid_t uid, gid_t gid) 2524 { 2525 register_t retval[2]; 2526 int error = 0; 2527 int rv = -1; 2528 struct sys_lchown_args callarg; 2529 2530 SPARG(&callarg, path) = path; 2531 SPARG(&callarg, uid) = uid; 2532 SPARG(&callarg, gid) = gid; 2533 2534 error = rsys_syscall(SYS_lchown, &callarg, sizeof(callarg), retval); 2535 rsys_seterrno(error); 2536 if (error == 0) { 2537 if (sizeof(int) > sizeof(register_t)) 2538 rv = *(int *)retval; 2539 else 2540 rv = *retval; 2541 } 2542 return rv; 2543 } 2544 rsys_define(rumpns_sys_lchown); 2545 rsys_aliases(lchown,rump___sysimpl_lchown); 2546 2547 int rump___sysimpl_lutimes(const char *, const struct timeval *); 2548 int 2549 rump___sysimpl_lutimes(const char * path, const struct timeval * tptr) 2550 { 2551 register_t retval[2]; 2552 int error = 0; 2553 int rv = -1; 2554 struct compat_50_sys_lutimes_args callarg; 2555 2556 SPARG(&callarg, path) = path; 2557 SPARG(&callarg, tptr) = (const struct timeval50 *)tptr; 2558 2559 error = rsys_syscall(SYS_compat_50_lutimes, &callarg, sizeof(callarg), retval); 2560 rsys_seterrno(error); 2561 if (error == 0) { 2562 if (sizeof(int) > sizeof(register_t)) 2563 rv = *(int *)retval; 2564 else 2565 rv = *retval; 2566 } 2567 return rv; 2568 } 2569 rsys_define(rumpns_compat_50_sys_lutimes); 2570 rsys_aliases(compat_50_lutimes,rump___sysimpl_lutimes); 2571 2572 pid_t rump___sysimpl_getsid(pid_t); 2573 pid_t 2574 rump___sysimpl_getsid(pid_t pid) 2575 { 2576 register_t retval[2]; 2577 int error = 0; 2578 pid_t rv = -1; 2579 struct sys_getsid_args callarg; 2580 2581 SPARG(&callarg, pid) = pid; 2582 2583 error = rsys_syscall(SYS_getsid, &callarg, sizeof(callarg), retval); 2584 rsys_seterrno(error); 2585 if (error == 0) { 2586 if (sizeof(pid_t) > sizeof(register_t)) 2587 rv = *(pid_t *)retval; 2588 else 2589 rv = *retval; 2590 } 2591 return rv; 2592 } 2593 rsys_define(rumpns_sys_getsid); 2594 rsys_aliases(getsid,rump___sysimpl_getsid); 2595 2596 int rump___sysimpl_fktrace(int, int, int, pid_t); 2597 int 2598 rump___sysimpl_fktrace(int fd, int ops, int facs, pid_t pid) 2599 { 2600 register_t retval[2]; 2601 int error = 0; 2602 int rv = -1; 2603 struct sys_fktrace_args callarg; 2604 2605 SPARG(&callarg, fd) = fd; 2606 SPARG(&callarg, ops) = ops; 2607 SPARG(&callarg, facs) = facs; 2608 SPARG(&callarg, pid) = pid; 2609 2610 error = rsys_syscall(SYS_fktrace, &callarg, sizeof(callarg), retval); 2611 rsys_seterrno(error); 2612 if (error == 0) { 2613 if (sizeof(int) > sizeof(register_t)) 2614 rv = *(int *)retval; 2615 else 2616 rv = *retval; 2617 } 2618 return rv; 2619 } 2620 rsys_define(rumpns_sys_fktrace); 2621 rsys_aliases(fktrace,rump___sysimpl_fktrace); 2622 2623 ssize_t rump___sysimpl_preadv(int, const struct iovec *, int, off_t); 2624 ssize_t 2625 rump___sysimpl_preadv(int fd, const struct iovec * iovp, int iovcnt, off_t offset) 2626 { 2627 register_t retval[2]; 2628 int error = 0; 2629 ssize_t rv = -1; 2630 struct sys_preadv_args callarg; 2631 2632 SPARG(&callarg, fd) = fd; 2633 SPARG(&callarg, iovp) = iovp; 2634 SPARG(&callarg, iovcnt) = iovcnt; 2635 SPARG(&callarg, PAD) = 0; 2636 SPARG(&callarg, offset) = offset; 2637 2638 error = rsys_syscall(SYS_preadv, &callarg, sizeof(callarg), retval); 2639 rsys_seterrno(error); 2640 if (error == 0) { 2641 if (sizeof(ssize_t) > sizeof(register_t)) 2642 rv = *(ssize_t *)retval; 2643 else 2644 rv = *retval; 2645 } 2646 return rv; 2647 } 2648 rsys_define(rumpns_sys_preadv); 2649 rsys_aliases(preadv,rump___sysimpl_preadv); 2650 2651 ssize_t rump___sysimpl_pwritev(int, const struct iovec *, int, off_t); 2652 ssize_t 2653 rump___sysimpl_pwritev(int fd, const struct iovec * iovp, int iovcnt, off_t offset) 2654 { 2655 register_t retval[2]; 2656 int error = 0; 2657 ssize_t rv = -1; 2658 struct sys_pwritev_args callarg; 2659 2660 SPARG(&callarg, fd) = fd; 2661 SPARG(&callarg, iovp) = iovp; 2662 SPARG(&callarg, iovcnt) = iovcnt; 2663 SPARG(&callarg, PAD) = 0; 2664 SPARG(&callarg, offset) = offset; 2665 2666 error = rsys_syscall(SYS_pwritev, &callarg, sizeof(callarg), retval); 2667 rsys_seterrno(error); 2668 if (error == 0) { 2669 if (sizeof(ssize_t) > sizeof(register_t)) 2670 rv = *(ssize_t *)retval; 2671 else 2672 rv = *retval; 2673 } 2674 return rv; 2675 } 2676 rsys_define(rumpns_sys_pwritev); 2677 rsys_aliases(pwritev,rump___sysimpl_pwritev); 2678 2679 int rump___sysimpl___getcwd(char *, size_t); 2680 int 2681 rump___sysimpl___getcwd(char * bufp, size_t length) 2682 { 2683 register_t retval[2]; 2684 int error = 0; 2685 int rv = -1; 2686 struct sys___getcwd_args callarg; 2687 2688 SPARG(&callarg, bufp) = bufp; 2689 SPARG(&callarg, length) = length; 2690 2691 error = rsys_syscall(SYS___getcwd, &callarg, sizeof(callarg), retval); 2692 rsys_seterrno(error); 2693 if (error == 0) { 2694 if (sizeof(int) > sizeof(register_t)) 2695 rv = *(int *)retval; 2696 else 2697 rv = *retval; 2698 } 2699 return rv; 2700 } 2701 rsys_define(rumpns_sys___getcwd); 2702 rsys_aliases(__getcwd,rump___sysimpl___getcwd); 2703 2704 int rump___sysimpl_fchroot(int); 2705 int 2706 rump___sysimpl_fchroot(int fd) 2707 { 2708 register_t retval[2]; 2709 int error = 0; 2710 int rv = -1; 2711 struct sys_fchroot_args callarg; 2712 2713 SPARG(&callarg, fd) = fd; 2714 2715 error = rsys_syscall(SYS_fchroot, &callarg, sizeof(callarg), retval); 2716 rsys_seterrno(error); 2717 if (error == 0) { 2718 if (sizeof(int) > sizeof(register_t)) 2719 rv = *(int *)retval; 2720 else 2721 rv = *retval; 2722 } 2723 return rv; 2724 } 2725 rsys_define(rumpns_sys_fchroot); 2726 rsys_aliases(fchroot,rump___sysimpl_fchroot); 2727 2728 int rump___sysimpl_lchflags(const char *, u_long); 2729 int 2730 rump___sysimpl_lchflags(const char * path, u_long flags) 2731 { 2732 register_t retval[2]; 2733 int error = 0; 2734 int rv = -1; 2735 struct sys_lchflags_args callarg; 2736 2737 SPARG(&callarg, path) = path; 2738 SPARG(&callarg, flags) = flags; 2739 2740 error = rsys_syscall(SYS_lchflags, &callarg, sizeof(callarg), retval); 2741 rsys_seterrno(error); 2742 if (error == 0) { 2743 if (sizeof(int) > sizeof(register_t)) 2744 rv = *(int *)retval; 2745 else 2746 rv = *retval; 2747 } 2748 return rv; 2749 } 2750 rsys_define(rumpns_sys_lchflags); 2751 rsys_aliases(lchflags,rump___sysimpl_lchflags); 2752 2753 int rump___sysimpl_issetugid(void); 2754 int 2755 rump___sysimpl_issetugid(void ) 2756 { 2757 register_t retval[2]; 2758 int rv = -1; 2759 2760 rsys_syscall(SYS_issetugid, NULL, 0, retval); 2761 if (sizeof(int) > sizeof(register_t)) 2762 rv = *(int *)retval; 2763 else 2764 rv = *retval; 2765 return rv; 2766 } 2767 rsys_define(rumpns_sys_issetugid); 2768 rsys_aliases(issetugid,rump___sysimpl_issetugid); 2769 2770 int rump___sysimpl_kqueue(void); 2771 int 2772 rump___sysimpl_kqueue(void ) 2773 { 2774 register_t retval[2]; 2775 int error = 0; 2776 int rv = -1; 2777 2778 error = rsys_syscall(SYS_kqueue, NULL, 0, retval); 2779 rsys_seterrno(error); 2780 if (error == 0) { 2781 if (sizeof(int) > sizeof(register_t)) 2782 rv = *(int *)retval; 2783 else 2784 rv = *retval; 2785 } 2786 return rv; 2787 } 2788 rsys_define(rumpns_sys_kqueue); 2789 rsys_aliases(kqueue,rump___sysimpl_kqueue); 2790 2791 int rump___sysimpl_kevent(int, const struct kevent *, size_t, struct kevent *, size_t, const struct timespec *); 2792 int 2793 rump___sysimpl_kevent(int fd, const struct kevent * changelist, size_t nchanges, struct kevent * eventlist, size_t nevents, const struct timespec * timeout) 2794 { 2795 register_t retval[2]; 2796 int error = 0; 2797 int rv = -1; 2798 struct compat_50_sys_kevent_args callarg; 2799 2800 SPARG(&callarg, fd) = fd; 2801 SPARG(&callarg, changelist) = changelist; 2802 SPARG(&callarg, nchanges) = nchanges; 2803 SPARG(&callarg, eventlist) = eventlist; 2804 SPARG(&callarg, nevents) = nevents; 2805 SPARG(&callarg, timeout) = (const struct timespec50 *)timeout; 2806 2807 error = rsys_syscall(SYS_compat_50_kevent, &callarg, sizeof(callarg), retval); 2808 rsys_seterrno(error); 2809 if (error == 0) { 2810 if (sizeof(int) > sizeof(register_t)) 2811 rv = *(int *)retval; 2812 else 2813 rv = *retval; 2814 } 2815 return rv; 2816 } 2817 rsys_define(rumpns_compat_50_sys_kevent); 2818 rsys_aliases(compat_50_kevent,rump___sysimpl_kevent); 2819 2820 int rump___sysimpl_fsync_range(int, int, off_t, off_t); 2821 int 2822 rump___sysimpl_fsync_range(int fd, int flags, off_t start, off_t length) 2823 { 2824 register_t retval[2]; 2825 int error = 0; 2826 int rv = -1; 2827 struct sys_fsync_range_args callarg; 2828 2829 SPARG(&callarg, fd) = fd; 2830 SPARG(&callarg, flags) = flags; 2831 SPARG(&callarg, start) = start; 2832 SPARG(&callarg, length) = length; 2833 2834 error = rsys_syscall(SYS_fsync_range, &callarg, sizeof(callarg), retval); 2835 rsys_seterrno(error); 2836 if (error == 0) { 2837 if (sizeof(int) > sizeof(register_t)) 2838 rv = *(int *)retval; 2839 else 2840 rv = *retval; 2841 } 2842 return rv; 2843 } 2844 rsys_define(rumpns_sys_fsync_range); 2845 rsys_aliases(fsync_range,rump___sysimpl_fsync_range); 2846 2847 int rump___sysimpl_getvfsstat(struct statvfs *, size_t, int); 2848 int 2849 rump___sysimpl_getvfsstat(struct statvfs * buf, size_t bufsize, int flags) 2850 { 2851 register_t retval[2]; 2852 int error = 0; 2853 int rv = -1; 2854 struct sys_getvfsstat_args callarg; 2855 2856 SPARG(&callarg, buf) = buf; 2857 SPARG(&callarg, bufsize) = bufsize; 2858 SPARG(&callarg, flags) = flags; 2859 2860 error = rsys_syscall(SYS_getvfsstat, &callarg, sizeof(callarg), retval); 2861 rsys_seterrno(error); 2862 if (error == 0) { 2863 if (sizeof(int) > sizeof(register_t)) 2864 rv = *(int *)retval; 2865 else 2866 rv = *retval; 2867 } 2868 return rv; 2869 } 2870 rsys_define(rumpns_sys_getvfsstat); 2871 rsys_aliases(getvfsstat,rump___sysimpl_getvfsstat); 2872 2873 int rump___sysimpl_statvfs1(const char *, struct statvfs *, int); 2874 int 2875 rump___sysimpl_statvfs1(const char * path, struct statvfs * buf, int flags) 2876 { 2877 register_t retval[2]; 2878 int error = 0; 2879 int rv = -1; 2880 struct sys_statvfs1_args callarg; 2881 2882 SPARG(&callarg, path) = path; 2883 SPARG(&callarg, buf) = buf; 2884 SPARG(&callarg, flags) = flags; 2885 2886 error = rsys_syscall(SYS_statvfs1, &callarg, sizeof(callarg), retval); 2887 rsys_seterrno(error); 2888 if (error == 0) { 2889 if (sizeof(int) > sizeof(register_t)) 2890 rv = *(int *)retval; 2891 else 2892 rv = *retval; 2893 } 2894 return rv; 2895 } 2896 rsys_define(rumpns_sys_statvfs1); 2897 rsys_aliases(statvfs1,rump___sysimpl_statvfs1); 2898 2899 int rump___sysimpl_fstatvfs1(int, struct statvfs *, int); 2900 int 2901 rump___sysimpl_fstatvfs1(int fd, struct statvfs * buf, int flags) 2902 { 2903 register_t retval[2]; 2904 int error = 0; 2905 int rv = -1; 2906 struct sys_fstatvfs1_args callarg; 2907 2908 SPARG(&callarg, fd) = fd; 2909 SPARG(&callarg, buf) = buf; 2910 SPARG(&callarg, flags) = flags; 2911 2912 error = rsys_syscall(SYS_fstatvfs1, &callarg, sizeof(callarg), retval); 2913 rsys_seterrno(error); 2914 if (error == 0) { 2915 if (sizeof(int) > sizeof(register_t)) 2916 rv = *(int *)retval; 2917 else 2918 rv = *retval; 2919 } 2920 return rv; 2921 } 2922 rsys_define(rumpns_sys_fstatvfs1); 2923 rsys_aliases(fstatvfs1,rump___sysimpl_fstatvfs1); 2924 2925 int rump___sysimpl_extattrctl(const char *, int, const char *, int, const char *); 2926 int 2927 rump___sysimpl_extattrctl(const char * path, int cmd, const char * filename, int attrnamespace, const char * attrname) 2928 { 2929 register_t retval[2]; 2930 int error = 0; 2931 int rv = -1; 2932 struct sys_extattrctl_args callarg; 2933 2934 SPARG(&callarg, path) = path; 2935 SPARG(&callarg, cmd) = cmd; 2936 SPARG(&callarg, filename) = filename; 2937 SPARG(&callarg, attrnamespace) = attrnamespace; 2938 SPARG(&callarg, attrname) = attrname; 2939 2940 error = rsys_syscall(SYS_extattrctl, &callarg, sizeof(callarg), retval); 2941 rsys_seterrno(error); 2942 if (error == 0) { 2943 if (sizeof(int) > sizeof(register_t)) 2944 rv = *(int *)retval; 2945 else 2946 rv = *retval; 2947 } 2948 return rv; 2949 } 2950 rsys_define(rumpns_sys_extattrctl); 2951 rsys_aliases(extattrctl,rump___sysimpl_extattrctl); 2952 2953 int rump___sysimpl_extattr_set_file(const char *, int, const char *, const void *, size_t); 2954 int 2955 rump___sysimpl_extattr_set_file(const char * path, int attrnamespace, const char * attrname, const void * data, size_t nbytes) 2956 { 2957 register_t retval[2]; 2958 int error = 0; 2959 int rv = -1; 2960 struct sys_extattr_set_file_args callarg; 2961 2962 SPARG(&callarg, path) = path; 2963 SPARG(&callarg, attrnamespace) = attrnamespace; 2964 SPARG(&callarg, attrname) = attrname; 2965 SPARG(&callarg, data) = data; 2966 SPARG(&callarg, nbytes) = nbytes; 2967 2968 error = rsys_syscall(SYS_extattr_set_file, &callarg, sizeof(callarg), retval); 2969 rsys_seterrno(error); 2970 if (error == 0) { 2971 if (sizeof(int) > sizeof(register_t)) 2972 rv = *(int *)retval; 2973 else 2974 rv = *retval; 2975 } 2976 return rv; 2977 } 2978 rsys_define(rumpns_sys_extattr_set_file); 2979 rsys_aliases(extattr_set_file,rump___sysimpl_extattr_set_file); 2980 2981 ssize_t rump___sysimpl_extattr_get_file(const char *, int, const char *, void *, size_t); 2982 ssize_t 2983 rump___sysimpl_extattr_get_file(const char * path, int attrnamespace, const char * attrname, void * data, size_t nbytes) 2984 { 2985 register_t retval[2]; 2986 int error = 0; 2987 ssize_t rv = -1; 2988 struct sys_extattr_get_file_args callarg; 2989 2990 SPARG(&callarg, path) = path; 2991 SPARG(&callarg, attrnamespace) = attrnamespace; 2992 SPARG(&callarg, attrname) = attrname; 2993 SPARG(&callarg, data) = data; 2994 SPARG(&callarg, nbytes) = nbytes; 2995 2996 error = rsys_syscall(SYS_extattr_get_file, &callarg, sizeof(callarg), retval); 2997 rsys_seterrno(error); 2998 if (error == 0) { 2999 if (sizeof(ssize_t) > sizeof(register_t)) 3000 rv = *(ssize_t *)retval; 3001 else 3002 rv = *retval; 3003 } 3004 return rv; 3005 } 3006 rsys_define(rumpns_sys_extattr_get_file); 3007 rsys_aliases(extattr_get_file,rump___sysimpl_extattr_get_file); 3008 3009 int rump___sysimpl_extattr_delete_file(const char *, int, const char *); 3010 int 3011 rump___sysimpl_extattr_delete_file(const char * path, int attrnamespace, const char * attrname) 3012 { 3013 register_t retval[2]; 3014 int error = 0; 3015 int rv = -1; 3016 struct sys_extattr_delete_file_args callarg; 3017 3018 SPARG(&callarg, path) = path; 3019 SPARG(&callarg, attrnamespace) = attrnamespace; 3020 SPARG(&callarg, attrname) = attrname; 3021 3022 error = rsys_syscall(SYS_extattr_delete_file, &callarg, sizeof(callarg), retval); 3023 rsys_seterrno(error); 3024 if (error == 0) { 3025 if (sizeof(int) > sizeof(register_t)) 3026 rv = *(int *)retval; 3027 else 3028 rv = *retval; 3029 } 3030 return rv; 3031 } 3032 rsys_define(rumpns_sys_extattr_delete_file); 3033 rsys_aliases(extattr_delete_file,rump___sysimpl_extattr_delete_file); 3034 3035 int rump___sysimpl_extattr_set_fd(int, int, const char *, const void *, size_t); 3036 int 3037 rump___sysimpl_extattr_set_fd(int fd, int attrnamespace, const char * attrname, const void * data, size_t nbytes) 3038 { 3039 register_t retval[2]; 3040 int error = 0; 3041 int rv = -1; 3042 struct sys_extattr_set_fd_args callarg; 3043 3044 SPARG(&callarg, fd) = fd; 3045 SPARG(&callarg, attrnamespace) = attrnamespace; 3046 SPARG(&callarg, attrname) = attrname; 3047 SPARG(&callarg, data) = data; 3048 SPARG(&callarg, nbytes) = nbytes; 3049 3050 error = rsys_syscall(SYS_extattr_set_fd, &callarg, sizeof(callarg), retval); 3051 rsys_seterrno(error); 3052 if (error == 0) { 3053 if (sizeof(int) > sizeof(register_t)) 3054 rv = *(int *)retval; 3055 else 3056 rv = *retval; 3057 } 3058 return rv; 3059 } 3060 rsys_define(rumpns_sys_extattr_set_fd); 3061 rsys_aliases(extattr_set_fd,rump___sysimpl_extattr_set_fd); 3062 3063 ssize_t rump___sysimpl_extattr_get_fd(int, int, const char *, void *, size_t); 3064 ssize_t 3065 rump___sysimpl_extattr_get_fd(int fd, int attrnamespace, const char * attrname, void * data, size_t nbytes) 3066 { 3067 register_t retval[2]; 3068 int error = 0; 3069 ssize_t rv = -1; 3070 struct sys_extattr_get_fd_args callarg; 3071 3072 SPARG(&callarg, fd) = fd; 3073 SPARG(&callarg, attrnamespace) = attrnamespace; 3074 SPARG(&callarg, attrname) = attrname; 3075 SPARG(&callarg, data) = data; 3076 SPARG(&callarg, nbytes) = nbytes; 3077 3078 error = rsys_syscall(SYS_extattr_get_fd, &callarg, sizeof(callarg), retval); 3079 rsys_seterrno(error); 3080 if (error == 0) { 3081 if (sizeof(ssize_t) > sizeof(register_t)) 3082 rv = *(ssize_t *)retval; 3083 else 3084 rv = *retval; 3085 } 3086 return rv; 3087 } 3088 rsys_define(rumpns_sys_extattr_get_fd); 3089 rsys_aliases(extattr_get_fd,rump___sysimpl_extattr_get_fd); 3090 3091 int rump___sysimpl_extattr_delete_fd(int, int, const char *); 3092 int 3093 rump___sysimpl_extattr_delete_fd(int fd, int attrnamespace, const char * attrname) 3094 { 3095 register_t retval[2]; 3096 int error = 0; 3097 int rv = -1; 3098 struct sys_extattr_delete_fd_args callarg; 3099 3100 SPARG(&callarg, fd) = fd; 3101 SPARG(&callarg, attrnamespace) = attrnamespace; 3102 SPARG(&callarg, attrname) = attrname; 3103 3104 error = rsys_syscall(SYS_extattr_delete_fd, &callarg, sizeof(callarg), retval); 3105 rsys_seterrno(error); 3106 if (error == 0) { 3107 if (sizeof(int) > sizeof(register_t)) 3108 rv = *(int *)retval; 3109 else 3110 rv = *retval; 3111 } 3112 return rv; 3113 } 3114 rsys_define(rumpns_sys_extattr_delete_fd); 3115 rsys_aliases(extattr_delete_fd,rump___sysimpl_extattr_delete_fd); 3116 3117 int rump___sysimpl_extattr_set_link(const char *, int, const char *, const void *, size_t); 3118 int 3119 rump___sysimpl_extattr_set_link(const char * path, int attrnamespace, const char * attrname, const void * data, size_t nbytes) 3120 { 3121 register_t retval[2]; 3122 int error = 0; 3123 int rv = -1; 3124 struct sys_extattr_set_link_args callarg; 3125 3126 SPARG(&callarg, path) = path; 3127 SPARG(&callarg, attrnamespace) = attrnamespace; 3128 SPARG(&callarg, attrname) = attrname; 3129 SPARG(&callarg, data) = data; 3130 SPARG(&callarg, nbytes) = nbytes; 3131 3132 error = rsys_syscall(SYS_extattr_set_link, &callarg, sizeof(callarg), retval); 3133 rsys_seterrno(error); 3134 if (error == 0) { 3135 if (sizeof(int) > sizeof(register_t)) 3136 rv = *(int *)retval; 3137 else 3138 rv = *retval; 3139 } 3140 return rv; 3141 } 3142 rsys_define(rumpns_sys_extattr_set_link); 3143 rsys_aliases(extattr_set_link,rump___sysimpl_extattr_set_link); 3144 3145 ssize_t rump___sysimpl_extattr_get_link(const char *, int, const char *, void *, size_t); 3146 ssize_t 3147 rump___sysimpl_extattr_get_link(const char * path, int attrnamespace, const char * attrname, void * data, size_t nbytes) 3148 { 3149 register_t retval[2]; 3150 int error = 0; 3151 ssize_t rv = -1; 3152 struct sys_extattr_get_link_args callarg; 3153 3154 SPARG(&callarg, path) = path; 3155 SPARG(&callarg, attrnamespace) = attrnamespace; 3156 SPARG(&callarg, attrname) = attrname; 3157 SPARG(&callarg, data) = data; 3158 SPARG(&callarg, nbytes) = nbytes; 3159 3160 error = rsys_syscall(SYS_extattr_get_link, &callarg, sizeof(callarg), retval); 3161 rsys_seterrno(error); 3162 if (error == 0) { 3163 if (sizeof(ssize_t) > sizeof(register_t)) 3164 rv = *(ssize_t *)retval; 3165 else 3166 rv = *retval; 3167 } 3168 return rv; 3169 } 3170 rsys_define(rumpns_sys_extattr_get_link); 3171 rsys_aliases(extattr_get_link,rump___sysimpl_extattr_get_link); 3172 3173 int rump___sysimpl_extattr_delete_link(const char *, int, const char *); 3174 int 3175 rump___sysimpl_extattr_delete_link(const char * path, int attrnamespace, const char * attrname) 3176 { 3177 register_t retval[2]; 3178 int error = 0; 3179 int rv = -1; 3180 struct sys_extattr_delete_link_args callarg; 3181 3182 SPARG(&callarg, path) = path; 3183 SPARG(&callarg, attrnamespace) = attrnamespace; 3184 SPARG(&callarg, attrname) = attrname; 3185 3186 error = rsys_syscall(SYS_extattr_delete_link, &callarg, sizeof(callarg), retval); 3187 rsys_seterrno(error); 3188 if (error == 0) { 3189 if (sizeof(int) > sizeof(register_t)) 3190 rv = *(int *)retval; 3191 else 3192 rv = *retval; 3193 } 3194 return rv; 3195 } 3196 rsys_define(rumpns_sys_extattr_delete_link); 3197 rsys_aliases(extattr_delete_link,rump___sysimpl_extattr_delete_link); 3198 3199 ssize_t rump___sysimpl_extattr_list_fd(int, int, void *, size_t); 3200 ssize_t 3201 rump___sysimpl_extattr_list_fd(int fd, int attrnamespace, void * data, size_t nbytes) 3202 { 3203 register_t retval[2]; 3204 int error = 0; 3205 ssize_t rv = -1; 3206 struct sys_extattr_list_fd_args callarg; 3207 3208 SPARG(&callarg, fd) = fd; 3209 SPARG(&callarg, attrnamespace) = attrnamespace; 3210 SPARG(&callarg, data) = data; 3211 SPARG(&callarg, nbytes) = nbytes; 3212 3213 error = rsys_syscall(SYS_extattr_list_fd, &callarg, sizeof(callarg), retval); 3214 rsys_seterrno(error); 3215 if (error == 0) { 3216 if (sizeof(ssize_t) > sizeof(register_t)) 3217 rv = *(ssize_t *)retval; 3218 else 3219 rv = *retval; 3220 } 3221 return rv; 3222 } 3223 rsys_define(rumpns_sys_extattr_list_fd); 3224 rsys_aliases(extattr_list_fd,rump___sysimpl_extattr_list_fd); 3225 3226 ssize_t rump___sysimpl_extattr_list_file(const char *, int, void *, size_t); 3227 ssize_t 3228 rump___sysimpl_extattr_list_file(const char * path, int attrnamespace, void * data, size_t nbytes) 3229 { 3230 register_t retval[2]; 3231 int error = 0; 3232 ssize_t rv = -1; 3233 struct sys_extattr_list_file_args callarg; 3234 3235 SPARG(&callarg, path) = path; 3236 SPARG(&callarg, attrnamespace) = attrnamespace; 3237 SPARG(&callarg, data) = data; 3238 SPARG(&callarg, nbytes) = nbytes; 3239 3240 error = rsys_syscall(SYS_extattr_list_file, &callarg, sizeof(callarg), retval); 3241 rsys_seterrno(error); 3242 if (error == 0) { 3243 if (sizeof(ssize_t) > sizeof(register_t)) 3244 rv = *(ssize_t *)retval; 3245 else 3246 rv = *retval; 3247 } 3248 return rv; 3249 } 3250 rsys_define(rumpns_sys_extattr_list_file); 3251 rsys_aliases(extattr_list_file,rump___sysimpl_extattr_list_file); 3252 3253 ssize_t rump___sysimpl_extattr_list_link(const char *, int, void *, size_t); 3254 ssize_t 3255 rump___sysimpl_extattr_list_link(const char * path, int attrnamespace, void * data, size_t nbytes) 3256 { 3257 register_t retval[2]; 3258 int error = 0; 3259 ssize_t rv = -1; 3260 struct sys_extattr_list_link_args callarg; 3261 3262 SPARG(&callarg, path) = path; 3263 SPARG(&callarg, attrnamespace) = attrnamespace; 3264 SPARG(&callarg, data) = data; 3265 SPARG(&callarg, nbytes) = nbytes; 3266 3267 error = rsys_syscall(SYS_extattr_list_link, &callarg, sizeof(callarg), retval); 3268 rsys_seterrno(error); 3269 if (error == 0) { 3270 if (sizeof(ssize_t) > sizeof(register_t)) 3271 rv = *(ssize_t *)retval; 3272 else 3273 rv = *retval; 3274 } 3275 return rv; 3276 } 3277 rsys_define(rumpns_sys_extattr_list_link); 3278 rsys_aliases(extattr_list_link,rump___sysimpl_extattr_list_link); 3279 3280 int rump___sysimpl_pselect(int, fd_set *, fd_set *, fd_set *, const struct timespec *, const sigset_t *); 3281 int 3282 rump___sysimpl_pselect(int nd, fd_set * in, fd_set * ou, fd_set * ex, const struct timespec * ts, const sigset_t * mask) 3283 { 3284 register_t retval[2]; 3285 int error = 0; 3286 int rv = -1; 3287 struct compat_50_sys_pselect_args callarg; 3288 3289 SPARG(&callarg, nd) = nd; 3290 SPARG(&callarg, in) = in; 3291 SPARG(&callarg, ou) = ou; 3292 SPARG(&callarg, ex) = ex; 3293 SPARG(&callarg, ts) = (const struct timespec50 *)ts; 3294 SPARG(&callarg, mask) = mask; 3295 3296 error = rsys_syscall(SYS_compat_50_pselect, &callarg, sizeof(callarg), retval); 3297 rsys_seterrno(error); 3298 if (error == 0) { 3299 if (sizeof(int) > sizeof(register_t)) 3300 rv = *(int *)retval; 3301 else 3302 rv = *retval; 3303 } 3304 return rv; 3305 } 3306 rsys_define(rumpns_compat_50_sys_pselect); 3307 rsys_aliases(compat_50_pselect,rump___sysimpl_pselect); 3308 3309 int rump___sysimpl_pollts(struct pollfd *, u_int, const struct timespec *, const sigset_t *); 3310 int 3311 rump___sysimpl_pollts(struct pollfd * fds, u_int nfds, const struct timespec * ts, const sigset_t * mask) 3312 { 3313 register_t retval[2]; 3314 int error = 0; 3315 int rv = -1; 3316 struct compat_50_sys_pollts_args callarg; 3317 3318 SPARG(&callarg, fds) = fds; 3319 SPARG(&callarg, nfds) = nfds; 3320 SPARG(&callarg, ts) = (const struct timespec50 *)ts; 3321 SPARG(&callarg, mask) = mask; 3322 3323 error = rsys_syscall(SYS_compat_50_pollts, &callarg, sizeof(callarg), retval); 3324 rsys_seterrno(error); 3325 if (error == 0) { 3326 if (sizeof(int) > sizeof(register_t)) 3327 rv = *(int *)retval; 3328 else 3329 rv = *retval; 3330 } 3331 return rv; 3332 } 3333 rsys_define(rumpns_compat_50_sys_pollts); 3334 rsys_aliases(compat_50_pollts,rump___sysimpl_pollts); 3335 3336 int rump___sysimpl_setxattr(const char *, const char *, const void *, size_t, int); 3337 int 3338 rump___sysimpl_setxattr(const char * path, const char * name, const void * value, size_t size, int flags) 3339 { 3340 register_t retval[2]; 3341 int error = 0; 3342 int rv = -1; 3343 struct sys_setxattr_args callarg; 3344 3345 SPARG(&callarg, path) = path; 3346 SPARG(&callarg, name) = name; 3347 SPARG(&callarg, value) = value; 3348 SPARG(&callarg, size) = size; 3349 SPARG(&callarg, flags) = flags; 3350 3351 error = rsys_syscall(SYS_setxattr, &callarg, sizeof(callarg), retval); 3352 rsys_seterrno(error); 3353 if (error == 0) { 3354 if (sizeof(int) > sizeof(register_t)) 3355 rv = *(int *)retval; 3356 else 3357 rv = *retval; 3358 } 3359 return rv; 3360 } 3361 rsys_define(rumpns_sys_setxattr); 3362 rsys_aliases(setxattr,rump___sysimpl_setxattr); 3363 3364 int rump___sysimpl_lsetxattr(const char *, const char *, const void *, size_t, int); 3365 int 3366 rump___sysimpl_lsetxattr(const char * path, const char * name, const void * value, size_t size, int flags) 3367 { 3368 register_t retval[2]; 3369 int error = 0; 3370 int rv = -1; 3371 struct sys_lsetxattr_args callarg; 3372 3373 SPARG(&callarg, path) = path; 3374 SPARG(&callarg, name) = name; 3375 SPARG(&callarg, value) = value; 3376 SPARG(&callarg, size) = size; 3377 SPARG(&callarg, flags) = flags; 3378 3379 error = rsys_syscall(SYS_lsetxattr, &callarg, sizeof(callarg), retval); 3380 rsys_seterrno(error); 3381 if (error == 0) { 3382 if (sizeof(int) > sizeof(register_t)) 3383 rv = *(int *)retval; 3384 else 3385 rv = *retval; 3386 } 3387 return rv; 3388 } 3389 rsys_define(rumpns_sys_lsetxattr); 3390 rsys_aliases(lsetxattr,rump___sysimpl_lsetxattr); 3391 3392 int rump___sysimpl_fsetxattr(int, const char *, const void *, size_t, int); 3393 int 3394 rump___sysimpl_fsetxattr(int fd, const char * name, const void * value, size_t size, int flags) 3395 { 3396 register_t retval[2]; 3397 int error = 0; 3398 int rv = -1; 3399 struct sys_fsetxattr_args callarg; 3400 3401 SPARG(&callarg, fd) = fd; 3402 SPARG(&callarg, name) = name; 3403 SPARG(&callarg, value) = value; 3404 SPARG(&callarg, size) = size; 3405 SPARG(&callarg, flags) = flags; 3406 3407 error = rsys_syscall(SYS_fsetxattr, &callarg, sizeof(callarg), retval); 3408 rsys_seterrno(error); 3409 if (error == 0) { 3410 if (sizeof(int) > sizeof(register_t)) 3411 rv = *(int *)retval; 3412 else 3413 rv = *retval; 3414 } 3415 return rv; 3416 } 3417 rsys_define(rumpns_sys_fsetxattr); 3418 rsys_aliases(fsetxattr,rump___sysimpl_fsetxattr); 3419 3420 int rump___sysimpl_getxattr(const char *, const char *, void *, size_t); 3421 int 3422 rump___sysimpl_getxattr(const char * path, const char * name, void * value, size_t size) 3423 { 3424 register_t retval[2]; 3425 int error = 0; 3426 int rv = -1; 3427 struct sys_getxattr_args callarg; 3428 3429 SPARG(&callarg, path) = path; 3430 SPARG(&callarg, name) = name; 3431 SPARG(&callarg, value) = value; 3432 SPARG(&callarg, size) = size; 3433 3434 error = rsys_syscall(SYS_getxattr, &callarg, sizeof(callarg), retval); 3435 rsys_seterrno(error); 3436 if (error == 0) { 3437 if (sizeof(int) > sizeof(register_t)) 3438 rv = *(int *)retval; 3439 else 3440 rv = *retval; 3441 } 3442 return rv; 3443 } 3444 rsys_define(rumpns_sys_getxattr); 3445 rsys_aliases(getxattr,rump___sysimpl_getxattr); 3446 3447 int rump___sysimpl_lgetxattr(const char *, const char *, void *, size_t); 3448 int 3449 rump___sysimpl_lgetxattr(const char * path, const char * name, void * value, size_t size) 3450 { 3451 register_t retval[2]; 3452 int error = 0; 3453 int rv = -1; 3454 struct sys_lgetxattr_args callarg; 3455 3456 SPARG(&callarg, path) = path; 3457 SPARG(&callarg, name) = name; 3458 SPARG(&callarg, value) = value; 3459 SPARG(&callarg, size) = size; 3460 3461 error = rsys_syscall(SYS_lgetxattr, &callarg, sizeof(callarg), retval); 3462 rsys_seterrno(error); 3463 if (error == 0) { 3464 if (sizeof(int) > sizeof(register_t)) 3465 rv = *(int *)retval; 3466 else 3467 rv = *retval; 3468 } 3469 return rv; 3470 } 3471 rsys_define(rumpns_sys_lgetxattr); 3472 rsys_aliases(lgetxattr,rump___sysimpl_lgetxattr); 3473 3474 int rump___sysimpl_fgetxattr(int, const char *, void *, size_t); 3475 int 3476 rump___sysimpl_fgetxattr(int fd, const char * name, void * value, size_t size) 3477 { 3478 register_t retval[2]; 3479 int error = 0; 3480 int rv = -1; 3481 struct sys_fgetxattr_args callarg; 3482 3483 SPARG(&callarg, fd) = fd; 3484 SPARG(&callarg, name) = name; 3485 SPARG(&callarg, value) = value; 3486 SPARG(&callarg, size) = size; 3487 3488 error = rsys_syscall(SYS_fgetxattr, &callarg, sizeof(callarg), retval); 3489 rsys_seterrno(error); 3490 if (error == 0) { 3491 if (sizeof(int) > sizeof(register_t)) 3492 rv = *(int *)retval; 3493 else 3494 rv = *retval; 3495 } 3496 return rv; 3497 } 3498 rsys_define(rumpns_sys_fgetxattr); 3499 rsys_aliases(fgetxattr,rump___sysimpl_fgetxattr); 3500 3501 int rump___sysimpl_listxattr(const char *, char *, size_t); 3502 int 3503 rump___sysimpl_listxattr(const char * path, char * list, size_t size) 3504 { 3505 register_t retval[2]; 3506 int error = 0; 3507 int rv = -1; 3508 struct sys_listxattr_args callarg; 3509 3510 SPARG(&callarg, path) = path; 3511 SPARG(&callarg, list) = list; 3512 SPARG(&callarg, size) = size; 3513 3514 error = rsys_syscall(SYS_listxattr, &callarg, sizeof(callarg), retval); 3515 rsys_seterrno(error); 3516 if (error == 0) { 3517 if (sizeof(int) > sizeof(register_t)) 3518 rv = *(int *)retval; 3519 else 3520 rv = *retval; 3521 } 3522 return rv; 3523 } 3524 rsys_define(rumpns_sys_listxattr); 3525 rsys_aliases(listxattr,rump___sysimpl_listxattr); 3526 3527 int rump___sysimpl_llistxattr(const char *, char *, size_t); 3528 int 3529 rump___sysimpl_llistxattr(const char * path, char * list, size_t size) 3530 { 3531 register_t retval[2]; 3532 int error = 0; 3533 int rv = -1; 3534 struct sys_llistxattr_args callarg; 3535 3536 SPARG(&callarg, path) = path; 3537 SPARG(&callarg, list) = list; 3538 SPARG(&callarg, size) = size; 3539 3540 error = rsys_syscall(SYS_llistxattr, &callarg, sizeof(callarg), retval); 3541 rsys_seterrno(error); 3542 if (error == 0) { 3543 if (sizeof(int) > sizeof(register_t)) 3544 rv = *(int *)retval; 3545 else 3546 rv = *retval; 3547 } 3548 return rv; 3549 } 3550 rsys_define(rumpns_sys_llistxattr); 3551 rsys_aliases(llistxattr,rump___sysimpl_llistxattr); 3552 3553 int rump___sysimpl_flistxattr(int, char *, size_t); 3554 int 3555 rump___sysimpl_flistxattr(int fd, char * list, size_t size) 3556 { 3557 register_t retval[2]; 3558 int error = 0; 3559 int rv = -1; 3560 struct sys_flistxattr_args callarg; 3561 3562 SPARG(&callarg, fd) = fd; 3563 SPARG(&callarg, list) = list; 3564 SPARG(&callarg, size) = size; 3565 3566 error = rsys_syscall(SYS_flistxattr, &callarg, sizeof(callarg), retval); 3567 rsys_seterrno(error); 3568 if (error == 0) { 3569 if (sizeof(int) > sizeof(register_t)) 3570 rv = *(int *)retval; 3571 else 3572 rv = *retval; 3573 } 3574 return rv; 3575 } 3576 rsys_define(rumpns_sys_flistxattr); 3577 rsys_aliases(flistxattr,rump___sysimpl_flistxattr); 3578 3579 int rump___sysimpl_removexattr(const char *, const char *); 3580 int 3581 rump___sysimpl_removexattr(const char * path, const char * name) 3582 { 3583 register_t retval[2]; 3584 int error = 0; 3585 int rv = -1; 3586 struct sys_removexattr_args callarg; 3587 3588 SPARG(&callarg, path) = path; 3589 SPARG(&callarg, name) = name; 3590 3591 error = rsys_syscall(SYS_removexattr, &callarg, sizeof(callarg), retval); 3592 rsys_seterrno(error); 3593 if (error == 0) { 3594 if (sizeof(int) > sizeof(register_t)) 3595 rv = *(int *)retval; 3596 else 3597 rv = *retval; 3598 } 3599 return rv; 3600 } 3601 rsys_define(rumpns_sys_removexattr); 3602 rsys_aliases(removexattr,rump___sysimpl_removexattr); 3603 3604 int rump___sysimpl_lremovexattr(const char *, const char *); 3605 int 3606 rump___sysimpl_lremovexattr(const char * path, const char * name) 3607 { 3608 register_t retval[2]; 3609 int error = 0; 3610 int rv = -1; 3611 struct sys_lremovexattr_args callarg; 3612 3613 SPARG(&callarg, path) = path; 3614 SPARG(&callarg, name) = name; 3615 3616 error = rsys_syscall(SYS_lremovexattr, &callarg, sizeof(callarg), retval); 3617 rsys_seterrno(error); 3618 if (error == 0) { 3619 if (sizeof(int) > sizeof(register_t)) 3620 rv = *(int *)retval; 3621 else 3622 rv = *retval; 3623 } 3624 return rv; 3625 } 3626 rsys_define(rumpns_sys_lremovexattr); 3627 rsys_aliases(lremovexattr,rump___sysimpl_lremovexattr); 3628 3629 int rump___sysimpl_fremovexattr(int, const char *); 3630 int 3631 rump___sysimpl_fremovexattr(int fd, const char * name) 3632 { 3633 register_t retval[2]; 3634 int error = 0; 3635 int rv = -1; 3636 struct sys_fremovexattr_args callarg; 3637 3638 SPARG(&callarg, fd) = fd; 3639 SPARG(&callarg, name) = name; 3640 3641 error = rsys_syscall(SYS_fremovexattr, &callarg, sizeof(callarg), retval); 3642 rsys_seterrno(error); 3643 if (error == 0) { 3644 if (sizeof(int) > sizeof(register_t)) 3645 rv = *(int *)retval; 3646 else 3647 rv = *retval; 3648 } 3649 return rv; 3650 } 3651 rsys_define(rumpns_sys_fremovexattr); 3652 rsys_aliases(fremovexattr,rump___sysimpl_fremovexattr); 3653 3654 int rump___sysimpl_stat30(const char *, struct stat *); 3655 int 3656 rump___sysimpl_stat30(const char * path, struct stat * ub) 3657 { 3658 register_t retval[2]; 3659 int error = 0; 3660 int rv = -1; 3661 struct compat_50_sys___stat30_args callarg; 3662 3663 SPARG(&callarg, path) = path; 3664 SPARG(&callarg, ub) = (struct stat30 *)ub; 3665 3666 error = rsys_syscall(SYS_compat_50___stat30, &callarg, sizeof(callarg), retval); 3667 rsys_seterrno(error); 3668 if (error == 0) { 3669 if (sizeof(int) > sizeof(register_t)) 3670 rv = *(int *)retval; 3671 else 3672 rv = *retval; 3673 } 3674 return rv; 3675 } 3676 rsys_define(rumpns_compat_50_sys___stat30); 3677 rsys_aliases(compat_50___stat30,rump___sysimpl_stat30); 3678 3679 int rump___sysimpl_fstat30(int, struct stat *); 3680 int 3681 rump___sysimpl_fstat30(int fd, struct stat * sb) 3682 { 3683 register_t retval[2]; 3684 int error = 0; 3685 int rv = -1; 3686 struct compat_50_sys___fstat30_args callarg; 3687 3688 SPARG(&callarg, fd) = fd; 3689 SPARG(&callarg, sb) = (struct stat30 *)sb; 3690 3691 error = rsys_syscall(SYS_compat_50___fstat30, &callarg, sizeof(callarg), retval); 3692 rsys_seterrno(error); 3693 if (error == 0) { 3694 if (sizeof(int) > sizeof(register_t)) 3695 rv = *(int *)retval; 3696 else 3697 rv = *retval; 3698 } 3699 return rv; 3700 } 3701 rsys_define(rumpns_compat_50_sys___fstat30); 3702 rsys_aliases(compat_50___fstat30,rump___sysimpl_fstat30); 3703 3704 int rump___sysimpl_lstat30(const char *, struct stat *); 3705 int 3706 rump___sysimpl_lstat30(const char * path, struct stat * ub) 3707 { 3708 register_t retval[2]; 3709 int error = 0; 3710 int rv = -1; 3711 struct compat_50_sys___lstat30_args callarg; 3712 3713 SPARG(&callarg, path) = path; 3714 SPARG(&callarg, ub) = (struct stat30 *)ub; 3715 3716 error = rsys_syscall(SYS_compat_50___lstat30, &callarg, sizeof(callarg), retval); 3717 rsys_seterrno(error); 3718 if (error == 0) { 3719 if (sizeof(int) > sizeof(register_t)) 3720 rv = *(int *)retval; 3721 else 3722 rv = *retval; 3723 } 3724 return rv; 3725 } 3726 rsys_define(rumpns_compat_50_sys___lstat30); 3727 rsys_aliases(compat_50___lstat30,rump___sysimpl_lstat30); 3728 3729 int rump___sysimpl_getdents30(int, char *, size_t); 3730 int 3731 rump___sysimpl_getdents30(int fd, char * buf, size_t count) 3732 { 3733 register_t retval[2]; 3734 int error = 0; 3735 int rv = -1; 3736 struct sys___getdents30_args callarg; 3737 3738 SPARG(&callarg, fd) = fd; 3739 SPARG(&callarg, buf) = buf; 3740 SPARG(&callarg, count) = count; 3741 3742 error = rsys_syscall(SYS___getdents30, &callarg, sizeof(callarg), retval); 3743 rsys_seterrno(error); 3744 if (error == 0) { 3745 if (sizeof(int) > sizeof(register_t)) 3746 rv = *(int *)retval; 3747 else 3748 rv = *retval; 3749 } 3750 return rv; 3751 } 3752 rsys_define(rumpns_sys___getdents30); 3753 rsys_aliases(__getdents30,rump___sysimpl_getdents30); 3754 3755 int rump___sysimpl_socket30(int, int, int); 3756 int 3757 rump___sysimpl_socket30(int domain, int type, int protocol) 3758 { 3759 register_t retval[2]; 3760 int error = 0; 3761 int rv = -1; 3762 struct sys___socket30_args callarg; 3763 3764 SPARG(&callarg, domain) = domain; 3765 SPARG(&callarg, type) = type; 3766 SPARG(&callarg, protocol) = protocol; 3767 3768 error = rsys_syscall(SYS___socket30, &callarg, sizeof(callarg), retval); 3769 rsys_seterrno(error); 3770 if (error == 0) { 3771 if (sizeof(int) > sizeof(register_t)) 3772 rv = *(int *)retval; 3773 else 3774 rv = *retval; 3775 } 3776 return rv; 3777 } 3778 rsys_define(rumpns_sys___socket30); 3779 rsys_aliases(__socket30,rump___sysimpl_socket30); 3780 3781 int rump___sysimpl_getfh30(const char *, void *, size_t *); 3782 int 3783 rump___sysimpl_getfh30(const char * fname, void * fhp, size_t * fh_size) 3784 { 3785 register_t retval[2]; 3786 int error = 0; 3787 int rv = -1; 3788 struct sys___getfh30_args callarg; 3789 3790 SPARG(&callarg, fname) = fname; 3791 SPARG(&callarg, fhp) = fhp; 3792 SPARG(&callarg, fh_size) = fh_size; 3793 3794 error = rsys_syscall(SYS___getfh30, &callarg, sizeof(callarg), retval); 3795 rsys_seterrno(error); 3796 if (error == 0) { 3797 if (sizeof(int) > sizeof(register_t)) 3798 rv = *(int *)retval; 3799 else 3800 rv = *retval; 3801 } 3802 return rv; 3803 } 3804 rsys_define(rumpns_sys___getfh30); 3805 rsys_aliases(__getfh30,rump___sysimpl_getfh30); 3806 3807 int rump___sysimpl_fhopen40(const void *, size_t, int); 3808 int 3809 rump___sysimpl_fhopen40(const void * fhp, size_t fh_size, int flags) 3810 { 3811 register_t retval[2]; 3812 int error = 0; 3813 int rv = -1; 3814 struct sys___fhopen40_args callarg; 3815 3816 SPARG(&callarg, fhp) = fhp; 3817 SPARG(&callarg, fh_size) = fh_size; 3818 SPARG(&callarg, flags) = flags; 3819 3820 error = rsys_syscall(SYS___fhopen40, &callarg, sizeof(callarg), retval); 3821 rsys_seterrno(error); 3822 if (error == 0) { 3823 if (sizeof(int) > sizeof(register_t)) 3824 rv = *(int *)retval; 3825 else 3826 rv = *retval; 3827 } 3828 return rv; 3829 } 3830 rsys_define(rumpns_sys___fhopen40); 3831 rsys_aliases(__fhopen40,rump___sysimpl_fhopen40); 3832 3833 int rump___sysimpl_fhstatvfs140(const void *, size_t, struct statvfs *, int); 3834 int 3835 rump___sysimpl_fhstatvfs140(const void * fhp, size_t fh_size, struct statvfs * buf, int flags) 3836 { 3837 register_t retval[2]; 3838 int error = 0; 3839 int rv = -1; 3840 struct sys___fhstatvfs140_args callarg; 3841 3842 SPARG(&callarg, fhp) = fhp; 3843 SPARG(&callarg, fh_size) = fh_size; 3844 SPARG(&callarg, buf) = buf; 3845 SPARG(&callarg, flags) = flags; 3846 3847 error = rsys_syscall(SYS___fhstatvfs140, &callarg, sizeof(callarg), retval); 3848 rsys_seterrno(error); 3849 if (error == 0) { 3850 if (sizeof(int) > sizeof(register_t)) 3851 rv = *(int *)retval; 3852 else 3853 rv = *retval; 3854 } 3855 return rv; 3856 } 3857 rsys_define(rumpns_sys___fhstatvfs140); 3858 rsys_aliases(__fhstatvfs140,rump___sysimpl_fhstatvfs140); 3859 3860 int rump___sysimpl_fhstat40(const void *, size_t, struct stat *); 3861 int 3862 rump___sysimpl_fhstat40(const void * fhp, size_t fh_size, struct stat * sb) 3863 { 3864 register_t retval[2]; 3865 int error = 0; 3866 int rv = -1; 3867 struct compat_50_sys___fhstat40_args callarg; 3868 3869 SPARG(&callarg, fhp) = fhp; 3870 SPARG(&callarg, fh_size) = fh_size; 3871 SPARG(&callarg, sb) = (struct stat30 *)sb; 3872 3873 error = rsys_syscall(SYS_compat_50___fhstat40, &callarg, sizeof(callarg), retval); 3874 rsys_seterrno(error); 3875 if (error == 0) { 3876 if (sizeof(int) > sizeof(register_t)) 3877 rv = *(int *)retval; 3878 else 3879 rv = *retval; 3880 } 3881 return rv; 3882 } 3883 rsys_define(rumpns_compat_50_sys___fhstat40); 3884 rsys_aliases(compat_50___fhstat40,rump___sysimpl_fhstat40); 3885 3886 int rump___sysimpl_mount50(const char *, const char *, int, void *, size_t); 3887 int 3888 rump___sysimpl_mount50(const char * type, const char * path, int flags, void * data, size_t data_len) 3889 { 3890 register_t retval[2]; 3891 int error = 0; 3892 int rv = -1; 3893 struct sys___mount50_args callarg; 3894 3895 SPARG(&callarg, type) = type; 3896 SPARG(&callarg, path) = path; 3897 SPARG(&callarg, flags) = flags; 3898 SPARG(&callarg, data) = data; 3899 SPARG(&callarg, data_len) = data_len; 3900 3901 error = rsys_syscall(SYS___mount50, &callarg, sizeof(callarg), retval); 3902 rsys_seterrno(error); 3903 if (error == 0) { 3904 if (sizeof(int) > sizeof(register_t)) 3905 rv = *(int *)retval; 3906 else 3907 rv = *retval; 3908 } 3909 return rv; 3910 } 3911 rsys_define(rumpns_sys___mount50); 3912 rsys_aliases(__mount50,rump___sysimpl_mount50); 3913 3914 int rump___sysimpl_posix_fadvise50(int, off_t, off_t, int); 3915 int 3916 rump___sysimpl_posix_fadvise50(int fd, off_t offset, off_t len, int advice) 3917 { 3918 register_t retval[2]; 3919 int rv = -1; 3920 struct sys___posix_fadvise50_args callarg; 3921 3922 SPARG(&callarg, fd) = fd; 3923 SPARG(&callarg, PAD) = 0; 3924 SPARG(&callarg, offset) = offset; 3925 SPARG(&callarg, len) = len; 3926 SPARG(&callarg, advice) = advice; 3927 3928 rsys_syscall(SYS___posix_fadvise50, &callarg, sizeof(callarg), retval); 3929 if (sizeof(int) > sizeof(register_t)) 3930 rv = *(int *)retval; 3931 else 3932 rv = *retval; 3933 return rv; 3934 } 3935 rsys_define(rumpns_sys___posix_fadvise50); 3936 rsys_aliases(__posix_fadvise50,rump___sysimpl_posix_fadvise50); 3937 3938 int rump___sysimpl_select50(int, fd_set *, fd_set *, fd_set *, struct timeval *); 3939 int 3940 rump___sysimpl_select50(int nd, fd_set * in, fd_set * ou, fd_set * ex, struct timeval * tv) 3941 { 3942 register_t retval[2]; 3943 int error = 0; 3944 int rv = -1; 3945 struct sys___select50_args callarg; 3946 3947 SPARG(&callarg, nd) = nd; 3948 SPARG(&callarg, in) = in; 3949 SPARG(&callarg, ou) = ou; 3950 SPARG(&callarg, ex) = ex; 3951 SPARG(&callarg, tv) = tv; 3952 3953 error = rsys_syscall(SYS___select50, &callarg, sizeof(callarg), retval); 3954 rsys_seterrno(error); 3955 if (error == 0) { 3956 if (sizeof(int) > sizeof(register_t)) 3957 rv = *(int *)retval; 3958 else 3959 rv = *retval; 3960 } 3961 return rv; 3962 } 3963 rsys_define(rumpns_sys___select50); 3964 rsys_aliases(__select50,rump___sysimpl_select50); 3965 3966 int rump___sysimpl_utimes50(const char *, const struct timeval *); 3967 int 3968 rump___sysimpl_utimes50(const char * path, const struct timeval * tptr) 3969 { 3970 register_t retval[2]; 3971 int error = 0; 3972 int rv = -1; 3973 struct sys___utimes50_args callarg; 3974 3975 SPARG(&callarg, path) = path; 3976 SPARG(&callarg, tptr) = tptr; 3977 3978 error = rsys_syscall(SYS___utimes50, &callarg, sizeof(callarg), retval); 3979 rsys_seterrno(error); 3980 if (error == 0) { 3981 if (sizeof(int) > sizeof(register_t)) 3982 rv = *(int *)retval; 3983 else 3984 rv = *retval; 3985 } 3986 return rv; 3987 } 3988 rsys_define(rumpns_sys___utimes50); 3989 rsys_aliases(__utimes50,rump___sysimpl_utimes50); 3990 3991 int rump___sysimpl_futimes50(int, const struct timeval *); 3992 int 3993 rump___sysimpl_futimes50(int fd, const struct timeval * tptr) 3994 { 3995 register_t retval[2]; 3996 int error = 0; 3997 int rv = -1; 3998 struct sys___futimes50_args callarg; 3999 4000 SPARG(&callarg, fd) = fd; 4001 SPARG(&callarg, tptr) = tptr; 4002 4003 error = rsys_syscall(SYS___futimes50, &callarg, sizeof(callarg), retval); 4004 rsys_seterrno(error); 4005 if (error == 0) { 4006 if (sizeof(int) > sizeof(register_t)) 4007 rv = *(int *)retval; 4008 else 4009 rv = *retval; 4010 } 4011 return rv; 4012 } 4013 rsys_define(rumpns_sys___futimes50); 4014 rsys_aliases(__futimes50,rump___sysimpl_futimes50); 4015 4016 int rump___sysimpl_lutimes50(const char *, const struct timeval *); 4017 int 4018 rump___sysimpl_lutimes50(const char * path, const struct timeval * tptr) 4019 { 4020 register_t retval[2]; 4021 int error = 0; 4022 int rv = -1; 4023 struct sys___lutimes50_args callarg; 4024 4025 SPARG(&callarg, path) = path; 4026 SPARG(&callarg, tptr) = tptr; 4027 4028 error = rsys_syscall(SYS___lutimes50, &callarg, sizeof(callarg), retval); 4029 rsys_seterrno(error); 4030 if (error == 0) { 4031 if (sizeof(int) > sizeof(register_t)) 4032 rv = *(int *)retval; 4033 else 4034 rv = *retval; 4035 } 4036 return rv; 4037 } 4038 rsys_define(rumpns_sys___lutimes50); 4039 rsys_aliases(__lutimes50,rump___sysimpl_lutimes50); 4040 4041 int rump___sysimpl_kevent50(int, const struct kevent *, size_t, struct kevent *, size_t, const struct timespec *); 4042 int 4043 rump___sysimpl_kevent50(int fd, const struct kevent * changelist, size_t nchanges, struct kevent * eventlist, size_t nevents, const struct timespec * timeout) 4044 { 4045 register_t retval[2]; 4046 int error = 0; 4047 int rv = -1; 4048 struct sys___kevent50_args callarg; 4049 4050 SPARG(&callarg, fd) = fd; 4051 SPARG(&callarg, changelist) = changelist; 4052 SPARG(&callarg, nchanges) = nchanges; 4053 SPARG(&callarg, eventlist) = eventlist; 4054 SPARG(&callarg, nevents) = nevents; 4055 SPARG(&callarg, timeout) = timeout; 4056 4057 error = rsys_syscall(SYS___kevent50, &callarg, sizeof(callarg), retval); 4058 rsys_seterrno(error); 4059 if (error == 0) { 4060 if (sizeof(int) > sizeof(register_t)) 4061 rv = *(int *)retval; 4062 else 4063 rv = *retval; 4064 } 4065 return rv; 4066 } 4067 rsys_define(rumpns_sys___kevent50); 4068 rsys_aliases(__kevent50,rump___sysimpl_kevent50); 4069 4070 int rump___sysimpl_pselect50(int, fd_set *, fd_set *, fd_set *, const struct timespec *, const sigset_t *); 4071 int 4072 rump___sysimpl_pselect50(int nd, fd_set * in, fd_set * ou, fd_set * ex, const struct timespec * ts, const sigset_t * mask) 4073 { 4074 register_t retval[2]; 4075 int error = 0; 4076 int rv = -1; 4077 struct sys___pselect50_args callarg; 4078 4079 SPARG(&callarg, nd) = nd; 4080 SPARG(&callarg, in) = in; 4081 SPARG(&callarg, ou) = ou; 4082 SPARG(&callarg, ex) = ex; 4083 SPARG(&callarg, ts) = ts; 4084 SPARG(&callarg, mask) = mask; 4085 4086 error = rsys_syscall(SYS___pselect50, &callarg, sizeof(callarg), retval); 4087 rsys_seterrno(error); 4088 if (error == 0) { 4089 if (sizeof(int) > sizeof(register_t)) 4090 rv = *(int *)retval; 4091 else 4092 rv = *retval; 4093 } 4094 return rv; 4095 } 4096 rsys_define(rumpns_sys___pselect50); 4097 rsys_aliases(__pselect50,rump___sysimpl_pselect50); 4098 4099 int rump___sysimpl_pollts50(struct pollfd *, u_int, const struct timespec *, const sigset_t *); 4100 int 4101 rump___sysimpl_pollts50(struct pollfd * fds, u_int nfds, const struct timespec * ts, const sigset_t * mask) 4102 { 4103 register_t retval[2]; 4104 int error = 0; 4105 int rv = -1; 4106 struct sys___pollts50_args callarg; 4107 4108 SPARG(&callarg, fds) = fds; 4109 SPARG(&callarg, nfds) = nfds; 4110 SPARG(&callarg, ts) = ts; 4111 SPARG(&callarg, mask) = mask; 4112 4113 error = rsys_syscall(SYS___pollts50, &callarg, sizeof(callarg), retval); 4114 rsys_seterrno(error); 4115 if (error == 0) { 4116 if (sizeof(int) > sizeof(register_t)) 4117 rv = *(int *)retval; 4118 else 4119 rv = *retval; 4120 } 4121 return rv; 4122 } 4123 rsys_define(rumpns_sys___pollts50); 4124 rsys_aliases(__pollts50,rump___sysimpl_pollts50); 4125 4126 int rump___sysimpl_stat50(const char *, struct stat *); 4127 int 4128 rump___sysimpl_stat50(const char * path, struct stat * ub) 4129 { 4130 register_t retval[2]; 4131 int error = 0; 4132 int rv = -1; 4133 struct sys___stat50_args callarg; 4134 4135 SPARG(&callarg, path) = path; 4136 SPARG(&callarg, ub) = ub; 4137 4138 error = rsys_syscall(SYS___stat50, &callarg, sizeof(callarg), retval); 4139 rsys_seterrno(error); 4140 if (error == 0) { 4141 if (sizeof(int) > sizeof(register_t)) 4142 rv = *(int *)retval; 4143 else 4144 rv = *retval; 4145 } 4146 return rv; 4147 } 4148 rsys_define(rumpns_sys___stat50); 4149 rsys_aliases(__stat50,rump___sysimpl_stat50); 4150 4151 int rump___sysimpl_fstat50(int, struct stat *); 4152 int 4153 rump___sysimpl_fstat50(int fd, struct stat * sb) 4154 { 4155 register_t retval[2]; 4156 int error = 0; 4157 int rv = -1; 4158 struct sys___fstat50_args callarg; 4159 4160 SPARG(&callarg, fd) = fd; 4161 SPARG(&callarg, sb) = sb; 4162 4163 error = rsys_syscall(SYS___fstat50, &callarg, sizeof(callarg), retval); 4164 rsys_seterrno(error); 4165 if (error == 0) { 4166 if (sizeof(int) > sizeof(register_t)) 4167 rv = *(int *)retval; 4168 else 4169 rv = *retval; 4170 } 4171 return rv; 4172 } 4173 rsys_define(rumpns_sys___fstat50); 4174 rsys_aliases(__fstat50,rump___sysimpl_fstat50); 4175 4176 int rump___sysimpl_lstat50(const char *, struct stat *); 4177 int 4178 rump___sysimpl_lstat50(const char * path, struct stat * ub) 4179 { 4180 register_t retval[2]; 4181 int error = 0; 4182 int rv = -1; 4183 struct sys___lstat50_args callarg; 4184 4185 SPARG(&callarg, path) = path; 4186 SPARG(&callarg, ub) = ub; 4187 4188 error = rsys_syscall(SYS___lstat50, &callarg, sizeof(callarg), retval); 4189 rsys_seterrno(error); 4190 if (error == 0) { 4191 if (sizeof(int) > sizeof(register_t)) 4192 rv = *(int *)retval; 4193 else 4194 rv = *retval; 4195 } 4196 return rv; 4197 } 4198 rsys_define(rumpns_sys___lstat50); 4199 rsys_aliases(__lstat50,rump___sysimpl_lstat50); 4200 4201 int rump___sysimpl_mknod50(const char *, mode_t, dev_t); 4202 int 4203 rump___sysimpl_mknod50(const char * path, mode_t mode, dev_t dev) 4204 { 4205 register_t retval[2]; 4206 int error = 0; 4207 int rv = -1; 4208 struct sys___mknod50_args callarg; 4209 4210 SPARG(&callarg, path) = path; 4211 SPARG(&callarg, mode) = mode; 4212 SPARG(&callarg, dev) = dev; 4213 4214 error = rsys_syscall(SYS___mknod50, &callarg, sizeof(callarg), retval); 4215 rsys_seterrno(error); 4216 if (error == 0) { 4217 if (sizeof(int) > sizeof(register_t)) 4218 rv = *(int *)retval; 4219 else 4220 rv = *retval; 4221 } 4222 return rv; 4223 } 4224 rsys_define(rumpns_sys___mknod50); 4225 rsys_aliases(__mknod50,rump___sysimpl_mknod50); 4226 4227 int rump___sysimpl_fhstat50(const void *, size_t, struct stat *); 4228 int 4229 rump___sysimpl_fhstat50(const void * fhp, size_t fh_size, struct stat * sb) 4230 { 4231 register_t retval[2]; 4232 int error = 0; 4233 int rv = -1; 4234 struct sys___fhstat50_args callarg; 4235 4236 SPARG(&callarg, fhp) = fhp; 4237 SPARG(&callarg, fh_size) = fh_size; 4238 SPARG(&callarg, sb) = sb; 4239 4240 error = rsys_syscall(SYS___fhstat50, &callarg, sizeof(callarg), retval); 4241 rsys_seterrno(error); 4242 if (error == 0) { 4243 if (sizeof(int) > sizeof(register_t)) 4244 rv = *(int *)retval; 4245 else 4246 rv = *retval; 4247 } 4248 return rv; 4249 } 4250 rsys_define(rumpns_sys___fhstat50); 4251 rsys_aliases(__fhstat50,rump___sysimpl_fhstat50); 4252 4253 int rump___sysimpl_pipe2(int *, int); 4254 int 4255 rump___sysimpl_pipe2(int * fildes, int flags) 4256 { 4257 register_t retval[2]; 4258 int error = 0; 4259 int rv = -1; 4260 struct sys_pipe2_args callarg; 4261 4262 SPARG(&callarg, fildes) = fildes; 4263 SPARG(&callarg, flags) = flags; 4264 4265 error = rsys_syscall(SYS_pipe2, &callarg, sizeof(callarg), retval); 4266 rsys_seterrno(error); 4267 if (error == 0) { 4268 if (sizeof(int) > sizeof(register_t)) 4269 rv = *(int *)retval; 4270 else 4271 rv = *retval; 4272 } 4273 return rv; 4274 } 4275 rsys_define(rumpns_sys_pipe2); 4276 rsys_aliases(pipe2,rump___sysimpl_pipe2); 4277 4278 int rump___sysimpl_dup3(int, int, int); 4279 int 4280 rump___sysimpl_dup3(int from, int to, int flags) 4281 { 4282 register_t retval[2]; 4283 int error = 0; 4284 int rv = -1; 4285 struct sys_dup3_args callarg; 4286 4287 SPARG(&callarg, from) = from; 4288 SPARG(&callarg, to) = to; 4289 SPARG(&callarg, flags) = flags; 4290 4291 error = rsys_syscall(SYS_dup3, &callarg, sizeof(callarg), retval); 4292 rsys_seterrno(error); 4293 if (error == 0) { 4294 if (sizeof(int) > sizeof(register_t)) 4295 rv = *(int *)retval; 4296 else 4297 rv = *retval; 4298 } 4299 return rv; 4300 } 4301 rsys_define(rumpns_sys_dup3); 4302 rsys_aliases(dup3,rump___sysimpl_dup3); 4303 4304 int rump___sysimpl_kqueue1(int); 4305 int 4306 rump___sysimpl_kqueue1(int flags) 4307 { 4308 register_t retval[2]; 4309 int error = 0; 4310 int rv = -1; 4311 struct sys_kqueue1_args callarg; 4312 4313 SPARG(&callarg, flags) = flags; 4314 4315 error = rsys_syscall(SYS_kqueue1, &callarg, sizeof(callarg), retval); 4316 rsys_seterrno(error); 4317 if (error == 0) { 4318 if (sizeof(int) > sizeof(register_t)) 4319 rv = *(int *)retval; 4320 else 4321 rv = *retval; 4322 } 4323 return rv; 4324 } 4325 rsys_define(rumpns_sys_kqueue1); 4326 rsys_aliases(kqueue1,rump___sysimpl_kqueue1); 4327 4328 int rump___sysimpl_paccept(int, struct sockaddr *, socklen_t *, const sigset_t *, int); 4329 int 4330 rump___sysimpl_paccept(int s, struct sockaddr * name, socklen_t * anamelen, const sigset_t * mask, int flags) 4331 { 4332 register_t retval[2]; 4333 int error = 0; 4334 int rv = -1; 4335 struct sys_paccept_args callarg; 4336 4337 SPARG(&callarg, s) = s; 4338 SPARG(&callarg, name) = name; 4339 SPARG(&callarg, anamelen) = anamelen; 4340 SPARG(&callarg, mask) = mask; 4341 SPARG(&callarg, flags) = flags; 4342 4343 error = rsys_syscall(SYS_paccept, &callarg, sizeof(callarg), retval); 4344 rsys_seterrno(error); 4345 if (error == 0) { 4346 if (sizeof(int) > sizeof(register_t)) 4347 rv = *(int *)retval; 4348 else 4349 rv = *retval; 4350 } 4351 return rv; 4352 } 4353 rsys_define(rumpns_sys_paccept); 4354 rsys_aliases(paccept,rump___sysimpl_paccept); 4355 4356 int rump___sysimpl_linkat(int, const char *, int, const char *, int); 4357 int 4358 rump___sysimpl_linkat(int fd1, const char * name1, int fd2, const char * name2, int flags) 4359 { 4360 register_t retval[2]; 4361 int error = 0; 4362 int rv = -1; 4363 struct sys_linkat_args callarg; 4364 4365 SPARG(&callarg, fd1) = fd1; 4366 SPARG(&callarg, name1) = name1; 4367 SPARG(&callarg, fd2) = fd2; 4368 SPARG(&callarg, name2) = name2; 4369 SPARG(&callarg, flags) = flags; 4370 4371 error = rsys_syscall(SYS_linkat, &callarg, sizeof(callarg), retval); 4372 rsys_seterrno(error); 4373 if (error == 0) { 4374 if (sizeof(int) > sizeof(register_t)) 4375 rv = *(int *)retval; 4376 else 4377 rv = *retval; 4378 } 4379 return rv; 4380 } 4381 rsys_define(rumpns_sys_linkat); 4382 rsys_aliases(linkat,rump___sysimpl_linkat); 4383 4384 int rump___sysimpl_renameat(int, const char *, int, const char *); 4385 int 4386 rump___sysimpl_renameat(int fromfd, const char * from, int tofd, const char * to) 4387 { 4388 register_t retval[2]; 4389 int error = 0; 4390 int rv = -1; 4391 struct sys_renameat_args callarg; 4392 4393 SPARG(&callarg, fromfd) = fromfd; 4394 SPARG(&callarg, from) = from; 4395 SPARG(&callarg, tofd) = tofd; 4396 SPARG(&callarg, to) = to; 4397 4398 error = rsys_syscall(SYS_renameat, &callarg, sizeof(callarg), retval); 4399 rsys_seterrno(error); 4400 if (error == 0) { 4401 if (sizeof(int) > sizeof(register_t)) 4402 rv = *(int *)retval; 4403 else 4404 rv = *retval; 4405 } 4406 return rv; 4407 } 4408 rsys_define(rumpns_sys_renameat); 4409 rsys_aliases(renameat,rump___sysimpl_renameat); 4410 4411 int rump___sysimpl_mkfifoat(int, const char *, mode_t); 4412 int 4413 rump___sysimpl_mkfifoat(int fd, const char * path, mode_t mode) 4414 { 4415 register_t retval[2]; 4416 int error = 0; 4417 int rv = -1; 4418 struct sys_mkfifoat_args callarg; 4419 4420 SPARG(&callarg, fd) = fd; 4421 SPARG(&callarg, path) = path; 4422 SPARG(&callarg, mode) = mode; 4423 4424 error = rsys_syscall(SYS_mkfifoat, &callarg, sizeof(callarg), retval); 4425 rsys_seterrno(error); 4426 if (error == 0) { 4427 if (sizeof(int) > sizeof(register_t)) 4428 rv = *(int *)retval; 4429 else 4430 rv = *retval; 4431 } 4432 return rv; 4433 } 4434 rsys_define(rumpns_sys_mkfifoat); 4435 rsys_aliases(mkfifoat,rump___sysimpl_mkfifoat); 4436 4437 int rump___sysimpl_mknodat(int, const char *, mode_t, dev_t); 4438 int 4439 rump___sysimpl_mknodat(int fd, const char * path, mode_t mode, dev_t dev) 4440 { 4441 register_t retval[2]; 4442 int error = 0; 4443 int rv = -1; 4444 struct sys_mknodat_args callarg; 4445 4446 SPARG(&callarg, fd) = fd; 4447 SPARG(&callarg, path) = path; 4448 SPARG(&callarg, mode) = mode; 4449 SPARG(&callarg, PAD) = 0; 4450 SPARG(&callarg, dev) = dev; 4451 4452 error = rsys_syscall(SYS_mknodat, &callarg, sizeof(callarg), retval); 4453 rsys_seterrno(error); 4454 if (error == 0) { 4455 if (sizeof(int) > sizeof(register_t)) 4456 rv = *(int *)retval; 4457 else 4458 rv = *retval; 4459 } 4460 return rv; 4461 } 4462 rsys_define(rumpns_sys_mknodat); 4463 rsys_aliases(mknodat,rump___sysimpl_mknodat); 4464 4465 int rump___sysimpl_mkdirat(int, const char *, mode_t); 4466 int 4467 rump___sysimpl_mkdirat(int fd, const char * path, mode_t mode) 4468 { 4469 register_t retval[2]; 4470 int error = 0; 4471 int rv = -1; 4472 struct sys_mkdirat_args callarg; 4473 4474 SPARG(&callarg, fd) = fd; 4475 SPARG(&callarg, path) = path; 4476 SPARG(&callarg, mode) = mode; 4477 4478 error = rsys_syscall(SYS_mkdirat, &callarg, sizeof(callarg), retval); 4479 rsys_seterrno(error); 4480 if (error == 0) { 4481 if (sizeof(int) > sizeof(register_t)) 4482 rv = *(int *)retval; 4483 else 4484 rv = *retval; 4485 } 4486 return rv; 4487 } 4488 rsys_define(rumpns_sys_mkdirat); 4489 rsys_aliases(mkdirat,rump___sysimpl_mkdirat); 4490 4491 int rump___sysimpl_faccessat(int, const char *, int, int); 4492 int 4493 rump___sysimpl_faccessat(int fd, const char * path, int amode, int flag) 4494 { 4495 register_t retval[2]; 4496 int error = 0; 4497 int rv = -1; 4498 struct sys_faccessat_args callarg; 4499 4500 SPARG(&callarg, fd) = fd; 4501 SPARG(&callarg, path) = path; 4502 SPARG(&callarg, amode) = amode; 4503 SPARG(&callarg, flag) = flag; 4504 4505 error = rsys_syscall(SYS_faccessat, &callarg, sizeof(callarg), retval); 4506 rsys_seterrno(error); 4507 if (error == 0) { 4508 if (sizeof(int) > sizeof(register_t)) 4509 rv = *(int *)retval; 4510 else 4511 rv = *retval; 4512 } 4513 return rv; 4514 } 4515 rsys_define(rumpns_sys_faccessat); 4516 rsys_aliases(faccessat,rump___sysimpl_faccessat); 4517 4518 int rump___sysimpl_fchmodat(int, const char *, mode_t, int); 4519 int 4520 rump___sysimpl_fchmodat(int fd, const char * path, mode_t mode, int flag) 4521 { 4522 register_t retval[2]; 4523 int error = 0; 4524 int rv = -1; 4525 struct sys_fchmodat_args callarg; 4526 4527 SPARG(&callarg, fd) = fd; 4528 SPARG(&callarg, path) = path; 4529 SPARG(&callarg, mode) = mode; 4530 SPARG(&callarg, flag) = flag; 4531 4532 error = rsys_syscall(SYS_fchmodat, &callarg, sizeof(callarg), retval); 4533 rsys_seterrno(error); 4534 if (error == 0) { 4535 if (sizeof(int) > sizeof(register_t)) 4536 rv = *(int *)retval; 4537 else 4538 rv = *retval; 4539 } 4540 return rv; 4541 } 4542 rsys_define(rumpns_sys_fchmodat); 4543 rsys_aliases(fchmodat,rump___sysimpl_fchmodat); 4544 4545 int rump___sysimpl_fchownat(int, const char *, uid_t, gid_t, int); 4546 int 4547 rump___sysimpl_fchownat(int fd, const char * path, uid_t owner, gid_t group, int flag) 4548 { 4549 register_t retval[2]; 4550 int error = 0; 4551 int rv = -1; 4552 struct sys_fchownat_args callarg; 4553 4554 SPARG(&callarg, fd) = fd; 4555 SPARG(&callarg, path) = path; 4556 SPARG(&callarg, owner) = owner; 4557 SPARG(&callarg, group) = group; 4558 SPARG(&callarg, flag) = flag; 4559 4560 error = rsys_syscall(SYS_fchownat, &callarg, sizeof(callarg), retval); 4561 rsys_seterrno(error); 4562 if (error == 0) { 4563 if (sizeof(int) > sizeof(register_t)) 4564 rv = *(int *)retval; 4565 else 4566 rv = *retval; 4567 } 4568 return rv; 4569 } 4570 rsys_define(rumpns_sys_fchownat); 4571 rsys_aliases(fchownat,rump___sysimpl_fchownat); 4572 4573 int rump___sysimpl_fstatat(int, const char *, struct stat *, int); 4574 int 4575 rump___sysimpl_fstatat(int fd, const char * path, struct stat * buf, int flag) 4576 { 4577 register_t retval[2]; 4578 int error = 0; 4579 int rv = -1; 4580 struct sys_fstatat_args callarg; 4581 4582 SPARG(&callarg, fd) = fd; 4583 SPARG(&callarg, path) = path; 4584 SPARG(&callarg, buf) = buf; 4585 SPARG(&callarg, flag) = flag; 4586 4587 error = rsys_syscall(SYS_fstatat, &callarg, sizeof(callarg), retval); 4588 rsys_seterrno(error); 4589 if (error == 0) { 4590 if (sizeof(int) > sizeof(register_t)) 4591 rv = *(int *)retval; 4592 else 4593 rv = *retval; 4594 } 4595 return rv; 4596 } 4597 rsys_define(rumpns_sys_fstatat); 4598 rsys_aliases(fstatat,rump___sysimpl_fstatat); 4599 4600 int rump___sysimpl_utimensat(int, const char *, const struct timespec *, int); 4601 int 4602 rump___sysimpl_utimensat(int fd, const char * path, const struct timespec * tptr, int flag) 4603 { 4604 register_t retval[2]; 4605 int error = 0; 4606 int rv = -1; 4607 struct sys_utimensat_args callarg; 4608 4609 SPARG(&callarg, fd) = fd; 4610 SPARG(&callarg, path) = path; 4611 SPARG(&callarg, tptr) = tptr; 4612 SPARG(&callarg, flag) = flag; 4613 4614 error = rsys_syscall(SYS_utimensat, &callarg, sizeof(callarg), retval); 4615 rsys_seterrno(error); 4616 if (error == 0) { 4617 if (sizeof(int) > sizeof(register_t)) 4618 rv = *(int *)retval; 4619 else 4620 rv = *retval; 4621 } 4622 return rv; 4623 } 4624 rsys_define(rumpns_sys_utimensat); 4625 rsys_aliases(utimensat,rump___sysimpl_utimensat); 4626 4627 int rump___sysimpl_openat(int, const char *, int, mode_t); 4628 int 4629 rump___sysimpl_openat(int fd, const char * path, int oflags, mode_t mode) 4630 { 4631 register_t retval[2]; 4632 int error = 0; 4633 int rv = -1; 4634 struct sys_openat_args callarg; 4635 4636 SPARG(&callarg, fd) = fd; 4637 SPARG(&callarg, path) = path; 4638 SPARG(&callarg, oflags) = oflags; 4639 SPARG(&callarg, mode) = mode; 4640 4641 error = rsys_syscall(SYS_openat, &callarg, sizeof(callarg), retval); 4642 rsys_seterrno(error); 4643 if (error == 0) { 4644 if (sizeof(int) > sizeof(register_t)) 4645 rv = *(int *)retval; 4646 else 4647 rv = *retval; 4648 } 4649 return rv; 4650 } 4651 rsys_define(rumpns_sys_openat); 4652 rsys_aliases(openat,rump___sysimpl_openat); 4653 4654 int rump___sysimpl_readlinkat(int, const char *, char *, size_t); 4655 int 4656 rump___sysimpl_readlinkat(int fd, const char * path, char * buf, size_t bufsize) 4657 { 4658 register_t retval[2]; 4659 int error = 0; 4660 int rv = -1; 4661 struct sys_readlinkat_args callarg; 4662 4663 SPARG(&callarg, fd) = fd; 4664 SPARG(&callarg, path) = path; 4665 SPARG(&callarg, buf) = buf; 4666 SPARG(&callarg, bufsize) = bufsize; 4667 4668 error = rsys_syscall(SYS_readlinkat, &callarg, sizeof(callarg), retval); 4669 rsys_seterrno(error); 4670 if (error == 0) { 4671 if (sizeof(int) > sizeof(register_t)) 4672 rv = *(int *)retval; 4673 else 4674 rv = *retval; 4675 } 4676 return rv; 4677 } 4678 rsys_define(rumpns_sys_readlinkat); 4679 rsys_aliases(readlinkat,rump___sysimpl_readlinkat); 4680 4681 int rump___sysimpl_symlinkat(const char *, int, const char *); 4682 int 4683 rump___sysimpl_symlinkat(const char * path1, int fd, const char * path2) 4684 { 4685 register_t retval[2]; 4686 int error = 0; 4687 int rv = -1; 4688 struct sys_symlinkat_args callarg; 4689 4690 SPARG(&callarg, path1) = path1; 4691 SPARG(&callarg, fd) = fd; 4692 SPARG(&callarg, path2) = path2; 4693 4694 error = rsys_syscall(SYS_symlinkat, &callarg, sizeof(callarg), retval); 4695 rsys_seterrno(error); 4696 if (error == 0) { 4697 if (sizeof(int) > sizeof(register_t)) 4698 rv = *(int *)retval; 4699 else 4700 rv = *retval; 4701 } 4702 return rv; 4703 } 4704 rsys_define(rumpns_sys_symlinkat); 4705 rsys_aliases(symlinkat,rump___sysimpl_symlinkat); 4706 4707 int rump___sysimpl_unlinkat(int, const char *, int); 4708 int 4709 rump___sysimpl_unlinkat(int fd, const char * path, int flag) 4710 { 4711 register_t retval[2]; 4712 int error = 0; 4713 int rv = -1; 4714 struct sys_unlinkat_args callarg; 4715 4716 SPARG(&callarg, fd) = fd; 4717 SPARG(&callarg, path) = path; 4718 SPARG(&callarg, flag) = flag; 4719 4720 error = rsys_syscall(SYS_unlinkat, &callarg, sizeof(callarg), retval); 4721 rsys_seterrno(error); 4722 if (error == 0) { 4723 if (sizeof(int) > sizeof(register_t)) 4724 rv = *(int *)retval; 4725 else 4726 rv = *retval; 4727 } 4728 return rv; 4729 } 4730 rsys_define(rumpns_sys_unlinkat); 4731 rsys_aliases(unlinkat,rump___sysimpl_unlinkat); 4732 4733 int rump___sysimpl_futimens(int, const struct timespec *); 4734 int 4735 rump___sysimpl_futimens(int fd, const struct timespec * tptr) 4736 { 4737 register_t retval[2]; 4738 int error = 0; 4739 int rv = -1; 4740 struct sys_futimens_args callarg; 4741 4742 SPARG(&callarg, fd) = fd; 4743 SPARG(&callarg, tptr) = tptr; 4744 4745 error = rsys_syscall(SYS_futimens, &callarg, sizeof(callarg), retval); 4746 rsys_seterrno(error); 4747 if (error == 0) { 4748 if (sizeof(int) > sizeof(register_t)) 4749 rv = *(int *)retval; 4750 else 4751 rv = *retval; 4752 } 4753 return rv; 4754 } 4755 rsys_define(rumpns_sys_futimens); 4756 rsys_aliases(futimens,rump___sysimpl_futimens); 4757 4758 int rump___sysimpl___quotactl(const char *, struct quotactl_args *); 4759 int 4760 rump___sysimpl___quotactl(const char * path, struct quotactl_args * args) 4761 { 4762 register_t retval[2]; 4763 int error = 0; 4764 int rv = -1; 4765 struct sys___quotactl_args callarg; 4766 4767 SPARG(&callarg, path) = path; 4768 SPARG(&callarg, args) = args; 4769 4770 error = rsys_syscall(SYS___quotactl, &callarg, sizeof(callarg), retval); 4771 rsys_seterrno(error); 4772 if (error == 0) { 4773 if (sizeof(int) > sizeof(register_t)) 4774 rv = *(int *)retval; 4775 else 4776 rv = *retval; 4777 } 4778 return rv; 4779 } 4780 rsys_define(rumpns_sys___quotactl); 4781 rsys_aliases(__quotactl,rump___sysimpl___quotactl); 4782 4783 int rump___sysimpl_recvmmsg(int, struct mmsghdr *, unsigned int, unsigned int, struct timespec *); 4784 int 4785 rump___sysimpl_recvmmsg(int s, struct mmsghdr * mmsg, unsigned int vlen, unsigned int flags, struct timespec * timeout) 4786 { 4787 register_t retval[2]; 4788 int error = 0; 4789 int rv = -1; 4790 struct sys_recvmmsg_args callarg; 4791 4792 SPARG(&callarg, s) = s; 4793 SPARG(&callarg, mmsg) = mmsg; 4794 SPARG(&callarg, vlen) = vlen; 4795 SPARG(&callarg, flags) = flags; 4796 SPARG(&callarg, timeout) = timeout; 4797 4798 error = rsys_syscall(SYS_recvmmsg, &callarg, sizeof(callarg), retval); 4799 rsys_seterrno(error); 4800 if (error == 0) { 4801 if (sizeof(int) > sizeof(register_t)) 4802 rv = *(int *)retval; 4803 else 4804 rv = *retval; 4805 } 4806 return rv; 4807 } 4808 rsys_define(rumpns_sys_recvmmsg); 4809 rsys_aliases(recvmmsg,rump___sysimpl_recvmmsg); 4810 4811 int rump___sysimpl_sendmmsg(int, struct mmsghdr *, unsigned int, unsigned int); 4812 int 4813 rump___sysimpl_sendmmsg(int s, struct mmsghdr * mmsg, unsigned int vlen, unsigned int flags) 4814 { 4815 register_t retval[2]; 4816 int error = 0; 4817 int rv = -1; 4818 struct sys_sendmmsg_args callarg; 4819 4820 SPARG(&callarg, s) = s; 4821 SPARG(&callarg, mmsg) = mmsg; 4822 SPARG(&callarg, vlen) = vlen; 4823 SPARG(&callarg, flags) = flags; 4824 4825 error = rsys_syscall(SYS_sendmmsg, &callarg, sizeof(callarg), retval); 4826 rsys_seterrno(error); 4827 if (error == 0) { 4828 if (sizeof(int) > sizeof(register_t)) 4829 rv = *(int *)retval; 4830 else 4831 rv = *retval; 4832 } 4833 return rv; 4834 } 4835 rsys_define(rumpns_sys_sendmmsg); 4836 rsys_aliases(sendmmsg,rump___sysimpl_sendmmsg); 4837 4838 int rump_sys_pipe(int *); 4839 int 4840 rump_sys_pipe(int *fd) 4841 { 4842 register_t retval[2]; 4843 int error = 0; 4844 4845 error = rsys_syscall(SYS_pipe, NULL, 0, retval); 4846 if (error) { 4847 rsys_seterrno(error); 4848 } else { 4849 fd[0] = retval[0]; 4850 fd[1] = retval[1]; 4851 } 4852 return error ? -1 : 0; 4853 } 4854 rsys_define(rumpns_sys_pipe); 4855 rsys_aliases(pipe,rump_sys_pipe); 4856 4857 #ifndef RUMP_CLIENT 4858 #define s(type) sizeof(type) 4859 #define n(type) (sizeof(type)/sizeof (register_t)) 4860 #define ns(type) n(type), s(type) 4861 4862 struct sysent rump_sysent[] = { 4863 { 0, 0, SYCALL_NOSYS, 4864 (sy_call_t *)rump_enosys }, /* 0 = syscall */ 4865 { 0, 0, SYCALL_NOSYS, 4866 (sy_call_t *)rump_enosys }, /* 1 = exit */ 4867 { 0, 0, SYCALL_NOSYS, 4868 (sy_call_t *)rump_enosys }, /* 2 = fork */ 4869 { ns(struct sys_read_args), 0, 4870 (sy_call_t *)rumpns_sys_read }, /* 3 = read */ 4871 { ns(struct sys_write_args), 0, 4872 (sy_call_t *)rumpns_sys_write }, /* 4 = write */ 4873 { ns(struct sys_open_args), 0, 4874 (sy_call_t *)rumpns_sys_open }, /* 5 = open */ 4875 { ns(struct sys_close_args), 0, 4876 (sy_call_t *)rumpns_sys_close }, /* 6 = close */ 4877 { 0, 0, 0, 4878 (sy_call_t *)rumpns_sys_nomodule }, /* 7 = wait4 */ 4879 { 0, 0, 0, 4880 (sy_call_t *)rumpns_sys_nomodule }, /* 8 = ocreat */ 4881 { ns(struct sys_link_args), 0, 4882 (sy_call_t *)rumpns_sys_link }, /* 9 = link */ 4883 { ns(struct sys_unlink_args), 0, 4884 (sy_call_t *)rumpns_sys_unlink }, /* 10 = unlink */ 4885 { 0, 0, SYCALL_NOSYS, 4886 (sy_call_t *)rump_enosys }, /* 11 = obsolete execv */ 4887 { ns(struct sys_chdir_args), 0, 4888 (sy_call_t *)rumpns_sys_chdir }, /* 12 = chdir */ 4889 { ns(struct sys_fchdir_args), 0, 4890 (sy_call_t *)rumpns_sys_fchdir }, /* 13 = fchdir */ 4891 { ns(struct compat_50_sys_mknod_args), 0, 4892 (sy_call_t *)rumpns_compat_50_sys_mknod },/* 14 = compat_50_mknod */ 4893 { ns(struct sys_chmod_args), 0, 4894 (sy_call_t *)rumpns_sys_chmod }, /* 15 = chmod */ 4895 { ns(struct sys_chown_args), 0, 4896 (sy_call_t *)rumpns_sys_chown }, /* 16 = chown */ 4897 { 0, 0, SYCALL_NOSYS, 4898 (sy_call_t *)rump_enosys }, /* 17 = break */ 4899 { 0, 0, 0, 4900 (sy_call_t *)rumpns_sys_nomodule }, /* 18 = getfsstat */ 4901 { 0, 0, 0, 4902 (sy_call_t *)rumpns_sys_nomodule }, /* 19 = olseek */ 4903 { 0, 0, 0, 4904 (sy_call_t *)rumpns_sys_getpid_with_ppid },/* 20 = getpid */ 4905 { 0, 0, 0, 4906 (sy_call_t *)rumpns_sys_nomodule }, /* 21 = mount */ 4907 { ns(struct sys_unmount_args), 0, 4908 (sy_call_t *)rumpns_sys_unmount }, /* 22 = unmount */ 4909 { ns(struct sys_setuid_args), 0, 4910 (sy_call_t *)rumpns_sys_setuid }, /* 23 = setuid */ 4911 { 0, 0, 0, 4912 (sy_call_t *)rumpns_sys_getuid_with_euid },/* 24 = getuid */ 4913 { 0, 0, 0, 4914 (sy_call_t *)rumpns_sys_geteuid }, /* 25 = geteuid */ 4915 { 0, 0, SYCALL_NOSYS, 4916 (sy_call_t *)rump_enosys }, /* 26 = ptrace */ 4917 { ns(struct sys_recvmsg_args), 0, 4918 (sy_call_t *)rumpns_sys_recvmsg }, /* 27 = recvmsg */ 4919 { ns(struct sys_sendmsg_args), 0, 4920 (sy_call_t *)rumpns_sys_sendmsg }, /* 28 = sendmsg */ 4921 { ns(struct sys_recvfrom_args), 0, 4922 (sy_call_t *)rumpns_sys_recvfrom }, /* 29 = recvfrom */ 4923 { ns(struct sys_accept_args), 0, 4924 (sy_call_t *)rumpns_sys_accept }, /* 30 = accept */ 4925 { ns(struct sys_getpeername_args), 0, 4926 (sy_call_t *)rumpns_sys_getpeername },/* 31 = getpeername */ 4927 { ns(struct sys_getsockname_args), 0, 4928 (sy_call_t *)rumpns_sys_getsockname },/* 32 = getsockname */ 4929 { ns(struct sys_access_args), 0, 4930 (sy_call_t *)rumpns_sys_access }, /* 33 = access */ 4931 { ns(struct sys_chflags_args), 0, 4932 (sy_call_t *)rumpns_sys_chflags }, /* 34 = chflags */ 4933 { ns(struct sys_fchflags_args), 0, 4934 (sy_call_t *)rumpns_sys_fchflags }, /* 35 = fchflags */ 4935 { 0, 0, 0, 4936 (sy_call_t *)rumpns_sys_sync }, /* 36 = sync */ 4937 { 0, 0, SYCALL_NOSYS, 4938 (sy_call_t *)rump_enosys }, /* 37 = kill */ 4939 { 0, 0, 0, 4940 (sy_call_t *)rumpns_sys_nomodule }, /* 38 = stat43 */ 4941 { 0, 0, 0, 4942 (sy_call_t *)rumpns_sys_getppid }, /* 39 = getppid */ 4943 { 0, 0, 0, 4944 (sy_call_t *)rumpns_sys_nomodule }, /* 40 = lstat43 */ 4945 { ns(struct sys_dup_args), 0, 4946 (sy_call_t *)rumpns_sys_dup }, /* 41 = dup */ 4947 { 0, 0, 0, 4948 (sy_call_t *)rumpns_sys_pipe }, /* 42 = pipe */ 4949 { 0, 0, 0, 4950 (sy_call_t *)rumpns_sys_getegid }, /* 43 = getegid */ 4951 { 0, 0, SYCALL_NOSYS, 4952 (sy_call_t *)rump_enosys }, /* 44 = profil */ 4953 { ns(struct sys_ktrace_args), 0, 4954 (sy_call_t *)rumpns_sys_ktrace }, /* 45 = ktrace */ 4955 { 0, 0, 0, 4956 (sy_call_t *)rumpns_sys_nomodule }, /* 46 = sigaction13 */ 4957 { 0, 0, 0, 4958 (sy_call_t *)rumpns_sys_getgid_with_egid },/* 47 = getgid */ 4959 { 0, 0, 0, 4960 (sy_call_t *)rumpns_sys_nomodule }, /* 48 = sigprocmask13 */ 4961 { ns(struct sys___getlogin_args), 0, 4962 (sy_call_t *)rumpns_sys___getlogin },/* 49 = __getlogin */ 4963 { ns(struct sys___setlogin_args), 0, 4964 (sy_call_t *)rumpns_sys___setlogin },/* 50 = __setlogin */ 4965 { 0, 0, SYCALL_NOSYS, 4966 (sy_call_t *)rump_enosys }, /* 51 = acct */ 4967 { 0, 0, 0, 4968 (sy_call_t *)rumpns_sys_nomodule }, /* 52 = sigpending13 */ 4969 { 0, 0, 0, 4970 (sy_call_t *)rumpns_sys_nomodule }, /* 53 = sigaltstack13 */ 4971 { ns(struct sys_ioctl_args), 0, 4972 (sy_call_t *)rumpns_sys_ioctl }, /* 54 = ioctl */ 4973 { 0, 0, 0, 4974 (sy_call_t *)rumpns_sys_nomodule }, /* 55 = oreboot */ 4975 { ns(struct sys_revoke_args), 0, 4976 (sy_call_t *)rumpns_sys_revoke }, /* 56 = revoke */ 4977 { ns(struct sys_symlink_args), 0, 4978 (sy_call_t *)rumpns_sys_symlink }, /* 57 = symlink */ 4979 { ns(struct sys_readlink_args), 0, 4980 (sy_call_t *)rumpns_sys_readlink }, /* 58 = readlink */ 4981 { 0, 0, SYCALL_NOSYS, 4982 (sy_call_t *)rump_enosys }, /* 59 = execve */ 4983 { ns(struct sys_umask_args), 0, 4984 (sy_call_t *)rumpns_sys_umask }, /* 60 = umask */ 4985 { ns(struct sys_chroot_args), 0, 4986 (sy_call_t *)rumpns_sys_chroot }, /* 61 = chroot */ 4987 { 0, 0, 0, 4988 (sy_call_t *)rumpns_sys_nomodule }, /* 62 = fstat43 */ 4989 { 0, 0, 0, 4990 (sy_call_t *)rumpns_sys_nomodule }, /* 63 = ogetkerninfo */ 4991 { 0, 0, 0, 4992 (sy_call_t *)rumpns_sys_nomodule }, /* 64 = ogetpagesize */ 4993 { 0, 0, 0, 4994 (sy_call_t *)rumpns_sys_nomodule }, /* 65 = msync */ 4995 { 0, 0, SYCALL_NOSYS, 4996 (sy_call_t *)rump_enosys }, /* 66 = vfork */ 4997 { 0, 0, SYCALL_NOSYS, 4998 (sy_call_t *)rump_enosys }, /* 67 = obsolete vread */ 4999 { 0, 0, SYCALL_NOSYS, 5000 (sy_call_t *)rump_enosys }, /* 68 = obsolete vwrite */ 5001 { 0, 0, SYCALL_NOSYS, 5002 (sy_call_t *)rump_enosys }, /* 69 = sbrk */ 5003 { 0, 0, SYCALL_NOSYS, 5004 (sy_call_t *)rump_enosys }, /* 70 = sstk */ 5005 { 0, 0, 0, 5006 (sy_call_t *)rumpns_sys_nomodule }, /* 71 = ommap */ 5007 { 0, 0, SYCALL_NOSYS, 5008 (sy_call_t *)rump_enosys }, /* 72 = vadvise */ 5009 { 0, 0, SYCALL_NOSYS, 5010 (sy_call_t *)rump_enosys }, /* 73 = munmap */ 5011 { 0, 0, SYCALL_NOSYS, 5012 (sy_call_t *)rump_enosys }, /* 74 = mprotect */ 5013 { 0, 0, SYCALL_NOSYS, 5014 (sy_call_t *)rump_enosys }, /* 75 = madvise */ 5015 { 0, 0, SYCALL_NOSYS, 5016 (sy_call_t *)rump_enosys }, /* 76 = obsolete vhangup */ 5017 { 0, 0, SYCALL_NOSYS, 5018 (sy_call_t *)rump_enosys }, /* 77 = obsolete vlimit */ 5019 { 0, 0, SYCALL_NOSYS, 5020 (sy_call_t *)rump_enosys }, /* 78 = mincore */ 5021 { ns(struct sys_getgroups_args), 0, 5022 (sy_call_t *)rumpns_sys_getgroups },/* 79 = getgroups */ 5023 { ns(struct sys_setgroups_args), 0, 5024 (sy_call_t *)rumpns_sys_setgroups },/* 80 = setgroups */ 5025 { 0, 0, 0, 5026 (sy_call_t *)rumpns_sys_getpgrp }, /* 81 = getpgrp */ 5027 { ns(struct sys_setpgid_args), 0, 5028 (sy_call_t *)rumpns_sys_setpgid }, /* 82 = setpgid */ 5029 { 0, 0, 0, 5030 (sy_call_t *)rumpns_sys_nomodule }, /* 83 = setitimer */ 5031 { 0, 0, 0, 5032 (sy_call_t *)rumpns_sys_nomodule }, /* 84 = owait */ 5033 { 0, 0, 0, 5034 (sy_call_t *)rumpns_sys_nomodule }, /* 85 = oswapon */ 5035 { 0, 0, 0, 5036 (sy_call_t *)rumpns_sys_nomodule }, /* 86 = getitimer */ 5037 { 0, 0, 0, 5038 (sy_call_t *)rumpns_sys_nomodule }, /* 87 = ogethostname */ 5039 { 0, 0, 0, 5040 (sy_call_t *)rumpns_sys_nomodule }, /* 88 = osethostname */ 5041 { 0, 0, 0, 5042 (sy_call_t *)rumpns_sys_nomodule }, /* 89 = ogetdtablesize */ 5043 { ns(struct sys_dup2_args), 0, 5044 (sy_call_t *)rumpns_sys_dup2 }, /* 90 = dup2 */ 5045 { 0, 0, SYCALL_NOSYS, 5046 (sy_call_t *)rump_enosys }, /* 91 = unimplemented getdopt */ 5047 { ns(struct sys_fcntl_args), 0, 5048 (sy_call_t *)rumpns_sys_fcntl }, /* 92 = fcntl */ 5049 { ns(struct compat_50_sys_select_args), 0, 5050 (sy_call_t *)rumpns_compat_50_sys_select },/* 93 = compat_50_select */ 5051 { 0, 0, SYCALL_NOSYS, 5052 (sy_call_t *)rump_enosys }, /* 94 = unimplemented setdopt */ 5053 { ns(struct sys_fsync_args), 0, 5054 (sy_call_t *)rumpns_sys_fsync }, /* 95 = fsync */ 5055 { 0, 0, SYCALL_NOSYS, 5056 (sy_call_t *)rump_enosys }, /* 96 = setpriority */ 5057 { 0, 0, 0, 5058 (sy_call_t *)rumpns_sys_nomodule }, /* 97 = socket */ 5059 { ns(struct sys_connect_args), 0, 5060 (sy_call_t *)rumpns_sys_connect }, /* 98 = connect */ 5061 { 0, 0, 0, 5062 (sy_call_t *)rumpns_sys_nomodule }, /* 99 = oaccept */ 5063 { 0, 0, SYCALL_NOSYS, 5064 (sy_call_t *)rump_enosys }, /* 100 = getpriority */ 5065 { 0, 0, 0, 5066 (sy_call_t *)rumpns_sys_nomodule }, /* 101 = osend */ 5067 { 0, 0, 0, 5068 (sy_call_t *)rumpns_sys_nomodule }, /* 102 = orecv */ 5069 { 0, 0, 0, 5070 (sy_call_t *)rumpns_sys_nomodule }, /* 103 = sigreturn13 */ 5071 { ns(struct sys_bind_args), 0, 5072 (sy_call_t *)rumpns_sys_bind }, /* 104 = bind */ 5073 { ns(struct sys_setsockopt_args), 0, 5074 (sy_call_t *)rumpns_sys_setsockopt },/* 105 = setsockopt */ 5075 { ns(struct sys_listen_args), 0, 5076 (sy_call_t *)rumpns_sys_listen }, /* 106 = listen */ 5077 { 0, 0, SYCALL_NOSYS, 5078 (sy_call_t *)rump_enosys }, /* 107 = obsolete vtimes */ 5079 { 0, 0, 0, 5080 (sy_call_t *)rumpns_sys_nomodule }, /* 108 = osigvec */ 5081 { 0, 0, 0, 5082 (sy_call_t *)rumpns_sys_nomodule }, /* 109 = osigblock */ 5083 { 0, 0, 0, 5084 (sy_call_t *)rumpns_sys_nomodule }, /* 110 = osigsetmask */ 5085 { 0, 0, 0, 5086 (sy_call_t *)rumpns_sys_nomodule }, /* 111 = sigsuspend13 */ 5087 { 0, 0, 0, 5088 (sy_call_t *)rumpns_sys_nomodule }, /* 112 = osigstack */ 5089 { 0, 0, 0, 5090 (sy_call_t *)rumpns_sys_nomodule }, /* 113 = orecvmsg */ 5091 { 0, 0, 0, 5092 (sy_call_t *)rumpns_sys_nomodule }, /* 114 = osendmsg */ 5093 { 0, 0, SYCALL_NOSYS, 5094 (sy_call_t *)rump_enosys }, /* 115 = obsolete vtrace */ 5095 { 0, 0, 0, 5096 (sy_call_t *)rumpns_sys_nomodule }, /* 116 = gettimeofday */ 5097 { 0, 0, 0, 5098 (sy_call_t *)rumpns_sys_nomodule }, /* 117 = getrusage */ 5099 { ns(struct sys_getsockopt_args), 0, 5100 (sy_call_t *)rumpns_sys_getsockopt },/* 118 = getsockopt */ 5101 { 0, 0, SYCALL_NOSYS, 5102 (sy_call_t *)rump_enosys }, /* 119 = obsolete resuba */ 5103 { ns(struct sys_readv_args), 0, 5104 (sy_call_t *)rumpns_sys_readv }, /* 120 = readv */ 5105 { ns(struct sys_writev_args), 0, 5106 (sy_call_t *)rumpns_sys_writev }, /* 121 = writev */ 5107 { 0, 0, 0, 5108 (sy_call_t *)rumpns_sys_nomodule }, /* 122 = settimeofday */ 5109 { ns(struct sys_fchown_args), 0, 5110 (sy_call_t *)rumpns_sys_fchown }, /* 123 = fchown */ 5111 { ns(struct sys_fchmod_args), 0, 5112 (sy_call_t *)rumpns_sys_fchmod }, /* 124 = fchmod */ 5113 { 0, 0, 0, 5114 (sy_call_t *)rumpns_sys_nomodule }, /* 125 = orecvfrom */ 5115 { ns(struct sys_setreuid_args), 0, 5116 (sy_call_t *)rumpns_sys_setreuid }, /* 126 = setreuid */ 5117 { ns(struct sys_setregid_args), 0, 5118 (sy_call_t *)rumpns_sys_setregid }, /* 127 = setregid */ 5119 { ns(struct sys_rename_args), 0, 5120 (sy_call_t *)rumpns_sys_rename }, /* 128 = rename */ 5121 { 0, 0, 0, 5122 (sy_call_t *)rumpns_sys_nomodule }, /* 129 = otruncate */ 5123 { 0, 0, 0, 5124 (sy_call_t *)rumpns_sys_nomodule }, /* 130 = oftruncate */ 5125 { ns(struct sys_flock_args), 0, 5126 (sy_call_t *)rumpns_sys_flock }, /* 131 = flock */ 5127 { ns(struct sys_mkfifo_args), 0, 5128 (sy_call_t *)rumpns_sys_mkfifo }, /* 132 = mkfifo */ 5129 { ns(struct sys_sendto_args), 0, 5130 (sy_call_t *)rumpns_sys_sendto }, /* 133 = sendto */ 5131 { ns(struct sys_shutdown_args), 0, 5132 (sy_call_t *)rumpns_sys_shutdown }, /* 134 = shutdown */ 5133 { ns(struct sys_socketpair_args), 0, 5134 (sy_call_t *)rumpns_sys_socketpair },/* 135 = socketpair */ 5135 { ns(struct sys_mkdir_args), 0, 5136 (sy_call_t *)rumpns_sys_mkdir }, /* 136 = mkdir */ 5137 { ns(struct sys_rmdir_args), 0, 5138 (sy_call_t *)rumpns_sys_rmdir }, /* 137 = rmdir */ 5139 { ns(struct compat_50_sys_utimes_args), 0, 5140 (sy_call_t *)rumpns_compat_50_sys_utimes },/* 138 = compat_50_utimes */ 5141 { 0, 0, SYCALL_NOSYS, 5142 (sy_call_t *)rump_enosys }, /* 139 = obsolete 4.2 sigreturn */ 5143 { 0, 0, 0, 5144 (sy_call_t *)rumpns_sys_nomodule }, /* 140 = adjtime */ 5145 { 0, 0, 0, 5146 (sy_call_t *)rumpns_sys_nomodule }, /* 141 = ogetpeername */ 5147 { 0, 0, 0, 5148 (sy_call_t *)rumpns_sys_nomodule }, /* 142 = ogethostid */ 5149 { 0, 0, 0, 5150 (sy_call_t *)rumpns_sys_nomodule }, /* 143 = osethostid */ 5151 { 0, 0, 0, 5152 (sy_call_t *)rumpns_sys_nomodule }, /* 144 = ogetrlimit */ 5153 { 0, 0, 0, 5154 (sy_call_t *)rumpns_sys_nomodule }, /* 145 = osetrlimit */ 5155 { 0, 0, 0, 5156 (sy_call_t *)rumpns_sys_nomodule }, /* 146 = okillpg */ 5157 { 0, 0, 0, 5158 (sy_call_t *)rumpns_sys_setsid }, /* 147 = setsid */ 5159 { 0, 0, 0, 5160 (sy_call_t *)rumpns_sys_nomodule }, /* 148 = quotactl */ 5161 { 0, 0, 0, 5162 (sy_call_t *)rumpns_sys_nomodule }, /* 149 = oquota */ 5163 { 0, 0, 0, 5164 (sy_call_t *)rumpns_sys_nomodule }, /* 150 = ogetsockname */ 5165 { 0, 0, SYCALL_NOSYS, 5166 (sy_call_t *)rump_enosys }, /* 151 = unimplemented */ 5167 { 0, 0, SYCALL_NOSYS, 5168 (sy_call_t *)rump_enosys }, /* 152 = unimplemented */ 5169 { 0, 0, SYCALL_NOSYS, 5170 (sy_call_t *)rump_enosys }, /* 153 = unimplemented */ 5171 { 0, 0, SYCALL_NOSYS, 5172 (sy_call_t *)rump_enosys }, /* 154 = unimplemented */ 5173 { ns(struct sys_nfssvc_args), 0, 5174 (sy_call_t *)rumpns_sys_nomodule }, /* 155 = nfssvc */ 5175 { 0, 0, 0, 5176 (sy_call_t *)rumpns_sys_nomodule }, /* 156 = ogetdirentries */ 5177 { 0, 0, 0, 5178 (sy_call_t *)rumpns_sys_nomodule }, /* 157 = statfs */ 5179 { 0, 0, 0, 5180 (sy_call_t *)rumpns_sys_nomodule }, /* 158 = fstatfs */ 5181 { 0, 0, SYCALL_NOSYS, 5182 (sy_call_t *)rump_enosys }, /* 159 = unimplemented */ 5183 { 0, 0, SYCALL_NOSYS, 5184 (sy_call_t *)rump_enosys }, /* 160 = unimplemented */ 5185 { 0, 0, 0, 5186 (sy_call_t *)rumpns_sys_nomodule }, /* 161 = getfh */ 5187 { 0, 0, 0, 5188 (sy_call_t *)rumpns_sys_nomodule }, /* 162 = ogetdomainname */ 5189 { 0, 0, 0, 5190 (sy_call_t *)rumpns_sys_nomodule }, /* 163 = osetdomainname */ 5191 { 0, 0, 0, 5192 (sy_call_t *)rumpns_sys_nomodule }, /* 164 = ouname */ 5193 { 0, 0, SYCALL_NOSYS, 5194 (sy_call_t *)rump_enosys }, /* 165 = sysarch */ 5195 { 0, 0, SYCALL_NOSYS, 5196 (sy_call_t *)rump_enosys }, /* 166 = unimplemented */ 5197 { 0, 0, SYCALL_NOSYS, 5198 (sy_call_t *)rump_enosys }, /* 167 = unimplemented */ 5199 { 0, 0, SYCALL_NOSYS, 5200 (sy_call_t *)rump_enosys }, /* 168 = unimplemented */ 5201 #if (defined(SYSVSEM) || !defined(_KERNEL_OPT)) && !defined(_LP64) 5202 { 0, 0, 0, 5203 (sy_call_t *)rumpns_sys_nomodule }, /* 169 = osemsys */ 5204 #else 5205 { 0, 0, SYCALL_NOSYS, 5206 (sy_call_t *)rump_enosys }, /* 169 = excluded 1.0 semsys */ 5207 #endif 5208 #if (defined(SYSVMSG) || !defined(_KERNEL_OPT)) && !defined(_LP64) 5209 { 0, 0, 0, 5210 (sy_call_t *)rumpns_sys_nomodule }, /* 170 = omsgsys */ 5211 #else 5212 { 0, 0, SYCALL_NOSYS, 5213 (sy_call_t *)rump_enosys }, /* 170 = excluded 1.0 msgsys */ 5214 #endif 5215 #if (defined(SYSVSHM) || !defined(_KERNEL_OPT)) && !defined(_LP64) 5216 { 0, 0, 0, 5217 (sy_call_t *)rumpns_sys_nomodule }, /* 171 = oshmsys */ 5218 #else 5219 { 0, 0, SYCALL_NOSYS, 5220 (sy_call_t *)rump_enosys }, /* 171 = excluded 1.0 shmsys */ 5221 #endif 5222 { 0, 0, SYCALL_NOSYS, 5223 (sy_call_t *)rump_enosys }, /* 172 = unimplemented */ 5224 { ns(struct sys_pread_args), 0, 5225 (sy_call_t *)rumpns_sys_pread }, /* 173 = pread */ 5226 { ns(struct sys_pwrite_args), 0, 5227 (sy_call_t *)rumpns_sys_pwrite }, /* 174 = pwrite */ 5228 { 0, 0, SYCALL_NOSYS, 5229 (sy_call_t *)rump_enosys }, /* 175 = ntp_gettime */ 5230 #if defined(NTP) || !defined(_KERNEL_OPT) 5231 { 0, 0, SYCALL_NOSYS, 5232 (sy_call_t *)rump_enosys }, /* 176 = ntp_adjtime */ 5233 #else 5234 { 0, 0, SYCALL_NOSYS, 5235 (sy_call_t *)rump_enosys }, /* 176 = excluded ntp_adjtime */ 5236 #endif 5237 { 0, 0, SYCALL_NOSYS, 5238 (sy_call_t *)rump_enosys }, /* 177 = unimplemented */ 5239 { 0, 0, SYCALL_NOSYS, 5240 (sy_call_t *)rump_enosys }, /* 178 = unimplemented */ 5241 { 0, 0, SYCALL_NOSYS, 5242 (sy_call_t *)rump_enosys }, /* 179 = unimplemented */ 5243 { 0, 0, SYCALL_NOSYS, 5244 (sy_call_t *)rump_enosys }, /* 180 = unimplemented */ 5245 { ns(struct sys_setgid_args), 0, 5246 (sy_call_t *)rumpns_sys_setgid }, /* 181 = setgid */ 5247 { ns(struct sys_setegid_args), 0, 5248 (sy_call_t *)rumpns_sys_setegid }, /* 182 = setegid */ 5249 { ns(struct sys_seteuid_args), 0, 5250 (sy_call_t *)rumpns_sys_seteuid }, /* 183 = seteuid */ 5251 { 0, 0, 0, 5252 (sy_call_t *)rumpns_sys_nomodule }, /* 184 = lfs_bmapv */ 5253 { 0, 0, 0, 5254 (sy_call_t *)rumpns_sys_nomodule }, /* 185 = lfs_markv */ 5255 { 0, 0, 0, 5256 (sy_call_t *)rumpns_sys_nomodule }, /* 186 = lfs_segclean */ 5257 { 0, 0, 0, 5258 (sy_call_t *)rumpns_sys_nomodule }, /* 187 = lfs_segwait */ 5259 { 0, 0, 0, 5260 (sy_call_t *)rumpns_sys_nomodule }, /* 188 = stat12 */ 5261 { 0, 0, 0, 5262 (sy_call_t *)rumpns_sys_nomodule }, /* 189 = fstat12 */ 5263 { 0, 0, 0, 5264 (sy_call_t *)rumpns_sys_nomodule }, /* 190 = lstat12 */ 5265 { ns(struct sys_pathconf_args), 0, 5266 (sy_call_t *)rumpns_sys_pathconf }, /* 191 = pathconf */ 5267 { ns(struct sys_fpathconf_args), 0, 5268 (sy_call_t *)rumpns_sys_fpathconf },/* 192 = fpathconf */ 5269 { 0, 0, SYCALL_NOSYS, 5270 (sy_call_t *)rump_enosys }, /* 193 = unimplemented */ 5271 { ns(struct sys_getrlimit_args), 0, 5272 (sy_call_t *)rumpns_sys_getrlimit },/* 194 = getrlimit */ 5273 { ns(struct sys_setrlimit_args), 0, 5274 (sy_call_t *)rumpns_sys_setrlimit },/* 195 = setrlimit */ 5275 { 0, 0, 0, 5276 (sy_call_t *)rumpns_sys_nomodule }, /* 196 = getdirentries */ 5277 { 0, 0, SYCALL_NOSYS, 5278 (sy_call_t *)rump_enosys }, /* 197 = mmap */ 5279 { 0, 0, SYCALL_NOSYS, 5280 (sy_call_t *)rump_enosys }, /* 198 = __syscall */ 5281 { ns(struct sys_lseek_args), 0, 5282 (sy_call_t *)rumpns_sys_lseek }, /* 199 = lseek */ 5283 { ns(struct sys_truncate_args), 0, 5284 (sy_call_t *)rumpns_sys_truncate }, /* 200 = truncate */ 5285 { ns(struct sys_ftruncate_args), 0, 5286 (sy_call_t *)rumpns_sys_ftruncate },/* 201 = ftruncate */ 5287 { ns(struct sys___sysctl_args), 0, 5288 (sy_call_t *)rumpns_sys___sysctl }, /* 202 = __sysctl */ 5289 { 0, 0, SYCALL_NOSYS, 5290 (sy_call_t *)rump_enosys }, /* 203 = mlock */ 5291 { 0, 0, SYCALL_NOSYS, 5292 (sy_call_t *)rump_enosys }, /* 204 = munlock */ 5293 { 0, 0, SYCALL_NOSYS, 5294 (sy_call_t *)rump_enosys }, /* 205 = undelete */ 5295 { ns(struct compat_50_sys_futimes_args), 0, 5296 (sy_call_t *)rumpns_compat_50_sys_futimes },/* 206 = compat_50_futimes */ 5297 { ns(struct sys_getpgid_args), 0, 5298 (sy_call_t *)rumpns_sys_getpgid }, /* 207 = getpgid */ 5299 { ns(struct sys_reboot_args), 0, 5300 (sy_call_t *)rumpns_sys_reboot }, /* 208 = reboot */ 5301 { ns(struct sys_poll_args), 0, 5302 (sy_call_t *)rumpns_sys_poll }, /* 209 = poll */ 5303 { 0, 0, 0, 5304 (sy_call_t *)rumpns_sys_nomodule }, /* 210 = afssys */ 5305 { 0, 0, SYCALL_NOSYS, 5306 (sy_call_t *)rump_enosys }, /* 211 = unimplemented */ 5307 { 0, 0, SYCALL_NOSYS, 5308 (sy_call_t *)rump_enosys }, /* 212 = unimplemented */ 5309 { 0, 0, SYCALL_NOSYS, 5310 (sy_call_t *)rump_enosys }, /* 213 = unimplemented */ 5311 { 0, 0, SYCALL_NOSYS, 5312 (sy_call_t *)rump_enosys }, /* 214 = unimplemented */ 5313 { 0, 0, SYCALL_NOSYS, 5314 (sy_call_t *)rump_enosys }, /* 215 = unimplemented */ 5315 { 0, 0, SYCALL_NOSYS, 5316 (sy_call_t *)rump_enosys }, /* 216 = unimplemented */ 5317 { 0, 0, SYCALL_NOSYS, 5318 (sy_call_t *)rump_enosys }, /* 217 = unimplemented */ 5319 { 0, 0, SYCALL_NOSYS, 5320 (sy_call_t *)rump_enosys }, /* 218 = unimplemented */ 5321 { 0, 0, SYCALL_NOSYS, 5322 (sy_call_t *)rump_enosys }, /* 219 = unimplemented */ 5323 #if defined(SYSVSEM) || !defined(_KERNEL_OPT) 5324 { 0, 0, 0, 5325 (sy_call_t *)rumpns_sys_nomodule }, /* 220 = __semctl */ 5326 { 0, 0, SYCALL_NOSYS, 5327 (sy_call_t *)rump_enosys }, /* 221 = semget */ 5328 { 0, 0, SYCALL_NOSYS, 5329 (sy_call_t *)rump_enosys }, /* 222 = semop */ 5330 { 0, 0, SYCALL_NOSYS, 5331 (sy_call_t *)rump_enosys }, /* 223 = semconfig */ 5332 #else 5333 { 0, 0, SYCALL_NOSYS, 5334 (sy_call_t *)rump_enosys }, /* 220 = excluded compat_14_semctl */ 5335 { 0, 0, SYCALL_NOSYS, 5336 (sy_call_t *)rump_enosys }, /* 221 = excluded semget */ 5337 { 0, 0, SYCALL_NOSYS, 5338 (sy_call_t *)rump_enosys }, /* 222 = excluded semop */ 5339 { 0, 0, SYCALL_NOSYS, 5340 (sy_call_t *)rump_enosys }, /* 223 = excluded semconfig */ 5341 #endif 5342 #if defined(SYSVMSG) || !defined(_KERNEL_OPT) 5343 { 0, 0, 0, 5344 (sy_call_t *)rumpns_sys_nomodule }, /* 224 = msgctl */ 5345 { 0, 0, SYCALL_NOSYS, 5346 (sy_call_t *)rump_enosys }, /* 225 = msgget */ 5347 { 0, 0, SYCALL_NOSYS, 5348 (sy_call_t *)rump_enosys }, /* 226 = msgsnd */ 5349 { 0, 0, SYCALL_NOSYS, 5350 (sy_call_t *)rump_enosys }, /* 227 = msgrcv */ 5351 #else 5352 { 0, 0, SYCALL_NOSYS, 5353 (sy_call_t *)rump_enosys }, /* 224 = excluded compat_14_msgctl */ 5354 { 0, 0, SYCALL_NOSYS, 5355 (sy_call_t *)rump_enosys }, /* 225 = excluded msgget */ 5356 { 0, 0, SYCALL_NOSYS, 5357 (sy_call_t *)rump_enosys }, /* 226 = excluded msgsnd */ 5358 { 0, 0, SYCALL_NOSYS, 5359 (sy_call_t *)rump_enosys }, /* 227 = excluded msgrcv */ 5360 #endif 5361 #if defined(SYSVSHM) || !defined(_KERNEL_OPT) 5362 { 0, 0, SYCALL_NOSYS, 5363 (sy_call_t *)rump_enosys }, /* 228 = shmat */ 5364 { 0, 0, 0, 5365 (sy_call_t *)rumpns_sys_nomodule }, /* 229 = shmctl */ 5366 { 0, 0, SYCALL_NOSYS, 5367 (sy_call_t *)rump_enosys }, /* 230 = shmdt */ 5368 { 0, 0, SYCALL_NOSYS, 5369 (sy_call_t *)rump_enosys }, /* 231 = shmget */ 5370 #else 5371 { 0, 0, SYCALL_NOSYS, 5372 (sy_call_t *)rump_enosys }, /* 228 = excluded shmat */ 5373 { 0, 0, SYCALL_NOSYS, 5374 (sy_call_t *)rump_enosys }, /* 229 = excluded compat_14_shmctl */ 5375 { 0, 0, SYCALL_NOSYS, 5376 (sy_call_t *)rump_enosys }, /* 230 = excluded shmdt */ 5377 { 0, 0, SYCALL_NOSYS, 5378 (sy_call_t *)rump_enosys }, /* 231 = excluded shmget */ 5379 #endif 5380 { 0, 0, 0, 5381 (sy_call_t *)rumpns_sys_nomodule }, /* 232 = clock_gettime */ 5382 { 0, 0, 0, 5383 (sy_call_t *)rumpns_sys_nomodule }, /* 233 = clock_settime */ 5384 { 0, 0, 0, 5385 (sy_call_t *)rumpns_sys_nomodule }, /* 234 = clock_getres */ 5386 { 0, 0, SYCALL_NOSYS, 5387 (sy_call_t *)rump_enosys }, /* 235 = timer_create */ 5388 { 0, 0, SYCALL_NOSYS, 5389 (sy_call_t *)rump_enosys }, /* 236 = timer_delete */ 5390 { 0, 0, 0, 5391 (sy_call_t *)rumpns_sys_nomodule }, /* 237 = timer_settime */ 5392 { 0, 0, 0, 5393 (sy_call_t *)rumpns_sys_nomodule }, /* 238 = timer_gettime */ 5394 { 0, 0, SYCALL_NOSYS, 5395 (sy_call_t *)rump_enosys }, /* 239 = timer_getoverrun */ 5396 { 0, 0, 0, 5397 (sy_call_t *)rumpns_sys_nomodule }, /* 240 = nanosleep */ 5398 { ns(struct sys_fdatasync_args), 0, 5399 (sy_call_t *)rumpns_sys_fdatasync },/* 241 = fdatasync */ 5400 { 0, 0, SYCALL_NOSYS, 5401 (sy_call_t *)rump_enosys }, /* 242 = mlockall */ 5402 { 0, 0, SYCALL_NOSYS, 5403 (sy_call_t *)rump_enosys }, /* 243 = munlockall */ 5404 { 0, 0, 0, 5405 (sy_call_t *)rumpns_sys_nomodule }, /* 244 = __sigtimedwait */ 5406 { 0, 0, SYCALL_NOSYS, 5407 (sy_call_t *)rump_enosys }, /* 245 = sigqueueinfo */ 5408 { ns(struct sys_modctl_args), 0, 5409 (sy_call_t *)rumpns_sys_modctl }, /* 246 = modctl */ 5410 { ns(struct sys__ksem_init_args), 0, 5411 (sy_call_t *)rumpns_sys_nomodule }, /* 247 = _ksem_init */ 5412 { ns(struct sys__ksem_open_args), 0, 5413 (sy_call_t *)rumpns_sys_nomodule }, /* 248 = _ksem_open */ 5414 { ns(struct sys__ksem_unlink_args), 0, 5415 (sy_call_t *)rumpns_sys_nomodule }, /* 249 = _ksem_unlink */ 5416 { ns(struct sys__ksem_close_args), 0, 5417 (sy_call_t *)rumpns_sys_nomodule }, /* 250 = _ksem_close */ 5418 { ns(struct sys__ksem_post_args), 0, 5419 (sy_call_t *)rumpns_sys_nomodule }, /* 251 = _ksem_post */ 5420 { ns(struct sys__ksem_wait_args), 0, 5421 (sy_call_t *)rumpns_sys_nomodule }, /* 252 = _ksem_wait */ 5422 { ns(struct sys__ksem_trywait_args), 0, 5423 (sy_call_t *)rumpns_sys_nomodule }, /* 253 = _ksem_trywait */ 5424 { ns(struct sys__ksem_getvalue_args), 0, 5425 (sy_call_t *)rumpns_sys_nomodule }, /* 254 = _ksem_getvalue */ 5426 { ns(struct sys__ksem_destroy_args), 0, 5427 (sy_call_t *)rumpns_sys_nomodule }, /* 255 = _ksem_destroy */ 5428 { ns(struct sys__ksem_timedwait_args), 0, 5429 (sy_call_t *)rumpns_sys_nomodule }, /* 256 = _ksem_timedwait */ 5430 { 0, 0, 0, 5431 (sy_call_t *)rumpns_sys_nomodule }, /* 257 = mq_open */ 5432 { 0, 0, 0, 5433 (sy_call_t *)rumpns_sys_nomodule }, /* 258 = mq_close */ 5434 { 0, 0, 0, 5435 (sy_call_t *)rumpns_sys_nomodule }, /* 259 = mq_unlink */ 5436 { 0, 0, 0, 5437 (sy_call_t *)rumpns_sys_nomodule }, /* 260 = mq_getattr */ 5438 { 0, 0, 0, 5439 (sy_call_t *)rumpns_sys_nomodule }, /* 261 = mq_setattr */ 5440 { 0, 0, 0, 5441 (sy_call_t *)rumpns_sys_nomodule }, /* 262 = mq_notify */ 5442 { 0, 0, 0, 5443 (sy_call_t *)rumpns_sys_nomodule }, /* 263 = mq_send */ 5444 { 0, 0, 0, 5445 (sy_call_t *)rumpns_sys_nomodule }, /* 264 = mq_receive */ 5446 { 0, 0, 0, 5447 (sy_call_t *)rumpns_sys_nomodule }, /* 265 = mq_timedsend */ 5448 { 0, 0, 0, 5449 (sy_call_t *)rumpns_sys_nomodule }, /* 266 = mq_timedreceive */ 5450 { 0, 0, SYCALL_NOSYS, 5451 (sy_call_t *)rump_enosys }, /* 267 = unimplemented */ 5452 { 0, 0, SYCALL_NOSYS, 5453 (sy_call_t *)rump_enosys }, /* 268 = unimplemented */ 5454 { 0, 0, SYCALL_NOSYS, 5455 (sy_call_t *)rump_enosys }, /* 269 = unimplemented */ 5456 { 0, 0, SYCALL_NOSYS, 5457 (sy_call_t *)rump_enosys }, /* 270 = __posix_rename */ 5458 { 0, 0, SYCALL_NOSYS, 5459 (sy_call_t *)rump_enosys }, /* 271 = swapctl */ 5460 { 0, 0, 0, 5461 (sy_call_t *)rumpns_sys_nomodule }, /* 272 = getdents */ 5462 { 0, 0, SYCALL_NOSYS, 5463 (sy_call_t *)rump_enosys }, /* 273 = minherit */ 5464 { ns(struct sys_lchmod_args), 0, 5465 (sy_call_t *)rumpns_sys_lchmod }, /* 274 = lchmod */ 5466 { ns(struct sys_lchown_args), 0, 5467 (sy_call_t *)rumpns_sys_lchown }, /* 275 = lchown */ 5468 { ns(struct compat_50_sys_lutimes_args), 0, 5469 (sy_call_t *)rumpns_compat_50_sys_lutimes },/* 276 = compat_50_lutimes */ 5470 { 0, 0, SYCALL_NOSYS, 5471 (sy_call_t *)rump_enosys }, /* 277 = __msync13 */ 5472 { 0, 0, 0, 5473 (sy_call_t *)rumpns_sys_nomodule }, /* 278 = __stat13 */ 5474 { 0, 0, 0, 5475 (sy_call_t *)rumpns_sys_nomodule }, /* 279 = __fstat13 */ 5476 { 0, 0, 0, 5477 (sy_call_t *)rumpns_sys_nomodule }, /* 280 = __lstat13 */ 5478 { 0, 0, SYCALL_NOSYS, 5479 (sy_call_t *)rump_enosys }, /* 281 = __sigaltstack14 */ 5480 { 0, 0, SYCALL_NOSYS, 5481 (sy_call_t *)rump_enosys }, /* 282 = __vfork14 */ 5482 { 0, 0, SYCALL_NOSYS, 5483 (sy_call_t *)rump_enosys }, /* 283 = __posix_chown */ 5484 { 0, 0, SYCALL_NOSYS, 5485 (sy_call_t *)rump_enosys }, /* 284 = __posix_fchown */ 5486 { 0, 0, SYCALL_NOSYS, 5487 (sy_call_t *)rump_enosys }, /* 285 = __posix_lchown */ 5488 { ns(struct sys_getsid_args), 0, 5489 (sy_call_t *)rumpns_sys_getsid }, /* 286 = getsid */ 5490 { 0, 0, SYCALL_NOSYS, 5491 (sy_call_t *)rump_enosys }, /* 287 = __clone */ 5492 { ns(struct sys_fktrace_args), 0, 5493 (sy_call_t *)rumpns_sys_fktrace }, /* 288 = fktrace */ 5494 { ns(struct sys_preadv_args), 0, 5495 (sy_call_t *)rumpns_sys_preadv }, /* 289 = preadv */ 5496 { ns(struct sys_pwritev_args), 0, 5497 (sy_call_t *)rumpns_sys_pwritev }, /* 290 = pwritev */ 5498 { 0, 0, 0, 5499 (sy_call_t *)rumpns_sys_nomodule }, /* 291 = __sigaction14 */ 5500 { 0, 0, SYCALL_NOSYS, 5501 (sy_call_t *)rump_enosys }, /* 292 = __sigpending14 */ 5502 { 0, 0, SYCALL_NOSYS, 5503 (sy_call_t *)rump_enosys }, /* 293 = __sigprocmask14 */ 5504 { 0, 0, SYCALL_NOSYS, 5505 (sy_call_t *)rump_enosys }, /* 294 = __sigsuspend14 */ 5506 { 0, 0, 0, 5507 (sy_call_t *)rumpns_sys_nomodule }, /* 295 = __sigreturn14 */ 5508 { ns(struct sys___getcwd_args), 0, 5509 (sy_call_t *)rumpns_sys___getcwd }, /* 296 = __getcwd */ 5510 { ns(struct sys_fchroot_args), 0, 5511 (sy_call_t *)rumpns_sys_fchroot }, /* 297 = fchroot */ 5512 { 0, 0, 0, 5513 (sy_call_t *)rumpns_sys_nomodule }, /* 298 = fhopen */ 5514 { 0, 0, 0, 5515 (sy_call_t *)rumpns_sys_nomodule }, /* 299 = fhstat */ 5516 { 0, 0, 0, 5517 (sy_call_t *)rumpns_sys_nomodule }, /* 300 = fhstatfs */ 5518 #if defined(SYSVSEM) || !defined(_KERNEL_OPT) 5519 { 0, 0, 0, 5520 (sy_call_t *)rumpns_sys_nomodule }, /* 301 = ____semctl13 */ 5521 #else 5522 { 0, 0, SYCALL_NOSYS, 5523 (sy_call_t *)rump_enosys }, /* 301 = excluded ____semctl13 */ 5524 #endif 5525 #if defined(SYSVMSG) || !defined(_KERNEL_OPT) 5526 { 0, 0, 0, 5527 (sy_call_t *)rumpns_sys_nomodule }, /* 302 = __msgctl13 */ 5528 #else 5529 { 0, 0, SYCALL_NOSYS, 5530 (sy_call_t *)rump_enosys }, /* 302 = excluded __msgctl13 */ 5531 #endif 5532 #if defined(SYSVSHM) || !defined(_KERNEL_OPT) 5533 { 0, 0, 0, 5534 (sy_call_t *)rumpns_sys_nomodule }, /* 303 = __shmctl13 */ 5535 #else 5536 { 0, 0, SYCALL_NOSYS, 5537 (sy_call_t *)rump_enosys }, /* 303 = excluded __shmctl13 */ 5538 #endif 5539 { ns(struct sys_lchflags_args), 0, 5540 (sy_call_t *)rumpns_sys_lchflags }, /* 304 = lchflags */ 5541 { 0, 0, 0, 5542 (sy_call_t *)rumpns_sys_issetugid },/* 305 = issetugid */ 5543 { 0, 0, SYCALL_NOSYS, 5544 (sy_call_t *)rump_enosys }, /* 306 = utrace */ 5545 { 0, 0, SYCALL_NOSYS, 5546 (sy_call_t *)rump_enosys }, /* 307 = getcontext */ 5547 { 0, 0, SYCALL_NOSYS, 5548 (sy_call_t *)rump_enosys }, /* 308 = setcontext */ 5549 { 0, 0, SYCALL_NOSYS, 5550 (sy_call_t *)rump_enosys }, /* 309 = _lwp_create */ 5551 { 0, 0, SYCALL_NOSYS, 5552 (sy_call_t *)rump_enosys }, /* 310 = _lwp_exit */ 5553 { 0, 0, SYCALL_NOSYS, 5554 (sy_call_t *)rump_enosys }, /* 311 = _lwp_self */ 5555 { 0, 0, SYCALL_NOSYS, 5556 (sy_call_t *)rump_enosys }, /* 312 = _lwp_wait */ 5557 { 0, 0, SYCALL_NOSYS, 5558 (sy_call_t *)rump_enosys }, /* 313 = _lwp_suspend */ 5559 { 0, 0, SYCALL_NOSYS, 5560 (sy_call_t *)rump_enosys }, /* 314 = _lwp_continue */ 5561 { 0, 0, SYCALL_NOSYS, 5562 (sy_call_t *)rump_enosys }, /* 315 = _lwp_wakeup */ 5563 { 0, 0, SYCALL_NOSYS, 5564 (sy_call_t *)rump_enosys }, /* 316 = _lwp_getprivate */ 5565 { 0, 0, SYCALL_NOSYS, 5566 (sy_call_t *)rump_enosys }, /* 317 = _lwp_setprivate */ 5567 { 0, 0, SYCALL_NOSYS, 5568 (sy_call_t *)rump_enosys }, /* 318 = _lwp_kill */ 5569 { 0, 0, SYCALL_NOSYS, 5570 (sy_call_t *)rump_enosys }, /* 319 = _lwp_detach */ 5571 { 0, 0, 0, 5572 (sy_call_t *)rumpns_sys_nomodule }, /* 320 = _lwp_park */ 5573 { 0, 0, SYCALL_NOSYS, 5574 (sy_call_t *)rump_enosys }, /* 321 = _lwp_unpark */ 5575 { 0, 0, SYCALL_NOSYS, 5576 (sy_call_t *)rump_enosys }, /* 322 = _lwp_unpark_all */ 5577 { 0, 0, SYCALL_NOSYS, 5578 (sy_call_t *)rump_enosys }, /* 323 = _lwp_setname */ 5579 { 0, 0, SYCALL_NOSYS, 5580 (sy_call_t *)rump_enosys }, /* 324 = _lwp_getname */ 5581 { 0, 0, SYCALL_NOSYS, 5582 (sy_call_t *)rump_enosys }, /* 325 = _lwp_ctl */ 5583 { 0, 0, SYCALL_NOSYS, 5584 (sy_call_t *)rump_enosys }, /* 326 = unimplemented */ 5585 { 0, 0, SYCALL_NOSYS, 5586 (sy_call_t *)rump_enosys }, /* 327 = unimplemented */ 5587 { 0, 0, SYCALL_NOSYS, 5588 (sy_call_t *)rump_enosys }, /* 328 = unimplemented */ 5589 { 0, 0, SYCALL_NOSYS, 5590 (sy_call_t *)rump_enosys }, /* 329 = unimplemented */ 5591 { 0, 0, SYCALL_NOSYS, 5592 (sy_call_t *)rump_enosys }, /* 330 = sa_register */ 5593 { 0, 0, SYCALL_NOSYS, 5594 (sy_call_t *)rump_enosys }, /* 331 = sa_stacks */ 5595 { 0, 0, SYCALL_NOSYS, 5596 (sy_call_t *)rump_enosys }, /* 332 = sa_enable */ 5597 { 0, 0, SYCALL_NOSYS, 5598 (sy_call_t *)rump_enosys }, /* 333 = sa_setconcurrency */ 5599 { 0, 0, SYCALL_NOSYS, 5600 (sy_call_t *)rump_enosys }, /* 334 = sa_yield */ 5601 { 0, 0, SYCALL_NOSYS, 5602 (sy_call_t *)rump_enosys }, /* 335 = sa_preempt */ 5603 { 0, 0, SYCALL_NOSYS, 5604 (sy_call_t *)rump_enosys }, /* 336 = obsolete sys_sa_unblockyield */ 5605 { 0, 0, SYCALL_NOSYS, 5606 (sy_call_t *)rump_enosys }, /* 337 = unimplemented */ 5607 { 0, 0, SYCALL_NOSYS, 5608 (sy_call_t *)rump_enosys }, /* 338 = unimplemented */ 5609 { 0, 0, SYCALL_NOSYS, 5610 (sy_call_t *)rump_enosys }, /* 339 = unimplemented */ 5611 { 0, 0, SYCALL_NOSYS, 5612 (sy_call_t *)rump_enosys }, /* 340 = __sigaction_sigtramp */ 5613 { 0, 0, SYCALL_NOSYS, 5614 (sy_call_t *)rump_enosys }, /* 341 = pmc_get_info */ 5615 { 0, 0, SYCALL_NOSYS, 5616 (sy_call_t *)rump_enosys }, /* 342 = pmc_control */ 5617 { 0, 0, SYCALL_NOSYS, 5618 (sy_call_t *)rump_enosys }, /* 343 = rasctl */ 5619 { 0, 0, 0, 5620 (sy_call_t *)rumpns_sys_kqueue }, /* 344 = kqueue */ 5621 { ns(struct compat_50_sys_kevent_args), 0, 5622 (sy_call_t *)rumpns_compat_50_sys_kevent },/* 345 = compat_50_kevent */ 5623 { 0, 0, SYCALL_NOSYS, 5624 (sy_call_t *)rump_enosys }, /* 346 = _sched_setparam */ 5625 { 0, 0, SYCALL_NOSYS, 5626 (sy_call_t *)rump_enosys }, /* 347 = _sched_getparam */ 5627 { 0, 0, SYCALL_NOSYS, 5628 (sy_call_t *)rump_enosys }, /* 348 = _sched_setaffinity */ 5629 { 0, 0, SYCALL_NOSYS, 5630 (sy_call_t *)rump_enosys }, /* 349 = _sched_getaffinity */ 5631 { 0, 0, SYCALL_NOSYS, 5632 (sy_call_t *)rump_enosys }, /* 350 = sched_yield */ 5633 { 0, 0, SYCALL_NOSYS, 5634 (sy_call_t *)rump_enosys }, /* 351 = unimplemented */ 5635 { 0, 0, SYCALL_NOSYS, 5636 (sy_call_t *)rump_enosys }, /* 352 = unimplemented */ 5637 { 0, 0, SYCALL_NOSYS, 5638 (sy_call_t *)rump_enosys }, /* 353 = unimplemented */ 5639 { ns(struct sys_fsync_range_args), 0, 5640 (sy_call_t *)rumpns_sys_fsync_range },/* 354 = fsync_range */ 5641 { 0, 0, SYCALL_NOSYS, 5642 (sy_call_t *)rump_enosys }, /* 355 = uuidgen */ 5643 { ns(struct sys_getvfsstat_args), 0, 5644 (sy_call_t *)rumpns_sys_getvfsstat },/* 356 = getvfsstat */ 5645 { ns(struct sys_statvfs1_args), 0, 5646 (sy_call_t *)rumpns_sys_statvfs1 }, /* 357 = statvfs1 */ 5647 { ns(struct sys_fstatvfs1_args), 0, 5648 (sy_call_t *)rumpns_sys_fstatvfs1 },/* 358 = fstatvfs1 */ 5649 { 0, 0, 0, 5650 (sy_call_t *)rumpns_sys_nomodule }, /* 359 = fhstatvfs1 */ 5651 { ns(struct sys_extattrctl_args), 0, 5652 (sy_call_t *)rumpns_sys_extattrctl },/* 360 = extattrctl */ 5653 { ns(struct sys_extattr_set_file_args), 0, 5654 (sy_call_t *)rumpns_sys_extattr_set_file },/* 361 = extattr_set_file */ 5655 { ns(struct sys_extattr_get_file_args), 0, 5656 (sy_call_t *)rumpns_sys_extattr_get_file },/* 362 = extattr_get_file */ 5657 { ns(struct sys_extattr_delete_file_args), 0, 5658 (sy_call_t *)rumpns_sys_extattr_delete_file },/* 363 = extattr_delete_file */ 5659 { ns(struct sys_extattr_set_fd_args), 0, 5660 (sy_call_t *)rumpns_sys_extattr_set_fd },/* 364 = extattr_set_fd */ 5661 { ns(struct sys_extattr_get_fd_args), 0, 5662 (sy_call_t *)rumpns_sys_extattr_get_fd },/* 365 = extattr_get_fd */ 5663 { ns(struct sys_extattr_delete_fd_args), 0, 5664 (sy_call_t *)rumpns_sys_extattr_delete_fd },/* 366 = extattr_delete_fd */ 5665 { ns(struct sys_extattr_set_link_args), 0, 5666 (sy_call_t *)rumpns_sys_extattr_set_link },/* 367 = extattr_set_link */ 5667 { ns(struct sys_extattr_get_link_args), 0, 5668 (sy_call_t *)rumpns_sys_extattr_get_link },/* 368 = extattr_get_link */ 5669 { ns(struct sys_extattr_delete_link_args), 0, 5670 (sy_call_t *)rumpns_sys_extattr_delete_link },/* 369 = extattr_delete_link */ 5671 { ns(struct sys_extattr_list_fd_args), 0, 5672 (sy_call_t *)rumpns_sys_extattr_list_fd },/* 370 = extattr_list_fd */ 5673 { ns(struct sys_extattr_list_file_args), 0, 5674 (sy_call_t *)rumpns_sys_extattr_list_file },/* 371 = extattr_list_file */ 5675 { ns(struct sys_extattr_list_link_args), 0, 5676 (sy_call_t *)rumpns_sys_extattr_list_link },/* 372 = extattr_list_link */ 5677 { ns(struct compat_50_sys_pselect_args), 0, 5678 (sy_call_t *)rumpns_compat_50_sys_pselect },/* 373 = compat_50_pselect */ 5679 { ns(struct compat_50_sys_pollts_args), 0, 5680 (sy_call_t *)rumpns_compat_50_sys_pollts },/* 374 = compat_50_pollts */ 5681 { ns(struct sys_setxattr_args), 0, 5682 (sy_call_t *)rumpns_sys_setxattr }, /* 375 = setxattr */ 5683 { ns(struct sys_lsetxattr_args), 0, 5684 (sy_call_t *)rumpns_sys_lsetxattr },/* 376 = lsetxattr */ 5685 { ns(struct sys_fsetxattr_args), 0, 5686 (sy_call_t *)rumpns_sys_fsetxattr },/* 377 = fsetxattr */ 5687 { ns(struct sys_getxattr_args), 0, 5688 (sy_call_t *)rumpns_sys_getxattr }, /* 378 = getxattr */ 5689 { ns(struct sys_lgetxattr_args), 0, 5690 (sy_call_t *)rumpns_sys_lgetxattr },/* 379 = lgetxattr */ 5691 { ns(struct sys_fgetxattr_args), 0, 5692 (sy_call_t *)rumpns_sys_fgetxattr },/* 380 = fgetxattr */ 5693 { ns(struct sys_listxattr_args), 0, 5694 (sy_call_t *)rumpns_sys_listxattr },/* 381 = listxattr */ 5695 { ns(struct sys_llistxattr_args), 0, 5696 (sy_call_t *)rumpns_sys_llistxattr },/* 382 = llistxattr */ 5697 { ns(struct sys_flistxattr_args), 0, 5698 (sy_call_t *)rumpns_sys_flistxattr },/* 383 = flistxattr */ 5699 { ns(struct sys_removexattr_args), 0, 5700 (sy_call_t *)rumpns_sys_removexattr },/* 384 = removexattr */ 5701 { ns(struct sys_lremovexattr_args), 0, 5702 (sy_call_t *)rumpns_sys_lremovexattr },/* 385 = lremovexattr */ 5703 { ns(struct sys_fremovexattr_args), 0, 5704 (sy_call_t *)rumpns_sys_fremovexattr },/* 386 = fremovexattr */ 5705 { ns(struct compat_50_sys___stat30_args), 0, 5706 (sy_call_t *)rumpns_compat_50_sys___stat30 },/* 387 = compat_50___stat30 */ 5707 { ns(struct compat_50_sys___fstat30_args), 0, 5708 (sy_call_t *)rumpns_compat_50_sys___fstat30 },/* 388 = compat_50___fstat30 */ 5709 { ns(struct compat_50_sys___lstat30_args), 0, 5710 (sy_call_t *)rumpns_compat_50_sys___lstat30 },/* 389 = compat_50___lstat30 */ 5711 { ns(struct sys___getdents30_args), 0, 5712 (sy_call_t *)rumpns_sys___getdents30 },/* 390 = __getdents30 */ 5713 { 0, 0, SYCALL_NOSYS, 5714 (sy_call_t *)rump_enosys }, /* 391 = ignored old posix_fadvise */ 5715 { 0, 0, 0, 5716 (sy_call_t *)rumpns_sys_nomodule }, /* 392 = __fhstat30 */ 5717 { 0, 0, 0, 5718 (sy_call_t *)rumpns_sys_nomodule }, /* 393 = __ntp_gettime30 */ 5719 { ns(struct sys___socket30_args), 0, 5720 (sy_call_t *)rumpns_sys___socket30 },/* 394 = __socket30 */ 5721 { ns(struct sys___getfh30_args), 0, 5722 (sy_call_t *)rumpns_sys___getfh30 },/* 395 = __getfh30 */ 5723 { ns(struct sys___fhopen40_args), 0, 5724 (sy_call_t *)rumpns_sys___fhopen40 },/* 396 = __fhopen40 */ 5725 { ns(struct sys___fhstatvfs140_args), 0, 5726 (sy_call_t *)rumpns_sys___fhstatvfs140 },/* 397 = __fhstatvfs140 */ 5727 { ns(struct compat_50_sys___fhstat40_args), 0, 5728 (sy_call_t *)rumpns_compat_50_sys___fhstat40 },/* 398 = compat_50___fhstat40 */ 5729 { 0, 0, 0, 5730 (sy_call_t *)rumpns_sys_nomodule }, /* 399 = aio_cancel */ 5731 { 0, 0, 0, 5732 (sy_call_t *)rumpns_sys_nomodule }, /* 400 = aio_error */ 5733 { 0, 0, 0, 5734 (sy_call_t *)rumpns_sys_nomodule }, /* 401 = aio_fsync */ 5735 { 0, 0, 0, 5736 (sy_call_t *)rumpns_sys_nomodule }, /* 402 = aio_read */ 5737 { 0, 0, 0, 5738 (sy_call_t *)rumpns_sys_nomodule }, /* 403 = aio_return */ 5739 { 0, 0, 0, 5740 (sy_call_t *)rumpns_sys_nomodule }, /* 404 = aio_suspend */ 5741 { 0, 0, 0, 5742 (sy_call_t *)rumpns_sys_nomodule }, /* 405 = aio_write */ 5743 { 0, 0, 0, 5744 (sy_call_t *)rumpns_sys_nomodule }, /* 406 = lio_listio */ 5745 { 0, 0, SYCALL_NOSYS, 5746 (sy_call_t *)rump_enosys }, /* 407 = unimplemented */ 5747 { 0, 0, SYCALL_NOSYS, 5748 (sy_call_t *)rump_enosys }, /* 408 = unimplemented */ 5749 { 0, 0, SYCALL_NOSYS, 5750 (sy_call_t *)rump_enosys }, /* 409 = unimplemented */ 5751 { ns(struct sys___mount50_args), 0, 5752 (sy_call_t *)rumpns_sys___mount50 },/* 410 = __mount50 */ 5753 { 0, 0, SYCALL_NOSYS, 5754 (sy_call_t *)rump_enosys }, /* 411 = mremap */ 5755 { 0, 0, SYCALL_NOSYS, 5756 (sy_call_t *)rump_enosys }, /* 412 = pset_create */ 5757 { 0, 0, SYCALL_NOSYS, 5758 (sy_call_t *)rump_enosys }, /* 413 = pset_destroy */ 5759 { 0, 0, SYCALL_NOSYS, 5760 (sy_call_t *)rump_enosys }, /* 414 = pset_assign */ 5761 { 0, 0, SYCALL_NOSYS, 5762 (sy_call_t *)rump_enosys }, /* 415 = _pset_bind */ 5763 { ns(struct sys___posix_fadvise50_args), 0, 5764 (sy_call_t *)rumpns_sys___posix_fadvise50 },/* 416 = __posix_fadvise50 */ 5765 { ns(struct sys___select50_args), 0, 5766 (sy_call_t *)rumpns_sys___select50 },/* 417 = __select50 */ 5767 { 0, 0, SYCALL_NOSYS, 5768 (sy_call_t *)rump_enosys }, /* 418 = __gettimeofday50 */ 5769 { 0, 0, SYCALL_NOSYS, 5770 (sy_call_t *)rump_enosys }, /* 419 = __settimeofday50 */ 5771 { ns(struct sys___utimes50_args), 0, 5772 (sy_call_t *)rumpns_sys___utimes50 },/* 420 = __utimes50 */ 5773 { 0, 0, SYCALL_NOSYS, 5774 (sy_call_t *)rump_enosys }, /* 421 = __adjtime50 */ 5775 { 0, 0, 0, 5776 (sy_call_t *)rumpns_sys_nomodule }, /* 422 = __lfs_segwait50 */ 5777 { ns(struct sys___futimes50_args), 0, 5778 (sy_call_t *)rumpns_sys___futimes50 },/* 423 = __futimes50 */ 5779 { ns(struct sys___lutimes50_args), 0, 5780 (sy_call_t *)rumpns_sys___lutimes50 },/* 424 = __lutimes50 */ 5781 { 0, 0, SYCALL_NOSYS, 5782 (sy_call_t *)rump_enosys }, /* 425 = __setitimer50 */ 5783 { 0, 0, SYCALL_NOSYS, 5784 (sy_call_t *)rump_enosys }, /* 426 = __getitimer50 */ 5785 { 0, 0, SYCALL_NOSYS, 5786 (sy_call_t *)rump_enosys }, /* 427 = __clock_gettime50 */ 5787 { 0, 0, SYCALL_NOSYS, 5788 (sy_call_t *)rump_enosys }, /* 428 = __clock_settime50 */ 5789 { 0, 0, SYCALL_NOSYS, 5790 (sy_call_t *)rump_enosys }, /* 429 = __clock_getres50 */ 5791 { 0, 0, SYCALL_NOSYS, 5792 (sy_call_t *)rump_enosys }, /* 430 = __nanosleep50 */ 5793 { 0, 0, SYCALL_NOSYS, 5794 (sy_call_t *)rump_enosys }, /* 431 = ____sigtimedwait50 */ 5795 { 0, 0, 0, 5796 (sy_call_t *)rumpns_sys_nomodule }, /* 432 = __mq_timedsend50 */ 5797 { 0, 0, 0, 5798 (sy_call_t *)rumpns_sys_nomodule }, /* 433 = __mq_timedreceive50 */ 5799 { 0, 0, 0, 5800 (sy_call_t *)rumpns_sys_nomodule }, /* 434 = _lwp_park */ 5801 { ns(struct sys___kevent50_args), 0, 5802 (sy_call_t *)rumpns_sys___kevent50 },/* 435 = __kevent50 */ 5803 { ns(struct sys___pselect50_args), 0, 5804 (sy_call_t *)rumpns_sys___pselect50 },/* 436 = __pselect50 */ 5805 { ns(struct sys___pollts50_args), 0, 5806 (sy_call_t *)rumpns_sys___pollts50 },/* 437 = __pollts50 */ 5807 { 0, 0, 0, 5808 (sy_call_t *)rumpns_sys_nomodule }, /* 438 = __aio_suspend50 */ 5809 { ns(struct sys___stat50_args), 0, 5810 (sy_call_t *)rumpns_sys___stat50 }, /* 439 = __stat50 */ 5811 { ns(struct sys___fstat50_args), 0, 5812 (sy_call_t *)rumpns_sys___fstat50 },/* 440 = __fstat50 */ 5813 { ns(struct sys___lstat50_args), 0, 5814 (sy_call_t *)rumpns_sys___lstat50 },/* 441 = __lstat50 */ 5815 #if defined(SYSVSEM) || !defined(_KERNEL_OPT) 5816 { 0, 0, SYCALL_NOSYS, 5817 (sy_call_t *)rump_enosys }, /* 442 = ____semctl50 */ 5818 #else 5819 { 0, 0, SYCALL_NOSYS, 5820 (sy_call_t *)rump_enosys }, /* 442 = excluded ____semctl50 */ 5821 #endif 5822 #if defined(SYSVSHM) || !defined(_KERNEL_OPT) 5823 { 0, 0, SYCALL_NOSYS, 5824 (sy_call_t *)rump_enosys }, /* 443 = __shmctl50 */ 5825 #else 5826 { 0, 0, SYCALL_NOSYS, 5827 (sy_call_t *)rump_enosys }, /* 443 = excluded ____shmctl50 */ 5828 #endif 5829 #if defined(SYSVMSG) || !defined(_KERNEL_OPT) 5830 { 0, 0, SYCALL_NOSYS, 5831 (sy_call_t *)rump_enosys }, /* 444 = __msgctl50 */ 5832 #else 5833 { 0, 0, SYCALL_NOSYS, 5834 (sy_call_t *)rump_enosys }, /* 444 = excluded ____msgctl50 */ 5835 #endif 5836 { 0, 0, SYCALL_NOSYS, 5837 (sy_call_t *)rump_enosys }, /* 445 = __getrusage50 */ 5838 { 0, 0, SYCALL_NOSYS, 5839 (sy_call_t *)rump_enosys }, /* 446 = __timer_settime50 */ 5840 { 0, 0, SYCALL_NOSYS, 5841 (sy_call_t *)rump_enosys }, /* 447 = __timer_gettime50 */ 5842 #if defined(NTP) || !defined(_KERNEL_OPT) 5843 { 0, 0, SYCALL_NOSYS, 5844 (sy_call_t *)rump_enosys }, /* 448 = __ntp_gettime50 */ 5845 #else 5846 { 0, 0, SYCALL_NOSYS, 5847 (sy_call_t *)rump_enosys }, /* 448 = excluded ___ntp_gettime50 */ 5848 #endif 5849 { 0, 0, SYCALL_NOSYS, 5850 (sy_call_t *)rump_enosys }, /* 449 = __wait450 */ 5851 { ns(struct sys___mknod50_args), 0, 5852 (sy_call_t *)rumpns_sys___mknod50 },/* 450 = __mknod50 */ 5853 { ns(struct sys___fhstat50_args), 0, 5854 (sy_call_t *)rumpns_sys___fhstat50 },/* 451 = __fhstat50 */ 5855 { 0, 0, SYCALL_NOSYS, 5856 (sy_call_t *)rump_enosys }, /* 452 = obsolete 5.99 quotactl */ 5857 { ns(struct sys_pipe2_args), 0, 5858 (sy_call_t *)rumpns_sys_pipe2 }, /* 453 = pipe2 */ 5859 { ns(struct sys_dup3_args), 0, 5860 (sy_call_t *)rumpns_sys_dup3 }, /* 454 = dup3 */ 5861 { ns(struct sys_kqueue1_args), 0, 5862 (sy_call_t *)rumpns_sys_kqueue1 }, /* 455 = kqueue1 */ 5863 { ns(struct sys_paccept_args), 0, 5864 (sy_call_t *)rumpns_sys_paccept }, /* 456 = paccept */ 5865 { ns(struct sys_linkat_args), 0, 5866 (sy_call_t *)rumpns_sys_linkat }, /* 457 = linkat */ 5867 { ns(struct sys_renameat_args), 0, 5868 (sy_call_t *)rumpns_sys_renameat }, /* 458 = renameat */ 5869 { ns(struct sys_mkfifoat_args), 0, 5870 (sy_call_t *)rumpns_sys_mkfifoat }, /* 459 = mkfifoat */ 5871 { ns(struct sys_mknodat_args), 0, 5872 (sy_call_t *)rumpns_sys_mknodat }, /* 460 = mknodat */ 5873 { ns(struct sys_mkdirat_args), 0, 5874 (sy_call_t *)rumpns_sys_mkdirat }, /* 461 = mkdirat */ 5875 { ns(struct sys_faccessat_args), 0, 5876 (sy_call_t *)rumpns_sys_faccessat },/* 462 = faccessat */ 5877 { ns(struct sys_fchmodat_args), 0, 5878 (sy_call_t *)rumpns_sys_fchmodat }, /* 463 = fchmodat */ 5879 { ns(struct sys_fchownat_args), 0, 5880 (sy_call_t *)rumpns_sys_fchownat }, /* 464 = fchownat */ 5881 { 0, 0, SYCALL_NOSYS, 5882 (sy_call_t *)rump_enosys }, /* 465 = fexecve */ 5883 { ns(struct sys_fstatat_args), 0, 5884 (sy_call_t *)rumpns_sys_fstatat }, /* 466 = fstatat */ 5885 { ns(struct sys_utimensat_args), 0, 5886 (sy_call_t *)rumpns_sys_utimensat },/* 467 = utimensat */ 5887 { ns(struct sys_openat_args), 0, 5888 (sy_call_t *)rumpns_sys_openat }, /* 468 = openat */ 5889 { ns(struct sys_readlinkat_args), 0, 5890 (sy_call_t *)rumpns_sys_readlinkat },/* 469 = readlinkat */ 5891 { ns(struct sys_symlinkat_args), 0, 5892 (sy_call_t *)rumpns_sys_symlinkat },/* 470 = symlinkat */ 5893 { ns(struct sys_unlinkat_args), 0, 5894 (sy_call_t *)rumpns_sys_unlinkat }, /* 471 = unlinkat */ 5895 { ns(struct sys_futimens_args), 0, 5896 (sy_call_t *)rumpns_sys_futimens }, /* 472 = futimens */ 5897 { ns(struct sys___quotactl_args), 0, 5898 (sy_call_t *)rumpns_sys___quotactl },/* 473 = __quotactl */ 5899 { 0, 0, SYCALL_NOSYS, 5900 (sy_call_t *)rump_enosys }, /* 474 = posix_spawn */ 5901 { ns(struct sys_recvmmsg_args), 0, 5902 (sy_call_t *)rumpns_sys_recvmmsg }, /* 475 = recvmmsg */ 5903 { ns(struct sys_sendmmsg_args), 0, 5904 (sy_call_t *)rumpns_sys_sendmmsg }, /* 476 = sendmmsg */ 5905 { 0, 0, SYCALL_NOSYS, 5906 (sy_call_t *)rump_enosys }, /* 477 = clock_nanosleep */ 5907 { 0, 0, SYCALL_NOSYS, 5908 (sy_call_t *)rump_enosys }, /* 478 = ___lwp_park60 */ 5909 { 0, 0, SYCALL_NOSYS, 5910 (sy_call_t *)rump_enosys }, /* 479 = filler */ 5911 { 0, 0, SYCALL_NOSYS, 5912 (sy_call_t *)rump_enosys }, /* 480 = filler */ 5913 { 0, 0, SYCALL_NOSYS, 5914 (sy_call_t *)rump_enosys }, /* 481 = filler */ 5915 { 0, 0, SYCALL_NOSYS, 5916 (sy_call_t *)rump_enosys }, /* 482 = filler */ 5917 { 0, 0, SYCALL_NOSYS, 5918 (sy_call_t *)rump_enosys }, /* 483 = filler */ 5919 { 0, 0, SYCALL_NOSYS, 5920 (sy_call_t *)rump_enosys }, /* 484 = filler */ 5921 { 0, 0, SYCALL_NOSYS, 5922 (sy_call_t *)rump_enosys }, /* 485 = filler */ 5923 { 0, 0, SYCALL_NOSYS, 5924 (sy_call_t *)rump_enosys }, /* 486 = filler */ 5925 { 0, 0, SYCALL_NOSYS, 5926 (sy_call_t *)rump_enosys }, /* 487 = filler */ 5927 { 0, 0, SYCALL_NOSYS, 5928 (sy_call_t *)rump_enosys }, /* 488 = filler */ 5929 { 0, 0, SYCALL_NOSYS, 5930 (sy_call_t *)rump_enosys }, /* 489 = filler */ 5931 { 0, 0, SYCALL_NOSYS, 5932 (sy_call_t *)rump_enosys }, /* 490 = filler */ 5933 { 0, 0, SYCALL_NOSYS, 5934 (sy_call_t *)rump_enosys }, /* 491 = filler */ 5935 { 0, 0, SYCALL_NOSYS, 5936 (sy_call_t *)rump_enosys }, /* 492 = filler */ 5937 { 0, 0, SYCALL_NOSYS, 5938 (sy_call_t *)rump_enosys }, /* 493 = filler */ 5939 { 0, 0, SYCALL_NOSYS, 5940 (sy_call_t *)rump_enosys }, /* 494 = filler */ 5941 { 0, 0, SYCALL_NOSYS, 5942 (sy_call_t *)rump_enosys }, /* 495 = filler */ 5943 { 0, 0, SYCALL_NOSYS, 5944 (sy_call_t *)rump_enosys }, /* 496 = filler */ 5945 { 0, 0, SYCALL_NOSYS, 5946 (sy_call_t *)rump_enosys }, /* 497 = filler */ 5947 { 0, 0, SYCALL_NOSYS, 5948 (sy_call_t *)rump_enosys }, /* 498 = filler */ 5949 { 0, 0, SYCALL_NOSYS, 5950 (sy_call_t *)rump_enosys }, /* 499 = filler */ 5951 { 0, 0, SYCALL_NOSYS, 5952 (sy_call_t *)rump_enosys }, /* 500 = filler */ 5953 { 0, 0, SYCALL_NOSYS, 5954 (sy_call_t *)rump_enosys }, /* 501 = filler */ 5955 { 0, 0, SYCALL_NOSYS, 5956 (sy_call_t *)rump_enosys }, /* 502 = filler */ 5957 { 0, 0, SYCALL_NOSYS, 5958 (sy_call_t *)rump_enosys }, /* 503 = filler */ 5959 { 0, 0, SYCALL_NOSYS, 5960 (sy_call_t *)rump_enosys }, /* 504 = filler */ 5961 { 0, 0, SYCALL_NOSYS, 5962 (sy_call_t *)rump_enosys }, /* 505 = filler */ 5963 { 0, 0, SYCALL_NOSYS, 5964 (sy_call_t *)rump_enosys }, /* 506 = filler */ 5965 { 0, 0, SYCALL_NOSYS, 5966 (sy_call_t *)rump_enosys }, /* 507 = filler */ 5967 { 0, 0, SYCALL_NOSYS, 5968 (sy_call_t *)rump_enosys }, /* 508 = filler */ 5969 { 0, 0, SYCALL_NOSYS, 5970 (sy_call_t *)rump_enosys }, /* 509 = filler */ 5971 { 0, 0, SYCALL_NOSYS, 5972 (sy_call_t *)rump_enosys }, /* 510 = filler */ 5973 { 0, 0, SYCALL_NOSYS, 5974 (sy_call_t *)rump_enosys }, /* 511 = filler */ 5975 }; 5976 CTASSERT(__arraycount(rump_sysent) == SYS_NSYSENT); 5977 __strong_alias(rumpns_sysent,rump_sysent); 5978 #endif /* RUMP_CLIENT */ 5979
Indexes created Tue Sep 30 20:09:53 GMT 2025