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

1.55.2.1! ad          1:        $NetBSD: syscalls.master,v 1.58 2007/12/24 14:17:18 njoly 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:
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>
                     46: #include <sys/syscallargs.h>
                     47:
                     48: #include <compat/linux/common/linux_types.h>
                     49: #include <compat/linux/common/linux_signal.h>
                     50: #include <compat/linux/common/linux_siginfo.h>
                     51: #include <compat/linux/common/linux_machdep.h>
1.42      thorpej    52: #include <compat/linux/common/linux_mmap.h>
1.1       itohy      53:
                     54: #include <compat/linux/linux_syscallargs.h>
                     55:
1.20      mycroft    56: %%
1.1       itohy      57:
1.30      jdolecek   58: 0      NOARGS          { int linux_sys_nosys(void); } syscall
1.1       itohy      59: 1      NOARGS          { int sys_exit(int rval); }
                     60: 2      NOARGS          { int sys_fork(void); }
                     61: 3      NOARGS          { int sys_read(int fd, char *buf, u_int nbyte); }
                     62: 4      NOARGS          { int sys_write(int fd, char *buf, u_int nbyte); }
1.2       itohy      63: 5      STD             { int linux_sys_open(const char *path, int flags, \
                     64:                            int mode); }
1.1       itohy      65: 6      NOARGS          { int sys_close(int fd); }
                     66: 7      STD             { int linux_sys_waitpid(int pid, int *status, \
                     67:                            int options);}
1.2       itohy      68: 8      STD             { int linux_sys_creat(const char *path, int mode); }
1.55      njoly      69: 9      NOARGS          { int sys_link(const char *path, const char *link); }
1.2       itohy      70: 10     STD             { int linux_sys_unlink(const char *path); }
1.55      njoly      71: 11     NOARGS          { int sys_execve(const char *path, char **argp, \
1.1       itohy      72:                            char **envp); }
1.55      njoly      73: 12     NOARGS          { int sys_chdir(const char *path); }
1.1       itohy      74: 13     STD             { int linux_sys_time(linux_time_t *t); }
1.2       itohy      75: 14     STD             { int linux_sys_mknod(const char *path, int mode, \
                     76:                            int dev); }
1.55      njoly      77: 15     NOARGS          { int sys_chmod(const char *path, int mode); }
1.1       itohy      78: ;16 lchown on i386; chown on m68k.
1.25      fvdl       79: 16     STD             { int linux_sys_chown16(const char *path, \
1.2       itohy      80:                            int uid, int gid); }
1.1       itohy      81: 17     OBSOL           break
                     82: 18     OBSOL           ostat
                     83: #if !defined(_KERNEL) || defined(COMPAT_43)
                     84: 19     NOARGS          { long compat_43_sys_lseek(int fd, long offset, \
                     85:                            int whence); }
                     86: #else
                     87: 19     UNIMPL          compat_43_sys_lseek
                     88: #endif
1.29      thorpej    89: 20     NOARGS MPSAFE   { pid_t sys_getpid(void); }
1.1       itohy      90: 21     UNIMPL          mount
                     91: 22     OBSOL           umount
1.27      fvdl       92: 23     NOARGS          linux_setuid16 { int sys_setuid(uid_t uid); }
                     93: 24     NOARGS          linux_getuid16 { uid_t sys_getuid(void); }
1.8       tron       94: 25     STD             { int linux_sys_stime(linux_time_t *t); }
1.12      tron       95: 26     STD             { int linux_sys_ptrace(int request, int pid, \
                     96:                          int addr, int data); }
1.1       itohy      97: 27     STD             { int linux_sys_alarm(unsigned int secs); }
                     98: 28     OBSOL           ofstat
                     99: 29     STD             { int linux_sys_pause(void); }
1.2       itohy     100: 30     STD             { int linux_sys_utime(const char *path, \
1.1       itohy     101:                            struct linux_utimbuf *times); }
                    102: 31     OBSOL           stty
                    103: 32     OBSOL           gtty
