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