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

1.68.2.1! uebayasi    1:        $NetBSD$
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:
1.34      mrg        36: #if defined(_KERNEL_OPT)
1.1       itohy      37: #include "opt_compat_netbsd.h"
                     38: #include "opt_compat_43.h"
1.19      mycroft    39: #endif
1.1       itohy      40:
                     41: #include <sys/param.h>
1.5       tron       42: #include <sys/poll.h>
1.1       itohy      43: #include <sys/systm.h>
                     44: #include <sys/signal.h>
                     45: #include <sys/mount.h>
1.62      tsutsui    46: #include <sys/sched.h>
1.1       itohy      47: #include <sys/syscallargs.h>
                     48:
                     49: #include <compat/linux/common/linux_types.h>
                     50: #include <compat/linux/common/linux_signal.h>
                     51: #include <compat/linux/common/linux_siginfo.h>
                     52: #include <compat/linux/common/linux_machdep.h>
1.42      thorpej    53: #include <compat/linux/common/linux_mmap.h>
1.1       itohy      54:
                     55: #include <compat/linux/linux_syscallargs.h>
                     56:
1.20      mycroft    57: %%
1.1       itohy      58:
1.65      pooka      59: 0      NOARGS          { int|linux_sys||nosys(void); } syscall
1.68.2.1! uebayasi   60: 1      STD             { int|linux_sys||exit(int rval); }
1.65      pooka      61: 2      NOARGS          { int|sys||fork(void); }
                     62: 3      NOARGS          { int|sys||read(int fd, char *buf, u_int nbyte); }
                     63: 4      NOARGS          { int|sys||write(int fd, char *buf, u_int nbyte); }
                     64: 5      STD             { int|linux_sys||open(const char *path, int flags, \
1.2       itohy      65:                            int mode); }
1.65      pooka      66: 6      NOARGS          { int|sys||close(int fd); }
                     67: 7      STD             { int|linux_sys||waitpid(int pid, int *status, \
1.1       itohy      68:                            int options);}
1.65      pooka      69: 8      STD             { int|linux_sys||creat(const char *path, int mode); }
                     70: 9      NOARGS          { int|sys||link(const char *path, const char *link); }
                     71: 10     STD             { int|linux_sys||unlink(const char *path); }
                     72: 11     NOARGS          { int|sys||execve(const char *path, char **argp, \
1.1       itohy      73:                            char **envp); }
1.65      pooka      74: 12     NOARGS          { int|sys||chdir(const char *path); }
                     75: 13     STD             { int|linux_sys||time(linux_time_t *t); }
                     76: 14     STD             { int|linux_sys||mknod(const char *path, int mode, \
1.2       itohy      77:                            int dev); }
1.65      pooka      78: 15     NOARGS          { int|sys||chmod(const char *path, int mode); }
1.1       itohy      79: ;16 lchown on i386; chown on m68k.
1.65      pooka      80: 16     STD             { int|linux_sys||chown16(const char *path, \
1.59      njoly      81:                            linux_uid16_t uid, linux_gid16_t gid); }
1.1       itohy      82: 17     OBSOL           break
                     83: 18     OBSOL           ostat
                     84: #if !defined(_KERNEL) || defined(COMPAT_43)
1.65      pooka      85: 19     NOARGS          { long|compat_43_sys||lseek(int fd, long offset, \
1.1       itohy      86:                            int whence); }
                     87: #else
                     88: 19     UNIMPL          compat_43_sys_lseek
                     89: #endif
1.65      pooka      90: 20     NOARGS          { pid_t|sys||getpid(void); }
1.1       itohy      91: 21     UNIMPL          mount
                     92: 22     OBSOL           umount
1.65      pooka      93: 23     NOARGS          linux_setuid16 { int|sys||setuid(uid_t uid); }
                     94: 24     NOARGS          linux_getuid16 { uid_t|sys||getuid(void); }
                     95: 25     STD             { int|linux_sys||stime(linux_time_t *t); }
                     96: 26     STD             { int|linux_sys||ptrace(int request, int pid, \
1.12      tron       97:                          int addr, int data); }
1.65      pooka      98: 27     STD             { int|linux_sys||alarm(unsigned int secs); }
1.1       itohy      99: 28     OBSOL           ofstat
1.65      pooka     100: 29     STD             { int|linux_sys||pause(void); }
                    101: 30     STD             { int|linux_sys||utime(const char *path, \
1.1       itohy     102:                            struct linux_utimbuf *times); }
                    103: 31     OBSOL           stty
                    104: 32     OBSOL           gtty
