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