rump_syscalls.c revision 1.122
1 /* $NetBSD: rump_syscalls.c,v 1.122 2016/01/26 23:12: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.281 2015/12/03 02:51:00 pgoyette Exp 8 */ 9 10 #ifdef RUMP_CLIENT 11 #include <rump/rumpuser_port.h> 12 #endif /* RUMP_CLIENT */ 13 14 #include <sys/param.h> 15 16 #ifdef __NetBSD__ 17 #include <sys/cdefs.h> 18 __KERNEL_RCSID(0, "$NetBSD: rump_syscalls.c,v 1.122 2016/01/26 23:12:17 pooka Exp $"); 19 20 #include <sys/fstypes.h> 21 #include <sys/proc.h> 22 #endif /* __NetBSD__ */ 23 24 #ifdef RUMP_CLIENT 25 #include <errno.h> 26 #include <stdint.h> 27 #include <stdlib.h> 28 #include <string.h> 29 30 #include <srcsys/syscall.h> 31 #include <srcsys/syscallargs.h> 32 33 #include <rump/rumpclient.h> 34 35 #define rsys_syscall(num, data, dlen, retval) \ 36 rumpclient_syscall(num, data, dlen, retval) 37 #define rsys_seterrno(error) errno = error 38 #else 39 #include <sys/syscall.h> 40 #include <sys/syscallargs.h> 41 42 #include <sys/syscallvar.h> 43 44 #include <rump-sys/kern.h> 45 46 #include <rump/rumpuser.h> 47 48 #define rsys_syscall(num, data, dlen, retval) \ 49 rump_syscall(num, data, dlen, retval) 50 51 #define rsys_seterrno(error) rumpuser_seterrno(error) 52 #endif 53 54 #ifndef RUMP_KERNEL_IS_LIBC 55 #define RUMP_SYS_COMPAT 56 #endif 57 58 #if BYTE_ORDER == BIG_ENDIAN 59 #define SPARG(p,k) ((p)->k.be.datum) 60 #else /* LITTLE_ENDIAN, I hope dearly */ 61 #define SPARG(p,k) ((p)->k.le.datum) 62 #endif 63 64 65 void rumpns_sys_nomodule(void); 66 67 ssize_t rump___sysimpl_read(int, void *, size_t); 68 ssize_t 69 rump___sysimpl_read(int fd, void * buf, size_t nbyte) 70 { 71 register_t retval[2]; 72 int error = 0; 73 ssize_t rv = -1; 74 struct sys_read_args callarg; 75 76 memset(&callarg, 0, sizeof(callarg)); 77 SPARG(&callarg, fd) = fd; 78 SPARG(&callarg, buf) = buf; 79 SPARG(&callarg, nbyte) = nbyte; 80 81 error = rsys_syscall(SYS_read, &callarg, sizeof(callarg), retval); 82 rsys_seterrno(error); 83 if (error == 0) { 84 if (sizeof(ssize_t) > sizeof(register_t)) 85 rv = *(ssize_t *)retval; 86 else 87 rv = *retval; 88 } 89 return rv; 90 } 91 #ifdef RUMP_KERNEL_IS_LIBC 92 __weak_alias(read,rump___sysimpl_read); 93 __weak_alias(_read,rump___sysimpl_read); 94 __strong_alias(_sys_read,rump___sysimpl_read); 95 #endif /* RUMP_KERNEL_IS_LIBC */ 96 97 ssize_t rump___sysimpl_write(int, const void *, size_t); 98 ssize_t 99 rump___sysimpl_write(int fd, const void * buf, size_t nbyte) 100 { 101 register_t retval[2]; 102 int error = 0; 103 ssize_t rv = -1; 104 struct sys_write_args callarg; 105 106 memset(&callarg, 0, sizeof(callarg)); 107 SPARG(&callarg, fd) = fd; 108 SPARG(&callarg, buf) = buf; 109 SPARG(&callarg, nbyte) = nbyte; 110 111 error = rsys_syscall(SYS_write, &callarg, sizeof(callarg), retval); 112 rsys_seterrno(error); 113 if (error == 0) { 114 if (sizeof(ssize_t) > sizeof(register_t)) 115 rv = *(ssize_t *)retval; 116 else 117 rv = *retval; 118 } 119 return rv; 120 } 121 #ifdef RUMP_KERNEL_IS_LIBC 122 __weak_alias(write,rump___sysimpl_write); 123 __weak_alias(_write,rump___sysimpl_write); 124 __strong_alias(_sys_write,rump___sysimpl_write); 125 #endif /* RUMP_KERNEL_IS_LIBC */ 126 127 int rump___sysimpl_open(const char *, int, mode_t); 128 int 129 rump___sysimpl_open(const char * path, int flags, mode_t mode) 130 { 131 register_t retval[2]; 132 int error = 0; 133 int rv = -1; 134 struct sys_open_args callarg; 135 136 memset(&callarg, 0, sizeof(callarg)); 137 SPARG(&callarg, path) = path; 138 SPARG(&callarg, flags) = flags; 139 SPARG(&callarg, mode) = mode; 140 141 error = rsys_syscall(SYS_open, &callarg, sizeof(callarg), retval); 142 rsys_seterrno(error); 143 if (error == 0) { 144 if (sizeof(int) > sizeof(register_t)) 145 rv = *(int *)retval; 146 else 147 rv = *retval; 148 } 149 return rv; 150 } 151 #ifdef RUMP_KERNEL_IS_LIBC 152 __weak_alias(open,rump___sysimpl_open); 153 __weak_alias(_open,rump___sysimpl_open); 154 __strong_alias(_sys_open,rump___sysimpl_open); 155 #endif /* RUMP_KERNEL_IS_LIBC */ 156 157 int rump___sysimpl_close(int); 158 int 159 rump___sysimpl_close(int fd) 160 { 161 register_t retval[2]; 162 int error = 0; 163 int rv = -1; 164 struct sys_close_args callarg; 165 166 memset(&callarg, 0, sizeof(callarg)); 167 SPARG(&callarg, fd) = fd; 168 169 error = rsys_syscall(SYS_close, &callarg, sizeof(callarg), retval); 170 rsys_seterrno(error); 171 if (error == 0) { 172 if (sizeof(int) > sizeof(register_t)) 173 rv = *(int *)retval; 174 else 175 rv = *retval; 176 } 177 return rv; 178 } 179 #ifdef RUMP_KERNEL_IS_LIBC 180 __weak_alias(close,rump___sysimpl_close); 181 __weak_alias(_close,rump___sysimpl_close); 182 __strong_alias(_sys_close,rump___sysimpl_close); 183 #endif /* RUMP_KERNEL_IS_LIBC */ 184 185 int rump___sysimpl_link(const char *, const char *); 186 int 187 rump___sysimpl_link(const char * path, const char * link) 188 { 189 register_t retval[2]; 190 int error = 0; 191 int rv = -1; 192 struct sys_link_args callarg; 193 194 memset(&callarg, 0, sizeof(callarg)); 195 SPARG(&callarg, path) = path; 196 SPARG(&callarg, link) = link; 197 198 error = rsys_syscall(SYS_link, &callarg, sizeof(callarg), retval); 199 rsys_seterrno(error); 200 if (error == 0) { 201 if (sizeof(int) > sizeof(register_t)) 202 rv = *(int *)retval; 203 else 204 rv = *retval; 205 } 206 return rv; 207 } 208 #ifdef RUMP_KERNEL_IS_LIBC 209 __weak_alias(link,rump___sysimpl_link); 210 __weak_alias(_link,rump___sysimpl_link); 211 __strong_alias(_sys_link,rump___sysimpl_link); 212 #endif /* RUMP_KERNEL_IS_LIBC */ 213 214 int rump___sysimpl_unlink(const char *); 215 int 216 rump___sysimpl_unlink(const char * path) 217 { 218 register_t retval[2]; 219 int error = 0; 220 int rv = -1; 221 struct sys_unlink_args callarg; 222 223 memset(&callarg, 0, sizeof(callarg)); 224 SPARG(&callarg, path) = path; 225 226 error = rsys_syscall(SYS_unlink, &callarg, sizeof(callarg), retval); 227 rsys_seterrno(error); 228 if (error == 0) { 229 if (sizeof(int) > sizeof(register_t)) 230 rv = *(int *)retval; 231 else 232 rv = *retval; 233 } 234 return rv; 235 } 236 #ifdef RUMP_KERNEL_IS_LIBC 237 __weak_alias(unlink,rump___sysimpl_unlink); 238 __weak_alias(_unlink,rump___sysimpl_unlink); 239 __strong_alias(_sys_unlink,rump___sysimpl_unlink); 240 #endif /* RUMP_KERNEL_IS_LIBC */ 241 242 int rump___sysimpl_chdir(const char *); 243 int 244 rump___sysimpl_chdir(const char * path) 245 { 246 register_t retval[2]; 247 int error = 0; 248 int rv = -1; 249 struct sys_chdir_args callarg; 250 251 memset(&callarg, 0, sizeof(callarg)); 252 SPARG(&callarg, path) = path; 253 254 error = rsys_syscall(SYS_chdir, &callarg, sizeof(callarg), retval); 255 rsys_seterrno(error); 256 if (error == 0) { 257 if (sizeof(int) > sizeof(register_t)) 258 rv = *(int *)retval; 259 else 260 rv = *retval; 261 } 262 return rv; 263 } 264 #ifdef RUMP_KERNEL_IS_LIBC 265 __weak_alias(chdir,rump___sysimpl_chdir); 266 __weak_alias(_chdir,rump___sysimpl_chdir); 267 __strong_alias(_sys_chdir,rump___sysimpl_chdir); 268 #endif /* RUMP_KERNEL_IS_LIBC */ 269 270 int rump___sysimpl_fchdir(int); 271 int 272 rump___sysimpl_fchdir(int fd) 273 { 274 register_t retval[2]; 275 int error = 0; 276 int rv = -1; 277 struct sys_fchdir_args callarg; 278 279 memset(&callarg, 0, sizeof(callarg)); 280 SPARG(&callarg, fd) = fd; 281 282 error = rsys_syscall(SYS_fchdir, &callarg, sizeof(callarg), retval); 283 rsys_seterrno(error); 284 if (error == 0) { 285 if (sizeof(int) > sizeof(register_t)) 286 rv = *(int *)retval; 287 else 288 rv = *retval; 289 } 290 return rv; 291 } 292 #ifdef RUMP_KERNEL_IS_LIBC 293 __weak_alias(fchdir,rump___sysimpl_fchdir); 294 __weak_alias(_fchdir,rump___sysimpl_fchdir); 295 __strong_alias(_sys_fchdir,rump___sysimpl_fchdir); 296 #endif /* RUMP_KERNEL_IS_LIBC */ 297 298 #ifdef RUMP_SYS_COMPAT 299 int rump___sysimpl_mknod(const char *, mode_t, uint32_t); 300 int 301 rump___sysimpl_mknod(const char * path, mode_t mode, uint32_t dev) 302 { 303 register_t retval[2]; 304 int error = 0; 305 int rv = -1; 306 struct compat_50_sys_mknod_args callarg; 307 308 memset(&callarg, 0, sizeof(callarg)); 309 SPARG(&callarg, path) = path; 310 SPARG(&callarg, mode) = mode; 311 SPARG(&callarg, dev) = dev; 312 313 error = rsys_syscall(SYS_compat_50_mknod, &callarg, sizeof(callarg), retval); 314 rsys_seterrno(error); 315 if (error == 0) { 316 if (sizeof(int) > sizeof(register_t)) 317 rv = *(int *)retval; 318 else 319 rv = *retval; 320 } 321 return rv; 322 } 323 #ifdef RUMP_KERNEL_IS_LIBC 324 __weak_alias(mknod,rump___sysimpl_mknod); 325 __weak_alias(_mknod,rump___sysimpl_mknod); 326 __strong_alias(_sys_mknod,rump___sysimpl_mknod); 327 #endif /* RUMP_KERNEL_IS_LIBC */ 328 #endif /* RUMP_SYS_COMPAT */ 329 330 int rump___sysimpl_chmod(const char *, mode_t); 331 int 332 rump___sysimpl_chmod(const char * path, mode_t mode) 333 { 334 register_t retval[2]; 335 int error = 0; 336 int rv = -1; 337 struct sys_chmod_args callarg; 338 339 memset(&callarg, 0, sizeof(callarg)); 340 SPARG(&callarg, path) = path; 341 SPARG(&callarg, mode) = mode; 342 343 error = rsys_syscall(SYS_chmod, &callarg, sizeof(callarg), retval); 344 rsys_seterrno(error); 345 if (error == 0) { 346 if (sizeof(int) > sizeof(register_t)) 347 rv = *(int *)retval; 348 else 349 rv = *retval; 350 } 351 return rv; 352 } 353 #ifdef RUMP_KERNEL_IS_LIBC 354 __weak_alias(chmod,rump___sysimpl_chmod); 355 __weak_alias(_chmod,rump___sysimpl_chmod); 356 __strong_alias(_sys_chmod,rump___sysimpl_chmod); 357 #endif /* RUMP_KERNEL_IS_LIBC */ 358 359 int rump___sysimpl_chown(const char *, uid_t, gid_t); 360 int 361 rump___sysimpl_chown(const char * path, uid_t uid, gid_t gid) 362 { 363 register_t retval[2]; 364 int error = 0; 365 int rv = -1; 366 struct sys_chown_args callarg; 367 368 memset(&callarg, 0, sizeof(callarg)); 369 SPARG(&callarg, path) = path; 370 SPARG(&callarg, uid) = uid; 371 SPARG(&callarg, gid) = gid; 372 373 error = rsys_syscall(SYS_chown, &callarg, sizeof(callarg), retval); 374 rsys_seterrno(error); 375 if (error == 0) { 376 if (sizeof(int) > sizeof(register_t)) 377 rv = *(int *)retval; 378 else 379 rv = *retval; 380 } 381 return rv; 382 } 383 #ifdef RUMP_KERNEL_IS_LIBC 384 __weak_alias(chown,rump___sysimpl_chown); 385 __weak_alias(_chown,rump___sysimpl_chown); 386 __strong_alias(_sys_chown,rump___sysimpl_chown); 387 #endif /* RUMP_KERNEL_IS_LIBC */ 388 389 pid_t rump___sysimpl_getpid(void); 390 pid_t 391 rump___sysimpl_getpid(void ) 392 { 393 register_t retval[2]; 394 pid_t rv = -1; 395 396 (void)rsys_syscall(SYS_getpid, NULL, 0, retval); 397 if (sizeof(pid_t) > sizeof(register_t)) 398 rv = *(pid_t *)retval; 399 else 400 rv = *retval; 401 return rv; 402 } 403 #ifdef RUMP_KERNEL_IS_LIBC 404 __weak_alias(getpid,rump___sysimpl_getpid); 405 __weak_alias(_getpid,rump___sysimpl_getpid); 406 __strong_alias(_sys_getpid,rump___sysimpl_getpid); 407 #endif /* RUMP_KERNEL_IS_LIBC */ 408 409 int rump___sysimpl_unmount(const char *, int); 410 int 411 rump___sysimpl_unmount(const char * path, int flags) 412 { 413 register_t retval[2]; 414 int error = 0; 415 int rv = -1; 416 struct sys_unmount_args callarg; 417 418 memset(&callarg, 0, sizeof(callarg)); 419 SPARG(&callarg, path) = path; 420 SPARG(&callarg, flags) = flags; 421 422 error = rsys_syscall(SYS_unmount, &callarg, sizeof(callarg), retval); 423 rsys_seterrno(error); 424 if (error == 0) { 425 if (sizeof(int) > sizeof(register_t)) 426 rv = *(int *)retval; 427 else 428 rv = *retval; 429 } 430 return rv; 431 } 432 #ifdef RUMP_KERNEL_IS_LIBC 433 __weak_alias(unmount,rump___sysimpl_unmount); 434 __weak_alias(_unmount,rump___sysimpl_unmount); 435 __strong_alias(_sys_unmount,rump___sysimpl_unmount); 436 #endif /* RUMP_KERNEL_IS_LIBC */ 437 438 int rump___sysimpl_setuid(uid_t); 439 int 440 rump___sysimpl_setuid(uid_t uid) 441 { 442 register_t retval[2]; 443 int error = 0; 444 int rv = -1; 445 struct sys_setuid_args callarg; 446 447 memset(&callarg, 0, sizeof(callarg)); 448 SPARG(&callarg, uid) = uid; 449 450 error = rsys_syscall(SYS_setuid, &callarg, sizeof(callarg), retval); 451 rsys_seterrno(error); 452 if (error == 0) { 453 if (sizeof(int) > sizeof(register_t)) 454 rv = *(int *)retval; 455 else 456 rv = *retval; 457 } 458 return rv; 459 } 460 #ifdef RUMP_KERNEL_IS_LIBC 461 __weak_alias(setuid,rump___sysimpl_setuid); 462 __weak_alias(_setuid,rump___sysimpl_setuid); 463 __strong_alias(_sys_setuid,rump___sysimpl_setuid); 464 #endif /* RUMP_KERNEL_IS_LIBC */ 465 466 uid_t rump___sysimpl_getuid(void); 467 uid_t 468 rump___sysimpl_getuid(void ) 469 { 470 register_t retval[2]; 471 uid_t rv = -1; 472 473 (void)rsys_syscall(SYS_getuid, NULL, 0, retval); 474 if (sizeof(uid_t) > sizeof(register_t)) 475 rv = *(uid_t *)retval; 476 else 477 rv = *retval; 478 return rv; 479 } 480 #ifdef RUMP_KERNEL_IS_LIBC 481 __weak_alias(getuid,rump___sysimpl_getuid); 482 __weak_alias(_getuid,rump___sysimpl_getuid); 483 __strong_alias(_sys_getuid,rump___sysimpl_getuid); 484 #endif /* RUMP_KERNEL_IS_LIBC */ 485 486 uid_t rump___sysimpl_geteuid(void); 487 uid_t 488 rump___sysimpl_geteuid(void ) 489 { 490 register_t retval[2]; 491 uid_t rv = -1; 492 493 (void)rsys_syscall(SYS_geteuid, NULL, 0, retval); 494 if (sizeof(uid_t) > sizeof(register_t)) 495 rv = *(uid_t *)retval; 496 else 497 rv = *retval; 498 return rv; 499 } 500 #ifdef RUMP_KERNEL_IS_LIBC 501 __weak_alias(geteuid,rump___sysimpl_geteuid); 502 __weak_alias(_geteuid,rump___sysimpl_geteuid); 503 __strong_alias(_sys_geteuid,rump___sysimpl_geteuid); 504 #endif /* RUMP_KERNEL_IS_LIBC */ 505 506 ssize_t rump___sysimpl_recvmsg(int, struct msghdr *, int); 507 ssize_t 508 rump___sysimpl_recvmsg(int s, struct msghdr * msg, int flags) 509 { 510 register_t retval[2]; 511 int error = 0; 512 ssize_t rv = -1; 513 struct sys_recvmsg_args callarg; 514 515 memset(&callarg, 0, sizeof(callarg)); 516 SPARG(&callarg, s) = s; 517 SPARG(&callarg, msg) = msg; 518 SPARG(&callarg, flags) = flags; 519 520 error = rsys_syscall(SYS_recvmsg, &callarg, sizeof(callarg), retval); 521 rsys_seterrno(error); 522 if (error == 0) { 523 if (sizeof(ssize_t) > sizeof(register_t)) 524 rv = *(ssize_t *)retval; 525 else 526 rv = *retval; 527 } 528 return rv; 529 } 530 #ifdef RUMP_KERNEL_IS_LIBC 531 __weak_alias(recvmsg,rump___sysimpl_recvmsg); 532 __weak_alias(_recvmsg,rump___sysimpl_recvmsg); 533 __strong_alias(_sys_recvmsg,rump___sysimpl_recvmsg); 534 #endif /* RUMP_KERNEL_IS_LIBC */ 535 536 ssize_t rump___sysimpl_sendmsg(int, const struct msghdr *, int); 537 ssize_t 538 rump___sysimpl_sendmsg(int s, const struct msghdr * msg, int flags) 539 { 540 register_t retval[2]; 541 int error = 0; 542 ssize_t rv = -1; 543 struct sys_sendmsg_args callarg; 544 545 memset(&callarg, 0, sizeof(callarg)); 546 SPARG(&callarg, s) = s; 547 SPARG(&callarg, msg) = msg; 548 SPARG(&callarg, flags) = flags; 549 550 error = rsys_syscall(SYS_sendmsg, &callarg, sizeof(callarg), retval); 551 rsys_seterrno(error); 552 if (error == 0) { 553 if (sizeof(ssize_t) > sizeof(register_t)) 554 rv = *(ssize_t *)retval; 555 else 556 rv = *retval; 557 } 558 return rv; 559 } 560 #ifdef RUMP_KERNEL_IS_LIBC 561 __weak_alias(sendmsg,rump___sysimpl_sendmsg); 562 __weak_alias(_sendmsg,rump___sysimpl_sendmsg); 563 __strong_alias(_sys_sendmsg,rump___sysimpl_sendmsg); 564 #endif /* RUMP_KERNEL_IS_LIBC */ 565 566 ssize_t rump___sysimpl_recvfrom(int, void *, size_t, int, struct sockaddr *, socklen_t *); 567 ssize_t 568 rump___sysimpl_recvfrom(int s, void * buf, size_t len, int flags, struct sockaddr * from, socklen_t * fromlenaddr) 569 { 570 register_t retval[2]; 571 int error = 0; 572 ssize_t rv = -1; 573 struct sys_recvfrom_args callarg; 574 575 memset(&callarg, 0, sizeof(callarg)); 576 SPARG(&callarg, s) = s; 577 SPARG(&callarg, buf) = buf; 578 SPARG(&callarg, len) = len; 579 SPARG(&callarg, flags) = flags; 580 SPARG(&callarg, from) = from; 581 SPARG(&callarg, fromlenaddr) = fromlenaddr; 582 583 error = rsys_syscall(SYS_recvfrom, &callarg, sizeof(callarg), retval); 584 rsys_seterrno(error); 585 if (error == 0) { 586 if (sizeof(ssize_t) > sizeof(register_t)) 587 rv = *(ssize_t *)retval; 588 else 589 rv = *retval; 590 } 591 return rv; 592 } 593 #ifdef RUMP_KERNEL_IS_LIBC 594 __weak_alias(recvfrom,rump___sysimpl_recvfrom); 595 __weak_alias(_recvfrom,rump___sysimpl_recvfrom); 596 __strong_alias(_sys_recvfrom,rump___sysimpl_recvfrom); 597 #endif /* RUMP_KERNEL_IS_LIBC */ 598 599 int rump___sysimpl_accept(int, struct sockaddr *, socklen_t *); 600 int 601 rump___sysimpl_accept(int s, struct sockaddr * name, socklen_t * anamelen) 602 { 603 register_t retval[2]; 604 int error = 0; 605 int rv = -1; 606 struct sys_accept_args callarg; 607 608 memset(&callarg, 0, sizeof(callarg)); 609 SPARG(&callarg, s) = s; 610 SPARG(&callarg, name) = name; 611 SPARG(&callarg, anamelen) = anamelen; 612 613 error = rsys_syscall(SYS_accept, &callarg, sizeof(callarg), retval); 614 rsys_seterrno(error); 615 if (error == 0) { 616 if (sizeof(int) > sizeof(register_t)) 617 rv = *(int *)retval; 618 else 619 rv = *retval; 620 } 621 return rv; 622 } 623 #ifdef RUMP_KERNEL_IS_LIBC 624 __weak_alias(accept,rump___sysimpl_accept); 625 __weak_alias(_accept,rump___sysimpl_accept); 626 __strong_alias(_sys_accept,rump___sysimpl_accept); 627 #endif /* RUMP_KERNEL_IS_LIBC */ 628 629 int rump___sysimpl_getpeername(int, struct sockaddr *, socklen_t *); 630 int 631 rump___sysimpl_getpeername(int fdes, struct sockaddr * asa, socklen_t * alen) 632 { 633 register_t retval[2]; 634 int error = 0; 635 int rv = -1; 636 struct sys_getpeername_args callarg; 637 638 memset(&callarg, 0, sizeof(callarg)); 639 SPARG(&callarg, fdes) = fdes; 640 SPARG(&callarg, asa) = asa; 641 SPARG(&callarg, alen) = alen; 642 643 error = rsys_syscall(SYS_getpeername, &callarg, sizeof(callarg), retval); 644 rsys_seterrno(error); 645 if (error == 0) { 646 if (sizeof(int) > sizeof(register_t)) 647 rv = *(int *)retval; 648 else 649 rv = *retval; 650 } 651 return rv; 652 } 653 #ifdef RUMP_KERNEL_IS_LIBC 654 __weak_alias(getpeername,rump___sysimpl_getpeername); 655 __weak_alias(_getpeername,rump___sysimpl_getpeername); 656 __strong_alias(_sys_getpeername,rump___sysimpl_getpeername); 657 #endif /* RUMP_KERNEL_IS_LIBC */ 658 659 int rump___sysimpl_getsockname(int, struct sockaddr *, socklen_t *); 660 int 661 rump___sysimpl_getsockname(int fdes, struct sockaddr * asa, socklen_t * alen) 662 { 663 register_t retval[2]; 664 int error = 0; 665 int rv = -1; 666 struct sys_getsockname_args callarg; 667 668 memset(&callarg, 0, sizeof(callarg)); 669 SPARG(&callarg, fdes) = fdes; 670 SPARG(&callarg, asa) = asa; 671 SPARG(&callarg, alen) = alen; 672 673 error = rsys_syscall(SYS_getsockname, &callarg, sizeof(callarg), retval); 674 rsys_seterrno(error); 675 if (error == 0) { 676 if (sizeof(int) > sizeof(register_t)) 677 rv = *(int *)retval; 678 else 679 rv = *retval; 680 } 681 return rv; 682 } 683 #ifdef RUMP_KERNEL_IS_LIBC 684 __weak_alias(getsockname,rump___sysimpl_getsockname); 685 __weak_alias(_getsockname,rump___sysimpl_getsockname); 686 __strong_alias(_sys_getsockname,rump___sysimpl_getsockname); 687 #endif /* RUMP_KERNEL_IS_LIBC */ 688 689 int rump___sysimpl_access(const char *, int); 690 int 691 rump___sysimpl_access(const char * path, int flags) 692 { 693 register_t retval[2]; 694 int error = 0; 695 int rv = -1; 696 struct sys_access_args callarg; 697 698 memset(&callarg, 0, sizeof(callarg)); 699 SPARG(&callarg, path) = path; 700 SPARG(&callarg, flags) = flags; 701 702 error = rsys_syscall(SYS_access, &callarg, sizeof(callarg), retval); 703 rsys_seterrno(error); 704 if (error == 0) { 705 if (sizeof(int) > sizeof(register_t)) 706 rv = *(int *)retval; 707 else 708 rv = *retval; 709 } 710 return rv; 711 } 712 #ifdef RUMP_KERNEL_IS_LIBC 713 __weak_alias(access,rump___sysimpl_access); 714 __weak_alias(_access,rump___sysimpl_access); 715 __strong_alias(_sys_access,rump___sysimpl_access); 716 #endif /* RUMP_KERNEL_IS_LIBC */ 717 718 int rump___sysimpl_chflags(const char *, u_long); 719 int 720 rump___sysimpl_chflags(const char * path, u_long flags) 721 { 722 register_t retval[2]; 723 int error = 0; 724 int rv = -1; 725 struct sys_chflags_args callarg; 726 727 memset(&callarg, 0, sizeof(callarg)); 728 SPARG(&callarg, path) = path; 729 SPARG(&callarg, flags) = flags; 730 731 error = rsys_syscall(SYS_chflags, &callarg, sizeof(callarg), retval); 732 rsys_seterrno(error); 733 if (error == 0) { 734 if (sizeof(int) > sizeof(register_t)) 735 rv = *(int *)retval; 736 else 737 rv = *retval; 738 } 739 return rv; 740 } 741 #ifdef RUMP_KERNEL_IS_LIBC 742 __weak_alias(chflags,rump___sysimpl_chflags); 743 __weak_alias(_chflags,rump___sysimpl_chflags); 744 __strong_alias(_sys_chflags,rump___sysimpl_chflags); 745 #endif /* RUMP_KERNEL_IS_LIBC */ 746 747 int rump___sysimpl_fchflags(int, u_long); 748 int 749 rump___sysimpl_fchflags(int fd, u_long flags) 750 { 751 register_t retval[2]; 752 int error = 0; 753 int rv = -1; 754 struct sys_fchflags_args callarg; 755 756 memset(&callarg, 0, sizeof(callarg)); 757 SPARG(&callarg, fd) = fd; 758 SPARG(&callarg, flags) = flags; 759 760 error = rsys_syscall(SYS_fchflags, &callarg, sizeof(callarg), retval); 761 rsys_seterrno(error); 762 if (error == 0) { 763 if (sizeof(int) > sizeof(register_t)) 764 rv = *(int *)retval; 765 else 766 rv = *retval; 767 } 768 return rv; 769 } 770 #ifdef RUMP_KERNEL_IS_LIBC 771 __weak_alias(fchflags,rump___sysimpl_fchflags); 772 __weak_alias(_fchflags,rump___sysimpl_fchflags); 773 __strong_alias(_sys_fchflags,rump___sysimpl_fchflags); 774 #endif /* RUMP_KERNEL_IS_LIBC */ 775 776 void rump___sysimpl_sync(void); 777 void 778 rump___sysimpl_sync(void ) 779 { 780 register_t retval[2]; 781 782 rsys_syscall(SYS_sync, NULL, 0, retval); 783 } 784 #ifdef RUMP_KERNEL_IS_LIBC 785 __weak_alias(sync,rump___sysimpl_sync); 786 __weak_alias(_sync,rump___sysimpl_sync); 787 __strong_alias(_sys_sync,rump___sysimpl_sync); 788 #endif /* RUMP_KERNEL_IS_LIBC */ 789 790 pid_t rump___sysimpl_getppid(void); 791 pid_t 792 rump___sysimpl_getppid(void ) 793 { 794 register_t retval[2]; 795 pid_t rv = -1; 796 797 (void)rsys_syscall(SYS_getppid, NULL, 0, retval); 798 if (sizeof(pid_t) > sizeof(register_t)) 799 rv = *(pid_t *)retval; 800 else 801 rv = *retval; 802 return rv; 803 } 804 #ifdef RUMP_KERNEL_IS_LIBC 805 __weak_alias(getppid,rump___sysimpl_getppid); 806 __weak_alias(_getppid,rump___sysimpl_getppid); 807 __strong_alias(_sys_getppid,rump___sysimpl_getppid); 808 #endif /* RUMP_KERNEL_IS_LIBC */ 809 810 int rump___sysimpl_dup(int); 811 int 812 rump___sysimpl_dup(int fd) 813 { 814 register_t retval[2]; 815 int error = 0; 816 int rv = -1; 817 struct sys_dup_args callarg; 818 819 memset(&callarg, 0, sizeof(callarg)); 820 SPARG(&callarg, fd) = fd; 821 822 error = rsys_syscall(SYS_dup, &callarg, sizeof(callarg), retval); 823 rsys_seterrno(error); 824 if (error == 0) { 825 if (sizeof(int) > sizeof(register_t)) 826 rv = *(int *)retval; 827 else 828 rv = *retval; 829 } 830 return rv; 831 } 832 #ifdef RUMP_KERNEL_IS_LIBC 833 __weak_alias(dup,rump___sysimpl_dup); 834 __weak_alias(_dup,rump___sysimpl_dup); 835 __strong_alias(_sys_dup,rump___sysimpl_dup); 836 #endif /* RUMP_KERNEL_IS_LIBC */ 837 838 gid_t rump___sysimpl_getegid(void); 839 gid_t 840 rump___sysimpl_getegid(void ) 841 { 842 register_t retval[2]; 843 gid_t rv = -1; 844 845 (void)rsys_syscall(SYS_getegid, NULL, 0, retval); 846 if (sizeof(gid_t) > sizeof(register_t)) 847 rv = *(gid_t *)retval; 848 else 849 rv = *retval; 850 return rv; 851 } 852 #ifdef RUMP_KERNEL_IS_LIBC 853 __weak_alias(getegid,rump___sysimpl_getegid); 854 __weak_alias(_getegid,rump___sysimpl_getegid); 855 __strong_alias(_sys_getegid,rump___sysimpl_getegid); 856 #endif /* RUMP_KERNEL_IS_LIBC */ 857 858 int rump___sysimpl_ktrace(const char *, int, int, pid_t); 859 int 860 rump___sysimpl_ktrace(const char * fname, int ops, int facs, pid_t pid) 861 { 862 register_t retval[2]; 863 int error = 0; 864 int rv = -1; 865 struct sys_ktrace_args callarg; 866 867 memset(&callarg, 0, sizeof(callarg)); 868 SPARG(&callarg, fname) = fname; 869 SPARG(&callarg, ops) = ops; 870 SPARG(&callarg, facs) = facs; 871 SPARG(&callarg, pid) = pid; 872 873 error = rsys_syscall(SYS_ktrace, &callarg, sizeof(callarg), retval); 874 rsys_seterrno(error); 875 if (error == 0) { 876 if (sizeof(int) > sizeof(register_t)) 877 rv = *(int *)retval; 878 else 879 rv = *retval; 880 } 881 return rv; 882 } 883 #ifdef RUMP_KERNEL_IS_LIBC 884 __weak_alias(ktrace,rump___sysimpl_ktrace); 885 __weak_alias(_ktrace,rump___sysimpl_ktrace); 886 __strong_alias(_sys_ktrace,rump___sysimpl_ktrace); 887 #endif /* RUMP_KERNEL_IS_LIBC */ 888 889 gid_t rump___sysimpl_getgid(void); 890 gid_t 891 rump___sysimpl_getgid(void ) 892 { 893 register_t retval[2]; 894 gid_t rv = -1; 895 896 (void)rsys_syscall(SYS_getgid, NULL, 0, retval); 897 if (sizeof(gid_t) > sizeof(register_t)) 898 rv = *(gid_t *)retval; 899 else 900 rv = *retval; 901 return rv; 902 } 903 #ifdef RUMP_KERNEL_IS_LIBC 904 __weak_alias(getgid,rump___sysimpl_getgid); 905 __weak_alias(_getgid,rump___sysimpl_getgid); 906 __strong_alias(_sys_getgid,rump___sysimpl_getgid); 907 #endif /* RUMP_KERNEL_IS_LIBC */ 908 909 int rump___sysimpl___getlogin(char *, size_t); 910 int 911 rump___sysimpl___getlogin(char * namebuf, size_t namelen) 912 { 913 register_t retval[2]; 914 int error = 0; 915 int rv = -1; 916 struct sys___getlogin_args callarg; 917 918 memset(&callarg, 0, sizeof(callarg)); 919 SPARG(&callarg, namebuf) = namebuf; 920 SPARG(&callarg, namelen) = namelen; 921 922 error = rsys_syscall(SYS___getlogin, &callarg, sizeof(callarg), retval); 923 rsys_seterrno(error); 924 if (error == 0) { 925 if (sizeof(int) > sizeof(register_t)) 926 rv = *(int *)retval; 927 else 928 rv = *retval; 929 } 930 return rv; 931 } 932 #ifdef RUMP_KERNEL_IS_LIBC 933 __weak_alias(__getlogin,rump___sysimpl___getlogin); 934 __weak_alias(___getlogin,rump___sysimpl___getlogin); 935 __strong_alias(_sys___getlogin,rump___sysimpl___getlogin); 936 #endif /* RUMP_KERNEL_IS_LIBC */ 937 938 int rump___sysimpl___setlogin(const char *); 939 int 940 rump___sysimpl___setlogin(const char * namebuf) 941 { 942 register_t retval[2]; 943 int error = 0; 944 int rv = -1; 945 struct sys___setlogin_args callarg; 946 947 memset(&callarg, 0, sizeof(callarg)); 948 SPARG(&callarg, namebuf) = namebuf; 949 950 error = rsys_syscall(SYS___setlogin, &callarg, sizeof(callarg), retval); 951 rsys_seterrno(error); 952 if (error == 0) { 953 if (sizeof(int) > sizeof(register_t)) 954 rv = *(int *)retval; 955 else 956 rv = *retval; 957 } 958 return rv; 959 } 960 #ifdef RUMP_KERNEL_IS_LIBC 961 __weak_alias(__setlogin,rump___sysimpl___setlogin); 962 __weak_alias(___setlogin,rump___sysimpl___setlogin); 963 __strong_alias(_sys___setlogin,rump___sysimpl___setlogin); 964 #endif /* RUMP_KERNEL_IS_LIBC */ 965 966 int rump___sysimpl_ioctl(int, u_long, void *); 967 int 968 rump___sysimpl_ioctl(int fd, u_long com, void * data) 969 { 970 register_t retval[2]; 971 int error = 0; 972 int rv = -1; 973 struct sys_ioctl_args callarg; 974 975 memset(&callarg, 0, sizeof(callarg)); 976 SPARG(&callarg, fd) = fd; 977 SPARG(&callarg, com) = com; 978 SPARG(&callarg, data) = data; 979 980 error = rsys_syscall(SYS_ioctl, &callarg, sizeof(callarg), retval); 981 rsys_seterrno(error); 982 if (error == 0) { 983 if (sizeof(int) > sizeof(register_t)) 984 rv = *(int *)retval; 985 else 986 rv = *retval; 987 } 988 return rv; 989 } 990 #ifdef RUMP_KERNEL_IS_LIBC 991 __weak_alias(ioctl,rump___sysimpl_ioctl); 992 __weak_alias(_ioctl,rump___sysimpl_ioctl); 993 __strong_alias(_sys_ioctl,rump___sysimpl_ioctl); 994 #endif /* RUMP_KERNEL_IS_LIBC */ 995 996 int rump___sysimpl_revoke(const char *); 997 int 998 rump___sysimpl_revoke(const char * path) 999 { 1000 register_t retval[2]; 1001 int error = 0; 1002 int rv = -1; 1003 struct sys_revoke_args callarg; 1004 1005 memset(&callarg, 0, sizeof(callarg)); 1006 SPARG(&callarg, path) = path; 1007 1008 error = rsys_syscall(SYS_revoke, &callarg, sizeof(callarg), retval); 1009 rsys_seterrno(error); 1010 if (error == 0) { 1011 if (sizeof(int) > sizeof(register_t)) 1012 rv = *(int *)retval; 1013 else 1014 rv = *retval; 1015 } 1016 return rv; 1017 } 1018 #ifdef RUMP_KERNEL_IS_LIBC 1019 __weak_alias(revoke,rump___sysimpl_revoke); 1020 __weak_alias(_revoke,rump___sysimpl_revoke); 1021 __strong_alias(_sys_revoke,rump___sysimpl_revoke); 1022 #endif /* RUMP_KERNEL_IS_LIBC */ 1023 1024 int rump___sysimpl_symlink(const char *, const char *); 1025 int 1026 rump___sysimpl_symlink(const char * path, const char * link) 1027 { 1028 register_t retval[2]; 1029 int error = 0; 1030 int rv = -1; 1031 struct sys_symlink_args callarg; 1032 1033 memset(&callarg, 0, sizeof(callarg)); 1034 SPARG(&callarg, path) = path; 1035 SPARG(&callarg, link) = link; 1036 1037 error = rsys_syscall(SYS_symlink, &callarg, sizeof(callarg), retval); 1038 rsys_seterrno(error); 1039 if (error == 0) { 1040 if (sizeof(int) > sizeof(register_t)) 1041 rv = *(int *)retval; 1042 else 1043 rv = *retval; 1044 } 1045 return rv; 1046 } 1047 #ifdef RUMP_KERNEL_IS_LIBC 1048 __weak_alias(symlink,rump___sysimpl_symlink); 1049 __weak_alias(_symlink,rump___sysimpl_symlink); 1050 __strong_alias(_sys_symlink,rump___sysimpl_symlink); 1051 #endif /* RUMP_KERNEL_IS_LIBC */ 1052 1053 ssize_t rump___sysimpl_readlink(const char *, char *, size_t); 1054 ssize_t 1055 rump___sysimpl_readlink(const char * path, char * buf, size_t count) 1056 { 1057 register_t retval[2]; 1058 int error = 0; 1059 ssize_t rv = -1; 1060 struct sys_readlink_args callarg; 1061 1062 memset(&callarg, 0, sizeof(callarg)); 1063 SPARG(&callarg, path) = path; 1064 SPARG(&callarg, buf) = buf; 1065 SPARG(&callarg, count) = count; 1066 1067 error = rsys_syscall(SYS_readlink, &callarg, sizeof(callarg), retval); 1068 rsys_seterrno(error); 1069 if (error == 0) { 1070 if (sizeof(ssize_t) > sizeof(register_t)) 1071 rv = *(ssize_t *)retval; 1072 else 1073 rv = *retval; 1074 } 1075 return rv; 1076 } 1077 #ifdef RUMP_KERNEL_IS_LIBC 1078 __weak_alias(readlink,rump___sysimpl_readlink); 1079 __weak_alias(_readlink,rump___sysimpl_readlink); 1080 __strong_alias(_sys_readlink,rump___sysimpl_readlink); 1081 #endif /* RUMP_KERNEL_IS_LIBC */ 1082 1083 mode_t rump___sysimpl_umask(mode_t); 1084 mode_t 1085 rump___sysimpl_umask(mode_t newmask) 1086 { 1087 register_t retval[2]; 1088 int error = 0; 1089 mode_t rv = -1; 1090 struct sys_umask_args callarg; 1091 1092 memset(&callarg, 0, sizeof(callarg)); 1093 SPARG(&callarg, newmask) = newmask; 1094 1095 error = rsys_syscall(SYS_umask, &callarg, sizeof(callarg), retval); 1096 rsys_seterrno(error); 1097 if (error == 0) { 1098 if (sizeof(mode_t) > sizeof(register_t)) 1099 rv = *(mode_t *)retval; 1100 else 1101 rv = *retval; 1102 } 1103 return rv; 1104 } 1105 #ifdef RUMP_KERNEL_IS_LIBC 1106 __weak_alias(umask,rump___sysimpl_umask); 1107 __weak_alias(_umask,rump___sysimpl_umask); 1108 __strong_alias(_sys_umask,rump___sysimpl_umask); 1109 #endif /* RUMP_KERNEL_IS_LIBC */ 1110 1111 int rump___sysimpl_chroot(const char *); 1112 int 1113 rump___sysimpl_chroot(const char * path) 1114 { 1115 register_t retval[2]; 1116 int error = 0; 1117 int rv = -1; 1118 struct sys_chroot_args callarg; 1119 1120 memset(&callarg, 0, sizeof(callarg)); 1121 SPARG(&callarg, path) = path; 1122 1123 error = rsys_syscall(SYS_chroot, &callarg, sizeof(callarg), retval); 1124 rsys_seterrno(error); 1125 if (error == 0) { 1126 if (sizeof(int) > sizeof(register_t)) 1127 rv = *(int *)retval; 1128 else 1129 rv = *retval; 1130 } 1131 return rv; 1132 } 1133 #ifdef RUMP_KERNEL_IS_LIBC 1134 __weak_alias(chroot,rump___sysimpl_chroot); 1135 __weak_alias(_chroot,rump___sysimpl_chroot); 1136 __strong_alias(_sys_chroot,rump___sysimpl_chroot); 1137 #endif /* RUMP_KERNEL_IS_LIBC */ 1138 1139 int rump___sysimpl_getgroups(int, gid_t *); 1140 int 1141 rump___sysimpl_getgroups(int gidsetsize, gid_t * gidset) 1142 { 1143 register_t retval[2]; 1144 int error = 0; 1145 int rv = -1; 1146 struct sys_getgroups_args callarg; 1147 1148 memset(&callarg, 0, sizeof(callarg)); 1149 SPARG(&callarg, gidsetsize) = gidsetsize; 1150 SPARG(&callarg, gidset) = gidset; 1151 1152 error = rsys_syscall(SYS_getgroups, &callarg, sizeof(callarg), retval); 1153 rsys_seterrno(error); 1154 if (error == 0) { 1155 if (sizeof(int) > sizeof(register_t)) 1156 rv = *(int *)retval; 1157 else 1158 rv = *retval; 1159 } 1160 return rv; 1161 } 1162 #ifdef RUMP_KERNEL_IS_LIBC 1163 __weak_alias(getgroups,rump___sysimpl_getgroups); 1164 __weak_alias(_getgroups,rump___sysimpl_getgroups); 1165 __strong_alias(_sys_getgroups,rump___sysimpl_getgroups); 1166 #endif /* RUMP_KERNEL_IS_LIBC */ 1167 1168 int rump___sysimpl_setgroups(int, const gid_t *); 1169 int 1170 rump___sysimpl_setgroups(int gidsetsize, const gid_t * gidset) 1171 { 1172 register_t retval[2]; 1173 int error = 0; 1174 int rv = -1; 1175 struct sys_setgroups_args callarg; 1176 1177 memset(&callarg, 0, sizeof(callarg)); 1178 SPARG(&callarg, gidsetsize) = gidsetsize; 1179 SPARG(&callarg, gidset) = gidset; 1180 1181 error = rsys_syscall(SYS_setgroups, &callarg, sizeof(callarg), retval); 1182 rsys_seterrno(error); 1183 if (error == 0) { 1184 if (sizeof(int) > sizeof(register_t)) 1185 rv = *(int *)retval; 1186 else 1187 rv = *retval; 1188 } 1189 return rv; 1190 } 1191 #ifdef RUMP_KERNEL_IS_LIBC 1192 __weak_alias(setgroups,rump___sysimpl_setgroups); 1193 __weak_alias(_setgroups,rump___sysimpl_setgroups); 1194 __strong_alias(_sys_setgroups,rump___sysimpl_setgroups); 1195 #endif /* RUMP_KERNEL_IS_LIBC */ 1196 1197 int rump___sysimpl_getpgrp(void); 1198 int 1199 rump___sysimpl_getpgrp(void ) 1200 { 1201 register_t retval[2]; 1202 int error = 0; 1203 int rv = -1; 1204 1205 error = rsys_syscall(SYS_getpgrp, NULL, 0, retval); 1206 rsys_seterrno(error); 1207 if (error == 0) { 1208 if (sizeof(int) > sizeof(register_t)) 1209 rv = *(int *)retval; 1210 else 1211 rv = *retval; 1212 } 1213 return rv; 1214 } 1215 #ifdef RUMP_KERNEL_IS_LIBC 1216 __weak_alias(getpgrp,rump___sysimpl_getpgrp); 1217 __weak_alias(_getpgrp,rump___sysimpl_getpgrp); 1218 __strong_alias(_sys_getpgrp,rump___sysimpl_getpgrp); 1219 #endif /* RUMP_KERNEL_IS_LIBC */ 1220 1221 int rump___sysimpl_setpgid(pid_t, pid_t); 1222 int 1223 rump___sysimpl_setpgid(pid_t pid, pid_t pgid) 1224 { 1225 register_t retval[2]; 1226 int error = 0; 1227 int rv = -1; 1228 struct sys_setpgid_args callarg; 1229 1230 memset(&callarg, 0, sizeof(callarg)); 1231 SPARG(&callarg, pid) = pid; 1232 SPARG(&callarg, pgid) = pgid; 1233 1234 error = rsys_syscall(SYS_setpgid, &callarg, sizeof(callarg), retval); 1235 rsys_seterrno(error); 1236 if (error == 0) { 1237 if (sizeof(int) > sizeof(register_t)) 1238 rv = *(int *)retval; 1239 else 1240 rv = *retval; 1241 } 1242 return rv; 1243 } 1244 #ifdef RUMP_KERNEL_IS_LIBC 1245 __weak_alias(setpgid,rump___sysimpl_setpgid); 1246 __weak_alias(_setpgid,rump___sysimpl_setpgid); 1247 __strong_alias(_sys_setpgid,rump___sysimpl_setpgid); 1248 #endif /* RUMP_KERNEL_IS_LIBC */ 1249 1250 int rump___sysimpl_dup2(int, int); 1251 int 1252 rump___sysimpl_dup2(int from, int to) 1253 { 1254 register_t retval[2]; 1255 int error = 0; 1256 int rv = -1; 1257 struct sys_dup2_args callarg; 1258 1259 memset(&callarg, 0, sizeof(callarg)); 1260 SPARG(&callarg, from) = from; 1261 SPARG(&callarg, to) = to; 1262 1263 error = rsys_syscall(SYS_dup2, &callarg, sizeof(callarg), retval); 1264 rsys_seterrno(error); 1265 if (error == 0) { 1266 if (sizeof(int) > sizeof(register_t)) 1267 rv = *(int *)retval; 1268 else 1269 rv = *retval; 1270 } 1271 return rv; 1272 } 1273 #ifdef RUMP_KERNEL_IS_LIBC 1274 __weak_alias(dup2,rump___sysimpl_dup2); 1275 __weak_alias(_dup2,rump___sysimpl_dup2); 1276 __strong_alias(_sys_dup2,rump___sysimpl_dup2); 1277 #endif /* RUMP_KERNEL_IS_LIBC */ 1278 1279 int rump___sysimpl_fcntl(int, int, void *); 1280 int 1281 rump___sysimpl_fcntl(int fd, int cmd, void * arg) 1282 { 1283 register_t retval[2]; 1284 int error = 0; 1285 int rv = -1; 1286 struct sys_fcntl_args callarg; 1287 1288 memset(&callarg, 0, sizeof(callarg)); 1289 SPARG(&callarg, fd) = fd; 1290 SPARG(&callarg, cmd) = cmd; 1291 SPARG(&callarg, arg) = arg; 1292 1293 error = rsys_syscall(SYS_fcntl, &callarg, sizeof(callarg), retval); 1294 rsys_seterrno(error); 1295 if (error == 0) { 1296 if (sizeof(int) > sizeof(register_t)) 1297 rv = *(int *)retval; 1298 else 1299 rv = *retval; 1300 } 1301 return rv; 1302 } 1303 #ifdef RUMP_KERNEL_IS_LIBC 1304 __weak_alias(fcntl,rump___sysimpl_fcntl); 1305 __weak_alias(_fcntl,rump___sysimpl_fcntl); 1306 __strong_alias(_sys_fcntl,rump___sysimpl_fcntl); 1307 #endif /* RUMP_KERNEL_IS_LIBC */ 1308 1309 #ifdef RUMP_SYS_COMPAT 1310 int rump___sysimpl_select(int, fd_set *, fd_set *, fd_set *, struct timeval *); 1311 int 1312 rump___sysimpl_select(int nd, fd_set * in, fd_set * ou, fd_set * ex, struct timeval * tv) 1313 { 1314 register_t retval[2]; 1315 int error = 0; 1316 int rv = -1; 1317 struct compat_50_sys_select_args callarg; 1318 1319 memset(&callarg, 0, sizeof(callarg)); 1320 SPARG(&callarg, nd) = nd; 1321 SPARG(&callarg, in) = in; 1322 SPARG(&callarg, ou) = ou; 1323 SPARG(&callarg, ex) = ex; 1324 SPARG(&callarg, tv) = (struct timeval50 *)tv; 1325 1326 error = rsys_syscall(SYS_compat_50_select, &callarg, sizeof(callarg), retval); 1327 rsys_seterrno(error); 1328 if (error == 0) { 1329 if (sizeof(int) > sizeof(register_t)) 1330 rv = *(int *)retval; 1331 else 1332 rv = *retval; 1333 } 1334 return rv; 1335 } 1336 #ifdef RUMP_KERNEL_IS_LIBC 1337 __weak_alias(select,rump___sysimpl_select); 1338 __weak_alias(_select,rump___sysimpl_select); 1339 __strong_alias(_sys_select,rump___sysimpl_select); 1340 #endif /* RUMP_KERNEL_IS_LIBC */ 1341 #endif /* RUMP_SYS_COMPAT */ 1342 1343 int rump___sysimpl_fsync(int); 1344 int 1345 rump___sysimpl_fsync(int fd) 1346 { 1347 register_t retval[2]; 1348 int error = 0; 1349 int rv = -1; 1350 struct sys_fsync_args callarg; 1351 1352 memset(&callarg, 0, sizeof(callarg)); 1353 SPARG(&callarg, fd) = fd; 1354 1355 error = rsys_syscall(SYS_fsync, &callarg, sizeof(callarg), retval); 1356 rsys_seterrno(error); 1357 if (error == 0) { 1358 if (sizeof(int) > sizeof(register_t)) 1359 rv = *(int *)retval; 1360 else 1361 rv = *retval; 1362 } 1363 return rv; 1364 } 1365 #ifdef RUMP_KERNEL_IS_LIBC 1366 __weak_alias(fsync,rump___sysimpl_fsync); 1367 __weak_alias(_fsync,rump___sysimpl_fsync); 1368 __strong_alias(_sys_fsync,rump___sysimpl_fsync); 1369 #endif /* RUMP_KERNEL_IS_LIBC */ 1370 1371 int rump___sysimpl_connect(int, const struct sockaddr *, socklen_t); 1372 int 1373 rump___sysimpl_connect(int s, const struct sockaddr * name, socklen_t namelen) 1374 { 1375 register_t retval[2]; 1376 int error = 0; 1377 int rv = -1; 1378 struct sys_connect_args callarg; 1379 1380 memset(&callarg, 0, sizeof(callarg)); 1381 SPARG(&callarg, s) = s; 1382 SPARG(&callarg, name) = name; 1383 SPARG(&callarg, namelen) = namelen; 1384 1385 error = rsys_syscall(SYS_connect, &callarg, sizeof(callarg), retval); 1386 rsys_seterrno(error); 1387 if (error == 0) { 1388 if (sizeof(int) > sizeof(register_t)) 1389 rv = *(int *)retval; 1390 else 1391 rv = *retval; 1392 } 1393 return rv; 1394 } 1395 #ifdef RUMP_KERNEL_IS_LIBC 1396 __weak_alias(connect,rump___sysimpl_connect); 1397 __weak_alias(_connect,rump___sysimpl_connect); 1398 __strong_alias(_sys_connect,rump___sysimpl_connect); 1399 #endif /* RUMP_KERNEL_IS_LIBC */ 1400 1401 int rump___sysimpl_bind(int, const struct sockaddr *, socklen_t); 1402 int 1403 rump___sysimpl_bind(int s, const struct sockaddr * name, socklen_t namelen) 1404 { 1405 register_t retval[2]; 1406 int error = 0; 1407 int rv = -1; 1408 struct sys_bind_args callarg; 1409 1410 memset(&callarg, 0, sizeof(callarg)); 1411 SPARG(&callarg, s) = s; 1412 SPARG(&callarg, name) = name; 1413 SPARG(&callarg, namelen) = namelen; 1414 1415 error = rsys_syscall(SYS_bind, &callarg, sizeof(callarg), retval); 1416 rsys_seterrno(error); 1417 if (error == 0) { 1418 if (sizeof(int) > sizeof(register_t)) 1419 rv = *(int *)retval; 1420 else 1421 rv = *retval; 1422 } 1423 return rv; 1424 } 1425 #ifdef RUMP_KERNEL_IS_LIBC 1426 __weak_alias(bind,rump___sysimpl_bind); 1427 __weak_alias(_bind,rump___sysimpl_bind); 1428 __strong_alias(_sys_bind,rump___sysimpl_bind); 1429 #endif /* RUMP_KERNEL_IS_LIBC */ 1430 1431 int rump___sysimpl_setsockopt(int, int, int, const void *, socklen_t); 1432 int 1433 rump___sysimpl_setsockopt(int s, int level, int name, const void * val, socklen_t valsize) 1434 { 1435 register_t retval[2]; 1436 int error = 0; 1437 int rv = -1; 1438 struct sys_setsockopt_args callarg; 1439 1440 memset(&callarg, 0, sizeof(callarg)); 1441 SPARG(&callarg, s) = s; 1442 SPARG(&callarg, level) = level; 1443 SPARG(&callarg, name) = name; 1444 SPARG(&callarg, val) = val; 1445 SPARG(&callarg, valsize) = valsize; 1446 1447 error = rsys_syscall(SYS_setsockopt, &callarg, sizeof(callarg), retval); 1448 rsys_seterrno(error); 1449 if (error == 0) { 1450 if (sizeof(int) > sizeof(register_t)) 1451 rv = *(int *)retval; 1452 else 1453 rv = *retval; 1454 } 1455 return rv; 1456 } 1457 #ifdef RUMP_KERNEL_IS_LIBC 1458 __weak_alias(setsockopt,rump___sysimpl_setsockopt); 1459 __weak_alias(_setsockopt,rump___sysimpl_setsockopt); 1460 __strong_alias(_sys_setsockopt,rump___sysimpl_setsockopt); 1461 #endif /* RUMP_KERNEL_IS_LIBC */ 1462 1463 int rump___sysimpl_listen(int, int); 1464 int 1465 rump___sysimpl_listen(int s, int backlog) 1466 { 1467 register_t retval[2]; 1468 int error = 0; 1469 int rv = -1; 1470 struct sys_listen_args callarg; 1471 1472 memset(&callarg, 0, sizeof(callarg)); 1473 SPARG(&callarg, s) = s; 1474 SPARG(&callarg, backlog) = backlog; 1475 1476 error = rsys_syscall(SYS_listen, &callarg, sizeof(callarg), retval); 1477 rsys_seterrno(error); 1478 if (error == 0) { 1479 if (sizeof(int) > sizeof(register_t)) 1480 rv = *(int *)retval; 1481 else 1482 rv = *retval; 1483 } 1484 return rv; 1485 } 1486 #ifdef RUMP_KERNEL_IS_LIBC 1487 __weak_alias(listen,rump___sysimpl_listen); 1488 __weak_alias(_listen,rump___sysimpl_listen); 1489 __strong_alias(_sys_listen,rump___sysimpl_listen); 1490 #endif /* RUMP_KERNEL_IS_LIBC */ 1491 1492 int rump___sysimpl_getsockopt(int, int, int, void *, socklen_t *); 1493 int 1494 rump___sysimpl_getsockopt(int s, int level, int name, void * val, socklen_t * avalsize) 1495 { 1496 register_t retval[2]; 1497 int error = 0; 1498 int rv = -1; 1499 struct sys_getsockopt_args callarg; 1500 1501 memset(&callarg, 0, sizeof(callarg)); 1502 SPARG(&callarg, s) = s; 1503 SPARG(&callarg, level) = level; 1504 SPARG(&callarg, name) = name; 1505 SPARG(&callarg, val) = val; 1506 SPARG(&callarg, avalsize) = avalsize; 1507 1508 error = rsys_syscall(SYS_getsockopt, &callarg, sizeof(callarg), retval); 1509 rsys_seterrno(error); 1510 if (error == 0) { 1511 if (sizeof(int) > sizeof(register_t)) 1512 rv = *(int *)retval; 1513 else 1514 rv = *retval; 1515 } 1516 return rv; 1517 } 1518 #ifdef RUMP_KERNEL_IS_LIBC 1519 __weak_alias(getsockopt,rump___sysimpl_getsockopt); 1520 __weak_alias(_getsockopt,rump___sysimpl_getsockopt); 1521 __strong_alias(_sys_getsockopt,rump___sysimpl_getsockopt); 1522 #endif /* RUMP_KERNEL_IS_LIBC */ 1523 1524 ssize_t rump___sysimpl_readv(int, const struct iovec *, int); 1525 ssize_t 1526 rump___sysimpl_readv(int fd, const struct iovec * iovp, int iovcnt) 1527 { 1528 register_t retval[2]; 1529 int error = 0; 1530 ssize_t rv = -1; 1531 struct sys_readv_args callarg; 1532 1533 memset(&callarg, 0, sizeof(callarg)); 1534 SPARG(&callarg, fd) = fd; 1535 SPARG(&callarg, iovp) = iovp; 1536 SPARG(&callarg, iovcnt) = iovcnt; 1537 1538 error = rsys_syscall(SYS_readv, &callarg, sizeof(callarg), retval); 1539 rsys_seterrno(error); 1540 if (error == 0) { 1541 if (sizeof(ssize_t) > sizeof(register_t)) 1542 rv = *(ssize_t *)retval; 1543 else 1544 rv = *retval; 1545 } 1546 return rv; 1547 } 1548 #ifdef RUMP_KERNEL_IS_LIBC 1549 __weak_alias(readv,rump___sysimpl_readv); 1550 __weak_alias(_readv,rump___sysimpl_readv); 1551 __strong_alias(_sys_readv,rump___sysimpl_readv); 1552 #endif /* RUMP_KERNEL_IS_LIBC */ 1553 1554 ssize_t rump___sysimpl_writev(int, const struct iovec *, int); 1555 ssize_t 1556 rump___sysimpl_writev(int fd, const struct iovec * iovp, int iovcnt) 1557 { 1558 register_t retval[2]; 1559 int error = 0; 1560 ssize_t rv = -1; 1561 struct sys_writev_args callarg; 1562 1563 memset(&callarg, 0, sizeof(callarg)); 1564 SPARG(&callarg, fd) = fd; 1565 SPARG(&callarg, iovp) = iovp; 1566 SPARG(&callarg, iovcnt) = iovcnt; 1567 1568 error = rsys_syscall(SYS_writev, &callarg, sizeof(callarg), retval); 1569 rsys_seterrno(error); 1570 if (error == 0) { 1571 if (sizeof(ssize_t) > sizeof(register_t)) 1572 rv = *(ssize_t *)retval; 1573 else 1574 rv = *retval; 1575 } 1576 return rv; 1577 } 1578 #ifdef RUMP_KERNEL_IS_LIBC 1579 __weak_alias(writev,rump___sysimpl_writev); 1580 __weak_alias(_writev,rump___sysimpl_writev); 1581 __strong_alias(_sys_writev,rump___sysimpl_writev); 1582 #endif /* RUMP_KERNEL_IS_LIBC */ 1583 1584 int rump___sysimpl_fchown(int, uid_t, gid_t); 1585 int 1586 rump___sysimpl_fchown(int fd, uid_t uid, gid_t gid) 1587 { 1588 register_t retval[2]; 1589 int error = 0; 1590 int rv = -1; 1591 struct sys_fchown_args callarg; 1592 1593 memset(&callarg, 0, sizeof(callarg)); 1594 SPARG(&callarg, fd) = fd; 1595 SPARG(&callarg, uid) = uid; 1596 SPARG(&callarg, gid) = gid; 1597 1598 error = rsys_syscall(SYS_fchown, &callarg, sizeof(callarg), retval); 1599 rsys_seterrno(error); 1600 if (error == 0) { 1601 if (sizeof(int) > sizeof(register_t)) 1602 rv = *(int *)retval; 1603 else 1604 rv = *retval; 1605 } 1606 return rv; 1607 } 1608 #ifdef RUMP_KERNEL_IS_LIBC 1609 __weak_alias(fchown,rump___sysimpl_fchown); 1610 __weak_alias(_fchown,rump___sysimpl_fchown); 1611 __strong_alias(_sys_fchown,rump___sysimpl_fchown); 1612 #endif /* RUMP_KERNEL_IS_LIBC */ 1613 1614 int rump___sysimpl_fchmod(int, mode_t); 1615 int 1616 rump___sysimpl_fchmod(int fd, mode_t mode) 1617 { 1618 register_t retval[2]; 1619 int error = 0; 1620 int rv = -1; 1621 struct sys_fchmod_args callarg; 1622 1623 memset(&callarg, 0, sizeof(callarg)); 1624 SPARG(&callarg, fd) = fd; 1625 SPARG(&callarg, mode) = mode; 1626 1627 error = rsys_syscall(SYS_fchmod, &callarg, sizeof(callarg), retval); 1628 rsys_seterrno(error); 1629 if (error == 0) { 1630 if (sizeof(int) > sizeof(register_t)) 1631 rv = *(int *)retval; 1632 else 1633 rv = *retval; 1634 } 1635 return rv; 1636 } 1637 #ifdef RUMP_KERNEL_IS_LIBC 1638 __weak_alias(fchmod,rump___sysimpl_fchmod); 1639 __weak_alias(_fchmod,rump___sysimpl_fchmod); 1640 __strong_alias(_sys_fchmod,rump___sysimpl_fchmod); 1641 #endif /* RUMP_KERNEL_IS_LIBC */ 1642 1643 int rump___sysimpl_setreuid(uid_t, uid_t); 1644 int 1645 rump___sysimpl_setreuid(uid_t ruid, uid_t euid) 1646 { 1647 register_t retval[2]; 1648 int error = 0; 1649 int rv = -1; 1650 struct sys_setreuid_args callarg; 1651 1652 memset(&callarg, 0, sizeof(callarg)); 1653 SPARG(&callarg, ruid) = ruid; 1654 SPARG(&callarg, euid) = euid; 1655 1656 error = rsys_syscall(SYS_setreuid, &callarg, sizeof(callarg), retval); 1657 rsys_seterrno(error); 1658 if (error == 0) { 1659 if (sizeof(int) > sizeof(register_t)) 1660 rv = *(int *)retval; 1661 else 1662 rv = *retval; 1663 } 1664 return rv; 1665 } 1666 #ifdef RUMP_KERNEL_IS_LIBC 1667 __weak_alias(setreuid,rump___sysimpl_setreuid); 1668 __weak_alias(_setreuid,rump___sysimpl_setreuid); 1669 __strong_alias(_sys_setreuid,rump___sysimpl_setreuid); 1670 #endif /* RUMP_KERNEL_IS_LIBC */ 1671 1672 int rump___sysimpl_setregid(gid_t, gid_t); 1673 int 1674 rump___sysimpl_setregid(gid_t rgid, gid_t egid) 1675 { 1676 register_t retval[2]; 1677 int error = 0; 1678 int rv = -1; 1679 struct sys_setregid_args callarg; 1680 1681 memset(&callarg, 0, sizeof(callarg)); 1682 SPARG(&callarg, rgid) = rgid; 1683 SPARG(&callarg, egid) = egid; 1684 1685 error = rsys_syscall(SYS_setregid, &callarg, sizeof(callarg), retval); 1686 rsys_seterrno(error); 1687 if (error == 0) { 1688 if (sizeof(int) > sizeof(register_t)) 1689 rv = *(int *)retval; 1690 else 1691 rv = *retval; 1692 } 1693 return rv; 1694 } 1695 #ifdef RUMP_KERNEL_IS_LIBC 1696 __weak_alias(setregid,rump___sysimpl_setregid); 1697 __weak_alias(_setregid,rump___sysimpl_setregid); 1698 __strong_alias(_sys_setregid,rump___sysimpl_setregid); 1699 #endif /* RUMP_KERNEL_IS_LIBC */ 1700 1701 int rump___sysimpl_rename(const char *, const char *); 1702 int 1703 rump___sysimpl_rename(const char * from, const char * to) 1704 { 1705 register_t retval[2]; 1706 int error = 0; 1707 int rv = -1; 1708 struct sys_rename_args callarg; 1709 1710 memset(&callarg, 0, sizeof(callarg)); 1711 SPARG(&callarg, from) = from; 1712 SPARG(&callarg, to) = to; 1713 1714 error = rsys_syscall(SYS_rename, &callarg, sizeof(callarg), retval); 1715 rsys_seterrno(error); 1716 if (error == 0) { 1717 if (sizeof(int) > sizeof(register_t)) 1718 rv = *(int *)retval; 1719 else 1720 rv = *retval; 1721 } 1722 return rv; 1723 } 1724 #ifdef RUMP_KERNEL_IS_LIBC 1725 __weak_alias(rename,rump___sysimpl_rename); 1726 __weak_alias(_rename,rump___sysimpl_rename); 1727 __strong_alias(_sys_rename,rump___sysimpl_rename); 1728 #endif /* RUMP_KERNEL_IS_LIBC */ 1729 1730 int rump___sysimpl_flock(int, int); 1731 int 1732 rump___sysimpl_flock(int fd, int how) 1733 { 1734 register_t retval[2]; 1735 int error = 0; 1736 int rv = -1; 1737 struct sys_flock_args callarg; 1738 1739 memset(&callarg, 0, sizeof(callarg)); 1740 SPARG(&callarg, fd) = fd; 1741 SPARG(&callarg, how) = how; 1742 1743 error = rsys_syscall(SYS_flock, &callarg, sizeof(callarg), retval); 1744 rsys_seterrno(error); 1745 if (error == 0) { 1746 if (sizeof(int) > sizeof(register_t)) 1747 rv = *(int *)retval; 1748 else 1749 rv = *retval; 1750 } 1751 return rv; 1752 } 1753 #ifdef RUMP_KERNEL_IS_LIBC 1754 __weak_alias(flock,rump___sysimpl_flock); 1755 __weak_alias(_flock,rump___sysimpl_flock); 1756 __strong_alias(_sys_flock,rump___sysimpl_flock); 1757 #endif /* RUMP_KERNEL_IS_LIBC */ 1758 1759 int rump___sysimpl_mkfifo(const char *, mode_t); 1760 int 1761 rump___sysimpl_mkfifo(const char * path, mode_t mode) 1762 { 1763 register_t retval[2]; 1764 int error = 0; 1765 int rv = -1; 1766 struct sys_mkfifo_args callarg; 1767 1768 memset(&callarg, 0, sizeof(callarg)); 1769 SPARG(&callarg, path) = path; 1770 SPARG(&callarg, mode) = mode; 1771 1772 error = rsys_syscall(SYS_mkfifo, &callarg, sizeof(callarg), retval); 1773 rsys_seterrno(error); 1774 if (error == 0) { 1775 if (sizeof(int) > sizeof(register_t)) 1776 rv = *(int *)retval; 1777 else 1778 rv = *retval; 1779 } 1780 return rv; 1781 } 1782 #ifdef RUMP_KERNEL_IS_LIBC 1783 __weak_alias(mkfifo,rump___sysimpl_mkfifo); 1784 __weak_alias(_mkfifo,rump___sysimpl_mkfifo); 1785 __strong_alias(_sys_mkfifo,rump___sysimpl_mkfifo); 1786 #endif /* RUMP_KERNEL_IS_LIBC */ 1787 1788 ssize_t rump___sysimpl_sendto(int, const void *, size_t, int, const struct sockaddr *, socklen_t); 1789 ssize_t 1790 rump___sysimpl_sendto(int s, const void * buf, size_t len, int flags, const struct sockaddr * to, socklen_t tolen) 1791 { 1792 register_t retval[2]; 1793 int error = 0; 1794 ssize_t rv = -1; 1795 struct sys_sendto_args callarg; 1796 1797 memset(&callarg, 0, sizeof(callarg)); 1798 SPARG(&callarg, s) = s; 1799 SPARG(&callarg, buf) = buf; 1800 SPARG(&callarg, len) = len; 1801 SPARG(&callarg, flags) = flags; 1802 SPARG(&callarg, to) = to; 1803 SPARG(&callarg, tolen) = tolen; 1804 1805 error = rsys_syscall(SYS_sendto, &callarg, sizeof(callarg), retval); 1806 rsys_seterrno(error); 1807 if (error == 0) { 1808 if (sizeof(ssize_t) > sizeof(register_t)) 1809 rv = *(ssize_t *)retval; 1810 else 1811 rv = *retval; 1812 } 1813 return rv; 1814 } 1815 #ifdef RUMP_KERNEL_IS_LIBC 1816 __weak_alias(sendto,rump___sysimpl_sendto); 1817 __weak_alias(_sendto,rump___sysimpl_sendto); 1818 __strong_alias(_sys_sendto,rump___sysimpl_sendto); 1819 #endif /* RUMP_KERNEL_IS_LIBC */ 1820 1821 int rump___sysimpl_shutdown(int, int); 1822 int 1823 rump___sysimpl_shutdown(int s, int how) 1824 { 1825 register_t retval[2]; 1826 int error = 0; 1827 int rv = -1; 1828 struct sys_shutdown_args callarg; 1829 1830 memset(&callarg, 0, sizeof(callarg)); 1831 SPARG(&callarg, s) = s; 1832 SPARG(&callarg, how) = how; 1833 1834 error = rsys_syscall(SYS_shutdown, &callarg, sizeof(callarg), retval); 1835 rsys_seterrno(error); 1836 if (error == 0) { 1837 if (sizeof(int) > sizeof(register_t)) 1838 rv = *(int *)retval; 1839 else 1840 rv = *retval; 1841 } 1842 return rv; 1843 } 1844 #ifdef RUMP_KERNEL_IS_LIBC 1845 __weak_alias(shutdown,rump___sysimpl_shutdown); 1846 __weak_alias(_shutdown,rump___sysimpl_shutdown); 1847 __strong_alias(_sys_shutdown,rump___sysimpl_shutdown); 1848 #endif /* RUMP_KERNEL_IS_LIBC */ 1849 1850 int rump___sysimpl_socketpair(int, int, int, int *); 1851 int 1852 rump___sysimpl_socketpair(int domain, int type, int protocol, int * rsv) 1853 { 1854 register_t retval[2]; 1855 int error = 0; 1856 int rv = -1; 1857 struct sys_socketpair_args callarg; 1858 1859 memset(&callarg, 0, sizeof(callarg)); 1860 SPARG(&callarg, domain) = domain; 1861 SPARG(&callarg, type) = type; 1862 SPARG(&callarg, protocol) = protocol; 1863 SPARG(&callarg, rsv) = rsv; 1864 1865 error = rsys_syscall(SYS_socketpair, &callarg, sizeof(callarg), retval); 1866 rsys_seterrno(error); 1867 if (error == 0) { 1868 if (sizeof(int) > sizeof(register_t)) 1869 rv = *(int *)retval; 1870 else 1871 rv = *retval; 1872 } 1873 return rv; 1874 } 1875 #ifdef RUMP_KERNEL_IS_LIBC 1876 __weak_alias(socketpair,rump___sysimpl_socketpair); 1877 __weak_alias(_socketpair,rump___sysimpl_socketpair); 1878 __strong_alias(_sys_socketpair,rump___sysimpl_socketpair); 1879 #endif /* RUMP_KERNEL_IS_LIBC */ 1880 1881 int rump___sysimpl_mkdir(const char *, mode_t); 1882 int 1883 rump___sysimpl_mkdir(const char * path, mode_t mode) 1884 { 1885 register_t retval[2]; 1886 int error = 0; 1887 int rv = -1; 1888 struct sys_mkdir_args callarg; 1889 1890 memset(&callarg, 0, sizeof(callarg)); 1891 SPARG(&callarg, path) = path; 1892 SPARG(&callarg, mode) = mode; 1893 1894 error = rsys_syscall(SYS_mkdir, &callarg, sizeof(callarg), retval); 1895 rsys_seterrno(error); 1896 if (error == 0) { 1897 if (sizeof(int) > sizeof(register_t)) 1898 rv = *(int *)retval; 1899 else 1900 rv = *retval; 1901 } 1902 return rv; 1903 } 1904 #ifdef RUMP_KERNEL_IS_LIBC 1905 __weak_alias(mkdir,rump___sysimpl_mkdir); 1906 __weak_alias(_mkdir,rump___sysimpl_mkdir); 1907 __strong_alias(_sys_mkdir,rump___sysimpl_mkdir); 1908 #endif /* RUMP_KERNEL_IS_LIBC */ 1909 1910 int rump___sysimpl_rmdir(const char *); 1911 int 1912 rump___sysimpl_rmdir(const char * path) 1913 { 1914 register_t retval[2]; 1915 int error = 0; 1916 int rv = -1; 1917 struct sys_rmdir_args callarg; 1918 1919 memset(&callarg, 0, sizeof(callarg)); 1920 SPARG(&callarg, path) = path; 1921 1922 error = rsys_syscall(SYS_rmdir, &callarg, sizeof(callarg), retval); 1923 rsys_seterrno(error); 1924 if (error == 0) { 1925 if (sizeof(int) > sizeof(register_t)) 1926 rv = *(int *)retval; 1927 else 1928 rv = *retval; 1929 } 1930 return rv; 1931 } 1932 #ifdef RUMP_KERNEL_IS_LIBC 1933 __weak_alias(rmdir,rump___sysimpl_rmdir); 1934 __weak_alias(_rmdir,rump___sysimpl_rmdir); 1935 __strong_alias(_sys_rmdir,rump___sysimpl_rmdir); 1936 #endif /* RUMP_KERNEL_IS_LIBC */ 1937 1938 #ifdef RUMP_SYS_COMPAT 1939 int rump___sysimpl_utimes(const char *, const struct timeval *); 1940 int 1941 rump___sysimpl_utimes(const char * path, const struct timeval * tptr) 1942 { 1943 register_t retval[2]; 1944 int error = 0; 1945 int rv = -1; 1946 struct compat_50_sys_utimes_args callarg; 1947 1948 memset(&callarg, 0, sizeof(callarg)); 1949 SPARG(&callarg, path) = path; 1950 SPARG(&callarg, tptr) = (const struct timeval50 *)tptr; 1951 1952 error = rsys_syscall(SYS_compat_50_utimes, &callarg, sizeof(callarg), retval); 1953 rsys_seterrno(error); 1954 if (error == 0) { 1955 if (sizeof(int) > sizeof(register_t)) 1956 rv = *(int *)retval; 1957 else 1958 rv = *retval; 1959 } 1960 return rv; 1961 } 1962 #ifdef RUMP_KERNEL_IS_LIBC 1963 __weak_alias(utimes,rump___sysimpl_utimes); 1964 __weak_alias(_utimes,rump___sysimpl_utimes); 1965 __strong_alias(_sys_utimes,rump___sysimpl_utimes); 1966 #endif /* RUMP_KERNEL_IS_LIBC */ 1967 #endif /* RUMP_SYS_COMPAT */ 1968 1969 int rump___sysimpl_setsid(void); 1970 int 1971 rump___sysimpl_setsid(void ) 1972 { 1973 register_t retval[2]; 1974 int error = 0; 1975 int rv = -1; 1976 1977 error = rsys_syscall(SYS_setsid, NULL, 0, retval); 1978 rsys_seterrno(error); 1979 if (error == 0) { 1980 if (sizeof(int) > sizeof(register_t)) 1981 rv = *(int *)retval; 1982 else 1983 rv = *retval; 1984 } 1985 return rv; 1986 } 1987 #ifdef RUMP_KERNEL_IS_LIBC 1988 __weak_alias(setsid,rump___sysimpl_setsid); 1989 __weak_alias(_setsid,rump___sysimpl_setsid); 1990 __strong_alias(_sys_setsid,rump___sysimpl_setsid); 1991 #endif /* RUMP_KERNEL_IS_LIBC */ 1992 1993 int rump___sysimpl_nfssvc(int, void *); 1994 int 1995 rump___sysimpl_nfssvc(int flag, void * argp) 1996 { 1997 register_t retval[2]; 1998 int error = 0; 1999 int rv = -1; 2000 struct sys_nfssvc_args callarg; 2001 2002 memset(&callarg, 0, sizeof(callarg)); 2003 SPARG(&callarg, flag) = flag; 2004 SPARG(&callarg, argp) = argp; 2005 2006 error = rsys_syscall(SYS_nfssvc, &callarg, sizeof(callarg), retval); 2007 rsys_seterrno(error); 2008 if (error == 0) { 2009 if (sizeof(int) > sizeof(register_t)) 2010 rv = *(int *)retval; 2011 else 2012 rv = *retval; 2013 } 2014 return rv; 2015 } 2016 #ifdef RUMP_KERNEL_IS_LIBC 2017 __weak_alias(nfssvc,rump___sysimpl_nfssvc); 2018 __weak_alias(_nfssvc,rump___sysimpl_nfssvc); 2019 __strong_alias(_sys_nfssvc,rump___sysimpl_nfssvc); 2020 #endif /* RUMP_KERNEL_IS_LIBC */ 2021 2022 ssize_t rump___sysimpl_pread(int, void *, size_t, off_t); 2023 ssize_t 2024 rump___sysimpl_pread(int fd, void * buf, size_t nbyte, off_t offset) 2025 { 2026 register_t retval[2]; 2027 int error = 0; 2028 ssize_t rv = -1; 2029 struct sys_pread_args callarg; 2030 2031 memset(&callarg, 0, sizeof(callarg)); 2032 SPARG(&callarg, fd) = fd; 2033 SPARG(&callarg, buf) = buf; 2034 SPARG(&callarg, nbyte) = nbyte; 2035 SPARG(&callarg, PAD) = 0; 2036 SPARG(&callarg, offset) = offset; 2037 2038 error = rsys_syscall(SYS_pread, &callarg, sizeof(callarg), retval); 2039 rsys_seterrno(error); 2040 if (error == 0) { 2041 if (sizeof(ssize_t) > sizeof(register_t)) 2042 rv = *(ssize_t *)retval; 2043 else 2044 rv = *retval; 2045 } 2046 return rv; 2047 } 2048 #ifdef RUMP_KERNEL_IS_LIBC 2049 __weak_alias(pread,rump___sysimpl_pread); 2050 __weak_alias(_pread,rump___sysimpl_pread); 2051 __strong_alias(_sys_pread,rump___sysimpl_pread); 2052 #endif /* RUMP_KERNEL_IS_LIBC */ 2053 2054 ssize_t rump___sysimpl_pwrite(int, const void *, size_t, off_t); 2055 ssize_t 2056 rump___sysimpl_pwrite(int fd, const void * buf, size_t nbyte, off_t offset) 2057 { 2058 register_t retval[2]; 2059 int error = 0; 2060 ssize_t rv = -1; 2061 struct sys_pwrite_args callarg; 2062 2063 memset(&callarg, 0, sizeof(callarg)); 2064 SPARG(&callarg, fd) = fd; 2065 SPARG(&callarg, buf) = buf; 2066 SPARG(&callarg, nbyte) = nbyte; 2067 SPARG(&callarg, PAD) = 0; 2068 SPARG(&callarg, offset) = offset; 2069 2070 error = rsys_syscall(SYS_pwrite, &callarg, sizeof(callarg), retval); 2071 rsys_seterrno(error); 2072 if (error == 0) { 2073 if (sizeof(ssize_t) > sizeof(register_t)) 2074 rv = *(ssize_t *)retval; 2075 else 2076 rv = *retval; 2077 } 2078 return rv; 2079 } 2080 #ifdef RUMP_KERNEL_IS_LIBC 2081 __weak_alias(pwrite,rump___sysimpl_pwrite); 2082 __weak_alias(_pwrite,rump___sysimpl_pwrite); 2083 __strong_alias(_sys_pwrite,rump___sysimpl_pwrite); 2084 #endif /* RUMP_KERNEL_IS_LIBC */ 2085 2086 int rump___sysimpl_setgid(gid_t); 2087 int 2088 rump___sysimpl_setgid(gid_t gid) 2089 { 2090 register_t retval[2]; 2091 int error = 0; 2092 int rv = -1; 2093 struct sys_setgid_args callarg; 2094 2095 memset(&callarg, 0, sizeof(callarg)); 2096 SPARG(&callarg, gid) = gid; 2097 2098 error = rsys_syscall(SYS_setgid, &callarg, sizeof(callarg), retval); 2099 rsys_seterrno(error); 2100 if (error == 0) { 2101 if (sizeof(int) > sizeof(register_t)) 2102 rv = *(int *)retval; 2103 else 2104 rv = *retval; 2105 } 2106 return rv; 2107 } 2108 #ifdef RUMP_KERNEL_IS_LIBC 2109 __weak_alias(setgid,rump___sysimpl_setgid); 2110 __weak_alias(_setgid,rump___sysimpl_setgid); 2111 __strong_alias(_sys_setgid,rump___sysimpl_setgid); 2112 #endif /* RUMP_KERNEL_IS_LIBC */ 2113 2114 int rump___sysimpl_setegid(gid_t); 2115 int 2116 rump___sysimpl_setegid(gid_t egid) 2117 { 2118 register_t retval[2]; 2119 int error = 0; 2120 int rv = -1; 2121 struct sys_setegid_args callarg; 2122 2123 memset(&callarg, 0, sizeof(callarg)); 2124 SPARG(&callarg, egid) = egid; 2125 2126 error = rsys_syscall(SYS_setegid, &callarg, sizeof(callarg), retval); 2127 rsys_seterrno(error); 2128 if (error == 0) { 2129 if (sizeof(int) > sizeof(register_t)) 2130 rv = *(int *)retval; 2131 else 2132 rv = *retval; 2133 } 2134 return rv; 2135 } 2136 #ifdef RUMP_KERNEL_IS_LIBC 2137 __weak_alias(setegid,rump___sysimpl_setegid); 2138 __weak_alias(_setegid,rump___sysimpl_setegid); 2139 __strong_alias(_sys_setegid,rump___sysimpl_setegid); 2140 #endif /* RUMP_KERNEL_IS_LIBC */ 2141 2142 int rump___sysimpl_seteuid(uid_t); 2143 int 2144 rump___sysimpl_seteuid(uid_t euid) 2145 { 2146 register_t retval[2]; 2147 int error = 0; 2148 int rv = -1; 2149 struct sys_seteuid_args callarg; 2150 2151 memset(&callarg, 0, sizeof(callarg)); 2152 SPARG(&callarg, euid) = euid; 2153 2154 error = rsys_syscall(SYS_seteuid, &callarg, sizeof(callarg), retval); 2155 rsys_seterrno(error); 2156 if (error == 0) { 2157 if (sizeof(int) > sizeof(register_t)) 2158 rv = *(int *)retval; 2159 else 2160 rv = *retval; 2161 } 2162 return rv; 2163 } 2164 #ifdef RUMP_KERNEL_IS_LIBC 2165 __weak_alias(seteuid,rump___sysimpl_seteuid); 2166 __weak_alias(_seteuid,rump___sysimpl_seteuid); 2167 __strong_alias(_sys_seteuid,rump___sysimpl_seteuid); 2168 #endif /* RUMP_KERNEL_IS_LIBC */ 2169 2170 long rump___sysimpl_pathconf(const char *, int); 2171 long 2172 rump___sysimpl_pathconf(const char * path, int name) 2173 { 2174 register_t retval[2]; 2175 int error = 0; 2176 long rv = -1; 2177 struct sys_pathconf_args callarg; 2178 2179 memset(&callarg, 0, sizeof(callarg)); 2180 SPARG(&callarg, path) = path; 2181 SPARG(&callarg, name) = name; 2182 2183 error = rsys_syscall(SYS_pathconf, &callarg, sizeof(callarg), retval); 2184 rsys_seterrno(error); 2185 if (error == 0) { 2186 if (sizeof(long) > sizeof(register_t)) 2187 rv = *(long *)retval; 2188 else 2189 rv = *retval; 2190 } 2191 return rv; 2192 } 2193 #ifdef RUMP_KERNEL_IS_LIBC 2194 __weak_alias(pathconf,rump___sysimpl_pathconf); 2195 __weak_alias(_pathconf,rump___sysimpl_pathconf); 2196 __strong_alias(_sys_pathconf,rump___sysimpl_pathconf); 2197 #endif /* RUMP_KERNEL_IS_LIBC */ 2198 2199 long rump___sysimpl_fpathconf(int, int); 2200 long 2201 rump___sysimpl_fpathconf(int fd, int name) 2202 { 2203 register_t retval[2]; 2204 int error = 0; 2205 long rv = -1; 2206 struct sys_fpathconf_args callarg; 2207 2208 memset(&callarg, 0, sizeof(callarg)); 2209 SPARG(&callarg, fd) = fd; 2210 SPARG(&callarg, name) = name; 2211 2212 error = rsys_syscall(SYS_fpathconf, &callarg, sizeof(callarg), retval); 2213 rsys_seterrno(error); 2214 if (error == 0) { 2215 if (sizeof(long) > sizeof(register_t)) 2216 rv = *(long *)retval; 2217 else 2218 rv = *retval; 2219 } 2220 return rv; 2221 } 2222 #ifdef RUMP_KERNEL_IS_LIBC 2223 __weak_alias(fpathconf,rump___sysimpl_fpathconf); 2224 __weak_alias(_fpathconf,rump___sysimpl_fpathconf); 2225 __strong_alias(_sys_fpathconf,rump___sysimpl_fpathconf); 2226 #endif /* RUMP_KERNEL_IS_LIBC */ 2227 2228 int rump___sysimpl_getrlimit(int, struct rlimit *); 2229 int 2230 rump___sysimpl_getrlimit(int which, struct rlimit * rlp) 2231 { 2232 register_t retval[2]; 2233 int error = 0; 2234 int rv = -1; 2235 struct sys_getrlimit_args callarg; 2236 2237 memset(&callarg, 0, sizeof(callarg)); 2238 SPARG(&callarg, which) = which; 2239 SPARG(&callarg, rlp) = rlp; 2240 2241 error = rsys_syscall(SYS_getrlimit, &callarg, sizeof(callarg), retval); 2242 rsys_seterrno(error); 2243 if (error == 0) { 2244 if (sizeof(int) > sizeof(register_t)) 2245 rv = *(int *)retval; 2246 else 2247 rv = *retval; 2248 } 2249 return rv; 2250 } 2251 #ifdef RUMP_KERNEL_IS_LIBC 2252 __weak_alias(getrlimit,rump___sysimpl_getrlimit); 2253 __weak_alias(_getrlimit,rump___sysimpl_getrlimit); 2254 __strong_alias(_sys_getrlimit,rump___sysimpl_getrlimit); 2255 #endif /* RUMP_KERNEL_IS_LIBC */ 2256 2257 int rump___sysimpl_setrlimit(int, const struct rlimit *); 2258 int 2259 rump___sysimpl_setrlimit(int which, const struct rlimit * rlp) 2260 { 2261 register_t retval[2]; 2262 int error = 0; 2263 int rv = -1; 2264 struct sys_setrlimit_args callarg; 2265 2266 memset(&callarg, 0, sizeof(callarg)); 2267 SPARG(&callarg, which) = which; 2268 SPARG(&callarg, rlp) = rlp; 2269 2270 error = rsys_syscall(SYS_setrlimit, &callarg, sizeof(callarg), retval); 2271 rsys_seterrno(error); 2272 if (error == 0) { 2273 if (sizeof(int) > sizeof(register_t)) 2274 rv = *(int *)retval; 2275 else 2276 rv = *retval; 2277 } 2278 return rv; 2279 } 2280 #ifdef RUMP_KERNEL_IS_LIBC 2281 __weak_alias(setrlimit,rump___sysimpl_setrlimit); 2282 __weak_alias(_setrlimit,rump___sysimpl_setrlimit); 2283 __strong_alias(_sys_setrlimit,rump___sysimpl_setrlimit); 2284 #endif /* RUMP_KERNEL_IS_LIBC */ 2285 2286 off_t rump___sysimpl_lseek(int, off_t, int); 2287 off_t 2288 rump___sysimpl_lseek(int fd, off_t offset, int whence) 2289 { 2290 register_t retval[2]; 2291 int error = 0; 2292 off_t rv = -1; 2293 struct sys_lseek_args callarg; 2294 2295 memset(&callarg, 0, sizeof(callarg)); 2296 SPARG(&callarg, fd) = fd; 2297 SPARG(&callarg, PAD) = 0; 2298 SPARG(&callarg, offset) = offset; 2299 SPARG(&callarg, whence) = whence; 2300 2301 error = rsys_syscall(SYS_lseek, &callarg, sizeof(callarg), retval); 2302 rsys_seterrno(error); 2303 if (error == 0) { 2304 if (sizeof(off_t) > sizeof(register_t)) 2305 rv = *(off_t *)retval; 2306 else 2307 rv = *retval; 2308 } 2309 return rv; 2310 } 2311 #ifdef RUMP_KERNEL_IS_LIBC 2312 __weak_alias(lseek,rump___sysimpl_lseek); 2313 __weak_alias(_lseek,rump___sysimpl_lseek); 2314 __strong_alias(_sys_lseek,rump___sysimpl_lseek); 2315 #endif /* RUMP_KERNEL_IS_LIBC */ 2316 2317 int rump___sysimpl_truncate(const char *, off_t); 2318 int 2319 rump___sysimpl_truncate(const char * path, off_t length) 2320 { 2321 register_t retval[2]; 2322 int error = 0; 2323 int rv = -1; 2324 struct sys_truncate_args callarg; 2325 2326 memset(&callarg, 0, sizeof(callarg)); 2327 SPARG(&callarg, path) = path; 2328 SPARG(&callarg, PAD) = 0; 2329 SPARG(&callarg, length) = length; 2330 2331 error = rsys_syscall(SYS_truncate, &callarg, sizeof(callarg), retval); 2332 rsys_seterrno(error); 2333 if (error == 0) { 2334 if (sizeof(int) > sizeof(register_t)) 2335 rv = *(int *)retval; 2336 else 2337 rv = *retval; 2338 } 2339 return rv; 2340 } 2341 #ifdef RUMP_KERNEL_IS_LIBC 2342 __weak_alias(truncate,rump___sysimpl_truncate); 2343 __weak_alias(_truncate,rump___sysimpl_truncate); 2344 __strong_alias(_sys_truncate,rump___sysimpl_truncate); 2345 #endif /* RUMP_KERNEL_IS_LIBC */ 2346 2347 int rump___sysimpl_ftruncate(int, off_t); 2348 int 2349 rump___sysimpl_ftruncate(int fd, off_t length) 2350 { 2351 register_t retval[2]; 2352 int error = 0; 2353 int rv = -1; 2354 struct sys_ftruncate_args callarg; 2355 2356 memset(&callarg, 0, sizeof(callarg)); 2357 SPARG(&callarg, fd) = fd; 2358 SPARG(&callarg, PAD) = 0; 2359 SPARG(&callarg, length) = length; 2360 2361 error = rsys_syscall(SYS_ftruncate, &callarg, sizeof(callarg), retval); 2362 rsys_seterrno(error); 2363 if (error == 0) { 2364 if (sizeof(int) > sizeof(register_t)) 2365 rv = *(int *)retval; 2366 else 2367 rv = *retval; 2368 } 2369 return rv; 2370 } 2371 #ifdef RUMP_KERNEL_IS_LIBC 2372 __weak_alias(ftruncate,rump___sysimpl_ftruncate); 2373 __weak_alias(_ftruncate,rump___sysimpl_ftruncate); 2374 __strong_alias(_sys_ftruncate,rump___sysimpl_ftruncate); 2375 #endif /* RUMP_KERNEL_IS_LIBC */ 2376 2377 int rump___sysimpl___sysctl(const int *, u_int, void *, size_t *, const void *, size_t); 2378 int 2379 rump___sysimpl___sysctl(const int * name, u_int namelen, void * oldv, size_t * oldlenp, const void * newv, size_t newlen) 2380 { 2381 register_t retval[2]; 2382 int error = 0; 2383 int rv = -1; 2384 struct sys___sysctl_args callarg; 2385 2386 memset(&callarg, 0, sizeof(callarg)); 2387 SPARG(&callarg, name) = name; 2388 SPARG(&callarg, namelen) = namelen; 2389 SPARG(&callarg, oldv) = oldv; 2390 SPARG(&callarg, oldlenp) = oldlenp; 2391 SPARG(&callarg, newv) = newv; 2392 SPARG(&callarg, newlen) = newlen; 2393 2394 error = rsys_syscall(SYS___sysctl, &callarg, sizeof(callarg), retval); 2395 rsys_seterrno(error); 2396 if (error == 0) { 2397 if (sizeof(int) > sizeof(register_t)) 2398 rv = *(int *)retval; 2399 else 2400 rv = *retval; 2401 } 2402 return rv; 2403 } 2404 #ifdef RUMP_KERNEL_IS_LIBC 2405 __weak_alias(__sysctl,rump___sysimpl___sysctl); 2406 __weak_alias(___sysctl,rump___sysimpl___sysctl); 2407 __strong_alias(_sys___sysctl,rump___sysimpl___sysctl); 2408 #endif /* RUMP_KERNEL_IS_LIBC */ 2409 2410 #ifdef RUMP_SYS_COMPAT 2411 int rump___sysimpl_futimes(int, const struct timeval *); 2412 int 2413 rump___sysimpl_futimes(int fd, const struct timeval * tptr) 2414 { 2415 register_t retval[2]; 2416 int error = 0; 2417 int rv = -1; 2418 struct compat_50_sys_futimes_args callarg; 2419 2420 memset(&callarg, 0, sizeof(callarg)); 2421 SPARG(&callarg, fd) = fd; 2422 SPARG(&callarg, tptr) = (const struct timeval50 *)tptr; 2423 2424 error = rsys_syscall(SYS_compat_50_futimes, &callarg, sizeof(callarg), retval); 2425 rsys_seterrno(error); 2426 if (error == 0) { 2427 if (sizeof(int) > sizeof(register_t)) 2428 rv = *(int *)retval; 2429 else 2430 rv = *retval; 2431 } 2432 return rv; 2433 } 2434 #ifdef RUMP_KERNEL_IS_LIBC 2435 __weak_alias(futimes,rump___sysimpl_futimes); 2436 __weak_alias(_futimes,rump___sysimpl_futimes); 2437 __strong_alias(_sys_futimes,rump___sysimpl_futimes); 2438 #endif /* RUMP_KERNEL_IS_LIBC */ 2439 #endif /* RUMP_SYS_COMPAT */ 2440 2441 pid_t rump___sysimpl_getpgid(pid_t); 2442 pid_t 2443 rump___sysimpl_getpgid(pid_t pid) 2444 { 2445 register_t retval[2]; 2446 int error = 0; 2447 pid_t rv = -1; 2448 struct sys_getpgid_args callarg; 2449 2450 memset(&callarg, 0, sizeof(callarg)); 2451 SPARG(&callarg, pid) = pid; 2452 2453 error = rsys_syscall(SYS_getpgid, &callarg, sizeof(callarg), retval); 2454 rsys_seterrno(error); 2455 if (error == 0) { 2456 if (sizeof(pid_t) > sizeof(register_t)) 2457 rv = *(pid_t *)retval; 2458 else 2459 rv = *retval; 2460 } 2461 return rv; 2462 } 2463 #ifdef RUMP_KERNEL_IS_LIBC 2464 __weak_alias(getpgid,rump___sysimpl_getpgid); 2465 __weak_alias(_getpgid,rump___sysimpl_getpgid); 2466 __strong_alias(_sys_getpgid,rump___sysimpl_getpgid); 2467 #endif /* RUMP_KERNEL_IS_LIBC */ 2468 2469 int rump___sysimpl_reboot(int, char *); 2470 int 2471 rump___sysimpl_reboot(int opt, char * bootstr) 2472 { 2473 register_t retval[2]; 2474 int error = 0; 2475 int rv = -1; 2476 struct sys_reboot_args callarg; 2477 2478 memset(&callarg, 0, sizeof(callarg)); 2479 SPARG(&callarg, opt) = opt; 2480 SPARG(&callarg, bootstr) = bootstr; 2481 2482 error = rsys_syscall(SYS_reboot, &callarg, sizeof(callarg), retval); 2483 rsys_seterrno(error); 2484 if (error == 0) { 2485 if (sizeof(int) > sizeof(register_t)) 2486 rv = *(int *)retval; 2487 else 2488 rv = *retval; 2489 } 2490 return rv; 2491 } 2492 #ifdef RUMP_KERNEL_IS_LIBC 2493 __weak_alias(reboot,rump___sysimpl_reboot); 2494 __weak_alias(_reboot,rump___sysimpl_reboot); 2495 __strong_alias(_sys_reboot,rump___sysimpl_reboot); 2496 #endif /* RUMP_KERNEL_IS_LIBC */ 2497 2498 int rump___sysimpl_poll(struct pollfd *, u_int, int); 2499 int 2500 rump___sysimpl_poll(struct pollfd * fds, u_int nfds, int timeout) 2501 { 2502 register_t retval[2]; 2503 int error = 0; 2504 int rv = -1; 2505 struct sys_poll_args callarg; 2506 2507 memset(&callarg, 0, sizeof(callarg)); 2508 SPARG(&callarg, fds) = fds; 2509 SPARG(&callarg, nfds) = nfds; 2510 SPARG(&callarg, timeout) = timeout; 2511 2512 error = rsys_syscall(SYS_poll, &callarg, sizeof(callarg), retval); 2513 rsys_seterrno(error); 2514 if (error == 0) { 2515 if (sizeof(int) > sizeof(register_t)) 2516 rv = *(int *)retval; 2517 else 2518 rv = *retval; 2519 } 2520 return rv; 2521 } 2522 #ifdef RUMP_KERNEL_IS_LIBC 2523 __weak_alias(poll,rump___sysimpl_poll); 2524 __weak_alias(_poll,rump___sysimpl_poll); 2525 __strong_alias(_sys_poll,rump___sysimpl_poll); 2526 #endif /* RUMP_KERNEL_IS_LIBC */ 2527 2528 int rump___sysimpl_timer_create(clockid_t, struct sigevent *, timer_t *); 2529 int 2530 rump___sysimpl_timer_create(clockid_t clock_id, struct sigevent * evp, timer_t * timerid) 2531 { 2532 register_t retval[2]; 2533 int error = 0; 2534 int rv = -1; 2535 struct sys_timer_create_args callarg; 2536 2537 memset(&callarg, 0, sizeof(callarg)); 2538 SPARG(&callarg, clock_id) = clock_id; 2539 SPARG(&callarg, evp) = evp; 2540 SPARG(&callarg, timerid) = timerid; 2541 2542 error = rsys_syscall(SYS_timer_create, &callarg, sizeof(callarg), retval); 2543 rsys_seterrno(error); 2544 if (error == 0) { 2545 if (sizeof(int) > sizeof(register_t)) 2546 rv = *(int *)retval; 2547 else 2548 rv = *retval; 2549 } 2550 return rv; 2551 } 2552 #ifdef RUMP_KERNEL_IS_LIBC 2553 __weak_alias(timer_create,rump___sysimpl_timer_create); 2554 __weak_alias(_timer_create,rump___sysimpl_timer_create); 2555 __strong_alias(_sys_timer_create,rump___sysimpl_timer_create); 2556 #endif /* RUMP_KERNEL_IS_LIBC */ 2557 2558 int rump___sysimpl_timer_delete(timer_t); 2559 int 2560 rump___sysimpl_timer_delete(timer_t timerid) 2561 { 2562 register_t retval[2]; 2563 int error = 0; 2564 int rv = -1; 2565 struct sys_timer_delete_args callarg; 2566 2567 memset(&callarg, 0, sizeof(callarg)); 2568 SPARG(&callarg, timerid) = timerid; 2569 2570 error = rsys_syscall(SYS_timer_delete, &callarg, sizeof(callarg), retval); 2571 rsys_seterrno(error); 2572 if (error == 0) { 2573 if (sizeof(int) > sizeof(register_t)) 2574 rv = *(int *)retval; 2575 else 2576 rv = *retval; 2577 } 2578 return rv; 2579 } 2580 #ifdef RUMP_KERNEL_IS_LIBC 2581 __weak_alias(timer_delete,rump___sysimpl_timer_delete); 2582 __weak_alias(_timer_delete,rump___sysimpl_timer_delete); 2583 __strong_alias(_sys_timer_delete,rump___sysimpl_timer_delete); 2584 #endif /* RUMP_KERNEL_IS_LIBC */ 2585 2586 int rump___sysimpl_timer_getoverrun(timer_t); 2587 int 2588 rump___sysimpl_timer_getoverrun(timer_t timerid) 2589 { 2590 register_t retval[2]; 2591 int error = 0; 2592 int rv = -1; 2593 struct sys_timer_getoverrun_args callarg; 2594 2595 memset(&callarg, 0, sizeof(callarg)); 2596 SPARG(&callarg, timerid) = timerid; 2597 2598 error = rsys_syscall(SYS_timer_getoverrun, &callarg, sizeof(callarg), retval); 2599 rsys_seterrno(error); 2600 if (error == 0) { 2601 if (sizeof(int) > sizeof(register_t)) 2602 rv = *(int *)retval; 2603 else 2604 rv = *retval; 2605 } 2606 return rv; 2607 } 2608 #ifdef RUMP_KERNEL_IS_LIBC 2609 __weak_alias(timer_getoverrun,rump___sysimpl_timer_getoverrun); 2610 __weak_alias(_timer_getoverrun,rump___sysimpl_timer_getoverrun); 2611 __strong_alias(_sys_timer_getoverrun,rump___sysimpl_timer_getoverrun); 2612 #endif /* RUMP_KERNEL_IS_LIBC */ 2613 2614 int rump___sysimpl_fdatasync(int); 2615 int 2616 rump___sysimpl_fdatasync(int fd) 2617 { 2618 register_t retval[2]; 2619 int error = 0; 2620 int rv = -1; 2621 struct sys_fdatasync_args callarg; 2622 2623 memset(&callarg, 0, sizeof(callarg)); 2624 SPARG(&callarg, fd) = fd; 2625 2626 error = rsys_syscall(SYS_fdatasync, &callarg, sizeof(callarg), retval); 2627 rsys_seterrno(error); 2628 if (error == 0) { 2629 if (sizeof(int) > sizeof(register_t)) 2630 rv = *(int *)retval; 2631 else 2632 rv = *retval; 2633 } 2634 return rv; 2635 } 2636 #ifdef RUMP_KERNEL_IS_LIBC 2637 __weak_alias(fdatasync,rump___sysimpl_fdatasync); 2638 __weak_alias(_fdatasync,rump___sysimpl_fdatasync); 2639 __strong_alias(_sys_fdatasync,rump___sysimpl_fdatasync); 2640 #endif /* RUMP_KERNEL_IS_LIBC */ 2641 2642 int rump___sysimpl_modctl(int, void *); 2643 int 2644 rump___sysimpl_modctl(int cmd, void * arg) 2645 { 2646 register_t retval[2]; 2647 int error = 0; 2648 int rv = -1; 2649 struct sys_modctl_args callarg; 2650 2651 memset(&callarg, 0, sizeof(callarg)); 2652 SPARG(&callarg, cmd) = cmd; 2653 SPARG(&callarg, arg) = arg; 2654 2655 error = rsys_syscall(SYS_modctl, &callarg, sizeof(callarg), retval); 2656 rsys_seterrno(error); 2657 if (error == 0) { 2658 if (sizeof(int) > sizeof(register_t)) 2659 rv = *(int *)retval; 2660 else 2661 rv = *retval; 2662 } 2663 return rv; 2664 } 2665 #ifdef RUMP_KERNEL_IS_LIBC 2666 __weak_alias(modctl,rump___sysimpl_modctl); 2667 __weak_alias(_modctl,rump___sysimpl_modctl); 2668 __strong_alias(_sys_modctl,rump___sysimpl_modctl); 2669 #endif /* RUMP_KERNEL_IS_LIBC */ 2670 2671 int rump___sysimpl__ksem_init(unsigned int, intptr_t *); 2672 int 2673 rump___sysimpl__ksem_init(unsigned int value, intptr_t * idp) 2674 { 2675 register_t retval[2]; 2676 int error = 0; 2677 int rv = -1; 2678 struct sys__ksem_init_args callarg; 2679 2680 memset(&callarg, 0, sizeof(callarg)); 2681 SPARG(&callarg, value) = value; 2682 SPARG(&callarg, idp) = idp; 2683 2684 error = rsys_syscall(SYS__ksem_init, &callarg, sizeof(callarg), retval); 2685 rsys_seterrno(error); 2686 if (error == 0) { 2687 if (sizeof(int) > sizeof(register_t)) 2688 rv = *(int *)retval; 2689 else 2690 rv = *retval; 2691 } 2692 return rv; 2693 } 2694 #ifdef RUMP_KERNEL_IS_LIBC 2695 __weak_alias(_ksem_init,rump___sysimpl__ksem_init); 2696 __weak_alias(__ksem_init,rump___sysimpl__ksem_init); 2697 __strong_alias(_sys__ksem_init,rump___sysimpl__ksem_init); 2698 #endif /* RUMP_KERNEL_IS_LIBC */ 2699 2700 int rump___sysimpl__ksem_open(const char *, int, mode_t, unsigned int, intptr_t *); 2701 int 2702 rump___sysimpl__ksem_open(const char * name, int oflag, mode_t mode, unsigned int value, intptr_t * idp) 2703 { 2704 register_t retval[2]; 2705 int error = 0; 2706 int rv = -1; 2707 struct sys__ksem_open_args callarg; 2708 2709 memset(&callarg, 0, sizeof(callarg)); 2710 SPARG(&callarg, name) = name; 2711 SPARG(&callarg, oflag) = oflag; 2712 SPARG(&callarg, mode) = mode; 2713 SPARG(&callarg, value) = value; 2714 SPARG(&callarg, idp) = idp; 2715 2716 error = rsys_syscall(SYS__ksem_open, &callarg, sizeof(callarg), retval); 2717 rsys_seterrno(error); 2718 if (error == 0) { 2719 if (sizeof(int) > sizeof(register_t)) 2720 rv = *(int *)retval; 2721 else 2722 rv = *retval; 2723 } 2724 return rv; 2725 } 2726 #ifdef RUMP_KERNEL_IS_LIBC 2727 __weak_alias(_ksem_open,rump___sysimpl__ksem_open); 2728 __weak_alias(__ksem_open,rump___sysimpl__ksem_open); 2729 __strong_alias(_sys__ksem_open,rump___sysimpl__ksem_open); 2730 #endif /* RUMP_KERNEL_IS_LIBC */ 2731 2732 int rump___sysimpl__ksem_unlink(const char *); 2733 int 2734 rump___sysimpl__ksem_unlink(const char * name) 2735 { 2736 register_t retval[2]; 2737 int error = 0; 2738 int rv = -1; 2739 struct sys__ksem_unlink_args callarg; 2740 2741 memset(&callarg, 0, sizeof(callarg)); 2742 SPARG(&callarg, name) = name; 2743 2744 error = rsys_syscall(SYS__ksem_unlink, &callarg, sizeof(callarg), retval); 2745 rsys_seterrno(error); 2746 if (error == 0) { 2747 if (sizeof(int) > sizeof(register_t)) 2748 rv = *(int *)retval; 2749 else 2750 rv = *retval; 2751 } 2752 return rv; 2753 } 2754 #ifdef RUMP_KERNEL_IS_LIBC 2755 __weak_alias(_ksem_unlink,rump___sysimpl__ksem_unlink); 2756 __weak_alias(__ksem_unlink,rump___sysimpl__ksem_unlink); 2757 __strong_alias(_sys__ksem_unlink,rump___sysimpl__ksem_unlink); 2758 #endif /* RUMP_KERNEL_IS_LIBC */ 2759 2760 int rump___sysimpl__ksem_close(intptr_t); 2761 int 2762 rump___sysimpl__ksem_close(intptr_t id) 2763 { 2764 register_t retval[2]; 2765 int error = 0; 2766 int rv = -1; 2767 struct sys__ksem_close_args callarg; 2768 2769 memset(&callarg, 0, sizeof(callarg)); 2770 SPARG(&callarg, id) = id; 2771 2772 error = rsys_syscall(SYS__ksem_close, &callarg, sizeof(callarg), retval); 2773 rsys_seterrno(error); 2774 if (error == 0) { 2775 if (sizeof(int) > sizeof(register_t)) 2776 rv = *(int *)retval; 2777 else 2778 rv = *retval; 2779 } 2780 return rv; 2781 } 2782 #ifdef RUMP_KERNEL_IS_LIBC 2783 __weak_alias(_ksem_close,rump___sysimpl__ksem_close); 2784 __weak_alias(__ksem_close,rump___sysimpl__ksem_close); 2785 __strong_alias(_sys__ksem_close,rump___sysimpl__ksem_close); 2786 #endif /* RUMP_KERNEL_IS_LIBC */ 2787 2788 int rump___sysimpl__ksem_post(intptr_t); 2789 int 2790 rump___sysimpl__ksem_post(intptr_t id) 2791 { 2792 register_t retval[2]; 2793 int error = 0; 2794 int rv = -1; 2795 struct sys__ksem_post_args callarg; 2796 2797 memset(&callarg, 0, sizeof(callarg)); 2798 SPARG(&callarg, id) = id; 2799 2800 error = rsys_syscall(SYS__ksem_post, &callarg, sizeof(callarg), retval); 2801 rsys_seterrno(error); 2802 if (error == 0) { 2803 if (sizeof(int) > sizeof(register_t)) 2804 rv = *(int *)retval; 2805 else 2806 rv = *retval; 2807 } 2808 return rv; 2809 } 2810 #ifdef RUMP_KERNEL_IS_LIBC 2811 __weak_alias(_ksem_post,rump___sysimpl__ksem_post); 2812 __weak_alias(__ksem_post,rump___sysimpl__ksem_post); 2813 __strong_alias(_sys__ksem_post,rump___sysimpl__ksem_post); 2814 #endif /* RUMP_KERNEL_IS_LIBC */ 2815 2816 int rump___sysimpl__ksem_wait(intptr_t); 2817 int 2818 rump___sysimpl__ksem_wait(intptr_t id) 2819 { 2820 register_t retval[2]; 2821 int error = 0; 2822 int rv = -1; 2823 struct sys__ksem_wait_args callarg; 2824 2825 memset(&callarg, 0, sizeof(callarg)); 2826 SPARG(&callarg, id) = id; 2827 2828 error = rsys_syscall(SYS__ksem_wait, &callarg, sizeof(callarg), retval); 2829 rsys_seterrno(error); 2830 if (error == 0) { 2831 if (sizeof(int) > sizeof(register_t)) 2832 rv = *(int *)retval; 2833 else 2834 rv = *retval; 2835 } 2836 return rv; 2837 } 2838 #ifdef RUMP_KERNEL_IS_LIBC 2839 __weak_alias(_ksem_wait,rump___sysimpl__ksem_wait); 2840 __weak_alias(__ksem_wait,rump___sysimpl__ksem_wait); 2841 __strong_alias(_sys__ksem_wait,rump___sysimpl__ksem_wait); 2842 #endif /* RUMP_KERNEL_IS_LIBC */ 2843 2844 int rump___sysimpl__ksem_trywait(intptr_t); 2845 int 2846 rump___sysimpl__ksem_trywait(intptr_t id) 2847 { 2848 register_t retval[2]; 2849 int error = 0; 2850 int rv = -1; 2851 struct sys__ksem_trywait_args callarg; 2852 2853 memset(&callarg, 0, sizeof(callarg)); 2854 SPARG(&callarg, id) = id; 2855 2856 error = rsys_syscall(SYS__ksem_trywait, &callarg, sizeof(callarg), retval); 2857 rsys_seterrno(error); 2858 if (error == 0) { 2859 if (sizeof(int) > sizeof(register_t)) 2860 rv = *(int *)retval; 2861 else 2862 rv = *retval; 2863 } 2864 return rv; 2865 } 2866 #ifdef RUMP_KERNEL_IS_LIBC 2867 __weak_alias(_ksem_trywait,rump___sysimpl__ksem_trywait); 2868 __weak_alias(__ksem_trywait,rump___sysimpl__ksem_trywait); 2869 __strong_alias(_sys__ksem_trywait,rump___sysimpl__ksem_trywait); 2870 #endif /* RUMP_KERNEL_IS_LIBC */ 2871 2872 int rump___sysimpl__ksem_getvalue(intptr_t, unsigned int *); 2873 int 2874 rump___sysimpl__ksem_getvalue(intptr_t id, unsigned int * value) 2875 { 2876 register_t retval[2]; 2877 int error = 0; 2878 int rv = -1; 2879 struct sys__ksem_getvalue_args callarg; 2880 2881 memset(&callarg, 0, sizeof(callarg)); 2882 SPARG(&callarg, id) = id; 2883 SPARG(&callarg, value) = value; 2884 2885 error = rsys_syscall(SYS__ksem_getvalue, &callarg, sizeof(callarg), retval); 2886 rsys_seterrno(error); 2887 if (error == 0) { 2888 if (sizeof(int) > sizeof(register_t)) 2889 rv = *(int *)retval; 2890 else 2891 rv = *retval; 2892 } 2893 return rv; 2894 } 2895 #ifdef RUMP_KERNEL_IS_LIBC 2896 __weak_alias(_ksem_getvalue,rump___sysimpl__ksem_getvalue); 2897 __weak_alias(__ksem_getvalue,rump___sysimpl__ksem_getvalue); 2898 __strong_alias(_sys__ksem_getvalue,rump___sysimpl__ksem_getvalue); 2899 #endif /* RUMP_KERNEL_IS_LIBC */ 2900 2901 int rump___sysimpl__ksem_destroy(intptr_t); 2902 int 2903 rump___sysimpl__ksem_destroy(intptr_t id) 2904 { 2905 register_t retval[2]; 2906 int error = 0; 2907 int rv = -1; 2908 struct sys__ksem_destroy_args callarg; 2909 2910 memset(&callarg, 0, sizeof(callarg)); 2911 SPARG(&callarg, id) = id; 2912 2913 error = rsys_syscall(SYS__ksem_destroy, &callarg, sizeof(callarg), retval); 2914 rsys_seterrno(error); 2915 if (error == 0) { 2916 if (sizeof(int) > sizeof(register_t)) 2917 rv = *(int *)retval; 2918 else 2919 rv = *retval; 2920 } 2921 return rv; 2922 } 2923 #ifdef RUMP_KERNEL_IS_LIBC 2924 __weak_alias(_ksem_destroy,rump___sysimpl__ksem_destroy); 2925 __weak_alias(__ksem_destroy,rump___sysimpl__ksem_destroy); 2926 __strong_alias(_sys__ksem_destroy,rump___sysimpl__ksem_destroy); 2927 #endif /* RUMP_KERNEL_IS_LIBC */ 2928 2929 int rump___sysimpl__ksem_timedwait(intptr_t, const struct timespec *); 2930 int 2931 rump___sysimpl__ksem_timedwait(intptr_t id, const struct timespec * abstime) 2932 { 2933 register_t retval[2]; 2934 int error = 0; 2935 int rv = -1; 2936 struct sys__ksem_timedwait_args callarg; 2937 2938 memset(&callarg, 0, sizeof(callarg)); 2939 SPARG(&callarg, id) = id; 2940 SPARG(&callarg, abstime) = abstime; 2941 2942 error = rsys_syscall(SYS__ksem_timedwait, &callarg, sizeof(callarg), retval); 2943 rsys_seterrno(error); 2944 if (error == 0) { 2945 if (sizeof(int) > sizeof(register_t)) 2946 rv = *(int *)retval; 2947 else 2948 rv = *retval; 2949 } 2950 return rv; 2951 } 2952 #ifdef RUMP_KERNEL_IS_LIBC 2953 __weak_alias(_ksem_timedwait,rump___sysimpl__ksem_timedwait); 2954 __weak_alias(__ksem_timedwait,rump___sysimpl__ksem_timedwait); 2955 __strong_alias(_sys__ksem_timedwait,rump___sysimpl__ksem_timedwait); 2956 #endif /* RUMP_KERNEL_IS_LIBC */ 2957 2958 int rump___sysimpl___posix_rename(const char *, const char *); 2959 int 2960 rump___sysimpl___posix_rename(const char * from, const char * to) 2961 { 2962 register_t retval[2]; 2963 int error = 0; 2964 int rv = -1; 2965 struct sys___posix_rename_args callarg; 2966 2967 memset(&callarg, 0, sizeof(callarg)); 2968 SPARG(&callarg, from) = from; 2969 SPARG(&callarg, to) = to; 2970 2971 error = rsys_syscall(SYS___posix_rename, &callarg, sizeof(callarg), retval); 2972 rsys_seterrno(error); 2973 if (error == 0) { 2974 if (sizeof(int) > sizeof(register_t)) 2975 rv = *(int *)retval; 2976 else 2977 rv = *retval; 2978 } 2979 return rv; 2980 } 2981 #ifdef RUMP_KERNEL_IS_LIBC 2982 __weak_alias(__posix_rename,rump___sysimpl___posix_rename); 2983 __weak_alias(___posix_rename,rump___sysimpl___posix_rename); 2984 __strong_alias(_sys___posix_rename,rump___sysimpl___posix_rename); 2985 #endif /* RUMP_KERNEL_IS_LIBC */ 2986 2987 int rump___sysimpl_lchmod(const char *, mode_t); 2988 int 2989 rump___sysimpl_lchmod(const char * path, mode_t mode) 2990 { 2991 register_t retval[2]; 2992 int error = 0; 2993 int rv = -1; 2994 struct sys_lchmod_args callarg; 2995 2996 memset(&callarg, 0, sizeof(callarg)); 2997 SPARG(&callarg, path) = path; 2998 SPARG(&callarg, mode) = mode; 2999 3000 error = rsys_syscall(SYS_lchmod, &callarg, sizeof(callarg), retval); 3001 rsys_seterrno(error); 3002 if (error == 0) { 3003 if (sizeof(int) > sizeof(register_t)) 3004 rv = *(int *)retval; 3005 else 3006 rv = *retval; 3007 } 3008 return rv; 3009 } 3010 #ifdef RUMP_KERNEL_IS_LIBC 3011 __weak_alias(lchmod,rump___sysimpl_lchmod); 3012 __weak_alias(_lchmod,rump___sysimpl_lchmod); 3013 __strong_alias(_sys_lchmod,rump___sysimpl_lchmod); 3014 #endif /* RUMP_KERNEL_IS_LIBC */ 3015 3016 int rump___sysimpl_lchown(const char *, uid_t, gid_t); 3017 int 3018 rump___sysimpl_lchown(const char * path, uid_t uid, gid_t gid) 3019 { 3020 register_t retval[2]; 3021 int error = 0; 3022 int rv = -1; 3023 struct sys_lchown_args callarg; 3024 3025 memset(&callarg, 0, sizeof(callarg)); 3026 SPARG(&callarg, path) = path; 3027 SPARG(&callarg, uid) = uid; 3028 SPARG(&callarg, gid) = gid; 3029 3030 error = rsys_syscall(SYS_lchown, &callarg, sizeof(callarg), retval); 3031 rsys_seterrno(error); 3032 if (error == 0) { 3033 if (sizeof(int) > sizeof(register_t)) 3034 rv = *(int *)retval; 3035 else 3036 rv = *retval; 3037 } 3038 return rv; 3039 } 3040 #ifdef RUMP_KERNEL_IS_LIBC 3041 __weak_alias(lchown,rump___sysimpl_lchown); 3042 __weak_alias(_lchown,rump___sysimpl_lchown); 3043 __strong_alias(_sys_lchown,rump___sysimpl_lchown); 3044 #endif /* RUMP_KERNEL_IS_LIBC */ 3045 3046 #ifdef RUMP_SYS_COMPAT 3047 int rump___sysimpl_lutimes(const char *, const struct timeval *); 3048 int 3049 rump___sysimpl_lutimes(const char * path, const struct timeval * tptr) 3050 { 3051 register_t retval[2]; 3052 int error = 0; 3053 int rv = -1; 3054 struct compat_50_sys_lutimes_args callarg; 3055 3056 memset(&callarg, 0, sizeof(callarg)); 3057 SPARG(&callarg, path) = path; 3058 SPARG(&callarg, tptr) = (const struct timeval50 *)tptr; 3059 3060 error = rsys_syscall(SYS_compat_50_lutimes, &callarg, sizeof(callarg), retval); 3061 rsys_seterrno(error); 3062 if (error == 0) { 3063 if (sizeof(int) > sizeof(register_t)) 3064 rv = *(int *)retval; 3065 else 3066 rv = *retval; 3067 } 3068 return rv; 3069 } 3070 #ifdef RUMP_KERNEL_IS_LIBC 3071 __weak_alias(lutimes,rump___sysimpl_lutimes); 3072 __weak_alias(_lutimes,rump___sysimpl_lutimes); 3073 __strong_alias(_sys_lutimes,rump___sysimpl_lutimes); 3074 #endif /* RUMP_KERNEL_IS_LIBC */ 3075 #endif /* RUMP_SYS_COMPAT */ 3076 3077 int rump___sysimpl___posix_chown(const char *, uid_t, gid_t); 3078 int 3079 rump___sysimpl___posix_chown(const char * path, uid_t uid, gid_t gid) 3080 { 3081 register_t retval[2]; 3082 int error = 0; 3083 int rv = -1; 3084 struct sys___posix_chown_args callarg; 3085 3086 memset(&callarg, 0, sizeof(callarg)); 3087 SPARG(&callarg, path) = path; 3088 SPARG(&callarg, uid) = uid; 3089 SPARG(&callarg, gid) = gid; 3090 3091 error = rsys_syscall(SYS___posix_chown, &callarg, sizeof(callarg), retval); 3092 rsys_seterrno(error); 3093 if (error == 0) { 3094 if (sizeof(int) > sizeof(register_t)) 3095 rv = *(int *)retval; 3096 else 3097 rv = *retval; 3098 } 3099 return rv; 3100 } 3101 #ifdef RUMP_KERNEL_IS_LIBC 3102 __weak_alias(__posix_chown,rump___sysimpl___posix_chown); 3103 __weak_alias(___posix_chown,rump___sysimpl___posix_chown); 3104 __strong_alias(_sys___posix_chown,rump___sysimpl___posix_chown); 3105 #endif /* RUMP_KERNEL_IS_LIBC */ 3106 3107 int rump___sysimpl___posix_fchown(int, uid_t, gid_t); 3108 int 3109 rump___sysimpl___posix_fchown(int fd, uid_t uid, gid_t gid) 3110 { 3111 register_t retval[2]; 3112 int error = 0; 3113 int rv = -1; 3114 struct sys___posix_fchown_args callarg; 3115 3116 memset(&callarg, 0, sizeof(callarg)); 3117 SPARG(&callarg, fd) = fd; 3118 SPARG(&callarg, uid) = uid; 3119 SPARG(&callarg, gid) = gid; 3120 3121 error = rsys_syscall(SYS___posix_fchown, &callarg, sizeof(callarg), retval); 3122 rsys_seterrno(error); 3123 if (error == 0) { 3124 if (sizeof(int) > sizeof(register_t)) 3125 rv = *(int *)retval; 3126 else 3127 rv = *retval; 3128 } 3129 return rv; 3130 } 3131 #ifdef RUMP_KERNEL_IS_LIBC 3132 __weak_alias(__posix_fchown,rump___sysimpl___posix_fchown); 3133 __weak_alias(___posix_fchown,rump___sysimpl___posix_fchown); 3134 __strong_alias(_sys___posix_fchown,rump___sysimpl___posix_fchown); 3135 #endif /* RUMP_KERNEL_IS_LIBC */ 3136 3137 int rump___sysimpl___posix_lchown(const char *, uid_t, gid_t); 3138 int 3139 rump___sysimpl___posix_lchown(const char * path, uid_t uid, gid_t gid) 3140 { 3141 register_t retval[2]; 3142 int error = 0; 3143 int rv = -1; 3144 struct sys___posix_lchown_args callarg; 3145 3146 memset(&callarg, 0, sizeof(callarg)); 3147 SPARG(&callarg, path) = path; 3148 SPARG(&callarg, uid) = uid; 3149 SPARG(&callarg, gid) = gid; 3150 3151 error = rsys_syscall(SYS___posix_lchown, &callarg, sizeof(callarg), retval); 3152 rsys_seterrno(error); 3153 if (error == 0) { 3154 if (sizeof(int) > sizeof(register_t)) 3155 rv = *(int *)retval; 3156 else 3157 rv = *retval; 3158 } 3159 return rv; 3160 } 3161 #ifdef RUMP_KERNEL_IS_LIBC 3162 __weak_alias(__posix_lchown,rump___sysimpl___posix_lchown); 3163 __weak_alias(___posix_lchown,rump___sysimpl___posix_lchown); 3164 __strong_alias(_sys___posix_lchown,rump___sysimpl___posix_lchown); 3165 #endif /* RUMP_KERNEL_IS_LIBC */ 3166 3167 pid_t rump___sysimpl_getsid(pid_t); 3168 pid_t 3169 rump___sysimpl_getsid(pid_t pid) 3170 { 3171 register_t retval[2]; 3172 int error = 0; 3173 pid_t rv = -1; 3174 struct sys_getsid_args callarg; 3175 3176 memset(&callarg, 0, sizeof(callarg)); 3177 SPARG(&callarg, pid) = pid; 3178 3179 error = rsys_syscall(SYS_getsid, &callarg, sizeof(callarg), retval); 3180 rsys_seterrno(error); 3181 if (error == 0) { 3182 if (sizeof(pid_t) > sizeof(register_t)) 3183 rv = *(pid_t *)retval; 3184 else 3185 rv = *retval; 3186 } 3187 return rv; 3188 } 3189 #ifdef RUMP_KERNEL_IS_LIBC 3190 __weak_alias(getsid,rump___sysimpl_getsid); 3191 __weak_alias(_getsid,rump___sysimpl_getsid); 3192 __strong_alias(_sys_getsid,rump___sysimpl_getsid); 3193 #endif /* RUMP_KERNEL_IS_LIBC */ 3194 3195 int rump___sysimpl_fktrace(int, int, int, pid_t); 3196 int 3197 rump___sysimpl_fktrace(int fd, int ops, int facs, pid_t pid) 3198 { 3199 register_t retval[2]; 3200 int error = 0; 3201 int rv = -1; 3202 struct sys_fktrace_args callarg; 3203 3204 memset(&callarg, 0, sizeof(callarg)); 3205 SPARG(&callarg, fd) = fd; 3206 SPARG(&callarg, ops) = ops; 3207 SPARG(&callarg, facs) = facs; 3208 SPARG(&callarg, pid) = pid; 3209 3210 error = rsys_syscall(SYS_fktrace, &callarg, sizeof(callarg), retval); 3211 rsys_seterrno(error); 3212 if (error == 0) { 3213 if (sizeof(int) > sizeof(register_t)) 3214 rv = *(int *)retval; 3215 else 3216 rv = *retval; 3217 } 3218 return rv; 3219 } 3220 #ifdef RUMP_KERNEL_IS_LIBC 3221 __weak_alias(fktrace,rump___sysimpl_fktrace); 3222 __weak_alias(_fktrace,rump___sysimpl_fktrace); 3223 __strong_alias(_sys_fktrace,rump___sysimpl_fktrace); 3224 #endif /* RUMP_KERNEL_IS_LIBC */ 3225 3226 ssize_t rump___sysimpl_preadv(int, const struct iovec *, int, off_t); 3227 ssize_t 3228 rump___sysimpl_preadv(int fd, const struct iovec * iovp, int iovcnt, off_t offset) 3229 { 3230 register_t retval[2]; 3231 int error = 0; 3232 ssize_t rv = -1; 3233 struct sys_preadv_args callarg; 3234 3235 memset(&callarg, 0, sizeof(callarg)); 3236 SPARG(&callarg, fd) = fd; 3237 SPARG(&callarg, iovp) = iovp; 3238 SPARG(&callarg, iovcnt) = iovcnt; 3239 SPARG(&callarg, PAD) = 0; 3240 SPARG(&callarg, offset) = offset; 3241 3242 error = rsys_syscall(SYS_preadv, &callarg, sizeof(callarg), retval); 3243 rsys_seterrno(error); 3244 if (error == 0) { 3245 if (sizeof(ssize_t) > sizeof(register_t)) 3246 rv = *(ssize_t *)retval; 3247 else 3248 rv = *retval; 3249 } 3250 return rv; 3251 } 3252 #ifdef RUMP_KERNEL_IS_LIBC 3253 __weak_alias(preadv,rump___sysimpl_preadv); 3254 __weak_alias(_preadv,rump___sysimpl_preadv); 3255 __strong_alias(_sys_preadv,rump___sysimpl_preadv); 3256 #endif /* RUMP_KERNEL_IS_LIBC */ 3257 3258 ssize_t rump___sysimpl_pwritev(int, const struct iovec *, int, off_t); 3259 ssize_t 3260 rump___sysimpl_pwritev(int fd, const struct iovec * iovp, int iovcnt, off_t offset) 3261 { 3262 register_t retval[2]; 3263 int error = 0; 3264 ssize_t rv = -1; 3265 struct sys_pwritev_args callarg; 3266 3267 memset(&callarg, 0, sizeof(callarg)); 3268 SPARG(&callarg, fd) = fd; 3269 SPARG(&callarg, iovp) = iovp; 3270 SPARG(&callarg, iovcnt) = iovcnt; 3271 SPARG(&callarg, PAD) = 0; 3272 SPARG(&callarg, offset) = offset; 3273 3274 error = rsys_syscall(SYS_pwritev, &callarg, sizeof(callarg), retval); 3275 rsys_seterrno(error); 3276 if (error == 0) { 3277 if (sizeof(ssize_t) > sizeof(register_t)) 3278 rv = *(ssize_t *)retval; 3279 else 3280 rv = *retval; 3281 } 3282 return rv; 3283 } 3284 #ifdef RUMP_KERNEL_IS_LIBC 3285 __weak_alias(pwritev,rump___sysimpl_pwritev); 3286 __weak_alias(_pwritev,rump___sysimpl_pwritev); 3287 __strong_alias(_sys_pwritev,rump___sysimpl_pwritev); 3288 #endif /* RUMP_KERNEL_IS_LIBC */ 3289 3290 int rump___sysimpl___getcwd(char *, size_t); 3291 int 3292 rump___sysimpl___getcwd(char * bufp, size_t length) 3293 { 3294 register_t retval[2]; 3295 int error = 0; 3296 int rv = -1; 3297 struct sys___getcwd_args callarg; 3298 3299 memset(&callarg, 0, sizeof(callarg)); 3300 SPARG(&callarg, bufp) = bufp; 3301 SPARG(&callarg, length) = length; 3302 3303 error = rsys_syscall(SYS___getcwd, &callarg, sizeof(callarg), retval); 3304 rsys_seterrno(error); 3305 if (error == 0) { 3306 if (sizeof(int) > sizeof(register_t)) 3307 rv = *(int *)retval; 3308 else 3309 rv = *retval; 3310 } 3311 return rv; 3312 } 3313 #ifdef RUMP_KERNEL_IS_LIBC 3314 __weak_alias(__getcwd,rump___sysimpl___getcwd); 3315 __weak_alias(___getcwd,rump___sysimpl___getcwd); 3316 __strong_alias(_sys___getcwd,rump___sysimpl___getcwd); 3317 #endif /* RUMP_KERNEL_IS_LIBC */ 3318 3319 int rump___sysimpl_fchroot(int); 3320 int 3321 rump___sysimpl_fchroot(int fd) 3322 { 3323 register_t retval[2]; 3324 int error = 0; 3325 int rv = -1; 3326 struct sys_fchroot_args callarg; 3327 3328 memset(&callarg, 0, sizeof(callarg)); 3329 SPARG(&callarg, fd) = fd; 3330 3331 error = rsys_syscall(SYS_fchroot, &callarg, sizeof(callarg), retval); 3332 rsys_seterrno(error); 3333 if (error == 0) { 3334 if (sizeof(int) > sizeof(register_t)) 3335 rv = *(int *)retval; 3336 else 3337 rv = *retval; 3338 } 3339 return rv; 3340 } 3341 #ifdef RUMP_KERNEL_IS_LIBC 3342 __weak_alias(fchroot,rump___sysimpl_fchroot); 3343 __weak_alias(_fchroot,rump___sysimpl_fchroot); 3344 __strong_alias(_sys_fchroot,rump___sysimpl_fchroot); 3345 #endif /* RUMP_KERNEL_IS_LIBC */ 3346 3347 int rump___sysimpl_lchflags(const char *, u_long); 3348 int 3349 rump___sysimpl_lchflags(const char * path, u_long flags) 3350 { 3351 register_t retval[2]; 3352 int error = 0; 3353 int rv = -1; 3354 struct sys_lchflags_args callarg; 3355 3356 memset(&callarg, 0, sizeof(callarg)); 3357 SPARG(&callarg, path) = path; 3358 SPARG(&callarg, flags) = flags; 3359 3360 error = rsys_syscall(SYS_lchflags, &callarg, sizeof(callarg), retval); 3361 rsys_seterrno(error); 3362 if (error == 0) { 3363 if (sizeof(int) > sizeof(register_t)) 3364 rv = *(int *)retval; 3365 else 3366 rv = *retval; 3367 } 3368 return rv; 3369 } 3370 #ifdef RUMP_KERNEL_IS_LIBC 3371 __weak_alias(lchflags,rump___sysimpl_lchflags); 3372 __weak_alias(_lchflags,rump___sysimpl_lchflags); 3373 __strong_alias(_sys_lchflags,rump___sysimpl_lchflags); 3374 #endif /* RUMP_KERNEL_IS_LIBC */ 3375 3376 int rump___sysimpl_issetugid(void); 3377 int 3378 rump___sysimpl_issetugid(void ) 3379 { 3380 register_t retval[2]; 3381 int rv = -1; 3382 3383 (void)rsys_syscall(SYS_issetugid, NULL, 0, retval); 3384 if (sizeof(int) > sizeof(register_t)) 3385 rv = *(int *)retval; 3386 else 3387 rv = *retval; 3388 return rv; 3389 } 3390 #ifdef RUMP_KERNEL_IS_LIBC 3391 __weak_alias(issetugid,rump___sysimpl_issetugid); 3392 __weak_alias(_issetugid,rump___sysimpl_issetugid); 3393 __strong_alias(_sys_issetugid,rump___sysimpl_issetugid); 3394 #endif /* RUMP_KERNEL_IS_LIBC */ 3395 3396 int rump___sysimpl_utrace(const char *, void *, size_t); 3397 int 3398 rump___sysimpl_utrace(const char * label, void * addr, size_t len) 3399 { 3400 register_t retval[2]; 3401 int error = 0; 3402 int rv = -1; 3403 struct sys_utrace_args callarg; 3404 3405 memset(&callarg, 0, sizeof(callarg)); 3406 SPARG(&callarg, label) = label; 3407 SPARG(&callarg, addr) = addr; 3408 SPARG(&callarg, len) = len; 3409 3410 error = rsys_syscall(SYS_utrace, &callarg, sizeof(callarg), retval); 3411 rsys_seterrno(error); 3412 if (error == 0) { 3413 if (sizeof(int) > sizeof(register_t)) 3414 rv = *(int *)retval; 3415 else 3416 rv = *retval; 3417 } 3418 return rv; 3419 } 3420 #ifdef RUMP_KERNEL_IS_LIBC 3421 __weak_alias(utrace,rump___sysimpl_utrace); 3422 __weak_alias(_utrace,rump___sysimpl_utrace); 3423 __strong_alias(_sys_utrace,rump___sysimpl_utrace); 3424 #endif /* RUMP_KERNEL_IS_LIBC */ 3425 3426 int rump___sysimpl_kqueue(void); 3427 int 3428 rump___sysimpl_kqueue(void ) 3429 { 3430 register_t retval[2]; 3431 int error = 0; 3432 int rv = -1; 3433 3434 error = rsys_syscall(SYS_kqueue, NULL, 0, retval); 3435 rsys_seterrno(error); 3436 if (error == 0) { 3437 if (sizeof(int) > sizeof(register_t)) 3438 rv = *(int *)retval; 3439 else 3440 rv = *retval; 3441 } 3442 return rv; 3443 } 3444 #ifdef RUMP_KERNEL_IS_LIBC 3445 __weak_alias(kqueue,rump___sysimpl_kqueue); 3446 __weak_alias(_kqueue,rump___sysimpl_kqueue); 3447 __strong_alias(_sys_kqueue,rump___sysimpl_kqueue); 3448 #endif /* RUMP_KERNEL_IS_LIBC */ 3449 3450 #ifdef RUMP_SYS_COMPAT 3451 int rump___sysimpl_kevent(int, const struct kevent *, size_t, struct kevent *, size_t, const struct timespec *); 3452 int 3453 rump___sysimpl_kevent(int fd, const struct kevent * changelist, size_t nchanges, struct kevent * eventlist, size_t nevents, const struct timespec * timeout) 3454 { 3455 register_t retval[2]; 3456 int error = 0; 3457 int rv = -1; 3458 struct compat_50_sys_kevent_args callarg; 3459 3460 memset(&callarg, 0, sizeof(callarg)); 3461 SPARG(&callarg, fd) = fd; 3462 SPARG(&callarg, changelist) = changelist; 3463 SPARG(&callarg, nchanges) = nchanges; 3464 SPARG(&callarg, eventlist) = eventlist; 3465 SPARG(&callarg, nevents) = nevents; 3466 SPARG(&callarg, timeout) = (const struct timespec50 *)timeout; 3467 3468 error = rsys_syscall(SYS_compat_50_kevent, &callarg, sizeof(callarg), retval); 3469 rsys_seterrno(error); 3470 if (error == 0) { 3471 if (sizeof(int) > sizeof(register_t)) 3472 rv = *(int *)retval; 3473 else 3474 rv = *retval; 3475 } 3476 return rv; 3477 } 3478 #ifdef RUMP_KERNEL_IS_LIBC 3479 __weak_alias(kevent,rump___sysimpl_kevent); 3480 __weak_alias(_kevent,rump___sysimpl_kevent); 3481 __strong_alias(_sys_kevent,rump___sysimpl_kevent); 3482 #endif /* RUMP_KERNEL_IS_LIBC */ 3483 #endif /* RUMP_SYS_COMPAT */ 3484 3485 int rump___sysimpl_fsync_range(int, int, off_t, off_t); 3486 int 3487 rump___sysimpl_fsync_range(int fd, int flags, off_t start, off_t length) 3488 { 3489 register_t retval[2]; 3490 int error = 0; 3491 int rv = -1; 3492 struct sys_fsync_range_args callarg; 3493 3494 memset(&callarg, 0, sizeof(callarg)); 3495 SPARG(&callarg, fd) = fd; 3496 SPARG(&callarg, flags) = flags; 3497 SPARG(&callarg, start) = start; 3498 SPARG(&callarg, length) = length; 3499 3500 error = rsys_syscall(SYS_fsync_range, &callarg, sizeof(callarg), retval); 3501 rsys_seterrno(error); 3502 if (error == 0) { 3503 if (sizeof(int) > sizeof(register_t)) 3504 rv = *(int *)retval; 3505 else 3506 rv = *retval; 3507 } 3508 return rv; 3509 } 3510 #ifdef RUMP_KERNEL_IS_LIBC 3511 __weak_alias(fsync_range,rump___sysimpl_fsync_range); 3512 __weak_alias(_fsync_range,rump___sysimpl_fsync_range); 3513 __strong_alias(_sys_fsync_range,rump___sysimpl_fsync_range); 3514 #endif /* RUMP_KERNEL_IS_LIBC */ 3515 3516 int rump___sysimpl_getvfsstat(struct statvfs *, size_t, int); 3517 int 3518 rump___sysimpl_getvfsstat(struct statvfs * buf, size_t bufsize, int flags) 3519 { 3520 register_t retval[2]; 3521 int error = 0; 3522 int rv = -1; 3523 struct sys_getvfsstat_args callarg; 3524 3525 memset(&callarg, 0, sizeof(callarg)); 3526 SPARG(&callarg, buf) = buf; 3527 SPARG(&callarg, bufsize) = bufsize; 3528 SPARG(&callarg, flags) = flags; 3529 3530 error = rsys_syscall(SYS_getvfsstat, &callarg, sizeof(callarg), retval); 3531 rsys_seterrno(error); 3532 if (error == 0) { 3533 if (sizeof(int) > sizeof(register_t)) 3534 rv = *(int *)retval; 3535 else 3536 rv = *retval; 3537 } 3538 return rv; 3539 } 3540 #ifdef RUMP_KERNEL_IS_LIBC 3541 __weak_alias(getvfsstat,rump___sysimpl_getvfsstat); 3542 __weak_alias(_getvfsstat,rump___sysimpl_getvfsstat); 3543 __strong_alias(_sys_getvfsstat,rump___sysimpl_getvfsstat); 3544 #endif /* RUMP_KERNEL_IS_LIBC */ 3545 3546 int rump___sysimpl_statvfs1(const char *, struct statvfs *, int); 3547 int 3548 rump___sysimpl_statvfs1(const char * path, struct statvfs * buf, int flags) 3549 { 3550 register_t retval[2]; 3551 int error = 0; 3552 int rv = -1; 3553 struct sys_statvfs1_args callarg; 3554 3555 memset(&callarg, 0, sizeof(callarg)); 3556 SPARG(&callarg, path) = path; 3557 SPARG(&callarg, buf) = buf; 3558 SPARG(&callarg, flags) = flags; 3559 3560 error = rsys_syscall(SYS_statvfs1, &callarg, sizeof(callarg), retval); 3561 rsys_seterrno(error); 3562 if (error == 0) { 3563 if (sizeof(int) > sizeof(register_t)) 3564 rv = *(int *)retval; 3565 else 3566 rv = *retval; 3567 } 3568 return rv; 3569 } 3570 #ifdef RUMP_KERNEL_IS_LIBC 3571 __weak_alias(statvfs1,rump___sysimpl_statvfs1); 3572 __weak_alias(_statvfs1,rump___sysimpl_statvfs1); 3573 __strong_alias(_sys_statvfs1,rump___sysimpl_statvfs1); 3574 #endif /* RUMP_KERNEL_IS_LIBC */ 3575 3576 int rump___sysimpl_fstatvfs1(int, struct statvfs *, int); 3577 int 3578 rump___sysimpl_fstatvfs1(int fd, struct statvfs * buf, int flags) 3579 { 3580 register_t retval[2]; 3581 int error = 0; 3582 int rv = -1; 3583 struct sys_fstatvfs1_args callarg; 3584 3585 memset(&callarg, 0, sizeof(callarg)); 3586 SPARG(&callarg, fd) = fd; 3587 SPARG(&callarg, buf) = buf; 3588 SPARG(&callarg, flags) = flags; 3589 3590 error = rsys_syscall(SYS_fstatvfs1, &callarg, sizeof(callarg), retval); 3591 rsys_seterrno(error); 3592 if (error == 0) { 3593 if (sizeof(int) > sizeof(register_t)) 3594 rv = *(int *)retval; 3595 else 3596 rv = *retval; 3597 } 3598 return rv; 3599 } 3600 #ifdef RUMP_KERNEL_IS_LIBC 3601 __weak_alias(fstatvfs1,rump___sysimpl_fstatvfs1); 3602 __weak_alias(_fstatvfs1,rump___sysimpl_fstatvfs1); 3603 __strong_alias(_sys_fstatvfs1,rump___sysimpl_fstatvfs1); 3604 #endif /* RUMP_KERNEL_IS_LIBC */ 3605 3606 int rump___sysimpl_extattrctl(const char *, int, const char *, int, const char *); 3607 int 3608 rump___sysimpl_extattrctl(const char * path, int cmd, const char * filename, int attrnamespace, const char * attrname) 3609 { 3610 register_t retval[2]; 3611 int error = 0; 3612 int rv = -1; 3613 struct sys_extattrctl_args callarg; 3614 3615 memset(&callarg, 0, sizeof(callarg)); 3616 SPARG(&callarg, path) = path; 3617 SPARG(&callarg, cmd) = cmd; 3618 SPARG(&callarg, filename) = filename; 3619 SPARG(&callarg, attrnamespace) = attrnamespace; 3620 SPARG(&callarg, attrname) = attrname; 3621 3622 error = rsys_syscall(SYS_extattrctl, &callarg, sizeof(callarg), retval); 3623 rsys_seterrno(error); 3624 if (error == 0) { 3625 if (sizeof(int) > sizeof(register_t)) 3626 rv = *(int *)retval; 3627 else 3628 rv = *retval; 3629 } 3630 return rv; 3631 } 3632 #ifdef RUMP_KERNEL_IS_LIBC 3633 __weak_alias(extattrctl,rump___sysimpl_extattrctl); 3634 __weak_alias(_extattrctl,rump___sysimpl_extattrctl); 3635 __strong_alias(_sys_extattrctl,rump___sysimpl_extattrctl); 3636 #endif /* RUMP_KERNEL_IS_LIBC */ 3637 3638 int rump___sysimpl_extattr_set_file(const char *, int, const char *, const void *, size_t); 3639 int 3640 rump___sysimpl_extattr_set_file(const char * path, int attrnamespace, const char * attrname, const void * data, size_t nbytes) 3641 { 3642 register_t retval[2]; 3643 int error = 0; 3644 int rv = -1; 3645 struct sys_extattr_set_file_args callarg; 3646 3647 memset(&callarg, 0, sizeof(callarg)); 3648 SPARG(&callarg, path) = path; 3649 SPARG(&callarg, attrnamespace) = attrnamespace; 3650 SPARG(&callarg, attrname) = attrname; 3651 SPARG(&callarg, data) = data; 3652 SPARG(&callarg, nbytes) = nbytes; 3653 3654 error = rsys_syscall(SYS_extattr_set_file, &callarg, sizeof(callarg), retval); 3655 rsys_seterrno(error); 3656 if (error == 0) { 3657 if (sizeof(int) > sizeof(register_t)) 3658 rv = *(int *)retval; 3659 else 3660 rv = *retval; 3661 } 3662 return rv; 3663 } 3664 #ifdef RUMP_KERNEL_IS_LIBC 3665 __weak_alias(extattr_set_file,rump___sysimpl_extattr_set_file); 3666 __weak_alias(_extattr_set_file,rump___sysimpl_extattr_set_file); 3667 __strong_alias(_sys_extattr_set_file,rump___sysimpl_extattr_set_file); 3668 #endif /* RUMP_KERNEL_IS_LIBC */ 3669 3670 ssize_t rump___sysimpl_extattr_get_file(const char *, int, const char *, void *, size_t); 3671 ssize_t 3672 rump___sysimpl_extattr_get_file(const char * path, int attrnamespace, const char * attrname, void * data, size_t nbytes) 3673 { 3674 register_t retval[2]; 3675 int error = 0; 3676 ssize_t rv = -1; 3677 struct sys_extattr_get_file_args callarg; 3678 3679 memset(&callarg, 0, sizeof(callarg)); 3680 SPARG(&callarg, path) = path; 3681 SPARG(&callarg, attrnamespace) = attrnamespace; 3682 SPARG(&callarg, attrname) = attrname; 3683 SPARG(&callarg, data) = data; 3684 SPARG(&callarg, nbytes) = nbytes; 3685 3686 error = rsys_syscall(SYS_extattr_get_file, &callarg, sizeof(callarg), retval); 3687 rsys_seterrno(error); 3688 if (error == 0) { 3689 if (sizeof(ssize_t) > sizeof(register_t)) 3690 rv = *(ssize_t *)retval; 3691 else 3692 rv = *retval; 3693 } 3694 return rv; 3695 } 3696 #ifdef RUMP_KERNEL_IS_LIBC 3697 __weak_alias(extattr_get_file,rump___sysimpl_extattr_get_file); 3698 __weak_alias(_extattr_get_file,rump___sysimpl_extattr_get_file); 3699 __strong_alias(_sys_extattr_get_file,rump___sysimpl_extattr_get_file); 3700 #endif /* RUMP_KERNEL_IS_LIBC */ 3701 3702 int rump___sysimpl_extattr_delete_file(const char *, int, const char *); 3703 int 3704 rump___sysimpl_extattr_delete_file(const char * path, int attrnamespace, const char * attrname) 3705 { 3706 register_t retval[2]; 3707 int error = 0; 3708 int rv = -1; 3709 struct sys_extattr_delete_file_args callarg; 3710 3711 memset(&callarg, 0, sizeof(callarg)); 3712 SPARG(&callarg, path) = path; 3713 SPARG(&callarg, attrnamespace) = attrnamespace; 3714 SPARG(&callarg, attrname) = attrname; 3715 3716 error = rsys_syscall(SYS_extattr_delete_file, &callarg, sizeof(callarg), retval); 3717 rsys_seterrno(error); 3718 if (error == 0) { 3719 if (sizeof(int) > sizeof(register_t)) 3720 rv = *(int *)retval; 3721 else 3722 rv = *retval; 3723 } 3724 return rv; 3725 } 3726 #ifdef RUMP_KERNEL_IS_LIBC 3727 __weak_alias(extattr_delete_file,rump___sysimpl_extattr_delete_file); 3728 __weak_alias(_extattr_delete_file,rump___sysimpl_extattr_delete_file); 3729 __strong_alias(_sys_extattr_delete_file,rump___sysimpl_extattr_delete_file); 3730 #endif /* RUMP_KERNEL_IS_LIBC */ 3731 3732 int rump___sysimpl_extattr_set_fd(int, int, const char *, const void *, size_t); 3733 int 3734 rump___sysimpl_extattr_set_fd(int fd, int attrnamespace, const char * attrname, const void * data, size_t nbytes) 3735 { 3736 register_t retval[2]; 3737 int error = 0; 3738 int rv = -1; 3739 struct sys_extattr_set_fd_args callarg; 3740 3741 memset(&callarg, 0, sizeof(callarg)); 3742 SPARG(&callarg, fd) = fd; 3743 SPARG(&callarg, attrnamespace) = attrnamespace; 3744 SPARG(&callarg, attrname) = attrname; 3745 SPARG(&callarg, data) = data; 3746 SPARG(&callarg, nbytes) = nbytes; 3747 3748 error = rsys_syscall(SYS_extattr_set_fd, &callarg, sizeof(callarg), retval); 3749 rsys_seterrno(error); 3750 if (error == 0) { 3751 if (sizeof(int) > sizeof(register_t)) 3752 rv = *(int *)retval; 3753 else 3754 rv = *retval; 3755 } 3756 return rv; 3757 } 3758 #ifdef RUMP_KERNEL_IS_LIBC 3759 __weak_alias(extattr_set_fd,rump___sysimpl_extattr_set_fd); 3760 __weak_alias(_extattr_set_fd,rump___sysimpl_extattr_set_fd); 3761 __strong_alias(_sys_extattr_set_fd,rump___sysimpl_extattr_set_fd); 3762 #endif /* RUMP_KERNEL_IS_LIBC */ 3763 3764 ssize_t rump___sysimpl_extattr_get_fd(int, int, const char *, void *, size_t); 3765 ssize_t 3766 rump___sysimpl_extattr_get_fd(int fd, int attrnamespace, const char * attrname, void * data, size_t nbytes) 3767 { 3768 register_t retval[2]; 3769 int error = 0; 3770 ssize_t rv = -1; 3771 struct sys_extattr_get_fd_args callarg; 3772 3773 memset(&callarg, 0, sizeof(callarg)); 3774 SPARG(&callarg, fd) = fd; 3775 SPARG(&callarg, attrnamespace) = attrnamespace; 3776 SPARG(&callarg, attrname) = attrname; 3777 SPARG(&callarg, data) = data; 3778 SPARG(&callarg, nbytes) = nbytes; 3779 3780 error = rsys_syscall(SYS_extattr_get_fd, &callarg, sizeof(callarg), retval); 3781 rsys_seterrno(error); 3782 if (error == 0) { 3783 if (sizeof(ssize_t) > sizeof(register_t)) 3784 rv = *(ssize_t *)retval; 3785 else 3786 rv = *retval; 3787 } 3788 return rv; 3789 } 3790 #ifdef RUMP_KERNEL_IS_LIBC 3791 __weak_alias(extattr_get_fd,rump___sysimpl_extattr_get_fd); 3792 __weak_alias(_extattr_get_fd,rump___sysimpl_extattr_get_fd); 3793 __strong_alias(_sys_extattr_get_fd,rump___sysimpl_extattr_get_fd); 3794 #endif /* RUMP_KERNEL_IS_LIBC */ 3795 3796 int rump___sysimpl_extattr_delete_fd(int, int, const char *); 3797 int 3798 rump___sysimpl_extattr_delete_fd(int fd, int attrnamespace, const char * attrname) 3799 { 3800 register_t retval[2]; 3801 int error = 0; 3802 int rv = -1; 3803 struct sys_extattr_delete_fd_args callarg; 3804 3805 memset(&callarg, 0, sizeof(callarg)); 3806 SPARG(&callarg, fd) = fd; 3807 SPARG(&callarg, attrnamespace) = attrnamespace; 3808 SPARG(&callarg, attrname) = attrname; 3809 3810 error = rsys_syscall(SYS_extattr_delete_fd, &callarg, sizeof(callarg), retval); 3811 rsys_seterrno(error); 3812 if (error == 0) { 3813 if (sizeof(int) > sizeof(register_t)) 3814 rv = *(int *)retval; 3815 else 3816 rv = *retval; 3817 } 3818 return rv; 3819 } 3820 #ifdef RUMP_KERNEL_IS_LIBC 3821 __weak_alias(extattr_delete_fd,rump___sysimpl_extattr_delete_fd); 3822 __weak_alias(_extattr_delete_fd,rump___sysimpl_extattr_delete_fd); 3823 __strong_alias(_sys_extattr_delete_fd,rump___sysimpl_extattr_delete_fd); 3824 #endif /* RUMP_KERNEL_IS_LIBC */ 3825 3826 int rump___sysimpl_extattr_set_link(const char *, int, const char *, const void *, size_t); 3827 int 3828 rump___sysimpl_extattr_set_link(const char * path, int attrnamespace, const char * attrname, const void * data, size_t nbytes) 3829 { 3830 register_t retval[2]; 3831 int error = 0; 3832 int rv = -1; 3833 struct sys_extattr_set_link_args callarg; 3834 3835 memset(&callarg, 0, sizeof(callarg)); 3836 SPARG(&callarg, path) = path; 3837 SPARG(&callarg, attrnamespace) = attrnamespace; 3838 SPARG(&callarg, attrname) = attrname; 3839 SPARG(&callarg, data) = data; 3840 SPARG(&callarg, nbytes) = nbytes; 3841 3842 error = rsys_syscall(SYS_extattr_set_link, &callarg, sizeof(callarg), retval); 3843 rsys_seterrno(error); 3844 if (error == 0) { 3845 if (sizeof(int) > sizeof(register_t)) 3846 rv = *(int *)retval; 3847 else 3848 rv = *retval; 3849 } 3850 return rv; 3851 } 3852 #ifdef RUMP_KERNEL_IS_LIBC 3853 __weak_alias(extattr_set_link,rump___sysimpl_extattr_set_link); 3854 __weak_alias(_extattr_set_link,rump___sysimpl_extattr_set_link); 3855 __strong_alias(_sys_extattr_set_link,rump___sysimpl_extattr_set_link); 3856 #endif /* RUMP_KERNEL_IS_LIBC */ 3857 3858 ssize_t rump___sysimpl_extattr_get_link(const char *, int, const char *, void *, size_t); 3859 ssize_t 3860 rump___sysimpl_extattr_get_link(const char * path, int attrnamespace, const char * attrname, void * data, size_t nbytes) 3861 { 3862 register_t retval[2]; 3863 int error = 0; 3864 ssize_t rv = -1; 3865 struct sys_extattr_get_link_args callarg; 3866 3867 memset(&callarg, 0, sizeof(callarg)); 3868 SPARG(&callarg, path) = path; 3869 SPARG(&callarg, attrnamespace) = attrnamespace; 3870 SPARG(&callarg, attrname) = attrname; 3871 SPARG(&callarg, data) = data; 3872 SPARG(&callarg, nbytes) = nbytes; 3873 3874 error = rsys_syscall(SYS_extattr_get_link, &callarg, sizeof(callarg), retval); 3875 rsys_seterrno(error); 3876 if (error == 0) { 3877 if (sizeof(ssize_t) > sizeof(register_t)) 3878 rv = *(ssize_t *)retval; 3879 else 3880 rv = *retval; 3881 } 3882 return rv; 3883 } 3884 #ifdef RUMP_KERNEL_IS_LIBC 3885 __weak_alias(extattr_get_link,rump___sysimpl_extattr_get_link); 3886 __weak_alias(_extattr_get_link,rump___sysimpl_extattr_get_link); 3887 __strong_alias(_sys_extattr_get_link,rump___sysimpl_extattr_get_link); 3888 #endif /* RUMP_KERNEL_IS_LIBC */ 3889 3890 int rump___sysimpl_extattr_delete_link(const char *, int, const char *); 3891 int 3892 rump___sysimpl_extattr_delete_link(const char * path, int attrnamespace, const char * attrname) 3893 { 3894 register_t retval[2]; 3895 int error = 0; 3896 int rv = -1; 3897 struct sys_extattr_delete_link_args callarg; 3898 3899 memset(&callarg, 0, sizeof(callarg)); 3900 SPARG(&callarg, path) = path; 3901 SPARG(&callarg, attrnamespace) = attrnamespace; 3902 SPARG(&callarg, attrname) = attrname; 3903 3904 error = rsys_syscall(SYS_extattr_delete_link, &callarg, sizeof(callarg), retval); 3905 rsys_seterrno(error); 3906 if (error == 0) { 3907 if (sizeof(int) > sizeof(register_t)) 3908 rv = *(int *)retval; 3909 else 3910 rv = *retval; 3911 } 3912 return rv; 3913 } 3914 #ifdef RUMP_KERNEL_IS_LIBC 3915 __weak_alias(extattr_delete_link,rump___sysimpl_extattr_delete_link); 3916 __weak_alias(_extattr_delete_link,rump___sysimpl_extattr_delete_link); 3917 __strong_alias(_sys_extattr_delete_link,rump___sysimpl_extattr_delete_link); 3918 #endif /* RUMP_KERNEL_IS_LIBC */ 3919 3920 ssize_t rump___sysimpl_extattr_list_fd(int, int, void *, size_t); 3921 ssize_t 3922 rump___sysimpl_extattr_list_fd(int fd, int attrnamespace, void * data, size_t nbytes) 3923 { 3924 register_t retval[2]; 3925 int error = 0; 3926 ssize_t rv = -1; 3927 struct sys_extattr_list_fd_args callarg; 3928 3929 memset(&callarg, 0, sizeof(callarg)); 3930 SPARG(&callarg, fd) = fd; 3931 SPARG(&callarg, attrnamespace) = attrnamespace; 3932 SPARG(&callarg, data) = data; 3933 SPARG(&callarg, nbytes) = nbytes; 3934 3935 error = rsys_syscall(SYS_extattr_list_fd, &callarg, sizeof(callarg), retval); 3936 rsys_seterrno(error); 3937 if (error == 0) { 3938 if (sizeof(ssize_t) > sizeof(register_t)) 3939 rv = *(ssize_t *)retval; 3940 else 3941 rv = *retval; 3942 } 3943 return rv; 3944 } 3945 #ifdef RUMP_KERNEL_IS_LIBC 3946 __weak_alias(extattr_list_fd,rump___sysimpl_extattr_list_fd); 3947 __weak_alias(_extattr_list_fd,rump___sysimpl_extattr_list_fd); 3948 __strong_alias(_sys_extattr_list_fd,rump___sysimpl_extattr_list_fd); 3949 #endif /* RUMP_KERNEL_IS_LIBC */ 3950 3951 ssize_t rump___sysimpl_extattr_list_file(const char *, int, void *, size_t); 3952 ssize_t 3953 rump___sysimpl_extattr_list_file(const char * path, int attrnamespace, void * data, size_t nbytes) 3954 { 3955 register_t retval[2]; 3956 int error = 0; 3957 ssize_t rv = -1; 3958 struct sys_extattr_list_file_args callarg; 3959 3960 memset(&callarg, 0, sizeof(callarg)); 3961 SPARG(&callarg, path) = path; 3962 SPARG(&callarg, attrnamespace) = attrnamespace; 3963 SPARG(&callarg, data) = data; 3964 SPARG(&callarg, nbytes) = nbytes; 3965 3966 error = rsys_syscall(SYS_extattr_list_file, &callarg, sizeof(callarg), retval); 3967 rsys_seterrno(error); 3968 if (error == 0) { 3969 if (sizeof(ssize_t) > sizeof(register_t)) 3970 rv = *(ssize_t *)retval; 3971 else 3972 rv = *retval; 3973 } 3974 return rv; 3975 } 3976 #ifdef RUMP_KERNEL_IS_LIBC 3977 __weak_alias(extattr_list_file,rump___sysimpl_extattr_list_file); 3978 __weak_alias(_extattr_list_file,rump___sysimpl_extattr_list_file); 3979 __strong_alias(_sys_extattr_list_file,rump___sysimpl_extattr_list_file); 3980 #endif /* RUMP_KERNEL_IS_LIBC */ 3981 3982 ssize_t rump___sysimpl_extattr_list_link(const char *, int, void *, size_t); 3983 ssize_t 3984 rump___sysimpl_extattr_list_link(const char * path, int attrnamespace, void * data, size_t nbytes) 3985 { 3986 register_t retval[2]; 3987 int error = 0; 3988 ssize_t rv = -1; 3989 struct sys_extattr_list_link_args callarg; 3990 3991 memset(&callarg, 0, sizeof(callarg)); 3992 SPARG(&callarg, path) = path; 3993 SPARG(&callarg, attrnamespace) = attrnamespace; 3994 SPARG(&callarg, data) = data; 3995 SPARG(&callarg, nbytes) = nbytes; 3996 3997 error = rsys_syscall(SYS_extattr_list_link, &callarg, sizeof(callarg), retval); 3998 rsys_seterrno(error); 3999 if (error == 0) { 4000 if (sizeof(ssize_t) > sizeof(register_t)) 4001 rv = *(ssize_t *)retval; 4002 else 4003 rv = *retval; 4004 } 4005 return rv; 4006 } 4007 #ifdef RUMP_KERNEL_IS_LIBC 4008 __weak_alias(extattr_list_link,rump___sysimpl_extattr_list_link); 4009 __weak_alias(_extattr_list_link,rump___sysimpl_extattr_list_link); 4010 __strong_alias(_sys_extattr_list_link,rump___sysimpl_extattr_list_link); 4011 #endif /* RUMP_KERNEL_IS_LIBC */ 4012 4013 #ifdef RUMP_SYS_COMPAT 4014 int rump___sysimpl_pselect(int, fd_set *, fd_set *, fd_set *, const struct timespec *, const sigset_t *); 4015 int 4016 rump___sysimpl_pselect(int nd, fd_set * in, fd_set * ou, fd_set * ex, const struct timespec * ts, const sigset_t * mask) 4017 { 4018 register_t retval[2]; 4019 int error = 0; 4020 int rv = -1; 4021 struct compat_50_sys_pselect_args callarg; 4022 4023 memset(&callarg, 0, sizeof(callarg)); 4024 SPARG(&callarg, nd) = nd; 4025 SPARG(&callarg, in) = in; 4026 SPARG(&callarg, ou) = ou; 4027 SPARG(&callarg, ex) = ex; 4028 SPARG(&callarg, ts) = (const struct timespec50 *)ts; 4029 SPARG(&callarg, mask) = mask; 4030 4031 error = rsys_syscall(SYS_compat_50_pselect, &callarg, sizeof(callarg), retval); 4032 rsys_seterrno(error); 4033 if (error == 0) { 4034 if (sizeof(int) > sizeof(register_t)) 4035 rv = *(int *)retval; 4036 else 4037 rv = *retval; 4038 } 4039 return rv; 4040 } 4041 #ifdef RUMP_KERNEL_IS_LIBC 4042 __weak_alias(pselect,rump___sysimpl_pselect); 4043 __weak_alias(_pselect,rump___sysimpl_pselect); 4044 __strong_alias(_sys_pselect,rump___sysimpl_pselect); 4045 #endif /* RUMP_KERNEL_IS_LIBC */ 4046 #endif /* RUMP_SYS_COMPAT */ 4047 4048 #ifdef RUMP_SYS_COMPAT 4049 int rump___sysimpl_pollts(struct pollfd *, u_int, const struct timespec *, const sigset_t *); 4050 int 4051 rump___sysimpl_pollts(struct pollfd * fds, u_int nfds, const struct timespec * ts, const sigset_t * mask) 4052 { 4053 register_t retval[2]; 4054 int error = 0; 4055 int rv = -1; 4056 struct compat_50_sys_pollts_args callarg; 4057 4058 memset(&callarg, 0, sizeof(callarg)); 4059 SPARG(&callarg, fds) = fds; 4060 SPARG(&callarg, nfds) = nfds; 4061 SPARG(&callarg, ts) = (const struct timespec50 *)ts; 4062 SPARG(&callarg, mask) = mask; 4063 4064 error = rsys_syscall(SYS_compat_50_pollts, &callarg, sizeof(callarg), retval); 4065 rsys_seterrno(error); 4066 if (error == 0) { 4067 if (sizeof(int) > sizeof(register_t)) 4068 rv = *(int *)retval; 4069 else 4070 rv = *retval; 4071 } 4072 return rv; 4073 } 4074 #ifdef RUMP_KERNEL_IS_LIBC 4075 __weak_alias(pollts,rump___sysimpl_pollts); 4076 __weak_alias(_pollts,rump___sysimpl_pollts); 4077 __strong_alias(_sys_pollts,rump___sysimpl_pollts); 4078 #endif /* RUMP_KERNEL_IS_LIBC */ 4079 #endif /* RUMP_SYS_COMPAT */ 4080 4081 int rump___sysimpl_setxattr(const char *, const char *, const void *, size_t, int); 4082 int 4083 rump___sysimpl_setxattr(const char * path, const char * name, const void * value, size_t size, int flags) 4084 { 4085 register_t retval[2]; 4086 int error = 0; 4087 int rv = -1; 4088 struct sys_setxattr_args callarg; 4089 4090 memset(&callarg, 0, sizeof(callarg)); 4091 SPARG(&callarg, path) = path; 4092 SPARG(&callarg, name) = name; 4093 SPARG(&callarg, value) = value; 4094 SPARG(&callarg, size) = size; 4095 SPARG(&callarg, flags) = flags; 4096 4097 error = rsys_syscall(SYS_setxattr, &callarg, sizeof(callarg), retval); 4098 rsys_seterrno(error); 4099 if (error == 0) { 4100 if (sizeof(int) > sizeof(register_t)) 4101 rv = *(int *)retval; 4102 else 4103 rv = *retval; 4104 } 4105 return rv; 4106 } 4107 #ifdef RUMP_KERNEL_IS_LIBC 4108 __weak_alias(setxattr,rump___sysimpl_setxattr); 4109 __weak_alias(_setxattr,rump___sysimpl_setxattr); 4110 __strong_alias(_sys_setxattr,rump___sysimpl_setxattr); 4111 #endif /* RUMP_KERNEL_IS_LIBC */ 4112 4113 int rump___sysimpl_lsetxattr(const char *, const char *, const void *, size_t, int); 4114 int 4115 rump___sysimpl_lsetxattr(const char * path, const char * name, const void * value, size_t size, int flags) 4116 { 4117 register_t retval[2]; 4118 int error = 0; 4119 int rv = -1; 4120 struct sys_lsetxattr_args callarg; 4121 4122 memset(&callarg, 0, sizeof(callarg)); 4123 SPARG(&callarg, path) = path; 4124 SPARG(&callarg, name) = name; 4125 SPARG(&callarg, value) = value; 4126 SPARG(&callarg, size) = size; 4127 SPARG(&callarg, flags) = flags; 4128 4129 error = rsys_syscall(SYS_lsetxattr, &callarg, sizeof(callarg), retval); 4130 rsys_seterrno(error); 4131 if (error == 0) { 4132 if (sizeof(int) > sizeof(register_t)) 4133 rv = *(int *)retval; 4134 else 4135 rv = *retval; 4136 } 4137 return rv; 4138 } 4139 #ifdef RUMP_KERNEL_IS_LIBC 4140 __weak_alias(lsetxattr,rump___sysimpl_lsetxattr); 4141 __weak_alias(_lsetxattr,rump___sysimpl_lsetxattr); 4142 __strong_alias(_sys_lsetxattr,rump___sysimpl_lsetxattr); 4143 #endif /* RUMP_KERNEL_IS_LIBC */ 4144 4145 int rump___sysimpl_fsetxattr(int, const char *, const void *, size_t, int); 4146 int 4147 rump___sysimpl_fsetxattr(int fd, const char * name, const void * value, size_t size, int flags) 4148 { 4149 register_t retval[2]; 4150 int error = 0; 4151 int rv = -1; 4152 struct sys_fsetxattr_args callarg; 4153 4154 memset(&callarg, 0, sizeof(callarg)); 4155 SPARG(&callarg, fd) = fd; 4156 SPARG(&callarg, name) = name; 4157 SPARG(&callarg, value) = value; 4158 SPARG(&callarg, size) = size; 4159 SPARG(&callarg, flags) = flags; 4160 4161 error = rsys_syscall(SYS_fsetxattr, &callarg, sizeof(callarg), retval); 4162 rsys_seterrno(error); 4163 if (error == 0) { 4164 if (sizeof(int) > sizeof(register_t)) 4165 rv = *(int *)retval; 4166 else 4167 rv = *retval; 4168 } 4169 return rv; 4170 } 4171 #ifdef RUMP_KERNEL_IS_LIBC 4172 __weak_alias(fsetxattr,rump___sysimpl_fsetxattr); 4173 __weak_alias(_fsetxattr,rump___sysimpl_fsetxattr); 4174 __strong_alias(_sys_fsetxattr,rump___sysimpl_fsetxattr); 4175 #endif /* RUMP_KERNEL_IS_LIBC */ 4176 4177 int rump___sysimpl_getxattr(const char *, const char *, void *, size_t); 4178 int 4179 rump___sysimpl_getxattr(const char * path, const char * name, void * value, size_t size) 4180 { 4181 register_t retval[2]; 4182 int error = 0; 4183 int rv = -1; 4184 struct sys_getxattr_args callarg; 4185 4186 memset(&callarg, 0, sizeof(callarg)); 4187 SPARG(&callarg, path) = path; 4188 SPARG(&callarg, name) = name; 4189 SPARG(&callarg, value) = value; 4190 SPARG(&callarg, size) = size; 4191 4192 error = rsys_syscall(SYS_getxattr, &callarg, sizeof(callarg), retval); 4193 rsys_seterrno(error); 4194 if (error == 0) { 4195 if (sizeof(int) > sizeof(register_t)) 4196 rv = *(int *)retval; 4197 else 4198 rv = *retval; 4199 } 4200 return rv; 4201 } 4202 #ifdef RUMP_KERNEL_IS_LIBC 4203 __weak_alias(getxattr,rump___sysimpl_getxattr); 4204 __weak_alias(_getxattr,rump___sysimpl_getxattr); 4205 __strong_alias(_sys_getxattr,rump___sysimpl_getxattr); 4206 #endif /* RUMP_KERNEL_IS_LIBC */ 4207 4208 int rump___sysimpl_lgetxattr(const char *, const char *, void *, size_t); 4209 int 4210 rump___sysimpl_lgetxattr(const char * path, const char * name, void * value, size_t size) 4211 { 4212 register_t retval[2]; 4213 int error = 0; 4214 int rv = -1; 4215 struct sys_lgetxattr_args callarg; 4216 4217 memset(&callarg, 0, sizeof(callarg)); 4218 SPARG(&callarg, path) = path; 4219 SPARG(&callarg, name) = name; 4220 SPARG(&callarg, value) = value; 4221 SPARG(&callarg, size) = size; 4222 4223 error = rsys_syscall(SYS_lgetxattr, &callarg, sizeof(callarg), retval); 4224 rsys_seterrno(error); 4225 if (error == 0) { 4226 if (sizeof(int) > sizeof(register_t)) 4227 rv = *(int *)retval; 4228 else 4229 rv = *retval; 4230 } 4231 return rv; 4232 } 4233 #ifdef RUMP_KERNEL_IS_LIBC 4234 __weak_alias(lgetxattr,rump___sysimpl_lgetxattr); 4235 __weak_alias(_lgetxattr,rump___sysimpl_lgetxattr); 4236 __strong_alias(_sys_lgetxattr,rump___sysimpl_lgetxattr); 4237 #endif /* RUMP_KERNEL_IS_LIBC */ 4238 4239 int rump___sysimpl_fgetxattr(int, const char *, void *, size_t); 4240 int 4241 rump___sysimpl_fgetxattr(int fd, const char * name, void * value, size_t size) 4242 { 4243 register_t retval[2]; 4244 int error = 0; 4245 int rv = -1; 4246 struct sys_fgetxattr_args callarg; 4247 4248 memset(&callarg, 0, sizeof(callarg)); 4249 SPARG(&callarg, fd) = fd; 4250 SPARG(&callarg, name) = name; 4251 SPARG(&callarg, value) = value; 4252 SPARG(&callarg, size) = size; 4253 4254 error = rsys_syscall(SYS_fgetxattr, &callarg, sizeof(callarg), retval); 4255 rsys_seterrno(error); 4256 if (error == 0) { 4257 if (sizeof(int) > sizeof(register_t)) 4258 rv = *(int *)retval; 4259 else 4260 rv = *retval; 4261 } 4262 return rv; 4263 } 4264 #ifdef RUMP_KERNEL_IS_LIBC 4265 __weak_alias(fgetxattr,rump___sysimpl_fgetxattr); 4266 __weak_alias(_fgetxattr,rump___sysimpl_fgetxattr); 4267 __strong_alias(_sys_fgetxattr,rump___sysimpl_fgetxattr); 4268 #endif /* RUMP_KERNEL_IS_LIBC */ 4269 4270 int rump___sysimpl_listxattr(const char *, char *, size_t); 4271 int 4272 rump___sysimpl_listxattr(const char * path, char * list, size_t size) 4273 { 4274 register_t retval[2]; 4275 int error = 0; 4276 int rv = -1; 4277 struct sys_listxattr_args callarg; 4278 4279 memset(&callarg, 0, sizeof(callarg)); 4280 SPARG(&callarg, path) = path; 4281 SPARG(&callarg, list) = list; 4282 SPARG(&callarg, size) = size; 4283 4284 error = rsys_syscall(SYS_listxattr, &callarg, sizeof(callarg), retval); 4285 rsys_seterrno(error); 4286 if (error == 0) { 4287 if (sizeof(int) > sizeof(register_t)) 4288 rv = *(int *)retval; 4289 else 4290 rv = *retval; 4291 } 4292 return rv; 4293 } 4294 #ifdef RUMP_KERNEL_IS_LIBC 4295 __weak_alias(listxattr,rump___sysimpl_listxattr); 4296 __weak_alias(_listxattr,rump___sysimpl_listxattr); 4297 __strong_alias(_sys_listxattr,rump___sysimpl_listxattr); 4298 #endif /* RUMP_KERNEL_IS_LIBC */ 4299 4300 int rump___sysimpl_llistxattr(const char *, char *, size_t); 4301 int 4302 rump___sysimpl_llistxattr(const char * path, char * list, size_t size) 4303 { 4304 register_t retval[2]; 4305 int error = 0; 4306 int rv = -1; 4307 struct sys_llistxattr_args callarg; 4308 4309 memset(&callarg, 0, sizeof(callarg)); 4310 SPARG(&callarg, path) = path; 4311 SPARG(&callarg, list) = list; 4312 SPARG(&callarg, size) = size; 4313 4314 error = rsys_syscall(SYS_llistxattr, &callarg, sizeof(callarg), retval); 4315 rsys_seterrno(error); 4316 if (error == 0) { 4317 if (sizeof(int) > sizeof(register_t)) 4318 rv = *(int *)retval; 4319 else 4320 rv = *retval; 4321 } 4322 return rv; 4323 } 4324 #ifdef RUMP_KERNEL_IS_LIBC 4325 __weak_alias(llistxattr,rump___sysimpl_llistxattr); 4326 __weak_alias(_llistxattr,rump___sysimpl_llistxattr); 4327 __strong_alias(_sys_llistxattr,rump___sysimpl_llistxattr); 4328 #endif /* RUMP_KERNEL_IS_LIBC */ 4329 4330 int rump___sysimpl_flistxattr(int, char *, size_t); 4331 int 4332 rump___sysimpl_flistxattr(int fd, char * list, size_t size) 4333 { 4334 register_t retval[2]; 4335 int error = 0; 4336 int rv = -1; 4337 struct sys_flistxattr_args callarg; 4338 4339 memset(&callarg, 0, sizeof(callarg)); 4340 SPARG(&callarg, fd) = fd; 4341 SPARG(&callarg, list) = list; 4342 SPARG(&callarg, size) = size; 4343 4344 error = rsys_syscall(SYS_flistxattr, &callarg, sizeof(callarg), retval); 4345 rsys_seterrno(error); 4346 if (error == 0) { 4347 if (sizeof(int) > sizeof(register_t)) 4348 rv = *(int *)retval; 4349 else 4350 rv = *retval; 4351 } 4352 return rv; 4353 } 4354 #ifdef RUMP_KERNEL_IS_LIBC 4355 __weak_alias(flistxattr,rump___sysimpl_flistxattr); 4356 __weak_alias(_flistxattr,rump___sysimpl_flistxattr); 4357 __strong_alias(_sys_flistxattr,rump___sysimpl_flistxattr); 4358 #endif /* RUMP_KERNEL_IS_LIBC */ 4359 4360 int rump___sysimpl_removexattr(const char *, const char *); 4361 int 4362 rump___sysimpl_removexattr(const char * path, const char * name) 4363 { 4364 register_t retval[2]; 4365 int error = 0; 4366 int rv = -1; 4367 struct sys_removexattr_args callarg; 4368 4369 memset(&callarg, 0, sizeof(callarg)); 4370 SPARG(&callarg, path) = path; 4371 SPARG(&callarg, name) = name; 4372 4373 error = rsys_syscall(SYS_removexattr, &callarg, sizeof(callarg), retval); 4374 rsys_seterrno(error); 4375 if (error == 0) { 4376 if (sizeof(int) > sizeof(register_t)) 4377 rv = *(int *)retval; 4378 else 4379 rv = *retval; 4380 } 4381 return rv; 4382 } 4383 #ifdef RUMP_KERNEL_IS_LIBC 4384 __weak_alias(removexattr,rump___sysimpl_removexattr); 4385 __weak_alias(_removexattr,rump___sysimpl_removexattr); 4386 __strong_alias(_sys_removexattr,rump___sysimpl_removexattr); 4387 #endif /* RUMP_KERNEL_IS_LIBC */ 4388 4389 int rump___sysimpl_lremovexattr(const char *, const char *); 4390 int 4391 rump___sysimpl_lremovexattr(const char * path, const char * name) 4392 { 4393 register_t retval[2]; 4394 int error = 0; 4395 int rv = -1; 4396 struct sys_lremovexattr_args callarg; 4397 4398 memset(&callarg, 0, sizeof(callarg)); 4399 SPARG(&callarg, path) = path; 4400 SPARG(&callarg, name) = name; 4401 4402 error = rsys_syscall(SYS_lremovexattr, &callarg, sizeof(callarg), retval); 4403 rsys_seterrno(error); 4404 if (error == 0) { 4405 if (sizeof(int) > sizeof(register_t)) 4406 rv = *(int *)retval; 4407 else 4408 rv = *retval; 4409 } 4410 return rv; 4411 } 4412 #ifdef RUMP_KERNEL_IS_LIBC 4413 __weak_alias(lremovexattr,rump___sysimpl_lremovexattr); 4414 __weak_alias(_lremovexattr,rump___sysimpl_lremovexattr); 4415 __strong_alias(_sys_lremovexattr,rump___sysimpl_lremovexattr); 4416 #endif /* RUMP_KERNEL_IS_LIBC */ 4417 4418 int rump___sysimpl_fremovexattr(int, const char *); 4419 int 4420 rump___sysimpl_fremovexattr(int fd, const char * name) 4421 { 4422 register_t retval[2]; 4423 int error = 0; 4424 int rv = -1; 4425 struct sys_fremovexattr_args callarg; 4426 4427 memset(&callarg, 0, sizeof(callarg)); 4428 SPARG(&callarg, fd) = fd; 4429 SPARG(&callarg, name) = name; 4430 4431 error = rsys_syscall(SYS_fremovexattr, &callarg, sizeof(callarg), retval); 4432 rsys_seterrno(error); 4433 if (error == 0) { 4434 if (sizeof(int) > sizeof(register_t)) 4435 rv = *(int *)retval; 4436 else 4437 rv = *retval; 4438 } 4439 return rv; 4440 } 4441 #ifdef RUMP_KERNEL_IS_LIBC 4442 __weak_alias(fremovexattr,rump___sysimpl_fremovexattr); 4443 __weak_alias(_fremovexattr,rump___sysimpl_fremovexattr); 4444 __strong_alias(_sys_fremovexattr,rump___sysimpl_fremovexattr); 4445 #endif /* RUMP_KERNEL_IS_LIBC */ 4446 4447 #ifdef RUMP_SYS_COMPAT 4448 int rump___sysimpl_stat30(const char *, struct stat *); 4449 int 4450 rump___sysimpl_stat30(const char * path, struct stat * ub) 4451 { 4452 register_t retval[2]; 4453 int error = 0; 4454 int rv = -1; 4455 struct compat_50_sys___stat30_args callarg; 4456 4457 memset(&callarg, 0, sizeof(callarg)); 4458 SPARG(&callarg, path) = path; 4459 SPARG(&callarg, ub) = (struct stat30 *)ub; 4460 4461 error = rsys_syscall(SYS_compat_50___stat30, &callarg, sizeof(callarg), retval); 4462 rsys_seterrno(error); 4463 if (error == 0) { 4464 if (sizeof(int) > sizeof(register_t)) 4465 rv = *(int *)retval; 4466 else 4467 rv = *retval; 4468 } 4469 return rv; 4470 } 4471 #ifdef RUMP_KERNEL_IS_LIBC 4472 __weak_alias(stat,rump___sysimpl_stat30); 4473 __weak_alias(__stat30,rump___sysimpl_stat30); 4474 __weak_alias(___stat30,rump___sysimpl_stat30); 4475 __strong_alias(_sys___stat30,rump___sysimpl_stat30); 4476 #endif /* RUMP_KERNEL_IS_LIBC */ 4477 #endif /* RUMP_SYS_COMPAT */ 4478 4479 #ifdef RUMP_SYS_COMPAT 4480 int rump___sysimpl_fstat30(int, struct stat *); 4481 int 4482 rump___sysimpl_fstat30(int fd, struct stat * sb) 4483 { 4484 register_t retval[2]; 4485 int error = 0; 4486 int rv = -1; 4487 struct compat_50_sys___fstat30_args callarg; 4488 4489 memset(&callarg, 0, sizeof(callarg)); 4490 SPARG(&callarg, fd) = fd; 4491 SPARG(&callarg, sb) = (struct stat30 *)sb; 4492 4493 error = rsys_syscall(SYS_compat_50___fstat30, &callarg, sizeof(callarg), retval); 4494 rsys_seterrno(error); 4495 if (error == 0) { 4496 if (sizeof(int) > sizeof(register_t)) 4497 rv = *(int *)retval; 4498 else 4499 rv = *retval; 4500 } 4501 return rv; 4502 } 4503 #ifdef RUMP_KERNEL_IS_LIBC 4504 __weak_alias(fstat,rump___sysimpl_fstat30); 4505 __weak_alias(__fstat30,rump___sysimpl_fstat30); 4506 __weak_alias(___fstat30,rump___sysimpl_fstat30); 4507 __strong_alias(_sys___fstat30,rump___sysimpl_fstat30); 4508 #endif /* RUMP_KERNEL_IS_LIBC */ 4509 #endif /* RUMP_SYS_COMPAT */ 4510 4511 #ifdef RUMP_SYS_COMPAT 4512 int rump___sysimpl_lstat30(const char *, struct stat *); 4513 int 4514 rump___sysimpl_lstat30(const char * path, struct stat * ub) 4515 { 4516 register_t retval[2]; 4517 int error = 0; 4518 int rv = -1; 4519 struct compat_50_sys___lstat30_args callarg; 4520 4521 memset(&callarg, 0, sizeof(callarg)); 4522 SPARG(&callarg, path) = path; 4523 SPARG(&callarg, ub) = (struct stat30 *)ub; 4524 4525 error = rsys_syscall(SYS_compat_50___lstat30, &callarg, sizeof(callarg), retval); 4526 rsys_seterrno(error); 4527 if (error == 0) { 4528 if (sizeof(int) > sizeof(register_t)) 4529 rv = *(int *)retval; 4530 else 4531 rv = *retval; 4532 } 4533 return rv; 4534 } 4535 #ifdef RUMP_KERNEL_IS_LIBC 4536 __weak_alias(lstat,rump___sysimpl_lstat30); 4537 __weak_alias(__lstat30,rump___sysimpl_lstat30); 4538 __weak_alias(___lstat30,rump___sysimpl_lstat30); 4539 __strong_alias(_sys___lstat30,rump___sysimpl_lstat30); 4540 #endif /* RUMP_KERNEL_IS_LIBC */ 4541 #endif /* RUMP_SYS_COMPAT */ 4542 4543 int rump___sysimpl_getdents30(int, char *, size_t); 4544 int 4545 rump___sysimpl_getdents30(int fd, char * buf, size_t count) 4546 { 4547 register_t retval[2]; 4548 int error = 0; 4549 int rv = -1; 4550 struct sys___getdents30_args callarg; 4551 4552 memset(&callarg, 0, sizeof(callarg)); 4553 SPARG(&callarg, fd) = fd; 4554 SPARG(&callarg, buf) = buf; 4555 SPARG(&callarg, count) = count; 4556 4557 error = rsys_syscall(SYS___getdents30, &callarg, sizeof(callarg), retval); 4558 rsys_seterrno(error); 4559 if (error == 0) { 4560 if (sizeof(int) > sizeof(register_t)) 4561 rv = *(int *)retval; 4562 else 4563 rv = *retval; 4564 } 4565 return rv; 4566 } 4567 #ifdef RUMP_KERNEL_IS_LIBC 4568 __weak_alias(getdents,rump___sysimpl_getdents30); 4569 __weak_alias(__getdents30,rump___sysimpl_getdents30); 4570 __weak_alias(___getdents30,rump___sysimpl_getdents30); 4571 __strong_alias(_sys___getdents30,rump___sysimpl_getdents30); 4572 #endif /* RUMP_KERNEL_IS_LIBC */ 4573 4574 int rump___sysimpl_socket30(int, int, int); 4575 int 4576 rump___sysimpl_socket30(int domain, int type, int protocol) 4577 { 4578 register_t retval[2]; 4579 int error = 0; 4580 int rv = -1; 4581 struct sys___socket30_args callarg; 4582 4583 memset(&callarg, 0, sizeof(callarg)); 4584 SPARG(&callarg, domain) = domain; 4585 SPARG(&callarg, type) = type; 4586 SPARG(&callarg, protocol) = protocol; 4587 4588 error = rsys_syscall(SYS___socket30, &callarg, sizeof(callarg), retval); 4589 rsys_seterrno(error); 4590 if (error == 0) { 4591 if (sizeof(int) > sizeof(register_t)) 4592 rv = *(int *)retval; 4593 else 4594 rv = *retval; 4595 } 4596 return rv; 4597 } 4598 #ifdef RUMP_KERNEL_IS_LIBC 4599 __weak_alias(socket,rump___sysimpl_socket30); 4600 __weak_alias(__socket30,rump___sysimpl_socket30); 4601 __weak_alias(___socket30,rump___sysimpl_socket30); 4602 __strong_alias(_sys___socket30,rump___sysimpl_socket30); 4603 #endif /* RUMP_KERNEL_IS_LIBC */ 4604 4605 int rump___sysimpl_getfh30(const char *, void *, size_t *); 4606 int 4607 rump___sysimpl_getfh30(const char * fname, void * fhp, size_t * fh_size) 4608 { 4609 register_t retval[2]; 4610 int error = 0; 4611 int rv = -1; 4612 struct sys___getfh30_args callarg; 4613 4614 memset(&callarg, 0, sizeof(callarg)); 4615 SPARG(&callarg, fname) = fname; 4616 SPARG(&callarg, fhp) = fhp; 4617 SPARG(&callarg, fh_size) = fh_size; 4618 4619 error = rsys_syscall(SYS___getfh30, &callarg, sizeof(callarg), retval); 4620 rsys_seterrno(error); 4621 if (error == 0) { 4622 if (sizeof(int) > sizeof(register_t)) 4623 rv = *(int *)retval; 4624 else 4625 rv = *retval; 4626 } 4627 return rv; 4628 } 4629 #ifdef RUMP_KERNEL_IS_LIBC 4630 __weak_alias(getfh,rump___sysimpl_getfh30); 4631 __weak_alias(__getfh30,rump___sysimpl_getfh30); 4632 __weak_alias(___getfh30,rump___sysimpl_getfh30); 4633 __strong_alias(_sys___getfh30,rump___sysimpl_getfh30); 4634 #endif /* RUMP_KERNEL_IS_LIBC */ 4635 4636 int rump___sysimpl_fhopen40(const void *, size_t, int); 4637 int 4638 rump___sysimpl_fhopen40(const void * fhp, size_t fh_size, int flags) 4639 { 4640 register_t retval[2]; 4641 int error = 0; 4642 int rv = -1; 4643 struct sys___fhopen40_args callarg; 4644 4645 memset(&callarg, 0, sizeof(callarg)); 4646 SPARG(&callarg, fhp) = fhp; 4647 SPARG(&callarg, fh_size) = fh_size; 4648 SPARG(&callarg, flags) = flags; 4649 4650 error = rsys_syscall(SYS___fhopen40, &callarg, sizeof(callarg), retval); 4651 rsys_seterrno(error); 4652 if (error == 0) { 4653 if (sizeof(int) > sizeof(register_t)) 4654 rv = *(int *)retval; 4655 else 4656 rv = *retval; 4657 } 4658 return rv; 4659 } 4660 #ifdef RUMP_KERNEL_IS_LIBC 4661 __weak_alias(fhopen,rump___sysimpl_fhopen40); 4662 __weak_alias(__fhopen40,rump___sysimpl_fhopen40); 4663 __weak_alias(___fhopen40,rump___sysimpl_fhopen40); 4664 __strong_alias(_sys___fhopen40,rump___sysimpl_fhopen40); 4665 #endif /* RUMP_KERNEL_IS_LIBC */ 4666 4667 int rump___sysimpl_fhstatvfs140(const void *, size_t, struct statvfs *, int); 4668 int 4669 rump___sysimpl_fhstatvfs140(const void * fhp, size_t fh_size, struct statvfs * buf, int flags) 4670 { 4671 register_t retval[2]; 4672 int error = 0; 4673 int rv = -1; 4674 struct sys___fhstatvfs140_args callarg; 4675 4676 memset(&callarg, 0, sizeof(callarg)); 4677 SPARG(&callarg, fhp) = fhp; 4678 SPARG(&callarg, fh_size) = fh_size; 4679 SPARG(&callarg, buf) = buf; 4680 SPARG(&callarg, flags) = flags; 4681 4682 error = rsys_syscall(SYS___fhstatvfs140, &callarg, sizeof(callarg), retval); 4683 rsys_seterrno(error); 4684 if (error == 0) { 4685 if (sizeof(int) > sizeof(register_t)) 4686 rv = *(int *)retval; 4687 else 4688 rv = *retval; 4689 } 4690 return rv; 4691 } 4692 #ifdef RUMP_KERNEL_IS_LIBC 4693 __weak_alias(fhstatvfs1,rump___sysimpl_fhstatvfs140); 4694 __weak_alias(__fhstatvfs140,rump___sysimpl_fhstatvfs140); 4695 __weak_alias(___fhstatvfs140,rump___sysimpl_fhstatvfs140); 4696 __strong_alias(_sys___fhstatvfs140,rump___sysimpl_fhstatvfs140); 4697 #endif /* RUMP_KERNEL_IS_LIBC */ 4698 4699 #ifdef RUMP_SYS_COMPAT 4700 int rump___sysimpl_fhstat40(const void *, size_t, struct stat *); 4701 int 4702 rump___sysimpl_fhstat40(const void * fhp, size_t fh_size, struct stat * sb) 4703 { 4704 register_t retval[2]; 4705 int error = 0; 4706 int rv = -1; 4707 struct compat_50_sys___fhstat40_args callarg; 4708 4709 memset(&callarg, 0, sizeof(callarg)); 4710 SPARG(&callarg, fhp) = fhp; 4711 SPARG(&callarg, fh_size) = fh_size; 4712 SPARG(&callarg, sb) = (struct stat30 *)sb; 4713 4714 error = rsys_syscall(SYS_compat_50___fhstat40, &callarg, sizeof(callarg), retval); 4715 rsys_seterrno(error); 4716 if (error == 0) { 4717 if (sizeof(int) > sizeof(register_t)) 4718 rv = *(int *)retval; 4719 else 4720 rv = *retval; 4721 } 4722 return rv; 4723 } 4724 #ifdef RUMP_KERNEL_IS_LIBC 4725 __weak_alias(fhstat,rump___sysimpl_fhstat40); 4726 __weak_alias(__fhstat40,rump___sysimpl_fhstat40); 4727 __weak_alias(___fhstat40,rump___sysimpl_fhstat40); 4728 __strong_alias(_sys___fhstat40,rump___sysimpl_fhstat40); 4729 #endif /* RUMP_KERNEL_IS_LIBC */ 4730 #endif /* RUMP_SYS_COMPAT */ 4731 4732 int rump___sysimpl_aio_cancel(int, struct aiocb *); 4733 int 4734 rump___sysimpl_aio_cancel(int fildes, struct aiocb * aiocbp) 4735 { 4736 register_t retval[2]; 4737 int error = 0; 4738 int rv = -1; 4739 struct sys_aio_cancel_args callarg; 4740 4741 memset(&callarg, 0, sizeof(callarg)); 4742 SPARG(&callarg, fildes) = fildes; 4743 SPARG(&callarg, aiocbp) = aiocbp; 4744 4745 error = rsys_syscall(SYS_aio_cancel, &callarg, sizeof(callarg), retval); 4746 rsys_seterrno(error); 4747 if (error == 0) { 4748 if (sizeof(int) > sizeof(register_t)) 4749 rv = *(int *)retval; 4750 else 4751 rv = *retval; 4752 } 4753 return rv; 4754 } 4755 #ifdef RUMP_KERNEL_IS_LIBC 4756 __weak_alias(aio_cancel,rump___sysimpl_aio_cancel); 4757 __weak_alias(_aio_cancel,rump___sysimpl_aio_cancel); 4758 __strong_alias(_sys_aio_cancel,rump___sysimpl_aio_cancel); 4759 #endif /* RUMP_KERNEL_IS_LIBC */ 4760 4761 int rump___sysimpl_aio_error(const struct aiocb *); 4762 int 4763 rump___sysimpl_aio_error(const struct aiocb * aiocbp) 4764 { 4765 register_t retval[2]; 4766 int error = 0; 4767 int rv = -1; 4768 struct sys_aio_error_args callarg; 4769 4770 memset(&callarg, 0, sizeof(callarg)); 4771 SPARG(&callarg, aiocbp) = aiocbp; 4772 4773 error = rsys_syscall(SYS_aio_error, &callarg, sizeof(callarg), retval); 4774 rsys_seterrno(error); 4775 if (error == 0) { 4776 if (sizeof(int) > sizeof(register_t)) 4777 rv = *(int *)retval; 4778 else 4779 rv = *retval; 4780 } 4781 return rv; 4782 } 4783 #ifdef RUMP_KERNEL_IS_LIBC 4784 __weak_alias(aio_error,rump___sysimpl_aio_error); 4785 __weak_alias(_aio_error,rump___sysimpl_aio_error); 4786 __strong_alias(_sys_aio_error,rump___sysimpl_aio_error); 4787 #endif /* RUMP_KERNEL_IS_LIBC */ 4788 4789 int rump___sysimpl_aio_fsync(int, struct aiocb *); 4790 int 4791 rump___sysimpl_aio_fsync(int op, struct aiocb * aiocbp) 4792 { 4793 register_t retval[2]; 4794 int error = 0; 4795 int rv = -1; 4796 struct sys_aio_fsync_args callarg; 4797 4798 memset(&callarg, 0, sizeof(callarg)); 4799 SPARG(&callarg, op) = op; 4800 SPARG(&callarg, aiocbp) = aiocbp; 4801 4802 error = rsys_syscall(SYS_aio_fsync, &callarg, sizeof(callarg), retval); 4803 rsys_seterrno(error); 4804 if (error == 0) { 4805 if (sizeof(int) > sizeof(register_t)) 4806 rv = *(int *)retval; 4807 else 4808 rv = *retval; 4809 } 4810 return rv; 4811 } 4812 #ifdef RUMP_KERNEL_IS_LIBC 4813 __weak_alias(aio_fsync,rump___sysimpl_aio_fsync); 4814 __weak_alias(_aio_fsync,rump___sysimpl_aio_fsync); 4815 __strong_alias(_sys_aio_fsync,rump___sysimpl_aio_fsync); 4816 #endif /* RUMP_KERNEL_IS_LIBC */ 4817 4818 int rump___sysimpl_aio_read(struct aiocb *); 4819 int 4820 rump___sysimpl_aio_read(struct aiocb * aiocbp) 4821 { 4822 register_t retval[2]; 4823 int error = 0; 4824 int rv = -1; 4825 struct sys_aio_read_args callarg; 4826 4827 memset(&callarg, 0, sizeof(callarg)); 4828 SPARG(&callarg, aiocbp) = aiocbp; 4829 4830 error = rsys_syscall(SYS_aio_read, &callarg, sizeof(callarg), retval); 4831 rsys_seterrno(error); 4832 if (error == 0) { 4833 if (sizeof(int) > sizeof(register_t)) 4834 rv = *(int *)retval; 4835 else 4836 rv = *retval; 4837 } 4838 return rv; 4839 } 4840 #ifdef RUMP_KERNEL_IS_LIBC 4841 __weak_alias(aio_read,rump___sysimpl_aio_read); 4842 __weak_alias(_aio_read,rump___sysimpl_aio_read); 4843 __strong_alias(_sys_aio_read,rump___sysimpl_aio_read); 4844 #endif /* RUMP_KERNEL_IS_LIBC */ 4845 4846 int rump___sysimpl_aio_return(struct aiocb *); 4847 int 4848 rump___sysimpl_aio_return(struct aiocb * aiocbp) 4849 { 4850 register_t retval[2]; 4851 int error = 0; 4852 int rv = -1; 4853 struct sys_aio_return_args callarg; 4854 4855 memset(&callarg, 0, sizeof(callarg)); 4856 SPARG(&callarg, aiocbp) = aiocbp; 4857 4858 error = rsys_syscall(SYS_aio_return, &callarg, sizeof(callarg), retval); 4859 rsys_seterrno(error); 4860 if (error == 0) { 4861 if (sizeof(int) > sizeof(register_t)) 4862 rv = *(int *)retval; 4863 else 4864 rv = *retval; 4865 } 4866 return rv; 4867 } 4868 #ifdef RUMP_KERNEL_IS_LIBC 4869 __weak_alias(aio_return,rump___sysimpl_aio_return); 4870 __weak_alias(_aio_return,rump___sysimpl_aio_return); 4871 __strong_alias(_sys_aio_return,rump___sysimpl_aio_return); 4872 #endif /* RUMP_KERNEL_IS_LIBC */ 4873 4874 int rump___sysimpl_aio_write(struct aiocb *); 4875 int 4876 rump___sysimpl_aio_write(struct aiocb * aiocbp) 4877 { 4878 register_t retval[2]; 4879 int error = 0; 4880 int rv = -1; 4881 struct sys_aio_write_args callarg; 4882 4883 memset(&callarg, 0, sizeof(callarg)); 4884 SPARG(&callarg, aiocbp) = aiocbp; 4885 4886 error = rsys_syscall(SYS_aio_write, &callarg, sizeof(callarg), retval); 4887 rsys_seterrno(error); 4888 if (error == 0) { 4889 if (sizeof(int) > sizeof(register_t)) 4890 rv = *(int *)retval; 4891 else 4892 rv = *retval; 4893 } 4894 return rv; 4895 } 4896 #ifdef RUMP_KERNEL_IS_LIBC 4897 __weak_alias(aio_write,rump___sysimpl_aio_write); 4898 __weak_alias(_aio_write,rump___sysimpl_aio_write); 4899 __strong_alias(_sys_aio_write,rump___sysimpl_aio_write); 4900 #endif /* RUMP_KERNEL_IS_LIBC */ 4901 4902 int rump___sysimpl_lio_listio(int, struct aiocb *const *, int, struct sigevent *); 4903 int 4904 rump___sysimpl_lio_listio(int mode, struct aiocb *const * list, int nent, struct sigevent * sig) 4905 { 4906 register_t retval[2]; 4907 int error = 0; 4908 int rv = -1; 4909 struct sys_lio_listio_args callarg; 4910 4911 memset(&callarg, 0, sizeof(callarg)); 4912 SPARG(&callarg, mode) = mode; 4913 SPARG(&callarg, list) = list; 4914 SPARG(&callarg, nent) = nent; 4915 SPARG(&callarg, sig) = sig; 4916 4917 error = rsys_syscall(SYS_lio_listio, &callarg, sizeof(callarg), retval); 4918 rsys_seterrno(error); 4919 if (error == 0) { 4920 if (sizeof(int) > sizeof(register_t)) 4921 rv = *(int *)retval; 4922 else 4923 rv = *retval; 4924 } 4925 return rv; 4926 } 4927 #ifdef RUMP_KERNEL_IS_LIBC 4928 __weak_alias(lio_listio,rump___sysimpl_lio_listio); 4929 __weak_alias(_lio_listio,rump___sysimpl_lio_listio); 4930 __strong_alias(_sys_lio_listio,rump___sysimpl_lio_listio); 4931 #endif /* RUMP_KERNEL_IS_LIBC */ 4932 4933 int rump___sysimpl_mount50(const char *, const char *, int, void *, size_t); 4934 int 4935 rump___sysimpl_mount50(const char * type, const char * path, int flags, void * data, size_t data_len) 4936 { 4937 register_t retval[2]; 4938 int error = 0; 4939 int rv = -1; 4940 struct sys___mount50_args callarg; 4941 4942 memset(&callarg, 0, sizeof(callarg)); 4943 SPARG(&callarg, type) = type; 4944 SPARG(&callarg, path) = path; 4945 SPARG(&callarg, flags) = flags; 4946 SPARG(&callarg, data) = data; 4947 SPARG(&callarg, data_len) = data_len; 4948 4949 error = rsys_syscall(SYS___mount50, &callarg, sizeof(callarg), retval); 4950 rsys_seterrno(error); 4951 if (error == 0) { 4952 if (sizeof(int) > sizeof(register_t)) 4953 rv = *(int *)retval; 4954 else 4955 rv = *retval; 4956 } 4957 return rv; 4958 } 4959 #ifdef RUMP_KERNEL_IS_LIBC 4960 __weak_alias(mount,rump___sysimpl_mount50); 4961 __weak_alias(__mount50,rump___sysimpl_mount50); 4962 __weak_alias(___mount50,rump___sysimpl_mount50); 4963 __strong_alias(_sys___mount50,rump___sysimpl_mount50); 4964 #endif /* RUMP_KERNEL_IS_LIBC */ 4965 4966 int rump___sysimpl_posix_fadvise50(int, off_t, off_t, int); 4967 int 4968 rump___sysimpl_posix_fadvise50(int fd, off_t offset, off_t len, int advice) 4969 { 4970 register_t retval[2]; 4971 int rv = -1; 4972 struct sys___posix_fadvise50_args callarg; 4973 4974 memset(&callarg, 0, sizeof(callarg)); 4975 SPARG(&callarg, fd) = fd; 4976 SPARG(&callarg, PAD) = 0; 4977 SPARG(&callarg, offset) = offset; 4978 SPARG(&callarg, len) = len; 4979 SPARG(&callarg, advice) = advice; 4980 4981 (void)rsys_syscall(SYS___posix_fadvise50, &callarg, sizeof(callarg), retval); 4982 if (sizeof(int) > sizeof(register_t)) 4983 rv = *(int *)retval; 4984 else 4985 rv = *retval; 4986 return rv; 4987 } 4988 #ifdef RUMP_KERNEL_IS_LIBC 4989 __weak_alias(posix_fadvise,rump___sysimpl_posix_fadvise50); 4990 __weak_alias(__posix_fadvise50,rump___sysimpl_posix_fadvise50); 4991 __weak_alias(___posix_fadvise50,rump___sysimpl_posix_fadvise50); 4992 __strong_alias(_sys___posix_fadvise50,rump___sysimpl_posix_fadvise50); 4993 #endif /* RUMP_KERNEL_IS_LIBC */ 4994 4995 int rump___sysimpl_select50(int, fd_set *, fd_set *, fd_set *, struct timeval *); 4996 int 4997 rump___sysimpl_select50(int nd, fd_set * in, fd_set * ou, fd_set * ex, struct timeval * tv) 4998 { 4999 register_t retval[2]; 5000 int error = 0; 5001 int rv = -1; 5002 struct sys___select50_args callarg; 5003 5004 memset(&callarg, 0, sizeof(callarg)); 5005 SPARG(&callarg, nd) = nd; 5006 SPARG(&callarg, in) = in; 5007 SPARG(&callarg, ou) = ou; 5008 SPARG(&callarg, ex) = ex; 5009 SPARG(&callarg, tv) = tv; 5010 5011 error = rsys_syscall(SYS___select50, &callarg, sizeof(callarg), retval); 5012 rsys_seterrno(error); 5013 if (error == 0) { 5014 if (sizeof(int) > sizeof(register_t)) 5015 rv = *(int *)retval; 5016 else 5017 rv = *retval; 5018 } 5019 return rv; 5020 } 5021 #ifdef RUMP_KERNEL_IS_LIBC 5022 __weak_alias(select,rump___sysimpl_select50); 5023 __weak_alias(__select50,rump___sysimpl_select50); 5024 __weak_alias(___select50,rump___sysimpl_select50); 5025 __strong_alias(_sys___select50,rump___sysimpl_select50); 5026 #endif /* RUMP_KERNEL_IS_LIBC */ 5027 5028 int rump___sysimpl_gettimeofday50(struct timeval *, void *); 5029 int 5030 rump___sysimpl_gettimeofday50(struct timeval * tp, void * tzp) 5031 { 5032 register_t retval[2]; 5033 int error = 0; 5034 int rv = -1; 5035 struct sys___gettimeofday50_args callarg; 5036 5037 memset(&callarg, 0, sizeof(callarg)); 5038 SPARG(&callarg, tp) = tp; 5039 SPARG(&callarg, tzp) = tzp; 5040 5041 error = rsys_syscall(SYS___gettimeofday50, &callarg, sizeof(callarg), retval); 5042 rsys_seterrno(error); 5043 if (error == 0) { 5044 if (sizeof(int) > sizeof(register_t)) 5045 rv = *(int *)retval; 5046 else 5047 rv = *retval; 5048 } 5049 return rv; 5050 } 5051 #ifdef RUMP_KERNEL_IS_LIBC 5052 __weak_alias(gettimeofday,rump___sysimpl_gettimeofday50); 5053 __weak_alias(__gettimeofday50,rump___sysimpl_gettimeofday50); 5054 __weak_alias(___gettimeofday50,rump___sysimpl_gettimeofday50); 5055 __strong_alias(_sys___gettimeofday50,rump___sysimpl_gettimeofday50); 5056 #endif /* RUMP_KERNEL_IS_LIBC */ 5057 5058 int rump___sysimpl_settimeofday50(const struct timeval *, const void *); 5059 int 5060 rump___sysimpl_settimeofday50(const struct timeval * tv, const void * tzp) 5061 { 5062 register_t retval[2]; 5063 int error = 0; 5064 int rv = -1; 5065 struct sys___settimeofday50_args callarg; 5066 5067 memset(&callarg, 0, sizeof(callarg)); 5068 SPARG(&callarg, tv) = tv; 5069 SPARG(&callarg, tzp) = tzp; 5070 5071 error = rsys_syscall(SYS___settimeofday50, &callarg, sizeof(callarg), retval); 5072 rsys_seterrno(error); 5073 if (error == 0) { 5074 if (sizeof(int) > sizeof(register_t)) 5075 rv = *(int *)retval; 5076 else 5077 rv = *retval; 5078 } 5079 return rv; 5080 } 5081 #ifdef RUMP_KERNEL_IS_LIBC 5082 __weak_alias(settimeofday,rump___sysimpl_settimeofday50); 5083 __weak_alias(__settimeofday50,rump___sysimpl_settimeofday50); 5084 __weak_alias(___settimeofday50,rump___sysimpl_settimeofday50); 5085 __strong_alias(_sys___settimeofday50,rump___sysimpl_settimeofday50); 5086 #endif /* RUMP_KERNEL_IS_LIBC */ 5087 5088 int rump___sysimpl_utimes50(const char *, const struct timeval *); 5089 int 5090 rump___sysimpl_utimes50(const char * path, const struct timeval * tptr) 5091 { 5092 register_t retval[2]; 5093 int error = 0; 5094 int rv = -1; 5095 struct sys___utimes50_args callarg; 5096 5097 memset(&callarg, 0, sizeof(callarg)); 5098 SPARG(&callarg, path) = path; 5099 SPARG(&callarg, tptr) = tptr; 5100 5101 error = rsys_syscall(SYS___utimes50, &callarg, sizeof(callarg), retval); 5102 rsys_seterrno(error); 5103 if (error == 0) { 5104 if (sizeof(int) > sizeof(register_t)) 5105 rv = *(int *)retval; 5106 else 5107 rv = *retval; 5108 } 5109 return rv; 5110 } 5111 #ifdef RUMP_KERNEL_IS_LIBC 5112 __weak_alias(utimes,rump___sysimpl_utimes50); 5113 __weak_alias(__utimes50,rump___sysimpl_utimes50); 5114 __weak_alias(___utimes50,rump___sysimpl_utimes50); 5115 __strong_alias(_sys___utimes50,rump___sysimpl_utimes50); 5116 #endif /* RUMP_KERNEL_IS_LIBC */ 5117 5118 int rump___sysimpl_adjtime50(const struct timeval *, struct timeval *); 5119 int 5120 rump___sysimpl_adjtime50(const struct timeval * delta, struct timeval * olddelta) 5121 { 5122 register_t retval[2]; 5123 int error = 0; 5124 int rv = -1; 5125 struct sys___adjtime50_args callarg; 5126 5127 memset(&callarg, 0, sizeof(callarg)); 5128 SPARG(&callarg, delta) = delta; 5129 SPARG(&callarg, olddelta) = olddelta; 5130 5131 error = rsys_syscall(SYS___adjtime50, &callarg, sizeof(callarg), retval); 5132 rsys_seterrno(error); 5133 if (error == 0) { 5134 if (sizeof(int) > sizeof(register_t)) 5135 rv = *(int *)retval; 5136 else 5137 rv = *retval; 5138 } 5139 return rv; 5140 } 5141 #ifdef RUMP_KERNEL_IS_LIBC 5142 __weak_alias(adjtime,rump___sysimpl_adjtime50); 5143 __weak_alias(__adjtime50,rump___sysimpl_adjtime50); 5144 __weak_alias(___adjtime50,rump___sysimpl_adjtime50); 5145 __strong_alias(_sys___adjtime50,rump___sysimpl_adjtime50); 5146 #endif /* RUMP_KERNEL_IS_LIBC */ 5147 5148 int rump___sysimpl_futimes50(int, const struct timeval *); 5149 int 5150 rump___sysimpl_futimes50(int fd, const struct timeval * tptr) 5151 { 5152 register_t retval[2]; 5153 int error = 0; 5154 int rv = -1; 5155 struct sys___futimes50_args callarg; 5156 5157 memset(&callarg, 0, sizeof(callarg)); 5158 SPARG(&callarg, fd) = fd; 5159 SPARG(&callarg, tptr) = tptr; 5160 5161 error = rsys_syscall(SYS___futimes50, &callarg, sizeof(callarg), retval); 5162 rsys_seterrno(error); 5163 if (error == 0) { 5164 if (sizeof(int) > sizeof(register_t)) 5165 rv = *(int *)retval; 5166 else 5167 rv = *retval; 5168 } 5169 return rv; 5170 } 5171 #ifdef RUMP_KERNEL_IS_LIBC 5172 __weak_alias(futimes,rump___sysimpl_futimes50); 5173 __weak_alias(__futimes50,rump___sysimpl_futimes50); 5174 __weak_alias(___futimes50,rump___sysimpl_futimes50); 5175 __strong_alias(_sys___futimes50,rump___sysimpl_futimes50); 5176 #endif /* RUMP_KERNEL_IS_LIBC */ 5177 5178 int rump___sysimpl_lutimes50(const char *, const struct timeval *); 5179 int 5180 rump___sysimpl_lutimes50(const char * path, const struct timeval * tptr) 5181 { 5182 register_t retval[2]; 5183 int error = 0; 5184 int rv = -1; 5185 struct sys___lutimes50_args callarg; 5186 5187 memset(&callarg, 0, sizeof(callarg)); 5188 SPARG(&callarg, path) = path; 5189 SPARG(&callarg, tptr) = tptr; 5190 5191 error = rsys_syscall(SYS___lutimes50, &callarg, sizeof(callarg), retval); 5192 rsys_seterrno(error); 5193 if (error == 0) { 5194 if (sizeof(int) > sizeof(register_t)) 5195 rv = *(int *)retval; 5196 else 5197 rv = *retval; 5198 } 5199 return rv; 5200 } 5201 #ifdef RUMP_KERNEL_IS_LIBC 5202 __weak_alias(lutimes,rump___sysimpl_lutimes50); 5203 __weak_alias(__lutimes50,rump___sysimpl_lutimes50); 5204 __weak_alias(___lutimes50,rump___sysimpl_lutimes50); 5205 __strong_alias(_sys___lutimes50,rump___sysimpl_lutimes50); 5206 #endif /* RUMP_KERNEL_IS_LIBC */ 5207 5208 int rump___sysimpl_setitimer50(int, const struct itimerval *, struct itimerval *); 5209 int 5210 rump___sysimpl_setitimer50(int which, const struct itimerval * itv, struct itimerval * oitv) 5211 { 5212 register_t retval[2]; 5213 int error = 0; 5214 int rv = -1; 5215 struct sys___setitimer50_args callarg; 5216 5217 memset(&callarg, 0, sizeof(callarg)); 5218 SPARG(&callarg, which) = which; 5219 SPARG(&callarg, itv) = itv; 5220 SPARG(&callarg, oitv) = oitv; 5221 5222 error = rsys_syscall(SYS___setitimer50, &callarg, sizeof(callarg), retval); 5223 rsys_seterrno(error); 5224 if (error == 0) { 5225 if (sizeof(int) > sizeof(register_t)) 5226 rv = *(int *)retval; 5227 else 5228 rv = *retval; 5229 } 5230 return rv; 5231 } 5232 #ifdef RUMP_KERNEL_IS_LIBC 5233 __weak_alias(setitimer,rump___sysimpl_setitimer50); 5234 __weak_alias(__setitimer50,rump___sysimpl_setitimer50); 5235 __weak_alias(___setitimer50,rump___sysimpl_setitimer50); 5236 __strong_alias(_sys___setitimer50,rump___sysimpl_setitimer50); 5237 #endif /* RUMP_KERNEL_IS_LIBC */ 5238 5239 int rump___sysimpl_getitimer50(int, struct itimerval *); 5240 int 5241 rump___sysimpl_getitimer50(int which, struct itimerval * itv) 5242 { 5243 register_t retval[2]; 5244 int error = 0; 5245 int rv = -1; 5246 struct sys___getitimer50_args callarg; 5247 5248 memset(&callarg, 0, sizeof(callarg)); 5249 SPARG(&callarg, which) = which; 5250 SPARG(&callarg, itv) = itv; 5251 5252 error = rsys_syscall(SYS___getitimer50, &callarg, sizeof(callarg), retval); 5253 rsys_seterrno(error); 5254 if (error == 0) { 5255 if (sizeof(int) > sizeof(register_t)) 5256 rv = *(int *)retval; 5257 else 5258 rv = *retval; 5259 } 5260 return rv; 5261 } 5262 #ifdef RUMP_KERNEL_IS_LIBC 5263 __weak_alias(getitimer,rump___sysimpl_getitimer50); 5264 __weak_alias(__getitimer50,rump___sysimpl_getitimer50); 5265 __weak_alias(___getitimer50,rump___sysimpl_getitimer50); 5266 __strong_alias(_sys___getitimer50,rump___sysimpl_getitimer50); 5267 #endif /* RUMP_KERNEL_IS_LIBC */ 5268 5269 int rump___sysimpl_clock_gettime50(clockid_t, struct timespec *); 5270 int 5271 rump___sysimpl_clock_gettime50(clockid_t clock_id, struct timespec * tp) 5272 { 5273 register_t retval[2]; 5274 int error = 0; 5275 int rv = -1; 5276 struct sys___clock_gettime50_args callarg; 5277 5278 memset(&callarg, 0, sizeof(callarg)); 5279 SPARG(&callarg, clock_id) = clock_id; 5280 SPARG(&callarg, tp) = tp; 5281 5282 error = rsys_syscall(SYS___clock_gettime50, &callarg, sizeof(callarg), retval); 5283 rsys_seterrno(error); 5284 if (error == 0) { 5285 if (sizeof(int) > sizeof(register_t)) 5286 rv = *(int *)retval; 5287 else 5288 rv = *retval; 5289 } 5290 return rv; 5291 } 5292 #ifdef RUMP_KERNEL_IS_LIBC 5293 __weak_alias(clock_gettime,rump___sysimpl_clock_gettime50); 5294 __weak_alias(__clock_gettime50,rump___sysimpl_clock_gettime50); 5295 __weak_alias(___clock_gettime50,rump___sysimpl_clock_gettime50); 5296 __strong_alias(_sys___clock_gettime50,rump___sysimpl_clock_gettime50); 5297 #endif /* RUMP_KERNEL_IS_LIBC */ 5298 5299 int rump___sysimpl_clock_settime50(clockid_t, const struct timespec *); 5300 int 5301 rump___sysimpl_clock_settime50(clockid_t clock_id, const struct timespec * tp) 5302 { 5303 register_t retval[2]; 5304 int error = 0; 5305 int rv = -1; 5306 struct sys___clock_settime50_args callarg; 5307 5308 memset(&callarg, 0, sizeof(callarg)); 5309 SPARG(&callarg, clock_id) = clock_id; 5310 SPARG(&callarg, tp) = tp; 5311 5312 error = rsys_syscall(SYS___clock_settime50, &callarg, sizeof(callarg), retval); 5313 rsys_seterrno(error); 5314 if (error == 0) { 5315 if (sizeof(int) > sizeof(register_t)) 5316 rv = *(int *)retval; 5317 else 5318 rv = *retval; 5319 } 5320 return rv; 5321 } 5322 #ifdef RUMP_KERNEL_IS_LIBC 5323 __weak_alias(clock_settime,rump___sysimpl_clock_settime50); 5324 __weak_alias(__clock_settime50,rump___sysimpl_clock_settime50); 5325 __weak_alias(___clock_settime50,rump___sysimpl_clock_settime50); 5326 __strong_alias(_sys___clock_settime50,rump___sysimpl_clock_settime50); 5327 #endif /* RUMP_KERNEL_IS_LIBC */ 5328 5329 int rump___sysimpl_clock_getres50(clockid_t, struct timespec *); 5330 int 5331 rump___sysimpl_clock_getres50(clockid_t clock_id, struct timespec * tp) 5332 { 5333 register_t retval[2]; 5334 int error = 0; 5335 int rv = -1; 5336 struct sys___clock_getres50_args callarg; 5337 5338 memset(&callarg, 0, sizeof(callarg)); 5339 SPARG(&callarg, clock_id) = clock_id; 5340 SPARG(&callarg, tp) = tp; 5341 5342 error = rsys_syscall(SYS___clock_getres50, &callarg, sizeof(callarg), retval); 5343 rsys_seterrno(error); 5344 if (error == 0) { 5345 if (sizeof(int) > sizeof(register_t)) 5346 rv = *(int *)retval; 5347 else 5348 rv = *retval; 5349 } 5350 return rv; 5351 } 5352 #ifdef RUMP_KERNEL_IS_LIBC 5353 __weak_alias(clock_getres,rump___sysimpl_clock_getres50); 5354 __weak_alias(__clock_getres50,rump___sysimpl_clock_getres50); 5355 __weak_alias(___clock_getres50,rump___sysimpl_clock_getres50); 5356 __strong_alias(_sys___clock_getres50,rump___sysimpl_clock_getres50); 5357 #endif /* RUMP_KERNEL_IS_LIBC */ 5358 5359 int rump___sysimpl_nanosleep50(const struct timespec *, struct timespec *); 5360 int 5361 rump___sysimpl_nanosleep50(const struct timespec * rqtp, struct timespec * rmtp) 5362 { 5363 register_t retval[2]; 5364 int error = 0; 5365 int rv = -1; 5366 struct sys___nanosleep50_args callarg; 5367 5368 memset(&callarg, 0, sizeof(callarg)); 5369 SPARG(&callarg, rqtp) = rqtp; 5370 SPARG(&callarg, rmtp) = rmtp; 5371 5372 error = rsys_syscall(SYS___nanosleep50, &callarg, sizeof(callarg), retval); 5373 rsys_seterrno(error); 5374 if (error == 0) { 5375 if (sizeof(int) > sizeof(register_t)) 5376 rv = *(int *)retval; 5377 else 5378 rv = *retval; 5379 } 5380 return rv; 5381 } 5382 #ifdef RUMP_KERNEL_IS_LIBC 5383 __weak_alias(nanosleep,rump___sysimpl_nanosleep50); 5384 __weak_alias(__nanosleep50,rump___sysimpl_nanosleep50); 5385 __weak_alias(___nanosleep50,rump___sysimpl_nanosleep50); 5386 __strong_alias(_sys___nanosleep50,rump___sysimpl_nanosleep50); 5387 #endif /* RUMP_KERNEL_IS_LIBC */ 5388 5389 int rump___sysimpl_kevent50(int, const struct kevent *, size_t, struct kevent *, size_t, const struct timespec *); 5390 int 5391 rump___sysimpl_kevent50(int fd, const struct kevent * changelist, size_t nchanges, struct kevent * eventlist, size_t nevents, const struct timespec * timeout) 5392 { 5393 register_t retval[2]; 5394 int error = 0; 5395 int rv = -1; 5396 struct sys___kevent50_args callarg; 5397 5398 memset(&callarg, 0, sizeof(callarg)); 5399 SPARG(&callarg, fd) = fd; 5400 SPARG(&callarg, changelist) = changelist; 5401 SPARG(&callarg, nchanges) = nchanges; 5402 SPARG(&callarg, eventlist) = eventlist; 5403 SPARG(&callarg, nevents) = nevents; 5404 SPARG(&callarg, timeout) = timeout; 5405 5406 error = rsys_syscall(SYS___kevent50, &callarg, sizeof(callarg), retval); 5407 rsys_seterrno(error); 5408 if (error == 0) { 5409 if (sizeof(int) > sizeof(register_t)) 5410 rv = *(int *)retval; 5411 else 5412 rv = *retval; 5413 } 5414 return rv; 5415 } 5416 #ifdef RUMP_KERNEL_IS_LIBC 5417 __weak_alias(kevent,rump___sysimpl_kevent50); 5418 __weak_alias(__kevent50,rump___sysimpl_kevent50); 5419 __weak_alias(___kevent50,rump___sysimpl_kevent50); 5420 __strong_alias(_sys___kevent50,rump___sysimpl_kevent50); 5421 #endif /* RUMP_KERNEL_IS_LIBC */ 5422 5423 int rump___sysimpl_pselect50(int, fd_set *, fd_set *, fd_set *, const struct timespec *, const sigset_t *); 5424 int 5425 rump___sysimpl_pselect50(int nd, fd_set * in, fd_set * ou, fd_set * ex, const struct timespec * ts, const sigset_t * mask) 5426 { 5427 register_t retval[2]; 5428 int error = 0; 5429 int rv = -1; 5430 struct sys___pselect50_args callarg; 5431 5432 memset(&callarg, 0, sizeof(callarg)); 5433 SPARG(&callarg, nd) = nd; 5434 SPARG(&callarg, in) = in; 5435 SPARG(&callarg, ou) = ou; 5436 SPARG(&callarg, ex) = ex; 5437 SPARG(&callarg, ts) = ts; 5438 SPARG(&callarg, mask) = mask; 5439 5440 error = rsys_syscall(SYS___pselect50, &callarg, sizeof(callarg), retval); 5441 rsys_seterrno(error); 5442 if (error == 0) { 5443 if (sizeof(int) > sizeof(register_t)) 5444 rv = *(int *)retval; 5445 else 5446 rv = *retval; 5447 } 5448 return rv; 5449 } 5450 #ifdef RUMP_KERNEL_IS_LIBC 5451 __weak_alias(pselect,rump___sysimpl_pselect50); 5452 __weak_alias(__pselect50,rump___sysimpl_pselect50); 5453 __weak_alias(___pselect50,rump___sysimpl_pselect50); 5454 __strong_alias(_sys___pselect50,rump___sysimpl_pselect50); 5455 #endif /* RUMP_KERNEL_IS_LIBC */ 5456 5457 int rump___sysimpl_pollts50(struct pollfd *, u_int, const struct timespec *, const sigset_t *); 5458 int 5459 rump___sysimpl_pollts50(struct pollfd * fds, u_int nfds, const struct timespec * ts, const sigset_t * mask) 5460 { 5461 register_t retval[2]; 5462 int error = 0; 5463 int rv = -1; 5464 struct sys___pollts50_args callarg; 5465 5466 memset(&callarg, 0, sizeof(callarg)); 5467 SPARG(&callarg, fds) = fds; 5468 SPARG(&callarg, nfds) = nfds; 5469 SPARG(&callarg, ts) = ts; 5470 SPARG(&callarg, mask) = mask; 5471 5472 error = rsys_syscall(SYS___pollts50, &callarg, sizeof(callarg), retval); 5473 rsys_seterrno(error); 5474 if (error == 0) { 5475 if (sizeof(int) > sizeof(register_t)) 5476 rv = *(int *)retval; 5477 else 5478 rv = *retval; 5479 } 5480 return rv; 5481 } 5482 #ifdef RUMP_KERNEL_IS_LIBC 5483 __weak_alias(pollts,rump___sysimpl_pollts50); 5484 __weak_alias(__pollts50,rump___sysimpl_pollts50); 5485 __weak_alias(___pollts50,rump___sysimpl_pollts50); 5486 __strong_alias(_sys___pollts50,rump___sysimpl_pollts50); 5487 #endif /* RUMP_KERNEL_IS_LIBC */ 5488 5489 int rump___sysimpl_aio_suspend50(const struct aiocb *const *, int, const struct timespec *); 5490 int 5491 rump___sysimpl_aio_suspend50(const struct aiocb *const * list, int nent, const struct timespec * timeout) 5492 { 5493 register_t retval[2]; 5494 int error = 0; 5495 int rv = -1; 5496 struct sys___aio_suspend50_args callarg; 5497 5498 memset(&callarg, 0, sizeof(callarg)); 5499 SPARG(&callarg, list) = list; 5500 SPARG(&callarg, nent) = nent; 5501 SPARG(&callarg, timeout) = timeout; 5502 5503 error = rsys_syscall(SYS___aio_suspend50, &callarg, sizeof(callarg), retval); 5504 rsys_seterrno(error); 5505 if (error == 0) { 5506 if (sizeof(int) > sizeof(register_t)) 5507 rv = *(int *)retval; 5508 else 5509 rv = *retval; 5510 } 5511 return rv; 5512 } 5513 #ifdef RUMP_KERNEL_IS_LIBC 5514 __weak_alias(aio_suspend,rump___sysimpl_aio_suspend50); 5515 __weak_alias(__aio_suspend50,rump___sysimpl_aio_suspend50); 5516 __weak_alias(___aio_suspend50,rump___sysimpl_aio_suspend50); 5517 __strong_alias(_sys___aio_suspend50,rump___sysimpl_aio_suspend50); 5518 #endif /* RUMP_KERNEL_IS_LIBC */ 5519 5520 int rump___sysimpl_stat50(const char *, struct stat *); 5521 int 5522 rump___sysimpl_stat50(const char * path, struct stat * ub) 5523 { 5524 register_t retval[2]; 5525 int error = 0; 5526 int rv = -1; 5527 struct sys___stat50_args callarg; 5528 5529 memset(&callarg, 0, sizeof(callarg)); 5530 SPARG(&callarg, path) = path; 5531 SPARG(&callarg, ub) = ub; 5532 5533 error = rsys_syscall(SYS___stat50, &callarg, sizeof(callarg), retval); 5534 rsys_seterrno(error); 5535 if (error == 0) { 5536 if (sizeof(int) > sizeof(register_t)) 5537 rv = *(int *)retval; 5538 else 5539 rv = *retval; 5540 } 5541 return rv; 5542 } 5543 #ifdef RUMP_KERNEL_IS_LIBC 5544 __weak_alias(stat,rump___sysimpl_stat50); 5545 __weak_alias(__stat50,rump___sysimpl_stat50); 5546 __weak_alias(___stat50,rump___sysimpl_stat50); 5547 __strong_alias(_sys___stat50,rump___sysimpl_stat50); 5548 #endif /* RUMP_KERNEL_IS_LIBC */ 5549 5550 int rump___sysimpl_fstat50(int, struct stat *); 5551 int 5552 rump___sysimpl_fstat50(int fd, struct stat * sb) 5553 { 5554 register_t retval[2]; 5555 int error = 0; 5556 int rv = -1; 5557 struct sys___fstat50_args callarg; 5558 5559 memset(&callarg, 0, sizeof(callarg)); 5560 SPARG(&callarg, fd) = fd; 5561 SPARG(&callarg, sb) = sb; 5562 5563 error = rsys_syscall(SYS___fstat50, &callarg, sizeof(callarg), retval); 5564 rsys_seterrno(error); 5565 if (error == 0) { 5566 if (sizeof(int) > sizeof(register_t)) 5567 rv = *(int *)retval; 5568 else 5569 rv = *retval; 5570 } 5571 return rv; 5572 } 5573 #ifdef RUMP_KERNEL_IS_LIBC 5574 __weak_alias(fstat,rump___sysimpl_fstat50); 5575 __weak_alias(__fstat50,rump___sysimpl_fstat50); 5576 __weak_alias(___fstat50,rump___sysimpl_fstat50); 5577 __strong_alias(_sys___fstat50,rump___sysimpl_fstat50); 5578 #endif /* RUMP_KERNEL_IS_LIBC */ 5579 5580 int rump___sysimpl_lstat50(const char *, struct stat *); 5581 int 5582 rump___sysimpl_lstat50(const char * path, struct stat * ub) 5583 { 5584 register_t retval[2]; 5585 int error = 0; 5586 int rv = -1; 5587 struct sys___lstat50_args callarg; 5588 5589 memset(&callarg, 0, sizeof(callarg)); 5590 SPARG(&callarg, path) = path; 5591 SPARG(&callarg, ub) = ub; 5592 5593 error = rsys_syscall(SYS___lstat50, &callarg, sizeof(callarg), retval); 5594 rsys_seterrno(error); 5595 if (error == 0) { 5596 if (sizeof(int) > sizeof(register_t)) 5597 rv = *(int *)retval; 5598 else 5599 rv = *retval; 5600 } 5601 return rv; 5602 } 5603 #ifdef RUMP_KERNEL_IS_LIBC 5604 __weak_alias(lstat,rump___sysimpl_lstat50); 5605 __weak_alias(__lstat50,rump___sysimpl_lstat50); 5606 __weak_alias(___lstat50,rump___sysimpl_lstat50); 5607 __strong_alias(_sys___lstat50,rump___sysimpl_lstat50); 5608 #endif /* RUMP_KERNEL_IS_LIBC */ 5609 5610 int rump___sysimpl_timer_settime50(timer_t, int, const struct itimerspec *, struct itimerspec *); 5611 int 5612 rump___sysimpl_timer_settime50(timer_t timerid, int flags, const struct itimerspec * value, struct itimerspec * ovalue) 5613 { 5614 register_t retval[2]; 5615 int error = 0; 5616 int rv = -1; 5617 struct sys___timer_settime50_args callarg; 5618 5619 memset(&callarg, 0, sizeof(callarg)); 5620 SPARG(&callarg, timerid) = timerid; 5621 SPARG(&callarg, flags) = flags; 5622 SPARG(&callarg, value) = value; 5623 SPARG(&callarg, ovalue) = ovalue; 5624 5625 error = rsys_syscall(SYS___timer_settime50, &callarg, sizeof(callarg), retval); 5626 rsys_seterrno(error); 5627 if (error == 0) { 5628 if (sizeof(int) > sizeof(register_t)) 5629 rv = *(int *)retval; 5630 else 5631 rv = *retval; 5632 } 5633 return rv; 5634 } 5635 #ifdef RUMP_KERNEL_IS_LIBC 5636 __weak_alias(timer_settime,rump___sysimpl_timer_settime50); 5637 __weak_alias(__timer_settime50,rump___sysimpl_timer_settime50); 5638 __weak_alias(___timer_settime50,rump___sysimpl_timer_settime50); 5639 __strong_alias(_sys___timer_settime50,rump___sysimpl_timer_settime50); 5640 #endif /* RUMP_KERNEL_IS_LIBC */ 5641 5642 int rump___sysimpl_timer_gettime50(timer_t, struct itimerspec *); 5643 int 5644 rump___sysimpl_timer_gettime50(timer_t timerid, struct itimerspec * value) 5645 { 5646 register_t retval[2]; 5647 int error = 0; 5648 int rv = -1; 5649 struct sys___timer_gettime50_args callarg; 5650 5651 memset(&callarg, 0, sizeof(callarg)); 5652 SPARG(&callarg, timerid) = timerid; 5653 SPARG(&callarg, value) = value; 5654 5655 error = rsys_syscall(SYS___timer_gettime50, &callarg, sizeof(callarg), retval); 5656 rsys_seterrno(error); 5657 if (error == 0) { 5658 if (sizeof(int) > sizeof(register_t)) 5659 rv = *(int *)retval; 5660 else 5661 rv = *retval; 5662 } 5663 return rv; 5664 } 5665 #ifdef RUMP_KERNEL_IS_LIBC 5666 __weak_alias(timer_gettime,rump___sysimpl_timer_gettime50); 5667 __weak_alias(__timer_gettime50,rump___sysimpl_timer_gettime50); 5668 __weak_alias(___timer_gettime50,rump___sysimpl_timer_gettime50); 5669 __strong_alias(_sys___timer_gettime50,rump___sysimpl_timer_gettime50); 5670 #endif /* RUMP_KERNEL_IS_LIBC */ 5671 5672 int rump___sysimpl_mknod50(const char *, mode_t, dev_t); 5673 int 5674 rump___sysimpl_mknod50(const char * path, mode_t mode, dev_t dev) 5675 { 5676 register_t retval[2]; 5677 int error = 0; 5678 int rv = -1; 5679 struct sys___mknod50_args callarg; 5680 5681 memset(&callarg, 0, sizeof(callarg)); 5682 SPARG(&callarg, path) = path; 5683 SPARG(&callarg, mode) = mode; 5684 SPARG(&callarg, dev) = dev; 5685 5686 error = rsys_syscall(SYS___mknod50, &callarg, sizeof(callarg), retval); 5687 rsys_seterrno(error); 5688 if (error == 0) { 5689 if (sizeof(int) > sizeof(register_t)) 5690 rv = *(int *)retval; 5691 else 5692 rv = *retval; 5693 } 5694 return rv; 5695 } 5696 #ifdef RUMP_KERNEL_IS_LIBC 5697 __weak_alias(mknod,rump___sysimpl_mknod50); 5698 __weak_alias(__mknod50,rump___sysimpl_mknod50); 5699 __weak_alias(___mknod50,rump___sysimpl_mknod50); 5700 __strong_alias(_sys___mknod50,rump___sysimpl_mknod50); 5701 #endif /* RUMP_KERNEL_IS_LIBC */ 5702 5703 int rump___sysimpl_fhstat50(const void *, size_t, struct stat *); 5704 int 5705 rump___sysimpl_fhstat50(const void * fhp, size_t fh_size, struct stat * sb) 5706 { 5707 register_t retval[2]; 5708 int error = 0; 5709 int rv = -1; 5710 struct sys___fhstat50_args callarg; 5711 5712 memset(&callarg, 0, sizeof(callarg)); 5713 SPARG(&callarg, fhp) = fhp; 5714 SPARG(&callarg, fh_size) = fh_size; 5715 SPARG(&callarg, sb) = sb; 5716 5717 error = rsys_syscall(SYS___fhstat50, &callarg, sizeof(callarg), retval); 5718 rsys_seterrno(error); 5719 if (error == 0) { 5720 if (sizeof(int) > sizeof(register_t)) 5721 rv = *(int *)retval; 5722 else 5723 rv = *retval; 5724 } 5725 return rv; 5726 } 5727 #ifdef RUMP_KERNEL_IS_LIBC 5728 __weak_alias(fhstat,rump___sysimpl_fhstat50); 5729 __weak_alias(__fhstat50,rump___sysimpl_fhstat50); 5730 __weak_alias(___fhstat50,rump___sysimpl_fhstat50); 5731 __strong_alias(_sys___fhstat50,rump___sysimpl_fhstat50); 5732 #endif /* RUMP_KERNEL_IS_LIBC */ 5733 5734 int rump___sysimpl_pipe2(int *, int); 5735 int 5736 rump___sysimpl_pipe2(int * fildes, int flags) 5737 { 5738 register_t retval[2]; 5739 int error = 0; 5740 int rv = -1; 5741 struct sys_pipe2_args callarg; 5742 5743 memset(&callarg, 0, sizeof(callarg)); 5744 SPARG(&callarg, fildes) = fildes; 5745 SPARG(&callarg, flags) = flags; 5746 5747 error = rsys_syscall(SYS_pipe2, &callarg, sizeof(callarg), retval); 5748 rsys_seterrno(error); 5749 if (error == 0) { 5750 if (sizeof(int) > sizeof(register_t)) 5751 rv = *(int *)retval; 5752 else 5753 rv = *retval; 5754 } 5755 return rv; 5756 } 5757 #ifdef RUMP_KERNEL_IS_LIBC 5758 __weak_alias(pipe2,rump___sysimpl_pipe2); 5759 __weak_alias(_pipe2,rump___sysimpl_pipe2); 5760 __strong_alias(_sys_pipe2,rump___sysimpl_pipe2); 5761 #endif /* RUMP_KERNEL_IS_LIBC */ 5762 5763 int rump___sysimpl_dup3(int, int, int); 5764 int 5765 rump___sysimpl_dup3(int from, int to, int flags) 5766 { 5767 register_t retval[2]; 5768 int error = 0; 5769 int rv = -1; 5770 struct sys_dup3_args callarg; 5771 5772 memset(&callarg, 0, sizeof(callarg)); 5773 SPARG(&callarg, from) = from; 5774 SPARG(&callarg, to) = to; 5775 SPARG(&callarg, flags) = flags; 5776 5777 error = rsys_syscall(SYS_dup3, &callarg, sizeof(callarg), retval); 5778 rsys_seterrno(error); 5779 if (error == 0) { 5780 if (sizeof(int) > sizeof(register_t)) 5781 rv = *(int *)retval; 5782 else 5783 rv = *retval; 5784 } 5785 return rv; 5786 } 5787 #ifdef RUMP_KERNEL_IS_LIBC 5788 __weak_alias(dup3,rump___sysimpl_dup3); 5789 __weak_alias(_dup3,rump___sysimpl_dup3); 5790 __strong_alias(_sys_dup3,rump___sysimpl_dup3); 5791 #endif /* RUMP_KERNEL_IS_LIBC */ 5792 5793 int rump___sysimpl_kqueue1(int); 5794 int 5795 rump___sysimpl_kqueue1(int flags) 5796 { 5797 register_t retval[2]; 5798 int error = 0; 5799 int rv = -1; 5800 struct sys_kqueue1_args callarg; 5801 5802 memset(&callarg, 0, sizeof(callarg)); 5803 SPARG(&callarg, flags) = flags; 5804 5805 error = rsys_syscall(SYS_kqueue1, &callarg, sizeof(callarg), retval); 5806 rsys_seterrno(error); 5807 if (error == 0) { 5808 if (sizeof(int) > sizeof(register_t)) 5809 rv = *(int *)retval; 5810 else 5811 rv = *retval; 5812 } 5813 return rv; 5814 } 5815 #ifdef RUMP_KERNEL_IS_LIBC 5816 __weak_alias(kqueue1,rump___sysimpl_kqueue1); 5817 __weak_alias(_kqueue1,rump___sysimpl_kqueue1); 5818 __strong_alias(_sys_kqueue1,rump___sysimpl_kqueue1); 5819 #endif /* RUMP_KERNEL_IS_LIBC */ 5820 5821 int rump___sysimpl_paccept(int, struct sockaddr *, socklen_t *, const sigset_t *, int); 5822 int 5823 rump___sysimpl_paccept(int s, struct sockaddr * name, socklen_t * anamelen, const sigset_t * mask, int flags) 5824 { 5825 register_t retval[2]; 5826 int error = 0; 5827 int rv = -1; 5828 struct sys_paccept_args callarg; 5829 5830 memset(&callarg, 0, sizeof(callarg)); 5831 SPARG(&callarg, s) = s; 5832 SPARG(&callarg, name) = name; 5833 SPARG(&callarg, anamelen) = anamelen; 5834 SPARG(&callarg, mask) = mask; 5835 SPARG(&callarg, flags) = flags; 5836 5837 error = rsys_syscall(SYS_paccept, &callarg, sizeof(callarg), retval); 5838 rsys_seterrno(error); 5839 if (error == 0) { 5840 if (sizeof(int) > sizeof(register_t)) 5841 rv = *(int *)retval; 5842 else 5843 rv = *retval; 5844 } 5845 return rv; 5846 } 5847 #ifdef RUMP_KERNEL_IS_LIBC 5848 __weak_alias(paccept,rump___sysimpl_paccept); 5849 __weak_alias(_paccept,rump___sysimpl_paccept); 5850 __strong_alias(_sys_paccept,rump___sysimpl_paccept); 5851 #endif /* RUMP_KERNEL_IS_LIBC */ 5852 5853 int rump___sysimpl_linkat(int, const char *, int, const char *, int); 5854 int 5855 rump___sysimpl_linkat(int fd1, const char * name1, int fd2, const char * name2, int flags) 5856 { 5857 register_t retval[2]; 5858 int error = 0; 5859 int rv = -1; 5860 struct sys_linkat_args callarg; 5861 5862 memset(&callarg, 0, sizeof(callarg)); 5863 SPARG(&callarg, fd1) = fd1; 5864 SPARG(&callarg, name1) = name1; 5865 SPARG(&callarg, fd2) = fd2; 5866 SPARG(&callarg, name2) = name2; 5867 SPARG(&callarg, flags) = flags; 5868 5869 error = rsys_syscall(SYS_linkat, &callarg, sizeof(callarg), retval); 5870 rsys_seterrno(error); 5871 if (error == 0) { 5872 if (sizeof(int) > sizeof(register_t)) 5873 rv = *(int *)retval; 5874 else 5875 rv = *retval; 5876 } 5877 return rv; 5878 } 5879 #ifdef RUMP_KERNEL_IS_LIBC 5880 __weak_alias(linkat,rump___sysimpl_linkat); 5881 __weak_alias(_linkat,rump___sysimpl_linkat); 5882 __strong_alias(_sys_linkat,rump___sysimpl_linkat); 5883 #endif /* RUMP_KERNEL_IS_LIBC */ 5884 5885 int rump___sysimpl_renameat(int, const char *, int, const char *); 5886 int 5887 rump___sysimpl_renameat(int fromfd, const char * from, int tofd, const char * to) 5888 { 5889 register_t retval[2]; 5890 int error = 0; 5891 int rv = -1; 5892 struct sys_renameat_args callarg; 5893 5894 memset(&callarg, 0, sizeof(callarg)); 5895 SPARG(&callarg, fromfd) = fromfd; 5896 SPARG(&callarg, from) = from; 5897 SPARG(&callarg, tofd) = tofd; 5898 SPARG(&callarg, to) = to; 5899 5900 error = rsys_syscall(SYS_renameat, &callarg, sizeof(callarg), retval); 5901 rsys_seterrno(error); 5902 if (error == 0) { 5903 if (sizeof(int) > sizeof(register_t)) 5904 rv = *(int *)retval; 5905 else 5906 rv = *retval; 5907 } 5908 return rv; 5909 } 5910 #ifdef RUMP_KERNEL_IS_LIBC 5911 __weak_alias(renameat,rump___sysimpl_renameat); 5912 __weak_alias(_renameat,rump___sysimpl_renameat); 5913 __strong_alias(_sys_renameat,rump___sysimpl_renameat); 5914 #endif /* RUMP_KERNEL_IS_LIBC */ 5915 5916 int rump___sysimpl_mkfifoat(int, const char *, mode_t); 5917 int 5918 rump___sysimpl_mkfifoat(int fd, const char * path, mode_t mode) 5919 { 5920 register_t retval[2]; 5921 int error = 0; 5922 int rv = -1; 5923 struct sys_mkfifoat_args callarg; 5924 5925 memset(&callarg, 0, sizeof(callarg)); 5926 SPARG(&callarg, fd) = fd; 5927 SPARG(&callarg, path) = path; 5928 SPARG(&callarg, mode) = mode; 5929 5930 error = rsys_syscall(SYS_mkfifoat, &callarg, sizeof(callarg), retval); 5931 rsys_seterrno(error); 5932 if (error == 0) { 5933 if (sizeof(int) > sizeof(register_t)) 5934 rv = *(int *)retval; 5935 else 5936 rv = *retval; 5937 } 5938 return rv; 5939 } 5940 #ifdef RUMP_KERNEL_IS_LIBC 5941 __weak_alias(mkfifoat,rump___sysimpl_mkfifoat); 5942 __weak_alias(_mkfifoat,rump___sysimpl_mkfifoat); 5943 __strong_alias(_sys_mkfifoat,rump___sysimpl_mkfifoat); 5944 #endif /* RUMP_KERNEL_IS_LIBC */ 5945 5946 int rump___sysimpl_mknodat(int, const char *, mode_t, dev_t); 5947 int 5948 rump___sysimpl_mknodat(int fd, const char * path, mode_t mode, dev_t dev) 5949 { 5950 register_t retval[2]; 5951 int error = 0; 5952 int rv = -1; 5953 struct sys_mknodat_args callarg; 5954 5955 memset(&callarg, 0, sizeof(callarg)); 5956 SPARG(&callarg, fd) = fd; 5957 SPARG(&callarg, path) = path; 5958 SPARG(&callarg, mode) = mode; 5959 SPARG(&callarg, PAD) = 0; 5960 SPARG(&callarg, dev) = dev; 5961 5962 error = rsys_syscall(SYS_mknodat, &callarg, sizeof(callarg), retval); 5963 rsys_seterrno(error); 5964 if (error == 0) { 5965 if (sizeof(int) > sizeof(register_t)) 5966 rv = *(int *)retval; 5967 else 5968 rv = *retval; 5969 } 5970 return rv; 5971 } 5972 #ifdef RUMP_KERNEL_IS_LIBC 5973 __weak_alias(mknodat,rump___sysimpl_mknodat); 5974 __weak_alias(_mknodat,rump___sysimpl_mknodat); 5975 __strong_alias(_sys_mknodat,rump___sysimpl_mknodat); 5976 #endif /* RUMP_KERNEL_IS_LIBC */ 5977 5978 int rump___sysimpl_mkdirat(int, const char *, mode_t); 5979 int 5980 rump___sysimpl_mkdirat(int fd, const char * path, mode_t mode) 5981 { 5982 register_t retval[2]; 5983 int error = 0; 5984 int rv = -1; 5985 struct sys_mkdirat_args callarg; 5986 5987 memset(&callarg, 0, sizeof(callarg)); 5988 SPARG(&callarg, fd) = fd; 5989 SPARG(&callarg, path) = path; 5990 SPARG(&callarg, mode) = mode; 5991 5992 error = rsys_syscall(SYS_mkdirat, &callarg, sizeof(callarg), retval); 5993 rsys_seterrno(error); 5994 if (error == 0) { 5995 if (sizeof(int) > sizeof(register_t)) 5996 rv = *(int *)retval; 5997 else 5998 rv = *retval; 5999 } 6000 return rv; 6001 } 6002 #ifdef RUMP_KERNEL_IS_LIBC 6003 __weak_alias(mkdirat,rump___sysimpl_mkdirat); 6004 __weak_alias(_mkdirat,rump___sysimpl_mkdirat); 6005 __strong_alias(_sys_mkdirat,rump___sysimpl_mkdirat); 6006 #endif /* RUMP_KERNEL_IS_LIBC */ 6007 6008 int rump___sysimpl_faccessat(int, const char *, int, int); 6009 int 6010 rump___sysimpl_faccessat(int fd, const char * path, int amode, int flag) 6011 { 6012 register_t retval[2]; 6013 int error = 0; 6014 int rv = -1; 6015 struct sys_faccessat_args callarg; 6016 6017 memset(&callarg, 0, sizeof(callarg)); 6018 SPARG(&callarg, fd) = fd; 6019 SPARG(&callarg, path) = path; 6020 SPARG(&callarg, amode) = amode; 6021 SPARG(&callarg, flag) = flag; 6022 6023 error = rsys_syscall(SYS_faccessat, &callarg, sizeof(callarg), retval); 6024 rsys_seterrno(error); 6025 if (error == 0) { 6026 if (sizeof(int) > sizeof(register_t)) 6027 rv = *(int *)retval; 6028 else 6029 rv = *retval; 6030 } 6031 return rv; 6032 } 6033 #ifdef RUMP_KERNEL_IS_LIBC 6034 __weak_alias(faccessat,rump___sysimpl_faccessat); 6035 __weak_alias(_faccessat,rump___sysimpl_faccessat); 6036 __strong_alias(_sys_faccessat,rump___sysimpl_faccessat); 6037 #endif /* RUMP_KERNEL_IS_LIBC */ 6038 6039 int rump___sysimpl_fchmodat(int, const char *, mode_t, int); 6040 int 6041 rump___sysimpl_fchmodat(int fd, const char * path, mode_t mode, int flag) 6042 { 6043 register_t retval[2]; 6044 int error = 0; 6045 int rv = -1; 6046 struct sys_fchmodat_args callarg; 6047 6048 memset(&callarg, 0, sizeof(callarg)); 6049 SPARG(&callarg, fd) = fd; 6050 SPARG(&callarg, path) = path; 6051 SPARG(&callarg, mode) = mode; 6052 SPARG(&callarg, flag) = flag; 6053 6054 error = rsys_syscall(SYS_fchmodat, &callarg, sizeof(callarg), retval); 6055 rsys_seterrno(error); 6056 if (error == 0) { 6057 if (sizeof(int) > sizeof(register_t)) 6058 rv = *(int *)retval; 6059 else 6060 rv = *retval; 6061 } 6062 return rv; 6063 } 6064 #ifdef RUMP_KERNEL_IS_LIBC 6065 __weak_alias(fchmodat,rump___sysimpl_fchmodat); 6066 __weak_alias(_fchmodat,rump___sysimpl_fchmodat); 6067 __strong_alias(_sys_fchmodat,rump___sysimpl_fchmodat); 6068 #endif /* RUMP_KERNEL_IS_LIBC */ 6069 6070 int rump___sysimpl_fchownat(int, const char *, uid_t, gid_t, int); 6071 int 6072 rump___sysimpl_fchownat(int fd, const char * path, uid_t owner, gid_t group, int flag) 6073 { 6074 register_t retval[2]; 6075 int error = 0; 6076 int rv = -1; 6077 struct sys_fchownat_args callarg; 6078 6079 memset(&callarg, 0, sizeof(callarg)); 6080 SPARG(&callarg, fd) = fd; 6081 SPARG(&callarg, path) = path; 6082 SPARG(&callarg, owner) = owner; 6083 SPARG(&callarg, group) = group; 6084 SPARG(&callarg, flag) = flag; 6085 6086 error = rsys_syscall(SYS_fchownat, &callarg, sizeof(callarg), retval); 6087 rsys_seterrno(error); 6088 if (error == 0) { 6089 if (sizeof(int) > sizeof(register_t)) 6090 rv = *(int *)retval; 6091 else 6092 rv = *retval; 6093 } 6094 return rv; 6095 } 6096 #ifdef RUMP_KERNEL_IS_LIBC 6097 __weak_alias(fchownat,rump___sysimpl_fchownat); 6098 __weak_alias(_fchownat,rump___sysimpl_fchownat); 6099 __strong_alias(_sys_fchownat,rump___sysimpl_fchownat); 6100 #endif /* RUMP_KERNEL_IS_LIBC */ 6101 6102 int rump___sysimpl_fstatat(int, const char *, struct stat *, int); 6103 int 6104 rump___sysimpl_fstatat(int fd, const char * path, struct stat * buf, int flag) 6105 { 6106 register_t retval[2]; 6107 int error = 0; 6108 int rv = -1; 6109 struct sys_fstatat_args callarg; 6110 6111 memset(&callarg, 0, sizeof(callarg)); 6112 SPARG(&callarg, fd) = fd; 6113 SPARG(&callarg, path) = path; 6114 SPARG(&callarg, buf) = buf; 6115 SPARG(&callarg, flag) = flag; 6116 6117 error = rsys_syscall(SYS_fstatat, &callarg, sizeof(callarg), retval); 6118 rsys_seterrno(error); 6119 if (error == 0) { 6120 if (sizeof(int) > sizeof(register_t)) 6121 rv = *(int *)retval; 6122 else 6123 rv = *retval; 6124 } 6125 return rv; 6126 } 6127 #ifdef RUMP_KERNEL_IS_LIBC 6128 __weak_alias(fstatat,rump___sysimpl_fstatat); 6129 __weak_alias(_fstatat,rump___sysimpl_fstatat); 6130 __strong_alias(_sys_fstatat,rump___sysimpl_fstatat); 6131 #endif /* RUMP_KERNEL_IS_LIBC */ 6132 6133 int rump___sysimpl_utimensat(int, const char *, const struct timespec *, int); 6134 int 6135 rump___sysimpl_utimensat(int fd, const char * path, const struct timespec * tptr, int flag) 6136 { 6137 register_t retval[2]; 6138 int error = 0; 6139 int rv = -1; 6140 struct sys_utimensat_args callarg; 6141 6142 memset(&callarg, 0, sizeof(callarg)); 6143 SPARG(&callarg, fd) = fd; 6144 SPARG(&callarg, path) = path; 6145 SPARG(&callarg, tptr) = tptr; 6146 SPARG(&callarg, flag) = flag; 6147 6148 error = rsys_syscall(SYS_utimensat, &callarg, sizeof(callarg), retval); 6149 rsys_seterrno(error); 6150 if (error == 0) { 6151 if (sizeof(int) > sizeof(register_t)) 6152 rv = *(int *)retval; 6153 else 6154 rv = *retval; 6155 } 6156 return rv; 6157 } 6158 #ifdef RUMP_KERNEL_IS_LIBC 6159 __weak_alias(utimensat,rump___sysimpl_utimensat); 6160 __weak_alias(_utimensat,rump___sysimpl_utimensat); 6161 __strong_alias(_sys_utimensat,rump___sysimpl_utimensat); 6162 #endif /* RUMP_KERNEL_IS_LIBC */ 6163 6164 int rump___sysimpl_openat(int, const char *, int, mode_t); 6165 int 6166 rump___sysimpl_openat(int fd, const char * path, int oflags, mode_t mode) 6167 { 6168 register_t retval[2]; 6169 int error = 0; 6170 int rv = -1; 6171 struct sys_openat_args callarg; 6172 6173 memset(&callarg, 0, sizeof(callarg)); 6174 SPARG(&callarg, fd) = fd; 6175 SPARG(&callarg, path) = path; 6176 SPARG(&callarg, oflags) = oflags; 6177 SPARG(&callarg, mode) = mode; 6178 6179 error = rsys_syscall(SYS_openat, &callarg, sizeof(callarg), retval); 6180 rsys_seterrno(error); 6181 if (error == 0) { 6182 if (sizeof(int) > sizeof(register_t)) 6183 rv = *(int *)retval; 6184 else 6185 rv = *retval; 6186 } 6187 return rv; 6188 } 6189 #ifdef RUMP_KERNEL_IS_LIBC 6190 __weak_alias(openat,rump___sysimpl_openat); 6191 __weak_alias(_openat,rump___sysimpl_openat); 6192 __strong_alias(_sys_openat,rump___sysimpl_openat); 6193 #endif /* RUMP_KERNEL_IS_LIBC */ 6194 6195 ssize_t rump___sysimpl_readlinkat(int, const char *, char *, size_t); 6196 ssize_t 6197 rump___sysimpl_readlinkat(int fd, const char * path, char * buf, size_t bufsize) 6198 { 6199 register_t retval[2]; 6200 int error = 0; 6201 ssize_t rv = -1; 6202 struct sys_readlinkat_args callarg; 6203 6204 memset(&callarg, 0, sizeof(callarg)); 6205 SPARG(&callarg, fd) = fd; 6206 SPARG(&callarg, path) = path; 6207 SPARG(&callarg, buf) = buf; 6208 SPARG(&callarg, bufsize) = bufsize; 6209 6210 error = rsys_syscall(SYS_readlinkat, &callarg, sizeof(callarg), retval); 6211 rsys_seterrno(error); 6212 if (error == 0) { 6213 if (sizeof(ssize_t) > sizeof(register_t)) 6214 rv = *(ssize_t *)retval; 6215 else 6216 rv = *retval; 6217 } 6218 return rv; 6219 } 6220 #ifdef RUMP_KERNEL_IS_LIBC 6221 __weak_alias(readlinkat,rump___sysimpl_readlinkat); 6222 __weak_alias(_readlinkat,rump___sysimpl_readlinkat); 6223 __strong_alias(_sys_readlinkat,rump___sysimpl_readlinkat); 6224 #endif /* RUMP_KERNEL_IS_LIBC */ 6225 6226 int rump___sysimpl_symlinkat(const char *, int, const char *); 6227 int 6228 rump___sysimpl_symlinkat(const char * path1, int fd, const char * path2) 6229 { 6230 register_t retval[2]; 6231 int error = 0; 6232 int rv = -1; 6233 struct sys_symlinkat_args callarg; 6234 6235 memset(&callarg, 0, sizeof(callarg)); 6236 SPARG(&callarg, path1) = path1; 6237 SPARG(&callarg, fd) = fd; 6238 SPARG(&callarg, path2) = path2; 6239 6240 error = rsys_syscall(SYS_symlinkat, &callarg, sizeof(callarg), retval); 6241 rsys_seterrno(error); 6242 if (error == 0) { 6243 if (sizeof(int) > sizeof(register_t)) 6244 rv = *(int *)retval; 6245 else 6246 rv = *retval; 6247 } 6248 return rv; 6249 } 6250 #ifdef RUMP_KERNEL_IS_LIBC 6251 __weak_alias(symlinkat,rump___sysimpl_symlinkat); 6252 __weak_alias(_symlinkat,rump___sysimpl_symlinkat); 6253 __strong_alias(_sys_symlinkat,rump___sysimpl_symlinkat); 6254 #endif /* RUMP_KERNEL_IS_LIBC */ 6255 6256 int rump___sysimpl_unlinkat(int, const char *, int); 6257 int 6258 rump___sysimpl_unlinkat(int fd, const char * path, int flag) 6259 { 6260 register_t retval[2]; 6261 int error = 0; 6262 int rv = -1; 6263 struct sys_unlinkat_args callarg; 6264 6265 memset(&callarg, 0, sizeof(callarg)); 6266 SPARG(&callarg, fd) = fd; 6267 SPARG(&callarg, path) = path; 6268 SPARG(&callarg, flag) = flag; 6269 6270 error = rsys_syscall(SYS_unlinkat, &callarg, sizeof(callarg), retval); 6271 rsys_seterrno(error); 6272 if (error == 0) { 6273 if (sizeof(int) > sizeof(register_t)) 6274 rv = *(int *)retval; 6275 else 6276 rv = *retval; 6277 } 6278 return rv; 6279 } 6280 #ifdef RUMP_KERNEL_IS_LIBC 6281 __weak_alias(unlinkat,rump___sysimpl_unlinkat); 6282 __weak_alias(_unlinkat,rump___sysimpl_unlinkat); 6283 __strong_alias(_sys_unlinkat,rump___sysimpl_unlinkat); 6284 #endif /* RUMP_KERNEL_IS_LIBC */ 6285 6286 int rump___sysimpl_futimens(int, const struct timespec *); 6287 int 6288 rump___sysimpl_futimens(int fd, const struct timespec * tptr) 6289 { 6290 register_t retval[2]; 6291 int error = 0; 6292 int rv = -1; 6293 struct sys_futimens_args callarg; 6294 6295 memset(&callarg, 0, sizeof(callarg)); 6296 SPARG(&callarg, fd) = fd; 6297 SPARG(&callarg, tptr) = tptr; 6298 6299 error = rsys_syscall(SYS_futimens, &callarg, sizeof(callarg), retval); 6300 rsys_seterrno(error); 6301 if (error == 0) { 6302 if (sizeof(int) > sizeof(register_t)) 6303 rv = *(int *)retval; 6304 else 6305 rv = *retval; 6306 } 6307 return rv; 6308 } 6309 #ifdef RUMP_KERNEL_IS_LIBC 6310 __weak_alias(futimens,rump___sysimpl_futimens); 6311 __weak_alias(_futimens,rump___sysimpl_futimens); 6312 __strong_alias(_sys_futimens,rump___sysimpl_futimens); 6313 #endif /* RUMP_KERNEL_IS_LIBC */ 6314 6315 int rump___sysimpl___quotactl(const char *, struct quotactl_args *); 6316 int 6317 rump___sysimpl___quotactl(const char * path, struct quotactl_args * args) 6318 { 6319 register_t retval[2]; 6320 int error = 0; 6321 int rv = -1; 6322 struct sys___quotactl_args callarg; 6323 6324 memset(&callarg, 0, sizeof(callarg)); 6325 SPARG(&callarg, path) = path; 6326 SPARG(&callarg, args) = args; 6327 6328 error = rsys_syscall(SYS___quotactl, &callarg, sizeof(callarg), retval); 6329 rsys_seterrno(error); 6330 if (error == 0) { 6331 if (sizeof(int) > sizeof(register_t)) 6332 rv = *(int *)retval; 6333 else 6334 rv = *retval; 6335 } 6336 return rv; 6337 } 6338 #ifdef RUMP_KERNEL_IS_LIBC 6339 __weak_alias(__quotactl,rump___sysimpl___quotactl); 6340 __weak_alias(___quotactl,rump___sysimpl___quotactl); 6341 __strong_alias(_sys___quotactl,rump___sysimpl___quotactl); 6342 #endif /* RUMP_KERNEL_IS_LIBC */ 6343 6344 int rump___sysimpl_recvmmsg(int, struct mmsghdr *, unsigned int, unsigned int, struct timespec *); 6345 int 6346 rump___sysimpl_recvmmsg(int s, struct mmsghdr * mmsg, unsigned int vlen, unsigned int flags, struct timespec * timeout) 6347 { 6348 register_t retval[2]; 6349 int error = 0; 6350 int rv = -1; 6351 struct sys_recvmmsg_args callarg; 6352 6353 memset(&callarg, 0, sizeof(callarg)); 6354 SPARG(&callarg, s) = s; 6355 SPARG(&callarg, mmsg) = mmsg; 6356 SPARG(&callarg, vlen) = vlen; 6357 SPARG(&callarg, flags) = flags; 6358 SPARG(&callarg, timeout) = timeout; 6359 6360 error = rsys_syscall(SYS_recvmmsg, &callarg, sizeof(callarg), retval); 6361 rsys_seterrno(error); 6362 if (error == 0) { 6363 if (sizeof(int) > sizeof(register_t)) 6364 rv = *(int *)retval; 6365 else 6366 rv = *retval; 6367 } 6368 return rv; 6369 } 6370 #ifdef RUMP_KERNEL_IS_LIBC 6371 __weak_alias(recvmmsg,rump___sysimpl_recvmmsg); 6372 __weak_alias(_recvmmsg,rump___sysimpl_recvmmsg); 6373 __strong_alias(_sys_recvmmsg,rump___sysimpl_recvmmsg); 6374 #endif /* RUMP_KERNEL_IS_LIBC */ 6375 6376 int rump___sysimpl_sendmmsg(int, struct mmsghdr *, unsigned int, unsigned int); 6377 int 6378 rump___sysimpl_sendmmsg(int s, struct mmsghdr * mmsg, unsigned int vlen, unsigned int flags) 6379 { 6380 register_t retval[2]; 6381 int error = 0; 6382 int rv = -1; 6383 struct sys_sendmmsg_args callarg; 6384 6385 memset(&callarg, 0, sizeof(callarg)); 6386 SPARG(&callarg, s) = s; 6387 SPARG(&callarg, mmsg) = mmsg; 6388 SPARG(&callarg, vlen) = vlen; 6389 SPARG(&callarg, flags) = flags; 6390 6391 error = rsys_syscall(SYS_sendmmsg, &callarg, sizeof(callarg), retval); 6392 rsys_seterrno(error); 6393 if (error == 0) { 6394 if (sizeof(int) > sizeof(register_t)) 6395 rv = *(int *)retval; 6396 else 6397 rv = *retval; 6398 } 6399 return rv; 6400 } 6401 #ifdef RUMP_KERNEL_IS_LIBC 6402 __weak_alias(sendmmsg,rump___sysimpl_sendmmsg); 6403 __weak_alias(_sendmmsg,rump___sysimpl_sendmmsg); 6404 __strong_alias(_sys_sendmmsg,rump___sysimpl_sendmmsg); 6405 #endif /* RUMP_KERNEL_IS_LIBC */ 6406 6407 int rump___sysimpl_clock_nanosleep(clockid_t, int, const struct timespec *, struct timespec *); 6408 int 6409 rump___sysimpl_clock_nanosleep(clockid_t clock_id, int flags, const struct timespec * rqtp, struct timespec * rmtp) 6410 { 6411 register_t retval[2]; 6412 int rv = -1; 6413 struct sys_clock_nanosleep_args callarg; 6414 6415 memset(&callarg, 0, sizeof(callarg)); 6416 SPARG(&callarg, clock_id) = clock_id; 6417 SPARG(&callarg, flags) = flags; 6418 SPARG(&callarg, rqtp) = rqtp; 6419 SPARG(&callarg, rmtp) = rmtp; 6420 6421 (void)rsys_syscall(SYS_clock_nanosleep, &callarg, sizeof(callarg), retval); 6422 if (sizeof(int) > sizeof(register_t)) 6423 rv = *(int *)retval; 6424 else 6425 rv = *retval; 6426 return rv; 6427 } 6428 #ifdef RUMP_KERNEL_IS_LIBC 6429 __weak_alias(clock_nanosleep,rump___sysimpl_clock_nanosleep); 6430 __weak_alias(_clock_nanosleep,rump___sysimpl_clock_nanosleep); 6431 __strong_alias(_sys_clock_nanosleep,rump___sysimpl_clock_nanosleep); 6432 #endif /* RUMP_KERNEL_IS_LIBC */ 6433 6434 int rump___sysimpl_posix_fallocate(int, off_t, off_t); 6435 int 6436 rump___sysimpl_posix_fallocate(int fd, off_t pos, off_t len) 6437 { 6438 register_t retval[2]; 6439 int rv = -1; 6440 struct sys_posix_fallocate_args callarg; 6441 6442 memset(&callarg, 0, sizeof(callarg)); 6443 SPARG(&callarg, fd) = fd; 6444 SPARG(&callarg, PAD) = 0; 6445 SPARG(&callarg, pos) = pos; 6446 SPARG(&callarg, len) = len; 6447 6448 (void)rsys_syscall(SYS_posix_fallocate, &callarg, sizeof(callarg), retval); 6449 if (sizeof(int) > sizeof(register_t)) 6450 rv = *(int *)retval; 6451 else 6452 rv = *retval; 6453 return rv; 6454 } 6455 #ifdef RUMP_KERNEL_IS_LIBC 6456 __weak_alias(posix_fallocate,rump___sysimpl_posix_fallocate); 6457 __weak_alias(_posix_fallocate,rump___sysimpl_posix_fallocate); 6458 __strong_alias(_sys_posix_fallocate,rump___sysimpl_posix_fallocate); 6459 #endif /* RUMP_KERNEL_IS_LIBC */ 6460 6461 int rump___sysimpl_fdiscard(int, off_t, off_t); 6462 int 6463 rump___sysimpl_fdiscard(int fd, off_t pos, off_t len) 6464 { 6465 register_t retval[2]; 6466 int error = 0; 6467 int rv = -1; 6468 struct sys_fdiscard_args callarg; 6469 6470 memset(&callarg, 0, sizeof(callarg)); 6471 SPARG(&callarg, fd) = fd; 6472 SPARG(&callarg, PAD) = 0; 6473 SPARG(&callarg, pos) = pos; 6474 SPARG(&callarg, len) = len; 6475 6476 error = rsys_syscall(SYS_fdiscard, &callarg, sizeof(callarg), retval); 6477 rsys_seterrno(error); 6478 if (error == 0) { 6479 if (sizeof(int) > sizeof(register_t)) 6480 rv = *(int *)retval; 6481 else 6482 rv = *retval; 6483 } 6484 return rv; 6485 } 6486 #ifdef RUMP_KERNEL_IS_LIBC 6487 __weak_alias(fdiscard,rump___sysimpl_fdiscard); 6488 __weak_alias(_fdiscard,rump___sysimpl_fdiscard); 6489 __strong_alias(_sys_fdiscard,rump___sysimpl_fdiscard); 6490 #endif /* RUMP_KERNEL_IS_LIBC */ 6491 6492 int rump_sys_pipe(int *); 6493 int 6494 rump_sys_pipe(int *fd) 6495 { 6496 register_t retval[2]; 6497 int error = 0; 6498 6499 error = rsys_syscall(SYS_pipe, NULL, 0, retval); 6500 if (error) { 6501 rsys_seterrno(error); 6502 } else { 6503 fd[0] = retval[0]; 6504 fd[1] = retval[1]; 6505 } 6506 return error ? -1 : 0; 6507 } 6508 #ifdef RUMP_KERNEL_IS_LIBC 6509 __weak_alias(pipe,rump_sys_pipe); 6510 __weak_alias(_pipe,rump_sys_pipe); 6511 __strong_alias(_sys_pipe,rump_sys_pipe); 6512 #endif 6513 6514 #ifndef RUMP_CLIENT 6515 int rumpns_enosys(void); 6516 #define s(type) sizeof(type) 6517 #define n(type) (sizeof(type)/sizeof (register_t)) 6518 #define ns(type) n(type), s(type) 6519 6520 struct sysent rump_sysent[] = { 6521 { 6522 .sy_call = (sy_call_t *)rumpns_enosys, 6523 }, /* 0 = syscall */ 6524 { 6525 .sy_call = (sy_call_t *)rumpns_enosys, 6526 }, /* 1 = exit */ 6527 { 6528 .sy_call = (sy_call_t *)rumpns_enosys, 6529 }, /* 2 = fork */ 6530 { 6531 ns(struct sys_read_args), 6532 .sy_call = (sy_call_t *)rumpns_enosys, 6533 }, /* 3 = read */ 6534 { 6535 ns(struct sys_write_args), 6536 .sy_call = (sy_call_t *)rumpns_enosys, 6537 }, /* 4 = write */ 6538 { 6539 ns(struct sys_open_args), 6540 .sy_call = (sy_call_t *)rumpns_enosys, 6541 }, /* 5 = open */ 6542 { 6543 ns(struct sys_close_args), 6544 .sy_call = (sy_call_t *)rumpns_enosys, 6545 }, /* 6 = close */ 6546 { 6547 .sy_flags = SYCALL_NOSYS, 6548 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 6549 }, /* 7 = wait4 */ 6550 { 6551 .sy_flags = SYCALL_NOSYS, 6552 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 6553 }, /* 8 = ocreat */ 6554 { 6555 ns(struct sys_link_args), 6556 .sy_call = (sy_call_t *)rumpns_enosys, 6557 }, /* 9 = link */ 6558 { 6559 ns(struct sys_unlink_args), 6560 .sy_call = (sy_call_t *)rumpns_enosys, 6561 }, /* 10 = unlink */ 6562 { 6563 .sy_flags = SYCALL_NOSYS, 6564 .sy_call = (sy_call_t *)rumpns_enosys, 6565 }, /* 11 = filler */ 6566 { 6567 ns(struct sys_chdir_args), 6568 .sy_call = (sy_call_t *)rumpns_enosys, 6569 }, /* 12 = chdir */ 6570 { 6571 ns(struct sys_fchdir_args), 6572 .sy_call = (sy_call_t *)rumpns_enosys, 6573 }, /* 13 = fchdir */ 6574 { 6575 ns(struct compat_50_sys_mknod_args), 6576 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 6577 }, /* 14 = compat_50_mknod */ 6578 { 6579 ns(struct sys_chmod_args), 6580 .sy_call = (sy_call_t *)rumpns_enosys, 6581 }, /* 15 = chmod */ 6582 { 6583 ns(struct sys_chown_args), 6584 .sy_call = (sy_call_t *)rumpns_enosys, 6585 }, /* 16 = chown */ 6586 { 6587 .sy_call = (sy_call_t *)rumpns_enosys, 6588 }, /* 17 = break */ 6589 { 6590 .sy_flags = SYCALL_NOSYS, 6591 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 6592 }, /* 18 = getfsstat */ 6593 { 6594 .sy_flags = SYCALL_NOSYS, 6595 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 6596 }, /* 19 = olseek */ 6597 { 6598 .sy_call = (sy_call_t *)rumpns_enosys, 6599 }, /* 20 = getpid */ 6600 { 6601 .sy_flags = SYCALL_NOSYS, 6602 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 6603 }, /* 21 = mount */ 6604 { 6605 ns(struct sys_unmount_args), 6606 .sy_call = (sy_call_t *)rumpns_enosys, 6607 }, /* 22 = unmount */ 6608 { 6609 ns(struct sys_setuid_args), 6610 .sy_call = (sy_call_t *)rumpns_enosys, 6611 }, /* 23 = setuid */ 6612 { 6613 .sy_call = (sy_call_t *)rumpns_enosys, 6614 }, /* 24 = getuid */ 6615 { 6616 .sy_call = (sy_call_t *)rumpns_enosys, 6617 }, /* 25 = geteuid */ 6618 { 6619 .sy_call = (sy_call_t *)rumpns_enosys, 6620 }, /* 26 = ptrace */ 6621 { 6622 ns(struct sys_recvmsg_args), 6623 .sy_call = (sy_call_t *)rumpns_enosys, 6624 }, /* 27 = recvmsg */ 6625 { 6626 ns(struct sys_sendmsg_args), 6627 .sy_call = (sy_call_t *)rumpns_enosys, 6628 }, /* 28 = sendmsg */ 6629 { 6630 ns(struct sys_recvfrom_args), 6631 .sy_call = (sy_call_t *)rumpns_enosys, 6632 }, /* 29 = recvfrom */ 6633 { 6634 ns(struct sys_accept_args), 6635 .sy_call = (sy_call_t *)rumpns_enosys, 6636 }, /* 30 = accept */ 6637 { 6638 ns(struct sys_getpeername_args), 6639 .sy_call = (sy_call_t *)rumpns_enosys, 6640 }, /* 31 = getpeername */ 6641 { 6642 ns(struct sys_getsockname_args), 6643 .sy_call = (sy_call_t *)rumpns_enosys, 6644 }, /* 32 = getsockname */ 6645 { 6646 ns(struct sys_access_args), 6647 .sy_call = (sy_call_t *)rumpns_enosys, 6648 }, /* 33 = access */ 6649 { 6650 ns(struct sys_chflags_args), 6651 .sy_call = (sy_call_t *)rumpns_enosys, 6652 }, /* 34 = chflags */ 6653 { 6654 ns(struct sys_fchflags_args), 6655 .sy_call = (sy_call_t *)rumpns_enosys, 6656 }, /* 35 = fchflags */ 6657 { 6658 .sy_call = (sy_call_t *)rumpns_enosys, 6659 }, /* 36 = sync */ 6660 { 6661 .sy_call = (sy_call_t *)rumpns_enosys, 6662 }, /* 37 = kill */ 6663 { 6664 .sy_flags = SYCALL_NOSYS, 6665 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 6666 }, /* 38 = stat43 */ 6667 { 6668 .sy_call = (sy_call_t *)rumpns_enosys, 6669 }, /* 39 = getppid */ 6670 { 6671 .sy_flags = SYCALL_NOSYS, 6672 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 6673 }, /* 40 = lstat43 */ 6674 { 6675 ns(struct sys_dup_args), 6676 .sy_call = (sy_call_t *)rumpns_enosys, 6677 }, /* 41 = dup */ 6678 { 6679 .sy_call = (sy_call_t *)rumpns_enosys, 6680 }, /* 42 = pipe */ 6681 { 6682 .sy_call = (sy_call_t *)rumpns_enosys, 6683 }, /* 43 = getegid */ 6684 { 6685 .sy_call = (sy_call_t *)rumpns_enosys, 6686 }, /* 44 = profil */ 6687 { 6688 ns(struct sys_ktrace_args), 6689 .sy_call = (sy_call_t *)rumpns_enosys, 6690 }, /* 45 = ktrace */ 6691 { 6692 .sy_flags = SYCALL_NOSYS, 6693 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 6694 }, /* 46 = sigaction13 */ 6695 { 6696 .sy_call = (sy_call_t *)rumpns_enosys, 6697 }, /* 47 = getgid */ 6698 { 6699 .sy_flags = SYCALL_NOSYS, 6700 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 6701 }, /* 48 = sigprocmask13 */ 6702 { 6703 ns(struct sys___getlogin_args), 6704 .sy_call = (sy_call_t *)rumpns_enosys, 6705 }, /* 49 = __getlogin */ 6706 { 6707 ns(struct sys___setlogin_args), 6708 .sy_call = (sy_call_t *)rumpns_enosys, 6709 }, /* 50 = __setlogin */ 6710 { 6711 .sy_call = (sy_call_t *)rumpns_enosys, 6712 }, /* 51 = acct */ 6713 { 6714 .sy_flags = SYCALL_NOSYS, 6715 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 6716 }, /* 52 = sigpending13 */ 6717 { 6718 .sy_flags = SYCALL_NOSYS, 6719 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 6720 }, /* 53 = sigaltstack13 */ 6721 { 6722 ns(struct sys_ioctl_args), 6723 .sy_call = (sy_call_t *)rumpns_enosys, 6724 }, /* 54 = ioctl */ 6725 { 6726 .sy_flags = SYCALL_NOSYS, 6727 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 6728 }, /* 55 = oreboot */ 6729 { 6730 ns(struct sys_revoke_args), 6731 .sy_call = (sy_call_t *)rumpns_enosys, 6732 }, /* 56 = revoke */ 6733 { 6734 ns(struct sys_symlink_args), 6735 .sy_call = (sy_call_t *)rumpns_enosys, 6736 }, /* 57 = symlink */ 6737 { 6738 ns(struct sys_readlink_args), 6739 .sy_call = (sy_call_t *)rumpns_enosys, 6740 }, /* 58 = readlink */ 6741 { 6742 .sy_call = (sy_call_t *)rumpns_enosys, 6743 }, /* 59 = execve */ 6744 { 6745 ns(struct sys_umask_args), 6746 .sy_call = (sy_call_t *)rumpns_enosys, 6747 }, /* 60 = umask */ 6748 { 6749 ns(struct sys_chroot_args), 6750 .sy_call = (sy_call_t *)rumpns_enosys, 6751 }, /* 61 = chroot */ 6752 { 6753 .sy_flags = SYCALL_NOSYS, 6754 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 6755 }, /* 62 = fstat43 */ 6756 { 6757 .sy_flags = SYCALL_NOSYS, 6758 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 6759 }, /* 63 = ogetkerninfo */ 6760 { 6761 .sy_flags = SYCALL_NOSYS, 6762 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 6763 }, /* 64 = ogetpagesize */ 6764 { 6765 .sy_flags = SYCALL_NOSYS, 6766 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 6767 }, /* 65 = msync */ 6768 { 6769 .sy_call = (sy_call_t *)rumpns_enosys, 6770 }, /* 66 = vfork */ 6771 { 6772 .sy_flags = SYCALL_NOSYS, 6773 .sy_call = (sy_call_t *)rumpns_enosys, 6774 }, /* 67 = filler */ 6775 { 6776 .sy_flags = SYCALL_NOSYS, 6777 .sy_call = (sy_call_t *)rumpns_enosys, 6778 }, /* 68 = filler */ 6779 { 6780 .sy_call = (sy_call_t *)rumpns_enosys, 6781 }, /* 69 = sbrk */ 6782 { 6783 .sy_call = (sy_call_t *)rumpns_enosys, 6784 }, /* 70 = sstk */ 6785 { 6786 .sy_flags = SYCALL_NOSYS, 6787 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 6788 }, /* 71 = ommap */ 6789 { 6790 .sy_call = (sy_call_t *)rumpns_enosys, 6791 }, /* 72 = vadvise */ 6792 { 6793 .sy_call = (sy_call_t *)rumpns_enosys, 6794 }, /* 73 = munmap */ 6795 { 6796 .sy_call = (sy_call_t *)rumpns_enosys, 6797 }, /* 74 = mprotect */ 6798 { 6799 .sy_call = (sy_call_t *)rumpns_enosys, 6800 }, /* 75 = madvise */ 6801 { 6802 .sy_flags = SYCALL_NOSYS, 6803 .sy_call = (sy_call_t *)rumpns_enosys, 6804 }, /* 76 = filler */ 6805 { 6806 .sy_flags = SYCALL_NOSYS, 6807 .sy_call = (sy_call_t *)rumpns_enosys, 6808 }, /* 77 = filler */ 6809 { 6810 .sy_call = (sy_call_t *)rumpns_enosys, 6811 }, /* 78 = mincore */ 6812 { 6813 ns(struct sys_getgroups_args), 6814 .sy_call = (sy_call_t *)rumpns_enosys, 6815 }, /* 79 = getgroups */ 6816 { 6817 ns(struct sys_setgroups_args), 6818 .sy_call = (sy_call_t *)rumpns_enosys, 6819 }, /* 80 = setgroups */ 6820 { 6821 .sy_call = (sy_call_t *)rumpns_enosys, 6822 }, /* 81 = getpgrp */ 6823 { 6824 ns(struct sys_setpgid_args), 6825 .sy_call = (sy_call_t *)rumpns_enosys, 6826 }, /* 82 = setpgid */ 6827 { 6828 .sy_flags = SYCALL_NOSYS, 6829 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 6830 }, /* 83 = setitimer */ 6831 { 6832 .sy_flags = SYCALL_NOSYS, 6833 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 6834 }, /* 84 = owait */ 6835 { 6836 .sy_flags = SYCALL_NOSYS, 6837 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 6838 }, /* 85 = oswapon */ 6839 { 6840 .sy_flags = SYCALL_NOSYS, 6841 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 6842 }, /* 86 = getitimer */ 6843 { 6844 .sy_flags = SYCALL_NOSYS, 6845 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 6846 }, /* 87 = ogethostname */ 6847 { 6848 .sy_flags = SYCALL_NOSYS, 6849 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 6850 }, /* 88 = osethostname */ 6851 { 6852 .sy_flags = SYCALL_NOSYS, 6853 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 6854 }, /* 89 = ogetdtablesize */ 6855 { 6856 ns(struct sys_dup2_args), 6857 .sy_call = (sy_call_t *)rumpns_enosys, 6858 }, /* 90 = dup2 */ 6859 { 6860 .sy_flags = SYCALL_NOSYS, 6861 .sy_call = (sy_call_t *)rumpns_enosys, 6862 }, /* 91 = filler */ 6863 { 6864 ns(struct sys_fcntl_args), 6865 .sy_call = (sy_call_t *)rumpns_enosys, 6866 }, /* 92 = fcntl */ 6867 { 6868 ns(struct compat_50_sys_select_args), 6869 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 6870 }, /* 93 = compat_50_select */ 6871 { 6872 .sy_flags = SYCALL_NOSYS, 6873 .sy_call = (sy_call_t *)rumpns_enosys, 6874 }, /* 94 = filler */ 6875 { 6876 ns(struct sys_fsync_args), 6877 .sy_call = (sy_call_t *)rumpns_enosys, 6878 }, /* 95 = fsync */ 6879 { 6880 .sy_call = (sy_call_t *)rumpns_enosys, 6881 }, /* 96 = setpriority */ 6882 { 6883 .sy_flags = SYCALL_NOSYS, 6884 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 6885 }, /* 97 = socket */ 6886 { 6887 ns(struct sys_connect_args), 6888 .sy_call = (sy_call_t *)rumpns_enosys, 6889 }, /* 98 = connect */ 6890 { 6891 .sy_flags = SYCALL_NOSYS, 6892 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 6893 }, /* 99 = oaccept */ 6894 { 6895 .sy_call = (sy_call_t *)rumpns_enosys, 6896 }, /* 100 = getpriority */ 6897 { 6898 .sy_flags = SYCALL_NOSYS, 6899 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 6900 }, /* 101 = osend */ 6901 { 6902 .sy_flags = SYCALL_NOSYS, 6903 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 6904 }, /* 102 = orecv */ 6905 { 6906 .sy_flags = SYCALL_NOSYS, 6907 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 6908 }, /* 103 = sigreturn13 */ 6909 { 6910 ns(struct sys_bind_args), 6911 .sy_call = (sy_call_t *)rumpns_enosys, 6912 }, /* 104 = bind */ 6913 { 6914 ns(struct sys_setsockopt_args), 6915 .sy_call = (sy_call_t *)rumpns_enosys, 6916 }, /* 105 = setsockopt */ 6917 { 6918 ns(struct sys_listen_args), 6919 .sy_call = (sy_call_t *)rumpns_enosys, 6920 }, /* 106 = listen */ 6921 { 6922 .sy_flags = SYCALL_NOSYS, 6923 .sy_call = (sy_call_t *)rumpns_enosys, 6924 }, /* 107 = filler */ 6925 { 6926 .sy_flags = SYCALL_NOSYS, 6927 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 6928 }, /* 108 = osigvec */ 6929 { 6930 .sy_flags = SYCALL_NOSYS, 6931 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 6932 }, /* 109 = osigblock */ 6933 { 6934 .sy_flags = SYCALL_NOSYS, 6935 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 6936 }, /* 110 = osigsetmask */ 6937 { 6938 .sy_flags = SYCALL_NOSYS, 6939 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 6940 }, /* 111 = sigsuspend13 */ 6941 { 6942 .sy_flags = SYCALL_NOSYS, 6943 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 6944 }, /* 112 = osigstack */ 6945 { 6946 .sy_flags = SYCALL_NOSYS, 6947 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 6948 }, /* 113 = orecvmsg */ 6949 { 6950 .sy_flags = SYCALL_NOSYS, 6951 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 6952 }, /* 114 = osendmsg */ 6953 { 6954 .sy_flags = SYCALL_NOSYS, 6955 .sy_call = (sy_call_t *)rumpns_enosys, 6956 }, /* 115 = filler */ 6957 { 6958 .sy_flags = SYCALL_NOSYS, 6959 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 6960 }, /* 116 = gettimeofday */ 6961 { 6962 .sy_flags = SYCALL_NOSYS, 6963 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 6964 }, /* 117 = getrusage */ 6965 { 6966 ns(struct sys_getsockopt_args), 6967 .sy_call = (sy_call_t *)rumpns_enosys, 6968 }, /* 118 = getsockopt */ 6969 { 6970 .sy_flags = SYCALL_NOSYS, 6971 .sy_call = (sy_call_t *)rumpns_enosys, 6972 }, /* 119 = filler */ 6973 { 6974 ns(struct sys_readv_args), 6975 .sy_call = (sy_call_t *)rumpns_enosys, 6976 }, /* 120 = readv */ 6977 { 6978 ns(struct sys_writev_args), 6979 .sy_call = (sy_call_t *)rumpns_enosys, 6980 }, /* 121 = writev */ 6981 { 6982 .sy_flags = SYCALL_NOSYS, 6983 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 6984 }, /* 122 = settimeofday */ 6985 { 6986 ns(struct sys_fchown_args), 6987 .sy_call = (sy_call_t *)rumpns_enosys, 6988 }, /* 123 = fchown */ 6989 { 6990 ns(struct sys_fchmod_args), 6991 .sy_call = (sy_call_t *)rumpns_enosys, 6992 }, /* 124 = fchmod */ 6993 { 6994 .sy_flags = SYCALL_NOSYS, 6995 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 6996 }, /* 125 = orecvfrom */ 6997 { 6998 ns(struct sys_setreuid_args), 6999 .sy_call = (sy_call_t *)rumpns_enosys, 7000 }, /* 126 = setreuid */ 7001 { 7002 ns(struct sys_setregid_args), 7003 .sy_call = (sy_call_t *)rumpns_enosys, 7004 }, /* 127 = setregid */ 7005 { 7006 ns(struct sys_rename_args), 7007 .sy_call = (sy_call_t *)rumpns_enosys, 7008 }, /* 128 = rename */ 7009 { 7010 .sy_flags = SYCALL_NOSYS, 7011 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7012 }, /* 129 = otruncate */ 7013 { 7014 .sy_flags = SYCALL_NOSYS, 7015 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7016 }, /* 130 = oftruncate */ 7017 { 7018 ns(struct sys_flock_args), 7019 .sy_call = (sy_call_t *)rumpns_enosys, 7020 }, /* 131 = flock */ 7021 { 7022 ns(struct sys_mkfifo_args), 7023 .sy_call = (sy_call_t *)rumpns_enosys, 7024 }, /* 132 = mkfifo */ 7025 { 7026 ns(struct sys_sendto_args), 7027 .sy_call = (sy_call_t *)rumpns_enosys, 7028 }, /* 133 = sendto */ 7029 { 7030 ns(struct sys_shutdown_args), 7031 .sy_call = (sy_call_t *)rumpns_enosys, 7032 }, /* 134 = shutdown */ 7033 { 7034 ns(struct sys_socketpair_args), 7035 .sy_call = (sy_call_t *)rumpns_enosys, 7036 }, /* 135 = socketpair */ 7037 { 7038 ns(struct sys_mkdir_args), 7039 .sy_call = (sy_call_t *)rumpns_enosys, 7040 }, /* 136 = mkdir */ 7041 { 7042 ns(struct sys_rmdir_args), 7043 .sy_call = (sy_call_t *)rumpns_enosys, 7044 }, /* 137 = rmdir */ 7045 { 7046 ns(struct compat_50_sys_utimes_args), 7047 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7048 }, /* 138 = compat_50_utimes */ 7049 { 7050 .sy_flags = SYCALL_NOSYS, 7051 .sy_call = (sy_call_t *)rumpns_enosys, 7052 }, /* 139 = filler */ 7053 { 7054 .sy_flags = SYCALL_NOSYS, 7055 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7056 }, /* 140 = adjtime */ 7057 { 7058 .sy_flags = SYCALL_NOSYS, 7059 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7060 }, /* 141 = ogetpeername */ 7061 { 7062 .sy_flags = SYCALL_NOSYS, 7063 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7064 }, /* 142 = ogethostid */ 7065 { 7066 .sy_flags = SYCALL_NOSYS, 7067 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7068 }, /* 143 = osethostid */ 7069 { 7070 .sy_flags = SYCALL_NOSYS, 7071 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7072 }, /* 144 = ogetrlimit */ 7073 { 7074 .sy_flags = SYCALL_NOSYS, 7075 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7076 }, /* 145 = osetrlimit */ 7077 { 7078 .sy_flags = SYCALL_NOSYS, 7079 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7080 }, /* 146 = okillpg */ 7081 { 7082 .sy_call = (sy_call_t *)rumpns_enosys, 7083 }, /* 147 = setsid */ 7084 { 7085 .sy_flags = SYCALL_NOSYS, 7086 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7087 }, /* 148 = quotactl */ 7088 { 7089 .sy_flags = SYCALL_NOSYS, 7090 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7091 }, /* 149 = oquota */ 7092 { 7093 .sy_flags = SYCALL_NOSYS, 7094 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7095 }, /* 150 = ogetsockname */ 7096 { 7097 .sy_flags = SYCALL_NOSYS, 7098 .sy_call = (sy_call_t *)rumpns_enosys, 7099 }, /* 151 = filler */ 7100 { 7101 .sy_flags = SYCALL_NOSYS, 7102 .sy_call = (sy_call_t *)rumpns_enosys, 7103 }, /* 152 = filler */ 7104 { 7105 .sy_flags = SYCALL_NOSYS, 7106 .sy_call = (sy_call_t *)rumpns_enosys, 7107 }, /* 153 = filler */ 7108 { 7109 .sy_flags = SYCALL_NOSYS, 7110 .sy_call = (sy_call_t *)rumpns_enosys, 7111 }, /* 154 = filler */ 7112 { 7113 ns(struct sys_nfssvc_args), 7114 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7115 }, /* 155 = nfssvc */ 7116 { 7117 .sy_flags = SYCALL_NOSYS, 7118 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7119 }, /* 156 = ogetdirentries */ 7120 { 7121 .sy_flags = SYCALL_NOSYS, 7122 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7123 }, /* 157 = statfs */ 7124 { 7125 .sy_flags = SYCALL_NOSYS, 7126 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7127 }, /* 158 = fstatfs */ 7128 { 7129 .sy_flags = SYCALL_NOSYS, 7130 .sy_call = (sy_call_t *)rumpns_enosys, 7131 }, /* 159 = filler */ 7132 { 7133 .sy_flags = SYCALL_NOSYS, 7134 .sy_call = (sy_call_t *)rumpns_enosys, 7135 }, /* 160 = filler */ 7136 { 7137 .sy_flags = SYCALL_NOSYS, 7138 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7139 }, /* 161 = getfh */ 7140 { 7141 .sy_flags = SYCALL_NOSYS, 7142 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7143 }, /* 162 = ogetdomainname */ 7144 { 7145 .sy_flags = SYCALL_NOSYS, 7146 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7147 }, /* 163 = osetdomainname */ 7148 { 7149 .sy_flags = SYCALL_NOSYS, 7150 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7151 }, /* 164 = ouname */ 7152 { 7153 .sy_call = (sy_call_t *)rumpns_enosys, 7154 }, /* 165 = sysarch */ 7155 { 7156 .sy_flags = SYCALL_NOSYS, 7157 .sy_call = (sy_call_t *)rumpns_enosys, 7158 }, /* 166 = filler */ 7159 { 7160 .sy_flags = SYCALL_NOSYS, 7161 .sy_call = (sy_call_t *)rumpns_enosys, 7162 }, /* 167 = filler */ 7163 { 7164 .sy_flags = SYCALL_NOSYS, 7165 .sy_call = (sy_call_t *)rumpns_enosys, 7166 }, /* 168 = filler */ 7167 #if !defined(_LP64) 7168 { 7169 .sy_flags = SYCALL_NOSYS, 7170 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7171 }, /* 169 = osemsys */ 7172 #else 7173 { 7174 .sy_flags = SYCALL_NOSYS, 7175 .sy_call = (sy_call_t *)rumpns_enosys, 7176 }, /* 169 = filler */ 7177 #endif 7178 #if !defined(_LP64) 7179 { 7180 .sy_flags = SYCALL_NOSYS, 7181 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7182 }, /* 170 = omsgsys */ 7183 #else 7184 { 7185 .sy_flags = SYCALL_NOSYS, 7186 .sy_call = (sy_call_t *)rumpns_enosys, 7187 }, /* 170 = filler */ 7188 #endif 7189 #if !defined(_LP64) 7190 { 7191 .sy_flags = SYCALL_NOSYS, 7192 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7193 }, /* 171 = oshmsys */ 7194 #else 7195 { 7196 .sy_flags = SYCALL_NOSYS, 7197 .sy_call = (sy_call_t *)rumpns_enosys, 7198 }, /* 171 = filler */ 7199 #endif 7200 { 7201 .sy_flags = SYCALL_NOSYS, 7202 .sy_call = (sy_call_t *)rumpns_enosys, 7203 }, /* 172 = filler */ 7204 { 7205 ns(struct sys_pread_args), 7206 .sy_call = (sy_call_t *)rumpns_enosys, 7207 }, /* 173 = pread */ 7208 { 7209 ns(struct sys_pwrite_args), 7210 .sy_call = (sy_call_t *)rumpns_enosys, 7211 }, /* 174 = pwrite */ 7212 { 7213 .sy_call = (sy_call_t *)rumpns_enosys, 7214 }, /* 175 = ntp_gettime */ 7215 #if defined(NTP) || !defined(_KERNEL_OPT) 7216 { 7217 .sy_call = (sy_call_t *)rumpns_enosys, 7218 }, /* 176 = ntp_adjtime */ 7219 #else 7220 { 7221 .sy_flags = SYCALL_NOSYS, 7222 .sy_call = (sy_call_t *)rumpns_enosys, 7223 }, /* 176 = filler */ 7224 #endif 7225 { 7226 .sy_flags = SYCALL_NOSYS, 7227 .sy_call = (sy_call_t *)rumpns_enosys, 7228 }, /* 177 = filler */ 7229 { 7230 .sy_flags = SYCALL_NOSYS, 7231 .sy_call = (sy_call_t *)rumpns_enosys, 7232 }, /* 178 = filler */ 7233 { 7234 .sy_flags = SYCALL_NOSYS, 7235 .sy_call = (sy_call_t *)rumpns_enosys, 7236 }, /* 179 = filler */ 7237 { 7238 .sy_flags = SYCALL_NOSYS, 7239 .sy_call = (sy_call_t *)rumpns_enosys, 7240 }, /* 180 = filler */ 7241 { 7242 ns(struct sys_setgid_args), 7243 .sy_call = (sy_call_t *)rumpns_enosys, 7244 }, /* 181 = setgid */ 7245 { 7246 ns(struct sys_setegid_args), 7247 .sy_call = (sy_call_t *)rumpns_enosys, 7248 }, /* 182 = setegid */ 7249 { 7250 ns(struct sys_seteuid_args), 7251 .sy_call = (sy_call_t *)rumpns_enosys, 7252 }, /* 183 = seteuid */ 7253 { 7254 .sy_flags = SYCALL_NOSYS, 7255 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7256 }, /* 184 = lfs_bmapv */ 7257 { 7258 .sy_flags = SYCALL_NOSYS, 7259 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7260 }, /* 185 = lfs_markv */ 7261 { 7262 .sy_flags = SYCALL_NOSYS, 7263 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7264 }, /* 186 = lfs_segclean */ 7265 { 7266 .sy_flags = SYCALL_NOSYS, 7267 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7268 }, /* 187 = lfs_segwait */ 7269 { 7270 .sy_flags = SYCALL_NOSYS, 7271 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7272 }, /* 188 = stat12 */ 7273 { 7274 .sy_flags = SYCALL_NOSYS, 7275 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7276 }, /* 189 = fstat12 */ 7277 { 7278 .sy_flags = SYCALL_NOSYS, 7279 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7280 }, /* 190 = lstat12 */ 7281 { 7282 ns(struct sys_pathconf_args), 7283 .sy_call = (sy_call_t *)rumpns_enosys, 7284 }, /* 191 = pathconf */ 7285 { 7286 ns(struct sys_fpathconf_args), 7287 .sy_call = (sy_call_t *)rumpns_enosys, 7288 }, /* 192 = fpathconf */ 7289 { 7290 .sy_flags = SYCALL_NOSYS, 7291 .sy_call = (sy_call_t *)rumpns_enosys, 7292 }, /* 193 = filler */ 7293 { 7294 ns(struct sys_getrlimit_args), 7295 .sy_call = (sy_call_t *)rumpns_enosys, 7296 }, /* 194 = getrlimit */ 7297 { 7298 ns(struct sys_setrlimit_args), 7299 .sy_call = (sy_call_t *)rumpns_enosys, 7300 }, /* 195 = setrlimit */ 7301 { 7302 .sy_flags = SYCALL_NOSYS, 7303 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7304 }, /* 196 = getdirentries */ 7305 { 7306 .sy_call = (sy_call_t *)rumpns_enosys, 7307 }, /* 197 = mmap */ 7308 { 7309 .sy_call = (sy_call_t *)rumpns_enosys, 7310 }, /* 198 = __syscall */ 7311 { 7312 ns(struct sys_lseek_args), 7313 .sy_call = (sy_call_t *)rumpns_enosys, 7314 }, /* 199 = lseek */ 7315 { 7316 ns(struct sys_truncate_args), 7317 .sy_call = (sy_call_t *)rumpns_enosys, 7318 }, /* 200 = truncate */ 7319 { 7320 ns(struct sys_ftruncate_args), 7321 .sy_call = (sy_call_t *)rumpns_enosys, 7322 }, /* 201 = ftruncate */ 7323 { 7324 ns(struct sys___sysctl_args), 7325 .sy_call = (sy_call_t *)rumpns_enosys, 7326 }, /* 202 = __sysctl */ 7327 { 7328 .sy_call = (sy_call_t *)rumpns_enosys, 7329 }, /* 203 = mlock */ 7330 { 7331 .sy_call = (sy_call_t *)rumpns_enosys, 7332 }, /* 204 = munlock */ 7333 { 7334 .sy_call = (sy_call_t *)rumpns_enosys, 7335 }, /* 205 = undelete */ 7336 { 7337 ns(struct compat_50_sys_futimes_args), 7338 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7339 }, /* 206 = compat_50_futimes */ 7340 { 7341 ns(struct sys_getpgid_args), 7342 .sy_call = (sy_call_t *)rumpns_enosys, 7343 }, /* 207 = getpgid */ 7344 { 7345 ns(struct sys_reboot_args), 7346 .sy_call = (sy_call_t *)rumpns_enosys, 7347 }, /* 208 = reboot */ 7348 { 7349 ns(struct sys_poll_args), 7350 .sy_call = (sy_call_t *)rumpns_enosys, 7351 }, /* 209 = poll */ 7352 { 7353 .sy_flags = SYCALL_NOSYS, 7354 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7355 }, /* 210 = afssys */ 7356 { 7357 .sy_flags = SYCALL_NOSYS, 7358 .sy_call = (sy_call_t *)rumpns_enosys, 7359 }, /* 211 = filler */ 7360 { 7361 .sy_flags = SYCALL_NOSYS, 7362 .sy_call = (sy_call_t *)rumpns_enosys, 7363 }, /* 212 = filler */ 7364 { 7365 .sy_flags = SYCALL_NOSYS, 7366 .sy_call = (sy_call_t *)rumpns_enosys, 7367 }, /* 213 = filler */ 7368 { 7369 .sy_flags = SYCALL_NOSYS, 7370 .sy_call = (sy_call_t *)rumpns_enosys, 7371 }, /* 214 = filler */ 7372 { 7373 .sy_flags = SYCALL_NOSYS, 7374 .sy_call = (sy_call_t *)rumpns_enosys, 7375 }, /* 215 = filler */ 7376 { 7377 .sy_flags = SYCALL_NOSYS, 7378 .sy_call = (sy_call_t *)rumpns_enosys, 7379 }, /* 216 = filler */ 7380 { 7381 .sy_flags = SYCALL_NOSYS, 7382 .sy_call = (sy_call_t *)rumpns_enosys, 7383 }, /* 217 = filler */ 7384 { 7385 .sy_flags = SYCALL_NOSYS, 7386 .sy_call = (sy_call_t *)rumpns_enosys, 7387 }, /* 218 = filler */ 7388 { 7389 .sy_flags = SYCALL_NOSYS, 7390 .sy_call = (sy_call_t *)rumpns_enosys, 7391 }, /* 219 = filler */ 7392 { 7393 .sy_flags = SYCALL_NOSYS, 7394 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7395 }, /* 220 = __semctl */ 7396 { 7397 .sy_flags = SYCALL_NOSYS, 7398 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7399 }, /* 221 = semget */ 7400 { 7401 .sy_flags = SYCALL_NOSYS, 7402 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7403 }, /* 222 = semop */ 7404 { 7405 .sy_flags = SYCALL_NOSYS, 7406 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7407 }, /* 223 = semconfig */ 7408 { 7409 .sy_flags = SYCALL_NOSYS, 7410 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7411 }, /* 224 = msgctl */ 7412 { 7413 .sy_flags = SYCALL_NOSYS, 7414 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7415 }, /* 225 = msgget */ 7416 { 7417 .sy_flags = SYCALL_NOSYS, 7418 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7419 }, /* 226 = msgsnd */ 7420 { 7421 .sy_flags = SYCALL_NOSYS, 7422 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7423 }, /* 227 = msgrcv */ 7424 { 7425 .sy_flags = SYCALL_NOSYS, 7426 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7427 }, /* 228 = shmat */ 7428 { 7429 .sy_flags = SYCALL_NOSYS, 7430 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7431 }, /* 229 = shmctl */ 7432 { 7433 .sy_flags = SYCALL_NOSYS, 7434 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7435 }, /* 230 = shmdt */ 7436 { 7437 .sy_flags = SYCALL_NOSYS, 7438 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7439 }, /* 231 = shmget */ 7440 { 7441 .sy_flags = SYCALL_NOSYS, 7442 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7443 }, /* 232 = clock_gettime */ 7444 { 7445 .sy_flags = SYCALL_NOSYS, 7446 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7447 }, /* 233 = clock_settime */ 7448 { 7449 .sy_flags = SYCALL_NOSYS, 7450 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7451 }, /* 234 = clock_getres */ 7452 { 7453 ns(struct sys_timer_create_args), 7454 .sy_call = (sy_call_t *)rumpns_enosys, 7455 }, /* 235 = timer_create */ 7456 { 7457 ns(struct sys_timer_delete_args), 7458 .sy_call = (sy_call_t *)rumpns_enosys, 7459 }, /* 236 = timer_delete */ 7460 { 7461 .sy_flags = SYCALL_NOSYS, 7462 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7463 }, /* 237 = timer_settime */ 7464 { 7465 .sy_flags = SYCALL_NOSYS, 7466 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7467 }, /* 238 = timer_gettime */ 7468 { 7469 ns(struct sys_timer_getoverrun_args), 7470 .sy_call = (sy_call_t *)rumpns_enosys, 7471 }, /* 239 = timer_getoverrun */ 7472 { 7473 .sy_flags = SYCALL_NOSYS, 7474 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7475 }, /* 240 = nanosleep */ 7476 { 7477 ns(struct sys_fdatasync_args), 7478 .sy_call = (sy_call_t *)rumpns_enosys, 7479 }, /* 241 = fdatasync */ 7480 { 7481 .sy_call = (sy_call_t *)rumpns_enosys, 7482 }, /* 242 = mlockall */ 7483 { 7484 .sy_call = (sy_call_t *)rumpns_enosys, 7485 }, /* 243 = munlockall */ 7486 { 7487 .sy_flags = SYCALL_NOSYS, 7488 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7489 }, /* 244 = __sigtimedwait */ 7490 { 7491 .sy_call = (sy_call_t *)rumpns_enosys, 7492 }, /* 245 = sigqueueinfo */ 7493 { 7494 ns(struct sys_modctl_args), 7495 .sy_call = (sy_call_t *)rumpns_enosys, 7496 }, /* 246 = modctl */ 7497 { 7498 ns(struct sys__ksem_init_args), 7499 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7500 }, /* 247 = _ksem_init */ 7501 { 7502 ns(struct sys__ksem_open_args), 7503 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7504 }, /* 248 = _ksem_open */ 7505 { 7506 ns(struct sys__ksem_unlink_args), 7507 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7508 }, /* 249 = _ksem_unlink */ 7509 { 7510 ns(struct sys__ksem_close_args), 7511 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7512 }, /* 250 = _ksem_close */ 7513 { 7514 ns(struct sys__ksem_post_args), 7515 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7516 }, /* 251 = _ksem_post */ 7517 { 7518 ns(struct sys__ksem_wait_args), 7519 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7520 }, /* 252 = _ksem_wait */ 7521 { 7522 ns(struct sys__ksem_trywait_args), 7523 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7524 }, /* 253 = _ksem_trywait */ 7525 { 7526 ns(struct sys__ksem_getvalue_args), 7527 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7528 }, /* 254 = _ksem_getvalue */ 7529 { 7530 ns(struct sys__ksem_destroy_args), 7531 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7532 }, /* 255 = _ksem_destroy */ 7533 { 7534 ns(struct sys__ksem_timedwait_args), 7535 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7536 }, /* 256 = _ksem_timedwait */ 7537 { 7538 .sy_flags = SYCALL_NOSYS, 7539 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7540 }, /* 257 = mq_open */ 7541 { 7542 .sy_flags = SYCALL_NOSYS, 7543 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7544 }, /* 258 = mq_close */ 7545 { 7546 .sy_flags = SYCALL_NOSYS, 7547 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7548 }, /* 259 = mq_unlink */ 7549 { 7550 .sy_flags = SYCALL_NOSYS, 7551 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7552 }, /* 260 = mq_getattr */ 7553 { 7554 .sy_flags = SYCALL_NOSYS, 7555 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7556 }, /* 261 = mq_setattr */ 7557 { 7558 .sy_flags = SYCALL_NOSYS, 7559 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7560 }, /* 262 = mq_notify */ 7561 { 7562 .sy_flags = SYCALL_NOSYS, 7563 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7564 }, /* 263 = mq_send */ 7565 { 7566 .sy_flags = SYCALL_NOSYS, 7567 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7568 }, /* 264 = mq_receive */ 7569 { 7570 .sy_flags = SYCALL_NOSYS, 7571 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7572 }, /* 265 = mq_timedsend */ 7573 { 7574 .sy_flags = SYCALL_NOSYS, 7575 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7576 }, /* 266 = mq_timedreceive */ 7577 { 7578 .sy_flags = SYCALL_NOSYS, 7579 .sy_call = (sy_call_t *)rumpns_enosys, 7580 }, /* 267 = filler */ 7581 { 7582 .sy_flags = SYCALL_NOSYS, 7583 .sy_call = (sy_call_t *)rumpns_enosys, 7584 }, /* 268 = filler */ 7585 { 7586 .sy_flags = SYCALL_NOSYS, 7587 .sy_call = (sy_call_t *)rumpns_enosys, 7588 }, /* 269 = filler */ 7589 { 7590 ns(struct sys___posix_rename_args), 7591 .sy_call = (sy_call_t *)rumpns_enosys, 7592 }, /* 270 = __posix_rename */ 7593 { 7594 .sy_call = (sy_call_t *)rumpns_enosys, 7595 }, /* 271 = swapctl */ 7596 { 7597 .sy_flags = SYCALL_NOSYS, 7598 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7599 }, /* 272 = getdents */ 7600 { 7601 .sy_call = (sy_call_t *)rumpns_enosys, 7602 }, /* 273 = minherit */ 7603 { 7604 ns(struct sys_lchmod_args), 7605 .sy_call = (sy_call_t *)rumpns_enosys, 7606 }, /* 274 = lchmod */ 7607 { 7608 ns(struct sys_lchown_args), 7609 .sy_call = (sy_call_t *)rumpns_enosys, 7610 }, /* 275 = lchown */ 7611 { 7612 ns(struct compat_50_sys_lutimes_args), 7613 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7614 }, /* 276 = compat_50_lutimes */ 7615 { 7616 .sy_call = (sy_call_t *)rumpns_enosys, 7617 }, /* 277 = __msync13 */ 7618 { 7619 .sy_flags = SYCALL_NOSYS, 7620 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7621 }, /* 278 = __stat13 */ 7622 { 7623 .sy_flags = SYCALL_NOSYS, 7624 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7625 }, /* 279 = __fstat13 */ 7626 { 7627 .sy_flags = SYCALL_NOSYS, 7628 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7629 }, /* 280 = __lstat13 */ 7630 { 7631 .sy_call = (sy_call_t *)rumpns_enosys, 7632 }, /* 281 = __sigaltstack14 */ 7633 { 7634 .sy_call = (sy_call_t *)rumpns_enosys, 7635 }, /* 282 = __vfork14 */ 7636 { 7637 ns(struct sys___posix_chown_args), 7638 .sy_call = (sy_call_t *)rumpns_enosys, 7639 }, /* 283 = __posix_chown */ 7640 { 7641 ns(struct sys___posix_fchown_args), 7642 .sy_call = (sy_call_t *)rumpns_enosys, 7643 }, /* 284 = __posix_fchown */ 7644 { 7645 ns(struct sys___posix_lchown_args), 7646 .sy_call = (sy_call_t *)rumpns_enosys, 7647 }, /* 285 = __posix_lchown */ 7648 { 7649 ns(struct sys_getsid_args), 7650 .sy_call = (sy_call_t *)rumpns_enosys, 7651 }, /* 286 = getsid */ 7652 { 7653 .sy_call = (sy_call_t *)rumpns_enosys, 7654 }, /* 287 = __clone */ 7655 { 7656 ns(struct sys_fktrace_args), 7657 .sy_call = (sy_call_t *)rumpns_enosys, 7658 }, /* 288 = fktrace */ 7659 { 7660 ns(struct sys_preadv_args), 7661 .sy_call = (sy_call_t *)rumpns_enosys, 7662 }, /* 289 = preadv */ 7663 { 7664 ns(struct sys_pwritev_args), 7665 .sy_call = (sy_call_t *)rumpns_enosys, 7666 }, /* 290 = pwritev */ 7667 { 7668 .sy_flags = SYCALL_NOSYS, 7669 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7670 }, /* 291 = __sigaction14 */ 7671 { 7672 .sy_call = (sy_call_t *)rumpns_enosys, 7673 }, /* 292 = __sigpending14 */ 7674 { 7675 .sy_call = (sy_call_t *)rumpns_enosys, 7676 }, /* 293 = __sigprocmask14 */ 7677 { 7678 .sy_call = (sy_call_t *)rumpns_enosys, 7679 }, /* 294 = __sigsuspend14 */ 7680 { 7681 .sy_flags = SYCALL_NOSYS, 7682 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7683 }, /* 295 = __sigreturn14 */ 7684 { 7685 ns(struct sys___getcwd_args), 7686 .sy_call = (sy_call_t *)rumpns_enosys, 7687 }, /* 296 = __getcwd */ 7688 { 7689 ns(struct sys_fchroot_args), 7690 .sy_call = (sy_call_t *)rumpns_enosys, 7691 }, /* 297 = fchroot */ 7692 { 7693 .sy_flags = SYCALL_NOSYS, 7694 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7695 }, /* 298 = fhopen */ 7696 { 7697 .sy_flags = SYCALL_NOSYS, 7698 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7699 }, /* 299 = fhstat */ 7700 { 7701 .sy_flags = SYCALL_NOSYS, 7702 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7703 }, /* 300 = fhstatfs */ 7704 { 7705 .sy_flags = SYCALL_NOSYS, 7706 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7707 }, /* 301 = ____semctl13 */ 7708 { 7709 .sy_flags = SYCALL_NOSYS, 7710 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7711 }, /* 302 = __msgctl13 */ 7712 { 7713 .sy_flags = SYCALL_NOSYS, 7714 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7715 }, /* 303 = __shmctl13 */ 7716 { 7717 ns(struct sys_lchflags_args), 7718 .sy_call = (sy_call_t *)rumpns_enosys, 7719 }, /* 304 = lchflags */ 7720 { 7721 .sy_call = (sy_call_t *)rumpns_enosys, 7722 }, /* 305 = issetugid */ 7723 { 7724 ns(struct sys_utrace_args), 7725 .sy_call = (sy_call_t *)rumpns_enosys, 7726 }, /* 306 = utrace */ 7727 { 7728 .sy_call = (sy_call_t *)rumpns_enosys, 7729 }, /* 307 = getcontext */ 7730 { 7731 .sy_call = (sy_call_t *)rumpns_enosys, 7732 }, /* 308 = setcontext */ 7733 { 7734 .sy_call = (sy_call_t *)rumpns_enosys, 7735 }, /* 309 = _lwp_create */ 7736 { 7737 .sy_call = (sy_call_t *)rumpns_enosys, 7738 }, /* 310 = _lwp_exit */ 7739 { 7740 .sy_call = (sy_call_t *)rumpns_enosys, 7741 }, /* 311 = _lwp_self */ 7742 { 7743 .sy_call = (sy_call_t *)rumpns_enosys, 7744 }, /* 312 = _lwp_wait */ 7745 { 7746 .sy_call = (sy_call_t *)rumpns_enosys, 7747 }, /* 313 = _lwp_suspend */ 7748 { 7749 .sy_call = (sy_call_t *)rumpns_enosys, 7750 }, /* 314 = _lwp_continue */ 7751 { 7752 .sy_call = (sy_call_t *)rumpns_enosys, 7753 }, /* 315 = _lwp_wakeup */ 7754 { 7755 .sy_call = (sy_call_t *)rumpns_enosys, 7756 }, /* 316 = _lwp_getprivate */ 7757 { 7758 .sy_call = (sy_call_t *)rumpns_enosys, 7759 }, /* 317 = _lwp_setprivate */ 7760 { 7761 .sy_call = (sy_call_t *)rumpns_enosys, 7762 }, /* 318 = _lwp_kill */ 7763 { 7764 .sy_call = (sy_call_t *)rumpns_enosys, 7765 }, /* 319 = _lwp_detach */ 7766 { 7767 .sy_flags = SYCALL_NOSYS, 7768 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7769 }, /* 320 = _lwp_park */ 7770 { 7771 .sy_call = (sy_call_t *)rumpns_enosys, 7772 }, /* 321 = _lwp_unpark */ 7773 { 7774 .sy_call = (sy_call_t *)rumpns_enosys, 7775 }, /* 322 = _lwp_unpark_all */ 7776 { 7777 .sy_call = (sy_call_t *)rumpns_enosys, 7778 }, /* 323 = _lwp_setname */ 7779 { 7780 .sy_call = (sy_call_t *)rumpns_enosys, 7781 }, /* 324 = _lwp_getname */ 7782 { 7783 .sy_call = (sy_call_t *)rumpns_enosys, 7784 }, /* 325 = _lwp_ctl */ 7785 { 7786 .sy_flags = SYCALL_NOSYS, 7787 .sy_call = (sy_call_t *)rumpns_enosys, 7788 }, /* 326 = filler */ 7789 { 7790 .sy_flags = SYCALL_NOSYS, 7791 .sy_call = (sy_call_t *)rumpns_enosys, 7792 }, /* 327 = filler */ 7793 { 7794 .sy_flags = SYCALL_NOSYS, 7795 .sy_call = (sy_call_t *)rumpns_enosys, 7796 }, /* 328 = filler */ 7797 { 7798 .sy_flags = SYCALL_NOSYS, 7799 .sy_call = (sy_call_t *)rumpns_enosys, 7800 }, /* 329 = filler */ 7801 { 7802 .sy_call = (sy_call_t *)rumpns_enosys, 7803 }, /* 330 = sa_register */ 7804 { 7805 .sy_call = (sy_call_t *)rumpns_enosys, 7806 }, /* 331 = sa_stacks */ 7807 { 7808 .sy_call = (sy_call_t *)rumpns_enosys, 7809 }, /* 332 = sa_enable */ 7810 { 7811 .sy_call = (sy_call_t *)rumpns_enosys, 7812 }, /* 333 = sa_setconcurrency */ 7813 { 7814 .sy_call = (sy_call_t *)rumpns_enosys, 7815 }, /* 334 = sa_yield */ 7816 { 7817 .sy_call = (sy_call_t *)rumpns_enosys, 7818 }, /* 335 = sa_preempt */ 7819 { 7820 .sy_flags = SYCALL_NOSYS, 7821 .sy_call = (sy_call_t *)rumpns_enosys, 7822 }, /* 336 = filler */ 7823 { 7824 .sy_flags = SYCALL_NOSYS, 7825 .sy_call = (sy_call_t *)rumpns_enosys, 7826 }, /* 337 = filler */ 7827 { 7828 .sy_flags = SYCALL_NOSYS, 7829 .sy_call = (sy_call_t *)rumpns_enosys, 7830 }, /* 338 = filler */ 7831 { 7832 .sy_flags = SYCALL_NOSYS, 7833 .sy_call = (sy_call_t *)rumpns_enosys, 7834 }, /* 339 = filler */ 7835 { 7836 .sy_call = (sy_call_t *)rumpns_enosys, 7837 }, /* 340 = __sigaction_sigtramp */ 7838 { 7839 .sy_call = (sy_call_t *)rumpns_enosys, 7840 }, /* 341 = pmc_get_info */ 7841 { 7842 .sy_call = (sy_call_t *)rumpns_enosys, 7843 }, /* 342 = pmc_control */ 7844 { 7845 .sy_call = (sy_call_t *)rumpns_enosys, 7846 }, /* 343 = rasctl */ 7847 { 7848 .sy_call = (sy_call_t *)rumpns_enosys, 7849 }, /* 344 = kqueue */ 7850 { 7851 ns(struct compat_50_sys_kevent_args), 7852 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7853 }, /* 345 = compat_50_kevent */ 7854 { 7855 .sy_call = (sy_call_t *)rumpns_enosys, 7856 }, /* 346 = _sched_setparam */ 7857 { 7858 .sy_call = (sy_call_t *)rumpns_enosys, 7859 }, /* 347 = _sched_getparam */ 7860 { 7861 .sy_call = (sy_call_t *)rumpns_enosys, 7862 }, /* 348 = _sched_setaffinity */ 7863 { 7864 .sy_call = (sy_call_t *)rumpns_enosys, 7865 }, /* 349 = _sched_getaffinity */ 7866 { 7867 .sy_call = (sy_call_t *)rumpns_enosys, 7868 }, /* 350 = sched_yield */ 7869 { 7870 .sy_flags = SYCALL_NOSYS, 7871 .sy_call = (sy_call_t *)rumpns_enosys, 7872 }, /* 351 = filler */ 7873 { 7874 .sy_flags = SYCALL_NOSYS, 7875 .sy_call = (sy_call_t *)rumpns_enosys, 7876 }, /* 352 = filler */ 7877 { 7878 .sy_flags = SYCALL_NOSYS, 7879 .sy_call = (sy_call_t *)rumpns_enosys, 7880 }, /* 353 = filler */ 7881 { 7882 ns(struct sys_fsync_range_args), 7883 .sy_call = (sy_call_t *)rumpns_enosys, 7884 }, /* 354 = fsync_range */ 7885 { 7886 .sy_call = (sy_call_t *)rumpns_enosys, 7887 }, /* 355 = uuidgen */ 7888 { 7889 ns(struct sys_getvfsstat_args), 7890 .sy_call = (sy_call_t *)rumpns_enosys, 7891 }, /* 356 = getvfsstat */ 7892 { 7893 ns(struct sys_statvfs1_args), 7894 .sy_call = (sy_call_t *)rumpns_enosys, 7895 }, /* 357 = statvfs1 */ 7896 { 7897 ns(struct sys_fstatvfs1_args), 7898 .sy_call = (sy_call_t *)rumpns_enosys, 7899 }, /* 358 = fstatvfs1 */ 7900 { 7901 .sy_flags = SYCALL_NOSYS, 7902 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7903 }, /* 359 = fhstatvfs1 */ 7904 { 7905 ns(struct sys_extattrctl_args), 7906 .sy_call = (sy_call_t *)rumpns_enosys, 7907 }, /* 360 = extattrctl */ 7908 { 7909 ns(struct sys_extattr_set_file_args), 7910 .sy_call = (sy_call_t *)rumpns_enosys, 7911 }, /* 361 = extattr_set_file */ 7912 { 7913 ns(struct sys_extattr_get_file_args), 7914 .sy_call = (sy_call_t *)rumpns_enosys, 7915 }, /* 362 = extattr_get_file */ 7916 { 7917 ns(struct sys_extattr_delete_file_args), 7918 .sy_call = (sy_call_t *)rumpns_enosys, 7919 }, /* 363 = extattr_delete_file */ 7920 { 7921 ns(struct sys_extattr_set_fd_args), 7922 .sy_call = (sy_call_t *)rumpns_enosys, 7923 }, /* 364 = extattr_set_fd */ 7924 { 7925 ns(struct sys_extattr_get_fd_args), 7926 .sy_call = (sy_call_t *)rumpns_enosys, 7927 }, /* 365 = extattr_get_fd */ 7928 { 7929 ns(struct sys_extattr_delete_fd_args), 7930 .sy_call = (sy_call_t *)rumpns_enosys, 7931 }, /* 366 = extattr_delete_fd */ 7932 { 7933 ns(struct sys_extattr_set_link_args), 7934 .sy_call = (sy_call_t *)rumpns_enosys, 7935 }, /* 367 = extattr_set_link */ 7936 { 7937 ns(struct sys_extattr_get_link_args), 7938 .sy_call = (sy_call_t *)rumpns_enosys, 7939 }, /* 368 = extattr_get_link */ 7940 { 7941 ns(struct sys_extattr_delete_link_args), 7942 .sy_call = (sy_call_t *)rumpns_enosys, 7943 }, /* 369 = extattr_delete_link */ 7944 { 7945 ns(struct sys_extattr_list_fd_args), 7946 .sy_call = (sy_call_t *)rumpns_enosys, 7947 }, /* 370 = extattr_list_fd */ 7948 { 7949 ns(struct sys_extattr_list_file_args), 7950 .sy_call = (sy_call_t *)rumpns_enosys, 7951 }, /* 371 = extattr_list_file */ 7952 { 7953 ns(struct sys_extattr_list_link_args), 7954 .sy_call = (sy_call_t *)rumpns_enosys, 7955 }, /* 372 = extattr_list_link */ 7956 { 7957 ns(struct compat_50_sys_pselect_args), 7958 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7959 }, /* 373 = compat_50_pselect */ 7960 { 7961 ns(struct compat_50_sys_pollts_args), 7962 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 7963 }, /* 374 = compat_50_pollts */ 7964 { 7965 ns(struct sys_setxattr_args), 7966 .sy_call = (sy_call_t *)rumpns_enosys, 7967 }, /* 375 = setxattr */ 7968 { 7969 ns(struct sys_lsetxattr_args), 7970 .sy_call = (sy_call_t *)rumpns_enosys, 7971 }, /* 376 = lsetxattr */ 7972 { 7973 ns(struct sys_fsetxattr_args), 7974 .sy_call = (sy_call_t *)rumpns_enosys, 7975 }, /* 377 = fsetxattr */ 7976 { 7977 ns(struct sys_getxattr_args), 7978 .sy_call = (sy_call_t *)rumpns_enosys, 7979 }, /* 378 = getxattr */ 7980 { 7981 ns(struct sys_lgetxattr_args), 7982 .sy_call = (sy_call_t *)rumpns_enosys, 7983 }, /* 379 = lgetxattr */ 7984 { 7985 ns(struct sys_fgetxattr_args), 7986 .sy_call = (sy_call_t *)rumpns_enosys, 7987 }, /* 380 = fgetxattr */ 7988 { 7989 ns(struct sys_listxattr_args), 7990 .sy_call = (sy_call_t *)rumpns_enosys, 7991 }, /* 381 = listxattr */ 7992 { 7993 ns(struct sys_llistxattr_args), 7994 .sy_call = (sy_call_t *)rumpns_enosys, 7995 }, /* 382 = llistxattr */ 7996 { 7997 ns(struct sys_flistxattr_args), 7998 .sy_call = (sy_call_t *)rumpns_enosys, 7999 }, /* 383 = flistxattr */ 8000 { 8001 ns(struct sys_removexattr_args), 8002 .sy_call = (sy_call_t *)rumpns_enosys, 8003 }, /* 384 = removexattr */ 8004 { 8005 ns(struct sys_lremovexattr_args), 8006 .sy_call = (sy_call_t *)rumpns_enosys, 8007 }, /* 385 = lremovexattr */ 8008 { 8009 ns(struct sys_fremovexattr_args), 8010 .sy_call = (sy_call_t *)rumpns_enosys, 8011 }, /* 386 = fremovexattr */ 8012 { 8013 ns(struct compat_50_sys___stat30_args), 8014 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 8015 }, /* 387 = compat_50___stat30 */ 8016 { 8017 ns(struct compat_50_sys___fstat30_args), 8018 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 8019 }, /* 388 = compat_50___fstat30 */ 8020 { 8021 ns(struct compat_50_sys___lstat30_args), 8022 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 8023 }, /* 389 = compat_50___lstat30 */ 8024 { 8025 ns(struct sys___getdents30_args), 8026 .sy_call = (sy_call_t *)rumpns_enosys, 8027 }, /* 390 = __getdents30 */ 8028 { 8029 .sy_flags = SYCALL_NOSYS, 8030 .sy_call = (sy_call_t *)rumpns_enosys, 8031 }, /* 391 = filler */ 8032 { 8033 .sy_flags = SYCALL_NOSYS, 8034 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 8035 }, /* 392 = __fhstat30 */ 8036 { 8037 .sy_flags = SYCALL_NOSYS, 8038 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 8039 }, /* 393 = __ntp_gettime30 */ 8040 { 8041 ns(struct sys___socket30_args), 8042 .sy_call = (sy_call_t *)rumpns_enosys, 8043 }, /* 394 = __socket30 */ 8044 { 8045 ns(struct sys___getfh30_args), 8046 .sy_call = (sy_call_t *)rumpns_enosys, 8047 }, /* 395 = __getfh30 */ 8048 { 8049 ns(struct sys___fhopen40_args), 8050 .sy_call = (sy_call_t *)rumpns_enosys, 8051 }, /* 396 = __fhopen40 */ 8052 { 8053 ns(struct sys___fhstatvfs140_args), 8054 .sy_call = (sy_call_t *)rumpns_enosys, 8055 }, /* 397 = __fhstatvfs140 */ 8056 { 8057 ns(struct compat_50_sys___fhstat40_args), 8058 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 8059 }, /* 398 = compat_50___fhstat40 */ 8060 { 8061 ns(struct sys_aio_cancel_args), 8062 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 8063 }, /* 399 = aio_cancel */ 8064 { 8065 ns(struct sys_aio_error_args), 8066 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 8067 }, /* 400 = aio_error */ 8068 { 8069 ns(struct sys_aio_fsync_args), 8070 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 8071 }, /* 401 = aio_fsync */ 8072 { 8073 ns(struct sys_aio_read_args), 8074 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 8075 }, /* 402 = aio_read */ 8076 { 8077 ns(struct sys_aio_return_args), 8078 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 8079 }, /* 403 = aio_return */ 8080 { 8081 .sy_flags = SYCALL_NOSYS, 8082 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 8083 }, /* 404 = aio_suspend */ 8084 { 8085 ns(struct sys_aio_write_args), 8086 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 8087 }, /* 405 = aio_write */ 8088 { 8089 ns(struct sys_lio_listio_args), 8090 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 8091 }, /* 406 = lio_listio */ 8092 { 8093 .sy_flags = SYCALL_NOSYS, 8094 .sy_call = (sy_call_t *)rumpns_enosys, 8095 }, /* 407 = filler */ 8096 { 8097 .sy_flags = SYCALL_NOSYS, 8098 .sy_call = (sy_call_t *)rumpns_enosys, 8099 }, /* 408 = filler */ 8100 { 8101 .sy_flags = SYCALL_NOSYS, 8102 .sy_call = (sy_call_t *)rumpns_enosys, 8103 }, /* 409 = filler */ 8104 { 8105 ns(struct sys___mount50_args), 8106 .sy_call = (sy_call_t *)rumpns_enosys, 8107 }, /* 410 = __mount50 */ 8108 { 8109 .sy_call = (sy_call_t *)rumpns_enosys, 8110 }, /* 411 = mremap */ 8111 { 8112 .sy_call = (sy_call_t *)rumpns_enosys, 8113 }, /* 412 = pset_create */ 8114 { 8115 .sy_call = (sy_call_t *)rumpns_enosys, 8116 }, /* 413 = pset_destroy */ 8117 { 8118 .sy_call = (sy_call_t *)rumpns_enosys, 8119 }, /* 414 = pset_assign */ 8120 { 8121 .sy_call = (sy_call_t *)rumpns_enosys, 8122 }, /* 415 = _pset_bind */ 8123 { 8124 ns(struct sys___posix_fadvise50_args), 8125 .sy_call = (sy_call_t *)rumpns_enosys, 8126 }, /* 416 = __posix_fadvise50 */ 8127 { 8128 ns(struct sys___select50_args), 8129 .sy_call = (sy_call_t *)rumpns_enosys, 8130 }, /* 417 = __select50 */ 8131 { 8132 ns(struct sys___gettimeofday50_args), 8133 .sy_call = (sy_call_t *)rumpns_enosys, 8134 }, /* 418 = __gettimeofday50 */ 8135 { 8136 ns(struct sys___settimeofday50_args), 8137 .sy_call = (sy_call_t *)rumpns_enosys, 8138 }, /* 419 = __settimeofday50 */ 8139 { 8140 ns(struct sys___utimes50_args), 8141 .sy_call = (sy_call_t *)rumpns_enosys, 8142 }, /* 420 = __utimes50 */ 8143 { 8144 ns(struct sys___adjtime50_args), 8145 .sy_call = (sy_call_t *)rumpns_enosys, 8146 }, /* 421 = __adjtime50 */ 8147 { 8148 .sy_flags = SYCALL_NOSYS, 8149 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 8150 }, /* 422 = __lfs_segwait50 */ 8151 { 8152 ns(struct sys___futimes50_args), 8153 .sy_call = (sy_call_t *)rumpns_enosys, 8154 }, /* 423 = __futimes50 */ 8155 { 8156 ns(struct sys___lutimes50_args), 8157 .sy_call = (sy_call_t *)rumpns_enosys, 8158 }, /* 424 = __lutimes50 */ 8159 { 8160 ns(struct sys___setitimer50_args), 8161 .sy_call = (sy_call_t *)rumpns_enosys, 8162 }, /* 425 = __setitimer50 */ 8163 { 8164 ns(struct sys___getitimer50_args), 8165 .sy_call = (sy_call_t *)rumpns_enosys, 8166 }, /* 426 = __getitimer50 */ 8167 { 8168 ns(struct sys___clock_gettime50_args), 8169 .sy_call = (sy_call_t *)rumpns_enosys, 8170 }, /* 427 = __clock_gettime50 */ 8171 { 8172 ns(struct sys___clock_settime50_args), 8173 .sy_call = (sy_call_t *)rumpns_enosys, 8174 }, /* 428 = __clock_settime50 */ 8175 { 8176 ns(struct sys___clock_getres50_args), 8177 .sy_call = (sy_call_t *)rumpns_enosys, 8178 }, /* 429 = __clock_getres50 */ 8179 { 8180 ns(struct sys___nanosleep50_args), 8181 .sy_call = (sy_call_t *)rumpns_enosys, 8182 }, /* 430 = __nanosleep50 */ 8183 { 8184 .sy_call = (sy_call_t *)rumpns_enosys, 8185 }, /* 431 = ____sigtimedwait50 */ 8186 { 8187 .sy_flags = SYCALL_NOSYS, 8188 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 8189 }, /* 432 = __mq_timedsend50 */ 8190 { 8191 .sy_flags = SYCALL_NOSYS, 8192 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 8193 }, /* 433 = __mq_timedreceive50 */ 8194 { 8195 .sy_flags = SYCALL_NOSYS, 8196 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 8197 }, /* 434 = _lwp_park */ 8198 { 8199 ns(struct sys___kevent50_args), 8200 .sy_call = (sy_call_t *)rumpns_enosys, 8201 }, /* 435 = __kevent50 */ 8202 { 8203 ns(struct sys___pselect50_args), 8204 .sy_call = (sy_call_t *)rumpns_enosys, 8205 }, /* 436 = __pselect50 */ 8206 { 8207 ns(struct sys___pollts50_args), 8208 .sy_call = (sy_call_t *)rumpns_enosys, 8209 }, /* 437 = __pollts50 */ 8210 { 8211 ns(struct sys___aio_suspend50_args), 8212 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 8213 }, /* 438 = __aio_suspend50 */ 8214 { 8215 ns(struct sys___stat50_args), 8216 .sy_call = (sy_call_t *)rumpns_enosys, 8217 }, /* 439 = __stat50 */ 8218 { 8219 ns(struct sys___fstat50_args), 8220 .sy_call = (sy_call_t *)rumpns_enosys, 8221 }, /* 440 = __fstat50 */ 8222 { 8223 ns(struct sys___lstat50_args), 8224 .sy_call = (sy_call_t *)rumpns_enosys, 8225 }, /* 441 = __lstat50 */ 8226 { 8227 .sy_flags = SYCALL_NOSYS, 8228 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 8229 }, /* 442 = ____semctl50 */ 8230 { 8231 .sy_flags = SYCALL_NOSYS, 8232 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 8233 }, /* 443 = __shmctl50 */ 8234 { 8235 .sy_flags = SYCALL_NOSYS, 8236 .sy_call = (sy_call_t *)rumpns_sys_nomodule, 8237 }, /* 444 = __msgctl50 */ 8238 { 8239 .sy_call = (sy_call_t *)rumpns_enosys, 8240 }, /* 445 = __getrusage50 */ 8241 { 8242 ns(struct sys___timer_settime50_args), 8243 .sy_call = (sy_call_t *)rumpns_enosys, 8244 }, /* 446 = __timer_settime50 */ 8245 { 8246 ns(struct sys___timer_gettime50_args), 8247 .sy_call = (sy_call_t *)rumpns_enosys, 8248 }, /* 447 = __timer_gettime50 */ 8249 #if defined(NTP) || !defined(_KERNEL_OPT) 8250 { 8251 .sy_call = (sy_call_t *)rumpns_enosys, 8252 }, /* 448 = __ntp_gettime50 */ 8253 #else 8254 { 8255 .sy_flags = SYCALL_NOSYS, 8256 .sy_call = (sy_call_t *)rumpns_enosys, 8257 }, /* 448 = filler */ 8258 #endif 8259 { 8260 .sy_call = (sy_call_t *)rumpns_enosys, 8261 }, /* 449 = __wait450 */ 8262 { 8263 ns(struct sys___mknod50_args), 8264 .sy_call = (sy_call_t *)rumpns_enosys, 8265 }, /* 450 = __mknod50 */ 8266 { 8267 ns(struct sys___fhstat50_args), 8268 .sy_call = (sy_call_t *)rumpns_enosys, 8269 }, /* 451 = __fhstat50 */ 8270 { 8271 .sy_flags = SYCALL_NOSYS, 8272 .sy_call = (sy_call_t *)rumpns_enosys, 8273 }, /* 452 = filler */ 8274 { 8275 ns(struct sys_pipe2_args), 8276 .sy_call = (sy_call_t *)rumpns_enosys, 8277 }, /* 453 = pipe2 */ 8278 { 8279 ns(struct sys_dup3_args), 8280 .sy_call = (sy_call_t *)rumpns_enosys, 8281 }, /* 454 = dup3 */ 8282 { 8283 ns(struct sys_kqueue1_args), 8284 .sy_call = (sy_call_t *)rumpns_enosys, 8285 }, /* 455 = kqueue1 */ 8286 { 8287 ns(struct sys_paccept_args), 8288 .sy_call = (sy_call_t *)rumpns_enosys, 8289 }, /* 456 = paccept */ 8290 { 8291 ns(struct sys_linkat_args), 8292 .sy_call = (sy_call_t *)rumpns_enosys, 8293 }, /* 457 = linkat */ 8294 { 8295 ns(struct sys_renameat_args), 8296 .sy_call = (sy_call_t *)rumpns_enosys, 8297 }, /* 458 = renameat */ 8298 { 8299 ns(struct sys_mkfifoat_args), 8300 .sy_call = (sy_call_t *)rumpns_enosys, 8301 }, /* 459 = mkfifoat */ 8302 { 8303 ns(struct sys_mknodat_args), 8304 .sy_call = (sy_call_t *)rumpns_enosys, 8305 }, /* 460 = mknodat */ 8306 { 8307 ns(struct sys_mkdirat_args), 8308 .sy_call = (sy_call_t *)rumpns_enosys, 8309 }, /* 461 = mkdirat */ 8310 { 8311 ns(struct sys_faccessat_args), 8312 .sy_call = (sy_call_t *)rumpns_enosys, 8313 }, /* 462 = faccessat */ 8314 { 8315 ns(struct sys_fchmodat_args), 8316 .sy_call = (sy_call_t *)rumpns_enosys, 8317 }, /* 463 = fchmodat */ 8318 { 8319 ns(struct sys_fchownat_args), 8320 .sy_call = (sy_call_t *)rumpns_enosys, 8321 }, /* 464 = fchownat */ 8322 { 8323 .sy_call = (sy_call_t *)rumpns_enosys, 8324 }, /* 465 = fexecve */ 8325 { 8326 ns(struct sys_fstatat_args), 8327 .sy_call = (sy_call_t *)rumpns_enosys, 8328 }, /* 466 = fstatat */ 8329 { 8330 ns(struct sys_utimensat_args), 8331 .sy_call = (sy_call_t *)rumpns_enosys, 8332 }, /* 467 = utimensat */ 8333 { 8334 ns(struct sys_openat_args), 8335 .sy_call = (sy_call_t *)rumpns_enosys, 8336 }, /* 468 = openat */ 8337 { 8338 ns(struct sys_readlinkat_args), 8339 .sy_call = (sy_call_t *)rumpns_enosys, 8340 }, /* 469 = readlinkat */ 8341 { 8342 ns(struct sys_symlinkat_args), 8343 .sy_call = (sy_call_t *)rumpns_enosys, 8344 }, /* 470 = symlinkat */ 8345 { 8346 ns(struct sys_unlinkat_args), 8347 .sy_call = (sy_call_t *)rumpns_enosys, 8348 }, /* 471 = unlinkat */ 8349 { 8350 ns(struct sys_futimens_args), 8351 .sy_call = (sy_call_t *)rumpns_enosys, 8352 }, /* 472 = futimens */ 8353 { 8354 ns(struct sys___quotactl_args), 8355 .sy_call = (sy_call_t *)rumpns_enosys, 8356 }, /* 473 = __quotactl */ 8357 { 8358 .sy_call = (sy_call_t *)rumpns_enosys, 8359 }, /* 474 = posix_spawn */ 8360 { 8361 ns(struct sys_recvmmsg_args), 8362 .sy_call = (sy_call_t *)rumpns_enosys, 8363 }, /* 475 = recvmmsg */ 8364 { 8365 ns(struct sys_sendmmsg_args), 8366 .sy_call = (sy_call_t *)rumpns_enosys, 8367 }, /* 476 = sendmmsg */ 8368 { 8369 ns(struct sys_clock_nanosleep_args), 8370 .sy_call = (sy_call_t *)rumpns_enosys, 8371 }, /* 477 = clock_nanosleep */ 8372 { 8373 .sy_call = (sy_call_t *)rumpns_enosys, 8374 }, /* 478 = ___lwp_park60 */ 8375 { 8376 ns(struct sys_posix_fallocate_args), 8377 .sy_call = (sy_call_t *)rumpns_enosys, 8378 }, /* 479 = posix_fallocate */ 8379 { 8380 ns(struct sys_fdiscard_args), 8381 .sy_call = (sy_call_t *)rumpns_enosys, 8382 }, /* 480 = fdiscard */ 8383 { 8384 .sy_flags = SYCALL_NOSYS, 8385 .sy_call = (sy_call_t *)rumpns_enosys, 8386 }, /* 481 = filler */ 8387 { 8388 .sy_flags = SYCALL_NOSYS, 8389 .sy_call = (sy_call_t *)rumpns_enosys, 8390 }, /* 482 = filler */ 8391 { 8392 .sy_flags = SYCALL_NOSYS, 8393 .sy_call = (sy_call_t *)rumpns_enosys, 8394 }, /* 483 = filler */ 8395 { 8396 .sy_flags = SYCALL_NOSYS, 8397 .sy_call = (sy_call_t *)rumpns_enosys, 8398 }, /* 484 = filler */ 8399 { 8400 .sy_flags = SYCALL_NOSYS, 8401 .sy_call = (sy_call_t *)rumpns_enosys, 8402 }, /* 485 = filler */ 8403 { 8404 .sy_flags = SYCALL_NOSYS, 8405 .sy_call = (sy_call_t *)rumpns_enosys, 8406 }, /* 486 = filler */ 8407 { 8408 .sy_flags = SYCALL_NOSYS, 8409 .sy_call = (sy_call_t *)rumpns_enosys, 8410 }, /* 487 = filler */ 8411 { 8412 .sy_flags = SYCALL_NOSYS, 8413 .sy_call = (sy_call_t *)rumpns_enosys, 8414 }, /* 488 = filler */ 8415 { 8416 .sy_flags = SYCALL_NOSYS, 8417 .sy_call = (sy_call_t *)rumpns_enosys, 8418 }, /* 489 = filler */ 8419 { 8420 .sy_flags = SYCALL_NOSYS, 8421 .sy_call = (sy_call_t *)rumpns_enosys, 8422 }, /* 490 = filler */ 8423 { 8424 .sy_flags = SYCALL_NOSYS, 8425 .sy_call = (sy_call_t *)rumpns_enosys, 8426 }, /* 491 = filler */ 8427 { 8428 .sy_flags = SYCALL_NOSYS, 8429 .sy_call = (sy_call_t *)rumpns_enosys, 8430 }, /* 492 = filler */ 8431 { 8432 .sy_flags = SYCALL_NOSYS, 8433 .sy_call = (sy_call_t *)rumpns_enosys, 8434 }, /* 493 = filler */ 8435 { 8436 .sy_flags = SYCALL_NOSYS, 8437 .sy_call = (sy_call_t *)rumpns_enosys, 8438 }, /* 494 = filler */ 8439 { 8440 .sy_flags = SYCALL_NOSYS, 8441 .sy_call = (sy_call_t *)rumpns_enosys, 8442 }, /* 495 = filler */ 8443 { 8444 .sy_flags = SYCALL_NOSYS, 8445 .sy_call = (sy_call_t *)rumpns_enosys, 8446 }, /* 496 = filler */ 8447 { 8448 .sy_flags = SYCALL_NOSYS, 8449 .sy_call = (sy_call_t *)rumpns_enosys, 8450 }, /* 497 = filler */ 8451 { 8452 .sy_flags = SYCALL_NOSYS, 8453 .sy_call = (sy_call_t *)rumpns_enosys, 8454 }, /* 498 = filler */ 8455 { 8456 .sy_flags = SYCALL_NOSYS, 8457 .sy_call = (sy_call_t *)rumpns_enosys, 8458 }, /* 499 = filler */ 8459 { 8460 .sy_flags = SYCALL_NOSYS, 8461 .sy_call = (sy_call_t *)rumpns_enosys, 8462 }, /* 500 = filler */ 8463 { 8464 .sy_flags = SYCALL_NOSYS, 8465 .sy_call = (sy_call_t *)rumpns_enosys, 8466 }, /* 501 = filler */ 8467 { 8468 .sy_flags = SYCALL_NOSYS, 8469 .sy_call = (sy_call_t *)rumpns_enosys, 8470 }, /* 502 = filler */ 8471 { 8472 .sy_flags = SYCALL_NOSYS, 8473 .sy_call = (sy_call_t *)rumpns_enosys, 8474 }, /* 503 = filler */ 8475 { 8476 .sy_flags = SYCALL_NOSYS, 8477 .sy_call = (sy_call_t *)rumpns_enosys, 8478 }, /* 504 = filler */ 8479 { 8480 .sy_flags = SYCALL_NOSYS, 8481 .sy_call = (sy_call_t *)rumpns_enosys, 8482 }, /* 505 = filler */ 8483 { 8484 .sy_flags = SYCALL_NOSYS, 8485 .sy_call = (sy_call_t *)rumpns_enosys, 8486 }, /* 506 = filler */ 8487 { 8488 .sy_flags = SYCALL_NOSYS, 8489 .sy_call = (sy_call_t *)rumpns_enosys, 8490 }, /* 507 = filler */ 8491 { 8492 .sy_flags = SYCALL_NOSYS, 8493 .sy_call = (sy_call_t *)rumpns_enosys, 8494 }, /* 508 = filler */ 8495 { 8496 .sy_flags = SYCALL_NOSYS, 8497 .sy_call = (sy_call_t *)rumpns_enosys, 8498 }, /* 509 = filler */ 8499 { 8500 .sy_flags = SYCALL_NOSYS, 8501 .sy_call = (sy_call_t *)rumpns_enosys, 8502 }, /* 510 = filler */ 8503 { 8504 .sy_flags = SYCALL_NOSYS, 8505 .sy_call = (sy_call_t *)rumpns_enosys, 8506 }, /* 511 = filler */ 8507 }; 8508 CTASSERT(__arraycount(rump_sysent) == SYS_NSYSENT); 8509 __strong_alias(rumpns_sysent,rump_sysent); 8510 #endif /* RUMP_CLIENT */ 8511
Indexes created Wed Oct 01 15:09:59 GMT 2025