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 | |
| 6 | #include "linux/stddef.h" |
| 7 | #include "linux/errno.h" |
| 8 | #include "linux/personality.h" |
| 9 | #include "linux/ptrace.h" |
| 10 | #include "asm/current.h" |
| 11 | #include "asm/uaccess.h" |
| 12 | #include "asm/sigcontext.h" |
| 13 | #include "asm/ptrace.h" |
| 14 | #include "asm/arch/ucontext.h" |
| 15 | #include "choose-mode.h" |
| 16 | #include "sysdep/ptrace.h" |
| 17 | #include "frame_kern.h" |
| 18 | |
| 19 | #ifdef CONFIG_MODE_SKAS |
| 20 | |
| 21 | #include "skas.h" |
| 22 | |
| 23 | static int copy_sc_from_user_skas(struct pt_regs *regs, |
Al Viro | b8719c3 | 2006-06-04 02:51:48 -0700 | [diff] [blame] | 24 | struct sigcontext __user *from) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 25 | { |
| 26 | int err = 0; |
| 27 | |
| 28 | #define GETREG(regs, regno, sc, regname) \ |
| 29 | __get_user((regs)->regs.skas.regs[(regno) / sizeof(unsigned long)], \ |
| 30 | &(sc)->regname) |
| 31 | |
| 32 | err |= GETREG(regs, R8, from, r8); |
| 33 | err |= GETREG(regs, R9, from, r9); |
| 34 | err |= GETREG(regs, R10, from, r10); |
| 35 | err |= GETREG(regs, R11, from, r11); |
| 36 | err |= GETREG(regs, R12, from, r12); |
| 37 | err |= GETREG(regs, R13, from, r13); |
| 38 | err |= GETREG(regs, R14, from, r14); |
| 39 | err |= GETREG(regs, R15, from, r15); |
| 40 | err |= GETREG(regs, RDI, from, rdi); |
| 41 | err |= GETREG(regs, RSI, from, rsi); |
| 42 | err |= GETREG(regs, RBP, from, rbp); |
| 43 | err |= GETREG(regs, RBX, from, rbx); |
| 44 | err |= GETREG(regs, RDX, from, rdx); |
| 45 | err |= GETREG(regs, RAX, from, rax); |
| 46 | err |= GETREG(regs, RCX, from, rcx); |
| 47 | err |= GETREG(regs, RSP, from, rsp); |
| 48 | err |= GETREG(regs, RIP, from, rip); |
| 49 | err |= GETREG(regs, EFLAGS, from, eflags); |
| 50 | err |= GETREG(regs, CS, from, cs); |
| 51 | |
| 52 | #undef GETREG |
| 53 | |
| 54 | return(err); |
| 55 | } |
| 56 | |
Al Viro | b8719c3 | 2006-06-04 02:51:48 -0700 | [diff] [blame] | 57 | int copy_sc_to_user_skas(struct sigcontext __user *to, |
| 58 | struct _fpstate __user *to_fp, |
Jeff Dike | 98c1823 | 2006-03-27 01:14:38 -0800 | [diff] [blame] | 59 | struct pt_regs *regs, unsigned long mask, |
| 60 | unsigned long sp) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 61 | { |
Bodo Stroesser | c578455 | 2005-05-05 16:15:31 -0700 | [diff] [blame] | 62 | struct faultinfo * fi = ¤t->thread.arch.faultinfo; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 63 | int err = 0; |
| 64 | |
| 65 | err |= __put_user(0, &to->gs); |
| 66 | err |= __put_user(0, &to->fs); |
| 67 | |
| 68 | #define PUTREG(regs, regno, sc, regname) \ |
| 69 | __put_user((regs)->regs.skas.regs[(regno) / sizeof(unsigned long)], \ |
| 70 | &(sc)->regname) |
| 71 | |
| 72 | err |= PUTREG(regs, RDI, to, rdi); |
| 73 | err |= PUTREG(regs, RSI, to, rsi); |
| 74 | err |= PUTREG(regs, RBP, to, rbp); |
Jeff Dike | 98c1823 | 2006-03-27 01:14:38 -0800 | [diff] [blame] | 75 | /* Must use orignal RSP, which is passed in, rather than what's in |
| 76 | * the pt_regs, because that's already been updated to point at the |
| 77 | * signal frame. |
| 78 | */ |
| 79 | err |= __put_user(sp, &to->rsp); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 80 | err |= PUTREG(regs, RBX, to, rbx); |
| 81 | err |= PUTREG(regs, RDX, to, rdx); |
| 82 | err |= PUTREG(regs, RCX, to, rcx); |
| 83 | err |= PUTREG(regs, RAX, to, rax); |
| 84 | err |= PUTREG(regs, R8, to, r8); |
| 85 | err |= PUTREG(regs, R9, to, r9); |
| 86 | err |= PUTREG(regs, R10, to, r10); |
| 87 | err |= PUTREG(regs, R11, to, r11); |
| 88 | err |= PUTREG(regs, R12, to, r12); |
| 89 | err |= PUTREG(regs, R13, to, r13); |
| 90 | err |= PUTREG(regs, R14, to, r14); |
| 91 | err |= PUTREG(regs, R15, to, r15); |
| 92 | 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] | 93 | |
| 94 | err |= __put_user(fi->cr2, &to->cr2); |
| 95 | err |= __put_user(fi->error_code, &to->err); |
| 96 | err |= __put_user(fi->trap_no, &to->trapno); |
| 97 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 98 | err |= PUTREG(regs, RIP, to, rip); |
| 99 | err |= PUTREG(regs, EFLAGS, to, eflags); |
| 100 | #undef PUTREG |
| 101 | |
| 102 | err |= __put_user(mask, &to->oldmask); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 103 | |
| 104 | return(err); |
| 105 | } |
| 106 | |
| 107 | #endif |
| 108 | |
| 109 | #ifdef CONFIG_MODE_TT |
Al Viro | b8719c3 | 2006-06-04 02:51:48 -0700 | [diff] [blame] | 110 | int copy_sc_from_user_tt(struct sigcontext *to, struct sigcontext __user *from, |
Jeff Dike | 98c1823 | 2006-03-27 01:14:38 -0800 | [diff] [blame] | 111 | int fpsize) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 112 | { |
Al Viro | b8719c3 | 2006-06-04 02:51:48 -0700 | [diff] [blame] | 113 | struct _fpstate *to_fp; |
| 114 | struct _fpstate __user *from_fp; |
Al Viro | e54a5df | 2005-09-03 15:57:27 -0700 | [diff] [blame] | 115 | unsigned long sigs; |
| 116 | int err; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 117 | |
Al Viro | e54a5df | 2005-09-03 15:57:27 -0700 | [diff] [blame] | 118 | to_fp = to->fpstate; |
| 119 | sigs = to->oldmask; |
| 120 | err = copy_from_user(to, from, sizeof(*to)); |
| 121 | from_fp = to->fpstate; |
| 122 | to->fpstate = to_fp; |
| 123 | to->oldmask = sigs; |
| 124 | if(to_fp != NULL) |
| 125 | err |= copy_from_user(to_fp, from_fp, fpsize); |
| 126 | return(err); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 127 | } |
| 128 | |
Al Viro | b8719c3 | 2006-06-04 02:51:48 -0700 | [diff] [blame] | 129 | int copy_sc_to_user_tt(struct sigcontext __user *to, struct _fpstate __user *fp, |
Jeff Dike | 98c1823 | 2006-03-27 01:14:38 -0800 | [diff] [blame] | 130 | struct sigcontext *from, int fpsize, unsigned long sp) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 131 | { |
Al Viro | b8719c3 | 2006-06-04 02:51:48 -0700 | [diff] [blame] | 132 | struct _fpstate __user *to_fp; |
| 133 | struct _fpstate *from_fp; |
Al Viro | e54a5df | 2005-09-03 15:57:27 -0700 | [diff] [blame] | 134 | int err; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 135 | |
Al Viro | b8719c3 | 2006-06-04 02:51:48 -0700 | [diff] [blame] | 136 | to_fp = (fp ? fp : (struct _fpstate __user *) (to + 1)); |
Al Viro | e54a5df | 2005-09-03 15:57:27 -0700 | [diff] [blame] | 137 | from_fp = from->fpstate; |
| 138 | err = copy_to_user(to, from, sizeof(*to)); |
Jeff Dike | 98c1823 | 2006-03-27 01:14:38 -0800 | [diff] [blame] | 139 | /* The SP in the sigcontext is the updated one for the signal |
| 140 | * delivery. The sp passed in is the original, and this needs |
| 141 | * to be restored, so we stick it in separately. |
| 142 | */ |
Paolo 'Blaisorblade' Giarrusso | f53389d | 2006-04-10 22:53:34 -0700 | [diff] [blame] | 143 | err |= copy_to_user(&SC_SP(to), &sp, sizeof(sp)); |
Jeff Dike | 98c1823 | 2006-03-27 01:14:38 -0800 | [diff] [blame] | 144 | |
Al Viro | e54a5df | 2005-09-03 15:57:27 -0700 | [diff] [blame] | 145 | if(from_fp != NULL){ |
| 146 | err |= copy_to_user(&to->fpstate, &to_fp, sizeof(to->fpstate)); |
| 147 | err |= copy_to_user(to_fp, from_fp, fpsize); |
| 148 | } |
Jeff Dike | 98c1823 | 2006-03-27 01:14:38 -0800 | [diff] [blame] | 149 | return err; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 150 | } |
| 151 | |
| 152 | #endif |
| 153 | |
| 154 | static int copy_sc_from_user(struct pt_regs *to, void __user *from) |
| 155 | { |
| 156 | int ret; |
| 157 | |
| 158 | ret = CHOOSE_MODE(copy_sc_from_user_tt(UPT_SC(&to->regs), from, |
| 159 | sizeof(struct _fpstate)), |
| 160 | copy_sc_from_user_skas(to, from)); |
| 161 | return(ret); |
| 162 | } |
| 163 | |
Al Viro | b8719c3 | 2006-06-04 02:51:48 -0700 | [diff] [blame] | 164 | static int copy_sc_to_user(struct sigcontext __user *to, |
| 165 | struct _fpstate __user *fp, |
Jeff Dike | 98c1823 | 2006-03-27 01:14:38 -0800 | [diff] [blame] | 166 | struct pt_regs *from, unsigned long mask, |
| 167 | unsigned long sp) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 168 | { |
| 169 | return(CHOOSE_MODE(copy_sc_to_user_tt(to, fp, UPT_SC(&from->regs), |
Jeff Dike | 98c1823 | 2006-03-27 01:14:38 -0800 | [diff] [blame] | 170 | sizeof(*fp), sp), |
| 171 | copy_sc_to_user_skas(to, fp, from, mask, sp))); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 172 | } |
| 173 | |
| 174 | struct rt_sigframe |
| 175 | { |
Al Viro | b8719c3 | 2006-06-04 02:51:48 -0700 | [diff] [blame] | 176 | char __user *pretcode; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 177 | struct ucontext uc; |
| 178 | struct siginfo info; |
| 179 | }; |
| 180 | |
| 181 | #define round_down(m, n) (((m) / (n)) * (n)) |
| 182 | |
| 183 | int setup_signal_stack_si(unsigned long stack_top, int sig, |
| 184 | struct k_sigaction *ka, struct pt_regs * regs, |
| 185 | siginfo_t *info, sigset_t *set) |
| 186 | { |
| 187 | struct rt_sigframe __user *frame; |
| 188 | struct _fpstate __user *fp = NULL; |
Jeff Dike | 98c1823 | 2006-03-27 01:14:38 -0800 | [diff] [blame] | 189 | unsigned long save_sp = PT_REGS_RSP(regs); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 190 | int err = 0; |
| 191 | struct task_struct *me = current; |
| 192 | |
| 193 | frame = (struct rt_sigframe __user *) |
| 194 | round_down(stack_top - sizeof(struct rt_sigframe), 16) - 8; |
Al Viro | b8719c3 | 2006-06-04 02:51:48 -0700 | [diff] [blame] | 195 | frame = (struct rt_sigframe __user *) ((unsigned long) frame - 128); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 196 | |
| 197 | if (!access_ok(VERIFY_WRITE, fp, sizeof(struct _fpstate))) |
| 198 | goto out; |
| 199 | |
| 200 | #if 0 /* XXX */ |
| 201 | if (save_i387(fp) < 0) |
| 202 | err |= -1; |
| 203 | #endif |
| 204 | if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame))) |
| 205 | goto out; |
| 206 | |
| 207 | if (ka->sa.sa_flags & SA_SIGINFO) { |
| 208 | err |= copy_siginfo_to_user(&frame->info, info); |
| 209 | if (err) |
| 210 | goto out; |
| 211 | } |
| 212 | |
Jeff Dike | 98c1823 | 2006-03-27 01:14:38 -0800 | [diff] [blame] | 213 | /* Update SP now because the page fault handler refuses to extend |
| 214 | * the stack if the faulting address is too far below the current |
| 215 | * SP, which frame now certainly is. If there's an error, the original |
| 216 | * value is restored on the way out. |
| 217 | * When writing the sigcontext to the stack, we have to write the |
| 218 | * original value, so that's passed to copy_sc_to_user, which does |
| 219 | * the right thing with it. |
| 220 | */ |
| 221 | PT_REGS_RSP(regs) = (unsigned long) frame; |
| 222 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 223 | /* Create the ucontext. */ |
| 224 | err |= __put_user(0, &frame->uc.uc_flags); |
| 225 | err |= __put_user(0, &frame->uc.uc_link); |
| 226 | 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] | 227 | err |= __put_user(sas_ss_flags(save_sp), |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 228 | &frame->uc.uc_stack.ss_flags); |
| 229 | err |= __put_user(me->sas_ss_size, &frame->uc.uc_stack.ss_size); |
Jeff Dike | 98c1823 | 2006-03-27 01:14:38 -0800 | [diff] [blame] | 230 | err |= copy_sc_to_user(&frame->uc.uc_mcontext, fp, regs, set->sig[0], |
| 231 | save_sp); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 232 | err |= __put_user(fp, &frame->uc.uc_mcontext.fpstate); |
| 233 | if (sizeof(*set) == 16) { |
| 234 | __put_user(set->sig[0], &frame->uc.uc_sigmask.sig[0]); |
| 235 | __put_user(set->sig[1], &frame->uc.uc_sigmask.sig[1]); |
| 236 | } |
| 237 | else |
| 238 | err |= __copy_to_user(&frame->uc.uc_sigmask, set, |
| 239 | sizeof(*set)); |
| 240 | |
| 241 | /* Set up to return from userspace. If provided, use a stub |
| 242 | already in userspace. */ |
| 243 | /* x86-64 should always use SA_RESTORER. */ |
| 244 | if (ka->sa.sa_flags & SA_RESTORER) |
| 245 | err |= __put_user(ka->sa.sa_restorer, &frame->pretcode); |
| 246 | else |
| 247 | /* could use a vstub here */ |
Jeff Dike | 98c1823 | 2006-03-27 01:14:38 -0800 | [diff] [blame] | 248 | goto restore_sp; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 249 | |
| 250 | if (err) |
Jeff Dike | 98c1823 | 2006-03-27 01:14:38 -0800 | [diff] [blame] | 251 | goto restore_sp; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 252 | |
| 253 | /* Set up registers for signal handler */ |
| 254 | { |
| 255 | struct exec_domain *ed = current_thread_info()->exec_domain; |
| 256 | if (unlikely(ed && ed->signal_invmap && sig < 32)) |
| 257 | sig = ed->signal_invmap[sig]; |
| 258 | } |
| 259 | |
| 260 | PT_REGS_RDI(regs) = sig; |
| 261 | /* In case the signal handler was declared without prototypes */ |
| 262 | PT_REGS_RAX(regs) = 0; |
| 263 | |
| 264 | /* This also works for non SA_SIGINFO handlers because they expect the |
| 265 | next argument after the signal number on the stack. */ |
| 266 | PT_REGS_RSI(regs) = (unsigned long) &frame->info; |
| 267 | PT_REGS_RDX(regs) = (unsigned long) &frame->uc; |
| 268 | PT_REGS_RIP(regs) = (unsigned long) ka->sa.sa_handler; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 269 | out: |
Jeff Dike | 98c1823 | 2006-03-27 01:14:38 -0800 | [diff] [blame] | 270 | return err; |
| 271 | |
| 272 | restore_sp: |
| 273 | PT_REGS_RSP(regs) = save_sp; |
| 274 | return err; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 275 | } |
| 276 | |
| 277 | long sys_rt_sigreturn(struct pt_regs *regs) |
| 278 | { |
| 279 | unsigned long sp = PT_REGS_SP(¤t->thread.regs); |
| 280 | struct rt_sigframe __user *frame = |
| 281 | (struct rt_sigframe __user *)(sp - 8); |
| 282 | struct ucontext __user *uc = &frame->uc; |
| 283 | sigset_t set; |
| 284 | |
| 285 | if(copy_from_user(&set, &uc->uc_sigmask, sizeof(set))) |
| 286 | goto segfault; |
| 287 | |
| 288 | sigdelsetmask(&set, ~_BLOCKABLE); |
| 289 | |
| 290 | spin_lock_irq(¤t->sighand->siglock); |
| 291 | current->blocked = set; |
| 292 | recalc_sigpending(); |
| 293 | spin_unlock_irq(¤t->sighand->siglock); |
| 294 | |
| 295 | if(copy_sc_from_user(¤t->thread.regs, &uc->uc_mcontext)) |
| 296 | goto segfault; |
| 297 | |
| 298 | /* Avoid ERESTART handling */ |
| 299 | PT_REGS_SYSCALL_NR(¤t->thread.regs) = -1; |
| 300 | return(PT_REGS_SYSCALL_RET(¤t->thread.regs)); |
| 301 | |
| 302 | segfault: |
| 303 | force_sig(SIGSEGV, current); |
| 304 | return 0; |
| 305 | } |
| 306 | /* |
| 307 | * Overrides for Emacs so that we follow Linus's tabbing style. |
| 308 | * Emacs will notice this stuff at the end of the file and automatically |
| 309 | * adjust the settings for this buffer only. This must remain at the end |
| 310 | * of the file. |
| 311 | * --------------------------------------------------------------------------- |
| 312 | * Local variables: |
| 313 | * c-file-style: "linux" |
| 314 | * End: |
| 315 | */ |