1.65      pooka     105: 33     NOARGS          { int|sys||access(const char *path, int flags); }
                    106: 34     STD             { int|linux_sys||nice(int incr); }
1.1       itohy     107: 35     OBSOL           ftime
1.65      pooka     108: 36     NOARGS          { int|sys||sync(void); }
                    109: 37     STD             { int|linux_sys||kill(int pid, int signum); }
                    110: 38     NOARGS          { int|sys||__posix_rename(const char *from, \
1.2       itohy     111:                            const char *to); }
1.65      pooka     112: 39     NOARGS          { int|sys||mkdir(const char *path, int mode); }
                    113: 40     NOARGS          { int|sys||rmdir(const char *path); }
                    114: 41     NOARGS          { int|sys||dup(u_int fd); }
                    115: 42     STD             { int|linux_sys||pipe(int *pfds); }
                    116: 43     STD             { int|linux_sys||times(struct times *tms); }
1.1       itohy     117: 44     OBSOL           prof
1.65      pooka     118: 45     STD             { int|linux_sys||brk(char *nsize); }
                    119: 46     NOARGS          linux_setgid16 { int|sys||setgid(gid_t gid); }
                    120: 47     NOARGS          linux_getgid16 { gid_t|sys||getgid(void); }
                    121: 48     STD             { int|linux_sys||signal(int signum, \
1.1       itohy     122:                            linux_handler_t handler); }
1.65      pooka     123: 49     NOARGS          linux_geteuid16 { uid_t|sys||geteuid(void); }
                    124: 50     NOARGS          linux_getegid16 { gid_t|sys||getegid(void); }
                    125: 51     NOARGS          { int|sys||acct(char *path); }
1.1       itohy     126: 52     UNIMPL          umount
                    127: 53     OBSOL           lock
1.65      pooka     128: 54     STD             { int|linux_sys||ioctl(int fd, u_long com, \
1.54      christos  129:                            void *data); }
1.65      pooka     130: 55     STD             { int|linux_sys||fcntl(int fd, int cmd, void *arg); }
1.1       itohy     131: 56     OBSOL           mpx
1.65      pooka     132: 57     NOARGS          { int|sys||setpgid(int pid, int pgid); }
1.1       itohy     133: 58     OBSOL           ulimit
                    134: 59     UNIMPL          oldolduname
1.65      pooka     135: 60     NOARGS          { int|sys||umask(int newmask); }
                    136: 61     NOARGS          { int|sys||chroot(char *path); }
1.1       itohy     137: 62     UNIMPL          ustat
1.65      pooka     138: 63     NOARGS          { int|sys||dup2(u_int from, u_int to); }
                    139: 64     NOARGS          { pid_t|sys||getppid(void); }
                    140: 65     NOARGS          { int|sys||getpgrp(void); }
                    141: 66     NOARGS          { int|sys||setsid(void); }
                    142: 67     STD             { int|linux_sys||sigaction(int signum, \
1.1       itohy     143:                            const struct linux_old_sigaction *nsa, \
                    144:                            struct linux_old_sigaction *osa); }
1.65      pooka     145: 68     STD             { int|linux_sys||siggetmask(void); }
                    146: 69     STD             { int|linux_sys||sigsetmask(linux_old_sigset_t mask); }
                    147: 70     STD             { int|linux_sys||setreuid16(linux_uid16_t ruid, \
1.59      njoly     148:                            linux_uid16_t euid); }
1.65      pooka     149: 71     STD             { int|linux_sys||setregid16(linux_gid16_t rgid, \
1.59      njoly     150:                            linux_gid16_t egid); }
1.65      pooka     151: 72     STD             { int|linux_sys||sigsuspend(void *restart, \
1.1       itohy     152:                            int oldmask, int mask); }
1.65      pooka     153: 73     STD             { int|linux_sys||sigpending(linux_old_sigset_t *set); }
1.1       itohy     154: #if !defined(_KERNEL) || defined(COMPAT_43)
1.65      pooka     155: 74     NOARGS          { int|compat_43_sys||sethostname(char *hostname, \
1.1       itohy     156:                            u_int len);}
                    157: #else
                    158: 74     UNIMPL          compat_43_sys_sethostname
                    159: #endif
