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