[BACK]Return to syscalls.master CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / sys / compat / linux / arch / m68k

Annotation of src/sys/compat/linux/arch/m68k/syscalls.master, Revision 1.12

1.12    ! tron        1:        $NetBSD: syscalls.master,v 1.11 1999/12/05 21:24:30 tron Exp $
1.1       itohy       2:
                      3: ;      @(#)syscalls.master     8.1 (Berkeley) 7/19/93
                      4:
                      5: ; NetBSD m68k COMPAT_LINUX 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: ;      INDIR   included, but don't define the syscall args structure
                     20: ;              and allow it to be "really" varargs.
                     21: ;
                     22: ; The compat options are defined in the syscalls.conf file, and the
                     23: ; compat option name is prefixed to the syscall name.  Other than
                     24: ; that, they're like NODEF (for 'compat' options), or STD (for
                     25: ; 'libcompat' options).
                     26: ;
                     27: ; The type-dependent arguments are as follows:
                     28: ; For STD, NODEF, NOARGS, and compat syscalls:
                     29: ;      { pseudo-proto } [alias]
                     30: ; For other syscalls:
                     31: ;      [comment]
                     32: ;
                     33: ; #ifdef's, etc. may be included, and are copied to the output files.
                     34: ; #include's are copied to the syscall names and switch definition files only.
                     35:
                     36: #include "opt_compat_netbsd.h"
                     37: #include "opt_compat_43.h"
                     38:
                     39: #include <sys/param.h>
1.5       tron       40: #include <sys/poll.h>
1.1       itohy      41: #include <sys/systm.h>
                     42: #include <sys/signal.h>
                     43: #include <sys/mount.h>
                     44: #include <sys/syscallargs.h>
                     45:
                     46: #include <compat/linux/common/linux_types.h>
                     47: #include <compat/linux/common/linux_signal.h>
                     48: #include <compat/linux/common/linux_siginfo.h>
                     49: #include <compat/linux/common/linux_machdep.h>
                     50:
                     51: #include <compat/linux/linux_syscallargs.h>
                     52:
                     53:
                     54: 0      NOARGS          { int sys_nosys(void); } syscall
                     55: 1      NOARGS          { int sys_exit(int rval); }
                     56: 2      NOARGS          { int sys_fork(void); }
                     57: 3      NOARGS          { int sys_read(int fd, char *buf, u_int nbyte); }
                     58: 4      NOARGS          { int sys_write(int fd, char *buf, u_int nbyte); }
1.2       itohy      59: 5      STD             { int linux_sys_open(const char *path, int flags, \
                     60:                            int mode); }
1.1       itohy      61: 6      NOARGS          { int sys_close(int fd); }
                     62: 7      STD             { int linux_sys_waitpid(int pid, int *status, \
                     63:                            int options);}
1.2       itohy      64: 8      STD             { int linux_sys_creat(const char *path, int mode); }
                     65: 9      NOARGS          { int sys_link(const char *path, const char *link); }
                     66: 10     STD             { int linux_sys_unlink(const char *path); }
                     67: 11     STD             { int linux_sys_execve(const char *path, char **argp, \
1.1       itohy      68:                            char **envp); }
1.2       itohy      69: 12     STD             { int linux_sys_chdir(const char *path); }
1.1       itohy      70: 13     STD             { int linux_sys_time(linux_time_t *t); }
1.2       itohy      71: 14     STD             { int linux_sys_mknod(const char *path, int mode, \
                     72:                            int dev); }
                     73: 15     STD             { int linux_sys_chmod(const char *path, int mode); }
1.1       itohy      74: ;16 lchown on i386; chown on m68k.
1.2       itohy      75: 16     STD             { int linux_sys_chown(const char *path, \
                     76:                            int uid, int gid); }
1.1       itohy      77: 17     OBSOL           break
                     78: 18     OBSOL           ostat
                     79: #if !defined(_KERNEL) || defined(COMPAT_43)
                     80: 19     NOARGS          { long compat_43_sys_lseek(int fd, long offset, \
                     81:                            int whence); }
                     82: #else
                     83: 19     UNIMPL          compat_43_sys_lseek
                     84: #endif
                     85: 20     NOARGS          { pid_t sys_getpid(void); }
                     86: 21     UNIMPL          mount
                     87: 22     OBSOL           umount
                     88: 23     NOARGS          { int sys_setuid(uid_t uid); }
                     89: 24     NOARGS          { uid_t sys_getuid(void); }
