blob: a8e5fd7b2adbe44a99ef1c6fe873af0d3da3d45d [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Copyright (C) 2003 PathScale, Inc.
3 * Licensed under the GPL
4 */
5
Linus Torvalds1da177e2005-04-16 15:20:36 -07006#include "linux/personality.h"
7#include "linux/ptrace.h"
Jeff Dikeba180fd2007-10-16 01:27:00 -07008#include "asm/unistd.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -07009#include "asm/uaccess.h"
Jeff Dikeba180fd2007-10-16 01:27:00 -070010#include "asm/ucontext.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070011#include "frame_kern.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070012#include "skas.h"
13
Jeff Dike77bf4402007-10-16 01:26:58 -070014void copy_sc(struct uml_pt_regs *regs, void *from)
Jeff Dike377fad32007-05-06 14:51:25 -070015{
16 struct sigcontext *sc = from;
17
Jeff Dikeba180fd2007-10-16 01:27:00 -070018#define GETREG(regs, regno, sc, regname) \
Jeff Dike18baddd2007-10-16 01:27:07 -070019 (regs)->gp[(regno) / sizeof(unsigned long)] = (sc)->regname
Jeff Dike377fad32007-05-06 14:51:25 -070020
Jeff Dikeba180fd2007-10-16 01:27:00 -070021 GETREG(regs, R8, sc, r8);
22 GETREG(regs, R9, sc, r9);
23 GETREG(regs, R10, sc, r10);
24 GETREG(regs, R11, sc, r11);
25 GETREG(regs, R12, sc, r12);
26 GETREG(regs, R13, sc, r13);
27 GETREG(regs, R14, sc, r14);
28 GETREG(regs, R15, sc, r15);
29 GETREG(regs, RDI, sc, rdi);
30 GETREG(regs, RSI, sc, rsi);
31 GETREG(regs, RBP, sc, rbp);
32 GETREG(regs, RBX, sc, rbx);
33 GETREG(regs, RDX, sc, rdx);
34 GETREG(regs, RAX, sc, rax);
35 GETREG(regs, RCX, sc, rcx);
36 GETREG(regs, RSP, sc, rsp);
37 GETREG(regs, RIP, sc, rip);
38 GETREG(regs, EFLAGS, sc, eflags);
39 GETREG(regs, CS, sc, cs);
Jeff Dike377fad32007-05-06 14:51:25 -070040
41#undef GETREG
42}
43
Jeff Dike77bf4402007-10-16 01:26:58 -070044static int copy_sc_from_user(struct pt_regs *regs,
Jeff Dikea5f60962007-10-16 01:27:15 -070045 struct sigcontext __user *from,
46 struct _fpstate __user *fpp)
Linus Torvalds1da177e2005-04-16 15:20:36 -070047{
Jeff Dikea5f60962007-10-16 01:27:15 -070048 struct user_i387_struct fp;
Jeff Dikeba180fd2007-10-16 01:27:00 -070049 int err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070050
Jeff Dikeba180fd2007-10-16 01:27:00 -070051#define GETREG(regs, regno, sc, regname) \
Jeff Dike18baddd2007-10-16 01:27:07 -070052 __get_user((regs)->regs.gp[(regno) / sizeof(unsigned long)], \
Jeff Dikeba180fd2007-10-16 01:27:00 -070053 &(sc)->regname)
Linus Torvalds1da177e2005-04-16 15:20:36 -070054
Jeff Dikeba180fd2007-10-16 01:27:00 -070055 err |= GETREG(regs, R8, from, r8);
56 err |= GETREG(regs, R9, from, r9);
57 err |= GETREG(regs, R10, from, r10);
58 err |= GETREG(regs, R11, from, r11);
59 err |= GETREG(regs, R12, from, r12);
60 err |= GETREG(regs, R13, from, r13);
61 err |= GETREG(regs, R14, from, r14);
62 err |= GETREG(regs, R15, from, r15);
63 err |= GETREG(regs, RDI, from, rdi);
64 err |= GETREG(regs, RSI, from, rsi);
65 err |= GETREG(regs, RBP, from, rbp);
66 err |= GETREG(regs, RBX, from, rbx);
67 err |= GETREG(regs, RDX, from, rdx);
68 err |= GETREG(regs, RAX, from, rax);
69 err |= GETREG(regs, RCX, from, rcx);
70 err |= GETREG(regs, RSP, from, rsp);
71 err |= GETREG(regs, RIP, from, rip);
72 err |= GETREG(regs, EFLAGS, from, eflags);
73 err |= GETREG(regs, CS, from, cs);
Jeff Dikea5f60962007-10-16 01:27:15 -070074 if (err)
75 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -070076
77#undef GETREG
78
Jeff Dikea5f60962007-10-16 01:27:15 -070079 err = copy_from_user(&fp, fpp, sizeof(struct user_i387_struct));
80 if (err)
81 return 1;
82
83 err = restore_fp_registers(userspace_pid[current_thread->cpu],
84 (unsigned long *) &fp);
85 if (err < 0) {
86 printk(KERN_ERR "copy_sc_from_user - "
87 "restore_fp_registers failed, errno = %d\n",
88 -err);
89 return 1;
90 }
91
92 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070093}
94
Jeff Dike77bf4402007-10-16 01:26:58 -070095static int copy_sc_to_user(struct sigcontext __user *to,
96 struct _fpstate __user *to_fp, struct pt_regs *regs,
97 unsigned long mask, unsigned long sp)
Linus Torvalds1da177e2005-04-16 15:20:36 -070098{
Jeff Dikeba180fd2007-10-16 01:27:00 -070099 struct faultinfo * fi = &current->thread.arch.faultinfo;
Jeff Dikea5f60962007-10-16 01:27:15 -0700100 struct user_i387_struct fp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101 int err = 0;
102
103 err |= __put_user(0, &to->gs);
104 err |= __put_user(0, &to->fs);
105
Jeff Dikeba180fd2007-10-16 01:27:00 -0700106#define PUTREG(regs, regno, sc, regname) \
Jeff Dike18baddd2007-10-16 01:27:07 -0700107 __put_user((regs)->regs.gp[(regno) / sizeof(unsigned long)], \
Jeff Dikeba180fd2007-10-16 01:27:00 -0700108 &(sc)->regname)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109
110 err |= PUTREG(regs, RDI, to, rdi);
111 err |= PUTREG(regs, RSI, to, rsi);
112 err |= PUTREG(regs, RBP, to, rbp);
Jeff Dikeba180fd2007-10-16 01:27:00 -0700113 /* Must use orignal RSP, which is passed in, rather than what's in
114 * the pt_regs, because that's already been updated to point at the
115 * signal frame.
116 */
Jeff Dike98c18232006-03-27 01:14:38 -0800117 err |= __put_user(sp, &to->rsp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118 err |= PUTREG(regs, RBX, to, rbx);
119 err |= PUTREG(regs, RDX, to, rdx);
120 err |= PUTREG(regs, RCX, to, rcx);
121 err |= PUTREG(regs, RAX, to, rax);
122 err |= PUTREG(regs, R8, to, r8);
123 err |= PUTREG(regs, R9, to, r9);
124 err |= PUTREG(regs, R10, to, r10);
125 err |= PUTREG(regs, R11, to, r11);
126 err |= PUTREG(regs, R12, to, r12);
127 err |= PUTREG(regs, R13, to, r13);
128 err |= PUTREG(regs, R14, to, r14);
129 err |= PUTREG(regs, R15, to, r15);
130 err |= PUTREG(regs, CS, to, cs); /* XXX x86_64 doesn't do this */
Bodo Stroesserc5784552005-05-05 16:15:31 -0700131
Jeff Dikeba180fd2007-10-16 01:27:00 -0700132 err |= __put_user(fi->cr2, &to->cr2);
133 err |= __put_user(fi->error_code, &to->err);
134 err |= __put_user(fi->trap_no, &to->trapno);
Bodo Stroesserc5784552005-05-05 16:15:31 -0700135
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136 err |= PUTREG(regs, RIP, to, rip);
137 err |= PUTREG(regs, EFLAGS, to, eflags);
138#undef PUTREG
139
140 err |= __put_user(mask, &to->oldmask);
Jeff Dikea5f60962007-10-16 01:27:15 -0700141 if (err)
142 return 1;
143
144 err = save_fp_registers(userspace_pid[current_thread->cpu],
145 (unsigned long *) &fp);
146 if (err < 0) {
147 printk(KERN_ERR "copy_sc_from_user - restore_fp_registers "
148 "failed, errno = %d\n", -err);
149 return 1;
150 }
151
152 if (copy_to_user(to_fp, &fp, sizeof(struct user_i387_struct)))
153 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154
155 return(err);
156}
157
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158struct rt_sigframe
159{
Jeff Dikeba180fd2007-10-16 01:27:00 -0700160 char __user *pretcode;
161 struct ucontext uc;
162 struct siginfo info;
Jeff Dikea5f60962007-10-16 01:27:15 -0700163 struct _fpstate fpstate;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164};
165
166#define round_down(m, n) (((m) / (n)) * (n))
167
168int setup_signal_stack_si(unsigned long stack_top, int sig,
169 struct k_sigaction *ka, struct pt_regs * regs,
170 siginfo_t *info, sigset_t *set)
171{
172 struct rt_sigframe __user *frame;
Jeff Dike98c18232006-03-27 01:14:38 -0800173 unsigned long save_sp = PT_REGS_RSP(regs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174 int err = 0;
175 struct task_struct *me = current;
176
177 frame = (struct rt_sigframe __user *)
Jeff Dike38966252007-01-30 14:36:17 -0800178 round_down(stack_top - sizeof(struct rt_sigframe), 16);
179 /* Subtract 128 for a red zone and 8 for proper alignment */
Jeff Dikeba180fd2007-10-16 01:27:00 -0700180 frame = (struct rt_sigframe __user *) ((unsigned long) frame - 128 - 8);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
183 goto out;
184
185 if (ka->sa.sa_flags & SA_SIGINFO) {
186 err |= copy_siginfo_to_user(&frame->info, info);
187 if (err)
188 goto out;
189 }
190
Jeff Dike98c18232006-03-27 01:14:38 -0800191 /* Update SP now because the page fault handler refuses to extend
192 * the stack if the faulting address is too far below the current
193 * SP, which frame now certainly is. If there's an error, the original
194 * value is restored on the way out.
195 * When writing the sigcontext to the stack, we have to write the
196 * original value, so that's passed to copy_sc_to_user, which does
197 * the right thing with it.
198 */
199 PT_REGS_RSP(regs) = (unsigned long) frame;
200
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201 /* Create the ucontext. */
202 err |= __put_user(0, &frame->uc.uc_flags);
203 err |= __put_user(0, &frame->uc.uc_link);
204 err |= __put_user(me->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
Jeff Dike98c18232006-03-27 01:14:38 -0800205 err |= __put_user(sas_ss_flags(save_sp),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206 &frame->uc.uc_stack.ss_flags);
207 err |= __put_user(me->sas_ss_size, &frame->uc.uc_stack.ss_size);
Jeff Dikea5f60962007-10-16 01:27:15 -0700208 err |= copy_sc_to_user(&frame->uc.uc_mcontext, &frame->fpstate, regs,
209 set->sig[0], save_sp);
210 err |= __put_user(&frame->fpstate, &frame->uc.uc_mcontext.fpstate);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211 if (sizeof(*set) == 16) {
212 __put_user(set->sig[0], &frame->uc.uc_sigmask.sig[0]);
213 __put_user(set->sig[1], &frame->uc.uc_sigmask.sig[1]);
214 }
215 else
216 err |= __copy_to_user(&frame->uc.uc_sigmask, set,
217 sizeof(*set));
218
219 /* Set up to return from userspace. If provided, use a stub
220 already in userspace. */
221 /* x86-64 should always use SA_RESTORER. */
222 if (ka->sa.sa_flags & SA_RESTORER)
223 err |= __put_user(ka->sa.sa_restorer, &frame->pretcode);
224 else
225 /* could use a vstub here */
Jeff Dike98c18232006-03-27 01:14:38 -0800226 goto restore_sp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227
228 if (err)
Jeff Dike98c18232006-03-27 01:14:38 -0800229 goto restore_sp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230
231 /* Set up registers for signal handler */
232 {
233 struct exec_domain *ed = current_thread_info()->exec_domain;
234 if (unlikely(ed && ed->signal_invmap && sig < 32))
235 sig = ed->signal_invmap[sig];
236 }
237
238 PT_REGS_RDI(regs) = sig;
239 /* In case the signal handler was declared without prototypes */
240 PT_REGS_RAX(regs) = 0;
241
242 /* This also works for non SA_SIGINFO handlers because they expect the
243 next argument after the signal number on the stack. */
244 PT_REGS_RSI(regs) = (unsigned long) &frame->info;
245 PT_REGS_RDX(regs) = (unsigned long) &frame->uc;
246 PT_REGS_RIP(regs) = (unsigned long) ka->sa.sa_handler;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247 out:
Jeff Dike98c18232006-03-27 01:14:38 -0800248 return err;
249
250restore_sp:
251 PT_REGS_RSP(regs) = save_sp;
252 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253}
254
255long sys_rt_sigreturn(struct pt_regs *regs)
256{
257 unsigned long sp = PT_REGS_SP(&current->thread.regs);
258 struct rt_sigframe __user *frame =
259 (struct rt_sigframe __user *)(sp - 8);
260 struct ucontext __user *uc = &frame->uc;
261 sigset_t set;
262
Jeff Dikeba180fd2007-10-16 01:27:00 -0700263 if (copy_from_user(&set, &uc->uc_sigmask, sizeof(set)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264 goto segfault;
265
266 sigdelsetmask(&set, ~_BLOCKABLE);
267
268 spin_lock_irq(&current->sighand->siglock);
269 current->blocked = set;
270 recalc_sigpending();
271 spin_unlock_irq(&current->sighand->siglock);
272
Jeff Dikea5f60962007-10-16 01:27:15 -0700273 if (copy_sc_from_user(&current->thread.regs, &uc->uc_mcontext,
274 &frame->fpstate))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275 goto segfault;
276
277 /* Avoid ERESTART handling */
278 PT_REGS_SYSCALL_NR(&current->thread.regs) = -1;
279 return(PT_REGS_SYSCALL_RET(&current->thread.regs));
280
281 segfault:
282 force_sig(SIGSEGV, current);
283 return 0;
284}