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 ; @(#)syscalls.master   8.2 (Berkeley) 1/13/94
    2 ; $FreeBSD: src/sys/kern/syscalls.master,v 1.72.2.10 2002/07/12 08:22:46 alfred Exp $
    3 ;
    4 ; System call name/number master file.
    5 ; Processed to create kern/init_sysent.c, kern/syscalls.c, sys/syscall.h,
    6 ;                     sys/syscall.mk, sys/sysproto.h and sys/sysunion.h
    7 
    8 ; Columns: number type nargs namespc name alt{name,tag,rtyp}/comments
    9 ;       number  system call number, must be in order
   10 ;       type    one of STD, OBSOL, UNIMPL, COMPAT, CPT_NOA, LIBCOMPAT,
   11 ;               NODEF, NOARGS, NOPROTO, NOIMPL
   12 ;       name    pseudo-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 ;       NOTE: All system calls are now called without the MP lock.  Those
   20 ;             that need the MP lock will acquire it.
   21 
   22 ; types:
   23 ;       STD     always included
   24 ;       COMPAT  included on COMPAT #ifdef
   25 ;       LIBCOMPAT included on COMPAT #ifdef, and placed in syscall.h
   26 ;       OBSOL   obsolete, not included in system, only specifies name
   27 ;       UNIMPL  not implemented, placeholder only
   28 
   29 ; #ifdef's, etc. may be included, and are copied to the output files.
   30 
   31 #include <sys/param.h>
   32 #include <sys/sysent.h>
   33 #include <sys/sysproto.h>
   34 #include <sys/statvfs.h>
   35 
   36 #ifdef COMPAT_43
   37 #include <emulation/43bsd/stat.h>
   38 #endif
   39 
   40 #include <emulation/dragonfly12/stat.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       STD     { int nosys(void); } syscall nosys_args int
   49 1       STD     { void exit(int rval); }
   50 2       STD     { int fork(void); }
   51 3       STD     { ssize_t read(int fd, void *buf, size_t nbyte); }
   52 4       STD     { ssize_t write(int fd, const void *buf, size_t nbyte); }
   53 5       STD     { 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       STD     { int close(int fd); }
   58 7       STD     { int wait4(int pid, int *status, int options, \
   59                             struct rusage *rusage); } wait4 wait_args int
   60 8       COMPAT  { int creat(char *path, int mode); }
   61 9       STD     { int link(char *path, char *link); }
   62 10      STD     { 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      STD     { int obreak(char *nsize); } break obreak_args int
   70 18      STD     { int getfsstat(struct statfs *buf, long bufsize, \
   71                             int flags); }
   72 19      COMPAT  { long lseek(int fd, long offset, int whence); }
   73 20      STD     { pid_t getpid(void); }
   74 21      STD     { int mount(char *type, char *path, int flags, \
   75                             caddr_t data); }
   76 ; XXX `path' should have type `const char *' but we're not ready for that.
   77 22      STD     { int unmount(char *path, int flags); }
   78 23      STD     { int setuid(uid_t uid); }
   79 24      STD     { uid_t getuid(void); }
   80 25      STD     { uid_t geteuid(void); }
   81 26      STD     { int ptrace(int req, pid_t pid, caddr_t addr, \
   82                             int data); }
   83 27      STD     { int recvmsg(int s, struct msghdr *msg, int flags); }
   84 28      STD     { int sendmsg(int s, caddr_t msg, int flags); }
   85 29      STD     { int recvfrom(int s, caddr_t buf, size_t len, \
   86                             int flags, caddr_t from, int *fromlenaddr); }
   87 30      STD     { int accept(int s, caddr_t name, int *anamelen); }
   88 31      STD     { int getpeername(int fdes, caddr_t asa, int *alen); }
   89 32      STD     { int getsockname(int fdes, caddr_t asa, int *alen); }
   90 33      STD     { int access(char *path, int flags); }
   91 34      STD     { int chflags(char *path, int flags); }
   92 35      STD     { int fchflags(int fd, int flags); }
   93 36      STD     { int sync(void); }
   94 37      STD     { int kill(int pid, int signum); }
   95 38      COMPAT  { int stat(char *path, struct ostat *ub); }
   96 39      STD     { pid_t getppid(void); }
   97 40      COMPAT  { int lstat(char *path, struct ostat *ub); }
   98 41      STD     { int dup(u_int fd); }
   99 42      STD     { int pipe(void); }
  100 43      STD     { gid_t getegid(void); }
  101 44      STD     { int profil(caddr_t samples, size_t size, \
  102                             size_t offset, u_int scale); }
  103 45      STD     { int ktrace(const char *fname, int ops, int facs, \
  104                             int pid); }
  105 46      OBSOL   freebsd3_sigaction
  106 47      STD     { gid_t getgid(void); }
  107 48      OBSOL   freebsd3_sigprocmask
  108 ; XXX note nonstandard (bogus) calling convention - the libc stub passes
  109 ; us the mask, not a pointer to it, and we return the old mask as the
  110 ; (int) return value.
  111 49      STD     { int getlogin(char *namebuf, u_int namelen); }
  112 50      STD     { int setlogin(char *namebuf); }
  113 51      STD     { int acct(char *path); }
  114 52      OBSOL   freebsd3_sigpending
  115 53      STD     { int sigaltstack(stack_t *ss, stack_t *oss); }
  116 54      STD     { int ioctl(int fd, u_long com, caddr_t data); }
  117 55      STD     { int reboot(int opt); }
  118 56      STD     { int revoke(char *path); }
  119 57      STD     { int symlink(char *path, char *link); }
  120 58      STD     { int readlink(char *path, char *buf, int count); }
  121 59      STD     { int execve(char *fname, char **argv, char **envv); }
  122 60      STD     { int umask(int newmask); } umask umask_args int
  123 61      STD     { int chroot(char *path); }
  124 62      COMPAT  { int fstat(int fd, struct ostat *sb); }
  125 63      COMPAT  { int getkerninfo(int op, char *where, size_t *size, \
  126                             int arg); } getkerninfo getkerninfo_args int
  127 64      COMPAT  { int getpagesize(void); } \
  128                             getpagesize getpagesize_args int
  129 65      STD     { int msync(void *addr, size_t len, int flags); }
  130 66      STD     { pid_t vfork(void); }
  131 67      OBSOL   vread
  132 68      OBSOL   vwrite
  133 69      STD     { int sbrk(int incr); }
  134 70      STD     { int sstk(int incr); }
  135 71      COMPAT  { int mmap(void *addr, int len, int prot, \
  136                             int flags, int fd, long pos); }
  137 72      COMPAT  { int vadvise(int anom); } vadvise ovadvise_args int
  138 73      STD     { int munmap(void *addr, size_t len); }
  139 74      STD     { int mprotect(void *addr, size_t len, int prot); }
  140 75      STD     { int madvise(void *addr, size_t len, int behav); }
  141 76      OBSOL   vhangup
  142 77      OBSOL   vlimit
  143 78      STD     { int mincore(const void *addr, size_t len, \
  144                             char *vec); }
  145 79      STD     { int getgroups(u_int gidsetsize, gid_t *gidset); }
  146 80      STD     { int setgroups(u_int gidsetsize, gid_t *gidset); }
  147 81      STD     { int getpgrp(void); }
  148 82      STD     { int setpgid(int pid, int pgid); }
  149 83      STD     { int setitimer(u_int which, struct itimerval *itv, \
  150                             struct itimerval *oitv); }
  151 84      COMPAT  { int wait(void); }
  152 85      STD     { int swapon(char *name); }
  153 86      STD     { int getitimer(u_int which, struct itimerval *itv); }
  154 87      COMPAT  { int gethostname(char *hostname, u_int len); } \
  155                             gethostname gethostname_args int
  156 88      COMPAT  { int sethostname(char *hostname, u_int len); } \
  157                             sethostname sethostname_args int
  158 89      STD     { int getdtablesize(void); }
  159 90      STD     { int dup2(u_int from, u_int to); }
  160 91      UNIMPL  getdopt
  161 92      STD     { int fcntl(int fd, int cmd, long arg); }
  162 ; XXX should be         { int fcntl(int fd, int cmd, ...); }
  163 ; but we're not ready for varargs.
  164 ; XXX man page says `int arg' too.
  165 93      STD     { int select(int nd, fd_set *in, fd_set *ou, \
  166                             fd_set *ex, struct timeval *tv); }
  167 94      UNIMPL  setdopt
  168 95      STD     { int fsync(int fd); }
  169 96      STD     { int setpriority(int which, int who, int prio); }
  170 97      STD     { int socket(int domain, int type, int protocol); }
  171 98      STD     { int connect(int s, caddr_t name, int namelen); }
  172 99      CPT_NOA { int accept(int s, caddr_t name, int *anamelen); } \
  173                             accept accept_args int
  174 100     STD     { int getpriority(int which, int who); }
  175 101     COMPAT  { int send(int s, caddr_t buf, int len, int flags); }
  176 102     COMPAT  { int recv(int s, caddr_t buf, int len, int flags); }
  177 103     OBSOL   freebsd3_sigreturn
  178 104     STD     { int bind(int s, caddr_t name, int namelen); }
  179 105     STD     { int setsockopt(int s, int level, int name, \
  180                             caddr_t val, int valsize); }
  181 106     STD     { int listen(int s, int backlog); }
  182 107     OBSOL   vtimes
  183 108     COMPAT  { int sigvec(int signum, struct sigvec *nsv, \
  184                             struct sigvec *osv); }
  185 109     COMPAT  { int sigblock(int mask); }
  186 110     COMPAT  { int sigsetmask(int mask); }
  187 111     OBSOL   freebsd3_sigsuspend
  188 ; XXX note nonstandard (bogus) calling convention - the libc stub passes
  189 ; us the mask, not a pointer to it.
  190 112     COMPAT  { int sigstack(struct sigstack *nss, \
  191                             struct sigstack *oss); }
  192 113     COMPAT  { int recvmsg(int s, struct omsghdr *msg, int flags); }
  193 114     COMPAT  { int sendmsg(int s, caddr_t msg, int flags); }
  194 115     OBSOL   vtrace
  195 116     STD     { int gettimeofday(struct timeval *tp, \
  196                             struct timezone *tzp); }
  197 117     STD     { int getrusage(int who, struct rusage *rusage); }
  198 118     STD     { int getsockopt(int s, int level, int name, \
  199                             caddr_t val, int *avalsize); }
  200 119     UNIMPL  resuba (BSD/OS 2.x)
  201 120     STD     { int readv(int fd, struct iovec *iovp, u_int iovcnt); }
  202 121     STD     { int writev(int fd, struct iovec *iovp, \
  203                             u_int iovcnt); }
  204 122     STD     { int settimeofday(struct timeval *tv, \
  205                             struct timezone *tzp); }
  206 123     STD     { int fchown(int fd, int uid, int gid); }
  207 124     STD     { int fchmod(int fd, int mode); }
  208 125     CPT_NOA { int recvfrom(int s, caddr_t buf, size_t len, \
  209                             int flags, caddr_t from, int *fromlenaddr); } \
  210                             recvfrom recvfrom_args int
  211 126     STD     { int setreuid(int ruid, int euid); }
  212 127     STD     { int setregid(int rgid, int egid); }
  213 128     STD     { int rename(char *from, char *to); }
  214 129     COMPAT  { int truncate(char *path, long length); }
  215 130     COMPAT  { int ftruncate(int fd, long length); }
  216 131     STD     { int flock(int fd, int how); }
  217 132     STD     { int mkfifo(char *path, int mode); }
  218 133     STD     { int sendto(int s, caddr_t buf, size_t len, \
  219                             int flags, caddr_t to, int tolen); }
  220 134     STD     { int shutdown(int s, int how); }
  221 135     STD     { int socketpair(int domain, int type, int protocol, \
  222                             int *rsv); }
  223 136     STD     { int mkdir(char *path, int mode); }
  224 137     STD     { int rmdir(char *path); }
  225 138     STD     { int utimes(char *path, struct timeval *tptr); }
  226 139     OBSOL   4.2 sigreturn
  227 140     STD     { int adjtime(struct timeval *delta, \
  228                             struct timeval *olddelta); }
  229 141     COMPAT  { int getpeername(int fdes, caddr_t asa, int *alen); }
  230 142     COMPAT  { long gethostid(void); }
  231 143     COMPAT  { int sethostid(long hostid); }
  232 144     COMPAT  { int getrlimit(u_int which, struct orlimit *rlp); }
  233 145     COMPAT  { int setrlimit(u_int which, struct orlimit *rlp); }
  234 146     COMPAT  { int killpg(int pgid, int signum); }
  235 147     STD     { int setsid(void); }
  236 148     STD     { int quotactl(char *path, int cmd, int uid, \
  237                             caddr_t arg); }
  238 149     COMPAT  { int quota(void); }
  239 150     CPT_NOA { int getsockname(int fdec, caddr_t asa, int *alen); }\
  240                             getsockname getsockname_args int
  241 
  242 ; Syscalls 151-180 inclusive are reserved for vendor-specific
  243 ; system calls.  (This includes various calls added for compatibity
  244 ; with other Unix variants.)
  245 ; Some of these calls are now supported by BSD...
  246 151     UNIMPL  sem_lock (BSD/OS 2.x)
  247 152     UNIMPL  sem_wakeup (BSD/OS 2.x)
  248 153     UNIMPL  asyncdaemon (BSD/OS 2.x)
  249 154     UNIMPL  nosys
  250 ; 155 is initialized by the NFS code, if present.
  251 155     NOIMPL  { int nfssvc(int flag, caddr_t argp); }
  252 156     COMPAT  { int getdirentries(int fd, char *buf, u_int count, \
  253                             long *basep); }
  254 157     STD     { int statfs(char *path, struct statfs *buf); }
  255 158     STD     { int fstatfs(int fd, struct statfs *buf); }
  256 159     UNIMPL  nosys
  257 160     UNIMPL  nosys
  258 ; 161 is initialized by the NFS code, if present.
  259 161     STD     { int getfh(char *fname, struct fhandle *fhp); }
  260 162     STD     { int getdomainname(char *domainname, int len); }
  261 163     STD     { int setdomainname(char *domainname, int len); }
  262 164     STD     { int uname(struct utsname *name); }
  263 165     STD     { int sysarch(int op, char *parms); }
  264 166     STD     { int rtprio(int function, pid_t pid, \
  265                             struct rtprio *rtp); }
  266 167     UNIMPL  nosys
  267 168     UNIMPL  nosys
  268 169     STD     { int semsys(int which, int a2, int a3, int a4, \
  269                             int a5); }
  270 ; XXX should be         { int semsys(int which, ...); }
  271 170     STD     { int msgsys(int which, int a2, int a3, int a4, \
  272                             int a5, int a6); }
  273 ; XXX should be         { int msgsys(int which, ...); }
  274 171     STD     { int shmsys(int which, int a2, int a3, int a4); }
  275 ; XXX should be         { int shmsys(int which, ...); }
  276 172     UNIMPL  nosys
  277 173     STD     { ssize_t extpread(int fd, void *buf, \
  278                             size_t nbyte, int flags, off_t offset); }
  279 174     STD     { ssize_t extpwrite(int fd, const void *buf, \
  280                             size_t nbyte, int flags, off_t offset); }
  281 175     UNIMPL  nosys
  282 176     STD     { int ntp_adjtime(struct timex *tp); }
  283 177     UNIMPL  sfork (BSD/OS 2.x)
  284 178     UNIMPL  getdescriptor (BSD/OS 2.x)
  285 179     UNIMPL  setdescriptor (BSD/OS 2.x)
  286 180     UNIMPL  nosys
  287 
  288 ; Syscalls 181-199 are used by/reserved for BSD
  289 181     STD     { int setgid(gid_t gid); }
  290 182     STD     { int setegid(gid_t egid); }
  291 183     STD     { int seteuid(uid_t euid); }
  292 184     UNIMPL  lfs_bmapv
  293 185     UNIMPL  lfs_markv
  294 186     UNIMPL  lfs_segclean
  295 187     UNIMPL  lfs_segwait
  296 188     COMPAT_DF12     { int stat(const char *path, struct dfbsd12_stat *ub); }
  297 189     COMPAT_DF12     { int fstat(int fd, struct dfbsd12_stat *sb); }
  298 190     COMPAT_DF12     { int lstat(const char *path, struct dfbsd12_stat *ub); }
  299 191     STD     { int pathconf(char *path, int name); }
  300 192     STD     { int fpathconf(int fd, int name); }
  301 193     UNIMPL  nosys
  302 194     STD     { int getrlimit(u_int which, \
  303                             struct rlimit *rlp); } \
  304                             getrlimit __getrlimit_args int
  305 195     STD     { int setrlimit(u_int which, \
  306                             struct rlimit *rlp); } \
  307                             setrlimit __setrlimit_args int
  308 196     COMPAT_DF12     { int getdirentries(int fd, char *buf, \
  309                                     u_int count, long *basep); }
  310 197     STD     { caddr_t mmap(caddr_t addr, size_t len, int prot, \
  311                             int flags, int fd, int pad, off_t pos); }
  312 198     STD     { int nosys(void); } __syscall __syscall_args int
  313 199     STD     { off_t lseek(int fd, int pad, off_t offset, \
  314                             int whence); }
  315 200     STD     { int truncate(char *path, int pad, off_t length); }
  316 201     STD     { int ftruncate(int fd, int pad, off_t length); }
  317 202     STD     { int __sysctl(int *name, u_int namelen, void *old, \
  318                             size_t *oldlenp, void *new, size_t newlen); } \
  319                             __sysctl sysctl_args int
  320 203     STD     { int mlock(const void *addr, size_t len); }
  321 204     STD     { int munlock(const void *addr, size_t len); }
  322 205     STD     { int undelete(char *path); }
  323 206     STD     { int futimes(int fd, struct timeval *tptr); }
  324 207     STD     { int getpgid(pid_t pid); }
  325 208     UNIMPL  newreboot (NetBSD)
  326 209     STD     { int poll(struct pollfd *fds, u_int nfds, \
  327                             int timeout); }
  328 
  329 ;
  330 ; The following are reserved for loadable syscalls
  331 ;
  332 ; 210 is used by the Checkpoint Module
  333 210     NODEF   lkmnosys lkmnosys nosys_args int
  334 211     NODEF   lkmnosys lkmnosys nosys_args int
  335 212     NODEF   lkmnosys lkmnosys nosys_args int
  336 213     NODEF   lkmnosys lkmnosys nosys_args int
  337 214     NODEF   lkmnosys lkmnosys nosys_args int
  338 215     NODEF   lkmnosys lkmnosys nosys_args int
  339 216     NODEF   lkmnosys lkmnosys nosys_args int
  340 217     NODEF   lkmnosys lkmnosys nosys_args int
  341 218     NODEF   lkmnosys lkmnosys nosys_args int
  342 219     NODEF   lkmnosys lkmnosys nosys_args int
  343 
  344 ;
  345 ; The following were introduced with NetBSD/4.4Lite-2
  346 ;
  347 220     STD     { int __semctl(int semid, int semnum, int cmd, \
  348                             union semun *arg); }
  349 221     STD     { int semget(key_t key, int nsems, int semflg); }
  350 222     STD     { int semop(int semid, struct sembuf *sops, \
  351                             u_int nsops); }
  352 223     UNIMPL  semconfig
  353 224     STD     { int msgctl(int msqid, int cmd, \
  354                             struct msqid_ds *buf); }
  355 225     STD     { int msgget(key_t key, int msgflg); }
  356 226     STD     { int msgsnd(int msqid, void *msgp, size_t msgsz, \
  357                             int msgflg); }
  358 227     STD     { int msgrcv(int msqid, void *msgp, size_t msgsz, \
  359                             long msgtyp, int msgflg); }
  360 228     STD     { caddr_t shmat(int shmid, const void *shmaddr, \
  361                             int shmflg); }
  362 229     STD     { int shmctl(int shmid, int cmd, \
  363                             struct shmid_ds *buf); }
  364 230     STD     { int shmdt(const void *shmaddr); }
  365 231     STD     { int shmget(key_t key, size_t size, int shmflg); }
  366 ;
  367 232     STD     { int clock_gettime(clockid_t clock_id, \
  368                             struct timespec *tp); }
  369 233     STD     { int clock_settime(clockid_t clock_id, \
  370                             const struct timespec *tp); }
  371 234     STD     { int clock_getres(clockid_t clock_id, \
  372                             struct timespec *tp); }
  373 235     UNIMPL  timer_create
  374 236     UNIMPL  timer_delete
  375 237     UNIMPL  timer_settime
  376 238     UNIMPL  timer_gettime
  377 239     UNIMPL  timer_getoverrun
  378 240     STD     { int nanosleep(const struct timespec *rqtp, \
  379                             struct timespec *rmtp); }
  380 241     UNIMPL  nosys
  381 242     UNIMPL  nosys
  382 243     UNIMPL  nosys
  383 244     UNIMPL  nosys
  384 245     UNIMPL  nosys
  385 246     UNIMPL  nosys
  386 247     UNIMPL  nosys
  387 248     UNIMPL  nosys
  388 249     UNIMPL  nosys
  389 ; syscall numbers initially used in OpenBSD
  390 250     STD     { int minherit(void *addr, size_t len, int inherit); }
  391 251     STD     { int rfork(int flags); }
  392 252     STD     { int openbsd_poll(struct pollfd *fds, u_int nfds, \
  393                             int timeout); }
  394 253     STD     { int issetugid(void); }
  395 254     STD     { int lchown(char *path, int uid, int gid); }
  396 255     UNIMPL  nosys
  397 256     UNIMPL  nosys
  398 257     UNIMPL  nosys
  399 258     UNIMPL  nosys
  400 259     UNIMPL  nosys
  401 260     UNIMPL  nosys
  402 261     UNIMPL  nosys
  403 262     UNIMPL  nosys
  404 263     UNIMPL  nosys
  405 264     UNIMPL  nosys
  406 265     UNIMPL  nosys
  407 266     UNIMPL  nosys
  408 267     UNIMPL  nosys
  409 268     UNIMPL  nosys
  410 269     UNIMPL  nosys
  411 270     UNIMPL  nosys
  412 271     UNIMPL  nosys
  413 272     COMPAT_DF12     { int getdents(int fd, char *buf, size_t count); }
  414 273     UNIMPL  nosys
  415 274     STD     { int lchmod(char *path, mode_t mode); }
  416 275     NOPROTO { int lchown(char *path, uid_t uid, gid_t gid); } netbsd_lchown lchown_args int
  417 276     STD     { int lutimes(char *path, struct timeval *tptr); }
  418 277     NOPROTO { int msync(void *addr, size_t len, int flags); } netbsd_msync msync_args int
  419 278     OBSOL   { int nstat(char *path, struct nstat *ub); }
  420 279     OBSOL   { int nfstat(int fd, struct nstat *sb); }
  421 280     OBSOL   { int nlstat(char *path, struct nstat *ub); }
  422 281     UNIMPL  nosys
  423 282     UNIMPL  nosys
  424 283     UNIMPL  nosys
  425 284     UNIMPL  nosys
  426 285     UNIMPL  nosys
  427 286     UNIMPL  nosys
  428 287     UNIMPL  nosys
  429 288     UNIMPL  nosys
  430 ; 289 and 290 from NetBSD (OpenBSD: 267 and 268)
  431 289     STD     { ssize_t extpreadv(int fd, struct iovec *iovp, \
  432                                   u_int iovcnt, int flags, off_t offset); }
  433 290     STD     { ssize_t extpwritev(int fd, struct iovec *iovp,\
  434                                   u_int iovcnt, int flags, off_t offset); }
  435 291     UNIMPL  nosys
  436 292     UNIMPL  nosys
  437 293     UNIMPL  nosys
  438 294     UNIMPL  nosys
  439 295     UNIMPL  nosys
  440 296     UNIMPL  nosys
  441 ; XXX 297 is 300 in NetBSD 
  442 297     STD     { int fhstatfs(const struct fhandle *u_fhp, struct statfs *buf); }
  443 298     STD     { int fhopen(const struct fhandle *u_fhp, int flags); }
  444 299     COMPAT_DF12     { int fhstat(const struct fhandle *u_fhp, struct dfbsd12_stat *sb); }
  445 ; syscall numbers for FreeBSD
  446 300     STD     { int modnext(int modid); }
  447 301     STD     { int modstat(int modid, struct module_stat* stat); }
  448 302     STD     { int modfnext(int modid); }
  449 303     STD     { int modfind(const char *name); }
  450 304     STD     { int kldload(const char *file); }
  451 305     STD     { int kldunload(int fileid); }
  452 306     STD     { int kldfind(const char *file); }
  453 307     STD     { int kldnext(int fileid); }
  454 308     STD     { int kldstat(int fileid, struct kld_file_stat* stat); }
  455 309     STD     { int kldfirstmod(int fileid); }
  456 310     STD     { int getsid(pid_t pid); }
  457 311     STD     { int setresuid(uid_t ruid, uid_t euid, uid_t suid); }
  458 312     STD     { int setresgid(gid_t rgid, gid_t egid, gid_t sgid); }
  459 313     OBSOL   signanosleep
  460 314     STD     { int aio_return(struct aiocb *aiocbp); }
  461 315     STD     { int aio_suspend(struct aiocb * const * aiocbp, int nent, const struct timespec *timeout); }
  462 316     STD     { int aio_cancel(int fd, struct aiocb *aiocbp); }
  463 317     STD     { int aio_error(struct aiocb *aiocbp); }
  464 318     STD     { int aio_read(struct aiocb *aiocbp); }
  465 319     STD     { int aio_write(struct aiocb *aiocbp); }
  466 320     STD     { int lio_listio(int mode, struct aiocb * const *acb_list, int nent, struct sigevent *sig); }
  467 321     STD     { int yield(void); }
  468 322     UNIMPL  thr_sleep
  469 323     UNIMPL  thr_wakeup
  470 324     STD     { int mlockall(int how); }
  471 325     STD     { int munlockall(void); }
  472 326     STD     { int __getcwd(u_char *buf, u_int buflen); }
  473 
  474 327     STD     { int sched_setparam (pid_t pid, const struct sched_param *param); }
  475 328     STD     { int sched_getparam (pid_t pid, struct sched_param *param); }
  476 
  477 329     STD     { int sched_setscheduler (pid_t pid, int policy, const struct sched_param *param); }
  478 330     STD     { int sched_getscheduler (pid_t pid); }
  479 
  480 331     STD     { int sched_yield (void); }
  481 332     STD     { int sched_get_priority_max (int policy); }
  482 333     STD     { int sched_get_priority_min (int policy); }
  483 334     STD     { int sched_rr_get_interval (pid_t pid, struct timespec *interval); }
  484 335     STD     { int utrace(const void *addr, size_t len); }
  485 336     OBSOL   freebsd4_sendfile
  486 337     STD     { int kldsym(int fileid, int cmd, void *data); }
  487 338     STD     { int jail(struct jail *jail); }
  488 339     UNIMPL  pioctl
  489 340     STD     { int sigprocmask(int how, const sigset_t *set, \
  490                             sigset_t *oset); }
  491 341     STD     { int sigsuspend(const sigset_t *sigmask); }
  492 342     STD     { int sigaction(int sig, const struct sigaction *act, \
  493                             struct sigaction *oact); }
  494 343     STD     { int sigpending(sigset_t *set); }
  495 344     STD     { int sigreturn(ucontext_t *sigcntxp); }
  496 345     STD     { int sigtimedwait(const sigset_t *set,\
  497                              siginfo_t *info, const struct timespec *timeout); }
  498 346     STD     { int sigwaitinfo(const sigset_t *set,\
  499                              siginfo_t *info); }
  500 347     STD     { int __acl_get_file(const char *path, \
  501                             acl_type_t type, struct acl *aclp); }
  502 348     STD     { int __acl_set_file(const char *path, \
  503                             acl_type_t type, struct acl *aclp); }
  504 349     STD     { int __acl_get_fd(int filedes, acl_type_t type, \
  505                             struct acl *aclp); }
  506 350     STD     { int __acl_set_fd(int filedes, acl_type_t type, \
  507                             struct acl *aclp); }
  508 351     STD     { int __acl_delete_file(const char *path, \
  509                             acl_type_t type); }
  510 352     STD     { int __acl_delete_fd(int filedes, acl_type_t type); }
  511 353     STD     { int __acl_aclcheck_file(const char *path, \
  512                             acl_type_t type, struct acl *aclp); }
  513 354     STD     { int __acl_aclcheck_fd(int filedes, acl_type_t type, \
  514                             struct acl *aclp); }
  515 355     STD     { int extattrctl(const char *path, int cmd, \
  516                             const char *filename, int attrnamespace, \
  517                             const char *attrname); }
  518 356     STD     { int extattr_set_file(const char *path, \
  519                             int attrnamespace, const char *attrname, \
  520                             void *data, size_t nbytes); }
  521 357     STD     { int extattr_get_file(const char *path, \
  522                             int attrnamespace, const char *attrname, \
  523                             void *data, size_t nbytes); }
  524 358     STD     { int extattr_delete_file(const char *path, \
  525                             int attrnamespace, const char *attrname); }
  526 359     STD     { int aio_waitcomplete(struct aiocb **aiocbp, struct timespec *timeout); }
  527 360     STD     { int getresuid(uid_t *ruid, uid_t *euid, uid_t *suid); }
  528 361     STD     { int getresgid(gid_t *rgid, gid_t *egid, gid_t *sgid); }
  529 362     STD     { int kqueue(void); }
  530 363     STD     { int kevent(int fd, \
  531                             const struct kevent *changelist, int nchanges, \
  532                             struct kevent *eventlist, int nevents, \
  533                             const struct timespec *timeout); }
  534 364     STD     { int sctp_peeloff(int sd, caddr_t name ); }
  535 ; 365-392 used by FreeBSD-current
  536 365     UNIMPL  nosys
  537 366     UNIMPL  nosys
  538 367     UNIMPL  nosys
  539 368     UNIMPL  nosys
  540 369     UNIMPL  nosys
  541 370     UNIMPL  nosys
  542 371     UNIMPL  nosys
  543 372     UNIMPL  nosys
  544 373     UNIMPL  nosys
  545 374     UNIMPL  nosys
  546 375     UNIMPL  nosys
  547 376     UNIMPL  nosys
  548 377     UNIMPL  nosys
  549 378     UNIMPL  nosys
  550 379     UNIMPL  nosys
  551 380     UNIMPL  nosys
  552 381     UNIMPL  nosys
  553 382     UNIMPL  nosys
  554 383     UNIMPL  nosys
  555 384     UNIMPL  nosys
  556 385     UNIMPL  nosys
  557 386     UNIMPL  nosys
  558 387     UNIMPL  nosys
  559 388     UNIMPL  nosys
  560 389     UNIMPL  nosys
  561 390     UNIMPL  nosys
  562 391     STD     { int lchflags(char *path, int flags); }
  563 392     STD     { int uuidgen(struct uuid *store, int count); }
  564 393     STD     { int sendfile(int fd, int s, off_t offset, size_t nbytes, \
  565                                 struct sf_hdtr *hdtr, off_t *sbytes, int flags); }
  566 ; 394-439 used by FreeBSD-current
  567 394     UNIMPL  nosys
  568 395     UNIMPL  nosys
  569 396     UNIMPL  nosys
  570 397     UNIMPL  nosys
  571 398     UNIMPL  nosys
  572 399     UNIMPL  nosys
  573 400     UNIMPL  nosys
  574 401     UNIMPL  nosys
  575 402     UNIMPL  nosys
  576 403     UNIMPL  nosys
  577 404     UNIMPL  nosys
  578 405     UNIMPL  nosys
  579 406     UNIMPL  nosys
  580 407     UNIMPL  nosys
  581 408     UNIMPL  nosys
  582 409     UNIMPL  nosys
  583 410     UNIMPL  nosys
  584 411     UNIMPL  nosys
  585 412     UNIMPL  nosys
  586 413     UNIMPL  nosys
  587 414     UNIMPL  nosys
  588 415     UNIMPL  nosys
  589 416     UNIMPL  nosys
  590 417     UNIMPL  nosys
  591 418     UNIMPL  nosys
  592 419     UNIMPL  nosys
  593 420     UNIMPL  nosys
  594 421     UNIMPL  nosys
  595 422     UNIMPL  nosys
  596 423     UNIMPL  nosys
  597 424     UNIMPL  nosys
  598 425     UNIMPL  nosys
  599 426     UNIMPL  nosys
  600 427     UNIMPL  nosys
  601 428     UNIMPL  nosys
  602 429     UNIMPL  nosys
  603 430     UNIMPL  nosys
  604 431     UNIMPL  nosys
  605 432     UNIMPL  nosys
  606 433     UNIMPL  nosys
  607 434     UNIMPL  nosys
  608 435     UNIMPL  nosys
  609 436     UNIMPL  nosys
  610 437     UNIMPL  nosys
  611 438     UNIMPL  nosys
  612 439     UNIMPL  nosys
  613 ; 440-449 reserved for FreeBSD-5.x growth
  614 440     UNIMPL  nosys
  615 441     UNIMPL  nosys
  616 442     UNIMPL  nosys
  617 443     UNIMPL  nosys
  618 444     UNIMPL  nosys
  619 445     UNIMPL  nosys
  620 446     UNIMPL  nosys
  621 447     UNIMPL  nosys
  622 448     UNIMPL  nosys
  623 449     UNIMPL  nosys
  624 ; 450 DragonFly system calls
  625 450     STD     { int varsym_set(int level, const char *name, const char *data); }
  626 451     STD     { int varsym_get(int mask, const char *wild, char *buf, int bufsize); }
  627 452     STD     { int varsym_list(int level, char *buf, int maxsize, int *marker); }
  628 453     OBSOL   upc_register
  629 454     OBSOL   upc_control
  630 455     OBSOL   caps_sys_service
  631 456     OBSOL   caps_sys_client
  632 457     OBSOL   caps_sys_close
  633 458     OBSOL   caps_sys_put
  634 459     OBSOL   caps_sys_reply
  635 460     OBSOL   caps_sys_get
  636 461     OBSOL   caps_sys_wait
  637 462     OBSOL   caps_sys_abort
  638 463     OBSOL   caps_sys_getgen
  639 464     OBSOL   caps_sys_setgen
  640 465     STD     { int exec_sys_register(void *entry); }
  641 466     STD     { int exec_sys_unregister(int id); }
  642 467     STD     { int sys_checkpoint(int type, int fd, pid_t pid, int retval); }
  643 468     STD     { int mountctl(const char *path, int op, int fd, const void *ctl, int ctllen, void *buf, int buflen); }
  644 469     STD     { int umtx_sleep(volatile const int *ptr, int value, int timeout); }
  645 470     STD     { int umtx_wakeup(volatile const int *ptr, int count); }
  646 471     STD     { int jail_attach(int jid); }
  647 472     STD     { int set_tls_area(int which, struct tls_info *info, size_t infosize); }
  648 473     STD     { int get_tls_area(int which, struct tls_info *info, size_t infosize); }
  649 474     STD     { int closefrom(int fd); }
  650 475     STD     { int stat(const char *path, struct stat *ub); }
  651 476     STD     { int fstat(int fd, struct stat *sb); }
  652 477     STD     { int lstat(const char *path, struct stat *ub); }
  653 478     STD     { int fhstat(const struct fhandle *u_fhp, struct stat *sb); }
  654 479     STD     { int getdirentries(int fd, char *buf, u_int count, \
  655                             long *basep); }
  656 480     STD     { int getdents(int fd, char *buf, size_t count); }
  657 481     STD     { int usched_set(pid_t pid, int cmd, void *data, \
  658                                 int bytes); }
  659 482     STD     { int extaccept(int s, int flags, caddr_t name, int *anamelen); }
  660 483     STD     { int extconnect(int s, int flags, caddr_t name, int namelen); }
  661 484     OBSOL   syslink
  662 485     STD     { int mcontrol(void *addr, size_t len, int behav, off_t value); }
  663 486     STD     { int vmspace_create(void *id, int type, void *data); } 
  664 487     STD     { int vmspace_destroy(void *id); }
  665 488     STD     { int vmspace_ctl(void *id, int cmd,            \
  666                                           struct trapframe *tframe,     \
  667                                           struct vextframe *vframe); }
  668 489     STD     { int vmspace_mmap(void *id, void *addr, size_t len, \
  669                                           int prot, int flags, int fd, \
  670                                           off_t offset); }
  671 490     STD     { int vmspace_munmap(void *id, void *addr,      \
  672                                           size_t len); }
  673 491     STD     { int vmspace_mcontrol(void *id, void *addr,    \
  674                                           size_t len, int behav, off_t value); } 
  675 492     STD     { ssize_t vmspace_pread(void *id, void *buf, \
  676                             size_t nbyte, int flags, off_t offset); }
  677 493     STD     { ssize_t vmspace_pwrite(void *id, const void *buf, \
  678                             size_t nbyte, int flags, off_t offset); }
  679 494     STD     { void extexit(int how, int status, void *addr); }
  680 495     STD     { int lwp_create(struct lwp_params *params); }
  681 496     STD     { lwpid_t lwp_gettid(void); }
  682 497     STD     { int lwp_kill(pid_t pid, lwpid_t tid, int signum); }
  683 498     STD     { int lwp_rtprio(int function, pid_t pid, lwpid_t tid, struct rtprio *rtp); }
  684 499     STD     { int pselect(int nd, fd_set *in, fd_set *ou, \
  685                             fd_set *ex, const struct timespec *ts,    \
  686                             const sigset_t *sigmask); }
  687 500     STD     { int statvfs(const char *path, struct statvfs *buf); }
  688 501     STD     { int fstatvfs(int fd, struct statvfs *buf); }
  689 502     STD     { int fhstatvfs(const struct fhandle *u_fhp, struct statvfs *buf); }
  690 503     STD     { int getvfsstat(struct statfs *buf,          \
  691                             struct statvfs *vbuf, long vbufsize, int flags); }
  692 504     STD     { int openat(int fd, char *path, int flags, int mode); }
  693 ; XXX should be         { int openat(int fd, const char *path, int flags, ...);}
  694 ; but we're not ready for `const' or varargs.
  695 ; XXX man page says `mode_t mode'.
  696 505     STD     { int fstatat(int fd, char *path,       \
  697                                         struct stat *sb, int flags); }
  698 506     STD     { int fchmodat(int fd, char *path, int mode, \
  699                                         int flags); }
  700 507     STD     { int fchownat(int fd, char *path, int uid, int gid, \
  701                                         int flags); }
  702 508     STD     { int unlinkat(int fd, char *path, int flags); }
  703 509     STD     { int faccessat(int fd, char *path, int amode, \
  704                                         int flags); }
  705 
  706 ; POSIX message queues system calls
  707 510     STD     { mqd_t mq_open(const char * name, int oflag, \
  708                                   mode_t mode, struct mq_attr *attr); }
  709 511     STD     { int mq_close(mqd_t mqdes); }
  710 512     STD     { int mq_unlink(const char *name); }
  711 513     STD     { int mq_getattr(mqd_t mqdes, \
  712                                   struct mq_attr *mqstat); }
  713 514     STD     { int mq_setattr(mqd_t mqdes, \
  714                                   const struct mq_attr *mqstat, \
  715                                   struct mq_attr *omqstat); }
  716 515     STD     { int mq_notify(mqd_t mqdes, \
  717                                   const struct sigevent *notification); }
  718 516     STD     { int mq_send(mqd_t mqdes, const char *msg_ptr, \
  719                                   size_t msg_len, unsigned msg_prio); }
  720 517     STD     { ssize_t mq_receive(mqd_t mqdes, char *msg_ptr, \
  721                                   size_t msg_len, unsigned *msg_prio); }
  722 518     STD     { int mq_timedsend(mqd_t mqdes, \
  723                                   const char *msg_ptr, size_t msg_len, \
  724                                   unsigned msg_prio, \
  725                                   const struct timespec *abs_timeout); }
  726 519     STD     { ssize_t mq_timedreceive(mqd_t mqdes, \
  727                                   char *msg_ptr, size_t msg_len, unsigned *msg_prio, \
  728                                   const struct timespec *abs_timeout); }
  729 520     STD     { int ioprio_set(int which, int who, int prio); }
  730 521     STD     { int ioprio_get(int which, int who); }
  731 522     STD     { int chroot_kernel(char *path); }
  732 523     STD     { int renameat(int oldfd, char *old, int newfd, \
  733                                   char *new); }
  734 524     STD     { int mkdirat(int fd, char *path, mode_t mode); }
  735 525     STD     { int mkfifoat(int fd, char *path, mode_t mode); }
  736 526     STD     { int mknodat(int fd, char *path, mode_t mode, \
  737                                   dev_t dev); }
  738 527     STD     { int readlinkat(int fd, char *path, char *buf, \
  739                                   size_t bufsize); }
  740 528     STD     { int symlinkat(char *path1, int fd, char *path2); }
  741 529     STD     { int swapoff(char *name); }
  742 530     STD     { int vquotactl(const char *path, \
  743                             struct plistref *pref); }
  744 531     STD     { int linkat(int fd1, char *path1, int fd2, \
  745                                 char *path2, int flags); }
  746 532     STD     { int eaccess(char *path, int flags); }
  747 533     STD     { int lpathconf(char *path, int name); }
  748 534     STD     { int vmm_guest_ctl(int op, struct vmm_guest_options *options); }
  749 535     STD     { int vmm_guest_sync_addr(long *dstaddr, long *srcaddr); }

Cache object: dcf01c5ef66a471c2a760e3beb311baa


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