lib/libsys/abi/syscalls_1_2_0.conf

   1 # System calls starting at 1.2.0-release.
   2 #
   3 # $DragonFly: src/lib/libsys/abi/syscalls_1_2_0.conf,v 1.1 2005/05/08 18:14:54 dillon Exp $
   4
   5 BASE map_syscalls_1_2_0;
   6
   7 ADD 0 {
   8     function  int nosys(void);
   9     implementation direct;
  10 }
  11
  12 ADD 1 {
  13     function  void sys_exit(int rval);
  14     implementation direct;
  15 }
  16
  17 ADD 2 {
  18     function  int fork(void);
  19     implementation direct;
  20 }
  21
  22 ADD 3 {
  23     function  ssize_t read(int fd, void_ptr buf, size_t nbyte);
  24     implementation direct;
  25 }
  26
  27 ADD 4 {
  28     function  ssize_t write(int fd, const_void_ptr buf, size_t nbyte);
  29     implementation direct;
  30 }
  31
  32 ADD 5 {
  33     function  int open(char_ptr path, int flags, int mode);
  34     implementation direct;
  35 }
  36
  37 ADD 6 {
  38     function  int close(int fd);
  39     implementation direct;
  40 }
  41
  42 ADD 7 {
  43     function  int wait4(int pid, int_ptr status, int options,
  44                         rusage_1_2_0_ptr rusage);
  45     implementation direct;
  46 }
  47
  48 ADD 9 {
  49     function  int link(char_ptr path, char_ptr link);
  50     implementation direct;
  51 }
  52
  53 ADD 10 {
  54     function  int unlink(char_ptr path);
  55     implementation direct;
  56 }
  57
  58 ADD 12 {
  59     function  int chdir(char_ptr path);
  60     implementation direct;
  61 }
  62
  63 ADD 13 {
  64     function  int fchdir(int fd);
  65     implementation direct;
  66 }
  67
  68 ADD 14 {
  69     function  int mknod(char_ptr path, int mode, int dev);
  70     implementation direct;
  71 }
  72
  73 ADD 15 {
  74     function  int chmod(char_ptr path, int mode);
  75     implementation direct;
  76 }
  77
  78 ADD 16 {
  79     function  int chown(char_ptr path, int uid, int gid);
  80     implementation direct;
  81 }
  82
  83 ADD 17 {
  84     function  int obreak(char_ptr nsize);
  85     implementation direct;
  86 }
  87
  88 ADD 18 {
  89     function  int getfsstat(statfs_1_2_0_ptr buf, long bufsize,
  90                             int flags);
  91     implementation direct;
  92 }
  93
  94 ADD 20 {
  95     function  pid_t getpid(void);
  96     implementation direct;
  97 }
  98
  99 ADD 21 {
 100     function  int mount(char_ptr type, char_ptr path, int flags,
 101                         caddr_t data);
 102     implementation direct;
 103 }
 104
 105 ADD 22 {
 106     function  int unmount(char_ptr path, int flags);
 107     implementation direct;
 108 }
 109
 110 ADD 23 {
 111     function  int setuid(uid_t uid);
 112     implementation direct;
 113 }
 114
 115 ADD 24 {
 116     function  uid_t getuid(void);
 117     implementation direct;
 118 }
 119
 120 ADD 25 {
 121     function  uid_t geteuid(void);
 122     implementation direct;
 123 }
 124
 125 ADD 26 {
 126     function  int ptrace(int req, pid_t pid, caddr_t addr,
 127                          int data);
 128     implementation direct;
 129 }
 130
 131 ADD 27 {
 132     function  int recvmsg(int s, msghdr_1_2_0_ptr msg, int flags);
 133     implementation direct;
 134 }
 135
 136 ADD 28 {
 137     function  int sendmsg(int s, caddr_t msg, int flags);
 138     implementation direct;
 139 }
 140
 141 ADD 29 {
 142     function  int recvfrom(int s, caddr_t buf, size_t len,
 143                            int flags, caddr_t from, int_ptr fromlenaddr);
 144     implementation direct;
 145 }
 146
 147 ADD 30 {
 148     function  int accept(int s, caddr_t name, int_ptr anamelen);
 149     implementation direct;
 150 }
 151
 152 ADD 31 {
 153     function  int getpeername(int fdes, caddr_t asa, int_ptr alen);
 154     implementation direct;
 155 }
 156
 157 ADD 32 {
 158     function  int getsockname(int fdes, caddr_t asa, int_ptr alen);
 159     implementation direct;
 160 }
 161
 162 ADD 33 {
 163     function  int access(char_ptr path, int flags);
 164     implementation direct;
 165 }
 166
 167 ADD 34 {
 168     function  int chflags(char_ptr path, int flags);
 169     implementation direct;
 170 }
 171
 172 ADD 35 {
 173     function  int fchflags(int fd, int flags);
 174     implementation direct;
 175 }
 176
 177 ADD 36 {
 178     function  int sync(void);
 179     implementation direct;
 180 }
 181
 182 ADD 37 {
 183     function  int kill(int pid, int signum);
 184     implementation direct;
 185 }
 186
 187 ADD 39 {
 188     function  pid_t getppid(void);
 189     implementation direct;
 190 }
 191
 192 ADD 41 {
 193     function  int dup(u_int fd);
 194     implementation direct;
 195 }
 196
 197 ADD 42 {
 198     function  int pipe(void);
 199     implementation direct;
 200 }
 201
 202 ADD 43 {
 203     function  gid_t getegid(void);
 204     implementation direct;
 205 }
 206
 207 ADD 44 {
 208     function  int profil(caddr_t samples, size_t size,
 209                          size_t offset, u_int scale);
 210     implementation direct;
 211 }
 212
 213 ADD 45 {
 214     function  int ktrace(const_char_ptr fname, int ops, int facs, int pid);
 215     implementation direct;
 216 }
 217
 218 ADD 47 {
 219     function  gid_t getgid(void);
 220     implementation direct;
 221 }
 222
 223 ADD 49 {
 224     function  int getlogin(char_ptr namebuf, u_int namelen);
 225     implementation direct;
 226 }
 227
 228 ADD 50 {
 229     function  int setlogin(char_ptr namebuf);
 230     implementation direct;
 231 }
 232
 233 ADD 51 {
 234     function  int acct(char_ptr path);
 235     implementation direct;
 236 }
 237
 238 ADD 53 {
 239     function  int sigaltstack(stack_t_ptr ss, stack_t_ptr oss);
 240     implementation direct;
 241 }
 242
 243 ADD 54 {
 244     function  int ioctl(int fd, u_long com, caddr_t data);
 245     implementation direct;
 246 }
 247
 248 ADD 55 {
 249     function  int reboot(int opt);
 250     implementation direct;
 251 }
 252
 253 ADD 56 {
 254     function  int revoke(char_ptr path);
 255     implementation direct;
 256 }
 257
 258 ADD 57 {
 259     function  int symlink(char_ptr path, char_ptr link);
 260     implementation direct;
 261 }
 262
 263 ADD 58 {
 264     function  int readlink(char_ptr path, char_ptr buf, int count);
 265     implementation direct;
 266 }
 267
 268 ADD 59 {
 269     function  int execve(char_ptr fname, char_ptr_ptr argv, char_ptr_ptr envv);
 270     implementation direct;
 271 }
 272
 273 ADD 60 {
 274     function  int umask(int newmask);
 275     implementation direct;
 276 }
 277
 278 ADD 61 {
 279     function  int chroot(char_ptr path);
 280     implementation direct;
 281 }
 282
 283 ADD 65 {
 284     function  int msync(void_ptr addr, size_t len, int flags);
 285     implementation direct;
 286 }
 287
 288 ADD 66 {
 289     function  int vfork(void);
 290     implementation direct;
 291 }
 292
 293 ADD 69 {
 294     function  int sbrk(int incr);
 295     implementation direct;
 296 }
 297
 298 ADD 70 {
 299     function  int sstk(int incr);
 300     implementation direct;
 301 }
 302
 303 ADD 72 {
 304     function  int ovadvise(int anom);
 305     implementation direct;
 306 }
 307
 308 ADD 73 {
 309     function  int munmap(void_ptr addr, size_t len);
 310     implementation direct;
 311 }
 312
 313 ADD 74 {
 314     function  int mprotect(const_void_ptr addr, size_t len, int prot);
 315     implementation direct;
 316 }
 317
 318 ADD 75 {
 319     function  int madvise(void_ptr addr, size_t len, int behav);
 320     implementation direct;
 321 }
 322
 323 ADD 78 {
 324     function  int mincore(const_void_ptr addr, size_t len, char_ptr vec);
 325     implementation direct;
 326 }
 327
 328 ADD 79 {
 329     function  int getgroups(u_int gidsetsize, gid_t_ptr gidset);
 330     implementation direct;
 331 }
 332
 333 ADD 80 {
 334     function  int setgroups(u_int gidsetsize, gid_t_ptr gidset);
 335     implementation direct;
 336 }
 337
 338 ADD 81 {
 339     function  int getpgrp(void);
 340     implementation direct;
 341 }
 342
 343 ADD 82 {
 344     function  int setpgid(int pid, int pgid);
 345     implementation direct;
 346 }
 347
 348 ADD 83 {
 349     function  int setitimer(u_int which, itimerval_1_2_0_ptr itv,
 350                             itimerval_1_2_0_ptr oitv);
 351     implementation direct;
 352 }
 353
 354 ADD 85 {
 355     function  int swapon(char_ptr name);
 356     implementation direct;
 357 }
 358
 359 ADD 86 {
 360     function  int getitimer(u_int which, itimerval_1_2_0_ptr itv);
 361     implementation direct;
 362 }
 363
 364 ADD 89 {
 365     function  int getdtablesize(void);
 366     implementation direct;
 367 }
 368
 369 ADD 90 {
 370     function  int dup2(u_int from, u_int to);
 371     implementation direct;
 372 }
 373
 374 ADD 92 {
 375     function  int fcntl(int fd, int cmd, long arg);
 376     implementation direct;
 377 }
 378
 379 ADD 93 {
 380     function  int select(int nd, fd_set_ptr in, fd_set_ptr ou,
 381                          fd_set_ptr ex, timeval_1_2_0_ptr tv);
 382     implementation direct;
 383 }
 384
 385 ADD 95 {
 386     function  int fsync(int fd);
 387     implementation direct;
 388 }
 389
 390 ADD 96 {
 391     function  int setpriority(int which, int who, int prio);
 392     implementation direct;
 393 }
 394
 395 ADD 97 {
 396     function  int socket(int domain, int type, int protocol);
 397     implementation direct;
 398 }
 399
 400 ADD 98 {
 401     function  int connect(int s, caddr_t name, int namelen);
 402     implementation direct;
 403 }
 404
 405 ADD 99 {
 406     function  int accept(int s, caddr_t name, int_ptr anamelen);
 407     implementation direct;
 408 }
 409
 410 ADD 100 {
 411     function  int getpriority(int which, int who);
 412     implementation direct;
 413 }
 414
 415 ADD 104 {
 416     function  int bind(int s, caddr_t name, int namelen);
 417     implementation direct;
 418 }
 419
 420 ADD 105 {
 421     function  int setsockopt(int s, int level, int name,
 422                              caddr_t val, int valsize);
 423     implementation direct;
 424 }
 425
 426 ADD 106 {
 427     function  int listen(int s, int backlog);
 428     implementation direct;
 429 }
 430
 431 ADD 116 {
 432     function  int gettimeofday(timeval_1_2_0_ptr tp, timezone_1_2_0_ptr tzp);
 433     implementation direct;
 434 }
 435
 436 ADD 117 {
 437     function  int getrusage(int who, rusage_1_2_0_ptr rusage);
 438     implementation direct;
 439 }
 440
 441 ADD 118 {
 442     function  int getsockopt(int s, int level, int name,
 443                              caddr_t val, int_ptr avalsize);
 444     implementation direct;
 445 }
 446
 447 ADD 120 {
 448     function  int readv(int fd, iovec_1_2_0_ptr iovp, u_int iovcnt);
 449     implementation direct;
 450 }
 451
 452 ADD 121 {
 453     function  int writev(int fd, iovec_1_2_0_ptr iovp, u_int iovcnt);
 454     implementation direct;
 455 }
 456
 457 ADD 122 {
 458     function  int settimeofday(timeval_1_2_0_ptr tv, timezone_1_2_0_ptr tzp);
 459     implementation direct;
 460 }
 461
 462 ADD 123 {
 463     function  int fchown(int fd, int uid, int gid);
 464     implementation direct;
 465 }
 466
 467 ADD 124 {
 468     function  int fchmod(int fd, int mode);
 469     implementation direct;
 470 }
 471
 472 ADD 125 {
 473     function  int recvfrom(int s, caddr_t buf, size_t len,
 474                            int flags, caddr_t from, int_ptr fromlenaddr);
 475     implementation direct;
 476 }
 477
 478 ADD 126 {
 479     function  int setreuid(int ruid, int euid);
 480     implementation direct;
 481 }
 482
 483 ADD 127 {
 484     function  int setregid(int rgid, int egid);
 485     implementation direct;
 486 }
 487
 488 ADD 128 {
 489     function  int rename(char_ptr from, char_ptr to);
 490     implementation direct;
 491 }
 492
 493 ADD 131 {
 494     function  int flock(int fd, int how);
 495     implementation direct;
 496 }
 497
 498 ADD 132 {
 499     function  int mkfifo(char_ptr path, int mode);
 500     implementation direct;
 501 }
 502
 503 ADD 133 {
 504     function  int sendto(int s, caddr_t buf, size_t len,
 505                          int flags, caddr_t to, int tolen);
 506     implementation direct;
 507 }
 508
 509 ADD 134 {
 510     function  int shutdown(int s, int how);
 511     implementation direct;
 512 }
 513
 514 ADD 135 {
 515     function  int socketpair(int domain, int type, int protocol, int_ptr rsv);
 516     implementation direct;
 517 }
 518
 519 ADD 136 {
 520     function  int mkdir(char_ptr path, int mode);
 521     implementation direct;
 522 }
 523
 524 ADD 137 {
 525     function  int rmdir(char_ptr path);
 526     implementation direct;
 527 }
 528
 529 ADD 138 {
 530     function  int utimes(char_ptr path, timeval_1_2_0_ptr tptr);
 531     implementation direct;
 532 }
 533
 534 ADD 140 {
 535     function  int adjtime(timeval_1_2_0_ptr delta, timeval_1_2_0_ptr olddelta);
 536     implementation direct;
 537 }
 538
 539 ADD 147 {
 540     function  int setsid(void);
 541     implementation direct;
 542 }
 543
 544 ADD 148 {
 545     function  int quotactl(char_ptr path, int cmd, int uid, caddr_t arg);
 546     implementation direct;
 547 }
 548
 549 ADD 150 {
 550     function  int getsockname(int fdec, caddr_t asa, int_ptr alen);
 551     implementation direct;
 552 }
 553
 554 ADD 155 {
 555     function  int nfssvc(int flag, caddr_t argp);
 556     implementation direct;
 557 }
 558
 559 ADD 157 {
 560     function  int statfs(char_ptr path, statfs_1_2_0_ptr buf);
 561     implementation direct;
 562 }
 563
 564 ADD 158 {
 565     function  int fstatfs(int fd, statfs_1_2_0_ptr buf);
 566     implementation direct;
 567 }
 568
 569 ADD 161 {
 570     function  int getfh(char_ptr fname, fhandle_1_2_0_ptr fhp);
 571     implementation direct;
 572 }
 573
 574 ADD 162 {
 575     function  int getdomainname(char_ptr domainname, int len);
 576     implementation direct;
 577 }
 578
 579 ADD 163 {
 580     function  int setdomainname(char_ptr domainname, int len);
 581     implementation direct;
 582 }
 583
 584 ADD 164 {
 585     function  int uname(utsname_1_2_0_ptr name);
 586     implementation direct;
 587 }
 588
 589 ADD 165 {
 590     function  int sysarch(int op, char_ptr parms);
 591     implementation direct;
 592 }
 593
 594 ADD 166 {
 595     function  int rtprio(int function, pid_t pid, rtprio_1_2_0_ptr rtp);
 596     implementation direct;
 597 }
 598
 599 ADD 169 {
 600     function  int semsys(int which, int a2, int a3, int a4, int a5);
 601     implementation direct;
 602 }
 603
 604 ADD 170 {
 605     function  int msgsys(int which, int a2, int a3, int a4, int a5, int a6);
 606     implementation direct;
 607 }
 608
 609 ADD 171 {
 610     function  int shmsys(int which, int a2, int a3, int a4);
 611     implementation direct;
 612 }
 613
 614 ADD 173 {
 615     function  ssize_t pread(int fd, void_ptr buf, size_t nbyte,
 616                             int pad, off_t offset);
 617     implementation direct;
 618 }
 619
 620 ADD 174 {
 621     function  ssize_t pwrite(int fd, const_void_ptr buf,
 622                              size_t nbyte, int pad, off_t offset);
 623     implementation direct;
 624 }
 625
 626 ADD 176 {
 627     function  int ntp_adjtime(timex_1_2_0_ptr tp);
 628     implementation direct;
 629 }
 630
 631 ADD 181 {
 632     function  int setgid(gid_t gid);
 633     implementation direct;
 634 }
 635
 636 ADD 182 {
 637     function  int setegid(gid_t egid);
 638     implementation direct;
 639 }
 640
 641 ADD 183 {
 642     function  int seteuid(uid_t euid);
 643     implementation direct;
 644 }
 645
 646 ADD 188 {
 647     function  int stat(char_ptr path, stat_1_2_0_ptr ub);
 648     implementation direct;
 649 }
 650
 651 ADD 189 {
 652     function  int fstat(int fd, stat_1_2_0_ptr sb);
 653     implementation direct;
 654 }
 655
 656 ADD 190 {
 657     function  int lstat(char_ptr path, stat_1_2_0_ptr ub);
 658     implementation direct;
 659 }
 660
 661 ADD 191 {
 662     function  int pathconf(char_ptr path, int name);
 663     implementation direct;
 664 }
 665
 666 ADD 192 {
 667     function  int fpathconf(int fd, int name);
 668     implementation direct;
 669 }
 670
 671 ADD 194 {
 672     function  int getrlimit(u_int which, rlimit_1_2_0_ptr rlp);
 673     implementation direct;
 674 }
 675
 676 ADD 195 {
 677     function  int setrlimit(u_int which, rlimit_1_2_0_ptr rlp);
 678     implementation direct;
 679 }
 680
 681 ADD 196 {
 682     function  int getdirentries(int fd, char_ptr buf, u_int count, long_ptr basep);
 683     implementation direct;
 684 }
 685
 686 ADD 197 {
 687     function  caddr_t mmap(caddr_t addr, size_t len, int prot,
 688                            int flags, int fd, int pad, off_t pos);
 689     implementation direct;
 690 }
 691
 692 ADD 198 {
 693     function  int nosys(void);
 694     implementation direct;
 695 }
 696
 697 ADD 199 {
 698     function  off_t lseek(int fd, int pad, off_t offset, int whence);
 699     implementation direct;
 700 }
 701
 702 ADD 200 {
 703     function  int truncate(char_ptr path, int pad, off_t length);
 704     implementation direct;
 705 }
 706
 707 ADD 201 {
 708     function  int ftruncate(int fd, int pad, off_t length);
 709     implementation direct;
 710 }
 711
 712 ADD 202 {
 713     function  int __sysctl(int_ptr name, u_int namelen, void_ptr old,
 714                            size_t_ptr oldlenp, void_ptr new, size_t newlen);
 715     implementation direct;
 716 }
 717
 718 ADD 203 {
 719     function  int mlock(const_void_ptr addr, size_t len);
 720     implementation direct;
 721 }
 722
 723 ADD 204 {
 724     function  int munlock(const_void_ptr addr, size_t len);
 725     implementation direct;
 726 }
 727
 728 ADD 205 {
 729     function  int undelete(char_ptr path);
 730     implementation direct;
 731 }
 732
 733 ADD 206 {
 734     function  int futimes(int fd, timeval_1_2_0_ptr tptr);
 735     implementation direct;
 736 }
 737
 738 ADD 207 {
 739     function  int getpgid(pid_t pid);
 740     implementation direct;
 741 }
 742
 743 ADD 209 {
 744     function  int poll(pollfd_1_2_0_ptr fds, u_int nfds, int timeout);
 745     implementation direct;
 746 }
 747
 748 ADD 220 {
 749     function  int __semctl(int semid, int semnum, int cmd, semun_ptr arg);
 750     implementation direct;
 751 }
 752
 753 ADD 221 {
 754     function  int semget(key_t key, int nsems, int semflg);
 755     implementation direct;
 756 }
 757
 758 ADD 222 {
 759     function  int semop(int semid, sembuf_1_2_0_ptr sops, u_int nsops);
 760     implementation direct;
 761 }
 762
 763 ADD 224 {
 764     function  int msgctl(int msqid, int cmd, msqid_ds_1_2_0_ptr buf);
 765     implementation direct;
 766 }
 767
 768 ADD 225 {
 769     function  int msgget(key_t key, int msgflg);
 770     implementation direct;
 771 }
 772
 773 ADD 226 {
 774     function  int msgsnd(int msqid, void_ptr msgp, size_t msgsz, int msgflg);
 775     implementation direct;
 776 }
 777
 778 ADD 227 {
 779     function  int msgrcv(int msqid, void_ptr msgp, size_t msgsz,
 780                          long msgtyp, int msgflg);
 781     implementation direct;
 782 }
 783
 784 ADD 228 {
 785     function  int shmat(int shmid, void_ptr shmaddr, int shmflg);
 786     implementation direct;
 787 }
 788
 789 ADD 229 {
 790     function  int shmctl(int shmid, int cmd, shmid_ds_1_2_0_ptr buf);
 791     implementation direct;
 792 }
 793
 794 ADD 230 {
 795     function  int shmdt(void_ptr shmaddr);
 796     implementation direct;
 797 }
 798
 799 ADD 231 {
 800     function  int shmget(key_t key, int size, int shmflg);
 801     implementation direct;
 802 }
 803
 804 ADD 232 {
 805     function  int clock_gettime(clockid_t clock_id, timespec_1_2_0_ptr tp);
 806     implementation direct;
 807 }
 808
 809 ADD 233 {
 810     function  int clock_settime(clockid_t clock_id,
 811                                 const_timespec_1_2_0_ptr tp);
 812     implementation direct;
 813 }
 814
 815 ADD 234 {
 816     function  int clock_getres(clockid_t clock_id, timespec_1_2_0_ptr tp);
 817     implementation direct;
 818 }
 819
 820 ADD 240 {
 821     function  int nanosleep(const_timespec_1_2_0_ptr rqtp,
 822                             timespec_1_2_0_ptr rmtp);
 823     implementation direct;
 824 }
 825
 826 ADD 250 {
 827     function  int minherit(void_ptr addr, size_t len, int inherit);
 828     implementation direct;
 829 }
 830
 831 ADD 251 {
 832     function  int rfork(int flags);
 833     implementation direct;
 834 }
 835
 836 ADD 252 {
 837     function  int openbsd_poll(pollfd_1_2_0_ptr fds, u_int nfds, int timeout);
 838     implementation direct;
 839 }
 840
 841 ADD 253 {
 842     function  int issetugid(void);
 843     implementation direct;
 844 }
 845
 846 ADD 254 {
 847     function  int lchown(char_ptr path, int uid, int gid);
 848     implementation direct;
 849 }
 850
 851 ADD 272 {
 852     function  int getdents(int fd, char_ptr buf, size_t count);
 853     implementation direct;
 854 }
 855
 856 ADD 274 {
 857     function  int lchmod(char_ptr path, mode_t mode);
 858     implementation direct;
 859 }
 860
 861 ADD 275 {
 862     function  int lchown(char_ptr path, uid_t uid, gid_t gid);
 863     implementation direct;
 864 }
 865
 866 ADD 276 {
 867     function  int lutimes(char_ptr path, timeval_1_2_0_ptr tptr);
 868     implementation direct;
 869 }
 870
 871 ADD 277 {
 872     function  int msync(void_ptr addr, size_t len, int flags);
 873     implementation direct;
 874 }
 875
 876 ADD 278 {
 877     function  int nstat(char_ptr path, nstat_1_2_0_ptr ub);
 878     implementation direct;
 879 }
 880
 881 ADD 279 {
 882     function  int nfstat(int fd, nstat_1_2_0_ptr sb);
 883     implementation direct;
 884 }
 885
 886 ADD 280 {
 887     function  int nlstat(char_ptr path, nstat_1_2_0_ptr ub);
 888     implementation direct;
 889 }
 890
 891 ADD 297 {
 892     function  int fhstatfs(const_fhandle_1_2_0_ptr u_fhp,
 893                            statfs_1_2_0_ptr buf);
 894     implementation direct;
 895 }
 896
 897 ADD 298 {
 898     function  int fhopen(const_fhandle_1_2_0_ptr u_fhp, int flags);
 899     implementation direct;
 900 }
 901
 902 ADD 299 {
 903     function  int fhstat(const_fhandle_1_2_0_ptr u_fhp, stat_1_2_0_ptr sb);
 904     implementation direct;
 905 }
 906
 907 ADD 300 {
 908     function  int modnext(int modid);
 909     implementation direct;
 910 }
 911
 912 ADD 301 {
 913     function  int modstat(int modid, module_stat_1_2_0_ptr stat);
 914     implementation direct;
 915 }
 916
 917 ADD 302 {
 918     function  int modfnext(int modid);
 919     implementation direct;
 920 }
 921
 922 ADD 303 {
 923     function  int modfind(const_char_ptr name);
 924     implementation direct;
 925 }
 926
 927 ADD 304 {
 928     function  int kldload(const_char_ptr file);
 929     implementation direct;
 930 }
 931
 932 ADD 305 {
 933     function  int kldunload(int fileid);
 934     implementation direct;
 935 }
 936
 937 ADD 306 {
 938     function  int kldfind(const_char_ptr file);
 939     implementation direct;
 940 }
 941
 942 ADD 307 {
 943     function  int kldnext(int fileid);
 944     implementation direct;
 945 }
 946
 947 ADD 308 {
 948     function  int kldstat(int fileid, kld_file_stat_1_2_0_ptr stat);
 949     implementation direct;
 950 }
 951
 952 ADD 309 {
 953     function  int kldfirstmod(int fileid);
 954     implementation direct;
 955 }
 956
 957 ADD 310 {
 958     function  int getsid(pid_t pid);
 959     implementation direct;
 960 }
 961
 962 ADD 311 {
 963     function  int setresuid(uid_t ruid, uid_t euid, uid_t suid);
 964     implementation direct;
 965 }
 966
 967 ADD 312 {
 968     function  int setresgid(gid_t rgid, gid_t egid, gid_t sgid);
 969     implementation direct;
 970 }
 971
 972 ADD 314 {
 973     function  int aio_return(aiocb_1_2_0_ptr aiocbp);
 974     implementation direct;
 975 }
 976
 977 ADD 315 {
 978     function  int aio_suspend(aiocb_1_2_0_ptr_const_ptr aiocbp, int nent,
 979                               const_timespec_1_2_0_ptr timeout);
 980     implementation direct;
 981 }
 982
 983 ADD 316 {
 984     function  int aio_cancel(int fd, aiocb_1_2_0_ptr aiocbp);
 985     implementation direct;
 986 }
 987
 988 ADD 317 {
 989     function  int aio_error(aiocb_1_2_0_ptr aiocbp);
 990     implementation direct;
 991 }
 992
 993 ADD 318 {
 994     function  int aio_read(aiocb_1_2_0_ptr aiocbp);
 995     implementation direct;
 996 }
 997
 998 ADD 319 {
 999     function  int aio_write(aiocb_1_2_0_ptr aiocbp);
1000     implementation direct;
1001 }
1002
1003 ADD 320 {
1004     function  int lio_listio(int mode, aiocb_1_2_0_ptr_const_ptr acb_list,
1005                              int nent, sigevent_1_2_0_ptr sig);
1006     implementation direct;
1007 }
1008
1009 ADD 321 {
1010     function  int yield(void);
1011     implementation direct;
1012 }
1013
1014 ADD 322 {
1015     function  int thr_sleep(const_timespec_1_2_0_ptr timeout);
1016     implementation direct;
1017 }
1018
1019 ADD 323 {
1020     function  int thr_wakeup(pid_t pid);
1021     implementation direct;
1022 }
1023
1024 ADD 324 {
1025     function  int mlockall(int how);
1026     implementation direct;
1027 }
1028
1029 ADD 325 {
1030     function  int munlockall(void);
1031     implementation direct;
1032 }
1033
1034 ADD 326 {
1035     function  int __getcwd(u_char_ptr buf, u_int buflen);
1036     implementation direct;
1037 }
1038
1039 ADD 327 {
1040     function  int sched_setparam (pid_t pid,
1041                                   const_sched_param_1_2_0_ptr param);
1042     implementation direct;
1043 }
1044
1045 ADD 328 {
1046     function  int sched_getparam (pid_t pid, sched_param_1_2_0_ptr param);
1047     implementation direct;
1048 }
1049
1050 ADD 329 {
1051     function  int sched_setscheduler (pid_t pid, int policy,
1052                                       const_sched_param_1_2_0_ptr param);
1053     implementation direct;
1054 }
1055
1056 ADD 330 {
1057     function  int sched_getscheduler (pid_t pid);
1058     implementation direct;
1059 }
1060
1061 ADD 331 {
1062     function  int sched_yield (void);
1063     implementation direct;
1064 }
1065
1066 ADD 332 {
1067     function  int sched_get_priority_max (int policy);
1068     implementation direct;
1069 }
1070
1071 ADD 333 {
1072     function  int sched_get_priority_min (int policy);
1073     implementation direct;
1074 }
1075
1076 ADD 334 {
1077     function  int sched_rr_get_interval (pid_t pid,
1078                                          timespec_1_2_0_ptr interval);
1079     implementation direct;
1080 }
1081
1082 ADD 335 {
1083     function  int utrace(const_void_ptr addr, size_t len);
1084     implementation direct;
1085 }
1086
1087 ADD 337 {
1088     function  int kldsym(int fileid, int cmd, void_ptr data);
1089     implementation direct;
1090 }
1091
1092 ADD 338 {
1093     function  int jail(jail_1_2_0_ptr jail);
1094     implementation direct;
1095 }
1096
1097 ADD 340 {
1098     function  int sigprocmask(int how, const_sigset_t_ptr set, sigset_t_ptr oset);
1099     implementation direct;
1100 }
1101
1102 ADD 341 {
1103     function  int sigsuspend(const_sigset_t_ptr sigmask);
1104     implementation direct;
1105 }
1106
1107 ADD 342 {
1108     function  int sigaction(int sig, const_sigaction_1_2_0_ptr act,
1109                             sigaction_1_2_0_ptr oact);
1110     implementation direct;
1111 }
1112
1113 ADD 343 {
1114     function  int sigpending(sigset_t_ptr set);
1115     implementation direct;
1116 }
1117
1118 ADD 344 {
1119     function  int sigreturn(ucontext_t_ptr sigcntxp);
1120     implementation direct;
1121 }
1122
1123 ADD 345 {
1124     function  int sigtimedwait(const_sigset_t_ptr set, siginfo_t_ptr info,
1125                                const_timespec_1_2_0_ptr timeout);
1126     implementation direct;
1127 }
1128
1129 ADD 346 {
1130     function  int sigwaitinfo(const_sigset_t_ptr set, siginfo_t_ptr info);
1131     implementation direct;
1132 }
1133
1134 ADD 347 {
1135     function  int __acl_get_file(const_char_ptr path, acl_type_t type,
1136                                  acl_1_2_0_ptr aclp);
1137     implementation direct;
1138 }
1139
1140 ADD 348 {
1141     function  int __acl_set_file(const_char_ptr path, acl_type_t type,
1142                                  acl_1_2_0_ptr aclp);
1143     implementation direct;
1144 }
1145
1146 ADD 349 {
1147     function  int __acl_get_fd(int filedes, acl_type_t type,
1148                                acl_1_2_0_ptr aclp);
1149     implementation direct;
1150 }
1151
1152 ADD 350 {
1153     function  int __acl_set_fd(int filedes, acl_type_t type,
1154                                acl_1_2_0_ptr aclp);
1155     implementation direct;
1156 }
1157
1158 ADD 351 {
1159     function  int __acl_delete_file(const_char_ptr path, acl_type_t type);
1160     implementation direct;
1161 }
1162
1163 ADD 352 {
1164     function  int __acl_delete_fd(int filedes, acl_type_t type);
1165     implementation direct;
1166 }
1167
1168 ADD 353 {
1169     function  int __acl_aclcheck_file(const_char_ptr path, acl_type_t type,
1170                                       acl_1_2_0_ptr aclp);
1171     implementation direct;
1172 }
1173
1174 ADD 354 {
1175     function  int __acl_aclcheck_fd(int filedes, acl_type_t type,
1176                                     acl_1_2_0_ptr aclp);
1177     implementation direct;
1178 }
1179
1180 ADD 355 {
1181     function  int extattrctl(const_char_ptr path, int cmd,
1182                              const_char_ptr attrname, char_ptr arg);
1183     implementation direct;
1184 }
1185
1186 ADD 356 {
1187     function  int extattr_set_file(const_char_ptr path, const_char_ptr attrname,
1188                                    iovec_1_2_0_ptr iovp, unsigned iovcnt);
1189     implementation direct;
1190 }
1191
1192 ADD 357 {
1193     function  int extattr_get_file(const_char_ptr path, const_char_ptr attrname,
1194                                    iovec_1_2_0_ptr iovp, unsigned iovcnt);
1195     implementation direct;
1196 }
1197
1198 ADD 358 {
1199     function  int extattr_delete_file(const_char_ptr path, const_char_ptr attrname);
1200     implementation direct;
1201 }
1202
1203 ADD 359 {
1204     function  int aio_waitcomplete(aiocb_1_2_0_ptr_ptr aiocbp,
1205                                    timespec_1_2_0_ptr timeout);
1206     implementation direct;
1207 }
1208
1209 ADD 360 {
1210     function  int getresuid(uid_t_ptr ruid, uid_t_ptr euid, uid_t_ptr suid);
1211     implementation direct;
1212 }
1213
1214 ADD 361 {
1215     function  int getresgid(gid_t_ptr rgid, gid_t_ptr egid, gid_t_ptr sgid);
1216     implementation direct;
1217 }
1218
1219 ADD 362 {
1220     function  int kqueue(void);
1221     implementation direct;
1222 }
1223
1224 ADD 363 {
1225     function  int kevent(int fd,
1226                          const_kevent_1_2_0_ptr changelist, int nchanges,
1227                          kevent_1_2_0_ptr eventlist, int nevents,
1228                          const_timespec_1_2_0_ptr timeout);
1229
1230     implementation direct;
1231 }
1232
1233 ADD 393 {
1234     function  int sendfile(int fd, int s, off_t offset, size_t nbytes,
1235                            sf_hdtr_1_2_0_ptr hdtr, off_t_ptr sbytes, int flags);
1236     implementation direct;
1237 }
1238
1239 ADD 450 {
1240     function  int varsym_set(int level, const_char_ptr name, const_char_ptr data);
1241     implementation direct;
1242 }
1243
1244 ADD 451 {
1245     function  int varsym_get(int mask, const_char_ptr wild, char_ptr buf, int bufsize);
1246     implementation direct;
1247 }
1248
1249 ADD 452 {
1250     function  int varsym_list(int level, char_ptr buf, int maxsize, int_ptr marker);
1251     implementation direct;
1252 }
1253
1254 ADD 453 {
1255     function  int upc_register(upcall_1_2_0_ptr upc, void_ptr ctxfunc,
1256                                void_ptr func, void_ptr data);
1257     implementation direct;
1258 }
1259
1260 ADD 454 {
1261     function  int upc_control(int cmd, int upcid, void_ptr data);
1262     implementation direct;
1263 }
1264
1265 ADD 455 {
1266     function  int caps_sys_service(const_char_ptr name, uid_t uid, gid_t gid, int upcid, int flags);
1267     implementation direct;
1268 }
1269
1270 ADD 456 {
1271     function  int caps_sys_client(const_char_ptr name, uid_t uid, gid_t gid, int upcid, int flags);
1272     implementation direct;
1273 }
1274
1275 ADD 457 {
1276     function  int caps_sys_close(int portid);
1277     implementation direct;
1278 }
1279
1280 ADD 458 {
1281     function  off_t caps_sys_put(int portid, void_ptr msg, int msgsize);
1282     implementation direct;
1283 }
1284
1285 ADD 459 {
1286     function  int caps_sys_reply(int portid, void_ptr msg, int msgsize, off_t msgcid);
1287     implementation direct;
1288 }
1289
1290 ADD 460 {
1291     function  int caps_sys_get(int portid, void_ptr msg, int maxsize,
1292                                caps_msgid_1_2_0_ptr msgid,
1293                                caps_cred_1_2_0_ptr ccr);
1294     implementation direct;
1295 }
1296
1297 ADD 461 {
1298     function  int caps_sys_wait(int portid, void_ptr msg, int maxsize,
1299                                 caps_msgid_1_2_0_ptr msgid,
1300                                 caps_cred_1_2_0_ptr ccr);
1301     implementation direct;
1302 }
1303
1304 ADD 462 {
1305     function  int caps_sys_abort(int portid, off_t msgcid, int flags);
1306     implementation direct;
1307 }
1308
1309 ADD 463 {
1310     function  off_t caps_sys_getgen(int portid);
1311     implementation direct;
1312 }
1313
1314 ADD 464 {
1315     function  int caps_sys_setgen(int portid, off_t gen);
1316     implementation direct;
1317 }
1318
1319 ADD 465 {
1320     function  int exec_sys_register(void_ptr entry);
1321     implementation direct;
1322 }
1323
1324 ADD 466 {
1325     function  int exec_sys_unregister(int id);
1326     implementation direct;
1327 }
1328
1329 ADD 467 {
1330     function  int sys_checkpoint(int type, int fd, pid_t pid, int retval);
1331     implementation direct;
1332 }
1333
1334 ADD 468 {
1335     function  int mountctl(const_char_ptr path, int op, int fd,
1336                            const_void_ptr ctl, int ctllen, void_ptr buf,
1337                            int buflen);
1338     implementation direct;
1339 }
1340
1341 ADD 469 {
1342     function  int umtx_sleep(volatile_const_int_ptr ptr, int value,
1343                              int timeout);
1344     implementation direct;
1345 }
1346
1347 ADD 470 {
1348     function  int umtx_wakeup(volatile_const_int_ptr ptr, int count);
1349     implementation direct;
1350 }
1351
1352 ADD 471 {
1353     function  int jail_attach(int jid);
1354     implementation direct;
1355 }
1356
1357 ADD 472 {
1358     function  int sys_set_tls_area(int which, tls_info_1_2_0_ptr info,
1359                                    size_t infosize);
1360     implementation direct;
1361 }
1362
1363 ADD 473 {
1364     function  int sys_get_tls_area(int which, tls_info_1_2_0_ptr info,
1365                                    size_t infosize);
1366     implementation direct;
1367 }
1368
1369 ADD 474 {
1370     function  int closefrom(int fd);
1371     implementation direct;
1372 }
1373