rump_syscalls.c revision 1.28
1 /* $NetBSD: rump_syscalls.c,v 1.28 2009/01/26 12:21:24 pooka Exp $ */ 2 3 /* 4 * System call marshalling for rump. 5 * 6 * DO NOT EDIT-- this file is automatically generated. 7 * created from NetBSD: syscalls.master,v 1.222 2009/01/26 12:20:05 pooka Exp 8 */ 9 10 #include <sys/cdefs.h> 11 __KERNEL_RCSID(0, "$NetBSD: rump_syscalls.c,v 1.28 2009/01/26 12:21:24 pooka Exp $"); 12 13 #include <sys/types.h> 14 #include <sys/param.h> 15 #include <sys/proc.h> 16 #include <sys/syscallargs.h> 17 #include <rump/rumpuser.h> 18 #include "rump_private.h" 19 20 #if BYTE_ORDER == BIG_ENDIAN 21 #define SPARG(p,k) ((p)->k.be.datum) 22 #else /* LITTLE_ENDIAN, I hope dearly */ 23 #define SPARG(p,k) ((p)->k.le.datum) 24 #endif 25 26 int rump_enosys(void); 27 int 28 rump_enosys() 29 { 30 31 return ENOSYS; 32 } 33 34 ssize_t rump_sys_read(int, void *, size_t); 35 ssize_t 36 rump_sys_read(int fd, void * buf, size_t nbyte) 37 { 38 register_t retval = 0; 39 int error = 0; 40 struct sys_read_args arg; 41 42 SPARG(&arg, fd) = fd; 43 SPARG(&arg, buf) = buf; 44 SPARG(&arg, nbyte) = nbyte; 45 46 error = sys_read(curlwp, &arg, &retval); 47 if (error) { 48 retval = -1; 49 rumpuser_seterrno(error); 50 } 51 return retval; 52 } 53 __weak_alias(sys_read,rump_enosys); 54 55 ssize_t rump_sys_write(int, const void *, size_t); 56 ssize_t 57 rump_sys_write(int fd, const void * buf, size_t nbyte) 58 { 59 register_t retval = 0; 60 int error = 0; 61 struct sys_write_args arg; 62 63 SPARG(&arg, fd) = fd; 64 SPARG(&arg, buf) = buf; 65 SPARG(&arg, nbyte) = nbyte; 66 67 error = sys_write(curlwp, &arg, &retval); 68 if (error) { 69 retval = -1; 70 rumpuser_seterrno(error); 71 } 72 return retval; 73 } 74 __weak_alias(sys_write,rump_enosys); 75 76 int rump_sys_open(const char *, int, mode_t); 77 int 78 rump_sys_open(const char * path, int flags, mode_t mode) 79 { 80 register_t retval = 0; 81 int error = 0; 82 struct sys_open_args arg; 83 84 SPARG(&arg, path) = path; 85 SPARG(&arg, flags) = flags; 86 SPARG(&arg, mode) = mode; 87 88 error = sys_open(curlwp, &arg, &retval); 89 if (error) { 90 retval = -1; 91 rumpuser_seterrno(error); 92 } 93 return retval; 94 } 95 __weak_alias(sys_open,rump_enosys); 96 97 int rump_sys_close(int); 98 int 99 rump_sys_close(int fd) 100 { 101 register_t retval = 0; 102 int error = 0; 103 struct sys_close_args arg; 104 105 SPARG(&arg, fd) = fd; 106 107 error = sys_close(curlwp, &arg, &retval); 108 if (error) { 109 retval = -1; 110 rumpuser_seterrno(error); 111 } 112 return retval; 113 } 114 __weak_alias(sys_close,rump_enosys); 115 116 int rump_sys_link(const char *, const char *); 117 int 118 rump_sys_link(const char * path, const char * link) 119 { 120 register_t retval = 0; 121 int error = 0; 122 struct sys_link_args arg; 123 124 SPARG(&arg, path) = path; 125 SPARG(&arg, link) = link; 126 127 error = sys_link(curlwp, &arg, &retval); 128 if (error) { 129 retval = -1; 130 rumpuser_seterrno(error); 131 } 132 return retval; 133 } 134 __weak_alias(sys_link,rump_enosys); 135 136 int rump_sys_unlink(const char *); 137 int 138 rump_sys_unlink(const char * path) 139 { 140 register_t retval = 0; 141 int error = 0; 142 struct sys_unlink_args arg; 143 144 SPARG(&arg, path) = path; 145 146 error = sys_unlink(curlwp, &arg, &retval); 147 if (error) { 148 retval = -1; 149 rumpuser_seterrno(error); 150 } 151 return retval; 152 } 153 __weak_alias(sys_unlink,rump_enosys); 154 155 int rump_sys_chdir(const char *); 156 int 157 rump_sys_chdir(const char * path) 158 { 159 register_t retval = 0; 160 int error = 0; 161 struct sys_chdir_args arg; 162 163 SPARG(&arg, path) = path; 164 165 error = sys_chdir(curlwp, &arg, &retval); 166 if (error) { 167 retval = -1; 168 rumpuser_seterrno(error); 169 } 170 return retval; 171 } 172 __weak_alias(sys_chdir,rump_enosys); 173 174 int rump_sys_fchdir(int); 175 int 176 rump_sys_fchdir(int fd) 177 { 178 register_t retval = 0; 179 int error = 0; 180 struct sys_fchdir_args arg; 181 182 SPARG(&arg, fd) = fd; 183 184 error = sys_fchdir(curlwp, &arg, &retval); 185 if (error) { 186 retval = -1; 187 rumpuser_seterrno(error); 188 } 189 return retval; 190 } 191 __weak_alias(sys_fchdir,rump_enosys); 192 193 int rump_sys_chmod(const char *, mode_t); 194 int 195 rump_sys_chmod(const char * path, mode_t mode) 196 { 197 register_t retval = 0; 198 int error = 0; 199 struct sys_chmod_args arg; 200 201 SPARG(&arg, path) = path; 202 SPARG(&arg, mode) = mode; 203 204 error = sys_chmod(curlwp, &arg, &retval); 205 if (error) { 206 retval = -1; 207 rumpuser_seterrno(error); 208 } 209 return retval; 210 } 211 __weak_alias(sys_chmod,rump_enosys); 212 213 int rump_sys_chown(const char *, uid_t, gid_t); 214 int 215 rump_sys_chown(const char * path, uid_t uid, gid_t gid) 216 { 217 register_t retval = 0; 218 int error = 0; 219 struct sys_chown_args arg; 220 221 SPARG(&arg, path) = path; 222 SPARG(&arg, uid) = uid; 223 SPARG(&arg, gid) = gid; 224 225 error = sys_chown(curlwp, &arg, &retval); 226 if (error) { 227 retval = -1; 228 rumpuser_seterrno(error); 229 } 230 return retval; 231 } 232 __weak_alias(sys_chown,rump_enosys); 233 234 int rump_sys_unmount(const char *, int); 235 int 236 rump_sys_unmount(const char * path, int flags) 237 { 238 register_t retval = 0; 239 int error = 0; 240 struct sys_unmount_args arg; 241 242 SPARG(&arg, path) = path; 243 SPARG(&arg, flags) = flags; 244 245 error = sys_unmount(curlwp, &arg, &retval); 246 if (error) { 247 retval = -1; 248 rumpuser_seterrno(error); 249 } 250 return retval; 251 } 252 __weak_alias(sys_unmount,rump_enosys); 253 254 ssize_t rump_sys_recvmsg(int, struct msghdr *, int); 255 ssize_t 256 rump_sys_recvmsg(int s, struct msghdr * msg, int flags) 257 { 258 register_t retval = 0; 259 int error = 0; 260 struct sys_recvmsg_args arg; 261 262 SPARG(&arg, s) = s; 263 SPARG(&arg, msg) = msg; 264 SPARG(&arg, flags) = flags; 265 266 error = sys_recvmsg(curlwp, &arg, &retval); 267 if (error) { 268 retval = -1; 269 rumpuser_seterrno(error); 270 } 271 return retval; 272 } 273 __weak_alias(sys_recvmsg,rump_enosys); 274 275 ssize_t rump_sys_sendmsg(int, const struct msghdr *, int); 276 ssize_t 277 rump_sys_sendmsg(int s, const struct msghdr * msg, int flags) 278 { 279 register_t retval = 0; 280 int error = 0; 281 struct sys_sendmsg_args arg; 282 283 SPARG(&arg, s) = s; 284 SPARG(&arg, msg) = msg; 285 SPARG(&arg, flags) = flags; 286 287 error = sys_sendmsg(curlwp, &arg, &retval); 288 if (error) { 289 retval = -1; 290 rumpuser_seterrno(error); 291 } 292 return retval; 293 } 294 __weak_alias(sys_sendmsg,rump_enosys); 295 296 ssize_t rump_sys_recvfrom(int, void *, size_t, int, struct sockaddr *, unsigned int *); 297 ssize_t 298 rump_sys_recvfrom(int s, void * buf, size_t len, int flags, struct sockaddr * from, unsigned int * fromlenaddr) 299 { 300 register_t retval = 0; 301 int error = 0; 302 struct sys_recvfrom_args arg; 303 304 SPARG(&arg, s) = s; 305 SPARG(&arg, buf) = buf; 306 SPARG(&arg, len) = len; 307 SPARG(&arg, flags) = flags; 308 SPARG(&arg, from) = from; 309 SPARG(&arg, fromlenaddr) = fromlenaddr; 310 311 error = sys_recvfrom(curlwp, &arg, &retval); 312 if (error) { 313 retval = -1; 314 rumpuser_seterrno(error); 315 } 316 return retval; 317 } 318 __weak_alias(sys_recvfrom,rump_enosys); 319 320 int rump_sys_accept(int, struct sockaddr *, unsigned int *); 321 int 322 rump_sys_accept(int s, struct sockaddr * name, unsigned int * anamelen) 323 { 324 register_t retval = 0; 325 int error = 0; 326 struct sys_accept_args arg; 327 328 SPARG(&arg, s) = s; 329 SPARG(&arg, name) = name; 330 SPARG(&arg, anamelen) = anamelen; 331 332 error = sys_accept(curlwp, &arg, &retval); 333 if (error) { 334 retval = -1; 335 rumpuser_seterrno(error); 336 } 337 return retval; 338 } 339 __weak_alias(sys_accept,rump_enosys); 340 341 int rump_sys_getpeername(int, struct sockaddr *, unsigned int *); 342 int 343 rump_sys_getpeername(int fdes, struct sockaddr * asa, unsigned int * alen) 344 { 345 register_t retval = 0; 346 int error = 0; 347 struct sys_getpeername_args arg; 348 349 SPARG(&arg, fdes) = fdes; 350 SPARG(&arg, asa) = asa; 351 SPARG(&arg, alen) = alen; 352 353 error = sys_getpeername(curlwp, &arg, &retval); 354 if (error) { 355 retval = -1; 356 rumpuser_seterrno(error); 357 } 358 return retval; 359 } 360 __weak_alias(sys_getpeername,rump_enosys); 361 362 int rump_sys_getsockname(int, struct sockaddr *, unsigned int *); 363 int 364 rump_sys_getsockname(int fdes, struct sockaddr * asa, unsigned int * alen) 365 { 366 register_t retval = 0; 367 int error = 0; 368 struct sys_getsockname_args arg; 369 370 SPARG(&arg, fdes) = fdes; 371 SPARG(&arg, asa) = asa; 372 SPARG(&arg, alen) = alen; 373 374 error = sys_getsockname(curlwp, &arg, &retval); 375 if (error) { 376 retval = -1; 377 rumpuser_seterrno(error); 378 } 379 return retval; 380 } 381 __weak_alias(sys_getsockname,rump_enosys); 382 383 int rump_sys_chflags(const char *, u_long); 384 int 385 rump_sys_chflags(const char * path, u_long flags) 386 { 387 register_t retval = 0; 388 int error = 0; 389 struct sys_chflags_args arg; 390 391 SPARG(&arg, path) = path; 392 SPARG(&arg, flags) = flags; 393 394 error = sys_chflags(curlwp, &arg, &retval); 395 if (error) { 396 retval = -1; 397 rumpuser_seterrno(error); 398 } 399 return retval; 400 } 401 __weak_alias(sys_chflags,rump_enosys); 402 403 void rump_sys_sync(void); 404 void 405 rump_sys_sync(void ) 406 { 407 register_t retval = 0; 408 int error = 0; 409 410 error = sys_sync(curlwp, NULL, &retval); 411 if (error) { 412 retval = -1; 413 } 414 } 415 __weak_alias(sys_sync,rump_enosys); 416 417 int rump_sys_ioctl(int, u_long, void *); 418 int 419 rump_sys_ioctl(int fd, u_long com, void * data) 420 { 421 register_t retval = 0; 422 int error = 0; 423 struct sys_ioctl_args arg; 424 425 SPARG(&arg, fd) = fd; 426 SPARG(&arg, com) = com; 427 SPARG(&arg, data) = data; 428 429 error = sys_ioctl(curlwp, &arg, &retval); 430 if (error) { 431 retval = -1; 432 rumpuser_seterrno(error); 433 } 434 return retval; 435 } 436 __weak_alias(sys_ioctl,rump_enosys); 437 438 int rump_sys_symlink(const char *, const char *); 439 int 440 rump_sys_symlink(const char * path, const char * link) 441 { 442 register_t retval = 0; 443 int error = 0; 444 struct sys_symlink_args arg; 445 446 SPARG(&arg, path) = path; 447 SPARG(&arg, link) = link; 448 449 error = sys_symlink(curlwp, &arg, &retval); 450 if (error) { 451 retval = -1; 452 rumpuser_seterrno(error); 453 } 454 return retval; 455 } 456 __weak_alias(sys_symlink,rump_enosys); 457 458 ssize_t rump_sys_readlink(const char *, char *, size_t); 459 ssize_t 460 rump_sys_readlink(const char * path, char * buf, size_t count) 461 { 462 register_t retval = 0; 463 int error = 0; 464 struct sys_readlink_args arg; 465 466 SPARG(&arg, path) = path; 467 SPARG(&arg, buf) = buf; 468 SPARG(&arg, count) = count; 469 470 error = sys_readlink(curlwp, &arg, &retval); 471 if (error) { 472 retval = -1; 473 rumpuser_seterrno(error); 474 } 475 return retval; 476 } 477 __weak_alias(sys_readlink,rump_enosys); 478 479 int rump_sys_fsync(int); 480 int 481 rump_sys_fsync(int fd) 482 { 483 register_t retval = 0; 484 int error = 0; 485 struct sys_fsync_args arg; 486 487 SPARG(&arg, fd) = fd; 488 489 error = sys_fsync(curlwp, &arg, &retval); 490 if (error) { 491 retval = -1; 492 rumpuser_seterrno(error); 493 } 494 return retval; 495 } 496 __weak_alias(sys_fsync,rump_enosys); 497 498 int rump_sys_connect(int, const struct sockaddr *, unsigned int); 499 int 500 rump_sys_connect(int s, const struct sockaddr * name, unsigned int namelen) 501 { 502 register_t retval = 0; 503 int error = 0; 504 struct sys_connect_args arg; 505 506 SPARG(&arg, s) = s; 507 SPARG(&arg, name) = name; 508 SPARG(&arg, namelen) = namelen; 509 510 error = sys_connect(curlwp, &arg, &retval); 511 if (error) { 512 retval = -1; 513 rumpuser_seterrno(error); 514 } 515 return retval; 516 } 517 __weak_alias(sys_connect,rump_enosys); 518 519 int rump_sys_bind(int, const struct sockaddr *, unsigned int); 520 int 521 rump_sys_bind(int s, const struct sockaddr * name, unsigned int namelen) 522 { 523 register_t retval = 0; 524 int error = 0; 525 struct sys_bind_args arg; 526 527 SPARG(&arg, s) = s; 528 SPARG(&arg, name) = name; 529 SPARG(&arg, namelen) = namelen; 530 531 error = sys_bind(curlwp, &arg, &retval); 532 if (error) { 533 retval = -1; 534 rumpuser_seterrno(error); 535 } 536 return retval; 537 } 538 __weak_alias(sys_bind,rump_enosys); 539 540 int rump_sys_setsockopt(int, int, int, const void *, unsigned int); 541 int 542 rump_sys_setsockopt(int s, int level, int name, const void * val, unsigned int valsize) 543 { 544 register_t retval = 0; 545 int error = 0; 546 struct sys_setsockopt_args arg; 547 548 SPARG(&arg, s) = s; 549 SPARG(&arg, level) = level; 550 SPARG(&arg, name) = name; 551 SPARG(&arg, val) = val; 552 SPARG(&arg, valsize) = valsize; 553 554 error = sys_setsockopt(curlwp, &arg, &retval); 555 if (error) { 556 retval = -1; 557 rumpuser_seterrno(error); 558 } 559 return retval; 560 } 561 __weak_alias(sys_setsockopt,rump_enosys); 562 563 int rump_sys_listen(int, int); 564 int 565 rump_sys_listen(int s, int backlog) 566 { 567 register_t retval = 0; 568 int error = 0; 569 struct sys_listen_args arg; 570 571 SPARG(&arg, s) = s; 572 SPARG(&arg, backlog) = backlog; 573 574 error = sys_listen(curlwp, &arg, &retval); 575 if (error) { 576 retval = -1; 577 rumpuser_seterrno(error); 578 } 579 return retval; 580 } 581 __weak_alias(sys_listen,rump_enosys); 582 583 int rump_sys_getsockopt(int, int, int, void *, unsigned int *); 584 int 585 rump_sys_getsockopt(int s, int level, int name, void * val, unsigned int * avalsize) 586 { 587 register_t retval = 0; 588 int error = 0; 589 struct sys_getsockopt_args arg; 590 591 SPARG(&arg, s) = s; 592 SPARG(&arg, level) = level; 593 SPARG(&arg, name) = name; 594 SPARG(&arg, val) = val; 595 SPARG(&arg, avalsize) = avalsize; 596 597 error = sys_getsockopt(curlwp, &arg, &retval); 598 if (error) { 599 retval = -1; 600 rumpuser_seterrno(error); 601 } 602 return retval; 603 } 604 __weak_alias(sys_getsockopt,rump_enosys); 605 606 int rump_sys_rename(const char *, const char *); 607 int 608 rump_sys_rename(const char * from, const char * to) 609 { 610 register_t retval = 0; 611 int error = 0; 612 struct sys_rename_args arg; 613 614 SPARG(&arg, from) = from; 615 SPARG(&arg, to) = to; 616 617 error = sys_rename(curlwp, &arg, &retval); 618 if (error) { 619 retval = -1; 620 rumpuser_seterrno(error); 621 } 622 return retval; 623 } 624 __weak_alias(sys_rename,rump_enosys); 625 626 int rump_sys_mkfifo(const char *, mode_t); 627 int 628 rump_sys_mkfifo(const char * path, mode_t mode) 629 { 630 register_t retval = 0; 631 int error = 0; 632 struct sys_mkfifo_args arg; 633 634 SPARG(&arg, path) = path; 635 SPARG(&arg, mode) = mode; 636 637 error = sys_mkfifo(curlwp, &arg, &retval); 638 if (error) { 639 retval = -1; 640 rumpuser_seterrno(error); 641 } 642 return retval; 643 } 644 __weak_alias(sys_mkfifo,rump_enosys); 645 646 ssize_t rump_sys_sendto(int, const void *, size_t, int, const struct sockaddr *, unsigned int); 647 ssize_t 648 rump_sys_sendto(int s, const void * buf, size_t len, int flags, const struct sockaddr * to, unsigned int tolen) 649 { 650 register_t retval = 0; 651 int error = 0; 652 struct sys_sendto_args arg; 653 654 SPARG(&arg, s) = s; 655 SPARG(&arg, buf) = buf; 656 SPARG(&arg, len) = len; 657 SPARG(&arg, flags) = flags; 658 SPARG(&arg, to) = to; 659 SPARG(&arg, tolen) = tolen; 660 661 error = sys_sendto(curlwp, &arg, &retval); 662 if (error) { 663 retval = -1; 664 rumpuser_seterrno(error); 665 } 666 return retval; 667 } 668 __weak_alias(sys_sendto,rump_enosys); 669 670 int rump_sys_shutdown(int, int); 671 int 672 rump_sys_shutdown(int s, int how) 673 { 674 register_t retval = 0; 675 int error = 0; 676 struct sys_shutdown_args arg; 677 678 SPARG(&arg, s) = s; 679 SPARG(&arg, how) = how; 680 681 error = sys_shutdown(curlwp, &arg, &retval); 682 if (error) { 683 retval = -1; 684 rumpuser_seterrno(error); 685 } 686 return retval; 687 } 688 __weak_alias(sys_shutdown,rump_enosys); 689 690 int rump_sys_socketpair(int, int, int, int *); 691 int 692 rump_sys_socketpair(int domain, int type, int protocol, int * rsv) 693 { 694 register_t retval = 0; 695 int error = 0; 696 struct sys_socketpair_args arg; 697 698 SPARG(&arg, domain) = domain; 699 SPARG(&arg, type) = type; 700 SPARG(&arg, protocol) = protocol; 701 SPARG(&arg, rsv) = rsv; 702 703 error = sys_socketpair(curlwp, &arg, &retval); 704 if (error) { 705 retval = -1; 706 rumpuser_seterrno(error); 707 } 708 return retval; 709 } 710 __weak_alias(sys_socketpair,rump_enosys); 711 712 int rump_sys_mkdir(const char *, mode_t); 713 int 714 rump_sys_mkdir(const char * path, mode_t mode) 715 { 716 register_t retval = 0; 717 int error = 0; 718 struct sys_mkdir_args arg; 719 720 SPARG(&arg, path) = path; 721 SPARG(&arg, mode) = mode; 722 723 error = sys_mkdir(curlwp, &arg, &retval); 724 if (error) { 725 retval = -1; 726 rumpuser_seterrno(error); 727 } 728 return retval; 729 } 730 __weak_alias(sys_mkdir,rump_enosys); 731 732 int rump_sys_rmdir(const char *); 733 int 734 rump_sys_rmdir(const char * path) 735 { 736 register_t retval = 0; 737 int error = 0; 738 struct sys_rmdir_args arg; 739 740 SPARG(&arg, path) = path; 741 742 error = sys_rmdir(curlwp, &arg, &retval); 743 if (error) { 744 retval = -1; 745 rumpuser_seterrno(error); 746 } 747 return retval; 748 } 749 __weak_alias(sys_rmdir,rump_enosys); 750 751 int rump_sys_nfssvc(int, void *); 752 int 753 rump_sys_nfssvc(int flag, void * argp) 754 { 755 register_t retval = 0; 756 int error = 0; 757 struct sys_nfssvc_args arg; 758 759 SPARG(&arg, flag) = flag; 760 SPARG(&arg, argp) = argp; 761 762 error = sys_nfssvc(curlwp, &arg, &retval); 763 if (error) { 764 retval = -1; 765 rumpuser_seterrno(error); 766 } 767 return retval; 768 } 769 __weak_alias(sys_nfssvc,rump_enosys); 770 771 ssize_t rump_sys_pread(int, void *, size_t, int, off_t); 772 ssize_t 773 rump_sys_pread(int fd, void * buf, size_t nbyte, int pad, off_t offset) 774 { 775 register_t retval = 0; 776 int error = 0; 777 struct sys_pread_args arg; 778 779 SPARG(&arg, fd) = fd; 780 SPARG(&arg, buf) = buf; 781 SPARG(&arg, nbyte) = nbyte; 782 SPARG(&arg, pad) = pad; 783 SPARG(&arg, offset) = offset; 784 785 error = sys_pread(curlwp, &arg, &retval); 786 if (error) { 787 retval = -1; 788 rumpuser_seterrno(error); 789 } 790 return retval; 791 } 792 __weak_alias(sys_pread,rump_enosys); 793 794 ssize_t rump_sys_pwrite(int, const void *, size_t, int, off_t); 795 ssize_t 796 rump_sys_pwrite(int fd, const void * buf, size_t nbyte, int pad, off_t offset) 797 { 798 register_t retval = 0; 799 int error = 0; 800 struct sys_pwrite_args arg; 801 802 SPARG(&arg, fd) = fd; 803 SPARG(&arg, buf) = buf; 804 SPARG(&arg, nbyte) = nbyte; 805 SPARG(&arg, pad) = pad; 806 SPARG(&arg, offset) = offset; 807 808 error = sys_pwrite(curlwp, &arg, &retval); 809 if (error) { 810 retval = -1; 811 rumpuser_seterrno(error); 812 } 813 return retval; 814 } 815 __weak_alias(sys_pwrite,rump_enosys); 816 817 int rump_sys_truncate(const char *, int, off_t); 818 int 819 rump_sys_truncate(const char * path, int pad, off_t length) 820 { 821 register_t retval = 0; 822 int error = 0; 823 struct sys_truncate_args arg; 824 825 SPARG(&arg, path) = path; 826 SPARG(&arg, pad) = pad; 827 SPARG(&arg, length) = length; 828 829 error = sys_truncate(curlwp, &arg, &retval); 830 if (error) { 831 retval = -1; 832 rumpuser_seterrno(error); 833 } 834 return retval; 835 } 836 __weak_alias(sys_truncate,rump_enosys); 837 838 int rump_sys___sysctl(const int *, u_int, void *, size_t *, const void *, size_t); 839 int 840 rump_sys___sysctl(const int * name, u_int namelen, void * old, size_t * oldlenp, const void * new, size_t newlen) 841 { 842 register_t retval = 0; 843 int error = 0; 844 struct sys___sysctl_args arg; 845 846 SPARG(&arg, name) = name; 847 SPARG(&arg, namelen) = namelen; 848 SPARG(&arg, old) = old; 849 SPARG(&arg, oldlenp) = oldlenp; 850 SPARG(&arg, new) = new; 851 SPARG(&arg, newlen) = newlen; 852 853 error = sys___sysctl(curlwp, &arg, &retval); 854 if (error) { 855 retval = -1; 856 rumpuser_seterrno(error); 857 } 858 return retval; 859 } 860 __weak_alias(sys___sysctl,rump_enosys); 861 862 int rump_sys_lchmod(const char *, mode_t); 863 int 864 rump_sys_lchmod(const char * path, mode_t mode) 865 { 866 register_t retval = 0; 867 int error = 0; 868 struct sys_lchmod_args arg; 869 870 SPARG(&arg, path) = path; 871 SPARG(&arg, mode) = mode; 872 873 error = sys_lchmod(curlwp, &arg, &retval); 874 if (error) { 875 retval = -1; 876 rumpuser_seterrno(error); 877 } 878 return retval; 879 } 880 __weak_alias(sys_lchmod,rump_enosys); 881 882 int rump_sys_lchown(const char *, uid_t, gid_t); 883 int 884 rump_sys_lchown(const char * path, uid_t uid, gid_t gid) 885 { 886 register_t retval = 0; 887 int error = 0; 888 struct sys_lchown_args arg; 889 890 SPARG(&arg, path) = path; 891 SPARG(&arg, uid) = uid; 892 SPARG(&arg, gid) = gid; 893 894 error = sys_lchown(curlwp, &arg, &retval); 895 if (error) { 896 retval = -1; 897 rumpuser_seterrno(error); 898 } 899 return retval; 900 } 901 __weak_alias(sys_lchown,rump_enosys); 902 903 int rump_sys_lchflags(const char *, u_long); 904 int 905 rump_sys_lchflags(const char * path, u_long flags) 906 { 907 register_t retval = 0; 908 int error = 0; 909 struct sys_lchflags_args arg; 910 911 SPARG(&arg, path) = path; 912 SPARG(&arg, flags) = flags; 913 914 error = sys_lchflags(curlwp, &arg, &retval); 915 if (error) { 916 retval = -1; 917 rumpuser_seterrno(error); 918 } 919 return retval; 920 } 921 __weak_alias(sys_lchflags,rump_enosys); 922 923 int rump_sys_statvfs1(const char *, struct statvfs *, int); 924 int 925 rump_sys_statvfs1(const char * path, struct statvfs * buf, int flags) 926 { 927 register_t retval = 0; 928 int error = 0; 929 struct sys_statvfs1_args arg; 930 931 SPARG(&arg, path) = path; 932 SPARG(&arg, buf) = buf; 933 SPARG(&arg, flags) = flags; 934 935 error = sys_statvfs1(curlwp, &arg, &retval); 936 if (error) { 937 retval = -1; 938 rumpuser_seterrno(error); 939 } 940 return retval; 941 } 942 __weak_alias(sys_statvfs1,rump_enosys); 943 944 int rump_sys___socket30(int, int, int); 945 int 946 rump_sys___socket30(int domain, int type, int protocol) 947 { 948 register_t retval = 0; 949 int error = 0; 950 struct sys___socket30_args arg; 951 952 SPARG(&arg, domain) = domain; 953 SPARG(&arg, type) = type; 954 SPARG(&arg, protocol) = protocol; 955 956 error = sys___socket30(curlwp, &arg, &retval); 957 if (error) { 958 retval = -1; 959 rumpuser_seterrno(error); 960 } 961 return retval; 962 } 963 __weak_alias(sys___socket30,rump_enosys); 964 965 int rump_sys___getfh30(const char *, void *, size_t *); 966 int 967 rump_sys___getfh30(const char * fname, void * fhp, size_t * fh_size) 968 { 969 register_t retval = 0; 970 int error = 0; 971 struct sys___getfh30_args arg; 972 973 SPARG(&arg, fname) = fname; 974 SPARG(&arg, fhp) = fhp; 975 SPARG(&arg, fh_size) = fh_size; 976 977 error = sys___getfh30(curlwp, &arg, &retval); 978 if (error) { 979 retval = -1; 980 rumpuser_seterrno(error); 981 } 982 return retval; 983 } 984 __weak_alias(sys___getfh30,rump_enosys); 985 986 int rump_sys___utimes50(const char *, const struct timeval *); 987 int 988 rump_sys___utimes50(const char * path, const struct timeval * tptr) 989 { 990 register_t retval = 0; 991 int error = 0; 992 struct sys___utimes50_args arg; 993 994 SPARG(&arg, path) = path; 995 SPARG(&arg, tptr) = tptr; 996 997 error = sys___utimes50(curlwp, &arg, &retval); 998 if (error) { 999 retval = -1; 1000 rumpuser_seterrno(error); 1001 } 1002 return retval; 1003 } 1004 __weak_alias(sys___utimes50,rump_enosys); 1005 1006 int rump_sys___lutimes50(const char *, const struct timeval *); 1007 int 1008 rump_sys___lutimes50(const char * path, const struct timeval * tptr) 1009 { 1010 register_t retval = 0; 1011 int error = 0; 1012 struct sys___lutimes50_args arg; 1013 1014 SPARG(&arg, path) = path; 1015 SPARG(&arg, tptr) = tptr; 1016 1017 error = sys___lutimes50(curlwp, &arg, &retval); 1018 if (error) { 1019 retval = -1; 1020 rumpuser_seterrno(error); 1021 } 1022 return retval; 1023 } 1024 __weak_alias(sys___lutimes50,rump_enosys); 1025 1026 int rump_sys___stat50(const char *, struct stat *); 1027 int 1028 rump_sys___stat50(const char * path, struct stat * ub) 1029 { 1030 register_t retval = 0; 1031 int error = 0; 1032 struct sys___stat50_args arg; 1033 1034 SPARG(&arg, path) = path; 1035 SPARG(&arg, ub) = ub; 1036 1037 error = sys___stat50(curlwp, &arg, &retval); 1038 if (error) { 1039 retval = -1; 1040 rumpuser_seterrno(error); 1041 } 1042 return retval; 1043 } 1044 __weak_alias(sys___stat50,rump_enosys); 1045 1046 int rump_sys___lstat50(const char *, struct stat *); 1047 int 1048 rump_sys___lstat50(const char * path, struct stat * ub) 1049 { 1050 register_t retval = 0; 1051 int error = 0; 1052 struct sys___lstat50_args arg; 1053 1054 SPARG(&arg, path) = path; 1055 SPARG(&arg, ub) = ub; 1056 1057 error = sys___lstat50(curlwp, &arg, &retval); 1058 if (error) { 1059 retval = -1; 1060 rumpuser_seterrno(error); 1061 } 1062 return retval; 1063 } 1064 __weak_alias(sys___lstat50,rump_enosys); 1065 1066 int rump_sys___mknod50(const char *, mode_t, dev_t); 1067 int 1068 rump_sys___mknod50(const char * path, mode_t mode, dev_t dev) 1069 { 1070 register_t retval = 0; 1071 int error = 0; 1072 struct sys___mknod50_args arg; 1073 1074 SPARG(&arg, path) = path; 1075 SPARG(&arg, mode) = mode; 1076 SPARG(&arg, dev) = dev; 1077 1078 error = sys___mknod50(curlwp, &arg, &retval); 1079 if (error) { 1080 retval = -1; 1081 rumpuser_seterrno(error); 1082 } 1083 return retval; 1084 } 1085 __weak_alias(sys___mknod50,rump_enosys); 1086
Indexes created Wed Oct 01 19:09:53 GMT 2025