Annotation of src/sys/compat/linux/arch/m68k/syscalls.master, Revision 1.12
1.12 ! tron 1: $NetBSD: syscalls.master,v 1.11 1999/12/05 21:24:30 tron Exp $
1.1 itohy 2:
3: ; @(#)syscalls.master 8.1 (Berkeley) 7/19/93
4:
5: ; NetBSD m68k COMPAT_LINUX system call name/number "master" file.
6: ; (See syscalls.conf to see what it is processed into.)
7: ;
8: ; Fields: number type [type-dependent ...]
9: ; number system call number, must be in order
10: ; type one of STD, OBSOL, UNIMPL, NODEF, NOARGS, or one of
11: ; the compatibility options defined in syscalls.conf.
12: ;
13: ; types:
14: ; STD always included
15: ; OBSOL obsolete, not included in system
16: ; UNIMPL unimplemented, not included in system
17: ; NODEF included, but don't define the syscall number
18: ; NOARGS included, but don't define the syscall args structure
19: ; INDIR included, but don't define the syscall args structure
20: ; and allow it to be "really" varargs.
21: ;
22: ; The compat options are defined in the syscalls.conf file, and the
23: ; compat option name is prefixed to the syscall name. Other than
24: ; that, they're like NODEF (for 'compat' options), or STD (for
25: ; 'libcompat' options).
26: ;
27: ; The type-dependent arguments are as follows:
28: ; For STD, NODEF, NOARGS, and compat syscalls:
29: ; { pseudo-proto } [alias]
30: ; For other syscalls:
31: ; [comment]
32: ;
33: ; #ifdef's, etc. may be included, and are copied to the output files.
34: ; #include's are copied to the syscall names and switch definition files only.
35:
36: #include "opt_compat_netbsd.h"
37: #include "opt_compat_43.h"
38:
39: #include <sys/param.h>
1.5 tron 40: #include <sys/poll.h>
1.1 itohy 41: #include <sys/systm.h>
42: #include <sys/signal.h>
43: #include <sys/mount.h>
44: #include <sys/syscallargs.h>
45:
46: #include <compat/linux/common/linux_types.h>
47: #include <compat/linux/common/linux_signal.h>
48: #include <compat/linux/common/linux_siginfo.h>
49: #include <compat/linux/common/linux_machdep.h>
50:
51: #include <compat/linux/linux_syscallargs.h>
52:
53:
54: 0 NOARGS { int sys_nosys(void); } syscall
55: 1 NOARGS { int sys_exit(int rval); }
56: 2 NOARGS { int sys_fork(void); }
57: 3 NOARGS { int sys_read(int fd, char *buf, u_int nbyte); }
58: 4 NOARGS { int sys_write(int fd, char *buf, u_int nbyte); }
1.2 itohy 59: 5 STD { int linux_sys_open(const char *path, int flags, \
60: int mode); }
1.1 itohy 61: 6 NOARGS { int sys_close(int fd); }
62: 7 STD { int linux_sys_waitpid(int pid, int *status, \
63: int options);}
1.2 itohy 64: 8 STD { int linux_sys_creat(const char *path, int mode); }
65: 9 NOARGS { int sys_link(const char *path, const char *link); }
66: 10 STD { int linux_sys_unlink(const char *path); }
67: 11 STD { int linux_sys_execve(const char *path, char **argp, \
1.1 itohy 68: char **envp); }
1.2 itohy 69: 12 STD { int linux_sys_chdir(const char *path); }
1.1 itohy 70: 13 STD { int linux_sys_time(linux_time_t *t); }
1.2 itohy 71: 14 STD { int linux_sys_mknod(const char *path, int mode, \
72: int dev); }
73: 15 STD { int linux_sys_chmod(const char *path, int mode); }
1.1 itohy 74: ;16 lchown on i386; chown on m68k.
1.2 itohy 75: 16 STD { int linux_sys_chown(const char *path, \
76: int uid, int gid); }
1.1 itohy 77: 17 OBSOL break
78: 18 OBSOL ostat
79: #if !defined(_KERNEL) || defined(COMPAT_43)
80: 19 NOARGS { long compat_43_sys_lseek(int fd, long offset, \
81: int whence); }
82: #else
83: 19 UNIMPL compat_43_sys_lseek
84: #endif
85: 20 NOARGS { pid_t sys_getpid(void); }
86: 21 UNIMPL mount
87: 22 OBSOL umount
88: 23 NOARGS { int sys_setuid(uid_t uid); }
89: 24 NOARGS { uid_t sys_getuid(void); }
1.8 tron 90: 25 STD { int linux_sys_stime(linux_time_t *t); }
1.12 ! tron 91: 26 STD { int linux_sys_ptrace(int request, int pid, \
! 92: int addr, int data); }
1.1 itohy 93: 27 STD { int linux_sys_alarm(unsigned int secs); }
94: 28 OBSOL ofstat
95: 29 STD { int linux_sys_pause(void); }
1.2 itohy 96: 30 STD { int linux_sys_utime(const char *path, \
1.1 itohy 97: struct linux_utimbuf *times); }
98: 31 OBSOL stty
99: 32 OBSOL gtty
1.2 itohy 100: 33 STD { int linux_sys_access(const char *path, int flags); }
1.1 itohy 101: 34 STD { int linux_sys_nice(int incr); }
102: 35 OBSOL ftime
103: 36 NOARGS { int sys_sync(void); }
104: 37 STD { int linux_sys_kill(int pid, int signum); }
1.2 itohy 105: 38 STD { int linux_sys_rename(const char *from, \
106: const char *to); }
107: 39 STD { int linux_sys_mkdir(const char *path, int mode); }
108: 40 STD { int linux_sys_rmdir(const char *path); }
1.1 itohy 109: 41 NOARGS { int sys_dup(u_int fd); }
110: 42 STD { int linux_sys_pipe(int *pfds); }
111: 43 STD { int linux_sys_times(struct times *tms); }
112: 44 OBSOL prof
113: 45 STD { int linux_sys_brk(char *nsize); }
114: 46 NOARGS { int sys_setgid(gid_t gid); }
115: 47 NOARGS { gid_t sys_getgid(void); }
1.10 tron 116: 48 STD { int linux_sys_signal(int signum, \
1.1 itohy 117: linux_handler_t handler); }
118: 49 NOARGS { uid_t sys_geteuid(void); }
119: 50 NOARGS { gid_t sys_getegid(void); }
120: 51 NOARGS { int sys_acct(char *path); }
121: 52 UNIMPL umount
122: 53 OBSOL lock
123: 54 STD { int linux_sys_ioctl(int fd, u_long com, \
124: caddr_t data); }
125: 55 STD { int linux_sys_fcntl(int fd, int cmd, void *arg); }
126: 56 OBSOL mpx
127: 57 NOARGS { int sys_setpgid(int pid, int pgid); }
128: 58 OBSOL ulimit
129: 59 UNIMPL oldolduname
130: 60 NOARGS { int sys_umask(int newmask); }
131: 61 NOARGS { int sys_chroot(char *path); }
132: 62 UNIMPL ustat
133: 63 NOARGS { int sys_dup2(u_int from, u_int to); }
134: 64 NOARGS { pid_t sys_getppid(void); }
135: 65 NOARGS { int sys_getpgrp(void); }
136: 66 NOARGS { int sys_setsid(void); }
137: 67 STD { int linux_sys_sigaction(int signum, \
138: const struct linux_old_sigaction *nsa, \
139: struct linux_old_sigaction *osa); }
140: 68 STD { int linux_sys_siggetmask(void); }
141: 69 STD { int linux_sys_sigsetmask(linux_old_sigset_t mask); }
142: 70 STD { int linux_sys_setreuid(int ruid, int euid); }
143: 71 STD { int linux_sys_setregid(int rgid, int egid); }
144: 72 STD { int linux_sys_sigsuspend(caddr_t restart, \
145: int oldmask, int mask); }
146: 73 STD { int linux_sys_sigpending(linux_old_sigset_t *set); }
147: #if !defined(_KERNEL) || defined(COMPAT_43)
148: 74 NOARGS { int compat_43_sys_sethostname(char *hostname, \
149: u_int len);}
150: 75 NOARGS { int compat_43_sys_setrlimit(u_int which, \
151: struct orlimit *rlp); }
152: 76 NOARGS { int compat_43_sys_getrlimit(u_int which, \
153: struct orlimit *rlp); }
154: #else
155: 74 UNIMPL compat_43_sys_sethostname
156: 75 UNIMPL compat_43_sys_setrlimit
157: 76 UNIMPL compat_43_sys_getrlimit
158: #endif
159: 77 NOARGS { int sys_getrusage(int who, struct rusage *rusage); }
160: 78 NOARGS { int sys_gettimeofday(struct timeval *tp, \
161: struct timezone *tzp); }
162: 79 NOARGS { int sys_settimeofday(struct timeval *tp, \
163: struct timezone *tzp); }
164: 80 NOARGS { int sys_getgroups(u_int gidsetsize, gid_t *gidset); }
165: 81 NOARGS { int sys_setgroups(u_int gidsetsize, gid_t *gidset); }
166: 82 STD { int linux_sys_oldselect(struct linux_oldselect *lsp); }
1.2 itohy 167: 83 STD { int linux_sys_symlink(const char *path, \
168: const char *to); }
1.1 itohy 169: #if !defined(_KERNEL) || defined(COMPAT_43)
1.2 itohy 170: 84 NOARGS { int compat_43_sys_lstat(const char *path, \
1.1 itohy 171: struct stat43 *up); } oolstat
172: #else
173: 84 UNIMPL compat_43_sys_lstat
174: #endif
1.2 itohy 175: 85 STD { int linux_sys_readlink(const char *name, char *buf, \
1.1 itohy 176: int count); }
1.2 itohy 177: 86 STD { int linux_sys_uselib(const char *path); }
1.1 itohy 178: #if !defined(_KERNEL) || defined(COMPAT_12)
179: 87 NOARGS { int compat_12_sys_swapon(char *name); }
180: #else
181: 87 UNIMPL compat_12_sys_swapon
182: #endif
183: 88 NOARGS { int sys_reboot(int opt); }
184: 89 STD { int linux_sys_readdir(int fd, caddr_t dent, \
185: unsigned int count); }
186: 90 STD { int linux_sys_old_mmap(struct linux_oldmmap *lmp); }
187: 91 NOARGS { int sys_munmap(caddr_t addr, int len); }
1.2 itohy 188: 92 STD { int linux_sys_truncate(const char *path, \
189: long length); }
1.1 itohy 190: #if !defined(_KERNEL) || defined(COMPAT_43)
191: 93 NOARGS { int compat_43_sys_ftruncate(int fd, long length); }
192: #else
193: 93 UNIMPL compat_43_sys_ftruncate
194: #endif
195: 94 NOARGS { int sys_fchmod(int fd, int mode); }
196: 95 STD { int linux_sys_fchown(int fd, int uid, int gid); }
197: 96 NOARGS { int sys_getpriority(int which, int who); }
198: 97 NOARGS { int sys_setpriority(int which, int who, int prio); }
199: 98 NOARGS { int sys_profil(caddr_t samples, u_int size, \
200: u_int offset, u_int scale); }
1.2 itohy 201: 99 STD { int linux_sys_statfs(const char *path, \
1.1 itohy 202: struct linux_statfs *sp); }
203: 100 STD { int linux_sys_fstatfs(int fd, \
204: struct linux_statfs *sp); }
205: 101 UNIMPL ioperm
206: 102 STD { int linux_sys_socketcall(int what, void *args); }
207: 103 UNIMPL syslog
208: 104 NOARGS { int sys_setitimer(u_int which, \
209: struct itimerval *itv, struct itimerval *oitv); }
210: 105 NOARGS { int sys_getitimer(u_int which, \
211: struct itimerval *itv); }
1.2 itohy 212: 106 STD { int linux_sys_stat(const char *path, \
1.1 itohy 213: struct linux_stat *sp); }
1.2 itohy 214: 107 STD { int linux_sys_lstat(const char *path, \
1.1 itohy 215: struct linux_stat *sp); }
216: 108 STD { int linux_sys_fstat(int fd, struct linux_stat *sp); }
217: 109 UNIMPL olduname
218: 110 UNIMPL iopl
219: 111 UNIMPL vhangup
220: 112 UNIMPL idle
221: 113 UNIMPL vm86old
222: 114 STD { int linux_sys_wait4(int pid, int *status, \
223: int options, struct rusage *rusage); }
224: 115 UNIMPL swapoff
225: 116 UNIMPL sysinfo
226: 117 STD { int linux_sys_ipc(int what, int a1, int a2, int a3, \
227: caddr_t ptr); }
228: 118 NOARGS { int sys_fsync(int fd); }
229: 119 STD { int linux_sys_sigreturn(void); }
1.6 thorpej 230: 120 STD { int linux_sys_clone(int flags, void *stack); }
1.1 itohy 231: #if !defined(_KERNEL) || defined(COMPAT_09)
232: 121 NOARGS { int compat_09_sys_setdomainname(char *name, \
233: int len); }
234: #else
235: 121 UNIMPL compat_09_sys_setdomainname
236: #endif
237: 122 STD { int linux_sys_uname(struct linux_utsname *up); }
238: 123 STD { int linux_sys_cacheflush(unsigned long addr, \
239: int scope, int cache, unsigned long len); }
240: 124 UNIMPL adjtimex
241: 125 NOARGS { int sys_mprotect(caddr_t addr, int len, int prot); }
242: 126 STD { int linux_sys_sigprocmask(int how, \
243: const linux_old_sigset_t *set, \
244: linux_old_sigset_t *oset); }
245: 127 UNIMPL create_module
246: 128 UNIMPL init_module
247: 129 UNIMPL delete_module
248: 130 UNIMPL get_kernel_syms
249: 131 UNIMPL quotactl
250: 132 STD { int linux_sys_getpgid(int pid); }
251: 133 NOARGS { int sys_fchdir(int fd); }
252: 134 UNIMPL bdflush
253: 135 UNIMPL sysfs
254: 136 STD { int linux_sys_personality(int per); }
255: 137 UNIMPL afs_syscall
256: 138 UNIMPL setfsuid
257: 139 UNIMPL getfsuid
258: 140 STD { int linux_sys_llseek(int fd, u_int32_t ohigh, \
259: u_int32_t olow, caddr_t res, int whence); }
260: 141 STD { int linux_sys_getdents(int fd, \
261: struct linux_dirent *dent, unsigned int count); }
262: 142 STD { int linux_sys_select(int nfds, fd_set *readfds, \
263: fd_set *writefds, fd_set *exceptfds, \
264: struct timeval *timeout); }
265: 143 NOARGS { int sys_flock(int fd, int how); }
266: 144 STD { int linux_sys_msync(caddr_t addr, int len, int fl); }
267: 145 NOARGS { int sys_readv(int fd, struct iovec *iovp, \
268: u_int iovcnt); }
269: 146 NOARGS { int sys_writev(int fd, struct iovec *iovp, \
270: u_int iovcnt); }
271: 147 NOARGS { pid_t sys_getsid(pid_t pid); }
272: 148 STD { int linux_sys_fdatasync(int fd); }
273: 149 STD { int linux_sys___sysctl(struct linux___sysctl *lsp); }
274: 150 NOARGS { int sys_mlock(caddr_t addr, size_t len); }
275: 151 NOARGS { int sys_munlock(caddr_t addr, size_t len); }
276: 152 UNIMPL mlockall
277: 153 UNIMPL munlockall
1.9 tron 278: 154 STD { int linux_sys_sched_setparam(pid_t pid, \
279: const struct linux_sched_param *sp); }
280: 155 STD { int linux_sys_sched_getparam(pid_t pid, \
281: struct linux_sched_param *sp); }
282: 156 STD { int linux_sys_sched_setscheduler(pid_t pid, \
283: int policy, const struct linux_sched_param *sp); }
284: 157 STD { int linux_sys_sched_getscheduler(pid_t pid); }
285: 158 STD { int linux_sys_sched_yield(void); }
286: 159 STD { int linux_sys_sched_get_priority_max(int policy); }
287: 160 STD { int linux_sys_sched_get_priority_min(int policy); }
1.1 itohy 288: 161 UNIMPL sched_rr_get_interval
289: 162 NOARGS { int sys_nanosleep(const struct timespec *rqtp, \
290: struct timespec *rmtp); }
291: 163 STD { void *linux_sys_mremap(void *old_address, \
292: size_t old_size, size_t new_size, u_long flags); }
1.7 thorpej 293: 164 STD { int linux_sys_setresuid(uid_t ruid, uid_t euid, \
294: uid_t suid); }
295: 165 STD { int linux_sys_getresuid(uid_t *ruid, uid_t *euid, \
296: uid_t *suid); }
1.1 itohy 297: 166 UNIMPL vm86
298: 167 UNIMPL query_module
1.5 tron 299: 168 NOARGS { int sys_poll(struct pollfd *fds, u_int nfds, \
300: int timeout); }
1.1 itohy 301: 169 UNIMPL nfsservctl
1.7 thorpej 302: 170 STD { int linux_sys_setresgid(gid_t rgid, gid_t egid, \
303: gid_t sgid); }
304: 171 STD { int linux_sys_getresgid(gid_t *rgid, gid_t *egid, \
305: gid_t *sgid); }
1.1 itohy 306: 172 UNIMPL prctl
307: 173 STD { int linux_sys_rt_sigreturn(void); }
308: 174 STD { int linux_sys_rt_sigaction(int signum, \
309: const struct linux_sigaction *nsa, \
310: struct linux_sigaction *osa, \
311: size_t sigsetsize); }
312: 175 STD { int linux_sys_rt_sigprocmask(int how, \
313: const linux_sigset_t *set, \
314: linux_sigset_t *oset, \
315: size_t sigsetsize); }
316: 176 STD { int linux_sys_rt_sigpending( \
317: linux_sigset_t *set, \
318: size_t sigsetsize); }
319: 177 UNIMPL rt_sigtimedwait
320: ; XXX XAX int here? sigset_t here? siginfo_t
321: 178 STD { int linux_sys_rt_queueinfo(int pid, int signum, \
322: void *uinfo); }
323: 179 STD { int linux_sys_rt_sigsuspend(linux_sigset_t *unewset, \
324: size_t sigsetsize); }
1.11 tron 325: 180 STD { int linux_sys_pread(int fd, char *buf, \
326: size_t nbyte, linux_off_t offset); }
327: 181 STD { int linux_sys_pwrite(int fd, char *buf, \
328: size_t nbyte, linux_off_t offset); }
1.1 itohy 329: ;182 chown on i386; lchown on m68k.
1.2 itohy 330: 182 STD { int linux_sys_lchown(const char *path, int uid, \
331: int gid); }
1.4 tron 332: 183 NOARGS { int sys___getcwd(char *bufp, size_t length); }
1.1 itohy 333: 184 UNIMPL capget
334: 185 UNIMPL capset
335: 186 UNIMPL sigaltstack
1.7 thorpej 336: 187 UNIMPL sendfile
337: 188 UNIMPL getpmsg
338: 189 UNIMPL putpmsg
339: 190 NOARGS { int sys___vfork14(void); }
CVSweb <webmaster@jp.NetBSD.org>