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