[BACK]Return to syscalls.master CVS log [TXT][DIR] Up to [local] / sys / compat / osf1

Annotation of sys/compat/osf1/syscalls.master, Revision 1.1.1.1

1.1       nbrk        1:        $OpenBSD: syscalls.master,v 1.10 2004/05/28 18:28:14 tedu Exp $
                      2: ;      $NetBSD: syscalls.master,v 1.29 1999/05/10 03:33:04 cgd Exp $
                      3:
                      4: ;      @(#)syscalls.master     8.1 (Berkeley) 7/19/93
                      5:
                      6: ; NetBSD COMPAT_OSF1 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 names and switch definition files 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/poll.h>
                     40: #include <sys/syscallargs.h>
                     41:
                     42: #include <compat/osf1/osf1.h>
                     43: #include <compat/osf1/osf1_syscallargs.h>
                     44:
                     45: 0      NOARGS          { int sys_nosys(void); } syscall
                     46: 1      NOARGS          { int sys_exit(int rval); }
                     47: 2      NOARGS          { int sys_fork(void); }
                     48: 3      NOARGS          { int sys_read(int fd, char *buf, u_int nbyte); }
                     49: 4      NOARGS          { int sys_write(int fd, const char *buf, \
                     50:                            u_int nbyte); }
                     51: 5      UNIMPL          old open
                     52: 6      NOARGS          { int sys_close(int fd); }
                     53: 7      STD             { int osf1_sys_wait4(int pid, int *status, \
                     54:                            int options, struct osf1_rusage *rusage); }
                     55: 8      UNIMPL          old creat
                     56: 9      NOARGS          { int sys_link(const char *path, const char *link); }
                     57: 10     NOARGS          { int sys_unlink(const char *path); }
                     58: 11     UNIMPL          execv
                     59: 12     NOARGS          { int sys_chdir(const char *path); }
                     60: 13     NOARGS          { int sys_fchdir(int fd); }
                     61: 14     STD             { int osf1_sys_mknod(char *path, int mode, \
                     62:                            int dev); }
                     63: 15     NOARGS          { int sys_chmod(const char *path, int mode); }
                     64: 16     NOARGS          { int sys_chown(const char *path, int uid, \
                     65:                            int gid); }
                     66: 17     NOARGS          { int sys_obreak(char *nsize); }
                     67: 18     STD             { int osf1_sys_getfsstat(struct osf1_statfs *buf, \
                     68:                            long bufsize, int flags); }
                     69: 19     STD             { off_t osf1_sys_lseek(int fd, off_t offset, \
                     70:                            int whence); }
                     71: 20     NOARGS          { pid_t sys_getpid(void); }
                     72: 21     STD             { int osf1_sys_mount(int type, const char *path, \
                     73:                            int flags, caddr_t data); }
                     74: 22     STD             { int osf1_sys_unmount(const char *path, int flags); }
                     75: 23     STD             { int osf1_sys_setuid(uid_t uid); }
                     76: 24     NOARGS          { uid_t sys_getuid(void); }
                     77: 25     UNIMPL          exec_with_loader
                     78: 26     UNIMPL          ptrace
                     79: 27     STD             { int osf1_sys_recvmsg_xopen(int s, \
                     80:                            struct osf1_msghdr_xopen *msg, int flags); }
                     81: 28     STD             { int osf1_sys_sendmsg_xopen(int s, \
                     82:                            const struct osf1_msghdr_xopen *msg, int flags); }
                     83: 29     UNIMPL          recvfrom
                     84: 30     UNIMPL          accept
                     85: 31     UNIMPL          getpeername
                     86: 32     UNIMPL          getsockname
                     87: 33     STD             { int osf1_sys_access(char *path, int flags); }
                     88: 34     UNIMPL          chflags
                     89: 35     UNIMPL          fchflags
                     90: 36     NOARGS          { int sys_sync(void); }
                     91: 37     NOARGS          { int sys_kill(int pid, int signum); }
                     92: 38     UNIMPL          old stat
                     93: 39     NOARGS          { int sys_setpgid(int pid, int pgid); }
                     94: 40     UNIMPL          old lstat
                     95: 41     NOARGS          { int sys_dup(u_int fd); }
                     96: 42     NOARGS          { int sys_pipe(void); }
                     97: 43     STD             { int osf1_sys_set_program_attributes( \
                     98:                           caddr_t taddr, unsigned long tsize, \
                     99:                           caddr_t daddr, unsigned long dsize); }
                    100: 44     UNIMPL          profil
                    101: 45     STD             { int osf1_sys_open(char *path, int flags, \
                    102:                            int mode); }
                    103: 46     OBSOL           sigaction
                    104: 47     NOARGS          { gid_t sys_getgid(void); }
                    105: ; XXX
                    106: 48     NOARGS          { int sys_sigprocmask(int how, sigset_t mask); }
                    107: 49     NOARGS          { int sys_getlogin(char *namebuf, u_int namelen); }
                    108: 50     NOARGS          { int sys_setlogin(const char *namebuf); }
                    109: #ifdef ACCOUNTING
                    110: 51     NOARGS          { int sys_acct(const char *path); }
                    111: #else
                    112: 51     UNIMPL          acct
                    113: #endif
                    114: 52     UNIMPL          sigpending
                    115: 53     STD             { int osf1_sys_classcntl(int opcode, int arg1, \
                    116:                            int arg2, int arg3); }
                    117: 54     STD             { int osf1_sys_ioctl(int fd, int com, caddr_t data); }
                    118: 55     STD             { int osf1_sys_reboot(int opt); }
                    119: 56     NOARGS          { int sys_revoke(const char *path); }
                    120: 57     NOARGS          { int sys_symlink(const char *path, \
                    121:                            const char *link); }
                    122: 58     NOARGS          { int sys_readlink(const char *path, char *buf, \
                    123:                            int count); }
                    124: 59     STD             { int osf1_sys_execve(char *path, \
                    125:                            char * const *argp, char * const *envp); }
                    126: 60     NOARGS          { int sys_umask(int newmask); }
                    127: 61     NOARGS          { int sys_chroot(const char *path); }
                    128: 62     UNIMPL          old fstat
                    129: 63     NOARGS          { int sys_getpgrp(void); }
                    130: 64     NOARGS          { int compat_43_sys_getpagesize(void); }
                    131: 65     UNIMPL          mremap
                    132: 66     NOARGS          { int sys_vfork(void); }
                    133: 67     STD             { int osf1_sys_stat(char *path, \
                    134:                            struct osf1_stat *ub); }
                    135: 68     STD             { int osf1_sys_lstat(char *path, \
                    136:                            struct osf1_stat *ub); }
                    137: 69     UNIMPL          sbrk
                    138: 70     UNIMPL          sstk
                    139: 71     STD             { caddr_t osf1_sys_mmap(caddr_t addr, size_t len, \
                    140:                            int prot, int flags, int fd, off_t pos); }
                    141: 72     UNIMPL          ovadvise
                    142: 73     NOARGS          { int sys_munmap(caddr_t addr, size_t len); }
                    143: 74     STD             { int osf1_sys_mprotect(void *addr, size_t len, \
                    144:                            int prot); }
                    145: 75     STD             { int osf1_sys_madvise(void *addr, size_t len, \
                    146:                            int behav); }
                    147: 76     UNIMPL          old vhangup
                    148: 77     UNIMPL          kmodcall
                    149: 78     UNIMPL          mincore
                    150: 79     NOARGS          { int sys_getgroups(u_int gidsetsize, gid_t *gidset); }
                    151: 80     NOARGS          { int sys_setgroups(u_int gidsetsize, gid_t *gidset); }
                    152: 81     UNIMPL          old getpgrp
                    153: ; OSF/1 setpgrp(); identical in function to setpgid().  XXX
                    154: 82     NOARGS          { int sys_setpgid(int pid, int pgid); } setpgrp
                    155: 83     STD             { int osf1_sys_setitimer(u_int which, \
                    156:                            struct osf1_itimerval *itv, \
                    157:                            struct osf1_itimerval *oitv); }
                    158: 84     UNIMPL          old wait
                    159: 85     UNIMPL          table
                    160: 86     UNIMPL          getitimer
                    161: 87     NOARGS          { int compat_43_sys_gethostname(char *hostname, \
                    162:                            u_int len); }
                    163: 88     NOARGS          { int compat_43_sys_sethostname(const char *hostname, \
                    164:                            u_int len); }
                    165: 89     NOARGS          { int compat_43_sys_getdtablesize(void); }
                    166: 90     NOARGS          { int sys_dup2(u_int from, u_int to); }
                    167: 91     STD             { int osf1_sys_fstat(int fd, void *sb); }
                    168: 92     STD             { int osf1_sys_fcntl(int fd, int cmd, void *arg); }
                    169: 93     STD             { int osf1_sys_select(u_int nd, fd_set *in, \
                    170:                            fd_set *ou, fd_set *ex, struct osf1_timeval *tv); }
                    171: ; maybe XXX
                    172: 94     NOARGS          { int sys_poll(struct pollfd *fds, u_int nfds, \
                    173:                            int timeout); }
                    174: 95     NOARGS          { int sys_fsync(int fd); }
                    175: 96     NOARGS          { int sys_setpriority(int which, int who, int prio); }
                    176: 97     STD             { int osf1_sys_socket(int domain, int type, \
                    177:                            int protocol); }
                    178: 98     NOARGS          { int sys_connect(int s, caddr_t name, int namelen); }
                    179: 99     NOARGS          { int compat_43_sys_accept(int s, caddr_t name, \
                    180:                            int *anamelen); }
                    181: 100    NOARGS          { int sys_getpriority(int which, int who); }
                    182: 101    NOARGS          { int compat_43_sys_send(int s, caddr_t buf, int len, \
                    183:                            int flags); }
                    184: 102    NOARGS          { int compat_43_sys_recv(int s, caddr_t buf, int len, \
                    185:                            int flags); }
                    186: 103    NOARGS          { int sys_sigreturn(struct sigcontext *sigcntxp); }
                    187: 104    NOARGS          { int sys_bind(int s, caddr_t name, int namelen); }
                    188: 105    NOARGS          { int sys_setsockopt(int s, int level, int name, \
                    189:                            caddr_t val, int valsize); }
                    190: 106    NOARGS          { int sys_listen(int s, int backlog); }
                    191: 107    UNIMPL          plock
                    192: 108    UNIMPL          old sigvec
                    193: 109    UNIMPL          old sigblock
                    194: 110    UNIMPL          old sigsetmask
                    195: 111    NOARGS          { int sys_sigsuspend(int mask); }
                    196: 112    NOARGS          { int compat_43_sys_sigstack(struct sigstack *nss, \
                    197:                            struct sigstack *oss); }
                    198: 113    UNIMPL          old recvmsg
                    199: 114    UNIMPL          old sendmsg
                    200: 115    OBSOL           vtrace
                    201: 116    STD             { int osf1_sys_gettimeofday(struct osf1_timeval *tp, \
                    202:                            struct osf1_timezone *tzp); }
                    203: 117    STD             { int osf1_sys_getrusage(int who, \
                    204:                            struct osf1_rusage *rusage); }
                    205: ; XXX
                    206: 118    NOARGS          { int sys_getsockopt(int s, int level, int name, \
                    207:                            caddr_t val, int *avalsize); }
                    208: 119    UNIMPL
                    209: 120    STD             { int osf1_sys_readv(int fd, \
                    210:                            struct osf1_iovec *iovp, u_int iovcnt); }
                    211: 121    STD             { int osf1_sys_writev(int fd, \
                    212:                            struct osf1_iovec *iovp, u_int iovcnt); }
                    213: 122    STD             { int osf1_sys_settimeofday(struct osf1_timeval *tv, \
                    214:                            struct osf1_timezone *tzp); }
                    215: 123    NOARGS          { int sys_fchown(int fd, int uid, int gid); }
                    216: 124    NOARGS          { int sys_fchmod(int fd, int mode); }
                    217: 125    NOARGS          { int compat_43_sys_recvfrom(int s, caddr_t buf, \
                    218:                            size_t len, int flags, caddr_t from, \
                    219:                            int *fromlenaddr); }
                    220: 126    NOARGS          { int sys_setreuid(uid_t ruid, uid_t euid); }
                    221: 127    NOARGS          { int sys_setregid(gid_t rgid, gid_t egid); }
                    222: 128    NOARGS          { int sys_rename(const char *from, \
                    223:                            const char *to); }
                    224: 129    STD             { int osf1_sys_truncate(char *path, \
                    225:                            off_t length); }
                    226: 130    STD             { int osf1_sys_ftruncate(int fd, off_t length); }
                    227: 131    UNIMPL          flock
                    228: 132    STD             { int osf1_sys_setgid(gid_t gid); }
                    229: 133    STD             { int osf1_sys_sendto(int s, caddr_t buf, size_t len, \
                    230:                            int flags, struct sockaddr *to, int tolen); }
                    231: 134    NOARGS          { int sys_shutdown(int s, int how); }
                    232: 135    STD             { int osf1_sys_socketpair(int domain, int type, \
                    233:                            int protocol, int *rsv); }
                    234: 136    NOARGS          { int sys_mkdir(const char *path, int mode); }
                    235: 137    NOARGS          { int sys_rmdir(const char *path); }
                    236: 138    STD             { int osf1_sys_utimes(char *path, \
                    237:                            const struct osf1_timeval *tptr); }
                    238: 139    OBSOL           4.2 sigreturn
                    239: 140    UNIMPL          adjtime
                    240: 141    NOARGS          { int compat_43_sys_getpeername(int fdes, \
                    241:                            caddr_t asa, int *alen); }
                    242: 142    NOARGS          { int32_t compat_43_sys_gethostid(void); }
                    243: 143    NOARGS          { int compat_43_sys_sethostid(int32_t hostid); }
                    244: ; XXX
                    245: 144    STD             { int osf1_sys_getrlimit(u_int which, \
                    246:                            struct rlimit *rlp); }
                    247: ; XXX
                    248: 145    STD             { int osf1_sys_setrlimit(u_int which, \
                    249:                            struct rlimit *rlp); }
                    250: 146    UNIMPL          old killpg
                    251: 147    NOARGS          { int sys_setsid(void); }
                    252: 148    UNIMPL          quotactl
                    253: 149    NOARGS          { int compat_43_sys_quota(void); }
                    254: 150    NOARGS          { int compat_43_sys_getsockname(int fdec, \
                    255:                            caddr_t asa, int *alen); }
                    256: 151    UNIMPL          pread
                    257: 152    UNIMPL          pwrite
                    258: 153    UNIMPL          pid_block
                    259: 154    UNIMPL          pid_unblock
                    260: 155    UNIMPL          signal_urti
                    261: 156    STD             { int osf1_sys_sigaction(int signum, \
                    262:                            struct osf1_sigaction *nsa, \
                    263:                            struct osf1_sigaction *osa); }
                    264: 157    UNIMPL          sigwaitprim
                    265: 158    UNIMPL          nfssvc
                    266: 159    NOARGS          { int compat_43_sys_getdirentries(int fd, char *buf, \
                    267:                            u_int count, long *basep); }
                    268: 160    STD             { int osf1_sys_statfs(const char *path, \
                    269:                            struct osf1_statfs *buf, int len); }
                    270: 161    STD             { int osf1_sys_fstatfs(int fd, \
                    271:                            struct osf1_statfs *buf, int len); }
                    272: 162    UNIMPL
                    273: 163    UNIMPL          async_daemon
                    274: 164    UNIMPL          getfh
                    275: 165    NOARGS          { int compat_09_sys_getdomainname(char *domainname, \
                    276:                            int len); }
                    277: 166    NOARGS          { int compat_09_sys_setdomainname(char *domainname, \
                    278:                            int len); }
                    279: 167    UNIMPL
                    280: 168    UNIMPL
                    281: 169    UNIMPL          exportfs
                    282: 170    UNIMPL
                    283: 171    UNIMPL
                    284: 172    UNIMPL          alt msgctl
                    285: 173    UNIMPL          alt msgget
                    286: 174    UNIMPL          alt msgrcv
                    287: 175    UNIMPL          alt msgsnd
                    288: 176    UNIMPL          alt semctl
                    289: 177    UNIMPL          alt semget
                    290: 178    UNIMPL          alt semop
                    291: 179    UNIMPL          alt uname
                    292: 180    UNIMPL
                    293: 181    UNIMPL          alt plock
                    294: 182    UNIMPL          lockf
                    295: 183    UNIMPL
                    296: 184    UNIMPL          getmnt
                    297: 185    UNIMPL
                    298: 186    UNIMPL          unmount
                    299: 187    UNIMPL          alt sigpending
                    300: 188    UNIMPL          alt setsid
                    301: 189    UNIMPL
                    302: 190    UNIMPL
                    303: 191    UNIMPL
                    304: 192    UNIMPL
                    305: 193    UNIMPL
                    306: 194    UNIMPL
                    307: 195    UNIMPL
                    308: 196    UNIMPL
                    309: 197    UNIMPL
                    310: 198    UNIMPL
                    311: 199    UNIMPL          swapon
                    312: 200    UNIMPL          msgctl
                    313: 201    UNIMPL          msgget
                    314: 202    UNIMPL          msgrcv
                    315: 203    UNIMPL          msgsnd
                    316: 204    UNIMPL          semctl
                    317: 205    UNIMPL          semget
                    318: 206    UNIMPL          semop
                    319: 207    STD             { int osf1_sys_uname(struct osf1_uname *name); }
                    320: 208    NOARGS          { int sys_lchown(const char *path, int uid, \
                    321:                            int gid); }
                    322: 209    STD             { void *osf1_sys_shmat(int shmid, \
                    323:                            const void *shmaddr, int shmflg); }
                    324: 210    STD             { int osf1_sys_shmctl(int shmid, int cmd, \
                    325:                            struct osf1_shmid_ds *buf); }
                    326: 211    STD             { int osf1_sys_shmdt(const void *shmaddr); }
                    327: 212    STD             { int osf1_sys_shmget(osf1_key_t key, size_t size, \
                    328:                            int flags); }
                    329: 213    UNIMPL          mvalid
                    330: 214    UNIMPL          getaddressconf
                    331: 215    UNIMPL          msleep
                    332: 216    UNIMPL          mwakeup
                    333: 217    UNIMPL          msync
                    334: 218    UNIMPL          signal
                    335: 219    UNIMPL          utc gettime
                    336: 220    UNIMPL          utc adjtime
                    337: 221    UNIMPL
                    338: 222    UNIMPL          security
                    339: 223    UNIMPL          kloadcall
                    340: 224    UNIMPL
                    341: 225    UNIMPL
                    342: 226    UNIMPL
                    343: 227    UNIMPL
                    344: 228    UNIMPL
                    345: 229    UNIMPL
                    346: 230    UNIMPL
                    347: 231    UNIMPL
                    348: 232    UNIMPL
                    349: 233    UNIMPL          getpgid
                    350: 234    NOARGS          { pid_t sys_getsid(pid_t pid); }
                    351: 235    STD             { int osf1_sys_sigaltstack( \
                    352:                            struct osf1_sigaltstack *nss, \
                    353:                            struct osf1_sigaltstack *oss); }
                    354: 236    UNIMPL          waitid
                    355: 237    UNIMPL          priocntlset
                    356: 238    UNIMPL          sigsendset
                    357: 239    UNIMPL          set_speculative
                    358: 240    UNIMPL          msfs_syscall
                    359: 241    STD             { int osf1_sys_sysinfo(int cmd, char *buf, long len); }
                    360: 242    UNIMPL          uadmin
                    361: 243    UNIMPL          fuser
                    362: 244    UNIMPL          proplist_syscall
                    363: 245    UNIMPL          ntp_adjtime
                    364: 246    UNIMPL          ntp_gettime
                    365: 247    STD             { long osf1_sys_pathconf(char *path, int name); }
                    366: 248    STD             { long osf1_sys_fpathconf(int fd, int name); }
                    367: 249    UNIMPL
                    368: 250    UNIMPL          uswitch
                    369: 251    STD             { int osf1_sys_usleep_thread( \
                    370:                            struct osf1_timeval *sleep, \
                    371:                            struct osf1_timeval *slept); }
                    372: 252    UNIMPL          audcntl
                    373: 253    UNIMPL          audgen
                    374: 254    UNIMPL          sysfs
                    375: 255    UNIMPL          subsys_info
                    376: 256    UNIMPL          getsysinfo
                    377: 257    STD             { int osf1_sys_setsysinfo(u_long op, caddr_t buffer, \
                    378:                            u_long nbytes, caddr_t arg, u_long flag); }
                    379: 258    UNIMPL          afs_syscall
                    380: 259    UNIMPL          swapctl
                    381: 260    UNIMPL          memcntl
                    382: 261    UNIMPL          fdatasync

CVSweb