$NetBSD: syscalls.master,v 1.58 2019/03/03 22:26:30 pgoyette Exp $

;       @(#)syscalls.master     8.1 (Berkeley) 7/19/93

; NetBSD COMPAT_ULTRIX system call name/number "master" file.
; (See syscalls.conf to see what it is processed into.)
;
; Fields: number type [type-dependent ...]
;       number  system call number, must be in order
;       type    one of STD, OBSOL, UNIMPL, NODEF, NOARGS, or one of
;               the compatibility options defined in syscalls.conf.
;
; types:
;       STD     always included
;       OBSOL   obsolete, not included in system
;       UNIMPL  unimplemented, not included in system
;       NODEF   included, but don't define the syscall number
;       NOARGS  included, but don't define the syscall args structure
;
; The compat options are defined in the syscalls.conf file, and the
; compat option name is prefixed to the syscall name.  Other than
; that, they're like NODEF (for 'compat' options), or STD (for
; 'libcompat' options).
;
; The type-dependent arguments are as follows:
; For STD, NODEF, NOARGS, and compat syscalls:
;       { pseudo-proto } [alias]
; For other syscalls:
;       [comment]
;
; #ifdef's, etc. may be included, and are copied to the output files.
; #include's are copied to the syscall names and switch definition files only.

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/signal.h>
#include <sys/mount.h>
#include <sys/sched.h>
#include <sys/syscallargs.h>
#include <compat/ultrix/ultrix_syscallargs.h>

%%

0       NOARGS          { int|sys||nosys(void); } syscall
1       NOARGS          { int|sys||exit(int rval); }
2       NOARGS          { int|sys||fork(void); }
3       NOARGS          { int|sys||read(int fd, char *buf, u_int nbyte); }
4       NOARGS          { int|sys||write(int fd, char *buf, u_int nbyte); }
5       STD             { int|ultrix_sys||open(const char *path, int flags, \
                           int mode); }
6       NOARGS          { int|sys||close(int fd); }
7       NOARGS          { int|compat_43_sys||wait(void); } owait
8       STD             { int|ultrix_sys||creat(const char *path, int mode); }
9       NOARGS          { int|sys||link(char *path, char *link); }
10      NOARGS          { int|sys||unlink(char *path); }
11      STD             { int|ultrix_sys||execv(const char *path, char **argp); }
12      NOARGS          { int|sys||chdir(char *path); }
13      OBSOL           time
14      STD             { int|ultrix_sys||mknod(const char *path, int mode, \
                           int dev); }
15      NOARGS          { int|sys||chmod(char *path, int mode); }
16      NOARGS          { int|sys||__posix_chown(char *path, int uid, int gid); }
17      NOARGS          { int|sys||obreak(char *nsize); } break
18      OBSOL           stat
19      NOARGS          { long|compat_43_sys||lseek(int fd, long offset, \
                           int whence); }
20      NOARGS          { pid_t|sys||getpid(void); }
21      STD             { int|ultrix_sys||mount(char *special, char *dir, \
                            int rdonly, int type, void *data); }
22      OBSOL           sysV_unmount
23      NOARGS          { int|sys||setuid(uid_t uid); }
24      NOARGS          { uid_t|sys||getuid(void); }
25      OBSOL           v7 stime
26      OBSOL           v7 ptrace
27      OBSOL           v7 alarm
28      OBSOL           v7 fstat
29      OBSOL           v7 pause
30      OBSOL           v7 utime
31      OBSOL           v7 stty
32      OBSOL           v7 gtty
33      STD             { int|ultrix_sys||access(const char *path, int flags); }
34      OBSOL           v7 nice
35      OBSOL           v7 ftime
36      NOARGS          { int|sys||sync(void); }
37      NOARGS          { int|sys||kill(int pid, int signum); }
38      STD             { int|ultrix_sys||stat(const char *path, \
                           struct stat43 *ub); } stat43
39      OBSOL           v7 setpgrp
40      STD             { int|ultrix_sys||lstat(const char *path, \
                           struct stat43 *ub); } lstat43
41      NOARGS          { int|sys||dup(int fd); }
42      NOARGS          { int|sys||pipe(void); }
43      OBSOL           v7 times
44      NOARGS          { int|sys||profil(void *samples, u_int size, \
                           u_int offset, u_int scale); }