1.55      njoly     104: 33     NOARGS          { int sys_access(const char *path, int flags); }
1.1       itohy     105: 34     STD             { int linux_sys_nice(int incr); }
                    106: 35     OBSOL           ftime
                    107: 36     NOARGS          { int sys_sync(void); }
                    108: 37     STD             { int linux_sys_kill(int pid, int signum); }
1.55      njoly     109: 38     NOARGS          { int sys___posix_rename(const char *from, \
1.2       itohy     110:                            const char *to); }
1.55      njoly     111: 39     NOARGS          { int sys_mkdir(const char *path, int mode); }
                    112: 40     NOARGS          { int sys_rmdir(const char *path); }
1.1       itohy     113: 41     NOARGS          { int sys_dup(u_int fd); }
                    114: 42     STD             { int linux_sys_pipe(int *pfds); }
                    115: 43     STD             { int linux_sys_times(struct times *tms); }
                    116: 44     OBSOL           prof
                    117: 45     STD             { int linux_sys_brk(char *nsize); }
1.27      fvdl      118: 46     NOARGS          linux_setgid16 { int sys_setgid(gid_t gid); }
                    119: 47     NOARGS          linux_getgid16 { gid_t sys_getgid(void); }
1.10      tron      120: 48     STD             { int linux_sys_signal(int signum, \
1.1       itohy     121:                            linux_handler_t handler); }
1.27      fvdl      122: 49     NOARGS          linux_geteuid16 { uid_t sys_geteuid(void); }
                    123: 50     NOARGS          linux_getegid16 { gid_t sys_getegid(void); }
1.1       itohy     124: 51     NOARGS          { int sys_acct(char *path); }
                    125: 52     UNIMPL          umount
                    126: 53     OBSOL           lock
                    127: 54     STD             { int linux_sys_ioctl(int fd, u_long com, \
1.54      christos  128:                            void *data); }
1.1       itohy     129: 55     STD             { int linux_sys_fcntl(int fd, int cmd, void *arg); }
                    130: 56     OBSOL           mpx
                    131: 57     NOARGS          { int sys_setpgid(int pid, int pgid); }
                    132: 58     OBSOL           ulimit
                    133: 59     UNIMPL          oldolduname
                    134: 60     NOARGS          { int sys_umask(int newmask); }
                    135: 61     NOARGS          { int sys_chroot(char *path); }
                    136: 62     UNIMPL          ustat
                    137: 63     NOARGS          { int sys_dup2(u_int from, u_int to); }
                    138: 64     NOARGS          { pid_t sys_getppid(void); }
                    139: 65     NOARGS          { int sys_getpgrp(void); }
                    140: 66     NOARGS          { int sys_setsid(void); }
                    141: 67     STD             { int linux_sys_sigaction(int signum, \
                    142:                            const struct linux_old_sigaction *nsa, \
                    143:                            struct linux_old_sigaction *osa); }
                    144: 68     STD             { int linux_sys_siggetmask(void); }
                    145: 69     STD             { int linux_sys_sigsetmask(linux_old_sigset_t mask); }
1.25      fvdl      146: 70     STD             { int linux_sys_setreuid16(int ruid, int euid); }
                    147: 71     STD             { int linux_sys_setregid16(int rgid, int egid); }
1.54      christos  148: 72     STD             { int linux_sys_sigsuspend(void *restart, \
1.1       itohy     149:                            int oldmask, int mask); }
                    150: 73     STD             { int linux_sys_sigpending(linux_old_sigset_t *set); }
                    151: #if !defined(_KERNEL) || defined(COMPAT_43)
                    152: 74     NOARGS          { int compat_43_sys_sethostname(char *hostname, \
                    153:                            u_int len);}
                    154: #else
                    155: 74     UNIMPL          compat_43_sys_sethostname
                    156: #endif
1.36      christos  157: 75     STD             { int linux_sys_setrlimit(u_int which, \
                    158:                            struct orlimit *rlp); }
                    159: 76     STD             { int linux_sys_getrlimit(u_int which, \
                    160:                            struct orlimit *rlp); }
