Home | History | Annotate | Line # | Download | only in ultrix
syscalls.master revision 1.49 
      1 	$NetBSD: syscalls.master,v 1.49 2009/01/13 22:27:44 pooka Exp $
      2 
      3 ;	@(#)syscalls.master	8.1 (Berkeley) 7/19/93
      4 
      5 ; NetBSD COMPAT_ULTRIX system call name/number "master" file.
      6 ; (See syscalls.conf to see what it is processed into.)
      7 ;
      8 ; Fields: number type [type-dependent ...]
      9 ;	number	system call number, must be in order
     10 ;	type	one of STD, OBSOL, UNIMPL, NODEF, NOARGS, or one of
     11 ;		the compatibility options defined in syscalls.conf.
     12 ;
     13 ; types:
     14 ;	STD	always included
     15 ;	OBSOL	obsolete, not included in system
     16 ;	UNIMPL	unimplemented, not included in system
     17 ;	NODEF	included, but don't define the syscall number
     18 ;	NOARGS	included, but don't define the syscall args structure
     19 ;
     20 ; The compat options are defined in the syscalls.conf file, and the
     21 ; compat option name is prefixed to the syscall name.  Other than
     22 ; that, they're like NODEF (for 'compat' options), or STD (for
     23 ; 'libcompat' options).
     24 ;
     25 ; The type-dependent arguments are as follows:
     26 ; For STD, NODEF, NOARGS, and compat syscalls:
     27 ;	{ pseudo-proto } [alias]
     28 ; For other syscalls:
     29 ;	[comment]
     30 ;
     31 ; #ifdef's, etc. may be included, and are copied to the output files.
     32 ; #include's are copied to the syscall names and switch definition files only.
     33 
     34 #if defined(_KERNEL_OPT)
     35 #include "fs_nfs.h"
     36 #endif
     37 
     38 #include <sys/param.h>
     39 #include <sys/systm.h>
     40 #include <sys/signal.h>
     41 #include <sys/mount.h>
     42 #include <sys/sched.h>
     43 #include <sys/syscallargs.h>
     44 #include <compat/ultrix/ultrix_syscallargs.h>
     45 
     46 %%
     47 
     48 0	NOARGS		{ int|sys||nosys(void); } syscall
     49 1	NOARGS		{ int|sys||exit(int rval); }
     50 2	NOARGS		{ int|sys||fork(void); }
     51 3	NOARGS		{ int|sys||read(int fd, char *buf, u_int nbyte); }
     52 4	NOARGS		{ int|sys||write(int fd, char *buf, u_int nbyte); }
     53 5	STD		{ int|ultrix_sys||open(const char *path, int flags, \
     54 			    int mode); }
     55 6	NOARGS		{ int|sys||close(int fd); }
     56 7	NOARGS		{ int|compat_43_sys||wait(void); } owait
     57 8	STD		{ int|ultrix_sys||creat(const char *path, int mode); }
     58 9	NOARGS		{ int|sys||link(char *path, char *link); }
     59 10	NOARGS		{ int|sys||unlink(char *path); }
     60 11	STD		{ int|ultrix_sys||execv(const char *path, char **argp); }
     61 12	NOARGS		{ int|sys||chdir(char *path); }
     62 13	OBSOL		time
     63 14	STD		{ int|ultrix_sys||mknod(const char *path, int mode, \
     64 			    int dev); }
     65 15	NOARGS		{ int|sys||chmod(char *path, int mode); }
     66 16	NOARGS		{ int|sys||__posix_chown(char *path, int uid, int gid); }
     67 17	NOARGS		{ int|sys||obreak(char *nsize); } break
     68 18	OBSOL		stat
     69 19	NOARGS		{ long|compat_43_sys||lseek(int fd, long offset, \
     70 			    int whence); }
     71 20	NOARGS 		{ pid_t|sys||getpid(void); }
     72 21	STD		{ int|ultrix_sys||mount(char *special, char *dir, \
     73 			     int rdonly, int type, void *data); }
     74 22	OBSOL		sysV_unmount
     75 23	NOARGS		{ int|sys||setuid(uid_t uid); }
     76 24	NOARGS		{ uid_t|sys||getuid(void); }
     77 25	OBSOL		v7 stime
     78 26	OBSOL		v7 ptrace
     79 27	OBSOL		v7 alarm
     80 28	OBSOL		v7 fstat
     81 29	OBSOL		v7 pause
     82 30	OBSOL		v7 utime
     83 31	OBSOL		v7 stty
     84 32	OBSOL		v7 gtty
     85 33	STD		{ int|ultrix_sys||access(const char *path, int flags); }
     86 34	OBSOL		v7 nice
     87 35	OBSOL		v7 ftime
     88 36	NOARGS		{ int|sys||sync(void); }
     89 37	NOARGS		{ int|sys||kill(int pid, int signum); }
     90 38	STD		{ int|ultrix_sys||stat(const char *path, \
     91 			    struct stat43 *ub); } stat43
     92 39	OBSOL		v7 setpgrp
     93 40	STD		{ int|ultrix_sys||lstat(const char *path, \
     94 			    struct stat43 *ub); } lstat43
     95 41	NOARGS		{ int|sys||dup(u_int fd); }
     96 42	NOARGS		{ int|sys||pipe(void); }
     97 43	OBSOL		v7 times
     98 44	NOARGS		{ int|sys||profil(void *samples, u_int size, \
     99 			    u_int offset, u_int scale); }
    100 45	UNIMPL
    101 46	OBSOL		v7 setgid
    102 47	NOARGS		{ gid_t|sys||getgid(void); }
    103 48	UNIMPL		ssig
    104 49	UNIMPL		reserved for USG
    105 50	UNIMPL		reserved for USG
    106 51	NOARGS		{ int|sys||acct(char *path); }
    107 52	UNIMPL
    108 53	UNIMPL		syslock
    109 54	STD		{ int|ultrix_sys||ioctl(int fd, u_long com, void *data); }
    110 55	NOARGS		{ int|sys||reboot(int opt); }
    111 56	UNIMPL		v7 mpxchan
    112 57	NOARGS		{ int|sys||symlink(char *path, char *link); }
    113 58	NOARGS		{ int|sys||readlink(char *path, char *buf, int count); }
    114 59	STD		{ int|ultrix_sys||execve(const char *path, char **argp, \
    115 			    char **envp); }
    116 60	NOARGS		{ int|sys||umask(int newmask); }
    117 61	NOARGS		{ int|sys||chroot(char *path); }
    118 62	NOARGS		{ int|compat_43_sys||fstat(int fd, struct stat43 *sb); }
    119 63	UNIMPL
    120 64	NOARGS		{ int|compat_43_sys||getpagesize(void); }
    121 65	UNIMPL		mremap
    122 66	NOARGS		{ int|sys||vfork(void); }
    123 67	OBSOL		vread
    124 68	OBSOL		vwrite
    125 69	NOARGS		{ int|sys||sbrk(intptr_t incr); }
    126 70	NOARGS		{ int|sys||sstk(int incr); }
    127 71	STD		{ int|ultrix_sys||mmap(void *addr, size_t len, \
    128 			    int prot, u_int flags, int fd, long pos); }
    129 72	NOARGS		{ int|sys||ovadvise(int anom); } vadvise
    130 73	NOARGS		{ int|sys||munmap(void *addr, size_t len); }
    131 74	NOARGS		{ int|sys||mprotect(void *addr, size_t len, \
    132 			    int prot); }
    133 75	NOARGS		{ int|sys||madvise(void *addr, size_t len, \
    134 			    int behav); }
    135 76	STD		{ int|ultrix_sys||vhangup(void); }
    136 77	UNIMPL		old vlimit
    137 78	NOARGS		{ int|sys||mincore(void *addr, int len, char *vec); }
    138 79	NOARGS		{ int|sys||getgroups(u_int gidsetsize, gid_t *gidset); }
    139 80	NOARGS		{ int|sys||setgroups(u_int gidsetsize, gid_t *gidset); }
    140 81	NOARGS		{ int|sys||getpgrp(void); }
    141 82	STD		{ int|ultrix_sys||setpgrp(int pid, int pgid); }
    142 83	NOARGS		{ int|sys||setitimer(u_int which, \
    143 			    struct itimerval *itv, struct itimerval *oitv); }
    144 84	STD		{ int|ultrix_sys||wait3(int *status, int options, \
    145 			    struct rusage *rusage);}
    146 85	NOARGS		{ int|compat_12_sys||swapon(char *name); }
    147 86	NOARGS		{ int|sys||getitimer(u_int which, \
    148 			    struct itimerval *itv); }
    149 87	NOARGS		{ int|compat_43_sys||gethostname(char *hostname, \
    150 			    u_int len); }
    151 88	NOARGS		{ int|compat_43_sys||sethostname(char *hostname, \
    152 			    u_int len); }
    153 89	NOARGS		{ int|compat_43_sys||getdtablesize(void); }
    154 90	NOARGS		{ int|sys||dup2(u_int from, u_int to); }
    155 91	UNIMPL		getdopt
    156 92	STD		{ int|ultrix_sys||fcntl(int fd, int cmd, void *arg); }
    157 93	STD		{ int|ultrix_sys||select(u_int nd, fd_set *in, fd_set *ou, \
    158 			    fd_set *ex, struct timeval *tv); }
    159 94	UNIMPL		setdopt
    160 95	NOARGS		{ int|sys||fsync(int fd); }
    161 96	NOARGS		{ int|sys||setpriority(int which, int who, int prio); }
    162 97	NOARGS		{ int|compat_30_sys||socket(int domain, int type, int protocol); }
    163 98	NOARGS		{ int|sys||connect(int s, void *name, int namelen); }
    164 99	NOARGS		{ int|compat_43_sys||accept(int s, void *name, \
    165 			    int *anamelen); }
    166 100	NOARGS		{ int|sys||getpriority(int which, int who); }
    167 101	NOARGS		{ int|compat_43_sys||send(int s, void *buf, int len, \
    168 			    int flags); }
    169 102	NOARGS		{ int|compat_43_sys||recv(int s, void *buf, int len, \
    170 			    int flags); }
    171 103	STD			{ int|ultrix_sys||sigreturn(struct sigcontext * \
    172 							sigcntxp); }
    173 104	NOARGS		{ int|sys||bind(int s, void *name, int namelen); }
    174 105	STD		{ int|ultrix_sys||setsockopt(int s, int level, \
    175 			    int name, void *val, int valsize); }
    176 106	NOARGS		{ int|sys||listen(int s, int backlog); }
    177 107	UNIMPL		vtimes
    178 108	STD		{ int|ultrix_sys||sigvec(int signum, \
    179 			    struct sigvec *nsv, struct sigvec *osv); }
    180 109	NOARGS		{ int|compat_43_sys||sigblock(int mask); }
    181 110	NOARGS		{ int|compat_43_sys||sigsetmask(int mask); }
    182 111	STD			{ int|ultrix_sys||sigsuspend(int mask); }
    183 112	NOARGS		{ int|compat_43_sys||sigstack(struct sigstack *nss, \
    184 			    struct sigstack *oss); }
    185 113	NOARGS		{ int|compat_43_sys||recvmsg(int s, \
    186 			    struct omsghdr *msg, int flags); }
    187 114	NOARGS		{ int|compat_43_sys||sendmsg(int s, void *msg, \
    188 			    int flags); }
    189 115	OBSOL		vtrace
    190 116	NOARGS		{ int|sys||gettimeofday(struct timeval *tp, \
    191 			    struct timezone *tzp); }
    192 117	NOARGS		{ int|sys||getrusage(int who, struct rusage *rusage); }
    193 118	NOARGS		{ int|sys||getsockopt(int s, int level, int name, \
    194 			    void *val, int *avalsize); }
    195 119	UNIMPL		resuba
    196 120	NOARGS		{ int|sys||readv(int fd, struct iovec *iovp, \
    197 			    u_int iovcnt); }
    198 121	NOARGS		{ int|sys||writev(int fd, struct iovec *iovp, \
    199 			    u_int iovcnt); }
    200 122	NOARGS		{ int|sys||settimeofday(struct timeval *tv, \
    201 			    struct timezone *tzp); }
    202 123	NOARGS		{ int|sys||__posix_fchown(int fd, int uid, int gid); }
    203 124	NOARGS		{ int|sys||fchmod(int fd, int mode); }
    204 125	NOARGS		{ int|compat_43_sys||recvfrom(int s, void *buf, \
    205 			    size_t len, int flags, void *from, \
    206 			    int *fromlenaddr); }
    207 126	NOARGS		{ int|sys||setreuid(int ruid, int euid); }
    208 127	NOARGS		{ int|sys||setregid(int rgid, int egid); }
    209 128	NOARGS		{ int|sys||rename(char *from, char *to); }
    210 129	NOARGS		{ int|compat_43_sys||truncate(char *path, long length); }
    211 130	NOARGS		{ int|compat_43_sys||ftruncate(int fd, long length); }
    212 131	NOARGS		{ int|sys||flock(int fd, int how); }
    213 132	UNIMPL
    214 133	NOARGS		{ int|sys||sendto(int s, void *buf, size_t len, \
    215 			    int flags, void *to, int tolen); }
    216 134	NOARGS		{ int|sys||shutdown(int s, int how); }
    217 135	NOARGS		{ int|sys||socketpair(int domain, int type, \
    218 			    int protocol, int *rsv); }
    219 136	NOARGS		{ int|sys||mkdir(char *path, int mode); }
    220 137	NOARGS		{ int|sys||rmdir(char *path); }
    221 138	NOARGS		{ int|sys||utimes(char *path, struct timeval *tptr); }
    222 139	STD		{ int|ultrix_sys||sigcleanup(struct sigcontext *sigcntxp); }
    223 140	NOARGS		{ int|sys||adjtime(struct timeval *delta, \
    224 			    struct timeval *olddelta); }
    225 141	NOARGS		{ int|compat_43_sys||getpeername(int fdes, void *asa, \
    226 			    int *alen); }
    227 142	NOARGS		{ int|compat_43_sys||gethostid(void); }
    228 143	UNIMPL		old sethostid
    229 144	NOARGS		{ int|compat_43_sys||getrlimit(u_int which, \
    230 			    struct orlimit *rlp); }
    231 145	NOARGS		{ int|compat_43_sys||setrlimit(u_int which, \
    232 			    struct orlimit *rlp); }
    233 146	NOARGS		{ int|compat_43_sys||killpg(int pgid, int signum); }
    234 147	UNIMPL
    235 148	UNIMPL		setquota
    236 149	UNIMPL	 	quota /* needs to be nullop to boot on Ultrix root partition*/
    237 150	NOARGS		{ int|compat_43_sys||getsockname(int fdes, void *asa, \
    238 			    int *alen); }
    239 151	UNIMPL		sysmips /* 4 args */
    240 #ifdef __mips
    241 152	STD		{ int|ultrix_sys||cacheflush(char *addr, int nbytes, \
    242 			    int whichcache); }
    243 153	STD	{ int|ultrix_sys||cachectl(char *addr, int nbytes, int cacheop); }
    244 #else	/* !mips */
    245 152	UNIMPL
    246 153	UNIMPL
    247 #endif	/* !mips */
    248 154	UNIMPL
    249 155	UNIMPL		atomic_op
    250 156	UNIMPL
    251 157	UNIMPL
    252 158	STD		{ int|ultrix_sys||nfssvc(int fd); }
    253 159	NOARGS		{ int|compat_43_sys||getdirentries(int fd, char *buf, \
    254 			    u_int count, long *basep); }
    255 160	STD		{ int|ultrix_sys||statfs(const char *path, \
    256 			    struct ultrix_statfs *buf); }
    257 161	STD		{ int|ultrix_sys||fstatfs(int fd, \
    258 			    struct ultrix_statfs *buf); }
    259 162	UNIMPL		umount
    260 #ifdef NFS
    261 163	NOARGS		{ int|async||daemon(void); }
    262 164	NOARGS		{ int|compat_30_sys||getfh(char *fname, fhandle_t *fhp); }
    263 #else
    264 163	UNIMPL		async_daemon
    265 164	UNIMPL		getfh
    266 #endif
    267 165	NOARGS		{ int|compat_09_sys||getdomainname(char *domainname, \
    268 			    int len); }
    269 166	NOARGS		{ int|compat_09_sys||setdomainname(char *domainname, \
    270 			    int len); }
    271 167	UNIMPL
    272 168	STD		{ int|ultrix_sys||quotactl(int cmd, char *special, \
    273 			    int uid, void *addr); }
    274 169	STD		{ int|ultrix_sys||exportfs(char *path, char *ex); }
    275 170	UNIMPL		ultrix_sys_mount
    276 171	UNIMPL	4 hdwconf
    277 172	UNIMPL		msgctl
    278 173	UNIMPL		msgget
    279 174	UNIMPL		msgrcv
    280 175	UNIMPL		msgsnd
    281 176	UNIMPL		semctl
    282 177	UNIMPL		semget
    283 178	UNIMPL		semop
    284 179	STD		{ int|ultrix_sys||uname(struct ultrix_utsname *name); }
    285 180	STD		{ int|ultrix_sys||shmsys(u_int shmop, \
    286 						u_int a2, u_int a3, u_int a4); }
    287 181	UNIMPL	0 plock
    288 182	UNIMPL	0 lockf
    289 183	STD		{ int|ultrix_sys||ustat(int dev, \
    290 			    struct ultrix_ustat *buf); }
    291 184	STD		{ int|ultrix_sys||getmnt(int *start, \
    292 				struct ultrix_fs_data *buf, \
    293 				int bufsize, int mode, char *path); }
    294 185	UNIMPL	 	notdef
    295 186	UNIMPL	 	notdef
    296 187	STD		{ int|ultrix_sys||sigpending(int *mask); }
    297 188	NOARGS		{ int|sys||setsid(void); }
    298 189	STD		{ int|ultrix_sys||waitpid(int pid, int *status, \
    299 			    int options); }
    300 190	UNIMPL
    301 191	UNIMPL
    302 192	UNIMPL
    303 193	UNIMPL
    304 194	UNIMPL
    305 195	UNIMPL
    306 196	UNIMPL
    307 197	UNIMPL
    308 198	UNIMPL
    309 199	UNIMPL
    310 200	UNIMPL
    311 201	UNIMPL
    312 202	UNIMPL
    313 203	UNIMPL
    314 204	UNIMPL
    315 205	UNIMPL
    316 206	UNIMPL
    317 207	UNIMPL
    318 208	UNIMPL
    319 209	UNIMPL
    320 210	UNIMPL
    321 211	UNIMPL
    322 212	UNIMPL
    323 213	UNIMPL
    324 214	UNIMPL
    325 215	UNIMPL
    326 216	UNIMPL
    327 217	UNIMPL
    328 218	UNIMPL
    329 219	UNIMPL
    330 220	UNIMPL
    331 221	UNIMPL
    332 222	UNIMPL
    333 223	UNIMPL
    334 224	UNIMPL
    335 225	UNIMPL
    336 226	UNIMPL
    337 227	UNIMPL
    338 228	UNIMPL
    339 229	UNIMPL
    340 230	UNIMPL
    341 231	UNIMPL
    342 232	UNIMPL
    343 233	UNIMPL	1 utc_gettime
    344 234	UNIMPL	2 utc_adjtime
    345 235	UNIMPL
    346 236	UNIMPL
    347 237	UNIMPL
    348 238	UNIMPL
    349 239	UNIMPL
    350 240	UNIMPL
    351 241	UNIMPL
    352 242	UNIMPL
    353 243	UNIMPL
    354 244	UNIMPL
    355 245	UNIMPL
    356 246	UNIMPL
    357 247	UNIMPL
    358 248	UNIMPL
    359 249	UNIMPL
    360 250	UNIMPL
    361 251	UNIMPL
    362 252     UNIMPL  	audctl /*Make no-op for installation on Ultrix rootpartition?*/
    363 253	UNIMPL		audgen /*Make no-op for installation on Ultrix rootpartition?*/
    364 254	UNIMPL		startcpu
    365 255	UNIMPL		stopcpu
    366 256	STD		{ int|ultrix_sys||getsysinfo(unsigned op, char *buffer, \
    367 			    unsigned nbytes, int *start, char *arg); }
    368 257	STD		{ int|ultrix_sys||setsysinfo(unsigned op, char *buffer, \
    369 			    unsigned nbytes, unsigned arg, unsigned flag); }
    370 
    371