1.8       tron       90: 25     STD             { int linux_sys_stime(linux_time_t *t); }
1.12    ! tron       91: 26     STD             { int linux_sys_ptrace(int request, int pid, \
        !            92:                          int addr, int data); }
1.1       itohy      93: 27     STD             { int linux_sys_alarm(unsigned int secs); }
                     94: 28     OBSOL           ofstat
                     95: 29     STD             { int linux_sys_pause(void); }
1.2       itohy      96: 30     STD             { int linux_sys_utime(const char *path, \
1.1       itohy      97:                            struct linux_utimbuf *times); }
                     98: 31     OBSOL           stty
                     99: 32     OBSOL           gtty
1.2       itohy     100: 33     STD             { int linux_sys_access(const char *path, int flags); }
1.1       itohy     101: 34     STD             { int linux_sys_nice(int incr); }
                    102: 35     OBSOL           ftime
                    103: 36     NOARGS          { int sys_sync(void); }
                    104: 37     STD             { int linux_sys_kill(int pid, int signum); }
1.2       itohy     105: 38     STD             { int linux_sys_rename(const char *from, \
                    106:                            const char *to); }
                    107: 39     STD             { int linux_sys_mkdir(const char *path, int mode); }
                    108: 40     STD             { int linux_sys_rmdir(const char *path); }
1.1       itohy     109: 41     NOARGS          { int sys_dup(u_int fd); }
                    110: 42     STD             { int linux_sys_pipe(int *pfds); }
                    111: 43     STD             { int linux_sys_times(struct times *tms); }
                    112: 44     OBSOL           prof
                    113: 45     STD             { int linux_sys_brk(char *nsize); }
                    114: 46     NOARGS          { int sys_setgid(gid_t gid); }
                    115: 47     NOARGS          { gid_t sys_getgid(void); }
1.10      tron      116: 48     STD             { int linux_sys_signal(int signum, \
1.1       itohy     117:                            linux_handler_t handler); }
                    118: 49     NOARGS          { uid_t sys_geteuid(void); }
                    119: 50     NOARGS          { gid_t sys_getegid(void); }
                    120: 51     NOARGS          { int sys_acct(char *path); }
                    121: 52     UNIMPL          umount
                    122: 53     OBSOL           lock
                    123: 54     STD             { int linux_sys_ioctl(int fd, u_long com, \
                    124:                            caddr_t data); }
                    125: 55     STD             { int linux_sys_fcntl(int fd, int cmd, void *arg); }
                    126: 56     OBSOL           mpx
                    127: 57     NOARGS          { int sys_setpgid(int pid, int pgid); }
                    128: 58     OBSOL           ulimit
                    129: 59     UNIMPL          oldolduname
                    130: 60     NOARGS          { int sys_umask(int newmask); }
                    131: 61     NOARGS          { int sys_chroot(char *path); }
                    132: 62     UNIMPL          ustat
                    133: 63     NOARGS          { int sys_dup2(u_int from, u_int to); }
                    134: 64     NOARGS          { pid_t sys_getppid(void); }
                    135: 65     NOARGS          { int sys_getpgrp(void); }
                    136: 66     NOARGS          { int sys_setsid(void); }
                    137: 67     STD             { int linux_sys_sigaction(int signum, \
                    138:                            const struct linux_old_sigaction *nsa, \
                    139:                            struct linux_old_sigaction *osa); }
                    140: 68     STD             { int linux_sys_siggetmask(void); }
                    141: 69     STD             { int linux_sys_sigsetmask(linux_old_sigset_t mask); }
                    142: 70     STD             { int linux_sys_setreuid(int ruid, int euid); }
                    143: 71     STD             { int linux_sys_setregid(int rgid, int egid); }
                    144: 72     STD             { int linux_sys_sigsuspend(caddr_t restart, \
                    145:                            int oldmask, int mask); }
                    146: 73     STD             { int linux_sys_sigpending(linux_old_sigset_t *set); }
                    147: #if !defined(_KERNEL) || defined(COMPAT_43)
                    148: 74     NOARGS          { int compat_43_sys_sethostname(char *hostname, \
                    149:                            u_int len);}
                    150: 75     NOARGS          { int compat_43_sys_setrlimit(u_int which, \
                    151:                            struct orlimit *rlp); }
                    152: 76     NOARGS          { int compat_43_sys_getrlimit(u_int which, \
                    153:                            struct orlimit *rlp); }
                    154: #else
                    155: 74     UNIMPL          compat_43_sys_sethostname
                    156: 75     UNIMPL          compat_43_sys_setrlimit
                    157: 76     UNIMPL          compat_43_sys_getrlimit
                    158: #endif
                    159: 77     NOARGS          { int sys_getrusage(int who, struct rusage *rusage); }
                    160: 78     NOARGS          { int sys_gettimeofday(struct timeval *tp, \
                    161:                            struct timezone *tzp); }
                    162: 79     NOARGS          { int sys_settimeofday(struct timeval *tp, \
                    163:                            struct timezone *tzp); }
                    164: 80     NOARGS          { int sys_getgroups(u_int gidsetsize, gid_t *gidset); }
                    165: 81     NOARGS          { int sys_setgroups(u_int gidsetsize, gid_t *gidset); }
                    166: 82     STD             { int linux_sys_oldselect(struct linux_oldselect *lsp); }
