[PATCH] VFS: Make filldir_t and struct kstat deal in 64-bit inode numbers
[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/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         compat_ino_t ino;
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         ino = stat->ino;
248         if (sizeof(ino) < sizeof(stat->ino) && ino != stat->ino)
249                 return -EOVERFLOW;
250
251         err  = put_user(new_encode_dev(stat->dev), &statbuf->st_dev);
252         err |= put_user(ino, &statbuf->st_ino);
253         err |= put_user(stat->mode, &statbuf->st_mode);
254         err |= put_user(stat->nlink, &statbuf->st_nlink);
255         err |= put_user(0, &statbuf->st_reserved1);
256         err |= put_user(0, &statbuf->st_reserved2);
257         err |= put_user(new_encode_dev(stat->rdev), &statbuf->st_rdev);
258         err |= put_user(stat->size, &statbuf->st_size);
259         err |= put_user(stat->atime.tv_sec, &statbuf->st_atime);
260         err |= put_user(stat->atime.tv_nsec, &statbuf->st_atime_nsec);
261         err |= put_user(stat->mtime.tv_sec, &statbuf->st_mtime);
262         err |= put_user(stat->mtime.tv_nsec, &statbuf->st_mtime_nsec);
263         err |= put_user(stat->ctime.tv_sec, &statbuf->st_ctime);
264         err |= put_user(stat->ctime.tv_nsec, &statbuf->st_ctime_nsec);
265         err |= put_user(stat->blksize, &statbuf->st_blksize);
266         err |= put_user(stat->blocks, &statbuf->st_blocks);
267         err |= put_user(0, &statbuf->__unused1);
268         err |= put_user(0, &statbuf->__unused2);
269         err |= put_user(0, &statbuf->__unused3);
270         err |= put_user(0, &statbuf->__unused4);
271         err |= put_user(0, &statbuf->__unused5);
272         err |= put_user(0, &statbuf->st_fstype); /* not avail */
273         err |= put_user(0, &statbuf->st_realdev); /* not avail */
274         err |= put_user(0, &statbuf->st_basemode); /* not avail */
275         err |= put_user(0, &statbuf->st_spareshort);
276         err |= put_user(stat->uid, &statbuf->st_uid);
277         err |= put_user(stat->gid, &statbuf->st_gid);
278         err |= put_user(0, &statbuf->st_spare4[0]);
279         err |= put_user(0, &statbuf->st_spare4[1]);
280         err |= put_user(0, &statbuf->st_spare4[2]);
281
282         return err;
283 }
284
285 struct linux32_dirent {
286         u32             d_ino;
287         compat_off_t    d_off;
288         u16             d_reclen;
289         char            d_name[1];
290 };
291
292 struct old_linux32_dirent {
293         u32     d_ino;
294         u32     d_offset;
295         u16     d_namlen;
296         char    d_name[1];
297 };
298
299 struct getdents32_callback {
300         struct linux32_dirent __user * current_dir;
301         struct linux32_dirent __user * previous;
302         int count;
303         int error;
304 };
305
306 struct readdir32_callback {
307         struct old_linux32_dirent __user * dirent;
308         int count;
309 };
310
311 #define ROUND_UP(x,a)   ((__typeof__(x))(((unsigned long)(x) + ((a) - 1)) & ~((a) - 1)))
312 #define NAME_OFFSET(de) ((int) ((de)->d_name - (char __user *) (de)))
313 static int
314 filldir32 (void *__buf, const char *name, int namlen, loff_t offset, ino_t ino,
315            unsigned int d_type)
316 {
317         struct linux32_dirent __user * dirent;
318         struct getdents32_callback * buf = (struct getdents32_callback *) __buf;
319         int reclen = ROUND_UP(NAME_OFFSET(dirent) + namlen + 1, 4);
320         u32 d_ino;
321
322         buf->error = -EINVAL;   /* only used if we fail.. */
323         if (reclen > buf->count)
324                 return -EINVAL;
325         d_ino = ino;
326         if (sizeof(d_ino) < sizeof(ino) && d_ino != ino)
327                 return -EOVERFLOW;
328         dirent = buf->previous;
329         if (dirent)
330                 put_user(offset, &dirent->d_off);
331         dirent = buf->current_dir;
332         buf->previous = dirent;
333         put_user(d_ino, &dirent->d_ino);
334         put_user(reclen, &dirent->d_reclen);
335         copy_to_user(dirent->d_name, name, namlen);
336         put_user(0, dirent->d_name + namlen);
337         dirent = ((void __user *)dirent) + reclen;
338         buf->current_dir = dirent;
339         buf->count -= reclen;
340         return 0;
341 }
342
343 asmlinkage long
344 sys32_getdents (unsigned int fd, void __user * dirent, unsigned int count)
345 {
346         struct file * file;
347         struct linux32_dirent __user * lastdirent;
348         struct getdents32_callback buf;
349         int error;
350
351         error = -EBADF;
352         file = fget(fd);
353         if (!file)
354                 goto out;
355
356         buf.current_dir = (struct linux32_dirent __user *) dirent;
357         buf.previous = NULL;
358         buf.count = count;
359         buf.error = 0;
360
361         error = vfs_readdir(file, filldir32, &buf);
362         if (error < 0)
363                 goto out_putf;
364         error = buf.error;
365         lastdirent = buf.previous;
366         if (lastdirent) {
367                 put_user(file->f_pos, &lastdirent->d_off);
368                 error = count - buf.count;
369         }
370
371 out_putf:
372         fput(file);
373 out:
374         return error;
375 }
376
377 static int
378 fillonedir32 (void * __buf, const char * name, int namlen, loff_t offset, ino_t ino,
379               unsigned int d_type)
380 {
381         struct readdir32_callback * buf = (struct readdir32_callback *) __buf;
382         struct old_linux32_dirent __user * dirent;
383         u32 d_ino;
384
385         if (buf->count)
386                 return -EINVAL;
387         d_ino = ino;
388         if (sizeof(d_ino) < sizeof(ino) && d_ino != ino)
389                 return -EOVERFLOW;
390         buf->count++;
391         dirent = buf->dirent;
392         put_user(d_ino, &dirent->d_ino);
393         put_user(offset, &dirent->d_offset);
394         put_user(namlen, &dirent->d_namlen);
395         copy_to_user(dirent->d_name, name, namlen);
396         put_user(0, dirent->d_name + namlen);
397         return 0;
398 }
399
400 asmlinkage long
401 sys32_readdir (unsigned int fd, void __user * dirent, unsigned int count)
402 {
403         int error;
404         struct file * file;
405         struct readdir32_callback buf;
406
407         error = -EBADF;
408         file = fget(fd);
409         if (!file)
410                 goto out;
411
412         buf.count = 0;
413         buf.dirent = dirent;
414
415         error = vfs_readdir(file, fillonedir32, &buf);
416         if (error >= 0)
417                 error = buf.count;
418         fput(file);
419 out:
420         return error;
421 }
422
423 /*** copied from mips64 ***/
424 /*
425  * Ooo, nasty.  We need here to frob 32-bit unsigned longs to
426  * 64-bit unsigned longs.
427  */
428
429 static inline int
430 get_fd_set32(unsigned long n, u32 *ufdset, unsigned long *fdset)
431 {
432         n = (n + 8*sizeof(u32) - 1) / (8*sizeof(u32));
433         if (ufdset) {
434                 unsigned long odd;
435
436                 if (!access_ok(VERIFY_WRITE, ufdset, n*sizeof(u32)))
437                         return -EFAULT;
438
439                 odd = n & 1UL;
440                 n &= ~1UL;
441                 while (n) {
442                         unsigned long h, l;
443                         __get_user(l, ufdset);
444                         __get_user(h, ufdset+1);
445                         ufdset += 2;
446                         *fdset++ = h << 32 | l;
447                         n -= 2;
448                 }
449                 if (odd)
450                         __get_user(*fdset, ufdset);
451         } else {
452                 /* Tricky, must clear full unsigned long in the
453                  * kernel fdset at the end, this makes sure that
454                  * actually happens.
455                  */
456                 memset(fdset, 0, ((n + 1) & ~1)*sizeof(u32));
457         }
458         return 0;
459 }
460
461 static inline void
462 set_fd_set32(unsigned long n, u32 *ufdset, unsigned long *fdset)
463 {
464         unsigned long odd;
465         n = (n + 8*sizeof(u32) - 1) / (8*sizeof(u32));
466
467         if (!ufdset)
468                 return;
469
470         odd = n & 1UL;
471         n &= ~1UL;
472         while (n) {
473                 unsigned long h, l;
474                 l = *fdset++;
475                 h = l >> 32;
476                 __put_user(l, ufdset);
477                 __put_user(h, ufdset+1);
478                 ufdset += 2;
479                 n -= 2;
480         }
481         if (odd)
482                 __put_user(*fdset, ufdset);
483 }
484
485 struct msgbuf32 {
486     int mtype;
487     char mtext[1];
488 };
489
490 asmlinkage long sys32_msgsnd(int msqid,
491                                 struct msgbuf32 __user *umsgp32,
492                                 size_t msgsz, int msgflg)
493 {
494         struct msgbuf *mb;
495         struct msgbuf32 mb32;
496         int err;
497
498         if ((mb = kmalloc(msgsz + sizeof *mb + 4, GFP_KERNEL)) == NULL)
499                 return -ENOMEM;
500
501         err = get_user(mb32.mtype, &umsgp32->mtype);
502         mb->mtype = mb32.mtype;
503         err |= copy_from_user(mb->mtext, &umsgp32->mtext, msgsz);
504
505         if (err)
506                 err = -EFAULT;
507         else
508                 KERNEL_SYSCALL(err, sys_msgsnd, msqid, (struct msgbuf __user *)mb, msgsz, msgflg);
509
510         kfree(mb);
511         return err;
512 }
513
514 asmlinkage long sys32_msgrcv(int msqid,
515                                 struct msgbuf32 __user *umsgp32,
516                                 size_t msgsz, long msgtyp, int msgflg)
517 {
518         struct msgbuf *mb;
519         struct msgbuf32 mb32;
520         int err, len;
521
522         if ((mb = kmalloc(msgsz + sizeof *mb + 4, GFP_KERNEL)) == NULL)
523                 return -ENOMEM;
524
525         KERNEL_SYSCALL(err, sys_msgrcv, msqid, (struct msgbuf __user *)mb, msgsz, msgtyp, msgflg);
526
527         if (err >= 0) {
528                 len = err;
529                 mb32.mtype = mb->mtype;
530                 err = put_user(mb32.mtype, &umsgp32->mtype);
531                 err |= copy_to_user(&umsgp32->mtext, mb->mtext, len);
532                 if (err)
533                         err = -EFAULT;
534                 else
535                         err = len;
536         }
537
538         kfree(mb);
539         return err;
540 }
541
542 asmlinkage int sys32_sendfile(int out_fd, int in_fd, compat_off_t __user *offset, s32 count)
543 {
544         mm_segment_t old_fs = get_fs();
545         int ret;
546         off_t of;
547
548         if (offset && get_user(of, offset))
549                 return -EFAULT;
550
551         set_fs(KERNEL_DS);
552         ret = sys_sendfile(out_fd, in_fd, offset ? (off_t __user *)&of : NULL, count);
553         set_fs(old_fs);
554
555         if (offset && put_user(of, offset))
556                 return -EFAULT;
557
558         return ret;
559 }
560
561 asmlinkage int sys32_sendfile64(int out_fd, int in_fd, compat_loff_t __user *offset, s32 count)
562 {
563         mm_segment_t old_fs = get_fs();
564         int ret;
565         loff_t lof;
566         
567         if (offset && get_user(lof, offset))
568                 return -EFAULT;
569                 
570         set_fs(KERNEL_DS);
571         ret = sys_sendfile64(out_fd, in_fd, offset ? (loff_t __user *)&lof : NULL, count);
572         set_fs(old_fs);
573         
574         if (offset && put_user(lof, offset))
575                 return -EFAULT;
576                 
577         return ret;
578 }
579
580
581 struct sysinfo32 {
582         s32 uptime;
583         u32 loads[3];
584         u32 totalram;
585         u32 freeram;
586         u32 sharedram;
587         u32 bufferram;
588         u32 totalswap;
589         u32 freeswap;
590         unsigned short procs;
591         u32 totalhigh;
592         u32 freehigh;
593         u32 mem_unit;
594         char _f[12];
595 };
596
597 /* We used to call sys_sysinfo and translate the result.  But sys_sysinfo
598  * undoes the good work done elsewhere, and rather than undoing the
599  * damage, I decided to just duplicate the code from sys_sysinfo here.
600  */
601
602 asmlinkage int sys32_sysinfo(struct sysinfo32 __user *info)
603 {
604         struct sysinfo val;
605         int err;
606         unsigned long seq;
607
608         /* We don't need a memset here because we copy the
609          * struct to userspace once element at a time.
610          */
611
612         do {
613                 seq = read_seqbegin(&xtime_lock);
614                 val.uptime = jiffies / HZ;
615
616                 val.loads[0] = avenrun[0] << (SI_LOAD_SHIFT - FSHIFT);
617                 val.loads[1] = avenrun[1] << (SI_LOAD_SHIFT - FSHIFT);
618                 val.loads[2] = avenrun[2] << (SI_LOAD_SHIFT - FSHIFT);
619
620                 val.procs = nr_threads;
621         } while (read_seqretry(&xtime_lock, seq));
622
623
624         si_meminfo(&val);
625         si_swapinfo(&val);
626         
627         err = put_user (val.uptime, &info->uptime);
628         err |= __put_user (val.loads[0], &info->loads[0]);
629         err |= __put_user (val.loads[1], &info->loads[1]);
630         err |= __put_user (val.loads[2], &info->loads[2]);
631         err |= __put_user (val.totalram, &info->totalram);
632         err |= __put_user (val.freeram, &info->freeram);
633         err |= __put_user (val.sharedram, &info->sharedram);
634         err |= __put_user (val.bufferram, &info->bufferram);
635         err |= __put_user (val.totalswap, &info->totalswap);
636         err |= __put_user (val.freeswap, &info->freeswap);
637         err |= __put_user (val.procs, &info->procs);
638         err |= __put_user (val.totalhigh, &info->totalhigh);
639         err |= __put_user (val.freehigh, &info->freehigh);
640         err |= __put_user (val.mem_unit, &info->mem_unit);
641         return err ? -EFAULT : 0;
642 }
643
644
645 /* lseek() needs a wrapper because 'offset' can be negative, but the top
646  * half of the argument has been zeroed by syscall.S.
647  */
648
649 asmlinkage int sys32_lseek(unsigned int fd, int offset, unsigned int origin)
650 {
651         return sys_lseek(fd, offset, origin);
652 }
653
654 asmlinkage long sys32_semctl(int semid, int semnum, int cmd, union semun arg)
655 {
656         union semun u;
657         
658         if (cmd == SETVAL) {
659                 /* Ugh.  arg is a union of int,ptr,ptr,ptr, so is 8 bytes.
660                  * The int should be in the first 4, but our argument
661                  * frobbing has left it in the last 4.
662                  */
663                 u.val = *((int *)&arg + 1);
664                 return sys_semctl (semid, semnum, cmd, u);
665         }
666         return sys_semctl (semid, semnum, cmd, arg);
667 }
668
669 long sys32_lookup_dcookie(u32 cookie_high, u32 cookie_low, char __user *buf,
670                           size_t len)
671 {
672         return sys_lookup_dcookie((u64)cookie_high << 32 | cookie_low,
673                                   buf, len);
674 }