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

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

Linux/Unix编程

开发平台：

Unix_Linux

sys_ia32.c：源码内容
  1. /*
  2.  * sys_ia32.c: Conversion between 32bit and 64bit native syscalls. Based on
  3.  *             sys_sparc32 
  4.  *
  5.  * Copyright (C) 2000 VA Linux Co
  6.  * Copyright (C) 2000 Don Dugger <n0ano@valinux.com>
  7.  * Copyright (C) 1999  Arun Sharma <arun.sharma@intel.com>
  8.  * Copyright (C) 1997,1998  Jakub Jelinek (jj@sunsite.mff.cuni.cz)
  9.  * Copyright (C) 1997  David S. Miller (davem@caip.rutgers.edu)
  10.  * Copyright (C) 2000 Hewlett-Packard Co.
  11.  * Copyright (C) 2000 David Mosberger-Tang <davidm@hpl.hp.com>
  12.  * Copyright (C) 2000,2001 Andi Kleen, SuSE Labs (x86-64 port) 
  13.  *
  14.  * These routines maintain argument size conversion between 32bit and 64bit
  15.  * environment. In 2.5 most of this should be moved to a generic directory. 
  16.  *
  17.  * This file assumes that there is a hole at the end of user address space.
  18.  * $Id: sys_ia32.c,v 1.42 2002/09/17 15:23:41 ak Exp $
  19.  */
  21. #include <linux/config.h>
  22. #include <linux/kernel.h>
  23. #include <linux/sched.h>
  24. #include <linux/fs.h> 
  25. #include <linux/file.h> 
  26. #include <linux/signal.h>
  27. #include <linux/utime.h>
  28. #include <linux/resource.h>
  29. #include <linux/times.h>
  30. #include <linux/utsname.h>
  31. #include <linux/timex.h>
  32. #include <linux/smp.h>
  33. #include <linux/smp_lock.h>
  34. #include <linux/sem.h>
  35. #include <linux/msg.h>
  36. #include <linux/mm.h>
  37. #include <linux/shm.h>
  38. #include <linux/slab.h>
  39. #include <linux/uio.h>
  40. #include <linux/nfs_fs.h>
  41. #include <linux/smb_fs.h>
  42. #include <linux/smb_mount.h>
  43. #include <linux/ncp_fs.h>
  44. #include <linux/quota.h>
  45. #include <linux/module.h>
  46. #include <linux/sunrpc/svc.h>
  47. #include <linux/nfsd/nfsd.h>
  48. #include <linux/nfsd/cache.h>
  49. #include <linux/nfsd/xdr.h>
  50. #include <linux/nfsd/syscall.h>
  51. #include <linux/poll.h>
  52. #include <linux/personality.h>
  53. #include <linux/stat.h>
  54. #include <linux/ipc.h>
  55. #include <linux/rwsem.h>
  56. #include <linux/binfmts.h>
  57. #include <linux/init.h>
  58. #include <asm/mman.h>
  59. #include <asm/types.h>
  60. #include <asm/uaccess.h>
  61. #include <asm/semaphore.h>
  62. #include <asm/ipc.h>
  63. #include <asm/atomic.h>
  65. #include <net/scm.h>
  66. #include <net/sock.h>
  67. #include <asm/ia32.h>
  69. #define A(__x) ((unsigned long)(__x))
  70. #define AA(__x) ((unsigned long)(__x))
  71. #define ROUND_UP(x,a) ((__typeof__(x))(((unsigned long)(x) + ((a) - 1)) & ~((a) - 1)))
  72. #define NAME_OFFSET(de) ((int) ((de)->d_name - (char *) (de)))
  74. #undef high2lowuid
  75. #undef high2lowgid
  76. #undef low2highuid
  77. #undef low2highgid
  79. #define high2lowuid(uid) ((uid) > 65535) ? (u16)overflowuid : (u16)(uid)
  80. #define high2lowgid(gid) ((gid) > 65535) ? (u16)overflowgid : (u16)(gid)
  81. #define low2highuid(uid) ((uid) == (u16)-1) ? (uid_t)-1 : (uid_t)(uid)
  82. #define low2highgid(gid) ((gid) == (u16)-1) ? (gid_t)-1 : (gid_t)(gid)
  83. extern int overflowuid,overflowgid; 
  86. static int
  87. putstat(struct stat32 *ubuf, struct stat *kbuf)
  88. {
  89. if (verify_area(VERIFY_WRITE, ubuf, sizeof(struct stat32)) ||
  90.     __put_user (kbuf->st_dev, &ubuf->st_dev) ||
  91.     __put_user (kbuf->st_ino, &ubuf->st_ino) ||
  92.     __put_user (kbuf->st_mode, &ubuf->st_mode) ||
  93.     __put_user (kbuf->st_nlink, &ubuf->st_nlink) ||
  94.     __put_user (kbuf->st_uid, &ubuf->st_uid) ||
  95.     __put_user (kbuf->st_gid, &ubuf->st_gid) ||
  96.     __put_user (kbuf->st_rdev, &ubuf->st_rdev) ||
  97.     __put_user (kbuf->st_size, &ubuf->st_size) ||
  98.     __put_user (kbuf->st_atime, &ubuf->st_atime) ||
  99.     __put_user (kbuf->st_mtime, &ubuf->st_mtime) ||
  100.     __put_user (kbuf->st_ctime, &ubuf->st_ctime) ||
  101.     __put_user (kbuf->st_blksize, &ubuf->st_blksize) ||
  102.     __put_user (kbuf->st_blocks, &ubuf->st_blocks))
  103. return -EFAULT;
  104. return 0;
  105. }
  107. extern asmlinkage long sys_newstat(char * filename, struct stat * statbuf);
  109. asmlinkage long
  110. sys32_newstat(char * filename, struct stat32 *statbuf)
  111. {
  112. int ret;
  113. struct stat s;
  114. mm_segment_t old_fs = get_fs();
  116. set_fs (KERNEL_DS);
  117. ret = sys_newstat(filename, &s);
  118. set_fs (old_fs);
  119. if (putstat (statbuf, &s))
  120. return -EFAULT;
  121. return ret;
  122. }
  124. extern asmlinkage long sys_newlstat(char * filename, struct stat * statbuf);
  126. asmlinkage long
  127. sys32_newlstat(char * filename, struct stat32 *statbuf)
  128. {
  129. int ret;
  130. struct stat s;
  131. mm_segment_t old_fs = get_fs();
  133. set_fs (KERNEL_DS);
  134. ret = sys_newlstat(filename, &s);
  135. set_fs (old_fs);
  136. if (putstat (statbuf, &s))
  137. return -EFAULT;
  138. return ret;
  139. }
  141. extern asmlinkage long sys_newfstat(unsigned int fd, struct stat * statbuf);
  143. asmlinkage long
  144. sys32_newfstat(unsigned int fd, struct stat32 *statbuf)
  145. {
  146. int ret;
  147. struct stat s;
  148. mm_segment_t old_fs = get_fs();
  150. set_fs (KERNEL_DS);
  151. ret = sys_newfstat(fd, &s);
  152. set_fs (old_fs);
  153. if (putstat (statbuf, &s))
  154. return -EFAULT;
  155. return ret;
  156. }
  158. /* Another set for IA32/LFS -- x86_64 struct stat is different due to 
  159.    support for 64bit inode numbers. */
  161. static int
  162. putstat64(struct stat64 *ubuf, struct stat *kbuf)
  163. {
  164. if (verify_area(VERIFY_WRITE, ubuf, sizeof(struct stat64)) ||
  165.     __put_user (kbuf->st_dev, &ubuf->st_dev) ||
  166.     __put_user (kbuf->st_ino, &ubuf->__st_ino) ||
  167.     __put_user (kbuf->st_ino, &ubuf->st_ino) ||
  168.     __put_user (kbuf->st_mode, &ubuf->st_mode) ||
  169.     __put_user (kbuf->st_nlink, &ubuf->st_nlink) ||
  170.     __put_user (kbuf->st_uid, &ubuf->st_uid) ||
  171.     __put_user (kbuf->st_gid, &ubuf->st_gid) ||
  172.     __put_user (kbuf->st_rdev, &ubuf->st_rdev) ||
  173.     __put_user (kbuf->st_size, &ubuf->st_size) ||
  174.     __put_user (kbuf->st_atime, &ubuf->st_atime) ||
  175.     __put_user (kbuf->st_mtime, &ubuf->st_mtime) ||
  176.     __put_user (kbuf->st_ctime, &ubuf->st_ctime) ||
  177.     __put_user (kbuf->st_blksize, &ubuf->st_blksize) ||
  178.     __put_user (kbuf->st_blocks, &ubuf->st_blocks))
  179. return -EFAULT;
  180. return 0;
  181. }
  183. asmlinkage long
  184. sys32_stat64(char * filename, struct stat64 *statbuf)
  185. {
  186. int ret;
  187. struct stat s;
  188. mm_segment_t old_fs = get_fs();
  190. set_fs (KERNEL_DS);
  191. ret = sys_newstat(filename, &s);
  192. set_fs (old_fs);
  193. if (putstat64 (statbuf, &s))
  194. return -EFAULT;
  195. return ret;
  196. }
  198. asmlinkage long
  199. sys32_lstat64(char * filename, struct stat64 *statbuf)
  200. {
  201. int ret;
  202. struct stat s;
  203. mm_segment_t old_fs = get_fs();
  205. set_fs (KERNEL_DS);
  206. ret = sys_newlstat(filename, &s);
  207. set_fs (old_fs);
  208. if (putstat64 (statbuf, &s))
  209. return -EFAULT;
  210. return ret;
  211. }
  213. asmlinkage long
  214. sys32_fstat64(unsigned int fd, struct stat64 *statbuf)
  215. {
  216. int ret;
  217. struct stat s;
  218. mm_segment_t old_fs = get_fs();
  220. set_fs (KERNEL_DS);
  221. ret = sys_newfstat(fd, &s);
  222. set_fs (old_fs);
  223. if (putstat64 (statbuf, &s))
  224. return -EFAULT;
  225. return ret;
  226. }
  230. /*
  231.  * Linux/i386 didn't use to be able to handle more than
  232.  * 4 system call parameters, so these system calls used a memory
  233.  * block for parameter passing..
  234.  */
  236. struct mmap_arg_struct {
  237. unsigned int addr;
  238. unsigned int len;
  239. unsigned int prot;
  240. unsigned int flags;
  241. unsigned int fd;
  242. unsigned int offset;
  243. };
  245. asmlinkage __u32
  246. sys32_mmap(struct mmap_arg_struct *arg)
  247. {
  248. struct mmap_arg_struct a;
  249. struct file *file = NULL;
  250. unsigned long retval;
  251. struct mm_struct *mm ;
  253. if (copy_from_user(&a, arg, sizeof(a)))
  254. return -EFAULT;
  256. if (a.offset & ~PAGE_MASK)
  257. return -EINVAL; 
  259. if (!(a.flags & MAP_ANONYMOUS)) {
  260. file = fget(a.fd);
  261. if (!file)
  262. return -EBADF;
  263. }
  264. if (a.prot & PROT_READ) 
  265. a.prot |= PROT_EXEC; 
  267. a.flags |= MAP_32BIT;
  269. mm = current->mm; 
  270. down_write(&mm->mmap_sem); 
  271. retval = do_mmap_pgoff(file, a.addr, a.len, a.prot, a.flags, a.offset>>PAGE_SHIFT);
  272. if (file)
  273. fput(file);
  275. /* Should not happen */
  276. if (retval >= 0xFFFFFFFF && (long)retval > 0) { 
  277. do_munmap(mm, retval, a.len); 
  278. retval = -ENOMEM; 
  279. } 
  280. up_write(&mm->mmap_sem); 
  282. return retval;
  283. }
  285. extern asmlinkage long sys_mprotect(unsigned long start,size_t len,unsigned long prot);
  287. asmlinkage int sys32_mprotect(unsigned long start, size_t len, unsigned long prot)
  288. {
  289. if (prot & PROT_READ) 
  290. prot |= PROT_EXEC; 
  291. return sys_mprotect(start,len,prot); 
  292. }
  294. asmlinkage long
  295. sys32_pipe(int *fd)
  296. {
  297. int retval;
  298. int fds[2];
  300. retval = do_pipe(fds);
  301. if (retval)
  302. goto out;
  303. if (copy_to_user(fd, fds, sizeof(fds)))
  304. retval = -EFAULT;
  305.   out:
  306. return retval;
  307. }
  309. asmlinkage long
  310. sys32_rt_sigaction(int sig, struct sigaction32 *act,
  311.    struct sigaction32 *oact,  unsigned int sigsetsize)
  312. {
  313. struct k_sigaction new_ka, old_ka;
  314. int ret;
  315. sigset32_t set32;
  317. /* XXX: Don't preclude handling different sized sigset_t's.  */
  318. if (sigsetsize != sizeof(sigset32_t))
  319. return -EINVAL;
  321. if (act) {
  322. if (verify_area(VERIFY_READ, act, sizeof(*act)) ||
  323.     __get_user((long)new_ka.sa.sa_handler, &act->sa_handler) ||
  324.     __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
  325.     __get_user((long)new_ka.sa.sa_restorer, &act->sa_restorer)||
  326.     __copy_from_user(&set32, &act->sa_mask, sizeof(sigset32_t)))
  327. return -EFAULT;
  329. /* FIXME: here we rely on _IA32_NSIG_WORS to be >= than _NSIG_WORDS << 1 */
  330. switch (_NSIG_WORDS) {
  331. case 4: new_ka.sa.sa_mask.sig[3] = set32.sig[6]
  332. | (((long)set32.sig[7]) << 32);
  333. case 3: new_ka.sa.sa_mask.sig[2] = set32.sig[4]
  334. | (((long)set32.sig[5]) << 32);
  335. case 2: new_ka.sa.sa_mask.sig[1] = set32.sig[2]
  336. | (((long)set32.sig[3]) << 32);
  337. case 1: new_ka.sa.sa_mask.sig[0] = set32.sig[0]
  338. | (((long)set32.sig[1]) << 32);
  339. }
  340. }
  342. ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
  344. if (!ret && oact) {
  345. /* FIXME: here we rely on _IA32_NSIG_WORS to be >= than _NSIG_WORDS << 1 */
  346. switch (_NSIG_WORDS) {
  347. case 4:
  348. set32.sig[7] = (old_ka.sa.sa_mask.sig[3] >> 32);
  349. set32.sig[6] = old_ka.sa.sa_mask.sig[3];
  350. case 3:
  351. set32.sig[5] = (old_ka.sa.sa_mask.sig[2] >> 32);
  352. set32.sig[4] = old_ka.sa.sa_mask.sig[2];
  353. case 2:
  354. set32.sig[3] = (old_ka.sa.sa_mask.sig[1] >> 32);
  355. set32.sig[2] = old_ka.sa.sa_mask.sig[1];
  356. case 1:
  357. set32.sig[1] = (old_ka.sa.sa_mask.sig[0] >> 32);
  358. set32.sig[0] = old_ka.sa.sa_mask.sig[0];
  359. }
  360. if (verify_area(VERIFY_WRITE, oact, sizeof(*oact)) ||
  361.     __put_user((long)old_ka.sa.sa_handler, &oact->sa_handler) ||
  362.     __put_user((long)old_ka.sa.sa_restorer, &oact->sa_restorer) ||
  363.     __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
  364.     __copy_to_user(&oact->sa_mask, &set32, sizeof(sigset32_t)))
  365. return -EFAULT;
  366. }
  368. return ret;
  369. }
  371. asmlinkage long
  372. sys32_sigaction (int sig, struct old_sigaction32 *act, struct old_sigaction32 *oact)
  373. {
  374.         struct k_sigaction new_ka, old_ka;
  375.         int ret;
  377.         if (act) {
  378. old_sigset32_t mask;
  380. if (verify_area(VERIFY_READ, act, sizeof(*act)) ||
  381.     __get_user((long)new_ka.sa.sa_handler, &act->sa_handler) ||
  382.     __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
  383.     __get_user((long)new_ka.sa.sa_restorer, &act->sa_restorer) ||
  384.     __get_user(mask, &act->sa_mask))
  385. return -EFAULT;
  386. siginitset(&new_ka.sa.sa_mask, mask);
  387.         }
  389.         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
  391. if (!ret && oact) {
  392. if (verify_area(VERIFY_WRITE, oact, sizeof(*oact)) ||
  393.     __put_user((long)old_ka.sa.sa_handler, &oact->sa_handler) ||
  394.     __put_user((long)old_ka.sa.sa_restorer, &oact->sa_restorer) ||
  395.     __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
  396.     __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
  397. return -EFAULT;
  398.         }
  400. return ret;
  401. }
  403. extern asmlinkage long sys_rt_sigprocmask(int how, sigset_t *set, sigset_t *oset,
  404.   size_t sigsetsize);
  406. asmlinkage long
  407. sys32_rt_sigprocmask(int how, sigset32_t *set, sigset32_t *oset,
  408.      unsigned int sigsetsize)
  409. {
  410. sigset_t s;
  411. sigset32_t s32;
  412. int ret;
  413. mm_segment_t old_fs = get_fs();
  415. if (set) {
  416. if (copy_from_user (&s32, set, sizeof(sigset32_t)))
  417. return -EFAULT;
  418. switch (_NSIG_WORDS) {
  419. case 4: s.sig[3] = s32.sig[6] | (((long)s32.sig[7]) << 32);
  420. case 3: s.sig[2] = s32.sig[4] | (((long)s32.sig[5]) << 32);
  421. case 2: s.sig[1] = s32.sig[2] | (((long)s32.sig[3]) << 32);
  422. case 1: s.sig[0] = s32.sig[0] | (((long)s32.sig[1]) << 32);
  423. }
  424. }
  425. set_fs (KERNEL_DS);
  426. ret = sys_rt_sigprocmask(how, set ? &s : NULL, oset ? &s : NULL,
  427.  sigsetsize); 
  428. set_fs (old_fs);
  429. if (ret) return ret;
  430. if (oset) {
  431. switch (_NSIG_WORDS) {
  432. case 4: s32.sig[7] = (s.sig[3] >> 32); s32.sig[6] = s.sig[3];
  433. case 3: s32.sig[5] = (s.sig[2] >> 32); s32.sig[4] = s.sig[2];
  434. case 2: s32.sig[3] = (s.sig[1] >> 32); s32.sig[2] = s.sig[1];
  435. case 1: s32.sig[1] = (s.sig[0] >> 32); s32.sig[0] = s.sig[0];
  436. }
  437. if (copy_to_user (oset, &s32, sizeof(sigset32_t)))
  438. return -EFAULT;
  439. }
  440. return 0;
  441. }
  443. static int
  444. put_statfs (struct statfs32 *ubuf, struct statfs *kbuf)
  445. {
  446. if (verify_area(VERIFY_WRITE, ubuf, sizeof(struct statfs32)) ||
  447.     __put_user (kbuf->f_type, &ubuf->f_type) ||
  448.     __put_user (kbuf->f_bsize, &ubuf->f_bsize) ||
  449.     __put_user (kbuf->f_blocks, &ubuf->f_blocks) ||
  450.     __put_user (kbuf->f_bfree, &ubuf->f_bfree) ||
  451.     __put_user (kbuf->f_bavail, &ubuf->f_bavail) ||
  452.     __put_user (kbuf->f_files, &ubuf->f_files) ||
  453.     __put_user (kbuf->f_ffree, &ubuf->f_ffree) ||
  454.     __put_user (kbuf->f_namelen, &ubuf->f_namelen) ||
  455.     __put_user (kbuf->f_fsid.val[0], &ubuf->f_fsid.val[0]) ||
  456.     __put_user (kbuf->f_fsid.val[1], &ubuf->f_fsid.val[1]))
  457. return -EFAULT;
  458. return 0;
  459. }
  461. extern asmlinkage long sys_statfs(const char * path, struct statfs * buf);
  463. asmlinkage long
  464. sys32_statfs(const char * path, struct statfs32 *buf)
  465. {
  466. int ret;
  467. struct statfs s;
  468. mm_segment_t old_fs = get_fs();
  470. set_fs (KERNEL_DS);
  471. ret = sys_statfs((const char *)path, &s);
  472. set_fs (old_fs);
  473. if (put_statfs(buf, &s))
  474. return -EFAULT;
  475. return ret;
  476. }
  478. extern asmlinkage long sys_fstatfs(unsigned int fd, struct statfs * buf);
  480. asmlinkage long
  481. sys32_fstatfs(unsigned int fd, struct statfs32 *buf)
  482. {
  483. int ret;
  484. struct statfs s;
  485. mm_segment_t old_fs = get_fs();
  487. set_fs (KERNEL_DS);
  488. ret = sys_fstatfs(fd, &s);
  489. set_fs (old_fs);
  490. if (put_statfs(buf, &s))
  491. return -EFAULT;
  492. return ret;
  493. }
  495. struct timeval32
  496. {
  497.     int tv_sec, tv_usec;
  498. };
  500. struct itimerval32
  501. {
  502.     struct timeval32 it_interval;
  503.     struct timeval32 it_value;
  504. };
  506. static inline long
  507. get_tv32(struct timeval *o, struct timeval32 *i)
  508. {
  509. int err = -EFAULT; 
  510. if (access_ok(VERIFY_READ, i, sizeof(*i))) { 
  511. err = __get_user(o->tv_sec, &i->tv_sec);
  512. err |= __get_user(o->tv_usec, &i->tv_usec);
  513. }
  514. return err; 
  515. }
  517. static inline long
  518. put_tv32(struct timeval32 *o, struct timeval *i)
  519. {
  520. int err = -EFAULT;
  521. if (access_ok(VERIFY_WRITE, o, sizeof(*o))) { 
  522. err = __put_user(i->tv_sec, &o->tv_sec);
  523. err |= __put_user(i->tv_usec, &o->tv_usec);
  524. } 
  525. return err; 
  526. }
  528. static inline long
  529. get_it32(struct itimerval *o, struct itimerval32 *i)
  530. {
  531. int err = -EFAULT; 
  532. if (access_ok(VERIFY_READ, i, sizeof(*i))) { 
  533. err = __get_user(o->it_interval.tv_sec, &i->it_interval.tv_sec);
  534. err |= __get_user(o->it_interval.tv_usec, &i->it_interval.tv_usec);
  535. err |= __get_user(o->it_value.tv_sec, &i->it_value.tv_sec);
  536. err |= __get_user(o->it_value.tv_usec, &i->it_value.tv_usec);
  537. }
  538. return err;
  539. }
  541. static inline long
  542. put_it32(struct itimerval32 *o, struct itimerval *i)
  543. {
  544. int err = -EFAULT;
  545. if (access_ok(VERIFY_WRITE, o, sizeof(*o))) {
  546. err = __put_user(i->it_interval.tv_sec, &o->it_interval.tv_sec);
  547. err |= __put_user(i->it_interval.tv_usec, &o->it_interval.tv_usec);
  548. err |= __put_user(i->it_value.tv_sec, &o->it_value.tv_sec);
  549. err |= __put_user(i->it_value.tv_usec, &o->it_value.tv_usec); 
  550. } 
  551. return err;
  552. }
  554. extern int do_getitimer(int which, struct itimerval *value);
  556. asmlinkage long
  557. sys32_getitimer(int which, struct itimerval32 *it)
  558. {
  559. struct itimerval kit;
  560. int error;
  562. error = do_getitimer(which, &kit);
  563. if (!error && put_it32(it, &kit))
  564. error = -EFAULT;
  566. return error;
  567. }
  569. extern int do_setitimer(int which, struct itimerval *, struct itimerval *);
  571. asmlinkage long
  572. sys32_setitimer(int which, struct itimerval32 *in, struct itimerval32 *out)
  573. {
  574. struct itimerval kin, kout;
  575. int error;
  577. if (in) {
  578. if (get_it32(&kin, in))
  579. return -EFAULT;
  580. } else
  581. memset(&kin, 0, sizeof(kin));
  583. error = do_setitimer(which, &kin, out ? &kout : NULL);
  584. if (error || !out)
  585. return error;
  586. if (put_it32(out, &kout))
  587. return -EFAULT;
  589. return 0;
  591. }
  592. asmlinkage unsigned long 
  593. sys32_alarm(unsigned int seconds)
  594. {
  595. struct itimerval it_new, it_old;
  596. unsigned int oldalarm;
  598. it_new.it_interval.tv_sec = it_new.it_interval.tv_usec = 0;
  599. it_new.it_value.tv_sec = seconds;
  600. it_new.it_value.tv_usec = 0;
  601. do_setitimer(ITIMER_REAL, &it_new, &it_old);
  602. oldalarm = it_old.it_value.tv_sec;
  603. /* ehhh.. We can't return 0 if we have an alarm pending.. */
  604. /* And we'd better return too much than too little anyway */
  605. if (it_old.it_value.tv_usec)
  606. oldalarm++;
  607. return oldalarm;
  608. }
  610. /* Translations due to time_t size differences.  Which affects all
  611.    sorts of things, like timeval and itimerval.  */
  613. struct utimbuf_32 {
  614. int atime;
  615. int mtime;
  616. };
  618. extern asmlinkage long sys_utimes(char * filename, struct timeval * utimes);
  619. extern asmlinkage long sys_gettimeofday (struct timeval *tv, struct timezone *tz);
  621. extern struct timezone sys_tz;
  622. extern int do_sys_settimeofday(struct timeval *tv, struct timezone *tz);
  624. asmlinkage long
  625. sys32_gettimeofday(struct timeval32 *tv, struct timezone *tz)
  626. {
  627. if (tv) {
  628. struct timeval ktv;
  629. do_gettimeofday(&ktv);
  630. if (put_tv32(tv, &ktv))
  631. return -EFAULT;
  632. }
  633. if (tz) {
  634. if (copy_to_user(tz, &sys_tz, sizeof(sys_tz)))
  635. return -EFAULT;
  636. }
  637. return 0;
  638. }
  640. asmlinkage long
  641. sys32_settimeofday(struct timeval32 *tv, struct timezone *tz)
  642. {
  643. struct timeval ktv;
  644. struct timezone ktz;
  646.   if (tv) {
  647. if (get_tv32(&ktv, tv))
  648. return -EFAULT;
  649. }
  650. if (tz) {
  651. if (copy_from_user(&ktz, tz, sizeof(ktz)))
  652. return -EFAULT;
  653. }
  655. return do_sys_settimeofday(tv ? &ktv : NULL, tz ? &ktz : NULL);
  656. }
  658. struct linux32_dirent {
  659. u32 d_ino;
  660. u32 d_off;
  661. u16 d_reclen;
  662. char d_name[1];
  663. };
  665. struct old_linux32_dirent {
  666. u32 d_ino;
  667. u32 d_offset;
  668. u16 d_namlen;
  669. char d_name[1];
  670. };
  672. struct getdents32_callback {
  673. struct linux32_dirent * current_dir;
  674. struct linux32_dirent * previous;
  675. int count;
  676. int error;
  677. };
  679. struct readdir32_callback {
  680. struct old_linux32_dirent * dirent;
  681. int count;
  682. };
  684. static int
  685. filldir32 (void *__buf, const char *name, int namlen, loff_t offset, ino_t ino,
  686.    unsigned int d_type)
  687. {
  688. struct linux32_dirent * dirent;
  689. struct getdents32_callback * buf = (struct getdents32_callback *) __buf;
  690. int reclen = ROUND_UP(NAME_OFFSET(dirent) + namlen + 1, 4);
  692. buf->error = -EINVAL; /* only used if we fail.. */
  693. if (reclen > buf->count)
  694. return -EINVAL;
  695. dirent = buf->previous;
  696. if (dirent)
  697. put_user(offset, &dirent->d_off);
  698. dirent = buf->current_dir;
  699. buf->previous = dirent;
  700. put_user(ino, &dirent->d_ino);
  701. put_user(reclen, &dirent->d_reclen);
  702. copy_to_user(dirent->d_name, name, namlen);
  703. put_user(0, dirent->d_name + namlen);
  704. ((char *) dirent) += reclen;
  705. buf->current_dir = dirent;
  706. buf->count -= reclen;
  707. return 0;
  708. }
  710. asmlinkage long
  711. sys32_getdents (unsigned int fd, void * dirent, unsigned int count)
  712. {
  713. struct file * file;
  714. struct linux32_dirent * lastdirent;
  715. struct getdents32_callback buf;
  716. int error;
  718. error = -EBADF;
  719. file = fget(fd);
  720. if (!file)
  721. goto out;
  723. buf.current_dir = (struct linux32_dirent *) dirent;
  724. buf.previous = NULL;
  725. buf.count = count;
  726. buf.error = 0;
  728. error = vfs_readdir(file, filldir32, &buf);
  729. if (error < 0)
  730. goto out_putf;
  731. error = buf.error;
  732. lastdirent = buf.previous;
  733. if (lastdirent) {
  734. put_user(file->f_pos, &lastdirent->d_off);
  735. error = count - buf.count;
  736. }
  738. out_putf:
  739. fput(file);
  740. out:
  741. return error;
  742. }
  744. static int
  745. fillonedir32 (void * __buf, const char * name, int namlen, loff_t offset, ino_t ino, unsigned d_type)
  746. {
  747. struct readdir32_callback * buf = (struct readdir32_callback *) __buf;
  748. struct old_linux32_dirent * dirent;
  750. if (buf->count)
  751. return -EINVAL;
  752. buf->count++;
  753. dirent = buf->dirent;
  754. put_user(ino, &dirent->d_ino);
  755. put_user(offset, &dirent->d_offset);
  756. put_user(namlen, &dirent->d_namlen);
  757. copy_to_user(dirent->d_name, name, namlen);
  758. put_user(0, dirent->d_name + namlen);
  759. return 0;
  760. }
  762. asmlinkage long
  763. sys32_oldreaddir (unsigned int fd, void * dirent, unsigned int count)
  764. {
  765. int error;
  766. struct file * file;
  767. struct readdir32_callback buf;
  769. error = -EBADF;
  770. file = fget(fd);
  771. if (!file)
  772. goto out;
  774. buf.count = 0;
  775. buf.dirent = dirent;
  777. error = vfs_readdir(file, fillonedir32, &buf);
  778. if (error >= 0)
  779. error = buf.count;
  780. fput(file);
  781. out:
  782. return error;
  783. }
  785. /*
  786.  * We can actually return ERESTARTSYS instead of EINTR, but I'd
  787.  * like to be certain this leads to no problems. So I return
  788.  * EINTR just for safety.
  789.  *
  790.  * Update: ERESTARTSYS breaks at least the xview clock binary, so
  791.  * I'm trying ERESTARTNOHAND which restart only when you want to.
  792.  */
  793. #define MAX_SELECT_SECONDS 
  794. ((unsigned long) (MAX_SCHEDULE_TIMEOUT / HZ)-1)
  795. #define ROUND_UP_TIME(x,y) (((x)+(y)-1)/(y))
  797. asmlinkage long
  798. sys32_select(int n, fd_set *inp, fd_set *outp, fd_set *exp, struct timeval32 *tvp32)
  799. {
  800. fd_set_bits fds;
  801. char *bits;
  802. long timeout;
  803. int ret, size;
  805. timeout = MAX_SCHEDULE_TIMEOUT;
  806. if (tvp32) {
  807. time_t sec, usec;
  809. get_user(sec, &tvp32->tv_sec);
  810. get_user(usec, &tvp32->tv_usec);
  812. ret = -EINVAL;
  813. if (sec < 0 || usec < 0)
  814. goto out_nofds;
  816. if ((unsigned long) sec < MAX_SELECT_SECONDS) {
  817. timeout = ROUND_UP_TIME(usec, 1000000/HZ);
  818. timeout += sec * (unsigned long) HZ;
  819. }
  820. }
  822. ret = -EINVAL;
  823. if (n < 0)
  824. goto out_nofds;
  826. if (n > current->files->max_fdset)
  827. n = current->files->max_fdset;
  829. /*
  830.  * We need 6 bitmaps (in/out/ex for both incoming and outgoing),
  831.  * since we used fdset we need to allocate memory in units of
  832.  * long-words. 
  833.  */
  834. ret = -ENOMEM;
  835. size = FDS_BYTES(n);
  836. bits = kmalloc(6 * size, GFP_KERNEL);
  837. if (!bits)
  838. goto out_nofds;
  839. fds.in      = (unsigned long *)  bits;
  840. fds.out     = (unsigned long *) (bits +   size);
  841. fds.ex      = (unsigned long *) (bits + 2*size);
  842. fds.res_in  = (unsigned long *) (bits + 3*size);
  843. fds.res_out = (unsigned long *) (bits + 4*size);
  844. fds.res_ex  = (unsigned long *) (bits + 5*size);
  846. if ((ret = get_fd_set(n, inp, fds.in)) ||
  847.     (ret = get_fd_set(n, outp, fds.out)) ||
  848.     (ret = get_fd_set(n, exp, fds.ex)))
  849. goto out;
  850. zero_fd_set(n, fds.res_in);
  851. zero_fd_set(n, fds.res_out);
  852. zero_fd_set(n, fds.res_ex);
  854. ret = do_select(n, &fds, &timeout);
  856. if (tvp32 && !(current->personality & STICKY_TIMEOUTS)) {
  857. time_t sec = 0, usec = 0;
  858. if (timeout) {
  859. sec = timeout / HZ;
  860. usec = timeout % HZ;
  861. usec *= (1000000/HZ);
  862. }
  863. put_user(sec, (int *)&tvp32->tv_sec);
  864. put_user(usec, (int *)&tvp32->tv_usec);
  865. }
  867. if (ret < 0)
  868. goto out;
  869. if (!ret) {
  870. ret = -ERESTARTNOHAND;
  871. if (signal_pending(current))
  872. goto out;
  873. ret = 0;
  874. }
  876. set_fd_set(n, inp, fds.res_in);
  877. set_fd_set(n, outp, fds.res_out);
  878. set_fd_set(n, exp, fds.res_ex);
  880. out:
  881. kfree(bits);
  882. out_nofds:
  883. return ret;
  884. }
  886. struct sel_arg_struct {
  887. unsigned int n;
  888. unsigned int inp;
  889. unsigned int outp;
  890. unsigned int exp;
  891. unsigned int tvp;
  892. };
  894. asmlinkage long
  895. sys32_old_select(struct sel_arg_struct *arg)
  896. {
  897. struct sel_arg_struct a;
  899. if (copy_from_user(&a, arg, sizeof(a)))
  900. return -EFAULT;
  901. return sys32_select(a.n, (fd_set *)A(a.inp), (fd_set *)A(a.outp), (fd_set *)A(a.exp),
  902.     (struct timeval32 *)A(a.tvp));
  903. }
  905. struct timespec32 {
  906. int  tv_sec;
  907. int tv_nsec;
  908. };
  910. extern asmlinkage long sys_nanosleep(struct timespec *rqtp, struct timespec *rmtp); 
  912. asmlinkage long
  913. sys32_nanosleep(struct timespec32 *rqtp, struct timespec32 *rmtp)
  914. {
  915. struct timespec t;
  916. int ret;
  917. mm_segment_t old_fs = get_fs ();
  919. if (verify_area(VERIFY_READ, rqtp, sizeof(struct timespec32)) ||
  920.     __get_user (t.tv_sec, &rqtp->tv_sec) ||
  921.     __get_user (t.tv_nsec, &rqtp->tv_nsec))
  922. return -EFAULT;
  923. set_fs (KERNEL_DS);
  924. ret = sys_nanosleep(&t, rmtp ? &t : NULL);
  925. set_fs (old_fs);
  926. if (rmtp && ret == -EINTR) {
  927. if (verify_area(VERIFY_WRITE, rmtp, sizeof(struct timespec32)) ||
  928.     __put_user (t.tv_sec, &rmtp->tv_sec) ||
  929.          __put_user (t.tv_nsec, &rmtp->tv_nsec))
  930. return -EFAULT;
  931. }
  932. return ret;
  933. }
  935. asmlinkage ssize_t sys_readv(unsigned long,const struct iovec *,unsigned long);
  936. asmlinkage ssize_t sys_writev(unsigned long,const struct iovec *,unsigned long);
  938. struct iovec *
  939. get_iovec32(struct iovec32 *iov32, struct iovec *iov_buf, u32 count, int type)
  940. {
  941. int i;
  942. u32 buf, len;
  943. struct iovec *ivp, *iov;
  945. /* Get the "struct iovec" from user memory */
  947. if (!count)
  948. return 0;
  949. if(verify_area(VERIFY_READ, iov32, sizeof(struct iovec32)*count))
  950. return(struct iovec *)0;
  951. if (count > UIO_MAXIOV)
  952. return(struct iovec *)0;
  953. if (count > UIO_FASTIOV) {
  954. iov = kmalloc(count*sizeof(struct iovec), GFP_KERNEL);
  955. if (!iov)
  956. return((struct iovec *)0);
  957. } else
  958. iov = iov_buf;
  960. ivp = iov;
  961. for (i = 0; i < count; i++) {
  962. if (__get_user(len, &iov32->iov_len) ||
  963.     __get_user(buf, &iov32->iov_base)) {
  964. if (iov != iov_buf)
  965. kfree(iov);
  966. return((struct iovec *)0);
  967. }
  968. if (verify_area(type, (void *)A(buf), len)) {
  969. if (iov != iov_buf)
  970. kfree(iov);
  971. return((struct iovec *)0);
  972. }
  973. ivp->iov_base = (void *)A(buf);
  974. ivp->iov_len = (__kernel_size_t)len;
  975. iov32++;
  976. ivp++;
  977. }
  978. return(iov);
  979. }
  981. asmlinkage long
  982. sys32_readv(int fd, struct iovec32 *vector, u32 count)
  983. {
  984. struct iovec iovstack[UIO_FASTIOV];
  985. struct iovec *iov;
  986. int ret;
  987. mm_segment_t old_fs = get_fs();
  989. if ((iov = get_iovec32(vector, iovstack, count, VERIFY_WRITE)) == (struct iovec *)0)
  990. return -EFAULT;
  991. set_fs(KERNEL_DS);
  992. ret = sys_readv(fd, iov, count);
  993. set_fs(old_fs);
  994. if (iov != iovstack)
  995. kfree(iov);
  996. return ret;
  997. }
  999. asmlinkage long
  1000. sys32_writev(int fd, struct iovec32 *vector, u32 count)
  1001. {
  1002. struct iovec iovstack[UIO_FASTIOV];
  1003. struct iovec *iov;
  1004. int ret;
  1005. mm_segment_t old_fs = get_fs();
  1007. if ((iov = get_iovec32(vector, iovstack, count, VERIFY_READ)) == (struct iovec *)0)
  1008. return -EFAULT;
  1009. set_fs(KERNEL_DS);
  1010. ret = sys_writev(fd, iov, count);
  1011. set_fs(old_fs);
  1012. if (iov != iovstack)
  1013. kfree(iov);
  1014. return ret;
  1015. }
  1017. #define RLIM_INFINITY32 0xffffffff
  1018. #define RESOURCE32(x) ((x > RLIM_INFINITY32) ? RLIM_INFINITY32 : x)
  1020. struct rlimit32 {
  1021. int rlim_cur;
  1022. int rlim_max;
  1023. };
  1025. extern asmlinkage long sys_getrlimit(unsigned int resource, struct rlimit *rlim);
  1027. asmlinkage long
  1028. sys32_getrlimit(unsigned int resource, struct rlimit32 *rlim)
  1029. {
  1030. struct rlimit r;
  1031. int ret;
  1032. mm_segment_t old_fs;
  1034. old_fs = get_fs();
  1035. set_fs(KERNEL_DS);
  1036. ret = sys_getrlimit(resource, &r);
  1037. set_fs(old_fs);
  1038. if (!ret) {
  1039. if (verify_area(VERIFY_WRITE, rlim, sizeof(struct rlimit32)) ||
  1040.     __put_user(RESOURCE32(r.rlim_cur), &rlim->rlim_cur) ||
  1041.     __put_user(RESOURCE32(r.rlim_max), &rlim->rlim_max))
  1042. ret = -EFAULT;
  1043. }
  1044. return ret;
  1045. }
  1047. extern asmlinkage long sys_old_getrlimit(unsigned int resource, struct rlimit *rlim);
  1049. asmlinkage long
  1050. sys32_old_getrlimit(unsigned int resource, struct rlimit32 *rlim)
  1051. {
  1052. struct rlimit r;
  1053. int ret;
  1054. mm_segment_t old_fs;
  1056. old_fs = get_fs();
  1057. set_fs(KERNEL_DS);
  1058. ret = sys_old_getrlimit(resource, &r);
  1059. set_fs(old_fs);
  1060. if (!ret) {
  1061. if (verify_area(VERIFY_WRITE, rlim, sizeof(struct rlimit32)) ||
  1062.     __put_user(r.rlim_cur, &rlim->rlim_cur) ||
  1063.     __put_user(r.rlim_max, &rlim->rlim_max))
  1064. ret = -EFAULT;
  1065. }
  1066. return ret;
  1067. }
  1069. extern asmlinkage long sys_setrlimit(unsigned int resource, struct rlimit *rlim);
  1071. asmlinkage long
  1072. sys32_setrlimit(unsigned int resource, struct rlimit32 *rlim)
  1073. {
  1074. struct rlimit r;
  1075. int ret;
  1076. mm_segment_t old_fs = get_fs ();
  1078. if (resource >= RLIM_NLIMITS) return -EINVAL;
  1079. if (verify_area(VERIFY_READ, rlim, sizeof(struct rlimit32)) ||
  1080.     __get_user (r.rlim_cur, &rlim->rlim_cur) ||
  1081.     __get_user (r.rlim_max, &rlim->rlim_max))
  1082. return -EFAULT;
  1083. if (r.rlim_cur == RLIM_INFINITY32)
  1084. r.rlim_cur = RLIM_INFINITY;
  1085. if (r.rlim_max == RLIM_INFINITY32)
  1086. r.rlim_max = RLIM_INFINITY;
  1087. set_fs (KERNEL_DS);
  1088. ret = sys_setrlimit(resource, &r);
  1089. set_fs (old_fs);
  1090. return ret;
  1091. }
  1093. /*
  1094.  * sys_time() can be implemented in user-level using
  1095.  * sys_gettimeofday().  IA64 did this but i386 Linux did not
  1096.  * so we have to implement this system call here.
  1097.  */
  1098. asmlinkage long sys32_time(int * tloc)
  1099. {
  1100. int i;
  1102. /* SMP: This is fairly trivial. We grab CURRENT_TIME and 
  1103.    stuff it to user space. No side effects */
  1104. i = CURRENT_TIME;
  1105. if (tloc) {
  1106. if (put_user(i,tloc))
  1107. i = -EFAULT;
  1108. }
  1109. return i;
  1110. }
  1112. struct rusage32 {
  1113.         struct timeval32 ru_utime;
  1114.         struct timeval32 ru_stime;
  1115.         int    ru_maxrss;
  1116.         int    ru_ixrss;
  1117.         int    ru_idrss;
  1118.         int    ru_isrss;
  1119.         int    ru_minflt;
  1120.         int    ru_majflt;
  1121.         int    ru_nswap;
  1122.         int    ru_inblock;
  1123.         int    ru_oublock;
  1124.         int    ru_msgsnd; 
  1125.         int    ru_msgrcv; 
  1126.         int    ru_nsignals;
  1127.         int    ru_nvcsw;
  1128.         int    ru_nivcsw;
  1129. };
  1131. static int
  1132. put_rusage (struct rusage32 *ru, struct rusage *r)
  1133. {
  1134. if (verify_area(VERIFY_WRITE, ru, sizeof(struct rusage32)) ||
  1135.     __put_user (r->ru_utime.tv_sec, &ru->ru_utime.tv_sec) ||
  1136.     __put_user (r->ru_utime.tv_usec, &ru->ru_utime.tv_usec) ||
  1137.     __put_user (r->ru_stime.tv_sec, &ru->ru_stime.tv_sec) ||
  1138.     __put_user (r->ru_stime.tv_usec, &ru->ru_stime.tv_usec) ||
  1139.     __put_user (r->ru_maxrss, &ru->ru_maxrss) ||
  1140.     __put_user (r->ru_ixrss, &ru->ru_ixrss) ||
  1141.     __put_user (r->ru_idrss, &ru->ru_idrss) ||
  1142.     __put_user (r->ru_isrss, &ru->ru_isrss) ||
  1143.     __put_user (r->ru_minflt, &ru->ru_minflt) ||
  1144.     __put_user (r->ru_majflt, &ru->ru_majflt) ||
  1145.     __put_user (r->ru_nswap, &ru->ru_nswap) ||
  1146.     __put_user (r->ru_inblock, &ru->ru_inblock) ||
  1147.     __put_user (r->ru_oublock, &ru->ru_oublock) ||
  1148.     __put_user (r->ru_msgsnd, &ru->ru_msgsnd) ||
  1149.     __put_user (r->ru_msgrcv, &ru->ru_msgrcv) ||
  1150.     __put_user (r->ru_nsignals, &ru->ru_nsignals) ||
  1151.     __put_user (r->ru_nvcsw, &ru->ru_nvcsw) ||
  1152.     __put_user (r->ru_nivcsw, &ru->ru_nivcsw))
  1153. return -EFAULT;
  1154. return 0;
  1155. }
  1157. extern asmlinkage long sys_wait4(pid_t pid,unsigned int * stat_addr,
  1158. int options, struct rusage * ru);
  1160. asmlinkage long
  1161. sys32_wait4(__kernel_pid_t32 pid, unsigned int *stat_addr, int options,
  1162.     struct rusage32 *ru)
  1163. {
  1164. if (!ru)
  1165. return sys_wait4(pid, stat_addr, options, NULL);
  1166. else {
  1167. struct rusage r;
  1168. int ret;
  1169. unsigned int status;
  1170. mm_segment_t old_fs = get_fs();
  1172. set_fs (KERNEL_DS);
  1173. ret = sys_wait4(pid, stat_addr ? &status : NULL, options, &r);
  1174. set_fs (old_fs);
  1175. if (put_rusage (ru, &r)) return -EFAULT;
  1176. if (stat_addr && put_user (status, stat_addr))
  1177. return -EFAULT;
  1178. return ret;
  1179. }
  1180. }
  1182. asmlinkage long
  1183. sys32_waitpid(__kernel_pid_t32 pid, unsigned int *stat_addr, int options)
  1184. {
  1185. return sys32_wait4(pid, stat_addr, options, NULL);
  1186. }
  1189. extern asmlinkage long
  1190. sys_getrusage(int who, struct rusage *ru);
  1192. asmlinkage long
  1193. sys32_getrusage(int who, struct rusage32 *ru)
  1194. {
  1195. struct rusage r;
  1196. int ret;
  1197. mm_segment_t old_fs = get_fs();
  1199. set_fs (KERNEL_DS);
  1200. ret = sys_getrusage(who, &r);
  1201. set_fs (old_fs);
  1202. if (put_rusage (ru, &r)) return -EFAULT;
  1203. return ret;
  1204. }
  1206. struct tms32 {
  1207. __kernel_clock_t32 tms_utime;
  1208. __kernel_clock_t32 tms_stime;
  1209. __kernel_clock_t32 tms_cutime;
  1210. __kernel_clock_t32 tms_cstime;
  1211. };
  1213. extern int sys_times(struct tms *);
  1214.                                
  1215. asmlinkage long
  1216. sys32_times(struct tms32 *tbuf)
  1217. {
  1218. struct tms t;
  1219. long ret;
  1220. mm_segment_t old_fs = get_fs ();
  1222. set_fs (KERNEL_DS);
  1223. ret = sys_times(tbuf ? &t : NULL);
  1224. set_fs (old_fs);
  1225. if (tbuf) {
  1226. if (verify_area(VERIFY_WRITE, tbuf, sizeof(struct tms32)) ||
  1227.     __put_user (t.tms_utime, &tbuf->tms_utime) ||
  1228.     __put_user (t.tms_stime, &tbuf->tms_stime) ||
  1229.     __put_user (t.tms_cutime, &tbuf->tms_cutime) ||
  1230.     __put_user (t.tms_cstime, &tbuf->tms_cstime))
  1231. return -EFAULT;
  1232. }
  1233. return ret;
  1234. }
  1237. static inline int get_flock(struct flock *kfl, struct flock32 *ufl)
  1238. {
  1239. int err;
  1241. err = get_user(kfl->l_type, &ufl->l_type);
  1242. err |= __get_user(kfl->l_whence, &ufl->l_whence);
  1243. err |= __get_user(kfl->l_start, &ufl->l_start);
  1244. err |= __get_user(kfl->l_len, &ufl->l_len);
  1245. err |= __get_user(kfl->l_pid, &ufl->l_pid);
  1246. return err;
  1247. }
  1249. static inline int put_flock(struct flock *kfl, struct flock32 *ufl)
  1250. {
  1251. int err;
  1253. err = __put_user(kfl->l_type, &ufl->l_type);
  1254. err |= __put_user(kfl->l_whence, &ufl->l_whence);
  1255. err |= __put_user(kfl->l_start, &ufl->l_start);
  1256. err |= __put_user(kfl->l_len, &ufl->l_len);
  1257. err |= __put_user(kfl->l_pid, &ufl->l_pid);
  1258. return err;
  1259. }
  1261. extern asmlinkage long sys_fcntl(unsigned int fd, unsigned int cmd, unsigned long arg);
  1262. asmlinkage long sys32_fcntl64(unsigned int fd, unsigned int cmd, unsigned long arg);
  1265. asmlinkage long sys32_fcntl(unsigned int fd, unsigned int cmd, unsigned long arg)
  1266. {
  1267. switch (cmd) {
  1268. case F_GETLK:
  1269. case F_SETLK:
  1270. case F_SETLKW:
  1271. {
  1272. struct flock f;
  1273. mm_segment_t old_fs;
  1274. long ret;
  1276. if (get_flock(&f, (struct flock32 *)arg))
  1277. return -EFAULT;
  1278. old_fs = get_fs(); set_fs (KERNEL_DS);
  1279. ret = sys_fcntl(fd, cmd, (unsigned long)&f);
  1280. set_fs (old_fs);
  1281. if (ret) return ret;
  1282. if (put_flock(&f, (struct flock32 *)arg))
  1283. return -EFAULT;
  1284. return 0;
  1285. }
  1286. case F_GETLK64: 
  1287. case F_SETLK64: 
  1288. case F_SETLKW64: 
  1289. return sys32_fcntl64(fd,cmd,arg); 
  1291. default:
  1292. return sys_fcntl(fd, cmd, (unsigned long)arg);
  1293. }
  1294. }
  1296. static inline int get_flock64(struct ia32_flock64 *fl32, struct flock *fl64)
  1297. {
  1298. if (access_ok(fl32, sizeof(struct ia32_flock64), VERIFY_WRITE)) {
  1299. int ret = __get_user(fl64->l_type, &fl32->l_type); 
  1300. ret |= __get_user(fl64->l_whence, &fl32->l_whence);
  1301. ret |= __get_user(fl64->l_start, &fl32->l_start); 
  1302. ret |= __get_user(fl64->l_len, &fl32->l_len); 
  1303. ret |= __get_user(fl64->l_pid, &fl32->l_pid); 
  1304. return ret; 
  1305. }
  1306. return -EFAULT; 
  1307. }
  1309. static inline int put_flock64(struct ia32_flock64 *fl32, struct flock *fl64)
  1310. {
  1311. if (access_ok(fl32, sizeof(struct ia32_flock64), VERIFY_WRITE)) {
  1312. int ret = __put_user(fl64->l_type, &fl32->l_type); 
  1313. ret |= __put_user(fl64->l_whence, &fl32->l_whence);
  1314. ret |= __put_user(fl64->l_start, &fl32->l_start); 
  1315. ret |= __put_user(fl64->l_len, &fl32->l_len); 
  1316. ret |= __put_user(fl64->l_pid, &fl32->l_pid); 
  1317. return ret; 
  1318. }
  1319. return -EFAULT; 
  1320. }
  1322. asmlinkage long sys32_fcntl64(unsigned int fd, unsigned int cmd, unsigned long arg)
  1323. {
  1324. struct flock fl64;  
  1325. mm_segment_t oldfs = get_fs(); 
  1326. int ret = 0; 
  1327. int oldcmd = cmd;
  1328. unsigned long oldarg = arg;
  1330. switch (cmd) {
  1331. case F_GETLK64: 
  1332. cmd = F_GETLK; 
  1333. goto cnv;
  1334. case F_SETLK64: 
  1335. cmd = F_SETLK; 
  1336. goto cnv; 
  1337. case F_SETLKW64:
  1338. cmd = F_SETLKW; 
  1339. cnv:
  1340. ret = get_flock64((struct ia32_flock64 *)arg, &fl64); 
  1341. arg = (unsigned long)&fl64; 
  1342. set_fs(KERNEL_DS); 
  1343. break; 
  1344. case F_GETLK:
  1345. case F_SETLK:
  1346. case F_SETLKW:
  1347. return sys32_fcntl(fd,cmd,arg); 
  1348. }
  1349. if (!ret)
  1350. ret = sys_fcntl(fd, cmd, arg);
  1351. set_fs(oldfs); 
  1352. if (oldcmd == F_GETLK64 && !ret)
  1353. ret = put_flock64((struct ia32_flock64 *)oldarg, &fl64); 
  1354. return ret; 
  1355. }
  1357. int sys32_ni_syscall(int call)
  1358. { 
  1359. printk(KERN_INFO "IA32 syscall %d from %s not implementedn", call,
  1360.        current->comm);
  1361. return -ENOSYS;        
  1362. } 
  1364. /* 32-bit timeval and related flotsam.  */
  1366. extern asmlinkage long sys_utime(char * filename, struct utimbuf * times);
  1368. struct utimbuf32 {
  1369. __kernel_time_t32 actime, modtime;
  1370. };
  1372. asmlinkage long
  1373. sys32_utime(char * filename, struct utimbuf32 *times)
  1374. {
  1375. struct utimbuf t;
  1376. mm_segment_t old_fs;
  1377. int ret;
  1378. char *filenam;
  1380. if (!times)
  1381. return sys_utime(filename, NULL);
  1382. if (verify_area(VERIFY_READ, times, sizeof(struct utimbuf32)) ||
  1383.     __get_user (t.actime, &times->actime) ||
  1384.     __get_user (t.modtime, &times->modtime))
  1385. return -EFAULT;
  1386. filenam = getname (filename);
  1387. ret = PTR_ERR(filenam);
  1388. if (!IS_ERR(filenam)) {
  1389. old_fs = get_fs();
  1390. set_fs (KERNEL_DS); 
  1391. ret = sys_utime(filenam, &t);
  1392. set_fs (old_fs);
  1393. putname(filenam);
  1394. }
  1395. return ret;
  1396. }
  1398. extern asmlinkage long sys_sysfs(int option, unsigned long arg1,
  1399. unsigned long arg2);
  1401. asmlinkage long
  1402. sys32_sysfs(int option, u32 arg1, u32 arg2)
  1403. {
  1404. return sys_sysfs(option, arg1, arg2);
  1405. }
  1407. extern asmlinkage long sys_mount(char * dev_name, char * dir_name, char * type,
  1408. unsigned long new_flags, void *data);
  1410. static char *badfs[] = {
  1411. "smbfs", "ncpfs", NULL
  1412. }; 
  1414. static int checktype(char *user_type) 
  1415. { 
  1416. int err = 0; 
  1417. char **s,*kernel_type = getname(user_type); 
  1418. if (!kernel_type || IS_ERR(kernel_type)) 
  1419. return -EFAULT; 
  1420. for (s = badfs; *s; ++s) 
  1421. if (!strcmp(kernel_type, *s)) { 
  1422. printk(KERN_ERR "mount32: unsupported fs `%s' -- use 64bit mountn", *s); 
  1423. err = -EINVAL; 
  1424. break;
  1425. } 
  1426. putname(user_type); 
  1427. return err;
  1428. } 
  1430. asmlinkage long
  1431. sys32_mount(char *dev_name, char *dir_name, char *type,
  1432.     unsigned long new_flags, u32 data)
  1433. {
  1434. int err;
  1435. if(!capable(CAP_SYS_ADMIN))
  1436. return -EPERM;
  1437. err = checktype(type);
  1438. if (err)
  1439. return err;
  1440. return sys_mount(dev_name, dir_name, type, new_flags, (void *)AA(data));
  1441. }
  1443. struct sysinfo32 {
  1444.         s32 uptime;
  1445.         u32 loads[3];
  1446.         u32 totalram;
  1447.         u32 freeram;
  1448.         u32 sharedram;
  1449.         u32 bufferram;
  1450.         u32 totalswap;
  1451.         u32 freeswap;
  1452.         unsigned short procs;
  1453.         char _f[22];
  1454. };
  1456. extern asmlinkage long sys_sysinfo(struct sysinfo *info);
  1458. asmlinkage long
  1459. sys32_sysinfo(struct sysinfo32 *info)
  1460. {
  1461. struct sysinfo s;
  1462. int ret;
  1463. mm_segment_t old_fs = get_fs ();
  1465. set_fs (KERNEL_DS);
  1466. ret = sys_sysinfo(&s);
  1467. set_fs (old_fs);
  1468. if (verify_area(VERIFY_WRITE, info, sizeof(struct sysinfo32)) ||
  1469.     __put_user (s.uptime, &info->uptime) ||
  1470.     __put_user (s.loads[0], &info->loads[0]) ||
  1471.     __put_user (s.loads[1], &info->loads[1]) ||
  1472.     __put_user (s.loads[2], &info->loads[2]) ||
  1473.     __put_user (s.totalram, &info->totalram) ||
  1474.     __put_user (s.freeram, &info->freeram) ||
  1475.     __put_user (s.sharedram, &info->sharedram) ||
  1476.     __put_user (s.bufferram, &info->bufferram) ||
  1477.     __put_user (s.totalswap, &info->totalswap) ||
  1478.     __put_user (s.freeswap, &info->freeswap) ||
  1479.     __put_user (s.procs, &info->procs))
  1480. return -EFAULT;
  1481. return 0;
  1482. }
  1483.                 
  1484. extern asmlinkage long sys_sched_rr_get_interval(pid_t pid,
  1485. struct timespec *interval);
  1487. asmlinkage long
  1488. sys32_sched_rr_get_interval(__kernel_pid_t32 pid, struct timespec32 *interval)
  1489. {
  1490. struct timespec t;
  1491. int ret;
  1492. mm_segment_t old_fs = get_fs ();
  1494. set_fs (KERNEL_DS);
  1495. ret = sys_sched_rr_get_interval(pid, &t);
  1496. set_fs (old_fs);
  1497. if (verify_area(VERIFY_WRITE, interval, sizeof(struct timespec32)) ||
  1498.     __put_user (t.tv_sec, &interval->tv_sec) ||
  1499.     __put_user (t.tv_nsec, &interval->tv_nsec))
  1500. return -EFAULT;
  1501. return ret;
  1502. }
  1504. extern asmlinkage long sys_sigprocmask(int how, old_sigset_t *set,
  1505.       old_sigset_t *oset);
  1507. asmlinkage long
  1508. sys32_sigprocmask(int how, old_sigset32_t *set, old_sigset32_t *oset)
  1509. {
  1510. old_sigset_t s;
  1511. int ret;
  1512. mm_segment_t old_fs = get_fs();
  1514. if (set && get_user (s, set)) return -EFAULT;
  1515. set_fs (KERNEL_DS);
  1516. ret = sys_sigprocmask(how, set ? &s : NULL, oset ? &s : NULL);
  1517. set_fs (old_fs);
  1518. if (ret) return ret;
  1519. if (oset && put_user (s, oset)) return -EFAULT;
  1520. return 0;
  1521. }
  1523. extern asmlinkage long sys_sigpending(old_sigset_t *set);
  1525. asmlinkage long
  1526. sys32_sigpending(old_sigset32_t *set)
  1527. {
  1528. old_sigset_t s;
  1529. int ret;
  1530. mm_segment_t old_fs = get_fs();
  1532. set_fs (KERNEL_DS);
  1533. ret = sys_sigpending(&s);
  1534. set_fs (old_fs);
  1535. if (put_user (s, set)) return -EFAULT;
  1536. return ret;
  1537. }
  1539. extern asmlinkage long sys_rt_sigpending(sigset_t *set, size_t sigsetsize);
  1541. asmlinkage long
  1542. sys32_rt_sigpending(sigset32_t *set, __kernel_size_t32 sigsetsize)
  1543. {
  1544. sigset_t s;
  1545. sigset32_t s32;
  1546. int ret;
  1547. mm_segment_t old_fs = get_fs();
  1549. set_fs (KERNEL_DS);
  1550. ret = sys_rt_sigpending(&s, sigsetsize);
  1551. set_fs (old_fs);
  1552. if (!ret) {
  1553. switch (_NSIG_WORDS) {
  1554. case 4: s32.sig[7] = (s.sig[3] >> 32); s32.sig[6] = s.sig[3];
  1555. case 3: s32.sig[5] = (s.sig[2] >> 32); s32.sig[4] = s.sig[2];
  1556. case 2: s32.sig[3] = (s.sig[1] >> 32); s32.sig[2] = s.sig[1];
  1557. case 1: s32.sig[1] = (s.sig[0] >> 32); s32.sig[0] = s.sig[0];
  1558. }
  1559. if (copy_to_user (set, &s32, sizeof(sigset32_t)))
  1560. return -EFAULT;
  1561. }
  1562. return ret;
  1563. }
  1565. siginfo_t32 *
  1566. siginfo64to32(siginfo_t32 *d, siginfo_t *s)
  1567. {
  1568. memset (d, 0, sizeof(siginfo_t32));
  1569. d->si_signo = s->si_signo;
  1570. d->si_errno = s->si_errno;
  1571. d->si_code = s->si_code;
  1572. if (s->si_signo >= SIGRTMIN) {
  1573. d->si_pid = s->si_pid;
  1574. d->si_uid = s->si_uid;
  1575. /* XXX: Ouch, how to find this out??? */
  1576. d->si_int = s->si_int;
  1577. } else switch (s->si_signo) {
  1578. /* XXX: What about POSIX1.b timers */
  1579. case SIGCHLD:
  1580. d->si_pid = s->si_pid;
  1581. d->si_status = s->si_status;
  1582. d->si_utime = s->si_utime;
  1583. d->si_stime = s->si_stime;
  1584. break;
  1585. case SIGSEGV:
  1586. case SIGBUS:
  1587. case SIGFPE:
  1588. case SIGILL:
  1589. d->si_addr = (long)(s->si_addr);
  1590. // d->si_trapno = s->si_trapno;
  1591. break;
  1592. case SIGPOLL:
  1593. d->si_band = s->si_band;
  1594. d->si_fd = s->si_fd;
  1595. break;
  1596. default:
  1597. d->si_pid = s->si_pid;
  1598. d->si_uid = s->si_uid;
  1599. break;
  1600. }
  1601. return d;
  1602. }
  1604. siginfo_t *
  1605. siginfo32to64(siginfo_t *d, siginfo_t32 *s)
  1606. {
  1607. d->si_signo = s->si_signo;
  1608. d->si_errno = s->si_errno;
  1609. d->si_code = s->si_code;
  1610. if (s->si_signo >= SIGRTMIN) {
  1611. d->si_pid = s->si_pid;
  1612. d->si_uid = s->si_uid;
  1613. /* XXX: Ouch, how to find this out??? */
  1614. d->si_int = s->si_int;
  1615. } else switch (s->si_signo) {
  1616. /* XXX: What about POSIX1.b timers */
  1617. case SIGCHLD:
  1618. d->si_pid = s->si_pid;
  1619. d->si_status = s->si_status;
  1620. d->si_utime = s->si_utime;
  1621. d->si_stime = s->si_stime;
  1622. break;
  1623. case SIGSEGV:
  1624. case SIGBUS:
  1625. case SIGFPE:
  1626. case SIGILL:
  1627. d->si_addr = (void *)A(s->si_addr);
  1628. // d->si_trapno = s->si_trapno;
  1629. break;
  1630. case SIGPOLL:
  1631. d->si_band = s->si_band;
  1632. d->si_fd = s->si_fd;
  1633. break;
  1634. default:
  1635. d->si_pid = s->si_pid;
  1636. d->si_uid = s->si_uid;
  1637. break;
  1638. }
  1639. return d;
  1640. }
  1642. extern asmlinkage long
  1643. sys_rt_sigtimedwait(const sigset_t *uthese, siginfo_t *uinfo,
  1644.     const struct timespec *uts, size_t sigsetsize);
  1646. asmlinkage long
  1647. sys32_rt_sigtimedwait(sigset32_t *uthese, siginfo_t32 *uinfo,
  1648.       struct timespec32 *uts, __kernel_size_t32 sigsetsize)
  1649. {
  1650. sigset_t s;
  1651. sigset32_t s32;
  1652. struct timespec t;
  1653. int ret;
  1654. mm_segment_t old_fs = get_fs();
  1655. siginfo_t info;
  1656. siginfo_t32 info32;
  1658. if (copy_from_user (&s32, uthese, sizeof(sigset32_t)))
  1659. return -EFAULT;
  1660. switch (_NSIG_WORDS) {
  1661. case 4: s.sig[3] = s32.sig[6] | (((long)s32.sig[7]) << 32);
  1662. case 3: s.sig[2] = s32.sig[4] | (((long)s32.sig[5]) << 32);
  1663. case 2: s.sig[1] = s32.sig[2] | (((long)s32.sig[3]) << 32);
  1664. case 1: s.sig[0] = s32.sig[0] | (((long)s32.sig[1]) << 32);
  1665. }
  1666. if (uts) {
  1667. if (verify_area(VERIFY_READ, uts, sizeof(struct timespec32)) ||
  1668.     __get_user (t.tv_sec, &uts->tv_sec) ||
  1669.     __get_user (t.tv_nsec, &uts->tv_nsec))
  1670. return -EFAULT;
  1671. }
  1672. set_fs (KERNEL_DS);
  1673. ret = sys_rt_sigtimedwait(&s, &info, &t, sigsetsize);
  1674. set_fs (old_fs);
  1675. if (ret >= 0 && uinfo) {
  1676. if (copy_to_user (uinfo, siginfo64to32(&info32, &info),
  1677.   sizeof(siginfo_t32)))
  1678. return -EFAULT;
  1679. }
  1680. return ret;
  1681. }
  1683. extern asmlinkage long
  1684. sys_rt_sigqueueinfo(int pid, int sig, siginfo_t *uinfo);
  1686. asmlinkage long
  1687. sys32_rt_sigqueueinfo(int pid, int sig, siginfo_t32 *uinfo)
  1688. {
  1689. siginfo_t info;
  1690. siginfo_t32 info32;
  1691. int ret;
  1692. mm_segment_t old_fs = get_fs();
  1694. if (copy_from_user (&info32, uinfo, sizeof(siginfo_t32)))
  1695. return -EFAULT;
  1696. /* XXX: Is this correct? */
  1697. siginfo32to64(&info, &info32);
  1698. set_fs (KERNEL_DS);
  1699. ret = sys_rt_sigqueueinfo(pid, sig, &info);
  1700. set_fs (old_fs);
  1701. return ret;
  1702. }
  1704. extern void check_pending(int signum);
  1706. asmlinkage long sys_utimes(char *, struct timeval *);
  1708. asmlinkage long
  1709. sys32_utimes(char *filename, struct timeval32 *tvs)
  1710. {
  1711. char *kfilename;
  1712. struct timeval ktvs[2];
  1713. mm_segment_t old_fs;
  1714. int ret;
  1716. kfilename = getname(filename);
  1717. ret = PTR_ERR(kfilename);
  1718. if (!IS_ERR(kfilename)) {
  1719. if (tvs) {
  1720. if (get_tv32(&ktvs[0], tvs) ||
  1721.     get_tv32(&ktvs[1], 1+tvs))
  1722. return -EFAULT;
  1723. }
  1725. old_fs = get_fs();
  1726. set_fs(KERNEL_DS);
  1727. ret = sys_utimes(kfilename, &ktvs[0]);
  1728. set_fs(old_fs);
  1730. putname(kfilename);
  1731. }
  1732. return ret;
  1733. }
  1735. /* These are here just in case some old ia32 binary calls it. */
  1736. asmlinkage long
  1737. sys32_pause(void)
  1738. {
  1739. current->state = TASK_INTERRUPTIBLE;
  1740. schedule();
  1741. return -ERESTARTNOHAND;
  1742. }
  1745. struct sysctl_ia32 {
  1746. unsigned int name;
  1747. int nlen;
  1748. unsigned int oldval;
  1749. unsigned int oldlenp;
  1750. unsigned int newval;
  1751. unsigned int newlen;
  1752. unsigned int __unused[4];
  1753. };
  1756. asmlinkage long
  1757. sys32_sysctl(struct sysctl_ia32 *args32)
  1758. {
  1759. #ifndef CONFIG_SYSCTL
  1760. return -ENOSYS; 
  1761. #else
  1762. struct sysctl_ia32 a32;
  1763. mm_segment_t old_fs = get_fs ();
  1764. void *oldvalp, *newvalp;
  1765. size_t oldlen;
  1766. int *namep;
  1767. long ret;
  1768. extern int do_sysctl(int *name, int nlen, void *oldval, size_t *oldlenp,
  1769.      void *newval, size_t newlen);
  1772. if (copy_from_user(&a32, args32, sizeof (a32)))
  1773. return -EFAULT;
  1775. /*
  1776.  * We need to pre-validate these because we have to disable address checking
  1777.  * before calling do_sysctl() because of OLDLEN but we can't run the risk of the
  1778.  * user specifying bad addresses here.  Well, since we're dealing with 32 bit
  1779.  * addresses, we KNOW that access_ok() will always succeed, so this is an
  1780.  * expensive NOP, but so what...
  1781.  */
  1782. namep = (int *) A(a32.name);
  1783. oldvalp = (void *) A(a32.oldval);
  1784. newvalp = (void *) A(a32.newval);
  1786. if ((oldvalp && get_user(oldlen, (int *) A(a32.oldlenp)))
  1787.     || !access_ok(VERIFY_WRITE, namep, 0)
  1788.     || !access_ok(VERIFY_WRITE, oldvalp, 0)
  1789.     || !access_ok(VERIFY_WRITE, newvalp, 0))
  1790. return -EFAULT;
  1792. set_fs(KERNEL_DS);
  1793. lock_kernel();
  1794. ret = do_sysctl(namep, a32.nlen, oldvalp, &oldlen, newvalp, (size_t) a32.newlen);
  1795. unlock_kernel();
  1796. set_fs(old_fs);
  1798. if (oldvalp && put_user (oldlen, (int *) A(a32.oldlenp)))
  1799. return -EFAULT;
  1801. return ret;
  1802. #endif
  1803. }
  1805. extern asmlinkage ssize_t sys_pread(unsigned int fd, char * buf,
  1806.     size_t count, loff_t pos);
  1808. extern asmlinkage ssize_t sys_pwrite(unsigned int fd, const char * buf,
  1809.      size_t count, loff_t pos);
  1811. typedef __kernel_ssize_t32 ssize_t32;
  1814. /* warning: next two assume little endian */ 
  1815. asmlinkage ssize_t32
  1816. sys32_pread(unsigned int fd, char *ubuf, __kernel_size_t32 count,
  1817.     u32 poslo, u32 poshi)
  1818. {
  1819. return sys_pread(fd, ubuf, count,
  1820.  ((loff_t)AA(poshi) << 32) | AA(poslo));
  1821. }
  1823. asmlinkage ssize_t32
  1824. sys32_pwrite(unsigned int fd, char *ubuf, __kernel_size_t32 count,
  1825.      u32 poslo, u32 poshi)
  1826. {
  1827. return sys_pwrite(fd, ubuf, count,
  1828.   ((loff_t)AA(poshi) << 32) | AA(poslo));
  1829. }
  1832. extern asmlinkage long sys_personality(unsigned long);
  1834. asmlinkage long
  1835. sys32_personality(unsigned long personality)
  1836. {
  1837. int ret;
  1838. if (personality(current->personality) == PER_LINUX32 && 
  1839. personality == PER_LINUX)
  1840. personality = PER_LINUX32;
  1841. ret = sys_personality(personality);
  1842. if (ret == PER_LINUX32)
  1843. ret = PER_LINUX;
  1844. return ret;
  1845. }
  1847. extern asmlinkage ssize_t sys_sendfile(int out_fd, int in_fd, off_t *offset,
  1848.        size_t count); 
  1850. asmlinkage long
  1851. sys32_sendfile(int out_fd, int in_fd, __kernel_off_t32 *offset, s32 count)
  1852. {
  1853. mm_segment_t old_fs = get_fs();
  1854. int ret;
  1855. off_t of;
  1857. if (offset && get_user(of, offset))
  1858. return -EFAULT;
  1860. set_fs(KERNEL_DS);
  1861. ret = sys_sendfile(out_fd, in_fd, offset ? &of : NULL, count);
  1862. set_fs(old_fs);
  1864. if (!ret && offset && put_user(of, offset))
  1865. return -EFAULT;
  1867. return ret;
  1868. }
  1870. /* Handle adjtimex compatability. */
  1872. struct timex32 {
  1873. u32 modes;
  1874. s32 offset, freq, maxerror, esterror;
  1875. s32 status, constant, precision, tolerance;
  1876. struct timeval32 time;
  1877. s32 tick;
  1878. s32 ppsfreq, jitter, shift, stabil;
  1879. s32 jitcnt, calcnt, errcnt, stbcnt;
  1880. s32  :32; s32  :32; s32  :32; s32  :32;
  1881. s32  :32; s32  :32; s32  :32; s32  :32;
  1882. s32  :32; s32  :32; s32  :32; s32  :32;
  1883. };
  1885. extern int do_adjtimex(struct timex *);
  1887. asmlinkage long
  1888. sys32_adjtimex(struct timex32 *utp)
  1889. {
  1890. struct timex txc;
  1891. int ret;
  1893. memset(&txc, 0, sizeof(struct timex));
  1895. if(verify_area(VERIFY_READ, utp, sizeof(struct timex32)) ||
  1896.    __get_user(txc.modes, &utp->modes) ||
  1897.    __get_user(txc.offset, &utp->offset) ||
  1898.    __get_user(txc.freq, &utp->freq) ||
  1899.    __get_user(txc.maxerror, &utp->maxerror) ||
  1900.    __get_user(txc.esterror, &utp->esterror) ||
  1901.    __get_user(txc.status, &utp->status) ||
  1902.    __get_user(txc.constant, &utp->constant) ||
  1903.    __get_user(txc.precision, &utp->precision) ||
  1904.    __get_user(txc.tolerance, &utp->tolerance) ||
  1905.    __get_user(txc.time.tv_sec, &utp->time.tv_sec) ||
  1906.    __get_user(txc.time.tv_usec, &utp->time.tv_usec) ||
  1907.    __get_user(txc.tick, &utp->tick) ||
  1908.    __get_user(txc.ppsfreq, &utp->ppsfreq) ||
  1909.    __get_user(txc.jitter, &utp->jitter) ||
  1910.    __get_user(txc.shift, &utp->shift) ||
  1911.    __get_user(txc.stabil, &utp->stabil) ||
  1912.    __get_user(txc.jitcnt, &utp->jitcnt) ||
  1913.    __get_user(txc.calcnt, &utp->calcnt) ||
  1914.    __get_user(txc.errcnt, &utp->errcnt) ||
  1915.    __get_user(txc.stbcnt, &utp->stbcnt))
  1916. return -EFAULT;
  1918. ret = do_adjtimex(&txc);
  1920. if(verify_area(VERIFY_WRITE, utp, sizeof(struct timex32)) ||
  1921.    __put_user(txc.modes, &utp->modes) ||
  1922.    __put_user(txc.offset, &utp->offset) ||
  1923.    __put_user(txc.freq, &utp->freq) ||
  1924.    __put_user(txc.maxerror, &utp->maxerror) ||
  1925.    __put_user(txc.esterror, &utp->esterror) ||
  1926.    __put_user(txc.status, &utp->status) ||
  1927.    __put_user(txc.constant, &utp->constant) ||
  1928.    __put_user(txc.precision, &utp->precision) ||
  1929.    __put_user(txc.tolerance, &utp->tolerance) ||
  1930.    __put_user(txc.time.tv_sec, &utp->time.tv_sec) ||
  1931.    __put_user(txc.time.tv_usec, &utp->time.tv_usec) ||
  1932.    __put_user(txc.tick, &utp->tick) ||
  1933.    __put_user(txc.ppsfreq, &utp->ppsfreq) ||
  1934.    __put_user(txc.jitter, &utp->jitter) ||
  1935.    __put_user(txc.shift, &utp->shift) ||
  1936.    __put_user(txc.stabil, &utp->stabil) ||
  1937.    __put_user(txc.jitcnt, &utp->jitcnt) ||
  1938.    __put_user(txc.calcnt, &utp->calcnt) ||
  1939.    __put_user(txc.errcnt, &utp->errcnt) ||
  1940.    __put_user(txc.stbcnt, &utp->stbcnt))
  1941. ret = -EFAULT;
  1943. return ret;
  1944. }
  1947. /* common code for old and new mmaps */
  1948. static inline long do_mmap2(
  1949. unsigned long addr, unsigned long len,
  1950. unsigned long prot, unsigned long flags,
  1951. unsigned long fd, unsigned long pgoff)
  1952. {
  1953. int error = -EBADF;
  1954. struct file * file = NULL;
  1956. flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE);
  1957. if (!(flags & MAP_ANONYMOUS)) {
  1958. file = fget(fd);
  1959. if (!file)
  1960. goto out;
  1961. }
  1963. down_write(&current->mm->mmap_sem);
  1964. error = do_mmap_pgoff(file, addr, len, prot, flags, pgoff);
  1965. up_write(&current->mm->mmap_sem);
  1967. if (file)
  1968. fput(file);
  1969. out:
  1970. return error;
  1971. }
  1973. asmlinkage long sys32_mmap2(unsigned long addr, unsigned long len,
  1974. unsigned long prot, unsigned long flags,
  1975. unsigned long fd, unsigned long pgoff)
  1976. {
  1977. return do_mmap2(addr, len, prot, flags, fd, pgoff);
  1978. }
  1981. asmlinkage long sys32_olduname(struct oldold_utsname * name)
  1982. {
  1983. int error;
  1985. if (!name)
  1986. return -EFAULT;
  1987. if (!access_ok(VERIFY_WRITE,name,sizeof(struct oldold_utsname)))
  1988. return -EFAULT;
  1989.   
  1990.    down_read(&uts_sem);
  1992. error = __copy_to_user(&name->sysname,&system_utsname.sysname,__OLD_UTS_LEN);
  1993.  __put_user(0,name->sysname+__OLD_UTS_LEN);
  1994.  __copy_to_user(&name->nodename,&system_utsname.nodename,__OLD_UTS_LEN);
  1995.  __put_user(0,name->nodename+__OLD_UTS_LEN);
  1996.  __copy_to_user(&name->release,&system_utsname.release,__OLD_UTS_LEN);
  1997.  __put_user(0,name->release+__OLD_UTS_LEN);
  1998.  __copy_to_user(&name->version,&system_utsname.version,__OLD_UTS_LEN);
  1999.  __put_user(0,name->version+__OLD_UTS_LEN);
  2000.  { 
  2001.  char *arch = (personality(current->personality) == PER_LINUX32)
  2002.  ? "i686" : "x86_64"; 
  2003.  
  2004.  __copy_to_user(&name->machine,arch,strlen(arch)+1);
  2005.  }
  2007.  up_read(&uts_sem);
  2008.  
  2009.  error = error ? -EFAULT : 0;
  2010.  
  2011.  return error;
  2012. }
  2014. asmlinkage long sys32_uname(struct old_utsname * name)
  2015. {
  2016. int err;
  2017. down_read(&uts_sem);
  2018. err=copy_to_user(name, &system_utsname, sizeof (*name));
  2019. up_read(&uts_sem);
  2020. if (personality(current->personality) == PER_LINUX32)
  2021. err = copy_to_user(name->machine, "i686", 5);
  2022. return err?-EFAULT:0;
  2023. }
  2025. extern int sys_ustat(dev_t, struct ustat *);
  2027. int sys32_ustat(dev_t dev, struct ustat32 *u32p)
  2028. {
  2029. struct ustat u;
  2030. mm_segment_t seg;
  2031. int ret;
  2033. seg = get_fs(); 
  2034. set_fs(KERNEL_DS); 
  2035. ret = sys_ustat(dev,&u); 
  2036. set_fs(seg);
  2037. if (ret >= 0) { 
  2038. if (!access_ok(VERIFY_WRITE,u32p,sizeof(struct ustat32)) || 
  2039.     __put_user((__u32) u.f_tfree, &u32p->f_tfree) ||
  2040.     __put_user((__u32) u.f_tinode, &u32p->f_tfree) ||
  2041.     __copy_to_user(&u32p->f_fname, u.f_fname, sizeof(u.f_fname)) ||
  2042.     __copy_to_user(&u32p->f_fpack, u.f_fpack, sizeof(u.f_fpack)))
  2043. ret = -EFAULT;
  2044. }
  2045. return ret;
  2046. } 
  2048. static int nargs(u32 src, char **dst) 
  2049. { 
  2050. int cnt;
  2051. u32 val; 
  2053. cnt = 0; 
  2054. do { 
  2055. int ret = get_user(val, (__u32 *)(u64)src); 
  2056. if (ret)
  2057. return ret;
  2058. if (dst)
  2059. dst[cnt] = (char *)(u64)val; 
  2060. cnt++;
  2061. src += 4;
  2062. if (cnt >= (MAX_ARG_PAGES*PAGE_SIZE)/sizeof(void*))
  2063. return -E2BIG; 
  2064. } while(val); 
  2065. if (dst)
  2066. dst[cnt-1] = 0; 
  2067. return cnt; 
  2068. } 
  2070. int sys32_execve(char *name, u32 argv, u32 envp, struct pt_regs regs)
  2071. { 
  2072. mm_segment_t oldseg; 
  2073. char **buf; 
  2074. int na,ne;
  2075. int ret;
  2076. unsigned sz; 
  2078. na = nargs(argv, NULL); 
  2079. if (na < 0) 
  2080. return -EFAULT; 
  2081. ne = nargs(envp, NULL); 
  2082. if (ne < 0) 
  2083. return -EFAULT; 
  2085. sz = (na+ne)*sizeof(void *); 
  2086. if (sz > PAGE_SIZE) 
  2087. buf = vmalloc(sz); 
  2088. else
  2089. buf = kmalloc(sz, GFP_KERNEL); 
  2090. if (!buf)
  2091. return -ENOMEM; 
  2093. ret = nargs(argv, buf);
  2094. if (ret < 0)
  2095. goto free;
  2097. ret = nargs(envp, buf + na); 
  2098. if (ret < 0)
  2099. goto free; 
  2101. name = getname(name); 
  2102. ret = PTR_ERR(name); 
  2103. if (IS_ERR(name))
  2104. goto free; 
  2106. oldseg = get_fs(); 
  2107. set_fs(KERNEL_DS);
  2108. ret = do_execve(name, buf, buf+na, &regs);  
  2109. set_fs(oldseg); 
  2111. if (ret == 0)
  2112. current->ptrace &= ~PT_DTRACE;
  2114. putname(name);
  2115.  
  2116. free:
  2117. if (sz > PAGE_SIZE)
  2118. vfree(buf); 
  2119. else
  2120. kfree(buf);
  2121. return ret; 
  2122. } 
  2124. asmlinkage int sys32_fork(struct pt_regs regs)
  2125. {
  2126. return do_fork(SIGCHLD, regs.rsp, &regs, 0);
  2127. }
  2129. asmlinkage int sys32_clone(unsigned int clone_flags, unsigned int newsp, struct pt_regs regs)
  2130. {
  2131. if (!newsp)
  2132. newsp = regs.rsp;
  2133. return do_fork(clone_flags, newsp, &regs, 0);
  2134. }
  2136. /*
  2137.  * This is trivial, and on the face of it looks like it
  2138.  * could equally well be done in user mode.
  2139.  *
  2140.  * Not so, for quite unobvious reasons - register pressure.
  2141.  * In user mode vfork() cannot have a stack frame, and if
  2142.  * done by calling the "clone()" system call directly, you
  2143.  * do not have enough call-clobbered registers to hold all
  2144.  * the information you need.
  2145.  */
  2146. asmlinkage int sys32_vfork(struct pt_regs regs)
  2147. {
  2148. return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, regs.rsp, &regs, 0);
  2149. }
  2151. /*
  2152.  * Some system calls that need sign extended arguments. This could be done by a generic wrapper.
  2153.  */ 
  2155. extern off_t sys_lseek (unsigned int fd, off_t offset, unsigned int origin);
  2157. int sys32_lseek (unsigned int fd, int offset, unsigned int whence)
  2158. {
  2159. return sys_lseek(fd, offset, whence);
  2160. }
  2162. extern int sys_kill(pid_t pid, int sig); 
  2164. int sys32_kill(int pid, int sig)
  2165. {
  2166. return sys_kill(pid, sig);
  2167. }
  2168.  
  2170. #if defined(CONFIG_NFSD) || defined(CONFIG_NFSD_MODULE)
  2171. /* Stuff for NFS server syscalls... */
  2172. struct nfsctl_svc32 {
  2173. u16 svc32_port;
  2174. s32 svc32_nthreads;
  2175. };
  2177. struct nfsctl_client32 {
  2178. s8 cl32_ident[NFSCLNT_IDMAX+1];
  2179. s32 cl32_naddr;
  2180. struct in_addr cl32_addrlist[NFSCLNT_ADDRMAX];
  2181. s32 cl32_fhkeytype;
  2182. s32 cl32_fhkeylen;
  2183. u8 cl32_fhkey[NFSCLNT_KEYMAX];
  2184. };
  2186. struct nfsctl_export32 {
  2187. s8 ex32_client[NFSCLNT_IDMAX+1];
  2188. s8 ex32_path[NFS_MAXPATHLEN+1];
  2189. __kernel_dev_t32 ex32_dev;
  2190. __kernel_ino_t32 ex32_ino;
  2191. s32 ex32_flags;
  2192. __kernel_uid_t32 ex32_anon_uid;
  2193. __kernel_gid_t32 ex32_anon_gid;
  2194. };
  2196. struct nfsctl_uidmap32 {
  2197. u32 ug32_ident;   /* char * */
  2198. __kernel_uid_t32 ug32_uidbase;
  2199. s32 ug32_uidlen;
  2200. u32 ug32_udimap;  /* uid_t * */
  2201. __kernel_uid_t32 ug32_gidbase;
  2202. s32 ug32_gidlen;
  2203. u32 ug32_gdimap;  /* gid_t * */
  2204. };
  2206. struct nfsctl_fhparm32 {
  2207. struct sockaddr gf32_addr;
  2208. __kernel_dev_t32 gf32_dev;
  2209. __kernel_ino_t32 gf32_ino;
  2210. s32 gf32_version;
  2211. };
  2213. struct nfsctl_fdparm32 {
  2214. struct sockaddr gd32_addr;
  2215. s8 gd32_path[NFS_MAXPATHLEN+1];
  2216. s32 gd32_version;
  2217. };
  2219. struct nfsctl_fsparm32 {
  2220. struct sockaddr gd32_addr;
  2221. s8 gd32_path[NFS_MAXPATHLEN+1];
  2222. s32 gd32_maxlen;
  2223. };
  2225. struct nfsctl_arg32 {
  2226. s32 ca32_version; /* safeguard */
  2227. union {
  2228. struct nfsctl_svc32 u32_svc;
  2229. struct nfsctl_client32 u32_client;
  2230. struct nfsctl_export32 u32_export;
  2231. struct nfsctl_uidmap32 u32_umap;
  2232. struct nfsctl_fhparm32 u32_getfh;
  2233. struct nfsctl_fdparm32 u32_getfd;
  2234. struct nfsctl_fsparm32 u32_getfs;
  2235. } u;
  2236. #define ca32_svc u.u32_svc
  2237. #define ca32_client u.u32_client
  2238. #define ca32_export u.u32_export
  2239. #define ca32_umap u.u32_umap
  2240. #define ca32_getfh u.u32_getfh
  2241. #define ca32_getfd u.u32_getfd
  2242. #define ca32_getfs u.u32_getfs
  2243. #define ca32_authd u.u32_authd
  2244. };
  2246. union nfsctl_res32 {
  2247. __u8 cr32_getfh[NFS_FHSIZE];
  2248. struct knfsd_fh cr32_getfs;
  2249. };
  2251. static int nfs_svc32_trans(struct nfsctl_arg *karg, struct nfsctl_arg32 *arg32)
  2252. {
  2253. int err;
  2255. err = get_user(karg->ca_version, &arg32->ca32_version);
  2256. err |= __get_user(karg->ca_svc.svc_port, &arg32->ca32_svc.svc32_port);
  2257. err |= __get_user(karg->ca_svc.svc_nthreads, &arg32->ca32_svc.svc32_nthreads);
  2258. return err;
  2259. }
  2261. static int nfs_clnt32_trans(struct nfsctl_arg *karg, struct nfsctl_arg32 *arg32)
  2262. {
  2263. int err;
  2265. err = get_user(karg->ca_version, &arg32->ca32_version);
  2266. err |= copy_from_user(&karg->ca_client.cl_ident[0],
  2267.   &arg32->ca32_client.cl32_ident[0],
  2268.   NFSCLNT_IDMAX);
  2269. err |= __get_user(karg->ca_client.cl_naddr, &arg32->ca32_client.cl32_naddr);
  2270. err |= copy_from_user(&karg->ca_client.cl_addrlist[0],
  2271.   &arg32->ca32_client.cl32_addrlist[0],
  2272.   (sizeof(struct in_addr) * NFSCLNT_ADDRMAX));
  2273. err |= __get_user(karg->ca_client.cl_fhkeytype,
  2274.       &arg32->ca32_client.cl32_fhkeytype);
  2275. err |= __get_user(karg->ca_client.cl_fhkeylen,
  2276.       &arg32->ca32_client.cl32_fhkeylen);
  2277. err |= copy_from_user(&karg->ca_client.cl_fhkey[0],
  2278.   &arg32->ca32_client.cl32_fhkey[0],
  2279.   NFSCLNT_KEYMAX);
  2280. return err;
  2281. }
  2283. static int nfs_exp32_trans(struct nfsctl_arg *karg, struct nfsctl_arg32 *arg32)
  2284. {
  2285. int err;
  2287. err = get_user(karg->ca_version, &arg32->ca32_version);
  2288. err |= copy_from_user(&karg->ca_export.ex_client[0],
  2289.   &arg32->ca32_export.ex32_client[0],
  2290.   NFSCLNT_IDMAX);
  2291. err |= copy_from_user(&karg->ca_export.ex_path[0],
  2292.   &arg32->ca32_export.ex32_path[0],
  2293.   NFS_MAXPATHLEN);
  2294. err |= __get_user(karg->ca_export.ex_dev,
  2295.       &arg32->ca32_export.ex32_dev);
  2296. err |= __get_user(karg->ca_export.ex_ino,
  2297.       &arg32->ca32_export.ex32_ino);
  2298. err |= __get_user(karg->ca_export.ex_flags,
  2299.       &arg32->ca32_export.ex32_flags);
  2300. err |= __get_user(karg->ca_export.ex_anon_uid,
  2301.       &arg32->ca32_export.ex32_anon_uid);
  2302. err |= __get_user(karg->ca_export.ex_anon_gid,
  2303.       &arg32->ca32_export.ex32_anon_gid);
  2304. karg->ca_export.ex_anon_uid = high2lowuid(karg->ca_export.ex_anon_uid);
  2305. karg->ca_export.ex_anon_gid = high2lowgid(karg->ca_export.ex_anon_gid);
  2306. return err;
  2307. }
  2309. static int nfs_uud32_trans(struct nfsctl_arg *karg, struct nfsctl_arg32 *arg32)
  2310. {
  2311. u32 uaddr;
  2312. int i;
  2313. int err;
  2315. memset(karg, 0, sizeof(*karg));
  2316. if(get_user(karg->ca_version, &arg32->ca32_version))
  2317. return -EFAULT;
  2318. karg->ca_umap.ug_ident = (char *)get_free_page(GFP_USER);
  2319. if(!karg->ca_umap.ug_ident)
  2320. return -ENOMEM;
  2321. err = get_user(uaddr, &arg32->ca32_umap.ug32_ident);
  2322. if(strncpy_from_user(karg->ca_umap.ug_ident,
  2323.      (char *)A(uaddr), PAGE_SIZE) <= 0)
  2324. return -EFAULT;
  2325. err |= __get_user(karg->ca_umap.ug_uidbase,
  2326.       &arg32->ca32_umap.ug32_uidbase);
  2327. err |= __get_user(karg->ca_umap.ug_uidlen,
  2328.       &arg32->ca32_umap.ug32_uidlen);
  2329. err |= __get_user(uaddr, &arg32->ca32_umap.ug32_udimap);
  2330. if (err)
  2331. return -EFAULT;
  2332. karg->ca_umap.ug_udimap = kmalloc((sizeof(uid_t) * karg->ca_umap.ug_uidlen),
  2333.   GFP_USER);
  2334. if(!karg->ca_umap.ug_udimap)
  2335. return -ENOMEM;
  2336. for(i = 0; i < karg->ca_umap.ug_uidlen; i++)
  2337. err |= __get_user(karg->ca_umap.ug_udimap[i],
  2338.       &(((__kernel_uid_t32 *)A(uaddr))[i]));
  2339. err |= __get_user(karg->ca_umap.ug_gidbase,
  2340.       &arg32->ca32_umap.ug32_gidbase);
  2341. err |= __get_user(karg->ca_umap.ug_uidlen,
  2342.       &arg32->ca32_umap.ug32_gidlen);
  2343. err |= __get_user(uaddr, &arg32->ca32_umap.ug32_gdimap);
  2344. if (err)
  2345. return -EFAULT;
  2346. karg->ca_umap.ug_gdimap = kmalloc((sizeof(gid_t) * karg->ca_umap.ug_uidlen),
  2347.   GFP_USER);
  2348. if(!karg->ca_umap.ug_gdimap)
  2349. return -ENOMEM;
  2350. for(i = 0; i < karg->ca_umap.ug_gidlen; i++)
  2351. err |= __get_user(karg->ca_umap.ug_gdimap[i],
  2352.       &(((__kernel_gid_t32 *)A(uaddr))[i]));
  2354. return err;
  2355. }
  2357. static int nfs_getfh32_trans(struct nfsctl_arg *karg, struct nfsctl_arg32 *arg32)
  2358. {
  2359. int err;
  2361. err = get_user(karg->ca_version, &arg32->ca32_version);
  2362. err |= copy_from_user(&karg->ca_getfh.gf_addr,
  2363.   &arg32->ca32_getfh.gf32_addr,
  2364.   (sizeof(struct sockaddr)));
  2365. err |= __get_user(karg->ca_getfh.gf_dev,
  2366.       &arg32->ca32_getfh.gf32_dev);
  2367. err |= __get_user(karg->ca_getfh.gf_ino,
  2368.       &arg32->ca32_getfh.gf32_ino);
  2369. err |= __get_user(karg->ca_getfh.gf_version,
  2370.       &arg32->ca32_getfh.gf32_version);
  2371. return err;
  2372. }
  2374. static int nfs_getfd32_trans(struct nfsctl_arg *karg, struct nfsctl_arg32 *arg32)
  2375. {
  2376. int err;
  2378. err = get_user(karg->ca_version, &arg32->ca32_version);
  2379. err |= copy_from_user(&karg->ca_getfd.gd_addr,
  2380.   &arg32->ca32_getfd.gd32_addr,
  2381.   (sizeof(struct sockaddr)));
  2382. err |= copy_from_user(&karg->ca_getfd.gd_path,
  2383.   &arg32->ca32_getfd.gd32_path,
  2384.   (NFS_MAXPATHLEN+1));
  2385. err |= get_user(karg->ca_getfd.gd_version,
  2386.       &arg32->ca32_getfd.gd32_version);
  2387. return err;
  2388. }
  2390. static int nfs_getfs32_trans(struct nfsctl_arg *karg, struct nfsctl_arg32 *arg32)
  2391. {
  2392. int err;
  2394. err = get_user(karg->ca_version, &arg32->ca32_version);
  2395. err |= copy_from_user(&karg->ca_getfs.gd_addr,
  2396.   &arg32->ca32_getfs.gd32_addr,
  2397.   (sizeof(struct sockaddr)));
  2398. err |= copy_from_user(&karg->ca_getfs.gd_path,
  2399.   &arg32->ca32_getfs.gd32_path,
  2400.   (NFS_MAXPATHLEN+1));
  2401. err |= get_user(karg->ca_getfs.gd_maxlen,
  2402.       &arg32->ca32_getfs.gd32_maxlen);
  2403. return err;
  2404. }
  2406. /* This really doesn't need translations, we are only passing
  2407.  * back a union which contains opaque nfs file handle data.
  2408.  */
  2409. static int nfs_getfh32_res_trans(union nfsctl_res *kres, union nfsctl_res32 *res32)
  2410. {
  2411. return copy_to_user(res32, kres, sizeof(*res32));
  2412. }
  2414. int asmlinkage sys32_nfsservctl(int cmd, struct nfsctl_arg32 *arg32, union nfsctl_res32 *res32)
  2415. {
  2416. struct nfsctl_arg *karg = NULL;
  2417. union nfsctl_res *kres = NULL;
  2418. mm_segment_t oldfs;
  2419. int err;
  2421. karg = kmalloc(sizeof(*karg), GFP_USER);
  2422. if(!karg)
  2423. return -ENOMEM;
  2424. if(res32) {
  2425. kres = kmalloc(sizeof(*kres), GFP_USER);
  2426. if(!kres) {
  2427. kfree(karg);
  2428. return -ENOMEM;
  2429. }
  2430. }
  2431. switch(cmd) {
  2432. case NFSCTL_SVC:
  2433. err = nfs_svc32_trans(karg, arg32);
  2434. break;
  2435. case NFSCTL_ADDCLIENT:
  2436. err = nfs_clnt32_trans(karg, arg32);
  2437. break;
  2438. case NFSCTL_DELCLIENT:
  2439. err = nfs_clnt32_trans(karg, arg32);
  2440. break;
  2441. case NFSCTL_EXPORT:
  2442. case NFSCTL_UNEXPORT:
  2443. err = nfs_exp32_trans(karg, arg32);
  2444. break;
  2445. /* This one is unimplemented, be we're ready for it. */
  2446. case NFSCTL_UGIDUPDATE:
  2447. err = nfs_uud32_trans(karg, arg32);
  2448. break;
  2449. case NFSCTL_GETFH:
  2450. err = nfs_getfh32_trans(karg, arg32);
  2451. break;
  2452. case NFSCTL_GETFD:
  2453. err = nfs_getfd32_trans(karg, arg32);
  2454. break;
  2455. case NFSCTL_GETFS:
  2456. err = nfs_getfs32_trans(karg, arg32);
  2457. break;
  2458. default:
  2459. err = -EINVAL;
  2460. break;
  2461. }
  2462. if(err)
  2463. goto done;
  2464. oldfs = get_fs();
  2465. set_fs(KERNEL_DS);
  2466. err = sys_nfsservctl(cmd, karg, kres);
  2467. set_fs(oldfs);
  2469. if (err)
  2470. goto done;
  2472. if((cmd == NFSCTL_GETFH) ||
  2473.    (cmd == NFSCTL_GETFD) ||
  2474.    (cmd == NFSCTL_GETFS))
  2475. err = nfs_getfh32_res_trans(kres, res32);
  2477. done:
  2478. if(karg) {
  2479. if(cmd == NFSCTL_UGIDUPDATE) {
  2480. if(karg->ca_umap.ug_ident)
  2481. kfree(karg->ca_umap.ug_ident);
  2482. if(karg->ca_umap.ug_udimap)
  2483. kfree(karg->ca_umap.ug_udimap);
  2484. if(karg->ca_umap.ug_gdimap)
  2485. kfree(karg->ca_umap.ug_gdimap);
  2486. }
  2487. kfree(karg);
  2488. }
  2489. if(kres)
  2490. kfree(kres);
  2491. return err;
  2492. }
  2493. #else /* !NFSD */
  2494. extern asmlinkage long sys_ni_syscall(void);
  2495. int asmlinkage sys32_nfsservctl(int cmd, void *notused, void *notused2)
  2496. {
  2497. return sys_ni_syscall();
  2498. }
  2499. #endif
  2501. int sys32_module_warning(void)
  2502. { 
  2503. static long warn_time = -(60*HZ); 
  2504. if (time_before(warn_time + 60*HZ,jiffies) && strcmp(current->comm,"klogd")) { 
  2505. printk(KERN_INFO "%s: 32bit modutils not supported on 64bit kerneln",
  2506.        current->comm);
  2507. warn_time = jiffies;
  2508. } 
  2509. return -ENOSYS ;
  2510. } 
  2512. struct exec_domain ia32_exec_domain = { 
  2513. name: "linux/x86",
  2514. pers_low: PER_LINUX32,
  2515. pers_high: PER_LINUX32,
  2516. };      
  2518. static int __init ia32_init (void)
  2519. {
  2520. printk("IA32 emulation $Id: sys_ia32.c,v 1.42 2002/09/17 15:23:41 ak Exp $n");  
  2521. ia32_exec_domain.signal_map = default_exec_domain.signal_map;
  2522. ia32_exec_domain.signal_invmap = default_exec_domain.signal_invmap;
  2523. register_exec_domain(&ia32_exec_domain);
  2524. return 0;
  2525. }
  2527. __initcall(ia32_init);