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