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 ;       $OpenBSD: syscalls.master,v 1.90 2008/03/16 19:42:57 otto Exp $
    2 ;       $NetBSD: syscalls.master,v 1.32 1996/04/23 10:24:21 mycroft Exp $
    3 
    4 ;       @(#)syscalls.master     8.2 (Berkeley) 1/13/94
    5 
    6 ; OpenBSD system call name/number "master" file.
    7 ; (See syscalls.conf to see what it is processed into.)
    8 ;
    9 ; Fields: number type [type-dependent ...]
   10 ;       number  system call number, must be in order
   11 ;       type    one of STD, OBSOL, UNIMPL, NODEF, NOARGS, or one of
   12 ;               the compatibility options defined in syscalls.conf.
   13 ;
   14 ; types:
   15 ;       STD     always included
   16 ;       OBSOL   obsolete, not included in system
   17 ;       UNIMPL  unimplemented, not included in system
   18 ;       NODEF   included, but don't define the syscall number
   19 ;       NOARGS  included, but don't define the syscall args structure
   20 ;       INDIR   included, but don't define the syscall args structure,
   21 ;               and allow it to be "really" varargs.
   22 ;
   23 ; The compat options are defined in the syscalls.conf file, and the
   24 ; compat option name is prefixed to the syscall name.  Other than
   25 ; that, they're like NODEF (for 'compat' options), or STD (for
   26 ; 'libcompat' options).
   27 ;
   28 ; The type-dependent arguments are as follows:
   29 ; For STD, NODEF, NOARGS, and compat syscalls:
   30 ;       { pseudo-proto } [alias]
   31 ; For other syscalls:
   32 ;       [comment]
   33 ;
   34 ; #ifdef's, etc. may be included, and are copied to the output files.
   35 ; #include's are copied to the syscall switch definition file only.
   36 
   37 #include <sys/param.h>
   38 #include <sys/systm.h>
   39 #include <sys/signal.h>
   40 #include <sys/mount.h>
   41 #include <sys/syscallargs.h>
   42 #include <sys/poll.h>
   43 #include <sys/event.h>
   44 #include <xfs/xfs_pioctl.h>
   45 
   46 ; Reserved/unimplemented system calls in the range 0-150 inclusive
   47 ; are reserved for use in future Berkeley releases.
   48 ; Additional system calls implemented in vendor and other
   49 ; redistributions should be placed in the reserved range at the end
   50 ; of the current calls.
   51 
   52 0       INDIR           { int sys_syscall(int number, ...); }
   53 1       STD             { void sys_exit(int rval); }
   54 2       STD             { int sys_fork(void); }
   55 3       STD             { ssize_t sys_read(int fd, void *buf, size_t nbyte); }
   56 4       STD             { ssize_t sys_write(int fd, const void *buf, \
   57                             size_t nbyte); }
   58 5       STD             { int sys_open(const char *path, \
   59                             int flags, ... mode_t mode); }
   60 6       STD             { int sys_close(int fd); }
   61 7       STD             { pid_t sys_wait4(pid_t pid, int *status, int options, \
   62                             struct rusage *rusage); }
   63 8       COMPAT_43       { int sys_creat(const char *path, mode_t mode); } ocreat
   64 9       STD             { int sys_link(const char *path, const char *link); }
   65 10      STD             { int sys_unlink(const char *path); }
   66 11      OBSOL           execv
   67 12      STD             { int sys_chdir(const char *path); }
   68 13      STD             { int sys_fchdir(int fd); }
   69 14      STD             { int sys_mknod(const char *path, mode_t mode, \
   70                             dev_t dev); }
   71 15      STD             { int sys_chmod(const char *path, mode_t mode); }
   72 16      STD             { int sys_chown(const char *path, uid_t uid, \
   73                             gid_t gid); }
   74 17      STD             { int sys_obreak(char *nsize); } break
   75 18      COMPAT_25       { int sys_getfsstat(struct statfs *buf, long bufsize, \
   76                             int flags); } ogetfsstat
   77 19      COMPAT_43       { long sys_lseek(int fd, long offset, int whence); } \
   78                             olseek
   79 20      STD NOLOCK      { pid_t sys_getpid(void); }
   80 21      STD             { int sys_mount(const char *type, const char *path, \
   81                             int flags, void *data); }
   82 22      STD             { int sys_unmount(const char *path, int flags); }
   83 23      STD             { int sys_setuid(uid_t uid); }
   84 24      STD             { uid_t sys_getuid(void); }
   85 25      STD             { uid_t sys_geteuid(void); }
   86 #ifdef PTRACE
   87 26      STD             { int sys_ptrace(int req, pid_t pid, caddr_t addr, \
   88                             int data); }
   89 #else
   90 26      UNIMPL          ptrace
   91 #endif
   92 27      STD             { ssize_t sys_recvmsg(int s, struct msghdr *msg, \
   93                             int flags); }
   94 28      STD             { ssize_t sys_sendmsg(int s, \
   95                             const struct msghdr *msg, int flags); }
   96 29      STD             { ssize_t sys_recvfrom(int s, void *buf, size_t len, \
   97                             int flags, struct sockaddr *from, \
   98                             socklen_t *fromlenaddr); }
   99 30      STD             { int sys_accept(int s, struct sockaddr *name, \
  100                             socklen_t *anamelen); }
  101 31      STD             { int sys_getpeername(int fdes, struct sockaddr *asa, \
  102                             socklen_t *alen); }
  103 32      STD             { int sys_getsockname(int fdes, struct sockaddr *asa, \
  104                             socklen_t *alen); }
  105 33      STD             { int sys_access(const char *path, int flags); }
  106 34      STD             { int sys_chflags(const char *path, u_int flags); }
  107 35      STD             { int sys_fchflags(int fd, u_int flags); }
  108 36      STD             { void sys_sync(void); }
  109 37      STD             { int sys_kill(int pid, int signum); }
  110 38      COMPAT_43       { int sys_stat(const char *path, struct stat43 *ub); } \
  111                             stat43
  112 39      STD             { pid_t sys_getppid(void); }
  113 40      COMPAT_43       { int sys_lstat(char *path, \
  114                             struct stat43 *ub); } lstat43
  115 41      STD             { int sys_dup(int fd); }
  116 42      STD             { int sys_opipe(void); }
  117 43      STD             { gid_t sys_getegid(void); }
  118 44      STD             { int sys_profil(caddr_t samples, size_t size, \
  119                             u_long offset, u_int scale); }
  120 #ifdef KTRACE
  121 45      STD             { int sys_ktrace(const char *fname, int ops, \
  122                             int facs, pid_t pid); }
  123 #else
  124 45      UNIMPL          ktrace
  125 #endif
  126 46      STD             { int sys_sigaction(int signum, \
  127                             const struct sigaction *nsa, \
  128                             struct sigaction *osa); }
  129 47      STD             { gid_t sys_getgid(void); }
  130 48      STD             { int sys_sigprocmask(int how, sigset_t mask); }
  131 49      STD             { int sys_getlogin(char *namebuf, u_int namelen); }
  132 50      STD             { int sys_setlogin(const char *namebuf); }
  133 #ifdef ACCOUNTING
  134 51      STD             { int sys_acct(const char *path); }
  135 #else
  136 51      UNIMPL          acct
  137 #endif
  138 52      STD             { int sys_sigpending(void); }
  139 53      STD             { int sys_osigaltstack(const struct osigaltstack *nss, \
  140                             struct osigaltstack *oss); }
  141 54      STD             { int sys_ioctl(int fd, \
  142                             u_long com, ... void *data); }
  143 55      STD             { int sys_reboot(int opt); }
  144 56      STD             { int sys_revoke(const char *path); }
  145 57      STD             { int sys_symlink(const char *path, \
  146                             const char *link); }
  147 58      STD             { int sys_readlink(const char *path, char *buf, \
  148                             size_t count); }
  149 59      STD             { int sys_execve(const char *path, \
  150                             char * const *argp, char * const *envp); }
  151 60      STD             { mode_t sys_umask(mode_t newmask); }
  152 61      STD             { int sys_chroot(const char *path); }
  153 62      COMPAT_43       { int sys_fstat(int fd, struct stat43 *sb); } fstat43
  154 63      COMPAT_43       { int sys_getkerninfo(int op, char *where, int *size, \
  155                             int arg); } ogetkerninfo
  156 64      COMPAT_43       { int sys_getpagesize(void); } ogetpagesize
  157 65      COMPAT_25       { int sys_omsync(caddr_t addr, size_t len); }
  158 66      STD             { int sys_vfork(void); }
  159 67      OBSOL           vread
  160 68      OBSOL           vwrite
  161 69      STD             { int sys_sbrk(int incr); }
  162 70      STD             { int sys_sstk(int incr); }
  163 71      COMPAT_43       { int sys_mmap(caddr_t addr, size_t len, int prot, \
  164                             int flags, int fd, long pos); } ommap
  165 72      OBSOL           vadvise
  166 73      STD             { int sys_munmap(void *addr, size_t len); }
  167 74      STD             { int sys_mprotect(void *addr, size_t len, \
  168                             int prot); }
  169 75      STD             { int sys_madvise(void *addr, size_t len, \
  170                             int behav); }
  171 76      OBSOL           vhangup
  172 77      OBSOL           vlimit
  173 78      STD             { int sys_mincore(void *addr, size_t len, \
  174                             char *vec); }
  175 79      STD             { int sys_getgroups(int gidsetsize, \
  176                             gid_t *gidset); }
  177 80      STD             { int sys_setgroups(int gidsetsize, \
  178                             const gid_t *gidset); }
  179 81      STD             { int sys_getpgrp(void); }
  180 82      STD             { int sys_setpgid(pid_t pid, int pgid); }
  181 83      STD             { int sys_setitimer(int which, \
  182                             const struct itimerval *itv, \
  183                             struct itimerval *oitv); }
  184 84      COMPAT_43       { int sys_wait(void); } owait
  185 85      COMPAT_25       { int sys_swapon(const char *name); }
  186 86      STD             { int sys_getitimer(int which, \
  187                             struct itimerval *itv); }
  188 87      COMPAT_43       { int sys_gethostname(char *hostname, u_int len); } \
  189                             ogethostname
  190 88      COMPAT_43       { int sys_sethostname(char *hostname, u_int len); } \
  191                             osethostname
  192 89      COMPAT_43       { int sys_getdtablesize(void); } ogetdtablesize
  193 90      STD             { int sys_dup2(int from, int to); }
  194 91      UNIMPL          getdopt
  195 92      STD             { int sys_fcntl(int fd, int cmd, ... void *arg); }
  196 93      STD             { int sys_select(int nd, fd_set *in, fd_set *ou, \
  197                             fd_set *ex, struct timeval *tv); }
  198 94      UNIMPL          setdopt
  199 95      STD             { int sys_fsync(int fd); }
  200 96      STD             { int sys_setpriority(int which, id_t who, int prio); }
  201 97      STD             { int sys_socket(int domain, int type, int protocol); }
  202 98      STD             { int sys_connect(int s, const struct sockaddr *name, \
  203                             socklen_t namelen); }
  204 99      COMPAT_43       { int sys_accept(int s, caddr_t name, \
  205                             int *anamelen); } oaccept
  206 100     STD             { int sys_getpriority(int which, id_t who); }
  207 101     COMPAT_43       { int sys_send(int s, caddr_t buf, int len, \
  208                             int flags); } osend
  209 102     COMPAT_43       { int sys_recv(int s, caddr_t buf, int len, \
  210                             int flags); } orecv
  211 103     STD             { int sys_sigreturn(struct sigcontext *sigcntxp); }
  212 104     STD             { int sys_bind(int s, const struct sockaddr *name, \
  213                             socklen_t namelen); }
  214 105     STD             { int sys_setsockopt(int s, int level, int name, \
  215                             const void *val, socklen_t valsize); }
  216 106     STD             { int sys_listen(int s, int backlog); }
  217 107     OBSOL           vtimes
  218 108     COMPAT_43       { int sys_sigvec(int signum, struct sigvec *nsv, \
  219                             struct sigvec *osv); } osigvec
  220 109     COMPAT_43       { int sys_sigblock(int mask); } osigblock
  221 110     COMPAT_43       { int sys_sigsetmask(int mask); } osigsetmask
  222 111     STD             { int sys_sigsuspend(int mask); }
  223 112     COMPAT_43       { int sys_sigstack(struct sigstack *nss, \
  224                             struct sigstack *oss); } osigstack
  225 113     COMPAT_43       { int sys_recvmsg(int s, struct omsghdr *msg, \
  226                             int flags); } orecvmsg
  227 114     COMPAT_43       { int sys_sendmsg(int s, caddr_t msg, int flags); } \
  228                             osendmsg
  229 115     OBSOL           vtrace
  230 116     STD             { int sys_gettimeofday(struct timeval *tp, \
  231                             struct timezone *tzp); }
  232 117     STD             { int sys_getrusage(int who, struct rusage *rusage); }
  233 118     STD             { int sys_getsockopt(int s, int level, int name, \
  234                             void *val, socklen_t *avalsize); }
  235 119     OBSOL           resuba
  236 120     STD             { ssize_t sys_readv(int fd, \
  237                             const struct iovec *iovp, int iovcnt); }
  238 121     STD             { ssize_t sys_writev(int fd, \
  239                             const struct iovec *iovp, int iovcnt); }
  240 122     STD             { int sys_settimeofday(const struct timeval *tv, \
  241                             const struct timezone *tzp); }
  242 123     STD             { int sys_fchown(int fd, uid_t uid, gid_t gid); }
  243 124     STD             { int sys_fchmod(int fd, mode_t mode); }
  244 125     COMPAT_43       { int sys_recvfrom(int s, caddr_t buf, size_t len, \
  245                             int flags, caddr_t from, int *fromlenaddr); } \
  246                             orecvfrom
  247 126     STD             { int sys_setreuid(uid_t ruid, uid_t euid); }
  248 127     STD             { int sys_setregid(gid_t rgid, gid_t egid); }
  249 128     STD             { int sys_rename(const char *from, const char *to); }
  250 129     COMPAT_43       { int sys_truncate(const char *path, long length); } \
  251                             otruncate
  252 130     COMPAT_43       { int sys_ftruncate(int fd, long length); } oftruncate
  253 131     STD             { int sys_flock(int fd, int how); }
  254 132     STD             { int sys_mkfifo(const char *path, mode_t mode); }
  255 133     STD             { ssize_t sys_sendto(int s, const void *buf, \
  256                             size_t len, int flags, const struct sockaddr *to, \
  257                             socklen_t tolen); }
  258 134     STD             { int sys_shutdown(int s, int how); }
  259 135     STD             { int sys_socketpair(int domain, int type, \
  260                             int protocol, int *rsv); }
  261 136     STD             { int sys_mkdir(const char *path, mode_t mode); }
  262 137     STD             { int sys_rmdir(const char *path); }
  263 138     STD             { int sys_utimes(const char *path, \
  264                             const struct timeval *tptr); }
  265 139     OBSOL           4.2 sigreturn
  266 140     STD             { int sys_adjtime(const struct timeval *delta, \
  267                             struct timeval *olddelta); }
  268 141     COMPAT_43       { int sys_getpeername(int fdes, caddr_t asa, \
  269                             socklen_t *alen); } ogetpeername
  270 142     COMPAT_43       { int32_t sys_gethostid(void); } ogethostid
  271 143     COMPAT_43       { int sys_sethostid(int32_t hostid); } osethostid
  272 144     COMPAT_43       { int sys_getrlimit(int which, \
  273                             struct ogetrlimit *rlp); } ogetrlimit
  274 145     COMPAT_43       { int sys_setrlimit(int which, \
  275                             struct ogetrlimit *rlp); } osetrlimit
  276 146     COMPAT_43       { int sys_killpg(int pgid, int signum); } okillpg
  277 147     STD             { int sys_setsid(void); }
  278 148     STD             { int sys_quotactl(const char *path, int cmd, \
  279                             int uid, char *arg); }
  280 149     COMPAT_43       { int sys_quota(void); } oquota
  281 150     COMPAT_43       { int sys_getsockname(int fdec, caddr_t asa, \
  282                             int *alen); } ogetsockname
  283 
  284 ; Syscalls 151-180 inclusive are reserved for vendor-specific
  285 ; system calls.  (This includes various calls added for compatibity
  286 ; with other Unix variants.)
  287 ; Some of these calls are now supported by BSD...
  288 151     UNIMPL
  289 152     UNIMPL
  290 153     UNIMPL
  291 154     UNIMPL
  292 #if defined(NFSCLIENT) || defined(NFSSERVER)
  293 155     STD             { int sys_nfssvc(int flag, void *argp); }
  294 #else
  295 155     UNIMPL
  296 #endif
  297 156     COMPAT_43       { int sys_getdirentries(int fd, char *buf, \
  298                             int count, long *basep); } ogetdirentries
  299 157     COMPAT_25       { int sys_statfs(const char *path, \
  300                             struct ostatfs *buf); } ostatfs
  301 158     COMPAT_25       { int sys_fstatfs(int fd, struct ostatfs *buf); } \
  302                             ostatfs
  303 159     UNIMPL
  304 160     UNIMPL
  305 161     STD             { int sys_getfh(const char *fname, fhandle_t *fhp); }
  306 162     COMPAT_09       { int sys_getdomainname(char *domainname, int len); } \
  307                             ogetdomainname
  308 163     COMPAT_09       { int sys_setdomainname(char *domainname, int len); } \
  309                             osetdomainname
  310 164     UNIMPL          ouname
  311 165     STD             { int sys_sysarch(int op, void *parms); }
  312 166     UNIMPL
  313 167     UNIMPL
  314 168     UNIMPL
  315 #if defined(SYSVSEM) && !defined(__LP64__)
  316 169     COMPAT_10       { int sys_semsys(int which, int a2, int a3, int a4, \
  317                             int a5); } osemsys
  318 #else
  319 169     UNIMPL          1.0 semsys
  320 #endif
  321 #if defined(SYSVMSG) && !defined(__LP64__)
  322 170     COMPAT_10       { int sys_msgsys(int which, int a2, int a3, int a4, \
  323                             int a5, int a6); } omsgsys
  324 #else
  325 170     UNIMPL          1.0 msgsys
  326 #endif
  327 #if defined(SYSVSHM) && !defined(__LP64__)
  328 171     COMPAT_10       { int sys_shmsys(int which, int a2, int a3, int a4); } \
  329                             oshmsys
  330 #else
  331 171     UNIMPL          1.0 shmsys
  332 #endif
  333 172     UNIMPL
  334 173     STD             { ssize_t sys_pread(int fd, void *buf, \
  335                           size_t nbyte, int pad, off_t offset); }
  336 174     STD             { ssize_t sys_pwrite(int fd, const void *buf, \
  337                           size_t nbyte, int pad, off_t offset); }
  338 175     UNIMPL          ntp_gettime
  339 176     UNIMPL          ntp_adjtime
  340 177     UNIMPL
  341 178     UNIMPL
  342 179     UNIMPL
  343 180     UNIMPL
  344 
  345 ; Syscalls 181-199 are used by/reserved for BSD
  346 181     STD             { int sys_setgid(gid_t gid); }
  347 182     STD             { int sys_setegid(gid_t egid); }
  348 183     STD             { int sys_seteuid(uid_t euid); }
  349 #ifdef LFS
  350 184     STD             { int lfs_bmapv(fsid_t *fsidp, \
  351                             struct block_info *blkiov, int blkcnt); }
  352 185     STD             { int lfs_markv(fsid_t *fsidp, \
  353                             struct block_info *blkiov, int blkcnt); }
  354 186     STD             { int lfs_segclean(fsid_t *fsidp, u_long segment); }
  355 187     STD             { int lfs_segwait(fsid_t *fsidp, struct timeval *tv); }
  356 #else
  357 184     UNIMPL
  358 185     UNIMPL
  359 186     UNIMPL
  360 187     UNIMPL
  361 #endif
  362 188     COMPAT_35       { int sys_stat(const char *path, struct stat35 *ub); } \
  363                             stat35
  364 189     COMPAT_35       { int sys_fstat(int fd, struct stat35 *sb); } \
  365                             fstat35
  366 190     COMPAT_35       { int sys_lstat(const char *path, \
  367                             struct stat35 *ub); } lstat35
  368 191     STD             { long sys_pathconf(const char *path, int name); }
  369 192     STD             { long sys_fpathconf(int fd, int name); }
  370 193     STD             { int sys_swapctl(int cmd, const void *arg, int misc); }
  371 194     STD             { int sys_getrlimit(int which, \
  372                             struct rlimit *rlp); }
  373 195     STD             { int sys_setrlimit(int which, \
  374                             const struct rlimit *rlp); }
  375 196     STD             { int sys_getdirentries(int fd, char *buf, \
  376                             int count, long *basep); }
  377 197     STD             { void *sys_mmap(void *addr, size_t len, int prot, \
  378                             int flags, int fd, long pad, off_t pos); }
  379 198     INDIR           { quad_t sys___syscall(quad_t num, ...); }
  380 199     STD             { off_t sys_lseek(int fd, int pad, off_t offset, \
  381                             int whence); }
  382 200     STD             { int sys_truncate(const char *path, int pad, \
  383                             off_t length); }
  384 201     STD             { int sys_ftruncate(int fd, int pad, off_t length); }
  385 202     STD             { int sys___sysctl(int *name, u_int namelen, \
  386                             void *old, size_t *oldlenp, void *new, \
  387                             size_t newlen); }
  388 203     STD             { int sys_mlock(const void *addr, size_t len); }
  389 204     STD             { int sys_munlock(const void *addr, size_t len); }
  390 205     UNIMPL          sys_undelete
  391 206     STD             { int sys_futimes(int fd, \
  392                             const struct timeval *tptr); }
  393 207     STD             { pid_t sys_getpgid(pid_t pid); }
  394 208     STD             { int sys_xfspioctl(int operation, char *a_pathP, \
  395                             int a_opcode, struct ViceIoctl *a_paramsP, \
  396                             int a_followSymlinks); }
  397 209     UNIMPL
  398 ;
  399 ; Syscalls 210-219 are reserved for dynamically loaded syscalls
  400 ;
  401 #ifdef LKM
  402 210     NODEF           { int sys_lkmnosys(void); }
  403 211     NODEF           { int sys_lkmnosys(void); }
  404 212     NODEF           { int sys_lkmnosys(void); }
  405 213     NODEF           { int sys_lkmnosys(void); }
  406 214     NODEF           { int sys_lkmnosys(void); }
  407 215     NODEF           { int sys_lkmnosys(void); }
  408 216     NODEF           { int sys_lkmnosys(void); }
  409 217     NODEF           { int sys_lkmnosys(void); }
  410 218     NODEF           { int sys_lkmnosys(void); }
  411 219     NODEF           { int sys_lkmnosys(void); }
  412 #else   /* !LKM */
  413 210     UNIMPL
  414 211     UNIMPL
  415 212     UNIMPL
  416 213     UNIMPL
  417 214     UNIMPL
  418 215     UNIMPL
  419 216     UNIMPL
  420 217     UNIMPL
  421 218     UNIMPL
  422 219     UNIMPL
  423 #endif  /* !LKM */
  424 ; System calls 220-240 are reserved for use by OpenBSD
  425 #ifdef SYSVSEM
  426 220     COMPAT_23       { int sys___semctl(int semid, int semnum, int cmd, \
  427                             union semun *arg); } semctl23
  428 221     STD             { int sys_semget(key_t key, int nsems, int semflg); }
  429 222     COMPAT_35       { int sys_semop(int semid, struct sembuf *sops, \
  430                             u_int nsops); }
  431 223     OBSOL           sys_semconfig
  432 #else
  433 220     UNIMPL          semctl
  434 221     UNIMPL          semget
  435 222     UNIMPL          semop
  436 223     UNIMPL          semconfig
  437 #endif
  438 #ifdef SYSVMSG
  439 224     COMPAT_23       { int sys_msgctl(int msqid, int cmd, \
  440                             struct omsqid_ds *buf); } msgctl23
  441 225     STD             { int sys_msgget(key_t key, int msgflg); }
  442 226     STD             { int sys_msgsnd(int msqid, const void *msgp, size_t msgsz, \
  443                             int msgflg); }
  444 227     STD             { int sys_msgrcv(int msqid, void *msgp, size_t msgsz, \
  445                             long msgtyp, int msgflg); }
  446 #else
  447 224     UNIMPL          msgctl
  448 225     UNIMPL          msgget
  449 226     UNIMPL          msgsnd
  450 227     UNIMPL          msgrcv
  451 #endif
  452 #ifdef SYSVSHM
  453 228     STD             { void *sys_shmat(int shmid, const void *shmaddr, \
  454                             int shmflg); }
  455 229     COMPAT_23       { int sys_shmctl(int shmid, int cmd, \
  456                             struct oshmid_ds *buf); } shmctl23
  457 230     STD             { int sys_shmdt(const void *shmaddr); }
  458 231     COMPAT_35       { int sys_shmget(key_t key, int size, int shmflg); }
  459 #else
  460 228     UNIMPL          shmat
  461 229     UNIMPL          shmctl
  462 230     UNIMPL          shmdt
  463 231     UNIMPL          shmget
  464 #endif
  465 232     STD             { int sys_clock_gettime(clockid_t clock_id, \
  466                             struct timespec *tp); }
  467 233     STD             { int sys_clock_settime(clockid_t clock_id, \
  468                             const struct timespec *tp); }
  469 234     STD             { int sys_clock_getres(clockid_t clock_id, \
  470                             struct timespec *tp); }
  471 235     UNIMPL          timer_create
  472 236     UNIMPL          timer_delete
  473 237     UNIMPL          timer_settime
  474 238     UNIMPL          timer_gettime
  475 239     UNIMPL          timer_getoverrun
  476 ;
  477 ; System calls 240-249 are reserved for other IEEE Std1003.1b syscalls
  478 ;
  479 240     STD             { int sys_nanosleep(const struct timespec *rqtp, \
  480                             struct timespec *rmtp); }
  481 241     UNIMPL
  482 242     UNIMPL
  483 243     UNIMPL
  484 244     UNIMPL
  485 245     UNIMPL
  486 246     UNIMPL
  487 247     UNIMPL
  488 248     UNIMPL
  489 249     UNIMPL
  490 250     STD             { int sys_minherit(void *addr, size_t len, \
  491                             int inherit); }
  492 251     STD             { int sys_rfork(int flags); }
  493 252     STD             { int sys_poll(struct pollfd *fds, \
  494                             u_int nfds, int timeout); }
  495 253     STD             { int sys_issetugid(void); }
  496 254     STD             { int sys_lchown(const char *path, uid_t uid, gid_t gid); }
  497 255     STD             { pid_t sys_getsid(pid_t pid); }
  498 256     STD             { int sys_msync(void *addr, size_t len, int flags); }
  499 #ifdef SYSVSEM
  500 257     COMPAT_35       { int sys___semctl(int semid, int semnum, int cmd, \
  501                             union semun *arg); } semctl35
  502 #else
  503 257     UNIMPL
  504 #endif
  505 #ifdef SYSVSHM
  506 258     COMPAT_35       { int sys_shmctl(int shmid, int cmd, \
  507                             struct shmid_ds35 *buf); } shmctl35
  508 #else
  509 258     UNIMPL
  510 #endif
  511 #ifdef SYSVMSG
  512 259     COMPAT_35       { int sys_msgctl(int msqid, int cmd, \
  513                             struct msqid_ds35 *buf); } msgctl35
  514 #else
  515 259     UNIMPL
  516 #endif
  517 260     COMPAT_O43      { int sys_getfsstat(struct o43statfs *buf, size_t bufsize, \
  518                             int flags); }
  519 261     COMPAT_O43      { int sys_statfs(const char *path, \
  520                             struct o43statfs *buf); }
  521 262     COMPAT_O43      { int sys_fstatfs(int fd, struct o43statfs *buf); }
  522 263     STD             { int sys_pipe(int *fdp); }
  523 264     STD             { int sys_fhopen(const fhandle_t *fhp, int flags); }
  524 265     COMPAT_35       { int sys_fhstat(const fhandle_t *fhp, \
  525                             struct stat35 *sb); }
  526 266     COMPAT_O43      { int sys_fhstatfs(const fhandle_t *fhp, \
  527                             struct o43statfs *buf); }
  528 267     STD             { ssize_t sys_preadv(int fd, \
  529                           const struct iovec *iovp, int iovcnt, \
  530                           int pad, off_t offset); }
  531 268     STD             { ssize_t sys_pwritev(int fd, \
  532                           const struct iovec *iovp, int iovcnt, \
  533                           int pad, off_t offset); }
  534 269     STD             { int sys_kqueue(void); }
  535 270     STD             { int sys_kevent(int fd, \
  536                             const struct kevent *changelist, int nchanges, \
  537                             struct kevent *eventlist, int nevents, \
  538                             const struct timespec *timeout); }
  539 271     STD             { int sys_mlockall(int flags); }
  540 272     STD             { int sys_munlockall(void); }
  541 273     STD             { int sys_getpeereid(int fdes, uid_t *euid, gid_t *egid); }
  542 274     UNIMPL          sys_extattrctl
  543 275     UNIMPL          sys_extattr_set_file
  544 276     UNIMPL          sys_extattr_get_file
  545 277     UNIMPL          sys_extattr_delete_file
  546 278     UNIMPL          sys_extattr_set_fd
  547 279     UNIMPL          sys_extattr_get_fd
  548 280     UNIMPL          sys_extattr_delete_fd
  549 281     STD             { int sys_getresuid(uid_t *ruid, uid_t *euid, \
  550                             uid_t *suid); }
  551 282     STD             { int sys_setresuid(uid_t ruid, uid_t euid, \
  552                             uid_t suid); }
  553 283     STD             { int sys_getresgid(gid_t *rgid, gid_t *egid, \
  554                             gid_t *sgid); }
  555 284     STD             { int sys_setresgid(gid_t rgid, gid_t egid, \
  556                             gid_t sgid); }
  557 285     OBSOL           sys_omquery
  558 286     STD             { void *sys_mquery(void *addr, size_t len, int prot, \
  559                             int flags, int fd, long pad, off_t pos); }
  560 287     STD             { int sys_closefrom(int fd); }
  561 288     STD             { int sys_sigaltstack(const struct sigaltstack *nss, \
  562                             struct sigaltstack *oss); }
  563 #ifdef SYSVSHM
  564 289     STD             { int sys_shmget(key_t key, size_t size, int shmflg); }
  565 #else
  566 289     UNIMPL          shmget
  567 #endif
  568 #ifdef SYSVSEM
  569 290     STD             { int sys_semop(int semid, struct sembuf *sops, \
  570                             size_t nsops); }
  571 #else
  572 290    UNIMPL           semop
  573 #endif
  574 291     STD             { int sys_stat(const char *path, struct stat *ub); }
  575 292     STD             { int sys_fstat(int fd, struct stat *sb); }
  576 293     STD             { int sys_lstat(const char *path, struct stat *ub); }
  577 294     STD             { int sys_fhstat(const fhandle_t *fhp, \
  578                             struct stat *sb); }
  579 #ifdef SYSVSEM
  580 295     STD             { int sys___semctl(int semid, int semnum, int cmd, \
  581                             union semun *arg); }
  582 #else
  583 295     UNIMPL
  584 #endif
  585 #ifdef SYSVSHM
  586 296     STD             { int sys_shmctl(int shmid, int cmd, \
  587                             struct shmid_ds *buf); }
  588 #else
  589 296     UNIMPL
  590 #endif
  591 #ifdef SYSVMSG
  592 297     STD             { int sys_msgctl(int msqid, int cmd, \
  593                             struct msqid_ds *buf); }
  594 #else
  595 297     UNIMPL
  596 #endif
  597 298     STD             { int sys_sched_yield(void); }
  598 #ifdef RTHREADS
  599 299     STD             { pid_t sys_getthrid(void); }
  600 300     STD             { int sys_thrsleep(void *ident, int timeout, void *lock); }
  601 301     STD             { int sys_thrwakeup(void *ident, int n); }
  602 302     STD             { int sys_threxit(int rval); }
  603 303     STD             { int sys_thrsigdivert(sigset_t sigmask); }
  604 #else
  605 299     UNIMPL
  606 300     UNIMPL
  607 301     UNIMPL
  608 302     UNIMPL
  609 303     UNIMPL
  610 #endif
  611 304     STD             { int sys___getcwd(char *buf, size_t len); }
  612 305     STD             { int sys_adjfreq(const int64_t *freq, \
  613                             int64_t *oldfreq); }
  614 306     STD             { int sys_getfsstat(struct statfs *buf, size_t bufsize, \
  615                             int flags); }
  616 307     STD             { int sys_statfs(const char *path, \
  617                             struct statfs *buf); }
  618 308     STD             { int sys_fstatfs(int fd, struct statfs *buf); }
  619 309     STD             { int sys_fhstatfs(const fhandle_t *fhp, \
  620                             struct statfs *buf); }

Cache object: a3bdf1b2162301fc4bc4b39fe9703578


[ 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.