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

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

Linux/Unix编程

开发平台：

Unix_Linux

linux32.c：源码内容
  1. /*
  2.  *  arch/s390x/kernel/linux32.c
  3.  *
  4.  *  S390 version
  5.  *    Copyright (C) 2000 IBM Deutschland Entwicklung GmbH, IBM Corporation
  6.  *    Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com),
  7.  *               Gerhard Tonn (ton@de.ibm.com)   
  8.  *
  9.  *  Conversion between 31bit and 64bit native syscalls.
  10.  *
  11.  * Heavily inspired by the 32-bit Sparc compat code which is 
  12.  * Copyright (C) 1997,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
  13.  * Copyright (C) 1997 David S. Miller (davem@caip.rutgers.edu)
  14.  *
  15.  */
  18. #include <linux/config.h>
  19. #include <linux/kernel.h>
  20. #include <linux/sched.h>
  21. #include <linux/fs.h> 
  22. #include <linux/mm.h> 
  23. #include <linux/file.h> 
  24. #include <linux/signal.h>
  25. #include <linux/utime.h>
  26. #include <linux/resource.h>
  27. #include <linux/times.h>
  28. #include <linux/utsname.h>
  29. #include <linux/timex.h>
  30. #include <linux/smp.h>
  31. #include <linux/smp_lock.h>
  32. #include <linux/sem.h>
  33. #include <linux/msg.h>
  34. #include <linux/shm.h>
  35. #include <linux/slab.h>
  36. #include <linux/uio.h>
  37. #include <linux/nfs_fs.h>
  38. #include <linux/smb_fs.h>
  39. #include <linux/smb_mount.h>
  40. #include <linux/ncp_fs.h>
  41. #include <linux/quota.h>
  42. #include <linux/module.h>
  43. #include <linux/sunrpc/svc.h>
  44. #include <linux/nfsd/nfsd.h>
  45. #include <linux/nfsd/cache.h>
  46. #include <linux/nfsd/xdr.h>
  47. #include <linux/nfsd/syscall.h>
  48. #include <linux/poll.h>
  49. #include <linux/personality.h>
  50. #include <linux/stat.h>
  51. #include <linux/filter.h>
  52. #include <linux/highmem.h>
  53. #include <linux/highuid.h>
  54. #include <linux/mman.h>
  55. #include <linux/ipv6.h>
  56. #include <linux/in.h>
  57. #include <linux/icmpv6.h>
  58. #include <linux/sysctl.h>
  60. #include <asm/types.h>
  61. #include <asm/ipc.h>
  62. #include <asm/uaccess.h>
  63. #include <asm/semaphore.h>
  65. #include <net/scm.h>
  67. #include "linux32.h"
  69. extern asmlinkage long sys_chown(const char *, uid_t,gid_t);
  70. extern asmlinkage long sys_lchown(const char *, uid_t,gid_t);
  71. extern asmlinkage long sys_fchown(unsigned int, uid_t,gid_t);
  72. extern asmlinkage long sys_setregid(gid_t, gid_t);
  73. extern asmlinkage long sys_setgid(gid_t);
  74. extern asmlinkage long sys_setreuid(uid_t, uid_t);
  75. extern asmlinkage long sys_setuid(uid_t);
  76. extern asmlinkage long sys_setresuid(uid_t, uid_t, uid_t);
  77. extern asmlinkage long sys_setresgid(gid_t, gid_t, gid_t);
  78. extern asmlinkage long sys_setfsuid(uid_t);
  79. extern asmlinkage long sys_setfsgid(gid_t);
  80.  
  81. /* For this source file, we want overflow handling. */
  83. #undef high2lowuid
  84. #undef high2lowgid
  85. #undef low2highuid
  86. #undef low2highgid
  87. #undef SET_UID16
  88. #undef SET_GID16
  89. #undef NEW_TO_OLD_UID
  90. #undef NEW_TO_OLD_GID
  91. #undef SET_OLDSTAT_UID
  92. #undef SET_OLDSTAT_GID
  93. #undef SET_STAT_UID
  94. #undef SET_STAT_GID
  96. #define high2lowuid(uid) ((uid) > 65535) ? (u16)overflowuid : (u16)(uid)
  97. #define high2lowgid(gid) ((gid) > 65535) ? (u16)overflowgid : (u16)(gid)
  98. #define low2highuid(uid) ((uid) == (u16)-1) ? (uid_t)-1 : (uid_t)(uid)
  99. #define low2highgid(gid) ((gid) == (u16)-1) ? (gid_t)-1 : (gid_t)(gid)
  100. #define SET_UID16(var, uid) var = high2lowuid(uid)
  101. #define SET_GID16(var, gid) var = high2lowgid(gid)
  102. #define NEW_TO_OLD_UID(uid) high2lowuid(uid)
  103. #define NEW_TO_OLD_GID(gid) high2lowgid(gid)
  104. #define SET_OLDSTAT_UID(stat, uid) (stat).st_uid = high2lowuid(uid)
  105. #define SET_OLDSTAT_GID(stat, gid) (stat).st_gid = high2lowgid(gid)
  106. #define SET_STAT_UID(stat, uid) (stat).st_uid = high2lowuid(uid)
  107. #define SET_STAT_GID(stat, gid) (stat).st_gid = high2lowgid(gid)
  109. asmlinkage long sys32_chown16(const char * filename, u16 user, u16 group)
  110. {
  111. return sys_chown(filename, low2highuid(user), low2highgid(group));
  112. }
  114. asmlinkage long sys32_lchown16(const char * filename, u16 user, u16 group)
  115. {
  116. return sys_lchown(filename, low2highuid(user), low2highgid(group));
  117. }
  119. asmlinkage long sys32_fchown16(unsigned int fd, u16 user, u16 group)
  120. {
  121. return sys_fchown(fd, low2highuid(user), low2highgid(group));
  122. }
  124. asmlinkage long sys32_setregid16(u16 rgid, u16 egid)
  125. {
  126. return sys_setregid(low2highgid(rgid), low2highgid(egid));
  127. }
  129. asmlinkage long sys32_setgid16(u16 gid)
  130. {
  131. return sys_setgid((gid_t)gid);
  132. }
  134. asmlinkage long sys32_setreuid16(u16 ruid, u16 euid)
  135. {
  136. return sys_setreuid(low2highuid(ruid), low2highuid(euid));
  137. }
  139. asmlinkage long sys32_setuid16(u16 uid)
  140. {
  141. return sys_setuid((uid_t)uid);
  142. }
  144. asmlinkage long sys32_setresuid16(u16 ruid, u16 euid, u16 suid)
  145. {
  146. return sys_setresuid(low2highuid(ruid), low2highuid(euid),
  147. low2highuid(suid));
  148. }
  150. asmlinkage long sys32_getresuid16(u16 *ruid, u16 *euid, u16 *suid)
  151. {
  152. int retval;
  154. if (!(retval = put_user(high2lowuid(current->uid), ruid)) &&
  155.     !(retval = put_user(high2lowuid(current->euid), euid)))
  156. retval = put_user(high2lowuid(current->suid), suid);
  158. return retval;
  159. }
  161. asmlinkage long sys32_setresgid16(u16 rgid, u16 egid, u16 sgid)
  162. {
  163. return sys_setresgid(low2highgid(rgid), low2highgid(egid),
  164. low2highgid(sgid));
  165. }
  167. asmlinkage long sys32_getresgid16(u16 *rgid, u16 *egid, u16 *sgid)
  168. {
  169. int retval;
  171. if (!(retval = put_user(high2lowgid(current->gid), rgid)) &&
  172.     !(retval = put_user(high2lowgid(current->egid), egid)))
  173. retval = put_user(high2lowgid(current->sgid), sgid);
  175. return retval;
  176. }
  178. asmlinkage long sys32_setfsuid16(u16 uid)
  179. {
  180. return sys_setfsuid((uid_t)uid);
  181. }
  183. asmlinkage long sys32_setfsgid16(u16 gid)
  184. {
  185. return sys_setfsgid((gid_t)gid);
  186. }
  188. asmlinkage long sys32_getgroups16(int gidsetsize, u16 *grouplist)
  189. {
  190. u16 groups[NGROUPS];
  191. int i,j;
  193. if (gidsetsize < 0)
  194. return -EINVAL;
  195. i = current->ngroups;
  196. if (gidsetsize) {
  197. if (i > gidsetsize)
  198. return -EINVAL;
  199. for(j=0;j<i;j++)
  200. groups[j] = current->groups[j];
  201. if (copy_to_user(grouplist, groups, sizeof(u16)*i))
  202. return -EFAULT;
  203. }
  204. return i;
  205. }
  207. asmlinkage long sys32_setgroups16(int gidsetsize, u16 *grouplist)
  208. {
  209. u16 groups[NGROUPS];
  210. int i;
  212. if (!capable(CAP_SETGID))
  213. return -EPERM;
  214. if ((unsigned) gidsetsize > NGROUPS)
  215. return -EINVAL;
  216. if (copy_from_user(groups, grouplist, gidsetsize * sizeof(u16)))
  217. return -EFAULT;
  218. for (i = 0 ; i < gidsetsize ; i++)
  219. current->groups[i] = (gid_t)groups[i];
  220. current->ngroups = gidsetsize;
  221. return 0;
  222. }
  224. asmlinkage long sys32_getuid16(void)
  225. {
  226. return high2lowuid(current->uid);
  227. }
  229. asmlinkage long sys32_geteuid16(void)
  230. {
  231. return high2lowuid(current->euid);
  232. }
  234. asmlinkage long sys32_getgid16(void)
  235. {
  236. return high2lowgid(current->gid);
  237. }
  239. asmlinkage long sys32_getegid16(void)
  240. {
  241. return high2lowgid(current->egid);
  242. }
  244. /* 32-bit timeval and related flotsam.  */
  246. struct timeval32
  247. {
  248.     int tv_sec, tv_usec;
  249. };
  251. struct itimerval32
  252. {
  253.     struct timeval32 it_interval;
  254.     struct timeval32 it_value;
  255. };
  257. static inline long get_tv32(struct timeval *o, struct timeval32 *i)
  258. {
  259. return (!access_ok(VERIFY_READ, tv32, sizeof(*tv32)) ||
  260. (__get_user(o->tv_sec, &i->tv_sec) |
  261.  __get_user(o->tv_usec, &i->tv_usec)));
  262. }
  264. static inline long put_tv32(struct timeval32 *o, struct timeval *i)
  265. {
  266. return (!access_ok(VERIFY_WRITE, o, sizeof(*o)) ||
  267. (__put_user(i->tv_sec, &o->tv_sec) |
  268.  __put_user(i->tv_usec, &o->tv_usec)));
  269. }
  271. static inline long get_it32(struct itimerval *o, struct itimerval32 *i)
  272. {
  273. return (!access_ok(VERIFY_READ, i32, sizeof(*i32)) ||
  274. (__get_user(o->it_interval.tv_sec, &i->it_interval.tv_sec) |
  275.  __get_user(o->it_interval.tv_usec, &i->it_interval.tv_usec) |
  276.  __get_user(o->it_value.tv_sec, &i->it_value.tv_sec) |
  277.  __get_user(o->it_value.tv_usec, &i->it_value.tv_usec)));
  278. }
  280. static inline long put_it32(struct itimerval32 *o, struct itimerval *i)
  281. {
  282. return (!access_ok(VERIFY_WRITE, i32, sizeof(*i32)) ||
  283. (__put_user(i->it_interval.tv_sec, &o->it_interval.tv_sec) |
  284.  __put_user(i->it_interval.tv_usec, &o->it_interval.tv_usec) |
  285.  __put_user(i->it_value.tv_sec, &o->it_value.tv_sec) |
  286.  __put_user(i->it_value.tv_usec, &o->it_value.tv_usec)));
  287. }
  289. struct msgbuf32 { s32 mtype; char mtext[1]; };
  291. struct ipc64_perm_ds32
  292. {
  293.         __kernel_key_t          key;
  294.         __kernel_uid32_t        uid;
  295.         __kernel_gid32_t        gid;
  296.         __kernel_uid32_t        cuid;
  297.         __kernel_gid32_t        cgid;
  298.         __kernel_mode_t32       mode;
  299.         unsigned short          __pad1;
  300.         unsigned short          seq;
  301.         unsigned short          __pad2;
  302.         unsigned int            __unused1;
  303.         unsigned int            __unused2;
  304. };
  306. struct ipc_perm32
  307. {
  308. key_t       key;
  309.         __kernel_uid_t32  uid;
  310.         __kernel_gid_t32  gid;
  311.         __kernel_uid_t32  cuid;
  312.         __kernel_gid_t32  cgid;
  313.         __kernel_mode_t32 mode;
  314.         unsigned short  seq;
  315. };
  317. struct semid_ds32 {
  318.         struct ipc_perm32 sem_perm;               /* permissions .. see ipc.h */
  319.         __kernel_time_t32 sem_otime;              /* last semop time */
  320.         __kernel_time_t32 sem_ctime;              /* last change time */
  321.         u32 sem_base;              /* ptr to first semaphore in array */
  322.         u32 sem_pending;          /* pending operations to be processed */
  323.         u32 sem_pending_last;    /* last pending operation */
  324.         u32 undo;                  /* undo requests on this array */
  325.         unsigned short  sem_nsems;              /* no. of semaphores in array */
  326. };
  328. struct semid64_ds32 {
  329. struct ipc64_perm_ds32 sem_perm;
  330. unsigned int   __pad1;
  331. __kernel_time_t32 sem_otime;
  332. unsigned int   __pad2;
  333. __kernel_time_t32 sem_ctime;
  334. u32 sem_nsems;
  335. u32 __unused1;
  336. u32 __unused2;
  337. };
  339. struct msqid_ds32
  340. {
  341.         struct ipc_perm32 msg_perm;
  342.         u32 msg_first;
  343.         u32 msg_last;
  344.         __kernel_time_t32 msg_stime;
  345.         __kernel_time_t32 msg_rtime;
  346.         __kernel_time_t32 msg_ctime;
  347.         u32 wwait;
  348.         u32 rwait;
  349.         unsigned short msg_cbytes;
  350.         unsigned short msg_qnum;  
  351.         unsigned short msg_qbytes;
  352.         __kernel_ipc_pid_t32 msg_lspid;
  353.         __kernel_ipc_pid_t32 msg_lrpid;
  354. };
  356. struct msqid64_ds32 {
  357. struct ipc64_perm_ds32 msg_perm;
  358. unsigned int   __pad1;
  359. __kernel_time_t32 msg_stime;
  360. unsigned int   __pad2;
  361. __kernel_time_t32 msg_rtime;
  362. unsigned int   __pad3;
  363. __kernel_time_t32 msg_ctime;
  364. unsigned int  msg_cbytes;
  365. unsigned int  msg_qnum;
  366. unsigned int  msg_qbytes;
  367. __kernel_pid_t32 msg_lspid;
  368. __kernel_pid_t32 msg_lrpid;
  369. unsigned int  __unused1;
  370. unsigned int  __unused2;
  371. };
  374. struct shmid_ds32 {
  375. struct ipc_perm32       shm_perm;
  376. int                     shm_segsz;
  377. __kernel_time_t32       shm_atime;
  378. __kernel_time_t32       shm_dtime;
  379. __kernel_time_t32       shm_ctime;
  380. __kernel_ipc_pid_t32    shm_cpid; 
  381. __kernel_ipc_pid_t32    shm_lpid; 
  382. unsigned short          shm_nattch;
  383. };
  385. struct shmid64_ds32 {
  386. struct ipc64_perm_ds32 shm_perm;
  387. unsigned int __pad1;
  388. __kernel_time_t32 shm_atime;
  389. unsigned int __pad2;
  390. __kernel_time_t32 shm_dtime;
  391. unsigned int __pad3;
  392. __kernel_time_t32 shm_ctime;
  393. __kernel_size_t32 shm_segsz;
  394. __kernel_pid_t32 shm_cpid;
  395. __kernel_pid_t32 shm_lpid;
  396. unsigned int shm_nattch;
  397. unsigned int __unused1;
  398. unsigned int __unused2;
  399. };
  401.                                                         
  402. /*
  403.  * sys32_ipc() is the de-multiplexer for the SysV IPC calls in 32bit emulation..
  404.  *
  405.  * This is really horribly ugly.
  406.  */
  407. #define IPCOP_MASK(__x) (1UL << (__x))
  408. static int do_sys32_semctl(int first, int second, int third, void *uptr)
  409. {
  410. union semun fourth;
  411. u32 pad;
  412. int err = -EINVAL;
  414. if (!uptr)
  415. goto out;
  416. err = -EFAULT;
  417. if (get_user (pad, (u32 *)uptr))
  418. goto out;
  419. if(third == SETVAL)
  420. fourth.val = (int)pad;
  421. else
  422. fourth.__pad = (void *)A(pad);
  423. if (IPCOP_MASK (third) &
  424.     (IPCOP_MASK (IPC_INFO) | IPCOP_MASK (SEM_INFO) | IPCOP_MASK (GETVAL) |
  425.      IPCOP_MASK (GETPID) | IPCOP_MASK (GETNCNT) | IPCOP_MASK (GETZCNT) |
  426.      IPCOP_MASK (GETALL) | IPCOP_MASK (SETALL) | IPCOP_MASK (IPC_RMID))) {
  427. err = sys_semctl (first, second, third, fourth);
  428. } else if (third & IPC_64) {
  429. struct semid64_ds s;
  430. struct semid64_ds32 *usp = (struct semid64_ds32 *)A(pad);
  431. mm_segment_t old_fs;
  432. int need_back_translation;
  434. if (third == (IPC_SET|IPC_64)) {
  435. err = get_user (s.sem_perm.uid, &usp->sem_perm.uid);
  436. err |= __get_user (s.sem_perm.gid, &usp->sem_perm.gid);
  437. err |= __get_user (s.sem_perm.mode, &usp->sem_perm.mode);
  438. if (err)
  439. goto out;
  440. fourth.__pad = &s;
  441. }
  442. need_back_translation =
  443. (IPCOP_MASK (third) &
  444.  (IPCOP_MASK (SEM_STAT) | IPCOP_MASK (IPC_STAT))) != 0;
  445. if (need_back_translation)
  446. fourth.__pad = &s;
  447. old_fs = get_fs ();
  448. set_fs (KERNEL_DS);
  449. err = sys_semctl (first, second, third, fourth);
  450. set_fs (old_fs);
  451. if (need_back_translation) {
  452. int err2 = put_user (s.sem_perm.key, &usp->sem_perm.key);
  453. err2 |= __put_user (high2lowuid(s.sem_perm.uid), &usp->sem_perm.uid);
  454. err2 |= __put_user (high2lowgid(s.sem_perm.gid), &usp->sem_perm.gid);
  455. err2 |= __put_user (high2lowuid(s.sem_perm.cuid), &usp->sem_perm.cuid);
  456. err2 |= __put_user (high2lowgid(s.sem_perm.cgid), &usp->sem_perm.cgid);
  457. err2 |= __put_user (s.sem_perm.mode, &usp->sem_perm.mode);
  458. err2 |= __put_user (s.sem_perm.seq, &usp->sem_perm.seq);
  459. err2 |= __put_user (s.sem_otime, &usp->sem_otime);
  460. err2 |= __put_user (s.sem_ctime, &usp->sem_ctime);
  461. err2 |= __put_user (s.sem_nsems, &usp->sem_nsems);
  462. if (err2) err = -EFAULT;
  463. }
  464. } else {
  465. struct semid_ds s;
  466. struct semid_ds32 *usp = (struct semid_ds32 *)A(pad);
  467. mm_segment_t old_fs;
  468. int need_back_translation;
  470. if (third == IPC_SET) {
  471. err = get_user (s.sem_perm.uid, &usp->sem_perm.uid);
  472. err |= __get_user (s.sem_perm.gid, &usp->sem_perm.gid);
  473. err |= __get_user (s.sem_perm.mode, &usp->sem_perm.mode);
  474. if (err)
  475. goto out;
  476. fourth.__pad = &s;
  477. }
  478. need_back_translation =
  479. (IPCOP_MASK (third) &
  480.  (IPCOP_MASK (SEM_STAT) | IPCOP_MASK (IPC_STAT))) != 0;
  481. if (need_back_translation)
  482. fourth.__pad = &s;
  483. old_fs = get_fs ();
  484. set_fs (KERNEL_DS);
  485. err = sys_semctl (first, second, third, fourth);
  486. set_fs (old_fs);
  487. if (need_back_translation) {
  488. int err2 = put_user (s.sem_perm.key, &usp->sem_perm.key);
  489. err2 |= __put_user (high2lowuid(s.sem_perm.uid), &usp->sem_perm.uid);
  490. err2 |= __put_user (high2lowgid(s.sem_perm.gid), &usp->sem_perm.gid);
  491. err2 |= __put_user (high2lowuid(s.sem_perm.cuid), &usp->sem_perm.cuid);
  492. err2 |= __put_user (high2lowgid(s.sem_perm.cgid), &usp->sem_perm.cgid);
  493. err2 |= __put_user (s.sem_perm.mode, &usp->sem_perm.mode);
  494. err2 |= __put_user (s.sem_perm.seq, &usp->sem_perm.seq);
  495. err2 |= __put_user (s.sem_otime, &usp->sem_otime);
  496. err2 |= __put_user (s.sem_ctime, &usp->sem_ctime);
  497. err2 |= __put_user (s.sem_nsems, &usp->sem_nsems);
  498. if (err2) err = -EFAULT;
  499. }
  500. }
  501. out:
  502. return err;
  503. }
  505. static int do_sys32_msgsnd (int first, int second, int third, void *uptr)
  506. {
  507. struct msgbuf *p = kmalloc (second + sizeof (struct msgbuf) + 4, GFP_USER);
  508. struct msgbuf32 *up = (struct msgbuf32 *)uptr;
  509. mm_segment_t old_fs;
  510. int err;
  512. if (!p)
  513. return -ENOMEM;
  514. err = get_user (p->mtype, &up->mtype);
  515. err |= __copy_from_user (p->mtext, &up->mtext, second);
  516. if (err)
  517. goto out;
  518. old_fs = get_fs ();
  519. set_fs (KERNEL_DS);
  520. err = sys_msgsnd (first, p, second, third);
  521. set_fs (old_fs);
  522. out:
  523. kfree (p);
  524. return err;
  525. }
  527. static int do_sys32_msgrcv (int first, int second, int msgtyp, int third,
  528.     int version, void *uptr)
  529. {
  530. struct msgbuf32 *up;
  531. struct msgbuf *p;
  532. mm_segment_t old_fs;
  533. int err;
  535. if (!version) {
  536. struct ipc_kludge_32 *uipck = (struct ipc_kludge_32 *)uptr;
  537. struct ipc_kludge_32 ipck;
  539. err = -EINVAL;
  540. if (!uptr)
  541. goto out;
  542. err = -EFAULT;
  543. if (copy_from_user (&ipck, uipck, sizeof (struct ipc_kludge_32)))
  544. goto out;
  545. uptr = (void *)A(ipck.msgp);
  546. msgtyp = ipck.msgtyp;
  547. }
  548. err = -ENOMEM;
  549. p = kmalloc (second + sizeof (struct msgbuf) + 4, GFP_USER);
  550. if (!p)
  551. goto out;
  552. old_fs = get_fs ();
  553. set_fs (KERNEL_DS);
  554. err = sys_msgrcv (first, p, second + 4, msgtyp, third);
  555. set_fs (old_fs);
  556. if (err < 0)
  557. goto free_then_out;
  558. up = (struct msgbuf32 *)uptr;
  559. if (put_user (p->mtype, &up->mtype) ||
  560.     __copy_to_user (&up->mtext, p->mtext, err))
  561. err = -EFAULT;
  562. free_then_out:
  563. kfree (p);
  564. out:
  565. return err;
  566. }
  568. static int do_sys32_msgctl (int first, int second, void *uptr)
  569. {
  570. int err;
  572. if (IPCOP_MASK (second) &
  573.     (IPCOP_MASK (IPC_INFO) | IPCOP_MASK (MSG_INFO) |
  574.      IPCOP_MASK (IPC_RMID))) {
  575. err = sys_msgctl (first, second, (struct msqid_ds *)uptr);
  576. } else if (second & IPC_64) {
  577. struct msqid64_ds m;
  578. struct msqid64_ds32 *up = (struct msqid64_ds32 *)uptr;
  579. mm_segment_t old_fs;
  581. if (second == (IPC_SET|IPC_64)) {
  582. err = get_user (m.msg_perm.uid, &up->msg_perm.uid);
  583. err |= __get_user (m.msg_perm.gid, &up->msg_perm.gid);
  584. err |= __get_user (m.msg_perm.mode, &up->msg_perm.mode);
  585. err |= __get_user (m.msg_qbytes, &up->msg_qbytes);
  586. if (err)
  587. goto out;
  588. }
  589. old_fs = get_fs ();
  590. set_fs (KERNEL_DS);
  591. err = sys_msgctl (first, second, (struct msqid_ds *)&m);
  592. set_fs (old_fs);
  593. if (IPCOP_MASK (second) &
  594.     (IPCOP_MASK (MSG_STAT) | IPCOP_MASK (IPC_STAT))) {
  595. int err2 = put_user (m.msg_perm.key, &up->msg_perm.key);
  596. err2 |= __put_user (high2lowuid(m.msg_perm.uid), &up->msg_perm.uid);
  597. err2 |= __put_user (high2lowgid(m.msg_perm.gid), &up->msg_perm.gid);
  598. err2 |= __put_user (high2lowuid(m.msg_perm.cuid), &up->msg_perm.cuid);
  599. err2 |= __put_user (high2lowgid(m.msg_perm.cgid), &up->msg_perm.cgid);
  600. err2 |= __put_user (m.msg_perm.mode, &up->msg_perm.mode);
  601. err2 |= __put_user (m.msg_perm.seq, &up->msg_perm.seq);
  602. err2 |= __put_user (m.msg_stime, &up->msg_stime);
  603. err2 |= __put_user (m.msg_rtime, &up->msg_rtime);
  604. err2 |= __put_user (m.msg_ctime, &up->msg_ctime);
  605. err2 |= __put_user (m.msg_cbytes, &up->msg_cbytes);
  606. err2 |= __put_user (m.msg_qnum, &up->msg_qnum);
  607. err2 |= __put_user (m.msg_qbytes, &up->msg_qbytes);
  608. err2 |= __put_user (m.msg_lspid, &up->msg_lspid);
  609. err2 |= __put_user (m.msg_lrpid, &up->msg_lrpid);
  610. if (err2)
  611. err = -EFAULT;
  612. }
  613. } else {
  614. struct msqid_ds m;
  615. struct msqid_ds32 *up = (struct msqid_ds32 *)uptr;
  616. mm_segment_t old_fs;
  618. if (second == IPC_SET) {
  619. err = get_user (m.msg_perm.uid, &up->msg_perm.uid);
  620. err |= __get_user (m.msg_perm.gid, &up->msg_perm.gid);
  621. err |= __get_user (m.msg_perm.mode, &up->msg_perm.mode);
  622. err |= __get_user (m.msg_qbytes, &up->msg_qbytes);
  623. if (err)
  624. goto out;
  625. }
  626. old_fs = get_fs ();
  627. set_fs (KERNEL_DS);
  628. err = sys_msgctl (first, second, &m);
  629. set_fs (old_fs);
  630. if (IPCOP_MASK (second) &
  631.     (IPCOP_MASK (MSG_STAT) | IPCOP_MASK (IPC_STAT))) {
  632. int err2 = put_user (m.msg_perm.key, &up->msg_perm.key);
  633. err2 |= __put_user (high2lowuid(m.msg_perm.uid), &up->msg_perm.uid);
  634. err2 |= __put_user (high2lowgid(m.msg_perm.gid), &up->msg_perm.gid);
  635. err2 |= __put_user (high2lowuid(m.msg_perm.cuid), &up->msg_perm.cuid);
  636. err2 |= __put_user (high2lowgid(m.msg_perm.cgid), &up->msg_perm.cgid);
  637. err2 |= __put_user (m.msg_perm.mode, &up->msg_perm.mode);
  638. err2 |= __put_user (m.msg_perm.seq, &up->msg_perm.seq);
  639. err2 |= __put_user (m.msg_stime, &up->msg_stime);
  640. err2 |= __put_user (m.msg_rtime, &up->msg_rtime);
  641. err2 |= __put_user (m.msg_ctime, &up->msg_ctime);
  642. err2 |= __put_user (m.msg_cbytes, &up->msg_cbytes);
  643. err2 |= __put_user (m.msg_qnum, &up->msg_qnum);
  644. err2 |= __put_user (m.msg_qbytes, &up->msg_qbytes);
  645. err2 |= __put_user (m.msg_lspid, &up->msg_lspid);
  646. err2 |= __put_user (m.msg_lrpid, &up->msg_lrpid);
  647. if (err2)
  648. err = -EFAULT;
  649. }
  650. }
  652. out:
  653. return err;
  654. }
  656. static int do_sys32_shmat (int first, int second, int third, int version, void *uptr)
  657. {
  658. unsigned long raddr;
  659. u32 *uaddr = (u32 *)A((u32)third);
  660. int err = -EINVAL;
  662. if (version == 1)
  663. goto out;
  664. err = sys_shmat (first, uptr, second, &raddr);
  665. if (err)
  666. goto out;
  667. err = put_user (raddr, uaddr);
  668. out:
  669. return err;
  670. }
  672. static int do_sys32_shmctl (int first, int second, void *uptr)
  673. {
  674. int err;
  676. if (IPCOP_MASK (second) &
  677.     (IPCOP_MASK (IPC_INFO) | IPCOP_MASK (SHM_LOCK) | IPCOP_MASK (SHM_UNLOCK) |
  678.      IPCOP_MASK (IPC_RMID))) {
  679. if (second == (IPC_INFO|IPC_64))
  680. second = IPC_INFO; /* So that we don't have to translate it */
  681. err = sys_shmctl (first, second, (struct shmid_ds *)uptr);
  682. } else if ((second & IPC_64) && second != (SHM_INFO|IPC_64)) {
  683. struct shmid64_ds s;
  684. struct shmid64_ds32 *up = (struct shmid64_ds32 *)uptr;
  685. mm_segment_t old_fs;
  687. if (second == (IPC_SET|IPC_64)) {
  688. err = get_user (s.shm_perm.uid, &up->shm_perm.uid);
  689. err |= __get_user (s.shm_perm.gid, &up->shm_perm.gid);
  690. err |= __get_user (s.shm_perm.mode, &up->shm_perm.mode);
  691. if (err)
  692. goto out;
  693. }
  694. old_fs = get_fs ();
  695. set_fs (KERNEL_DS);
  696. err = sys_shmctl (first, second, (struct shmid_ds *)&s);
  697. set_fs (old_fs);
  698. if (err < 0)
  699. goto out;
  701. /* Mask it even in this case so it becomes a CSE. */
  702. if (IPCOP_MASK (second) &
  703.     (IPCOP_MASK (SHM_STAT) | IPCOP_MASK (IPC_STAT))) {
  704. int err2 = put_user (s.shm_perm.key, &up->shm_perm.key);
  705. err2 |= __put_user (high2lowuid(s.shm_perm.uid), &up->shm_perm.uid);
  706. err2 |= __put_user (high2lowgid(s.shm_perm.gid), &up->shm_perm.gid);
  707. err2 |= __put_user (high2lowuid(s.shm_perm.cuid), &up->shm_perm.cuid);
  708. err2 |= __put_user (high2lowgid(s.shm_perm.cgid), &up->shm_perm.cgid);
  709. err2 |= __put_user (s.shm_perm.mode, &up->shm_perm.mode);
  710. err2 |= __put_user (s.shm_perm.seq, &up->shm_perm.seq);
  711. err2 |= __put_user (s.shm_atime, &up->shm_atime);
  712. err2 |= __put_user (s.shm_dtime, &up->shm_dtime);
  713. err2 |= __put_user (s.shm_ctime, &up->shm_ctime);
  714. err2 |= __put_user (s.shm_segsz, &up->shm_segsz);
  715. err2 |= __put_user (s.shm_nattch, &up->shm_nattch);
  716. err2 |= __put_user (s.shm_cpid, &up->shm_cpid);
  717. err2 |= __put_user (s.shm_lpid, &up->shm_lpid);
  718. if (err2)
  719. err = -EFAULT;
  720. }
  721. } else {
  722. struct shmid_ds s;
  723. struct shmid_ds32 *up = (struct shmid_ds32 *)uptr;
  724. mm_segment_t old_fs;
  726. second &= ~IPC_64;
  727. if (second == IPC_SET) {
  728. err = get_user (s.shm_perm.uid, &up->shm_perm.uid);
  729. err |= __get_user (s.shm_perm.gid, &up->shm_perm.gid);
  730. err |= __get_user (s.shm_perm.mode, &up->shm_perm.mode);
  731. if (err)
  732. goto out;
  733. }
  734. old_fs = get_fs ();
  735. set_fs (KERNEL_DS);
  736. err = sys_shmctl (first, second, &s);
  737. set_fs (old_fs);
  738. if (err < 0)
  739. goto out;
  741. /* Mask it even in this case so it becomes a CSE. */
  742. if (second == SHM_INFO) {
  743. struct shm_info32 {
  744. int used_ids;
  745. u32 shm_tot, shm_rss, shm_swp;
  746. u32 swap_attempts, swap_successes;
  747. } *uip = (struct shm_info32 *)uptr;
  748. struct shm_info *kp = (struct shm_info *)&s;
  749. int err2 = put_user (kp->used_ids, &uip->used_ids);
  750. err2 |= __put_user (kp->shm_tot, &uip->shm_tot);
  751. err2 |= __put_user (kp->shm_rss, &uip->shm_rss);
  752. err2 |= __put_user (kp->shm_swp, &uip->shm_swp);
  753. err2 |= __put_user (kp->swap_attempts, &uip->swap_attempts);
  754. err2 |= __put_user (kp->swap_successes, &uip->swap_successes);
  755. if (err2)
  756. err = -EFAULT;
  757. } else if (IPCOP_MASK (second) &
  758.    (IPCOP_MASK (SHM_STAT) | IPCOP_MASK (IPC_STAT))) {
  759. int err2 = put_user (s.shm_perm.key, &up->shm_perm.key);
  760. err2 |= __put_user (high2lowuid(s.shm_perm.uid), &up->shm_perm.uid);
  761. err2 |= __put_user (high2lowgid(s.shm_perm.gid), &up->shm_perm.gid);
  762. err2 |= __put_user (high2lowuid(s.shm_perm.cuid), &up->shm_perm.cuid);
  763. err2 |= __put_user (high2lowgid(s.shm_perm.cgid), &up->shm_perm.cgid);
  764. err2 |= __put_user (s.shm_perm.mode, &up->shm_perm.mode);
  765. err2 |= __put_user (s.shm_perm.seq, &up->shm_perm.seq);
  766. err2 |= __put_user (s.shm_atime, &up->shm_atime);
  767. err2 |= __put_user (s.shm_dtime, &up->shm_dtime);
  768. err2 |= __put_user (s.shm_ctime, &up->shm_ctime);
  769. err2 |= __put_user (s.shm_segsz, &up->shm_segsz);
  770. err2 |= __put_user (s.shm_nattch, &up->shm_nattch);
  771. err2 |= __put_user (s.shm_cpid, &up->shm_cpid);
  772. err2 |= __put_user (s.shm_lpid, &up->shm_lpid);
  773. if (err2)
  774. err = -EFAULT;
  775. }
  776. }
  777. out:
  778. return err;
  779. }
  781. asmlinkage int sys32_ipc (u32 call, int first, int second, int third, u32 ptr, u32 fifth)
  782. {
  783. int version, err;
  785. version = call >> 16; /* hack for backward compatibility */
  786. call &= 0xffff;
  788. if(version)
  789. return -EINVAL;
  791. if (call <= SEMCTL)
  792. switch (call) {
  793. case SEMOP:
  794. /* struct sembuf is the same on 32 and 64bit :)) */
  795. err = sys_semop (first, (struct sembuf *)AA(ptr), second);
  796. goto out;
  797. case SEMGET:
  798. err = sys_semget (first, second, third);
  799. goto out;
  800. case SEMCTL:
  801. err = do_sys32_semctl (first, second, third, (void *)AA(ptr));
  802. goto out;
  803. default:
  804. err = -EINVAL;
  805. goto out;
  806. };
  807. if (call <= MSGCTL) 
  808. switch (call) {
  809. case MSGSND:
  810. err = do_sys32_msgsnd (first, second, third, (void *)AA(ptr));
  811. goto out;
  812. case MSGRCV:
  813. err = do_sys32_msgrcv (first, second, 0, third,
  814.        version, (void *)AA(ptr));
  815. goto out;
  816. case MSGGET:
  817. err = sys_msgget ((key_t) first, second);
  818. goto out;
  819. case MSGCTL:
  820. err = do_sys32_msgctl (first, second, (void *)AA(ptr));
  821. goto out;
  822. default:
  823. err = -EINVAL;
  824. goto out;
  825. }
  826. if (call <= SHMCTL) 
  827. switch (call) {
  828. case SHMAT:
  829. err = do_sys32_shmat (first, second, third,
  830.       version, (void *)AA(ptr));
  831. goto out;
  832. case SHMDT: 
  833. err = sys_shmdt ((char *)AA(ptr));
  834. goto out;
  835. case SHMGET:
  836. err = sys_shmget (first, second, third);
  837. goto out;
  838. case SHMCTL:
  839. err = do_sys32_shmctl (first, second, (void *)AA(ptr));
  840. goto out;
  841. default:
  842. err = -EINVAL;
  843. goto out;
  844. }
  846. err = -EINVAL;
  848. out:
  849. return err;
  850. }
  852. static inline int get_flock(struct flock *kfl, struct flock32 *ufl)
  853. {
  854. int err;
  856. err = get_user(kfl->l_type, &ufl->l_type);
  857. err |= __get_user(kfl->l_whence, &ufl->l_whence);
  858. err |= __get_user(kfl->l_start, &ufl->l_start);
  859. err |= __get_user(kfl->l_len, &ufl->l_len);
  860. err |= __get_user(kfl->l_pid, &ufl->l_pid);
  861. return err;
  862. }
  864. static inline int put_flock(struct flock *kfl, struct flock32 *ufl)
  865. {
  866. int err;
  868. err = __put_user(kfl->l_type, &ufl->l_type);
  869. err |= __put_user(kfl->l_whence, &ufl->l_whence);
  870. err |= __put_user(kfl->l_start, &ufl->l_start);
  871. err |= __put_user(kfl->l_len, &ufl->l_len);
  872. err |= __put_user(kfl->l_pid, &ufl->l_pid);
  873. return err;
  874. }
  876. extern asmlinkage long sys_fcntl(unsigned int fd, unsigned int cmd, unsigned long arg);
  878. asmlinkage long sys32_fcntl(unsigned int fd, unsigned int cmd, unsigned long arg)
  879. {
  880. switch (cmd) {
  881. case F_GETLK:
  882. case F_SETLK:
  883. case F_SETLKW:
  884. {
  885. struct flock f;
  886. mm_segment_t old_fs;
  887. long ret;
  889. if(get_flock(&f, (struct flock32 *)arg))
  890. return -EFAULT;
  891. old_fs = get_fs(); set_fs (KERNEL_DS);
  892. ret = sys_fcntl(fd, cmd, (unsigned long)&f);
  893. set_fs (old_fs);
  894. if (ret) return ret;
  895. if (f.l_start >= 0x7fffffffUL ||
  896.     f.l_len >= 0x7fffffffUL ||
  897.     f.l_start + f.l_len >= 0x7fffffffUL)
  898. return -EOVERFLOW;
  899. if(put_flock(&f, (struct flock32 *)arg))
  900. return -EFAULT;
  901. return 0;
  902. }
  903. default:
  904. return sys_fcntl(fd, cmd, (unsigned long)arg);
  905. }
  906. }
  908. asmlinkage long sys32_fcntl64(unsigned int fd, unsigned int cmd, unsigned long arg)
  909. {
  910. if (cmd >= F_GETLK64 && cmd <= F_SETLKW64)
  911. return sys_fcntl(fd, cmd + F_GETLK - F_GETLK64, arg);
  912. return sys32_fcntl(fd, cmd, arg);
  913. }
  915. struct dqblk32 {
  916.     __u32 dqb_bhardlimit;
  917.     __u32 dqb_bsoftlimit;
  918.     __u32 dqb_curblocks;
  919.     __u32 dqb_ihardlimit;
  920.     __u32 dqb_isoftlimit;
  921.     __u32 dqb_curinodes;
  922.     __kernel_time_t32 dqb_btime;
  923.     __kernel_time_t32 dqb_itime;
  924. };
  925.                                 
  926. extern asmlinkage int sys_quotactl(int cmd, const char *special, int id, caddr_t addr);
  928. asmlinkage int sys32_quotactl(int cmd, const char *special, int id, unsigned long addr)
  929. {
  930. int cmds = cmd >> SUBCMDSHIFT;
  931. int err;
  932. struct dqblk d;
  933. mm_segment_t old_fs;
  934. char *spec;
  936. switch (cmds) {
  937. case Q_GETQUOTA:
  938. break;
  939. case Q_SETQUOTA:
  940. case Q_SETUSE:
  941. case Q_SETQLIM:
  942. if (copy_from_user (&d, (struct dqblk32 *)addr,
  943.     sizeof (struct dqblk32)))
  944. return -EFAULT;
  945. d.dqb_itime = ((struct dqblk32 *)&d)->dqb_itime;
  946. d.dqb_btime = ((struct dqblk32 *)&d)->dqb_btime;
  947. break;
  948. default:
  949. return sys_quotactl(cmd, special,
  950.     id, (caddr_t)addr);
  951. }
  952. spec = getname (special);
  953. err = PTR_ERR(spec);
  954. if (IS_ERR(spec)) return err;
  955. old_fs = get_fs ();
  956. set_fs (KERNEL_DS);
  957. err = sys_quotactl(cmd, (const char *)spec, id, (caddr_t)&d);
  958. set_fs (old_fs);
  959. putname (spec);
  960. if (err)
  961. return err;
  962. if (cmds == Q_GETQUOTA) {
  963. __kernel_time_t b = d.dqb_btime, i = d.dqb_itime;
  964. ((struct dqblk32 *)&d)->dqb_itime = i;
  965. ((struct dqblk32 *)&d)->dqb_btime = b;
  966. if (copy_to_user ((struct dqblk32 *)addr, &d,
  967.   sizeof (struct dqblk32)))
  968. return -EFAULT;
  969. }
  970. return 0;
  971. }
  973. static inline int put_statfs (struct statfs32 *ubuf, struct statfs *kbuf)
  974. {
  975. int err;
  977. err = put_user (kbuf->f_type, &ubuf->f_type);
  978. err |= __put_user (kbuf->f_bsize, &ubuf->f_bsize);
  979. err |= __put_user (kbuf->f_blocks, &ubuf->f_blocks);
  980. err |= __put_user (kbuf->f_bfree, &ubuf->f_bfree);
  981. err |= __put_user (kbuf->f_bavail, &ubuf->f_bavail);
  982. err |= __put_user (kbuf->f_files, &ubuf->f_files);
  983. err |= __put_user (kbuf->f_ffree, &ubuf->f_ffree);
  984. err |= __put_user (kbuf->f_namelen, &ubuf->f_namelen);
  985. err |= __put_user (kbuf->f_fsid.val[0], &ubuf->f_fsid.val[0]);
  986. err |= __put_user (kbuf->f_fsid.val[1], &ubuf->f_fsid.val[1]);
  987. return err;
  988. }
  990. extern asmlinkage int sys_statfs(const char * path, struct statfs * buf);
  992. asmlinkage int sys32_statfs(const char * path, struct statfs32 *buf)
  993. {
  994. int ret;
  995. struct statfs s;
  996. mm_segment_t old_fs = get_fs();
  997. char *pth;
  999. pth = getname (path);
  1000. ret = PTR_ERR(pth);
  1001. if (!IS_ERR(pth)) {
  1002. set_fs (KERNEL_DS);
  1003. ret = sys_statfs((const char *)pth, &s);
  1004. set_fs (old_fs);
  1005. putname (pth);
  1006. if (put_statfs(buf, &s))
  1007. return -EFAULT;
  1008. }
  1009. return ret;
  1010. }
  1012. extern asmlinkage int sys_fstatfs(unsigned int fd, struct statfs * buf);
  1014. asmlinkage int sys32_fstatfs(unsigned int fd, struct statfs32 *buf)
  1015. {
  1016. int ret;
  1017. struct statfs s;
  1018. mm_segment_t old_fs = get_fs();
  1020. set_fs (KERNEL_DS);
  1021. ret = sys_fstatfs(fd, &s);
  1022. set_fs (old_fs);
  1023. if (put_statfs(buf, &s))
  1024. return -EFAULT;
  1025. return ret;
  1026. }
  1028. extern asmlinkage long sys_truncate(const char * path, unsigned long length);
  1029. extern asmlinkage long sys_ftruncate(unsigned int fd, unsigned long length);
  1031. asmlinkage int sys32_truncate64(const char * path, unsigned long high, unsigned long low)
  1032. {
  1033. if ((int)high < 0)
  1034. return -EINVAL;
  1035. else
  1036. return sys_truncate(path, (high << 32) | low);
  1037. }
  1039. asmlinkage int sys32_ftruncate64(unsigned int fd, unsigned long high, unsigned long low)
  1040. {
  1041. if ((int)high < 0)
  1042. return -EINVAL;
  1043. else
  1044. return sys_ftruncate(fd, (high << 32) | low);
  1045. }
  1047. extern asmlinkage int sys_utime(char * filename, struct utimbuf * times);
  1049. struct utimbuf32 {
  1050. __kernel_time_t32 actime, modtime;
  1051. };
  1053. asmlinkage int sys32_utime(char * filename, struct utimbuf32 *times)
  1054. {
  1055. struct utimbuf t;
  1056. mm_segment_t old_fs;
  1057. int ret;
  1058. char *filenam;
  1060. if (!times)
  1061. return sys_utime(filename, NULL);
  1062. if (get_user (t.actime, &times->actime) ||
  1063.     __get_user (t.modtime, &times->modtime))
  1064. return -EFAULT;
  1065. filenam = getname (filename);
  1066. ret = PTR_ERR(filenam);
  1067. if (!IS_ERR(filenam)) {
  1068. old_fs = get_fs();
  1069. set_fs (KERNEL_DS); 
  1070. ret = sys_utime(filenam, &t);
  1071. set_fs (old_fs);
  1072. putname (filenam);
  1073. }
  1074. return ret;
  1075. }
  1077. struct iovec32 { u32 iov_base; __kernel_size_t32 iov_len; };
  1079. typedef ssize_t (*io_fn_t)(struct file *, char *, size_t, loff_t *);
  1080. typedef ssize_t (*iov_fn_t)(struct file *, const struct iovec *, unsigned long, loff_t *);
  1082. static long do_readv_writev32(int type, struct file *file,
  1083.       const struct iovec32 *vector, u32 count)
  1084. {
  1085. unsigned long tot_len;
  1086. struct iovec iovstack[UIO_FASTIOV];
  1087. struct iovec *iov=iovstack, *ivp;
  1088. struct inode *inode;
  1089. long retval, i;
  1090. io_fn_t fn;
  1091. iov_fn_t fnv;
  1093. /* First get the "struct iovec" from user memory and
  1094.  * verify all the pointers
  1095.  */
  1096. if (!count)
  1097. return 0;
  1098. if (verify_area(VERIFY_READ, vector, sizeof(struct iovec32)*count))
  1099. return -EFAULT;
  1100. if (count > UIO_MAXIOV)
  1101. return -EINVAL;
  1102. if (count > UIO_FASTIOV) {
  1103. iov = kmalloc(count*sizeof(struct iovec), GFP_KERNEL);
  1104. if (!iov)
  1105. return -ENOMEM;
  1106. }
  1108. tot_len = 0;
  1109. i = count;
  1110. ivp = iov;
  1111. while(i > 0) {
  1112. u32 len;
  1113. u32 buf;
  1115. __get_user(len, &vector->iov_len);
  1116. __get_user(buf, &vector->iov_base);
  1117. tot_len += len;
  1118. ivp->iov_base = (void *)A(buf);
  1119. ivp->iov_len = (__kernel_size_t) len;
  1120. vector++;
  1121. ivp++;
  1122. i--;
  1123. }
  1125. inode = file->f_dentry->d_inode;
  1126. /* VERIFY_WRITE actually means a read, as we write to user space */
  1127. retval = locks_verify_area((type == VERIFY_WRITE
  1128.     ? FLOCK_VERIFY_READ : FLOCK_VERIFY_WRITE),
  1129.    inode, file, file->f_pos, tot_len);
  1130. if (retval)
  1131. goto out;
  1133. /* VERIFY_WRITE actually means a read, as we write to user space */
  1134. fnv = (type == VERIFY_WRITE ? file->f_op->readv : file->f_op->writev);
  1135. if (fnv) {
  1136. retval = fnv(file, iov, count, &file->f_pos);
  1137. goto out;
  1138. }
  1140. fn = (type == VERIFY_WRITE ? file->f_op->read :
  1141.       (io_fn_t) file->f_op->write);
  1143. ivp = iov;
  1144. while (count > 0) {
  1145. void * base;
  1146. int len, nr;
  1148. base = ivp->iov_base;
  1149. len = ivp->iov_len;
  1150. ivp++;
  1151. count--;
  1152. nr = fn(file, base, len, &file->f_pos);
  1153. if (nr < 0) {
  1154. if (!retval)
  1155. retval = nr;
  1156. break;
  1157. }
  1158. retval += nr;
  1159. if (nr != len)
  1160. break;
  1161. }
  1162. out:
  1163. if (iov != iovstack)
  1164. kfree(iov);
  1166. return retval;
  1167. }
  1169. asmlinkage long sys32_readv(int fd, struct iovec32 *vector, u32 count)
  1170. {
  1171. struct file *file;
  1172. long ret = -EBADF;
  1174. file = fget(fd);
  1175. if(!file)
  1176. goto bad_file;
  1178. if (file->f_op && (file->f_mode & FMODE_READ) &&
  1179.     (file->f_op->readv || file->f_op->read))
  1180. ret = do_readv_writev32(VERIFY_WRITE, file, vector, count);
  1181. fput(file);
  1183. bad_file:
  1184. return ret;
  1185. }
  1187. asmlinkage long sys32_writev(int fd, struct iovec32 *vector, u32 count)
  1188. {
  1189. struct file *file;
  1190. int ret = -EBADF;
  1192. file = fget(fd);
  1193. if(!file)
  1194. goto bad_file;
  1195. if (file->f_op && (file->f_mode & FMODE_WRITE) &&
  1196.     (file->f_op->writev || file->f_op->write))
  1197. ret = do_readv_writev32(VERIFY_READ, file, vector, count);
  1198. fput(file);
  1200. bad_file:
  1201. return ret;
  1202. }
  1204. /* readdir & getdents */
  1206. #define NAME_OFFSET(de) ((int) ((de)->d_name - (char *) (de)))
  1207. #define ROUND_UP(x) (((x)+sizeof(u32)-1) & ~(sizeof(u32)-1))
  1209. struct old_linux_dirent32 {
  1210. u32 d_ino;
  1211. u32 d_offset;
  1212. unsigned short d_namlen;
  1213. char d_name[1];
  1214. };
  1216. struct readdir_callback32 {
  1217. struct old_linux_dirent32 * dirent;
  1218. int count;
  1219. };
  1221. static int fillonedir(void * __buf, const char * name, int namlen,
  1222.       loff_t offset, ino_t ino, unsigned int d_type)
  1223. {
  1224. struct readdir_callback32 * buf = (struct readdir_callback32 *) __buf;
  1225. struct old_linux_dirent32 * dirent;
  1227. if (buf->count)
  1228. return -EINVAL;
  1229. buf->count++;
  1230. dirent = buf->dirent;
  1231. put_user(ino, &dirent->d_ino);
  1232. put_user(offset, &dirent->d_offset);
  1233. put_user(namlen, &dirent->d_namlen);
  1234. copy_to_user(dirent->d_name, name, namlen);
  1235. put_user(0, dirent->d_name + namlen);
  1236. return 0;
  1237. }
  1239. asmlinkage int old32_readdir(unsigned int fd, struct old_linux_dirent32 *dirent, unsigned int count)
  1240. {
  1241. int error = -EBADF;
  1242. struct file * file;
  1243. struct readdir_callback32 buf;
  1245. file = fget(fd);
  1246. if (!file)
  1247. goto out;
  1249. buf.count = 0;
  1250. buf.dirent = dirent;
  1252. error = vfs_readdir(file, fillonedir, &buf);
  1253. if (error < 0)
  1254. goto out_putf;
  1255. error = buf.count;
  1257. out_putf:
  1258. fput(file);
  1259. out:
  1260. return error;
  1261. }
  1263. struct linux_dirent32 {
  1264. u32 d_ino;
  1265. u32 d_off;
  1266. unsigned short d_reclen;
  1267. char d_name[1];
  1268. };
  1270. struct getdents_callback32 {
  1271. struct linux_dirent32 * current_dir;
  1272. struct linux_dirent32 * previous;
  1273. int count;
  1274. int error;
  1275. };
  1277. static int filldir(void * __buf, const char * name, int namlen, loff_t offset, ino_t ino,
  1278.    unsigned int d_type)
  1279. {
  1280. struct linux_dirent32 * dirent;
  1281. struct getdents_callback32 * buf = (struct getdents_callback32 *) __buf;
  1282. int reclen = ROUND_UP(NAME_OFFSET(dirent) + namlen + 1);
  1284. buf->error = -EINVAL; /* only used if we fail.. */
  1285. if (reclen > buf->count)
  1286. return -EINVAL;
  1287. dirent = buf->previous;
  1288. if (dirent)
  1289. put_user(offset, &dirent->d_off);
  1290. dirent = buf->current_dir;
  1291. buf->previous = dirent;
  1292. put_user(ino, &dirent->d_ino);
  1293. put_user(reclen, &dirent->d_reclen);
  1294. copy_to_user(dirent->d_name, name, namlen);
  1295. put_user(0, dirent->d_name + namlen);
  1296. ((char *) dirent) += reclen;
  1297. buf->current_dir = dirent;
  1298. buf->count -= reclen;
  1299. return 0;
  1300. }
  1302. asmlinkage int sys32_getdents(unsigned int fd, struct linux_dirent32 *dirent, unsigned int count)
  1303. {
  1304. struct file * file;
  1305. struct linux_dirent32 * lastdirent;
  1306. struct getdents_callback32 buf;
  1307. int error = -EBADF;
  1309. file = fget(fd);
  1310. if (!file)
  1311. goto out;
  1313. buf.current_dir = dirent;
  1314. buf.previous = NULL;
  1315. buf.count = count;
  1316. buf.error = 0;
  1318. error = vfs_readdir(file, filldir, &buf);
  1319. if (error < 0)
  1320. goto out_putf;
  1321. lastdirent = buf.previous;
  1322. error = buf.error;
  1323. if(lastdirent) {
  1324. put_user(file->f_pos, &lastdirent->d_off);
  1325. error = count - buf.count;
  1326. }
  1327. out_putf:
  1328. fput(file);
  1329. out:
  1330. return error;
  1331. }
  1333. /* end of readdir & getdents */
  1335. /*
  1336.  * Ooo, nasty.  We need here to frob 32-bit unsigned longs to
  1337.  * 64-bit unsigned longs.
  1338.  */
  1340. static inline int
  1341. get_fd_set32(unsigned long n, unsigned long *fdset, u32 *ufdset)
  1342. {
  1343. if (ufdset) {
  1344. unsigned long odd;
  1346. if (verify_area(VERIFY_WRITE, ufdset, n*sizeof(u32)))
  1347. return -EFAULT;
  1349. odd = n & 1UL;
  1350. n &= ~1UL;
  1351. while (n) {
  1352. unsigned long h, l;
  1353. __get_user(l, ufdset);
  1354. __get_user(h, ufdset+1);
  1355. ufdset += 2;
  1356. *fdset++ = h << 32 | l;
  1357. n -= 2;
  1358. }
  1359. if (odd)
  1360. __get_user(*fdset, ufdset);
  1361. } else {
  1362. /* Tricky, must clear full unsigned long in the
  1363.  * kernel fdset at the end, this makes sure that
  1364.  * actually happens.
  1365.  */
  1366. memset(fdset, 0, ((n + 1) & ~1)*sizeof(u32));
  1367. }
  1368. return 0;
  1369. }
  1371. static inline void
  1372. set_fd_set32(unsigned long n, u32 *ufdset, unsigned long *fdset)
  1373. {
  1374. unsigned long odd;
  1376. if (!ufdset)
  1377. return;
  1379. odd = n & 1UL;
  1380. n &= ~1UL;
  1381. while (n) {
  1382. unsigned long h, l;
  1383. l = *fdset++;
  1384. h = l >> 32;
  1385. __put_user(l, ufdset);
  1386. __put_user(h, ufdset+1);
  1387. ufdset += 2;
  1388. n -= 2;
  1389. }
  1390. if (odd)
  1391. __put_user(*fdset, ufdset);
  1392. }
  1394. #define MAX_SELECT_SECONDS 
  1395. ((unsigned long) (MAX_SCHEDULE_TIMEOUT / HZ)-1)
  1397. asmlinkage int sys32_select(int n, u32 *inp, u32 *outp, u32 *exp, u32 tvp_x)
  1398. {
  1399. fd_set_bits fds;
  1400. struct timeval32 *tvp = (struct timeval32 *)AA(tvp_x);
  1401. char *bits;
  1402. unsigned long nn;
  1403. long timeout;
  1404. int ret, size;
  1406. timeout = MAX_SCHEDULE_TIMEOUT;
  1407. if (tvp) {
  1408. int sec, usec;
  1410. if ((ret = verify_area(VERIFY_READ, tvp, sizeof(*tvp)))
  1411.     || (ret = __get_user(sec, &tvp->tv_sec))
  1412.     || (ret = __get_user(usec, &tvp->tv_usec)))
  1413. goto out_nofds;
  1415. ret = -EINVAL;
  1416. if(sec < 0 || usec < 0)
  1417. goto out_nofds;
  1419. if ((unsigned long) sec < MAX_SELECT_SECONDS) {
  1420. timeout = (usec + 1000000/HZ - 1) / (1000000/HZ);
  1421. timeout += sec * (unsigned long) HZ;
  1422. }
  1423. }
  1425. ret = -EINVAL;
  1426. if (n < 0)
  1427. goto out_nofds;
  1428. if (n > current->files->max_fdset)
  1429. n = current->files->max_fdset;
  1431. /*
  1432.  * We need 6 bitmaps (in/out/ex for both incoming and outgoing),
  1433.  * since we used fdset we need to allocate memory in units of
  1434.  * long-words. 
  1435.  */
  1436. ret = -ENOMEM;
  1437. size = FDS_BYTES(n);
  1438. bits = kmalloc(6 * size, GFP_KERNEL);
  1439. if (!bits)
  1440. goto out_nofds;
  1441. fds.in      = (unsigned long *)  bits;
  1442. fds.out     = (unsigned long *) (bits +   size);
  1443. fds.ex      = (unsigned long *) (bits + 2*size);
  1444. fds.res_in  = (unsigned long *) (bits + 3*size);
  1445. fds.res_out = (unsigned long *) (bits + 4*size);
  1446. fds.res_ex  = (unsigned long *) (bits + 5*size);
  1448. nn = (n + 8*sizeof(u32) - 1) / (8*sizeof(u32));
  1449. if ((ret = get_fd_set32(nn, fds.in, inp)) ||
  1450.     (ret = get_fd_set32(nn, fds.out, outp)) ||
  1451.     (ret = get_fd_set32(nn, fds.ex, exp)))
  1452. goto out;
  1453. zero_fd_set(n, fds.res_in);
  1454. zero_fd_set(n, fds.res_out);
  1455. zero_fd_set(n, fds.res_ex);
  1457. ret = do_select(n, &fds, &timeout);
  1459. if (tvp && !(current->personality & STICKY_TIMEOUTS)) {
  1460. int sec = 0, usec = 0;
  1461. if (timeout) {
  1462. sec = timeout / HZ;
  1463. usec = timeout % HZ;
  1464. usec *= (1000000/HZ);
  1465. }
  1466. put_user(sec, &tvp->tv_sec);
  1467. put_user(usec, &tvp->tv_usec);
  1468. }
  1470. if (ret < 0)
  1471. goto out;
  1472. if (!ret) {
  1473. ret = -ERESTARTNOHAND;
  1474. if (signal_pending(current))
  1475. goto out;
  1476. ret = 0;
  1477. }
  1479. set_fd_set32(nn, inp, fds.res_in);
  1480. set_fd_set32(nn, outp, fds.res_out);
  1481. set_fd_set32(nn, exp, fds.res_ex);
  1483. out:
  1484. kfree(bits);
  1485. out_nofds:
  1486. return ret;
  1487. }
  1489. static int cp_new_stat32(struct inode *inode, struct stat32 *statbuf)
  1490. {
  1491. unsigned long ino, blksize, blocks;
  1492. kdev_t dev, rdev;
  1493. umode_t mode;
  1494. nlink_t nlink;
  1495. uid_t uid;
  1496. gid_t gid;
  1497. off_t size;
  1498. time_t atime, mtime, ctime;
  1499. int err;
  1501. /* Stream the loads of inode data into the load buffer,
  1502.  * then we push it all into the store buffer below.  This
  1503.  * should give optimal cache performance.
  1504.  */
  1505. ino = inode->i_ino;
  1506. dev = inode->i_dev;
  1507. mode = inode->i_mode;
  1508. nlink = inode->i_nlink;
  1509. uid = inode->i_uid;
  1510. gid = inode->i_gid;
  1511. rdev = inode->i_rdev;
  1512. size = inode->i_size;
  1513. atime = inode->i_atime;
  1514. mtime = inode->i_mtime;
  1515. ctime = inode->i_ctime;
  1516. blksize = inode->i_blksize;
  1517. blocks = inode->i_blocks;
  1519. err  = put_user(kdev_t_to_nr(dev), &statbuf->st_dev);
  1520. err |= put_user(ino, &statbuf->st_ino);
  1521. err |= put_user(mode, &statbuf->st_mode);
  1522. err |= put_user(nlink, &statbuf->st_nlink);
  1523. err |= put_user(high2lowuid(uid), &statbuf->st_uid);
  1524. err |= put_user(high2lowgid(gid), &statbuf->st_gid);
  1525. err |= put_user(kdev_t_to_nr(rdev), &statbuf->st_rdev);
  1526. err |= put_user(size, &statbuf->st_size);
  1527. err |= put_user(atime, &statbuf->st_atime);
  1528. err |= put_user(0, &statbuf->__unused1);
  1529. err |= put_user(mtime, &statbuf->st_mtime);
  1530. err |= put_user(0, &statbuf->__unused2);
  1531. err |= put_user(ctime, &statbuf->st_ctime);
  1532. err |= put_user(0, &statbuf->__unused3);
  1533. if (blksize) {
  1534. err |= put_user(blksize, &statbuf->st_blksize);
  1535. err |= put_user(blocks, &statbuf->st_blocks);
  1536. } else {
  1537. unsigned int tmp_blocks;
  1539. #define D_B   7
  1540. #define I_B   (BLOCK_SIZE / sizeof(unsigned short))
  1541. tmp_blocks = (size + BLOCK_SIZE - 1) / BLOCK_SIZE;
  1542. if (tmp_blocks > D_B) {
  1543. unsigned int indirect;
  1545. indirect = (tmp_blocks - D_B + I_B - 1) / I_B;
  1546. tmp_blocks += indirect;
  1547. if (indirect > 1) {
  1548. indirect = (indirect - 1 + I_B - 1) / I_B;
  1549. tmp_blocks += indirect;
  1550. if (indirect > 1)
  1551. tmp_blocks++;
  1552. }
  1553. }
  1554. err |= put_user(BLOCK_SIZE, &statbuf->st_blksize);
  1555. err |= put_user((BLOCK_SIZE / 512) * tmp_blocks, &statbuf->st_blocks);
  1556. #undef D_B
  1557. #undef I_B
  1558. }
  1559. /* fixme
  1560. err |= put_user(0, &statbuf->__unused4[0]);
  1561. err |= put_user(0, &statbuf->__unused4[1]);
  1562. */
  1564. return err;
  1565. }
  1567. /* Perhaps this belongs in fs.h or similar. -DaveM */
  1568. static __inline__ int
  1569. do_revalidate(struct dentry *dentry)
  1570. {
  1571. struct inode * inode = dentry->d_inode;
  1572. if (inode->i_op && inode->i_op->revalidate)
  1573. return inode->i_op->revalidate(dentry);
  1574. return 0;
  1575. }
  1577. asmlinkage int sys32_newstat(char * filename, struct stat32 *statbuf)
  1578. {
  1579. struct nameidata nd;
  1580. int error;
  1582. error = user_path_walk(filename, &nd);
  1583. if (!error) {
  1584. error = do_revalidate(nd.dentry);
  1585. if (!error)
  1586. error = cp_new_stat32(nd.dentry->d_inode, statbuf);
  1587. path_release(&nd);
  1588. }
  1589. return error;
  1590. }
  1592. asmlinkage int sys32_newlstat(char * filename, struct stat32 *statbuf)
  1593. {
  1594. struct nameidata nd;
  1595. int error;
  1597. error = user_path_walk_link(filename, &nd);
  1598. if (!error) {
  1599. error = do_revalidate(nd.dentry);
  1600. if (!error)
  1601. error = cp_new_stat32(nd.dentry->d_inode, statbuf);
  1603. path_release(&nd);
  1604. }
  1605. return error;
  1606. }
  1608. asmlinkage int sys32_newfstat(unsigned int fd, struct stat32 *statbuf)
  1609. {
  1610. struct file *f;
  1611. int err = -EBADF;
  1613. f = fget(fd);
  1614. if (f) {
  1615. struct dentry * dentry = f->f_dentry;
  1617. err = do_revalidate(dentry);
  1618. if (!err)
  1619. err = cp_new_stat32(dentry->d_inode, statbuf);
  1620. fput(f);
  1621. }
  1622. return err;
  1623. }
  1625. extern asmlinkage int sys_sysfs(int option, unsigned long arg1, unsigned long arg2);
  1627. asmlinkage int sys32_sysfs(int option, u32 arg1, u32 arg2)
  1628. {
  1629. return sys_sysfs(option, arg1, arg2);
  1630. }
  1632. struct ncp_mount_data32 {
  1633.         int version;
  1634.         unsigned int ncp_fd;
  1635.         __kernel_uid_t32 mounted_uid;
  1636.         __kernel_pid_t32 wdog_pid;
  1637.         unsigned char mounted_vol[NCP_VOLNAME_LEN + 1];
  1638.         unsigned int time_out;
  1639.         unsigned int retry_count;
  1640.         unsigned int flags;
  1641.         __kernel_uid_t32 uid;
  1642.         __kernel_gid_t32 gid;
  1643.         __kernel_mode_t32 file_mode;
  1644.         __kernel_mode_t32 dir_mode;
  1645. };
  1647. static void *do_ncp_super_data_conv(void *raw_data)
  1648. {
  1649. struct ncp_mount_data *n = (struct ncp_mount_data *)raw_data;
  1650. struct ncp_mount_data32 *n32 = (struct ncp_mount_data32 *)raw_data;
  1652. n->dir_mode = n32->dir_mode;
  1653. n->file_mode = n32->file_mode;
  1654. n->gid = low2highgid(n32->gid);
  1655. n->uid = low2highuid(n32->uid);
  1656. memmove (n->mounted_vol, n32->mounted_vol, (sizeof (n32->mounted_vol) + 3 * sizeof (unsigned int)));
  1657. n->wdog_pid = n32->wdog_pid;
  1658. n->mounted_uid = low2highuid(n32->mounted_uid);
  1659. return raw_data;
  1660. }
  1662. struct smb_mount_data32 {
  1663.         int version;
  1664.         __kernel_uid_t32 mounted_uid;
  1665.         __kernel_uid_t32 uid;
  1666.         __kernel_gid_t32 gid;
  1667.         __kernel_mode_t32 file_mode;
  1668.         __kernel_mode_t32 dir_mode;
  1669. };
  1671. static void *do_smb_super_data_conv(void *raw_data)
  1672. {
  1673. struct smb_mount_data *s = (struct smb_mount_data *)raw_data;
  1674. struct smb_mount_data32 *s32 = (struct smb_mount_data32 *)raw_data;
  1676. s->version = s32->version;
  1677. s->mounted_uid = low2highuid(s32->mounted_uid);
  1678. s->uid = low2highuid(s32->uid);
  1679. s->gid = low2highgid(s32->gid);
  1680. s->file_mode = s32->file_mode;
  1681. s->dir_mode = s32->dir_mode;
  1682. return raw_data;
  1683. }
  1685. static int copy_mount_stuff_to_kernel(const void *user, unsigned long *kernel)
  1686. {
  1687. int i;
  1688. unsigned long page;
  1689. struct vm_area_struct *vma;
  1691. *kernel = 0;
  1692. if(!user)
  1693. return 0;
  1694. vma = find_vma(current->mm, (unsigned long)user);
  1695. if(!vma || (unsigned long)user < vma->vm_start)
  1696. return -EFAULT;
  1697. if(!(vma->vm_flags & VM_READ))
  1698. return -EFAULT;
  1699. i = vma->vm_end - (unsigned long) user;
  1700. if(PAGE_SIZE <= (unsigned long) i)
  1701. i = PAGE_SIZE - 1;
  1702. if(!(page = __get_free_page(GFP_KERNEL)))
  1703. return -ENOMEM;
  1704. if(copy_from_user((void *) page, user, i)) {
  1705. free_page(page);
  1706. return -EFAULT;
  1707. }
  1708. *kernel = page;
  1709. return 0;
  1710. }
  1712. #define SMBFS_NAME "smbfs"
  1713. #define NCPFS_NAME "ncpfs"
  1715. asmlinkage int sys32_mount(char *dev_name, char *dir_name, char *type, unsigned long new_flags, u32 data)
  1716. {
  1717. unsigned long type_page = 0;
  1718. unsigned long data_page = 0;
  1719. unsigned long dev_page = 0;
  1720. unsigned long dir_page = 0;
  1721. int err, is_smb, is_ncp;
  1723. is_smb = is_ncp = 0;
  1725. err = copy_mount_stuff_to_kernel((const void *)type, &type_page);
  1726. if (err)
  1727. goto out;
  1729. if (!type_page) {
  1730. err = -EINVAL;
  1731. goto out;
  1732. }
  1734. is_smb = !strcmp((char *)type_page, SMBFS_NAME);
  1735. is_ncp = !strcmp((char *)type_page, NCPFS_NAME);
  1737. err = copy_mount_stuff_to_kernel((const void *)AA(data), &data_page);
  1738. if (err)
  1739. goto type_out;
  1741. err = copy_mount_stuff_to_kernel(dev_name, &dev_page);
  1742. if (err)
  1743. goto data_out;
  1745. err = copy_mount_stuff_to_kernel(dir_name, &dir_page);
  1746. if (err)
  1747. goto dev_out;
  1749. if (!is_smb && !is_ncp) {
  1750. lock_kernel();
  1751. err = do_mount((char*)dev_page, (char*)dir_page,
  1752. (char*)type_page, new_flags, (char*)data_page);
  1753. unlock_kernel();
  1754. } else {
  1755. if (is_ncp)
  1756. do_ncp_super_data_conv((void *)data_page);
  1757. else
  1758. do_smb_super_data_conv((void *)data_page);
  1760. lock_kernel();
  1761. err = do_mount((char*)dev_page, (char*)dir_page,
  1762. (char*)type_page, new_flags, (char*)data_page);
  1763. unlock_kernel();
  1764. }
  1765. free_page(dir_page);
  1767. dev_out:
  1768. free_page(dev_page);
  1770. data_out:
  1771. free_page(data_page);
  1773. type_out:
  1774. free_page(type_page);
  1776. out:
  1777. return err;
  1778. }
  1780. struct rusage32 {
  1781.         struct timeval32 ru_utime;
  1782.         struct timeval32 ru_stime;
  1783.         s32    ru_maxrss;
  1784.         s32    ru_ixrss;
  1785.         s32    ru_idrss;
  1786.         s32    ru_isrss;
  1787.         s32    ru_minflt;
  1788.         s32    ru_majflt;
  1789.         s32    ru_nswap;
  1790.         s32    ru_inblock;
  1791.         s32    ru_oublock;
  1792.         s32    ru_msgsnd; 
  1793.         s32    ru_msgrcv; 
  1794.         s32    ru_nsignals;
  1795.         s32    ru_nvcsw;
  1796.         s32    ru_nivcsw;
  1797. };
  1799. static int put_rusage (struct rusage32 *ru, struct rusage *r)
  1800. {
  1801. int err;
  1803. err = put_user (r->ru_utime.tv_sec, &ru->ru_utime.tv_sec);
  1804. err |= __put_user (r->ru_utime.tv_usec, &ru->ru_utime.tv_usec);
  1805. err |= __put_user (r->ru_stime.tv_sec, &ru->ru_stime.tv_sec);
  1806. err |= __put_user (r->ru_stime.tv_usec, &ru->ru_stime.tv_usec);
  1807. err |= __put_user (r->ru_maxrss, &ru->ru_maxrss);
  1808. err |= __put_user (r->ru_ixrss, &ru->ru_ixrss);
  1809. err |= __put_user (r->ru_idrss, &ru->ru_idrss);
  1810. err |= __put_user (r->ru_isrss, &ru->ru_isrss);
  1811. err |= __put_user (r->ru_minflt, &ru->ru_minflt);
  1812. err |= __put_user (r->ru_majflt, &ru->ru_majflt);
  1813. err |= __put_user (r->ru_nswap, &ru->ru_nswap);
  1814. err |= __put_user (r->ru_inblock, &ru->ru_inblock);
  1815. err |= __put_user (r->ru_oublock, &ru->ru_oublock);
  1816. err |= __put_user (r->ru_msgsnd, &ru->ru_msgsnd);
  1817. err |= __put_user (r->ru_msgrcv, &ru->ru_msgrcv);
  1818. err |= __put_user (r->ru_nsignals, &ru->ru_nsignals);
  1819. err |= __put_user (r->ru_nvcsw, &ru->ru_nvcsw);
  1820. err |= __put_user (r->ru_nivcsw, &ru->ru_nivcsw);
  1821. return err;
  1822. }
  1824. asmlinkage int sys32_wait4(__kernel_pid_t32 pid, unsigned int *stat_addr, int options, struct rusage32 *ru)
  1825. {
  1826. if (!ru)
  1827. return sys_wait4(pid, stat_addr, options, NULL);
  1828. else {
  1829. struct rusage r;
  1830. int ret;
  1831. unsigned int status;
  1832. mm_segment_t old_fs = get_fs();
  1834. set_fs (KERNEL_DS);
  1835. ret = sys_wait4(pid, stat_addr ? &status : NULL, options, &r);
  1836. set_fs (old_fs);
  1837. if (put_rusage (ru, &r)) return -EFAULT;
  1838. if (stat_addr && put_user (status, stat_addr))
  1839. return -EFAULT;
  1840. return ret;
  1841. }
  1842. }
  1844. struct sysinfo32 {
  1845.         s32 uptime;
  1846.         u32 loads[3];
  1847.         u32 totalram;
  1848.         u32 freeram;
  1849.         u32 sharedram;
  1850.         u32 bufferram;
  1851.         u32 totalswap;
  1852.         u32 freeswap;
  1853.         unsigned short procs;
  1854.         char _f[22];
  1855. };
  1857. extern asmlinkage int sys_sysinfo(struct sysinfo *info);
  1859. asmlinkage int sys32_sysinfo(struct sysinfo32 *info)
  1860. {
  1861. struct sysinfo s;
  1862. int ret, err;
  1863. mm_segment_t old_fs = get_fs ();
  1865. set_fs (KERNEL_DS);
  1866. ret = sys_sysinfo(&s);
  1867. set_fs (old_fs);
  1868. err = put_user (s.uptime, &info->uptime);
  1869. err |= __put_user (s.loads[0], &info->loads[0]);
  1870. err |= __put_user (s.loads[1], &info->loads[1]);
  1871. err |= __put_user (s.loads[2], &info->loads[2]);
  1872. err |= __put_user (s.totalram, &info->totalram);
  1873. err |= __put_user (s.freeram, &info->freeram);
  1874. err |= __put_user (s.sharedram, &info->sharedram);
  1875. err |= __put_user (s.bufferram, &info->bufferram);
  1876. err |= __put_user (s.totalswap, &info->totalswap);
  1877. err |= __put_user (s.freeswap, &info->freeswap);
  1878. err |= __put_user (s.procs, &info->procs);
  1879. if (err)
  1880. return -EFAULT;
  1881. return ret;
  1882. }
  1884. struct timespec32 {
  1885. s32    tv_sec;
  1886. s32    tv_nsec;
  1887. };
  1888.                 
  1889. extern asmlinkage int sys_sched_rr_get_interval(pid_t pid, struct timespec *interval);
  1891. asmlinkage int sys32_sched_rr_get_interval(__kernel_pid_t32 pid, struct timespec32 *interval)
  1892. {
  1893. struct timespec t;
  1894. int ret;
  1895. mm_segment_t old_fs = get_fs ();
  1897. set_fs (KERNEL_DS);
  1898. ret = sys_sched_rr_get_interval(pid, &t);
  1899. set_fs (old_fs);
  1900. if (put_user (t.tv_sec, &interval->tv_sec) ||
  1901.     __put_user (t.tv_nsec, &interval->tv_nsec))
  1902. return -EFAULT;
  1903. return ret;
  1904. }
  1906. extern asmlinkage int sys_nanosleep(struct timespec *rqtp, struct timespec *rmtp);
  1908. asmlinkage int sys32_nanosleep(struct timespec32 *rqtp, struct timespec32 *rmtp)
  1909. {
  1910. struct timespec t;
  1911. int ret;
  1912. mm_segment_t old_fs = get_fs ();
  1914. if (get_user (t.tv_sec, &rqtp->tv_sec) ||
  1915.     __get_user (t.tv_nsec, &rqtp->tv_nsec))
  1916. return -EFAULT;
  1917. set_fs (KERNEL_DS);
  1918. ret = sys_nanosleep(&t, rmtp ? &t : NULL);
  1919. set_fs (old_fs);
  1920. if (rmtp && ret == -EINTR) {
  1921. if (__put_user (t.tv_sec, &rmtp->tv_sec) ||
  1922.          __put_user (t.tv_nsec, &rmtp->tv_nsec))
  1923. return -EFAULT;
  1924. }
  1925. return ret;
  1926. }
  1928. extern asmlinkage int sys_sigprocmask(int how, old_sigset_t *set, old_sigset_t *oset);
  1930. asmlinkage int sys32_sigprocmask(int how, old_sigset_t32 *set, old_sigset_t32 *oset)
  1931. {
  1932. old_sigset_t s;
  1933. int ret;
  1934. mm_segment_t old_fs = get_fs();
  1936. if (set && get_user (s, set)) return -EFAULT;
  1937. set_fs (KERNEL_DS);
  1938. ret = sys_sigprocmask(how, set ? &s : NULL, oset ? &s : NULL);
  1939. set_fs (old_fs);
  1940. if (ret) return ret;
  1941. if (oset && put_user (s, oset)) return -EFAULT;
  1942. return 0;
  1943. }
  1945. extern asmlinkage int sys_rt_sigprocmask(int how, sigset_t *set, sigset_t *oset, size_t sigsetsize);
  1947. asmlinkage int sys32_rt_sigprocmask(int how, sigset_t32 *set, sigset_t32 *oset, __kernel_size_t32 sigsetsize)
  1948. {
  1949. sigset_t s;
  1950. sigset_t32 s32;
  1951. int ret;
  1952. mm_segment_t old_fs = get_fs();
  1954. if (set) {
  1955. if (copy_from_user (&s32, set, sizeof(sigset_t32)))
  1956. return -EFAULT;
  1957. switch (_NSIG_WORDS) {
  1958. case 4: s.sig[3] = s32.sig[6] | (((long)s32.sig[7]) << 32);
  1959. case 3: s.sig[2] = s32.sig[4] | (((long)s32.sig[5]) << 32);
  1960. case 2: s.sig[1] = s32.sig[2] | (((long)s32.sig[3]) << 32);
  1961. case 1: s.sig[0] = s32.sig[0] | (((long)s32.sig[1]) << 32);
  1962. }
  1963. }
  1964. set_fs (KERNEL_DS);
  1965. ret = sys_rt_sigprocmask(how, set ? &s : NULL, oset ? &s : NULL, sigsetsize);
  1966. set_fs (old_fs);
  1967. if (ret) return ret;
  1968. if (oset) {
  1969. switch (_NSIG_WORDS) {
  1970. case 4: s32.sig[7] = (s.sig[3] >> 32); s32.sig[6] = s.sig[3];
  1971. case 3: s32.sig[5] = (s.sig[2] >> 32); s32.sig[4] = s.sig[2];
  1972. case 2: s32.sig[3] = (s.sig[1] >> 32); s32.sig[2] = s.sig[1];
  1973. case 1: s32.sig[1] = (s.sig[0] >> 32); s32.sig[0] = s.sig[0];
  1974. }
  1975. if (copy_to_user (oset, &s32, sizeof(sigset_t32)))
  1976. return -EFAULT;
  1977. }
  1978. return 0;
  1979. }
  1981. extern asmlinkage int sys_sigpending(old_sigset_t *set);
  1983. asmlinkage int sys32_sigpending(old_sigset_t32 *set)
  1984. {
  1985. old_sigset_t s;
  1986. int ret;
  1987. mm_segment_t old_fs = get_fs();
  1989. set_fs (KERNEL_DS);
  1990. ret = sys_sigpending(&s);
  1991. set_fs (old_fs);
  1992. if (put_user (s, set)) return -EFAULT;
  1993. return ret;
  1994. }
  1996. extern asmlinkage int sys_rt_sigpending(sigset_t *set, size_t sigsetsize);
  1998. asmlinkage int sys32_rt_sigpending(sigset_t32 *set, __kernel_size_t32 sigsetsize)
  1999. {
  2000. sigset_t s;
  2001. sigset_t32 s32;
  2002. int ret;
  2003. mm_segment_t old_fs = get_fs();
  2005. set_fs (KERNEL_DS);
  2006. ret = sys_rt_sigpending(&s, sigsetsize);
  2007. set_fs (old_fs);
  2008. if (!ret) {
  2009. switch (_NSIG_WORDS) {
  2010. case 4: s32.sig[7] = (s.sig[3] >> 32); s32.sig[6] = s.sig[3];
  2011. case 3: s32.sig[5] = (s.sig[2] >> 32); s32.sig[4] = s.sig[2];
  2012. case 2: s32.sig[3] = (s.sig[1] >> 32); s32.sig[2] = s.sig[1];
  2013. case 1: s32.sig[1] = (s.sig[0] >> 32); s32.sig[0] = s.sig[0];
  2014. }
  2015. if (copy_to_user (set, &s32, sizeof(sigset_t32)))
  2016. return -EFAULT;
  2017. }
  2018. return ret;
  2019. }
  2021. extern int
  2022. copy_siginfo_to_user32(siginfo_t32 *to, siginfo_t *from);
  2024. asmlinkage int
  2025. sys32_rt_sigtimedwait(sigset_t32 *uthese, siginfo_t32 *uinfo,
  2026.       struct timespec32 *uts, __kernel_size_t32 sigsetsize)
  2027. {
  2028. int ret, sig;
  2029. sigset_t these;
  2030. sigset_t32 these32;
  2031. struct timespec ts;
  2032. siginfo_t info;
  2033. long timeout = 0;
  2035. /* XXX: Don't preclude handling different sized sigset_t's.  */
  2036. if (sigsetsize != sizeof(sigset_t))
  2037. return -EINVAL;
  2039. if (copy_from_user (&these32, uthese, sizeof(sigset_t32)))
  2040. return -EFAULT;
  2042. switch (_NSIG_WORDS) {
  2043. case 4: these.sig[3] = these32.sig[6] | (((long)these32.sig[7]) << 32);
  2044. case 3: these.sig[2] = these32.sig[4] | (((long)these32.sig[5]) << 32);
  2045. case 2: these.sig[1] = these32.sig[2] | (((long)these32.sig[3]) << 32);
  2046. case 1: these.sig[0] = these32.sig[0] | (((long)these32.sig[1]) << 32);
  2047. }
  2049. /*
  2050.  * Invert the set of allowed signals to get those we
  2051.  * want to block.
  2052.  */
  2053. sigdelsetmask(&these, sigmask(SIGKILL)|sigmask(SIGSTOP));
  2054. signotset(&these);
  2056. if (uts) {
  2057. if (get_user (ts.tv_sec, &uts->tv_sec) ||
  2058.     get_user (ts.tv_nsec, &uts->tv_nsec))
  2059. return -EINVAL;
  2060. if (ts.tv_nsec >= 1000000000L || ts.tv_nsec < 0
  2061.     || ts.tv_sec < 0)
  2062. return -EINVAL;
  2063. }
  2065. spin_lock_irq(&current->sigmask_lock);
  2066. sig = dequeue_signal(&these, &info);
  2067. if (!sig) {
  2068. /* None ready -- temporarily unblock those we're interested
  2069.    in so that we'll be awakened when they arrive.  */
  2070. sigset_t oldblocked = current->blocked;
  2071. sigandsets(&current->blocked, &current->blocked, &these);
  2072. recalc_sigpending(current);
  2073. spin_unlock_irq(&current->sigmask_lock);
  2075. timeout = MAX_SCHEDULE_TIMEOUT;
  2076. if (uts)
  2077. timeout = (timespec_to_jiffies(&ts)
  2078.    + (ts.tv_sec || ts.tv_nsec));
  2080. current->state = TASK_INTERRUPTIBLE;
  2081. timeout = schedule_timeout(timeout);
  2083. spin_lock_irq(&current->sigmask_lock);
  2084. sig = dequeue_signal(&these, &info);
  2085. current->blocked = oldblocked;
  2086. recalc_sigpending(current);
  2087. }
  2088. spin_unlock_irq(&current->sigmask_lock);
  2090. if (sig) {
  2091. ret = sig;
  2092. if (uinfo) {
  2093. if (copy_siginfo_to_user32(uinfo, &info))
  2094. ret = -EFAULT;
  2095. }
  2096. } else {
  2097. ret = -EAGAIN;
  2098. if (timeout)
  2099. ret = -EINTR;
  2100. }
  2102. return ret;
  2103. }
  2105. extern asmlinkage int
  2106. sys_rt_sigqueueinfo(int pid, int sig, siginfo_t *uinfo);
  2108. asmlinkage int
  2109. sys32_rt_sigqueueinfo(int pid, int sig, siginfo_t32 *uinfo)
  2110. {
  2111. siginfo_t info;
  2112. int ret;
  2113. mm_segment_t old_fs = get_fs();
  2115. if (copy_from_user (&info, uinfo, 3*sizeof(int)) ||
  2116.     copy_from_user (info._sifields._pad, uinfo->_sifields._pad, SI_PAD_SIZE))
  2117. return -EFAULT;
  2118. set_fs (KERNEL_DS);
  2119. ret = sys_rt_sigqueueinfo(pid, sig, &info);
  2120. set_fs (old_fs);
  2121. return ret;
  2122. }
  2124. struct tms32 {
  2125. __kernel_clock_t32 tms_utime;
  2126. __kernel_clock_t32 tms_stime;
  2127. __kernel_clock_t32 tms_cutime;
  2128. __kernel_clock_t32 tms_cstime;
  2129. };
  2130.                                 
  2131. extern asmlinkage long sys_times(struct tms * tbuf);
  2133. asmlinkage long sys32_times(struct tms32 *tbuf)
  2134. {
  2135. struct tms t;
  2136. long ret;
  2137. mm_segment_t old_fs = get_fs ();
  2138. int err;
  2140. set_fs (KERNEL_DS);
  2141. ret = sys_times(tbuf ? &t : NULL);
  2142. set_fs (old_fs);
  2143. if (tbuf) {
  2144. err = put_user (t.tms_utime, &tbuf->tms_utime);
  2145. err |= __put_user (t.tms_stime, &tbuf->tms_stime);
  2146. err |= __put_user (t.tms_cutime, &tbuf->tms_cutime);
  2147. err |= __put_user (t.tms_cstime, &tbuf->tms_cstime);
  2148. if (err)
  2149. ret = -EFAULT;
  2150. }
  2151. return ret;
  2152. }
  2154. #define RLIM_INFINITY32 0x7fffffff
  2155. #define RESOURCE32(x) ((x > RLIM_INFINITY32) ? RLIM_INFINITY32 : x)
  2157. struct rlimit32 {
  2158. u32 rlim_cur;
  2159. u32 rlim_max;
  2160. };
  2162. extern asmlinkage long sys_old_getrlimit(unsigned int resource, struct rlimit *rlim);
  2164. asmlinkage int sys32_old_getrlimit(unsigned int resource, struct rlimit32 *rlim)
  2165. {
  2166. struct rlimit r;
  2167. int ret;
  2168. mm_segment_t old_fs = get_fs ();
  2170. set_fs (KERNEL_DS);
  2171. ret = sys_old_getrlimit(resource, &r);
  2172. set_fs (old_fs);
  2173. if (!ret) {
  2174. ret = put_user (RESOURCE32(r.rlim_cur), &rlim->rlim_cur);
  2175. ret |= __put_user (RESOURCE32(r.rlim_max), &rlim->rlim_max);
  2176. }
  2177. return ret;
  2178. }
  2180. extern asmlinkage int sys_setrlimit(unsigned int resource, struct rlimit *rlim);
  2182. asmlinkage int sys32_setrlimit(unsigned int resource, struct rlimit32 *rlim)
  2183. {
  2184. struct rlimit r;
  2185. int ret;
  2186. mm_segment_t old_fs = get_fs ();
  2188. if (resource >= RLIM_NLIMITS) return -EINVAL;
  2189. if (get_user (r.rlim_cur, &rlim->rlim_cur) ||
  2190.     __get_user (r.rlim_max, &rlim->rlim_max))
  2191. return -EFAULT;
  2192. if (r.rlim_cur == RLIM_INFINITY32)
  2193. r.rlim_cur = RLIM_INFINITY;
  2194. if (r.rlim_max == RLIM_INFINITY32)
  2195. r.rlim_max = RLIM_INFINITY;
  2196. set_fs (KERNEL_DS);
  2197. ret = sys_setrlimit(resource, &r);
  2198. set_fs (old_fs);
  2199. return ret;
  2200. }
  2202. extern asmlinkage int sys_getrusage(int who, struct rusage *ru);
  2204. asmlinkage int sys32_getrusage(int who, struct rusage32 *ru)
  2205. {
  2206. struct rusage r;
  2207. int ret;
  2208. mm_segment_t old_fs = get_fs();
  2210. set_fs (KERNEL_DS);
  2211. ret = sys_getrusage(who, &r);
  2212. set_fs (old_fs);
  2213. if (put_rusage (ru, &r)) return -EFAULT;
  2214. return ret;
  2215. }
  2217. /* XXX This really belongs in some header file... -DaveM */
  2218. #define MAX_SOCK_ADDR 128 /* 108 for Unix domain - 
  2219.    16 for IP, 16 for IPX,
  2220.    24 for IPv6,
  2221.    about 80 for AX.25 */
  2223. extern struct socket *sockfd_lookup(int fd, int *err);
  2225. /* XXX This as well... */
  2226. extern __inline__ void sockfd_put(struct socket *sock)
  2227. {
  2228. fput(sock->file);
  2229. }
  2231. struct msghdr32 {
  2232.         u32               msg_name;
  2233.         int               msg_namelen;
  2234.         u32               msg_iov;
  2235.         __kernel_size_t32 msg_iovlen;
  2236.         u32               msg_control;
  2237.         __kernel_size_t32 msg_controllen;
  2238.         unsigned          msg_flags;
  2239. };
  2241. struct cmsghdr32 {
  2242.         __kernel_size_t32 cmsg_len;
  2243.         int               cmsg_level;
  2244.         int               cmsg_type;
  2245. };
  2247. /* Bleech... */
  2248. #define __CMSG32_NXTHDR(ctl, len, cmsg, cmsglen) __cmsg32_nxthdr((ctl),(len),(cmsg),(cmsglen))
  2249. #define CMSG32_NXTHDR(mhdr, cmsg, cmsglen) cmsg32_nxthdr((mhdr), (cmsg), (cmsglen))
  2251. #define CMSG32_ALIGN(len) ( ((len)+sizeof(int)-1) & ~(sizeof(int)-1) )
  2253. #define CMSG32_DATA(cmsg) ((void *)((char *)(cmsg) + CMSG32_ALIGN(sizeof(struct cmsghdr32))))
  2254. #define CMSG32_SPACE(len) (CMSG32_ALIGN(sizeof(struct cmsghdr32)) + CMSG32_ALIGN(len))
  2255. #define CMSG32_LEN(len) (CMSG32_ALIGN(sizeof(struct cmsghdr32)) + (len))
  2257. #define __CMSG32_FIRSTHDR(ctl,len) ((len) >= sizeof(struct cmsghdr32) ? 
  2258.     (struct cmsghdr32 *)(ctl) : 
  2259.     (struct cmsghdr32 *)NULL)
  2260. #define CMSG32_FIRSTHDR(msg) __CMSG32_FIRSTHDR((msg)->msg_control, (msg)->msg_controllen)
  2262. __inline__ struct cmsghdr32 *__cmsg32_nxthdr(void *__ctl, __kernel_size_t __size,
  2263.       struct cmsghdr32 *__cmsg, int __cmsg_len)
  2264. {
  2265. struct cmsghdr32 * __ptr;
  2267. __ptr = (struct cmsghdr32 *)(((unsigned char *) __cmsg) +
  2268.      CMSG32_ALIGN(__cmsg_len));
  2269. if ((unsigned long)((char*)(__ptr+1) - (char *) __ctl) > __size)
  2270. return NULL;
  2272. return __ptr;
  2273. }
  2275. __inline__ struct cmsghdr32 *cmsg32_nxthdr (struct msghdr *__msg,
  2276.     struct cmsghdr32 *__cmsg,
  2277.     int __cmsg_len)
  2278. {
  2279. return __cmsg32_nxthdr(__msg->msg_control, __msg->msg_controllen,
  2280.        __cmsg, __cmsg_len);
  2281. }
  2283. static inline int iov_from_user32_to_kern(struct iovec *kiov,
  2284.   struct iovec32 *uiov32,
  2285.   int niov)
  2286. {
  2287. int tot_len = 0;
  2289. while(niov > 0) {
  2290. u32 len, buf;
  2292. if(get_user(len, &uiov32->iov_len) ||
  2293.    get_user(buf, &uiov32->iov_base)) {
  2294. tot_len = -EFAULT;
  2295. break;
  2296. }
  2297. tot_len += len;
  2298. kiov->iov_base = (void *)A(buf);
  2299. kiov->iov_len = (__kernel_size_t) len;
  2300. uiov32++;
  2301. kiov++;
  2302. niov--;
  2303. }
  2304. return tot_len;
  2305. }
  2307. static inline int msghdr_from_user32_to_kern(struct msghdr *kmsg,
  2308.      struct msghdr32 *umsg)
  2309. {
  2310. u32 tmp1, tmp2, tmp3;
  2311. int err;
  2313. err = get_user(tmp1, &umsg->msg_name);
  2314. err |= __get_user(tmp2, &umsg->msg_iov);
  2315. err |= __get_user(tmp3, &umsg->msg_control);
  2316. if (err)
  2317. return -EFAULT;
  2319. kmsg->msg_name = (void *)A(tmp1);
  2320. kmsg->msg_iov = (struct iovec *)A(tmp2);
  2321. kmsg->msg_control = (void *)A(tmp3);
  2323. err = get_user(kmsg->msg_namelen, &umsg->msg_namelen);
  2324. err |= get_user(kmsg->msg_iovlen, &umsg->msg_iovlen);
  2325. err |= get_user(kmsg->msg_controllen, &umsg->msg_controllen);
  2326. err |= get_user(kmsg->msg_flags, &umsg->msg_flags);
  2328. return err;
  2329. }
  2331. /* I've named the args so it is easy to tell whose space the pointers are in. */
  2332. static int verify_iovec32(struct msghdr *kern_msg, struct iovec *kern_iov,
  2333.   char *kern_address, int mode)
  2334. {
  2335. int tot_len;
  2337. if(kern_msg->msg_namelen) {
  2338. if(mode==VERIFY_READ) {
  2339. int err = move_addr_to_kernel(kern_msg->msg_name,
  2340.       kern_msg->msg_namelen,
  2341.       kern_address);
  2342. if(err < 0)
  2343. return err;
  2344. }
  2345. kern_msg->msg_name = kern_address;
  2346. } else
  2347. kern_msg->msg_name = NULL;
  2349. if(kern_msg->msg_iovlen > UIO_FASTIOV) {
  2350. kern_iov = kmalloc(kern_msg->msg_iovlen * sizeof(struct iovec),
  2351.    GFP_KERNEL);
  2352. if(!kern_iov)
  2353. return -ENOMEM;
  2354. }
  2356. tot_len = iov_from_user32_to_kern(kern_iov,
  2357.   (struct iovec32 *)kern_msg->msg_iov,
  2358.   kern_msg->msg_iovlen);
  2359. if(tot_len >= 0)
  2360. kern_msg->msg_iov = kern_iov;
  2361. else if(kern_msg->msg_iovlen > UIO_FASTIOV)
  2362. kfree(kern_iov);
  2364. return tot_len;
  2365. }
  2367. /* There is a lot of hair here because the alignment rules (and
  2368.  * thus placement) of cmsg headers and length are different for
  2369.  * 32-bit apps.  -DaveM
  2370.  */
  2371. static int cmsghdr_from_user32_to_kern(struct msghdr *kmsg,
  2372.        unsigned char *stackbuf, int stackbuf_size)
  2373. {
  2374. struct cmsghdr32 *ucmsg;
  2375. struct cmsghdr *kcmsg, *kcmsg_base;
  2376. __kernel_size_t32 ucmlen;
  2377. __kernel_size_t kcmlen, tmp;
  2379. kcmlen = 0;
  2380. kcmsg_base = kcmsg = (struct cmsghdr *)stackbuf;
  2381. ucmsg = CMSG32_FIRSTHDR(kmsg);
  2382. while(ucmsg != NULL) {
  2383. if(get_user(ucmlen, &ucmsg->cmsg_len))
  2384. return -EFAULT;
  2386. /* Catch bogons. */
  2387. if(CMSG32_ALIGN(ucmlen) <
  2388.    CMSG32_ALIGN(sizeof(struct cmsghdr32)))
  2389. return -EINVAL;
  2390. if((unsigned long)(((char *)ucmsg - (char *)kmsg->msg_control)
  2391.    + ucmlen) > kmsg->msg_controllen)
  2392. return -EINVAL;
  2394. tmp = ((ucmlen - CMSG32_ALIGN(sizeof(*ucmsg))) +
  2395.        CMSG_ALIGN(sizeof(struct cmsghdr)));
  2396. kcmlen += tmp;
  2397. ucmsg = CMSG32_NXTHDR(kmsg, ucmsg, ucmlen);
  2398. }
  2399. if(kcmlen == 0)
  2400. return -EINVAL;
  2402. /* The kcmlen holds the 64-bit version of the control length.
  2403.  * It may not be modified as we do not stick it into the kmsg
  2404.  * until we have successfully copied over all of the data
  2405.  * from the user.
  2406.  */
  2407. if(kcmlen > stackbuf_size)
  2408. kcmsg_base = kcmsg = kmalloc(kcmlen, GFP_KERNEL);
  2409. if(kcmsg == NULL)
  2410. return -ENOBUFS;
  2412. /* Now copy them over neatly. */
  2413. memset(kcmsg, 0, kcmlen);
  2414. ucmsg = CMSG32_FIRSTHDR(kmsg);
  2415. while(ucmsg != NULL) {
  2416. __get_user(ucmlen, &ucmsg->cmsg_len);
  2417. tmp = ((ucmlen - CMSG32_ALIGN(sizeof(*ucmsg))) +
  2418.        CMSG_ALIGN(sizeof(struct cmsghdr)));
  2419. kcmsg->cmsg_len = tmp;
  2420. __get_user(kcmsg->cmsg_level, &ucmsg->cmsg_level);
  2421. __get_user(kcmsg->cmsg_type, &ucmsg->cmsg_type);
  2423. /* Copy over the data. */
  2424. if(copy_from_user(CMSG_DATA(kcmsg),
  2425.   CMSG32_DATA(ucmsg),
  2426.   (ucmlen - CMSG32_ALIGN(sizeof(*ucmsg)))))
  2427. goto out_free_efault;
  2429. /* Advance. */
  2430. kcmsg = (struct cmsghdr *)((char *)kcmsg + CMSG_ALIGN(tmp));
  2431. ucmsg = CMSG32_NXTHDR(kmsg, ucmsg, ucmlen);
  2432. }
  2434. /* Ok, looks like we made it.  Hook it up and return success. */
  2435. kmsg->msg_control = kcmsg_base;
  2436. kmsg->msg_controllen = kcmlen;
  2437. return 0;
  2439. out_free_efault:
  2440. if(kcmsg_base != (struct cmsghdr *)stackbuf)
  2441. kfree(kcmsg_base);
  2442. return -EFAULT;
  2443. }
  2445. static void put_cmsg32(struct msghdr *kmsg, int level, int type,
  2446.        int len, void *data)
  2447. {
  2448. struct cmsghdr32 *cm = (struct cmsghdr32 *) kmsg->msg_control;
  2449. struct cmsghdr32 cmhdr;
  2450. int cmlen = CMSG32_LEN(len);
  2452. if(cm == NULL || kmsg->msg_controllen < sizeof(*cm)) {
  2453. kmsg->msg_flags |= MSG_CTRUNC;
  2454. return;
  2455. }
  2457. if(kmsg->msg_controllen < cmlen) {
  2458. kmsg->msg_flags |= MSG_CTRUNC;
  2459. cmlen = kmsg->msg_controllen;
  2460. }
  2461. cmhdr.cmsg_level = level;
  2462. cmhdr.cmsg_type = type;
  2463. cmhdr.cmsg_len = cmlen;
  2465. if(copy_to_user(cm, &cmhdr, sizeof cmhdr))
  2466. return;
  2467. if(copy_to_user(CMSG32_DATA(cm), data, cmlen - sizeof(struct cmsghdr32)))
  2468. return;
  2469. cmlen = CMSG32_SPACE(len);
  2470. kmsg->msg_control += cmlen;
  2471. kmsg->msg_controllen -= cmlen;
  2472. }
  2474. static void scm_detach_fds32(struct msghdr *kmsg, struct scm_cookie *scm)
  2475. {
  2476. struct cmsghdr32 *cm = (struct cmsghdr32 *) kmsg->msg_control;
  2477. int fdmax = (kmsg->msg_controllen - sizeof(struct cmsghdr32)) / sizeof(int);
  2478. int fdnum = scm->fp->count;
  2479. struct file **fp = scm->fp->fp;
  2480. int *cmfptr;
  2481. int err = 0, i;
  2483. if (fdnum < fdmax)
  2484. fdmax = fdnum;
  2486. for (i = 0, cmfptr = (int *) CMSG32_DATA(cm); i < fdmax; i++, cmfptr++) {
  2487. int new_fd;
  2488. err = get_unused_fd();
  2489. if (err < 0)
  2490. break;
  2491. new_fd = err;
  2492. err = put_user(new_fd, cmfptr);
  2493. if (err) {
  2494. put_unused_fd(new_fd);
  2495. break;
  2496. }
  2497. /* Bump the usage count and install the file. */
  2498. get_file(fp[i]);
  2499. fd_install(new_fd, fp[i]);
  2500. }
  2502. if (i > 0) {
  2503. int cmlen = CMSG32_LEN(i * sizeof(int));
  2504. if (!err)
  2505. err = put_user(SOL_SOCKET, &cm->cmsg_level);
  2506. if (!err)
  2507. err = put_user(SCM_RIGHTS, &cm->cmsg_type);
  2508. if (!err)
  2509. err = put_user(cmlen, &cm->cmsg_len);
  2510. if (!err) {
  2511. cmlen = CMSG32_SPACE(i * sizeof(int));
  2512. kmsg->msg_control += cmlen;
  2513. kmsg->msg_controllen -= cmlen;
  2514. }
  2515. }
  2516. if (i < fdnum)
  2517. kmsg->msg_flags |= MSG_CTRUNC;
  2519. /*
  2520.  * All of the files that fit in the message have had their
  2521.  * usage counts incremented, so we just free the list.
  2522.  */
  2523. __scm_destroy(scm);
  2524. }
  2526. /* In these cases we (currently) can just copy to data over verbatim
  2527.  * because all CMSGs created by the kernel have well defined types which
  2528.  * have the same layout in both the 32-bit and 64-bit API.  One must add
  2529.  * some special cased conversions here if we start sending control messages
  2530.  * with incompatible types.
  2531.  *
  2532.  * SCM_RIGHTS and SCM_CREDENTIALS are done by hand in recvmsg32 right after
  2533.  * we do our work.  The remaining cases are:
  2534.  *
  2535.  * SOL_IP IP_PKTINFO struct in_pktinfo 32-bit clean
  2536.  * IP_TTL int 32-bit clean
  2537.  * IP_TOS __u8 32-bit clean
  2538.  * IP_RECVOPTS variable length 32-bit clean
  2539.  * IP_RETOPTS variable length 32-bit clean
  2540.  * (these last two are clean because the types are defined
  2541.  *  by the IPv4 protocol)
  2542.  * IP_RECVERR struct sock_extended_err +
  2543.  * struct sockaddr_in 32-bit clean
  2544.  * SOL_IPV6 IPV6_RECVERR struct sock_extended_err +
  2545.  * struct sockaddr_in6 32-bit clean
  2546.  * IPV6_PKTINFO struct in6_pktinfo 32-bit clean
  2547.  * IPV6_HOPLIMIT int 32-bit clean
  2548.  * IPV6_FLOWINFO u32 32-bit clean
  2549.  * IPV6_HOPOPTS ipv6 hop exthdr 32-bit clean
  2550.  * IPV6_DSTOPTS ipv6 dst exthdr(s) 32-bit clean
  2551.  * IPV6_RTHDR ipv6 routing exthdr 32-bit clean
  2552.  * IPV6_AUTHHDR ipv6 auth exthdr 32-bit clean
  2553.  */
  2554. static void cmsg32_recvmsg_fixup(struct msghdr *kmsg, unsigned long orig_cmsg_uptr)
  2555. {
  2556. unsigned char *workbuf, *wp;
  2557. unsigned long bufsz, space_avail;
  2558. struct cmsghdr *ucmsg;
  2560. bufsz = ((unsigned long)kmsg->msg_control) - orig_cmsg_uptr;
  2561. space_avail = kmsg->msg_controllen + bufsz;
  2562. wp = workbuf = kmalloc(bufsz, GFP_KERNEL);
  2563. if(workbuf == NULL)
  2564. goto fail;
  2566. /* To make this more sane we assume the kernel sends back properly
  2567.  * formatted control messages.  Because of how the kernel will truncate
  2568.  * the cmsg_len for MSG_TRUNC cases, we need not check that case either.
  2569.  */
  2570. ucmsg = (struct cmsghdr *) orig_cmsg_uptr;
  2571. while(((unsigned long)ucmsg) <=
  2572.       (((unsigned long)kmsg->msg_control) - sizeof(struct cmsghdr))) {
  2573. struct cmsghdr32 *kcmsg32 = (struct cmsghdr32 *) wp;
  2574. int clen64, clen32;
  2576. /* UCMSG is the 64-bit format CMSG entry in user-space.
  2577.  * KCMSG32 is within the kernel space temporary buffer
  2578.  * we use to convert into a 32-bit style CMSG.
  2579.  */
  2580. __get_user(kcmsg32->cmsg_len, &ucmsg->cmsg_len);
  2581. __get_user(kcmsg32->cmsg_level, &ucmsg->cmsg_level);
  2582. __get_user(kcmsg32->cmsg_type, &ucmsg->cmsg_type);
  2584. clen64 = kcmsg32->cmsg_len;
  2585. copy_from_user(CMSG32_DATA(kcmsg32), CMSG_DATA(ucmsg),
  2586.        clen64 - CMSG_ALIGN(sizeof(*ucmsg)));
  2587. clen32 = ((clen64 - CMSG_ALIGN(sizeof(*ucmsg))) +
  2588.   CMSG32_ALIGN(sizeof(struct cmsghdr32)));
  2589. kcmsg32->cmsg_len = clen32;
  2591. ucmsg = (struct cmsghdr *) (((char *)ucmsg) + CMSG_ALIGN(clen64));
  2592. wp = (((char *)kcmsg32) + CMSG32_ALIGN(clen32));
  2593. }
  2595. /* Copy back fixed up data, and adjust pointers. */
  2596. bufsz = (wp - workbuf);
  2597. copy_to_user((void *)orig_cmsg_uptr, workbuf, bufsz);
  2599. kmsg->msg_control = (struct cmsghdr *)
  2600. (((char *)orig_cmsg_uptr) + bufsz);
  2601. kmsg->msg_controllen = space_avail - bufsz;
  2603. kfree(workbuf);
  2604. return;
  2606. fail:
  2607. /* If we leave the 64-bit format CMSG chunks in there,
  2608.  * the application could get confused and crash.  So to
  2609.  * ensure greater recovery, we report no CMSGs.
  2610.  */
  2611. kmsg->msg_controllen += bufsz;
  2612. kmsg->msg_control = (void *) orig_cmsg_uptr;
  2613. }
  2615. asmlinkage int sys32_sendmsg(int fd, struct msghdr32 *user_msg, unsigned user_flags)
  2616. {
  2617. struct socket *sock;
  2618. char address[MAX_SOCK_ADDR];
  2619. struct iovec iov[UIO_FASTIOV];
  2620. unsigned char ctl[sizeof(struct cmsghdr) + 20];
  2621. unsigned char *ctl_buf = ctl;
  2622. struct msghdr kern_msg;
  2623. int err, total_len;
  2625. if(msghdr_from_user32_to_kern(&kern_msg, user_msg))
  2626. return -EFAULT;
  2627. if(kern_msg.msg_iovlen > UIO_MAXIOV)
  2628. return -EINVAL;
  2629. err = verify_iovec32(&kern_msg, iov, address, VERIFY_READ);
  2630. if (err < 0)
  2631. goto out;
  2632. total_len = err;
  2634. if(kern_msg.msg_controllen) {
  2635. err = cmsghdr_from_user32_to_kern(&kern_msg, ctl, sizeof(ctl));
  2636. if(err)
  2637. goto out_freeiov;
  2638. ctl_buf = kern_msg.msg_control;
  2639. }
  2640. kern_msg.msg_flags = user_flags;
  2642. sock = sockfd_lookup(fd, &err);
  2643. if (sock != NULL) {
  2644. if (sock->file->f_flags & O_NONBLOCK)
  2645. kern_msg.msg_flags |= MSG_DONTWAIT;
  2646. err = sock_sendmsg(sock, &kern_msg, total_len);
  2647. sockfd_put(sock);
  2648. }
  2650. /* N.B. Use kfree here, as kern_msg.msg_controllen might change? */
  2651. if(ctl_buf != ctl)
  2652. kfree(ctl_buf);
  2653. out_freeiov:
  2654. if(kern_msg.msg_iov != iov)
  2655. kfree(kern_msg.msg_iov);
  2656. out:
  2657. return err;
  2658. }
  2660. asmlinkage int sys32_recvmsg(int fd, struct msghdr32 *user_msg, unsigned int user_flags)
  2661. {
  2662. struct iovec iovstack[UIO_FASTIOV];
  2663. struct msghdr kern_msg;
  2664. char addr[MAX_SOCK_ADDR];
  2665. struct socket *sock;
  2666. struct iovec *iov = iovstack;
  2667. struct sockaddr *uaddr;
  2668. int *uaddr_len;
  2669. unsigned long cmsg_ptr;
  2670. int err, total_len, len = 0;
  2672. if(msghdr_from_user32_to_kern(&kern_msg, user_msg))
  2673. return -EFAULT;
  2674. if(kern_msg.msg_iovlen > UIO_MAXIOV)
  2675. return -EINVAL;
  2677. uaddr = kern_msg.msg_name;
  2678. uaddr_len = &user_msg->msg_namelen;
  2679. err = verify_iovec32(&kern_msg, iov, addr, VERIFY_WRITE);
  2680. if (err < 0)
  2681. goto out;
  2682. total_len = err;
  2684. cmsg_ptr = (unsigned long) kern_msg.msg_control;
  2685. kern_msg.msg_flags = 0;
  2687. sock = sockfd_lookup(fd, &err);
  2688. if (sock != NULL) {
  2689. struct scm_cookie scm;
  2691. if (sock->file->f_flags & O_NONBLOCK)
  2692. user_flags |= MSG_DONTWAIT;
  2693. memset(&scm, 0, sizeof(scm));
  2694. err = sock->ops->recvmsg(sock, &kern_msg, total_len,
  2695.  user_flags, &scm);
  2696. if(err >= 0) {
  2697. len = err;
  2698. if(!kern_msg.msg_control) {
  2699. if(sock->passcred || scm.fp)
  2700. kern_msg.msg_flags |= MSG_CTRUNC;
  2701. if(scm.fp)
  2702. __scm_destroy(&scm);
  2703. } else {
  2704. /* If recvmsg processing itself placed some
  2705.  * control messages into user space, it's is
  2706.  * using 64-bit CMSG processing, so we need
  2707.  * to fix it up before we tack on more stuff.
  2708.  */
  2709. if((unsigned long) kern_msg.msg_control != cmsg_ptr)
  2710. cmsg32_recvmsg_fixup(&kern_msg, cmsg_ptr);
  2712. /* Wheee... */
  2713. if(sock->passcred)
  2714. put_cmsg32(&kern_msg,
  2715.    SOL_SOCKET, SCM_CREDENTIALS,
  2716.    sizeof(scm.creds), &scm.creds);
  2717. if(scm.fp != NULL)
  2718. scm_detach_fds32(&kern_msg, &scm);
  2719. }
  2720. }
  2721. sockfd_put(sock);
  2722. }
  2724. if(uaddr != NULL && err >= 0)
  2725. err = move_addr_to_user(addr, kern_msg.msg_namelen, uaddr, uaddr_len);
  2726. if(cmsg_ptr != 0 && err >= 0) {
  2727. unsigned long ucmsg_ptr = ((unsigned long)kern_msg.msg_control);
  2728. __kernel_size_t32 uclen = (__kernel_size_t32) (ucmsg_ptr - cmsg_ptr);
  2729. err |= __put_user(uclen, &user_msg->msg_controllen);
  2730. }
  2731. if(err >= 0)
  2732. err = __put_user(kern_msg.msg_flags, &user_msg->msg_flags);
  2733. if(kern_msg.msg_iov != iov)
  2734. kfree(kern_msg.msg_iov);
  2735. out:
  2736. if(err < 0)
  2737. return err;
  2738. return len;
  2739. }
  2741. extern asmlinkage int sys_setsockopt(int fd, int level, int optname,
  2742.      char *optval, int optlen);
  2744. static int do_set_attach_filter(int fd, int level, int optname,
  2745. char *optval, int optlen)
  2746. {
  2747. struct sock_fprog32 {
  2748. __u16 len;
  2749. __u32 filter;
  2750. } *fprog32 = (struct sock_fprog32 *)optval;
  2751. struct sock_fprog kfprog;
  2752. struct sock_filter *kfilter;
  2753. unsigned int fsize;
  2754. mm_segment_t old_fs;
  2755. __u32 uptr;
  2756. int ret;
  2758. if (get_user(kfprog.len, &fprog32->len) ||
  2759.     __get_user(uptr, &fprog32->filter))
  2760. return -EFAULT;
  2762. kfprog.filter = (struct sock_filter *)A(uptr);
  2763. fsize = kfprog.len * sizeof(struct sock_filter);
  2765. kfilter = (struct sock_filter *)kmalloc(fsize, GFP_KERNEL);
  2766. if (kfilter == NULL)
  2767. return -ENOMEM;
  2769. if (copy_from_user(kfilter, kfprog.filter, fsize)) {
  2770. kfree(kfilter);
  2771. return -EFAULT;
  2772. }
  2774. kfprog.filter = kfilter;
  2776. old_fs = get_fs();
  2777. set_fs(KERNEL_DS);
  2778. ret = sys_setsockopt(fd, level, optname,
  2779.      (char *)&kfprog, sizeof(kfprog));
  2780. set_fs(old_fs);
  2782. kfree(kfilter);
  2784. return ret;
  2785. }
  2787. static int do_set_icmpv6_filter(int fd, int level, int optname,
  2788. char *optval, int optlen)
  2789. {
  2790. struct icmp6_filter kfilter;
  2791. mm_segment_t old_fs;
  2792. int ret, i;
  2794. if (copy_from_user(&kfilter, optval, sizeof(kfilter)))
  2795. return -EFAULT;
  2798. for (i = 0; i < 8; i += 2) {
  2799. u32 tmp = kfilter.data[i];
  2801. kfilter.data[i] = kfilter.data[i + 1];
  2802. kfilter.data[i + 1] = tmp;
  2803. }
  2805. old_fs = get_fs();
  2806. set_fs(KERNEL_DS);
  2807. ret = sys_setsockopt(fd, level, optname,
  2808.      (char *) &kfilter, sizeof(kfilter));
  2809. set_fs(old_fs);
  2811. return ret;
  2812. }
  2814. asmlinkage int sys32_setsockopt(int fd, int level, int optname,
  2815. char *optval, int optlen)
  2816. {
  2817. if (optname == SO_ATTACH_FILTER)
  2818. return do_set_attach_filter(fd, level, optname,
  2819.     optval, optlen);
  2820. if (level == SOL_ICMPV6 && optname == ICMPV6_FILTER)
  2821. return do_set_icmpv6_filter(fd, level, optname,
  2822.     optval, optlen);
  2824. return sys_setsockopt(fd, level, optname, optval, optlen);
  2825. }
  2827. extern void check_pending(int signum);
  2829. /*
  2830.  * count32() counts the number of arguments/envelopes
  2831.  */
  2832. static int count32(u32 * argv)
  2833. {
  2834. int i = 0;
  2836. if (argv != NULL) {
  2837. for (;;) {
  2838. u32 p; int error;
  2840. error = get_user(p,argv);
  2841. if (error) return error;
  2842. if (!p) break;
  2843. argv++; i++;
  2844. }
  2845. }
  2846. return i;
  2847. }
  2849. /*
  2850.  * 'copy_string32()' copies argument/envelope strings from user
  2851.  * memory to free pages in kernel mem. These are in a format ready
  2852.  * to be put directly into the top of new user memory.
  2853.  */
  2854. static int copy_strings32(int argc, u32 * argv, struct linux_binprm *bprm)
  2855. {
  2856. while (argc-- > 0) {
  2857. u32 str;
  2858. int len;
  2859. unsigned long pos;
  2861. if (get_user(str, argv + argc) ||
  2862.     !str ||
  2863.     !(len = strnlen_user((char *)A(str), bprm->p)))
  2864. return -EFAULT;
  2866. if (bprm->p < len)
  2867. return -E2BIG;
  2869. bprm->p -= len;
  2871. pos = bprm->p;
  2872. while (len) {
  2873. char *kaddr;
  2874. struct page *page;
  2875. int offset, bytes_to_copy, new, err;
  2877. offset = pos % PAGE_SIZE;
  2878. page = bprm->page[pos / PAGE_SIZE];
  2879. new = 0;
  2880. if (!page) {
  2881. page = alloc_page(GFP_USER);
  2882. bprm->page[pos / PAGE_SIZE] = page;
  2883. if (!page)
  2884. return -ENOMEM;
  2885. new = 1;
  2886. }
  2887. kaddr = (char *)kmap(page);
  2889. if (new && offset)
  2890. memset(kaddr, 0, offset);
  2891. bytes_to_copy = PAGE_SIZE - offset;
  2892. if (bytes_to_copy > len) {
  2893. bytes_to_copy = len;
  2894. if (new)
  2895. memset(kaddr+offset+len, 0,
  2896.        PAGE_SIZE-offset-len);
  2897. }
  2899. err = copy_from_user(kaddr + offset, (char *)A(str),
  2900.      bytes_to_copy);
  2901. flush_page_to_ram(page);
  2902. kunmap(page);
  2904. if (err)
  2905. return -EFAULT;
  2907. pos += bytes_to_copy;
  2908. str += bytes_to_copy;
  2909. len -= bytes_to_copy;
  2910. }
  2911. }
  2912. return 0;
  2913. }
  2915. /*
  2916.  * sys32_execve() executes a new program.
  2917.  */
  2918. static inline int 
  2919. do_execve32(char * filename, u32 * argv, u32 * envp, struct pt_regs * regs)
  2920. {
  2921. struct linux_binprm bprm;
  2922. struct file * file;
  2923. int retval;
  2924. int i;
  2926. bprm.p = PAGE_SIZE*MAX_ARG_PAGES-sizeof(void *);
  2927. memset(bprm.page, 0, MAX_ARG_PAGES * sizeof(bprm.page[0]));
  2929. file = open_exec(filename);
  2931. retval = PTR_ERR(file);
  2932. if (IS_ERR(file))
  2933. return retval;
  2935. bprm.file = file;
  2936. bprm.filename = filename;
  2937. bprm.sh_bang = 0;
  2938. bprm.loader = 0;
  2939. bprm.exec = 0;
  2940. if ((bprm.argc = count32(argv)) < 0) {
  2941. allow_write_access(file);
  2942. fput(file);
  2943. return bprm.argc;
  2944. }
  2945. if ((bprm.envc = count32(envp)) < 0) {
  2946. allow_write_access(file);
  2947. fput(file);
  2948. return bprm.envc;
  2949. }
  2951. retval = prepare_binprm(&bprm);
  2952. if (retval < 0)
  2953. goto out;
  2955. retval = copy_strings_kernel(1, &bprm.filename, &bprm);
  2956. if (retval < 0)
  2957. goto out;
  2959. bprm.exec = bprm.p;
  2960. retval = copy_strings32(bprm.envc, envp, &bprm);
  2961. if (retval < 0)
  2962. goto out;
  2964. retval = copy_strings32(bprm.argc, argv, &bprm);
  2965. if (retval < 0)
  2966. goto out;
  2968. retval = search_binary_handler(&bprm, regs);
  2969. if (retval >= 0)
  2970. /* execve success */
  2971. return retval;
  2973. out:
  2974. /* Something went wrong, return the inode and free the argument pages*/
  2975. allow_write_access(bprm.file);
  2976. if (bprm.file)
  2977. fput(bprm.file);
  2979. for (i=0 ; i<MAX_ARG_PAGES ; i++)
  2980. if (bprm.page[i])
  2981. __free_page(bprm.page[i]);
  2983. return retval;
  2984. }
  2986. /*
  2987.  * sys32_execve() executes a new program after the asm stub has set
  2988.  * things up for us.  This should basically do what I want it to.
  2989.  */
  2990. asmlinkage int
  2991. sys32_execve(struct pt_regs regs)
  2992. {
  2993.         int error;
  2994.         char * filename;
  2996.         filename = getname((char *)A(regs.orig_gpr2));
  2997.         error = PTR_ERR(filename);
  2998.         if (IS_ERR(filename))
  2999.                 goto out;
  3000.         error = do_execve32(filename, (u32 *)A(regs.gprs[3]), (u32 *)A(regs.gprs[4]), &regs);
  3001. if (error == 0)
  3002. {
  3003. current->ptrace &= ~PT_DTRACE;
  3004. current->thread.fp_regs.fpc=0;
  3005. __asm__ __volatile__
  3006.         ("sr  0,0nt"
  3007.          "sfpc 0,0nt"
  3008.  : : :"0");
  3009. }
  3010.         putname(filename);
  3011. out:
  3012.         return error;
  3013. }
  3016. #ifdef CONFIG_MODULES
  3018. extern asmlinkage unsigned long sys_create_module(const char *name_user, size_t size);
  3020. asmlinkage unsigned long sys32_create_module(const char *name_user, __kernel_size_t32 size)
  3021. {
  3022. return sys_create_module(name_user, (size_t)size);
  3023. }
  3025. extern asmlinkage int sys_init_module(const char *name_user, struct module *mod_user);
  3027. /* Hey, when you're trying to init module, take time and prepare us a nice 64bit
  3028.  * module structure, even if from 32bit modutils... Why to pollute kernel... :))
  3029.  */
  3030. asmlinkage int sys32_init_module(const char *name_user, struct module *mod_user)
  3031. {
  3032. return sys_init_module(name_user, mod_user);
  3033. }
  3035. extern asmlinkage int sys_delete_module(const char *name_user);
  3037. asmlinkage int sys32_delete_module(const char *name_user)
  3038. {
  3039. return sys_delete_module(name_user);
  3040. }
  3042. struct module_info32 {
  3043. u32 addr;
  3044. u32 size;
  3045. u32 flags;
  3046. s32 usecount;
  3047. };
  3049. /* Query various bits about modules.  */
  3051. static inline long
  3052. get_mod_name(const char *user_name, char **buf)
  3053. {
  3054. unsigned long page;
  3055. long retval;
  3057. if ((unsigned long)user_name >= TASK_SIZE
  3058.     && !segment_eq(get_fs (), KERNEL_DS))
  3059. return -EFAULT;
  3061. page = __get_free_page(GFP_KERNEL);
  3062. if (!page)
  3063. return -ENOMEM;
  3065. retval = strncpy_from_user((char *)page, user_name, PAGE_SIZE);
  3066. if (retval > 0) {
  3067. if (retval < PAGE_SIZE) {
  3068. *buf = (char *)page;
  3069. return retval;
  3070. }
  3071. retval = -ENAMETOOLONG;
  3072. } else if (!retval)
  3073. retval = -EINVAL;
  3075. free_page(page);
  3076. return retval;
  3077. }
  3079. static inline void
  3080. put_mod_name(char *buf)
  3081. {
  3082. free_page((unsigned long)buf);
  3083. }
  3085. static __inline__ struct module *find_module(const char *name)
  3086. {
  3087. struct module *mod;
  3089. for (mod = module_list; mod ; mod = mod->next) {
  3090. if (mod->flags & MOD_DELETED)
  3091. continue;
  3092. if (!strcmp(mod->name, name))
  3093. break;
  3094. }
  3096. return mod;
  3097. }
  3099. static int
  3100. qm_modules(char *buf, size_t bufsize, __kernel_size_t32 *ret)
  3101. {
  3102. struct module *mod;
  3103. size_t nmod, space, len;
  3105. nmod = space = 0;
  3107. for (mod = module_list; mod->next != NULL; mod = mod->next, ++nmod) {
  3108. len = strlen(mod->name)+1;
  3109. if (len > bufsize)
  3110. goto calc_space_needed;
  3111. if (copy_to_user(buf, mod->name, len))
  3112. return -EFAULT;
  3113. buf += len;
  3114. bufsize -= len;
  3115. space += len;
  3116. }
  3118. if (put_user(nmod, ret))
  3119. return -EFAULT;
  3120. else
  3121. return 0;
  3123. calc_space_needed:
  3124. space += len;
  3125. while ((mod = mod->next)->next != NULL)
  3126. space += strlen(mod->name)+1;
  3128. if (put_user(space, ret))
  3129. return -EFAULT;
  3130. else
  3131. return -ENOSPC;
  3132. }
  3134. static int
  3135. qm_deps(struct module *mod, char *buf, size_t bufsize, __kernel_size_t32 *ret)
  3136. {
  3137. size_t i, space, len;
  3139. if (mod->next == NULL)
  3140. return -EINVAL;
  3141. if (!MOD_CAN_QUERY(mod))
  3142. return put_user(0, ret);
  3144. space = 0;
  3145. for (i = 0; i < mod->ndeps; ++i) {
  3146. const char *dep_name = mod->deps[i].dep->name;
  3148. len = strlen(dep_name)+1;
  3149. if (len > bufsize)
  3150. goto calc_space_needed;
  3151. if (copy_to_user(buf, dep_name, len))
  3152. return -EFAULT;
  3153. buf += len;
  3154. bufsize -= len;
  3155. space += len;
  3156. }
  3158. return put_user(i, ret);
  3160. calc_space_needed:
  3161. space += len;
  3162. while (++i < mod->ndeps)
  3163. space += strlen(mod->deps[i].dep->name)+1;
  3165. if (put_user(space, ret))
  3166. return -EFAULT;
  3167. else
  3168. return -ENOSPC;
  3169. }
  3171. static int
  3172. qm_refs(struct module *mod, char *buf, size_t bufsize, __kernel_size_t32 *ret)
  3173. {
  3174. size_t nrefs, space, len;
  3175. struct module_ref *ref;
  3177. if (mod->next == NULL)
  3178. return -EINVAL;
  3179. if (!MOD_CAN_QUERY(mod))
  3180. if (put_user(0, ret))
  3181. return -EFAULT;
  3182. else
  3183. return 0;
  3185. space = 0;
  3186. for (nrefs = 0, ref = mod->refs; ref ; ++nrefs, ref = ref->next_ref) {
  3187. const char *ref_name = ref->ref->name;
  3189. len = strlen(ref_name)+1;
  3190. if (len > bufsize)
  3191. goto calc_space_needed;
  3192. if (copy_to_user(buf, ref_name, len))
  3193. return -EFAULT;
  3194. buf += len;
  3195. bufsize -= len;
  3196. space += len;
  3197. }
  3199. if (put_user(nrefs, ret))
  3200. return -EFAULT;
  3201. else
  3202. return 0;
  3204. calc_space_needed:
  3205. space += len;
  3206. while ((ref = ref->next_ref) != NULL)
  3207. space += strlen(ref->ref->name)+1;
  3209. if (put_user(space, ret))
  3210. return -EFAULT;
  3211. else
  3212. return -ENOSPC;
  3213. }
  3215. static inline int
  3216. qm_symbols(struct module *mod, char *buf, size_t bufsize, __kernel_size_t32 *ret)
  3217. {
  3218. size_t i, space, len;
  3219. struct module_symbol *s;
  3220. char *strings;
  3221. unsigned *vals;
  3223. if (!MOD_CAN_QUERY(mod))
  3224. if (put_user(0, ret))
  3225. return -EFAULT;
  3226. else
  3227. return 0;
  3229. space = mod->nsyms * 2*sizeof(u32);
  3231. i = len = 0;
  3232. s = mod->syms;
  3234. if (space > bufsize)
  3235. goto calc_space_needed;
  3237. if (!access_ok(VERIFY_WRITE, buf, space))
  3238. return -EFAULT;
  3240. bufsize -= space;
  3241. vals = (unsigned *)buf;
  3242. strings = buf+space;
  3244. for (; i < mod->nsyms ; ++i, ++s, vals += 2) {
  3245. len = strlen(s->name)+1;
  3246. if (len > bufsize)
  3247. goto calc_space_needed;
  3249. if (copy_to_user(strings, s->name, len)
  3250.     || __put_user(s->value, vals+0)
  3251.     || __put_user(space, vals+1))
  3252. return -EFAULT;
  3254. strings += len;
  3255. bufsize -= len;
  3256. space += len;
  3257. }
  3259. if (put_user(i, ret))
  3260. return -EFAULT;
  3261. else
  3262. return 0;
  3264. calc_space_needed:
  3265. for (; i < mod->nsyms; ++i, ++s)
  3266. space += strlen(s->name)+1;
  3268. if (put_user(space, ret))
  3269. return -EFAULT;
  3270. else
  3271. return -ENOSPC;
  3272. }
  3274. static inline int
  3275. qm_info(struct module *mod, char *buf, size_t bufsize, __kernel_size_t32 *ret)
  3276. {
  3277. int error = 0;
  3279. if (mod->next == NULL)
  3280. return -EINVAL;
  3282. if (sizeof(struct module_info32) <= bufsize) {
  3283. struct module_info32 info;
  3284. info.addr = (unsigned long)mod;
  3285. info.size = mod->size;
  3286. info.flags = mod->flags;
  3287. info.usecount =
  3288. ((mod_member_present(mod, can_unload)
  3289.   && mod->can_unload)
  3290.  ? -1 : atomic_read(&mod->uc.usecount));
  3292. if (copy_to_user(buf, &info, sizeof(struct module_info32)))
  3293. return -EFAULT;
  3294. } else
  3295. error = -ENOSPC;
  3297. if (put_user(sizeof(struct module_info32), ret))
  3298. return -EFAULT;
  3300. return error;
  3301. }
  3303. asmlinkage int sys32_query_module(char *name_user, int which, char *buf, __kernel_size_t32 bufsize, u32 ret)
  3304. {
  3305. struct module *mod;
  3306. int err;
  3308. lock_kernel();
  3309. if (name_user == 0) {
  3310. /* This finds "kernel_module" which is not exported. */
  3311. for(mod = module_list; mod->next != NULL; mod = mod->next)
  3312. ;
  3313. } else {
  3314. long namelen;
  3315. char *name;
  3317. if ((namelen = get_mod_name(name_user, &name)) < 0) {
  3318. err = namelen;
  3319. goto out;
  3320. }
  3321. err = -ENOENT;
  3322. if (namelen == 0) {
  3323. /* This finds "kernel_module" which is not exported. */
  3324. for(mod = module_list; mod->next != NULL; mod = mod->next)
  3325. ;
  3326. } else if ((mod = find_module(name)) == NULL) {
  3327. put_mod_name(name);
  3328. goto out;
  3329. }
  3330. put_mod_name(name);
  3331. }
  3333. switch (which)
  3334. {
  3335. case 0:
  3336. err = 0;
  3337. break;
  3338. case QM_MODULES:
  3339. err = qm_modules(buf, bufsize, (__kernel_size_t32 *)AA(ret));
  3340. break;
  3341. case QM_DEPS:
  3342. err = qm_deps(mod, buf, bufsize, (__kernel_size_t32 *)AA(ret));
  3343. break;
  3344. case QM_REFS:
  3345. err = qm_refs(mod, buf, bufsize, (__kernel_size_t32 *)AA(ret));
  3346. break;
  3347. case QM_SYMBOLS:
  3348. err = qm_symbols(mod, buf, bufsize, (__kernel_size_t32 *)AA(ret));
  3349. break;
  3350. case QM_INFO:
  3351. err = qm_info(mod, buf, bufsize, (__kernel_size_t32 *)AA(ret));
  3352. break;
  3353. default:
  3354. err = -EINVAL;
  3355. break;
  3356. }
  3357. out:
  3358. unlock_kernel();
  3359. return err;
  3360. }
  3362. struct kernel_sym32 {
  3363. u32 value;
  3364. char name[60];
  3365. };
  3366.  
  3367. extern asmlinkage int sys_get_kernel_syms(struct kernel_sym *table);
  3369. asmlinkage int sys32_get_kernel_syms(struct kernel_sym32 *table)
  3370. {
  3371. int len, i;
  3372. struct kernel_sym *tbl;
  3373. mm_segment_t old_fs;
  3375. len = sys_get_kernel_syms(NULL);
  3376. if (!table) return len;
  3377. tbl = kmalloc (len * sizeof (struct kernel_sym), GFP_KERNEL);
  3378. if (!tbl) return -ENOMEM;
  3379. old_fs = get_fs();
  3380. set_fs (KERNEL_DS);
  3381. sys_get_kernel_syms(tbl);
  3382. set_fs (old_fs);
  3383. for (i = 0; i < len; i++, table += sizeof (struct kernel_sym32)) {
  3384. if (put_user (tbl[i].value, &table->value) ||
  3385.     copy_to_user (table->name, tbl[i].name, 60))
  3386. break;
  3387. }
  3388. kfree (tbl);
  3389. return i;
  3390. }
  3392. #else /* CONFIG_MODULES */
  3394. asmlinkage unsigned long
  3395. sys32_create_module(const char *name_user, size_t size)
  3396. {
  3397. return -ENOSYS;
  3398. }
  3400. asmlinkage int
  3401. sys32_init_module(const char *name_user, struct module *mod_user)
  3402. {
  3403. return -ENOSYS;
  3404. }
  3406. asmlinkage int
  3407. sys32_delete_module(const char *name_user)
  3408. {
  3409. return -ENOSYS;
  3410. }
  3412. asmlinkage int
  3413. sys32_query_module(const char *name_user, int which, char *buf, size_t bufsize,
  3414.  size_t *ret)
  3415. {
  3416. /* Let the program know about the new interface.  Not that
  3417.    it'll do them much good.  */
  3418. if (which == 0)
  3419. return 0;
  3421. return -ENOSYS;
  3422. }
  3424. asmlinkage int
  3425. sys32_get_kernel_syms(struct kernel_sym *table)
  3426. {
  3427. return -ENOSYS;
  3428. }
  3430. #endif  /* CONFIG_MODULES */
  3432. /* Stuff for NFS server syscalls... */
  3433. struct nfsctl_svc32 {
  3434. u16 svc32_port;
  3435. s32 svc32_nthreads;
  3436. };
  3438. struct nfsctl_client32 {
  3439. s8 cl32_ident[NFSCLNT_IDMAX+1];
  3440. s32 cl32_naddr;
  3441. struct in_addr cl32_addrlist[NFSCLNT_ADDRMAX];
  3442. s32 cl32_fhkeytype;
  3443. s32 cl32_fhkeylen;
  3444. u8 cl32_fhkey[NFSCLNT_KEYMAX];
  3445. };
  3447. struct nfsctl_export32 {
  3448. s8 ex32_client[NFSCLNT_IDMAX+1];
  3449. s8 ex32_path[NFS_MAXPATHLEN+1];
  3450. __kernel_dev_t32 ex32_dev;
  3451. __kernel_ino_t32 ex32_ino;
  3452. s32 ex32_flags;
  3453. __kernel_uid_t32 ex32_anon_uid;
  3454. __kernel_gid_t32 ex32_anon_gid;
  3455. };
  3457. struct nfsctl_uidmap32 {
  3458. u32 ug32_ident;   /* char * */
  3459. __kernel_uid_t32 ug32_uidbase;
  3460. s32 ug32_uidlen;
  3461. u32 ug32_udimap;  /* uid_t * */
  3462. __kernel_uid_t32 ug32_gidbase;
  3463. s32 ug32_gidlen;
  3464. u32 ug32_gdimap;  /* gid_t * */
  3465. };
  3467. struct nfsctl_fhparm32 {
  3468. struct sockaddr gf32_addr;
  3469. __kernel_dev_t32 gf32_dev;
  3470. __kernel_ino_t32 gf32_ino;
  3471. s32 gf32_version;
  3472. };
  3474. struct nfsctl_fdparm32 {
  3475. struct sockaddr gd32_addr;
  3476. s8 gd32_path[NFS_MAXPATHLEN+1];
  3477. s32 gd32_version;
  3478. };
  3480. struct nfsctl_fsparm32 {
  3481. struct sockaddr gd32_addr;
  3482. s8 gd32_path[NFS_MAXPATHLEN+1];
  3483. s32 gd32_maxlen;
  3484. };
  3486. struct nfsctl_arg32 {
  3487. s32 ca32_version; /* safeguard */
  3488. union {
  3489. struct nfsctl_svc32 u32_svc;
  3490. struct nfsctl_client32 u32_client;
  3491. struct nfsctl_export32 u32_export;
  3492. struct nfsctl_uidmap32 u32_umap;
  3493. struct nfsctl_fhparm32 u32_getfh;
  3494. struct nfsctl_fdparm32 u32_getfd;
  3495. struct nfsctl_fsparm32 u32_getfs;
  3496. } u;
  3497. #define ca32_svc u.u32_svc
  3498. #define ca32_client u.u32_client
  3499. #define ca32_export u.u32_export
  3500. #define ca32_umap u.u32_umap
  3501. #define ca32_getfh u.u32_getfh
  3502. #define ca32_getfd u.u32_getfd
  3503. #define ca32_getfs u.u32_getfs
  3504. #define ca32_authd u.u32_authd
  3505. };
  3507. union nfsctl_res32 {
  3508. __u8 cr32_getfh[NFS_FHSIZE];
  3509. struct knfsd_fh cr32_getfs;
  3510. };
  3512. static int nfs_svc32_trans(struct nfsctl_arg *karg, struct nfsctl_arg32 *arg32)
  3513. {
  3514. int err;
  3516. err = __get_user(karg->ca_version, &arg32->ca32_version);
  3517. err |= __get_user(karg->ca_svc.svc_port, &arg32->ca32_svc.svc32_port);
  3518. err |= __get_user(karg->ca_svc.svc_nthreads, &arg32->ca32_svc.svc32_nthreads);
  3519. return err;
  3520. }
  3522. static int nfs_clnt32_trans(struct nfsctl_arg *karg, struct nfsctl_arg32 *arg32)
  3523. {
  3524. int err;
  3526. err = __get_user(karg->ca_version, &arg32->ca32_version);
  3527. err |= copy_from_user(&karg->ca_client.cl_ident[0],
  3528.   &arg32->ca32_client.cl32_ident[0],
  3529.   NFSCLNT_IDMAX);
  3530. err |= __get_user(karg->ca_client.cl_naddr, &arg32->ca32_client.cl32_naddr);
  3531. err |= copy_from_user(&karg->ca_client.cl_addrlist[0],
  3532.   &arg32->ca32_client.cl32_addrlist[0],
  3533.   (sizeof(struct in_addr) * NFSCLNT_ADDRMAX));
  3534. err |= __get_user(karg->ca_client.cl_fhkeytype,
  3535.       &arg32->ca32_client.cl32_fhkeytype);
  3536. err |= __get_user(karg->ca_client.cl_fhkeylen,
  3537.       &arg32->ca32_client.cl32_fhkeylen);
  3538. err |= copy_from_user(&karg->ca_client.cl_fhkey[0],
  3539.   &arg32->ca32_client.cl32_fhkey[0],
  3540.   NFSCLNT_KEYMAX);
  3541. return err;
  3542. }
  3544. static int nfs_exp32_trans(struct nfsctl_arg *karg, struct nfsctl_arg32 *arg32)
  3545. {
  3546. int err;
  3548. err = __get_user(karg->ca_version, &arg32->ca32_version);
  3549. err |= copy_from_user(&karg->ca_export.ex_client[0],
  3550.   &arg32->ca32_export.ex32_client[0],
  3551.   NFSCLNT_IDMAX);
  3552. err |= copy_from_user(&karg->ca_export.ex_path[0],
  3553.   &arg32->ca32_export.ex32_path[0],
  3554.   NFS_MAXPATHLEN);
  3555. err |= __get_user(karg->ca_export.ex_dev,
  3556.       &arg32->ca32_export.ex32_dev);
  3557. err |= __get_user(karg->ca_export.ex_ino,
  3558.       &arg32->ca32_export.ex32_ino);
  3559. err |= __get_user(karg->ca_export.ex_flags,
  3560.       &arg32->ca32_export.ex32_flags);
  3561. err |= __get_user(karg->ca_export.ex_anon_uid,
  3562.       &arg32->ca32_export.ex32_anon_uid);
  3563. err |= __get_user(karg->ca_export.ex_anon_gid,
  3564.       &arg32->ca32_export.ex32_anon_gid);
  3565. karg->ca_export.ex_anon_uid = high2lowuid(karg->ca_export.ex_anon_uid);
  3566. karg->ca_export.ex_anon_gid = high2lowgid(karg->ca_export.ex_anon_gid);
  3567. return err;
  3568. }
  3570. static int nfs_uud32_trans(struct nfsctl_arg *karg, struct nfsctl_arg32 *arg32)
  3571. {
  3572. u32 uaddr;
  3573. int i;
  3574. int err;
  3576. memset(karg, 0, sizeof(*karg));
  3577. if(__get_user(karg->ca_version, &arg32->ca32_version))
  3578. return -EFAULT;
  3579. karg->ca_umap.ug_ident = (char *)get_free_page(GFP_USER);
  3580. if(!karg->ca_umap.ug_ident)
  3581. return -ENOMEM;
  3582. err = __get_user(uaddr, &arg32->ca32_umap.ug32_ident);
  3583. if(strncpy_from_user(karg->ca_umap.ug_ident,
  3584.      (char *)A(uaddr), PAGE_SIZE) <= 0)
  3585. return -EFAULT;
  3586. err |= __get_user(karg->ca_umap.ug_uidbase,
  3587.       &arg32->ca32_umap.ug32_uidbase);
  3588. err |= __get_user(karg->ca_umap.ug_uidlen,
  3589.       &arg32->ca32_umap.ug32_uidlen);
  3590. err |= __get_user(uaddr, &arg32->ca32_umap.ug32_udimap);
  3591. if (err)
  3592. return -EFAULT;
  3593. karg->ca_umap.ug_udimap = kmalloc((sizeof(uid_t) * karg->ca_umap.ug_uidlen),
  3594.   GFP_USER);
  3595. if(!karg->ca_umap.ug_udimap)
  3596. return -ENOMEM;
  3597. for(i = 0; i < karg->ca_umap.ug_uidlen; i++)
  3598. err |= __get_user(karg->ca_umap.ug_udimap[i],
  3599.       &(((__kernel_uid_t32 *)A(uaddr))[i]));
  3600. err |= __get_user(karg->ca_umap.ug_gidbase,
  3601.       &arg32->ca32_umap.ug32_gidbase);
  3602. err |= __get_user(karg->ca_umap.ug_uidlen,
  3603.       &arg32->ca32_umap.ug32_gidlen);
  3604. err |= __get_user(uaddr, &arg32->ca32_umap.ug32_gdimap);
  3605. if (err)
  3606. return -EFAULT;
  3607. karg->ca_umap.ug_gdimap = kmalloc((sizeof(gid_t) * karg->ca_umap.ug_uidlen),
  3608.   GFP_USER);
  3609. if(!karg->ca_umap.ug_gdimap)
  3610. return -ENOMEM;
  3611. for(i = 0; i < karg->ca_umap.ug_gidlen; i++)
  3612. err |= __get_user(karg->ca_umap.ug_gdimap[i],
  3613.       &(((__kernel_gid_t32 *)A(uaddr))[i]));
  3615. return err;
  3616. }
  3618. static int nfs_getfh32_trans(struct nfsctl_arg *karg, struct nfsctl_arg32 *arg32)
  3619. {
  3620. int err;
  3622. err = __get_user(karg->ca_version, &arg32->ca32_version);
  3623. err |= copy_from_user(&karg->ca_getfh.gf_addr,
  3624.   &arg32->ca32_getfh.gf32_addr,
  3625.   (sizeof(struct sockaddr)));
  3626. err |= __get_user(karg->ca_getfh.gf_dev,
  3627.       &arg32->ca32_getfh.gf32_dev);
  3628. err |= __get_user(karg->ca_getfh.gf_ino,
  3629.       &arg32->ca32_getfh.gf32_ino);
  3630. err |= __get_user(karg->ca_getfh.gf_version,
  3631.       &arg32->ca32_getfh.gf32_version);
  3632. return err;
  3633. }
  3635. static int nfs_getfd32_trans(struct nfsctl_arg *karg, struct nfsctl_arg32 *arg32)
  3636. {
  3637. int err;
  3639. err = __get_user(karg->ca_version, &arg32->ca32_version);
  3640. err |= copy_from_user(&karg->ca_getfd.gd_addr,
  3641.   &arg32->ca32_getfd.gd32_addr,
  3642.   (sizeof(struct sockaddr)));
  3643. err |= copy_from_user(&karg->ca_getfd.gd_path,
  3644.   &arg32->ca32_getfd.gd32_path,
  3645.   (NFS_MAXPATHLEN+1));
  3646. err |= __get_user(karg->ca_getfd.gd_version,
  3647.       &arg32->ca32_getfd.gd32_version);
  3648. return err;
  3649. }
  3651. static int nfs_getfs32_trans(struct nfsctl_arg *karg, struct nfsctl_arg32 *arg32)
  3652. {
  3653. int err;
  3655. err = __get_user(karg->ca_version, &arg32->ca32_version);
  3656. err |= copy_from_user(&karg->ca_getfs.gd_addr,
  3657.   &arg32->ca32_getfs.gd32_addr,
  3658.   (sizeof(struct sockaddr)));
  3659. err |= copy_from_user(&karg->ca_getfs.gd_path,
  3660.   &arg32->ca32_getfs.gd32_path,
  3661.   (NFS_MAXPATHLEN+1));
  3662. err |= __get_user(karg->ca_getfs.gd_maxlen,
  3663.       &arg32->ca32_getfs.gd32_maxlen);
  3664. return err;
  3665. }
  3667. /* This really doesn't need translations, we are only passing
  3668.  * back a union which contains opaque nfs file handle data.
  3669.  */
  3670. static int nfs_getfh32_res_trans(union nfsctl_res *kres, union nfsctl_res32 *res32)
  3671. {
  3672. return copy_to_user(res32, kres, sizeof(*res32));
  3673. }
  3675. /*
  3676. asmlinkage long sys_ni_syscall(void); 
  3677. */
  3679. int asmlinkage sys32_nfsservctl(int cmd, struct nfsctl_arg32 *arg32, union nfsctl_res32 *res32)
  3680. {
  3681. struct nfsctl_arg *karg = NULL;
  3682. union nfsctl_res *kres = NULL;
  3683. mm_segment_t oldfs;
  3684. int err;
  3686. karg = kmalloc(sizeof(*karg), GFP_USER);
  3687. if(!karg)
  3688. return -ENOMEM;
  3689. if(res32) {
  3690. kres = kmalloc(sizeof(*kres), GFP_USER);
  3691. if(!kres) {
  3692. kfree(karg);
  3693. return -ENOMEM;
  3694. }
  3695. }
  3696. switch(cmd) {
  3697. case NFSCTL_SVC:
  3698. err = nfs_svc32_trans(karg, arg32);
  3699. break;
  3700. case NFSCTL_ADDCLIENT:
  3701. err = nfs_clnt32_trans(karg, arg32);
  3702. break;
  3703. case NFSCTL_DELCLIENT:
  3704. err = nfs_clnt32_trans(karg, arg32);
  3705. break;
  3706. case NFSCTL_EXPORT:
  3707. case NFSCTL_UNEXPORT:
  3708. err = nfs_exp32_trans(karg, arg32);
  3709. break;
  3710. /* This one is unimplemented, be we're ready for it. */
  3711. case NFSCTL_UGIDUPDATE:
  3712. err = nfs_uud32_trans(karg, arg32);
  3713. break;
  3714. case NFSCTL_GETFH:
  3715. err = nfs_getfh32_trans(karg, arg32);
  3716. break;
  3717. case NFSCTL_GETFD:
  3718. err = nfs_getfd32_trans(karg, arg32);
  3719. break;
  3720. case NFSCTL_GETFS:
  3721. err = nfs_getfs32_trans(karg, arg32);
  3722. break;
  3723. default:
  3724. err = -EINVAL;
  3725. break;
  3726. }
  3727. if(err)
  3728. goto done;
  3729. oldfs = get_fs();
  3730. set_fs(KERNEL_DS);
  3731. err = sys_nfsservctl(cmd, karg, kres);
  3732. set_fs(oldfs);
  3734. if (err)
  3735. goto done;
  3737. if((cmd == NFSCTL_GETFH) ||
  3738.    (cmd == NFSCTL_GETFD) ||
  3739.    (cmd == NFSCTL_GETFS))
  3740. err = nfs_getfh32_res_trans(kres, res32);
  3742. done:
  3743. if(karg) {
  3744. if(cmd == NFSCTL_UGIDUPDATE) {
  3745. if(karg->ca_umap.ug_ident)
  3746. kfree(karg->ca_umap.ug_ident);
  3747. if(karg->ca_umap.ug_udimap)
  3748. kfree(karg->ca_umap.ug_udimap);
  3749. if(karg->ca_umap.ug_gdimap)
  3750. kfree(karg->ca_umap.ug_gdimap);
  3751. }
  3752. kfree(karg);
  3753. }
  3754. if(kres)
  3755. kfree(kres);
  3756. return err;
  3757. }
  3759. /* Translations due to time_t size differences.  Which affects all
  3760.    sorts of things, like timeval and itimerval.  */
  3762. extern struct timezone sys_tz;
  3763. extern int do_sys_settimeofday(struct timeval *tv, struct timezone *tz);
  3765. asmlinkage int sys32_gettimeofday(struct timeval32 *tv, struct timezone *tz)
  3766. {
  3767. if (tv) {
  3768. struct timeval ktv;
  3769. do_gettimeofday(&ktv);
  3770. if (put_tv32(tv, &ktv))
  3771. return -EFAULT;
  3772. }
  3773. if (tz) {
  3774. if (copy_to_user(tz, &sys_tz, sizeof(sys_tz)))
  3775. return -EFAULT;
  3776. }
  3777. return 0;
  3778. }
  3780. asmlinkage int sys32_settimeofday(struct timeval32 *tv, struct timezone *tz)
  3781. {
  3782. struct timeval ktv;
  3783. struct timezone ktz;
  3785.   if (tv) {
  3786. if (get_tv32(&ktv, tv))
  3787. return -EFAULT;
  3788. }
  3789. if (tz) {
  3790. if (copy_from_user(&ktz, tz, sizeof(ktz)))
  3791. return -EFAULT;
  3792. }
  3794. return do_sys_settimeofday(tv ? &ktv : NULL, tz ? &ktz : NULL);
  3795. }
  3797. extern int do_getitimer(int which, struct itimerval *value);
  3799. asmlinkage int sys32_getitimer(int which, struct itimerval32 *it)
  3800. {
  3801. struct itimerval kit;
  3802. int error;
  3804. error = do_getitimer(which, &kit);
  3805. if (!error && put_it32(it, &kit))
  3806. error = -EFAULT;
  3808. return error;
  3809. }
  3811. extern int do_setitimer(int which, struct itimerval *, struct itimerval *);
  3813. asmlinkage int sys32_setitimer(int which, struct itimerval32 *in, struct itimerval32 *out)
  3814. {
  3815. struct itimerval kin, kout;
  3816. int error;
  3818. if (in) {
  3819. if (get_it32(&kin, in))
  3820. return -EFAULT;
  3821. } else
  3822. memset(&kin, 0, sizeof(kin));
  3824. error = do_setitimer(which, &kin, out ? &kout : NULL);
  3825. if (error || !out)
  3826. return error;
  3827. if (put_it32(out, &kout))
  3828. return -EFAULT;
  3830. return 0;
  3832. }
  3834. asmlinkage int sys_utimes(char *, struct timeval *);
  3836. asmlinkage int sys32_utimes(char *filename, struct timeval32 *tvs)
  3837. {
  3838. char *kfilename;
  3839. struct timeval ktvs[2];
  3840. mm_segment_t old_fs;
  3841. int ret;
  3843. kfilename = getname(filename);
  3844. ret = PTR_ERR(kfilename);
  3845. if (!IS_ERR(kfilename)) {
  3846. if (tvs) {
  3847. if (get_tv32(&ktvs[0], tvs) ||
  3848.     get_tv32(&ktvs[1], 1+tvs))
  3849. return -EFAULT;
  3850. }
  3852. old_fs = get_fs();
  3853. set_fs(KERNEL_DS);
  3854. ret = sys_utimes(kfilename, &ktvs[0]);
  3855. set_fs(old_fs);
  3857. putname(kfilename);
  3858. }
  3859. return ret;
  3860. }
  3862. /* These are here just in case some old sparc32 binary calls it. */
  3863. asmlinkage int sys32_pause(void)
  3864. {
  3865. current->state = TASK_INTERRUPTIBLE;
  3866. schedule();
  3867. return -ERESTARTNOHAND;
  3868. }
  3870. extern asmlinkage int sys_prctl(int option, unsigned long arg2, unsigned long arg3,
  3871. unsigned long arg4, unsigned long arg5);
  3873. asmlinkage int sys32_prctl(int option, u32 arg2, u32 arg3, u32 arg4, u32 arg5)
  3874. {
  3875. return sys_prctl(option,
  3876.  (unsigned long) arg2,
  3877.  (unsigned long) arg3,
  3878.  (unsigned long) arg4,
  3879.  (unsigned long) arg5);
  3880. }
  3883. extern asmlinkage ssize_t sys_pread(unsigned int fd, char * buf,
  3884.     size_t count, loff_t pos);
  3886. extern asmlinkage ssize_t sys_pwrite(unsigned int fd, const char * buf,
  3887.      size_t count, loff_t pos);
  3889. typedef __kernel_ssize_t32 ssize_t32;
  3891. asmlinkage ssize_t32 sys32_pread(unsigned int fd, char *ubuf,
  3892.  __kernel_size_t32 count, u32 poshi, u32 poslo)
  3893. {
  3894. return sys_pread(fd, ubuf, count, ((loff_t)AA(poshi) << 32) | AA(poslo));
  3895. }
  3897. asmlinkage ssize_t32 sys32_pwrite(unsigned int fd, char *ubuf,
  3898.   __kernel_size_t32 count, u32 poshi, u32 poslo)
  3899. {
  3900. return sys_pwrite(fd, ubuf, count, ((loff_t)AA(poshi) << 32) | AA(poslo));
  3901. }
  3904. extern asmlinkage ssize_t sys_sendfile(int out_fd, int in_fd, off_t *offset, size_t count);
  3906. asmlinkage int sys32_sendfile(int out_fd, int in_fd, __kernel_off_t32 *offset, s32 count)
  3907. {
  3908. mm_segment_t old_fs = get_fs();
  3909. int ret;
  3910. off_t of;
  3912. if (offset && get_user(of, offset))
  3913. return -EFAULT;
  3915. set_fs(KERNEL_DS);
  3916. ret = sys_sendfile(out_fd, in_fd, offset ? &of : NULL, count);
  3917. set_fs(old_fs);
  3919. if (!ret && offset && put_user(of, offset))
  3920. return -EFAULT;
  3922. return ret;
  3923. }
  3925. /* Handle adjtimex compatability. */
  3927. struct timex32 {
  3928. u32 modes;
  3929. s32 offset, freq, maxerror, esterror;
  3930. s32 status, constant, precision, tolerance;
  3931. struct timeval32 time;
  3932. s32 tick;
  3933. s32 ppsfreq, jitter, shift, stabil;
  3934. s32 jitcnt, calcnt, errcnt, stbcnt;
  3935. s32  :32; s32  :32; s32  :32; s32  :32;
  3936. s32  :32; s32  :32; s32  :32; s32  :32;
  3937. s32  :32; s32  :32; s32  :32; s32  :32;
  3938. };
  3940. extern int do_adjtimex(struct timex *);
  3942. asmlinkage int sys32_adjtimex(struct timex32 *utp)
  3943. {
  3944. struct timex txc;
  3945. int ret;
  3947. memset(&txc, 0, sizeof(struct timex));
  3949. if(get_user(txc.modes, &utp->modes) ||
  3950.    __get_user(txc.offset, &utp->offset) ||
  3951.    __get_user(txc.freq, &utp->freq) ||
  3952.    __get_user(txc.maxerror, &utp->maxerror) ||
  3953.    __get_user(txc.esterror, &utp->esterror) ||
  3954.    __get_user(txc.status, &utp->status) ||
  3955.    __get_user(txc.constant, &utp->constant) ||
  3956.    __get_user(txc.precision, &utp->precision) ||
  3957.    __get_user(txc.tolerance, &utp->tolerance) ||
  3958.    __get_user(txc.time.tv_sec, &utp->time.tv_sec) ||
  3959.    __get_user(txc.time.tv_usec, &utp->time.tv_usec) ||
  3960.    __get_user(txc.tick, &utp->tick) ||
  3961.    __get_user(txc.ppsfreq, &utp->ppsfreq) ||
  3962.    __get_user(txc.jitter, &utp->jitter) ||
  3963.    __get_user(txc.shift, &utp->shift) ||
  3964.    __get_user(txc.stabil, &utp->stabil) ||
  3965.    __get_user(txc.jitcnt, &utp->jitcnt) ||
  3966.    __get_user(txc.calcnt, &utp->calcnt) ||
  3967.    __get_user(txc.errcnt, &utp->errcnt) ||
  3968.    __get_user(txc.stbcnt, &utp->stbcnt))
  3969. return -EFAULT;
  3971. ret = do_adjtimex(&txc);
  3973. if(put_user(txc.modes, &utp->modes) ||
  3974.    __put_user(txc.offset, &utp->offset) ||
  3975.    __put_user(txc.freq, &utp->freq) ||
  3976.    __put_user(txc.maxerror, &utp->maxerror) ||
  3977.    __put_user(txc.esterror, &utp->esterror) ||
  3978.    __put_user(txc.status, &utp->status) ||
  3979.    __put_user(txc.constant, &utp->constant) ||
  3980.    __put_user(txc.precision, &utp->precision) ||
  3981.    __put_user(txc.tolerance, &utp->tolerance) ||
  3982.    __put_user(txc.time.tv_sec, &utp->time.tv_sec) ||
  3983.    __put_user(txc.time.tv_usec, &utp->time.tv_usec) ||
  3984.    __put_user(txc.tick, &utp->tick) ||
  3985.    __put_user(txc.ppsfreq, &utp->ppsfreq) ||
  3986.    __put_user(txc.jitter, &utp->jitter) ||
  3987.    __put_user(txc.shift, &utp->shift) ||
  3988.    __put_user(txc.stabil, &utp->stabil) ||
  3989.    __put_user(txc.jitcnt, &utp->jitcnt) ||
  3990.    __put_user(txc.calcnt, &utp->calcnt) ||
  3991.    __put_user(txc.errcnt, &utp->errcnt) ||
  3992.    __put_user(txc.stbcnt, &utp->stbcnt))
  3993. ret = -EFAULT;
  3995. return ret;
  3996. }
  3998. extern asmlinkage long sys_setpriority(int which, int who, int niceval);
  4000. asmlinkage int sys_setpriority32(u32 which, u32 who, u32 niceval)
  4001. {
  4002. return sys_setpriority((int) which,
  4003.        (int) who,
  4004.        (int) niceval);
  4005. }
  4007. struct __sysctl_args32 {
  4008. u32 name;
  4009. int nlen;
  4010. u32 oldval;
  4011. u32 oldlenp;
  4012. u32 newval;
  4013. u32 newlen;
  4014. u32 __unused[4];
  4015. };
  4017. extern asmlinkage long sys32_sysctl(struct __sysctl_args32 *args)
  4018. {
  4019. struct __sysctl_args32 tmp;
  4020. int error;
  4021. size_t oldlen, *oldlenp = NULL;
  4022. unsigned long addr = (((long)&args->__unused[0]) + 7) & ~7;
  4024. if (copy_from_user(&tmp, args, sizeof(tmp)))
  4025. return -EFAULT;
  4027. if (tmp.oldval && tmp.oldlenp) {
  4028. /* Duh, this is ugly and might not work if sysctl_args
  4029.    is in read-only memory, but do_sysctl does indirectly
  4030.    a lot of uaccess in both directions and we'd have to
  4031.    basically copy the whole sysctl.c here, and
  4032.    glibc's __sysctl uses rw memory for the structure
  4033.    anyway.  */
  4034. if (get_user(oldlen, (u32 *)A(tmp.oldlenp)) ||
  4035.     put_user(oldlen, (size_t *)addr))
  4036. return -EFAULT;
  4037. oldlenp = (size_t *)addr;
  4038. }
  4040. lock_kernel();
  4041. error = do_sysctl((int *)A(tmp.name), tmp.nlen, (void *)A(tmp.oldval),
  4042.   oldlenp, (void *)A(tmp.newval), tmp.newlen);
  4043. unlock_kernel();
  4044. if (oldlenp) {
  4045. if (!error) {
  4046. if (get_user(oldlen, (size_t *)addr) ||
  4047.     put_user(oldlen, (u32 *)A(tmp.oldlenp)))
  4048. error = -EFAULT;
  4049. }
  4050. copy_to_user(args->__unused, tmp.__unused, sizeof(tmp.__unused));
  4051. }
  4052. return error;
  4053. }
  4055. struct stat64_emu31 {
  4056. unsigned char   __pad0[6];
  4057. unsigned short  st_dev;
  4058. unsigned int    __pad1;
  4059. #define STAT64_HAS_BROKEN_ST_INO        1
  4060. u32             __st_ino;
  4061. unsigned int    st_mode;
  4062. unsigned int    st_nlink;
  4063. u32             st_uid;
  4064. u32             st_gid;
  4065. unsigned char   __pad2[6];
  4066. unsigned short  st_rdev;
  4067. unsigned int    __pad3;
  4068. long            st_size;
  4069. u32             st_blksize;
  4070. unsigned char   __pad4[4];
  4071. u32             __pad5;     /* future possible st_blocks high bits */
  4072. u32             st_blocks;  /* Number 512-byte blocks allocated. */
  4073. u32             st_atime;
  4074. u32             __pad6;
  4075. u32             st_mtime;
  4076. u32             __pad7;
  4077. u32             st_ctime;
  4078. u32             __pad8;     /* will be high 32 bits of ctime someday */
  4079. unsigned long   st_ino;
  4080. };
  4082. static inline int
  4083. putstat64 (struct stat64_emu31 *ubuf, struct stat *kbuf)
  4084. {
  4085.     struct stat64_emu31 tmp;
  4086.    
  4087.     memset(&tmp, 0, sizeof(tmp));
  4089.     tmp.st_dev = (unsigned short)kbuf->st_dev;
  4090.     tmp.st_ino = kbuf->st_ino;
  4091.     tmp.__st_ino = (u32)kbuf->st_ino;
  4092.     tmp.st_mode = kbuf->st_mode;
  4093.     tmp.st_nlink = (unsigned int)kbuf->st_nlink;
  4094.     tmp.st_uid = kbuf->st_uid;
  4095.     tmp.st_gid = kbuf->st_gid;
  4096.     tmp.st_rdev = (unsigned short)kbuf->st_rdev;
  4097.     tmp.st_size = kbuf->st_size;
  4098.     tmp.st_blksize = (u32)kbuf->st_blksize;
  4099.     tmp.st_blocks = (u32)kbuf->st_blocks;
  4100.     tmp.st_atime = (u32)kbuf->st_atime;
  4101.     tmp.st_mtime = (u32)kbuf->st_mtime;
  4102.     tmp.st_ctime = (u32)kbuf->st_ctime;
  4104.     return copy_to_user(ubuf,&tmp,sizeof(tmp)) ? -EFAULT : 0; 
  4105. }
  4107. extern asmlinkage long sys_newstat(char * filename, struct stat * statbuf);
  4109. asmlinkage long sys32_stat64(char * filename, struct stat64_emu31 * statbuf, long flags)
  4110. {
  4111.     int ret;
  4112.     struct stat s;
  4113.     char * tmp;
  4114.     int err;
  4115.     mm_segment_t old_fs = get_fs();
  4116.     
  4117.     tmp = getname(filename);
  4118.     err = PTR_ERR(tmp);
  4119.     if (IS_ERR(tmp))   
  4120.     return err;
  4122.     set_fs (KERNEL_DS);
  4123.     ret = sys_newstat(tmp, &s);
  4124.     set_fs (old_fs);
  4125.     putname(tmp);
  4126.     if (putstat64 (statbuf, &s)) 
  4127.     return -EFAULT;
  4128.     return ret;
  4129. }
  4131. extern asmlinkage long sys_newlstat(char * filename, struct stat * statbuf);
  4133. asmlinkage long sys32_lstat64(char * filename, struct stat64_emu31 * statbuf, long flags)
  4134. {
  4135.     int ret;
  4136.     struct stat s;
  4137.     char * tmp;
  4138.     int err;
  4139.     mm_segment_t old_fs = get_fs();
  4140.     
  4141.     tmp = getname(filename);
  4142.     err = PTR_ERR(tmp);
  4143.     if (IS_ERR(tmp))   
  4144.     return err;
  4146.     set_fs (KERNEL_DS);
  4147.     ret = sys_newlstat(tmp, &s);
  4148.     set_fs (old_fs);
  4149.     putname(tmp);
  4150.     if (putstat64 (statbuf, &s)) 
  4151.     return -EFAULT;
  4152.     return ret;
  4153. }
  4155. extern asmlinkage long sys_newfstat(unsigned int fd, struct stat * statbuf);
  4157. asmlinkage long sys32_fstat64(unsigned long fd, struct stat64_emu31 * statbuf, long flags)
  4158. {
  4159.     int ret;
  4160.     struct stat s;
  4161.     mm_segment_t old_fs = get_fs();
  4162.     
  4163.     set_fs (KERNEL_DS);
  4164.     ret = sys_newfstat(fd, &s);
  4165.     set_fs (old_fs);
  4166.     if (putstat64 (statbuf, &s))
  4167.     return -EFAULT;
  4168.     return ret;
  4169. }
  4171. /*
  4172.  * Linux/i386 didn't use to be able to handle more than
  4173.  * 4 system call parameters, so these system calls used a memory
  4174.  * block for parameter passing..
  4175.  */
  4177. struct mmap_arg_struct_emu31 {
  4178. u32 addr;
  4179. u32 len;
  4180. u32 prot;
  4181. u32 flags;
  4182. u32 fd;
  4183. u32 offset;
  4184. };
  4186. /* common code for old and new mmaps */
  4187. static inline long do_mmap2(
  4188. unsigned long addr, unsigned long len,
  4189. unsigned long prot, unsigned long flags,
  4190. unsigned long fd, unsigned long pgoff)
  4191. {
  4192. struct file * file = NULL;
  4193. unsigned long error = -EBADF;
  4195. flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE);
  4196. if (!(flags & MAP_ANONYMOUS)) {
  4197. file = fget(fd);
  4198. if (!file)
  4199. goto out;
  4200. }
  4202. down_write(&current->mm->mmap_sem);
  4203. error = do_mmap_pgoff(file, addr, len, prot, flags, pgoff);
  4204. if (!IS_ERR((void *) error) && error + len >= 0x80000000ULL) {
  4205. /* Result is out of bounds.  */
  4206. do_munmap(current->mm, addr, len);
  4207. error = -ENOMEM;
  4208. }
  4209. up_write(&current->mm->mmap_sem);
  4211. if (file)
  4212. fput(file);
  4213. out:    
  4214. return error;
  4215. }
  4218. asmlinkage unsigned long
  4219. old32_mmap(struct mmap_arg_struct_emu31 *arg)
  4220. {
  4221. struct mmap_arg_struct_emu31 a;
  4222. int error = -EFAULT;
  4224. if (copy_from_user(&a, arg, sizeof(a)))
  4225. goto out;
  4227. error = -EINVAL;
  4228. if (a.offset & ~PAGE_MASK)
  4229. goto out;
  4231. error = do_mmap2(a.addr, a.len, a.prot, a.flags, a.fd, a.offset >> PAGE_SHIFT); 
  4232. out:
  4233. return error;
  4234. }
  4236. asmlinkage long 
  4237. sys32_mmap2(struct mmap_arg_struct_emu31 *arg)
  4238. {
  4239. struct mmap_arg_struct_emu31 a;
  4240. int error = -EFAULT;
  4242. if (copy_from_user(&a, arg, sizeof(a)))
  4243. goto out;
  4244. error = do_mmap2(a.addr, a.len, a.prot, a.flags, a.fd, a.offset);
  4245. out:
  4246. return error;
  4247. }
  4249. extern asmlinkage long sys_socket(int family, int type, int protocol);
  4250. extern asmlinkage long sys_bind(int fd, struct sockaddr *umyaddr, int addrlen);
  4251. extern asmlinkage long sys_connect(int fd, struct sockaddr *uservaddr, int addrlen);
  4252. extern asmlinkage long sys_listen(int fd, int backlog);
  4253. extern asmlinkage long sys_accept(int fd, struct sockaddr *upeer_sockaddr, int *upeer_addrlen);
  4254. extern asmlinkage long sys_getsockname(int fd, struct sockaddr *usockaddr, int *usockaddr_len);
  4255. extern asmlinkage long sys_getpeername(int fd, struct sockaddr *usockaddr, int *usockaddr_len);
  4256. extern asmlinkage long sys_socketpair(int family, int type, int protocol, int usockvec[2]);
  4257. extern asmlinkage long sys_send(int fd, void * buff, size_t len, unsigned flags);
  4258. extern asmlinkage long sys_sendto(int fd, void * buff, size_t len, unsigned flags,
  4259.                            struct sockaddr *addr, int addr_len);
  4260. extern asmlinkage long sys_recv(int fd, void * ubuf, size_t size, unsigned flags);
  4261. extern asmlinkage long sys_recvfrom(int fd, void * ubuf, size_t size, unsigned flags,
  4262.                              struct sockaddr *addr, int *addr_len);
  4263. extern asmlinkage long sys_shutdown(int fd, int how);
  4264. extern asmlinkage long sys_getsockopt(int fd, int level, int optname, char *optval, int * optlen);
  4266. /* Argument list sizes for sys_socketcall */
  4267. #define AL(x) ((x) * sizeof(u32))
  4268. static unsigned char nas[18] = {AL(0),AL(3),AL(3),AL(3),AL(2),AL(3),
  4269.                                 AL(3),AL(3),AL(4),AL(4),AL(4),AL(6),
  4270.                                 AL(6),AL(2),AL(5),AL(5),AL(3),AL(3)};
  4271. #undef AL
  4273. asmlinkage long sys32_socketcall(int call, u32 *args)
  4274. {
  4275. int ret;
  4276. u32 a[6];
  4277.  
  4278. if (call < SYS_SOCKET || call > SYS_RECVMSG)
  4279. return -EINVAL;
  4280. if (copy_from_user(a, args, nas[call]))
  4281. return -EFAULT;
  4282. switch(call) {
  4283. case SYS_SOCKET:
  4284. ret = sys_socket(a[0], a[1], a[2]);
  4285. break;
  4286. case SYS_BIND:
  4287. ret = sys_bind(a[0], (struct sockaddr *) A(a[1]), a[2]);
  4288. break;
  4289. case SYS_CONNECT:
  4290. ret = sys_connect(a[0], (struct sockaddr *) A(a[1]), a[2]);
  4291. break;
  4292. case SYS_LISTEN:
  4293. ret = sys_listen(a[0], a[1]);
  4294. break;
  4295. case SYS_ACCEPT:
  4296. ret = sys_accept(a[0], (struct sockaddr *) A(a[1]),
  4297.  (int *) A(a[2]));
  4298. break;
  4299. case SYS_GETSOCKNAME:
  4300. ret = sys_getsockname(a[0], (struct sockaddr *) A(a[1]),
  4301.       (int *) A(a[2]));
  4302. break;
  4303. case SYS_GETPEERNAME:
  4304. ret = sys_getpeername(a[0], (struct sockaddr *) A(a[1]),
  4305.       (int *) A(a[2]));
  4306. break;
  4307. case SYS_SOCKETPAIR:
  4308. ret = sys_socketpair(a[0], a[1], a[2], (int *) A(a[3]));
  4309. break;
  4310. case SYS_SEND:
  4311. ret = sys_send(a[0], (void *) A(a[1]), a[2], a[3]);
  4312. break;
  4313. case SYS_SENDTO:
  4314. ret = sys_sendto(a[0], (void*) A(a[1]), a[2], a[3], (struct sockaddr *) A(a[4]), a[5]);
  4315. break;
  4316. case SYS_RECV:
  4317. ret = sys_recv(a[0], (void *) A(a[1]), a[2], a[3]);
  4318. break;
  4319. case SYS_RECVFROM:
  4320. ret = sys_recvfrom(a[0], (void *) A(a[1]), a[2], a[3], (struct sockaddr *) A(a[4]), (int *) A(a[5]) );
  4321. break;
  4322. case SYS_SHUTDOWN:
  4323. ret = sys_shutdown(a[0], a[1]);
  4324. break;
  4325. case SYS_SETSOCKOPT:
  4326. ret = sys32_setsockopt(a[0], a[1], a[2], (char *) A(a[3]),
  4327.      a[4]);
  4328. break;
  4329. case SYS_GETSOCKOPT:
  4330. ret = sys_getsockopt(a[0], a[1], a[2], (char *) A(a[3]), (int *) A(a[4]) );
  4331. break;
  4332. case SYS_SENDMSG:
  4333. ret = sys32_sendmsg(a[0], (struct msghdr32 *) A(a[1]),
  4334.     a[2]);
  4335. break;
  4336. case SYS_RECVMSG:
  4337. ret = sys32_recvmsg(a[0], (struct msghdr32 *) A(a[1]),
  4338.     a[2]);
  4339. break;
  4340. default:
  4341. ret = EINVAL;
  4342. break;
  4343. }
  4344. return ret;
  4345. }