freebsd-skq/sys/kern/syscalls.master

	$FreeBSD$
;	from: @(#)syscalls.master	8.2 (Berkeley) 1/13/94
;
; System call name/number master file.
; Processed to created init_sysent.c, syscalls.c and syscall.h.

; Columns: number type nargs namespc name alt{name,tag,rtyp}/comments
;	number	system call number, must be in order
;	type	one of STD, OBSOL, UNIMPL, COMPAT
;	namespc one of POSIX, BSD, NOHIDE
;	name	psuedo-prototype of syscall routine
;		If one of the following alts is different, then all appear:
;	altname	name of system call if different
;	alttag	name of args struct tag if different from [o]`name'"_args"
;	altrtyp	return type if not int (bogus - syscalls always return int)
;		for UNIMPL/OBSOL, name continues with comments

; types:
;	STD	always included
;	COMPAT	included on COMPAT #ifdef
;	LIBCOMPAT included on COMPAT #ifdef, and placed in syscall.h
;	OBSOL	obsolete, not included in system, only specifies name
;	UNIMPL	not implemented, placeholder only

; #ifdef's, etc. may be included, and are copied to the output files.

#include <sys/param.h>
#include <sys/sysent.h>
#include <sys/sysproto.h>

; Reserved/unimplemented system calls in the range 0-150 inclusive
; are reserved for use in future Berkeley releases.
; Additional system calls implemented in vendor and other
; redistributions should be placed in the reserved range at the end
; of the current calls.

0	STD	NOHIDE	{ int nosys(void); } syscall nosys_args int
1	STD	NOHIDE	{ void exit(int rval); } exit rexit_args void
2	STD	POSIX	{ int fork(void); }
3	STD	POSIX	{ int read(int fd, char *buf, u_int nbyte); }
4	STD	POSIX	{ int write(int fd, char *buf, u_int nbyte); }
5	STD	POSIX	{ int open(char *path, int flags, int mode); }
; XXX should be		{ int open(const char *path, int flags, ...); }
; but we're not ready for `const' or varargs.
; XXX man page says `mode_t mode'.
6	STD	POSIX	{ int close(int fd); }
7	STD	BSD	{ int wait4(int pid, int *status, int options, \
			    struct rusage *rusage); } wait4 wait_args int
8	COMPAT	BSD	{ int creat(char *path, int mode); }
9	STD	POSIX	{ int link(char *path, char *link); }
10	STD	POSIX	{ int unlink(char *path); }
11	OBSOL	NOHIDE	execv
12	STD	POSIX	{ int chdir(char *path); }
13	STD	BSD	{ int fchdir(int fd); }
14	STD	POSIX	{ int mknod(char *path, int mode, int dev); }
15	STD	POSIX	{ int chmod(char *path, int mode); }
16	STD	POSIX	{ int chown(char *path, int uid, int gid); }
17	STD	BSD	{ int obreak(char *nsize); } break obreak_args int
18	STD	BSD	{ int getfsstat(struct statfs *buf, long bufsize, \
			    int flags); }
19	COMPAT	POSIX	{ long lseek(int fd, long offset, int whence); }
20	STD	POSIX	{ pid_t getpid(void); }
21	STD	BSD	{ int mount(char *type, char *path, int flags, \
			    caddr_t data); }
; XXX 4.4lite2 uses `char *type' but we're not ready for that.
; XXX `path' should have type `const char *' but we're not ready for that.
22	STD	BSD	{ int unmount(char *path, int flags); }
23	STD	POSIX	{ int setuid(uid_t uid); }
24	STD	POSIX	{ uid_t getuid(void); }
25	STD	POSIX	{ uid_t geteuid(void); }
26	STD	BSD	{ int ptrace(int req, pid_t pid, caddr_t addr, \
			    int data); }
27	STD	BSD	{ int recvmsg(int s, struct msghdr *msg, int flags); }
28	STD	BSD	{ int sendmsg(int s, caddr_t msg, int flags); }
29	STD	BSD	{ int recvfrom(int s, caddr_t buf, size_t len, \
			    int flags, caddr_t from, int *fromlenaddr); }
30	STD	BSD	{ int accept(int s, caddr_t name, int *anamelen); }
31	STD	BSD	{ int getpeername(int fdes, caddr_t asa, int *alen); }
32	STD	BSD	{ int getsockname(int fdes, caddr_t asa, int *alen); }
33	STD	POSIX	{ int access(char *path, int flags); }
34	STD	BSD	{ int chflags(char *path, int flags); }
35	STD	BSD	{ int fchflags(int fd, int flags); }
36	STD	BSD	{ int sync(void); }
37	STD	POSIX	{ int kill(int pid, int signum); }
38	COMPAT	POSIX	{ int stat(char *path, struct ostat *ub); }
39	STD	POSIX	{ pid_t getppid(void); }
40	COMPAT	POSIX	{ int lstat(char *path, struct ostat *ub); }
41	STD	POSIX	{ int dup(u_int fd); }
42	STD	POSIX	{ int pipe(void); }
43	STD	POSIX	{ gid_t getegid(void); }
44	STD	BSD	{ int profil(caddr_t samples, u_int size, \
			    u_int offset, u_int scale); }
45	STD	BSD	{ int ktrace(char *fname, int ops, int facs, \
			    int pid); }
46	STD	POSIX	{ int sigaction(int signum, struct sigaction *nsa, \
			    struct sigaction *osa); }
47	STD	POSIX	{ gid_t getgid(void); }
48	STD	POSIX	{ int sigprocmask(int how, sigset_t mask); }
; XXX note nonstandard (bogus) calling convention - the libc stub passes
; us the mask, not a pointer to it, and we return the old mask as the
; (int) return value.
49	STD	BSD	{ int getlogin(char *namebuf, u_int namelen); }
50	STD	BSD	{ int setlogin(char *namebuf); }
51	STD	BSD	{ int acct(char *path); }
52	STD	POSIX	{ int sigpending(void); }
53	STD	BSD	{ int sigaltstack(struct sigaltstack *nss, \
			    struct sigaltstack *oss); }
54	STD	POSIX	{ int ioctl(int fd, u_long com, caddr_t data); }
55	STD	BSD	{ int reboot(int opt); }
56	STD	POSIX	{ int revoke(char *path); }
57	STD	POSIX	{ int symlink(char *path, char *link); }
58	STD	POSIX	{ int readlink(char *path, char *buf, int count); }
59	STD	POSIX	{ int execve(char *fname, char **argv, char **envv); }
60	STD	POSIX	{ int umask(int newmask); } umask umask_args int
61	STD	BSD	{ int chroot(char *path); }
62	COMPAT	POSIX	{ int fstat(int fd, struct ostat *sb); }
63	COMPAT	BSD	{ int getkerninfo(int op, char *where, int *size, \
			    int arg); } getkerninfo getkerninfo_args int
64	COMPAT	BSD	{ int getpagesize(void); } \
			    getpagesize getpagesize_args int
65	STD	BSD	{ int msync(caddr_t addr, size_t len, int flags); }
66	STD	BSD	{ int vfork(void); }
67	OBSOL	NOHIDE	vread
68	OBSOL	NOHIDE	vwrite
69	STD	BSD	{ int sbrk(int incr); }
70	STD	BSD	{ int sstk(int incr); }
71	COMPAT	BSD	{ int mmap(caddr_t addr, int len, int prot, \
			    int flags, int fd, long pos); }
72	STD	BSD	{ int ovadvise(int anom); } vadvise ovadvise_args int
73	STD	BSD	{ int munmap(caddr_t addr, size_t len); }
74	STD	BSD	{ int mprotect(caddr_t addr, size_t len, int prot); }
75	STD	BSD	{ int madvise(caddr_t addr, size_t len, int behav); }
76	OBSOL	NOHIDE	vhangup
77	OBSOL	NOHIDE	vlimit
78	STD	BSD	{ int mincore(caddr_t addr, size_t len, char *vec); }
79	STD	POSIX	{ int getgroups(u_int gidsetsize, gid_t *gidset); }
80	STD	POSIX	{ int setgroups(u_int gidsetsize, gid_t *gidset); }
81	STD	POSIX	{ int getpgrp(void); }
82	STD	POSIX	{ int setpgid(int pid, int pgid); }
83	STD	BSD	{ int setitimer(u_int which, struct itimerval *itv, \
			    struct itimerval *oitv); }
84	COMPAT	BSD	{ int wait(void); }
85	STD	BSD	{ int swapon(char *name); }
86	STD	BSD	{ int getitimer(u_int which, struct itimerval *itv); }
87	COMPAT	BSD	{ int gethostname(char *hostname, u_int len); } \
			    gethostname gethostname_args int
88	COMPAT	BSD	{ int sethostname(char *hostname, u_int len); } \
			    sethostname sethostname_args int
89	STD	BSD	{ int getdtablesize(void); }
90	STD	POSIX	{ int dup2(u_int from, u_int to); }
91	UNIMPL	BSD	getdopt
92	STD	POSIX	{ int fcntl(int fd, int cmd, int arg); }
; XXX should be		{ int fcntl(int fd, int cmd, ...); }
; but we're not ready for varargs.
; XXX man page says `int arg' too.
93	STD	BSD	{ int select(int nd, fd_set *in, fd_set *ou, \
			    fd_set *ex, struct timeval *tv); }
94	UNIMPL	BSD	setdopt
95	STD	POSIX	{ int fsync(int fd); }
96	STD	BSD	{ int setpriority(int which, int who, int prio); }
97	STD	BSD	{ int socket(int domain, int type, int protocol); }
98	STD	BSD	{ int connect(int s, caddr_t name, int namelen); }
99	CPT_NOA	BSD	{ int accept(int s, caddr_t name, int *anamelen); } \
			    accept accept_args int
100	STD	BSD	{ int getpriority(int which, int who); }
101	COMPAT	BSD	{ int send(int s, caddr_t buf, int len, int flags); }
102	COMPAT	BSD	{ int recv(int s, caddr_t buf, int len, int flags); }
103	STD	BSD	{ int sigreturn(struct sigcontext *sigcntxp); }
104	STD	BSD	{ int bind(int s, caddr_t name, int namelen); }
105	STD	BSD	{ int setsockopt(int s, int level, int name, \
			    caddr_t val, int valsize); }
106	STD	BSD	{ int listen(int s, int backlog); }
107	OBSOL	NOHIDE	vtimes
108	COMPAT	BSD	{ int sigvec(int signum, struct sigvec *nsv, \
			    struct sigvec *osv); }
109	COMPAT	BSD	{ int sigblock(int mask); }
110	COMPAT	BSD	{ int sigsetmask(int mask); }
111	STD	POSIX	{ int sigsuspend(sigset_t mask); }
; XXX note nonstandard (bogus) calling convention - the libc stub passes
; us the mask, not a pointer to it.
112	COMPAT	BSD	{ int sigstack(struct sigstack *nss, \
			    struct sigstack *oss); }
113	COMPAT	BSD	{ int recvmsg(int s, struct omsghdr *msg, int flags); }
114	COMPAT	BSD	{ int sendmsg(int s, caddr_t msg, int flags); }
115	OBSOL	NOHIDE	vtrace
116	STD	BSD	{ int gettimeofday(struct timeval *tp, \
			    struct timezone *tzp); }
117	STD	BSD	{ int getrusage(int who, struct rusage *rusage); }
118	STD	BSD	{ int getsockopt(int s, int level, int name, \
			    caddr_t val, int *avalsize); }
119	UNIMPL	NOHIDE	resuba (BSD/OS 2.x)
120	STD	BSD	{ int readv(int fd, struct iovec *iovp, u_int iovcnt); }
121	STD	BSD	{ int writev(int fd, struct iovec *iovp, \
			    u_int iovcnt); }
122	STD	BSD	{ int settimeofday(struct timeval *tv, \
			    struct timezone *tzp); }
123	STD	BSD	{ int fchown(int fd, int uid, int gid); }
124	STD	BSD	{ int fchmod(int fd, int mode); }
125	CPT_NOA	BSD	{ int recvfrom(int s, caddr_t buf, size_t len, \
			    int flags, caddr_t from, int *fromlenaddr); } \
			    recvfrom recvfrom_args int
126	STD	BSD	{ int setreuid(int ruid, int euid); }
127	STD	BSD	{ int setregid(int rgid, int egid); }
128	STD	POSIX	{ int rename(char *from, char *to); }
129	COMPAT	BSD	{ int truncate(char *path, long length); }
130	COMPAT	BSD	{ int ftruncate(int fd, long length); }
131	STD	BSD	{ int flock(int fd, int how); }
132	STD	POSIX	{ int mkfifo(char *path, int mode); }
133	STD	BSD	{ int sendto(int s, caddr_t buf, size_t len, \
			    int flags, caddr_t to, int tolen); }
134	STD	BSD	{ int shutdown(int s, int how); }
135	STD	BSD	{ int socketpair(int domain, int type, int protocol, \
			    int *rsv); }
136	STD	POSIX	{ int mkdir(char *path, int mode); }
137	STD	POSIX	{ int rmdir(char *path); }
138	STD	BSD	{ int utimes(char *path, struct timeval *tptr); }
139	OBSOL	NOHIDE	4.2 sigreturn
140	STD	BSD	{ int adjtime(struct timeval *delta, \
			    struct timeval *olddelta); }
141	COMPAT	BSD	{ int getpeername(int fdes, caddr_t asa, int *alen); }
142	COMPAT	BSD	{ long gethostid(void); }
143	COMPAT	BSD	{ int sethostid(long hostid); }
144	COMPAT	BSD	{ int getrlimit(u_int which, struct ogetrlimit *rlp); }
145	COMPAT	BSD	{ int setrlimit(u_int which, struct ogetrlimit *rlp); }
146	COMPAT	BSD	{ int killpg(int pgid, int signum); }
147	STD	POSIX	{ int setsid(void); }
148	STD	BSD	{ int quotactl(char *path, int cmd, int uid, \
			    caddr_t arg); }
149	COMPAT	BSD	{ int quota(void); }
150	CPT_NOA	BSD	{ int getsockname(int fdec, caddr_t asa, int *alen); }\
			    getsockname getsockname_args int

; Syscalls 151-180 inclusive are reserved for vendor-specific
; system calls.  (This includes various calls added for compatibity
; with other Unix variants.)
; Some of these calls are now supported by BSD...
151	UNIMPL	NOHIDE	sem_lock (BSD/OS 2.x)
152	UNIMPL	NOHIDE	sem_wakeup (BSD/OS 2.x)
153	UNIMPL	NOHIDE	asyncdaemon (BSD/OS 2.x)
154	UNIMPL	NOHIDE	nosys
#ifdef NFS
155	STD	BSD	{ int nfssvc(int flag, caddr_t argp); }
#else
155	UNIMPL	BSD	nosys
#endif
156	COMPAT	BSD	{ int getdirentries(int fd, char *buf, u_int count, \
			    long *basep); }
157	STD	BSD	{ int statfs(char *path, struct statfs *buf); }
158	STD	BSD	{ int fstatfs(int fd, struct statfs *buf); }
159	UNIMPL	NOHIDE	nosys
160	UNIMPL	NOHIDE	nosys
#if defined(NFS) && !defined (NFS_NOSERVER)
161	STD	BSD	{ int getfh(char *fname, struct fhandle *fhp); }
#else
161	UNIMPL	BSD	nosys
#endif
162	STD	BSD	{ int getdomainname(char *domainname, int len); }
163	STD	BSD	{ int setdomainname(char *domainname, int len); }
164	STD	BSD	{ int uname(struct utsname *name); }
165	STD	BSD	{ int sysarch(int op, char *parms); }
166	STD	BSD	{ int rtprio(int function, pid_t pid, \
			    struct rtprio *rtp); }
167	UNIMPL	NOHIDE	nosys
168	UNIMPL	NOHIDE	nosys
169	STD	BSD	{ int semsys(int which, int a2, int a3, int a4, \
			    int a5); }
; XXX should be		{ int semsys(int which, ...); }
170	STD	BSD	{ int msgsys(int which, int a2, int a3, int a4, \
			    int a5, int a6); }
; XXX should be		{ int msgsys(int which, ...); }
171	STD	BSD	{ int shmsys(int which, int a2, int a3, int a4); }
; XXX should be		{ int shmsys(int which, ...); }
172	UNIMPL	NOHIDE	nosys
173	UNIMPL	NOHIDE	nosys
174	UNIMPL	NOHIDE	nosys
175	UNIMPL	NOHIDE	nosys
176	STD	BSD	{ int ntp_adjtime(struct timex *tp); }
177	UNIMPL	NOHIDE	sfork (BSD/OS 2.x)
178	UNIMPL	NOHIDE	getdescriptor (BSD/OS 2.x)
179	UNIMPL	NOHIDE	setdescriptor (BSD/OS 2.x)
180	UNIMPL	NOHIDE	nosys

; Syscalls 180-199 are used by/reserved for BSD
181	STD	POSIX	{ int setgid(gid_t gid); }
182	STD	BSD	{ int setegid(gid_t egid); }
183	STD	BSD	{ int seteuid(uid_t euid); }
#ifdef LFS
184	STD	BSD	{ int lfs_bmapv(struct fsid **fsidp, \
			    struct block_info *blkiov, int blkcnt); }
185	STD	BSD	{ int lfs_markv(struct fsid **fsidp, \
			    struct block_info *blkiov, int blkcnt); }
186	STD	BSD	{ int lfs_segclean(struct fsid **fsidp, \
			    u_long segment); }
187	STD	BSD	{ int lfs_segwait(struct fsid **fsidp, \
			    struct timeval *tv); }
#else
184	UNIMPL	BSD	nosys
185	UNIMPL	BSD	nosys
186	UNIMPL	BSD	nosys
187	UNIMPL	BSD	nosys
#endif
188	STD	POSIX	{ int stat(char *path, struct stat *ub); }
189	STD	POSIX	{ int fstat(int fd, struct stat *sb); }
190	STD	POSIX	{ int lstat(char *path, struct stat *ub); }
191	STD	POSIX	{ int pathconf(char *path, int name); }
192	STD	POSIX	{ int fpathconf(int fd, int name); }
193	UNIMPL	NOHIDE	nosys
194	STD	BSD	{ int getrlimit(u_int which, \
			    struct orlimit *rlp); } \
			    getrlimit __getrlimit_args int
195	STD	BSD	{ int setrlimit(u_int which, \
			    struct orlimit *rlp); } \
			    setrlimit __setrlimit_args int
196	STD	BSD	{ int getdirentries(int fd, char *buf, u_int count, \
			    long *basep); }
197	STD	BSD	{ caddr_t mmap(caddr_t addr, size_t len, int prot, \
			    int flags, int fd, long pad, off_t pos); }
198	STD	NOHIDE	{ int nosys(void); } __syscall __syscall_args int
199	STD	POSIX	{ off_t lseek(int fd, int pad, off_t offset, \
			    int whence); }
200	STD	BSD	{ int truncate(char *path, int pad, off_t length); }
201	STD	BSD	{ int ftruncate(int fd, int pad, off_t length); }
202	STD	BSD	{ int __sysctl(int *name, u_int namelen, void *old, \
			    size_t *oldlenp, void *new, size_t newlen); } \
			    __sysctl sysctl_args int
; properly, __sysctl should be a NOHIDE, but making an exception
; here allows to avoid one in libc/sys/Makefile.inc.
203	STD	BSD	{ int mlock(caddr_t addr, size_t len); }
204	STD	BSD	{ int munlock(caddr_t addr, size_t len); }
205	STD	BSD	{ int utrace(caddr_t addr, size_t len); }
206	STD	BSD	{ int undelete(char *path); }
207	UNIMPL	NOHIDE	nosys
208	UNIMPL	NOHIDE	nosys
209	UNIMPL	NOHIDE	nosys

;
; The following are reserved for loadable syscalls
;
210	NODEF	NOHIDE	lkmnosys lkmnosys nosys_args int
211	NODEF	NOHIDE	lkmnosys lkmnosys nosys_args int
212	NODEF	NOHIDE	lkmnosys lkmnosys nosys_args int
213	NODEF	NOHIDE	lkmnosys lkmnosys nosys_args int
214	NODEF	NOHIDE	lkmnosys lkmnosys nosys_args int
215	NODEF	NOHIDE	lkmnosys lkmnosys nosys_args int
216	NODEF	NOHIDE	lkmnosys lkmnosys nosys_args int
217	NODEF	NOHIDE	lkmnosys lkmnosys nosys_args int
218	NODEF	NOHIDE	lkmnosys lkmnosys nosys_args int
219	NODEF	NOHIDE	lkmnosys lkmnosys nosys_args int

;
; The following were introduced with NetBSD/4.4Lite-2
;
220	STD	BSD	{ int __semctl(int semid, int semnum, int cmd, \
			    union semun *arg); }
221	STD	BSD	{ int semget(key_t key, int nsems, int semflg); }
222	STD	BSD	{ int semop(int semid, struct sembuf *sops, \
			    u_int nsops); }
223	STD	BSD	{ int semconfig(int flag); }
224	STD	BSD	{ int msgctl(int msqid, int cmd, \
			    struct msqid_ds *buf); }
225	STD	BSD	{ int msgget(key_t key, int msgflg); }
226	STD	BSD	{ int msgsnd(int msqid, void *msgp, size_t msgsz, \
			    int msgflg); }
227	STD	BSD	{ int msgrcv(int msqid, void *msgp, size_t msgsz, \
			    long msgtyp, int msgflg); }
228	STD	BSD	{ int shmat(int shmid, void *shmaddr, int shmflg); }
229	STD	BSD	{ int shmctl(int shmid, int cmd, \
			    struct shmid_ds *buf); }
230	STD	BSD	{ int shmdt(void *shmaddr); }
231	STD	BSD	{ int shmget(key_t key, int size, int shmflg); }
;
232	UNIMPL	NOHIDE	nosys
233	UNIMPL	NOHIDE	nosys
234	UNIMPL	NOHIDE	nosys
235	UNIMPL	NOHIDE	nosys
236	UNIMPL	NOHIDE	nosys
237	UNIMPL	NOHIDE	nosys
238	UNIMPL	NOHIDE	nosys
239	UNIMPL	NOHIDE	nosys
240	UNIMPL	NOHIDE	nosys
241	UNIMPL	NOHIDE	nosys
242	UNIMPL	NOHIDE	nosys
243	UNIMPL	NOHIDE	nosys
244	UNIMPL	NOHIDE	nosys
245	UNIMPL	NOHIDE	nosys
246	UNIMPL	NOHIDE	nosys
247	UNIMPL	NOHIDE	nosys
248	UNIMPL	NOHIDE	nosys
249	UNIMPL	NOHIDE	nosys
; syscall numbers initially used in OpenBSD
250	STD	BSD	{ int minherit(caddr_t addr, size_t len, int inherit); }
251	STD	BSD	{ int rfork(int flags); }