diff options
author | Hiroshi Shimamoto <h-shimamoto@ct.jp.nec.com> | 2008-11-24 21:24:11 -0500 |
---|---|---|
committer | Ingo Molnar <mingo@elte.hu> | 2008-11-25 23:11:56 -0500 |
commit | 5ceb40da9bacc8b056805d72efb1a52502d56b6b (patch) | |
tree | 5c49f89e0147c0a7bb34a24112fc7df607b97840 /arch/x86/kernel/signal.c | |
parent | e5fa2d063cf2ca38eae5fb3469315db669d5c041 (diff) |
x86: signal: unify signal_{32|64}.c
Impact: cleanup
Unify signal_{32|64}.c! Mechanic unification - the two
files are the same.
Signed-off-by: Hiroshi Shimamoto <h-shimamoto@ct.jp.nec.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Diffstat (limited to 'arch/x86/kernel/signal.c')
-rw-r--r-- | arch/x86/kernel/signal.c | 915 |
1 files changed, 915 insertions, 0 deletions
diff --git a/arch/x86/kernel/signal.c b/arch/x86/kernel/signal.c new file mode 100644 index 000000000000..b1f4d34e0a38 --- /dev/null +++ b/arch/x86/kernel/signal.c | |||
@@ -0,0 +1,915 @@ | |||
1 | /* | ||
2 | * Copyright (C) 1991, 1992 Linus Torvalds | ||
3 | * Copyright (C) 2000, 2001, 2002 Andi Kleen SuSE Labs | ||
4 | * | ||
5 | * 1997-11-28 Modified for POSIX.1b signals by Richard Henderson | ||
6 | * 2000-06-20 Pentium III FXSR, SSE support by Gareth Hughes | ||
7 | * 2000-2002 x86-64 support by Andi Kleen | ||
8 | */ | ||
9 | |||
10 | #include <linux/sched.h> | ||
11 | #include <linux/mm.h> | ||
12 | #include <linux/smp.h> | ||
13 | #include <linux/kernel.h> | ||
14 | #include <linux/signal.h> | ||
15 | #include <linux/errno.h> | ||
16 | #include <linux/wait.h> | ||
17 | #include <linux/ptrace.h> | ||
18 | #include <linux/tracehook.h> | ||
19 | #include <linux/unistd.h> | ||
20 | #include <linux/stddef.h> | ||
21 | #include <linux/personality.h> | ||
22 | #include <linux/uaccess.h> | ||
23 | |||
24 | #include <asm/processor.h> | ||
25 | #include <asm/ucontext.h> | ||
26 | #include <asm/i387.h> | ||
27 | #include <asm/vdso.h> | ||
28 | |||
29 | #ifdef CONFIG_X86_64 | ||
30 | #include <asm/proto.h> | ||
31 | #include <asm/ia32_unistd.h> | ||
32 | #include <asm/mce.h> | ||
33 | #endif /* CONFIG_X86_64 */ | ||
34 | |||
35 | #include <asm/syscall.h> | ||
36 | #include <asm/syscalls.h> | ||
37 | |||
38 | #include "sigframe.h" | ||
39 | |||
40 | #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP))) | ||
41 | |||
42 | #define __FIX_EFLAGS (X86_EFLAGS_AC | X86_EFLAGS_OF | \ | ||
43 | X86_EFLAGS_DF | X86_EFLAGS_TF | X86_EFLAGS_SF | \ | ||
44 | X86_EFLAGS_ZF | X86_EFLAGS_AF | X86_EFLAGS_PF | \ | ||
45 | X86_EFLAGS_CF) | ||
46 | |||
47 | #ifdef CONFIG_X86_32 | ||
48 | # define FIX_EFLAGS (__FIX_EFLAGS | X86_EFLAGS_RF) | ||
49 | #else | ||
50 | # define FIX_EFLAGS __FIX_EFLAGS | ||
51 | #endif | ||
52 | |||
53 | #define COPY(x) { \ | ||
54 | err |= __get_user(regs->x, &sc->x); \ | ||
55 | } | ||
56 | |||
57 | #define COPY_SEG(seg) { \ | ||
58 | unsigned short tmp; \ | ||
59 | err |= __get_user(tmp, &sc->seg); \ | ||
60 | regs->seg = tmp; \ | ||
61 | } | ||
62 | |||
63 | #define COPY_SEG_CPL3(seg) { \ | ||
64 | unsigned short tmp; \ | ||
65 | err |= __get_user(tmp, &sc->seg); \ | ||
66 | regs->seg = tmp | 3; \ | ||
67 | } | ||
68 | |||
69 | #define GET_SEG(seg) { \ | ||
70 | unsigned short tmp; \ | ||
71 | err |= __get_user(tmp, &sc->seg); \ | ||
72 | loadsegment(seg, tmp); \ | ||
73 | } | ||
74 | |||
75 | static int | ||
76 | restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc, | ||
77 | unsigned long *pax) | ||
78 | { | ||
79 | void __user *buf; | ||
80 | unsigned int tmpflags; | ||
81 | unsigned int err = 0; | ||
82 | |||
83 | /* Always make any pending restarted system calls return -EINTR */ | ||
84 | current_thread_info()->restart_block.fn = do_no_restart_syscall; | ||
85 | |||
86 | #ifdef CONFIG_X86_32 | ||
87 | GET_SEG(gs); | ||
88 | COPY_SEG(fs); | ||
89 | COPY_SEG(es); | ||
90 | COPY_SEG(ds); | ||
91 | #endif /* CONFIG_X86_32 */ | ||
92 | |||
93 | COPY(di); COPY(si); COPY(bp); COPY(sp); COPY(bx); | ||
94 | COPY(dx); COPY(cx); COPY(ip); | ||
95 | |||
96 | #ifdef CONFIG_X86_64 | ||
97 | COPY(r8); | ||
98 | COPY(r9); | ||
99 | COPY(r10); | ||
100 | COPY(r11); | ||
101 | COPY(r12); | ||
102 | COPY(r13); | ||
103 | COPY(r14); | ||
104 | COPY(r15); | ||
105 | #endif /* CONFIG_X86_64 */ | ||
106 | |||
107 | #ifdef CONFIG_X86_32 | ||
108 | COPY_SEG_CPL3(cs); | ||
109 | COPY_SEG_CPL3(ss); | ||
110 | #else /* !CONFIG_X86_32 */ | ||
111 | /* Kernel saves and restores only the CS segment register on signals, | ||
112 | * which is the bare minimum needed to allow mixed 32/64-bit code. | ||
113 | * App's signal handler can save/restore other segments if needed. */ | ||
114 | COPY_SEG_CPL3(cs); | ||
115 | #endif /* CONFIG_X86_32 */ | ||
116 | |||
117 | err |= __get_user(tmpflags, &sc->flags); | ||
118 | regs->flags = (regs->flags & ~FIX_EFLAGS) | (tmpflags & FIX_EFLAGS); | ||
119 | regs->orig_ax = -1; /* disable syscall checks */ | ||
120 | |||
121 | err |= __get_user(buf, &sc->fpstate); | ||
122 | err |= restore_i387_xstate(buf); | ||
123 | |||
124 | err |= __get_user(*pax, &sc->ax); | ||
125 | return err; | ||
126 | } | ||
127 | |||
128 | static int | ||
129 | setup_sigcontext(struct sigcontext __user *sc, void __user *fpstate, | ||
130 | struct pt_regs *regs, unsigned long mask) | ||
131 | { | ||
132 | int err = 0; | ||
133 | |||
134 | #ifdef CONFIG_X86_32 | ||
135 | { | ||
136 | unsigned int tmp; | ||
137 | |||
138 | savesegment(gs, tmp); | ||
139 | err |= __put_user(tmp, (unsigned int __user *)&sc->gs); | ||
140 | } | ||
141 | err |= __put_user(regs->fs, (unsigned int __user *)&sc->fs); | ||
142 | err |= __put_user(regs->es, (unsigned int __user *)&sc->es); | ||
143 | err |= __put_user(regs->ds, (unsigned int __user *)&sc->ds); | ||
144 | #endif /* CONFIG_X86_32 */ | ||
145 | |||
146 | err |= __put_user(regs->di, &sc->di); | ||
147 | err |= __put_user(regs->si, &sc->si); | ||
148 | err |= __put_user(regs->bp, &sc->bp); | ||
149 | err |= __put_user(regs->sp, &sc->sp); | ||
150 | err |= __put_user(regs->bx, &sc->bx); | ||
151 | err |= __put_user(regs->dx, &sc->dx); | ||
152 | err |= __put_user(regs->cx, &sc->cx); | ||
153 | err |= __put_user(regs->ax, &sc->ax); | ||
154 | #ifdef CONFIG_X86_64 | ||
155 | err |= __put_user(regs->r8, &sc->r8); | ||
156 | err |= __put_user(regs->r9, &sc->r9); | ||
157 | err |= __put_user(regs->r10, &sc->r10); | ||
158 | err |= __put_user(regs->r11, &sc->r11); | ||
159 | err |= __put_user(regs->r12, &sc->r12); | ||
160 | err |= __put_user(regs->r13, &sc->r13); | ||
161 | err |= __put_user(regs->r14, &sc->r14); | ||
162 | err |= __put_user(regs->r15, &sc->r15); | ||
163 | #endif /* CONFIG_X86_64 */ | ||
164 | |||
165 | err |= __put_user(current->thread.trap_no, &sc->trapno); | ||
166 | err |= __put_user(current->thread.error_code, &sc->err); | ||
167 | err |= __put_user(regs->ip, &sc->ip); | ||
168 | #ifdef CONFIG_X86_32 | ||
169 | err |= __put_user(regs->cs, (unsigned int __user *)&sc->cs); | ||
170 | err |= __put_user(regs->flags, &sc->flags); | ||
171 | err |= __put_user(regs->sp, &sc->sp_at_signal); | ||
172 | err |= __put_user(regs->ss, (unsigned int __user *)&sc->ss); | ||
173 | #else /* !CONFIG_X86_32 */ | ||
174 | err |= __put_user(regs->flags, &sc->flags); | ||
175 | err |= __put_user(regs->cs, &sc->cs); | ||
176 | err |= __put_user(0, &sc->gs); | ||
177 | err |= __put_user(0, &sc->fs); | ||
178 | #endif /* CONFIG_X86_32 */ | ||
179 | |||
180 | err |= __put_user(fpstate, &sc->fpstate); | ||
181 | |||
182 | /* non-iBCS2 extensions.. */ | ||
183 | err |= __put_user(mask, &sc->oldmask); | ||
184 | err |= __put_user(current->thread.cr2, &sc->cr2); | ||
185 | |||
186 | return err; | ||
187 | } | ||
188 | |||
189 | /* | ||
190 | * Set up a signal frame. | ||
191 | */ | ||
192 | #ifdef CONFIG_X86_32 | ||
193 | static const struct { | ||
194 | u16 poplmovl; | ||
195 | u32 val; | ||
196 | u16 int80; | ||
197 | } __attribute__((packed)) retcode = { | ||
198 | 0xb858, /* popl %eax; movl $..., %eax */ | ||
199 | __NR_sigreturn, | ||
200 | 0x80cd, /* int $0x80 */ | ||
201 | }; | ||
202 | |||
203 | static const struct { | ||
204 | u8 movl; | ||
205 | u32 val; | ||
206 | u16 int80; | ||
207 | u8 pad; | ||
208 | } __attribute__((packed)) rt_retcode = { | ||
209 | 0xb8, /* movl $..., %eax */ | ||
210 | __NR_rt_sigreturn, | ||
211 | 0x80cd, /* int $0x80 */ | ||
212 | 0 | ||
213 | }; | ||
214 | |||
215 | /* | ||
216 | * Determine which stack to use.. | ||
217 | */ | ||
218 | static inline void __user * | ||
219 | get_sigframe(struct k_sigaction *ka, struct pt_regs *regs, size_t frame_size, | ||
220 | void **fpstate) | ||
221 | { | ||
222 | unsigned long sp; | ||
223 | |||
224 | /* Default to using normal stack */ | ||
225 | sp = regs->sp; | ||
226 | |||
227 | /* | ||
228 | * If we are on the alternate signal stack and would overflow it, don't. | ||
229 | * Return an always-bogus address instead so we will die with SIGSEGV. | ||
230 | */ | ||
231 | if (on_sig_stack(sp) && !likely(on_sig_stack(sp - frame_size))) | ||
232 | return (void __user *) -1L; | ||
233 | |||
234 | /* This is the X/Open sanctioned signal stack switching. */ | ||
235 | if (ka->sa.sa_flags & SA_ONSTACK) { | ||
236 | if (sas_ss_flags(sp) == 0) | ||
237 | sp = current->sas_ss_sp + current->sas_ss_size; | ||
238 | } else { | ||
239 | /* This is the legacy signal stack switching. */ | ||
240 | if ((regs->ss & 0xffff) != __USER_DS && | ||
241 | !(ka->sa.sa_flags & SA_RESTORER) && | ||
242 | ka->sa.sa_restorer) | ||
243 | sp = (unsigned long) ka->sa.sa_restorer; | ||
244 | } | ||
245 | |||
246 | if (used_math()) { | ||
247 | sp = sp - sig_xstate_size; | ||
248 | *fpstate = (struct _fpstate *) sp; | ||
249 | if (save_i387_xstate(*fpstate) < 0) | ||
250 | return (void __user *)-1L; | ||
251 | } | ||
252 | |||
253 | sp -= frame_size; | ||
254 | /* | ||
255 | * Align the stack pointer according to the i386 ABI, | ||
256 | * i.e. so that on function entry ((sp + 4) & 15) == 0. | ||
257 | */ | ||
258 | sp = ((sp + 4) & -16ul) - 4; | ||
259 | |||
260 | return (void __user *) sp; | ||
261 | } | ||
262 | |||
263 | static int | ||
264 | __setup_frame(int sig, struct k_sigaction *ka, sigset_t *set, | ||
265 | struct pt_regs *regs) | ||
266 | { | ||
267 | struct sigframe __user *frame; | ||
268 | void __user *restorer; | ||
269 | int err = 0; | ||
270 | void __user *fpstate = NULL; | ||
271 | |||
272 | frame = get_sigframe(ka, regs, sizeof(*frame), &fpstate); | ||
273 | |||
274 | if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame))) | ||
275 | return -EFAULT; | ||
276 | |||
277 | if (__put_user(sig, &frame->sig)) | ||
278 | return -EFAULT; | ||
279 | |||
280 | if (setup_sigcontext(&frame->sc, fpstate, regs, set->sig[0])) | ||
281 | return -EFAULT; | ||
282 | |||
283 | if (_NSIG_WORDS > 1) { | ||
284 | if (__copy_to_user(&frame->extramask, &set->sig[1], | ||
285 | sizeof(frame->extramask))) | ||
286 | return -EFAULT; | ||
287 | } | ||
288 | |||
289 | if (current->mm->context.vdso) | ||
290 | restorer = VDSO32_SYMBOL(current->mm->context.vdso, sigreturn); | ||
291 | else | ||
292 | restorer = &frame->retcode; | ||
293 | if (ka->sa.sa_flags & SA_RESTORER) | ||
294 | restorer = ka->sa.sa_restorer; | ||
295 | |||
296 | /* Set up to return from userspace. */ | ||
297 | err |= __put_user(restorer, &frame->pretcode); | ||
298 | |||
299 | /* | ||
300 | * This is popl %eax ; movl $__NR_sigreturn, %eax ; int $0x80 | ||
301 | * | ||
302 | * WE DO NOT USE IT ANY MORE! It's only left here for historical | ||
303 | * reasons and because gdb uses it as a signature to notice | ||
304 | * signal handler stack frames. | ||
305 | */ | ||
306 | err |= __put_user(*((u64 *)&retcode), (u64 *)frame->retcode); | ||
307 | |||
308 | if (err) | ||
309 | return -EFAULT; | ||
310 | |||
311 | /* Set up registers for signal handler */ | ||
312 | regs->sp = (unsigned long)frame; | ||
313 | regs->ip = (unsigned long)ka->sa.sa_handler; | ||
314 | regs->ax = (unsigned long)sig; | ||
315 | regs->dx = 0; | ||
316 | regs->cx = 0; | ||
317 | |||
318 | regs->ds = __USER_DS; | ||
319 | regs->es = __USER_DS; | ||
320 | regs->ss = __USER_DS; | ||
321 | regs->cs = __USER_CS; | ||
322 | |||
323 | return 0; | ||
324 | } | ||
325 | |||
326 | static int __setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info, | ||
327 | sigset_t *set, struct pt_regs *regs) | ||
328 | { | ||
329 | struct rt_sigframe __user *frame; | ||
330 | void __user *restorer; | ||
331 | int err = 0; | ||
332 | void __user *fpstate = NULL; | ||
333 | |||
334 | frame = get_sigframe(ka, regs, sizeof(*frame), &fpstate); | ||
335 | |||
336 | if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame))) | ||
337 | return -EFAULT; | ||
338 | |||
339 | err |= __put_user(sig, &frame->sig); | ||
340 | err |= __put_user(&frame->info, &frame->pinfo); | ||
341 | err |= __put_user(&frame->uc, &frame->puc); | ||
342 | err |= copy_siginfo_to_user(&frame->info, info); | ||
343 | if (err) | ||
344 | return -EFAULT; | ||
345 | |||
346 | /* Create the ucontext. */ | ||
347 | if (cpu_has_xsave) | ||
348 | err |= __put_user(UC_FP_XSTATE, &frame->uc.uc_flags); | ||
349 | else | ||
350 | err |= __put_user(0, &frame->uc.uc_flags); | ||
351 | err |= __put_user(0, &frame->uc.uc_link); | ||
352 | err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp); | ||
353 | err |= __put_user(sas_ss_flags(regs->sp), | ||
354 | &frame->uc.uc_stack.ss_flags); | ||
355 | err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size); | ||
356 | err |= setup_sigcontext(&frame->uc.uc_mcontext, fpstate, | ||
357 | regs, set->sig[0]); | ||
358 | err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set)); | ||
359 | if (err) | ||
360 | return -EFAULT; | ||
361 | |||
362 | /* Set up to return from userspace. */ | ||
363 | restorer = VDSO32_SYMBOL(current->mm->context.vdso, rt_sigreturn); | ||
364 | if (ka->sa.sa_flags & SA_RESTORER) | ||
365 | restorer = ka->sa.sa_restorer; | ||
366 | err |= __put_user(restorer, &frame->pretcode); | ||
367 | |||
368 | /* | ||
369 | * This is movl $__NR_rt_sigreturn, %ax ; int $0x80 | ||
370 | * | ||
371 | * WE DO NOT USE IT ANY MORE! It's only left here for historical | ||
372 | * reasons and because gdb uses it as a signature to notice | ||
373 | * signal handler stack frames. | ||
374 | */ | ||
375 | err |= __put_user(*((u64 *)&rt_retcode), (u64 *)frame->retcode); | ||
376 | |||
377 | if (err) | ||
378 | return -EFAULT; | ||
379 | |||
380 | /* Set up registers for signal handler */ | ||
381 | regs->sp = (unsigned long)frame; | ||
382 | regs->ip = (unsigned long)ka->sa.sa_handler; | ||
383 | regs->ax = (unsigned long)sig; | ||
384 | regs->dx = (unsigned long)&frame->info; | ||
385 | regs->cx = (unsigned long)&frame->uc; | ||
386 | |||
387 | regs->ds = __USER_DS; | ||
388 | regs->es = __USER_DS; | ||
389 | regs->ss = __USER_DS; | ||
390 | regs->cs = __USER_CS; | ||
391 | |||
392 | return 0; | ||
393 | } | ||
394 | #else /* !CONFIG_X86_32 */ | ||
395 | /* | ||
396 | * Determine which stack to use.. | ||
397 | */ | ||
398 | static void __user * | ||
399 | get_stack(struct k_sigaction *ka, unsigned long sp, unsigned long size) | ||
400 | { | ||
401 | /* Default to using normal stack - redzone*/ | ||
402 | sp -= 128; | ||
403 | |||
404 | /* This is the X/Open sanctioned signal stack switching. */ | ||
405 | if (ka->sa.sa_flags & SA_ONSTACK) { | ||
406 | if (sas_ss_flags(sp) == 0) | ||
407 | sp = current->sas_ss_sp + current->sas_ss_size; | ||
408 | } | ||
409 | |||
410 | return (void __user *)round_down(sp - size, 64); | ||
411 | } | ||
412 | |||
413 | static int __setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info, | ||
414 | sigset_t *set, struct pt_regs *regs) | ||
415 | { | ||
416 | struct rt_sigframe __user *frame; | ||
417 | void __user *fp = NULL; | ||
418 | int err = 0; | ||
419 | struct task_struct *me = current; | ||
420 | |||
421 | if (used_math()) { | ||
422 | fp = get_stack(ka, regs->sp, sig_xstate_size); | ||
423 | frame = (void __user *)round_down( | ||
424 | (unsigned long)fp - sizeof(struct rt_sigframe), 16) - 8; | ||
425 | |||
426 | if (save_i387_xstate(fp) < 0) | ||
427 | return -EFAULT; | ||
428 | } else | ||
429 | frame = get_stack(ka, regs->sp, sizeof(struct rt_sigframe)) - 8; | ||
430 | |||
431 | if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame))) | ||
432 | return -EFAULT; | ||
433 | |||
434 | if (ka->sa.sa_flags & SA_SIGINFO) { | ||
435 | if (copy_siginfo_to_user(&frame->info, info)) | ||
436 | return -EFAULT; | ||
437 | } | ||
438 | |||
439 | /* Create the ucontext. */ | ||
440 | if (cpu_has_xsave) | ||
441 | err |= __put_user(UC_FP_XSTATE, &frame->uc.uc_flags); | ||
442 | else | ||
443 | err |= __put_user(0, &frame->uc.uc_flags); | ||
444 | err |= __put_user(0, &frame->uc.uc_link); | ||
445 | err |= __put_user(me->sas_ss_sp, &frame->uc.uc_stack.ss_sp); | ||
446 | err |= __put_user(sas_ss_flags(regs->sp), | ||
447 | &frame->uc.uc_stack.ss_flags); | ||
448 | err |= __put_user(me->sas_ss_size, &frame->uc.uc_stack.ss_size); | ||
449 | err |= setup_sigcontext(&frame->uc.uc_mcontext, fp, regs, set->sig[0]); | ||
450 | err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set)); | ||
451 | |||
452 | /* Set up to return from userspace. If provided, use a stub | ||
453 | already in userspace. */ | ||
454 | /* x86-64 should always use SA_RESTORER. */ | ||
455 | if (ka->sa.sa_flags & SA_RESTORER) { | ||
456 | err |= __put_user(ka->sa.sa_restorer, &frame->pretcode); | ||
457 | } else { | ||
458 | /* could use a vstub here */ | ||
459 | return -EFAULT; | ||
460 | } | ||
461 | |||
462 | if (err) | ||
463 | return -EFAULT; | ||
464 | |||
465 | /* Set up registers for signal handler */ | ||
466 | regs->di = sig; | ||
467 | /* In case the signal handler was declared without prototypes */ | ||
468 | regs->ax = 0; | ||
469 | |||
470 | /* This also works for non SA_SIGINFO handlers because they expect the | ||
471 | next argument after the signal number on the stack. */ | ||
472 | regs->si = (unsigned long)&frame->info; | ||
473 | regs->dx = (unsigned long)&frame->uc; | ||
474 | regs->ip = (unsigned long) ka->sa.sa_handler; | ||
475 | |||
476 | regs->sp = (unsigned long)frame; | ||
477 | |||
478 | /* Set up the CS register to run signal handlers in 64-bit mode, | ||
479 | even if the handler happens to be interrupting 32-bit code. */ | ||
480 | regs->cs = __USER_CS; | ||
481 | |||
482 | return 0; | ||
483 | } | ||
484 | #endif /* CONFIG_X86_32 */ | ||
485 | |||
486 | #ifdef CONFIG_X86_32 | ||
487 | /* | ||
488 | * Atomically swap in the new signal mask, and wait for a signal. | ||
489 | */ | ||
490 | asmlinkage int | ||
491 | sys_sigsuspend(int history0, int history1, old_sigset_t mask) | ||
492 | { | ||
493 | mask &= _BLOCKABLE; | ||
494 | spin_lock_irq(¤t->sighand->siglock); | ||
495 | current->saved_sigmask = current->blocked; | ||
496 | siginitset(¤t->blocked, mask); | ||
497 | recalc_sigpending(); | ||
498 | spin_unlock_irq(¤t->sighand->siglock); | ||
499 | |||
500 | current->state = TASK_INTERRUPTIBLE; | ||
501 | schedule(); | ||
502 | set_restore_sigmask(); | ||
503 | |||
504 | return -ERESTARTNOHAND; | ||
505 | } | ||
506 | |||
507 | asmlinkage int | ||
508 | sys_sigaction(int sig, const struct old_sigaction __user *act, | ||
509 | struct old_sigaction __user *oact) | ||
510 | { | ||
511 | struct k_sigaction new_ka, old_ka; | ||
512 | int ret; | ||
513 | |||
514 | if (act) { | ||
515 | old_sigset_t mask; | ||
516 | |||
517 | if (!access_ok(VERIFY_READ, act, sizeof(*act)) || | ||
518 | __get_user(new_ka.sa.sa_handler, &act->sa_handler) || | ||
519 | __get_user(new_ka.sa.sa_restorer, &act->sa_restorer)) | ||
520 | return -EFAULT; | ||
521 | |||
522 | __get_user(new_ka.sa.sa_flags, &act->sa_flags); | ||
523 | __get_user(mask, &act->sa_mask); | ||
524 | siginitset(&new_ka.sa.sa_mask, mask); | ||
525 | } | ||
526 | |||
527 | ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL); | ||
528 | |||
529 | if (!ret && oact) { | ||
530 | if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) || | ||
531 | __put_user(old_ka.sa.sa_handler, &oact->sa_handler) || | ||
532 | __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer)) | ||
533 | return -EFAULT; | ||
534 | |||
535 | __put_user(old_ka.sa.sa_flags, &oact->sa_flags); | ||
536 | __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask); | ||
537 | } | ||
538 | |||
539 | return ret; | ||
540 | } | ||
541 | #endif /* CONFIG_X86_32 */ | ||
542 | |||
543 | #ifdef CONFIG_X86_32 | ||
544 | asmlinkage int sys_sigaltstack(unsigned long bx) | ||
545 | { | ||
546 | /* | ||
547 | * This is needed to make gcc realize it doesn't own the | ||
548 | * "struct pt_regs" | ||
549 | */ | ||
550 | struct pt_regs *regs = (struct pt_regs *)&bx; | ||
551 | const stack_t __user *uss = (const stack_t __user *)bx; | ||
552 | stack_t __user *uoss = (stack_t __user *)regs->cx; | ||
553 | |||
554 | return do_sigaltstack(uss, uoss, regs->sp); | ||
555 | } | ||
556 | #else /* !CONFIG_X86_32 */ | ||
557 | asmlinkage long | ||
558 | sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss, | ||
559 | struct pt_regs *regs) | ||
560 | { | ||
561 | return do_sigaltstack(uss, uoss, regs->sp); | ||
562 | } | ||
563 | #endif /* CONFIG_X86_32 */ | ||
564 | |||
565 | /* | ||
566 | * Do a signal return; undo the signal stack. | ||
567 | */ | ||
568 | #ifdef CONFIG_X86_32 | ||
569 | asmlinkage unsigned long sys_sigreturn(unsigned long __unused) | ||
570 | { | ||
571 | struct sigframe __user *frame; | ||
572 | struct pt_regs *regs; | ||
573 | unsigned long ax; | ||
574 | sigset_t set; | ||
575 | |||
576 | regs = (struct pt_regs *) &__unused; | ||
577 | frame = (struct sigframe __user *)(regs->sp - 8); | ||
578 | |||
579 | if (!access_ok(VERIFY_READ, frame, sizeof(*frame))) | ||
580 | goto badframe; | ||
581 | if (__get_user(set.sig[0], &frame->sc.oldmask) || (_NSIG_WORDS > 1 | ||
582 | && __copy_from_user(&set.sig[1], &frame->extramask, | ||
583 | sizeof(frame->extramask)))) | ||
584 | goto badframe; | ||
585 | |||
586 | sigdelsetmask(&set, ~_BLOCKABLE); | ||
587 | spin_lock_irq(¤t->sighand->siglock); | ||
588 | current->blocked = set; | ||
589 | recalc_sigpending(); | ||
590 | spin_unlock_irq(¤t->sighand->siglock); | ||
591 | |||
592 | if (restore_sigcontext(regs, &frame->sc, &ax)) | ||
593 | goto badframe; | ||
594 | return ax; | ||
595 | |||
596 | badframe: | ||
597 | if (show_unhandled_signals && printk_ratelimit()) { | ||
598 | printk("%s%s[%d] bad frame in sigreturn frame:" | ||
599 | "%p ip:%lx sp:%lx oeax:%lx", | ||
600 | task_pid_nr(current) > 1 ? KERN_INFO : KERN_EMERG, | ||
601 | current->comm, task_pid_nr(current), frame, regs->ip, | ||
602 | regs->sp, regs->orig_ax); | ||
603 | print_vma_addr(" in ", regs->ip); | ||
604 | printk(KERN_CONT "\n"); | ||
605 | } | ||
606 | |||
607 | force_sig(SIGSEGV, current); | ||
608 | |||
609 | return 0; | ||
610 | } | ||
611 | #endif /* CONFIG_X86_32 */ | ||
612 | |||
613 | static long do_rt_sigreturn(struct pt_regs *regs) | ||
614 | { | ||
615 | struct rt_sigframe __user *frame; | ||
616 | unsigned long ax; | ||
617 | sigset_t set; | ||
618 | |||
619 | frame = (struct rt_sigframe __user *)(regs->sp - sizeof(long)); | ||
620 | if (!access_ok(VERIFY_READ, frame, sizeof(*frame))) | ||
621 | goto badframe; | ||
622 | if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set))) | ||
623 | goto badframe; | ||
624 | |||
625 | sigdelsetmask(&set, ~_BLOCKABLE); | ||
626 | spin_lock_irq(¤t->sighand->siglock); | ||
627 | current->blocked = set; | ||
628 | recalc_sigpending(); | ||
629 | spin_unlock_irq(¤t->sighand->siglock); | ||
630 | |||
631 | if (restore_sigcontext(regs, &frame->uc.uc_mcontext, &ax)) | ||
632 | goto badframe; | ||
633 | |||
634 | if (do_sigaltstack(&frame->uc.uc_stack, NULL, regs->sp) == -EFAULT) | ||
635 | goto badframe; | ||
636 | |||
637 | return ax; | ||
638 | |||
639 | badframe: | ||
640 | signal_fault(regs, frame, "rt_sigreturn"); | ||
641 | return 0; | ||
642 | } | ||
643 | |||
644 | #ifdef CONFIG_X86_32 | ||
645 | asmlinkage int sys_rt_sigreturn(unsigned long __unused) | ||
646 | { | ||
647 | struct pt_regs *regs = (struct pt_regs *)&__unused; | ||
648 | |||
649 | return do_rt_sigreturn(regs); | ||
650 | } | ||
651 | #else /* !CONFIG_X86_32 */ | ||
652 | asmlinkage long sys_rt_sigreturn(struct pt_regs *regs) | ||
653 | { | ||
654 | return do_rt_sigreturn(regs); | ||
655 | } | ||
656 | #endif /* CONFIG_X86_32 */ | ||
657 | |||
658 | /* | ||
659 | * OK, we're invoking a handler: | ||
660 | */ | ||
661 | static int signr_convert(int sig) | ||
662 | { | ||
663 | #ifdef CONFIG_X86_32 | ||
664 | struct thread_info *info = current_thread_info(); | ||
665 | |||
666 | if (info->exec_domain && info->exec_domain->signal_invmap && sig < 32) | ||
667 | return info->exec_domain->signal_invmap[sig]; | ||
668 | #endif /* CONFIG_X86_32 */ | ||
669 | return sig; | ||
670 | } | ||
671 | |||
672 | #ifdef CONFIG_X86_32 | ||
673 | |||
674 | #define is_ia32 1 | ||
675 | #define ia32_setup_frame __setup_frame | ||
676 | #define ia32_setup_rt_frame __setup_rt_frame | ||
677 | |||
678 | #else /* !CONFIG_X86_32 */ | ||
679 | |||
680 | #ifdef CONFIG_IA32_EMULATION | ||
681 | #define is_ia32 test_thread_flag(TIF_IA32) | ||
682 | #else /* !CONFIG_IA32_EMULATION */ | ||
683 | #define is_ia32 0 | ||
684 | #endif /* CONFIG_IA32_EMULATION */ | ||
685 | |||
686 | #endif /* CONFIG_X86_32 */ | ||
687 | |||
688 | static int | ||
689 | setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info, | ||
690 | sigset_t *set, struct pt_regs *regs) | ||
691 | { | ||
692 | int usig = signr_convert(sig); | ||
693 | int ret; | ||
694 | |||
695 | /* Set up the stack frame */ | ||
696 | if (is_ia32) { | ||
697 | if (ka->sa.sa_flags & SA_SIGINFO) | ||
698 | ret = ia32_setup_rt_frame(usig, ka, info, set, regs); | ||
699 | else | ||
700 | ret = ia32_setup_frame(usig, ka, set, regs); | ||
701 | } else | ||
702 | ret = __setup_rt_frame(sig, ka, info, set, regs); | ||
703 | |||
704 | if (ret) { | ||
705 | force_sigsegv(sig, current); | ||
706 | return -EFAULT; | ||
707 | } | ||
708 | |||
709 | return ret; | ||
710 | } | ||
711 | |||
712 | static int | ||
713 | handle_signal(unsigned long sig, siginfo_t *info, struct k_sigaction *ka, | ||
714 | sigset_t *oldset, struct pt_regs *regs) | ||
715 | { | ||
716 | int ret; | ||
717 | |||
718 | /* Are we from a system call? */ | ||
719 | if (syscall_get_nr(current, regs) >= 0) { | ||
720 | /* If so, check system call restarting.. */ | ||
721 | switch (syscall_get_error(current, regs)) { | ||
722 | case -ERESTART_RESTARTBLOCK: | ||
723 | case -ERESTARTNOHAND: | ||
724 | regs->ax = -EINTR; | ||
725 | break; | ||
726 | |||
727 | case -ERESTARTSYS: | ||
728 | if (!(ka->sa.sa_flags & SA_RESTART)) { | ||
729 | regs->ax = -EINTR; | ||
730 | break; | ||
731 | } | ||
732 | /* fallthrough */ | ||
733 | case -ERESTARTNOINTR: | ||
734 | regs->ax = regs->orig_ax; | ||
735 | regs->ip -= 2; | ||
736 | break; | ||
737 | } | ||
738 | } | ||
739 | |||
740 | /* | ||
741 | * If TF is set due to a debugger (TIF_FORCED_TF), clear the TF | ||
742 | * flag so that register information in the sigcontext is correct. | ||
743 | */ | ||
744 | if (unlikely(regs->flags & X86_EFLAGS_TF) && | ||
745 | likely(test_and_clear_thread_flag(TIF_FORCED_TF))) | ||
746 | regs->flags &= ~X86_EFLAGS_TF; | ||
747 | |||
748 | ret = setup_rt_frame(sig, ka, info, oldset, regs); | ||
749 | |||
750 | if (ret) | ||
751 | return ret; | ||
752 | |||
753 | #ifdef CONFIG_X86_64 | ||
754 | /* | ||
755 | * This has nothing to do with segment registers, | ||
756 | * despite the name. This magic affects uaccess.h | ||
757 | * macros' behavior. Reset it to the normal setting. | ||
758 | */ | ||
759 | set_fs(USER_DS); | ||
760 | #endif | ||
761 | |||
762 | /* | ||
763 | * Clear the direction flag as per the ABI for function entry. | ||
764 | */ | ||
765 | regs->flags &= ~X86_EFLAGS_DF; | ||
766 | |||
767 | /* | ||
768 | * Clear TF when entering the signal handler, but | ||
769 | * notify any tracer that was single-stepping it. | ||
770 | * The tracer may want to single-step inside the | ||
771 | * handler too. | ||
772 | */ | ||
773 | regs->flags &= ~X86_EFLAGS_TF; | ||
774 | |||
775 | spin_lock_irq(¤t->sighand->siglock); | ||
776 | sigorsets(¤t->blocked, ¤t->blocked, &ka->sa.sa_mask); | ||
777 | if (!(ka->sa.sa_flags & SA_NODEFER)) | ||
778 | sigaddset(¤t->blocked, sig); | ||
779 | recalc_sigpending(); | ||
780 | spin_unlock_irq(¤t->sighand->siglock); | ||
781 | |||
782 | tracehook_signal_handler(sig, info, ka, regs, | ||
783 | test_thread_flag(TIF_SINGLESTEP)); | ||
784 | |||
785 | return 0; | ||
786 | } | ||
787 | |||
788 | #ifdef CONFIG_X86_32 | ||
789 | #define NR_restart_syscall __NR_restart_syscall | ||
790 | #else /* !CONFIG_X86_32 */ | ||
791 | #define NR_restart_syscall \ | ||
792 | test_thread_flag(TIF_IA32) ? __NR_ia32_restart_syscall : __NR_restart_syscall | ||
793 | #endif /* CONFIG_X86_32 */ | ||
794 | |||
795 | /* | ||
796 | * Note that 'init' is a special process: it doesn't get signals it doesn't | ||
797 | * want to handle. Thus you cannot kill init even with a SIGKILL even by | ||
798 | * mistake. | ||
799 | */ | ||
800 | static void do_signal(struct pt_regs *regs) | ||
801 | { | ||
802 | struct k_sigaction ka; | ||
803 | siginfo_t info; | ||
804 | int signr; | ||
805 | sigset_t *oldset; | ||
806 | |||
807 | /* | ||
808 | * We want the common case to go fast, which is why we may in certain | ||
809 | * cases get here from kernel mode. Just return without doing anything | ||
810 | * if so. | ||
811 | * X86_32: vm86 regs switched out by assembly code before reaching | ||
812 | * here, so testing against kernel CS suffices. | ||
813 | */ | ||
814 | if (!user_mode(regs)) | ||
815 | return; | ||
816 | |||
817 | if (current_thread_info()->status & TS_RESTORE_SIGMASK) | ||
818 | oldset = ¤t->saved_sigmask; | ||
819 | else | ||
820 | oldset = ¤t->blocked; | ||
821 | |||
822 | signr = get_signal_to_deliver(&info, &ka, regs, NULL); | ||
823 | if (signr > 0) { | ||
824 | /* | ||
825 | * Re-enable any watchpoints before delivering the | ||
826 | * signal to user space. The processor register will | ||
827 | * have been cleared if the watchpoint triggered | ||
828 | * inside the kernel. | ||
829 | */ | ||
830 | if (current->thread.debugreg7) | ||
831 | set_debugreg(current->thread.debugreg7, 7); | ||
832 | |||
833 | /* Whee! Actually deliver the signal. */ | ||
834 | if (handle_signal(signr, &info, &ka, oldset, regs) == 0) { | ||
835 | /* | ||
836 | * A signal was successfully delivered; the saved | ||
837 | * sigmask will have been stored in the signal frame, | ||
838 | * and will be restored by sigreturn, so we can simply | ||
839 | * clear the TS_RESTORE_SIGMASK flag. | ||
840 | */ | ||
841 | current_thread_info()->status &= ~TS_RESTORE_SIGMASK; | ||
842 | } | ||
843 | return; | ||
844 | } | ||
845 | |||
846 | /* Did we come from a system call? */ | ||
847 | if (syscall_get_nr(current, regs) >= 0) { | ||
848 | /* Restart the system call - no handlers present */ | ||
849 | switch (syscall_get_error(current, regs)) { | ||
850 | case -ERESTARTNOHAND: | ||
851 | case -ERESTARTSYS: | ||
852 | case -ERESTARTNOINTR: | ||
853 | regs->ax = regs->orig_ax; | ||
854 | regs->ip -= 2; | ||
855 | break; | ||
856 | |||
857 | case -ERESTART_RESTARTBLOCK: | ||
858 | regs->ax = NR_restart_syscall; | ||
859 | regs->ip -= 2; | ||
860 | break; | ||
861 | } | ||
862 | } | ||
863 | |||
864 | /* | ||
865 | * If there's no signal to deliver, we just put the saved sigmask | ||
866 | * back. | ||
867 | */ | ||
868 | if (current_thread_info()->status & TS_RESTORE_SIGMASK) { | ||
869 | current_thread_info()->status &= ~TS_RESTORE_SIGMASK; | ||
870 | sigprocmask(SIG_SETMASK, ¤t->saved_sigmask, NULL); | ||
871 | } | ||
872 | } | ||
873 | |||
874 | /* | ||
875 | * notification of userspace execution resumption | ||
876 | * - triggered by the TIF_WORK_MASK flags | ||
877 | */ | ||
878 | void | ||
879 | do_notify_resume(struct pt_regs *regs, void *unused, __u32 thread_info_flags) | ||
880 | { | ||
881 | #if defined(CONFIG_X86_64) && defined(CONFIG_X86_MCE) | ||
882 | /* notify userspace of pending MCEs */ | ||
883 | if (thread_info_flags & _TIF_MCE_NOTIFY) | ||
884 | mce_notify_user(); | ||
885 | #endif /* CONFIG_X86_64 && CONFIG_X86_MCE */ | ||
886 | |||
887 | /* deal with pending signal delivery */ | ||
888 | if (thread_info_flags & _TIF_SIGPENDING) | ||
889 | do_signal(regs); | ||
890 | |||
891 | if (thread_info_flags & _TIF_NOTIFY_RESUME) { | ||
892 | clear_thread_flag(TIF_NOTIFY_RESUME); | ||
893 | tracehook_notify_resume(regs); | ||
894 | } | ||
895 | |||
896 | #ifdef CONFIG_X86_32 | ||
897 | clear_thread_flag(TIF_IRET); | ||
898 | #endif /* CONFIG_X86_32 */ | ||
899 | } | ||
900 | |||
901 | void signal_fault(struct pt_regs *regs, void __user *frame, char *where) | ||
902 | { | ||
903 | struct task_struct *me = current; | ||
904 | |||
905 | if (show_unhandled_signals && printk_ratelimit()) { | ||
906 | printk(KERN_INFO | ||
907 | "%s[%d] bad frame in %s frame:%p ip:%lx sp:%lx orax:%lx", | ||
908 | me->comm, me->pid, where, frame, | ||
909 | regs->ip, regs->sp, regs->orig_ax); | ||
910 | print_vma_addr(" in ", regs->ip); | ||
911 | printk(KERN_CONT "\n"); | ||
912 | } | ||
913 | |||
914 | force_sig(SIGSEGV, me); | ||
915 | } | ||