1.1       itohy     161: 77     NOARGS          { int sys_getrusage(int who, struct rusage *rusage); }
1.33      manu      162: 78     STD             { int linux_sys_gettimeofday(struct timeval *tp, \
1.1       itohy     163:                            struct timezone *tzp); }
1.33      manu      164: 79     STD             { int linux_sys_settimeofday(struct timeval *tp, \
1.1       itohy     165:                            struct timezone *tzp); }
1.27      fvdl      166: 80     STD             { int linux_sys_getgroups16(u_int gidsetsize, linux_gid_t *gidset); }
                    167: 81     STD             { int linux_sys_setgroups16(u_int gidsetsize, linux_gid_t *gidset); }
1.1       itohy     168: 82     STD             { int linux_sys_oldselect(struct linux_oldselect *lsp); }
1.55      njoly     169: 83     NOARGS          { int sys_symlink(const char *path, const char *to); }
1.1       itohy     170: #if !defined(_KERNEL) || defined(COMPAT_43)
1.2       itohy     171: 84     NOARGS          { int compat_43_sys_lstat(const char *path, \
1.1       itohy     172:                            struct stat43 *up); } oolstat
                    173: #else
                    174: 84     UNIMPL          compat_43_sys_lstat
                    175: #endif
1.55      njoly     176: 85     NOARGS          { int sys_readlink(const char *name, char *buf, \
1.1       itohy     177:                            int count); }
1.47      joerg     178: #ifdef EXEC_AOUT
1.2       itohy     179: 86     STD             { int linux_sys_uselib(const char *path); }
1.47      joerg     180: #else
                    181: 86     UNIMPL          sys_uselib
                    182: #endif
1.17      jdolecek  183: 87     STD             { int linux_sys_swapon(char *name); }
1.14      erh       184: 88     STD             { int linux_sys_reboot(int magic1, int magic2, \
                    185:                            int cmd, void *arg); }
1.54      christos  186: 89     STD             { int linux_sys_readdir(int fd, void *dent, \
1.1       itohy     187:                            unsigned int count); }
                    188: 90     STD             { int linux_sys_old_mmap(struct linux_oldmmap *lmp); }
1.54      christos  189: 91     NOARGS          { int sys_munmap(void *addr, int len); }
1.55      njoly     190: 92     NOARGS          { int compat_43_sys_truncate(const char *path, \
1.2       itohy     191:                            long length); }
1.1       itohy     192: #if !defined(_KERNEL) || defined(COMPAT_43)
                    193: 93     NOARGS          { int compat_43_sys_ftruncate(int fd, long length); }
                    194: #else
                    195: 93     UNIMPL          compat_43_sys_ftruncate
                    196: #endif
                    197: 94     NOARGS          { int sys_fchmod(int fd, int mode); }
1.25      fvdl      198: 95     STD             { int linux_sys_fchown16(int fd, int uid, int gid); }
1.50      he        199: 96     STD             { int linux_sys_getpriority(int which, int who); }
1.1       itohy     200: 97     NOARGS          { int sys_setpriority(int which, int who, int prio); }
1.54      christos  201: 98     NOARGS          { int sys_profil(void *samples, u_int size, \
1.1       itohy     202:                            u_int offset, u_int scale); }
1.2       itohy     203: 99     STD             { int linux_sys_statfs(const char *path, \
1.1       itohy     204:                            struct linux_statfs *sp); }
                    205: 100    STD             { int linux_sys_fstatfs(int fd, \
                    206:                            struct linux_statfs *sp); }
                    207: 101    UNIMPL          ioperm
                    208: 102    STD             { int linux_sys_socketcall(int what, void *args); }
                    209: 103    UNIMPL          syslog
                    210: 104    NOARGS          { int sys_setitimer(u_int which, \
                    211:                            struct itimerval *itv, struct itimerval *oitv); }
                    212: 105    NOARGS          { int sys_getitimer(u_int which, \
                    213:                            struct itimerval *itv); }
