sys/rump/librump/rumpkern/rump_syscalls.c

   1 /* $NetBSD$ */
   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.231 2009/11/26 17:20:20 pooka Exp
   8  */
   9
  10 #include <sys/cdefs.h>
  11 __KERNEL_RCSID(0, "$NetBSD$");
  12
  13 #include <sys/types.h>
  14 #include <sys/param.h>
  15 #include <sys/proc.h>
  16 #include <sys/syscall.h>
  17 #include <sys/syscallargs.h>
  18 #include <rump/rumpuser.h>
  19 #include "rump_private.h"
  20
  21 #if     BYTE_ORDER == BIG_ENDIAN
  22 #define SPARG(p,k)      ((p)->k.be.datum)
  23 #else /* LITTLE_ENDIAN, I hope dearly */
  24 #define SPARG(p,k)      ((p)->k.le.datum)
  25 #endif
  26
  27 int rump_enosys(void);
  28 int
  29 rump_enosys()
  30 {
  31
  32         return ENOSYS;
  33 }
  34
  35 ssize_t rump_sys_read(int, void *, size_t);
  36 ssize_t
  37 rump_sys_read(int fd, void * buf, size_t nbyte)
  38 {
  39         register_t rval[2] = {0, 0};
  40         int error = 0;
  41         struct sys_read_args callarg;
  42
  43         SPARG(&callarg, fd) = fd;
  44         SPARG(&callarg, buf) = buf;
  45         SPARG(&callarg, nbyte) = nbyte;
  46
  47         error = rump_sysproxy(SYS_read, rump_sysproxy_arg,
  48             (uint8_t *)&callarg, sizeof(callarg), rval);
  49         if (error) {
  50                 rval[0] = -1;
  51                 rumpuser_seterrno(error);
  52         }
  53         return rval[0];
  54 }
  55 __weak_alias(sys_read,rump_enosys);
  56
  57 ssize_t rump_sys_write(int, const void *, size_t);
  58 ssize_t
  59 rump_sys_write(int fd, const void * buf, size_t nbyte)
  60 {
  61         register_t rval[2] = {0, 0};
  62         int error = 0;
  63         struct sys_write_args callarg;
  64
  65         SPARG(&callarg, fd) = fd;
  66         SPARG(&callarg, buf) = buf;
  67         SPARG(&callarg, nbyte) = nbyte;
  68
  69         error = rump_sysproxy(SYS_write, rump_sysproxy_arg,
  70             (uint8_t *)&callarg, sizeof(callarg), rval);
  71         if (error) {
  72                 rval[0] = -1;
  73                 rumpuser_seterrno(error);
  74         }
  75         return rval[0];
  76 }
  77 __weak_alias(sys_write,rump_enosys);
  78
  79 int rump_sys_open(const char *, int, mode_t);
  80 int
  81 rump_sys_open(const char * path, int flags, mode_t mode)
  82 {
  83         register_t rval[2] = {0, 0};
  84         int error = 0;
  85         struct sys_open_args callarg;
  86
  87         SPARG(&callarg, path) = path;
  88         SPARG(&callarg, flags) = flags;
  89         SPARG(&callarg, mode) = mode;
  90
  91         error = rump_sysproxy(SYS_open, rump_sysproxy_arg,
  92             (uint8_t *)&callarg, sizeof(callarg), rval);
  93         if (error) {
  94                 rval[0] = -1;
  95                 rumpuser_seterrno(error);
  96         }
  97         return rval[0];
  98 }
  99 __weak_alias(sys_open,rump_enosys);
 100
 101 int rump_sys_close(int);
 102 int
 103 rump_sys_close(int fd)
 104 {
 105         register_t rval[2] = {0, 0};
 106         int error = 0;
 107         struct sys_close_args callarg;
 108
 109         SPARG(&callarg, fd) = fd;
 110
 111         error = rump_sysproxy(SYS_close, rump_sysproxy_arg,
 112             (uint8_t *)&callarg, sizeof(callarg), rval);
 113         if (error) {
 114                 rval[0] = -1;
 115                 rumpuser_seterrno(error);
 116         }
 117         return rval[0];
 118 }
 119 __weak_alias(sys_close,rump_enosys);
 120
 121 int rump_sys_link(const char *, const char *);
 122 int
 123 rump_sys_link(const char * path, const char * link)
 124 {
 125         register_t rval[2] = {0, 0};
 126         int error = 0;
 127         struct sys_link_args callarg;
 128
 129         SPARG(&callarg, path) = path;
 130         SPARG(&callarg, link) = link;
 131
 132         error = rump_sysproxy(SYS_link, rump_sysproxy_arg,
 133             (uint8_t *)&callarg, sizeof(callarg), rval);
 134         if (error) {
 135                 rval[0] = -1;
 136                 rumpuser_seterrno(error);
 137         }
 138         return rval[0];
 139 }
 140 __weak_alias(sys_link,rump_enosys);
 141
 142 int rump_sys_unlink(const char *);
 143 int
 144 rump_sys_unlink(const char * path)
 145 {
 146         register_t rval[2] = {0, 0};
 147         int error = 0;
 148         struct sys_unlink_args callarg;
 149
 150         SPARG(&callarg, path) = path;
 151
 152         error = rump_sysproxy(SYS_unlink, rump_sysproxy_arg,
 153             (uint8_t *)&callarg, sizeof(callarg), rval);
 154         if (error) {
 155                 rval[0] = -1;
 156                 rumpuser_seterrno(error);
 157         }
 158         return rval[0];
 159 }
 160 __weak_alias(sys_unlink,rump_enosys);
 161
 162 int rump_sys_chdir(const char *);
 163 int
 164 rump_sys_chdir(const char * path)
 165 {
 166         register_t rval[2] = {0, 0};
 167         int error = 0;
 168         struct sys_chdir_args callarg;
 169
 170         SPARG(&callarg, path) = path;
 171
 172         error = rump_sysproxy(SYS_chdir, rump_sysproxy_arg,
 173             (uint8_t *)&callarg, sizeof(callarg), rval);
 174         if (error) {
 175                 rval[0] = -1;
 176                 rumpuser_seterrno(error);
 177         }
 178         return rval[0];
 179 }
 180 __weak_alias(sys_chdir,rump_enosys);
 181
 182 int rump_sys_fchdir(int);
 183 int
 184 rump_sys_fchdir(int fd)
 185 {
 186         register_t rval[2] = {0, 0};
 187         int error = 0;
 188         struct sys_fchdir_args callarg;
 189
 190         SPARG(&callarg, fd) = fd;
 191
 192         error = rump_sysproxy(SYS_fchdir, rump_sysproxy_arg,
 193             (uint8_t *)&callarg, sizeof(callarg), rval);
 194         if (error) {
 195                 rval[0] = -1;
 196                 rumpuser_seterrno(error);
 197         }
 198         return rval[0];
 199 }
 200 __weak_alias(sys_fchdir,rump_enosys);
 201
 202 int rump_sys_chmod(const char *, mode_t);
 203 int
 204 rump_sys_chmod(const char * path, mode_t mode)
 205 {
 206         register_t rval[2] = {0, 0};
 207         int error = 0;
 208         struct sys_chmod_args callarg;
 209
 210         SPARG(&callarg, path) = path;
 211         SPARG(&callarg, mode) = mode;
 212
 213         error = rump_sysproxy(SYS_chmod, rump_sysproxy_arg,
 214             (uint8_t *)&callarg, sizeof(callarg), rval);
 215         if (error) {
 216                 rval[0] = -1;
 217                 rumpuser_seterrno(error);
 218         }
 219         return rval[0];
 220 }
 221 __weak_alias(sys_chmod,rump_enosys);
 222
 223 int rump_sys_chown(const char *, uid_t, gid_t);
 224 int
 225 rump_sys_chown(const char * path, uid_t uid, gid_t gid)
 226 {
 227         register_t rval[2] = {0, 0};
 228         int error = 0;
 229         struct sys_chown_args callarg;
 230
 231         SPARG(&callarg, path) = path;
 232         SPARG(&callarg, uid) = uid;
 233         SPARG(&callarg, gid) = gid;
 234
 235         error = rump_sysproxy(SYS_chown, rump_sysproxy_arg,
 236             (uint8_t *)&callarg, sizeof(callarg), rval);
 237         if (error) {
 238                 rval[0] = -1;
 239                 rumpuser_seterrno(error);
 240         }
 241         return rval[0];
 242 }
 243 __weak_alias(sys_chown,rump_enosys);
 244
 245 int rump_sys_unmount(const char *, int);
 246 int
 247 rump_sys_unmount(const char * path, int flags)
 248 {
 249         register_t rval[2] = {0, 0};
 250         int error = 0;
 251         struct sys_unmount_args callarg;
 252
 253         SPARG(&callarg, path) = path;
 254         SPARG(&callarg, flags) = flags;
 255
 256         error = rump_sysproxy(SYS_unmount, rump_sysproxy_arg,
 257             (uint8_t *)&callarg, sizeof(callarg), rval);
 258         if (error) {
 259                 rval[0] = -1;
 260                 rumpuser_seterrno(error);
 261         }
 262         return rval[0];
 263 }
 264 __weak_alias(sys_unmount,rump_enosys);
 265
 266 ssize_t rump_sys_recvmsg(int, struct msghdr *, int);
 267 ssize_t
 268 rump_sys_recvmsg(int s, struct msghdr * msg, int flags)
 269 {
 270         register_t rval[2] = {0, 0};
 271         int error = 0;
 272         struct sys_recvmsg_args callarg;
 273
 274         SPARG(&callarg, s) = s;
 275         SPARG(&callarg, msg) = msg;
 276         SPARG(&callarg, flags) = flags;
 277
 278         error = rump_sysproxy(SYS_recvmsg, rump_sysproxy_arg,
 279             (uint8_t *)&callarg, sizeof(callarg), rval);
 280         if (error) {
 281                 rval[0] = -1;
 282                 rumpuser_seterrno(error);
 283         }
 284         return rval[0];
 285 }
 286 __weak_alias(sys_recvmsg,rump_enosys);
 287
 288 ssize_t rump_sys_sendmsg(int, const struct msghdr *, int);
 289 ssize_t
 290 rump_sys_sendmsg(int s, const struct msghdr * msg, int flags)
 291 {
 292         register_t rval[2] = {0, 0};
 293         int error = 0;
 294         struct sys_sendmsg_args callarg;
 295
 296         SPARG(&callarg, s) = s;
 297         SPARG(&callarg, msg) = msg;
 298         SPARG(&callarg, flags) = flags;
 299
 300         error = rump_sysproxy(SYS_sendmsg, rump_sysproxy_arg,
 301             (uint8_t *)&callarg, sizeof(callarg), rval);
 302         if (error) {
 303                 rval[0] = -1;
 304                 rumpuser_seterrno(error);
 305         }
 306         return rval[0];
 307 }
 308 __weak_alias(sys_sendmsg,rump_enosys);
 309
 310 ssize_t rump_sys_recvfrom(int, void *, size_t, int, struct sockaddr *, unsigned int *);
 311 ssize_t
 312 rump_sys_recvfrom(int s, void * buf, size_t len, int flags, struct sockaddr * from, unsigned int * fromlenaddr)
 313 {
 314         register_t rval[2] = {0, 0};
 315         int error = 0;
 316         struct sys_recvfrom_args callarg;
 317
 318         SPARG(&callarg, s) = s;
 319         SPARG(&callarg, buf) = buf;
 320         SPARG(&callarg, len) = len;
 321         SPARG(&callarg, flags) = flags;
 322         SPARG(&callarg, from) = from;
 323         SPARG(&callarg, fromlenaddr) = fromlenaddr;
 324
 325         error = rump_sysproxy(SYS_recvfrom, rump_sysproxy_arg,
 326             (uint8_t *)&callarg, sizeof(callarg), rval);
 327         if (error) {
 328                 rval[0] = -1;
 329                 rumpuser_seterrno(error);
 330         }
 331         return rval[0];
 332 }
 333 __weak_alias(sys_recvfrom,rump_enosys);
 334
 335 int rump_sys_accept(int, struct sockaddr *, unsigned int *);
 336 int
 337 rump_sys_accept(int s, struct sockaddr * name, unsigned int * anamelen)
 338 {
 339         register_t rval[2] = {0, 0};
 340         int error = 0;
 341         struct sys_accept_args callarg;
 342
 343         SPARG(&callarg, s) = s;
 344         SPARG(&callarg, name) = name;
 345         SPARG(&callarg, anamelen) = anamelen;
 346
 347         error = rump_sysproxy(SYS_accept, rump_sysproxy_arg,
 348             (uint8_t *)&callarg, sizeof(callarg), rval);
 349         if (error) {
 350                 rval[0] = -1;
 351                 rumpuser_seterrno(error);
 352         }
 353         return rval[0];
 354 }
 355 __weak_alias(sys_accept,rump_enosys);
 356
 357 int rump_sys_getpeername(int, struct sockaddr *, unsigned int *);
 358 int
 359 rump_sys_getpeername(int fdes, struct sockaddr * asa, unsigned int * alen)
 360 {
 361         register_t rval[2] = {0, 0};
 362         int error = 0;
 363         struct sys_getpeername_args callarg;
 364
 365         SPARG(&callarg, fdes) = fdes;
 366         SPARG(&callarg, asa) = asa;
 367         SPARG(&callarg, alen) = alen;
 368
 369         error = rump_sysproxy(SYS_getpeername, rump_sysproxy_arg,
 370             (uint8_t *)&callarg, sizeof(callarg), rval);
 371         if (error) {
 372                 rval[0] = -1;
 373                 rumpuser_seterrno(error);
 374         }
 375         return rval[0];
 376 }
 377 __weak_alias(sys_getpeername,rump_enosys);
 378
 379 int rump_sys_getsockname(int, struct sockaddr *, unsigned int *);
 380 int
 381 rump_sys_getsockname(int fdes, struct sockaddr * asa, unsigned int * alen)
 382 {
 383         register_t rval[2] = {0, 0};
 384         int error = 0;
 385         struct sys_getsockname_args callarg;
 386
 387         SPARG(&callarg, fdes) = fdes;
 388         SPARG(&callarg, asa) = asa;
 389         SPARG(&callarg, alen) = alen;
 390
 391         error = rump_sysproxy(SYS_getsockname, rump_sysproxy_arg,
 392             (uint8_t *)&callarg, sizeof(callarg), rval);
 393         if (error) {
 394                 rval[0] = -1;
 395                 rumpuser_seterrno(error);
 396         }
 397         return rval[0];
 398 }
 399 __weak_alias(sys_getsockname,rump_enosys);
 400
 401 int rump_sys_access(const char *, int);
 402 int
 403 rump_sys_access(const char * path, int flags)
 404 {
 405         register_t rval[2] = {0, 0};
 406         int error = 0;
 407         struct sys_access_args callarg;
 408
 409         SPARG(&callarg, path) = path;
 410         SPARG(&callarg, flags) = flags;
 411
 412         error = rump_sysproxy(SYS_access, rump_sysproxy_arg,
 413             (uint8_t *)&callarg, sizeof(callarg), rval);
 414         if (error) {
 415                 rval[0] = -1;
 416                 rumpuser_seterrno(error);
 417         }
 418         return rval[0];
 419 }
 420 __weak_alias(sys_access,rump_enosys);
 421
 422 int rump_sys_chflags(const char *, u_long);
 423 int
 424 rump_sys_chflags(const char * path, u_long flags)
 425 {
 426         register_t rval[2] = {0, 0};
 427         int error = 0;
 428         struct sys_chflags_args callarg;
 429
 430         SPARG(&callarg, path) = path;
 431         SPARG(&callarg, flags) = flags;
 432
 433         error = rump_sysproxy(SYS_chflags, rump_sysproxy_arg,
 434             (uint8_t *)&callarg, sizeof(callarg), rval);
 435         if (error) {
 436                 rval[0] = -1;
 437                 rumpuser_seterrno(error);
 438         }
 439         return rval[0];
 440 }
 441 __weak_alias(sys_chflags,rump_enosys);
 442
 443 int rump_sys_fchflags(int, u_long);
 444 int
 445 rump_sys_fchflags(int fd, u_long flags)
 446 {
 447         register_t rval[2] = {0, 0};
 448         int error = 0;
 449         struct sys_fchflags_args callarg;
 450
 451         SPARG(&callarg, fd) = fd;
 452         SPARG(&callarg, flags) = flags;
 453
 454         error = rump_sysproxy(SYS_fchflags, rump_sysproxy_arg,
 455             (uint8_t *)&callarg, sizeof(callarg), rval);
 456         if (error) {
 457                 rval[0] = -1;
 458                 rumpuser_seterrno(error);
 459         }
 460         return rval[0];
 461 }
 462 __weak_alias(sys_fchflags,rump_enosys);
 463
 464 void rump_sys_sync(void);
 465 void
 466 rump_sys_sync(void )
 467 {
 468         register_t rval[2] = {0, 0};
 469         int error = 0;
 470
 471         error = rump_sysproxy(SYS_sync, rump_sysproxy_arg,
 472             (uint8_t *)NULL, 0, rval);
 473         if (error) {
 474                 rval[0] = -1;
 475         }
 476 }
 477 __weak_alias(sys_sync,rump_enosys);
 478
 479 int rump_sys_dup(int);
 480 int
 481 rump_sys_dup(int fd)
 482 {
 483         register_t rval[2] = {0, 0};
 484         int error = 0;
 485         struct sys_dup_args callarg;
 486
 487         SPARG(&callarg, fd) = fd;
 488
 489         error = rump_sysproxy(SYS_dup, rump_sysproxy_arg,
 490             (uint8_t *)&callarg, sizeof(callarg), rval);
 491         if (error) {
 492                 rval[0] = -1;
 493                 rumpuser_seterrno(error);
 494         }
 495         return rval[0];
 496 }
 497 __weak_alias(sys_dup,rump_enosys);
 498
 499 int rump_sys_ioctl(int, u_long, void *);
 500 int
 501 rump_sys_ioctl(int fd, u_long com, void * data)
 502 {
 503         register_t rval[2] = {0, 0};
 504         int error = 0;
 505         struct sys_ioctl_args callarg;
 506
 507         SPARG(&callarg, fd) = fd;
 508         SPARG(&callarg, com) = com;
 509         SPARG(&callarg, data) = data;
 510
 511         error = rump_sysproxy(SYS_ioctl, rump_sysproxy_arg,
 512             (uint8_t *)&callarg, sizeof(callarg), rval);
 513         if (error) {
 514                 rval[0] = -1;
 515                 rumpuser_seterrno(error);
 516         }
 517         return rval[0];
 518 }
 519 __weak_alias(sys_ioctl,rump_enosys);
 520
 521 int rump_sys_revoke(const char *);
 522 int
 523 rump_sys_revoke(const char * path)
 524 {
 525         register_t rval[2] = {0, 0};
 526         int error = 0;
 527         struct sys_revoke_args callarg;
 528
 529         SPARG(&callarg, path) = path;
 530
 531         error = rump_sysproxy(SYS_revoke, rump_sysproxy_arg,
 532             (uint8_t *)&callarg, sizeof(callarg), rval);
 533         if (error) {
 534                 rval[0] = -1;
 535                 rumpuser_seterrno(error);
 536         }
 537         return rval[0];
 538 }
 539 __weak_alias(sys_revoke,rump_enosys);
 540
 541 int rump_sys_symlink(const char *, const char *);
 542 int
 543 rump_sys_symlink(const char * path, const char * link)
 544 {
 545         register_t rval[2] = {0, 0};
 546         int error = 0;
 547         struct sys_symlink_args callarg;
 548
 549         SPARG(&callarg, path) = path;
 550         SPARG(&callarg, link) = link;
 551
 552         error = rump_sysproxy(SYS_symlink, rump_sysproxy_arg,
 553             (uint8_t *)&callarg, sizeof(callarg), rval);
 554         if (error) {
 555                 rval[0] = -1;
 556                 rumpuser_seterrno(error);
 557         }
 558         return rval[0];
 559 }
 560 __weak_alias(sys_symlink,rump_enosys);
 561
 562 ssize_t rump_sys_readlink(const char *, char *, size_t);
 563 ssize_t
 564 rump_sys_readlink(const char * path, char * buf, size_t count)
 565 {
 566         register_t rval[2] = {0, 0};
 567         int error = 0;
 568         struct sys_readlink_args callarg;
 569
 570         SPARG(&callarg, path) = path;
 571         SPARG(&callarg, buf) = buf;
 572         SPARG(&callarg, count) = count;
 573
 574         error = rump_sysproxy(SYS_readlink, rump_sysproxy_arg,
 575             (uint8_t *)&callarg, sizeof(callarg), rval);
 576         if (error) {
 577                 rval[0] = -1;
 578                 rumpuser_seterrno(error);
 579         }
 580         return rval[0];
 581 }
 582 __weak_alias(sys_readlink,rump_enosys);
 583
 584 int rump_sys_chroot(const char *);
 585 int
 586 rump_sys_chroot(const char * path)
 587 {
 588         register_t rval[2] = {0, 0};
 589         int error = 0;
 590         struct sys_chroot_args callarg;
 591
 592         SPARG(&callarg, path) = path;
 593
 594         error = rump_sysproxy(SYS_chroot, rump_sysproxy_arg,
 595             (uint8_t *)&callarg, sizeof(callarg), rval);
 596         if (error) {
 597                 rval[0] = -1;
 598                 rumpuser_seterrno(error);
 599         }
 600         return rval[0];
 601 }
 602 __weak_alias(sys_chroot,rump_enosys);
 603
 604 int rump_sys_dup2(int, int);
 605 int
 606 rump_sys_dup2(int from, int to)
 607 {
 608         register_t rval[2] = {0, 0};
 609         int error = 0;
 610         struct sys_dup2_args callarg;
 611
 612         SPARG(&callarg, from) = from;
 613         SPARG(&callarg, to) = to;
 614
 615         error = rump_sysproxy(SYS_dup2, rump_sysproxy_arg,
 616             (uint8_t *)&callarg, sizeof(callarg), rval);
 617         if (error) {
 618                 rval[0] = -1;
 619                 rumpuser_seterrno(error);
 620         }
 621         return rval[0];
 622 }
 623 __weak_alias(sys_dup2,rump_enosys);
 624
 625 int rump_sys_fcntl(int, int, void *);
 626 int
 627 rump_sys_fcntl(int fd, int cmd, void * arg)
 628 {
 629         register_t rval[2] = {0, 0};
 630         int error = 0;
 631         struct sys_fcntl_args callarg;
 632
 633         SPARG(&callarg, fd) = fd;
 634         SPARG(&callarg, cmd) = cmd;
 635         SPARG(&callarg, arg) = arg;
 636
 637         error = rump_sysproxy(SYS_fcntl, rump_sysproxy_arg,
 638             (uint8_t *)&callarg, sizeof(callarg), rval);
 639         if (error) {
 640                 rval[0] = -1;
 641                 rumpuser_seterrno(error);
 642         }
 643         return rval[0];
 644 }
 645 __weak_alias(sys_fcntl,rump_enosys);
 646
 647 int rump_sys_fsync(int);
 648 int
 649 rump_sys_fsync(int fd)
 650 {
 651         register_t rval[2] = {0, 0};
 652         int error = 0;
 653         struct sys_fsync_args callarg;
 654
 655         SPARG(&callarg, fd) = fd;
 656
 657         error = rump_sysproxy(SYS_fsync, rump_sysproxy_arg,
 658             (uint8_t *)&callarg, sizeof(callarg), rval);
 659         if (error) {
 660                 rval[0] = -1;
 661                 rumpuser_seterrno(error);
 662         }
 663         return rval[0];
 664 }
 665 __weak_alias(sys_fsync,rump_enosys);
 666
 667 int rump_sys_connect(int, const struct sockaddr *, unsigned int);
 668 int
 669 rump_sys_connect(int s, const struct sockaddr * name, unsigned int namelen)
 670 {
 671         register_t rval[2] = {0, 0};
 672         int error = 0;
 673         struct sys_connect_args callarg;
 674
 675         SPARG(&callarg, s) = s;
 676         SPARG(&callarg, name) = name;
 677         SPARG(&callarg, namelen) = namelen;
 678
 679         error = rump_sysproxy(SYS_connect, rump_sysproxy_arg,
 680             (uint8_t *)&callarg, sizeof(callarg), rval);
 681         if (error) {
 682                 rval[0] = -1;
 683                 rumpuser_seterrno(error);
 684         }
 685         return rval[0];
 686 }
 687 __weak_alias(sys_connect,rump_enosys);
 688
 689 int rump_sys_bind(int, const struct sockaddr *, unsigned int);
 690 int
 691 rump_sys_bind(int s, const struct sockaddr * name, unsigned int namelen)
 692 {
 693         register_t rval[2] = {0, 0};
 694         int error = 0;
 695         struct sys_bind_args callarg;
 696
 697         SPARG(&callarg, s) = s;
 698         SPARG(&callarg, name) = name;
 699         SPARG(&callarg, namelen) = namelen;
 700
 701         error = rump_sysproxy(SYS_bind, rump_sysproxy_arg,
 702             (uint8_t *)&callarg, sizeof(callarg), rval);
 703         if (error) {
 704                 rval[0] = -1;
 705                 rumpuser_seterrno(error);
 706         }
 707         return rval[0];
 708 }
 709 __weak_alias(sys_bind,rump_enosys);
 710
 711 int rump_sys_setsockopt(int, int, int, const void *, unsigned int);
 712 int
 713 rump_sys_setsockopt(int s, int level, int name, const void * val, unsigned int valsize)
 714 {
 715         register_t rval[2] = {0, 0};
 716         int error = 0;
 717         struct sys_setsockopt_args callarg;
 718
 719         SPARG(&callarg, s) = s;
 720         SPARG(&callarg, level) = level;
 721         SPARG(&callarg, name) = name;
 722         SPARG(&callarg, val) = val;
 723         SPARG(&callarg, valsize) = valsize;
 724
 725         error = rump_sysproxy(SYS_setsockopt, rump_sysproxy_arg,
 726             (uint8_t *)&callarg, sizeof(callarg), rval);
 727         if (error) {
 728                 rval[0] = -1;
 729                 rumpuser_seterrno(error);
 730         }
 731         return rval[0];
 732 }
 733 __weak_alias(sys_setsockopt,rump_enosys);
 734
 735 int rump_sys_listen(int, int);
 736 int
 737 rump_sys_listen(int s, int backlog)
 738 {
 739         register_t rval[2] = {0, 0};
 740         int error = 0;
 741         struct sys_listen_args callarg;
 742
 743         SPARG(&callarg, s) = s;
 744         SPARG(&callarg, backlog) = backlog;
 745
 746         error = rump_sysproxy(SYS_listen, rump_sysproxy_arg,
 747             (uint8_t *)&callarg, sizeof(callarg), rval);
 748         if (error) {
 749                 rval[0] = -1;
 750                 rumpuser_seterrno(error);
 751         }
 752         return rval[0];
 753 }
 754 __weak_alias(sys_listen,rump_enosys);
 755
 756 int rump_sys_getsockopt(int, int, int, void *, unsigned int *);
 757 int
 758 rump_sys_getsockopt(int s, int level, int name, void * val, unsigned int * avalsize)
 759 {
 760         register_t rval[2] = {0, 0};
 761         int error = 0;
 762         struct sys_getsockopt_args callarg;
 763
 764         SPARG(&callarg, s) = s;
 765         SPARG(&callarg, level) = level;
 766         SPARG(&callarg, name) = name;
 767         SPARG(&callarg, val) = val;
 768         SPARG(&callarg, avalsize) = avalsize;
 769
 770         error = rump_sysproxy(SYS_getsockopt, rump_sysproxy_arg,
 771             (uint8_t *)&callarg, sizeof(callarg), rval);
 772         if (error) {
 773                 rval[0] = -1;
 774                 rumpuser_seterrno(error);
 775         }
 776         return rval[0];
 777 }
 778 __weak_alias(sys_getsockopt,rump_enosys);
 779
 780 ssize_t rump_sys_readv(int, const struct iovec *, int);
 781 ssize_t
 782 rump_sys_readv(int fd, const struct iovec * iovp, int iovcnt)
 783 {
 784         register_t rval[2] = {0, 0};
 785         int error = 0;
 786         struct sys_readv_args callarg;
 787
 788         SPARG(&callarg, fd) = fd;
 789         SPARG(&callarg, iovp) = iovp;
 790         SPARG(&callarg, iovcnt) = iovcnt;
 791
 792         error = rump_sysproxy(SYS_readv, rump_sysproxy_arg,
 793             (uint8_t *)&callarg, sizeof(callarg), rval);
 794         if (error) {
 795                 rval[0] = -1;
 796                 rumpuser_seterrno(error);
 797         }
 798         return rval[0];
 799 }
 800 __weak_alias(sys_readv,rump_enosys);
 801
 802 ssize_t rump_sys_writev(int, const struct iovec *, int);
 803 ssize_t
 804 rump_sys_writev(int fd, const struct iovec * iovp, int iovcnt)
 805 {
 806         register_t rval[2] = {0, 0};
 807         int error = 0;
 808         struct sys_writev_args callarg;
 809
 810         SPARG(&callarg, fd) = fd;
 811         SPARG(&callarg, iovp) = iovp;
 812         SPARG(&callarg, iovcnt) = iovcnt;
 813
 814         error = rump_sysproxy(SYS_writev, rump_sysproxy_arg,
 815             (uint8_t *)&callarg, sizeof(callarg), rval);
 816         if (error) {
 817                 rval[0] = -1;
 818                 rumpuser_seterrno(error);
 819         }
 820         return rval[0];
 821 }
 822 __weak_alias(sys_writev,rump_enosys);
 823
 824 int rump_sys_fchown(int, uid_t, gid_t);
 825 int
 826 rump_sys_fchown(int fd, uid_t uid, gid_t gid)
 827 {
 828         register_t rval[2] = {0, 0};
 829         int error = 0;
 830         struct sys_fchown_args callarg;
 831
 832         SPARG(&callarg, fd) = fd;
 833         SPARG(&callarg, uid) = uid;
 834         SPARG(&callarg, gid) = gid;
 835
 836         error = rump_sysproxy(SYS_fchown, rump_sysproxy_arg,
 837             (uint8_t *)&callarg, sizeof(callarg), rval);
 838         if (error) {
 839                 rval[0] = -1;
 840                 rumpuser_seterrno(error);
 841         }
 842         return rval[0];
 843 }
 844 __weak_alias(sys_fchown,rump_enosys);
 845
 846 int rump_sys_fchmod(int, mode_t);
 847 int
 848 rump_sys_fchmod(int fd, mode_t mode)
 849 {
 850         register_t rval[2] = {0, 0};
 851         int error = 0;
 852         struct sys_fchmod_args callarg;
 853
 854         SPARG(&callarg, fd) = fd;
 855         SPARG(&callarg, mode) = mode;
 856
 857         error = rump_sysproxy(SYS_fchmod, rump_sysproxy_arg,
 858             (uint8_t *)&callarg, sizeof(callarg), rval);
 859         if (error) {
 860                 rval[0] = -1;
 861                 rumpuser_seterrno(error);
 862         }
 863         return rval[0];
 864 }
 865 __weak_alias(sys_fchmod,rump_enosys);
 866
 867 int rump_sys_rename(const char *, const char *);
 868 int
 869 rump_sys_rename(const char * from, const char * to)
 870 {
 871         register_t rval[2] = {0, 0};
 872         int error = 0;
 873         struct sys_rename_args callarg;
 874
 875         SPARG(&callarg, from) = from;
 876         SPARG(&callarg, to) = to;
 877
 878         error = rump_sysproxy(SYS_rename, rump_sysproxy_arg,
 879             (uint8_t *)&callarg, sizeof(callarg), rval);
 880         if (error) {
 881                 rval[0] = -1;
 882                 rumpuser_seterrno(error);
 883         }
 884         return rval[0];
 885 }
 886 __weak_alias(sys_rename,rump_enosys);
 887
 888 int rump_sys_flock(int, int);
 889 int
 890 rump_sys_flock(int fd, int how)
 891 {
 892         register_t rval[2] = {0, 0};
 893         int error = 0;
 894         struct sys_flock_args callarg;
 895
 896         SPARG(&callarg, fd) = fd;
 897         SPARG(&callarg, how) = how;
 898
 899         error = rump_sysproxy(SYS_flock, rump_sysproxy_arg,
 900             (uint8_t *)&callarg, sizeof(callarg), rval);
 901         if (error) {
 902                 rval[0] = -1;
 903                 rumpuser_seterrno(error);
 904         }
 905         return rval[0];
 906 }
 907 __weak_alias(sys_flock,rump_enosys);
 908
 909 int rump_sys_mkfifo(const char *, mode_t);
 910 int
 911 rump_sys_mkfifo(const char * path, mode_t mode)
 912 {
 913         register_t rval[2] = {0, 0};
 914         int error = 0;
 915         struct sys_mkfifo_args callarg;
 916
 917         SPARG(&callarg, path) = path;
 918         SPARG(&callarg, mode) = mode;
 919
 920         error = rump_sysproxy(SYS_mkfifo, rump_sysproxy_arg,
 921             (uint8_t *)&callarg, sizeof(callarg), rval);
 922         if (error) {
 923                 rval[0] = -1;
 924                 rumpuser_seterrno(error);
 925         }
 926         return rval[0];
 927 }
 928 __weak_alias(sys_mkfifo,rump_enosys);
 929
 930 ssize_t rump_sys_sendto(int, const void *, size_t, int, const struct sockaddr *, unsigned int);
 931 ssize_t
 932 rump_sys_sendto(int s, const void * buf, size_t len, int flags, const struct sockaddr * to, unsigned int tolen)
 933 {
 934         register_t rval[2] = {0, 0};
 935         int error = 0;
 936         struct sys_sendto_args callarg;
 937
 938         SPARG(&callarg, s) = s;
 939         SPARG(&callarg, buf) = buf;
 940         SPARG(&callarg, len) = len;
 941         SPARG(&callarg, flags) = flags;
 942         SPARG(&callarg, to) = to;
 943         SPARG(&callarg, tolen) = tolen;
 944
 945         error = rump_sysproxy(SYS_sendto, rump_sysproxy_arg,
 946             (uint8_t *)&callarg, sizeof(callarg), rval);
 947         if (error) {
 948                 rval[0] = -1;
 949                 rumpuser_seterrno(error);
 950         }
 951         return rval[0];
 952 }
 953 __weak_alias(sys_sendto,rump_enosys);
 954
 955 int rump_sys_shutdown(int, int);
 956 int
 957 rump_sys_shutdown(int s, int how)
 958 {
 959         register_t rval[2] = {0, 0};
 960         int error = 0;
 961         struct sys_shutdown_args callarg;
 962
 963         SPARG(&callarg, s) = s;
 964         SPARG(&callarg, how) = how;
 965
 966         error = rump_sysproxy(SYS_shutdown, rump_sysproxy_arg,
 967             (uint8_t *)&callarg, sizeof(callarg), rval);
 968         if (error) {
 969                 rval[0] = -1;
 970                 rumpuser_seterrno(error);
 971         }
 972         return rval[0];
 973 }
 974 __weak_alias(sys_shutdown,rump_enosys);
 975
 976 int rump_sys_socketpair(int, int, int, int *);
 977 int
 978 rump_sys_socketpair(int domain, int type, int protocol, int * rsv)
 979 {
 980         register_t rval[2] = {0, 0};
 981         int error = 0;
 982         struct sys_socketpair_args callarg;
 983
 984         SPARG(&callarg, domain) = domain;
 985         SPARG(&callarg, type) = type;
 986         SPARG(&callarg, protocol) = protocol;
 987         SPARG(&callarg, rsv) = rsv;
 988
 989         error = rump_sysproxy(SYS_socketpair, rump_sysproxy_arg,
 990             (uint8_t *)&callarg, sizeof(callarg), rval);
 991         if (error) {
 992                 rval[0] = -1;
 993                 rumpuser_seterrno(error);
 994         }
 995         return rval[0];
 996 }
 997 __weak_alias(sys_socketpair,rump_enosys);
 998
 999 int rump_sys_mkdir(const char *, mode_t);