45      UNIMPL
46      OBSOL           v7 setgid
47      NOARGS          { gid_t|sys||getgid(void); }
48      UNIMPL          ssig
49      UNIMPL          reserved for USG
50      UNIMPL          reserved for USG
51      NOARGS          { int|sys||acct(char *path); }
52      UNIMPL
53      UNIMPL          syslock
54      STD             { int|ultrix_sys||ioctl(int fd, u_long com, void *data); }
55      NOARGS          { int|sys||reboot(int opt); }
56      UNIMPL          v7 mpxchan
57      NOARGS          { int|sys||symlink(char *path, char *link); }
58      NOARGS          { int|sys||readlink(char *path, char *buf, int count); }
59      STD             { int|ultrix_sys||execve(const char *path, char **argp, \
                           char **envp); }
60      NOARGS          { int|sys||umask(int newmask); }
61      NOARGS          { int|sys||chroot(char *path); }
62      NOARGS          { int|compat_43_sys||fstat(int fd, struct stat43 *sb); }
63      UNIMPL
64      NOARGS          { int|compat_43_sys||getpagesize(void); }
65      UNIMPL          mremap
66      NOARGS          { int|sys||vfork(void); }
67      OBSOL           vread
68      OBSOL           vwrite
69      OBSOL           sbrk
70      OBSOL           sstk
71      STD             { int|ultrix_sys||mmap(void *addr, size_t len, \
                           int prot, u_int flags, int fd, long pos); }
72      NOARGS          { int|sys||ovadvise(int anom); } vadvise
73      NOARGS          { int|sys||munmap(void *addr, size_t len); }
74      NOARGS          { int|sys||mprotect(void *addr, size_t len, \
                           int prot); }
75      NOARGS          { int|sys||madvise(void *addr, size_t len, \
                           int behav); }
76      STD             { int|ultrix_sys||vhangup(void); }
77      UNIMPL          old vlimit
78      NOARGS          { int|sys||mincore(void *addr, int len, char *vec); }
79      NOARGS          { int|sys||getgroups(u_int gidsetsize, gid_t *gidset); }
80      NOARGS          { int|sys||setgroups(u_int gidsetsize, gid_t *gidset); }
81      NOARGS          { int|sys||getpgrp(void); }
82      STD             { int|ultrix_sys||setpgrp(int pid, int pgid); }
83      NOARGS          { int|sys|50|setitimer(u_int which, \
                           struct itimerval50 *itv, struct itimerval50 *oitv); }
84      STD             { int|ultrix_sys||wait3(int *status, int options, \
                           struct rusage50 *rusage);}
85      NOARGS          { int|compat_12_sys||swapon(char *name); }
86      NOARGS          { int|sys|50|getitimer(u_int which, \
                           struct itimerval50 *itv); }
87      NOARGS          { int|compat_43_sys||gethostname(char *hostname, \
                           u_int len); }
88      NOARGS          { int|compat_43_sys||sethostname(char *hostname, \
                           u_int len); }
89      NOARGS          { int|compat_43_sys||getdtablesize(void); }
90      NOARGS          { int|sys||dup2(int from, int to); }
91      UNIMPL          getdopt
92      STD             { int|ultrix_sys||fcntl(int fd, int cmd, void *arg); }
93      STD             { int|ultrix_sys||select(u_int nd, fd_set *in, fd_set *ou, \
                           fd_set *ex, struct timeval50 *tv); }
94      UNIMPL          setdopt
95      NOARGS          { int|sys||fsync(int fd); }
96      NOARGS          { int|sys||setpriority(int which, int who, int prio); }
97      NOARGS          { int|compat_30_sys||socket(int domain, int type, int protocol); }
98      NOARGS          { int|sys||connect(int s, void *name, int namelen); }
99      NOARGS          { int|compat_43_sys||accept(int s, void *name, \
                           int *anamelen); }
100     NOARGS          { int|sys||getpriority(int which, int who); }
101     NOARGS          { int|compat_43_sys||send(int s, void *buf, int len, \
                           int flags); }
102     NOARGS          { int|compat_43_sys||recv(int s, void *buf, int len, \
                           int flags); }
103     STD                     { int|ultrix_sys||sigreturn(struct sigcontext * \
                                                       sigcntxp); }
104     NOARGS          { int|sys||bind(int s, void *name, int namelen); }
105     STD             { int|ultrix_sys||setsockopt(int s, int level, \
                           int name, void *val, int valsize); }
