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