rump_syscalls.c revision 1.35
1 /* $NetBSD: rump_syscalls.c,v 1.35 2009/05/15 15:52:46 pooka Exp $ */ 2 3 /* 4 * System call vector and marshalling for rump. 5 * 6 * DO NOT EDIT-- this file is automatically generated. 7 * created from NetBSD: syscalls.master,v 1.227 2009/05/15 15:51:27 pooka Exp 8 */ 9 10 #include <sys/cdefs.h> 11 __KERNEL_RCSID(0, "$NetBSD: rump_syscalls.c,v 1.35 2009/05/15 15:52:46 pooka 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___mount50(const char *, const char *, int, void *, size_t); 2094 int 2095 rump_sys___mount50(const char * type, const char * path, int flags, void * data, size_t data_len) 2096 { 2097 register_t retval = 0; 2098 int error = 0; 2099 struct sys___mount50_args callarg; 2100 2101 SPARG(&callarg, type) = type; 2102 SPARG(&callarg, path) = path; 2103 SPARG(&callarg, flags) = flags; 2104 SPARG(&callarg, data) = data; 2105 SPARG(&callarg, data_len) = data_len; 2106 2107 error = rump_sysproxy(SYS___mount50, rump_sysproxy_arg, 2108 (uint8_t *)&callarg, sizeof(callarg), &retval); 2109 if (error) { 2110 retval = -1; 2111 rumpuser_seterrno(error); 2112 } 2113 return retval; 2114 } 2115 __weak_alias(sys___mount50,rump_enosys); 2116 2117 int rump_sys___select50(int, fd_set *, fd_set *, fd_set *, struct timeval *); 2118 int 2119 rump_sys___select50(int nd, fd_set * in, fd_set * ou, fd_set * ex, struct timeval * tv) 2120 { 2121 register_t retval = 0; 2122 int error = 0; 2123 struct sys___select50_args callarg; 2124 2125 SPARG(&callarg, nd) = nd; 2126 SPARG(&callarg, in) = in; 2127 SPARG(&callarg, ou) = ou; 2128 SPARG(&callarg, ex) = ex; 2129 SPARG(&callarg, tv) = tv; 2130 2131 error = rump_sysproxy(SYS___select50, rump_sysproxy_arg, 2132 (uint8_t *)&callarg, sizeof(callarg), &retval); 2133 if (error) { 2134 retval = -1; 2135 rumpuser_seterrno(error); 2136 } 2137 return retval; 2138 } 2139 __weak_alias(sys___select50,rump_enosys); 2140 2141 int rump_sys___utimes50(const char *, const struct timeval *); 2142 int 2143 rump_sys___utimes50(const char * path, const struct timeval * tptr) 2144 { 2145 register_t retval = 0; 2146 int error = 0; 2147 struct sys___utimes50_args callarg; 2148 2149 SPARG(&callarg, path) = path; 2150 SPARG(&callarg, tptr) = tptr; 2151 2152 error = rump_sysproxy(SYS___utimes50, 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___utimes50,rump_enosys); 2161 2162 int rump_sys___futimes50(int, const struct timeval *); 2163 int 2164 rump_sys___futimes50(int fd, const struct timeval * tptr) 2165 { 2166 register_t retval = 0; 2167 int error = 0; 2168 struct sys___futimes50_args callarg; 2169 2170 SPARG(&callarg, fd) = fd; 2171 SPARG(&callarg, tptr) = tptr; 2172 2173 error = rump_sysproxy(SYS___futimes50, rump_sysproxy_arg, 2174 (uint8_t *)&callarg, sizeof(callarg), &retval); 2175 if (error) { 2176 retval = -1; 2177 rumpuser_seterrno(error); 2178 } 2179 return retval; 2180 } 2181 __weak_alias(sys___futimes50,rump_enosys); 2182 2183 int rump_sys___lutimes50(const char *, const struct timeval *); 2184 int 2185 rump_sys___lutimes50(const char * path, const struct timeval * tptr) 2186 { 2187 register_t retval = 0; 2188 int error = 0; 2189 struct sys___lutimes50_args callarg; 2190 2191 SPARG(&callarg, path) = path; 2192 SPARG(&callarg, tptr) = tptr; 2193 2194 error = rump_sysproxy(SYS___lutimes50, rump_sysproxy_arg, 2195 (uint8_t *)&callarg, sizeof(callarg), &retval); 2196 if (error) { 2197 retval = -1; 2198 rumpuser_seterrno(error); 2199 } 2200 return retval; 2201 } 2202 __weak_alias(sys___lutimes50,rump_enosys); 2203 2204 int rump_sys___kevent50(int, const struct kevent *, size_t, struct kevent *, size_t, const struct timespec *); 2205 int 2206 rump_sys___kevent50(int fd, const struct kevent * changelist, size_t nchanges, struct kevent * eventlist, size_t nevents, const struct timespec * timeout) 2207 { 2208 register_t retval = 0; 2209 int error = 0; 2210 struct sys___kevent50_args callarg; 2211 2212 SPARG(&callarg, fd) = fd; 2213 SPARG(&callarg, changelist) = changelist; 2214 SPARG(&callarg, nchanges) = nchanges; 2215 SPARG(&callarg, eventlist) = eventlist; 2216 SPARG(&callarg, nevents) = nevents; 2217 SPARG(&callarg, timeout) = timeout; 2218 2219 error = rump_sysproxy(SYS___kevent50, rump_sysproxy_arg, 2220 (uint8_t *)&callarg, sizeof(callarg), &retval); 2221 if (error) { 2222 retval = -1; 2223 rumpuser_seterrno(error); 2224 } 2225 return retval; 2226 } 2227 __weak_alias(sys___kevent50,rump_enosys); 2228 2229 int rump_sys___pselect50(int, fd_set *, fd_set *, fd_set *, const struct timespec *, const sigset_t *); 2230 int 2231 rump_sys___pselect50(int nd, fd_set * in, fd_set * ou, fd_set * ex, const struct timespec * ts, const sigset_t * mask) 2232 { 2233 register_t retval = 0; 2234 int error = 0; 2235 struct sys___pselect50_args callarg; 2236 2237 SPARG(&callarg, nd) = nd; 2238 SPARG(&callarg, in) = in; 2239 SPARG(&callarg, ou) = ou; 2240 SPARG(&callarg, ex) = ex; 2241 SPARG(&callarg, ts) = ts; 2242 SPARG(&callarg, mask) = mask; 2243 2244 error = rump_sysproxy(SYS___pselect50, rump_sysproxy_arg, 2245 (uint8_t *)&callarg, sizeof(callarg), &retval); 2246 if (error) { 2247 retval = -1; 2248 rumpuser_seterrno(error); 2249 } 2250 return retval; 2251 } 2252 __weak_alias(sys___pselect50,rump_enosys); 2253 2254 int rump_sys___pollts50(struct pollfd *, u_int, const struct timespec *, const sigset_t *); 2255 int 2256 rump_sys___pollts50(struct pollfd * fds, u_int nfds, const struct timespec * ts, const sigset_t * mask) 2257 { 2258 register_t retval = 0; 2259 int error = 0; 2260 struct sys___pollts50_args callarg; 2261 2262 SPARG(&callarg, fds) = fds; 2263 SPARG(&callarg, nfds) = nfds; 2264 SPARG(&callarg, ts) = ts; 2265 SPARG(&callarg, mask) = mask; 2266 2267 error = rump_sysproxy(SYS___pollts50, rump_sysproxy_arg, 2268 (uint8_t *)&callarg, sizeof(callarg), &retval); 2269 if (error) { 2270 retval = -1; 2271 rumpuser_seterrno(error); 2272 } 2273 return retval; 2274 } 2275 __weak_alias(sys___pollts50,rump_enosys); 2276 2277 int rump_sys___stat50(const char *, struct stat *); 2278 int 2279 rump_sys___stat50(const char * path, struct stat * ub) 2280 { 2281 register_t retval = 0; 2282 int error = 0; 2283 struct sys___stat50_args callarg; 2284 2285 SPARG(&callarg, path) = path; 2286 SPARG(&callarg, ub) = ub; 2287 2288 error = rump_sysproxy(SYS___stat50, rump_sysproxy_arg, 2289 (uint8_t *)&callarg, sizeof(callarg), &retval); 2290 if (error) { 2291 retval = -1; 2292 rumpuser_seterrno(error); 2293 } 2294 return retval; 2295 } 2296 __weak_alias(sys___stat50,rump_enosys); 2297 2298 int rump_sys___fstat50(int, struct stat *); 2299 int 2300 rump_sys___fstat50(int fd, struct stat * sb) 2301 { 2302 register_t retval = 0; 2303 int error = 0; 2304 struct sys___fstat50_args callarg; 2305 2306 SPARG(&callarg, fd) = fd; 2307 SPARG(&callarg, sb) = sb; 2308 2309 error = rump_sysproxy(SYS___fstat50, rump_sysproxy_arg, 2310 (uint8_t *)&callarg, sizeof(callarg), &retval); 2311 if (error) { 2312 retval = -1; 2313 rumpuser_seterrno(error); 2314 } 2315 return retval; 2316 } 2317 __weak_alias(sys___fstat50,rump_enosys); 2318 2319 int rump_sys___lstat50(const char *, struct stat *); 2320 int 2321 rump_sys___lstat50(const char * path, struct stat * ub) 2322 { 2323 register_t retval = 0; 2324 int error = 0; 2325 struct sys___lstat50_args callarg; 2326 2327 SPARG(&callarg, path) = path; 2328 SPARG(&callarg, ub) = ub; 2329 2330 error = rump_sysproxy(SYS___lstat50, rump_sysproxy_arg, 2331 (uint8_t *)&callarg, sizeof(callarg), &retval); 2332 if (error) { 2333 retval = -1; 2334 rumpuser_seterrno(error); 2335 } 2336 return retval; 2337 } 2338 __weak_alias(sys___lstat50,rump_enosys); 2339 2340 int rump_sys___mknod50(const char *, mode_t, dev_t); 2341 int 2342 rump_sys___mknod50(const char * path, mode_t mode, dev_t dev) 2343 { 2344 register_t retval = 0; 2345 int error = 0; 2346 struct sys___mknod50_args callarg; 2347 2348 SPARG(&callarg, path) = path; 2349 SPARG(&callarg, mode) = mode; 2350 SPARG(&callarg, dev) = dev; 2351 2352 error = rump_sysproxy(SYS___mknod50, rump_sysproxy_arg, 2353 (uint8_t *)&callarg, sizeof(callarg), &retval); 2354 if (error) { 2355 retval = -1; 2356 rumpuser_seterrno(error); 2357 } 2358 return retval; 2359 } 2360 __weak_alias(sys___mknod50,rump_enosys); 2361 2362 int rump_sys___fhstat50(const void *, size_t, struct stat *); 2363 int 2364 rump_sys___fhstat50(const void * fhp, size_t fh_size, struct stat * sb) 2365 { 2366 register_t retval = 0; 2367 int error = 0; 2368 struct sys___fhstat50_args callarg; 2369 2370 SPARG(&callarg, fhp) = fhp; 2371 SPARG(&callarg, fh_size) = fh_size; 2372 SPARG(&callarg, sb) = sb; 2373 2374 error = rump_sysproxy(SYS___fhstat50, rump_sysproxy_arg, 2375 (uint8_t *)&callarg, sizeof(callarg), &retval); 2376 if (error) { 2377 retval = -1; 2378 rumpuser_seterrno(error); 2379 } 2380 return retval; 2381 } 2382 __weak_alias(sys___fhstat50,rump_enosys); 2383 2384 #define s(type) sizeof(type) 2385 #define n(type) (sizeof(type)/sizeof (register_t)) 2386 #define ns(type) n(type), s(type) 2387 2388 struct sysent rump_sysent[] = { 2389 { 0, 0, 0, 2390 (sy_call_t *)rump_enosys }, /* 0 = unrumped */ 2391 { 0, 0, 0, 2392 (sy_call_t *)rump_enosys }, /* 1 = unrumped */ 2393 { 0, 0, 0, 2394 (sy_call_t *)rump_enosys }, /* 2 = unrumped */ 2395 { ns(struct sys_read_args), 0, 2396 (sy_call_t *)sys_read }, /* 3 = read */ 2397 { ns(struct sys_write_args), 0, 2398 (sy_call_t *)sys_write }, /* 4 = write */ 2399 { ns(struct sys_open_args), 0, 2400 (sy_call_t *)sys_open }, /* 5 = open */ 2401 { ns(struct sys_close_args), 0, 2402 (sy_call_t *)sys_close }, /* 6 = close */ 2403 { 0, 0, 0, 2404 (sy_call_t *)rump_enosys }, /* 7 = unrumped */ 2405 { 0, 0, 0, 2406 (sy_call_t *)rump_enosys }, /* 8 = unrumped */ 2407 { ns(struct sys_link_args), 0, 2408 (sy_call_t *)sys_link }, /* 9 = link */ 2409 { ns(struct sys_unlink_args), 0, 2410 (sy_call_t *)sys_unlink }, /* 10 = unlink */ 2411 { 0, 0, 0, 2412 (sy_call_t *)rump_enosys }, /* 11 = obsolete execv */ 2413 { ns(struct sys_chdir_args), 0, 2414 (sy_call_t *)sys_chdir }, /* 12 = chdir */ 2415 { ns(struct sys_fchdir_args), 0, 2416 (sy_call_t *)sys_fchdir }, /* 13 = fchdir */ 2417 { 0, 0, 0, 2418 (sy_call_t *)rump_enosys }, /* 14 = unrumped */ 2419 { ns(struct sys_chmod_args), 0, 2420 (sy_call_t *)sys_chmod }, /* 15 = chmod */ 2421 { ns(struct sys_chown_args), 0, 2422 (sy_call_t *)sys_chown }, /* 16 = chown */ 2423 { 0, 0, 0, 2424 (sy_call_t *)rump_enosys }, /* 17 = unrumped */ 2425 { 0, 0, 0, 2426 (sy_call_t *)rump_enosys }, /* 18 = unrumped */ 2427 { 0, 0, 0, 2428 (sy_call_t *)rump_enosys }, /* 19 = unrumped */ 2429 { 0, 0, 0, 2430 (sy_call_t *)rump_enosys }, /* 20 = unrumped */ 2431 { 0, 0, 0, 2432 (sy_call_t *)rump_enosys }, /* 21 = unrumped */ 2433 { ns(struct sys_unmount_args), 0, 2434 (sy_call_t *)sys_unmount }, /* 22 = unmount */ 2435 { 0, 0, 0, 2436 (sy_call_t *)rump_enosys }, /* 23 = unrumped */ 2437 { 0, 0, 0, 2438 (sy_call_t *)rump_enosys }, /* 24 = unrumped */ 2439 { 0, 0, 0, 2440 (sy_call_t *)rump_enosys }, /* 25 = unrumped */ 2441 { 0, 0, 0, 2442 (sy_call_t *)rump_enosys }, /* 26 = unrumped */ 2443 { ns(struct sys_recvmsg_args), 0, 2444 (sy_call_t *)sys_recvmsg }, /* 27 = recvmsg */ 2445 { ns(struct sys_sendmsg_args), 0, 2446 (sy_call_t *)sys_sendmsg }, /* 28 = sendmsg */ 2447 { ns(struct sys_recvfrom_args), 0, 2448 (sy_call_t *)sys_recvfrom }, /* 29 = recvfrom */ 2449 { ns(struct sys_accept_args), 0, 2450 (sy_call_t *)sys_accept }, /* 30 = accept */ 2451 { ns(struct sys_getpeername_args), 0, 2452 (sy_call_t *)sys_getpeername }, /* 31 = getpeername */ 2453 { ns(struct sys_getsockname_args), 0, 2454 (sy_call_t *)sys_getsockname }, /* 32 = getsockname */ 2455 { ns(struct sys_access_args), 0, 2456 (sy_call_t *)sys_access }, /* 33 = access */ 2457 { ns(struct sys_chflags_args), 0, 2458 (sy_call_t *)sys_chflags }, /* 34 = chflags */ 2459 { ns(struct sys_fchflags_args), 0, 2460 (sy_call_t *)sys_fchflags }, /* 35 = fchflags */ 2461 { 0, 0, 0, 2462 (sy_call_t *)sys_sync }, /* 36 = sync */ 2463 { 0, 0, 0, 2464 (sy_call_t *)rump_enosys }, /* 37 = unrumped */ 2465 { 0, 0, 0, 2466 (sy_call_t *)rump_enosys }, /* 38 = unrumped */ 2467 { 0, 0, 0, 2468 (sy_call_t *)rump_enosys }, /* 39 = unrumped */ 2469 { 0, 0, 0, 2470 (sy_call_t *)rump_enosys }, /* 40 = unrumped */ 2471 { ns(struct sys_dup_args), 0, 2472 (sy_call_t *)sys_dup }, /* 41 = dup */ 2473 { 0, 0, 0, 2474 (sy_call_t *)rump_enosys }, /* 42 = unrumped */ 2475 { 0, 0, 0, 2476 (sy_call_t *)rump_enosys }, /* 43 = unrumped */ 2477 { 0, 0, 0, 2478 (sy_call_t *)rump_enosys }, /* 44 = unrumped */ 2479 { 0, 0, 0, 2480 (sy_call_t *)rump_enosys }, /* 45 = unrumped */ 2481 { 0, 0, 0, 2482 (sy_call_t *)rump_enosys }, /* 46 = unrumped */ 2483 { 0, 0, 0, 2484 (sy_call_t *)rump_enosys }, /* 47 = unrumped */ 2485 { 0, 0, 0, 2486 (sy_call_t *)rump_enosys }, /* 48 = unrumped */ 2487 { 0, 0, 0, 2488 (sy_call_t *)rump_enosys }, /* 49 = unrumped */ 2489 { 0, 0, 0, 2490 (sy_call_t *)rump_enosys }, /* 50 = unrumped */ 2491 { 0, 0, 0, 2492 (sy_call_t *)rump_enosys }, /* 51 = unrumped */ 2493 { 0, 0, 0, 2494 (sy_call_t *)rump_enosys }, /* 52 = unrumped */ 2495 { 0, 0, 0, 2496 (sy_call_t *)rump_enosys }, /* 53 = unrumped */ 2497 { ns(struct sys_ioctl_args), 0, 2498 (sy_call_t *)sys_ioctl }, /* 54 = ioctl */ 2499 { 0, 0, 0, 2500 (sy_call_t *)rump_enosys }, /* 55 = unrumped */ 2501 { ns(struct sys_revoke_args), 0, 2502 (sy_call_t *)sys_revoke }, /* 56 = revoke */ 2503 { ns(struct sys_symlink_args), 0, 2504 (sy_call_t *)sys_symlink }, /* 57 = symlink */ 2505 { ns(struct sys_readlink_args), 0, 2506 (sy_call_t *)sys_readlink }, /* 58 = readlink */ 2507 { 0, 0, 0, 2508 (sy_call_t *)rump_enosys }, /* 59 = unrumped */ 2509 { 0, 0, 0, 2510 (sy_call_t *)rump_enosys }, /* 60 = unrumped */ 2511 { ns(struct sys_chroot_args), 0, 2512 (sy_call_t *)sys_chroot }, /* 61 = chroot */ 2513 { 0, 0, 0, 2514 (sy_call_t *)rump_enosys }, /* 62 = unrumped */ 2515 { 0, 0, 0, 2516 (sy_call_t *)rump_enosys }, /* 63 = unrumped */ 2517 { 0, 0, 0, 2518 (sy_call_t *)rump_enosys }, /* 64 = unrumped */ 2519 { 0, 0, 0, 2520 (sy_call_t *)rump_enosys }, /* 65 = unrumped */ 2521 { 0, 0, 0, 2522 (sy_call_t *)rump_enosys }, /* 66 = unrumped */ 2523 { 0, 0, 0, 2524 (sy_call_t *)rump_enosys }, /* 67 = obsolete vread */ 2525 { 0, 0, 0, 2526 (sy_call_t *)rump_enosys }, /* 68 = obsolete vwrite */ 2527 { 0, 0, 0, 2528 (sy_call_t *)rump_enosys }, /* 69 = unrumped */ 2529 { 0, 0, 0, 2530 (sy_call_t *)rump_enosys }, /* 70 = unrumped */ 2531 { 0, 0, 0, 2532 (sy_call_t *)rump_enosys }, /* 71 = unrumped */ 2533 { 0, 0, 0, 2534 (sy_call_t *)rump_enosys }, /* 72 = unrumped */ 2535 { 0, 0, 0, 2536 (sy_call_t *)rump_enosys }, /* 73 = unrumped */ 2537 { 0, 0, 0, 2538 (sy_call_t *)rump_enosys }, /* 74 = unrumped */ 2539 { 0, 0, 0, 2540 (sy_call_t *)rump_enosys }, /* 75 = unrumped */ 2541 { 0, 0, 0, 2542 (sy_call_t *)rump_enosys }, /* 76 = obsolete vhangup */ 2543 { 0, 0, 0, 2544 (sy_call_t *)rump_enosys }, /* 77 = obsolete vlimit */ 2545 { 0, 0, 0, 2546 (sy_call_t *)rump_enosys }, /* 78 = unrumped */ 2547 { 0, 0, 0, 2548 (sy_call_t *)rump_enosys }, /* 79 = unrumped */ 2549 { 0, 0, 0, 2550 (sy_call_t *)rump_enosys }, /* 80 = unrumped */ 2551 { 0, 0, 0, 2552 (sy_call_t *)rump_enosys }, /* 81 = unrumped */ 2553 { 0, 0, 0, 2554 (sy_call_t *)rump_enosys }, /* 82 = unrumped */ 2555 { 0, 0, 0, 2556 (sy_call_t *)rump_enosys }, /* 83 = unrumped */ 2557 { 0, 0, 0, 2558 (sy_call_t *)rump_enosys }, /* 84 = unrumped */ 2559 { 0, 0, 0, 2560 (sy_call_t *)rump_enosys }, /* 85 = unrumped */ 2561 { 0, 0, 0, 2562 (sy_call_t *)rump_enosys }, /* 86 = unrumped */ 2563 { 0, 0, 0, 2564 (sy_call_t *)rump_enosys }, /* 87 = unrumped */ 2565 { 0, 0, 0, 2566 (sy_call_t *)rump_enosys }, /* 88 = unrumped */ 2567 { 0, 0, 0, 2568 (sy_call_t *)rump_enosys }, /* 89 = unrumped */ 2569 { ns(struct sys_dup2_args), 0, 2570 (sy_call_t *)sys_dup2 }, /* 90 = dup2 */ 2571 { 0, 0, 0, 2572 (sy_call_t *)rump_enosys }, /* 91 = unimplemented getdopt */ 2573 { ns(struct sys_fcntl_args), 0, 2574 (sy_call_t *)sys_fcntl }, /* 92 = fcntl */ 2575 { 0, 0, 0, 2576 (sy_call_t *)rump_enosys }, /* 93 = unrumped */ 2577 { 0, 0, 0, 2578 (sy_call_t *)rump_enosys }, /* 94 = unimplemented setdopt */ 2579 { ns(struct sys_fsync_args), 0, 2580 (sy_call_t *)sys_fsync }, /* 95 = fsync */ 2581 { 0, 0, 0, 2582 (sy_call_t *)rump_enosys }, /* 96 = unrumped */ 2583 { 0, 0, 0, 2584 (sy_call_t *)rump_enosys }, /* 97 = unrumped */ 2585 { ns(struct sys_connect_args), 0, 2586 (sy_call_t *)sys_connect }, /* 98 = connect */ 2587 { 0, 0, 0, 2588 (sy_call_t *)rump_enosys }, /* 99 = unrumped */ 2589 { 0, 0, 0, 2590 (sy_call_t *)rump_enosys }, /* 100 = unrumped */ 2591 { 0, 0, 0, 2592 (sy_call_t *)rump_enosys }, /* 101 = unrumped */ 2593 { 0, 0, 0, 2594 (sy_call_t *)rump_enosys }, /* 102 = unrumped */ 2595 { 0, 0, 0, 2596 (sy_call_t *)rump_enosys }, /* 103 = unrumped */ 2597 { ns(struct sys_bind_args), 0, 2598 (sy_call_t *)sys_bind }, /* 104 = bind */ 2599 { ns(struct sys_setsockopt_args), 0, 2600 (sy_call_t *)sys_setsockopt }, /* 105 = setsockopt */ 2601 { ns(struct sys_listen_args), 0, 2602 (sy_call_t *)sys_listen }, /* 106 = listen */ 2603 { 0, 0, 0, 2604 (sy_call_t *)rump_enosys }, /* 107 = obsolete vtimes */ 2605 { 0, 0, 0, 2606 (sy_call_t *)rump_enosys }, /* 108 = unrumped */ 2607 { 0, 0, 0, 2608 (sy_call_t *)rump_enosys }, /* 109 = unrumped */ 2609 { 0, 0, 0, 2610 (sy_call_t *)rump_enosys }, /* 110 = unrumped */ 2611 { 0, 0, 0, 2612 (sy_call_t *)rump_enosys }, /* 111 = unrumped */ 2613 { 0, 0, 0, 2614 (sy_call_t *)rump_enosys }, /* 112 = unrumped */ 2615 { 0, 0, 0, 2616 (sy_call_t *)rump_enosys }, /* 113 = unrumped */ 2617 { 0, 0, 0, 2618 (sy_call_t *)rump_enosys }, /* 114 = unrumped */ 2619 { 0, 0, 0, 2620 (sy_call_t *)rump_enosys }, /* 115 = obsolete vtrace */ 2621 { 0, 0, 0, 2622 (sy_call_t *)rump_enosys }, /* 116 = unrumped */ 2623 { 0, 0, 0, 2624 (sy_call_t *)rump_enosys }, /* 117 = unrumped */ 2625 { ns(struct sys_getsockopt_args), 0, 2626 (sy_call_t *)sys_getsockopt }, /* 118 = getsockopt */ 2627 { 0, 0, 0, 2628 (sy_call_t *)rump_enosys }, /* 119 = obsolete resuba */ 2629 { ns(struct sys_readv_args), 0, 2630 (sy_call_t *)sys_readv }, /* 120 = readv */ 2631 { ns(struct sys_writev_args), 0, 2632 (sy_call_t *)sys_writev }, /* 121 = writev */ 2633 { 0, 0, 0, 2634 (sy_call_t *)rump_enosys }, /* 122 = unrumped */ 2635 { ns(struct sys_fchown_args), 0, 2636 (sy_call_t *)sys_fchown }, /* 123 = fchown */ 2637 { ns(struct sys_fchmod_args), 0, 2638 (sy_call_t *)sys_fchmod }, /* 124 = fchmod */ 2639 { 0, 0, 0, 2640 (sy_call_t *)rump_enosys }, /* 125 = unrumped */ 2641 { 0, 0, 0, 2642 (sy_call_t *)rump_enosys }, /* 126 = unrumped */ 2643 { 0, 0, 0, 2644 (sy_call_t *)rump_enosys }, /* 127 = unrumped */ 2645 { ns(struct sys_rename_args), 0, 2646 (sy_call_t *)sys_rename }, /* 128 = rename */ 2647 { 0, 0, 0, 2648 (sy_call_t *)rump_enosys }, /* 129 = unrumped */ 2649 { 0, 0, 0, 2650 (sy_call_t *)rump_enosys }, /* 130 = unrumped */ 2651 { ns(struct sys_flock_args), 0, 2652 (sy_call_t *)sys_flock }, /* 131 = flock */ 2653 { ns(struct sys_mkfifo_args), 0, 2654 (sy_call_t *)sys_mkfifo }, /* 132 = mkfifo */ 2655 { ns(struct sys_sendto_args), 0, 2656 (sy_call_t *)sys_sendto }, /* 133 = sendto */ 2657 { ns(struct sys_shutdown_args), 0, 2658 (sy_call_t *)sys_shutdown }, /* 134 = shutdown */ 2659 { ns(struct sys_socketpair_args), 0, 2660 (sy_call_t *)sys_socketpair }, /* 135 = socketpair */ 2661 { ns(struct sys_mkdir_args), 0, 2662 (sy_call_t *)sys_mkdir }, /* 136 = mkdir */ 2663 { ns(struct sys_rmdir_args), 0, 2664 (sy_call_t *)sys_rmdir }, /* 137 = rmdir */ 2665 { 0, 0, 0, 2666 (sy_call_t *)rump_enosys }, /* 138 = unrumped */ 2667 { 0, 0, 0, 2668 (sy_call_t *)rump_enosys }, /* 139 = obsolete 4.2 sigreturn */ 2669 { 0, 0, 0, 2670 (sy_call_t *)rump_enosys }, /* 140 = unrumped */ 2671 { 0, 0, 0, 2672 (sy_call_t *)rump_enosys }, /* 141 = unrumped */ 2673 { 0, 0, 0, 2674 (sy_call_t *)rump_enosys }, /* 142 = unrumped */ 2675 { 0, 0, 0, 2676 (sy_call_t *)rump_enosys }, /* 143 = unrumped */ 2677 { 0, 0, 0, 2678 (sy_call_t *)rump_enosys }, /* 144 = unrumped */ 2679 { 0, 0, 0, 2680 (sy_call_t *)rump_enosys }, /* 145 = unrumped */ 2681 { 0, 0, 0, 2682 (sy_call_t *)rump_enosys }, /* 146 = unrumped */ 2683 { 0, 0, 0, 2684 (sy_call_t *)rump_enosys }, /* 147 = unrumped */ 2685 { 0, 0, 0, 2686 (sy_call_t *)rump_enosys }, /* 148 = unrumped */ 2687 { 0, 0, 0, 2688 (sy_call_t *)rump_enosys }, /* 149 = unrumped */ 2689 { 0, 0, 0, 2690 (sy_call_t *)rump_enosys }, /* 150 = unrumped */ 2691 { 0, 0, 0, 2692 (sy_call_t *)rump_enosys }, /* 151 = unimplemented */ 2693 { 0, 0, 0, 2694 (sy_call_t *)rump_enosys }, /* 152 = unimplemented */ 2695 { 0, 0, 0, 2696 (sy_call_t *)rump_enosys }, /* 153 = unimplemented */ 2697 { 0, 0, 0, 2698 (sy_call_t *)rump_enosys }, /* 154 = unimplemented */ 2699 { ns(struct sys_nfssvc_args), 0, 2700 (sy_call_t *)sys_nomodule }, /* 155 = nfssvc */ 2701 { 0, 0, 0, 2702 (sy_call_t *)rump_enosys }, /* 156 = unrumped */ 2703 { 0, 0, 0, 2704 (sy_call_t *)rump_enosys }, /* 157 = unrumped */ 2705 { 0, 0, 0, 2706 (sy_call_t *)rump_enosys }, /* 158 = unrumped */ 2707 { 0, 0, 0, 2708 (sy_call_t *)rump_enosys }, /* 159 = unimplemented */ 2709 { 0, 0, 0, 2710 (sy_call_t *)rump_enosys }, /* 160 = unimplemented */ 2711 { 0, 0, 0, 2712 (sy_call_t *)rump_enosys }, /* 161 = unrumped */ 2713 { 0, 0, 0, 2714 (sy_call_t *)rump_enosys }, /* 162 = unrumped */ 2715 { 0, 0, 0, 2716 (sy_call_t *)rump_enosys }, /* 163 = unrumped */ 2717 { 0, 0, 0, 2718 (sy_call_t *)rump_enosys }, /* 164 = unrumped */ 2719 { 0, 0, 0, 2720 (sy_call_t *)rump_enosys }, /* 165 = unrumped */ 2721 { 0, 0, 0, 2722 (sy_call_t *)rump_enosys }, /* 166 = unimplemented */ 2723 { 0, 0, 0, 2724 (sy_call_t *)rump_enosys }, /* 167 = unimplemented */ 2725 { 0, 0, 0, 2726 (sy_call_t *)rump_enosys }, /* 168 = unimplemented */ 2727 #if (defined(SYSVSEM) || !defined(_KERNEL_OPT)) && !defined(_LP64) 2728 { 0, 0, 0, 2729 (sy_call_t *)rump_enosys }, /* 169 = unrumped */ 2730 #else 2731 { 0, 0, 0, 2732 (sy_call_t *)rump_enosys }, /* 169 = excluded 1.0 semsys */ 2733 #endif 2734 #if (defined(SYSVMSG) || !defined(_KERNEL_OPT)) && !defined(_LP64) 2735 { 0, 0, 0, 2736 (sy_call_t *)rump_enosys }, /* 170 = unrumped */ 2737 #else 2738 { 0, 0, 0, 2739 (sy_call_t *)rump_enosys }, /* 170 = excluded 1.0 msgsys */ 2740 #endif 2741 #if (defined(SYSVSHM) || !defined(_KERNEL_OPT)) && !defined(_LP64) 2742 { 0, 0, 0, 2743 (sy_call_t *)rump_enosys }, /* 171 = unrumped */ 2744 #else 2745 { 0, 0, 0, 2746 (sy_call_t *)rump_enosys }, /* 171 = excluded 1.0 shmsys */ 2747 #endif 2748 { 0, 0, 0, 2749 (sy_call_t *)rump_enosys }, /* 172 = unimplemented */ 2750 { ns(struct sys_pread_args), 0, 2751 (sy_call_t *)sys_pread }, /* 173 = pread */ 2752 { ns(struct sys_pwrite_args), 0, 2753 (sy_call_t *)sys_pwrite }, /* 174 = pwrite */ 2754 { 0, 0, 0, 2755 (sy_call_t *)rump_enosys }, /* 175 = unrumped */ 2756 #if defined(NTP) || !defined(_KERNEL_OPT) 2757 { 0, 0, 0, 2758 (sy_call_t *)rump_enosys }, /* 176 = unrumped */ 2759 #else 2760 { 0, 0, 0, 2761 (sy_call_t *)rump_enosys }, /* 176 = excluded ntp_adjtime */ 2762 #endif 2763 { 0, 0, 0, 2764 (sy_call_t *)rump_enosys }, /* 177 = unimplemented */ 2765 { 0, 0, 0, 2766 (sy_call_t *)rump_enosys }, /* 178 = unimplemented */ 2767 { 0, 0, 0, 2768 (sy_call_t *)rump_enosys }, /* 179 = unimplemented */ 2769 { 0, 0, 0, 2770 (sy_call_t *)rump_enosys }, /* 180 = unimplemented */ 2771 { 0, 0, 0, 2772 (sy_call_t *)rump_enosys }, /* 181 = unrumped */ 2773 { 0, 0, 0, 2774 (sy_call_t *)rump_enosys }, /* 182 = unrumped */ 2775 { 0, 0, 0, 2776 (sy_call_t *)rump_enosys }, /* 183 = unrumped */ 2777 #if defined(LFS) || !defined(_KERNEL) 2778 { 0, 0, 0, 2779 (sy_call_t *)rump_enosys }, /* 184 = unrumped */ 2780 { 0, 0, 0, 2781 (sy_call_t *)rump_enosys }, /* 185 = unrumped */ 2782 { 0, 0, 0, 2783 (sy_call_t *)rump_enosys }, /* 186 = unrumped */ 2784 { 0, 0, 0, 2785 (sy_call_t *)rump_enosys }, /* 187 = unrumped */ 2786 #else 2787 { 0, 0, 0, 2788 (sy_call_t *)rump_enosys }, /* 184 = excluded lfs_bmapv */ 2789 { 0, 0, 0, 2790 (sy_call_t *)rump_enosys }, /* 185 = excluded lfs_markv */ 2791 { 0, 0, 0, 2792 (sy_call_t *)rump_enosys }, /* 186 = excluded lfs_segclean */ 2793 { 0, 0, 0, 2794 (sy_call_t *)rump_enosys }, /* 187 = excluded lfs_segwait */ 2795 #endif 2796 { 0, 0, 0, 2797 (sy_call_t *)rump_enosys }, /* 188 = unrumped */ 2798 { 0, 0, 0, 2799 (sy_call_t *)rump_enosys }, /* 189 = unrumped */ 2800 { 0, 0, 0, 2801 (sy_call_t *)rump_enosys }, /* 190 = unrumped */ 2802 { 0, 0, 0, 2803 (sy_call_t *)rump_enosys }, /* 191 = unrumped */ 2804 { 0, 0, 0, 2805 (sy_call_t *)rump_enosys }, /* 192 = unrumped */ 2806 { 0, 0, 0, 2807 (sy_call_t *)rump_enosys }, /* 193 = unimplemented */ 2808 { 0, 0, 0, 2809 (sy_call_t *)rump_enosys }, /* 194 = unrumped */ 2810 { 0, 0, 0, 2811 (sy_call_t *)rump_enosys }, /* 195 = unrumped */ 2812 { 0, 0, 0, 2813 (sy_call_t *)rump_enosys }, /* 196 = unrumped */ 2814 { 0, 0, 0, 2815 (sy_call_t *)rump_enosys }, /* 197 = unrumped */ 2816 { 0, 0, 0, 2817 (sy_call_t *)rump_enosys }, /* 198 = unrumped */ 2818 { ns(struct sys_lseek_args), 0, 2819 (sy_call_t *)sys_lseek }, /* 199 = lseek */ 2820 { ns(struct sys_truncate_args), 0, 2821 (sy_call_t *)sys_truncate }, /* 200 = truncate */ 2822 { ns(struct sys_ftruncate_args), 0, 2823 (sy_call_t *)sys_ftruncate }, /* 201 = ftruncate */ 2824 { ns(struct sys___sysctl_args), 0, 2825 (sy_call_t *)sys___sysctl }, /* 202 = __sysctl */ 2826 { 0, 0, 0, 2827 (sy_call_t *)rump_enosys }, /* 203 = unrumped */ 2828 { 0, 0, 0, 2829 (sy_call_t *)rump_enosys }, /* 204 = unrumped */ 2830 { 0, 0, 0, 2831 (sy_call_t *)rump_enosys }, /* 205 = unrumped */ 2832 { 0, 0, 0, 2833 (sy_call_t *)rump_enosys }, /* 206 = unrumped */ 2834 { 0, 0, 0, 2835 (sy_call_t *)rump_enosys }, /* 207 = unrumped */ 2836 { ns(struct sys_reboot_args), 0, 2837 (sy_call_t *)sys_reboot }, /* 208 = reboot */ 2838 { ns(struct sys_poll_args), 0, 2839 (sy_call_t *)sys_poll }, /* 209 = poll */ 2840 { 0, 0, 0, 2841 (sy_call_t *)rump_enosys }, /* 210 = unimplemented */ 2842 { 0, 0, 0, 2843 (sy_call_t *)rump_enosys }, /* 211 = unimplemented */ 2844 { 0, 0, 0, 2845 (sy_call_t *)rump_enosys }, /* 212 = unimplemented */ 2846 { 0, 0, 0, 2847 (sy_call_t *)rump_enosys }, /* 213 = unimplemented */ 2848 { 0, 0, 0, 2849 (sy_call_t *)rump_enosys }, /* 214 = unimplemented */ 2850 { 0, 0, 0, 2851 (sy_call_t *)rump_enosys }, /* 215 = unimplemented */ 2852 { 0, 0, 0, 2853 (sy_call_t *)rump_enosys }, /* 216 = unimplemented */ 2854 { 0, 0, 0, 2855 (sy_call_t *)rump_enosys }, /* 217 = unimplemented */ 2856 { 0, 0, 0, 2857 (sy_call_t *)rump_enosys }, /* 218 = unimplemented */ 2858 { 0, 0, 0, 2859 (sy_call_t *)rump_enosys }, /* 219 = unimplemented */ 2860 #if defined(SYSVSEM) || !defined(_KERNEL_OPT) 2861 { 0, 0, 0, 2862 (sy_call_t *)rump_enosys }, /* 220 = unrumped */ 2863 { 0, 0, 0, 2864 (sy_call_t *)rump_enosys }, /* 221 = unrumped */ 2865 { 0, 0, 0, 2866 (sy_call_t *)rump_enosys }, /* 222 = unrumped */ 2867 { 0, 0, 0, 2868 (sy_call_t *)rump_enosys }, /* 223 = unrumped */ 2869 #else 2870 { 0, 0, 0, 2871 (sy_call_t *)rump_enosys }, /* 220 = excluded compat_14_semctl */ 2872 { 0, 0, 0, 2873 (sy_call_t *)rump_enosys }, /* 221 = excluded semget */ 2874 { 0, 0, 0, 2875 (sy_call_t *)rump_enosys }, /* 222 = excluded semop */ 2876 { 0, 0, 0, 2877 (sy_call_t *)rump_enosys }, /* 223 = excluded semconfig */ 2878 #endif 2879 #if defined(SYSVMSG) || !defined(_KERNEL_OPT) 2880 { 0, 0, 0, 2881 (sy_call_t *)rump_enosys }, /* 224 = unrumped */ 2882 { 0, 0, 0, 2883 (sy_call_t *)rump_enosys }, /* 225 = unrumped */ 2884 { 0, 0, 0, 2885 (sy_call_t *)rump_enosys }, /* 226 = unrumped */ 2886 { 0, 0, 0, 2887 (sy_call_t *)rump_enosys }, /* 227 = unrumped */ 2888 #else 2889 { 0, 0, 0, 2890 (sy_call_t *)rump_enosys }, /* 224 = excluded compat_14_msgctl */ 2891 { 0, 0, 0, 2892 (sy_call_t *)rump_enosys }, /* 225 = excluded msgget */ 2893 { 0, 0, 0, 2894 (sy_call_t *)rump_enosys }, /* 226 = excluded msgsnd */ 2895 { 0, 0, 0, 2896 (sy_call_t *)rump_enosys }, /* 227 = excluded msgrcv */ 2897 #endif 2898 #if defined(SYSVSHM) || !defined(_KERNEL_OPT) 2899 { 0, 0, 0, 2900 (sy_call_t *)rump_enosys }, /* 228 = unrumped */ 2901 { 0, 0, 0, 2902 (sy_call_t *)rump_enosys }, /* 229 = unrumped */ 2903 { 0, 0, 0, 2904 (sy_call_t *)rump_enosys }, /* 230 = unrumped */ 2905 { 0, 0, 0, 2906 (sy_call_t *)rump_enosys }, /* 231 = unrumped */ 2907 #else 2908 { 0, 0, 0, 2909 (sy_call_t *)rump_enosys }, /* 228 = excluded shmat */ 2910 { 0, 0, 0, 2911 (sy_call_t *)rump_enosys }, /* 229 = excluded compat_14_shmctl */ 2912 { 0, 0, 0, 2913 (sy_call_t *)rump_enosys }, /* 230 = excluded shmdt */ 2914 { 0, 0, 0, 2915 (sy_call_t *)rump_enosys }, /* 231 = excluded shmget */ 2916 #endif 2917 { 0, 0, 0, 2918 (sy_call_t *)rump_enosys }, /* 232 = unrumped */ 2919 { 0, 0, 0, 2920 (sy_call_t *)rump_enosys }, /* 233 = unrumped */ 2921 { 0, 0, 0, 2922 (sy_call_t *)rump_enosys }, /* 234 = unrumped */ 2923 { 0, 0, 0, 2924 (sy_call_t *)rump_enosys }, /* 235 = unrumped */ 2925 { 0, 0, 0, 2926 (sy_call_t *)rump_enosys }, /* 236 = unrumped */ 2927 { 0, 0, 0, 2928 (sy_call_t *)rump_enosys }, /* 237 = unrumped */ 2929 { 0, 0, 0, 2930 (sy_call_t *)rump_enosys }, /* 238 = unrumped */ 2931 { 0, 0, 0, 2932 (sy_call_t *)rump_enosys }, /* 239 = unrumped */ 2933 { 0, 0, 0, 2934 (sy_call_t *)rump_enosys }, /* 240 = unrumped */ 2935 { ns(struct sys_fdatasync_args), 0, 2936 (sy_call_t *)sys_fdatasync }, /* 241 = fdatasync */ 2937 { 0, 0, 0, 2938 (sy_call_t *)rump_enosys }, /* 242 = unrumped */ 2939 { 0, 0, 0, 2940 (sy_call_t *)rump_enosys }, /* 243 = unrumped */ 2941 { 0, 0, 0, 2942 (sy_call_t *)rump_enosys }, /* 244 = unrumped */ 2943 { 0, 0, 0, 2944 (sy_call_t *)rump_enosys }, /* 245 = unimplemented sys_sigqueue */ 2945 { 0, 0, 0, 2946 (sy_call_t *)rump_enosys }, /* 246 = unrumped */ 2947 { 0, 0, 0, 2948 (sy_call_t *)rump_enosys }, /* 247 = unrumped */ 2949 { 0, 0, 0, 2950 (sy_call_t *)rump_enosys }, /* 248 = unrumped */ 2951 { 0, 0, 0, 2952 (sy_call_t *)rump_enosys }, /* 249 = unrumped */ 2953 { 0, 0, 0, 2954 (sy_call_t *)rump_enosys }, /* 250 = unrumped */ 2955 { 0, 0, 0, 2956 (sy_call_t *)rump_enosys }, /* 251 = unrumped */ 2957 { 0, 0, 0, 2958 (sy_call_t *)rump_enosys }, /* 252 = unrumped */ 2959 { 0, 0, 0, 2960 (sy_call_t *)rump_enosys }, /* 253 = unrumped */ 2961 { 0, 0, 0, 2962 (sy_call_t *)rump_enosys }, /* 254 = unrumped */ 2963 { 0, 0, 0, 2964 (sy_call_t *)rump_enosys }, /* 255 = unrumped */ 2965 { 0, 0, 0, 2966 (sy_call_t *)rump_enosys }, /* 256 = unimplemented sys__ksem_timedwait */ 2967 { 0, 0, 0, 2968 (sy_call_t *)rump_enosys }, /* 257 = unrumped */ 2969 { 0, 0, 0, 2970 (sy_call_t *)rump_enosys }, /* 258 = unrumped */ 2971 { 0, 0, 0, 2972 (sy_call_t *)rump_enosys }, /* 259 = unrumped */ 2973 { 0, 0, 0, 2974 (sy_call_t *)rump_enosys }, /* 260 = unrumped */ 2975 { 0, 0, 0, 2976 (sy_call_t *)rump_enosys }, /* 261 = unrumped */ 2977 { 0, 0, 0, 2978 (sy_call_t *)rump_enosys }, /* 262 = unrumped */ 2979 { 0, 0, 0, 2980 (sy_call_t *)rump_enosys }, /* 263 = unrumped */ 2981 { 0, 0, 0, 2982 (sy_call_t *)rump_enosys }, /* 264 = unrumped */ 2983 { 0, 0, 0, 2984 (sy_call_t *)rump_enosys }, /* 265 = unrumped */ 2985 { 0, 0, 0, 2986 (sy_call_t *)rump_enosys }, /* 266 = unrumped */ 2987 { 0, 0, 0, 2988 (sy_call_t *)rump_enosys }, /* 267 = unimplemented */ 2989 { 0, 0, 0, 2990 (sy_call_t *)rump_enosys }, /* 268 = unimplemented */ 2991 { 0, 0, 0, 2992 (sy_call_t *)rump_enosys }, /* 269 = unimplemented */ 2993 { 0, 0, 0, 2994 (sy_call_t *)rump_enosys }, /* 270 = unrumped */ 2995 { 0, 0, 0, 2996 (sy_call_t *)rump_enosys }, /* 271 = unrumped */ 2997 { 0, 0, 0, 2998 (sy_call_t *)rump_enosys }, /* 272 = unrumped */ 2999 { 0, 0, 0, 3000 (sy_call_t *)rump_enosys }, /* 273 = unrumped */ 3001 { ns(struct sys_lchmod_args), 0, 3002 (sy_call_t *)sys_lchmod }, /* 274 = lchmod */ 3003 { ns(struct sys_lchown_args), 0, 3004 (sy_call_t *)sys_lchown }, /* 275 = lchown */ 3005 { 0, 0, 0, 3006 (sy_call_t *)rump_enosys }, /* 276 = unrumped */ 3007 { 0, 0, 0, 3008 (sy_call_t *)rump_enosys }, /* 277 = unrumped */ 3009 { 0, 0, 0, 3010 (sy_call_t *)rump_enosys }, /* 278 = unrumped */ 3011 { 0, 0, 0, 3012 (sy_call_t *)rump_enosys }, /* 279 = unrumped */ 3013 { 0, 0, 0, 3014 (sy_call_t *)rump_enosys }, /* 280 = unrumped */ 3015 { 0, 0, 0, 3016 (sy_call_t *)rump_enosys }, /* 281 = unrumped */ 3017 { 0, 0, 0, 3018 (sy_call_t *)rump_enosys }, /* 282 = unrumped */ 3019 { 0, 0, 0, 3020 (sy_call_t *)rump_enosys }, /* 283 = unrumped */ 3021 { 0, 0, 0, 3022 (sy_call_t *)rump_enosys }, /* 284 = unrumped */ 3023 { 0, 0, 0, 3024 (sy_call_t *)rump_enosys }, /* 285 = unrumped */ 3025 { 0, 0, 0, 3026 (sy_call_t *)rump_enosys }, /* 286 = unrumped */ 3027 { 0, 0, 0, 3028 (sy_call_t *)rump_enosys }, /* 287 = unrumped */ 3029 { 0, 0, 0, 3030 (sy_call_t *)rump_enosys }, /* 288 = unrumped */ 3031 { 0, 0, 0, 3032 (sy_call_t *)rump_enosys }, /* 289 = unrumped */ 3033 { 0, 0, 0, 3034 (sy_call_t *)rump_enosys }, /* 290 = unrumped */ 3035 { 0, 0, 0, 3036 (sy_call_t *)rump_enosys }, /* 291 = unrumped */ 3037 { 0, 0, 0, 3038 (sy_call_t *)rump_enosys }, /* 292 = unrumped */ 3039 { 0, 0, 0, 3040 (sy_call_t *)rump_enosys }, /* 293 = unrumped */ 3041 { 0, 0, 0, 3042 (sy_call_t *)rump_enosys }, /* 294 = unrumped */ 3043 { 0, 0, 0, 3044 (sy_call_t *)rump_enosys }, /* 295 = unrumped */ 3045 { 0, 0, 0, 3046 (sy_call_t *)rump_enosys }, /* 296 = unrumped */ 3047 { ns(struct sys_fchroot_args), 0, 3048 (sy_call_t *)sys_fchroot }, /* 297 = fchroot */ 3049 { 0, 0, 0, 3050 (sy_call_t *)rump_enosys }, /* 298 = unrumped */ 3051 { 0, 0, 0, 3052 (sy_call_t *)rump_enosys }, /* 299 = unrumped */ 3053 { 0, 0, 0, 3054 (sy_call_t *)rump_enosys }, /* 300 = unrumped */ 3055 #if defined(SYSVSEM) || !defined(_KERNEL_OPT) 3056 { 0, 0, 0, 3057 (sy_call_t *)rump_enosys }, /* 301 = unrumped */ 3058 #else 3059 { 0, 0, 0, 3060 (sy_call_t *)rump_enosys }, /* 301 = excluded ____semctl13 */ 3061 #endif 3062 #if defined(SYSVMSG) || !defined(_KERNEL_OPT) 3063 { 0, 0, 0, 3064 (sy_call_t *)rump_enosys }, /* 302 = unrumped */ 3065 #else 3066 { 0, 0, 0, 3067 (sy_call_t *)rump_enosys }, /* 302 = excluded __msgctl13 */ 3068 #endif 3069 #if defined(SYSVSHM) || !defined(_KERNEL_OPT) 3070 { 0, 0, 0, 3071 (sy_call_t *)rump_enosys }, /* 303 = unrumped */ 3072 #else 3073 { 0, 0, 0, 3074 (sy_call_t *)rump_enosys }, /* 303 = excluded __shmctl13 */ 3075 #endif 3076 { ns(struct sys_lchflags_args), 0, 3077 (sy_call_t *)sys_lchflags }, /* 304 = lchflags */ 3078 { 0, 0, 0, 3079 (sy_call_t *)rump_enosys }, /* 305 = unrumped */ 3080 { 0, 0, 0, 3081 (sy_call_t *)rump_enosys }, /* 306 = unrumped */ 3082 { 0, 0, 0, 3083 (sy_call_t *)rump_enosys }, /* 307 = unrumped */ 3084 { 0, 0, 0, 3085 (sy_call_t *)rump_enosys }, /* 308 = unrumped */ 3086 { 0, 0, 0, 3087 (sy_call_t *)rump_enosys }, /* 309 = unrumped */ 3088 { 0, 0, 0, 3089 (sy_call_t *)rump_enosys }, /* 310 = unrumped */ 3090 { 0, 0, 0, 3091 (sy_call_t *)rump_enosys }, /* 311 = unrumped */ 3092 { 0, 0, 0, 3093 (sy_call_t *)rump_enosys }, /* 312 = unrumped */ 3094 { 0, 0, 0, 3095 (sy_call_t *)rump_enosys }, /* 313 = unrumped */ 3096 { 0, 0, 0, 3097 (sy_call_t *)rump_enosys }, /* 314 = unrumped */ 3098 { 0, 0, 0, 3099 (sy_call_t *)rump_enosys }, /* 315 = unrumped */ 3100 { 0, 0, 0, 3101 (sy_call_t *)rump_enosys }, /* 316 = unrumped */ 3102 { 0, 0, 0, 3103 (sy_call_t *)rump_enosys }, /* 317 = unrumped */ 3104 { 0, 0, 0, 3105 (sy_call_t *)rump_enosys }, /* 318 = unrumped */ 3106 { 0, 0, 0, 3107 (sy_call_t *)rump_enosys }, /* 319 = unrumped */ 3108 { 0, 0, 0, 3109 (sy_call_t *)rump_enosys }, /* 320 = unrumped */ 3110 { 0, 0, 0, 3111 (sy_call_t *)rump_enosys }, /* 321 = unrumped */ 3112 { 0, 0, 0, 3113 (sy_call_t *)rump_enosys }, /* 322 = unrumped */ 3114 { 0, 0, 0, 3115 (sy_call_t *)rump_enosys }, /* 323 = unrumped */ 3116 { 0, 0, 0, 3117 (sy_call_t *)rump_enosys }, /* 324 = unrumped */ 3118 { 0, 0, 0, 3119 (sy_call_t *)rump_enosys }, /* 325 = unrumped */ 3120 { 0, 0, 0, 3121 (sy_call_t *)rump_enosys }, /* 326 = unimplemented */ 3122 { 0, 0, 0, 3123 (sy_call_t *)rump_enosys }, /* 327 = unimplemented */ 3124 { 0, 0, 0, 3125 (sy_call_t *)rump_enosys }, /* 328 = unimplemented */ 3126 { 0, 0, 0, 3127 (sy_call_t *)rump_enosys }, /* 329 = unimplemented */ 3128 { 0, 0, 0, 3129 (sy_call_t *)rump_enosys }, /* 330 = unrumped */ 3130 { 0, 0, 0, 3131 (sy_call_t *)rump_enosys }, /* 331 = unrumped */ 3132 { 0, 0, 0, 3133 (sy_call_t *)rump_enosys }, /* 332 = unrumped */ 3134 { 0, 0, 0, 3135 (sy_call_t *)rump_enosys }, /* 333 = unrumped */ 3136 { 0, 0, 0, 3137 (sy_call_t *)rump_enosys }, /* 334 = unrumped */ 3138 { 0, 0, 0, 3139 (sy_call_t *)rump_enosys }, /* 335 = unrumped */ 3140 { 0, 0, 0, 3141 (sy_call_t *)rump_enosys }, /* 336 = obsolete sys_sa_unblockyield */ 3142 { 0, 0, 0, 3143 (sy_call_t *)rump_enosys }, /* 337 = unimplemented */ 3144 { 0, 0, 0, 3145 (sy_call_t *)rump_enosys }, /* 338 = unimplemented */ 3146 { 0, 0, 0, 3147 (sy_call_t *)rump_enosys }, /* 339 = unimplemented */ 3148 { 0, 0, 0, 3149 (sy_call_t *)rump_enosys }, /* 340 = unrumped */ 3150 { 0, 0, 0, 3151 (sy_call_t *)rump_enosys }, /* 341 = unrumped */ 3152 { 0, 0, 0, 3153 (sy_call_t *)rump_enosys }, /* 342 = unrumped */ 3154 { 0, 0, 0, 3155 (sy_call_t *)rump_enosys }, /* 343 = unrumped */ 3156 { 0, 0, 0, 3157 (sy_call_t *)sys_kqueue }, /* 344 = kqueue */ 3158 { 0, 0, 0, 3159 (sy_call_t *)rump_enosys }, /* 345 = unrumped */ 3160 { 0, 0, 0, 3161 (sy_call_t *)rump_enosys }, /* 346 = unrumped */ 3162 { 0, 0, 0, 3163 (sy_call_t *)rump_enosys }, /* 347 = unrumped */ 3164 { 0, 0, 0, 3165 (sy_call_t *)rump_enosys }, /* 348 = unrumped */ 3166 { 0, 0, 0, 3167 (sy_call_t *)rump_enosys }, /* 349 = unrumped */ 3168 { 0, 0, 0, 3169 (sy_call_t *)rump_enosys }, /* 350 = unrumped */ 3170 { 0, 0, 0, 3171 (sy_call_t *)rump_enosys }, /* 351 = unimplemented */ 3172 { 0, 0, 0, 3173 (sy_call_t *)rump_enosys }, /* 352 = unimplemented */ 3174 { 0, 0, 0, 3175 (sy_call_t *)rump_enosys }, /* 353 = unimplemented */ 3176 { ns(struct sys_fsync_range_args), 0, 3177 (sy_call_t *)sys_fsync_range }, /* 354 = fsync_range */ 3178 { 0, 0, 0, 3179 (sy_call_t *)rump_enosys }, /* 355 = unrumped */ 3180 { ns(struct sys_getvfsstat_args), 0, 3181 (sy_call_t *)sys_getvfsstat }, /* 356 = getvfsstat */ 3182 { ns(struct sys_statvfs1_args), 0, 3183 (sy_call_t *)sys_statvfs1 }, /* 357 = statvfs1 */ 3184 { ns(struct sys_fstatvfs1_args), 0, 3185 (sy_call_t *)sys_fstatvfs1 }, /* 358 = fstatvfs1 */ 3186 { 0, 0, 0, 3187 (sy_call_t *)rump_enosys }, /* 359 = unrumped */ 3188 { ns(struct sys_extattrctl_args), 0, 3189 (sy_call_t *)sys_extattrctl }, /* 360 = extattrctl */ 3190 { ns(struct sys_extattr_set_file_args), 0, 3191 (sy_call_t *)sys_extattr_set_file }, /* 361 = extattr_set_file */ 3192 { ns(struct sys_extattr_get_file_args), 0, 3193 (sy_call_t *)sys_extattr_get_file }, /* 362 = extattr_get_file */ 3194 { ns(struct sys_extattr_delete_file_args), 0, 3195 (sy_call_t *)sys_extattr_delete_file }, /* 363 = extattr_delete_file */ 3196 { ns(struct sys_extattr_set_fd_args), 0, 3197 (sy_call_t *)sys_extattr_set_fd }, /* 364 = extattr_set_fd */ 3198 { ns(struct sys_extattr_get_fd_args), 0, 3199 (sy_call_t *)sys_extattr_get_fd }, /* 365 = extattr_get_fd */ 3200 { ns(struct sys_extattr_delete_fd_args), 0, 3201 (sy_call_t *)sys_extattr_delete_fd }, /* 366 = extattr_delete_fd */ 3202 { ns(struct sys_extattr_set_link_args), 0, 3203 (sy_call_t *)sys_extattr_set_link }, /* 367 = extattr_set_link */ 3204 { ns(struct sys_extattr_get_link_args), 0, 3205 (sy_call_t *)sys_extattr_get_link }, /* 368 = extattr_get_link */ 3206 { ns(struct sys_extattr_delete_link_args), 0, 3207 (sy_call_t *)sys_extattr_delete_link }, /* 369 = extattr_delete_link */ 3208 { ns(struct sys_extattr_list_fd_args), 0, 3209 (sy_call_t *)sys_extattr_list_fd }, /* 370 = extattr_list_fd */ 3210 { ns(struct sys_extattr_list_file_args), 0, 3211 (sy_call_t *)sys_extattr_list_file }, /* 371 = extattr_list_file */ 3212 { ns(struct sys_extattr_list_link_args), 0, 3213 (sy_call_t *)sys_extattr_list_link }, /* 372 = extattr_list_link */ 3214 { 0, 0, 0, 3215 (sy_call_t *)rump_enosys }, /* 373 = unrumped */ 3216 { 0, 0, 0, 3217 (sy_call_t *)rump_enosys }, /* 374 = unrumped */ 3218 { ns(struct sys_setxattr_args), 0, 3219 (sy_call_t *)sys_setxattr }, /* 375 = setxattr */ 3220 { ns(struct sys_lsetxattr_args), 0, 3221 (sy_call_t *)sys_lsetxattr }, /* 376 = lsetxattr */ 3222 { ns(struct sys_fsetxattr_args), 0, 3223 (sy_call_t *)sys_fsetxattr }, /* 377 = fsetxattr */ 3224 { ns(struct sys_getxattr_args), 0, 3225 (sy_call_t *)sys_getxattr }, /* 378 = getxattr */ 3226 { ns(struct sys_lgetxattr_args), 0, 3227 (sy_call_t *)sys_lgetxattr }, /* 379 = lgetxattr */ 3228 { ns(struct sys_fgetxattr_args), 0, 3229 (sy_call_t *)sys_fgetxattr }, /* 380 = fgetxattr */ 3230 { ns(struct sys_listxattr_args), 0, 3231 (sy_call_t *)sys_listxattr }, /* 381 = listxattr */ 3232 { ns(struct sys_llistxattr_args), 0, 3233 (sy_call_t *)sys_llistxattr }, /* 382 = llistxattr */ 3234 { ns(struct sys_flistxattr_args), 0, 3235 (sy_call_t *)sys_flistxattr }, /* 383 = flistxattr */ 3236 { ns(struct sys_removexattr_args), 0, 3237 (sy_call_t *)sys_removexattr }, /* 384 = removexattr */ 3238 { ns(struct sys_lremovexattr_args), 0, 3239 (sy_call_t *)sys_lremovexattr }, /* 385 = lremovexattr */ 3240 { ns(struct sys_fremovexattr_args), 0, 3241 (sy_call_t *)sys_fremovexattr }, /* 386 = fremovexattr */ 3242 { 0, 0, 0, 3243 (sy_call_t *)rump_enosys }, /* 387 = unrumped */ 3244 { 0, 0, 0, 3245 (sy_call_t *)rump_enosys }, /* 388 = unrumped */ 3246 { 0, 0, 0, 3247 (sy_call_t *)rump_enosys }, /* 389 = unrumped */ 3248 { ns(struct sys___getdents30_args), 0, 3249 (sy_call_t *)sys___getdents30 }, /* 390 = __getdents30 */ 3250 { 0, 0, 0, 3251 (sy_call_t *)rump_enosys }, /* 391 = ignored old posix_fadvise */ 3252 { 0, 0, 0, 3253 (sy_call_t *)rump_enosys }, /* 392 = unrumped */ 3254 { 0, 0, 0, 3255 (sy_call_t *)rump_enosys }, /* 393 = unrumped */ 3256 { ns(struct sys___socket30_args), 0, 3257 (sy_call_t *)sys___socket30 }, /* 394 = __socket30 */ 3258 { ns(struct sys___getfh30_args), 0, 3259 (sy_call_t *)sys___getfh30 }, /* 395 = __getfh30 */ 3260 { 0, 0, 0, 3261 (sy_call_t *)rump_enosys }, /* 396 = unrumped */ 3262 { 0, 0, 0, 3263 (sy_call_t *)rump_enosys }, /* 397 = unrumped */ 3264 { 0, 0, 0, 3265 (sy_call_t *)rump_enosys }, /* 398 = unrumped */ 3266 { 0, 0, 0, 3267 (sy_call_t *)rump_enosys }, /* 399 = unrumped */ 3268 { 0, 0, 0, 3269 (sy_call_t *)rump_enosys }, /* 400 = unrumped */ 3270 { 0, 0, 0, 3271 (sy_call_t *)rump_enosys }, /* 401 = unrumped */ 3272 { 0, 0, 0, 3273 (sy_call_t *)rump_enosys }, /* 402 = unrumped */ 3274 { 0, 0, 0, 3275 (sy_call_t *)rump_enosys }, /* 403 = unrumped */ 3276 { 0, 0, 0, 3277 (sy_call_t *)rump_enosys }, /* 404 = unrumped */ 3278 { 0, 0, 0, 3279 (sy_call_t *)rump_enosys }, /* 405 = unrumped */ 3280 { 0, 0, 0, 3281 (sy_call_t *)rump_enosys }, /* 406 = unrumped */ 3282 { 0, 0, 0, 3283 (sy_call_t *)rump_enosys }, /* 407 = unimplemented */ 3284 { 0, 0, 0, 3285 (sy_call_t *)rump_enosys }, /* 408 = unimplemented */ 3286 { 0, 0, 0, 3287 (sy_call_t *)rump_enosys }, /* 409 = unimplemented */ 3288 { ns(struct sys___mount50_args), 0, 3289 (sy_call_t *)sys___mount50 }, /* 410 = __mount50 */ 3290 { 0, 0, 0, 3291 (sy_call_t *)rump_enosys }, /* 411 = unrumped */ 3292 { 0, 0, 0, 3293 (sy_call_t *)rump_enosys }, /* 412 = unrumped */ 3294 { 0, 0, 0, 3295 (sy_call_t *)rump_enosys }, /* 413 = unrumped */ 3296 { 0, 0, 0, 3297 (sy_call_t *)rump_enosys }, /* 414 = unrumped */ 3298 { 0, 0, 0, 3299 (sy_call_t *)rump_enosys }, /* 415 = unrumped */ 3300 { 0, 0, 0, 3301 (sy_call_t *)rump_enosys }, /* 416 = unrumped */ 3302 { ns(struct sys___select50_args), 0, 3303 (sy_call_t *)sys___select50 }, /* 417 = __select50 */ 3304 { 0, 0, 0, 3305 (sy_call_t *)rump_enosys }, /* 418 = unrumped */ 3306 { 0, 0, 0, 3307 (sy_call_t *)rump_enosys }, /* 419 = unrumped */ 3308 { ns(struct sys___utimes50_args), 0, 3309 (sy_call_t *)sys___utimes50 }, /* 420 = __utimes50 */ 3310 { 0, 0, 0, 3311 (sy_call_t *)rump_enosys }, /* 421 = unrumped */ 3312 #if defined(LFS) || !defined(_KERNEL) 3313 { 0, 0, 0, 3314 (sy_call_t *)rump_enosys }, /* 422 = unrumped */ 3315 #else 3316 { 0, 0, 0, 3317 (sy_call_t *)rump_enosys }, /* 422 = excluded __lfs_segwait50 */ 3318 #endif 3319 { ns(struct sys___futimes50_args), 0, 3320 (sy_call_t *)sys___futimes50 }, /* 423 = __futimes50 */ 3321 { ns(struct sys___lutimes50_args), 0, 3322 (sy_call_t *)sys___lutimes50 }, /* 424 = __lutimes50 */ 3323 { 0, 0, 0, 3324 (sy_call_t *)rump_enosys }, /* 425 = unrumped */ 3325 { 0, 0, 0, 3326 (sy_call_t *)rump_enosys }, /* 426 = unrumped */ 3327 { 0, 0, 0, 3328 (sy_call_t *)rump_enosys }, /* 427 = unrumped */ 3329 { 0, 0, 0, 3330 (sy_call_t *)rump_enosys }, /* 428 = unrumped */ 3331 { 0, 0, 0, 3332 (sy_call_t *)rump_enosys }, /* 429 = unrumped */ 3333 { 0, 0, 0, 3334 (sy_call_t *)rump_enosys }, /* 430 = unrumped */ 3335 { 0, 0, 0, 3336 (sy_call_t *)rump_enosys }, /* 431 = unrumped */ 3337 { 0, 0, 0, 3338 (sy_call_t *)rump_enosys }, /* 432 = unrumped */ 3339 { 0, 0, 0, 3340 (sy_call_t *)rump_enosys }, /* 433 = unrumped */ 3341 { 0, 0, 0, 3342 (sy_call_t *)rump_enosys }, /* 434 = unrumped */ 3343 { ns(struct sys___kevent50_args), 0, 3344 (sy_call_t *)sys___kevent50 }, /* 435 = __kevent50 */ 3345 { ns(struct sys___pselect50_args), 0, 3346 (sy_call_t *)sys___pselect50 }, /* 436 = __pselect50 */ 3347 { ns(struct sys___pollts50_args), 0, 3348 (sy_call_t *)sys___pollts50 }, /* 437 = __pollts50 */ 3349 { 0, 0, 0, 3350 (sy_call_t *)rump_enosys }, /* 438 = unrumped */ 3351 { ns(struct sys___stat50_args), 0, 3352 (sy_call_t *)sys___stat50 }, /* 439 = __stat50 */ 3353 { ns(struct sys___fstat50_args), 0, 3354 (sy_call_t *)sys___fstat50 }, /* 440 = __fstat50 */ 3355 { ns(struct sys___lstat50_args), 0, 3356 (sy_call_t *)sys___lstat50 }, /* 441 = __lstat50 */ 3357 #if defined(SYSVSEM) || !defined(_KERNEL_OPT) 3358 { 0, 0, 0, 3359 (sy_call_t *)rump_enosys }, /* 442 = unrumped */ 3360 #else 3361 { 0, 0, 0, 3362 (sy_call_t *)rump_enosys }, /* 442 = excluded ____semctl50 */ 3363 #endif 3364 #if defined(SYSVSHM) || !defined(_KERNEL_OPT) 3365 { 0, 0, 0, 3366 (sy_call_t *)rump_enosys }, /* 443 = unrumped */ 3367 #else 3368 { 0, 0, 0, 3369 (sy_call_t *)rump_enosys }, /* 443 = excluded ____shmctl50 */ 3370 #endif 3371 #if defined(SYSVMSG) || !defined(_KERNEL_OPT) 3372 { 0, 0, 0, 3373 (sy_call_t *)rump_enosys }, /* 444 = unrumped */ 3374 #else 3375 { 0, 0, 0, 3376 (sy_call_t *)rump_enosys }, /* 444 = excluded ____msgctl50 */ 3377 #endif 3378 { 0, 0, 0, 3379 (sy_call_t *)rump_enosys }, /* 445 = unrumped */ 3380 { 0, 0, 0, 3381 (sy_call_t *)rump_enosys }, /* 446 = unrumped */ 3382 { 0, 0, 0, 3383 (sy_call_t *)rump_enosys }, /* 447 = unrumped */ 3384 #if defined(NTP) || !defined(_KERNEL_OPT) 3385 { 0, 0, 0, 3386 (sy_call_t *)rump_enosys }, /* 448 = unrumped */ 3387 #else 3388 { 0, 0, 0, 3389 (sy_call_t *)rump_enosys }, /* 448 = excluded ___ntp_gettime50 */ 3390 #endif 3391 { 0, 0, 0, 3392 (sy_call_t *)rump_enosys }, /* 449 = unrumped */ 3393 { ns(struct sys___mknod50_args), 0, 3394 (sy_call_t *)sys___mknod50 }, /* 450 = __mknod50 */ 3395 { ns(struct sys___fhstat50_args), 0, 3396 (sy_call_t *)sys___fhstat50 }, /* 451 = __fhstat50 */ 3397 { 0, 0, 0, 3398 (sy_call_t *)rump_enosys }, /* 452 = filler */ 3399 { 0, 0, 0, 3400 (sy_call_t *)rump_enosys }, /* 453 = filler */ 3401 { 0, 0, 0, 3402 (sy_call_t *)rump_enosys }, /* 454 = filler */ 3403 { 0, 0, 0, 3404 (sy_call_t *)rump_enosys }, /* 455 = filler */ 3405 { 0, 0, 0, 3406 (sy_call_t *)rump_enosys }, /* 456 = filler */ 3407 { 0, 0, 0, 3408 (sy_call_t *)rump_enosys }, /* 457 = filler */ 3409 { 0, 0, 0, 3410 (sy_call_t *)rump_enosys }, /* 458 = filler */ 3411 { 0, 0, 0, 3412 (sy_call_t *)rump_enosys }, /* 459 = filler */ 3413 { 0, 0, 0, 3414 (sy_call_t *)rump_enosys }, /* 460 = filler */ 3415 { 0, 0, 0, 3416 (sy_call_t *)rump_enosys }, /* 461 = filler */ 3417 { 0, 0, 0, 3418 (sy_call_t *)rump_enosys }, /* 462 = filler */ 3419 { 0, 0, 0, 3420 (sy_call_t *)rump_enosys }, /* 463 = filler */ 3421 { 0, 0, 0, 3422 (sy_call_t *)rump_enosys }, /* 464 = filler */ 3423 { 0, 0, 0, 3424 (sy_call_t *)rump_enosys }, /* 465 = filler */ 3425 { 0, 0, 0, 3426 (sy_call_t *)rump_enosys }, /* 466 = filler */ 3427 { 0, 0, 0, 3428 (sy_call_t *)rump_enosys }, /* 467 = filler */ 3429 { 0, 0, 0, 3430 (sy_call_t *)rump_enosys }, /* 468 = filler */ 3431 { 0, 0, 0, 3432 (sy_call_t *)rump_enosys }, /* 469 = filler */ 3433 { 0, 0, 0, 3434 (sy_call_t *)rump_enosys }, /* 470 = filler */ 3435 { 0, 0, 0, 3436 (sy_call_t *)rump_enosys }, /* 471 = filler */ 3437 { 0, 0, 0, 3438 (sy_call_t *)rump_enosys }, /* 472 = filler */ 3439 { 0, 0, 0, 3440 (sy_call_t *)rump_enosys }, /* 473 = filler */ 3441 { 0, 0, 0, 3442 (sy_call_t *)rump_enosys }, /* 474 = filler */ 3443 { 0, 0, 0, 3444 (sy_call_t *)rump_enosys }, /* 475 = filler */ 3445 { 0, 0, 0, 3446 (sy_call_t *)rump_enosys }, /* 476 = filler */ 3447 { 0, 0, 0, 3448 (sy_call_t *)rump_enosys }, /* 477 = filler */ 3449 { 0, 0, 0, 3450 (sy_call_t *)rump_enosys }, /* 478 = filler */ 3451 { 0, 0, 0, 3452 (sy_call_t *)rump_enosys }, /* 479 = filler */ 3453 { 0, 0, 0, 3454 (sy_call_t *)rump_enosys }, /* 480 = filler */ 3455 { 0, 0, 0, 3456 (sy_call_t *)rump_enosys }, /* 481 = filler */ 3457 { 0, 0, 0, 3458 (sy_call_t *)rump_enosys }, /* 482 = filler */ 3459 { 0, 0, 0, 3460 (sy_call_t *)rump_enosys }, /* 483 = filler */ 3461 { 0, 0, 0, 3462 (sy_call_t *)rump_enosys }, /* 484 = filler */ 3463 { 0, 0, 0, 3464 (sy_call_t *)rump_enosys }, /* 485 = filler */ 3465 { 0, 0, 0, 3466 (sy_call_t *)rump_enosys }, /* 486 = filler */ 3467 { 0, 0, 0, 3468 (sy_call_t *)rump_enosys }, /* 487 = filler */ 3469 { 0, 0, 0, 3470 (sy_call_t *)rump_enosys }, /* 488 = filler */ 3471 { 0, 0, 0, 3472 (sy_call_t *)rump_enosys }, /* 489 = filler */ 3473 { 0, 0, 0, 3474 (sy_call_t *)rump_enosys }, /* 490 = filler */ 3475 { 0, 0, 0, 3476 (sy_call_t *)rump_enosys }, /* 491 = filler */ 3477 { 0, 0, 0, 3478 (sy_call_t *)rump_enosys }, /* 492 = filler */ 3479 { 0, 0, 0, 3480 (sy_call_t *)rump_enosys }, /* 493 = filler */ 3481 { 0, 0, 0, 3482 (sy_call_t *)rump_enosys }, /* 494 = filler */ 3483 { 0, 0, 0, 3484 (sy_call_t *)rump_enosys }, /* 495 = filler */ 3485 { 0, 0, 0, 3486 (sy_call_t *)rump_enosys }, /* 496 = filler */ 3487 { 0, 0, 0, 3488 (sy_call_t *)rump_enosys }, /* 497 = filler */ 3489 { 0, 0, 0, 3490 (sy_call_t *)rump_enosys }, /* 498 = filler */ 3491 { 0, 0, 0, 3492 (sy_call_t *)rump_enosys }, /* 499 = filler */ 3493 { 0, 0, 0, 3494 (sy_call_t *)rump_enosys }, /* 500 = filler */ 3495 { 0, 0, 0, 3496 (sy_call_t *)rump_enosys }, /* 501 = filler */ 3497 { 0, 0, 0, 3498 (sy_call_t *)rump_enosys }, /* 502 = filler */ 3499 { 0, 0, 0, 3500 (sy_call_t *)rump_enosys }, /* 503 = filler */ 3501 { 0, 0, 0, 3502 (sy_call_t *)rump_enosys }, /* 504 = filler */ 3503 { 0, 0, 0, 3504 (sy_call_t *)rump_enosys }, /* 505 = filler */ 3505 { 0, 0, 0, 3506 (sy_call_t *)rump_enosys }, /* 506 = filler */ 3507 { 0, 0, 0, 3508 (sy_call_t *)rump_enosys }, /* 507 = filler */ 3509 { 0, 0, 0, 3510 (sy_call_t *)rump_enosys }, /* 508 = filler */ 3511 { 0, 0, 0, 3512 (sy_call_t *)rump_enosys }, /* 509 = filler */ 3513 { 0, 0, 0, 3514 (sy_call_t *)rump_enosys }, /* 510 = filler */ 3515 { 0, 0, 0, 3516 (sy_call_t *)rump_enosys }, /* 511 = filler */ 3517 }; 3518 CTASSERT(__arraycount(rump_sysent) == SYS_NSYSENT); 3519
Indexes created Wed Oct 01 13:09:50 GMT 2025