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

Cache object: ab0f415ecdd50d9d91cdba7b8977766a


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