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