signal.c 30 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137
  1. /*
  2. * linux/arch/m68k/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. * Linux/m68k support by Hamish Macdonald
  12. *
  13. * 68060 fixes by Jesper Skov
  14. *
  15. * 1997-12-01 Modified for POSIX.1b signals by Andreas Schwab
  16. *
  17. * mathemu support by Roman Zippel
  18. * (Note: fpstate in the signal context is completely ignored for the emulator
  19. * and the internal floating point format is put on stack)
  20. */
  21. /*
  22. * ++roman (07/09/96): implemented signal stacks (specially for tosemu on
  23. * Atari :-) Current limitation: Only one sigstack can be active at one time.
  24. * If a second signal with SA_ONSTACK set arrives while working on a sigstack,
  25. * SA_ONSTACK is ignored. This behaviour avoids lots of trouble with nested
  26. * signal handlers!
  27. */
  28. #include <linux/sched.h>
  29. #include <linux/mm.h>
  30. #include <linux/kernel.h>
  31. #include <linux/signal.h>
  32. #include <linux/syscalls.h>
  33. #include <linux/errno.h>
  34. #include <linux/wait.h>
  35. #include <linux/ptrace.h>
  36. #include <linux/unistd.h>
  37. #include <linux/stddef.h>
  38. #include <linux/highuid.h>
  39. #include <linux/personality.h>
  40. #include <linux/tty.h>
  41. #include <linux/binfmts.h>
  42. #include <linux/extable.h>
  43. #include <linux/tracehook.h>
  44. #include <asm/setup.h>
  45. #include <linux/uaccess.h>
  46. #include <asm/traps.h>
  47. #include <asm/ucontext.h>
  48. #include <asm/cacheflush.h>
  49. #ifdef CONFIG_MMU
  50. /*
  51. * Handle the slight differences in classic 68k and ColdFire trap frames.
  52. */
  53. #ifdef CONFIG_COLDFIRE
  54. #define FORMAT 4
  55. #define FMT4SIZE 0
  56. #else
  57. #define FORMAT 0
  58. #define FMT4SIZE sizeof_field(struct frame, un.fmt4)
  59. #endif
  60. static const int frame_size_change[16] = {
  61. [1] = -1, /* sizeof_field(struct frame, un.fmt1), */
  62. [2] = sizeof_field(struct frame, un.fmt2),
  63. [3] = sizeof_field(struct frame, un.fmt3),
  64. [4] = FMT4SIZE,
  65. [5] = -1, /* sizeof_field(struct frame, un.fmt5), */
  66. [6] = -1, /* sizeof_field(struct frame, un.fmt6), */
  67. [7] = sizeof_field(struct frame, un.fmt7),
  68. [8] = -1, /* sizeof_field(struct frame, un.fmt8), */
  69. [9] = sizeof_field(struct frame, un.fmt9),
  70. [10] = sizeof_field(struct frame, un.fmta),
  71. [11] = sizeof_field(struct frame, un.fmtb),
  72. [12] = -1, /* sizeof_field(struct frame, un.fmtc), */
  73. [13] = -1, /* sizeof_field(struct frame, un.fmtd), */
  74. [14] = -1, /* sizeof_field(struct frame, un.fmte), */
  75. [15] = -1, /* sizeof_field(struct frame, un.fmtf), */
  76. };
  77. static inline int frame_extra_sizes(int f)
  78. {
  79. return frame_size_change[f];
  80. }
  81. int fixup_exception(struct pt_regs *regs)
  82. {
  83. const struct exception_table_entry *fixup;
  84. struct pt_regs *tregs;
  85. /* Are we prepared to handle this kernel fault? */
  86. fixup = search_exception_tables(regs->pc);
  87. if (!fixup)
  88. return 0;
  89. /* Create a new four word stack frame, discarding the old one. */
  90. regs->stkadj = frame_extra_sizes(regs->format);
  91. tregs = (struct pt_regs *)((long)regs + regs->stkadj);
  92. tregs->vector = regs->vector;
  93. tregs->format = FORMAT;
  94. tregs->pc = fixup->fixup;
  95. tregs->sr = regs->sr;
  96. return 1;
  97. }
  98. static inline void push_cache (unsigned long vaddr)
  99. {
  100. /*
  101. * Using the old cache_push_v() was really a big waste.
  102. *
  103. * What we are trying to do is to flush 8 bytes to ram.
  104. * Flushing 2 cache lines of 16 bytes is much cheaper than
  105. * flushing 1 or 2 pages, as previously done in
  106. * cache_push_v().
  107. * Jes
  108. */
  109. if (CPU_IS_040) {
  110. unsigned long temp;
  111. __asm__ __volatile__ (".chip 68040\n\t"
  112. "nop\n\t"
  113. "ptestr (%1)\n\t"
  114. "movec %%mmusr,%0\n\t"
  115. ".chip 68k"
  116. : "=r" (temp)
  117. : "a" (vaddr));
  118. temp &= PAGE_MASK;
  119. temp |= vaddr & ~PAGE_MASK;
  120. __asm__ __volatile__ (".chip 68040\n\t"
  121. "nop\n\t"
  122. "cpushl %%bc,(%0)\n\t"
  123. ".chip 68k"
  124. : : "a" (temp));
  125. }
  126. else if (CPU_IS_060) {
  127. unsigned long temp;
  128. __asm__ __volatile__ (".chip 68060\n\t"
  129. "plpar (%0)\n\t"
  130. ".chip 68k"
  131. : "=a" (temp)
  132. : "0" (vaddr));
  133. __asm__ __volatile__ (".chip 68060\n\t"
  134. "cpushl %%bc,(%0)\n\t"
  135. ".chip 68k"
  136. : : "a" (temp));
  137. } else if (!CPU_IS_COLDFIRE) {
  138. /*
  139. * 68030/68020 have no writeback cache;
  140. * still need to clear icache.
  141. * Note that vaddr is guaranteed to be long word aligned.
  142. */
  143. unsigned long temp;
  144. asm volatile ("movec %%cacr,%0" : "=r" (temp));
  145. temp += 4;
  146. asm volatile ("movec %0,%%caar\n\t"
  147. "movec %1,%%cacr"
  148. : : "r" (vaddr), "r" (temp));
  149. asm volatile ("movec %0,%%caar\n\t"
  150. "movec %1,%%cacr"
  151. : : "r" (vaddr + 4), "r" (temp));
  152. } else {
  153. /* CPU_IS_COLDFIRE */
  154. #if defined(CONFIG_CACHE_COPYBACK)
  155. flush_cf_dcache(0, DCACHE_MAX_ADDR);
  156. #endif
  157. /* Invalidate instruction cache for the pushed bytes */
  158. clear_cf_icache(vaddr, vaddr + 8);
  159. }
  160. }
  161. static inline void adjustformat(struct pt_regs *regs)
  162. {
  163. }
  164. static inline void save_a5_state(struct sigcontext *sc, struct pt_regs *regs)
  165. {
  166. }
  167. #else /* CONFIG_MMU */
  168. void ret_from_user_signal(void);
  169. void ret_from_user_rt_signal(void);
  170. static inline int frame_extra_sizes(int f)
  171. {
  172. /* No frame size adjustments required on non-MMU CPUs */
  173. return 0;
  174. }
  175. static inline void adjustformat(struct pt_regs *regs)
  176. {
  177. /*
  178. * set format byte to make stack appear modulo 4, which it will
  179. * be when doing the rte
  180. */
  181. regs->format = 0x4;
  182. }
  183. static inline void save_a5_state(struct sigcontext *sc, struct pt_regs *regs)
  184. {
  185. sc->sc_a5 = ((struct switch_stack *)regs - 1)->a5;
  186. }
  187. static inline void push_cache(unsigned long vaddr)
  188. {
  189. }
  190. #endif /* CONFIG_MMU */
  191. /*
  192. * Do a signal return; undo the signal stack.
  193. *
  194. * Keep the return code on the stack quadword aligned!
  195. * That makes the cache flush below easier.
  196. */
  197. struct sigframe
  198. {
  199. char __user *pretcode;
  200. int sig;
  201. int code;
  202. struct sigcontext __user *psc;
  203. char retcode[8];
  204. unsigned long extramask[_NSIG_WORDS-1];
  205. struct sigcontext sc;
  206. };
  207. struct rt_sigframe
  208. {
  209. char __user *pretcode;
  210. int sig;
  211. struct siginfo __user *pinfo;
  212. void __user *puc;
  213. char retcode[8];
  214. struct siginfo info;
  215. struct ucontext uc;
  216. };
  217. #define FPCONTEXT_SIZE 216
  218. #define uc_fpstate uc_filler[0]
  219. #define uc_formatvec uc_filler[FPCONTEXT_SIZE/4]
  220. #define uc_extra uc_filler[FPCONTEXT_SIZE/4+1]
  221. #ifdef CONFIG_FPU
  222. static unsigned char fpu_version; /* version number of fpu, set by setup_frame */
  223. static inline int restore_fpu_state(struct sigcontext *sc)
  224. {
  225. int err = 1;
  226. if (FPU_IS_EMU) {
  227. /* restore registers */
  228. memcpy(current->thread.fpcntl, sc->sc_fpcntl, 12);
  229. memcpy(current->thread.fp, sc->sc_fpregs, 24);
  230. return 0;
  231. }
  232. if (CPU_IS_060 ? sc->sc_fpstate[2] : sc->sc_fpstate[0]) {
  233. /* Verify the frame format. */
  234. if (!(CPU_IS_060 || CPU_IS_COLDFIRE) &&
  235. (sc->sc_fpstate[0] != fpu_version))
  236. goto out;
  237. if (CPU_IS_020_OR_030) {
  238. if (m68k_fputype & FPU_68881 &&
  239. !(sc->sc_fpstate[1] == 0x18 || sc->sc_fpstate[1] == 0xb4))
  240. goto out;
  241. if (m68k_fputype & FPU_68882 &&
  242. !(sc->sc_fpstate[1] == 0x38 || sc->sc_fpstate[1] == 0xd4))
  243. goto out;
  244. } else if (CPU_IS_040) {
  245. if (!(sc->sc_fpstate[1] == 0x00 ||
  246. sc->sc_fpstate[1] == 0x28 ||
  247. sc->sc_fpstate[1] == 0x60))
  248. goto out;
  249. } else if (CPU_IS_060) {
  250. if (!(sc->sc_fpstate[3] == 0x00 ||
  251. sc->sc_fpstate[3] == 0x60 ||
  252. sc->sc_fpstate[3] == 0xe0))
  253. goto out;
  254. } else if (CPU_IS_COLDFIRE) {
  255. if (!(sc->sc_fpstate[0] == 0x00 ||
  256. sc->sc_fpstate[0] == 0x05 ||
  257. sc->sc_fpstate[0] == 0xe5))
  258. goto out;
  259. } else
  260. goto out;
  261. if (CPU_IS_COLDFIRE) {
  262. __asm__ volatile ("fmovemd %0,%%fp0-%%fp1\n\t"
  263. "fmovel %1,%%fpcr\n\t"
  264. "fmovel %2,%%fpsr\n\t"
  265. "fmovel %3,%%fpiar"
  266. : /* no outputs */
  267. : "m" (sc->sc_fpregs[0]),
  268. "m" (sc->sc_fpcntl[0]),
  269. "m" (sc->sc_fpcntl[1]),
  270. "m" (sc->sc_fpcntl[2]));
  271. } else {
  272. __asm__ volatile (".chip 68k/68881\n\t"
  273. "fmovemx %0,%%fp0-%%fp1\n\t"
  274. "fmoveml %1,%%fpcr/%%fpsr/%%fpiar\n\t"
  275. ".chip 68k"
  276. : /* no outputs */
  277. : "m" (*sc->sc_fpregs),
  278. "m" (*sc->sc_fpcntl));
  279. }
  280. }
  281. if (CPU_IS_COLDFIRE) {
  282. __asm__ volatile ("frestore %0" : : "m" (*sc->sc_fpstate));
  283. } else {
  284. __asm__ volatile (".chip 68k/68881\n\t"
  285. "frestore %0\n\t"
  286. ".chip 68k"
  287. : : "m" (*sc->sc_fpstate));
  288. }
  289. err = 0;
  290. out:
  291. return err;
  292. }
  293. static inline int rt_restore_fpu_state(struct ucontext __user *uc)
  294. {
  295. unsigned char fpstate[FPCONTEXT_SIZE];
  296. int context_size = CPU_IS_060 ? 8 : (CPU_IS_COLDFIRE ? 12 : 0);
  297. fpregset_t fpregs;
  298. int err = 1;
  299. if (FPU_IS_EMU) {
  300. /* restore fpu control register */
  301. if (__copy_from_user(current->thread.fpcntl,
  302. uc->uc_mcontext.fpregs.f_fpcntl, 12))
  303. goto out;
  304. /* restore all other fpu register */
  305. if (__copy_from_user(current->thread.fp,
  306. uc->uc_mcontext.fpregs.f_fpregs, 96))
  307. goto out;
  308. return 0;
  309. }
  310. if (__get_user(*(long *)fpstate, (long __user *)&uc->uc_fpstate))
  311. goto out;
  312. if (CPU_IS_060 ? fpstate[2] : fpstate[0]) {
  313. if (!(CPU_IS_060 || CPU_IS_COLDFIRE))
  314. context_size = fpstate[1];
  315. /* Verify the frame format. */
  316. if (!(CPU_IS_060 || CPU_IS_COLDFIRE) &&
  317. (fpstate[0] != fpu_version))
  318. goto out;
  319. if (CPU_IS_020_OR_030) {
  320. if (m68k_fputype & FPU_68881 &&
  321. !(context_size == 0x18 || context_size == 0xb4))
  322. goto out;
  323. if (m68k_fputype & FPU_68882 &&
  324. !(context_size == 0x38 || context_size == 0xd4))
  325. goto out;
  326. } else if (CPU_IS_040) {
  327. if (!(context_size == 0x00 ||
  328. context_size == 0x28 ||
  329. context_size == 0x60))
  330. goto out;
  331. } else if (CPU_IS_060) {
  332. if (!(fpstate[3] == 0x00 ||
  333. fpstate[3] == 0x60 ||
  334. fpstate[3] == 0xe0))
  335. goto out;
  336. } else if (CPU_IS_COLDFIRE) {
  337. if (!(fpstate[3] == 0x00 ||
  338. fpstate[3] == 0x05 ||
  339. fpstate[3] == 0xe5))
  340. goto out;
  341. } else
  342. goto out;
  343. if (__copy_from_user(&fpregs, &uc->uc_mcontext.fpregs,
  344. sizeof(fpregs)))
  345. goto out;
  346. if (CPU_IS_COLDFIRE) {
  347. __asm__ volatile ("fmovemd %0,%%fp0-%%fp7\n\t"
  348. "fmovel %1,%%fpcr\n\t"
  349. "fmovel %2,%%fpsr\n\t"
  350. "fmovel %3,%%fpiar"
  351. : /* no outputs */
  352. : "m" (fpregs.f_fpregs[0]),
  353. "m" (fpregs.f_fpcntl[0]),
  354. "m" (fpregs.f_fpcntl[1]),
  355. "m" (fpregs.f_fpcntl[2]));
  356. } else {
  357. __asm__ volatile (".chip 68k/68881\n\t"
  358. "fmovemx %0,%%fp0-%%fp7\n\t"
  359. "fmoveml %1,%%fpcr/%%fpsr/%%fpiar\n\t"
  360. ".chip 68k"
  361. : /* no outputs */
  362. : "m" (*fpregs.f_fpregs),
  363. "m" (*fpregs.f_fpcntl));
  364. }
  365. }
  366. if (context_size &&
  367. __copy_from_user(fpstate + 4, (long __user *)&uc->uc_fpstate + 1,
  368. context_size))
  369. goto out;
  370. if (CPU_IS_COLDFIRE) {
  371. __asm__ volatile ("frestore %0" : : "m" (*fpstate));
  372. } else {
  373. __asm__ volatile (".chip 68k/68881\n\t"
  374. "frestore %0\n\t"
  375. ".chip 68k"
  376. : : "m" (*fpstate));
  377. }
  378. err = 0;
  379. out:
  380. return err;
  381. }
  382. /*
  383. * Set up a signal frame.
  384. */
  385. static inline void save_fpu_state(struct sigcontext *sc, struct pt_regs *regs)
  386. {
  387. if (FPU_IS_EMU) {
  388. /* save registers */
  389. memcpy(sc->sc_fpcntl, current->thread.fpcntl, 12);
  390. memcpy(sc->sc_fpregs, current->thread.fp, 24);
  391. return;
  392. }
  393. if (CPU_IS_COLDFIRE) {
  394. __asm__ volatile ("fsave %0"
  395. : : "m" (*sc->sc_fpstate) : "memory");
  396. } else {
  397. __asm__ volatile (".chip 68k/68881\n\t"
  398. "fsave %0\n\t"
  399. ".chip 68k"
  400. : : "m" (*sc->sc_fpstate) : "memory");
  401. }
  402. if (CPU_IS_060 ? sc->sc_fpstate[2] : sc->sc_fpstate[0]) {
  403. fpu_version = sc->sc_fpstate[0];
  404. if (CPU_IS_020_OR_030 && !regs->stkadj &&
  405. regs->vector >= (VEC_FPBRUC * 4) &&
  406. regs->vector <= (VEC_FPNAN * 4)) {
  407. /* Clear pending exception in 68882 idle frame */
  408. if (*(unsigned short *) sc->sc_fpstate == 0x1f38)
  409. sc->sc_fpstate[0x38] |= 1 << 3;
  410. }
  411. if (CPU_IS_COLDFIRE) {
  412. __asm__ volatile ("fmovemd %%fp0-%%fp1,%0\n\t"
  413. "fmovel %%fpcr,%1\n\t"
  414. "fmovel %%fpsr,%2\n\t"
  415. "fmovel %%fpiar,%3"
  416. : "=m" (sc->sc_fpregs[0]),
  417. "=m" (sc->sc_fpcntl[0]),
  418. "=m" (sc->sc_fpcntl[1]),
  419. "=m" (sc->sc_fpcntl[2])
  420. : /* no inputs */
  421. : "memory");
  422. } else {
  423. __asm__ volatile (".chip 68k/68881\n\t"
  424. "fmovemx %%fp0-%%fp1,%0\n\t"
  425. "fmoveml %%fpcr/%%fpsr/%%fpiar,%1\n\t"
  426. ".chip 68k"
  427. : "=m" (*sc->sc_fpregs),
  428. "=m" (*sc->sc_fpcntl)
  429. : /* no inputs */
  430. : "memory");
  431. }
  432. }
  433. }
  434. static inline int rt_save_fpu_state(struct ucontext __user *uc, struct pt_regs *regs)
  435. {
  436. unsigned char fpstate[FPCONTEXT_SIZE];
  437. int context_size = CPU_IS_060 ? 8 : (CPU_IS_COLDFIRE ? 12 : 0);
  438. int err = 0;
  439. if (FPU_IS_EMU) {
  440. /* save fpu control register */
  441. err |= copy_to_user(uc->uc_mcontext.fpregs.f_fpcntl,
  442. current->thread.fpcntl, 12);
  443. /* save all other fpu register */
  444. err |= copy_to_user(uc->uc_mcontext.fpregs.f_fpregs,
  445. current->thread.fp, 96);
  446. return err;
  447. }
  448. if (CPU_IS_COLDFIRE) {
  449. __asm__ volatile ("fsave %0" : : "m" (*fpstate) : "memory");
  450. } else {
  451. __asm__ volatile (".chip 68k/68881\n\t"
  452. "fsave %0\n\t"
  453. ".chip 68k"
  454. : : "m" (*fpstate) : "memory");
  455. }
  456. err |= __put_user(*(long *)fpstate, (long __user *)&uc->uc_fpstate);
  457. if (CPU_IS_060 ? fpstate[2] : fpstate[0]) {
  458. fpregset_t fpregs;
  459. if (!(CPU_IS_060 || CPU_IS_COLDFIRE))
  460. context_size = fpstate[1];
  461. fpu_version = fpstate[0];
  462. if (CPU_IS_020_OR_030 && !regs->stkadj &&
  463. regs->vector >= (VEC_FPBRUC * 4) &&
  464. regs->vector <= (VEC_FPNAN * 4)) {
  465. /* Clear pending exception in 68882 idle frame */
  466. if (*(unsigned short *) fpstate == 0x1f38)
  467. fpstate[0x38] |= 1 << 3;
  468. }
  469. if (CPU_IS_COLDFIRE) {
  470. __asm__ volatile ("fmovemd %%fp0-%%fp7,%0\n\t"
  471. "fmovel %%fpcr,%1\n\t"
  472. "fmovel %%fpsr,%2\n\t"
  473. "fmovel %%fpiar,%3"
  474. : "=m" (fpregs.f_fpregs[0]),
  475. "=m" (fpregs.f_fpcntl[0]),
  476. "=m" (fpregs.f_fpcntl[1]),
  477. "=m" (fpregs.f_fpcntl[2])
  478. : /* no inputs */
  479. : "memory");
  480. } else {
  481. __asm__ volatile (".chip 68k/68881\n\t"
  482. "fmovemx %%fp0-%%fp7,%0\n\t"
  483. "fmoveml %%fpcr/%%fpsr/%%fpiar,%1\n\t"
  484. ".chip 68k"
  485. : "=m" (*fpregs.f_fpregs),
  486. "=m" (*fpregs.f_fpcntl)
  487. : /* no inputs */
  488. : "memory");
  489. }
  490. err |= copy_to_user(&uc->uc_mcontext.fpregs, &fpregs,
  491. sizeof(fpregs));
  492. }
  493. if (context_size)
  494. err |= copy_to_user((long __user *)&uc->uc_fpstate + 1, fpstate + 4,
  495. context_size);
  496. return err;
  497. }
  498. #else /* CONFIG_FPU */
  499. /*
  500. * For the case with no FPU configured these all do nothing.
  501. */
  502. static inline int restore_fpu_state(struct sigcontext *sc)
  503. {
  504. return 0;
  505. }
  506. static inline int rt_restore_fpu_state(struct ucontext __user *uc)
  507. {
  508. return 0;
  509. }
  510. static inline void save_fpu_state(struct sigcontext *sc, struct pt_regs *regs)
  511. {
  512. }
  513. static inline int rt_save_fpu_state(struct ucontext __user *uc, struct pt_regs *regs)
  514. {
  515. return 0;
  516. }
  517. #endif /* CONFIG_FPU */
  518. static inline void siginfo_build_tests(void)
  519. {
  520. /*
  521. * This needs to be tested on m68k as it has a lesser
  522. * alignment requirement than x86 and that can cause surprises.
  523. */
  524. /* This is part of the ABI and can never change in size: */
  525. BUILD_BUG_ON(sizeof(siginfo_t) != 128);
  526. /* Ensure the known fields never change in location */
  527. BUILD_BUG_ON(offsetof(siginfo_t, si_signo) != 0);
  528. BUILD_BUG_ON(offsetof(siginfo_t, si_errno) != 4);
  529. BUILD_BUG_ON(offsetof(siginfo_t, si_code) != 8);
  530. /* _kill */
  531. BUILD_BUG_ON(offsetof(siginfo_t, si_pid) != 0x0c);
  532. BUILD_BUG_ON(offsetof(siginfo_t, si_uid) != 0x10);
  533. /* _timer */
  534. BUILD_BUG_ON(offsetof(siginfo_t, si_tid) != 0x0c);
  535. BUILD_BUG_ON(offsetof(siginfo_t, si_overrun) != 0x10);
  536. BUILD_BUG_ON(offsetof(siginfo_t, si_value) != 0x14);
  537. /* _rt */
  538. BUILD_BUG_ON(offsetof(siginfo_t, si_pid) != 0x0c);
  539. BUILD_BUG_ON(offsetof(siginfo_t, si_uid) != 0x10);
  540. BUILD_BUG_ON(offsetof(siginfo_t, si_value) != 0x14);
  541. /* _sigchld */
  542. BUILD_BUG_ON(offsetof(siginfo_t, si_pid) != 0x0c);
  543. BUILD_BUG_ON(offsetof(siginfo_t, si_uid) != 0x10);
  544. BUILD_BUG_ON(offsetof(siginfo_t, si_status) != 0x14);
  545. BUILD_BUG_ON(offsetof(siginfo_t, si_utime) != 0x18);
  546. BUILD_BUG_ON(offsetof(siginfo_t, si_stime) != 0x1c);
  547. /* _sigfault */
  548. BUILD_BUG_ON(offsetof(siginfo_t, si_addr) != 0x0c);
  549. /* _sigfault._mcerr */
  550. BUILD_BUG_ON(offsetof(siginfo_t, si_addr_lsb) != 0x10);
  551. /* _sigfault._addr_bnd */
  552. BUILD_BUG_ON(offsetof(siginfo_t, si_lower) != 0x12);
  553. BUILD_BUG_ON(offsetof(siginfo_t, si_upper) != 0x16);
  554. /* _sigfault._addr_pkey */
  555. BUILD_BUG_ON(offsetof(siginfo_t, si_pkey) != 0x12);
  556. /* _sigpoll */
  557. BUILD_BUG_ON(offsetof(siginfo_t, si_band) != 0x0c);
  558. BUILD_BUG_ON(offsetof(siginfo_t, si_fd) != 0x10);
  559. /* _sigsys */
  560. BUILD_BUG_ON(offsetof(siginfo_t, si_call_addr) != 0x0c);
  561. BUILD_BUG_ON(offsetof(siginfo_t, si_syscall) != 0x10);
  562. BUILD_BUG_ON(offsetof(siginfo_t, si_arch) != 0x14);
  563. /* any new si_fields should be added here */
  564. }
  565. static int mangle_kernel_stack(struct pt_regs *regs, int formatvec,
  566. void __user *fp)
  567. {
  568. int fsize = frame_extra_sizes(formatvec >> 12);
  569. if (fsize < 0) {
  570. /*
  571. * user process trying to return with weird frame format
  572. */
  573. pr_debug("user process returning with weird frame format\n");
  574. return 1;
  575. }
  576. if (!fsize) {
  577. regs->format = formatvec >> 12;
  578. regs->vector = formatvec & 0xfff;
  579. } else {
  580. struct switch_stack *sw = (struct switch_stack *)regs - 1;
  581. /* yes, twice as much as max(sizeof(frame.un.fmt<x>)) */
  582. unsigned long buf[sizeof_field(struct frame, un) / 2];
  583. /* that'll make sure that expansion won't crap over data */
  584. if (copy_from_user(buf + fsize / 4, fp, fsize))
  585. return 1;
  586. /* point of no return */
  587. regs->format = formatvec >> 12;
  588. regs->vector = formatvec & 0xfff;
  589. #define frame_offset (sizeof(struct pt_regs)+sizeof(struct switch_stack))
  590. __asm__ __volatile__ (
  591. #ifdef CONFIG_COLDFIRE
  592. " movel %0,%/sp\n\t"
  593. " bra ret_from_signal\n"
  594. #else
  595. " movel %0,%/a0\n\t"
  596. " subl %1,%/a0\n\t" /* make room on stack */
  597. " movel %/a0,%/sp\n\t" /* set stack pointer */
  598. /* move switch_stack and pt_regs */
  599. "1: movel %0@+,%/a0@+\n\t"
  600. " dbra %2,1b\n\t"
  601. " lea %/sp@(%c3),%/a0\n\t" /* add offset of fmt */
  602. " lsrl #2,%1\n\t"
  603. " subql #1,%1\n\t"
  604. /* copy to the gap we'd made */
  605. "2: movel %4@+,%/a0@+\n\t"
  606. " dbra %1,2b\n\t"
  607. " bral ret_from_signal\n"
  608. #endif
  609. : /* no outputs, it doesn't ever return */
  610. : "a" (sw), "d" (fsize), "d" (frame_offset/4-1),
  611. "n" (frame_offset), "a" (buf + fsize/4)
  612. : "a0");
  613. #undef frame_offset
  614. }
  615. return 0;
  616. }
  617. static inline int
  618. restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *usc, void __user *fp)
  619. {
  620. int formatvec;
  621. struct sigcontext context;
  622. int err = 0;
  623. siginfo_build_tests();
  624. /* Always make any pending restarted system calls return -EINTR */
  625. current->restart_block.fn = do_no_restart_syscall;
  626. /* get previous context */
  627. if (copy_from_user(&context, usc, sizeof(context)))
  628. goto badframe;
  629. /* restore passed registers */
  630. regs->d0 = context.sc_d0;
  631. regs->d1 = context.sc_d1;
  632. regs->a0 = context.sc_a0;
  633. regs->a1 = context.sc_a1;
  634. regs->sr = (regs->sr & 0xff00) | (context.sc_sr & 0xff);
  635. regs->pc = context.sc_pc;
  636. regs->orig_d0 = -1; /* disable syscall checks */
  637. wrusp(context.sc_usp);
  638. formatvec = context.sc_formatvec;
  639. err = restore_fpu_state(&context);
  640. if (err || mangle_kernel_stack(regs, formatvec, fp))
  641. goto badframe;
  642. return 0;
  643. badframe:
  644. return 1;
  645. }
  646. static inline int
  647. rt_restore_ucontext(struct pt_regs *regs, struct switch_stack *sw,
  648. struct ucontext __user *uc)
  649. {
  650. int temp;
  651. greg_t __user *gregs = uc->uc_mcontext.gregs;
  652. unsigned long usp;
  653. int err;
  654. /* Always make any pending restarted system calls return -EINTR */
  655. current->restart_block.fn = do_no_restart_syscall;
  656. err = __get_user(temp, &uc->uc_mcontext.version);
  657. if (temp != MCONTEXT_VERSION)
  658. goto badframe;
  659. /* restore passed registers */
  660. err |= __get_user(regs->d0, &gregs[0]);
  661. err |= __get_user(regs->d1, &gregs[1]);
  662. err |= __get_user(regs->d2, &gregs[2]);
  663. err |= __get_user(regs->d3, &gregs[3]);
  664. err |= __get_user(regs->d4, &gregs[4]);
  665. err |= __get_user(regs->d5, &gregs[5]);
  666. err |= __get_user(sw->d6, &gregs[6]);
  667. err |= __get_user(sw->d7, &gregs[7]);
  668. err |= __get_user(regs->a0, &gregs[8]);
  669. err |= __get_user(regs->a1, &gregs[9]);
  670. err |= __get_user(regs->a2, &gregs[10]);
  671. err |= __get_user(sw->a3, &gregs[11]);
  672. err |= __get_user(sw->a4, &gregs[12]);
  673. err |= __get_user(sw->a5, &gregs[13]);
  674. err |= __get_user(sw->a6, &gregs[14]);
  675. err |= __get_user(usp, &gregs[15]);
  676. wrusp(usp);
  677. err |= __get_user(regs->pc, &gregs[16]);
  678. err |= __get_user(temp, &gregs[17]);
  679. regs->sr = (regs->sr & 0xff00) | (temp & 0xff);
  680. regs->orig_d0 = -1; /* disable syscall checks */
  681. err |= __get_user(temp, &uc->uc_formatvec);
  682. err |= rt_restore_fpu_state(uc);
  683. err |= restore_altstack(&uc->uc_stack);
  684. if (err)
  685. goto badframe;
  686. if (mangle_kernel_stack(regs, temp, &uc->uc_extra))
  687. goto badframe;
  688. return 0;
  689. badframe:
  690. return 1;
  691. }
  692. asmlinkage int do_sigreturn(struct pt_regs *regs, struct switch_stack *sw)
  693. {
  694. unsigned long usp = rdusp();
  695. struct sigframe __user *frame = (struct sigframe __user *)(usp - 4);
  696. sigset_t set;
  697. if (!access_ok(frame, sizeof(*frame)))
  698. goto badframe;
  699. if (__get_user(set.sig[0], &frame->sc.sc_mask) ||
  700. (_NSIG_WORDS > 1 &&
  701. __copy_from_user(&set.sig[1], &frame->extramask,
  702. sizeof(frame->extramask))))
  703. goto badframe;
  704. set_current_blocked(&set);
  705. if (restore_sigcontext(regs, &frame->sc, frame + 1))
  706. goto badframe;
  707. return regs->d0;
  708. badframe:
  709. force_sig(SIGSEGV);
  710. return 0;
  711. }
  712. asmlinkage int do_rt_sigreturn(struct pt_regs *regs, struct switch_stack *sw)
  713. {
  714. unsigned long usp = rdusp();
  715. struct rt_sigframe __user *frame = (struct rt_sigframe __user *)(usp - 4);
  716. sigset_t set;
  717. if (!access_ok(frame, sizeof(*frame)))
  718. goto badframe;
  719. if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
  720. goto badframe;
  721. set_current_blocked(&set);
  722. if (rt_restore_ucontext(regs, sw, &frame->uc))
  723. goto badframe;
  724. return regs->d0;
  725. badframe:
  726. force_sig(SIGSEGV);
  727. return 0;
  728. }
  729. static inline struct pt_regs *rte_regs(struct pt_regs *regs)
  730. {
  731. return (void *)regs + regs->stkadj;
  732. }
  733. static void setup_sigcontext(struct sigcontext *sc, struct pt_regs *regs,
  734. unsigned long mask)
  735. {
  736. struct pt_regs *tregs = rte_regs(regs);
  737. sc->sc_mask = mask;
  738. sc->sc_usp = rdusp();
  739. sc->sc_d0 = regs->d0;
  740. sc->sc_d1 = regs->d1;
  741. sc->sc_a0 = regs->a0;
  742. sc->sc_a1 = regs->a1;
  743. sc->sc_sr = tregs->sr;
  744. sc->sc_pc = tregs->pc;
  745. sc->sc_formatvec = tregs->format << 12 | tregs->vector;
  746. save_a5_state(sc, regs);
  747. save_fpu_state(sc, regs);
  748. }
  749. static inline int rt_setup_ucontext(struct ucontext __user *uc, struct pt_regs *regs)
  750. {
  751. struct switch_stack *sw = (struct switch_stack *)regs - 1;
  752. struct pt_regs *tregs = rte_regs(regs);
  753. greg_t __user *gregs = uc->uc_mcontext.gregs;
  754. int err = 0;
  755. err |= __put_user(MCONTEXT_VERSION, &uc->uc_mcontext.version);
  756. err |= __put_user(regs->d0, &gregs[0]);
  757. err |= __put_user(regs->d1, &gregs[1]);
  758. err |= __put_user(regs->d2, &gregs[2]);
  759. err |= __put_user(regs->d3, &gregs[3]);
  760. err |= __put_user(regs->d4, &gregs[4]);
  761. err |= __put_user(regs->d5, &gregs[5]);
  762. err |= __put_user(sw->d6, &gregs[6]);
  763. err |= __put_user(sw->d7, &gregs[7]);
  764. err |= __put_user(regs->a0, &gregs[8]);
  765. err |= __put_user(regs->a1, &gregs[9]);
  766. err |= __put_user(regs->a2, &gregs[10]);
  767. err |= __put_user(sw->a3, &gregs[11]);
  768. err |= __put_user(sw->a4, &gregs[12]);
  769. err |= __put_user(sw->a5, &gregs[13]);
  770. err |= __put_user(sw->a6, &gregs[14]);
  771. err |= __put_user(rdusp(), &gregs[15]);
  772. err |= __put_user(tregs->pc, &gregs[16]);
  773. err |= __put_user(tregs->sr, &gregs[17]);
  774. err |= __put_user((tregs->format << 12) | tregs->vector, &uc->uc_formatvec);
  775. err |= rt_save_fpu_state(uc, regs);
  776. return err;
  777. }
  778. static inline void __user *
  779. get_sigframe(struct ksignal *ksig, size_t frame_size)
  780. {
  781. unsigned long usp = sigsp(rdusp(), ksig);
  782. return (void __user *)((usp - frame_size) & -8UL);
  783. }
  784. static int setup_frame(struct ksignal *ksig, sigset_t *set,
  785. struct pt_regs *regs)
  786. {
  787. struct sigframe __user *frame;
  788. struct pt_regs *tregs = rte_regs(regs);
  789. int fsize = frame_extra_sizes(tregs->format);
  790. struct sigcontext context;
  791. int err = 0, sig = ksig->sig;
  792. if (fsize < 0) {
  793. pr_debug("setup_frame: Unknown frame format %#x\n",
  794. tregs->format);
  795. return -EFAULT;
  796. }
  797. frame = get_sigframe(ksig, sizeof(*frame) + fsize);
  798. if (fsize)
  799. err |= copy_to_user (frame + 1, regs + 1, fsize);
  800. err |= __put_user(sig, &frame->sig);
  801. err |= __put_user(tregs->vector, &frame->code);
  802. err |= __put_user(&frame->sc, &frame->psc);
  803. if (_NSIG_WORDS > 1)
  804. err |= copy_to_user(frame->extramask, &set->sig[1],
  805. sizeof(frame->extramask));
  806. setup_sigcontext(&context, regs, set->sig[0]);
  807. err |= copy_to_user (&frame->sc, &context, sizeof(context));
  808. /* Set up to return from userspace. */
  809. #ifdef CONFIG_MMU
  810. err |= __put_user(frame->retcode, &frame->pretcode);
  811. /* moveq #,d0; trap #0 */
  812. err |= __put_user(0x70004e40 + (__NR_sigreturn << 16),
  813. (long __user *)(frame->retcode));
  814. #else
  815. err |= __put_user((long) ret_from_user_signal,
  816. (long __user *) &frame->pretcode);
  817. #endif
  818. if (err)
  819. return -EFAULT;
  820. push_cache ((unsigned long) &frame->retcode);
  821. /*
  822. * This is subtle; if we build more than one sigframe, all but the
  823. * first one will see frame format 0 and have fsize == 0, so we won't
  824. * screw stkadj.
  825. */
  826. if (fsize) {
  827. regs->stkadj = fsize;
  828. tregs = rte_regs(regs);
  829. pr_debug("Performing stackadjust=%04lx\n", regs->stkadj);
  830. tregs->vector = 0;
  831. tregs->format = 0;
  832. tregs->sr = regs->sr;
  833. }
  834. /*
  835. * Set up registers for signal handler. All the state we are about
  836. * to destroy is successfully copied to sigframe.
  837. */
  838. wrusp ((unsigned long) frame);
  839. tregs->pc = (unsigned long) ksig->ka.sa.sa_handler;
  840. adjustformat(regs);
  841. return 0;
  842. }
  843. static int setup_rt_frame(struct ksignal *ksig, sigset_t *set,
  844. struct pt_regs *regs)
  845. {
  846. struct rt_sigframe __user *frame;
  847. struct pt_regs *tregs = rte_regs(regs);
  848. int fsize = frame_extra_sizes(tregs->format);
  849. int err = 0, sig = ksig->sig;
  850. if (fsize < 0) {
  851. pr_debug("setup_frame: Unknown frame format %#x\n",
  852. regs->format);
  853. return -EFAULT;
  854. }
  855. frame = get_sigframe(ksig, sizeof(*frame));
  856. if (fsize)
  857. err |= copy_to_user (&frame->uc.uc_extra, regs + 1, fsize);
  858. err |= __put_user(sig, &frame->sig);
  859. err |= __put_user(&frame->info, &frame->pinfo);
  860. err |= __put_user(&frame->uc, &frame->puc);
  861. err |= copy_siginfo_to_user(&frame->info, &ksig->info);
  862. /* Create the ucontext. */
  863. err |= __put_user(0, &frame->uc.uc_flags);
  864. err |= __put_user(NULL, &frame->uc.uc_link);
  865. err |= __save_altstack(&frame->uc.uc_stack, rdusp());
  866. err |= rt_setup_ucontext(&frame->uc, regs);
  867. err |= copy_to_user (&frame->uc.uc_sigmask, set, sizeof(*set));
  868. /* Set up to return from userspace. */
  869. #ifdef CONFIG_MMU
  870. err |= __put_user(frame->retcode, &frame->pretcode);
  871. #ifdef __mcoldfire__
  872. /* movel #__NR_rt_sigreturn,d0; trap #0 */
  873. err |= __put_user(0x203c0000, (long __user *)(frame->retcode + 0));
  874. err |= __put_user(0x00004e40 + (__NR_rt_sigreturn << 16),
  875. (long __user *)(frame->retcode + 4));
  876. #else
  877. /* moveq #,d0; notb d0; trap #0 */
  878. err |= __put_user(0x70004600 + ((__NR_rt_sigreturn ^ 0xff) << 16),
  879. (long __user *)(frame->retcode + 0));
  880. err |= __put_user(0x4e40, (short __user *)(frame->retcode + 4));
  881. #endif
  882. #else
  883. err |= __put_user((long) ret_from_user_rt_signal,
  884. (long __user *) &frame->pretcode);
  885. #endif /* CONFIG_MMU */
  886. if (err)
  887. return -EFAULT;
  888. push_cache ((unsigned long) &frame->retcode);
  889. /*
  890. * This is subtle; if we build more than one sigframe, all but the
  891. * first one will see frame format 0 and have fsize == 0, so we won't
  892. * screw stkadj.
  893. */
  894. if (fsize) {
  895. regs->stkadj = fsize;
  896. tregs = rte_regs(regs);
  897. pr_debug("Performing stackadjust=%04lx\n", regs->stkadj);
  898. tregs->vector = 0;
  899. tregs->format = 0;
  900. tregs->sr = regs->sr;
  901. }
  902. /*
  903. * Set up registers for signal handler. All the state we are about
  904. * to destroy is successfully copied to sigframe.
  905. */
  906. wrusp ((unsigned long) frame);
  907. tregs->pc = (unsigned long) ksig->ka.sa.sa_handler;
  908. adjustformat(regs);
  909. return 0;
  910. }
  911. static inline void
  912. handle_restart(struct pt_regs *regs, struct k_sigaction *ka, int has_handler)
  913. {
  914. switch (regs->d0) {
  915. case -ERESTARTNOHAND:
  916. if (!has_handler)
  917. goto do_restart;
  918. regs->d0 = -EINTR;
  919. break;
  920. case -ERESTART_RESTARTBLOCK:
  921. if (!has_handler) {
  922. regs->d0 = __NR_restart_syscall;
  923. regs->pc -= 2;
  924. break;
  925. }
  926. regs->d0 = -EINTR;
  927. break;
  928. case -ERESTARTSYS:
  929. if (has_handler && !(ka->sa.sa_flags & SA_RESTART)) {
  930. regs->d0 = -EINTR;
  931. break;
  932. }
  933. fallthrough;
  934. case -ERESTARTNOINTR:
  935. do_restart:
  936. regs->d0 = regs->orig_d0;
  937. regs->pc -= 2;
  938. break;
  939. }
  940. }
  941. /*
  942. * OK, we're invoking a handler
  943. */
  944. static void
  945. handle_signal(struct ksignal *ksig, struct pt_regs *regs)
  946. {
  947. sigset_t *oldset = sigmask_to_save();
  948. int err;
  949. /* are we from a system call? */
  950. if (regs->orig_d0 >= 0)
  951. /* If so, check system call restarting.. */
  952. handle_restart(regs, &ksig->ka, 1);
  953. /* set up the stack frame */
  954. if (ksig->ka.sa.sa_flags & SA_SIGINFO)
  955. err = setup_rt_frame(ksig, oldset, regs);
  956. else
  957. err = setup_frame(ksig, oldset, regs);
  958. signal_setup_done(err, ksig, 0);
  959. if (test_thread_flag(TIF_DELAYED_TRACE)) {
  960. regs->sr &= ~0x8000;
  961. send_sig(SIGTRAP, current, 1);
  962. }
  963. }
  964. /*
  965. * Note that 'init' is a special process: it doesn't get signals it doesn't
  966. * want to handle. Thus you cannot kill init even with a SIGKILL even by
  967. * mistake.
  968. */
  969. static void do_signal(struct pt_regs *regs)
  970. {
  971. struct ksignal ksig;
  972. current->thread.esp0 = (unsigned long) regs;
  973. if (get_signal(&ksig)) {
  974. /* Whee! Actually deliver the signal. */
  975. handle_signal(&ksig, regs);
  976. return;
  977. }
  978. /* Did we come from a system call? */
  979. if (regs->orig_d0 >= 0)
  980. /* Restart the system call - no handlers present */
  981. handle_restart(regs, NULL, 0);
  982. /* If there's no signal to deliver, we just restore the saved mask. */
  983. restore_saved_sigmask();
  984. }
  985. void do_notify_resume(struct pt_regs *regs)
  986. {
  987. if (test_thread_flag(TIF_SIGPENDING))
  988. do_signal(regs);
  989. if (test_thread_flag(TIF_NOTIFY_RESUME))
  990. tracehook_notify_resume(regs);
  991. }