Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
signal32.c
Go to the documentation of this file.
1 /* arch/sparc64/kernel/signal32.c
2  *
3  * Copyright (C) 1991, 1992 Linus Torvalds
4  * Copyright (C) 1995 David S. Miller ([email protected])
5  * Copyright (C) 1996 Miguel de Icaza ([email protected])
6  * Copyright (C) 1997 Eddie C. Dost ([email protected])
7  * Copyright (C) 1997,1998 Jakub Jelinek ([email protected])
8  */
9 
10 #include <linux/sched.h>
11 #include <linux/kernel.h>
12 #include <linux/signal.h>
13 #include <linux/errno.h>
14 #include <linux/wait.h>
15 #include <linux/ptrace.h>
16 #include <linux/unistd.h>
17 #include <linux/mm.h>
18 #include <linux/tty.h>
19 #include <linux/binfmts.h>
20 #include <linux/compat.h>
21 #include <linux/bitops.h>
22 #include <linux/tracehook.h>
23 
24 #include <asm/uaccess.h>
25 #include <asm/ptrace.h>
26 #include <asm/pgtable.h>
27 #include <asm/psrcompat.h>
28 #include <asm/fpumacro.h>
29 #include <asm/visasm.h>
30 #include <asm/compat_signal.h>
31 #include <asm/switch_to.h>
32 
33 #include "sigutil.h"
34 
35 /* This magic should be in g_upper[0] for all upper parts
36  * to be valid.
37  */
38 #define SIGINFO_EXTRA_V8PLUS_MAGIC 0x130e269
39 typedef struct {
40  unsigned int g_upper[8];
41  unsigned int o_upper[8];
42  unsigned int asi;
43 } siginfo_extra_v8plus_t;
44 
45 struct signal_frame32 {
46  struct sparc_stackf32 ss;
47  __siginfo32_t info;
48  /* __siginfo_fpu_t * */ u32 fpu_save;
49  unsigned int insns[2];
50  unsigned int extramask[_COMPAT_NSIG_WORDS - 1];
51  unsigned int extra_size; /* Should be sizeof(siginfo_extra_v8plus_t) */
52  /* Only valid if (info.si_regs.psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS */
53  siginfo_extra_v8plus_t v8plus;
54  /* __siginfo_rwin_t * */u32 rwin_save;
55 } __attribute__((aligned(8)));
56 
57 struct rt_signal_frame32 {
58  struct sparc_stackf32 ss;
59  compat_siginfo_t info;
60  struct pt_regs32 regs;
61  compat_sigset_t mask;
62  /* __siginfo_fpu_t * */ u32 fpu_save;
63  unsigned int insns[2];
64  stack_t32 stack;
65  unsigned int extra_size; /* Should be sizeof(siginfo_extra_v8plus_t) */
66  /* Only valid if (regs.psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS */
67  siginfo_extra_v8plus_t v8plus;
68  /* __siginfo_rwin_t * */u32 rwin_save;
69 } __attribute__((aligned(8)));
70 
71 int copy_siginfo_to_user32(compat_siginfo_t __user *to, siginfo_t *from)
72 {
73  int err;
74 
75  if (!access_ok(VERIFY_WRITE, to, sizeof(compat_siginfo_t)))
76  return -EFAULT;
77 
78  /* If you change siginfo_t structure, please be sure
79  this code is fixed accordingly.
80  It should never copy any pad contained in the structure
81  to avoid security leaks, but must copy the generic
82  3 ints plus the relevant union member.
83  This routine must convert siginfo from 64bit to 32bit as well
84  at the same time. */
85  err = __put_user(from->si_signo, &to->si_signo);
86  err |= __put_user(from->si_errno, &to->si_errno);
87  err |= __put_user((short)from->si_code, &to->si_code);
88  if (from->si_code < 0)
89  err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
90  else {
91  switch (from->si_code >> 16) {
92  case __SI_TIMER >> 16:
93  err |= __put_user(from->si_tid, &to->si_tid);
94  err |= __put_user(from->si_overrun, &to->si_overrun);
95  err |= __put_user(from->si_int, &to->si_int);
96  break;
97  case __SI_CHLD >> 16:
98  err |= __put_user(from->si_utime, &to->si_utime);
99  err |= __put_user(from->si_stime, &to->si_stime);
100  err |= __put_user(from->si_status, &to->si_status);
101  default:
102  err |= __put_user(from->si_pid, &to->si_pid);
103  err |= __put_user(from->si_uid, &to->si_uid);
104  break;
105  case __SI_FAULT >> 16:
106  err |= __put_user(from->si_trapno, &to->si_trapno);
107  err |= __put_user((unsigned long)from->si_addr, &to->si_addr);
108  break;
109  case __SI_POLL >> 16:
110  err |= __put_user(from->si_band, &to->si_band);
111  err |= __put_user(from->si_fd, &to->si_fd);
112  break;
113  case __SI_RT >> 16: /* This is not generated by the kernel as of now. */
114  case __SI_MESGQ >> 16:
115  err |= __put_user(from->si_pid, &to->si_pid);
116  err |= __put_user(from->si_uid, &to->si_uid);
117  err |= __put_user(from->si_int, &to->si_int);
118  break;
119  }
120  }
121  return err;
122 }
123 
124 /* CAUTION: This is just a very minimalist implementation for the
125  * sake of compat_sys_rt_sigqueueinfo()
126  */
127 int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from)
128 {
129  if (!access_ok(VERIFY_WRITE, from, sizeof(compat_siginfo_t)))
130  return -EFAULT;
131 
132  if (copy_from_user(to, from, 3*sizeof(int)) ||
133  copy_from_user(to->_sifields._pad, from->_sifields._pad,
134  SI_PAD_SIZE))
135  return -EFAULT;
136 
137  return 0;
138 }
139 
140 void do_sigreturn32(struct pt_regs *regs)
141 {
142  struct signal_frame32 __user *sf;
143  compat_uptr_t fpu_save;
144  compat_uptr_t rwin_save;
145  unsigned int psr;
146  unsigned pc, npc;
147  sigset_t set;
148  unsigned seta[_COMPAT_NSIG_WORDS];
149  int err, i;
150 
151  /* Always make any pending restarted system calls return -EINTR */
152  current_thread_info()->restart_block.fn = do_no_restart_syscall;
153 
154  synchronize_user_stack();
155 
156  regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
157  sf = (struct signal_frame32 __user *) regs->u_regs[UREG_FP];
158 
159  /* 1. Make sure we are not getting garbage from the user */
160  if (!access_ok(VERIFY_READ, sf, sizeof(*sf)) ||
161  (((unsigned long) sf) & 3))
162  goto segv;
163 
164  if (get_user(pc, &sf->info.si_regs.pc) ||
165  __get_user(npc, &sf->info.si_regs.npc))
166  goto segv;
167 
168  if ((pc | npc) & 3)
169  goto segv;
170 
171  if (test_thread_flag(TIF_32BIT)) {
172  pc &= 0xffffffff;
173  npc &= 0xffffffff;
174  }
175  regs->tpc = pc;
176  regs->tnpc = npc;
177 
178  /* 2. Restore the state */
179  err = __get_user(regs->y, &sf->info.si_regs.y);
180  err |= __get_user(psr, &sf->info.si_regs.psr);
181 
182  for (i = UREG_G1; i <= UREG_I7; i++)
183  err |= __get_user(regs->u_regs[i], &sf->info.si_regs.u_regs[i]);
184  if ((psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS) {
185  err |= __get_user(i, &sf->v8plus.g_upper[0]);
186  if (i == SIGINFO_EXTRA_V8PLUS_MAGIC) {
187  unsigned long asi;
188 
189  for (i = UREG_G1; i <= UREG_I7; i++)
190  err |= __get_user(((u32 *)regs->u_regs)[2*i], &sf->v8plus.g_upper[i]);
191  err |= __get_user(asi, &sf->v8plus.asi);
192  regs->tstate &= ~TSTATE_ASI;
193  regs->tstate |= ((asi & 0xffUL) << 24UL);
194  }
195  }
196 
197  /* User can only change condition codes in %tstate. */
198  regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC);
199  regs->tstate |= psr_to_tstate_icc(psr);
200 
201  /* Prevent syscall restart. */
202  pt_regs_clear_syscall(regs);
203 
204  err |= __get_user(fpu_save, &sf->fpu_save);
205  if (!err && fpu_save)
206  err |= restore_fpu_state(regs, compat_ptr(fpu_save));
207  err |= __get_user(rwin_save, &sf->rwin_save);
208  if (!err && rwin_save) {
209  if (restore_rwin_state(compat_ptr(rwin_save)))
210  goto segv;
211  }
212  err |= __get_user(seta[0], &sf->info.si_mask);
213  err |= copy_from_user(seta+1, &sf->extramask,
214  (_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int));
215  if (err)
216  goto segv;
217  switch (_NSIG_WORDS) {
218  case 4: set.sig[3] = seta[6] + (((long)seta[7]) << 32);
219  case 3: set.sig[2] = seta[4] + (((long)seta[5]) << 32);
220  case 2: set.sig[1] = seta[2] + (((long)seta[3]) << 32);
221  case 1: set.sig[0] = seta[0] + (((long)seta[1]) << 32);
222  }
223  set_current_blocked(&set);
224  return;
225 
226 segv:
227  force_sig(SIGSEGV, current);
228 }
229 
230 asmlinkage void do_rt_sigreturn32(struct pt_regs *regs)
231 {
232  struct rt_signal_frame32 __user *sf;
233  unsigned int psr, pc, npc, u_ss_sp;
234  compat_uptr_t fpu_save;
235  compat_uptr_t rwin_save;
236  mm_segment_t old_fs;
237  sigset_t set;
238  compat_sigset_t seta;
239  stack_t st;
240  int err, i;
241 
242  /* Always make any pending restarted system calls return -EINTR */
243  current_thread_info()->restart_block.fn = do_no_restart_syscall;
244 
245  synchronize_user_stack();
246  regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
247  sf = (struct rt_signal_frame32 __user *) regs->u_regs[UREG_FP];
248 
249  /* 1. Make sure we are not getting garbage from the user */
250  if (!access_ok(VERIFY_READ, sf, sizeof(*sf)) ||
251  (((unsigned long) sf) & 3))
252  goto segv;
253 
254  if (get_user(pc, &sf->regs.pc) ||
255  __get_user(npc, &sf->regs.npc))
256  goto segv;
257 
258  if ((pc | npc) & 3)
259  goto segv;
260 
261  if (test_thread_flag(TIF_32BIT)) {
262  pc &= 0xffffffff;
263  npc &= 0xffffffff;
264  }
265  regs->tpc = pc;
266  regs->tnpc = npc;
267 
268  /* 2. Restore the state */
269  err = __get_user(regs->y, &sf->regs.y);
270  err |= __get_user(psr, &sf->regs.psr);
271 
272  for (i = UREG_G1; i <= UREG_I7; i++)
273  err |= __get_user(regs->u_regs[i], &sf->regs.u_regs[i]);
274  if ((psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS) {
275  err |= __get_user(i, &sf->v8plus.g_upper[0]);
276  if (i == SIGINFO_EXTRA_V8PLUS_MAGIC) {
277  unsigned long asi;
278 
279  for (i = UREG_G1; i <= UREG_I7; i++)
280  err |= __get_user(((u32 *)regs->u_regs)[2*i], &sf->v8plus.g_upper[i]);
281  err |= __get_user(asi, &sf->v8plus.asi);
282  regs->tstate &= ~TSTATE_ASI;
283  regs->tstate |= ((asi & 0xffUL) << 24UL);
284  }
285  }
286 
287  /* User can only change condition codes in %tstate. */
288  regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC);
289  regs->tstate |= psr_to_tstate_icc(psr);
290 
291  /* Prevent syscall restart. */
292  pt_regs_clear_syscall(regs);
293 
294  err |= __get_user(fpu_save, &sf->fpu_save);
295  if (!err && fpu_save)
296  err |= restore_fpu_state(regs, compat_ptr(fpu_save));
297  err |= copy_from_user(&seta, &sf->mask, sizeof(compat_sigset_t));
298  err |= __get_user(u_ss_sp, &sf->stack.ss_sp);
299  st.ss_sp = compat_ptr(u_ss_sp);
300  err |= __get_user(st.ss_flags, &sf->stack.ss_flags);
301  err |= __get_user(st.ss_size, &sf->stack.ss_size);
302  if (err)
303  goto segv;
304 
305  /* It is more difficult to avoid calling this function than to
306  call it and ignore errors. */
307  old_fs = get_fs();
308  set_fs(KERNEL_DS);
309  do_sigaltstack((stack_t __user *) &st, NULL, (unsigned long)sf);
310  set_fs(old_fs);
311 
312  err |= __get_user(rwin_save, &sf->rwin_save);
313  if (!err && rwin_save) {
314  if (restore_rwin_state(compat_ptr(rwin_save)))
315  goto segv;
316  }
317 
318  switch (_NSIG_WORDS) {
319  case 4: set.sig[3] = seta.sig[6] + (((long)seta.sig[7]) << 32);
320  case 3: set.sig[2] = seta.sig[4] + (((long)seta.sig[5]) << 32);
321  case 2: set.sig[1] = seta.sig[2] + (((long)seta.sig[3]) << 32);
322  case 1: set.sig[0] = seta.sig[0] + (((long)seta.sig[1]) << 32);
323  }
324  set_current_blocked(&set);
325  return;
326 segv:
327  force_sig(SIGSEGV, current);
328 }
329 
330 /* Checks if the fp is valid */
331 static int invalid_frame_pointer(void __user *fp, int fplen)
332 {
333  if ((((unsigned long) fp) & 7) || ((unsigned long)fp) > 0x100000000ULL - fplen)
334  return 1;
335  return 0;
336 }
337 
338 static void __user *get_sigframe(struct sigaction *sa, struct pt_regs *regs, unsigned long framesize)
339 {
340  unsigned long sp;
341 
342  regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
343  sp = regs->u_regs[UREG_FP];
344 
345  /*
346  * If we are on the alternate signal stack and would overflow it, don't.
347  * Return an always-bogus address instead so we will die with SIGSEGV.
348  */
349  if (on_sig_stack(sp) && !likely(on_sig_stack(sp - framesize)))
350  return (void __user *) -1L;
351 
352  /* This is the X/Open sanctioned signal stack switching. */
353  if (sa->sa_flags & SA_ONSTACK) {
354  if (sas_ss_flags(sp) == 0)
355  sp = current->sas_ss_sp + current->sas_ss_size;
356  }
357 
358  sp -= framesize;
359 
360  /* Always align the stack frame. This handles two cases. First,
361  * sigaltstack need not be mindful of platform specific stack
362  * alignment. Second, if we took this signal because the stack
363  * is not aligned properly, we'd like to take the signal cleanly
364  * and report that.
365  */
366  sp &= ~15UL;
367 
368  return (void __user *) sp;
369 }
370 
371 /* The I-cache flush instruction only works in the primary ASI, which
372  * right now is the nucleus, aka. kernel space.
373  *
374  * Therefore we have to kick the instructions out using the kernel
375  * side linear mapping of the physical address backing the user
376  * instructions.
377  */
378 static void flush_signal_insns(unsigned long address)
379 {
380  unsigned long pstate, paddr;
381  pte_t *ptep, pte;
382  pgd_t *pgdp;
383  pud_t *pudp;
384  pmd_t *pmdp;
385 
386  /* Commit all stores of the instructions we are about to flush. */
387  wmb();
388 
389  /* Disable cross-call reception. In this way even a very wide
390  * munmap() on another cpu can't tear down the page table
391  * hierarchy from underneath us, since that can't complete
392  * until the IPI tlb flush returns.
393  */
394 
395  __asm__ __volatile__("rdpr %%pstate, %0" : "=r" (pstate));
396  __asm__ __volatile__("wrpr %0, %1, %%pstate"
397  : : "r" (pstate), "i" (PSTATE_IE));
398 
399  pgdp = pgd_offset(current->mm, address);
400  if (pgd_none(*pgdp))
401  goto out_irqs_on;
402  pudp = pud_offset(pgdp, address);
403  if (pud_none(*pudp))
404  goto out_irqs_on;
405  pmdp = pmd_offset(pudp, address);
406  if (pmd_none(*pmdp))
407  goto out_irqs_on;
408 
409  ptep = pte_offset_map(pmdp, address);
410  pte = *ptep;
411  if (!pte_present(pte))
412  goto out_unmap;
413 
414  paddr = (unsigned long) page_address(pte_page(pte));
415 
416  __asm__ __volatile__("flush %0 + %1"
417  : /* no outputs */
418  : "r" (paddr),
419  "r" (address & (PAGE_SIZE - 1))
420  : "memory");
421 
422 out_unmap:
423  pte_unmap(ptep);
424 out_irqs_on:
425  __asm__ __volatile__("wrpr %0, 0x0, %%pstate" : : "r" (pstate));
426 
427 }
428 
429 static int setup_frame32(struct k_sigaction *ka, struct pt_regs *regs,
430  int signo, sigset_t *oldset)
431 {
432  struct signal_frame32 __user *sf;
433  int i, err, wsaved;
434  void __user *tail;
435  int sigframe_size;
436  u32 psr;
437  unsigned int seta[_COMPAT_NSIG_WORDS];
438 
439  /* 1. Make sure everything is clean */
440  synchronize_user_stack();
441  save_and_clear_fpu();
442 
443  wsaved = get_thread_wsaved();
444 
445  sigframe_size = sizeof(*sf);
446  if (current_thread_info()->fpsaved[0] & FPRS_FEF)
447  sigframe_size += sizeof(__siginfo_fpu_t);
448  if (wsaved)
449  sigframe_size += sizeof(__siginfo_rwin_t);
450 
451  sf = (struct signal_frame32 __user *)
452  get_sigframe(&ka->sa, regs, sigframe_size);
453 
454  if (invalid_frame_pointer(sf, sigframe_size))
455  goto sigill;
456 
457  tail = (sf + 1);
458 
459  /* 2. Save the current process state */
460  if (test_thread_flag(TIF_32BIT)) {
461  regs->tpc &= 0xffffffff;
462  regs->tnpc &= 0xffffffff;
463  }
464  err = put_user(regs->tpc, &sf->info.si_regs.pc);
465  err |= __put_user(regs->tnpc, &sf->info.si_regs.npc);
466  err |= __put_user(regs->y, &sf->info.si_regs.y);
467  psr = tstate_to_psr(regs->tstate);
468  if (current_thread_info()->fpsaved[0] & FPRS_FEF)
469  psr |= PSR_EF;
470  err |= __put_user(psr, &sf->info.si_regs.psr);
471  for (i = 0; i < 16; i++)
472  err |= __put_user(regs->u_regs[i], &sf->info.si_regs.u_regs[i]);
473  err |= __put_user(sizeof(siginfo_extra_v8plus_t), &sf->extra_size);
474  err |= __put_user(SIGINFO_EXTRA_V8PLUS_MAGIC, &sf->v8plus.g_upper[0]);
475  for (i = 1; i < 16; i++)
476  err |= __put_user(((u32 *)regs->u_regs)[2*i],
477  &sf->v8plus.g_upper[i]);
478  err |= __put_user((regs->tstate & TSTATE_ASI) >> 24UL,
479  &sf->v8plus.asi);
480 
481  if (psr & PSR_EF) {
482  __siginfo_fpu_t __user *fp = tail;
483  tail += sizeof(*fp);
484  err |= save_fpu_state(regs, fp);
485  err |= __put_user((u64)fp, &sf->fpu_save);
486  } else {
487  err |= __put_user(0, &sf->fpu_save);
488  }
489  if (wsaved) {
490  __siginfo_rwin_t __user *rwp = tail;
491  tail += sizeof(*rwp);
492  err |= save_rwin_state(wsaved, rwp);
493  err |= __put_user((u64)rwp, &sf->rwin_save);
494  set_thread_wsaved(0);
495  } else {
496  err |= __put_user(0, &sf->rwin_save);
497  }
498 
499  switch (_NSIG_WORDS) {
500  case 4: seta[7] = (oldset->sig[3] >> 32);
501  seta[6] = oldset->sig[3];
502  case 3: seta[5] = (oldset->sig[2] >> 32);
503  seta[4] = oldset->sig[2];
504  case 2: seta[3] = (oldset->sig[1] >> 32);
505  seta[2] = oldset->sig[1];
506  case 1: seta[1] = (oldset->sig[0] >> 32);
507  seta[0] = oldset->sig[0];
508  }
509  err |= __put_user(seta[0], &sf->info.si_mask);
510  err |= __copy_to_user(sf->extramask, seta + 1,
511  (_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int));
512 
513  if (!wsaved) {
514  err |= copy_in_user((u32 __user *)sf,
515  (u32 __user *)(regs->u_regs[UREG_FP]),
516  sizeof(struct reg_window32));
517  } else {
518  struct reg_window *rp;
519 
520  rp = &current_thread_info()->reg_window[wsaved - 1];
521  for (i = 0; i < 8; i++)
522  err |= __put_user(rp->locals[i], &sf->ss.locals[i]);
523  for (i = 0; i < 6; i++)
524  err |= __put_user(rp->ins[i], &sf->ss.ins[i]);
525  err |= __put_user(rp->ins[6], &sf->ss.fp);
526  err |= __put_user(rp->ins[7], &sf->ss.callers_pc);
527  }
528  if (err)
529  goto sigsegv;
530 
531  /* 3. signal handler back-trampoline and parameters */
532  regs->u_regs[UREG_FP] = (unsigned long) sf;
533  regs->u_regs[UREG_I0] = signo;
534  regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
535  regs->u_regs[UREG_I2] = (unsigned long) &sf->info;
536 
537  /* 4. signal handler */
538  regs->tpc = (unsigned long) ka->sa.sa_handler;
539  regs->tnpc = (regs->tpc + 4);
540  if (test_thread_flag(TIF_32BIT)) {
541  regs->tpc &= 0xffffffff;
542  regs->tnpc &= 0xffffffff;
543  }
544 
545  /* 5. return to kernel instructions */
546  if (ka->ka_restorer) {
547  regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer;
548  } else {
549  unsigned long address = ((unsigned long)&(sf->insns[0]));
550 
551  regs->u_regs[UREG_I7] = (unsigned long) (&(sf->insns[0]) - 2);
552 
553  err = __put_user(0x821020d8, &sf->insns[0]); /*mov __NR_sigreturn, %g1*/
554  err |= __put_user(0x91d02010, &sf->insns[1]); /*t 0x10*/
555  if (err)
556  goto sigsegv;
557  flush_signal_insns(address);
558  }
559  return 0;
560 
561 sigill:
562  do_exit(SIGILL);
563  return -EINVAL;
564 
565 sigsegv:
566  force_sigsegv(signo, current);
567  return -EFAULT;
568 }
569 
570 static int setup_rt_frame32(struct k_sigaction *ka, struct pt_regs *regs,
571  unsigned long signr, sigset_t *oldset,
572  siginfo_t *info)
573 {
574  struct rt_signal_frame32 __user *sf;
575  int i, err, wsaved;
576  void __user *tail;
577  int sigframe_size;
578  u32 psr;
579  compat_sigset_t seta;
580 
581  /* 1. Make sure everything is clean */
582  synchronize_user_stack();
583  save_and_clear_fpu();
584 
585  wsaved = get_thread_wsaved();
586 
587  sigframe_size = sizeof(*sf);
588  if (current_thread_info()->fpsaved[0] & FPRS_FEF)
589  sigframe_size += sizeof(__siginfo_fpu_t);
590  if (wsaved)
591  sigframe_size += sizeof(__siginfo_rwin_t);
592 
593  sf = (struct rt_signal_frame32 __user *)
594  get_sigframe(&ka->sa, regs, sigframe_size);
595 
596  if (invalid_frame_pointer(sf, sigframe_size))
597  goto sigill;
598 
599  tail = (sf + 1);
600 
601  /* 2. Save the current process state */
602  if (test_thread_flag(TIF_32BIT)) {
603  regs->tpc &= 0xffffffff;
604  regs->tnpc &= 0xffffffff;
605  }
606  err = put_user(regs->tpc, &sf->regs.pc);
607  err |= __put_user(regs->tnpc, &sf->regs.npc);
608  err |= __put_user(regs->y, &sf->regs.y);
609  psr = tstate_to_psr(regs->tstate);
610  if (current_thread_info()->fpsaved[0] & FPRS_FEF)
611  psr |= PSR_EF;
612  err |= __put_user(psr, &sf->regs.psr);
613  for (i = 0; i < 16; i++)
614  err |= __put_user(regs->u_regs[i], &sf->regs.u_regs[i]);
615  err |= __put_user(sizeof(siginfo_extra_v8plus_t), &sf->extra_size);
616  err |= __put_user(SIGINFO_EXTRA_V8PLUS_MAGIC, &sf->v8plus.g_upper[0]);
617  for (i = 1; i < 16; i++)
618  err |= __put_user(((u32 *)regs->u_regs)[2*i],
619  &sf->v8plus.g_upper[i]);
620  err |= __put_user((regs->tstate & TSTATE_ASI) >> 24UL,
621  &sf->v8plus.asi);
622 
623  if (psr & PSR_EF) {
624  __siginfo_fpu_t __user *fp = tail;
625  tail += sizeof(*fp);
626  err |= save_fpu_state(regs, fp);
627  err |= __put_user((u64)fp, &sf->fpu_save);
628  } else {
629  err |= __put_user(0, &sf->fpu_save);
630  }
631  if (wsaved) {
632  __siginfo_rwin_t __user *rwp = tail;
633  tail += sizeof(*rwp);
634  err |= save_rwin_state(wsaved, rwp);
635  err |= __put_user((u64)rwp, &sf->rwin_save);
636  set_thread_wsaved(0);
637  } else {
638  err |= __put_user(0, &sf->rwin_save);
639  }
640 
641  /* Update the siginfo structure. */
642  err |= copy_siginfo_to_user32(&sf->info, info);
643 
644  /* Setup sigaltstack */
645  err |= __put_user(current->sas_ss_sp, &sf->stack.ss_sp);
646  err |= __put_user(sas_ss_flags(regs->u_regs[UREG_FP]), &sf->stack.ss_flags);
647  err |= __put_user(current->sas_ss_size, &sf->stack.ss_size);
648 
649  switch (_NSIG_WORDS) {
650  case 4: seta.sig[7] = (oldset->sig[3] >> 32);
651  seta.sig[6] = oldset->sig[3];
652  case 3: seta.sig[5] = (oldset->sig[2] >> 32);
653  seta.sig[4] = oldset->sig[2];
654  case 2: seta.sig[3] = (oldset->sig[1] >> 32);
655  seta.sig[2] = oldset->sig[1];
656  case 1: seta.sig[1] = (oldset->sig[0] >> 32);
657  seta.sig[0] = oldset->sig[0];
658  }
659  err |= __copy_to_user(&sf->mask, &seta, sizeof(compat_sigset_t));
660 
661  if (!wsaved) {
662  err |= copy_in_user((u32 __user *)sf,
663  (u32 __user *)(regs->u_regs[UREG_FP]),
664  sizeof(struct reg_window32));
665  } else {
666  struct reg_window *rp;
667 
668  rp = &current_thread_info()->reg_window[wsaved - 1];
669  for (i = 0; i < 8; i++)
670  err |= __put_user(rp->locals[i], &sf->ss.locals[i]);
671  for (i = 0; i < 6; i++)
672  err |= __put_user(rp->ins[i], &sf->ss.ins[i]);
673  err |= __put_user(rp->ins[6], &sf->ss.fp);
674  err |= __put_user(rp->ins[7], &sf->ss.callers_pc);
675  }
676  if (err)
677  goto sigsegv;
678 
679  /* 3. signal handler back-trampoline and parameters */
680  regs->u_regs[UREG_FP] = (unsigned long) sf;
681  regs->u_regs[UREG_I0] = signr;
682  regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
683  regs->u_regs[UREG_I2] = (unsigned long) &sf->regs;
684 
685  /* 4. signal handler */
686  regs->tpc = (unsigned long) ka->sa.sa_handler;
687  regs->tnpc = (regs->tpc + 4);
688  if (test_thread_flag(TIF_32BIT)) {
689  regs->tpc &= 0xffffffff;
690  regs->tnpc &= 0xffffffff;
691  }
692 
693  /* 5. return to kernel instructions */
694  if (ka->ka_restorer)
695  regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer;
696  else {
697  unsigned long address = ((unsigned long)&(sf->insns[0]));
698 
699  regs->u_regs[UREG_I7] = (unsigned long) (&(sf->insns[0]) - 2);
700 
701  /* mov __NR_rt_sigreturn, %g1 */
702  err |= __put_user(0x82102065, &sf->insns[0]);
703 
704  /* t 0x10 */
705  err |= __put_user(0x91d02010, &sf->insns[1]);
706  if (err)
707  goto sigsegv;
708 
709  flush_signal_insns(address);
710  }
711  return 0;
712 
713 sigill:
714  do_exit(SIGILL);
715  return -EINVAL;
716 
717 sigsegv:
718  force_sigsegv(signr, current);
719  return -EFAULT;
720 }
721 
722 static inline void handle_signal32(unsigned long signr, struct k_sigaction *ka,
723  siginfo_t *info,
724  sigset_t *oldset, struct pt_regs *regs)
725 {
726  int err;
727 
728  if (ka->sa.sa_flags & SA_SIGINFO)
729  err = setup_rt_frame32(ka, regs, signr, oldset, info);
730  else
731  err = setup_frame32(ka, regs, signr, oldset);
732 
733  if (err)
734  return;
735 
736  signal_delivered(signr, info, ka, regs, 0);
737 }
738 
739 static inline void syscall_restart32(unsigned long orig_i0, struct pt_regs *regs,
740  struct sigaction *sa)
741 {
742  switch (regs->u_regs[UREG_I0]) {
743  case ERESTART_RESTARTBLOCK:
744  case ERESTARTNOHAND:
745  no_system_call_restart:
746  regs->u_regs[UREG_I0] = EINTR;
747  regs->tstate |= TSTATE_ICARRY;
748  break;
749  case ERESTARTSYS:
750  if (!(sa->sa_flags & SA_RESTART))
751  goto no_system_call_restart;
752  /* fallthrough */
753  case ERESTARTNOINTR:
754  regs->u_regs[UREG_I0] = orig_i0;
755  regs->tpc -= 4;
756  regs->tnpc -= 4;
757  }
758 }
759 
760 /* Note that 'init' is a special process: it doesn't get signals it doesn't
761  * want to handle. Thus you cannot kill init even with a SIGKILL even by
762  * mistake.
763  */
764 void do_signal32(sigset_t *oldset, struct pt_regs * regs)
765 {
766  struct k_sigaction ka;
767  unsigned long orig_i0;
768  int restart_syscall;
769  siginfo_t info;
770  int signr;
771 
772  signr = get_signal_to_deliver(&info, &ka, regs, NULL);
773 
774  restart_syscall = 0;
775  orig_i0 = 0;
776  if (pt_regs_is_syscall(regs) &&
777  (regs->tstate & (TSTATE_XCARRY | TSTATE_ICARRY))) {
778  restart_syscall = 1;
779  orig_i0 = regs->u_regs[UREG_G6];
780  }
781 
782  if (signr > 0) {
783  if (restart_syscall)
784  syscall_restart32(orig_i0, regs, &ka.sa);
785  handle_signal32(signr, &ka, &info, oldset, regs);
786  return;
787  }
788  if (restart_syscall &&
789  (regs->u_regs[UREG_I0] == ERESTARTNOHAND ||
790  regs->u_regs[UREG_I0] == ERESTARTSYS ||
791  regs->u_regs[UREG_I0] == ERESTARTNOINTR)) {
792  /* replay the system call when we are done */
793  regs->u_regs[UREG_I0] = orig_i0;
794  regs->tpc -= 4;
795  regs->tnpc -= 4;
796  pt_regs_clear_syscall(regs);
797  }
798  if (restart_syscall &&
799  regs->u_regs[UREG_I0] == ERESTART_RESTARTBLOCK) {
800  regs->u_regs[UREG_G1] = __NR_restart_syscall;
801  regs->tpc -= 4;
802  regs->tnpc -= 4;
803  pt_regs_clear_syscall(regs);
804  }
805 
806  /* If there's no signal to deliver, we just put the saved sigmask
807  * back
808  */
809  restore_saved_sigmask();
810 }
811 
812 struct sigstack32 {
813  u32 the_stack;
814  int cur_status;
815 };
816 
817 asmlinkage int do_sys32_sigstack(u32 u_ssptr, u32 u_ossptr, unsigned long sp)
818 {
819  struct sigstack32 __user *ssptr =
820  (struct sigstack32 __user *)((unsigned long)(u_ssptr));
821  struct sigstack32 __user *ossptr =
822  (struct sigstack32 __user *)((unsigned long)(u_ossptr));
823  int ret = -EFAULT;
824 
825  /* First see if old state is wanted. */
826  if (ossptr) {
827  if (put_user(current->sas_ss_sp + current->sas_ss_size,
828  &ossptr->the_stack) ||
829  __put_user(on_sig_stack(sp), &ossptr->cur_status))
830  goto out;
831  }
832 
833  /* Now see if we want to update the new state. */
834  if (ssptr) {
835  u32 ss_sp;
836 
837  if (get_user(ss_sp, &ssptr->the_stack))
838  goto out;
839 
840  /* If the current stack was set with sigaltstack, don't
841  * swap stacks while we are on it.
842  */
843  ret = -EPERM;
844  if (current->sas_ss_sp && on_sig_stack(sp))
845  goto out;
846 
847  /* Since we don't know the extent of the stack, and we don't
848  * track onstack-ness, but rather calculate it, we must
849  * presume a size. Ho hum this interface is lossy.
850  */
851  current->sas_ss_sp = (unsigned long)ss_sp - SIGSTKSZ;
852  current->sas_ss_size = SIGSTKSZ;
853  }
854 
855  ret = 0;
856 out:
857  return ret;
858 }
859 
860 asmlinkage long do_sys32_sigaltstack(u32 ussa, u32 uossa, unsigned long sp)
861 {
862  stack_t uss, uoss;
863  u32 u_ss_sp = 0;
864  int ret;
865  mm_segment_t old_fs;
866  stack_t32 __user *uss32 = compat_ptr(ussa);
867  stack_t32 __user *uoss32 = compat_ptr(uossa);
868 
869  if (ussa && (get_user(u_ss_sp, &uss32->ss_sp) ||
870  __get_user(uss.ss_flags, &uss32->ss_flags) ||
871  __get_user(uss.ss_size, &uss32->ss_size)))
872  return -EFAULT;
873  uss.ss_sp = compat_ptr(u_ss_sp);
874  old_fs = get_fs();
875  set_fs(KERNEL_DS);
876  ret = do_sigaltstack(ussa ? (stack_t __user *) &uss : NULL,
877  uossa ? (stack_t __user *) &uoss : NULL, sp);
878  set_fs(old_fs);
879  if (!ret && uossa && (put_user(ptr_to_compat(uoss.ss_sp), &uoss32->ss_sp) ||
880  __put_user(uoss.ss_flags, &uoss32->ss_flags) ||
881  __put_user(uoss.ss_size, &uoss32->ss_size)))
882  return -EFAULT;
883  return ret;
884 }
Generated on Thu Jan 10 2013 13:03:42 for Linux Kernel by   doxygen 1.8.2