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