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