1 /* 2 * Copyright (C) 2003 PathScale, Inc. 3 * Copyright (C) 2003 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com) 4 * Licensed under the GPL 5 */ 6 7 8 #include <linux/personality.h> 9 #include <linux/ptrace.h> 10 #include <linux/kernel.h> 11 #include <linux/syscalls.h> 12 #include <asm/unistd.h> 13 #include <linux/uaccess.h> 14 #include <asm/ucontext.h> 15 #include <frame_kern.h> 16 #include <registers.h> 17 #include <skas.h> 18 19 #include <linux/regset.h> 20 #include <asm/sigframe.h> 21 22 #ifdef CONFIG_X86_32 23 struct _xstate_64 { 24 struct _fpstate_64 fpstate; 25 struct _header xstate_hdr; 26 struct _ymmh_state ymmh; 27 /* New processor state extensions go here: */ 28 }; 29 #else 30 #define _xstate_64 _xstate 31 #endif 32 33 static int copy_sc_from_user(struct pt_regs *regs, 34 struct sigcontext __user *from) 35 { 36 struct _xstate_64 __user *from_fp64; 37 struct sigcontext sc; 38 int err; 39 40 /* Always make any pending restarted system calls return -EINTR */ 41 current->restart_block.fn = do_no_restart_syscall; 42 43 err = copy_from_user(&sc, from, sizeof(sc)); 44 if (err) 45 return err; 46 47 #define GETREG(regno, regname) regs->regs.gp[HOST_##regno] = sc.regname 48 49 #ifdef CONFIG_X86_32 50 GETREG(GS, gs); 51 GETREG(FS, fs); 52 GETREG(ES, es); 53 GETREG(DS, ds); 54 #endif 55 GETREG(DI, di); 56 GETREG(SI, si); 57 GETREG(BP, bp); 58 GETREG(SP, sp); 59 GETREG(BX, bx); 60 GETREG(DX, dx); 61 GETREG(CX, cx); 62 GETREG(AX, ax); 63 GETREG(IP, ip); 64 65 #ifdef CONFIG_X86_64 66 GETREG(R8, r8); 67 GETREG(R9, r9); 68 GETREG(R10, r10); 69 GETREG(R11, r11); 70 GETREG(R12, r12); 71 GETREG(R13, r13); 72 GETREG(R14, r14); 73 GETREG(R15, r15); 74 #endif 75 76 GETREG(CS, cs); 77 GETREG(EFLAGS, flags); 78 #ifdef CONFIG_X86_32 79 GETREG(SS, ss); 80 #endif 81 82 #undef GETREG 83 84 #ifdef CONFIG_X86_32 85 from_fp64 = ((void __user *)sc.fpstate) + 86 offsetof(struct _fpstate_32, _fxsr_env); 87 #else 88 from_fp64 = (void __user *)sc.fpstate; 89 #endif 90 91 err = copy_from_user(regs->regs.fp, from_fp64, host_fp_size); 92 if (err) 93 return 1; 94 95 #ifdef CONFIG_X86_32 96 /* Data is duplicated and this copy is the important one */ 97 err = copy_regset_from_user(current, 98 task_user_regset_view(current), 99 REGSET_FP_LEGACY, 0, 100 sizeof(struct user_i387_struct), 101 (void __user *)sc.fpstate); 102 if (err < 0) 103 return err; 104 #endif 105 106 return 0; 107 } 108 109 static int copy_sc_to_user(struct sigcontext __user *to, 110 struct _xstate __user *to_fp, struct pt_regs *regs, 111 unsigned long mask) 112 { 113 struct _xstate_64 __user *to_fp64; 114 struct sigcontext sc; 115 struct faultinfo * fi = ¤t->thread.arch.faultinfo; 116 int err; 117 memset(&sc, 0, sizeof(struct sigcontext)); 118 119 #define PUTREG(regno, regname) sc.regname = regs->regs.gp[HOST_##regno] 120 121 #ifdef CONFIG_X86_32 122 PUTREG(GS, gs); 123 PUTREG(FS, fs); 124 PUTREG(ES, es); 125 PUTREG(DS, ds); 126 #endif 127 PUTREG(DI, di); 128 PUTREG(SI, si); 129 PUTREG(BP, bp); 130 PUTREG(SP, sp); 131 PUTREG(BX, bx); 132 PUTREG(DX, dx); 133 PUTREG(CX, cx); 134 PUTREG(AX, ax); 135 #ifdef CONFIG_X86_64 136 PUTREG(R8, r8); 137 PUTREG(R9, r9); 138 PUTREG(R10, r10); 139 PUTREG(R11, r11); 140 PUTREG(R12, r12); 141 PUTREG(R13, r13); 142 PUTREG(R14, r14); 143 PUTREG(R15, r15); 144 #endif 145 146 sc.cr2 = fi->cr2; 147 sc.err = fi->error_code; 148 sc.trapno = fi->trap_no; 149 PUTREG(IP, ip); 150 PUTREG(CS, cs); 151 PUTREG(EFLAGS, flags); 152 #ifdef CONFIG_X86_32 153 PUTREG(SP, sp_at_signal); 154 PUTREG(SS, ss); 155 #endif 156 #undef PUTREG 157 sc.oldmask = mask; 158 sc.fpstate = (unsigned long)to_fp; 159 160 err = copy_to_user(to, &sc, sizeof(struct sigcontext)); 161 if (err) 162 return 1; 163 164 #ifdef CONFIG_X86_32 165 err = copy_regset_to_user(current, 166 task_user_regset_view(current), 167 REGSET_FP_LEGACY, 0, 168 sizeof(struct _fpstate_32), to_fp); 169 if (err < 0) 170 return err; 171 172 __put_user(X86_FXSR_MAGIC, &to_fp->fpstate.magic); 173 174 BUILD_BUG_ON(offsetof(struct _xstate, xstate_hdr) != 175 offsetof(struct _xstate_64, xstate_hdr) + 176 offsetof(struct _fpstate_32, _fxsr_env)); 177 to_fp64 = (void __user *)to_fp + 178 offsetof(struct _fpstate_32, _fxsr_env); 179 #else 180 to_fp64 = to_fp; 181 #endif /* CONFIG_X86_32 */ 182 183 if (copy_to_user(to_fp64, regs->regs.fp, host_fp_size)) 184 return 1; 185 186 /* 187 * Put magic/size values for userspace. We do not bother to verify them 188 * later on, however, userspace needs them should it try to read the 189 * XSTATE data. And ptrace does not fill in these parts. 190 */ 191 BUILD_BUG_ON(sizeof(int) != FP_XSTATE_MAGIC2_SIZE); 192 #ifdef CONFIG_X86_32 193 __put_user(offsetof(struct _fpstate_32, _fxsr_env) + 194 host_fp_size + FP_XSTATE_MAGIC2_SIZE, 195 &to_fp64->fpstate.sw_reserved.extended_size); 196 #else 197 __put_user(host_fp_size + FP_XSTATE_MAGIC2_SIZE, 198 &to_fp64->fpstate.sw_reserved.extended_size); 199 #endif 200 __put_user(host_fp_size, &to_fp64->fpstate.sw_reserved.xstate_size); 201 202 __put_user(FP_XSTATE_MAGIC1, &to_fp64->fpstate.sw_reserved.magic1); 203 __put_user(FP_XSTATE_MAGIC2, 204 (int __user *)((void __user *)to_fp64 + host_fp_size)); 205 206 return 0; 207 } 208 209 #ifdef CONFIG_X86_32 210 static int copy_ucontext_to_user(struct ucontext __user *uc, 211 struct _xstate __user *fp, sigset_t *set, 212 unsigned long sp) 213 { 214 int err = 0; 215 216 err |= __save_altstack(&uc->uc_stack, sp); 217 err |= copy_sc_to_user(&uc->uc_mcontext, fp, ¤t->thread.regs, 0); 218 err |= copy_to_user(&uc->uc_sigmask, set, sizeof(*set)); 219 return err; 220 } 221 222 int setup_signal_stack_sc(unsigned long stack_top, struct ksignal *ksig, 223 struct pt_regs *regs, sigset_t *mask) 224 { 225 size_t math_size = offsetof(struct _fpstate_32, _fxsr_env) + 226 host_fp_size + FP_XSTATE_MAGIC2_SIZE; 227 struct sigframe __user *frame; 228 void __user *restorer; 229 int err = 0, sig = ksig->sig; 230 unsigned long fp_to; 231 232 /* This is the same calculation as i386 - ((sp + 4) & 15) == 0 */ 233 stack_top = ((stack_top + 4) & -16UL) - 4; 234 frame = (struct sigframe __user *) stack_top - 1; 235 if (!access_ok(frame, sizeof(*frame))) 236 return 1; 237 238 /* Add required space for math frame */ 239 frame = (struct sigframe __user *)((unsigned long)frame - math_size); 240 241 restorer = frame->retcode; 242 if (ksig->ka.sa.sa_flags & SA_RESTORER) 243 restorer = ksig->ka.sa.sa_restorer; 244 245 err |= __put_user(restorer, (void __user * __user *)&frame->pretcode); 246 err |= __put_user(sig, &frame->sig); 247 248 fp_to = (unsigned long)frame + sizeof(*frame); 249 250 err |= copy_sc_to_user(&frame->sc, 251 (struct _xstate __user *)fp_to, 252 regs, mask->sig[0]); 253 if (_NSIG_WORDS > 1) 254 err |= __copy_to_user(&frame->extramask, &mask->sig[1], 255 sizeof(frame->extramask)); 256 257 /* 258 * This is popl %eax ; movl $,%eax ; int $0x80 259 * 260 * WE DO NOT USE IT ANY MORE! It's only left here for historical 261 * reasons and because gdb uses it as a signature to notice 262 * signal handler stack frames. 263 */ 264 err |= __put_user(0xb858, (short __user *)(frame->retcode+0)); 265 err |= __put_user(__NR_sigreturn, (int __user *)(frame->retcode+2)); 266 err |= __put_user(0x80cd, (short __user *)(frame->retcode+6)); 267 268 if (err) 269 return err; 270 271 PT_REGS_SP(regs) = (unsigned long) frame; 272 PT_REGS_IP(regs) = (unsigned long) ksig->ka.sa.sa_handler; 273 PT_REGS_AX(regs) = (unsigned long) sig; 274 PT_REGS_DX(regs) = (unsigned long) 0; 275 PT_REGS_CX(regs) = (unsigned long) 0; 276 return 0; 277 } 278 279 int setup_signal_stack_si(unsigned long stack_top, struct ksignal *ksig, 280 struct pt_regs *regs, sigset_t *mask) 281 { 282 size_t math_size = offsetof(struct _fpstate_32, _fxsr_env) + 283 host_fp_size + FP_XSTATE_MAGIC2_SIZE; 284 struct rt_sigframe __user *frame; 285 void __user *restorer; 286 int err = 0, sig = ksig->sig; 287 unsigned long fp_to; 288 289 stack_top &= -8UL; 290 frame = (struct rt_sigframe __user *) stack_top - 1; 291 if (!access_ok(frame, sizeof(*frame))) 292 return 1; 293 294 /* Add required space for math frame */ 295 frame = (struct rt_sigframe __user *)((unsigned long)frame - math_size); 296 297 restorer = frame->retcode; 298 if (ksig->ka.sa.sa_flags & SA_RESTORER) 299 restorer = ksig->ka.sa.sa_restorer; 300 301 err |= __put_user(restorer, (void __user * __user *)&frame->pretcode); 302 err |= __put_user(sig, &frame->sig); 303 err |= __put_user(&frame->info, (void __user * __user *)&frame->pinfo); 304 err |= __put_user(&frame->uc, (void __user * __user *)&frame->puc); 305 err |= copy_siginfo_to_user(&frame->info, &ksig->info); 306 307 fp_to = (unsigned long)frame + sizeof(*frame); 308 309 err |= copy_ucontext_to_user(&frame->uc, (struct _xstate __user *)fp_to, 310 mask, PT_REGS_SP(regs)); 311 312 /* 313 * This is movl $,%eax ; int $0x80 314 * 315 * WE DO NOT USE IT ANY MORE! It's only left here for historical 316 * reasons and because gdb uses it as a signature to notice 317 * signal handler stack frames. 318 */ 319 err |= __put_user(0xb8, (char __user *)(frame->retcode+0)); 320 err |= __put_user(__NR_rt_sigreturn, (int __user *)(frame->retcode+1)); 321 err |= __put_user(0x80cd, (short __user *)(frame->retcode+5)); 322 323 if (err) 324 return err; 325 326 PT_REGS_SP(regs) = (unsigned long) frame; 327 PT_REGS_IP(regs) = (unsigned long) ksig->ka.sa.sa_handler; 328 PT_REGS_AX(regs) = (unsigned long) sig; 329 PT_REGS_DX(regs) = (unsigned long) &frame->info; 330 PT_REGS_CX(regs) = (unsigned long) &frame->uc; 331 return 0; 332 } 333 334 SYSCALL_DEFINE0(sigreturn) 335 { 336 unsigned long sp = PT_REGS_SP(¤t->thread.regs); 337 struct sigframe __user *frame = (struct sigframe __user *)(sp - 8); 338 sigset_t set; 339 struct sigcontext __user *sc = &frame->sc; 340 int sig_size = (_NSIG_WORDS - 1) * sizeof(unsigned long); 341 342 if (copy_from_user(&set.sig[0], &sc->oldmask, sizeof(set.sig[0])) || 343 copy_from_user(&set.sig[1], frame->extramask, sig_size)) 344 goto segfault; 345 346 set_current_blocked(&set); 347 348 if (copy_sc_from_user(¤t->thread.regs, sc)) 349 goto segfault; 350 351 /* Avoid ERESTART handling */ 352 PT_REGS_SYSCALL_NR(¤t->thread.regs) = -1; 353 return PT_REGS_SYSCALL_RET(¤t->thread.regs); 354 355 segfault: 356 force_sig(SIGSEGV); 357 return 0; 358 } 359 360 #else 361 362 int setup_signal_stack_si(unsigned long stack_top, struct ksignal *ksig, 363 struct pt_regs *regs, sigset_t *set) 364 { 365 unsigned long math_size = host_fp_size + FP_XSTATE_MAGIC2_SIZE; 366 struct rt_sigframe __user *frame; 367 int err = 0, sig = ksig->sig; 368 unsigned long fp_to; 369 370 frame = (struct rt_sigframe __user *) 371 round_down(stack_top - sizeof(struct rt_sigframe), 16); 372 373 /* Add required space for math frame */ 374 frame = (struct rt_sigframe __user *)((unsigned long)frame - math_size); 375 376 /* Subtract 128 for a red zone and 8 for proper alignment */ 377 frame = (struct rt_sigframe __user *) ((unsigned long) frame - 128 - 8); 378 379 if (!access_ok(frame, sizeof(*frame) + math_size)) 380 goto out; 381 382 if (ksig->ka.sa.sa_flags & SA_SIGINFO) { 383 err |= copy_siginfo_to_user(&frame->info, &ksig->info); 384 if (err) 385 goto out; 386 } 387 388 /* Create the ucontext. */ 389 err |= __put_user(0, &frame->uc.uc_flags); 390 err |= __put_user(NULL, &frame->uc.uc_link); 391 err |= __save_altstack(&frame->uc.uc_stack, PT_REGS_SP(regs)); 392 393 fp_to = (unsigned long)frame + sizeof(*frame); 394 395 err |= copy_sc_to_user(&frame->uc.uc_mcontext, 396 (struct _xstate __user *)fp_to, 397 regs, set->sig[0]); 398 399 err |= __put_user(fp_to, &frame->uc.uc_mcontext.fpstate); 400 if (sizeof(*set) == 16) { 401 err |= __put_user(set->sig[0], &frame->uc.uc_sigmask.sig[0]); 402 err |= __put_user(set->sig[1], &frame->uc.uc_sigmask.sig[1]); 403 } 404 else 405 err |= __copy_to_user(&frame->uc.uc_sigmask, set, 406 sizeof(*set)); 407 408 /* 409 * Set up to return from userspace. If provided, use a stub 410 * already in userspace. 411 */ 412 /* x86-64 should always use SA_RESTORER. */ 413 if (ksig->ka.sa.sa_flags & SA_RESTORER) 414 err |= __put_user((void __user *)ksig->ka.sa.sa_restorer, 415 &frame->pretcode); 416 else 417 /* could use a vstub here */ 418 return err; 419 420 if (err) 421 return err; 422 423 PT_REGS_SP(regs) = (unsigned long) frame; 424 PT_REGS_DI(regs) = sig; 425 /* In case the signal handler was declared without prototypes */ 426 PT_REGS_AX(regs) = 0; 427 428 /* 429 * This also works for non SA_SIGINFO handlers because they expect the 430 * next argument after the signal number on the stack. 431 */ 432 PT_REGS_SI(regs) = (unsigned long) &frame->info; 433 PT_REGS_DX(regs) = (unsigned long) &frame->uc; 434 PT_REGS_IP(regs) = (unsigned long) ksig->ka.sa.sa_handler; 435 out: 436 return err; 437 } 438 #endif 439 440 SYSCALL_DEFINE0(rt_sigreturn) 441 { 442 unsigned long sp = PT_REGS_SP(¤t->thread.regs); 443 struct rt_sigframe __user *frame = 444 (struct rt_sigframe __user *)(sp - sizeof(long)); 445 struct ucontext __user *uc = &frame->uc; 446 sigset_t set; 447 448 if (copy_from_user(&set, &uc->uc_sigmask, sizeof(set))) 449 goto segfault; 450 451 set_current_blocked(&set); 452 453 if (copy_sc_from_user(¤t->thread.regs, &uc->uc_mcontext)) 454 goto segfault; 455 456 /* Avoid ERESTART handling */ 457 PT_REGS_SYSCALL_NR(¤t->thread.regs) = -1; 458 return PT_REGS_SYSCALL_RET(¤t->thread.regs); 459 460 segfault: 461 force_sig(SIGSEGV); 462 return 0; 463 } 464