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