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
|
$Id: syscalls.master,v 1.1 1996/03/02 19:04:15 peter Exp $
; @(#)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 <sys/types.h>
#include <sys/param.h>
#include <sys/systm.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 { int exit(int rval); }
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 NOPROTO LINUX { int link(char *path, char *link); }
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_chown(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(void); }
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_phys(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(struct linux_oldold_utsname *up); }
60 NOPROTO LINUX { int umask(int newmask); }
61 NOPROTO LINUX { int chroot(char *path); }
62 STD LINUX { int linux_ustat(void); }
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, \
struct linux_sigaction *nsa, \
struct linux_sigaction *osa); }
68 STD LINUX { int linux_siggetmask(void); }
69 STD LINUX { int linux_sigsetmask(linux_sigset_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_sigset_t oldmask, linux_sigset_t mask); }
73 STD LINUX { int linux_sigpending(linux_sigset_t *mask); }
74 NOPROTO LINUX { int osethostname(char *hostname, \
u_int len);}
75 NOPROTO LINUX { int osetrlimit(u_int which, \
struct ogetrlimit *rlp); }
76 NOPROTO LINUX { int ogetrlimit(u_int which, \
struct ogetrlimit *rlp); }
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 NOPROTO LINUX { int getgroups(u_int gidsetsize, gid_t *gidset); }
81 NOPROTO LINUX { int setgroups(u_int gidsetsize, 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 lo, \
unsigned int hi, int val); }
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(struct linux_old_utsname *up); }
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_vm86(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(void); }
121 NOPROTO LINUX { int setdomainname(char *name, \
int len); }
122 STD LINUX { int linux_newuname(struct linux_newuname_t *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_sigset_t *mask, linux_sigset_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 UNIMPL LINUX sysfs
136 STD LINUX { int linux_personality(int per); }
137 UNIMPL LINUX afs_syscall
138 UNIMPL LINUX setfsuid
139 UNIMPL LINUX getfsuid
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); }
|
