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/compat/pecoff/syscalls.master

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

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

Cache object: e5f6a04b87e0877f8700262e79116983


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