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