1.65      pooka     160: 75     STD             { int|linux_sys||setrlimit(u_int which, \
1.36      christos  161:                            struct orlimit *rlp); }
1.65      pooka     162: 76     STD             { int|linux_sys||getrlimit(u_int which, \
1.36      christos  163:                            struct orlimit *rlp); }
1.65      pooka     164: 77     NOARGS          { int|compat_50_sys||getrusage(int who, \
1.64      tsutsui   165:                            struct rusage50 *rusage); }
1.65      pooka     166: 78     STD             { int|linux_sys||gettimeofday(struct timeval50 *tp, \
1.1       itohy     167:                            struct timezone *tzp); }
1.65      pooka     168: 79     STD             { int|linux_sys||settimeofday(struct timeval50 *tp, \
1.1       itohy     169:                            struct timezone *tzp); }
1.65      pooka     170: 80     STD             { int|linux_sys||getgroups16(int gidsetsize, \
1.59      njoly     171:                            linux_gid16_t *gidset); }
1.65      pooka     172: 81     STD             { int|linux_sys||setgroups16(int gidsetsize, \
1.59      njoly     173:                            linux_gid16_t *gidset); }
1.65      pooka     174: 82     STD             { int|linux_sys||oldselect(struct linux_oldselect *lsp); }
                    175: 83     NOARGS          { int|sys||symlink(const char *path, const char *to); }
1.1       itohy     176: #if !defined(_KERNEL) || defined(COMPAT_43)
1.65      pooka     177: 84     NOARGS          { int|compat_43_sys||lstat(const char *path, \
1.1       itohy     178:                            struct stat43 *up); } oolstat
                    179: #else
                    180: 84     UNIMPL          compat_43_sys_lstat
                    181: #endif
1.65      pooka     182: 85     NOARGS          { int|sys||readlink(const char *name, char *buf, \
1.1       itohy     183:                            int count); }
1.47      joerg     184: #ifdef EXEC_AOUT
1.65      pooka     185: 86     STD             { int|linux_sys||uselib(const char *path); }
1.47      joerg     186: #else
                    187: 86     UNIMPL          sys_uselib
                    188: #endif
1.65      pooka     189: 87     STD             { int|linux_sys||swapon(char *name); }
                    190: 88     STD             { int|linux_sys||reboot(int magic1, int magic2, \
1.14      erh       191:                            int cmd, void *arg); }
1.65      pooka     192: 89     STD             { int|linux_sys||readdir(int fd, void *dent, \
1.1       itohy     193:                            unsigned int count); }
1.65      pooka     194: 90     STD             { int|linux_sys||old_mmap(struct linux_oldmmap *lmp); }
                    195: 91     NOARGS          { int|sys||munmap(void *addr, int len); }
                    196: 92     NOARGS          { int|compat_43_sys||truncate(const char *path, \
1.2       itohy     197:                            long length); }
1.1       itohy     198: #if !defined(_KERNEL) || defined(COMPAT_43)
1.65      pooka     199: 93     NOARGS          { int|compat_43_sys||ftruncate(int fd, long length); }
1.1       itohy     200: #else
                    201: 93     UNIMPL          compat_43_sys_ftruncate
                    202: #endif
1.65      pooka     203: 94     NOARGS          { int|sys||fchmod(int fd, int mode); }
                    204: 95     STD             { int|linux_sys||fchown16(int fd, linux_uid16_t uid, \
1.59      njoly     205:                            linux_gid16_t gid); }
1.65      pooka     206: 96     STD             { int|linux_sys||getpriority(int which, int who); }
                    207: 97     NOARGS          { int|sys||setpriority(int which, int who, int prio); }
                    208: 98     NOARGS          { int|sys||profil(void *samples, u_int size, \
1.1       itohy     209:                            u_int offset, u_int scale); }
1.65      pooka     210: 99     STD             { int|linux_sys||statfs(const char *path, \
1.1       itohy     211:                            struct linux_statfs *sp); }
1.65      pooka     212: 100    STD             { int|linux_sys||fstatfs(int fd, \
1.1       itohy     213:                            struct linux_statfs *sp); }
                    214: 101    UNIMPL          ioperm
1.65      pooka     215: 102    STD             { int|linux_sys||socketcall(int what, void *args); }
1.1       itohy     216: 103    UNIMPL          syslog
1.65      pooka     217: 104    NOARGS          { int|compat_50_sys||setitimer(u_int which, \
1.64      tsutsui   218:                            struct itimerval50 *itv, \
                    219:                            struct itimerval50 *oitv); }
