File: /usr/src/linux/arch/mips64/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/mm.h>
9 #include <linux/errno.h>
10 #include <linux/file.h>
11 #include <linux/smp_lock.h>
12 #include <linux/highuid.h>
13 #include <linux/dirent.h>
14 #include <linux/resource.h>
15 #include <linux/highmem.h>
16 #include <linux/time.h>
17 #include <linux/poll.h>
18 #include <linux/slab.h>
19 #include <linux/skbuff.h>
20 #include <linux/filter.h>
21 #include <linux/shm.h>
22 #include <linux/sem.h>
23 #include <linux/msg.h>
24 #include <linux/sysctl.h>
25 #include <linux/utime.h>
26 #include <linux/utsname.h>
27 #include <linux/personality.h>
28 #include <linux/timex.h>
29 #include <linux/dnotify.h>
30 #include <net/sock.h>
31
32 #include <asm/uaccess.h>
33 #include <asm/mman.h>
34 #include <asm/ipc.h>
35
36
37 #define A(__x) ((unsigned long)(__x))
38
39 /*
40 * Revalidate the inode. This is required for proper NFS attribute caching.
41 */
42 static __inline__ int
43 do_revalidate(struct dentry *dentry)
44 {
45 struct inode * inode = dentry->d_inode;
46
47 if (inode->i_op && inode->i_op->revalidate)
48 return inode->i_op->revalidate(dentry);
49
50 return 0;
51 }
52
53 static int cp_new_stat32(struct inode * inode, struct stat32 * statbuf)
54 {
55 struct stat32 tmp;
56 unsigned int blocks, indirect;
57
58 memset(&tmp, 0, sizeof(tmp));
59 tmp.st_dev = kdev_t_to_nr(inode->i_dev);
60 tmp.st_ino = inode->i_ino;
61 tmp.st_mode = inode->i_mode;
62 tmp.st_nlink = inode->i_nlink;
63 SET_STAT_UID(tmp, inode->i_uid);
64 SET_STAT_GID(tmp, inode->i_gid);
65 tmp.st_rdev = kdev_t_to_nr(inode->i_rdev);
66 tmp.st_size = inode->i_size;
67 tmp.st_atime = inode->i_atime;
68 tmp.st_mtime = inode->i_mtime;
69 tmp.st_ctime = inode->i_ctime;
70
71 /*
72 * st_blocks and st_blksize are approximated with a simple algorithm if
73 * they aren't supported directly by the filesystem. The minix and msdos
74 * filesystems don't keep track of blocks, so they would either have to
75 * be counted explicitly (by delving into the file itself), or by using
76 * this simple algorithm to get a reasonable (although not 100%
77 * accurate) value.
78 */
79
80 /*
81 * Use minix fs values for the number of direct and indirect blocks.
82 * The count is now exact for the minix fs except that it counts zero
83 * blocks. Everything is in units of BLOCK_SIZE until the assignment
84 * to tmp.st_blksize.
85 */
86 #define D_B 7
87 #define I_B (BLOCK_SIZE / sizeof(unsigned short))
88
89 if (!inode->i_blksize) {
90 blocks = (tmp.st_size + BLOCK_SIZE - 1) / BLOCK_SIZE;
91 if (blocks > D_B) {
92 indirect = (blocks - D_B + I_B - 1) / I_B;
93 blocks += indirect;
94 if (indirect > 1) {
95 indirect = (indirect - 1 + I_B - 1) / I_B;
96 blocks += indirect;
97 if (indirect > 1)
98 blocks++;
99 }
100 }
101 tmp.st_blocks = (BLOCK_SIZE / 512) * blocks;
102 tmp.st_blksize = BLOCK_SIZE;
103 } else {
104 tmp.st_blocks = inode->i_blocks;
105 tmp.st_blksize = inode->i_blksize;
106 }
107
108 return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0;
109 }
110
111 asmlinkage int sys32_newstat(char * filename, struct stat32 *statbuf)
112 {
113 struct nameidata nd;
114 int error;
115
116 error = user_path_walk(filename, &nd);
117 if (!error) {
118 error = do_revalidate(nd.dentry);
119 if (!error)
120 error = cp_new_stat32(nd.dentry->d_inode, statbuf);
121
122 path_release(&nd);
123 }
124
125 return error;
126 }
127
128 asmlinkage int sys32_newlstat(char * filename, struct stat32 *statbuf)
129 {
130 struct nameidata nd;
131 int error;
132
133 error = user_path_walk_link(filename, &nd);
134 if (!error) {
135 error = do_revalidate(nd.dentry);
136 if (!error)
137 error = cp_new_stat32(nd.dentry->d_inode, statbuf);
138
139 path_release(&nd);
140 }
141
142 return error;
143 }
144
145 asmlinkage long sys32_newfstat(unsigned int fd, struct stat32 * statbuf)
146 {
147 struct file * f;
148 int err = -EBADF;
149
150 f = fget(fd);
151 if (f) {
152 struct dentry * dentry = f->f_dentry;
153
154 err = do_revalidate(dentry);
155 if (!err)
156 err = cp_new_stat32(dentry->d_inode, statbuf);
157 fput(f);
158 }
159
160 return err;
161 }
162
163 asmlinkage int sys_mmap2(void) {return 0;}
164
165 asmlinkage long sys_truncate(const char * path, unsigned long length);
166
167 asmlinkage int sys_truncate64(const char *path, unsigned int high,
168 unsigned int low)
169 {
170 if ((int)high < 0)
171 return -EINVAL;
172 return sys_truncate(path, ((long) high << 32) | low);
173 }
174
175 asmlinkage long sys_ftruncate(unsigned int fd, unsigned long length);
176
177 asmlinkage int sys_ftruncate64(unsigned int fd, unsigned int high,
178 unsigned int low)
179 {
180 if ((int)high < 0)
181 return -EINVAL;
182 return sys_ftruncate(fd, ((long) high << 32) | low);
183 }
184
185 extern asmlinkage int sys_utime(char * filename, struct utimbuf * times);
186
187 struct utimbuf32 {
188 __kernel_time_t32 actime, modtime;
189 };
190
191 asmlinkage int sys32_utime(char * filename, struct utimbuf32 *times)
192 {
193 struct utimbuf t;
194 mm_segment_t old_fs;
195 int ret;
196 char *filenam;
197
198 if (!times)
199 return sys_utime(filename, NULL);
200 if (get_user (t.actime, ×->actime) ||
201 __get_user (t.modtime, ×->modtime))
202 return -EFAULT;
203 filenam = getname (filename);
204 ret = PTR_ERR(filenam);
205 if (!IS_ERR(filenam)) {
206 old_fs = get_fs();
207 set_fs (KERNEL_DS);
208 ret = sys_utime(filenam, &t);
209 set_fs (old_fs);
210 putname (filenam);
211 }
212 return ret;
213 }
214
215 #if 0
216 /*
217 * count32() counts the number of arguments/envelopes
218 */
219 static int count32(u32 * argv, int max)
220 {
221 int i = 0;
222
223 if (argv != NULL) {
224 for (;;) {
225 u32 p;
226 /* egcs is stupid */
227 if (!access_ok(VERIFY_READ, argv, sizeof (u32)))
228 return -EFAULT;
229 __get_user(p,argv);
230 if (!p)
231 break;
232 argv++;
233 if(++i > max)
234 return -E2BIG;
235 }
236 }
237 return i;
238 }
239
240
241 /*
242 * 'copy_strings32()' copies argument/envelope strings from user
243 * memory to free pages in kernel mem. These are in a format ready
244 * to be put directly into the top of new user memory.
245 */
246 int copy_strings32(int argc, u32 * argv, struct linux_binprm *bprm)
247 {
248 while (argc-- > 0) {
249 u32 str;
250 int len;
251 unsigned long pos;
252
253 if (get_user(str, argv+argc) || !str ||
254 !(len = strnlen_user((char *)A(str), bprm->p)))
255 return -EFAULT;
256 if (bprm->p < len)
257 return -E2BIG;
258
259 bprm->p -= len;
260 /* XXX: add architecture specific overflow check here. */
261
262 pos = bprm->p;
263 while (len > 0) {
264 char *kaddr;
265 int i, new, err;
266 struct page *page;
267 int offset, bytes_to_copy;
268
269 offset = pos % PAGE_SIZE;
270 i = pos/PAGE_SIZE;
271 page = bprm->page[i];
272 new = 0;
273 if (!page) {
274 page = alloc_page(GFP_HIGHUSER);
275 bprm->page[i] = page;
276 if (!page)
277 return -ENOMEM;
278 new = 1;
279 }
280 kaddr = kmap(page);
281
282 if (new && offset)
283 memset(kaddr, 0, offset);
284 bytes_to_copy = PAGE_SIZE - offset;
285 if (bytes_to_copy > len) {
286 bytes_to_copy = len;
287 if (new)
288 memset(kaddr+offset+len, 0,
289 PAGE_SIZE-offset-len);
290 }
291 err = copy_from_user(kaddr + offset, (char *)A(str),
292 bytes_to_copy);
293 flush_page_to_ram(page);
294 kunmap(page);
295
296 if (err)
297 return -EFAULT;
298
299 pos += bytes_to_copy;
300 str += bytes_to_copy;
301 len -= bytes_to_copy;
302 }
303 }
304 return 0;
305 }
306
307
308 /*
309 * sys_execve32() executes a new program.
310 */
311 int do_execve32(char * filename, u32 * argv, u32 * envp, struct pt_regs * regs)
312 {
313 struct linux_binprm bprm;
314 struct dentry * dentry;
315 int retval;
316 int i;
317
318 bprm.p = PAGE_SIZE*MAX_ARG_PAGES-sizeof(void *);
319 memset(bprm.page, 0, MAX_ARG_PAGES*sizeof(bprm.page[0]));
320
321 dentry = open_namei(filename, 0, 0);
322 retval = PTR_ERR(dentry);
323 if (IS_ERR(dentry))
324 return retval;
325
326 bprm.dentry = dentry;
327 bprm.filename = filename;
328 bprm.sh_bang = 0;
329 bprm.loader = 0;
330 bprm.exec = 0;
331 if ((bprm.argc = count32(argv, bprm.p / sizeof(u32))) < 0) {
332 dput(dentry);
333 return bprm.argc;
334 }
335
336 if ((bprm.envc = count32(envp, bprm.p / sizeof(u32))) < 0) {
337 dput(dentry);
338 return bprm.envc;
339 }
340
341 retval = prepare_binprm(&bprm);
342 if (retval < 0)
343 goto out;
344
345 retval = copy_strings_kernel(1, &bprm.filename, &bprm);
346 if (retval < 0)
347 goto out;
348
349 bprm.exec = bprm.p;
350 retval = copy_strings32(bprm.envc, envp, &bprm);
351 if (retval < 0)
352 goto out;
353
354 retval = copy_strings32(bprm.argc, argv, &bprm);
355 if (retval < 0)
356 goto out;
357
358 retval = search_binary_handler(&bprm,regs);
359 if (retval >= 0)
360 /* execve success */
361 return retval;
362
363 out:
364 /* Something went wrong, return the inode and free the argument pages*/
365 if (bprm.dentry)
366 dput(bprm.dentry);
367
368 /* Assumes that free_page() can take a NULL argument. */
369 /* I hope this is ok for all architectures */
370 for (i = 0 ; i < MAX_ARG_PAGES ; i++)
371 if (bprm.page[i])
372 __free_page(bprm.page[i]);
373
374 return retval;
375 }
376
377 /*
378 * sys_execve() executes a new program.
379 */
380 asmlinkage int sys32_execve(abi64_no_regargs, struct pt_regs regs)
381 {
382 int error;
383 char * filename;
384
385 filename = getname((char *) (long)regs.regs[4]);
386 printk("Executing: %s\n", filename);
387 error = PTR_ERR(filename);
388 if (IS_ERR(filename))
389 goto out;
390 error = do_execve32(filename, (u32 *) (long)regs.regs[5],
391 (u32 *) (long)regs.regs[6], ®s);
392 putname(filename);
393
394 out:
395 return error;
396 }
397 #else
398 static int
399 nargs(unsigned int arg, char **ap)
400 {
401 char *ptr;
402 int n, ret;
403
404 n = 0;
405 do {
406 /* egcs is stupid */
407 if (!access_ok(VERIFY_READ, arg, sizeof (unsigned int)))
408 return -EFAULT;
409 if (IS_ERR(ret = __get_user((long)ptr,(int *)A(arg))))
410 return ret;
411 if (ap) /* no access_ok needed, we allocated */
412 if (IS_ERR(ret = __put_user(ptr, ap++)))
413 return ret;
414 arg += sizeof(unsigned int);
415 n++;
416 } while (ptr);
417 return(n - 1);
418 }
419
420 asmlinkage int
421 sys32_execve(abi64_no_regargs, struct pt_regs regs)
422 {
423 extern asmlinkage int sys_execve(abi64_no_regargs, struct pt_regs regs);
424 extern asmlinkage long sys_munmap(unsigned long addr, size_t len);
425 unsigned int argv = (unsigned int)regs.regs[5];
426 unsigned int envp = (unsigned int)regs.regs[6];
427 char **av, **ae;
428 int na, ne, r, len;
429 char * filename;
430
431 na = nargs(argv, NULL);
432 if (IS_ERR(na))
433 return(na);
434 ne = nargs(envp, NULL);
435 if (IS_ERR(ne))
436 return(ne);
437 len = (na + ne + 2) * sizeof(*av);
438 /*
439 * kmalloc won't work because the `sys_exec' code will attempt
440 * to do a `get_user' on the arg list and `get_user' will fail
441 * on a kernel address (simplifies `get_user'). Instead we
442 * do an mmap to get a user address. Note that since a successful
443 * `execve' frees all current memory we only have to do an
444 * `munmap' if the `execve' failes.
445 */
446 down_write(¤t->mm->mmap_sem);
447 av = (char **) do_mmap_pgoff(0, 0, len, PROT_READ | PROT_WRITE,
448 MAP_PRIVATE | MAP_ANONYMOUS, 0);
449 up_write(¤t->mm->mmap_sem);
450
451 if (IS_ERR(av))
452 return (long) av;
453 ae = av + na + 1;
454 if (IS_ERR(r = __put_user(0, (av + na))))
455 goto out;
456 if (IS_ERR(r = __put_user(0, (ae + ne))))
457 goto out;
458 if (IS_ERR(r = nargs(argv, av)))
459 goto out;
460 if (IS_ERR(r = nargs(envp, ae)))
461 goto out;
462 filename = getname((char *) (long)regs.regs[4]);
463 r = PTR_ERR(filename);
464 if (IS_ERR(filename))
465 goto out;
466
467 r = do_execve(filename, av, ae, ®s);
468 putname(filename);
469 if (IS_ERR(r))
470 out:
471 sys_munmap((unsigned long)av, len);
472 return(r);
473 }
474 #endif
475
476 struct dirent32 {
477 unsigned int d_ino;
478 unsigned int d_off;
479 unsigned short d_reclen;
480 char d_name[NAME_MAX + 1];
481 };
482
483 static void
484 xlate_dirent(void *dirent64, void *dirent32, long n)
485 {
486 long off;
487 struct dirent *dirp;
488 struct dirent32 *dirp32;
489
490 off = 0;
491 while (off < n) {
492 dirp = (struct dirent *)(dirent64 + off);
493 dirp32 = (struct dirent32 *)(dirent32 + off);
494 off += dirp->d_reclen;
495 dirp32->d_ino = dirp->d_ino;
496 dirp32->d_off = (unsigned int)dirp->d_off;
497 dirp32->d_reclen = dirp->d_reclen;
498 strncpy(dirp32->d_name, dirp->d_name, dirp->d_reclen - ((3 * 4) + 2));
499 }
500 return;
501 }
502
503 asmlinkage long sys_getdents(unsigned int fd, void * dirent, unsigned int count);
504
505 asmlinkage long
506 sys32_getdents(unsigned int fd, void * dirent32, unsigned int count)
507 {
508 long n;
509 void *dirent64;
510
511 dirent64 = (void *)((unsigned long)(dirent32 + (sizeof(long) - 1)) & ~(sizeof(long) - 1));
512 if ((n = sys_getdents(fd, dirent64, count - (dirent64 - dirent32))) < 0)
513 return(n);
514 xlate_dirent(dirent64, dirent32, n);
515 return(n);
516 }
517
518 asmlinkage int old_readdir(unsigned int fd, void * dirent, unsigned int count);
519
520 asmlinkage int
521 sys32_readdir(unsigned int fd, void * dirent32, unsigned int count)
522 {
523 int n;
524 struct dirent dirent64;
525
526 if ((n = old_readdir(fd, &dirent64, count)) < 0)
527 return(n);
528 xlate_dirent(&dirent64, dirent32, dirent64.d_reclen);
529 return(n);
530 }
531
532 struct timeval32
533 {
534 int tv_sec, tv_usec;
535 };
536
537 struct itimerval32
538 {
539 struct timeval32 it_interval;
540 struct timeval32 it_value;
541 };
542
543 struct rusage32 {
544 struct timeval32 ru_utime;
545 struct timeval32 ru_stime;
546 int ru_maxrss;
547 int ru_ixrss;
548 int ru_idrss;
549 int ru_isrss;
550 int ru_minflt;
551 int ru_majflt;
552 int ru_nswap;
553 int ru_inblock;
554 int ru_oublock;
555 int ru_msgsnd;
556 int ru_msgrcv;
557 int ru_nsignals;
558 int ru_nvcsw;
559 int ru_nivcsw;
560 };
561
562 static int
563 put_rusage (struct rusage32 *ru, struct rusage *r)
564 {
565 int err;
566
567 err = put_user (r->ru_utime.tv_sec, &ru->ru_utime.tv_sec);
568 err |= __put_user (r->ru_utime.tv_usec, &ru->ru_utime.tv_usec);
569 err |= __put_user (r->ru_stime.tv_sec, &ru->ru_stime.tv_sec);
570 err |= __put_user (r->ru_stime.tv_usec, &ru->ru_stime.tv_usec);
571 err |= __put_user (r->ru_maxrss, &ru->ru_maxrss);
572 err |= __put_user (r->ru_ixrss, &ru->ru_ixrss);
573 err |= __put_user (r->ru_idrss, &ru->ru_idrss);
574 err |= __put_user (r->ru_isrss, &ru->ru_isrss);
575 err |= __put_user (r->ru_minflt, &ru->ru_minflt);
576 err |= __put_user (r->ru_majflt, &ru->ru_majflt);
577 err |= __put_user (r->ru_nswap, &ru->ru_nswap);
578 err |= __put_user (r->ru_inblock, &ru->ru_inblock);
579 err |= __put_user (r->ru_oublock, &ru->ru_oublock);
580 err |= __put_user (r->ru_msgsnd, &ru->ru_msgsnd);
581 err |= __put_user (r->ru_msgrcv, &ru->ru_msgrcv);
582 err |= __put_user (r->ru_nsignals, &ru->ru_nsignals);
583 err |= __put_user (r->ru_nvcsw, &ru->ru_nvcsw);
584 err |= __put_user (r->ru_nivcsw, &ru->ru_nivcsw);
585 return err;
586 }
587
588 asmlinkage int
589 sys32_wait4(__kernel_pid_t32 pid, unsigned int * stat_addr, int options,
590 struct rusage32 * ru)
591 {
592 if (!ru)
593 return sys_wait4(pid, stat_addr, options, NULL);
594 else {
595 struct rusage r;
596 int ret;
597 unsigned int status;
598 mm_segment_t old_fs = get_fs();
599
600 set_fs(KERNEL_DS);
601 ret = sys_wait4(pid, stat_addr ? &status : NULL, options, &r);
602 set_fs(old_fs);
603 if (put_rusage (ru, &r)) return -EFAULT;
604 if (stat_addr && put_user (status, stat_addr))
605 return -EFAULT;
606 return ret;
607 }
608 }
609
610 asmlinkage int
611 sys32_waitpid(__kernel_pid_t32 pid, unsigned int *stat_addr, int options)
612 {
613 return sys32_wait4(pid, stat_addr, options, NULL);
614 }
615
616 #define RLIM_INFINITY32 0x7fffffff
617 #define RESOURCE32(x) ((x > RLIM_INFINITY32) ? RLIM_INFINITY32 : x)
618
619 struct rlimit32 {
620 int rlim_cur;
621 int rlim_max;
622 };
623
624 extern asmlinkage int sys_old_getrlimit(unsigned int resource, struct rlimit *rlim);
625
626 asmlinkage int
627 sys32_getrlimit(unsigned int resource, struct rlimit32 *rlim)
628 {
629 struct rlimit r;
630 int ret;
631 mm_segment_t old_fs = get_fs ();
632
633 set_fs (KERNEL_DS);
634 ret = sys_old_getrlimit(resource, &r);
635 set_fs (old_fs);
636 if (!ret) {
637 ret = put_user (RESOURCE32(r.rlim_cur), &rlim->rlim_cur);
638 ret |= __put_user (RESOURCE32(r.rlim_max), &rlim->rlim_max);
639 }
640 return ret;
641 }
642
643 extern asmlinkage int sys_setrlimit(unsigned int resource, struct rlimit *rlim);
644
645 asmlinkage int
646 sys32_setrlimit(unsigned int resource, struct rlimit32 *rlim)
647 {
648 struct rlimit r;
649 int ret;
650 mm_segment_t old_fs = get_fs ();
651
652 if (resource >= RLIM_NLIMITS) return -EINVAL;
653 if (get_user (r.rlim_cur, &rlim->rlim_cur) ||
654 __get_user (r.rlim_max, &rlim->rlim_max))
655 return -EFAULT;
656 if (r.rlim_cur == RLIM_INFINITY32)
657 r.rlim_cur = RLIM_INFINITY;
658 if (r.rlim_max == RLIM_INFINITY32)
659 r.rlim_max = RLIM_INFINITY;
660 set_fs (KERNEL_DS);
661 ret = sys_setrlimit(resource, &r);
662 set_fs (old_fs);
663 return ret;
664 }
665
666 struct statfs32 {
667 int f_type;
668 int f_bsize;
669 int f_frsize;
670 int f_blocks;
671 int f_bfree;
672 int f_files;
673 int f_ffree;
674 int f_bavail;
675 __kernel_fsid_t32 f_fsid;
676 int f_namelen;
677 int f_spare[6];
678 };
679
680 static inline int
681 put_statfs (struct statfs32 *ubuf, struct statfs *kbuf)
682 {
683 int err;
684
685 err = put_user (kbuf->f_type, &ubuf->f_type);
686 err |= __put_user (kbuf->f_bsize, &ubuf->f_bsize);
687 err |= __put_user (kbuf->f_blocks, &ubuf->f_blocks);
688 err |= __put_user (kbuf->f_bfree, &ubuf->f_bfree);
689 err |= __put_user (kbuf->f_bavail, &ubuf->f_bavail);
690 err |= __put_user (kbuf->f_files, &ubuf->f_files);
691 err |= __put_user (kbuf->f_ffree, &ubuf->f_ffree);
692 err |= __put_user (kbuf->f_namelen, &ubuf->f_namelen);
693 err |= __put_user (kbuf->f_fsid.val[0], &ubuf->f_fsid.val[0]);
694 err |= __put_user (kbuf->f_fsid.val[1], &ubuf->f_fsid.val[1]);
695 return err;
696 }
697
698 extern asmlinkage int sys_statfs(const char * path, struct statfs * buf);
699
700 asmlinkage int
701 sys32_statfs(const char * path, struct statfs32 *buf)
702 {
703 int ret;
704 struct statfs s;
705 mm_segment_t old_fs = get_fs();
706
707 set_fs (KERNEL_DS);
708 ret = sys_statfs((const char *)path, &s);
709 set_fs (old_fs);
710 if (put_statfs(buf, &s))
711 return -EFAULT;
712 return ret;
713 }
714
715 extern asmlinkage int sys_fstatfs(unsigned int fd, struct statfs * buf);
716
717 asmlinkage int
718 sys32_fstatfs(unsigned int fd, struct statfs32 *buf)
719 {
720 int ret;
721 struct statfs s;
722 mm_segment_t old_fs = get_fs();
723
724 set_fs (KERNEL_DS);
725 ret = sys_fstatfs(fd, &s);
726 set_fs (old_fs);
727 if (put_statfs(buf, &s))
728 return -EFAULT;
729 return ret;
730 }
731
732 extern asmlinkage int
733 sys_getrusage(int who, struct rusage *ru);
734
735 asmlinkage int
736 sys32_getrusage(int who, struct rusage32 *ru)
737 {
738 struct rusage r;
739 int ret;
740 mm_segment_t old_fs = get_fs();
741
742 set_fs (KERNEL_DS);
743 ret = sys_getrusage(who, &r);
744 set_fs (old_fs);
745 if (put_rusage (ru, &r))
746 return -EFAULT;
747
748 return ret;
749 }
750
751 static inline long
752 get_tv32(struct timeval *o, struct timeval32 *i)
753 {
754 return (!access_ok(VERIFY_READ, i, sizeof(*i)) ||
755 (__get_user(o->tv_sec, &i->tv_sec) |
756 __get_user(o->tv_usec, &i->tv_usec)));
757 }
758
759 static inline long
760 get_it32(struct itimerval *o, struct itimerval32 *i)
761 {
762 return (!access_ok(VERIFY_READ, i, sizeof(*i)) ||
763 (__get_user(o->it_interval.tv_sec, &i->it_interval.tv_sec) |
764 __get_user(o->it_interval.tv_usec, &i->it_interval.tv_usec) |
765 __get_user(o->it_value.tv_sec, &i->it_value.tv_sec) |
766 __get_user(o->it_value.tv_usec, &i->it_value.tv_usec)));
767 }
768
769 static inline long
770 put_tv32(struct timeval32 *o, struct timeval *i)
771 {
772 return (!access_ok(VERIFY_WRITE, o, sizeof(*o)) ||
773 (__put_user(i->tv_sec, &o->tv_sec) |
774 __put_user(i->tv_usec, &o->tv_usec)));
775 }
776
777 static inline long
778 put_it32(struct itimerval32 *o, struct itimerval *i)
779 {
780 return (!access_ok(VERIFY_WRITE, o, sizeof(*o)) ||
781 (__put_user(i->it_interval.tv_sec, &o->it_interval.tv_sec) |
782 __put_user(i->it_interval.tv_usec, &o->it_interval.tv_usec) |
783 __put_user(i->it_value.tv_sec, &o->it_value.tv_sec) |
784 __put_user(i->it_value.tv_usec, &o->it_value.tv_usec)));
785 }
786
787 extern int do_getitimer(int which, struct itimerval *value);
788
789 asmlinkage int
790 sys32_getitimer(int which, struct itimerval32 *it)
791 {
792 struct itimerval kit;
793 int error;
794
795 error = do_getitimer(which, &kit);
796 if (!error && put_it32(it, &kit))
797 error = -EFAULT;
798
799 return error;
800 }
801
802 extern int do_setitimer(int which, struct itimerval *, struct itimerval *);
803
804
805 asmlinkage int
806 sys32_setitimer(int which, struct itimerval32 *in, struct itimerval32 *out)
807 {
808 struct itimerval kin, kout;
809 int error;
810
811 if (in) {
812 if (get_it32(&kin, in))
813 return -EFAULT;
814 } else
815 memset(&kin, 0, sizeof(kin));
816
817 error = do_setitimer(which, &kin, out ? &kout : NULL);
818 if (error || !out)
819 return error;
820 if (put_it32(out, &kout))
821 return -EFAULT;
822
823 return 0;
824
825 }
826 asmlinkage unsigned long
827 sys32_alarm(unsigned int seconds)
828 {
829 struct itimerval it_new, it_old;
830 unsigned int oldalarm;
831
832 it_new.it_interval.tv_sec = it_new.it_interval.tv_usec = 0;
833 it_new.it_value.tv_sec = seconds;
834 it_new.it_value.tv_usec = 0;
835 do_setitimer(ITIMER_REAL, &it_new, &it_old);
836 oldalarm = it_old.it_value.tv_sec;
837 /* ehhh.. We can't return 0 if we have an alarm pending.. */
838 /* And we'd better return too much than too little anyway */
839 if (it_old.it_value.tv_usec)
840 oldalarm++;
841
842 return oldalarm;
843 }
844
845 /* Translations due to time_t size differences. Which affects all
846 sorts of things, like timeval and itimerval. */
847
848
849 extern struct timezone sys_tz;
850 extern int do_sys_settimeofday(struct timeval *tv, struct timezone *tz);
851
852 asmlinkage int
853 sys32_gettimeofday(struct timeval32 *tv, struct timezone *tz)
854 {
855 if (tv) {
856 struct timeval ktv;
857 do_gettimeofday(&ktv);
858 if (put_tv32(tv, &ktv))
859 return -EFAULT;
860 }
861 if (tz) {
862 if (copy_to_user(tz, &sys_tz, sizeof(sys_tz)))
863 return -EFAULT;
864 }
865 return 0;
866 }
867
868 asmlinkage int
869 sys32_settimeofday(struct timeval32 *tv, struct timezone *tz)
870 {
871 struct timeval ktv;
872 struct timezone ktz;
873
874 if (tv) {
875 if (get_tv32(&ktv, tv))
876 return -EFAULT;
877 }
878 if (tz) {
879 if (copy_from_user(&ktz, tz, sizeof(ktz)))
880 return -EFAULT;
881 }
882
883 return do_sys_settimeofday(tv ? &ktv : NULL, tz ? &ktz : NULL);
884 }
885
886 extern asmlinkage long sys_llseek(unsigned int fd, unsigned long offset_high,
887 unsigned long offset_low, loff_t * result,
888 unsigned int origin);
889
890 extern asmlinkage int sys32_llseek(unsigned int fd, unsigned int offset_high,
891 unsigned int offset_low, loff_t * result,
892 unsigned int origin)
893 {
894 return sys_llseek(fd, offset_high, offset_low, result, origin);
895 }
896
897 struct iovec32 { unsigned int iov_base; int iov_len; };
898
899 typedef ssize_t (*IO_fn_t)(struct file *, char *, size_t, loff_t *);
900
901 static long
902 do_readv_writev32(int type, struct file *file, const struct iovec32 *vector,
903 u32 count)
904 {
905 unsigned long tot_len;
906 struct iovec iovstack[UIO_FASTIOV];
907 struct iovec *iov=iovstack, *ivp;
908 struct inode *inode;
909 long retval, i;
910 IO_fn_t fn;
911
912 /* First get the "struct iovec" from user memory and
913 * verify all the pointers
914 */
915 if (!count)
916 return 0;
917 if(verify_area(VERIFY_READ, vector, sizeof(struct iovec32)*count))
918 return -EFAULT;
919 if (count > UIO_MAXIOV)
920 return -EINVAL;
921 if (count > UIO_FASTIOV) {
922 iov = kmalloc(count*sizeof(struct iovec), GFP_KERNEL);
923 if (!iov)
924 return -ENOMEM;
925 }
926
927 tot_len = 0;
928 i = count;
929 ivp = iov;
930 while (i > 0) {
931 u32 len;
932 u32 buf;
933
934 __get_user(len, &vector->iov_len);
935 __get_user(buf, &vector->iov_base);
936 tot_len += len;
937 ivp->iov_base = (void *)A(buf);
938 ivp->iov_len = (__kernel_size_t) len;
939 vector++;
940 ivp++;
941 i--;
942 }
943
944 inode = file->f_dentry->d_inode;
945 /* VERIFY_WRITE actually means a read, as we write to user space */
946 retval = locks_verify_area((type == VERIFY_WRITE
947 ? FLOCK_VERIFY_READ : FLOCK_VERIFY_WRITE),
948 inode, file, file->f_pos, tot_len);
949 if (retval) {
950 if (iov != iovstack)
951 kfree(iov);
952 return retval;
953 }
954
955 /* Then do the actual IO. Note that sockets need to be handled
956 * specially as they have atomicity guarantees and can handle
957 * iovec's natively
958 */
959 if (inode->i_sock) {
960 int err;
961 err = sock_readv_writev(type, inode, file, iov, count, tot_len);
962 if (iov != iovstack)
963 kfree(iov);
964 return err;
965 }
966
967 if (!file->f_op) {
968 if (iov != iovstack)
969 kfree(iov);
970 return -EINVAL;
971 }
972 /* VERIFY_WRITE actually means a read, as we write to user space */
973 fn = file->f_op->read;
974 if (type == VERIFY_READ)
975 fn = (IO_fn_t) file->f_op->write;
976 ivp = iov;
977 while (count > 0) {
978 void * base;
979 int len, nr;
980
981 base = ivp->iov_base;
982 len = ivp->iov_len;
983 ivp++;
984 count--;
985 nr = fn(file, base, len, &file->f_pos);
986 if (nr < 0) {
987 if (retval)
988 break;
989 retval = nr;
990 break;
991 }
992 retval += nr;
993 if (nr != len)
994 break;
995 }
996 if (iov != iovstack)
997 kfree(iov);
998
999 return retval;
1000 }
1001
1002 asmlinkage long
1003 sys32_readv(int fd, struct iovec32 *vector, u32 count)
1004 {
1005 struct file *file;
1006 ssize_t ret;
1007
1008 ret = -EBADF;
1009 file = fget(fd);
1010 if (!file)
1011 goto bad_file;
1012 if (file->f_op && (file->f_mode & FMODE_READ) &&
1013 (file->f_op->readv || file->f_op->read))
1014 ret = do_readv_writev32(VERIFY_WRITE, file, vector, count);
1015
1016 fput(file);
1017
1018 bad_file:
1019 return ret;
1020 }
1021
1022 asmlinkage long
1023 sys32_writev(int fd, struct iovec32 *vector, u32 count)
1024 {
1025 struct file *file;
1026 ssize_t ret;
1027
1028 ret = -EBADF;
1029 file = fget(fd);
1030 if(!file)
1031 goto bad_file;
1032 if (file->f_op && (file->f_mode & FMODE_WRITE) &&
1033 (file->f_op->writev || file->f_op->write))
1034 ret = do_readv_writev32(VERIFY_READ, file, vector, count);
1035 fput(file);
1036
1037 bad_file:
1038 return ret;
1039 }
1040
1041 /* From the Single Unix Spec: pread & pwrite act like lseek to pos + op +
1042 lseek back to original location. They fail just like lseek does on
1043 non-seekable files. */
1044
1045 asmlinkage ssize_t sys32_pread(unsigned int fd, char * buf,
1046 size_t count, u32 unused, loff_t pos)
1047 {
1048 ssize_t ret;
1049 struct file * file;
1050 ssize_t (*read)(struct file *, char *, size_t, loff_t *);
1051
1052 ret = -EBADF;
1053 file = fget(fd);
1054 if (!file)
1055 goto bad_file;
1056 if (!(file->f_mode & FMODE_READ))
1057 goto out;
1058 ret = locks_verify_area(FLOCK_VERIFY_READ, file->f_dentry->d_inode,
1059 file, pos, count);
1060 if (ret)
1061 goto out;
1062 ret = -EINVAL;
1063 if (!file->f_op || !(read = file->f_op->read))
1064 goto out;
1065 if (pos < 0)
1066 goto out;
1067 ret = read(file, buf, count, &pos);
1068 if (ret > 0)
1069 inode_dir_notify(file->f_dentry->d_parent->d_inode, DN_ACCESS);
1070 out:
1071 fput(file);
1072 bad_file:
1073 return ret;
1074 }
1075
1076 asmlinkage ssize_t sys32_pwrite(unsigned int fd, const char * buf,
1077 size_t count, u32 unused, loff_t pos)
1078 {
1079 ssize_t ret;
1080 struct file * file;
1081 ssize_t (*write)(struct file *, const char *, size_t, loff_t *);
1082
1083 ret = -EBADF;
1084 file = fget(fd);
1085 if (!file)
1086 goto bad_file;
1087 if (!(file->f_mode & FMODE_WRITE))
1088 goto out;
1089 ret = locks_verify_area(FLOCK_VERIFY_WRITE, file->f_dentry->d_inode,
1090 file, pos, count);
1091 if (ret)
1092 goto out;
1093 ret = -EINVAL;
1094 if (!file->f_op || !(write = file->f_op->write))
1095 goto out;
1096 if (pos < 0)
1097 goto out;
1098
1099 ret = write(file, buf, count, &pos);
1100 if (ret > 0)
1101 inode_dir_notify(file->f_dentry->d_parent->d_inode, DN_MODIFY);
1102 out:
1103 fput(file);
1104 bad_file:
1105 return ret;
1106 }
1107 /*
1108 * Ooo, nasty. We need here to frob 32-bit unsigned longs to
1109 * 64-bit unsigned longs.
1110 */
1111
1112 static inline int
1113 get_fd_set32(unsigned long n, unsigned long *fdset, u32 *ufdset)
1114 {
1115 #ifdef __MIPSEB__
1116 if (ufdset) {
1117 unsigned long odd;
1118
1119 if (verify_area(VERIFY_WRITE, ufdset, n*sizeof(u32)))
1120 return -EFAULT;
1121
1122 odd = n & 1UL;
1123 n &= ~1UL;
1124 while (n) {
1125 unsigned long h, l;
1126 __get_user(l, ufdset);
1127 __get_user(h, ufdset+1);
1128 ufdset += 2;
1129 *fdset++ = h << 32 | l;
1130 n -= 2;
1131 }
1132 if (odd)
1133 __get_user(*fdset, ufdset);
1134 } else {
1135 /* Tricky, must clear full unsigned long in the
1136 * kernel fdset at the end, this makes sure that
1137 * actually happens.
1138 */
1139 memset(fdset, 0, ((n + 1) & ~1)*sizeof(u32));
1140 }
1141 return 0;
1142 #else
1143 <<Bomb - little endian support must define this>>
1144 #endif
1145 }
1146
1147 static inline void
1148 set_fd_set32(unsigned long n, u32 *ufdset, unsigned long *fdset)
1149 {
1150 unsigned long odd;
1151
1152 if (!ufdset)
1153 return;
1154
1155 odd = n & 1UL;
1156 n &= ~1UL;
1157 while (n) {
1158 unsigned long h, l;
1159 l = *fdset++;
1160 h = l >> 32;
1161 __put_user(l, ufdset);
1162 __put_user(h, ufdset+1);
1163 ufdset += 2;
1164 n -= 2;
1165 }
1166 if (odd)
1167 __put_user(*fdset, ufdset);
1168 }
1169
1170 /*
1171 * We can actually return ERESTARTSYS instead of EINTR, but I'd
1172 * like to be certain this leads to no problems. So I return
1173 * EINTR just for safety.
1174 *
1175 * Update: ERESTARTSYS breaks at least the xview clock binary, so
1176 * I'm trying ERESTARTNOHAND which restart only when you want to.
1177 */
1178 #define MAX_SELECT_SECONDS \
1179 ((unsigned long) (MAX_SCHEDULE_TIMEOUT / HZ)-1)
1180
1181 asmlinkage int sys32_select(int n, u32 *inp, u32 *outp, u32 *exp, struct timeval32 *tvp)
1182 {
1183 fd_set_bits fds;
1184 char *bits;
1185 unsigned long nn;
1186 long timeout;
1187 int ret, size;
1188
1189 timeout = MAX_SCHEDULE_TIMEOUT;
1190 if (tvp) {
1191 time_t sec, usec;
1192
1193 if ((ret = verify_area(VERIFY_READ, tvp, sizeof(*tvp)))
1194 || (ret = __get_user(sec, &tvp->tv_sec))
1195 || (ret = __get_user(usec, &tvp->tv_usec)))
1196 goto out_nofds;
1197
1198 ret = -EINVAL;
1199 if(sec < 0 || usec < 0)
1200 goto out_nofds;
1201
1202 if ((unsigned long) sec < MAX_SELECT_SECONDS) {
1203 timeout = (usec + 1000000/HZ - 1) / (1000000/HZ);
1204 timeout += sec * (unsigned long) HZ;
1205 }
1206 }
1207
1208 ret = -EINVAL;
1209 if (n < 0)
1210 goto out_nofds;
1211 if (n > current->files->max_fdset)
1212 n = current->files->max_fdset;
1213
1214 /*
1215 * We need 6 bitmaps (in/out/ex for both incoming and outgoing),
1216 * since we used fdset we need to allocate memory in units of
1217 * long-words.
1218 */
1219 ret = -ENOMEM;
1220 size = FDS_BYTES(n);
1221 bits = kmalloc(6 * size, GFP_KERNEL);
1222 if (!bits)
1223 goto out_nofds;
1224 fds.in = (unsigned long *) bits;
1225 fds.out = (unsigned long *) (bits + size);
1226 fds.ex = (unsigned long *) (bits + 2*size);
1227 fds.res_in = (unsigned long *) (bits + 3*size);
1228 fds.res_out = (unsigned long *) (bits + 4*size);
1229 fds.res_ex = (unsigned long *) (bits + 5*size);
1230
1231 nn = (n + 8*sizeof(u32) - 1) / (8*sizeof(u32));
1232 if ((ret = get_fd_set32(nn, fds.in, inp)) ||
1233 (ret = get_fd_set32(nn, fds.out, outp)) ||
1234 (ret = get_fd_set32(nn, fds.ex, exp)))
1235 goto out;
1236 zero_fd_set(n, fds.res_in);
1237 zero_fd_set(n, fds.res_out);
1238 zero_fd_set(n, fds.res_ex);
1239
1240 ret = do_select(n, &fds, &timeout);
1241
1242 if (tvp && !(current->personality & STICKY_TIMEOUTS)) {
1243 time_t sec = 0, usec = 0;
1244 if (timeout) {
1245 sec = timeout / HZ;
1246 usec = timeout % HZ;
1247 usec *= (1000000/HZ);
1248 }
1249 put_user(sec, &tvp->tv_sec);
1250 put_user(usec, &tvp->tv_usec);
1251 }
1252
1253 if (ret < 0)
1254 goto out;
1255 if (!ret) {
1256 ret = -ERESTARTNOHAND;
1257 if (signal_pending(current))
1258 goto out;
1259 ret = 0;
1260 }
1261
1262 set_fd_set32(nn, inp, fds.res_in);
1263 set_fd_set32(nn, outp, fds.res_out);
1264 set_fd_set32(nn, exp, fds.res_ex);
1265
1266 out:
1267 kfree(bits);
1268 out_nofds:
1269 return ret;
1270 }
1271
1272
1273
1274 struct timespec32 {
1275 int tv_sec;
1276 int tv_nsec;
1277 };
1278
1279 extern asmlinkage int sys_sched_rr_get_interval(pid_t pid,
1280 struct timespec *interval);
1281
1282 asmlinkage int
1283 sys32_sched_rr_get_interval(__kernel_pid_t32 pid, struct timespec32 *interval)
1284 {
1285 struct timespec t;
1286 int ret;
1287 mm_segment_t old_fs = get_fs ();
1288
1289 set_fs (KERNEL_DS);
1290 ret = sys_sched_rr_get_interval(pid, &t);
1291 set_fs (old_fs);
1292 if (put_user (t.tv_sec, &interval->tv_sec) ||
1293 __put_user (t.tv_nsec, &interval->tv_nsec))
1294 return -EFAULT;
1295 return ret;
1296 }
1297
1298
1299 extern asmlinkage int sys_nanosleep(struct timespec *rqtp,
1300 struct timespec *rmtp);
1301
1302 asmlinkage int
1303 sys32_nanosleep(struct timespec32 *rqtp, struct timespec32 *rmtp)
1304 {
1305 struct timespec t;
1306 int ret;
1307 mm_segment_t old_fs = get_fs ();
1308
1309 if (get_user (t.tv_sec, &rqtp->tv_sec) ||
1310 __get_user (t.tv_nsec, &rqtp->tv_nsec))
1311 return -EFAULT;
1312
1313 set_fs (KERNEL_DS);
1314 ret = sys_nanosleep(&t, rmtp ? &t : NULL);
1315 set_fs (old_fs);
1316 if (rmtp && ret == -EINTR) {
1317 if (__put_user (t.tv_sec, &rmtp->tv_sec) ||
1318 __put_user (t.tv_nsec, &rmtp->tv_nsec))
1319 return -EFAULT;
1320 }
1321 return ret;
1322 }
1323
1324 struct tms32 {
1325 int tms_utime;
1326 int tms_stime;
1327 int tms_cutime;
1328 int tms_cstime;
1329 };
1330
1331 extern asmlinkage long sys_times(struct tms * tbuf);
1332 asmlinkage long sys32_times(struct tms32 *tbuf)
1333 {
1334 struct tms t;
1335 long ret;
1336 mm_segment_t old_fs = get_fs();
1337 int err;
1338
1339 set_fs(KERNEL_DS);
1340 ret = sys_times(tbuf ? &t : NULL);
1341 set_fs(old_fs);
1342 if (tbuf) {
1343 err = put_user (t.tms_utime, &tbuf->tms_utime);
1344 err |= __put_user (t.tms_stime, &tbuf->tms_stime);
1345 err |= __put_user (t.tms_cutime, &tbuf->tms_cutime);
1346 err |= __put_user (t.tms_cstime, &tbuf->tms_cstime);
1347 if (err)
1348 ret = -EFAULT;
1349 }
1350 return ret;
1351 }
1352
1353 extern asmlinkage int sys_setsockopt(int fd, int level, int optname,
1354 char *optval, int optlen);
1355
1356 asmlinkage int sys32_setsockopt(int fd, int level, int optname,
1357 char *optval, int optlen)
1358 {
1359 if (optname == SO_ATTACH_FILTER) {
1360 struct sock_fprog32 {
1361 __u16 len;
1362 __u32 filter;
1363 } *fprog32 = (struct sock_fprog32 *)optval;
1364 struct sock_fprog kfprog;
1365 struct sock_filter *kfilter;
1366 unsigned int fsize;
1367 mm_segment_t old_fs;
1368 __u32 uptr;
1369 int ret;
1370
1371 if (get_user(kfprog.len, &fprog32->len) ||
1372 __get_user(uptr, &fprog32->filter))
1373 return -EFAULT;
1374 kfprog.filter = (struct sock_filter *)A(uptr);
1375 fsize = kfprog.len * sizeof(struct sock_filter);
1376 kfilter = (struct sock_filter *)kmalloc(fsize, GFP_KERNEL);
1377 if (kfilter == NULL)
1378 return -ENOMEM;
1379 if (copy_from_user(kfilter, kfprog.filter, fsize)) {
1380 kfree(kfilter);
1381 return -EFAULT;
1382 }
1383 kfprog.filter = kfilter;
1384 old_fs = get_fs();
1385 set_fs(KERNEL_DS);
1386 ret = sys_setsockopt(fd, level, optname,
1387 (char *)&kfprog, sizeof(kfprog));
1388 set_fs(old_fs);
1389 kfree(kfilter);
1390 return ret;
1391 }
1392 return sys_setsockopt(fd, level, optname, optval, optlen);
1393 }
1394
1395 struct flock32 {
1396 short l_type;
1397 short l_whence;
1398 __kernel_off_t32 l_start;
1399 __kernel_off_t32 l_len;
1400 __kernel_pid_t32 l_pid;
1401 short __unused;
1402 };
1403
1404 static inline int get_flock(struct flock *kfl, struct flock32 *ufl)
1405 {
1406 int err;
1407
1408 err = get_user(kfl->l_type, &ufl->l_type);
1409 err |= __get_user(kfl->l_whence, &ufl->l_whence);
1410 err |= __get_user(kfl->l_start, &ufl->l_start);
1411 err |= __get_user(kfl->l_len, &ufl->l_len);
1412 err |= __get_user(kfl->l_pid, &ufl->l_pid);
1413 return err;
1414 }
1415
1416 static inline int put_flock(struct flock *kfl, struct flock32 *ufl)
1417 {
1418 int err;
1419
1420 err = __put_user(kfl->l_type, &ufl->l_type);
1421 err |= __put_user(kfl->l_whence, &ufl->l_whence);
1422 err |= __put_user(kfl->l_start, &ufl->l_start);
1423 err |= __put_user(kfl->l_len, &ufl->l_len);
1424 err |= __put_user(kfl->l_pid, &ufl->l_pid);
1425 return err;
1426 }
1427
1428 extern asmlinkage long
1429 sys_fcntl(unsigned int fd, unsigned int cmd, unsigned long arg);
1430
1431 asmlinkage long
1432 sys32_fcntl(unsigned int fd, unsigned int cmd, unsigned long arg)
1433 {
1434 switch (cmd) {
1435 case F_GETLK:
1436 case F_SETLK:
1437 case F_SETLKW:
1438 {
1439 struct flock f;
1440 mm_segment_t old_fs;
1441 long ret;
1442
1443 if (get_flock(&f, (struct flock32 *)arg))
1444 return -EFAULT;
1445 old_fs = get_fs(); set_fs (KERNEL_DS);
1446 ret = sys_fcntl(fd, cmd, (unsigned long)&f);
1447 set_fs (old_fs);
1448 if (put_flock(&f, (struct flock32 *)arg))
1449 return -EFAULT;
1450 return ret;
1451 }
1452 default:
1453 return sys_fcntl(fd, cmd, (unsigned long)arg);
1454 }
1455 }
1456
1457 asmlinkage long
1458 sys32_fcntl64(unsigned int fd, unsigned int cmd, unsigned long arg)
1459 {
1460 switch (cmd) {
1461 case F_GETLK64:
1462 return sys_fcntl(fd, F_GETLK, arg);
1463 case F_SETLK64:
1464 return sys_fcntl(fd, F_SETLK, arg);
1465 case F_SETLKW64:
1466 return sys_fcntl(fd, F_SETLKW, arg);
1467 }
1468
1469 return sys32_fcntl(fd, cmd, arg);
1470 }
1471
1472 struct msgbuf32 { s32 mtype; char mtext[1]; };
1473
1474 struct ipc_perm32
1475 {
1476 key_t key;
1477 __kernel_uid_t32 uid;
1478 __kernel_gid_t32 gid;
1479 __kernel_uid_t32 cuid;
1480 __kernel_gid_t32 cgid;
1481 __kernel_mode_t32 mode;
1482 unsigned short seq;
1483 };
1484
1485 struct semid_ds32 {
1486 struct ipc_perm32 sem_perm; /* permissions .. see ipc.h */
1487 __kernel_time_t32 sem_otime; /* last semop time */
1488 __kernel_time_t32 sem_ctime; /* last change time */
1489 u32 sem_base; /* ptr to first semaphore in array */
1490 u32 sem_pending; /* pending operations to be processed */
1491 u32 sem_pending_last; /* last pending operation */
1492 u32 undo; /* undo requests on this array */
1493 unsigned short sem_nsems; /* no. of semaphores in array */
1494 };
1495
1496 struct msqid_ds32
1497 {
1498 struct ipc_perm32 msg_perm;
1499 u32 msg_first;
1500 u32 msg_last;
1501 __kernel_time_t32 msg_stime;
1502 __kernel_time_t32 msg_rtime;
1503 __kernel_time_t32 msg_ctime;
1504 u32 wwait;
1505 u32 rwait;
1506 unsigned short msg_cbytes;
1507 unsigned short msg_qnum;
1508 unsigned short msg_qbytes;
1509 __kernel_ipc_pid_t32 msg_lspid;
1510 __kernel_ipc_pid_t32 msg_lrpid;
1511 };
1512
1513 struct shmid_ds32 {
1514 struct ipc_perm32 shm_perm;
1515 int shm_segsz;
1516 __kernel_time_t32 shm_atime;
1517 __kernel_time_t32 shm_dtime;
1518 __kernel_time_t32 shm_ctime;
1519 __kernel_ipc_pid_t32 shm_cpid;
1520 __kernel_ipc_pid_t32 shm_lpid;
1521 unsigned short shm_nattch;
1522 };
1523
1524 #define IPCOP_MASK(__x) (1UL << (__x))
1525
1526 static int
1527 do_sys32_semctl(int first, int second, int third, void *uptr)
1528 {
1529 union semun fourth;
1530 u32 pad;
1531 int err, err2;
1532 struct semid64_ds s;
1533 struct semid_ds32 *usp;
1534 mm_segment_t old_fs;
1535
1536 if (!uptr)
1537 return -EINVAL;
1538 err = -EFAULT;
1539 if (get_user (pad, (u32 *)uptr))
1540 return err;
1541 if ((third & ~IPC_64) == SETVAL)
1542 fourth.val = (int)pad;
1543 else
1544 fourth.__pad = (void *)A(pad);
1545 switch (third & ~IPC_64) {
1546
1547 case IPC_INFO:
1548 case IPC_RMID:
1549 case IPC_SET:
1550 case SEM_INFO:
1551 case GETVAL:
1552 case GETPID:
1553 case GETNCNT:
1554 case GETZCNT:
1555 case GETALL:
1556 case SETVAL:
1557 case SETALL:
1558 err = sys_semctl (first, second, third, fourth);
1559 break;
1560
1561 case IPC_STAT:
1562 case SEM_STAT:
1563 usp = (struct semid_ds32 *)A(pad);
1564 fourth.__pad = &s;
1565 old_fs = get_fs ();
1566 set_fs (KERNEL_DS);
1567 err = sys_semctl (first, second, third, fourth);
1568 set_fs (old_fs);
1569 err2 = put_user(s.sem_perm.key, &usp->sem_perm.key);
1570 err2 |= __put_user(s.sem_perm.uid, &usp->sem_perm.uid);
1571 err2 |= __put_user(s.sem_perm.gid, &usp->sem_perm.gid);
1572 err2 |= __put_user(s.sem_perm.cuid,
1573 &usp->sem_perm.cuid);
1574 err2 |= __put_user (s.sem_perm.cgid,
1575 &usp->sem_perm.cgid);
1576 err2 |= __put_user (s.sem_perm.mode,
1577 &usp->sem_perm.mode);
1578 err2 |= __put_user (s.sem_perm.seq, &usp->sem_perm.seq);
1579 err2 |= __put_user (s.sem_otime, &usp->sem_otime);
1580 err2 |= __put_user (s.sem_ctime, &usp->sem_ctime);
1581 err2 |= __put_user (s.sem_nsems, &usp->sem_nsems);
1582 if (err2)
1583 err = -EFAULT;
1584 break;
1585
1586 }
1587
1588 return err;
1589 }
1590
1591 static int
1592 do_sys32_msgsnd (int first, int second, int third, void *uptr)
1593 {
1594 struct msgbuf *p = kmalloc (second + sizeof (struct msgbuf)
1595 + 4, GFP_USER);
1596 struct msgbuf32 *up = (struct msgbuf32 *)uptr;
1597 mm_segment_t old_fs;
1598 int err;
1599
1600 if (!p)
1601 return -ENOMEM;
1602 err = get_user (p->mtype, &up->mtype);
1603 err |= __copy_from_user (p->mtext, &up->mtext, second);
1604 if (err)
1605 goto out;
1606 old_fs = get_fs ();
1607 set_fs (KERNEL_DS);
1608 err = sys_msgsnd (first, p, second, third);
1609 set_fs (old_fs);
1610 out:
1611 kfree (p);
1612 return err;
1613 }
1614
1615 static int
1616 do_sys32_msgrcv (int first, int second, int msgtyp, int third,
1617 int version, void *uptr)
1618 {
1619 struct msgbuf32 *up;
1620 struct msgbuf *p;
1621 mm_segment_t old_fs;
1622 int err;
1623
1624 if (!version) {
1625 struct ipc_kludge *uipck = (struct ipc_kludge *)uptr;
1626 struct ipc_kludge ipck;
1627
1628 err = -EINVAL;
1629 if (!uptr)
1630 goto out;
1631 err = -EFAULT;
1632 if (copy_from_user (&ipck, uipck, sizeof (struct ipc_kludge)))
1633 goto out;
1634 uptr = (void *)A(ipck.msgp);
1635 msgtyp = ipck.msgtyp;
1636 }
1637 err = -ENOMEM;
1638 p = kmalloc (second + sizeof (struct msgbuf) + 4, GFP_USER);
1639 if (!p)
1640 goto out;
1641 old_fs = get_fs ();
1642 set_fs (KERNEL_DS);
1643 err = sys_msgrcv (first, p, second + 4, msgtyp, third);
1644 set_fs (old_fs);
1645 if (err < 0)
1646 goto free_then_out;
1647 up = (struct msgbuf32 *)uptr;
1648 if (put_user (p->mtype, &up->mtype) ||
1649 __copy_to_user (&up->mtext, p->mtext, err))
1650 err = -EFAULT;
1651 free_then_out:
1652 kfree (p);
1653 out:
1654 return err;
1655 }
1656
1657 static int
1658 do_sys32_msgctl (int first, int second, void *uptr)
1659 {
1660 int err = -EINVAL, err2;
1661 struct msqid_ds m;
1662 struct msqid64_ds m64;
1663 struct msqid_ds32 *up = (struct msqid_ds32 *)uptr;
1664 mm_segment_t old_fs;
1665
1666 switch (second) {
1667
1668 case IPC_INFO:
1669 case IPC_RMID:
1670 case MSG_INFO:
1671 err = sys_msgctl (first, second, (struct msqid_ds *)uptr);
1672 break;
1673
1674 case IPC_SET:
1675 err = get_user (m.msg_perm.uid, &up->msg_perm.uid);
1676 err |= __get_user (m.msg_perm.gid, &up->msg_perm.gid);
1677 err |= __get_user (m.msg_perm.mode, &up->msg_perm.mode);
1678 err |= __get_user (m.msg_qbytes, &up->msg_qbytes);
1679 if (err)
1680 break;
1681 old_fs = get_fs ();
1682 set_fs (KERNEL_DS);
1683 err = sys_msgctl (first, second, &m);
1684 set_fs (old_fs);
1685 break;
1686
1687 case IPC_STAT:
1688 case MSG_STAT:
1689 old_fs = get_fs ();
1690 set_fs (KERNEL_DS);
1691 err = sys_msgctl (first, second, (void *) &m64);
1692 set_fs (old_fs);
1693 err2 = put_user (m64.msg_perm.key, &up->msg_perm.key);
1694 err2 |= __put_user(m64.msg_perm.uid, &up->msg_perm.uid);
1695 err2 |= __put_user(m64.msg_perm.gid, &up->msg_perm.gid);
1696 err2 |= __put_user(m64.msg_perm.cuid, &up->msg_perm.cuid);
1697 err2 |= __put_user(m64.msg_perm.cgid, &up->msg_perm.cgid);
1698 err2 |= __put_user(m64.msg_perm.mode, &up->msg_perm.mode);
1699 err2 |= __put_user(m64.msg_perm.seq, &up->msg_perm.seq);
1700 err2 |= __put_user(m64.msg_stime, &up->msg_stime);
1701 err2 |= __put_user(m64.msg_rtime, &up->msg_rtime);
1702 err2 |= __put_user(m64.msg_ctime, &up->msg_ctime);
1703 err2 |= __put_user(m64.msg_cbytes, &up->msg_cbytes);
1704 err2 |= __put_user(m64.msg_qnum, &up->msg_qnum);
1705 err2 |= __put_user(m64.msg_qbytes, &up->msg_qbytes);
1706 err2 |= __put_user(m64.msg_lspid, &up->msg_lspid);
1707 err2 |= __put_user(m64.msg_lrpid, &up->msg_lrpid);
1708 if (err2)
1709 err = -EFAULT;
1710 break;
1711
1712 }
1713
1714 return err;
1715 }
1716
1717 static int
1718 do_sys32_shmat (int first, int second, int third, int version, void *uptr)
1719 {
1720 unsigned long raddr;
1721 u32 *uaddr = (u32 *)A((u32)third);
1722 int err = -EINVAL;
1723
1724 if (version == 1)
1725 return err;
1726 if (version == 1)
1727 return err;
1728 err = sys_shmat (first, uptr, second, &raddr);
1729 if (err)
1730 return err;
1731 err = put_user (raddr, uaddr);
1732 return err;
1733 }
1734
1735 static int
1736 do_sys32_shmctl (int first, int second, void *uptr)
1737 {
1738 int err = -EFAULT, err2;
1739 struct shmid_ds s;
1740 struct shmid64_ds s64;
1741 struct shmid_ds32 *up = (struct shmid_ds32 *)uptr;
1742 mm_segment_t old_fs;
1743 struct shm_info32 {
1744 int used_ids;
1745 u32 shm_tot, shm_rss, shm_swp;
1746 u32 swap_attempts, swap_successes;
1747 } *uip = (struct shm_info32 *)uptr;
1748 struct shm_info si;
1749
1750 switch (second) {
1751
1752 case IPC_INFO:
1753 case IPC_RMID:
1754 case SHM_LOCK:
1755 case SHM_UNLOCK:
1756 err = sys_shmctl (first, second, (struct shmid_ds *)uptr);
1757 break;
1758 case IPC_SET:
1759 err = get_user (s.shm_perm.uid, &up->shm_perm.uid);
1760 err |= __get_user (s.shm_perm.gid, &up->shm_perm.gid);
1761 err |= __get_user (s.shm_perm.mode, &up->shm_perm.mode);
1762 if (err)
1763 break;
1764 old_fs = get_fs ();
1765 set_fs (KERNEL_DS);
1766 err = sys_shmctl (first, second, &s);
1767 set_fs (old_fs);
1768 break;
1769
1770 case IPC_STAT:
1771 case SHM_STAT:
1772 old_fs = get_fs ();
1773 set_fs (KERNEL_DS);
1774 err = sys_shmctl (first, second, (void *) &s64);
1775 set_fs (old_fs);
1776 if (err < 0)
1777 break;
1778 err2 = put_user (s64.shm_perm.key, &up->shm_perm.key);
1779 err2 |= __put_user (s64.shm_perm.uid, &up->shm_perm.uid);
1780 err2 |= __put_user (s64.shm_perm.gid, &up->shm_perm.gid);
1781 err2 |= __put_user (s64.shm_perm.cuid,
1782 &up->shm_perm.cuid);
1783 err2 |= __put_user (s64.shm_perm.cgid,
1784 &up->shm_perm.cgid);
1785 err2 |= __put_user (s64.shm_perm.mode,
1786 &up->shm_perm.mode);
1787 err2 |= __put_user (s64.shm_perm.seq, &up->shm_perm.seq);
1788 err2 |= __put_user (s64.shm_atime, &up->shm_atime);
1789 err2 |= __put_user (s64.shm_dtime, &up->shm_dtime);
1790 err2 |= __put_user (s64.shm_ctime, &up->shm_ctime);
1791 err2 |= __put_user (s64.shm_segsz, &up->shm_segsz);
1792 err2 |= __put_user (s64.shm_nattch, &up->shm_nattch);
1793 err2 |= __put_user (s64.shm_cpid, &up->shm_cpid);
1794 err2 |= __put_user (s64.shm_lpid, &up->shm_lpid);
1795 if (err2)
1796 err = -EFAULT;
1797 break;
1798
1799 case SHM_INFO:
1800 old_fs = get_fs ();
1801 set_fs (KERNEL_DS);
1802 err = sys_shmctl (first, second, (void *)&si);
1803 set_fs (old_fs);
1804 if (err < 0)
1805 break;
1806 err2 = put_user (si.used_ids, &uip->used_ids);
1807 err2 |= __put_user (si.shm_tot, &uip->shm_tot);
1808 err2 |= __put_user (si.shm_rss, &uip->shm_rss);
1809 err2 |= __put_user (si.shm_swp, &uip->shm_swp);
1810 err2 |= __put_user (si.swap_attempts,
1811 &uip->swap_attempts);
1812 err2 |= __put_user (si.swap_successes,
1813 &uip->swap_successes);
1814 if (err2)
1815 err = -EFAULT;
1816 break;
1817
1818 }
1819 return err;
1820 }
1821
1822 asmlinkage long
1823 sys32_ipc (u32 call, int first, int second, int third, u32 ptr, u32 fifth)
1824 {
1825 int version, err;
1826
1827 version = call >> 16; /* hack for backward compatibility */
1828 call &= 0xffff;
1829
1830 switch (call) {
1831
1832 case SEMOP:
1833 /* struct sembuf is the same on 32 and 64bit :)) */
1834 err = sys_semop (first, (struct sembuf *)A(ptr),
1835 second);
1836 break;
1837 case SEMGET:
1838 err = sys_semget (first, second, third);
1839 break;
1840 case SEMCTL:
1841 err = do_sys32_semctl (first, second, third,
1842 (void *)A(ptr));
1843 break;
1844
1845 case MSGSND:
1846 err = do_sys32_msgsnd (first, second, third,
1847 (void *)A(ptr));
1848 break;
1849 case MSGRCV:
1850 err = do_sys32_msgrcv (first, second, fifth, third,
1851 version, (void *)A(ptr));
1852 break;
1853 case MSGGET:
1854 err = sys_msgget ((key_t) first, second);
1855 break;
1856 case MSGCTL:
1857 err = do_sys32_msgctl (first, second, (void *)A(ptr));
1858 break;
1859
1860 case SHMAT:
1861 err = do_sys32_shmat (first, second, third,
1862 version, (void *)A(ptr));
1863 break;
1864 case SHMDT:
1865 err = sys_shmdt ((char *)A(ptr));
1866 break;
1867 case SHMGET:
1868 err = sys_shmget (first, second, third);
1869 break;
1870 case SHMCTL:
1871 err = do_sys32_shmctl (first, second, (void *)A(ptr));
1872 break;
1873 default:
1874 err = -EINVAL;
1875 break;
1876 }
1877
1878 return err;
1879 }
1880
1881 struct sysctl_args32
1882 {
1883 __kernel_caddr_t32 name;
1884 int nlen;
1885 __kernel_caddr_t32 oldval;
1886 __kernel_caddr_t32 oldlenp;
1887 __kernel_caddr_t32 newval;
1888 __kernel_size_t32 newlen;
1889 unsigned int __unused[4];
1890 };
1891
1892 asmlinkage long sys32_sysctl(struct sysctl_args32 *uargs32)
1893 {
1894 struct __sysctl_args kargs;
1895 struct sysctl_args32 kargs32;
1896 mm_segment_t old_fs;
1897 int name[CTL_MAXNAME];
1898 size_t oldlen[1];
1899 int err, ret;
1900
1901 ret = -EFAULT;
1902
1903 memset(&kargs, 0, sizeof (kargs));
1904
1905 err = get_user(kargs32.name, &uargs32->name);
1906 err |= __get_user(kargs32.nlen, &uargs32->nlen);
1907 err |= __get_user(kargs32.oldval, &uargs32->oldval);
1908 err |= __get_user(kargs32.oldlenp, &uargs32->oldlenp);
1909 err |= __get_user(kargs32.newval, &uargs32->newval);
1910 err |= __get_user(kargs32.newlen, &uargs32->newlen);
1911 if (err)
1912 goto out;
1913
1914 if (kargs32.nlen == 0 || kargs32.nlen >= CTL_MAXNAME) {
1915 ret = -ENOTDIR;
1916 goto out;
1917 }
1918
1919 kargs.name = name;
1920 kargs.nlen = kargs32.nlen;
1921 if (copy_from_user(kargs.name, (int *)A(kargs32.name),
1922 kargs32.nlen * sizeof(name) / sizeof(name[0])))
1923 goto out;
1924
1925 if (kargs32.oldval) {
1926 if (!kargs32.oldlenp || get_user(oldlen[0],
1927 (int *)A(kargs32.oldlenp)))
1928 return -EFAULT;
1929 kargs.oldlenp = oldlen;
1930 kargs.oldval = kmalloc(oldlen[0], GFP_KERNEL);
1931 if (!kargs.oldval) {
1932 ret = -ENOMEM;
1933 goto out;
1934 }
1935 }
1936
1937 if (kargs32.newval && kargs32.newlen) {
1938 kargs.newval = kmalloc(kargs32.newlen, GFP_KERNEL);
1939 if (!kargs.newval) {
1940 ret = -ENOMEM;
1941 goto out;
1942 }
1943 if (copy_from_user(kargs.newval, (int *)A(kargs32.newval),
1944 kargs32.newlen))
1945 goto out;
1946 }
1947
1948 old_fs = get_fs(); set_fs (KERNEL_DS);
1949 ret = sys_sysctl(&kargs);
1950 set_fs (old_fs);
1951
1952 if (ret)
1953 goto out;
1954
1955 if (kargs.oldval) {
1956 if (put_user(oldlen[0], (int *)A(kargs32.oldlenp)) ||
1957 copy_to_user((int *)A(kargs32.oldval), kargs.oldval,
1958 oldlen[0]))
1959 ret = -EFAULT;
1960 }
1961 out:
1962 if (kargs.oldval)
1963 kfree(kargs.oldval);
1964 if (kargs.newval)
1965 kfree(kargs.newval);
1966 return ret;
1967 }
1968
1969 asmlinkage long sys32_newuname(struct new_utsname * name)
1970 {
1971 int ret = 0;
1972
1973 down_read(&uts_sem);
1974 if (copy_to_user(name,&system_utsname,sizeof *name))
1975 ret = -EFAULT;
1976 up_read(&uts_sem);
1977
1978 if (current->personality == PER_LINUX32 && !ret)
1979 if (copy_to_user(name->machine, "mips\0\0\0", 8))
1980 ret = -EFAULT;
1981
1982 return ret;
1983 }
1984
1985 extern asmlinkage long sys_personality(unsigned long);
1986
1987 asmlinkage int sys32_personality(unsigned long personality)
1988 {
1989 int ret;
1990 if (current->personality == PER_LINUX32 && personality == PER_LINUX)
1991 personality = PER_LINUX32;
1992 ret = sys_personality(personality);
1993 if (ret == PER_LINUX32)
1994 ret = PER_LINUX;
1995 return ret;
1996 }
1997
1998 /* Handle adjtimex compatability. */
1999
2000 struct timex32 {
2001 u32 modes;
2002 s32 offset, freq, maxerror, esterror;
2003 s32 status, constant, precision, tolerance;
2004 struct timeval32 time;
2005 s32 tick;
2006 s32 ppsfreq, jitter, shift, stabil;
2007 s32 jitcnt, calcnt, errcnt, stbcnt;
2008 s32 :32; s32 :32; s32 :32; s32 :32;
2009 s32 :32; s32 :32; s32 :32; s32 :32;
2010 s32 :32; s32 :32; s32 :32; s32 :32;
2011 };
2012
2013 extern int do_adjtimex(struct timex *);
2014
2015 asmlinkage int sys32_adjtimex(struct timex32 *utp)
2016 {
2017 struct timex txc;
2018 int ret;
2019
2020 memset(&txc, 0, sizeof(struct timex));
2021
2022 if(get_user(txc.modes, &utp->modes) ||
2023 __get_user(txc.offset, &utp->offset) ||
2024 __get_user(txc.freq, &utp->freq) ||
2025 __get_user(txc.maxerror, &utp->maxerror) ||
2026 __get_user(txc.esterror, &utp->esterror) ||
2027 __get_user(txc.status, &utp->status) ||
2028 __get_user(txc.constant, &utp->constant) ||
2029 __get_user(txc.precision, &utp->precision) ||
2030 __get_user(txc.tolerance, &utp->tolerance) ||
2031 __get_user(txc.time.tv_sec, &utp->time.tv_sec) ||
2032 __get_user(txc.time.tv_usec, &utp->time.tv_usec) ||
2033 __get_user(txc.tick, &utp->tick) ||
2034 __get_user(txc.ppsfreq, &utp->ppsfreq) ||
2035 __get_user(txc.jitter, &utp->jitter) ||
2036 __get_user(txc.shift, &utp->shift) ||
2037 __get_user(txc.stabil, &utp->stabil) ||
2038 __get_user(txc.jitcnt, &utp->jitcnt) ||
2039 __get_user(txc.calcnt, &utp->calcnt) ||
2040 __get_user(txc.errcnt, &utp->errcnt) ||
2041 __get_user(txc.stbcnt, &utp->stbcnt))
2042 return -EFAULT;
2043
2044 ret = do_adjtimex(&txc);
2045
2046 if(put_user(txc.modes, &utp->modes) ||
2047 __put_user(txc.offset, &utp->offset) ||
2048 __put_user(txc.freq, &utp->freq) ||
2049 __put_user(txc.maxerror, &utp->maxerror) ||
2050 __put_user(txc.esterror, &utp->esterror) ||
2051 __put_user(txc.status, &utp->status) ||
2052 __put_user(txc.constant, &utp->constant) ||
2053 __put_user(txc.precision, &utp->precision) ||
2054 __put_user(txc.tolerance, &utp->tolerance) ||
2055 __put_user(txc.time.tv_sec, &utp->time.tv_sec) ||
2056 __put_user(txc.time.tv_usec, &utp->time.tv_usec) ||
2057 __put_user(txc.tick, &utp->tick) ||
2058 __put_user(txc.ppsfreq, &utp->ppsfreq) ||
2059 __put_user(txc.jitter, &utp->jitter) ||
2060 __put_user(txc.shift, &utp->shift) ||
2061 __put_user(txc.stabil, &utp->stabil) ||
2062 __put_user(txc.jitcnt, &utp->jitcnt) ||
2063 __put_user(txc.calcnt, &utp->calcnt) ||
2064 __put_user(txc.errcnt, &utp->errcnt) ||
2065 __put_user(txc.stbcnt, &utp->stbcnt))
2066 ret = -EFAULT;
2067
2068 return ret;
2069 }
2070
2071 /*
2072 * Declare the 32-bit version of the msghdr
2073 */
2074
2075 struct msghdr32 {
2076 unsigned int msg_name; /* Socket name */
2077 int msg_namelen; /* Length of name */
2078 unsigned int msg_iov; /* Data blocks */
2079 unsigned int msg_iovlen; /* Number of blocks */
2080 unsigned int msg_control; /* Per protocol magic (eg BSD file descriptor passing) */
2081 unsigned int msg_controllen; /* Length of cmsg list */
2082 unsigned msg_flags;
2083 };
2084
2085 static inline int
2086 shape_msg(struct msghdr *mp, struct msghdr32 *mp32)
2087 {
2088 int ret;
2089 unsigned int i;
2090
2091 if (!access_ok(VERIFY_READ, mp32, sizeof(*mp32)))
2092 return(-EFAULT);
2093 ret = __get_user(i, &mp32->msg_name);
2094 mp->msg_name = (void *)A(i);
2095 ret |= __get_user(mp->msg_namelen, &mp32->msg_namelen);
2096 ret |= __get_user(i, &mp32->msg_iov);
2097 mp->msg_iov = (struct iovec *)A(i);
2098 ret |= __get_user(mp->msg_iovlen, &mp32->msg_iovlen);
2099 ret |= __get_user(i, &mp32->msg_control);
2100 mp->msg_control = (void *)A(i);
2101 ret |= __get_user(mp->msg_controllen, &mp32->msg_controllen);
2102 ret |= __get_user(mp->msg_flags, &mp32->msg_flags);
2103 return(ret ? -EFAULT : 0);
2104 }
2105
2106 /*
2107 * Verify & re-shape IA32 iovec. The caller must ensure that the
2108 * iovec is big enough to hold the re-shaped message iovec.
2109 *
2110 * Save time not doing verify_area. copy_*_user will make this work
2111 * in any case.
2112 *
2113 * Don't need to check the total size for overflow (cf net/core/iovec.c),
2114 * 32-bit sizes can't overflow a 64-bit count.
2115 */
2116
2117 static inline int
2118 verify_iovec32(struct msghdr *m, struct iovec *iov, char *address, int mode)
2119 {
2120 int size, err, ct;
2121 struct iovec32 *iov32;
2122
2123 if(m->msg_namelen)
2124 {
2125 if(mode==VERIFY_READ)
2126 {
2127 err=move_addr_to_kernel(m->msg_name, m->msg_namelen, address);
2128 if(err<0)
2129 goto out;
2130 }
2131
2132 m->msg_name = address;
2133 } else
2134 m->msg_name = NULL;
2135
2136 err = -EFAULT;
2137 size = m->msg_iovlen * sizeof(struct iovec32);
2138 if (copy_from_user(iov, m->msg_iov, size))
2139 goto out;
2140 m->msg_iov=iov;
2141
2142 err = 0;
2143 iov32 = (struct iovec32 *)iov;
2144 for (ct = m->msg_iovlen; ct-- > 0; ) {
2145 iov[ct].iov_len = (__kernel_size_t)iov32[ct].iov_len;
2146 iov[ct].iov_base = (void *) A(iov32[ct].iov_base);
2147 err += iov[ct].iov_len;
2148 }
2149 out:
2150 return err;
2151 }
2152
2153 extern __inline__ void
2154 sockfd_put(struct socket *sock)
2155 {
2156 fput(sock->file);
2157 }
2158
2159 /* XXX This really belongs in some header file... -DaveM */
2160 #define MAX_SOCK_ADDR 128 /* 108 for Unix domain -
2161 16 for IP, 16 for IPX,
2162 24 for IPv6,
2163 about 80 for AX.25 */
2164
2165 extern struct socket *sockfd_lookup(int fd, int *err);
2166
2167 /*
2168 * BSD sendmsg interface
2169 */
2170
2171 int sys32_sendmsg(int fd, struct msghdr32 *msg, unsigned flags)
2172 {
2173 struct socket *sock;
2174 char address[MAX_SOCK_ADDR];
2175 struct iovec iovstack[UIO_FASTIOV], *iov = iovstack;
2176 unsigned char ctl[sizeof(struct cmsghdr) + 20]; /* 20 is size of ipv6_pktinfo */
2177 unsigned char *ctl_buf = ctl;
2178 struct msghdr msg_sys;
2179 int err, ctl_len, iov_size, total_len;
2180
2181 err = -EFAULT;
2182 if (shape_msg(&msg_sys, msg))
2183 goto out;
2184
2185 sock = sockfd_lookup(fd, &err);
2186 if (!sock)
2187 goto out;
2188
2189 /* do not move before msg_sys is valid */
2190 err = -EINVAL;
2191 if (msg_sys.msg_iovlen > UIO_MAXIOV)
2192 goto out_put;
2193
2194 /* Check whether to allocate the iovec area*/
2195 err = -ENOMEM;
2196 iov_size = msg_sys.msg_iovlen * sizeof(struct iovec32);
2197 if (msg_sys.msg_iovlen > UIO_FASTIOV) {
2198 iov = sock_kmalloc(sock->sk, iov_size, GFP_KERNEL);
2199 if (!iov)
2200 goto out_put;
2201 }
2202
2203 /* This will also move the address data into kernel space */
2204 err = verify_iovec32(&msg_sys, iov, address, VERIFY_READ);
2205 if (err < 0)
2206 goto out_freeiov;
2207 total_len = err;
2208
2209 err = -ENOBUFS;
2210
2211 if (msg_sys.msg_controllen > INT_MAX)
2212 goto out_freeiov;
2213 ctl_len = msg_sys.msg_controllen;
2214 if (ctl_len)
2215 {
2216 if (ctl_len > sizeof(ctl))
2217 {
2218 err = -ENOBUFS;
2219 ctl_buf = sock_kmalloc(sock->sk, ctl_len, GFP_KERNEL);
2220 if (ctl_buf == NULL)
2221 goto out_freeiov;
2222 }
2223 err = -EFAULT;
2224 if (copy_from_user(ctl_buf, msg_sys.msg_control, ctl_len))
2225 goto out_freectl;
2226 msg_sys.msg_control = ctl_buf;
2227 }
2228 msg_sys.msg_flags = flags;
2229
2230 if (sock->file->f_flags & O_NONBLOCK)
2231 msg_sys.msg_flags |= MSG_DONTWAIT;
2232 err = sock_sendmsg(sock, &msg_sys, total_len);
2233
2234 out_freectl:
2235 if (ctl_buf != ctl)
2236 sock_kfree_s(sock->sk, ctl_buf, ctl_len);
2237 out_freeiov:
2238 if (iov != iovstack)
2239 sock_kfree_s(sock->sk, iov, iov_size);
2240 out_put:
2241 sockfd_put(sock);
2242 out:
2243 return err;
2244 }
2245
2246 /*
2247 * BSD recvmsg interface
2248 */
2249
2250 int
2251 sys32_recvmsg (int fd, struct msghdr32 *msg, unsigned int flags)
2252 {
2253 struct socket *sock;
2254 struct iovec iovstack[UIO_FASTIOV];
2255 struct iovec *iov=iovstack;
2256 struct msghdr msg_sys;
2257 unsigned long cmsg_ptr;
2258 int err, iov_size, total_len, len;
2259
2260 /* kernel mode address */
2261 char addr[MAX_SOCK_ADDR];
2262
2263 /* user mode address pointers */
2264 struct sockaddr *uaddr;
2265 int *uaddr_len;
2266
2267 err=-EFAULT;
2268 if (shape_msg(&msg_sys, msg))
2269 goto out;
2270
2271 sock = sockfd_lookup(fd, &err);
2272 if (!sock)
2273 goto out;
2274
2275 err = -EINVAL;
2276 if (msg_sys.msg_iovlen > UIO_MAXIOV)
2277 goto out_put;
2278
2279 /* Check whether to allocate the iovec area*/
2280 err = -ENOMEM;
2281 iov_size = msg_sys.msg_iovlen * sizeof(struct iovec);
2282 if (msg_sys.msg_iovlen > UIO_FASTIOV) {
2283 iov = sock_kmalloc(sock->sk, iov_size, GFP_KERNEL);
2284 if (!iov)
2285 goto out_put;
2286 }
2287
2288 /*
2289 * Save the user-mode address (verify_iovec will change the
2290 * kernel msghdr to use the kernel address space)
2291 */
2292
2293 uaddr = msg_sys.msg_name;
2294 uaddr_len = &msg->msg_namelen;
2295 err = verify_iovec32(&msg_sys, iov, addr, VERIFY_WRITE);
2296 if (err < 0)
2297 goto out_freeiov;
2298 total_len=err;
2299
2300 cmsg_ptr = (unsigned long)msg_sys.msg_control;
2301 msg_sys.msg_flags = 0;
2302
2303 if (sock->file->f_flags & O_NONBLOCK)
2304 flags |= MSG_DONTWAIT;
2305 err = sock_recvmsg(sock, &msg_sys, total_len, flags);
2306 if (err < 0)
2307 goto out_freeiov;
2308 len = err;
2309
2310 if (uaddr != NULL) {
2311 err = move_addr_to_user(addr, msg_sys.msg_namelen, uaddr, uaddr_len);
2312 if (err < 0)
2313 goto out_freeiov;
2314 }
2315 err = __put_user(msg_sys.msg_flags, &msg->msg_flags);
2316 if (err)
2317 goto out_freeiov;
2318 err = __put_user((unsigned long)msg_sys.msg_control-cmsg_ptr,
2319 &msg->msg_controllen);
2320 if (err)
2321 goto out_freeiov;
2322 err = len;
2323
2324 out_freeiov:
2325 if (iov != iovstack)
2326 sock_kfree_s(sock->sk, iov, iov_size);
2327 out_put:
2328 sockfd_put(sock);
2329 out:
2330 return err;
2331 }
2332