projects / deliverable / linux.git / blob
? search:


54605eb1631f8516f3a45379ad68b064005d89ac
[deliverable/linux.git] / arch / x86 / ia32 / ia32_signal.c
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
9 */
10
11 #include <linux/sched.h>
12 #include <linux/mm.h>
13 #include <linux/smp.h>
14 #include <linux/kernel.h>
15 #include <linux/errno.h>
16 #include <linux/wait.h>
17 #include <linux/unistd.h>
18 #include <linux/stddef.h>
19 #include <linux/personality.h>
20 #include <linux/compat.h>
21 #include <linux/binfmts.h>
22 #include <asm/ucontext.h>
23 #include <asm/uaccess.h>
24 #include <asm/fpu/internal.h>
25 #include <asm/ptrace.h>
26 #include <asm/ia32_unistd.h>
27 #include <asm/user32.h>
28 #include <asm/sigcontext32.h>
29 #include <asm/proto.h>
30 #include <asm/vdso.h>
31 #include <asm/sigframe.h>
32 #include <asm/sighandling.h>
33 #include <asm/sys_ia32.h>
34 #include <asm/smap.h>
35
36 int copy_siginfo_to_user32(compat_siginfo_t __user *to, const siginfo_t *from)
37 {
38 int err = 0;
39 bool ia32 = test_thread_flag(TIF_IA32);
40
41 if (!access_ok(VERIFY_WRITE, to, sizeof(compat_siginfo_t)))
42 return -EFAULT;
43
44 put_user_try {
45 /* If you change siginfo_t structure, please make sure that
46 this code is fixed accordingly.
47 It should never copy any pad contained in the structure
48 to avoid security leaks, but must copy the generic
49 3 ints plus the relevant union member. */
50 put_user_ex(from->si_signo, &to->si_signo);
51 put_user_ex(from->si_errno, &to->si_errno);
52 put_user_ex((short)from->si_code, &to->si_code);
53
54 if (from->si_code < 0) {
55 put_user_ex(from->si_pid, &to->si_pid);
56 put_user_ex(from->si_uid, &to->si_uid);
57 put_user_ex(ptr_to_compat(from->si_ptr), &to->si_ptr);
58 } else {
59 /*
60 * First 32bits of unions are always present:
61 * si_pid === si_band === si_tid === si_addr(LS half)
62 */
63 put_user_ex(from->_sifields._pad[0],
64 &to->_sifields._pad[0]);
65 switch (from->si_code >> 16) {
66 case __SI_FAULT >> 16:
67 break;
68 case __SI_SYS >> 16:
69 put_user_ex(from->si_syscall, &to->si_syscall);
70 put_user_ex(from->si_arch, &to->si_arch);
71 break;
72 case __SI_CHLD >> 16:
73 if (ia32) {
74 put_user_ex(from->si_utime, &to->si_utime);
75 put_user_ex(from->si_stime, &to->si_stime);
76 } else {
77 put_user_ex(from->si_utime, &to->_sifields._sigchld_x32._utime);
78 put_user_ex(from->si_stime, &to->_sifields._sigchld_x32._stime);
79 }
80 put_user_ex(from->si_status, &to->si_status);
81 /* FALL THROUGH */
82 default:
83 case __SI_KILL >> 16:
84 put_user_ex(from->si_uid, &to->si_uid);
85 break;
86 case __SI_POLL >> 16:
87 put_user_ex(from->si_fd, &to->si_fd);
88 break;
89 case __SI_TIMER >> 16:
90 put_user_ex(from->si_overrun, &to->si_overrun);
91 put_user_ex(ptr_to_compat(from->si_ptr),
92 &to->si_ptr);
93 break;
94 /* This is not generated by the kernel as of now. */
95 case __SI_RT >> 16:
96 case __SI_MESGQ >> 16:
97 put_user_ex(from->si_uid, &to->si_uid);
98 put_user_ex(from->si_int, &to->si_int);
99 break;
100 }
101 }
102 } put_user_catch(err);
103
104 return err;
105 }
106
107 int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from)
108 {
109 int err = 0;
110 u32 ptr32;
111
112 if (!access_ok(VERIFY_READ, from, sizeof(compat_siginfo_t)))
113 return -EFAULT;
114
115 get_user_try {
116 get_user_ex(to->si_signo, &from->si_signo);
117 get_user_ex(to->si_errno, &from->si_errno);
118 get_user_ex(to->si_code, &from->si_code);
119
120 get_user_ex(to->si_pid, &from->si_pid);
121 get_user_ex(to->si_uid, &from->si_uid);
122 get_user_ex(ptr32, &from->si_ptr);
123 to->si_ptr = compat_ptr(ptr32);
124 } get_user_catch(err);
125
126 return err;
127 }
128
129 /*
130 * Do a signal return; undo the signal stack.
131 */
132 #define loadsegment_gs(v) load_gs_index(v)
133 #define loadsegment_fs(v) loadsegment(fs, v)
134 #define loadsegment_ds(v) loadsegment(ds, v)
135 #define loadsegment_es(v) loadsegment(es, v)
136
137 #define get_user_seg(seg) ({ unsigned int v; savesegment(seg, v); v; })
138 #define set_user_seg(seg, v) loadsegment_##seg(v)
139
140 #define COPY(x) { \
141 get_user_ex(regs->x, &sc->x); \
142 }
143
144 #define GET_SEG(seg) ({ \
145 unsigned short tmp; \
146 get_user_ex(tmp, &sc->seg); \
147 tmp; \
148 })
149
150 #define COPY_SEG_CPL3(seg) do { \
151 regs->seg = GET_SEG(seg) | 3; \
152 } while (0)
153
154 #define RELOAD_SEG(seg) { \
155 unsigned int pre = GET_SEG(seg); \
156 unsigned int cur = get_user_seg(seg); \
157 pre |= 3; \
158 if (pre != cur) \
159 set_user_seg(seg, pre); \
160 }
161
162 static int ia32_restore_sigcontext(struct pt_regs *regs,
163 struct sigcontext_ia32 __user *sc)
164 {
165 unsigned int tmpflags, err = 0;
166 void __user *buf;
167 u32 tmp;
168
169 /* Always make any pending restarted system calls return -EINTR */
170 current->restart_block.fn = do_no_restart_syscall;
171
172 get_user_try {
173 /*
174 * Reload fs and gs if they have changed in the signal
175 * handler. This does not handle long fs/gs base changes in
176 * the handler, but does not clobber them at least in the
177 * normal case.
178 */
179 RELOAD_SEG(gs);
180 RELOAD_SEG(fs);
181 RELOAD_SEG(ds);
182 RELOAD_SEG(es);
183
184 COPY(di); COPY(si); COPY(bp); COPY(sp); COPY(bx);
185 COPY(dx); COPY(cx); COPY(ip); COPY(ax);
186 /* Don't touch extended registers */
187
188 COPY_SEG_CPL3(cs);
189 COPY_SEG_CPL3(ss);
190
191 get_user_ex(tmpflags, &sc->flags);
192 regs->flags = (regs->flags & ~FIX_EFLAGS) | (tmpflags & FIX_EFLAGS);
193 /* disable syscall checks */
194 regs->orig_ax = -1;
195
196 get_user_ex(tmp, &sc->fpstate);
197 buf = compat_ptr(tmp);
198 } get_user_catch(err);
199
200 err |= fpu__restore_sig(buf, 1);
201
202 force_iret();
203
204 return err;
205 }
206
207 asmlinkage long sys32_sigreturn(void)
208 {
209 struct pt_regs *regs = current_pt_regs();
210 struct sigframe_ia32 __user *frame = (struct sigframe_ia32 __user *)(regs->sp-8);
211 sigset_t set;
212
213 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
214 goto badframe;
215 if (__get_user(set.sig[0], &frame->sc.oldmask)
216 || (_COMPAT_NSIG_WORDS > 1
217 && __copy_from_user((((char *) &set.sig) + 4),
218 &frame->extramask,
219 sizeof(frame->extramask))))
220 goto badframe;
221
222 set_current_blocked(&set);
223
224 if (ia32_restore_sigcontext(regs, &frame->sc))
225 goto badframe;
226 return regs->ax;
227
228 badframe:
229 signal_fault(regs, frame, "32bit sigreturn");
230 return 0;
231 }
232
233 asmlinkage long sys32_rt_sigreturn(void)
234 {
235 struct pt_regs *regs = current_pt_regs();
236 struct rt_sigframe_ia32 __user *frame;
237 sigset_t set;
238
239 frame = (struct rt_sigframe_ia32 __user *)(regs->sp - 4);
240
241 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
242 goto badframe;
243 if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
244 goto badframe;
245
246 set_current_blocked(&set);
247
248 if (ia32_restore_sigcontext(regs, &frame->uc.uc_mcontext))
249 goto badframe;
250
251 if (compat_restore_altstack(&frame->uc.uc_stack))
252 goto badframe;
253
254 return regs->ax;
255
256 badframe:
257 signal_fault(regs, frame, "32bit rt sigreturn");
258 return 0;
259 }
260
261 /*
262 * Set up a signal frame.
263 */
264
265 static int ia32_setup_sigcontext(struct sigcontext_ia32 __user *sc,
266 void __user *fpstate,
267 struct pt_regs *regs, unsigned int mask)
268 {
269 int err = 0;
270
271 put_user_try {
272 put_user_ex(get_user_seg(gs), (unsigned int __user *)&sc->gs);
273 put_user_ex(get_user_seg(fs), (unsigned int __user *)&sc->fs);
274 put_user_ex(get_user_seg(ds), (unsigned int __user *)&sc->ds);
275 put_user_ex(get_user_seg(es), (unsigned int __user *)&sc->es);
276
277 put_user_ex(regs->di, &sc->di);
278 put_user_ex(regs->si, &sc->si);
279 put_user_ex(regs->bp, &sc->bp);
280 put_user_ex(regs->sp, &sc->sp);
281 put_user_ex(regs->bx, &sc->bx);
282 put_user_ex(regs->dx, &sc->dx);
283 put_user_ex(regs->cx, &sc->cx);
284 put_user_ex(regs->ax, &sc->ax);
285 put_user_ex(current->thread.trap_nr, &sc->trapno);
286 put_user_ex(current->thread.error_code, &sc->err);
287 put_user_ex(regs->ip, &sc->ip);
288 put_user_ex(regs->cs, (unsigned int __user *)&sc->cs);
289 put_user_ex(regs->flags, &sc->flags);
290 put_user_ex(regs->sp, &sc->sp_at_signal);
291 put_user_ex(regs->ss, (unsigned int __user *)&sc->ss);
292
293 put_user_ex(ptr_to_compat(fpstate), &sc->fpstate);
294
295 /* non-iBCS2 extensions.. */
296 put_user_ex(mask, &sc->oldmask);
297 put_user_ex(current->thread.cr2, &sc->cr2);
298 } put_user_catch(err);
299
300 return err;
301 }
302
303 /*
304 * Determine which stack to use..
305 */
306 static void __user *get_sigframe(struct ksignal *ksig, struct pt_regs *regs,
307 size_t frame_size,
308 void __user **fpstate)
309 {
310 struct fpu *fpu = &current->thread.fpu;
311 unsigned long sp;
312
313 /* Default to using normal stack */
314 sp = regs->sp;
315
316 /* This is the X/Open sanctioned signal stack switching. */
317 if (ksig->ka.sa.sa_flags & SA_ONSTACK)
318 sp = sigsp(sp, ksig);
319 /* This is the legacy signal stack switching. */
320 else if ((regs->ss & 0xffff) != __USER32_DS &&
321 !(ksig->ka.sa.sa_flags & SA_RESTORER) &&
322 ksig->ka.sa.sa_restorer)
323 sp = (unsigned long) ksig->ka.sa.sa_restorer;
324
325 if (fpu->fpstate_active) {
326 unsigned long fx_aligned, math_size;
327
328 sp = fpu__alloc_mathframe(sp, 1, &fx_aligned, &math_size);
329 *fpstate = (struct _fpstate_ia32 __user *) sp;
330 if (copy_fpstate_to_sigframe(*fpstate, (void __user *)fx_aligned,
331 math_size) < 0)
332 return (void __user *) -1L;
333 }
334
335 sp -= frame_size;
336 /* Align the stack pointer according to the i386 ABI,
337 * i.e. so that on function entry ((sp + 4) & 15) == 0. */
338 sp = ((sp + 4) & -16ul) - 4;
339 return (void __user *) sp;
340 }
341
342 int ia32_setup_frame(int sig, struct ksignal *ksig,
343 compat_sigset_t *set, struct pt_regs *regs)
344 {
345 struct sigframe_ia32 __user *frame;
346 void __user *restorer;
347 int err = 0;
348 void __user *fpstate = NULL;
349
350 /* copy_to_user optimizes that into a single 8 byte store */
351 static const struct {
352 u16 poplmovl;
353 u32 val;
354 u16 int80;
355 } __attribute__((packed)) code = {
356 0xb858, /* popl %eax ; movl $...,%eax */
357 __NR_ia32_sigreturn,
358 0x80cd, /* int $0x80 */
359 };
360
361 frame = get_sigframe(ksig, regs, sizeof(*frame), &fpstate);
362
363 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
364 return -EFAULT;
365
366 if (__put_user(sig, &frame->sig))
367 return -EFAULT;
368
369 if (ia32_setup_sigcontext(&frame->sc, fpstate, regs, set->sig[0]))
370 return -EFAULT;
371
372 if (_COMPAT_NSIG_WORDS > 1) {
373 if (__copy_to_user(frame->extramask, &set->sig[1],
374 sizeof(frame->extramask)))
375 return -EFAULT;
376 }
377
378 if (ksig->ka.sa.sa_flags & SA_RESTORER) {
379 restorer = ksig->ka.sa.sa_restorer;
380 } else {
381 /* Return stub is in 32bit vsyscall page */
382 if (current->mm->context.vdso)
383 restorer = current->mm->context.vdso +
384 selected_vdso32->sym___kernel_sigreturn;
385 else
386 restorer = &frame->retcode;
387 }
388
389 put_user_try {
390 put_user_ex(ptr_to_compat(restorer), &frame->pretcode);
391
392 /*
393 * These are actually not used anymore, but left because some
394 * gdb versions depend on them as a marker.
395 */
396 put_user_ex(*((u64 *)&code), (u64 __user *)frame->retcode);
397 } put_user_catch(err);
398
399 if (err)
400 return -EFAULT;
401
402 /* Set up registers for signal handler */
403 regs->sp = (unsigned long) frame;
404 regs->ip = (unsigned long) ksig->ka.sa.sa_handler;
405
406 /* Make -mregparm=3 work */
407 regs->ax = sig;
408 regs->dx = 0;
409 regs->cx = 0;
410
411 loadsegment(ds, __USER32_DS);
412 loadsegment(es, __USER32_DS);
413
414 regs->cs = __USER32_CS;
415 regs->ss = __USER32_DS;
416
417 return 0;
418 }
419
420 int ia32_setup_rt_frame(int sig, struct ksignal *ksig,
421 compat_sigset_t *set, struct pt_regs *regs)
422 {
423 struct rt_sigframe_ia32 __user *frame;
424 void __user *restorer;
425 int err = 0;
426 void __user *fpstate = NULL;
427
428 /* __copy_to_user optimizes that into a single 8 byte store */
429 static const struct {
430 u8 movl;
431 u32 val;
432 u16 int80;
433 u8 pad;
434 } __attribute__((packed)) code = {
435 0xb8,
436 __NR_ia32_rt_sigreturn,
437 0x80cd,
438 0,
439 };
440
441 frame = get_sigframe(ksig, regs, sizeof(*frame), &fpstate);
442
443 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
444 return -EFAULT;
445
446 put_user_try {
447 put_user_ex(sig, &frame->sig);
448 put_user_ex(ptr_to_compat(&frame->info), &frame->pinfo);
449 put_user_ex(ptr_to_compat(&frame->uc), &frame->puc);
450
451 /* Create the ucontext. */
452 if (cpu_has_xsave)
453 put_user_ex(UC_FP_XSTATE, &frame->uc.uc_flags);
454 else
455 put_user_ex(0, &frame->uc.uc_flags);
456 put_user_ex(0, &frame->uc.uc_link);
457 compat_save_altstack_ex(&frame->uc.uc_stack, regs->sp);
458
459 if (ksig->ka.sa.sa_flags & SA_RESTORER)
460 restorer = ksig->ka.sa.sa_restorer;
461 else
462 restorer = current->mm->context.vdso +
463 selected_vdso32->sym___kernel_rt_sigreturn;
464 put_user_ex(ptr_to_compat(restorer), &frame->pretcode);
465
466 /*
467 * Not actually used anymore, but left because some gdb
468 * versions need it.
469 */
470 put_user_ex(*((u64 *)&code), (u64 __user *)frame->retcode);
471 } put_user_catch(err);
472
473 err |= copy_siginfo_to_user32(&frame->info, &ksig->info);
474 err |= ia32_setup_sigcontext(&frame->uc.uc_mcontext, fpstate,
475 regs, set->sig[0]);
476 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
477
478 if (err)
479 return -EFAULT;
480
481 /* Set up registers for signal handler */
482 regs->sp = (unsigned long) frame;
483 regs->ip = (unsigned long) ksig->ka.sa.sa_handler;
484
485 /* Make -mregparm=3 work */
486 regs->ax = sig;
487 regs->dx = (unsigned long) &frame->info;
488 regs->cx = (unsigned long) &frame->uc;
489
490 loadsegment(ds, __USER32_DS);
491 loadsegment(es, __USER32_DS);
492
493 regs->cs = __USER32_CS;
494 regs->ss = __USER32_DS;
495
496 return 0;
497 }
Linux kernel - Deliverables
This page took 0.039518 seconds and 4 git commands to generate.