atomic: use <linux/atomic.h>
[linux-2.6.git] / arch / x86 / ia32 / sys_ia32.c
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/mm.h>
32 #include <linux/uio.h>
33 #include <linux/poll.h>
34 #include <linux/personality.h>
35 #include <linux/stat.h>
36 #include <linux/rwsem.h>
37 #include <linux/compat.h>
38 #include <linux/vfs.h>
39 #include <linux/ptrace.h>
40 #include <linux/highuid.h>
41 #include <linux/sysctl.h>
42 #include <linux/slab.h>
43 #include <asm/mman.h>
44 #include <asm/types.h>
45 #include <asm/uaccess.h>
46 #include <linux/atomic.h>
47 #include <asm/vgtod.h>
48 #include <asm/sys_ia32.h>
49
50 #define AA(__x)         ((unsigned long)(__x))
51
52
53 asmlinkage long sys32_truncate64(const char __user *filename,
54                                  unsigned long offset_low,
55                                  unsigned long offset_high)
56 {
57        return sys_truncate(filename, ((loff_t) offset_high << 32) | offset_low);
58 }
59
60 asmlinkage long sys32_ftruncate64(unsigned int fd, unsigned long offset_low,
61                                   unsigned long offset_high)
62 {
63        return sys_ftruncate(fd, ((loff_t) offset_high << 32) | offset_low);
64 }
65
66 /*
67  * Another set for IA32/LFS -- x86_64 struct stat is different due to
68  * support for 64bit inode numbers.
69  */
70 static int cp_stat64(struct stat64 __user *ubuf, struct kstat *stat)
71 {
72         typeof(ubuf->st_uid) uid = 0;
73         typeof(ubuf->st_gid) gid = 0;
74         SET_UID(uid, stat->uid);
75         SET_GID(gid, stat->gid);
76         if (!access_ok(VERIFY_WRITE, ubuf, sizeof(struct stat64)) ||
77             __put_user(huge_encode_dev(stat->dev), &ubuf->st_dev) ||
78             __put_user(stat->ino, &ubuf->__st_ino) ||
79             __put_user(stat->ino, &ubuf->st_ino) ||
80             __put_user(stat->mode, &ubuf->st_mode) ||
81             __put_user(stat->nlink, &ubuf->st_nlink) ||
82             __put_user(uid, &ubuf->st_uid) ||
83             __put_user(gid, &ubuf->st_gid) ||
84             __put_user(huge_encode_dev(stat->rdev), &ubuf->st_rdev) ||
85             __put_user(stat->size, &ubuf->st_size) ||
86             __put_user(stat->atime.tv_sec, &ubuf->st_atime) ||
87             __put_user(stat->atime.tv_nsec, &ubuf->st_atime_nsec) ||
88             __put_user(stat->mtime.tv_sec, &ubuf->st_mtime) ||
89             __put_user(stat->mtime.tv_nsec, &ubuf->st_mtime_nsec) ||
90             __put_user(stat->ctime.tv_sec, &ubuf->st_ctime) ||
91             __put_user(stat->ctime.tv_nsec, &ubuf->st_ctime_nsec) ||
92             __put_user(stat->blksize, &ubuf->st_blksize) ||
93             __put_user(stat->blocks, &ubuf->st_blocks))
94                 return -EFAULT;
95         return 0;
96 }
97
98 asmlinkage long sys32_stat64(const char __user *filename,
99                              struct stat64 __user *statbuf)
100 {
101         struct kstat stat;
102         int ret = vfs_stat(filename, &stat);
103
104         if (!ret)
105                 ret = cp_stat64(statbuf, &stat);
106         return ret;
107 }
108
109 asmlinkage long sys32_lstat64(const char __user *filename,
110                               struct stat64 __user *statbuf)
111 {
112         struct kstat stat;
113         int ret = vfs_lstat(filename, &stat);
114         if (!ret)
115                 ret = cp_stat64(statbuf, &stat);
116         return ret;
117 }
118
119 asmlinkage long sys32_fstat64(unsigned int fd, struct stat64 __user *statbuf)
120 {
121         struct kstat stat;
122         int ret = vfs_fstat(fd, &stat);
123         if (!ret)
124                 ret = cp_stat64(statbuf, &stat);
125         return ret;
126 }
127
128 asmlinkage long sys32_fstatat(unsigned int dfd, const char __user *filename,
129                               struct stat64 __user *statbuf, int flag)
130 {
131         struct kstat stat;
132         int error;
133
134         error = vfs_fstatat(dfd, filename, &stat, flag);
135         if (error)
136                 return error;
137         return cp_stat64(statbuf, &stat);
138 }
139
140 /*
141  * Linux/i386 didn't use to be able to handle more than
142  * 4 system call parameters, so these system calls used a memory
143  * block for parameter passing..
144  */
145
146 struct mmap_arg_struct32 {
147         unsigned int addr;
148         unsigned int len;
149         unsigned int prot;
150         unsigned int flags;
151         unsigned int fd;
152         unsigned int offset;
153 };
154
155 asmlinkage long sys32_mmap(struct mmap_arg_struct32 __user *arg)
156 {
157         struct mmap_arg_struct32 a;
158
159         if (copy_from_user(&a, arg, sizeof(a)))
160                 return -EFAULT;
161
162         if (a.offset & ~PAGE_MASK)
163                 return -EINVAL;
164
165         return sys_mmap_pgoff(a.addr, a.len, a.prot, a.flags, a.fd,
166                                a.offset>>PAGE_SHIFT);
167 }
168
169 asmlinkage long sys32_mprotect(unsigned long start, size_t len,
170                                unsigned long prot)
171 {
172         return sys_mprotect(start, len, prot);
173 }
174
175 asmlinkage long sys32_rt_sigaction(int sig, struct sigaction32 __user *act,
176                                    struct sigaction32 __user *oact,
177                                    unsigned int sigsetsize)
178 {
179         struct k_sigaction new_ka, old_ka;
180         int ret;
181         compat_sigset_t set32;
182
183         /* XXX: Don't preclude handling different sized sigset_t's.  */
184         if (sigsetsize != sizeof(compat_sigset_t))
185                 return -EINVAL;
186
187         if (act) {
188                 compat_uptr_t handler, restorer;
189
190                 if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
191                     __get_user(handler, &act->sa_handler) ||
192                     __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
193                     __get_user(restorer, &act->sa_restorer) ||
194                     __copy_from_user(&set32, &act->sa_mask,
195                                      sizeof(compat_sigset_t)))
196                         return -EFAULT;
197                 new_ka.sa.sa_handler = compat_ptr(handler);
198                 new_ka.sa.sa_restorer = compat_ptr(restorer);
199
200                 /*
201                  * FIXME: here we rely on _COMPAT_NSIG_WORS to be >=
202                  * than _NSIG_WORDS << 1
203                  */
204                 switch (_NSIG_WORDS) {
205                 case 4: new_ka.sa.sa_mask.sig[3] = set32.sig[6]
206                                 | (((long)set32.sig[7]) << 32);
207                 case 3: new_ka.sa.sa_mask.sig[2] = set32.sig[4]
208                                 | (((long)set32.sig[5]) << 32);
209                 case 2: new_ka.sa.sa_mask.sig[1] = set32.sig[2]
210                                 | (((long)set32.sig[3]) << 32);
211                 case 1: new_ka.sa.sa_mask.sig[0] = set32.sig[0]
212                                 | (((long)set32.sig[1]) << 32);
213                 }
214         }
215
216         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
217
218         if (!ret && oact) {
219                 /*
220                  * FIXME: here we rely on _COMPAT_NSIG_WORS to be >=
221                  * than _NSIG_WORDS << 1
222                  */
223                 switch (_NSIG_WORDS) {
224                 case 4:
225                         set32.sig[7] = (old_ka.sa.sa_mask.sig[3] >> 32);
226                         set32.sig[6] = old_ka.sa.sa_mask.sig[3];
227                 case 3:
228                         set32.sig[5] = (old_ka.sa.sa_mask.sig[2] >> 32);
229                         set32.sig[4] = old_ka.sa.sa_mask.sig[2];
230                 case 2:
231                         set32.sig[3] = (old_ka.sa.sa_mask.sig[1] >> 32);
232                         set32.sig[2] = old_ka.sa.sa_mask.sig[1];
233                 case 1:
234                         set32.sig[1] = (old_ka.sa.sa_mask.sig[0] >> 32);
235                         set32.sig[0] = old_ka.sa.sa_mask.sig[0];
236                 }
237                 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
238                     __put_user(ptr_to_compat(old_ka.sa.sa_handler),
239                                &oact->sa_handler) ||
240                     __put_user(ptr_to_compat(old_ka.sa.sa_restorer),
241                                &oact->sa_restorer) ||
242                     __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
243                     __copy_to_user(&oact->sa_mask, &set32,
244                                    sizeof(compat_sigset_t)))
245                         return -EFAULT;
246         }
247
248         return ret;
249 }
250
251 asmlinkage long sys32_sigaction(int sig, struct old_sigaction32 __user *act,
252                                 struct old_sigaction32 __user *oact)
253 {
254         struct k_sigaction new_ka, old_ka;
255         int ret;
256
257         if (act) {
258                 compat_old_sigset_t mask;
259                 compat_uptr_t handler, restorer;
260
261                 if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
262                     __get_user(handler, &act->sa_handler) ||
263                     __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
264                     __get_user(restorer, &act->sa_restorer) ||
265                     __get_user(mask, &act->sa_mask))
266                         return -EFAULT;
267
268                 new_ka.sa.sa_handler = compat_ptr(handler);
269                 new_ka.sa.sa_restorer = compat_ptr(restorer);
270
271                 siginitset(&new_ka.sa.sa_mask, mask);
272         }
273
274         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
275
276         if (!ret && oact) {
277                 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
278                     __put_user(ptr_to_compat(old_ka.sa.sa_handler),
279                                &oact->sa_handler) ||
280                     __put_user(ptr_to_compat(old_ka.sa.sa_restorer),
281                                &oact->sa_restorer) ||
282                     __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
283                     __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
284                         return -EFAULT;
285         }
286
287         return ret;
288 }
289
290 asmlinkage long sys32_rt_sigprocmask(int how, compat_sigset_t __user *set,
291                                      compat_sigset_t __user *oset,
292                                      unsigned int sigsetsize)
293 {
294         sigset_t s;
295         compat_sigset_t s32;
296         int ret;
297         mm_segment_t old_fs = get_fs();
298
299         if (set) {
300                 if (copy_from_user(&s32, set, sizeof(compat_sigset_t)))
301                         return -EFAULT;
302                 switch (_NSIG_WORDS) {
303                 case 4: s.sig[3] = s32.sig[6] | (((long)s32.sig[7]) << 32);
304                 case 3: s.sig[2] = s32.sig[4] | (((long)s32.sig[5]) << 32);
305                 case 2: s.sig[1] = s32.sig[2] | (((long)s32.sig[3]) << 32);
306                 case 1: s.sig[0] = s32.sig[0] | (((long)s32.sig[1]) << 32);
307                 }
308         }
309         set_fs(KERNEL_DS);
310         ret = sys_rt_sigprocmask(how,
311                                  set ? (sigset_t __user *)&s : NULL,
312                                  oset ? (sigset_t __user *)&s : NULL,
313                                  sigsetsize);
314         set_fs(old_fs);
315         if (ret)
316                 return ret;
317         if (oset) {
318                 switch (_NSIG_WORDS) {
319                 case 4: s32.sig[7] = (s.sig[3] >> 32); s32.sig[6] = s.sig[3];
320                 case 3: s32.sig[5] = (s.sig[2] >> 32); s32.sig[4] = s.sig[2];
321                 case 2: s32.sig[3] = (s.sig[1] >> 32); s32.sig[2] = s.sig[1];
322                 case 1: s32.sig[1] = (s.sig[0] >> 32); s32.sig[0] = s.sig[0];
323                 }
324                 if (copy_to_user(oset, &s32, sizeof(compat_sigset_t)))
325                         return -EFAULT;
326         }
327         return 0;
328 }
329
330 asmlinkage long sys32_alarm(unsigned int seconds)
331 {
332         return alarm_setitimer(seconds);
333 }
334
335 asmlinkage long sys32_waitpid(compat_pid_t pid, unsigned int *stat_addr,
336                               int options)
337 {
338         return compat_sys_wait4(pid, stat_addr, options, NULL);
339 }
340
341 /* 32-bit timeval and related flotsam.  */
342
343 asmlinkage long sys32_sysfs(int option, u32 arg1, u32 arg2)
344 {
345         return sys_sysfs(option, arg1, arg2);
346 }
347
348 asmlinkage long sys32_sched_rr_get_interval(compat_pid_t pid,
349                                     struct compat_timespec __user *interval)
350 {
351         struct timespec t;
352         int ret;
353         mm_segment_t old_fs = get_fs();
354
355         set_fs(KERNEL_DS);
356         ret = sys_sched_rr_get_interval(pid, (struct timespec __user *)&t);
357         set_fs(old_fs);
358         if (put_compat_timespec(&t, interval))
359                 return -EFAULT;
360         return ret;
361 }
362
363 asmlinkage long sys32_rt_sigpending(compat_sigset_t __user *set,
364                                     compat_size_t sigsetsize)
365 {
366         sigset_t s;
367         compat_sigset_t s32;
368         int ret;
369         mm_segment_t old_fs = get_fs();
370
371         set_fs(KERNEL_DS);
372         ret = sys_rt_sigpending((sigset_t __user *)&s, sigsetsize);
373         set_fs(old_fs);
374         if (!ret) {
375                 switch (_NSIG_WORDS) {
376                 case 4: s32.sig[7] = (s.sig[3] >> 32); s32.sig[6] = s.sig[3];
377                 case 3: s32.sig[5] = (s.sig[2] >> 32); s32.sig[4] = s.sig[2];
378                 case 2: s32.sig[3] = (s.sig[1] >> 32); s32.sig[2] = s.sig[1];
379                 case 1: s32.sig[1] = (s.sig[0] >> 32); s32.sig[0] = s.sig[0];
380                 }
381                 if (copy_to_user(set, &s32, sizeof(compat_sigset_t)))
382                         return -EFAULT;
383         }
384         return ret;
385 }
386
387 asmlinkage long sys32_rt_sigqueueinfo(int pid, int sig,
388                                       compat_siginfo_t __user *uinfo)
389 {
390         siginfo_t info;
391         int ret;
392         mm_segment_t old_fs = get_fs();
393
394         if (copy_siginfo_from_user32(&info, uinfo))
395                 return -EFAULT;
396         set_fs(KERNEL_DS);
397         ret = sys_rt_sigqueueinfo(pid, sig, (siginfo_t __user *)&info);
398         set_fs(old_fs);
399         return ret;
400 }
401
402 /* warning: next two assume little endian */
403 asmlinkage long sys32_pread(unsigned int fd, char __user *ubuf, u32 count,
404                             u32 poslo, u32 poshi)
405 {
406         return sys_pread64(fd, ubuf, count,
407                          ((loff_t)AA(poshi) << 32) | AA(poslo));
408 }
409
410 asmlinkage long sys32_pwrite(unsigned int fd, const char __user *ubuf,
411                              u32 count, u32 poslo, u32 poshi)
412 {
413         return sys_pwrite64(fd, ubuf, count,
414                           ((loff_t)AA(poshi) << 32) | AA(poslo));
415 }
416
417
418 asmlinkage long sys32_personality(unsigned long personality)
419 {
420         int ret;
421
422         if (personality(current->personality) == PER_LINUX32 &&
423                 personality == PER_LINUX)
424                 personality = PER_LINUX32;
425         ret = sys_personality(personality);
426         if (ret == PER_LINUX32)
427                 ret = PER_LINUX;
428         return ret;
429 }
430
431 asmlinkage long sys32_sendfile(int out_fd, int in_fd,
432                                compat_off_t __user *offset, s32 count)
433 {
434         mm_segment_t old_fs = get_fs();
435         int ret;
436         off_t of;
437
438         if (offset && get_user(of, offset))
439                 return -EFAULT;
440
441         set_fs(KERNEL_DS);
442         ret = sys_sendfile(out_fd, in_fd, offset ? (off_t __user *)&of : NULL,
443                            count);
444         set_fs(old_fs);
445
446         if (offset && put_user(of, offset))
447                 return -EFAULT;
448         return ret;
449 }
450
451 asmlinkage long sys32_execve(const char __user *name, compat_uptr_t __user *argv,
452                              compat_uptr_t __user *envp, struct pt_regs *regs)
453 {
454         long error;
455         char *filename;
456
457         filename = getname(name);
458         error = PTR_ERR(filename);
459         if (IS_ERR(filename))
460                 return error;
461         error = compat_do_execve(filename, argv, envp, regs);
462         putname(filename);
463         return error;
464 }
465
466 asmlinkage long sys32_clone(unsigned int clone_flags, unsigned int newsp,
467                             struct pt_regs *regs)
468 {
469         void __user *parent_tid = (void __user *)regs->dx;
470         void __user *child_tid = (void __user *)regs->di;
471
472         if (!newsp)
473                 newsp = regs->sp;
474         return do_fork(clone_flags, newsp, regs, 0, parent_tid, child_tid);
475 }
476
477 /*
478  * Some system calls that need sign extended arguments. This could be
479  * done by a generic wrapper.
480  */
481 long sys32_lseek(unsigned int fd, int offset, unsigned int whence)
482 {
483         return sys_lseek(fd, offset, whence);
484 }
485
486 long sys32_kill(int pid, int sig)
487 {
488         return sys_kill(pid, sig);
489 }
490
491 long sys32_fadvise64_64(int fd, __u32 offset_low, __u32 offset_high,
492                         __u32 len_low, __u32 len_high, int advice)
493 {
494         return sys_fadvise64_64(fd,
495                                (((u64)offset_high)<<32) | offset_low,
496                                (((u64)len_high)<<32) | len_low,
497                                 advice);
498 }
499
500 long sys32_vm86_warning(void)
501 {
502         struct task_struct *me = current;
503         static char lastcomm[sizeof(me->comm)];
504
505         if (strncmp(lastcomm, me->comm, sizeof(lastcomm))) {
506                 compat_printk(KERN_INFO
507                               "%s: vm86 mode not supported on 64 bit kernel\n",
508                               me->comm);
509                 strncpy(lastcomm, me->comm, sizeof(lastcomm));
510         }
511         return -ENOSYS;
512 }
513
514 long sys32_lookup_dcookie(u32 addr_low, u32 addr_high,
515                           char __user *buf, size_t len)
516 {
517         return sys_lookup_dcookie(((u64)addr_high << 32) | addr_low, buf, len);
518 }
519
520 asmlinkage ssize_t sys32_readahead(int fd, unsigned off_lo, unsigned off_hi,
521                                    size_t count)
522 {
523         return sys_readahead(fd, ((u64)off_hi << 32) | off_lo, count);
524 }
525
526 asmlinkage long sys32_sync_file_range(int fd, unsigned off_low, unsigned off_hi,
527                                       unsigned n_low, unsigned n_hi,  int flags)
528 {
529         return sys_sync_file_range(fd,
530                                    ((u64)off_hi << 32) | off_low,
531                                    ((u64)n_hi << 32) | n_low, flags);
532 }
533
534 asmlinkage long sys32_fadvise64(int fd, unsigned offset_lo, unsigned offset_hi,
535                                 size_t len, int advice)
536 {
537         return sys_fadvise64_64(fd, ((u64)offset_hi << 32) | offset_lo,
538                                 len, advice);
539 }
540
541 asmlinkage long sys32_fallocate(int fd, int mode, unsigned offset_lo,
542                                 unsigned offset_hi, unsigned len_lo,
543                                 unsigned len_hi)
544 {
545         return sys_fallocate(fd, mode, ((u64)offset_hi << 32) | offset_lo,
546                              ((u64)len_hi << 32) | len_lo);
547 }
548
549 asmlinkage long sys32_fanotify_mark(int fanotify_fd, unsigned int flags,
550                                     u32 mask_lo, u32 mask_hi,
551                                     int fd, const char  __user *pathname)
552 {
553         return sys_fanotify_mark(fanotify_fd, flags,
554                                  ((u64)mask_hi << 32) | mask_lo,
555                                  fd, pathname);
556 }