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