1.2       itohy     167: 83     STD             { int linux_sys_symlink(const char *path, \
                    168:                            const char *to); }
1.1       itohy     169: #if !defined(_KERNEL) || defined(COMPAT_43)
1.2       itohy     170: 84     NOARGS          { int compat_43_sys_lstat(const char *path, \
1.1       itohy     171:                            struct stat43 *up); } oolstat
                    172: #else
                    173: 84     UNIMPL          compat_43_sys_lstat
                    174: #endif
1.2       itohy     175: 85     STD             { int linux_sys_readlink(const char *name, char *buf, \
1.1       itohy     176:                            int count); }
1.2       itohy     177: 86     STD             { int linux_sys_uselib(const char *path); }
1.1       itohy     178: #if !defined(_KERNEL) || defined(COMPAT_12)
                    179: 87     NOARGS          { int compat_12_sys_swapon(char *name); }
                    180: #else
                    181: 87     UNIMPL          compat_12_sys_swapon
                    182: #endif
                    183: 88     NOARGS          { int sys_reboot(int opt); }
                    184: 89     STD             { int linux_sys_readdir(int fd, caddr_t dent, \
                    185:                            unsigned int count); }
                    186: 90     STD             { int linux_sys_old_mmap(struct linux_oldmmap *lmp); }
                    187: 91     NOARGS          { int sys_munmap(caddr_t addr, int len); }
1.2       itohy     188: 92     STD             { int linux_sys_truncate(const char *path, \
                    189:                            long length); }
1.1       itohy     190: #if !defined(_KERNEL) || defined(COMPAT_43)
                    191: 93     NOARGS          { int compat_43_sys_ftruncate(int fd, long length); }
                    192: #else
                    193: 93     UNIMPL          compat_43_sys_ftruncate
                    194: #endif
                    195: 94     NOARGS          { int sys_fchmod(int fd, int mode); }
                    196: 95     STD             { int linux_sys_fchown(int fd, int uid, int gid); }
                    197: 96     NOARGS          { int sys_getpriority(int which, int who); }
                    198: 97     NOARGS          { int sys_setpriority(int which, int who, int prio); }
                    199: 98     NOARGS          { int sys_profil(caddr_t samples, u_int size, \
                    200:                            u_int offset, u_int scale); }
1.2       itohy     201: 99     STD             { int linux_sys_statfs(const char *path, \
1.1       itohy     202:                            struct linux_statfs *sp); }
                    203: 100    STD             { int linux_sys_fstatfs(int fd, \
                    204:                            struct linux_statfs *sp); }
                    205: 101    UNIMPL          ioperm
                    206: 102    STD             { int linux_sys_socketcall(int what, void *args); }
                    207: 103    UNIMPL          syslog
                    208: 104    NOARGS          { int sys_setitimer(u_int which, \
                    209:                            struct itimerval *itv, struct itimerval *oitv); }
                    210: 105    NOARGS          { int sys_getitimer(u_int which, \
                    211:                            struct itimerval *itv); }