106     NOARGS          { int|sys||listen(int s, int backlog); }
107     UNIMPL          vtimes
108     STD             { int|ultrix_sys||sigvec(int signum, \
                           struct sigvec *nsv, struct sigvec *osv); }
109     NOARGS          { int|compat_43_sys||sigblock(int mask); }
110     NOARGS          { int|compat_43_sys||sigsetmask(int mask); }
111     STD                     { int|ultrix_sys||sigsuspend(int mask); }
112     NOARGS          { int|compat_43_sys||sigstack(struct sigstack *nss, \
                           struct sigstack *oss); }
113     NOARGS          { int|compat_43_sys||recvmsg(int s, \
                           struct omsghdr *msg, int flags); }
114     NOARGS          { int|compat_43_sys||sendmsg(int s, void *msg, \
                           int flags); }
115     OBSOL           vtrace
116     NOARGS          { int|sys|50|gettimeofday(struct timeval50 *tp, \
                           struct timezone *tzp); }
117     NOARGS          { int|sys|50|getrusage(int who, struct rusage50 *rusage); }
118     NOARGS          { int|sys||getsockopt(int s, int level, int name, \
                           void *val, int *avalsize); }
119     UNIMPL          resuba
120     NOARGS          { int|sys||readv(int fd, struct iovec *iovp, \
                           u_int iovcnt); }
121     NOARGS          { int|sys||writev(int fd, struct iovec *iovp, \
                           u_int iovcnt); }
122     NOARGS          { int|sys|50|settimeofday(struct timeval50 *tv, \
                           struct timezone *tzp); }
123     NOARGS          { int|sys||__posix_fchown(int fd, int uid, int gid); }
124     NOARGS          { int|sys||fchmod(int fd, int mode); }
125     NOARGS          { int|compat_43_sys||recvfrom(int s, void *buf, \
                           size_t len, int flags, void *from, \
                           int *fromlenaddr); }
126     NOARGS          { int|sys||setreuid(int ruid, int euid); }
127     NOARGS          { int|sys||setregid(int rgid, int egid); }
128     NOARGS          { int|sys||rename(char *from, char *to); }
129     NOARGS          { int|compat_43_sys||truncate(char *path, long length); }
130     NOARGS          { int|compat_43_sys||ftruncate(int fd, long length); }
131     NOARGS          { int|sys||flock(int fd, int how); }
132     UNIMPL
133     NOARGS          { int|sys||sendto(int s, void *buf, size_t len, \
                           int flags, void *to, int tolen); }
134     NOARGS          { int|sys||shutdown(int s, int how); }
135     NOARGS          { int|sys||socketpair(int domain, int type, \
                           int protocol, int *rsv); }
136     NOARGS          { int|sys||mkdir(char *path, int mode); }
137     NOARGS          { int|sys||rmdir(char *path); }
138     NOARGS          { int|sys|50|utimes(char *path, struct timeval50 *tptr); }
139     STD             { int|ultrix_sys||sigcleanup(struct sigcontext *sigcntxp); }
140     NOARGS          { int|sys|50|adjtime(struct timeval50 *delta, \
                           struct timeval50 *olddelta); }
141     NOARGS          { int|compat_43_sys||getpeername(int fdes, void *asa, \
                           int *alen); }
142     NOARGS          { int|compat_43_sys||gethostid(void); }
143     UNIMPL          old sethostid
144     NOARGS          { int|compat_43_sys||getrlimit(u_int which, \
                           struct orlimit *rlp); }
145     NOARGS          { int|compat_43_sys||setrlimit(u_int which, \
                           struct orlimit *rlp); }
146     NOARGS          { int|compat_43_sys||killpg(int pgid, int signum); }
147     UNIMPL
148     UNIMPL          setquota
149     UNIMPL          quota /* needs to be nullop to boot on Ultrix root partition*/
150     NOARGS          { int|compat_43_sys||getsockname(int fdes, void *asa, \
                           int *alen); }
151     UNIMPL          sysmips /* 4 args */
#ifdef __mips
152     STD             { int|ultrix_sys||cacheflush(char *addr, int nbytes, \
                           int whichcache); }
