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