1.2       itohy     214: 106    STD             { int linux_sys_stat(const char *path, \
1.1       itohy     215:                            struct linux_stat *sp); }
1.2       itohy     216: 107    STD             { int linux_sys_lstat(const char *path, \
1.1       itohy     217:                            struct linux_stat *sp); }
                    218: 108    STD             { int linux_sys_fstat(int fd, struct linux_stat *sp); }
                    219: 109    UNIMPL          olduname
                    220: 110    UNIMPL          iopl
                    221: 111    UNIMPL          vhangup
                    222: 112    UNIMPL          idle
                    223: 113    UNIMPL          vm86old
                    224: 114    STD             { int linux_sys_wait4(int pid, int *status, \
                    225:                            int options, struct rusage *rusage); }
1.18      jdolecek  226: 115    STD             { int linux_sys_swapoff(const char *path); }
1.24      jdolecek  227: 116    STD             { int linux_sys_sysinfo(struct linux_sysinfo *arg); }
1.1       itohy     228: 117    STD             { int linux_sys_ipc(int what, int a1, int a2, int a3, \
1.54      christos  229:                            void *ptr); }
1.1       itohy     230: 118    NOARGS          { int sys_fsync(int fd); }
                    231: 119    STD             { int linux_sys_sigreturn(void); }
1.6       thorpej   232: 120    STD             { int linux_sys_clone(int flags, void *stack); }
1.17      jdolecek  233: 121    STD             { int linux_sys_setdomainname(char *domainname, \
1.1       itohy     234:                            int len); }
                    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
1.37      christos  239: 125    STD             { int linux_sys_mprotect(const void *start, \
                    240:                            unsigned long len, int prot); }
1.1       itohy     241: 126    STD             { int linux_sys_sigprocmask(int how, \
                    242:                            const linux_old_sigset_t *set, \
                    243:                            linux_old_sigset_t *oset); }
                    244: 127    UNIMPL          create_module
                    245: 128    UNIMPL          init_module
                    246: 129    UNIMPL          delete_module
                    247: 130    UNIMPL          get_kernel_syms
                    248: 131    UNIMPL          quotactl
1.55.2.1! ad        249: 132    NOARGS          { pid_t sys_getpgid(pid_t pid); }
1.1       itohy     250: 133    NOARGS          { int sys_fchdir(int fd); }
                    251: 134    UNIMPL          bdflush
                    252: 135    UNIMPL          sysfs
                    253: 136    STD             { int linux_sys_personality(int per); }
                    254: 137    UNIMPL          afs_syscall
1.27      fvdl      255: 138    NOARGS          linux_setfsuid16 { int linux_sys_setfsuid(uid_t uid); }
1.55.2.1! ad        256: 139    NOARGS          linux_setfsgid16 { int linux_sys_setfsgid(gid_t gid); }
1.1       itohy     257: 140    STD             { int linux_sys_llseek(int fd, u_int32_t ohigh, \
1.54      christos  258:                            u_int32_t olow, void *res, int whence); }
1.1       itohy     259: 141    STD             { int linux_sys_getdents(int fd, \
                    260:                            struct linux_dirent *dent, unsigned int count); }
                    261: 142    STD             { int linux_sys_select(int nfds, fd_set *readfds, \
                    262:                            fd_set *writefds, fd_set *exceptfds, \
                    263:                            struct timeval *timeout); }
                    264: 143    NOARGS          { int sys_flock(int fd, int how); }
1.54      christos  265: 144    STD             { int linux_sys_msync(void *addr, int len, int fl); }
1.1       itohy     266: 145    NOARGS          { int sys_readv(int fd, struct iovec *iovp, \
                    267:                                u_int iovcnt); }
                    268: 146    NOARGS          { int sys_writev(int fd, struct iovec *iovp, \
                    269:                                u_int iovcnt); }
                    270: 147    NOARGS          { pid_t sys_getsid(pid_t pid); }
                    271: 148    STD             { int linux_sys_fdatasync(int fd); }
                    272: 149    STD             { int linux_sys___sysctl(struct linux___sysctl *lsp); }
