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