b74869803081900be006855604f941664a46d157
[linux-3.10.git] / arch / parisc / kernel / sys_parisc32.c
1 /*
2  * sys_parisc32.c: Conversion between 32bit and 64bit native syscalls.
3  *
4  * Copyright (C) 2000-2001 Hewlett Packard Company
5  * Copyright (C) 2000 John Marvin
6  * Copyright (C) 2001 Matthew Wilcox
7  *
8  * These routines maintain argument size conversion between 32bit and 64bit
9  * environment. Based heavily on sys_ia32.c and sys_sparc32.c.
10  */
11
12 #include <linux/compat.h>
13 #include <linux/kernel.h>
14 #include <linux/sched.h>
15 #include <linux/fs.h> 
16 #include <linux/mm.h> 
17 #include <linux/file.h> 
18 #include <linux/signal.h>
19 #include <linux/resource.h>
20 #include <linux/times.h>
21 #include <linux/utsname.h>
22 #include <linux/time.h>
23 #include <linux/smp.h>
24 #include <linux/smp_lock.h>
25 #include <linux/sem.h>
26 #include <linux/msg.h>
27 #include <linux/shm.h>
28 #include <linux/slab.h>
29 #include <linux/uio.h>
30 #include <linux/nfs_fs.h>
31 #include <linux/ncp_fs.h>
32 #include <linux/sunrpc/svc.h>
33 #include <linux/nfsd/nfsd.h>
34 #include <linux/nfsd/cache.h>
35 #include <linux/nfsd/xdr.h>
36 #include <linux/nfsd/syscall.h>
37 #include <linux/poll.h>
38 #include <linux/personality.h>
39 #include <linux/stat.h>
40 #include <linux/highmem.h>
41 #include <linux/highuid.h>
42 #include <linux/mman.h>
43 #include <linux/binfmts.h>
44 #include <linux/namei.h>
45 #include <linux/vfs.h>
46 #include <linux/ptrace.h>
47 #include <linux/swap.h>
48 #include <linux/syscalls.h>
49
50 #include <asm/types.h>
51 #include <asm/uaccess.h>
52 #include <asm/semaphore.h>
53 #include <asm/mmu_context.h>
54
55 #include "sys32.h"
56
57 #undef DEBUG
58
59 #ifdef DEBUG
60 #define DBG(x)  printk x
61 #else
62 #define DBG(x)
63 #endif
64
65 /*
66  * sys32_execve() executes a new program.
67  */
68
69 asmlinkage int sys32_execve(struct pt_regs *regs)
70 {
71         int error;
72         char *filename;
73
74         DBG(("sys32_execve(%p) r26 = 0x%lx\n", regs, regs->gr[26]));
75         filename = getname((const char __user *) regs->gr[26]);
76         error = PTR_ERR(filename);
77         if (IS_ERR(filename))
78                 goto out;
79         error = compat_do_execve(filename, compat_ptr(regs->gr[25]),
80                                  compat_ptr(regs->gr[24]), regs);
81         if (error == 0) {
82                 task_lock(current);
83                 current->ptrace &= ~PT_DTRACE;
84                 task_unlock(current);
85         }
86         putname(filename);
87 out:
88
89         return error;
90 }
91
92 asmlinkage long sys32_unimplemented(int r26, int r25, int r24, int r23,
93         int r22, int r21, int r20)
94 {
95     printk(KERN_ERR "%s(%d): Unimplemented 32 on 64 syscall #%d!\n", 
96         current->comm, current->pid, r20);
97     return -ENOSYS;
98 }
99
100 #ifdef CONFIG_SYSCTL
101
102 struct __sysctl_args32 {
103         u32 name;
104         int nlen;
105         u32 oldval;
106         u32 oldlenp;
107         u32 newval;
108         u32 newlen;
109         u32 __unused[4];
110 };
111
112 asmlinkage long sys32_sysctl(struct __sysctl_args32 __user *args)
113 {
114         struct __sysctl_args32 tmp;
115         int error;
116         unsigned int oldlen32;
117         size_t oldlen, *oldlenp = NULL;
118         unsigned long addr = (((long __force)&args->__unused[0]) + 7) & ~7;
119         extern int do_sysctl(int *name, int nlen, void *oldval, size_t *oldlenp,
120                void *newval, size_t newlen);
121
122         DBG(("sysctl32(%p)\n", args));
123
124         if (copy_from_user(&tmp, args, sizeof(tmp)))
125                 return -EFAULT;
126
127         if (tmp.oldval && tmp.oldlenp) {
128                 /* Duh, this is ugly and might not work if sysctl_args
129                    is in read-only memory, but do_sysctl does indirectly
130                    a lot of uaccess in both directions and we'd have to
131                    basically copy the whole sysctl.c here, and
132                    glibc's __sysctl uses rw memory for the structure
133                    anyway.  */
134                 /* a possibly better hack than this, which will avoid the
135                  * problem if the struct is read only, is to push the
136                  * 'oldlen' value out to the user's stack instead. -PB
137                  */
138                 if (get_user(oldlen32, (u32 *)(u64)tmp.oldlenp))
139                         return -EFAULT;
140                 oldlen = oldlen32;
141                 if (put_user(oldlen, (size_t *)addr))
142                         return -EFAULT;
143                 oldlenp = (size_t *)addr;
144         }
145
146         lock_kernel();
147         error = do_sysctl((int *)(u64)tmp.name, tmp.nlen, (void *)(u64)tmp.oldval,
148                           oldlenp, (void *)(u64)tmp.newval, tmp.newlen);
149         unlock_kernel();
150         if (oldlenp) {
151                 if (!error) {
152                         if (get_user(oldlen, (size_t *)addr)) {
153                                 error = -EFAULT;
154                         } else {
155                                 oldlen32 = oldlen;
156                                 if (put_user(oldlen32, (u32 *)(u64)tmp.oldlenp))
157                                         error = -EFAULT;
158                         }
159                 }
160                 if (copy_to_user(&args->__unused[0], tmp.__unused, sizeof(tmp.__unused)))
161                         error = -EFAULT;
162         }
163         return error;
164 }
165
166 #endif /* CONFIG_SYSCTL */
167
168 asmlinkage long sys32_sched_rr_get_interval(pid_t pid,
169         struct compat_timespec __user *interval)
170 {
171         struct timespec t;
172         int ret;
173
174         KERNEL_SYSCALL(ret, sys_sched_rr_get_interval, pid, (struct timespec __user *)&t);
175         if (put_compat_timespec(&t, interval))
176                 return -EFAULT;
177         return ret;
178 }
179
180 static int
181 put_compat_timeval(struct compat_timeval __user *u, struct timeval *t)
182 {
183         struct compat_timeval t32;
184         t32.tv_sec = t->tv_sec;
185         t32.tv_usec = t->tv_usec;
186         return copy_to_user(u, &t32, sizeof t32);
187 }
188
189 static inline long get_ts32(struct timespec *o, struct compat_timeval __user *i)
190 {
191         long usec;
192
193         if (__get_user(o->tv_sec, &i->tv_sec))
194                 return -EFAULT;
195         if (__get_user(usec, &i->tv_usec))
196                 return -EFAULT;
197         o->tv_nsec = usec * 1000;
198         return 0;
199 }
200
201 asmlinkage int
202 sys32_gettimeofday(struct compat_timeval __user *tv, struct timezone __user *tz)
203 {
204     extern void do_gettimeofday(struct timeval *tv);
205
206     if (tv) {
207             struct timeval ktv;
208             do_gettimeofday(&ktv);
209             if (put_compat_timeval(tv, &ktv))
210                     return -EFAULT;
211     }
212     if (tz) {
213             extern struct timezone sys_tz;
214             if (copy_to_user(tz, &sys_tz, sizeof(sys_tz)))
215                     return -EFAULT;
216     }
217     return 0;
218 }
219
220 asmlinkage 
221 int sys32_settimeofday(struct compat_timeval __user *tv, struct timezone __user *tz)
222 {
223         struct timespec kts;
224         struct timezone ktz;
225
226         if (tv) {
227                 if (get_ts32(&kts, tv))
228                         return -EFAULT;
229         }
230         if (tz) {
231                 if (copy_from_user(&ktz, tz, sizeof(ktz)))
232                         return -EFAULT;
233         }
234
235         return do_sys_settimeofday(tv ? &kts : NULL, tz ? &ktz : NULL);
236 }
237
238 int cp_compat_stat(struct kstat *stat, struct compat_stat __user *statbuf)
239 {
240         int err;
241
242         if (stat->size > MAX_NON_LFS || !new_valid_dev(stat->dev) ||
243             !new_valid_dev(stat->rdev))
244                 return -EOVERFLOW;
245
246         err  = put_user(new_encode_dev(stat->dev), &statbuf->st_dev);
247         err |= put_user(stat->ino, &statbuf->st_ino);
248         err |= put_user(stat->mode, &statbuf->st_mode);
249         err |= put_user(stat->nlink, &statbuf->st_nlink);
250         err |= put_user(0, &statbuf->st_reserved1);
251         err |= put_user(0, &statbuf->st_reserved2);
252         err |= put_user(new_encode_dev(stat->rdev), &statbuf->st_rdev);
253         err |= put_user(stat->size, &statbuf->st_size);
254         err |= put_user(stat->atime.tv_sec, &statbuf->st_atime);
255         err |= put_user(stat->atime.tv_nsec, &statbuf->st_atime_nsec);
256         err |= put_user(stat->mtime.tv_sec, &statbuf->st_mtime);
257         err |= put_user(stat->mtime.tv_nsec, &statbuf->st_mtime_nsec);
258         err |= put_user(stat->ctime.tv_sec, &statbuf->st_ctime);
259         err |= put_user(stat->ctime.tv_nsec, &statbuf->st_ctime_nsec);
260         err |= put_user(stat->blksize, &statbuf->st_blksize);
261         err |= put_user(stat->blocks, &statbuf->st_blocks);
262         err |= put_user(0, &statbuf->__unused1);
263         err |= put_user(0, &statbuf->__unused2);
264         err |= put_user(0, &statbuf->__unused3);
265         err |= put_user(0, &statbuf->__unused4);
266         err |= put_user(0, &statbuf->__unused5);
267         err |= put_user(0, &statbuf->st_fstype); /* not avail */
268         err |= put_user(0, &statbuf->st_realdev); /* not avail */
269         err |= put_user(0, &statbuf->st_basemode); /* not avail */
270         err |= put_user(0, &statbuf->st_spareshort);
271         err |= put_user(stat->uid, &statbuf->st_uid);
272         err |= put_user(stat->gid, &statbuf->st_gid);
273         err |= put_user(0, &statbuf->st_spare4[0]);
274         err |= put_user(0, &statbuf->st_spare4[1]);
275         err |= put_user(0, &statbuf->st_spare4[2]);
276
277         return err;
278 }
279
280 struct linux32_dirent {
281         u32             d_ino;
282         compat_off_t    d_off;
283         u16             d_reclen;
284         char            d_name[1];
285 };
286
287 struct old_linux32_dirent {
288         u32     d_ino;
289         u32     d_offset;
290         u16     d_namlen;
291         char    d_name[1];
292 };
293
294 struct getdents32_callback {
295         struct linux32_dirent __user * current_dir;
296         struct linux32_dirent __user * previous;
297         int count;
298         int error;
299 };
300
301 struct readdir32_callback {
302         struct old_linux32_dirent __user * dirent;
303         int count;
304 };
305
306 #define ROUND_UP(x,a)   ((__typeof__(x))(((unsigned long)(x) + ((a) - 1)) & ~((a) - 1)))
307 #define NAME_OFFSET(de) ((int) ((de)->d_name - (char __user *) (de)))
308 static int
309 filldir32 (void *__buf, const char *name, int namlen, loff_t offset, ino_t ino,
310            unsigned int d_type)
311 {
312         struct linux32_dirent __user * dirent;
313         struct getdents32_callback * buf = (struct getdents32_callback *) __buf;
314         int reclen = ROUND_UP(NAME_OFFSET(dirent) + namlen + 1, 4);
315
316         buf->error = -EINVAL;   /* only used if we fail.. */
317         if (reclen > buf->count)
318                 return -EINVAL;
319         dirent = buf->previous;
320         if (dirent)
321                 put_user(offset, &dirent->d_off);
322         dirent = buf->current_dir;
323         buf->previous = dirent;
324         put_user(ino, &dirent->d_ino);
325         put_user(reclen, &dirent->d_reclen);
326         copy_to_user(dirent->d_name, name, namlen);
327         put_user(0, dirent->d_name + namlen);
328         dirent = ((void __user *)dirent) + reclen;
329         buf->current_dir = dirent;
330         buf->count -= reclen;
331         return 0;
332 }
333
334 asmlinkage long
335 sys32_getdents (unsigned int fd, void __user * dirent, unsigned int count)
336 {
337         struct file * file;
338         struct linux32_dirent __user * lastdirent;
339         struct getdents32_callback buf;
340         int error;
341
342         error = -EBADF;
343         file = fget(fd);
344         if (!file)
345                 goto out;
346
347         buf.current_dir = (struct linux32_dirent __user *) dirent;
348         buf.previous = NULL;
349         buf.count = count;
350         buf.error = 0;
351
352         error = vfs_readdir(file, filldir32, &buf);
353         if (error < 0)
354                 goto out_putf;
355         error = buf.error;
356         lastdirent = buf.previous;
357         if (lastdirent) {
358                 put_user(file->f_pos, &lastdirent->d_off);
359                 error = count - buf.count;
360         }
361
362 out_putf:
363         fput(file);
364 out:
365         return error;
366 }
367
368 static int
369 fillonedir32 (void * __buf, const char * name, int namlen, loff_t offset, ino_t ino,
370               unsigned int d_type)
371 {
372         struct readdir32_callback * buf = (struct readdir32_callback *) __buf;
373         struct old_linux32_dirent __user * dirent;
374
375         if (buf->count)
376                 return -EINVAL;
377         buf->count++;
378         dirent = buf->dirent;
379         put_user(ino, &dirent->d_ino);
380         put_user(offset, &dirent->d_offset);
381         put_user(namlen, &dirent->d_namlen);
382         copy_to_user(dirent->d_name, name, namlen);
383         put_user(0, dirent->d_name + namlen);
384         return 0;
385 }
386
387 asmlinkage long
388 sys32_readdir (unsigned int fd, void __user * dirent, unsigned int count)
389 {
390         int error;
391         struct file * file;
392         struct readdir32_callback buf;
393
394         error = -EBADF;
395         file = fget(fd);
396         if (!file)
397                 goto out;
398
399         buf.count = 0;
400         buf.dirent = dirent;
401
402         error = vfs_readdir(file, fillonedir32, &buf);
403         if (error >= 0)
404                 error = buf.count;
405         fput(file);
406 out:
407         return error;
408 }
409
410 /*** copied from mips64 ***/
411 /*
412  * Ooo, nasty.  We need here to frob 32-bit unsigned longs to
413  * 64-bit unsigned longs.
414  */
415
416 static inline int
417 get_fd_set32(unsigned long n, u32 *ufdset, unsigned long *fdset)
418 {
419         n = (n + 8*sizeof(u32) - 1) / (8*sizeof(u32));
420         if (ufdset) {
421                 unsigned long odd;
422
423                 if (!access_ok(VERIFY_WRITE, ufdset, n*sizeof(u32)))
424                         return -EFAULT;
425
426                 odd = n & 1UL;
427                 n &= ~1UL;
428                 while (n) {
429                         unsigned long h, l;
430                         __get_user(l, ufdset);
431                         __get_user(h, ufdset+1);
432                         ufdset += 2;
433                         *fdset++ = h << 32 | l;
434                         n -= 2;
435                 }
436                 if (odd)
437                         __get_user(*fdset, ufdset);
438         } else {
439                 /* Tricky, must clear full unsigned long in the
440                  * kernel fdset at the end, this makes sure that
441                  * actually happens.
442                  */
443                 memset(fdset, 0, ((n + 1) & ~1)*sizeof(u32));
444         }
445         return 0;
446 }
447
448 static inline void
449 set_fd_set32(unsigned long n, u32 *ufdset, unsigned long *fdset)
450 {
451         unsigned long odd;
452         n = (n + 8*sizeof(u32) - 1) / (8*sizeof(u32));
453
454         if (!ufdset)
455                 return;
456
457         odd = n & 1UL;
458         n &= ~1UL;
459         while (n) {
460                 unsigned long h, l;
461                 l = *fdset++;
462                 h = l >> 32;
463                 __put_user(l, ufdset);
464                 __put_user(h, ufdset+1);
465                 ufdset += 2;
466                 n -= 2;
467         }
468         if (odd)
469                 __put_user(*fdset, ufdset);
470 }
471
472 struct msgbuf32 {
473     int mtype;
474     char mtext[1];
475 };
476
477 asmlinkage long sys32_msgsnd(int msqid,
478                                 struct msgbuf32 __user *umsgp32,
479                                 size_t msgsz, int msgflg)
480 {
481         struct msgbuf *mb;
482         struct msgbuf32 mb32;
483         int err;
484
485         if ((mb = kmalloc(msgsz + sizeof *mb + 4, GFP_KERNEL)) == NULL)
486                 return -ENOMEM;
487
488         err = get_user(mb32.mtype, &umsgp32->mtype);
489         mb->mtype = mb32.mtype;
490         err |= copy_from_user(mb->mtext, &umsgp32->mtext, msgsz);
491
492         if (err)
493                 err = -EFAULT;
494         else
495                 KERNEL_SYSCALL(err, sys_msgsnd, msqid, (struct msgbuf __user *)mb, msgsz, msgflg);
496
497         kfree(mb);
498         return err;
499 }
500
501 asmlinkage long sys32_msgrcv(int msqid,
502                                 struct msgbuf32 __user *umsgp32,
503                                 size_t msgsz, long msgtyp, int msgflg)
504 {
505         struct msgbuf *mb;
506         struct msgbuf32 mb32;
507         int err, len;
508
509         if ((mb = kmalloc(msgsz + sizeof *mb + 4, GFP_KERNEL)) == NULL)
510                 return -ENOMEM;
511
512         KERNEL_SYSCALL(err, sys_msgrcv, msqid, (struct msgbuf __user *)mb, msgsz, msgtyp, msgflg);
513
514         if (err >= 0) {
515                 len = err;
516                 mb32.mtype = mb->mtype;
517                 err = put_user(mb32.mtype, &umsgp32->mtype);
518                 err |= copy_to_user(&umsgp32->mtext, mb->mtext, len);
519                 if (err)
520                         err = -EFAULT;
521                 else
522                         err = len;
523         }
524
525         kfree(mb);
526         return err;
527 }
528
529 asmlinkage int sys32_sendfile(int out_fd, int in_fd, compat_off_t __user *offset, s32 count)
530 {
531         mm_segment_t old_fs = get_fs();
532         int ret;
533         off_t of;
534
535         if (offset && get_user(of, offset))
536                 return -EFAULT;
537
538         set_fs(KERNEL_DS);
539         ret = sys_sendfile(out_fd, in_fd, offset ? (off_t __user *)&of : NULL, count);
540         set_fs(old_fs);
541
542         if (offset && put_user(of, offset))
543                 return -EFAULT;
544
545         return ret;
546 }
547
548 asmlinkage int sys32_sendfile64(int out_fd, int in_fd, compat_loff_t __user *offset, s32 count)
549 {
550         mm_segment_t old_fs = get_fs();
551         int ret;
552         loff_t lof;
553         
554         if (offset && get_user(lof, offset))
555                 return -EFAULT;
556                 
557         set_fs(KERNEL_DS);
558         ret = sys_sendfile64(out_fd, in_fd, offset ? (loff_t __user *)&lof : NULL, count);
559         set_fs(old_fs);
560         
561         if (offset && put_user(lof, offset))
562                 return -EFAULT;
563                 
564         return ret;
565 }
566
567
568 struct sysinfo32 {
569         s32 uptime;
570         u32 loads[3];
571         u32 totalram;
572         u32 freeram;
573         u32 sharedram;
574         u32 bufferram;
575         u32 totalswap;
576         u32 freeswap;
577         unsigned short procs;
578         u32 totalhigh;
579         u32 freehigh;
580         u32 mem_unit;
581         char _f[12];
582 };
583
584 /* We used to call sys_sysinfo and translate the result.  But sys_sysinfo
585  * undoes the good work done elsewhere, and rather than undoing the
586  * damage, I decided to just duplicate the code from sys_sysinfo here.
587  */
588
589 asmlinkage int sys32_sysinfo(struct sysinfo32 __user *info)
590 {
591         struct sysinfo val;
592         int err;
593         unsigned long seq;
594
595         /* We don't need a memset here because we copy the
596          * struct to userspace once element at a time.
597          */
598
599         do {
600                 seq = read_seqbegin(&xtime_lock);
601                 val.uptime = jiffies / HZ;
602
603                 val.loads[0] = avenrun[0] << (SI_LOAD_SHIFT - FSHIFT);
604                 val.loads[1] = avenrun[1] << (SI_LOAD_SHIFT - FSHIFT);
605                 val.loads[2] = avenrun[2] << (SI_LOAD_SHIFT - FSHIFT);
606
607                 val.procs = nr_threads;
608         } while (read_seqretry(&xtime_lock, seq));
609
610
611         si_meminfo(&val);
612         si_swapinfo(&val);
613         
614         err = put_user (val.uptime, &info->uptime);
615         err |= __put_user (val.loads[0], &info->loads[0]);
616         err |= __put_user (val.loads[1], &info->loads[1]);
617         err |= __put_user (val.loads[2], &info->loads[2]);
618         err |= __put_user (val.totalram, &info->totalram);
619         err |= __put_user (val.freeram, &info->freeram);
620         err |= __put_user (val.sharedram, &info->sharedram);
621         err |= __put_user (val.bufferram, &info->bufferram);
622         err |= __put_user (val.totalswap, &info->totalswap);
623         err |= __put_user (val.freeswap, &info->freeswap);
624         err |= __put_user (val.procs, &info->procs);
625         err |= __put_user (val.totalhigh, &info->totalhigh);
626         err |= __put_user (val.freehigh, &info->freehigh);
627         err |= __put_user (val.mem_unit, &info->mem_unit);
628         return err ? -EFAULT : 0;
629 }
630
631
632 /* lseek() needs a wrapper because 'offset' can be negative, but the top
633  * half of the argument has been zeroed by syscall.S.
634  */
635
636 asmlinkage int sys32_lseek(unsigned int fd, int offset, unsigned int origin)
637 {
638         return sys_lseek(fd, offset, origin);
639 }
640
641 asmlinkage long sys32_semctl(int semid, int semnum, int cmd, union semun arg)
642 {
643         union semun u;
644         
645         if (cmd == SETVAL) {
646                 /* Ugh.  arg is a union of int,ptr,ptr,ptr, so is 8 bytes.
647                  * The int should be in the first 4, but our argument
648                  * frobbing has left it in the last 4.
649                  */
650                 u.val = *((int *)&arg + 1);
651                 return sys_semctl (semid, semnum, cmd, u);
652         }
653         return sys_semctl (semid, semnum, cmd, arg);
654 }
655
656 long sys32_lookup_dcookie(u32 cookie_high, u32 cookie_low, char __user *buf,
657                           size_t len)
658 {
659         return sys_lookup_dcookie((u64)cookie_high << 32 | cookie_low,
660                                   buf, len);
661 }