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  $FreeBSD: src/sys/kern/syscalls.master,v 1.72.2.10 2002/07/12 08:22:46 alfred Exp $
    2 ;       from: @(#)syscalls.master       8.2 (Berkeley) 1/13/94
    3 ;
    4 ; System call name/number master file.
    5 ; Processed to created init_sysent.c, syscalls.c and syscall.h.
    6 
    7 ; Columns: number [MPSAFE] type nargs namespc name alt{name,tag,rtyp}/comments
    8 ;       number  system call number, must be in order
    9 ;   MPSAFE      optional field, specifies that syscall does not want the
   10 ;               BGL grabbed automatically (it is SMP safe).
   11 ;       type    one of STD, OBSOL, UNIMPL, COMPAT, CPT_NOA, LIBCOMPAT,
   12 ;               NODEF, NOARGS, NOPROTO, NOIMPL
   13 ;       namespc one of POSIX, BSD, NOHIDE
   14 ;       name    psuedo-prototype of syscall routine
   15 ;               If one of the following alts is different, then all appear:
   16 ;       altname name of system call if different
   17 ;       alttag  name of args struct tag if different from [o]`name'"_args"
   18 ;       altrtyp return type if not int (bogus - syscalls always return int)
   19 ;               for UNIMPL/OBSOL, name continues with comments
   20 
   21 ; types:
   22 ;       STD     always included
   23 ;       COMPAT  included on COMPAT #ifdef
   24 ;       LIBCOMPAT included on COMPAT #ifdef, and placed in syscall.h
   25 ;       OBSOL   obsolete, not included in system, only specifies name
   26 ;       UNIMPL  not implemented, placeholder only
   27 
   28 ; #ifdef's, etc. may be included, and are copied to the output files.
   29 
   30 #include <sys/param.h>
   31 #include <sys/sysent.h>
   32 #include <sys/sysproto.h>
   33 
   34 ; Reserved/unimplemented system calls in the range 0-150 inclusive
   35 ; are reserved for use in future Berkeley releases.
   36 ; Additional system calls implemented in vendor and other
   37 ; redistributions should be placed in the reserved range at the end
   38 ; of the current calls.
   39 
   40 0       STD     NOHIDE  { int nosys(void); } syscall nosys_args int
   41 1       STD     NOHIDE  { void sys_exit(int rval); } exit sys_exit_args void
   42 2       STD     POSIX   { int fork(void); }
   43 3       STD     POSIX   { ssize_t read(int fd, void *buf, size_t nbyte); }
   44 4       STD     POSIX   { ssize_t write(int fd, const void *buf, size_t nbyte); }
   45 5       STD     POSIX   { int open(char *path, int flags, int mode); }
   46 ; XXX should be         { int open(const char *path, int flags, ...); }
   47 ; but we're not ready for `const' or varargs.
   48 ; XXX man page says `mode_t mode'.
   49 6       STD     POSIX   { int close(int fd); }
   50 7       STD     BSD     { int wait4(int pid, int *status, int options, \
   51                             struct rusage *rusage); } wait4 wait_args int
   52 8       COMPAT  BSD     { int creat(char *path, int mode); }
   53 9       STD     POSIX   { int link(char *path, char *link); }
   54 10      STD     POSIX   { int unlink(char *path); }
   55 11      OBSOL   NOHIDE  execv
   56 12      STD     POSIX   { int chdir(char *path); }
   57 13      STD     BSD     { int fchdir(int fd); }
   58 14      STD     POSIX   { int mknod(char *path, int mode, int dev); }
   59 15      STD     POSIX   { int chmod(char *path, int mode); }
   60 16      STD     POSIX   { int chown(char *path, int uid, int gid); }
   61 17      STD     BSD     { int obreak(char *nsize); } break obreak_args int
   62 18      STD     BSD     { int getfsstat(struct statfs *buf, long bufsize, \
   63                             int flags); }
   64 19      COMPAT  POSIX   { long lseek(int fd, long offset, int whence); }
   65 20      STD     POSIX   { pid_t getpid(void); }
   66 21      STD     BSD     { int mount(char *type, char *path, int flags, \
   67                             caddr_t data); }
   68 ; XXX `path' should have type `const char *' but we're not ready for that.
   69 22      STD     BSD     { int unmount(char *path, int flags); }
   70 23      STD     POSIX   { int setuid(uid_t uid); }
   71 24      MPSAFE  STD     POSIX   { uid_t getuid(void); }
   72 25      MPSAFE  STD     POSIX   { uid_t geteuid(void); }
   73 26      STD     BSD     { int ptrace(int req, pid_t pid, caddr_t addr, \
   74                             int data); }
   75 27      STD     BSD     { int recvmsg(int s, struct msghdr *msg, int flags); }
   76 28      STD     BSD     { int sendmsg(int s, caddr_t msg, int flags); }
   77 29      STD     BSD     { int recvfrom(int s, caddr_t buf, size_t len, \
   78                             int flags, caddr_t from, int *fromlenaddr); }
   79 30      STD     BSD     { int accept(int s, caddr_t name, int *anamelen); }
   80 31      STD     BSD     { int getpeername(int fdes, caddr_t asa, int *alen); }
   81 32      STD     BSD     { int getsockname(int fdes, caddr_t asa, int *alen); }
   82 33      STD     POSIX   { int access(char *path, int flags); }
   83 34      STD     BSD     { int chflags(char *path, int flags); }
   84 35      STD     BSD     { int fchflags(int fd, int flags); }
   85 36      STD     BSD     { int sync(void); }
   86 37      STD     POSIX   { int kill(int pid, int signum); }
   87 38      COMPAT  POSIX   { int stat(char *path, struct ostat *ub); }
   88 39      STD     POSIX   { pid_t getppid(void); }
   89 40      COMPAT  POSIX   { int lstat(char *path, struct ostat *ub); }
   90 41      STD     POSIX   { int dup(u_int fd); }
   91 42      STD     POSIX   { int pipe(void); }
   92 43      STD     POSIX   { gid_t getegid(void); }
   93 44      STD     BSD     { int profil(caddr_t samples, size_t size, \
   94                             size_t offset, u_int scale); }
   95 45      STD     BSD     { int ktrace(const char *fname, int ops, int facs, \
   96                             int pid); }
   97 46      COMPAT  POSIX   { int sigaction(int signum, struct osigaction *nsa, \
   98                             struct osigaction *osa); }
   99 47      MPSAFE  STD     POSIX   { gid_t getgid(void); }
  100 48      MPSAFE  COMPAT  POSIX   { int sigprocmask(int how, osigset_t mask); }
  101 ; XXX note nonstandard (bogus) calling convention - the libc stub passes
  102 ; us the mask, not a pointer to it, and we return the old mask as the
  103 ; (int) return value.
  104 49      STD     BSD     { int getlogin(char *namebuf, u_int namelen); }
  105 50      STD     BSD     { int setlogin(char *namebuf); }
  106 51      STD     BSD     { int acct(char *path); }
  107 52      COMPAT  POSIX   { int sigpending(void); }
  108 53      STD     BSD     { int sigaltstack(stack_t *ss, stack_t *oss); }
  109 54      STD     POSIX   { int ioctl(int fd, u_long com, caddr_t data); }
  110 55      STD     BSD     { int reboot(int opt); }
  111 56      STD     POSIX   { int revoke(char *path); }
  112 57      STD     POSIX   { int symlink(char *path, char *link); }
  113 58      STD     POSIX   { int readlink(char *path, char *buf, int count); }
  114 59      STD     POSIX   { int execve(char *fname, char **argv, char **envv); }
  115 60      MPSAFE  STD     POSIX   { int umask(int newmask); } umask umask_args int
  116 61      STD     BSD     { int chroot(char *path); }
  117 62      COMPAT  POSIX   { int fstat(int fd, struct ostat *sb); }
  118 63      COMPAT  BSD     { int getkerninfo(int op, char *where, size_t *size, \
  119                             int arg); } getkerninfo getkerninfo_args int
  120 64      COMPAT  BSD     { int getpagesize(void); } \
  121                             getpagesize getpagesize_args int
  122 65      STD     BSD     { int msync(void *addr, size_t len, int flags); }
  123 66      STD     BSD     { int vfork(void); }
  124 67      OBSOL   NOHIDE  vread
  125 68      OBSOL   NOHIDE  vwrite
  126 69      STD     BSD     { int sbrk(int incr); }
  127 70      STD     BSD     { int sstk(int incr); }
  128 71      COMPAT  BSD     { int mmap(void *addr, int len, int prot, \
  129                             int flags, int fd, long pos); }
  130 72      STD     BSD     { int ovadvise(int anom); } vadvise ovadvise_args int
  131 73      STD     BSD     { int munmap(void *addr, size_t len); }
  132 74      STD     BSD     { int mprotect(const void *addr, size_t len, int prot); }
  133 75      STD     BSD     { int madvise(void *addr, size_t len, int behav); }
  134 76      OBSOL   NOHIDE  vhangup
  135 77      OBSOL   NOHIDE  vlimit
  136 78      STD     BSD     { int mincore(const void *addr, size_t len, \
  137                             char *vec); }
  138 79      STD     POSIX   { int getgroups(u_int gidsetsize, gid_t *gidset); }
  139 80      STD     POSIX   { int setgroups(u_int gidsetsize, gid_t *gidset); }
  140 81      MPSAFE  STD     POSIX   { int getpgrp(void); }
  141 82      STD     POSIX   { int setpgid(int pid, int pgid); }
  142 83      STD     BSD     { int setitimer(u_int which, struct itimerval *itv, \
  143                             struct itimerval *oitv); }
  144 84      COMPAT  BSD     { int wait(void); }
  145 85      STD     BSD     { int swapon(char *name); }
  146 86      STD     BSD     { int getitimer(u_int which, struct itimerval *itv); }
  147 87      COMPAT  BSD     { int gethostname(char *hostname, u_int len); } \
  148                             gethostname gethostname_args int
  149 88      COMPAT  BSD     { int sethostname(char *hostname, u_int len); } \
  150                             sethostname sethostname_args int
  151 89      STD     BSD     { int getdtablesize(void); }
  152 90      STD     POSIX   { int dup2(u_int from, u_int to); }
  153 91      UNIMPL  BSD     getdopt
  154 92      STD     POSIX   { int fcntl(int fd, int cmd, long arg); }
  155 ; XXX should be         { int fcntl(int fd, int cmd, ...); }
  156 ; but we're not ready for varargs.
  157 ; XXX man page says `int arg' too.
  158 93      STD     BSD     { int select(int nd, fd_set *in, fd_set *ou, \
  159                             fd_set *ex, struct timeval *tv); }
  160 94      UNIMPL  BSD     setdopt
  161 95      STD     POSIX   { int fsync(int fd); }
  162 96      STD     BSD     { int setpriority(int which, int who, int prio); }
  163 97      STD     BSD     { int socket(int domain, int type, int protocol); }
  164 98      STD     BSD     { int connect(int s, caddr_t name, int namelen); }
  165 99      CPT_NOA BSD     { int accept(int s, caddr_t name, int *anamelen); } \
  166                             accept accept_args int
  167 100     STD     BSD     { int getpriority(int which, int who); }
  168 101     COMPAT  BSD     { int send(int s, caddr_t buf, int len, int flags); }
  169 102     COMPAT  BSD     { int recv(int s, caddr_t buf, int len, int flags); }
  170 103     COMPAT  BSD     { int sigreturn(struct osigcontext *sigcntxp); }
  171 104     STD     BSD     { int bind(int s, caddr_t name, int namelen); }
  172 105     STD     BSD     { int setsockopt(int s, int level, int name, \
  173                             caddr_t val, int valsize); }
  174 106     STD     BSD     { int listen(int s, int backlog); }
  175 107     OBSOL   NOHIDE  vtimes
  176 108     COMPAT  BSD     { int sigvec(int signum, struct sigvec *nsv, \
  177                             struct sigvec *osv); }
  178 109     COMPAT  BSD     { int sigblock(int mask); }
  179 110     COMPAT  BSD     { int sigsetmask(int mask); }
  180 111     COMPAT  POSIX   { int sigsuspend(osigset_t mask); }
  181 ; XXX note nonstandard (bogus) calling convention - the libc stub passes
  182 ; us the mask, not a pointer to it.
  183 112     COMPAT  BSD     { int sigstack(struct sigstack *nss, \
  184                             struct sigstack *oss); }
  185 113     COMPAT  BSD     { int recvmsg(int s, struct omsghdr *msg, int flags); }
  186 114     COMPAT  BSD     { int sendmsg(int s, caddr_t msg, int flags); }
  187 115     OBSOL   NOHIDE  vtrace
  188 116     MPSAFE  STD     BSD     { int gettimeofday(struct timeval *tp, \
  189                             struct timezone *tzp); }
  190 117     STD     BSD     { int getrusage(int who, struct rusage *rusage); }
  191 118     STD     BSD     { int getsockopt(int s, int level, int name, \
  192                             caddr_t val, int *avalsize); }
  193 119     UNIMPL  NOHIDE  resuba (BSD/OS 2.x)
  194 120     STD     BSD     { int readv(int fd, struct iovec *iovp, u_int iovcnt); }
  195 121     STD     BSD     { int writev(int fd, struct iovec *iovp, \
  196                             u_int iovcnt); }
  197 122     STD     BSD     { int settimeofday(struct timeval *tv, \
  198                             struct timezone *tzp); }
  199 123     STD     BSD     { int fchown(int fd, int uid, int gid); }
  200 124     STD     BSD     { int fchmod(int fd, int mode); }
  201 125     CPT_NOA BSD     { int recvfrom(int s, caddr_t buf, size_t len, \
  202                             int flags, caddr_t from, int *fromlenaddr); } \
  203                             recvfrom recvfrom_args int
  204 126     STD     BSD     { int setreuid(int ruid, int euid); }
  205 127     STD     BSD     { int setregid(int rgid, int egid); }
  206 128     STD     POSIX   { int rename(char *from, char *to); }
  207 129     COMPAT  BSD     { int truncate(char *path, long length); }
  208 130     COMPAT  BSD     { int ftruncate(int fd, long length); }
  209 131     STD     BSD     { int flock(int fd, int how); }
  210 132     STD     POSIX   { int mkfifo(char *path, int mode); }
  211 133     STD     BSD     { int sendto(int s, caddr_t buf, size_t len, \
  212                             int flags, caddr_t to, int tolen); }
  213 134     STD     BSD     { int shutdown(int s, int how); }
  214 135     STD     BSD     { int socketpair(int domain, int type, int protocol, \
  215                             int *rsv); }
  216 136     STD     POSIX   { int mkdir(char *path, int mode); }
  217 137     STD     POSIX   { int rmdir(char *path); }
  218 138     STD     BSD     { int utimes(char *path, struct timeval *tptr); }
  219 139     OBSOL   NOHIDE  4.2 sigreturn
  220 140     STD     BSD     { int adjtime(struct timeval *delta, \
  221                             struct timeval *olddelta); }
  222 141     COMPAT  BSD     { int getpeername(int fdes, caddr_t asa, int *alen); }
  223 142     COMPAT  BSD     { long gethostid(void); }
  224 143     COMPAT  BSD     { int sethostid(long hostid); }
  225 144     COMPAT  BSD     { int getrlimit(u_int which, struct orlimit *rlp); }
  226 145     COMPAT  BSD     { int setrlimit(u_int which, struct orlimit *rlp); }
  227 146     COMPAT  BSD     { int killpg(int pgid, int signum); }
  228 147     STD     POSIX   { int setsid(void); }
  229 148     STD     BSD     { int quotactl(char *path, int cmd, int uid, \
  230                             caddr_t arg); }
  231 149     COMPAT  BSD     { int quota(void); }
  232 150     CPT_NOA BSD     { int getsockname(int fdec, caddr_t asa, int *alen); }\
  233                             getsockname getsockname_args int
  234 
  235 ; Syscalls 151-180 inclusive are reserved for vendor-specific
  236 ; system calls.  (This includes various calls added for compatibity
  237 ; with other Unix variants.)
  238 ; Some of these calls are now supported by BSD...
  239 151     UNIMPL  NOHIDE  sem_lock (BSD/OS 2.x)
  240 152     UNIMPL  NOHIDE  sem_wakeup (BSD/OS 2.x)
  241 153     UNIMPL  NOHIDE  asyncdaemon (BSD/OS 2.x)
  242 154     UNIMPL  NOHIDE  nosys
  243 ; 155 is initialized by the NFS code, if present.
  244 155     NOIMPL  BSD     { int nfssvc(int flag, caddr_t argp); }
  245 156     COMPAT  BSD     { int getdirentries(int fd, char *buf, u_int count, \
  246                             long *basep); }
  247 157     STD     BSD     { int statfs(char *path, struct statfs *buf); }
  248 158     STD     BSD     { int fstatfs(int fd, struct statfs *buf); }
  249 159     UNIMPL  NOHIDE  nosys
  250 160     UNIMPL  NOHIDE  nosys
  251 ; 161 is initialized by the NFS code, if present.
  252 161     STD     BSD     { int getfh(char *fname, struct fhandle *fhp); }
  253 162     STD     BSD     { int getdomainname(char *domainname, int len); }
  254 163     STD     BSD     { int setdomainname(char *domainname, int len); }
  255 164     STD     BSD     { int uname(struct utsname *name); }
  256 165     STD     BSD     { int sysarch(int op, char *parms); }
  257 166     STD     BSD     { int rtprio(int function, pid_t pid, \
  258                             struct rtprio *rtp); }
  259 167     UNIMPL  NOHIDE  nosys
  260 168     UNIMPL  NOHIDE  nosys
  261 169     STD     BSD     { int semsys(int which, int a2, int a3, int a4, \
  262                             int a5); }
  263 ; XXX should be         { int semsys(int which, ...); }
  264 170     STD     BSD     { int msgsys(int which, int a2, int a3, int a4, \
  265                             int a5, int a6); }
  266 ; XXX should be         { int msgsys(int which, ...); }
  267 171     STD     BSD     { int shmsys(int which, int a2, int a3, int a4); }
  268 ; XXX should be         { int shmsys(int which, ...); }
  269 172     UNIMPL  NOHIDE  nosys
  270 173     STD     POSIX   { ssize_t pread(int fd, void *buf, size_t nbyte, \
  271                             int pad, off_t offset); }
  272 174     STD     POSIX   { ssize_t pwrite(int fd, const void *buf, \
  273                             size_t nbyte, int pad, off_t offset); }
  274 175     UNIMPL  NOHIDE  nosys
  275 176     STD     BSD     { int ntp_adjtime(struct timex *tp); }
  276 177     UNIMPL  NOHIDE  sfork (BSD/OS 2.x)
  277 178     UNIMPL  NOHIDE  getdescriptor (BSD/OS 2.x)
  278 179     UNIMPL  NOHIDE  setdescriptor (BSD/OS 2.x)
  279 180     UNIMPL  NOHIDE  nosys
  280 
  281 ; Syscalls 181-199 are used by/reserved for BSD
  282 181     STD     POSIX   { int setgid(gid_t gid); }
  283 182     STD     BSD     { int setegid(gid_t egid); }
  284 183     STD     BSD     { int seteuid(uid_t euid); }
  285 184     UNIMPL  BSD     lfs_bmapv
  286 185     UNIMPL  BSD     lfs_markv
  287 186     UNIMPL  BSD     lfs_segclean
  288 187     UNIMPL  BSD     lfs_segwait
  289 188     STD     POSIX   { int stat(char *path, struct stat *ub); }
  290 189     STD     POSIX   { int fstat(int fd, struct stat *sb); }
  291 190     STD     POSIX   { int lstat(char *path, struct stat *ub); }
  292 191     STD     POSIX   { int pathconf(char *path, int name); }
  293 192     STD     POSIX   { int fpathconf(int fd, int name); }
  294 193     UNIMPL  NOHIDE  nosys
  295 194     STD     BSD     { int getrlimit(u_int which, \
  296                             struct rlimit *rlp); } \
  297                             getrlimit __getrlimit_args int
  298 195     STD     BSD     { int setrlimit(u_int which, \
  299                             struct rlimit *rlp); } \
  300                             setrlimit __setrlimit_args int
  301 196     STD     BSD     { int getdirentries(int fd, char *buf, u_int count, \
  302                             long *basep); }
  303 197     STD     BSD     { caddr_t mmap(caddr_t addr, size_t len, int prot, \
  304                             int flags, int fd, int pad, off_t pos); }
  305 198     STD     NOHIDE  { int nosys(void); } __syscall __syscall_args int
  306 199     STD     POSIX   { off_t lseek(int fd, int pad, off_t offset, \
  307                             int whence); }
  308 200     STD     BSD     { int truncate(char *path, int pad, off_t length); }
  309 201     STD     BSD     { int ftruncate(int fd, int pad, off_t length); }
  310 202     STD     BSD     { int __sysctl(int *name, u_int namelen, void *old, \
  311                             size_t *oldlenp, void *new, size_t newlen); } \
  312                             __sysctl sysctl_args int
  313 ; properly, __sysctl should be a NOHIDE, but making an exception
  314 ; here allows to avoid one in libc/sys/Makefile.inc.
  315 203     STD     BSD     { int mlock(const void *addr, size_t len); }
  316 204     STD     BSD     { int munlock(const void *addr, size_t len); }
  317 205     STD     BSD     { int undelete(char *path); }
  318 206     STD     BSD     { int futimes(int fd, struct timeval *tptr); }
  319 207     STD     BSD     { int getpgid(pid_t pid); }
  320 208     UNIMPL  NOHIDE  newreboot (NetBSD)
  321 209     STD     BSD     { int poll(struct pollfd *fds, u_int nfds, \
  322                             int timeout); }
  323 
  324 ;
  325 ; The following are reserved for loadable syscalls
  326 ;
  327 210     NODEF   NOHIDE  lkmnosys lkmnosys nosys_args int
  328 211     NODEF   NOHIDE  lkmnosys lkmnosys nosys_args int
  329 212     NODEF   NOHIDE  lkmnosys lkmnosys nosys_args int
  330 213     NODEF   NOHIDE  lkmnosys lkmnosys nosys_args int
  331 214     NODEF   NOHIDE  lkmnosys lkmnosys nosys_args int
  332 215     NODEF   NOHIDE  lkmnosys lkmnosys nosys_args int
  333 216     NODEF   NOHIDE  lkmnosys lkmnosys nosys_args int
  334 217     NODEF   NOHIDE  lkmnosys lkmnosys nosys_args int
  335 218     NODEF   NOHIDE  lkmnosys lkmnosys nosys_args int
  336 219     NODEF   NOHIDE  lkmnosys lkmnosys nosys_args int
  337 
  338 ;
  339 ; The following were introduced with NetBSD/4.4Lite-2
  340 ;
  341 220     STD     BSD     { int __semctl(int semid, int semnum, int cmd, \
  342                             union semun *arg); }
  343 221     STD     BSD     { int semget(key_t key, int nsems, int semflg); }
  344 222     STD     BSD     { int semop(int semid, struct sembuf *sops, \
  345                             u_int nsops); }
  346 223     UNIMPL  NOHIDE  semconfig
  347 224     STD     BSD     { int msgctl(int msqid, int cmd, \
  348                             struct msqid_ds *buf); }
  349 225     STD     BSD     { int msgget(key_t key, int msgflg); }
  350 226     STD     BSD     { int msgsnd(int msqid, void *msgp, size_t msgsz, \
  351                             int msgflg); }
  352 227     STD     BSD     { int msgrcv(int msqid, void *msgp, size_t msgsz, \
  353                             long msgtyp, int msgflg); }
  354 228     STD     BSD     { int shmat(int shmid, void *shmaddr, int shmflg); }
  355 229     STD     BSD     { int shmctl(int shmid, int cmd, \
  356                             struct shmid_ds *buf); }
  357 230     STD     BSD     { int shmdt(void *shmaddr); }
  358 231     STD     BSD     { int shmget(key_t key, int size, int shmflg); }
  359 ;
  360 232     STD     POSIX   { int clock_gettime(clockid_t clock_id, \
  361                             struct timespec *tp); }
  362 233     STD     POSIX   { int clock_settime(clockid_t clock_id, \
  363                             const struct timespec *tp); }
  364 234     STD     POSIX   { int clock_getres(clockid_t clock_id, \
  365                             struct timespec *tp); }
  366 235     UNIMPL  NOHIDE  timer_create
  367 236     UNIMPL  NOHIDE  timer_delete
  368 237     UNIMPL  NOHIDE  timer_settime
  369 238     UNIMPL  NOHIDE  timer_gettime
  370 239     UNIMPL  NOHIDE  timer_getoverrun
  371 240     STD     POSIX   { int nanosleep(const struct timespec *rqtp, \
  372                             struct timespec *rmtp); }
  373 241     UNIMPL  NOHIDE  nosys
  374 242     UNIMPL  NOHIDE  nosys
  375 243     UNIMPL  NOHIDE  nosys
  376 244     UNIMPL  NOHIDE  nosys
  377 245     UNIMPL  NOHIDE  nosys
  378 246     UNIMPL  NOHIDE  nosys
  379 247     UNIMPL  NOHIDE  nosys
  380 248     UNIMPL  NOHIDE  nosys
  381 249     UNIMPL  NOHIDE  nosys
  382 ; syscall numbers initially used in OpenBSD
  383 250     STD     BSD     { int minherit(void *addr, size_t len, int inherit); }
  384 251     STD     BSD     { int rfork(int flags); }
  385 252     STD     BSD     { int openbsd_poll(struct pollfd *fds, u_int nfds, \
  386                             int timeout); }
  387 253     STD     BSD     { int issetugid(void); }
  388 254     STD     BSD     { int lchown(char *path, int uid, int gid); }
  389 255     UNIMPL  NOHIDE  nosys
  390 256     UNIMPL  NOHIDE  nosys
  391 257     UNIMPL  NOHIDE  nosys
  392 258     UNIMPL  NOHIDE  nosys
  393 259     UNIMPL  NOHIDE  nosys
  394 260     UNIMPL  NOHIDE  nosys
  395 261     UNIMPL  NOHIDE  nosys
  396 262     UNIMPL  NOHIDE  nosys
  397 263     UNIMPL  NOHIDE  nosys
  398 264     UNIMPL  NOHIDE  nosys
  399 265     UNIMPL  NOHIDE  nosys
  400 266     UNIMPL  NOHIDE  nosys
  401 267     UNIMPL  NOHIDE  nosys
  402 268     UNIMPL  NOHIDE  nosys
  403 269     UNIMPL  NOHIDE  nosys
  404 270     UNIMPL  NOHIDE  nosys
  405 271     UNIMPL  NOHIDE  nosys
  406 272     STD     BSD     { int getdents(int fd, char *buf, size_t count); }
  407 273     UNIMPL  NOHIDE  nosys
  408 274     STD     BSD     { int lchmod(char *path, mode_t mode); }
  409 275     NOPROTO BSD     { int lchown(char *path, uid_t uid, gid_t gid); } netbsd_lchown lchown_args int
  410 276     STD     BSD     { int lutimes(char *path, struct timeval *tptr); }
  411 277     NOPROTO BSD     { int msync(void *addr, size_t len, int flags); } netbsd_msync msync_args int
  412 278     STD     BSD     { int nstat(char *path, struct nstat *ub); }
  413 279     STD     BSD     { int nfstat(int fd, struct nstat *sb); }
  414 280     STD     BSD     { int nlstat(char *path, struct nstat *ub); }
  415 281     UNIMPL  NOHIDE  nosys
  416 282     UNIMPL  NOHIDE  nosys
  417 283     UNIMPL  NOHIDE  nosys
  418 284     UNIMPL  NOHIDE  nosys
  419 285     UNIMPL  NOHIDE  nosys
  420 286     UNIMPL  NOHIDE  nosys
  421 287     UNIMPL  NOHIDE  nosys
  422 288     UNIMPL  NOHIDE  nosys
  423 289     UNIMPL  NOHIDE  nosys
  424 290     UNIMPL  NOHIDE  nosys
  425 291     UNIMPL  NOHIDE  nosys
  426 292     UNIMPL  NOHIDE  nosys
  427 293     UNIMPL  NOHIDE  nosys
  428 294     UNIMPL  NOHIDE  nosys
  429 295     UNIMPL  NOHIDE  nosys
  430 296     UNIMPL  NOHIDE  nosys
  431 ; XXX 297 is 300 in NetBSD 
  432 297     STD     BSD     { int fhstatfs(const struct fhandle *u_fhp, struct statfs *buf); }
  433 298     STD     BSD     { int fhopen(const struct fhandle *u_fhp, int flags); }
  434 299     STD     BSD     { int fhstat(const struct fhandle *u_fhp, struct stat *sb); }
  435 ; syscall numbers for FreeBSD
  436 300     STD     BSD     { int modnext(int modid); }
  437 301     STD     BSD     { int modstat(int modid, struct module_stat* stat); }
  438 302     STD     BSD     { int modfnext(int modid); }
  439 303     STD     BSD     { int modfind(const char *name); }
  440 304     STD     BSD     { int kldload(const char *file); }
  441 305     STD     BSD     { int kldunload(int fileid); }
  442 306     STD     BSD     { int kldfind(const char *file); }
  443 307     STD     BSD     { int kldnext(int fileid); }
  444 308     STD     BSD     { int kldstat(int fileid, struct kld_file_stat* stat); }
  445 309     STD     BSD     { int kldfirstmod(int fileid); }
  446 310     STD     BSD     { int getsid(pid_t pid); }
  447 311     STD     BSD     { int setresuid(uid_t ruid, uid_t euid, uid_t suid); }
  448 312     STD     BSD     { int setresgid(gid_t rgid, gid_t egid, gid_t sgid); }
  449 313     OBSOL   NOHIDE  signanosleep
  450 314     STD     BSD     { int aio_return(struct aiocb *aiocbp); }
  451 315     STD     BSD     { int aio_suspend(struct aiocb * const * aiocbp, int nent, const struct timespec *timeout); }
  452 316     STD     BSD     { int aio_cancel(int fd, struct aiocb *aiocbp); }
  453 317     STD     BSD     { int aio_error(struct aiocb *aiocbp); }
  454 318     STD     BSD     { int aio_read(struct aiocb *aiocbp); }
  455 319     STD     BSD     { int aio_write(struct aiocb *aiocbp); }
  456 320     STD     BSD     { int lio_listio(int mode, struct aiocb * const *acb_list, int nent, struct sigevent *sig); }
  457 321     STD     BSD     { int yield(void); }
  458 322     STD     BSD     { int thr_sleep(const struct timespec *timeout); }
  459 323     STD     BSD     { int thr_wakeup(pid_t pid); }
  460 324     STD     BSD     { int mlockall(int how); }
  461 325     STD     BSD     { int munlockall(void); }
  462 326     STD     BSD     { int __getcwd(u_char *buf, u_int buflen); }
  463 
  464 327     STD     POSIX   { int sched_setparam (pid_t pid, const struct sched_param *param); }
  465 328     STD     POSIX   { int sched_getparam (pid_t pid, struct sched_param *param); }
  466 
  467 329     STD     POSIX   { int sched_setscheduler (pid_t pid, int policy, const struct sched_param *param); }
  468 330     STD     POSIX   { int sched_getscheduler (pid_t pid); }
  469 
  470 331     STD     POSIX   { int sched_yield (void); }
  471 332     STD     POSIX   { int sched_get_priority_max (int policy); }
  472 333     STD     POSIX   { int sched_get_priority_min (int policy); }
  473 334     STD     POSIX   { int sched_rr_get_interval (pid_t pid, struct timespec *interval); }
  474 335     STD     BSD     { int utrace(const void *addr, size_t len); }
  475 336     COMPAT  BSD     { int sendfile(int fd, int s, off_t offset, size_t nbytes, \
  476                                 struct sf_hdtr *hdtr, off_t *sbytes, int flags); }
  477 337     STD     BSD     { int kldsym(int fileid, int cmd, void *data); }
  478 338     STD     BSD     { int jail(struct jail *jail); }
  479 339     UNIMPL  BSD     pioctl
  480 340     MPSAFE  STD     POSIX   { int sigprocmask(int how, const sigset_t *set, \
  481                             sigset_t *oset); }
  482 341     STD     POSIX   { int sigsuspend(const sigset_t *sigmask); }
  483 342     STD     POSIX   { int sigaction(int sig, const struct sigaction *act, \
  484                             struct sigaction *oact); }
  485 343     STD     POSIX   { int sigpending(sigset_t *set); }
  486 344     STD     BSD     { int sigreturn(ucontext_t *sigcntxp); }
  487 345     UNIMPL  NOHIDE  sigtimedwait
  488 346     UNIMPL  NOHIDE  sigwaitinfo
  489 347     STD     BSD     { int __acl_get_file(const char *path, \
  490                             acl_type_t type, struct acl *aclp); }
  491 348     STD     BSD     { int __acl_set_file(const char *path, \
  492                             acl_type_t type, struct acl *aclp); }
  493 349     STD     BSD     { int __acl_get_fd(int filedes, acl_type_t type, \
  494                             struct acl *aclp); }
  495 350     STD     BSD     { int __acl_set_fd(int filedes, acl_type_t type, \
  496                             struct acl *aclp); }
  497 351     STD     BSD     { int __acl_delete_file(const char *path, \
  498                             acl_type_t type); }
  499 352     STD     BSD     { int __acl_delete_fd(int filedes, acl_type_t type); }
  500 353     STD     BSD     { int __acl_aclcheck_file(const char *path, \
  501                             acl_type_t type, struct acl *aclp); }
  502 354     STD     BSD     { int __acl_aclcheck_fd(int filedes, acl_type_t type, \
  503                             struct acl *aclp); }
  504 355     STD     BSD     { int extattrctl(const char *path, int cmd, \
  505                             const char *attrname, char *arg); }
  506 356     STD     BSD     { int extattr_set_file(const char *path, \
  507                             const char *attrname, struct iovec *iovp, \
  508                             unsigned iovcnt); }
  509 357     STD     BSD     { int extattr_get_file(const char *path, \
  510                             const char *attrname, struct iovec *iovp, \
  511                             unsigned iovcnt); }
  512 358     STD     BSD     { int extattr_delete_file(const char *path, \
  513                             const char *attrname); }
  514 359     STD     BSD     { int aio_waitcomplete(struct aiocb **aiocbp, struct timespec *timeout); }
  515 360     STD     BSD     { int getresuid(uid_t *ruid, uid_t *euid, uid_t *suid); }
  516 361     STD     BSD     { int getresgid(gid_t *rgid, gid_t *egid, gid_t *sgid); }
  517 362     STD     BSD     { int kqueue(void); }
  518 363     STD     BSD     { int kevent(int fd, \
  519                             const struct kevent *changelist, int nchanges, \
  520                             struct kevent *eventlist, int nevents, \
  521                             const struct timespec *timeout); }
  522 
  523 364     UNIMPL  NOHIDE  nosys
  524 365     UNIMPL  NOHIDE  nosys
  525 366     UNIMPL  NOHIDE  nosys
  526 367     UNIMPL  NOHIDE  nosys
  527 368     UNIMPL  NOHIDE  nosys
  528 369     UNIMPL  NOHIDE  nosys
  529 370     UNIMPL  NOHIDE  nosys
  530 371     UNIMPL  NOHIDE  nosys
  531 372     UNIMPL  NOHIDE  nosys
  532 373     UNIMPL  NOHIDE  nosys
  533 374     UNIMPL  NOHIDE  nosys
  534 375     UNIMPL  NOHIDE  nosys
  535 376     UNIMPL  NOHIDE  nosys
  536 377     UNIMPL  NOHIDE  nosys
  537 378     UNIMPL  NOHIDE  nosys
  538 379     UNIMPL  NOHIDE  nosys
  539 380     UNIMPL  NOHIDE  nosys
  540 381     UNIMPL  NOHIDE  nosys
  541 382     UNIMPL  NOHIDE  nosys
  542 383     UNIMPL  NOHIDE  nosys
  543 384     UNIMPL  NOHIDE  nosys
  544 385     UNIMPL  NOHIDE  nosys
  545 386     UNIMPL  NOHIDE  nosys
  546 387     UNIMPL  NOHIDE  nosys
  547 388     UNIMPL  NOHIDE  nosys
  548 389     UNIMPL  NOHIDE  nosys
  549 390     UNIMPL  NOHIDE  nosys
  550 391     UNIMPL  NOHIDE  nosys
  551 392     UNIMPL  NOHIDE  nosys
  552 393     STD     BSD     { int sendfile(int fd, int s, off_t offset, size_t nbytes, \
  553                                 struct sf_hdtr *hdtr, off_t *sbytes, int flags); }

Cache object: 446f778ceb139a436de19636f7be3977


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