1000 int
1001 rump_sys_mkdir(const char * path, mode_t mode)
1002 {
1003         register_t rval[2] = {0, 0};
1004         int error = 0;
1005         struct sys_mkdir_args callarg;
1006
1007         SPARG(&callarg, path) = path;
1008         SPARG(&callarg, mode) = mode;
1009
1010         error = rump_sysproxy(SYS_mkdir, rump_sysproxy_arg,
1011             (uint8_t *)&callarg, sizeof(callarg), rval);
1012         if (error) {
1013                 rval[0] = -1;
1014                 rumpuser_seterrno(error);
1015         }
1016         return rval[0];
1017 }
1018 __weak_alias(sys_mkdir,rump_enosys);
1019
1020 int rump_sys_rmdir(const char *);
1021 int
1022 rump_sys_rmdir(const char * path)
1023 {
1024         register_t rval[2] = {0, 0};
1025         int error = 0;
1026         struct sys_rmdir_args callarg;
1027
1028         SPARG(&callarg, path) = path;
1029
1030         error = rump_sysproxy(SYS_rmdir, rump_sysproxy_arg,
1031             (uint8_t *)&callarg, sizeof(callarg), rval);
1032         if (error) {
1033                 rval[0] = -1;
1034                 rumpuser_seterrno(error);
1035         }
1036         return rval[0];
1037 }
1038 __weak_alias(sys_rmdir,rump_enosys);
1039
1040 int rump_sys_nfssvc(int, void *);
1041 int
1042 rump_sys_nfssvc(int flag, void * argp)
1043 {
1044         register_t rval[2] = {0, 0};
1045         int error = 0;
1046         struct sys_nfssvc_args callarg;
1047
1048         SPARG(&callarg, flag) = flag;
1049         SPARG(&callarg, argp) = argp;
1050
1051         error = rump_sysproxy(SYS_nfssvc, rump_sysproxy_arg,
1052             (uint8_t *)&callarg, sizeof(callarg), rval);
1053         if (error) {
1054                 rval[0] = -1;
1055                 rumpuser_seterrno(error);
1056         }
1057         return rval[0];
1058 }
1059 __weak_alias(sys_nfssvc,rump_enosys);
1060
1061 ssize_t rump_sys_pread(int, void *, size_t, off_t);
1062 ssize_t
1063 rump_sys_pread(int fd, void * buf, size_t nbyte, off_t offset)
1064 {
1065         register_t rval[2] = {0, 0};
1066         int error = 0;
1067         struct sys_pread_args callarg;
1068
1069         SPARG(&callarg, fd) = fd;
1070         SPARG(&callarg, buf) = buf;
1071         SPARG(&callarg, nbyte) = nbyte;
1072         SPARG(&callarg, PAD) = 0;
1073         SPARG(&callarg, offset) = offset;
1074
1075         error = rump_sysproxy(SYS_pread, rump_sysproxy_arg,
1076             (uint8_t *)&callarg, sizeof(callarg), rval);
1077         if (error) {
1078                 rval[0] = -1;
1079                 rumpuser_seterrno(error);
1080         }
1081         return rval[0];
1082 }
1083 __weak_alias(sys_pread,rump_enosys);
1084
1085 ssize_t rump_sys_pwrite(int, const void *, size_t, off_t);
1086 ssize_t
1087 rump_sys_pwrite(int fd, const void * buf, size_t nbyte, off_t offset)
1088 {
1089         register_t rval[2] = {0, 0};
1090         int error = 0;
1091         struct sys_pwrite_args callarg;
1092
1093         SPARG(&callarg, fd) = fd;
1094         SPARG(&callarg, buf) = buf;
1095         SPARG(&callarg, nbyte) = nbyte;
1096         SPARG(&callarg, PAD) = 0;
1097         SPARG(&callarg, offset) = offset;
1098
1099         error = rump_sysproxy(SYS_pwrite, rump_sysproxy_arg,
1100             (uint8_t *)&callarg, sizeof(callarg), rval);
1101         if (error) {
1102                 rval[0] = -1;
1103                 rumpuser_seterrno(error);
1104         }
1105         return rval[0];
1106 }
1107 __weak_alias(sys_pwrite,rump_enosys);
1108
1109 off_t rump_sys_lseek(int, off_t, int);
1110 off_t
1111 rump_sys_lseek(int fd, off_t offset, int whence)
1112 {
1113         register_t rval[2] = {0, 0};
1114         int error = 0;
1115         struct sys_lseek_args callarg;
1116
1117         SPARG(&callarg, fd) = fd;
1118         SPARG(&callarg, PAD) = 0;
1119         SPARG(&callarg, offset) = offset;
1120         SPARG(&callarg, whence) = whence;
1121
1122         error = rump_sysproxy(SYS_lseek, rump_sysproxy_arg,
1123             (uint8_t *)&callarg, sizeof(callarg), rval);
1124         if (error) {
1125                 rval[0] = -1;
1126                 rumpuser_seterrno(error);
1127         }
1128         return rval[0];
1129 }
1130 __weak_alias(sys_lseek,rump_enosys);
1131
1132 int rump_sys_truncate(const char *, off_t);
1133 int
1134 rump_sys_truncate(const char * path, off_t length)
1135 {
1136         register_t rval[2] = {0, 0};
1137         int error = 0;
1138         struct sys_truncate_args callarg;
1139
1140         SPARG(&callarg, path) = path;
1141         SPARG(&callarg, PAD) = 0;
1142         SPARG(&callarg, length) = length;
1143
1144         error = rump_sysproxy(SYS_truncate, rump_sysproxy_arg,
1145             (uint8_t *)&callarg, sizeof(callarg), rval);
1146         if (error) {
1147                 rval[0] = -1;
1148                 rumpuser_seterrno(error);
1149         }
1150         return rval[0];
1151 }
1152 __weak_alias(sys_truncate,rump_enosys);
1153
1154 int rump_sys_ftruncate(int, off_t);
1155 int
1156 rump_sys_ftruncate(int fd, off_t length)
1157 {
1158         register_t rval[2] = {0, 0};
1159         int error = 0;
1160         struct sys_ftruncate_args callarg;
1161
1162         SPARG(&callarg, fd) = fd;
1163         SPARG(&callarg, PAD) = 0;
1164         SPARG(&callarg, length) = length;
1165
1166         error = rump_sysproxy(SYS_ftruncate, rump_sysproxy_arg,
1167             (uint8_t *)&callarg, sizeof(callarg), rval);
1168         if (error) {
1169                 rval[0] = -1;
1170                 rumpuser_seterrno(error);
1171         }
1172         return rval[0];
1173 }
1174 __weak_alias(sys_ftruncate,rump_enosys);
1175
1176 int rump_sys___sysctl(const int *, u_int, void *, size_t *, const void *, size_t);
1177 int
1178 rump_sys___sysctl(const int * name, u_int namelen, void * old, size_t * oldlenp, const void * new, size_t newlen)
1179 {
1180         register_t rval[2] = {0, 0};
1181         int error = 0;
1182         struct sys___sysctl_args callarg;
1183
1184         SPARG(&callarg, name) = name;
1185         SPARG(&callarg, namelen) = namelen;
1186         SPARG(&callarg, old) = old;
1187         SPARG(&callarg, oldlenp) = oldlenp;
1188         SPARG(&callarg, new) = new;
1189         SPARG(&callarg, newlen) = newlen;
1190
1191         error = rump_sysproxy(SYS___sysctl, rump_sysproxy_arg,
1192             (uint8_t *)&callarg, sizeof(callarg), rval);
1193         if (error) {
1194                 rval[0] = -1;
1195                 rumpuser_seterrno(error);
1196         }
1197         return rval[0];
1198 }
1199 __weak_alias(sys___sysctl,rump_enosys);
1200
1201 int rump_sys_reboot(int, char *);
1202 int
1203 rump_sys_reboot(int opt, char * bootstr)
1204 {
1205         register_t rval[2] = {0, 0};
1206         int error = 0;
1207         struct sys_reboot_args callarg;
1208
1209         SPARG(&callarg, opt) = opt;
1210         SPARG(&callarg, bootstr) = bootstr;
1211
1212         error = rump_sysproxy(SYS_reboot, rump_sysproxy_arg,
1213             (uint8_t *)&callarg, sizeof(callarg), rval);
1214         if (error) {
1215                 rval[0] = -1;
1216                 rumpuser_seterrno(error);
1217         }
1218         return rval[0];
1219 }
1220 __weak_alias(sys_reboot,rump_enosys);
1221
1222 int rump_sys_poll(struct pollfd *, u_int, int);
1223 int
1224 rump_sys_poll(struct pollfd * fds, u_int nfds, int timeout)
1225 {
1226         register_t rval[2] = {0, 0};
1227         int error = 0;
1228         struct sys_poll_args callarg;
1229
1230         SPARG(&callarg, fds) = fds;
1231         SPARG(&callarg, nfds) = nfds;
1232         SPARG(&callarg, timeout) = timeout;
1233
1234         error = rump_sysproxy(SYS_poll, rump_sysproxy_arg,
1235             (uint8_t *)&callarg, sizeof(callarg), rval);
1236         if (error) {
1237                 rval[0] = -1;
1238                 rumpuser_seterrno(error);
1239         }
1240         return rval[0];
1241 }
1242 __weak_alias(sys_poll,rump_enosys);
1243
1244 int rump_sys_fdatasync(int);
1245 int
1246 rump_sys_fdatasync(int fd)
1247 {
1248         register_t rval[2] = {0, 0};
1249         int error = 0;
1250         struct sys_fdatasync_args callarg;
1251
1252         SPARG(&callarg, fd) = fd;
1253
1254         error = rump_sysproxy(SYS_fdatasync, rump_sysproxy_arg,
1255             (uint8_t *)&callarg, sizeof(callarg), rval);
1256         if (error) {
1257                 rval[0] = -1;
1258                 rumpuser_seterrno(error);
1259         }
1260         return rval[0];
1261 }
1262 __weak_alias(sys_fdatasync,rump_enosys);
1263
1264 int rump_sys_modctl(int, void *);
1265 int
1266 rump_sys_modctl(int cmd, void * arg)
1267 {
1268         register_t rval[2] = {0, 0};
1269         int error = 0;
1270         struct sys_modctl_args callarg;
1271
1272         SPARG(&callarg, cmd) = cmd;
1273         SPARG(&callarg, arg) = arg;
1274
1275         error = rump_sysproxy(SYS_modctl, rump_sysproxy_arg,
1276             (uint8_t *)&callarg, sizeof(callarg), rval);
1277         if (error) {
1278                 rval[0] = -1;
1279                 rumpuser_seterrno(error);
1280         }
1281         return rval[0];
1282 }
1283 __weak_alias(sys_modctl,rump_enosys);
1284
1285 int rump_sys_lchmod(const char *, mode_t);
1286 int
1287 rump_sys_lchmod(const char * path, mode_t mode)
1288 {
1289         register_t rval[2] = {0, 0};
1290         int error = 0;
1291         struct sys_lchmod_args callarg;
1292
1293         SPARG(&callarg, path) = path;
1294         SPARG(&callarg, mode) = mode;
1295
1296         error = rump_sysproxy(SYS_lchmod, rump_sysproxy_arg,
1297             (uint8_t *)&callarg, sizeof(callarg), rval);
1298         if (error) {
1299                 rval[0] = -1;
1300                 rumpuser_seterrno(error);
1301         }
1302         return rval[0];
1303 }
1304 __weak_alias(sys_lchmod,rump_enosys);
1305
1306 int rump_sys_lchown(const char *, uid_t, gid_t);
1307 int
1308 rump_sys_lchown(const char * path, uid_t uid, gid_t gid)
1309 {
1310         register_t rval[2] = {0, 0};
1311         int error = 0;
1312         struct sys_lchown_args callarg;
1313
1314         SPARG(&callarg, path) = path;
1315         SPARG(&callarg, uid) = uid;
1316         SPARG(&callarg, gid) = gid;
1317
1318         error = rump_sysproxy(SYS_lchown, rump_sysproxy_arg,
1319             (uint8_t *)&callarg, sizeof(callarg), rval);
1320         if (error) {
1321                 rval[0] = -1;
1322                 rumpuser_seterrno(error);
1323         }
1324         return rval[0];
1325 }
1326 __weak_alias(sys_lchown,rump_enosys);
1327
1328 int rump_sys_fchroot(int);
1329 int
1330 rump_sys_fchroot(int fd)
1331 {
1332         register_t rval[2] = {0, 0};
1333         int error = 0;
1334         struct sys_fchroot_args callarg;
1335
1336         SPARG(&callarg, fd) = fd;
1337
1338         error = rump_sysproxy(SYS_fchroot, rump_sysproxy_arg,
1339             (uint8_t *)&callarg, sizeof(callarg), rval);
1340         if (error) {
1341                 rval[0] = -1;
1342                 rumpuser_seterrno(error);
1343         }
1344         return rval[0];
1345 }
1346 __weak_alias(sys_fchroot,rump_enosys);
1347
1348 int rump_sys_lchflags(const char *, u_long);
1349 int
1350 rump_sys_lchflags(const char * path, u_long flags)
1351 {
1352         register_t rval[2] = {0, 0};
1353         int error = 0;
1354         struct sys_lchflags_args callarg;
1355
1356         SPARG(&callarg, path) = path;
1357         SPARG(&callarg, flags) = flags;
1358
1359         error = rump_sysproxy(SYS_lchflags, rump_sysproxy_arg,
1360             (uint8_t *)&callarg, sizeof(callarg), rval);
1361         if (error) {
1362                 rval[0] = -1;
1363                 rumpuser_seterrno(error);
1364         }
1365         return rval[0];
1366 }
1367 __weak_alias(sys_lchflags,rump_enosys);
1368
1369 int rump_sys_kqueue(void);
1370 int
1371 rump_sys_kqueue(void )
1372 {
1373         register_t rval[2] = {0, 0};
1374         int error = 0;
1375
1376         error = rump_sysproxy(SYS_kqueue, rump_sysproxy_arg,
1377             (uint8_t *)NULL, 0, rval);
1378         if (error) {
1379                 rval[0] = -1;
1380                 rumpuser_seterrno(error);
1381         }
1382         return rval[0];
1383 }
1384 __weak_alias(sys_kqueue,rump_enosys);
1385
1386 int rump_sys_fsync_range(int, int, off_t, off_t);
1387 int
1388 rump_sys_fsync_range(int fd, int flags, off_t start, off_t length)
1389 {
1390         register_t rval[2] = {0, 0};
1391         int error = 0;
1392         struct sys_fsync_range_args callarg;
1393
1394         SPARG(&callarg, fd) = fd;
1395         SPARG(&callarg, flags) = flags;
1396         SPARG(&callarg, start) = start;
1397         SPARG(&callarg, length) = length;
1398
1399         error = rump_sysproxy(SYS_fsync_range, rump_sysproxy_arg,
1400             (uint8_t *)&callarg, sizeof(callarg), rval);
1401         if (error) {
1402                 rval[0] = -1;
1403                 rumpuser_seterrno(error);
1404         }
1405         return rval[0];
1406 }
1407 __weak_alias(sys_fsync_range,rump_enosys);
1408
1409 int rump_sys_getvfsstat(struct statvfs *, size_t, int);
1410 int
1411 rump_sys_getvfsstat(struct statvfs * buf, size_t bufsize, int flags)
1412 {
1413         register_t rval[2] = {0, 0};
1414         int error = 0;
1415         struct sys_getvfsstat_args callarg;
1416
1417         SPARG(&callarg, buf) = buf;
1418         SPARG(&callarg, bufsize) = bufsize;
1419         SPARG(&callarg, flags) = flags;
1420
1421         error = rump_sysproxy(SYS_getvfsstat, rump_sysproxy_arg,
1422             (uint8_t *)&callarg, sizeof(callarg), rval);
1423         if (error) {
1424                 rval[0] = -1;
1425                 rumpuser_seterrno(error);
1426         }
1427         return rval[0];
1428 }
1429 __weak_alias(sys_getvfsstat,rump_enosys);
1430
1431 int rump_sys_statvfs1(const char *, struct statvfs *, int);
1432 int
1433 rump_sys_statvfs1(const char * path, struct statvfs * buf, int flags)
1434 {
1435         register_t rval[2] = {0, 0};
1436         int error = 0;
1437         struct sys_statvfs1_args callarg;
1438
1439         SPARG(&callarg, path) = path;
1440         SPARG(&callarg, buf) = buf;
1441         SPARG(&callarg, flags) = flags;
1442
1443         error = rump_sysproxy(SYS_statvfs1, rump_sysproxy_arg,
1444             (uint8_t *)&callarg, sizeof(callarg), rval);
1445         if (error) {
1446                 rval[0] = -1;
1447                 rumpuser_seterrno(error);
1448         }
1449         return rval[0];
1450 }
1451 __weak_alias(sys_statvfs1,rump_enosys);
1452
1453 int rump_sys_fstatvfs1(int, struct statvfs *, int);
1454 int
1455 rump_sys_fstatvfs1(int fd, struct statvfs * buf, int flags)
1456 {
1457         register_t rval[2] = {0, 0};
1458         int error = 0;
1459         struct sys_fstatvfs1_args callarg;
1460
1461         SPARG(&callarg, fd) = fd;
1462         SPARG(&callarg, buf) = buf;
1463         SPARG(&callarg, flags) = flags;
1464
1465         error = rump_sysproxy(SYS_fstatvfs1, rump_sysproxy_arg,
1466             (uint8_t *)&callarg, sizeof(callarg), rval);
1467         if (error) {
1468                 rval[0] = -1;
1469                 rumpuser_seterrno(error);
1470         }
1471         return rval[0];
1472 }
1473 __weak_alias(sys_fstatvfs1,rump_enosys);
1474
1475 int rump_sys_extattrctl(const char *, int, const char *, int, const char *);
1476 int
1477 rump_sys_extattrctl(const char * path, int cmd, const char * filename, int attrnamespace, const char * attrname)
1478 {
1479         register_t rval[2] = {0, 0};
1480         int error = 0;
1481         struct sys_extattrctl_args callarg;
1482
1483         SPARG(&callarg, path) = path;
1484         SPARG(&callarg, cmd) = cmd;
1485         SPARG(&callarg, filename) = filename;
1486         SPARG(&callarg, attrnamespace) = attrnamespace;
1487         SPARG(&callarg, attrname) = attrname;
1488
1489         error = rump_sysproxy(SYS_extattrctl, rump_sysproxy_arg,
1490             (uint8_t *)&callarg, sizeof(callarg), rval);
1491         if (error) {
1492                 rval[0] = -1;
1493                 rumpuser_seterrno(error);
1494         }
1495         return rval[0];
1496 }
1497 __weak_alias(sys_extattrctl,rump_enosys);
1498
1499 int rump_sys_extattr_set_file(const char *, int, const char *, const void *, size_t);
1500 int
1501 rump_sys_extattr_set_file(const char * path, int attrnamespace, const char * attrname, const void * data, size_t nbytes)
1502 {
1503         register_t rval[2] = {0, 0};
1504         int error = 0;
1505         struct sys_extattr_set_file_args callarg;
1506
1507         SPARG(&callarg, path) = path;
1508         SPARG(&callarg, attrnamespace) = attrnamespace;
1509         SPARG(&callarg, attrname) = attrname;
1510         SPARG(&callarg, data) = data;
1511         SPARG(&callarg, nbytes) = nbytes;
1512
1513         error = rump_sysproxy(SYS_extattr_set_file, rump_sysproxy_arg,
1514             (uint8_t *)&callarg, sizeof(callarg), rval);
1515         if (error) {
1516                 rval[0] = -1;
1517                 rumpuser_seterrno(error);
1518         }
1519         return rval[0];
1520 }
1521 __weak_alias(sys_extattr_set_file,rump_enosys);
1522
1523 ssize_t rump_sys_extattr_get_file(const char *, int, const char *, void *, size_t);
1524 ssize_t
1525 rump_sys_extattr_get_file(const char * path, int attrnamespace, const char * attrname, void * data, size_t nbytes)
1526 {
1527         register_t rval[2] = {0, 0};
1528         int error = 0;
1529         struct sys_extattr_get_file_args callarg;
1530
1531         SPARG(&callarg, path) = path;
1532         SPARG(&callarg, attrnamespace) = attrnamespace;
1533         SPARG(&callarg, attrname) = attrname;
1534         SPARG(&callarg, data) = data;
1535         SPARG(&callarg, nbytes) = nbytes;
1536
1537         error = rump_sysproxy(SYS_extattr_get_file, rump_sysproxy_arg,
1538             (uint8_t *)&callarg, sizeof(callarg), rval);
1539         if (error) {
1540                 rval[0] = -1;
1541                 rumpuser_seterrno(error);
1542         }
1543         return rval[0];
1544 }
1545 __weak_alias(sys_extattr_get_file,rump_enosys);
1546
1547 int rump_sys_extattr_delete_file(const char *, int, const char *);
1548 int
1549 rump_sys_extattr_delete_file(const char * path, int attrnamespace, const char * attrname)
1550 {
1551         register_t rval[2] = {0, 0};
1552         int error = 0;
1553         struct sys_extattr_delete_file_args callarg;
1554
1555         SPARG(&callarg, path) = path;
1556         SPARG(&callarg, attrnamespace) = attrnamespace;
1557         SPARG(&callarg, attrname) = attrname;
1558
1559         error = rump_sysproxy(SYS_extattr_delete_file, rump_sysproxy_arg,
1560             (uint8_t *)&callarg, sizeof(callarg), rval);
1561         if (error) {
1562                 rval[0] = -1;
1563                 rumpuser_seterrno(error);
1564         }
1565         return rval[0];
1566 }
1567 __weak_alias(sys_extattr_delete_file,rump_enosys);
1568
1569 int rump_sys_extattr_set_fd(int, int, const char *, const void *, size_t);
1570 int
1571 rump_sys_extattr_set_fd(int fd, int attrnamespace, const char * attrname, const void * data, size_t nbytes)
1572 {
1573         register_t rval[2] = {0, 0};
1574         int error = 0;
1575         struct sys_extattr_set_fd_args callarg;
1576
1577         SPARG(&callarg, fd) = fd;
1578         SPARG(&callarg, attrnamespace) = attrnamespace;
1579         SPARG(&callarg, attrname) = attrname;
1580         SPARG(&callarg, data) = data;
1581         SPARG(&callarg, nbytes) = nbytes;
1582
1583         error = rump_sysproxy(SYS_extattr_set_fd, rump_sysproxy_arg,
1584             (uint8_t *)&callarg, sizeof(callarg), rval);
1585         if (error) {
1586                 rval[0] = -1;
1587                 rumpuser_seterrno(error);
1588         }
1589         return rval[0];
1590 }
1591 __weak_alias(sys_extattr_set_fd,rump_enosys);
1592
1593 ssize_t rump_sys_extattr_get_fd(int, int, const char *, void *, size_t);
1594 ssize_t
1595 rump_sys_extattr_get_fd(int fd, int attrnamespace, const char * attrname, void * data, size_t nbytes)
1596 {
1597         register_t rval[2] = {0, 0};
1598         int error = 0;
1599         struct sys_extattr_get_fd_args callarg;
1600
1601         SPARG(&callarg, fd) = fd;
1602         SPARG(&callarg, attrnamespace) = attrnamespace;
1603         SPARG(&callarg, attrname) = attrname;
1604         SPARG(&callarg, data) = data;
1605         SPARG(&callarg, nbytes) = nbytes;
1606
1607         error = rump_sysproxy(SYS_extattr_get_fd, rump_sysproxy_arg,
1608             (uint8_t *)&callarg, sizeof(callarg), rval);
1609         if (error) {
1610                 rval[0] = -1;
1611                 rumpuser_seterrno(error);
1612         }
1613         return rval[0];
1614 }
1615 __weak_alias(sys_extattr_get_fd,rump_enosys);
1616
1617 int rump_sys_extattr_delete_fd(int, int, const char *);
1618 int
1619 rump_sys_extattr_delete_fd(int fd, int attrnamespace, const char * attrname)
1620 {
1621         register_t rval[2] = {0, 0};
1622         int error = 0;
1623         struct sys_extattr_delete_fd_args callarg;
1624
1625         SPARG(&callarg, fd) = fd;
1626         SPARG(&callarg, attrnamespace) = attrnamespace;
1627         SPARG(&callarg, attrname) = attrname;
1628
1629         error = rump_sysproxy(SYS_extattr_delete_fd, rump_sysproxy_arg,
1630             (uint8_t *)&callarg, sizeof(callarg), rval);
1631         if (error) {
1632                 rval[0] = -1;
1633                 rumpuser_seterrno(error);
1634         }
1635         return rval[0];
1636 }
1637 __weak_alias(sys_extattr_delete_fd,rump_enosys);
1638
1639 int rump_sys_extattr_set_link(const char *, int, const char *, const void *, size_t);
1640 int
1641 rump_sys_extattr_set_link(const char * path, int attrnamespace, const char * attrname, const void * data, size_t nbytes)
1642 {
1643         register_t rval[2] = {0, 0};
1644         int error = 0;
1645         struct sys_extattr_set_link_args callarg;
1646
1647         SPARG(&callarg, path) = path;
1648         SPARG(&callarg, attrnamespace) = attrnamespace;
1649         SPARG(&callarg, attrname) = attrname;
1650         SPARG(&callarg, data) = data;
1651         SPARG(&callarg, nbytes) = nbytes;
1652
1653         error = rump_sysproxy(SYS_extattr_set_link, rump_sysproxy_arg,
1654             (uint8_t *)&callarg, sizeof(callarg), rval);
1655         if (error) {
1656                 rval[0] = -1;
1657                 rumpuser_seterrno(error);
1658         }
1659         return rval[0];
1660 }
1661 __weak_alias(sys_extattr_set_link,rump_enosys);
1662
1663 ssize_t rump_sys_extattr_get_link(const char *, int, const char *, void *, size_t);
1664 ssize_t
1665 rump_sys_extattr_get_link(const char * path, int attrnamespace, const char * attrname, void * data, size_t nbytes)
1666 {
1667         register_t rval[2] = {0, 0};
1668         int error = 0;
1669         struct sys_extattr_get_link_args callarg;
1670
1671         SPARG(&callarg, path) = path;
1672         SPARG(&callarg, attrnamespace) = attrnamespace;
1673         SPARG(&callarg, attrname) = attrname;
1674         SPARG(&callarg, data) = data;
1675         SPARG(&callarg, nbytes) = nbytes;
1676
1677         error = rump_sysproxy(SYS_extattr_get_link, rump_sysproxy_arg,
1678             (uint8_t *)&callarg, sizeof(callarg), rval);
1679         if (error) {
1680                 rval[0] = -1;
1681                 rumpuser_seterrno(error);
1682         }
1683         return rval[0];
1684 }
1685 __weak_alias(sys_extattr_get_link,rump_enosys);
1686
1687 int rump_sys_extattr_delete_link(const char *, int, const char *);
1688 int
1689 rump_sys_extattr_delete_link(const char * path, int attrnamespace, const char * attrname)
1690 {
1691         register_t rval[2] = {0, 0};
1692         int error = 0;
1693         struct sys_extattr_delete_link_args callarg;
1694
1695         SPARG(&callarg, path) = path;
1696         SPARG(&callarg, attrnamespace) = attrnamespace;
1697         SPARG(&callarg, attrname) = attrname;
1698
1699         error = rump_sysproxy(SYS_extattr_delete_link, rump_sysproxy_arg,
1700             (uint8_t *)&callarg, sizeof(callarg), rval);
1701         if (error) {
1702                 rval[0] = -1;
1703                 rumpuser_seterrno(error);
1704         }
1705         return rval[0];
1706 }
1707 __weak_alias(sys_extattr_delete_link,rump_enosys);
1708
1709 ssize_t rump_sys_extattr_list_fd(int, int, void *, size_t);
1710 ssize_t
1711 rump_sys_extattr_list_fd(int fd, int attrnamespace, void * data, size_t nbytes)
1712 {
1713         register_t rval[2] = {0, 0};
1714         int error = 0;
1715         struct sys_extattr_list_fd_args callarg;
1716
1717         SPARG(&callarg, fd) = fd;
1718         SPARG(&callarg, attrnamespace) = attrnamespace;
1719         SPARG(&callarg, data) = data;
1720         SPARG(&callarg, nbytes) = nbytes;
1721
1722         error = rump_sysproxy(SYS_extattr_list_fd, rump_sysproxy_arg,
1723             (uint8_t *)&callarg, sizeof(callarg), rval);
1724         if (error) {
1725                 rval[0] = -1;
1726                 rumpuser_seterrno(error);
1727         }
1728         return rval[0];
1729 }
1730 __weak_alias(sys_extattr_list_fd,rump_enosys);
1731
1732 ssize_t rump_sys_extattr_list_file(const char *, int, void *, size_t);
1733 ssize_t
1734 rump_sys_extattr_list_file(const char * path, int attrnamespace, void * data, size_t nbytes)
1735 {
1736         register_t rval[2] = {0, 0};
1737         int error = 0;
1738         struct sys_extattr_list_file_args callarg;
1739
1740         SPARG(&callarg, path) = path;
1741         SPARG(&callarg, attrnamespace) = attrnamespace;
1742         SPARG(&callarg, data) = data;
1743         SPARG(&callarg, nbytes) = nbytes;
1744
1745         error = rump_sysproxy(SYS_extattr_list_file, rump_sysproxy_arg,
1746             (uint8_t *)&callarg, sizeof(callarg), rval);
1747         if (error) {
1748                 rval[0] = -1;
1749                 rumpuser_seterrno(error);
1750         }
1751         return rval[0];
1752 }
1753 __weak_alias(sys_extattr_list_file,rump_enosys);
1754
1755 ssize_t rump_sys_extattr_list_link(const char *, int, void *, size_t);
1756 ssize_t
1757 rump_sys_extattr_list_link(const char * path, int attrnamespace, void * data, size_t nbytes)
1758 {
1759         register_t rval[2] = {0, 0};
1760         int error = 0;
1761         struct sys_extattr_list_link_args callarg;
1762
1763         SPARG(&callarg, path) = path;
1764         SPARG(&callarg, attrnamespace) = attrnamespace;
1765         SPARG(&callarg, data) = data;
1766         SPARG(&callarg, nbytes) = nbytes;
1767
1768         error = rump_sysproxy(SYS_extattr_list_link, rump_sysproxy_arg,
1769             (uint8_t *)&callarg, sizeof(callarg), rval);
1770         if (error) {
1771                 rval[0] = -1;
1772                 rumpuser_seterrno(error);
1773         }
1774         return rval[0];
1775 }
1776 __weak_alias(sys_extattr_list_link,rump_enosys);
1777
1778 int rump_sys_setxattr(const char *, const char *, void *, size_t, int);
1779 int
1780 rump_sys_setxattr(const char * path, const char * name, void * value, size_t size, int flags)
1781 {
1782         register_t rval[2] = {0, 0};
1783         int error = 0;
1784         struct sys_setxattr_args callarg;
1785
1786         SPARG(&callarg, path) = path;
1787         SPARG(&callarg, name) = name;
1788         SPARG(&callarg, value) = value;
1789         SPARG(&callarg, size) = size;
1790         SPARG(&callarg, flags) = flags;
1791
1792         error = rump_sysproxy(SYS_setxattr, rump_sysproxy_arg,
1793             (uint8_t *)&callarg, sizeof(callarg), rval);
1794         if (error) {
1795                 rval[0] = -1;
1796                 rumpuser_seterrno(error);
1797         }
1798         return rval[0];
1799 }
1800 __weak_alias(sys_setxattr,rump_enosys);
1801
1802 int rump_sys_lsetxattr(const char *, const char *, void *, size_t, int);
1803 int
1804 rump_sys_lsetxattr(const char * path, const char * name, void * value, size_t size, int flags)
1805 {
1806         register_t rval[2] = {0, 0};
1807         int error = 0;
1808         struct sys_lsetxattr_args callarg;
1809
1810         SPARG(&callarg, path) = path;
1811         SPARG(&callarg, name) = name;
1812         SPARG(&callarg, value) = value;
1813         SPARG(&callarg, size) = size;
1814         SPARG(&callarg, flags) = flags;
1815
1816         error = rump_sysproxy(SYS_lsetxattr, rump_sysproxy_arg,
1817             (uint8_t *)&callarg, sizeof(callarg), rval);
1818         if (error) {
1819                 rval[0] = -1;
1820                 rumpuser_seterrno(error);
1821         }
1822         return rval[0];
1823 }
1824 __weak_alias(sys_lsetxattr,rump_enosys);
1825
1826 int rump_sys_fsetxattr(int, const char *, void *, size_t, int);
1827 int
1828 rump_sys_fsetxattr(int fd, const char * name, void * value, size_t size, int flags)
1829 {
1830         register_t rval[2] = {0, 0};
1831         int error = 0;
1832         struct sys_fsetxattr_args callarg;
1833
1834         SPARG(&callarg, fd) = fd;
1835         SPARG(&callarg, name) = name;
1836         SPARG(&callarg, value) = value;
1837         SPARG(&callarg, size) = size;
1838         SPARG(&callarg, flags) = flags;
1839
1840         error = rump_sysproxy(SYS_fsetxattr, rump_sysproxy_arg,
1841             (uint8_t *)&callarg, sizeof(callarg), rval);
1842         if (error) {
1843                 rval[0] = -1;
1844                 rumpuser_seterrno(error);
1845         }
1846         return rval[0];
1847 }
1848 __weak_alias(sys_fsetxattr,rump_enosys);
1849
1850 int rump_sys_getxattr(const char *, const char *, void *, size_t);
1851 int
1852 rump_sys_getxattr(const char * path, const char * name, void * value, size_t size)
1853 {
1854         register_t rval[2] = {0, 0};
1855         int error = 0;
1856         struct sys_getxattr_args callarg;
1857
1858         SPARG(&callarg, path) = path;
1859         SPARG(&callarg, name) = name;
1860         SPARG(&callarg, value) = value;
1861         SPARG(&callarg, size) = size;
1862
1863         error = rump_sysproxy(SYS_getxattr, rump_sysproxy_arg,
1864             (uint8_t *)&callarg, sizeof(callarg), rval);
1865         if (error) {
1866                 rval[0] = -1;
1867                 rumpuser_seterrno(error);
1868         }
1869         return rval[0];
1870 }
1871 __weak_alias(sys_getxattr,rump_enosys);
1872
1873 int rump_sys_lgetxattr(const char *, const char *, void *, size_t);
1874 int
1875 rump_sys_lgetxattr(const char * path, const char * name, void * value, size_t size)
1876 {
1877         register_t rval[2] = {0, 0};
1878         int error = 0;
1879         struct sys_lgetxattr_args callarg;
1880
1881         SPARG(&callarg, path) = path;
1882         SPARG(&callarg, name) = name;
1883         SPARG(&callarg, value) = value;
1884         SPARG(&callarg, size) = size;
1885
1886         error = rump_sysproxy(SYS_lgetxattr, rump_sysproxy_arg,
1887             (uint8_t *)&callarg, sizeof(callarg), rval);
1888         if (error) {
1889                 rval[0] = -1;
1890                 rumpuser_seterrno(error);
1891         }
1892         return rval[0];
1893 }
1894 __weak_alias(sys_lgetxattr,rump_enosys);
1895
1896 int rump_sys_fgetxattr(int, const char *, void *, size_t);
1897 int
1898 rump_sys_fgetxattr(int fd, const char * name, void * value, size_t size)
1899 {
1900         register_t rval[2] = {0, 0};
1901         int error = 0;
1902         struct sys_fgetxattr_args callarg;
1903
1904         SPARG(&callarg, fd) = fd;
1905         SPARG(&callarg, name) = name;
1906         SPARG(&callarg, value) = value;
1907         SPARG(&callarg, size) = size;
1908
1909         error = rump_sysproxy(SYS_fgetxattr, rump_sysproxy_arg,
1910             (uint8_t *)&callarg, sizeof(callarg), rval);
1911         if (error) {
1912                 rval[0] = -1;
1913                 rumpuser_seterrno(error);
1914         }
1915         return rval[0];
1916 }
1917 __weak_alias(sys_fgetxattr,rump_enosys);
1918
1919 int rump_sys_listxattr(const char *, char *, size_t);
1920 int
1921 rump_sys_listxattr(const char * path, char * list, size_t size)
1922 {
1923         register_t rval[2] = {0, 0};
1924         int error = 0;
1925         struct sys_listxattr_args callarg;
1926
1927         SPARG(&callarg, path) = path;
1928         SPARG(&callarg, list) = list;
1929         SPARG(&callarg, size) = size;
1930
1931         error = rump_sysproxy(SYS_listxattr, rump_sysproxy_arg,
1932             (uint8_t *)&callarg, sizeof(callarg), rval);
1933         if (error) {
1934                 rval[0] = -1;
1935                 rumpuser_seterrno(error);
1936         }
1937         return rval[0];
1938 }
1939 __weak_alias(sys_listxattr,rump_enosys);
1940
1941 int rump_sys_llistxattr(const char *, char *, size_t);
1942 int
1943 rump_sys_llistxattr(const char * path, char * list, size_t size)
1944 {
1945         register_t rval[2] = {0, 0};
1946         int error = 0;
1947         struct sys_llistxattr_args callarg;
1948
1949         SPARG(&callarg, path) = path;
1950         SPARG(&callarg, list) = list;
1951         SPARG(&callarg, size) = size;
1952
1953         error = rump_sysproxy(SYS_llistxattr, rump_sysproxy_arg,
1954             (uint8_t *)&callarg, sizeof(callarg), rval);
1955         if (error) {
1956                 rval[0] = -1;
1957                 rumpuser_seterrno(error);
1958         }
1959         return rval[0];
1960 }
1961 __weak_alias(sys_llistxattr,rump_enosys);
1962
1963 int rump_sys_flistxattr(int, char *, size_t);
1964 int
1965 rump_sys_flistxattr(int fd, char * list, size_t size)
1966 {
1967         register_t rval[2] = {0, 0};
1968         int error = 0;
1969         struct sys_flistxattr_args callarg;
1970
1971         SPARG(&callarg, fd) = fd;
1972         SPARG(&callarg, list) = list;
1973         SPARG(&callarg, size) = size;
1974
1975         error = rump_sysproxy(SYS_flistxattr, rump_sysproxy_arg,
1976             (uint8_t *)&callarg, sizeof(callarg), rval);
1977         if (error) {
1978                 rval[0] = -1;
1979                 rumpuser_seterrno(error);
1980         }
1981         return rval[0];
1982 }
1983 __weak_alias(sys_flistxattr,rump_enosys);
1984
1985 int rump_sys_removexattr(const char *, const char *);
1986 int
1987 rump_sys_removexattr(const char * path, const char * name)
1988 {
1989         register_t rval[2] = {0, 0};
1990         int error = 0;
1991         struct sys_removexattr_args callarg;
1992
1993         SPARG(&callarg, path) = path;
1994         SPARG(&callarg, name) = name;
1995
1996         error = rump_sysproxy(SYS_removexattr, rump_sysproxy_arg,
1997             (uint8_t *)&callarg, sizeof(callarg), rval);
1998         if (error) {
1999                 rval[0] = -1;
2000                 rumpuser_seterrno(error);
2001         }
2002         return rval[0];
2003 }
2004 __weak_alias(sys_removexattr,rump_enosys);
2005
2006 int rump_sys_lremovexattr(const char *, const char *);
2007 int
2008 rump_sys_lremovexattr(const char * path, const char * name)
2009 {
2010         register_t rval[2] = {0, 0};
2011         int error = 0;
2012         struct sys_lremovexattr_args callarg;
2013
2014         SPARG(&callarg, path) = path;
2015         SPARG(&callarg, name) = name;
2016
2017         error = rump_sysproxy(SYS_lremovexattr, rump_sysproxy_arg,
2018             (uint8_t *)&callarg, sizeof(callarg), rval);
2019         if (error) {
2020                 rval[0] = -1;
2021                 rumpuser_seterrno(error);
2022         }
2023         return rval[0];
2024 }
2025 __weak_alias(sys_lremovexattr,rump_enosys);
2026
2027 int rump_sys_fremovexattr(int, const char *);
2028 int
2029 rump_sys_fremovexattr(int fd, const char * name)
2030 {
2031         register_t rval[2] = {0, 0};
2032         int error = 0;
2033         struct sys_fremovexattr_args callarg;
2034
2035         SPARG(&callarg, fd) = fd;
2036         SPARG(&callarg, name) = name;
2037
2038         error = rump_sysproxy(SYS_fremovexattr, rump_sysproxy_arg,
2039             (uint8_t *)&callarg, sizeof(callarg), rval);
2040         if (error) {
2041                 rval[0] = -1;
2042                 rumpuser_seterrno(error);
2043         }
2044         return rval[0];
2045 }
2046 __weak_alias(sys_fremovexattr,rump_enosys);
2047
2048 int rump_sys___getdents30(int, char *, size_t);
2049 int
2050 rump_sys___getdents30(int fd, char * buf, size_t count)
2051 {
2052         register_t rval[2] = {0, 0};
2053         int error = 0;
2054         struct sys___getdents30_args callarg;
2055
2056         SPARG(&callarg, fd) = fd;
2057         SPARG(&callarg, buf) = buf;
2058         SPARG(&callarg, count) = count;
2059
2060         error = rump_sysproxy(SYS___getdents30, rump_sysproxy_arg,
2061             (uint8_t *)&callarg, sizeof(callarg), rval);
2062         if (error) {
2063                 rval[0] = -1;
2064                 rumpuser_seterrno(error);
2065         }
2066         return rval[0];
2067 }
2068 __weak_alias(sys___getdents30,rump_enosys);
2069
2070 int rump_sys___socket30(int, int, int);
2071 int
2072 rump_sys___socket30(int domain, int type, int protocol)
2073 {
2074         register_t rval[2] = {0, 0};
2075         int error = 0;
2076         struct sys___socket30_args callarg;
2077
2078         SPARG(&callarg, domain) = domain;
2079         SPARG(&callarg, type) = type;
2080         SPARG(&callarg, protocol) = protocol;
2081
2082         error = rump_sysproxy(SYS___socket30, rump_sysproxy_arg,
2083             (uint8_t *)&callarg, sizeof(callarg), rval);
2084         if (error) {
2085                 rval[0] = -1;
2086                 rumpuser_seterrno(error);
2087         }
2088         return rval[0];
2089 }
2090 __weak_alias(sys___socket30,rump_enosys);
2091
2092 int rump_sys___getfh30(const char *, void *, size_t *);
2093 int
2094 rump_sys___getfh30(const char * fname, void * fhp, size_t * fh_size)
2095 {
2096         register_t rval[2] = {0, 0};
2097         int error = 0;
2098         struct sys___getfh30_args callarg;
2099
2100         SPARG(&callarg, fname) = fname;
2101         SPARG(&callarg, fhp) = fhp;
2102         SPARG(&callarg, fh_size) = fh_size;
2103
2104         error = rump_sysproxy(SYS___getfh30, rump_sysproxy_arg,
2105             (uint8_t *)&callarg, sizeof(callarg), rval);
2106         if (error) {
2107                 rval[0] = -1;
2108                 rumpuser_seterrno(error);
2109         }
2110         return rval[0];
2111 }
2112 __weak_alias(sys___getfh30,rump_enosys);
2113
2114 int rump_sys___fhopen40(const void *, size_t, int);
2115 int
2116 rump_sys___fhopen40(const void * fhp, size_t fh_size, int flags)
2117 {
2118         register_t rval[2] = {0, 0};
2119         int error = 0;
2120         struct sys___fhopen40_args callarg;
2121
2122         SPARG(&callarg, fhp) = fhp;
2123         SPARG(&callarg, fh_size) = fh_size;
2124         SPARG(&callarg, flags) = flags;
2125
2126         error = rump_sysproxy(SYS___fhopen40, rump_sysproxy_arg,
2127             (uint8_t *)&callarg, sizeof(callarg), rval);
2128         if (error) {
2129                 rval[0] = -1;
2130                 rumpuser_seterrno(error);
2131         }
2132         return rval[0];
2133 }
2134 __weak_alias(sys___fhopen40,rump_enosys);
2135
2136 int rump_sys___fhstatvfs140(const void *, size_t, struct statvfs *, int);
2137 int
2138 rump_sys___fhstatvfs140(const void * fhp, size_t fh_size, struct statvfs * buf, int flags)
2139 {
2140         register_t rval[2] = {0, 0};
2141         int error = 0;
2142         struct sys___fhstatvfs140_args callarg;
2143
2144         SPARG(&callarg, fhp) = fhp;
2145         SPARG(&callarg, fh_size) = fh_size;
2146         SPARG(&callarg, buf) = buf;
2147         SPARG(&callarg, flags) = flags;
2148
2149         error = rump_sysproxy(SYS___fhstatvfs140, rump_sysproxy_arg,
2150             (uint8_t *)&callarg, sizeof(callarg), rval);
2151         if (error) {
2152                 rval[0] = -1;
2153                 rumpuser_seterrno(error);
2154         }
2155         return rval[0];
2156 }
2157 __weak_alias(sys___fhstatvfs140,rump_enosys);
2158
2159 int rump_sys___mount50(const char *, const char *, int, void *, size_t);
2160 int
2161 rump_sys___mount50(const char * type, const char * path, int flags, void * data, size_t data_len)
2162 {
2163         register_t rval[2] = {0, 0};
2164         int error = 0;
2165         struct sys___mount50_args callarg;
2166
2167         SPARG(&callarg, type) = type;
2168         SPARG(&callarg, path) = path;
2169         SPARG(&callarg, flags) = flags;
2170         SPARG(&callarg, data) = data;
2171         SPARG(&callarg, data_len) = data_len;
2172
2173         error = rump_sysproxy(SYS___mount50, rump_sysproxy_arg,
2174             (uint8_t *)&callarg, sizeof(callarg), rval);
2175         if (error) {
2176                 rval[0] = -1;
2177                 rumpuser_seterrno(error);
2178         }
2179         return rval[0];
2180 }
2181 __weak_alias(sys___mount50,rump_enosys);
2182
2183 int rump_sys___select50(int, fd_set *, fd_set *, fd_set *, struct timeval *);
2184 int
2185 rump_sys___select50(int nd, fd_set * in, fd_set * ou, fd_set * ex, struct timeval * tv)
2186 {
2187         register_t rval[2] = {0, 0};
2188         int error = 0;
2189         struct sys___select50_args callarg;
2190
2191         SPARG(&callarg, nd) = nd;
2192         SPARG(&callarg, in) = in;
2193         SPARG(&callarg, ou) = ou;
2194         SPARG(&callarg, ex) = ex;
2195         SPARG(&callarg, tv) = tv;
2196
2197         error = rump_sysproxy(SYS___select50, rump_sysproxy_arg,
2198             (uint8_t *)&callarg, sizeof(callarg), rval);
2199         if (error) {
2200                 rval[0] = -1;
2201                 rumpuser_seterrno(error);
2202         }
2203         return rval[0];
2204 }
2205 __weak_alias(sys___select50,rump_enosys);
2206
2207 int rump_sys___utimes50(const char *, const struct timeval *);
2208 int
2209 rump_sys___utimes50(const char * path, const struct timeval * tptr)
2210 {
2211         register_t rval[2] = {0, 0};
2212         int error = 0;
2213         struct sys___utimes50_args callarg;
2214
2215         SPARG(&callarg, path) = path;
2216         SPARG(&callarg, tptr) = tptr;
2217
2218         error = rump_sysproxy(SYS___utimes50, rump_sysproxy_arg,
2219             (uint8_t *)&callarg, sizeof(callarg), rval);
2220         if (error) {
2221                 rval[0] = -1;
2222                 rumpuser_seterrno(error);
2223         }
2224         return rval[0];
2225 }
2226 __weak_alias(sys___utimes50,rump_enosys);
2227
2228 int rump_sys___futimes50(int, const struct timeval *);
2229 int
2230 rump_sys___futimes50(int fd, const struct timeval * tptr)
2231 {
2232         register_t rval[2] = {0, 0};
2233         int error = 0;
2234         struct sys___futimes50_args callarg;
2235
2236         SPARG(&callarg, fd) = fd;
2237         SPARG(&callarg, tptr) = tptr;
2238
2239         error = rump_sysproxy(SYS___futimes50, rump_sysproxy_arg,
2240             (uint8_t *)&callarg, sizeof(callarg), rval);
2241         if (error) {
2242                 rval[0] = -1;
2243                 rumpuser_seterrno(error);
2244         }
2245         return rval[0];
2246 }
2247 __weak_alias(sys___futimes50,rump_enosys);
2248
2249 int rump_sys___lutimes50(const char *, const struct timeval *);
2250 int
2251 rump_sys___lutimes50(const char * path, const struct timeval * tptr)
2252 {
2253         register_t rval[2] = {0, 0};
2254         int error = 0;
2255         struct sys___lutimes50_args callarg;
2256
2257         SPARG(&callarg, path) = path;
2258         SPARG(&callarg, tptr) = tptr;
2259
2260         error = rump_sysproxy(SYS___lutimes50, rump_sysproxy_arg,
2261             (uint8_t *)&callarg, sizeof(callarg), rval);
2262         if (error) {
2263                 rval[0] = -1;
2264                 rumpuser_seterrno(error);
2265         }
2266         return rval[0];
2267 }
2268 __weak_alias(sys___lutimes50,rump_enosys);
2269
2270 int rump_sys___kevent50(int, const struct kevent *, size_t, struct kevent *, size_t, const struct timespec *);
2271 int
2272 rump_sys___kevent50(int fd, const struct kevent * changelist, size_t nchanges, struct kevent * eventlist, size_t nevents, const struct timespec * timeout)
2273 {
2274         register_t rval[2] = {0, 0};
2275         int error = 0;
2276         struct sys___kevent50_args callarg;
2277
2278         SPARG(&callarg, fd) = fd;
2279         SPARG(&callarg, changelist) = changelist;
2280         SPARG(&callarg, nchanges) = nchanges;
2281         SPARG(&callarg, eventlist) = eventlist;
2282         SPARG(&callarg, nevents) = nevents;
2283         SPARG(&callarg, timeout) = timeout;
2284
2285         error = rump_sysproxy(SYS___kevent50, rump_sysproxy_arg,
2286             (uint8_t *)&callarg, sizeof(callarg), rval);
2287         if (error) {
2288                 rval[0] = -1;
2289                 rumpuser_seterrno(error);
2290         }
2291         return rval[0];
2292 }
2293 __weak_alias(sys___kevent50,rump_enosys);
2294
2295 int rump_sys___pselect50(int, fd_set *, fd_set *, fd_set *, const struct timespec *, const sigset_t *);
2296 int
2297 rump_sys___pselect50(int nd, fd_set * in, fd_set * ou, fd_set * ex, const struct timespec * ts, const sigset_t * mask)
2298 {
2299         register_t rval[2] = {0, 0};
2300         int error = 0;
2301         struct sys___pselect50_args callarg;
2302
2303         SPARG(&callarg, nd) = nd;
2304         SPARG(&callarg, in) = in;
2305         SPARG(&callarg, ou) = ou;
2306         SPARG(&callarg, ex) = ex;
2307         SPARG(&callarg, ts) = ts;
2308         SPARG(&callarg, mask) = mask;
2309
2310         error = rump_sysproxy(SYS___pselect50, rump_sysproxy_arg,
2311             (uint8_t *)&callarg, sizeof(callarg), rval);
2312         if (error) {
2313                 rval[0] = -1;
2314                 rumpuser_seterrno(error);
2315         }
2316         return rval[0];
2317 }
2318 __weak_alias(sys___pselect50,rump_enosys);
2319
2320 int rump_sys___pollts50(struct pollfd *, u_int, const struct timespec *, const sigset_t *);
2321 int
2322 rump_sys___pollts50(struct pollfd * fds, u_int nfds, const struct timespec * ts, const sigset_t * mask)
2323 {
2324         register_t rval[2] = {0, 0};
2325         int error = 0;
2326         struct sys___pollts50_args callarg;
2327
2328         SPARG(&callarg, fds) = fds;
2329         SPARG(&callarg, nfds) = nfds;
2330         SPARG(&callarg, ts) = ts;
2331         SPARG(&callarg, mask) = mask;
2332
2333         error = rump_sysproxy(SYS___pollts50, rump_sysproxy_arg,
2334             (uint8_t *)&callarg, sizeof(callarg), rval);
2335         if (error) {
2336                 rval[0] = -1;
2337                 rumpuser_seterrno(error);
2338         }
2339         return rval[0];
2340 }
2341 __weak_alias(sys___pollts50,rump_enosys);
2342
2343 int rump_sys___stat50(const char *, struct stat *);
2344 int
2345 rump_sys___stat50(const char * path, struct stat * ub)
2346 {
2347         register_t rval[2] = {0, 0};
2348         int error = 0;
2349         struct sys___stat50_args callarg;
2350
2351         SPARG(&callarg, path) = path;
2352         SPARG(&callarg, ub) = ub;
2353
2354         error = rump_sysproxy(SYS___stat50, rump_sysproxy_arg,
2355             (uint8_t *)&callarg, sizeof(callarg), rval);
2356         if (error) {
2357                 rval[0] = -1;
2358                 rumpuser_seterrno(error);
2359         }
2360         return rval[0];
2361 }
2362 __weak_alias(sys___stat50,rump_enosys);
2363
2364 int rump_sys___fstat50(int, struct stat *);
2365 int
2366 rump_sys___fstat50(int fd, struct stat * sb)
2367 {
2368         register_t rval[2] = {0, 0};
2369         int error = 0;
2370         struct sys___fstat50_args callarg;
2371
2372         SPARG(&callarg, fd) = fd;
2373         SPARG(&callarg, sb) = sb;
2374
2375         error = rump_sysproxy(SYS___fstat50, rump_sysproxy_arg,
2376             (uint8_t *)&callarg, sizeof(callarg), rval);
2377         if (error) {
2378                 rval[0] = -1;
2379                 rumpuser_seterrno(error);
2380         }
2381         return rval[0];
2382 }
2383 __weak_alias(sys___fstat50,rump_enosys);
2384
2385 int rump_sys___lstat50(const char *, struct stat *);
2386 int
2387 rump_sys___lstat50(const char * path, struct stat * ub)
2388 {
2389         register_t rval[2] = {0, 0};
2390         int error = 0;
2391         struct sys___lstat50_args callarg;
2392
2393         SPARG(&callarg, path) = path;
2394         SPARG(&callarg, ub) = ub;
2395
2396         error = rump_sysproxy(SYS___lstat50, rump_sysproxy_arg,
2397             (uint8_t *)&callarg, sizeof(callarg), rval);
2398         if (error) {
2399                 rval[0] = -1;
2400                 rumpuser_seterrno(error);
2401         }
2402         return rval[0];
2403 }
2404 __weak_alias(sys___lstat50,rump_enosys);
2405
2406 int rump_sys___mknod50(const char *, mode_t, dev_t);
2407 int
2408 rump_sys___mknod50(const char * path, mode_t mode, dev_t dev)
2409 {
2410         register_t rval[2] = {0, 0};
2411         int error = 0;
2412         struct sys___mknod50_args callarg;
2413
2414         SPARG(&callarg, path) = path;
2415         SPARG(&callarg, mode) = mode;
2416         SPARG(&callarg, dev) = dev;
2417
2418         error = rump_sysproxy(SYS___mknod50, rump_sysproxy_arg,
2419             (uint8_t *)&callarg, sizeof(callarg), rval);
2420         if (error) {
2421                 rval[0] = -1;
2422                 rumpuser_seterrno(error);
2423         }
2424         return rval[0];
2425 }
2426 __weak_alias(sys___mknod50,rump_enosys);
2427
2428 int rump_sys___fhstat50(const void *, size_t, struct stat *);
2429 int
2430 rump_sys___fhstat50(const void * fhp, size_t fh_size, struct stat * sb)
2431 {
2432         register_t rval[2] = {0, 0};
2433         int error = 0;
2434         struct sys___fhstat50_args callarg;
2435
2436         SPARG(&callarg, fhp) = fhp;
2437         SPARG(&callarg, fh_size) = fh_size;
2438         SPARG(&callarg, sb) = sb;
2439
2440         error = rump_sysproxy(SYS___fhstat50, rump_sysproxy_arg,
2441             (uint8_t *)&callarg, sizeof(callarg), rval);
2442         if (error) {
2443                 rval[0] = -1;
2444                 rumpuser_seterrno(error);
2445         }
2446         return rval[0];
2447 }
2448 __weak_alias(sys___fhstat50,rump_enosys);
2449
2450 int rump_sys_pipe(int *);
2451 int
2452 rump_sys_pipe(int *fd)
2453 {
2454         register_t rval[2] = {0, 0};
2455         int error = 0;
2456
2457         error = rump_sysproxy(SYS_pipe, rump_sysproxy_arg, NULL, 0, rval);
2458         if (error) {
2459                 rumpuser_seterrno(error);
2460         } else {
2461                 fd[0] = rval[0];
2462                 fd[1] = rval[1];
2463         }
2464         return error ? -1 : 0;
2465 }
2466
2467 #define s(type) sizeof(type)
2468 #define n(type) (sizeof(type)/sizeof (register_t))
2469 #define ns(type)        n(type), s(type)
2470
2471 struct sysent rump_sysent[] = {
2472         { 0, 0, 0,
2473             (sy_call_t *)rump_enosys },                 /* 0 = unrumped */
2474         { 0, 0, 0,
2475             (sy_call_t *)rump_enosys },                 /* 1 = unrumped */
2476         { 0, 0, 0,
2477             (sy_call_t *)rump_enosys },                 /* 2 = unrumped */
2478         { ns(struct sys_read_args), 0,
2479             (sy_call_t *)sys_read },                    /* 3 = read */
2480         { ns(struct sys_write_args), 0,
2481             (sy_call_t *)sys_write },                   /* 4 = write */
2482         { ns(struct sys_open_args), 0,
2483             (sy_call_t *)sys_open },                    /* 5 = open */
2484         { ns(struct sys_close_args), 0,
2485             (sy_call_t *)sys_close },                   /* 6 = close */
2486         { 0, 0, 0,
2487             (sy_call_t *)rump_enosys },                 /* 7 = unrumped */
2488         { 0, 0, 0,
2489             (sy_call_t *)rump_enosys },                 /* 8 = unrumped */
2490         { ns(struct sys_link_args), 0,
2491             (sy_call_t *)sys_link },                    /* 9 = link */
2492         { ns(struct sys_unlink_args), 0,
2493             (sy_call_t *)sys_unlink },                  /* 10 = unlink */
2494         { 0, 0, 0,
2495             (sy_call_t *)rump_enosys },                 /* 11 = obsolete execv */
2496         { ns(struct sys_chdir_args), 0,
2497             (sy_call_t *)sys_chdir },                   /* 12 = chdir */
2498         { ns(struct sys_fchdir_args), 0,
2499             (sy_call_t *)sys_fchdir },                  /* 13 = fchdir */
2500         { 0, 0, 0,
2501             (sy_call_t *)rump_enosys },                 /* 14 = unrumped */
2502         { ns(struct sys_chmod_args), 0,
2503             (sy_call_t *)sys_chmod },                   /* 15 = chmod */
2504         { ns(struct sys_chown_args), 0,
2505             (sy_call_t *)sys_chown },                   /* 16 = chown */
2506         { 0, 0, 0,
2507             (sy_call_t *)rump_enosys },                 /* 17 = unrumped */
2508         { 0, 0, 0,
2509             (sy_call_t *)rump_enosys },                 /* 18 = unrumped */
2510         { 0, 0, 0,
2511             (sy_call_t *)rump_enosys },                 /* 19 = unrumped */
2512         { 0, 0, 0,
2513             (sy_call_t *)rump_enosys },                 /* 20 = unrumped */
2514         { 0, 0, 0,
2515             (sy_call_t *)rump_enosys },                 /* 21 = unrumped */
2516         { ns(struct sys_unmount_args), 0,
2517             (sy_call_t *)sys_unmount },                 /* 22 = unmount */
2518         { 0, 0, 0,
2519             (sy_call_t *)rump_enosys },                 /* 23 = unrumped */
2520         { 0, 0, 0,
2521             (sy_call_t *)rump_enosys },                 /* 24 = unrumped */
2522         { 0, 0, 0,
2523             (sy_call_t *)rump_enosys },                 /* 25 = unrumped */
2524         { 0, 0, 0,
2525             (sy_call_t *)rump_enosys },                 /* 26 = unrumped */
2526         { ns(struct sys_recvmsg_args), 0,
2527             (sy_call_t *)sys_recvmsg },                 /* 27 = recvmsg */
2528         { ns(struct sys_sendmsg_args), 0,
2529             (sy_call_t *)sys_sendmsg },                 /* 28 = sendmsg */
2530         { ns(struct sys_recvfrom_args), 0,
2531             (sy_call_t *)sys_recvfrom },                /* 29 = recvfrom */
2532         { ns(struct sys_accept_args), 0,
2533             (sy_call_t *)sys_accept },                  /* 30 = accept */
2534         { ns(struct sys_getpeername_args), 0,
2535             (sy_call_t *)sys_getpeername },             /* 31 = getpeername */
2536         { ns(struct sys_getsockname_args), 0,
2537             (sy_call_t *)sys_getsockname },             /* 32 = getsockname */
2538         { ns(struct sys_access_args), 0,
2539             (sy_call_t *)sys_access },                  /* 33 = access */
2540         { ns(struct sys_chflags_args), 0,
2541             (sy_call_t *)sys_chflags },                 /* 34 = chflags */
2542         { ns(struct sys_fchflags_args), 0,
2543             (sy_call_t *)sys_fchflags },                /* 35 = fchflags */
2544         { 0, 0, 0,
2545             (sy_call_t *)sys_sync },                    /* 36 = sync */
2546         { 0, 0, 0,
2547             (sy_call_t *)rump_enosys },                 /* 37 = unrumped */
2548         { 0, 0, 0,
2549             (sy_call_t *)rump_enosys },                 /* 38 = unrumped */
2550         { 0, 0, 0,
2551             (sy_call_t *)rump_enosys },                 /* 39 = unrumped */
2552         { 0, 0, 0,
2553             (sy_call_t *)rump_enosys },                 /* 40 = unrumped */
2554         { ns(struct sys_dup_args), 0,
2555             (sy_call_t *)sys_dup },                     /* 41 = dup */
2556         { 0, 0, 0,
2557             (sy_call_t *)sys_pipe },                    /* 42 = pipe */
2558         { 0, 0, 0,
2559             (sy_call_t *)rump_enosys },                 /* 43 = unrumped */
2560         { 0, 0, 0,
2561             (sy_call_t *)rump_enosys },                 /* 44 = unrumped */
2562         { 0, 0, 0,
2563             (sy_call_t *)rump_enosys },                 /* 45 = unrumped */
2564         { 0, 0, 0,
2565             (sy_call_t *)rump_enosys },                 /* 46 = unrumped */
2566         { 0, 0, 0,
2567             (sy_call_t *)rump_enosys },                 /* 47 = unrumped */
2568         { 0, 0, 0,
2569             (sy_call_t *)rump_enosys },                 /* 48 = unrumped */
2570         { 0, 0, 0,
2571             (sy_call_t *)rump_enosys },                 /* 49 = unrumped */
2572         { 0, 0, 0,
2573             (sy_call_t *)rump_enosys },                 /* 50 = unrumped */
2574         { 0, 0, 0,
2575             (sy_call_t *)rump_enosys },                 /* 51 = unrumped */
2576         { 0, 0, 0,
2577             (sy_call_t *)rump_enosys },                 /* 52 = unrumped */
2578         { 0, 0, 0,
2579             (sy_call_t *)rump_enosys },                 /* 53 = unrumped */
2580         { ns(struct sys_ioctl_args), 0,
2581             (sy_call_t *)sys_ioctl },                   /* 54 = ioctl */
2582         { 0, 0, 0,
2583             (sy_call_t *)rump_enosys },                 /* 55 = unrumped */
2584         { ns(struct sys_revoke_args), 0,
2585             (sy_call_t *)sys_revoke },                  /* 56 = revoke */
2586         { ns(struct sys_symlink_args), 0,
2587             (sy_call_t *)sys_symlink },                 /* 57 = symlink */
2588         { ns(struct sys_readlink_args), 0,
2589             (sy_call_t *)sys_readlink },                /* 58 = readlink */
2590         { 0, 0, 0,
2591             (sy_call_t *)rump_enosys },                 /* 59 = unrumped */
2592         { 0, 0, 0,
2593             (sy_call_t *)rump_enosys },                 /* 60 = unrumped */
2594         { ns(struct sys_chroot_args), 0,
2595             (sy_call_t *)sys_chroot },                  /* 61 = chroot */
2596         { 0, 0, 0,
2597             (sy_call_t *)rump_enosys },                 /* 62 = unrumped */
2598         { 0, 0, 0,
2599             (sy_call_t *)rump_enosys },                 /* 63 = unrumped */
2600         { 0, 0, 0,
2601             (sy_call_t *)rump_enosys },                 /* 64 = unrumped */
2602         { 0, 0, 0,
2603             (sy_call_t *)rump_enosys },                 /* 65 = unrumped */
2604         { 0, 0, 0,
2605             (sy_call_t *)rump_enosys },                 /* 66 = unrumped */
2606         { 0, 0, 0,
2607             (sy_call_t *)rump_enosys },                 /* 67 = obsolete vread */
2608         { 0, 0, 0,
2609             (sy_call_t *)rump_enosys },                 /* 68 = obsolete vwrite */
2610         { 0, 0, 0,
2611             (sy_call_t *)rump_enosys },                 /* 69 = unrumped */
2612         { 0, 0, 0,
2613             (sy_call_t *)rump_enosys },                 /* 70 = unrumped */
2614         { 0, 0, 0,
2615             (sy_call_t *)rump_enosys },                 /* 71 = unrumped */
2616         { 0, 0, 0,
2617             (sy_call_t *)rump_enosys },                 /* 72 = unrumped */
2618         { 0, 0, 0,
2619             (sy_call_t *)rump_enosys },                 /* 73 = unrumped */
2620         { 0, 0, 0,
2621             (sy_call_t *)rump_enosys },                 /* 74 = unrumped */
2622         { 0, 0, 0,
2623             (sy_call_t *)rump_enosys },                 /* 75 = unrumped */
2624         { 0, 0, 0,
2625             (sy_call_t *)rump_enosys },                 /* 76 = obsolete vhangup */
2626         { 0, 0, 0,
2627             (sy_call_t *)rump_enosys },                 /* 77 = obsolete vlimit */
2628         { 0, 0, 0,
2629             (sy_call_t *)rump_enosys },                 /* 78 = unrumped */
2630         { 0, 0, 0,
2631             (sy_call_t *)rump_enosys },                 /* 79 = unrumped */
2632         { 0, 0, 0,
2633             (sy_call_t *)rump_enosys },                 /* 80 = unrumped */
2634         { 0, 0, 0,
2635             (sy_call_t *)rump_enosys },                 /* 81 = unrumped */
2636         { 0, 0, 0,
2637             (sy_call_t *)rump_enosys },                 /* 82 = unrumped */
2638         { 0, 0, 0,
2639             (sy_call_t *)rump_enosys },                 /* 83 = unrumped */
2640         { 0, 0, 0,
2641             (sy_call_t *)rump_enosys },                 /* 84 = unrumped */
2642         { 0, 0, 0,
2643             (sy_call_t *)rump_enosys },                 /* 85 = unrumped */
2644         { 0, 0, 0,
2645             (sy_call_t *)rump_enosys },                 /* 86 = unrumped */
2646         { 0, 0, 0,
2647             (sy_call_t *)rump_enosys },                 /* 87 = unrumped */
2648         { 0, 0, 0,
2649             (sy_call_t *)rump_enosys },                 /* 88 = unrumped */
2650         { 0, 0, 0,
2651             (sy_call_t *)rump_enosys },                 /* 89 = unrumped */
2652         { ns(struct sys_dup2_args), 0,
2653             (sy_call_t *)sys_dup2 },                    /* 90 = dup2 */
2654         { 0, 0, 0,
2655             (sy_call_t *)rump_enosys },                 /* 91 = unimplemented getdopt */
2656         { ns(struct sys_fcntl_args), 0,
2657             (sy_call_t *)sys_fcntl },                   /* 92 = fcntl */
2658         { 0, 0, 0,
2659             (sy_call_t *)rump_enosys },                 /* 93 = unrumped */
2660         { 0, 0, 0,
2661             (sy_call_t *)rump_enosys },                 /* 94 = unimplemented setdopt */
2662         { ns(struct sys_fsync_args), 0,
2663             (sy_call_t *)sys_fsync },                   /* 95 = fsync */
2664         { 0, 0, 0,
2665             (sy_call_t *)rump_enosys },                 /* 96 = unrumped */
2666         { 0, 0, 0,
2667             (sy_call_t *)rump_enosys },                 /* 97 = unrumped */
2668         { ns(struct sys_connect_args), 0,
2669             (sy_call_t *)sys_connect },                 /* 98 = connect */
2670         { 0, 0, 0,
2671             (sy_call_t *)rump_enosys },                 /* 99 = unrumped */
2672         { 0, 0, 0,
2673             (sy_call_t *)rump_enosys },                 /* 100 = unrumped */
2674         { 0, 0, 0,
2675             (sy_call_t *)rump_enosys },                 /* 101 = unrumped */
2676         { 0, 0, 0,
2677             (sy_call_t *)rump_enosys },                 /* 102 = unrumped */
2678         { 0, 0, 0,
2679             (sy_call_t *)rump_enosys },                 /* 103 = unrumped */
2680         { ns(struct sys_bind_args), 0,
2681             (sy_call_t *)sys_bind },                    /* 104 = bind */
2682         { ns(struct sys_setsockopt_args), 0,
2683             (sy_call_t *)sys_setsockopt },              /* 105 = setsockopt */
2684         { ns(struct sys_listen_args), 0,
2685             (sy_call_t *)sys_listen },                  /* 106 = listen */
2686         { 0, 0, 0,
2687             (sy_call_t *)rump_enosys },                 /* 107 = obsolete vtimes */
2688         { 0, 0, 0,
2689             (sy_call_t *)rump_enosys },                 /* 108 = unrumped */
2690         { 0, 0, 0,
2691             (sy_call_t *)rump_enosys },                 /* 109 = unrumped */
2692         { 0, 0, 0,
2693             (sy_call_t *)rump_enosys },                 /* 110 = unrumped */
2694         { 0, 0, 0,
2695             (sy_call_t *)rump_enosys },                 /* 111 = unrumped */
2696         { 0, 0, 0,
2697             (sy_call_t *)rump_enosys },                 /* 112 = unrumped */
2698         { 0, 0, 0,
2699             (sy_call_t *)rump_enosys },                 /* 113 = unrumped */
2700         { 0, 0, 0,
2701             (sy_call_t *)rump_enosys },                 /* 114 = unrumped */
2702         { 0, 0, 0,
2703             (sy_call_t *)rump_enosys },                 /* 115 = obsolete vtrace */
2704         { 0, 0, 0,
2705             (sy_call_t *)rump_enosys },                 /* 116 = unrumped */
2706         { 0, 0, 0,
2707             (sy_call_t *)rump_enosys },                 /* 117 = unrumped */
2708         { ns(struct sys_getsockopt_args), 0,
2709             (sy_call_t *)sys_getsockopt },              /* 118 = getsockopt */
2710         { 0, 0, 0,
2711             (sy_call_t *)rump_enosys },                 /* 119 = obsolete resuba */
2712         { ns(struct sys_readv_args), 0,
2713             (sy_call_t *)sys_readv },                   /* 120 = readv */
2714         { ns(struct sys_writev_args), 0,
2715             (sy_call_t *)sys_writev },                  /* 121 = writev */
2716         { 0, 0, 0,
2717             (sy_call_t *)rump_enosys },                 /* 122 = unrumped */
2718         { ns(struct sys_fchown_args), 0,
2719             (sy_call_t *)sys_fchown },                  /* 123 = fchown */
2720         { ns(struct sys_fchmod_args), 0,
2721             (sy_call_t *)sys_fchmod },                  /* 124 = fchmod */
2722         { 0, 0, 0,
2723             (sy_call_t *)rump_enosys },                 /* 125 = unrumped */
2724         { 0, 0, 0,
2725             (sy_call_t *)rump_enosys },                 /* 126 = unrumped */
2726         { 0, 0, 0,
2727             (sy_call_t *)rump_enosys },                 /* 127 = unrumped */
2728         { ns(struct sys_rename_args), 0,
2729             (sy_call_t *)sys_rename },                  /* 128 = rename */
2730         { 0, 0, 0,
2731             (sy_call_t *)rump_enosys },                 /* 129 = unrumped */
2732         { 0, 0, 0,
2733             (sy_call_t *)rump_enosys },                 /* 130 = unrumped */
2734         { ns(struct sys_flock_args), 0,
2735             (sy_call_t *)sys_flock },                   /* 131 = flock */
2736         { ns(struct sys_mkfifo_args), 0,
2737             (sy_call_t *)sys_mkfifo },                  /* 132 = mkfifo */
2738         { ns(struct sys_sendto_args), 0,
2739             (sy_call_t *)sys_sendto },                  /* 133 = sendto */
2740         { ns(struct sys_shutdown_args), 0,
2741             (sy_call_t *)sys_shutdown },                /* 134 = shutdown */
2742         { ns(struct sys_socketpair_args), 0,
2743             (sy_call_t *)sys_socketpair },              /* 135 = socketpair */
2744         { ns(struct sys_mkdir_args), 0,
2745             (sy_call_t *)sys_mkdir },                   /* 136 = mkdir */
2746         { ns(struct sys_rmdir_args), 0,
2747             (sy_call_t *)sys_rmdir },                   /* 137 = rmdir */
2748         { 0, 0, 0,
2749             (sy_call_t *)rump_enosys },                 /* 138 = unrumped */
2750         { 0, 0, 0,
2751             (sy_call_t *)rump_enosys },                 /* 139 = obsolete 4.2 sigreturn */
2752         { 0, 0, 0,
2753             (sy_call_t *)rump_enosys },                 /* 140 = unrumped */
2754         { 0, 0, 0,
2755             (sy_call_t *)rump_enosys },                 /* 141 = unrumped */
2756         { 0, 0, 0,
2757             (sy_call_t *)rump_enosys },                 /* 142 = unrumped */
2758         { 0, 0, 0,
2759             (sy_call_t *)rump_enosys },                 /* 143 = unrumped */
2760         { 0, 0, 0,
2761             (sy_call_t *)rump_enosys },                 /* 144 = unrumped */
2762         { 0, 0, 0,
2763             (sy_call_t *)rump_enosys },                 /* 145 = unrumped */
2764         { 0, 0, 0,
2765             (sy_call_t *)rump_enosys },                 /* 146 = unrumped */
2766         { 0, 0, 0,
2767             (sy_call_t *)rump_enosys },                 /* 147 = unrumped */
2768         { 0, 0, 0,
2769             (sy_call_t *)rump_enosys },                 /* 148 = unrumped */
2770         { 0, 0, 0,
2771             (sy_call_t *)rump_enosys },                 /* 149 = unrumped */
2772         { 0, 0, 0,
2773             (sy_call_t *)rump_enosys },                 /* 150 = unrumped */
2774         { 0, 0, 0,
2775             (sy_call_t *)rump_enosys },                 /* 151 = unimplemented */
2776         { 0, 0, 0,
2777             (sy_call_t *)rump_enosys },                 /* 152 = unimplemented */
2778         { 0, 0, 0,
2779             (sy_call_t *)rump_enosys },                 /* 153 = unimplemented */
2780         { 0, 0, 0,
2781             (sy_call_t *)rump_enosys },                 /* 154 = unimplemented */
2782         { ns(struct sys_nfssvc_args), 0,
2783             (sy_call_t *)sys_nomodule },                /* 155 = nfssvc */
2784         { 0, 0, 0,
2785             (sy_call_t *)rump_enosys },                 /* 156 = unrumped */
2786         { 0, 0, 0,
2787             (sy_call_t *)rump_enosys },                 /* 157 = unrumped */
2788         { 0, 0, 0,
2789             (sy_call_t *)rump_enosys },                 /* 158 = unrumped */
2790         { 0, 0, 0,
2791             (sy_call_t *)rump_enosys },                 /* 159 = unimplemented */
2792         { 0, 0, 0,
2793             (sy_call_t *)rump_enosys },                 /* 160 = unimplemented */
2794         { 0, 0, 0,
2795             (sy_call_t *)rump_enosys },                 /* 161 = unrumped */
2796         { 0, 0, 0,
2797             (sy_call_t *)rump_enosys },                 /* 162 = unrumped */
2798         { 0, 0, 0,
2799             (sy_call_t *)rump_enosys },                 /* 163 = unrumped */
2800         { 0, 0, 0,
2801             (sy_call_t *)rump_enosys },                 /* 164 = unrumped */
2802         { 0, 0, 0,
2803             (sy_call_t *)rump_enosys },                 /* 165 = unrumped */
2804         { 0, 0, 0,
2805             (sy_call_t *)rump_enosys },                 /* 166 = unimplemented */
2806         { 0, 0, 0,
2807             (sy_call_t *)rump_enosys },                 /* 167 = unimplemented */
2808         { 0, 0, 0,
2809             (sy_call_t *)rump_enosys },                 /* 168 = unimplemented */
2810 #if (defined(SYSVSEM) || !defined(_KERNEL_OPT)) && !defined(_LP64)
2811         { 0, 0, 0,
2812             (sy_call_t *)rump_enosys },                 /* 169 = unrumped */
2813 #else
2814         { 0, 0, 0,
2815             (sy_call_t *)rump_enosys },                 /* 169 = excluded 1.0 semsys */
2816 #endif
2817 #if (defined(SYSVMSG) || !defined(_KERNEL_OPT)) && !defined(_LP64)
2818         { 0, 0, 0,
2819             (sy_call_t *)rump_enosys },                 /* 170 = unrumped */
2820 #else
2821         { 0, 0, 0,
2822             (sy_call_t *)rump_enosys },                 /* 170 = excluded 1.0 msgsys */
2823 #endif
2824 #if (defined(SYSVSHM) || !defined(_KERNEL_OPT)) && !defined(_LP64)
2825         { 0, 0, 0,
2826             (sy_call_t *)rump_enosys },                 /* 171 = unrumped */
2827 #else
2828         { 0, 0, 0,
2829             (sy_call_t *)rump_enosys },                 /* 171 = excluded 1.0 shmsys */
2830 #endif
2831         { 0, 0, 0,
2832             (sy_call_t *)rump_enosys },                 /* 172 = unimplemented */
2833         { ns(struct sys_pread_args), 0,
2834             (sy_call_t *)sys_pread },                   /* 173 = pread */
2835         { ns(struct sys_pwrite_args), 0,
2836             (sy_call_t *)sys_pwrite },                  /* 174 = pwrite */
2837         { 0, 0, 0,
2838             (sy_call_t *)rump_enosys },                 /* 175 = unrumped */
2839 #if defined(NTP) || !defined(_KERNEL_OPT)
2840         { 0, 0, 0,
2841             (sy_call_t *)rump_enosys },                 /* 176 = unrumped */
2842 #else
2843         { 0, 0, 0,
2844             (sy_call_t *)rump_enosys },                 /* 176 = excluded ntp_adjtime */
2845 #endif
2846         { 0, 0, 0,
2847             (sy_call_t *)rump_enosys },                 /* 177 = unimplemented */
2848         { 0, 0, 0,
2849             (sy_call_t *)rump_enosys },                 /* 178 = unimplemented */
2850         { 0, 0, 0,
2851             (sy_call_t *)rump_enosys },                 /* 179 = unimplemented */
2852         { 0, 0, 0,
2853             (sy_call_t *)rump_enosys },                 /* 180 = unimplemented */
2854         { 0, 0, 0,
2855             (sy_call_t *)rump_enosys },                 /* 181 = unrumped */
2856         { 0, 0, 0,
2857             (sy_call_t *)rump_enosys },                 /* 182 = unrumped */
2858         { 0, 0, 0,
2859             (sy_call_t *)rump_enosys },                 /* 183 = unrumped */
2860 #if defined(LFS) || !defined(_KERNEL)
2861         { 0, 0, 0,
2862             (sy_call_t *)rump_enosys },                 /* 184 = unrumped */
2863         { 0, 0, 0,
2864             (sy_call_t *)rump_enosys },                 /* 185 = unrumped */
2865         { 0, 0, 0,
2866             (sy_call_t *)rump_enosys },                 /* 186 = unrumped */
2867         { 0, 0, 0,
2868             (sy_call_t *)rump_enosys },                 /* 187 = unrumped */
2869 #else
2870         { 0, 0, 0,
2871             (sy_call_t *)rump_enosys },                 /* 184 = excluded lfs_bmapv */
2872         { 0, 0, 0,
2873             (sy_call_t *)rump_enosys },                 /* 185 = excluded lfs_markv */
2874         { 0, 0, 0,
2875             (sy_call_t *)rump_enosys },                 /* 186 = excluded lfs_segclean */
2876         { 0, 0, 0,
2877             (sy_call_t *)rump_enosys },                 /* 187 = excluded lfs_segwait */
2878 #endif
2879         { 0, 0, 0,
2880             (sy_call_t *)rump_enosys },                 /* 188 = unrumped */
2881         { 0, 0, 0,
2882             (sy_call_t *)rump_enosys },                 /* 189 = unrumped */
2883         { 0, 0, 0,
2884             (sy_call_t *)rump_enosys },                 /* 190 = unrumped */
2885         { 0, 0, 0,
2886             (sy_call_t *)rump_enosys },                 /* 191 = unrumped */
2887         { 0, 0, 0,
2888             (sy_call_t *)rump_enosys },                 /* 192 = unrumped */
2889         { 0, 0, 0,
2890             (sy_call_t *)rump_enosys },                 /* 193 = unimplemented */
2891         { 0, 0, 0,
2892             (sy_call_t *)rump_enosys },                 /* 194 = unrumped */
2893         { 0, 0, 0,
2894             (sy_call_t *)rump_enosys },                 /* 195 = unrumped */
2895         { 0, 0, 0,
2896             (sy_call_t *)rump_enosys },                 /* 196 = unrumped */
2897         { 0, 0, 0,
2898             (sy_call_t *)rump_enosys },                 /* 197 = unrumped */
2899         { 0, 0, 0,
2900             (sy_call_t *)rump_enosys },                 /* 198 = unrumped */
2901         { ns(struct sys_lseek_args), 0,
2902             (sy_call_t *)sys_lseek },                   /* 199 = lseek */
2903         { ns(struct sys_truncate_args), 0,
2904             (sy_call_t *)sys_truncate },                /* 200 = truncate */
2905         { ns(struct sys_ftruncate_args), 0,
2906             (sy_call_t *)sys_ftruncate },               /* 201 = ftruncate */
2907         { ns(struct sys___sysctl_args), 0,
2908             (sy_call_t *)sys___sysctl },                /* 202 = __sysctl */
2909         { 0, 0, 0,
2910             (sy_call_t *)rump_enosys },                 /* 203 = unrumped */
2911         { 0, 0, 0,
2912             (sy_call_t *)rump_enosys },                 /* 204 = unrumped */
2913         { 0, 0, 0,
2914             (sy_call_t *)rump_enosys },                 /* 205 = unrumped */
2915         { 0, 0, 0,
2916             (sy_call_t *)rump_enosys },                 /* 206 = unrumped */
2917         { 0, 0, 0,
2918             (sy_call_t *)rump_enosys },                 /* 207 = unrumped */
2919         { ns(struct sys_reboot_args), 0,
2920             (sy_call_t *)sys_reboot },                  /* 208 = reboot */
2921         { ns(struct sys_poll_args), 0,
2922             (sy_call_t *)sys_poll },                    /* 209 = poll */
2923         { 0, 0, 0,
2924             (sy_call_t *)rump_enosys },                 /* 210 = unimplemented */
2925         { 0, 0, 0,
2926             (sy_call_t *)rump_enosys },                 /* 211 = unimplemented */
2927         { 0, 0, 0,
2928             (sy_call_t *)rump_enosys },                 /* 212 = unimplemented */
2929         { 0, 0, 0,
2930             (sy_call_t *)rump_enosys },                 /* 213 = unimplemented */
2931         { 0, 0, 0,
2932             (sy_call_t *)rump_enosys },                 /* 214 = unimplemented */
2933         { 0, 0, 0,
2934             (sy_call_t *)rump_enosys },                 /* 215 = unimplemented */
2935         { 0, 0, 0,
2936             (sy_call_t *)rump_enosys },                 /* 216 = unimplemented */
2937         { 0, 0, 0,
2938             (sy_call_t *)rump_enosys },                 /* 217 = unimplemented */
2939         { 0, 0, 0,
2940             (sy_call_t *)rump_enosys },                 /* 218 = unimplemented */
2941         { 0, 0, 0,
2942             (sy_call_t *)rump_enosys },                 /* 219 = unimplemented */
2943 #if defined(SYSVSEM) || !defined(_KERNEL_OPT)
2944         { 0, 0, 0,
2945             (sy_call_t *)rump_enosys },                 /* 220 = unrumped */
2946         { 0, 0, 0,
2947             (sy_call_t *)rump_enosys },                 /* 221 = unrumped */
2948         { 0, 0, 0,
2949             (sy_call_t *)rump_enosys },                 /* 222 = unrumped */
2950         { 0, 0, 0,
2951             (sy_call_t *)rump_enosys },                 /* 223 = unrumped */
2952 #else
2953         { 0, 0, 0,
2954             (sy_call_t *)rump_enosys },                 /* 220 = excluded compat_14_semctl */
2955         { 0, 0, 0,
2956             (sy_call_t *)rump_enosys },                 /* 221 = excluded semget */
2957         { 0, 0, 0,
2958             (sy_call_t *)rump_enosys },                 /* 222 = excluded semop */
2959         { 0, 0, 0,
2960             (sy_call_t *)rump_enosys },                 /* 223 = excluded semconfig */
2961 #endif
2962 #if defined(SYSVMSG) || !defined(_KERNEL_OPT)
2963         { 0, 0, 0,
2964             (sy_call_t *)rump_enosys },                 /* 224 = unrumped */
2965         { 0, 0, 0,
2966             (sy_call_t *)rump_enosys },                 /* 225 = unrumped */
2967         { 0, 0, 0,
2968             (sy_call_t *)rump_enosys },                 /* 226 = unrumped */
2969         { 0, 0, 0,
2970             (sy_call_t *)rump_enosys },                 /* 227 = unrumped */
2971 #else
2972         { 0, 0, 0,
2973             (sy_call_t *)rump_enosys },                 /* 224 = excluded compat_14_msgctl */
2974         { 0, 0, 0,
2975             (sy_call_t *)rump_enosys },                 /* 225 = excluded msgget */
2976         { 0, 0, 0,
2977             (sy_call_t *)rump_enosys },                 /* 226 = excluded msgsnd */
2978         { 0, 0, 0,
2979             (sy_call_t *)rump_enosys },                 /* 227 = excluded msgrcv */
2980 #endif
2981 #if defined(SYSVSHM) || !defined(_KERNEL_OPT)
2982         { 0, 0, 0,
2983             (sy_call_t *)rump_enosys },                 /* 228 = unrumped */
2984         { 0, 0, 0,
2985             (sy_call_t *)rump_enosys },                 /* 229 = unrumped */
2986         { 0, 0, 0,
2987             (sy_call_t *)rump_enosys },                 /* 230 = unrumped */
2988         { 0, 0, 0,
2989             (sy_call_t *)rump_enosys },                 /* 231 = unrumped */
2990 #else
2991         { 0, 0, 0,
2992             (sy_call_t *)rump_enosys },                 /* 228 = excluded shmat */
2993         { 0, 0, 0,
2994             (sy_call_t *)rump_enosys },                 /* 229 = excluded compat_14_shmctl */
2995         { 0, 0, 0,
2996             (sy_call_t *)rump_enosys },                 /* 230 = excluded shmdt */
2997         { 0, 0, 0,
2998             (sy_call_t *)rump_enosys },                 /* 231 = excluded shmget */
2999 #endif
3000         { 0, 0, 0,
3001             (sy_call_t *)rump_enosys },                 /* 232 = unrumped */
3002         { 0, 0, 0,
3003             (sy_call_t *)rump_enosys },                 /* 233 = unrumped */
3004         { 0, 0, 0,
3005             (sy_call_t *)rump_enosys },                 /* 234 = unrumped */
3006         { 0, 0, 0,
3007             (sy_call_t *)rump_enosys },                 /* 235 = unrumped */
3008         { 0, 0, 0,
3009             (sy_call_t *)rump_enosys },                 /* 236 = unrumped */
3010         { 0, 0, 0,
3011             (sy_call_t *)rump_enosys },                 /* 237 = unrumped */
3012         { 0, 0, 0,
3013             (sy_call_t *)rump_enosys },                 /* 238 = unrumped */
3014         { 0, 0, 0,
3015             (sy_call_t *)rump_enosys },                 /* 239 = unrumped */
3016         { 0, 0, 0,
3017             (sy_call_t *)rump_enosys },                 /* 240 = unrumped */
3018         { ns(struct sys_fdatasync_args), 0,
3019             (sy_call_t *)sys_fdatasync },               /* 241 = fdatasync */
3020         { 0, 0, 0,
3021             (sy_call_t *)rump_enosys },                 /* 242 = unrumped */
3022         { 0, 0, 0,
3023             (sy_call_t *)rump_enosys },                 /* 243 = unrumped */
3024         { 0, 0, 0,
3025             (sy_call_t *)rump_enosys },                 /* 244 = unrumped */
3026         { 0, 0, 0,
3027             (sy_call_t *)rump_enosys },                 /* 245 = unimplemented sys_sigqueue */
3028         { ns(struct sys_modctl_args), 0,
3029             (sy_call_t *)sys_modctl },                  /* 246 = modctl */
3030         { 0, 0, 0,
3031             (sy_call_t *)rump_enosys },                 /* 247 = unrumped */
3032         { 0, 0, 0,
3033             (sy_call_t *)rump_enosys },                 /* 248 = unrumped */
3034         { 0, 0, 0,
3035             (sy_call_t *)rump_enosys },                 /* 249 = unrumped */
3036         { 0, 0, 0,
3037             (sy_call_t *)rump_enosys },                 /* 250 = unrumped */
3038         { 0, 0, 0,
3039             (sy_call_t *)rump_enosys },                 /* 251 = unrumped */
3040         { 0, 0, 0,
3041             (sy_call_t *)rump_enosys },                 /* 252 = unrumped */
3042         { 0, 0, 0,
3043             (sy_call_t *)rump_enosys },                 /* 253 = unrumped */
3044         { 0, 0, 0,
3045             (sy_call_t *)rump_enosys },                 /* 254 = unrumped */
3046         { 0, 0, 0,
3047             (sy_call_t *)rump_enosys },                 /* 255 = unrumped */
3048         { 0, 0, 0,
3049             (sy_call_t *)rump_enosys },                 /* 256 = unimplemented sys__ksem_timedwait */
3050         { 0, 0, 0,
3051             (sy_call_t *)rump_enosys },                 /* 257 = unrumped */
3052         { 0, 0, 0,
3053             (sy_call_t *)rump_enosys },                 /* 258 = unrumped */
3054         { 0, 0, 0,
3055             (sy_call_t *)rump_enosys },                 /* 259 = unrumped */
3056         { 0, 0, 0,
3057             (sy_call_t *)rump_enosys },                 /* 260 = unrumped */
3058         { 0, 0, 0,
3059             (sy_call_t *)rump_enosys },                 /* 261 = unrumped */
3060         { 0, 0, 0,
3061             (sy_call_t *)rump_enosys },                 /* 262 = unrumped */
3062         { 0, 0, 0,
3063             (sy_call_t *)rump_enosys },                 /* 263 = unrumped */
3064         { 0, 0, 0,
3065             (sy_call_t *)rump_enosys },                 /* 264 = unrumped */
3066         { 0, 0, 0,
3067             (sy_call_t *)rump_enosys },                 /* 265 = unrumped */
3068         { 0, 0, 0,
3069             (sy_call_t *)rump_enosys },                 /* 266 = unrumped */
3070         { 0, 0, 0,
3071             (sy_call_t *)rump_enosys },                 /* 267 = unimplemented */
3072         { 0, 0, 0,
3073             (sy_call_t *)rump_enosys },                 /* 268 = unimplemented */
3074         { 0, 0, 0,
3075             (sy_call_t *)rump_enosys },                 /* 269 = unimplemented */
3076         { 0, 0, 0,
3077             (sy_call_t *)rump_enosys },                 /* 270 = unrumped */
3078         { 0, 0, 0,
3079             (sy_call_t *)rump_enosys },                 /* 271 = unrumped */
3080         { 0, 0, 0,
3081             (sy_call_t *)rump_enosys },                 /* 272 = unrumped */
3082         { 0, 0, 0,
3083             (sy_call_t *)rump_enosys },                 /* 273 = unrumped */
3084         { ns(struct sys_lchmod_args), 0,
3085             (sy_call_t *)sys_lchmod },                  /* 274 = lchmod */
3086         { ns(struct sys_lchown_args), 0,
3087             (sy_call_t *)sys_lchown },                  /* 275 = lchown */
3088         { 0, 0, 0,
3089             (sy_call_t *)rump_enosys },                 /* 276 = unrumped */
3090         { 0, 0, 0,
3091             (sy_call_t *)rump_enosys },                 /* 277 = unrumped */
3092         { 0, 0, 0,
3093             (sy_call_t *)rump_enosys },                 /* 278 = unrumped */
3094         { 0, 0, 0,
3095             (sy_call_t *)rump_enosys },                 /* 279 = unrumped */
3096         { 0, 0, 0,
3097             (sy_call_t *)rump_enosys },                 /* 280 = unrumped */
3098         { 0, 0, 0,
3099             (sy_call_t *)rump_enosys },                 /* 281 = unrumped */
3100         { 0, 0, 0,
3101             (sy_call_t *)rump_enosys },                 /* 282 = unrumped */
3102         { 0, 0, 0,
3103             (sy_call_t *)rump_enosys },                 /* 283 = unrumped */
3104         { 0, 0, 0,
3105             (sy_call_t *)rump_enosys },                 /* 284 = unrumped */
3106         { 0, 0, 0,
3107             (sy_call_t *)rump_enosys },                 /* 285 = unrumped */
3108         { 0, 0, 0,
3109             (sy_call_t *)rump_enosys },                 /* 286 = unrumped */
3110         { 0, 0, 0,
3111             (sy_call_t *)rump_enosys },                 /* 287 = unrumped */
3112         { 0, 0, 0,
3113             (sy_call_t *)rump_enosys },                 /* 288 = unrumped */
3114         { 0, 0, 0,
3115             (sy_call_t *)rump_enosys },                 /* 289 = unrumped */
3116         { 0, 0, 0,
3117             (sy_call_t *)rump_enosys },                 /* 290 = unrumped */
3118         { 0, 0, 0,
3119             (sy_call_t *)rump_enosys },                 /* 291 = unrumped */
3120         { 0, 0, 0,
3121             (sy_call_t *)rump_enosys },                 /* 292 = unrumped */
3122         { 0, 0, 0,
3123             (sy_call_t *)rump_enosys },                 /* 293 = unrumped */
3124         { 0, 0, 0,
3125             (sy_call_t *)rump_enosys },                 /* 294 = unrumped */
3126         { 0, 0, 0,
3127             (sy_call_t *)rump_enosys },                 /* 295 = unrumped */
3128         { 0, 0, 0,
3129             (sy_call_t *)rump_enosys },                 /* 296 = unrumped */
3130         { ns(struct sys_fchroot_args), 0,
3131             (sy_call_t *)sys_fchroot },                 /* 297 = fchroot */
3132         { 0, 0, 0,
3133             (sy_call_t *)rump_enosys },                 /* 298 = unrumped */
3134         { 0, 0, 0,
3135             (sy_call_t *)rump_enosys },                 /* 299 = unrumped */
3136         { 0, 0, 0,
3137             (sy_call_t *)rump_enosys },                 /* 300 = unrumped */
3138 #if defined(SYSVSEM) || !defined(_KERNEL_OPT)
3139         { 0, 0, 0,
3140             (sy_call_t *)rump_enosys },                 /* 301 = unrumped */
3141 #else
3142         { 0, 0, 0,
3143             (sy_call_t *)rump_enosys },                 /* 301 = excluded ____semctl13 */
3144 #endif
3145 #if defined(SYSVMSG) || !defined(_KERNEL_OPT)
3146         { 0, 0, 0,
3147             (sy_call_t *)rump_enosys },                 /* 302 = unrumped */
3148 #else
3149         { 0, 0, 0,
3150             (sy_call_t *)rump_enosys },                 /* 302 = excluded __msgctl13 */
3151 #endif
3152 #if defined(SYSVSHM) || !defined(_KERNEL_OPT)
3153         { 0, 0, 0,
3154             (sy_call_t *)rump_enosys },                 /* 303 = unrumped */
3155 #else
3156         { 0, 0, 0,
3157             (sy_call_t *)rump_enosys },                 /* 303 = excluded __shmctl13 */
3158 #endif
3159         { ns(struct sys_lchflags_args), 0,
3160             (sy_call_t *)sys_lchflags },                /* 304 = lchflags */
3161         { 0, 0, 0,
3162             (sy_call_t *)rump_enosys },                 /* 305 = unrumped */
3163         { 0, 0, 0,
3164             (sy_call_t *)rump_enosys },                 /* 306 = unrumped */
3165         { 0, 0, 0,
3166             (sy_call_t *)rump_enosys },                 /* 307 = unrumped */
3167         { 0, 0, 0,
3168             (sy_call_t *)rump_enosys },                 /* 308 = unrumped */
3169         { 0, 0, 0,
3170             (sy_call_t *)rump_enosys },                 /* 309 = unrumped */
3171         { 0, 0, 0,
3172             (sy_call_t *)rump_enosys },                 /* 310 = unrumped */
3173         { 0, 0, 0,
3174             (sy_call_t *)rump_enosys },                 /* 311 = unrumped */
3175         { 0, 0, 0,
3176             (sy_call_t *)rump_enosys },                 /* 312 = unrumped */
3177         { 0, 0, 0,
3178             (sy_call_t *)rump_enosys },                 /* 313 = unrumped */
3179         { 0, 0, 0,
3180             (sy_call_t *)rump_enosys },                 /* 314 = unrumped */
3181         { 0, 0, 0,
3182             (sy_call_t *)rump_enosys },                 /* 315 = unrumped */
3183         { 0, 0, 0,
3184             (sy_call_t *)rump_enosys },                 /* 316 = unrumped */
3185         { 0, 0, 0,
3186             (sy_call_t *)rump_enosys },                 /* 317 = unrumped */
3187         { 0, 0, 0,
3188             (sy_call_t *)rump_enosys },                 /* 318 = unrumped */
3189         { 0, 0, 0,
3190             (sy_call_t *)rump_enosys },                 /* 319 = unrumped */
3191         { 0, 0, 0,
3192             (sy_call_t *)rump_enosys },                 /* 320 = unrumped */
3193         { 0, 0, 0,
3194             (sy_call_t *)rump_enosys },                 /* 321 = unrumped */
3195         { 0, 0, 0,
3196             (sy_call_t *)rump_enosys },                 /* 322 = unrumped */
3197         { 0, 0, 0,
3198             (sy_call_t *)rump_enosys },                 /* 323 = unrumped */
3199         { 0, 0, 0,
3200             (sy_call_t *)rump_enosys },                 /* 324 = unrumped */
3201         { 0, 0, 0,
3202             (sy_call_t *)rump_enosys },                 /* 325 = unrumped */
3203         { 0, 0, 0,
3204             (sy_call_t *)rump_enosys },                 /* 326 = unimplemented */
3205         { 0, 0, 0,
3206             (sy_call_t *)rump_enosys },                 /* 327 = unimplemented */
3207         { 0, 0, 0,
3208             (sy_call_t *)rump_enosys },                 /* 328 = unimplemented */
3209         { 0, 0, 0,
3210             (sy_call_t *)rump_enosys },                 /* 329 = unimplemented */
3211         { 0, 0, 0,
3212             (sy_call_t *)rump_enosys },                 /* 330 = unrumped */
3213         { 0, 0, 0,
3214             (sy_call_t *)rump_enosys },                 /* 331 = unrumped */
3215         { 0, 0, 0,
3216             (sy_call_t *)rump_enosys },                 /* 332 = unrumped */
3217         { 0, 0, 0,
3218             (sy_call_t *)rump_enosys },                 /* 333 = unrumped */
3219         { 0, 0, 0,
3220             (sy_call_t *)rump_enosys },                 /* 334 = unrumped */
3221         { 0, 0, 0,
3222             (sy_call_t *)rump_enosys },                 /* 335 = unrumped */
3223         { 0, 0, 0,
3224             (sy_call_t *)rump_enosys },                 /* 336 = obsolete sys_sa_unblockyield */
3225         { 0, 0, 0,
3226             (sy_call_t *)rump_enosys },                 /* 337 = unimplemented */
3227         { 0, 0, 0,
3228             (sy_call_t *)rump_enosys },                 /* 338 = unimplemented */
3229         { 0, 0, 0,
3230             (sy_call_t *)rump_enosys },                 /* 339 = unimplemented */
3231         { 0, 0, 0,
3232             (sy_call_t *)rump_enosys },                 /* 340 = unrumped */
3233         { 0, 0, 0,
3234             (sy_call_t *)rump_enosys },                 /* 341 = unrumped */
3235         { 0, 0, 0,
3236             (sy_call_t *)rump_enosys },                 /* 342 = unrumped */
3237         { 0, 0, 0,
3238             (sy_call_t *)rump_enosys },                 /* 343 = unrumped */
3239         { 0, 0, 0,
3240             (sy_call_t *)sys_kqueue },                  /* 344 = kqueue */
3241         { 0, 0, 0,
3242             (sy_call_t *)rump_enosys },                 /* 345 = unrumped */
3243         { 0, 0, 0,
3244             (sy_call_t *)rump_enosys },                 /* 346 = unrumped */
3245         { 0, 0, 0,
3246             (sy_call_t *)rump_enosys },                 /* 347 = unrumped */
3247         { 0, 0, 0,
3248             (sy_call_t *)rump_enosys },                 /* 348 = unrumped */
3249         { 0, 0, 0,
3250             (sy_call_t *)rump_enosys },                 /* 349 = unrumped */
3251         { 0, 0, 0,
3252             (sy_call_t *)rump_enosys },                 /* 350 = unrumped */
3253         { 0, 0, 0,
3254             (sy_call_t *)rump_enosys },                 /* 351 = unimplemented */
3255         { 0, 0, 0,
3256             (sy_call_t *)rump_enosys },                 /* 352 = unimplemented */
3257         { 0, 0, 0,
3258             (sy_call_t *)rump_enosys },                 /* 353 = unimplemented */
3259         { ns(struct sys_fsync_range_args), 0,
3260             (sy_call_t *)sys_fsync_range },             /* 354 = fsync_range */
3261         { 0, 0, 0,
3262             (sy_call_t *)rump_enosys },                 /* 355 = unrumped */
3263         { ns(struct sys_getvfsstat_args), 0,
3264             (sy_call_t *)sys_getvfsstat },              /* 356 = getvfsstat */
3265         { ns(struct sys_statvfs1_args), 0,
3266             (sy_call_t *)sys_statvfs1 },                /* 357 = statvfs1 */
3267         { ns(struct sys_fstatvfs1_args), 0,
3268             (sy_call_t *)sys_fstatvfs1 },               /* 358 = fstatvfs1 */
3269         { 0, 0, 0,
3270             (sy_call_t *)rump_enosys },                 /* 359 = unrumped */
3271         { ns(struct sys_extattrctl_args), 0,
3272             (sy_call_t *)sys_extattrctl },              /* 360 = extattrctl */
3273         { ns(struct sys_extattr_set_file_args), 0,
3274             (sy_call_t *)sys_extattr_set_file },        /* 361 = extattr_set_file */
3275         { ns(struct sys_extattr_get_file_args), 0,
3276             (sy_call_t *)sys_extattr_get_file },        /* 362 = extattr_get_file */
3277         { ns(struct sys_extattr_delete_file_args), 0,
3278             (sy_call_t *)sys_extattr_delete_file },     /* 363 = extattr_delete_file */
3279         { ns(struct sys_extattr_set_fd_args), 0,
3280             (sy_call_t *)sys_extattr_set_fd },          /* 364 = extattr_set_fd */
3281         { ns(struct sys_extattr_get_fd_args), 0,
3282             (sy_call_t *)sys_extattr_get_fd },          /* 365 = extattr_get_fd */
3283         { ns(struct sys_extattr_delete_fd_args), 0,
3284             (sy_call_t *)sys_extattr_delete_fd },       /* 366 = extattr_delete_fd */
3285         { ns(struct sys_extattr_set_link_args), 0,
3286             (sy_call_t *)sys_extattr_set_link },        /* 367 = extattr_set_link */
3287         { ns(struct sys_extattr_get_link_args), 0,
3288             (sy_call_t *)sys_extattr_get_link },        /* 368 = extattr_get_link */
3289         { ns(struct sys_extattr_delete_link_args), 0,
3290             (sy_call_t *)sys_extattr_delete_link },     /* 369 = extattr_delete_link */
3291         { ns(struct sys_extattr_list_fd_args), 0,
3292             (sy_call_t *)sys_extattr_list_fd },         /* 370 = extattr_list_fd */
3293         { ns(struct sys_extattr_list_file_args), 0,
3294             (sy_call_t *)sys_extattr_list_file },       /* 371 = extattr_list_file */
3295         { ns(struct sys_extattr_list_link_args), 0,
3296             (sy_call_t *)sys_extattr_list_link },       /* 372 = extattr_list_link */
3297         { 0, 0, 0,
3298             (sy_call_t *)rump_enosys },                 /* 373 = unrumped */
3299         { 0, 0, 0,
3300             (sy_call_t *)rump_enosys },                 /* 374 = unrumped */
3301         { ns(struct sys_setxattr_args), 0,
3302             (sy_call_t *)sys_setxattr },                /* 375 = setxattr */
3303         { ns(struct sys_lsetxattr_args), 0,
3304             (sy_call_t *)sys_lsetxattr },               /* 376 = lsetxattr */
3305         { ns(struct sys_fsetxattr_args), 0,
3306             (sy_call_t *)sys_fsetxattr },               /* 377 = fsetxattr */
3307         { ns(struct sys_getxattr_args), 0,
3308             (sy_call_t *)sys_getxattr },                /* 378 = getxattr */
3309         { ns(struct sys_lgetxattr_args), 0,
3310             (sy_call_t *)sys_lgetxattr },               /* 379 = lgetxattr */
3311         { ns(struct sys_fgetxattr_args), 0,
3312             (sy_call_t *)sys_fgetxattr },               /* 380 = fgetxattr */
3313         { ns(struct sys_listxattr_args), 0,
3314             (sy_call_t *)sys_listxattr },               /* 381 = listxattr */
3315         { ns(struct sys_llistxattr_args), 0,
3316             (sy_call_t *)sys_llistxattr },              /* 382 = llistxattr */
3317         { ns(struct sys_flistxattr_args), 0,
3318             (sy_call_t *)sys_flistxattr },              /* 383 = flistxattr */
3319         { ns(struct sys_removexattr_args), 0,
3320             (sy_call_t *)sys_removexattr },             /* 384 = removexattr */
3321         { ns(struct sys_lremovexattr_args), 0,
3322             (sy_call_t *)sys_lremovexattr },            /* 385 = lremovexattr */
3323         { ns(struct sys_fremovexattr_args), 0,
3324             (sy_call_t *)sys_fremovexattr },            /* 386 = fremovexattr */
3325         { 0, 0, 0,
3326             (sy_call_t *)rump_enosys },                 /* 387 = unrumped */
3327         { 0, 0, 0,
3328             (sy_call_t *)rump_enosys },                 /* 388 = unrumped */
3329         { 0, 0, 0,
3330             (sy_call_t *)rump_enosys },                 /* 389 = unrumped */
3331         { ns(struct sys___getdents30_args), 0,
3332             (sy_call_t *)sys___getdents30 },            /* 390 = __getdents30 */
3333         { 0, 0, 0,
3334             (sy_call_t *)rump_enosys },                 /* 391 = ignored old posix_fadvise */
3335         { 0, 0, 0,
3336             (sy_call_t *)rump_enosys },                 /* 392 = unrumped */
3337         { 0, 0, 0,
3338             (sy_call_t *)rump_enosys },                 /* 393 = unrumped */
3339         { ns(struct sys___socket30_args), 0,
3340             (sy_call_t *)sys___socket30 },              /* 394 = __socket30 */
3341         { ns(struct sys___getfh30_args), 0,
3342             (sy_call_t *)sys___getfh30 },               /* 395 = __getfh30 */
3343         { ns(struct sys___fhopen40_args), 0,
3344             (sy_call_t *)sys___fhopen40 },              /* 396 = __fhopen40 */
3345         { ns(struct sys___fhstatvfs140_args), 0,
3346             (sy_call_t *)sys___fhstatvfs140 },          /* 397 = __fhstatvfs140 */
3347         { 0, 0, 0,
3348             (sy_call_t *)rump_enosys },                 /* 398 = unrumped */
3349         { 0, 0, 0,
3350             (sy_call_t *)rump_enosys },                 /* 399 = unrumped */
3351         { 0, 0, 0,
3352             (sy_call_t *)rump_enosys },                 /* 400 = unrumped */
3353         { 0, 0, 0,
3354             (sy_call_t *)rump_enosys },                 /* 401 = unrumped */
3355         { 0, 0, 0,
3356             (sy_call_t *)rump_enosys },                 /* 402 = unrumped */
3357         { 0, 0, 0,
3358             (sy_call_t *)rump_enosys },                 /* 403 = unrumped */
3359         { 0, 0, 0,
3360             (sy_call_t *)rump_enosys },                 /* 404 = unrumped */
3361         { 0, 0, 0,
3362             (sy_call_t *)rump_enosys },                 /* 405 = unrumped */
3363         { 0, 0, 0,
3364             (sy_call_t *)rump_enosys },                 /* 406 = unrumped */
3365         { 0, 0, 0,
3366             (sy_call_t *)rump_enosys },                 /* 407 = unimplemented */
3367         { 0, 0, 0,
3368             (sy_call_t *)rump_enosys },                 /* 408 = unimplemented */
3369         { 0, 0, 0,
3370             (sy_call_t *)rump_enosys },                 /* 409 = unimplemented */
3371         { ns(struct sys___mount50_args), 0,
3372             (sy_call_t *)sys___mount50 },               /* 410 = __mount50 */
3373         { 0, 0, 0,
3374             (sy_call_t *)rump_enosys },                 /* 411 = unrumped */
3375         { 0, 0, 0,
3376             (sy_call_t *)rump_enosys },                 /* 412 = unrumped */
3377         { 0, 0, 0,
3378             (sy_call_t *)rump_enosys },                 /* 413 = unrumped */
3379         { 0, 0, 0,
3380             (sy_call_t *)rump_enosys },                 /* 414 = unrumped */
3381         { 0, 0, 0,
3382             (sy_call_t *)rump_enosys },                 /* 415 = unrumped */
3383         { 0, 0, 0,
3384             (sy_call_t *)rump_enosys },                 /* 416 = unrumped */
3385         { ns(struct sys___select50_args), 0,
3386             (sy_call_t *)sys___select50 },              /* 417 = __select50 */
3387         { 0, 0, 0,
3388             (sy_call_t *)rump_enosys },                 /* 418 = unrumped */
3389         { 0, 0, 0,
3390             (sy_call_t *)rump_enosys },                 /* 419 = unrumped */
3391         { ns(struct sys___utimes50_args), 0,
3392             (sy_call_t *)sys___utimes50 },              /* 420 = __utimes50 */
3393         { 0, 0, 0,
3394             (sy_call_t *)rump_enosys },                 /* 421 = unrumped */
3395 #if defined(LFS) || !defined(_KERNEL)
3396         { 0, 0, 0,
3397             (sy_call_t *)rump_enosys },                 /* 422 = unrumped */
3398 #else
3399         { 0, 0, 0,
3400             (sy_call_t *)rump_enosys },                 /* 422 = excluded __lfs_segwait50 */
3401 #endif
3402         { ns(struct sys___futimes50_args), 0,
3403             (sy_call_t *)sys___futimes50 },             /* 423 = __futimes50 */
3404         { ns(struct sys___lutimes50_args), 0,
3405             (sy_call_t *)sys___lutimes50 },             /* 424 = __lutimes50 */
3406         { 0, 0, 0,
3407             (sy_call_t *)rump_enosys },                 /* 425 = unrumped */
3408         { 0, 0, 0,
3409             (sy_call_t *)rump_enosys },                 /* 426 = unrumped */
3410         { 0, 0, 0,
3411             (sy_call_t *)rump_enosys },                 /* 427 = unrumped */
3412         { 0, 0, 0,
3413             (sy_call_t *)rump_enosys },                 /* 428 = unrumped */
3414         { 0, 0, 0,
3415             (sy_call_t *)rump_enosys },                 /* 429 = unrumped */
3416         { 0, 0, 0,
3417             (sy_call_t *)rump_enosys },                 /* 430 = unrumped */
3418         { 0, 0, 0,
3419             (sy_call_t *)rump_enosys },                 /* 431 = unrumped */
3420         { 0, 0, 0,
3421             (sy_call_t *)rump_enosys },                 /* 432 = unrumped */
3422         { 0, 0, 0,
3423             (sy_call_t *)rump_enosys },                 /* 433 = unrumped */
3424         { 0, 0, 0,
3425             (sy_call_t *)rump_enosys },                 /* 434 = unrumped */
3426         { ns(struct sys___kevent50_args), 0,
3427             (sy_call_t *)sys___kevent50 },              /* 435 = __kevent50 */
3428         { ns(struct sys___pselect50_args), 0,
3429             (sy_call_t *)sys___pselect50 },             /* 436 = __pselect50 */
3430         { ns(struct sys___pollts50_args), 0,
3431             (sy_call_t *)sys___pollts50 },              /* 437 = __pollts50 */
3432         { 0, 0, 0,
3433             (sy_call_t *)rump_enosys },                 /* 438 = unrumped */
3434         { ns(struct sys___stat50_args), 0,
3435             (sy_call_t *)sys___stat50 },                /* 439 = __stat50 */
3436         { ns(struct sys___fstat50_args), 0,
3437             (sy_call_t *)sys___fstat50 },               /* 440 = __fstat50 */
3438         { ns(struct sys___lstat50_args), 0,
3439             (sy_call_t *)sys___lstat50 },               /* 441 = __lstat50 */
3440 #if defined(SYSVSEM) || !defined(_KERNEL_OPT)
3441         { 0, 0, 0,
3442             (sy_call_t *)rump_enosys },                 /* 442 = unrumped */
3443 #else
3444         { 0, 0, 0,
3445             (sy_call_t *)rump_enosys },                 /* 442 = excluded ____semctl50 */
3446 #endif
3447 #if defined(SYSVSHM) || !defined(_KERNEL_OPT)
3448         { 0, 0, 0,
3449             (sy_call_t *)rump_enosys },                 /* 443 = unrumped */
3450 #else
3451         { 0, 0, 0,
3452             (sy_call_t *)rump_enosys },                 /* 443 = excluded ____shmctl50 */
3453 #endif
3454 #if defined(SYSVMSG) || !defined(_KERNEL_OPT)
3455         { 0, 0, 0,
3456             (sy_call_t *)rump_enosys },                 /* 444 = unrumped */
3457 #else
3458         { 0, 0, 0,
3459             (sy_call_t *)rump_enosys },                 /* 444 = excluded ____msgctl50 */
3460 #endif
3461         { 0, 0, 0,
3462             (sy_call_t *)rump_enosys },                 /* 445 = unrumped */
3463         { 0, 0, 0,
3464             (sy_call_t *)rump_enosys },                 /* 446 = unrumped */
3465         { 0, 0, 0,
3466             (sy_call_t *)rump_enosys },                 /* 447 = unrumped */
3467 #if defined(NTP) || !defined(_KERNEL_OPT)
3468         { 0, 0, 0,
3469             (sy_call_t *)rump_enosys },                 /* 448 = unrumped */
3470 #else
3471         { 0, 0, 0,
3472             (sy_call_t *)rump_enosys },                 /* 448 = excluded ___ntp_gettime50 */
3473 #endif
3474         { 0, 0, 0,
3475             (sy_call_t *)rump_enosys },                 /* 449 = unrumped */
3476         { ns(struct sys___mknod50_args), 0,
3477             (sy_call_t *)sys___mknod50 },               /* 450 = __mknod50 */
3478         { ns(struct sys___fhstat50_args), 0,
3479             (sy_call_t *)sys___fhstat50 },              /* 451 = __fhstat50 */
3480         { 0, 0, 0,
3481             (sy_call_t *)rump_enosys },                 /* 452 = filler */
3482         { 0, 0, 0,
3483             (sy_call_t *)rump_enosys },                 /* 453 = filler */
3484         { 0, 0, 0,
3485             (sy_call_t *)rump_enosys },                 /* 454 = filler */
3486         { 0, 0, 0,
3487             (sy_call_t *)rump_enosys },                 /* 455 = filler */
3488         { 0, 0, 0,
3489             (sy_call_t *)rump_enosys },                 /* 456 = filler */
3490         { 0, 0, 0,
3491             (sy_call_t *)rump_enosys },                 /* 457 = filler */
3492         { 0, 0, 0,
3493             (sy_call_t *)rump_enosys },                 /* 458 = filler */
3494         { 0, 0, 0,
3495             (sy_call_t *)rump_enosys },                 /* 459 = filler */
3496         { 0, 0, 0,
3497             (sy_call_t *)rump_enosys },                 /* 460 = filler */
3498         { 0, 0, 0,
3499             (sy_call_t *)rump_enosys },                 /* 461 = filler */
3500         { 0, 0, 0,
3501             (sy_call_t *)rump_enosys },                 /* 462 = filler */
3502         { 0, 0, 0,
3503             (sy_call_t *)rump_enosys },                 /* 463 = filler */
3504         { 0, 0, 0,
3505             (sy_call_t *)rump_enosys },                 /* 464 = filler */
3506         { 0, 0, 0,
3507             (sy_call_t *)rump_enosys },                 /* 465 = filler */
3508         { 0, 0, 0,
3509             (sy_call_t *)rump_enosys },                 /* 466 = filler */
3510         { 0, 0, 0,
3511             (sy_call_t *)rump_enosys },                 /* 467 = filler */
3512         { 0, 0, 0,
3513             (sy_call_t *)rump_enosys },                 /* 468 = filler */
3514         { 0, 0, 0,
3515             (sy_call_t *)rump_enosys },                 /* 469 = filler */
3516         { 0, 0, 0,
3517             (sy_call_t *)rump_enosys },                 /* 470 = filler */
3518         { 0, 0, 0,
3519             (sy_call_t *)rump_enosys },                 /* 471 = filler */
3520         { 0, 0, 0,
3521             (sy_call_t *)rump_enosys },                 /* 472 = filler */
3522         { 0, 0, 0,
3523             (sy_call_t *)rump_enosys },                 /* 473 = filler */
3524         { 0, 0, 0,
3525             (sy_call_t *)rump_enosys },                 /* 474 = filler */
3526         { 0, 0, 0,
3527             (sy_call_t *)rump_enosys },                 /* 475 = filler */
3528         { 0, 0, 0,
3529             (sy_call_t *)rump_enosys },                 /* 476 = filler */
3530         { 0, 0, 0,
3531             (sy_call_t *)rump_enosys },                 /* 477 = filler */
3532         { 0, 0, 0,
3533             (sy_call_t *)rump_enosys },                 /* 478 = filler */
3534         { 0, 0, 0,
3535             (sy_call_t *)rump_enosys },                 /* 479 = filler */
3536         { 0, 0, 0,
3537             (sy_call_t *)rump_enosys },                 /* 480 = filler */
3538         { 0, 0, 0,
3539             (sy_call_t *)rump_enosys },                 /* 481 = filler */
3540         { 0, 0, 0,
3541             (sy_call_t *)rump_enosys },                 /* 482 = filler */
3542         { 0, 0, 0,
3543             (sy_call_t *)rump_enosys },                 /* 483 = filler */
3544         { 0, 0, 0,
3545             (sy_call_t *)rump_enosys },                 /* 484 = filler */
3546         { 0, 0, 0,
3547             (sy_call_t *)rump_enosys },                 /* 485 = filler */
3548         { 0, 0, 0,
3549             (sy_call_t *)rump_enosys },                 /* 486 = filler */
3550         { 0, 0, 0,
3551             (sy_call_t *)rump_enosys },                 /* 487 = filler */
3552         { 0, 0, 0,
3553             (sy_call_t *)rump_enosys },                 /* 488 = filler */
3554         { 0, 0, 0,
3555             (sy_call_t *)rump_enosys },                 /* 489 = filler */
3556         { 0, 0, 0,
3557             (sy_call_t *)rump_enosys },                 /* 490 = filler */
3558         { 0, 0, 0,
3559             (sy_call_t *)rump_enosys },                 /* 491 = filler */
3560         { 0, 0, 0,
3561             (sy_call_t *)rump_enosys },                 /* 492 = filler */
3562         { 0, 0, 0,
3563             (sy_call_t *)rump_enosys },                 /* 493 = filler */
3564         { 0, 0, 0,
3565             (sy_call_t *)rump_enosys },                 /* 494 = filler */
3566         { 0, 0, 0,
3567             (sy_call_t *)rump_enosys },                 /* 495 = filler */
3568         { 0, 0, 0,
3569             (sy_call_t *)rump_enosys },                 /* 496 = filler */
3570         { 0, 0, 0,
3571             (sy_call_t *)rump_enosys },                 /* 497 = filler */
3572         { 0, 0, 0,
3573             (sy_call_t *)rump_enosys },                 /* 498 = filler */
3574         { 0, 0, 0,
3575             (sy_call_t *)rump_enosys },                 /* 499 = filler */
3576         { 0, 0, 0,
3577             (sy_call_t *)rump_enosys },                 /* 500 = filler */
3578         { 0, 0, 0,
3579             (sy_call_t *)rump_enosys },                 /* 501 = filler */
3580         { 0, 0, 0,
3581             (sy_call_t *)rump_enosys },                 /* 502 = filler */
3582         { 0, 0, 0,
3583             (sy_call_t *)rump_enosys },                 /* 503 = filler */
3584         { 0, 0, 0,
3585             (sy_call_t *)rump_enosys },                 /* 504 = filler */
3586         { 0, 0, 0,
3587             (sy_call_t *)rump_enosys },                 /* 505 = filler */
3588         { 0, 0, 0,
3589             (sy_call_t *)rump_enosys },                 /* 506 = filler */
3590         { 0, 0, 0,
3591             (sy_call_t *)rump_enosys },                 /* 507 = filler */
3592         { 0, 0, 0,
3593             (sy_call_t *)rump_enosys },                 /* 508 = filler */
3594         { 0, 0, 0,
3595             (sy_call_t *)rump_enosys },                 /* 509 = filler */
3596         { 0, 0, 0,
3597             (sy_call_t *)rump_enosys },                 /* 510 = filler */
3598         { 0, 0, 0,
3599             (sy_call_t *)rump_enosys },                 /* 511 = filler */
3600 };
3601 CTASSERT(__arraycount(rump_sysent) == SYS_NSYSENT);