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/i387.h>
25 #include <asm/fpu-internal.h>
26 #include <asm/ptrace.h>
27 #include <asm/ia32_unistd.h>
28 #include <asm/user32.h>
29 #include <asm/sigcontext32.h>
30 #include <asm/proto.h>
31 #include <asm/vdso.h>
32 #include <asm/sigframe.h>
33 #include <asm/sighandling.h>
34 #include <asm/sys_ia32.h>
35 #include <asm/smap.h>
36
copy_siginfo_to_user32(compat_siginfo_t __user * to,const siginfo_t * from)37 int copy_siginfo_to_user32(compat_siginfo_t __user *to, const siginfo_t *from)
38 {
39 int err = 0;
40 bool ia32 = test_thread_flag(TIF_IA32);
41
42 if (!access_ok(VERIFY_WRITE, to, sizeof(compat_siginfo_t)))
43 return -EFAULT;
44
45 put_user_try {
46 /* If you change siginfo_t structure, please make sure that
47 this code is fixed accordingly.
48 It should never copy any pad contained in the structure
49 to avoid security leaks, but must copy the generic
50 3 ints plus the relevant union member. */
51 put_user_ex(from->si_signo, &to->si_signo);
52 put_user_ex(from->si_errno, &to->si_errno);
53 put_user_ex((short)from->si_code, &to->si_code);
54
55 if (from->si_code < 0) {
56 put_user_ex(from->si_pid, &to->si_pid);
57 put_user_ex(from->si_uid, &to->si_uid);
58 put_user_ex(ptr_to_compat(from->si_ptr), &to->si_ptr);
59 } else {
60 /*
61 * First 32bits of unions are always present:
62 * si_pid === si_band === si_tid === si_addr(LS half)
63 */
64 put_user_ex(from->_sifields._pad[0],
65 &to->_sifields._pad[0]);
66 switch (from->si_code >> 16) {
67 case __SI_FAULT >> 16:
68 break;
69 case __SI_SYS >> 16:
70 put_user_ex(from->si_syscall, &to->si_syscall);
71 put_user_ex(from->si_arch, &to->si_arch);
72 break;
73 case __SI_CHLD >> 16:
74 if (ia32) {
75 put_user_ex(from->si_utime, &to->si_utime);
76 put_user_ex(from->si_stime, &to->si_stime);
77 } else {
78 put_user_ex(from->si_utime, &to->_sifields._sigchld_x32._utime);
79 put_user_ex(from->si_stime, &to->_sifields._sigchld_x32._stime);
80 }
81 put_user_ex(from->si_status, &to->si_status);
82 /* FALL THROUGH */
83 default:
84 case __SI_KILL >> 16:
85 put_user_ex(from->si_uid, &to->si_uid);
86 break;
87 case __SI_POLL >> 16:
88 put_user_ex(from->si_fd, &to->si_fd);
89 break;
90 case __SI_TIMER >> 16:
91 put_user_ex(from->si_overrun, &to->si_overrun);
92 put_user_ex(ptr_to_compat(from->si_ptr),
93 &to->si_ptr);
94 break;
95 /* This is not generated by the kernel as of now. */
96 case __SI_RT >> 16:
97 case __SI_MESGQ >> 16:
98 put_user_ex(from->si_uid, &to->si_uid);
99 put_user_ex(from->si_int, &to->si_int);
100 break;
101 }
102 }
103 } put_user_catch(err);
104
105 return err;
106 }
107
copy_siginfo_from_user32(siginfo_t * to,compat_siginfo_t __user * from)108 int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from)
109 {
110 int err = 0;
111 u32 ptr32;
112
113 if (!access_ok(VERIFY_READ, from, sizeof(compat_siginfo_t)))
114 return -EFAULT;
115
116 get_user_try {
117 get_user_ex(to->si_signo, &from->si_signo);
118 get_user_ex(to->si_errno, &from->si_errno);
119 get_user_ex(to->si_code, &from->si_code);
120
121 get_user_ex(to->si_pid, &from->si_pid);
122 get_user_ex(to->si_uid, &from->si_uid);
123 get_user_ex(ptr32, &from->si_ptr);
124 to->si_ptr = compat_ptr(ptr32);
125 } get_user_catch(err);
126
127 return err;
128 }
129
130 /*
131 * Do a signal return; undo the signal stack.
132 */
133 #define loadsegment_gs(v) load_gs_index(v)
134 #define loadsegment_fs(v) loadsegment(fs, v)
135 #define loadsegment_ds(v) loadsegment(ds, v)
136 #define loadsegment_es(v) loadsegment(es, v)
137
138 #define get_user_seg(seg) ({ unsigned int v; savesegment(seg, v); v; })
139 #define set_user_seg(seg, v) loadsegment_##seg(v)
140
141 #define COPY(x) { \
142 get_user_ex(regs->x, &sc->x); \
143 }
144
145 #define GET_SEG(seg) ({ \
146 unsigned short tmp; \
147 get_user_ex(tmp, &sc->seg); \
148 tmp; \
149 })
150
151 #define COPY_SEG_CPL3(seg) do { \
152 regs->seg = GET_SEG(seg) | 3; \
153 } while (0)
154
155 #define RELOAD_SEG(seg) { \
156 unsigned int pre = GET_SEG(seg); \
157 unsigned int cur = get_user_seg(seg); \
158 pre |= 3; \
159 if (pre != cur) \
160 set_user_seg(seg, pre); \
161 }
162
ia32_restore_sigcontext(struct pt_regs * regs,struct sigcontext_ia32 __user * sc)163 static int ia32_restore_sigcontext(struct pt_regs *regs,
164 struct sigcontext_ia32 __user *sc)
165 {
166 unsigned int tmpflags, err = 0;
167 void __user *buf;
168 u32 tmp;
169
170 /* Always make any pending restarted system calls return -EINTR */
171 current->restart_block.fn = do_no_restart_syscall;
172
173 get_user_try {
174 /*
175 * Reload fs and gs if they have changed in the signal
176 * handler. This does not handle long fs/gs base changes in
177 * the handler, but does not clobber them at least in the
178 * normal case.
179 */
180 RELOAD_SEG(gs);
181 RELOAD_SEG(fs);
182 RELOAD_SEG(ds);
183 RELOAD_SEG(es);
184
185 COPY(di); COPY(si); COPY(bp); COPY(sp); COPY(bx);
186 COPY(dx); COPY(cx); COPY(ip); COPY(ax);
187 /* Don't touch extended registers */
188
189 COPY_SEG_CPL3(cs);
190 COPY_SEG_CPL3(ss);
191
192 get_user_ex(tmpflags, &sc->flags);
193 regs->flags = (regs->flags & ~FIX_EFLAGS) | (tmpflags & FIX_EFLAGS);
194 /* disable syscall checks */
195 regs->orig_ax = -1;
196
197 get_user_ex(tmp, &sc->fpstate);
198 buf = compat_ptr(tmp);
199 } get_user_catch(err);
200
201 err |= restore_xstate_sig(buf, 1);
202
203 force_iret();
204
205 return err;
206 }
207
sys32_sigreturn(void)208 asmlinkage long sys32_sigreturn(void)
209 {
210 struct pt_regs *regs = current_pt_regs();
211 struct sigframe_ia32 __user *frame = (struct sigframe_ia32 __user *)(regs->sp-8);
212 sigset_t set;
213
214 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
215 goto badframe;
216 if (__get_user(set.sig[0], &frame->sc.oldmask)
217 || (_COMPAT_NSIG_WORDS > 1
218 && __copy_from_user((((char *) &set.sig) + 4),
219 &frame->extramask,
220 sizeof(frame->extramask))))
221 goto badframe;
222
223 set_current_blocked(&set);
224
225 if (ia32_restore_sigcontext(regs, &frame->sc))
226 goto badframe;
227 return regs->ax;
228
229 badframe:
230 signal_fault(regs, frame, "32bit sigreturn");
231 return 0;
232 }
233
sys32_rt_sigreturn(void)234 asmlinkage long sys32_rt_sigreturn(void)
235 {
236 struct pt_regs *regs = current_pt_regs();
237 struct rt_sigframe_ia32 __user *frame;
238 sigset_t set;
239
240 frame = (struct rt_sigframe_ia32 __user *)(regs->sp - 4);
241
242 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
243 goto badframe;
244 if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
245 goto badframe;
246
247 set_current_blocked(&set);
248
249 if (ia32_restore_sigcontext(regs, &frame->uc.uc_mcontext))
250 goto badframe;
251
252 if (compat_restore_altstack(&frame->uc.uc_stack))
253 goto badframe;
254
255 return regs->ax;
256
257 badframe:
258 signal_fault(regs, frame, "32bit rt sigreturn");
259 return 0;
260 }
261
262 /*
263 * Set up a signal frame.
264 */
265
ia32_setup_sigcontext(struct sigcontext_ia32 __user * sc,void __user * fpstate,struct pt_regs * regs,unsigned int mask)266 static int ia32_setup_sigcontext(struct sigcontext_ia32 __user *sc,
267 void __user *fpstate,
268 struct pt_regs *regs, unsigned int mask)
269 {
270 int err = 0;
271
272 put_user_try {
273 put_user_ex(get_user_seg(gs), (unsigned int __user *)&sc->gs);
274 put_user_ex(get_user_seg(fs), (unsigned int __user *)&sc->fs);
275 put_user_ex(get_user_seg(ds), (unsigned int __user *)&sc->ds);
276 put_user_ex(get_user_seg(es), (unsigned int __user *)&sc->es);
277
278 put_user_ex(regs->di, &sc->di);
279 put_user_ex(regs->si, &sc->si);
280 put_user_ex(regs->bp, &sc->bp);
281 put_user_ex(regs->sp, &sc->sp);
282 put_user_ex(regs->bx, &sc->bx);
283 put_user_ex(regs->dx, &sc->dx);
284 put_user_ex(regs->cx, &sc->cx);
285 put_user_ex(regs->ax, &sc->ax);
286 put_user_ex(current->thread.trap_nr, &sc->trapno);
287 put_user_ex(current->thread.error_code, &sc->err);
288 put_user_ex(regs->ip, &sc->ip);
289 put_user_ex(regs->cs, (unsigned int __user *)&sc->cs);
290 put_user_ex(regs->flags, &sc->flags);
291 put_user_ex(regs->sp, &sc->sp_at_signal);
292 put_user_ex(regs->ss, (unsigned int __user *)&sc->ss);
293
294 put_user_ex(ptr_to_compat(fpstate), &sc->fpstate);
295
296 /* non-iBCS2 extensions.. */
297 put_user_ex(mask, &sc->oldmask);
298 put_user_ex(current->thread.cr2, &sc->cr2);
299 } put_user_catch(err);
300
301 return err;
302 }
303
304 /*
305 * Determine which stack to use..
306 */
get_sigframe(struct ksignal * ksig,struct pt_regs * regs,size_t frame_size,void __user ** fpstate)307 static void __user *get_sigframe(struct ksignal *ksig, struct pt_regs *regs,
308 size_t frame_size,
309 void __user **fpstate)
310 {
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 (used_math()) {
326 unsigned long fx_aligned, math_size;
327
328 sp = alloc_mathframe(sp, 1, &fx_aligned, &math_size);
329 *fpstate = (struct _fpstate_ia32 __user *) sp;
330 if (save_xstate_sig(*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
ia32_setup_frame(int sig,struct ksignal * ksig,compat_sigset_t * set,struct pt_regs * regs)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
ia32_setup_rt_frame(int sig,struct ksignal * ksig,compat_sigset_t * set,struct pt_regs * regs)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 }
498