1 $FreeBSD: src/sys/compat/svr4/syscalls.master,v 1.15.2.1 2004/09/03 15:30:20 jhb Exp $
2 ; from: @(#)syscalls.master 8.1 (Berkeley) 7/19/93
3 ;
4 ; System call name/number master file (or rather, slave, from SVR4).
5 ; Processed to create svr4_sysent.c, svr4_syscalls.c and svr4_syscall.h.
6
7 ; Columns: number type nargs name alt{name,tag,rtyp}/comments
8 ; number system call number, must be in order
9 ; type one of STD, OBSOL, UNIMPL, COMPAT
10 ; name psuedo-prototype of syscall routine
11 ; If one of the following alts is different, then all appear:
12 ; altname name of system call if different
13 ; alttag name of args struct tag if different from [o]`name'"_args"
14 ; altrtyp return type if not int (bogus - syscalls always return int)
15 ; for UNIMPL/OBSOL, name continues with comments
16
17 ; types:
18 ; STD always included
19 ; COMPAT included on COMPAT #ifdef
20 ; LIBCOMPAT included on COMPAT #ifdef, and placed in syscall.h
21 ; OBSOL obsolete, not included in system, only specifies name
22 ; UNIMPL not implemented, placeholder only
23
24 ; #ifdef's, etc. may be included, and are copied to the output files.
25
26 #include <sys/types.h>
27 #include <sys/sysent.h>
28 #include <sys/sysproto.h>
29 #include <netinet/in.h>
30
31 #include <compat/svr4/svr4.h>
32 #include <compat/svr4/svr4_types.h>
33 #include <compat/svr4/svr4_signal.h>
34 #include <compat/svr4/svr4_proto.h>
35
36 0 UNIMPL unused
37 1 NOPROTO { void sys_exit(int rval); } exit sys_exit_args void
38 2 MNOPROTO { int fork(void); }
39 3 MNOPROTO { int read(int fd, char *buf, u_int nbyte); }
40 4 MNOPROTO { int write(int fd, char *buf, u_int nbyte); }
41 5 STD { int svr4_sys_open(char *path, int flags, int mode); }
42 6 MNOPROTO { int close(int fd); }
43 7 STD { int svr4_sys_wait(int *status); }
44 8 STD { int svr4_sys_creat(char *path, int mode); }
45 9 NOPROTO { int link(char *path, char *link); }
46 10 NOPROTO { int unlink(char *path); }
47 11 STD { int svr4_sys_execv(char *path, char **argp); }
48 12 NOPROTO { int chdir(char *path); }
49 13 STD { int svr4_sys_time(time_t *t); }
50 14 STD { int svr4_sys_mknod(char* path, int mode, int dev); }
51 15 NOPROTO { int chmod(char *path, int mode); }
52 16 NOPROTO { int chown(char *path, uid_t uid, gid_t gid); }
53 17 STD { int svr4_sys_break(caddr_t nsize); }
54 18 STD { int svr4_sys_stat(char* path, struct svr4_stat* ub); }
55 19 NOPROTO { int lseek(int filedes, off_t *offset, int whence); }
56 20 MNOPROTO { pid_t getpid(void); }
57 21 UNIMPL old_mount
58 22 UNIMPL sysv_umount
59 23 MNOPROTO { int setuid(uid_t uid); }
60 24 MNOPROTO { uid_t getuid(void); }
61 25 UNIMPL stime
62 26 UNIMPL ptrace
63 27 STD { int svr4_sys_alarm(unsigned sec); }
64 28 STD { int svr4_sys_fstat(int fd, struct svr4_stat *sb); }
65 29 MSTD { int svr4_sys_pause(void); }
66 30 STD { int svr4_sys_utime(char *path, struct svr4_utimbuf *ubuf); }
67 31 UNIMPL stty
68 32 UNIMPL gtty
69 33 STD { int svr4_sys_access(char *path, int flags); }
70 34 MSTD { int svr4_sys_nice(int prio); }
71 35 UNIMPL statfs
72 36 NOPROTO { int sync(void); }
73 37 MSTD { int svr4_sys_kill(int pid, int signum); }
74 38 UNIMPL fstatfs
75 39 MSTD { int svr4_sys_pgrpsys(int cmd, int pid, int pgid); }
76 40 UNIMPL xenix
77 41 MNOPROTO { int dup(u_int fd); }
78 42 MNOPROTO { int pipe(void); }
79 43 STD { int svr4_sys_times(struct tms *tp); }
80 44 UNIMPL profil
81 45 UNIMPL plock
82 46 MNOPROTO { int setgid(gid_t gid); }
83 47 MNOPROTO { gid_t getgid(void); }
84 48 MSTD { int svr4_sys_signal(int signum, svr4_sig_t handler); }
85 #if defined(NOTYET)
86 49 STD { int svr4_sys_msgsys(int what, int a2, int a3, int a4, \
87 int a5); }
88 #else
89 49 UNIMPL msgsys
90 #endif
91 50 STD { int svr4_sys_sysarch(int op, void *a1); }
92 51 UNIMPL acct
93 52 UNIMPL shmsys
94 53 UNIMPL semsys
95 54 STD { int svr4_sys_ioctl(int fd, u_long com, caddr_t data); }
96 55 UNIMPL uadmin
97 56 UNIMPL exch
98 57 STD { int svr4_sys_utssys(void *a1, void *a2, int sel, void *a3); }
99 58 NOPROTO { int fsync(int fd); }
100 59 STD { int svr4_sys_execve(char *path, char **argp, char **envp); }
101 60 MNOPROTO { int umask(int newmask); }
102 61 NOPROTO { int chroot(char *path); }
103 62 MSTD { int svr4_sys_fcntl(int fd, int cmd, char *arg); }
104 63 MSTD { int svr4_sys_ulimit(int cmd, long newlimit); }
105 64 UNIMPL reserved
106 65 UNIMPL reserved
107 66 UNIMPL reserved
108 67 UNIMPL reserved
109 68 UNIMPL reserved
110 69 UNIMPL reserved
111 70 UNIMPL advfs
112 71 UNIMPL unadvfs
113 72 UNIMPL rmount
114 73 UNIMPL rumount
115 74 UNIMPL rfstart
116 75 UNIMPL sigret
117 76 UNIMPL rdebug
118 77 UNIMPL rfstop
119 78 UNIMPL rfsys
120 79 NOPROTO { int rmdir(char *path); }
121 80 NOPROTO { int mkdir(char *path, int mode); }
122 81 STD { int svr4_sys_getdents(int fd, char *buf, int nbytes); }
123 82 UNIMPL libattach
124 83 UNIMPL libdetach
125 84 UNIMPL sysfs
126 85 STD { int svr4_sys_getmsg(int fd, struct svr4_strbuf *ctl, \
127 struct svr4_strbuf *dat, int *flags); }
128 86 STD { int svr4_sys_putmsg(int fd, struct svr4_strbuf *ctl, \
129 struct svr4_strbuf *dat, int flags); }
130 87 STD { int svr4_sys_poll(struct pollfd *fds, unsigned int nfds, \
131 int timeout); }
132 88 STD { int svr4_sys_lstat(char *path, struct svr4_stat *ub); }
133 89 NOPROTO { int symlink(char *path, char *link); }
134 90 NOPROTO { int readlink(char *path, char *buf, int count); }
135 91 MNOPROTO { int getgroups(u_int gidsetsize, gid_t *gidset); }
136 92 MNOPROTO { int setgroups(u_int gidsetsize, gid_t *gidset); }
137 93 NOPROTO { int fchmod(int fd, int mode); }
138 94 NOPROTO { int fchown(int fd, int uid, int gid); }
139 95 MSTD { int svr4_sys_sigprocmask(int how, svr4_sigset_t *set, \
140 svr4_sigset_t *oset); }
141 96 MSTD { int svr4_sys_sigsuspend(svr4_sigset_t *ss); }
142 97 MSTD { int svr4_sys_sigaltstack(struct svr4_sigaltstack *nss, \
143 struct svr4_sigaltstack *oss); }
144 98 MSTD { int svr4_sys_sigaction(int signum, \
145 struct svr4_sigaction *nsa, struct svr4_sigaction *osa); }
146 99 MSTD { int svr4_sys_sigpending(int what, svr4_sigset_t *mask); }
147 100 STD { int svr4_sys_context(int func, struct svr4_ucontext *uc); }
148 101 UNIMPL evsys
149 102 UNIMPL evtrapret
150 103 STD { int svr4_sys_statvfs(char *path, struct svr4_statvfs *fs); }
151 104 STD { int svr4_sys_fstatvfs(int fd, struct svr4_statvfs *fs); }
152 105 UNIMPL whoknows
153 106 UNIMPL nfssvc
154 107 STD { int svr4_sys_waitsys(int grp, int id, \
155 union svr4_siginfo *info, int options); }
156 108 UNIMPL sigsendsys
157 109 STD { int svr4_sys_hrtsys(int cmd, int fun, int sub, void *rv1, \
158 void *rv2); }
159 110 UNIMPL acancel
160 111 UNIMPL async
161 112 UNIMPL priocntlsys
162 113 STD { int svr4_sys_pathconf(char *path, int name); }
163 114 UNIMPL mincore
164 115 STD { caddr_t svr4_sys_mmap( caddr_t addr, svr4_size_t len, \
165 int prot, int flags, int fd, svr4_off_t pos); }
166 116 MNOPROTO { int mprotect(void *addr, int len, int prot); }
167 117 MNOPROTO { int munmap(void *addr, int len); }
168 118 STD { int svr4_sys_fpathconf(int fd, int name); }
169 119 MNOPROTO { int vfork(void); }
170 120 NOPROTO { int fchdir(int fd); }
171 121 NOPROTO { int readv(int fd, struct iovec *iovp, u_int iovcnt); }
172 122 NOPROTO { int writev(int fd, struct iovec *iovp, u_int iovcnt); }
173 123 STD { int svr4_sys_xstat(int two, char *path, \
174 struct svr4_xstat *ub); }
175 124 STD { int svr4_sys_lxstat(int two, char *path, \
176 struct svr4_xstat *ub); }
177 125 STD { int svr4_sys_fxstat(int two, int fd, struct svr4_xstat *sb); }
178 126 STD { int svr4_sys_xmknod(int two, char *path, svr4_mode_t mode, \
179 svr4_dev_t dev); }
180 127 UNIMPL clocal
181 128 MSTD { int svr4_sys_setrlimit(int which, \
182 const struct svr4_rlimit *rlp); }
183 129 MSTD { int svr4_sys_getrlimit(int which, \
184 struct svr4_rlimit *rlp); }
185 130 NOPROTO { int lchown(char *path, uid_t uid, gid_t gid); }
186 131 STD { int svr4_sys_memcntl(void * addr, svr4_size_t len, int cmd, \
187 void * arg, int attr, int mask); }
188 132 UNIMPL getpmsg
189 133 UNIMPL putpmsg
190 134 NOPROTO { int rename(char *from, char *to); }
191 135 STD { int svr4_sys_uname(struct svr4_utsname* name, int dummy); }
192 136 MNOPROTO { int setegid(gid_t egid); }
193 137 STD { int svr4_sys_sysconfig(int name); }
194 138 MNOPROTO { int adjtime(struct timeval *delta, \
195 struct timeval *olddelta); }
196 139 STD { long svr4_sys_systeminfo(int what, char *buf, long len); }
197 140 UNIMPL notused
198 141 MNOPROTO { int seteuid(uid_t euid); }
199 142 UNIMPL vtrace
200 ; fork1
201 143 MUNIMPL { int fork(void); }
202 144 UNIMPL sigtimedwait
203 145 UNIMPL lwp_info
204 146 UNIMPL yield
205 147 UNIMPL lwp_sema_wait
206 148 UNIMPL lwp_sema_post
207 149 UNIMPL lwp_sema_trywait
208 150 UNIMPL notused
209 151 UNIMPL notused
210 152 UNIMPL modctl
211 153 STD { int svr4_sys_fchroot(int fd); }
212 154 STD { int svr4_sys_utimes(char *path, struct timeval *tptr); }
213 155 STD { int svr4_sys_vhangup(void); }
214 156 STD { int svr4_sys_gettimeofday(struct timeval *tp); }
215 157 MNOPROTO { int getitimer(u_int which, struct itimerval *itv); }
216 158 MNOPROTO { int setitimer(u_int which, struct itimerval *itv, \
217 struct itimerval *oitv); }
218 159 UNIMPL lwp_create
219 160 UNIMPL lwp_exit
220 161 UNIMPL lwp_suspend
221 162 UNIMPL lwp_continue
222 163 UNIMPL lwp_kill
223 164 UNIMPL lwp_self
224 165 UNIMPL lwp_getprivate
225 166 UNIMPL lwp_setprivate
226 167 UNIMPL lwp_wait
227 168 UNIMPL lwp_mutex_unlock
228 169 UNIMPL lwp_mutex_lock
229 170 UNIMPL lwp_cond_wait
230 171 UNIMPL lwp_cond_signal
231 172 UNIMPL lwp_cond_broadcast
232 173 UNIMPL { ssize_t svr4_sys_pread(int fd, void *buf, size_t nbyte, \
233 svr4_off_t off); }
234 174 UNIMPL { ssize_t svr4_sys_pwrite(int fd, const void *buf, \
235 size_t nbyte, svr4_off_t off); }
236 175 STD { svr4_off64_t svr4_sys_llseek(int fd, long offset1, \
237 long offset2, int whence); }
238 176 UNIMPL inst_sync
239 177 UNIMPL whoknows
240 178 UNIMPL kaio
241 179 UNIMPL whoknows
242 180 UNIMPL whoknows
243 181 UNIMPL whoknows
244 182 UNIMPL whoknows
245 183 UNIMPL whoknows
246 184 UNIMPL tsolsys
247 185 STD { int svr4_sys_acl(char *path, int cmd, int num, \
248 struct svr4_aclent *buf); }
249 186 STD { int svr4_sys_auditsys(int code, int a1, int a2, int a3, \
250 int a4, int a5); }
251 187 UNIMPL processor_bind
252 188 UNIMPL processor_info
253 189 UNIMPL p_online
254 190 UNIMPL sigqueue
255 191 UNIMPL clock_gettime
256 192 UNIMPL clock_settime
257 193 UNIMPL clock_getres
258 194 UNIMPL timer_create
259 195 UNIMPL timer_delete
260 196 UNIMPL timer_settime
261 197 UNIMPL timer_gettime
262 198 UNIMPL timer_overrun
263 199 MNOPROTO { int nanosleep(const struct timespec *rqtp, \
264 struct timespec *rmtp); }
265 200 STD { int svr4_sys_facl(int fd, int cmd, int num, \
266 struct svr4_aclent *buf); }
267 201 UNIMPL door
268 202 MNOPROTO { int setreuid(int ruid, int euid); }
269 203 MNOPROTO { int setregid(int rgid, int egid); }
270 204 UNIMPL install_utrap
271 205 UNIMPL signotify
272 206 UNIMPL schedctl
273 207 UNIMPL pset
274 208 UNIMPL whoknows
275 209 STD { int svr4_sys_resolvepath(const char *path, char *buf, \
276 size_t bufsiz); }
277 210 UNIMPL signotifywait
278 211 UNIMPL lwp_sigredirect
279 212 UNIMPL lwp_alarm
280 213 STD { int svr4_sys_getdents64(int fd, struct svr4_dirent64 *dp, \
281 int nbytes); }
282 ;213 UNIMPL getdents64
283 214 STD { caddr_t svr4_sys_mmap64(void *addr, svr4_size_t len, \
284 int prot, int flags, int fd, svr4_off64_t pos); }
285 215 STD { int svr4_sys_stat64(char *path, struct svr4_stat64 *sb); }
286 216 STD { int svr4_sys_lstat64(char *path, struct svr4_stat64 *sb); }
287 217 STD { int svr4_sys_fstat64(int fd, struct svr4_stat64 *sb); }
288 218 STD { int svr4_sys_statvfs64(char *path, \
289 struct svr4_statvfs64 *fs); }
290 219 STD { int svr4_sys_fstatvfs64(int fd, struct svr4_statvfs64 *fs); }
291 220 MSTD { int svr4_sys_setrlimit64(int which, \
292 const struct svr4_rlimit64 *rlp); }
293 221 MSTD { int svr4_sys_getrlimit64(int which, \
294 struct svr4_rlimit64 *rlp); }
295 222 UNIMPL pread64
296 223 UNIMPL pwrite64
297 224 STD { int svr4_sys_creat64(char *path, int mode); }
298 225 STD { int svr4_sys_open64(char *path, int flags, int mode); }
299 226 UNIMPL rpcsys
300 227 UNIMPL whoknows
301 228 UNIMPL whoknows
302 229 UNIMPL whoknows
303 230 STD { int svr4_sys_socket(int domain, int type, int protocol); }
304 231 NOPROTO { int socketpair(int domain, int type, int protocol, \
305 int *rsv); }
306 232 NOPROTO { int bind(int s, const struct sockaddr *name, int namelen); }
307 233 NOPROTO { int listen(int s, int backlog); }
308 234 NOPROTO { int accept(int s, struct sockaddr *name, int *anamelen); }
309 235 NOPROTO { int connect(int s, const struct sockaddr *name, \
310 int namelen); }
311 236 NOPROTO { int shutdown(int s, int how); }
312 237 STD { int svr4_sys_recv(int s, caddr_t buf, int len, int flags); }
313 238 NOPROTO { ssize_t recvfrom(int s, void *buf, size_t len, int flags, \
314 struct sockaddr *from, int *fromlenaddr); }
315 239 NOPROTO { ssize_t recvmsg(int s, struct msghdr *msg, int flags); }
316 240 STD { int svr4_sys_send(int s, caddr_t buf, int len, int flags); }
317 241 NOPROTO { ssize_t sendmsg(int s, const struct msghdr *msg, int flags); }
318 242 STD { ssize_t svr4_sys_sendto(int s, void *buf, size_t len, \
319 int flags, struct sockaddr *to, int tolen); }
320 243 NOPROTO { int getpeername(int fdes, struct sockaddr *asa, int *alen); }
321 244 NOPROTO { int getsockname(int fdes, struct sockaddr *asa, int *alen); }
322 245 NOPROTO { int getsockopt(int s, int level, int name, void *val, \
323 int *avalsize); }
324 246 NOPROTO { int setsockopt(int s, int level, int name, const void *val, \
325 int valsize); }
326 247 UNIMPL sockconfig
327 248 UNIMPL { int ntp_gettime(struct ntptimeval *ntvp); }
328 249 MUNIMPL { int ntp_adjtime(struct timex *tp); }
Cache object: 51902e0dff8a2a614aa9345caf0803e0
|