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