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