rump_syscalls.c revision 1.54
1 /* $NetBSD: rump_syscalls.c,v 1.54 2010/11/11 14:48:14 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.239 2010/11/11 14:47:41 pooka Exp 8 */ 9 10 #include <sys/cdefs.h> 11 __KERNEL_RCSID(0, "$NetBSD: rump_syscalls.c,v 1.54 2010/11/11 14:48:14 pooka Exp $"); 12 13 #include <sys/param.h> 14 #include <sys/fstypes.h> 15 #include <sys/proc.h> 16 #include <sys/syscall.h> 17 #include <sys/syscallargs.h> 18 19 #ifdef RUMP_CLIENT 20 #include <errno.h> 21 #include <rump/rumpclient.h> 22 23 #define rsys_syscall(num, data, dlen, retval) \ 24 rumpclient_syscall(num, data, dlen, retval) 25 #define rsys_seterrno(error) errno = error 26 #define rsys_alias(a,b) 27 #else 28 #include <rump/rumpuser.h> 29 #include "rump_private.h" 30 31 static int 32 rsys_syscall(int num, void *data, size_t dlen, register_t *retval) 33 { 34 int rv; 35 36 rump_schedule(); 37 rv = rump_syscall(num, data, retval); 38 rump_unschedule(); 39 40 return rv; 41 } 42 43 #define rsys_seterrno(error) rumpuser_seterrno(error) 44 #define rsys_alias(a,b) __weak_alias(a,b); 45 #endif 46 47 #if BYTE_ORDER == BIG_ENDIAN 48 #define SPARG(p,k) ((p)->k.be.datum) 49 #else /* LITTLE_ENDIAN, I hope dearly */ 50 #define SPARG(p,k) ((p)->k.le.datum) 51 #endif 52 53 #ifndef RUMP_CLIENT 54 int rump_enosys(void); 55 int 56 rump_enosys() 57 { 58 59 return ENOSYS; 60 } 61 #endif 62 63 ssize_t rump_sys_read(int, void *, size_t); 64 ssize_t 65 rump_sys_read(int fd, void * buf, size_t nbyte) 66 { 67 register_t rval[2] = {0, 0}; 68 int error = 0; 69 struct sys_read_args callarg; 70 71 SPARG(&callarg, fd) = fd; 72 SPARG(&callarg, buf) = buf; 73 SPARG(&callarg, nbyte) = nbyte; 74 75 error = rsys_syscall(SYS_read, &callarg, sizeof(callarg), rval); 76 if (error) { 77 rval[0] = -1; 78 rsys_seterrno(error); 79 } 80 return rval[0]; 81 } 82 rsys_alias(sys_read,rump_enosys) 83 84 ssize_t rump_sys_write(int, const void *, size_t); 85 ssize_t 86 rump_sys_write(int fd, const void * buf, size_t nbyte) 87 { 88 register_t rval[2] = {0, 0}; 89 int error = 0; 90 struct sys_write_args callarg; 91 92 SPARG(&callarg, fd) = fd; 93 SPARG(&callarg, buf) = buf; 94 SPARG(&callarg, nbyte) = nbyte; 95 96 error = rsys_syscall(SYS_write, &callarg, sizeof(callarg), rval); 97 if (error) { 98 rval[0] = -1; 99 rsys_seterrno(error); 100 } 101 return rval[0]; 102 } 103 rsys_alias(sys_write,rump_enosys) 104 105 int rump_sys_open(const char *, int, mode_t); 106 int 107 rump_sys_open(const char * path, int flags, mode_t mode) 108 { 109 register_t rval[2] = {0, 0}; 110 int error = 0; 111 struct sys_open_args callarg; 112 113 SPARG(&callarg, path) = path; 114 SPARG(&callarg, flags) = flags; 115 SPARG(&callarg, mode) = mode; 116 117 error = rsys_syscall(SYS_open, &callarg, sizeof(callarg), rval); 118 if (error) { 119 rval[0] = -1; 120 rsys_seterrno(error); 121 } 122 return rval[0]; 123 } 124 rsys_alias(sys_open,rump_enosys) 125 126 int rump_sys_close(int); 127 int 128 rump_sys_close(int fd) 129 { 130 register_t rval[2] = {0, 0}; 131 int error = 0; 132 struct sys_close_args callarg; 133 134 SPARG(&callarg, fd) = fd; 135 136 error = rsys_syscall(SYS_close, &callarg, sizeof(callarg), rval); 137 if (error) { 138 rval[0] = -1; 139 rsys_seterrno(error); 140 } 141 return rval[0]; 142 } 143 rsys_alias(sys_close,rump_enosys) 144 145 int rump_sys_link(const char *, const char *); 146 int 147 rump_sys_link(const char * path, const char * link) 148 { 149 register_t rval[2] = {0, 0}; 150 int error = 0; 151 struct sys_link_args callarg; 152 153 SPARG(&callarg, path) = path; 154 SPARG(&callarg, link) = link; 155 156 error = rsys_syscall(SYS_link, &callarg, sizeof(callarg), rval); 157 if (error) { 158 rval[0] = -1; 159 rsys_seterrno(error); 160 } 161 return rval[0]; 162 } 163 rsys_alias(sys_link,rump_enosys) 164 165 int rump_sys_unlink(const char *); 166 int 167 rump_sys_unlink(const char * path) 168 { 169 register_t rval[2] = {0, 0}; 170 int error = 0; 171 struct sys_unlink_args callarg; 172 173 SPARG(&callarg, path) = path; 174 175 error = rsys_syscall(SYS_unlink, &callarg, sizeof(callarg), rval); 176 if (error) { 177 rval[0] = -1; 178 rsys_seterrno(error); 179 } 180 return rval[0]; 181 } 182 rsys_alias(sys_unlink,rump_enosys) 183 184 int rump_sys_chdir(const char *); 185 int 186 rump_sys_chdir(const char * path) 187 { 188 register_t rval[2] = {0, 0}; 189 int error = 0; 190 struct sys_chdir_args callarg; 191 192 SPARG(&callarg, path) = path; 193 194 error = rsys_syscall(SYS_chdir, &callarg, sizeof(callarg), rval); 195 if (error) { 196 rval[0] = -1; 197 rsys_seterrno(error); 198 } 199 return rval[0]; 200 } 201 rsys_alias(sys_chdir,rump_enosys) 202 203 int rump_sys_fchdir(int); 204 int 205 rump_sys_fchdir(int fd) 206 { 207 register_t rval[2] = {0, 0}; 208 int error = 0; 209 struct sys_fchdir_args callarg; 210 211 SPARG(&callarg, fd) = fd; 212 213 error = rsys_syscall(SYS_fchdir, &callarg, sizeof(callarg), rval); 214 if (error) { 215 rval[0] = -1; 216 rsys_seterrno(error); 217 } 218 return rval[0]; 219 } 220 rsys_alias(sys_fchdir,rump_enosys) 221 222 int rump_sys_chmod(const char *, mode_t); 223 int 224 rump_sys_chmod(const char * path, mode_t mode) 225 { 226 register_t rval[2] = {0, 0}; 227 int error = 0; 228 struct sys_chmod_args callarg; 229 230 SPARG(&callarg, path) = path; 231 SPARG(&callarg, mode) = mode; 232 233 error = rsys_syscall(SYS_chmod, &callarg, sizeof(callarg), rval); 234 if (error) { 235 rval[0] = -1; 236 rsys_seterrno(error); 237 } 238 return rval[0]; 239 } 240 rsys_alias(sys_chmod,rump_enosys) 241 242 int rump_sys_chown(const char *, uid_t, gid_t); 243 int 244 rump_sys_chown(const char * path, uid_t uid, gid_t gid) 245 { 246 register_t rval[2] = {0, 0}; 247 int error = 0; 248 struct sys_chown_args callarg; 249 250 SPARG(&callarg, path) = path; 251 SPARG(&callarg, uid) = uid; 252 SPARG(&callarg, gid) = gid; 253 254 error = rsys_syscall(SYS_chown, &callarg, sizeof(callarg), rval); 255 if (error) { 256 rval[0] = -1; 257 rsys_seterrno(error); 258 } 259 return rval[0]; 260 } 261 rsys_alias(sys_chown,rump_enosys) 262 263 pid_t rump_sys_getpid(void); 264 pid_t 265 rump_sys_getpid(void ) 266 { 267 register_t rval[2] = {0, 0}; 268 int error = 0; 269 270 error = rsys_syscall(SYS_getpid, NULL, 0, rval); 271 if (error) { 272 rval[0] = -1; 273 rsys_seterrno(error); 274 } 275 return rval[0]; 276 } 277 rsys_alias(sys_getpid_with_ppid,rump_enosys) 278 279 int rump_sys_unmount(const char *, int); 280 int 281 rump_sys_unmount(const char * path, int flags) 282 { 283 register_t rval[2] = {0, 0}; 284 int error = 0; 285 struct sys_unmount_args callarg; 286 287 SPARG(&callarg, path) = path; 288 SPARG(&callarg, flags) = flags; 289 290 error = rsys_syscall(SYS_unmount, &callarg, sizeof(callarg), rval); 291 if (error) { 292 rval[0] = -1; 293 rsys_seterrno(error); 294 } 295 return rval[0]; 296 } 297 rsys_alias(sys_unmount,rump_enosys) 298 299 int rump_sys_setuid(uid_t); 300 int 301 rump_sys_setuid(uid_t uid) 302 { 303 register_t rval[2] = {0, 0}; 304 int error = 0; 305 struct sys_setuid_args callarg; 306 307 SPARG(&callarg, uid) = uid; 308 309 error = rsys_syscall(SYS_setuid, &callarg, sizeof(callarg), rval); 310 if (error) { 311 rval[0] = -1; 312 rsys_seterrno(error); 313 } 314 return rval[0]; 315 } 316 rsys_alias(sys_setuid,rump_enosys) 317 318 uid_t rump_sys_getuid(void); 319 uid_t 320 rump_sys_getuid(void ) 321 { 322 register_t rval[2] = {0, 0}; 323 int error = 0; 324 325 error = rsys_syscall(SYS_getuid, NULL, 0, rval); 326 if (error) { 327 rval[0] = -1; 328 rsys_seterrno(error); 329 } 330 return rval[0]; 331 } 332 rsys_alias(sys_getuid_with_euid,rump_enosys) 333 334 uid_t rump_sys_geteuid(void); 335 uid_t 336 rump_sys_geteuid(void ) 337 { 338 register_t rval[2] = {0, 0}; 339 int error = 0; 340 341 error = rsys_syscall(SYS_geteuid, NULL, 0, rval); 342 if (error) { 343 rval[0] = -1; 344 rsys_seterrno(error); 345 } 346 return rval[0]; 347 } 348 rsys_alias(sys_geteuid,rump_enosys) 349 350 ssize_t rump_sys_recvmsg(int, struct msghdr *, int); 351 ssize_t 352 rump_sys_recvmsg(int s, struct msghdr * msg, int flags) 353 { 354 register_t rval[2] = {0, 0}; 355 int error = 0; 356 struct sys_recvmsg_args callarg; 357 358 SPARG(&callarg, s) = s; 359 SPARG(&callarg, msg) = msg; 360 SPARG(&callarg, flags) = flags; 361 362 error = rsys_syscall(SYS_recvmsg, &callarg, sizeof(callarg), rval); 363 if (error) { 364 rval[0] = -1; 365 rsys_seterrno(error); 366 } 367 return rval[0]; 368 } 369 rsys_alias(sys_recvmsg,rump_enosys) 370 371 ssize_t rump_sys_sendmsg(int, const struct msghdr *, int); 372 ssize_t 373 rump_sys_sendmsg(int s, const struct msghdr * msg, int flags) 374 { 375 register_t rval[2] = {0, 0}; 376 int error = 0; 377 struct sys_sendmsg_args callarg; 378 379 SPARG(&callarg, s) = s; 380 SPARG(&callarg, msg) = msg; 381 SPARG(&callarg, flags) = flags; 382 383 error = rsys_syscall(SYS_sendmsg, &callarg, sizeof(callarg), rval); 384 if (error) { 385 rval[0] = -1; 386 rsys_seterrno(error); 387 } 388 return rval[0]; 389 } 390 rsys_alias(sys_sendmsg,rump_enosys) 391 392 ssize_t rump_sys_recvfrom(int, void *, size_t, int, struct sockaddr *, unsigned int *); 393 ssize_t 394 rump_sys_recvfrom(int s, void * buf, size_t len, int flags, struct sockaddr * from, unsigned int * fromlenaddr) 395 { 396 register_t rval[2] = {0, 0}; 397 int error = 0; 398 struct sys_recvfrom_args callarg; 399 400 SPARG(&callarg, s) = s; 401 SPARG(&callarg, buf) = buf; 402 SPARG(&callarg, len) = len; 403 SPARG(&callarg, flags) = flags; 404 SPARG(&callarg, from) = from; 405 SPARG(&callarg, fromlenaddr) = fromlenaddr; 406 407 error = rsys_syscall(SYS_recvfrom, &callarg, sizeof(callarg), rval); 408 if (error) { 409 rval[0] = -1; 410 rsys_seterrno(error); 411 } 412 return rval[0]; 413 } 414 rsys_alias(sys_recvfrom,rump_enosys) 415 416 int rump_sys_accept(int, struct sockaddr *, unsigned int *); 417 int 418 rump_sys_accept(int s, struct sockaddr * name, unsigned int * anamelen) 419 { 420 register_t rval[2] = {0, 0}; 421 int error = 0; 422 struct sys_accept_args callarg; 423 424 SPARG(&callarg, s) = s; 425 SPARG(&callarg, name) = name; 426 SPARG(&callarg, anamelen) = anamelen; 427 428 error = rsys_syscall(SYS_accept, &callarg, sizeof(callarg), rval); 429 if (error) { 430 rval[0] = -1; 431 rsys_seterrno(error); 432 } 433 return rval[0]; 434 } 435 rsys_alias(sys_accept,rump_enosys) 436 437 int rump_sys_getpeername(int, struct sockaddr *, unsigned int *); 438 int 439 rump_sys_getpeername(int fdes, struct sockaddr * asa, unsigned int * alen) 440 { 441 register_t rval[2] = {0, 0}; 442 int error = 0; 443 struct sys_getpeername_args callarg; 444 445 SPARG(&callarg, fdes) = fdes; 446 SPARG(&callarg, asa) = asa; 447 SPARG(&callarg, alen) = alen; 448 449 error = rsys_syscall(SYS_getpeername, &callarg, sizeof(callarg), rval); 450 if (error) { 451 rval[0] = -1; 452 rsys_seterrno(error); 453 } 454 return rval[0]; 455 } 456 rsys_alias(sys_getpeername,rump_enosys) 457 458 int rump_sys_getsockname(int, struct sockaddr *, unsigned int *); 459 int 460 rump_sys_getsockname(int fdes, struct sockaddr * asa, unsigned int * alen) 461 { 462 register_t rval[2] = {0, 0}; 463 int error = 0; 464 struct sys_getsockname_args callarg; 465 466 SPARG(&callarg, fdes) = fdes; 467 SPARG(&callarg, asa) = asa; 468 SPARG(&callarg, alen) = alen; 469 470 error = rsys_syscall(SYS_getsockname, &callarg, sizeof(callarg), rval); 471 if (error) { 472 rval[0] = -1; 473 rsys_seterrno(error); 474 } 475 return rval[0]; 476 } 477 rsys_alias(sys_getsockname,rump_enosys) 478 479 int rump_sys_access(const char *, int); 480 int 481 rump_sys_access(const char * path, int flags) 482 { 483 register_t rval[2] = {0, 0}; 484 int error = 0; 485 struct sys_access_args callarg; 486 487 SPARG(&callarg, path) = path; 488 SPARG(&callarg, flags) = flags; 489 490 error = rsys_syscall(SYS_access, &callarg, sizeof(callarg), rval); 491 if (error) { 492 rval[0] = -1; 493 rsys_seterrno(error); 494 } 495 return rval[0]; 496 } 497 rsys_alias(sys_access,rump_enosys) 498 499 int rump_sys_chflags(const char *, u_long); 500 int 501 rump_sys_chflags(const char * path, u_long flags) 502 { 503 register_t rval[2] = {0, 0}; 504 int error = 0; 505 struct sys_chflags_args callarg; 506 507 SPARG(&callarg, path) = path; 508 SPARG(&callarg, flags) = flags; 509 510 error = rsys_syscall(SYS_chflags, &callarg, sizeof(callarg), rval); 511 if (error) { 512 rval[0] = -1; 513 rsys_seterrno(error); 514 } 515 return rval[0]; 516 } 517 rsys_alias(sys_chflags,rump_enosys) 518 519 int rump_sys_fchflags(int, u_long); 520 int 521 rump_sys_fchflags(int fd, u_long flags) 522 { 523 register_t rval[2] = {0, 0}; 524 int error = 0; 525 struct sys_fchflags_args callarg; 526 527 SPARG(&callarg, fd) = fd; 528 SPARG(&callarg, flags) = flags; 529 530 error = rsys_syscall(SYS_fchflags, &callarg, sizeof(callarg), rval); 531 if (error) { 532 rval[0] = -1; 533 rsys_seterrno(error); 534 } 535 return rval[0]; 536 } 537 rsys_alias(sys_fchflags,rump_enosys) 538 539 void rump_sys_sync(void); 540 void 541 rump_sys_sync(void ) 542 { 543 register_t rval[2] = {0, 0}; 544 int error = 0; 545 546 error = rsys_syscall(SYS_sync, NULL, 0, rval); 547 if (error) { 548 rval[0] = -1; 549 } 550 } 551 rsys_alias(sys_sync,rump_enosys) 552 553 pid_t rump_sys_getppid(void); 554 pid_t 555 rump_sys_getppid(void ) 556 { 557 register_t rval[2] = {0, 0}; 558 int error = 0; 559 560 error = rsys_syscall(SYS_getppid, NULL, 0, rval); 561 if (error) { 562 rval[0] = -1; 563 rsys_seterrno(error); 564 } 565 return rval[0]; 566 } 567 rsys_alias(sys_getppid,rump_enosys) 568 569 int rump_sys_dup(int); 570 int 571 rump_sys_dup(int fd) 572 { 573 register_t rval[2] = {0, 0}; 574 int error = 0; 575 struct sys_dup_args callarg; 576 577 SPARG(&callarg, fd) = fd; 578 579 error = rsys_syscall(SYS_dup, &callarg, sizeof(callarg), rval); 580 if (error) { 581 rval[0] = -1; 582 rsys_seterrno(error); 583 } 584 return rval[0]; 585 } 586 rsys_alias(sys_dup,rump_enosys) 587 588 gid_t rump_sys_getegid(void); 589 gid_t 590 rump_sys_getegid(void ) 591 { 592 register_t rval[2] = {0, 0}; 593 int error = 0; 594 595 error = rsys_syscall(SYS_getegid, NULL, 0, rval); 596 if (error) { 597 rval[0] = -1; 598 rsys_seterrno(error); 599 } 600 return rval[0]; 601 } 602 rsys_alias(sys_getegid,rump_enosys) 603 604 gid_t rump_sys_getgid(void); 605 gid_t 606 rump_sys_getgid(void ) 607 { 608 register_t rval[2] = {0, 0}; 609 int error = 0; 610 611 error = rsys_syscall(SYS_getgid, NULL, 0, rval); 612 if (error) { 613 rval[0] = -1; 614 rsys_seterrno(error); 615 } 616 return rval[0]; 617 } 618 rsys_alias(sys_getgid_with_egid,rump_enosys) 619 620 int rump_sys___getlogin(char *, size_t); 621 int 622 rump_sys___getlogin(char * namebuf, size_t namelen) 623 { 624 register_t rval[2] = {0, 0}; 625 int error = 0; 626 struct sys___getlogin_args callarg; 627 628 SPARG(&callarg, namebuf) = namebuf; 629 SPARG(&callarg, namelen) = namelen; 630 631 error = rsys_syscall(SYS___getlogin, &callarg, sizeof(callarg), rval); 632 if (error) { 633 rval[0] = -1; 634 rsys_seterrno(error); 635 } 636 return rval[0]; 637 } 638 rsys_alias(sys___getlogin,rump_enosys) 639 640 int rump_sys___setlogin(const char *); 641 int 642 rump_sys___setlogin(const char * namebuf) 643 { 644 register_t rval[2] = {0, 0}; 645 int error = 0; 646 struct sys___setlogin_args callarg; 647 648 SPARG(&callarg, namebuf) = namebuf; 649 650 error = rsys_syscall(SYS___setlogin, &callarg, sizeof(callarg), rval); 651 if (error) { 652 rval[0] = -1; 653 rsys_seterrno(error); 654 } 655 return rval[0]; 656 } 657 rsys_alias(sys___setlogin,rump_enosys) 658 659 int rump_sys_ioctl(int, u_long, void *); 660 int 661 rump_sys_ioctl(int fd, u_long com, void * data) 662 { 663 register_t rval[2] = {0, 0}; 664 int error = 0; 665 struct sys_ioctl_args callarg; 666 667 SPARG(&callarg, fd) = fd; 668 SPARG(&callarg, com) = com; 669 SPARG(&callarg, data) = data; 670 671 error = rsys_syscall(SYS_ioctl, &callarg, sizeof(callarg), rval); 672 if (error) { 673 rval[0] = -1; 674 rsys_seterrno(error); 675 } 676 return rval[0]; 677 } 678 rsys_alias(sys_ioctl,rump_enosys) 679 680 int rump_sys_revoke(const char *); 681 int 682 rump_sys_revoke(const char * path) 683 { 684 register_t rval[2] = {0, 0}; 685 int error = 0; 686 struct sys_revoke_args callarg; 687 688 SPARG(&callarg, path) = path; 689 690 error = rsys_syscall(SYS_revoke, &callarg, sizeof(callarg), rval); 691 if (error) { 692 rval[0] = -1; 693 rsys_seterrno(error); 694 } 695 return rval[0]; 696 } 697 rsys_alias(sys_revoke,rump_enosys) 698 699 int rump_sys_symlink(const char *, const char *); 700 int 701 rump_sys_symlink(const char * path, const char * link) 702 { 703 register_t rval[2] = {0, 0}; 704 int error = 0; 705 struct sys_symlink_args callarg; 706 707 SPARG(&callarg, path) = path; 708 SPARG(&callarg, link) = link; 709 710 error = rsys_syscall(SYS_symlink, &callarg, sizeof(callarg), rval); 711 if (error) { 712 rval[0] = -1; 713 rsys_seterrno(error); 714 } 715 return rval[0]; 716 } 717 rsys_alias(sys_symlink,rump_enosys) 718 719 ssize_t rump_sys_readlink(const char *, char *, size_t); 720 ssize_t 721 rump_sys_readlink(const char * path, char * buf, size_t count) 722 { 723 register_t rval[2] = {0, 0}; 724 int error = 0; 725 struct sys_readlink_args callarg; 726 727 SPARG(&callarg, path) = path; 728 SPARG(&callarg, buf) = buf; 729 SPARG(&callarg, count) = count; 730 731 error = rsys_syscall(SYS_readlink, &callarg, sizeof(callarg), rval); 732 if (error) { 733 rval[0] = -1; 734 rsys_seterrno(error); 735 } 736 return rval[0]; 737 } 738 rsys_alias(sys_readlink,rump_enosys) 739 740 mode_t rump_sys_umask(mode_t); 741 mode_t 742 rump_sys_umask(mode_t newmask) 743 { 744 register_t rval[2] = {0, 0}; 745 int error = 0; 746 struct sys_umask_args callarg; 747 748 SPARG(&callarg, newmask) = newmask; 749 750 error = rsys_syscall(SYS_umask, &callarg, sizeof(callarg), rval); 751 if (error) { 752 rval[0] = -1; 753 rsys_seterrno(error); 754 } 755 return rval[0]; 756 } 757 rsys_alias(sys_umask,rump_enosys) 758 759 int rump_sys_chroot(const char *); 760 int 761 rump_sys_chroot(const char * path) 762 { 763 register_t rval[2] = {0, 0}; 764 int error = 0; 765 struct sys_chroot_args callarg; 766 767 SPARG(&callarg, path) = path; 768 769 error = rsys_syscall(SYS_chroot, &callarg, sizeof(callarg), rval); 770 if (error) { 771 rval[0] = -1; 772 rsys_seterrno(error); 773 } 774 return rval[0]; 775 } 776 rsys_alias(sys_chroot,rump_enosys) 777 778 int rump_sys_getgroups(int, gid_t *); 779 int 780 rump_sys_getgroups(int gidsetsize, gid_t * gidset) 781 { 782 register_t rval[2] = {0, 0}; 783 int error = 0; 784 struct sys_getgroups_args callarg; 785 786 SPARG(&callarg, gidsetsize) = gidsetsize; 787 SPARG(&callarg, gidset) = gidset; 788 789 error = rsys_syscall(SYS_getgroups, &callarg, sizeof(callarg), rval); 790 if (error) { 791 rval[0] = -1; 792 rsys_seterrno(error); 793 } 794 return rval[0]; 795 } 796 rsys_alias(sys_getgroups,rump_enosys) 797 798 int rump_sys_setgroups(int, const gid_t *); 799 int 800 rump_sys_setgroups(int gidsetsize, const gid_t * gidset) 801 { 802 register_t rval[2] = {0, 0}; 803 int error = 0; 804 struct sys_setgroups_args callarg; 805 806 SPARG(&callarg, gidsetsize) = gidsetsize; 807 SPARG(&callarg, gidset) = gidset; 808 809 error = rsys_syscall(SYS_setgroups, &callarg, sizeof(callarg), rval); 810 if (error) { 811 rval[0] = -1; 812 rsys_seterrno(error); 813 } 814 return rval[0]; 815 } 816 rsys_alias(sys_setgroups,rump_enosys) 817 818 int rump_sys_getpgrp(void); 819 int 820 rump_sys_getpgrp(void ) 821 { 822 register_t rval[2] = {0, 0}; 823 int error = 0; 824 825 error = rsys_syscall(SYS_getpgrp, NULL, 0, rval); 826 if (error) { 827 rval[0] = -1; 828 rsys_seterrno(error); 829 } 830 return rval[0]; 831 } 832 rsys_alias(sys_getpgrp,rump_enosys) 833 834 int rump_sys_setpgid(int, int); 835 int 836 rump_sys_setpgid(int pid, int pgid) 837 { 838 register_t rval[2] = {0, 0}; 839 int error = 0; 840 struct sys_setpgid_args callarg; 841 842 SPARG(&callarg, pid) = pid; 843 SPARG(&callarg, pgid) = pgid; 844 845 error = rsys_syscall(SYS_setpgid, &callarg, sizeof(callarg), rval); 846 if (error) { 847 rval[0] = -1; 848 rsys_seterrno(error); 849 } 850 return rval[0]; 851 } 852 rsys_alias(sys_setpgid,rump_enosys) 853 854 int rump_sys_dup2(int, int); 855 int 856 rump_sys_dup2(int from, int to) 857 { 858 register_t rval[2] = {0, 0}; 859 int error = 0; 860 struct sys_dup2_args callarg; 861 862 SPARG(&callarg, from) = from; 863 SPARG(&callarg, to) = to; 864 865 error = rsys_syscall(SYS_dup2, &callarg, sizeof(callarg), rval); 866 if (error) { 867 rval[0] = -1; 868 rsys_seterrno(error); 869 } 870 return rval[0]; 871 } 872 rsys_alias(sys_dup2,rump_enosys) 873 874 int rump_sys_fcntl(int, int, void *); 875 int 876 rump_sys_fcntl(int fd, int cmd, void * arg) 877 { 878 register_t rval[2] = {0, 0}; 879 int error = 0; 880 struct sys_fcntl_args callarg; 881 882 SPARG(&callarg, fd) = fd; 883 SPARG(&callarg, cmd) = cmd; 884 SPARG(&callarg, arg) = arg; 885 886 error = rsys_syscall(SYS_fcntl, &callarg, sizeof(callarg), rval); 887 if (error) { 888 rval[0] = -1; 889 rsys_seterrno(error); 890 } 891 return rval[0]; 892 } 893 rsys_alias(sys_fcntl,rump_enosys) 894 895 int rump_sys_fsync(int); 896 int 897 rump_sys_fsync(int fd) 898 { 899 register_t rval[2] = {0, 0}; 900 int error = 0; 901 struct sys_fsync_args callarg; 902 903 SPARG(&callarg, fd) = fd; 904 905 error = rsys_syscall(SYS_fsync, &callarg, sizeof(callarg), rval); 906 if (error) { 907 rval[0] = -1; 908 rsys_seterrno(error); 909 } 910 return rval[0]; 911 } 912 rsys_alias(sys_fsync,rump_enosys) 913 914 int rump_sys_connect(int, const struct sockaddr *, unsigned int); 915 int 916 rump_sys_connect(int s, const struct sockaddr * name, unsigned int namelen) 917 { 918 register_t rval[2] = {0, 0}; 919 int error = 0; 920 struct sys_connect_args callarg; 921 922 SPARG(&callarg, s) = s; 923 SPARG(&callarg, name) = name; 924 SPARG(&callarg, namelen) = namelen; 925 926 error = rsys_syscall(SYS_connect, &callarg, sizeof(callarg), rval); 927 if (error) { 928 rval[0] = -1; 929 rsys_seterrno(error); 930 } 931 return rval[0]; 932 } 933 rsys_alias(sys_connect,rump_enosys) 934 935 int rump_sys_bind(int, const struct sockaddr *, unsigned int); 936 int 937 rump_sys_bind(int s, const struct sockaddr * name, unsigned int namelen) 938 { 939 register_t rval[2] = {0, 0}; 940 int error = 0; 941 struct sys_bind_args callarg; 942 943 SPARG(&callarg, s) = s; 944 SPARG(&callarg, name) = name; 945 SPARG(&callarg, namelen) = namelen; 946 947 error = rsys_syscall(SYS_bind, &callarg, sizeof(callarg), rval); 948 if (error) { 949 rval[0] = -1; 950 rsys_seterrno(error); 951 } 952 return rval[0]; 953 } 954 rsys_alias(sys_bind,rump_enosys) 955 956 int rump_sys_setsockopt(int, int, int, const void *, unsigned int); 957 int 958 rump_sys_setsockopt(int s, int level, int name, const void * val, unsigned int valsize) 959 { 960 register_t rval[2] = {0, 0}; 961 int error = 0; 962 struct sys_setsockopt_args callarg; 963 964 SPARG(&callarg, s) = s; 965 SPARG(&callarg, level) = level; 966 SPARG(&callarg, name) = name; 967 SPARG(&callarg, val) = val; 968 SPARG(&callarg, valsize) = valsize; 969 970 error = rsys_syscall(SYS_setsockopt, &callarg, sizeof(callarg), rval); 971 if (error) { 972 rval[0] = -1; 973 rsys_seterrno(error); 974 } 975 return rval[0]; 976 } 977 rsys_alias(sys_setsockopt,rump_enosys) 978 979 int rump_sys_listen(int, int); 980 int 981 rump_sys_listen(int s, int backlog) 982 { 983 register_t rval[2] = {0, 0}; 984 int error = 0; 985 struct sys_listen_args callarg; 986 987 SPARG(&callarg, s) = s; 988 SPARG(&callarg, backlog) = backlog; 989 990 error = rsys_syscall(SYS_listen, &callarg, sizeof(callarg), rval); 991 if (error) { 992 rval[0] = -1; 993 rsys_seterrno(error); 994 } 995 return rval[0]; 996 } 997 rsys_alias(sys_listen,rump_enosys) 998 999 int rump_sys_getsockopt(int, int, int, void *, unsigned int *); 1000 int 1001 rump_sys_getsockopt(int s, int level, int name, void * val, unsigned int * avalsize) 1002 { 1003 register_t rval[2] = {0, 0}; 1004 int error = 0; 1005 struct sys_getsockopt_args callarg; 1006 1007 SPARG(&callarg, s) = s; 1008 SPARG(&callarg, level) = level; 1009 SPARG(&callarg, name) = name; 1010 SPARG(&callarg, val) = val; 1011 SPARG(&callarg, avalsize) = avalsize; 1012 1013 error = rsys_syscall(SYS_getsockopt, &callarg, sizeof(callarg), rval); 1014 if (error) { 1015 rval[0] = -1; 1016 rsys_seterrno(error); 1017 } 1018 return rval[0]; 1019 } 1020 rsys_alias(sys_getsockopt,rump_enosys) 1021 1022 ssize_t rump_sys_readv(int, const struct iovec *, int); 1023 ssize_t 1024 rump_sys_readv(int fd, const struct iovec * iovp, int iovcnt) 1025 { 1026 register_t rval[2] = {0, 0}; 1027 int error = 0; 1028 struct sys_readv_args callarg; 1029 1030 SPARG(&callarg, fd) = fd; 1031 SPARG(&callarg, iovp) = iovp; 1032 SPARG(&callarg, iovcnt) = iovcnt; 1033 1034 error = rsys_syscall(SYS_readv, &callarg, sizeof(callarg), rval); 1035 if (error) { 1036 rval[0] = -1; 1037 rsys_seterrno(error); 1038 } 1039 return rval[0]; 1040 } 1041 rsys_alias(sys_readv,rump_enosys) 1042 1043 ssize_t rump_sys_writev(int, const struct iovec *, int); 1044 ssize_t 1045 rump_sys_writev(int fd, const struct iovec * iovp, int iovcnt) 1046 { 1047 register_t rval[2] = {0, 0}; 1048 int error = 0; 1049 struct sys_writev_args callarg; 1050 1051 SPARG(&callarg, fd) = fd; 1052 SPARG(&callarg, iovp) = iovp; 1053 SPARG(&callarg, iovcnt) = iovcnt; 1054 1055 error = rsys_syscall(SYS_writev, &callarg, sizeof(callarg), rval); 1056 if (error) { 1057 rval[0] = -1; 1058 rsys_seterrno(error); 1059 } 1060 return rval[0]; 1061 } 1062 rsys_alias(sys_writev,rump_enosys) 1063 1064 int rump_sys_fchown(int, uid_t, gid_t); 1065 int 1066 rump_sys_fchown(int fd, uid_t uid, gid_t gid) 1067 { 1068 register_t rval[2] = {0, 0}; 1069 int error = 0; 1070 struct sys_fchown_args callarg; 1071 1072 SPARG(&callarg, fd) = fd; 1073 SPARG(&callarg, uid) = uid; 1074 SPARG(&callarg, gid) = gid; 1075 1076 error = rsys_syscall(SYS_fchown, &callarg, sizeof(callarg), rval); 1077 if (error) { 1078 rval[0] = -1; 1079 rsys_seterrno(error); 1080 } 1081 return rval[0]; 1082 } 1083 rsys_alias(sys_fchown,rump_enosys) 1084 1085 int rump_sys_fchmod(int, mode_t); 1086 int 1087 rump_sys_fchmod(int fd, mode_t mode) 1088 { 1089 register_t rval[2] = {0, 0}; 1090 int error = 0; 1091 struct sys_fchmod_args callarg; 1092 1093 SPARG(&callarg, fd) = fd; 1094 SPARG(&callarg, mode) = mode; 1095 1096 error = rsys_syscall(SYS_fchmod, &callarg, sizeof(callarg), rval); 1097 if (error) { 1098 rval[0] = -1; 1099 rsys_seterrno(error); 1100 } 1101 return rval[0]; 1102 } 1103 rsys_alias(sys_fchmod,rump_enosys) 1104 1105 int rump_sys_setreuid(uid_t, uid_t); 1106 int 1107 rump_sys_setreuid(uid_t ruid, uid_t euid) 1108 { 1109 register_t rval[2] = {0, 0}; 1110 int error = 0; 1111 struct sys_setreuid_args callarg; 1112 1113 SPARG(&callarg, ruid) = ruid; 1114 SPARG(&callarg, euid) = euid; 1115 1116 error = rsys_syscall(SYS_setreuid, &callarg, sizeof(callarg), rval); 1117 if (error) { 1118 rval[0] = -1; 1119 rsys_seterrno(error); 1120 } 1121 return rval[0]; 1122 } 1123 rsys_alias(sys_setreuid,rump_enosys) 1124 1125 int rump_sys_setregid(gid_t, gid_t); 1126 int 1127 rump_sys_setregid(gid_t rgid, gid_t egid) 1128 { 1129 register_t rval[2] = {0, 0}; 1130 int error = 0; 1131 struct sys_setregid_args callarg; 1132 1133 SPARG(&callarg, rgid) = rgid; 1134 SPARG(&callarg, egid) = egid; 1135 1136 error = rsys_syscall(SYS_setregid, &callarg, sizeof(callarg), rval); 1137 if (error) { 1138 rval[0] = -1; 1139 rsys_seterrno(error); 1140 } 1141 return rval[0]; 1142 } 1143 rsys_alias(sys_setregid,rump_enosys) 1144 1145 int rump_sys_rename(const char *, const char *); 1146 int 1147 rump_sys_rename(const char * from, const char * to) 1148 { 1149 register_t rval[2] = {0, 0}; 1150 int error = 0; 1151 struct sys_rename_args callarg; 1152 1153 SPARG(&callarg, from) = from; 1154 SPARG(&callarg, to) = to; 1155 1156 error = rsys_syscall(SYS_rename, &callarg, sizeof(callarg), rval); 1157 if (error) { 1158 rval[0] = -1; 1159 rsys_seterrno(error); 1160 } 1161 return rval[0]; 1162 } 1163 rsys_alias(sys_rename,rump_enosys) 1164 1165 int rump_sys_flock(int, int); 1166 int 1167 rump_sys_flock(int fd, int how) 1168 { 1169 register_t rval[2] = {0, 0}; 1170 int error = 0; 1171 struct sys_flock_args callarg; 1172 1173 SPARG(&callarg, fd) = fd; 1174 SPARG(&callarg, how) = how; 1175 1176 error = rsys_syscall(SYS_flock, &callarg, sizeof(callarg), rval); 1177 if (error) { 1178 rval[0] = -1; 1179 rsys_seterrno(error); 1180 } 1181 return rval[0]; 1182 } 1183 rsys_alias(sys_flock,rump_enosys) 1184 1185 int rump_sys_mkfifo(const char *, mode_t); 1186 int 1187 rump_sys_mkfifo(const char * path, mode_t mode) 1188 { 1189 register_t rval[2] = {0, 0}; 1190 int error = 0; 1191 struct sys_mkfifo_args callarg; 1192 1193 SPARG(&callarg, path) = path; 1194 SPARG(&callarg, mode) = mode; 1195 1196 error = rsys_syscall(SYS_mkfifo, &callarg, sizeof(callarg), rval); 1197 if (error) { 1198 rval[0] = -1; 1199 rsys_seterrno(error); 1200 } 1201 return rval[0]; 1202 } 1203 rsys_alias(sys_mkfifo,rump_enosys) 1204 1205 ssize_t rump_sys_sendto(int, const void *, size_t, int, const struct sockaddr *, unsigned int); 1206 ssize_t 1207 rump_sys_sendto(int s, const void * buf, size_t len, int flags, const struct sockaddr * to, unsigned int tolen) 1208 { 1209 register_t rval[2] = {0, 0}; 1210 int error = 0; 1211 struct sys_sendto_args callarg; 1212 1213 SPARG(&callarg, s) = s; 1214 SPARG(&callarg, buf) = buf; 1215 SPARG(&callarg, len) = len; 1216 SPARG(&callarg, flags) = flags; 1217 SPARG(&callarg, to) = to; 1218 SPARG(&callarg, tolen) = tolen; 1219 1220 error = rsys_syscall(SYS_sendto, &callarg, sizeof(callarg), rval); 1221 if (error) { 1222 rval[0] = -1; 1223 rsys_seterrno(error); 1224 } 1225 return rval[0]; 1226 } 1227 rsys_alias(sys_sendto,rump_enosys) 1228 1229 int rump_sys_shutdown(int, int); 1230 int 1231 rump_sys_shutdown(int s, int how) 1232 { 1233 register_t rval[2] = {0, 0}; 1234 int error = 0; 1235 struct sys_shutdown_args callarg; 1236 1237 SPARG(&callarg, s) = s; 1238 SPARG(&callarg, how) = how; 1239 1240 error = rsys_syscall(SYS_shutdown, &callarg, sizeof(callarg), rval); 1241 if (error) { 1242 rval[0] = -1; 1243 rsys_seterrno(error); 1244 } 1245 return rval[0]; 1246 } 1247 rsys_alias(sys_shutdown,rump_enosys) 1248 1249 int rump_sys_socketpair(int, int, int, int *); 1250 int 1251 rump_sys_socketpair(int domain, int type, int protocol, int * rsv) 1252 { 1253 register_t rval[2] = {0, 0}; 1254 int error = 0; 1255 struct sys_socketpair_args callarg; 1256 1257 SPARG(&callarg, domain) = domain; 1258 SPARG(&callarg, type) = type; 1259 SPARG(&callarg, protocol) = protocol; 1260 SPARG(&callarg, rsv) = rsv; 1261 1262 error = rsys_syscall(SYS_socketpair, &callarg, sizeof(callarg), rval); 1263 if (error) { 1264 rval[0] = -1; 1265 rsys_seterrno(error); 1266 } 1267 return rval[0]; 1268 } 1269 rsys_alias(sys_socketpair,rump_enosys) 1270 1271 int rump_sys_mkdir(const char *, mode_t); 1272 int 1273 rump_sys_mkdir(const char * path, mode_t mode) 1274 { 1275 register_t rval[2] = {0, 0}; 1276 int error = 0; 1277 struct sys_mkdir_args callarg; 1278 1279 SPARG(&callarg, path) = path; 1280 SPARG(&callarg, mode) = mode; 1281 1282 error = rsys_syscall(SYS_mkdir, &callarg, sizeof(callarg), rval); 1283 if (error) { 1284 rval[0] = -1; 1285 rsys_seterrno(error); 1286 } 1287 return rval[0]; 1288 } 1289 rsys_alias(sys_mkdir,rump_enosys) 1290 1291 int rump_sys_rmdir(const char *); 1292 int 1293 rump_sys_rmdir(const char * path) 1294 { 1295 register_t rval[2] = {0, 0}; 1296 int error = 0; 1297 struct sys_rmdir_args callarg; 1298 1299 SPARG(&callarg, path) = path; 1300 1301 error = rsys_syscall(SYS_rmdir, &callarg, sizeof(callarg), rval); 1302 if (error) { 1303 rval[0] = -1; 1304 rsys_seterrno(error); 1305 } 1306 return rval[0]; 1307 } 1308 rsys_alias(sys_rmdir,rump_enosys) 1309 1310 int rump_sys_setsid(void); 1311 int 1312 rump_sys_setsid(void ) 1313 { 1314 register_t rval[2] = {0, 0}; 1315 int error = 0; 1316 1317 error = rsys_syscall(SYS_setsid, NULL, 0, rval); 1318 if (error) { 1319 rval[0] = -1; 1320 rsys_seterrno(error); 1321 } 1322 return rval[0]; 1323 } 1324 rsys_alias(sys_setsid,rump_enosys) 1325 1326 int rump_sys_nfssvc(int, void *); 1327 int 1328 rump_sys_nfssvc(int flag, void * argp) 1329 { 1330 register_t rval[2] = {0, 0}; 1331 int error = 0; 1332 struct sys_nfssvc_args callarg; 1333 1334 SPARG(&callarg, flag) = flag; 1335 SPARG(&callarg, argp) = argp; 1336 1337 error = rsys_syscall(SYS_nfssvc, &callarg, sizeof(callarg), rval); 1338 if (error) { 1339 rval[0] = -1; 1340 rsys_seterrno(error); 1341 } 1342 return rval[0]; 1343 } 1344 rsys_alias(sys_nfssvc,rump_enosys) 1345 1346 ssize_t rump_sys_pread(int, void *, size_t, off_t); 1347 ssize_t 1348 rump_sys_pread(int fd, void * buf, size_t nbyte, off_t offset) 1349 { 1350 register_t rval[2] = {0, 0}; 1351 int error = 0; 1352 struct sys_pread_args callarg; 1353 1354 SPARG(&callarg, fd) = fd; 1355 SPARG(&callarg, buf) = buf; 1356 SPARG(&callarg, nbyte) = nbyte; 1357 SPARG(&callarg, PAD) = 0; 1358 SPARG(&callarg, offset) = offset; 1359 1360 error = rsys_syscall(SYS_pread, &callarg, sizeof(callarg), rval); 1361 if (error) { 1362 rval[0] = -1; 1363 rsys_seterrno(error); 1364 } 1365 return rval[0]; 1366 } 1367 rsys_alias(sys_pread,rump_enosys) 1368 1369 ssize_t rump_sys_pwrite(int, const void *, size_t, off_t); 1370 ssize_t 1371 rump_sys_pwrite(int fd, const void * buf, size_t nbyte, off_t offset) 1372 { 1373 register_t rval[2] = {0, 0}; 1374 int error = 0; 1375 struct sys_pwrite_args callarg; 1376 1377 SPARG(&callarg, fd) = fd; 1378 SPARG(&callarg, buf) = buf; 1379 SPARG(&callarg, nbyte) = nbyte; 1380 SPARG(&callarg, PAD) = 0; 1381 SPARG(&callarg, offset) = offset; 1382 1383 error = rsys_syscall(SYS_pwrite, &callarg, sizeof(callarg), rval); 1384 if (error) { 1385 rval[0] = -1; 1386 rsys_seterrno(error); 1387 } 1388 return rval[0]; 1389 } 1390 rsys_alias(sys_pwrite,rump_enosys) 1391 1392 int rump_sys_setgid(gid_t); 1393 int 1394 rump_sys_setgid(gid_t gid) 1395 { 1396 register_t rval[2] = {0, 0}; 1397 int error = 0; 1398 struct sys_setgid_args callarg; 1399 1400 SPARG(&callarg, gid) = gid; 1401 1402 error = rsys_syscall(SYS_setgid, &callarg, sizeof(callarg), rval); 1403 if (error) { 1404 rval[0] = -1; 1405 rsys_seterrno(error); 1406 } 1407 return rval[0]; 1408 } 1409 rsys_alias(sys_setgid,rump_enosys) 1410 1411 int rump_sys_setegid(gid_t); 1412 int 1413 rump_sys_setegid(gid_t egid) 1414 { 1415 register_t rval[2] = {0, 0}; 1416 int error = 0; 1417 struct sys_setegid_args callarg; 1418 1419 SPARG(&callarg, egid) = egid; 1420 1421 error = rsys_syscall(SYS_setegid, &callarg, sizeof(callarg), rval); 1422 if (error) { 1423 rval[0] = -1; 1424 rsys_seterrno(error); 1425 } 1426 return rval[0]; 1427 } 1428 rsys_alias(sys_setegid,rump_enosys) 1429 1430 int rump_sys_seteuid(uid_t); 1431 int 1432 rump_sys_seteuid(uid_t euid) 1433 { 1434 register_t rval[2] = {0, 0}; 1435 int error = 0; 1436 struct sys_seteuid_args callarg; 1437 1438 SPARG(&callarg, euid) = euid; 1439 1440 error = rsys_syscall(SYS_seteuid, &callarg, sizeof(callarg), rval); 1441 if (error) { 1442 rval[0] = -1; 1443 rsys_seterrno(error); 1444 } 1445 return rval[0]; 1446 } 1447 rsys_alias(sys_seteuid,rump_enosys) 1448 1449 long rump_sys_pathconf(const char *, int); 1450 long 1451 rump_sys_pathconf(const char * path, int name) 1452 { 1453 register_t rval[2] = {0, 0}; 1454 int error = 0; 1455 struct sys_pathconf_args callarg; 1456 1457 SPARG(&callarg, path) = path; 1458 SPARG(&callarg, name) = name; 1459 1460 error = rsys_syscall(SYS_pathconf, &callarg, sizeof(callarg), rval); 1461 if (error) { 1462 rval[0] = -1; 1463 rsys_seterrno(error); 1464 } 1465 return rval[0]; 1466 } 1467 rsys_alias(sys_pathconf,rump_enosys) 1468 1469 long rump_sys_fpathconf(int, int); 1470 long 1471 rump_sys_fpathconf(int fd, int name) 1472 { 1473 register_t rval[2] = {0, 0}; 1474 int error = 0; 1475 struct sys_fpathconf_args callarg; 1476 1477 SPARG(&callarg, fd) = fd; 1478 SPARG(&callarg, name) = name; 1479 1480 error = rsys_syscall(SYS_fpathconf, &callarg, sizeof(callarg), rval); 1481 if (error) { 1482 rval[0] = -1; 1483 rsys_seterrno(error); 1484 } 1485 return rval[0]; 1486 } 1487 rsys_alias(sys_fpathconf,rump_enosys) 1488 1489 int rump_sys_getrlimit(int, struct rlimit *); 1490 int 1491 rump_sys_getrlimit(int which, struct rlimit * rlp) 1492 { 1493 register_t rval[2] = {0, 0}; 1494 int error = 0; 1495 struct sys_getrlimit_args callarg; 1496 1497 SPARG(&callarg, which) = which; 1498 SPARG(&callarg, rlp) = rlp; 1499 1500 error = rsys_syscall(SYS_getrlimit, &callarg, sizeof(callarg), rval); 1501 if (error) { 1502 rval[0] = -1; 1503 rsys_seterrno(error); 1504 } 1505 return rval[0]; 1506 } 1507 rsys_alias(sys_getrlimit,rump_enosys) 1508 1509 int rump_sys_setrlimit(int, const struct rlimit *); 1510 int 1511 rump_sys_setrlimit(int which, const struct rlimit * rlp) 1512 { 1513 register_t rval[2] = {0, 0}; 1514 int error = 0; 1515 struct sys_setrlimit_args callarg; 1516 1517 SPARG(&callarg, which) = which; 1518 SPARG(&callarg, rlp) = rlp; 1519 1520 error = rsys_syscall(SYS_setrlimit, &callarg, sizeof(callarg), rval); 1521 if (error) { 1522 rval[0] = -1; 1523 rsys_seterrno(error); 1524 } 1525 return rval[0]; 1526 } 1527 rsys_alias(sys_setrlimit,rump_enosys) 1528 1529 off_t rump_sys_lseek(int, off_t, int); 1530 off_t 1531 rump_sys_lseek(int fd, off_t offset, int whence) 1532 { 1533 register_t rval[2] = {0, 0}; 1534 int error = 0; 1535 struct sys_lseek_args callarg; 1536 1537 SPARG(&callarg, fd) = fd; 1538 SPARG(&callarg, PAD) = 0; 1539 SPARG(&callarg, offset) = offset; 1540 SPARG(&callarg, whence) = whence; 1541 1542 error = rsys_syscall(SYS_lseek, &callarg, sizeof(callarg), rval); 1543 if (error) { 1544 rval[0] = -1; 1545 rsys_seterrno(error); 1546 } 1547 return rval[0]; 1548 } 1549 rsys_alias(sys_lseek,rump_enosys) 1550 1551 int rump_sys_truncate(const char *, off_t); 1552 int 1553 rump_sys_truncate(const char * path, off_t length) 1554 { 1555 register_t rval[2] = {0, 0}; 1556 int error = 0; 1557 struct sys_truncate_args callarg; 1558 1559 SPARG(&callarg, path) = path; 1560 SPARG(&callarg, PAD) = 0; 1561 SPARG(&callarg, length) = length; 1562 1563 error = rsys_syscall(SYS_truncate, &callarg, sizeof(callarg), rval); 1564 if (error) { 1565 rval[0] = -1; 1566 rsys_seterrno(error); 1567 } 1568 return rval[0]; 1569 } 1570 rsys_alias(sys_truncate,rump_enosys) 1571 1572 int rump_sys_ftruncate(int, off_t); 1573 int 1574 rump_sys_ftruncate(int fd, off_t length) 1575 { 1576 register_t rval[2] = {0, 0}; 1577 int error = 0; 1578 struct sys_ftruncate_args callarg; 1579 1580 SPARG(&callarg, fd) = fd; 1581 SPARG(&callarg, PAD) = 0; 1582 SPARG(&callarg, length) = length; 1583 1584 error = rsys_syscall(SYS_ftruncate, &callarg, sizeof(callarg), rval); 1585 if (error) { 1586 rval[0] = -1; 1587 rsys_seterrno(error); 1588 } 1589 return rval[0]; 1590 } 1591 rsys_alias(sys_ftruncate,rump_enosys) 1592 1593 int rump_sys___sysctl(const int *, u_int, void *, size_t *, const void *, size_t); 1594 int 1595 rump_sys___sysctl(const int * name, u_int namelen, void * old, size_t * oldlenp, const void * new, size_t newlen) 1596 { 1597 register_t rval[2] = {0, 0}; 1598 int error = 0; 1599 struct sys___sysctl_args callarg; 1600 1601 SPARG(&callarg, name) = name; 1602 SPARG(&callarg, namelen) = namelen; 1603 SPARG(&callarg, old) = old; 1604 SPARG(&callarg, oldlenp) = oldlenp; 1605 SPARG(&callarg, new) = new; 1606 SPARG(&callarg, newlen) = newlen; 1607 1608 error = rsys_syscall(SYS___sysctl, &callarg, sizeof(callarg), rval); 1609 if (error) { 1610 rval[0] = -1; 1611 rsys_seterrno(error); 1612 } 1613 return rval[0]; 1614 } 1615 rsys_alias(sys___sysctl,rump_enosys) 1616 1617 pid_t rump_sys_getpgid(pid_t); 1618 pid_t 1619 rump_sys_getpgid(pid_t pid) 1620 { 1621 register_t rval[2] = {0, 0}; 1622 int error = 0; 1623 struct sys_getpgid_args callarg; 1624 1625 SPARG(&callarg, pid) = pid; 1626 1627 error = rsys_syscall(SYS_getpgid, &callarg, sizeof(callarg), rval); 1628 if (error) { 1629 rval[0] = -1; 1630 rsys_seterrno(error); 1631 } 1632 return rval[0]; 1633 } 1634 rsys_alias(sys_getpgid,rump_enosys) 1635 1636 int rump_sys_reboot(int, char *); 1637 int 1638 rump_sys_reboot(int opt, char * bootstr) 1639 { 1640 register_t rval[2] = {0, 0}; 1641 int error = 0; 1642 struct sys_reboot_args callarg; 1643 1644 SPARG(&callarg, opt) = opt; 1645 SPARG(&callarg, bootstr) = bootstr; 1646 1647 error = rsys_syscall(SYS_reboot, &callarg, sizeof(callarg), rval); 1648 if (error) { 1649 rval[0] = -1; 1650 rsys_seterrno(error); 1651 } 1652 return rval[0]; 1653 } 1654 rsys_alias(sys_reboot,rump_enosys) 1655 1656 int rump_sys_poll(struct pollfd *, u_int, int); 1657 int 1658 rump_sys_poll(struct pollfd * fds, u_int nfds, int timeout) 1659 { 1660 register_t rval[2] = {0, 0}; 1661 int error = 0; 1662 struct sys_poll_args callarg; 1663 1664 SPARG(&callarg, fds) = fds; 1665 SPARG(&callarg, nfds) = nfds; 1666 SPARG(&callarg, timeout) = timeout; 1667 1668 error = rsys_syscall(SYS_poll, &callarg, sizeof(callarg), rval); 1669 if (error) { 1670 rval[0] = -1; 1671 rsys_seterrno(error); 1672 } 1673 return rval[0]; 1674 } 1675 rsys_alias(sys_poll,rump_enosys) 1676 1677 int rump_sys_fdatasync(int); 1678 int 1679 rump_sys_fdatasync(int fd) 1680 { 1681 register_t rval[2] = {0, 0}; 1682 int error = 0; 1683 struct sys_fdatasync_args callarg; 1684 1685 SPARG(&callarg, fd) = fd; 1686 1687 error = rsys_syscall(SYS_fdatasync, &callarg, sizeof(callarg), rval); 1688 if (error) { 1689 rval[0] = -1; 1690 rsys_seterrno(error); 1691 } 1692 return rval[0]; 1693 } 1694 rsys_alias(sys_fdatasync,rump_enosys) 1695 1696 int rump_sys_modctl(int, void *); 1697 int 1698 rump_sys_modctl(int cmd, void * arg) 1699 { 1700 register_t rval[2] = {0, 0}; 1701 int error = 0; 1702 struct sys_modctl_args callarg; 1703 1704 SPARG(&callarg, cmd) = cmd; 1705 SPARG(&callarg, arg) = arg; 1706 1707 error = rsys_syscall(SYS_modctl, &callarg, sizeof(callarg), rval); 1708 if (error) { 1709 rval[0] = -1; 1710 rsys_seterrno(error); 1711 } 1712 return rval[0]; 1713 } 1714 rsys_alias(sys_modctl,rump_enosys) 1715 1716 int rump_sys__ksem_init(unsigned int, intptr_t *); 1717 int 1718 rump_sys__ksem_init(unsigned int value, intptr_t * idp) 1719 { 1720 register_t rval[2] = {0, 0}; 1721 int error = 0; 1722 struct sys__ksem_init_args callarg; 1723 1724 SPARG(&callarg, value) = value; 1725 SPARG(&callarg, idp) = idp; 1726 1727 error = rsys_syscall(SYS__ksem_init, &callarg, sizeof(callarg), rval); 1728 if (error) { 1729 rval[0] = -1; 1730 rsys_seterrno(error); 1731 } 1732 return rval[0]; 1733 } 1734 rsys_alias(sys__ksem_init,rump_enosys) 1735 1736 int rump_sys__ksem_open(const char *, int, mode_t, unsigned int, intptr_t *); 1737 int 1738 rump_sys__ksem_open(const char * name, int oflag, mode_t mode, unsigned int value, intptr_t * idp) 1739 { 1740 register_t rval[2] = {0, 0}; 1741 int error = 0; 1742 struct sys__ksem_open_args callarg; 1743 1744 SPARG(&callarg, name) = name; 1745 SPARG(&callarg, oflag) = oflag; 1746 SPARG(&callarg, mode) = mode; 1747 SPARG(&callarg, value) = value; 1748 SPARG(&callarg, idp) = idp; 1749 1750 error = rsys_syscall(SYS__ksem_open, &callarg, sizeof(callarg), rval); 1751 if (error) { 1752 rval[0] = -1; 1753 rsys_seterrno(error); 1754 } 1755 return rval[0]; 1756 } 1757 rsys_alias(sys__ksem_open,rump_enosys) 1758 1759 int rump_sys__ksem_unlink(const char *); 1760 int 1761 rump_sys__ksem_unlink(const char * name) 1762 { 1763 register_t rval[2] = {0, 0}; 1764 int error = 0; 1765 struct sys__ksem_unlink_args callarg; 1766 1767 SPARG(&callarg, name) = name; 1768 1769 error = rsys_syscall(SYS__ksem_unlink, &callarg, sizeof(callarg), rval); 1770 if (error) { 1771 rval[0] = -1; 1772 rsys_seterrno(error); 1773 } 1774 return rval[0]; 1775 } 1776 rsys_alias(sys__ksem_unlink,rump_enosys) 1777 1778 int rump_sys__ksem_close(intptr_t); 1779 int 1780 rump_sys__ksem_close(intptr_t id) 1781 { 1782 register_t rval[2] = {0, 0}; 1783 int error = 0; 1784 struct sys__ksem_close_args callarg; 1785 1786 SPARG(&callarg, id) = id; 1787 1788 error = rsys_syscall(SYS__ksem_close, &callarg, sizeof(callarg), rval); 1789 if (error) { 1790 rval[0] = -1; 1791 rsys_seterrno(error); 1792 } 1793 return rval[0]; 1794 } 1795 rsys_alias(sys__ksem_close,rump_enosys) 1796 1797 int rump_sys__ksem_post(intptr_t); 1798 int 1799 rump_sys__ksem_post(intptr_t id) 1800 { 1801 register_t rval[2] = {0, 0}; 1802 int error = 0; 1803 struct sys__ksem_post_args callarg; 1804 1805 SPARG(&callarg, id) = id; 1806 1807 error = rsys_syscall(SYS__ksem_post, &callarg, sizeof(callarg), rval); 1808 if (error) { 1809 rval[0] = -1; 1810 rsys_seterrno(error); 1811 } 1812 return rval[0]; 1813 } 1814 rsys_alias(sys__ksem_post,rump_enosys) 1815 1816 int rump_sys__ksem_wait(intptr_t); 1817 int 1818 rump_sys__ksem_wait(intptr_t id) 1819 { 1820 register_t rval[2] = {0, 0}; 1821 int error = 0; 1822 struct sys__ksem_wait_args callarg; 1823 1824 SPARG(&callarg, id) = id; 1825 1826 error = rsys_syscall(SYS__ksem_wait, &callarg, sizeof(callarg), rval); 1827 if (error) { 1828 rval[0] = -1; 1829 rsys_seterrno(error); 1830 } 1831 return rval[0]; 1832 } 1833 rsys_alias(sys__ksem_wait,rump_enosys) 1834 1835 int rump_sys__ksem_trywait(intptr_t); 1836 int 1837 rump_sys__ksem_trywait(intptr_t id) 1838 { 1839 register_t rval[2] = {0, 0}; 1840 int error = 0; 1841 struct sys__ksem_trywait_args callarg; 1842 1843 SPARG(&callarg, id) = id; 1844 1845 error = rsys_syscall(SYS__ksem_trywait, &callarg, sizeof(callarg), rval); 1846 if (error) { 1847 rval[0] = -1; 1848 rsys_seterrno(error); 1849 } 1850 return rval[0]; 1851 } 1852 rsys_alias(sys__ksem_trywait,rump_enosys) 1853 1854 int rump_sys__ksem_getvalue(intptr_t, unsigned int *); 1855 int 1856 rump_sys__ksem_getvalue(intptr_t id, unsigned int * value) 1857 { 1858 register_t rval[2] = {0, 0}; 1859 int error = 0; 1860 struct sys__ksem_getvalue_args callarg; 1861 1862 SPARG(&callarg, id) = id; 1863 SPARG(&callarg, value) = value; 1864 1865 error = rsys_syscall(SYS__ksem_getvalue, &callarg, sizeof(callarg), rval); 1866 if (error) { 1867 rval[0] = -1; 1868 rsys_seterrno(error); 1869 } 1870 return rval[0]; 1871 } 1872 rsys_alias(sys__ksem_getvalue,rump_enosys) 1873 1874 int rump_sys__ksem_destroy(intptr_t); 1875 int 1876 rump_sys__ksem_destroy(intptr_t id) 1877 { 1878 register_t rval[2] = {0, 0}; 1879 int error = 0; 1880 struct sys__ksem_destroy_args callarg; 1881 1882 SPARG(&callarg, id) = id; 1883 1884 error = rsys_syscall(SYS__ksem_destroy, &callarg, sizeof(callarg), rval); 1885 if (error) { 1886 rval[0] = -1; 1887 rsys_seterrno(error); 1888 } 1889 return rval[0]; 1890 } 1891 rsys_alias(sys__ksem_destroy,rump_enosys) 1892 1893 int rump_sys_lchmod(const char *, mode_t); 1894 int 1895 rump_sys_lchmod(const char * path, mode_t mode) 1896 { 1897 register_t rval[2] = {0, 0}; 1898 int error = 0; 1899 struct sys_lchmod_args callarg; 1900 1901 SPARG(&callarg, path) = path; 1902 SPARG(&callarg, mode) = mode; 1903 1904 error = rsys_syscall(SYS_lchmod, &callarg, sizeof(callarg), rval); 1905 if (error) { 1906 rval[0] = -1; 1907 rsys_seterrno(error); 1908 } 1909 return rval[0]; 1910 } 1911 rsys_alias(sys_lchmod,rump_enosys) 1912 1913 int rump_sys_lchown(const char *, uid_t, gid_t); 1914 int 1915 rump_sys_lchown(const char * path, uid_t uid, gid_t gid) 1916 { 1917 register_t rval[2] = {0, 0}; 1918 int error = 0; 1919 struct sys_lchown_args callarg; 1920 1921 SPARG(&callarg, path) = path; 1922 SPARG(&callarg, uid) = uid; 1923 SPARG(&callarg, gid) = gid; 1924 1925 error = rsys_syscall(SYS_lchown, &callarg, sizeof(callarg), rval); 1926 if (error) { 1927 rval[0] = -1; 1928 rsys_seterrno(error); 1929 } 1930 return rval[0]; 1931 } 1932 rsys_alias(sys_lchown,rump_enosys) 1933 1934 pid_t rump_sys_getsid(pid_t); 1935 pid_t 1936 rump_sys_getsid(pid_t pid) 1937 { 1938 register_t rval[2] = {0, 0}; 1939 int error = 0; 1940 struct sys_getsid_args callarg; 1941 1942 SPARG(&callarg, pid) = pid; 1943 1944 error = rsys_syscall(SYS_getsid, &callarg, sizeof(callarg), rval); 1945 if (error) { 1946 rval[0] = -1; 1947 rsys_seterrno(error); 1948 } 1949 return rval[0]; 1950 } 1951 rsys_alias(sys_getsid,rump_enosys) 1952 1953 int rump_sys___getcwd(char *, size_t); 1954 int 1955 rump_sys___getcwd(char * bufp, size_t length) 1956 { 1957 register_t rval[2] = {0, 0}; 1958 int error = 0; 1959 struct sys___getcwd_args callarg; 1960 1961 SPARG(&callarg, bufp) = bufp; 1962 SPARG(&callarg, length) = length; 1963 1964 error = rsys_syscall(SYS___getcwd, &callarg, sizeof(callarg), rval); 1965 if (error) { 1966 rval[0] = -1; 1967 rsys_seterrno(error); 1968 } 1969 return rval[0]; 1970 } 1971 rsys_alias(sys___getcwd,rump_enosys) 1972 1973 int rump_sys_fchroot(int); 1974 int 1975 rump_sys_fchroot(int fd) 1976 { 1977 register_t rval[2] = {0, 0}; 1978 int error = 0; 1979 struct sys_fchroot_args callarg; 1980 1981 SPARG(&callarg, fd) = fd; 1982 1983 error = rsys_syscall(SYS_fchroot, &callarg, sizeof(callarg), rval); 1984 if (error) { 1985 rval[0] = -1; 1986 rsys_seterrno(error); 1987 } 1988 return rval[0]; 1989 } 1990 rsys_alias(sys_fchroot,rump_enosys) 1991 1992 int rump_sys_lchflags(const char *, u_long); 1993 int 1994 rump_sys_lchflags(const char * path, u_long flags) 1995 { 1996 register_t rval[2] = {0, 0}; 1997 int error = 0; 1998 struct sys_lchflags_args callarg; 1999 2000 SPARG(&callarg, path) = path; 2001 SPARG(&callarg, flags) = flags; 2002 2003 error = rsys_syscall(SYS_lchflags, &callarg, sizeof(callarg), rval); 2004 if (error) { 2005 rval[0] = -1; 2006 rsys_seterrno(error); 2007 } 2008 return rval[0]; 2009 } 2010 rsys_alias(sys_lchflags,rump_enosys) 2011 2012 int rump_sys_issetugid(void); 2013 int 2014 rump_sys_issetugid(void ) 2015 { 2016 register_t rval[2] = {0, 0}; 2017 int error = 0; 2018 2019 error = rsys_syscall(SYS_issetugid, NULL, 0, rval); 2020 if (error) { 2021 rval[0] = -1; 2022 rsys_seterrno(error); 2023 } 2024 return rval[0]; 2025 } 2026 rsys_alias(sys_issetugid,rump_enosys) 2027 2028 int rump_sys_kqueue(void); 2029 int 2030 rump_sys_kqueue(void ) 2031 { 2032 register_t rval[2] = {0, 0}; 2033 int error = 0; 2034 2035 error = rsys_syscall(SYS_kqueue, NULL, 0, rval); 2036 if (error) { 2037 rval[0] = -1; 2038 rsys_seterrno(error); 2039 } 2040 return rval[0]; 2041 } 2042 rsys_alias(sys_kqueue,rump_enosys) 2043 2044 int rump_sys_fsync_range(int, int, off_t, off_t); 2045 int 2046 rump_sys_fsync_range(int fd, int flags, off_t start, off_t length) 2047 { 2048 register_t rval[2] = {0, 0}; 2049 int error = 0; 2050 struct sys_fsync_range_args callarg; 2051 2052 SPARG(&callarg, fd) = fd; 2053 SPARG(&callarg, flags) = flags; 2054 SPARG(&callarg, start) = start; 2055 SPARG(&callarg, length) = length; 2056 2057 error = rsys_syscall(SYS_fsync_range, &callarg, sizeof(callarg), rval); 2058 if (error) { 2059 rval[0] = -1; 2060 rsys_seterrno(error); 2061 } 2062 return rval[0]; 2063 } 2064 rsys_alias(sys_fsync_range,rump_enosys) 2065 2066 int rump_sys_getvfsstat(struct statvfs *, size_t, int); 2067 int 2068 rump_sys_getvfsstat(struct statvfs * buf, size_t bufsize, int flags) 2069 { 2070 register_t rval[2] = {0, 0}; 2071 int error = 0; 2072 struct sys_getvfsstat_args callarg; 2073 2074 SPARG(&callarg, buf) = buf; 2075 SPARG(&callarg, bufsize) = bufsize; 2076 SPARG(&callarg, flags) = flags; 2077 2078 error = rsys_syscall(SYS_getvfsstat, &callarg, sizeof(callarg), rval); 2079 if (error) { 2080 rval[0] = -1; 2081 rsys_seterrno(error); 2082 } 2083 return rval[0]; 2084 } 2085 rsys_alias(sys_getvfsstat,rump_enosys) 2086 2087 int rump_sys_statvfs1(const char *, struct statvfs *, int); 2088 int 2089 rump_sys_statvfs1(const char * path, struct statvfs * buf, int flags) 2090 { 2091 register_t rval[2] = {0, 0}; 2092 int error = 0; 2093 struct sys_statvfs1_args callarg; 2094 2095 SPARG(&callarg, path) = path; 2096 SPARG(&callarg, buf) = buf; 2097 SPARG(&callarg, flags) = flags; 2098 2099 error = rsys_syscall(SYS_statvfs1, &callarg, sizeof(callarg), rval); 2100 if (error) { 2101 rval[0] = -1; 2102 rsys_seterrno(error); 2103 } 2104 return rval[0]; 2105 } 2106 rsys_alias(sys_statvfs1,rump_enosys) 2107 2108 int rump_sys_fstatvfs1(int, struct statvfs *, int); 2109 int 2110 rump_sys_fstatvfs1(int fd, struct statvfs * buf, int flags) 2111 { 2112 register_t rval[2] = {0, 0}; 2113 int error = 0; 2114 struct sys_fstatvfs1_args callarg; 2115 2116 SPARG(&callarg, fd) = fd; 2117 SPARG(&callarg, buf) = buf; 2118 SPARG(&callarg, flags) = flags; 2119 2120 error = rsys_syscall(SYS_fstatvfs1, &callarg, sizeof(callarg), rval); 2121 if (error) { 2122 rval[0] = -1; 2123 rsys_seterrno(error); 2124 } 2125 return rval[0]; 2126 } 2127 rsys_alias(sys_fstatvfs1,rump_enosys) 2128 2129 int rump_sys_extattrctl(const char *, int, const char *, int, const char *); 2130 int 2131 rump_sys_extattrctl(const char * path, int cmd, const char * filename, int attrnamespace, const char * attrname) 2132 { 2133 register_t rval[2] = {0, 0}; 2134 int error = 0; 2135 struct sys_extattrctl_args callarg; 2136 2137 SPARG(&callarg, path) = path; 2138 SPARG(&callarg, cmd) = cmd; 2139 SPARG(&callarg, filename) = filename; 2140 SPARG(&callarg, attrnamespace) = attrnamespace; 2141 SPARG(&callarg, attrname) = attrname; 2142 2143 error = rsys_syscall(SYS_extattrctl, &callarg, sizeof(callarg), rval); 2144 if (error) { 2145 rval[0] = -1; 2146 rsys_seterrno(error); 2147 } 2148 return rval[0]; 2149 } 2150 rsys_alias(sys_extattrctl,rump_enosys) 2151 2152 int rump_sys_extattr_set_file(const char *, int, const char *, const void *, size_t); 2153 int 2154 rump_sys_extattr_set_file(const char * path, int attrnamespace, const char * attrname, const void * data, size_t nbytes) 2155 { 2156 register_t rval[2] = {0, 0}; 2157 int error = 0; 2158 struct sys_extattr_set_file_args callarg; 2159 2160 SPARG(&callarg, path) = path; 2161 SPARG(&callarg, attrnamespace) = attrnamespace; 2162 SPARG(&callarg, attrname) = attrname; 2163 SPARG(&callarg, data) = data; 2164 SPARG(&callarg, nbytes) = nbytes; 2165 2166 error = rsys_syscall(SYS_extattr_set_file, &callarg, sizeof(callarg), rval); 2167 if (error) { 2168 rval[0] = -1; 2169 rsys_seterrno(error); 2170 } 2171 return rval[0]; 2172 } 2173 rsys_alias(sys_extattr_set_file,rump_enosys) 2174 2175 ssize_t rump_sys_extattr_get_file(const char *, int, const char *, void *, size_t); 2176 ssize_t 2177 rump_sys_extattr_get_file(const char * path, int attrnamespace, const char * attrname, void * data, size_t nbytes) 2178 { 2179 register_t rval[2] = {0, 0}; 2180 int error = 0; 2181 struct sys_extattr_get_file_args callarg; 2182 2183 SPARG(&callarg, path) = path; 2184 SPARG(&callarg, attrnamespace) = attrnamespace; 2185 SPARG(&callarg, attrname) = attrname; 2186 SPARG(&callarg, data) = data; 2187 SPARG(&callarg, nbytes) = nbytes; 2188 2189 error = rsys_syscall(SYS_extattr_get_file, &callarg, sizeof(callarg), rval); 2190 if (error) { 2191 rval[0] = -1; 2192 rsys_seterrno(error); 2193 } 2194 return rval[0]; 2195 } 2196 rsys_alias(sys_extattr_get_file,rump_enosys) 2197 2198 int rump_sys_extattr_delete_file(const char *, int, const char *); 2199 int 2200 rump_sys_extattr_delete_file(const char * path, int attrnamespace, const char * attrname) 2201 { 2202 register_t rval[2] = {0, 0}; 2203 int error = 0; 2204 struct sys_extattr_delete_file_args callarg; 2205 2206 SPARG(&callarg, path) = path; 2207 SPARG(&callarg, attrnamespace) = attrnamespace; 2208 SPARG(&callarg, attrname) = attrname; 2209 2210 error = rsys_syscall(SYS_extattr_delete_file, &callarg, sizeof(callarg), rval); 2211 if (error) { 2212 rval[0] = -1; 2213 rsys_seterrno(error); 2214 } 2215 return rval[0]; 2216 } 2217 rsys_alias(sys_extattr_delete_file,rump_enosys) 2218 2219 int rump_sys_extattr_set_fd(int, int, const char *, const void *, size_t); 2220 int 2221 rump_sys_extattr_set_fd(int fd, int attrnamespace, const char * attrname, const void * data, size_t nbytes) 2222 { 2223 register_t rval[2] = {0, 0}; 2224 int error = 0; 2225 struct sys_extattr_set_fd_args callarg; 2226 2227 SPARG(&callarg, fd) = fd; 2228 SPARG(&callarg, attrnamespace) = attrnamespace; 2229 SPARG(&callarg, attrname) = attrname; 2230 SPARG(&callarg, data) = data; 2231 SPARG(&callarg, nbytes) = nbytes; 2232 2233 error = rsys_syscall(SYS_extattr_set_fd, &callarg, sizeof(callarg), rval); 2234 if (error) { 2235 rval[0] = -1; 2236 rsys_seterrno(error); 2237 } 2238 return rval[0]; 2239 } 2240 rsys_alias(sys_extattr_set_fd,rump_enosys) 2241 2242 ssize_t rump_sys_extattr_get_fd(int, int, const char *, void *, size_t); 2243 ssize_t 2244 rump_sys_extattr_get_fd(int fd, int attrnamespace, const char * attrname, void * data, size_t nbytes) 2245 { 2246 register_t rval[2] = {0, 0}; 2247 int error = 0; 2248 struct sys_extattr_get_fd_args callarg; 2249 2250 SPARG(&callarg, fd) = fd; 2251 SPARG(&callarg, attrnamespace) = attrnamespace; 2252 SPARG(&callarg, attrname) = attrname; 2253 SPARG(&callarg, data) = data; 2254 SPARG(&callarg, nbytes) = nbytes; 2255 2256 error = rsys_syscall(SYS_extattr_get_fd, &callarg, sizeof(callarg), rval); 2257 if (error) { 2258 rval[0] = -1; 2259 rsys_seterrno(error); 2260 } 2261 return rval[0]; 2262 } 2263 rsys_alias(sys_extattr_get_fd,rump_enosys) 2264 2265 int rump_sys_extattr_delete_fd(int, int, const char *); 2266 int 2267 rump_sys_extattr_delete_fd(int fd, int attrnamespace, const char * attrname) 2268 { 2269 register_t rval[2] = {0, 0}; 2270 int error = 0; 2271 struct sys_extattr_delete_fd_args callarg; 2272 2273 SPARG(&callarg, fd) = fd; 2274 SPARG(&callarg, attrnamespace) = attrnamespace; 2275 SPARG(&callarg, attrname) = attrname; 2276 2277 error = rsys_syscall(SYS_extattr_delete_fd, &callarg, sizeof(callarg), rval); 2278 if (error) { 2279 rval[0] = -1; 2280 rsys_seterrno(error); 2281 } 2282 return rval[0]; 2283 } 2284 rsys_alias(sys_extattr_delete_fd,rump_enosys) 2285 2286 int rump_sys_extattr_set_link(const char *, int, const char *, const void *, size_t); 2287 int 2288 rump_sys_extattr_set_link(const char * path, int attrnamespace, const char * attrname, const void * data, size_t nbytes) 2289 { 2290 register_t rval[2] = {0, 0}; 2291 int error = 0; 2292 struct sys_extattr_set_link_args callarg; 2293 2294 SPARG(&callarg, path) = path; 2295 SPARG(&callarg, attrnamespace) = attrnamespace; 2296 SPARG(&callarg, attrname) = attrname; 2297 SPARG(&callarg, data) = data; 2298 SPARG(&callarg, nbytes) = nbytes; 2299 2300 error = rsys_syscall(SYS_extattr_set_link, &callarg, sizeof(callarg), rval); 2301 if (error) { 2302 rval[0] = -1; 2303 rsys_seterrno(error); 2304 } 2305 return rval[0]; 2306 } 2307 rsys_alias(sys_extattr_set_link,rump_enosys) 2308 2309 ssize_t rump_sys_extattr_get_link(const char *, int, const char *, void *, size_t); 2310 ssize_t 2311 rump_sys_extattr_get_link(const char * path, int attrnamespace, const char * attrname, void * data, size_t nbytes) 2312 { 2313 register_t rval[2] = {0, 0}; 2314 int error = 0; 2315 struct sys_extattr_get_link_args callarg; 2316 2317 SPARG(&callarg, path) = path; 2318 SPARG(&callarg, attrnamespace) = attrnamespace; 2319 SPARG(&callarg, attrname) = attrname; 2320 SPARG(&callarg, data) = data; 2321 SPARG(&callarg, nbytes) = nbytes; 2322 2323 error = rsys_syscall(SYS_extattr_get_link, &callarg, sizeof(callarg), rval); 2324 if (error) { 2325 rval[0] = -1; 2326 rsys_seterrno(error); 2327 } 2328 return rval[0]; 2329 } 2330 rsys_alias(sys_extattr_get_link,rump_enosys) 2331 2332 int rump_sys_extattr_delete_link(const char *, int, const char *); 2333 int 2334 rump_sys_extattr_delete_link(const char * path, int attrnamespace, const char * attrname) 2335 { 2336 register_t rval[2] = {0, 0}; 2337 int error = 0; 2338 struct sys_extattr_delete_link_args callarg; 2339 2340 SPARG(&callarg, path) = path; 2341 SPARG(&callarg, attrnamespace) = attrnamespace; 2342 SPARG(&callarg, attrname) = attrname; 2343 2344 error = rsys_syscall(SYS_extattr_delete_link, &callarg, sizeof(callarg), rval); 2345 if (error) { 2346 rval[0] = -1; 2347 rsys_seterrno(error); 2348 } 2349 return rval[0]; 2350 } 2351 rsys_alias(sys_extattr_delete_link,rump_enosys) 2352 2353 ssize_t rump_sys_extattr_list_fd(int, int, void *, size_t); 2354 ssize_t 2355 rump_sys_extattr_list_fd(int fd, int attrnamespace, void * data, size_t nbytes) 2356 { 2357 register_t rval[2] = {0, 0}; 2358 int error = 0; 2359 struct sys_extattr_list_fd_args callarg; 2360 2361 SPARG(&callarg, fd) = fd; 2362 SPARG(&callarg, attrnamespace) = attrnamespace; 2363 SPARG(&callarg, data) = data; 2364 SPARG(&callarg, nbytes) = nbytes; 2365 2366 error = rsys_syscall(SYS_extattr_list_fd, &callarg, sizeof(callarg), rval); 2367 if (error) { 2368 rval[0] = -1; 2369 rsys_seterrno(error); 2370 } 2371 return rval[0]; 2372 } 2373 rsys_alias(sys_extattr_list_fd,rump_enosys) 2374 2375 ssize_t rump_sys_extattr_list_file(const char *, int, void *, size_t); 2376 ssize_t 2377 rump_sys_extattr_list_file(const char * path, int attrnamespace, void * data, size_t nbytes) 2378 { 2379 register_t rval[2] = {0, 0}; 2380 int error = 0; 2381 struct sys_extattr_list_file_args callarg; 2382 2383 SPARG(&callarg, path) = path; 2384 SPARG(&callarg, attrnamespace) = attrnamespace; 2385 SPARG(&callarg, data) = data; 2386 SPARG(&callarg, nbytes) = nbytes; 2387 2388 error = rsys_syscall(SYS_extattr_list_file, &callarg, sizeof(callarg), rval); 2389 if (error) { 2390 rval[0] = -1; 2391 rsys_seterrno(error); 2392 } 2393 return rval[0]; 2394 } 2395 rsys_alias(sys_extattr_list_file,rump_enosys) 2396 2397 ssize_t rump_sys_extattr_list_link(const char *, int, void *, size_t); 2398 ssize_t 2399 rump_sys_extattr_list_link(const char * path, int attrnamespace, void * data, size_t nbytes) 2400 { 2401 register_t rval[2] = {0, 0}; 2402 int error = 0; 2403 struct sys_extattr_list_link_args callarg; 2404 2405 SPARG(&callarg, path) = path; 2406 SPARG(&callarg, attrnamespace) = attrnamespace; 2407 SPARG(&callarg, data) = data; 2408 SPARG(&callarg, nbytes) = nbytes; 2409 2410 error = rsys_syscall(SYS_extattr_list_link, &callarg, sizeof(callarg), rval); 2411 if (error) { 2412 rval[0] = -1; 2413 rsys_seterrno(error); 2414 } 2415 return rval[0]; 2416 } 2417 rsys_alias(sys_extattr_list_link,rump_enosys) 2418 2419 int rump_sys_setxattr(const char *, const char *, void *, size_t, int); 2420 int 2421 rump_sys_setxattr(const char * path, const char * name, void * value, size_t size, int flags) 2422 { 2423 register_t rval[2] = {0, 0}; 2424 int error = 0; 2425 struct sys_setxattr_args callarg; 2426 2427 SPARG(&callarg, path) = path; 2428 SPARG(&callarg, name) = name; 2429 SPARG(&callarg, value) = value; 2430 SPARG(&callarg, size) = size; 2431 SPARG(&callarg, flags) = flags; 2432 2433 error = rsys_syscall(SYS_setxattr, &callarg, sizeof(callarg), rval); 2434 if (error) { 2435 rval[0] = -1; 2436 rsys_seterrno(error); 2437 } 2438 return rval[0]; 2439 } 2440 rsys_alias(sys_setxattr,rump_enosys) 2441 2442 int rump_sys_lsetxattr(const char *, const char *, void *, size_t, int); 2443 int 2444 rump_sys_lsetxattr(const char * path, const char * name, void * value, size_t size, int flags) 2445 { 2446 register_t rval[2] = {0, 0}; 2447 int error = 0; 2448 struct sys_lsetxattr_args callarg; 2449 2450 SPARG(&callarg, path) = path; 2451 SPARG(&callarg, name) = name; 2452 SPARG(&callarg, value) = value; 2453 SPARG(&callarg, size) = size; 2454 SPARG(&callarg, flags) = flags; 2455 2456 error = rsys_syscall(SYS_lsetxattr, &callarg, sizeof(callarg), rval); 2457 if (error) { 2458 rval[0] = -1; 2459 rsys_seterrno(error); 2460 } 2461 return rval[0]; 2462 } 2463 rsys_alias(sys_lsetxattr,rump_enosys) 2464 2465 int rump_sys_fsetxattr(int, const char *, void *, size_t, int); 2466 int 2467 rump_sys_fsetxattr(int fd, const char * name, void * value, size_t size, int flags) 2468 { 2469 register_t rval[2] = {0, 0}; 2470 int error = 0; 2471 struct sys_fsetxattr_args callarg; 2472 2473 SPARG(&callarg, fd) = fd; 2474 SPARG(&callarg, name) = name; 2475 SPARG(&callarg, value) = value; 2476 SPARG(&callarg, size) = size; 2477 SPARG(&callarg, flags) = flags; 2478 2479 error = rsys_syscall(SYS_fsetxattr, &callarg, sizeof(callarg), rval); 2480 if (error) { 2481 rval[0] = -1; 2482 rsys_seterrno(error); 2483 } 2484 return rval[0]; 2485 } 2486 rsys_alias(sys_fsetxattr,rump_enosys) 2487 2488 int rump_sys_getxattr(const char *, const char *, void *, size_t); 2489 int 2490 rump_sys_getxattr(const char * path, const char * name, void * value, size_t size) 2491 { 2492 register_t rval[2] = {0, 0}; 2493 int error = 0; 2494 struct sys_getxattr_args callarg; 2495 2496 SPARG(&callarg, path) = path; 2497 SPARG(&callarg, name) = name; 2498 SPARG(&callarg, value) = value; 2499 SPARG(&callarg, size) = size; 2500 2501 error = rsys_syscall(SYS_getxattr, &callarg, sizeof(callarg), rval); 2502 if (error) { 2503 rval[0] = -1; 2504 rsys_seterrno(error); 2505 } 2506 return rval[0]; 2507 } 2508 rsys_alias(sys_getxattr,rump_enosys) 2509 2510 int rump_sys_lgetxattr(const char *, const char *, void *, size_t); 2511 int 2512 rump_sys_lgetxattr(const char * path, const char * name, void * value, size_t size) 2513 { 2514 register_t rval[2] = {0, 0}; 2515 int error = 0; 2516 struct sys_lgetxattr_args callarg; 2517 2518 SPARG(&callarg, path) = path; 2519 SPARG(&callarg, name) = name; 2520 SPARG(&callarg, value) = value; 2521 SPARG(&callarg, size) = size; 2522 2523 error = rsys_syscall(SYS_lgetxattr, &callarg, sizeof(callarg), rval); 2524 if (error) { 2525 rval[0] = -1; 2526 rsys_seterrno(error); 2527 } 2528 return rval[0]; 2529 } 2530 rsys_alias(sys_lgetxattr,rump_enosys) 2531 2532 int rump_sys_fgetxattr(int, const char *, void *, size_t); 2533 int 2534 rump_sys_fgetxattr(int fd, const char * name, void * value, size_t size) 2535 { 2536 register_t rval[2] = {0, 0}; 2537 int error = 0; 2538 struct sys_fgetxattr_args callarg; 2539 2540 SPARG(&callarg, fd) = fd; 2541 SPARG(&callarg, name) = name; 2542 SPARG(&callarg, value) = value; 2543 SPARG(&callarg, size) = size; 2544 2545 error = rsys_syscall(SYS_fgetxattr, &callarg, sizeof(callarg), rval); 2546 if (error) { 2547 rval[0] = -1; 2548 rsys_seterrno(error); 2549 } 2550 return rval[0]; 2551 } 2552 rsys_alias(sys_fgetxattr,rump_enosys) 2553 2554 int rump_sys_listxattr(const char *, char *, size_t); 2555 int 2556 rump_sys_listxattr(const char * path, char * list, size_t size) 2557 { 2558 register_t rval[2] = {0, 0}; 2559 int error = 0; 2560 struct sys_listxattr_args callarg; 2561 2562 SPARG(&callarg, path) = path; 2563 SPARG(&callarg, list) = list; 2564 SPARG(&callarg, size) = size; 2565 2566 error = rsys_syscall(SYS_listxattr, &callarg, sizeof(callarg), rval); 2567 if (error) { 2568 rval[0] = -1; 2569 rsys_seterrno(error); 2570 } 2571 return rval[0]; 2572 } 2573 rsys_alias(sys_listxattr,rump_enosys) 2574 2575 int rump_sys_llistxattr(const char *, char *, size_t); 2576 int 2577 rump_sys_llistxattr(const char * path, char * list, size_t size) 2578 { 2579 register_t rval[2] = {0, 0}; 2580 int error = 0; 2581 struct sys_llistxattr_args callarg; 2582 2583 SPARG(&callarg, path) = path; 2584 SPARG(&callarg, list) = list; 2585 SPARG(&callarg, size) = size; 2586 2587 error = rsys_syscall(SYS_llistxattr, &callarg, sizeof(callarg), rval); 2588 if (error) { 2589 rval[0] = -1; 2590 rsys_seterrno(error); 2591 } 2592 return rval[0]; 2593 } 2594 rsys_alias(sys_llistxattr,rump_enosys) 2595 2596 int rump_sys_flistxattr(int, char *, size_t); 2597 int 2598 rump_sys_flistxattr(int fd, char * list, size_t size) 2599 { 2600 register_t rval[2] = {0, 0}; 2601 int error = 0; 2602 struct sys_flistxattr_args callarg; 2603 2604 SPARG(&callarg, fd) = fd; 2605 SPARG(&callarg, list) = list; 2606 SPARG(&callarg, size) = size; 2607 2608 error = rsys_syscall(SYS_flistxattr, &callarg, sizeof(callarg), rval); 2609 if (error) { 2610 rval[0] = -1; 2611 rsys_seterrno(error); 2612 } 2613 return rval[0]; 2614 } 2615 rsys_alias(sys_flistxattr,rump_enosys) 2616 2617 int rump_sys_removexattr(const char *, const char *); 2618 int 2619 rump_sys_removexattr(const char * path, const char * name) 2620 { 2621 register_t rval[2] = {0, 0}; 2622 int error = 0; 2623 struct sys_removexattr_args callarg; 2624 2625 SPARG(&callarg, path) = path; 2626 SPARG(&callarg, name) = name; 2627 2628 error = rsys_syscall(SYS_removexattr, &callarg, sizeof(callarg), rval); 2629 if (error) { 2630 rval[0] = -1; 2631 rsys_seterrno(error); 2632 } 2633 return rval[0]; 2634 } 2635 rsys_alias(sys_removexattr,rump_enosys) 2636 2637 int rump_sys_lremovexattr(const char *, const char *); 2638 int 2639 rump_sys_lremovexattr(const char * path, const char * name) 2640 { 2641 register_t rval[2] = {0, 0}; 2642 int error = 0; 2643 struct sys_lremovexattr_args callarg; 2644 2645 SPARG(&callarg, path) = path; 2646 SPARG(&callarg, name) = name; 2647 2648 error = rsys_syscall(SYS_lremovexattr, &callarg, sizeof(callarg), rval); 2649 if (error) { 2650 rval[0] = -1; 2651 rsys_seterrno(error); 2652 } 2653 return rval[0]; 2654 } 2655 rsys_alias(sys_lremovexattr,rump_enosys) 2656 2657 int rump_sys_fremovexattr(int, const char *); 2658 int 2659 rump_sys_fremovexattr(int fd, const char * name) 2660 { 2661 register_t rval[2] = {0, 0}; 2662 int error = 0; 2663 struct sys_fremovexattr_args callarg; 2664 2665 SPARG(&callarg, fd) = fd; 2666 SPARG(&callarg, name) = name; 2667 2668 error = rsys_syscall(SYS_fremovexattr, &callarg, sizeof(callarg), rval); 2669 if (error) { 2670 rval[0] = -1; 2671 rsys_seterrno(error); 2672 } 2673 return rval[0]; 2674 } 2675 rsys_alias(sys_fremovexattr,rump_enosys) 2676 2677 int rump_sys___getdents30(int, char *, size_t); 2678 int 2679 rump_sys___getdents30(int fd, char * buf, size_t count) 2680 { 2681 register_t rval[2] = {0, 0}; 2682 int error = 0; 2683 struct sys___getdents30_args callarg; 2684 2685 SPARG(&callarg, fd) = fd; 2686 SPARG(&callarg, buf) = buf; 2687 SPARG(&callarg, count) = count; 2688 2689 error = rsys_syscall(SYS___getdents30, &callarg, sizeof(callarg), rval); 2690 if (error) { 2691 rval[0] = -1; 2692 rsys_seterrno(error); 2693 } 2694 return rval[0]; 2695 } 2696 rsys_alias(sys___getdents30,rump_enosys) 2697 2698 int rump_sys___socket30(int, int, int); 2699 int 2700 rump_sys___socket30(int domain, int type, int protocol) 2701 { 2702 register_t rval[2] = {0, 0}; 2703 int error = 0; 2704 struct sys___socket30_args callarg; 2705 2706 SPARG(&callarg, domain) = domain; 2707 SPARG(&callarg, type) = type; 2708 SPARG(&callarg, protocol) = protocol; 2709 2710 error = rsys_syscall(SYS___socket30, &callarg, sizeof(callarg), rval); 2711 if (error) { 2712 rval[0] = -1; 2713 rsys_seterrno(error); 2714 } 2715 return rval[0]; 2716 } 2717 rsys_alias(sys___socket30,rump_enosys) 2718 2719 int rump_sys___getfh30(const char *, void *, size_t *); 2720 int 2721 rump_sys___getfh30(const char * fname, void * fhp, size_t * fh_size) 2722 { 2723 register_t rval[2] = {0, 0}; 2724 int error = 0; 2725 struct sys___getfh30_args callarg; 2726 2727 SPARG(&callarg, fname) = fname; 2728 SPARG(&callarg, fhp) = fhp; 2729 SPARG(&callarg, fh_size) = fh_size; 2730 2731 error = rsys_syscall(SYS___getfh30, &callarg, sizeof(callarg), rval); 2732 if (error) { 2733 rval[0] = -1; 2734 rsys_seterrno(error); 2735 } 2736 return rval[0]; 2737 } 2738 rsys_alias(sys___getfh30,rump_enosys) 2739 2740 int rump_sys___fhopen40(const void *, size_t, int); 2741 int 2742 rump_sys___fhopen40(const void * fhp, size_t fh_size, int flags) 2743 { 2744 register_t rval[2] = {0, 0}; 2745 int error = 0; 2746 struct sys___fhopen40_args callarg; 2747 2748 SPARG(&callarg, fhp) = fhp; 2749 SPARG(&callarg, fh_size) = fh_size; 2750 SPARG(&callarg, flags) = flags; 2751 2752 error = rsys_syscall(SYS___fhopen40, &callarg, sizeof(callarg), rval); 2753 if (error) { 2754 rval[0] = -1; 2755 rsys_seterrno(error); 2756 } 2757 return rval[0]; 2758 } 2759 rsys_alias(sys___fhopen40,rump_enosys) 2760 2761 int rump_sys___fhstatvfs140(const void *, size_t, struct statvfs *, int); 2762 int 2763 rump_sys___fhstatvfs140(const void * fhp, size_t fh_size, struct statvfs * buf, int flags) 2764 { 2765 register_t rval[2] = {0, 0}; 2766 int error = 0; 2767 struct sys___fhstatvfs140_args callarg; 2768 2769 SPARG(&callarg, fhp) = fhp; 2770 SPARG(&callarg, fh_size) = fh_size; 2771 SPARG(&callarg, buf) = buf; 2772 SPARG(&callarg, flags) = flags; 2773 2774 error = rsys_syscall(SYS___fhstatvfs140, &callarg, sizeof(callarg), rval); 2775 if (error) { 2776 rval[0] = -1; 2777 rsys_seterrno(error); 2778 } 2779 return rval[0]; 2780 } 2781 rsys_alias(sys___fhstatvfs140,rump_enosys) 2782 2783 int rump_sys___mount50(const char *, const char *, int, void *, size_t); 2784 int 2785 rump_sys___mount50(const char * type, const char * path, int flags, void * data, size_t data_len) 2786 { 2787 register_t rval[2] = {0, 0}; 2788 int error = 0; 2789 struct sys___mount50_args callarg; 2790 2791 SPARG(&callarg, type) = type; 2792 SPARG(&callarg, path) = path; 2793 SPARG(&callarg, flags) = flags; 2794 SPARG(&callarg, data) = data; 2795 SPARG(&callarg, data_len) = data_len; 2796 2797 error = rsys_syscall(SYS___mount50, &callarg, sizeof(callarg), rval); 2798 if (error) { 2799 rval[0] = -1; 2800 rsys_seterrno(error); 2801 } 2802 return rval[0]; 2803 } 2804 rsys_alias(sys___mount50,rump_enosys) 2805 2806 int rump_sys___posix_fadvise50(int, off_t, off_t, int); 2807 int 2808 rump_sys___posix_fadvise50(int fd, off_t offset, off_t len, int advice) 2809 { 2810 register_t rval[2] = {0, 0}; 2811 int error = 0; 2812 struct sys___posix_fadvise50_args callarg; 2813 2814 SPARG(&callarg, fd) = fd; 2815 SPARG(&callarg, PAD) = 0; 2816 SPARG(&callarg, offset) = offset; 2817 SPARG(&callarg, len) = len; 2818 SPARG(&callarg, advice) = advice; 2819 2820 error = rsys_syscall(SYS___posix_fadvise50, &callarg, sizeof(callarg), rval); 2821 if (error) { 2822 rval[0] = -1; 2823 rsys_seterrno(error); 2824 } 2825 return rval[0]; 2826 } 2827 rsys_alias(sys___posix_fadvise50,rump_enosys) 2828 2829 int rump_sys___select50(int, fd_set *, fd_set *, fd_set *, struct timeval *); 2830 int 2831 rump_sys___select50(int nd, fd_set * in, fd_set * ou, fd_set * ex, struct timeval * tv) 2832 { 2833 register_t rval[2] = {0, 0}; 2834 int error = 0; 2835 struct sys___select50_args callarg; 2836 2837 SPARG(&callarg, nd) = nd; 2838 SPARG(&callarg, in) = in; 2839 SPARG(&callarg, ou) = ou; 2840 SPARG(&callarg, ex) = ex; 2841 SPARG(&callarg, tv) = tv; 2842 2843 error = rsys_syscall(SYS___select50, &callarg, sizeof(callarg), rval); 2844 if (error) { 2845 rval[0] = -1; 2846 rsys_seterrno(error); 2847 } 2848 return rval[0]; 2849 } 2850 rsys_alias(sys___select50,rump_enosys) 2851 2852 int rump_sys___utimes50(const char *, const struct timeval *); 2853 int 2854 rump_sys___utimes50(const char * path, const struct timeval * tptr) 2855 { 2856 register_t rval[2] = {0, 0}; 2857 int error = 0; 2858 struct sys___utimes50_args callarg; 2859 2860 SPARG(&callarg, path) = path; 2861 SPARG(&callarg, tptr) = tptr; 2862 2863 error = rsys_syscall(SYS___utimes50, &callarg, sizeof(callarg), rval); 2864 if (error) { 2865 rval[0] = -1; 2866 rsys_seterrno(error); 2867 } 2868 return rval[0]; 2869 } 2870 rsys_alias(sys___utimes50,rump_enosys) 2871 2872 int rump_sys___futimes50(int, const struct timeval *); 2873 int 2874 rump_sys___futimes50(int fd, const struct timeval * tptr) 2875 { 2876 register_t rval[2] = {0, 0}; 2877 int error = 0; 2878 struct sys___futimes50_args callarg; 2879 2880 SPARG(&callarg, fd) = fd; 2881 SPARG(&callarg, tptr) = tptr; 2882 2883 error = rsys_syscall(SYS___futimes50, &callarg, sizeof(callarg), rval); 2884 if (error) { 2885 rval[0] = -1; 2886 rsys_seterrno(error); 2887 } 2888 return rval[0]; 2889 } 2890 rsys_alias(sys___futimes50,rump_enosys) 2891 2892 int rump_sys___lutimes50(const char *, const struct timeval *); 2893 int 2894 rump_sys___lutimes50(const char * path, const struct timeval * tptr) 2895 { 2896 register_t rval[2] = {0, 0}; 2897 int error = 0; 2898 struct sys___lutimes50_args callarg; 2899 2900 SPARG(&callarg, path) = path; 2901 SPARG(&callarg, tptr) = tptr; 2902 2903 error = rsys_syscall(SYS___lutimes50, &callarg, sizeof(callarg), rval); 2904 if (error) { 2905 rval[0] = -1; 2906 rsys_seterrno(error); 2907 } 2908 return rval[0]; 2909 } 2910 rsys_alias(sys___lutimes50,rump_enosys) 2911 2912 int rump_sys___kevent50(int, const struct kevent *, size_t, struct kevent *, size_t, const struct timespec *); 2913 int 2914 rump_sys___kevent50(int fd, const struct kevent * changelist, size_t nchanges, struct kevent * eventlist, size_t nevents, const struct timespec * timeout) 2915 { 2916 register_t rval[2] = {0, 0}; 2917 int error = 0; 2918 struct sys___kevent50_args callarg; 2919 2920 SPARG(&callarg, fd) = fd; 2921 SPARG(&callarg, changelist) = changelist; 2922 SPARG(&callarg, nchanges) = nchanges; 2923 SPARG(&callarg, eventlist) = eventlist; 2924 SPARG(&callarg, nevents) = nevents; 2925 SPARG(&callarg, timeout) = timeout; 2926 2927 error = rsys_syscall(SYS___kevent50, &callarg, sizeof(callarg), rval); 2928 if (error) { 2929 rval[0] = -1; 2930 rsys_seterrno(error); 2931 } 2932 return rval[0]; 2933 } 2934 rsys_alias(sys___kevent50,rump_enosys) 2935 2936 int rump_sys___pselect50(int, fd_set *, fd_set *, fd_set *, const struct timespec *, const sigset_t *); 2937 int 2938 rump_sys___pselect50(int nd, fd_set * in, fd_set * ou, fd_set * ex, const struct timespec * ts, const sigset_t * mask) 2939 { 2940 register_t rval[2] = {0, 0}; 2941 int error = 0; 2942 struct sys___pselect50_args callarg; 2943 2944 SPARG(&callarg, nd) = nd; 2945 SPARG(&callarg, in) = in; 2946 SPARG(&callarg, ou) = ou; 2947 SPARG(&callarg, ex) = ex; 2948 SPARG(&callarg, ts) = ts; 2949 SPARG(&callarg, mask) = mask; 2950 2951 error = rsys_syscall(SYS___pselect50, &callarg, sizeof(callarg), rval); 2952 if (error) { 2953 rval[0] = -1; 2954 rsys_seterrno(error); 2955 } 2956 return rval[0]; 2957 } 2958 rsys_alias(sys___pselect50,rump_enosys) 2959 2960 int rump_sys___pollts50(struct pollfd *, u_int, const struct timespec *, const sigset_t *); 2961 int 2962 rump_sys___pollts50(struct pollfd * fds, u_int nfds, const struct timespec * ts, const sigset_t * mask) 2963 { 2964 register_t rval[2] = {0, 0}; 2965 int error = 0; 2966 struct sys___pollts50_args callarg; 2967 2968 SPARG(&callarg, fds) = fds; 2969 SPARG(&callarg, nfds) = nfds; 2970 SPARG(&callarg, ts) = ts; 2971 SPARG(&callarg, mask) = mask; 2972 2973 error = rsys_syscall(SYS___pollts50, &callarg, sizeof(callarg), rval); 2974 if (error) { 2975 rval[0] = -1; 2976 rsys_seterrno(error); 2977 } 2978 return rval[0]; 2979 } 2980 rsys_alias(sys___pollts50,rump_enosys) 2981 2982 int rump_sys___stat50(const char *, struct stat *); 2983 int 2984 rump_sys___stat50(const char * path, struct stat * ub) 2985 { 2986 register_t rval[2] = {0, 0}; 2987 int error = 0; 2988 struct sys___stat50_args callarg; 2989 2990 SPARG(&callarg, path) = path; 2991 SPARG(&callarg, ub) = ub; 2992 2993 error = rsys_syscall(SYS___stat50, &callarg, sizeof(callarg), rval); 2994 if (error) { 2995 rval[0] = -1; 2996 rsys_seterrno(error); 2997 } 2998 return rval[0]; 2999 } 3000 rsys_alias(sys___stat50,rump_enosys) 3001 3002 int rump_sys___fstat50(int, struct stat *); 3003 int 3004 rump_sys___fstat50(int fd, struct stat * sb) 3005 { 3006 register_t rval[2] = {0, 0}; 3007 int error = 0; 3008 struct sys___fstat50_args callarg; 3009 3010 SPARG(&callarg, fd) = fd; 3011 SPARG(&callarg, sb) = sb; 3012 3013 error = rsys_syscall(SYS___fstat50, &callarg, sizeof(callarg), rval); 3014 if (error) { 3015 rval[0] = -1; 3016 rsys_seterrno(error); 3017 } 3018 return rval[0]; 3019 } 3020 rsys_alias(sys___fstat50,rump_enosys) 3021 3022 int rump_sys___lstat50(const char *, struct stat *); 3023 int 3024 rump_sys___lstat50(const char * path, struct stat * ub) 3025 { 3026 register_t rval[2] = {0, 0}; 3027 int error = 0; 3028 struct sys___lstat50_args callarg; 3029 3030 SPARG(&callarg, path) = path; 3031 SPARG(&callarg, ub) = ub; 3032 3033 error = rsys_syscall(SYS___lstat50, &callarg, sizeof(callarg), rval); 3034 if (error) { 3035 rval[0] = -1; 3036 rsys_seterrno(error); 3037 } 3038 return rval[0]; 3039 } 3040 rsys_alias(sys___lstat50,rump_enosys) 3041 3042 int rump_sys___mknod50(const char *, mode_t, dev_t); 3043 int 3044 rump_sys___mknod50(const char * path, mode_t mode, dev_t dev) 3045 { 3046 register_t rval[2] = {0, 0}; 3047 int error = 0; 3048 struct sys___mknod50_args callarg; 3049 3050 SPARG(&callarg, path) = path; 3051 SPARG(&callarg, mode) = mode; 3052 SPARG(&callarg, dev) = dev; 3053 3054 error = rsys_syscall(SYS___mknod50, &callarg, sizeof(callarg), rval); 3055 if (error) { 3056 rval[0] = -1; 3057 rsys_seterrno(error); 3058 } 3059 return rval[0]; 3060 } 3061 rsys_alias(sys___mknod50,rump_enosys) 3062 3063 int rump_sys___fhstat50(const void *, size_t, struct stat *); 3064 int 3065 rump_sys___fhstat50(const void * fhp, size_t fh_size, struct stat * sb) 3066 { 3067 register_t rval[2] = {0, 0}; 3068 int error = 0; 3069 struct sys___fhstat50_args callarg; 3070 3071 SPARG(&callarg, fhp) = fhp; 3072 SPARG(&callarg, fh_size) = fh_size; 3073 SPARG(&callarg, sb) = sb; 3074 3075 error = rsys_syscall(SYS___fhstat50, &callarg, sizeof(callarg), rval); 3076 if (error) { 3077 rval[0] = -1; 3078 rsys_seterrno(error); 3079 } 3080 return rval[0]; 3081 } 3082 rsys_alias(sys___fhstat50,rump_enosys) 3083 3084 int rump_sys_pipe(int *); 3085 int 3086 rump_sys_pipe(int *fd) 3087 { 3088 register_t rval[2] = {0, 0}; 3089 int error = 0; 3090 3091 error = rsys_syscall(SYS_pipe, NULL, 0, rval); 3092 if (error) { 3093 rsys_seterrno(error); 3094 } else { 3095 fd[0] = rval[0]; 3096 fd[1] = rval[1]; 3097 } 3098 return error ? -1 : 0; 3099 } 3100 3101 #ifndef RUMP_CLIENT 3102 #define s(type) sizeof(type) 3103 #define n(type) (sizeof(type)/sizeof (register_t)) 3104 #define ns(type) n(type), s(type) 3105 3106 struct sysent rump_sysent[] = { 3107 { 0, 0, 0, 3108 (sy_call_t *)rump_enosys }, /* 0 = unrumped */ 3109 { 0, 0, 0, 3110 (sy_call_t *)rump_enosys }, /* 1 = unrumped */ 3111 { 0, 0, 0, 3112 (sy_call_t *)rump_enosys }, /* 2 = unrumped */ 3113 { ns(struct sys_read_args), 0, 3114 (sy_call_t *)sys_read }, /* 3 = read */ 3115 { ns(struct sys_write_args), 0, 3116 (sy_call_t *)sys_write }, /* 4 = write */ 3117 { ns(struct sys_open_args), 0, 3118 (sy_call_t *)sys_open }, /* 5 = open */ 3119 { ns(struct sys_close_args), 0, 3120 (sy_call_t *)sys_close }, /* 6 = close */ 3121 { 0, 0, 0, 3122 (sy_call_t *)sys_nomodule }, /* 7 = unrumped */ 3123 { 0, 0, 0, 3124 (sy_call_t *)sys_nomodule }, /* 8 = unrumped */ 3125 { ns(struct sys_link_args), 0, 3126 (sy_call_t *)sys_link }, /* 9 = link */ 3127 { ns(struct sys_unlink_args), 0, 3128 (sy_call_t *)sys_unlink }, /* 10 = unlink */ 3129 { 0, 0, 0, 3130 (sy_call_t *)rump_enosys }, /* 11 = obsolete execv */ 3131 { ns(struct sys_chdir_args), 0, 3132 (sy_call_t *)sys_chdir }, /* 12 = chdir */ 3133 { ns(struct sys_fchdir_args), 0, 3134 (sy_call_t *)sys_fchdir }, /* 13 = fchdir */ 3135 { 0, 0, 0, 3136 (sy_call_t *)sys_nomodule }, /* 14 = unrumped */ 3137 { ns(struct sys_chmod_args), 0, 3138 (sy_call_t *)sys_chmod }, /* 15 = chmod */ 3139 { ns(struct sys_chown_args), 0, 3140 (sy_call_t *)sys_chown }, /* 16 = chown */ 3141 { 0, 0, 0, 3142 (sy_call_t *)rump_enosys }, /* 17 = unrumped */ 3143 { 0, 0, 0, 3144 (sy_call_t *)sys_nomodule }, /* 18 = unrumped */ 3145 { 0, 0, 0, 3146 (sy_call_t *)sys_nomodule }, /* 19 = unrumped */ 3147 { 0, 0, 0, 3148 (sy_call_t *)sys_getpid_with_ppid }, /* 20 = getpid */ 3149 { 0, 0, 0, 3150 (sy_call_t *)sys_nomodule }, /* 21 = unrumped */ 3151 { ns(struct sys_unmount_args), 0, 3152 (sy_call_t *)sys_unmount }, /* 22 = unmount */ 3153 { ns(struct sys_setuid_args), 0, 3154 (sy_call_t *)sys_setuid }, /* 23 = setuid */ 3155 { 0, 0, 0, 3156 (sy_call_t *)sys_getuid_with_euid }, /* 24 = getuid */ 3157 { 0, 0, 0, 3158 (sy_call_t *)sys_geteuid }, /* 25 = geteuid */ 3159 { 0, 0, 0, 3160 (sy_call_t *)rump_enosys }, /* 26 = unrumped */ 3161 { ns(struct sys_recvmsg_args), 0, 3162 (sy_call_t *)sys_recvmsg }, /* 27 = recvmsg */ 3163 { ns(struct sys_sendmsg_args), 0, 3164 (sy_call_t *)sys_sendmsg }, /* 28 = sendmsg */ 3165 { ns(struct sys_recvfrom_args), 0, 3166 (sy_call_t *)sys_recvfrom }, /* 29 = recvfrom */ 3167 { ns(struct sys_accept_args), 0, 3168 (sy_call_t *)sys_accept }, /* 30 = accept */ 3169 { ns(struct sys_getpeername_args), 0, 3170 (sy_call_t *)sys_getpeername }, /* 31 = getpeername */ 3171 { ns(struct sys_getsockname_args), 0, 3172 (sy_call_t *)sys_getsockname }, /* 32 = getsockname */ 3173 { ns(struct sys_access_args), 0, 3174 (sy_call_t *)sys_access }, /* 33 = access */ 3175 { ns(struct sys_chflags_args), 0, 3176 (sy_call_t *)sys_chflags }, /* 34 = chflags */ 3177 { ns(struct sys_fchflags_args), 0, 3178 (sy_call_t *)sys_fchflags }, /* 35 = fchflags */ 3179 { 0, 0, 0, 3180 (sy_call_t *)sys_sync }, /* 36 = sync */ 3181 { 0, 0, 0, 3182 (sy_call_t *)rump_enosys }, /* 37 = unrumped */ 3183 { 0, 0, 0, 3184 (sy_call_t *)sys_nomodule }, /* 38 = unrumped */ 3185 { 0, 0, 0, 3186 (sy_call_t *)sys_getppid }, /* 39 = getppid */ 3187 { 0, 0, 0, 3188 (sy_call_t *)sys_nomodule }, /* 40 = unrumped */ 3189 { ns(struct sys_dup_args), 0, 3190 (sy_call_t *)sys_dup }, /* 41 = dup */ 3191 { 0, 0, 0, 3192 (sy_call_t *)sys_pipe }, /* 42 = pipe */ 3193 { 0, 0, 0, 3194 (sy_call_t *)sys_getegid }, /* 43 = getegid */ 3195 { 0, 0, 0, 3196 (sy_call_t *)rump_enosys }, /* 44 = unrumped */ 3197 { 0, 0, 0, 3198 (sy_call_t *)rump_enosys }, /* 45 = unrumped */ 3199 { 0, 0, 0, 3200 (sy_call_t *)sys_nomodule }, /* 46 = unrumped */ 3201 { 0, 0, 0, 3202 (sy_call_t *)sys_getgid_with_egid }, /* 47 = getgid */ 3203 { 0, 0, 0, 3204 (sy_call_t *)sys_nomodule }, /* 48 = unrumped */ 3205 { ns(struct sys___getlogin_args), 0, 3206 (sy_call_t *)sys___getlogin }, /* 49 = __getlogin */ 3207 { ns(struct sys___setlogin_args), 0, 3208 (sy_call_t *)sys___setlogin }, /* 50 = __setlogin */ 3209 { 0, 0, 0, 3210 (sy_call_t *)rump_enosys }, /* 51 = unrumped */ 3211 { 0, 0, 0, 3212 (sy_call_t *)sys_nomodule }, /* 52 = unrumped */ 3213 { 0, 0, 0, 3214 (sy_call_t *)sys_nomodule }, /* 53 = unrumped */ 3215 { ns(struct sys_ioctl_args), 0, 3216 (sy_call_t *)sys_ioctl }, /* 54 = ioctl */ 3217 { 0, 0, 0, 3218 (sy_call_t *)sys_nomodule }, /* 55 = unrumped */ 3219 { ns(struct sys_revoke_args), 0, 3220 (sy_call_t *)sys_revoke }, /* 56 = revoke */ 3221 { ns(struct sys_symlink_args), 0, 3222 (sy_call_t *)sys_symlink }, /* 57 = symlink */ 3223 { ns(struct sys_readlink_args), 0, 3224 (sy_call_t *)sys_readlink }, /* 58 = readlink */ 3225 { 0, 0, 0, 3226 (sy_call_t *)rump_enosys }, /* 59 = unrumped */ 3227 { ns(struct sys_umask_args), 0, 3228 (sy_call_t *)sys_umask }, /* 60 = umask */ 3229 { ns(struct sys_chroot_args), 0, 3230 (sy_call_t *)sys_chroot }, /* 61 = chroot */ 3231 { 0, 0, 0, 3232 (sy_call_t *)sys_nomodule }, /* 62 = unrumped */ 3233 { 0, 0, 0, 3234 (sy_call_t *)sys_nomodule }, /* 63 = unrumped */ 3235 { 0, 0, 0, 3236 (sy_call_t *)sys_nomodule }, /* 64 = unrumped */ 3237 { 0, 0, 0, 3238 (sy_call_t *)sys_nomodule }, /* 65 = unrumped */ 3239 { 0, 0, 0, 3240 (sy_call_t *)rump_enosys }, /* 66 = unrumped */ 3241 { 0, 0, 0, 3242 (sy_call_t *)rump_enosys }, /* 67 = obsolete vread */ 3243 { 0, 0, 0, 3244 (sy_call_t *)rump_enosys }, /* 68 = obsolete vwrite */ 3245 { 0, 0, 0, 3246 (sy_call_t *)rump_enosys }, /* 69 = unrumped */ 3247 { 0, 0, 0, 3248 (sy_call_t *)rump_enosys }, /* 70 = unrumped */ 3249 { 0, 0, 0, 3250 (sy_call_t *)sys_nomodule }, /* 71 = unrumped */ 3251 { 0, 0, 0, 3252 (sy_call_t *)rump_enosys }, /* 72 = unrumped */ 3253 { 0, 0, 0, 3254 (sy_call_t *)rump_enosys }, /* 73 = unrumped */ 3255 { 0, 0, 0, 3256 (sy_call_t *)rump_enosys }, /* 74 = unrumped */ 3257 { 0, 0, 0, 3258 (sy_call_t *)rump_enosys }, /* 75 = unrumped */ 3259 { 0, 0, 0, 3260 (sy_call_t *)rump_enosys }, /* 76 = obsolete vhangup */ 3261 { 0, 0, 0, 3262 (sy_call_t *)rump_enosys }, /* 77 = obsolete vlimit */ 3263 { 0, 0, 0, 3264 (sy_call_t *)rump_enosys }, /* 78 = unrumped */ 3265 { ns(struct sys_getgroups_args), 0, 3266 (sy_call_t *)sys_getgroups }, /* 79 = getgroups */ 3267 { ns(struct sys_setgroups_args), 0, 3268 (sy_call_t *)sys_setgroups }, /* 80 = setgroups */ 3269 { 0, 0, 0, 3270 (sy_call_t *)sys_getpgrp }, /* 81 = getpgrp */ 3271 { ns(struct sys_setpgid_args), 0, 3272 (sy_call_t *)sys_setpgid }, /* 82 = setpgid */ 3273 { 0, 0, 0, 3274 (sy_call_t *)sys_nomodule }, /* 83 = unrumped */ 3275 { 0, 0, 0, 3276 (sy_call_t *)sys_nomodule }, /* 84 = unrumped */ 3277 { 0, 0, 0, 3278 (sy_call_t *)sys_nomodule }, /* 85 = unrumped */ 3279 { 0, 0, 0, 3280 (sy_call_t *)sys_nomodule }, /* 86 = unrumped */ 3281 { 0, 0, 0, 3282 (sy_call_t *)sys_nomodule }, /* 87 = unrumped */ 3283 { 0, 0, 0, 3284 (sy_call_t *)sys_nomodule }, /* 88 = unrumped */ 3285 { 0, 0, 0, 3286 (sy_call_t *)sys_nomodule }, /* 89 = unrumped */ 3287 { ns(struct sys_dup2_args), 0, 3288 (sy_call_t *)sys_dup2 }, /* 90 = dup2 */ 3289 { 0, 0, 0, 3290 (sy_call_t *)rump_enosys }, /* 91 = unimplemented getdopt */ 3291 { ns(struct sys_fcntl_args), 0, 3292 (sy_call_t *)sys_fcntl }, /* 92 = fcntl */ 3293 { 0, 0, 0, 3294 (sy_call_t *)sys_nomodule }, /* 93 = unrumped */ 3295 { 0, 0, 0, 3296 (sy_call_t *)rump_enosys }, /* 94 = unimplemented setdopt */ 3297 { ns(struct sys_fsync_args), 0, 3298 (sy_call_t *)sys_fsync }, /* 95 = fsync */ 3299 { 0, 0, 0, 3300 (sy_call_t *)rump_enosys }, /* 96 = unrumped */ 3301 { 0, 0, 0, 3302 (sy_call_t *)sys_nomodule }, /* 97 = unrumped */ 3303 { ns(struct sys_connect_args), 0, 3304 (sy_call_t *)sys_connect }, /* 98 = connect */ 3305 { 0, 0, 0, 3306 (sy_call_t *)sys_nomodule }, /* 99 = unrumped */ 3307 { 0, 0, 0, 3308 (sy_call_t *)rump_enosys }, /* 100 = unrumped */ 3309 { 0, 0, 0, 3310 (sy_call_t *)sys_nomodule }, /* 101 = unrumped */ 3311 { 0, 0, 0, 3312 (sy_call_t *)sys_nomodule }, /* 102 = unrumped */ 3313 { 0, 0, 0, 3314 (sy_call_t *)sys_nomodule }, /* 103 = unrumped */ 3315 { ns(struct sys_bind_args), 0, 3316 (sy_call_t *)sys_bind }, /* 104 = bind */ 3317 { ns(struct sys_setsockopt_args), 0, 3318 (sy_call_t *)sys_setsockopt }, /* 105 = setsockopt */ 3319 { ns(struct sys_listen_args), 0, 3320 (sy_call_t *)sys_listen }, /* 106 = listen */ 3321 { 0, 0, 0, 3322 (sy_call_t *)rump_enosys }, /* 107 = obsolete vtimes */ 3323 { 0, 0, 0, 3324 (sy_call_t *)sys_nomodule }, /* 108 = unrumped */ 3325 { 0, 0, 0, 3326 (sy_call_t *)sys_nomodule }, /* 109 = unrumped */ 3327 { 0, 0, 0, 3328 (sy_call_t *)sys_nomodule }, /* 110 = unrumped */ 3329 { 0, 0, 0, 3330 (sy_call_t *)sys_nomodule }, /* 111 = unrumped */ 3331 { 0, 0, 0, 3332 (sy_call_t *)sys_nomodule }, /* 112 = unrumped */ 3333 { 0, 0, 0, 3334 (sy_call_t *)sys_nomodule }, /* 113 = unrumped */ 3335 { 0, 0, 0, 3336 (sy_call_t *)sys_nomodule }, /* 114 = unrumped */ 3337 { 0, 0, 0, 3338 (sy_call_t *)rump_enosys }, /* 115 = obsolete vtrace */ 3339 { 0, 0, 0, 3340 (sy_call_t *)sys_nomodule }, /* 116 = unrumped */ 3341 { 0, 0, 0, 3342 (sy_call_t *)sys_nomodule }, /* 117 = unrumped */ 3343 { ns(struct sys_getsockopt_args), 0, 3344 (sy_call_t *)sys_getsockopt }, /* 118 = getsockopt */ 3345 { 0, 0, 0, 3346 (sy_call_t *)rump_enosys }, /* 119 = obsolete resuba */ 3347 { ns(struct sys_readv_args), 0, 3348 (sy_call_t *)sys_readv }, /* 120 = readv */ 3349 { ns(struct sys_writev_args), 0, 3350 (sy_call_t *)sys_writev }, /* 121 = writev */ 3351 { 0, 0, 0, 3352 (sy_call_t *)sys_nomodule }, /* 122 = unrumped */ 3353 { ns(struct sys_fchown_args), 0, 3354 (sy_call_t *)sys_fchown }, /* 123 = fchown */ 3355 { ns(struct sys_fchmod_args), 0, 3356 (sy_call_t *)sys_fchmod }, /* 124 = fchmod */ 3357 { 0, 0, 0, 3358 (sy_call_t *)sys_nomodule }, /* 125 = unrumped */ 3359 { ns(struct sys_setreuid_args), 0, 3360 (sy_call_t *)sys_setreuid }, /* 126 = setreuid */ 3361 { ns(struct sys_setregid_args), 0, 3362 (sy_call_t *)sys_setregid }, /* 127 = setregid */ 3363 { ns(struct sys_rename_args), 0, 3364 (sy_call_t *)sys_rename }, /* 128 = rename */ 3365 { 0, 0, 0, 3366 (sy_call_t *)sys_nomodule }, /* 129 = unrumped */ 3367 { 0, 0, 0, 3368 (sy_call_t *)sys_nomodule }, /* 130 = unrumped */ 3369 { ns(struct sys_flock_args), 0, 3370 (sy_call_t *)sys_flock }, /* 131 = flock */ 3371 { ns(struct sys_mkfifo_args), 0, 3372 (sy_call_t *)sys_mkfifo }, /* 132 = mkfifo */ 3373 { ns(struct sys_sendto_args), 0, 3374 (sy_call_t *)sys_sendto }, /* 133 = sendto */ 3375 { ns(struct sys_shutdown_args), 0, 3376 (sy_call_t *)sys_shutdown }, /* 134 = shutdown */ 3377 { ns(struct sys_socketpair_args), 0, 3378 (sy_call_t *)sys_socketpair }, /* 135 = socketpair */ 3379 { ns(struct sys_mkdir_args), 0, 3380 (sy_call_t *)sys_mkdir }, /* 136 = mkdir */ 3381 { ns(struct sys_rmdir_args), 0, 3382 (sy_call_t *)sys_rmdir }, /* 137 = rmdir */ 3383 { 0, 0, 0, 3384 (sy_call_t *)sys_nomodule }, /* 138 = unrumped */ 3385 { 0, 0, 0, 3386 (sy_call_t *)rump_enosys }, /* 139 = obsolete 4.2 sigreturn */ 3387 { 0, 0, 0, 3388 (sy_call_t *)sys_nomodule }, /* 140 = unrumped */ 3389 { 0, 0, 0, 3390 (sy_call_t *)sys_nomodule }, /* 141 = unrumped */ 3391 { 0, 0, 0, 3392 (sy_call_t *)sys_nomodule }, /* 142 = unrumped */ 3393 { 0, 0, 0, 3394 (sy_call_t *)sys_nomodule }, /* 143 = unrumped */ 3395 { 0, 0, 0, 3396 (sy_call_t *)sys_nomodule }, /* 144 = unrumped */ 3397 { 0, 0, 0, 3398 (sy_call_t *)sys_nomodule }, /* 145 = unrumped */ 3399 { 0, 0, 0, 3400 (sy_call_t *)sys_nomodule }, /* 146 = unrumped */ 3401 { 0, 0, 0, 3402 (sy_call_t *)sys_setsid }, /* 147 = setsid */ 3403 { 0, 0, 0, 3404 (sy_call_t *)rump_enosys }, /* 148 = unrumped */ 3405 { 0, 0, 0, 3406 (sy_call_t *)sys_nomodule }, /* 149 = unrumped */ 3407 { 0, 0, 0, 3408 (sy_call_t *)sys_nomodule }, /* 150 = unrumped */ 3409 { 0, 0, 0, 3410 (sy_call_t *)rump_enosys }, /* 151 = unimplemented */ 3411 { 0, 0, 0, 3412 (sy_call_t *)rump_enosys }, /* 152 = unimplemented */ 3413 { 0, 0, 0, 3414 (sy_call_t *)rump_enosys }, /* 153 = unimplemented */ 3415 { 0, 0, 0, 3416 (sy_call_t *)rump_enosys }, /* 154 = unimplemented */ 3417 { ns(struct sys_nfssvc_args), 0, 3418 (sy_call_t *)sys_nomodule }, /* 155 = nfssvc */ 3419 { 0, 0, 0, 3420 (sy_call_t *)sys_nomodule }, /* 156 = unrumped */ 3421 { 0, 0, 0, 3422 (sy_call_t *)sys_nomodule }, /* 157 = unrumped */ 3423 { 0, 0, 0, 3424 (sy_call_t *)sys_nomodule }, /* 158 = unrumped */ 3425 { 0, 0, 0, 3426 (sy_call_t *)rump_enosys }, /* 159 = unimplemented */ 3427 { 0, 0, 0, 3428 (sy_call_t *)rump_enosys }, /* 160 = unimplemented */ 3429 { 0, 0, 0, 3430 (sy_call_t *)sys_nomodule }, /* 161 = unrumped */ 3431 { 0, 0, 0, 3432 (sy_call_t *)sys_nomodule }, /* 162 = unrumped */ 3433 { 0, 0, 0, 3434 (sy_call_t *)sys_nomodule }, /* 163 = unrumped */ 3435 { 0, 0, 0, 3436 (sy_call_t *)sys_nomodule }, /* 164 = unrumped */ 3437 { 0, 0, 0, 3438 (sy_call_t *)rump_enosys }, /* 165 = unrumped */ 3439 { 0, 0, 0, 3440 (sy_call_t *)rump_enosys }, /* 166 = unimplemented */ 3441 { 0, 0, 0, 3442 (sy_call_t *)rump_enosys }, /* 167 = unimplemented */ 3443 { 0, 0, 0, 3444 (sy_call_t *)rump_enosys }, /* 168 = unimplemented */ 3445 #if (defined(SYSVSEM) || !defined(_KERNEL_OPT)) && !defined(_LP64) 3446 { 0, 0, 0, 3447 (sy_call_t *)sys_nomodule }, /* 169 = unrumped */ 3448 #else 3449 { 0, 0, 0, 3450 (sy_call_t *)rump_enosys }, /* 169 = excluded 1.0 semsys */ 3451 #endif 3452 #if (defined(SYSVMSG) || !defined(_KERNEL_OPT)) && !defined(_LP64) 3453 { 0, 0, 0, 3454 (sy_call_t *)sys_nomodule }, /* 170 = unrumped */ 3455 #else 3456 { 0, 0, 0, 3457 (sy_call_t *)rump_enosys }, /* 170 = excluded 1.0 msgsys */ 3458 #endif 3459 #if (defined(SYSVSHM) || !defined(_KERNEL_OPT)) && !defined(_LP64) 3460 { 0, 0, 0, 3461 (sy_call_t *)sys_nomodule }, /* 171 = unrumped */ 3462 #else 3463 { 0, 0, 0, 3464 (sy_call_t *)rump_enosys }, /* 171 = excluded 1.0 shmsys */ 3465 #endif 3466 { 0, 0, 0, 3467 (sy_call_t *)rump_enosys }, /* 172 = unimplemented */ 3468 { ns(struct sys_pread_args), 0, 3469 (sy_call_t *)sys_pread }, /* 173 = pread */ 3470 { ns(struct sys_pwrite_args), 0, 3471 (sy_call_t *)sys_pwrite }, /* 174 = pwrite */ 3472 { 0, 0, 0, 3473 (sy_call_t *)rump_enosys }, /* 175 = unrumped */ 3474 #if defined(NTP) || !defined(_KERNEL_OPT) 3475 { 0, 0, 0, 3476 (sy_call_t *)rump_enosys }, /* 176 = unrumped */ 3477 #else 3478 { 0, 0, 0, 3479 (sy_call_t *)rump_enosys }, /* 176 = excluded ntp_adjtime */ 3480 #endif 3481 { 0, 0, 0, 3482 (sy_call_t *)rump_enosys }, /* 177 = unimplemented */ 3483 { 0, 0, 0, 3484 (sy_call_t *)rump_enosys }, /* 178 = unimplemented */ 3485 { 0, 0, 0, 3486 (sy_call_t *)rump_enosys }, /* 179 = unimplemented */ 3487 { 0, 0, 0, 3488 (sy_call_t *)rump_enosys }, /* 180 = unimplemented */ 3489 { ns(struct sys_setgid_args), 0, 3490 (sy_call_t *)sys_setgid }, /* 181 = setgid */ 3491 { ns(struct sys_setegid_args), 0, 3492 (sy_call_t *)sys_setegid }, /* 182 = setegid */ 3493 { ns(struct sys_seteuid_args), 0, 3494 (sy_call_t *)sys_seteuid }, /* 183 = seteuid */ 3495 { 0, 0, 0, 3496 (sy_call_t *)sys_nomodule }, /* 184 = unrumped */ 3497 { 0, 0, 0, 3498 (sy_call_t *)sys_nomodule }, /* 185 = unrumped */ 3499 { 0, 0, 0, 3500 (sy_call_t *)sys_nomodule }, /* 186 = unrumped */ 3501 { 0, 0, 0, 3502 (sy_call_t *)sys_nomodule }, /* 187 = unrumped */ 3503 { 0, 0, 0, 3504 (sy_call_t *)sys_nomodule }, /* 188 = unrumped */ 3505 { 0, 0, 0, 3506 (sy_call_t *)sys_nomodule }, /* 189 = unrumped */ 3507 { 0, 0, 0, 3508 (sy_call_t *)sys_nomodule }, /* 190 = unrumped */ 3509 { ns(struct sys_pathconf_args), 0, 3510 (sy_call_t *)sys_pathconf }, /* 191 = pathconf */ 3511 { ns(struct sys_fpathconf_args), 0, 3512 (sy_call_t *)sys_fpathconf }, /* 192 = fpathconf */ 3513 { 0, 0, 0, 3514 (sy_call_t *)rump_enosys }, /* 193 = unimplemented */ 3515 { ns(struct sys_getrlimit_args), 0, 3516 (sy_call_t *)sys_getrlimit }, /* 194 = getrlimit */ 3517 { ns(struct sys_setrlimit_args), 0, 3518 (sy_call_t *)sys_setrlimit }, /* 195 = setrlimit */ 3519 { 0, 0, 0, 3520 (sy_call_t *)sys_nomodule }, /* 196 = unrumped */ 3521 { 0, 0, 0, 3522 (sy_call_t *)rump_enosys }, /* 197 = unrumped */ 3523 { 0, 0, 0, 3524 (sy_call_t *)rump_enosys }, /* 198 = unrumped */ 3525 { ns(struct sys_lseek_args), 0, 3526 (sy_call_t *)sys_lseek }, /* 199 = lseek */ 3527 { ns(struct sys_truncate_args), 0, 3528 (sy_call_t *)sys_truncate }, /* 200 = truncate */ 3529 { ns(struct sys_ftruncate_args), 0, 3530 (sy_call_t *)sys_ftruncate }, /* 201 = ftruncate */ 3531 { ns(struct sys___sysctl_args), 0, 3532 (sy_call_t *)sys___sysctl }, /* 202 = __sysctl */ 3533 { 0, 0, 0, 3534 (sy_call_t *)rump_enosys }, /* 203 = unrumped */ 3535 { 0, 0, 0, 3536 (sy_call_t *)rump_enosys }, /* 204 = unrumped */ 3537 { 0, 0, 0, 3538 (sy_call_t *)rump_enosys }, /* 205 = unrumped */ 3539 { 0, 0, 0, 3540 (sy_call_t *)sys_nomodule }, /* 206 = unrumped */ 3541 { ns(struct sys_getpgid_args), 0, 3542 (sy_call_t *)sys_getpgid }, /* 207 = getpgid */ 3543 { ns(struct sys_reboot_args), 0, 3544 (sy_call_t *)sys_reboot }, /* 208 = reboot */ 3545 { ns(struct sys_poll_args), 0, 3546 (sy_call_t *)sys_poll }, /* 209 = poll */ 3547 { 0, 0, 0, 3548 (sy_call_t *)rump_enosys }, /* 210 = unimplemented */ 3549 { 0, 0, 0, 3550 (sy_call_t *)rump_enosys }, /* 211 = unimplemented */ 3551 { 0, 0, 0, 3552 (sy_call_t *)rump_enosys }, /* 212 = unimplemented */ 3553 { 0, 0, 0, 3554 (sy_call_t *)rump_enosys }, /* 213 = unimplemented */ 3555 { 0, 0, 0, 3556 (sy_call_t *)rump_enosys }, /* 214 = unimplemented */ 3557 { 0, 0, 0, 3558 (sy_call_t *)rump_enosys }, /* 215 = unimplemented */ 3559 { 0, 0, 0, 3560 (sy_call_t *)rump_enosys }, /* 216 = unimplemented */ 3561 { 0, 0, 0, 3562 (sy_call_t *)rump_enosys }, /* 217 = unimplemented */ 3563 { 0, 0, 0, 3564 (sy_call_t *)rump_enosys }, /* 218 = unimplemented */ 3565 { 0, 0, 0, 3566 (sy_call_t *)rump_enosys }, /* 219 = unimplemented */ 3567 #if defined(SYSVSEM) || !defined(_KERNEL_OPT) 3568 { 0, 0, 0, 3569 (sy_call_t *)sys_nomodule }, /* 220 = unrumped */ 3570 { 0, 0, 0, 3571 (sy_call_t *)rump_enosys }, /* 221 = unrumped */ 3572 { 0, 0, 0, 3573 (sy_call_t *)rump_enosys }, /* 222 = unrumped */ 3574 { 0, 0, 0, 3575 (sy_call_t *)rump_enosys }, /* 223 = unrumped */ 3576 #else 3577 { 0, 0, 0, 3578 (sy_call_t *)rump_enosys }, /* 220 = excluded compat_14_semctl */ 3579 { 0, 0, 0, 3580 (sy_call_t *)rump_enosys }, /* 221 = excluded semget */ 3581 { 0, 0, 0, 3582 (sy_call_t *)rump_enosys }, /* 222 = excluded semop */ 3583 { 0, 0, 0, 3584 (sy_call_t *)rump_enosys }, /* 223 = excluded semconfig */ 3585 #endif 3586 #if defined(SYSVMSG) || !defined(_KERNEL_OPT) 3587 { 0, 0, 0, 3588 (sy_call_t *)sys_nomodule }, /* 224 = unrumped */ 3589 { 0, 0, 0, 3590 (sy_call_t *)rump_enosys }, /* 225 = unrumped */ 3591 { 0, 0, 0, 3592 (sy_call_t *)rump_enosys }, /* 226 = unrumped */ 3593 { 0, 0, 0, 3594 (sy_call_t *)rump_enosys }, /* 227 = unrumped */ 3595 #else 3596 { 0, 0, 0, 3597 (sy_call_t *)rump_enosys }, /* 224 = excluded compat_14_msgctl */ 3598 { 0, 0, 0, 3599 (sy_call_t *)rump_enosys }, /* 225 = excluded msgget */ 3600 { 0, 0, 0, 3601 (sy_call_t *)rump_enosys }, /* 226 = excluded msgsnd */ 3602 { 0, 0, 0, 3603 (sy_call_t *)rump_enosys }, /* 227 = excluded msgrcv */ 3604 #endif 3605 #if defined(SYSVSHM) || !defined(_KERNEL_OPT) 3606 { 0, 0, 0, 3607 (sy_call_t *)rump_enosys }, /* 228 = unrumped */ 3608 { 0, 0, 0, 3609 (sy_call_t *)sys_nomodule }, /* 229 = unrumped */ 3610 { 0, 0, 0, 3611 (sy_call_t *)rump_enosys }, /* 230 = unrumped */ 3612 { 0, 0, 0, 3613 (sy_call_t *)rump_enosys }, /* 231 = unrumped */ 3614 #else 3615 { 0, 0, 0, 3616 (sy_call_t *)rump_enosys }, /* 228 = excluded shmat */ 3617 { 0, 0, 0, 3618 (sy_call_t *)rump_enosys }, /* 229 = excluded compat_14_shmctl */ 3619 { 0, 0, 0, 3620 (sy_call_t *)rump_enosys }, /* 230 = excluded shmdt */ 3621 { 0, 0, 0, 3622 (sy_call_t *)rump_enosys }, /* 231 = excluded shmget */ 3623 #endif 3624 { 0, 0, 0, 3625 (sy_call_t *)sys_nomodule }, /* 232 = unrumped */ 3626 { 0, 0, 0, 3627 (sy_call_t *)sys_nomodule }, /* 233 = unrumped */ 3628 { 0, 0, 0, 3629 (sy_call_t *)sys_nomodule }, /* 234 = unrumped */ 3630 { 0, 0, 0, 3631 (sy_call_t *)rump_enosys }, /* 235 = unrumped */ 3632 { 0, 0, 0, 3633 (sy_call_t *)rump_enosys }, /* 236 = unrumped */ 3634 { 0, 0, 0, 3635 (sy_call_t *)sys_nomodule }, /* 237 = unrumped */ 3636 { 0, 0, 0, 3637 (sy_call_t *)sys_nomodule }, /* 238 = unrumped */ 3638 { 0, 0, 0, 3639 (sy_call_t *)rump_enosys }, /* 239 = unrumped */ 3640 { 0, 0, 0, 3641 (sy_call_t *)sys_nomodule }, /* 240 = unrumped */ 3642 { ns(struct sys_fdatasync_args), 0, 3643 (sy_call_t *)sys_fdatasync }, /* 241 = fdatasync */ 3644 { 0, 0, 0, 3645 (sy_call_t *)rump_enosys }, /* 242 = unrumped */ 3646 { 0, 0, 0, 3647 (sy_call_t *)rump_enosys }, /* 243 = unrumped */ 3648 { 0, 0, 0, 3649 (sy_call_t *)sys_nomodule }, /* 244 = unrumped */ 3650 { 0, 0, 0, 3651 (sy_call_t *)rump_enosys }, /* 245 = unimplemented sys_sigqueue */ 3652 { ns(struct sys_modctl_args), 0, 3653 (sy_call_t *)sys_modctl }, /* 246 = modctl */ 3654 { ns(struct sys__ksem_init_args), 0, 3655 (sy_call_t *)sys_nomodule }, /* 247 = _ksem_init */ 3656 { ns(struct sys__ksem_open_args), 0, 3657 (sy_call_t *)sys_nomodule }, /* 248 = _ksem_open */ 3658 { ns(struct sys__ksem_unlink_args), 0, 3659 (sy_call_t *)sys_nomodule }, /* 249 = _ksem_unlink */ 3660 { ns(struct sys__ksem_close_args), 0, 3661 (sy_call_t *)sys_nomodule }, /* 250 = _ksem_close */ 3662 { ns(struct sys__ksem_post_args), 0, 3663 (sy_call_t *)sys_nomodule }, /* 251 = _ksem_post */ 3664 { ns(struct sys__ksem_wait_args), 0, 3665 (sy_call_t *)sys_nomodule }, /* 252 = _ksem_wait */ 3666 { ns(struct sys__ksem_trywait_args), 0, 3667 (sy_call_t *)sys_nomodule }, /* 253 = _ksem_trywait */ 3668 { ns(struct sys__ksem_getvalue_args), 0, 3669 (sy_call_t *)sys_nomodule }, /* 254 = _ksem_getvalue */ 3670 { ns(struct sys__ksem_destroy_args), 0, 3671 (sy_call_t *)sys_nomodule }, /* 255 = _ksem_destroy */ 3672 { 0, 0, 0, 3673 (sy_call_t *)rump_enosys }, /* 256 = unimplemented sys__ksem_timedwait */ 3674 { 0, 0, 0, 3675 (sy_call_t *)sys_nomodule }, /* 257 = unrumped */ 3676 { 0, 0, 0, 3677 (sy_call_t *)sys_nomodule }, /* 258 = unrumped */ 3678 { 0, 0, 0, 3679 (sy_call_t *)sys_nomodule }, /* 259 = unrumped */ 3680 { 0, 0, 0, 3681 (sy_call_t *)sys_nomodule }, /* 260 = unrumped */ 3682 { 0, 0, 0, 3683 (sy_call_t *)sys_nomodule }, /* 261 = unrumped */ 3684 { 0, 0, 0, 3685 (sy_call_t *)sys_nomodule }, /* 262 = unrumped */ 3686 { 0, 0, 0, 3687 (sy_call_t *)sys_nomodule }, /* 263 = unrumped */ 3688 { 0, 0, 0, 3689 (sy_call_t *)sys_nomodule }, /* 264 = unrumped */ 3690 { 0, 0, 0, 3691 (sy_call_t *)sys_nomodule }, /* 265 = unrumped */ 3692 { 0, 0, 0, 3693 (sy_call_t *)sys_nomodule }, /* 266 = unrumped */ 3694 { 0, 0, 0, 3695 (sy_call_t *)rump_enosys }, /* 267 = unimplemented */ 3696 { 0, 0, 0, 3697 (sy_call_t *)rump_enosys }, /* 268 = unimplemented */ 3698 { 0, 0, 0, 3699 (sy_call_t *)rump_enosys }, /* 269 = unimplemented */ 3700 { 0, 0, 0, 3701 (sy_call_t *)rump_enosys }, /* 270 = unrumped */ 3702 { 0, 0, 0, 3703 (sy_call_t *)rump_enosys }, /* 271 = unrumped */ 3704 { 0, 0, 0, 3705 (sy_call_t *)sys_nomodule }, /* 272 = unrumped */ 3706 { 0, 0, 0, 3707 (sy_call_t *)rump_enosys }, /* 273 = unrumped */ 3708 { ns(struct sys_lchmod_args), 0, 3709 (sy_call_t *)sys_lchmod }, /* 274 = lchmod */ 3710 { ns(struct sys_lchown_args), 0, 3711 (sy_call_t *)sys_lchown }, /* 275 = lchown */ 3712 { 0, 0, 0, 3713 (sy_call_t *)sys_nomodule }, /* 276 = unrumped */ 3714 { 0, 0, 0, 3715 (sy_call_t *)rump_enosys }, /* 277 = unrumped */ 3716 { 0, 0, 0, 3717 (sy_call_t *)sys_nomodule }, /* 278 = unrumped */ 3718 { 0, 0, 0, 3719 (sy_call_t *)sys_nomodule }, /* 279 = unrumped */ 3720 { 0, 0, 0, 3721 (sy_call_t *)sys_nomodule }, /* 280 = unrumped */ 3722 { 0, 0, 0, 3723 (sy_call_t *)rump_enosys }, /* 281 = unrumped */ 3724 { 0, 0, 0, 3725 (sy_call_t *)rump_enosys }, /* 282 = unrumped */ 3726 { 0, 0, 0, 3727 (sy_call_t *)rump_enosys }, /* 283 = unrumped */ 3728 { 0, 0, 0, 3729 (sy_call_t *)rump_enosys }, /* 284 = unrumped */ 3730 { 0, 0, 0, 3731 (sy_call_t *)rump_enosys }, /* 285 = unrumped */ 3732 { ns(struct sys_getsid_args), 0, 3733 (sy_call_t *)sys_getsid }, /* 286 = getsid */ 3734 { 0, 0, 0, 3735 (sy_call_t *)rump_enosys }, /* 287 = unrumped */ 3736 { 0, 0, 0, 3737 (sy_call_t *)rump_enosys }, /* 288 = unrumped */ 3738 { 0, 0, 0, 3739 (sy_call_t *)rump_enosys }, /* 289 = unrumped */ 3740 { 0, 0, 0, 3741 (sy_call_t *)rump_enosys }, /* 290 = unrumped */ 3742 { 0, 0, 0, 3743 (sy_call_t *)sys_nomodule }, /* 291 = unrumped */ 3744 { 0, 0, 0, 3745 (sy_call_t *)rump_enosys }, /* 292 = unrumped */ 3746 { 0, 0, 0, 3747 (sy_call_t *)rump_enosys }, /* 293 = unrumped */ 3748 { 0, 0, 0, 3749 (sy_call_t *)rump_enosys }, /* 294 = unrumped */ 3750 { 0, 0, 0, 3751 (sy_call_t *)sys_nomodule }, /* 295 = unrumped */ 3752 { ns(struct sys___getcwd_args), 0, 3753 (sy_call_t *)sys___getcwd }, /* 296 = __getcwd */ 3754 { ns(struct sys_fchroot_args), 0, 3755 (sy_call_t *)sys_fchroot }, /* 297 = fchroot */ 3756 { 0, 0, 0, 3757 (sy_call_t *)sys_nomodule }, /* 298 = unrumped */ 3758 { 0, 0, 0, 3759 (sy_call_t *)sys_nomodule }, /* 299 = unrumped */ 3760 { 0, 0, 0, 3761 (sy_call_t *)sys_nomodule }, /* 300 = unrumped */ 3762 #if defined(SYSVSEM) || !defined(_KERNEL_OPT) 3763 { 0, 0, 0, 3764 (sy_call_t *)sys_nomodule }, /* 301 = unrumped */ 3765 #else 3766 { 0, 0, 0, 3767 (sy_call_t *)rump_enosys }, /* 301 = excluded ____semctl13 */ 3768 #endif 3769 #if defined(SYSVMSG) || !defined(_KERNEL_OPT) 3770 { 0, 0, 0, 3771 (sy_call_t *)sys_nomodule }, /* 302 = unrumped */ 3772 #else 3773 { 0, 0, 0, 3774 (sy_call_t *)rump_enosys }, /* 302 = excluded __msgctl13 */ 3775 #endif 3776 #if defined(SYSVSHM) || !defined(_KERNEL_OPT) 3777 { 0, 0, 0, 3778 (sy_call_t *)sys_nomodule }, /* 303 = unrumped */ 3779 #else 3780 { 0, 0, 0, 3781 (sy_call_t *)rump_enosys }, /* 303 = excluded __shmctl13 */ 3782 #endif 3783 { ns(struct sys_lchflags_args), 0, 3784 (sy_call_t *)sys_lchflags }, /* 304 = lchflags */ 3785 { 0, 0, 0, 3786 (sy_call_t *)sys_issetugid }, /* 305 = issetugid */ 3787 { 0, 0, 0, 3788 (sy_call_t *)rump_enosys }, /* 306 = unrumped */ 3789 { 0, 0, 0, 3790 (sy_call_t *)rump_enosys }, /* 307 = unrumped */ 3791 { 0, 0, 0, 3792 (sy_call_t *)rump_enosys }, /* 308 = unrumped */ 3793 { 0, 0, 0, 3794 (sy_call_t *)rump_enosys }, /* 309 = unrumped */ 3795 { 0, 0, 0, 3796 (sy_call_t *)rump_enosys }, /* 310 = unrumped */ 3797 { 0, 0, 0, 3798 (sy_call_t *)rump_enosys }, /* 311 = unrumped */ 3799 { 0, 0, 0, 3800 (sy_call_t *)rump_enosys }, /* 312 = unrumped */ 3801 { 0, 0, 0, 3802 (sy_call_t *)rump_enosys }, /* 313 = unrumped */ 3803 { 0, 0, 0, 3804 (sy_call_t *)rump_enosys }, /* 314 = unrumped */ 3805 { 0, 0, 0, 3806 (sy_call_t *)rump_enosys }, /* 315 = unrumped */ 3807 { 0, 0, 0, 3808 (sy_call_t *)rump_enosys }, /* 316 = unrumped */ 3809 { 0, 0, 0, 3810 (sy_call_t *)rump_enosys }, /* 317 = unrumped */ 3811 { 0, 0, 0, 3812 (sy_call_t *)rump_enosys }, /* 318 = unrumped */ 3813 { 0, 0, 0, 3814 (sy_call_t *)rump_enosys }, /* 319 = unrumped */ 3815 { 0, 0, 0, 3816 (sy_call_t *)sys_nomodule }, /* 320 = unrumped */ 3817 { 0, 0, 0, 3818 (sy_call_t *)rump_enosys }, /* 321 = unrumped */ 3819 { 0, 0, 0, 3820 (sy_call_t *)rump_enosys }, /* 322 = unrumped */ 3821 { 0, 0, 0, 3822 (sy_call_t *)rump_enosys }, /* 323 = unrumped */ 3823 { 0, 0, 0, 3824 (sy_call_t *)rump_enosys }, /* 324 = unrumped */ 3825 { 0, 0, 0, 3826 (sy_call_t *)rump_enosys }, /* 325 = unrumped */ 3827 { 0, 0, 0, 3828 (sy_call_t *)rump_enosys }, /* 326 = unimplemented */ 3829 { 0, 0, 0, 3830 (sy_call_t *)rump_enosys }, /* 327 = unimplemented */ 3831 { 0, 0, 0, 3832 (sy_call_t *)rump_enosys }, /* 328 = unimplemented */ 3833 { 0, 0, 0, 3834 (sy_call_t *)rump_enosys }, /* 329 = unimplemented */ 3835 { 0, 0, 0, 3836 (sy_call_t *)rump_enosys }, /* 330 = unrumped */ 3837 { 0, 0, 0, 3838 (sy_call_t *)rump_enosys }, /* 331 = unrumped */ 3839 { 0, 0, 0, 3840 (sy_call_t *)rump_enosys }, /* 332 = unrumped */ 3841 { 0, 0, 0, 3842 (sy_call_t *)rump_enosys }, /* 333 = unrumped */ 3843 { 0, 0, 0, 3844 (sy_call_t *)rump_enosys }, /* 334 = unrumped */ 3845 { 0, 0, 0, 3846 (sy_call_t *)rump_enosys }, /* 335 = unrumped */ 3847 { 0, 0, 0, 3848 (sy_call_t *)rump_enosys }, /* 336 = obsolete sys_sa_unblockyield */ 3849 { 0, 0, 0, 3850 (sy_call_t *)rump_enosys }, /* 337 = unimplemented */ 3851 { 0, 0, 0, 3852 (sy_call_t *)rump_enosys }, /* 338 = unimplemented */ 3853 { 0, 0, 0, 3854 (sy_call_t *)rump_enosys }, /* 339 = unimplemented */ 3855 { 0, 0, 0, 3856 (sy_call_t *)rump_enosys }, /* 340 = unrumped */ 3857 { 0, 0, 0, 3858 (sy_call_t *)rump_enosys }, /* 341 = unrumped */ 3859 { 0, 0, 0, 3860 (sy_call_t *)rump_enosys }, /* 342 = unrumped */ 3861 { 0, 0, 0, 3862 (sy_call_t *)rump_enosys }, /* 343 = unrumped */ 3863 { 0, 0, 0, 3864 (sy_call_t *)sys_kqueue }, /* 344 = kqueue */ 3865 { 0, 0, 0, 3866 (sy_call_t *)sys_nomodule }, /* 345 = unrumped */ 3867 { 0, 0, 0, 3868 (sy_call_t *)rump_enosys }, /* 346 = unrumped */ 3869 { 0, 0, 0, 3870 (sy_call_t *)rump_enosys }, /* 347 = unrumped */ 3871 { 0, 0, 0, 3872 (sy_call_t *)rump_enosys }, /* 348 = unrumped */ 3873 { 0, 0, 0, 3874 (sy_call_t *)rump_enosys }, /* 349 = unrumped */ 3875 { 0, 0, 0, 3876 (sy_call_t *)rump_enosys }, /* 350 = unrumped */ 3877 { 0, 0, 0, 3878 (sy_call_t *)rump_enosys }, /* 351 = unimplemented */ 3879 { 0, 0, 0, 3880 (sy_call_t *)rump_enosys }, /* 352 = unimplemented */ 3881 { 0, 0, 0, 3882 (sy_call_t *)rump_enosys }, /* 353 = unimplemented */ 3883 { ns(struct sys_fsync_range_args), 0, 3884 (sy_call_t *)sys_fsync_range }, /* 354 = fsync_range */ 3885 { 0, 0, 0, 3886 (sy_call_t *)rump_enosys }, /* 355 = unrumped */ 3887 { ns(struct sys_getvfsstat_args), 0, 3888 (sy_call_t *)sys_getvfsstat }, /* 356 = getvfsstat */ 3889 { ns(struct sys_statvfs1_args), 0, 3890 (sy_call_t *)sys_statvfs1 }, /* 357 = statvfs1 */ 3891 { ns(struct sys_fstatvfs1_args), 0, 3892 (sy_call_t *)sys_fstatvfs1 }, /* 358 = fstatvfs1 */ 3893 { 0, 0, 0, 3894 (sy_call_t *)sys_nomodule }, /* 359 = unrumped */ 3895 { ns(struct sys_extattrctl_args), 0, 3896 (sy_call_t *)sys_extattrctl }, /* 360 = extattrctl */ 3897 { ns(struct sys_extattr_set_file_args), 0, 3898 (sy_call_t *)sys_extattr_set_file }, /* 361 = extattr_set_file */ 3899 { ns(struct sys_extattr_get_file_args), 0, 3900 (sy_call_t *)sys_extattr_get_file }, /* 362 = extattr_get_file */ 3901 { ns(struct sys_extattr_delete_file_args), 0, 3902 (sy_call_t *)sys_extattr_delete_file }, /* 363 = extattr_delete_file */ 3903 { ns(struct sys_extattr_set_fd_args), 0, 3904 (sy_call_t *)sys_extattr_set_fd }, /* 364 = extattr_set_fd */ 3905 { ns(struct sys_extattr_get_fd_args), 0, 3906 (sy_call_t *)sys_extattr_get_fd }, /* 365 = extattr_get_fd */ 3907 { ns(struct sys_extattr_delete_fd_args), 0, 3908 (sy_call_t *)sys_extattr_delete_fd }, /* 366 = extattr_delete_fd */ 3909 { ns(struct sys_extattr_set_link_args), 0, 3910 (sy_call_t *)sys_extattr_set_link }, /* 367 = extattr_set_link */ 3911 { ns(struct sys_extattr_get_link_args), 0, 3912 (sy_call_t *)sys_extattr_get_link }, /* 368 = extattr_get_link */ 3913 { ns(struct sys_extattr_delete_link_args), 0, 3914 (sy_call_t *)sys_extattr_delete_link }, /* 369 = extattr_delete_link */ 3915 { ns(struct sys_extattr_list_fd_args), 0, 3916 (sy_call_t *)sys_extattr_list_fd }, /* 370 = extattr_list_fd */ 3917 { ns(struct sys_extattr_list_file_args), 0, 3918 (sy_call_t *)sys_extattr_list_file }, /* 371 = extattr_list_file */ 3919 { ns(struct sys_extattr_list_link_args), 0, 3920 (sy_call_t *)sys_extattr_list_link }, /* 372 = extattr_list_link */ 3921 { 0, 0, 0, 3922 (sy_call_t *)sys_nomodule }, /* 373 = unrumped */ 3923 { 0, 0, 0, 3924 (sy_call_t *)sys_nomodule }, /* 374 = unrumped */ 3925 { ns(struct sys_setxattr_args), 0, 3926 (sy_call_t *)sys_setxattr }, /* 375 = setxattr */ 3927 { ns(struct sys_lsetxattr_args), 0, 3928 (sy_call_t *)sys_lsetxattr }, /* 376 = lsetxattr */ 3929 { ns(struct sys_fsetxattr_args), 0, 3930 (sy_call_t *)sys_fsetxattr }, /* 377 = fsetxattr */ 3931 { ns(struct sys_getxattr_args), 0, 3932 (sy_call_t *)sys_getxattr }, /* 378 = getxattr */ 3933 { ns(struct sys_lgetxattr_args), 0, 3934 (sy_call_t *)sys_lgetxattr }, /* 379 = lgetxattr */ 3935 { ns(struct sys_fgetxattr_args), 0, 3936 (sy_call_t *)sys_fgetxattr }, /* 380 = fgetxattr */ 3937 { ns(struct sys_listxattr_args), 0, 3938 (sy_call_t *)sys_listxattr }, /* 381 = listxattr */ 3939 { ns(struct sys_llistxattr_args), 0, 3940 (sy_call_t *)sys_llistxattr }, /* 382 = llistxattr */ 3941 { ns(struct sys_flistxattr_args), 0, 3942 (sy_call_t *)sys_flistxattr }, /* 383 = flistxattr */ 3943 { ns(struct sys_removexattr_args), 0, 3944 (sy_call_t *)sys_removexattr }, /* 384 = removexattr */ 3945 { ns(struct sys_lremovexattr_args), 0, 3946 (sy_call_t *)sys_lremovexattr }, /* 385 = lremovexattr */ 3947 { ns(struct sys_fremovexattr_args), 0, 3948 (sy_call_t *)sys_fremovexattr }, /* 386 = fremovexattr */ 3949 { 0, 0, 0, 3950 (sy_call_t *)sys_nomodule }, /* 387 = unrumped */ 3951 { 0, 0, 0, 3952 (sy_call_t *)sys_nomodule }, /* 388 = unrumped */ 3953 { 0, 0, 0, 3954 (sy_call_t *)sys_nomodule }, /* 389 = unrumped */ 3955 { ns(struct sys___getdents30_args), 0, 3956 (sy_call_t *)sys___getdents30 }, /* 390 = __getdents30 */ 3957 { 0, 0, 0, 3958 (sy_call_t *)rump_enosys }, /* 391 = ignored old posix_fadvise */ 3959 { 0, 0, 0, 3960 (sy_call_t *)sys_nomodule }, /* 392 = unrumped */ 3961 { 0, 0, 0, 3962 (sy_call_t *)sys_nomodule }, /* 393 = unrumped */ 3963 { ns(struct sys___socket30_args), 0, 3964 (sy_call_t *)sys___socket30 }, /* 394 = __socket30 */ 3965 { ns(struct sys___getfh30_args), 0, 3966 (sy_call_t *)sys___getfh30 }, /* 395 = __getfh30 */ 3967 { ns(struct sys___fhopen40_args), 0, 3968 (sy_call_t *)sys___fhopen40 }, /* 396 = __fhopen40 */ 3969 { ns(struct sys___fhstatvfs140_args), 0, 3970 (sy_call_t *)sys___fhstatvfs140 }, /* 397 = __fhstatvfs140 */ 3971 { 0, 0, 0, 3972 (sy_call_t *)sys_nomodule }, /* 398 = unrumped */ 3973 { 0, 0, 0, 3974 (sy_call_t *)sys_nomodule }, /* 399 = unrumped */ 3975 { 0, 0, 0, 3976 (sy_call_t *)sys_nomodule }, /* 400 = unrumped */ 3977 { 0, 0, 0, 3978 (sy_call_t *)sys_nomodule }, /* 401 = unrumped */ 3979 { 0, 0, 0, 3980 (sy_call_t *)sys_nomodule }, /* 402 = unrumped */ 3981 { 0, 0, 0, 3982 (sy_call_t *)sys_nomodule }, /* 403 = unrumped */ 3983 { 0, 0, 0, 3984 (sy_call_t *)sys_nomodule }, /* 404 = unrumped */ 3985 { 0, 0, 0, 3986 (sy_call_t *)sys_nomodule }, /* 405 = unrumped */ 3987 { 0, 0, 0, 3988 (sy_call_t *)sys_nomodule }, /* 406 = unrumped */ 3989 { 0, 0, 0, 3990 (sy_call_t *)rump_enosys }, /* 407 = unimplemented */ 3991 { 0, 0, 0, 3992 (sy_call_t *)rump_enosys }, /* 408 = unimplemented */ 3993 { 0, 0, 0, 3994 (sy_call_t *)rump_enosys }, /* 409 = unimplemented */ 3995 { ns(struct sys___mount50_args), 0, 3996 (sy_call_t *)sys___mount50 }, /* 410 = __mount50 */ 3997 { 0, 0, 0, 3998 (sy_call_t *)rump_enosys }, /* 411 = unrumped */ 3999 { 0, 0, 0, 4000 (sy_call_t *)rump_enosys }, /* 412 = unrumped */ 4001 { 0, 0, 0, 4002 (sy_call_t *)rump_enosys }, /* 413 = unrumped */ 4003 { 0, 0, 0, 4004 (sy_call_t *)rump_enosys }, /* 414 = unrumped */ 4005 { 0, 0, 0, 4006 (sy_call_t *)rump_enosys }, /* 415 = unrumped */ 4007 { ns(struct sys___posix_fadvise50_args), 0, 4008 (sy_call_t *)sys___posix_fadvise50 }, /* 416 = __posix_fadvise50 */ 4009 { ns(struct sys___select50_args), 0, 4010 (sy_call_t *)sys___select50 }, /* 417 = __select50 */ 4011 { 0, 0, 0, 4012 (sy_call_t *)rump_enosys }, /* 418 = unrumped */ 4013 { 0, 0, 0, 4014 (sy_call_t *)rump_enosys }, /* 419 = unrumped */ 4015 { ns(struct sys___utimes50_args), 0, 4016 (sy_call_t *)sys___utimes50 }, /* 420 = __utimes50 */ 4017 { 0, 0, 0, 4018 (sy_call_t *)rump_enosys }, /* 421 = unrumped */ 4019 { 0, 0, 0, 4020 (sy_call_t *)sys_nomodule }, /* 422 = unrumped */ 4021 { ns(struct sys___futimes50_args), 0, 4022 (sy_call_t *)sys___futimes50 }, /* 423 = __futimes50 */ 4023 { ns(struct sys___lutimes50_args), 0, 4024 (sy_call_t *)sys___lutimes50 }, /* 424 = __lutimes50 */ 4025 { 0, 0, 0, 4026 (sy_call_t *)rump_enosys }, /* 425 = unrumped */ 4027 { 0, 0, 0, 4028 (sy_call_t *)rump_enosys }, /* 426 = unrumped */ 4029 { 0, 0, 0, 4030 (sy_call_t *)rump_enosys }, /* 427 = unrumped */ 4031 { 0, 0, 0, 4032 (sy_call_t *)rump_enosys }, /* 428 = unrumped */ 4033 { 0, 0, 0, 4034 (sy_call_t *)rump_enosys }, /* 429 = unrumped */ 4035 { 0, 0, 0, 4036 (sy_call_t *)rump_enosys }, /* 430 = unrumped */ 4037 { 0, 0, 0, 4038 (sy_call_t *)rump_enosys }, /* 431 = unrumped */ 4039 { 0, 0, 0, 4040 (sy_call_t *)sys_nomodule }, /* 432 = unrumped */ 4041 { 0, 0, 0, 4042 (sy_call_t *)sys_nomodule }, /* 433 = unrumped */ 4043 { 0, 0, 0, 4044 (sy_call_t *)rump_enosys }, /* 434 = unrumped */ 4045 { ns(struct sys___kevent50_args), 0, 4046 (sy_call_t *)sys___kevent50 }, /* 435 = __kevent50 */ 4047 { ns(struct sys___pselect50_args), 0, 4048 (sy_call_t *)sys___pselect50 }, /* 436 = __pselect50 */ 4049 { ns(struct sys___pollts50_args), 0, 4050 (sy_call_t *)sys___pollts50 }, /* 437 = __pollts50 */ 4051 { 0, 0, 0, 4052 (sy_call_t *)sys_nomodule }, /* 438 = unrumped */ 4053 { ns(struct sys___stat50_args), 0, 4054 (sy_call_t *)sys___stat50 }, /* 439 = __stat50 */ 4055 { ns(struct sys___fstat50_args), 0, 4056 (sy_call_t *)sys___fstat50 }, /* 440 = __fstat50 */ 4057 { ns(struct sys___lstat50_args), 0, 4058 (sy_call_t *)sys___lstat50 }, /* 441 = __lstat50 */ 4059 #if defined(SYSVSEM) || !defined(_KERNEL_OPT) 4060 { 0, 0, 0, 4061 (sy_call_t *)rump_enosys }, /* 442 = unrumped */ 4062 #else 4063 { 0, 0, 0, 4064 (sy_call_t *)rump_enosys }, /* 442 = excluded ____semctl50 */ 4065 #endif 4066 #if defined(SYSVSHM) || !defined(_KERNEL_OPT) 4067 { 0, 0, 0, 4068 (sy_call_t *)rump_enosys }, /* 443 = unrumped */ 4069 #else 4070 { 0, 0, 0, 4071 (sy_call_t *)rump_enosys }, /* 443 = excluded ____shmctl50 */ 4072 #endif 4073 #if defined(SYSVMSG) || !defined(_KERNEL_OPT) 4074 { 0, 0, 0, 4075 (sy_call_t *)rump_enosys }, /* 444 = unrumped */ 4076 #else 4077 { 0, 0, 0, 4078 (sy_call_t *)rump_enosys }, /* 444 = excluded ____msgctl50 */ 4079 #endif 4080 { 0, 0, 0, 4081 (sy_call_t *)rump_enosys }, /* 445 = unrumped */ 4082 { 0, 0, 0, 4083 (sy_call_t *)rump_enosys }, /* 446 = unrumped */ 4084 { 0, 0, 0, 4085 (sy_call_t *)rump_enosys }, /* 447 = unrumped */ 4086 #if defined(NTP) || !defined(_KERNEL_OPT) 4087 { 0, 0, 0, 4088 (sy_call_t *)rump_enosys }, /* 448 = unrumped */ 4089 #else 4090 { 0, 0, 0, 4091 (sy_call_t *)rump_enosys }, /* 448 = excluded ___ntp_gettime50 */ 4092 #endif 4093 { 0, 0, 0, 4094 (sy_call_t *)rump_enosys }, /* 449 = unrumped */ 4095 { ns(struct sys___mknod50_args), 0, 4096 (sy_call_t *)sys___mknod50 }, /* 450 = __mknod50 */ 4097 { ns(struct sys___fhstat50_args), 0, 4098 (sy_call_t *)sys___fhstat50 }, /* 451 = __fhstat50 */ 4099 { 0, 0, 0, 4100 (sy_call_t *)rump_enosys }, /* 452 = filler */ 4101 { 0, 0, 0, 4102 (sy_call_t *)rump_enosys }, /* 453 = filler */ 4103 { 0, 0, 0, 4104 (sy_call_t *)rump_enosys }, /* 454 = filler */ 4105 { 0, 0, 0, 4106 (sy_call_t *)rump_enosys }, /* 455 = filler */ 4107 { 0, 0, 0, 4108 (sy_call_t *)rump_enosys }, /* 456 = filler */ 4109 { 0, 0, 0, 4110 (sy_call_t *)rump_enosys }, /* 457 = filler */ 4111 { 0, 0, 0, 4112 (sy_call_t *)rump_enosys }, /* 458 = filler */ 4113 { 0, 0, 0, 4114 (sy_call_t *)rump_enosys }, /* 459 = filler */ 4115 { 0, 0, 0, 4116 (sy_call_t *)rump_enosys }, /* 460 = filler */ 4117 { 0, 0, 0, 4118 (sy_call_t *)rump_enosys }, /* 461 = filler */ 4119 { 0, 0, 0, 4120 (sy_call_t *)rump_enosys }, /* 462 = filler */ 4121 { 0, 0, 0, 4122 (sy_call_t *)rump_enosys }, /* 463 = filler */ 4123 { 0, 0, 0, 4124 (sy_call_t *)rump_enosys }, /* 464 = filler */ 4125 { 0, 0, 0, 4126 (sy_call_t *)rump_enosys }, /* 465 = filler */ 4127 { 0, 0, 0, 4128 (sy_call_t *)rump_enosys }, /* 466 = filler */ 4129 { 0, 0, 0, 4130 (sy_call_t *)rump_enosys }, /* 467 = filler */ 4131 { 0, 0, 0, 4132 (sy_call_t *)rump_enosys }, /* 468 = filler */ 4133 { 0, 0, 0, 4134 (sy_call_t *)rump_enosys }, /* 469 = filler */ 4135 { 0, 0, 0, 4136 (sy_call_t *)rump_enosys }, /* 470 = filler */ 4137 { 0, 0, 0, 4138 (sy_call_t *)rump_enosys }, /* 471 = filler */ 4139 { 0, 0, 0, 4140 (sy_call_t *)rump_enosys }, /* 472 = filler */ 4141 { 0, 0, 0, 4142 (sy_call_t *)rump_enosys }, /* 473 = filler */ 4143 { 0, 0, 0, 4144 (sy_call_t *)rump_enosys }, /* 474 = filler */ 4145 { 0, 0, 0, 4146 (sy_call_t *)rump_enosys }, /* 475 = filler */ 4147 { 0, 0, 0, 4148 (sy_call_t *)rump_enosys }, /* 476 = filler */ 4149 { 0, 0, 0, 4150 (sy_call_t *)rump_enosys }, /* 477 = filler */ 4151 { 0, 0, 0, 4152 (sy_call_t *)rump_enosys }, /* 478 = filler */ 4153 { 0, 0, 0, 4154 (sy_call_t *)rump_enosys }, /* 479 = filler */ 4155 { 0, 0, 0, 4156 (sy_call_t *)rump_enosys }, /* 480 = filler */ 4157 { 0, 0, 0, 4158 (sy_call_t *)rump_enosys }, /* 481 = filler */ 4159 { 0, 0, 0, 4160 (sy_call_t *)rump_enosys }, /* 482 = filler */ 4161 { 0, 0, 0, 4162 (sy_call_t *)rump_enosys }, /* 483 = filler */ 4163 { 0, 0, 0, 4164 (sy_call_t *)rump_enosys }, /* 484 = filler */ 4165 { 0, 0, 0, 4166 (sy_call_t *)rump_enosys }, /* 485 = filler */ 4167 { 0, 0, 0, 4168 (sy_call_t *)rump_enosys }, /* 486 = filler */ 4169 { 0, 0, 0, 4170 (sy_call_t *)rump_enosys }, /* 487 = filler */ 4171 { 0, 0, 0, 4172 (sy_call_t *)rump_enosys }, /* 488 = filler */ 4173 { 0, 0, 0, 4174 (sy_call_t *)rump_enosys }, /* 489 = filler */ 4175 { 0, 0, 0, 4176 (sy_call_t *)rump_enosys }, /* 490 = filler */ 4177 { 0, 0, 0, 4178 (sy_call_t *)rump_enosys }, /* 491 = filler */ 4179 { 0, 0, 0, 4180 (sy_call_t *)rump_enosys }, /* 492 = filler */ 4181 { 0, 0, 0, 4182 (sy_call_t *)rump_enosys }, /* 493 = filler */ 4183 { 0, 0, 0, 4184 (sy_call_t *)rump_enosys }, /* 494 = filler */ 4185 { 0, 0, 0, 4186 (sy_call_t *)rump_enosys }, /* 495 = filler */ 4187 { 0, 0, 0, 4188 (sy_call_t *)rump_enosys }, /* 496 = filler */ 4189 { 0, 0, 0, 4190 (sy_call_t *)rump_enosys }, /* 497 = filler */ 4191 { 0, 0, 0, 4192 (sy_call_t *)rump_enosys }, /* 498 = filler */ 4193 { 0, 0, 0, 4194 (sy_call_t *)rump_enosys }, /* 499 = filler */ 4195 { 0, 0, 0, 4196 (sy_call_t *)rump_enosys }, /* 500 = filler */ 4197 { 0, 0, 0, 4198 (sy_call_t *)rump_enosys }, /* 501 = filler */ 4199 { 0, 0, 0, 4200 (sy_call_t *)rump_enosys }, /* 502 = filler */ 4201 { 0, 0, 0, 4202 (sy_call_t *)rump_enosys }, /* 503 = filler */ 4203 { 0, 0, 0, 4204 (sy_call_t *)rump_enosys }, /* 504 = filler */ 4205 { 0, 0, 0, 4206 (sy_call_t *)rump_enosys }, /* 505 = filler */ 4207 { 0, 0, 0, 4208 (sy_call_t *)rump_enosys }, /* 506 = filler */ 4209 { 0, 0, 0, 4210 (sy_call_t *)rump_enosys }, /* 507 = filler */ 4211 { 0, 0, 0, 4212 (sy_call_t *)rump_enosys }, /* 508 = filler */ 4213 { 0, 0, 0, 4214 (sy_call_t *)rump_enosys }, /* 509 = filler */ 4215 { 0, 0, 0, 4216 (sy_call_t *)rump_enosys }, /* 510 = filler */ 4217 { 0, 0, 0, 4218 (sy_call_t *)rump_enosys }, /* 511 = filler */ 4219 }; 4220 CTASSERT(__arraycount(rump_sysent) == SYS_NSYSENT); 4221 #endif /* RUMP_CLIENT */ 4222
Indexes created Wed Oct 01 12:09:54 GMT 2025