Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2003 PathScale, Inc. |
| 3 | * Licensed under the GPL |
| 4 | */ |
| 5 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 6 | #include "linux/personality.h" |
| 7 | #include "linux/ptrace.h" |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 8 | #include "asm/unistd.h" |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 9 | #include "asm/uaccess.h" |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 10 | #include "asm/ucontext.h" |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 11 | #include "frame_kern.h" |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 12 | #include "skas.h" |
| 13 | |
Jeff Dike | 77bf440 | 2007-10-16 01:26:58 -0700 | [diff] [blame] | 14 | void copy_sc(struct uml_pt_regs *regs, void *from) |
Jeff Dike | 377fad3 | 2007-05-06 14:51:25 -0700 | [diff] [blame] | 15 | { |
| 16 | struct sigcontext *sc = from; |
| 17 | |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 18 | #define GETREG(regs, regno, sc, regname) \ |
Jeff Dike | 18baddd | 2007-10-16 01:27:07 -0700 | [diff] [blame] | 19 | (regs)->gp[(regno) / sizeof(unsigned long)] = (sc)->regname |
Jeff Dike | 377fad3 | 2007-05-06 14:51:25 -0700 | [diff] [blame] | 20 | |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 21 | 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 Dike | 377fad3 | 2007-05-06 14:51:25 -0700 | [diff] [blame] | 40 | |
| 41 | #undef GETREG |
| 42 | } |
| 43 | |
Jeff Dike | 77bf440 | 2007-10-16 01:26:58 -0700 | [diff] [blame] | 44 | static int copy_sc_from_user(struct pt_regs *regs, |
Jeff Dike | a5f6096 | 2007-10-16 01:27:15 -0700 | [diff] [blame^] | 45 | struct sigcontext __user *from, |
| 46 | struct _fpstate __user *fpp) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 47 | { |
Jeff Dike | a5f6096 | 2007-10-16 01:27:15 -0700 | [diff] [blame^] | 48 | struct user_i387_struct fp; |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 49 | int err = 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 50 | |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 51 | #define GETREG(regs, regno, sc, regname) \ |
Jeff Dike | 18baddd | 2007-10-16 01:27:07 -0700 | [diff] [blame] | 52 | __get_user((regs)->regs.gp[(regno) / sizeof(unsigned long)], \ |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 53 | &(sc)->regname) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 54 | |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 55 | 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 Dike | a5f6096 | 2007-10-16 01:27:15 -0700 | [diff] [blame^] | 74 | if (err) |
| 75 | return 1; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 76 | |
| 77 | #undef GETREG |
| 78 | |
Jeff Dike | a5f6096 | 2007-10-16 01:27:15 -0700 | [diff] [blame^] | 79 | 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 Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 93 | } |
| 94 | |
Jeff Dike | 77bf440 | 2007-10-16 01:26:58 -0700 | [diff] [blame] | 95 | static 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 Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 98 | { |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 99 | struct faultinfo * fi = ¤t->thread.arch.faultinfo; |
Jeff Dike | a5f6096 | 2007-10-16 01:27:15 -0700 | [diff] [blame^] | 100 | struct user_i387_struct fp; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 101 | int err = 0; |
| 102 | |
| 103 | err |= __put_user(0, &to->gs); |
| 104 | err |= __put_user(0, &to->fs); |
| 105 | |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 106 | #define PUTREG(regs, regno, sc, regname) \ |
Jeff Dike | 18baddd | 2007-10-16 01:27:07 -0700 | [diff] [blame] | 107 | __put_user((regs)->regs.gp[(regno) / sizeof(unsigned long)], \ |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 108 | &(sc)->regname) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 109 | |
| 110 | err |= PUTREG(regs, RDI, to, rdi); |
| 111 | err |= PUTREG(regs, RSI, to, rsi); |
| 112 | err |= PUTREG(regs, RBP, to, rbp); |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 113 | /* 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 Dike | 98c1823 | 2006-03-27 01:14:38 -0800 | [diff] [blame] | 117 | err |= __put_user(sp, &to->rsp); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 118 | 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 Stroesser | c578455 | 2005-05-05 16:15:31 -0700 | [diff] [blame] | 131 | |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 132 | 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 Stroesser | c578455 | 2005-05-05 16:15:31 -0700 | [diff] [blame] | 135 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 136 | 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 Dike | a5f6096 | 2007-10-16 01:27:15 -0700 | [diff] [blame^] | 141 | 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 Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 154 | |
| 155 | return(err); |
| 156 | } |
| 157 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 158 | struct rt_sigframe |
| 159 | { |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 160 | char __user *pretcode; |
| 161 | struct ucontext uc; |
| 162 | struct siginfo info; |
Jeff Dike | a5f6096 | 2007-10-16 01:27:15 -0700 | [diff] [blame^] | 163 | struct _fpstate fpstate; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 164 | }; |
| 165 | |
| 166 | #define round_down(m, n) (((m) / (n)) * (n)) |
| 167 | |
| 168 | int 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 Dike | 98c1823 | 2006-03-27 01:14:38 -0800 | [diff] [blame] | 173 | unsigned long save_sp = PT_REGS_RSP(regs); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 174 | int err = 0; |
| 175 | struct task_struct *me = current; |
| 176 | |
| 177 | frame = (struct rt_sigframe __user *) |
Jeff Dike | 3896625 | 2007-01-30 14:36:17 -0800 | [diff] [blame] | 178 | round_down(stack_top - sizeof(struct rt_sigframe), 16); |
| 179 | /* Subtract 128 for a red zone and 8 for proper alignment */ |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 180 | frame = (struct rt_sigframe __user *) ((unsigned long) frame - 128 - 8); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 181 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 182 | 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 Dike | 98c1823 | 2006-03-27 01:14:38 -0800 | [diff] [blame] | 191 | /* 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 Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 201 | /* 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 Dike | 98c1823 | 2006-03-27 01:14:38 -0800 | [diff] [blame] | 205 | err |= __put_user(sas_ss_flags(save_sp), |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 206 | &frame->uc.uc_stack.ss_flags); |
| 207 | err |= __put_user(me->sas_ss_size, &frame->uc.uc_stack.ss_size); |
Jeff Dike | a5f6096 | 2007-10-16 01:27:15 -0700 | [diff] [blame^] | 208 | 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 Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 211 | 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 Dike | 98c1823 | 2006-03-27 01:14:38 -0800 | [diff] [blame] | 226 | goto restore_sp; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 227 | |
| 228 | if (err) |
Jeff Dike | 98c1823 | 2006-03-27 01:14:38 -0800 | [diff] [blame] | 229 | goto restore_sp; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 230 | |
| 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 Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 247 | out: |
Jeff Dike | 98c1823 | 2006-03-27 01:14:38 -0800 | [diff] [blame] | 248 | return err; |
| 249 | |
| 250 | restore_sp: |
| 251 | PT_REGS_RSP(regs) = save_sp; |
| 252 | return err; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 253 | } |
| 254 | |
| 255 | long sys_rt_sigreturn(struct pt_regs *regs) |
| 256 | { |
| 257 | unsigned long sp = PT_REGS_SP(¤t->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 Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 263 | if (copy_from_user(&set, &uc->uc_sigmask, sizeof(set))) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 264 | goto segfault; |
| 265 | |
| 266 | sigdelsetmask(&set, ~_BLOCKABLE); |
| 267 | |
| 268 | spin_lock_irq(¤t->sighand->siglock); |
| 269 | current->blocked = set; |
| 270 | recalc_sigpending(); |
| 271 | spin_unlock_irq(¤t->sighand->siglock); |
| 272 | |
Jeff Dike | a5f6096 | 2007-10-16 01:27:15 -0700 | [diff] [blame^] | 273 | if (copy_sc_from_user(¤t->thread.regs, &uc->uc_mcontext, |
| 274 | &frame->fpstate)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 275 | goto segfault; |
| 276 | |
| 277 | /* Avoid ERESTART handling */ |
| 278 | PT_REGS_SYSCALL_NR(¤t->thread.regs) = -1; |
| 279 | return(PT_REGS_SYSCALL_RET(¤t->thread.regs)); |
| 280 | |
| 281 | segfault: |
| 282 | force_sig(SIGSEGV, current); |
| 283 | return 0; |
| 284 | } |