1.65      pooka     220: 105    NOARGS          { int|compat_50_sys||getitimer(u_int which, \
1.64      tsutsui   221:                            struct itimerval50 *itv); }
1.65      pooka     222: 106    STD             { int|linux_sys||stat(const char *path, \
1.1       itohy     223:                            struct linux_stat *sp); }
1.65      pooka     224: 107    STD             { int|linux_sys||lstat(const char *path, \
1.1       itohy     225:                            struct linux_stat *sp); }
1.65      pooka     226: 108    STD             { int|linux_sys||fstat(int fd, struct linux_stat *sp); }
1.1       itohy     227: 109    UNIMPL          olduname
                    228: 110    UNIMPL          iopl
                    229: 111    UNIMPL          vhangup
                    230: 112    UNIMPL          idle
                    231: 113    UNIMPL          vm86old
1.65      pooka     232: 114    STD             { int|linux_sys||wait4(int pid, int *status, \
1.66      njoly     233:                            int options, struct rusage50 *rusage); }
1.65      pooka     234: 115    STD             { int|linux_sys||swapoff(const char *path); }
                    235: 116    STD             { int|linux_sys||sysinfo(struct linux_sysinfo *arg); }
                    236: 117    STD             { int|linux_sys||ipc(int what, int a1, int a2, int a3, \
1.54      christos  237:                            void *ptr); }
1.65      pooka     238: 118    NOARGS          { int|sys||fsync(int fd); }
                    239: 119    STD             { int|linux_sys||sigreturn(void); }
1.68.2.1! uebayasi  240: 120    STD             { int|linux_sys||clone(int flags, void *stack, \
        !           241:                            void *parent_tidptr, void *tls, void *child_tidptr); }
1.65      pooka     242: 121    STD             { int|linux_sys||setdomainname(char *domainname, \
1.1       itohy     243:                            int len); }
1.65      pooka     244: 122    STD             { int|linux_sys||uname(struct linux_utsname *up); }
                    245: 123    STD             { int|linux_sys||cacheflush(unsigned long addr, \
1.1       itohy     246:                            int scope, int cache, unsigned long len); }
                    247: 124    UNIMPL          adjtimex
1.65      pooka     248: 125    STD             { int|linux_sys||mprotect(const void *start, \
1.37      christos  249:                            unsigned long len, int prot); }
1.65      pooka     250: 126    STD             { int|linux_sys||sigprocmask(int how, \
1.1       itohy     251:                            const linux_old_sigset_t *set, \
                    252:                            linux_old_sigset_t *oset); }
                    253: 127    UNIMPL          create_module
                    254: 128    UNIMPL          init_module
                    255: 129    UNIMPL          delete_module
                    256: 130    UNIMPL          get_kernel_syms
                    257: 131    UNIMPL          quotactl
1.65      pooka     258: 132    NOARGS          { pid_t|sys||getpgid(pid_t pid); }
                    259: 133    NOARGS          { int|sys||fchdir(int fd); }
1.1       itohy     260: 134    UNIMPL          bdflush
                    261: 135    UNIMPL          sysfs
1.68      njoly     262: 136    STD             { int|linux_sys||personality(unsigned long per); }
1.1       itohy     263: 137    UNIMPL          afs_syscall
1.65      pooka     264: 138    NOARGS          linux_setfsuid16 { int|linux_sys||setfsuid(uid_t uid); }
                    265: 139    NOARGS          linux_setfsgid16 { int|linux_sys||setfsgid(gid_t gid); }
                    266: 140    STD             { int|linux_sys||llseek(int fd, u_int32_t ohigh, \
1.54      christos  267:                            u_int32_t olow, void *res, int whence); }
1.65      pooka     268: 141    STD             { int|linux_sys||getdents(int fd, \
1.1       itohy     269:                            struct linux_dirent *dent, unsigned int count); }
1.65      pooka     270: 142    STD             { int|linux_sys||select(int nfds, fd_set *readfds, \
1.1       itohy     271:                            fd_set *writefds, fd_set *exceptfds, \
1.64      tsutsui   272:                            struct timeval50 *timeout); }
1.65      pooka     273: 143    NOARGS          { int|sys||flock(int fd, int how); }
                    274: 144    NOARGS          { int|sys|13|msync(void *addr, size_t len, int flags); }
                    275: 145    NOARGS          { int|sys||readv(int fd, struct iovec *iovp, \
1.1       itohy     276:                                u_int iovcnt); }
1.65      pooka     277: 146    NOARGS          { int|sys||writev(int fd, struct iovec *iovp, \
1.1       itohy     278:                                u_int iovcnt); }
1.65      pooka     279: 147    NOARGS          { pid_t|sys||getsid(pid_t pid); }
                    280: 148    STD             { int|linux_sys||fdatasync(int fd); }
                    281: 149    STD             { int|linux_sys||__sysctl(struct linux___sysctl *lsp); }
                    282: 150    NOARGS          { int|sys||mlock(void *addr, size_t len); }
                    283: 151    NOARGS          { int|sys||munlock(void *addr, size_t len); }
                    284: 152    NOARGS          { int|sys||mlockall(int flags); }
                    285: 153    NOARGS          { int|sys||munlockall(void); }
                    286: 154    STD             { int|linux_sys||sched_setparam(pid_t pid, \
1.9       tron      287:                            const struct linux_sched_param *sp); }
1.65      pooka     288: 155    STD             { int|linux_sys||sched_getparam(pid_t pid, \
1.9       tron      289:                            struct linux_sched_param *sp); }
1.65      pooka     290: 156    STD             { int|linux_sys||sched_setscheduler(pid_t pid, \
1.9       tron      291:                            int policy, const struct linux_sched_param *sp); }
1.65      pooka     292: 157    STD             { int|linux_sys||sched_getscheduler(pid_t pid); }
                    293: 158    STD             { int|linux_sys||sched_yield(void); }
                    294: 159    STD             { int|linux_sys||sched_get_priority_max(int policy); }
                    295: 160    STD             { int|linux_sys||sched_get_priority_min(int policy); }
