?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ia64/kvm: compilation fix. export account_system_vtime.
[pv_ops_mirror.git] / arch / x86 / ia32 / sys_ia32.c
blobf00afdf61e6735bbee01085fa24dc42ea529bed7
1 /*
2 * sys_ia32.c: Conversion between 32bit and 64bit native syscalls. Based on
3 * sys_sparc32
4 *
5 * Copyright (C) 2000 VA Linux Co
6 * Copyright (C) 2000 Don Dugger <n0ano@valinux.com>
7 * Copyright (C) 1999 Arun Sharma <arun.sharma@intel.com>
8 * Copyright (C) 1997,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
9 * Copyright (C) 1997 David S. Miller (davem@caip.rutgers.edu)
10 * Copyright (C) 2000 Hewlett-Packard Co.
11 * Copyright (C) 2000 David Mosberger-Tang <davidm@hpl.hp.com>
12 * Copyright (C) 2000,2001,2002 Andi Kleen, SuSE Labs (x86-64 port)
13 *
14 * These routines maintain argument size conversion between 32bit and 64bit
15 * environment. In 2.5 most of this should be moved to a generic directory.
16 *
17 * This file assumes that there is a hole at the end of user address space.
18 *
19 * Some of the functions are LE specific currently. These are
20 * hopefully all marked. This should be fixed.
21 */
22
23 #include <linux/kernel.h>
24 #include <linux/sched.h>
25 #include <linux/fs.h>
26 #include <linux/file.h>
27 #include <linux/signal.h>
28 #include <linux/syscalls.h>
29 #include <linux/times.h>
30 #include <linux/utsname.h>
31 #include <linux/smp_lock.h>
32 #include <linux/mm.h>
33 #include <linux/uio.h>
34 #include <linux/poll.h>
35 #include <linux/personality.h>
36 #include <linux/stat.h>
37 #include <linux/rwsem.h>
38 #include <linux/compat.h>
39 #include <linux/vfs.h>
40 #include <linux/ptrace.h>
41 #include <linux/highuid.h>
42 #include <linux/sysctl.h>
43 #include <asm/mman.h>
44 #include <asm/types.h>
45 #include <asm/uaccess.h>
46 #include <asm/atomic.h>
47 #include <asm/ia32.h>
48 #include <asm/vgtod.h>
49
50 #define AA(__x) ((unsigned long)(__x))
51
52 int cp_compat_stat(struct kstat *kbuf, struct compat_stat __user *ubuf)
53 {
54 compat_ino_t ino;
55
56 typeof(ubuf->st_uid) uid = 0;
57 typeof(ubuf->st_gid) gid = 0;
58 SET_UID(uid, kbuf->uid);
59 SET_GID(gid, kbuf->gid);
60 if (!old_valid_dev(kbuf->dev) || !old_valid_dev(kbuf->rdev))
61 return -EOVERFLOW;
62 if (kbuf->size >= 0x7fffffff)
63 return -EOVERFLOW;
64 ino = kbuf->ino;
65 if (sizeof(ino) < sizeof(kbuf->ino) && ino != kbuf->ino)
66 return -EOVERFLOW;
67 if (!access_ok(VERIFY_WRITE, ubuf, sizeof(struct compat_stat)) ||
68 __put_user(old_encode_dev(kbuf->dev), &ubuf->st_dev) ||
69 __put_user(ino, &ubuf->st_ino) ||
70 __put_user(kbuf->mode, &ubuf->st_mode) ||
71 __put_user(kbuf->nlink, &ubuf->st_nlink) ||
72 __put_user(uid, &ubuf->st_uid) ||
73 __put_user(gid, &ubuf->st_gid) ||
74 __put_user(old_encode_dev(kbuf->rdev), &ubuf->st_rdev) ||
75 __put_user(kbuf->size, &ubuf->st_size) ||
76 __put_user(kbuf->atime.tv_sec, &ubuf->st_atime) ||
77 __put_user(kbuf->atime.tv_nsec, &ubuf->st_atime_nsec) ||
78 __put_user(kbuf->mtime.tv_sec, &ubuf->st_mtime) ||
79 __put_user(kbuf->mtime.tv_nsec, &ubuf->st_mtime_nsec) ||
80 __put_user(kbuf->ctime.tv_sec, &ubuf->st_ctime) ||
81 __put_user(kbuf->ctime.tv_nsec, &ubuf->st_ctime_nsec) ||
82 __put_user(kbuf->blksize, &ubuf->st_blksize) ||
83 __put_user(kbuf->blocks, &ubuf->st_blocks))
84 return -EFAULT;
85 return 0;
86 }
87
88 asmlinkage long sys32_truncate64(char __user *filename,
89 unsigned long offset_low,
90 unsigned long offset_high)
91 {
92 return sys_truncate(filename, ((loff_t) offset_high << 32) | offset_low);
93 }
94
95 asmlinkage long sys32_ftruncate64(unsigned int fd, unsigned long offset_low,
96 unsigned long offset_high)
97 {
98 return sys_ftruncate(fd, ((loff_t) offset_high << 32) | offset_low);
99 }
100
101 /*
102 * Another set for IA32/LFS -- x86_64 struct stat is different due to
103 * support for 64bit inode numbers.
104 */
105 static int cp_stat64(struct stat64 __user *ubuf, struct kstat *stat)
106 {
107 typeof(ubuf->st_uid) uid = 0;
108 typeof(ubuf->st_gid) gid = 0;
109 SET_UID(uid, stat->uid);
110 SET_GID(gid, stat->gid);
111 if (!access_ok(VERIFY_WRITE, ubuf, sizeof(struct stat64)) ||
112 __put_user(huge_encode_dev(stat->dev), &ubuf->st_dev) ||
113 __put_user(stat->ino, &ubuf->__st_ino) ||
114 __put_user(stat->ino, &ubuf->st_ino) ||
115 __put_user(stat->mode, &ubuf->st_mode) ||
116 __put_user(stat->nlink, &ubuf->st_nlink) ||
117 __put_user(uid, &ubuf->st_uid) ||
118 __put_user(gid, &ubuf->st_gid) ||
119 __put_user(huge_encode_dev(stat->rdev), &ubuf->st_rdev) ||
120 __put_user(stat->size, &ubuf->st_size) ||
121 __put_user(stat->atime.tv_sec, &ubuf->st_atime) ||
122 __put_user(stat->atime.tv_nsec, &ubuf->st_atime_nsec) ||
123 __put_user(stat->mtime.tv_sec, &ubuf->st_mtime) ||
124 __put_user(stat->mtime.tv_nsec, &ubuf->st_mtime_nsec) ||
125 __put_user(stat->ctime.tv_sec, &ubuf->st_ctime) ||
126 __put_user(stat->ctime.tv_nsec, &ubuf->st_ctime_nsec) ||
127 __put_user(stat->blksize, &ubuf->st_blksize) ||
128 __put_user(stat->blocks, &ubuf->st_blocks))
129 return -EFAULT;
130 return 0;
131 }
132
133 asmlinkage long sys32_stat64(char __user *filename,
134 struct stat64 __user *statbuf)
135 {
136 struct kstat stat;
137 int ret = vfs_stat(filename, &stat);
138
139 if (!ret)
140 ret = cp_stat64(statbuf, &stat);
141 return ret;
142 }
143
144 asmlinkage long sys32_lstat64(char __user *filename,
145 struct stat64 __user *statbuf)
146 {
147 struct kstat stat;
148 int ret = vfs_lstat(filename, &stat);
149 if (!ret)
150 ret = cp_stat64(statbuf, &stat);
151 return ret;
152 }
153
154 asmlinkage long sys32_fstat64(unsigned int fd, struct stat64 __user *statbuf)
155 {
156 struct kstat stat;
157 int ret = vfs_fstat(fd, &stat);
158 if (!ret)
159 ret = cp_stat64(statbuf, &stat);
160 return ret;
161 }
162
163 asmlinkage long sys32_fstatat(unsigned int dfd, char __user *filename,
164 struct stat64 __user *statbuf, int flag)
165 {
166 struct kstat stat;
167 int error = -EINVAL;
168
169 if ((flag & ~AT_SYMLINK_NOFOLLOW) != 0)
170 goto out;
171
172 if (flag & AT_SYMLINK_NOFOLLOW)
173 error = vfs_lstat_fd(dfd, filename, &stat);
174 else
175 error = vfs_stat_fd(dfd, filename, &stat);
176
177 if (!error)
178 error = cp_stat64(statbuf, &stat);
179
180 out:
181 return error;
182 }
183
184 /*
185 * Linux/i386 didn't use to be able to handle more than
186 * 4 system call parameters, so these system calls used a memory
187 * block for parameter passing..
188 */
189
190 struct mmap_arg_struct {
191 unsigned int addr;
192 unsigned int len;
193 unsigned int prot;
194 unsigned int flags;
195 unsigned int fd;
196 unsigned int offset;
197 };
198
199 asmlinkage long sys32_mmap(struct mmap_arg_struct __user *arg)
200 {
201 struct mmap_arg_struct a;
202 struct file *file = NULL;
203 unsigned long retval;
204 struct mm_struct *mm ;
205
206 if (copy_from_user(&a, arg, sizeof(a)))
207 return -EFAULT;
208
209 if (a.offset & ~PAGE_MASK)
210 return -EINVAL;
211
212 if (!(a.flags & MAP_ANONYMOUS)) {
213 file = fget(a.fd);
214 if (!file)
215 return -EBADF;
216 }
217
218 mm = current->mm;
219 down_write(&mm->mmap_sem);
220 retval = do_mmap_pgoff(file, a.addr, a.len, a.prot, a.flags,
221 a.offset>>PAGE_SHIFT);
222 if (file)
223 fput(file);
224
225 up_write(&mm->mmap_sem);
226
227 return retval;
228 }
229
230 asmlinkage long sys32_mprotect(unsigned long start, size_t len,
231 unsigned long prot)
232 {
233 return sys_mprotect(start, len, prot);
234 }
235
236 asmlinkage long sys32_pipe(int __user *fd)
237 {
238 int retval;
239 int fds[2];
240
241 retval = do_pipe(fds);
242 if (retval)
243 goto out;
244 if (copy_to_user(fd, fds, sizeof(fds)))
245 retval = -EFAULT;
246 out:
247 return retval;
248 }
249
250 asmlinkage long sys32_rt_sigaction(int sig, struct sigaction32 __user *act,
251 struct sigaction32 __user *oact,
252 unsigned int sigsetsize)
253 {
254 struct k_sigaction new_ka, old_ka;
255 int ret;
256 compat_sigset_t set32;
257
258 /* XXX: Don't preclude handling different sized sigset_t's. */
259 if (sigsetsize != sizeof(compat_sigset_t))
260 return -EINVAL;
261
262 if (act) {
263 compat_uptr_t handler, restorer;
264
265 if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
266 __get_user(handler, &act->sa_handler) ||
267 __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
268 __get_user(restorer, &act->sa_restorer) ||
269 __copy_from_user(&set32, &act->sa_mask,
270 sizeof(compat_sigset_t)))
271 return -EFAULT;
272 new_ka.sa.sa_handler = compat_ptr(handler);
273 new_ka.sa.sa_restorer = compat_ptr(restorer);
274
275 /*
276 * FIXME: here we rely on _COMPAT_NSIG_WORS to be >=
277 * than _NSIG_WORDS << 1
278 */
279 switch (_NSIG_WORDS) {
280 case 4: new_ka.sa.sa_mask.sig[3] = set32.sig[6]
281 | (((long)set32.sig[7]) << 32);
282 case 3: new_ka.sa.sa_mask.sig[2] = set32.sig[4]
283 | (((long)set32.sig[5]) << 32);
284 case 2: new_ka.sa.sa_mask.sig[1] = set32.sig[2]
285 | (((long)set32.sig[3]) << 32);
286 case 1: new_ka.sa.sa_mask.sig[0] = set32.sig[0]
287 | (((long)set32.sig[1]) << 32);
288 }
289 }
290
291 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
292
293 if (!ret && oact) {
294 /*
295 * FIXME: here we rely on _COMPAT_NSIG_WORS to be >=
296 * than _NSIG_WORDS << 1
297 */
298 switch (_NSIG_WORDS) {
299 case 4:
300 set32.sig[7] = (old_ka.sa.sa_mask.sig[3] >> 32);
301 set32.sig[6] = old_ka.sa.sa_mask.sig[3];
302 case 3:
303 set32.sig[5] = (old_ka.sa.sa_mask.sig[2] >> 32);
304 set32.sig[4] = old_ka.sa.sa_mask.sig[2];
305 case 2:
306 set32.sig[3] = (old_ka.sa.sa_mask.sig[1] >> 32);
307 set32.sig[2] = old_ka.sa.sa_mask.sig[1];
308 case 1:
309 set32.sig[1] = (old_ka.sa.sa_mask.sig[0] >> 32);
310 set32.sig[0] = old_ka.sa.sa_mask.sig[0];
311 }
312 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
313 __put_user(ptr_to_compat(old_ka.sa.sa_handler),
314 &oact->sa_handler) ||
315 __put_user(ptr_to_compat(old_ka.sa.sa_restorer),
316 &oact->sa_restorer) ||
317 __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
318 __copy_to_user(&oact->sa_mask, &set32,
319 sizeof(compat_sigset_t)))
320 return -EFAULT;
321 }
322
323 return ret;
324 }
325
326 asmlinkage long sys32_sigaction(int sig, struct old_sigaction32 __user *act,
327 struct old_sigaction32 __user *oact)
328 {
329 struct k_sigaction new_ka, old_ka;
330 int ret;
331
332 if (act) {
333 compat_old_sigset_t mask;
334 compat_uptr_t handler, restorer;
335
336 if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
337 __get_user(handler, &act->sa_handler) ||
338 __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
339 __get_user(restorer, &act->sa_restorer) ||
340 __get_user(mask, &act->sa_mask))
341 return -EFAULT;
342
343 new_ka.sa.sa_handler = compat_ptr(handler);
344 new_ka.sa.sa_restorer = compat_ptr(restorer);
345
346 siginitset(&new_ka.sa.sa_mask, mask);
347 }
348
349 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
350
351 if (!ret && oact) {
352 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
353 __put_user(ptr_to_compat(old_ka.sa.sa_handler),
354 &oact->sa_handler) ||
355 __put_user(ptr_to_compat(old_ka.sa.sa_restorer),
356 &oact->sa_restorer) ||
357 __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
358 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
359 return -EFAULT;
360 }
361
362 return ret;
363 }
364
365 asmlinkage long sys32_rt_sigprocmask(int how, compat_sigset_t __user *set,
366 compat_sigset_t __user *oset,
367 unsigned int sigsetsize)
368 {
369 sigset_t s;
370 compat_sigset_t s32;
371 int ret;
372 mm_segment_t old_fs = get_fs();
373
374 if (set) {
375 if (copy_from_user(&s32, set, sizeof(compat_sigset_t)))
376 return -EFAULT;
377 switch (_NSIG_WORDS) {
378 case 4: s.sig[3] = s32.sig[6] | (((long)s32.sig[7]) << 32);
379 case 3: s.sig[2] = s32.sig[4] | (((long)s32.sig[5]) << 32);
380 case 2: s.sig[1] = s32.sig[2] | (((long)s32.sig[3]) << 32);
381 case 1: s.sig[0] = s32.sig[0] | (((long)s32.sig[1]) << 32);
382 }
383 }
384 set_fs(KERNEL_DS);
385 ret = sys_rt_sigprocmask(how,
386 set ? (sigset_t __user *)&s : NULL,
387 oset ? (sigset_t __user *)&s : NULL,
388 sigsetsize);
389 set_fs(old_fs);
390 if (ret)
391 return ret;
392 if (oset) {
393 switch (_NSIG_WORDS) {
394 case 4: s32.sig[7] = (s.sig[3] >> 32); s32.sig[6] = s.sig[3];
395 case 3: s32.sig[5] = (s.sig[2] >> 32); s32.sig[4] = s.sig[2];
396 case 2: s32.sig[3] = (s.sig[1] >> 32); s32.sig[2] = s.sig[1];
397 case 1: s32.sig[1] = (s.sig[0] >> 32); s32.sig[0] = s.sig[0];
398 }
399 if (copy_to_user(oset, &s32, sizeof(compat_sigset_t)))
400 return -EFAULT;
401 }
402 return 0;
403 }
404
405 static inline long get_tv32(struct timeval *o, struct compat_timeval __user *i)
406 {
407 int err = -EFAULT;
408
409 if (access_ok(VERIFY_READ, i, sizeof(*i))) {
410 err = __get_user(o->tv_sec, &i->tv_sec);
411 err |= __get_user(o->tv_usec, &i->tv_usec);
412 }
413 return err;
414 }
415
416 static inline long put_tv32(struct compat_timeval __user *o, struct timeval *i)
417 {
418 int err = -EFAULT;
419
420 if (access_ok(VERIFY_WRITE, o, sizeof(*o))) {
421 err = __put_user(i->tv_sec, &o->tv_sec);
422 err |= __put_user(i->tv_usec, &o->tv_usec);
423 }
424 return err;
425 }
426
427 asmlinkage long sys32_alarm(unsigned int seconds)
428 {
429 return alarm_setitimer(seconds);
430 }
431
432 /*
433 * Translations due to time_t size differences. Which affects all
434 * sorts of things, like timeval and itimerval.
435 */
436 asmlinkage long sys32_gettimeofday(struct compat_timeval __user *tv,
437 struct timezone __user *tz)
438 {
439 if (tv) {
440 struct timeval ktv;
441
442 do_gettimeofday(&ktv);
443 if (put_tv32(tv, &ktv))
444 return -EFAULT;
445 }
446 if (tz) {
447 if (copy_to_user(tz, &sys_tz, sizeof(sys_tz)))
448 return -EFAULT;
449 }
450 return 0;
451 }
452
453 asmlinkage long sys32_settimeofday(struct compat_timeval __user *tv,
454 struct timezone __user *tz)
455 {
456 struct timeval ktv;
457 struct timespec kts;
458 struct timezone ktz;
459
460 if (tv) {
461 if (get_tv32(&ktv, tv))
462 return -EFAULT;
463 kts.tv_sec = ktv.tv_sec;
464 kts.tv_nsec = ktv.tv_usec * NSEC_PER_USEC;
465 }
466 if (tz) {
467 if (copy_from_user(&ktz, tz, sizeof(ktz)))
468 return -EFAULT;
469 }
470
471 return do_sys_settimeofday(tv ? &kts : NULL, tz ? &ktz : NULL);
472 }
473
474 struct sel_arg_struct {
475 unsigned int n;
476 unsigned int inp;
477 unsigned int outp;
478 unsigned int exp;
479 unsigned int tvp;
480 };
481
482 asmlinkage long sys32_old_select(struct sel_arg_struct __user *arg)
483 {
484 struct sel_arg_struct a;
485
486 if (copy_from_user(&a, arg, sizeof(a)))
487 return -EFAULT;
488 return compat_sys_select(a.n, compat_ptr(a.inp), compat_ptr(a.outp),
489 compat_ptr(a.exp), compat_ptr(a.tvp));
490 }
491
492 asmlinkage long sys32_waitpid(compat_pid_t pid, unsigned int *stat_addr,
493 int options)
494 {
495 return compat_sys_wait4(pid, stat_addr, options, NULL);
496 }
497
498 /* 32-bit timeval and related flotsam. */
499
500 asmlinkage long sys32_sysfs(int option, u32 arg1, u32 arg2)
501 {
502 return sys_sysfs(option, arg1, arg2);
503 }
504
505 asmlinkage long sys32_sched_rr_get_interval(compat_pid_t pid,
506 struct compat_timespec __user *interval)
507 {
508 struct timespec t;
509 int ret;
510 mm_segment_t old_fs = get_fs();
511
512 set_fs(KERNEL_DS);
513 ret = sys_sched_rr_get_interval(pid, (struct timespec __user *)&t);
514 set_fs(old_fs);
515 if (put_compat_timespec(&t, interval))
516 return -EFAULT;
517 return ret;
518 }
519
520 asmlinkage long sys32_rt_sigpending(compat_sigset_t __user *set,
521 compat_size_t sigsetsize)
522 {
523 sigset_t s;
524 compat_sigset_t s32;
525 int ret;
526 mm_segment_t old_fs = get_fs();
527
528 set_fs(KERNEL_DS);
529 ret = sys_rt_sigpending((sigset_t __user *)&s, sigsetsize);
530 set_fs(old_fs);
531 if (!ret) {
532 switch (_NSIG_WORDS) {
533 case 4: s32.sig[7] = (s.sig[3] >> 32); s32.sig[6] = s.sig[3];
534 case 3: s32.sig[5] = (s.sig[2] >> 32); s32.sig[4] = s.sig[2];
535 case 2: s32.sig[3] = (s.sig[1] >> 32); s32.sig[2] = s.sig[1];
536 case 1: s32.sig[1] = (s.sig[0] >> 32); s32.sig[0] = s.sig[0];
537 }
538 if (copy_to_user(set, &s32, sizeof(compat_sigset_t)))
539 return -EFAULT;
540 }
541 return ret;
542 }
543
544 asmlinkage long sys32_rt_sigqueueinfo(int pid, int sig,
545 compat_siginfo_t __user *uinfo)
546 {
547 siginfo_t info;
548 int ret;
549 mm_segment_t old_fs = get_fs();
550
551 if (copy_siginfo_from_user32(&info, uinfo))
552 return -EFAULT;
553 set_fs(KERNEL_DS);
554 ret = sys_rt_sigqueueinfo(pid, sig, (siginfo_t __user *)&info);
555 set_fs(old_fs);
556 return ret;
557 }
558
559 /* These are here just in case some old ia32 binary calls it. */
560 asmlinkage long sys32_pause(void)
561 {
562 current->state = TASK_INTERRUPTIBLE;
563 schedule();
564 return -ERESTARTNOHAND;
565 }
566
567
568 #ifdef CONFIG_SYSCTL_SYSCALL
569 struct sysctl_ia32 {
570 unsigned int name;
571 int nlen;
572 unsigned int oldval;
573 unsigned int oldlenp;
574 unsigned int newval;
575 unsigned int newlen;
576 unsigned int __unused[4];
577 };
578
579
580 asmlinkage long sys32_sysctl(struct sysctl_ia32 __user *args32)
581 {
582 struct sysctl_ia32 a32;
583 mm_segment_t old_fs = get_fs();
584 void __user *oldvalp, *newvalp;
585 size_t oldlen;
586 int __user *namep;
587 long ret;
588
589 if (copy_from_user(&a32, args32, sizeof(a32)))
590 return -EFAULT;
591
592 /*
593 * We need to pre-validate these because we have to disable
594 * address checking before calling do_sysctl() because of
595 * OLDLEN but we can't run the risk of the user specifying bad
596 * addresses here. Well, since we're dealing with 32 bit
597 * addresses, we KNOW that access_ok() will always succeed, so
598 * this is an expensive NOP, but so what...
599 */
600 namep = compat_ptr(a32.name);
601 oldvalp = compat_ptr(a32.oldval);
602 newvalp = compat_ptr(a32.newval);
603
604 if ((oldvalp && get_user(oldlen, (int __user *)compat_ptr(a32.oldlenp)))
605 || !access_ok(VERIFY_WRITE, namep, 0)
606 || !access_ok(VERIFY_WRITE, oldvalp, 0)
607 || !access_ok(VERIFY_WRITE, newvalp, 0))
608 return -EFAULT;
609
610 set_fs(KERNEL_DS);
611 lock_kernel();
612 ret = do_sysctl(namep, a32.nlen, oldvalp, (size_t __user *)&oldlen,
613 newvalp, (size_t) a32.newlen);
614 unlock_kernel();
615 set_fs(old_fs);
616
617 if (oldvalp && put_user(oldlen, (int __user *)compat_ptr(a32.oldlenp)))
618 return -EFAULT;
619
620 return ret;
621 }
622 #endif
623
624 /* warning: next two assume little endian */
625 asmlinkage long sys32_pread(unsigned int fd, char __user *ubuf, u32 count,
626 u32 poslo, u32 poshi)
627 {
628 return sys_pread64(fd, ubuf, count,
629 ((loff_t)AA(poshi) << 32) | AA(poslo));
630 }
631
632 asmlinkage long sys32_pwrite(unsigned int fd, char __user *ubuf, u32 count,
633 u32 poslo, u32 poshi)
634 {
635 return sys_pwrite64(fd, ubuf, count,
636 ((loff_t)AA(poshi) << 32) | AA(poslo));
637 }
638
639
640 asmlinkage long sys32_personality(unsigned long personality)
641 {
642 int ret;
643
644 if (personality(current->personality) == PER_LINUX32 &&
645 personality == PER_LINUX)
646 personality = PER_LINUX32;
647 ret = sys_personality(personality);
648 if (ret == PER_LINUX32)
649 ret = PER_LINUX;
650 return ret;
651 }
652
653 asmlinkage long sys32_sendfile(int out_fd, int in_fd,
654 compat_off_t __user *offset, s32 count)
655 {
656 mm_segment_t old_fs = get_fs();
657 int ret;
658 off_t of;
659
660 if (offset && get_user(of, offset))
661 return -EFAULT;
662
663 set_fs(KERNEL_DS);
664 ret = sys_sendfile(out_fd, in_fd, offset ? (off_t __user *)&of : NULL,
665 count);
666 set_fs(old_fs);
667
668 if (offset && put_user(of, offset))
669 return -EFAULT;
670 return ret;
671 }
672
673 asmlinkage long sys32_mmap2(unsigned long addr, unsigned long len,
674 unsigned long prot, unsigned long flags,
675 unsigned long fd, unsigned long pgoff)
676 {
677 struct mm_struct *mm = current->mm;
678 unsigned long error;
679 struct file *file = NULL;
680
681 flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE);
682 if (!(flags & MAP_ANONYMOUS)) {
683 file = fget(fd);
684 if (!file)
685 return -EBADF;
686 }
687
688 down_write(&mm->mmap_sem);
689 error = do_mmap_pgoff(file, addr, len, prot, flags, pgoff);
690 up_write(&mm->mmap_sem);
691
692 if (file)
693 fput(file);
694 return error;
695 }
696
697 asmlinkage long sys32_olduname(struct oldold_utsname __user *name)
698 {
699 char *arch = "x86_64";
700 int err;
701
702 if (!name)
703 return -EFAULT;
704 if (!access_ok(VERIFY_WRITE, name, sizeof(struct oldold_utsname)))
705 return -EFAULT;
706
707 down_read(&uts_sem);
708
709 err = __copy_to_user(&name->sysname, &utsname()->sysname,
710 __OLD_UTS_LEN);
711 err |= __put_user(0, name->sysname+__OLD_UTS_LEN);
712 err |= __copy_to_user(&name->nodename, &utsname()->nodename,
713 __OLD_UTS_LEN);
714 err |= __put_user(0, name->nodename+__OLD_UTS_LEN);
715 err |= __copy_to_user(&name->release, &utsname()->release,
716 __OLD_UTS_LEN);
717 err |= __put_user(0, name->release+__OLD_UTS_LEN);
718 err |= __copy_to_user(&name->version, &utsname()->version,
719 __OLD_UTS_LEN);
720 err |= __put_user(0, name->version+__OLD_UTS_LEN);
721
722 if (personality(current->personality) == PER_LINUX32)
723 arch = "i686";
724
725 err |= __copy_to_user(&name->machine, arch, strlen(arch) + 1);
726
727 up_read(&uts_sem);
728
729 err = err ? -EFAULT : 0;
730
731 return err;
732 }
733
734 long sys32_uname(struct old_utsname __user *name)
735 {
736 int err;
737
738 if (!name)
739 return -EFAULT;
740 down_read(&uts_sem);
741 err = copy_to_user(name, utsname(), sizeof(*name));
742 up_read(&uts_sem);
743 if (personality(current->personality) == PER_LINUX32)
744 err |= copy_to_user(&name->machine, "i686", 5);
745
746 return err ? -EFAULT : 0;
747 }
748
749 long sys32_ustat(unsigned dev, struct ustat32 __user *u32p)
750 {
751 struct ustat u;
752 mm_segment_t seg;
753 int ret;
754
755 seg = get_fs();
756 set_fs(KERNEL_DS);
757 ret = sys_ustat(dev, (struct ustat __user *)&u);
758 set_fs(seg);
759 if (ret < 0)
760 return ret;
761
762 if (!access_ok(VERIFY_WRITE, u32p, sizeof(struct ustat32)) ||
763 __put_user((__u32) u.f_tfree, &u32p->f_tfree) ||
764 __put_user((__u32) u.f_tinode, &u32p->f_tfree) ||
765 __copy_to_user(&u32p->f_fname, u.f_fname, sizeof(u.f_fname)) ||
766 __copy_to_user(&u32p->f_fpack, u.f_fpack, sizeof(u.f_fpack)))
767 ret = -EFAULT;
768 return ret;
769 }
770
771 asmlinkage long sys32_execve(char __user *name, compat_uptr_t __user *argv,
772 compat_uptr_t __user *envp, struct pt_regs *regs)
773 {
774 long error;
775 char *filename;
776
777 filename = getname(name);
778 error = PTR_ERR(filename);
779 if (IS_ERR(filename))
780 return error;
781 error = compat_do_execve(filename, argv, envp, regs);
782 putname(filename);
783 return error;
784 }
785
786 asmlinkage long sys32_clone(unsigned int clone_flags, unsigned int newsp,
787 struct pt_regs *regs)
788 {
789 void __user *parent_tid = (void __user *)regs->dx;
790 void __user *child_tid = (void __user *)regs->di;
791
792 if (!newsp)
793 newsp = regs->sp;
794 return do_fork(clone_flags, newsp, regs, 0, parent_tid, child_tid);
795 }
796
797 /*
798 * Some system calls that need sign extended arguments. This could be
799 * done by a generic wrapper.
800 */
801 long sys32_lseek(unsigned int fd, int offset, unsigned int whence)
802 {
803 return sys_lseek(fd, offset, whence);
804 }
805
806 long sys32_kill(int pid, int sig)
807 {
808 return sys_kill(pid, sig);
809 }
810
811 long sys32_fadvise64_64(int fd, __u32 offset_low, __u32 offset_high,
812 __u32 len_low, __u32 len_high, int advice)
813 {
814 return sys_fadvise64_64(fd,
815 (((u64)offset_high)<<32) | offset_low,
816 (((u64)len_high)<<32) | len_low,
817 advice);
818 }
819
820 long sys32_vm86_warning(void)
821 {
822 struct task_struct *me = current;
823 static char lastcomm[sizeof(me->comm)];
824
825 if (strncmp(lastcomm, me->comm, sizeof(lastcomm))) {
826 compat_printk(KERN_INFO
827 "%s: vm86 mode not supported on 64 bit kernel\n",
828 me->comm);
829 strncpy(lastcomm, me->comm, sizeof(lastcomm));
830 }
831 return -ENOSYS;
832 }
833
834 long sys32_lookup_dcookie(u32 addr_low, u32 addr_high,
835 char __user *buf, size_t len)
836 {
837 return sys_lookup_dcookie(((u64)addr_high << 32) | addr_low, buf, len);
838 }
839
840 asmlinkage ssize_t sys32_readahead(int fd, unsigned off_lo, unsigned off_hi,
841 size_t count)
842 {
843 return sys_readahead(fd, ((u64)off_hi << 32) | off_lo, count);
844 }
845
846 asmlinkage long sys32_sync_file_range(int fd, unsigned off_low, unsigned off_hi,
847 unsigned n_low, unsigned n_hi, int flags)
848 {
849 return sys_sync_file_range(fd,
850 ((u64)off_hi << 32) | off_low,
851 ((u64)n_hi << 32) | n_low, flags);
852 }
853
854 asmlinkage long sys32_fadvise64(int fd, unsigned offset_lo, unsigned offset_hi,
855 size_t len, int advice)
856 {
857 return sys_fadvise64_64(fd, ((u64)offset_hi << 32) | offset_lo,
858 len, advice);
859 }
860
861 asmlinkage long sys32_fallocate(int fd, int mode, unsigned offset_lo,
862 unsigned offset_hi, unsigned len_lo,
863 unsigned len_hi)
864 {
865 return sys_fallocate(fd, mode, ((u64)offset_hi << 32) | offset_lo,
866 ((u64)len_hi << 32) | len_lo);
867 }
Mirror for ia64_pv_ops.git