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