[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.2

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

CVSweb <webmaster@jp.NetBSD.org>