]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * Conversion between 32-bit and 64-bit native system calls. | |
3 | * | |
4 | * Copyright (C) 2000 Silicon Graphics, Inc. | |
5 | * Written by Ulf Carlsson (ulfc@engr.sgi.com) | |
6 | * sys32_execve from ia64/ia32 code, Feb 2000, Kanoj Sarcar (kanoj@sgi.com) | |
7 | */ | |
1da177e4 LT |
8 | #include <linux/compiler.h> |
9 | #include <linux/mm.h> | |
10 | #include <linux/errno.h> | |
11 | #include <linux/file.h> | |
1da177e4 | 12 | #include <linux/highuid.h> |
1da177e4 LT |
13 | #include <linux/resource.h> |
14 | #include <linux/highmem.h> | |
15 | #include <linux/time.h> | |
16 | #include <linux/times.h> | |
17 | #include <linux/poll.h> | |
18 | #include <linux/slab.h> | |
19 | #include <linux/skbuff.h> | |
20 | #include <linux/filter.h> | |
21 | #include <linux/shm.h> | |
22 | #include <linux/sem.h> | |
23 | #include <linux/msg.h> | |
24 | #include <linux/icmpv6.h> | |
25 | #include <linux/syscalls.h> | |
26 | #include <linux/sysctl.h> | |
27 | #include <linux/utime.h> | |
28 | #include <linux/utsname.h> | |
29 | #include <linux/personality.h> | |
1da177e4 LT |
30 | #include <linux/dnotify.h> |
31 | #include <linux/module.h> | |
32 | #include <linux/binfmts.h> | |
33 | #include <linux/security.h> | |
34 | #include <linux/compat.h> | |
35 | #include <linux/vfs.h> | |
cba4fbbf | 36 | #include <linux/ipc.h> |
1da177e4 LT |
37 | |
38 | #include <net/sock.h> | |
39 | #include <net/scm.h> | |
40 | ||
431dc804 | 41 | #include <asm/compat-signal.h> |
1da177e4 LT |
42 | #include <asm/sim.h> |
43 | #include <asm/uaccess.h> | |
44 | #include <asm/mmu_context.h> | |
45 | #include <asm/mman.h> | |
46 | ||
47 | /* Use this to get at 32-bit user passed pointers. */ | |
48 | /* A() macro should be used for places where you e.g. | |
49 | have some internal variable u32 and just want to get | |
50 | rid of a compiler warning. AA() has to be used in | |
51 | places where you want to convert a function argument | |
52 | to 32bit pointer or when you e.g. access pt_regs | |
53 | structure and want to consider 32bit registers only. | |
54 | */ | |
55 | #define A(__x) ((unsigned long)(__x)) | |
56 | #define AA(__x) ((unsigned long)((int)__x)) | |
57 | ||
58 | #ifdef __MIPSEB__ | |
21a151d8 | 59 | #define merge_64(r1, r2) ((((r1) & 0xffffffffUL) << 32) + ((r2) & 0xffffffffUL)) |
1da177e4 LT |
60 | #endif |
61 | #ifdef __MIPSEL__ | |
21a151d8 | 62 | #define merge_64(r1, r2) ((((r2) & 0xffffffffUL) << 32) + ((r1) & 0xffffffffUL)) |
1da177e4 LT |
63 | #endif |
64 | ||
dbda6ac0 RB |
65 | SYSCALL_DEFINE6(32_mmap2, unsigned long, addr, unsigned long, len, |
66 | unsigned long, prot, unsigned long, flags, unsigned long, fd, | |
67 | unsigned long, pgoff) | |
1da177e4 | 68 | { |
1da177e4 LT |
69 | unsigned long error; |
70 | ||
71 | error = -EINVAL; | |
947df17c PA |
72 | if (pgoff & (~PAGE_MASK >> 12)) |
73 | goto out; | |
f8b72560 AV |
74 | error = sys_mmap_pgoff(addr, len, prot, flags, fd, |
75 | pgoff >> (PAGE_SHIFT-12)); | |
1da177e4 LT |
76 | out: |
77 | return error; | |
78 | } | |
79 | ||
1da177e4 LT |
80 | /* |
81 | * sys_execve() executes a new program. | |
82 | */ | |
83 | asmlinkage int sys32_execve(nabi_no_regargs struct pt_regs regs) | |
84 | { | |
85 | int error; | |
86 | char * filename; | |
87 | ||
88 | filename = getname(compat_ptr(regs.regs[4])); | |
89 | error = PTR_ERR(filename); | |
90 | if (IS_ERR(filename)) | |
91 | goto out; | |
92 | error = compat_do_execve(filename, compat_ptr(regs.regs[5]), | |
93 | compat_ptr(regs.regs[6]), ®s); | |
94 | putname(filename); | |
95 | ||
96 | out: | |
97 | return error; | |
98 | } | |
99 | ||
1da177e4 LT |
100 | #define RLIM_INFINITY32 0x7fffffff |
101 | #define RESOURCE32(x) ((x > RLIM_INFINITY32) ? RLIM_INFINITY32 : x) | |
102 | ||
103 | struct rlimit32 { | |
104 | int rlim_cur; | |
105 | int rlim_max; | |
106 | }; | |
107 | ||
dbda6ac0 RB |
108 | SYSCALL_DEFINE4(32_truncate64, const char __user *, path, |
109 | unsigned long, __dummy, unsigned long, a2, unsigned long, a3) | |
1da177e4 | 110 | { |
d4e9cffa | 111 | return sys_truncate(path, merge_64(a2, a3)); |
1da177e4 LT |
112 | } |
113 | ||
dbda6ac0 RB |
114 | SYSCALL_DEFINE4(32_ftruncate64, unsigned long, fd, unsigned long, __dummy, |
115 | unsigned long, a2, unsigned long, a3) | |
1da177e4 | 116 | { |
d4e9cffa | 117 | return sys_ftruncate(fd, merge_64(a2, a3)); |
1da177e4 LT |
118 | } |
119 | ||
d6c178e9 RB |
120 | SYSCALL_DEFINE5(32_llseek, unsigned int, fd, unsigned int, offset_high, |
121 | unsigned int, offset_low, loff_t __user *, result, | |
122 | unsigned int, origin) | |
1da177e4 LT |
123 | { |
124 | return sys_llseek(fd, offset_high, offset_low, result, origin); | |
125 | } | |
126 | ||
127 | /* From the Single Unix Spec: pread & pwrite act like lseek to pos + op + | |
128 | lseek back to original location. They fail just like lseek does on | |
129 | non-seekable files. */ | |
130 | ||
dbda6ac0 RB |
131 | SYSCALL_DEFINE6(32_pread, unsigned long, fd, char __user *, buf, size_t, count, |
132 | unsigned long, unused, unsigned long, a4, unsigned long, a5) | |
1da177e4 | 133 | { |
6ad0013b | 134 | return sys_pread64(fd, buf, count, merge_64(a4, a5)); |
1da177e4 LT |
135 | } |
136 | ||
dbda6ac0 RB |
137 | SYSCALL_DEFINE6(32_pwrite, unsigned int, fd, const char __user *, buf, |
138 | size_t, count, u32, unused, u64, a4, u64, a5) | |
1da177e4 | 139 | { |
6ad0013b | 140 | return sys_pwrite64(fd, buf, count, merge_64(a4, a5)); |
1da177e4 LT |
141 | } |
142 | ||
dbda6ac0 RB |
143 | SYSCALL_DEFINE2(32_sched_rr_get_interval, compat_pid_t, pid, |
144 | struct compat_timespec __user *, interval) | |
1da177e4 LT |
145 | { |
146 | struct timespec t; | |
147 | int ret; | |
49a89efb | 148 | mm_segment_t old_fs = get_fs(); |
1da177e4 | 149 | |
49a89efb | 150 | set_fs(KERNEL_DS); |
219ac73a | 151 | ret = sys_sched_rr_get_interval(pid, (struct timespec __user *)&t); |
49a89efb | 152 | set_fs(old_fs); |
1da177e4 | 153 | if (put_user (t.tv_sec, &interval->tv_sec) || |
49a89efb | 154 | __put_user(t.tv_nsec, &interval->tv_nsec)) |
1da177e4 LT |
155 | return -EFAULT; |
156 | return ret; | |
157 | } | |
158 | ||
65f8ebe0 RB |
159 | #ifdef CONFIG_SYSVIPC |
160 | ||
dbda6ac0 RB |
161 | SYSCALL_DEFINE6(32_ipc, u32, call, long, first, long, second, long, third, |
162 | unsigned long, ptr, unsigned long, fifth) | |
1da177e4 LT |
163 | { |
164 | int version, err; | |
165 | ||
166 | version = call >> 16; /* hack for backward compatibility */ | |
167 | call &= 0xffff; | |
168 | ||
169 | switch (call) { | |
170 | case SEMOP: | |
171 | /* struct sembuf is the same on 32 and 64bit :)) */ | |
05e43966 | 172 | err = sys_semtimedop(first, compat_ptr(ptr), second, NULL); |
1da177e4 LT |
173 | break; |
174 | case SEMTIMEDOP: | |
05e43966 AN |
175 | err = compat_sys_semtimedop(first, compat_ptr(ptr), second, |
176 | compat_ptr(fifth)); | |
1da177e4 LT |
177 | break; |
178 | case SEMGET: | |
05e43966 | 179 | err = sys_semget(first, second, third); |
1da177e4 LT |
180 | break; |
181 | case SEMCTL: | |
05e43966 | 182 | err = compat_sys_semctl(first, second, third, compat_ptr(ptr)); |
1da177e4 | 183 | break; |
1da177e4 | 184 | case MSGSND: |
05e43966 | 185 | err = compat_sys_msgsnd(first, second, third, compat_ptr(ptr)); |
1da177e4 LT |
186 | break; |
187 | case MSGRCV: | |
05e43966 AN |
188 | err = compat_sys_msgrcv(first, second, fifth, third, |
189 | version, compat_ptr(ptr)); | |
1da177e4 LT |
190 | break; |
191 | case MSGGET: | |
05e43966 | 192 | err = sys_msgget((key_t) first, second); |
1da177e4 LT |
193 | break; |
194 | case MSGCTL: | |
05e43966 | 195 | err = compat_sys_msgctl(first, second, compat_ptr(ptr)); |
1da177e4 | 196 | break; |
1da177e4 | 197 | case SHMAT: |
05e43966 AN |
198 | err = compat_sys_shmat(first, second, third, version, |
199 | compat_ptr(ptr)); | |
1da177e4 LT |
200 | break; |
201 | case SHMDT: | |
05e43966 | 202 | err = sys_shmdt(compat_ptr(ptr)); |
1da177e4 LT |
203 | break; |
204 | case SHMGET: | |
05e43966 | 205 | err = sys_shmget(first, (unsigned)second, third); |
1da177e4 LT |
206 | break; |
207 | case SHMCTL: | |
05e43966 | 208 | err = compat_sys_shmctl(first, second, compat_ptr(ptr)); |
1da177e4 LT |
209 | break; |
210 | default: | |
211 | err = -EINVAL; | |
212 | break; | |
213 | } | |
214 | ||
215 | return err; | |
216 | } | |
217 | ||
65f8ebe0 RB |
218 | #else |
219 | ||
dbda6ac0 | 220 | SYSCALL_DEFINE6(32_ipc, u32, call, int, first, int, second, int, third, |
c189846e | 221 | u32, ptr, u32, fifth) |
65f8ebe0 RB |
222 | { |
223 | return -ENOSYS; | |
224 | } | |
225 | ||
226 | #endif /* CONFIG_SYSVIPC */ | |
227 | ||
05e43966 | 228 | #ifdef CONFIG_MIPS32_N32 |
dbda6ac0 | 229 | SYSCALL_DEFINE4(n32_semctl, int, semid, int, semnum, int, cmd, u32, arg) |
1da177e4 | 230 | { |
05e43966 AN |
231 | /* compat_sys_semctl expects a pointer to union semun */ |
232 | u32 __user *uptr = compat_alloc_user_space(sizeof(u32)); | |
e16d8df0 | 233 | if (put_user(arg, uptr)) |
05e43966 AN |
234 | return -EFAULT; |
235 | return compat_sys_semctl(semid, semnum, cmd, uptr); | |
1da177e4 | 236 | } |
e16d8df0 | 237 | |
dbda6ac0 RB |
238 | SYSCALL_DEFINE4(n32_msgsnd, int, msqid, u32, msgp, unsigned int, msgsz, |
239 | int, msgflg) | |
e16d8df0 AN |
240 | { |
241 | return compat_sys_msgsnd(msqid, msgsz, msgflg, compat_ptr(msgp)); | |
242 | } | |
243 | ||
dbda6ac0 RB |
244 | SYSCALL_DEFINE5(n32_msgrcv, int, msqid, u32, msgp, size_t, msgsz, |
245 | int, msgtyp, int, msgflg) | |
e16d8df0 AN |
246 | { |
247 | return compat_sys_msgrcv(msqid, msgsz, msgtyp, msgflg, IPC_64, | |
248 | compat_ptr(msgp)); | |
249 | } | |
05e43966 | 250 | #endif |
1da177e4 | 251 | |
dbda6ac0 | 252 | SYSCALL_DEFINE1(32_newuname, struct new_utsname __user *, name) |
1da177e4 LT |
253 | { |
254 | int ret = 0; | |
255 | ||
256 | down_read(&uts_sem); | |
e9ff3990 | 257 | if (copy_to_user(name, utsname(), sizeof *name)) |
1da177e4 LT |
258 | ret = -EFAULT; |
259 | up_read(&uts_sem); | |
260 | ||
261 | if (current->personality == PER_LINUX32 && !ret) | |
262 | if (copy_to_user(name->machine, "mips\0\0\0", 8)) | |
263 | ret = -EFAULT; | |
264 | ||
265 | return ret; | |
266 | } | |
267 | ||
dbda6ac0 | 268 | SYSCALL_DEFINE1(32_personality, unsigned long, personality) |
1da177e4 LT |
269 | { |
270 | int ret; | |
53571ce4 TS |
271 | personality &= 0xffffffff; |
272 | if (personality(current->personality) == PER_LINUX32 && | |
273 | personality == PER_LINUX) | |
1da177e4 LT |
274 | personality = PER_LINUX32; |
275 | ret = sys_personality(personality); | |
276 | if (ret == PER_LINUX32) | |
277 | ret = PER_LINUX; | |
278 | return ret; | |
279 | } | |
280 | ||
dbda6ac0 RB |
281 | SYSCALL_DEFINE4(32_sendfile, long, out_fd, long, in_fd, |
282 | compat_off_t __user *, offset, s32, count) | |
1da177e4 LT |
283 | { |
284 | mm_segment_t old_fs = get_fs(); | |
285 | int ret; | |
286 | off_t of; | |
42a3b4f2 | 287 | |
1da177e4 LT |
288 | if (offset && get_user(of, offset)) |
289 | return -EFAULT; | |
42a3b4f2 | 290 | |
1da177e4 | 291 | set_fs(KERNEL_DS); |
219ac73a | 292 | ret = sys_sendfile(out_fd, in_fd, offset ? (off_t __user *)&of : NULL, count); |
1da177e4 | 293 | set_fs(old_fs); |
42a3b4f2 | 294 | |
1da177e4 LT |
295 | if (offset && put_user(of, offset)) |
296 | return -EFAULT; | |
42a3b4f2 | 297 | |
1da177e4 LT |
298 | return ret; |
299 | } | |
300 | ||
301 | asmlinkage ssize_t sys32_readahead(int fd, u32 pad0, u64 a2, u64 a3, | |
302 | size_t count) | |
303 | { | |
304 | return sys_readahead(fd, merge_64(a2, a3), count); | |
305 | } | |
306 | ||
a8d587a7 RB |
307 | asmlinkage long sys32_sync_file_range(int fd, int __pad, |
308 | unsigned long a2, unsigned long a3, | |
309 | unsigned long a4, unsigned long a5, | |
310 | int flags) | |
311 | { | |
312 | return sys_sync_file_range(fd, | |
313 | merge_64(a2, a3), merge_64(a4, a5), | |
314 | flags); | |
315 | } | |
316 | ||
8676d2e0 AN |
317 | asmlinkage long sys32_fadvise64_64(int fd, int __pad, |
318 | unsigned long a2, unsigned long a3, | |
319 | unsigned long a4, unsigned long a5, | |
320 | int flags) | |
321 | { | |
322 | return sys_fadvise64_64(fd, | |
323 | merge_64(a2, a3), merge_64(a4, a5), | |
324 | flags); | |
325 | } | |
326 | ||
4dc46775 RB |
327 | asmlinkage long sys32_fallocate(int fd, int mode, unsigned offset_a2, |
328 | unsigned offset_a3, unsigned len_a4, unsigned len_a5) | |
329 | { | |
330 | return sys_fallocate(fd, mode, merge_64(offset_a2, offset_a3), | |
331 | merge_64(len_a4, len_a5)); | |
332 | } | |
333 | ||
3c37026d | 334 | save_static_function(sys32_clone); |
f5dbeaf5 | 335 | static int noinline __used |
3c37026d RB |
336 | _sys32_clone(nabi_no_regargs struct pt_regs regs) |
337 | { | |
338 | unsigned long clone_flags; | |
339 | unsigned long newsp; | |
340 | int __user *parent_tidptr, *child_tidptr; | |
341 | ||
342 | clone_flags = regs.regs[4]; | |
343 | newsp = regs.regs[5]; | |
344 | if (!newsp) | |
345 | newsp = regs.regs[29]; | |
219ac73a | 346 | parent_tidptr = (int __user *) regs.regs[6]; |
3c37026d RB |
347 | |
348 | /* Use __dummy4 instead of getting it off the stack, so that | |
349 | syscall() works. */ | |
350 | child_tidptr = (int __user *) __dummy4; | |
351 | return do_fork(clone_flags, newsp, ®s, 0, | |
352 | parent_tidptr, child_tidptr); | |
353 | } | |
80b8585b WZ |
354 | |
355 | asmlinkage long sys32_lookup_dcookie(u32 a0, u32 a1, char __user *buf, | |
356 | size_t len) | |
357 | { | |
358 | return sys_lookup_dcookie(merge_64(a0, a1), buf, len); | |
359 | } |