xref: /csrg-svn/sys/kern/syscalls.master (revision 68658)

	@(#)syscalls.master	8.6 (Berkeley) 03/30/95
; System call name/number "master" file.
; (See syscalls.conf to see what it is processed into.)
;
; Fields: number type [type-dependent ...]
;	number	system call number, must be in order
;	type	one of STD, OBSOL, UNIMPL, NODEF, NOARGS, or one of
;		the compatibility options defined in syscalls.conf.
;
; types:
;	STD	always included
;	OBSOL	obsolete, not included in system
;	UNIMPL	unimplemented, not included in system
;	NODEF	included, but don't define the syscall number
;	NOARGS	included, but don't define the syscall args structure
;
; The compat options are defined in the syscalls.conf file, and the
; compat option name is prefixed to the syscall name.  Other than
; that, they're like NODEF (for 'compat' options), or STD (for
; 'libcompat' options).
;
; The type-dependent arguments are as follows:
; For STD, NODEF, NOARGS, and compat syscalls:
;	{ pseudo-proto } [alias]
; For other syscalls:
;	[comment]
;
; #ifdef's, etc. may be included, and are copied to the output files.
; #include's are copied to the syscall switch definition file only.

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

; 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
152	UNIMPL
153	UNIMPL
154	UNIMPL
#ifdef NFS
155	STD		{ int nfssvc(int flag, caddr_t argp); }
#else
155	UNIMPL		nfssvc
#endif
156	COMPAT_43	{ int getdirentries(int fd, char *buf, u_int count, \
			    long *basep); }
157	STD		{ int statfs(char *path, struct statfs *buf); }
158	STD		{ int fstatfs(int fd, struct statfs *buf); }
159	UNIMPL
160	UNIMPL
#ifdef NFS
161	STD		{ int getfh(char *fname, fhandle_t *fhp); }
#else
161	UNIMPL		getfh
#endif
162	UNIMPL		getdomainname
163	UNIMPL		setdomainname
164	UNIMPL
165	UNIMPL
166	UNIMPL
167	UNIMPL
168	UNIMPL
169	UNIMPL		semsys
170	UNIMPL		msgsys
; XXX more generally, never on machines where sizeof(void *) != sizeof(int)
#if defined(SYSVSHM) && !defined(alpha)
171	COMPAT_43	{ int shmsys(int which, int a2, int a3, int a4); }
#else
171	UNIMPL		shmsys
#endif
172	UNIMPL
173	UNIMPL
174	UNIMPL
175	UNIMPL
176	UNIMPL
177	UNIMPL
178	UNIMPL
179	UNIMPL
180	UNIMPL

; Syscalls 180-209 are used by/reserved for BSD
181	STD		{ int setgid(gid_t gid); }
182	STD		{ int setegid(gid_t egid); }
183	STD		{ int seteuid(uid_t euid); }
#ifdef LFS
184	STD		{ int lfs_bmapv(fsid_t *fsidp, \
			    struct block_info *blkiov, int blkcnt); }
185	STD		{ int lfs_markv(fsid_t *fsidp, \
			    struct block_info *blkiov, int blkcnt); }
186	STD		{ int lfs_segclean(fsid_t *fsidp, u_long segment); }
187	STD		{ int lfs_segwait(fsid_t *fsidp, struct timeval *tv); }
#else
184	UNIMPL		lfs_bmapv
185	UNIMPL		lfs_markv
186	UNIMPL		lfs_segclean
187	UNIMPL		lfs_segwait
#endif
188	STD		{ int stat(char *path, struct stat *ub); }
189	STD		{ int fstat(int fd, struct stat *sb); }
190	STD		{ int lstat(char *path, struct stat *ub); }
191	STD		{ int pathconf(char *path, int name); }
192	STD		{ int fpathconf(int fd, int name); }
193	UNIMPL
194	STD		{ int getrlimit(u_int which, struct rlimit *rlp); }
195	STD		{ int setrlimit(u_int which, struct rlimit *rlp); }
196	STD		{ int getdirentries(int fd, char *buf, u_int count, \
			    long *basep); }
197	STD		{ caddr_t mmap(caddr_t addr, size_t len, int prot, \
			    int flags, int fd, long pad, off_t pos); }
198	STD		{ int nosys(void); } __syscall
199	STD		{ off_t lseek(int fd, int pad, off_t offset, \
			    int whence); }
200	STD		{ int truncate(char *path, int pad, off_t length); }
201	STD		{ int ftruncate(int fd, int pad, off_t length); }
202	STD		{ int __sysctl(int *name, u_int namelen, void *old, \
			    size_t *oldlenp, void *new, size_t newlen); }
203	STD		{ int mlock(caddr_t addr, size_t len); }
204	STD		{ int munlock(caddr_t addr, size_t len); }
205	STD		{ int undelete(char *path); }
206	UNIMPL
207	UNIMPL
208	UNIMPL
209	UNIMPL
; Syscalls 210-219 are used by/reserved for vendor-specific system calls
210	UNIMPL
211	UNIMPL
212	UNIMPL
213	UNIMPL
214	UNIMPL
215	UNIMPL
216	UNIMPL
217	UNIMPL
218	UNIMPL
219	UNIMPL
; System calls 220-240 are reserved for use by BSD
220	UNIMPL		semctl
221	UNIMPL		semget
222	UNIMPL		semop
223	UNIMPL		semconfig
224	UNIMPL		msgctl
225	UNIMPL		msgget
226	UNIMPL		msgsnd
227	UNIMPL		msgrcv
#if defined(SYSVSHM) && 0
228	STD		{ int shmat(int shmid, void *shmaddr, int shmflg); }
229	STD		{ int shmctl(int shmid, int cmd, \
			    struct shmid_ds *buf); }
230	STD		{ int shmdt(void *shmaddr); }
231	STD		{ int shmget(key_t key, int size, int shmflg); }
#else
228	UNIMPL		shmat
229	UNIMPL		shmctl
230	UNIMPL		shmdt
231	UNIMPL		shmget
#endif