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

Cache object: 3c6d5317f3208e7b52bc069b3efafe4e


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