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