1.2       itohy     212: 106    STD             { int linux_sys_stat(const char *path, \
1.1       itohy     213:                            struct linux_stat *sp); }
1.2       itohy     214: 107    STD             { int linux_sys_lstat(const char *path, \
1.1       itohy     215:                            struct linux_stat *sp); }
                    216: 108    STD             { int linux_sys_fstat(int fd, struct linux_stat *sp); }
                    217: 109    UNIMPL          olduname
                    218: 110    UNIMPL          iopl
                    219: 111    UNIMPL          vhangup
                    220: 112    UNIMPL          idle
                    221: 113    UNIMPL          vm86old
                    222: 114    STD             { int linux_sys_wait4(int pid, int *status, \
                    223:                            int options, struct rusage *rusage); }
                    224: 115    UNIMPL          swapoff
                    225: 116    UNIMPL          sysinfo
                    226: 117    STD             { int linux_sys_ipc(int what, int a1, int a2, int a3, \
                    227:                            caddr_t ptr); }
                    228: 118    NOARGS          { int sys_fsync(int fd); }
                    229: 119    STD             { int linux_sys_sigreturn(void); }
1.6       thorpej   230: 120    STD             { int linux_sys_clone(int flags, void *stack); }
1.1       itohy     231: #if !defined(_KERNEL) || defined(COMPAT_09)
                    232: 121    NOARGS          { int compat_09_sys_setdomainname(char *name, \
                    233:                            int len); }
                    234: #else
                    235: 121    UNIMPL          compat_09_sys_setdomainname
                    236: #endif
                    237: 122    STD             { int linux_sys_uname(struct linux_utsname *up); }
                    238: 123    STD             { int linux_sys_cacheflush(unsigned long addr, \
                    239:                            int scope, int cache, unsigned long len); }
                    240: 124    UNIMPL          adjtimex
                    241: 125    NOARGS          { int sys_mprotect(caddr_t addr, int len, int prot); }
                    242: 126    STD             { int linux_sys_sigprocmask(int how, \
                    243:                            const linux_old_sigset_t *set, \
                    244:                            linux_old_sigset_t *oset); }
                    245: 127    UNIMPL          create_module
                    246: 128    UNIMPL          init_module
                    247: 129    UNIMPL          delete_module
                    248: 130    UNIMPL          get_kernel_syms
                    249: 131    UNIMPL          quotactl
                    250: 132    STD             { int linux_sys_getpgid(int pid); }
                    251: 133    NOARGS          { int sys_fchdir(int fd); }
                    252: 134    UNIMPL          bdflush
                    253: 135    UNIMPL          sysfs
                    254: 136    STD             { int linux_sys_personality(int per); }
                    255: 137    UNIMPL          afs_syscall
                    256: 138    UNIMPL          setfsuid
                    257: 139    UNIMPL          getfsuid
                    258: 140    STD             { int linux_sys_llseek(int fd, u_int32_t ohigh, \
                    259:                            u_int32_t olow, caddr_t res, int whence); }
                    260: 141    STD             { int linux_sys_getdents(int fd, \
                    261:                            struct linux_dirent *dent, unsigned int count); }
                    262: 142    STD             { int linux_sys_select(int nfds, fd_set *readfds, \
                    263:                            fd_set *writefds, fd_set *exceptfds, \
                    264:                            struct timeval *timeout); }
                    265: 143    NOARGS          { int sys_flock(int fd, int how); }
                    266: 144    STD             { int linux_sys_msync(caddr_t addr, int len, int fl); }
                    267: 145    NOARGS          { int sys_readv(int fd, struct iovec *iovp, \
                    268:                                u_int iovcnt); }
                    269: 146    NOARGS          { int sys_writev(int fd, struct iovec *iovp, \
                    270:                                u_int iovcnt); }
                    271: 147    NOARGS          { pid_t sys_getsid(pid_t pid); }
                    272: 148    STD             { int linux_sys_fdatasync(int fd); }
                    273: 149    STD             { int linux_sys___sysctl(struct linux___sysctl *lsp); }
                    274: 150    NOARGS          { int sys_mlock(caddr_t addr, size_t len); }
                    275: 151    NOARGS          { int sys_munlock(caddr_t addr, size_t len); }
                    276: 152    UNIMPL          mlockall
                    277: 153    UNIMPL          munlockall