1.54      christos  273: 150    NOARGS          { int sys_mlock(void *addr, size_t len); }
                    274: 151    NOARGS          { int sys_munlock(void *addr, size_t len); }
1.16      jdolecek  275: 152    NOARGS          { int sys_mlockall(int flags); }
                    276: 153    NOARGS          { int sys_munlockall(void); }
1.9       tron      277: 154    STD             { int linux_sys_sched_setparam(pid_t pid, \
                    278:                            const struct linux_sched_param *sp); }
                    279: 155    STD             { int linux_sys_sched_getparam(pid_t pid, \
                    280:                            struct linux_sched_param *sp); }
                    281: 156    STD             { int linux_sys_sched_setscheduler(pid_t pid, \
                    282:                            int policy, const struct linux_sched_param *sp); }
                    283: 157    STD             { int linux_sys_sched_getscheduler(pid_t pid); }
                    284: 158    STD             { int linux_sys_sched_yield(void); }
                    285: 159    STD             { int linux_sys_sched_get_priority_max(int policy); }
                    286: 160    STD             { int linux_sys_sched_get_priority_min(int policy); }
1.1       itohy     287: 161    UNIMPL          sched_rr_get_interval
                    288: 162    NOARGS          { int sys_nanosleep(const struct timespec *rqtp, \
                    289:                                struct timespec *rmtp); }
                    290: 163    STD             { void *linux_sys_mremap(void *old_address, \
                    291:                            size_t old_size, size_t new_size, u_long flags); }
1.27      fvdl      292: 164    STD             { int linux_sys_setresuid16(uid_t ruid, uid_t euid, \
1.7       thorpej   293:                            uid_t suid); }
1.27      fvdl      294: 165    NOARGS          linux_getresuid16 { int linux_sys_getresuid( \
                    295:                            uid_t *ruid, uid_t *euid, uid_t *suid); }
1.1       itohy     296: 166    UNIMPL          vm86
                    297: 167    UNIMPL          query_module
1.5       tron      298: 168    NOARGS          { int sys_poll(struct pollfd *fds, u_int nfds, \
                    299:                            int timeout); }
1.1       itohy     300: 169    UNIMPL          nfsservctl
1.27      fvdl      301: 170    STD             { int linux_sys_setresgid16(gid_t rgid, gid_t egid, \
1.7       thorpej   302:                            gid_t sgid); }
1.27      fvdl      303: 171    NOARGS          linux_getresgid16 { int linux_sys_getresgid( \
                    304:                            gid_t *rgid, gid_t *egid, gid_t *sgid); }
1.1       itohy     305: 172    UNIMPL          prctl
                    306: 173    STD             { int linux_sys_rt_sigreturn(void); }
                    307: 174    STD             { int linux_sys_rt_sigaction(int signum, \
                    308:                            const struct linux_sigaction *nsa, \
                    309:                            struct linux_sigaction *osa, \
                    310:                            size_t sigsetsize); }
                    311: 175    STD             { int linux_sys_rt_sigprocmask(int how, \
                    312:                            const linux_sigset_t *set, \
                    313:                            linux_sigset_t *oset, \
                    314:                            size_t sigsetsize); }
                    315: 176    STD             { int linux_sys_rt_sigpending( \
                    316:                            linux_sigset_t *set, \
                    317:                            size_t sigsetsize); }
                    318: 177    UNIMPL          rt_sigtimedwait
                    319: ; XXX XAX int here?  sigset_t here?  siginfo_t
                    320: 178    STD             { int linux_sys_rt_queueinfo(int pid, int signum, \
                    321:                            void *uinfo); }
                    322: 179    STD             { int linux_sys_rt_sigsuspend(linux_sigset_t *unewset, \
                    323:                            size_t sigsetsize); }
1.11      tron      324: 180    STD             { int linux_sys_pread(int fd, char *buf, \
                    325:                            size_t nbyte, linux_off_t offset); }
                    326: 181    STD             { int linux_sys_pwrite(int fd, char *buf, \
                    327:                            size_t nbyte, linux_off_t offset); }