1.1       itohy     296: 161    UNIMPL          sched_rr_get_interval
1.65      pooka     297: 162    STD             { int|linux_sys||nanosleep( \
1.63      njoly     298:                            const struct linux_timespec *rqtp, \
                    299:                            struct linux_timespec *rmtp); }
1.65      pooka     300: 163    STD             { void *|linux_sys||mremap(void *old_address, \
1.1       itohy     301:                            size_t old_size, size_t new_size, u_long flags); }
1.65      pooka     302: 164    STD             { int|linux_sys||setresuid16(linux_uid16_t ruid, \
1.59      njoly     303:                            linux_uid16_t euid, linux_uid16_t suid); }
1.65      pooka     304: 165    STD             { int|linux_sys||getresuid16(linux_uid16_t *ruid, \
1.59      njoly     305:                            linux_uid16_t *euid, linux_uid16_t *suid); }
1.1       itohy     306: 166    UNIMPL          vm86
                    307: 167    UNIMPL          query_module
1.65      pooka     308: 168    NOARGS          { int|sys||poll(struct pollfd *fds, u_int nfds, \
1.5       tron      309:                            int timeout); }
1.1       itohy     310: 169    UNIMPL          nfsservctl
1.65      pooka     311: 170    STD             { int|linux_sys||setresgid16(linux_gid16_t rgid, \
1.59      njoly     312:                            linux_gid16_t egid, linux_gid16_t sgid); }
1.65      pooka     313: 171    STD             { int|linux_sys||getresgid16(linux_gid16_t *rgid, \
1.59      njoly     314:                            linux_gid16_t *egid, linux_gid16_t *sgid); }
1.1       itohy     315: 172    UNIMPL          prctl
1.65      pooka     316: 173    STD             { int|linux_sys||rt_sigreturn(void); }
                    317: 174    STD             { int|linux_sys||rt_sigaction(int signum, \
1.1       itohy     318:                            const struct linux_sigaction *nsa, \
                    319:                            struct linux_sigaction *osa, \
                    320:                            size_t sigsetsize); }
1.65      pooka     321: 175    STD             { int|linux_sys||rt_sigprocmask(int how, \
1.1       itohy     322:                            const linux_sigset_t *set, \
                    323:                            linux_sigset_t *oset, \
                    324:                            size_t sigsetsize); }
1.65      pooka     325: 176    STD             { int|linux_sys||rt_sigpending( \
1.1       itohy     326:                            linux_sigset_t *set, \
                    327:                            size_t sigsetsize); }
                    328: 177    UNIMPL          rt_sigtimedwait
1.65      pooka     329: 178    STD             { int|linux_sys||rt_queueinfo(int pid, int signum, \
1.67      njoly     330:                            linux_siginfo_t *uinfo); }
1.65      pooka     331: 179    STD             { int|linux_sys||rt_sigsuspend(linux_sigset_t *unewset, \
1.1       itohy     332:                            size_t sigsetsize); }
1.65      pooka     333: 180    STD             { int|linux_sys||pread(int fd, char *buf, \
1.11      tron      334:                            size_t nbyte, linux_off_t offset); }
1.65      pooka     335: 181    STD             { int|linux_sys||pwrite(int fd, char *buf, \
1.11      tron      336:                            size_t nbyte, linux_off_t offset); }
1.1       itohy     337: ;182 chown on i386; lchown on m68k.
1.65      pooka     338: 182    STD             { int|linux_sys||lchown16(const char *path, \
1.59      njoly     339:                            linux_uid16_t uid, linux_gid16_t gid); }
1.65      pooka     340: 183    NOARGS          { int|sys||__getcwd(char *bufp, size_t length); }
1.1       itohy     341: 184    UNIMPL          capget
                    342: 185    UNIMPL          capset
