rump_syscalls.c revision 1.92
1 /* $NetBSD: rump_syscalls.c,v 1.92 2013/10/17 18:04:40 njoly 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.264 2013/10/17 18:01:11 njoly Exp 8 */ 9 10 #ifdef RUMP_CLIENT 11 #include <rump/rumpuser_port.h> 12 #endif /* RUMP_CLIENT */ 13 14 #include <sys/param.h> 15 16 #ifdef __NetBSD__ 17 #include <sys/cdefs.h> 18 __KERNEL_RCSID(0, "$NetBSD: rump_syscalls.c,v 1.92 2013/10/17 18:04:40 njoly Exp $"); 19 20 #include <sys/fstypes.h> 21 #include <sys/proc.h> 22 #endif /* __NetBSD__ */ 23 24 #ifdef RUMP_CLIENT 25 #include <errno.h> 26 #include <stdint.h> 27 #include <stdlib.h> 28 29 #include <srcsys/syscall.h> 30 #include <srcsys/syscallargs.h> 31 32 #include <rump/rumpclient.h> 33 34 #define rsys_syscall(num, data, dlen, retval) \ 35 rumpclient_syscall(num, data, dlen, retval) 36 #define rsys_seterrno(error) errno = error 37 #define rsys_define(nam) 38 #else 39 #include <sys/syscall.h> 40 #include <sys/syscallargs.h> 41 42 #include <sys/syscallvar.h> 43 44 #include <rump/rumpuser.h> 45 #include "rump_private.h" 46 47 #define rsys_syscall(num, data, dlen, retval) \ 48 rump_syscall(num, data, dlen, retval) 49 50 #define rsys_seterrno(error) rumpuser_seterrno(error) 51 #define rsys_define(nam) \ 52 int nam(struct lwp *, const void *, register_t *); \ 53 __weak_alias(nam,rump_enosys); 54 #endif 55 56 #ifdef RUMP_KERNEL_IS_LIBC 57 #define rsys_aliases(what,where) \ 58 __strong_alias(what,where); \ 59 __strong_alias(_##what,where); 60 #else 61 #define rsys_aliases(a,b) 62 #endif 63 64 #if BYTE_ORDER == BIG_ENDIAN 65 #define SPARG(p,k) ((p)->k.be.datum) 66 #else /* LITTLE_ENDIAN, I hope dearly */ 67 #define SPARG(p,k) ((p)->k.le.datum) 68 #endif 69 70 #ifndef RUMP_CLIENT 71 int rump_enosys(void); 72 int 73 rump_enosys() 74 { 75 76 return ENOSYS; 77 } 78 #endif 79 80 void rumpns_sys_nomodule(void); 81 82 ssize_t rump___sysimpl_read(int, void *, size_t); 83 ssize_t 84 rump___sysimpl_read(int fd, void * buf, size_t nbyte) 85 { 86 register_t retval[2] = {0, 0}; 87 int error = 0; 88 ssize_t rv = -1; 89 struct sys_read_args callarg; 90 91 SPARG(&callarg, fd) = fd; 92 SPARG(&callarg, buf) = buf; 93 SPARG(&callarg, nbyte) = nbyte; 94 95 error = rsys_syscall(SYS_read, &callarg, sizeof(callarg), retval); 96 rsys_seterrno(error); 97 if (error == 0) { 98 if (sizeof(ssize_t) > sizeof(register_t)) 99 rv = *(ssize_t *)retval; 100 else 101 rv = *retval; 102 } 103 return rv; 104 } 105 rsys_define(rumpns_sys_read); 106 rsys_aliases(read,rump___sysimpl_read); 107 108 ssize_t rump___sysimpl_write(int, const void *, size_t); 109 ssize_t 110 rump___sysimpl_write(int fd, const void * buf, size_t nbyte) 111 { 112 register_t retval[2] = {0, 0}; 113 int error = 0; 114 ssize_t rv = -1; 115 struct sys_write_args callarg; 116 117 SPARG(&callarg, fd) = fd; 118 SPARG(&callarg, buf) = buf; 119 SPARG(&callarg, nbyte) = nbyte; 120 121 error = rsys_syscall(SYS_write, &callarg, sizeof(callarg), retval); 122 rsys_seterrno(error); 123 if (error == 0) { 124 if (sizeof(ssize_t) > sizeof(register_t)) 125 rv = *(ssize_t *)retval; 126 else 127 rv = *retval; 128 } 129 return rv; 130 } 131 rsys_define(rumpns_sys_write); 132 rsys_aliases(write,rump___sysimpl_write); 133 134 int rump___sysimpl_open(const char *, int, mode_t); 135 int 136 rump___sysimpl_open(const char * path, int flags, mode_t mode) 137 { 138 register_t retval[2] = {0, 0}; 139 int error = 0; 140 int rv = -1; 141 struct sys_open_args callarg; 142 143 SPARG(&callarg, path) = path; 144 SPARG(&callarg, flags) = flags; 145 SPARG(&callarg, mode) = mode; 146 147 error = rsys_syscall(SYS_open, &callarg, sizeof(callarg), retval); 148 rsys_seterrno(error); 149 if (error == 0) { 150 if (sizeof(int) > sizeof(register_t)) 151 rv = *(int *)retval; 152 else 153 rv = *retval; 154 } 155 return rv; 156 } 157 rsys_define(rumpns_sys_open); 158 rsys_aliases(open,rump___sysimpl_open); 159 160 int rump___sysimpl_close(int); 161 int 162 rump___sysimpl_close(int fd) 163 { 164 register_t retval[2] = {0, 0}; 165 int error = 0; 166 int rv = -1; 167 struct sys_close_args callarg; 168 169 SPARG(&callarg, fd) = fd; 170 171 error = rsys_syscall(SYS_close, &callarg, sizeof(callarg), retval); 172 rsys_seterrno(error); 173 if (error == 0) { 174 if (sizeof(int) > sizeof(register_t)) 175 rv = *(int *)retval; 176 else 177 rv = *retval; 178 } 179 return rv; 180 } 181 rsys_define(rumpns_sys_close); 182 rsys_aliases(close,rump___sysimpl_close); 183 184 int rump___sysimpl_link(const char *, const char *); 185 int 186 rump___sysimpl_link(const char * path, const char * link) 187 { 188 register_t retval[2] = {0, 0}; 189 int error = 0; 190 int rv = -1; 191 struct sys_link_args callarg; 192 193 SPARG(&callarg, path) = path; 194 SPARG(&callarg, link) = link; 195 196 error = rsys_syscall(SYS_link, &callarg, sizeof(callarg), retval); 197 rsys_seterrno(error); 198 if (error == 0) { 199 if (sizeof(int) > sizeof(register_t)) 200 rv = *(int *)retval; 201 else 202 rv = *retval; 203 } 204 return rv; 205 } 206 rsys_define(rumpns_sys_link); 207 rsys_aliases(link,rump___sysimpl_link); 208 209 int rump___sysimpl_unlink(const char *); 210 int 211 rump___sysimpl_unlink(const char * path) 212 { 213 register_t retval[2] = {0, 0}; 214 int error = 0; 215 int rv = -1; 216 struct sys_unlink_args callarg; 217 218 SPARG(&callarg, path) = path; 219 220 error = rsys_syscall(SYS_unlink, &callarg, sizeof(callarg), retval); 221 rsys_seterrno(error); 222 if (error == 0) { 223 if (sizeof(int) > sizeof(register_t)) 224 rv = *(int *)retval; 225 else 226 rv = *retval; 227 } 228 return rv; 229 } 230 rsys_define(rumpns_sys_unlink); 231 rsys_aliases(unlink,rump___sysimpl_unlink); 232 233 int rump___sysimpl_chdir(const char *); 234 int 235 rump___sysimpl_chdir(const char * path) 236 { 237 register_t retval[2] = {0, 0}; 238 int error = 0; 239 int rv = -1; 240 struct sys_chdir_args callarg; 241 242 SPARG(&callarg, path) = path; 243 244 error = rsys_syscall(SYS_chdir, &callarg, sizeof(callarg), retval); 245 rsys_seterrno(error); 246 if (error == 0) { 247 if (sizeof(int) > sizeof(register_t)) 248 rv = *(int *)retval; 249 else 250 rv = *retval; 251 } 252 return rv; 253 } 254 rsys_define(rumpns_sys_chdir); 255 rsys_aliases(chdir,rump___sysimpl_chdir); 256 257 int rump___sysimpl_fchdir(int); 258 int 259 rump___sysimpl_fchdir(int fd) 260 { 261 register_t retval[2] = {0, 0}; 262 int error = 0; 263 int rv = -1; 264 struct sys_fchdir_args callarg; 265 266 SPARG(&callarg, fd) = fd; 267 268 error = rsys_syscall(SYS_fchdir, &callarg, sizeof(callarg), retval); 269 rsys_seterrno(error); 270 if (error == 0) { 271 if (sizeof(int) > sizeof(register_t)) 272 rv = *(int *)retval; 273 else 274 rv = *retval; 275 } 276 return rv; 277 } 278 rsys_define(rumpns_sys_fchdir); 279 rsys_aliases(fchdir,rump___sysimpl_fchdir); 280 281 int rump___sysimpl_mknod(const char *, mode_t, uint32_t); 282 int 283 rump___sysimpl_mknod(const char * path, mode_t mode, uint32_t dev) 284 { 285 register_t retval[2] = {0, 0}; 286 int error = 0; 287 int rv = -1; 288 struct compat_50_sys_mknod_args callarg; 289 290 SPARG(&callarg, path) = path; 291 SPARG(&callarg, mode) = mode; 292 SPARG(&callarg, dev) = dev; 293 294 error = rsys_syscall(SYS_compat_50_mknod, &callarg, sizeof(callarg), retval); 295 rsys_seterrno(error); 296 if (error == 0) { 297 if (sizeof(int) > sizeof(register_t)) 298 rv = *(int *)retval; 299 else 300 rv = *retval; 301 } 302 return rv; 303 } 304 rsys_define(rumpns_compat_50_sys_mknod); 305 rsys_aliases(compat_50_mknod,rump___sysimpl_mknod); 306 307 int rump___sysimpl_chmod(const char *, mode_t); 308 int 309 rump___sysimpl_chmod(const char * path, mode_t mode) 310 { 311 register_t retval[2] = {0, 0}; 312 int error = 0; 313 int rv = -1; 314 struct sys_chmod_args callarg; 315 316 SPARG(&callarg, path) = path; 317 SPARG(&callarg, mode) = mode; 318 319 error = rsys_syscall(SYS_chmod, &callarg, sizeof(callarg), retval); 320 rsys_seterrno(error); 321 if (error == 0) { 322 if (sizeof(int) > sizeof(register_t)) 323 rv = *(int *)retval; 324 else 325 rv = *retval; 326 } 327 return rv; 328 } 329 rsys_define(rumpns_sys_chmod); 330 rsys_aliases(chmod,rump___sysimpl_chmod); 331 332 int rump___sysimpl_chown(const char *, uid_t, gid_t); 333 int 334 rump___sysimpl_chown(const char * path, uid_t uid, gid_t gid) 335 { 336 register_t retval[2] = {0, 0}; 337 int error = 0; 338 int rv = -1; 339 struct sys_chown_args callarg; 340 341 SPARG(&callarg, path) = path; 342 SPARG(&callarg, uid) = uid; 343 SPARG(&callarg, gid) = gid; 344 345 error = rsys_syscall(SYS_chown, &callarg, sizeof(callarg), retval); 346 rsys_seterrno(error); 347 if (error == 0) { 348 if (sizeof(int) > sizeof(register_t)) 349 rv = *(int *)retval; 350 else 351 rv = *retval; 352 } 353 return rv; 354 } 355 rsys_define(rumpns_sys_chown); 356 rsys_aliases(chown,rump___sysimpl_chown); 357 358 pid_t rump___sysimpl_getpid(void); 359 pid_t 360 rump___sysimpl_getpid(void ) 361 { 362 register_t retval[2] = {0, 0}; 363 pid_t rv = -1; 364 365 rsys_syscall(SYS_getpid, NULL, 0, retval); 366 if (sizeof(pid_t) > sizeof(register_t)) 367 rv = *(pid_t *)retval; 368 else 369 rv = *retval; 370 return rv; 371 } 372 rsys_define(rumpns_sys_getpid_with_ppid); 373 rsys_aliases(getpid,rump___sysimpl_getpid); 374 375 int rump___sysimpl_unmount(const char *, int); 376 int 377 rump___sysimpl_unmount(const char * path, int flags) 378 { 379 register_t retval[2] = {0, 0}; 380 int error = 0; 381 int rv = -1; 382 struct sys_unmount_args callarg; 383 384 SPARG(&callarg, path) = path; 385 SPARG(&callarg, flags) = flags; 386 387 error = rsys_syscall(SYS_unmount, &callarg, sizeof(callarg), retval); 388 rsys_seterrno(error); 389 if (error == 0) { 390 if (sizeof(int) > sizeof(register_t)) 391 rv = *(int *)retval; 392 else 393 rv = *retval; 394 } 395 return rv; 396 } 397 rsys_define(rumpns_sys_unmount); 398 rsys_aliases(unmount,rump___sysimpl_unmount); 399 400 int rump___sysimpl_setuid(uid_t); 401 int 402 rump___sysimpl_setuid(uid_t uid) 403 { 404 register_t retval[2] = {0, 0}; 405 int error = 0; 406 int rv = -1; 407 struct sys_setuid_args callarg; 408 409 SPARG(&callarg, uid) = uid; 410 411 error = rsys_syscall(SYS_setuid, &callarg, sizeof(callarg), retval); 412 rsys_seterrno(error); 413 if (error == 0) { 414 if (sizeof(int) > sizeof(register_t)) 415 rv = *(int *)retval; 416 else 417 rv = *retval; 418 } 419 return rv; 420 } 421 rsys_define(rumpns_sys_setuid); 422 rsys_aliases(setuid,rump___sysimpl_setuid); 423 424 uid_t rump___sysimpl_getuid(void); 425 uid_t 426 rump___sysimpl_getuid(void ) 427 { 428 register_t retval[2] = {0, 0}; 429 uid_t rv = -1; 430 431 rsys_syscall(SYS_getuid, NULL, 0, retval); 432 if (sizeof(uid_t) > sizeof(register_t)) 433 rv = *(uid_t *)retval; 434 else 435 rv = *retval; 436 return rv; 437 } 438 rsys_define(rumpns_sys_getuid_with_euid); 439 rsys_aliases(getuid,rump___sysimpl_getuid); 440 441 uid_t rump___sysimpl_geteuid(void); 442 uid_t 443 rump___sysimpl_geteuid(void ) 444 { 445 register_t retval[2] = {0, 0}; 446 uid_t rv = -1; 447 448 rsys_syscall(SYS_geteuid, NULL, 0, retval); 449 if (sizeof(uid_t) > sizeof(register_t)) 450 rv = *(uid_t *)retval; 451 else 452 rv = *retval; 453 return rv; 454 } 455 rsys_define(rumpns_sys_geteuid); 456 rsys_aliases(geteuid,rump___sysimpl_geteuid); 457 458 ssize_t rump___sysimpl_recvmsg(int, struct msghdr *, int); 459 ssize_t 460 rump___sysimpl_recvmsg(int s, struct msghdr * msg, int flags) 461 { 462 register_t retval[2] = {0, 0}; 463 int error = 0; 464 ssize_t rv = -1; 465 struct sys_recvmsg_args callarg; 466 467 SPARG(&callarg, s) = s; 468 SPARG(&callarg, msg) = msg; 469 SPARG(&callarg, flags) = flags; 470 471 error = rsys_syscall(SYS_recvmsg, &callarg, sizeof(callarg), retval); 472 rsys_seterrno(error); 473 if (error == 0) { 474 if (sizeof(ssize_t) > sizeof(register_t)) 475 rv = *(ssize_t *)retval; 476 else 477 rv = *retval; 478 } 479 return rv; 480 } 481 rsys_define(rumpns_sys_recvmsg); 482 rsys_aliases(recvmsg,rump___sysimpl_recvmsg); 483 484 ssize_t rump___sysimpl_sendmsg(int, const struct msghdr *, int); 485 ssize_t 486 rump___sysimpl_sendmsg(int s, const struct msghdr * msg, int flags) 487 { 488 register_t retval[2] = {0, 0}; 489 int error = 0; 490 ssize_t rv = -1; 491 struct sys_sendmsg_args callarg; 492 493 SPARG(&callarg, s) = s; 494 SPARG(&callarg, msg) = msg; 495 SPARG(&callarg, flags) = flags; 496 497 error = rsys_syscall(SYS_sendmsg, &callarg, sizeof(callarg), retval); 498 rsys_seterrno(error); 499 if (error == 0) { 500 if (sizeof(ssize_t) > sizeof(register_t)) 501 rv = *(ssize_t *)retval; 502 else 503 rv = *retval; 504 } 505 return rv; 506 } 507 rsys_define(rumpns_sys_sendmsg); 508 rsys_aliases(sendmsg,rump___sysimpl_sendmsg); 509 510 ssize_t rump___sysimpl_recvfrom(int, void *, size_t, int, struct sockaddr *, socklen_t *); 511 ssize_t 512 rump___sysimpl_recvfrom(int s, void * buf, size_t len, int flags, struct sockaddr * from, socklen_t * fromlenaddr) 513 { 514 register_t retval[2] = {0, 0}; 515 int error = 0; 516 ssize_t rv = -1; 517 struct sys_recvfrom_args callarg; 518 519 SPARG(&callarg, s) = s; 520 SPARG(&callarg, buf) = buf; 521 SPARG(&callarg, len) = len; 522 SPARG(&callarg, flags) = flags; 523 SPARG(&callarg, from) = from; 524 SPARG(&callarg, fromlenaddr) = fromlenaddr; 525 526 error = rsys_syscall(SYS_recvfrom, &callarg, sizeof(callarg), retval); 527 rsys_seterrno(error); 528 if (error == 0) { 529 if (sizeof(ssize_t) > sizeof(register_t)) 530 rv = *(ssize_t *)retval; 531 else 532 rv = *retval; 533 } 534 return rv; 535 } 536 rsys_define(rumpns_sys_recvfrom); 537 rsys_aliases(recvfrom,rump___sysimpl_recvfrom); 538 539 int rump___sysimpl_accept(int, struct sockaddr *, socklen_t *); 540 int 541 rump___sysimpl_accept(int s, struct sockaddr * name, socklen_t * anamelen) 542 { 543 register_t retval[2] = {0, 0}; 544 int error = 0; 545 int rv = -1; 546 struct sys_accept_args callarg; 547 548 SPARG(&callarg, s) = s; 549 SPARG(&callarg, name) = name; 550 SPARG(&callarg, anamelen) = anamelen; 551 552 error = rsys_syscall(SYS_accept, &callarg, sizeof(callarg), retval); 553 rsys_seterrno(error); 554 if (error == 0) { 555 if (sizeof(int) > sizeof(register_t)) 556 rv = *(int *)retval; 557 else 558 rv = *retval; 559 } 560 return rv; 561 } 562 rsys_define(rumpns_sys_accept); 563 rsys_aliases(accept,rump___sysimpl_accept); 564 565 int rump___sysimpl_getpeername(int, struct sockaddr *, socklen_t *); 566 int 567 rump___sysimpl_getpeername(int fdes, struct sockaddr * asa, socklen_t * alen) 568 { 569 register_t retval[2] = {0, 0}; 570 int error = 0; 571 int rv = -1; 572 struct sys_getpeername_args callarg; 573 574 SPARG(&callarg, fdes) = fdes; 575 SPARG(&callarg, asa) = asa; 576 SPARG(&callarg, alen) = alen; 577 578 error = rsys_syscall(SYS_getpeername, &callarg, sizeof(callarg), retval); 579 rsys_seterrno(error); 580 if (error == 0) { 581 if (sizeof(int) > sizeof(register_t)) 582 rv = *(int *)retval; 583 else 584 rv = *retval; 585 } 586 return rv; 587 } 588 rsys_define(rumpns_sys_getpeername); 589 rsys_aliases(getpeername,rump___sysimpl_getpeername); 590 591 int rump___sysimpl_getsockname(int, struct sockaddr *, socklen_t *); 592 int 593 rump___sysimpl_getsockname(int fdes, struct sockaddr * asa, socklen_t * alen) 594 { 595 register_t retval[2] = {0, 0}; 596 int error = 0; 597 int rv = -1; 598 struct sys_getsockname_args callarg; 599 600 SPARG(&callarg, fdes) = fdes; 601 SPARG(&callarg, asa) = asa; 602 SPARG(&callarg, alen) = alen; 603 604 error = rsys_syscall(SYS_getsockname, &callarg, sizeof(callarg), retval); 605 rsys_seterrno(error); 606 if (error == 0) { 607 if (sizeof(int) > sizeof(register_t)) 608 rv = *(int *)retval; 609 else 610 rv = *retval; 611 } 612 return rv; 613 } 614 rsys_define(rumpns_sys_getsockname); 615 rsys_aliases(getsockname,rump___sysimpl_getsockname); 616 617 int rump___sysimpl_access(const char *, int); 618 int 619 rump___sysimpl_access(const char * path, int flags) 620 { 621 register_t retval[2] = {0, 0}; 622 int error = 0; 623 int rv = -1; 624 struct sys_access_args callarg; 625 626 SPARG(&callarg, path) = path; 627 SPARG(&callarg, flags) = flags; 628 629 error = rsys_syscall(SYS_access, &callarg, sizeof(callarg), retval); 630 rsys_seterrno(error); 631 if (error == 0) { 632 if (sizeof(int) > sizeof(register_t)) 633 rv = *(int *)retval; 634 else 635 rv = *retval; 636 } 637 return rv; 638 } 639 rsys_define(rumpns_sys_access); 640 rsys_aliases(access,rump___sysimpl_access); 641 642 int rump___sysimpl_chflags(const char *, u_long); 643 int 644 rump___sysimpl_chflags(const char * path, u_long flags) 645 { 646 register_t retval[2] = {0, 0}; 647 int error = 0; 648 int rv = -1; 649 struct sys_chflags_args callarg; 650 651 SPARG(&callarg, path) = path; 652 SPARG(&callarg, flags) = flags; 653 654 error = rsys_syscall(SYS_chflags, &callarg, sizeof(callarg), retval); 655 rsys_seterrno(error); 656 if (error == 0) { 657 if (sizeof(int) > sizeof(register_t)) 658 rv = *(int *)retval; 659 else 660 rv = *retval; 661 } 662 return rv; 663 } 664 rsys_define(rumpns_sys_chflags); 665 rsys_aliases(chflags,rump___sysimpl_chflags); 666 667 int rump___sysimpl_fchflags(int, u_long); 668 int 669 rump___sysimpl_fchflags(int fd, u_long flags) 670 { 671 register_t retval[2] = {0, 0}; 672 int error = 0; 673 int rv = -1; 674 struct sys_fchflags_args callarg; 675 676 SPARG(&callarg, fd) = fd; 677 SPARG(&callarg, flags) = flags; 678 679 error = rsys_syscall(SYS_fchflags, &callarg, sizeof(callarg), retval); 680 rsys_seterrno(error); 681 if (error == 0) { 682 if (sizeof(int) > sizeof(register_t)) 683 rv = *(int *)retval; 684 else 685 rv = *retval; 686 } 687 return rv; 688 } 689 rsys_define(rumpns_sys_fchflags); 690 rsys_aliases(fchflags,rump___sysimpl_fchflags); 691 692 void rump___sysimpl_sync(void); 693 void 694 rump___sysimpl_sync(void ) 695 { 696 register_t retval[2] = {0, 0}; 697 698 rsys_syscall(SYS_sync, NULL, 0, retval); 699 } 700 rsys_define(rumpns_sys_sync); 701 rsys_aliases(sync,rump___sysimpl_sync); 702 703 pid_t rump___sysimpl_getppid(void); 704 pid_t 705 rump___sysimpl_getppid(void ) 706 { 707 register_t retval[2] = {0, 0}; 708 pid_t rv = -1; 709 710 rsys_syscall(SYS_getppid, NULL, 0, retval); 711 if (sizeof(pid_t) > sizeof(register_t)) 712 rv = *(pid_t *)retval; 713 else 714 rv = *retval; 715 return rv; 716 } 717 rsys_define(rumpns_sys_getppid); 718 rsys_aliases(getppid,rump___sysimpl_getppid); 719 720 int rump___sysimpl_dup(int); 721 int 722 rump___sysimpl_dup(int fd) 723 { 724 register_t retval[2] = {0, 0}; 725 int error = 0; 726 int rv = -1; 727 struct sys_dup_args callarg; 728 729 SPARG(&callarg, fd) = fd; 730 731 error = rsys_syscall(SYS_dup, &callarg, sizeof(callarg), retval); 732 rsys_seterrno(error); 733 if (error == 0) { 734 if (sizeof(int) > sizeof(register_t)) 735 rv = *(int *)retval; 736 else 737 rv = *retval; 738 } 739 return rv; 740 } 741 rsys_define(rumpns_sys_dup); 742 rsys_aliases(dup,rump___sysimpl_dup); 743 744 gid_t rump___sysimpl_getegid(void); 745 gid_t 746 rump___sysimpl_getegid(void ) 747 { 748 register_t retval[2] = {0, 0}; 749 gid_t rv = -1; 750 751 rsys_syscall(SYS_getegid, NULL, 0, retval); 752 if (sizeof(gid_t) > sizeof(register_t)) 753 rv = *(gid_t *)retval; 754 else 755 rv = *retval; 756 return rv; 757 } 758 rsys_define(rumpns_sys_getegid); 759 rsys_aliases(getegid,rump___sysimpl_getegid); 760 761 gid_t rump___sysimpl_getgid(void); 762 gid_t 763 rump___sysimpl_getgid(void ) 764 { 765 register_t retval[2] = {0, 0}; 766 gid_t rv = -1; 767 768 rsys_syscall(SYS_getgid, NULL, 0, retval); 769 if (sizeof(gid_t) > sizeof(register_t)) 770 rv = *(gid_t *)retval; 771 else 772 rv = *retval; 773 return rv; 774 } 775 rsys_define(rumpns_sys_getgid_with_egid); 776 rsys_aliases(getgid,rump___sysimpl_getgid); 777 778 int rump___sysimpl___getlogin(char *, size_t); 779 int 780 rump___sysimpl___getlogin(char * namebuf, size_t namelen) 781 { 782 register_t retval[2] = {0, 0}; 783 int error = 0; 784 int rv = -1; 785 struct sys___getlogin_args callarg; 786 787 SPARG(&callarg, namebuf) = namebuf; 788 SPARG(&callarg, namelen) = namelen; 789 790 error = rsys_syscall(SYS___getlogin, &callarg, sizeof(callarg), retval); 791 rsys_seterrno(error); 792 if (error == 0) { 793 if (sizeof(int) > sizeof(register_t)) 794 rv = *(int *)retval; 795 else 796 rv = *retval; 797 } 798 return rv; 799 } 800 rsys_define(rumpns_sys___getlogin); 801 rsys_aliases(__getlogin,rump___sysimpl___getlogin); 802 803 int rump___sysimpl___setlogin(const char *); 804 int 805 rump___sysimpl___setlogin(const char * namebuf) 806 { 807 register_t retval[2] = {0, 0}; 808 int error = 0; 809 int rv = -1; 810 struct sys___setlogin_args callarg; 811 812 SPARG(&callarg, namebuf) = namebuf; 813 814 error = rsys_syscall(SYS___setlogin, &callarg, sizeof(callarg), retval); 815 rsys_seterrno(error); 816 if (error == 0) { 817 if (sizeof(int) > sizeof(register_t)) 818 rv = *(int *)retval; 819 else 820 rv = *retval; 821 } 822 return rv; 823 } 824 rsys_define(rumpns_sys___setlogin); 825 rsys_aliases(__setlogin,rump___sysimpl___setlogin); 826 827 int rump___sysimpl_ioctl(int, u_long, void *); 828 int 829 rump___sysimpl_ioctl(int fd, u_long com, void * data) 830 { 831 register_t retval[2] = {0, 0}; 832 int error = 0; 833 int rv = -1; 834 struct sys_ioctl_args callarg; 835 836 SPARG(&callarg, fd) = fd; 837 SPARG(&callarg, com) = com; 838 SPARG(&callarg, data) = data; 839 840 error = rsys_syscall(SYS_ioctl, &callarg, sizeof(callarg), retval); 841 rsys_seterrno(error); 842 if (error == 0) { 843 if (sizeof(int) > sizeof(register_t)) 844 rv = *(int *)retval; 845 else 846 rv = *retval; 847 } 848 return rv; 849 } 850 rsys_define(rumpns_sys_ioctl); 851 rsys_aliases(ioctl,rump___sysimpl_ioctl); 852 853 int rump___sysimpl_revoke(const char *); 854 int 855 rump___sysimpl_revoke(const char * path) 856 { 857 register_t retval[2] = {0, 0}; 858 int error = 0; 859 int rv = -1; 860 struct sys_revoke_args callarg; 861 862 SPARG(&callarg, path) = path; 863 864 error = rsys_syscall(SYS_revoke, &callarg, sizeof(callarg), retval); 865 rsys_seterrno(error); 866 if (error == 0) { 867 if (sizeof(int) > sizeof(register_t)) 868 rv = *(int *)retval; 869 else 870 rv = *retval; 871 } 872 return rv; 873 } 874 rsys_define(rumpns_sys_revoke); 875 rsys_aliases(revoke,rump___sysimpl_revoke); 876 877 int rump___sysimpl_symlink(const char *, const char *); 878 int 879 rump___sysimpl_symlink(const char * path, const char * link) 880 { 881 register_t retval[2] = {0, 0}; 882 int error = 0; 883 int rv = -1; 884 struct sys_symlink_args callarg; 885 886 SPARG(&callarg, path) = path; 887 SPARG(&callarg, link) = link; 888 889 error = rsys_syscall(SYS_symlink, &callarg, sizeof(callarg), retval); 890 rsys_seterrno(error); 891 if (error == 0) { 892 if (sizeof(int) > sizeof(register_t)) 893 rv = *(int *)retval; 894 else 895 rv = *retval; 896 } 897 return rv; 898 } 899 rsys_define(rumpns_sys_symlink); 900 rsys_aliases(symlink,rump___sysimpl_symlink); 901 902 ssize_t rump___sysimpl_readlink(const char *, char *, size_t); 903 ssize_t 904 rump___sysimpl_readlink(const char * path, char * buf, size_t count) 905 { 906 register_t retval[2] = {0, 0}; 907 int error = 0; 908 ssize_t rv = -1; 909 struct sys_readlink_args callarg; 910 911 SPARG(&callarg, path) = path; 912 SPARG(&callarg, buf) = buf; 913 SPARG(&callarg, count) = count; 914 915 error = rsys_syscall(SYS_readlink, &callarg, sizeof(callarg), retval); 916 rsys_seterrno(error); 917 if (error == 0) { 918 if (sizeof(ssize_t) > sizeof(register_t)) 919 rv = *(ssize_t *)retval; 920 else 921 rv = *retval; 922 } 923 return rv; 924 } 925 rsys_define(rumpns_sys_readlink); 926 rsys_aliases(readlink,rump___sysimpl_readlink); 927 928 mode_t rump___sysimpl_umask(mode_t); 929 mode_t 930 rump___sysimpl_umask(mode_t newmask) 931 { 932 register_t retval[2] = {0, 0}; 933 int error = 0; 934 mode_t rv = -1; 935 struct sys_umask_args callarg; 936 937 SPARG(&callarg, newmask) = newmask; 938 939 error = rsys_syscall(SYS_umask, &callarg, sizeof(callarg), retval); 940 rsys_seterrno(error); 941 if (error == 0) { 942 if (sizeof(mode_t) > sizeof(register_t)) 943 rv = *(mode_t *)retval; 944 else 945 rv = *retval; 946 } 947 return rv; 948 } 949 rsys_define(rumpns_sys_umask); 950 rsys_aliases(umask,rump___sysimpl_umask); 951 952 int rump___sysimpl_chroot(const char *); 953 int 954 rump___sysimpl_chroot(const char * path) 955 { 956 register_t retval[2] = {0, 0}; 957 int error = 0; 958 int rv = -1; 959 struct sys_chroot_args callarg; 960 961 SPARG(&callarg, path) = path; 962 963 error = rsys_syscall(SYS_chroot, &callarg, sizeof(callarg), retval); 964 rsys_seterrno(error); 965 if (error == 0) { 966 if (sizeof(int) > sizeof(register_t)) 967 rv = *(int *)retval; 968 else 969 rv = *retval; 970 } 971 return rv; 972 } 973 rsys_define(rumpns_sys_chroot); 974 rsys_aliases(chroot,rump___sysimpl_chroot); 975 976 int rump___sysimpl_getgroups(int, gid_t *); 977 int 978 rump___sysimpl_getgroups(int gidsetsize, gid_t * gidset) 979 { 980 register_t retval[2] = {0, 0}; 981 int error = 0; 982 int rv = -1; 983 struct sys_getgroups_args callarg; 984 985 SPARG(&callarg, gidsetsize) = gidsetsize; 986 SPARG(&callarg, gidset) = gidset; 987 988 error = rsys_syscall(SYS_getgroups, &callarg, sizeof(callarg), retval); 989 rsys_seterrno(error); 990 if (error == 0) { 991 if (sizeof(int) > sizeof(register_t)) 992 rv = *(int *)retval; 993 else 994 rv = *retval; 995 } 996 return rv; 997 } 998 rsys_define(rumpns_sys_getgroups); 999 rsys_aliases(getgroups,rump___sysimpl_getgroups); 1000 1001 int rump___sysimpl_setgroups(int, const gid_t *); 1002 int 1003 rump___sysimpl_setgroups(int gidsetsize, const gid_t * gidset) 1004 { 1005 register_t retval[2] = {0, 0}; 1006 int error = 0; 1007 int rv = -1; 1008 struct sys_setgroups_args callarg; 1009 1010 SPARG(&callarg, gidsetsize) = gidsetsize; 1011 SPARG(&callarg, gidset) = gidset; 1012 1013 error = rsys_syscall(SYS_setgroups, &callarg, sizeof(callarg), retval); 1014 rsys_seterrno(error); 1015 if (error == 0) { 1016 if (sizeof(int) > sizeof(register_t)) 1017 rv = *(int *)retval; 1018 else 1019 rv = *retval; 1020 } 1021 return rv; 1022 } 1023 rsys_define(rumpns_sys_setgroups); 1024 rsys_aliases(setgroups,rump___sysimpl_setgroups); 1025 1026 int rump___sysimpl_getpgrp(void); 1027 int 1028 rump___sysimpl_getpgrp(void ) 1029 { 1030 register_t retval[2] = {0, 0}; 1031 int error = 0; 1032 int rv = -1; 1033 1034 error = rsys_syscall(SYS_getpgrp, NULL, 0, retval); 1035 rsys_seterrno(error); 1036 if (error == 0) { 1037 if (sizeof(int) > sizeof(register_t)) 1038 rv = *(int *)retval; 1039 else 1040 rv = *retval; 1041 } 1042 return rv; 1043 } 1044 rsys_define(rumpns_sys_getpgrp); 1045 rsys_aliases(getpgrp,rump___sysimpl_getpgrp); 1046 1047 int rump___sysimpl_setpgid(pid_t, pid_t); 1048 int 1049 rump___sysimpl_setpgid(pid_t pid, pid_t pgid) 1050 { 1051 register_t retval[2] = {0, 0}; 1052 int error = 0; 1053 int rv = -1; 1054 struct sys_setpgid_args callarg; 1055 1056 SPARG(&callarg, pid) = pid; 1057 SPARG(&callarg, pgid) = pgid; 1058 1059 error = rsys_syscall(SYS_setpgid, &callarg, sizeof(callarg), retval); 1060 rsys_seterrno(error); 1061 if (error == 0) { 1062 if (sizeof(int) > sizeof(register_t)) 1063 rv = *(int *)retval; 1064 else 1065 rv = *retval; 1066 } 1067 return rv; 1068 } 1069 rsys_define(rumpns_sys_setpgid); 1070 rsys_aliases(setpgid,rump___sysimpl_setpgid); 1071 1072 int rump___sysimpl_dup2(int, int); 1073 int 1074 rump___sysimpl_dup2(int from, int to) 1075 { 1076 register_t retval[2] = {0, 0}; 1077 int error = 0; 1078 int rv = -1; 1079 struct sys_dup2_args callarg; 1080 1081 SPARG(&callarg, from) = from; 1082 SPARG(&callarg, to) = to; 1083 1084 error = rsys_syscall(SYS_dup2, &callarg, sizeof(callarg), retval); 1085 rsys_seterrno(error); 1086 if (error == 0) { 1087 if (sizeof(int) > sizeof(register_t)) 1088 rv = *(int *)retval; 1089 else 1090 rv = *retval; 1091 } 1092 return rv; 1093 } 1094 rsys_define(rumpns_sys_dup2); 1095 rsys_aliases(dup2,rump___sysimpl_dup2); 1096 1097 int rump___sysimpl_fcntl(int, int, void *); 1098 int 1099 rump___sysimpl_fcntl(int fd, int cmd, void * arg) 1100 { 1101 register_t retval[2] = {0, 0}; 1102 int error = 0; 1103 int rv = -1; 1104 struct sys_fcntl_args callarg; 1105 1106 SPARG(&callarg, fd) = fd; 1107 SPARG(&callarg, cmd) = cmd; 1108 SPARG(&callarg, arg) = arg; 1109 1110 error = rsys_syscall(SYS_fcntl, &callarg, sizeof(callarg), retval); 1111 rsys_seterrno(error); 1112 if (error == 0) { 1113 if (sizeof(int) > sizeof(register_t)) 1114 rv = *(int *)retval; 1115 else 1116 rv = *retval; 1117 } 1118 return rv; 1119 } 1120 rsys_define(rumpns_sys_fcntl); 1121 rsys_aliases(fcntl,rump___sysimpl_fcntl); 1122 1123 int rump___sysimpl_select(int, fd_set *, fd_set *, fd_set *, struct timeval *); 1124 int 1125 rump___sysimpl_select(int nd, fd_set * in, fd_set * ou, fd_set * ex, struct timeval * tv) 1126 { 1127 register_t retval[2] = {0, 0}; 1128 int error = 0; 1129 int rv = -1; 1130 struct compat_50_sys_select_args callarg; 1131 1132 SPARG(&callarg, nd) = nd; 1133 SPARG(&callarg, in) = in; 1134 SPARG(&callarg, ou) = ou; 1135 SPARG(&callarg, ex) = ex; 1136 SPARG(&callarg, tv) = (struct timeval50 *)tv; 1137 1138 error = rsys_syscall(SYS_compat_50_select, &callarg, sizeof(callarg), retval); 1139 rsys_seterrno(error); 1140 if (error == 0) { 1141 if (sizeof(int) > sizeof(register_t)) 1142 rv = *(int *)retval; 1143 else 1144 rv = *retval; 1145 } 1146 return rv; 1147 } 1148 rsys_define(rumpns_compat_50_sys_select); 1149 rsys_aliases(compat_50_select,rump___sysimpl_select); 1150 1151 int rump___sysimpl_fsync(int); 1152 int 1153 rump___sysimpl_fsync(int fd) 1154 { 1155 register_t retval[2] = {0, 0}; 1156 int error = 0; 1157 int rv = -1; 1158 struct sys_fsync_args callarg; 1159 1160 SPARG(&callarg, fd) = fd; 1161 1162 error = rsys_syscall(SYS_fsync, &callarg, sizeof(callarg), retval); 1163 rsys_seterrno(error); 1164 if (error == 0) { 1165 if (sizeof(int) > sizeof(register_t)) 1166 rv = *(int *)retval; 1167 else 1168 rv = *retval; 1169 } 1170 return rv; 1171 } 1172 rsys_define(rumpns_sys_fsync); 1173 rsys_aliases(fsync,rump___sysimpl_fsync); 1174 1175 int rump___sysimpl_connect(int, const struct sockaddr *, socklen_t); 1176 int 1177 rump___sysimpl_connect(int s, const struct sockaddr * name, socklen_t namelen) 1178 { 1179 register_t retval[2] = {0, 0}; 1180 int error = 0; 1181 int rv = -1; 1182 struct sys_connect_args callarg; 1183 1184 SPARG(&callarg, s) = s; 1185 SPARG(&callarg, name) = name; 1186 SPARG(&callarg, namelen) = namelen; 1187 1188 error = rsys_syscall(SYS_connect, &callarg, sizeof(callarg), retval); 1189 rsys_seterrno(error); 1190 if (error == 0) { 1191 if (sizeof(int) > sizeof(register_t)) 1192 rv = *(int *)retval; 1193 else 1194 rv = *retval; 1195 } 1196 return rv; 1197 } 1198 rsys_define(rumpns_sys_connect); 1199 rsys_aliases(connect,rump___sysimpl_connect); 1200 1201 int rump___sysimpl_bind(int, const struct sockaddr *, socklen_t); 1202 int 1203 rump___sysimpl_bind(int s, const struct sockaddr * name, socklen_t namelen) 1204 { 1205 register_t retval[2] = {0, 0}; 1206 int error = 0; 1207 int rv = -1; 1208 struct sys_bind_args callarg; 1209 1210 SPARG(&callarg, s) = s; 1211 SPARG(&callarg, name) = name; 1212 SPARG(&callarg, namelen) = namelen; 1213 1214 error = rsys_syscall(SYS_bind, &callarg, sizeof(callarg), retval); 1215 rsys_seterrno(error); 1216 if (error == 0) { 1217 if (sizeof(int) > sizeof(register_t)) 1218 rv = *(int *)retval; 1219 else 1220 rv = *retval; 1221 } 1222 return rv; 1223 } 1224 rsys_define(rumpns_sys_bind); 1225 rsys_aliases(bind,rump___sysimpl_bind); 1226 1227 int rump___sysimpl_setsockopt(int, int, int, const void *, socklen_t); 1228 int 1229 rump___sysimpl_setsockopt(int s, int level, int name, const void * val, socklen_t valsize) 1230 { 1231 register_t retval[2] = {0, 0}; 1232 int error = 0; 1233 int rv = -1; 1234 struct sys_setsockopt_args callarg; 1235 1236 SPARG(&callarg, s) = s; 1237 SPARG(&callarg, level) = level; 1238 SPARG(&callarg, name) = name; 1239 SPARG(&callarg, val) = val; 1240 SPARG(&callarg, valsize) = valsize; 1241 1242 error = rsys_syscall(SYS_setsockopt, &callarg, sizeof(callarg), retval); 1243 rsys_seterrno(error); 1244 if (error == 0) { 1245 if (sizeof(int) > sizeof(register_t)) 1246 rv = *(int *)retval; 1247 else 1248 rv = *retval; 1249 } 1250 return rv; 1251 } 1252 rsys_define(rumpns_sys_setsockopt); 1253 rsys_aliases(setsockopt,rump___sysimpl_setsockopt); 1254 1255 int rump___sysimpl_listen(int, int); 1256 int 1257 rump___sysimpl_listen(int s, int backlog) 1258 { 1259 register_t retval[2] = {0, 0}; 1260 int error = 0; 1261 int rv = -1; 1262 struct sys_listen_args callarg; 1263 1264 SPARG(&callarg, s) = s; 1265 SPARG(&callarg, backlog) = backlog; 1266 1267 error = rsys_syscall(SYS_listen, &callarg, sizeof(callarg), retval); 1268 rsys_seterrno(error); 1269 if (error == 0) { 1270 if (sizeof(int) > sizeof(register_t)) 1271 rv = *(int *)retval; 1272 else 1273 rv = *retval; 1274 } 1275 return rv; 1276 } 1277 rsys_define(rumpns_sys_listen); 1278 rsys_aliases(listen,rump___sysimpl_listen); 1279 1280 int rump___sysimpl_getsockopt(int, int, int, void *, socklen_t *); 1281 int 1282 rump___sysimpl_getsockopt(int s, int level, int name, void * val, socklen_t * avalsize) 1283 { 1284 register_t retval[2] = {0, 0}; 1285 int error = 0; 1286 int rv = -1; 1287 struct sys_getsockopt_args callarg; 1288 1289 SPARG(&callarg, s) = s; 1290 SPARG(&callarg, level) = level; 1291 SPARG(&callarg, name) = name; 1292 SPARG(&callarg, val) = val; 1293 SPARG(&callarg, avalsize) = avalsize; 1294 1295 error = rsys_syscall(SYS_getsockopt, &callarg, sizeof(callarg), retval); 1296 rsys_seterrno(error); 1297 if (error == 0) { 1298 if (sizeof(int) > sizeof(register_t)) 1299 rv = *(int *)retval; 1300 else 1301 rv = *retval; 1302 } 1303 return rv; 1304 } 1305 rsys_define(rumpns_sys_getsockopt); 1306 rsys_aliases(getsockopt,rump___sysimpl_getsockopt); 1307 1308 ssize_t rump___sysimpl_readv(int, const struct iovec *, int); 1309 ssize_t 1310 rump___sysimpl_readv(int fd, const struct iovec * iovp, int iovcnt) 1311 { 1312 register_t retval[2] = {0, 0}; 1313 int error = 0; 1314 ssize_t rv = -1; 1315 struct sys_readv_args callarg; 1316 1317 SPARG(&callarg, fd) = fd; 1318 SPARG(&callarg, iovp) = iovp; 1319 SPARG(&callarg, iovcnt) = iovcnt; 1320 1321 error = rsys_syscall(SYS_readv, &callarg, sizeof(callarg), retval); 1322 rsys_seterrno(error); 1323 if (error == 0) { 1324 if (sizeof(ssize_t) > sizeof(register_t)) 1325 rv = *(ssize_t *)retval; 1326 else 1327 rv = *retval; 1328 } 1329 return rv; 1330 } 1331 rsys_define(rumpns_sys_readv); 1332 rsys_aliases(readv,rump___sysimpl_readv); 1333 1334 ssize_t rump___sysimpl_writev(int, const struct iovec *, int); 1335 ssize_t 1336 rump___sysimpl_writev(int fd, const struct iovec * iovp, int iovcnt) 1337 { 1338 register_t retval[2] = {0, 0}; 1339 int error = 0; 1340 ssize_t rv = -1; 1341 struct sys_writev_args callarg; 1342 1343 SPARG(&callarg, fd) = fd; 1344 SPARG(&callarg, iovp) = iovp; 1345 SPARG(&callarg, iovcnt) = iovcnt; 1346 1347 error = rsys_syscall(SYS_writev, &callarg, sizeof(callarg), retval); 1348 rsys_seterrno(error); 1349 if (error == 0) { 1350 if (sizeof(ssize_t) > sizeof(register_t)) 1351 rv = *(ssize_t *)retval; 1352 else 1353 rv = *retval; 1354 } 1355 return rv; 1356 } 1357 rsys_define(rumpns_sys_writev); 1358 rsys_aliases(writev,rump___sysimpl_writev); 1359 1360 int rump___sysimpl_fchown(int, uid_t, gid_t); 1361 int 1362 rump___sysimpl_fchown(int fd, uid_t uid, gid_t gid) 1363 { 1364 register_t retval[2] = {0, 0}; 1365 int error = 0; 1366 int rv = -1; 1367 struct sys_fchown_args callarg; 1368 1369 SPARG(&callarg, fd) = fd; 1370 SPARG(&callarg, uid) = uid; 1371 SPARG(&callarg, gid) = gid; 1372 1373 error = rsys_syscall(SYS_fchown, &callarg, sizeof(callarg), retval); 1374 rsys_seterrno(error); 1375 if (error == 0) { 1376 if (sizeof(int) > sizeof(register_t)) 1377 rv = *(int *)retval; 1378 else 1379 rv = *retval; 1380 } 1381 return rv; 1382 } 1383 rsys_define(rumpns_sys_fchown); 1384 rsys_aliases(fchown,rump___sysimpl_fchown); 1385 1386 int rump___sysimpl_fchmod(int, mode_t); 1387 int 1388 rump___sysimpl_fchmod(int fd, mode_t mode) 1389 { 1390 register_t retval[2] = {0, 0}; 1391 int error = 0; 1392 int rv = -1; 1393 struct sys_fchmod_args callarg; 1394 1395 SPARG(&callarg, fd) = fd; 1396 SPARG(&callarg, mode) = mode; 1397 1398 error = rsys_syscall(SYS_fchmod, &callarg, sizeof(callarg), retval); 1399 rsys_seterrno(error); 1400 if (error == 0) { 1401 if (sizeof(int) > sizeof(register_t)) 1402 rv = *(int *)retval; 1403 else 1404 rv = *retval; 1405 } 1406 return rv; 1407 } 1408 rsys_define(rumpns_sys_fchmod); 1409 rsys_aliases(fchmod,rump___sysimpl_fchmod); 1410 1411 int rump___sysimpl_setreuid(uid_t, uid_t); 1412 int 1413 rump___sysimpl_setreuid(uid_t ruid, uid_t euid) 1414 { 1415 register_t retval[2] = {0, 0}; 1416 int error = 0; 1417 int rv = -1; 1418 struct sys_setreuid_args callarg; 1419 1420 SPARG(&callarg, ruid) = ruid; 1421 SPARG(&callarg, euid) = euid; 1422 1423 error = rsys_syscall(SYS_setreuid, &callarg, sizeof(callarg), retval); 1424 rsys_seterrno(error); 1425 if (error == 0) { 1426 if (sizeof(int) > sizeof(register_t)) 1427 rv = *(int *)retval; 1428 else 1429 rv = *retval; 1430 } 1431 return rv; 1432 } 1433 rsys_define(rumpns_sys_setreuid); 1434 rsys_aliases(setreuid,rump___sysimpl_setreuid); 1435 1436 int rump___sysimpl_setregid(gid_t, gid_t); 1437 int 1438 rump___sysimpl_setregid(gid_t rgid, gid_t egid) 1439 { 1440 register_t retval[2] = {0, 0}; 1441 int error = 0; 1442 int rv = -1; 1443 struct sys_setregid_args callarg; 1444 1445 SPARG(&callarg, rgid) = rgid; 1446 SPARG(&callarg, egid) = egid; 1447 1448 error = rsys_syscall(SYS_setregid, &callarg, sizeof(callarg), retval); 1449 rsys_seterrno(error); 1450 if (error == 0) { 1451 if (sizeof(int) > sizeof(register_t)) 1452 rv = *(int *)retval; 1453 else 1454 rv = *retval; 1455 } 1456 return rv; 1457 } 1458 rsys_define(rumpns_sys_setregid); 1459 rsys_aliases(setregid,rump___sysimpl_setregid); 1460 1461 int rump___sysimpl_rename(const char *, const char *); 1462 int 1463 rump___sysimpl_rename(const char * from, const char * to) 1464 { 1465 register_t retval[2] = {0, 0}; 1466 int error = 0; 1467 int rv = -1; 1468 struct sys_rename_args callarg; 1469 1470 SPARG(&callarg, from) = from; 1471 SPARG(&callarg, to) = to; 1472 1473 error = rsys_syscall(SYS_rename, &callarg, sizeof(callarg), retval); 1474 rsys_seterrno(error); 1475 if (error == 0) { 1476 if (sizeof(int) > sizeof(register_t)) 1477 rv = *(int *)retval; 1478 else 1479 rv = *retval; 1480 } 1481 return rv; 1482 } 1483 rsys_define(rumpns_sys_rename); 1484 rsys_aliases(rename,rump___sysimpl_rename); 1485 1486 int rump___sysimpl_flock(int, int); 1487 int 1488 rump___sysimpl_flock(int fd, int how) 1489 { 1490 register_t retval[2] = {0, 0}; 1491 int error = 0; 1492 int rv = -1; 1493 struct sys_flock_args callarg; 1494 1495 SPARG(&callarg, fd) = fd; 1496 SPARG(&callarg, how) = how; 1497 1498 error = rsys_syscall(SYS_flock, &callarg, sizeof(callarg), retval); 1499 rsys_seterrno(error); 1500 if (error == 0) { 1501 if (sizeof(int) > sizeof(register_t)) 1502 rv = *(int *)retval; 1503 else 1504 rv = *retval; 1505 } 1506 return rv; 1507 } 1508 rsys_define(rumpns_sys_flock); 1509 rsys_aliases(flock,rump___sysimpl_flock); 1510 1511 int rump___sysimpl_mkfifo(const char *, mode_t); 1512 int 1513 rump___sysimpl_mkfifo(const char * path, mode_t mode) 1514 { 1515 register_t retval[2] = {0, 0}; 1516 int error = 0; 1517 int rv = -1; 1518 struct sys_mkfifo_args callarg; 1519 1520 SPARG(&callarg, path) = path; 1521 SPARG(&callarg, mode) = mode; 1522 1523 error = rsys_syscall(SYS_mkfifo, &callarg, sizeof(callarg), retval); 1524 rsys_seterrno(error); 1525 if (error == 0) { 1526 if (sizeof(int) > sizeof(register_t)) 1527 rv = *(int *)retval; 1528 else 1529 rv = *retval; 1530 } 1531 return rv; 1532 } 1533 rsys_define(rumpns_sys_mkfifo); 1534 rsys_aliases(mkfifo,rump___sysimpl_mkfifo); 1535 1536 ssize_t rump___sysimpl_sendto(int, const void *, size_t, int, const struct sockaddr *, socklen_t); 1537 ssize_t 1538 rump___sysimpl_sendto(int s, const void * buf, size_t len, int flags, const struct sockaddr * to, socklen_t tolen) 1539 { 1540 register_t retval[2] = {0, 0}; 1541 int error = 0; 1542 ssize_t rv = -1; 1543 struct sys_sendto_args callarg; 1544 1545 SPARG(&callarg, s) = s; 1546 SPARG(&callarg, buf) = buf; 1547 SPARG(&callarg, len) = len; 1548 SPARG(&callarg, flags) = flags; 1549 SPARG(&callarg, to) = to; 1550 SPARG(&callarg, tolen) = tolen; 1551 1552 error = rsys_syscall(SYS_sendto, &callarg, sizeof(callarg), retval); 1553 rsys_seterrno(error); 1554 if (error == 0) { 1555 if (sizeof(ssize_t) > sizeof(register_t)) 1556 rv = *(ssize_t *)retval; 1557 else 1558 rv = *retval; 1559 } 1560 return rv; 1561 } 1562 rsys_define(rumpns_sys_sendto); 1563 rsys_aliases(sendto,rump___sysimpl_sendto); 1564 1565 int rump___sysimpl_shutdown(int, int); 1566 int 1567 rump___sysimpl_shutdown(int s, int how) 1568 { 1569 register_t retval[2] = {0, 0}; 1570 int error = 0; 1571 int rv = -1; 1572 struct sys_shutdown_args callarg; 1573 1574 SPARG(&callarg, s) = s; 1575 SPARG(&callarg, how) = how; 1576 1577 error = rsys_syscall(SYS_shutdown, &callarg, sizeof(callarg), retval); 1578 rsys_seterrno(error); 1579 if (error == 0) { 1580 if (sizeof(int) > sizeof(register_t)) 1581 rv = *(int *)retval; 1582 else 1583 rv = *retval; 1584 } 1585 return rv; 1586 } 1587 rsys_define(rumpns_sys_shutdown); 1588 rsys_aliases(shutdown,rump___sysimpl_shutdown); 1589 1590 int rump___sysimpl_socketpair(int, int, int, int *); 1591 int 1592 rump___sysimpl_socketpair(int domain, int type, int protocol, int * rsv) 1593 { 1594 register_t retval[2] = {0, 0}; 1595 int error = 0; 1596 int rv = -1; 1597 struct sys_socketpair_args callarg; 1598 1599 SPARG(&callarg, domain) = domain; 1600 SPARG(&callarg, type) = type; 1601 SPARG(&callarg, protocol) = protocol; 1602 SPARG(&callarg, rsv) = rsv; 1603 1604 error = rsys_syscall(SYS_socketpair, &callarg, sizeof(callarg), retval); 1605 rsys_seterrno(error); 1606 if (error == 0) { 1607 if (sizeof(int) > sizeof(register_t)) 1608 rv = *(int *)retval; 1609 else 1610 rv = *retval; 1611 } 1612 return rv; 1613 } 1614 rsys_define(rumpns_sys_socketpair); 1615 rsys_aliases(socketpair,rump___sysimpl_socketpair); 1616 1617 int rump___sysimpl_mkdir(const char *, mode_t); 1618 int 1619 rump___sysimpl_mkdir(const char * path, mode_t mode) 1620 { 1621 register_t retval[2] = {0, 0}; 1622 int error = 0; 1623 int rv = -1; 1624 struct sys_mkdir_args callarg; 1625 1626 SPARG(&callarg, path) = path; 1627 SPARG(&callarg, mode) = mode; 1628 1629 error = rsys_syscall(SYS_mkdir, &callarg, sizeof(callarg), retval); 1630 rsys_seterrno(error); 1631 if (error == 0) { 1632 if (sizeof(int) > sizeof(register_t)) 1633 rv = *(int *)retval; 1634 else 1635 rv = *retval; 1636 } 1637 return rv; 1638 } 1639 rsys_define(rumpns_sys_mkdir); 1640 rsys_aliases(mkdir,rump___sysimpl_mkdir); 1641 1642 int rump___sysimpl_rmdir(const char *); 1643 int 1644 rump___sysimpl_rmdir(const char * path) 1645 { 1646 register_t retval[2] = {0, 0}; 1647 int error = 0; 1648 int rv = -1; 1649 struct sys_rmdir_args callarg; 1650 1651 SPARG(&callarg, path) = path; 1652 1653 error = rsys_syscall(SYS_rmdir, &callarg, sizeof(callarg), retval); 1654 rsys_seterrno(error); 1655 if (error == 0) { 1656 if (sizeof(int) > sizeof(register_t)) 1657 rv = *(int *)retval; 1658 else 1659 rv = *retval; 1660 } 1661 return rv; 1662 } 1663 rsys_define(rumpns_sys_rmdir); 1664 rsys_aliases(rmdir,rump___sysimpl_rmdir); 1665 1666 int rump___sysimpl_utimes(const char *, const struct timeval *); 1667 int 1668 rump___sysimpl_utimes(const char * path, const struct timeval * tptr) 1669 { 1670 register_t retval[2] = {0, 0}; 1671 int error = 0; 1672 int rv = -1; 1673 struct compat_50_sys_utimes_args callarg; 1674 1675 SPARG(&callarg, path) = path; 1676 SPARG(&callarg, tptr) = (const struct timeval50 *)tptr; 1677 1678 error = rsys_syscall(SYS_compat_50_utimes, &callarg, sizeof(callarg), retval); 1679 rsys_seterrno(error); 1680 if (error == 0) { 1681 if (sizeof(int) > sizeof(register_t)) 1682 rv = *(int *)retval; 1683 else 1684 rv = *retval; 1685 } 1686 return rv; 1687 } 1688 rsys_define(rumpns_compat_50_sys_utimes); 1689 rsys_aliases(compat_50_utimes,rump___sysimpl_utimes); 1690 1691 int rump___sysimpl_setsid(void); 1692 int 1693 rump___sysimpl_setsid(void ) 1694 { 1695 register_t retval[2] = {0, 0}; 1696 int error = 0; 1697 int rv = -1; 1698 1699 error = rsys_syscall(SYS_setsid, NULL, 0, retval); 1700 rsys_seterrno(error); 1701 if (error == 0) { 1702 if (sizeof(int) > sizeof(register_t)) 1703 rv = *(int *)retval; 1704 else 1705 rv = *retval; 1706 } 1707 return rv; 1708 } 1709 rsys_define(rumpns_sys_setsid); 1710 rsys_aliases(setsid,rump___sysimpl_setsid); 1711 1712 int rump___sysimpl_nfssvc(int, void *); 1713 int 1714 rump___sysimpl_nfssvc(int flag, void * argp) 1715 { 1716 register_t retval[2] = {0, 0}; 1717 int error = 0; 1718 int rv = -1; 1719 struct sys_nfssvc_args callarg; 1720 1721 SPARG(&callarg, flag) = flag; 1722 SPARG(&callarg, argp) = argp; 1723 1724 error = rsys_syscall(SYS_nfssvc, &callarg, sizeof(callarg), retval); 1725 rsys_seterrno(error); 1726 if (error == 0) { 1727 if (sizeof(int) > sizeof(register_t)) 1728 rv = *(int *)retval; 1729 else 1730 rv = *retval; 1731 } 1732 return rv; 1733 } 1734 rsys_define(rumpns_sys_nfssvc); 1735 rsys_aliases(nfssvc,rump___sysimpl_nfssvc); 1736 1737 ssize_t rump___sysimpl_pread(int, void *, size_t, off_t); 1738 ssize_t 1739 rump___sysimpl_pread(int fd, void * buf, size_t nbyte, off_t offset) 1740 { 1741 register_t retval[2] = {0, 0}; 1742 int error = 0; 1743 ssize_t rv = -1; 1744 struct sys_pread_args callarg; 1745 1746 SPARG(&callarg, fd) = fd; 1747 SPARG(&callarg, buf) = buf; 1748 SPARG(&callarg, nbyte) = nbyte; 1749 SPARG(&callarg, PAD) = 0; 1750 SPARG(&callarg, offset) = offset; 1751 1752 error = rsys_syscall(SYS_pread, &callarg, sizeof(callarg), retval); 1753 rsys_seterrno(error); 1754 if (error == 0) { 1755 if (sizeof(ssize_t) > sizeof(register_t)) 1756 rv = *(ssize_t *)retval; 1757 else 1758 rv = *retval; 1759 } 1760 return rv; 1761 } 1762 rsys_define(rumpns_sys_pread); 1763 rsys_aliases(pread,rump___sysimpl_pread); 1764 1765 ssize_t rump___sysimpl_pwrite(int, const void *, size_t, off_t); 1766 ssize_t 1767 rump___sysimpl_pwrite(int fd, const void * buf, size_t nbyte, off_t offset) 1768 { 1769 register_t retval[2] = {0, 0}; 1770 int error = 0; 1771 ssize_t rv = -1; 1772 struct sys_pwrite_args callarg; 1773 1774 SPARG(&callarg, fd) = fd; 1775 SPARG(&callarg, buf) = buf; 1776 SPARG(&callarg, nbyte) = nbyte; 1777 SPARG(&callarg, PAD) = 0; 1778 SPARG(&callarg, offset) = offset; 1779 1780 error = rsys_syscall(SYS_pwrite, &callarg, sizeof(callarg), retval); 1781 rsys_seterrno(error); 1782 if (error == 0) { 1783 if (sizeof(ssize_t) > sizeof(register_t)) 1784 rv = *(ssize_t *)retval; 1785 else 1786 rv = *retval; 1787 } 1788 return rv; 1789 } 1790 rsys_define(rumpns_sys_pwrite); 1791 rsys_aliases(pwrite,rump___sysimpl_pwrite); 1792 1793 int rump___sysimpl_setgid(gid_t); 1794 int 1795 rump___sysimpl_setgid(gid_t gid) 1796 { 1797 register_t retval[2] = {0, 0}; 1798 int error = 0; 1799 int rv = -1; 1800 struct sys_setgid_args callarg; 1801 1802 SPARG(&callarg, gid) = gid; 1803 1804 error = rsys_syscall(SYS_setgid, &callarg, sizeof(callarg), retval); 1805 rsys_seterrno(error); 1806 if (error == 0) { 1807 if (sizeof(int) > sizeof(register_t)) 1808 rv = *(int *)retval; 1809 else 1810 rv = *retval; 1811 } 1812 return rv; 1813 } 1814 rsys_define(rumpns_sys_setgid); 1815 rsys_aliases(setgid,rump___sysimpl_setgid); 1816 1817 int rump___sysimpl_setegid(gid_t); 1818 int 1819 rump___sysimpl_setegid(gid_t egid) 1820 { 1821 register_t retval[2] = {0, 0}; 1822 int error = 0; 1823 int rv = -1; 1824 struct sys_setegid_args callarg; 1825 1826 SPARG(&callarg, egid) = egid; 1827 1828 error = rsys_syscall(SYS_setegid, &callarg, sizeof(callarg), retval); 1829 rsys_seterrno(error); 1830 if (error == 0) { 1831 if (sizeof(int) > sizeof(register_t)) 1832 rv = *(int *)retval; 1833 else 1834 rv = *retval; 1835 } 1836 return rv; 1837 } 1838 rsys_define(rumpns_sys_setegid); 1839 rsys_aliases(setegid,rump___sysimpl_setegid); 1840 1841 int rump___sysimpl_seteuid(uid_t); 1842 int 1843 rump___sysimpl_seteuid(uid_t euid) 1844 { 1845 register_t retval[2] = {0, 0}; 1846 int error = 0; 1847 int rv = -1; 1848 struct sys_seteuid_args callarg; 1849 1850 SPARG(&callarg, euid) = euid; 1851 1852 error = rsys_syscall(SYS_seteuid, &callarg, sizeof(callarg), retval); 1853 rsys_seterrno(error); 1854 if (error == 0) { 1855 if (sizeof(int) > sizeof(register_t)) 1856 rv = *(int *)retval; 1857 else 1858 rv = *retval; 1859 } 1860 return rv; 1861 } 1862 rsys_define(rumpns_sys_seteuid); 1863 rsys_aliases(seteuid,rump___sysimpl_seteuid); 1864 1865 long rump___sysimpl_pathconf(const char *, int); 1866 long 1867 rump___sysimpl_pathconf(const char * path, int name) 1868 { 1869 register_t retval[2] = {0, 0}; 1870 int error = 0; 1871 long rv = -1; 1872 struct sys_pathconf_args callarg; 1873 1874 SPARG(&callarg, path) = path; 1875 SPARG(&callarg, name) = name; 1876 1877 error = rsys_syscall(SYS_pathconf, &callarg, sizeof(callarg), retval); 1878 rsys_seterrno(error); 1879 if (error == 0) { 1880 if (sizeof(long) > sizeof(register_t)) 1881 rv = *(long *)retval; 1882 else 1883 rv = *retval; 1884 } 1885 return rv; 1886 } 1887 rsys_define(rumpns_sys_pathconf); 1888 rsys_aliases(pathconf,rump___sysimpl_pathconf); 1889 1890 long rump___sysimpl_fpathconf(int, int); 1891 long 1892 rump___sysimpl_fpathconf(int fd, int name) 1893 { 1894 register_t retval[2] = {0, 0}; 1895 int error = 0; 1896 long rv = -1; 1897 struct sys_fpathconf_args callarg; 1898 1899 SPARG(&callarg, fd) = fd; 1900 SPARG(&callarg, name) = name; 1901 1902 error = rsys_syscall(SYS_fpathconf, &callarg, sizeof(callarg), retval); 1903 rsys_seterrno(error); 1904 if (error == 0) { 1905 if (sizeof(long) > sizeof(register_t)) 1906 rv = *(long *)retval; 1907 else 1908 rv = *retval; 1909 } 1910 return rv; 1911 } 1912 rsys_define(rumpns_sys_fpathconf); 1913 rsys_aliases(fpathconf,rump___sysimpl_fpathconf); 1914 1915 int rump___sysimpl_getrlimit(int, struct rlimit *); 1916 int 1917 rump___sysimpl_getrlimit(int which, struct rlimit * rlp) 1918 { 1919 register_t retval[2] = {0, 0}; 1920 int error = 0; 1921 int rv = -1; 1922 struct sys_getrlimit_args callarg; 1923 1924 SPARG(&callarg, which) = which; 1925 SPARG(&callarg, rlp) = rlp; 1926 1927 error = rsys_syscall(SYS_getrlimit, &callarg, sizeof(callarg), retval); 1928 rsys_seterrno(error); 1929 if (error == 0) { 1930 if (sizeof(int) > sizeof(register_t)) 1931 rv = *(int *)retval; 1932 else 1933 rv = *retval; 1934 } 1935 return rv; 1936 } 1937 rsys_define(rumpns_sys_getrlimit); 1938 rsys_aliases(getrlimit,rump___sysimpl_getrlimit); 1939 1940 int rump___sysimpl_setrlimit(int, const struct rlimit *); 1941 int 1942 rump___sysimpl_setrlimit(int which, const struct rlimit * rlp) 1943 { 1944 register_t retval[2] = {0, 0}; 1945 int error = 0; 1946 int rv = -1; 1947 struct sys_setrlimit_args callarg; 1948 1949 SPARG(&callarg, which) = which; 1950 SPARG(&callarg, rlp) = rlp; 1951 1952 error = rsys_syscall(SYS_setrlimit, &callarg, sizeof(callarg), retval); 1953 rsys_seterrno(error); 1954 if (error == 0) { 1955 if (sizeof(int) > sizeof(register_t)) 1956 rv = *(int *)retval; 1957 else 1958 rv = *retval; 1959 } 1960 return rv; 1961 } 1962 rsys_define(rumpns_sys_setrlimit); 1963 rsys_aliases(setrlimit,rump___sysimpl_setrlimit); 1964 1965 off_t rump___sysimpl_lseek(int, off_t, int); 1966 off_t 1967 rump___sysimpl_lseek(int fd, off_t offset, int whence) 1968 { 1969 register_t retval[2] = {0, 0}; 1970 int error = 0; 1971 off_t rv = -1; 1972 struct sys_lseek_args callarg; 1973 1974 SPARG(&callarg, fd) = fd; 1975 SPARG(&callarg, PAD) = 0; 1976 SPARG(&callarg, offset) = offset; 1977 SPARG(&callarg, whence) = whence; 1978 1979 error = rsys_syscall(SYS_lseek, &callarg, sizeof(callarg), retval); 1980 rsys_seterrno(error); 1981 if (error == 0) { 1982 if (sizeof(off_t) > sizeof(register_t)) 1983 rv = *(off_t *)retval; 1984 else 1985 rv = *retval; 1986 } 1987 return rv; 1988 } 1989 rsys_define(rumpns_sys_lseek); 1990 rsys_aliases(lseek,rump___sysimpl_lseek); 1991 1992 int rump___sysimpl_truncate(const char *, off_t); 1993 int 1994 rump___sysimpl_truncate(const char * path, off_t length) 1995 { 1996 register_t retval[2] = {0, 0}; 1997 int error = 0; 1998 int rv = -1; 1999 struct sys_truncate_args callarg; 2000 2001 SPARG(&callarg, path) = path; 2002 SPARG(&callarg, PAD) = 0; 2003 SPARG(&callarg, length) = length; 2004 2005 error = rsys_syscall(SYS_truncate, &callarg, sizeof(callarg), retval); 2006 rsys_seterrno(error); 2007 if (error == 0) { 2008 if (sizeof(int) > sizeof(register_t)) 2009 rv = *(int *)retval; 2010 else 2011 rv = *retval; 2012 } 2013 return rv; 2014 } 2015 rsys_define(rumpns_sys_truncate); 2016 rsys_aliases(truncate,rump___sysimpl_truncate); 2017 2018 int rump___sysimpl_ftruncate(int, off_t); 2019 int 2020 rump___sysimpl_ftruncate(int fd, off_t length) 2021 { 2022 register_t retval[2] = {0, 0}; 2023 int error = 0; 2024 int rv = -1; 2025 struct sys_ftruncate_args callarg; 2026 2027 SPARG(&callarg, fd) = fd; 2028 SPARG(&callarg, PAD) = 0; 2029 SPARG(&callarg, length) = length; 2030 2031 error = rsys_syscall(SYS_ftruncate, &callarg, sizeof(callarg), retval); 2032 rsys_seterrno(error); 2033 if (error == 0) { 2034 if (sizeof(int) > sizeof(register_t)) 2035 rv = *(int *)retval; 2036 else 2037 rv = *retval; 2038 } 2039 return rv; 2040 } 2041 rsys_define(rumpns_sys_ftruncate); 2042 rsys_aliases(ftruncate,rump___sysimpl_ftruncate); 2043 2044 int rump___sysimpl___sysctl(const int *, u_int, void *, size_t *, const void *, size_t); 2045 int 2046 rump___sysimpl___sysctl(const int * name, u_int namelen, void * old, size_t * oldlenp, const void * new, size_t newlen) 2047 { 2048 register_t retval[2] = {0, 0}; 2049 int error = 0; 2050 int rv = -1; 2051 struct sys___sysctl_args callarg; 2052 2053 SPARG(&callarg, name) = name; 2054 SPARG(&callarg, namelen) = namelen; 2055 SPARG(&callarg, old) = old; 2056 SPARG(&callarg, oldlenp) = oldlenp; 2057 SPARG(&callarg, new) = new; 2058 SPARG(&callarg, newlen) = newlen; 2059 2060 error = rsys_syscall(SYS___sysctl, &callarg, sizeof(callarg), retval); 2061 rsys_seterrno(error); 2062 if (error == 0) { 2063 if (sizeof(int) > sizeof(register_t)) 2064 rv = *(int *)retval; 2065 else 2066 rv = *retval; 2067 } 2068 return rv; 2069 } 2070 rsys_define(rumpns_sys___sysctl); 2071 rsys_aliases(__sysctl,rump___sysimpl___sysctl); 2072 2073 int rump___sysimpl_futimes(int, const struct timeval *); 2074 int 2075 rump___sysimpl_futimes(int fd, const struct timeval * tptr) 2076 { 2077 register_t retval[2] = {0, 0}; 2078 int error = 0; 2079 int rv = -1; 2080 struct compat_50_sys_futimes_args callarg; 2081 2082 SPARG(&callarg, fd) = fd; 2083 SPARG(&callarg, tptr) = (const struct timeval50 *)tptr; 2084 2085 error = rsys_syscall(SYS_compat_50_futimes, &callarg, sizeof(callarg), retval); 2086 rsys_seterrno(error); 2087 if (error == 0) { 2088 if (sizeof(int) > sizeof(register_t)) 2089 rv = *(int *)retval; 2090 else 2091 rv = *retval; 2092 } 2093 return rv; 2094 } 2095 rsys_define(rumpns_compat_50_sys_futimes); 2096 rsys_aliases(compat_50_futimes,rump___sysimpl_futimes); 2097 2098 pid_t rump___sysimpl_getpgid(pid_t); 2099 pid_t 2100 rump___sysimpl_getpgid(pid_t pid) 2101 { 2102 register_t retval[2] = {0, 0}; 2103 int error = 0; 2104 pid_t rv = -1; 2105 struct sys_getpgid_args callarg; 2106 2107 SPARG(&callarg, pid) = pid; 2108 2109 error = rsys_syscall(SYS_getpgid, &callarg, sizeof(callarg), retval); 2110 rsys_seterrno(error); 2111 if (error == 0) { 2112 if (sizeof(pid_t) > sizeof(register_t)) 2113 rv = *(pid_t *)retval; 2114 else 2115 rv = *retval; 2116 } 2117 return rv; 2118 } 2119 rsys_define(rumpns_sys_getpgid); 2120 rsys_aliases(getpgid,rump___sysimpl_getpgid); 2121 2122 int rump___sysimpl_reboot(int, char *); 2123 int 2124 rump___sysimpl_reboot(int opt, char * bootstr) 2125 { 2126 register_t retval[2] = {0, 0}; 2127 int error = 0; 2128 int rv = -1; 2129 struct sys_reboot_args callarg; 2130 2131 SPARG(&callarg, opt) = opt; 2132 SPARG(&callarg, bootstr) = bootstr; 2133 2134 error = rsys_syscall(SYS_reboot, &callarg, sizeof(callarg), retval); 2135 rsys_seterrno(error); 2136 if (error == 0) { 2137 if (sizeof(int) > sizeof(register_t)) 2138 rv = *(int *)retval; 2139 else 2140 rv = *retval; 2141 } 2142 return rv; 2143 } 2144 rsys_define(rumpns_sys_reboot); 2145 rsys_aliases(reboot,rump___sysimpl_reboot); 2146 2147 int rump___sysimpl_poll(struct pollfd *, u_int, int); 2148 int 2149 rump___sysimpl_poll(struct pollfd * fds, u_int nfds, int timeout) 2150 { 2151 register_t retval[2] = {0, 0}; 2152 int error = 0; 2153 int rv = -1; 2154 struct sys_poll_args callarg; 2155 2156 SPARG(&callarg, fds) = fds; 2157 SPARG(&callarg, nfds) = nfds; 2158 SPARG(&callarg, timeout) = timeout; 2159 2160 error = rsys_syscall(SYS_poll, &callarg, sizeof(callarg), retval); 2161 rsys_seterrno(error); 2162 if (error == 0) { 2163 if (sizeof(int) > sizeof(register_t)) 2164 rv = *(int *)retval; 2165 else 2166 rv = *retval; 2167 } 2168 return rv; 2169 } 2170 rsys_define(rumpns_sys_poll); 2171 rsys_aliases(poll,rump___sysimpl_poll); 2172 2173 int rump___sysimpl_fdatasync(int); 2174 int 2175 rump___sysimpl_fdatasync(int fd) 2176 { 2177 register_t retval[2] = {0, 0}; 2178 int error = 0; 2179 int rv = -1; 2180 struct sys_fdatasync_args callarg; 2181 2182 SPARG(&callarg, fd) = fd; 2183 2184 error = rsys_syscall(SYS_fdatasync, &callarg, sizeof(callarg), retval); 2185 rsys_seterrno(error); 2186 if (error == 0) { 2187 if (sizeof(int) > sizeof(register_t)) 2188 rv = *(int *)retval; 2189 else 2190 rv = *retval; 2191 } 2192 return rv; 2193 } 2194 rsys_define(rumpns_sys_fdatasync); 2195 rsys_aliases(fdatasync,rump___sysimpl_fdatasync); 2196 2197 int rump___sysimpl_modctl(int, void *); 2198 int 2199 rump___sysimpl_modctl(int cmd, void * arg) 2200 { 2201 register_t retval[2] = {0, 0}; 2202 int error = 0; 2203 int rv = -1; 2204 struct sys_modctl_args callarg; 2205 2206 SPARG(&callarg, cmd) = cmd; 2207 SPARG(&callarg, arg) = arg; 2208 2209 error = rsys_syscall(SYS_modctl, &callarg, sizeof(callarg), retval); 2210 rsys_seterrno(error); 2211 if (error == 0) { 2212 if (sizeof(int) > sizeof(register_t)) 2213 rv = *(int *)retval; 2214 else 2215 rv = *retval; 2216 } 2217 return rv; 2218 } 2219 rsys_define(rumpns_sys_modctl); 2220 rsys_aliases(modctl,rump___sysimpl_modctl); 2221 2222 int rump___sysimpl__ksem_init(unsigned int, intptr_t *); 2223 int 2224 rump___sysimpl__ksem_init(unsigned int value, intptr_t * idp) 2225 { 2226 register_t retval[2] = {0, 0}; 2227 int error = 0; 2228 int rv = -1; 2229 struct sys__ksem_init_args callarg; 2230 2231 SPARG(&callarg, value) = value; 2232 SPARG(&callarg, idp) = idp; 2233 2234 error = rsys_syscall(SYS__ksem_init, &callarg, sizeof(callarg), retval); 2235 rsys_seterrno(error); 2236 if (error == 0) { 2237 if (sizeof(int) > sizeof(register_t)) 2238 rv = *(int *)retval; 2239 else 2240 rv = *retval; 2241 } 2242 return rv; 2243 } 2244 rsys_define(rumpns_sys__ksem_init); 2245 rsys_aliases(_ksem_init,rump___sysimpl__ksem_init); 2246 2247 int rump___sysimpl__ksem_open(const char *, int, mode_t, unsigned int, intptr_t *); 2248 int 2249 rump___sysimpl__ksem_open(const char * name, int oflag, mode_t mode, unsigned int value, intptr_t * idp) 2250 { 2251 register_t retval[2] = {0, 0}; 2252 int error = 0; 2253 int rv = -1; 2254 struct sys__ksem_open_args callarg; 2255 2256 SPARG(&callarg, name) = name; 2257 SPARG(&callarg, oflag) = oflag; 2258 SPARG(&callarg, mode) = mode; 2259 SPARG(&callarg, value) = value; 2260 SPARG(&callarg, idp) = idp; 2261 2262 error = rsys_syscall(SYS__ksem_open, &callarg, sizeof(callarg), retval); 2263 rsys_seterrno(error); 2264 if (error == 0) { 2265 if (sizeof(int) > sizeof(register_t)) 2266 rv = *(int *)retval; 2267 else 2268 rv = *retval; 2269 } 2270 return rv; 2271 } 2272 rsys_define(rumpns_sys__ksem_open); 2273 rsys_aliases(_ksem_open,rump___sysimpl__ksem_open); 2274 2275 int rump___sysimpl__ksem_unlink(const char *); 2276 int 2277 rump___sysimpl__ksem_unlink(const char * name) 2278 { 2279 register_t retval[2] = {0, 0}; 2280 int error = 0; 2281 int rv = -1; 2282 struct sys__ksem_unlink_args callarg; 2283 2284 SPARG(&callarg, name) = name; 2285 2286 error = rsys_syscall(SYS__ksem_unlink, &callarg, sizeof(callarg), retval); 2287 rsys_seterrno(error); 2288 if (error == 0) { 2289 if (sizeof(int) > sizeof(register_t)) 2290 rv = *(int *)retval; 2291 else 2292 rv = *retval; 2293 } 2294 return rv; 2295 } 2296 rsys_define(rumpns_sys__ksem_unlink); 2297 rsys_aliases(_ksem_unlink,rump___sysimpl__ksem_unlink); 2298 2299 int rump___sysimpl__ksem_close(intptr_t); 2300 int 2301 rump___sysimpl__ksem_close(intptr_t id) 2302 { 2303 register_t retval[2] = {0, 0}; 2304 int error = 0; 2305 int rv = -1; 2306 struct sys__ksem_close_args callarg; 2307 2308 SPARG(&callarg, id) = id; 2309 2310 error = rsys_syscall(SYS__ksem_close, &callarg, sizeof(callarg), retval); 2311 rsys_seterrno(error); 2312 if (error == 0) { 2313 if (sizeof(int) > sizeof(register_t)) 2314 rv = *(int *)retval; 2315 else 2316 rv = *retval; 2317 } 2318 return rv; 2319 } 2320 rsys_define(rumpns_sys__ksem_close); 2321 rsys_aliases(_ksem_close,rump___sysimpl__ksem_close); 2322 2323 int rump___sysimpl__ksem_post(intptr_t); 2324 int 2325 rump___sysimpl__ksem_post(intptr_t id) 2326 { 2327 register_t retval[2] = {0, 0}; 2328 int error = 0; 2329 int rv = -1; 2330 struct sys__ksem_post_args callarg; 2331 2332 SPARG(&callarg, id) = id; 2333 2334 error = rsys_syscall(SYS__ksem_post, &callarg, sizeof(callarg), retval); 2335 rsys_seterrno(error); 2336 if (error == 0) { 2337 if (sizeof(int) > sizeof(register_t)) 2338 rv = *(int *)retval; 2339 else 2340 rv = *retval; 2341 } 2342 return rv; 2343 } 2344 rsys_define(rumpns_sys__ksem_post); 2345 rsys_aliases(_ksem_post,rump___sysimpl__ksem_post); 2346 2347 int rump___sysimpl__ksem_wait(intptr_t); 2348 int 2349 rump___sysimpl__ksem_wait(intptr_t id) 2350 { 2351 register_t retval[2] = {0, 0}; 2352 int error = 0; 2353 int rv = -1; 2354 struct sys__ksem_wait_args callarg; 2355 2356 SPARG(&callarg, id) = id; 2357 2358 error = rsys_syscall(SYS__ksem_wait, &callarg, sizeof(callarg), retval); 2359 rsys_seterrno(error); 2360 if (error == 0) { 2361 if (sizeof(int) > sizeof(register_t)) 2362 rv = *(int *)retval; 2363 else 2364 rv = *retval; 2365 } 2366 return rv; 2367 } 2368 rsys_define(rumpns_sys__ksem_wait); 2369 rsys_aliases(_ksem_wait,rump___sysimpl__ksem_wait); 2370 2371 int rump___sysimpl__ksem_trywait(intptr_t); 2372 int 2373 rump___sysimpl__ksem_trywait(intptr_t id) 2374 { 2375 register_t retval[2] = {0, 0}; 2376 int error = 0; 2377 int rv = -1; 2378 struct sys__ksem_trywait_args callarg; 2379 2380 SPARG(&callarg, id) = id; 2381 2382 error = rsys_syscall(SYS__ksem_trywait, &callarg, sizeof(callarg), retval); 2383 rsys_seterrno(error); 2384 if (error == 0) { 2385 if (sizeof(int) > sizeof(register_t)) 2386 rv = *(int *)retval; 2387 else 2388 rv = *retval; 2389 } 2390 return rv; 2391 } 2392 rsys_define(rumpns_sys__ksem_trywait); 2393 rsys_aliases(_ksem_trywait,rump___sysimpl__ksem_trywait); 2394 2395 int rump___sysimpl__ksem_getvalue(intptr_t, unsigned int *); 2396 int 2397 rump___sysimpl__ksem_getvalue(intptr_t id, unsigned int * value) 2398 { 2399 register_t retval[2] = {0, 0}; 2400 int error = 0; 2401 int rv = -1; 2402 struct sys__ksem_getvalue_args callarg; 2403 2404 SPARG(&callarg, id) = id; 2405 SPARG(&callarg, value) = value; 2406 2407 error = rsys_syscall(SYS__ksem_getvalue, &callarg, sizeof(callarg), retval); 2408 rsys_seterrno(error); 2409 if (error == 0) { 2410 if (sizeof(int) > sizeof(register_t)) 2411 rv = *(int *)retval; 2412 else 2413 rv = *retval; 2414 } 2415 return rv; 2416 } 2417 rsys_define(rumpns_sys__ksem_getvalue); 2418 rsys_aliases(_ksem_getvalue,rump___sysimpl__ksem_getvalue); 2419 2420 int rump___sysimpl__ksem_destroy(intptr_t); 2421 int 2422 rump___sysimpl__ksem_destroy(intptr_t id) 2423 { 2424 register_t retval[2] = {0, 0}; 2425 int error = 0; 2426 int rv = -1; 2427 struct sys__ksem_destroy_args callarg; 2428 2429 SPARG(&callarg, id) = id; 2430 2431 error = rsys_syscall(SYS__ksem_destroy, &callarg, sizeof(callarg), retval); 2432 rsys_seterrno(error); 2433 if (error == 0) { 2434 if (sizeof(int) > sizeof(register_t)) 2435 rv = *(int *)retval; 2436 else 2437 rv = *retval; 2438 } 2439 return rv; 2440 } 2441 rsys_define(rumpns_sys__ksem_destroy); 2442 rsys_aliases(_ksem_destroy,rump___sysimpl__ksem_destroy); 2443 2444 int rump___sysimpl__ksem_timedwait(intptr_t, const struct timespec *); 2445 int 2446 rump___sysimpl__ksem_timedwait(intptr_t id, const struct timespec * abstime) 2447 { 2448 register_t retval[2] = {0, 0}; 2449 int error = 0; 2450 int rv = -1; 2451 struct sys__ksem_timedwait_args callarg; 2452 2453 SPARG(&callarg, id) = id; 2454 SPARG(&callarg, abstime) = abstime; 2455 2456 error = rsys_syscall(SYS__ksem_timedwait, &callarg, sizeof(callarg), retval); 2457 rsys_seterrno(error); 2458 if (error == 0) { 2459 if (sizeof(int) > sizeof(register_t)) 2460 rv = *(int *)retval; 2461 else 2462 rv = *retval; 2463 } 2464 return rv; 2465 } 2466 rsys_define(rumpns_sys__ksem_timedwait); 2467 rsys_aliases(_ksem_timedwait,rump___sysimpl__ksem_timedwait); 2468 2469 int rump___sysimpl_lchmod(const char *, mode_t); 2470 int 2471 rump___sysimpl_lchmod(const char * path, mode_t mode) 2472 { 2473 register_t retval[2] = {0, 0}; 2474 int error = 0; 2475 int rv = -1; 2476 struct sys_lchmod_args callarg; 2477 2478 SPARG(&callarg, path) = path; 2479 SPARG(&callarg, mode) = mode; 2480 2481 error = rsys_syscall(SYS_lchmod, &callarg, sizeof(callarg), retval); 2482 rsys_seterrno(error); 2483 if (error == 0) { 2484 if (sizeof(int) > sizeof(register_t)) 2485 rv = *(int *)retval; 2486 else 2487 rv = *retval; 2488 } 2489 return rv; 2490 } 2491 rsys_define(rumpns_sys_lchmod); 2492 rsys_aliases(lchmod,rump___sysimpl_lchmod); 2493 2494 int rump___sysimpl_lchown(const char *, uid_t, gid_t); 2495 int 2496 rump___sysimpl_lchown(const char * path, uid_t uid, gid_t gid) 2497 { 2498 register_t retval[2] = {0, 0}; 2499 int error = 0; 2500 int rv = -1; 2501 struct sys_lchown_args callarg; 2502 2503 SPARG(&callarg, path) = path; 2504 SPARG(&callarg, uid) = uid; 2505 SPARG(&callarg, gid) = gid; 2506 2507 error = rsys_syscall(SYS_lchown, &callarg, sizeof(callarg), retval); 2508 rsys_seterrno(error); 2509 if (error == 0) { 2510 if (sizeof(int) > sizeof(register_t)) 2511 rv = *(int *)retval; 2512 else 2513 rv = *retval; 2514 } 2515 return rv; 2516 } 2517 rsys_define(rumpns_sys_lchown); 2518 rsys_aliases(lchown,rump___sysimpl_lchown); 2519 2520 int rump___sysimpl_lutimes(const char *, const struct timeval *); 2521 int 2522 rump___sysimpl_lutimes(const char * path, const struct timeval * tptr) 2523 { 2524 register_t retval[2] = {0, 0}; 2525 int error = 0; 2526 int rv = -1; 2527 struct compat_50_sys_lutimes_args callarg; 2528 2529 SPARG(&callarg, path) = path; 2530 SPARG(&callarg, tptr) = (const struct timeval50 *)tptr; 2531 2532 error = rsys_syscall(SYS_compat_50_lutimes, &callarg, sizeof(callarg), retval); 2533 rsys_seterrno(error); 2534 if (error == 0) { 2535 if (sizeof(int) > sizeof(register_t)) 2536 rv = *(int *)retval; 2537 else 2538 rv = *retval; 2539 } 2540 return rv; 2541 } 2542 rsys_define(rumpns_compat_50_sys_lutimes); 2543 rsys_aliases(compat_50_lutimes,rump___sysimpl_lutimes); 2544 2545 pid_t rump___sysimpl_getsid(pid_t); 2546 pid_t 2547 rump___sysimpl_getsid(pid_t pid) 2548 { 2549 register_t retval[2] = {0, 0}; 2550 int error = 0; 2551 pid_t rv = -1; 2552 struct sys_getsid_args callarg; 2553 2554 SPARG(&callarg, pid) = pid; 2555 2556 error = rsys_syscall(SYS_getsid, &callarg, sizeof(callarg), retval); 2557 rsys_seterrno(error); 2558 if (error == 0) { 2559 if (sizeof(pid_t) > sizeof(register_t)) 2560 rv = *(pid_t *)retval; 2561 else 2562 rv = *retval; 2563 } 2564 return rv; 2565 } 2566 rsys_define(rumpns_sys_getsid); 2567 rsys_aliases(getsid,rump___sysimpl_getsid); 2568 2569 ssize_t rump___sysimpl_preadv(int, const struct iovec *, int, off_t); 2570 ssize_t 2571 rump___sysimpl_preadv(int fd, const struct iovec * iovp, int iovcnt, off_t offset) 2572 { 2573 register_t retval[2] = {0, 0}; 2574 int error = 0; 2575 ssize_t rv = -1; 2576 struct sys_preadv_args callarg; 2577 2578 SPARG(&callarg, fd) = fd; 2579 SPARG(&callarg, iovp) = iovp; 2580 SPARG(&callarg, iovcnt) = iovcnt; 2581 SPARG(&callarg, PAD) = 0; 2582 SPARG(&callarg, offset) = offset; 2583 2584 error = rsys_syscall(SYS_preadv, &callarg, sizeof(callarg), retval); 2585 rsys_seterrno(error); 2586 if (error == 0) { 2587 if (sizeof(ssize_t) > sizeof(register_t)) 2588 rv = *(ssize_t *)retval; 2589 else 2590 rv = *retval; 2591 } 2592 return rv; 2593 } 2594 rsys_define(rumpns_sys_preadv); 2595 rsys_aliases(preadv,rump___sysimpl_preadv); 2596 2597 ssize_t rump___sysimpl_pwritev(int, const struct iovec *, int, off_t); 2598 ssize_t 2599 rump___sysimpl_pwritev(int fd, const struct iovec * iovp, int iovcnt, off_t offset) 2600 { 2601 register_t retval[2] = {0, 0}; 2602 int error = 0; 2603 ssize_t rv = -1; 2604 struct sys_pwritev_args callarg; 2605 2606 SPARG(&callarg, fd) = fd; 2607 SPARG(&callarg, iovp) = iovp; 2608 SPARG(&callarg, iovcnt) = iovcnt; 2609 SPARG(&callarg, PAD) = 0; 2610 SPARG(&callarg, offset) = offset; 2611 2612 error = rsys_syscall(SYS_pwritev, &callarg, sizeof(callarg), retval); 2613 rsys_seterrno(error); 2614 if (error == 0) { 2615 if (sizeof(ssize_t) > sizeof(register_t)) 2616 rv = *(ssize_t *)retval; 2617 else 2618 rv = *retval; 2619 } 2620 return rv; 2621 } 2622 rsys_define(rumpns_sys_pwritev); 2623 rsys_aliases(pwritev,rump___sysimpl_pwritev); 2624 2625 int rump___sysimpl___getcwd(char *, size_t); 2626 int 2627 rump___sysimpl___getcwd(char * bufp, size_t length) 2628 { 2629 register_t retval[2] = {0, 0}; 2630 int error = 0; 2631 int rv = -1; 2632 struct sys___getcwd_args callarg; 2633 2634 SPARG(&callarg, bufp) = bufp; 2635 SPARG(&callarg, length) = length; 2636 2637 error = rsys_syscall(SYS___getcwd, &callarg, sizeof(callarg), retval); 2638 rsys_seterrno(error); 2639 if (error == 0) { 2640 if (sizeof(int) > sizeof(register_t)) 2641 rv = *(int *)retval; 2642 else 2643 rv = *retval; 2644 } 2645 return rv; 2646 } 2647 rsys_define(rumpns_sys___getcwd); 2648 rsys_aliases(__getcwd,rump___sysimpl___getcwd); 2649 2650 int rump___sysimpl_fchroot(int); 2651 int 2652 rump___sysimpl_fchroot(int fd) 2653 { 2654 register_t retval[2] = {0, 0}; 2655 int error = 0; 2656 int rv = -1; 2657 struct sys_fchroot_args callarg; 2658 2659 SPARG(&callarg, fd) = fd; 2660 2661 error = rsys_syscall(SYS_fchroot, &callarg, sizeof(callarg), retval); 2662 rsys_seterrno(error); 2663 if (error == 0) { 2664 if (sizeof(int) > sizeof(register_t)) 2665 rv = *(int *)retval; 2666 else 2667 rv = *retval; 2668 } 2669 return rv; 2670 } 2671 rsys_define(rumpns_sys_fchroot); 2672 rsys_aliases(fchroot,rump___sysimpl_fchroot); 2673 2674 int rump___sysimpl_lchflags(const char *, u_long); 2675 int 2676 rump___sysimpl_lchflags(const char * path, u_long flags) 2677 { 2678 register_t retval[2] = {0, 0}; 2679 int error = 0; 2680 int rv = -1; 2681 struct sys_lchflags_args callarg; 2682 2683 SPARG(&callarg, path) = path; 2684 SPARG(&callarg, flags) = flags; 2685 2686 error = rsys_syscall(SYS_lchflags, &callarg, sizeof(callarg), retval); 2687 rsys_seterrno(error); 2688 if (error == 0) { 2689 if (sizeof(int) > sizeof(register_t)) 2690 rv = *(int *)retval; 2691 else 2692 rv = *retval; 2693 } 2694 return rv; 2695 } 2696 rsys_define(rumpns_sys_lchflags); 2697 rsys_aliases(lchflags,rump___sysimpl_lchflags); 2698 2699 int rump___sysimpl_issetugid(void); 2700 int 2701 rump___sysimpl_issetugid(void ) 2702 { 2703 register_t retval[2] = {0, 0}; 2704 int rv = -1; 2705 2706 rsys_syscall(SYS_issetugid, NULL, 0, retval); 2707 if (sizeof(int) > sizeof(register_t)) 2708 rv = *(int *)retval; 2709 else 2710 rv = *retval; 2711 return rv; 2712 } 2713 rsys_define(rumpns_sys_issetugid); 2714 rsys_aliases(issetugid,rump___sysimpl_issetugid); 2715 2716 int rump___sysimpl_kqueue(void); 2717 int 2718 rump___sysimpl_kqueue(void ) 2719 { 2720 register_t retval[2] = {0, 0}; 2721 int error = 0; 2722 int rv = -1; 2723 2724 error = rsys_syscall(SYS_kqueue, NULL, 0, retval); 2725 rsys_seterrno(error); 2726 if (error == 0) { 2727 if (sizeof(int) > sizeof(register_t)) 2728 rv = *(int *)retval; 2729 else 2730 rv = *retval; 2731 } 2732 return rv; 2733 } 2734 rsys_define(rumpns_sys_kqueue); 2735 rsys_aliases(kqueue,rump___sysimpl_kqueue); 2736 2737 int rump___sysimpl_kevent(int, const struct kevent *, size_t, struct kevent *, size_t, const struct timespec *); 2738 int 2739 rump___sysimpl_kevent(int fd, const struct kevent * changelist, size_t nchanges, struct kevent * eventlist, size_t nevents, const struct timespec * timeout) 2740 { 2741 register_t retval[2] = {0, 0}; 2742 int error = 0; 2743 int rv = -1; 2744 struct compat_50_sys_kevent_args callarg; 2745 2746 SPARG(&callarg, fd) = fd; 2747 SPARG(&callarg, changelist) = changelist; 2748 SPARG(&callarg, nchanges) = nchanges; 2749 SPARG(&callarg, eventlist) = eventlist; 2750 SPARG(&callarg, nevents) = nevents; 2751 SPARG(&callarg, timeout) = (const struct timespec50 *)timeout; 2752 2753 error = rsys_syscall(SYS_compat_50_kevent, &callarg, sizeof(callarg), retval); 2754 rsys_seterrno(error); 2755 if (error == 0) { 2756 if (sizeof(int) > sizeof(register_t)) 2757 rv = *(int *)retval; 2758 else 2759 rv = *retval; 2760 } 2761 return rv; 2762 } 2763 rsys_define(rumpns_compat_50_sys_kevent); 2764 rsys_aliases(compat_50_kevent,rump___sysimpl_kevent); 2765 2766 int rump___sysimpl_fsync_range(int, int, off_t, off_t); 2767 int 2768 rump___sysimpl_fsync_range(int fd, int flags, off_t start, off_t length) 2769 { 2770 register_t retval[2] = {0, 0}; 2771 int error = 0; 2772 int rv = -1; 2773 struct sys_fsync_range_args callarg; 2774 2775 SPARG(&callarg, fd) = fd; 2776 SPARG(&callarg, flags) = flags; 2777 SPARG(&callarg, start) = start; 2778 SPARG(&callarg, length) = length; 2779 2780 error = rsys_syscall(SYS_fsync_range, &callarg, sizeof(callarg), retval); 2781 rsys_seterrno(error); 2782 if (error == 0) { 2783 if (sizeof(int) > sizeof(register_t)) 2784 rv = *(int *)retval; 2785 else 2786 rv = *retval; 2787 } 2788 return rv; 2789 } 2790 rsys_define(rumpns_sys_fsync_range); 2791 rsys_aliases(fsync_range,rump___sysimpl_fsync_range); 2792 2793 int rump___sysimpl_getvfsstat(struct statvfs *, size_t, int); 2794 int 2795 rump___sysimpl_getvfsstat(struct statvfs * buf, size_t bufsize, int flags) 2796 { 2797 register_t retval[2] = {0, 0}; 2798 int error = 0; 2799 int rv = -1; 2800 struct sys_getvfsstat_args callarg; 2801 2802 SPARG(&callarg, buf) = buf; 2803 SPARG(&callarg, bufsize) = bufsize; 2804 SPARG(&callarg, flags) = flags; 2805 2806 error = rsys_syscall(SYS_getvfsstat, &callarg, sizeof(callarg), retval); 2807 rsys_seterrno(error); 2808 if (error == 0) { 2809 if (sizeof(int) > sizeof(register_t)) 2810 rv = *(int *)retval; 2811 else 2812 rv = *retval; 2813 } 2814 return rv; 2815 } 2816 rsys_define(rumpns_sys_getvfsstat); 2817 rsys_aliases(getvfsstat,rump___sysimpl_getvfsstat); 2818 2819 int rump___sysimpl_statvfs1(const char *, struct statvfs *, int); 2820 int 2821 rump___sysimpl_statvfs1(const char * path, struct statvfs * buf, int flags) 2822 { 2823 register_t retval[2] = {0, 0}; 2824 int error = 0; 2825 int rv = -1; 2826 struct sys_statvfs1_args callarg; 2827 2828 SPARG(&callarg, path) = path; 2829 SPARG(&callarg, buf) = buf; 2830 SPARG(&callarg, flags) = flags; 2831 2832 error = rsys_syscall(SYS_statvfs1, &callarg, sizeof(callarg), retval); 2833 rsys_seterrno(error); 2834 if (error == 0) { 2835 if (sizeof(int) > sizeof(register_t)) 2836 rv = *(int *)retval; 2837 else 2838 rv = *retval; 2839 } 2840 return rv; 2841 } 2842 rsys_define(rumpns_sys_statvfs1); 2843 rsys_aliases(statvfs1,rump___sysimpl_statvfs1); 2844 2845 int rump___sysimpl_fstatvfs1(int, struct statvfs *, int); 2846 int 2847 rump___sysimpl_fstatvfs1(int fd, struct statvfs * buf, int flags) 2848 { 2849 register_t retval[2] = {0, 0}; 2850 int error = 0; 2851 int rv = -1; 2852 struct sys_fstatvfs1_args callarg; 2853 2854 SPARG(&callarg, fd) = fd; 2855 SPARG(&callarg, buf) = buf; 2856 SPARG(&callarg, flags) = flags; 2857 2858 error = rsys_syscall(SYS_fstatvfs1, &callarg, sizeof(callarg), retval); 2859 rsys_seterrno(error); 2860 if (error == 0) { 2861 if (sizeof(int) > sizeof(register_t)) 2862 rv = *(int *)retval; 2863 else 2864 rv = *retval; 2865 } 2866 return rv; 2867 } 2868 rsys_define(rumpns_sys_fstatvfs1); 2869 rsys_aliases(fstatvfs1,rump___sysimpl_fstatvfs1); 2870 2871 int rump___sysimpl_extattrctl(const char *, int, const char *, int, const char *); 2872 int 2873 rump___sysimpl_extattrctl(const char * path, int cmd, const char * filename, int attrnamespace, const char * attrname) 2874 { 2875 register_t retval[2] = {0, 0}; 2876 int error = 0; 2877 int rv = -1; 2878 struct sys_extattrctl_args callarg; 2879 2880 SPARG(&callarg, path) = path; 2881 SPARG(&callarg, cmd) = cmd; 2882 SPARG(&callarg, filename) = filename; 2883 SPARG(&callarg, attrnamespace) = attrnamespace; 2884 SPARG(&callarg, attrname) = attrname; 2885 2886 error = rsys_syscall(SYS_extattrctl, &callarg, sizeof(callarg), retval); 2887 rsys_seterrno(error); 2888 if (error == 0) { 2889 if (sizeof(int) > sizeof(register_t)) 2890 rv = *(int *)retval; 2891 else 2892 rv = *retval; 2893 } 2894 return rv; 2895 } 2896 rsys_define(rumpns_sys_extattrctl); 2897 rsys_aliases(extattrctl,rump___sysimpl_extattrctl); 2898 2899 int rump___sysimpl_extattr_set_file(const char *, int, const char *, const void *, size_t); 2900 int 2901 rump___sysimpl_extattr_set_file(const char * path, int attrnamespace, const char * attrname, const void * data, size_t nbytes) 2902 { 2903 register_t retval[2] = {0, 0}; 2904 int error = 0; 2905 int rv = -1; 2906 struct sys_extattr_set_file_args callarg; 2907 2908 SPARG(&callarg, path) = path; 2909 SPARG(&callarg, attrnamespace) = attrnamespace; 2910 SPARG(&callarg, attrname) = attrname; 2911 SPARG(&callarg, data) = data; 2912 SPARG(&callarg, nbytes) = nbytes; 2913 2914 error = rsys_syscall(SYS_extattr_set_file, &callarg, sizeof(callarg), retval); 2915 rsys_seterrno(error); 2916 if (error == 0) { 2917 if (sizeof(int) > sizeof(register_t)) 2918 rv = *(int *)retval; 2919 else 2920 rv = *retval; 2921 } 2922 return rv; 2923 } 2924 rsys_define(rumpns_sys_extattr_set_file); 2925 rsys_aliases(extattr_set_file,rump___sysimpl_extattr_set_file); 2926 2927 ssize_t rump___sysimpl_extattr_get_file(const char *, int, const char *, void *, size_t); 2928 ssize_t 2929 rump___sysimpl_extattr_get_file(const char * path, int attrnamespace, const char * attrname, void * data, size_t nbytes) 2930 { 2931 register_t retval[2] = {0, 0}; 2932 int error = 0; 2933 ssize_t rv = -1; 2934 struct sys_extattr_get_file_args callarg; 2935 2936 SPARG(&callarg, path) = path; 2937 SPARG(&callarg, attrnamespace) = attrnamespace; 2938 SPARG(&callarg, attrname) = attrname; 2939 SPARG(&callarg, data) = data; 2940 SPARG(&callarg, nbytes) = nbytes; 2941 2942 error = rsys_syscall(SYS_extattr_get_file, &callarg, sizeof(callarg), retval); 2943 rsys_seterrno(error); 2944 if (error == 0) { 2945 if (sizeof(ssize_t) > sizeof(register_t)) 2946 rv = *(ssize_t *)retval; 2947 else 2948 rv = *retval; 2949 } 2950 return rv; 2951 } 2952 rsys_define(rumpns_sys_extattr_get_file); 2953 rsys_aliases(extattr_get_file,rump___sysimpl_extattr_get_file); 2954 2955 int rump___sysimpl_extattr_delete_file(const char *, int, const char *); 2956 int 2957 rump___sysimpl_extattr_delete_file(const char * path, int attrnamespace, const char * attrname) 2958 { 2959 register_t retval[2] = {0, 0}; 2960 int error = 0; 2961 int rv = -1; 2962 struct sys_extattr_delete_file_args callarg; 2963 2964 SPARG(&callarg, path) = path; 2965 SPARG(&callarg, attrnamespace) = attrnamespace; 2966 SPARG(&callarg, attrname) = attrname; 2967 2968 error = rsys_syscall(SYS_extattr_delete_file, &callarg, sizeof(callarg), retval); 2969 rsys_seterrno(error); 2970 if (error == 0) { 2971 if (sizeof(int) > sizeof(register_t)) 2972 rv = *(int *)retval; 2973 else 2974 rv = *retval; 2975 } 2976 return rv; 2977 } 2978 rsys_define(rumpns_sys_extattr_delete_file); 2979 rsys_aliases(extattr_delete_file,rump___sysimpl_extattr_delete_file); 2980 2981 int rump___sysimpl_extattr_set_fd(int, int, const char *, const void *, size_t); 2982 int 2983 rump___sysimpl_extattr_set_fd(int fd, int attrnamespace, const char * attrname, const void * data, size_t nbytes) 2984 { 2985 register_t retval[2] = {0, 0}; 2986 int error = 0; 2987 int rv = -1; 2988 struct sys_extattr_set_fd_args callarg; 2989 2990 SPARG(&callarg, fd) = fd; 2991 SPARG(&callarg, attrnamespace) = attrnamespace; 2992 SPARG(&callarg, attrname) = attrname; 2993 SPARG(&callarg, data) = data; 2994 SPARG(&callarg, nbytes) = nbytes; 2995 2996 error = rsys_syscall(SYS_extattr_set_fd, &callarg, sizeof(callarg), retval); 2997 rsys_seterrno(error); 2998 if (error == 0) { 2999 if (sizeof(int) > sizeof(register_t)) 3000 rv = *(int *)retval; 3001 else 3002 rv = *retval; 3003 } 3004 return rv; 3005 } 3006 rsys_define(rumpns_sys_extattr_set_fd); 3007 rsys_aliases(extattr_set_fd,rump___sysimpl_extattr_set_fd); 3008 3009 ssize_t rump___sysimpl_extattr_get_fd(int, int, const char *, void *, size_t); 3010 ssize_t 3011 rump___sysimpl_extattr_get_fd(int fd, int attrnamespace, const char * attrname, void * data, size_t nbytes) 3012 { 3013 register_t retval[2] = {0, 0}; 3014 int error = 0; 3015 ssize_t rv = -1; 3016 struct sys_extattr_get_fd_args callarg; 3017 3018 SPARG(&callarg, fd) = fd; 3019 SPARG(&callarg, attrnamespace) = attrnamespace; 3020 SPARG(&callarg, attrname) = attrname; 3021 SPARG(&callarg, data) = data; 3022 SPARG(&callarg, nbytes) = nbytes; 3023 3024 error = rsys_syscall(SYS_extattr_get_fd, &callarg, sizeof(callarg), retval); 3025 rsys_seterrno(error); 3026 if (error == 0) { 3027 if (sizeof(ssize_t) > sizeof(register_t)) 3028 rv = *(ssize_t *)retval; 3029 else 3030 rv = *retval; 3031 } 3032 return rv; 3033 } 3034 rsys_define(rumpns_sys_extattr_get_fd); 3035 rsys_aliases(extattr_get_fd,rump___sysimpl_extattr_get_fd); 3036 3037 int rump___sysimpl_extattr_delete_fd(int, int, const char *); 3038 int 3039 rump___sysimpl_extattr_delete_fd(int fd, int attrnamespace, const char * attrname) 3040 { 3041 register_t retval[2] = {0, 0}; 3042 int error = 0; 3043 int rv = -1; 3044 struct sys_extattr_delete_fd_args callarg; 3045 3046 SPARG(&callarg, fd) = fd; 3047 SPARG(&callarg, attrnamespace) = attrnamespace; 3048 SPARG(&callarg, attrname) = attrname; 3049 3050 error = rsys_syscall(SYS_extattr_delete_fd, &callarg, sizeof(callarg), retval); 3051 rsys_seterrno(error); 3052 if (error == 0) { 3053 if (sizeof(int) > sizeof(register_t)) 3054 rv = *(int *)retval; 3055 else 3056 rv = *retval; 3057 } 3058 return rv; 3059 } 3060 rsys_define(rumpns_sys_extattr_delete_fd); 3061 rsys_aliases(extattr_delete_fd,rump___sysimpl_extattr_delete_fd); 3062 3063 int rump___sysimpl_extattr_set_link(const char *, int, const char *, const void *, size_t); 3064 int 3065 rump___sysimpl_extattr_set_link(const char * path, int attrnamespace, const char * attrname, const void * data, size_t nbytes) 3066 { 3067 register_t retval[2] = {0, 0}; 3068 int error = 0; 3069 int rv = -1; 3070 struct sys_extattr_set_link_args callarg; 3071 3072 SPARG(&callarg, path) = path; 3073 SPARG(&callarg, attrnamespace) = attrnamespace; 3074 SPARG(&callarg, attrname) = attrname; 3075 SPARG(&callarg, data) = data; 3076 SPARG(&callarg, nbytes) = nbytes; 3077 3078 error = rsys_syscall(SYS_extattr_set_link, &callarg, sizeof(callarg), retval); 3079 rsys_seterrno(error); 3080 if (error == 0) { 3081 if (sizeof(int) > sizeof(register_t)) 3082 rv = *(int *)retval; 3083 else 3084 rv = *retval; 3085 } 3086 return rv; 3087 } 3088 rsys_define(rumpns_sys_extattr_set_link); 3089 rsys_aliases(extattr_set_link,rump___sysimpl_extattr_set_link); 3090 3091 ssize_t rump___sysimpl_extattr_get_link(const char *, int, const char *, void *, size_t); 3092 ssize_t 3093 rump___sysimpl_extattr_get_link(const char * path, int attrnamespace, const char * attrname, void * data, size_t nbytes) 3094 { 3095 register_t retval[2] = {0, 0}; 3096 int error = 0; 3097 ssize_t rv = -1; 3098 struct sys_extattr_get_link_args callarg; 3099 3100 SPARG(&callarg, path) = path; 3101 SPARG(&callarg, attrnamespace) = attrnamespace; 3102 SPARG(&callarg, attrname) = attrname; 3103 SPARG(&callarg, data) = data; 3104 SPARG(&callarg, nbytes) = nbytes; 3105 3106 error = rsys_syscall(SYS_extattr_get_link, &callarg, sizeof(callarg), retval); 3107 rsys_seterrno(error); 3108 if (error == 0) { 3109 if (sizeof(ssize_t) > sizeof(register_t)) 3110 rv = *(ssize_t *)retval; 3111 else 3112 rv = *retval; 3113 } 3114 return rv; 3115 } 3116 rsys_define(rumpns_sys_extattr_get_link); 3117 rsys_aliases(extattr_get_link,rump___sysimpl_extattr_get_link); 3118 3119 int rump___sysimpl_extattr_delete_link(const char *, int, const char *); 3120 int 3121 rump___sysimpl_extattr_delete_link(const char * path, int attrnamespace, const char * attrname) 3122 { 3123 register_t retval[2] = {0, 0}; 3124 int error = 0; 3125 int rv = -1; 3126 struct sys_extattr_delete_link_args callarg; 3127 3128 SPARG(&callarg, path) = path; 3129 SPARG(&callarg, attrnamespace) = attrnamespace; 3130 SPARG(&callarg, attrname) = attrname; 3131 3132 error = rsys_syscall(SYS_extattr_delete_link, &callarg, sizeof(callarg), retval); 3133 rsys_seterrno(error); 3134 if (error == 0) { 3135 if (sizeof(int) > sizeof(register_t)) 3136 rv = *(int *)retval; 3137 else 3138 rv = *retval; 3139 } 3140 return rv; 3141 } 3142 rsys_define(rumpns_sys_extattr_delete_link); 3143 rsys_aliases(extattr_delete_link,rump___sysimpl_extattr_delete_link); 3144 3145 ssize_t rump___sysimpl_extattr_list_fd(int, int, void *, size_t); 3146 ssize_t 3147 rump___sysimpl_extattr_list_fd(int fd, int attrnamespace, void * data, size_t nbytes) 3148 { 3149 register_t retval[2] = {0, 0}; 3150 int error = 0; 3151 ssize_t rv = -1; 3152 struct sys_extattr_list_fd_args callarg; 3153 3154 SPARG(&callarg, fd) = fd; 3155 SPARG(&callarg, attrnamespace) = attrnamespace; 3156 SPARG(&callarg, data) = data; 3157 SPARG(&callarg, nbytes) = nbytes; 3158 3159 error = rsys_syscall(SYS_extattr_list_fd, &callarg, sizeof(callarg), retval); 3160 rsys_seterrno(error); 3161 if (error == 0) { 3162 if (sizeof(ssize_t) > sizeof(register_t)) 3163 rv = *(ssize_t *)retval; 3164 else 3165 rv = *retval; 3166 } 3167 return rv; 3168 } 3169 rsys_define(rumpns_sys_extattr_list_fd); 3170 rsys_aliases(extattr_list_fd,rump___sysimpl_extattr_list_fd); 3171 3172 ssize_t rump___sysimpl_extattr_list_file(const char *, int, void *, size_t); 3173 ssize_t 3174 rump___sysimpl_extattr_list_file(const char * path, int attrnamespace, void * data, size_t nbytes) 3175 { 3176 register_t retval[2] = {0, 0}; 3177 int error = 0; 3178 ssize_t rv = -1; 3179 struct sys_extattr_list_file_args callarg; 3180 3181 SPARG(&callarg, path) = path; 3182 SPARG(&callarg, attrnamespace) = attrnamespace; 3183 SPARG(&callarg, data) = data; 3184 SPARG(&callarg, nbytes) = nbytes; 3185 3186 error = rsys_syscall(SYS_extattr_list_file, &callarg, sizeof(callarg), retval); 3187 rsys_seterrno(error); 3188 if (error == 0) { 3189 if (sizeof(ssize_t) > sizeof(register_t)) 3190 rv = *(ssize_t *)retval; 3191 else 3192 rv = *retval; 3193 } 3194 return rv; 3195 } 3196 rsys_define(rumpns_sys_extattr_list_file); 3197 rsys_aliases(extattr_list_file,rump___sysimpl_extattr_list_file); 3198 3199 ssize_t rump___sysimpl_extattr_list_link(const char *, int, void *, size_t); 3200 ssize_t 3201 rump___sysimpl_extattr_list_link(const char * path, int attrnamespace, void * data, size_t nbytes) 3202 { 3203 register_t retval[2] = {0, 0}; 3204 int error = 0; 3205 ssize_t rv = -1; 3206 struct sys_extattr_list_link_args callarg; 3207 3208 SPARG(&callarg, path) = path; 3209 SPARG(&callarg, attrnamespace) = attrnamespace; 3210 SPARG(&callarg, data) = data; 3211 SPARG(&callarg, nbytes) = nbytes; 3212 3213 error = rsys_syscall(SYS_extattr_list_link, &callarg, sizeof(callarg), retval); 3214 rsys_seterrno(error); 3215 if (error == 0) { 3216 if (sizeof(ssize_t) > sizeof(register_t)) 3217 rv = *(ssize_t *)retval; 3218 else 3219 rv = *retval; 3220 } 3221 return rv; 3222 } 3223 rsys_define(rumpns_sys_extattr_list_link); 3224 rsys_aliases(extattr_list_link,rump___sysimpl_extattr_list_link); 3225 3226 int rump___sysimpl_pselect(int, fd_set *, fd_set *, fd_set *, const struct timespec *, const sigset_t *); 3227 int 3228 rump___sysimpl_pselect(int nd, fd_set * in, fd_set * ou, fd_set * ex, const struct timespec * ts, const sigset_t * mask) 3229 { 3230 register_t retval[2] = {0, 0}; 3231 int error = 0; 3232 int rv = -1; 3233 struct compat_50_sys_pselect_args callarg; 3234 3235 SPARG(&callarg, nd) = nd; 3236 SPARG(&callarg, in) = in; 3237 SPARG(&callarg, ou) = ou; 3238 SPARG(&callarg, ex) = ex; 3239 SPARG(&callarg, ts) = (const struct timespec50 *)ts; 3240 SPARG(&callarg, mask) = mask; 3241 3242 error = rsys_syscall(SYS_compat_50_pselect, &callarg, sizeof(callarg), retval); 3243 rsys_seterrno(error); 3244 if (error == 0) { 3245 if (sizeof(int) > sizeof(register_t)) 3246 rv = *(int *)retval; 3247 else 3248 rv = *retval; 3249 } 3250 return rv; 3251 } 3252 rsys_define(rumpns_compat_50_sys_pselect); 3253 rsys_aliases(compat_50_pselect,rump___sysimpl_pselect); 3254 3255 int rump___sysimpl_pollts(struct pollfd *, u_int, const struct timespec *, const sigset_t *); 3256 int 3257 rump___sysimpl_pollts(struct pollfd * fds, u_int nfds, const struct timespec * ts, const sigset_t * mask) 3258 { 3259 register_t retval[2] = {0, 0}; 3260 int error = 0; 3261 int rv = -1; 3262 struct compat_50_sys_pollts_args callarg; 3263 3264 SPARG(&callarg, fds) = fds; 3265 SPARG(&callarg, nfds) = nfds; 3266 SPARG(&callarg, ts) = (const struct timespec50 *)ts; 3267 SPARG(&callarg, mask) = mask; 3268 3269 error = rsys_syscall(SYS_compat_50_pollts, &callarg, sizeof(callarg), retval); 3270 rsys_seterrno(error); 3271 if (error == 0) { 3272 if (sizeof(int) > sizeof(register_t)) 3273 rv = *(int *)retval; 3274 else 3275 rv = *retval; 3276 } 3277 return rv; 3278 } 3279 rsys_define(rumpns_compat_50_sys_pollts); 3280 rsys_aliases(compat_50_pollts,rump___sysimpl_pollts); 3281 3282 int rump___sysimpl_setxattr(const char *, const char *, const void *, size_t, int); 3283 int 3284 rump___sysimpl_setxattr(const char * path, const char * name, const void * value, size_t size, int flags) 3285 { 3286 register_t retval[2] = {0, 0}; 3287 int error = 0; 3288 int rv = -1; 3289 struct sys_setxattr_args callarg; 3290 3291 SPARG(&callarg, path) = path; 3292 SPARG(&callarg, name) = name; 3293 SPARG(&callarg, value) = value; 3294 SPARG(&callarg, size) = size; 3295 SPARG(&callarg, flags) = flags; 3296 3297 error = rsys_syscall(SYS_setxattr, &callarg, sizeof(callarg), retval); 3298 rsys_seterrno(error); 3299 if (error == 0) { 3300 if (sizeof(int) > sizeof(register_t)) 3301 rv = *(int *)retval; 3302 else 3303 rv = *retval; 3304 } 3305 return rv; 3306 } 3307 rsys_define(rumpns_sys_setxattr); 3308 rsys_aliases(setxattr,rump___sysimpl_setxattr); 3309 3310 int rump___sysimpl_lsetxattr(const char *, const char *, const void *, size_t, int); 3311 int 3312 rump___sysimpl_lsetxattr(const char * path, const char * name, const void * value, size_t size, int flags) 3313 { 3314 register_t retval[2] = {0, 0}; 3315 int error = 0; 3316 int rv = -1; 3317 struct sys_lsetxattr_args callarg; 3318 3319 SPARG(&callarg, path) = path; 3320 SPARG(&callarg, name) = name; 3321 SPARG(&callarg, value) = value; 3322 SPARG(&callarg, size) = size; 3323 SPARG(&callarg, flags) = flags; 3324 3325 error = rsys_syscall(SYS_lsetxattr, &callarg, sizeof(callarg), retval); 3326 rsys_seterrno(error); 3327 if (error == 0) { 3328 if (sizeof(int) > sizeof(register_t)) 3329 rv = *(int *)retval; 3330 else 3331 rv = *retval; 3332 } 3333 return rv; 3334 } 3335 rsys_define(rumpns_sys_lsetxattr); 3336 rsys_aliases(lsetxattr,rump___sysimpl_lsetxattr); 3337 3338 int rump___sysimpl_fsetxattr(int, const char *, const void *, size_t, int); 3339 int 3340 rump___sysimpl_fsetxattr(int fd, const char * name, const void * value, size_t size, int flags) 3341 { 3342 register_t retval[2] = {0, 0}; 3343 int error = 0; 3344 int rv = -1; 3345 struct sys_fsetxattr_args callarg; 3346 3347 SPARG(&callarg, fd) = fd; 3348 SPARG(&callarg, name) = name; 3349 SPARG(&callarg, value) = value; 3350 SPARG(&callarg, size) = size; 3351 SPARG(&callarg, flags) = flags; 3352 3353 error = rsys_syscall(SYS_fsetxattr, &callarg, sizeof(callarg), retval); 3354 rsys_seterrno(error); 3355 if (error == 0) { 3356 if (sizeof(int) > sizeof(register_t)) 3357 rv = *(int *)retval; 3358 else 3359 rv = *retval; 3360 } 3361 return rv; 3362 } 3363 rsys_define(rumpns_sys_fsetxattr); 3364 rsys_aliases(fsetxattr,rump___sysimpl_fsetxattr); 3365 3366 int rump___sysimpl_getxattr(const char *, const char *, void *, size_t); 3367 int 3368 rump___sysimpl_getxattr(const char * path, const char * name, void * value, size_t size) 3369 { 3370 register_t retval[2] = {0, 0}; 3371 int error = 0; 3372 int rv = -1; 3373 struct sys_getxattr_args callarg; 3374 3375 SPARG(&callarg, path) = path; 3376 SPARG(&callarg, name) = name; 3377 SPARG(&callarg, value) = value; 3378 SPARG(&callarg, size) = size; 3379 3380 error = rsys_syscall(SYS_getxattr, &callarg, sizeof(callarg), retval); 3381 rsys_seterrno(error); 3382 if (error == 0) { 3383 if (sizeof(int) > sizeof(register_t)) 3384 rv = *(int *)retval; 3385 else 3386 rv = *retval; 3387 } 3388 return rv; 3389 } 3390 rsys_define(rumpns_sys_getxattr); 3391 rsys_aliases(getxattr,rump___sysimpl_getxattr); 3392 3393 int rump___sysimpl_lgetxattr(const char *, const char *, void *, size_t); 3394 int 3395 rump___sysimpl_lgetxattr(const char * path, const char * name, void * value, size_t size) 3396 { 3397 register_t retval[2] = {0, 0}; 3398 int error = 0; 3399 int rv = -1; 3400 struct sys_lgetxattr_args callarg; 3401 3402 SPARG(&callarg, path) = path; 3403 SPARG(&callarg, name) = name; 3404 SPARG(&callarg, value) = value; 3405 SPARG(&callarg, size) = size; 3406 3407 error = rsys_syscall(SYS_lgetxattr, &callarg, sizeof(callarg), retval); 3408 rsys_seterrno(error); 3409 if (error == 0) { 3410 if (sizeof(int) > sizeof(register_t)) 3411 rv = *(int *)retval; 3412 else 3413 rv = *retval; 3414 } 3415 return rv; 3416 } 3417 rsys_define(rumpns_sys_lgetxattr); 3418 rsys_aliases(lgetxattr,rump___sysimpl_lgetxattr); 3419 3420 int rump___sysimpl_fgetxattr(int, const char *, void *, size_t); 3421 int 3422 rump___sysimpl_fgetxattr(int fd, const char * name, void * value, size_t size) 3423 { 3424 register_t retval[2] = {0, 0}; 3425 int error = 0; 3426 int rv = -1; 3427 struct sys_fgetxattr_args callarg; 3428 3429 SPARG(&callarg, fd) = fd; 3430 SPARG(&callarg, name) = name; 3431 SPARG(&callarg, value) = value; 3432 SPARG(&callarg, size) = size; 3433 3434 error = rsys_syscall(SYS_fgetxattr, &callarg, sizeof(callarg), retval); 3435 rsys_seterrno(error); 3436 if (error == 0) { 3437 if (sizeof(int) > sizeof(register_t)) 3438 rv = *(int *)retval; 3439 else 3440 rv = *retval; 3441 } 3442 return rv; 3443 } 3444 rsys_define(rumpns_sys_fgetxattr); 3445 rsys_aliases(fgetxattr,rump___sysimpl_fgetxattr); 3446 3447 int rump___sysimpl_listxattr(const char *, char *, size_t); 3448 int 3449 rump___sysimpl_listxattr(const char * path, char * list, size_t size) 3450 { 3451 register_t retval[2] = {0, 0}; 3452 int error = 0; 3453 int rv = -1; 3454 struct sys_listxattr_args callarg; 3455 3456 SPARG(&callarg, path) = path; 3457 SPARG(&callarg, list) = list; 3458 SPARG(&callarg, size) = size; 3459 3460 error = rsys_syscall(SYS_listxattr, &callarg, sizeof(callarg), retval); 3461 rsys_seterrno(error); 3462 if (error == 0) { 3463 if (sizeof(int) > sizeof(register_t)) 3464 rv = *(int *)retval; 3465 else 3466 rv = *retval; 3467 } 3468 return rv; 3469 } 3470 rsys_define(rumpns_sys_listxattr); 3471 rsys_aliases(listxattr,rump___sysimpl_listxattr); 3472 3473 int rump___sysimpl_llistxattr(const char *, char *, size_t); 3474 int 3475 rump___sysimpl_llistxattr(const char * path, char * list, size_t size) 3476 { 3477 register_t retval[2] = {0, 0}; 3478 int error = 0; 3479 int rv = -1; 3480 struct sys_llistxattr_args callarg; 3481 3482 SPARG(&callarg, path) = path; 3483 SPARG(&callarg, list) = list; 3484 SPARG(&callarg, size) = size; 3485 3486 error = rsys_syscall(SYS_llistxattr, &callarg, sizeof(callarg), retval); 3487 rsys_seterrno(error); 3488 if (error == 0) { 3489 if (sizeof(int) > sizeof(register_t)) 3490 rv = *(int *)retval; 3491 else 3492 rv = *retval; 3493 } 3494 return rv; 3495 } 3496 rsys_define(rumpns_sys_llistxattr); 3497 rsys_aliases(llistxattr,rump___sysimpl_llistxattr); 3498 3499 int rump___sysimpl_flistxattr(int, char *, size_t); 3500 int 3501 rump___sysimpl_flistxattr(int fd, char * list, size_t size) 3502 { 3503 register_t retval[2] = {0, 0}; 3504 int error = 0; 3505 int rv = -1; 3506 struct sys_flistxattr_args callarg; 3507 3508 SPARG(&callarg, fd) = fd; 3509 SPARG(&callarg, list) = list; 3510 SPARG(&callarg, size) = size; 3511 3512 error = rsys_syscall(SYS_flistxattr, &callarg, sizeof(callarg), retval); 3513 rsys_seterrno(error); 3514 if (error == 0) { 3515 if (sizeof(int) > sizeof(register_t)) 3516 rv = *(int *)retval; 3517 else 3518 rv = *retval; 3519 } 3520 return rv; 3521 } 3522 rsys_define(rumpns_sys_flistxattr); 3523 rsys_aliases(flistxattr,rump___sysimpl_flistxattr); 3524 3525 int rump___sysimpl_removexattr(const char *, const char *); 3526 int 3527 rump___sysimpl_removexattr(const char * path, const char * name) 3528 { 3529 register_t retval[2] = {0, 0}; 3530 int error = 0; 3531 int rv = -1; 3532 struct sys_removexattr_args callarg; 3533 3534 SPARG(&callarg, path) = path; 3535 SPARG(&callarg, name) = name; 3536 3537 error = rsys_syscall(SYS_removexattr, &callarg, sizeof(callarg), retval); 3538 rsys_seterrno(error); 3539 if (error == 0) { 3540 if (sizeof(int) > sizeof(register_t)) 3541 rv = *(int *)retval; 3542 else 3543 rv = *retval; 3544 } 3545 return rv; 3546 } 3547 rsys_define(rumpns_sys_removexattr); 3548 rsys_aliases(removexattr,rump___sysimpl_removexattr); 3549 3550 int rump___sysimpl_lremovexattr(const char *, const char *); 3551 int 3552 rump___sysimpl_lremovexattr(const char * path, const char * name) 3553 { 3554 register_t retval[2] = {0, 0}; 3555 int error = 0; 3556 int rv = -1; 3557 struct sys_lremovexattr_args callarg; 3558 3559 SPARG(&callarg, path) = path; 3560 SPARG(&callarg, name) = name; 3561 3562 error = rsys_syscall(SYS_lremovexattr, &callarg, sizeof(callarg), retval); 3563 rsys_seterrno(error); 3564 if (error == 0) { 3565 if (sizeof(int) > sizeof(register_t)) 3566 rv = *(int *)retval; 3567 else 3568 rv = *retval; 3569 } 3570 return rv; 3571 } 3572 rsys_define(rumpns_sys_lremovexattr); 3573 rsys_aliases(lremovexattr,rump___sysimpl_lremovexattr); 3574 3575 int rump___sysimpl_fremovexattr(int, const char *); 3576 int 3577 rump___sysimpl_fremovexattr(int fd, const char * name) 3578 { 3579 register_t retval[2] = {0, 0}; 3580 int error = 0; 3581 int rv = -1; 3582 struct sys_fremovexattr_args callarg; 3583 3584 SPARG(&callarg, fd) = fd; 3585 SPARG(&callarg, name) = name; 3586 3587 error = rsys_syscall(SYS_fremovexattr, &callarg, sizeof(callarg), retval); 3588 rsys_seterrno(error); 3589 if (error == 0) { 3590 if (sizeof(int) > sizeof(register_t)) 3591 rv = *(int *)retval; 3592 else 3593 rv = *retval; 3594 } 3595 return rv; 3596 } 3597 rsys_define(rumpns_sys_fremovexattr); 3598 rsys_aliases(fremovexattr,rump___sysimpl_fremovexattr); 3599 3600 int rump___sysimpl_stat30(const char *, struct stat *); 3601 int 3602 rump___sysimpl_stat30(const char * path, struct stat * ub) 3603 { 3604 register_t retval[2] = {0, 0}; 3605 int error = 0; 3606 int rv = -1; 3607 struct compat_50_sys___stat30_args callarg; 3608 3609 SPARG(&callarg, path) = path; 3610 SPARG(&callarg, ub) = (struct stat30 *)ub; 3611 3612 error = rsys_syscall(SYS_compat_50___stat30, &callarg, sizeof(callarg), retval); 3613 rsys_seterrno(error); 3614 if (error == 0) { 3615 if (sizeof(int) > sizeof(register_t)) 3616 rv = *(int *)retval; 3617 else 3618 rv = *retval; 3619 } 3620 return rv; 3621 } 3622 rsys_define(rumpns_compat_50_sys___stat30); 3623 rsys_aliases(compat_50___stat30,rump___sysimpl_stat30); 3624 3625 int rump___sysimpl_fstat30(int, struct stat *); 3626 int 3627 rump___sysimpl_fstat30(int fd, struct stat * sb) 3628 { 3629 register_t retval[2] = {0, 0}; 3630 int error = 0; 3631 int rv = -1; 3632 struct compat_50_sys___fstat30_args callarg; 3633 3634 SPARG(&callarg, fd) = fd; 3635 SPARG(&callarg, sb) = (struct stat30 *)sb; 3636 3637 error = rsys_syscall(SYS_compat_50___fstat30, &callarg, sizeof(callarg), retval); 3638 rsys_seterrno(error); 3639 if (error == 0) { 3640 if (sizeof(int) > sizeof(register_t)) 3641 rv = *(int *)retval; 3642 else 3643 rv = *retval; 3644 } 3645 return rv; 3646 } 3647 rsys_define(rumpns_compat_50_sys___fstat30); 3648 rsys_aliases(compat_50___fstat30,rump___sysimpl_fstat30); 3649 3650 int rump___sysimpl_lstat30(const char *, struct stat *); 3651 int 3652 rump___sysimpl_lstat30(const char * path, struct stat * ub) 3653 { 3654 register_t retval[2] = {0, 0}; 3655 int error = 0; 3656 int rv = -1; 3657 struct compat_50_sys___lstat30_args callarg; 3658 3659 SPARG(&callarg, path) = path; 3660 SPARG(&callarg, ub) = (struct stat30 *)ub; 3661 3662 error = rsys_syscall(SYS_compat_50___lstat30, &callarg, sizeof(callarg), retval); 3663 rsys_seterrno(error); 3664 if (error == 0) { 3665 if (sizeof(int) > sizeof(register_t)) 3666 rv = *(int *)retval; 3667 else 3668 rv = *retval; 3669 } 3670 return rv; 3671 } 3672 rsys_define(rumpns_compat_50_sys___lstat30); 3673 rsys_aliases(compat_50___lstat30,rump___sysimpl_lstat30); 3674 3675 int rump___sysimpl_getdents30(int, char *, size_t); 3676 int 3677 rump___sysimpl_getdents30(int fd, char * buf, size_t count) 3678 { 3679 register_t retval[2] = {0, 0}; 3680 int error = 0; 3681 int rv = -1; 3682 struct sys___getdents30_args callarg; 3683 3684 SPARG(&callarg, fd) = fd; 3685 SPARG(&callarg, buf) = buf; 3686 SPARG(&callarg, count) = count; 3687 3688 error = rsys_syscall(SYS___getdents30, &callarg, sizeof(callarg), retval); 3689 rsys_seterrno(error); 3690 if (error == 0) { 3691 if (sizeof(int) > sizeof(register_t)) 3692 rv = *(int *)retval; 3693 else 3694 rv = *retval; 3695 } 3696 return rv; 3697 } 3698 rsys_define(rumpns_sys___getdents30); 3699 rsys_aliases(__getdents30,rump___sysimpl_getdents30); 3700 3701 int rump___sysimpl_socket30(int, int, int); 3702 int 3703 rump___sysimpl_socket30(int domain, int type, int protocol) 3704 { 3705 register_t retval[2] = {0, 0}; 3706 int error = 0; 3707 int rv = -1; 3708 struct sys___socket30_args callarg; 3709 3710 SPARG(&callarg, domain) = domain; 3711 SPARG(&callarg, type) = type; 3712 SPARG(&callarg, protocol) = protocol; 3713 3714 error = rsys_syscall(SYS___socket30, &callarg, sizeof(callarg), retval); 3715 rsys_seterrno(error); 3716 if (error == 0) { 3717 if (sizeof(int) > sizeof(register_t)) 3718 rv = *(int *)retval; 3719 else 3720 rv = *retval; 3721 } 3722 return rv; 3723 } 3724 rsys_define(rumpns_sys___socket30); 3725 rsys_aliases(__socket30,rump___sysimpl_socket30); 3726 3727 int rump___sysimpl_getfh30(const char *, void *, size_t *); 3728 int 3729 rump___sysimpl_getfh30(const char * fname, void * fhp, size_t * fh_size) 3730 { 3731 register_t retval[2] = {0, 0}; 3732 int error = 0; 3733 int rv = -1; 3734 struct sys___getfh30_args callarg; 3735 3736 SPARG(&callarg, fname) = fname; 3737 SPARG(&callarg, fhp) = fhp; 3738 SPARG(&callarg, fh_size) = fh_size; 3739 3740 error = rsys_syscall(SYS___getfh30, &callarg, sizeof(callarg), retval); 3741 rsys_seterrno(error); 3742 if (error == 0) { 3743 if (sizeof(int) > sizeof(register_t)) 3744 rv = *(int *)retval; 3745 else 3746 rv = *retval; 3747 } 3748 return rv; 3749 } 3750 rsys_define(rumpns_sys___getfh30); 3751 rsys_aliases(__getfh30,rump___sysimpl_getfh30); 3752 3753 int rump___sysimpl_fhopen40(const void *, size_t, int); 3754 int 3755 rump___sysimpl_fhopen40(const void * fhp, size_t fh_size, int flags) 3756 { 3757 register_t retval[2] = {0, 0}; 3758 int error = 0; 3759 int rv = -1; 3760 struct sys___fhopen40_args callarg; 3761 3762 SPARG(&callarg, fhp) = fhp; 3763 SPARG(&callarg, fh_size) = fh_size; 3764 SPARG(&callarg, flags) = flags; 3765 3766 error = rsys_syscall(SYS___fhopen40, &callarg, sizeof(callarg), retval); 3767 rsys_seterrno(error); 3768 if (error == 0) { 3769 if (sizeof(int) > sizeof(register_t)) 3770 rv = *(int *)retval; 3771 else 3772 rv = *retval; 3773 } 3774 return rv; 3775 } 3776 rsys_define(rumpns_sys___fhopen40); 3777 rsys_aliases(__fhopen40,rump___sysimpl_fhopen40); 3778 3779 int rump___sysimpl_fhstatvfs140(const void *, size_t, struct statvfs *, int); 3780 int 3781 rump___sysimpl_fhstatvfs140(const void * fhp, size_t fh_size, struct statvfs * buf, int flags) 3782 { 3783 register_t retval[2] = {0, 0}; 3784 int error = 0; 3785 int rv = -1; 3786 struct sys___fhstatvfs140_args callarg; 3787 3788 SPARG(&callarg, fhp) = fhp; 3789 SPARG(&callarg, fh_size) = fh_size; 3790 SPARG(&callarg, buf) = buf; 3791 SPARG(&callarg, flags) = flags; 3792 3793 error = rsys_syscall(SYS___fhstatvfs140, &callarg, sizeof(callarg), retval); 3794 rsys_seterrno(error); 3795 if (error == 0) { 3796 if (sizeof(int) > sizeof(register_t)) 3797 rv = *(int *)retval; 3798 else 3799 rv = *retval; 3800 } 3801 return rv; 3802 } 3803 rsys_define(rumpns_sys___fhstatvfs140); 3804 rsys_aliases(__fhstatvfs140,rump___sysimpl_fhstatvfs140); 3805 3806 int rump___sysimpl_fhstat40(const void *, size_t, struct stat *); 3807 int 3808 rump___sysimpl_fhstat40(const void * fhp, size_t fh_size, struct stat * sb) 3809 { 3810 register_t retval[2] = {0, 0}; 3811 int error = 0; 3812 int rv = -1; 3813 struct compat_50_sys___fhstat40_args callarg; 3814 3815 SPARG(&callarg, fhp) = fhp; 3816 SPARG(&callarg, fh_size) = fh_size; 3817 SPARG(&callarg, sb) = (struct stat30 *)sb; 3818 3819 error = rsys_syscall(SYS_compat_50___fhstat40, &callarg, sizeof(callarg), retval); 3820 rsys_seterrno(error); 3821 if (error == 0) { 3822 if (sizeof(int) > sizeof(register_t)) 3823 rv = *(int *)retval; 3824 else 3825 rv = *retval; 3826 } 3827 return rv; 3828 } 3829 rsys_define(rumpns_compat_50_sys___fhstat40); 3830 rsys_aliases(compat_50___fhstat40,rump___sysimpl_fhstat40); 3831 3832 int rump___sysimpl_mount50(const char *, const char *, int, void *, size_t); 3833 int 3834 rump___sysimpl_mount50(const char * type, const char * path, int flags, void * data, size_t data_len) 3835 { 3836 register_t retval[2] = {0, 0}; 3837 int error = 0; 3838 int rv = -1; 3839 struct sys___mount50_args callarg; 3840 3841 SPARG(&callarg, type) = type; 3842 SPARG(&callarg, path) = path; 3843 SPARG(&callarg, flags) = flags; 3844 SPARG(&callarg, data) = data; 3845 SPARG(&callarg, data_len) = data_len; 3846 3847 error = rsys_syscall(SYS___mount50, &callarg, sizeof(callarg), retval); 3848 rsys_seterrno(error); 3849 if (error == 0) { 3850 if (sizeof(int) > sizeof(register_t)) 3851 rv = *(int *)retval; 3852 else 3853 rv = *retval; 3854 } 3855 return rv; 3856 } 3857 rsys_define(rumpns_sys___mount50); 3858 rsys_aliases(__mount50,rump___sysimpl_mount50); 3859 3860 int rump___sysimpl_posix_fadvise50(int, off_t, off_t, int); 3861 int 3862 rump___sysimpl_posix_fadvise50(int fd, off_t offset, off_t len, int advice) 3863 { 3864 register_t retval[2] = {0, 0}; 3865 int rv = -1; 3866 struct sys___posix_fadvise50_args callarg; 3867 3868 SPARG(&callarg, fd) = fd; 3869 SPARG(&callarg, PAD) = 0; 3870 SPARG(&callarg, offset) = offset; 3871 SPARG(&callarg, len) = len; 3872 SPARG(&callarg, advice) = advice; 3873 3874 rsys_syscall(SYS___posix_fadvise50, &callarg, sizeof(callarg), retval); 3875 if (sizeof(int) > sizeof(register_t)) 3876 rv = *(int *)retval; 3877 else 3878 rv = *retval; 3879 return rv; 3880 } 3881 rsys_define(rumpns_sys___posix_fadvise50); 3882 rsys_aliases(__posix_fadvise50,rump___sysimpl_posix_fadvise50); 3883 3884 int rump___sysimpl_select50(int, fd_set *, fd_set *, fd_set *, struct timeval *); 3885 int 3886 rump___sysimpl_select50(int nd, fd_set * in, fd_set * ou, fd_set * ex, struct timeval * tv) 3887 { 3888 register_t retval[2] = {0, 0}; 3889 int error = 0; 3890 int rv = -1; 3891 struct sys___select50_args callarg; 3892 3893 SPARG(&callarg, nd) = nd; 3894 SPARG(&callarg, in) = in; 3895 SPARG(&callarg, ou) = ou; 3896 SPARG(&callarg, ex) = ex; 3897 SPARG(&callarg, tv) = tv; 3898 3899 error = rsys_syscall(SYS___select50, &callarg, sizeof(callarg), retval); 3900 rsys_seterrno(error); 3901 if (error == 0) { 3902 if (sizeof(int) > sizeof(register_t)) 3903 rv = *(int *)retval; 3904 else 3905 rv = *retval; 3906 } 3907 return rv; 3908 } 3909 rsys_define(rumpns_sys___select50); 3910 rsys_aliases(__select50,rump___sysimpl_select50); 3911 3912 int rump___sysimpl_utimes50(const char *, const struct timeval *); 3913 int 3914 rump___sysimpl_utimes50(const char * path, const struct timeval * tptr) 3915 { 3916 register_t retval[2] = {0, 0}; 3917 int error = 0; 3918 int rv = -1; 3919 struct sys___utimes50_args callarg; 3920 3921 SPARG(&callarg, path) = path; 3922 SPARG(&callarg, tptr) = tptr; 3923 3924 error = rsys_syscall(SYS___utimes50, &callarg, sizeof(callarg), retval); 3925 rsys_seterrno(error); 3926 if (error == 0) { 3927 if (sizeof(int) > sizeof(register_t)) 3928 rv = *(int *)retval; 3929 else 3930 rv = *retval; 3931 } 3932 return rv; 3933 } 3934 rsys_define(rumpns_sys___utimes50); 3935 rsys_aliases(__utimes50,rump___sysimpl_utimes50); 3936 3937 int rump___sysimpl_futimes50(int, const struct timeval *); 3938 int 3939 rump___sysimpl_futimes50(int fd, const struct timeval * tptr) 3940 { 3941 register_t retval[2] = {0, 0}; 3942 int error = 0; 3943 int rv = -1; 3944 struct sys___futimes50_args callarg; 3945 3946 SPARG(&callarg, fd) = fd; 3947 SPARG(&callarg, tptr) = tptr; 3948 3949 error = rsys_syscall(SYS___futimes50, &callarg, sizeof(callarg), retval); 3950 rsys_seterrno(error); 3951 if (error == 0) { 3952 if (sizeof(int) > sizeof(register_t)) 3953 rv = *(int *)retval; 3954 else 3955 rv = *retval; 3956 } 3957 return rv; 3958 } 3959 rsys_define(rumpns_sys___futimes50); 3960 rsys_aliases(__futimes50,rump___sysimpl_futimes50); 3961 3962 int rump___sysimpl_lutimes50(const char *, const struct timeval *); 3963 int 3964 rump___sysimpl_lutimes50(const char * path, const struct timeval * tptr) 3965 { 3966 register_t retval[2] = {0, 0}; 3967 int error = 0; 3968 int rv = -1; 3969 struct sys___lutimes50_args callarg; 3970 3971 SPARG(&callarg, path) = path; 3972 SPARG(&callarg, tptr) = tptr; 3973 3974 error = rsys_syscall(SYS___lutimes50, &callarg, sizeof(callarg), retval); 3975 rsys_seterrno(error); 3976 if (error == 0) { 3977 if (sizeof(int) > sizeof(register_t)) 3978 rv = *(int *)retval; 3979 else 3980 rv = *retval; 3981 } 3982 return rv; 3983 } 3984 rsys_define(rumpns_sys___lutimes50); 3985 rsys_aliases(__lutimes50,rump___sysimpl_lutimes50); 3986 3987 int rump___sysimpl_kevent50(int, const struct kevent *, size_t, struct kevent *, size_t, const struct timespec *); 3988 int 3989 rump___sysimpl_kevent50(int fd, const struct kevent * changelist, size_t nchanges, struct kevent * eventlist, size_t nevents, const struct timespec * timeout) 3990 { 3991 register_t retval[2] = {0, 0}; 3992 int error = 0; 3993 int rv = -1; 3994 struct sys___kevent50_args callarg; 3995 3996 SPARG(&callarg, fd) = fd; 3997 SPARG(&callarg, changelist) = changelist; 3998 SPARG(&callarg, nchanges) = nchanges; 3999 SPARG(&callarg, eventlist) = eventlist; 4000 SPARG(&callarg, nevents) = nevents; 4001 SPARG(&callarg, timeout) = timeout; 4002 4003 error = rsys_syscall(SYS___kevent50, &callarg, sizeof(callarg), retval); 4004 rsys_seterrno(error); 4005 if (error == 0) { 4006 if (sizeof(int) > sizeof(register_t)) 4007 rv = *(int *)retval; 4008 else 4009 rv = *retval; 4010 } 4011 return rv; 4012 } 4013 rsys_define(rumpns_sys___kevent50); 4014 rsys_aliases(__kevent50,rump___sysimpl_kevent50); 4015 4016 int rump___sysimpl_pselect50(int, fd_set *, fd_set *, fd_set *, const struct timespec *, const sigset_t *); 4017 int 4018 rump___sysimpl_pselect50(int nd, fd_set * in, fd_set * ou, fd_set * ex, const struct timespec * ts, const sigset_t * mask) 4019 { 4020 register_t retval[2] = {0, 0}; 4021 int error = 0; 4022 int rv = -1; 4023 struct sys___pselect50_args callarg; 4024 4025 SPARG(&callarg, nd) = nd; 4026 SPARG(&callarg, in) = in; 4027 SPARG(&callarg, ou) = ou; 4028 SPARG(&callarg, ex) = ex; 4029 SPARG(&callarg, ts) = ts; 4030 SPARG(&callarg, mask) = mask; 4031 4032 error = rsys_syscall(SYS___pselect50, &callarg, sizeof(callarg), retval); 4033 rsys_seterrno(error); 4034 if (error == 0) { 4035 if (sizeof(int) > sizeof(register_t)) 4036 rv = *(int *)retval; 4037 else 4038 rv = *retval; 4039 } 4040 return rv; 4041 } 4042 rsys_define(rumpns_sys___pselect50); 4043 rsys_aliases(__pselect50,rump___sysimpl_pselect50); 4044 4045 int rump___sysimpl_pollts50(struct pollfd *, u_int, const struct timespec *, const sigset_t *); 4046 int 4047 rump___sysimpl_pollts50(struct pollfd * fds, u_int nfds, const struct timespec * ts, const sigset_t * mask) 4048 { 4049 register_t retval[2] = {0, 0}; 4050 int error = 0; 4051 int rv = -1; 4052 struct sys___pollts50_args callarg; 4053 4054 SPARG(&callarg, fds) = fds; 4055 SPARG(&callarg, nfds) = nfds; 4056 SPARG(&callarg, ts) = ts; 4057 SPARG(&callarg, mask) = mask; 4058 4059 error = rsys_syscall(SYS___pollts50, &callarg, sizeof(callarg), retval); 4060 rsys_seterrno(error); 4061 if (error == 0) { 4062 if (sizeof(int) > sizeof(register_t)) 4063 rv = *(int *)retval; 4064 else 4065 rv = *retval; 4066 } 4067 return rv; 4068 } 4069 rsys_define(rumpns_sys___pollts50); 4070 rsys_aliases(__pollts50,rump___sysimpl_pollts50); 4071 4072 int rump___sysimpl_stat50(const char *, struct stat *); 4073 int 4074 rump___sysimpl_stat50(const char * path, struct stat * ub) 4075 { 4076 register_t retval[2] = {0, 0}; 4077 int error = 0; 4078 int rv = -1; 4079 struct sys___stat50_args callarg; 4080 4081 SPARG(&callarg, path) = path; 4082 SPARG(&callarg, ub) = ub; 4083 4084 error = rsys_syscall(SYS___stat50, &callarg, sizeof(callarg), retval); 4085 rsys_seterrno(error); 4086 if (error == 0) { 4087 if (sizeof(int) > sizeof(register_t)) 4088 rv = *(int *)retval; 4089 else 4090 rv = *retval; 4091 } 4092 return rv; 4093 } 4094 rsys_define(rumpns_sys___stat50); 4095 rsys_aliases(__stat50,rump___sysimpl_stat50); 4096 4097 int rump___sysimpl_fstat50(int, struct stat *); 4098 int 4099 rump___sysimpl_fstat50(int fd, struct stat * sb) 4100 { 4101 register_t retval[2] = {0, 0}; 4102 int error = 0; 4103 int rv = -1; 4104 struct sys___fstat50_args callarg; 4105 4106 SPARG(&callarg, fd) = fd; 4107 SPARG(&callarg, sb) = sb; 4108 4109 error = rsys_syscall(SYS___fstat50, &callarg, sizeof(callarg), retval); 4110 rsys_seterrno(error); 4111 if (error == 0) { 4112 if (sizeof(int) > sizeof(register_t)) 4113 rv = *(int *)retval; 4114 else 4115 rv = *retval; 4116 } 4117 return rv; 4118 } 4119 rsys_define(rumpns_sys___fstat50); 4120 rsys_aliases(__fstat50,rump___sysimpl_fstat50); 4121 4122 int rump___sysimpl_lstat50(const char *, struct stat *); 4123 int 4124 rump___sysimpl_lstat50(const char * path, struct stat * ub) 4125 { 4126 register_t retval[2] = {0, 0}; 4127 int error = 0; 4128 int rv = -1; 4129 struct sys___lstat50_args callarg; 4130 4131 SPARG(&callarg, path) = path; 4132 SPARG(&callarg, ub) = ub; 4133 4134 error = rsys_syscall(SYS___lstat50, &callarg, sizeof(callarg), retval); 4135 rsys_seterrno(error); 4136 if (error == 0) { 4137 if (sizeof(int) > sizeof(register_t)) 4138 rv = *(int *)retval; 4139 else 4140 rv = *retval; 4141 } 4142 return rv; 4143 } 4144 rsys_define(rumpns_sys___lstat50); 4145 rsys_aliases(__lstat50,rump___sysimpl_lstat50); 4146 4147 int rump___sysimpl_mknod50(const char *, mode_t, dev_t); 4148 int 4149 rump___sysimpl_mknod50(const char * path, mode_t mode, dev_t dev) 4150 { 4151 register_t retval[2] = {0, 0}; 4152 int error = 0; 4153 int rv = -1; 4154 struct sys___mknod50_args callarg; 4155 4156 SPARG(&callarg, path) = path; 4157 SPARG(&callarg, mode) = mode; 4158 SPARG(&callarg, dev) = dev; 4159 4160 error = rsys_syscall(SYS___mknod50, &callarg, sizeof(callarg), retval); 4161 rsys_seterrno(error); 4162 if (error == 0) { 4163 if (sizeof(int) > sizeof(register_t)) 4164 rv = *(int *)retval; 4165 else 4166 rv = *retval; 4167 } 4168 return rv; 4169 } 4170 rsys_define(rumpns_sys___mknod50); 4171 rsys_aliases(__mknod50,rump___sysimpl_mknod50); 4172 4173 int rump___sysimpl_fhstat50(const void *, size_t, struct stat *); 4174 int 4175 rump___sysimpl_fhstat50(const void * fhp, size_t fh_size, struct stat * sb) 4176 { 4177 register_t retval[2] = {0, 0}; 4178 int error = 0; 4179 int rv = -1; 4180 struct sys___fhstat50_args callarg; 4181 4182 SPARG(&callarg, fhp) = fhp; 4183 SPARG(&callarg, fh_size) = fh_size; 4184 SPARG(&callarg, sb) = sb; 4185 4186 error = rsys_syscall(SYS___fhstat50, &callarg, sizeof(callarg), retval); 4187 rsys_seterrno(error); 4188 if (error == 0) { 4189 if (sizeof(int) > sizeof(register_t)) 4190 rv = *(int *)retval; 4191 else 4192 rv = *retval; 4193 } 4194 return rv; 4195 } 4196 rsys_define(rumpns_sys___fhstat50); 4197 rsys_aliases(__fhstat50,rump___sysimpl_fhstat50); 4198 4199 int rump___sysimpl_pipe2(int *, int); 4200 int 4201 rump___sysimpl_pipe2(int * fildes, int flags) 4202 { 4203 register_t retval[2] = {0, 0}; 4204 int error = 0; 4205 int rv = -1; 4206 struct sys_pipe2_args callarg; 4207 4208 SPARG(&callarg, fildes) = fildes; 4209 SPARG(&callarg, flags) = flags; 4210 4211 error = rsys_syscall(SYS_pipe2, &callarg, sizeof(callarg), retval); 4212 rsys_seterrno(error); 4213 if (error == 0) { 4214 if (sizeof(int) > sizeof(register_t)) 4215 rv = *(int *)retval; 4216 else 4217 rv = *retval; 4218 } 4219 return rv; 4220 } 4221 rsys_define(rumpns_sys_pipe2); 4222 rsys_aliases(pipe2,rump___sysimpl_pipe2); 4223 4224 int rump___sysimpl_dup3(int, int, int); 4225 int 4226 rump___sysimpl_dup3(int from, int to, int flags) 4227 { 4228 register_t retval[2] = {0, 0}; 4229 int error = 0; 4230 int rv = -1; 4231 struct sys_dup3_args callarg; 4232 4233 SPARG(&callarg, from) = from; 4234 SPARG(&callarg, to) = to; 4235 SPARG(&callarg, flags) = flags; 4236 4237 error = rsys_syscall(SYS_dup3, &callarg, sizeof(callarg), retval); 4238 rsys_seterrno(error); 4239 if (error == 0) { 4240 if (sizeof(int) > sizeof(register_t)) 4241 rv = *(int *)retval; 4242 else 4243 rv = *retval; 4244 } 4245 return rv; 4246 } 4247 rsys_define(rumpns_sys_dup3); 4248 rsys_aliases(dup3,rump___sysimpl_dup3); 4249 4250 int rump___sysimpl_kqueue1(int); 4251 int 4252 rump___sysimpl_kqueue1(int flags) 4253 { 4254 register_t retval[2] = {0, 0}; 4255 int error = 0; 4256 int rv = -1; 4257 struct sys_kqueue1_args callarg; 4258 4259 SPARG(&callarg, flags) = flags; 4260 4261 error = rsys_syscall(SYS_kqueue1, &callarg, sizeof(callarg), retval); 4262 rsys_seterrno(error); 4263 if (error == 0) { 4264 if (sizeof(int) > sizeof(register_t)) 4265 rv = *(int *)retval; 4266 else 4267 rv = *retval; 4268 } 4269 return rv; 4270 } 4271 rsys_define(rumpns_sys_kqueue1); 4272 rsys_aliases(kqueue1,rump___sysimpl_kqueue1); 4273 4274 int rump___sysimpl_paccept(int, struct sockaddr *, socklen_t *, const sigset_t *, int); 4275 int 4276 rump___sysimpl_paccept(int s, struct sockaddr * name, socklen_t * anamelen, const sigset_t * mask, int flags) 4277 { 4278 register_t retval[2] = {0, 0}; 4279 int error = 0; 4280 int rv = -1; 4281 struct sys_paccept_args callarg; 4282 4283 SPARG(&callarg, s) = s; 4284 SPARG(&callarg, name) = name; 4285 SPARG(&callarg, anamelen) = anamelen; 4286 SPARG(&callarg, mask) = mask; 4287 SPARG(&callarg, flags) = flags; 4288 4289 error = rsys_syscall(SYS_paccept, &callarg, sizeof(callarg), retval); 4290 rsys_seterrno(error); 4291 if (error == 0) { 4292 if (sizeof(int) > sizeof(register_t)) 4293 rv = *(int *)retval; 4294 else 4295 rv = *retval; 4296 } 4297 return rv; 4298 } 4299 rsys_define(rumpns_sys_paccept); 4300 rsys_aliases(paccept,rump___sysimpl_paccept); 4301 4302 int rump___sysimpl_linkat(int, const char *, int, const char *, int); 4303 int 4304 rump___sysimpl_linkat(int fd1, const char * name1, int fd2, const char * name2, int flags) 4305 { 4306 register_t retval[2] = {0, 0}; 4307 int error = 0; 4308 int rv = -1; 4309 struct sys_linkat_args callarg; 4310 4311 SPARG(&callarg, fd1) = fd1; 4312 SPARG(&callarg, name1) = name1; 4313 SPARG(&callarg, fd2) = fd2; 4314 SPARG(&callarg, name2) = name2; 4315 SPARG(&callarg, flags) = flags; 4316 4317 error = rsys_syscall(SYS_linkat, &callarg, sizeof(callarg), retval); 4318 rsys_seterrno(error); 4319 if (error == 0) { 4320 if (sizeof(int) > sizeof(register_t)) 4321 rv = *(int *)retval; 4322 else 4323 rv = *retval; 4324 } 4325 return rv; 4326 } 4327 rsys_define(rumpns_sys_linkat); 4328 rsys_aliases(linkat,rump___sysimpl_linkat); 4329 4330 int rump___sysimpl_renameat(int, const char *, int, const char *); 4331 int 4332 rump___sysimpl_renameat(int fromfd, const char * from, int tofd, const char * to) 4333 { 4334 register_t retval[2] = {0, 0}; 4335 int error = 0; 4336 int rv = -1; 4337 struct sys_renameat_args callarg; 4338 4339 SPARG(&callarg, fromfd) = fromfd; 4340 SPARG(&callarg, from) = from; 4341 SPARG(&callarg, tofd) = tofd; 4342 SPARG(&callarg, to) = to; 4343 4344 error = rsys_syscall(SYS_renameat, &callarg, sizeof(callarg), retval); 4345 rsys_seterrno(error); 4346 if (error == 0) { 4347 if (sizeof(int) > sizeof(register_t)) 4348 rv = *(int *)retval; 4349 else 4350 rv = *retval; 4351 } 4352 return rv; 4353 } 4354 rsys_define(rumpns_sys_renameat); 4355 rsys_aliases(renameat,rump___sysimpl_renameat); 4356 4357 int rump___sysimpl_mkfifoat(int, const char *, mode_t); 4358 int 4359 rump___sysimpl_mkfifoat(int fd, const char * path, mode_t mode) 4360 { 4361 register_t retval[2] = {0, 0}; 4362 int error = 0; 4363 int rv = -1; 4364 struct sys_mkfifoat_args callarg; 4365 4366 SPARG(&callarg, fd) = fd; 4367 SPARG(&callarg, path) = path; 4368 SPARG(&callarg, mode) = mode; 4369 4370 error = rsys_syscall(SYS_mkfifoat, &callarg, sizeof(callarg), retval); 4371 rsys_seterrno(error); 4372 if (error == 0) { 4373 if (sizeof(int) > sizeof(register_t)) 4374 rv = *(int *)retval; 4375 else 4376 rv = *retval; 4377 } 4378 return rv; 4379 } 4380 rsys_define(rumpns_sys_mkfifoat); 4381 rsys_aliases(mkfifoat,rump___sysimpl_mkfifoat); 4382 4383 int rump___sysimpl_mknodat(int, const char *, mode_t, dev_t); 4384 int 4385 rump___sysimpl_mknodat(int fd, const char * path, mode_t mode, dev_t dev) 4386 { 4387 register_t retval[2] = {0, 0}; 4388 int error = 0; 4389 int rv = -1; 4390 struct sys_mknodat_args callarg; 4391 4392 SPARG(&callarg, fd) = fd; 4393 SPARG(&callarg, path) = path; 4394 SPARG(&callarg, mode) = mode; 4395 SPARG(&callarg, PAD) = 0; 4396 SPARG(&callarg, dev) = dev; 4397 4398 error = rsys_syscall(SYS_mknodat, &callarg, sizeof(callarg), retval); 4399 rsys_seterrno(error); 4400 if (error == 0) { 4401 if (sizeof(int) > sizeof(register_t)) 4402 rv = *(int *)retval; 4403 else 4404 rv = *retval; 4405 } 4406 return rv; 4407 } 4408 rsys_define(rumpns_sys_mknodat); 4409 rsys_aliases(mknodat,rump___sysimpl_mknodat); 4410 4411 int rump___sysimpl_mkdirat(int, const char *, mode_t); 4412 int 4413 rump___sysimpl_mkdirat(int fd, const char * path, mode_t mode) 4414 { 4415 register_t retval[2] = {0, 0}; 4416 int error = 0; 4417 int rv = -1; 4418 struct sys_mkdirat_args callarg; 4419 4420 SPARG(&callarg, fd) = fd; 4421 SPARG(&callarg, path) = path; 4422 SPARG(&callarg, mode) = mode; 4423 4424 error = rsys_syscall(SYS_mkdirat, &callarg, sizeof(callarg), retval); 4425 rsys_seterrno(error); 4426 if (error == 0) { 4427 if (sizeof(int) > sizeof(register_t)) 4428 rv = *(int *)retval; 4429 else 4430 rv = *retval; 4431 } 4432 return rv; 4433 } 4434 rsys_define(rumpns_sys_mkdirat); 4435 rsys_aliases(mkdirat,rump___sysimpl_mkdirat); 4436 4437 int rump___sysimpl_faccessat(int, const char *, int, int); 4438 int 4439 rump___sysimpl_faccessat(int fd, const char * path, int amode, int flag) 4440 { 4441 register_t retval[2] = {0, 0}; 4442 int error = 0; 4443 int rv = -1; 4444 struct sys_faccessat_args callarg; 4445 4446 SPARG(&callarg, fd) = fd; 4447 SPARG(&callarg, path) = path; 4448 SPARG(&callarg, amode) = amode; 4449 SPARG(&callarg, flag) = flag; 4450 4451 error = rsys_syscall(SYS_faccessat, &callarg, sizeof(callarg), retval); 4452 rsys_seterrno(error); 4453 if (error == 0) { 4454 if (sizeof(int) > sizeof(register_t)) 4455 rv = *(int *)retval; 4456 else 4457 rv = *retval; 4458 } 4459 return rv; 4460 } 4461 rsys_define(rumpns_sys_faccessat); 4462 rsys_aliases(faccessat,rump___sysimpl_faccessat); 4463 4464 int rump___sysimpl_fchmodat(int, const char *, mode_t, int); 4465 int 4466 rump___sysimpl_fchmodat(int fd, const char * path, mode_t mode, int flag) 4467 { 4468 register_t retval[2] = {0, 0}; 4469 int error = 0; 4470 int rv = -1; 4471 struct sys_fchmodat_args callarg; 4472 4473 SPARG(&callarg, fd) = fd; 4474 SPARG(&callarg, path) = path; 4475 SPARG(&callarg, mode) = mode; 4476 SPARG(&callarg, flag) = flag; 4477 4478 error = rsys_syscall(SYS_fchmodat, &callarg, sizeof(callarg), retval); 4479 rsys_seterrno(error); 4480 if (error == 0) { 4481 if (sizeof(int) > sizeof(register_t)) 4482 rv = *(int *)retval; 4483 else 4484 rv = *retval; 4485 } 4486 return rv; 4487 } 4488 rsys_define(rumpns_sys_fchmodat); 4489 rsys_aliases(fchmodat,rump___sysimpl_fchmodat); 4490 4491 int rump___sysimpl_fchownat(int, const char *, uid_t, gid_t, int); 4492 int 4493 rump___sysimpl_fchownat(int fd, const char * path, uid_t owner, gid_t group, int flag) 4494 { 4495 register_t retval[2] = {0, 0}; 4496 int error = 0; 4497 int rv = -1; 4498 struct sys_fchownat_args callarg; 4499 4500 SPARG(&callarg, fd) = fd; 4501 SPARG(&callarg, path) = path; 4502 SPARG(&callarg, owner) = owner; 4503 SPARG(&callarg, group) = group; 4504 SPARG(&callarg, flag) = flag; 4505 4506 error = rsys_syscall(SYS_fchownat, &callarg, sizeof(callarg), retval); 4507 rsys_seterrno(error); 4508 if (error == 0) { 4509 if (sizeof(int) > sizeof(register_t)) 4510 rv = *(int *)retval; 4511 else 4512 rv = *retval; 4513 } 4514 return rv; 4515 } 4516 rsys_define(rumpns_sys_fchownat); 4517 rsys_aliases(fchownat,rump___sysimpl_fchownat); 4518 4519 int rump___sysimpl_fstatat(int, const char *, struct stat *, int); 4520 int 4521 rump___sysimpl_fstatat(int fd, const char * path, struct stat * buf, int flag) 4522 { 4523 register_t retval[2] = {0, 0}; 4524 int error = 0; 4525 int rv = -1; 4526 struct sys_fstatat_args callarg; 4527 4528 SPARG(&callarg, fd) = fd; 4529 SPARG(&callarg, path) = path; 4530 SPARG(&callarg, buf) = buf; 4531 SPARG(&callarg, flag) = flag; 4532 4533 error = rsys_syscall(SYS_fstatat, &callarg, sizeof(callarg), retval); 4534 rsys_seterrno(error); 4535 if (error == 0) { 4536 if (sizeof(int) > sizeof(register_t)) 4537 rv = *(int *)retval; 4538 else 4539 rv = *retval; 4540 } 4541 return rv; 4542 } 4543 rsys_define(rumpns_sys_fstatat); 4544 rsys_aliases(fstatat,rump___sysimpl_fstatat); 4545 4546 int rump___sysimpl_utimensat(int, const char *, const struct timespec *, int); 4547 int 4548 rump___sysimpl_utimensat(int fd, const char * path, const struct timespec * tptr, int flag) 4549 { 4550 register_t retval[2] = {0, 0}; 4551 int error = 0; 4552 int rv = -1; 4553 struct sys_utimensat_args callarg; 4554 4555 SPARG(&callarg, fd) = fd; 4556 SPARG(&callarg, path) = path; 4557 SPARG(&callarg, tptr) = tptr; 4558 SPARG(&callarg, flag) = flag; 4559 4560 error = rsys_syscall(SYS_utimensat, &callarg, sizeof(callarg), retval); 4561 rsys_seterrno(error); 4562 if (error == 0) { 4563 if (sizeof(int) > sizeof(register_t)) 4564 rv = *(int *)retval; 4565 else 4566 rv = *retval; 4567 } 4568 return rv; 4569 } 4570 rsys_define(rumpns_sys_utimensat); 4571 rsys_aliases(utimensat,rump___sysimpl_utimensat); 4572 4573 int rump___sysimpl_openat(int, const char *, int, mode_t); 4574 int 4575 rump___sysimpl_openat(int fd, const char * path, int oflags, mode_t mode) 4576 { 4577 register_t retval[2] = {0, 0}; 4578 int error = 0; 4579 int rv = -1; 4580 struct sys_openat_args callarg; 4581 4582 SPARG(&callarg, fd) = fd; 4583 SPARG(&callarg, path) = path; 4584 SPARG(&callarg, oflags) = oflags; 4585 SPARG(&callarg, mode) = mode; 4586 4587 error = rsys_syscall(SYS_openat, &callarg, sizeof(callarg), retval); 4588 rsys_seterrno(error); 4589 if (error == 0) { 4590 if (sizeof(int) > sizeof(register_t)) 4591 rv = *(int *)retval; 4592 else 4593 rv = *retval; 4594 } 4595 return rv; 4596 } 4597 rsys_define(rumpns_sys_openat); 4598 rsys_aliases(openat,rump___sysimpl_openat); 4599 4600 int rump___sysimpl_readlinkat(int, const char *, char *, size_t); 4601 int 4602 rump___sysimpl_readlinkat(int fd, const char * path, char * buf, size_t bufsize) 4603 { 4604 register_t retval[2] = {0, 0}; 4605 int error = 0; 4606 int rv = -1; 4607 struct sys_readlinkat_args callarg; 4608 4609 SPARG(&callarg, fd) = fd; 4610 SPARG(&callarg, path) = path; 4611 SPARG(&callarg, buf) = buf; 4612 SPARG(&callarg, bufsize) = bufsize; 4613 4614 error = rsys_syscall(SYS_readlinkat, &callarg, sizeof(callarg), retval); 4615 rsys_seterrno(error); 4616 if (error == 0) { 4617 if (sizeof(int) > sizeof(register_t)) 4618 rv = *(int *)retval; 4619 else 4620 rv = *retval; 4621 } 4622 return rv; 4623 } 4624 rsys_define(rumpns_sys_readlinkat); 4625 rsys_aliases(readlinkat,rump___sysimpl_readlinkat); 4626 4627 int rump___sysimpl_symlinkat(const char *, int, const char *); 4628 int 4629 rump___sysimpl_symlinkat(const char * path1, int fd, const char * path2) 4630 { 4631 register_t retval[2] = {0, 0}; 4632 int error = 0; 4633 int rv = -1; 4634 struct sys_symlinkat_args callarg; 4635 4636 SPARG(&callarg, path1) = path1; 4637 SPARG(&callarg, fd) = fd; 4638 SPARG(&callarg, path2) = path2; 4639 4640 error = rsys_syscall(SYS_symlinkat, &callarg, sizeof(callarg), retval); 4641 rsys_seterrno(error); 4642 if (error == 0) { 4643 if (sizeof(int) > sizeof(register_t)) 4644 rv = *(int *)retval; 4645 else 4646 rv = *retval; 4647 } 4648 return rv; 4649 } 4650 rsys_define(rumpns_sys_symlinkat); 4651 rsys_aliases(symlinkat,rump___sysimpl_symlinkat); 4652 4653 int rump___sysimpl_unlinkat(int, const char *, int); 4654 int 4655 rump___sysimpl_unlinkat(int fd, const char * path, int flag) 4656 { 4657 register_t retval[2] = {0, 0}; 4658 int error = 0; 4659 int rv = -1; 4660 struct sys_unlinkat_args callarg; 4661 4662 SPARG(&callarg, fd) = fd; 4663 SPARG(&callarg, path) = path; 4664 SPARG(&callarg, flag) = flag; 4665 4666 error = rsys_syscall(SYS_unlinkat, &callarg, sizeof(callarg), retval); 4667 rsys_seterrno(error); 4668 if (error == 0) { 4669 if (sizeof(int) > sizeof(register_t)) 4670 rv = *(int *)retval; 4671 else 4672 rv = *retval; 4673 } 4674 return rv; 4675 } 4676 rsys_define(rumpns_sys_unlinkat); 4677 rsys_aliases(unlinkat,rump___sysimpl_unlinkat); 4678 4679 int rump___sysimpl_futimens(int, const struct timespec *); 4680 int 4681 rump___sysimpl_futimens(int fd, const struct timespec * tptr) 4682 { 4683 register_t retval[2] = {0, 0}; 4684 int error = 0; 4685 int rv = -1; 4686 struct sys_futimens_args callarg; 4687 4688 SPARG(&callarg, fd) = fd; 4689 SPARG(&callarg, tptr) = tptr; 4690 4691 error = rsys_syscall(SYS_futimens, &callarg, sizeof(callarg), retval); 4692 rsys_seterrno(error); 4693 if (error == 0) { 4694 if (sizeof(int) > sizeof(register_t)) 4695 rv = *(int *)retval; 4696 else 4697 rv = *retval; 4698 } 4699 return rv; 4700 } 4701 rsys_define(rumpns_sys_futimens); 4702 rsys_aliases(futimens,rump___sysimpl_futimens); 4703 4704 int rump___sysimpl___quotactl(const char *, struct quotactl_args *); 4705 int 4706 rump___sysimpl___quotactl(const char * path, struct quotactl_args * args) 4707 { 4708 register_t retval[2] = {0, 0}; 4709 int error = 0; 4710 int rv = -1; 4711 struct sys___quotactl_args callarg; 4712 4713 SPARG(&callarg, path) = path; 4714 SPARG(&callarg, args) = args; 4715 4716 error = rsys_syscall(SYS___quotactl, &callarg, sizeof(callarg), retval); 4717 rsys_seterrno(error); 4718 if (error == 0) { 4719 if (sizeof(int) > sizeof(register_t)) 4720 rv = *(int *)retval; 4721 else 4722 rv = *retval; 4723 } 4724 return rv; 4725 } 4726 rsys_define(rumpns_sys___quotactl); 4727 rsys_aliases(__quotactl,rump___sysimpl___quotactl); 4728 4729 int rump___sysimpl_recvmmsg(int, struct mmsghdr *, unsigned int, unsigned int, struct timespec *); 4730 int 4731 rump___sysimpl_recvmmsg(int s, struct mmsghdr * mmsg, unsigned int vlen, unsigned int flags, struct timespec * timeout) 4732 { 4733 register_t retval[2] = {0, 0}; 4734 int error = 0; 4735 int rv = -1; 4736 struct sys_recvmmsg_args callarg; 4737 4738 SPARG(&callarg, s) = s; 4739 SPARG(&callarg, mmsg) = mmsg; 4740 SPARG(&callarg, vlen) = vlen; 4741 SPARG(&callarg, flags) = flags; 4742 SPARG(&callarg, timeout) = timeout; 4743 4744 error = rsys_syscall(SYS_recvmmsg, &callarg, sizeof(callarg), retval); 4745 rsys_seterrno(error); 4746 if (error == 0) { 4747 if (sizeof(int) > sizeof(register_t)) 4748 rv = *(int *)retval; 4749 else 4750 rv = *retval; 4751 } 4752 return rv; 4753 } 4754 rsys_define(rumpns_sys_recvmmsg); 4755 rsys_aliases(recvmmsg,rump___sysimpl_recvmmsg); 4756 4757 int rump___sysimpl_sendmmsg(int, struct mmsghdr *, unsigned int, unsigned int); 4758 int 4759 rump___sysimpl_sendmmsg(int s, struct mmsghdr * mmsg, unsigned int vlen, unsigned int flags) 4760 { 4761 register_t retval[2] = {0, 0}; 4762 int error = 0; 4763 int rv = -1; 4764 struct sys_sendmmsg_args callarg; 4765 4766 SPARG(&callarg, s) = s; 4767 SPARG(&callarg, mmsg) = mmsg; 4768 SPARG(&callarg, vlen) = vlen; 4769 SPARG(&callarg, flags) = flags; 4770 4771 error = rsys_syscall(SYS_sendmmsg, &callarg, sizeof(callarg), retval); 4772 rsys_seterrno(error); 4773 if (error == 0) { 4774 if (sizeof(int) > sizeof(register_t)) 4775 rv = *(int *)retval; 4776 else 4777 rv = *retval; 4778 } 4779 return rv; 4780 } 4781 rsys_define(rumpns_sys_sendmmsg); 4782 rsys_aliases(sendmmsg,rump___sysimpl_sendmmsg); 4783 4784 int rump_sys_pipe(int *); 4785 int 4786 rump_sys_pipe(int *fd) 4787 { 4788 register_t retval[2] = {0, 0}; 4789 int error = 0; 4790 4791 error = rsys_syscall(SYS_pipe, NULL, 0, retval); 4792 if (error) { 4793 rsys_seterrno(error); 4794 } else { 4795 fd[0] = retval[0]; 4796 fd[1] = retval[1]; 4797 } 4798 return error ? -1 : 0; 4799 } 4800 rsys_define(rumpns_sys_pipe); 4801 rsys_aliases(pipe,rump_sys_pipe); 4802 4803 #ifndef RUMP_CLIENT 4804 #define s(type) sizeof(type) 4805 #define n(type) (sizeof(type)/sizeof (register_t)) 4806 #define ns(type) n(type), s(type) 4807 4808 struct sysent rump_sysent[] = { 4809 { 0, 0, SYCALL_NOSYS, 4810 (sy_call_t *)rump_enosys }, /* 0 = syscall */ 4811 { 0, 0, SYCALL_NOSYS, 4812 (sy_call_t *)rump_enosys }, /* 1 = exit */ 4813 { 0, 0, SYCALL_NOSYS, 4814 (sy_call_t *)rump_enosys }, /* 2 = fork */ 4815 { ns(struct sys_read_args), 0, 4816 (sy_call_t *)rumpns_sys_read }, /* 3 = read */ 4817 { ns(struct sys_write_args), 0, 4818 (sy_call_t *)rumpns_sys_write }, /* 4 = write */ 4819 { ns(struct sys_open_args), 0, 4820 (sy_call_t *)rumpns_sys_open }, /* 5 = open */ 4821 { ns(struct sys_close_args), 0, 4822 (sy_call_t *)rumpns_sys_close }, /* 6 = close */ 4823 { 0, 0, 0, 4824 (sy_call_t *)rumpns_sys_nomodule }, /* 7 = wait4 */ 4825 { 0, 0, 0, 4826 (sy_call_t *)rumpns_sys_nomodule }, /* 8 = ocreat */ 4827 { ns(struct sys_link_args), 0, 4828 (sy_call_t *)rumpns_sys_link }, /* 9 = link */ 4829 { ns(struct sys_unlink_args), 0, 4830 (sy_call_t *)rumpns_sys_unlink }, /* 10 = unlink */ 4831 { 0, 0, SYCALL_NOSYS, 4832 (sy_call_t *)rump_enosys }, /* 11 = obsolete execv */ 4833 { ns(struct sys_chdir_args), 0, 4834 (sy_call_t *)rumpns_sys_chdir }, /* 12 = chdir */ 4835 { ns(struct sys_fchdir_args), 0, 4836 (sy_call_t *)rumpns_sys_fchdir }, /* 13 = fchdir */ 4837 { ns(struct compat_50_sys_mknod_args), 0, 4838 (sy_call_t *)rumpns_compat_50_sys_mknod },/* 14 = compat_50_mknod */ 4839 { ns(struct sys_chmod_args), 0, 4840 (sy_call_t *)rumpns_sys_chmod }, /* 15 = chmod */ 4841 { ns(struct sys_chown_args), 0, 4842 (sy_call_t *)rumpns_sys_chown }, /* 16 = chown */ 4843 { 0, 0, SYCALL_NOSYS, 4844 (sy_call_t *)rump_enosys }, /* 17 = break */ 4845 { 0, 0, 0, 4846 (sy_call_t *)rumpns_sys_nomodule }, /* 18 = getfsstat */ 4847 { 0, 0, 0, 4848 (sy_call_t *)rumpns_sys_nomodule }, /* 19 = olseek */ 4849 { 0, 0, 0, 4850 (sy_call_t *)rumpns_sys_getpid_with_ppid },/* 20 = getpid */ 4851 { 0, 0, 0, 4852 (sy_call_t *)rumpns_sys_nomodule }, /* 21 = mount */ 4853 { ns(struct sys_unmount_args), 0, 4854 (sy_call_t *)rumpns_sys_unmount }, /* 22 = unmount */ 4855 { ns(struct sys_setuid_args), 0, 4856 (sy_call_t *)rumpns_sys_setuid }, /* 23 = setuid */ 4857 { 0, 0, 0, 4858 (sy_call_t *)rumpns_sys_getuid_with_euid },/* 24 = getuid */ 4859 { 0, 0, 0, 4860 (sy_call_t *)rumpns_sys_geteuid }, /* 25 = geteuid */ 4861 { 0, 0, SYCALL_NOSYS, 4862 (sy_call_t *)rump_enosys }, /* 26 = ptrace */ 4863 { ns(struct sys_recvmsg_args), 0, 4864 (sy_call_t *)rumpns_sys_recvmsg }, /* 27 = recvmsg */ 4865 { ns(struct sys_sendmsg_args), 0, 4866 (sy_call_t *)rumpns_sys_sendmsg }, /* 28 = sendmsg */ 4867 { ns(struct sys_recvfrom_args), 0, 4868 (sy_call_t *)rumpns_sys_recvfrom }, /* 29 = recvfrom */ 4869 { ns(struct sys_accept_args), 0, 4870 (sy_call_t *)rumpns_sys_accept }, /* 30 = accept */ 4871 { ns(struct sys_getpeername_args), 0, 4872 (sy_call_t *)rumpns_sys_getpeername },/* 31 = getpeername */ 4873 { ns(struct sys_getsockname_args), 0, 4874 (sy_call_t *)rumpns_sys_getsockname },/* 32 = getsockname */ 4875 { ns(struct sys_access_args), 0, 4876 (sy_call_t *)rumpns_sys_access }, /* 33 = access */ 4877 { ns(struct sys_chflags_args), 0, 4878 (sy_call_t *)rumpns_sys_chflags }, /* 34 = chflags */ 4879 { ns(struct sys_fchflags_args), 0, 4880 (sy_call_t *)rumpns_sys_fchflags }, /* 35 = fchflags */ 4881 { 0, 0, 0, 4882 (sy_call_t *)rumpns_sys_sync }, /* 36 = sync */ 4883 { 0, 0, SYCALL_NOSYS, 4884 (sy_call_t *)rump_enosys }, /* 37 = kill */ 4885 { 0, 0, 0, 4886 (sy_call_t *)rumpns_sys_nomodule }, /* 38 = stat43 */ 4887 { 0, 0, 0, 4888 (sy_call_t *)rumpns_sys_getppid }, /* 39 = getppid */ 4889 { 0, 0, 0, 4890 (sy_call_t *)rumpns_sys_nomodule }, /* 40 = lstat43 */ 4891 { ns(struct sys_dup_args), 0, 4892 (sy_call_t *)rumpns_sys_dup }, /* 41 = dup */ 4893 { 0, 0, 0, 4894 (sy_call_t *)rumpns_sys_pipe }, /* 42 = pipe */ 4895 { 0, 0, 0, 4896 (sy_call_t *)rumpns_sys_getegid }, /* 43 = getegid */ 4897 { 0, 0, SYCALL_NOSYS, 4898 (sy_call_t *)rump_enosys }, /* 44 = profil */ 4899 { 0, 0, SYCALL_NOSYS, 4900 (sy_call_t *)rump_enosys }, /* 45 = ktrace */ 4901 { 0, 0, 0, 4902 (sy_call_t *)rumpns_sys_nomodule }, /* 46 = sigaction13 */ 4903 { 0, 0, 0, 4904 (sy_call_t *)rumpns_sys_getgid_with_egid },/* 47 = getgid */ 4905 { 0, 0, 0, 4906 (sy_call_t *)rumpns_sys_nomodule }, /* 48 = sigprocmask13 */ 4907 { ns(struct sys___getlogin_args), 0, 4908 (sy_call_t *)rumpns_sys___getlogin },/* 49 = __getlogin */ 4909 { ns(struct sys___setlogin_args), 0, 4910 (sy_call_t *)rumpns_sys___setlogin },/* 50 = __setlogin */ 4911 { 0, 0, SYCALL_NOSYS, 4912 (sy_call_t *)rump_enosys }, /* 51 = acct */ 4913 { 0, 0, 0, 4914 (sy_call_t *)rumpns_sys_nomodule }, /* 52 = sigpending13 */ 4915 { 0, 0, 0, 4916 (sy_call_t *)rumpns_sys_nomodule }, /* 53 = sigaltstack13 */ 4917 { ns(struct sys_ioctl_args), 0, 4918 (sy_call_t *)rumpns_sys_ioctl }, /* 54 = ioctl */ 4919 { 0, 0, 0, 4920 (sy_call_t *)rumpns_sys_nomodule }, /* 55 = oreboot */ 4921 { ns(struct sys_revoke_args), 0, 4922 (sy_call_t *)rumpns_sys_revoke }, /* 56 = revoke */ 4923 { ns(struct sys_symlink_args), 0, 4924 (sy_call_t *)rumpns_sys_symlink }, /* 57 = symlink */ 4925 { ns(struct sys_readlink_args), 0, 4926 (sy_call_t *)rumpns_sys_readlink }, /* 58 = readlink */ 4927 { 0, 0, SYCALL_NOSYS, 4928 (sy_call_t *)rump_enosys }, /* 59 = execve */ 4929 { ns(struct sys_umask_args), 0, 4930 (sy_call_t *)rumpns_sys_umask }, /* 60 = umask */ 4931 { ns(struct sys_chroot_args), 0, 4932 (sy_call_t *)rumpns_sys_chroot }, /* 61 = chroot */ 4933 { 0, 0, 0, 4934 (sy_call_t *)rumpns_sys_nomodule }, /* 62 = fstat43 */ 4935 { 0, 0, 0, 4936 (sy_call_t *)rumpns_sys_nomodule }, /* 63 = ogetkerninfo */ 4937 { 0, 0, 0, 4938 (sy_call_t *)rumpns_sys_nomodule }, /* 64 = ogetpagesize */ 4939 { 0, 0, 0, 4940 (sy_call_t *)rumpns_sys_nomodule }, /* 65 = msync */ 4941 { 0, 0, SYCALL_NOSYS, 4942 (sy_call_t *)rump_enosys }, /* 66 = vfork */ 4943 { 0, 0, SYCALL_NOSYS, 4944 (sy_call_t *)rump_enosys }, /* 67 = obsolete vread */ 4945 { 0, 0, SYCALL_NOSYS, 4946 (sy_call_t *)rump_enosys }, /* 68 = obsolete vwrite */ 4947 { 0, 0, SYCALL_NOSYS, 4948 (sy_call_t *)rump_enosys }, /* 69 = sbrk */ 4949 { 0, 0, SYCALL_NOSYS, 4950 (sy_call_t *)rump_enosys }, /* 70 = sstk */ 4951 { 0, 0, 0, 4952 (sy_call_t *)rumpns_sys_nomodule }, /* 71 = ommap */ 4953 { 0, 0, SYCALL_NOSYS, 4954 (sy_call_t *)rump_enosys }, /* 72 = vadvise */ 4955 { 0, 0, SYCALL_NOSYS, 4956 (sy_call_t *)rump_enosys }, /* 73 = munmap */ 4957 { 0, 0, SYCALL_NOSYS, 4958 (sy_call_t *)rump_enosys }, /* 74 = mprotect */ 4959 { 0, 0, SYCALL_NOSYS, 4960 (sy_call_t *)rump_enosys }, /* 75 = madvise */ 4961 { 0, 0, SYCALL_NOSYS, 4962 (sy_call_t *)rump_enosys }, /* 76 = obsolete vhangup */ 4963 { 0, 0, SYCALL_NOSYS, 4964 (sy_call_t *)rump_enosys }, /* 77 = obsolete vlimit */ 4965 { 0, 0, SYCALL_NOSYS, 4966 (sy_call_t *)rump_enosys }, /* 78 = mincore */ 4967 { ns(struct sys_getgroups_args), 0, 4968 (sy_call_t *)rumpns_sys_getgroups },/* 79 = getgroups */ 4969 { ns(struct sys_setgroups_args), 0, 4970 (sy_call_t *)rumpns_sys_setgroups },/* 80 = setgroups */ 4971 { 0, 0, 0, 4972 (sy_call_t *)rumpns_sys_getpgrp }, /* 81 = getpgrp */ 4973 { ns(struct sys_setpgid_args), 0, 4974 (sy_call_t *)rumpns_sys_setpgid }, /* 82 = setpgid */ 4975 { 0, 0, 0, 4976 (sy_call_t *)rumpns_sys_nomodule }, /* 83 = setitimer */ 4977 { 0, 0, 0, 4978 (sy_call_t *)rumpns_sys_nomodule }, /* 84 = owait */ 4979 { 0, 0, 0, 4980 (sy_call_t *)rumpns_sys_nomodule }, /* 85 = oswapon */ 4981 { 0, 0, 0, 4982 (sy_call_t *)rumpns_sys_nomodule }, /* 86 = getitimer */ 4983 { 0, 0, 0, 4984 (sy_call_t *)rumpns_sys_nomodule }, /* 87 = ogethostname */ 4985 { 0, 0, 0, 4986 (sy_call_t *)rumpns_sys_nomodule }, /* 88 = osethostname */ 4987 { 0, 0, 0, 4988 (sy_call_t *)rumpns_sys_nomodule }, /* 89 = ogetdtablesize */ 4989 { ns(struct sys_dup2_args), 0, 4990 (sy_call_t *)rumpns_sys_dup2 }, /* 90 = dup2 */ 4991 { 0, 0, SYCALL_NOSYS, 4992 (sy_call_t *)rump_enosys }, /* 91 = unimplemented getdopt */ 4993 { ns(struct sys_fcntl_args), 0, 4994 (sy_call_t *)rumpns_sys_fcntl }, /* 92 = fcntl */ 4995 { ns(struct compat_50_sys_select_args), 0, 4996 (sy_call_t *)rumpns_compat_50_sys_select },/* 93 = compat_50_select */ 4997 { 0, 0, SYCALL_NOSYS, 4998 (sy_call_t *)rump_enosys }, /* 94 = unimplemented setdopt */ 4999 { ns(struct sys_fsync_args), 0, 5000 (sy_call_t *)rumpns_sys_fsync }, /* 95 = fsync */ 5001 { 0, 0, SYCALL_NOSYS, 5002 (sy_call_t *)rump_enosys }, /* 96 = setpriority */ 5003 { 0, 0, 0, 5004 (sy_call_t *)rumpns_sys_nomodule }, /* 97 = socket */ 5005 { ns(struct sys_connect_args), 0, 5006 (sy_call_t *)rumpns_sys_connect }, /* 98 = connect */ 5007 { 0, 0, 0, 5008 (sy_call_t *)rumpns_sys_nomodule }, /* 99 = oaccept */ 5009 { 0, 0, SYCALL_NOSYS, 5010 (sy_call_t *)rump_enosys }, /* 100 = getpriority */ 5011 { 0, 0, 0, 5012 (sy_call_t *)rumpns_sys_nomodule }, /* 101 = osend */ 5013 { 0, 0, 0, 5014 (sy_call_t *)rumpns_sys_nomodule }, /* 102 = orecv */ 5015 { 0, 0, 0, 5016 (sy_call_t *)rumpns_sys_nomodule }, /* 103 = sigreturn13 */ 5017 { ns(struct sys_bind_args), 0, 5018 (sy_call_t *)rumpns_sys_bind }, /* 104 = bind */ 5019 { ns(struct sys_setsockopt_args), 0, 5020 (sy_call_t *)rumpns_sys_setsockopt },/* 105 = setsockopt */ 5021 { ns(struct sys_listen_args), 0, 5022 (sy_call_t *)rumpns_sys_listen }, /* 106 = listen */ 5023 { 0, 0, SYCALL_NOSYS, 5024 (sy_call_t *)rump_enosys }, /* 107 = obsolete vtimes */ 5025 { 0, 0, 0, 5026 (sy_call_t *)rumpns_sys_nomodule }, /* 108 = osigvec */ 5027 { 0, 0, 0, 5028 (sy_call_t *)rumpns_sys_nomodule }, /* 109 = osigblock */ 5029 { 0, 0, 0, 5030 (sy_call_t *)rumpns_sys_nomodule }, /* 110 = osigsetmask */ 5031 { 0, 0, 0, 5032 (sy_call_t *)rumpns_sys_nomodule }, /* 111 = sigsuspend13 */ 5033 { 0, 0, 0, 5034 (sy_call_t *)rumpns_sys_nomodule }, /* 112 = osigstack */ 5035 { 0, 0, 0, 5036 (sy_call_t *)rumpns_sys_nomodule }, /* 113 = orecvmsg */ 5037 { 0, 0, 0, 5038 (sy_call_t *)rumpns_sys_nomodule }, /* 114 = osendmsg */ 5039 { 0, 0, SYCALL_NOSYS, 5040 (sy_call_t *)rump_enosys }, /* 115 = obsolete vtrace */ 5041 { 0, 0, 0, 5042 (sy_call_t *)rumpns_sys_nomodule }, /* 116 = gettimeofday */ 5043 { 0, 0, 0, 5044 (sy_call_t *)rumpns_sys_nomodule }, /* 117 = getrusage */ 5045 { ns(struct sys_getsockopt_args), 0, 5046 (sy_call_t *)rumpns_sys_getsockopt },/* 118 = getsockopt */ 5047 { 0, 0, SYCALL_NOSYS, 5048 (sy_call_t *)rump_enosys }, /* 119 = obsolete resuba */ 5049 { ns(struct sys_readv_args), 0, 5050 (sy_call_t *)rumpns_sys_readv }, /* 120 = readv */ 5051 { ns(struct sys_writev_args), 0, 5052 (sy_call_t *)rumpns_sys_writev }, /* 121 = writev */ 5053 { 0, 0, 0, 5054 (sy_call_t *)rumpns_sys_nomodule }, /* 122 = settimeofday */ 5055 { ns(struct sys_fchown_args), 0, 5056 (sy_call_t *)rumpns_sys_fchown }, /* 123 = fchown */ 5057 { ns(struct sys_fchmod_args), 0, 5058 (sy_call_t *)rumpns_sys_fchmod }, /* 124 = fchmod */ 5059 { 0, 0, 0, 5060 (sy_call_t *)rumpns_sys_nomodule }, /* 125 = orecvfrom */ 5061 { ns(struct sys_setreuid_args), 0, 5062 (sy_call_t *)rumpns_sys_setreuid }, /* 126 = setreuid */ 5063 { ns(struct sys_setregid_args), 0, 5064 (sy_call_t *)rumpns_sys_setregid }, /* 127 = setregid */ 5065 { ns(struct sys_rename_args), 0, 5066 (sy_call_t *)rumpns_sys_rename }, /* 128 = rename */ 5067 { 0, 0, 0, 5068 (sy_call_t *)rumpns_sys_nomodule }, /* 129 = otruncate */ 5069 { 0, 0, 0, 5070 (sy_call_t *)rumpns_sys_nomodule }, /* 130 = oftruncate */ 5071 { ns(struct sys_flock_args), 0, 5072 (sy_call_t *)rumpns_sys_flock }, /* 131 = flock */ 5073 { ns(struct sys_mkfifo_args), 0, 5074 (sy_call_t *)rumpns_sys_mkfifo }, /* 132 = mkfifo */ 5075 { ns(struct sys_sendto_args), 0, 5076 (sy_call_t *)rumpns_sys_sendto }, /* 133 = sendto */ 5077 { ns(struct sys_shutdown_args), 0, 5078 (sy_call_t *)rumpns_sys_shutdown }, /* 134 = shutdown */ 5079 { ns(struct sys_socketpair_args), 0, 5080 (sy_call_t *)rumpns_sys_socketpair },/* 135 = socketpair */ 5081 { ns(struct sys_mkdir_args), 0, 5082 (sy_call_t *)rumpns_sys_mkdir }, /* 136 = mkdir */ 5083 { ns(struct sys_rmdir_args), 0, 5084 (sy_call_t *)rumpns_sys_rmdir }, /* 137 = rmdir */ 5085 { ns(struct compat_50_sys_utimes_args), 0, 5086 (sy_call_t *)rumpns_compat_50_sys_utimes },/* 138 = compat_50_utimes */ 5087 { 0, 0, SYCALL_NOSYS, 5088 (sy_call_t *)rump_enosys }, /* 139 = obsolete 4.2 sigreturn */ 5089 { 0, 0, 0, 5090 (sy_call_t *)rumpns_sys_nomodule }, /* 140 = adjtime */ 5091 { 0, 0, 0, 5092 (sy_call_t *)rumpns_sys_nomodule }, /* 141 = ogetpeername */ 5093 { 0, 0, 0, 5094 (sy_call_t *)rumpns_sys_nomodule }, /* 142 = ogethostid */ 5095 { 0, 0, 0, 5096 (sy_call_t *)rumpns_sys_nomodule }, /* 143 = osethostid */ 5097 { 0, 0, 0, 5098 (sy_call_t *)rumpns_sys_nomodule }, /* 144 = ogetrlimit */ 5099 { 0, 0, 0, 5100 (sy_call_t *)rumpns_sys_nomodule }, /* 145 = osetrlimit */ 5101 { 0, 0, 0, 5102 (sy_call_t *)rumpns_sys_nomodule }, /* 146 = okillpg */ 5103 { 0, 0, 0, 5104 (sy_call_t *)rumpns_sys_setsid }, /* 147 = setsid */ 5105 { 0, 0, 0, 5106 (sy_call_t *)rumpns_sys_nomodule }, /* 148 = quotactl */ 5107 { 0, 0, 0, 5108 (sy_call_t *)rumpns_sys_nomodule }, /* 149 = oquota */ 5109 { 0, 0, 0, 5110 (sy_call_t *)rumpns_sys_nomodule }, /* 150 = ogetsockname */ 5111 { 0, 0, SYCALL_NOSYS, 5112 (sy_call_t *)rump_enosys }, /* 151 = unimplemented */ 5113 { 0, 0, SYCALL_NOSYS, 5114 (sy_call_t *)rump_enosys }, /* 152 = unimplemented */ 5115 { 0, 0, SYCALL_NOSYS, 5116 (sy_call_t *)rump_enosys }, /* 153 = unimplemented */ 5117 { 0, 0, SYCALL_NOSYS, 5118 (sy_call_t *)rump_enosys }, /* 154 = unimplemented */ 5119 { ns(struct sys_nfssvc_args), 0, 5120 (sy_call_t *)rumpns_sys_nomodule }, /* 155 = nfssvc */ 5121 { 0, 0, 0, 5122 (sy_call_t *)rumpns_sys_nomodule }, /* 156 = ogetdirentries */ 5123 { 0, 0, 0, 5124 (sy_call_t *)rumpns_sys_nomodule }, /* 157 = statfs */ 5125 { 0, 0, 0, 5126 (sy_call_t *)rumpns_sys_nomodule }, /* 158 = fstatfs */ 5127 { 0, 0, SYCALL_NOSYS, 5128 (sy_call_t *)rump_enosys }, /* 159 = unimplemented */ 5129 { 0, 0, SYCALL_NOSYS, 5130 (sy_call_t *)rump_enosys }, /* 160 = unimplemented */ 5131 { 0, 0, 0, 5132 (sy_call_t *)rumpns_sys_nomodule }, /* 161 = getfh */ 5133 { 0, 0, 0, 5134 (sy_call_t *)rumpns_sys_nomodule }, /* 162 = ogetdomainname */ 5135 { 0, 0, 0, 5136 (sy_call_t *)rumpns_sys_nomodule }, /* 163 = osetdomainname */ 5137 { 0, 0, 0, 5138 (sy_call_t *)rumpns_sys_nomodule }, /* 164 = ouname */ 5139 { 0, 0, SYCALL_NOSYS, 5140 (sy_call_t *)rump_enosys }, /* 165 = sysarch */ 5141 { 0, 0, SYCALL_NOSYS, 5142 (sy_call_t *)rump_enosys }, /* 166 = unimplemented */ 5143 { 0, 0, SYCALL_NOSYS, 5144 (sy_call_t *)rump_enosys }, /* 167 = unimplemented */ 5145 { 0, 0, SYCALL_NOSYS, 5146 (sy_call_t *)rump_enosys }, /* 168 = unimplemented */ 5147 #if (defined(SYSVSEM) || !defined(_KERNEL_OPT)) && !defined(_LP64) 5148 { 0, 0, 0, 5149 (sy_call_t *)rumpns_sys_nomodule }, /* 169 = osemsys */ 5150 #else 5151 { 0, 0, SYCALL_NOSYS, 5152 (sy_call_t *)rump_enosys }, /* 169 = excluded 1.0 semsys */ 5153 #endif 5154 #if (defined(SYSVMSG) || !defined(_KERNEL_OPT)) && !defined(_LP64) 5155 { 0, 0, 0, 5156 (sy_call_t *)rumpns_sys_nomodule }, /* 170 = omsgsys */ 5157 #else 5158 { 0, 0, SYCALL_NOSYS, 5159 (sy_call_t *)rump_enosys }, /* 170 = excluded 1.0 msgsys */ 5160 #endif 5161 #if (defined(SYSVSHM) || !defined(_KERNEL_OPT)) && !defined(_LP64) 5162 { 0, 0, 0, 5163 (sy_call_t *)rumpns_sys_nomodule }, /* 171 = oshmsys */ 5164 #else 5165 { 0, 0, SYCALL_NOSYS, 5166 (sy_call_t *)rump_enosys }, /* 171 = excluded 1.0 shmsys */ 5167 #endif 5168 { 0, 0, SYCALL_NOSYS, 5169 (sy_call_t *)rump_enosys }, /* 172 = unimplemented */ 5170 { ns(struct sys_pread_args), 0, 5171 (sy_call_t *)rumpns_sys_pread }, /* 173 = pread */ 5172 { ns(struct sys_pwrite_args), 0, 5173 (sy_call_t *)rumpns_sys_pwrite }, /* 174 = pwrite */ 5174 { 0, 0, SYCALL_NOSYS, 5175 (sy_call_t *)rump_enosys }, /* 175 = ntp_gettime */ 5176 #if defined(NTP) || !defined(_KERNEL_OPT) 5177 { 0, 0, SYCALL_NOSYS, 5178 (sy_call_t *)rump_enosys }, /* 176 = ntp_adjtime */ 5179 #else 5180 { 0, 0, SYCALL_NOSYS, 5181 (sy_call_t *)rump_enosys }, /* 176 = excluded ntp_adjtime */ 5182 #endif 5183 { 0, 0, SYCALL_NOSYS, 5184 (sy_call_t *)rump_enosys }, /* 177 = unimplemented */ 5185 { 0, 0, SYCALL_NOSYS, 5186 (sy_call_t *)rump_enosys }, /* 178 = unimplemented */ 5187 { 0, 0, SYCALL_NOSYS, 5188 (sy_call_t *)rump_enosys }, /* 179 = unimplemented */ 5189 { 0, 0, SYCALL_NOSYS, 5190 (sy_call_t *)rump_enosys }, /* 180 = unimplemented */ 5191 { ns(struct sys_setgid_args), 0, 5192 (sy_call_t *)rumpns_sys_setgid }, /* 181 = setgid */ 5193 { ns(struct sys_setegid_args), 0, 5194 (sy_call_t *)rumpns_sys_setegid }, /* 182 = setegid */ 5195 { ns(struct sys_seteuid_args), 0, 5196 (sy_call_t *)rumpns_sys_seteuid }, /* 183 = seteuid */ 5197 { 0, 0, 0, 5198 (sy_call_t *)rumpns_sys_nomodule }, /* 184 = lfs_bmapv */ 5199 { 0, 0, 0, 5200 (sy_call_t *)rumpns_sys_nomodule }, /* 185 = lfs_markv */ 5201 { 0, 0, 0, 5202 (sy_call_t *)rumpns_sys_nomodule }, /* 186 = lfs_segclean */ 5203 { 0, 0, 0, 5204 (sy_call_t *)rumpns_sys_nomodule }, /* 187 = lfs_segwait */ 5205 { 0, 0, 0, 5206 (sy_call_t *)rumpns_sys_nomodule }, /* 188 = stat12 */ 5207 { 0, 0, 0, 5208 (sy_call_t *)rumpns_sys_nomodule }, /* 189 = fstat12 */ 5209 { 0, 0, 0, 5210 (sy_call_t *)rumpns_sys_nomodule }, /* 190 = lstat12 */ 5211 { ns(struct sys_pathconf_args), 0, 5212 (sy_call_t *)rumpns_sys_pathconf }, /* 191 = pathconf */ 5213 { ns(struct sys_fpathconf_args), 0, 5214 (sy_call_t *)rumpns_sys_fpathconf },/* 192 = fpathconf */ 5215 { 0, 0, SYCALL_NOSYS, 5216 (sy_call_t *)rump_enosys }, /* 193 = unimplemented */ 5217 { ns(struct sys_getrlimit_args), 0, 5218 (sy_call_t *)rumpns_sys_getrlimit },/* 194 = getrlimit */ 5219 { ns(struct sys_setrlimit_args), 0, 5220 (sy_call_t *)rumpns_sys_setrlimit },/* 195 = setrlimit */ 5221 { 0, 0, 0, 5222 (sy_call_t *)rumpns_sys_nomodule }, /* 196 = getdirentries */ 5223 { 0, 0, SYCALL_NOSYS, 5224 (sy_call_t *)rump_enosys }, /* 197 = mmap */ 5225 { 0, 0, SYCALL_NOSYS, 5226 (sy_call_t *)rump_enosys }, /* 198 = __syscall */ 5227 { ns(struct sys_lseek_args), 0, 5228 (sy_call_t *)rumpns_sys_lseek }, /* 199 = lseek */ 5229 { ns(struct sys_truncate_args), 0, 5230 (sy_call_t *)rumpns_sys_truncate }, /* 200 = truncate */ 5231 { ns(struct sys_ftruncate_args), 0, 5232 (sy_call_t *)rumpns_sys_ftruncate },/* 201 = ftruncate */ 5233 { ns(struct sys___sysctl_args), 0, 5234 (sy_call_t *)rumpns_sys___sysctl }, /* 202 = __sysctl */ 5235 { 0, 0, SYCALL_NOSYS, 5236 (sy_call_t *)rump_enosys }, /* 203 = mlock */ 5237 { 0, 0, SYCALL_NOSYS, 5238 (sy_call_t *)rump_enosys }, /* 204 = munlock */ 5239 { 0, 0, SYCALL_NOSYS, 5240 (sy_call_t *)rump_enosys }, /* 205 = undelete */ 5241 { ns(struct compat_50_sys_futimes_args), 0, 5242 (sy_call_t *)rumpns_compat_50_sys_futimes },/* 206 = compat_50_futimes */ 5243 { ns(struct sys_getpgid_args), 0, 5244 (sy_call_t *)rumpns_sys_getpgid }, /* 207 = getpgid */ 5245 { ns(struct sys_reboot_args), 0, 5246 (sy_call_t *)rumpns_sys_reboot }, /* 208 = reboot */ 5247 { ns(struct sys_poll_args), 0, 5248 (sy_call_t *)rumpns_sys_poll }, /* 209 = poll */ 5249 { 0, 0, 0, 5250 (sy_call_t *)rumpns_sys_nomodule }, /* 210 = afssys */ 5251 { 0, 0, SYCALL_NOSYS, 5252 (sy_call_t *)rump_enosys }, /* 211 = unimplemented */ 5253 { 0, 0, SYCALL_NOSYS, 5254 (sy_call_t *)rump_enosys }, /* 212 = unimplemented */ 5255 { 0, 0, SYCALL_NOSYS, 5256 (sy_call_t *)rump_enosys }, /* 213 = unimplemented */ 5257 { 0, 0, SYCALL_NOSYS, 5258 (sy_call_t *)rump_enosys }, /* 214 = unimplemented */ 5259 { 0, 0, SYCALL_NOSYS, 5260 (sy_call_t *)rump_enosys }, /* 215 = unimplemented */ 5261 { 0, 0, SYCALL_NOSYS, 5262 (sy_call_t *)rump_enosys }, /* 216 = unimplemented */ 5263 { 0, 0, SYCALL_NOSYS, 5264 (sy_call_t *)rump_enosys }, /* 217 = unimplemented */ 5265 { 0, 0, SYCALL_NOSYS, 5266 (sy_call_t *)rump_enosys }, /* 218 = unimplemented */ 5267 { 0, 0, SYCALL_NOSYS, 5268 (sy_call_t *)rump_enosys }, /* 219 = unimplemented */ 5269 #if defined(SYSVSEM) || !defined(_KERNEL_OPT) 5270 { 0, 0, 0, 5271 (sy_call_t *)rumpns_sys_nomodule }, /* 220 = __semctl */ 5272 { 0, 0, SYCALL_NOSYS, 5273 (sy_call_t *)rump_enosys }, /* 221 = semget */ 5274 { 0, 0, SYCALL_NOSYS, 5275 (sy_call_t *)rump_enosys }, /* 222 = semop */ 5276 { 0, 0, SYCALL_NOSYS, 5277 (sy_call_t *)rump_enosys }, /* 223 = semconfig */ 5278 #else 5279 { 0, 0, SYCALL_NOSYS, 5280 (sy_call_t *)rump_enosys }, /* 220 = excluded compat_14_semctl */ 5281 { 0, 0, SYCALL_NOSYS, 5282 (sy_call_t *)rump_enosys }, /* 221 = excluded semget */ 5283 { 0, 0, SYCALL_NOSYS, 5284 (sy_call_t *)rump_enosys }, /* 222 = excluded semop */ 5285 { 0, 0, SYCALL_NOSYS, 5286 (sy_call_t *)rump_enosys }, /* 223 = excluded semconfig */ 5287 #endif 5288 #if defined(SYSVMSG) || !defined(_KERNEL_OPT) 5289 { 0, 0, 0, 5290 (sy_call_t *)rumpns_sys_nomodule }, /* 224 = msgctl */ 5291 { 0, 0, SYCALL_NOSYS, 5292 (sy_call_t *)rump_enosys }, /* 225 = msgget */ 5293 { 0, 0, SYCALL_NOSYS, 5294 (sy_call_t *)rump_enosys }, /* 226 = msgsnd */ 5295 { 0, 0, SYCALL_NOSYS, 5296 (sy_call_t *)rump_enosys }, /* 227 = msgrcv */ 5297 #else 5298 { 0, 0, SYCALL_NOSYS, 5299 (sy_call_t *)rump_enosys }, /* 224 = excluded compat_14_msgctl */ 5300 { 0, 0, SYCALL_NOSYS, 5301 (sy_call_t *)rump_enosys }, /* 225 = excluded msgget */ 5302 { 0, 0, SYCALL_NOSYS, 5303 (sy_call_t *)rump_enosys }, /* 226 = excluded msgsnd */ 5304 { 0, 0, SYCALL_NOSYS, 5305 (sy_call_t *)rump_enosys }, /* 227 = excluded msgrcv */ 5306 #endif 5307 #if defined(SYSVSHM) || !defined(_KERNEL_OPT) 5308 { 0, 0, SYCALL_NOSYS, 5309 (sy_call_t *)rump_enosys }, /* 228 = shmat */ 5310 { 0, 0, 0, 5311 (sy_call_t *)rumpns_sys_nomodule }, /* 229 = shmctl */ 5312 { 0, 0, SYCALL_NOSYS, 5313 (sy_call_t *)rump_enosys }, /* 230 = shmdt */ 5314 { 0, 0, SYCALL_NOSYS, 5315 (sy_call_t *)rump_enosys }, /* 231 = shmget */ 5316 #else 5317 { 0, 0, SYCALL_NOSYS, 5318 (sy_call_t *)rump_enosys }, /* 228 = excluded shmat */ 5319 { 0, 0, SYCALL_NOSYS, 5320 (sy_call_t *)rump_enosys }, /* 229 = excluded compat_14_shmctl */ 5321 { 0, 0, SYCALL_NOSYS, 5322 (sy_call_t *)rump_enosys }, /* 230 = excluded shmdt */ 5323 { 0, 0, SYCALL_NOSYS, 5324 (sy_call_t *)rump_enosys }, /* 231 = excluded shmget */ 5325 #endif 5326 { 0, 0, 0, 5327 (sy_call_t *)rumpns_sys_nomodule }, /* 232 = clock_gettime */ 5328 { 0, 0, 0, 5329 (sy_call_t *)rumpns_sys_nomodule }, /* 233 = clock_settime */ 5330 { 0, 0, 0, 5331 (sy_call_t *)rumpns_sys_nomodule }, /* 234 = clock_getres */ 5332 { 0, 0, SYCALL_NOSYS, 5333 (sy_call_t *)rump_enosys }, /* 235 = timer_create */ 5334 { 0, 0, SYCALL_NOSYS, 5335 (sy_call_t *)rump_enosys }, /* 236 = timer_delete */ 5336 { 0, 0, 0, 5337 (sy_call_t *)rumpns_sys_nomodule }, /* 237 = timer_settime */ 5338 { 0, 0, 0, 5339 (sy_call_t *)rumpns_sys_nomodule }, /* 238 = timer_gettime */ 5340 { 0, 0, SYCALL_NOSYS, 5341 (sy_call_t *)rump_enosys }, /* 239 = timer_getoverrun */ 5342 { 0, 0, 0, 5343 (sy_call_t *)rumpns_sys_nomodule }, /* 240 = nanosleep */ 5344 { ns(struct sys_fdatasync_args), 0, 5345 (sy_call_t *)rumpns_sys_fdatasync },/* 241 = fdatasync */ 5346 { 0, 0, SYCALL_NOSYS, 5347 (sy_call_t *)rump_enosys }, /* 242 = mlockall */ 5348 { 0, 0, SYCALL_NOSYS, 5349 (sy_call_t *)rump_enosys }, /* 243 = munlockall */ 5350 { 0, 0, 0, 5351 (sy_call_t *)rumpns_sys_nomodule }, /* 244 = __sigtimedwait */ 5352 { 0, 0, SYCALL_NOSYS, 5353 (sy_call_t *)rump_enosys }, /* 245 = sigqueueinfo */ 5354 { ns(struct sys_modctl_args), 0, 5355 (sy_call_t *)rumpns_sys_modctl }, /* 246 = modctl */ 5356 { ns(struct sys__ksem_init_args), 0, 5357 (sy_call_t *)rumpns_sys_nomodule }, /* 247 = _ksem_init */ 5358 { ns(struct sys__ksem_open_args), 0, 5359 (sy_call_t *)rumpns_sys_nomodule }, /* 248 = _ksem_open */ 5360 { ns(struct sys__ksem_unlink_args), 0, 5361 (sy_call_t *)rumpns_sys_nomodule }, /* 249 = _ksem_unlink */ 5362 { ns(struct sys__ksem_close_args), 0, 5363 (sy_call_t *)rumpns_sys_nomodule }, /* 250 = _ksem_close */ 5364 { ns(struct sys__ksem_post_args), 0, 5365 (sy_call_t *)rumpns_sys_nomodule }, /* 251 = _ksem_post */ 5366 { ns(struct sys__ksem_wait_args), 0, 5367 (sy_call_t *)rumpns_sys_nomodule }, /* 252 = _ksem_wait */ 5368 { ns(struct sys__ksem_trywait_args), 0, 5369 (sy_call_t *)rumpns_sys_nomodule }, /* 253 = _ksem_trywait */ 5370 { ns(struct sys__ksem_getvalue_args), 0, 5371 (sy_call_t *)rumpns_sys_nomodule }, /* 254 = _ksem_getvalue */ 5372 { ns(struct sys__ksem_destroy_args), 0, 5373 (sy_call_t *)rumpns_sys_nomodule }, /* 255 = _ksem_destroy */ 5374 { ns(struct sys__ksem_timedwait_args), 0, 5375 (sy_call_t *)rumpns_sys_nomodule }, /* 256 = _ksem_timedwait */ 5376 { 0, 0, 0, 5377 (sy_call_t *)rumpns_sys_nomodule }, /* 257 = mq_open */ 5378 { 0, 0, 0, 5379 (sy_call_t *)rumpns_sys_nomodule }, /* 258 = mq_close */ 5380 { 0, 0, 0, 5381 (sy_call_t *)rumpns_sys_nomodule }, /* 259 = mq_unlink */ 5382 { 0, 0, 0, 5383 (sy_call_t *)rumpns_sys_nomodule }, /* 260 = mq_getattr */ 5384 { 0, 0, 0, 5385 (sy_call_t *)rumpns_sys_nomodule }, /* 261 = mq_setattr */ 5386 { 0, 0, 0, 5387 (sy_call_t *)rumpns_sys_nomodule }, /* 262 = mq_notify */ 5388 { 0, 0, 0, 5389 (sy_call_t *)rumpns_sys_nomodule }, /* 263 = mq_send */ 5390 { 0, 0, 0, 5391 (sy_call_t *)rumpns_sys_nomodule }, /* 264 = mq_receive */ 5392 { 0, 0, 0, 5393 (sy_call_t *)rumpns_sys_nomodule }, /* 265 = mq_timedsend */ 5394 { 0, 0, 0, 5395 (sy_call_t *)rumpns_sys_nomodule }, /* 266 = mq_timedreceive */ 5396 { 0, 0, SYCALL_NOSYS, 5397 (sy_call_t *)rump_enosys }, /* 267 = unimplemented */ 5398 { 0, 0, SYCALL_NOSYS, 5399 (sy_call_t *)rump_enosys }, /* 268 = unimplemented */ 5400 { 0, 0, SYCALL_NOSYS, 5401 (sy_call_t *)rump_enosys }, /* 269 = unimplemented */ 5402 { 0, 0, SYCALL_NOSYS, 5403 (sy_call_t *)rump_enosys }, /* 270 = __posix_rename */ 5404 { 0, 0, SYCALL_NOSYS, 5405 (sy_call_t *)rump_enosys }, /* 271 = swapctl */ 5406 { 0, 0, 0, 5407 (sy_call_t *)rumpns_sys_nomodule }, /* 272 = getdents */ 5408 { 0, 0, SYCALL_NOSYS, 5409 (sy_call_t *)rump_enosys }, /* 273 = minherit */ 5410 { ns(struct sys_lchmod_args), 0, 5411 (sy_call_t *)rumpns_sys_lchmod }, /* 274 = lchmod */ 5412 { ns(struct sys_lchown_args), 0, 5413 (sy_call_t *)rumpns_sys_lchown }, /* 275 = lchown */ 5414 { ns(struct compat_50_sys_lutimes_args), 0, 5415 (sy_call_t *)rumpns_compat_50_sys_lutimes },/* 276 = compat_50_lutimes */ 5416 { 0, 0, SYCALL_NOSYS, 5417 (sy_call_t *)rump_enosys }, /* 277 = __msync13 */ 5418 { 0, 0, 0, 5419 (sy_call_t *)rumpns_sys_nomodule }, /* 278 = __stat13 */ 5420 { 0, 0, 0, 5421 (sy_call_t *)rumpns_sys_nomodule }, /* 279 = __fstat13 */ 5422 { 0, 0, 0, 5423 (sy_call_t *)rumpns_sys_nomodule }, /* 280 = __lstat13 */ 5424 { 0, 0, SYCALL_NOSYS, 5425 (sy_call_t *)rump_enosys }, /* 281 = __sigaltstack14 */ 5426 { 0, 0, SYCALL_NOSYS, 5427 (sy_call_t *)rump_enosys }, /* 282 = __vfork14 */ 5428 { 0, 0, SYCALL_NOSYS, 5429 (sy_call_t *)rump_enosys }, /* 283 = __posix_chown */ 5430 { 0, 0, SYCALL_NOSYS, 5431 (sy_call_t *)rump_enosys }, /* 284 = __posix_fchown */ 5432 { 0, 0, SYCALL_NOSYS, 5433 (sy_call_t *)rump_enosys }, /* 285 = __posix_lchown */ 5434 { ns(struct sys_getsid_args), 0, 5435 (sy_call_t *)rumpns_sys_getsid }, /* 286 = getsid */ 5436 { 0, 0, SYCALL_NOSYS, 5437 (sy_call_t *)rump_enosys }, /* 287 = __clone */ 5438 { 0, 0, SYCALL_NOSYS, 5439 (sy_call_t *)rump_enosys }, /* 288 = fktrace */ 5440 { ns(struct sys_preadv_args), 0, 5441 (sy_call_t *)rumpns_sys_preadv }, /* 289 = preadv */ 5442 { ns(struct sys_pwritev_args), 0, 5443 (sy_call_t *)rumpns_sys_pwritev }, /* 290 = pwritev */ 5444 { 0, 0, 0, 5445 (sy_call_t *)rumpns_sys_nomodule }, /* 291 = __sigaction14 */ 5446 { 0, 0, SYCALL_NOSYS, 5447 (sy_call_t *)rump_enosys }, /* 292 = __sigpending14 */ 5448 { 0, 0, SYCALL_NOSYS, 5449 (sy_call_t *)rump_enosys }, /* 293 = __sigprocmask14 */ 5450 { 0, 0, SYCALL_NOSYS, 5451 (sy_call_t *)rump_enosys }, /* 294 = __sigsuspend14 */ 5452 { 0, 0, 0, 5453 (sy_call_t *)rumpns_sys_nomodule }, /* 295 = __sigreturn14 */ 5454 { ns(struct sys___getcwd_args), 0, 5455 (sy_call_t *)rumpns_sys___getcwd }, /* 296 = __getcwd */ 5456 { ns(struct sys_fchroot_args), 0, 5457 (sy_call_t *)rumpns_sys_fchroot }, /* 297 = fchroot */ 5458 { 0, 0, 0, 5459 (sy_call_t *)rumpns_sys_nomodule }, /* 298 = fhopen */ 5460 { 0, 0, 0, 5461 (sy_call_t *)rumpns_sys_nomodule }, /* 299 = fhstat */ 5462 { 0, 0, 0, 5463 (sy_call_t *)rumpns_sys_nomodule }, /* 300 = fhstatfs */ 5464 #if defined(SYSVSEM) || !defined(_KERNEL_OPT) 5465 { 0, 0, 0, 5466 (sy_call_t *)rumpns_sys_nomodule }, /* 301 = ____semctl13 */ 5467 #else 5468 { 0, 0, SYCALL_NOSYS, 5469 (sy_call_t *)rump_enosys }, /* 301 = excluded ____semctl13 */ 5470 #endif 5471 #if defined(SYSVMSG) || !defined(_KERNEL_OPT) 5472 { 0, 0, 0, 5473 (sy_call_t *)rumpns_sys_nomodule }, /* 302 = __msgctl13 */ 5474 #else 5475 { 0, 0, SYCALL_NOSYS, 5476 (sy_call_t *)rump_enosys }, /* 302 = excluded __msgctl13 */ 5477 #endif 5478 #if defined(SYSVSHM) || !defined(_KERNEL_OPT) 5479 { 0, 0, 0, 5480 (sy_call_t *)rumpns_sys_nomodule }, /* 303 = __shmctl13 */ 5481 #else 5482 { 0, 0, SYCALL_NOSYS, 5483 (sy_call_t *)rump_enosys }, /* 303 = excluded __shmctl13 */ 5484 #endif 5485 { ns(struct sys_lchflags_args), 0, 5486 (sy_call_t *)rumpns_sys_lchflags }, /* 304 = lchflags */ 5487 { 0, 0, 0, 5488 (sy_call_t *)rumpns_sys_issetugid },/* 305 = issetugid */ 5489 { 0, 0, SYCALL_NOSYS, 5490 (sy_call_t *)rump_enosys }, /* 306 = utrace */ 5491 { 0, 0, SYCALL_NOSYS, 5492 (sy_call_t *)rump_enosys }, /* 307 = getcontext */ 5493 { 0, 0, SYCALL_NOSYS, 5494 (sy_call_t *)rump_enosys }, /* 308 = setcontext */ 5495 { 0, 0, SYCALL_NOSYS, 5496 (sy_call_t *)rump_enosys }, /* 309 = _lwp_create */ 5497 { 0, 0, SYCALL_NOSYS, 5498 (sy_call_t *)rump_enosys }, /* 310 = _lwp_exit */ 5499 { 0, 0, SYCALL_NOSYS, 5500 (sy_call_t *)rump_enosys }, /* 311 = _lwp_self */ 5501 { 0, 0, SYCALL_NOSYS, 5502 (sy_call_t *)rump_enosys }, /* 312 = _lwp_wait */ 5503 { 0, 0, SYCALL_NOSYS, 5504 (sy_call_t *)rump_enosys }, /* 313 = _lwp_suspend */ 5505 { 0, 0, SYCALL_NOSYS, 5506 (sy_call_t *)rump_enosys }, /* 314 = _lwp_continue */ 5507 { 0, 0, SYCALL_NOSYS, 5508 (sy_call_t *)rump_enosys }, /* 315 = _lwp_wakeup */ 5509 { 0, 0, SYCALL_NOSYS, 5510 (sy_call_t *)rump_enosys }, /* 316 = _lwp_getprivate */ 5511 { 0, 0, SYCALL_NOSYS, 5512 (sy_call_t *)rump_enosys }, /* 317 = _lwp_setprivate */ 5513 { 0, 0, SYCALL_NOSYS, 5514 (sy_call_t *)rump_enosys }, /* 318 = _lwp_kill */ 5515 { 0, 0, SYCALL_NOSYS, 5516 (sy_call_t *)rump_enosys }, /* 319 = _lwp_detach */ 5517 { 0, 0, 0, 5518 (sy_call_t *)rumpns_sys_nomodule }, /* 320 = _lwp_park */ 5519 { 0, 0, SYCALL_NOSYS, 5520 (sy_call_t *)rump_enosys }, /* 321 = _lwp_unpark */ 5521 { 0, 0, SYCALL_NOSYS, 5522 (sy_call_t *)rump_enosys }, /* 322 = _lwp_unpark_all */ 5523 { 0, 0, SYCALL_NOSYS, 5524 (sy_call_t *)rump_enosys }, /* 323 = _lwp_setname */ 5525 { 0, 0, SYCALL_NOSYS, 5526 (sy_call_t *)rump_enosys }, /* 324 = _lwp_getname */ 5527 { 0, 0, SYCALL_NOSYS, 5528 (sy_call_t *)rump_enosys }, /* 325 = _lwp_ctl */ 5529 { 0, 0, SYCALL_NOSYS, 5530 (sy_call_t *)rump_enosys }, /* 326 = unimplemented */ 5531 { 0, 0, SYCALL_NOSYS, 5532 (sy_call_t *)rump_enosys }, /* 327 = unimplemented */ 5533 { 0, 0, SYCALL_NOSYS, 5534 (sy_call_t *)rump_enosys }, /* 328 = unimplemented */ 5535 { 0, 0, SYCALL_NOSYS, 5536 (sy_call_t *)rump_enosys }, /* 329 = unimplemented */ 5537 { 0, 0, SYCALL_NOSYS, 5538 (sy_call_t *)rump_enosys }, /* 330 = sa_register */ 5539 { 0, 0, SYCALL_NOSYS, 5540 (sy_call_t *)rump_enosys }, /* 331 = sa_stacks */ 5541 { 0, 0, SYCALL_NOSYS, 5542 (sy_call_t *)rump_enosys }, /* 332 = sa_enable */ 5543 { 0, 0, SYCALL_NOSYS, 5544 (sy_call_t *)rump_enosys }, /* 333 = sa_setconcurrency */ 5545 { 0, 0, SYCALL_NOSYS, 5546 (sy_call_t *)rump_enosys }, /* 334 = sa_yield */ 5547 { 0, 0, SYCALL_NOSYS, 5548 (sy_call_t *)rump_enosys }, /* 335 = sa_preempt */ 5549 { 0, 0, SYCALL_NOSYS, 5550 (sy_call_t *)rump_enosys }, /* 336 = obsolete sys_sa_unblockyield */ 5551 { 0, 0, SYCALL_NOSYS, 5552 (sy_call_t *)rump_enosys }, /* 337 = unimplemented */ 5553 { 0, 0, SYCALL_NOSYS, 5554 (sy_call_t *)rump_enosys }, /* 338 = unimplemented */ 5555 { 0, 0, SYCALL_NOSYS, 5556 (sy_call_t *)rump_enosys }, /* 339 = unimplemented */ 5557 { 0, 0, SYCALL_NOSYS, 5558 (sy_call_t *)rump_enosys }, /* 340 = __sigaction_sigtramp */ 5559 { 0, 0, SYCALL_NOSYS, 5560 (sy_call_t *)rump_enosys }, /* 341 = pmc_get_info */ 5561 { 0, 0, SYCALL_NOSYS, 5562 (sy_call_t *)rump_enosys }, /* 342 = pmc_control */ 5563 { 0, 0, SYCALL_NOSYS, 5564 (sy_call_t *)rump_enosys }, /* 343 = rasctl */ 5565 { 0, 0, 0, 5566 (sy_call_t *)rumpns_sys_kqueue }, /* 344 = kqueue */ 5567 { ns(struct compat_50_sys_kevent_args), 0, 5568 (sy_call_t *)rumpns_compat_50_sys_kevent },/* 345 = compat_50_kevent */ 5569 { 0, 0, SYCALL_NOSYS, 5570 (sy_call_t *)rump_enosys }, /* 346 = _sched_setparam */ 5571 { 0, 0, SYCALL_NOSYS, 5572 (sy_call_t *)rump_enosys }, /* 347 = _sched_getparam */ 5573 { 0, 0, SYCALL_NOSYS, 5574 (sy_call_t *)rump_enosys }, /* 348 = _sched_setaffinity */ 5575 { 0, 0, SYCALL_NOSYS, 5576 (sy_call_t *)rump_enosys }, /* 349 = _sched_getaffinity */ 5577 { 0, 0, SYCALL_NOSYS, 5578 (sy_call_t *)rump_enosys }, /* 350 = sched_yield */ 5579 { 0, 0, SYCALL_NOSYS, 5580 (sy_call_t *)rump_enosys }, /* 351 = unimplemented */ 5581 { 0, 0, SYCALL_NOSYS, 5582 (sy_call_t *)rump_enosys }, /* 352 = unimplemented */ 5583 { 0, 0, SYCALL_NOSYS, 5584 (sy_call_t *)rump_enosys }, /* 353 = unimplemented */ 5585 { ns(struct sys_fsync_range_args), 0, 5586 (sy_call_t *)rumpns_sys_fsync_range },/* 354 = fsync_range */ 5587 { 0, 0, SYCALL_NOSYS, 5588 (sy_call_t *)rump_enosys }, /* 355 = uuidgen */ 5589 { ns(struct sys_getvfsstat_args), 0, 5590 (sy_call_t *)rumpns_sys_getvfsstat },/* 356 = getvfsstat */ 5591 { ns(struct sys_statvfs1_args), 0, 5592 (sy_call_t *)rumpns_sys_statvfs1 }, /* 357 = statvfs1 */ 5593 { ns(struct sys_fstatvfs1_args), 0, 5594 (sy_call_t *)rumpns_sys_fstatvfs1 },/* 358 = fstatvfs1 */ 5595 { 0, 0, 0, 5596 (sy_call_t *)rumpns_sys_nomodule }, /* 359 = fhstatvfs1 */ 5597 { ns(struct sys_extattrctl_args), 0, 5598 (sy_call_t *)rumpns_sys_extattrctl },/* 360 = extattrctl */ 5599 { ns(struct sys_extattr_set_file_args), 0, 5600 (sy_call_t *)rumpns_sys_extattr_set_file },/* 361 = extattr_set_file */ 5601 { ns(struct sys_extattr_get_file_args), 0, 5602 (sy_call_t *)rumpns_sys_extattr_get_file },/* 362 = extattr_get_file */ 5603 { ns(struct sys_extattr_delete_file_args), 0, 5604 (sy_call_t *)rumpns_sys_extattr_delete_file },/* 363 = extattr_delete_file */ 5605 { ns(struct sys_extattr_set_fd_args), 0, 5606 (sy_call_t *)rumpns_sys_extattr_set_fd },/* 364 = extattr_set_fd */ 5607 { ns(struct sys_extattr_get_fd_args), 0, 5608 (sy_call_t *)rumpns_sys_extattr_get_fd },/* 365 = extattr_get_fd */ 5609 { ns(struct sys_extattr_delete_fd_args), 0, 5610 (sy_call_t *)rumpns_sys_extattr_delete_fd },/* 366 = extattr_delete_fd */ 5611 { ns(struct sys_extattr_set_link_args), 0, 5612 (sy_call_t *)rumpns_sys_extattr_set_link },/* 367 = extattr_set_link */ 5613 { ns(struct sys_extattr_get_link_args), 0, 5614 (sy_call_t *)rumpns_sys_extattr_get_link },/* 368 = extattr_get_link */ 5615 { ns(struct sys_extattr_delete_link_args), 0, 5616 (sy_call_t *)rumpns_sys_extattr_delete_link },/* 369 = extattr_delete_link */ 5617 { ns(struct sys_extattr_list_fd_args), 0, 5618 (sy_call_t *)rumpns_sys_extattr_list_fd },/* 370 = extattr_list_fd */ 5619 { ns(struct sys_extattr_list_file_args), 0, 5620 (sy_call_t *)rumpns_sys_extattr_list_file },/* 371 = extattr_list_file */ 5621 { ns(struct sys_extattr_list_link_args), 0, 5622 (sy_call_t *)rumpns_sys_extattr_list_link },/* 372 = extattr_list_link */ 5623 { ns(struct compat_50_sys_pselect_args), 0, 5624 (sy_call_t *)rumpns_compat_50_sys_pselect },/* 373 = compat_50_pselect */ 5625 { ns(struct compat_50_sys_pollts_args), 0, 5626 (sy_call_t *)rumpns_compat_50_sys_pollts },/* 374 = compat_50_pollts */ 5627 { ns(struct sys_setxattr_args), 0, 5628 (sy_call_t *)rumpns_sys_setxattr }, /* 375 = setxattr */ 5629 { ns(struct sys_lsetxattr_args), 0, 5630 (sy_call_t *)rumpns_sys_lsetxattr },/* 376 = lsetxattr */ 5631 { ns(struct sys_fsetxattr_args), 0, 5632 (sy_call_t *)rumpns_sys_fsetxattr },/* 377 = fsetxattr */ 5633 { ns(struct sys_getxattr_args), 0, 5634 (sy_call_t *)rumpns_sys_getxattr }, /* 378 = getxattr */ 5635 { ns(struct sys_lgetxattr_args), 0, 5636 (sy_call_t *)rumpns_sys_lgetxattr },/* 379 = lgetxattr */ 5637 { ns(struct sys_fgetxattr_args), 0, 5638 (sy_call_t *)rumpns_sys_fgetxattr },/* 380 = fgetxattr */ 5639 { ns(struct sys_listxattr_args), 0, 5640 (sy_call_t *)rumpns_sys_listxattr },/* 381 = listxattr */ 5641 { ns(struct sys_llistxattr_args), 0, 5642 (sy_call_t *)rumpns_sys_llistxattr },/* 382 = llistxattr */ 5643 { ns(struct sys_flistxattr_args), 0, 5644 (sy_call_t *)rumpns_sys_flistxattr },/* 383 = flistxattr */ 5645 { ns(struct sys_removexattr_args), 0, 5646 (sy_call_t *)rumpns_sys_removexattr },/* 384 = removexattr */ 5647 { ns(struct sys_lremovexattr_args), 0, 5648 (sy_call_t *)rumpns_sys_lremovexattr },/* 385 = lremovexattr */ 5649 { ns(struct sys_fremovexattr_args), 0, 5650 (sy_call_t *)rumpns_sys_fremovexattr },/* 386 = fremovexattr */ 5651 { ns(struct compat_50_sys___stat30_args), 0, 5652 (sy_call_t *)rumpns_compat_50_sys___stat30 },/* 387 = compat_50___stat30 */ 5653 { ns(struct compat_50_sys___fstat30_args), 0, 5654 (sy_call_t *)rumpns_compat_50_sys___fstat30 },/* 388 = compat_50___fstat30 */ 5655 { ns(struct compat_50_sys___lstat30_args), 0, 5656 (sy_call_t *)rumpns_compat_50_sys___lstat30 },/* 389 = compat_50___lstat30 */ 5657 { ns(struct sys___getdents30_args), 0, 5658 (sy_call_t *)rumpns_sys___getdents30 },/* 390 = __getdents30 */ 5659 { 0, 0, SYCALL_NOSYS, 5660 (sy_call_t *)rump_enosys }, /* 391 = ignored old posix_fadvise */ 5661 { 0, 0, 0, 5662 (sy_call_t *)rumpns_sys_nomodule }, /* 392 = __fhstat30 */ 5663 { 0, 0, 0, 5664 (sy_call_t *)rumpns_sys_nomodule }, /* 393 = __ntp_gettime30 */ 5665 { ns(struct sys___socket30_args), 0, 5666 (sy_call_t *)rumpns_sys___socket30 },/* 394 = __socket30 */ 5667 { ns(struct sys___getfh30_args), 0, 5668 (sy_call_t *)rumpns_sys___getfh30 },/* 395 = __getfh30 */ 5669 { ns(struct sys___fhopen40_args), 0, 5670 (sy_call_t *)rumpns_sys___fhopen40 },/* 396 = __fhopen40 */ 5671 { ns(struct sys___fhstatvfs140_args), 0, 5672 (sy_call_t *)rumpns_sys___fhstatvfs140 },/* 397 = __fhstatvfs140 */ 5673 { ns(struct compat_50_sys___fhstat40_args), 0, 5674 (sy_call_t *)rumpns_compat_50_sys___fhstat40 },/* 398 = compat_50___fhstat40 */ 5675 { 0, 0, 0, 5676 (sy_call_t *)rumpns_sys_nomodule }, /* 399 = aio_cancel */ 5677 { 0, 0, 0, 5678 (sy_call_t *)rumpns_sys_nomodule }, /* 400 = aio_error */ 5679 { 0, 0, 0, 5680 (sy_call_t *)rumpns_sys_nomodule }, /* 401 = aio_fsync */ 5681 { 0, 0, 0, 5682 (sy_call_t *)rumpns_sys_nomodule }, /* 402 = aio_read */ 5683 { 0, 0, 0, 5684 (sy_call_t *)rumpns_sys_nomodule }, /* 403 = aio_return */ 5685 { 0, 0, 0, 5686 (sy_call_t *)rumpns_sys_nomodule }, /* 404 = aio_suspend */ 5687 { 0, 0, 0, 5688 (sy_call_t *)rumpns_sys_nomodule }, /* 405 = aio_write */ 5689 { 0, 0, 0, 5690 (sy_call_t *)rumpns_sys_nomodule }, /* 406 = lio_listio */ 5691 { 0, 0, SYCALL_NOSYS, 5692 (sy_call_t *)rump_enosys }, /* 407 = unimplemented */ 5693 { 0, 0, SYCALL_NOSYS, 5694 (sy_call_t *)rump_enosys }, /* 408 = unimplemented */ 5695 { 0, 0, SYCALL_NOSYS, 5696 (sy_call_t *)rump_enosys }, /* 409 = unimplemented */ 5697 { ns(struct sys___mount50_args), 0, 5698 (sy_call_t *)rumpns_sys___mount50 },/* 410 = __mount50 */ 5699 { 0, 0, SYCALL_NOSYS, 5700 (sy_call_t *)rump_enosys }, /* 411 = mremap */ 5701 { 0, 0, SYCALL_NOSYS, 5702 (sy_call_t *)rump_enosys }, /* 412 = pset_create */ 5703 { 0, 0, SYCALL_NOSYS, 5704 (sy_call_t *)rump_enosys }, /* 413 = pset_destroy */ 5705 { 0, 0, SYCALL_NOSYS, 5706 (sy_call_t *)rump_enosys }, /* 414 = pset_assign */ 5707 { 0, 0, SYCALL_NOSYS, 5708 (sy_call_t *)rump_enosys }, /* 415 = _pset_bind */ 5709 { ns(struct sys___posix_fadvise50_args), 0, 5710 (sy_call_t *)rumpns_sys___posix_fadvise50 },/* 416 = __posix_fadvise50 */ 5711 { ns(struct sys___select50_args), 0, 5712 (sy_call_t *)rumpns_sys___select50 },/* 417 = __select50 */ 5713 { 0, 0, SYCALL_NOSYS, 5714 (sy_call_t *)rump_enosys }, /* 418 = __gettimeofday50 */ 5715 { 0, 0, SYCALL_NOSYS, 5716 (sy_call_t *)rump_enosys }, /* 419 = __settimeofday50 */ 5717 { ns(struct sys___utimes50_args), 0, 5718 (sy_call_t *)rumpns_sys___utimes50 },/* 420 = __utimes50 */ 5719 { 0, 0, SYCALL_NOSYS, 5720 (sy_call_t *)rump_enosys }, /* 421 = __adjtime50 */ 5721 { 0, 0, 0, 5722 (sy_call_t *)rumpns_sys_nomodule }, /* 422 = __lfs_segwait50 */ 5723 { ns(struct sys___futimes50_args), 0, 5724 (sy_call_t *)rumpns_sys___futimes50 },/* 423 = __futimes50 */ 5725 { ns(struct sys___lutimes50_args), 0, 5726 (sy_call_t *)rumpns_sys___lutimes50 },/* 424 = __lutimes50 */ 5727 { 0, 0, SYCALL_NOSYS, 5728 (sy_call_t *)rump_enosys }, /* 425 = __setitimer50 */ 5729 { 0, 0, SYCALL_NOSYS, 5730 (sy_call_t *)rump_enosys }, /* 426 = __getitimer50 */ 5731 { 0, 0, SYCALL_NOSYS, 5732 (sy_call_t *)rump_enosys }, /* 427 = __clock_gettime50 */ 5733 { 0, 0, SYCALL_NOSYS, 5734 (sy_call_t *)rump_enosys }, /* 428 = __clock_settime50 */ 5735 { 0, 0, SYCALL_NOSYS, 5736 (sy_call_t *)rump_enosys }, /* 429 = __clock_getres50 */ 5737 { 0, 0, SYCALL_NOSYS, 5738 (sy_call_t *)rump_enosys }, /* 430 = __nanosleep50 */ 5739 { 0, 0, SYCALL_NOSYS, 5740 (sy_call_t *)rump_enosys }, /* 431 = ____sigtimedwait50 */ 5741 { 0, 0, 0, 5742 (sy_call_t *)rumpns_sys_nomodule }, /* 432 = __mq_timedsend50 */ 5743 { 0, 0, 0, 5744 (sy_call_t *)rumpns_sys_nomodule }, /* 433 = __mq_timedreceive50 */ 5745 { 0, 0, 0, 5746 (sy_call_t *)rumpns_sys_nomodule }, /* 434 = _lwp_park */ 5747 { ns(struct sys___kevent50_args), 0, 5748 (sy_call_t *)rumpns_sys___kevent50 },/* 435 = __kevent50 */ 5749 { ns(struct sys___pselect50_args), 0, 5750 (sy_call_t *)rumpns_sys___pselect50 },/* 436 = __pselect50 */ 5751 { ns(struct sys___pollts50_args), 0, 5752 (sy_call_t *)rumpns_sys___pollts50 },/* 437 = __pollts50 */ 5753 { 0, 0, 0, 5754 (sy_call_t *)rumpns_sys_nomodule }, /* 438 = __aio_suspend50 */ 5755 { ns(struct sys___stat50_args), 0, 5756 (sy_call_t *)rumpns_sys___stat50 }, /* 439 = __stat50 */ 5757 { ns(struct sys___fstat50_args), 0, 5758 (sy_call_t *)rumpns_sys___fstat50 },/* 440 = __fstat50 */ 5759 { ns(struct sys___lstat50_args), 0, 5760 (sy_call_t *)rumpns_sys___lstat50 },/* 441 = __lstat50 */ 5761 #if defined(SYSVSEM) || !defined(_KERNEL_OPT) 5762 { 0, 0, SYCALL_NOSYS, 5763 (sy_call_t *)rump_enosys }, /* 442 = ____semctl50 */ 5764 #else 5765 { 0, 0, SYCALL_NOSYS, 5766 (sy_call_t *)rump_enosys }, /* 442 = excluded ____semctl50 */ 5767 #endif 5768 #if defined(SYSVSHM) || !defined(_KERNEL_OPT) 5769 { 0, 0, SYCALL_NOSYS, 5770 (sy_call_t *)rump_enosys }, /* 443 = __shmctl50 */ 5771 #else 5772 { 0, 0, SYCALL_NOSYS, 5773 (sy_call_t *)rump_enosys }, /* 443 = excluded ____shmctl50 */ 5774 #endif 5775 #if defined(SYSVMSG) || !defined(_KERNEL_OPT) 5776 { 0, 0, SYCALL_NOSYS, 5777 (sy_call_t *)rump_enosys }, /* 444 = __msgctl50 */ 5778 #else 5779 { 0, 0, SYCALL_NOSYS, 5780 (sy_call_t *)rump_enosys }, /* 444 = excluded ____msgctl50 */ 5781 #endif 5782 { 0, 0, SYCALL_NOSYS, 5783 (sy_call_t *)rump_enosys }, /* 445 = __getrusage50 */ 5784 { 0, 0, SYCALL_NOSYS, 5785 (sy_call_t *)rump_enosys }, /* 446 = __timer_settime50 */ 5786 { 0, 0, SYCALL_NOSYS, 5787 (sy_call_t *)rump_enosys }, /* 447 = __timer_gettime50 */ 5788 #if defined(NTP) || !defined(_KERNEL_OPT) 5789 { 0, 0, SYCALL_NOSYS, 5790 (sy_call_t *)rump_enosys }, /* 448 = __ntp_gettime50 */ 5791 #else 5792 { 0, 0, SYCALL_NOSYS, 5793 (sy_call_t *)rump_enosys }, /* 448 = excluded ___ntp_gettime50 */ 5794 #endif 5795 { 0, 0, SYCALL_NOSYS, 5796 (sy_call_t *)rump_enosys }, /* 449 = __wait450 */ 5797 { ns(struct sys___mknod50_args), 0, 5798 (sy_call_t *)rumpns_sys___mknod50 },/* 450 = __mknod50 */ 5799 { ns(struct sys___fhstat50_args), 0, 5800 (sy_call_t *)rumpns_sys___fhstat50 },/* 451 = __fhstat50 */ 5801 { 0, 0, SYCALL_NOSYS, 5802 (sy_call_t *)rump_enosys }, /* 452 = obsolete 5.99 quotactl */ 5803 { ns(struct sys_pipe2_args), 0, 5804 (sy_call_t *)rumpns_sys_pipe2 }, /* 453 = pipe2 */ 5805 { ns(struct sys_dup3_args), 0, 5806 (sy_call_t *)rumpns_sys_dup3 }, /* 454 = dup3 */ 5807 { ns(struct sys_kqueue1_args), 0, 5808 (sy_call_t *)rumpns_sys_kqueue1 }, /* 455 = kqueue1 */ 5809 { ns(struct sys_paccept_args), 0, 5810 (sy_call_t *)rumpns_sys_paccept }, /* 456 = paccept */ 5811 { ns(struct sys_linkat_args), 0, 5812 (sy_call_t *)rumpns_sys_linkat }, /* 457 = linkat */ 5813 { ns(struct sys_renameat_args), 0, 5814 (sy_call_t *)rumpns_sys_renameat }, /* 458 = renameat */ 5815 { ns(struct sys_mkfifoat_args), 0, 5816 (sy_call_t *)rumpns_sys_mkfifoat }, /* 459 = mkfifoat */ 5817 { ns(struct sys_mknodat_args), 0, 5818 (sy_call_t *)rumpns_sys_mknodat }, /* 460 = mknodat */ 5819 { ns(struct sys_mkdirat_args), 0, 5820 (sy_call_t *)rumpns_sys_mkdirat }, /* 461 = mkdirat */ 5821 { ns(struct sys_faccessat_args), 0, 5822 (sy_call_t *)rumpns_sys_faccessat },/* 462 = faccessat */ 5823 { ns(struct sys_fchmodat_args), 0, 5824 (sy_call_t *)rumpns_sys_fchmodat }, /* 463 = fchmodat */ 5825 { ns(struct sys_fchownat_args), 0, 5826 (sy_call_t *)rumpns_sys_fchownat }, /* 464 = fchownat */ 5827 { 0, 0, SYCALL_NOSYS, 5828 (sy_call_t *)rump_enosys }, /* 465 = fexecve */ 5829 { ns(struct sys_fstatat_args), 0, 5830 (sy_call_t *)rumpns_sys_fstatat }, /* 466 = fstatat */ 5831 { ns(struct sys_utimensat_args), 0, 5832 (sy_call_t *)rumpns_sys_utimensat },/* 467 = utimensat */ 5833 { ns(struct sys_openat_args), 0, 5834 (sy_call_t *)rumpns_sys_openat }, /* 468 = openat */ 5835 { ns(struct sys_readlinkat_args), 0, 5836 (sy_call_t *)rumpns_sys_readlinkat },/* 469 = readlinkat */ 5837 { ns(struct sys_symlinkat_args), 0, 5838 (sy_call_t *)rumpns_sys_symlinkat },/* 470 = symlinkat */ 5839 { ns(struct sys_unlinkat_args), 0, 5840 (sy_call_t *)rumpns_sys_unlinkat }, /* 471 = unlinkat */ 5841 { ns(struct sys_futimens_args), 0, 5842 (sy_call_t *)rumpns_sys_futimens }, /* 472 = futimens */ 5843 { ns(struct sys___quotactl_args), 0, 5844 (sy_call_t *)rumpns_sys___quotactl },/* 473 = __quotactl */ 5845 { 0, 0, SYCALL_NOSYS, 5846 (sy_call_t *)rump_enosys }, /* 474 = posix_spawn */ 5847 { ns(struct sys_recvmmsg_args), 0, 5848 (sy_call_t *)rumpns_sys_recvmmsg }, /* 475 = recvmmsg */ 5849 { ns(struct sys_sendmmsg_args), 0, 5850 (sy_call_t *)rumpns_sys_sendmmsg }, /* 476 = sendmmsg */ 5851 { 0, 0, SYCALL_NOSYS, 5852 (sy_call_t *)rump_enosys }, /* 477 = clock_nanosleep */ 5853 { 0, 0, SYCALL_NOSYS, 5854 (sy_call_t *)rump_enosys }, /* 478 = ___lwp_park60 */ 5855 { 0, 0, SYCALL_NOSYS, 5856 (sy_call_t *)rump_enosys }, /* 479 = filler */ 5857 { 0, 0, SYCALL_NOSYS, 5858 (sy_call_t *)rump_enosys }, /* 480 = filler */ 5859 { 0, 0, SYCALL_NOSYS, 5860 (sy_call_t *)rump_enosys }, /* 481 = filler */ 5861 { 0, 0, SYCALL_NOSYS, 5862 (sy_call_t *)rump_enosys }, /* 482 = filler */ 5863 { 0, 0, SYCALL_NOSYS, 5864 (sy_call_t *)rump_enosys }, /* 483 = filler */ 5865 { 0, 0, SYCALL_NOSYS, 5866 (sy_call_t *)rump_enosys }, /* 484 = filler */ 5867 { 0, 0, SYCALL_NOSYS, 5868 (sy_call_t *)rump_enosys }, /* 485 = filler */ 5869 { 0, 0, SYCALL_NOSYS, 5870 (sy_call_t *)rump_enosys }, /* 486 = filler */ 5871 { 0, 0, SYCALL_NOSYS, 5872 (sy_call_t *)rump_enosys }, /* 487 = filler */ 5873 { 0, 0, SYCALL_NOSYS, 5874 (sy_call_t *)rump_enosys }, /* 488 = filler */ 5875 { 0, 0, SYCALL_NOSYS, 5876 (sy_call_t *)rump_enosys }, /* 489 = filler */ 5877 { 0, 0, SYCALL_NOSYS, 5878 (sy_call_t *)rump_enosys }, /* 490 = filler */ 5879 { 0, 0, SYCALL_NOSYS, 5880 (sy_call_t *)rump_enosys }, /* 491 = filler */ 5881 { 0, 0, SYCALL_NOSYS, 5882 (sy_call_t *)rump_enosys }, /* 492 = filler */ 5883 { 0, 0, SYCALL_NOSYS, 5884 (sy_call_t *)rump_enosys }, /* 493 = filler */ 5885 { 0, 0, SYCALL_NOSYS, 5886 (sy_call_t *)rump_enosys }, /* 494 = filler */ 5887 { 0, 0, SYCALL_NOSYS, 5888 (sy_call_t *)rump_enosys }, /* 495 = filler */ 5889 { 0, 0, SYCALL_NOSYS, 5890 (sy_call_t *)rump_enosys }, /* 496 = filler */ 5891 { 0, 0, SYCALL_NOSYS, 5892 (sy_call_t *)rump_enosys }, /* 497 = filler */ 5893 { 0, 0, SYCALL_NOSYS, 5894 (sy_call_t *)rump_enosys }, /* 498 = filler */ 5895 { 0, 0, SYCALL_NOSYS, 5896 (sy_call_t *)rump_enosys }, /* 499 = filler */ 5897 { 0, 0, SYCALL_NOSYS, 5898 (sy_call_t *)rump_enosys }, /* 500 = filler */ 5899 { 0, 0, SYCALL_NOSYS, 5900 (sy_call_t *)rump_enosys }, /* 501 = filler */ 5901 { 0, 0, SYCALL_NOSYS, 5902 (sy_call_t *)rump_enosys }, /* 502 = filler */ 5903 { 0, 0, SYCALL_NOSYS, 5904 (sy_call_t *)rump_enosys }, /* 503 = filler */ 5905 { 0, 0, SYCALL_NOSYS, 5906 (sy_call_t *)rump_enosys }, /* 504 = filler */ 5907 { 0, 0, SYCALL_NOSYS, 5908 (sy_call_t *)rump_enosys }, /* 505 = filler */ 5909 { 0, 0, SYCALL_NOSYS, 5910 (sy_call_t *)rump_enosys }, /* 506 = filler */ 5911 { 0, 0, SYCALL_NOSYS, 5912 (sy_call_t *)rump_enosys }, /* 507 = filler */ 5913 { 0, 0, SYCALL_NOSYS, 5914 (sy_call_t *)rump_enosys }, /* 508 = filler */ 5915 { 0, 0, SYCALL_NOSYS, 5916 (sy_call_t *)rump_enosys }, /* 509 = filler */ 5917 { 0, 0, SYCALL_NOSYS, 5918 (sy_call_t *)rump_enosys }, /* 510 = filler */ 5919 { 0, 0, SYCALL_NOSYS, 5920 (sy_call_t *)rump_enosys }, /* 511 = filler */ 5921 }; 5922 CTASSERT(__arraycount(rump_sysent) == SYS_NSYSENT); 5923 __strong_alias(rumpns_sysent,rump_sysent); 5924 #endif /* RUMP_CLIENT */ 5925
Indexes created Wed Oct 01 07:09:59 GMT 2025