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