Annotation of sys/compat/svr4/syscalls.master, Revision 1.1
1.1 ! nbrk 1: $OpenBSD: syscalls.master,v 1.33 2003/01/30 03:29:49 millert Exp $
! 2: ; $NetBSD: syscalls.master,v 1.17 1996/02/10 17:12:51 christos Exp $
! 3:
! 4: ; @(#)syscalls.master 8.1 (Berkeley) 7/19/93
! 5:
! 6: ; OpenBSD COMPAT_SVR4 system call name/number "master" file.
! 7: ; (See syscalls.conf to see what it is processed into.)
! 8: ;
! 9: ; Fields: number type [type-dependent ...]
! 10: ; number system call number, must be in order
! 11: ; type one of STD, OBSOL, UNIMPL, NODEF, NOARGS, or one of
! 12: ; the compatibility options defined in syscalls.conf.
! 13: ;
! 14: ; types:
! 15: ; STD always included
! 16: ; OBSOL obsolete, not included in system
! 17: ; UNIMPL unimplemented, not included in system
! 18: ; NODEF included, but don't define the syscall number
! 19: ; NOARGS included, but don't define the syscall args structure
! 20: ;
! 21: ; The compat options are defined in the syscalls.conf file, and the
! 22: ; compat option name is prefixed to the syscall name. Other than
! 23: ; that, they're like NODEF (for 'compat' options), or STD (for
! 24: ; 'libcompat' options).
! 25: ;
! 26: ; The type-dependent arguments are as follows:
! 27: ; For STD, NODEF, NOARGS, and compat syscalls:
! 28: ; { pseudo-proto } [alias]
! 29: ; For other syscalls:
! 30: ; [comment]
! 31: ;
! 32: ; #ifdef's, etc. may be included, and are copied to the output files.
! 33: ; #include's are copied to the syscall switch definition file only.
! 34:
! 35: #include <sys/param.h>
! 36: #include <sys/systm.h>
! 37: #include <sys/signal.h>
! 38: #include <sys/mount.h>
! 39: #include <sys/syscallargs.h>
! 40:
! 41: #include <compat/svr4/svr4_types.h>
! 42: #include <compat/svr4/svr4_time.h>
! 43: #include <compat/svr4/svr4_signal.h>
! 44: #include <compat/svr4/svr4_ucontext.h>
! 45: #include <compat/svr4/svr4_syscallargs.h>
! 46: #include <compat/svr4/svr4_statvfs.h>
! 47: #include <compat/svr4/svr4_acl.h>
! 48:
! 49: 0 NOARGS { int sys_nosys(void); } syscall
! 50: 1 NOARGS { int sys_exit(int rval); }
! 51: 2 NOARGS { int sys_fork(void); }
! 52: 3 NOARGS { int sys_read(int fd, char *buf, u_int nbyte); }
! 53: 4 NOARGS { int sys_write(int fd, char *buf, u_int nbyte); }
! 54: 5 STD { int svr4_sys_open(char *path, int flags, int mode); }
! 55: 6 NOARGS { int sys_close(int fd); }
! 56: 7 STD { int svr4_sys_wait(int *status); }
! 57: 8 STD { int svr4_sys_creat(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 svr4_sys_execv(char *path, char **argp); }
! 61: 12 NOARGS { int sys_chdir(char *path); }
! 62: 13 STD { int svr4_sys_time(svr4_time_t *t); }
! 63: 14 STD { int svr4_sys_mknod(char *path, int mode, int dev); }
! 64: 15 NOARGS { int sys_chmod(char *path, int mode); }
! 65: 16 NOARGS { int sys_chown(char *path, int uid, int gid); }
! 66: 17 STD { int svr4_sys_break(caddr_t nsize); }
! 67: 18 STD { int svr4_sys_stat(char *path, struct svr4_stat* ub); }
! 68: 19 NOARGS { long compat_43_sys_lseek(int fd, long offset, \
! 69: int whence); }
! 70: 20 NOARGS { pid_t sys_getpid(void); }
! 71: 21 UNIMPL old_mount
! 72: 22 UNIMPL System V umount
! 73: 23 NOARGS { int sys_setuid(uid_t uid); }
! 74: 24 NOARGS { uid_t sys_getuid(void); }
! 75: 25 UNIMPL stime
! 76: 26 UNIMPL ptrace
! 77: 27 STD { int svr4_sys_alarm(unsigned sec); }
! 78: 28 STD { int svr4_sys_fstat(int fd, struct svr4_stat *sb); }
! 79: 29 STD { int svr4_sys_pause(void); }
! 80: 30 STD { int svr4_sys_utime(char *path, \
! 81: struct svr4_utimbuf *ubuf); }
! 82: 31 UNIMPL was stty
! 83: 32 UNIMPL was gtty
! 84: 33 STD { int svr4_sys_access(char *path, int flags); }
! 85: 34 STD { int svr4_sys_nice(int prio); }
! 86: 35 UNIMPL statfs
! 87: 36 NOARGS { int sys_sync(void); }
! 88: 37 STD { int svr4_sys_kill(int pid, int signum); }
! 89: 38 UNIMPL fstatfs
! 90: 39 STD { int svr4_sys_pgrpsys(int cmd, int pid, int pgid); }
! 91: 40 UNIMPL xenix
! 92: 41 NOARGS { int sys_dup(u_int fd); }
! 93: 42 NOARGS { int sys_opipe(void); }
! 94: 43 STD { int svr4_sys_times(struct tms *tp); }
! 95: 44 UNIMPL profil
! 96: 45 UNIMPL plock
! 97: 46 NOARGS { int sys_setgid(gid_t gid); }
! 98: 47 NOARGS { gid_t sys_getgid(void); }
! 99: 48 STD { int svr4_sys_signal(int signum, svr4_sig_t handler); }
! 100: #ifdef SYSVMSG
! 101: 49 STD { int svr4_sys_msgsys(int what, int a2, int a3, \
! 102: int a4, int a5); }
! 103: #else
! 104: 49 UNIMPL msgsys
! 105: #endif
! 106: 50 STD { int svr4_sys_sysarch(int op, void *a1); }
! 107: 51 UNIMPL acct
! 108: #ifdef SYSVSHM
! 109: 52 STD { int svr4_sys_shmsys(int what, int a2, int a3, \
! 110: int a4); }
! 111: #else
! 112: 52 UNIMPL shmsys
! 113: #endif
! 114: #ifdef SYSVSEM
! 115: 53 STD { int svr4_sys_semsys(int what, int a2, int a3, \
! 116: int a4, int a5); }
! 117: #else
! 118: 53 UNIMPL semsys
! 119: #endif
! 120: 54 STD { int svr4_sys_ioctl(int fd, u_long com, \
! 121: caddr_t data); }
! 122: 55 UNIMPL uadmin
! 123: 56 UNIMPL exch
! 124: 57 STD { int svr4_sys_utssys(void *a1, void *a2, int sel, \
! 125: void *a3); }
! 126: 58 NOARGS { int sys_fsync(int fd); }
! 127: 59 STD { int svr4_sys_execve(char *path, char **argp, \
! 128: char **envp); }
! 129: 60 NOARGS { int sys_umask(int newmask); }
! 130: 61 NOARGS { int sys_chroot(char *path); }
! 131: 62 STD { int svr4_sys_fcntl(int fd, int cmd, char *arg); }
! 132: 63 STD { long svr4_sys_ulimit(int cmd, long newlimit); }
! 133: 64 UNIMPL reserved for unix/pc
! 134: 65 UNIMPL reserved for unix/pc
! 135: 66 UNIMPL reserved for unix/pc
! 136: 67 UNIMPL reserved for unix/pc
! 137: 68 UNIMPL reserved for unix/pc
! 138: 69 UNIMPL reserved for unix/pc
! 139: 70 OBSOL advfs
! 140: 71 OBSOL unadvfs
! 141: 72 OBSOL rmount
! 142: 73 OBSOL rumount
! 143: 74 OBSOL rfstart
! 144: 75 OBSOL sigret
! 145: 76 STD { int svr4_sys_rdebug(void); }
! 146: 77 OBSOL rfstop
! 147: 78 UNIMPL rfsys
! 148: 79 NOARGS { int sys_rmdir(char *path); }
! 149: 80 NOARGS { int sys_mkdir(char *path, int mode); }
! 150: 81 STD { int svr4_sys_getdents(int fd, char *buf, \
! 151: int nbytes); }
! 152: 82 OBSOL libattach
! 153: 83 OBSOL libdetach
! 154: 84 UNIMPL sysfs
! 155: 85 STD { int svr4_sys_getmsg(int fd, struct svr4_strbuf *ctl, \
! 156: struct svr4_strbuf *dat, int *flags); }
! 157: 86 STD { int svr4_sys_putmsg(int fd, struct svr4_strbuf *ctl, \
! 158: struct svr4_strbuf *dat, int flags); }
! 159: 87 NOARGS { int sys_poll(struct pollfd *fds, u_long nfds, \
! 160: int timeout); }
! 161: 88 STD { int svr4_sys_lstat(char *path, \
! 162: struct svr4_stat *ub); }
! 163: 89 NOARGS { int sys_symlink(char *path, char *link); }
! 164: 90 NOARGS { int sys_readlink(char *path, char *buf, int count); }
! 165: 91 NOARGS { int sys_getgroups(u_int gidsetsize, gid_t *gidset); }
! 166: 92 NOARGS { int sys_setgroups(u_int gidsetsize, gid_t *gidset); }
! 167: 93 NOARGS { int sys_fchmod(int fd, int mode); }
! 168: 94 NOARGS { int sys_fchown(int fd, int uid, int gid); }
! 169: 95 STD { int svr4_sys_sigprocmask(int how, \
! 170: svr4_sigset_t *set, svr4_sigset_t *oset); }
! 171: 96 STD { int svr4_sys_sigsuspend(svr4_sigset_t *ss); }
! 172: 97 STD { int svr4_sys_sigaltstack( \
! 173: struct svr4_sigaltstack *nss, \
! 174: struct svr4_sigaltstack *oss); }
! 175: 98 STD { int svr4_sys_sigaction(int signum, \
! 176: struct svr4_sigaction *nsa, \
! 177: struct svr4_sigaction *osa); }
! 178: 99 STD { int svr4_sys_sigpending(int what, \
! 179: svr4_sigset_t *mask); }
! 180: 100 STD { int svr4_sys_context(int func, \
! 181: struct svr4_ucontext *uc); }
! 182: 101 UNIMPL evsys
! 183: 102 UNIMPL evtrapret
! 184: 103 STD { int svr4_sys_statvfs(char *path, \
! 185: struct svr4_statvfs *fs); }
! 186: 104 STD { int svr4_sys_fstatvfs(int fd, \
! 187: struct svr4_statvfs *fs); }
! 188: 105 UNIMPL
! 189: 106 UNIMPL nfssvc
! 190: 107 STD { int svr4_sys_waitsys(int grp, int id, \
! 191: union svr4_siginfo *info, int options); }
! 192: 108 UNIMPL sigsendsys
! 193: 109 STD { int svr4_sys_hrtsys(int cmd, int fun, int sub, \
! 194: void *rv1, void *rv2); }
! 195: 110 UNIMPL acancel
! 196: 111 UNIMPL async
! 197: 112 UNIMPL priocntlsys
! 198: 113 STD { int svr4_sys_pathconf(char *path, int name); }
! 199: 114 NOARGS { int sys_mincore(caddr_t addr, int len, char *vec); }
! 200: 115 STD { int svr4_sys_mmap(svr4_caddr_t addr, \
! 201: svr4_size_t len, int prot, int flags, int fd, \
! 202: svr4_off_t pos); }
! 203: 116 NOARGS { int sys_mprotect(caddr_t addr, int len, int prot); }
! 204: 117 NOARGS { int sys_munmap(caddr_t addr, int len); }
! 205: 118 STD { int svr4_sys_fpathconf(int fd, int name); }
! 206: 119 NOARGS { int sys_vfork(void); }
! 207: 120 NOARGS { int sys_fchdir(int fd); }
! 208: 121 NOARGS { int sys_readv(int fd, struct iovec *iovp, u_int iovcnt); }
! 209: 122 NOARGS { int sys_writev(int fd, struct iovec *iovp, \
! 210: u_int iovcnt); }
! 211: 123 STD { int svr4_sys_xstat(int two, char *path, \
! 212: struct svr4_xstat *ub); }
! 213: 124 STD { int svr4_sys_lxstat(int two, char *path, \
! 214: struct svr4_xstat *ub); }
! 215: 125 STD { int svr4_sys_fxstat(int two, int fd, \
! 216: struct svr4_xstat *sb); }
! 217: 126 STD { int svr4_sys_xmknod(int two, char *path, \
! 218: svr4_mode_t mode, svr4_dev_t dev); }
! 219: 127 UNIMPL clocal
! 220: 128 STD { int svr4_sys_setrlimit(int which, \
! 221: struct ogetrlimit *rlp); }
! 222: 129 STD { int svr4_sys_getrlimit(int which, \
! 223: struct ogetrlimit *rlp); }
! 224: 130 NOARGS { int sys_lchown(char *path, int uid, int gid); }
! 225: 131 STD { int svr4_sys_memcntl(svr4_caddr_t addr, \
! 226: svr4_size_t len, int cmd, svr4_caddr_t arg, \
! 227: int attr, int mask); }
! 228: 132 UNIMPL getpmsg
! 229: 133 UNIMPL putpmsg
! 230: 134 NOARGS { int sys_rename(char *from, char *to); }
! 231: 135 STD { int svr4_sys_uname(struct svr4_utsname* name, \
! 232: int dummy); }
! 233: 136 STD { int svr4_sys_setegid(gid_t egid); }
! 234: 137 STD { int svr4_sys_sysconfig(int name); }
! 235: 138 NOARGS { int sys_adjtime(struct timeval *delta, \
! 236: struct timeval *olddelta); }
! 237: 139 STD { long svr4_sys_systeminfo(int what, char *buf, \
! 238: long len); }
! 239: 140 UNIMPL
! 240: 141 NOARGS { int sys_seteuid(uid_t euid); }
! 241: 142 UNIMPL vtrace
! 242: 143 UNIMPL fork1
! 243: 144 UNIMPL sigtimedwait
! 244: 145 UNIMPL lwp_info
! 245: 146 UNIMPL yield
! 246: 147 UNIMPL lwp_sema_wait
! 247: 148 UNIMPL lwp_sema_post
! 248: 149 UNIMPL lwp_sema_trywait
! 249: 150 UNIMPL
! 250: 151 UNIMPL
! 251: 152 UNIMPL modctl
! 252: 153 STD { int svr4_sys_fchroot(int fd); }
! 253: 154 STD { int svr4_sys_utimes(char *path, \
! 254: struct timeval *tptr); }
! 255: 155 STD { int svr4_sys_vhangup(void); }
! 256: 156 STD { int svr4_sys_gettimeofday(struct timeval *tp); }
! 257: 157 NOARGS { int sys_getitimer(u_int which, \
! 258: struct itimerval *itv); }
! 259: 158 NOARGS { int sys_setitimer(u_int which, \
! 260: struct itimerval *itv, struct itimerval *oitv); }
! 261: 159 UNIMPL lwp_create
! 262: 160 UNIMPL lwp_exit
! 263: 161 UNIMPL lwp_suspend
! 264: 162 UNIMPL lwp_continue
! 265: 163 UNIMPL lwp_kill
! 266: 164 UNIMPL lwp_self
! 267: 165 UNIMPL lwp_getprivate
! 268: 166 UNIMPL lwp_setprivate
! 269: 167 UNIMPL lwp_wait
! 270: 168 UNIMPL lwp_mutex_unlock
! 271: 169 UNIMPL lwp_mutex_lock
! 272: 170 UNIMPL lwp_cond_wait
! 273: 171 UNIMPL lwp_cond_signal
! 274: 172 UNIMPL lwp_cond_broadcast
! 275: 173 STD { ssize_t svr4_sys_pread(int fd, void *buf, \
! 276: size_t nbyte, svr4_off_t off); }
! 277: 174 STD { ssize_t svr4_sys_pwrite(int fd, const void *buf, \
! 278: size_t nbyte, svr4_off_t off); }
! 279: 175 STD { svr4_off64_t svr4_sys_llseek(int fd, \
! 280: long offset1, long offset2, int whence); }
! 281: 176 UNIMPL inst_sync
! 282: 177 UNIMPL
! 283: 178 UNIMPL kaio
! 284: 179 UNIMPL
! 285: 180 UNIMPL
! 286: 181 UNIMPL
! 287: 182 UNIMPL
! 288: 183 UNIMPL
! 289: 184 UNIMPL tsolsys
! 290: 185 STD { int svr4_sys_acl(char *path, int cmd, int num, \
! 291: struct svr4_aclent *buf); }
! 292: 186 STD { int svr4_sys_auditsys(int code, int a1, int a2, \
! 293: int a3, int a4, int a5); }
! 294: 187 UNIMPL processor_bind
! 295: 188 UNIMPL processor_info
! 296: 189 UNIMPL p_online
! 297: 190 UNIMPL sigqueue
! 298: 191 NOARGS { int sys_clock_gettime(clockid_t clock_id, \
! 299: struct timespec *tp); }
! 300: 192 NOARGS { int sys_clock_settime(clockid_t clock_id, \
! 301: const struct timespec *tp); }
! 302: 193 NOARGS { int sys_clock_getres(clockid_t clock_id, \
! 303: struct timespec *tp); }
! 304: 194 UNIMPL timer_create
! 305: 195 UNIMPL timer_delete
! 306: 196 UNIMPL timer_settime
! 307: 197 UNIMPL timer_gettime
! 308: 198 UNIMPL timer_getoverrun
! 309: 199 NOARGS { int sys_nanosleep(const struct timespec *rqtp, \
! 310: struct timespec *rmtp); }
! 311: 200 STD { int svr4_sys_facl(int fd, int cmd, int num, \
! 312: struct svr4_aclent *buf); }
! 313: 201 UNIMPL door
! 314: 202 NOARGS { int sys_setreuid(uid_t ruid, uid_t euid); }
! 315: 203 NOARGS { int sys_setregid(gid_t rgid, gid_t egid); }
! 316: 204 UNIMPL install_utrap
! 317: 205 UNIMPL signotify
! 318: 206 UNIMPL schedctl
! 319: 207 UNIMPL pset
! 320: 208 UNIMPL
! 321: 209 UNIMPL resolvepath
! 322: 210 UNIMPL signotifywait
! 323: 211 UNIMPL lwp_sigredirect
! 324: 212 UNIMPL lwp_alarm
! 325: 213 STD { int svr4_sys_getdents64(int fd, \
! 326: struct svr4_dirent64 *dp, \
! 327: int nbytes); }
! 328: 214 STD { int svr4_sys_mmap64(svr4_caddr_t addr, \
! 329: svr4_size_t len, int prot, int flags, int fd, \
! 330: svr4_off64_t pos); }
! 331: 215 STD { int svr4_sys_stat64(const char *path, \
! 332: struct svr4_stat64 *sb); }
! 333: 216 STD { int svr4_sys_lstat64(const char *path, \
! 334: struct svr4_stat64 *sb); }
! 335: 217 STD { int svr4_sys_fstat64(int fd, \
! 336: struct svr4_stat64 *sb); }
! 337: 218 UNIMPL statvfs64
! 338: 219 STD { int svr4_sys_fstatvfs64(int fd, \
! 339: struct svr4_statvfs64 *fs); }
! 340: 220 UNIMPL setrlimit64
! 341: 221 UNIMPL getrlimit64
! 342: 222 STD { ssize_t svr4_sys_pread64(int fd, void *buf, \
! 343: size_t nbyte, svr4_off64_t off); }
! 344: 223 STD { ssize_t svr4_sys_pwrite64(int fd, const void *buf, \
! 345: size_t nbyte, svr4_off64_t off); }
! 346: 224 STD { int svr4_sys_creat64(char *path, int mode); }
! 347: 225 STD { int svr4_sys_open64(char *path, int flags, \
! 348: int mode); }
! 349: 226 UNIMPL rpcsys
! 350: 227 UNIMPL
! 351: 228 UNIMPL
! 352: 229 UNIMPL
! 353: 230 STD { int svr4_sys_socket(int domain, int type, \
! 354: int protocol); }
! 355: 231 NOARGS { int sys_socketpair(int domain, int type, \
! 356: int protocol, int *rsv); }
! 357: 232 NOARGS { int sys_bind(int s, const struct sockaddr *name, \
! 358: int namelen); }
! 359: 233 NOARGS { int sys_listen(int s, int backlog); }
! 360: 234 NOARGS { int compat_43_sys_accept(int s, \
! 361: struct sockaddr *name, int *anamelen); }
! 362: 235 NOARGS { int sys_connect(int s, const struct sockaddr *name, \
! 363: int namelen); }
! 364: 236 NOARGS { int sys_shutdown(int s, int how); }
! 365: 237 NOARGS { int compat_43_sys_recv(int s, caddr_t buf, int len, \
! 366: int flags); }
! 367: 238 NOARGS { ssize_t compat_43_sys_recvfrom(int s, void *buf, \
! 368: size_t len, int flags, struct sockaddr *from, \
! 369: int *fromlenaddr); }
! 370: 239 NOARGS { ssize_t compat_43_sys_recvmsg(int s, \
! 371: struct msghdr *msg, int flags); }
! 372: 240 NOARGS { int compat_43_sys_send(int s, caddr_t buf, int len, \
! 373: int flags); }
! 374: 241 NOARGS { ssize_t compat_43_sys_sendmsg(int s, \
! 375: const struct msghdr *msg, int flags); }
! 376: 242 NOARGS { ssize_t sys_sendto(int s, const void *buf, \
! 377: size_t len, int flags, const struct sockaddr *to, \
! 378: int tolen); }
! 379: 243 NOARGS { int compat_43_sys_getpeername(int fdes, \
! 380: struct sockaddr *asa, int *alen); }
! 381: 244 NOARGS { int compat_43_sys_getsockname(int fdes, \
! 382: struct sockaddr *asa, int *alen); }
! 383: 245 NOARGS { int sys_getsockopt(int s, int level, int name, \
! 384: void *val, int *avalsize); }
! 385: 246 NOARGS { int sys_setsockopt(int s, int level, int name, \
! 386: const void *val, int valsize); }
! 387: 247 UNIMPL sockconfig
! 388: 248 UNIMPL ntp_gettime
! 389: 249 UNIMPL ntp_adjtime
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to syscalls.master CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / compat / svr4