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         $NetBSD: syscalls.master,v 1.160 2006/10/17 15:06:18 christos Exp $
    2 
    3 ;       @(#)syscalls.master     8.2 (Berkeley) 1/13/94
    4 
    5 ; NetBSD system call name/number "master" file.
    6 ; (See syscalls.conf to see what it is processed into.)
    7 ;
    8 ; Fields: number type [type-dependent ...]
    9 ;       number  system call number, must be in order
   10 ;       type    one of STD, OBSOL, UNIMPL, NODEF, NOARGS, or one of
   11 ;               the compatibility options defined in syscalls.conf.
   12 ;
   13 ; An optional field, MPSAFE, after the type field, indicates that
   14 ; the system call is MP-safe.
   15 ;
   16 ; types:
   17 ;       STD     always included
   18 ;       OBSOL   obsolete, not included in system
   19 ;       UNIMPL  unimplemented, not included in system
   20 ;       EXCL    implemented, but not included in system
   21 ;       NODEF   included, but don't define the syscall number
   22 ;       NOARGS  included, but don't define the syscall args structure
   23 ;       INDIR   included, but don't define the syscall args structure,
   24 ;               and allow it to be "really" varargs.
   25 ;
   26 ; The compat options are defined in the syscalls.conf file, and the
   27 ; compat option name is prefixed to the syscall name.  Other than
   28 ; that, they're like NODEF (for 'compat' options), or STD (for
   29 ; 'libcompat' options).
   30 ;
   31 ; The type-dependent arguments are as follows:
   32 ; For STD, NODEF, NOARGS, and compat syscalls:
   33 ;       { pseudo-proto } [alias]
   34 ; For other syscalls:
   35 ;       [comment]
   36 ;
   37 ; #ifdef's, etc. may be included, and are copied to the output files.
   38 ; #include's are copied to the syscall names and switch definition files only.
   39 
   40 #include "opt_ktrace.h"
   41 #include "opt_nfsserver.h"
   42 #include "opt_ntp.h"
   43 #include "opt_compat_netbsd.h"
   44 #include "opt_sysv.h"
   45 #include "opt_compat_43.h"
   46 #include "opt_posix.h"
   47 
   48 #include "fs_lfs.h"
   49 #include "fs_nfs.h"
   50 
   51 #include <sys/param.h>
   52 #include <sys/systm.h>
   53 #include <sys/signal.h>
   54 #include <sys/mount.h>
   55 #include <sys/sa.h>
   56 #include <sys/syscallargs.h>
   57 
   58 %%
   59 
   60 ; Reserved/unimplemented system calls in the range 0-150 inclusive
   61 ; are reserved for use in future Berkeley releases.
   62 ; Additional system calls implemented in vendor and other
   63 ; redistributions should be placed in the reserved range at the end
   64 ; of the current calls.
   65 
   66 0       INDIR           { int sys_syscall(int number, ...); }
   67 1       STD             { void sys_exit(int rval); }
   68 2       STD             { int sys_fork(void); }
   69 3       STD             { ssize_t sys_read(int fd, void *buf, size_t nbyte); }
   70 4       STD             { ssize_t sys_write(int fd, const void *buf, \
   71                             size_t nbyte); }
   72 5       STD             { int sys_open(const char *path, \
   73                             int flags, ... mode_t mode); }
   74 6       STD             { int sys_close(int fd); }
   75 7       STD             { int sys_wait4(int pid, int *status, int options, \
   76                             struct rusage *rusage); }
   77 8       COMPAT_43       { int sys_creat(const char *path, mode_t mode); } ocreat
   78 9       STD             { int sys_link(const char *path, const char *link); }
   79 10      STD             { int sys_unlink(const char *path); }
   80 11      OBSOL           execv
   81 12      STD             { int sys_chdir(const char *path); }
   82 13      STD             { int sys_fchdir(int fd); }
   83 14      STD             { int sys_mknod(const char *path, mode_t mode, \
   84                             dev_t dev); }
   85 15      STD             { int sys_chmod(const char *path, mode_t mode); }
   86 16      STD             { int sys_chown(const char *path, uid_t uid, \
   87                             gid_t gid); }
   88 17      STD             { int sys_obreak(char *nsize); } break
   89 18      COMPAT_20       { int sys_getfsstat(struct statfs12 *buf, \
   90                             long bufsize, int flags); }
   91 19      COMPAT_43       { long sys_lseek(int fd, long offset, int whence); } \
   92                             olseek
   93 #ifdef COMPAT_43
   94 20      STD             { pid_t sys_getpid_with_ppid(void); } getpid
   95 #else
   96 20      STD MPSAFE      { pid_t sys_getpid(void); }
   97 #endif
   98 21      STD             { int sys_mount(const char *type, const char *path, \
   99                             int flags, void *data); }
  100 22      STD             { int sys_unmount(const char *path, int flags); }
  101 23      STD             { int sys_setuid(uid_t uid); }
  102 #ifdef COMPAT_43
  103 24      STD             { uid_t sys_getuid_with_euid(void); } getuid
  104 #else
  105 24      STD             { uid_t sys_getuid(void); }
  106 #endif
  107 25      STD             { uid_t sys_geteuid(void); }
  108 26      STD             { int sys_ptrace(int req, pid_t pid, caddr_t addr, \
  109                             int data); }
  110 27      STD             { ssize_t sys_recvmsg(int s, struct msghdr *msg, \
  111                             int flags); }
  112 28      STD             { ssize_t sys_sendmsg(int s, \
  113                             const struct msghdr *msg, int flags); }
  114 29      STD             { ssize_t sys_recvfrom(int s, void *buf, size_t len, \
  115                             int flags, struct sockaddr *from, \
  116                             unsigned int *fromlenaddr); }
  117 30      STD             { int sys_accept(int s, struct sockaddr *name, \
  118                             unsigned int *anamelen); }
  119 31      STD             { int sys_getpeername(int fdes, struct sockaddr *asa, \
  120                             unsigned int *alen); }
  121 32      STD             { int sys_getsockname(int fdes, struct sockaddr *asa, \
  122                             unsigned int *alen); }
  123 33      STD             { int sys_access(const char *path, int flags); }
  124 34      STD             { int sys_chflags(const char *path, u_long flags); }
  125 35      STD             { int sys_fchflags(int fd, u_long flags); }
  126 36      STD             { void sys_sync(void); }
  127 37      STD             { int sys_kill(int pid, int signum); }
  128 38      COMPAT_43       { int sys_stat(const char *path, struct stat43 *ub); } \
  129                             stat43
  130 39      STD             { pid_t sys_getppid(void); }
  131 40      COMPAT_43       { int sys_lstat(const char *path, \
  132                             struct stat43 *ub); } lstat43
  133 41      STD             { int sys_dup(int fd); }
  134 42      STD             { int sys_pipe(void); }
  135 43      STD             { gid_t sys_getegid(void); }
  136 44      STD             { int sys_profil(caddr_t samples, size_t size, \
  137                             u_long offset, u_int scale); }
  138 #if defined(KTRACE) || !defined(_KERNEL)
  139 45      STD             { int sys_ktrace(const char *fname, int ops, \
  140                             int facs, int pid); }
  141 #else
  142 45      EXCL            ktrace
  143 #endif
  144 46      COMPAT_13       { int sys_sigaction(int signum, \
  145                             const struct sigaction13 *nsa, \
  146                             struct sigaction13 *osa); } sigaction13
  147 #ifdef COMPAT_43
  148 47      STD             { gid_t sys_getgid_with_egid(void); } getgid
  149 #else
  150 47      STD             { gid_t sys_getgid(void); }
  151 #endif
  152 48      COMPAT_13       { int sys_sigprocmask(int how, \
  153                             int mask); } sigprocmask13
  154 49      STD             { int sys___getlogin(char *namebuf, size_t namelen); }
  155 50      STD             { int sys___setlogin(const char *namebuf); }
  156 51      STD             { int sys_acct(const char *path); }
  157 52      COMPAT_13       { int sys_sigpending(void); } sigpending13
  158 53      COMPAT_13       { int sys_sigaltstack( \
  159                             const struct sigaltstack13 *nss, \
  160                             struct sigaltstack13 *oss); } sigaltstack13
  161 54      STD             { int sys_ioctl(int fd, \
  162                             u_long com, ... void *data); }
  163 55      COMPAT_12       { int sys_reboot(int opt); } oreboot
  164 56      STD             { int sys_revoke(const char *path); }
  165 57      STD             { int sys_symlink(const char *path, \
  166                             const char *link); }
  167 58      STD             { ssize_t sys_readlink(const char *path, char *buf, \
  168                             size_t count); }
  169 59      STD             { int sys_execve(const char *path, \
  170                             char * const *argp, char * const *envp); }
  171 60      STD             { mode_t sys_umask(mode_t newmask); }
  172 61      STD             { int sys_chroot(const char *path); }
  173 62      COMPAT_43       { int sys_fstat(int fd, struct stat43 *sb); } fstat43
  174 63      COMPAT_43       { int sys_getkerninfo(int op, char *where, int *size, \
  175                             int arg); } ogetkerninfo
  176 64      COMPAT_43       { int sys_getpagesize(void); } ogetpagesize
  177 65      COMPAT_12       { int sys_msync(caddr_t addr, size_t len); }
  178 ; XXX COMPAT_??? for 4.4BSD-compatible vfork(2)?
  179 66      STD             { int sys_vfork(void); }
  180 67      OBSOL           vread
  181 68      OBSOL           vwrite
  182 69      STD             { int sys_sbrk(intptr_t incr); }
  183 70      STD             { int sys_sstk(int incr); }
  184 71      COMPAT_43       { int sys_mmap(caddr_t addr, size_t len, int prot, \
  185                             int flags, int fd, long pos); } ommap
  186 72      STD             { int sys_ovadvise(int anom); } vadvise
  187 73      STD             { int sys_munmap(void *addr, size_t len); }
  188 74      STD             { int sys_mprotect(void *addr, size_t len, \
  189                             int prot); }
  190 75      STD             { int sys_madvise(void *addr, size_t len, \
  191                             int behav); }
  192 76      OBSOL           vhangup
  193 77      OBSOL           vlimit
  194 78      STD             { int sys_mincore(void *addr, size_t len, \
  195                             char *vec); }
  196 79      STD             { int sys_getgroups(int gidsetsize, \
  197                             gid_t *gidset); }
  198 80      STD             { int sys_setgroups(int gidsetsize, \
  199                             const gid_t *gidset); }
  200 81      STD             { int sys_getpgrp(void); }
  201 82      STD             { int sys_setpgid(int pid, int pgid); }
  202 83      STD             { int sys_setitimer(int which, \
  203                             const struct itimerval *itv, \
  204                             struct itimerval *oitv); }
  205 84      COMPAT_43       { int sys_wait(void); } owait
  206 85      COMPAT_12       { int sys_swapon(const char *name); } oswapon
  207 86      STD             { int sys_getitimer(int which, \
  208                             struct itimerval *itv); }
  209 87      COMPAT_43       { int sys_gethostname(char *hostname, u_int len); } \
  210                             ogethostname
  211 88      COMPAT_43       { int sys_sethostname(char *hostname, u_int len); } \
  212                             osethostname
  213 89      COMPAT_43       { int sys_getdtablesize(void); } ogetdtablesize
  214 90      STD             { int sys_dup2(int from, int to); }
  215 91      UNIMPL          getdopt
  216 92      STD             { int sys_fcntl(int fd, int cmd, ... void *arg); }
  217 93      STD             { int sys_select(int nd, fd_set *in, fd_set *ou, \
  218                             fd_set *ex, struct timeval *tv); }
  219 94      UNIMPL          setdopt
  220 95      STD             { int sys_fsync(int fd); }
  221 96      STD             { int sys_setpriority(int which, id_t who, int prio); }
  222 97      COMPAT_30       { int sys_socket(int domain, int type, int protocol); }
  223 98      STD             { int sys_connect(int s, const struct sockaddr *name, \
  224                             unsigned int namelen); }
  225 99      COMPAT_43       { int sys_accept(int s, caddr_t name, \
  226                             int *anamelen); } oaccept
  227 100     STD             { int sys_getpriority(int which, id_t who); }
  228 101     COMPAT_43       { int sys_send(int s, caddr_t buf, int len, \
  229                             int flags); } osend
  230 102     COMPAT_43       { int sys_recv(int s, caddr_t buf, int len, \
  231                             int flags); } orecv
  232 103     COMPAT_13       { int sys_sigreturn(struct sigcontext13 *sigcntxp); } \
  233                             sigreturn13
  234 104     STD             { int sys_bind(int s, const struct sockaddr *name, \
  235                             unsigned int namelen); }
  236 105     STD             { int sys_setsockopt(int s, int level, int name, \
  237                             const void *val, unsigned int valsize); }
  238 106     STD             { int sys_listen(int s, int backlog); }
  239 107     OBSOL           vtimes
  240 108     COMPAT_43       { int sys_sigvec(int signum, struct sigvec *nsv, \
  241                             struct sigvec *osv); } osigvec
  242 109     COMPAT_43       { int sys_sigblock(int mask); } osigblock
  243 110     COMPAT_43       { int sys_sigsetmask(int mask); } osigsetmask
  244 111     COMPAT_13       { int sys_sigsuspend(int mask); } sigsuspend13
  245 112     COMPAT_43       { int sys_sigstack(struct sigstack *nss, \
  246                             struct sigstack *oss); } osigstack
  247 113     COMPAT_43       { int sys_recvmsg(int s, struct omsghdr *msg, \
  248                             int flags); } orecvmsg
  249 114     COMPAT_43       { int sys_sendmsg(int s, caddr_t msg, int flags); } \
  250                             osendmsg
  251 115     OBSOL           vtrace
  252 116     STD             { int sys_gettimeofday(struct timeval *tp, \
  253                             void *tzp); }
  254 117     STD             { int sys_getrusage(int who, struct rusage *rusage); }
  255 118     STD             { int sys_getsockopt(int s, int level, int name, \
  256                             void *val, unsigned int *avalsize); }
  257 119     OBSOL           resuba
  258 120     STD             { ssize_t sys_readv(int fd, \
  259                             const struct iovec *iovp, int iovcnt); }
  260 121     STD             { ssize_t sys_writev(int fd, \
  261                             const struct iovec *iovp, int iovcnt); }
  262 122     STD             { int sys_settimeofday(const struct timeval *tv, \
  263                             const void *tzp); }
  264 123     STD             { int sys_fchown(int fd, uid_t uid, gid_t gid); }
  265 124     STD             { int sys_fchmod(int fd, mode_t mode); }
  266 125     COMPAT_43       { int sys_recvfrom(int s, caddr_t buf, size_t len, \
  267                             int flags, caddr_t from, int *fromlenaddr); } \
  268                             orecvfrom
  269 126     STD             { int sys_setreuid(uid_t ruid, uid_t euid); }
  270 127     STD             { int sys_setregid(gid_t rgid, gid_t egid); }
  271 128     STD             { int sys_rename(const char *from, const char *to); }
  272 129     COMPAT_43       { int sys_truncate(const char *path, long length); } \
  273                             otruncate
  274 130     COMPAT_43       { int sys_ftruncate(int fd, long length); } oftruncate
  275 131     STD             { int sys_flock(int fd, int how); }
  276 132     STD             { int sys_mkfifo(const char *path, mode_t mode); }
  277 133     STD             { ssize_t sys_sendto(int s, const void *buf, \
  278                             size_t len, int flags, const struct sockaddr *to, \
  279                             unsigned int tolen); }
  280 134     STD             { int sys_shutdown(int s, int how); }
  281 135     STD             { int sys_socketpair(int domain, int type, \
  282                             int protocol, int *rsv); }
  283 136     STD             { int sys_mkdir(const char *path, mode_t mode); }
  284 137     STD             { int sys_rmdir(const char *path); }
  285 138     STD             { int sys_utimes(const char *path, \
  286                             const struct timeval *tptr); }
  287 139     OBSOL           4.2 sigreturn
  288 140     STD             { int sys_adjtime(const struct timeval *delta, \
  289                             struct timeval *olddelta); }
  290 141     COMPAT_43       { int sys_getpeername(int fdes, caddr_t asa, \
  291                             int *alen); } ogetpeername
  292 142     COMPAT_43       { int32_t sys_gethostid(void); } ogethostid
  293 143     COMPAT_43       { int sys_sethostid(int32_t hostid); } osethostid
  294 144     COMPAT_43       { int sys_getrlimit(int which, \
  295                             struct orlimit *rlp); } ogetrlimit
  296 145     COMPAT_43       { int sys_setrlimit(int which, \
  297                             const struct orlimit *rlp); } osetrlimit
  298 146     COMPAT_43       { int sys_killpg(int pgid, int signum); } okillpg
  299 147     STD             { int sys_setsid(void); }
  300 148     STD             { int sys_quotactl(const char *path, int cmd, \
  301                             int uid, void *arg); }
  302 149     COMPAT_43       { int sys_quota(void); } oquota
  303 150     COMPAT_43       { int sys_getsockname(int fdec, caddr_t asa, \
  304                             int *alen); } ogetsockname
  305 
  306 ; Syscalls 151-180 inclusive are reserved for vendor-specific
  307 ; system calls.  (This includes various calls added for compatibity
  308 ; with other Unix variants.)
  309 ; Some of these calls are now supported by BSD...
  310 151     UNIMPL
  311 152     UNIMPL
  312 153     UNIMPL
  313 154     UNIMPL
  314 #if defined(NFS) || defined(NFSSERVER) || !defined(_KERNEL)
  315 155     STD             { int sys_nfssvc(int flag, void *argp); }
  316 #else
  317 155     EXCL            nfssvc
  318 #endif
  319 156     COMPAT_43       { int sys_getdirentries(int fd, char *buf, \
  320                             u_int count, long *basep); } ogetdirentries
  321 157     COMPAT_20       { int sys_statfs(const char *path, \
  322                             struct statfs12 *buf); }
  323 158     COMPAT_20       { int sys_fstatfs(int fd, struct statfs12 *buf); }
  324 159     UNIMPL
  325 160     UNIMPL
  326 161     COMPAT_30       { int sys_getfh(const char *fname, \
  327                             struct compat_30_fhandle *fhp); }
  328 162     COMPAT_09       { int sys_getdomainname(char *domainname, int len); } \
  329                             ogetdomainname
  330 163     COMPAT_09       { int sys_setdomainname(char *domainname, int len); } \
  331                             osetdomainname
  332 164     COMPAT_09       { int sys_uname(struct outsname *name); } ouname
  333 165     STD             { int sys_sysarch(int op, void *parms); }
  334 166     UNIMPL
  335 167     UNIMPL
  336 168     UNIMPL
  337 ; XXX more generally, never on machines where sizeof(void *) != sizeof(int)
  338 #if (defined(SYSVSEM) || !defined(_KERNEL)) && !defined(_LP64)
  339 169     COMPAT_10       { int sys_semsys(int which, int a2, int a3, int a4, \
  340                             int a5); } osemsys
  341 #else
  342 169     EXCL            1.0 semsys
  343 #endif
  344 ; XXX more generally, never on machines where sizeof(void *) != sizeof(int)
  345 #if (defined(SYSVMSG) || !defined(_KERNEL)) && !defined(_LP64)
  346 170     COMPAT_10       { int sys_msgsys(int which, int a2, int a3, int a4, \
  347                             int a5, int a6); } omsgsys
  348 #else
  349 170     EXCL            1.0 msgsys
  350 #endif
  351 ; XXX more generally, never on machines where sizeof(void *) != sizeof(int)
  352 #if (defined(SYSVSHM) || !defined(_KERNEL)) && !defined(_LP64)
  353 171     COMPAT_10       { int sys_shmsys(int which, int a2, int a3, int a4); } \
  354                             oshmsys
  355 #else
  356 171     EXCL            1.0 shmsys
  357 #endif
  358 172     UNIMPL
  359 173     STD             { ssize_t sys_pread(int fd, void *buf, \
  360                             size_t nbyte, int pad, off_t offset); }
  361 174     STD             { ssize_t sys_pwrite(int fd, const void *buf, \
  362                             size_t nbyte, int pad, off_t offset); }
  363 ; For some reason, ntp_gettime doesn't want to raise SIGSYS when it's excluded.
  364 175     COMPAT_30       { int sys_ntp_gettime(struct ntptimeval30 *ntvp); }
  365 #if defined(NTP) || !defined(_KERNEL)
  366 176     STD             { int sys_ntp_adjtime(struct timex *tp); }
  367 #else
  368 176     EXCL            ntp_adjtime
  369 #endif
  370 177     UNIMPL
  371 178     UNIMPL
  372 179     UNIMPL
  373 180     UNIMPL
  374 
  375 ; Syscalls 180-199 are used by/reserved for BSD
  376 181     STD             { int sys_setgid(gid_t gid); }
  377 182     STD             { int sys_setegid(gid_t egid); }
  378 183     STD             { int sys_seteuid(uid_t euid); }
  379 #if defined(LFS) || !defined(_KERNEL)
  380 184     STD             { int sys_lfs_bmapv(fsid_t *fsidp, \
  381                             struct block_info *blkiov, int blkcnt); }
  382 185     STD             { int sys_lfs_markv(fsid_t *fsidp, \
  383                             struct block_info *blkiov, int blkcnt); }
  384 186     STD             { int sys_lfs_segclean(fsid_t *fsidp, u_long segment); }
  385 187     STD             { int sys_lfs_segwait(fsid_t *fsidp, \
  386                             struct timeval *tv); }
  387 #else
  388 184     EXCL            lfs_bmapv
  389 185     EXCL            lfs_markv
  390 186     EXCL            lfs_segclean
  391 187     EXCL            lfs_segwait
  392 #endif
  393 188     COMPAT_12       { int sys_stat(const char *path, struct stat12 *ub); } \
  394                             stat12
  395 189     COMPAT_12       { int sys_fstat(int fd, struct stat12 *sb); } fstat12
  396 190     COMPAT_12       { int sys_lstat(const char *path, \
  397                             struct stat12 *ub); } lstat12
  398 191     STD             { long sys_pathconf(const char *path, int name); }
  399 192     STD             { long sys_fpathconf(int fd, int name); }
  400 193     UNIMPL
  401 194     STD             { int sys_getrlimit(int which, \
  402                             struct rlimit *rlp); }
  403 195     STD             { int sys_setrlimit(int which, \
  404                             const struct rlimit *rlp); }
  405 196     COMPAT_12       { int sys_getdirentries(int fd, char *buf, \
  406                             u_int count, long *basep); }
  407 197     STD             { void *sys_mmap(void *addr, size_t len, int prot, \
  408                             int flags, int fd, long pad, off_t pos); }
  409 198     INDIR           { quad_t sys___syscall(quad_t num, ...); }
  410 199     STD             { off_t sys_lseek(int fd, int pad, off_t offset, \
  411                             int whence); }
  412 200     STD             { int sys_truncate(const char *path, int pad, \
  413                             off_t length); }
  414 201     STD             { int sys_ftruncate(int fd, int pad, off_t length); }
  415 202     STD             { int sys___sysctl(const int *name, u_int namelen, \
  416                             void *old, size_t *oldlenp, const void *new, \
  417                             size_t newlen); }
  418 203     STD             { int sys_mlock(const void *addr, size_t len); }
  419 204     STD             { int sys_munlock(const void *addr, size_t len); }
  420 205     STD             { int sys_undelete(const char *path); }
  421 206     STD             { int sys_futimes(int fd, \
  422                             const struct timeval *tptr); }
  423 207     STD             { pid_t sys_getpgid(pid_t pid); }
  424 208     STD             { int sys_reboot(int opt, char *bootstr); }
  425 209     STD             { int sys_poll(struct pollfd *fds, u_int nfds, \
  426                             int timeout); }
  427 ;
  428 ; Syscalls 210-219 are reserved for dynamically loaded syscalls
  429 ;
  430 #if defined(LKM) || !defined(_KERNEL)
  431 210     NODEF           { int sys_lkmnosys(void); }
  432 211     NODEF           { int sys_lkmnosys(void); }
  433 212     NODEF           { int sys_lkmnosys(void); }
  434 213     NODEF           { int sys_lkmnosys(void); }
  435 214     NODEF           { int sys_lkmnosys(void); }
  436 215     NODEF           { int sys_lkmnosys(void); }
  437 216     NODEF           { int sys_lkmnosys(void); }
  438 217     NODEF           { int sys_lkmnosys(void); }
  439 218     NODEF           { int sys_lkmnosys(void); }
  440 219     NODEF           { int sys_lkmnosys(void); }
  441 #else   /* !LKM */
  442 210     EXCL            lkmnosys
  443 211     EXCL            lkmnosys
  444 212     EXCL            lkmnosys
  445 213     EXCL            lkmnosys
  446 214     EXCL            lkmnosys
  447 215     EXCL            lkmnosys
  448 216     EXCL            lkmnosys
  449 217     EXCL            lkmnosys
  450 218     EXCL            lkmnosys
  451 219     EXCL            lkmnosys
  452 #endif  /* !LKM */
  453 ; System calls 220-300 are reserved for use by NetBSD
  454 #if defined(SYSVSEM) || !defined(_KERNEL)
  455 220     COMPAT_14       { int sys___semctl(int semid, int semnum, int cmd, \
  456                             union __semun *arg); }
  457 221     STD             { int sys_semget(key_t key, int nsems, int semflg); }
  458 222     STD             { int sys_semop(int semid, struct sembuf *sops, \
  459                             size_t nsops); }
  460 223     STD             { int sys_semconfig(int flag); }
  461 #else
  462 220     EXCL            compat_14_semctl
  463 221     EXCL            semget
  464 222     EXCL            semop
  465 223     EXCL            semconfig
  466 #endif
  467 #if defined(SYSVMSG) || !defined(_KERNEL)
  468 224     COMPAT_14       { int sys_msgctl(int msqid, int cmd, \
  469                             struct msqid_ds14 *buf); }
  470 225     STD             { int sys_msgget(key_t key, int msgflg); }
  471 226     STD             { int sys_msgsnd(int msqid, const void *msgp, \
  472                             size_t msgsz, int msgflg); }
  473 227     STD             { ssize_t sys_msgrcv(int msqid, void *msgp, \
  474                             size_t msgsz, long msgtyp, int msgflg); }
  475 #else
  476 224     EXCL            compat_14_msgctl
  477 225     EXCL            msgget
  478 226     EXCL            msgsnd
  479 227     EXCL            msgrcv
  480 #endif
  481 #if defined(SYSVSHM) || !defined(_KERNEL)
  482 228     STD             { void *sys_shmat(int shmid, const void *shmaddr, \
  483                             int shmflg); }
  484 229     COMPAT_14       { int sys_shmctl(int shmid, int cmd, \
  485                             struct shmid_ds14 *buf); }
  486 230     STD             { int sys_shmdt(const void *shmaddr); }
  487 231     STD             { int sys_shmget(key_t key, size_t size, int shmflg); }
  488 #else
  489 228     EXCL            shmat
  490 229     EXCL            compat_14_shmctl
  491 230     EXCL            shmdt
  492 231     EXCL            shmget
  493 #endif
  494 232     STD             { int sys_clock_gettime(clockid_t clock_id, \
  495                             struct timespec *tp); }
  496 233     STD             { int sys_clock_settime(clockid_t clock_id, \
  497                             const struct timespec *tp); }
  498 234     STD             { int sys_clock_getres(clockid_t clock_id, \
  499                             struct timespec *tp); }
  500 235     STD             { int sys_timer_create(clockid_t clock_id, \
  501                             struct sigevent *evp, timer_t *timerid); }
  502 236     STD             { int sys_timer_delete(timer_t timerid); }
  503 237     STD             { int sys_timer_settime(timer_t timerid, int flags, \
  504                             const struct itimerspec *value, \
  505                             struct itimerspec *ovalue); }
  506 238     STD             { int sys_timer_gettime(timer_t timerid, struct \
  507                             itimerspec *value); }
  508 239     STD             { int sys_timer_getoverrun(timer_t timerid); }
  509 ;
  510 ; Syscalls 240-269 are reserved for other IEEE Std1003.1b syscalls
  511 ;
  512 240     STD             { int sys_nanosleep(const struct timespec *rqtp, \
  513                             struct timespec *rmtp); }
  514 241     STD             { int sys_fdatasync(int fd); }
  515 242     STD             { int sys_mlockall(int flags); }
  516 243     STD             { int sys_munlockall(void); }
  517 244     STD             { int sys___sigtimedwait(const sigset_t *set, \
  518                             siginfo_t *info, \
  519                             struct timespec *timeout); }
  520 245     UNIMPL          sys_sigqueue
  521 ;
  522 ; Syscall 246 is free for any use
  523 ;
  524 246     UNIMPL
  525 #if defined(P1003_1B_SEMAPHORE) || (!defined(_KERNEL) && defined(_LIBC))
  526 247     STD             { int sys__ksem_init(unsigned int value, semid_t *idp); }
  527 248     STD             { int sys__ksem_open(const char *name, int oflag, \
  528                             mode_t mode, unsigned int value, semid_t *idp); }
  529 249     STD             { int sys__ksem_unlink(const char *name); }
  530 250     STD             { int sys__ksem_close(semid_t id); }
  531 251     STD             { int sys__ksem_post(semid_t id); }
  532 252     STD             { int sys__ksem_wait(semid_t id); }
  533 253     STD             { int sys__ksem_trywait(semid_t id); }
  534 254     STD             { int sys__ksem_getvalue(semid_t id, \
  535                             unsigned int *value); }
  536 255     STD             { int sys__ksem_destroy(semid_t id); }
  537 256     UNIMPL          sys__ksem_timedwait
  538 #else
  539 247     EXCL            sys__ksem_init
  540 248     EXCL            sys__ksem_open
  541 249     EXCL            sys__ksem_unlink
  542 250     EXCL            sys__ksem_close
  543 251     EXCL            sys__ksem_post
  544 252     EXCL            sys__ksem_wait
  545 253     EXCL            sys__ksem_trywait
  546 254     EXCL            sys__ksem_getvalue
  547 255     EXCL            sys__ksem_destroy
  548 256     UNIMPL          sys__ksem_timedwait
  549 #endif
  550 257     UNIMPL          sys_mq_open
  551 258     UNIMPL          sys_mq_close
  552 259     UNIMPL          sys_mq_unlink
  553 260     UNIMPL          sys_mq_getattr
  554 261     UNIMPL          sys_mq_setattr
  555 262     UNIMPL          sys_mq_notify
  556 263     UNIMPL          sys_mq_send
  557 264     UNIMPL          sys_mq_receive
  558 265     UNIMPL          sys_mq_timedsend
  559 266     UNIMPL          sys_mq_timedreceive
  560 267     UNIMPL
  561 268     UNIMPL
  562 269     UNIMPL
  563 270     STD             { int sys___posix_rename(const char *from, \
  564                             const char *to); }
  565 271     STD             { int sys_swapctl(int cmd, void *arg, int misc); }
  566 272     COMPAT_30       { int sys_getdents(int fd, char *buf, size_t count); }
  567 273     STD             { int sys_minherit(void *addr, size_t len, \
  568                             int inherit); }
  569 274     STD             { int sys_lchmod(const char *path, mode_t mode); }
  570 275     STD             { int sys_lchown(const char *path, uid_t uid, \
  571                             gid_t gid); }
  572 276     STD             { int sys_lutimes(const char *path, \
  573                             const struct timeval *tptr); }
  574 277     STD             { int sys___msync13(void *addr, size_t len, int flags); }
  575 278     COMPAT_30       { int sys___stat13(const char *path, struct stat13 *ub); }
  576 279     COMPAT_30       { int sys___fstat13(int fd, struct stat13 *sb); }
  577 280     COMPAT_30       { int sys___lstat13(const char *path, struct stat13 *ub); }
  578 281     STD             { int sys___sigaltstack14( \
  579                             const struct sigaltstack *nss, \
  580                             struct sigaltstack *oss); }
  581 282     STD             { int sys___vfork14(void); }
  582 283     STD             { int sys___posix_chown(const char *path, uid_t uid, \
  583                             gid_t gid); }
  584 284     STD             { int sys___posix_fchown(int fd, uid_t uid, \
  585                             gid_t gid); }
  586 285     STD             { int sys___posix_lchown(const char *path, uid_t uid, \
  587                             gid_t gid); }
  588 286     STD             { pid_t sys_getsid(pid_t pid); }
  589 287     STD             { pid_t sys___clone(int flags, void *stack); }
  590 #if defined(KTRACE) || !defined(_KERNEL)
  591 288     STD             { int sys_fktrace(const int fd, int ops, \
  592                             int facs, int pid); }
  593 #else
  594 288     EXCL            ktrace
  595 #endif
  596 289     STD             { ssize_t sys_preadv(int fd, \
  597                             const struct iovec *iovp, int iovcnt, \
  598                             int pad, off_t offset); }
  599 290     STD             { ssize_t sys_pwritev(int fd, \
  600                             const struct iovec *iovp, int iovcnt, \
  601                             int pad, off_t offset); }
  602 291     COMPAT_16       { int sys___sigaction14(int signum, \
  603                             const struct sigaction *nsa, \
  604                             struct sigaction *osa); }
  605 292     STD             { int sys___sigpending14(sigset_t *set); }
  606 293     STD             { int sys___sigprocmask14(int how, \
  607                             const sigset_t *set, \
  608                             sigset_t *oset); }
  609 294     STD             { int sys___sigsuspend14(const sigset_t *set); }
  610 295     COMPAT_16       { int sys___sigreturn14(struct sigcontext *sigcntxp); }
  611 296     STD             { int sys___getcwd(char *bufp, size_t length); }
  612 297     STD             { int sys_fchroot(int fd); }
  613 298     COMPAT_30       { int sys_fhopen(const struct compat_30_fhandle *fhp, int flags); }
  614 299     COMPAT_30       { int sys_fhstat(const struct compat_30_fhandle *fhp, \
  615                             struct stat13 *sb); }
  616 300     COMPAT_20       { int sys_fhstatfs(const struct compat_30_fhandle *fhp, \
  617                             struct statfs12 *buf); }
  618 #if defined(SYSVSEM) || !defined(_KERNEL)
  619 301     STD             { int sys_____semctl13(int semid, int semnum, int cmd, \
  620                             ... union __semun *arg); }
  621 #else
  622 301     EXCL            ____semctl13
  623 #endif
  624 #if defined(SYSVMSG) || !defined(_KERNEL)
  625 302     STD             { int sys___msgctl13(int msqid, int cmd, \
  626                             struct msqid_ds *buf); }
  627 #else
  628 302     EXCL            __msgctl13
  629 #endif
  630 #if defined(SYSVSHM) || !defined(_KERNEL)
  631 303     STD             { int sys___shmctl13(int shmid, int cmd, \
  632                             struct shmid_ds *buf); }
  633 #else
  634 303     EXCL            __shmctl13
  635 #endif
  636 304     STD             { int sys_lchflags(const char *path, u_long flags); }
  637 305     STD             { int sys_issetugid(void); }
  638 306     STD             { int sys_utrace(const char *label, void *addr, \
  639                                 size_t len); }
  640 307     STD             { int sys_getcontext(struct __ucontext *ucp); }
  641 308     STD             { int sys_setcontext(const struct __ucontext *ucp); }
  642 309     STD             { int sys__lwp_create(const struct __ucontext *ucp, \
  643                                 u_long flags, lwpid_t *new_lwp); }
  644 310     STD             { int sys__lwp_exit(void); }
  645 311     STD             { lwpid_t sys__lwp_self(void); }
  646 312     STD             { int sys__lwp_wait(lwpid_t wait_for, \
  647                                 lwpid_t *departed); }
  648 313     STD             { int sys__lwp_suspend(lwpid_t target); }
  649 314     STD             { int sys__lwp_continue(lwpid_t target); }
  650 315     STD             { int sys__lwp_wakeup(lwpid_t target); }
  651 316     STD             { void *sys__lwp_getprivate(void); }
  652 317     STD             { void sys__lwp_setprivate(void *ptr); }
  653 ; Syscalls 318-329 reserved for remaining Solaris-compatible LWP calls.
  654 318     UNIMPL
  655 319     UNIMPL
  656 320     UNIMPL
  657 321     UNIMPL
  658 322     UNIMPL
  659 323     UNIMPL
  660 324     UNIMPL
  661 325     UNIMPL
  662 326     UNIMPL
  663 327     UNIMPL
  664 328     UNIMPL
  665 329     UNIMPL
  666 ; Scheduler activation syscalls
  667 330     STD             { int sys_sa_register(sa_upcall_t new, \
  668                                 sa_upcall_t *old, int flags, \
  669                                 ssize_t stackinfo_offset); }
  670 331     STD             { int sys_sa_stacks(int num, stack_t *stacks); }
  671 332     STD             { int sys_sa_enable(void); }
  672 333     STD             { int sys_sa_setconcurrency(int concurrency); }
  673 334     STD             { int sys_sa_yield(void); }
  674 335     STD             { int sys_sa_preempt(int sa_id); }
  675 336     OBSOL           sys_sa_unblockyield
  676 ;
  677 ; Syscalls 337-339 are reserved for other scheduler activation syscalls.
  678 ;
  679 337     UNIMPL
  680 338     UNIMPL
  681 339     UNIMPL
  682 340     STD             { int sys___sigaction_sigtramp(int signum, \
  683                             const struct sigaction *nsa, \
  684                             struct sigaction *osa, \
  685                             const void *tramp, int vers); }
  686 341     STD             { int sys_pmc_get_info(int ctr, int op, void *args); }
  687 342     STD             { int sys_pmc_control(int ctr, int op, void *args); }
  688 343     STD             { int sys_rasctl(caddr_t addr, size_t len, int op); }
  689 344     STD             { int sys_kqueue(void); }
  690 345     STD             { int sys_kevent(int fd, \
  691                             const struct kevent *changelist, size_t nchanges, \
  692                             struct kevent *eventlist, size_t nevents, \
  693                             const struct timespec *timeout); }
  694 ;
  695 ; Syscalls 346-353 are reserved for the IEEE Std1003.1b scheduling syscalls
  696 ;
  697 346     UNIMPL          sys_sched_setparam
  698 347     UNIMPL          sys_sched_getparam
  699 348     UNIMPL          sys_sched_setscheduler
  700 349     UNIMPL          sys_sched_getscheduler
  701 350     UNIMPL          sys_sched_yield
  702 351     UNIMPL          sys_sched_get_priority_max
  703 352     UNIMPL          sys_sched_get_priority_min
  704 353     UNIMPL          sys_sched_rr_get_interval
  705 
  706 354     STD             { int sys_fsync_range(int fd, int flags, off_t start, \
  707                             off_t length); }
  708 355     STD             { int sys_uuidgen(struct uuid *store, int count); }
  709 356     STD             { int sys_getvfsstat(struct statvfs *buf, \
  710                             size_t bufsize, int flags); }
  711 357     STD             { int sys_statvfs1(const char *path, \
  712                             struct statvfs *buf, int flags); }
  713 358     STD             { int sys_fstatvfs1(int fd, struct statvfs *buf, \
  714                             int flags); }
  715 359     COMPAT_30       { int sys_fhstatvfs1(const struct compat_30_fhandle *fhp, \
  716                             struct statvfs *buf, int flags); }
  717 360     STD             { int sys_extattrctl(const char *path, int cmd, \
  718                             const char *filename, int attrnamespace, \
  719                             const char *attrname); }
  720 361     STD             { int sys_extattr_set_file(const char *path, \
  721                             int attrnamespace, const char *attrname, \
  722                             const void *data, size_t nbytes); }
  723 362     STD             { ssize_t sys_extattr_get_file(const char *path, \
  724                             int attrnamespace, const char *attrname, \
  725                             void *data, size_t nbytes); }
  726 363     STD             { int sys_extattr_delete_file(const char *path, \
  727                             int attrnamespace, const char *attrname); }
  728 364     STD             { int sys_extattr_set_fd(int fd, \
  729                             int attrnamespace, const char *attrname, \
  730                             const void *data, size_t nbytes); }
  731 365     STD             { ssize_t sys_extattr_get_fd(int fd, \
  732                             int attrnamespace, const char *attrname, \
  733                             void *data, size_t nbytes); }
  734 366     STD             { int sys_extattr_delete_fd(int fd, \
  735                             int attrnamespace, const char *attrname); }
  736 367     STD             { int sys_extattr_set_link(const char *path, \
  737                             int attrnamespace, const char *attrname, \
  738                             const void *data, size_t nbytes); }
  739 368     STD             { ssize_t sys_extattr_get_link(const char *path, \
  740                             int attrnamespace, const char *attrname, \
  741                             void *data, size_t nbytes); }
  742 369     STD             { int sys_extattr_delete_link(const char *path, \
  743                             int attrnamespace, const char *attrname); }
  744 370     STD             { ssize_t sys_extattr_list_fd(int fd, \
  745                             int attrnamespace, void *data, size_t nbytes); }
  746 371     STD             { ssize_t sys_extattr_list_file(const char *path, \
  747                             int attrnamespace, void *data, size_t nbytes); }
  748 372     STD             { ssize_t sys_extattr_list_link(const char *path, \
  749                             int attrnamespace, void *data, size_t nbytes); }
  750 373     STD             { int sys_pselect(int nd, fd_set *in, fd_set *ou, \
  751                             fd_set *ex, const struct timespec *ts, \
  752                             const sigset_t *mask); }
  753 374     STD             { int sys_pollts(struct pollfd *fds, u_int nfds, \
  754                             const struct timespec *ts, const sigset_t *mask); }
  755 375     STD             { int sys_setxattr(const char *path, \
  756                             const char *name, void *value, size_t size, \
  757                             int flags); }
  758 376     STD             { int sys_lsetxattr(const char *path, \
  759                             const char *name, void *value, size_t size, \
  760                             int flags); }
  761 377     STD             { int sys_fsetxattr(int fd, \
  762                             const char *name, void *value, size_t size, \
  763                             int flags); }
  764 378     STD             { int sys_getxattr(const char *path, \
  765                             const char *name, void *value, size_t size); }
  766 379     STD             { int sys_lgetxattr(const char *path, \
  767                             const char *name, void *value, size_t size); }
  768 380     STD             { int sys_fgetxattr(int fd, \
  769                             const char *name, void *value, size_t size); }
  770 381     STD             { int sys_listxattr(const char *path, \
  771                             char *list, size_t size); }
  772 382     STD             { int sys_llistxattr(const char *path, \
  773                             char *list, size_t size); }
  774 383     STD             { int sys_flistxattr(int fd, \
  775                             char *list, size_t size); }
  776 384     STD             { int sys_removexattr(const char *path, \
  777                             const char *name); }
  778 385     STD             { int sys_lremovexattr(const char *path, \
  779                             const char *name); }
  780 386     STD             { int sys_fremovexattr(int fd, \
  781                             const char *name); }
  782 387     STD             { int sys___stat30(const char *path, struct stat *ub); }
  783 388     STD             { int sys___fstat30(int fd, struct stat *sb); }
  784 389     STD             { int sys___lstat30(const char *path, struct stat *ub); }
  785 390     STD             { int sys___getdents30(int fd, char *buf, size_t count); }
  786 391     STD             { int sys_posix_fadvise(int fd, off_t offset, \
  787                             off_t len, int advice); }
  788 392     COMPAT_30       { int sys___fhstat30(const struct compat_30_fhandle \
  789                             *fhp, struct stat *sb); }
  790 393     STD             { int sys___ntp_gettime30(struct ntptimeval *ntvp); }
  791 394     STD             { int sys___socket30(int domain, int type, int protocol); }
  792 395     STD             { int sys___getfh30(const char *fname, void *fhp, \
  793                             size_t *fh_size); }
  794 396     STD             { int sys___fhopen40(const void *fhp, size_t fh_size,\
  795                             int flags); }
  796 397     STD             { int sys___fhstatvfs140(const void *fhp, \
  797                             size_t fh_size, struct statvfs *buf, int flags); }
  798 398     STD             { int sys___fhstat40(const void *fhp, \
  799                             size_t fh_size, struct stat *sb); }

Cache object: 7236d9efc146155ef6e1e7bf482c9b1c


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