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.145 2005/02/25 19:53:56 matt 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      STD             { 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, caddr_t 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     STD             { int sys_getfh(const char *fname, fhandle_t *fhp); }
  327 162     COMPAT_09       { int sys_getdomainname(char *domainname, int len); } \
  328                             ogetdomainname
  329 163     COMPAT_09       { int sys_setdomainname(char *domainname, int len); } \
  330                             osetdomainname
  331 164     COMPAT_09       { int sys_uname(struct outsname *name); } ouname
  332 165     STD             { int sys_sysarch(int op, void *parms); }
  333 166     UNIMPL
  334 167     UNIMPL
  335 168     UNIMPL
  336 ; XXX more generally, never on machines where sizeof(void *) != sizeof(int)
  337 #if (defined(SYSVSEM) || !defined(_KERNEL)) && !defined(_LP64)
  338 169     COMPAT_10       { int sys_semsys(int which, int a2, int a3, int a4, \
  339                             int a5); } osemsys
  340 #else
  341 169     EXCL            1.0 semsys
  342 #endif
  343 ; XXX more generally, never on machines where sizeof(void *) != sizeof(int)
  344 #if (defined(SYSVMSG) || !defined(_KERNEL)) && !defined(_LP64)
  345 170     COMPAT_10       { int sys_msgsys(int which, int a2, int a3, int a4, \
  346                             int a5, int a6); } omsgsys
  347 #else
  348 170     EXCL            1.0 msgsys
  349 #endif
  350 ; XXX more generally, never on machines where sizeof(void *) != sizeof(int)
  351 #if (defined(SYSVSHM) || !defined(_KERNEL)) && !defined(_LP64)
  352 171     COMPAT_10       { int sys_shmsys(int which, int a2, int a3, int a4); } \
  353                             oshmsys
  354 #else
  355 171     EXCL            1.0 shmsys
  356 #endif
  357 172     UNIMPL
  358 173     STD             { ssize_t sys_pread(int fd, void *buf, \
  359                             size_t nbyte, int pad, off_t offset); }
  360 174     STD             { ssize_t sys_pwrite(int fd, const void *buf, \
  361                             size_t nbyte, int pad, off_t offset); }
  362 ; For some reason, ntp_gettime doesn't want to raise SIGSYS when it's excluded.
  363 175     STD             { int sys_ntp_gettime(struct ntptimeval *ntvp); }
  364 #if defined(NTP) || !defined(_KERNEL)
  365 176     STD             { int sys_ntp_adjtime(struct timex *tp); }
  366 #else
  367 176     EXCL            ntp_adjtime
  368 #endif
  369 177     UNIMPL
  370 178     UNIMPL
  371 179     UNIMPL
  372 180     UNIMPL
  373 
  374 ; Syscalls 180-199 are used by/reserved for BSD
  375 181     STD             { int sys_setgid(gid_t gid); }
  376 182     STD             { int sys_setegid(gid_t egid); }
  377 183     STD             { int sys_seteuid(uid_t euid); }
  378 #if defined(LFS) || !defined(_KERNEL)
  379 184     STD             { int sys_lfs_bmapv(fsid_t *fsidp, \
  380                             struct block_info *blkiov, int blkcnt); }
  381 185     STD             { int sys_lfs_markv(fsid_t *fsidp, \
  382                             struct block_info *blkiov, int blkcnt); }
  383 186     STD             { int sys_lfs_segclean(fsid_t *fsidp, u_long segment); }
  384 187     STD             { int sys_lfs_segwait(fsid_t *fsidp, \
  385                             struct timeval *tv); }
  386 #else
  387 184     EXCL            lfs_bmapv
  388 185     EXCL            lfs_markv
  389 186     EXCL            lfs_segclean
  390 187     EXCL            lfs_segwait
  391 #endif
  392 188     COMPAT_12       { int sys_stat(const char *path, struct stat12 *ub); } \
  393                             stat12
  394 189     COMPAT_12       { int sys_fstat(int fd, struct stat12 *sb); } fstat12
  395 190     COMPAT_12       { int sys_lstat(const char *path, \
  396                             struct stat12 *ub); } lstat12
  397 191     STD             { long sys_pathconf(const char *path, int name); }
  398 192     STD             { long sys_fpathconf(int fd, int name); }
  399 193     UNIMPL
  400 194     STD             { int sys_getrlimit(int which, \
  401                             struct rlimit *rlp); }
  402 195     STD             { int sys_setrlimit(int which, \
  403                             const struct rlimit *rlp); }
  404 196     COMPAT_12       { int sys_getdirentries(int fd, char *buf, \
  405                             u_int count, long *basep); }
  406 197     STD             { void *sys_mmap(void *addr, size_t len, int prot, \
  407                             int flags, int fd, long pad, off_t pos); }
  408 198     INDIR           { quad_t sys___syscall(quad_t num, ...); }
  409 199     STD             { off_t sys_lseek(int fd, int pad, off_t offset, \
  410                             int whence); }
  411 200     STD             { int sys_truncate(const char *path, int pad, \
  412                             off_t length); }
  413 201     STD             { int sys_ftruncate(int fd, int pad, off_t length); }
  414 202     STD             { int sys___sysctl(int *name, u_int namelen, \
  415                             void *old, size_t *oldlenp, void *new, \
  416                             size_t newlen); }
  417 203     STD             { int sys_mlock(const void *addr, size_t len); }
  418 204     STD             { int sys_munlock(const void *addr, size_t len); }
  419 205     STD             { int sys_undelete(const char *path); }
  420 206     STD             { int sys_futimes(int fd, \
  421                             const struct timeval *tptr); }
  422 207     STD             { pid_t sys_getpgid(pid_t pid); }
  423 208     STD             { int sys_reboot(int opt, char *bootstr); }
  424 209     STD             { int sys_poll(struct pollfd *fds, u_int nfds, \
  425                             int timeout); }
  426 ;
  427 ; Syscalls 210-219 are reserved for dynamically loaded syscalls
  428 ;
  429 #if defined(LKM) || !defined(_KERNEL)
  430 210     NODEF           { int sys_lkmnosys(void); }
  431 211     NODEF           { int sys_lkmnosys(void); }
  432 212     NODEF           { int sys_lkmnosys(void); }
  433 213     NODEF           { int sys_lkmnosys(void); }
  434 214     NODEF           { int sys_lkmnosys(void); }
  435 215     NODEF           { int sys_lkmnosys(void); }
  436 216     NODEF           { int sys_lkmnosys(void); }
  437 217     NODEF           { int sys_lkmnosys(void); }
  438 218     NODEF           { int sys_lkmnosys(void); }
  439 219     NODEF           { int sys_lkmnosys(void); }
  440 #else   /* !LKM */
  441 210     EXCL            lkmnosys
  442 211     EXCL            lkmnosys
  443 212     EXCL            lkmnosys
  444 213     EXCL            lkmnosys
  445 214     EXCL            lkmnosys
  446 215     EXCL            lkmnosys
  447 216     EXCL            lkmnosys
  448 217     EXCL            lkmnosys
  449 218     EXCL            lkmnosys
  450 219     EXCL            lkmnosys
  451 #endif  /* !LKM */
  452 ; System calls 220-300 are reserved for use by NetBSD
  453 #if defined(SYSVSEM) || !defined(_KERNEL)
  454 220     COMPAT_14       { int sys___semctl(int semid, int semnum, int cmd, \
  455                             union __semun *arg); }
  456 221     STD             { int sys_semget(key_t key, int nsems, int semflg); }
  457 222     STD             { int sys_semop(int semid, struct sembuf *sops, \
  458                             size_t nsops); }
  459 223     STD             { int sys_semconfig(int flag); }
  460 #else
  461 220     EXCL            compat_14_semctl
  462 221     EXCL            semget
  463 222     EXCL            semop
  464 223     EXCL            semconfig
  465 #endif
  466 #if defined(SYSVMSG) || !defined(_KERNEL)
  467 224     COMPAT_14       { int sys_msgctl(int msqid, int cmd, \
  468                             struct msqid_ds14 *buf); }
  469 225     STD             { int sys_msgget(key_t key, int msgflg); }
  470 226     STD             { int sys_msgsnd(int msqid, const void *msgp, \
  471                             size_t msgsz, int msgflg); }
  472 227     STD             { ssize_t sys_msgrcv(int msqid, void *msgp, \
  473                             size_t msgsz, long msgtyp, int msgflg); }
  474 #else
  475 224     EXCL            compat_14_msgctl
  476 225     EXCL            msgget
  477 226     EXCL            msgsnd
  478 227     EXCL            msgrcv
  479 #endif
  480 #if defined(SYSVSHM) || !defined(_KERNEL)
  481 228     STD             { void *sys_shmat(int shmid, const void *shmaddr, \
  482                             int shmflg); }
  483 229     COMPAT_14       { int sys_shmctl(int shmid, int cmd, \
  484                             struct shmid_ds14 *buf); }
  485 230     STD             { int sys_shmdt(const void *shmaddr); }
  486 231     STD             { int sys_shmget(key_t key, size_t size, int shmflg); }
  487 #else
  488 228     EXCL            shmat
  489 229     EXCL            compat_14_shmctl
  490 230     EXCL            shmdt
  491 231     EXCL            shmget
  492 #endif
  493 232     STD             { int sys_clock_gettime(clockid_t clock_id, \
  494                             struct timespec *tp); }
  495 233     STD             { int sys_clock_settime(clockid_t clock_id, \
  496                             const struct timespec *tp); }
  497 234     STD             { int sys_clock_getres(clockid_t clock_id, \
  498                             struct timespec *tp); }
  499 235     STD             { int sys_timer_create(clockid_t clock_id, \
  500                             struct sigevent *evp, timer_t *timerid); }
  501 236     STD             { int sys_timer_delete(timer_t timerid); }
  502 237     STD             { int sys_timer_settime(timer_t timerid, int flags, \
  503                             const struct itimerspec *value, \
  504                             struct itimerspec *ovalue); }
  505 238     STD             { int sys_timer_gettime(timer_t timerid, struct \
  506                             itimerspec *value); }
  507 239     STD             { int sys_timer_getoverrun(timer_t timerid); }
  508 ;
  509 ; Syscalls 240-269 are reserved for other IEEE Std1003.1b syscalls
  510 ;
  511 240     STD             { int sys_nanosleep(const struct timespec *rqtp, \
  512                             struct timespec *rmtp); }
  513 241     STD             { int sys_fdatasync(int fd); }
  514 242     STD             { int sys_mlockall(int flags); }
  515 243     STD             { int sys_munlockall(void); }
  516 244     STD             { int sys___sigtimedwait(const sigset_t *set, \
  517                             siginfo_t *info, \
  518                             struct timespec *timeout); }
  519 245     UNIMPL          sys_sigqueue
  520 ;
  521 ; Syscall 246 is free for any use
  522 ;
  523 246     UNIMPL
  524 #if defined(P1003_1B_SEMAPHORE) || (!defined(_KERNEL) && defined(_LIBC))
  525 247     STD             { int sys__ksem_init(unsigned int value, semid_t *idp); }
  526 248     STD             { int sys__ksem_open(const char *name, int oflag, \
  527                             mode_t mode, unsigned int value, semid_t *idp); }
  528 249     STD             { int sys__ksem_unlink(const char *name); }
  529 250     STD             { int sys__ksem_close(semid_t id); }
  530 251     STD             { int sys__ksem_post(semid_t id); }
  531 252     STD             { int sys__ksem_wait(semid_t id); }
  532 253     STD             { int sys__ksem_trywait(semid_t id); }
  533 254     STD             { int sys__ksem_getvalue(semid_t id, \
  534                             unsigned int *value); }
  535 255     STD             { int sys__ksem_destroy(semid_t id); }
  536 256     UNIMPL          sys__ksem_timedwait
  537 #else
  538 247     EXCL            sys__ksem_init
  539 248     EXCL            sys__ksem_open
  540 249     EXCL            sys__ksem_unlink
  541 250     EXCL            sys__ksem_close
  542 251     EXCL            sys__ksem_post
  543 252     EXCL            sys__ksem_wait
  544 253     EXCL            sys__ksem_trywait
  545 254     EXCL            sys__ksem_getvalue
  546 255     EXCL            sys__ksem_destroy
  547 256     UNIMPL          sys__ksem_timedwait
  548 #endif
  549 257     UNIMPL          sys_mq_open
  550 258     UNIMPL          sys_mq_close
  551 259     UNIMPL          sys_mq_unlink
  552 260     UNIMPL          sys_mq_getattr
  553 261     UNIMPL          sys_mq_setattr
  554 262     UNIMPL          sys_mq_notify
  555 263     UNIMPL          sys_mq_send
  556 264     UNIMPL          sys_mq_receive
  557 265     UNIMPL          sys_mq_timedsend
  558 266     UNIMPL          sys_mq_timedreceive
  559 267     UNIMPL
  560 268     UNIMPL
  561 269     UNIMPL
  562 270     STD             { int sys___posix_rename(const char *from, \
  563                             const char *to); }
  564 271     STD             { int sys_swapctl(int cmd, const void *arg, int misc); }
  565 272     STD             { int sys_getdents(int fd, char *buf, size_t count); }
  566 273     STD             { int sys_minherit(void *addr, size_t len, \
  567                             int inherit); }
  568 274     STD             { int sys_lchmod(const char *path, mode_t mode); }
  569 275     STD             { int sys_lchown(const char *path, uid_t uid, \
  570                             gid_t gid); }
  571 276     STD             { int sys_lutimes(const char *path, \
  572                             const struct timeval *tptr); }
  573 277     STD             { int sys___msync13(void *addr, size_t len, int flags); }
  574 278     STD             { int sys___stat13(const char *path, struct stat *ub); }
  575 279     STD             { int sys___fstat13(int fd, struct stat *sb); }
  576 280     STD             { int sys___lstat13(const char *path, struct stat *ub); }
  577 281     STD             { int sys___sigaltstack14( \
  578                             const struct sigaltstack *nss, \
  579                             struct sigaltstack *oss); }
  580 282     STD             { int sys___vfork14(void); }
  581 283     STD             { int sys___posix_chown(const char *path, uid_t uid, \
  582                             gid_t gid); }
  583 284     STD             { int sys___posix_fchown(int fd, uid_t uid, \
  584                             gid_t gid); }
  585 285     STD             { int sys___posix_lchown(const char *path, uid_t uid, \
  586                             gid_t gid); }
  587 286     STD             { pid_t sys_getsid(pid_t pid); }
  588 287     STD             { pid_t sys___clone(int flags, void *stack); }
  589 #if defined(KTRACE) || !defined(_KERNEL)
  590 288     STD             { int sys_fktrace(const int fd, int ops, \
  591                             int facs, int pid); }
  592 #else
  593 288     EXCL            ktrace
  594 #endif
  595 289     STD             { ssize_t sys_preadv(int fd, \
  596                             const struct iovec *iovp, int iovcnt, \
  597                             int pad, off_t offset); }
  598 290     STD             { ssize_t sys_pwritev(int fd, \
  599                             const struct iovec *iovp, int iovcnt, \
  600                             int pad, off_t offset); }
  601 291     COMPAT_16       { int sys___sigaction14(int signum, \
  602                             const struct sigaction *nsa, \
  603                             struct sigaction *osa); }
  604 292     STD             { int sys___sigpending14(sigset_t *set); }
  605 293     STD             { int sys___sigprocmask14(int how, \
  606                             const sigset_t *set, \
  607                             sigset_t *oset); }
  608 294     STD             { int sys___sigsuspend14(const sigset_t *set); }
  609 295     COMPAT_16       { int sys___sigreturn14(struct sigcontext *sigcntxp); }
  610 296     STD             { int sys___getcwd(char *bufp, size_t length); }
  611 297     STD             { int sys_fchroot(int fd); }
  612 298     STD             { int sys_fhopen(const fhandle_t *fhp, int flags); }
  613 299     STD             { int sys_fhstat(const fhandle_t *fhp, \
  614                             struct stat *sb); }
  615 300     COMPAT_20       { int sys_fhstatfs(const fhandle_t *fhp, \
  616                             struct statfs12 *buf); }
  617 #if defined(SYSVSEM) || !defined(_KERNEL)
  618 301     STD             { int sys_____semctl13(int semid, int semnum, int cmd, \
  619                             ... union __semun *arg); }
  620 #else
  621 301     EXCL            ____semctl13
  622 #endif
  623 #if defined(SYSVMSG) || !defined(_KERNEL)
  624 302     STD             { int sys___msgctl13(int msqid, int cmd, \
  625                             struct msqid_ds *buf); }
  626 #else
  627 302     EXCL            __msgctl13
  628 #endif
  629 #if defined(SYSVSHM) || !defined(_KERNEL)
  630 303     STD             { int sys___shmctl13(int shmid, int cmd, \
  631                             struct shmid_ds *buf); }
  632 #else
  633 303     EXCL            __shmctl13
  634 #endif
  635 304     STD             { int sys_lchflags(const char *path, u_long flags); }
  636 305     STD             { int sys_issetugid(void); }
  637 306     STD             { int sys_utrace(const char *label, void *addr, \
  638                                 size_t len); }
  639 307     STD             { int sys_getcontext(struct __ucontext *ucp); }
  640 308     STD             { int sys_setcontext(const struct __ucontext *ucp); }
  641 309     STD             { int sys__lwp_create(const struct __ucontext *ucp, \
  642                                 u_long flags, lwpid_t *new_lwp); }
  643 310     STD             { int sys__lwp_exit(void); }
  644 311     STD             { lwpid_t sys__lwp_self(void); }
  645 312     STD             { int sys__lwp_wait(lwpid_t wait_for, \
  646                                 lwpid_t *departed); }
  647 313     STD             { int sys__lwp_suspend(lwpid_t target); }
  648 314     STD             { int sys__lwp_continue(lwpid_t target); }
  649 315     STD             { int sys__lwp_wakeup(lwpid_t target); }
  650 316     STD             { void *sys__lwp_getprivate(void); }
  651 317     STD             { void sys__lwp_setprivate(void *ptr); }
  652 ; Syscalls 318-329 reserved for remaining Solaris-compatible LWP calls.
  653 318     UNIMPL
  654 319     UNIMPL
  655 320     UNIMPL
  656 321     UNIMPL
  657 322     UNIMPL
  658 323     UNIMPL
  659 324     UNIMPL
  660 325     UNIMPL
  661 326     UNIMPL
  662 327     UNIMPL
  663 328     UNIMPL
  664 329     UNIMPL
  665 ; Scheduler activation syscalls
  666 330     STD             { int sys_sa_register(sa_upcall_t new, \
  667                                 sa_upcall_t *old, int flags, \
  668                                 ssize_t stackinfo_offset); }
  669 331     STD             { int sys_sa_stacks(int num, stack_t *stacks); }
  670 332     STD             { int sys_sa_enable(void); }
  671 333     STD             { int sys_sa_setconcurrency(int concurrency); }
  672 334     STD             { int sys_sa_yield(void); }
  673 335     STD             { int sys_sa_preempt(int sa_id); }
  674 336     OBSOL           sys_sa_unblockyield
  675 ;
  676 ; Syscalls 337-339 are reserved for other scheduler activation syscalls.
  677 ;
  678 337     UNIMPL
  679 338     UNIMPL
  680 339     UNIMPL
  681 340     STD             { int sys___sigaction_sigtramp(int signum, \
  682                             const struct sigaction *nsa, \
  683                             struct sigaction *osa, \
  684                             const void *tramp, int vers); }
  685 341     STD             { int sys_pmc_get_info(int ctr, int op, void *args); }
  686 342     STD             { int sys_pmc_control(int ctr, int op, void *args); }
  687 343     STD             { int sys_rasctl(caddr_t addr, size_t len, int op); }
  688 344     STD             { int sys_kqueue(void); }
  689 345     STD             { int sys_kevent(int fd, \
  690                             const struct kevent *changelist, size_t nchanges, \
  691                             struct kevent *eventlist, size_t nevents, \
  692                             const struct timespec *timeout); }
  693 ;
  694 ; Syscalls 346-353 are reserved for the IEEE Std1003.1b scheduling syscalls
  695 ;
  696 346     UNIMPL          sys_sched_setparam
  697 347     UNIMPL          sys_sched_getparam
  698 348     UNIMPL          sys_sched_setscheduler
  699 349     UNIMPL          sys_sched_getscheduler
  700 350     UNIMPL          sys_sched_yield
  701 351     UNIMPL          sys_sched_get_priority_max
  702 352     UNIMPL          sys_sched_get_priority_min
  703 353     UNIMPL          sys_sched_rr_get_interval
  704 
  705 354     STD             { int sys_fsync_range(int fd, int flags, off_t start, \
  706                             off_t length); }
  707 355     STD             { int sys_uuidgen(struct uuid *store, int count); }
  708 356     STD             { int sys_getvfsstat(struct statvfs *buf, \
  709                             size_t bufsize, int flags); }
  710 357     STD             { int sys_statvfs1(const char *path, \
  711                             struct statvfs *buf, int flags); }
  712 358     STD             { int sys_fstatvfs1(int fd, struct statvfs *buf, \
  713                             int flags); }
  714 359     STD             { int sys_fhstatvfs1(const fhandle_t *fhp, \
  715                             struct statvfs *buf, int flags); }
  716 360     STD             { int sys_extattrctl(const char *path, int cmd, \
  717                             const char *filename, int attrnamespace, \
  718                             const char *attrname); }
  719 361     STD             { int sys_extattr_set_file(const char *path, \
  720                             int attrnamespace, const char *attrname, \
  721                             const void *data, size_t nbytes); }
  722 362     STD             { int sys_extattr_get_file(const char *path, \
  723                             int attrnamespace, const char *attrname, \
  724                             void *data, size_t nbytes); }
  725 363     STD             { int sys_extattr_delete_file(const char *path, \
  726                             int attrnamespace, const char *attrname); }
  727 364     STD             { int sys_extattr_set_fd(int fd, \
  728                             int attrnamespace, const char *attrname, \
  729                             const void *data, size_t nbytes); }
  730 365     STD             { int sys_extattr_get_fd(int fd, \
  731                             int attrnamespace, const char *attrname, \
  732                             void *data, size_t nbytes); }
  733 366     STD             { int sys_extattr_delete_fd(int fd, \
  734                             int attrnamespace, const char *attrname); }
  735 367     STD             { int sys_extattr_set_link(const char *path, \
  736                             int attrnamespace, const char *attrname, \
  737                             const void *data, size_t nbytes); }
  738 368     STD             { int sys_extattr_get_link(const char *path, \
  739                             int attrnamespace, const char *attrname, \
  740                             void *data, size_t nbytes); }
  741 369     STD             { int sys_extattr_delete_link(const char *path, \
  742                             int attrnamespace, const char *attrname); }
  743 370     STD             { int sys_extattr_list_fd(int fd, \
  744                             int attrnamespace, void *data, size_t nbytes); }
  745 371     STD             { int sys_extattr_list_file(const char *path, \
  746                             int attrnamespace, void *data, size_t nbytes); }
  747 372     STD             { int sys_extattr_list_link(const char *path, \
  748                             int attrnamespace, void *data, size_t nbytes); }
  749 373     STD             { int sys_pselect(int nd, fd_set *in, fd_set *ou, \
  750                             fd_set *ex, const struct timespec *ts, \
  751                             const sigset_t *mask); }
  752 374     STD             { int sys_pollts(struct pollfd *fds, u_int nfds, \
  753                             const struct timespec *ts, const sigset_t *mask); }

Cache object: f84c4d9ce8c5635c7ce7ec1efcd30654


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