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