compat_signal.c 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585
  1. /*
  2. * arch/s390/kernel/compat_signal.c
  3. *
  4. * Copyright (C) IBM Corp. 2000,2006
  5. * Author(s): Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
  6. * Gerhard Tonn (ton@de.ibm.com)
  7. *
  8. * Copyright (C) 1991, 1992 Linus Torvalds
  9. *
  10. * 1997-11-28 Modified for POSIX.1b signals by Richard Henderson
  11. */
  12. #include <linux/compat.h>
  13. #include <linux/sched.h>
  14. #include <linux/mm.h>
  15. #include <linux/smp.h>
  16. #include <linux/smp_lock.h>
  17. #include <linux/kernel.h>
  18. #include <linux/signal.h>
  19. #include <linux/errno.h>
  20. #include <linux/wait.h>
  21. #include <linux/ptrace.h>
  22. #include <linux/unistd.h>
  23. #include <linux/stddef.h>
  24. #include <linux/tty.h>
  25. #include <linux/personality.h>
  26. #include <linux/binfmts.h>
  27. #include <asm/ucontext.h>
  28. #include <asm/uaccess.h>
  29. #include <asm/lowcore.h>
  30. #include "compat_linux.h"
  31. #include "compat_ptrace.h"
  32. #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
  33. typedef struct
  34. {
  35. __u8 callee_used_stack[__SIGNAL_FRAMESIZE32];
  36. struct sigcontext32 sc;
  37. _sigregs32 sregs;
  38. int signo;
  39. __u8 retcode[S390_SYSCALL_SIZE];
  40. } sigframe32;
  41. typedef struct
  42. {
  43. __u8 callee_used_stack[__SIGNAL_FRAMESIZE32];
  44. __u8 retcode[S390_SYSCALL_SIZE];
  45. compat_siginfo_t info;
  46. struct ucontext32 uc;
  47. } rt_sigframe32;
  48. int copy_siginfo_to_user32(compat_siginfo_t __user *to, siginfo_t *from)
  49. {
  50. int err;
  51. if (!access_ok (VERIFY_WRITE, to, sizeof(compat_siginfo_t)))
  52. return -EFAULT;
  53. /* If you change siginfo_t structure, please be sure
  54. this code is fixed accordingly.
  55. It should never copy any pad contained in the structure
  56. to avoid security leaks, but must copy the generic
  57. 3 ints plus the relevant union member.
  58. This routine must convert siginfo from 64bit to 32bit as well
  59. at the same time. */
  60. err = __put_user(from->si_signo, &to->si_signo);
  61. err |= __put_user(from->si_errno, &to->si_errno);
  62. err |= __put_user((short)from->si_code, &to->si_code);
  63. if (from->si_code < 0)
  64. err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
  65. else {
  66. switch (from->si_code >> 16) {
  67. case __SI_RT >> 16: /* This is not generated by the kernel as of now. */
  68. case __SI_MESGQ >> 16:
  69. err |= __put_user(from->si_int, &to->si_int);
  70. /* fallthrough */
  71. case __SI_KILL >> 16:
  72. err |= __put_user(from->si_pid, &to->si_pid);
  73. err |= __put_user(from->si_uid, &to->si_uid);
  74. break;
  75. case __SI_CHLD >> 16:
  76. err |= __put_user(from->si_pid, &to->si_pid);
  77. err |= __put_user(from->si_uid, &to->si_uid);
  78. err |= __put_user(from->si_utime, &to->si_utime);
  79. err |= __put_user(from->si_stime, &to->si_stime);
  80. err |= __put_user(from->si_status, &to->si_status);
  81. break;
  82. case __SI_FAULT >> 16:
  83. err |= __put_user((unsigned long) from->si_addr,
  84. &to->si_addr);
  85. break;
  86. case __SI_POLL >> 16:
  87. err |= __put_user(from->si_band, &to->si_band);
  88. err |= __put_user(from->si_fd, &to->si_fd);
  89. break;
  90. case __SI_TIMER >> 16:
  91. err |= __put_user(from->si_tid, &to->si_tid);
  92. err |= __put_user(from->si_overrun, &to->si_overrun);
  93. err |= __put_user(from->si_int, &to->si_int);
  94. break;
  95. default:
  96. break;
  97. }
  98. }
  99. return err;
  100. }
  101. int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from)
  102. {
  103. int err;
  104. u32 tmp;
  105. if (!access_ok (VERIFY_READ, from, sizeof(compat_siginfo_t)))
  106. return -EFAULT;
  107. err = __get_user(to->si_signo, &from->si_signo);
  108. err |= __get_user(to->si_errno, &from->si_errno);
  109. err |= __get_user(to->si_code, &from->si_code);
  110. if (to->si_code < 0)
  111. err |= __copy_from_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
  112. else {
  113. switch (to->si_code >> 16) {
  114. case __SI_RT >> 16: /* This is not generated by the kernel as of now. */
  115. case __SI_MESGQ >> 16:
  116. err |= __get_user(to->si_int, &from->si_int);
  117. /* fallthrough */
  118. case __SI_KILL >> 16:
  119. err |= __get_user(to->si_pid, &from->si_pid);
  120. err |= __get_user(to->si_uid, &from->si_uid);
  121. break;
  122. case __SI_CHLD >> 16:
  123. err |= __get_user(to->si_pid, &from->si_pid);
  124. err |= __get_user(to->si_uid, &from->si_uid);
  125. err |= __get_user(to->si_utime, &from->si_utime);
  126. err |= __get_user(to->si_stime, &from->si_stime);
  127. err |= __get_user(to->si_status, &from->si_status);
  128. break;
  129. case __SI_FAULT >> 16:
  130. err |= __get_user(tmp, &from->si_addr);
  131. to->si_addr = (void __user *)(u64) (tmp & PSW32_ADDR_INSN);
  132. break;
  133. case __SI_POLL >> 16:
  134. err |= __get_user(to->si_band, &from->si_band);
  135. err |= __get_user(to->si_fd, &from->si_fd);
  136. break;
  137. case __SI_TIMER >> 16:
  138. err |= __get_user(to->si_tid, &from->si_tid);
  139. err |= __get_user(to->si_overrun, &from->si_overrun);
  140. err |= __get_user(to->si_int, &from->si_int);
  141. break;
  142. default:
  143. break;
  144. }
  145. }
  146. return err;
  147. }
  148. asmlinkage long
  149. sys32_sigaction(int sig, const struct old_sigaction32 __user *act,
  150. struct old_sigaction32 __user *oact)
  151. {
  152. struct k_sigaction new_ka, old_ka;
  153. unsigned long sa_handler, sa_restorer;
  154. int ret;
  155. if (act) {
  156. compat_old_sigset_t mask;
  157. if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
  158. __get_user(sa_handler, &act->sa_handler) ||
  159. __get_user(sa_restorer, &act->sa_restorer) ||
  160. __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
  161. __get_user(mask, &act->sa_mask))
  162. return -EFAULT;
  163. new_ka.sa.sa_handler = (__sighandler_t) sa_handler;
  164. new_ka.sa.sa_restorer = (void (*)(void)) sa_restorer;
  165. siginitset(&new_ka.sa.sa_mask, mask);
  166. }
  167. ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
  168. if (!ret && oact) {
  169. sa_handler = (unsigned long) old_ka.sa.sa_handler;
  170. sa_restorer = (unsigned long) old_ka.sa.sa_restorer;
  171. if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
  172. __put_user(sa_handler, &oact->sa_handler) ||
  173. __put_user(sa_restorer, &oact->sa_restorer) ||
  174. __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
  175. __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
  176. return -EFAULT;
  177. }
  178. return ret;
  179. }
  180. asmlinkage long
  181. sys32_rt_sigaction(int sig, const struct sigaction32 __user *act,
  182. struct sigaction32 __user *oact, size_t sigsetsize)
  183. {
  184. struct k_sigaction new_ka, old_ka;
  185. unsigned long sa_handler;
  186. int ret;
  187. compat_sigset_t set32;
  188. /* XXX: Don't preclude handling different sized sigset_t's. */
  189. if (sigsetsize != sizeof(compat_sigset_t))
  190. return -EINVAL;
  191. if (act) {
  192. ret = get_user(sa_handler, &act->sa_handler);
  193. ret |= __copy_from_user(&set32, &act->sa_mask,
  194. sizeof(compat_sigset_t));
  195. switch (_NSIG_WORDS) {
  196. case 4: new_ka.sa.sa_mask.sig[3] = set32.sig[6]
  197. | (((long)set32.sig[7]) << 32);
  198. case 3: new_ka.sa.sa_mask.sig[2] = set32.sig[4]
  199. | (((long)set32.sig[5]) << 32);
  200. case 2: new_ka.sa.sa_mask.sig[1] = set32.sig[2]
  201. | (((long)set32.sig[3]) << 32);
  202. case 1: new_ka.sa.sa_mask.sig[0] = set32.sig[0]
  203. | (((long)set32.sig[1]) << 32);
  204. }
  205. ret |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
  206. if (ret)
  207. return -EFAULT;
  208. new_ka.sa.sa_handler = (__sighandler_t) sa_handler;
  209. }
  210. ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
  211. if (!ret && oact) {
  212. switch (_NSIG_WORDS) {
  213. case 4:
  214. set32.sig[7] = (old_ka.sa.sa_mask.sig[3] >> 32);
  215. set32.sig[6] = old_ka.sa.sa_mask.sig[3];
  216. case 3:
  217. set32.sig[5] = (old_ka.sa.sa_mask.sig[2] >> 32);
  218. set32.sig[4] = old_ka.sa.sa_mask.sig[2];
  219. case 2:
  220. set32.sig[3] = (old_ka.sa.sa_mask.sig[1] >> 32);
  221. set32.sig[2] = old_ka.sa.sa_mask.sig[1];
  222. case 1:
  223. set32.sig[1] = (old_ka.sa.sa_mask.sig[0] >> 32);
  224. set32.sig[0] = old_ka.sa.sa_mask.sig[0];
  225. }
  226. ret = put_user((unsigned long)old_ka.sa.sa_handler, &oact->sa_handler);
  227. ret |= __copy_to_user(&oact->sa_mask, &set32,
  228. sizeof(compat_sigset_t));
  229. ret |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
  230. }
  231. return ret;
  232. }
  233. asmlinkage long
  234. sys32_sigaltstack(const stack_t32 __user *uss, stack_t32 __user *uoss,
  235. struct pt_regs *regs)
  236. {
  237. stack_t kss, koss;
  238. unsigned long ss_sp;
  239. int ret, err = 0;
  240. mm_segment_t old_fs = get_fs();
  241. if (uss) {
  242. if (!access_ok(VERIFY_READ, uss, sizeof(*uss)))
  243. return -EFAULT;
  244. err |= __get_user(ss_sp, &uss->ss_sp);
  245. err |= __get_user(kss.ss_size, &uss->ss_size);
  246. err |= __get_user(kss.ss_flags, &uss->ss_flags);
  247. if (err)
  248. return -EFAULT;
  249. kss.ss_sp = (void __user *) ss_sp;
  250. }
  251. set_fs (KERNEL_DS);
  252. ret = do_sigaltstack((stack_t __force __user *) (uss ? &kss : NULL),
  253. (stack_t __force __user *) (uoss ? &koss : NULL),
  254. regs->gprs[15]);
  255. set_fs (old_fs);
  256. if (!ret && uoss) {
  257. if (!access_ok(VERIFY_WRITE, uoss, sizeof(*uoss)))
  258. return -EFAULT;
  259. ss_sp = (unsigned long) koss.ss_sp;
  260. err |= __put_user(ss_sp, &uoss->ss_sp);
  261. err |= __put_user(koss.ss_size, &uoss->ss_size);
  262. err |= __put_user(koss.ss_flags, &uoss->ss_flags);
  263. if (err)
  264. return -EFAULT;
  265. }
  266. return ret;
  267. }
  268. static int save_sigregs32(struct pt_regs *regs, _sigregs32 __user *sregs)
  269. {
  270. _s390_regs_common32 regs32;
  271. int err, i;
  272. regs32.psw.mask = PSW32_MASK_MERGE(psw32_user_bits,
  273. (__u32)(regs->psw.mask >> 32));
  274. regs32.psw.addr = PSW32_ADDR_AMODE31 | (__u32) regs->psw.addr;
  275. for (i = 0; i < NUM_GPRS; i++)
  276. regs32.gprs[i] = (__u32) regs->gprs[i];
  277. save_access_regs(current->thread.acrs);
  278. memcpy(regs32.acrs, current->thread.acrs, sizeof(regs32.acrs));
  279. err = __copy_to_user(&sregs->regs, &regs32, sizeof(regs32));
  280. if (err)
  281. return err;
  282. save_fp_regs(&current->thread.fp_regs);
  283. /* s390_fp_regs and _s390_fp_regs32 are the same ! */
  284. return __copy_to_user(&sregs->fpregs, &current->thread.fp_regs,
  285. sizeof(_s390_fp_regs32));
  286. }
  287. static int restore_sigregs32(struct pt_regs *regs,_sigregs32 __user *sregs)
  288. {
  289. _s390_regs_common32 regs32;
  290. int err, i;
  291. /* Alwys make any pending restarted system call return -EINTR */
  292. current_thread_info()->restart_block.fn = do_no_restart_syscall;
  293. err = __copy_from_user(&regs32, &sregs->regs, sizeof(regs32));
  294. if (err)
  295. return err;
  296. regs->psw.mask = PSW_MASK_MERGE(regs->psw.mask,
  297. (__u64)regs32.psw.mask << 32);
  298. regs->psw.addr = (__u64)(regs32.psw.addr & PSW32_ADDR_INSN);
  299. for (i = 0; i < NUM_GPRS; i++)
  300. regs->gprs[i] = (__u64) regs32.gprs[i];
  301. memcpy(current->thread.acrs, regs32.acrs, sizeof(current->thread.acrs));
  302. restore_access_regs(current->thread.acrs);
  303. err = __copy_from_user(&current->thread.fp_regs, &sregs->fpregs,
  304. sizeof(_s390_fp_regs32));
  305. current->thread.fp_regs.fpc &= FPC_VALID_MASK;
  306. if (err)
  307. return err;
  308. restore_fp_regs(&current->thread.fp_regs);
  309. regs->trap = -1; /* disable syscall checks */
  310. return 0;
  311. }
  312. asmlinkage long sys32_sigreturn(struct pt_regs *regs)
  313. {
  314. sigframe32 __user *frame = (sigframe32 __user *)regs->gprs[15];
  315. sigset_t set;
  316. if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
  317. goto badframe;
  318. if (__copy_from_user(&set.sig, &frame->sc.oldmask, _SIGMASK_COPY_SIZE32))
  319. goto badframe;
  320. sigdelsetmask(&set, ~_BLOCKABLE);
  321. spin_lock_irq(&current->sighand->siglock);
  322. current->blocked = set;
  323. recalc_sigpending();
  324. spin_unlock_irq(&current->sighand->siglock);
  325. if (restore_sigregs32(regs, &frame->sregs))
  326. goto badframe;
  327. return regs->gprs[2];
  328. badframe:
  329. force_sig(SIGSEGV, current);
  330. return 0;
  331. }
  332. asmlinkage long sys32_rt_sigreturn(struct pt_regs *regs)
  333. {
  334. rt_sigframe32 __user *frame = (rt_sigframe32 __user *)regs->gprs[15];
  335. sigset_t set;
  336. stack_t st;
  337. __u32 ss_sp;
  338. int err;
  339. mm_segment_t old_fs = get_fs();
  340. if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
  341. goto badframe;
  342. if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
  343. goto badframe;
  344. sigdelsetmask(&set, ~_BLOCKABLE);
  345. spin_lock_irq(&current->sighand->siglock);
  346. current->blocked = set;
  347. recalc_sigpending();
  348. spin_unlock_irq(&current->sighand->siglock);
  349. if (restore_sigregs32(regs, &frame->uc.uc_mcontext))
  350. goto badframe;
  351. err = __get_user(ss_sp, &frame->uc.uc_stack.ss_sp);
  352. st.ss_sp = compat_ptr(ss_sp);
  353. err |= __get_user(st.ss_size, &frame->uc.uc_stack.ss_size);
  354. err |= __get_user(st.ss_flags, &frame->uc.uc_stack.ss_flags);
  355. if (err)
  356. goto badframe;
  357. set_fs (KERNEL_DS);
  358. do_sigaltstack((stack_t __force __user *)&st, NULL, regs->gprs[15]);
  359. set_fs (old_fs);
  360. return regs->gprs[2];
  361. badframe:
  362. force_sig(SIGSEGV, current);
  363. return 0;
  364. }
  365. /*
  366. * Set up a signal frame.
  367. */
  368. /*
  369. * Determine which stack to use..
  370. */
  371. static inline void __user *
  372. get_sigframe(struct k_sigaction *ka, struct pt_regs * regs, size_t frame_size)
  373. {
  374. unsigned long sp;
  375. /* Default to using normal stack */
  376. sp = (unsigned long) A(regs->gprs[15]);
  377. /* This is the X/Open sanctioned signal stack switching. */
  378. if (ka->sa.sa_flags & SA_ONSTACK) {
  379. if (! sas_ss_flags(sp))
  380. sp = current->sas_ss_sp + current->sas_ss_size;
  381. }
  382. /* This is the legacy signal stack switching. */
  383. else if (!user_mode(regs) &&
  384. !(ka->sa.sa_flags & SA_RESTORER) &&
  385. ka->sa.sa_restorer) {
  386. sp = (unsigned long) ka->sa.sa_restorer;
  387. }
  388. return (void __user *)((sp - frame_size) & -8ul);
  389. }
  390. static inline int map_signal(int sig)
  391. {
  392. if (current_thread_info()->exec_domain
  393. && current_thread_info()->exec_domain->signal_invmap
  394. && sig < 32)
  395. return current_thread_info()->exec_domain->signal_invmap[sig];
  396. else
  397. return sig;
  398. }
  399. static int setup_frame32(int sig, struct k_sigaction *ka,
  400. sigset_t *set, struct pt_regs * regs)
  401. {
  402. sigframe32 __user *frame = get_sigframe(ka, regs, sizeof(sigframe32));
  403. if (!access_ok(VERIFY_WRITE, frame, sizeof(sigframe32)))
  404. goto give_sigsegv;
  405. if (__copy_to_user(&frame->sc.oldmask, &set->sig, _SIGMASK_COPY_SIZE32))
  406. goto give_sigsegv;
  407. if (save_sigregs32(regs, &frame->sregs))
  408. goto give_sigsegv;
  409. if (__put_user((unsigned long) &frame->sregs, &frame->sc.sregs))
  410. goto give_sigsegv;
  411. /* Set up to return from userspace. If provided, use a stub
  412. already in userspace. */
  413. if (ka->sa.sa_flags & SA_RESTORER) {
  414. regs->gprs[14] = (__u64) ka->sa.sa_restorer;
  415. } else {
  416. regs->gprs[14] = (__u64) frame->retcode;
  417. if (__put_user(S390_SYSCALL_OPCODE | __NR_sigreturn,
  418. (u16 __user *)(frame->retcode)))
  419. goto give_sigsegv;
  420. }
  421. /* Set up backchain. */
  422. if (__put_user(regs->gprs[15], (unsigned int __user *) frame))
  423. goto give_sigsegv;
  424. /* Set up registers for signal handler */
  425. regs->gprs[15] = (__u64) frame;
  426. regs->psw.addr = (__u64) ka->sa.sa_handler;
  427. regs->gprs[2] = map_signal(sig);
  428. regs->gprs[3] = (__u64) &frame->sc;
  429. /* We forgot to include these in the sigcontext.
  430. To avoid breaking binary compatibility, they are passed as args. */
  431. regs->gprs[4] = current->thread.trap_no;
  432. regs->gprs[5] = current->thread.prot_addr;
  433. /* Place signal number on stack to allow backtrace from handler. */
  434. if (__put_user(regs->gprs[2], (int __user *) &frame->signo))
  435. goto give_sigsegv;
  436. return 0;
  437. give_sigsegv:
  438. force_sigsegv(sig, current);
  439. return -EFAULT;
  440. }
  441. static int setup_rt_frame32(int sig, struct k_sigaction *ka, siginfo_t *info,
  442. sigset_t *set, struct pt_regs * regs)
  443. {
  444. int err = 0;
  445. rt_sigframe32 __user *frame = get_sigframe(ka, regs, sizeof(rt_sigframe32));
  446. if (!access_ok(VERIFY_WRITE, frame, sizeof(rt_sigframe32)))
  447. goto give_sigsegv;
  448. if (copy_siginfo_to_user32(&frame->info, info))
  449. goto give_sigsegv;
  450. /* Create the ucontext. */
  451. err |= __put_user(0, &frame->uc.uc_flags);
  452. err |= __put_user(0, &frame->uc.uc_link);
  453. err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
  454. err |= __put_user(sas_ss_flags(regs->gprs[15]),
  455. &frame->uc.uc_stack.ss_flags);
  456. err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
  457. err |= save_sigregs32(regs, &frame->uc.uc_mcontext);
  458. err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
  459. if (err)
  460. goto give_sigsegv;
  461. /* Set up to return from userspace. If provided, use a stub
  462. already in userspace. */
  463. if (ka->sa.sa_flags & SA_RESTORER) {
  464. regs->gprs[14] = (__u64) ka->sa.sa_restorer;
  465. } else {
  466. regs->gprs[14] = (__u64) frame->retcode;
  467. err |= __put_user(S390_SYSCALL_OPCODE | __NR_rt_sigreturn,
  468. (u16 __user *)(frame->retcode));
  469. }
  470. /* Set up backchain. */
  471. if (__put_user(regs->gprs[15], (unsigned int __user *) frame))
  472. goto give_sigsegv;
  473. /* Set up registers for signal handler */
  474. regs->gprs[15] = (__u64) frame;
  475. regs->psw.addr = (__u64) ka->sa.sa_handler;
  476. regs->gprs[2] = map_signal(sig);
  477. regs->gprs[3] = (__u64) &frame->info;
  478. regs->gprs[4] = (__u64) &frame->uc;
  479. return 0;
  480. give_sigsegv:
  481. force_sigsegv(sig, current);
  482. return -EFAULT;
  483. }
  484. /*
  485. * OK, we're invoking a handler
  486. */
  487. int
  488. handle_signal32(unsigned long sig, struct k_sigaction *ka,
  489. siginfo_t *info, sigset_t *oldset, struct pt_regs * regs)
  490. {
  491. int ret;
  492. /* Set up the stack frame */
  493. if (ka->sa.sa_flags & SA_SIGINFO)
  494. ret = setup_rt_frame32(sig, ka, info, oldset, regs);
  495. else
  496. ret = setup_frame32(sig, ka, oldset, regs);
  497. if (ret == 0) {
  498. spin_lock_irq(&current->sighand->siglock);
  499. sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
  500. if (!(ka->sa.sa_flags & SA_NODEFER))
  501. sigaddset(&current->blocked,sig);
  502. recalc_sigpending();
  503. spin_unlock_irq(&current->sighand->siglock);
  504. }
  505. return ret;
  506. }