rump_syscalls.c revision 1.99
1 /* $NetBSD: rump_syscalls.c,v 1.99 2014/04/09 23:57:26 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.268 2014/04/09 23:55:37 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.99 2014/04/09 23:57:26 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_aio_cancel(int, struct aiocb *); 4132 int 4133 rump___sysimpl_aio_cancel(int fildes, struct aiocb * aiocbp) 4134 { 4135 register_t retval[2]; 4136 int error = 0; 4137 int rv = -1; 4138 struct sys_aio_cancel_args callarg; 4139 4140 memset(&callarg, 0, sizeof(callarg)); 4141 SPARG(&callarg, fildes) = fildes; 4142 SPARG(&callarg, aiocbp) = aiocbp; 4143 4144 error = rsys_syscall(SYS_aio_cancel, &callarg, sizeof(callarg), retval); 4145 rsys_seterrno(error); 4146 if (error == 0) { 4147 if (sizeof(int) > sizeof(register_t)) 4148 rv = *(int *)retval; 4149 else 4150 rv = *retval; 4151 } 4152 return rv; 4153 } 4154 rsys_define(rumpns_sys_aio_cancel); 4155 rsys_aliases(aio_cancel,rump___sysimpl_aio_cancel); 4156 4157 int rump___sysimpl_aio_error(const struct aiocb *); 4158 int 4159 rump___sysimpl_aio_error(const struct aiocb * aiocbp) 4160 { 4161 register_t retval[2]; 4162 int error = 0; 4163 int rv = -1; 4164 struct sys_aio_error_args callarg; 4165 4166 memset(&callarg, 0, sizeof(callarg)); 4167 SPARG(&callarg, aiocbp) = aiocbp; 4168 4169 error = rsys_syscall(SYS_aio_error, &callarg, sizeof(callarg), retval); 4170 rsys_seterrno(error); 4171 if (error == 0) { 4172 if (sizeof(int) > sizeof(register_t)) 4173 rv = *(int *)retval; 4174 else 4175 rv = *retval; 4176 } 4177 return rv; 4178 } 4179 rsys_define(rumpns_sys_aio_error); 4180 rsys_aliases(aio_error,rump___sysimpl_aio_error); 4181 4182 int rump___sysimpl_aio_fsync(int, struct aiocb *); 4183 int 4184 rump___sysimpl_aio_fsync(int op, struct aiocb * aiocbp) 4185 { 4186 register_t retval[2]; 4187 int error = 0; 4188 int rv = -1; 4189 struct sys_aio_fsync_args callarg; 4190 4191 memset(&callarg, 0, sizeof(callarg)); 4192 SPARG(&callarg, op) = op; 4193 SPARG(&callarg, aiocbp) = aiocbp; 4194 4195 error = rsys_syscall(SYS_aio_fsync, &callarg, sizeof(callarg), retval); 4196 rsys_seterrno(error); 4197 if (error == 0) { 4198 if (sizeof(int) > sizeof(register_t)) 4199 rv = *(int *)retval; 4200 else 4201 rv = *retval; 4202 } 4203 return rv; 4204 } 4205 rsys_define(rumpns_sys_aio_fsync); 4206 rsys_aliases(aio_fsync,rump___sysimpl_aio_fsync); 4207 4208 int rump___sysimpl_aio_read(struct aiocb *); 4209 int 4210 rump___sysimpl_aio_read(struct aiocb * aiocbp) 4211 { 4212 register_t retval[2]; 4213 int error = 0; 4214 int rv = -1; 4215 struct sys_aio_read_args callarg; 4216 4217 memset(&callarg, 0, sizeof(callarg)); 4218 SPARG(&callarg, aiocbp) = aiocbp; 4219 4220 error = rsys_syscall(SYS_aio_read, &callarg, sizeof(callarg), retval); 4221 rsys_seterrno(error); 4222 if (error == 0) { 4223 if (sizeof(int) > sizeof(register_t)) 4224 rv = *(int *)retval; 4225 else 4226 rv = *retval; 4227 } 4228 return rv; 4229 } 4230 rsys_define(rumpns_sys_aio_read); 4231 rsys_aliases(aio_read,rump___sysimpl_aio_read); 4232 4233 int rump___sysimpl_aio_return(struct aiocb *); 4234 int 4235 rump___sysimpl_aio_return(struct aiocb * aiocbp) 4236 { 4237 register_t retval[2]; 4238 int error = 0; 4239 int rv = -1; 4240 struct sys_aio_return_args callarg; 4241 4242 memset(&callarg, 0, sizeof(callarg)); 4243 SPARG(&callarg, aiocbp) = aiocbp; 4244 4245 error = rsys_syscall(SYS_aio_return, &callarg, sizeof(callarg), retval); 4246 rsys_seterrno(error); 4247 if (error == 0) { 4248 if (sizeof(int) > sizeof(register_t)) 4249 rv = *(int *)retval; 4250 else 4251 rv = *retval; 4252 } 4253 return rv; 4254 } 4255 rsys_define(rumpns_sys_aio_return); 4256 rsys_aliases(aio_return,rump___sysimpl_aio_return); 4257 4258 int rump___sysimpl_aio_write(struct aiocb *); 4259 int 4260 rump___sysimpl_aio_write(struct aiocb * aiocbp) 4261 { 4262 register_t retval[2]; 4263 int error = 0; 4264 int rv = -1; 4265 struct sys_aio_write_args callarg; 4266 4267 memset(&callarg, 0, sizeof(callarg)); 4268 SPARG(&callarg, aiocbp) = aiocbp; 4269 4270 error = rsys_syscall(SYS_aio_write, &callarg, sizeof(callarg), retval); 4271 rsys_seterrno(error); 4272 if (error == 0) { 4273 if (sizeof(int) > sizeof(register_t)) 4274 rv = *(int *)retval; 4275 else 4276 rv = *retval; 4277 } 4278 return rv; 4279 } 4280 rsys_define(rumpns_sys_aio_write); 4281 rsys_aliases(aio_write,rump___sysimpl_aio_write); 4282 4283 int rump___sysimpl_lio_listio(int, struct aiocb *const *, int, struct sigevent *); 4284 int 4285 rump___sysimpl_lio_listio(int mode, struct aiocb *const * list, int nent, struct sigevent * sig) 4286 { 4287 register_t retval[2]; 4288 int error = 0; 4289 int rv = -1; 4290 struct sys_lio_listio_args callarg; 4291 4292 memset(&callarg, 0, sizeof(callarg)); 4293 SPARG(&callarg, mode) = mode; 4294 SPARG(&callarg, list) = list; 4295 SPARG(&callarg, nent) = nent; 4296 SPARG(&callarg, sig) = sig; 4297 4298 error = rsys_syscall(SYS_lio_listio, &callarg, sizeof(callarg), retval); 4299 rsys_seterrno(error); 4300 if (error == 0) { 4301 if (sizeof(int) > sizeof(register_t)) 4302 rv = *(int *)retval; 4303 else 4304 rv = *retval; 4305 } 4306 return rv; 4307 } 4308 rsys_define(rumpns_sys_lio_listio); 4309 rsys_aliases(lio_listio,rump___sysimpl_lio_listio); 4310 4311 int rump___sysimpl_mount50(const char *, const char *, int, void *, size_t); 4312 int 4313 rump___sysimpl_mount50(const char * type, const char * path, int flags, void * data, size_t data_len) 4314 { 4315 register_t retval[2]; 4316 int error = 0; 4317 int rv = -1; 4318 struct sys___mount50_args callarg; 4319 4320 memset(&callarg, 0, sizeof(callarg)); 4321 SPARG(&callarg, type) = type; 4322 SPARG(&callarg, path) = path; 4323 SPARG(&callarg, flags) = flags; 4324 SPARG(&callarg, data) = data; 4325 SPARG(&callarg, data_len) = data_len; 4326 4327 error = rsys_syscall(SYS___mount50, &callarg, sizeof(callarg), retval); 4328 rsys_seterrno(error); 4329 if (error == 0) { 4330 if (sizeof(int) > sizeof(register_t)) 4331 rv = *(int *)retval; 4332 else 4333 rv = *retval; 4334 } 4335 return rv; 4336 } 4337 rsys_define(rumpns_sys___mount50); 4338 rsys_aliases(__mount50,rump___sysimpl_mount50); 4339 4340 int rump___sysimpl_posix_fadvise50(int, off_t, off_t, int); 4341 int 4342 rump___sysimpl_posix_fadvise50(int fd, off_t offset, off_t len, int advice) 4343 { 4344 register_t retval[2]; 4345 int rv = -1; 4346 struct sys___posix_fadvise50_args callarg; 4347 4348 memset(&callarg, 0, sizeof(callarg)); 4349 SPARG(&callarg, fd) = fd; 4350 SPARG(&callarg, PAD) = 0; 4351 SPARG(&callarg, offset) = offset; 4352 SPARG(&callarg, len) = len; 4353 SPARG(&callarg, advice) = advice; 4354 4355 rsys_syscall(SYS___posix_fadvise50, &callarg, sizeof(callarg), retval); 4356 if (sizeof(int) > sizeof(register_t)) 4357 rv = *(int *)retval; 4358 else 4359 rv = *retval; 4360 return rv; 4361 } 4362 rsys_define(rumpns_sys___posix_fadvise50); 4363 rsys_aliases(__posix_fadvise50,rump___sysimpl_posix_fadvise50); 4364 4365 int rump___sysimpl_select50(int, fd_set *, fd_set *, fd_set *, struct timeval *); 4366 int 4367 rump___sysimpl_select50(int nd, fd_set * in, fd_set * ou, fd_set * ex, struct timeval * tv) 4368 { 4369 register_t retval[2]; 4370 int error = 0; 4371 int rv = -1; 4372 struct sys___select50_args callarg; 4373 4374 memset(&callarg, 0, sizeof(callarg)); 4375 SPARG(&callarg, nd) = nd; 4376 SPARG(&callarg, in) = in; 4377 SPARG(&callarg, ou) = ou; 4378 SPARG(&callarg, ex) = ex; 4379 SPARG(&callarg, tv) = tv; 4380 4381 error = rsys_syscall(SYS___select50, &callarg, sizeof(callarg), retval); 4382 rsys_seterrno(error); 4383 if (error == 0) { 4384 if (sizeof(int) > sizeof(register_t)) 4385 rv = *(int *)retval; 4386 else 4387 rv = *retval; 4388 } 4389 return rv; 4390 } 4391 rsys_define(rumpns_sys___select50); 4392 rsys_aliases(__select50,rump___sysimpl_select50); 4393 4394 int rump___sysimpl_gettimeofday50(struct timeval *, void *); 4395 int 4396 rump___sysimpl_gettimeofday50(struct timeval * tp, void * tzp) 4397 { 4398 register_t retval[2]; 4399 int error = 0; 4400 int rv = -1; 4401 struct sys___gettimeofday50_args callarg; 4402 4403 memset(&callarg, 0, sizeof(callarg)); 4404 SPARG(&callarg, tp) = tp; 4405 SPARG(&callarg, tzp) = tzp; 4406 4407 error = rsys_syscall(SYS___gettimeofday50, &callarg, sizeof(callarg), retval); 4408 rsys_seterrno(error); 4409 if (error == 0) { 4410 if (sizeof(int) > sizeof(register_t)) 4411 rv = *(int *)retval; 4412 else 4413 rv = *retval; 4414 } 4415 return rv; 4416 } 4417 rsys_define(rumpns_sys___gettimeofday50); 4418 rsys_aliases(__gettimeofday50,rump___sysimpl_gettimeofday50); 4419 4420 int rump___sysimpl_settimeofday50(const struct timeval *, const void *); 4421 int 4422 rump___sysimpl_settimeofday50(const struct timeval * tv, const void * tzp) 4423 { 4424 register_t retval[2]; 4425 int error = 0; 4426 int rv = -1; 4427 struct sys___settimeofday50_args callarg; 4428 4429 memset(&callarg, 0, sizeof(callarg)); 4430 SPARG(&callarg, tv) = tv; 4431 SPARG(&callarg, tzp) = tzp; 4432 4433 error = rsys_syscall(SYS___settimeofday50, &callarg, sizeof(callarg), retval); 4434 rsys_seterrno(error); 4435 if (error == 0) { 4436 if (sizeof(int) > sizeof(register_t)) 4437 rv = *(int *)retval; 4438 else 4439 rv = *retval; 4440 } 4441 return rv; 4442 } 4443 rsys_define(rumpns_sys___settimeofday50); 4444 rsys_aliases(__settimeofday50,rump___sysimpl_settimeofday50); 4445 4446 int rump___sysimpl_utimes50(const char *, const struct timeval *); 4447 int 4448 rump___sysimpl_utimes50(const char * path, const struct timeval * tptr) 4449 { 4450 register_t retval[2]; 4451 int error = 0; 4452 int rv = -1; 4453 struct sys___utimes50_args callarg; 4454 4455 memset(&callarg, 0, sizeof(callarg)); 4456 SPARG(&callarg, path) = path; 4457 SPARG(&callarg, tptr) = tptr; 4458 4459 error = rsys_syscall(SYS___utimes50, &callarg, sizeof(callarg), retval); 4460 rsys_seterrno(error); 4461 if (error == 0) { 4462 if (sizeof(int) > sizeof(register_t)) 4463 rv = *(int *)retval; 4464 else 4465 rv = *retval; 4466 } 4467 return rv; 4468 } 4469 rsys_define(rumpns_sys___utimes50); 4470 rsys_aliases(__utimes50,rump___sysimpl_utimes50); 4471 4472 int rump___sysimpl_adjtime50(const struct timeval *, struct timeval *); 4473 int 4474 rump___sysimpl_adjtime50(const struct timeval * delta, struct timeval * olddelta) 4475 { 4476 register_t retval[2]; 4477 int error = 0; 4478 int rv = -1; 4479 struct sys___adjtime50_args callarg; 4480 4481 memset(&callarg, 0, sizeof(callarg)); 4482 SPARG(&callarg, delta) = delta; 4483 SPARG(&callarg, olddelta) = olddelta; 4484 4485 error = rsys_syscall(SYS___adjtime50, &callarg, sizeof(callarg), retval); 4486 rsys_seterrno(error); 4487 if (error == 0) { 4488 if (sizeof(int) > sizeof(register_t)) 4489 rv = *(int *)retval; 4490 else 4491 rv = *retval; 4492 } 4493 return rv; 4494 } 4495 rsys_define(rumpns_sys___adjtime50); 4496 rsys_aliases(__adjtime50,rump___sysimpl_adjtime50); 4497 4498 int rump___sysimpl_futimes50(int, const struct timeval *); 4499 int 4500 rump___sysimpl_futimes50(int fd, const struct timeval * tptr) 4501 { 4502 register_t retval[2]; 4503 int error = 0; 4504 int rv = -1; 4505 struct sys___futimes50_args callarg; 4506 4507 memset(&callarg, 0, sizeof(callarg)); 4508 SPARG(&callarg, fd) = fd; 4509 SPARG(&callarg, tptr) = tptr; 4510 4511 error = rsys_syscall(SYS___futimes50, &callarg, sizeof(callarg), retval); 4512 rsys_seterrno(error); 4513 if (error == 0) { 4514 if (sizeof(int) > sizeof(register_t)) 4515 rv = *(int *)retval; 4516 else 4517 rv = *retval; 4518 } 4519 return rv; 4520 } 4521 rsys_define(rumpns_sys___futimes50); 4522 rsys_aliases(__futimes50,rump___sysimpl_futimes50); 4523 4524 int rump___sysimpl_lutimes50(const char *, const struct timeval *); 4525 int 4526 rump___sysimpl_lutimes50(const char * path, const struct timeval * tptr) 4527 { 4528 register_t retval[2]; 4529 int error = 0; 4530 int rv = -1; 4531 struct sys___lutimes50_args callarg; 4532 4533 memset(&callarg, 0, sizeof(callarg)); 4534 SPARG(&callarg, path) = path; 4535 SPARG(&callarg, tptr) = tptr; 4536 4537 error = rsys_syscall(SYS___lutimes50, &callarg, sizeof(callarg), retval); 4538 rsys_seterrno(error); 4539 if (error == 0) { 4540 if (sizeof(int) > sizeof(register_t)) 4541 rv = *(int *)retval; 4542 else 4543 rv = *retval; 4544 } 4545 return rv; 4546 } 4547 rsys_define(rumpns_sys___lutimes50); 4548 rsys_aliases(__lutimes50,rump___sysimpl_lutimes50); 4549 4550 int rump___sysimpl_setitimer50(int, const struct itimerval *, struct itimerval *); 4551 int 4552 rump___sysimpl_setitimer50(int which, const struct itimerval * itv, struct itimerval * oitv) 4553 { 4554 register_t retval[2]; 4555 int error = 0; 4556 int rv = -1; 4557 struct sys___setitimer50_args callarg; 4558 4559 memset(&callarg, 0, sizeof(callarg)); 4560 SPARG(&callarg, which) = which; 4561 SPARG(&callarg, itv) = itv; 4562 SPARG(&callarg, oitv) = oitv; 4563 4564 error = rsys_syscall(SYS___setitimer50, &callarg, sizeof(callarg), retval); 4565 rsys_seterrno(error); 4566 if (error == 0) { 4567 if (sizeof(int) > sizeof(register_t)) 4568 rv = *(int *)retval; 4569 else 4570 rv = *retval; 4571 } 4572 return rv; 4573 } 4574 rsys_define(rumpns_sys___setitimer50); 4575 rsys_aliases(__setitimer50,rump___sysimpl_setitimer50); 4576 4577 int rump___sysimpl_getitimer50(int, struct itimerval *); 4578 int 4579 rump___sysimpl_getitimer50(int which, struct itimerval * itv) 4580 { 4581 register_t retval[2]; 4582 int error = 0; 4583 int rv = -1; 4584 struct sys___getitimer50_args callarg; 4585 4586 memset(&callarg, 0, sizeof(callarg)); 4587 SPARG(&callarg, which) = which; 4588 SPARG(&callarg, itv) = itv; 4589 4590 error = rsys_syscall(SYS___getitimer50, &callarg, sizeof(callarg), retval); 4591 rsys_seterrno(error); 4592 if (error == 0) { 4593 if (sizeof(int) > sizeof(register_t)) 4594 rv = *(int *)retval; 4595 else 4596 rv = *retval; 4597 } 4598 return rv; 4599 } 4600 rsys_define(rumpns_sys___getitimer50); 4601 rsys_aliases(__getitimer50,rump___sysimpl_getitimer50); 4602 4603 int rump___sysimpl_clock_gettime50(clockid_t, struct timespec *); 4604 int 4605 rump___sysimpl_clock_gettime50(clockid_t clock_id, struct timespec * tp) 4606 { 4607 register_t retval[2]; 4608 int error = 0; 4609 int rv = -1; 4610 struct sys___clock_gettime50_args callarg; 4611 4612 memset(&callarg, 0, sizeof(callarg)); 4613 SPARG(&callarg, clock_id) = clock_id; 4614 SPARG(&callarg, tp) = tp; 4615 4616 error = rsys_syscall(SYS___clock_gettime50, &callarg, sizeof(callarg), retval); 4617 rsys_seterrno(error); 4618 if (error == 0) { 4619 if (sizeof(int) > sizeof(register_t)) 4620 rv = *(int *)retval; 4621 else 4622 rv = *retval; 4623 } 4624 return rv; 4625 } 4626 rsys_define(rumpns_sys___clock_gettime50); 4627 rsys_aliases(__clock_gettime50,rump___sysimpl_clock_gettime50); 4628 4629 int rump___sysimpl_clock_settime50(clockid_t, const struct timespec *); 4630 int 4631 rump___sysimpl_clock_settime50(clockid_t clock_id, const struct timespec * tp) 4632 { 4633 register_t retval[2]; 4634 int error = 0; 4635 int rv = -1; 4636 struct sys___clock_settime50_args callarg; 4637 4638 memset(&callarg, 0, sizeof(callarg)); 4639 SPARG(&callarg, clock_id) = clock_id; 4640 SPARG(&callarg, tp) = tp; 4641 4642 error = rsys_syscall(SYS___clock_settime50, &callarg, sizeof(callarg), retval); 4643 rsys_seterrno(error); 4644 if (error == 0) { 4645 if (sizeof(int) > sizeof(register_t)) 4646 rv = *(int *)retval; 4647 else 4648 rv = *retval; 4649 } 4650 return rv; 4651 } 4652 rsys_define(rumpns_sys___clock_settime50); 4653 rsys_aliases(__clock_settime50,rump___sysimpl_clock_settime50); 4654 4655 int rump___sysimpl_clock_getres50(clockid_t, struct timespec *); 4656 int 4657 rump___sysimpl_clock_getres50(clockid_t clock_id, struct timespec * tp) 4658 { 4659 register_t retval[2]; 4660 int error = 0; 4661 int rv = -1; 4662 struct sys___clock_getres50_args callarg; 4663 4664 memset(&callarg, 0, sizeof(callarg)); 4665 SPARG(&callarg, clock_id) = clock_id; 4666 SPARG(&callarg, tp) = tp; 4667 4668 error = rsys_syscall(SYS___clock_getres50, &callarg, sizeof(callarg), retval); 4669 rsys_seterrno(error); 4670 if (error == 0) { 4671 if (sizeof(int) > sizeof(register_t)) 4672 rv = *(int *)retval; 4673 else 4674 rv = *retval; 4675 } 4676 return rv; 4677 } 4678 rsys_define(rumpns_sys___clock_getres50); 4679 rsys_aliases(__clock_getres50,rump___sysimpl_clock_getres50); 4680 4681 int rump___sysimpl_nanosleep50(const struct timespec *, struct timespec *); 4682 int 4683 rump___sysimpl_nanosleep50(const struct timespec * rqtp, struct timespec * rmtp) 4684 { 4685 register_t retval[2]; 4686 int error = 0; 4687 int rv = -1; 4688 struct sys___nanosleep50_args callarg; 4689 4690 memset(&callarg, 0, sizeof(callarg)); 4691 SPARG(&callarg, rqtp) = rqtp; 4692 SPARG(&callarg, rmtp) = rmtp; 4693 4694 error = rsys_syscall(SYS___nanosleep50, &callarg, sizeof(callarg), retval); 4695 rsys_seterrno(error); 4696 if (error == 0) { 4697 if (sizeof(int) > sizeof(register_t)) 4698 rv = *(int *)retval; 4699 else 4700 rv = *retval; 4701 } 4702 return rv; 4703 } 4704 rsys_define(rumpns_sys___nanosleep50); 4705 rsys_aliases(__nanosleep50,rump___sysimpl_nanosleep50); 4706 4707 int rump___sysimpl_kevent50(int, const struct kevent *, size_t, struct kevent *, size_t, const struct timespec *); 4708 int 4709 rump___sysimpl_kevent50(int fd, const struct kevent * changelist, size_t nchanges, struct kevent * eventlist, size_t nevents, const struct timespec * timeout) 4710 { 4711 register_t retval[2]; 4712 int error = 0; 4713 int rv = -1; 4714 struct sys___kevent50_args callarg; 4715 4716 memset(&callarg, 0, sizeof(callarg)); 4717 SPARG(&callarg, fd) = fd; 4718 SPARG(&callarg, changelist) = changelist; 4719 SPARG(&callarg, nchanges) = nchanges; 4720 SPARG(&callarg, eventlist) = eventlist; 4721 SPARG(&callarg, nevents) = nevents; 4722 SPARG(&callarg, timeout) = timeout; 4723 4724 error = rsys_syscall(SYS___kevent50, &callarg, sizeof(callarg), retval); 4725 rsys_seterrno(error); 4726 if (error == 0) { 4727 if (sizeof(int) > sizeof(register_t)) 4728 rv = *(int *)retval; 4729 else 4730 rv = *retval; 4731 } 4732 return rv; 4733 } 4734 rsys_define(rumpns_sys___kevent50); 4735 rsys_aliases(__kevent50,rump___sysimpl_kevent50); 4736 4737 int rump___sysimpl_pselect50(int, fd_set *, fd_set *, fd_set *, const struct timespec *, const sigset_t *); 4738 int 4739 rump___sysimpl_pselect50(int nd, fd_set * in, fd_set * ou, fd_set * ex, const struct timespec * ts, const sigset_t * mask) 4740 { 4741 register_t retval[2]; 4742 int error = 0; 4743 int rv = -1; 4744 struct sys___pselect50_args callarg; 4745 4746 memset(&callarg, 0, sizeof(callarg)); 4747 SPARG(&callarg, nd) = nd; 4748 SPARG(&callarg, in) = in; 4749 SPARG(&callarg, ou) = ou; 4750 SPARG(&callarg, ex) = ex; 4751 SPARG(&callarg, ts) = ts; 4752 SPARG(&callarg, mask) = mask; 4753 4754 error = rsys_syscall(SYS___pselect50, &callarg, sizeof(callarg), retval); 4755 rsys_seterrno(error); 4756 if (error == 0) { 4757 if (sizeof(int) > sizeof(register_t)) 4758 rv = *(int *)retval; 4759 else 4760 rv = *retval; 4761 } 4762 return rv; 4763 } 4764 rsys_define(rumpns_sys___pselect50); 4765 rsys_aliases(__pselect50,rump___sysimpl_pselect50); 4766 4767 int rump___sysimpl_pollts50(struct pollfd *, u_int, const struct timespec *, const sigset_t *); 4768 int 4769 rump___sysimpl_pollts50(struct pollfd * fds, u_int nfds, const struct timespec * ts, const sigset_t * mask) 4770 { 4771 register_t retval[2]; 4772 int error = 0; 4773 int rv = -1; 4774 struct sys___pollts50_args callarg; 4775 4776 memset(&callarg, 0, sizeof(callarg)); 4777 SPARG(&callarg, fds) = fds; 4778 SPARG(&callarg, nfds) = nfds; 4779 SPARG(&callarg, ts) = ts; 4780 SPARG(&callarg, mask) = mask; 4781 4782 error = rsys_syscall(SYS___pollts50, &callarg, sizeof(callarg), retval); 4783 rsys_seterrno(error); 4784 if (error == 0) { 4785 if (sizeof(int) > sizeof(register_t)) 4786 rv = *(int *)retval; 4787 else 4788 rv = *retval; 4789 } 4790 return rv; 4791 } 4792 rsys_define(rumpns_sys___pollts50); 4793 rsys_aliases(__pollts50,rump___sysimpl_pollts50); 4794 4795 int rump___sysimpl_aio_suspend50(const struct aiocb *const *, int, const struct timespec *); 4796 int 4797 rump___sysimpl_aio_suspend50(const struct aiocb *const * list, int nent, const struct timespec * timeout) 4798 { 4799 register_t retval[2]; 4800 int error = 0; 4801 int rv = -1; 4802 struct sys___aio_suspend50_args callarg; 4803 4804 memset(&callarg, 0, sizeof(callarg)); 4805 SPARG(&callarg, list) = list; 4806 SPARG(&callarg, nent) = nent; 4807 SPARG(&callarg, timeout) = timeout; 4808 4809 error = rsys_syscall(SYS___aio_suspend50, &callarg, sizeof(callarg), retval); 4810 rsys_seterrno(error); 4811 if (error == 0) { 4812 if (sizeof(int) > sizeof(register_t)) 4813 rv = *(int *)retval; 4814 else 4815 rv = *retval; 4816 } 4817 return rv; 4818 } 4819 rsys_define(rumpns_sys___aio_suspend50); 4820 rsys_aliases(__aio_suspend50,rump___sysimpl_aio_suspend50); 4821 4822 int rump___sysimpl_stat50(const char *, struct stat *); 4823 int 4824 rump___sysimpl_stat50(const char * path, struct stat * ub) 4825 { 4826 register_t retval[2]; 4827 int error = 0; 4828 int rv = -1; 4829 struct sys___stat50_args callarg; 4830 4831 memset(&callarg, 0, sizeof(callarg)); 4832 SPARG(&callarg, path) = path; 4833 SPARG(&callarg, ub) = ub; 4834 4835 error = rsys_syscall(SYS___stat50, &callarg, sizeof(callarg), retval); 4836 rsys_seterrno(error); 4837 if (error == 0) { 4838 if (sizeof(int) > sizeof(register_t)) 4839 rv = *(int *)retval; 4840 else 4841 rv = *retval; 4842 } 4843 return rv; 4844 } 4845 rsys_define(rumpns_sys___stat50); 4846 rsys_aliases(__stat50,rump___sysimpl_stat50); 4847 4848 int rump___sysimpl_fstat50(int, struct stat *); 4849 int 4850 rump___sysimpl_fstat50(int fd, struct stat * sb) 4851 { 4852 register_t retval[2]; 4853 int error = 0; 4854 int rv = -1; 4855 struct sys___fstat50_args callarg; 4856 4857 memset(&callarg, 0, sizeof(callarg)); 4858 SPARG(&callarg, fd) = fd; 4859 SPARG(&callarg, sb) = sb; 4860 4861 error = rsys_syscall(SYS___fstat50, &callarg, sizeof(callarg), retval); 4862 rsys_seterrno(error); 4863 if (error == 0) { 4864 if (sizeof(int) > sizeof(register_t)) 4865 rv = *(int *)retval; 4866 else 4867 rv = *retval; 4868 } 4869 return rv; 4870 } 4871 rsys_define(rumpns_sys___fstat50); 4872 rsys_aliases(__fstat50,rump___sysimpl_fstat50); 4873 4874 int rump___sysimpl_lstat50(const char *, struct stat *); 4875 int 4876 rump___sysimpl_lstat50(const char * path, struct stat * ub) 4877 { 4878 register_t retval[2]; 4879 int error = 0; 4880 int rv = -1; 4881 struct sys___lstat50_args callarg; 4882 4883 memset(&callarg, 0, sizeof(callarg)); 4884 SPARG(&callarg, path) = path; 4885 SPARG(&callarg, ub) = ub; 4886 4887 error = rsys_syscall(SYS___lstat50, &callarg, sizeof(callarg), retval); 4888 rsys_seterrno(error); 4889 if (error == 0) { 4890 if (sizeof(int) > sizeof(register_t)) 4891 rv = *(int *)retval; 4892 else 4893 rv = *retval; 4894 } 4895 return rv; 4896 } 4897 rsys_define(rumpns_sys___lstat50); 4898 rsys_aliases(__lstat50,rump___sysimpl_lstat50); 4899 4900 int rump___sysimpl_timer_settime50(timer_t, int, const struct itimerspec *, struct itimerspec *); 4901 int 4902 rump___sysimpl_timer_settime50(timer_t timerid, int flags, const struct itimerspec * value, struct itimerspec * ovalue) 4903 { 4904 register_t retval[2]; 4905 int error = 0; 4906 int rv = -1; 4907 struct sys___timer_settime50_args callarg; 4908 4909 memset(&callarg, 0, sizeof(callarg)); 4910 SPARG(&callarg, timerid) = timerid; 4911 SPARG(&callarg, flags) = flags; 4912 SPARG(&callarg, value) = value; 4913 SPARG(&callarg, ovalue) = ovalue; 4914 4915 error = rsys_syscall(SYS___timer_settime50, &callarg, sizeof(callarg), retval); 4916 rsys_seterrno(error); 4917 if (error == 0) { 4918 if (sizeof(int) > sizeof(register_t)) 4919 rv = *(int *)retval; 4920 else 4921 rv = *retval; 4922 } 4923 return rv; 4924 } 4925 rsys_define(rumpns_sys___timer_settime50); 4926 rsys_aliases(__timer_settime50,rump___sysimpl_timer_settime50); 4927 4928 int rump___sysimpl_timer_gettime50(timer_t, struct itimerspec *); 4929 int 4930 rump___sysimpl_timer_gettime50(timer_t timerid, struct itimerspec * value) 4931 { 4932 register_t retval[2]; 4933 int error = 0; 4934 int rv = -1; 4935 struct sys___timer_gettime50_args callarg; 4936 4937 memset(&callarg, 0, sizeof(callarg)); 4938 SPARG(&callarg, timerid) = timerid; 4939 SPARG(&callarg, value) = value; 4940 4941 error = rsys_syscall(SYS___timer_gettime50, &callarg, sizeof(callarg), retval); 4942 rsys_seterrno(error); 4943 if (error == 0) { 4944 if (sizeof(int) > sizeof(register_t)) 4945 rv = *(int *)retval; 4946 else 4947 rv = *retval; 4948 } 4949 return rv; 4950 } 4951 rsys_define(rumpns_sys___timer_gettime50); 4952 rsys_aliases(__timer_gettime50,rump___sysimpl_timer_gettime50); 4953 4954 int rump___sysimpl_mknod50(const char *, mode_t, dev_t); 4955 int 4956 rump___sysimpl_mknod50(const char * path, mode_t mode, dev_t dev) 4957 { 4958 register_t retval[2]; 4959 int error = 0; 4960 int rv = -1; 4961 struct sys___mknod50_args callarg; 4962 4963 memset(&callarg, 0, sizeof(callarg)); 4964 SPARG(&callarg, path) = path; 4965 SPARG(&callarg, mode) = mode; 4966 SPARG(&callarg, dev) = dev; 4967 4968 error = rsys_syscall(SYS___mknod50, &callarg, sizeof(callarg), retval); 4969 rsys_seterrno(error); 4970 if (error == 0) { 4971 if (sizeof(int) > sizeof(register_t)) 4972 rv = *(int *)retval; 4973 else 4974 rv = *retval; 4975 } 4976 return rv; 4977 } 4978 rsys_define(rumpns_sys___mknod50); 4979 rsys_aliases(__mknod50,rump___sysimpl_mknod50); 4980 4981 int rump___sysimpl_fhstat50(const void *, size_t, struct stat *); 4982 int 4983 rump___sysimpl_fhstat50(const void * fhp, size_t fh_size, struct stat * sb) 4984 { 4985 register_t retval[2]; 4986 int error = 0; 4987 int rv = -1; 4988 struct sys___fhstat50_args callarg; 4989 4990 memset(&callarg, 0, sizeof(callarg)); 4991 SPARG(&callarg, fhp) = fhp; 4992 SPARG(&callarg, fh_size) = fh_size; 4993 SPARG(&callarg, sb) = sb; 4994 4995 error = rsys_syscall(SYS___fhstat50, &callarg, sizeof(callarg), retval); 4996 rsys_seterrno(error); 4997 if (error == 0) { 4998 if (sizeof(int) > sizeof(register_t)) 4999 rv = *(int *)retval; 5000 else 5001 rv = *retval; 5002 } 5003 return rv; 5004 } 5005 rsys_define(rumpns_sys___fhstat50); 5006 rsys_aliases(__fhstat50,rump___sysimpl_fhstat50); 5007 5008 int rump___sysimpl_pipe2(int *, int); 5009 int 5010 rump___sysimpl_pipe2(int * fildes, int flags) 5011 { 5012 register_t retval[2]; 5013 int error = 0; 5014 int rv = -1; 5015 struct sys_pipe2_args callarg; 5016 5017 memset(&callarg, 0, sizeof(callarg)); 5018 SPARG(&callarg, fildes) = fildes; 5019 SPARG(&callarg, flags) = flags; 5020 5021 error = rsys_syscall(SYS_pipe2, &callarg, sizeof(callarg), retval); 5022 rsys_seterrno(error); 5023 if (error == 0) { 5024 if (sizeof(int) > sizeof(register_t)) 5025 rv = *(int *)retval; 5026 else 5027 rv = *retval; 5028 } 5029 return rv; 5030 } 5031 rsys_define(rumpns_sys_pipe2); 5032 rsys_aliases(pipe2,rump___sysimpl_pipe2); 5033 5034 int rump___sysimpl_dup3(int, int, int); 5035 int 5036 rump___sysimpl_dup3(int from, int to, int flags) 5037 { 5038 register_t retval[2]; 5039 int error = 0; 5040 int rv = -1; 5041 struct sys_dup3_args callarg; 5042 5043 memset(&callarg, 0, sizeof(callarg)); 5044 SPARG(&callarg, from) = from; 5045 SPARG(&callarg, to) = to; 5046 SPARG(&callarg, flags) = flags; 5047 5048 error = rsys_syscall(SYS_dup3, &callarg, sizeof(callarg), retval); 5049 rsys_seterrno(error); 5050 if (error == 0) { 5051 if (sizeof(int) > sizeof(register_t)) 5052 rv = *(int *)retval; 5053 else 5054 rv = *retval; 5055 } 5056 return rv; 5057 } 5058 rsys_define(rumpns_sys_dup3); 5059 rsys_aliases(dup3,rump___sysimpl_dup3); 5060 5061 int rump___sysimpl_kqueue1(int); 5062 int 5063 rump___sysimpl_kqueue1(int flags) 5064 { 5065 register_t retval[2]; 5066 int error = 0; 5067 int rv = -1; 5068 struct sys_kqueue1_args callarg; 5069 5070 memset(&callarg, 0, sizeof(callarg)); 5071 SPARG(&callarg, flags) = flags; 5072 5073 error = rsys_syscall(SYS_kqueue1, &callarg, sizeof(callarg), retval); 5074 rsys_seterrno(error); 5075 if (error == 0) { 5076 if (sizeof(int) > sizeof(register_t)) 5077 rv = *(int *)retval; 5078 else 5079 rv = *retval; 5080 } 5081 return rv; 5082 } 5083 rsys_define(rumpns_sys_kqueue1); 5084 rsys_aliases(kqueue1,rump___sysimpl_kqueue1); 5085 5086 int rump___sysimpl_paccept(int, struct sockaddr *, socklen_t *, const sigset_t *, int); 5087 int 5088 rump___sysimpl_paccept(int s, struct sockaddr * name, socklen_t * anamelen, const sigset_t * mask, int flags) 5089 { 5090 register_t retval[2]; 5091 int error = 0; 5092 int rv = -1; 5093 struct sys_paccept_args callarg; 5094 5095 memset(&callarg, 0, sizeof(callarg)); 5096 SPARG(&callarg, s) = s; 5097 SPARG(&callarg, name) = name; 5098 SPARG(&callarg, anamelen) = anamelen; 5099 SPARG(&callarg, mask) = mask; 5100 SPARG(&callarg, flags) = flags; 5101 5102 error = rsys_syscall(SYS_paccept, &callarg, sizeof(callarg), retval); 5103 rsys_seterrno(error); 5104 if (error == 0) { 5105 if (sizeof(int) > sizeof(register_t)) 5106 rv = *(int *)retval; 5107 else 5108 rv = *retval; 5109 } 5110 return rv; 5111 } 5112 rsys_define(rumpns_sys_paccept); 5113 rsys_aliases(paccept,rump___sysimpl_paccept); 5114 5115 int rump___sysimpl_linkat(int, const char *, int, const char *, int); 5116 int 5117 rump___sysimpl_linkat(int fd1, const char * name1, int fd2, const char * name2, int flags) 5118 { 5119 register_t retval[2]; 5120 int error = 0; 5121 int rv = -1; 5122 struct sys_linkat_args callarg; 5123 5124 memset(&callarg, 0, sizeof(callarg)); 5125 SPARG(&callarg, fd1) = fd1; 5126 SPARG(&callarg, name1) = name1; 5127 SPARG(&callarg, fd2) = fd2; 5128 SPARG(&callarg, name2) = name2; 5129 SPARG(&callarg, flags) = flags; 5130 5131 error = rsys_syscall(SYS_linkat, &callarg, sizeof(callarg), retval); 5132 rsys_seterrno(error); 5133 if (error == 0) { 5134 if (sizeof(int) > sizeof(register_t)) 5135 rv = *(int *)retval; 5136 else 5137 rv = *retval; 5138 } 5139 return rv; 5140 } 5141 rsys_define(rumpns_sys_linkat); 5142 rsys_aliases(linkat,rump___sysimpl_linkat); 5143 5144 int rump___sysimpl_renameat(int, const char *, int, const char *); 5145 int 5146 rump___sysimpl_renameat(int fromfd, const char * from, int tofd, const char * to) 5147 { 5148 register_t retval[2]; 5149 int error = 0; 5150 int rv = -1; 5151 struct sys_renameat_args callarg; 5152 5153 memset(&callarg, 0, sizeof(callarg)); 5154 SPARG(&callarg, fromfd) = fromfd; 5155 SPARG(&callarg, from) = from; 5156 SPARG(&callarg, tofd) = tofd; 5157 SPARG(&callarg, to) = to; 5158 5159 error = rsys_syscall(SYS_renameat, &callarg, sizeof(callarg), retval); 5160 rsys_seterrno(error); 5161 if (error == 0) { 5162 if (sizeof(int) > sizeof(register_t)) 5163 rv = *(int *)retval; 5164 else 5165 rv = *retval; 5166 } 5167 return rv; 5168 } 5169 rsys_define(rumpns_sys_renameat); 5170 rsys_aliases(renameat,rump___sysimpl_renameat); 5171 5172 int rump___sysimpl_mkfifoat(int, const char *, mode_t); 5173 int 5174 rump___sysimpl_mkfifoat(int fd, const char * path, mode_t mode) 5175 { 5176 register_t retval[2]; 5177 int error = 0; 5178 int rv = -1; 5179 struct sys_mkfifoat_args callarg; 5180 5181 memset(&callarg, 0, sizeof(callarg)); 5182 SPARG(&callarg, fd) = fd; 5183 SPARG(&callarg, path) = path; 5184 SPARG(&callarg, mode) = mode; 5185 5186 error = rsys_syscall(SYS_mkfifoat, &callarg, sizeof(callarg), retval); 5187 rsys_seterrno(error); 5188 if (error == 0) { 5189 if (sizeof(int) > sizeof(register_t)) 5190 rv = *(int *)retval; 5191 else 5192 rv = *retval; 5193 } 5194 return rv; 5195 } 5196 rsys_define(rumpns_sys_mkfifoat); 5197 rsys_aliases(mkfifoat,rump___sysimpl_mkfifoat); 5198 5199 int rump___sysimpl_mknodat(int, const char *, mode_t, dev_t); 5200 int 5201 rump___sysimpl_mknodat(int fd, const char * path, mode_t mode, dev_t dev) 5202 { 5203 register_t retval[2]; 5204 int error = 0; 5205 int rv = -1; 5206 struct sys_mknodat_args callarg; 5207 5208 memset(&callarg, 0, sizeof(callarg)); 5209 SPARG(&callarg, fd) = fd; 5210 SPARG(&callarg, path) = path; 5211 SPARG(&callarg, mode) = mode; 5212 SPARG(&callarg, PAD) = 0; 5213 SPARG(&callarg, dev) = dev; 5214 5215 error = rsys_syscall(SYS_mknodat, &callarg, sizeof(callarg), retval); 5216 rsys_seterrno(error); 5217 if (error == 0) { 5218 if (sizeof(int) > sizeof(register_t)) 5219 rv = *(int *)retval; 5220 else 5221 rv = *retval; 5222 } 5223 return rv; 5224 } 5225 rsys_define(rumpns_sys_mknodat); 5226 rsys_aliases(mknodat,rump___sysimpl_mknodat); 5227 5228 int rump___sysimpl_mkdirat(int, const char *, mode_t); 5229 int 5230 rump___sysimpl_mkdirat(int fd, const char * path, mode_t mode) 5231 { 5232 register_t retval[2]; 5233 int error = 0; 5234 int rv = -1; 5235 struct sys_mkdirat_args callarg; 5236 5237 memset(&callarg, 0, sizeof(callarg)); 5238 SPARG(&callarg, fd) = fd; 5239 SPARG(&callarg, path) = path; 5240 SPARG(&callarg, mode) = mode; 5241 5242 error = rsys_syscall(SYS_mkdirat, &callarg, sizeof(callarg), retval); 5243 rsys_seterrno(error); 5244 if (error == 0) { 5245 if (sizeof(int) > sizeof(register_t)) 5246 rv = *(int *)retval; 5247 else 5248 rv = *retval; 5249 } 5250 return rv; 5251 } 5252 rsys_define(rumpns_sys_mkdirat); 5253 rsys_aliases(mkdirat,rump___sysimpl_mkdirat); 5254 5255 int rump___sysimpl_faccessat(int, const char *, int, int); 5256 int 5257 rump___sysimpl_faccessat(int fd, const char * path, int amode, int flag) 5258 { 5259 register_t retval[2]; 5260 int error = 0; 5261 int rv = -1; 5262 struct sys_faccessat_args callarg; 5263 5264 memset(&callarg, 0, sizeof(callarg)); 5265 SPARG(&callarg, fd) = fd; 5266 SPARG(&callarg, path) = path; 5267 SPARG(&callarg, amode) = amode; 5268 SPARG(&callarg, flag) = flag; 5269 5270 error = rsys_syscall(SYS_faccessat, &callarg, sizeof(callarg), retval); 5271 rsys_seterrno(error); 5272 if (error == 0) { 5273 if (sizeof(int) > sizeof(register_t)) 5274 rv = *(int *)retval; 5275 else 5276 rv = *retval; 5277 } 5278 return rv; 5279 } 5280 rsys_define(rumpns_sys_faccessat); 5281 rsys_aliases(faccessat,rump___sysimpl_faccessat); 5282 5283 int rump___sysimpl_fchmodat(int, const char *, mode_t, int); 5284 int 5285 rump___sysimpl_fchmodat(int fd, const char * path, mode_t mode, int flag) 5286 { 5287 register_t retval[2]; 5288 int error = 0; 5289 int rv = -1; 5290 struct sys_fchmodat_args callarg; 5291 5292 memset(&callarg, 0, sizeof(callarg)); 5293 SPARG(&callarg, fd) = fd; 5294 SPARG(&callarg, path) = path; 5295 SPARG(&callarg, mode) = mode; 5296 SPARG(&callarg, flag) = flag; 5297 5298 error = rsys_syscall(SYS_fchmodat, &callarg, sizeof(callarg), retval); 5299 rsys_seterrno(error); 5300 if (error == 0) { 5301 if (sizeof(int) > sizeof(register_t)) 5302 rv = *(int *)retval; 5303 else 5304 rv = *retval; 5305 } 5306 return rv; 5307 } 5308 rsys_define(rumpns_sys_fchmodat); 5309 rsys_aliases(fchmodat,rump___sysimpl_fchmodat); 5310 5311 int rump___sysimpl_fchownat(int, const char *, uid_t, gid_t, int); 5312 int 5313 rump___sysimpl_fchownat(int fd, const char * path, uid_t owner, gid_t group, int flag) 5314 { 5315 register_t retval[2]; 5316 int error = 0; 5317 int rv = -1; 5318 struct sys_fchownat_args callarg; 5319 5320 memset(&callarg, 0, sizeof(callarg)); 5321 SPARG(&callarg, fd) = fd; 5322 SPARG(&callarg, path) = path; 5323 SPARG(&callarg, owner) = owner; 5324 SPARG(&callarg, group) = group; 5325 SPARG(&callarg, flag) = flag; 5326 5327 error = rsys_syscall(SYS_fchownat, &callarg, sizeof(callarg), retval); 5328 rsys_seterrno(error); 5329 if (error == 0) { 5330 if (sizeof(int) > sizeof(register_t)) 5331 rv = *(int *)retval; 5332 else 5333 rv = *retval; 5334 } 5335 return rv; 5336 } 5337 rsys_define(rumpns_sys_fchownat); 5338 rsys_aliases(fchownat,rump___sysimpl_fchownat); 5339 5340 int rump___sysimpl_fstatat(int, const char *, struct stat *, int); 5341 int 5342 rump___sysimpl_fstatat(int fd, const char * path, struct stat * buf, int flag) 5343 { 5344 register_t retval[2]; 5345 int error = 0; 5346 int rv = -1; 5347 struct sys_fstatat_args callarg; 5348 5349 memset(&callarg, 0, sizeof(callarg)); 5350 SPARG(&callarg, fd) = fd; 5351 SPARG(&callarg, path) = path; 5352 SPARG(&callarg, buf) = buf; 5353 SPARG(&callarg, flag) = flag; 5354 5355 error = rsys_syscall(SYS_fstatat, &callarg, sizeof(callarg), retval); 5356 rsys_seterrno(error); 5357 if (error == 0) { 5358 if (sizeof(int) > sizeof(register_t)) 5359 rv = *(int *)retval; 5360 else 5361 rv = *retval; 5362 } 5363 return rv; 5364 } 5365 rsys_define(rumpns_sys_fstatat); 5366 rsys_aliases(fstatat,rump___sysimpl_fstatat); 5367 5368 int rump___sysimpl_utimensat(int, const char *, const struct timespec *, int); 5369 int 5370 rump___sysimpl_utimensat(int fd, const char * path, const struct timespec * tptr, int flag) 5371 { 5372 register_t retval[2]; 5373 int error = 0; 5374 int rv = -1; 5375 struct sys_utimensat_args callarg; 5376 5377 memset(&callarg, 0, sizeof(callarg)); 5378 SPARG(&callarg, fd) = fd; 5379 SPARG(&callarg, path) = path; 5380 SPARG(&callarg, tptr) = tptr; 5381 SPARG(&callarg, flag) = flag; 5382 5383 error = rsys_syscall(SYS_utimensat, &callarg, sizeof(callarg), retval); 5384 rsys_seterrno(error); 5385 if (error == 0) { 5386 if (sizeof(int) > sizeof(register_t)) 5387 rv = *(int *)retval; 5388 else 5389 rv = *retval; 5390 } 5391 return rv; 5392 } 5393 rsys_define(rumpns_sys_utimensat); 5394 rsys_aliases(utimensat,rump___sysimpl_utimensat); 5395 5396 int rump___sysimpl_openat(int, const char *, int, mode_t); 5397 int 5398 rump___sysimpl_openat(int fd, const char * path, int oflags, mode_t mode) 5399 { 5400 register_t retval[2]; 5401 int error = 0; 5402 int rv = -1; 5403 struct sys_openat_args callarg; 5404 5405 memset(&callarg, 0, sizeof(callarg)); 5406 SPARG(&callarg, fd) = fd; 5407 SPARG(&callarg, path) = path; 5408 SPARG(&callarg, oflags) = oflags; 5409 SPARG(&callarg, mode) = mode; 5410 5411 error = rsys_syscall(SYS_openat, &callarg, sizeof(callarg), retval); 5412 rsys_seterrno(error); 5413 if (error == 0) { 5414 if (sizeof(int) > sizeof(register_t)) 5415 rv = *(int *)retval; 5416 else 5417 rv = *retval; 5418 } 5419 return rv; 5420 } 5421 rsys_define(rumpns_sys_openat); 5422 rsys_aliases(openat,rump___sysimpl_openat); 5423 5424 int rump___sysimpl_readlinkat(int, const char *, char *, size_t); 5425 int 5426 rump___sysimpl_readlinkat(int fd, const char * path, char * buf, size_t bufsize) 5427 { 5428 register_t retval[2]; 5429 int error = 0; 5430 int rv = -1; 5431 struct sys_readlinkat_args callarg; 5432 5433 memset(&callarg, 0, sizeof(callarg)); 5434 SPARG(&callarg, fd) = fd; 5435 SPARG(&callarg, path) = path; 5436 SPARG(&callarg, buf) = buf; 5437 SPARG(&callarg, bufsize) = bufsize; 5438 5439 error = rsys_syscall(SYS_readlinkat, &callarg, sizeof(callarg), retval); 5440 rsys_seterrno(error); 5441 if (error == 0) { 5442 if (sizeof(int) > sizeof(register_t)) 5443 rv = *(int *)retval; 5444 else 5445 rv = *retval; 5446 } 5447 return rv; 5448 } 5449 rsys_define(rumpns_sys_readlinkat); 5450 rsys_aliases(readlinkat,rump___sysimpl_readlinkat); 5451 5452 int rump___sysimpl_symlinkat(const char *, int, const char *); 5453 int 5454 rump___sysimpl_symlinkat(const char * path1, int fd, const char * path2) 5455 { 5456 register_t retval[2]; 5457 int error = 0; 5458 int rv = -1; 5459 struct sys_symlinkat_args callarg; 5460 5461 memset(&callarg, 0, sizeof(callarg)); 5462 SPARG(&callarg, path1) = path1; 5463 SPARG(&callarg, fd) = fd; 5464 SPARG(&callarg, path2) = path2; 5465 5466 error = rsys_syscall(SYS_symlinkat, &callarg, sizeof(callarg), retval); 5467 rsys_seterrno(error); 5468 if (error == 0) { 5469 if (sizeof(int) > sizeof(register_t)) 5470 rv = *(int *)retval; 5471 else 5472 rv = *retval; 5473 } 5474 return rv; 5475 } 5476 rsys_define(rumpns_sys_symlinkat); 5477 rsys_aliases(symlinkat,rump___sysimpl_symlinkat); 5478 5479 int rump___sysimpl_unlinkat(int, const char *, int); 5480 int 5481 rump___sysimpl_unlinkat(int fd, const char * path, int flag) 5482 { 5483 register_t retval[2]; 5484 int error = 0; 5485 int rv = -1; 5486 struct sys_unlinkat_args callarg; 5487 5488 memset(&callarg, 0, sizeof(callarg)); 5489 SPARG(&callarg, fd) = fd; 5490 SPARG(&callarg, path) = path; 5491 SPARG(&callarg, flag) = flag; 5492 5493 error = rsys_syscall(SYS_unlinkat, &callarg, sizeof(callarg), retval); 5494 rsys_seterrno(error); 5495 if (error == 0) { 5496 if (sizeof(int) > sizeof(register_t)) 5497 rv = *(int *)retval; 5498 else 5499 rv = *retval; 5500 } 5501 return rv; 5502 } 5503 rsys_define(rumpns_sys_unlinkat); 5504 rsys_aliases(unlinkat,rump___sysimpl_unlinkat); 5505 5506 int rump___sysimpl_futimens(int, const struct timespec *); 5507 int 5508 rump___sysimpl_futimens(int fd, const struct timespec * tptr) 5509 { 5510 register_t retval[2]; 5511 int error = 0; 5512 int rv = -1; 5513 struct sys_futimens_args callarg; 5514 5515 memset(&callarg, 0, sizeof(callarg)); 5516 SPARG(&callarg, fd) = fd; 5517 SPARG(&callarg, tptr) = tptr; 5518 5519 error = rsys_syscall(SYS_futimens, &callarg, sizeof(callarg), retval); 5520 rsys_seterrno(error); 5521 if (error == 0) { 5522 if (sizeof(int) > sizeof(register_t)) 5523 rv = *(int *)retval; 5524 else 5525 rv = *retval; 5526 } 5527 return rv; 5528 } 5529 rsys_define(rumpns_sys_futimens); 5530 rsys_aliases(futimens,rump___sysimpl_futimens); 5531 5532 int rump___sysimpl___quotactl(const char *, struct quotactl_args *); 5533 int 5534 rump___sysimpl___quotactl(const char * path, struct quotactl_args * args) 5535 { 5536 register_t retval[2]; 5537 int error = 0; 5538 int rv = -1; 5539 struct sys___quotactl_args callarg; 5540 5541 memset(&callarg, 0, sizeof(callarg)); 5542 SPARG(&callarg, path) = path; 5543 SPARG(&callarg, args) = args; 5544 5545 error = rsys_syscall(SYS___quotactl, &callarg, sizeof(callarg), retval); 5546 rsys_seterrno(error); 5547 if (error == 0) { 5548 if (sizeof(int) > sizeof(register_t)) 5549 rv = *(int *)retval; 5550 else 5551 rv = *retval; 5552 } 5553 return rv; 5554 } 5555 rsys_define(rumpns_sys___quotactl); 5556 rsys_aliases(__quotactl,rump___sysimpl___quotactl); 5557 5558 int rump___sysimpl_recvmmsg(int, struct mmsghdr *, unsigned int, unsigned int, struct timespec *); 5559 int 5560 rump___sysimpl_recvmmsg(int s, struct mmsghdr * mmsg, unsigned int vlen, unsigned int flags, struct timespec * timeout) 5561 { 5562 register_t retval[2]; 5563 int error = 0; 5564 int rv = -1; 5565 struct sys_recvmmsg_args callarg; 5566 5567 memset(&callarg, 0, sizeof(callarg)); 5568 SPARG(&callarg, s) = s; 5569 SPARG(&callarg, mmsg) = mmsg; 5570 SPARG(&callarg, vlen) = vlen; 5571 SPARG(&callarg, flags) = flags; 5572 SPARG(&callarg, timeout) = timeout; 5573 5574 error = rsys_syscall(SYS_recvmmsg, &callarg, sizeof(callarg), retval); 5575 rsys_seterrno(error); 5576 if (error == 0) { 5577 if (sizeof(int) > sizeof(register_t)) 5578 rv = *(int *)retval; 5579 else 5580 rv = *retval; 5581 } 5582 return rv; 5583 } 5584 rsys_define(rumpns_sys_recvmmsg); 5585 rsys_aliases(recvmmsg,rump___sysimpl_recvmmsg); 5586 5587 int rump___sysimpl_sendmmsg(int, struct mmsghdr *, unsigned int, unsigned int); 5588 int 5589 rump___sysimpl_sendmmsg(int s, struct mmsghdr * mmsg, unsigned int vlen, unsigned int flags) 5590 { 5591 register_t retval[2]; 5592 int error = 0; 5593 int rv = -1; 5594 struct sys_sendmmsg_args callarg; 5595 5596 memset(&callarg, 0, sizeof(callarg)); 5597 SPARG(&callarg, s) = s; 5598 SPARG(&callarg, mmsg) = mmsg; 5599 SPARG(&callarg, vlen) = vlen; 5600 SPARG(&callarg, flags) = flags; 5601 5602 error = rsys_syscall(SYS_sendmmsg, &callarg, sizeof(callarg), retval); 5603 rsys_seterrno(error); 5604 if (error == 0) { 5605 if (sizeof(int) > sizeof(register_t)) 5606 rv = *(int *)retval; 5607 else 5608 rv = *retval; 5609 } 5610 return rv; 5611 } 5612 rsys_define(rumpns_sys_sendmmsg); 5613 rsys_aliases(sendmmsg,rump___sysimpl_sendmmsg); 5614 5615 int rump___sysimpl_clock_nanosleep(clockid_t, int, const struct timespec *, struct timespec *); 5616 int 5617 rump___sysimpl_clock_nanosleep(clockid_t clock_id, int flags, const struct timespec * rqtp, struct timespec * rmtp) 5618 { 5619 register_t retval[2]; 5620 int error = 0; 5621 int rv = -1; 5622 struct sys_clock_nanosleep_args callarg; 5623 5624 memset(&callarg, 0, sizeof(callarg)); 5625 SPARG(&callarg, clock_id) = clock_id; 5626 SPARG(&callarg, flags) = flags; 5627 SPARG(&callarg, rqtp) = rqtp; 5628 SPARG(&callarg, rmtp) = rmtp; 5629 5630 error = rsys_syscall(SYS_clock_nanosleep, &callarg, sizeof(callarg), retval); 5631 rsys_seterrno(error); 5632 if (error == 0) { 5633 if (sizeof(int) > sizeof(register_t)) 5634 rv = *(int *)retval; 5635 else 5636 rv = *retval; 5637 } 5638 return rv; 5639 } 5640 rsys_define(rumpns_sys_clock_nanosleep); 5641 rsys_aliases(clock_nanosleep,rump___sysimpl_clock_nanosleep); 5642 5643 int rump_sys_pipe(int *); 5644 int 5645 rump_sys_pipe(int *fd) 5646 { 5647 register_t retval[2]; 5648 int error = 0; 5649 5650 error = rsys_syscall(SYS_pipe, NULL, 0, retval); 5651 if (error) { 5652 rsys_seterrno(error); 5653 } else { 5654 fd[0] = retval[0]; 5655 fd[1] = retval[1]; 5656 } 5657 return error ? -1 : 0; 5658 } 5659 rsys_define(rumpns_sys_pipe); 5660 rsys_aliases(pipe,rump_sys_pipe); 5661 5662 #ifndef RUMP_CLIENT 5663 #define s(type) sizeof(type) 5664 #define n(type) (sizeof(type)/sizeof (register_t)) 5665 #define ns(type) n(type), s(type) 5666 5667 struct sysent rump_sysent[] = { 5668 { 0, 0, SYCALL_NOSYS, 5669 (sy_call_t *)rump_enosys }, /* 0 = syscall */ 5670 { 0, 0, SYCALL_NOSYS, 5671 (sy_call_t *)rump_enosys }, /* 1 = exit */ 5672 { 0, 0, SYCALL_NOSYS, 5673 (sy_call_t *)rump_enosys }, /* 2 = fork */ 5674 { ns(struct sys_read_args), 0, 5675 (sy_call_t *)rumpns_sys_read }, /* 3 = read */ 5676 { ns(struct sys_write_args), 0, 5677 (sy_call_t *)rumpns_sys_write }, /* 4 = write */ 5678 { ns(struct sys_open_args), 0, 5679 (sy_call_t *)rumpns_sys_open }, /* 5 = open */ 5680 { ns(struct sys_close_args), 0, 5681 (sy_call_t *)rumpns_sys_close }, /* 6 = close */ 5682 { 0, 0, 0, 5683 (sy_call_t *)rumpns_sys_nomodule }, /* 7 = wait4 */ 5684 { 0, 0, 0, 5685 (sy_call_t *)rumpns_sys_nomodule }, /* 8 = ocreat */ 5686 { ns(struct sys_link_args), 0, 5687 (sy_call_t *)rumpns_sys_link }, /* 9 = link */ 5688 { ns(struct sys_unlink_args), 0, 5689 (sy_call_t *)rumpns_sys_unlink }, /* 10 = unlink */ 5690 { 0, 0, SYCALL_NOSYS, 5691 (sy_call_t *)rump_enosys }, /* 11 = obsolete execv */ 5692 { ns(struct sys_chdir_args), 0, 5693 (sy_call_t *)rumpns_sys_chdir }, /* 12 = chdir */ 5694 { ns(struct sys_fchdir_args), 0, 5695 (sy_call_t *)rumpns_sys_fchdir }, /* 13 = fchdir */ 5696 { ns(struct compat_50_sys_mknod_args), 0, 5697 (sy_call_t *)rumpns_compat_50_sys_mknod },/* 14 = compat_50_mknod */ 5698 { ns(struct sys_chmod_args), 0, 5699 (sy_call_t *)rumpns_sys_chmod }, /* 15 = chmod */ 5700 { ns(struct sys_chown_args), 0, 5701 (sy_call_t *)rumpns_sys_chown }, /* 16 = chown */ 5702 { 0, 0, SYCALL_NOSYS, 5703 (sy_call_t *)rump_enosys }, /* 17 = break */ 5704 { 0, 0, 0, 5705 (sy_call_t *)rumpns_sys_nomodule }, /* 18 = getfsstat */ 5706 { 0, 0, 0, 5707 (sy_call_t *)rumpns_sys_nomodule }, /* 19 = olseek */ 5708 { 0, 0, 0, 5709 (sy_call_t *)rumpns_sys_getpid_with_ppid },/* 20 = getpid */ 5710 { 0, 0, 0, 5711 (sy_call_t *)rumpns_sys_nomodule }, /* 21 = mount */ 5712 { ns(struct sys_unmount_args), 0, 5713 (sy_call_t *)rumpns_sys_unmount }, /* 22 = unmount */ 5714 { ns(struct sys_setuid_args), 0, 5715 (sy_call_t *)rumpns_sys_setuid }, /* 23 = setuid */ 5716 { 0, 0, 0, 5717 (sy_call_t *)rumpns_sys_getuid_with_euid },/* 24 = getuid */ 5718 { 0, 0, 0, 5719 (sy_call_t *)rumpns_sys_geteuid }, /* 25 = geteuid */ 5720 { 0, 0, SYCALL_NOSYS, 5721 (sy_call_t *)rump_enosys }, /* 26 = ptrace */ 5722 { ns(struct sys_recvmsg_args), 0, 5723 (sy_call_t *)rumpns_sys_recvmsg }, /* 27 = recvmsg */ 5724 { ns(struct sys_sendmsg_args), 0, 5725 (sy_call_t *)rumpns_sys_sendmsg }, /* 28 = sendmsg */ 5726 { ns(struct sys_recvfrom_args), 0, 5727 (sy_call_t *)rumpns_sys_recvfrom }, /* 29 = recvfrom */ 5728 { ns(struct sys_accept_args), 0, 5729 (sy_call_t *)rumpns_sys_accept }, /* 30 = accept */ 5730 { ns(struct sys_getpeername_args), 0, 5731 (sy_call_t *)rumpns_sys_getpeername },/* 31 = getpeername */ 5732 { ns(struct sys_getsockname_args), 0, 5733 (sy_call_t *)rumpns_sys_getsockname },/* 32 = getsockname */ 5734 { ns(struct sys_access_args), 0, 5735 (sy_call_t *)rumpns_sys_access }, /* 33 = access */ 5736 { ns(struct sys_chflags_args), 0, 5737 (sy_call_t *)rumpns_sys_chflags }, /* 34 = chflags */ 5738 { ns(struct sys_fchflags_args), 0, 5739 (sy_call_t *)rumpns_sys_fchflags }, /* 35 = fchflags */ 5740 { 0, 0, 0, 5741 (sy_call_t *)rumpns_sys_sync }, /* 36 = sync */ 5742 { 0, 0, SYCALL_NOSYS, 5743 (sy_call_t *)rump_enosys }, /* 37 = kill */ 5744 { 0, 0, 0, 5745 (sy_call_t *)rumpns_sys_nomodule }, /* 38 = stat43 */ 5746 { 0, 0, 0, 5747 (sy_call_t *)rumpns_sys_getppid }, /* 39 = getppid */ 5748 { 0, 0, 0, 5749 (sy_call_t *)rumpns_sys_nomodule }, /* 40 = lstat43 */ 5750 { ns(struct sys_dup_args), 0, 5751 (sy_call_t *)rumpns_sys_dup }, /* 41 = dup */ 5752 { 0, 0, 0, 5753 (sy_call_t *)rumpns_sys_pipe }, /* 42 = pipe */ 5754 { 0, 0, 0, 5755 (sy_call_t *)rumpns_sys_getegid }, /* 43 = getegid */ 5756 { 0, 0, SYCALL_NOSYS, 5757 (sy_call_t *)rump_enosys }, /* 44 = profil */ 5758 { ns(struct sys_ktrace_args), 0, 5759 (sy_call_t *)rumpns_sys_ktrace }, /* 45 = ktrace */ 5760 { 0, 0, 0, 5761 (sy_call_t *)rumpns_sys_nomodule }, /* 46 = sigaction13 */ 5762 { 0, 0, 0, 5763 (sy_call_t *)rumpns_sys_getgid_with_egid },/* 47 = getgid */ 5764 { 0, 0, 0, 5765 (sy_call_t *)rumpns_sys_nomodule }, /* 48 = sigprocmask13 */ 5766 { ns(struct sys___getlogin_args), 0, 5767 (sy_call_t *)rumpns_sys___getlogin },/* 49 = __getlogin */ 5768 { ns(struct sys___setlogin_args), 0, 5769 (sy_call_t *)rumpns_sys___setlogin },/* 50 = __setlogin */ 5770 { 0, 0, SYCALL_NOSYS, 5771 (sy_call_t *)rump_enosys }, /* 51 = acct */ 5772 { 0, 0, 0, 5773 (sy_call_t *)rumpns_sys_nomodule }, /* 52 = sigpending13 */ 5774 { 0, 0, 0, 5775 (sy_call_t *)rumpns_sys_nomodule }, /* 53 = sigaltstack13 */ 5776 { ns(struct sys_ioctl_args), 0, 5777 (sy_call_t *)rumpns_sys_ioctl }, /* 54 = ioctl */ 5778 { 0, 0, 0, 5779 (sy_call_t *)rumpns_sys_nomodule }, /* 55 = oreboot */ 5780 { ns(struct sys_revoke_args), 0, 5781 (sy_call_t *)rumpns_sys_revoke }, /* 56 = revoke */ 5782 { ns(struct sys_symlink_args), 0, 5783 (sy_call_t *)rumpns_sys_symlink }, /* 57 = symlink */ 5784 { ns(struct sys_readlink_args), 0, 5785 (sy_call_t *)rumpns_sys_readlink }, /* 58 = readlink */ 5786 { 0, 0, SYCALL_NOSYS, 5787 (sy_call_t *)rump_enosys }, /* 59 = execve */ 5788 { ns(struct sys_umask_args), 0, 5789 (sy_call_t *)rumpns_sys_umask }, /* 60 = umask */ 5790 { ns(struct sys_chroot_args), 0, 5791 (sy_call_t *)rumpns_sys_chroot }, /* 61 = chroot */ 5792 { 0, 0, 0, 5793 (sy_call_t *)rumpns_sys_nomodule }, /* 62 = fstat43 */ 5794 { 0, 0, 0, 5795 (sy_call_t *)rumpns_sys_nomodule }, /* 63 = ogetkerninfo */ 5796 { 0, 0, 0, 5797 (sy_call_t *)rumpns_sys_nomodule }, /* 64 = ogetpagesize */ 5798 { 0, 0, 0, 5799 (sy_call_t *)rumpns_sys_nomodule }, /* 65 = msync */ 5800 { 0, 0, SYCALL_NOSYS, 5801 (sy_call_t *)rump_enosys }, /* 66 = vfork */ 5802 { 0, 0, SYCALL_NOSYS, 5803 (sy_call_t *)rump_enosys }, /* 67 = obsolete vread */ 5804 { 0, 0, SYCALL_NOSYS, 5805 (sy_call_t *)rump_enosys }, /* 68 = obsolete vwrite */ 5806 { 0, 0, SYCALL_NOSYS, 5807 (sy_call_t *)rump_enosys }, /* 69 = sbrk */ 5808 { 0, 0, SYCALL_NOSYS, 5809 (sy_call_t *)rump_enosys }, /* 70 = sstk */ 5810 { 0, 0, 0, 5811 (sy_call_t *)rumpns_sys_nomodule }, /* 71 = ommap */ 5812 { 0, 0, SYCALL_NOSYS, 5813 (sy_call_t *)rump_enosys }, /* 72 = vadvise */ 5814 { 0, 0, SYCALL_NOSYS, 5815 (sy_call_t *)rump_enosys }, /* 73 = munmap */ 5816 { 0, 0, SYCALL_NOSYS, 5817 (sy_call_t *)rump_enosys }, /* 74 = mprotect */ 5818 { 0, 0, SYCALL_NOSYS, 5819 (sy_call_t *)rump_enosys }, /* 75 = madvise */ 5820 { 0, 0, SYCALL_NOSYS, 5821 (sy_call_t *)rump_enosys }, /* 76 = obsolete vhangup */ 5822 { 0, 0, SYCALL_NOSYS, 5823 (sy_call_t *)rump_enosys }, /* 77 = obsolete vlimit */ 5824 { 0, 0, SYCALL_NOSYS, 5825 (sy_call_t *)rump_enosys }, /* 78 = mincore */ 5826 { ns(struct sys_getgroups_args), 0, 5827 (sy_call_t *)rumpns_sys_getgroups },/* 79 = getgroups */ 5828 { ns(struct sys_setgroups_args), 0, 5829 (sy_call_t *)rumpns_sys_setgroups },/* 80 = setgroups */ 5830 { 0, 0, 0, 5831 (sy_call_t *)rumpns_sys_getpgrp }, /* 81 = getpgrp */ 5832 { ns(struct sys_setpgid_args), 0, 5833 (sy_call_t *)rumpns_sys_setpgid }, /* 82 = setpgid */ 5834 { 0, 0, 0, 5835 (sy_call_t *)rumpns_sys_nomodule }, /* 83 = setitimer */ 5836 { 0, 0, 0, 5837 (sy_call_t *)rumpns_sys_nomodule }, /* 84 = owait */ 5838 { 0, 0, 0, 5839 (sy_call_t *)rumpns_sys_nomodule }, /* 85 = oswapon */ 5840 { 0, 0, 0, 5841 (sy_call_t *)rumpns_sys_nomodule }, /* 86 = getitimer */ 5842 { 0, 0, 0, 5843 (sy_call_t *)rumpns_sys_nomodule }, /* 87 = ogethostname */ 5844 { 0, 0, 0, 5845 (sy_call_t *)rumpns_sys_nomodule }, /* 88 = osethostname */ 5846 { 0, 0, 0, 5847 (sy_call_t *)rumpns_sys_nomodule }, /* 89 = ogetdtablesize */ 5848 { ns(struct sys_dup2_args), 0, 5849 (sy_call_t *)rumpns_sys_dup2 }, /* 90 = dup2 */ 5850 { 0, 0, SYCALL_NOSYS, 5851 (sy_call_t *)rump_enosys }, /* 91 = unimplemented getdopt */ 5852 { ns(struct sys_fcntl_args), 0, 5853 (sy_call_t *)rumpns_sys_fcntl }, /* 92 = fcntl */ 5854 { ns(struct compat_50_sys_select_args), 0, 5855 (sy_call_t *)rumpns_compat_50_sys_select },/* 93 = compat_50_select */ 5856 { 0, 0, SYCALL_NOSYS, 5857 (sy_call_t *)rump_enosys }, /* 94 = unimplemented setdopt */ 5858 { ns(struct sys_fsync_args), 0, 5859 (sy_call_t *)rumpns_sys_fsync }, /* 95 = fsync */ 5860 { 0, 0, SYCALL_NOSYS, 5861 (sy_call_t *)rump_enosys }, /* 96 = setpriority */ 5862 { 0, 0, 0, 5863 (sy_call_t *)rumpns_sys_nomodule }, /* 97 = socket */ 5864 { ns(struct sys_connect_args), 0, 5865 (sy_call_t *)rumpns_sys_connect }, /* 98 = connect */ 5866 { 0, 0, 0, 5867 (sy_call_t *)rumpns_sys_nomodule }, /* 99 = oaccept */ 5868 { 0, 0, SYCALL_NOSYS, 5869 (sy_call_t *)rump_enosys }, /* 100 = getpriority */ 5870 { 0, 0, 0, 5871 (sy_call_t *)rumpns_sys_nomodule }, /* 101 = osend */ 5872 { 0, 0, 0, 5873 (sy_call_t *)rumpns_sys_nomodule }, /* 102 = orecv */ 5874 { 0, 0, 0, 5875 (sy_call_t *)rumpns_sys_nomodule }, /* 103 = sigreturn13 */ 5876 { ns(struct sys_bind_args), 0, 5877 (sy_call_t *)rumpns_sys_bind }, /* 104 = bind */ 5878 { ns(struct sys_setsockopt_args), 0, 5879 (sy_call_t *)rumpns_sys_setsockopt },/* 105 = setsockopt */ 5880 { ns(struct sys_listen_args), 0, 5881 (sy_call_t *)rumpns_sys_listen }, /* 106 = listen */ 5882 { 0, 0, SYCALL_NOSYS, 5883 (sy_call_t *)rump_enosys }, /* 107 = obsolete vtimes */ 5884 { 0, 0, 0, 5885 (sy_call_t *)rumpns_sys_nomodule }, /* 108 = osigvec */ 5886 { 0, 0, 0, 5887 (sy_call_t *)rumpns_sys_nomodule }, /* 109 = osigblock */ 5888 { 0, 0, 0, 5889 (sy_call_t *)rumpns_sys_nomodule }, /* 110 = osigsetmask */ 5890 { 0, 0, 0, 5891 (sy_call_t *)rumpns_sys_nomodule }, /* 111 = sigsuspend13 */ 5892 { 0, 0, 0, 5893 (sy_call_t *)rumpns_sys_nomodule }, /* 112 = osigstack */ 5894 { 0, 0, 0, 5895 (sy_call_t *)rumpns_sys_nomodule }, /* 113 = orecvmsg */ 5896 { 0, 0, 0, 5897 (sy_call_t *)rumpns_sys_nomodule }, /* 114 = osendmsg */ 5898 { 0, 0, SYCALL_NOSYS, 5899 (sy_call_t *)rump_enosys }, /* 115 = obsolete vtrace */ 5900 { 0, 0, 0, 5901 (sy_call_t *)rumpns_sys_nomodule }, /* 116 = gettimeofday */ 5902 { 0, 0, 0, 5903 (sy_call_t *)rumpns_sys_nomodule }, /* 117 = getrusage */ 5904 { ns(struct sys_getsockopt_args), 0, 5905 (sy_call_t *)rumpns_sys_getsockopt },/* 118 = getsockopt */ 5906 { 0, 0, SYCALL_NOSYS, 5907 (sy_call_t *)rump_enosys }, /* 119 = obsolete resuba */ 5908 { ns(struct sys_readv_args), 0, 5909 (sy_call_t *)rumpns_sys_readv }, /* 120 = readv */ 5910 { ns(struct sys_writev_args), 0, 5911 (sy_call_t *)rumpns_sys_writev }, /* 121 = writev */ 5912 { 0, 0, 0, 5913 (sy_call_t *)rumpns_sys_nomodule }, /* 122 = settimeofday */ 5914 { ns(struct sys_fchown_args), 0, 5915 (sy_call_t *)rumpns_sys_fchown }, /* 123 = fchown */ 5916 { ns(struct sys_fchmod_args), 0, 5917 (sy_call_t *)rumpns_sys_fchmod }, /* 124 = fchmod */ 5918 { 0, 0, 0, 5919 (sy_call_t *)rumpns_sys_nomodule }, /* 125 = orecvfrom */ 5920 { ns(struct sys_setreuid_args), 0, 5921 (sy_call_t *)rumpns_sys_setreuid }, /* 126 = setreuid */ 5922 { ns(struct sys_setregid_args), 0, 5923 (sy_call_t *)rumpns_sys_setregid }, /* 127 = setregid */ 5924 { ns(struct sys_rename_args), 0, 5925 (sy_call_t *)rumpns_sys_rename }, /* 128 = rename */ 5926 { 0, 0, 0, 5927 (sy_call_t *)rumpns_sys_nomodule }, /* 129 = otruncate */ 5928 { 0, 0, 0, 5929 (sy_call_t *)rumpns_sys_nomodule }, /* 130 = oftruncate */ 5930 { ns(struct sys_flock_args), 0, 5931 (sy_call_t *)rumpns_sys_flock }, /* 131 = flock */ 5932 { ns(struct sys_mkfifo_args), 0, 5933 (sy_call_t *)rumpns_sys_mkfifo }, /* 132 = mkfifo */ 5934 { ns(struct sys_sendto_args), 0, 5935 (sy_call_t *)rumpns_sys_sendto }, /* 133 = sendto */ 5936 { ns(struct sys_shutdown_args), 0, 5937 (sy_call_t *)rumpns_sys_shutdown }, /* 134 = shutdown */ 5938 { ns(struct sys_socketpair_args), 0, 5939 (sy_call_t *)rumpns_sys_socketpair },/* 135 = socketpair */ 5940 { ns(struct sys_mkdir_args), 0, 5941 (sy_call_t *)rumpns_sys_mkdir }, /* 136 = mkdir */ 5942 { ns(struct sys_rmdir_args), 0, 5943 (sy_call_t *)rumpns_sys_rmdir }, /* 137 = rmdir */ 5944 { ns(struct compat_50_sys_utimes_args), 0, 5945 (sy_call_t *)rumpns_compat_50_sys_utimes },/* 138 = compat_50_utimes */ 5946 { 0, 0, SYCALL_NOSYS, 5947 (sy_call_t *)rump_enosys }, /* 139 = obsolete 4.2 sigreturn */ 5948 { 0, 0, 0, 5949 (sy_call_t *)rumpns_sys_nomodule }, /* 140 = adjtime */ 5950 { 0, 0, 0, 5951 (sy_call_t *)rumpns_sys_nomodule }, /* 141 = ogetpeername */ 5952 { 0, 0, 0, 5953 (sy_call_t *)rumpns_sys_nomodule }, /* 142 = ogethostid */ 5954 { 0, 0, 0, 5955 (sy_call_t *)rumpns_sys_nomodule }, /* 143 = osethostid */ 5956 { 0, 0, 0, 5957 (sy_call_t *)rumpns_sys_nomodule }, /* 144 = ogetrlimit */ 5958 { 0, 0, 0, 5959 (sy_call_t *)rumpns_sys_nomodule }, /* 145 = osetrlimit */ 5960 { 0, 0, 0, 5961 (sy_call_t *)rumpns_sys_nomodule }, /* 146 = okillpg */ 5962 { 0, 0, 0, 5963 (sy_call_t *)rumpns_sys_setsid }, /* 147 = setsid */ 5964 { 0, 0, 0, 5965 (sy_call_t *)rumpns_sys_nomodule }, /* 148 = quotactl */ 5966 { 0, 0, 0, 5967 (sy_call_t *)rumpns_sys_nomodule }, /* 149 = oquota */ 5968 { 0, 0, 0, 5969 (sy_call_t *)rumpns_sys_nomodule }, /* 150 = ogetsockname */ 5970 { 0, 0, SYCALL_NOSYS, 5971 (sy_call_t *)rump_enosys }, /* 151 = unimplemented */ 5972 { 0, 0, SYCALL_NOSYS, 5973 (sy_call_t *)rump_enosys }, /* 152 = unimplemented */ 5974 { 0, 0, SYCALL_NOSYS, 5975 (sy_call_t *)rump_enosys }, /* 153 = unimplemented */ 5976 { 0, 0, SYCALL_NOSYS, 5977 (sy_call_t *)rump_enosys }, /* 154 = unimplemented */ 5978 { ns(struct sys_nfssvc_args), 0, 5979 (sy_call_t *)rumpns_sys_nomodule }, /* 155 = nfssvc */ 5980 { 0, 0, 0, 5981 (sy_call_t *)rumpns_sys_nomodule }, /* 156 = ogetdirentries */ 5982 { 0, 0, 0, 5983 (sy_call_t *)rumpns_sys_nomodule }, /* 157 = statfs */ 5984 { 0, 0, 0, 5985 (sy_call_t *)rumpns_sys_nomodule }, /* 158 = fstatfs */ 5986 { 0, 0, SYCALL_NOSYS, 5987 (sy_call_t *)rump_enosys }, /* 159 = unimplemented */ 5988 { 0, 0, SYCALL_NOSYS, 5989 (sy_call_t *)rump_enosys }, /* 160 = unimplemented */ 5990 { 0, 0, 0, 5991 (sy_call_t *)rumpns_sys_nomodule }, /* 161 = getfh */ 5992 { 0, 0, 0, 5993 (sy_call_t *)rumpns_sys_nomodule }, /* 162 = ogetdomainname */ 5994 { 0, 0, 0, 5995 (sy_call_t *)rumpns_sys_nomodule }, /* 163 = osetdomainname */ 5996 { 0, 0, 0, 5997 (sy_call_t *)rumpns_sys_nomodule }, /* 164 = ouname */ 5998 { 0, 0, SYCALL_NOSYS, 5999 (sy_call_t *)rump_enosys }, /* 165 = sysarch */ 6000 { 0, 0, SYCALL_NOSYS, 6001 (sy_call_t *)rump_enosys }, /* 166 = unimplemented */ 6002 { 0, 0, SYCALL_NOSYS, 6003 (sy_call_t *)rump_enosys }, /* 167 = unimplemented */ 6004 { 0, 0, SYCALL_NOSYS, 6005 (sy_call_t *)rump_enosys }, /* 168 = unimplemented */ 6006 #if (defined(SYSVSEM) || !defined(_KERNEL_OPT)) && !defined(_LP64) 6007 { 0, 0, 0, 6008 (sy_call_t *)rumpns_sys_nomodule }, /* 169 = osemsys */ 6009 #else 6010 { 0, 0, SYCALL_NOSYS, 6011 (sy_call_t *)rump_enosys }, /* 169 = excluded 1.0 semsys */ 6012 #endif 6013 #if (defined(SYSVMSG) || !defined(_KERNEL_OPT)) && !defined(_LP64) 6014 { 0, 0, 0, 6015 (sy_call_t *)rumpns_sys_nomodule }, /* 170 = omsgsys */ 6016 #else 6017 { 0, 0, SYCALL_NOSYS, 6018 (sy_call_t *)rump_enosys }, /* 170 = excluded 1.0 msgsys */ 6019 #endif 6020 #if (defined(SYSVSHM) || !defined(_KERNEL_OPT)) && !defined(_LP64) 6021 { 0, 0, 0, 6022 (sy_call_t *)rumpns_sys_nomodule }, /* 171 = oshmsys */ 6023 #else 6024 { 0, 0, SYCALL_NOSYS, 6025 (sy_call_t *)rump_enosys }, /* 171 = excluded 1.0 shmsys */ 6026 #endif 6027 { 0, 0, SYCALL_NOSYS, 6028 (sy_call_t *)rump_enosys }, /* 172 = unimplemented */ 6029 { ns(struct sys_pread_args), 0, 6030 (sy_call_t *)rumpns_sys_pread }, /* 173 = pread */ 6031 { ns(struct sys_pwrite_args), 0, 6032 (sy_call_t *)rumpns_sys_pwrite }, /* 174 = pwrite */ 6033 { 0, 0, SYCALL_NOSYS, 6034 (sy_call_t *)rump_enosys }, /* 175 = ntp_gettime */ 6035 #if defined(NTP) || !defined(_KERNEL_OPT) 6036 { 0, 0, SYCALL_NOSYS, 6037 (sy_call_t *)rump_enosys }, /* 176 = ntp_adjtime */ 6038 #else 6039 { 0, 0, SYCALL_NOSYS, 6040 (sy_call_t *)rump_enosys }, /* 176 = excluded ntp_adjtime */ 6041 #endif 6042 { 0, 0, SYCALL_NOSYS, 6043 (sy_call_t *)rump_enosys }, /* 177 = unimplemented */ 6044 { 0, 0, SYCALL_NOSYS, 6045 (sy_call_t *)rump_enosys }, /* 178 = unimplemented */ 6046 { 0, 0, SYCALL_NOSYS, 6047 (sy_call_t *)rump_enosys }, /* 179 = unimplemented */ 6048 { 0, 0, SYCALL_NOSYS, 6049 (sy_call_t *)rump_enosys }, /* 180 = unimplemented */ 6050 { ns(struct sys_setgid_args), 0, 6051 (sy_call_t *)rumpns_sys_setgid }, /* 181 = setgid */ 6052 { ns(struct sys_setegid_args), 0, 6053 (sy_call_t *)rumpns_sys_setegid }, /* 182 = setegid */ 6054 { ns(struct sys_seteuid_args), 0, 6055 (sy_call_t *)rumpns_sys_seteuid }, /* 183 = seteuid */ 6056 { 0, 0, 0, 6057 (sy_call_t *)rumpns_sys_nomodule }, /* 184 = lfs_bmapv */ 6058 { 0, 0, 0, 6059 (sy_call_t *)rumpns_sys_nomodule }, /* 185 = lfs_markv */ 6060 { 0, 0, 0, 6061 (sy_call_t *)rumpns_sys_nomodule }, /* 186 = lfs_segclean */ 6062 { 0, 0, 0, 6063 (sy_call_t *)rumpns_sys_nomodule }, /* 187 = lfs_segwait */ 6064 { 0, 0, 0, 6065 (sy_call_t *)rumpns_sys_nomodule }, /* 188 = stat12 */ 6066 { 0, 0, 0, 6067 (sy_call_t *)rumpns_sys_nomodule }, /* 189 = fstat12 */ 6068 { 0, 0, 0, 6069 (sy_call_t *)rumpns_sys_nomodule }, /* 190 = lstat12 */ 6070 { ns(struct sys_pathconf_args), 0, 6071 (sy_call_t *)rumpns_sys_pathconf }, /* 191 = pathconf */ 6072 { ns(struct sys_fpathconf_args), 0, 6073 (sy_call_t *)rumpns_sys_fpathconf },/* 192 = fpathconf */ 6074 { 0, 0, SYCALL_NOSYS, 6075 (sy_call_t *)rump_enosys }, /* 193 = unimplemented */ 6076 { ns(struct sys_getrlimit_args), 0, 6077 (sy_call_t *)rumpns_sys_getrlimit },/* 194 = getrlimit */ 6078 { ns(struct sys_setrlimit_args), 0, 6079 (sy_call_t *)rumpns_sys_setrlimit },/* 195 = setrlimit */ 6080 { 0, 0, 0, 6081 (sy_call_t *)rumpns_sys_nomodule }, /* 196 = getdirentries */ 6082 { 0, 0, SYCALL_NOSYS, 6083 (sy_call_t *)rump_enosys }, /* 197 = mmap */ 6084 { 0, 0, SYCALL_NOSYS, 6085 (sy_call_t *)rump_enosys }, /* 198 = __syscall */ 6086 { ns(struct sys_lseek_args), 0, 6087 (sy_call_t *)rumpns_sys_lseek }, /* 199 = lseek */ 6088 { ns(struct sys_truncate_args), 0, 6089 (sy_call_t *)rumpns_sys_truncate }, /* 200 = truncate */ 6090 { ns(struct sys_ftruncate_args), 0, 6091 (sy_call_t *)rumpns_sys_ftruncate },/* 201 = ftruncate */ 6092 { ns(struct sys___sysctl_args), 0, 6093 (sy_call_t *)rumpns_sys___sysctl }, /* 202 = __sysctl */ 6094 { 0, 0, SYCALL_NOSYS, 6095 (sy_call_t *)rump_enosys }, /* 203 = mlock */ 6096 { 0, 0, SYCALL_NOSYS, 6097 (sy_call_t *)rump_enosys }, /* 204 = munlock */ 6098 { 0, 0, SYCALL_NOSYS, 6099 (sy_call_t *)rump_enosys }, /* 205 = undelete */ 6100 { ns(struct compat_50_sys_futimes_args), 0, 6101 (sy_call_t *)rumpns_compat_50_sys_futimes },/* 206 = compat_50_futimes */ 6102 { ns(struct sys_getpgid_args), 0, 6103 (sy_call_t *)rumpns_sys_getpgid }, /* 207 = getpgid */ 6104 { ns(struct sys_reboot_args), 0, 6105 (sy_call_t *)rumpns_sys_reboot }, /* 208 = reboot */ 6106 { ns(struct sys_poll_args), 0, 6107 (sy_call_t *)rumpns_sys_poll }, /* 209 = poll */ 6108 { 0, 0, 0, 6109 (sy_call_t *)rumpns_sys_nomodule }, /* 210 = afssys */ 6110 { 0, 0, SYCALL_NOSYS, 6111 (sy_call_t *)rump_enosys }, /* 211 = unimplemented */ 6112 { 0, 0, SYCALL_NOSYS, 6113 (sy_call_t *)rump_enosys }, /* 212 = unimplemented */ 6114 { 0, 0, SYCALL_NOSYS, 6115 (sy_call_t *)rump_enosys }, /* 213 = unimplemented */ 6116 { 0, 0, SYCALL_NOSYS, 6117 (sy_call_t *)rump_enosys }, /* 214 = unimplemented */ 6118 { 0, 0, SYCALL_NOSYS, 6119 (sy_call_t *)rump_enosys }, /* 215 = unimplemented */ 6120 { 0, 0, SYCALL_NOSYS, 6121 (sy_call_t *)rump_enosys }, /* 216 = unimplemented */ 6122 { 0, 0, SYCALL_NOSYS, 6123 (sy_call_t *)rump_enosys }, /* 217 = unimplemented */ 6124 { 0, 0, SYCALL_NOSYS, 6125 (sy_call_t *)rump_enosys }, /* 218 = unimplemented */ 6126 { 0, 0, SYCALL_NOSYS, 6127 (sy_call_t *)rump_enosys }, /* 219 = unimplemented */ 6128 #if defined(SYSVSEM) || !defined(_KERNEL_OPT) 6129 { 0, 0, 0, 6130 (sy_call_t *)rumpns_sys_nomodule }, /* 220 = __semctl */ 6131 { 0, 0, SYCALL_NOSYS, 6132 (sy_call_t *)rump_enosys }, /* 221 = semget */ 6133 { 0, 0, SYCALL_NOSYS, 6134 (sy_call_t *)rump_enosys }, /* 222 = semop */ 6135 { 0, 0, SYCALL_NOSYS, 6136 (sy_call_t *)rump_enosys }, /* 223 = semconfig */ 6137 #else 6138 { 0, 0, SYCALL_NOSYS, 6139 (sy_call_t *)rump_enosys }, /* 220 = excluded compat_14_semctl */ 6140 { 0, 0, SYCALL_NOSYS, 6141 (sy_call_t *)rump_enosys }, /* 221 = excluded semget */ 6142 { 0, 0, SYCALL_NOSYS, 6143 (sy_call_t *)rump_enosys }, /* 222 = excluded semop */ 6144 { 0, 0, SYCALL_NOSYS, 6145 (sy_call_t *)rump_enosys }, /* 223 = excluded semconfig */ 6146 #endif 6147 #if defined(SYSVMSG) || !defined(_KERNEL_OPT) 6148 { 0, 0, 0, 6149 (sy_call_t *)rumpns_sys_nomodule }, /* 224 = msgctl */ 6150 { 0, 0, SYCALL_NOSYS, 6151 (sy_call_t *)rump_enosys }, /* 225 = msgget */ 6152 { 0, 0, SYCALL_NOSYS, 6153 (sy_call_t *)rump_enosys }, /* 226 = msgsnd */ 6154 { 0, 0, SYCALL_NOSYS, 6155 (sy_call_t *)rump_enosys }, /* 227 = msgrcv */ 6156 #else 6157 { 0, 0, SYCALL_NOSYS, 6158 (sy_call_t *)rump_enosys }, /* 224 = excluded compat_14_msgctl */ 6159 { 0, 0, SYCALL_NOSYS, 6160 (sy_call_t *)rump_enosys }, /* 225 = excluded msgget */ 6161 { 0, 0, SYCALL_NOSYS, 6162 (sy_call_t *)rump_enosys }, /* 226 = excluded msgsnd */ 6163 { 0, 0, SYCALL_NOSYS, 6164 (sy_call_t *)rump_enosys }, /* 227 = excluded msgrcv */ 6165 #endif 6166 #if defined(SYSVSHM) || !defined(_KERNEL_OPT) 6167 { 0, 0, SYCALL_NOSYS, 6168 (sy_call_t *)rump_enosys }, /* 228 = shmat */ 6169 { 0, 0, 0, 6170 (sy_call_t *)rumpns_sys_nomodule }, /* 229 = shmctl */ 6171 { 0, 0, SYCALL_NOSYS, 6172 (sy_call_t *)rump_enosys }, /* 230 = shmdt */ 6173 { 0, 0, SYCALL_NOSYS, 6174 (sy_call_t *)rump_enosys }, /* 231 = shmget */ 6175 #else 6176 { 0, 0, SYCALL_NOSYS, 6177 (sy_call_t *)rump_enosys }, /* 228 = excluded shmat */ 6178 { 0, 0, SYCALL_NOSYS, 6179 (sy_call_t *)rump_enosys }, /* 229 = excluded compat_14_shmctl */ 6180 { 0, 0, SYCALL_NOSYS, 6181 (sy_call_t *)rump_enosys }, /* 230 = excluded shmdt */ 6182 { 0, 0, SYCALL_NOSYS, 6183 (sy_call_t *)rump_enosys }, /* 231 = excluded shmget */ 6184 #endif 6185 { 0, 0, 0, 6186 (sy_call_t *)rumpns_sys_nomodule }, /* 232 = clock_gettime */ 6187 { 0, 0, 0, 6188 (sy_call_t *)rumpns_sys_nomodule }, /* 233 = clock_settime */ 6189 { 0, 0, 0, 6190 (sy_call_t *)rumpns_sys_nomodule }, /* 234 = clock_getres */ 6191 { ns(struct sys_timer_create_args), 0, 6192 (sy_call_t *)rumpns_sys_timer_create },/* 235 = timer_create */ 6193 { ns(struct sys_timer_delete_args), 0, 6194 (sy_call_t *)rumpns_sys_timer_delete },/* 236 = timer_delete */ 6195 { 0, 0, 0, 6196 (sy_call_t *)rumpns_sys_nomodule }, /* 237 = timer_settime */ 6197 { 0, 0, 0, 6198 (sy_call_t *)rumpns_sys_nomodule }, /* 238 = timer_gettime */ 6199 { ns(struct sys_timer_getoverrun_args), 0, 6200 (sy_call_t *)rumpns_sys_timer_getoverrun },/* 239 = timer_getoverrun */ 6201 { 0, 0, 0, 6202 (sy_call_t *)rumpns_sys_nomodule }, /* 240 = nanosleep */ 6203 { ns(struct sys_fdatasync_args), 0, 6204 (sy_call_t *)rumpns_sys_fdatasync },/* 241 = fdatasync */ 6205 { 0, 0, SYCALL_NOSYS, 6206 (sy_call_t *)rump_enosys }, /* 242 = mlockall */ 6207 { 0, 0, SYCALL_NOSYS, 6208 (sy_call_t *)rump_enosys }, /* 243 = munlockall */ 6209 { 0, 0, 0, 6210 (sy_call_t *)rumpns_sys_nomodule }, /* 244 = __sigtimedwait */ 6211 { 0, 0, SYCALL_NOSYS, 6212 (sy_call_t *)rump_enosys }, /* 245 = sigqueueinfo */ 6213 { ns(struct sys_modctl_args), 0, 6214 (sy_call_t *)rumpns_sys_modctl }, /* 246 = modctl */ 6215 { ns(struct sys__ksem_init_args), 0, 6216 (sy_call_t *)rumpns_sys_nomodule }, /* 247 = _ksem_init */ 6217 { ns(struct sys__ksem_open_args), 0, 6218 (sy_call_t *)rumpns_sys_nomodule }, /* 248 = _ksem_open */ 6219 { ns(struct sys__ksem_unlink_args), 0, 6220 (sy_call_t *)rumpns_sys_nomodule }, /* 249 = _ksem_unlink */ 6221 { ns(struct sys__ksem_close_args), 0, 6222 (sy_call_t *)rumpns_sys_nomodule }, /* 250 = _ksem_close */ 6223 { ns(struct sys__ksem_post_args), 0, 6224 (sy_call_t *)rumpns_sys_nomodule }, /* 251 = _ksem_post */ 6225 { ns(struct sys__ksem_wait_args), 0, 6226 (sy_call_t *)rumpns_sys_nomodule }, /* 252 = _ksem_wait */ 6227 { ns(struct sys__ksem_trywait_args), 0, 6228 (sy_call_t *)rumpns_sys_nomodule }, /* 253 = _ksem_trywait */ 6229 { ns(struct sys__ksem_getvalue_args), 0, 6230 (sy_call_t *)rumpns_sys_nomodule }, /* 254 = _ksem_getvalue */ 6231 { ns(struct sys__ksem_destroy_args), 0, 6232 (sy_call_t *)rumpns_sys_nomodule }, /* 255 = _ksem_destroy */ 6233 { ns(struct sys__ksem_timedwait_args), 0, 6234 (sy_call_t *)rumpns_sys_nomodule }, /* 256 = _ksem_timedwait */ 6235 { 0, 0, 0, 6236 (sy_call_t *)rumpns_sys_nomodule }, /* 257 = mq_open */ 6237 { 0, 0, 0, 6238 (sy_call_t *)rumpns_sys_nomodule }, /* 258 = mq_close */ 6239 { 0, 0, 0, 6240 (sy_call_t *)rumpns_sys_nomodule }, /* 259 = mq_unlink */ 6241 { 0, 0, 0, 6242 (sy_call_t *)rumpns_sys_nomodule }, /* 260 = mq_getattr */ 6243 { 0, 0, 0, 6244 (sy_call_t *)rumpns_sys_nomodule }, /* 261 = mq_setattr */ 6245 { 0, 0, 0, 6246 (sy_call_t *)rumpns_sys_nomodule }, /* 262 = mq_notify */ 6247 { 0, 0, 0, 6248 (sy_call_t *)rumpns_sys_nomodule }, /* 263 = mq_send */ 6249 { 0, 0, 0, 6250 (sy_call_t *)rumpns_sys_nomodule }, /* 264 = mq_receive */ 6251 { 0, 0, 0, 6252 (sy_call_t *)rumpns_sys_nomodule }, /* 265 = mq_timedsend */ 6253 { 0, 0, 0, 6254 (sy_call_t *)rumpns_sys_nomodule }, /* 266 = mq_timedreceive */ 6255 { 0, 0, SYCALL_NOSYS, 6256 (sy_call_t *)rump_enosys }, /* 267 = unimplemented */ 6257 { 0, 0, SYCALL_NOSYS, 6258 (sy_call_t *)rump_enosys }, /* 268 = unimplemented */ 6259 { 0, 0, SYCALL_NOSYS, 6260 (sy_call_t *)rump_enosys }, /* 269 = unimplemented */ 6261 { 0, 0, SYCALL_NOSYS, 6262 (sy_call_t *)rump_enosys }, /* 270 = __posix_rename */ 6263 { 0, 0, SYCALL_NOSYS, 6264 (sy_call_t *)rump_enosys }, /* 271 = swapctl */ 6265 { 0, 0, 0, 6266 (sy_call_t *)rumpns_sys_nomodule }, /* 272 = getdents */ 6267 { 0, 0, SYCALL_NOSYS, 6268 (sy_call_t *)rump_enosys }, /* 273 = minherit */ 6269 { ns(struct sys_lchmod_args), 0, 6270 (sy_call_t *)rumpns_sys_lchmod }, /* 274 = lchmod */ 6271 { ns(struct sys_lchown_args), 0, 6272 (sy_call_t *)rumpns_sys_lchown }, /* 275 = lchown */ 6273 { ns(struct compat_50_sys_lutimes_args), 0, 6274 (sy_call_t *)rumpns_compat_50_sys_lutimes },/* 276 = compat_50_lutimes */ 6275 { 0, 0, SYCALL_NOSYS, 6276 (sy_call_t *)rump_enosys }, /* 277 = __msync13 */ 6277 { 0, 0, 0, 6278 (sy_call_t *)rumpns_sys_nomodule }, /* 278 = __stat13 */ 6279 { 0, 0, 0, 6280 (sy_call_t *)rumpns_sys_nomodule }, /* 279 = __fstat13 */ 6281 { 0, 0, 0, 6282 (sy_call_t *)rumpns_sys_nomodule }, /* 280 = __lstat13 */ 6283 { 0, 0, SYCALL_NOSYS, 6284 (sy_call_t *)rump_enosys }, /* 281 = __sigaltstack14 */ 6285 { 0, 0, SYCALL_NOSYS, 6286 (sy_call_t *)rump_enosys }, /* 282 = __vfork14 */ 6287 { 0, 0, SYCALL_NOSYS, 6288 (sy_call_t *)rump_enosys }, /* 283 = __posix_chown */ 6289 { 0, 0, SYCALL_NOSYS, 6290 (sy_call_t *)rump_enosys }, /* 284 = __posix_fchown */ 6291 { 0, 0, SYCALL_NOSYS, 6292 (sy_call_t *)rump_enosys }, /* 285 = __posix_lchown */ 6293 { ns(struct sys_getsid_args), 0, 6294 (sy_call_t *)rumpns_sys_getsid }, /* 286 = getsid */ 6295 { 0, 0, SYCALL_NOSYS, 6296 (sy_call_t *)rump_enosys }, /* 287 = __clone */ 6297 { ns(struct sys_fktrace_args), 0, 6298 (sy_call_t *)rumpns_sys_fktrace }, /* 288 = fktrace */ 6299 { ns(struct sys_preadv_args), 0, 6300 (sy_call_t *)rumpns_sys_preadv }, /* 289 = preadv */ 6301 { ns(struct sys_pwritev_args), 0, 6302 (sy_call_t *)rumpns_sys_pwritev }, /* 290 = pwritev */ 6303 { 0, 0, 0, 6304 (sy_call_t *)rumpns_sys_nomodule }, /* 291 = __sigaction14 */ 6305 { 0, 0, SYCALL_NOSYS, 6306 (sy_call_t *)rump_enosys }, /* 292 = __sigpending14 */ 6307 { 0, 0, SYCALL_NOSYS, 6308 (sy_call_t *)rump_enosys }, /* 293 = __sigprocmask14 */ 6309 { 0, 0, SYCALL_NOSYS, 6310 (sy_call_t *)rump_enosys }, /* 294 = __sigsuspend14 */ 6311 { 0, 0, 0, 6312 (sy_call_t *)rumpns_sys_nomodule }, /* 295 = __sigreturn14 */ 6313 { ns(struct sys___getcwd_args), 0, 6314 (sy_call_t *)rumpns_sys___getcwd }, /* 296 = __getcwd */ 6315 { ns(struct sys_fchroot_args), 0, 6316 (sy_call_t *)rumpns_sys_fchroot }, /* 297 = fchroot */ 6317 { 0, 0, 0, 6318 (sy_call_t *)rumpns_sys_nomodule }, /* 298 = fhopen */ 6319 { 0, 0, 0, 6320 (sy_call_t *)rumpns_sys_nomodule }, /* 299 = fhstat */ 6321 { 0, 0, 0, 6322 (sy_call_t *)rumpns_sys_nomodule }, /* 300 = fhstatfs */ 6323 #if defined(SYSVSEM) || !defined(_KERNEL_OPT) 6324 { 0, 0, 0, 6325 (sy_call_t *)rumpns_sys_nomodule }, /* 301 = ____semctl13 */ 6326 #else 6327 { 0, 0, SYCALL_NOSYS, 6328 (sy_call_t *)rump_enosys }, /* 301 = excluded ____semctl13 */ 6329 #endif 6330 #if defined(SYSVMSG) || !defined(_KERNEL_OPT) 6331 { 0, 0, 0, 6332 (sy_call_t *)rumpns_sys_nomodule }, /* 302 = __msgctl13 */ 6333 #else 6334 { 0, 0, SYCALL_NOSYS, 6335 (sy_call_t *)rump_enosys }, /* 302 = excluded __msgctl13 */ 6336 #endif 6337 #if defined(SYSVSHM) || !defined(_KERNEL_OPT) 6338 { 0, 0, 0, 6339 (sy_call_t *)rumpns_sys_nomodule }, /* 303 = __shmctl13 */ 6340 #else 6341 { 0, 0, SYCALL_NOSYS, 6342 (sy_call_t *)rump_enosys }, /* 303 = excluded __shmctl13 */ 6343 #endif 6344 { ns(struct sys_lchflags_args), 0, 6345 (sy_call_t *)rumpns_sys_lchflags }, /* 304 = lchflags */ 6346 { 0, 0, 0, 6347 (sy_call_t *)rumpns_sys_issetugid },/* 305 = issetugid */ 6348 { ns(struct sys_utrace_args), 0, 6349 (sy_call_t *)rumpns_sys_utrace }, /* 306 = utrace */ 6350 { 0, 0, SYCALL_NOSYS, 6351 (sy_call_t *)rump_enosys }, /* 307 = getcontext */ 6352 { 0, 0, SYCALL_NOSYS, 6353 (sy_call_t *)rump_enosys }, /* 308 = setcontext */ 6354 { 0, 0, SYCALL_NOSYS, 6355 (sy_call_t *)rump_enosys }, /* 309 = _lwp_create */ 6356 { 0, 0, SYCALL_NOSYS, 6357 (sy_call_t *)rump_enosys }, /* 310 = _lwp_exit */ 6358 { 0, 0, SYCALL_NOSYS, 6359 (sy_call_t *)rump_enosys }, /* 311 = _lwp_self */ 6360 { 0, 0, SYCALL_NOSYS, 6361 (sy_call_t *)rump_enosys }, /* 312 = _lwp_wait */ 6362 { 0, 0, SYCALL_NOSYS, 6363 (sy_call_t *)rump_enosys }, /* 313 = _lwp_suspend */ 6364 { 0, 0, SYCALL_NOSYS, 6365 (sy_call_t *)rump_enosys }, /* 314 = _lwp_continue */ 6366 { 0, 0, SYCALL_NOSYS, 6367 (sy_call_t *)rump_enosys }, /* 315 = _lwp_wakeup */ 6368 { 0, 0, SYCALL_NOSYS, 6369 (sy_call_t *)rump_enosys }, /* 316 = _lwp_getprivate */ 6370 { 0, 0, SYCALL_NOSYS, 6371 (sy_call_t *)rump_enosys }, /* 317 = _lwp_setprivate */ 6372 { 0, 0, SYCALL_NOSYS, 6373 (sy_call_t *)rump_enosys }, /* 318 = _lwp_kill */ 6374 { 0, 0, SYCALL_NOSYS, 6375 (sy_call_t *)rump_enosys }, /* 319 = _lwp_detach */ 6376 { 0, 0, 0, 6377 (sy_call_t *)rumpns_sys_nomodule }, /* 320 = _lwp_park */ 6378 { 0, 0, SYCALL_NOSYS, 6379 (sy_call_t *)rump_enosys }, /* 321 = _lwp_unpark */ 6380 { 0, 0, SYCALL_NOSYS, 6381 (sy_call_t *)rump_enosys }, /* 322 = _lwp_unpark_all */ 6382 { 0, 0, SYCALL_NOSYS, 6383 (sy_call_t *)rump_enosys }, /* 323 = _lwp_setname */ 6384 { 0, 0, SYCALL_NOSYS, 6385 (sy_call_t *)rump_enosys }, /* 324 = _lwp_getname */ 6386 { 0, 0, SYCALL_NOSYS, 6387 (sy_call_t *)rump_enosys }, /* 325 = _lwp_ctl */ 6388 { 0, 0, SYCALL_NOSYS, 6389 (sy_call_t *)rump_enosys }, /* 326 = unimplemented */ 6390 { 0, 0, SYCALL_NOSYS, 6391 (sy_call_t *)rump_enosys }, /* 327 = unimplemented */ 6392 { 0, 0, SYCALL_NOSYS, 6393 (sy_call_t *)rump_enosys }, /* 328 = unimplemented */ 6394 { 0, 0, SYCALL_NOSYS, 6395 (sy_call_t *)rump_enosys }, /* 329 = unimplemented */ 6396 { 0, 0, SYCALL_NOSYS, 6397 (sy_call_t *)rump_enosys }, /* 330 = sa_register */ 6398 { 0, 0, SYCALL_NOSYS, 6399 (sy_call_t *)rump_enosys }, /* 331 = sa_stacks */ 6400 { 0, 0, SYCALL_NOSYS, 6401 (sy_call_t *)rump_enosys }, /* 332 = sa_enable */ 6402 { 0, 0, SYCALL_NOSYS, 6403 (sy_call_t *)rump_enosys }, /* 333 = sa_setconcurrency */ 6404 { 0, 0, SYCALL_NOSYS, 6405 (sy_call_t *)rump_enosys }, /* 334 = sa_yield */ 6406 { 0, 0, SYCALL_NOSYS, 6407 (sy_call_t *)rump_enosys }, /* 335 = sa_preempt */ 6408 { 0, 0, SYCALL_NOSYS, 6409 (sy_call_t *)rump_enosys }, /* 336 = obsolete sys_sa_unblockyield */ 6410 { 0, 0, SYCALL_NOSYS, 6411 (sy_call_t *)rump_enosys }, /* 337 = unimplemented */ 6412 { 0, 0, SYCALL_NOSYS, 6413 (sy_call_t *)rump_enosys }, /* 338 = unimplemented */ 6414 { 0, 0, SYCALL_NOSYS, 6415 (sy_call_t *)rump_enosys }, /* 339 = unimplemented */ 6416 { 0, 0, SYCALL_NOSYS, 6417 (sy_call_t *)rump_enosys }, /* 340 = __sigaction_sigtramp */ 6418 { 0, 0, SYCALL_NOSYS, 6419 (sy_call_t *)rump_enosys }, /* 341 = pmc_get_info */ 6420 { 0, 0, SYCALL_NOSYS, 6421 (sy_call_t *)rump_enosys }, /* 342 = pmc_control */ 6422 { 0, 0, SYCALL_NOSYS, 6423 (sy_call_t *)rump_enosys }, /* 343 = rasctl */ 6424 { 0, 0, 0, 6425 (sy_call_t *)rumpns_sys_kqueue }, /* 344 = kqueue */ 6426 { ns(struct compat_50_sys_kevent_args), 0, 6427 (sy_call_t *)rumpns_compat_50_sys_kevent },/* 345 = compat_50_kevent */ 6428 { 0, 0, SYCALL_NOSYS, 6429 (sy_call_t *)rump_enosys }, /* 346 = _sched_setparam */ 6430 { 0, 0, SYCALL_NOSYS, 6431 (sy_call_t *)rump_enosys }, /* 347 = _sched_getparam */ 6432 { 0, 0, SYCALL_NOSYS, 6433 (sy_call_t *)rump_enosys }, /* 348 = _sched_setaffinity */ 6434 { 0, 0, SYCALL_NOSYS, 6435 (sy_call_t *)rump_enosys }, /* 349 = _sched_getaffinity */ 6436 { 0, 0, SYCALL_NOSYS, 6437 (sy_call_t *)rump_enosys }, /* 350 = sched_yield */ 6438 { 0, 0, SYCALL_NOSYS, 6439 (sy_call_t *)rump_enosys }, /* 351 = unimplemented */ 6440 { 0, 0, SYCALL_NOSYS, 6441 (sy_call_t *)rump_enosys }, /* 352 = unimplemented */ 6442 { 0, 0, SYCALL_NOSYS, 6443 (sy_call_t *)rump_enosys }, /* 353 = unimplemented */ 6444 { ns(struct sys_fsync_range_args), 0, 6445 (sy_call_t *)rumpns_sys_fsync_range },/* 354 = fsync_range */ 6446 { 0, 0, SYCALL_NOSYS, 6447 (sy_call_t *)rump_enosys }, /* 355 = uuidgen */ 6448 { ns(struct sys_getvfsstat_args), 0, 6449 (sy_call_t *)rumpns_sys_getvfsstat },/* 356 = getvfsstat */ 6450 { ns(struct sys_statvfs1_args), 0, 6451 (sy_call_t *)rumpns_sys_statvfs1 }, /* 357 = statvfs1 */ 6452 { ns(struct sys_fstatvfs1_args), 0, 6453 (sy_call_t *)rumpns_sys_fstatvfs1 },/* 358 = fstatvfs1 */ 6454 { 0, 0, 0, 6455 (sy_call_t *)rumpns_sys_nomodule }, /* 359 = fhstatvfs1 */ 6456 { ns(struct sys_extattrctl_args), 0, 6457 (sy_call_t *)rumpns_sys_extattrctl },/* 360 = extattrctl */ 6458 { ns(struct sys_extattr_set_file_args), 0, 6459 (sy_call_t *)rumpns_sys_extattr_set_file },/* 361 = extattr_set_file */ 6460 { ns(struct sys_extattr_get_file_args), 0, 6461 (sy_call_t *)rumpns_sys_extattr_get_file },/* 362 = extattr_get_file */ 6462 { ns(struct sys_extattr_delete_file_args), 0, 6463 (sy_call_t *)rumpns_sys_extattr_delete_file },/* 363 = extattr_delete_file */ 6464 { ns(struct sys_extattr_set_fd_args), 0, 6465 (sy_call_t *)rumpns_sys_extattr_set_fd },/* 364 = extattr_set_fd */ 6466 { ns(struct sys_extattr_get_fd_args), 0, 6467 (sy_call_t *)rumpns_sys_extattr_get_fd },/* 365 = extattr_get_fd */ 6468 { ns(struct sys_extattr_delete_fd_args), 0, 6469 (sy_call_t *)rumpns_sys_extattr_delete_fd },/* 366 = extattr_delete_fd */ 6470 { ns(struct sys_extattr_set_link_args), 0, 6471 (sy_call_t *)rumpns_sys_extattr_set_link },/* 367 = extattr_set_link */ 6472 { ns(struct sys_extattr_get_link_args), 0, 6473 (sy_call_t *)rumpns_sys_extattr_get_link },/* 368 = extattr_get_link */ 6474 { ns(struct sys_extattr_delete_link_args), 0, 6475 (sy_call_t *)rumpns_sys_extattr_delete_link },/* 369 = extattr_delete_link */ 6476 { ns(struct sys_extattr_list_fd_args), 0, 6477 (sy_call_t *)rumpns_sys_extattr_list_fd },/* 370 = extattr_list_fd */ 6478 { ns(struct sys_extattr_list_file_args), 0, 6479 (sy_call_t *)rumpns_sys_extattr_list_file },/* 371 = extattr_list_file */ 6480 { ns(struct sys_extattr_list_link_args), 0, 6481 (sy_call_t *)rumpns_sys_extattr_list_link },/* 372 = extattr_list_link */ 6482 { ns(struct compat_50_sys_pselect_args), 0, 6483 (sy_call_t *)rumpns_compat_50_sys_pselect },/* 373 = compat_50_pselect */ 6484 { ns(struct compat_50_sys_pollts_args), 0, 6485 (sy_call_t *)rumpns_compat_50_sys_pollts },/* 374 = compat_50_pollts */ 6486 { ns(struct sys_setxattr_args), 0, 6487 (sy_call_t *)rumpns_sys_setxattr }, /* 375 = setxattr */ 6488 { ns(struct sys_lsetxattr_args), 0, 6489 (sy_call_t *)rumpns_sys_lsetxattr },/* 376 = lsetxattr */ 6490 { ns(struct sys_fsetxattr_args), 0, 6491 (sy_call_t *)rumpns_sys_fsetxattr },/* 377 = fsetxattr */ 6492 { ns(struct sys_getxattr_args), 0, 6493 (sy_call_t *)rumpns_sys_getxattr }, /* 378 = getxattr */ 6494 { ns(struct sys_lgetxattr_args), 0, 6495 (sy_call_t *)rumpns_sys_lgetxattr },/* 379 = lgetxattr */ 6496 { ns(struct sys_fgetxattr_args), 0, 6497 (sy_call_t *)rumpns_sys_fgetxattr },/* 380 = fgetxattr */ 6498 { ns(struct sys_listxattr_args), 0, 6499 (sy_call_t *)rumpns_sys_listxattr },/* 381 = listxattr */ 6500 { ns(struct sys_llistxattr_args), 0, 6501 (sy_call_t *)rumpns_sys_llistxattr },/* 382 = llistxattr */ 6502 { ns(struct sys_flistxattr_args), 0, 6503 (sy_call_t *)rumpns_sys_flistxattr },/* 383 = flistxattr */ 6504 { ns(struct sys_removexattr_args), 0, 6505 (sy_call_t *)rumpns_sys_removexattr },/* 384 = removexattr */ 6506 { ns(struct sys_lremovexattr_args), 0, 6507 (sy_call_t *)rumpns_sys_lremovexattr },/* 385 = lremovexattr */ 6508 { ns(struct sys_fremovexattr_args), 0, 6509 (sy_call_t *)rumpns_sys_fremovexattr },/* 386 = fremovexattr */ 6510 { ns(struct compat_50_sys___stat30_args), 0, 6511 (sy_call_t *)rumpns_compat_50_sys___stat30 },/* 387 = compat_50___stat30 */ 6512 { ns(struct compat_50_sys___fstat30_args), 0, 6513 (sy_call_t *)rumpns_compat_50_sys___fstat30 },/* 388 = compat_50___fstat30 */ 6514 { ns(struct compat_50_sys___lstat30_args), 0, 6515 (sy_call_t *)rumpns_compat_50_sys___lstat30 },/* 389 = compat_50___lstat30 */ 6516 { ns(struct sys___getdents30_args), 0, 6517 (sy_call_t *)rumpns_sys___getdents30 },/* 390 = __getdents30 */ 6518 { 0, 0, SYCALL_NOSYS, 6519 (sy_call_t *)rump_enosys }, /* 391 = ignored old posix_fadvise */ 6520 { 0, 0, 0, 6521 (sy_call_t *)rumpns_sys_nomodule }, /* 392 = __fhstat30 */ 6522 { 0, 0, 0, 6523 (sy_call_t *)rumpns_sys_nomodule }, /* 393 = __ntp_gettime30 */ 6524 { ns(struct sys___socket30_args), 0, 6525 (sy_call_t *)rumpns_sys___socket30 },/* 394 = __socket30 */ 6526 { ns(struct sys___getfh30_args), 0, 6527 (sy_call_t *)rumpns_sys___getfh30 },/* 395 = __getfh30 */ 6528 { ns(struct sys___fhopen40_args), 0, 6529 (sy_call_t *)rumpns_sys___fhopen40 },/* 396 = __fhopen40 */ 6530 { ns(struct sys___fhstatvfs140_args), 0, 6531 (sy_call_t *)rumpns_sys___fhstatvfs140 },/* 397 = __fhstatvfs140 */ 6532 { ns(struct compat_50_sys___fhstat40_args), 0, 6533 (sy_call_t *)rumpns_compat_50_sys___fhstat40 },/* 398 = compat_50___fhstat40 */ 6534 { ns(struct sys_aio_cancel_args), 0, 6535 (sy_call_t *)rumpns_sys_nomodule }, /* 399 = aio_cancel */ 6536 { ns(struct sys_aio_error_args), 0, 6537 (sy_call_t *)rumpns_sys_nomodule }, /* 400 = aio_error */ 6538 { ns(struct sys_aio_fsync_args), 0, 6539 (sy_call_t *)rumpns_sys_nomodule }, /* 401 = aio_fsync */ 6540 { ns(struct sys_aio_read_args), 0, 6541 (sy_call_t *)rumpns_sys_nomodule }, /* 402 = aio_read */ 6542 { ns(struct sys_aio_return_args), 0, 6543 (sy_call_t *)rumpns_sys_nomodule }, /* 403 = aio_return */ 6544 { 0, 0, 0, 6545 (sy_call_t *)rumpns_sys_nomodule }, /* 404 = aio_suspend */ 6546 { ns(struct sys_aio_write_args), 0, 6547 (sy_call_t *)rumpns_sys_nomodule }, /* 405 = aio_write */ 6548 { ns(struct sys_lio_listio_args), 0, 6549 (sy_call_t *)rumpns_sys_nomodule }, /* 406 = lio_listio */ 6550 { 0, 0, SYCALL_NOSYS, 6551 (sy_call_t *)rump_enosys }, /* 407 = unimplemented */ 6552 { 0, 0, SYCALL_NOSYS, 6553 (sy_call_t *)rump_enosys }, /* 408 = unimplemented */ 6554 { 0, 0, SYCALL_NOSYS, 6555 (sy_call_t *)rump_enosys }, /* 409 = unimplemented */ 6556 { ns(struct sys___mount50_args), 0, 6557 (sy_call_t *)rumpns_sys___mount50 },/* 410 = __mount50 */ 6558 { 0, 0, SYCALL_NOSYS, 6559 (sy_call_t *)rump_enosys }, /* 411 = mremap */ 6560 { 0, 0, SYCALL_NOSYS, 6561 (sy_call_t *)rump_enosys }, /* 412 = pset_create */ 6562 { 0, 0, SYCALL_NOSYS, 6563 (sy_call_t *)rump_enosys }, /* 413 = pset_destroy */ 6564 { 0, 0, SYCALL_NOSYS, 6565 (sy_call_t *)rump_enosys }, /* 414 = pset_assign */ 6566 { 0, 0, SYCALL_NOSYS, 6567 (sy_call_t *)rump_enosys }, /* 415 = _pset_bind */ 6568 { ns(struct sys___posix_fadvise50_args), 0, 6569 (sy_call_t *)rumpns_sys___posix_fadvise50 },/* 416 = __posix_fadvise50 */ 6570 { ns(struct sys___select50_args), 0, 6571 (sy_call_t *)rumpns_sys___select50 },/* 417 = __select50 */ 6572 { ns(struct sys___gettimeofday50_args), 0, 6573 (sy_call_t *)rumpns_sys___gettimeofday50 },/* 418 = __gettimeofday50 */ 6574 { ns(struct sys___settimeofday50_args), 0, 6575 (sy_call_t *)rumpns_sys___settimeofday50 },/* 419 = __settimeofday50 */ 6576 { ns(struct sys___utimes50_args), 0, 6577 (sy_call_t *)rumpns_sys___utimes50 },/* 420 = __utimes50 */ 6578 { ns(struct sys___adjtime50_args), 0, 6579 (sy_call_t *)rumpns_sys___adjtime50 },/* 421 = __adjtime50 */ 6580 { 0, 0, 0, 6581 (sy_call_t *)rumpns_sys_nomodule }, /* 422 = __lfs_segwait50 */ 6582 { ns(struct sys___futimes50_args), 0, 6583 (sy_call_t *)rumpns_sys___futimes50 },/* 423 = __futimes50 */ 6584 { ns(struct sys___lutimes50_args), 0, 6585 (sy_call_t *)rumpns_sys___lutimes50 },/* 424 = __lutimes50 */ 6586 { ns(struct sys___setitimer50_args), 0, 6587 (sy_call_t *)rumpns_sys___setitimer50 },/* 425 = __setitimer50 */ 6588 { ns(struct sys___getitimer50_args), 0, 6589 (sy_call_t *)rumpns_sys___getitimer50 },/* 426 = __getitimer50 */ 6590 { ns(struct sys___clock_gettime50_args), 0, 6591 (sy_call_t *)rumpns_sys___clock_gettime50 },/* 427 = __clock_gettime50 */ 6592 { ns(struct sys___clock_settime50_args), 0, 6593 (sy_call_t *)rumpns_sys___clock_settime50 },/* 428 = __clock_settime50 */ 6594 { ns(struct sys___clock_getres50_args), 0, 6595 (sy_call_t *)rumpns_sys___clock_getres50 },/* 429 = __clock_getres50 */ 6596 { ns(struct sys___nanosleep50_args), 0, 6597 (sy_call_t *)rumpns_sys___nanosleep50 },/* 430 = __nanosleep50 */ 6598 { 0, 0, SYCALL_NOSYS, 6599 (sy_call_t *)rump_enosys }, /* 431 = ____sigtimedwait50 */ 6600 { 0, 0, 0, 6601 (sy_call_t *)rumpns_sys_nomodule }, /* 432 = __mq_timedsend50 */ 6602 { 0, 0, 0, 6603 (sy_call_t *)rumpns_sys_nomodule }, /* 433 = __mq_timedreceive50 */ 6604 { 0, 0, 0, 6605 (sy_call_t *)rumpns_sys_nomodule }, /* 434 = _lwp_park */ 6606 { ns(struct sys___kevent50_args), 0, 6607 (sy_call_t *)rumpns_sys___kevent50 },/* 435 = __kevent50 */ 6608 { ns(struct sys___pselect50_args), 0, 6609 (sy_call_t *)rumpns_sys___pselect50 },/* 436 = __pselect50 */ 6610 { ns(struct sys___pollts50_args), 0, 6611 (sy_call_t *)rumpns_sys___pollts50 },/* 437 = __pollts50 */ 6612 { ns(struct sys___aio_suspend50_args), 0, 6613 (sy_call_t *)rumpns_sys_nomodule }, /* 438 = __aio_suspend50 */ 6614 { ns(struct sys___stat50_args), 0, 6615 (sy_call_t *)rumpns_sys___stat50 }, /* 439 = __stat50 */ 6616 { ns(struct sys___fstat50_args), 0, 6617 (sy_call_t *)rumpns_sys___fstat50 },/* 440 = __fstat50 */ 6618 { ns(struct sys___lstat50_args), 0, 6619 (sy_call_t *)rumpns_sys___lstat50 },/* 441 = __lstat50 */ 6620 #if defined(SYSVSEM) || !defined(_KERNEL_OPT) 6621 { 0, 0, SYCALL_NOSYS, 6622 (sy_call_t *)rump_enosys }, /* 442 = ____semctl50 */ 6623 #else 6624 { 0, 0, SYCALL_NOSYS, 6625 (sy_call_t *)rump_enosys }, /* 442 = excluded ____semctl50 */ 6626 #endif 6627 #if defined(SYSVSHM) || !defined(_KERNEL_OPT) 6628 { 0, 0, SYCALL_NOSYS, 6629 (sy_call_t *)rump_enosys }, /* 443 = __shmctl50 */ 6630 #else 6631 { 0, 0, SYCALL_NOSYS, 6632 (sy_call_t *)rump_enosys }, /* 443 = excluded ____shmctl50 */ 6633 #endif 6634 #if defined(SYSVMSG) || !defined(_KERNEL_OPT) 6635 { 0, 0, SYCALL_NOSYS, 6636 (sy_call_t *)rump_enosys }, /* 444 = __msgctl50 */ 6637 #else 6638 { 0, 0, SYCALL_NOSYS, 6639 (sy_call_t *)rump_enosys }, /* 444 = excluded ____msgctl50 */ 6640 #endif 6641 { 0, 0, SYCALL_NOSYS, 6642 (sy_call_t *)rump_enosys }, /* 445 = __getrusage50 */ 6643 { ns(struct sys___timer_settime50_args), 0, 6644 (sy_call_t *)rumpns_sys___timer_settime50 },/* 446 = __timer_settime50 */ 6645 { ns(struct sys___timer_gettime50_args), 0, 6646 (sy_call_t *)rumpns_sys___timer_gettime50 },/* 447 = __timer_gettime50 */ 6647 #if defined(NTP) || !defined(_KERNEL_OPT) 6648 { 0, 0, SYCALL_NOSYS, 6649 (sy_call_t *)rump_enosys }, /* 448 = __ntp_gettime50 */ 6650 #else 6651 { 0, 0, SYCALL_NOSYS, 6652 (sy_call_t *)rump_enosys }, /* 448 = excluded ___ntp_gettime50 */ 6653 #endif 6654 { 0, 0, SYCALL_NOSYS, 6655 (sy_call_t *)rump_enosys }, /* 449 = __wait450 */ 6656 { ns(struct sys___mknod50_args), 0, 6657 (sy_call_t *)rumpns_sys___mknod50 },/* 450 = __mknod50 */ 6658 { ns(struct sys___fhstat50_args), 0, 6659 (sy_call_t *)rumpns_sys___fhstat50 },/* 451 = __fhstat50 */ 6660 { 0, 0, SYCALL_NOSYS, 6661 (sy_call_t *)rump_enosys }, /* 452 = obsolete 5.99 quotactl */ 6662 { ns(struct sys_pipe2_args), 0, 6663 (sy_call_t *)rumpns_sys_pipe2 }, /* 453 = pipe2 */ 6664 { ns(struct sys_dup3_args), 0, 6665 (sy_call_t *)rumpns_sys_dup3 }, /* 454 = dup3 */ 6666 { ns(struct sys_kqueue1_args), 0, 6667 (sy_call_t *)rumpns_sys_kqueue1 }, /* 455 = kqueue1 */ 6668 { ns(struct sys_paccept_args), 0, 6669 (sy_call_t *)rumpns_sys_paccept }, /* 456 = paccept */ 6670 { ns(struct sys_linkat_args), 0, 6671 (sy_call_t *)rumpns_sys_linkat }, /* 457 = linkat */ 6672 { ns(struct sys_renameat_args), 0, 6673 (sy_call_t *)rumpns_sys_renameat }, /* 458 = renameat */ 6674 { ns(struct sys_mkfifoat_args), 0, 6675 (sy_call_t *)rumpns_sys_mkfifoat }, /* 459 = mkfifoat */ 6676 { ns(struct sys_mknodat_args), 0, 6677 (sy_call_t *)rumpns_sys_mknodat }, /* 460 = mknodat */ 6678 { ns(struct sys_mkdirat_args), 0, 6679 (sy_call_t *)rumpns_sys_mkdirat }, /* 461 = mkdirat */ 6680 { ns(struct sys_faccessat_args), 0, 6681 (sy_call_t *)rumpns_sys_faccessat },/* 462 = faccessat */ 6682 { ns(struct sys_fchmodat_args), 0, 6683 (sy_call_t *)rumpns_sys_fchmodat }, /* 463 = fchmodat */ 6684 { ns(struct sys_fchownat_args), 0, 6685 (sy_call_t *)rumpns_sys_fchownat }, /* 464 = fchownat */ 6686 { 0, 0, SYCALL_NOSYS, 6687 (sy_call_t *)rump_enosys }, /* 465 = fexecve */ 6688 { ns(struct sys_fstatat_args), 0, 6689 (sy_call_t *)rumpns_sys_fstatat }, /* 466 = fstatat */ 6690 { ns(struct sys_utimensat_args), 0, 6691 (sy_call_t *)rumpns_sys_utimensat },/* 467 = utimensat */ 6692 { ns(struct sys_openat_args), 0, 6693 (sy_call_t *)rumpns_sys_openat }, /* 468 = openat */ 6694 { ns(struct sys_readlinkat_args), 0, 6695 (sy_call_t *)rumpns_sys_readlinkat },/* 469 = readlinkat */ 6696 { ns(struct sys_symlinkat_args), 0, 6697 (sy_call_t *)rumpns_sys_symlinkat },/* 470 = symlinkat */ 6698 { ns(struct sys_unlinkat_args), 0, 6699 (sy_call_t *)rumpns_sys_unlinkat }, /* 471 = unlinkat */ 6700 { ns(struct sys_futimens_args), 0, 6701 (sy_call_t *)rumpns_sys_futimens }, /* 472 = futimens */ 6702 { ns(struct sys___quotactl_args), 0, 6703 (sy_call_t *)rumpns_sys___quotactl },/* 473 = __quotactl */ 6704 { 0, 0, SYCALL_NOSYS, 6705 (sy_call_t *)rump_enosys }, /* 474 = posix_spawn */ 6706 { ns(struct sys_recvmmsg_args), 0, 6707 (sy_call_t *)rumpns_sys_recvmmsg }, /* 475 = recvmmsg */ 6708 { ns(struct sys_sendmmsg_args), 0, 6709 (sy_call_t *)rumpns_sys_sendmmsg }, /* 476 = sendmmsg */ 6710 { ns(struct sys_clock_nanosleep_args), 0, 6711 (sy_call_t *)rumpns_sys_clock_nanosleep },/* 477 = clock_nanosleep */ 6712 { 0, 0, SYCALL_NOSYS, 6713 (sy_call_t *)rump_enosys }, /* 478 = ___lwp_park60 */ 6714 { 0, 0, SYCALL_NOSYS, 6715 (sy_call_t *)rump_enosys }, /* 479 = filler */ 6716 { 0, 0, SYCALL_NOSYS, 6717 (sy_call_t *)rump_enosys }, /* 480 = filler */ 6718 { 0, 0, SYCALL_NOSYS, 6719 (sy_call_t *)rump_enosys }, /* 481 = filler */ 6720 { 0, 0, SYCALL_NOSYS, 6721 (sy_call_t *)rump_enosys }, /* 482 = filler */ 6722 { 0, 0, SYCALL_NOSYS, 6723 (sy_call_t *)rump_enosys }, /* 483 = filler */ 6724 { 0, 0, SYCALL_NOSYS, 6725 (sy_call_t *)rump_enosys }, /* 484 = filler */ 6726 { 0, 0, SYCALL_NOSYS, 6727 (sy_call_t *)rump_enosys }, /* 485 = filler */ 6728 { 0, 0, SYCALL_NOSYS, 6729 (sy_call_t *)rump_enosys }, /* 486 = filler */ 6730 { 0, 0, SYCALL_NOSYS, 6731 (sy_call_t *)rump_enosys }, /* 487 = filler */ 6732 { 0, 0, SYCALL_NOSYS, 6733 (sy_call_t *)rump_enosys }, /* 488 = filler */ 6734 { 0, 0, SYCALL_NOSYS, 6735 (sy_call_t *)rump_enosys }, /* 489 = filler */ 6736 { 0, 0, SYCALL_NOSYS, 6737 (sy_call_t *)rump_enosys }, /* 490 = filler */ 6738 { 0, 0, SYCALL_NOSYS, 6739 (sy_call_t *)rump_enosys }, /* 491 = filler */ 6740 { 0, 0, SYCALL_NOSYS, 6741 (sy_call_t *)rump_enosys }, /* 492 = filler */ 6742 { 0, 0, SYCALL_NOSYS, 6743 (sy_call_t *)rump_enosys }, /* 493 = filler */ 6744 { 0, 0, SYCALL_NOSYS, 6745 (sy_call_t *)rump_enosys }, /* 494 = filler */ 6746 { 0, 0, SYCALL_NOSYS, 6747 (sy_call_t *)rump_enosys }, /* 495 = filler */ 6748 { 0, 0, SYCALL_NOSYS, 6749 (sy_call_t *)rump_enosys }, /* 496 = filler */ 6750 { 0, 0, SYCALL_NOSYS, 6751 (sy_call_t *)rump_enosys }, /* 497 = filler */ 6752 { 0, 0, SYCALL_NOSYS, 6753 (sy_call_t *)rump_enosys }, /* 498 = filler */ 6754 { 0, 0, SYCALL_NOSYS, 6755 (sy_call_t *)rump_enosys }, /* 499 = filler */ 6756 { 0, 0, SYCALL_NOSYS, 6757 (sy_call_t *)rump_enosys }, /* 500 = filler */ 6758 { 0, 0, SYCALL_NOSYS, 6759 (sy_call_t *)rump_enosys }, /* 501 = filler */ 6760 { 0, 0, SYCALL_NOSYS, 6761 (sy_call_t *)rump_enosys }, /* 502 = filler */ 6762 { 0, 0, SYCALL_NOSYS, 6763 (sy_call_t *)rump_enosys }, /* 503 = filler */ 6764 { 0, 0, SYCALL_NOSYS, 6765 (sy_call_t *)rump_enosys }, /* 504 = filler */ 6766 { 0, 0, SYCALL_NOSYS, 6767 (sy_call_t *)rump_enosys }, /* 505 = filler */ 6768 { 0, 0, SYCALL_NOSYS, 6769 (sy_call_t *)rump_enosys }, /* 506 = filler */ 6770 { 0, 0, SYCALL_NOSYS, 6771 (sy_call_t *)rump_enosys }, /* 507 = filler */ 6772 { 0, 0, SYCALL_NOSYS, 6773 (sy_call_t *)rump_enosys }, /* 508 = filler */ 6774 { 0, 0, SYCALL_NOSYS, 6775 (sy_call_t *)rump_enosys }, /* 509 = filler */ 6776 { 0, 0, SYCALL_NOSYS, 6777 (sy_call_t *)rump_enosys }, /* 510 = filler */ 6778 { 0, 0, SYCALL_NOSYS, 6779 (sy_call_t *)rump_enosys }, /* 511 = filler */ 6780 }; 6781 CTASSERT(__arraycount(rump_sysent) == SYS_NSYSENT); 6782 __strong_alias(rumpns_sysent,rump_sysent); 6783 #endif /* RUMP_CLIENT */ 6784
Indexes created Wed Oct 01 12:09:54 GMT 2025