/arch/sparc64/kernel/sys_sparc32.c

https://bitbucket.org/evzijst/gittest · C · 1118 lines · 912 code · 156 blank · 50 comment · 104 complexity · 8d8fd88137e627a513e56bd6d9da4d53 MD5 · raw file

  1. /* $Id: sys_sparc32.c,v 1.184 2002/02/09 19:49:31 davem Exp $
  2. * sys_sparc32.c: Conversion between 32bit and 64bit native syscalls.
  3. *
  4. * Copyright (C) 1997,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
  5. * Copyright (C) 1997 David S. Miller (davem@caip.rutgers.edu)
  6. *
  7. * These routines maintain argument size conversion between 32bit and 64bit
  8. * environment.
  9. */
  10. #include <linux/config.h>
  11. #include <linux/kernel.h>
  12. #include <linux/sched.h>
  13. #include <linux/fs.h>
  14. #include <linux/mm.h>
  15. #include <linux/file.h>
  16. #include <linux/signal.h>
  17. #include <linux/resource.h>
  18. #include <linux/times.h>
  19. #include <linux/utsname.h>
  20. #include <linux/timex.h>
  21. #include <linux/smp.h>
  22. #include <linux/smp_lock.h>
  23. #include <linux/sem.h>
  24. #include <linux/msg.h>
  25. #include <linux/shm.h>
  26. #include <linux/slab.h>
  27. #include <linux/uio.h>
  28. #include <linux/nfs_fs.h>
  29. #include <linux/quota.h>
  30. #include <linux/module.h>
  31. #include <linux/sunrpc/svc.h>
  32. #include <linux/nfsd/nfsd.h>
  33. #include <linux/nfsd/cache.h>
  34. #include <linux/nfsd/xdr.h>
  35. #include <linux/nfsd/syscall.h>
  36. #include <linux/poll.h>
  37. #include <linux/personality.h>
  38. #include <linux/stat.h>
  39. #include <linux/filter.h>
  40. #include <linux/highmem.h>
  41. #include <linux/highuid.h>
  42. #include <linux/mman.h>
  43. #include <linux/ipv6.h>
  44. #include <linux/in.h>
  45. #include <linux/icmpv6.h>
  46. #include <linux/syscalls.h>
  47. #include <linux/sysctl.h>
  48. #include <linux/binfmts.h>
  49. #include <linux/dnotify.h>
  50. #include <linux/security.h>
  51. #include <linux/compat.h>
  52. #include <linux/vfs.h>
  53. #include <linux/netfilter_ipv4/ip_tables.h>
  54. #include <linux/ptrace.h>
  55. #include <linux/highuid.h>
  56. #include <asm/types.h>
  57. #include <asm/ipc.h>
  58. #include <asm/uaccess.h>
  59. #include <asm/fpumacro.h>
  60. #include <asm/semaphore.h>
  61. #include <asm/mmu_context.h>
  62. asmlinkage long sys32_chown16(const char __user * filename, u16 user, u16 group)
  63. {
  64. return sys_chown(filename, low2highuid(user), low2highgid(group));
  65. }
  66. asmlinkage long sys32_lchown16(const char __user * filename, u16 user, u16 group)
  67. {
  68. return sys_lchown(filename, low2highuid(user), low2highgid(group));
  69. }
  70. asmlinkage long sys32_fchown16(unsigned int fd, u16 user, u16 group)
  71. {
  72. return sys_fchown(fd, low2highuid(user), low2highgid(group));
  73. }
  74. asmlinkage long sys32_setregid16(u16 rgid, u16 egid)
  75. {
  76. return sys_setregid(low2highgid(rgid), low2highgid(egid));
  77. }
  78. asmlinkage long sys32_setgid16(u16 gid)
  79. {
  80. return sys_setgid((gid_t)gid);
  81. }
  82. asmlinkage long sys32_setreuid16(u16 ruid, u16 euid)
  83. {
  84. return sys_setreuid(low2highuid(ruid), low2highuid(euid));
  85. }
  86. asmlinkage long sys32_setuid16(u16 uid)
  87. {
  88. return sys_setuid((uid_t)uid);
  89. }
  90. asmlinkage long sys32_setresuid16(u16 ruid, u16 euid, u16 suid)
  91. {
  92. return sys_setresuid(low2highuid(ruid), low2highuid(euid),
  93. low2highuid(suid));
  94. }
  95. asmlinkage long sys32_getresuid16(u16 __user *ruid, u16 __user *euid, u16 __user *suid)
  96. {
  97. int retval;
  98. if (!(retval = put_user(high2lowuid(current->uid), ruid)) &&
  99. !(retval = put_user(high2lowuid(current->euid), euid)))
  100. retval = put_user(high2lowuid(current->suid), suid);
  101. return retval;
  102. }
  103. asmlinkage long sys32_setresgid16(u16 rgid, u16 egid, u16 sgid)
  104. {
  105. return sys_setresgid(low2highgid(rgid), low2highgid(egid),
  106. low2highgid(sgid));
  107. }
  108. asmlinkage long sys32_getresgid16(u16 __user *rgid, u16 __user *egid, u16 __user *sgid)
  109. {
  110. int retval;
  111. if (!(retval = put_user(high2lowgid(current->gid), rgid)) &&
  112. !(retval = put_user(high2lowgid(current->egid), egid)))
  113. retval = put_user(high2lowgid(current->sgid), sgid);
  114. return retval;
  115. }
  116. asmlinkage long sys32_setfsuid16(u16 uid)
  117. {
  118. return sys_setfsuid((uid_t)uid);
  119. }
  120. asmlinkage long sys32_setfsgid16(u16 gid)
  121. {
  122. return sys_setfsgid((gid_t)gid);
  123. }
  124. static int groups16_to_user(u16 __user *grouplist, struct group_info *group_info)
  125. {
  126. int i;
  127. u16 group;
  128. for (i = 0; i < group_info->ngroups; i++) {
  129. group = (u16)GROUP_AT(group_info, i);
  130. if (put_user(group, grouplist+i))
  131. return -EFAULT;
  132. }
  133. return 0;
  134. }
  135. static int groups16_from_user(struct group_info *group_info, u16 __user *grouplist)
  136. {
  137. int i;
  138. u16 group;
  139. for (i = 0; i < group_info->ngroups; i++) {
  140. if (get_user(group, grouplist+i))
  141. return -EFAULT;
  142. GROUP_AT(group_info, i) = (gid_t)group;
  143. }
  144. return 0;
  145. }
  146. asmlinkage long sys32_getgroups16(int gidsetsize, u16 __user *grouplist)
  147. {
  148. int i;
  149. if (gidsetsize < 0)
  150. return -EINVAL;
  151. get_group_info(current->group_info);
  152. i = current->group_info->ngroups;
  153. if (gidsetsize) {
  154. if (i > gidsetsize) {
  155. i = -EINVAL;
  156. goto out;
  157. }
  158. if (groups16_to_user(grouplist, current->group_info)) {
  159. i = -EFAULT;
  160. goto out;
  161. }
  162. }
  163. out:
  164. put_group_info(current->group_info);
  165. return i;
  166. }
  167. asmlinkage long sys32_setgroups16(int gidsetsize, u16 __user *grouplist)
  168. {
  169. struct group_info *group_info;
  170. int retval;
  171. if (!capable(CAP_SETGID))
  172. return -EPERM;
  173. if ((unsigned)gidsetsize > NGROUPS_MAX)
  174. return -EINVAL;
  175. group_info = groups_alloc(gidsetsize);
  176. if (!group_info)
  177. return -ENOMEM;
  178. retval = groups16_from_user(group_info, grouplist);
  179. if (retval) {
  180. put_group_info(group_info);
  181. return retval;
  182. }
  183. retval = set_current_groups(group_info);
  184. put_group_info(group_info);
  185. return retval;
  186. }
  187. asmlinkage long sys32_getuid16(void)
  188. {
  189. return high2lowuid(current->uid);
  190. }
  191. asmlinkage long sys32_geteuid16(void)
  192. {
  193. return high2lowuid(current->euid);
  194. }
  195. asmlinkage long sys32_getgid16(void)
  196. {
  197. return high2lowgid(current->gid);
  198. }
  199. asmlinkage long sys32_getegid16(void)
  200. {
  201. return high2lowgid(current->egid);
  202. }
  203. /* 32-bit timeval and related flotsam. */
  204. static long get_tv32(struct timeval *o, struct compat_timeval __user *i)
  205. {
  206. return (!access_ok(VERIFY_READ, i, sizeof(*i)) ||
  207. (__get_user(o->tv_sec, &i->tv_sec) |
  208. __get_user(o->tv_usec, &i->tv_usec)));
  209. }
  210. static inline long put_tv32(struct compat_timeval __user *o, struct timeval *i)
  211. {
  212. return (!access_ok(VERIFY_WRITE, o, sizeof(*o)) ||
  213. (__put_user(i->tv_sec, &o->tv_sec) |
  214. __put_user(i->tv_usec, &o->tv_usec)));
  215. }
  216. #ifdef CONFIG_SYSVIPC
  217. asmlinkage long compat_sys_ipc(u32 call, u32 first, u32 second, u32 third, compat_uptr_t ptr, u32 fifth)
  218. {
  219. int version;
  220. version = call >> 16; /* hack for backward compatibility */
  221. call &= 0xffff;
  222. switch (call) {
  223. case SEMTIMEDOP:
  224. if (fifth)
  225. /* sign extend semid */
  226. return compat_sys_semtimedop((int)first,
  227. compat_ptr(ptr), second,
  228. compat_ptr(fifth));
  229. /* else fall through for normal semop() */
  230. case SEMOP:
  231. /* struct sembuf is the same on 32 and 64bit :)) */
  232. /* sign extend semid */
  233. return sys_semtimedop((int)first, compat_ptr(ptr), second,
  234. NULL);
  235. case SEMGET:
  236. /* sign extend key, nsems */
  237. return sys_semget((int)first, (int)second, third);
  238. case SEMCTL:
  239. /* sign extend semid, semnum */
  240. return compat_sys_semctl((int)first, (int)second, third,
  241. compat_ptr(ptr));
  242. case MSGSND:
  243. /* sign extend msqid */
  244. return compat_sys_msgsnd((int)first, (int)second, third,
  245. compat_ptr(ptr));
  246. case MSGRCV:
  247. /* sign extend msqid, msgtyp */
  248. return compat_sys_msgrcv((int)first, second, (int)fifth,
  249. third, version, compat_ptr(ptr));
  250. case MSGGET:
  251. /* sign extend key */
  252. return sys_msgget((int)first, second);
  253. case MSGCTL:
  254. /* sign extend msqid */
  255. return compat_sys_msgctl((int)first, second, compat_ptr(ptr));
  256. case SHMAT:
  257. /* sign extend shmid */
  258. return compat_sys_shmat((int)first, second, third, version,
  259. compat_ptr(ptr));
  260. case SHMDT:
  261. return sys_shmdt(compat_ptr(ptr));
  262. case SHMGET:
  263. /* sign extend key_t */
  264. return sys_shmget((int)first, second, third);
  265. case SHMCTL:
  266. /* sign extend shmid */
  267. return compat_sys_shmctl((int)first, second, compat_ptr(ptr));
  268. default:
  269. return -ENOSYS;
  270. };
  271. return -ENOSYS;
  272. }
  273. #endif
  274. asmlinkage long sys32_truncate64(const char __user * path, unsigned long high, unsigned long low)
  275. {
  276. if ((int)high < 0)
  277. return -EINVAL;
  278. else
  279. return sys_truncate(path, (high << 32) | low);
  280. }
  281. asmlinkage long sys32_ftruncate64(unsigned int fd, unsigned long high, unsigned long low)
  282. {
  283. if ((int)high < 0)
  284. return -EINVAL;
  285. else
  286. return sys_ftruncate(fd, (high << 32) | low);
  287. }
  288. int cp_compat_stat(struct kstat *stat, struct compat_stat __user *statbuf)
  289. {
  290. int err;
  291. if (stat->size > MAX_NON_LFS || !old_valid_dev(stat->dev) ||
  292. !old_valid_dev(stat->rdev))
  293. return -EOVERFLOW;
  294. err = put_user(old_encode_dev(stat->dev), &statbuf->st_dev);
  295. err |= put_user(stat->ino, &statbuf->st_ino);
  296. err |= put_user(stat->mode, &statbuf->st_mode);
  297. err |= put_user(stat->nlink, &statbuf->st_nlink);
  298. err |= put_user(high2lowuid(stat->uid), &statbuf->st_uid);
  299. err |= put_user(high2lowgid(stat->gid), &statbuf->st_gid);
  300. err |= put_user(old_encode_dev(stat->rdev), &statbuf->st_rdev);
  301. err |= put_user(stat->size, &statbuf->st_size);
  302. err |= put_user(stat->atime.tv_sec, &statbuf->st_atime);
  303. err |= put_user(0, &statbuf->__unused1);
  304. err |= put_user(stat->mtime.tv_sec, &statbuf->st_mtime);
  305. err |= put_user(0, &statbuf->__unused2);
  306. err |= put_user(stat->ctime.tv_sec, &statbuf->st_ctime);
  307. err |= put_user(0, &statbuf->__unused3);
  308. err |= put_user(stat->blksize, &statbuf->st_blksize);
  309. err |= put_user(stat->blocks, &statbuf->st_blocks);
  310. err |= put_user(0, &statbuf->__unused4[0]);
  311. err |= put_user(0, &statbuf->__unused4[1]);
  312. return err;
  313. }
  314. asmlinkage long compat_sys_sysfs(int option, u32 arg1, u32 arg2)
  315. {
  316. return sys_sysfs(option, arg1, arg2);
  317. }
  318. struct sysinfo32 {
  319. s32 uptime;
  320. u32 loads[3];
  321. u32 totalram;
  322. u32 freeram;
  323. u32 sharedram;
  324. u32 bufferram;
  325. u32 totalswap;
  326. u32 freeswap;
  327. unsigned short procs;
  328. unsigned short pad;
  329. u32 totalhigh;
  330. u32 freehigh;
  331. u32 mem_unit;
  332. char _f[20-2*sizeof(int)-sizeof(int)];
  333. };
  334. asmlinkage long sys32_sysinfo(struct sysinfo32 __user *info)
  335. {
  336. struct sysinfo s;
  337. int ret, err;
  338. int bitcount = 0;
  339. mm_segment_t old_fs = get_fs ();
  340. set_fs(KERNEL_DS);
  341. ret = sys_sysinfo((struct sysinfo __user *) &s);
  342. set_fs(old_fs);
  343. /* Check to see if any memory value is too large for 32-bit and
  344. * scale down if needed.
  345. */
  346. if ((s.totalram >> 32) || (s.totalswap >> 32)) {
  347. while (s.mem_unit < PAGE_SIZE) {
  348. s.mem_unit <<= 1;
  349. bitcount++;
  350. }
  351. s.totalram >>= bitcount;
  352. s.freeram >>= bitcount;
  353. s.sharedram >>= bitcount;
  354. s.bufferram >>= bitcount;
  355. s.totalswap >>= bitcount;
  356. s.freeswap >>= bitcount;
  357. s.totalhigh >>= bitcount;
  358. s.freehigh >>= bitcount;
  359. }
  360. err = put_user (s.uptime, &info->uptime);
  361. err |= __put_user (s.loads[0], &info->loads[0]);
  362. err |= __put_user (s.loads[1], &info->loads[1]);
  363. err |= __put_user (s.loads[2], &info->loads[2]);
  364. err |= __put_user (s.totalram, &info->totalram);
  365. err |= __put_user (s.freeram, &info->freeram);
  366. err |= __put_user (s.sharedram, &info->sharedram);
  367. err |= __put_user (s.bufferram, &info->bufferram);
  368. err |= __put_user (s.totalswap, &info->totalswap);
  369. err |= __put_user (s.freeswap, &info->freeswap);
  370. err |= __put_user (s.procs, &info->procs);
  371. err |= __put_user (s.totalhigh, &info->totalhigh);
  372. err |= __put_user (s.freehigh, &info->freehigh);
  373. err |= __put_user (s.mem_unit, &info->mem_unit);
  374. if (err)
  375. return -EFAULT;
  376. return ret;
  377. }
  378. asmlinkage long compat_sys_sched_rr_get_interval(compat_pid_t pid, struct compat_timespec __user *interval)
  379. {
  380. struct timespec t;
  381. int ret;
  382. mm_segment_t old_fs = get_fs ();
  383. set_fs (KERNEL_DS);
  384. ret = sys_sched_rr_get_interval(pid, (struct timespec __user *) &t);
  385. set_fs (old_fs);
  386. if (put_compat_timespec(&t, interval))
  387. return -EFAULT;
  388. return ret;
  389. }
  390. asmlinkage long compat_sys_rt_sigprocmask(int how,
  391. compat_sigset_t __user *set,
  392. compat_sigset_t __user *oset,
  393. compat_size_t sigsetsize)
  394. {
  395. sigset_t s;
  396. compat_sigset_t s32;
  397. int ret;
  398. mm_segment_t old_fs = get_fs();
  399. if (set) {
  400. if (copy_from_user (&s32, set, sizeof(compat_sigset_t)))
  401. return -EFAULT;
  402. switch (_NSIG_WORDS) {
  403. case 4: s.sig[3] = s32.sig[6] | (((long)s32.sig[7]) << 32);
  404. case 3: s.sig[2] = s32.sig[4] | (((long)s32.sig[5]) << 32);
  405. case 2: s.sig[1] = s32.sig[2] | (((long)s32.sig[3]) << 32);
  406. case 1: s.sig[0] = s32.sig[0] | (((long)s32.sig[1]) << 32);
  407. }
  408. }
  409. set_fs (KERNEL_DS);
  410. ret = sys_rt_sigprocmask(how,
  411. set ? (sigset_t __user *) &s : NULL,
  412. oset ? (sigset_t __user *) &s : NULL,
  413. sigsetsize);
  414. set_fs (old_fs);
  415. if (ret) return ret;
  416. if (oset) {
  417. switch (_NSIG_WORDS) {
  418. case 4: s32.sig[7] = (s.sig[3] >> 32); s32.sig[6] = s.sig[3];
  419. case 3: s32.sig[5] = (s.sig[2] >> 32); s32.sig[4] = s.sig[2];
  420. case 2: s32.sig[3] = (s.sig[1] >> 32); s32.sig[2] = s.sig[1];
  421. case 1: s32.sig[1] = (s.sig[0] >> 32); s32.sig[0] = s.sig[0];
  422. }
  423. if (copy_to_user (oset, &s32, sizeof(compat_sigset_t)))
  424. return -EFAULT;
  425. }
  426. return 0;
  427. }
  428. asmlinkage long sys32_rt_sigpending(compat_sigset_t __user *set,
  429. compat_size_t sigsetsize)
  430. {
  431. sigset_t s;
  432. compat_sigset_t s32;
  433. int ret;
  434. mm_segment_t old_fs = get_fs();
  435. set_fs (KERNEL_DS);
  436. ret = sys_rt_sigpending((sigset_t __user *) &s, sigsetsize);
  437. set_fs (old_fs);
  438. if (!ret) {
  439. switch (_NSIG_WORDS) {
  440. case 4: s32.sig[7] = (s.sig[3] >> 32); s32.sig[6] = s.sig[3];
  441. case 3: s32.sig[5] = (s.sig[2] >> 32); s32.sig[4] = s.sig[2];
  442. case 2: s32.sig[3] = (s.sig[1] >> 32); s32.sig[2] = s.sig[1];
  443. case 1: s32.sig[1] = (s.sig[0] >> 32); s32.sig[0] = s.sig[0];
  444. }
  445. if (copy_to_user (set, &s32, sizeof(compat_sigset_t)))
  446. return -EFAULT;
  447. }
  448. return ret;
  449. }
  450. asmlinkage long compat_sys_rt_sigqueueinfo(int pid, int sig,
  451. struct compat_siginfo __user *uinfo)
  452. {
  453. siginfo_t info;
  454. int ret;
  455. mm_segment_t old_fs = get_fs();
  456. if (copy_siginfo_from_user32(&info, uinfo))
  457. return -EFAULT;
  458. set_fs (KERNEL_DS);
  459. ret = sys_rt_sigqueueinfo(pid, sig, (siginfo_t __user *) &info);
  460. set_fs (old_fs);
  461. return ret;
  462. }
  463. asmlinkage long compat_sys_sigaction(int sig, struct old_sigaction32 __user *act,
  464. struct old_sigaction32 __user *oact)
  465. {
  466. struct k_sigaction new_ka, old_ka;
  467. int ret;
  468. if (sig < 0) {
  469. set_thread_flag(TIF_NEWSIGNALS);
  470. sig = -sig;
  471. }
  472. if (act) {
  473. compat_old_sigset_t mask;
  474. u32 u_handler, u_restorer;
  475. ret = get_user(u_handler, &act->sa_handler);
  476. new_ka.sa.sa_handler = compat_ptr(u_handler);
  477. ret |= __get_user(u_restorer, &act->sa_restorer);
  478. new_ka.sa.sa_restorer = compat_ptr(u_restorer);
  479. ret |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
  480. ret |= __get_user(mask, &act->sa_mask);
  481. if (ret)
  482. return ret;
  483. new_ka.ka_restorer = NULL;
  484. siginitset(&new_ka.sa.sa_mask, mask);
  485. }
  486. ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
  487. if (!ret && oact) {
  488. ret = put_user(ptr_to_compat(old_ka.sa.sa_handler), &oact->sa_handler);
  489. ret |= __put_user(ptr_to_compat(old_ka.sa.sa_restorer), &oact->sa_restorer);
  490. ret |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
  491. ret |= __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask);
  492. }
  493. return ret;
  494. }
  495. asmlinkage long compat_sys_rt_sigaction(int sig,
  496. struct sigaction32 __user *act,
  497. struct sigaction32 __user *oact,
  498. void __user *restorer,
  499. compat_size_t sigsetsize)
  500. {
  501. struct k_sigaction new_ka, old_ka;
  502. int ret;
  503. compat_sigset_t set32;
  504. /* XXX: Don't preclude handling different sized sigset_t's. */
  505. if (sigsetsize != sizeof(compat_sigset_t))
  506. return -EINVAL;
  507. /* All tasks which use RT signals (effectively) use
  508. * new style signals.
  509. */
  510. set_thread_flag(TIF_NEWSIGNALS);
  511. if (act) {
  512. u32 u_handler, u_restorer;
  513. new_ka.ka_restorer = restorer;
  514. ret = get_user(u_handler, &act->sa_handler);
  515. new_ka.sa.sa_handler = compat_ptr(u_handler);
  516. ret |= __copy_from_user(&set32, &act->sa_mask, sizeof(compat_sigset_t));
  517. switch (_NSIG_WORDS) {
  518. case 4: new_ka.sa.sa_mask.sig[3] = set32.sig[6] | (((long)set32.sig[7]) << 32);
  519. case 3: new_ka.sa.sa_mask.sig[2] = set32.sig[4] | (((long)set32.sig[5]) << 32);
  520. case 2: new_ka.sa.sa_mask.sig[1] = set32.sig[2] | (((long)set32.sig[3]) << 32);
  521. case 1: new_ka.sa.sa_mask.sig[0] = set32.sig[0] | (((long)set32.sig[1]) << 32);
  522. }
  523. ret |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
  524. ret |= __get_user(u_restorer, &act->sa_restorer);
  525. new_ka.sa.sa_restorer = compat_ptr(u_restorer);
  526. if (ret)
  527. return -EFAULT;
  528. }
  529. ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
  530. if (!ret && oact) {
  531. switch (_NSIG_WORDS) {
  532. case 4: set32.sig[7] = (old_ka.sa.sa_mask.sig[3] >> 32); set32.sig[6] = old_ka.sa.sa_mask.sig[3];
  533. case 3: set32.sig[5] = (old_ka.sa.sa_mask.sig[2] >> 32); set32.sig[4] = old_ka.sa.sa_mask.sig[2];
  534. case 2: set32.sig[3] = (old_ka.sa.sa_mask.sig[1] >> 32); set32.sig[2] = old_ka.sa.sa_mask.sig[1];
  535. case 1: set32.sig[1] = (old_ka.sa.sa_mask.sig[0] >> 32); set32.sig[0] = old_ka.sa.sa_mask.sig[0];
  536. }
  537. ret = put_user(ptr_to_compat(old_ka.sa.sa_handler), &oact->sa_handler);
  538. ret |= __copy_to_user(&oact->sa_mask, &set32, sizeof(compat_sigset_t));
  539. ret |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
  540. ret |= __put_user(ptr_to_compat(old_ka.sa.sa_restorer), &oact->sa_restorer);
  541. if (ret)
  542. ret = -EFAULT;
  543. }
  544. return ret;
  545. }
  546. /*
  547. * sparc32_execve() executes a new program after the asm stub has set
  548. * things up for us. This should basically do what I want it to.
  549. */
  550. asmlinkage long sparc32_execve(struct pt_regs *regs)
  551. {
  552. int error, base = 0;
  553. char *filename;
  554. /* User register window flush is done by entry.S */
  555. /* Check for indirect call. */
  556. if ((u32)regs->u_regs[UREG_G1] == 0)
  557. base = 1;
  558. filename = getname(compat_ptr(regs->u_regs[base + UREG_I0]));
  559. error = PTR_ERR(filename);
  560. if (IS_ERR(filename))
  561. goto out;
  562. error = compat_do_execve(filename,
  563. compat_ptr(regs->u_regs[base + UREG_I1]),
  564. compat_ptr(regs->u_regs[base + UREG_I2]), regs);
  565. putname(filename);
  566. if (!error) {
  567. fprs_write(0);
  568. current_thread_info()->xfsr[0] = 0;
  569. current_thread_info()->fpsaved[0] = 0;
  570. regs->tstate &= ~TSTATE_PEF;
  571. task_lock(current);
  572. current->ptrace &= ~PT_DTRACE;
  573. task_unlock(current);
  574. }
  575. out:
  576. return error;
  577. }
  578. #ifdef CONFIG_MODULES
  579. asmlinkage long sys32_init_module(void __user *umod, u32 len,
  580. const char __user *uargs)
  581. {
  582. return sys_init_module(umod, len, uargs);
  583. }
  584. asmlinkage long sys32_delete_module(const char __user *name_user,
  585. unsigned int flags)
  586. {
  587. return sys_delete_module(name_user, flags);
  588. }
  589. #else /* CONFIG_MODULES */
  590. asmlinkage long sys32_init_module(const char __user *name_user,
  591. struct module __user *mod_user)
  592. {
  593. return -ENOSYS;
  594. }
  595. asmlinkage long sys32_delete_module(const char __user *name_user)
  596. {
  597. return -ENOSYS;
  598. }
  599. #endif /* CONFIG_MODULES */
  600. /* Translations due to time_t size differences. Which affects all
  601. sorts of things, like timeval and itimerval. */
  602. extern struct timezone sys_tz;
  603. asmlinkage long sys32_gettimeofday(struct compat_timeval __user *tv,
  604. struct timezone __user *tz)
  605. {
  606. if (tv) {
  607. struct timeval ktv;
  608. do_gettimeofday(&ktv);
  609. if (put_tv32(tv, &ktv))
  610. return -EFAULT;
  611. }
  612. if (tz) {
  613. if (copy_to_user(tz, &sys_tz, sizeof(sys_tz)))
  614. return -EFAULT;
  615. }
  616. return 0;
  617. }
  618. static inline long get_ts32(struct timespec *o, struct compat_timeval __user *i)
  619. {
  620. long usec;
  621. if (!access_ok(VERIFY_READ, i, sizeof(*i)))
  622. return -EFAULT;
  623. if (__get_user(o->tv_sec, &i->tv_sec))
  624. return -EFAULT;
  625. if (__get_user(usec, &i->tv_usec))
  626. return -EFAULT;
  627. o->tv_nsec = usec * 1000;
  628. return 0;
  629. }
  630. asmlinkage long sys32_settimeofday(struct compat_timeval __user *tv,
  631. struct timezone __user *tz)
  632. {
  633. struct timespec kts;
  634. struct timezone ktz;
  635. if (tv) {
  636. if (get_ts32(&kts, tv))
  637. return -EFAULT;
  638. }
  639. if (tz) {
  640. if (copy_from_user(&ktz, tz, sizeof(ktz)))
  641. return -EFAULT;
  642. }
  643. return do_sys_settimeofday(tv ? &kts : NULL, tz ? &ktz : NULL);
  644. }
  645. asmlinkage long sys32_utimes(char __user *filename,
  646. struct compat_timeval __user *tvs)
  647. {
  648. struct timeval ktvs[2];
  649. if (tvs) {
  650. if (get_tv32(&ktvs[0], tvs) ||
  651. get_tv32(&ktvs[1], 1+tvs))
  652. return -EFAULT;
  653. }
  654. return do_utimes(filename, (tvs ? &ktvs[0] : NULL));
  655. }
  656. /* These are here just in case some old sparc32 binary calls it. */
  657. asmlinkage long sys32_pause(void)
  658. {
  659. current->state = TASK_INTERRUPTIBLE;
  660. schedule();
  661. return -ERESTARTNOHAND;
  662. }
  663. asmlinkage compat_ssize_t sys32_pread64(unsigned int fd,
  664. char __user *ubuf,
  665. compat_size_t count,
  666. unsigned long poshi,
  667. unsigned long poslo)
  668. {
  669. return sys_pread64(fd, ubuf, count, (poshi << 32) | poslo);
  670. }
  671. asmlinkage compat_ssize_t sys32_pwrite64(unsigned int fd,
  672. char __user *ubuf,
  673. compat_size_t count,
  674. unsigned long poshi,
  675. unsigned long poslo)
  676. {
  677. return sys_pwrite64(fd, ubuf, count, (poshi << 32) | poslo);
  678. }
  679. asmlinkage long compat_sys_readahead(int fd,
  680. unsigned long offhi,
  681. unsigned long offlo,
  682. compat_size_t count)
  683. {
  684. return sys_readahead(fd, (offhi << 32) | offlo, count);
  685. }
  686. long compat_sys_fadvise64(int fd,
  687. unsigned long offhi,
  688. unsigned long offlo,
  689. compat_size_t len, int advice)
  690. {
  691. return sys_fadvise64_64(fd, (offhi << 32) | offlo, len, advice);
  692. }
  693. long compat_sys_fadvise64_64(int fd,
  694. unsigned long offhi, unsigned long offlo,
  695. unsigned long lenhi, unsigned long lenlo,
  696. int advice)
  697. {
  698. return sys_fadvise64_64(fd,
  699. (offhi << 32) | offlo,
  700. (lenhi << 32) | lenlo,
  701. advice);
  702. }
  703. asmlinkage long compat_sys_sendfile(int out_fd, int in_fd,
  704. compat_off_t __user *offset,
  705. compat_size_t count)
  706. {
  707. mm_segment_t old_fs = get_fs();
  708. int ret;
  709. off_t of;
  710. if (offset && get_user(of, offset))
  711. return -EFAULT;
  712. set_fs(KERNEL_DS);
  713. ret = sys_sendfile(out_fd, in_fd,
  714. offset ? (off_t __user *) &of : NULL,
  715. count);
  716. set_fs(old_fs);
  717. if (offset && put_user(of, offset))
  718. return -EFAULT;
  719. return ret;
  720. }
  721. asmlinkage long compat_sys_sendfile64(int out_fd, int in_fd,
  722. compat_loff_t __user *offset,
  723. compat_size_t count)
  724. {
  725. mm_segment_t old_fs = get_fs();
  726. int ret;
  727. loff_t lof;
  728. if (offset && get_user(lof, offset))
  729. return -EFAULT;
  730. set_fs(KERNEL_DS);
  731. ret = sys_sendfile64(out_fd, in_fd,
  732. offset ? (loff_t __user *) &lof : NULL,
  733. count);
  734. set_fs(old_fs);
  735. if (offset && put_user(lof, offset))
  736. return -EFAULT;
  737. return ret;
  738. }
  739. /* Handle adjtimex compatibility. */
  740. struct timex32 {
  741. u32 modes;
  742. s32 offset, freq, maxerror, esterror;
  743. s32 status, constant, precision, tolerance;
  744. struct compat_timeval time;
  745. s32 tick;
  746. s32 ppsfreq, jitter, shift, stabil;
  747. s32 jitcnt, calcnt, errcnt, stbcnt;
  748. s32 :32; s32 :32; s32 :32; s32 :32;
  749. s32 :32; s32 :32; s32 :32; s32 :32;
  750. s32 :32; s32 :32; s32 :32; s32 :32;
  751. };
  752. extern int do_adjtimex(struct timex *);
  753. asmlinkage long sys32_adjtimex(struct timex32 __user *utp)
  754. {
  755. struct timex txc;
  756. int ret;
  757. memset(&txc, 0, sizeof(struct timex));
  758. if (get_user(txc.modes, &utp->modes) ||
  759. __get_user(txc.offset, &utp->offset) ||
  760. __get_user(txc.freq, &utp->freq) ||
  761. __get_user(txc.maxerror, &utp->maxerror) ||
  762. __get_user(txc.esterror, &utp->esterror) ||
  763. __get_user(txc.status, &utp->status) ||
  764. __get_user(txc.constant, &utp->constant) ||
  765. __get_user(txc.precision, &utp->precision) ||
  766. __get_user(txc.tolerance, &utp->tolerance) ||
  767. __get_user(txc.time.tv_sec, &utp->time.tv_sec) ||
  768. __get_user(txc.time.tv_usec, &utp->time.tv_usec) ||
  769. __get_user(txc.tick, &utp->tick) ||
  770. __get_user(txc.ppsfreq, &utp->ppsfreq) ||
  771. __get_user(txc.jitter, &utp->jitter) ||
  772. __get_user(txc.shift, &utp->shift) ||
  773. __get_user(txc.stabil, &utp->stabil) ||
  774. __get_user(txc.jitcnt, &utp->jitcnt) ||
  775. __get_user(txc.calcnt, &utp->calcnt) ||
  776. __get_user(txc.errcnt, &utp->errcnt) ||
  777. __get_user(txc.stbcnt, &utp->stbcnt))
  778. return -EFAULT;
  779. ret = do_adjtimex(&txc);
  780. if (put_user(txc.modes, &utp->modes) ||
  781. __put_user(txc.offset, &utp->offset) ||
  782. __put_user(txc.freq, &utp->freq) ||
  783. __put_user(txc.maxerror, &utp->maxerror) ||
  784. __put_user(txc.esterror, &utp->esterror) ||
  785. __put_user(txc.status, &utp->status) ||
  786. __put_user(txc.constant, &utp->constant) ||
  787. __put_user(txc.precision, &utp->precision) ||
  788. __put_user(txc.tolerance, &utp->tolerance) ||
  789. __put_user(txc.time.tv_sec, &utp->time.tv_sec) ||
  790. __put_user(txc.time.tv_usec, &utp->time.tv_usec) ||
  791. __put_user(txc.tick, &utp->tick) ||
  792. __put_user(txc.ppsfreq, &utp->ppsfreq) ||
  793. __put_user(txc.jitter, &utp->jitter) ||
  794. __put_user(txc.shift, &utp->shift) ||
  795. __put_user(txc.stabil, &utp->stabil) ||
  796. __put_user(txc.jitcnt, &utp->jitcnt) ||
  797. __put_user(txc.calcnt, &utp->calcnt) ||
  798. __put_user(txc.errcnt, &utp->errcnt) ||
  799. __put_user(txc.stbcnt, &utp->stbcnt))
  800. ret = -EFAULT;
  801. return ret;
  802. }
  803. /* This is just a version for 32-bit applications which does
  804. * not force O_LARGEFILE on.
  805. */
  806. asmlinkage long sparc32_open(const char __user *filename,
  807. int flags, int mode)
  808. {
  809. char * tmp;
  810. int fd, error;
  811. tmp = getname(filename);
  812. fd = PTR_ERR(tmp);
  813. if (!IS_ERR(tmp)) {
  814. fd = get_unused_fd();
  815. if (fd >= 0) {
  816. struct file * f = filp_open(tmp, flags, mode);
  817. error = PTR_ERR(f);
  818. if (IS_ERR(f))
  819. goto out_error;
  820. fd_install(fd, f);
  821. }
  822. out:
  823. putname(tmp);
  824. }
  825. return fd;
  826. out_error:
  827. put_unused_fd(fd);
  828. fd = error;
  829. goto out;
  830. }
  831. extern unsigned long do_mremap(unsigned long addr,
  832. unsigned long old_len, unsigned long new_len,
  833. unsigned long flags, unsigned long new_addr);
  834. asmlinkage unsigned long sys32_mremap(unsigned long addr,
  835. unsigned long old_len, unsigned long new_len,
  836. unsigned long flags, u32 __new_addr)
  837. {
  838. struct vm_area_struct *vma;
  839. unsigned long ret = -EINVAL;
  840. unsigned long new_addr = __new_addr;
  841. if (old_len > 0xf0000000UL || new_len > 0xf0000000UL)
  842. goto out;
  843. if (addr > 0xf0000000UL - old_len)
  844. goto out;
  845. down_write(&current->mm->mmap_sem);
  846. if (flags & MREMAP_FIXED) {
  847. if (new_addr > 0xf0000000UL - new_len)
  848. goto out_sem;
  849. } else if (addr > 0xf0000000UL - new_len) {
  850. unsigned long map_flags = 0;
  851. struct file *file = NULL;
  852. ret = -ENOMEM;
  853. if (!(flags & MREMAP_MAYMOVE))
  854. goto out_sem;
  855. vma = find_vma(current->mm, addr);
  856. if (vma) {
  857. if (vma->vm_flags & VM_SHARED)
  858. map_flags |= MAP_SHARED;
  859. file = vma->vm_file;
  860. }
  861. /* MREMAP_FIXED checked above. */
  862. new_addr = get_unmapped_area(file, addr, new_len,
  863. vma ? vma->vm_pgoff : 0,
  864. map_flags);
  865. ret = new_addr;
  866. if (new_addr & ~PAGE_MASK)
  867. goto out_sem;
  868. flags |= MREMAP_FIXED;
  869. }
  870. ret = do_mremap(addr, old_len, new_len, flags, new_addr);
  871. out_sem:
  872. up_write(&current->mm->mmap_sem);
  873. out:
  874. return ret;
  875. }
  876. struct __sysctl_args32 {
  877. u32 name;
  878. int nlen;
  879. u32 oldval;
  880. u32 oldlenp;
  881. u32 newval;
  882. u32 newlen;
  883. u32 __unused[4];
  884. };
  885. asmlinkage long sys32_sysctl(struct __sysctl_args32 __user *args)
  886. {
  887. #ifndef CONFIG_SYSCTL
  888. return -ENOSYS;
  889. #else
  890. struct __sysctl_args32 tmp;
  891. int error;
  892. size_t oldlen, __user *oldlenp = NULL;
  893. unsigned long addr = (((unsigned long)&args->__unused[0]) + 7UL) & ~7UL;
  894. if (copy_from_user(&tmp, args, sizeof(tmp)))
  895. return -EFAULT;
  896. if (tmp.oldval && tmp.oldlenp) {
  897. /* Duh, this is ugly and might not work if sysctl_args
  898. is in read-only memory, but do_sysctl does indirectly
  899. a lot of uaccess in both directions and we'd have to
  900. basically copy the whole sysctl.c here, and
  901. glibc's __sysctl uses rw memory for the structure
  902. anyway. */
  903. if (get_user(oldlen, (u32 __user *)(unsigned long)tmp.oldlenp) ||
  904. put_user(oldlen, (size_t __user *)addr))
  905. return -EFAULT;
  906. oldlenp = (size_t __user *)addr;
  907. }
  908. lock_kernel();
  909. error = do_sysctl((int __user *)(unsigned long) tmp.name,
  910. tmp.nlen,
  911. (void __user *)(unsigned long) tmp.oldval,
  912. oldlenp,
  913. (void __user *)(unsigned long) tmp.newval,
  914. tmp.newlen);
  915. unlock_kernel();
  916. if (oldlenp) {
  917. if (!error) {
  918. if (get_user(oldlen, (size_t __user *)addr) ||
  919. put_user(oldlen, (u32 __user *)(unsigned long) tmp.oldlenp))
  920. error = -EFAULT;
  921. }
  922. if (copy_to_user(args->__unused, tmp.__unused, sizeof(tmp.__unused)))
  923. error = -EFAULT;
  924. }
  925. return error;
  926. #endif
  927. }
  928. long sys32_lookup_dcookie(unsigned long cookie_high,
  929. unsigned long cookie_low,
  930. char __user *buf, size_t len)
  931. {
  932. return sys_lookup_dcookie((cookie_high << 32) | cookie_low,
  933. buf, len);
  934. }
  935. extern asmlinkage long
  936. sys_timer_create(clockid_t which_clock,
  937. struct sigevent __user *timer_event_spec,
  938. timer_t __user *created_timer_id);
  939. long
  940. sys32_timer_create(u32 clock, struct compat_sigevent __user *se32,
  941. timer_t __user *timer_id)
  942. {
  943. struct sigevent se;
  944. mm_segment_t oldfs;
  945. timer_t t;
  946. long err;
  947. if (se32 == NULL)
  948. return sys_timer_create(clock, NULL, timer_id);
  949. if (get_compat_sigevent(&se, se32))
  950. return -EFAULT;
  951. if (!access_ok(VERIFY_WRITE,timer_id,sizeof(timer_t)))
  952. return -EFAULT;
  953. oldfs = get_fs();
  954. set_fs(KERNEL_DS);
  955. err = sys_timer_create(clock,
  956. (struct sigevent __user *) &se,
  957. (timer_t __user *) &t);
  958. set_fs(oldfs);
  959. if (!err)
  960. err = __put_user (t, timer_id);
  961. return err;
  962. }