1.65      pooka     343: 186    STD             { int|linux_sys||sigaltstack( \
1.15      itohy     344:                            const struct linux_sigaltstack *ss, \
                    345:                            struct linux_sigaltstack *oss); }
1.7       thorpej   346: 187    UNIMPL          sendfile
                    347: 188    UNIMPL          getpmsg
                    348: 189    UNIMPL          putpmsg
1.65      pooka     349: 190    NOARGS          { int|sys|14|vfork(void); }
                    350: 191    STD             { int|linux_sys||ugetrlimit(int which, \
1.36      christos  351:                            struct orlimit *rlp); }
1.56      dsl       352: #define linux_sys_mmap2_args linux_sys_mmap_args
1.65      pooka     353: 192    NOARGS          { linux_off_t|linux_sys||mmap2(unsigned long addr, \
1.41      christos  354:                            size_t len, int prot, int flags, int fd, \
                    355:                            linux_off_t offset); }
1.65      pooka     356: 193    STD             { int|linux_sys||truncate64(const char *path, \
1.35      christos  357:                            off_t length); }
1.65      pooka     358: 194    STD             { int|linux_sys||ftruncate64(unsigned int fd, \
1.43      jdolecek  359:                            off_t length); }
1.65      pooka     360: 195    STD             { int|linux_sys||stat64(const char *path, \
1.35      christos  361:                            struct linux_stat64 *sp); }
1.65      pooka     362: 196    STD             { int|linux_sys||lstat64(const char *path, \
1.35      christos  363:                            struct linux_stat64 *sp); }
1.65      pooka     364: 197    STD             { int|linux_sys||fstat64(int fd, \
1.35      christos  365:                            struct linux_stat64 *sp); }
1.65      pooka     366: 198    NOARGS           { int|sys||__posix_chown(const char *path, uid_t uid, \
1.35      christos  367:                            gid_t gid); }
1.65      pooka     368: 199    NOARGS          { uid_t|sys||getuid(void); }
                    369: 200    NOARGS          { gid_t|sys||getgid(void); }
                    370: 201    NOARGS          { uid_t|sys||geteuid(void); }
                    371: 202    NOARGS          { gid_t|sys||getegid(void); }
                    372: 203    NOARGS          { int|sys||setreuid(uid_t ruid, uid_t euid); }
                    373: 204    NOARGS          { int|sys||setregid(gid_t rgid, gid_t egid); }
                    374: 205    NOARGS          { int|sys||getgroups(u_int gidsetsize, gid_t *gidset); }
                    375: 206    NOARGS          { int|sys||setgroups(u_int gidsetsize, gid_t *gidset); }
                    376: 207    NOARGS          { int|sys||__posix_fchown(int fd, uid_t uid, \
1.35      christos  377:                            gid_t gid); }
1.65      pooka     378: 208    STD             { int|linux_sys||setresuid(uid_t ruid, uid_t euid, \
1.27      fvdl      379:                            uid_t suid); }
1.65      pooka     380: 209    STD             { int|linux_sys||getresuid(uid_t *ruid, uid_t *euid, \
1.27      fvdl      381:                            uid_t *suid); }
1.65      pooka     382: 210    STD             { int|linux_sys||setresgid(gid_t rgid, gid_t egid, \
1.27      fvdl      383:                            gid_t sgid); }
1.65      pooka     384: 211    STD             { int|linux_sys||getresgid(gid_t *rgid, gid_t *egid, \
1.27      fvdl      385:                            gid_t *sgid); }
1.65      pooka     386: 212    NOARGS          { int|sys||__posix_lchown(const char *path, uid_t uid, \
1.35      christos  387:                            gid_t gid); }
1.65      pooka     388: 213    NOARGS          { int|sys||setuid(uid_t uid); }
                    389: 214    NOARGS          { int|sys||setgid(gid_t gid); }
                    390: 215    STD             { int|linux_sys||setfsuid(uid_t uid); }
                    391: 216    STD             { int|linux_sys||setfsgid(gid_t gid); }
1.39      jdolecek  392: 217    UNIMPL          /* unused */
                    393: 218    UNIMPL          /* unused */
                    394: 219    UNIMPL          /* unused */
