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