Annotation of sys/compat/svr4/syscalls.master, Revision 1.1.1.1
1.1 nbrk 1: $OpenBSD: syscalls.master,v 1.33 2003/01/30 03:29:49 millert Exp $
2: ; $NetBSD: syscalls.master,v 1.17 1996/02/10 17:12:51 christos Exp $
3:
4: ; @(#)syscalls.master 8.1 (Berkeley) 7/19/93
5:
6: ; OpenBSD COMPAT_SVR4 system call name/number "master" file.
7: ; (See syscalls.conf to see what it is processed into.)
8: ;
9: ; Fields: number type [type-dependent ...]
10: ; number system call number, must be in order
11: ; type one of STD, OBSOL, UNIMPL, NODEF, NOARGS, or one of
12: ; the compatibility options defined in syscalls.conf.
13: ;
14: ; types:
15: ; STD always included
16: ; OBSOL obsolete, not included in system
17: ; UNIMPL unimplemented, not included in system
18: ; NODEF included, but don't define the syscall number
19: ; NOARGS included, but don't define the syscall args structure
20: ;
21: ; The compat options are defined in the syscalls.conf file, and the
22: ; compat option name is prefixed to the syscall name. Other than
23: ; that, they're like NODEF (for 'compat' options), or STD (for
24: ; 'libcompat' options).
25: ;
26: ; The type-dependent arguments are as follows:
27: ; For STD, NODEF, NOARGS, and compat syscalls:
28: ; { pseudo-proto } [alias]
29: ; For other syscalls:
30: ; [comment]
31: ;
32: ; #ifdef's, etc. may be included, and are copied to the output files.
33: ; #include's are copied to the syscall switch definition file only.
34:
35: #include <sys/param.h>
36: #include <sys/systm.h>
37: #include <sys/signal.h>
38: #include <sys/mount.h>
39: #include <sys/syscallargs.h>
40:
41: #include <compat/svr4/svr4_types.h>
42: #include <compat/svr4/svr4_time.h>
43: #include <compat/svr4/svr4_signal.h>
44: #include <compat/svr4/svr4_ucontext.h>
45: #include <compat/svr4/svr4_syscallargs.h>
46: #include <compat/svr4/svr4_statvfs.h>
47: #include <compat/svr4/svr4_acl.h>
48:
49: 0 NOARGS { int sys_nosys(void); } syscall
50: 1 NOARGS { int sys_exit(int rval); }
51: 2 NOARGS { int sys_fork(void); }
52: 3 NOARGS { int sys_read(int fd, char *buf, u_int nbyte); }
53: 4 NOARGS { int sys_write(int fd, char *buf, u_int nbyte); }
54: 5 STD { int svr4_sys_open(char *path, int flags, int mode); }
55: 6 NOARGS { int sys_close(int fd); }
56: 7 STD { int svr4_sys_wait(int *status); }
57: 8 STD { int svr4_sys_creat(char *path, int mode); }
58: 9 NOARGS { int sys_link(char *path, char *link); }
59: 10 NOARGS { int sys_unlink(char *path); }
60: 11 STD { int svr4_sys_execv(char *path, char **argp); }
61: 12 NOARGS { int sys_chdir(char *path); }
62: 13 STD { int svr4_sys_time(svr4_time_t *t); }
63: 14 STD { int svr4_sys_mknod(char *path, int mode, int dev); }
64: 15 NOARGS { int sys_chmod(char *path, int mode); }
65: 16 NOARGS { int sys_chown(char *path, int uid, int gid); }
66: 17 STD { int svr4_sys_break(caddr_t nsize); }
67: 18 STD { int svr4_sys_stat(char *path, struct svr4_stat* ub); }
68: 19 NOARGS { long compat_43_sys_lseek(int fd, long offset, \
69: int whence); }
70: 20 NOARGS { pid_t sys_getpid(void); }
71: 21 UNIMPL old_mount
72: 22 UNIMPL System V umount
73: 23 NOARGS { int sys_setuid(uid_t uid); }
74: 24 NOARGS { uid_t sys_getuid(void); }
75: 25 UNIMPL stime
76: 26 UNIMPL ptrace
77: 27 STD { int svr4_sys_alarm(unsigned sec); }
78: 28 STD { int svr4_sys_fstat(int fd, struct svr4_stat *sb); }
79: 29 STD { int svr4_sys_pause(void); }
80: 30 STD { int svr4_sys_utime(char *path, \
81: struct svr4_utimbuf *ubuf); }
82: 31 UNIMPL was stty
83: 32 UNIMPL was gtty
84: 33 STD { int svr4_sys_access(char *path, int flags); }
85: 34 STD { int svr4_sys_nice(int prio); }
86: 35 UNIMPL statfs
87: 36 NOARGS { int sys_sync(void); }
88: 37 STD { int svr4_sys_kill(int pid, int signum); }
89: 38 UNIMPL fstatfs
90: 39 STD { int svr4_sys_pgrpsys(int cmd, int pid, int pgid); }
91: 40 UNIMPL xenix
92: 41 NOARGS { int sys_dup(u_int fd); }
93: 42 NOARGS { int sys_opipe(void); }
94: 43 STD { int svr4_sys_times(struct tms *tp); }
95: 44 UNIMPL profil
96: 45 UNIMPL plock
97: 46 NOARGS { int sys_setgid(gid_t gid); }
98: 47 NOARGS { gid_t sys_getgid(void); }
99: 48 STD { int svr4_sys_signal(int signum, svr4_sig_t handler); }
100: #ifdef SYSVMSG
101: 49 STD { int svr4_sys_msgsys(int what, int a2, int a3, \
102: int a4, int a5); }
103: #else
104: 49 UNIMPL msgsys
105: #endif
106: 50 STD { int svr4_sys_sysarch(int op, void *a1); }
107: 51 UNIMPL acct
108: #ifdef SYSVSHM
109: 52 STD { int svr4_sys_shmsys(int what, int a2, int a3, \
110: int a4); }
111: #else
112: 52 UNIMPL shmsys
113: #endif
114: #ifdef SYSVSEM
115: 53 STD { int svr4_sys_semsys(int what, int a2, int a3, \
116: int a4, int a5); }
117: #else
118: 53 UNIMPL semsys
119: #endif
120: 54 STD { int svr4_sys_ioctl(int fd, u_long com, \
121: caddr_t data); }
122: 55 UNIMPL uadmin
123: 56 UNIMPL exch
124: 57 STD { int svr4_sys_utssys(void *a1, void *a2, int sel, \
125: void *a3); }
126: 58 NOARGS { int sys_fsync(int fd); }
127: 59 STD { int svr4_sys_execve(char *path, char **argp, \
128: char **envp); }
129: 60 NOARGS { int sys_umask(int newmask); }
130: 61 NOARGS { int sys_chroot(char *path); }
131: 62 STD { int svr4_sys_fcntl(int fd, int cmd, char *arg); }
132: 63 STD { long svr4_sys_ulimit(int cmd, long newlimit); }
133: 64 UNIMPL reserved for unix/pc
134: 65 UNIMPL reserved for unix/pc
135: 66 UNIMPL reserved for unix/pc
136: 67 UNIMPL reserved for unix/pc
137: 68 UNIMPL reserved for unix/pc
138: 69 UNIMPL reserved for unix/pc
139: 70 OBSOL advfs
140: 71 OBSOL unadvfs
141: 72 OBSOL rmount
142: 73 OBSOL rumount
143: 74 OBSOL rfstart
144: 75 OBSOL sigret
145: 76 STD { int svr4_sys_rdebug(void); }
146: 77 OBSOL rfstop
147: 78 UNIMPL rfsys
148: 79 NOARGS { int sys_rmdir(char *path); }
149: 80 NOARGS { int sys_mkdir(char *path, int mode); }
150: 81 STD { int svr4_sys_getdents(int fd, char *buf, \
151: int nbytes); }
152: 82 OBSOL libattach
153: 83 OBSOL libdetach
154: 84 UNIMPL sysfs
155: 85 STD { int svr4_sys_getmsg(int fd, struct svr4_strbuf *ctl, \
156: struct svr4_strbuf *dat, int *flags); }
157: 86 STD { int svr4_sys_putmsg(int fd, struct svr4_strbuf *ctl, \
158: struct svr4_strbuf *dat, int flags); }
159: 87 NOARGS { int sys_poll(struct pollfd *fds, u_long nfds, \
160: int timeout); }
161: 88 STD { int svr4_sys_lstat(char *path, \
162: struct svr4_stat *ub); }
163: 89 NOARGS { int sys_symlink(char *path, char *link); }
164: 90 NOARGS { int sys_readlink(char *path, char *buf, int count); }
165: 91 NOARGS { int sys_getgroups(u_int gidsetsize, gid_t *gidset); }
166: 92 NOARGS { int sys_setgroups(u_int gidsetsize, gid_t *gidset); }
167: 93 NOARGS { int sys_fchmod(int fd, int mode); }
168: 94 NOARGS { int sys_fchown(int fd, int uid, int gid); }
169: 95 STD { int svr4_sys_sigprocmask(int how, \
170: svr4_sigset_t *set, svr4_sigset_t *oset); }
171: 96 STD { int svr4_sys_sigsuspend(svr4_sigset_t *ss); }
172: 97 STD { int svr4_sys_sigaltstack( \
173: struct svr4_sigaltstack *nss, \
174: struct svr4_sigaltstack *oss); }
175: 98 STD { int svr4_sys_sigaction(int signum, \
176: struct svr4_sigaction *nsa, \
177: struct svr4_sigaction *osa); }
178: 99 STD { int svr4_sys_sigpending(int what, \
179: svr4_sigset_t *mask); }
180: 100 STD { int svr4_sys_context(int func, \
181: struct svr4_ucontext *uc); }
182: 101 UNIMPL evsys
183: 102 UNIMPL evtrapret
184: 103 STD { int svr4_sys_statvfs(char *path, \
185: struct svr4_statvfs *fs); }
186: 104 STD { int svr4_sys_fstatvfs(int fd, \
187: struct svr4_statvfs *fs); }
188: 105 UNIMPL
189: 106 UNIMPL nfssvc
190: 107 STD { int svr4_sys_waitsys(int grp, int id, \
191: union svr4_siginfo *info, int options); }
192: 108 UNIMPL sigsendsys
193: 109 STD { int svr4_sys_hrtsys(int cmd, int fun, int sub, \
194: void *rv1, void *rv2); }
195: 110 UNIMPL acancel
196: 111 UNIMPL async
197: 112 UNIMPL priocntlsys
198: 113 STD { int svr4_sys_pathconf(char *path, int name); }
199: 114 NOARGS { int sys_mincore(caddr_t addr, int len, char *vec); }
200: 115 STD { int svr4_sys_mmap(svr4_caddr_t addr, \
201: svr4_size_t len, int prot, int flags, int fd, \
202: svr4_off_t pos); }
203: 116 NOARGS { int sys_mprotect(caddr_t addr, int len, int prot); }
204: 117 NOARGS { int sys_munmap(caddr_t addr, int len); }
205: 118 STD { int svr4_sys_fpathconf(int fd, int name); }
206: 119 NOARGS { int sys_vfork(void); }
207: 120 NOARGS { int sys_fchdir(int fd); }
208: 121 NOARGS { int sys_readv(int fd, struct iovec *iovp, u_int iovcnt); }
209: 122 NOARGS { int sys_writev(int fd, struct iovec *iovp, \
210: u_int iovcnt); }
211: 123 STD { int svr4_sys_xstat(int two, char *path, \
212: struct svr4_xstat *ub); }
213: 124 STD { int svr4_sys_lxstat(int two, char *path, \
214: struct svr4_xstat *ub); }
215: 125 STD { int svr4_sys_fxstat(int two, int fd, \
216: struct svr4_xstat *sb); }
217: 126 STD { int svr4_sys_xmknod(int two, char *path, \
218: svr4_mode_t mode, svr4_dev_t dev); }
219: 127 UNIMPL clocal
220: 128 STD { int svr4_sys_setrlimit(int which, \
221: struct ogetrlimit *rlp); }
222: 129 STD { int svr4_sys_getrlimit(int which, \
223: struct ogetrlimit *rlp); }
224: 130 NOARGS { int sys_lchown(char *path, int uid, int gid); }
225: 131 STD { int svr4_sys_memcntl(svr4_caddr_t addr, \
226: svr4_size_t len, int cmd, svr4_caddr_t arg, \
227: int attr, int mask); }
228: 132 UNIMPL getpmsg
229: 133 UNIMPL putpmsg
230: 134 NOARGS { int sys_rename(char *from, char *to); }
231: 135 STD { int svr4_sys_uname(struct svr4_utsname* name, \
232: int dummy); }
233: 136 STD { int svr4_sys_setegid(gid_t egid); }
234: 137 STD { int svr4_sys_sysconfig(int name); }
235: 138 NOARGS { int sys_adjtime(struct timeval *delta, \
236: struct timeval *olddelta); }
237: 139 STD { long svr4_sys_systeminfo(int what, char *buf, \
238: long len); }
239: 140 UNIMPL
240: 141 NOARGS { int sys_seteuid(uid_t euid); }
241: 142 UNIMPL vtrace
242: 143 UNIMPL fork1
243: 144 UNIMPL sigtimedwait
244: 145 UNIMPL lwp_info
245: 146 UNIMPL yield
246: 147 UNIMPL lwp_sema_wait
247: 148 UNIMPL lwp_sema_post
248: 149 UNIMPL lwp_sema_trywait
249: 150 UNIMPL
250: 151 UNIMPL
251: 152 UNIMPL modctl
252: 153 STD { int svr4_sys_fchroot(int fd); }
253: 154 STD { int svr4_sys_utimes(char *path, \
254: struct timeval *tptr); }
255: 155 STD { int svr4_sys_vhangup(void); }
256: 156 STD { int svr4_sys_gettimeofday(struct timeval *tp); }
257: 157 NOARGS { int sys_getitimer(u_int which, \
258: struct itimerval *itv); }
259: 158 NOARGS { int sys_setitimer(u_int which, \
260: struct itimerval *itv, struct itimerval *oitv); }
261: 159 UNIMPL lwp_create
262: 160 UNIMPL lwp_exit
263: 161 UNIMPL lwp_suspend
264: 162 UNIMPL lwp_continue
265: 163 UNIMPL lwp_kill
266: 164 UNIMPL lwp_self
267: 165 UNIMPL lwp_getprivate
268: 166 UNIMPL lwp_setprivate
269: 167 UNIMPL lwp_wait
270: 168 UNIMPL lwp_mutex_unlock
271: 169 UNIMPL lwp_mutex_lock
272: 170 UNIMPL lwp_cond_wait
273: 171 UNIMPL lwp_cond_signal
274: 172 UNIMPL lwp_cond_broadcast
275: 173 STD { ssize_t svr4_sys_pread(int fd, void *buf, \
276: size_t nbyte, svr4_off_t off); }
277: 174 STD { ssize_t svr4_sys_pwrite(int fd, const void *buf, \
278: size_t nbyte, svr4_off_t off); }
279: 175 STD { svr4_off64_t svr4_sys_llseek(int fd, \
280: long offset1, long offset2, int whence); }
281: 176 UNIMPL inst_sync
282: 177 UNIMPL
283: 178 UNIMPL kaio
284: 179 UNIMPL
285: 180 UNIMPL
286: 181 UNIMPL
287: 182 UNIMPL
288: 183 UNIMPL
289: 184 UNIMPL tsolsys
290: 185 STD { int svr4_sys_acl(char *path, int cmd, int num, \
291: struct svr4_aclent *buf); }
292: 186 STD { int svr4_sys_auditsys(int code, int a1, int a2, \
293: int a3, int a4, int a5); }
294: 187 UNIMPL processor_bind
295: 188 UNIMPL processor_info
296: 189 UNIMPL p_online
297: 190 UNIMPL sigqueue
298: 191 NOARGS { int sys_clock_gettime(clockid_t clock_id, \
299: struct timespec *tp); }
300: 192 NOARGS { int sys_clock_settime(clockid_t clock_id, \
301: const struct timespec *tp); }
302: 193 NOARGS { int sys_clock_getres(clockid_t clock_id, \
303: struct timespec *tp); }
304: 194 UNIMPL timer_create
305: 195 UNIMPL timer_delete
306: 196 UNIMPL timer_settime
307: 197 UNIMPL timer_gettime
308: 198 UNIMPL timer_getoverrun
309: 199 NOARGS { int sys_nanosleep(const struct timespec *rqtp, \
310: struct timespec *rmtp); }
311: 200 STD { int svr4_sys_facl(int fd, int cmd, int num, \
312: struct svr4_aclent *buf); }
313: 201 UNIMPL door
314: 202 NOARGS { int sys_setreuid(uid_t ruid, uid_t euid); }
315: 203 NOARGS { int sys_setregid(gid_t rgid, gid_t egid); }
316: 204 UNIMPL install_utrap
317: 205 UNIMPL signotify
318: 206 UNIMPL schedctl
319: 207 UNIMPL pset
320: 208 UNIMPL
321: 209 UNIMPL resolvepath
322: 210 UNIMPL signotifywait
323: 211 UNIMPL lwp_sigredirect
324: 212 UNIMPL lwp_alarm
325: 213 STD { int svr4_sys_getdents64(int fd, \
326: struct svr4_dirent64 *dp, \
327: int nbytes); }
328: 214 STD { int svr4_sys_mmap64(svr4_caddr_t addr, \
329: svr4_size_t len, int prot, int flags, int fd, \
330: svr4_off64_t pos); }
331: 215 STD { int svr4_sys_stat64(const char *path, \
332: struct svr4_stat64 *sb); }
333: 216 STD { int svr4_sys_lstat64(const char *path, \
334: struct svr4_stat64 *sb); }
335: 217 STD { int svr4_sys_fstat64(int fd, \
336: struct svr4_stat64 *sb); }
337: 218 UNIMPL statvfs64
338: 219 STD { int svr4_sys_fstatvfs64(int fd, \
339: struct svr4_statvfs64 *fs); }
340: 220 UNIMPL setrlimit64
341: 221 UNIMPL getrlimit64
342: 222 STD { ssize_t svr4_sys_pread64(int fd, void *buf, \
343: size_t nbyte, svr4_off64_t off); }
344: 223 STD { ssize_t svr4_sys_pwrite64(int fd, const void *buf, \
345: size_t nbyte, svr4_off64_t off); }
346: 224 STD { int svr4_sys_creat64(char *path, int mode); }
347: 225 STD { int svr4_sys_open64(char *path, int flags, \
348: int mode); }
349: 226 UNIMPL rpcsys
350: 227 UNIMPL
351: 228 UNIMPL
352: 229 UNIMPL
353: 230 STD { int svr4_sys_socket(int domain, int type, \
354: int protocol); }
355: 231 NOARGS { int sys_socketpair(int domain, int type, \
356: int protocol, int *rsv); }
357: 232 NOARGS { int sys_bind(int s, const struct sockaddr *name, \
358: int namelen); }
359: 233 NOARGS { int sys_listen(int s, int backlog); }
360: 234 NOARGS { int compat_43_sys_accept(int s, \
361: struct sockaddr *name, int *anamelen); }
362: 235 NOARGS { int sys_connect(int s, const struct sockaddr *name, \
363: int namelen); }
364: 236 NOARGS { int sys_shutdown(int s, int how); }
365: 237 NOARGS { int compat_43_sys_recv(int s, caddr_t buf, int len, \
366: int flags); }
367: 238 NOARGS { ssize_t compat_43_sys_recvfrom(int s, void *buf, \
368: size_t len, int flags, struct sockaddr *from, \
369: int *fromlenaddr); }
370: 239 NOARGS { ssize_t compat_43_sys_recvmsg(int s, \
371: struct msghdr *msg, int flags); }
372: 240 NOARGS { int compat_43_sys_send(int s, caddr_t buf, int len, \
373: int flags); }
374: 241 NOARGS { ssize_t compat_43_sys_sendmsg(int s, \
375: const struct msghdr *msg, int flags); }
376: 242 NOARGS { ssize_t sys_sendto(int s, const void *buf, \
377: size_t len, int flags, const struct sockaddr *to, \
378: int tolen); }
379: 243 NOARGS { int compat_43_sys_getpeername(int fdes, \
380: struct sockaddr *asa, int *alen); }
381: 244 NOARGS { int compat_43_sys_getsockname(int fdes, \
382: struct sockaddr *asa, int *alen); }
383: 245 NOARGS { int sys_getsockopt(int s, int level, int name, \
384: void *val, int *avalsize); }
385: 246 NOARGS { int sys_setsockopt(int s, int level, int name, \
386: const void *val, int valsize); }
387: 247 UNIMPL sockconfig
388: 248 UNIMPL ntp_gettime
389: 249 UNIMPL ntp_adjtime
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to syscalls.master CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / compat / svr4