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