开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
linux32.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：60k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

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