1.65      pooka     395: 220    STD             { int|linux_sys||getdents64(int fd, \
1.38      christos  396:                            struct linux_dirent64 *dent, unsigned int count); }
1.68.2.1! uebayasi  397: 221    NOARGS          { pid_t|linux_sys||gettid(void); }
        !           398: 222    STD             { int|linux_sys||tkill(int tid, int sig); }
1.65      pooka     399: 223    STD             { int|linux_sys||setxattr(char *path, char *name, \
1.45      fvdl      400:                            void *value, size_t size, int flags); }
1.65      pooka     401: 224    STD             { int|linux_sys||lsetxattr(char *path, char *name, \
1.45      fvdl      402:                            void *value, size_t size, int flags); }
1.65      pooka     403: 225    STD             { int|linux_sys||fsetxattr(int fd, char *name, \
1.45      fvdl      404:                            void *value, size_t size, int flags); }
1.65      pooka     405: 226    STD             { ssize_t|linux_sys||getxattr(char *path, char *name, \
1.45      fvdl      406:                            void *value, size_t size); }
1.65      pooka     407: 227    STD             { ssize_t|linux_sys||lgetxattr(char *path, char *name, \
1.45      fvdl      408:                            void *value, size_t size); }
1.65      pooka     409: 228    STD             { ssize_t|linux_sys||fgetxattr(int fd, char *name, \
1.45      fvdl      410:                            void *value, size_t size); }
1.65      pooka     411: 229    STD             { ssize_t|linux_sys||listxattr(char *path, char *list, \
1.45      fvdl      412:                            size_t size); }
1.65      pooka     413: 230    STD             { ssize_t|linux_sys||llistxattr(char *path, char *list, \
1.45      fvdl      414:                            size_t size); }
1.65      pooka     415: 231    STD             { ssize_t|linux_sys||flistxattr(int fd, char *list, \
1.45      fvdl      416:                            size_t size); }
1.65      pooka     417: 232    STD             { int|linux_sys||removexattr(char *path, char *name); }
                    418: 233    STD             { int|linux_sys||lremovexattr(char *path, char *name); }
                    419: 234    STD             { int|linux_sys||fremovexattr(int fd, char *name); }
1.68.2.1! uebayasi  420: 235    STD             { int|linux_sys||futex(int *uaddr, int op, int val, \
        !           421:                            const struct linux_timespec *timeout, int *uaddr2, \
        !           422:                            int val3); }
1.46      jmc       423: 236    UNIMPL          sendfile64
                    424: 237    UNIMPL          mincore
                    425: 238    UNIMPL          madvise
                    426: 239    UNIMPL          fcntl64
                    427: 240    UNIMPL          readahead
                    428: 241    UNIMPL          io_setup
                    429: 242    UNIMPL          io_destroy
                    430: 243    UNIMPL          io_getevents
                    431: 244    UNIMPL          io_submit
                    432: 245    UNIMPL          io_cancel
                    433: 246    UNIMPL          fadvise64
                    434: 247    UNIMPL          exit_group
                    435: 248    UNIMPL          lookup_dcookie
                    436: 249    UNIMPL          epoll_create
                    437: 250    UNIMPL          epoll_ctl
                    438: 251    UNIMPL          epoll_wait
                    439: 252    UNIMPL          remap_file_pages
1.68.2.1! uebayasi  440: 253    STD             { int|linux_sys||set_tid_address(int *tid); }
1.46      jmc       441: 254    UNIMPL          timer_create
                    442: 255    UNIMPL          timer_settime
                    443: 256    UNIMPL          timer_gettime
                    444: 257    UNIMPL          timer_getoverrun
1.68.2.1! uebayasi  445: 258    UNIMPL          timer_ delete
1.65      pooka     446: 259    STD             { int|linux_sys||clock_settime(clockid_t which, \
1.46      jmc       447:                            struct linux_timespec *tp); }
1.65      pooka     448: 260    STD             { int|linux_sys||clock_gettime(clockid_t which, \
1.46      jmc       449:                            struct linux_timespec *tp); }
1.65      pooka     450: 261    STD             { int|linux_sys||clock_getres(clockid_t which, \
1.46      jmc       451:                            struct linux_timespec *tp); }
1.65      pooka     452: 262    STD             { int|linux_sys||clock_nanosleep(clockid_t which, \
1.46      jmc       453:                            int flags, struct linux_timespec *rqtp, \
                    454:                            struct linux_timespec *rmtp); }