1.1       itohy     328: ;182 chown on i386; lchown on m68k.
1.26      itohy     329: 182    STD             { int linux_sys_lchown16(const char *path, int uid, \
1.2       itohy     330:                            int gid); }
1.4       tron      331: 183    NOARGS          { int sys___getcwd(char *bufp, size_t length); }
1.1       itohy     332: 184    UNIMPL          capget
                    333: 185    UNIMPL          capset
1.15      itohy     334: 186    STD             { int linux_sys_sigaltstack( \
                    335:                            const struct linux_sigaltstack *ss, \
                    336:                            struct linux_sigaltstack *oss); }
1.7       thorpej   337: 187    UNIMPL          sendfile
                    338: 188    UNIMPL          getpmsg
                    339: 189    UNIMPL          putpmsg
                    340: 190    NOARGS          { int sys___vfork14(void); }
1.35      christos  341: 191    STD             { int linux_sys_ugetrlimit(int which, \
1.36      christos  342:                            struct orlimit *rlp); }
1.55.2.1! ad        343: #define linux_sys_mmap2_args linux_sys_mmap_args
1.41      christos  344: 192    NOARGS          { linux_off_t linux_sys_mmap2(unsigned long addr, \
                    345:                            size_t len, int prot, int flags, int fd, \
                    346:                            linux_off_t offset); }
1.23      jdolecek  347: 193    STD             { int linux_sys_truncate64(const char *path, \
1.35      christos  348:                            off_t length); }
1.43      jdolecek  349: 194    STD             { int linux_sys_ftruncate64(unsigned int fd, \
                    350:                            off_t length); }
1.22      jdolecek  351: 195    STD             { int linux_sys_stat64(const char *path, \
1.35      christos  352:                            struct linux_stat64 *sp); }
1.22      jdolecek  353: 196    STD             { int linux_sys_lstat64(const char *path, \
1.35      christos  354:                            struct linux_stat64 *sp); }
1.22      jdolecek  355: 197    STD             { int linux_sys_fstat64(int fd, \
1.35      christos  356:                            struct linux_stat64 *sp); }
1.55      njoly     357: 198    NOARGS           { int sys___posix_chown(const char *path, uid_t uid, \
1.35      christos  358:                            gid_t gid); }
1.25      fvdl      359: 199    NOARGS          { uid_t sys_getuid(void); }
                    360: 200    NOARGS          { gid_t sys_getgid(void); }
                    361: 201    NOARGS          { uid_t sys_geteuid(void); }
                    362: 202    NOARGS          { gid_t sys_getegid(void); }
                    363: 203    NOARGS          { int sys_setreuid(uid_t ruid, uid_t euid); }
                    364: 204    NOARGS          { int sys_setregid(gid_t rgid, gid_t egid); }
1.27      fvdl      365: 205    NOARGS          { int sys_getgroups(u_int gidsetsize, gid_t *gidset); }
                    366: 206    NOARGS          { int sys_setgroups(u_int gidsetsize, gid_t *gidset); }
1.25      fvdl      367: 207    NOARGS          { int sys___posix_fchown(int fd, uid_t uid, \
1.35      christos  368:                            gid_t gid); }
1.27      fvdl      369: 208    STD             { int linux_sys_setresuid(uid_t ruid, uid_t euid, \
                    370:                            uid_t suid); }
                    371: 209    STD             { int linux_sys_getresuid(uid_t *ruid, uid_t *euid, \
                    372:                            uid_t *suid); }
                    373: 210    STD             { int linux_sys_setresgid(gid_t rgid, gid_t egid, \
                    374:                            gid_t sgid); }
                    375: 211    STD             { int linux_sys_getresgid(gid_t *rgid, gid_t *egid, \
                    376:                            gid_t *sgid); }
1.55      njoly     377: 212    NOARGS          { int sys___posix_lchown(const char *path, uid_t uid, \
1.35      christos  378:                            gid_t gid); }
1.25      fvdl      379: 213    NOARGS          { int sys_setuid(uid_t uid); }
                    380: 214    NOARGS          { int sys_setgid(gid_t gid); }
