Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * linux/arch/x86_64/ia32/ia32_signal.c | |
3 | * | |
4 | * Copyright (C) 1991, 1992 Linus Torvalds | |
5 | * | |
6 | * 1997-11-28 Modified for POSIX.1b signals by Richard Henderson | |
7 | * 2000-06-20 Pentium III FXSR, SSE support by Gareth Hughes | |
8 | * 2000-12-* x86-64 compatibility mode signal handling by Andi Kleen | |
1da177e4 LT |
9 | */ |
10 | ||
11 | #include <linux/sched.h> | |
12 | #include <linux/mm.h> | |
13 | #include <linux/smp.h> | |
14 | #include <linux/smp_lock.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/personality.h> | |
23 | #include <linux/compat.h> | |
24 | #include <asm/ucontext.h> | |
25 | #include <asm/uaccess.h> | |
26 | #include <asm/i387.h> | |
27 | #include <asm/ia32.h> | |
28 | #include <asm/ptrace.h> | |
29 | #include <asm/ia32_unistd.h> | |
30 | #include <asm/user32.h> | |
31 | #include <asm/sigcontext32.h> | |
32 | #include <asm/fpu32.h> | |
33 | #include <asm/proto.h> | |
34 | #include <asm/vsyscall32.h> | |
35 | ||
36 | #define DEBUG_SIG 0 | |
37 | ||
38 | #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP))) | |
39 | ||
40 | asmlinkage int do_signal(struct pt_regs *regs, sigset_t *oldset); | |
41 | void signal_fault(struct pt_regs *regs, void __user *frame, char *where); | |
42 | ||
43 | int copy_siginfo_to_user32(compat_siginfo_t __user *to, siginfo_t *from) | |
44 | { | |
45 | int err; | |
46 | if (!access_ok (VERIFY_WRITE, to, sizeof(compat_siginfo_t))) | |
47 | return -EFAULT; | |
48 | ||
49 | /* If you change siginfo_t structure, please make sure that | |
50 | this code is fixed accordingly. | |
51 | It should never copy any pad contained in the structure | |
52 | to avoid security leaks, but must copy the generic | |
53 | 3 ints plus the relevant union member. */ | |
54 | err = __put_user(from->si_signo, &to->si_signo); | |
55 | err |= __put_user(from->si_errno, &to->si_errno); | |
56 | err |= __put_user((short)from->si_code, &to->si_code); | |
57 | ||
58 | if (from->si_code < 0) { | |
59 | err |= __put_user(from->si_pid, &to->si_pid); | |
60 | err |= __put_user(from->si_uid, &to->si_uid); | |
61 | err |= __put_user(ptr_to_compat(from->si_ptr), &to->si_ptr); | |
62 | } else { | |
63 | /* First 32bits of unions are always present: | |
64 | * si_pid === si_band === si_tid === si_addr(LS half) */ | |
65 | err |= __put_user(from->_sifields._pad[0], &to->_sifields._pad[0]); | |
66 | switch (from->si_code >> 16) { | |
67 | case __SI_FAULT >> 16: | |
68 | break; | |
69 | case __SI_CHLD >> 16: | |
70 | err |= __put_user(from->si_utime, &to->si_utime); | |
71 | err |= __put_user(from->si_stime, &to->si_stime); | |
72 | err |= __put_user(from->si_status, &to->si_status); | |
73 | /* FALL THROUGH */ | |
74 | default: | |
75 | case __SI_KILL >> 16: | |
76 | err |= __put_user(from->si_uid, &to->si_uid); | |
77 | break; | |
78 | case __SI_POLL >> 16: | |
79 | err |= __put_user(from->si_fd, &to->si_fd); | |
80 | break; | |
81 | case __SI_TIMER >> 16: | |
82 | err |= __put_user(from->si_overrun, &to->si_overrun); | |
83 | err |= __put_user(ptr_to_compat(from->si_ptr), | |
84 | &to->si_ptr); | |
85 | break; | |
86 | case __SI_RT >> 16: /* This is not generated by the kernel as of now. */ | |
87 | case __SI_MESGQ >> 16: | |
88 | err |= __put_user(from->si_uid, &to->si_uid); | |
89 | err |= __put_user(from->si_int, &to->si_int); | |
90 | break; | |
91 | } | |
92 | } | |
93 | return err; | |
94 | } | |
95 | ||
96 | int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from) | |
97 | { | |
98 | int err; | |
99 | u32 ptr32; | |
100 | if (!access_ok (VERIFY_READ, from, sizeof(compat_siginfo_t))) | |
101 | return -EFAULT; | |
102 | ||
103 | err = __get_user(to->si_signo, &from->si_signo); | |
104 | err |= __get_user(to->si_errno, &from->si_errno); | |
105 | err |= __get_user(to->si_code, &from->si_code); | |
106 | ||
107 | err |= __get_user(to->si_pid, &from->si_pid); | |
108 | err |= __get_user(to->si_uid, &from->si_uid); | |
109 | err |= __get_user(ptr32, &from->si_ptr); | |
110 | to->si_ptr = compat_ptr(ptr32); | |
111 | ||
112 | return err; | |
113 | } | |
114 | ||
115 | asmlinkage long | |
1d001df1 | 116 | sys32_sigsuspend(int history0, int history1, old_sigset_t mask) |
1da177e4 | 117 | { |
1da177e4 LT |
118 | mask &= _BLOCKABLE; |
119 | spin_lock_irq(¤t->sighand->siglock); | |
1d001df1 | 120 | current->saved_sigmask = current->blocked; |
1da177e4 LT |
121 | siginitset(¤t->blocked, mask); |
122 | recalc_sigpending(); | |
123 | spin_unlock_irq(¤t->sighand->siglock); | |
124 | ||
1d001df1 AK |
125 | current->state = TASK_INTERRUPTIBLE; |
126 | schedule(); | |
127 | set_thread_flag(TIF_RESTORE_SIGMASK); | |
128 | return -ERESTARTNOHAND; | |
1da177e4 LT |
129 | } |
130 | ||
131 | asmlinkage long | |
132 | sys32_sigaltstack(const stack_ia32_t __user *uss_ptr, | |
133 | stack_ia32_t __user *uoss_ptr, | |
134 | struct pt_regs *regs) | |
135 | { | |
136 | stack_t uss,uoss; | |
137 | int ret; | |
138 | mm_segment_t seg; | |
139 | if (uss_ptr) { | |
140 | u32 ptr; | |
141 | memset(&uss,0,sizeof(stack_t)); | |
142 | if (!access_ok(VERIFY_READ,uss_ptr,sizeof(stack_ia32_t)) || | |
143 | __get_user(ptr, &uss_ptr->ss_sp) || | |
144 | __get_user(uss.ss_flags, &uss_ptr->ss_flags) || | |
145 | __get_user(uss.ss_size, &uss_ptr->ss_size)) | |
146 | return -EFAULT; | |
147 | uss.ss_sp = compat_ptr(ptr); | |
148 | } | |
149 | seg = get_fs(); | |
150 | set_fs(KERNEL_DS); | |
151 | ret = do_sigaltstack(uss_ptr ? &uss : NULL, &uoss, regs->rsp); | |
152 | set_fs(seg); | |
153 | if (ret >= 0 && uoss_ptr) { | |
154 | if (!access_ok(VERIFY_WRITE,uoss_ptr,sizeof(stack_ia32_t)) || | |
155 | __put_user(ptr_to_compat(uoss.ss_sp), &uoss_ptr->ss_sp) || | |
156 | __put_user(uoss.ss_flags, &uoss_ptr->ss_flags) || | |
157 | __put_user(uoss.ss_size, &uoss_ptr->ss_size)) | |
158 | ret = -EFAULT; | |
159 | } | |
160 | return ret; | |
161 | } | |
162 | ||
163 | /* | |
164 | * Do a signal return; undo the signal stack. | |
165 | */ | |
166 | ||
167 | struct sigframe | |
168 | { | |
169 | u32 pretcode; | |
170 | int sig; | |
171 | struct sigcontext_ia32 sc; | |
172 | struct _fpstate_ia32 fpstate; | |
173 | unsigned int extramask[_COMPAT_NSIG_WORDS-1]; | |
174 | char retcode[8]; | |
175 | }; | |
176 | ||
177 | struct rt_sigframe | |
178 | { | |
179 | u32 pretcode; | |
180 | int sig; | |
181 | u32 pinfo; | |
182 | u32 puc; | |
183 | compat_siginfo_t info; | |
184 | struct ucontext_ia32 uc; | |
185 | struct _fpstate_ia32 fpstate; | |
186 | char retcode[8]; | |
187 | }; | |
188 | ||
189 | static int | |
190 | ia32_restore_sigcontext(struct pt_regs *regs, struct sigcontext_ia32 __user *sc, unsigned int *peax) | |
191 | { | |
192 | unsigned int err = 0; | |
193 | ||
194 | /* Always make any pending restarted system calls return -EINTR */ | |
195 | current_thread_info()->restart_block.fn = do_no_restart_syscall; | |
196 | ||
197 | #if DEBUG_SIG | |
198 | printk("SIG restore_sigcontext: sc=%p err(%x) eip(%x) cs(%x) flg(%x)\n", | |
199 | sc, sc->err, sc->eip, sc->cs, sc->eflags); | |
200 | #endif | |
201 | #define COPY(x) { \ | |
202 | unsigned int reg; \ | |
203 | err |= __get_user(reg, &sc->e ##x); \ | |
204 | regs->r ## x = reg; \ | |
205 | } | |
206 | ||
207 | #define RELOAD_SEG(seg,mask) \ | |
208 | { unsigned int cur; \ | |
209 | unsigned short pre; \ | |
210 | err |= __get_user(pre, &sc->seg); \ | |
211 | asm volatile("movl %%" #seg ",%0" : "=r" (cur)); \ | |
212 | pre |= mask; \ | |
213 | if (pre != cur) loadsegment(seg,pre); } | |
214 | ||
215 | /* Reload fs and gs if they have changed in the signal handler. | |
216 | This does not handle long fs/gs base changes in the handler, but | |
217 | does not clobber them at least in the normal case. */ | |
218 | ||
219 | { | |
220 | unsigned gs, oldgs; | |
221 | err |= __get_user(gs, &sc->gs); | |
222 | gs |= 3; | |
223 | asm("movl %%gs,%0" : "=r" (oldgs)); | |
224 | if (gs != oldgs) | |
225 | load_gs_index(gs); | |
226 | } | |
227 | RELOAD_SEG(fs,3); | |
228 | RELOAD_SEG(ds,3); | |
229 | RELOAD_SEG(es,3); | |
230 | ||
231 | COPY(di); COPY(si); COPY(bp); COPY(sp); COPY(bx); | |
232 | COPY(dx); COPY(cx); COPY(ip); | |
233 | /* Don't touch extended registers */ | |
234 | ||
235 | err |= __get_user(regs->cs, &sc->cs); | |
236 | regs->cs |= 3; | |
237 | err |= __get_user(regs->ss, &sc->ss); | |
238 | regs->ss |= 3; | |
239 | ||
240 | { | |
241 | unsigned int tmpflags; | |
242 | err |= __get_user(tmpflags, &sc->eflags); | |
243 | regs->eflags = (regs->eflags & ~0x40DD5) | (tmpflags & 0x40DD5); | |
244 | regs->orig_rax = -1; /* disable syscall checks */ | |
245 | } | |
246 | ||
247 | { | |
248 | u32 tmp; | |
249 | struct _fpstate_ia32 __user * buf; | |
250 | err |= __get_user(tmp, &sc->fpstate); | |
251 | buf = compat_ptr(tmp); | |
252 | if (buf) { | |
253 | if (!access_ok(VERIFY_READ, buf, sizeof(*buf))) | |
254 | goto badframe; | |
255 | err |= restore_i387_ia32(current, buf, 0); | |
256 | } else { | |
257 | struct task_struct *me = current; | |
258 | if (used_math()) { | |
259 | clear_fpu(me); | |
260 | clear_used_math(); | |
261 | } | |
262 | } | |
263 | } | |
264 | ||
265 | { | |
266 | u32 tmp; | |
267 | err |= __get_user(tmp, &sc->eax); | |
268 | *peax = tmp; | |
269 | } | |
270 | return err; | |
271 | ||
272 | badframe: | |
273 | return 1; | |
274 | } | |
275 | ||
276 | asmlinkage long sys32_sigreturn(struct pt_regs *regs) | |
277 | { | |
278 | struct sigframe __user *frame = (struct sigframe __user *)(regs->rsp-8); | |
279 | sigset_t set; | |
280 | unsigned int eax; | |
281 | ||
282 | if (!access_ok(VERIFY_READ, frame, sizeof(*frame))) | |
283 | goto badframe; | |
284 | if (__get_user(set.sig[0], &frame->sc.oldmask) | |
285 | || (_COMPAT_NSIG_WORDS > 1 | |
286 | && __copy_from_user((((char *) &set.sig) + 4), &frame->extramask, | |
287 | sizeof(frame->extramask)))) | |
288 | goto badframe; | |
289 | ||
290 | sigdelsetmask(&set, ~_BLOCKABLE); | |
291 | spin_lock_irq(¤t->sighand->siglock); | |
292 | current->blocked = set; | |
293 | recalc_sigpending(); | |
294 | spin_unlock_irq(¤t->sighand->siglock); | |
295 | ||
296 | if (ia32_restore_sigcontext(regs, &frame->sc, &eax)) | |
297 | goto badframe; | |
298 | return eax; | |
299 | ||
300 | badframe: | |
301 | signal_fault(regs, frame, "32bit sigreturn"); | |
302 | return 0; | |
303 | } | |
304 | ||
305 | asmlinkage long sys32_rt_sigreturn(struct pt_regs *regs) | |
306 | { | |
307 | struct rt_sigframe __user *frame; | |
308 | sigset_t set; | |
309 | unsigned int eax; | |
310 | struct pt_regs tregs; | |
311 | ||
312 | frame = (struct rt_sigframe __user *)(regs->rsp - 4); | |
313 | ||
314 | if (!access_ok(VERIFY_READ, frame, sizeof(*frame))) | |
315 | goto badframe; | |
316 | if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set))) | |
317 | goto badframe; | |
318 | ||
319 | sigdelsetmask(&set, ~_BLOCKABLE); | |
320 | spin_lock_irq(¤t->sighand->siglock); | |
321 | current->blocked = set; | |
322 | recalc_sigpending(); | |
323 | spin_unlock_irq(¤t->sighand->siglock); | |
324 | ||
325 | if (ia32_restore_sigcontext(regs, &frame->uc.uc_mcontext, &eax)) | |
326 | goto badframe; | |
327 | ||
328 | tregs = *regs; | |
329 | if (sys32_sigaltstack(&frame->uc.uc_stack, NULL, &tregs) == -EFAULT) | |
330 | goto badframe; | |
331 | ||
332 | return eax; | |
333 | ||
334 | badframe: | |
335 | signal_fault(regs,frame,"32bit rt sigreturn"); | |
336 | return 0; | |
337 | } | |
338 | ||
339 | /* | |
340 | * Set up a signal frame. | |
341 | */ | |
342 | ||
343 | static int | |
344 | ia32_setup_sigcontext(struct sigcontext_ia32 __user *sc, struct _fpstate_ia32 __user *fpstate, | |
345 | struct pt_regs *regs, unsigned int mask) | |
346 | { | |
347 | int tmp, err = 0; | |
1da177e4 LT |
348 | |
349 | tmp = 0; | |
350 | __asm__("movl %%gs,%0" : "=r"(tmp): "0"(tmp)); | |
351 | err |= __put_user(tmp, (unsigned int __user *)&sc->gs); | |
352 | __asm__("movl %%fs,%0" : "=r"(tmp): "0"(tmp)); | |
353 | err |= __put_user(tmp, (unsigned int __user *)&sc->fs); | |
354 | __asm__("movl %%ds,%0" : "=r"(tmp): "0"(tmp)); | |
355 | err |= __put_user(tmp, (unsigned int __user *)&sc->ds); | |
356 | __asm__("movl %%es,%0" : "=r"(tmp): "0"(tmp)); | |
357 | err |= __put_user(tmp, (unsigned int __user *)&sc->es); | |
358 | ||
359 | err |= __put_user((u32)regs->rdi, &sc->edi); | |
360 | err |= __put_user((u32)regs->rsi, &sc->esi); | |
361 | err |= __put_user((u32)regs->rbp, &sc->ebp); | |
362 | err |= __put_user((u32)regs->rsp, &sc->esp); | |
363 | err |= __put_user((u32)regs->rbx, &sc->ebx); | |
364 | err |= __put_user((u32)regs->rdx, &sc->edx); | |
365 | err |= __put_user((u32)regs->rcx, &sc->ecx); | |
366 | err |= __put_user((u32)regs->rax, &sc->eax); | |
367 | err |= __put_user((u32)regs->cs, &sc->cs); | |
368 | err |= __put_user((u32)regs->ss, &sc->ss); | |
369 | err |= __put_user(current->thread.trap_no, &sc->trapno); | |
370 | err |= __put_user(current->thread.error_code, &sc->err); | |
371 | err |= __put_user((u32)regs->rip, &sc->eip); | |
4724e3e8 | 372 | err |= __put_user((u32)regs->eflags, &sc->eflags); |
1da177e4 LT |
373 | err |= __put_user((u32)regs->rsp, &sc->esp_at_signal); |
374 | ||
375 | tmp = save_i387_ia32(current, fpstate, regs, 0); | |
376 | if (tmp < 0) | |
377 | err = -EFAULT; | |
378 | else { | |
379 | clear_used_math(); | |
380 | stts(); | |
381 | err |= __put_user(ptr_to_compat(tmp ? fpstate : NULL), | |
382 | &sc->fpstate); | |
383 | } | |
384 | ||
385 | /* non-iBCS2 extensions.. */ | |
386 | err |= __put_user(mask, &sc->oldmask); | |
387 | err |= __put_user(current->thread.cr2, &sc->cr2); | |
388 | ||
389 | return err; | |
390 | } | |
391 | ||
392 | /* | |
393 | * Determine which stack to use.. | |
394 | */ | |
395 | static void __user * | |
396 | get_sigframe(struct k_sigaction *ka, struct pt_regs * regs, size_t frame_size) | |
397 | { | |
398 | unsigned long rsp; | |
399 | ||
400 | /* Default to using normal stack */ | |
401 | rsp = regs->rsp; | |
402 | ||
403 | /* This is the X/Open sanctioned signal stack switching. */ | |
404 | if (ka->sa.sa_flags & SA_ONSTACK) { | |
405 | if (sas_ss_flags(rsp) == 0) | |
406 | rsp = current->sas_ss_sp + current->sas_ss_size; | |
407 | } | |
408 | ||
409 | /* This is the legacy signal stack switching. */ | |
410 | else if ((regs->ss & 0xffff) != __USER_DS && | |
411 | !(ka->sa.sa_flags & SA_RESTORER) && | |
412 | ka->sa.sa_restorer) { | |
413 | rsp = (unsigned long) ka->sa.sa_restorer; | |
414 | } | |
415 | ||
d347f372 MO |
416 | rsp -= frame_size; |
417 | /* Align the stack pointer according to the i386 ABI, | |
418 | * i.e. so that on function entry ((sp + 4) & 15) == 0. */ | |
419 | rsp = ((rsp + 4) & -16ul) - 4; | |
420 | return (void __user *) rsp; | |
1da177e4 LT |
421 | } |
422 | ||
0928d6ef RM |
423 | int ia32_setup_frame(int sig, struct k_sigaction *ka, |
424 | compat_sigset_t *set, struct pt_regs * regs) | |
1da177e4 LT |
425 | { |
426 | struct sigframe __user *frame; | |
427 | int err = 0; | |
428 | ||
429 | frame = get_sigframe(ka, regs, sizeof(*frame)); | |
430 | ||
431 | if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame))) | |
432 | goto give_sigsegv; | |
433 | ||
dd54a110 | 434 | err |= __put_user(sig, &frame->sig); |
1da177e4 LT |
435 | if (err) |
436 | goto give_sigsegv; | |
437 | ||
438 | err |= ia32_setup_sigcontext(&frame->sc, &frame->fpstate, regs, | |
439 | set->sig[0]); | |
440 | if (err) | |
441 | goto give_sigsegv; | |
442 | ||
443 | if (_COMPAT_NSIG_WORDS > 1) { | |
444 | err |= __copy_to_user(frame->extramask, &set->sig[1], | |
445 | sizeof(frame->extramask)); | |
446 | } | |
447 | if (err) | |
448 | goto give_sigsegv; | |
449 | ||
450 | /* Return stub is in 32bit vsyscall page */ | |
451 | { | |
452 | void __user *restorer = VSYSCALL32_SIGRETURN; | |
453 | if (ka->sa.sa_flags & SA_RESTORER) | |
454 | restorer = ka->sa.sa_restorer; | |
455 | err |= __put_user(ptr_to_compat(restorer), &frame->pretcode); | |
456 | } | |
457 | /* These are actually not used anymore, but left because some | |
458 | gdb versions depend on them as a marker. */ | |
459 | { | |
460 | /* copy_to_user optimizes that into a single 8 byte store */ | |
461 | static const struct { | |
462 | u16 poplmovl; | |
463 | u32 val; | |
464 | u16 int80; | |
465 | u16 pad; | |
466 | } __attribute__((packed)) code = { | |
467 | 0xb858, /* popl %eax ; movl $...,%eax */ | |
468 | __NR_ia32_sigreturn, | |
469 | 0x80cd, /* int $0x80 */ | |
470 | 0, | |
471 | }; | |
472 | err |= __copy_to_user(frame->retcode, &code, 8); | |
473 | } | |
474 | if (err) | |
475 | goto give_sigsegv; | |
476 | ||
477 | /* Set up registers for signal handler */ | |
478 | regs->rsp = (unsigned long) frame; | |
479 | regs->rip = (unsigned long) ka->sa.sa_handler; | |
480 | ||
536e3ee4 AK |
481 | /* Make -mregparm=3 work */ |
482 | regs->rax = sig; | |
483 | regs->rdx = 0; | |
484 | regs->rcx = 0; | |
485 | ||
1da177e4 LT |
486 | asm volatile("movl %0,%%ds" :: "r" (__USER32_DS)); |
487 | asm volatile("movl %0,%%es" :: "r" (__USER32_DS)); | |
488 | ||
489 | regs->cs = __USER32_CS; | |
490 | regs->ss = __USER32_DS; | |
491 | ||
492 | set_fs(USER_DS); | |
ab2e0b46 AK |
493 | regs->eflags &= ~TF_MASK; |
494 | if (test_thread_flag(TIF_SINGLESTEP)) | |
495 | ptrace_notify(SIGTRAP); | |
1da177e4 LT |
496 | |
497 | #if DEBUG_SIG | |
498 | printk("SIG deliver (%s:%d): sp=%p pc=%p ra=%p\n", | |
499 | current->comm, current->pid, frame, regs->rip, frame->pretcode); | |
500 | #endif | |
501 | ||
1d001df1 | 502 | return 0; |
1da177e4 LT |
503 | |
504 | give_sigsegv: | |
505 | force_sigsegv(sig, current); | |
1d001df1 | 506 | return -EFAULT; |
1da177e4 LT |
507 | } |
508 | ||
0928d6ef RM |
509 | int ia32_setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info, |
510 | compat_sigset_t *set, struct pt_regs * regs) | |
1da177e4 LT |
511 | { |
512 | struct rt_sigframe __user *frame; | |
513 | int err = 0; | |
514 | ||
515 | frame = get_sigframe(ka, regs, sizeof(*frame)); | |
516 | ||
517 | if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame))) | |
518 | goto give_sigsegv; | |
519 | ||
520 | { | |
521 | struct exec_domain *ed = current_thread_info()->exec_domain; | |
522 | err |= __put_user((ed | |
523 | && ed->signal_invmap | |
524 | && sig < 32 | |
525 | ? ed->signal_invmap[sig] | |
526 | : sig), | |
527 | &frame->sig); | |
528 | } | |
529 | err |= __put_user(ptr_to_compat(&frame->info), &frame->pinfo); | |
530 | err |= __put_user(ptr_to_compat(&frame->uc), &frame->puc); | |
531 | err |= copy_siginfo_to_user32(&frame->info, info); | |
532 | if (err) | |
533 | goto give_sigsegv; | |
534 | ||
535 | /* Create the ucontext. */ | |
536 | err |= __put_user(0, &frame->uc.uc_flags); | |
537 | err |= __put_user(0, &frame->uc.uc_link); | |
538 | err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp); | |
539 | err |= __put_user(sas_ss_flags(regs->rsp), | |
540 | &frame->uc.uc_stack.ss_flags); | |
541 | err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size); | |
542 | err |= ia32_setup_sigcontext(&frame->uc.uc_mcontext, &frame->fpstate, | |
543 | regs, set->sig[0]); | |
544 | err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set)); | |
545 | if (err) | |
546 | goto give_sigsegv; | |
547 | ||
548 | ||
549 | { | |
550 | void __user *restorer = VSYSCALL32_RTSIGRETURN; | |
551 | if (ka->sa.sa_flags & SA_RESTORER) | |
552 | restorer = ka->sa.sa_restorer; | |
553 | err |= __put_user(ptr_to_compat(restorer), &frame->pretcode); | |
554 | } | |
555 | ||
556 | /* This is movl $,%eax ; int $0x80 */ | |
557 | /* Not actually used anymore, but left because some gdb versions | |
558 | need it. */ | |
559 | { | |
560 | /* __copy_to_user optimizes that into a single 8 byte store */ | |
561 | static const struct { | |
562 | u8 movl; | |
563 | u32 val; | |
564 | u16 int80; | |
565 | u16 pad; | |
566 | u8 pad2; | |
567 | } __attribute__((packed)) code = { | |
568 | 0xb8, | |
569 | __NR_ia32_rt_sigreturn, | |
570 | 0x80cd, | |
571 | 0, | |
572 | }; | |
573 | err |= __copy_to_user(frame->retcode, &code, 8); | |
574 | } | |
575 | if (err) | |
576 | goto give_sigsegv; | |
577 | ||
578 | /* Set up registers for signal handler */ | |
579 | regs->rsp = (unsigned long) frame; | |
580 | regs->rip = (unsigned long) ka->sa.sa_handler; | |
581 | ||
582 | asm volatile("movl %0,%%ds" :: "r" (__USER32_DS)); | |
583 | asm volatile("movl %0,%%es" :: "r" (__USER32_DS)); | |
584 | ||
585 | regs->cs = __USER32_CS; | |
586 | regs->ss = __USER32_DS; | |
587 | ||
588 | set_fs(USER_DS); | |
1d001df1 | 589 | regs->eflags &= ~TF_MASK; |
ab2e0b46 AK |
590 | if (test_thread_flag(TIF_SINGLESTEP)) |
591 | ptrace_notify(SIGTRAP); | |
1da177e4 LT |
592 | |
593 | #if DEBUG_SIG | |
594 | printk("SIG deliver (%s:%d): sp=%p pc=%p ra=%p\n", | |
595 | current->comm, current->pid, frame, regs->rip, frame->pretcode); | |
596 | #endif | |
597 | ||
1d001df1 | 598 | return 0; |
1da177e4 LT |
599 | |
600 | give_sigsegv: | |
601 | force_sigsegv(sig, current); | |
1d001df1 | 602 | return -EFAULT; |
1da177e4 | 603 | } |