153     STD     { int|ultrix_sys||cachectl(char *addr, int nbytes, int cacheop); }
#else   /* !mips */
152     UNIMPL
153     UNIMPL
#endif  /* !mips */
154     UNIMPL
155     UNIMPL          atomic_op
156     UNIMPL
157     UNIMPL
158     UNIMPL          ultrix_sys_nfssvc
159     NOARGS          { int|compat_43_sys||getdirentries(int fd, char *buf, \
                           u_int count, long *basep); }
160     STD             { int|ultrix_sys||statfs(const char *path, \
                           struct ultrix_statfs *buf); }
161     STD             { int|ultrix_sys||fstatfs(int fd, \
                           struct ultrix_statfs *buf); }
162     UNIMPL          umount
163     UNIMPL          async_daemon
164     NOARGS          { int|compat_30_sys||getfh(char *fname, fhandle_t *fhp); }
165     NOARGS MODULAR compat_09 \
                       { int|compat_09_sys||getdomainname(char *domainname, \
                           int len); }
166     NOARGS MODULAR compat_09 \
                       { int|compat_09_sys||setdomainname(char *domainname, \
                           int len); }
167     UNIMPL
168     STD             { int|ultrix_sys||quotactl(int cmd, char *special, \
                           int uid, void *addr); }
169     STD             { int|ultrix_sys||exportfs(char *path, char *ex); }
170     UNIMPL          ultrix_sys_mount
171     UNIMPL  4 hdwconf
172     UNIMPL          msgctl
173     UNIMPL          msgget
174     UNIMPL          msgrcv
175     UNIMPL          msgsnd
176     UNIMPL          semctl
177     UNIMPL          semget
178     UNIMPL          semop
179     STD             { int|ultrix_sys||uname(struct ultrix_utsname *name); }
180     STD             { int|ultrix_sys||shmsys(u_int shmop, \
                                               u_int a2, u_int a3, u_int a4); }
181     UNIMPL  0 plock
182     UNIMPL  0 lockf
183     STD             { int|ultrix_sys||ustat(int dev, \
                           struct ultrix_ustat *buf); }
184     STD             { int|ultrix_sys||getmnt(int *start, \
                               struct ultrix_fs_data *buf, \
                               int bufsize, int mode, char *path); }
185     UNIMPL          notdef
186     UNIMPL          notdef
187     STD             { int|ultrix_sys||sigpending(int *mask); }
188     NOARGS          { int|sys||setsid(void); }
189     STD             { int|ultrix_sys||waitpid(int pid, int *status, \
                           int options); }
190     UNIMPL
191     UNIMPL
192     UNIMPL
193     UNIMPL
194     UNIMPL
195     UNIMPL
196     UNIMPL
197     UNIMPL
198     UNIMPL
199     UNIMPL
200     UNIMPL
201     UNIMPL
202     UNIMPL
203     UNIMPL
204     UNIMPL
205     UNIMPL
206     UNIMPL
207     UNIMPL
208     UNIMPL
209     UNIMPL
210     UNIMPL
211     UNIMPL
212     UNIMPL
213     UNIMPL
214     UNIMPL
215     UNIMPL
216     UNIMPL
217     UNIMPL
218     UNIMPL
219     UNIMPL
220     UNIMPL
221     UNIMPL
222     UNIMPL
223     UNIMPL
224     UNIMPL
225     UNIMPL
226     UNIMPL
227     UNIMPL
228     UNIMPL
229     UNIMPL
230     UNIMPL
231     UNIMPL
232     UNIMPL
233     UNIMPL  1 utc_gettime
234     UNIMPL  2 utc_adjtime
235     UNIMPL
236     UNIMPL
237     UNIMPL
238     UNIMPL
239     UNIMPL
240     UNIMPL
241     UNIMPL
242     UNIMPL
243     UNIMPL
244     UNIMPL
245     UNIMPL
246     UNIMPL
247     UNIMPL
248     UNIMPL
249     UNIMPL
250     UNIMPL
251     UNIMPL
252     UNIMPL          audctl /*Make no-op for installation on Ultrix rootpartition?*/
253     UNIMPL          audgen /*Make no-op for installation on Ultrix rootpartition?*/
254     UNIMPL          startcpu
255     UNIMPL          stopcpu
256     STD             { int|ultrix_sys||getsysinfo(unsigned op, char *buffer, \
                           unsigned nbytes, int *start, char *arg); }
257     STD             { int|ultrix_sys||setsysinfo(unsigned op, char *buffer, \
                           unsigned nbytes, unsigned arg, unsigned flag); }

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.