[PATCH] (5/5) beginning of getattr series.
[opensuse:kernel.git] / arch / ia64 / ia32 / sys_ia32.c
1 /*
2  * sys_ia32.c: Conversion between 32bit and 64bit native syscalls. Derived from sys_sparc32.c.
3  *
4  * Copyright (C) 2000           VA Linux Co
5  * Copyright (C) 2000           Don Dugger <n0ano@valinux.com>
6  * Copyright (C) 1999           Arun Sharma <arun.sharma@intel.com>
7  * Copyright (C) 1997,1998      Jakub Jelinek (jj@sunsite.mff.cuni.cz)
8  * Copyright (C) 1997           David S. Miller (davem@caip.rutgers.edu)
9  * Copyright (C) 2000-2001 Hewlett-Packard Co
10  *      David Mosberger-Tang <davidm@hpl.hp.com>
11  *
12  * These routines maintain argument size conversion between 32bit and 64bit
13  * environment.
14  */
15
16 #include <linux/config.h>
17 #include <linux/kernel.h>
18 #include <linux/sysctl.h>
19 #include <linux/sched.h>
20 #include <linux/fs.h>
21 #include <linux/file.h>
22 #include <linux/signal.h>
23 #include <linux/utime.h>
24 #include <linux/resource.h>
25 #include <linux/times.h>
26 #include <linux/utsname.h>
27 #include <linux/timex.h>
28 #include <linux/smp.h>
29 #include <linux/smp_lock.h>
30 #include <linux/sem.h>
31 #include <linux/msg.h>
32 #include <linux/mm.h>
33 #include <linux/shm.h>
34 #include <linux/slab.h>
35 #include <linux/uio.h>
36 #include <linux/nfs_fs.h>
37 #include <linux/smb_fs.h>
38 #include <linux/smb_mount.h>
39 #include <linux/ncp_fs.h>
40 #include <linux/quota.h>
41 #include <linux/module.h>
42 #include <linux/sunrpc/svc.h>
43 #include <linux/nfsd/nfsd.h>
44 #include <linux/nfsd/cache.h>
45 #include <linux/nfsd/xdr.h>
46 #include <linux/nfsd/syscall.h>
47 #include <linux/poll.h>
48 #include <linux/personality.h>
49 #include <linux/stat.h>
50 #include <linux/ipc.h>
51
52 #include <asm/types.h>
53 #include <asm/uaccess.h>
54 #include <asm/semaphore.h>
55
56 #include <net/scm.h>
57 #include <net/sock.h>
58 #include <asm/ia32.h>
59
60 #define DEBUG   0
61
62 #if DEBUG
63 # define DBG(fmt...)    printk(KERN_DEBUG fmt)
64 #else
65 # define DBG(fmt...)
66 #endif
67
68 #define A(__x)          ((unsigned long)(__x))
69 #define AA(__x)         ((unsigned long)(__x))
70 #define ROUND_UP(x,a)   ((__typeof__(x))(((unsigned long)(x) + ((a) - 1)) & ~((a) - 1)))
71 #define NAME_OFFSET(de) ((int) ((de)->d_name - (char *) (de)))
72
73 #define OFFSET4K(a)             ((a) & 0xfff)
74 #define PAGE_START(addr)        ((addr) & PAGE_MASK)
75 #define PAGE_OFF(addr)          ((addr) & ~PAGE_MASK)
76
77 extern asmlinkage long sys_execve (char *, char **, char **, struct pt_regs *);
78 extern asmlinkage long sys_mprotect (unsigned long, size_t, unsigned long);
79 extern asmlinkage long sys_munmap (unsigned long, size_t);
80 extern unsigned long arch_get_unmapped_area (struct file *, unsigned long, unsigned long,
81                                              unsigned long, unsigned long);
82
83 /* forward declaration: */
84 asmlinkage long sys32_mprotect (unsigned int, unsigned int, int);
85
86 /*
87  * Anything that modifies or inspects ia32 user virtual memory must hold this semaphore
88  * while doing so.
89  */
90 /* XXX make per-mm: */
91 static DECLARE_MUTEX(ia32_mmap_sem);
92
93 static int
94 nargs (unsigned int arg, char **ap)
95 {
96         unsigned int addr;
97         int n, err;
98
99         if (!arg)
100                 return 0;
101
102         n = 0;
103         do {
104                 err = get_user(addr, (unsigned int *)A(arg));
105                 if (err)
106                         return err;
107                 if (ap)
108                         *ap++ = (char *) A(addr);
109                 arg += sizeof(unsigned int);
110                 n++;
111         } while (addr);
112         return n - 1;
113 }
114
115 asmlinkage long
116 sys32_execve (char *filename, unsigned int argv, unsigned int envp,
117               int dummy3, int dummy4, int dummy5, int dummy6, int dummy7,
118               int stack)
119 {
120         struct pt_regs *regs = (struct pt_regs *)&stack;
121         unsigned long old_map_base, old_task_size, tssd;
122         char **av, **ae;
123         int na, ne, len;
124         long r;
125
126         na = nargs(argv, NULL);
127         if (na < 0)
128                 return na;
129         ne = nargs(envp, NULL);
130         if (ne < 0)
131                 return ne;
132         len = (na + ne + 2) * sizeof(*av);
133         av = kmalloc(len, GFP_KERNEL);
134         if (!av)
135                 return -ENOMEM;
136
137         ae = av + na + 1;
138         av[na] = NULL;
139         ae[ne] = NULL;
140
141         r = nargs(argv, av);
142         if (r < 0)
143                 goto out;
144         r = nargs(envp, ae);
145         if (r < 0)
146                 goto out;
147
148         old_map_base  = current->thread.map_base;
149         old_task_size = current->thread.task_size;
150         tssd = ia64_get_kr(IA64_KR_TSSD);
151
152         /* we may be exec'ing a 64-bit process: reset map base, task-size, and io-base: */
153         current->thread.map_base  = DEFAULT_MAP_BASE;
154         current->thread.task_size = DEFAULT_TASK_SIZE;
155         ia64_set_kr(IA64_KR_IO_BASE, current->thread.old_iob);
156         ia64_set_kr(IA64_KR_TSSD, current->thread.old_k1);
157
158         set_fs(KERNEL_DS);
159         r = sys_execve(filename, av, ae, regs);
160         if (r < 0) {
161                 /* oops, execve failed, switch back to old values... */
162                 ia64_set_kr(IA64_KR_IO_BASE, IA32_IOBASE);
163                 ia64_set_kr(IA64_KR_TSSD, tssd);
164                 current->thread.map_base  = old_map_base;
165                 current->thread.task_size = old_task_size;
166                 set_fs(USER_DS);        /* establish new task-size as the address-limit */
167           out:
168                 kfree(av);
169         }
170         return r;
171 }
172
173 static inline int
174 putstat (struct stat32 *ubuf, struct kstat *stat)
175 {
176         int err;
177
178         if (stat->size > MAX_NON_LFS)
179                 return -EOVERFLOW;
180
181         if (clear_user(ubuf, sizeof(*ubuf)))
182                 return -EFAULT;
183
184         err  = __put_user(stat->dev, &ubuf->st_dev);
185         err |= __put_user(stat->ino, &ubuf->st_ino);
186         err |= __put_user(stat->mode, &ubuf->st_mode);
187         err |= __put_user(stat->nlink, &ubuf->st_nlink);
188         err |= __put_user(high2lowuid(stat->uid), &ubuf->st_uid);
189         err |= __put_user(high2lowgid(stat->gid), &ubuf->st_gid);
190         err |= __put_user(stat->rdev, &ubuf->st_rdev);
191         err |= __put_user(stat->size, &ubuf->st_size);
192         err |= __put_user(stat->atime, &ubuf->st_atime);
193         err |= __put_user(stat->mtime, &ubuf->st_mtime);
194         err |= __put_user(stat->ctime, &ubuf->st_ctime);
195         err |= __put_user(stat->blksize, &ubuf->st_blksize);
196         err |= __put_user(stat->blocks, &ubuf->st_blocks);
197         return err;
198 }
199
200 asmlinkage long
201 sys32_newstat (char *filename, struct stat32 *statbuf)
202 {
203         struct kstat stat;
204         int ret = vfs_stat(filename, &stat);
205
206         if (!ret)
207                 ret = putstat(statbuf, &stat);
208
209         return ret;
210 }
211
212 asmlinkage long
213 sys32_newlstat (char *filename, struct stat32 *statbuf)
214 {
215         struct kstat stat;
216         int ret = vfs_lstat(filename, &stat);
217
218         if (!ret)
219                 ret = putstat(statbuf, &stat);
220
221         return ret;
222 }
223
224 asmlinkage long
225 sys32_newfstat (unsigned int fd, struct stat32 *statbuf)
226 {
227         struct kstat stat;
228         int ret = vfs_fstat(fd, &stat);
229
230         if (!ret)
231                 ret = putstat(statbuf, &stat);
232
233         return ret;
234 }
235
236 #if PAGE_SHIFT > IA32_PAGE_SHIFT
237
238
239 static int
240 get_page_prot (unsigned long addr)
241 {
242         struct vm_area_struct *vma = find_vma(current->mm, addr);
243         int prot = 0;
244
245         if (!vma || vma->vm_start > addr)
246                 return 0;
247
248         if (vma->vm_flags & VM_READ)
249                 prot |= PROT_READ;
250         if (vma->vm_flags & VM_WRITE)
251                 prot |= PROT_WRITE;
252         if (vma->vm_flags & VM_EXEC)
253                 prot |= PROT_EXEC;
254         return prot;
255 }
256
257 /*
258  * Map a subpage by creating an anonymous page that contains the union of the old page and
259  * the subpage.
260  */
261 static unsigned long
262 mmap_subpage (struct file *file, unsigned long start, unsigned long end, int prot, int flags,
263               loff_t off)
264 {
265         void *page = (void *) get_zeroed_page(GFP_KERNEL);
266         struct inode *inode;
267         unsigned long ret;
268         int old_prot = get_page_prot(start);
269
270         DBG("mmap_subpage(file=%p,start=0x%lx,end=0x%lx,prot=%x,flags=%x,off=0x%llx)\n",
271             file, start, end, prot, flags, off);
272
273         if (!page)
274                 return -ENOMEM;
275
276         if (old_prot)
277                 copy_from_user(page, (void *) PAGE_START(start), PAGE_SIZE);
278
279         down_write(&current->mm->mmap_sem);
280         {
281                 ret = do_mmap(0, PAGE_START(start), PAGE_SIZE, prot | PROT_WRITE,
282                               flags | MAP_FIXED | MAP_ANONYMOUS, 0);
283         }
284         up_write(&current->mm->mmap_sem);
285
286         if (IS_ERR((void *) ret))
287                 goto out;
288
289         if (old_prot) {
290                 /* copy back the old page contents.  */
291                 if (PAGE_OFF(start))
292                         copy_to_user((void *) PAGE_START(start), page, PAGE_OFF(start));
293                 if (PAGE_OFF(end))
294                         copy_to_user((void *) end, page + PAGE_OFF(end),
295                                      PAGE_SIZE - PAGE_OFF(end));
296         }
297         if (!(flags & MAP_ANONYMOUS)) {
298                 /* read the file contents */
299                 inode = file->f_dentry->d_inode;
300                 if (!inode->i_fop || !file->f_op->read
301                     || ((*file->f_op->read)(file, (char *) start, end - start, &off) < 0))
302                 {
303                         ret = -EINVAL;
304                         goto out;
305                 }
306         }
307         if (!(prot & PROT_WRITE))
308                 ret = sys_mprotect(PAGE_START(start), PAGE_SIZE, prot | old_prot);
309   out:
310         free_page((unsigned long) page);
311         return ret;
312 }
313
314 static unsigned long
315 emulate_mmap (struct file *file, unsigned long start, unsigned long len, int prot, int flags,
316               loff_t off)
317 {
318         unsigned long tmp, end, pend, pstart, ret, is_congruent, fudge = 0;
319         struct inode *inode;
320         loff_t poff;
321
322         end = start + len;
323         pstart = PAGE_START(start);
324         pend = PAGE_ALIGN(end);
325
326         if (flags & MAP_FIXED) {
327                 if (start > pstart) {
328                         if (flags & MAP_SHARED)
329                                 printk(KERN_INFO
330                                        "%s(%d): emulate_mmap() can't share head (addr=0x%lx)\n",
331                                        current->comm, current->pid, start);
332                         ret = mmap_subpage(file, start, min(PAGE_ALIGN(start), end), prot, flags,
333                                            off);
334                         if (IS_ERR((void *) ret))
335                                 return ret;
336                         pstart += PAGE_SIZE;
337                         if (pstart >= pend)
338                                 return start;   /* done */
339                 }
340                 if (end < pend) {
341                         if (flags & MAP_SHARED)
342                                 printk(KERN_INFO
343                                        "%s(%d): emulate_mmap() can't share tail (end=0x%lx)\n",
344                                        current->comm, current->pid, end);
345                         ret = mmap_subpage(file, max(start, PAGE_START(end)), end, prot, flags,
346                                            (off + len) - PAGE_OFF(end));
347                         if (IS_ERR((void *) ret))
348                                 return ret;
349                         pend -= PAGE_SIZE;
350                         if (pstart >= pend)
351                                 return start;   /* done */
352                 }
353         } else {
354                 /*
355                  * If a start address was specified, use it if the entire rounded out area
356                  * is available.
357                  */
358                 if (start && !pstart)
359                         fudge = 1;      /* handle case of mapping to range (0,PAGE_SIZE) */
360                 tmp = arch_get_unmapped_area(file, pstart - fudge, pend - pstart, 0, flags);
361                 if (tmp != pstart) {
362                         pstart = tmp;
363                         start = pstart + PAGE_OFF(off); /* make start congruent with off */
364                         end = start + len;
365                         pend = PAGE_ALIGN(end);
366                 }
367         }
368
369         poff = off + (pstart - start);  /* note: (pstart - start) may be negative */
370         is_congruent = (flags & MAP_ANONYMOUS) || (PAGE_OFF(poff) == 0);
371
372         if ((flags & MAP_SHARED) && !is_congruent)
373                 printk(KERN_INFO "%s(%d): emulate_mmap() can't share contents of incongruent mmap "
374                        "(addr=0x%lx,off=0x%llx)\n", current->comm, current->pid, start, off);
375
376         DBG("mmap_body: mapping [0x%lx-0x%lx) %s with poff 0x%llx\n", pstart, pend,
377             is_congruent ? "congruent" : "not congruent", poff);
378
379         down_write(&current->mm->mmap_sem);
380         {
381                 if (!(flags & MAP_ANONYMOUS) && is_congruent)
382                         ret = do_mmap(file, pstart, pend - pstart, prot, flags | MAP_FIXED, poff);
383                 else
384                         ret = do_mmap(0, pstart, pend - pstart,
385                                       prot | ((flags & MAP_ANONYMOUS) ? 0 : PROT_WRITE),
386                                       flags | MAP_FIXED | MAP_ANONYMOUS, 0);
387         }
388         up_write(&current->mm->mmap_sem);
389
390         if (IS_ERR((void *) ret))
391                 return ret;
392
393         if (!is_congruent) {
394                 /* read the file contents */
395                 inode = file->f_dentry->d_inode;
396                 if (!inode->i_fop || !file->f_op->read
397                     || ((*file->f_op->read)(file, (char *) pstart, pend - pstart, &poff) < 0))
398                 {
399                         sys_munmap(pstart, pend - pstart);
400                         return -EINVAL;
401                 }
402                 if (!(prot & PROT_WRITE) && sys_mprotect(pstart, pend - pstart, prot) < 0)
403                         return EINVAL;
404         }
405         return start;
406 }
407
408 #endif /* PAGE_SHIFT > IA32_PAGE_SHIFT */
409
410 static inline unsigned int
411 get_prot32 (unsigned int prot)
412 {
413         if (prot & PROT_WRITE)
414                 /* on x86, PROT_WRITE implies PROT_READ which implies PROT_EEC */
415                 prot |= PROT_READ | PROT_WRITE | PROT_EXEC;
416         else if (prot & (PROT_READ | PROT_EXEC))
417                 /* on x86, there is no distinction between PROT_READ and PROT_EXEC */
418                 prot |= (PROT_READ | PROT_EXEC);
419
420         return prot;
421 }
422
423 unsigned long
424 ia32_do_mmap (struct file *file, unsigned long addr, unsigned long len, int prot, int flags,
425               loff_t offset)
426 {
427         DBG("ia32_do_mmap(file=%p,addr=0x%lx,len=0x%lx,prot=%x,flags=%x,offset=0x%llx)\n",
428             file, addr, len, prot, flags, offset);
429
430         if (file && (!file->f_op || !file->f_op->mmap))
431                 return -ENODEV;
432
433         len = IA32_PAGE_ALIGN(len);
434         if (len == 0)
435                 return addr;
436
437         if (len > IA32_PAGE_OFFSET || addr > IA32_PAGE_OFFSET - len)
438                 return -EINVAL;
439
440         if (OFFSET4K(offset))
441                 return -EINVAL;
442
443         prot = get_prot32(prot);
444
445 #if PAGE_SHIFT > IA32_PAGE_SHIFT
446         down(&ia32_mmap_sem);
447         {
448                 addr = emulate_mmap(file, addr, len, prot, flags, offset);
449         }
450         up(&ia32_mmap_sem);
451 #else
452         down_write(&current->mm->mmap_sem);
453         {
454                 addr = do_mmap(file, addr, len, prot, flags, offset);
455         }
456         up_write(&current->mm->mmap_sem);
457 #endif
458         DBG("ia32_do_mmap: returning 0x%lx\n", addr);
459         return addr;
460 }
461
462 /*
463  * Linux/i386 didn't use to be able to handle more than 4 system call parameters, so these
464  * system calls used a memory block for parameter passing..
465  */
466
467 struct mmap_arg_struct {
468         unsigned int addr;
469         unsigned int len;
470         unsigned int prot;
471         unsigned int flags;
472         unsigned int fd;
473         unsigned int offset;
474 };
475
476 asmlinkage long
477 sys32_mmap (struct mmap_arg_struct *arg)
478 {
479         struct mmap_arg_struct a;
480         struct file *file = NULL;
481         unsigned long addr;
482         int flags;
483
484         if (copy_from_user(&a, arg, sizeof(a)))
485                 return -EFAULT;
486
487         if (OFFSET4K(a.offset))
488                 return -EINVAL;
489
490         flags = a.flags;
491
492         flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE);
493         if (!(flags & MAP_ANONYMOUS)) {
494                 file = fget(a.fd);
495                 if (!file)
496                         return -EBADF;
497         }
498
499         addr = ia32_do_mmap(file, a.addr, a.len, a.prot, flags, a.offset);
500
501         if (file)
502                 fput(file);
503         return addr;
504 }
505
506 asmlinkage long
507 sys32_mmap2 (unsigned int addr, unsigned int len, unsigned int prot, unsigned int flags,
508              unsigned int fd, unsigned int pgoff)
509 {
510         struct file *file = NULL;
511         unsigned long retval;
512
513         flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE);
514         if (!(flags & MAP_ANONYMOUS)) {
515                 file = fget(fd);
516                 if (!file)
517                         return -EBADF;
518         }
519
520         retval = ia32_do_mmap(file, addr, len, prot, flags,
521                               (unsigned long) pgoff << IA32_PAGE_SHIFT);
522
523         if (file)
524                 fput(file);
525         return retval;
526 }
527
528 asmlinkage long
529 sys32_munmap (unsigned int start, unsigned int len)
530 {
531         unsigned int end = start + len;
532         long ret;
533
534 #if PAGE_SHIFT <= IA32_PAGE_SHIFT
535         ret = sys_munmap(start, end - start);
536 #else
537         if (start > end)
538                 return -EINVAL;
539
540         start = PAGE_ALIGN(start);
541         end = PAGE_START(end);
542
543         if (start >= end)
544                 return 0;
545
546         down(&ia32_mmap_sem);
547         {
548                 ret = sys_munmap(start, end - start);
549         }
550         up(&ia32_mmap_sem);
551 #endif
552         return ret;
553 }
554
555 #if PAGE_SHIFT > IA32_PAGE_SHIFT
556
557 /*
558  * When mprotect()ing a partial page, we set the permission to the union of the old
559  * settings and the new settings.  In other words, it's only possible to make access to a
560  * partial page less restrictive.
561  */
562 static long
563 mprotect_subpage (unsigned long address, int new_prot)
564 {
565         int old_prot;
566
567         if (new_prot == PROT_NONE)
568                 return 0;               /* optimize case where nothing changes... */
569
570         old_prot = get_page_prot(address);
571         return sys_mprotect(address, PAGE_SIZE, new_prot | old_prot);
572 }
573
574 #endif /* PAGE_SHIFT > IA32_PAGE_SHIFT */
575
576 asmlinkage long
577 sys32_mprotect (unsigned int start, unsigned int len, int prot)
578 {
579         unsigned long end = start + len;
580 #if PAGE_SHIFT > IA32_PAGE_SHIFT
581         long retval = 0;
582 #endif
583
584         prot = get_prot32(prot);
585
586 #if PAGE_SHIFT <= IA32_PAGE_SHIFT
587         return sys_mprotect(start, end - start, prot);
588 #else
589         if (OFFSET4K(start))
590                 return -EINVAL;
591
592         end = IA32_PAGE_ALIGN(end);
593         if (end < start)
594                 return -EINVAL;
595
596         down(&ia32_mmap_sem);
597         {
598                 if (PAGE_OFF(start)) {
599                         /* start address is 4KB aligned but not page aligned. */
600                         retval = mprotect_subpage(PAGE_START(start), prot);
601                         if (retval < 0)
602                                 goto out;
603
604                         start = PAGE_ALIGN(start);
605                         if (start >= end)
606                                 goto out;       /* retval is already zero... */
607                 }
608
609                 if (PAGE_OFF(end)) {
610                         /* end address is 4KB aligned but not page aligned. */
611                         retval = mprotect_subpage(PAGE_START(end), prot);
612                         if (retval < 0)
613                                 return retval;
614                         end = PAGE_START(end);
615                 }
616                 retval = sys_mprotect(start, end - start, prot);
617         }
618   out:
619         up(&ia32_mmap_sem);
620         return retval;
621 #endif
622 }
623
624 asmlinkage long
625 sys32_pipe (int *fd)
626 {
627         int retval;
628         int fds[2];
629
630         retval = do_pipe(fds);
631         if (retval)
632                 goto out;
633         if (copy_to_user(fd, fds, sizeof(fds)))
634                 retval = -EFAULT;
635   out:
636         return retval;
637 }
638
639 static inline int
640 put_statfs (struct statfs32 *ubuf, struct statfs *kbuf)
641 {
642         int err;
643
644         if (!access_ok(VERIFY_WRITE, ubuf, sizeof(*ubuf)))
645                 return -EFAULT;
646
647         err = __put_user(kbuf->f_type, &ubuf->f_type);
648         err |= __put_user(kbuf->f_bsize, &ubuf->f_bsize);
649         err |= __put_user(kbuf->f_blocks, &ubuf->f_blocks);
650         err |= __put_user(kbuf->f_bfree, &ubuf->f_bfree);
651         err |= __put_user(kbuf->f_bavail, &ubuf->f_bavail);
652         err |= __put_user(kbuf->f_files, &ubuf->f_files);
653         err |= __put_user(kbuf->f_ffree, &ubuf->f_ffree);
654         err |= __put_user(kbuf->f_namelen, &ubuf->f_namelen);
655         err |= __put_user(kbuf->f_fsid.val[0], &ubuf->f_fsid.val[0]);
656         err |= __put_user(kbuf->f_fsid.val[1], &ubuf->f_fsid.val[1]);
657         return err;
658 }
659
660 extern asmlinkage long sys_statfs(const char * path, struct statfs * buf);
661
662 asmlinkage long
663 sys32_statfs (const char *path, struct statfs32 *buf)
664 {
665         int ret;
666         struct statfs s;
667         mm_segment_t old_fs = get_fs();
668
669         set_fs(KERNEL_DS);
670         ret = sys_statfs(path, &s);
671         set_fs(old_fs);
672         if (put_statfs(buf, &s))
673                 return -EFAULT;
674         return ret;
675 }
676
677 extern asmlinkage long sys_fstatfs(unsigned int fd, struct statfs * buf);
678
679 asmlinkage long
680 sys32_fstatfs (unsigned int fd, struct statfs32 *buf)
681 {
682         int ret;
683         struct statfs s;
684         mm_segment_t old_fs = get_fs();
685
686         set_fs(KERNEL_DS);
687         ret = sys_fstatfs(fd, &s);
688         set_fs(old_fs);
689         if (put_statfs(buf, &s))
690                 return -EFAULT;
691         return ret;
692 }
693
694 struct timeval32
695 {
696     int tv_sec, tv_usec;
697 };
698
699 struct itimerval32
700 {
701     struct timeval32 it_interval;
702     struct timeval32 it_value;
703 };
704
705 static inline long
706 get_tv32 (struct timeval *o, struct timeval32 *i)
707 {
708         return (!access_ok(VERIFY_READ, i, sizeof(*i)) ||
709                 (__get_user(o->tv_sec, &i->tv_sec) | __get_user(o->tv_usec, &i->tv_usec)));
710 }
711
712 static inline long
713 put_tv32 (struct timeval32 *o, struct timeval *i)
714 {
715         return (!access_ok(VERIFY_WRITE, o, sizeof(*o)) ||
716                 (__put_user(i->tv_sec, &o->tv_sec) | __put_user(i->tv_usec, &o->tv_usec)));
717 }
718
719 static inline long
720 get_it32 (struct itimerval *o, struct itimerval32 *i)
721 {
722         return (!access_ok(VERIFY_READ, i, sizeof(*i)) ||
723                 (__get_user(o->it_interval.tv_sec, &i->it_interval.tv_sec) |
724                  __get_user(o->it_interval.tv_usec, &i->it_interval.tv_usec) |
725                  __get_user(o->it_value.tv_sec, &i->it_value.tv_sec) |
726                  __get_user(o->it_value.tv_usec, &i->it_value.tv_usec)));
727 }
728
729 static inline long
730 put_it32 (struct itimerval32 *o, struct itimerval *i)
731 {
732         return (!access_ok(VERIFY_WRITE, o, sizeof(*o)) ||
733                 (__put_user(i->it_interval.tv_sec, &o->it_interval.tv_sec) |
734                  __put_user(i->it_interval.tv_usec, &o->it_interval.tv_usec) |
735                  __put_user(i->it_value.tv_sec, &o->it_value.tv_sec) |
736                  __put_user(i->it_value.tv_usec, &o->it_value.tv_usec)));
737 }
738
739 extern int do_getitimer (int which, struct itimerval *value);
740
741 asmlinkage long
742 sys32_getitimer (int which, struct itimerval32 *it)
743 {
744         struct itimerval kit;
745         int error;
746
747         error = do_getitimer(which, &kit);
748         if (!error && put_it32(it, &kit))
749                 error = -EFAULT;
750
751         return error;
752 }
753
754 extern int do_setitimer (int which, struct itimerval *, struct itimerval *);
755
756 asmlinkage long
757 sys32_setitimer (int which, struct itimerval32 *in, struct itimerval32 *out)
758 {
759         struct itimerval kin, kout;
760         int error;
761
762         if (in) {
763                 if (get_it32(&kin, in))
764                         return -EFAULT;
765         } else
766                 memset(&kin, 0, sizeof(kin));
767
768         error = do_setitimer(which, &kin, out ? &kout : NULL);
769         if (error || !out)
770                 return error;
771         if (put_it32(out, &kout))
772                 return -EFAULT;
773
774         return 0;
775
776 }
777
778 asmlinkage unsigned long
779 sys32_alarm (unsigned int seconds)
780 {
781         struct itimerval it_new, it_old;
782         unsigned int oldalarm;
783
784         it_new.it_interval.tv_sec = it_new.it_interval.tv_usec = 0;
785         it_new.it_value.tv_sec = seconds;
786         it_new.it_value.tv_usec = 0;
787         do_setitimer(ITIMER_REAL, &it_new, &it_old);
788         oldalarm = it_old.it_value.tv_sec;
789         /* ehhh.. We can't return 0 if we have an alarm pending.. */
790         /* And we'd better return too much than too little anyway */
791         if (it_old.it_value.tv_usec)
792                 oldalarm++;
793         return oldalarm;
794 }
795
796 /* Translations due to time_t size differences.  Which affects all
797    sorts of things, like timeval and itimerval.  */
798
799 struct utimbuf_32 {
800         int     atime;
801         int     mtime;
802 };
803
804 extern asmlinkage long sys_utimes(char * filename, struct timeval * utimes);
805 extern asmlinkage long sys_gettimeofday (struct timeval *tv, struct timezone *tz);
806
807 asmlinkage long
808 sys32_utime (char *filename, struct utimbuf_32 *times32)
809 {
810         mm_segment_t old_fs = get_fs();
811         struct timeval tv[2], *tvp;
812         long ret;
813
814         if (times32) {
815                 if (get_user(tv[0].tv_sec, &times32->atime))
816                         return -EFAULT;
817                 tv[0].tv_usec = 0;
818                 if (get_user(tv[1].tv_sec, &times32->mtime))
819                         return -EFAULT;
820                 tv[1].tv_usec = 0;
821                 set_fs(KERNEL_DS);
822                 tvp = tv;
823         } else
824                 tvp = NULL;
825         ret = sys_utimes(filename, tvp);
826         set_fs(old_fs);
827         return ret;
828 }
829
830 extern struct timezone sys_tz;
831 extern int do_sys_settimeofday (struct timeval *tv, struct timezone *tz);
832
833 asmlinkage long
834 sys32_gettimeofday (struct timeval32 *tv, struct timezone *tz)
835 {
836         if (tv) {
837                 struct timeval ktv;
838                 do_gettimeofday(&ktv);
839                 if (put_tv32(tv, &ktv))
840                         return -EFAULT;
841         }
842         if (tz) {
843                 if (copy_to_user(tz, &sys_tz, sizeof(sys_tz)))
844                         return -EFAULT;
845         }
846         return 0;
847 }
848
849 asmlinkage long
850 sys32_settimeofday (struct timeval32 *tv, struct timezone *tz)
851 {
852         struct timeval ktv;
853         struct timezone ktz;
854
855         if (tv) {
856                 if (get_tv32(&ktv, tv))
857                         return -EFAULT;
858         }
859         if (tz) {
860                 if (copy_from_user(&ktz, tz, sizeof(ktz)))
861                         return -EFAULT;
862         }
863
864         return do_sys_settimeofday(tv ? &ktv : NULL, tz ? &ktz : NULL);
865 }
866
867 struct getdents32_callback {
868         struct linux32_dirent * current_dir;
869         struct linux32_dirent * previous;
870         int count;
871         int error;
872 };
873
874 struct readdir32_callback {
875         struct old_linux32_dirent * dirent;
876         int count;
877 };
878
879 static int
880 filldir32 (void *__buf, const char *name, int namlen, loff_t offset, ino_t ino,
881            unsigned int d_type)
882 {
883         struct linux32_dirent * dirent;
884         struct getdents32_callback * buf = (struct getdents32_callback *) __buf;
885         int reclen = ROUND_UP(NAME_OFFSET(dirent) + namlen + 1, 4);
886
887         buf->error = -EINVAL;   /* only used if we fail.. */
888         if (reclen > buf->count)
889                 return -EINVAL;
890         buf->error = -EFAULT;   /* only used if we fail.. */
891         dirent = buf->previous;
892         if (dirent)
893                 if (put_user(offset, &dirent->d_off))
894                         return -EFAULT;
895         dirent = buf->current_dir;
896         buf->previous = dirent;
897         if (put_user(ino, &dirent->d_ino)
898             || put_user(reclen, &dirent->d_reclen)
899             || copy_to_user(dirent->d_name, name, namlen)
900             || put_user(0, dirent->d_name + namlen))
901                 return -EFAULT;
902         ((char *) dirent) += reclen;
903         buf->current_dir = dirent;
904         buf->count -= reclen;
905         return 0;
906 }
907
908 asmlinkage long
909 sys32_getdents (unsigned int fd, struct linux32_dirent *dirent, unsigned int count)
910 {
911         struct file * file;
912         struct linux32_dirent * lastdirent;
913         struct getdents32_callback buf;
914         int error;
915
916         error = -EBADF;
917         file = fget(fd);
918         if (!file)
919                 goto out;
920
921         buf.current_dir = dirent;
922         buf.previous = NULL;
923         buf.count = count;
924         buf.error = 0;
925
926         error = vfs_readdir(file, filldir32, &buf);
927         if (error < 0)
928                 goto out_putf;
929         error = buf.error;
930         lastdirent = buf.previous;
931         if (lastdirent) {
932                 error = -EINVAL;
933                 if (put_user(file->f_pos, &lastdirent->d_off))
934                         goto out_putf;
935                 error = count - buf.count;
936         }
937
938 out_putf:
939         fput(file);
940 out:
941         return error;
942 }
943
944 static int
945 fillonedir32 (void * __buf, const char * name, int namlen, loff_t offset, ino_t ino,
946               unsigned int d_type)
947 {
948         struct readdir32_callback * buf = (struct readdir32_callback *) __buf;
949         struct old_linux32_dirent * dirent;
950
951         if (buf->count)
952                 return -EINVAL;
953         buf->count++;
954         dirent = buf->dirent;
955         if (put_user(ino, &dirent->d_ino)
956             || put_user(offset, &dirent->d_offset)
957             || put_user(namlen, &dirent->d_namlen)
958             || copy_to_user(dirent->d_name, name, namlen)
959             || put_user(0, dirent->d_name + namlen))
960                 return -EFAULT;
961         return 0;
962 }
963
964 asmlinkage long
965 sys32_readdir (unsigned int fd, void *dirent, unsigned int count)
966 {
967         int error;
968         struct file * file;
969         struct readdir32_callback buf;
970
971         error = -EBADF;
972         file = fget(fd);
973         if (!file)
974                 goto out;
975
976         buf.count = 0;
977         buf.dirent = dirent;
978
979         error = vfs_readdir(file, fillonedir32, &buf);
980         if (error >= 0)
981                 error = buf.count;
982         fput(file);
983 out:
984         return error;
985 }
986
987 /*
988  * We can actually return ERESTARTSYS instead of EINTR, but I'd
989  * like to be certain this leads to no problems. So I return
990  * EINTR just for safety.
991  *
992  * Update: ERESTARTSYS breaks at least the xview clock binary, so
993  * I'm trying ERESTARTNOHAND which restart only when you want to.
994  */
995 #define MAX_SELECT_SECONDS \
996         ((unsigned long) (MAX_SCHEDULE_TIMEOUT / HZ)-1)
997 #define ROUND_UP_TIME(x,y) (((x)+(y)-1)/(y))
998
999 asmlinkage long
1000 sys32_select (int n, fd_set *inp, fd_set *outp, fd_set *exp, struct timeval32 *tvp32)
1001 {
1002         fd_set_bits fds;
1003         char *bits;
1004         long timeout;
1005         int ret, size;
1006
1007         timeout = MAX_SCHEDULE_TIMEOUT;
1008         if (tvp32) {
1009                 time_t sec, usec;
1010
1011                 ret = -EFAULT;
1012                 if (get_user(sec, &tvp32->tv_sec) || get_user(usec, &tvp32->tv_usec))
1013                         goto out_nofds;
1014
1015                 ret = -EINVAL;
1016                 if (sec < 0 || usec < 0)
1017                         goto out_nofds;
1018
1019                 if ((unsigned long) sec < MAX_SELECT_SECONDS) {
1020                         timeout = ROUND_UP_TIME(usec, 1000000/HZ);
1021                         timeout += sec * (unsigned long) HZ;
1022                 }
1023         }
1024
1025         ret = -EINVAL;
1026         if (n < 0)
1027                 goto out_nofds;
1028
1029         if (n > current->files->max_fdset)
1030                 n = current->files->max_fdset;
1031
1032         /*
1033          * We need 6 bitmaps (in/out/ex for both incoming and outgoing),
1034          * since we used fdset we need to allocate memory in units of
1035          * long-words.
1036          */
1037         ret = -ENOMEM;
1038         size = FDS_BYTES(n);
1039         bits = kmalloc(6 * size, GFP_KERNEL);
1040         if (!bits)
1041                 goto out_nofds;
1042         fds.in      = (unsigned long *)  bits;
1043         fds.out     = (unsigned long *) (bits +   size);
1044         fds.ex      = (unsigned long *) (bits + 2*size);
1045         fds.res_in  = (unsigned long *) (bits + 3*size);
1046         fds.res_out = (unsigned long *) (bits + 4*size);
1047         fds.res_ex  = (unsigned long *) (bits + 5*size);
1048
1049         if ((ret = get_fd_set(n, inp, fds.in)) ||
1050             (ret = get_fd_set(n, outp, fds.out)) ||
1051             (ret = get_fd_set(n, exp, fds.ex)))
1052                 goto out;
1053         zero_fd_set(n, fds.res_in);
1054         zero_fd_set(n, fds.res_out);
1055         zero_fd_set(n, fds.res_ex);
1056
1057         ret = do_select(n, &fds, &timeout);
1058
1059         if (tvp32 && !(current->personality & STICKY_TIMEOUTS)) {
1060                 time_t sec = 0, usec = 0;
1061                 if (timeout) {
1062                         sec = timeout / HZ;
1063                         usec = timeout % HZ;
1064                         usec *= (1000000/HZ);
1065                 }
1066                 if (put_user(sec, &tvp32->tv_sec) || put_user(usec, &tvp32->tv_usec)) {
1067                         ret = -EFAULT;
1068                         goto out;
1069                 }
1070         }
1071
1072         if (ret < 0)
1073                 goto out;
1074         if (!ret) {
1075                 ret = -ERESTARTNOHAND;
1076                 if (signal_pending(current))
1077                         goto out;
1078                 ret = 0;
1079         }
1080
1081         set_fd_set(n, inp, fds.res_in);
1082         set_fd_set(n, outp, fds.res_out);
1083         set_fd_set(n, exp, fds.res_ex);
1084
1085 out:
1086         kfree(bits);
1087 out_nofds:
1088         return ret;
1089 }
1090
1091 struct sel_arg_struct {
1092         unsigned int n;
1093         unsigned int inp;
1094         unsigned int outp;
1095         unsigned int exp;
1096         unsigned int tvp;
1097 };
1098
1099 asmlinkage long
1100 sys32_old_select (struct sel_arg_struct *arg)
1101 {
1102         struct sel_arg_struct a;
1103
1104         if (copy_from_user(&a, arg, sizeof(a)))
1105                 return -EFAULT;
1106         return sys32_select(a.n, (fd_set *) A(a.inp), (fd_set *) A(a.outp), (fd_set *) A(a.exp),
1107                             (struct timeval32 *) A(a.tvp));
1108 }
1109
1110 extern asmlinkage long sys_nanosleep (struct timespec *rqtp, struct timespec *rmtp);
1111
1112 asmlinkage long
1113 sys32_nanosleep (struct timespec32 *rqtp, struct timespec32 *rmtp)
1114 {
1115         struct timespec t;
1116         int ret;
1117         mm_segment_t old_fs = get_fs();
1118
1119         if (get_user (t.tv_sec, &rqtp->tv_sec) || get_user (t.tv_nsec, &rqtp->tv_nsec))
1120                 return -EFAULT;
1121         set_fs(KERNEL_DS);
1122         ret = sys_nanosleep(&t, rmtp ? &t : NULL);
1123         set_fs(old_fs);
1124         if (rmtp && ret == -EINTR) {
1125                 if (put_user(t.tv_sec, &rmtp->tv_sec) || put_user(t.tv_nsec, &rmtp->tv_nsec))
1126                         return -EFAULT;
1127         }
1128         return ret;
1129 }
1130
1131 struct iovec32 { unsigned int iov_base; int iov_len; };
1132 asmlinkage ssize_t sys_readv (unsigned long,const struct iovec *,unsigned long);
1133 asmlinkage ssize_t sys_writev (unsigned long,const struct iovec *,unsigned long);
1134
1135 static struct iovec *
1136 get_iovec32 (struct iovec32 *iov32, struct iovec *iov_buf, u32 count, int type)
1137 {
1138         int i;
1139         u32 buf, len;
1140         struct iovec *ivp, *iov;
1141
1142         /* Get the "struct iovec" from user memory */
1143
1144         if (!count)
1145                 return 0;
1146         if (verify_area(VERIFY_READ, iov32, sizeof(struct iovec32)*count))
1147                 return NULL;
1148         if (count > UIO_MAXIOV)
1149                 return NULL;
1150         if (count > UIO_FASTIOV) {
1151                 iov = kmalloc(count*sizeof(struct iovec), GFP_KERNEL);
1152                 if (!iov)
1153                         return NULL;
1154         } else
1155                 iov = iov_buf;
1156
1157         ivp = iov;
1158         for (i = 0; i < count; i++) {
1159                 if (__get_user(len, &iov32->iov_len) || __get_user(buf, &iov32->iov_base)) {
1160                         if (iov != iov_buf)
1161                                 kfree(iov);
1162                         return NULL;
1163                 }
1164                 if (verify_area(type, (void *)A(buf), len)) {
1165                         if (iov != iov_buf)
1166                                 kfree(iov);
1167                         return((struct iovec *)0);
1168                 }
1169                 ivp->iov_base = (void *)A(buf);
1170                 ivp->iov_len = (__kernel_size_t) len;
1171                 iov32++;
1172                 ivp++;
1173         }
1174         return iov;
1175 }
1176
1177 asmlinkage long
1178 sys32_readv (int fd, struct iovec32 *vector, u32 count)
1179 {
1180         struct iovec iovstack[UIO_FASTIOV];
1181         struct iovec *iov;
1182         long ret;
1183         mm_segment_t old_fs = get_fs();
1184
1185         iov = get_iovec32(vector, iovstack, count, VERIFY_WRITE);
1186         if (!iov)
1187                 return -EFAULT;
1188         set_fs(KERNEL_DS);
1189         ret = sys_readv(fd, iov, count);
1190         set_fs(old_fs);
1191         if (iov != iovstack)
1192                 kfree(iov);
1193         return ret;
1194 }
1195
1196 asmlinkage long
1197 sys32_writev (int fd, struct iovec32 *vector, u32 count)
1198 {
1199         struct iovec iovstack[UIO_FASTIOV];
1200         struct iovec *iov;
1201         long ret;
1202         mm_segment_t old_fs = get_fs();
1203
1204         iov = get_iovec32(vector, iovstack, count, VERIFY_READ);
1205         if (!iov)
1206                 return -EFAULT;
1207         set_fs(KERNEL_DS);
1208         ret = sys_writev(fd, iov, count);
1209         set_fs(old_fs);
1210         if (iov != iovstack)
1211                 kfree(iov);
1212         return ret;
1213 }
1214
1215 #define RLIM_INFINITY32 0x7fffffff
1216 #define RESOURCE32(x) ((x > RLIM_INFINITY32) ? RLIM_INFINITY32 : x)
1217
1218 struct rlimit32 {
1219         int     rlim_cur;
1220         int     rlim_max;
1221 };
1222
1223 extern asmlinkage long sys_getrlimit (unsigned int resource, struct rlimit *rlim);
1224
1225 asmlinkage long
1226 sys32_old_getrlimit (unsigned int resource, struct rlimit32 *rlim)
1227 {
1228         mm_segment_t old_fs = get_fs();
1229         struct rlimit r;
1230         int ret;
1231
1232         set_fs(KERNEL_DS);
1233         ret = sys_getrlimit(resource, &r);
1234         set_fs(old_fs);
1235         if (!ret) {
1236                 ret = put_user(RESOURCE32(r.rlim_cur), &rlim->rlim_cur);
1237                 ret |= put_user(RESOURCE32(r.rlim_max), &rlim->rlim_max);
1238         }
1239         return ret;
1240 }
1241
1242 asmlinkage long
1243 sys32_getrlimit (unsigned int resource, struct rlimit32 *rlim)
1244 {
1245         mm_segment_t old_fs = get_fs();
1246         struct rlimit r;
1247         int ret;
1248
1249         set_fs(KERNEL_DS);
1250         ret = sys_getrlimit(resource, &r);
1251         set_fs(old_fs);
1252         if (!ret) {
1253                 if (r.rlim_cur >= 0xffffffff)
1254                         r.rlim_cur = 0xffffffff;
1255                 if (r.rlim_max >= 0xffffffff)
1256                         r.rlim_max = 0xffffffff;
1257                 ret = put_user(r.rlim_cur, &rlim->rlim_cur);
1258                 ret |= put_user(r.rlim_max, &rlim->rlim_max);
1259         }
1260         return ret;
1261 }
1262
1263 extern asmlinkage long sys_setrlimit (unsigned int resource, struct rlimit *rlim);
1264
1265 asmlinkage long
1266 sys32_setrlimit (unsigned int resource, struct rlimit32 *rlim)
1267 {
1268         struct rlimit r;
1269         int ret;
1270         mm_segment_t old_fs = get_fs();
1271
1272         if (resource >= RLIM_NLIMITS)
1273                 return -EINVAL;
1274         if (get_user(r.rlim_cur, &rlim->rlim_cur) || get_user(r.rlim_max, &rlim->rlim_max))
1275                 return -EFAULT;
1276         if (r.rlim_cur == RLIM_INFINITY32)
1277                 r.rlim_cur = RLIM_INFINITY;
1278         if (r.rlim_max == RLIM_INFINITY32)
1279                 r.rlim_max = RLIM_INFINITY;
1280         set_fs(KERNEL_DS);
1281         ret = sys_setrlimit(resource, &r);
1282         set_fs(old_fs);
1283         return ret;
1284 }
1285
1286 /*
1287  *  Declare the IA32 version of the msghdr
1288  */
1289
1290 struct msghdr32 {
1291         unsigned int    msg_name;       /* Socket name                  */
1292         int             msg_namelen;    /* Length of name               */
1293         unsigned int    msg_iov;        /* Data blocks                  */
1294         unsigned int    msg_iovlen;     /* Number of blocks             */
1295         unsigned int    msg_control;    /* Per protocol magic (eg BSD file descriptor passing) */
1296         unsigned int    msg_controllen; /* Length of cmsg list */
1297         unsigned        msg_flags;
1298 };
1299
1300 struct cmsghdr32 {
1301         __kernel_size_t32 cmsg_len;
1302         int               cmsg_level;
1303         int               cmsg_type;
1304 };
1305
1306 /* Bleech... */
1307 #define __CMSG32_NXTHDR(ctl, len, cmsg, cmsglen) __cmsg32_nxthdr((ctl),(len),(cmsg),(cmsglen))
1308 #define CMSG32_NXTHDR(mhdr, cmsg, cmsglen)      cmsg32_nxthdr((mhdr), (cmsg), (cmsglen))
1309 #define CMSG32_ALIGN(len) ( ((len)+sizeof(int)-1) & ~(sizeof(int)-1) )
1310 #define CMSG32_DATA(cmsg) \
1311         ((void *)((char *)(cmsg) + CMSG32_ALIGN(sizeof(struct cmsghdr32))))
1312 #define CMSG32_SPACE(len) \
1313         (CMSG32_ALIGN(sizeof(struct cmsghdr32)) + CMSG32_ALIGN(len))
1314 #define CMSG32_LEN(len) (CMSG32_ALIGN(sizeof(struct cmsghdr32)) + (len))
1315 #define __CMSG32_FIRSTHDR(ctl,len) \
1316         ((len) >= sizeof(struct cmsghdr32) ? (struct cmsghdr32 *)(ctl) : (struct cmsghdr32 *)NULL)
1317 #define CMSG32_FIRSTHDR(msg)    __CMSG32_FIRSTHDR((msg)->msg_control, (msg)->msg_controllen)
1318
1319 static inline struct cmsghdr32 *
1320 __cmsg32_nxthdr (void *ctl, __kernel_size_t size, struct cmsghdr32 *cmsg, int cmsg_len)
1321 {
1322         struct cmsghdr32 * ptr;
1323
1324         ptr = (struct cmsghdr32 *)(((unsigned char *) cmsg) + CMSG32_ALIGN(cmsg_len));
1325         if ((unsigned long)((char*)(ptr+1) - (char *) ctl) > size)
1326                 return NULL;
1327         return ptr;
1328 }
1329
1330 static inline struct cmsghdr32 *
1331 cmsg32_nxthdr (struct msghdr *msg, struct cmsghdr32 *cmsg, int cmsg_len)
1332 {
1333         return __cmsg32_nxthdr(msg->msg_control, msg->msg_controllen, cmsg, cmsg_len);
1334 }
1335
1336 static inline int
1337 get_msghdr32 (struct msghdr *mp, struct msghdr32 *mp32)
1338 {
1339         int ret;
1340         unsigned int i;
1341
1342         if (!access_ok(VERIFY_READ, mp32, sizeof(*mp32)))
1343                 return -EFAULT;
1344         ret = __get_user(i, &mp32->msg_name);
1345         mp->msg_name = (void *)A(i);
1346         ret |= __get_user(mp->msg_namelen, &mp32->msg_namelen);
1347         ret |= __get_user(i, &mp32->msg_iov);
1348         mp->msg_iov = (struct iovec *)A(i);
1349         ret |= __get_user(mp->msg_iovlen, &mp32->msg_iovlen);
1350         ret |= __get_user(i, &mp32->msg_control);
1351         mp->msg_control = (void *)A(i);
1352         ret |= __get_user(mp->msg_controllen, &mp32->msg_controllen);
1353         ret |= __get_user(mp->msg_flags, &mp32->msg_flags);
1354         return ret ? -EFAULT : 0;
1355 }
1356
1357 /*
1358  * There is a lot of hair here because the alignment rules (and thus placement) of cmsg
1359  * headers and length are different for 32-bit apps.  -DaveM
1360  */
1361 static int
1362 get_cmsghdr32 (struct msghdr *kmsg, unsigned char *stackbuf, struct sock *sk, size_t *bufsize)
1363 {
1364         struct cmsghdr *kcmsg, *kcmsg_base;
1365         __kernel_size_t kcmlen, tmp;
1366         __kernel_size_t32 ucmlen;
1367         struct cmsghdr32 *ucmsg;
1368         long err;
1369
1370         kcmlen = 0;
1371         kcmsg_base = kcmsg = (struct cmsghdr *)stackbuf;
1372         ucmsg = CMSG32_FIRSTHDR(kmsg);
1373         while (ucmsg != NULL) {
1374                 if (get_user(ucmlen, &ucmsg->cmsg_len))
1375                         return -EFAULT;
1376
1377                 /* Catch bogons. */
1378                 if (CMSG32_ALIGN(ucmlen) < CMSG32_ALIGN(sizeof(struct cmsghdr32)))
1379                         return -EINVAL;
1380                 if ((unsigned long)(((char *)ucmsg - (char *)kmsg->msg_control) + ucmlen)
1381                     > kmsg->msg_controllen)
1382                         return -EINVAL;
1383
1384                 tmp = ((ucmlen - CMSG32_ALIGN(sizeof(*ucmsg))) +
1385                        CMSG_ALIGN(sizeof(struct cmsghdr)));
1386                 kcmlen += tmp;
1387                 ucmsg = CMSG32_NXTHDR(kmsg, ucmsg, ucmlen);
1388         }
1389         if (kcmlen == 0)
1390                 return -EINVAL;
1391
1392         /*
1393          * The kcmlen holds the 64-bit version of the control length.  It may not be
1394          * modified as we do not stick it into the kmsg until we have successfully copied
1395          * over all of the data from the user.
1396          */
1397         if (kcmlen > *bufsize) {
1398                 *bufsize = kcmlen;
1399                 kcmsg_base = kcmsg = sock_kmalloc(sk, kcmlen, GFP_KERNEL);
1400         }
1401         if (kcmsg == NULL)
1402                 return -ENOBUFS;
1403
1404         /* Now copy them over neatly. */
1405         memset(kcmsg, 0, kcmlen);
1406         ucmsg = CMSG32_FIRSTHDR(kmsg);
1407         while (ucmsg != NULL) {
1408                 err = get_user(ucmlen, &ucmsg->cmsg_len);
1409                 tmp = ((ucmlen - CMSG32_ALIGN(sizeof(*ucmsg))) +
1410                        CMSG_ALIGN(sizeof(struct cmsghdr)));
1411                 kcmsg->cmsg_len = tmp;
1412                 err |= get_user(kcmsg->cmsg_level, &ucmsg->cmsg_level);
1413                 err |= get_user(kcmsg->cmsg_type, &ucmsg->cmsg_type);
1414
1415                 /* Copy over the data. */
1416                 err |= copy_from_user(CMSG_DATA(kcmsg), CMSG32_DATA(ucmsg),
1417                                       (ucmlen - CMSG32_ALIGN(sizeof(*ucmsg))));
1418                 if (err)
1419                         goto out_free_efault;
1420
1421                 /* Advance. */
1422                 kcmsg = (struct cmsghdr *)((char *)kcmsg + CMSG_ALIGN(tmp));
1423                 ucmsg = CMSG32_NXTHDR(kmsg, ucmsg, ucmlen);
1424         }
1425
1426         /* Ok, looks like we made it.  Hook it up and return success. */
1427         kmsg->msg_control = kcmsg_base;
1428         kmsg->msg_controllen = kcmlen;
1429         return 0;
1430
1431 out_free_efault:
1432         if (kcmsg_base != (struct cmsghdr *)stackbuf)
1433                 sock_kfree_s(sk, kcmsg_base, kcmlen);
1434         return -EFAULT;
1435 }
1436
1437 /*
1438  *      Verify & re-shape IA32 iovec. The caller must ensure that the
1439  *      iovec is big enough to hold the re-shaped message iovec.
1440  *
1441  *      Save time not doing verify_area. copy_*_user will make this work
1442  *      in any case.
1443  *
1444  *      Don't need to check the total size for overflow (cf net/core/iovec.c),
1445  *      32-bit sizes can't overflow a 64-bit count.
1446  */
1447
1448 static inline int
1449 verify_iovec32 (struct msghdr *m, struct iovec *iov, char *address, int mode)
1450 {
1451         int size, err, ct;
1452         struct iovec32 *iov32;
1453
1454         if (m->msg_namelen) {
1455                 if (mode == VERIFY_READ) {
1456                         err = move_addr_to_kernel(m->msg_name, m->msg_namelen, address);
1457                         if (err < 0)
1458                                 goto out;
1459                 }
1460                 m->msg_name = address;
1461         } else
1462                 m->msg_name = NULL;
1463
1464         err = -EFAULT;
1465         size = m->msg_iovlen * sizeof(struct iovec32);
1466         if (copy_from_user(iov, m->msg_iov, size))
1467                 goto out;
1468         m->msg_iov = iov;
1469
1470         err = 0;
1471         iov32 = (struct iovec32 *)iov;
1472         for (ct = m->msg_iovlen; ct-- > 0; ) {
1473                 iov[ct].iov_len = (__kernel_size_t)iov32[ct].iov_len;
1474                 iov[ct].iov_base = (void *) A(iov32[ct].iov_base);
1475                 err += iov[ct].iov_len;
1476         }
1477 out:
1478         return err;
1479 }
1480
1481 static void
1482 put_cmsg32(struct msghdr *kmsg, int level, int type, int len, void *data)
1483 {
1484         struct cmsghdr32 *cm = (struct cmsghdr32 *) kmsg->msg_control;
1485         struct cmsghdr32 cmhdr;
1486         int cmlen = CMSG32_LEN(len);
1487
1488         if(cm == NULL || kmsg->msg_controllen < sizeof(*cm)) {
1489                 kmsg->msg_flags |= MSG_CTRUNC;
1490                 return;
1491         }
1492
1493         if(kmsg->msg_controllen < cmlen) {
1494                 kmsg->msg_flags |= MSG_CTRUNC;
1495                 cmlen = kmsg->msg_controllen;
1496         }
1497         cmhdr.cmsg_level = level;
1498         cmhdr.cmsg_type = type;
1499         cmhdr.cmsg_len = cmlen;
1500
1501         if(copy_to_user(cm, &cmhdr, sizeof cmhdr))
1502                 return;
1503         if(copy_to_user(CMSG32_DATA(cm), data,
1504                         cmlen - sizeof(struct cmsghdr32)))
1505                 return;
1506         cmlen = CMSG32_SPACE(len);
1507         kmsg->msg_control += cmlen;
1508         kmsg->msg_controllen -= cmlen;
1509 }
1510
1511 static void
1512 scm_detach_fds32 (struct msghdr *kmsg, struct scm_cookie *scm)
1513 {
1514         struct cmsghdr32 *cm = (struct cmsghdr32 *) kmsg->msg_control;
1515         int fdmax = (kmsg->msg_controllen - sizeof(struct cmsghdr32))
1516                 / sizeof(int);
1517         int fdnum = scm->fp->count;
1518         struct file **fp = scm->fp->fp;
1519         int *cmfptr;
1520         int err = 0, i;
1521
1522         if (fdnum < fdmax)
1523                 fdmax = fdnum;
1524
1525         for (i = 0, cmfptr = (int *) CMSG32_DATA(cm);
1526              i < fdmax;
1527              i++, cmfptr++) {
1528                 int new_fd;
1529                 err = get_unused_fd();
1530                 if (err < 0)
1531                         break;
1532                 new_fd = err;
1533                 err = put_user(new_fd, cmfptr);
1534                 if (err) {
1535                         put_unused_fd(new_fd);
1536                         break;
1537                 }
1538                 /* Bump the usage count and install the file. */
1539                 get_file(fp[i]);
1540                 current->files->fd[new_fd] = fp[i];
1541         }
1542
1543         if (i > 0) {
1544                 int cmlen = CMSG32_LEN(i * sizeof(int));
1545                 if (!err)
1546                         err = put_user(SOL_SOCKET, &cm->cmsg_level);
1547                 if (!err)
1548                         err = put_user(SCM_RIGHTS, &cm->cmsg_type);
1549                 if (!err)
1550                         err = put_user(cmlen, &cm->cmsg_len);
1551                 if (!err) {
1552                         cmlen = CMSG32_SPACE(i * sizeof(int));
1553                         kmsg->msg_control += cmlen;
1554                         kmsg->msg_controllen -= cmlen;
1555                 }
1556         }
1557         if (i < fdnum)
1558                 kmsg->msg_flags |= MSG_CTRUNC;
1559
1560         /*
1561          * All of the files that fit in the message have had their
1562          * usage counts incremented, so we just free the list.
1563          */
1564         __scm_destroy(scm);
1565 }
1566
1567 /*
1568  * In these cases we (currently) can just copy to data over verbatim because all CMSGs
1569  * created by the kernel have well defined types which have the same layout in both the
1570  * 32-bit and 64-bit API.  One must add some special cased conversions here if we start
1571  * sending control messages with incompatible types.
1572  *
1573  * SCM_RIGHTS and SCM_CREDENTIALS are done by hand in recvmsg32 right after
1574  * we do our work.  The remaining cases are:
1575  *
1576  * SOL_IP       IP_PKTINFO      struct in_pktinfo       32-bit clean
1577  *              IP_TTL          int                     32-bit clean
1578  *              IP_TOS          __u8                    32-bit clean
1579  *              IP_RECVOPTS     variable length         32-bit clean
1580  *              IP_RETOPTS      variable length         32-bit clean
1581  *              (these last two are clean because the types are defined
1582  *               by the IPv4 protocol)
1583  *              IP_RECVERR      struct sock_extended_err +
1584  *                              struct sockaddr_in      32-bit clean
1585  * SOL_IPV6     IPV6_RECVERR    struct sock_extended_err +
1586  *                              struct sockaddr_in6     32-bit clean
1587  *              IPV6_PKTINFO    struct in6_pktinfo      32-bit clean
1588  *              IPV6_HOPLIMIT   int                     32-bit clean
1589  *              IPV6_FLOWINFO   u32                     32-bit clean
1590  *              IPV6_HOPOPTS    ipv6 hop exthdr         32-bit clean
1591  *              IPV6_DSTOPTS    ipv6 dst exthdr(s)      32-bit clean
1592  *              IPV6_RTHDR      ipv6 routing exthdr     32-bit clean
1593  *              IPV6_AUTHHDR    ipv6 auth exthdr        32-bit clean
1594  */
1595 static void
1596 cmsg32_recvmsg_fixup (struct msghdr *kmsg, unsigned long orig_cmsg_uptr)
1597 {
1598         unsigned char *workbuf, *wp;
1599         unsigned long bufsz, space_avail;
1600         struct cmsghdr *ucmsg;
1601         long err;
1602
1603         bufsz = ((unsigned long)kmsg->msg_control) - orig_cmsg_uptr;
1604         space_avail = kmsg->msg_controllen + bufsz;
1605         wp = workbuf = kmalloc(bufsz, GFP_KERNEL);
1606         if (workbuf == NULL)
1607                 goto fail;
1608
1609         /* To make this more sane we assume the kernel sends back properly
1610          * formatted control messages.  Because of how the kernel will truncate
1611          * the cmsg_len for MSG_TRUNC cases, we need not check that case either.
1612          */
1613         ucmsg = (struct cmsghdr *) orig_cmsg_uptr;
1614         while (((unsigned long)ucmsg) < ((unsigned long)kmsg->msg_control)) {
1615                 struct cmsghdr32 *kcmsg32 = (struct cmsghdr32 *) wp;
1616                 int clen64, clen32;
1617
1618                 /*
1619                  * UCMSG is the 64-bit format CMSG entry in user-space.  KCMSG32 is within
1620                  * the kernel space temporary buffer we use to convert into a 32-bit style
1621                  * CMSG.
1622                  */
1623                 err = get_user(kcmsg32->cmsg_len, &ucmsg->cmsg_len);
1624                 err |= get_user(kcmsg32->cmsg_level, &ucmsg->cmsg_level);
1625                 err |= get_user(kcmsg32->cmsg_type, &ucmsg->cmsg_type);
1626                 if (err)
1627                         goto fail2;
1628
1629                 clen64 = kcmsg32->cmsg_len;
1630                 copy_from_user(CMSG32_DATA(kcmsg32), CMSG_DATA(ucmsg),
1631                                clen64 - CMSG_ALIGN(sizeof(*ucmsg)));
1632                 clen32 = ((clen64 - CMSG_ALIGN(sizeof(*ucmsg))) +
1633                           CMSG32_ALIGN(sizeof(struct cmsghdr32)));
1634                 kcmsg32->cmsg_len = clen32;
1635
1636                 ucmsg = (struct cmsghdr *) (((char *)ucmsg) + CMSG_ALIGN(clen64));
1637                 wp = (((char *)kcmsg32) + CMSG32_ALIGN(clen32));
1638         }
1639
1640         /* Copy back fixed up data, and adjust pointers. */
1641         bufsz = (wp - workbuf);
1642         if (copy_to_user((void *)orig_cmsg_uptr, workbuf, bufsz))
1643                 goto fail2;
1644
1645         kmsg->msg_control = (struct cmsghdr *) (((char *)orig_cmsg_uptr) + bufsz);
1646         kmsg->msg_controllen = space_avail - bufsz;
1647         kfree(workbuf);
1648         return;
1649
1650   fail2:
1651         kfree(workbuf);
1652   fail:
1653         /*
1654          * If we leave the 64-bit format CMSG chunks in there, the application could get
1655          * confused and crash.  So to ensure greater recovery, we report no CMSGs.
1656          */
1657         kmsg->msg_controllen += bufsz;
1658         kmsg->msg_control = (void *) orig_cmsg_uptr;
1659 }
1660
1661 static inline void
1662 sockfd_put (struct socket *sock)
1663 {
1664         fput(sock->file);
1665 }
1666
1667 /* XXX This really belongs in some header file... -DaveM */
1668 #define MAX_SOCK_ADDR   128             /* 108 for Unix domain -
1669                                            16 for IP, 16 for IPX,
1670                                            24 for IPv6,
1671                                            about 80 for AX.25 */
1672
1673 extern struct socket *sockfd_lookup (int fd, int *err);
1674
1675 /*
1676  *      BSD sendmsg interface
1677  */
1678
1679 int
1680 sys32_sendmsg (int fd, struct msghdr32 *msg, unsigned flags)
1681 {
1682         struct socket *sock;
1683         char address[MAX_SOCK_ADDR];
1684         struct iovec iovstack[UIO_FASTIOV], *iov = iovstack;
1685         unsigned char ctl[sizeof(struct cmsghdr) + 20]; /* 20 is size of ipv6_pktinfo */
1686         unsigned char *ctl_buf = ctl;
1687         struct msghdr msg_sys;
1688         int err, iov_size, total_len;
1689         size_t ctl_len;
1690
1691         err = -EFAULT;
1692         if (get_msghdr32(&msg_sys, msg))
1693                 goto out;
1694
1695         sock = sockfd_lookup(fd, &err);
1696         if (!sock)
1697                 goto out;
1698
1699         /* do not move before msg_sys is valid */
1700         err = -EINVAL;
1701         if (msg_sys.msg_iovlen > UIO_MAXIOV)
1702                 goto out_put;
1703
1704         /* Check whether to allocate the iovec area*/
1705         err = -ENOMEM;
1706         iov_size = msg_sys.msg_iovlen * sizeof(struct iovec32);
1707         if (msg_sys.msg_iovlen > UIO_FASTIOV) {
1708                 iov = sock_kmalloc(sock->sk, iov_size, GFP_KERNEL);
1709                 if (!iov)
1710                         goto out_put;
1711         }
1712
1713         /* This will also move the address data into kernel space */
1714         err = verify_iovec32(&msg_sys, iov, address, VERIFY_READ);
1715         if (err < 0)
1716                 goto out_freeiov;
1717         total_len = err;
1718
1719         err = -ENOBUFS;
1720
1721         if (msg_sys.msg_controllen > INT_MAX)
1722                 goto out_freeiov;
1723         if (msg_sys.msg_controllen) {
1724                 ctl_len = sizeof(ctl);
1725                 err = get_cmsghdr32(&msg_sys, ctl_buf, sock->sk, &ctl_len);
1726                 if (err)
1727                         goto out_freeiov;
1728                 ctl_buf = msg_sys.msg_control;
1729         }
1730         msg_sys.msg_flags = flags;
1731
1732         if (sock->file->f_flags & O_NONBLOCK)
1733                 msg_sys.msg_flags |= MSG_DONTWAIT;
1734         err = sock_sendmsg(sock, &msg_sys, total_len);
1735
1736         if (ctl_buf != ctl)
1737                 sock_kfree_s(sock->sk, ctl_buf, ctl_len);
1738 out_freeiov:
1739         if (iov != iovstack)
1740                 sock_kfree_s(sock->sk, iov, iov_size);
1741 out_put:
1742         sockfd_put(sock);
1743 out:
1744         return err;
1745 }
1746
1747 /*
1748  *      BSD recvmsg interface
1749  */
1750
1751 int
1752 sys32_recvmsg (int fd, struct msghdr32 *msg, unsigned int flags)
1753 {
1754         struct socket *sock;
1755         struct iovec iovstack[UIO_FASTIOV];
1756         struct iovec *iov=iovstack;
1757         struct msghdr msg_sys;
1758         unsigned long cmsg_ptr;
1759         int err, iov_size, total_len, len;
1760         struct scm_cookie scm;
1761
1762         /* kernel mode address */
1763         char addr[MAX_SOCK_ADDR];
1764
1765         /* user mode address pointers */
1766         struct sockaddr *uaddr;
1767         int *uaddr_len;
1768
1769         err = -EFAULT;
1770         if (get_msghdr32(&msg_sys, msg))
1771                 goto out;
1772
1773         sock = sockfd_lookup(fd, &err);
1774         if (!sock)
1775                 goto out;
1776
1777         err = -EINVAL;
1778         if (msg_sys.msg_iovlen > UIO_MAXIOV)
1779                 goto out_put;
1780
1781         /* Check whether to allocate the iovec area*/
1782         err = -ENOMEM;
1783         iov_size = msg_sys.msg_iovlen * sizeof(struct iovec);
1784         if (msg_sys.msg_iovlen > UIO_FASTIOV) {
1785                 iov = sock_kmalloc(sock->sk, iov_size, GFP_KERNEL);
1786                 if (!iov)
1787                         goto out_put;
1788         }
1789
1790         /*
1791          *      Save the user-mode address (verify_iovec will change the
1792          *      kernel msghdr to use the kernel address space)
1793          */
1794
1795         uaddr = msg_sys.msg_name;
1796         uaddr_len = &msg->msg_namelen;
1797         err = verify_iovec32(&msg_sys, iov, addr, VERIFY_WRITE);
1798         if (err < 0)
1799                 goto out_freeiov;
1800         total_len=err;
1801
1802         cmsg_ptr = (unsigned long)msg_sys.msg_control;
1803         msg_sys.msg_flags = 0;
1804
1805         if (sock->file->f_flags & O_NONBLOCK)
1806                 flags |= MSG_DONTWAIT;
1807
1808         memset(&scm, 0, sizeof(scm));
1809
1810         lock_kernel();
1811         {
1812                 err = sock->ops->recvmsg(sock, &msg_sys, total_len, flags, &scm);
1813                 if (err < 0)
1814                         goto out_unlock_freeiov;
1815
1816                 len = err;
1817                 if (!msg_sys.msg_control) {
1818                         if (sock->passcred || scm.fp)
1819                                 msg_sys.msg_flags |= MSG_CTRUNC;
1820                         if (scm.fp)
1821                                 __scm_destroy(&scm);
1822                 } else {
1823                         /*
1824                          * If recvmsg processing itself placed some control messages into
1825                          * user space, it's is using 64-bit CMSG processing, so we need to
1826                          * fix it up before we tack on more stuff.
1827                          */
1828                         if ((unsigned long) msg_sys.msg_control != cmsg_ptr)
1829                                 cmsg32_recvmsg_fixup(&msg_sys, cmsg_ptr);
1830
1831                         /* Wheee... */
1832                         if (sock->passcred)
1833                                 put_cmsg32(&msg_sys, SOL_SOCKET, SCM_CREDENTIALS,
1834                                            sizeof(scm.creds), &scm.creds);
1835                         if (scm.fp != NULL)
1836                                 scm_detach_fds32(&msg_sys, &scm);
1837                 }
1838         }
1839         unlock_kernel();
1840
1841         if (uaddr != NULL) {
1842                 err = move_addr_to_user(addr, msg_sys.msg_namelen, uaddr, uaddr_len);
1843                 if (err < 0)
1844                         goto out_freeiov;
1845         }
1846         err = __put_user(msg_sys.msg_flags, &msg->msg_flags);
1847         if (err)
1848                 goto out_freeiov;
1849         err = __put_user((unsigned long)msg_sys.msg_control-cmsg_ptr,
1850                                                          &msg->msg_controllen);
1851         if (err)
1852                 goto out_freeiov;
1853         err = len;
1854
1855   out_freeiov:
1856         if (iov != iovstack)
1857                 sock_kfree_s(sock->sk, iov, iov_size);
1858   out_put:
1859         sockfd_put(sock);
1860   out:
1861         return err;
1862
1863   out_unlock_freeiov:
1864         goto out_freeiov;
1865 }
1866
1867 /* Argument list sizes for sys_socketcall */
1868 #define AL(x) ((x) * sizeof(u32))
1869 static const unsigned char nas[18]={AL(0),AL(3),AL(3),AL(3),AL(2),AL(3),
1870                                     AL(3),AL(3),AL(4),AL(4),AL(4),AL(6),
1871                                     AL(6),AL(2),AL(5),AL(5),AL(3),AL(3)};
1872 #undef AL
1873
1874 extern asmlinkage long sys_bind(int fd, struct sockaddr *umyaddr, int addrlen);
1875 extern asmlinkage long sys_connect(int fd, struct sockaddr *uservaddr,
1876                                   int addrlen);
1877 extern asmlinkage long sys_accept(int fd, struct sockaddr *upeer_sockaddr,
1878                                  int *upeer_addrlen);
1879 extern asmlinkage long sys_getsockname(int fd, struct sockaddr *usockaddr,
1880                                       int *usockaddr_len);
1881 extern asmlinkage long sys_getpeername(int fd, struct sockaddr *usockaddr,
1882                                       int *usockaddr_len);
1883 extern asmlinkage long sys_send(int fd, void *buff, size_t len, unsigned flags);
1884 extern asmlinkage long sys_sendto(int fd, u32 buff, __kernel_size_t32 len,
1885                                    unsigned flags, u32 addr, int addr_len);
1886 extern asmlinkage long sys_recv(int fd, void *ubuf, size_t size, unsigned flags);
1887 extern asmlinkage long sys_recvfrom(int fd, u32 ubuf, __kernel_size_t32 size,
1888                                      unsigned flags, u32 addr, u32 addr_len);
1889 extern asmlinkage long sys_setsockopt(int fd, int level, int optname,
1890                                      char *optval, int optlen);
1891 extern asmlinkage long sys_getsockopt(int fd, int level, int optname,
1892                                        u32 optval, u32 optlen);
1893
1894 extern asmlinkage long sys_socket(int family, int type, int protocol);
1895 extern asmlinkage long sys_socketpair(int family, int type, int protocol,
1896                                      int usockvec[2]);
1897 extern asmlinkage long sys_shutdown(int fd, int how);
1898 extern asmlinkage long sys_listen(int fd, int backlog);
1899
1900 asmlinkage long
1901 sys32_socketcall (int call, u32 *args)
1902 {
1903         int ret;
1904         u32 a[6];
1905         u32 a0,a1;
1906
1907         if (call<SYS_SOCKET||call>SYS_RECVMSG)
1908                 return -EINVAL;
1909         if (copy_from_user(a, args, nas[call]))
1910                 return -EFAULT;
1911         a0=a[0];
1912         a1=a[1];
1913
1914         switch(call)
1915         {
1916                 case SYS_SOCKET:
1917                         ret = sys_socket(a0, a1, a[2]);
1918                         break;
1919                 case SYS_BIND:
1920                         ret = sys_bind(a0, (struct sockaddr *)A(a1), a[2]);
1921                         break;
1922                 case SYS_CONNECT:
1923                         ret = sys_connect(a0, (struct sockaddr *)A(a1), a[2]);
1924                         break;
1925                 case SYS_LISTEN:
1926                         ret = sys_listen(a0, a1);
1927                         break;
1928                 case SYS_ACCEPT:
1929                         ret = sys_accept(a0, (struct sockaddr *)A(a1), (int *)A(a[2]));
1930                         break;
1931                 case SYS_GETSOCKNAME:
1932                         ret = sys_getsockname(a0, (struct sockaddr *)A(a1), (int *)A(a[2]));
1933                         break;
1934                 case SYS_GETPEERNAME:
1935                         ret = sys_getpeername(a0, (struct sockaddr *)A(a1), (int *)A(a[2]));
1936                         break;
1937                 case SYS_SOCKETPAIR:
1938                         ret = sys_socketpair(a0, a1, a[2], (int *)A(a[3]));
1939                         break;
1940                 case SYS_SEND:
1941                         ret = sys_send(a0, (void *)A(a1), a[2], a[3]);
1942                         break;
1943                 case SYS_SENDTO:
1944                         ret = sys_sendto(a0, a1, a[2], a[3], a[4], a[5]);
1945                         break;
1946                 case SYS_RECV:
1947                         ret = sys_recv(a0, (void *)A(a1), a[2], a[3]);
1948                         break;
1949                 case SYS_RECVFROM:
1950                         ret = sys_recvfrom(a0, a1, a[2], a[3], a[4], a[5]);
1951                         break;
1952                 case SYS_SHUTDOWN:
1953                         ret = sys_shutdown(a0,a1);
1954                         break;
1955                 case SYS_SETSOCKOPT:
1956                         ret = sys_setsockopt(a0, a1, a[2], (char *)A(a[3]),
1957                                               a[4]);
1958                         break;
1959                 case SYS_GETSOCKOPT:
1960                         ret = sys_getsockopt(a0, a1, a[2], a[3], a[4]);
1961                         break;
1962                 case SYS_SENDMSG:
1963                         ret = sys32_sendmsg(a0, (struct msghdr32 *) A(a1), a[2]);
1964                         break;
1965                 case SYS_RECVMSG:
1966                         ret = sys32_recvmsg(a0, (struct msghdr32 *) A(a1), a[2]);
1967                         break;
1968                 default:
1969                         ret = EINVAL;
1970                         break;
1971         }
1972         return ret;
1973 }
1974
1975 /*
1976  * sys32_ipc() is the de-multiplexer for the SysV IPC calls in 32bit emulation..
1977  *
1978  * This is really horribly ugly.
1979  */
1980
1981 struct msgbuf32 { s32 mtype; char mtext[1]; };
1982
1983 struct ipc_perm32 {
1984         key_t key;
1985         __kernel_uid_t32 uid;
1986         __kernel_gid_t32 gid;
1987         __kernel_uid_t32 cuid;
1988         __kernel_gid_t32 cgid;
1989         __kernel_mode_t32 mode;
1990         unsigned short seq;
1991 };
1992
1993 struct ipc64_perm32 {
1994         key_t key;
1995         __kernel_uid32_t32 uid;
1996         __kernel_gid32_t32 gid;
1997         __kernel_uid32_t32 cuid;
1998         __kernel_gid32_t32 cgid;
1999         __kernel_mode_t32 mode;
2000         unsigned short __pad1;
2001         unsigned short seq;
2002         unsigned short __pad2;
2003         unsigned int unused1;
2004         unsigned int unused2;
2005 };
2006
2007 struct semid_ds32 {
2008         struct ipc_perm32 sem_perm;               /* permissions .. see ipc.h */
2009         __kernel_time_t32 sem_otime;              /* last semop time */
2010         __kernel_time_t32 sem_ctime;              /* last change time */
2011         u32 sem_base;              /* ptr to first semaphore in array */
2012         u32 sem_pending;          /* pending operations to be processed */
2013         u32 sem_pending_last;    /* last pending operation */
2014         u32 undo;                  /* undo requests on this array */
2015         unsigned short  sem_nsems;              /* no. of semaphores in array */
2016 };
2017
2018 struct semid64_ds32 {
2019         struct ipc64_perm32 sem_perm;
2020         __kernel_time_t32 sem_otime;
2021         unsigned int __unused1;
2022         __kernel_time_t32 sem_ctime;
2023         unsigned int __unused2;
2024         unsigned int sem_nsems;
2025         unsigned int __unused3;
2026         unsigned int __unused4;
2027 };
2028
2029 struct msqid_ds32 {
2030         struct ipc_perm32 msg_perm;
2031         u32 msg_first;
2032         u32 msg_last;
2033         __kernel_time_t32 msg_stime;
2034         __kernel_time_t32 msg_rtime;
2035         __kernel_time_t32 msg_ctime;
2036         u32 wwait;
2037         u32 rwait;
2038         unsigned short msg_cbytes;
2039         unsigned short msg_qnum;
2040         unsigned short msg_qbytes;
2041         __kernel_ipc_pid_t32 msg_lspid;
2042         __kernel_ipc_pid_t32 msg_lrpid;
2043 };
2044
2045 struct msqid64_ds32 {
2046         struct ipc64_perm32 msg_perm;
2047         __kernel_time_t32 msg_stime;
2048         unsigned int __unused1;
2049         __kernel_time_t32 msg_rtime;
2050         unsigned int __unused2;
2051         __kernel_time_t32 msg_ctime;
2052         unsigned int __unused3;
2053         unsigned int msg_cbytes;
2054         unsigned int msg_qnum;
2055         unsigned int msg_qbytes;
2056         __kernel_pid_t32 msg_lspid;
2057         __kernel_pid_t32 msg_lrpid;
2058         unsigned int __unused4;
2059         unsigned int __unused5;
2060 };
2061
2062 struct shmid_ds32 {
2063         struct ipc_perm32 shm_perm;
2064         int shm_segsz;
2065         __kernel_time_t32 shm_atime;
2066         __kernel_time_t32 shm_dtime;
2067         __kernel_time_t32 shm_ctime;
2068         __kernel_ipc_pid_t32 shm_cpid;
2069         __kernel_ipc_pid_t32 shm_lpid;
2070         unsigned short shm_nattch;
2071 };
2072
2073 struct shmid64_ds32 {
2074         struct ipc64_perm shm_perm;
2075         __kernel_size_t32 shm_segsz;
2076         __kernel_time_t32 shm_atime;
2077         unsigned int __unused1;
2078         __kernel_time_t32 shm_dtime;
2079         unsigned int __unused2;
2080         __kernel_time_t32 shm_ctime;
2081         unsigned int __unused3;
2082         __kernel_pid_t32 shm_cpid;
2083         __kernel_pid_t32 shm_lpid;
2084         unsigned int shm_nattch;
2085         unsigned int __unused4;
2086         unsigned int __unused5;
2087 };
2088
2089 struct shminfo64_32 {
2090         unsigned int shmmax;
2091         unsigned int shmmin;
2092         unsigned int shmmni;
2093         unsigned int shmseg;
2094         unsigned int shmall;
2095         unsigned int __unused1;
2096         unsigned int __unused2;
2097         unsigned int __unused3;
2098         unsigned int __unused4;
2099 };
2100
2101 struct shm_info32 {
2102         int used_ids;
2103         u32 shm_tot, shm_rss, shm_swp;
2104         u32 swap_attempts, swap_successes;
2105 };
2106
2107 struct ipc_kludge {
2108         struct msgbuf *msgp;
2109         long msgtyp;
2110 };
2111
2112 #define SEMOP            1
2113 #define SEMGET           2
2114 #define SEMCTL           3
2115 #define MSGSND          11
2116 #define MSGRCV          12
2117 #define MSGGET          13
2118 #define MSGCTL          14
2119 #define SHMAT           21
2120 #define SHMDT           22
2121 #define SHMGET          23
2122 #define SHMCTL          24
2123
2124 #define IPCOP_MASK(__x) (1UL << (__x))
2125
2126 static int
2127 ipc_parse_version32 (int *cmd)
2128 {
2129         if (*cmd & IPC_64) {
2130                 *cmd ^= IPC_64;
2131                 return IPC_64;
2132         } else {
2133                 return IPC_OLD;
2134         }
2135 }
2136
2137 static int
2138 semctl32 (int first, int second, int third, void *uptr)
2139 {
2140         union semun fourth;
2141         u32 pad;
2142         int err = 0, err2;
2143         struct semid64_ds s;
2144         mm_segment_t old_fs;
2145         int version = ipc_parse_version32(&third);
2146
2147         if (!uptr)
2148                 return -EINVAL;
2149         if (get_user(pad, (u32 *)uptr))
2150                 return -EFAULT;
2151         if (third == SETVAL)
2152                 fourth.val = (int)pad;
2153         else
2154                 fourth.__pad = (void *)A(pad);
2155         switch (third) {
2156               case IPC_INFO:
2157               case IPC_RMID:
2158               case IPC_SET:
2159               case SEM_INFO:
2160               case GETVAL:
2161               case GETPID:
2162               case GETNCNT:
2163               case GETZCNT:
2164               case GETALL:
2165               case SETVAL:
2166               case SETALL:
2167                 err = sys_semctl(first, second, third, fourth);
2168                 break;
2169
2170               case IPC_STAT:
2171               case SEM_STAT:
2172                 fourth.__pad = &s;
2173                 old_fs = get_fs();
2174                 set_fs(KERNEL_DS);
2175                 err = sys_semctl(first, second, third, fourth);
2176                 set_fs(old_fs);
2177
2178                 if (version == IPC_64) {
2179                         struct semid64_ds32 *usp64 = (struct semid64_ds32 *) A(pad);
2180
2181                         if (!access_ok(VERIFY_WRITE, usp64, sizeof(*usp64))) {
2182                                 err = -EFAULT;
2183                                 break;
2184                         }
2185                         err2 = __put_user(s.sem_perm.key, &usp64->sem_perm.key);
2186                         err2 |= __put_user(s.sem_perm.uid, &usp64->sem_perm.uid);
2187                         err2 |= __put_user(s.sem_perm.gid, &usp64->sem_perm.gid);
2188                         err2 |= __put_user(s.sem_perm.cuid, &usp64->sem_perm.cuid);
2189                         err2 |= __put_user(s.sem_perm.cgid, &usp64->sem_perm.cgid);
2190                         err2 |= __put_user(s.sem_perm.mode, &usp64->sem_perm.mode);
2191                         err2 |= __put_user(s.sem_perm.seq, &usp64->sem_perm.seq);
2192                         err2 |= __put_user(s.sem_otime, &usp64->sem_otime);
2193                         err2 |= __put_user(s.sem_ctime, &usp64->sem_ctime);
2194                         err2 |= __put_user(s.sem_nsems, &usp64->sem_nsems);
2195                 } else {
2196                         struct semid_ds32 *usp32 = (struct semid_ds32 *) A(pad);
2197
2198                         if (!access_ok(VERIFY_WRITE, usp32, sizeof(*usp32))) {
2199                                 err = -EFAULT;
2200                                 break;
2201                         }
2202                         err2 = __put_user(s.sem_perm.key, &usp32->sem_perm.key);
2203                         err2 |= __put_user(s.sem_perm.uid, &usp32->sem_perm.uid);
2204                         err2 |= __put_user(s.sem_perm.gid, &usp32->sem_perm.gid);
2205                         err2 |= __put_user(s.sem_perm.cuid, &usp32->sem_perm.cuid);
2206                         err2 |= __put_user(s.sem_perm.cgid, &usp32->sem_perm.cgid);
2207                         err2 |= __put_user(s.sem_perm.mode, &usp32->sem_perm.mode);
2208                         err2 |= __put_user(s.sem_perm.seq, &usp32->sem_perm.seq);
2209                         err2 |= __put_user(s.sem_otime, &usp32->sem_otime);
2210                         err2 |= __put_user(s.sem_ctime, &usp32->sem_ctime);
2211                         err2 |= __put_user(s.sem_nsems, &usp32->sem_nsems);
2212                 }
2213                 if (err2)
2214                     err = -EFAULT;
2215                 break;
2216         }
2217         return err;
2218 }
2219
2220 static int
2221 do_sys32_msgsnd (int first, int second, int third, void *uptr)
2222 {
2223         struct msgbuf *p = kmalloc(second + sizeof(struct msgbuf) + 4, GFP_USER);
2224         struct msgbuf32 *up = (struct msgbuf32 *)uptr;
2225         mm_segment_t old_fs;
2226         int err;
2227
2228         if (!p)
2229                 return -ENOMEM;
2230         err = get_user(p->mtype, &up->mtype);
2231         err |= copy_from_user(p->mtext, &up->mtext, second);
2232         if (err)
2233                 goto out;
2234         old_fs = get_fs();
2235         set_fs(KERNEL_DS);
2236         err = sys_msgsnd(first, p, second, third);
2237         set_fs(old_fs);
2238   out:
2239         kfree(p);
2240         return err;
2241 }
2242
2243 static int
2244 do_sys32_msgrcv (int first, int second, int msgtyp, int third, int version, void *uptr)
2245 {
2246         struct msgbuf32 *up;
2247         struct msgbuf *p;
2248         mm_segment_t old_fs;
2249         int err;
2250
2251         if (!version) {
2252                 struct ipc_kludge *uipck = (struct ipc_kludge *)uptr;
2253                 struct ipc_kludge ipck;
2254
2255                 err = -EINVAL;
2256                 if (!uptr)
2257                         goto out;
2258                 err = -EFAULT;
2259                 if (copy_from_user(&ipck, uipck, sizeof(struct ipc_kludge)))
2260                         goto out;
2261                 uptr = (void *)A(ipck.msgp);
2262                 msgtyp = ipck.msgtyp;
2263         }
2264         err = -ENOMEM;
2265         p = kmalloc(second + sizeof(struct msgbuf) + 4, GFP_USER);
2266         if (!p)
2267                 goto out;
2268         old_fs = get_fs();
2269         set_fs(KERNEL_DS);
2270         err = sys_msgrcv(first, p, second + 4, msgtyp, third);
2271         set_fs(old_fs);
2272         if (err < 0)
2273                 goto free_then_out;
2274         up = (struct msgbuf32 *)uptr;
2275         if (put_user(p->mtype, &up->mtype) || copy_to_user(&up->mtext, p->mtext, err))
2276                 err = -EFAULT;
2277 free_then_out:
2278         kfree(p);
2279 out:
2280         return err;
2281 }
2282
2283 static int
2284 msgctl32 (int first, int second, void *uptr)
2285 {
2286         int err = -EINVAL, err2;
2287         struct msqid_ds m;
2288         struct msqid64_ds m64;
2289         struct msqid_ds32 *up32 = (struct msqid_ds32 *)uptr;
2290         struct msqid64_ds32 *up64 = (struct msqid64_ds32 *)uptr;
2291         mm_segment_t old_fs;
2292         int version = ipc_parse_version32(&second);
2293
2294         switch (second) {
2295               case IPC_INFO:
2296               case IPC_RMID:
2297               case MSG_INFO:
2298                 err = sys_msgctl(first, second, (struct msqid_ds *)uptr);
2299                 break;
2300
2301               case IPC_SET:
2302                 if (version == IPC_64) {
2303                         err = get_user(m.msg_perm.uid, &up64->msg_perm.uid);
2304                         err |= get_user(m.msg_perm.gid, &up64->msg_perm.gid);
2305                         err |= get_user(m.msg_perm.mode, &up64->msg_perm.mode);
2306                         err |= get_user(m.msg_qbytes, &up64->msg_qbytes);
2307                 } else {
2308                         err = get_user(m.msg_perm.uid, &up32->msg_perm.uid);
2309                         err |= get_user(m.msg_perm.gid, &up32->msg_perm.gid);
2310                         err |= get_user(m.msg_perm.mode, &up32->msg_perm.mode);
2311                         err |= get_user(m.msg_qbytes, &up32->msg_qbytes);
2312                 }
2313                 if (err)
2314                         break;
2315                 old_fs = get_fs();
2316                 set_fs(KERNEL_DS);
2317                 err = sys_msgctl(first, second, &m);
2318                 set_fs(old_fs);
2319                 break;
2320
2321               case IPC_STAT:
2322               case MSG_STAT:
2323                 old_fs = get_fs();
2324                 set_fs(KERNEL_DS);
2325                 err = sys_msgctl(first, second, (void *) &m64);
2326                 set_fs(old_fs);
2327
2328                 if (version == IPC_64) {
2329                         if (!access_ok(VERIFY_WRITE, up64, sizeof(*up64))) {
2330                                 err = -EFAULT;
2331                                 break;
2332                         }
2333                         err2 = __put_user(m64.msg_perm.key, &up64->msg_perm.key);
2334                         err2 |= __put_user(m64.msg_perm.uid, &up64->msg_perm.uid);
2335                         err2 |= __put_user(m64.msg_perm.gid, &up64->msg_perm.gid);
2336                         err2 |= __put_user(m64.msg_perm.cuid, &up64->msg_perm.cuid);
2337                         err2 |= __put_user(m64.msg_perm.cgid, &up64->msg_perm.cgid);
2338                         err2 |= __put_user(m64.msg_perm.mode, &up64->msg_perm.mode);
2339                         err2 |= __put_user(m64.msg_perm.seq, &up64->msg_perm.seq);
2340                         err2 |= __put_user(m64.msg_stime, &up64->msg_stime);
2341                         err2 |= __put_user(m64.msg_rtime, &up64->msg_rtime);
2342                         err2 |= __put_user(m64.msg_ctime, &up64->msg_ctime);
2343                         err2 |= __put_user(m64.msg_cbytes, &up64->msg_cbytes);
2344                         err2 |= __put_user(m64.msg_qnum, &up64->msg_qnum);
2345                         err2 |= __put_user(m64.msg_qbytes, &up64->msg_qbytes);
2346                         err2 |= __put_user(m64.msg_lspid, &up64->msg_lspid);
2347                         err2 |= __put_user(m64.msg_lrpid, &up64->msg_lrpid);
2348                         if (err2)
2349                                 err = -EFAULT;
2350                 } else {
2351                         if (!access_ok(VERIFY_WRITE, up32, sizeof(*up32))) {
2352                                 err = -EFAULT;
2353                                 break;
2354                         }
2355                         err2 = __put_user(m64.msg_perm.key, &up32->msg_perm.key);
2356                         err2 |= __put_user(m64.msg_perm.uid, &up32->msg_perm.uid);
2357                         err2 |= __put_user(m64.msg_perm.gid, &up32->msg_perm.gid);
2358                         err2 |= __put_user(m64.msg_perm.cuid, &up32->msg_perm.cuid);
2359                         err2 |= __put_user(m64.msg_perm.cgid, &up32->msg_perm.cgid);
2360                         err2 |= __put_user(m64.msg_perm.mode, &up32->msg_perm.mode);
2361                         err2 |= __put_user(m64.msg_perm.seq, &up32->msg_perm.seq);
2362                         err2 |= __put_user(m64.msg_stime, &up32->msg_stime);
2363                         err2 |= __put_user(m64.msg_rtime, &up32->msg_rtime);
2364                         err2 |= __put_user(m64.msg_ctime, &up32->msg_ctime);
2365                         err2 |= __put_user(m64.msg_cbytes, &up32->msg_cbytes);
2366                         err2 |= __put_user(m64.msg_qnum, &up32->msg_qnum);
2367                         err2 |= __put_user(m64.msg_qbytes, &up32->msg_qbytes);
2368                         err2 |= __put_user(m64.msg_lspid, &up32->msg_lspid);
2369                         err2 |= __put_user(m64.msg_lrpid, &up32->msg_lrpid);
2370                         if (err2)
2371                                 err = -EFAULT;
2372                 }
2373                 break;
2374         }
2375         return err;
2376 }
2377
2378 static int
2379 shmat32 (int first, int second, int third, int version, void *uptr)
2380 {
2381         unsigned long raddr;
2382         u32 *uaddr = (u32 *)A((u32)third);
2383         int err;
2384
2385         if (version == 1)
2386                 return -EINVAL; /* iBCS2 emulator entry point: unsupported */
2387         err = sys_shmat(first, uptr, second, &raddr);
2388         if (err)
2389                 return err;
2390         return put_user(raddr, uaddr);
2391 }
2392
2393 static int
2394 shmctl32 (int first, int second, void *uptr)
2395 {
2396         int err = -EFAULT, err2;
2397         struct shmid_ds s;
2398         struct shmid64_ds s64;
2399         struct shmid_ds32 *up32 = (struct shmid_ds32 *)uptr;
2400         struct shmid64_ds32 *up64 = (struct shmid64_ds32 *)uptr;
2401         mm_segment_t old_fs;
2402         struct shm_info32 *uip = (struct shm_info32 *)uptr;
2403         struct shm_info si;
2404         int version = ipc_parse_version32(&second);
2405         struct shminfo64 smi;
2406         struct shminfo *usi32 = (struct shminfo *) uptr;
2407         struct shminfo64_32 *usi64 = (struct shminfo64_32 *) uptr;
2408
2409         switch (second) {
2410               case IPC_INFO:
2411                 old_fs = get_fs();
2412                 set_fs(KERNEL_DS);
2413                 err = sys_shmctl(first, second, (struct shmid_ds *)&smi);
2414                 set_fs(old_fs);
2415
2416                 if (version == IPC_64) {
2417                         if (!access_ok(VERIFY_WRITE, usi64, sizeof(*usi64))) {
2418                                 err = -EFAULT;
2419                                 break;
2420                         }
2421                         err2 = __put_user(smi.shmmax, &usi64->shmmax);
2422                         err2 |= __put_user(smi.shmmin, &usi64->shmmin);
2423                         err2 |= __put_user(smi.shmmni, &usi64->shmmni);
2424                         err2 |= __put_user(smi.shmseg, &usi64->shmseg);
2425                         err2 |= __put_user(smi.shmall, &usi64->shmall);
2426                 } else {
2427                         if (!access_ok(VERIFY_WRITE, usi32, sizeof(*usi32))) {
2428                                 err = -EFAULT;
2429                                 break;
2430                         }
2431                         err2 = __put_user(smi.shmmax, &usi32->shmmax);
2432                         err2 |= __put_user(smi.shmmin, &usi32->shmmin);
2433                         err2 |= __put_user(smi.shmmni, &usi32->shmmni);
2434                         err2 |= __put_user(smi.shmseg, &usi32->shmseg);
2435                         err2 |= __put_user(smi.shmall, &usi32->shmall);
2436                 }
2437                 if (err2)
2438                         err = -EFAULT;
2439                 break;
2440
2441               case IPC_RMID:
2442               case SHM_LOCK:
2443               case SHM_UNLOCK:
2444                 err = sys_shmctl(first, second, (struct shmid_ds *)uptr);
2445                 break;
2446
2447               case IPC_SET:
2448                 if (version == IPC_64) {
2449                         err = get_user(s.shm_perm.uid, &up64->shm_perm.uid);
2450                         err |= get_user(s.shm_perm.gid, &up64->shm_perm.gid);
2451                         err |= get_user(s.shm_perm.mode, &up64->shm_perm.mode);
2452                 } else {
2453                         err = get_user(s.shm_perm.uid, &up32->shm_perm.uid);
2454                         err |= get_user(s.shm_perm.gid, &up32->shm_perm.gid);
2455                         err |= get_user(s.shm_perm.mode, &up32->shm_perm.mode);
2456                 }
2457                 if (err)
2458                         break;
2459                 old_fs = get_fs();
2460                 set_fs(KERNEL_DS);
2461                 err = sys_shmctl(first, second, &s);
2462                 set_fs(old_fs);
2463                 break;
2464
2465               case IPC_STAT:
2466               case SHM_STAT:
2467                 old_fs = get_fs();
2468                 set_fs(KERNEL_DS);
2469                 err = sys_shmctl(first, second, (void *) &s64);
2470                 set_fs(old_fs);
2471                 if (err < 0)
2472                         break;
2473                 if (version == IPC_64) {
2474                         if (!access_ok(VERIFY_WRITE, up64, sizeof(*up64))) {
2475                                 err = -EFAULT;
2476                                 break;
2477                         }
2478                         err2 = __put_user(s64.shm_perm.key, &up64->shm_perm.key);
2479                         err2 |= __put_user(s64.shm_perm.uid, &up64->shm_perm.uid);
2480                         err2 |= __put_user(s64.shm_perm.gid, &up64->shm_perm.gid);
2481                         err2 |= __put_user(s64.shm_perm.cuid, &up64->shm_perm.cuid);
2482                         err2 |= __put_user(s64.shm_perm.cgid, &up64->shm_perm.cgid);
2483                         err2 |= __put_user(s64.shm_perm.mode, &up64->shm_perm.mode);
2484                         err2 |= __put_user(s64.shm_perm.seq, &up64->shm_perm.seq);
2485                         err2 |= __put_user(s64.shm_atime, &up64->shm_atime);
2486                         err2 |= __put_user(s64.shm_dtime, &up64->shm_dtime);
2487                         err2 |= __put_user(s64.shm_ctime, &up64->shm_ctime);
2488                         err2 |= __put_user(s64.shm_segsz, &up64->shm_segsz);
2489                         err2 |= __put_user(s64.shm_nattch, &up64->shm_nattch);
2490                         err2 |= __put_user(s64.shm_cpid, &up64->shm_cpid);
2491                         err2 |= __put_user(s64.shm_lpid, &up64->shm_lpid);
2492                 } else {
2493                         if (!access_ok(VERIFY_WRITE, up32, sizeof(*up32))) {
2494                                 err = -EFAULT;
2495                                 break;
2496                         }
2497                         err2 = __put_user(s64.shm_perm.key, &up32->shm_perm.key);
2498                         err2 |= __put_user(s64.shm_perm.uid, &up32->shm_perm.uid);
2499                         err2 |= __put_user(s64.shm_perm.gid, &up32->shm_perm.gid);
2500                         err2 |= __put_user(s64.shm_perm.cuid, &up32->shm_perm.cuid);
2501                         err2 |= __put_user(s64.shm_perm.cgid, &up32->shm_perm.cgid);
2502                         err2 |= __put_user(s64.shm_perm.mode, &up32->shm_perm.mode);
2503                         err2 |= __put_user(s64.shm_perm.seq, &up32->shm_perm.seq);
2504                         err2 |= __put_user(s64.shm_atime, &up32->shm_atime);
2505                         err2 |= __put_user(s64.shm_dtime, &up32->shm_dtime);
2506                         err2 |= __put_user(s64.shm_ctime, &up32->shm_ctime);
2507                         err2 |= __put_user(s64.shm_segsz, &up32->shm_segsz);
2508                         err2 |= __put_user(s64.shm_nattch, &up32->shm_nattch);
2509                         err2 |= __put_user(s64.shm_cpid, &up32->shm_cpid);
2510                         err2 |= __put_user(s64.shm_lpid, &up32->shm_lpid);
2511                 }
2512                 if (err2)
2513                         err = -EFAULT;
2514                 break;
2515
2516               case SHM_INFO:
2517                 old_fs = get_fs();
2518                 set_fs(KERNEL_DS);
2519                 err = sys_shmctl(first, second, (void *)&si);
2520                 set_fs(old_fs);
2521                 if (err < 0)
2522                         break;
2523
2524                 if (!access_ok(VERIFY_WRITE, uip, sizeof(*uip))) {
2525                         err = -EFAULT;
2526                         break;
2527                 }
2528                 err2 = __put_user(si.used_ids, &uip->used_ids);
2529                 err2 |= __put_user(si.shm_tot, &uip->shm_tot);
2530                 err2 |= __put_user(si.shm_rss, &uip->shm_rss);
2531                 err2 |= __put_user(si.shm_swp, &uip->shm_swp);
2532                 err2 |= __put_user(si.swap_attempts, &uip->swap_attempts);
2533                 err2 |= __put_user(si.swap_successes, &uip->swap_successes);
2534                 if (err2)
2535                         err = -EFAULT;
2536                 break;
2537
2538         }
2539         return err;
2540 }
2541
2542 asmlinkage long
2543 sys32_ipc (u32 call, int first, int second, int third, u32 ptr, u32 fifth)
2544 {
2545         int version;
2546
2547         version = call >> 16; /* hack for backward compatibility */
2548         call &= 0xffff;
2549
2550         switch (call) {
2551               case SEMOP:
2552                 /* struct sembuf is the same on 32 and 64bit :)) */
2553                 return sys_semop(first, (struct sembuf *)AA(ptr), second);
2554               case SEMGET:
2555                 return sys_semget(first, second, third);
2556               case SEMCTL:
2557                 return semctl32(first, second, third, (void *)AA(ptr));
2558
2559               case MSGSND:
2560                 return do_sys32_msgsnd(first, second, third, (void *)AA(ptr));
2561               case MSGRCV:
2562                 return do_sys32_msgrcv(first, second, fifth, third, version, (void *)AA(ptr));
2563               case MSGGET:
2564                 return sys_msgget((key_t) first, second);
2565               case MSGCTL:
2566                 return msgctl32(first, second, (void *)AA(ptr));
2567
2568               case SHMAT:
2569                 return shmat32(first, second, third, version, (void *)AA(ptr));
2570                 break;
2571               case SHMDT:
2572                 return sys_shmdt((char *)AA(ptr));
2573               case SHMGET:
2574                 return sys_shmget(first, second, third);
2575               case SHMCTL:
2576                 return shmctl32(first, second, (void *)AA(ptr));
2577
2578               default:
2579                 return -EINVAL;
2580         }
2581 }
2582
2583 /*
2584  * sys_time() can be implemented in user-level using
2585  * sys_gettimeofday().  IA64 did this but i386 Linux did not
2586  * so we have to implement this system call here.
2587  */
2588 asmlinkage long
2589 sys32_time (int *tloc)
2590 {
2591         int i;
2592
2593         /* SMP: This is fairly trivial. We grab CURRENT_TIME and
2594            stuff it to user space. No side effects */
2595         i = CURRENT_TIME;
2596         if (tloc) {
2597                 if (put_user(i, tloc))
2598                         i = -EFAULT;
2599         }
2600         return i;
2601 }
2602
2603 struct rusage32 {
2604         struct timeval32 ru_utime;
2605         struct timeval32 ru_stime;
2606         int    ru_maxrss;
2607         int    ru_ixrss;
2608         int    ru_idrss;
2609         int    ru_isrss;
2610         int    ru_minflt;
2611         int    ru_majflt;
2612         int    ru_nswap;
2613         int    ru_inblock;
2614         int    ru_oublock;
2615         int    ru_msgsnd;
2616         int    ru_msgrcv;
2617         int    ru_nsignals;
2618         int    ru_nvcsw;
2619         int    ru_nivcsw;
2620 };
2621
2622 static int
2623 put_rusage (struct rusage32 *ru, struct rusage *r)
2624 {
2625         int err;
2626
2627         if (!access_ok(VERIFY_WRITE, ru, sizeof(*ru)))
2628                 return -EFAULT;
2629
2630         err = __put_user (r->ru_utime.tv_sec, &ru->ru_utime.tv_sec);
2631         err |= __put_user (r->ru_utime.tv_usec, &ru->ru_utime.tv_usec);
2632         err |= __put_user (r->ru_stime.tv_sec, &ru->ru_stime.tv_sec);
2633         err |= __put_user (r->ru_stime.tv_usec, &ru->ru_stime.tv_usec);
2634         err |= __put_user (r->ru_maxrss, &ru->ru_maxrss);
2635         err |= __put_user (r->ru_ixrss, &ru->ru_ixrss);
2636         err |= __put_user (r->ru_idrss, &ru->ru_idrss);
2637         err |= __put_user (r->ru_isrss, &ru->ru_isrss);
2638         err |= __put_user (r->ru_minflt, &ru->ru_minflt);
2639         err |= __put_user (r->ru_majflt, &ru->ru_majflt);
2640         err |= __put_user (r->ru_nswap, &ru->ru_nswap);
2641         err |= __put_user (r->ru_inblock, &ru->ru_inblock);
2642         err |= __put_user (r->ru_oublock, &ru->ru_oublock);
2643         err |= __put_user (r->ru_msgsnd, &ru->ru_msgsnd);
2644         err |= __put_user (r->ru_msgrcv, &ru->ru_msgrcv);
2645         err |= __put_user (r->ru_nsignals, &ru->ru_nsignals);
2646         err |= __put_user (r->ru_nvcsw, &ru->ru_nvcsw);
2647         err |= __put_user (r->ru_nivcsw, &ru->ru_nivcsw);
2648         return err;
2649 }
2650
2651 asmlinkage long
2652 sys32_wait4 (int pid, unsigned int *stat_addr, int options, struct rusage32 *ru)
2653 {
2654         if (!ru)
2655                 return sys_wait4(pid, stat_addr, options, NULL);
2656         else {
2657                 struct rusage r;
2658                 int ret;
2659                 unsigned int status;
2660                 mm_segment_t old_fs = get_fs();
2661
2662                 set_fs(KERNEL_DS);
2663                 ret = sys_wait4(pid, stat_addr ? &status : NULL, options, &r);
2664                 set_fs(old_fs);
2665                 if (put_rusage(ru, &r))
2666                         return -EFAULT;
2667                 if (stat_addr && put_user(status, stat_addr))
2668                         return -EFAULT;
2669                 return ret;
2670         }
2671 }
2672
2673 asmlinkage long
2674 sys32_waitpid (int pid, unsigned int *stat_addr, int options)
2675 {
2676         return sys32_wait4(pid, stat_addr, options, NULL);
2677 }
2678
2679
2680 extern asmlinkage long sys_getrusage (int who, struct rusage *ru);
2681
2682 asmlinkage long
2683 sys32_getrusage (int who, struct rusage32 *ru)
2684 {
2685         struct rusage r;
2686         int ret;
2687         mm_segment_t old_fs = get_fs();
2688
2689         set_fs(KERNEL_DS);
2690         ret = sys_getrusage(who, &r);
2691         set_fs(old_fs);
2692         if (put_rusage (ru, &r))
2693                 return -EFAULT;
2694         return ret;
2695 }
2696
2697 struct tms32 {
2698         __kernel_clock_t32 tms_utime;
2699         __kernel_clock_t32 tms_stime;
2700         __kernel_clock_t32 tms_cutime;
2701         __kernel_clock_t32 tms_cstime;
2702 };
2703
2704 extern asmlinkage long sys_times (struct tms * tbuf);
2705
2706 asmlinkage long
2707 sys32_times (struct tms32 *tbuf)
2708 {
2709         mm_segment_t old_fs = get_fs();
2710         struct tms t;
2711         long ret;
2712         int err;
2713
2714         set_fs(KERNEL_DS);
2715         ret = sys_times(tbuf ? &t : NULL);
2716         set_fs(old_fs);
2717         if (tbuf) {
2718                 err = put_user (IA32_TICK(t.tms_utime), &tbuf->tms_utime);
2719                 err |= put_user (IA32_TICK(t.tms_stime), &tbuf->tms_stime);
2720                 err |= put_user (IA32_TICK(t.tms_cutime), &tbuf->tms_cutime);
2721                 err |= put_user (IA32_TICK(t.tms_cstime), &tbuf->tms_cstime);
2722                 if (err)
2723                         ret = -EFAULT;
2724         }
2725         return IA32_TICK(ret);
2726 }
2727
2728 static unsigned int
2729 ia32_peek (struct pt_regs *regs, struct task_struct *child, unsigned long addr, unsigned int *val)
2730 {
2731         size_t copied;
2732         unsigned int ret;
2733
2734         copied = access_process_vm(child, addr, val, sizeof(*val), 0);
2735         return (copied != sizeof(ret)) ? -EIO : 0;
2736 }
2737
2738 static unsigned int
2739 ia32_poke (struct pt_regs *regs, struct task_struct *child, unsigned long addr, unsigned int val)
2740 {
2741
2742         if (access_process_vm(child, addr, &val, sizeof(val), 1) != sizeof(val))
2743                 return -EIO;
2744         return 0;
2745 }
2746
2747 /*
2748  *  The order in which registers are stored in the ptrace regs structure
2749  */
2750 #define PT_EBX  0
2751 #define PT_ECX  1
2752 #define PT_EDX  2
2753 #define PT_ESI  3
2754 #define PT_EDI  4
2755 #define PT_EBP  5
2756 #define PT_EAX  6
2757 #define PT_DS   7
2758 #define PT_ES   8
2759 #define PT_FS   9
2760 #define PT_GS   10
2761 #define PT_ORIG_EAX 11
2762 #define PT_EIP  12
2763 #define PT_CS   13
2764 #define PT_EFL  14