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

Cache object: 74c34bf81238e5b6ee9358bb4b968bac


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