signal.c 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515
  1. /*
  2. * arch/s390/kernel/signal.c
  3. *
  4. * Copyright (C) IBM Corp. 1999,2006
  5. * Author(s): Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
  6. *
  7. * Based on Intel version
  8. *
  9. * Copyright (C) 1991, 1992 Linus Torvalds
  10. *
  11. * 1997-11-28 Modified for POSIX.1b signals by Richard Henderson
  12. */
  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. #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
  31. typedef struct
  32. {
  33. __u8 callee_used_stack[__SIGNAL_FRAMESIZE];
  34. struct sigcontext sc;
  35. _sigregs sregs;
  36. int signo;
  37. __u8 retcode[S390_SYSCALL_SIZE];
  38. } sigframe;
  39. typedef struct
  40. {
  41. __u8 callee_used_stack[__SIGNAL_FRAMESIZE];
  42. __u8 retcode[S390_SYSCALL_SIZE];
  43. struct siginfo info;
  44. struct ucontext uc;
  45. } rt_sigframe;
  46. /*
  47. * Atomically swap in the new signal mask, and wait for a signal.
  48. */
  49. asmlinkage int
  50. sys_sigsuspend(int history0, int history1, old_sigset_t mask)
  51. {
  52. mask &= _BLOCKABLE;
  53. spin_lock_irq(&current->sighand->siglock);
  54. current->saved_sigmask = current->blocked;
  55. siginitset(&current->blocked, mask);
  56. recalc_sigpending();
  57. spin_unlock_irq(&current->sighand->siglock);
  58. current->state = TASK_INTERRUPTIBLE;
  59. schedule();
  60. set_thread_flag(TIF_RESTORE_SIGMASK);
  61. return -ERESTARTNOHAND;
  62. }
  63. asmlinkage long
  64. sys_sigaction(int sig, const struct old_sigaction __user *act,
  65. struct old_sigaction __user *oact)
  66. {
  67. struct k_sigaction new_ka, old_ka;
  68. int ret;
  69. if (act) {
  70. old_sigset_t mask;
  71. if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
  72. __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
  73. __get_user(new_ka.sa.sa_restorer, &act->sa_restorer) ||
  74. __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
  75. __get_user(mask, &act->sa_mask))
  76. return -EFAULT;
  77. siginitset(&new_ka.sa.sa_mask, mask);
  78. }
  79. ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
  80. if (!ret && oact) {
  81. if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
  82. __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
  83. __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer) ||
  84. __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
  85. __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
  86. return -EFAULT;
  87. }
  88. return ret;
  89. }
  90. asmlinkage long
  91. sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss,
  92. struct pt_regs *regs)
  93. {
  94. return do_sigaltstack(uss, uoss, regs->gprs[15]);
  95. }
  96. /* Returns non-zero on fault. */
  97. static int save_sigregs(struct pt_regs *regs, _sigregs __user *sregs)
  98. {
  99. _sigregs user_sregs;
  100. save_access_regs(current->thread.acrs);
  101. /* Copy a 'clean' PSW mask to the user to avoid leaking
  102. information about whether PER is currently on. */
  103. user_sregs.regs.psw.mask = PSW_MASK_MERGE(psw_user_bits, regs->psw.mask);
  104. user_sregs.regs.psw.addr = regs->psw.addr;
  105. memcpy(&user_sregs.regs.gprs, &regs->gprs, sizeof(sregs->regs.gprs));
  106. memcpy(&user_sregs.regs.acrs, current->thread.acrs,
  107. sizeof(sregs->regs.acrs));
  108. /*
  109. * We have to store the fp registers to current->thread.fp_regs
  110. * to merge them with the emulated registers.
  111. */
  112. save_fp_regs(&current->thread.fp_regs);
  113. memcpy(&user_sregs.fpregs, &current->thread.fp_regs,
  114. sizeof(s390_fp_regs));
  115. return __copy_to_user(sregs, &user_sregs, sizeof(_sigregs));
  116. }
  117. /* Returns positive number on error */
  118. static int restore_sigregs(struct pt_regs *regs, _sigregs __user *sregs)
  119. {
  120. int err;
  121. _sigregs user_sregs;
  122. /* Alwys make any pending restarted system call return -EINTR */
  123. current_thread_info()->restart_block.fn = do_no_restart_syscall;
  124. err = __copy_from_user(&user_sregs, sregs, sizeof(_sigregs));
  125. if (err)
  126. return err;
  127. regs->psw.mask = PSW_MASK_MERGE(regs->psw.mask,
  128. user_sregs.regs.psw.mask);
  129. regs->psw.addr = PSW_ADDR_AMODE | user_sregs.regs.psw.addr;
  130. memcpy(&regs->gprs, &user_sregs.regs.gprs, sizeof(sregs->regs.gprs));
  131. memcpy(&current->thread.acrs, &user_sregs.regs.acrs,
  132. sizeof(sregs->regs.acrs));
  133. restore_access_regs(current->thread.acrs);
  134. memcpy(&current->thread.fp_regs, &user_sregs.fpregs,
  135. sizeof(s390_fp_regs));
  136. current->thread.fp_regs.fpc &= FPC_VALID_MASK;
  137. restore_fp_regs(&current->thread.fp_regs);
  138. regs->trap = -1; /* disable syscall checks */
  139. return 0;
  140. }
  141. asmlinkage long sys_sigreturn(struct pt_regs *regs)
  142. {
  143. sigframe __user *frame = (sigframe __user *)regs->gprs[15];
  144. sigset_t set;
  145. if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
  146. goto badframe;
  147. if (__copy_from_user(&set.sig, &frame->sc.oldmask, _SIGMASK_COPY_SIZE))
  148. goto badframe;
  149. sigdelsetmask(&set, ~_BLOCKABLE);
  150. spin_lock_irq(&current->sighand->siglock);
  151. current->blocked = set;
  152. recalc_sigpending();
  153. spin_unlock_irq(&current->sighand->siglock);
  154. if (restore_sigregs(regs, &frame->sregs))
  155. goto badframe;
  156. return regs->gprs[2];
  157. badframe:
  158. force_sig(SIGSEGV, current);
  159. return 0;
  160. }
  161. asmlinkage long sys_rt_sigreturn(struct pt_regs *regs)
  162. {
  163. rt_sigframe __user *frame = (rt_sigframe __user *)regs->gprs[15];
  164. sigset_t set;
  165. if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
  166. goto badframe;
  167. if (__copy_from_user(&set.sig, &frame->uc.uc_sigmask, sizeof(set)))
  168. goto badframe;
  169. sigdelsetmask(&set, ~_BLOCKABLE);
  170. spin_lock_irq(&current->sighand->siglock);
  171. current->blocked = set;
  172. recalc_sigpending();
  173. spin_unlock_irq(&current->sighand->siglock);
  174. if (restore_sigregs(regs, &frame->uc.uc_mcontext))
  175. goto badframe;
  176. if (do_sigaltstack(&frame->uc.uc_stack, NULL,
  177. regs->gprs[15]) == -EFAULT)
  178. goto badframe;
  179. return regs->gprs[2];
  180. badframe:
  181. force_sig(SIGSEGV, current);
  182. return 0;
  183. }
  184. /*
  185. * Set up a signal frame.
  186. */
  187. /*
  188. * Determine which stack to use..
  189. */
  190. static inline void __user *
  191. get_sigframe(struct k_sigaction *ka, struct pt_regs * regs, size_t frame_size)
  192. {
  193. unsigned long sp;
  194. /* Default to using normal stack */
  195. sp = regs->gprs[15];
  196. /* This is the X/Open sanctioned signal stack switching. */
  197. if (ka->sa.sa_flags & SA_ONSTACK) {
  198. if (! sas_ss_flags(sp))
  199. sp = current->sas_ss_sp + current->sas_ss_size;
  200. }
  201. /* This is the legacy signal stack switching. */
  202. else if (!user_mode(regs) &&
  203. !(ka->sa.sa_flags & SA_RESTORER) &&
  204. ka->sa.sa_restorer) {
  205. sp = (unsigned long) ka->sa.sa_restorer;
  206. }
  207. return (void __user *)((sp - frame_size) & -8ul);
  208. }
  209. static inline int map_signal(int sig)
  210. {
  211. if (current_thread_info()->exec_domain
  212. && current_thread_info()->exec_domain->signal_invmap
  213. && sig < 32)
  214. return current_thread_info()->exec_domain->signal_invmap[sig];
  215. else
  216. return sig;
  217. }
  218. static int setup_frame(int sig, struct k_sigaction *ka,
  219. sigset_t *set, struct pt_regs * regs)
  220. {
  221. sigframe __user *frame;
  222. frame = get_sigframe(ka, regs, sizeof(sigframe));
  223. if (!access_ok(VERIFY_WRITE, frame, sizeof(sigframe)))
  224. goto give_sigsegv;
  225. if (__copy_to_user(&frame->sc.oldmask, &set->sig, _SIGMASK_COPY_SIZE))
  226. goto give_sigsegv;
  227. if (save_sigregs(regs, &frame->sregs))
  228. goto give_sigsegv;
  229. if (__put_user(&frame->sregs, &frame->sc.sregs))
  230. goto give_sigsegv;
  231. /* Set up to return from userspace. If provided, use a stub
  232. already in userspace. */
  233. if (ka->sa.sa_flags & SA_RESTORER) {
  234. regs->gprs[14] = (unsigned long)
  235. ka->sa.sa_restorer | PSW_ADDR_AMODE;
  236. } else {
  237. regs->gprs[14] = (unsigned long)
  238. frame->retcode | PSW_ADDR_AMODE;
  239. if (__put_user(S390_SYSCALL_OPCODE | __NR_sigreturn,
  240. (u16 __user *)(frame->retcode)))
  241. goto give_sigsegv;
  242. }
  243. /* Set up backchain. */
  244. if (__put_user(regs->gprs[15], (addr_t __user *) frame))
  245. goto give_sigsegv;
  246. /* Set up registers for signal handler */
  247. regs->gprs[15] = (unsigned long) frame;
  248. regs->psw.addr = (unsigned long) ka->sa.sa_handler | PSW_ADDR_AMODE;
  249. regs->gprs[2] = map_signal(sig);
  250. regs->gprs[3] = (unsigned long) &frame->sc;
  251. /* We forgot to include these in the sigcontext.
  252. To avoid breaking binary compatibility, they are passed as args. */
  253. regs->gprs[4] = current->thread.trap_no;
  254. regs->gprs[5] = current->thread.prot_addr;
  255. /* Place signal number on stack to allow backtrace from handler. */
  256. if (__put_user(regs->gprs[2], (int __user *) &frame->signo))
  257. goto give_sigsegv;
  258. return 0;
  259. give_sigsegv:
  260. force_sigsegv(sig, current);
  261. return -EFAULT;
  262. }
  263. static int setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
  264. sigset_t *set, struct pt_regs * regs)
  265. {
  266. int err = 0;
  267. rt_sigframe __user *frame;
  268. frame = get_sigframe(ka, regs, sizeof(rt_sigframe));
  269. if (!access_ok(VERIFY_WRITE, frame, sizeof(rt_sigframe)))
  270. goto give_sigsegv;
  271. if (copy_siginfo_to_user(&frame->info, info))
  272. goto give_sigsegv;
  273. /* Create the ucontext. */
  274. err |= __put_user(0, &frame->uc.uc_flags);
  275. err |= __put_user(NULL, &frame->uc.uc_link);
  276. err |= __put_user((void __user *)current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
  277. err |= __put_user(sas_ss_flags(regs->gprs[15]),
  278. &frame->uc.uc_stack.ss_flags);
  279. err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
  280. err |= save_sigregs(regs, &frame->uc.uc_mcontext);
  281. err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
  282. if (err)
  283. goto give_sigsegv;
  284. /* Set up to return from userspace. If provided, use a stub
  285. already in userspace. */
  286. if (ka->sa.sa_flags & SA_RESTORER) {
  287. regs->gprs[14] = (unsigned long)
  288. ka->sa.sa_restorer | PSW_ADDR_AMODE;
  289. } else {
  290. regs->gprs[14] = (unsigned long)
  291. frame->retcode | PSW_ADDR_AMODE;
  292. if (__put_user(S390_SYSCALL_OPCODE | __NR_rt_sigreturn,
  293. (u16 __user *)(frame->retcode)))
  294. goto give_sigsegv;
  295. }
  296. /* Set up backchain. */
  297. if (__put_user(regs->gprs[15], (addr_t __user *) frame))
  298. goto give_sigsegv;
  299. /* Set up registers for signal handler */
  300. regs->gprs[15] = (unsigned long) frame;
  301. regs->psw.addr = (unsigned long) ka->sa.sa_handler | PSW_ADDR_AMODE;
  302. regs->gprs[2] = map_signal(sig);
  303. regs->gprs[3] = (unsigned long) &frame->info;
  304. regs->gprs[4] = (unsigned long) &frame->uc;
  305. return 0;
  306. give_sigsegv:
  307. force_sigsegv(sig, current);
  308. return -EFAULT;
  309. }
  310. /*
  311. * OK, we're invoking a handler
  312. */
  313. static int
  314. handle_signal(unsigned long sig, struct k_sigaction *ka,
  315. siginfo_t *info, sigset_t *oldset, struct pt_regs * regs)
  316. {
  317. int ret;
  318. /* Set up the stack frame */
  319. if (ka->sa.sa_flags & SA_SIGINFO)
  320. ret = setup_rt_frame(sig, ka, info, oldset, regs);
  321. else
  322. ret = setup_frame(sig, ka, oldset, regs);
  323. if (ret == 0) {
  324. spin_lock_irq(&current->sighand->siglock);
  325. sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
  326. if (!(ka->sa.sa_flags & SA_NODEFER))
  327. sigaddset(&current->blocked,sig);
  328. recalc_sigpending();
  329. spin_unlock_irq(&current->sighand->siglock);
  330. }
  331. return ret;
  332. }
  333. /*
  334. * Note that 'init' is a special process: it doesn't get signals it doesn't
  335. * want to handle. Thus you cannot kill init even with a SIGKILL even by
  336. * mistake.
  337. *
  338. * Note that we go through the signals twice: once to check the signals that
  339. * the kernel can handle, and then we build all the user-level signal handling
  340. * stack-frames in one go after that.
  341. */
  342. void do_signal(struct pt_regs *regs)
  343. {
  344. unsigned long retval = 0, continue_addr = 0, restart_addr = 0;
  345. siginfo_t info;
  346. int signr;
  347. struct k_sigaction ka;
  348. sigset_t *oldset;
  349. /*
  350. * We want the common case to go fast, which
  351. * is why we may in certain cases get here from
  352. * kernel mode. Just return without doing anything
  353. * if so.
  354. */
  355. if (!user_mode(regs))
  356. return;
  357. if (test_thread_flag(TIF_RESTORE_SIGMASK))
  358. oldset = &current->saved_sigmask;
  359. else
  360. oldset = &current->blocked;
  361. /* Are we from a system call? */
  362. if (regs->trap == __LC_SVC_OLD_PSW) {
  363. continue_addr = regs->psw.addr;
  364. restart_addr = continue_addr - regs->ilc;
  365. retval = regs->gprs[2];
  366. /* Prepare for system call restart. We do this here so that a
  367. debugger will see the already changed PSW. */
  368. switch (retval) {
  369. case -ERESTARTNOHAND:
  370. case -ERESTARTSYS:
  371. case -ERESTARTNOINTR:
  372. regs->gprs[2] = regs->orig_gpr2;
  373. regs->psw.addr = restart_addr;
  374. break;
  375. case -ERESTART_RESTARTBLOCK:
  376. regs->gprs[2] = -EINTR;
  377. }
  378. regs->trap = -1; /* Don't deal with this again. */
  379. }
  380. /* Get signal to deliver. When running under ptrace, at this point
  381. the debugger may change all our registers ... */
  382. signr = get_signal_to_deliver(&info, &ka, regs, NULL);
  383. /* Depending on the signal settings we may need to revert the
  384. decision to restart the system call. */
  385. if (signr > 0 && regs->psw.addr == restart_addr) {
  386. if (retval == -ERESTARTNOHAND
  387. || (retval == -ERESTARTSYS
  388. && !(current->sighand->action[signr-1].sa.sa_flags
  389. & SA_RESTART))) {
  390. regs->gprs[2] = -EINTR;
  391. regs->psw.addr = continue_addr;
  392. }
  393. }
  394. if (signr > 0) {
  395. /* Whee! Actually deliver the signal. */
  396. #ifdef CONFIG_COMPAT
  397. if (test_thread_flag(TIF_31BIT)) {
  398. extern int handle_signal32(unsigned long sig,
  399. struct k_sigaction *ka,
  400. siginfo_t *info,
  401. sigset_t *oldset,
  402. struct pt_regs *regs);
  403. if (handle_signal32(
  404. signr, &ka, &info, oldset, regs) == 0) {
  405. if (test_thread_flag(TIF_RESTORE_SIGMASK))
  406. clear_thread_flag(TIF_RESTORE_SIGMASK);
  407. }
  408. return;
  409. }
  410. #endif
  411. if (handle_signal(signr, &ka, &info, oldset, regs) == 0) {
  412. /*
  413. * A signal was successfully delivered; the saved
  414. * sigmask will have been stored in the signal frame,
  415. * and will be restored by sigreturn, so we can simply
  416. * clear the TIF_RESTORE_SIGMASK flag.
  417. */
  418. if (test_thread_flag(TIF_RESTORE_SIGMASK))
  419. clear_thread_flag(TIF_RESTORE_SIGMASK);
  420. }
  421. return;
  422. }
  423. /*
  424. * If there's no signal to deliver, we just put the saved sigmask back.
  425. */
  426. if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
  427. clear_thread_flag(TIF_RESTORE_SIGMASK);
  428. sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);
  429. }
  430. /* Restart a different system call. */
  431. if (retval == -ERESTART_RESTARTBLOCK
  432. && regs->psw.addr == continue_addr) {
  433. regs->gprs[2] = __NR_restart_syscall;
  434. set_thread_flag(TIF_RESTART_SVC);
  435. }
  436. }