1.68.2.1! uebayasi  455: 263    STD             { int|linux_sys||statfs64(const char *path, \
        !           456:                            size_t sz, struct linux_statfs64 *sp); }
        !           457: 264    STD             { int|linux_sys||fstatfs64(int fd, \
        !           458:                            size_t sz, struct linux_statfs64 *sp); }
        !           459: 265    STD             { int|linux_sys||tgkill(int tgid, int tid, int sig); }
        !           460: 266    UNIMPL          utimes
        !           461: 267    UNIMPL          fadvise64_64
        !           462: 268    UNIMPL          mbind
        !           463: 269    UNIMPL          get_mempolicy
        !           464: 270    UNIMPL          set_mempolicy
        !           465: 271    UNIMPL          mq_open
        !           466: 272    UNIMPL          mq_unlink
        !           467: 273    UNIMPL          mq_timedsend
        !           468: 274    UNIMPL          mq_timedreceive
        !           469: 275    UNIMPL          mq_notify
        !           470: 276    UNIMPL          mq_getsetattr
        !           471: 277    UNIMPL          waitid
        !           472: 278    UNIMPL          vserver
        !           473: 279    UNIMPL          add_key
        !           474: 280    UNIMPL          request_key
        !           475: 281    UNIMPL          keyctl
        !           476: 282    UNIMPL          ioprio_set
        !           477: 283    UNIMPL          ioprio_get
        !           478: 284    UNIMPL          inotify_init
        !           479: 285    UNIMPL          inotify_add_watch
        !           480: 286    UNIMPL          inotify_rm_watch
        !           481: 287    UNIMPL          migrate_pages
        !           482: 288    UNIMPL          openat
        !           483: 289    UNIMPL          mkdirat
        !           484: 290    UNIMPL          mknodat
        !           485: 291    UNIMPL          fchownat
        !           486: 292    UNIMPL          futimesat
        !           487: 293    UNIMPL          fstatat64
        !           488: 294    UNIMPL          unlinkat
        !           489: 295    UNIMPL          renameat
        !           490: 296    UNIMPL          linkat
        !           491: 297    UNIMPL          symlinkat
        !           492: 298    UNIMPL          readlinkat
        !           493: 299    UNIMPL          fchmodat
        !           494: 300    UNIMPL          faccessat
        !           495: 301    UNIMPL          pselect6
        !           496: 302    UNIMPL          ppoll
        !           497: 303    UNIMPL          unshare
        !           498: 304    STD             { int|linux_sys||set_robust_list( \
        !           499:                            struct linux_robust_list_head *head, size_t len); }
        !           500: 305    STD             { int|linux_sys||get_robust_list(int pid, \
        !           501:                            struct linux_robust_list_head **head, \
        !           502:                            size_t *len); }
        !           503: 306    UNIMPL          splice
        !           504: 307    UNIMPL          sync_file_range
        !           505: 308    UNIMPL          tee
        !           506: 309    UNIMPL          vmsplice
        !           507: 310    UNIMPL          move_pages
        !           508: 311    STD             { int|linux_sys||sched_setaffinity(pid_t pid, \
        !           509:                            unsigned int len, unsigned long *mask); }
        !           510: 312    STD             { int|linux_sys||sched_getaffinity(pid_t pid, \
        !           511:                            unsigned int len, unsigned long *mask); }
        !           512: 313    UNIMPL          kexec_load
        !           513: 314    UNIMPL          getcpu
        !           514: 315    UNIMPL          epoll_wait
        !           515: 316    UNIMPL          utimensat
        !           516: 317    UNIMPL          signalfd
        !           517: 318    UNIMPL          timerfd_create
        !           518: 319    UNIMPL          eventfd
        !           519: 320    UNIMPL          fallocate
        !           520: 321    UNIMPL          timerfd_settime
        !           521: 322    UNIMPL          timerfd_gettime
        !           522: 323    UNIMPL          signalfd4
        !           523: 324    UNIMPL          eventfd2
        !           524: 325    UNIMPL          epoll_create1
        !           525: 326    UNIMPL          dup3
        !           526: 327    UNIMPL          pipe2
        !           527: 328    UNIMPL          inotify_init1
        !           528: 329    UNIMPL          preadv
        !           529: 330    UNIMPL          pwritev
        !           530: 331    UNIMPL          rt_tgsigqueueinfo
        !           531: 332    UNIMPL          perf_counter_open
        !           532: 333    UNIMPL          set_thread_area
        !           533: 334    UNIMPL          get_thread_area
        !           534: 335    UNIMPL          atomic_cmpxchg_32
        !           535: 336    UNIMPL          atomic_barrier

CVSweb <webmaster@jp.NetBSD.org>