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