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,unsigned int * pax)163 static int ia32_restore_sigcontext(struct pt_regs *regs,
164 struct sigcontext_ia32 __user *sc,
165 unsigned int *pax)
166 {
167 unsigned int tmpflags, err = 0;
168 void __user *buf;
169 u32 tmp;
170
171 /* Always make any pending restarted system calls return -EINTR */
172 current->restart_block.fn = do_no_restart_syscall;
173
174 get_user_try {
175 /*
176 * Reload fs and gs if they have changed in the signal
177 * handler. This does not handle long fs/gs base changes in
178 * the handler, but does not clobber them at least in the
179 * normal case.
180 */
181 RELOAD_SEG(gs);
182 RELOAD_SEG(fs);
183 RELOAD_SEG(ds);
184 RELOAD_SEG(es);
185
186 COPY(di); COPY(si); COPY(bp); COPY(sp); COPY(bx);
187 COPY(dx); COPY(cx); COPY(ip);
188 /* Don't touch extended registers */
189
190 COPY_SEG_CPL3(cs);
191 COPY_SEG_CPL3(ss);
192
193 get_user_ex(tmpflags, &sc->flags);
194 regs->flags = (regs->flags & ~FIX_EFLAGS) | (tmpflags & FIX_EFLAGS);
195 /* disable syscall checks */
196 regs->orig_ax = -1;
197
198 get_user_ex(tmp, &sc->fpstate);
199 buf = compat_ptr(tmp);
200
201 get_user_ex(*pax, &sc->ax);
202 } get_user_catch(err);
203
204 err |= restore_xstate_sig(buf, 1);
205
206 return err;
207 }
208
sys32_sigreturn(void)209 asmlinkage long sys32_sigreturn(void)
210 {
211 struct pt_regs *regs = current_pt_regs();
212 struct sigframe_ia32 __user *frame = (struct sigframe_ia32 __user *)(regs->sp-8);
213 sigset_t set;
214 unsigned int ax;
215
216 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
217 goto badframe;
218 if (__get_user(set.sig[0], &frame->sc.oldmask)
219 || (_COMPAT_NSIG_WORDS > 1
220 && __copy_from_user((((char *) &set.sig) + 4),
221 &frame->extramask,
222 sizeof(frame->extramask))))
223 goto badframe;
224
225 set_current_blocked(&set);
226
227 if (ia32_restore_sigcontext(regs, &frame->sc, &ax))
228 goto badframe;
229 return ax;
230
231 badframe:
232 signal_fault(regs, frame, "32bit sigreturn");
233 return 0;
234 }
235
sys32_rt_sigreturn(void)236 asmlinkage long sys32_rt_sigreturn(void)
237 {
238 struct pt_regs *regs = current_pt_regs();
239 struct rt_sigframe_ia32 __user *frame;
240 sigset_t set;
241 unsigned int ax;
242
243 frame = (struct rt_sigframe_ia32 __user *)(regs->sp - 4);
244
245 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
246 goto badframe;
247 if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
248 goto badframe;
249
250 set_current_blocked(&set);
251
252 if (ia32_restore_sigcontext(regs, &frame->uc.uc_mcontext, &ax))
253 goto badframe;
254
255 if (compat_restore_altstack(&frame->uc.uc_stack))
256 goto badframe;
257
258 return ax;
259
260 badframe:
261 signal_fault(regs, frame, "32bit rt sigreturn");
262 return 0;
263 }
264
265 /*
266 * Set up a signal frame.
267 */
268
ia32_setup_sigcontext(struct sigcontext_ia32 __user * sc,void __user * fpstate,struct pt_regs * regs,unsigned int mask)269 static int ia32_setup_sigcontext(struct sigcontext_ia32 __user *sc,
270 void __user *fpstate,
271 struct pt_regs *regs, unsigned int mask)
272 {
273 int err = 0;
274
275 put_user_try {
276 put_user_ex(get_user_seg(gs), (unsigned int __user *)&sc->gs);
277 put_user_ex(get_user_seg(fs), (unsigned int __user *)&sc->fs);
278 put_user_ex(get_user_seg(ds), (unsigned int __user *)&sc->ds);
279 put_user_ex(get_user_seg(es), (unsigned int __user *)&sc->es);
280
281 put_user_ex(regs->di, &sc->di);
282 put_user_ex(regs->si, &sc->si);
283 put_user_ex(regs->bp, &sc->bp);
284 put_user_ex(regs->sp, &sc->sp);
285 put_user_ex(regs->bx, &sc->bx);
286 put_user_ex(regs->dx, &sc->dx);
287 put_user_ex(regs->cx, &sc->cx);
288 put_user_ex(regs->ax, &sc->ax);
289 put_user_ex(current->thread.trap_nr, &sc->trapno);
290 put_user_ex(current->thread.error_code, &sc->err);
291 put_user_ex(regs->ip, &sc->ip);
292 put_user_ex(regs->cs, (unsigned int __user *)&sc->cs);
293 put_user_ex(regs->flags, &sc->flags);
294 put_user_ex(regs->sp, &sc->sp_at_signal);
295 put_user_ex(regs->ss, (unsigned int __user *)&sc->ss);
296
297 put_user_ex(ptr_to_compat(fpstate), &sc->fpstate);
298
299 /* non-iBCS2 extensions.. */
300 put_user_ex(mask, &sc->oldmask);
301 put_user_ex(current->thread.cr2, &sc->cr2);
302 } put_user_catch(err);
303
304 return err;
305 }
306
307 /*
308 * Determine which stack to use..
309 */
get_sigframe(struct ksignal * ksig,struct pt_regs * regs,size_t frame_size,void __user ** fpstate)310 static void __user *get_sigframe(struct ksignal *ksig, struct pt_regs *regs,
311 size_t frame_size,
312 void __user **fpstate)
313 {
314 unsigned long sp;
315
316 /* Default to using normal stack */
317 sp = regs->sp;
318
319 /* This is the X/Open sanctioned signal stack switching. */
320 if (ksig->ka.sa.sa_flags & SA_ONSTACK)
321 sp = sigsp(sp, ksig);
322 /* This is the legacy signal stack switching. */
323 else if ((regs->ss & 0xffff) != __USER32_DS &&
324 !(ksig->ka.sa.sa_flags & SA_RESTORER) &&
325 ksig->ka.sa.sa_restorer)
326 sp = (unsigned long) ksig->ka.sa.sa_restorer;
327
328 if (used_math()) {
329 unsigned long fx_aligned, math_size;
330
331 sp = alloc_mathframe(sp, 1, &fx_aligned, &math_size);
332 *fpstate = (struct _fpstate_ia32 __user *) sp;
333 if (save_xstate_sig(*fpstate, (void __user *)fx_aligned,
334 math_size) < 0)
335 return (void __user *) -1L;
336 }
337
338 sp -= frame_size;
339 /* Align the stack pointer according to the i386 ABI,
340 * i.e. so that on function entry ((sp + 4) & 15) == 0. */
341 sp = ((sp + 4) & -16ul) - 4;
342 return (void __user *) sp;
343 }
344
ia32_setup_frame(int sig,struct ksignal * ksig,compat_sigset_t * set,struct pt_regs * regs)345 int ia32_setup_frame(int sig, struct ksignal *ksig,
346 compat_sigset_t *set, struct pt_regs *regs)
347 {
348 struct sigframe_ia32 __user *frame;
349 void __user *restorer;
350 int err = 0;
351 void __user *fpstate = NULL;
352
353 /* copy_to_user optimizes that into a single 8 byte store */
354 static const struct {
355 u16 poplmovl;
356 u32 val;
357 u16 int80;
358 } __attribute__((packed)) code = {
359 0xb858, /* popl %eax ; movl $...,%eax */
360 __NR_ia32_sigreturn,
361 0x80cd, /* int $0x80 */
362 };
363
364 frame = get_sigframe(ksig, regs, sizeof(*frame), &fpstate);
365
366 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
367 return -EFAULT;
368
369 if (__put_user(sig, &frame->sig))
370 return -EFAULT;
371
372 if (ia32_setup_sigcontext(&frame->sc, fpstate, regs, set->sig[0]))
373 return -EFAULT;
374
375 if (_COMPAT_NSIG_WORDS > 1) {
376 if (__copy_to_user(frame->extramask, &set->sig[1],
377 sizeof(frame->extramask)))
378 return -EFAULT;
379 }
380
381 if (ksig->ka.sa.sa_flags & SA_RESTORER) {
382 restorer = ksig->ka.sa.sa_restorer;
383 } else {
384 /* Return stub is in 32bit vsyscall page */
385 if (current->mm->context.vdso)
386 restorer = current->mm->context.vdso +
387 selected_vdso32->sym___kernel_sigreturn;
388 else
389 restorer = &frame->retcode;
390 }
391
392 put_user_try {
393 put_user_ex(ptr_to_compat(restorer), &frame->pretcode);
394
395 /*
396 * These are actually not used anymore, but left because some
397 * gdb versions depend on them as a marker.
398 */
399 put_user_ex(*((u64 *)&code), (u64 __user *)frame->retcode);
400 } put_user_catch(err);
401
402 if (err)
403 return -EFAULT;
404
405 /* Set up registers for signal handler */
406 regs->sp = (unsigned long) frame;
407 regs->ip = (unsigned long) ksig->ka.sa.sa_handler;
408
409 /* Make -mregparm=3 work */
410 regs->ax = sig;
411 regs->dx = 0;
412 regs->cx = 0;
413
414 loadsegment(ds, __USER32_DS);
415 loadsegment(es, __USER32_DS);
416
417 regs->cs = __USER32_CS;
418 regs->ss = __USER32_DS;
419
420 return 0;
421 }
422
ia32_setup_rt_frame(int sig,struct ksignal * ksig,compat_sigset_t * set,struct pt_regs * regs)423 int ia32_setup_rt_frame(int sig, struct ksignal *ksig,
424 compat_sigset_t *set, struct pt_regs *regs)
425 {
426 struct rt_sigframe_ia32 __user *frame;
427 void __user *restorer;
428 int err = 0;
429 void __user *fpstate = NULL;
430
431 /* __copy_to_user optimizes that into a single 8 byte store */
432 static const struct {
433 u8 movl;
434 u32 val;
435 u16 int80;
436 u8 pad;
437 } __attribute__((packed)) code = {
438 0xb8,
439 __NR_ia32_rt_sigreturn,
440 0x80cd,
441 0,
442 };
443
444 frame = get_sigframe(ksig, regs, sizeof(*frame), &fpstate);
445
446 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
447 return -EFAULT;
448
449 put_user_try {
450 put_user_ex(sig, &frame->sig);
451 put_user_ex(ptr_to_compat(&frame->info), &frame->pinfo);
452 put_user_ex(ptr_to_compat(&frame->uc), &frame->puc);
453
454 /* Create the ucontext. */
455 if (cpu_has_xsave)
456 put_user_ex(UC_FP_XSTATE, &frame->uc.uc_flags);
457 else
458 put_user_ex(0, &frame->uc.uc_flags);
459 put_user_ex(0, &frame->uc.uc_link);
460 compat_save_altstack_ex(&frame->uc.uc_stack, regs->sp);
461
462 if (ksig->ka.sa.sa_flags & SA_RESTORER)
463 restorer = ksig->ka.sa.sa_restorer;
464 else
465 restorer = current->mm->context.vdso +
466 selected_vdso32->sym___kernel_rt_sigreturn;
467 put_user_ex(ptr_to_compat(restorer), &frame->pretcode);
468
469 /*
470 * Not actually used anymore, but left because some gdb
471 * versions need it.
472 */
473 put_user_ex(*((u64 *)&code), (u64 __user *)frame->retcode);
474 } put_user_catch(err);
475
476 err |= copy_siginfo_to_user32(&frame->info, &ksig->info);
477 err |= ia32_setup_sigcontext(&frame->uc.uc_mcontext, fpstate,
478 regs, set->sig[0]);
479 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
480
481 if (err)
482 return -EFAULT;
483
484 /* Set up registers for signal handler */
485 regs->sp = (unsigned long) frame;
486 regs->ip = (unsigned long) ksig->ka.sa.sa_handler;
487
488 /* Make -mregparm=3 work */
489 regs->ax = sig;
490 regs->dx = (unsigned long) &frame->info;
491 regs->cx = (unsigned long) &frame->uc;
492
493 loadsegment(ds, __USER32_DS);
494 loadsegment(es, __USER32_DS);
495
496 regs->cs = __USER32_CS;
497 regs->ss = __USER32_DS;
498
499 return 0;
500 }
501