f981a79ed9
1. establish type independence for ease in porting and,
2. provide a visual queue as to which syscalls have proper
prototypes to further cleanup the i386/alpha split.
Linuxulator types are prefixed by 'l_'. void and char have not
been "virtualized".
o Remove dummy functions for syscalls that are now truely
unimplemented.
o Rename syscalls so they match the names used in the Linux kernel.
Also, provide more accurate prototypes. This generally improves
cross-referencing and reduces head-scratching.
o Provide seperate implementations for the 16-bit uid_t and gid_t
based syscalls as Linux used to have. The new 32-bit uid_t and
gid_t based syscalls now map to their FreeBSD equivalents.
o Fix the linux_ipc syscall so that it doesn't force the shm*, sem*
and msg* syscalls to have the same syscall. The prototypes for
these syscalls now match the those used on Alpha. While here,
add the same kludge for MSGRCV as is present in the Linux kernel.
o Implement the following syscalls:
linux_stat64, linux_lstat64 and linux_fstat64
linux_sysctl
o Added syscalls numbered 198 - 221. This include:
- the 32-bit uid_t and gid_t bases syscalls
- 64-bit file offset/size based syscalls
341 lines
15 KiB
Plaintext
341 lines
15 KiB
Plaintext
$FreeBSD$
|
|
|
|
; @(#)syscalls.master 8.1 (Berkeley) 7/19/93
|
|
; System call name/number master file (or rather, slave, from LINUX).
|
|
; Processed to create linux_sysent.c, linux_proto.h 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 UNIMPL LINUX setup
|
|
1 MNOPROTO LINUX { void sys_exit(int rval); } exit sys_exit_args void
|
|
2 MSTD 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, l_int flags, \
|
|
l_int mode); }
|
|
6 NOPROTO LINUX { int close(int fd); }
|
|
7 STD LINUX { int linux_waitpid(l_pid_t pid, l_int *status, \
|
|
l_int options); }
|
|
8 STD LINUX { int linux_creat(char *path, l_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(l_time_t *tm); }
|
|
14 STD LINUX { int linux_mknod(char *path, l_int mode, \
|
|
l_dev_t dev); }
|
|
15 STD LINUX { int linux_chmod(char *path, l_mode_t mode); }
|
|
16 STD LINUX { int linux_lchown16(char *path, l_uid16_t uid, \
|
|
l_gid16_t gid); }
|
|
17 UNIMPL LINUX break
|
|
18 STD LINUX { int linux_stat(char *path, struct ostat *up); }
|
|
19 STD LINUX { int linux_lseek(l_uint fdes, l_off_t off, \
|
|
l_int whence); }
|
|
20 STD LINUX { int linux_getpid(void); }
|
|
21 STD LINUX { int linux_mount(char *specialfile, char *dir, \
|
|
char *filesystemtype, l_ulong rwflag, \
|
|
void *data); }
|
|
22 STD LINUX { int linux_oldumount(char *path); }
|
|
23 STD LINUX { int linux_setuid16(l_uid16_t uid); }
|
|
24 STD LINUX { int linux_getuid16(void); }
|
|
25 STD LINUX { int linux_stime(void); }
|
|
26 STD LINUX { int linux_ptrace(void); }
|
|
27 STD LINUX { int linux_alarm(l_uint secs); }
|
|
28 STD LINUX { int linux_fstat(l_uint fd, struct ostat *up); }
|
|
29 STD LINUX { int linux_pause(void); }
|
|
30 STD LINUX { int linux_utime(char *fname, \
|
|
struct l_utimbuf *times); }
|
|
31 UNIMPL LINUX stty
|
|
32 UNIMPL LINUX gtty
|
|
33 STD LINUX { int linux_access(char *path, l_int flags); }
|
|
34 STD LINUX { int linux_nice(l_int inc); }
|
|
35 UNIMPL LINUX ftime
|
|
36 NOPROTO LINUX { int sync(void); }
|
|
37 STD LINUX { int linux_kill(l_int pid, l_int signum); }
|
|
38 STD LINUX { int linux_rename(char *from, char *to); }
|
|
39 STD LINUX { int linux_mkdir(char *path, l_int mode); }
|
|
40 STD LINUX { int linux_rmdir(char *path); }
|
|
41 NOPROTO LINUX { int dup(u_int fd); }
|
|
42 STD LINUX { int linux_pipe(l_ulong *pipefds); }
|
|
43 STD LINUX { int linux_times(struct l_times_argv *buf); }
|
|
44 UNIMPL LINUX prof
|
|
45 STD LINUX { int linux_brk(l_ulong dsend); }
|
|
46 STD LINUX { int linux_setgid16(l_gid16_t gid); }
|
|
47 STD LINUX { int linux_getgid16(void); }
|
|
48 STD LINUX { int linux_signal(l_int sig, l_handler_t handler); }
|
|
49 STD LINUX { int linux_geteuid16(void); }
|
|
50 STD LINUX { int linux_getegid16(void); }
|
|
51 NOPROTO LINUX { int acct(char *path); }
|
|
52 STD LINUX { int linux_umount(char *path, l_int flags); }
|
|
53 UNIMPL LINUX lock
|
|
54 STD LINUX { int linux_ioctl(l_uint fd, l_uint cmd, \
|
|
l_ulong arg); }
|
|
55 STD LINUX { int linux_fcntl(l_uint fd, l_uint cmd, \
|
|
l_ulong arg); }
|
|
56 UNIMPL LINUX mpx
|
|
57 NOPROTO LINUX { int setpgid(int pid, int pgid); }
|
|
58 UNIMPL LINUX ulimit
|
|
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(l_dev_t dev, struct l_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(l_int sig, l_osigaction_t *nsa, \
|
|
l_osigaction_t *osa); }
|
|
68 STD LINUX { int linux_sgetmask(void); }
|
|
69 STD LINUX { int linux_ssetmask(l_osigset_t mask); }
|
|
70 STD LINUX { int linux_setreuid16(l_uid16_t ruid, \
|
|
l_uid16_t euid); }
|
|
71 STD LINUX { int linux_setregid16(l_gid16_t rgid, \
|
|
l_gid16_t egid); }
|
|
72 STD LINUX { int linux_sigsuspend(l_int hist0, l_int hist1, \
|
|
l_osigset_t mask); }
|
|
73 STD LINUX { int linux_sigpending(l_osigset_t *mask); }
|
|
74 MNOPROTO LINUX { int osethostname(char *hostname, u_int len); } \
|
|
osethostname sethostname_args int
|
|
75 STD LINUX { int linux_setrlimit(l_uint resource, \
|
|
struct l_rlimit *rlim); }
|
|
76 STD LINUX { int linux_old_getrlimit(l_uint resource, \
|
|
struct l_rlimit *rlim); }
|
|
77 NOPROTO LINUX { int getrusage(int who, struct rusage *rusage); }
|
|
78 NOPROTO LINUX { int gettimeofday(struct timeval *tp, \
|
|
struct timezone *tzp); }
|
|
79 MNOPROTO LINUX { int settimeofday(struct timeval *tp, \
|
|
struct timezone *tzp); }
|
|
80 STD LINUX { int linux_getgroups16(l_uint gidsetsize, \
|
|
l_gid16_t *gidset); }
|
|
81 STD LINUX { int linux_setgroups16(l_uint gidsetsize, \
|
|
l_gid16_t *gidset); }
|
|
82 STD LINUX { int linux_old_select(struct l_old_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, \
|
|
l_int count); }
|
|
86 STD LINUX { int linux_uselib(char *library); }
|
|
87 NOPROTO LINUX { int swapon(char *name); }
|
|
88 STD LINUX { int linux_reboot(l_int magic1, l_int magic2, \
|
|
l_uint cmd, void *arg); }
|
|
89 STD LINUX { int linux_readdir(l_uint fd, struct l_dirent *dent, \
|
|
l_uint count); }
|
|
90 STD LINUX { int linux_mmap(struct l_mmap_argv *ptr); }
|
|
91 NOPROTO LINUX { int munmap(caddr_t addr, int len); }
|
|
92 STD LINUX { int linux_truncate(char *path, l_ulong 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 UNIMPL LINUX profil
|
|
99 STD LINUX { int linux_statfs(char *path, \
|
|
struct l_statfs_buf *buf); }
|
|
100 STD LINUX { int linux_fstatfs(l_uint fd, \
|
|
struct l_statfs_buf *buf); }
|
|
101 STD LINUX { int linux_ioperm(l_ulong start, l_ulong length, \
|
|
l_int enable); }
|
|
102 STD LINUX { int linux_socketcall(l_int what, l_ulong args); }
|
|
103 STD LINUX { int linux_syslog(l_int type, char *buf, l_int len); }
|
|
104 STD LINUX { int linux_setitimer(l_int which, \
|
|
struct l_itimerval *itv, \
|
|
struct l_itimerval *oitv); }
|
|
105 STD LINUX { int linux_getitimer(l_int which, \
|
|
struct l_itimerval *itv); }
|
|
106 STD LINUX { int linux_newstat(char *path, \
|
|
struct l_newstat *buf); }
|
|
107 STD LINUX { int linux_newlstat(char *path, \
|
|
struct l_newstat *buf); }
|
|
108 STD LINUX { int linux_newfstat(l_uint fd, \
|
|
struct l_newstat *buf); }
|
|
109 STD LINUX { int linux_uname(void); }
|
|
110 STD LINUX { int linux_iopl(l_ulong level); }
|
|
111 STD LINUX { int linux_vhangup(void); }
|
|
112 UNIMPL LINUX idle
|
|
113 STD LINUX { int linux_vm86old(void); }
|
|
114 STD LINUX { int linux_wait4(l_pid_t pid, l_uint *status, \
|
|
l_int options, struct l_rusage *rusage); }
|
|
115 STD LINUX { int linux_swapoff(void); }
|
|
116 STD LINUX { int linux_sysinfo(struct l_sysinfo *info); }
|
|
117 STD LINUX { int linux_ipc(l_uint what, l_int arg1, l_int arg2, \
|
|
l_int arg3, void *ptr, l_long arg5); }
|
|
118 NOPROTO LINUX { int fsync(int fd); }
|
|
119 STD LINUX { int linux_sigreturn(struct l_sigframe *sfp); }
|
|
120 STD LINUX { int linux_clone(l_int flags, void *stack); }
|
|
121 MNOPROTO LINUX { int setdomainname(char *name, int len); }
|
|
122 STD LINUX { int linux_newuname(struct l_new_utsname *buf); }
|
|
123 STD LINUX { int linux_modify_ldt(l_int func, void *ptr, \
|
|
l_ulong 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(l_int how, l_osigset_t *mask, \
|
|
l_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(l_pid_t pid); }
|
|
133 NOPROTO LINUX { int fchdir(int fd); }
|
|
134 STD LINUX { int linux_bdflush(void); }
|
|
135 STD LINUX { int linux_sysfs(l_int option, l_ulong arg1, \
|
|
l_ulong arg2); }
|
|
136 STD LINUX { int linux_personality(l_ulong per); }
|
|
137 UNIMPL LINUX afs_syscall
|
|
138 STD LINUX { int linux_setfsuid16(l_uid16_t uid); }
|
|
139 STD LINUX { int linux_setfsgid16(l_gid16_t gid); }
|
|
140 STD LINUX { int linux_llseek(l_int fd, l_ulong ohigh, \
|
|
l_ulong olow, l_loff_t *res, l_uint whence); }
|
|
141 STD LINUX { int linux_getdents(l_uint fd, void *dent, \
|
|
l_uint count); }
|
|
142 STD LINUX { int linux_select(l_int nfds, l_fd_set *readfds, \
|
|
l_fd_set *writefds, l_fd_set *exceptfds, \
|
|
struct l_timeval *timeout); }
|
|
143 NOPROTO LINUX { int flock(int fd, int how); }
|
|
144 STD LINUX { int linux_msync(l_ulong addr, l_size_t len, \
|
|
l_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(l_pid_t pid); }
|
|
148 STD LINUX { int linux_fdatasync(l_uint fd); }
|
|
149 STD LINUX { int linux_sysctl(struct l___sysctl_args *args); }
|
|
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(l_pid_t pid, \
|
|
l_int policy, struct l_sched_param *param); }
|
|
157 STD POSIX { int linux_sched_getscheduler(l_pid_t pid); }
|
|
158 NOPROTO POSIX { int sched_yield(void); }
|
|
159 STD POSIX { int linux_sched_get_priority_max(l_int policy); }
|
|
160 STD POSIX { int linux_sched_get_priority_min(l_int policy); }
|
|
161 NOPROTO POSIX { int sched_rr_get_interval(l_pid_t pid, \
|
|
struct l_timespec *interval); }
|
|
162 MNOPROTO POSIX { int nanosleep(const struct timespec *rqtp, \
|
|
struct timespec *rmtp); }
|
|
163 STD LINUX { int linux_mremap(l_ulong addr, l_ulong old_len, \
|
|
l_ulong new_len, l_ulong flags, \
|
|
l_ulong new_addr); }
|
|
164 STD LINUX { int linux_setresuid16(l_uid16_t ruid, \
|
|
l_uid16_t euid, l_uid16_t suid); }
|
|
165 STD LINUX { int linux_getresuid16(l_uid16_t *ruid, \
|
|
l_uid16_t *euid, l_uid16_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 STD LINUX { int linux_setresgid16(l_gid16_t rgid, \
|
|
l_gid16_t egid, l_gid16_t sgid); }
|
|
171 STD LINUX { int linux_getresgid16(l_gid16_t *rgid, \
|
|
l_gid16_t *egid, l_gid16_t *sgid); }
|
|
172 STD LINUX { int linux_prctl(void); }
|
|
173 STD LINUX { int linux_rt_sigreturn(struct l_ucontext *ucp); }
|
|
174 STD LINUX { int linux_rt_sigaction(l_int sig, \
|
|
l_sigaction_t *act, l_sigaction_t *oact, \
|
|
l_size_t sigsetsize); }
|
|
175 STD LINUX { int linux_rt_sigprocmask(l_int how, \
|
|
l_sigset_t *mask, l_sigset_t *omask, \
|
|
l_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(l_sigset_t *newset, \
|
|
l_size_t sigsetsize); }
|
|
180 STD LINUX { int linux_pread(l_uint fd, char *buf, \
|
|
l_size_t nbyte, l_loff_t offset); }
|
|
181 STD LINUX { int linux_pwrite(l_uint fd, char *buf, \
|
|
l_size_t nbyte, l_loff_t offset); }
|
|
182 STD LINUX { int linux_chown16(char *path, l_uid16_t uid, \
|
|
l_gid16_t gid); }
|
|
183 STD LINUX { int linux_getcwd(char *buf, l_ulong bufsize); }
|
|
184 STD LINUX { int linux_capget(void); }
|
|
185 STD LINUX { int linux_capset(void); }
|
|
186 STD LINUX { int linux_sigaltstack(l_stack_t *uss, \
|
|
l_stack_t *uoss); }
|
|
187 STD LINUX { int linux_sendfile(void); }
|
|
188 UNIMPL LINUX getpmsg
|
|
189 UNIMPL LINUX putpmsg
|
|
190 MSTD LINUX { int linux_vfork(void); }
|
|
191 STD LINUX { int linux_getrlimit(l_uint resource, \
|
|
struct l_rlimit *rlim); }
|
|
192 STD LINUX { int linux_mmap2(l_ulong addr, l_ulong len, \
|
|
l_ulong prot, l_ulong flags, l_ulong fd, \
|
|
l_ulong pgoff); }
|
|
193 STD LINUX { int linux_truncate64(char *path, l_loff_t length); }
|
|
194 STD LINUX { int linux_ftruncate64(l_uint fd, l_loff_t length); }
|
|
195 STD LINUX { int linux_stat64(char *filename, \
|
|
struct l_stat64 *statbuf, l_long flags); }
|
|
196 STD LINUX { int linux_lstat64(char *filename, \
|
|
struct l_stat64 *statbuf, l_long flags); }
|
|
197 STD LINUX { int linux_fstat64(l_ulong fd, \
|
|
struct l_stat64 *statbuf, l_long flags); }
|
|
198 STD LINUX { int linux_lchown(char *filename, l_uid_t user, \
|
|
l_gid_t group); }
|
|
199 STD POSIX { int linux_getuid(void); }
|
|
200 STD POSIX { int linux_getgid(void); }
|
|
201 NOPROTO POSIX { int geteuid(void); }
|
|
202 NOPROTO POSIX { int getegid(void); }
|
|
203 NOPROTO LINUX { int setreuid(uid_t ruid, uid_t euid); }
|
|
204 NOPROTO LINUX { int setregid(gid_t rgid, gid_t egid); }
|
|
205 STD LINUX { int linux_getgroups(l_int gidsetsize, \
|
|
l_gid_t *grouplist); }
|
|
206 STD LINUX { int linux_setgroups(l_int gidsetsize, \
|
|
l_gid_t *grouplist); }
|
|
207 STD LINUX { int linux_fchown(l_uint fd, l_uid_t user, \
|
|
l_gid_t group); }
|
|
208 NOPROTO LINUX { int setresuid(uid_t ruid, uid_t euid, uid_t suid); }
|
|
209 NOPROTO LINUX { int getresuid(uid_t *ruid, uid_t *euid, \
|
|
uid_t *suid); }
|
|
210 NOPROTO LINUX { int setresgid(gid_t rgid, gid_t egid, gid_t sgid); }
|
|
211 NOPROTO LINUX { int getresgid(gid_t *rgid, gid_t *egid, \
|
|
gid_t *sgid); }
|
|
212 STD LINUX { int linux_chown(char *filename, l_uid_t user, \
|
|
l_gid_t group); }
|
|
213 NOPROTO LINUX { int setuid(uid_t uid); }
|
|
214 NOPROTO LINUX { int setgid(gid_t gid); }
|
|
215 STD LINUX { int linux_setfsuid(l_uid_t uid); }
|
|
216 STD LINUX { int linux_setfsgid(l_gid_t gid); }
|
|
217 STD LINUX { int linux_pivot_root(char *new_root, \
|
|
char *put_old); }
|
|
218 STD LINUX { int linux_mincore(l_ulong start, l_size_t len, \
|
|
u_char *vec); }
|
|
219 STD LINUX { int linux_madvise(void); }
|
|
220 STD LINUX { int linux_getdents64(l_uint fd, void *dirent, \
|
|
l_uint count); }
|
|
221 STD LINUX { int linux_fcntl64(l_uint fd, l_uint cmd, \
|
|
l_ulong arg); }
|