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