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

Cache object: a42d7bc98eda22d59315d417ebcd9392


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