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