1.27      fvdl      381: 215    STD             { int linux_sys_setfsuid(uid_t uid); }
1.55.2.1! ad        382: 216    STD             { int linux_sys_setfsgid(gid_t gid); }
1.39      jdolecek  383: 217    UNIMPL          /* unused */
                    384: 218    UNIMPL          /* unused */
                    385: 219    UNIMPL          /* unused */
1.38      christos  386: 220    STD             { int linux_sys_getdents64(int fd, \
                    387:                            struct linux_dirent64 *dent, unsigned int count); }
1.39      jdolecek  388: 221    UNIMPL          gettid
                    389: 222    UNIMPL          tkill
1.45      fvdl      390: 223    STD             { int linux_sys_setxattr(char *path, char *name, \
                    391:                            void *value, size_t size, int flags); }
                    392: 224    STD             { int linux_sys_lsetxattr(char *path, char *name, \
                    393:                            void *value, size_t size, int flags); }
                    394: 225    STD             { int linux_sys_fsetxattr(int fd, char *name, \
                    395:                            void *value, size_t size, int flags); }
                    396: 226    STD             { ssize_t linux_sys_getxattr(char *path, char *name, \
                    397:                            void *value, size_t size); }
                    398: 227    STD             { ssize_t linux_sys_lgetxattr(char *path, char *name, \
                    399:                            void *value, size_t size); }
                    400: 228    STD             { ssize_t linux_sys_fgetxattr(int fd, char *name, \
                    401:                            void *value, size_t size); }
                    402: 229    STD             { ssize_t linux_sys_listxattr(char *path, char *list, \
                    403:                            size_t size); }
                    404: 230    STD             { ssize_t linux_sys_llistxattr(char *path, char *list, \
                    405:                            size_t size); }
                    406: 231    STD             { ssize_t linux_sys_flistxattr(int fd, char *list, \
                    407:                            size_t size); }
                    408: 232    STD             { int linux_sys_removexattr(char *path, char *name); }
                    409: 233    STD             { int linux_sys_lremovexattr(char *path, char *name); }
                    410: 234    STD             { int linux_sys_fremovexattr(int fd, char *name); }
1.44      jdolecek  411: 235    UNIMPL          futex
1.46      jmc       412: 236    UNIMPL          sendfile64
                    413: 237    UNIMPL          mincore
                    414: 238    UNIMPL          madvise
                    415: 239    UNIMPL          fcntl64
                    416: 240    UNIMPL          readahead
                    417: 241    UNIMPL          io_setup
                    418: 242    UNIMPL          io_destroy
                    419: 243    UNIMPL          io_getevents
                    420: 244    UNIMPL          io_submit
                    421: 245    UNIMPL          io_cancel
                    422: 246    UNIMPL          fadvise64
                    423: 247    UNIMPL          exit_group
                    424: 248    UNIMPL          lookup_dcookie
                    425: 249    UNIMPL          epoll_create
                    426: 250    UNIMPL          epoll_ctl
                    427: 251    UNIMPL          epoll_wait
                    428: 252    UNIMPL          remap_file_pages
                    429: 253    UNIMPL          set_tid_address
                    430: 254    UNIMPL          timer_create
                    431: 255    UNIMPL          timer_settime
                    432: 256    UNIMPL          timer_gettime
                    433: 257    UNIMPL          timer_getoverrun
                    434: 258    UNIMPL          timer_delete
                    435: 259    STD             { int linux_sys_clock_settime(clockid_t which, \
                    436:                            struct linux_timespec *tp); }
                    437: 260    STD             { int linux_sys_clock_gettime(clockid_t which, \
                    438:                            struct linux_timespec *tp); }
                    439: 261    STD             { int linux_sys_clock_getres(clockid_t which, \
                    440:                            struct linux_timespec *tp); }
                    441: 262    STD             { int linux_sys_clock_nanosleep(clockid_t which, \
                    442:                            int flags, struct linux_timespec *rqtp, \
                    443:                            struct linux_timespec *rmtp); }

CVSweb <webmaster@jp.NetBSD.org>