1.9       tron      278: 154    STD             { int linux_sys_sched_setparam(pid_t pid, \
                    279:                            const struct linux_sched_param *sp); }
                    280: 155    STD             { int linux_sys_sched_getparam(pid_t pid, \
                    281:                            struct linux_sched_param *sp); }
                    282: 156    STD             { int linux_sys_sched_setscheduler(pid_t pid, \
                    283:                            int policy, const struct linux_sched_param *sp); }
                    284: 157    STD             { int linux_sys_sched_getscheduler(pid_t pid); }
                    285: 158    STD             { int linux_sys_sched_yield(void); }
                    286: 159    STD             { int linux_sys_sched_get_priority_max(int policy); }
                    287: 160    STD             { int linux_sys_sched_get_priority_min(int policy); }
1.1       itohy     288: 161    UNIMPL          sched_rr_get_interval
                    289: 162    NOARGS          { int sys_nanosleep(const struct timespec *rqtp, \
                    290:                                struct timespec *rmtp); }
                    291: 163    STD             { void *linux_sys_mremap(void *old_address, \
                    292:                            size_t old_size, size_t new_size, u_long flags); }
1.7       thorpej   293: 164    STD             { int linux_sys_setresuid(uid_t ruid, uid_t euid, \
                    294:                            uid_t suid); }
                    295: 165    STD             { int linux_sys_getresuid(uid_t *ruid, uid_t *euid, \
                    296:                            uid_t *suid); }
1.1       itohy     297: 166    UNIMPL          vm86
                    298: 167    UNIMPL          query_module
1.5       tron      299: 168    NOARGS          { int sys_poll(struct pollfd *fds, u_int nfds, \
                    300:                            int timeout); }
1.1       itohy     301: 169    UNIMPL          nfsservctl
1.7       thorpej   302: 170    STD             { int linux_sys_setresgid(gid_t rgid, gid_t egid, \
                    303:                            gid_t sgid); }
                    304: 171    STD             { int linux_sys_getresgid(gid_t *rgid, gid_t *egid, \
                    305:                            gid_t *sgid); }
1.1       itohy     306: 172    UNIMPL          prctl
                    307: 173    STD             { int linux_sys_rt_sigreturn(void); }
                    308: 174    STD             { int linux_sys_rt_sigaction(int signum, \
                    309:                            const struct linux_sigaction *nsa, \
                    310:                            struct linux_sigaction *osa, \
                    311:                            size_t sigsetsize); }
                    312: 175    STD             { int linux_sys_rt_sigprocmask(int how, \
                    313:                            const linux_sigset_t *set, \
                    314:                            linux_sigset_t *oset, \
                    315:                            size_t sigsetsize); }
                    316: 176    STD             { int linux_sys_rt_sigpending( \
                    317:                            linux_sigset_t *set, \
                    318:                            size_t sigsetsize); }
                    319: 177    UNIMPL          rt_sigtimedwait
                    320: ; XXX XAX int here?  sigset_t here?  siginfo_t
                    321: 178    STD             { int linux_sys_rt_queueinfo(int pid, int signum, \
                    322:                            void *uinfo); }
                    323: 179    STD             { int linux_sys_rt_sigsuspend(linux_sigset_t *unewset, \
                    324:                            size_t sigsetsize); }
1.11      tron      325: 180    STD             { int linux_sys_pread(int fd, char *buf, \
                    326:                            size_t nbyte, linux_off_t offset); }
                    327: 181    STD             { int linux_sys_pwrite(int fd, char *buf, \
                    328:                            size_t nbyte, linux_off_t offset); }
1.1       itohy     329: ;182 chown on i386; lchown on m68k.
1.2       itohy     330: 182    STD             { int linux_sys_lchown(const char *path, int uid, \
                    331:                            int gid); }
1.4       tron      332: 183    NOARGS          { int sys___getcwd(char *bufp, size_t length); }
1.1       itohy     333: 184    UNIMPL          capget
                    334: 185    UNIMPL          capset
                    335: 186    UNIMPL          sigaltstack
1.7       thorpej   336: 187    UNIMPL          sendfile
                    337: 188    UNIMPL          getpmsg
                    338: 189    UNIMPL          putpmsg
                    339: 190    NOARGS          { int sys___vfork14(void); }

CVSweb <webmaster@jp.NetBSD.org>