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