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