1 $FreeBSD$
2
3 ; @(#)syscalls.master 8.1 (Berkeley) 7/19/93
4 ; System call name/number master file (or rather, slave, from LINUX).
5 ; Processed to created linux_sysent.c, linux_syscalls.c and linux_syscall.h.
6
7 ; Columns: number type nargs namespc name alt{name,tag,rtyp}/comments
8 ; number system call number, must be in order
9 ; type one of STD, OBSOL, UNIMPL, COMPAT
10 ; namespc one of POSIX, BSD, STD, NOHIDE (I dont care :-) -Peter
11 ; name psuedo-prototype of syscall routine
12 ; If one of the following alts is different, then all appear:
13 ; altname name of system call if different
14 ; alttag name of args struct tag if different from [o]`name'"_args"
15 ; altrtyp return type if not int (bogus - syscalls always return int)
16 ; for UNIMPL/OBSOL, name continues with comments
17
18 ; types:
19 ; STD always included
20 ; COMPAT included on COMPAT #ifdef
21 ; LIBCOMPAT included on COMPAT #ifdef, and placed in syscall.h
22 ; OBSOL obsolete, not included in system, only specifies name
23 ; UNIMPL not implemented, placeholder only
24
25 #include "opt_compat.h"
26 #include <sys/param.h>
27 #include <sys/sysent.h>
28 #include <sys/sysproto.h>
29 #include <i386/linux/linux.h>
30 #include <i386/linux/linux_proto.h>
31
32 ; #ifdef's, etc. may be included, and are copied to the output files.
33
34 0 STD LINUX { int linux_setup(void); }
35 1 NOPROTO LINUX { int exit(int rval); }
36 2 STD LINUX { int linux_fork(void); }
37 3 NOPROTO LINUX { int read(int fd, char *buf, u_int nbyte); }
38 4 NOPROTO LINUX { int write(int fd, char *buf, u_int nbyte); }
39 5 STD LINUX { int linux_open(char *path, int flags, int mode); }
40 6 NOPROTO LINUX { int close(int fd); }
41 7 STD LINUX { int linux_waitpid(int pid, int *status, int options);}
42 8 STD LINUX { int linux_creat(char *path, int mode); }
43 9 STD LINUX { int linux_link(char *path, char *to); }
44 10 STD LINUX { int linux_unlink(char *path); }
45 11 STD LINUX { int linux_execve(char *path, char **argp, char **envp); }
46 12 STD LINUX { int linux_chdir(char *path); }
47 13 STD LINUX { int linux_time(linux_time_t *tm); }
48 14 STD LINUX { int linux_mknod(char *path, int mode, int dev); }
49 15 STD LINUX { int linux_chmod(char *path, int mode); }
50 16 STD LINUX { int linux_lchown(char *path, int uid, int gid); }
51 17 STD LINUX { int linux_break(char *nsize); }
52 18 STD LINUX { int linux_stat(char *path, struct ostat *up); }
53 19 STD LINUX { int linux_lseek(int fdes, long off, int whence); }
54 20 NOPROTO LINUX { int getpid(void); }
55 21 STD LINUX { int linux_mount(void); }
56 22 STD LINUX { int linux_umount(void); }
57 23 NOPROTO LINUX { int setuid(uid_t uid); }
58 24 NOPROTO LINUX { int getuid(void); }
59 25 STD LINUX { int linux_stime(void); }
60 26 STD LINUX { int linux_ptrace(void); }
61 27 STD LINUX { int linux_alarm(unsigned int secs); }
62 28 STD LINUX { int linux_fstat(int fd, struct ostat *up); }
63 29 STD LINUX { int linux_pause(void); }
64 30 STD LINUX { int linux_utime(char *fname, struct linux_utimbuf *times); }
65 31 STD LINUX { int linux_stty(void); }
66 32 STD LINUX { int linux_gtty(void); }
67 33 STD LINUX { int linux_access(char *path, int flags); }
68 34 STD LINUX { int linux_nice(int inc); }
69 35 STD LINUX { int linux_ftime(void); }
70 36 NOPROTO LINUX { int sync(void); }
71 37 STD LINUX { int linux_kill(int pid, int signum); }
72 38 STD LINUX { int linux_rename(char *from, char *to); }
73 39 STD LINUX { int linux_mkdir(char *path, int mode); }
74 40 STD LINUX { int linux_rmdir(char *path); }
75 41 NOPROTO LINUX { int dup(u_int fd); }
76 42 STD LINUX { int linux_pipe(int *pipefds); }
77 43 STD LINUX { int linux_times(struct linux_times_argv *buf); }
78 44 STD LINUX { int linux_prof(void); }
79 45 STD LINUX { int linux_brk(char *dsend); }
80 46 NOPROTO LINUX { int setgid(gid_t gid); }
81 47 NOPROTO LINUX { int getgid(void); }
82 48 STD LINUX { int linux_signal(int sig, linux_handler_t handler); }
83 49 NOPROTO LINUX { int geteuid(void); }
84 50 NOPROTO LINUX { int getegid(void); }
85 51 NOPROTO LINUX { int acct(char *path); }
86 52 STD LINUX { int linux_phys(void); }
87 53 STD LINUX { int linux_lock(void); }
88 54 STD LINUX { int linux_ioctl(int fd, u_long cmd, int arg); }
89 55 STD LINUX { int linux_fcntl(int fd, int cmd, int arg); }
90 56 STD LINUX { int linux_mpx(void); }
91 57 NOPROTO LINUX { int setpgid(int pid, int pgid); }
92 58 STD LINUX { int linux_ulimit(void); }
93 59 STD LINUX { int linux_olduname(struct linux_oldold_utsname *up); }
94 60 NOPROTO LINUX { int umask(int newmask); }
95 61 NOPROTO LINUX { int chroot(char *path); }
96 62 STD LINUX { int linux_ustat(linux_dev_t dev, \
97 struct linux_ustat *ubuf); }
98 63 NOPROTO LINUX { int dup2(u_int from, u_int to); }
99 64 NOPROTO LINUX { int getppid(void); }
100 65 NOPROTO LINUX { int getpgrp(void); }
101 66 NOPROTO LINUX { int setsid(void); }
102 67 STD LINUX { int linux_sigaction(int sig, \
103 struct linux_sigaction *nsa, \
104 struct linux_sigaction *osa); }
105 68 STD LINUX { int linux_siggetmask(void); }
106 69 STD LINUX { int linux_sigsetmask(linux_sigset_t mask); }
107 70 NOPROTO LINUX { int setreuid(int ruid, int euid); }
108 71 NOPROTO LINUX { int setregid(int rgid, int egid); }
109 72 STD LINUX { int linux_sigsuspend(int restart, \
110 linux_sigset_t oldmask, linux_sigset_t mask); }
111 73 STD LINUX { int linux_sigpending(linux_sigset_t *mask); }
112 74 NOPROTO LINUX { int osethostname(char *hostname, \
113 u_int len);}
114 75 STD LINUX { int linux_setrlimit(u_int resource, \
115 struct ogetrlimit *rlim); }
116 76 STD LINUX { int linux_getrlimit(u_int resource, \
117 struct ogetrlimit *rlim); }
118 77 NOPROTO LINUX { int getrusage(int who, struct rusage *rusage); }
119 78 NOPROTO LINUX { int gettimeofday(struct timeval *tp, \
120 struct timezone *tzp); }
121 79 NOPROTO LINUX { int settimeofday(struct timeval *tp, \
122 struct timezone *tzp); }
123 80 STD LINUX { int linux_getgroups(u_int gidsetsize, \
124 linux_gid_t *gidset); }
125 81 STD LINUX { int linux_setgroups(u_int gidsetsize, \
126 linux_gid_t *gidset); }
127 82 STD LINUX { int linux_select(struct linux_select_argv *ptr); }
128 83 STD LINUX { int linux_symlink(char *path, char *to); }
129 84 NOPROTO LINUX { int ostat(char *path, struct ostat *up); }
130 85 STD LINUX { int linux_readlink(char *name, char *buf, \
131 int count); }
132 86 STD LINUX { int linux_uselib(char *library); }
133 87 NOPROTO LINUX { int swapon(char *name); }
134 88 NOPROTO LINUX { int reboot(int opt); }
135 89 STD LINUX { int linux_readdir(int fd, struct linux_dirent *dent, \
136 unsigned int count); }
137 90 STD LINUX { int linux_mmap(struct linux_mmap_argv *ptr); }
138 91 NOPROTO LINUX { int munmap(caddr_t addr, int len); }
139 92 STD LINUX { int linux_truncate(char *path, long length); }
140 93 NOPROTO LINUX { int oftruncate(int fd, long length); }
141 94 NOPROTO LINUX { int fchmod(int fd, int mode); }
142 95 NOPROTO LINUX { int fchown(int fd, int uid, int gid); }
143 96 NOPROTO LINUX { int getpriority(int which, int who); }
144 97 NOPROTO LINUX { int setpriority(int which, int who, int prio); }
145 98 NOPROTO LINUX { int profil(caddr_t samples, u_int size, \
146 u_int offset, u_int scale); }
147 99 STD LINUX { int linux_statfs(char *path, \
148 struct linux_statfs_buf *buf); }
149 100 STD LINUX { int linux_fstatfs(int fd, \
150 struct linux_statfs_buf *buf); }
151 101 STD LINUX { int linux_ioperm(unsigned int lo, \
152 unsigned int hi, int val); }
153 102 STD LINUX { int linux_socketcall(int what, void *args); }
154 103 STD LINUX { int linux_ksyslog(int what); }
155 104 STD LINUX { int linux_setitimer(u_int which, \
156 struct itimerval *itv, struct itimerval *oitv); }
157 105 STD LINUX { int linux_getitimer(u_int which, \
158 struct itimerval *itv); }
159 106 STD LINUX { int linux_newstat(char *path, \
160 struct linux_newstat *buf); }
161 107 STD LINUX { int linux_newlstat(char *path, \
162 struct linux_newstat *buf); }
163 108 STD LINUX { int linux_newfstat(int fd, struct linux_newstat *buf); }
164 109 STD LINUX { int linux_uname(struct linux_old_utsname *up); }
165 110 STD LINUX { int linux_iopl(int level); }
166 111 STD LINUX { int linux_vhangup(void); }
167 112 STD LINUX { int linux_idle(void); }
168 113 STD LINUX { int linux_vm86(void); }
169 114 STD LINUX { int linux_wait4(int pid, int *status, \
170 int options, struct rusage *rusage); }
171 115 STD LINUX { int linux_swapoff(void); }
172 116 STD LINUX { int linux_sysinfo(void); }
173 117 STD LINUX { int linux_ipc(int what, int arg1, int arg2, int arg3, \
174 caddr_t ptr); }
175 118 NOPROTO LINUX { int fsync(int fd); }
176 119 STD LINUX { int linux_sigreturn(struct linux_sigcontext *scp); }
177 120 STD LINUX { int linux_clone(int flags, void *stack); }
178 121 NOPROTO LINUX { int setdomainname(char *name, \
179 int len); }
180 122 STD LINUX { int linux_newuname(struct linux_newuname_t *buf); }
181 123 STD LINUX { int linux_modify_ldt(int func, void *ptr, \
182 size_t bytecount); }
183 124 STD LINUX { int linux_adjtimex(void); }
184 125 NOPROTO LINUX { int mprotect(caddr_t addr, int len, int prot); }
185 126 STD LINUX { int linux_sigprocmask(int how, \
186 linux_sigset_t *mask, linux_sigset_t *omask); }
187 127 STD LINUX { int linux_create_module(void); }
188 128 STD LINUX { int linux_init_module(void); }
189 129 STD LINUX { int linux_delete_module(void); }
190 130 STD LINUX { int linux_get_kernel_syms(void); }
191 131 STD LINUX { int linux_quotactl(void); }
192 132 STD LINUX { int linux_getpgid(int pid); }
193 133 NOPROTO LINUX { int fchdir(int fd); }
194 134 STD LINUX { int linux_bdflush(void); }
195 135 UNIMPL LINUX sysfs
196 136 STD LINUX { int linux_personality(int per); }
197 137 UNIMPL LINUX afs_syscall
198 138 UNIMPL LINUX setfsuid
199 139 UNIMPL LINUX getfsuid
200 140 STD LINUX { int linux_llseek(int fd, u_int32_t ohigh, \
201 u_int32_t olow, caddr_t res, int whence); }
202 141 STD LINUX { int linux_getdents(int fd, void *dent, \
203 unsigned count); }
204 142 STD LINUX { int linux_newselect(int nfds, fd_set *readfds, \
205 fd_set *writefds, fd_set *exceptfds, \
206 struct timeval *timeout); }
207 143 NOPROTO LINUX { int flock(int fd, int how); }
208 144 STD LINUX { int linux_msync(caddr_t addr, int len, int fl); }
209 145 NOPROTO LINUX { int readv(int fd, struct iovec *iovp, \
210 u_int iovcnt); }
211 146 NOPROTO LINUX { int writev(int fd, struct iovec *iovp, \
212 u_int iovcnt); }
213
214 ; Turn on getsid after checking that it matches.
215
216 147 UNIMPL LINUX getsid
217 148 STD LINUX { int linux_fdatasync(int fd); }
218 149 UNIMPL LINUX _sysctl
219
220 150 NOPROTO BSD { int mlock(const void *addr, size_t len); }
221 151 NOPROTO BSD { int munlock(const void *addr, size_t len); }
222 152 NOPROTO BSD { int mlockall(int how); }
223 153 NOPROTO BSD { int munlockall(void); }
224
225 154 NOPROTO POSIX { int sched_setparam (pid_t pid, const struct sched_param *param); }
226 155 NOPROTO POSIX { int sched_getparam (pid_t pid, struct sched_param *param); }
227
228 156 STD POSIX { int linux_sched_setscheduler(pid_t pid, int policy, \
229 const struct sched_param *param); }
230 157 STD POSIX { int linux_sched_getscheduler(pid_t pid); }
231
232 158 NOPROTO POSIX { int sched_yield (void); }
233 159 NOPROTO POSIX { int sched_get_priority_max (int policy); }
234 160 NOPROTO POSIX { int sched_get_priority_min (int policy); }
235 161 NOPROTO POSIX { int sched_rr_get_interval (pid_t pid, struct timespec *interval); }
236
237 162 NOPROTO POSIX { int nanosleep(const struct timespec *rqtp, \
238 struct timespec *rmtp); }
239
240 163 STD LINUX { int linux_mremap(caddr_t addr, int old_len, \
241 int new_len, int flags); }
242 164 UNIMPL LINUX setresuid
243 165 UNIMPL LINUX getresuid
244 166 UNIMPL LINUX new_vm86
245 167 UNIMPL LINUX query_module
246 168 NOPROTO LINUX { int poll(struct pollfd*, unsigned int nfds, \
247 long timeout); }
248 169 UNIMPL LINUX nfsservctl
249 170 UNIMPL LINUX setresgid
250 171 UNIMPL LINUX getresgid
251 172 UNIMPL LINUX prctl
252 173 UNIMPL LINUX rt_sigreturn
253 174 STD LINUX { int linux_rt_sigaction(int sig, \
254 struct linux_new_sigaction *act, \
255 struct linux_new_sigaction *oact, \
256 size_t sigsetsize); }
257 175 STD LINUX { int linux_rt_sigprocmask(int how, \
258 struct linux_new_sigset *mask, \
259 struct linux_new_sigset *omask, \
260 size_t sigsetsize); }
261 176 UNIMPL LINUX rt_sigpending
262 177 UNIMPL LINUX rt_sigtimedwait
263 178 UNIMPL LINUX rt_sigqueueinfo
264 179 STD LINUX { int linux_rt_sigsuspend( \
265 struct linux_new_sigset *newset, \
266 size_t sigsetsize); }
267 180 UNIMPL LINUX pread
268 181 UNIMPL LINUX pwrite
269 182 STD LINUX { int linux_chown(char *path, int uid, int gid); }
270 183 STD LINUX { int linux_getcwd(char *buf, unsigned long bufsize); }
271 184 UNIMPL LINUX capget
272 185 UNIMPL LINUX capset
273 186 STD LINUX { int linux_sigaltstack(const linux_stack_t *uss, \
274 linux_stack_t *uoss); }
275 187 UNIMPL LINUX sendfile
276 188 UNIMPL LINUX getpmsg
277 189 UNIMPL LINUX putpmsg
278 190 STD LINUX { int linux_vfork(void); }
Cache object: 66ddffda99fc85b7392f62071085f787
|