Merge branch 'upstream' into upstream-jgarzik
[linux-2.6] / arch / mips / kernel / linux32.c
1 /*
2  * Conversion between 32-bit and 64-bit native system calls.
3  *
4  * Copyright (C) 2000 Silicon Graphics, Inc.
5  * Written by Ulf Carlsson (ulfc@engr.sgi.com)
6  * sys32_execve from ia64/ia32 code, Feb 2000, Kanoj Sarcar (kanoj@sgi.com)
7  */
8 #include <linux/compiler.h>
9 #include <linux/mm.h>
10 #include <linux/errno.h>
11 #include <linux/file.h>
12 #include <linux/smp_lock.h>
13 #include <linux/highuid.h>
14 #include <linux/dirent.h>
15 #include <linux/resource.h>
16 #include <linux/highmem.h>
17 #include <linux/time.h>
18 #include <linux/times.h>
19 #include <linux/poll.h>
20 #include <linux/slab.h>
21 #include <linux/skbuff.h>
22 #include <linux/filter.h>
23 #include <linux/shm.h>
24 #include <linux/sem.h>
25 #include <linux/msg.h>
26 #include <linux/icmpv6.h>
27 #include <linux/syscalls.h>
28 #include <linux/sysctl.h>
29 #include <linux/utime.h>
30 #include <linux/utsname.h>
31 #include <linux/personality.h>
32 #include <linux/dnotify.h>
33 #include <linux/module.h>
34 #include <linux/binfmts.h>
35 #include <linux/security.h>
36 #include <linux/compat.h>
37 #include <linux/vfs.h>
38
39 #include <net/sock.h>
40 #include <net/scm.h>
41
42 #include <asm/compat-signal.h>
43 #include <asm/ipc.h>
44 #include <asm/sim.h>
45 #include <asm/uaccess.h>
46 #include <asm/mmu_context.h>
47 #include <asm/mman.h>
48
49 /* Use this to get at 32-bit user passed pointers. */
50 /* A() macro should be used for places where you e.g.
51    have some internal variable u32 and just want to get
52    rid of a compiler warning. AA() has to be used in
53    places where you want to convert a function argument
54    to 32bit pointer or when you e.g. access pt_regs
55    structure and want to consider 32bit registers only.
56  */
57 #define A(__x) ((unsigned long)(__x))
58 #define AA(__x) ((unsigned long)((int)__x))
59
60 #ifdef __MIPSEB__
61 #define merge_64(r1,r2) ((((r1) & 0xffffffffUL) << 32) + ((r2) & 0xffffffffUL))
62 #endif
63 #ifdef __MIPSEL__
64 #define merge_64(r1,r2) ((((r2) & 0xffffffffUL) << 32) + ((r1) & 0xffffffffUL))
65 #endif
66
67 /*
68  * Revalidate the inode. This is required for proper NFS attribute caching.
69  */
70
71 int cp_compat_stat(struct kstat *stat, struct compat_stat __user *statbuf)
72 {
73         struct compat_stat tmp;
74
75         if (!new_valid_dev(stat->dev) || !new_valid_dev(stat->rdev))
76                 return -EOVERFLOW;
77
78         memset(&tmp, 0, sizeof(tmp));
79         tmp.st_dev = new_encode_dev(stat->dev);
80         tmp.st_ino = stat->ino;
81         if (sizeof(tmp.st_ino) < sizeof(stat->ino) && tmp.st_ino != stat->ino)
82                 return -EOVERFLOW;
83         tmp.st_mode = stat->mode;
84         tmp.st_nlink = stat->nlink;
85         SET_UID(tmp.st_uid, stat->uid);
86         SET_GID(tmp.st_gid, stat->gid);
87         tmp.st_rdev = new_encode_dev(stat->rdev);
88         tmp.st_size = stat->size;
89         tmp.st_atime = stat->atime.tv_sec;
90         tmp.st_mtime = stat->mtime.tv_sec;
91         tmp.st_ctime = stat->ctime.tv_sec;
92 #ifdef STAT_HAVE_NSEC
93         tmp.st_atime_nsec = stat->atime.tv_nsec;
94         tmp.st_mtime_nsec = stat->mtime.tv_nsec;
95         tmp.st_ctime_nsec = stat->ctime.tv_nsec;
96 #endif
97         tmp.st_blocks = stat->blocks;
98         tmp.st_blksize = stat->blksize;
99         return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0;
100 }
101
102 asmlinkage unsigned long
103 sys32_mmap2(unsigned long addr, unsigned long len, unsigned long prot,
104          unsigned long flags, unsigned long fd, unsigned long pgoff)
105 {
106         struct file * file = NULL;
107         unsigned long error;
108
109         error = -EINVAL;
110         if (pgoff & (~PAGE_MASK >> 12))
111                 goto out;
112         pgoff >>= PAGE_SHIFT-12;
113
114         if (!(flags & MAP_ANONYMOUS)) {
115                 error = -EBADF;
116                 file = fget(fd);
117                 if (!file)
118                         goto out;
119         }
120         flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE);
121
122         down_write(&current->mm->mmap_sem);
123         error = do_mmap_pgoff(file, addr, len, prot, flags, pgoff);
124         up_write(&current->mm->mmap_sem);
125         if (file)
126                 fput(file);
127
128 out:
129         return error;
130 }
131
132
133 asmlinkage int sys_truncate64(const char __user *path, unsigned int high,
134                               unsigned int low)
135 {
136         if ((int)high < 0)
137                 return -EINVAL;
138         return sys_truncate(path, ((long) high << 32) | low);
139 }
140
141 asmlinkage int sys_ftruncate64(unsigned int fd, unsigned int high,
142                                unsigned int low)
143 {
144         if ((int)high < 0)
145                 return -EINVAL;
146         return sys_ftruncate(fd, ((long) high << 32) | low);
147 }
148
149 /*
150  * sys_execve() executes a new program.
151  */
152 asmlinkage int sys32_execve(nabi_no_regargs struct pt_regs regs)
153 {
154         int error;
155         char * filename;
156
157         filename = getname(compat_ptr(regs.regs[4]));
158         error = PTR_ERR(filename);
159         if (IS_ERR(filename))
160                 goto out;
161         error = compat_do_execve(filename, compat_ptr(regs.regs[5]),
162                                  compat_ptr(regs.regs[6]), &regs);
163         putname(filename);
164
165 out:
166         return error;
167 }
168
169 asmlinkage long
170 sysn32_waitid(int which, compat_pid_t pid,
171               siginfo_t __user *uinfo, int options,
172               struct compat_rusage __user *uru)
173 {
174         struct rusage ru;
175         long ret;
176         mm_segment_t old_fs = get_fs();
177         int si_signo;
178
179         if (!access_ok(VERIFY_WRITE, uinfo, sizeof(*uinfo)))
180                 return -EFAULT;
181
182         set_fs (KERNEL_DS);
183         ret = sys_waitid(which, pid, uinfo, options,
184                          uru ? (struct rusage __user *) &ru : NULL);
185         set_fs (old_fs);
186
187         if (__get_user(si_signo, &uinfo->si_signo))
188                 return -EFAULT;
189         if (ret < 0 || si_signo == 0)
190                 return ret;
191
192         if (uru)
193                 ret = put_compat_rusage(&ru, uru);
194         return ret;
195 }
196
197 #define RLIM_INFINITY32 0x7fffffff
198 #define RESOURCE32(x) ((x > RLIM_INFINITY32) ? RLIM_INFINITY32 : x)
199
200 struct rlimit32 {
201         int     rlim_cur;
202         int     rlim_max;
203 };
204
205 #ifdef __MIPSEB__
206 asmlinkage long sys32_truncate64(const char __user * path, unsigned long __dummy,
207         int length_hi, int length_lo)
208 #endif
209 #ifdef __MIPSEL__
210 asmlinkage long sys32_truncate64(const char __user * path, unsigned long __dummy,
211         int length_lo, int length_hi)
212 #endif
213 {
214         loff_t length;
215
216         length = ((unsigned long) length_hi << 32) | (unsigned int) length_lo;
217
218         return sys_truncate(path, length);
219 }
220
221 #ifdef __MIPSEB__
222 asmlinkage long sys32_ftruncate64(unsigned int fd, unsigned long __dummy,
223         int length_hi, int length_lo)
224 #endif
225 #ifdef __MIPSEL__
226 asmlinkage long sys32_ftruncate64(unsigned int fd, unsigned long __dummy,
227         int length_lo, int length_hi)
228 #endif
229 {
230         loff_t length;
231
232         length = ((unsigned long) length_hi << 32) | (unsigned int) length_lo;
233
234         return sys_ftruncate(fd, length);
235 }
236
237 static inline long
238 get_tv32(struct timeval *o, struct compat_timeval __user *i)
239 {
240         return (!access_ok(VERIFY_READ, i, sizeof(*i)) ||
241                 (__get_user(o->tv_sec, &i->tv_sec) |
242                  __get_user(o->tv_usec, &i->tv_usec)));
243 }
244
245 static inline long
246 put_tv32(struct compat_timeval __user *o, struct timeval *i)
247 {
248         return (!access_ok(VERIFY_WRITE, o, sizeof(*o)) ||
249                 (__put_user(i->tv_sec, &o->tv_sec) |
250                  __put_user(i->tv_usec, &o->tv_usec)));
251 }
252
253 extern struct timezone sys_tz;
254
255 asmlinkage int
256 sys32_gettimeofday(struct compat_timeval __user *tv, struct timezone __user *tz)
257 {
258         if (tv) {
259                 struct timeval ktv;
260                 do_gettimeofday(&ktv);
261                 if (put_tv32(tv, &ktv))
262                         return -EFAULT;
263         }
264         if (tz) {
265                 if (copy_to_user(tz, &sys_tz, sizeof(sys_tz)))
266                         return -EFAULT;
267         }
268         return 0;
269 }
270
271 static inline long get_ts32(struct timespec *o, struct compat_timeval __user *i)
272 {
273         long usec;
274
275         if (!access_ok(VERIFY_READ, i, sizeof(*i)))
276                 return -EFAULT;
277         if (__get_user(o->tv_sec, &i->tv_sec))
278                 return -EFAULT;
279         if (__get_user(usec, &i->tv_usec))
280                 return -EFAULT;
281         o->tv_nsec = usec * 1000;
282                 return 0;
283 }
284
285 asmlinkage int
286 sys32_settimeofday(struct compat_timeval __user *tv, struct timezone __user *tz)
287 {
288         struct timespec kts;
289         struct timezone ktz;
290
291         if (tv) {
292                 if (get_ts32(&kts, tv))
293                         return -EFAULT;
294         }
295         if (tz) {
296                 if (copy_from_user(&ktz, tz, sizeof(ktz)))
297                         return -EFAULT;
298         }
299
300         return do_sys_settimeofday(tv ? &kts : NULL, tz ? &ktz : NULL);
301 }
302
303 asmlinkage int sys32_llseek(unsigned int fd, unsigned int offset_high,
304                             unsigned int offset_low, loff_t __user * result,
305                             unsigned int origin)
306 {
307         return sys_llseek(fd, offset_high, offset_low, result, origin);
308 }
309
310 /* From the Single Unix Spec: pread & pwrite act like lseek to pos + op +
311    lseek back to original location.  They fail just like lseek does on
312    non-seekable files.  */
313
314 asmlinkage ssize_t sys32_pread(unsigned int fd, char __user * buf,
315                                size_t count, u32 unused, u64 a4, u64 a5)
316 {
317         return sys_pread64(fd, buf, count, merge_64(a4, a5));
318 }
319
320 asmlinkage ssize_t sys32_pwrite(unsigned int fd, const char __user * buf,
321                                 size_t count, u32 unused, u64 a4, u64 a5)
322 {
323         return sys_pwrite64(fd, buf, count, merge_64(a4, a5));
324 }
325
326 asmlinkage int sys32_sched_rr_get_interval(compat_pid_t pid,
327         struct compat_timespec __user *interval)
328 {
329         struct timespec t;
330         int ret;
331         mm_segment_t old_fs = get_fs ();
332
333         set_fs (KERNEL_DS);
334         ret = sys_sched_rr_get_interval(pid, (struct timespec __user *)&t);
335         set_fs (old_fs);
336         if (put_user (t.tv_sec, &interval->tv_sec) ||
337             __put_user (t.tv_nsec, &interval->tv_nsec))
338                 return -EFAULT;
339         return ret;
340 }
341
342 asmlinkage long
343 sys32_ipc (u32 call, int first, int second, int third, u32 ptr, u32 fifth)
344 {
345         int version, err;
346
347         version = call >> 16; /* hack for backward compatibility */
348         call &= 0xffff;
349
350         switch (call) {
351         case SEMOP:
352                 /* struct sembuf is the same on 32 and 64bit :)) */
353                 err = sys_semtimedop(first, compat_ptr(ptr), second, NULL);
354                 break;
355         case SEMTIMEDOP:
356                 err = compat_sys_semtimedop(first, compat_ptr(ptr), second,
357                                             compat_ptr(fifth));
358                 break;
359         case SEMGET:
360                 err = sys_semget(first, second, third);
361                 break;
362         case SEMCTL:
363                 err = compat_sys_semctl(first, second, third, compat_ptr(ptr));
364                 break;
365         case MSGSND:
366                 err = compat_sys_msgsnd(first, second, third, compat_ptr(ptr));
367                 break;
368         case MSGRCV:
369                 err = compat_sys_msgrcv(first, second, fifth, third,
370                                         version, compat_ptr(ptr));
371                 break;
372         case MSGGET:
373                 err = sys_msgget((key_t) first, second);
374                 break;
375         case MSGCTL:
376                 err = compat_sys_msgctl(first, second, compat_ptr(ptr));
377                 break;
378         case SHMAT:
379                 err = compat_sys_shmat(first, second, third, version,
380                                        compat_ptr(ptr));
381                 break;
382         case SHMDT:
383                 err = sys_shmdt(compat_ptr(ptr));
384                 break;
385         case SHMGET:
386                 err = sys_shmget(first, (unsigned)second, third);
387                 break;
388         case SHMCTL:
389                 err = compat_sys_shmctl(first, second, compat_ptr(ptr));
390                 break;
391         default:
392                 err = -EINVAL;
393                 break;
394         }
395
396         return err;
397 }
398
399 #ifdef CONFIG_MIPS32_N32
400 asmlinkage long sysn32_semctl(int semid, int semnum, int cmd, u32 arg)
401 {
402         /* compat_sys_semctl expects a pointer to union semun */
403         u32 __user *uptr = compat_alloc_user_space(sizeof(u32));
404         if (put_user(arg, uptr))
405                 return -EFAULT;
406         return compat_sys_semctl(semid, semnum, cmd, uptr);
407 }
408
409 asmlinkage long sysn32_msgsnd(int msqid, u32 msgp, unsigned msgsz, int msgflg)
410 {
411         return compat_sys_msgsnd(msqid, msgsz, msgflg, compat_ptr(msgp));
412 }
413
414 asmlinkage long sysn32_msgrcv(int msqid, u32 msgp, size_t msgsz, int msgtyp,
415                               int msgflg)
416 {
417         return compat_sys_msgrcv(msqid, msgsz, msgtyp, msgflg, IPC_64,
418                                  compat_ptr(msgp));
419 }
420 #endif
421
422 struct sysctl_args32
423 {
424         compat_caddr_t name;
425         int nlen;
426         compat_caddr_t oldval;
427         compat_caddr_t oldlenp;
428         compat_caddr_t newval;
429         compat_size_t newlen;
430         unsigned int __unused[4];
431 };
432
433 #ifdef CONFIG_SYSCTL_SYSCALL
434
435 asmlinkage long sys32_sysctl(struct sysctl_args32 __user *args)
436 {
437         struct sysctl_args32 tmp;
438         int error;
439         size_t oldlen;
440         size_t __user *oldlenp = NULL;
441         unsigned long addr = (((unsigned long)&args->__unused[0]) + 7) & ~7;
442
443         if (copy_from_user(&tmp, args, sizeof(tmp)))
444                 return -EFAULT;
445
446         if (tmp.oldval && tmp.oldlenp) {
447                 /* Duh, this is ugly and might not work if sysctl_args
448                    is in read-only memory, but do_sysctl does indirectly
449                    a lot of uaccess in both directions and we'd have to
450                    basically copy the whole sysctl.c here, and
451                    glibc's __sysctl uses rw memory for the structure
452                    anyway.  */
453                 if (get_user(oldlen, (u32 __user *)A(tmp.oldlenp)) ||
454                     put_user(oldlen, (size_t __user *)addr))
455                         return -EFAULT;
456                 oldlenp = (size_t __user *)addr;
457         }
458
459         lock_kernel();
460         error = do_sysctl((int __user *)A(tmp.name), tmp.nlen, (void __user *)A(tmp.oldval),
461                           oldlenp, (void __user *)A(tmp.newval), tmp.newlen);
462         unlock_kernel();
463         if (oldlenp) {
464                 if (!error) {
465                         if (get_user(oldlen, (size_t __user *)addr) ||
466                             put_user(oldlen, (u32 __user *)A(tmp.oldlenp)))
467                                 error = -EFAULT;
468                 }
469                 copy_to_user(args->__unused, tmp.__unused, sizeof(tmp.__unused));
470         }
471         return error;
472 }
473
474 #endif /* CONFIG_SYSCTL_SYSCALL */
475
476 asmlinkage long sys32_newuname(struct new_utsname __user * name)
477 {
478         int ret = 0;
479
480         down_read(&uts_sem);
481         if (copy_to_user(name, utsname(), sizeof *name))
482                 ret = -EFAULT;
483         up_read(&uts_sem);
484
485         if (current->personality == PER_LINUX32 && !ret)
486                 if (copy_to_user(name->machine, "mips\0\0\0", 8))
487                         ret = -EFAULT;
488
489         return ret;
490 }
491
492 asmlinkage int sys32_personality(unsigned long personality)
493 {
494         int ret;
495         personality &= 0xffffffff;
496         if (personality(current->personality) == PER_LINUX32 &&
497             personality == PER_LINUX)
498                 personality = PER_LINUX32;
499         ret = sys_personality(personality);
500         if (ret == PER_LINUX32)
501                 ret = PER_LINUX;
502         return ret;
503 }
504
505 /* ustat compatibility */
506 struct ustat32 {
507         compat_daddr_t  f_tfree;
508         compat_ino_t    f_tinode;
509         char            f_fname[6];
510         char            f_fpack[6];
511 };
512
513 extern asmlinkage long sys_ustat(dev_t dev, struct ustat __user * ubuf);
514
515 asmlinkage int sys32_ustat(dev_t dev, struct ustat32 __user * ubuf32)
516 {
517         int err;
518         struct ustat tmp;
519         struct ustat32 tmp32;
520         mm_segment_t old_fs = get_fs();
521
522         set_fs(KERNEL_DS);
523         err = sys_ustat(dev, (struct ustat __user *)&tmp);
524         set_fs (old_fs);
525
526         if (err)
527                 goto out;
528
529         memset(&tmp32,0,sizeof(struct ustat32));
530         tmp32.f_tfree = tmp.f_tfree;
531         tmp32.f_tinode = tmp.f_tinode;
532
533         err = copy_to_user(ubuf32,&tmp32,sizeof(struct ustat32)) ? -EFAULT : 0;
534
535 out:
536         return err;
537 }
538
539 asmlinkage int sys32_sendfile(int out_fd, int in_fd, compat_off_t __user *offset,
540         s32 count)
541 {
542         mm_segment_t old_fs = get_fs();
543         int ret;
544         off_t of;
545
546         if (offset && get_user(of, offset))
547                 return -EFAULT;
548
549         set_fs(KERNEL_DS);
550         ret = sys_sendfile(out_fd, in_fd, offset ? (off_t __user *)&of : NULL, count);
551         set_fs(old_fs);
552
553         if (offset && put_user(of, offset))
554                 return -EFAULT;
555
556         return ret;
557 }
558
559 asmlinkage ssize_t sys32_readahead(int fd, u32 pad0, u64 a2, u64 a3,
560                                    size_t count)
561 {
562         return sys_readahead(fd, merge_64(a2, a3), count);
563 }
564
565 asmlinkage long sys32_sync_file_range(int fd, int __pad,
566         unsigned long a2, unsigned long a3,
567         unsigned long a4, unsigned long a5,
568         int flags)
569 {
570         return sys_sync_file_range(fd,
571                         merge_64(a2, a3), merge_64(a4, a5),
572                         flags);
573 }
574
575 /* Argument list sizes for sys_socketcall */
576 #define AL(x) ((x) * sizeof(unsigned int))
577 static unsigned char socketcall_nargs[18]={AL(0),AL(3),AL(3),AL(3),AL(2),AL(3),
578                                 AL(3),AL(3),AL(4),AL(4),AL(4),AL(6),
579                                 AL(6),AL(2),AL(5),AL(5),AL(3),AL(3)};
580 #undef AL
581
582 /*
583  *      System call vectors.
584  *
585  *      Argument checking cleaned up. Saved 20% in size.
586  *  This function doesn't need to set the kernel lock because
587  *  it is set by the callees.
588  */
589
590 asmlinkage long sys32_socketcall(int call, unsigned int __user *args32)
591 {
592         unsigned int a[6];
593         unsigned int a0,a1;
594         int err;
595
596         extern asmlinkage long sys_socket(int family, int type, int protocol);
597         extern asmlinkage long sys_bind(int fd, struct sockaddr __user *umyaddr, int addrlen);
598         extern asmlinkage long sys_connect(int fd, struct sockaddr __user *uservaddr, int addrlen);
599         extern asmlinkage long sys_listen(int fd, int backlog);
600         extern asmlinkage long sys_accept(int fd, struct sockaddr __user *upeer_sockaddr, int __user *upeer_addrlen);
601         extern asmlinkage long sys_getsockname(int fd, struct sockaddr __user *usockaddr, int __user *usockaddr_len);
602         extern asmlinkage long sys_getpeername(int fd, struct sockaddr __user *usockaddr, int __user *usockaddr_len);
603         extern asmlinkage long sys_socketpair(int family, int type, int protocol, int __user *usockvec);
604         extern asmlinkage long sys_send(int fd, void __user * buff, size_t len, unsigned flags);
605         extern asmlinkage long sys_sendto(int fd, void __user * buff, size_t len, unsigned flags,
606                                           struct sockaddr __user *addr, int addr_len);
607         extern asmlinkage long sys_recv(int fd, void __user * ubuf, size_t size, unsigned flags);
608         extern asmlinkage long sys_recvfrom(int fd, void __user * ubuf, size_t size, unsigned flags,
609                                             struct sockaddr __user *addr, int __user *addr_len);
610         extern asmlinkage long sys_shutdown(int fd, int how);
611         extern asmlinkage long sys_setsockopt(int fd, int level, int optname, char __user *optval, int optlen);
612         extern asmlinkage long sys_getsockopt(int fd, int level, int optname, char __user *optval, int __user *optlen);
613         extern asmlinkage long sys_sendmsg(int fd, struct msghdr __user *msg, unsigned flags);
614         extern asmlinkage long sys_recvmsg(int fd, struct msghdr __user *msg, unsigned int flags);
615
616
617         if(call<1||call>SYS_RECVMSG)
618                 return -EINVAL;
619
620         /* copy_from_user should be SMP safe. */
621         if (copy_from_user(a, args32, socketcall_nargs[call]))
622                 return -EFAULT;
623
624         a0=a[0];
625         a1=a[1];
626
627         switch(call)
628         {
629                 case SYS_SOCKET:
630                         err = sys_socket(a0,a1,a[2]);
631                         break;
632                 case SYS_BIND:
633                         err = sys_bind(a0,(struct sockaddr __user *)A(a1), a[2]);
634                         break;
635                 case SYS_CONNECT:
636                         err = sys_connect(a0, (struct sockaddr __user *)A(a1), a[2]);
637                         break;
638                 case SYS_LISTEN:
639                         err = sys_listen(a0,a1);
640                         break;
641                 case SYS_ACCEPT:
642                         err = sys_accept(a0,(struct sockaddr __user *)A(a1), (int __user *)A(a[2]));
643                         break;
644                 case SYS_GETSOCKNAME:
645                         err = sys_getsockname(a0,(struct sockaddr __user *)A(a1), (int __user *)A(a[2]));
646                         break;
647                 case SYS_GETPEERNAME:
648                         err = sys_getpeername(a0, (struct sockaddr __user *)A(a1), (int __user *)A(a[2]));
649                         break;
650                 case SYS_SOCKETPAIR:
651                         err = sys_socketpair(a0,a1, a[2], (int __user *)A(a[3]));
652                         break;
653                 case SYS_SEND:
654                         err = sys_send(a0, (void __user *)A(a1), a[2], a[3]);
655                         break;
656                 case SYS_SENDTO:
657                         err = sys_sendto(a0,(void __user *)A(a1), a[2], a[3],
658                                          (struct sockaddr __user *)A(a[4]), a[5]);
659                         break;
660                 case SYS_RECV:
661                         err = sys_recv(a0, (void __user *)A(a1), a[2], a[3]);
662                         break;
663                 case SYS_RECVFROM:
664                         err = sys_recvfrom(a0, (void __user *)A(a1), a[2], a[3],
665                                            (struct sockaddr __user *)A(a[4]), (int __user *)A(a[5]));
666                         break;
667                 case SYS_SHUTDOWN:
668                         err = sys_shutdown(a0,a1);
669                         break;
670                 case SYS_SETSOCKOPT:
671                         err = sys_setsockopt(a0, a1, a[2], (char __user *)A(a[3]), a[4]);
672                         break;
673                 case SYS_GETSOCKOPT:
674                         err = sys_getsockopt(a0, a1, a[2], (char __user *)A(a[3]), (int __user *)A(a[4]));
675                         break;
676                 case SYS_SENDMSG:
677                         err = sys_sendmsg(a0, (struct msghdr __user *) A(a1), a[2]);
678                         break;
679                 case SYS_RECVMSG:
680                         err = sys_recvmsg(a0, (struct msghdr __user *) A(a1), a[2]);
681                         break;
682                 default:
683                         err = -EINVAL;
684                         break;
685         }
686         return err;
687 }
688
689 struct sigevent32 {
690         u32 sigev_value;
691         u32 sigev_signo;
692         u32 sigev_notify;
693         u32 payload[(64 / 4) - 3];
694 };
695
696 extern asmlinkage long
697 sys_timer_create(clockid_t which_clock,
698                  struct sigevent __user *timer_event_spec,
699                  timer_t __user * created_timer_id);
700
701 long
702 sys32_timer_create(u32 clock, struct sigevent32 __user *se32, timer_t __user *timer_id)
703 {
704         struct sigevent __user *p = NULL;
705         if (se32) {
706                 struct sigevent se;
707                 p = compat_alloc_user_space(sizeof(struct sigevent));
708                 memset(&se, 0, sizeof(struct sigevent));
709                 if (get_user(se.sigev_value.sival_int,  &se32->sigev_value) ||
710                     __get_user(se.sigev_signo, &se32->sigev_signo) ||
711                     __get_user(se.sigev_notify, &se32->sigev_notify) ||
712                     __copy_from_user(&se._sigev_un._pad, &se32->payload,
713                                      sizeof(se32->payload)) ||
714                     copy_to_user(p, &se, sizeof(se)))
715                         return -EFAULT;
716         }
717         return sys_timer_create(clock, p, timer_id);
718 }
719
720 save_static_function(sys32_clone);
721 __attribute_used__ noinline static int
722 _sys32_clone(nabi_no_regargs struct pt_regs regs)
723 {
724         unsigned long clone_flags;
725         unsigned long newsp;
726         int __user *parent_tidptr, *child_tidptr;
727
728         clone_flags = regs.regs[4];
729         newsp = regs.regs[5];
730         if (!newsp)
731                 newsp = regs.regs[29];
732         parent_tidptr = (int __user *) regs.regs[6];
733
734         /* Use __dummy4 instead of getting it off the stack, so that
735            syscall() works.  */
736         child_tidptr = (int __user *) __dummy4;
737         return do_fork(clone_flags, newsp, &regs, 0,
738                        parent_tidptr, child_tidptr);
739 }
740
741 /*
742  * Implement the event wait interface for the eventpoll file. It is the kernel
743  * part of the user space epoll_pwait(2).
744  */
745 asmlinkage long compat_sys_epoll_pwait(int epfd,
746         struct epoll_event __user *events, int maxevents, int timeout,
747         const compat_sigset_t __user *sigmask, size_t sigsetsize)
748 {
749         int error;
750         sigset_t ksigmask, sigsaved;
751
752         /*
753          * If the caller wants a certain signal mask to be set during the wait,
754          * we apply it here.
755          */
756         if (sigmask) {
757                 if (sigsetsize != sizeof(sigset_t))
758                         return -EINVAL;
759                 if (!access_ok(VERIFY_READ, sigmask, sizeof(ksigmask)))
760                         return -EFAULT;
761                 if (__copy_conv_sigset_from_user(&ksigmask, sigmask))
762                         return -EFAULT;
763                 sigdelsetmask(&ksigmask, sigmask(SIGKILL) | sigmask(SIGSTOP));
764                 sigprocmask(SIG_SETMASK, &ksigmask, &sigsaved);
765         }
766
767         error = sys_epoll_wait(epfd, events, maxevents, timeout);
768
769         /*
770          * If we changed the signal mask, we need to restore the original one.
771          * In case we've got a signal while waiting, we do not restore the
772          * signal mask yet, and we allow do_signal() to deliver the signal on
773          * the way back to userspace, before the signal mask is restored.
774          */
775         if (sigmask) {
776                 if (error == -EINTR) {
777                         memcpy(&current->saved_sigmask, &sigsaved,
778                                 sizeof(sigsaved));
779                         set_thread_flag(TIF_RESTORE_SIGMASK);
780                 } else
781                         sigprocmask(SIG_SETMASK, &sigsaved, NULL);
782         }
783
784         return error;
785 }