signal.c 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563
  1. /*
  2. * linux/arch/h8300/kernel/signal.c
  3. *
  4. * Copyright (C) 1991, 1992 Linus Torvalds
  5. *
  6. * This file is subject to the terms and conditions of the GNU General Public
  7. * License. See the file COPYING in the main directory of this archive
  8. * for more details.
  9. */
  10. /*
  11. * uClinux H8/300 support by Yoshinori Sato <ysato@users.sourceforge.jp>
  12. * and David McCullough <davidm@snapgear.com>
  13. *
  14. * Based on
  15. * Linux/m68k by Hamish Macdonald
  16. */
  17. /*
  18. * ++roman (07/09/96): implemented signal stacks (specially for tosemu on
  19. * Atari :-) Current limitation: Only one sigstack can be active at one time.
  20. * If a second signal with SA_ONSTACK set arrives while working on a sigstack,
  21. * SA_ONSTACK is ignored. This behaviour avoids lots of trouble with nested
  22. * signal handlers!
  23. */
  24. #include <linux/sched.h>
  25. #include <linux/mm.h>
  26. #include <linux/kernel.h>
  27. #include <linux/signal.h>
  28. #include <linux/syscalls.h>
  29. #include <linux/errno.h>
  30. #include <linux/wait.h>
  31. #include <linux/ptrace.h>
  32. #include <linux/unistd.h>
  33. #include <linux/stddef.h>
  34. #include <linux/highuid.h>
  35. #include <linux/personality.h>
  36. #include <linux/tty.h>
  37. #include <linux/binfmts.h>
  38. #include <linux/freezer.h>
  39. #include <linux/tracehook.h>
  40. #include <asm/setup.h>
  41. #include <asm/uaccess.h>
  42. #include <asm/pgtable.h>
  43. #include <asm/traps.h>
  44. #include <asm/ucontext.h>
  45. #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
  46. asmlinkage int do_signal(struct pt_regs *regs, sigset_t *oldset);
  47. /*
  48. * Atomically swap in the new signal mask, and wait for a signal.
  49. */
  50. asmlinkage int do_sigsuspend(struct pt_regs *regs)
  51. {
  52. old_sigset_t mask = regs->er3;
  53. sigset_t saveset;
  54. mask &= _BLOCKABLE;
  55. spin_lock_irq(&current->sighand->siglock);
  56. saveset = current->blocked;
  57. siginitset(&current->blocked, mask);
  58. recalc_sigpending();
  59. spin_unlock_irq(&current->sighand->siglock);
  60. regs->er0 = -EINTR;
  61. while (1) {
  62. current->state = TASK_INTERRUPTIBLE;
  63. schedule();
  64. if (do_signal(regs, &saveset))
  65. return -EINTR;
  66. }
  67. }
  68. asmlinkage int
  69. do_rt_sigsuspend(struct pt_regs *regs)
  70. {
  71. sigset_t *unewset = (sigset_t *)regs->er1;
  72. size_t sigsetsize = (size_t)regs->er2;
  73. sigset_t saveset, newset;
  74. /* XXX: Don't preclude handling different sized sigset_t's. */
  75. if (sigsetsize != sizeof(sigset_t))
  76. return -EINVAL;
  77. if (copy_from_user(&newset, unewset, sizeof(newset)))
  78. return -EFAULT;
  79. sigdelsetmask(&newset, ~_BLOCKABLE);
  80. spin_lock_irq(&current->sighand->siglock);
  81. saveset = current->blocked;
  82. current->blocked = newset;
  83. recalc_sigpending();
  84. spin_unlock_irq(&current->sighand->siglock);
  85. regs->er0 = -EINTR;
  86. while (1) {
  87. current->state = TASK_INTERRUPTIBLE;
  88. schedule();
  89. if (do_signal(regs, &saveset))
  90. return -EINTR;
  91. }
  92. }
  93. asmlinkage int
  94. sys_sigaction(int sig, const struct old_sigaction *act,
  95. struct old_sigaction *oact)
  96. {
  97. struct k_sigaction new_ka, old_ka;
  98. int ret;
  99. if (act) {
  100. old_sigset_t mask;
  101. if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
  102. __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
  103. __get_user(new_ka.sa.sa_restorer, &act->sa_restorer))
  104. return -EFAULT;
  105. __get_user(new_ka.sa.sa_flags, &act->sa_flags);
  106. __get_user(mask, &act->sa_mask);
  107. siginitset(&new_ka.sa.sa_mask, mask);
  108. }
  109. ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
  110. if (!ret && oact) {
  111. if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
  112. __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
  113. __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer))
  114. return -EFAULT;
  115. __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
  116. __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask);
  117. }
  118. return ret;
  119. }
  120. asmlinkage int
  121. sys_sigaltstack(const stack_t *uss, stack_t *uoss)
  122. {
  123. return do_sigaltstack(uss, uoss, rdusp());
  124. }
  125. /*
  126. * Do a signal return; undo the signal stack.
  127. *
  128. * Keep the return code on the stack quadword aligned!
  129. * That makes the cache flush below easier.
  130. */
  131. struct sigframe
  132. {
  133. long dummy_er0;
  134. long dummy_vector;
  135. #if defined(CONFIG_CPU_H8S)
  136. short dummy_exr;
  137. #endif
  138. long dummy_pc;
  139. char *pretcode;
  140. unsigned char retcode[8];
  141. unsigned long extramask[_NSIG_WORDS-1];
  142. struct sigcontext sc;
  143. int sig;
  144. } __attribute__((aligned(2),packed));
  145. struct rt_sigframe
  146. {
  147. long dummy_er0;
  148. long dummy_vector;
  149. #if defined(CONFIG_CPU_H8S)
  150. short dummy_exr;
  151. #endif
  152. long dummy_pc;
  153. char *pretcode;
  154. struct siginfo *pinfo;
  155. void *puc;
  156. unsigned char retcode[8];
  157. struct siginfo info;
  158. struct ucontext uc;
  159. int sig;
  160. } __attribute__((aligned(2),packed));
  161. static inline int
  162. restore_sigcontext(struct pt_regs *regs, struct sigcontext *usc,
  163. int *pd0)
  164. {
  165. int err = 0;
  166. unsigned int ccr;
  167. unsigned int usp;
  168. unsigned int er0;
  169. /* Always make any pending restarted system calls return -EINTR */
  170. current_thread_info()->restart_block.fn = do_no_restart_syscall;
  171. #define COPY(r) err |= __get_user(regs->r, &usc->sc_##r) /* restore passed registers */
  172. COPY(er1);
  173. COPY(er2);
  174. COPY(er3);
  175. COPY(er5);
  176. COPY(pc);
  177. ccr = regs->ccr & 0x10;
  178. COPY(ccr);
  179. #undef COPY
  180. regs->ccr &= 0xef;
  181. regs->ccr |= ccr;
  182. regs->orig_er0 = -1; /* disable syscall checks */
  183. err |= __get_user(usp, &usc->sc_usp);
  184. wrusp(usp);
  185. err |= __get_user(er0, &usc->sc_er0);
  186. *pd0 = er0;
  187. return err;
  188. }
  189. asmlinkage int do_sigreturn(unsigned long __unused,...)
  190. {
  191. struct pt_regs *regs = (struct pt_regs *) (&__unused - 1);
  192. unsigned long usp = rdusp();
  193. struct sigframe *frame = (struct sigframe *)(usp - 4);
  194. sigset_t set;
  195. int er0;
  196. if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
  197. goto badframe;
  198. if (__get_user(set.sig[0], &frame->sc.sc_mask) ||
  199. (_NSIG_WORDS > 1 &&
  200. __copy_from_user(&set.sig[1], &frame->extramask,
  201. sizeof(frame->extramask))))
  202. goto badframe;
  203. sigdelsetmask(&set, ~_BLOCKABLE);
  204. spin_lock_irq(&current->sighand->siglock);
  205. current->blocked = set;
  206. recalc_sigpending();
  207. spin_unlock_irq(&current->sighand->siglock);
  208. if (restore_sigcontext(regs, &frame->sc, &er0))
  209. goto badframe;
  210. return er0;
  211. badframe:
  212. force_sig(SIGSEGV, current);
  213. return 0;
  214. }
  215. asmlinkage int do_rt_sigreturn(unsigned long __unused,...)
  216. {
  217. struct pt_regs *regs = (struct pt_regs *) &__unused;
  218. unsigned long usp = rdusp();
  219. struct rt_sigframe *frame = (struct rt_sigframe *)(usp - 4);
  220. sigset_t set;
  221. int er0;
  222. if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
  223. goto badframe;
  224. if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
  225. goto badframe;
  226. sigdelsetmask(&set, ~_BLOCKABLE);
  227. spin_unlock_irq(&current->sighand->siglock);
  228. current->blocked = set;
  229. recalc_sigpending();
  230. spin_lock_irq(&current->sighand->siglock);
  231. if (restore_sigcontext(regs, &frame->uc.uc_mcontext, &er0))
  232. goto badframe;
  233. if (do_sigaltstack(&frame->uc.uc_stack, NULL, usp) == -EFAULT)
  234. goto badframe;
  235. return er0;
  236. badframe:
  237. force_sig(SIGSEGV, current);
  238. return 0;
  239. }
  240. static int setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs,
  241. unsigned long mask)
  242. {
  243. int err = 0;
  244. err |= __put_user(regs->er0, &sc->sc_er0);
  245. err |= __put_user(regs->er1, &sc->sc_er1);
  246. err |= __put_user(regs->er2, &sc->sc_er2);
  247. err |= __put_user(regs->er3, &sc->sc_er3);
  248. err |= __put_user(regs->er4, &sc->sc_er4);
  249. err |= __put_user(regs->er5, &sc->sc_er5);
  250. err |= __put_user(regs->er6, &sc->sc_er6);
  251. err |= __put_user(rdusp(), &sc->sc_usp);
  252. err |= __put_user(regs->pc, &sc->sc_pc);
  253. err |= __put_user(regs->ccr, &sc->sc_ccr);
  254. err |= __put_user(mask, &sc->sc_mask);
  255. return err;
  256. }
  257. static inline void *
  258. get_sigframe(struct k_sigaction *ka, struct pt_regs *regs, size_t frame_size)
  259. {
  260. unsigned long usp;
  261. /* Default to using normal stack. */
  262. usp = rdusp();
  263. /* This is the X/Open sanctioned signal stack switching. */
  264. if (ka->sa.sa_flags & SA_ONSTACK) {
  265. if (!sas_ss_flags(usp))
  266. usp = current->sas_ss_sp + current->sas_ss_size;
  267. }
  268. return (void *)((usp - frame_size) & -8UL);
  269. }
  270. static void setup_frame (int sig, struct k_sigaction *ka,
  271. sigset_t *set, struct pt_regs *regs)
  272. {
  273. struct sigframe *frame;
  274. int err = 0;
  275. int usig;
  276. unsigned char *ret;
  277. frame = get_sigframe(ka, regs, sizeof(*frame));
  278. if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
  279. goto give_sigsegv;
  280. usig = current_thread_info()->exec_domain
  281. && current_thread_info()->exec_domain->signal_invmap
  282. && sig < 32
  283. ? current_thread_info()->exec_domain->signal_invmap[sig]
  284. : sig;
  285. err |= __put_user(usig, &frame->sig);
  286. if (err)
  287. goto give_sigsegv;
  288. err |= setup_sigcontext(&frame->sc, regs, set->sig[0]);
  289. if (err)
  290. goto give_sigsegv;
  291. if (_NSIG_WORDS > 1) {
  292. err |= copy_to_user(frame->extramask, &set->sig[1],
  293. sizeof(frame->extramask));
  294. if (err)
  295. goto give_sigsegv;
  296. }
  297. ret = frame->retcode;
  298. if (ka->sa.sa_flags & SA_RESTORER)
  299. ret = (unsigned char *)(ka->sa.sa_restorer);
  300. else {
  301. /* sub.l er0,er0; mov.b #__NR_sigreturn,r0l; trapa #0 */
  302. err |= __put_user(0x1a80f800 + (__NR_sigreturn & 0xff),
  303. (unsigned long *)(frame->retcode + 0));
  304. err |= __put_user(0x5700, (unsigned short *)(frame->retcode + 4));
  305. }
  306. /* Set up to return from userspace. */
  307. err |= __put_user(ret, &frame->pretcode);
  308. if (err)
  309. goto give_sigsegv;
  310. /* Set up registers for signal handler */
  311. wrusp ((unsigned long) frame);
  312. regs->pc = (unsigned long) ka->sa.sa_handler;
  313. regs->er0 = (current_thread_info()->exec_domain
  314. && current_thread_info()->exec_domain->signal_invmap
  315. && sig < 32
  316. ? current_thread_info()->exec_domain->signal_invmap[sig]
  317. : sig);
  318. regs->er1 = (unsigned long)&(frame->sc);
  319. regs->er5 = current->mm->start_data; /* GOT base */
  320. return;
  321. give_sigsegv:
  322. force_sigsegv(sig, current);
  323. }
  324. static void setup_rt_frame (int sig, struct k_sigaction *ka, siginfo_t *info,
  325. sigset_t *set, struct pt_regs *regs)
  326. {
  327. struct rt_sigframe *frame;
  328. int err = 0;
  329. int usig;
  330. unsigned char *ret;
  331. frame = get_sigframe(ka, regs, sizeof(*frame));
  332. if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
  333. goto give_sigsegv;
  334. usig = current_thread_info()->exec_domain
  335. && current_thread_info()->exec_domain->signal_invmap
  336. && sig < 32
  337. ? current_thread_info()->exec_domain->signal_invmap[sig]
  338. : sig;
  339. err |= __put_user(usig, &frame->sig);
  340. if (err)
  341. goto give_sigsegv;
  342. err |= __put_user(&frame->info, &frame->pinfo);
  343. err |= __put_user(&frame->uc, &frame->puc);
  344. err |= copy_siginfo_to_user(&frame->info, info);
  345. if (err)
  346. goto give_sigsegv;
  347. /* Create the ucontext. */
  348. err |= __put_user(0, &frame->uc.uc_flags);
  349. err |= __put_user(0, &frame->uc.uc_link);
  350. err |= __put_user((void *)current->sas_ss_sp,
  351. &frame->uc.uc_stack.ss_sp);
  352. err |= __put_user(sas_ss_flags(rdusp()),
  353. &frame->uc.uc_stack.ss_flags);
  354. err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
  355. err |= setup_sigcontext(&frame->uc.uc_mcontext, regs, set->sig[0]);
  356. err |= copy_to_user (&frame->uc.uc_sigmask, set, sizeof(*set));
  357. if (err)
  358. goto give_sigsegv;
  359. /* Set up to return from userspace. */
  360. ret = frame->retcode;
  361. if (ka->sa.sa_flags & SA_RESTORER)
  362. ret = (unsigned char *)(ka->sa.sa_restorer);
  363. else {
  364. /* sub.l er0,er0; mov.b #__NR_sigreturn,r0l; trapa #0 */
  365. err |= __put_user(0x1a80f800 + (__NR_sigreturn & 0xff),
  366. (unsigned long *)(frame->retcode + 0));
  367. err |= __put_user(0x5700, (unsigned short *)(frame->retcode + 4));
  368. }
  369. err |= __put_user(ret, &frame->pretcode);
  370. if (err)
  371. goto give_sigsegv;
  372. /* Set up registers for signal handler */
  373. wrusp ((unsigned long) frame);
  374. regs->pc = (unsigned long) ka->sa.sa_handler;
  375. regs->er0 = (current_thread_info()->exec_domain
  376. && current_thread_info()->exec_domain->signal_invmap
  377. && sig < 32
  378. ? current_thread_info()->exec_domain->signal_invmap[sig]
  379. : sig);
  380. regs->er1 = (unsigned long)&(frame->info);
  381. regs->er2 = (unsigned long)&frame->uc;
  382. regs->er5 = current->mm->start_data; /* GOT base */
  383. return;
  384. give_sigsegv:
  385. force_sigsegv(sig, current);
  386. }
  387. /*
  388. * OK, we're invoking a handler
  389. */
  390. static void
  391. handle_signal(unsigned long sig, siginfo_t *info, struct k_sigaction *ka,
  392. sigset_t *oldset, struct pt_regs * regs)
  393. {
  394. /* are we from a system call? */
  395. if (regs->orig_er0 >= 0) {
  396. switch (regs->er0) {
  397. case -ERESTART_RESTARTBLOCK:
  398. case -ERESTARTNOHAND:
  399. regs->er0 = -EINTR;
  400. break;
  401. case -ERESTARTSYS:
  402. if (!(ka->sa.sa_flags & SA_RESTART)) {
  403. regs->er0 = -EINTR;
  404. break;
  405. }
  406. /* fallthrough */
  407. case -ERESTARTNOINTR:
  408. regs->er0 = regs->orig_er0;
  409. regs->pc -= 2;
  410. }
  411. }
  412. /* set up the stack frame */
  413. if (ka->sa.sa_flags & SA_SIGINFO)
  414. setup_rt_frame(sig, ka, info, oldset, regs);
  415. else
  416. setup_frame(sig, ka, oldset, regs);
  417. spin_lock_irq(&current->sighand->siglock);
  418. sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
  419. if (!(ka->sa.sa_flags & SA_NODEFER))
  420. sigaddset(&current->blocked,sig);
  421. recalc_sigpending();
  422. spin_unlock_irq(&current->sighand->siglock);
  423. }
  424. /*
  425. * Note that 'init' is a special process: it doesn't get signals it doesn't
  426. * want to handle. Thus you cannot kill init even with a SIGKILL even by
  427. * mistake.
  428. */
  429. asmlinkage int do_signal(struct pt_regs *regs, sigset_t *oldset)
  430. {
  431. siginfo_t info;
  432. int signr;
  433. struct k_sigaction ka;
  434. /*
  435. * We want the common case to go fast, which
  436. * is why we may in certain cases get here from
  437. * kernel mode. Just return without doing anything
  438. * if so.
  439. */
  440. if ((regs->ccr & 0x10))
  441. return 1;
  442. if (try_to_freeze())
  443. goto no_signal;
  444. current->thread.esp0 = (unsigned long) regs;
  445. if (!oldset)
  446. oldset = &current->blocked;
  447. signr = get_signal_to_deliver(&info, &ka, regs, NULL);
  448. if (signr > 0) {
  449. /* Whee! Actually deliver the signal. */
  450. handle_signal(signr, &info, &ka, oldset, regs);
  451. return 1;
  452. }
  453. no_signal:
  454. /* Did we come from a system call? */
  455. if (regs->orig_er0 >= 0) {
  456. /* Restart the system call - no handlers present */
  457. if (regs->er0 == -ERESTARTNOHAND ||
  458. regs->er0 == -ERESTARTSYS ||
  459. regs->er0 == -ERESTARTNOINTR) {
  460. regs->er0 = regs->orig_er0;
  461. regs->pc -= 2;
  462. }
  463. if (regs->er0 == -ERESTART_RESTARTBLOCK){
  464. regs->er0 = __NR_restart_syscall;
  465. regs->pc -= 2;
  466. }
  467. }
  468. return 0;
  469. }
  470. asmlinkage void do_notify_resume(struct pt_regs *regs, u32 thread_info_flags)
  471. {
  472. if (thread_info_flags & (_TIF_SIGPENDING | _TIF_RESTORE_SIGMASK))
  473. do_signal(regs, NULL);
  474. if (thread_info_flags & _TIF_NOTIFY_RESUME) {
  475. clear_thread_flag(TIF_NOTIFY_RESUME);
  476. tracehook_notify_resume(regs);
  477. if (current->replacement_session_keyring)
  478. key_replace_session_keyring();
  479. }
  480. }