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