]>
Commit | Line | Data |
---|---|---|
1da177e4 | 1 | /* |
a53c8fab | 2 | * Copyright IBM Corp. 1999, 2006 |
1da177e4 LT |
3 | * Author(s): Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com) |
4 | * | |
5 | * Based on Intel version | |
6 | * | |
7 | * Copyright (C) 1991, 1992 Linus Torvalds | |
8 | * | |
9 | * 1997-11-28 Modified for POSIX.1b signals by Richard Henderson | |
10 | */ | |
11 | ||
1da177e4 LT |
12 | #include <linux/sched.h> |
13 | #include <linux/mm.h> | |
14 | #include <linux/smp.h> | |
1da177e4 LT |
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> | |
753c4dd6 | 25 | #include <linux/tracehook.h> |
26689452 | 26 | #include <linux/syscalls.h> |
7757591a | 27 | #include <linux/compat.h> |
1da177e4 LT |
28 | #include <asm/ucontext.h> |
29 | #include <asm/uaccess.h> | |
30 | #include <asm/lowcore.h> | |
a0616cde | 31 | #include <asm/switch_to.h> |
a806170e | 32 | #include "entry.h" |
1da177e4 | 33 | |
80703617 MS |
34 | /* |
35 | * Layout of an old-style signal-frame: | |
36 | * ----------------------------------------- | |
37 | * | save area (_SIGNAL_FRAMESIZE) | | |
38 | * ----------------------------------------- | |
39 | * | struct sigcontext | | |
40 | * | oldmask | | |
41 | * | _sigregs * | | |
42 | * ----------------------------------------- | |
43 | * | _sigregs with | | |
44 | * | _s390_regs_common | | |
45 | * | _s390_fp_regs | | |
46 | * ----------------------------------------- | |
47 | * | int signo | | |
48 | * ----------------------------------------- | |
49 | * | _sigregs_ext with | | |
50 | * | gprs_high 64 byte (opt) | | |
51 | * | vxrs_low 128 byte (opt) | | |
52 | * | vxrs_high 256 byte (opt) | | |
53 | * | reserved 128 byte (opt) | | |
54 | * ----------------------------------------- | |
55 | * | __u16 svc_insn | | |
56 | * ----------------------------------------- | |
57 | * The svc_insn entry with the sigreturn system call opcode does not | |
58 | * have a fixed position and moves if gprs_high or vxrs exist. | |
59 | * Future extensions will be added to _sigregs_ext. | |
60 | */ | |
61 | struct sigframe | |
1da177e4 LT |
62 | { |
63 | __u8 callee_used_stack[__SIGNAL_FRAMESIZE]; | |
64 | struct sigcontext sc; | |
65 | _sigregs sregs; | |
66 | int signo; | |
80703617 MS |
67 | _sigregs_ext sregs_ext; |
68 | __u16 svc_insn; /* Offset of svc_insn is NOT fixed! */ | |
69 | }; | |
1da177e4 | 70 | |
80703617 MS |
71 | /* |
72 | * Layout of an rt signal-frame: | |
73 | * ----------------------------------------- | |
74 | * | save area (_SIGNAL_FRAMESIZE) | | |
75 | * ----------------------------------------- | |
76 | * | svc __NR_rt_sigreturn 2 byte | | |
77 | * ----------------------------------------- | |
78 | * | struct siginfo | | |
79 | * ----------------------------------------- | |
80 | * | struct ucontext_extended with | | |
81 | * | unsigned long uc_flags | | |
82 | * | struct ucontext *uc_link | | |
83 | * | stack_t uc_stack | | |
84 | * | _sigregs uc_mcontext with | | |
85 | * | _s390_regs_common | | |
86 | * | _s390_fp_regs | | |
87 | * | sigset_t uc_sigmask | | |
88 | * | _sigregs_ext uc_mcontext_ext | | |
89 | * | gprs_high 64 byte (opt) | | |
90 | * | vxrs_low 128 byte (opt) | | |
91 | * | vxrs_high 256 byte (opt)| | |
92 | * | reserved 128 byte (opt) | | |
93 | * ----------------------------------------- | |
94 | * Future extensions will be added to _sigregs_ext. | |
95 | */ | |
96 | struct rt_sigframe | |
1da177e4 LT |
97 | { |
98 | __u8 callee_used_stack[__SIGNAL_FRAMESIZE]; | |
80703617 | 99 | __u16 svc_insn; |
1da177e4 | 100 | struct siginfo info; |
80703617 MS |
101 | struct ucontext_extended uc; |
102 | }; | |
103 | ||
104 | /* Store registers needed to create the signal frame */ | |
105 | static void store_sigregs(void) | |
106 | { | |
107 | save_access_regs(current->thread.acrs); | |
108 | save_fp_ctl(¤t->thread.fp_regs.fpc); | |
109 | #ifdef CONFIG_64BIT | |
110 | if (current->thread.vxrs) { | |
111 | int i; | |
112 | ||
113 | save_vx_regs(current->thread.vxrs); | |
114 | for (i = 0; i < __NUM_FPRS; i++) | |
115 | current->thread.fp_regs.fprs[i] = | |
116 | *(freg_t *)(current->thread.vxrs + i); | |
117 | } else | |
118 | #endif | |
119 | save_fp_regs(current->thread.fp_regs.fprs); | |
120 | } | |
121 | ||
122 | /* Load registers after signal return */ | |
123 | static void load_sigregs(void) | |
124 | { | |
125 | restore_access_regs(current->thread.acrs); | |
126 | /* restore_fp_ctl is done in restore_sigregs */ | |
127 | #ifdef CONFIG_64BIT | |
128 | if (current->thread.vxrs) { | |
129 | int i; | |
130 | ||
131 | for (i = 0; i < __NUM_FPRS; i++) | |
132 | *(freg_t *)(current->thread.vxrs + i) = | |
133 | current->thread.fp_regs.fprs[i]; | |
134 | restore_vx_regs(current->thread.vxrs); | |
135 | } else | |
136 | #endif | |
137 | restore_fp_regs(current->thread.fp_regs.fprs); | |
138 | } | |
1da177e4 | 139 | |
1da177e4 LT |
140 | /* Returns non-zero on fault. */ |
141 | static int save_sigregs(struct pt_regs *regs, _sigregs __user *sregs) | |
142 | { | |
6837a8c3 GS |
143 | _sigregs user_sregs; |
144 | ||
1da177e4 LT |
145 | /* Copy a 'clean' PSW mask to the user to avoid leaking |
146 | information about whether PER is currently on. */ | |
e258d719 | 147 | user_sregs.regs.psw.mask = PSW_USER_BITS | |
5ebf250d | 148 | (regs->psw.mask & (PSW_MASK_USER | PSW_MASK_RI)); |
b05e3703 MS |
149 | user_sregs.regs.psw.addr = regs->psw.addr; |
150 | memcpy(&user_sregs.regs.gprs, ®s->gprs, sizeof(sregs->regs.gprs)); | |
6837a8c3 | 151 | memcpy(&user_sregs.regs.acrs, current->thread.acrs, |
4725c860 | 152 | sizeof(user_sregs.regs.acrs)); |
6837a8c3 | 153 | memcpy(&user_sregs.fpregs, ¤t->thread.fp_regs, |
4725c860 | 154 | sizeof(user_sregs.fpregs)); |
f8544ec4 HC |
155 | if (__copy_to_user(sregs, &user_sregs, sizeof(_sigregs))) |
156 | return -EFAULT; | |
157 | return 0; | |
1da177e4 LT |
158 | } |
159 | ||
1da177e4 LT |
160 | static int restore_sigregs(struct pt_regs *regs, _sigregs __user *sregs) |
161 | { | |
6837a8c3 | 162 | _sigregs user_sregs; |
1da177e4 LT |
163 | |
164 | /* Alwys make any pending restarted system call return -EINTR */ | |
f56141e3 | 165 | current->restart_block.fn = do_no_restart_syscall; |
1da177e4 | 166 | |
4725c860 | 167 | if (__copy_from_user(&user_sregs, sregs, sizeof(user_sregs))) |
f8544ec4 | 168 | return -EFAULT; |
4725c860 | 169 | |
5ebf250d HC |
170 | if (!is_ri_task(current) && (user_sregs.regs.psw.mask & PSW_MASK_RI)) |
171 | return -EINVAL; | |
172 | ||
4725c860 MS |
173 | /* Loading the floating-point-control word can fail. Do that first. */ |
174 | if (restore_fp_ctl(&user_sregs.fpregs.fpc)) | |
175 | return -EINVAL; | |
176 | ||
e258d719 | 177 | /* Use regs->psw.mask instead of PSW_USER_BITS to preserve PER bit. */ |
aa7e04b3 | 178 | regs->psw.mask = (regs->psw.mask & ~(PSW_MASK_USER | PSW_MASK_RI)) | |
5ebf250d | 179 | (user_sregs.regs.psw.mask & (PSW_MASK_USER | PSW_MASK_RI)); |
fa968ee2 | 180 | /* Check for invalid user address space control. */ |
e258d719 MS |
181 | if ((regs->psw.mask & PSW_MASK_ASC) == PSW_ASC_HOME) |
182 | regs->psw.mask = PSW_ASC_PRIMARY | | |
fa968ee2 | 183 | (regs->psw.mask & ~PSW_MASK_ASC); |
d4e81b35 MS |
184 | /* Check for invalid amode */ |
185 | if (regs->psw.mask & PSW_MASK_EA) | |
186 | regs->psw.mask |= PSW_MASK_BA; | |
187 | regs->psw.addr = user_sregs.regs.psw.addr; | |
b05e3703 | 188 | memcpy(®s->gprs, &user_sregs.regs.gprs, sizeof(sregs->regs.gprs)); |
6837a8c3 | 189 | memcpy(¤t->thread.acrs, &user_sregs.regs.acrs, |
4725c860 | 190 | sizeof(current->thread.acrs)); |
1da177e4 | 191 | |
6837a8c3 | 192 | memcpy(¤t->thread.fp_regs, &user_sregs.fpregs, |
4725c860 | 193 | sizeof(current->thread.fp_regs)); |
1da177e4 | 194 | |
d3a73acb | 195 | clear_pt_regs_flag(regs, PIF_SYSCALL); /* No longer in a system call */ |
1da177e4 LT |
196 | return 0; |
197 | } | |
198 | ||
80703617 MS |
199 | /* Returns non-zero on fault. */ |
200 | static int save_sigregs_ext(struct pt_regs *regs, | |
201 | _sigregs_ext __user *sregs_ext) | |
202 | { | |
203 | #ifdef CONFIG_64BIT | |
204 | __u64 vxrs[__NUM_VXRS_LOW]; | |
205 | int i; | |
206 | ||
207 | /* Save vector registers to signal stack */ | |
208 | if (current->thread.vxrs) { | |
209 | for (i = 0; i < __NUM_VXRS_LOW; i++) | |
210 | vxrs[i] = *((__u64 *)(current->thread.vxrs + i) + 1); | |
211 | if (__copy_to_user(&sregs_ext->vxrs_low, vxrs, | |
212 | sizeof(sregs_ext->vxrs_low)) || | |
213 | __copy_to_user(&sregs_ext->vxrs_high, | |
214 | current->thread.vxrs + __NUM_VXRS_LOW, | |
215 | sizeof(sregs_ext->vxrs_high))) | |
216 | return -EFAULT; | |
217 | } | |
218 | #endif | |
219 | return 0; | |
220 | } | |
221 | ||
222 | static int restore_sigregs_ext(struct pt_regs *regs, | |
223 | _sigregs_ext __user *sregs_ext) | |
224 | { | |
225 | #ifdef CONFIG_64BIT | |
226 | __u64 vxrs[__NUM_VXRS_LOW]; | |
227 | int i; | |
228 | ||
229 | /* Restore vector registers from signal stack */ | |
230 | if (current->thread.vxrs) { | |
231 | if (__copy_from_user(vxrs, &sregs_ext->vxrs_low, | |
232 | sizeof(sregs_ext->vxrs_low)) || | |
233 | __copy_from_user(current->thread.vxrs + __NUM_VXRS_LOW, | |
234 | &sregs_ext->vxrs_high, | |
235 | sizeof(sregs_ext->vxrs_high))) | |
236 | return -EFAULT; | |
237 | for (i = 0; i < __NUM_VXRS_LOW; i++) | |
238 | *((__u64 *)(current->thread.vxrs + i) + 1) = vxrs[i]; | |
239 | } | |
240 | #endif | |
241 | return 0; | |
242 | } | |
243 | ||
26689452 | 244 | SYSCALL_DEFINE0(sigreturn) |
1da177e4 | 245 | { |
03ff9a23 | 246 | struct pt_regs *regs = task_pt_regs(current); |
80703617 MS |
247 | struct sigframe __user *frame = |
248 | (struct sigframe __user *) regs->gprs[15]; | |
1da177e4 LT |
249 | sigset_t set; |
250 | ||
1da177e4 LT |
251 | if (__copy_from_user(&set.sig, &frame->sc.oldmask, _SIGMASK_COPY_SIZE)) |
252 | goto badframe; | |
391c62fe | 253 | set_current_blocked(&set); |
1da177e4 LT |
254 | if (restore_sigregs(regs, &frame->sregs)) |
255 | goto badframe; | |
80703617 MS |
256 | if (restore_sigregs_ext(regs, &frame->sregs_ext)) |
257 | goto badframe; | |
258 | load_sigregs(); | |
1da177e4 | 259 | return regs->gprs[2]; |
1da177e4 LT |
260 | badframe: |
261 | force_sig(SIGSEGV, current); | |
262 | return 0; | |
263 | } | |
264 | ||
26689452 | 265 | SYSCALL_DEFINE0(rt_sigreturn) |
1da177e4 | 266 | { |
03ff9a23 | 267 | struct pt_regs *regs = task_pt_regs(current); |
80703617 MS |
268 | struct rt_sigframe __user *frame = |
269 | (struct rt_sigframe __user *)regs->gprs[15]; | |
1da177e4 LT |
270 | sigset_t set; |
271 | ||
1da177e4 LT |
272 | if (__copy_from_user(&set.sig, &frame->uc.uc_sigmask, sizeof(set))) |
273 | goto badframe; | |
391c62fe | 274 | set_current_blocked(&set); |
80703617 MS |
275 | if (restore_altstack(&frame->uc.uc_stack)) |
276 | goto badframe; | |
1da177e4 LT |
277 | if (restore_sigregs(regs, &frame->uc.uc_mcontext)) |
278 | goto badframe; | |
80703617 | 279 | if (restore_sigregs_ext(regs, &frame->uc.uc_mcontext_ext)) |
4e3df37e | 280 | goto badframe; |
80703617 | 281 | load_sigregs(); |
1da177e4 | 282 | return regs->gprs[2]; |
1da177e4 LT |
283 | badframe: |
284 | force_sig(SIGSEGV, current); | |
285 | return 0; | |
286 | } | |
287 | ||
1da177e4 LT |
288 | /* |
289 | * Determine which stack to use.. | |
290 | */ | |
291 | static inline void __user * | |
292 | get_sigframe(struct k_sigaction *ka, struct pt_regs * regs, size_t frame_size) | |
293 | { | |
294 | unsigned long sp; | |
295 | ||
296 | /* Default to using normal stack */ | |
297 | sp = regs->gprs[15]; | |
298 | ||
de553438 HC |
299 | /* Overflow on alternate signal stack gives SIGSEGV. */ |
300 | if (on_sig_stack(sp) && !on_sig_stack((sp - frame_size) & -8UL)) | |
301 | return (void __user *) -1UL; | |
302 | ||
1da177e4 LT |
303 | /* This is the X/Open sanctioned signal stack switching. */ |
304 | if (ka->sa.sa_flags & SA_ONSTACK) { | |
305 | if (! sas_ss_flags(sp)) | |
306 | sp = current->sas_ss_sp + current->sas_ss_size; | |
307 | } | |
308 | ||
1da177e4 LT |
309 | return (void __user *)((sp - frame_size) & -8ul); |
310 | } | |
311 | ||
312 | static inline int map_signal(int sig) | |
313 | { | |
314 | if (current_thread_info()->exec_domain | |
315 | && current_thread_info()->exec_domain->signal_invmap | |
316 | && sig < 32) | |
317 | return current_thread_info()->exec_domain->signal_invmap[sig]; | |
318 | else | |
319 | return sig; | |
320 | } | |
321 | ||
54dfe5dd HC |
322 | static int setup_frame(int sig, struct k_sigaction *ka, |
323 | sigset_t *set, struct pt_regs * regs) | |
1da177e4 | 324 | { |
80703617 MS |
325 | struct sigframe __user *frame; |
326 | struct sigcontext sc; | |
327 | unsigned long restorer; | |
328 | size_t frame_size; | |
329 | ||
330 | /* | |
331 | * gprs_high are only present for a 31-bit task running on | |
332 | * a 64-bit kernel (see compat_signal.c) but the space for | |
333 | * gprs_high need to be allocated if vector registers are | |
334 | * included in the signal frame on a 31-bit system. | |
335 | */ | |
336 | frame_size = sizeof(*frame) - sizeof(frame->sregs_ext); | |
337 | if (MACHINE_HAS_VX) | |
338 | frame_size += sizeof(frame->sregs_ext); | |
339 | frame = get_sigframe(ka, regs, frame_size); | |
de553438 | 340 | if (frame == (void __user *) -1UL) |
067bf2d4 | 341 | return -EFAULT; |
de553438 | 342 | |
80703617 MS |
343 | /* Set up backchain. */ |
344 | if (__put_user(regs->gprs[15], (addr_t __user *) frame)) | |
067bf2d4 | 345 | return -EFAULT; |
1da177e4 | 346 | |
80703617 MS |
347 | /* Create struct sigcontext on the signal stack */ |
348 | memcpy(&sc.oldmask, &set->sig, _SIGMASK_COPY_SIZE); | |
349 | sc.sregs = (_sigregs __user __force *) &frame->sregs; | |
350 | if (__copy_to_user(&frame->sc, &sc, sizeof(frame->sc))) | |
351 | return -EFAULT; | |
352 | ||
353 | /* Store registers needed to create the signal frame */ | |
354 | store_sigregs(); | |
355 | ||
356 | /* Create _sigregs on the signal stack */ | |
1da177e4 | 357 | if (save_sigregs(regs, &frame->sregs)) |
067bf2d4 | 358 | return -EFAULT; |
80703617 MS |
359 | |
360 | /* Place signal number on stack to allow backtrace from handler. */ | |
361 | if (__put_user(regs->gprs[2], (int __user *) &frame->signo)) | |
362 | return -EFAULT; | |
363 | ||
364 | /* Create _sigregs_ext on the signal stack */ | |
365 | if (save_sigregs_ext(regs, &frame->sregs_ext)) | |
067bf2d4 | 366 | return -EFAULT; |
1da177e4 LT |
367 | |
368 | /* Set up to return from userspace. If provided, use a stub | |
369 | already in userspace. */ | |
370 | if (ka->sa.sa_flags & SA_RESTORER) { | |
80703617 | 371 | restorer = (unsigned long) ka->sa.sa_restorer | PSW_ADDR_AMODE; |
1da177e4 | 372 | } else { |
80703617 | 373 | /* Signal frame without vector registers are short ! */ |
37d2cd9d | 374 | __u16 __user *svc = (void __user *) frame + frame_size - 2; |
80703617 | 375 | if (__put_user(S390_SYSCALL_OPCODE | __NR_sigreturn, svc)) |
067bf2d4 | 376 | return -EFAULT; |
80703617 | 377 | restorer = (unsigned long) svc | PSW_ADDR_AMODE; |
1da177e4 LT |
378 | } |
379 | ||
1da177e4 | 380 | /* Set up registers for signal handler */ |
80703617 | 381 | regs->gprs[14] = restorer; |
1da177e4 | 382 | regs->gprs[15] = (unsigned long) frame; |
fa968ee2 MS |
383 | /* Force default amode and default user address space control. */ |
384 | regs->psw.mask = PSW_MASK_EA | PSW_MASK_BA | | |
e258d719 | 385 | (PSW_USER_BITS & PSW_MASK_ASC) | |
fa968ee2 | 386 | (regs->psw.mask & ~PSW_MASK_ASC); |
1da177e4 LT |
387 | regs->psw.addr = (unsigned long) ka->sa.sa_handler | PSW_ADDR_AMODE; |
388 | ||
389 | regs->gprs[2] = map_signal(sig); | |
390 | regs->gprs[3] = (unsigned long) &frame->sc; | |
391 | ||
392 | /* We forgot to include these in the sigcontext. | |
393 | To avoid breaking binary compatibility, they are passed as args. */ | |
aa33c8cb MS |
394 | if (sig == SIGSEGV || sig == SIGBUS || sig == SIGILL || |
395 | sig == SIGTRAP || sig == SIGFPE) { | |
396 | /* set extra registers only for synchronous signals */ | |
397 | regs->gprs[4] = regs->int_code & 127; | |
398 | regs->gprs[5] = regs->int_parm_long; | |
399 | regs->gprs[6] = task_thread_info(current)->last_break; | |
400 | } | |
54dfe5dd | 401 | return 0; |
1da177e4 LT |
402 | } |
403 | ||
067bf2d4 RW |
404 | static int setup_rt_frame(struct ksignal *ksig, sigset_t *set, |
405 | struct pt_regs *regs) | |
1da177e4 | 406 | { |
80703617 MS |
407 | struct rt_sigframe __user *frame; |
408 | unsigned long uc_flags, restorer; | |
409 | size_t frame_size; | |
410 | ||
411 | frame_size = sizeof(struct rt_sigframe) - sizeof(_sigregs_ext); | |
412 | /* | |
413 | * gprs_high are only present for a 31-bit task running on | |
414 | * a 64-bit kernel (see compat_signal.c) but the space for | |
415 | * gprs_high need to be allocated if vector registers are | |
416 | * included in the signal frame on a 31-bit system. | |
417 | */ | |
418 | uc_flags = 0; | |
419 | #ifdef CONFIG_64BIT | |
420 | if (MACHINE_HAS_VX) { | |
421 | frame_size += sizeof(_sigregs_ext); | |
422 | if (current->thread.vxrs) | |
423 | uc_flags |= UC_VXRS; | |
424 | } | |
425 | #endif | |
426 | frame = get_sigframe(&ksig->ka, regs, frame_size); | |
de553438 | 427 | if (frame == (void __user *) -1UL) |
067bf2d4 | 428 | return -EFAULT; |
de553438 | 429 | |
80703617 MS |
430 | /* Set up backchain. */ |
431 | if (__put_user(regs->gprs[15], (addr_t __user *) frame)) | |
067bf2d4 | 432 | return -EFAULT; |
1da177e4 LT |
433 | |
434 | /* Set up to return from userspace. If provided, use a stub | |
435 | already in userspace. */ | |
067bf2d4 | 436 | if (ksig->ka.sa.sa_flags & SA_RESTORER) { |
80703617 | 437 | restorer = (unsigned long) |
067bf2d4 | 438 | ksig->ka.sa.sa_restorer | PSW_ADDR_AMODE; |
1da177e4 | 439 | } else { |
80703617 MS |
440 | __u16 __user *svc = &frame->svc_insn; |
441 | if (__put_user(S390_SYSCALL_OPCODE | __NR_rt_sigreturn, svc)) | |
067bf2d4 | 442 | return -EFAULT; |
80703617 | 443 | restorer = (unsigned long) svc | PSW_ADDR_AMODE; |
1da177e4 LT |
444 | } |
445 | ||
80703617 MS |
446 | /* Create siginfo on the signal stack */ |
447 | if (copy_siginfo_to_user(&frame->info, &ksig->info)) | |
448 | return -EFAULT; | |
449 | ||
450 | /* Store registers needed to create the signal frame */ | |
451 | store_sigregs(); | |
452 | ||
453 | /* Create ucontext on the signal stack. */ | |
454 | if (__put_user(uc_flags, &frame->uc.uc_flags) || | |
455 | __put_user(NULL, &frame->uc.uc_link) || | |
456 | __save_altstack(&frame->uc.uc_stack, regs->gprs[15]) || | |
457 | save_sigregs(regs, &frame->uc.uc_mcontext) || | |
458 | __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set)) || | |
459 | save_sigregs_ext(regs, &frame->uc.uc_mcontext_ext)) | |
067bf2d4 | 460 | return -EFAULT; |
1da177e4 LT |
461 | |
462 | /* Set up registers for signal handler */ | |
80703617 | 463 | regs->gprs[14] = restorer; |
1da177e4 | 464 | regs->gprs[15] = (unsigned long) frame; |
fa968ee2 MS |
465 | /* Force default amode and default user address space control. */ |
466 | regs->psw.mask = PSW_MASK_EA | PSW_MASK_BA | | |
e258d719 | 467 | (PSW_USER_BITS & PSW_MASK_ASC) | |
fa968ee2 | 468 | (regs->psw.mask & ~PSW_MASK_ASC); |
067bf2d4 | 469 | regs->psw.addr = (unsigned long) ksig->ka.sa.sa_handler | PSW_ADDR_AMODE; |
1da177e4 | 470 | |
067bf2d4 | 471 | regs->gprs[2] = map_signal(ksig->sig); |
1da177e4 LT |
472 | regs->gprs[3] = (unsigned long) &frame->info; |
473 | regs->gprs[4] = (unsigned long) &frame->uc; | |
86f2552b | 474 | regs->gprs[5] = task_thread_info(current)->last_break; |
54dfe5dd | 475 | return 0; |
1da177e4 LT |
476 | } |
477 | ||
067bf2d4 RW |
478 | static void handle_signal(struct ksignal *ksig, sigset_t *oldset, |
479 | struct pt_regs *regs) | |
1da177e4 | 480 | { |
54dfe5dd HC |
481 | int ret; |
482 | ||
1da177e4 | 483 | /* Set up the stack frame */ |
067bf2d4 RW |
484 | if (ksig->ka.sa.sa_flags & SA_SIGINFO) |
485 | ret = setup_rt_frame(ksig, oldset, regs); | |
1da177e4 | 486 | else |
067bf2d4 RW |
487 | ret = setup_frame(ksig->sig, &ksig->ka, oldset, regs); |
488 | ||
489 | signal_setup_done(ret, ksig, test_thread_flag(TIF_SINGLE_STEP)); | |
1da177e4 LT |
490 | } |
491 | ||
492 | /* | |
493 | * Note that 'init' is a special process: it doesn't get signals it doesn't | |
494 | * want to handle. Thus you cannot kill init even with a SIGKILL even by | |
495 | * mistake. | |
496 | * | |
497 | * Note that we go through the signals twice: once to check the signals that | |
498 | * the kernel can handle, and then we build all the user-level signal handling | |
499 | * stack-frames in one go after that. | |
500 | */ | |
54dfe5dd | 501 | void do_signal(struct pt_regs *regs) |
1da177e4 | 502 | { |
067bf2d4 | 503 | struct ksignal ksig; |
b7f9a11a | 504 | sigset_t *oldset = sigmask_to_save(); |
1da177e4 | 505 | |
20b40a79 MS |
506 | /* |
507 | * Get signal to deliver. When running under ptrace, at this point | |
508 | * the debugger may change all our registers, including the system | |
509 | * call information. | |
510 | */ | |
b6ef5bb3 | 511 | current_thread_info()->system_call = |
d3a73acb | 512 | test_pt_regs_flag(regs, PIF_SYSCALL) ? regs->int_code : 0; |
1da177e4 | 513 | |
067bf2d4 | 514 | if (get_signal(&ksig)) { |
1da177e4 | 515 | /* Whee! Actually deliver the signal. */ |
b6ef5bb3 | 516 | if (current_thread_info()->system_call) { |
aa33c8cb | 517 | regs->int_code = current_thread_info()->system_call; |
20b40a79 MS |
518 | /* Check for system call restarting. */ |
519 | switch (regs->gprs[2]) { | |
520 | case -ERESTART_RESTARTBLOCK: | |
521 | case -ERESTARTNOHAND: | |
522 | regs->gprs[2] = -EINTR; | |
523 | break; | |
524 | case -ERESTARTSYS: | |
067bf2d4 | 525 | if (!(ksig.ka.sa.sa_flags & SA_RESTART)) { |
20b40a79 MS |
526 | regs->gprs[2] = -EINTR; |
527 | break; | |
528 | } | |
529 | /* fallthrough */ | |
530 | case -ERESTARTNOINTR: | |
531 | regs->gprs[2] = regs->orig_gpr2; | |
ccf45caf MS |
532 | regs->psw.addr = |
533 | __rewind_psw(regs->psw, | |
aa33c8cb | 534 | regs->int_code >> 16); |
20b40a79 MS |
535 | break; |
536 | } | |
20b40a79 | 537 | } |
d9ae6772 | 538 | /* No longer in a system call */ |
d3a73acb | 539 | clear_pt_regs_flag(regs, PIF_SYSCALL); |
20b40a79 | 540 | |
a610d6e6 | 541 | if (is_compat_task()) |
067bf2d4 | 542 | handle_signal32(&ksig, oldset, regs); |
a610d6e6 | 543 | else |
067bf2d4 | 544 | handle_signal(&ksig, oldset, regs); |
54dfe5dd HC |
545 | return; |
546 | } | |
547 | ||
20b40a79 | 548 | /* No handlers present - check for system call restart */ |
d3a73acb | 549 | clear_pt_regs_flag(regs, PIF_SYSCALL); |
b6ef5bb3 | 550 | if (current_thread_info()->system_call) { |
aa33c8cb | 551 | regs->int_code = current_thread_info()->system_call; |
20b40a79 MS |
552 | switch (regs->gprs[2]) { |
553 | case -ERESTART_RESTARTBLOCK: | |
554 | /* Restart with sys_restart_syscall */ | |
aa33c8cb | 555 | regs->int_code = __NR_restart_syscall; |
20b40a79 MS |
556 | /* fallthrough */ |
557 | case -ERESTARTNOHAND: | |
558 | case -ERESTARTSYS: | |
559 | case -ERESTARTNOINTR: | |
560 | /* Restart system call with magic TIF bit. */ | |
561 | regs->gprs[2] = regs->orig_gpr2; | |
d3a73acb | 562 | set_pt_regs_flag(regs, PIF_SYSCALL); |
39efd4ec | 563 | if (test_thread_flag(TIF_SINGLE_STEP)) |
d3a73acb | 564 | clear_pt_regs_flag(regs, PIF_PER_TRAP); |
b6ef5bb3 | 565 | break; |
20b40a79 MS |
566 | } |
567 | } | |
568 | ||
54dfe5dd HC |
569 | /* |
570 | * If there's no signal to deliver, we just put the saved sigmask back. | |
571 | */ | |
51a7b448 | 572 | restore_saved_sigmask(); |
1da177e4 | 573 | } |
753c4dd6 MS |
574 | |
575 | void do_notify_resume(struct pt_regs *regs) | |
576 | { | |
577 | clear_thread_flag(TIF_NOTIFY_RESUME); | |
578 | tracehook_notify_resume(regs); | |
579 | } |