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