sys/compat/linux/arch/arm/syscalls.master

   1         $NetBSD: syscalls.master,v 1.33 2008/01/15 22:38:34 njoly Exp $
   2
   3 ; Derived from sys/compat/linux/arch/*/syscalls.master
   4 ; and from Linux 2.4.12 arch/arm/kernel/calls.S
   5
   6 ; NetBSD/arm COMPAT_LINUX system call name/number "master" file.
   7 ; (See syscalls.conf to see what it is processed into.)
   8 ;
   9 ; Fields: number type [type-dependent ...]
  10 ;       number  system call number, must be in order
  11 ;       type    one of STD, OBSOL, UNIMPL, NODEF, NOARGS, or one of
  12 ;               the compatibility options defined in syscalls.conf.
  13 ;
  14 ; types:
  15 ;       STD     always included
  16 ;       OBSOL   obsolete, not included in system
  17 ;       UNIMPL  unimplemented, not included in system
  18 ;       NODEF   included, but don't define the syscall number
  19 ;       NOARGS  included, but don't define the syscall args structure
  20 ;       INDIR   included, but don't define the syscall args structure
  21 ;               and allow it to be "really" varargs.
  22 ;
  23 ; The compat options are defined in the syscalls.conf file, and the
  24 ; compat option name is prefixed to the syscall name.  Other than
  25 ; that, they're like NODEF (for 'compat' options), or STD (for
  26 ; 'libcompat' options).
  27 ;
  28 ; The type-dependent arguments are as follows:
  29 ; For STD, NODEF, NOARGS, and compat syscalls:
  30 ;       { pseudo-proto } [alias]
  31 ; For other syscalls:
  32 ;       [comment]
  33 ;
  34 ; #ifdef's, etc. may be included, and are copied to the output files.
  35 ; #include's are copied to the syscall names and switch definition files only.
  36
  37 #if defined(_KERNEL_OPT)
  38 #include "opt_compat_43.h"
  39 #endif
  40
  41 #include <sys/param.h>
  42 #include <sys/poll.h>
  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_mmap.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>
  53
  54 #include <compat/linux/linux_syscallargs.h>
  55
  56 %%
  57 ; XXX We have to explicitly declare linux_sys_nosys.
  58 0       NOARGS          { int linux_sys_nosys(void); }
  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); }
  63 5       STD             { int linux_sys_open(const char *path, int flags, \
  64                             int mode); }
  65 6       NOARGS          { int sys_close(int fd); }
  66 7       STD             { int linux_sys_waitpid(int pid, int *status, \
  67                             int options);}
  68 8       STD             { int linux_sys_creat(const char *path, int mode); }
  69 9       NOARGS          { int sys_link(const char *path, const char *link); }
  70 10      STD             { int linux_sys_unlink(const char *path); }
  71 11      NOARGS          { int sys_execve(const char *path, char **argp, \
  72                             char **envp); }
  73 12      NOARGS          { int sys_chdir(const char *path); }
  74 13      STD             { int linux_sys_time(linux_time_t *t); }
  75 14      STD             { int linux_sys_mknod(const char *path, int mode, \
  76                             int dev); }
  77 15      NOARGS          { int sys_chmod(const char *path, int mode); }
  78 16      STD             { int linux_sys_lchown16(const char *path, \
  79                             linux_uid16_t uid, linux_gid16_t gid); }
  80 17      OBSOL           break
  81 18      OBSOL           ostat
  82 19      NOARGS          { long compat_43_sys_lseek(int fd, long offset, \
  83                             int whence); }
  84 20      NOARGS MPSAFE   { 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      STD             { int linux_sys_stime(linux_time_t *t); }
  90 26      STD             { int linux_sys_ptrace(int request, int pid, \
  91                             int addr, int data); }
  92 27      STD             { int linux_sys_alarm(unsigned int secs); }
  93 28      OBSOL           ofstat
  94 29      STD             { int linux_sys_pause(void); }
  95 30      STD             { int linux_sys_utime(const char *path, \
  96                             struct linux_utimbuf *times); }
  97 31      OBSOL           stty
  98 32      OBSOL           gtty
  99 33      NOARGS          { int sys_access(const char *path, int flags); }
 100 34      STD             { int linux_sys_nice(int incr); }
 101 35      OBSOL           ftime
 102 36      NOARGS          { int sys_sync(void); }
 103 37      STD             { int linux_sys_kill(int pid, int signum); }
 104 38      NOARGS          { int sys___posix_rename(const char *from, \
 105                             const char *to); }
 106 39      NOARGS          { int sys_mkdir(const char *path, int mode); }
 107 40      NOARGS          { int sys_rmdir(const char *path); }
 108 41      NOARGS          { int sys_dup(u_int fd); }
 109 42      STD             { int linux_sys_pipe(int *pfds); }
 110 43      STD             { int linux_sys_times(struct times *tms); }
 111 44      OBSOL           prof
 112 45      STD             { int linux_sys_brk(char *nsize); }
 113 46      NOARGS          { int sys_setgid(gid_t gid); }
 114 47      NOARGS          { gid_t sys_getgid(void); }
 115 48      STD             { int linux_sys_signal(int signum, \
 116                             linux_handler_t handler); }
 117 49      NOARGS          { uid_t sys_geteuid(void); }
 118 50      NOARGS          { gid_t sys_getegid(void); }
 119 51      NOARGS          { int sys_acct(char *path); }
 120 52      UNIMPL          umount
 121 53      OBSOL           lock
 122 54      STD             { int linux_sys_ioctl(int fd, u_long com, \
 123                             void *data); }
 124 55      STD             { int linux_sys_fcntl(int fd, int cmd, void *arg); }
 125 56      OBSOL           mpx
 126 57      NOARGS          { int sys_setpgid(int pid, int pgid); }
 127 58      OBSOL           ulimit
 128 59      STD             { int linux_sys_oldolduname( \
 129                            struct linux_oldold_utsname *up); }
 130 60      NOARGS          { int sys_umask(int newmask); }
 131 61      NOARGS          { int sys_chroot(char *path); }
 132 62      UNIMPL          ustat
 133 63      NOARGS          { int sys_dup2(u_int from, u_int to); }
 134 64      NOARGS          { pid_t sys_getppid(void); }
 135 65      NOARGS          { int sys_getpgrp(void); }
 136 66      NOARGS          { int sys_setsid(void); }
 137 67      STD             { int linux_sys_sigaction(int signum, \
 138                             const struct linux_old_sigaction *nsa, \
 139                             struct linux_old_sigaction *osa); }
 140 68      STD             { int linux_sys_siggetmask(void); }
 141 69      STD             { int linux_sys_sigsetmask(linux_old_sigset_t mask); }
 142 70      STD             { int linux_sys_setreuid16(linux_uid16_t ruid, \
 143                             linux_uid16_t euid); }
 144 71      STD             { int linux_sys_setregid16(linux_gid16_t rgid, \
 145                             linux_gid16_t egid); }
 146 72      STD             { int linux_sys_sigsuspend(void *restart, \
 147                             int oldmask, int mask); }
 148 73      STD             { int linux_sys_sigpending(linux_old_sigset_t *set); }
 149 74      NOARGS          { int compat_43_sys_sethostname(char *hostname, \
 150                             u_int len);}
 151 75      STD             { int linux_sys_setrlimit(u_int which, \
 152                             struct orlimit *rlp); }
 153 76      STD             { int linux_sys_getrlimit(u_int which, \
 154                             struct orlimit *rlp); }
 155 77      NOARGS          { int sys_getrusage(int who, struct rusage *rusage); }
 156 78      STD             { int linux_sys_gettimeofday(struct timeval *tp, \
 157                             struct timezone *tzp); }
 158 79      STD             { int linux_sys_settimeofday(struct timeval *tp, \
 159                             struct timezone *tzp); }
 160 80      STD             { int linux_sys_getgroups16(int gidsetsize, \
 161                             linux_gid16_t *gidset); }
 162 81      STD             { int linux_sys_setgroups16(int gidsetsize, \
 163                             linux_gid16_t *gidset); }
 164 82      STD             { int linux_sys_oldselect(struct linux_oldselect *lsp); }
 165 83      NOARGS          { int sys_symlink(const char *path, const char *to); }
 166 84      NOARGS          { int compat_43_sys_lstat(const char *path, \
 167                             struct stat43 *up); } oolstat
 168 85      NOARGS          { int sys_readlink(const char *name, char *buf, \
 169                             int count); }
 170 #ifdef EXEC_AOUT
 171 86      STD             { int linux_sys_uselib(const char *path); }
 172 #else
 173 86      EXCL            uselib
 174 #endif
 175 87      STD             { int linux_sys_swapon(char *name); }
 176 88      STD             { int linux_sys_reboot(int magic1, int magic2, \
 177                             int cmd, void *arg); }
 178 89      STD             { int linux_sys_readdir(int fd, void *dent, \
 179                             unsigned int count); }
 180 90      STD             { int linux_sys_old_mmap(struct linux_oldmmap *lmp); }
 181 91      NOARGS          { int sys_munmap(void *addr, int len); }
 182 92      NOARGS          { int compat_43_sys_truncate(const char *path, \
 183                             long length); }
 184 93      NOARGS          { int compat_43_sys_ftruncate(int fd, long length); }
 185 94      NOARGS          { int sys_fchmod(int fd, int mode); }
 186 95      STD             { int linux_sys_fchown16(int fd, linux_uid16_t uid, \
 187                             linux_gid16_t gid); }
 188 96      STD             { int linux_sys_getpriority(int which, int who); }
 189 97      NOARGS          { int sys_setpriority(int which, int who, int prio); }
 190 98      NOARGS          { int sys_profil(void *samples, u_int size, \
 191                             u_int offset, u_int scale); }
 192 99      STD             { int linux_sys_statfs(const char *path, \
 193                             struct linux_statfs *sp); }
 194 100     STD             { int linux_sys_fstatfs(int fd, \
 195                             struct linux_statfs *sp); }
 196 101     UNIMPL
 197 102     STD             { int linux_sys_socketcall(int what, void *args); }
 198 103     UNIMPL          syslog
 199 104     NOARGS          { int sys_setitimer(u_int which, \
 200                             struct itimerval *itv, struct itimerval *oitv); }
 201 105     NOARGS          { int sys_getitimer(u_int which, \
 202                             struct itimerval *itv); }
 203 106     STD             { int linux_sys_stat(const char *path, \
 204                             struct linux_stat *sp); }
 205 107     STD             { int linux_sys_lstat(const char *path, \
 206                             struct linux_stat *sp); }
 207 108     STD             { int linux_sys_fstat(int fd, struct linux_stat *sp); }
 208 109     STD             { int linux_sys_olduname(struct linux_oldutsname *up); }
 209 110     UNIMPL
 210 111     UNIMPL          vhangup
 211 112     UNIMPL          idle
 212 113     UNIMPL          syscall
 213 114     STD             { int linux_sys_wait4(int pid, int *status, \
 214                             int options, struct rusage *rusage); }
 215 115     STD             { int linux_sys_swapoff(const char *path); }
 216 116     STD             { int linux_sys_sysinfo(struct linux_sysinfo *arg); }
 217 117     STD             { int linux_sys_ipc(int what, int a1, int a2, int a3, \
 218                             void *ptr); }
 219 118     NOARGS          { int sys_fsync(int fd); }
 220 119     STD             { int linux_sys_sigreturn(struct linux_sigcontext *scp); }
 221 120     STD             { int linux_sys_clone(int flags, void *stack); }
 222 121     STD             { int linux_sys_setdomainname(char *domainname, \
 223                             int len); }
 224 122     STD             { int linux_sys_uname(struct linux_utsname *up); }
 225 123     UNIMPL          modify_ldt
 226 124     UNIMPL          adjtimex
 227 125     STD             { int linux_sys_mprotect(const void *start, \
 228                             unsigned long len, int prot); }
 229 126     STD             { int linux_sys_sigprocmask(int how, \
 230                             const linux_old_sigset_t *set, \
 231                             linux_old_sigset_t *oset); }
 232 127     UNIMPL          create_module
 233 128     UNIMPL          init_module
 234 129     UNIMPL          delete_module
 235 130     UNIMPL          get_kernel_syms
 236 131     UNIMPL          quotactl
 237 132     NOARGS          { pid_t sys_getpgid(pid_t pid); }
 238 133     NOARGS          { int sys_fchdir(int fd); }
 239 134     UNIMPL          bdflush
 240 135     UNIMPL          sysfs
 241 136     STD             { int linux_sys_personality(int per); }
 242 137     UNIMPL          afs_syscall
 243 138     STD             { int linux_sys_setfsuid(uid_t uid); }
 244 139     STD             { int linux_sys_setfsgid(gid_t gid); }
 245 140     STD             { int linux_sys_llseek(int fd, u_int32_t ohigh, \
 246                             u_int32_t olow, void *res, int whence); }
 247 141     STD             { int linux_sys_getdents(int fd, \
 248                             struct linux_dirent *dent, unsigned int count); }
 249 142     STD             { int linux_sys_select(int nfds, fd_set *readfds, \
 250                             fd_set *writefds, fd_set *exceptfds, \
 251                             struct timeval *timeout); }
 252 143     NOARGS          { int sys_flock(int fd, int how); }
 253 144     NOARGS          { int sys___msync13(void *addr, size_t len, int flags); }
 254 145     NOARGS          { int sys_readv(int fd, struct iovec *iovp, \
 255                                 u_int iovcnt); }
 256 146     NOARGS          { int sys_writev(int fd, struct iovec *iovp, \
 257                                 u_int iovcnt); }
 258 147     NOARGS          { pid_t sys_getsid(pid_t pid); }
 259 148     STD             { int linux_sys_fdatasync(int fd); }
 260 149     STD             { int linux_sys___sysctl(struct linux___sysctl *lsp); }
 261 150     NOARGS          { int sys_mlock(void *addr, size_t len); }
 262 151     NOARGS          { int sys_munlock(void *addr, size_t len); }
 263 152     NOARGS          { int sys_mlockall(int flags); }
 264 153     NOARGS          { int sys_munlockall(void); }
 265 154     STD             { int linux_sys_sched_setparam(pid_t pid, \
 266                             const struct linux_sched_param *sp); }
 267 155     STD             { int linux_sys_sched_getparam(pid_t pid, \
 268                             struct linux_sched_param *sp); }
 269 156     STD             { int linux_sys_sched_setscheduler(pid_t pid, \
 270                             int policy, const struct linux_sched_param *sp); }
 271 157     STD             { int linux_sys_sched_getscheduler(pid_t pid); }
 272 158     STD             { int linux_sys_sched_yield(void); }
 273 159     STD             { int linux_sys_sched_get_priority_max(int policy); }
 274 160     STD             { int linux_sys_sched_get_priority_min(int policy); }
 275 161     UNIMPL          sched_rr_get_interval
 276 162     NOARGS          { int sys_nanosleep(const struct timespec *rqtp, \
 277                                 struct timespec *rmtp); }
 278 163     STD             { void *linux_sys_mremap(void *old_address, \
 279                             size_t old_size, size_t new_size, u_long flags); }
 280 164     STD             { int linux_sys_setresuid16(linux_uid16_t ruid, \
 281                             linux_uid16_t euid, linux_uid16_t suid); }
 282 165     STD             { int linux_sys_getresuid16(linux_uid16_t *ruid, \
 283                             linux_uid16_t *euid, linux_uid16_t *suid); }
 284 166     UNIMPL
 285 167     UNIMPL          query_module
 286 168     NOARGS          { int sys_poll(struct pollfd *fds, u_int nfds, \
 287                             int timeout); }
 288 169     UNIMPL          nfsservctl
 289 170     STD             { int linux_sys_setresgid16(linux_gid16_t rgid, \
 290                             linux_gid16_t egid, linux_gid16_t sgid); }
 291 171     STD             { int linux_sys_getresgid16(linux_gid16_t *rgid, \
 292                             linux_gid16_t *egid, linux_gid16_t *sgid); }
 293 172     UNIMPL          prctl
 294 173     UNIMPL          rt_sigreturn
 295 ;173    STD             { int linux_sys_rt_sigreturn( \
 296 ;                           struct linux_rt_sigframe *sfp); }
 297 174     STD             { int linux_sys_rt_sigaction(int signum, \
 298                             const struct linux_sigaction *nsa, \
 299                             struct linux_sigaction *osa, \
 300                             size_t sigsetsize); }
 301 175     STD             { int linux_sys_rt_sigprocmask(int how, \
 302                             const linux_sigset_t *set, \
 303                             linux_sigset_t *oset, \
 304                             size_t sigsetsize); }
 305 176     STD             { int linux_sys_rt_sigpending( \
 306                             linux_sigset_t *set, \
 307                             size_t sigsetsize); }
 308 177     UNIMPL          rt_sigtimedwait
 309 ; XXX XAX int here?  sigset_t here?  siginfo_t
 310 178     STD             { int linux_sys_rt_queueinfo(int pid, int signum, \
 311                             void *uinfo); }
 312 179     STD             { int linux_sys_rt_sigsuspend(linux_sigset_t *unewset, \
 313                             size_t sigsetsize); }
 314 180     STD             { int linux_sys_pread(int fd, char *buf, \
 315                             size_t nbyte, linux_off_t offset); }
 316 181     STD             { int linux_sys_pwrite(int fd, char *buf, \
 317                             size_t nbyte, linux_off_t offset); }
 318 182     STD             { int linux_sys_chown16(const char *path, \
 319                             linux_uid16_t uid, linux_gid16_t gid); }
 320 183     NOARGS          { int sys___getcwd(char *bufp, size_t length); }
 321 184     UNIMPL          capget
 322 185     UNIMPL          capset
 323 186     STD             { int linux_sys_sigaltstack( \
 324                             const struct linux_sigaltstack *ss, \
 325                             struct linux_sigaltstack *oss); }
 326 187     UNIMPL          sendfile
 327 188     UNIMPL          getpmsg
 328 189     UNIMPL          putpmsg
 329 190     NOARGS          vfork { int sys___vfork14(void); }
 330 191     STD             { int linux_sys_ugetrlimit(int which, \
 331                             struct rlimit *rlp); }
 332 #define linux_sys_mmap2_args linux_sys_mmap_args
 333 192     NOARGS          { linux_off_t linux_sys_mmap2(unsigned long addr, \
 334                             size_t len, int prot, int flags, int fd, \
 335                             linux_off_t offset); }
 336 193     STD             { int linux_sys_truncate64(const char *path, \
 337                                 off_t length); }
 338 194     STD             { int linux_sys_ftruncate64(unsigned int fd, \
 339                                 off_t length); }
 340 195     STD             { int linux_sys_stat64(const char *path, \
 341                                 struct linux_stat64 *sp); }
 342 196     STD             { int linux_sys_lstat64(const char *path, \
 343                                 struct linux_stat64 *sp); }
 344 197     STD             { int linux_sys_fstat64(int fd, \
 345                                 struct linux_stat64 *sp); }
 346 198     NOARGS          { int sys___posix_lchown(const char *path, uid_t uid, \
 347                                 gid_t gid); }
 348 199     NOARGS          getuid32 { uid_t sys_getuid(void); }
 349 200     NOARGS          getgid32 { gid_t sys_getgid(void); }
 350 201     NOARGS          geteuid32 { uid_t sys_geteuid(void); }
 351 202     NOARGS          getegid32 { gid_t sys_getegid(void); }
 352 203     NOARGS          setreuid32 { int sys_setreuid(uid_t ruid, \
 353                                 uid_t euid); }
 354 204     NOARGS          setregid32 { int sys_setregid(gid_t rgid, \
 355                                 gid_t egid); }
 356 205     NOARGS          getgroups32 { int sys_getgroups(u_int gidsetsize, \
 357                                 gid_t *gidset); }
 358 206     NOARGS          setgroups32 { int sys_setgroups(u_int gidsetsize, \
 359                                 gid_t *gidset); }
 360 207     NOARGS          fchown32 { int sys___posix_fchown(int fd, uid_t uid, \
 361                                 gid_t gid); }
 362 208     STD             setresuid32 { int linux_sys_setresuid(uid_t ruid, \
 363                                 uid_t euid, uid_t suid); }
 364 209     STD             getresuid32 { int linux_sys_getresuid(uid_t *ruid, \
 365                                 uid_t *euid, uid_t *suid); }
 366 210     STD             setresgid32 { int linux_sys_setresgid(gid_t rgid, \
 367                                 gid_t egid, gid_t sgid); }
 368 211     STD             getresgid32 { int linux_sys_getresgid(gid_t *rgid, \
 369                                 gid_t *egid, gid_t *sgid); }
 370 212     NOARGS          chown32 { int sys___posix_chown(const char *path, \
 371                                 uid_t uid, gid_t gid); }
 372 213     NOARGS          setuid32 { int sys_setuid(uid_t uid); }
 373 214     NOARGS          setgid32 { int sys_setgid(gid_t gid); }
 374 215     NOARGS          setfsuid32 { int linux_sys_setfsuid(uid_t uid); }
 375 216     NOARGS          setfsgid32 { int linux_sys_setfsgid(gid_t gid); }
 376 217     STD             { int linux_sys_getdents64(int fd, \
 377                             struct linux_dirent64 *dent, unsigned int count); }
 378 218     UNIMPL          pivot_root
 379 219     NOARGS          { int sys_mincore(void *addr, size_t len, char *vec); }
 380 220     NOARGS          { int sys_madvise(void *addr, size_t len, int behav); }
 381 221     STD             { int linux_sys_fcntl64(int fd, int cmd, void *arg); }
 382 222     UNIMPL          /* for tux */
 383 223     UNIMPL          /* unused */
 384 224     UNIMPL          gettid
 385 225     UNIMPL          readahead
 386 226     STD             { int linux_sys_setxattr(char *path, char *name, \
 387                             void *value, size_t size, int flags); }
 388 227     STD             { int linux_sys_lsetxattr(char *path, char *name, \
 389                             void *value, size_t size, int flags); }
 390 228     STD             { int linux_sys_fsetxattr(int fd, char *name, \
 391                             void *value, size_t size, int flags); }
 392 229     STD             { ssize_t linux_sys_getxattr(char *path, char *name, \
 393                             void *value, size_t size); }
 394 230     STD             { ssize_t linux_sys_lgetxattr(char *path, char *name, \
 395                             void *value, size_t size); }
 396 231     STD             { ssize_t linux_sys_fgetxattr(int fd, char *name, \
 397                             void *value, size_t size); }
 398 232     STD             { ssize_t linux_sys_listxattr(char *path, char *list, \
 399                             size_t size); }
 400 233     STD             { ssize_t linux_sys_llistxattr(char *path, char *list, \
 401                             size_t size); }
 402 234     STD             { ssize_t linux_sys_flistxattr(int fd, char *list, \
 403                             size_t size); }
 404 235     STD             { int linux_sys_removexattr(char *path, char *name); }
 405 236     STD             { int linux_sys_lremovexattr(char *path, char *name); }
 406 237     STD             { int linux_sys_fremovexattr(int fd, char *name); }
 407 238     UNIMPL          tkill
 408 239     UNIMPL          sendfile64
 409 240     UNIMPL          futex
 410 241     UNIMPL          sched_setaffinity
 411 242     UNIMPL          sched_getaffinity
 412 243     UNIMPL          io_setup
 413 244     UNIMPL          io_destroy
 414 245     UNIMPL          io_getevents
 415 246     UNIMPL          io_submit
 416 247     UNIMPL          io_cancel
 417 248     STD             { int linux_sys_exit_group(int error_code); }
 418 249     UNIMPL          lookup_dcookie
 419 250     UNIMPL          epoll_create
 420 251     UNIMPL          epoll_ctl
 421 252     UNIMPL          epoll_wait
 422 253     UNIMPL          remap_file_pages
 423 254     UNIMPL          /* for set_thread_area */
 424 255     UNIMPL          /* for get_thread_area */
 425 256     UNIMPL          /* for set_tid_address */
 426 257     UNIMPL          timer_create
 427 258     UNIMPL          timer_settime
 428 259     UNIMPL          timer_gettime
 429 260     UNIMPL          timer_getoverrun
 430 261     UNIMPL          timer_delete
 431 262     STD             { int linux_sys_clock_settime(clockid_t which, \
 432                             struct linux_timespec *tp); }
 433 263     STD             { int linux_sys_clock_gettime(clockid_t which, \
 434                             struct linux_timespec *tp); }
 435 264     STD             { int linux_sys_clock_getres(clockid_t which, \
 436                             struct linux_timespec *tp); }
 437 265     STD             { int linux_sys_clock_nanosleep(clockid_t which, \
 438                             int flags, struct linux_timespec *rqtp, \
 439                             struct linux_timespec *rmtp); }
 440 266     STD             { int linux_sys_statfs64(const char *path, \
 441                             size_t sz, struct linux_statfs64 *sp); }
 442 267     STD             { int linux_sys_fstatfs64(int fd, \
 443                             size_t sz, struct linux_statfs64 *sp); }
 444 268     UNIMPL          tgkill
 445 269     UNIMPL          utimes
 446 270     UNIMPL          fadvise64_64
 447 271     UNIMPL          pciconfig_iobase
 448 272     UNIMPL          pciconfig_read
 449 273     UNIMPL          pciconfig_write
 450 274     UNIMPL
 451 275     UNIMPL
 452 276     UNIMPL
 453 277     UNIMPL
 454 278     UNIMPL
 455 279     UNIMPL
 456 280     UNIMPL
 457 281     UNIMPL
 458 282     UNIMPL
 459 283     UNIMPL
 460 284     UNIMPL
 461 285     UNIMPL
 462 286     UNIMPL
 463 287     UNIMPL
 464 288     UNIMPL
 465 289     UNIMPL
 466 290     UNIMPL
 467 291     UNIMPL
 468 292     UNIMPL
 469 293     UNIMPL
 470 294     UNIMPL
 471 295     UNIMPL
 472 296     UNIMPL
 473 297     UNIMPL
 474 298     UNIMPL
 475 299     UNIMPL
 476 300     UNIMPL
 477 301     UNIMPL
 478 302     UNIMPL
 479 303     UNIMPL
 480 304     UNIMPL
 481 305     UNIMPL
 482 306     UNIMPL
 483 307     UNIMPL
 484 308     UNIMPL
 485 309     UNIMPL
 486 310     UNIMPL
 487 311     UNIMPL
 488 312     UNIMPL
 489 313     UNIMPL
 490 314     UNIMPL
 491 315     UNIMPL
 492 316     UNIMPL
 493 317     UNIMPL
 494 318     UNIMPL
 495 319     UNIMPL
 496 320     UNIMPL
 497 321     UNIMPL
 498 322     UNIMPL
 499 323     UNIMPL
 500 324     UNIMPL
 501 325     UNIMPL
 502 326     UNIMPL
 503 327     UNIMPL
 504 328     UNIMPL
 505 329     UNIMPL
 506 330     UNIMPL
 507 331     UNIMPL
 508 332     UNIMPL
 509 333     UNIMPL
 510 334     UNIMPL
 511 335     UNIMPL
 512 336     UNIMPL
 513 337     UNIMPL
 514 338     UNIMPL
 515 339     UNIMPL
 516 340     UNIMPL
 517 341     UNIMPL
 518 342     UNIMPL
 519 343     UNIMPL
 520 344     UNIMPL
 521 345     UNIMPL
 522 346     UNIMPL
 523 347     UNIMPL
 524 348     UNIMPL
 525 349     UNIMPL
 526 350     UNIMPL
 527 351     UNIMPL
 528 352     UNIMPL
 529 353     UNIMPL
 530 354     UNIMPL
 531 355     UNIMPL
 532 356     UNIMPL
 533 357     UNIMPL
 534 358     UNIMPL
 535 359     UNIMPL
 536 360     UNIMPL
 537 361     UNIMPL
 538 362     UNIMPL
 539 363     UNIMPL
 540 364     UNIMPL
 541 365     UNIMPL
 542 366     UNIMPL
 543 367     UNIMPL
 544 368     UNIMPL
 545 369     UNIMPL
 546 370     UNIMPL
 547 371     UNIMPL
 548 372     UNIMPL
 549 373     UNIMPL
 550 374     UNIMPL
 551 375     UNIMPL
 552 376     UNIMPL
 553 377     UNIMPL
 554 378     UNIMPL
 555 379     UNIMPL
 556 380     UNIMPL
 557 381     UNIMPL
 558 382     UNIMPL
 559 383     UNIMPL
 560
 561 ; ARMLinux actually has two ranges of syscalls.  Normal syscalls use
 562 ; SWI numbers starting at 0x900000 (__NR_SYSCALL_BASE).  Special
 563 ; ARM-specific syscalls use SWI numbers starting at 0x9f0000
 564 ; (__ARM_NR_BASE).  linux_syscall() (in arch/arm/arm/linux_syscall.c)
 565 ; remaps these down to 0x900180 so that we can use one linux_sysent
 566 ; array for the whole lot.
 567
 568 384     UNIMPL          /* base */
 569 385     STD             { int linux_sys_breakpoint(void); }
 570 386     STD             { int linux_sys_cacheflush(uintptr_t from, \
 571                                 intptr_t to); }
 572 387     UNIMPL          usr26
 573 388     UNIMPL          usr32