File:  [DragonFly] / src / sys / kern / syscalls.master
Revision 1.11: download - view: text, annotated - select for diffs
Tue Jan 20 18:41:51 2004 UTC (10 years, 7 months ago) by dillon
Branches: MAIN
CVS tags: HEAD
Resident executable support stage 1/4: Add kernel bits and syscall support
for in-kernel caching of vmspace structures.  The main purpose of this
feature is to make it possible to run dynamically linked programs as fast
as if they were statically linked, by vmspace_fork()ing their vmspace and
saving the copy in the kernel, then using that whenever the program is
exec'd.

    1:  $DragonFly: src/sys/kern/syscalls.master,v 1.11 2004/01/20 18:41:51 dillon Exp $
    2: 
    3: ; @(#)syscalls.master	8.2 (Berkeley) 1/13/94
    4: ; $FreeBSD: src/sys/kern/syscalls.master,v 1.72.2.10 2002/07/12 08:22:46 alfred Exp $
    5: ;
    6: ; System call name/number master file.
    7: ; Processed to created init_sysent.c, syscalls.c and syscall.h.
    8: 
    9: ; Columns: number [MPSAFE] type nargs namespc name alt{name,tag,rtyp}/comments
   10: ;	number	system call number, must be in order
   11: ;   MPSAFE	optional field, specifies that syscall does not want the
   12: ;		BGL grabbed automatically (it is SMP safe).
   13: ;	type	one of STD, OBSOL, UNIMPL, COMPAT, CPT_NOA, LIBCOMPAT,
   14: ;		NODEF, NOARGS, NOPROTO, NOIMPL
   15: ;	namespc one of POSIX, BSD, NOHIDE
   16: ;	name	psuedo-prototype of syscall routine
   17: ;		If one of the following alts is different, then all appear:
   18: ;	altname	name of system call if different
   19: ;	alttag	name of args struct tag if different from [o]`name'"_args"
   20: ;	altrtyp	return type if not int (bogus - syscalls always return int)
   21: ;		for UNIMPL/OBSOL, name continues with comments
   22: 
   23: ; types:
   24: ;	STD	always included
   25: ;	COMPAT	included on COMPAT #ifdef
   26: ;	LIBCOMPAT included on COMPAT #ifdef, and placed in syscall.h
   27: ;	OBSOL	obsolete, not included in system, only specifies name
   28: ;	UNIMPL	not implemented, placeholder only
   29: 
   30: ; #ifdef's, etc. may be included, and are copied to the output files.
   31: 
   32: #include <sys/param.h>
   33: #include <sys/sysent.h>
   34: #include <sys/sysproto.h>
   35: 
   36: ; Reserved/unimplemented system calls in the range 0-150 inclusive
   37: ; are reserved for use in future Berkeley releases.
   38: ; Additional system calls implemented in vendor and other
   39: ; redistributions should be placed in the reserved range at the end
   40: ; of the current calls.
   41: 
   42: 0	STD	NOHIDE	{ int nosys(void); } syscall nosys_args int
   43: 1	STD	NOHIDE	{ void sys_exit(int rval); } exit sys_exit_args void
   44: 2	STD	POSIX	{ int fork(void); }
   45: 3	STD	POSIX	{ ssize_t read(int fd, void *buf, size_t nbyte); }
   46: 4	STD	POSIX	{ ssize_t write(int fd, const void *buf, size_t nbyte); }
   47: 5	STD	POSIX	{ int open(char *path, int flags, int mode); }
   48: ; XXX should be		{ int open(const char *path, int flags, ...); }
   49: ; but we're not ready for `const' or varargs.
   50: ; XXX man page says `mode_t mode'.
   51: 6	STD	POSIX	{ int close(int fd); }
   52: 7	STD	BSD	{ int wait4(int pid, int *status, int options, \
   53: 			    struct rusage *rusage); } wait4 wait_args int
   54: 8	COMPAT	BSD	{ int creat(char *path, int mode); }
   55: 9	STD	POSIX	{ int link(char *path, char *link); }
   56: 10	STD	POSIX	{ int unlink(char *path); }
   57: 11	OBSOL	NOHIDE	execv
   58: 12	STD	POSIX	{ int chdir(char *path); }
   59: 13	STD	BSD	{ int fchdir(int fd); }
   60: 14	STD	POSIX	{ int mknod(char *path, int mode, int dev); }
   61: 15	STD	POSIX	{ int chmod(char *path, int mode); }
   62: 16	STD	POSIX	{ int chown(char *path, int uid, int gid); }
   63: 17	STD	BSD	{ int obreak(char *nsize); } break obreak_args int
   64: 18	STD	BSD	{ int getfsstat(struct statfs *buf, long bufsize, \
   65: 			    int flags); }
   66: 19	COMPAT	POSIX	{ long lseek(int fd, long offset, int whence); }
   67: 20	STD	POSIX	{ pid_t getpid(void); }
   68: 21	STD	BSD	{ int mount(char *type, char *path, int flags, \
   69: 			    caddr_t data); }
   70: ; XXX `path' should have type `const char *' but we're not ready for that.
   71: 22	STD	BSD	{ int unmount(char *path, int flags); }
   72: 23	STD	POSIX	{ int setuid(uid_t uid); }
   73: 24	MPSAFE	STD	POSIX	{ uid_t getuid(void); }
   74: 25	MPSAFE	STD	POSIX	{ uid_t geteuid(void); }
   75: 26	STD	BSD	{ int ptrace(int req, pid_t pid, caddr_t addr, \
   76: 			    int data); }
   77: 27	STD	BSD	{ int recvmsg(int s, struct msghdr *msg, int flags); }
   78: 28	STD	BSD	{ int sendmsg(int s, caddr_t msg, int flags); }
   79: 29	STD	BSD	{ int recvfrom(int s, caddr_t buf, size_t len, \
   80: 			    int flags, caddr_t from, int *fromlenaddr); }
   81: 30	STD	BSD	{ int accept(int s, caddr_t name, int *anamelen); }
   82: 31	STD	BSD	{ int getpeername(int fdes, caddr_t asa, int *alen); }
   83: 32	STD	BSD	{ int getsockname(int fdes, caddr_t asa, int *alen); }
   84: 33	STD	POSIX	{ int access(char *path, int flags); }
   85: 34	STD	BSD	{ int chflags(char *path, int flags); }
   86: 35	STD	BSD	{ int fchflags(int fd, int flags); }
   87: 36	STD	BSD	{ int sync(void); }
   88: 37	STD	POSIX	{ int kill(int pid, int signum); }
   89: 38	COMPAT	POSIX	{ int stat(char *path, struct ostat *ub); }
   90: 39	STD	POSIX	{ pid_t getppid(void); }
   91: 40	COMPAT	POSIX	{ int lstat(char *path, struct ostat *ub); }
   92: 41	STD	POSIX	{ int dup(u_int fd); }
   93: 42	STD	POSIX	{ int pipe(void); }
   94: 43	STD	POSIX	{ gid_t getegid(void); }
   95: 44	STD	BSD	{ int profil(caddr_t samples, size_t size, \
   96: 			    size_t offset, u_int scale); }
   97: 45	STD	BSD	{ int ktrace(const char *fname, int ops, int facs, \
   98: 			    int pid); }
   99: 46	OBSOL	NOHIDE	freebsd3_sigaction
  100: 47	MPSAFE	STD	POSIX	{ gid_t getgid(void); }
  101: 48	OBSOL	NOHIDE	freebsd3_sigprocmask
  102: ; XXX note nonstandard (bogus) calling convention - the libc stub passes
  103: ; us the mask, not a pointer to it, and we return the old mask as the
  104: ; (int) return value.
  105: 49	STD	BSD	{ int getlogin(char *namebuf, u_int namelen); }
  106: 50	STD	BSD	{ int setlogin(char *namebuf); }
  107: 51	STD	BSD	{ int acct(char *path); }
  108: 52	OBSOL	NOHIDE	freebsd3_sigpending
  109: 53	STD	BSD	{ int sigaltstack(stack_t *ss, stack_t *oss); }
  110: 54	STD	POSIX	{ int ioctl(int fd, u_long com, caddr_t data); }
  111: 55	STD	BSD	{ int reboot(int opt); }
  112: 56	STD	POSIX	{ int revoke(char *path); }
  113: 57	STD	POSIX	{ int symlink(char *path, char *link); }
  114: 58	STD	POSIX	{ int readlink(char *path, char *buf, int count); }
  115: 59	STD	POSIX	{ int execve(char *fname, char **argv, char **envv); }
  116: 60	MPSAFE	STD	POSIX	{ int umask(int newmask); } umask umask_args int
  117: 61	STD	BSD	{ int chroot(char *path); }
  118: 62	COMPAT	POSIX	{ int fstat(int fd, struct ostat *sb); }
  119: 63	COMPAT	BSD	{ int getkerninfo(int op, char *where, size_t *size, \
  120: 			    int arg); } getkerninfo getkerninfo_args int
  121: 64	COMPAT	BSD	{ int getpagesize(void); } \
  122: 			    getpagesize getpagesize_args int
  123: 65	STD	BSD	{ int msync(void *addr, size_t len, int flags); }
  124: 66	STD	BSD	{ int vfork(void); }
  125: 67	OBSOL	NOHIDE	vread
  126: 68	OBSOL	NOHIDE	vwrite
  127: 69	STD	BSD	{ int sbrk(int incr); }
  128: 70	STD	BSD	{ int sstk(int incr); }
  129: 71	COMPAT	BSD	{ int mmap(void *addr, int len, int prot, \
  130: 			    int flags, int fd, long pos); }
  131: 72	STD	BSD	{ int ovadvise(int anom); } vadvise ovadvise_args int
  132: 73	STD	BSD	{ int munmap(void *addr, size_t len); }
  133: 74	STD	BSD	{ int mprotect(const void *addr, size_t len, int prot); }
  134: 75	STD	BSD	{ int madvise(void *addr, size_t len, int behav); }
  135: 76	OBSOL	NOHIDE	vhangup
  136: 77	OBSOL	NOHIDE	vlimit
  137: 78	STD	BSD	{ int mincore(const void *addr, size_t len, \
  138: 			    char *vec); }
  139: 79	STD	POSIX	{ int getgroups(u_int gidsetsize, gid_t *gidset); }
  140: 80	STD	POSIX	{ int setgroups(u_int gidsetsize, gid_t *gidset); }
  141: 81	MPSAFE	STD	POSIX	{ int getpgrp(void); }
  142: 82	STD	POSIX	{ int setpgid(int pid, int pgid); }
  143: 83	STD	BSD	{ int setitimer(u_int which, struct itimerval *itv, \
  144: 			    struct itimerval *oitv); }
  145: 84	COMPAT	BSD	{ int wait(void); }
  146: 85	STD	BSD	{ int swapon(char *name); }
  147: 86	STD	BSD	{ int getitimer(u_int which, struct itimerval *itv); }
  148: 87	COMPAT	BSD	{ int gethostname(char *hostname, u_int len); } \
  149: 			    gethostname gethostname_args int
  150: 88	COMPAT	BSD	{ int sethostname(char *hostname, u_int len); } \
  151: 			    sethostname sethostname_args int
  152: 89	STD	BSD	{ int getdtablesize(void); }
  153: 90	STD	POSIX	{ int dup2(u_int from, u_int to); }
  154: 91	UNIMPL	BSD	getdopt
  155: 92	STD	POSIX	{ int fcntl(int fd, int cmd, long arg); }
  156: ; XXX should be		{ int fcntl(int fd, int cmd, ...); }
  157: ; but we're not ready for varargs.
  158: ; XXX man page says `int arg' too.
  159: 93	STD	BSD	{ int select(int nd, fd_set *in, fd_set *ou, \
  160: 			    fd_set *ex, struct timeval *tv); }
  161: 94	UNIMPL	BSD	setdopt
  162: 95	STD	POSIX	{ int fsync(int fd); }
  163: 96	STD	BSD	{ int setpriority(int which, int who, int prio); }
  164: 97	STD	BSD	{ int socket(int domain, int type, int protocol); }
  165: 98	STD	BSD	{ int connect(int s, caddr_t name, int namelen); }
  166: 99	CPT_NOA	BSD	{ int accept(int s, caddr_t name, int *anamelen); } \
  167: 			    accept accept_args int
  168: 100	STD	BSD	{ int getpriority(int which, int who); }
  169: 101	COMPAT	BSD	{ int send(int s, caddr_t buf, int len, int flags); }
  170: 102	COMPAT	BSD	{ int recv(int s, caddr_t buf, int len, int flags); }
  171: 103	OBSOL	NOHIDE	freebsd3_sigreturn
  172: 104	STD	BSD	{ int bind(int s, caddr_t name, int namelen); }
  173: 105	STD	BSD	{ int setsockopt(int s, int level, int name, \
  174: 			    caddr_t val, int valsize); }
  175: 106	STD	BSD	{ int listen(int s, int backlog); }
  176: 107	OBSOL	NOHIDE	vtimes
  177: 108	COMPAT	BSD	{ int sigvec(int signum, struct sigvec *nsv, \
  178: 			    struct sigvec *osv); }
  179: 109	COMPAT	BSD	{ int sigblock(int mask); }
  180: 110	COMPAT	BSD	{ int sigsetmask(int mask); }
  181: 111	OBSOL	NOHIDE	freebsd3_sigsuspend
  182: ; XXX note nonstandard (bogus) calling convention - the libc stub passes
  183: ; us the mask, not a pointer to it.
  184: 112	COMPAT	BSD	{ int sigstack(struct sigstack *nss, \
  185: 			    struct sigstack *oss); }
  186: 113	COMPAT	BSD	{ int recvmsg(int s, struct omsghdr *msg, int flags); }
  187: 114	COMPAT	BSD	{ int sendmsg(int s, caddr_t msg, int flags); }
  188: 115	OBSOL	NOHIDE	vtrace
  189: 116	MPSAFE	STD	BSD	{ int gettimeofday(struct timeval *tp, \
  190: 			    struct timezone *tzp); }
  191: 117	STD	BSD	{ int getrusage(int who, struct rusage *rusage); }
  192: 118	STD	BSD	{ int getsockopt(int s, int level, int name, \
  193: 			    caddr_t val, int *avalsize); }
  194: 119	UNIMPL	NOHIDE	resuba (BSD/OS 2.x)
  195: 120	STD	BSD	{ int readv(int fd, struct iovec *iovp, u_int iovcnt); }
  196: 121	STD	BSD	{ int writev(int fd, struct iovec *iovp, \
  197: 			    u_int iovcnt); }
  198: 122	STD	BSD	{ int settimeofday(struct timeval *tv, \
  199: 			    struct timezone *tzp); }
  200: 123	STD	BSD	{ int fchown(int fd, int uid, int gid); }
  201: 124	STD	BSD	{ int fchmod(int fd, int mode); }
  202: 125	CPT_NOA	BSD	{ int recvfrom(int s, caddr_t buf, size_t len, \
  203: 			    int flags, caddr_t from, int *fromlenaddr); } \
  204: 			    recvfrom recvfrom_args int
  205: 126	STD	BSD	{ int setreuid(int ruid, int euid); }
  206: 127	STD	BSD	{ int setregid(int rgid, int egid); }
  207: 128	STD	POSIX	{ int rename(char *from, char *to); }
  208: 129	COMPAT	BSD	{ int truncate(char *path, long length); }
  209: 130	COMPAT	BSD	{ int ftruncate(int fd, long length); }
  210: 131	STD	BSD	{ int flock(int fd, int how); }
  211: 132	STD	POSIX	{ int mkfifo(char *path, int mode); }
  212: 133	STD	BSD	{ int sendto(int s, caddr_t buf, size_t len, \
  213: 			    int flags, caddr_t to, int tolen); }
  214: 134	STD	BSD	{ int shutdown(int s, int how); }
  215: 135	STD	BSD	{ int socketpair(int domain, int type, int protocol, \
  216: 			    int *rsv); }
  217: 136	STD	POSIX	{ int mkdir(char *path, int mode); }
  218: 137	STD	POSIX	{ int rmdir(char *path); }
  219: 138	STD	BSD	{ int utimes(char *path, struct timeval *tptr); }
  220: 139	OBSOL	NOHIDE	4.2 sigreturn
  221: 140	STD	BSD	{ int adjtime(struct timeval *delta, \
  222: 			    struct timeval *olddelta); }
  223: 141	COMPAT	BSD	{ int getpeername(int fdes, caddr_t asa, int *alen); }
  224: 142	COMPAT	BSD	{ long gethostid(void); }
  225: 143	COMPAT	BSD	{ int sethostid(long hostid); }
  226: 144	COMPAT	BSD	{ int getrlimit(u_int which, struct orlimit *rlp); }
  227: 145	COMPAT	BSD	{ int setrlimit(u_int which, struct orlimit *rlp); }
  228: 146	COMPAT	BSD	{ int killpg(int pgid, int signum); }
  229: 147	STD	POSIX	{ int setsid(void); }
  230: 148	STD	BSD	{ int quotactl(char *path, int cmd, int uid, \
  231: 			    caddr_t arg); }
  232: 149	COMPAT	BSD	{ int quota(void); }
  233: 150	CPT_NOA	BSD	{ int getsockname(int fdec, caddr_t asa, int *alen); }\
  234: 			    getsockname getsockname_args int
  235: 
  236: ; Syscalls 151-180 inclusive are reserved for vendor-specific
  237: ; system calls.  (This includes various calls added for compatibity
  238: ; with other Unix variants.)
  239: ; Some of these calls are now supported by BSD...
  240: 151	UNIMPL	NOHIDE	sem_lock (BSD/OS 2.x)
  241: 152	UNIMPL	NOHIDE	sem_wakeup (BSD/OS 2.x)
  242: 153	UNIMPL	NOHIDE	asyncdaemon (BSD/OS 2.x)
  243: 154	UNIMPL	NOHIDE	nosys
  244: ; 155 is initialized by the NFS code, if present.
  245: 155	NOIMPL	BSD	{ int nfssvc(int flag, caddr_t argp); }
  246: 156	COMPAT	BSD	{ int getdirentries(int fd, char *buf, u_int count, \
  247: 			    long *basep); }
  248: 157	STD	BSD	{ int statfs(char *path, struct statfs *buf); }
  249: 158	STD	BSD	{ int fstatfs(int fd, struct statfs *buf); }
  250: 159	UNIMPL	NOHIDE	nosys
  251: 160	UNIMPL	NOHIDE	nosys
  252: ; 161 is initialized by the NFS code, if present.
  253: 161	STD	BSD	{ int getfh(char *fname, struct fhandle *fhp); }
  254: 162	STD	BSD	{ int getdomainname(char *domainname, int len); }
  255: 163	STD	BSD	{ int setdomainname(char *domainname, int len); }
  256: 164	STD	BSD	{ int uname(struct utsname *name); }
  257: 165	STD	BSD	{ int sysarch(int op, char *parms); }
  258: 166	STD	BSD	{ int rtprio(int function, pid_t pid, \
  259: 			    struct rtprio *rtp); }
  260: 167	UNIMPL	NOHIDE	nosys
  261: 168	UNIMPL	NOHIDE	nosys
  262: 169	STD	BSD	{ int semsys(int which, int a2, int a3, int a4, \
  263: 			    int a5); }
  264: ; XXX should be		{ int semsys(int which, ...); }
  265: 170	STD	BSD	{ int msgsys(int which, int a2, int a3, int a4, \
  266: 			    int a5, int a6); }
  267: ; XXX should be		{ int msgsys(int which, ...); }
  268: 171	STD	BSD	{ int shmsys(int which, int a2, int a3, int a4); }
  269: ; XXX should be		{ int shmsys(int which, ...); }
  270: 172	UNIMPL	NOHIDE	nosys
  271: 173	STD	POSIX	{ ssize_t pread(int fd, void *buf, size_t nbyte, \
  272: 			    int pad, off_t offset); }
  273: 174	STD	POSIX	{ ssize_t pwrite(int fd, const void *buf, \
  274: 			    size_t nbyte, int pad, off_t offset); }
  275: 175	UNIMPL	NOHIDE	nosys
  276: 176	STD	BSD	{ int ntp_adjtime(struct timex *tp); }
  277: 177	UNIMPL	NOHIDE	sfork (BSD/OS 2.x)
  278: 178	UNIMPL	NOHIDE	getdescriptor (BSD/OS 2.x)
  279: 179	UNIMPL	NOHIDE	setdescriptor (BSD/OS 2.x)
  280: 180	UNIMPL	NOHIDE	nosys
  281: 
  282: ; Syscalls 181-199 are used by/reserved for BSD
  283: 181	STD	POSIX	{ int setgid(gid_t gid); }
  284: 182	STD	BSD	{ int setegid(gid_t egid); }
  285: 183	STD	BSD	{ int seteuid(uid_t euid); }
  286: 184	UNIMPL	BSD	lfs_bmapv
  287: 185	UNIMPL	BSD	lfs_markv
  288: 186	UNIMPL	BSD	lfs_segclean
  289: 187	UNIMPL	BSD	lfs_segwait
  290: 188	STD	POSIX	{ int stat(char *path, struct stat *ub); }
  291: 189	STD	POSIX	{ int fstat(int fd, struct stat *sb); }
  292: 190	STD	POSIX	{ int lstat(char *path, struct stat *ub); }
  293: 191	STD	POSIX	{ int pathconf(char *path, int name); }
  294: 192	STD	POSIX	{ int fpathconf(int fd, int name); }
  295: 193	UNIMPL	NOHIDE	nosys
  296: 194	STD	BSD	{ int getrlimit(u_int which, \
  297: 			    struct rlimit *rlp); } \
  298: 			    getrlimit __getrlimit_args int
  299: 195	STD	BSD	{ int setrlimit(u_int which, \
  300: 			    struct rlimit *rlp); } \
  301: 			    setrlimit __setrlimit_args int
  302: 196	STD	BSD	{ int getdirentries(int fd, char *buf, u_int count, \
  303: 			    long *basep); }
  304: 197	STD	BSD	{ caddr_t mmap(caddr_t addr, size_t len, int prot, \
  305: 			    int flags, int fd, int pad, off_t pos); }
  306: 198	STD	NOHIDE	{ int nosys(void); } __syscall __syscall_args int
  307: 199	STD	POSIX	{ off_t lseek(int fd, int pad, off_t offset, \
  308: 			    int whence); }
  309: 200	STD	BSD	{ int truncate(char *path, int pad, off_t length); }
  310: 201	STD	BSD	{ int ftruncate(int fd, int pad, off_t length); }
  311: 202	STD	BSD	{ int __sysctl(int *name, u_int namelen, void *old, \
  312: 			    size_t *oldlenp, void *new, size_t newlen); } \
  313: 			    __sysctl sysctl_args int
  314: ; properly, __sysctl should be a NOHIDE, but making an exception
  315: ; here allows to avoid one in libc/sys/Makefile.inc.
  316: 203	STD	BSD	{ int mlock(const void *addr, size_t len); }
  317: 204	STD	BSD	{ int munlock(const void *addr, size_t len); }
  318: 205	STD	BSD	{ int undelete(char *path); }
  319: 206	STD	BSD	{ int futimes(int fd, struct timeval *tptr); }
  320: 207	STD	BSD	{ int getpgid(pid_t pid); }
  321: 208	UNIMPL	NOHIDE	newreboot (NetBSD)
  322: 209	STD	BSD	{ int poll(struct pollfd *fds, u_int nfds, \
  323: 			    int timeout); }
  324: 
  325: ;
  326: ; The following are reserved for loadable syscalls
  327: ;
  328: ; 210 is used by the Checkpoint Module
  329: 210	NODEF	NOHIDE	lkmnosys lkmnosys nosys_args int
  330: 211	NODEF	NOHIDE	lkmnosys lkmnosys nosys_args int
  331: 212	NODEF	NOHIDE	lkmnosys lkmnosys nosys_args int
  332: 213	NODEF	NOHIDE	lkmnosys lkmnosys nosys_args int
  333: 214	NODEF	NOHIDE	lkmnosys lkmnosys nosys_args int
  334: 215	NODEF	NOHIDE	lkmnosys lkmnosys nosys_args int
  335: 216	NODEF	NOHIDE	lkmnosys lkmnosys nosys_args int
  336: 217	NODEF	NOHIDE	lkmnosys lkmnosys nosys_args int
  337: 218	NODEF	NOHIDE	lkmnosys lkmnosys nosys_args int
  338: 219	NODEF	NOHIDE	lkmnosys lkmnosys nosys_args int
  339: 
  340: ;
  341: ; The following were introduced with NetBSD/4.4Lite-2
  342: ;
  343: 220	STD	BSD	{ int __semctl(int semid, int semnum, int cmd, \
  344: 			    union semun *arg); }
  345: 221	STD	BSD	{ int semget(key_t key, int nsems, int semflg); }
  346: 222	STD	BSD	{ int semop(int semid, struct sembuf *sops, \
  347: 			    u_int nsops); }
  348: 223	UNIMPL	NOHIDE	semconfig
  349: 224	STD	BSD	{ int msgctl(int msqid, int cmd, \
  350: 			    struct msqid_ds *buf); }
  351: 225	STD	BSD	{ int msgget(key_t key, int msgflg); }
  352: 226	STD	BSD	{ int msgsnd(int msqid, void *msgp, size_t msgsz, \
  353: 			    int msgflg); }
  354: 227	STD	BSD	{ int msgrcv(int msqid, void *msgp, size_t msgsz, \
  355: 			    long msgtyp, int msgflg); }
  356: 228	STD	BSD	{ int shmat(int shmid, void *shmaddr, int shmflg); }
  357: 229	STD	BSD	{ int shmctl(int shmid, int cmd, \
  358: 			    struct shmid_ds *buf); }
  359: 230	STD	BSD	{ int shmdt(void *shmaddr); }
  360: 231	STD	BSD	{ int shmget(key_t key, int size, int shmflg); }
  361: ;
  362: 232	STD	POSIX	{ int clock_gettime(clockid_t clock_id, \
  363: 			    struct timespec *tp); }
  364: 233	STD	POSIX	{ int clock_settime(clockid_t clock_id, \
  365: 			    const struct timespec *tp); }
  366: 234	STD	POSIX	{ int clock_getres(clockid_t clock_id, \
  367: 			    struct timespec *tp); }
  368: 235	UNIMPL	NOHIDE	timer_create
  369: 236	UNIMPL	NOHIDE	timer_delete
  370: 237	UNIMPL	NOHIDE	timer_settime
  371: 238	UNIMPL	NOHIDE	timer_gettime
  372: 239	UNIMPL	NOHIDE	timer_getoverrun
  373: 240	STD	POSIX	{ int nanosleep(const struct timespec *rqtp, \
  374: 			    struct timespec *rmtp); }
  375: 241	UNIMPL	NOHIDE	nosys
  376: 242	UNIMPL	NOHIDE	nosys
  377: 243	UNIMPL	NOHIDE	nosys
  378: 244	UNIMPL	NOHIDE	nosys
  379: 245	UNIMPL	NOHIDE	nosys
  380: 246	UNIMPL	NOHIDE	nosys
  381: 247	UNIMPL	NOHIDE	nosys
  382: 248	UNIMPL	NOHIDE	nosys
  383: 249	UNIMPL	NOHIDE	nosys
  384: ; syscall numbers initially used in OpenBSD
  385: 250	STD	BSD	{ int minherit(void *addr, size_t len, int inherit); }
  386: 251	STD	BSD	{ int rfork(int flags); }
  387: 252	STD	BSD	{ int openbsd_poll(struct pollfd *fds, u_int nfds, \
  388: 			    int timeout); }
  389: 253	STD	BSD	{ int issetugid(void); }
  390: 254	STD	BSD	{ int lchown(char *path, int uid, int gid); }
  391: 255	UNIMPL	NOHIDE	nosys
  392: 256	UNIMPL	NOHIDE	nosys
  393: 257	UNIMPL	NOHIDE	nosys
  394: 258	UNIMPL	NOHIDE	nosys
  395: 259	UNIMPL	NOHIDE	nosys
  396: 260	UNIMPL	NOHIDE	nosys
  397: 261	UNIMPL	NOHIDE	nosys
  398: 262	UNIMPL	NOHIDE	nosys
  399: 263	UNIMPL	NOHIDE	nosys
  400: 264	UNIMPL	NOHIDE	nosys
  401: 265	UNIMPL	NOHIDE	nosys
  402: 266	UNIMPL	NOHIDE	nosys
  403: 267	UNIMPL	NOHIDE	nosys
  404: 268	UNIMPL	NOHIDE	nosys
  405: 269	UNIMPL	NOHIDE	nosys
  406: 270	UNIMPL	NOHIDE	nosys
  407: 271	UNIMPL	NOHIDE	nosys
  408: 272	STD	BSD	{ int getdents(int fd, char *buf, size_t count); }
  409: 273	UNIMPL	NOHIDE	nosys
  410: 274	STD	BSD	{ int lchmod(char *path, mode_t mode); }
  411: 275	NOPROTO BSD	{ int lchown(char *path, uid_t uid, gid_t gid); } netbsd_lchown lchown_args int
  412: 276	STD	BSD	{ int lutimes(char *path, struct timeval *tptr); }
  413: 277	NOPROTO	BSD	{ int msync(void *addr, size_t len, int flags); } netbsd_msync msync_args int
  414: 278	STD	BSD	{ int nstat(char *path, struct nstat *ub); }
  415: 279	STD	BSD	{ int nfstat(int fd, struct nstat *sb); }
  416: 280	STD	BSD	{ int nlstat(char *path, struct nstat *ub); }
  417: 281	UNIMPL	NOHIDE	nosys
  418: 282	UNIMPL	NOHIDE	nosys
  419: 283	UNIMPL	NOHIDE	nosys
  420: 284	UNIMPL	NOHIDE	nosys
  421: 285	UNIMPL	NOHIDE	nosys
  422: 286	UNIMPL	NOHIDE	nosys
  423: 287	UNIMPL	NOHIDE	nosys
  424: 288	UNIMPL	NOHIDE	nosys
  425: 289	UNIMPL	NOHIDE	nosys
  426: 290	UNIMPL	NOHIDE	nosys
  427: 291	UNIMPL	NOHIDE	nosys
  428: 292	UNIMPL	NOHIDE	nosys
  429: 293	UNIMPL	NOHIDE	nosys
  430: 294	UNIMPL	NOHIDE	nosys
  431: 295	UNIMPL	NOHIDE	nosys
  432: 296	UNIMPL	NOHIDE	nosys
  433: ; XXX 297 is 300 in NetBSD 
  434: 297	STD	BSD	{ int fhstatfs(const struct fhandle *u_fhp, struct statfs *buf); }
  435: 298	STD	BSD	{ int fhopen(const struct fhandle *u_fhp, int flags); }
  436: 299	STD	BSD 	{ int fhstat(const struct fhandle *u_fhp, struct stat *sb); }
  437: ; syscall numbers for FreeBSD
  438: 300	STD	BSD	{ int modnext(int modid); }
  439: 301	STD	BSD	{ int modstat(int modid, struct module_stat* stat); }
  440: 302	STD	BSD	{ int modfnext(int modid); }
  441: 303	STD	BSD	{ int modfind(const char *name); }
  442: 304	STD	BSD	{ int kldload(const char *file); }
  443: 305	STD	BSD	{ int kldunload(int fileid); }
  444: 306	STD	BSD	{ int kldfind(const char *file); }
  445: 307	STD	BSD	{ int kldnext(int fileid); }
  446: 308	STD	BSD	{ int kldstat(int fileid, struct kld_file_stat* stat); }
  447: 309	STD	BSD	{ int kldfirstmod(int fileid); }
  448: 310	STD	BSD	{ int getsid(pid_t pid); }
  449: 311	STD	BSD	{ int setresuid(uid_t ruid, uid_t euid, uid_t suid); }
  450: 312	STD	BSD	{ int setresgid(gid_t rgid, gid_t egid, gid_t sgid); }
  451: 313	OBSOL	NOHIDE	signanosleep
  452: 314     STD     BSD     { int aio_return(struct aiocb *aiocbp); }
  453: 315     STD     BSD     { int aio_suspend(struct aiocb * const * aiocbp, int nent, const struct timespec *timeout); }
  454: 316     STD     BSD     { int aio_cancel(int fd, struct aiocb *aiocbp); }
  455: 317     STD     BSD     { int aio_error(struct aiocb *aiocbp); }
  456: 318     STD     BSD     { int aio_read(struct aiocb *aiocbp); }
  457: 319     STD     BSD     { int aio_write(struct aiocb *aiocbp); }
  458: 320     STD     BSD     { int lio_listio(int mode, struct aiocb * const *acb_list, int nent, struct sigevent *sig); }
  459: 321     STD     BSD     { int yield(void); }
  460: 322     STD     BSD     { int thr_sleep(const struct timespec *timeout); }
  461: 323     STD     BSD     { int thr_wakeup(pid_t pid); }
  462: 324     STD     BSD     { int mlockall(int how); }
  463: 325     STD     BSD     { int munlockall(void); }
  464: 326     STD     BSD     { int __getcwd(u_char *buf, u_int buflen); }
  465: 
  466: 327     STD     POSIX   { int sched_setparam (pid_t pid, const struct sched_param *param); }
  467: 328     STD     POSIX   { int sched_getparam (pid_t pid, struct sched_param *param); }
  468: 
  469: 329     STD     POSIX   { int sched_setscheduler (pid_t pid, int policy, const struct sched_param *param); }
  470: 330     STD     POSIX   { int sched_getscheduler (pid_t pid); }
  471: 
  472: 331     STD     POSIX   { int sched_yield (void); }
  473: 332     STD     POSIX   { int sched_get_priority_max (int policy); }
  474: 333     STD     POSIX   { int sched_get_priority_min (int policy); }
  475: 334     STD     POSIX   { int sched_rr_get_interval (pid_t pid, struct timespec *interval); }
  476: 335	STD	BSD	{ int utrace(const void *addr, size_t len); }
  477: 336	OBSOL	NOHIDE	freebsd4_sendfile
  478: 337	STD	BSD	{ int kldsym(int fileid, int cmd, void *data); }
  479: 338	STD	BSD	{ int jail(struct jail *jail); }
  480: 339	UNIMPL	BSD	pioctl
  481: 340	MPSAFE	STD	POSIX	{ int sigprocmask(int how, const sigset_t *set, \
  482: 			    sigset_t *oset); }
  483: 341	STD	POSIX	{ int sigsuspend(const sigset_t *sigmask); }
  484: 342	STD	POSIX	{ int sigaction(int sig, const struct sigaction *act, \
  485: 			    struct sigaction *oact); }
  486: 343	STD	POSIX	{ int sigpending(sigset_t *set); }
  487: 344	STD	BSD	{ int sigreturn(ucontext_t *sigcntxp); }
  488: 345	UNIMPL	NOHIDE	sigtimedwait
  489: 346	UNIMPL	NOHIDE	sigwaitinfo
  490: 347	STD	BSD	{ int __acl_get_file(const char *path, \
  491: 			    acl_type_t type, struct acl *aclp); }
  492: 348	STD	BSD	{ int __acl_set_file(const char *path, \
  493: 			    acl_type_t type, struct acl *aclp); }
  494: 349	STD	BSD	{ int __acl_get_fd(int filedes, acl_type_t type, \
  495: 			    struct acl *aclp); }
  496: 350	STD	BSD	{ int __acl_set_fd(int filedes, acl_type_t type, \
  497: 			    struct acl *aclp); }
  498: 351	STD	BSD	{ int __acl_delete_file(const char *path, \
  499: 			    acl_type_t type); }
  500: 352	STD	BSD	{ int __acl_delete_fd(int filedes, acl_type_t type); }
  501: 353	STD	BSD	{ int __acl_aclcheck_file(const char *path, \
  502: 			    acl_type_t type, struct acl *aclp); }
  503: 354	STD	BSD	{ int __acl_aclcheck_fd(int filedes, acl_type_t type, \
  504: 			    struct acl *aclp); }
  505: 355	STD	BSD	{ int extattrctl(const char *path, int cmd, \
  506: 			    const char *attrname, char *arg); }
  507: 356	STD	BSD	{ int extattr_set_file(const char *path, \
  508: 			    const char *attrname, struct iovec *iovp, \
  509: 			    unsigned iovcnt); }
  510: 357	STD	BSD	{ int extattr_get_file(const char *path, \
  511: 			    const char *attrname, struct iovec *iovp, \
  512: 			    unsigned iovcnt); }
  513: 358	STD	BSD	{ int extattr_delete_file(const char *path, \
  514: 			    const char *attrname); }
  515: 359	STD	BSD	{ int aio_waitcomplete(struct aiocb **aiocbp, struct timespec *timeout); }
  516: 360	STD	BSD	{ int getresuid(uid_t *ruid, uid_t *euid, uid_t *suid); }
  517: 361	STD	BSD	{ int getresgid(gid_t *rgid, gid_t *egid, gid_t *sgid); }
  518: 362	STD	BSD	{ int kqueue(void); }
  519: 363	STD	BSD	{ int kevent(int fd, \
  520: 			    const struct kevent *changelist, int nchanges, \
  521: 			    struct kevent *eventlist, int nevents, \
  522: 			    const struct timespec *timeout); }
  523: 
  524: ; 364-392 used by FreeBSD-current
  525: 364	UNIMPL	NOHIDE	nosys
  526: 365	UNIMPL	NOHIDE	nosys
  527: 366	UNIMPL	NOHIDE	nosys
  528: 367	UNIMPL	NOHIDE	nosys
  529: 368	UNIMPL	NOHIDE	nosys
  530: 369	UNIMPL	NOHIDE	nosys
  531: 370	UNIMPL	NOHIDE	nosys
  532: 371	UNIMPL	NOHIDE	nosys
  533: 372	UNIMPL	NOHIDE	nosys
  534: 373	UNIMPL	NOHIDE	nosys
  535: 374	UNIMPL	NOHIDE	nosys
  536: 375	UNIMPL	NOHIDE	nosys
  537: 376	UNIMPL	NOHIDE	nosys
  538: 377	UNIMPL	NOHIDE	nosys
  539: 378	UNIMPL	NOHIDE	nosys
  540: 379	UNIMPL	NOHIDE	nosys
  541: 380	UNIMPL	NOHIDE	nosys
  542: 381	UNIMPL	NOHIDE	nosys
  543: 382	UNIMPL	NOHIDE	nosys
  544: 383	UNIMPL	NOHIDE	nosys
  545: 384	UNIMPL	NOHIDE	nosys
  546: 385	UNIMPL	NOHIDE	nosys
  547: 386	UNIMPL	NOHIDE	nosys
  548: 387	UNIMPL	NOHIDE	nosys
  549: 388	UNIMPL	NOHIDE	nosys
  550: 389	UNIMPL	NOHIDE	nosys
  551: 390	UNIMPL	NOHIDE	nosys
  552: 391	UNIMPL	NOHIDE	nosys
  553: 392	UNIMPL	NOHIDE	nosys
  554: 393	STD	BSD	{ int sendfile(int fd, int s, off_t offset, size_t nbytes, \
  555: 				struct sf_hdtr *hdtr, off_t *sbytes, int flags); }
  556: ; 394-439 used by FreeBSD-current
  557: 394	UNIMPL	NOHIDE	nosys
  558: 395	UNIMPL	NOHIDE	nosys
  559: 396	UNIMPL	NOHIDE	nosys
  560: 397	UNIMPL	NOHIDE	nosys
  561: 398	UNIMPL	NOHIDE	nosys
  562: 399	UNIMPL	NOHIDE	nosys
  563: 400	UNIMPL	NOHIDE	nosys
  564: 401	UNIMPL	NOHIDE	nosys
  565: 402	UNIMPL	NOHIDE	nosys
  566: 403	UNIMPL	NOHIDE	nosys
  567: 404	UNIMPL	NOHIDE	nosys
  568: 405	UNIMPL	NOHIDE	nosys
  569: 406	UNIMPL	NOHIDE	nosys
  570: 407	UNIMPL	NOHIDE	nosys
  571: 408	UNIMPL	NOHIDE	nosys
  572: 409	UNIMPL	NOHIDE	nosys
  573: 410	UNIMPL	NOHIDE	nosys
  574: 411	UNIMPL	NOHIDE	nosys
  575: 412	UNIMPL	NOHIDE	nosys
  576: 413	UNIMPL	NOHIDE	nosys
  577: 414	UNIMPL	NOHIDE	nosys
  578: 415	UNIMPL	NOHIDE	nosys
  579: 416	UNIMPL	NOHIDE	nosys
  580: 417	UNIMPL	NOHIDE	nosys
  581: 418	UNIMPL	NOHIDE	nosys
  582: 419	UNIMPL	NOHIDE	nosys
  583: 420	UNIMPL	NOHIDE	nosys
  584: 421	UNIMPL	NOHIDE	nosys
  585: 422	UNIMPL	NOHIDE	nosys
  586: 423	UNIMPL	NOHIDE	nosys
  587: 424	UNIMPL	NOHIDE	nosys
  588: 425	UNIMPL	NOHIDE	nosys
  589: 426	UNIMPL	NOHIDE	nosys
  590: 427	UNIMPL	NOHIDE	nosys
  591: 428	UNIMPL	NOHIDE	nosys
  592: 429	UNIMPL	NOHIDE	nosys
  593: 430	UNIMPL	NOHIDE	nosys
  594: 431	UNIMPL	NOHIDE	nosys
  595: 432	UNIMPL	NOHIDE	nosys
  596: 433	UNIMPL	NOHIDE	nosys
  597: 434	UNIMPL	NOHIDE	nosys
  598: 435	UNIMPL	NOHIDE	nosys
  599: 436	UNIMPL	NOHIDE	nosys
  600: 437	UNIMPL	NOHIDE	nosys
  601: 438	UNIMPL	NOHIDE	nosys
  602: 439	UNIMPL	NOHIDE	nosys
  603: ; 440-449 reserved for FreeBSD-5.x growth
  604: 440	UNIMPL	NOHIDE	nosys
  605: 441	UNIMPL	NOHIDE	nosys
  606: 442	UNIMPL	NOHIDE	nosys
  607: 443	UNIMPL	NOHIDE	nosys
  608: 444	UNIMPL	NOHIDE	nosys
  609: 445	UNIMPL	NOHIDE	nosys
  610: 446	UNIMPL	NOHIDE	nosys
  611: 447	UNIMPL	NOHIDE	nosys
  612: 448	UNIMPL	NOHIDE	nosys
  613: 449	UNIMPL	NOHIDE	nosys
  614: ; 450 DragonFly system calls
  615: 450	STD	BSD	{ int varsym_set(int level, const char *name, const char *data); }
  616: 451	STD	BSD	{ int varsym_get(int mask, const char *wild, char *buf, int bufsize); }
  617: 452	STD	BSD	{ int varsym_list(int level, char *buf, int maxsize, int *marker); }
  618: 453	STD	BSD	{ int upc_register(struct upcall *upc, void *ctxfunc, void *func, void *data); }
  619: 454	STD	BSD	{ int upc_control(int cmd, int upcid, void *data); }
  620: 455	STD	BSD	{ int caps_sys_service(const char *name, uid_t uid, gid_t gid, int upcid, int flags); }
  621: 456	STD	BSD	{ int caps_sys_client(const char *name, uid_t uid, gid_t gid, int upcid, int flags); }
  622: 457	STD	BSD	{ int caps_sys_close(int portid); }
  623: 458	STD	BSD	{ off_t caps_sys_put(int portid, void *msg, int msgsize); }
  624: 459	STD	BSD	{ int caps_sys_reply(int portid, void *msg, int msgsize, off_t msgcid); }
  625: 460	STD	BSD	{ int caps_sys_get(int portid, void *msg, int maxsize, struct caps_msgid *msgid, struct caps_cred *ccr); }
  626: 461	STD	BSD	{ int caps_sys_wait(int portid, void *msg, int maxsize, struct caps_msgid *msgid, struct caps_cred *ccr); }
  627: 462	STD	BSD	{ int caps_sys_abort(int portid, off_t msgcid, int flags); }
  628: 463	UNIMPL	NOHIDE	nosys
  629: 464	UNIMPL	NOHIDE	nosys
  630: 465	STD	BSD	{ int exec_sys_register(void *entry); }
  631: 466	STD	BSD	{ int exec_sys_unregister(int id); }