The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/kern/syscalls.master

Version: -  FREEBSD  -  FREEBSD11  -  FREEBSD10  -  FREEBSD9  -  FREEBSD92  -  FREEBSD91  -  FREEBSD90  -  FREEBSD8  -  FREEBSD82  -  FREEBSD81  -  FREEBSD80  -  FREEBSD7  -  FREEBSD74  -  FREEBSD73  -  FREEBSD72  -  FREEBSD71  -  FREEBSD70  -  FREEBSD6  -  FREEBSD64  -  FREEBSD63  -  FREEBSD62  -  FREEBSD61  -  FREEBSD60  -  FREEBSD5  -  FREEBSD55  -  FREEBSD54  -  FREEBSD53  -  FREEBSD52  -  FREEBSD51  -  FREEBSD50  -  FREEBSD4  -  FREEBSD3  -  FREEBSD22  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1 
SearchContext: -  none  -  3  -  10 

    1         $NetBSD: syscalls.master,v 1.248 2011/03/09 22:12:45 pooka Exp $
    2 
    3 ;       @(#)syscalls.master     8.2 (Berkeley) 1/13/94
    4 
    5 ; NetBSD system call name/number "master" file.
    6 ; (See syscalls.conf to see what it is processed into.)
    7 ;
    8 ; Fields: number type [type-dependent ...]
    9 ;       number  system call number, must be in order
   10 ;       type    one of STD, OBSOL, UNIMPL, IGNORED, NODEF, NOARGS, or one of
   11 ;               the compatibility options defined in syscalls.conf.
   12 ;
   13 ; Optional fields are specified after the type field
   14 ; (NOTE! they *must* be specified in this order):
   15 ;       MODULAR:attempt to autoload system call if not present
   16 ;       RUMP:   generate rump syscall entry point
   17 ;
   18 ; types:
   19 ;       STD     always included
   20 ;       OBSOL   obsolete, not included in system
   21 ;       IGNORED syscall is a null op, but always succeeds
   22 ;       UNIMPL  unimplemented, not included in system
   23 ;       EXCL    implemented, but not included in system
   24 ;       NODEF   included, but don't define the syscall number
   25 ;       NOARGS  included, but don't define the syscall args structure
   26 ;       INDIR   included, but don't define the syscall args structure,
   27 ;               and allow it to be "really" varargs.
   28 ;       NOERR   included, syscall does not set errno
   29 ;
   30 ; arguments:
   31 ;       PAD     argument not part of the C interface, used only for padding
   32 ;
   33 ; The compat options are defined in the syscalls.conf file, and the
   34 ; compat option name is prefixed to the syscall name.  Other than
   35 ; that, they're like NODEF (for 'compat' options), or STD (for
   36 ; 'libcompat' options).
   37 ;
   38 ; The type-dependent arguments are as follows:
   39 ; For STD, NODEF, NOARGS, and compat syscalls:
   40 ;       { return_type|prefix|compat(optional)|basename(pseudo-proto); } [alias]
   41 ; For other syscalls:
   42 ;       [comment]
   43 ;
   44 ; #ifdef's, etc. may be included, and are copied to the output files.
   45 ; #include's are copied to the syscall names and switch definition files only.
   46 
   47 #include "opt_modular.h"
   48 #include "opt_ntp.h"
   49 #include "opt_sysv.h"
   50 
   51 #include <sys/param.h>
   52 #include <sys/systm.h>
   53 #include <sys/signal.h>
   54 #include <sys/mount.h>
   55 #include <sys/sched.h>
   56 #include <sys/syscallargs.h>
   57 
   58 %%
   59 
   60 ; Reserved/unimplemented system calls in the range 0-150 inclusive
   61 ; are reserved for use in future Berkeley releases.
   62 ; Additional system calls implemented in vendor and other
   63 ; redistributions should be placed in the reserved range at the end
   64 ; of the current calls.
   65 
   66 0       INDIR           { int|sys||syscall(int code, \
   67                             ... register_t args[SYS_MAXSYSARGS]); }
   68 1       STD             { void|sys||exit(int rval); }
   69 2       STD             { int|sys||fork(void); }
   70 3       STD      RUMP   { ssize_t|sys||read(int fd, void *buf, size_t nbyte); }
   71 4       STD      RUMP   { ssize_t|sys||write(int fd, const void *buf, \
   72                             size_t nbyte); }
   73 5       STD      RUMP   { int|sys||open(const char *path, \
   74                             int flags, ... mode_t mode); }
   75 6       STD      RUMP   { int|sys||close(int fd); }
   76 7       COMPAT_50 MODULAR { int|sys||wait4(pid_t pid, int *status, \
   77                             int options, struct rusage50 *rusage); }
   78 8       COMPAT_43 MODULAR { int|sys||creat(const char *path, mode_t mode); } ocreat
   79 9       STD      RUMP   { int|sys||link(const char *path, const char *link); }
   80 10      STD      RUMP   { int|sys||unlink(const char *path); }
   81 11      OBSOL           execv
   82 12      STD      RUMP   { int|sys||chdir(const char *path); }
   83 13      STD      RUMP   { int|sys||fchdir(int fd); }
   84 14      COMPAT_50 MODULAR RUMP { int|sys||mknod(const char *path, mode_t mode, \
   85                             uint32_t dev); }
   86 15      STD      RUMP   { int|sys||chmod(const char *path, mode_t mode); }
   87 16      STD      RUMP   { int|sys||chown(const char *path, uid_t uid, \
   88                             gid_t gid); }
   89 17      STD             { int|sys||obreak(char *nsize); } break
   90 18      COMPAT_20 MODULAR { int|sys||getfsstat(struct statfs12 *buf, \
   91                             long bufsize, int flags); }
   92 19      COMPAT_43 MODULAR { long|sys||lseek(int fd, long offset, int whence); }\
   93                             olseek
   94 20      NOERR   RUMP    { pid_t|sys||getpid_with_ppid(void); } getpid
   95 21      COMPAT_40 MODULAR { int|sys||mount(const char *type, const char *path, \
   96                             int flags, void *data); }
   97 22      STD      RUMP   { int|sys||unmount(const char *path, int flags); }
   98 23      STD     RUMP    { int|sys||setuid(uid_t uid); }
   99 24      NOERR   RUMP    { uid_t|sys||getuid_with_euid(void); } getuid
  100 25      NOERR   RUMP    { uid_t|sys||geteuid(void); }
  101 26      STD             { int|sys||ptrace(int req, pid_t pid, void *addr, \
  102                             int data); }
  103 27      STD     RUMP    { ssize_t|sys||recvmsg(int s, struct msghdr *msg, \
  104                             int flags); }
  105 28      STD     RUMP    { ssize_t|sys||sendmsg(int s, \
  106                             const struct msghdr *msg, int flags); }
  107 29      STD     RUMP    { ssize_t|sys||recvfrom(int s, void *buf, size_t len, \
  108                             int flags, struct sockaddr *from, \
  109                             unsigned int *fromlenaddr); }
  110 30      STD     RUMP    { int|sys||accept(int s, struct sockaddr *name, \
  111                             unsigned int *anamelen); }
  112 31      STD     RUMP    { int|sys||getpeername(int fdes, struct sockaddr *asa, \
  113                             unsigned int *alen); }
  114 32      STD     RUMP    { int|sys||getsockname(int fdes, struct sockaddr *asa, \
  115                             unsigned int *alen); }
  116 33      STD     RUMP    { int|sys||access(const char *path, int flags); }
  117 34      STD      RUMP   { int|sys||chflags(const char *path, u_long flags); }
  118 35      STD     RUMP    { int|sys||fchflags(int fd, u_long flags); }
  119 36      NOERR    RUMP   { void|sys||sync(void); }
  120 37      STD             { int|sys||kill(pid_t pid, int signum); }
  121 38      COMPAT_43 MODULAR { int|sys||stat(const char *path, struct stat43 *ub); } \
  122                             stat43
  123 39      NOERR   RUMP    { pid_t|sys||getppid(void); }
  124 40      COMPAT_43 MODULAR { int|sys||lstat(const char *path, \
  125                             struct stat43 *ub); } lstat43
  126 41      STD     RUMP    { int|sys||dup(int fd); }
  127 42      STD     RUMP    { int|sys||pipe(void); }
  128 43      NOERR   RUMP    { gid_t|sys||getegid(void); }
  129 44      STD             { int|sys||profil(char *samples, size_t size, \
  130                             u_long offset, u_int scale); }
  131 45      STD             { int|sys||ktrace(const char *fname, int ops, \
  132                             int facs, pid_t pid); }
  133 46      COMPAT_13 MODULAR { int|sys||sigaction(int signum, \
  134                             const struct sigaction13 *nsa, \
  135                             struct sigaction13 *osa); } sigaction13
  136 47      NOERR   RUMP    { gid_t|sys||getgid_with_egid(void); } getgid
  137 48      COMPAT_13 MODULAR { int|sys||sigprocmask(int how, \
  138                             int mask); } sigprocmask13
  139 49      STD     RUMP    { int|sys||__getlogin(char *namebuf, size_t namelen); }
  140 50      STD     RUMP    { int|sys||__setlogin(const char *namebuf); }
  141 51      STD             { int|sys||acct(const char *path); }
  142 52      COMPAT_13 MODULAR { int|sys||sigpending(void); } sigpending13
  143 53      COMPAT_13 MODULAR { int|sys||sigaltstack( \
  144                             const struct sigaltstack13 *nss, \
  145                             struct sigaltstack13 *oss); } sigaltstack13
  146 54      STD     RUMP    { int|sys||ioctl(int fd, \
  147                             u_long com, ... void *data); }
  148 55      COMPAT_12 MODULAR { int|sys||reboot(int opt); } oreboot
  149 56      STD      RUMP   { int|sys||revoke(const char *path); }
  150 57      STD      RUMP   { int|sys||symlink(const char *path, \
  151                             const char *link); }
  152 58      STD      RUMP   { ssize_t|sys||readlink(const char *path, char *buf, \
  153                             size_t count); }
  154 59      STD             { int|sys||execve(const char *path, \
  155                             char * const *argp, char * const *envp); }
  156 60      STD      RUMP   { mode_t|sys||umask(mode_t newmask); }
  157 61      STD      RUMP   { int|sys||chroot(const char *path); }
  158 62      COMPAT_43 MODULAR { int|sys||fstat(int fd, struct stat43 *sb); } fstat43
  159 63      COMPAT_43 MODULAR { int|sys||getkerninfo(int op, char *where, int *size, \
  160                             int arg); } ogetkerninfo
  161 64      COMPAT_43 MODULAR { int|sys||getpagesize(void); } ogetpagesize
  162 65      COMPAT_12 MODULAR { int|sys||msync(void *addr, size_t len); }
  163 ; XXX COMPAT_??? for 4.4BSD-compatible vfork(2)?
  164 66      STD             { int|sys||vfork(void); }
  165 67      OBSOL           vread
  166 68      OBSOL           vwrite
  167 69      STD             { int|sys||sbrk(intptr_t incr); }
  168 70      STD             { int|sys||sstk(int incr); }
  169 71      COMPAT_43 MODULAR { int|sys||mmap(void *addr, size_t len, int prot, \
  170                             int flags, int fd, long pos); } ommap
  171 72      STD             { int|sys||ovadvise(int anom); } vadvise
  172 73      STD             { int|sys||munmap(void *addr, size_t len); }
  173 74      STD             { int|sys||mprotect(void *addr, size_t len, \
  174                             int prot); }
  175 75      STD             { int|sys||madvise(void *addr, size_t len, \
  176                             int behav); }
  177 76      OBSOL           vhangup
  178 77      OBSOL           vlimit
  179 78      STD             { int|sys||mincore(void *addr, size_t len, \
  180                             char *vec); }
  181 79      STD     RUMP    { int|sys||getgroups(int gidsetsize, \
  182                             gid_t *gidset); }
  183 80      STD     RUMP    { int|sys||setgroups(int gidsetsize, \
  184                             const gid_t *gidset); }
  185 81      STD     RUMP    { int|sys||getpgrp(void); }
  186 82      STD     RUMP    { int|sys||setpgid(pid_t pid, pid_t pgid); }
  187 83      COMPAT_50 MODULAR { int|sys||setitimer(int which, \
  188                             const struct itimerval50 *itv, \
  189                             struct itimerval50 *oitv); }
  190 84      COMPAT_43 MODULAR { int|sys||wait(void); } owait
  191 85      COMPAT_12 MODULAR { int|sys||swapon(const char *name); } oswapon
  192 86      COMPAT_50 MODULAR { int|sys||getitimer(int which, \
  193                             struct itimerval50 *itv); }
  194 87      COMPAT_43 MODULAR { int|sys||gethostname(char *hostname, u_int len); } \
  195                             ogethostname
  196 88      COMPAT_43 MODULAR { int|sys||sethostname(char *hostname, u_int len); } \
  197                             osethostname
  198 89      COMPAT_43 MODULAR { int|sys||getdtablesize(void); } ogetdtablesize
  199 90      STD      RUMP   { int|sys||dup2(int from, int to); }
  200 91      UNIMPL          getdopt
  201 92      STD     RUMP    { int|sys||fcntl(int fd, int cmd, ... void *arg); }
  202 93      COMPAT_50 MODULAR RUMP  { int|sys||select(int nd, fd_set *in, fd_set *ou, \
  203                             fd_set *ex, struct timeval50 *tv); }
  204 94      UNIMPL          setdopt
  205 95      STD     RUMP    { int|sys||fsync(int fd); }
  206 96      STD             { int|sys||setpriority(int which, id_t who, int prio); }
  207 97      COMPAT_30 MODULAR { int|sys||socket(int domain, int type, int protocol); }
  208 98      STD     RUMP    { int|sys||connect(int s, const struct sockaddr *name, \
  209                             unsigned int namelen); }
  210 99      COMPAT_43 MODULAR { int|sys||accept(int s, void *name, \
  211                             int *anamelen); } oaccept
  212 100     STD             { int|sys||getpriority(int which, id_t who); }
  213 101     COMPAT_43 MODULAR { int|sys||send(int s, void *buf, int len, \
  214                             int flags); } osend
  215 102     COMPAT_43 MODULAR { int|sys||recv(int s, void *buf, int len, \
  216                             int flags); } orecv
  217 103     COMPAT_13 MODULAR { int|sys||sigreturn(struct sigcontext13 *sigcntxp); } \
  218                             sigreturn13
  219 104     STD     RUMP    { int|sys||bind(int s, const struct sockaddr *name, \
  220                             unsigned int namelen); }
  221 105     STD     RUMP    { int|sys||setsockopt(int s, int level, int name, \
  222                             const void *val, unsigned int valsize); }
  223 106     STD     RUMP    { int|sys||listen(int s, int backlog); }
  224 107     OBSOL           vtimes
  225 108     COMPAT_43 MODULAR { int|sys||sigvec(int signum, struct sigvec *nsv, \
  226                             struct sigvec *osv); } osigvec
  227 109     COMPAT_43 MODULAR { int|sys||sigblock(int mask); } osigblock
  228 110     COMPAT_43 MODULAR { int|sys||sigsetmask(int mask); } osigsetmask
  229 111     COMPAT_13 MODULAR { int|sys||sigsuspend(int mask); } sigsuspend13
  230 112     COMPAT_43 MODULAR { int|sys||sigstack(struct sigstack *nss, \
  231                             struct sigstack *oss); } osigstack
  232 113     COMPAT_43 MODULAR { int|sys||recvmsg(int s, struct omsghdr *msg, \
  233                             int flags); } orecvmsg
  234 114     COMPAT_43 MODULAR { int|sys||sendmsg(int s, void *msg, int flags); } \
  235                             osendmsg
  236 115     OBSOL           vtrace
  237 116     COMPAT_50 MODULAR { int|sys||gettimeofday(struct timeval50 *tp, \
  238                             void *tzp); }
  239 117     COMPAT_50 MODULAR { int|sys||getrusage(int who, struct rusage50 *rusage); }
  240 118     STD     RUMP    { int|sys||getsockopt(int s, int level, int name, \
  241                             void *val, unsigned int *avalsize); }
  242 119     OBSOL           resuba
  243 120     STD     RUMP    { ssize_t|sys||readv(int fd, \
  244                             const struct iovec *iovp, int iovcnt); }
  245 121     STD     RUMP    { ssize_t|sys||writev(int fd, \
  246                             const struct iovec *iovp, int iovcnt); }
  247 122     COMPAT_50 MODULAR { int|sys||settimeofday(const struct timeval50 *tv, \
  248                             const void *tzp); }
  249 123     STD      RUMP   { int|sys||fchown(int fd, uid_t uid, gid_t gid); }
  250 124     STD      RUMP   { int|sys||fchmod(int fd, mode_t mode); }
  251 125     COMPAT_43 MODULAR { int|sys||recvfrom(int s, void *buf, size_t len, \
  252                             int flags, void *from, int *fromlenaddr); } \
  253                             orecvfrom
  254 126     STD     RUMP    { int|sys||setreuid(uid_t ruid, uid_t euid); }
  255 127     STD     RUMP    { int|sys||setregid(gid_t rgid, gid_t egid); }
  256 128     STD      RUMP   { int|sys||rename(const char *from, const char *to); }
  257 129     COMPAT_43 MODULAR { int|sys||truncate(const char *path, long length); } \
  258                             otruncate
  259 130     COMPAT_43 MODULAR { int|sys||ftruncate(int fd, long length); } oftruncate
  260 131     STD      RUMP   { int|sys||flock(int fd, int how); }
  261 132     STD      RUMP   { int|sys||mkfifo(const char *path, mode_t mode); }
  262 133     STD      RUMP   { ssize_t|sys||sendto(int s, const void *buf, \
  263                             size_t len, int flags, const struct sockaddr *to, \
  264                             unsigned int tolen); }
  265 134     STD      RUMP   { int|sys||shutdown(int s, int how); }
  266 135     STD      RUMP   { int|sys||socketpair(int domain, int type, \
  267                             int protocol, int *rsv); }
  268 136     STD      RUMP   { int|sys||mkdir(const char *path, mode_t mode); }
  269 137     STD      RUMP   { int|sys||rmdir(const char *path); }
  270 138     COMPAT_50 MODULAR RUMP { int|sys||utimes(const char *path, \
  271                             const struct timeval50 *tptr); }
  272 139     OBSOL           4.2 sigreturn
  273 140     COMPAT_50 MODULAR { int|sys||adjtime(const struct timeval50 *delta, \
  274                             struct timeval50 *olddelta); }
  275 141     COMPAT_43 MODULAR { int|sys||getpeername(int fdes, void *asa, \
  276                             int *alen); } ogetpeername
  277 142     COMPAT_43 MODULAR { int32_t|sys||gethostid(void); } ogethostid
  278 143     COMPAT_43 MODULAR { int|sys||sethostid(int32_t hostid); } osethostid
  279 144     COMPAT_43 MODULAR { int|sys||getrlimit(int which, \
  280                             struct orlimit *rlp); } ogetrlimit
  281 145     COMPAT_43 MODULAR { int|sys||setrlimit(int which, \
  282                             const struct orlimit *rlp); } osetrlimit
  283 146     COMPAT_43 MODULAR { int|sys||killpg(int pgid, int signum); } okillpg
  284 147     STD     RUMP    { int|sys||setsid(void); }
  285 148     COMPAT_50 MODULAR { int|sys||quotactl(const char *path, int cmd, \
  286                             int uid, void *arg); }
  287 149     COMPAT_43 MODULAR { int|sys||quota(void); } oquota
  288 150     COMPAT_43 MODULAR { int|sys||getsockname(int fdec, void *asa, \
  289                             int *alen); } ogetsockname
  290 
  291 ; Syscalls 151-180 inclusive are reserved for vendor-specific
  292 ; system calls.  (This includes various calls added for compatibity
  293 ; with other Unix variants.)
  294 ; Some of these calls are now supported by BSD...
  295 151     UNIMPL
  296 152     UNIMPL
  297 153     UNIMPL
  298 154     UNIMPL
  299 155     STD MODULAR RUMP  { int|sys||nfssvc(int flag, void *argp); }
  300 156     COMPAT_43 MODULAR { int|sys||getdirentries(int fd, char *buf, \
  301                             u_int count, long *basep); } ogetdirentries
  302 157     COMPAT_20 MODULAR { int|sys||statfs(const char *path, \
  303                             struct statfs12 *buf); }
  304 158     COMPAT_20 MODULAR { int|sys||fstatfs(int fd, struct statfs12 *buf); }
  305 159     UNIMPL
  306 160     UNIMPL
  307 161     COMPAT_30 MODULAR { int|sys||getfh(const char *fname, \
  308                             struct compat_30_fhandle *fhp); }
  309 162     COMPAT_09 MODULAR { int|sys||getdomainname(char *domainname, int len); } \
  310                             ogetdomainname
  311 163     COMPAT_09 MODULAR { int|sys||setdomainname(char *domainname, int len); } \
  312                             osetdomainname
  313 164     COMPAT_09 MODULAR { int|sys||uname(struct outsname *name); } ouname
  314 165     STD             { int|sys||sysarch(int op, void *parms); }
  315 166     UNIMPL
  316 167     UNIMPL
  317 168     UNIMPL
  318 ; XXX more generally, never on machines where sizeof(void *) != sizeof(int)
  319 #if (defined(SYSVSEM) || !defined(_KERNEL_OPT)) && !defined(_LP64)
  320 169     COMPAT_10 MODULAR { int|sys||semsys(int which, int a2, int a3, int a4, \
  321                             int a5); } osemsys
  322 #else
  323 169     EXCL            1.0 semsys
  324 #endif
  325 ; XXX more generally, never on machines where sizeof(void *) != sizeof(int)
  326 #if (defined(SYSVMSG) || !defined(_KERNEL_OPT)) && !defined(_LP64)
  327 170     COMPAT_10 MODULAR { int|sys||msgsys(int which, int a2, int a3, int a4, \
  328                             int a5, int a6); } omsgsys
  329 #else
  330 170     EXCL            1.0 msgsys
  331 #endif
  332 ; XXX more generally, never on machines where sizeof(void *) != sizeof(int)
  333 #if (defined(SYSVSHM) || !defined(_KERNEL_OPT)) && !defined(_LP64)
  334 171     COMPAT_10 MODULAR { int|sys||shmsys(int which, int a2, int a3, int a4); } \
  335                             oshmsys
  336 #else
  337 171     EXCL            1.0 shmsys
  338 #endif
  339 172     UNIMPL
  340 173     STD      RUMP   { ssize_t|sys||pread(int fd, void *buf, \
  341                             size_t nbyte, int PAD, off_t offset); }
  342 174     STD      RUMP   { ssize_t|sys||pwrite(int fd, const void *buf, \
  343                             size_t nbyte, int PAD, off_t offset); }
  344 ; For some reason, ntp_gettime doesn't want to raise SIGSYS when it's excluded.
  345 175     COMPAT_30       { int|sys||ntp_gettime(struct ntptimeval30 *ntvp); }
  346 #if defined(NTP) || !defined(_KERNEL_OPT)
  347 176     STD             { int|sys||ntp_adjtime(struct timex *tp); }
  348 #else
  349 176     EXCL            ntp_adjtime
  350 #endif
  351 177     UNIMPL
  352 178     UNIMPL
  353 179     UNIMPL
  354 180     UNIMPL
  355 
  356 ; Syscalls 180-199 are used by/reserved for BSD
  357 181     STD     RUMP    { int|sys||setgid(gid_t gid); }
  358 182     STD     RUMP    { int|sys||setegid(gid_t egid); }
  359 183     STD     RUMP    { int|sys||seteuid(uid_t euid); }
  360 184     STD MODULAR     { int|sys||lfs_bmapv(fsid_t *fsidp, \
  361                             struct block_info *blkiov, int blkcnt); }
  362 185     STD MODULAR     { int|sys||lfs_markv(fsid_t *fsidp, \
  363                             struct block_info *blkiov, int blkcnt); }
  364 186     STD MODULAR     { int|sys||lfs_segclean(fsid_t *fsidp, u_long segment); }
  365 187     COMPAT_50 MODULAR { int|sys||lfs_segwait(fsid_t *fsidp, \
  366                             struct timeval50 *tv); }
  367 188     COMPAT_12 MODULAR { int|sys||stat(const char *path, struct stat12 *ub); } \
  368                             stat12
  369 189     COMPAT_12 MODULAR { int|sys||fstat(int fd, struct stat12 *sb); } fstat12
  370 190     COMPAT_12 MODULAR { int|sys||lstat(const char *path, \
  371                             struct stat12 *ub); } lstat12
  372 191     STD     RUMP    { long|sys||pathconf(const char *path, int name); }
  373 192     STD     RUMP    { long|sys||fpathconf(int fd, int name); }
  374 193     UNIMPL
  375 194     STD     RUMP    { int|sys||getrlimit(int which, \
  376                             struct rlimit *rlp); }
  377 195     STD     RUMP    { int|sys||setrlimit(int which, \
  378                             const struct rlimit *rlp); }
  379 196     COMPAT_12 MODULAR { int|sys||getdirentries(int fd, char *buf, \
  380                             u_int count, long *basep); }
  381 197     STD             { void *|sys||mmap(void *addr, size_t len, int prot, \
  382                             int flags, int fd, long PAD, off_t pos); }
  383 198     INDIR           { quad_t|sys||__syscall(quad_t code, \
  384                             ... register_t args[SYS_MAXSYSARGS]); }
  385 199     STD      RUMP   { off_t|sys||lseek(int fd, int PAD, off_t offset, \
  386                             int whence); }
  387 200     STD      RUMP   { int|sys||truncate(const char *path, int PAD, \
  388                             off_t length); }
  389 201     STD      RUMP   { int|sys||ftruncate(int fd, int PAD, off_t length); }
  390 202     STD      RUMP   { int|sys||__sysctl(const int *name, u_int namelen, \
  391                             void *old, size_t *oldlenp, const void *new, \
  392                             size_t newlen); }
  393 203     STD             { int|sys||mlock(const void *addr, size_t len); }
  394 204     STD             { int|sys||munlock(const void *addr, size_t len); }
  395 205     STD             { int|sys||undelete(const char *path); }
  396 206     COMPAT_50 MODULAR RUMP { int|sys||futimes(int fd, \
  397                             const struct timeval50 *tptr); }
  398 207     STD      RUMP   { pid_t|sys||getpgid(pid_t pid); }
  399 208     STD      RUMP   { int|sys||reboot(int opt, char *bootstr); }
  400 209     STD      RUMP   { int|sys||poll(struct pollfd *fds, u_int nfds, \
  401                             int timeout); }
  402 ;
  403 ; Syscalls 210-219 are reserved for dynamically loaded syscalls
  404 ;
  405 210     UNIMPL
  406 211     UNIMPL
  407 212     UNIMPL
  408 213     UNIMPL
  409 214     UNIMPL
  410 215     UNIMPL
  411 216     UNIMPL
  412 217     UNIMPL
  413 218     UNIMPL
  414 219     UNIMPL
  415 ; System calls 220-300 are reserved for use by NetBSD
  416 #if defined(SYSVSEM) || !defined(_KERNEL_OPT)
  417 220     COMPAT_14 MODULAR { int|sys||__semctl(int semid, int semnum, int cmd, \
  418                             union __semun *arg); }
  419 221     STD             { int|sys||semget(key_t key, int nsems, int semflg); }
  420 222     STD             { int|sys||semop(int semid, struct sembuf *sops, \
  421                             size_t nsops); }
  422 223     STD             { int|sys||semconfig(int flag); }
  423 #else
  424 220     EXCL            compat_14_semctl
  425 221     EXCL            semget
  426 222     EXCL            semop
  427 223     EXCL            semconfig
  428 #endif
  429 #if defined(SYSVMSG) || !defined(_KERNEL_OPT)
  430 224     COMPAT_14 MODULAR { int|sys||msgctl(int msqid, int cmd, \
  431                             struct msqid_ds14 *buf); }
  432 225     STD             { int|sys||msgget(key_t key, int msgflg); }
  433 226     STD             { int|sys||msgsnd(int msqid, const void *msgp, \
  434                             size_t msgsz, int msgflg); }
  435 227     STD             { ssize_t|sys||msgrcv(int msqid, void *msgp, \
  436                             size_t msgsz, long msgtyp, int msgflg); }
  437 #else
  438 224     EXCL            compat_14_msgctl
  439 225     EXCL            msgget
  440 226     EXCL            msgsnd
  441 227     EXCL            msgrcv
  442 #endif
  443 #if defined(SYSVSHM) || !defined(_KERNEL_OPT)
  444 228     STD             { void *|sys||shmat(int shmid, const void *shmaddr, \
  445                             int shmflg); }
  446 229     COMPAT_14 MODULAR { int|sys||shmctl(int shmid, int cmd, \
  447                             struct shmid_ds14 *buf); }
  448 230     STD             { int|sys||shmdt(const void *shmaddr); }
  449 231     STD             { int|sys||shmget(key_t key, size_t size, int shmflg); }
  450 #else
  451 228     EXCL            shmat
  452 229     EXCL            compat_14_shmctl
  453 230     EXCL            shmdt
  454 231     EXCL            shmget
  455 #endif
  456 232     COMPAT_50 MODULAR { int|sys||clock_gettime(clockid_t clock_id, \
  457                             struct timespec50 *tp); }
  458 233     COMPAT_50 MODULAR { int|sys||clock_settime(clockid_t clock_id, \
  459                             const struct timespec50 *tp); }
  460 234     COMPAT_50 MODULAR { int|sys||clock_getres(clockid_t clock_id, \
  461                             struct timespec50 *tp); }
  462 235     STD             { int|sys||timer_create(clockid_t clock_id, \
  463                             struct sigevent *evp, timer_t *timerid); }
  464 236     STD             { int|sys||timer_delete(timer_t timerid); }
  465 237     COMPAT_50 MODULAR { int|sys||timer_settime(timer_t timerid, int flags, \
  466                             const struct itimerspec50 *value, \
  467                             struct itimerspec50 *ovalue); }
  468 238     COMPAT_50 MODULAR { int|sys||timer_gettime(timer_t timerid, struct \
  469                             itimerspec50 *value); }
  470 239     STD             { int|sys||timer_getoverrun(timer_t timerid); }
  471 ;
  472 ; Syscalls 240-269 are reserved for other IEEE Std1003.1b syscalls
  473 ;
  474 240     COMPAT_50 MODULAR { int|sys||nanosleep(const struct timespec50 *rqtp, \
  475                             struct timespec50 *rmtp); }
  476 241     STD      RUMP   { int|sys||fdatasync(int fd); }
  477 242     STD             { int|sys||mlockall(int flags); }
  478 243     STD             { int|sys||munlockall(void); }
  479 244     COMPAT_50 MODULAR { int|sys||__sigtimedwait(const sigset_t *set, \
  480                             siginfo_t *info, \
  481                             struct timespec50 *timeout); }
  482 245     STD             { int|sys||sigqueueinfo(pid_t pid, \
  483                             const siginfo_t *info); }
  484 246     STD RUMP        { int|sys||modctl(int cmd, void *arg); }
  485 247     STD MODULAR RUMP { int|sys||_ksem_init(unsigned int value, intptr_t *idp); }
  486 248     STD MODULAR RUMP { int|sys||_ksem_open(const char *name, int oflag, \
  487                             mode_t mode, unsigned int value, intptr_t *idp); }
  488 249     STD MODULAR RUMP { int|sys||_ksem_unlink(const char *name); }
  489 250     STD MODULAR RUMP { int|sys||_ksem_close(intptr_t id); }
  490 251     STD MODULAR RUMP { int|sys||_ksem_post(intptr_t id); }
  491 252     STD MODULAR RUMP { int|sys||_ksem_wait(intptr_t id); }
  492 253     STD MODULAR RUMP { int|sys||_ksem_trywait(intptr_t id); }
  493 254     STD MODULAR RUMP { int|sys||_ksem_getvalue(intptr_t id, \
  494                             unsigned int *value); }
  495 255     STD MODULAR RUMP { int|sys||_ksem_destroy(intptr_t id); }
  496 256     UNIMPL          sys__ksem_timedwait
  497 257     STD MODULAR     { mqd_t|sys||mq_open(const char * name, int oflag, \
  498                             mode_t mode, struct mq_attr *attr); }
  499 258     STD MODULAR     { int|sys||mq_close(mqd_t mqdes); }
  500 259     STD MODULAR     { int|sys||mq_unlink(const char *name); }
  501 260     STD MODULAR     { int|sys||mq_getattr(mqd_t mqdes, \
  502                             struct mq_attr *mqstat); }
  503 261     STD MODULAR     { int|sys||mq_setattr(mqd_t mqdes, \
  504                             const struct mq_attr *mqstat, \
  505                             struct mq_attr *omqstat); }
  506 262     STD MODULAR     { int|sys||mq_notify(mqd_t mqdes, \
  507                             const struct sigevent *notification); }
  508 263     STD MODULAR     { int|sys||mq_send(mqd_t mqdes, const char *msg_ptr, \
  509                             size_t msg_len, unsigned msg_prio); }
  510 264     STD MODULAR     { ssize_t|sys||mq_receive(mqd_t mqdes, char *msg_ptr, \
  511                             size_t msg_len, unsigned *msg_prio); }
  512 265     COMPAT_50 MODULAR { int|sys||mq_timedsend(mqd_t mqdes, \
  513                             const char *msg_ptr, size_t msg_len, \
  514                             unsigned msg_prio, \
  515                             const struct timespec50 *abs_timeout); }
  516 266     COMPAT_50 MODULAR { ssize_t|sys||mq_timedreceive(mqd_t mqdes, \
  517                             char *msg_ptr, size_t msg_len, unsigned *msg_prio, \
  518                             const struct timespec50 *abs_timeout); }
  519 267     UNIMPL
  520 268     UNIMPL
  521 269     UNIMPL
  522 270     STD             { int|sys||__posix_rename(const char *from, \
  523                             const char *to); }
  524 271     STD             { int|sys||swapctl(int cmd, void *arg, int misc); }
  525 272     COMPAT_30 MODULAR { int|sys||getdents(int fd, char *buf, size_t count); }
  526 273     STD             { int|sys||minherit(void *addr, size_t len, \
  527                             int inherit); }
  528 274     STD      RUMP   { int|sys||lchmod(const char *path, mode_t mode); }
  529 275     STD      RUMP   { int|sys||lchown(const char *path, uid_t uid, \
  530                             gid_t gid); }
  531 276     COMPAT_50 MODULAR RUMP { int|sys||lutimes(const char *path, \
  532                             const struct timeval50 *tptr); }
  533 277     STD             { int|sys|13|msync(void *addr, size_t len, int flags); }
  534 278     COMPAT_30 MODULAR { int|sys|13|stat(const char *path, struct stat13 *ub); }
  535 279     COMPAT_30 MODULAR { int|sys|13|fstat(int fd, struct stat13 *sb); }
  536 280     COMPAT_30 MODULAR { int|sys|13|lstat(const char *path, struct stat13 *ub); }
  537 281     STD             { int|sys|14|sigaltstack( \
  538                             const struct sigaltstack *nss, \
  539                             struct sigaltstack *oss); }
  540 282     STD             { int|sys|14|vfork(void); }
  541 283     STD             { int|sys||__posix_chown(const char *path, uid_t uid, \
  542                             gid_t gid); }
  543 284     STD             { int|sys||__posix_fchown(int fd, uid_t uid, \
  544                             gid_t gid); }
  545 285     STD             { int|sys||__posix_lchown(const char *path, uid_t uid, \
  546                             gid_t gid); }
  547 286     STD     RUMP    { pid_t|sys||getsid(pid_t pid); }
  548 287     STD             { pid_t|sys||__clone(int flags, void *stack); }
  549 288     STD             { int|sys||fktrace(int fd, int ops, \
  550                             int facs, pid_t pid); }
  551 289     STD     RUMP    { ssize_t|sys||preadv(int fd, \
  552                             const struct iovec *iovp, int iovcnt, \
  553                             int PAD, off_t offset); }
  554 290     STD     RUMP    { ssize_t|sys||pwritev(int fd, \
  555                             const struct iovec *iovp, int iovcnt, \
  556                             int PAD, off_t offset); }
  557 291     COMPAT_16 MODULAR { int|sys|14|sigaction(int signum, \
  558                             const struct sigaction *nsa, \
  559                             struct sigaction *osa); }
  560 292     STD             { int|sys|14|sigpending(sigset_t *set); }
  561 293     STD             { int|sys|14|sigprocmask(int how, \
  562                             const sigset_t *set, \
  563                             sigset_t *oset); }
  564 294     STD             { int|sys|14|sigsuspend(const sigset_t *set); }
  565 295     COMPAT_16 MODULAR { int|sys|14|sigreturn(struct sigcontext *sigcntxp); }
  566 296     STD      RUMP   { int|sys||__getcwd(char *bufp, size_t length); }
  567 297     STD      RUMP   { int|sys||fchroot(int fd); }
  568 298     COMPAT_30 MODULAR { int|sys||fhopen(const struct compat_30_fhandle *fhp, int flags); }
  569 299     COMPAT_30 MODULAR { int|sys||fhstat(const struct compat_30_fhandle *fhp, \
  570                             struct stat13 *sb); }
  571 300     COMPAT_20 MODULAR { int|sys||fhstatfs(const struct compat_30_fhandle *fhp, \
  572                             struct statfs12 *buf); }
  573 #if defined(SYSVSEM) || !defined(_KERNEL_OPT)
  574 301     COMPAT_50 MODULAR { int|sys|13|__semctl(int semid, int semnum, int cmd, \
  575                             ... union __semun *arg); }
  576 #else
  577 301     EXCL            ____semctl13
  578 #endif
  579 #if defined(SYSVMSG) || !defined(_KERNEL_OPT)
  580 302     COMPAT_50 MODULAR { int|sys|13|msgctl(int msqid, int cmd, \
  581                             struct msqid_ds *buf); }
  582 #else
  583 302     EXCL            __msgctl13
  584 #endif
  585 #if defined(SYSVSHM) || !defined(_KERNEL_OPT)
  586 303     COMPAT_50 MODULAR { int|sys|13|shmctl(int shmid, int cmd, \
  587                             struct shmid_ds13 *buf); }
  588 #else
  589 303     EXCL            __shmctl13
  590 #endif
  591 304     STD      RUMP   { int|sys||lchflags(const char *path, u_long flags); }
  592 305     NOERR   RUMP    { int|sys||issetugid(void); }
  593 306     STD             { int|sys||utrace(const char *label, void *addr, \
  594                                 size_t len); }
  595 307     STD             { int|sys||getcontext(struct __ucontext *ucp); }
  596 308     STD             { int|sys||setcontext(const struct __ucontext *ucp); }
  597 309     STD             { int|sys||_lwp_create(const struct __ucontext *ucp, \
  598                                 u_long flags, lwpid_t *new_lwp); }
  599 310     STD             { int|sys||_lwp_exit(void); }
  600 311     STD             { lwpid_t|sys||_lwp_self(void); }
  601 312     STD             { int|sys||_lwp_wait(lwpid_t wait_for, \
  602                                 lwpid_t *departed); }
  603 313     STD             { int|sys||_lwp_suspend(lwpid_t target); }
  604 314     STD             { int|sys||_lwp_continue(lwpid_t target); }
  605 315     STD             { int|sys||_lwp_wakeup(lwpid_t target); }
  606 316     STD             { void *|sys||_lwp_getprivate(void); }
  607 317     STD             { void|sys||_lwp_setprivate(void *ptr); }
  608 318     STD             { int|sys||_lwp_kill(lwpid_t target, int signo); }
  609 319     STD             { int|sys||_lwp_detach(lwpid_t target); }
  610 320     COMPAT_50 MODULAR { int|sys||_lwp_park(const struct timespec50 *ts, \
  611                                 lwpid_t unpark, const void *hint, \
  612                                 const void *unparkhint); }
  613 321     STD             { int|sys||_lwp_unpark(lwpid_t target, const void *hint); }
  614 322     STD             { ssize_t|sys||_lwp_unpark_all(const lwpid_t *targets, \
  615                                 size_t ntargets, const void *hint); }
  616 323     STD             { int|sys||_lwp_setname(lwpid_t target, \
  617                                 const char *name); }
  618 324     STD             { int|sys||_lwp_getname(lwpid_t target, \
  619                                 char *name, size_t len); }
  620 325     STD             { int|sys||_lwp_ctl(int features, \
  621                                 struct lwpctl **address); }
  622 ; Syscalls 326-339 reserved for LWP syscalls.
  623 326     UNIMPL
  624 327     UNIMPL
  625 328     UNIMPL
  626 329     UNIMPL
  627 ; SA system calls.
  628 330     STD             { int|sys||sa_register(sa_upcall_t new, \
  629                                 sa_upcall_t *old, int flags, \
  630                                 ssize_t stackinfo_offset); }
  631 331     STD             { int|sys||sa_stacks(int num, stack_t *stacks); }
  632 332     STD             { int|sys||sa_enable(void); }
  633 333     STD             { int|sys||sa_setconcurrency(int concurrency); }
  634 334     STD             { int|sys||sa_yield(void); }
  635 335     STD             { int|sys||sa_preempt(int sa_id); }
  636 336     OBSOL           sys_sa_unblockyield
  637 ;
  638 ; Syscalls 337-339 are reserved for other scheduler activation syscalls.
  639 ;
  640 337     UNIMPL
  641 338     UNIMPL
  642 339     UNIMPL
  643 340     STD             { int|sys||__sigaction_sigtramp(int signum, \
  644                             const struct sigaction *nsa, \
  645                             struct sigaction *osa, \
  646                             const void *tramp, int vers); }
  647 341     STD             { int|sys||pmc_get_info(int ctr, int op, void *args); }
  648 342     STD             { int|sys||pmc_control(int ctr, int op, void *args); }
  649 343     STD             { int|sys||rasctl(void *addr, size_t len, int op); }
  650 344     STD     RUMP    { int|sys||kqueue(void); }
  651 345     COMPAT_50 MODULAR RUMP { int|sys||kevent(int fd, \
  652                             const struct kevent *changelist, size_t nchanges, \
  653                             struct kevent *eventlist, size_t nevents, \
  654                             const struct timespec50 *timeout); }
  655 
  656 ; Scheduling system calls.
  657 346     STD             { int|sys||_sched_setparam(pid_t pid, lwpid_t lid, \
  658                             int policy, const struct sched_param *params); }
  659 347     STD             { int|sys||_sched_getparam(pid_t pid, lwpid_t lid, \
  660                             int *policy, struct sched_param *params); }
  661 348     STD             { int|sys||_sched_setaffinity(pid_t pid, lwpid_t lid, \
  662                             size_t size, const cpuset_t *cpuset); }
  663 349     STD             { int|sys||_sched_getaffinity(pid_t pid, lwpid_t lid, \
  664                             size_t size, cpuset_t *cpuset); }
  665 350     STD             { int|sys||sched_yield(void); }
  666 351     UNIMPL
  667 352     UNIMPL
  668 353     UNIMPL
  669 
  670 354     STD     RUMP    { int|sys||fsync_range(int fd, int flags, off_t start, \
  671                             off_t length); }
  672 355     STD             { int|sys||uuidgen(struct uuid *store, int count); }
  673 356     STD     RUMP    { int|sys||getvfsstat(struct statvfs *buf, \
  674                             size_t bufsize, int flags); }
  675 357     STD     RUMP    { int|sys||statvfs1(const char *path, \
  676                             struct statvfs *buf, int flags); }
  677 358     STD     RUMP    { int|sys||fstatvfs1(int fd, struct statvfs *buf, \
  678                             int flags); }
  679 359     COMPAT_30 MODULAR { int|sys||fhstatvfs1(const struct compat_30_fhandle *fhp, \
  680                             struct statvfs *buf, int flags); }
  681 360     STD     RUMP    { int|sys||extattrctl(const char *path, int cmd, \
  682                             const char *filename, int attrnamespace, \
  683                             const char *attrname); }
  684 361     STD     RUMP    { int|sys||extattr_set_file(const char *path, \
  685                             int attrnamespace, const char *attrname, \
  686                             const void *data, size_t nbytes); }
  687 362     STD     RUMP    { ssize_t|sys||extattr_get_file(const char *path, \
  688                             int attrnamespace, const char *attrname, \
  689                             void *data, size_t nbytes); }
  690 363     STD     RUMP    { int|sys||extattr_delete_file(const char *path, \
  691                             int attrnamespace, const char *attrname); }
  692 364     STD     RUMP    { int|sys||extattr_set_fd(int fd, \
  693                             int attrnamespace, const char *attrname, \
  694                             const void *data, size_t nbytes); }
  695 365     STD     RUMP    { ssize_t|sys||extattr_get_fd(int fd, \
  696                             int attrnamespace, const char *attrname, \
  697                             void *data, size_t nbytes); }
  698 366     STD     RUMP    { int|sys||extattr_delete_fd(int fd, \
  699                             int attrnamespace, const char *attrname); }
  700 367     STD     RUMP    { int|sys||extattr_set_link(const char *path, \
  701                             int attrnamespace, const char *attrname, \
  702                             const void *data, size_t nbytes); }
  703 368     STD     RUMP    { ssize_t|sys||extattr_get_link(const char *path, \
  704                             int attrnamespace, const char *attrname, \
  705                             void *data, size_t nbytes); }
  706 369     STD     RUMP    { int|sys||extattr_delete_link(const char *path, \
  707                             int attrnamespace, const char *attrname); }
  708 370     STD     RUMP    { ssize_t|sys||extattr_list_fd(int fd, \
  709                             int attrnamespace, void *data, size_t nbytes); }
  710 371     STD     RUMP    { ssize_t|sys||extattr_list_file(const char *path, \
  711                             int attrnamespace, void *data, size_t nbytes); }
  712 372     STD     RUMP    { ssize_t|sys||extattr_list_link(const char *path, \
  713                             int attrnamespace, void *data, size_t nbytes); }
  714 373     COMPAT_50 MODULAR RUMP { int|sys||pselect(int nd, fd_set *in, fd_set *ou, \
  715                             fd_set *ex, const struct timespec50 *ts, \
  716                             const sigset_t *mask); }
  717 374     COMPAT_50 MODULAR RUMP { int|sys||pollts(struct pollfd *fds, u_int nfds, \
  718                             const struct timespec50 *ts, const sigset_t *mask); }
  719 375     STD     RUMP    { int|sys||setxattr(const char *path, \
  720                             const char *name, void *value, size_t size, \
  721                             int flags); }
  722 376     STD     RUMP    { int|sys||lsetxattr(const char *path, \
  723                             const char *name, void *value, size_t size, \
  724                             int flags); }
  725 377     STD     RUMP    { int|sys||fsetxattr(int fd, \
  726                             const char *name, void *value, size_t size, \
  727                             int flags); }
  728 378     STD     RUMP    { int|sys||getxattr(const char *path, \
  729                             const char *name, void *value, size_t size); }
  730 379     STD     RUMP    { int|sys||lgetxattr(const char *path, \
  731                             const char *name, void *value, size_t size); }
  732 380     STD     RUMP    { int|sys||fgetxattr(int fd, \
  733                             const char *name, void *value, size_t size); }
  734 381     STD     RUMP    { int|sys||listxattr(const char *path, \
  735                             char *list, size_t size); }
  736 382     STD     RUMP    { int|sys||llistxattr(const char *path, \
  737                             char *list, size_t size); }
  738 383     STD     RUMP    { int|sys||flistxattr(int fd, \
  739                             char *list, size_t size); }
  740 384     STD     RUMP    { int|sys||removexattr(const char *path, \
  741                             const char *name); }
  742 385     STD     RUMP    { int|sys||lremovexattr(const char *path, \
  743                             const char *name); }
  744 386     STD     RUMP    { int|sys||fremovexattr(int fd, \
  745                             const char *name); }
  746 387     COMPAT_50 MODULAR RUMP { int|sys|30|stat(const char *path, struct stat30 *ub); }
  747 388     COMPAT_50 MODULAR RUMP { int|sys|30|fstat(int fd, struct stat30 *sb); }
  748 389     COMPAT_50 MODULAR RUMP { int|sys|30|lstat(const char *path, struct stat30 *ub); }
  749 390     STD     RUMP    { int|sys|30|getdents(int fd, char *buf, size_t count); }
  750 391     IGNORED         old posix_fadvise
  751 392     COMPAT_30 MODULAR { int|sys|30|fhstat(const struct compat_30_fhandle \
  752                             *fhp, struct stat30 *sb); }
  753 393     COMPAT_50 MODULAR { int|sys|30|ntp_gettime(struct ntptimeval50 *ntvp); }
  754 394     STD      RUMP   { int|sys|30|socket(int domain, int type, int protocol); }
  755 395     STD      RUMP   { int|sys|30|getfh(const char *fname, void *fhp, \
  756                             size_t *fh_size); }
  757 396     STD      RUMP   { int|sys|40|fhopen(const void *fhp, size_t fh_size,\
  758                             int flags); }
  759 397     STD      RUMP   { int|sys|40|fhstatvfs1(const void *fhp, \
  760                             size_t fh_size, struct statvfs *buf, int flags); }
  761 398     COMPAT_50 MODULAR RUMP { int|sys|40|fhstat(const void *fhp, \
  762                             size_t fh_size, struct stat30 *sb); }
  763 
  764 ; Asynchronous I/O system calls
  765 399     STD MODULAR     { int|sys||aio_cancel(int fildes, struct aiocb *aiocbp); }
  766 400     STD MODULAR     { int|sys||aio_error(const struct aiocb *aiocbp); }
  767 401     STD MODULAR     { int|sys||aio_fsync(int op, struct aiocb *aiocbp); }
  768 402     STD MODULAR     { int|sys||aio_read(struct aiocb *aiocbp); }
  769 403     STD MODULAR     { int|sys||aio_return(struct aiocb *aiocbp); }
  770 404     COMPAT_50 MODULAR { int|sys||aio_suspend(const struct aiocb *const *list, \
  771                             int nent, const struct timespec50 *timeout); }
  772 405     STD MODULAR     { int|sys||aio_write(struct aiocb *aiocbp); }
  773 406     STD MODULAR     { int|sys||lio_listio(int mode, struct aiocb *const *list, \
  774                             int nent, struct sigevent *sig); }
  775 
  776 407     UNIMPL
  777 408     UNIMPL
  778 409     UNIMPL
  779 
  780 410     STD  RUMP       { int|sys|50|mount(const char *type, \
  781                             const char *path, int flags, void *data, \
  782                             size_t data_len); }
  783 411     STD             { void *|sys||mremap(void *old_address, size_t old_size, \
  784                             void *new_address, size_t new_size, int flags); }
  785 
  786 ; Processor-sets system calls
  787 412     STD             { int|sys||pset_create(psetid_t *psid); }
  788 413     STD             { int|sys||pset_destroy(psetid_t psid); }
  789 414     STD             { int|sys||pset_assign(psetid_t psid, cpuid_t cpuid, \
  790                             psetid_t *opsid); }
  791 415     STD             { int|sys||_pset_bind(idtype_t idtype, id_t first_id, \
  792                             id_t second_id, psetid_t psid, psetid_t *opsid); }
  793 416     NOERR RUMP      { int|sys|50|posix_fadvise(int fd, int PAD, \
  794                             off_t offset, off_t len, int advice); }
  795 417     STD  RUMP       { int|sys|50|select(int nd, fd_set *in, fd_set *ou, \
  796                             fd_set *ex, struct timeval *tv); }
  797 418     STD             { int|sys|50|gettimeofday(struct timeval *tp, \
  798                             void *tzp); }
  799 419     STD             { int|sys|50|settimeofday(const struct timeval *tv, \
  800                             const void *tzp); }
  801 420     STD  RUMP       { int|sys|50|utimes(const char *path, \
  802                             const struct timeval *tptr); }
  803 421     STD             { int|sys|50|adjtime(const struct timeval *delta, \
  804                             struct timeval *olddelta); }
  805 422     STD  MODULAR    { int|sys|50|lfs_segwait(fsid_t *fsidp, \
  806                             struct timeval *tv); }
  807 423     STD  RUMP       { int|sys|50|futimes(int fd, \
  808                             const struct timeval *tptr); }
  809 424     STD  RUMP       { int|sys|50|lutimes(const char *path, \
  810                             const struct timeval *tptr); }
  811 425     STD             { int|sys|50|setitimer(int which, \
  812                             const struct itimerval *itv, \
  813                             struct itimerval *oitv); }
  814 426     STD             { int|sys|50|getitimer(int which, \
  815                             struct itimerval *itv); }
  816 427     STD             { int|sys|50|clock_gettime(clockid_t clock_id, \
  817                             struct timespec *tp); }
  818 428     STD             { int|sys|50|clock_settime(clockid_t clock_id, \
  819                             const struct timespec *tp); }
  820 429     STD             { int|sys|50|clock_getres(clockid_t clock_id, \
  821                             struct timespec *tp); }
  822 430     STD             { int|sys|50|nanosleep(const struct timespec *rqtp, \
  823                             struct timespec *rmtp); }
  824 431     STD             { int|sys|50|__sigtimedwait(const sigset_t *set, \
  825                             siginfo_t *info, \
  826                             struct timespec *timeout); }
  827 432     STD MODULAR     { int|sys|50|mq_timedsend(mqd_t mqdes, \
  828                             const char *msg_ptr, size_t msg_len, \
  829                             unsigned msg_prio, \
  830                             const struct timespec *abs_timeout); }
  831 433     STD MODULAR     { ssize_t|sys|50|mq_timedreceive(mqd_t mqdes, \
  832                             char *msg_ptr, size_t msg_len, unsigned *msg_prio, \
  833                             const struct timespec *abs_timeout); }
  834 434     STD             { int|sys|50|_lwp_park(const struct timespec *ts, \
  835                                 lwpid_t unpark, const void *hint, \
  836                                 const void *unparkhint); }
  837 435     STD     RUMP    { int|sys|50|kevent(int fd, \
  838                             const struct kevent *changelist, size_t nchanges, \
  839                             struct kevent *eventlist, size_t nevents, \
  840                             const struct timespec *timeout); }
  841 436     STD     RUMP    { int|sys|50|pselect(int nd, fd_set *in, fd_set *ou, \
  842                             fd_set *ex, const struct timespec *ts, \
  843                             const sigset_t *mask); }
  844 437     STD     RUMP    { int|sys|50|pollts(struct pollfd *fds, u_int nfds, \
  845                             const struct timespec *ts, const sigset_t *mask); }
  846 438     STD MODULAR     { int|sys|50|aio_suspend( \
  847                             const struct aiocb *const *list, \
  848                             int nent, const struct timespec *timeout); }
  849 439     STD  RUMP       { int|sys|50|stat(const char *path, struct stat *ub); }
  850 440     STD  RUMP       { int|sys|50|fstat(int fd, struct stat *sb); }
  851 441     STD  RUMP       { int|sys|50|lstat(const char *path, struct stat *ub); }
  852 #if defined(SYSVSEM) || !defined(_KERNEL_OPT)
  853 442     STD             { int|sys|50|__semctl(int semid, int semnum, int cmd, \
  854                             ... union __semun *arg); }
  855 #else
  856 442     EXCL            ____semctl50
  857 #endif
  858 #if defined(SYSVSHM) || !defined(_KERNEL_OPT)
  859 443     STD             { int|sys|50|shmctl(int shmid, int cmd, \
  860                             struct shmid_ds *buf); }
  861 #else
  862 443     EXCL            ____shmctl50
  863 #endif
  864 #if defined(SYSVMSG) || !defined(_KERNEL_OPT)
  865 444     STD             { int|sys|50|msgctl(int msqid, int cmd, \
  866                             struct msqid_ds *buf); }
  867 #else
  868 444     EXCL            ____msgctl50
  869 #endif
  870 445     STD             { int|sys|50|getrusage(int who, struct rusage *rusage); }
  871 446     STD             { int|sys|50|timer_settime(timer_t timerid, \
  872                             int flags, const struct itimerspec *value, \
  873                             struct itimerspec *ovalue); }
  874 447     STD             { int|sys|50|timer_gettime(timer_t timerid, struct \
  875                             itimerspec *value); }
  876 #if defined(NTP) || !defined(_KERNEL_OPT)
  877 448     STD             { int|sys|50|ntp_gettime(struct ntptimeval *ntvp); }
  878 #else
  879 448     EXCL            ___ntp_gettime50
  880 #endif
  881 449     STD             { int|sys|50|wait4(pid_t pid, int *status, \
  882                                     int options, struct rusage *rusage); }
  883 450     STD  RUMP       { int|sys|50|mknod(const char *path, mode_t mode, \
  884                             dev_t dev); }
  885 451     STD  RUMP       { int|sys|50|fhstat(const void *fhp, \
  886                             size_t fh_size, struct stat *sb); }
  887 452     STD  RUMP       { int|sys|50|quotactl(const char *path, \
  888                             struct plistref *pref); }

Cache object: 72e31b234524b9091618e07b3657916f


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.