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