1 /* 2 * Based on arch/arm/kernel/signal.c 3 * 4 * Copyright (C) 1995-2009 Russell King 5 * Copyright (C) 2012 ARM Ltd. 6 * Modified by Will Deacon <will.deacon@arm.com> 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License version 2 as 10 * published by the Free Software Foundation. 11 * 12 * This program is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * GNU General Public License for more details. 16 * 17 * You should have received a copy of the GNU General Public License 18 * along with this program. If not, see <http://www.gnu.org/licenses/>. 19 */ 20 21 #include <linux/compat.h> 22 #include <linux/signal.h> 23 #include <linux/syscalls.h> 24 #include <linux/ratelimit.h> 25 26 #include <asm/esr.h> 27 #include <asm/fpsimd.h> 28 #include <asm/signal32.h> 29 #include <asm/traps.h> 30 #include <linux/uaccess.h> 31 #include <asm/unistd.h> 32 33 struct compat_sigcontext { 34 /* We always set these two fields to 0 */ 35 compat_ulong_t trap_no; 36 compat_ulong_t error_code; 37 38 compat_ulong_t oldmask; 39 compat_ulong_t arm_r0; 40 compat_ulong_t arm_r1; 41 compat_ulong_t arm_r2; 42 compat_ulong_t arm_r3; 43 compat_ulong_t arm_r4; 44 compat_ulong_t arm_r5; 45 compat_ulong_t arm_r6; 46 compat_ulong_t arm_r7; 47 compat_ulong_t arm_r8; 48 compat_ulong_t arm_r9; 49 compat_ulong_t arm_r10; 50 compat_ulong_t arm_fp; 51 compat_ulong_t arm_ip; 52 compat_ulong_t arm_sp; 53 compat_ulong_t arm_lr; 54 compat_ulong_t arm_pc; 55 compat_ulong_t arm_cpsr; 56 compat_ulong_t fault_address; 57 }; 58 59 struct compat_ucontext { 60 compat_ulong_t uc_flags; 61 compat_uptr_t uc_link; 62 compat_stack_t uc_stack; 63 struct compat_sigcontext uc_mcontext; 64 compat_sigset_t uc_sigmask; 65 int __unused[32 - (sizeof (compat_sigset_t) / sizeof (int))]; 66 compat_ulong_t uc_regspace[128] __attribute__((__aligned__(8))); 67 }; 68 69 struct compat_vfp_sigframe { 70 compat_ulong_t magic; 71 compat_ulong_t size; 72 struct compat_user_vfp { 73 compat_u64 fpregs[32]; 74 compat_ulong_t fpscr; 75 } ufp; 76 struct compat_user_vfp_exc { 77 compat_ulong_t fpexc; 78 compat_ulong_t fpinst; 79 compat_ulong_t fpinst2; 80 } ufp_exc; 81 } __attribute__((__aligned__(8))); 82 83 #define VFP_MAGIC 0x56465001 84 #define VFP_STORAGE_SIZE sizeof(struct compat_vfp_sigframe) 85 86 #define FSR_WRITE_SHIFT (11) 87 88 struct compat_aux_sigframe { 89 struct compat_vfp_sigframe vfp; 90 91 /* Something that isn't a valid magic number for any coprocessor. */ 92 unsigned long end_magic; 93 } __attribute__((__aligned__(8))); 94 95 struct compat_sigframe { 96 struct compat_ucontext uc; 97 compat_ulong_t retcode[2]; 98 }; 99 100 struct compat_rt_sigframe { 101 struct compat_siginfo info; 102 struct compat_sigframe sig; 103 }; 104 105 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP))) 106 107 static inline int put_sigset_t(compat_sigset_t __user *uset, sigset_t *set) 108 { 109 compat_sigset_t cset; 110 111 cset.sig[0] = set->sig[0] & 0xffffffffull; 112 cset.sig[1] = set->sig[0] >> 32; 113 114 return copy_to_user(uset, &cset, sizeof(*uset)); 115 } 116 117 static inline int get_sigset_t(sigset_t *set, 118 const compat_sigset_t __user *uset) 119 { 120 compat_sigset_t s32; 121 122 if (copy_from_user(&s32, uset, sizeof(*uset))) 123 return -EFAULT; 124 125 set->sig[0] = s32.sig[0] | (((long)s32.sig[1]) << 32); 126 return 0; 127 } 128 129 /* 130 * VFP save/restore code. 131 * 132 * We have to be careful with endianness, since the fpsimd context-switch 133 * code operates on 128-bit (Q) register values whereas the compat ABI 134 * uses an array of 64-bit (D) registers. Consequently, we need to swap 135 * the two halves of each Q register when running on a big-endian CPU. 136 */ 137 union __fpsimd_vreg { 138 __uint128_t raw; 139 struct { 140 #ifdef __AARCH64EB__ 141 u64 hi; 142 u64 lo; 143 #else 144 u64 lo; 145 u64 hi; 146 #endif 147 }; 148 }; 149 150 static int compat_preserve_vfp_context(struct compat_vfp_sigframe __user *frame) 151 { 152 struct user_fpsimd_state const *fpsimd = 153 ¤t->thread.uw.fpsimd_state; 154 compat_ulong_t magic = VFP_MAGIC; 155 compat_ulong_t size = VFP_STORAGE_SIZE; 156 compat_ulong_t fpscr, fpexc; 157 int i, err = 0; 158 159 /* 160 * Save the hardware registers to the fpsimd_state structure. 161 * Note that this also saves V16-31, which aren't visible 162 * in AArch32. 163 */ 164 fpsimd_signal_preserve_current_state(); 165 166 /* Place structure header on the stack */ 167 __put_user_error(magic, &frame->magic, err); 168 __put_user_error(size, &frame->size, err); 169 170 /* 171 * Now copy the FP registers. Since the registers are packed, 172 * we can copy the prefix we want (V0-V15) as it is. 173 */ 174 for (i = 0; i < ARRAY_SIZE(frame->ufp.fpregs); i += 2) { 175 union __fpsimd_vreg vreg = { 176 .raw = fpsimd->vregs[i >> 1], 177 }; 178 179 __put_user_error(vreg.lo, &frame->ufp.fpregs[i], err); 180 __put_user_error(vreg.hi, &frame->ufp.fpregs[i + 1], err); 181 } 182 183 /* Create an AArch32 fpscr from the fpsr and the fpcr. */ 184 fpscr = (fpsimd->fpsr & VFP_FPSCR_STAT_MASK) | 185 (fpsimd->fpcr & VFP_FPSCR_CTRL_MASK); 186 __put_user_error(fpscr, &frame->ufp.fpscr, err); 187 188 /* 189 * The exception register aren't available so we fake up a 190 * basic FPEXC and zero everything else. 191 */ 192 fpexc = (1 << 30); 193 __put_user_error(fpexc, &frame->ufp_exc.fpexc, err); 194 __put_user_error(0, &frame->ufp_exc.fpinst, err); 195 __put_user_error(0, &frame->ufp_exc.fpinst2, err); 196 197 return err ? -EFAULT : 0; 198 } 199 200 static int compat_restore_vfp_context(struct compat_vfp_sigframe __user *frame) 201 { 202 struct user_fpsimd_state fpsimd; 203 compat_ulong_t magic = VFP_MAGIC; 204 compat_ulong_t size = VFP_STORAGE_SIZE; 205 compat_ulong_t fpscr; 206 int i, err = 0; 207 208 __get_user_error(magic, &frame->magic, err); 209 __get_user_error(size, &frame->size, err); 210 211 if (err) 212 return -EFAULT; 213 if (magic != VFP_MAGIC || size != VFP_STORAGE_SIZE) 214 return -EINVAL; 215 216 /* Copy the FP registers into the start of the fpsimd_state. */ 217 for (i = 0; i < ARRAY_SIZE(frame->ufp.fpregs); i += 2) { 218 union __fpsimd_vreg vreg; 219 220 __get_user_error(vreg.lo, &frame->ufp.fpregs[i], err); 221 __get_user_error(vreg.hi, &frame->ufp.fpregs[i + 1], err); 222 fpsimd.vregs[i >> 1] = vreg.raw; 223 } 224 225 /* Extract the fpsr and the fpcr from the fpscr */ 226 __get_user_error(fpscr, &frame->ufp.fpscr, err); 227 fpsimd.fpsr = fpscr & VFP_FPSCR_STAT_MASK; 228 fpsimd.fpcr = fpscr & VFP_FPSCR_CTRL_MASK; 229 230 /* 231 * We don't need to touch the exception register, so 232 * reload the hardware state. 233 */ 234 if (!err) 235 fpsimd_update_current_state(&fpsimd); 236 237 return err ? -EFAULT : 0; 238 } 239 240 static int compat_restore_sigframe(struct pt_regs *regs, 241 struct compat_sigframe __user *sf) 242 { 243 int err; 244 sigset_t set; 245 struct compat_aux_sigframe __user *aux; 246 247 err = get_sigset_t(&set, &sf->uc.uc_sigmask); 248 if (err == 0) { 249 sigdelsetmask(&set, ~_BLOCKABLE); 250 set_current_blocked(&set); 251 } 252 253 __get_user_error(regs->regs[0], &sf->uc.uc_mcontext.arm_r0, err); 254 __get_user_error(regs->regs[1], &sf->uc.uc_mcontext.arm_r1, err); 255 __get_user_error(regs->regs[2], &sf->uc.uc_mcontext.arm_r2, err); 256 __get_user_error(regs->regs[3], &sf->uc.uc_mcontext.arm_r3, err); 257 __get_user_error(regs->regs[4], &sf->uc.uc_mcontext.arm_r4, err); 258 __get_user_error(regs->regs[5], &sf->uc.uc_mcontext.arm_r5, err); 259 __get_user_error(regs->regs[6], &sf->uc.uc_mcontext.arm_r6, err); 260 __get_user_error(regs->regs[7], &sf->uc.uc_mcontext.arm_r7, err); 261 __get_user_error(regs->regs[8], &sf->uc.uc_mcontext.arm_r8, err); 262 __get_user_error(regs->regs[9], &sf->uc.uc_mcontext.arm_r9, err); 263 __get_user_error(regs->regs[10], &sf->uc.uc_mcontext.arm_r10, err); 264 __get_user_error(regs->regs[11], &sf->uc.uc_mcontext.arm_fp, err); 265 __get_user_error(regs->regs[12], &sf->uc.uc_mcontext.arm_ip, err); 266 __get_user_error(regs->compat_sp, &sf->uc.uc_mcontext.arm_sp, err); 267 __get_user_error(regs->compat_lr, &sf->uc.uc_mcontext.arm_lr, err); 268 __get_user_error(regs->pc, &sf->uc.uc_mcontext.arm_pc, err); 269 __get_user_error(regs->pstate, &sf->uc.uc_mcontext.arm_cpsr, err); 270 271 /* 272 * Avoid compat_sys_sigreturn() restarting. 273 */ 274 forget_syscall(regs); 275 276 err |= !valid_user_regs(®s->user_regs, current); 277 278 aux = (struct compat_aux_sigframe __user *) sf->uc.uc_regspace; 279 if (err == 0) 280 err |= compat_restore_vfp_context(&aux->vfp); 281 282 return err; 283 } 284 285 asmlinkage int compat_sys_sigreturn(struct pt_regs *regs) 286 { 287 struct compat_sigframe __user *frame; 288 289 /* Always make any pending restarted system calls return -EINTR */ 290 current->restart_block.fn = do_no_restart_syscall; 291 292 /* 293 * Since we stacked the signal on a 64-bit boundary, 294 * then 'sp' should be word aligned here. If it's 295 * not, then the user is trying to mess with us. 296 */ 297 if (regs->compat_sp & 7) 298 goto badframe; 299 300 frame = (struct compat_sigframe __user *)regs->compat_sp; 301 302 if (!access_ok(VERIFY_READ, frame, sizeof (*frame))) 303 goto badframe; 304 305 if (compat_restore_sigframe(regs, frame)) 306 goto badframe; 307 308 return regs->regs[0]; 309 310 badframe: 311 arm64_notify_segfault(regs->compat_sp); 312 return 0; 313 } 314 315 asmlinkage int compat_sys_rt_sigreturn(struct pt_regs *regs) 316 { 317 struct compat_rt_sigframe __user *frame; 318 319 /* Always make any pending restarted system calls return -EINTR */ 320 current->restart_block.fn = do_no_restart_syscall; 321 322 /* 323 * Since we stacked the signal on a 64-bit boundary, 324 * then 'sp' should be word aligned here. If it's 325 * not, then the user is trying to mess with us. 326 */ 327 if (regs->compat_sp & 7) 328 goto badframe; 329 330 frame = (struct compat_rt_sigframe __user *)regs->compat_sp; 331 332 if (!access_ok(VERIFY_READ, frame, sizeof (*frame))) 333 goto badframe; 334 335 if (compat_restore_sigframe(regs, &frame->sig)) 336 goto badframe; 337 338 if (compat_restore_altstack(&frame->sig.uc.uc_stack)) 339 goto badframe; 340 341 return regs->regs[0]; 342 343 badframe: 344 arm64_notify_segfault(regs->compat_sp); 345 return 0; 346 } 347 348 static void __user *compat_get_sigframe(struct ksignal *ksig, 349 struct pt_regs *regs, 350 int framesize) 351 { 352 compat_ulong_t sp = sigsp(regs->compat_sp, ksig); 353 void __user *frame; 354 355 /* 356 * ATPCS B01 mandates 8-byte alignment 357 */ 358 frame = compat_ptr((compat_uptr_t)((sp - framesize) & ~7)); 359 360 /* 361 * Check that we can actually write to the signal frame. 362 */ 363 if (!access_ok(VERIFY_WRITE, frame, framesize)) 364 frame = NULL; 365 366 return frame; 367 } 368 369 static void compat_setup_return(struct pt_regs *regs, struct k_sigaction *ka, 370 compat_ulong_t __user *rc, void __user *frame, 371 int usig) 372 { 373 compat_ulong_t handler = ptr_to_compat(ka->sa.sa_handler); 374 compat_ulong_t retcode; 375 compat_ulong_t spsr = regs->pstate & ~(PSR_f | COMPAT_PSR_E_BIT); 376 int thumb; 377 378 /* Check if the handler is written for ARM or Thumb */ 379 thumb = handler & 1; 380 381 if (thumb) 382 spsr |= COMPAT_PSR_T_BIT; 383 else 384 spsr &= ~COMPAT_PSR_T_BIT; 385 386 /* The IT state must be cleared for both ARM and Thumb-2 */ 387 spsr &= ~COMPAT_PSR_IT_MASK; 388 389 /* Restore the original endianness */ 390 spsr |= COMPAT_PSR_ENDSTATE; 391 392 if (ka->sa.sa_flags & SA_RESTORER) { 393 retcode = ptr_to_compat(ka->sa.sa_restorer); 394 } else { 395 /* Set up sigreturn pointer */ 396 unsigned int idx = thumb << 1; 397 398 if (ka->sa.sa_flags & SA_SIGINFO) 399 idx += 3; 400 401 retcode = AARCH32_VECTORS_BASE + 402 AARCH32_KERN_SIGRET_CODE_OFFSET + 403 (idx << 2) + thumb; 404 } 405 406 regs->regs[0] = usig; 407 regs->compat_sp = ptr_to_compat(frame); 408 regs->compat_lr = retcode; 409 regs->pc = handler; 410 regs->pstate = spsr; 411 } 412 413 static int compat_setup_sigframe(struct compat_sigframe __user *sf, 414 struct pt_regs *regs, sigset_t *set) 415 { 416 struct compat_aux_sigframe __user *aux; 417 int err = 0; 418 419 __put_user_error(regs->regs[0], &sf->uc.uc_mcontext.arm_r0, err); 420 __put_user_error(regs->regs[1], &sf->uc.uc_mcontext.arm_r1, err); 421 __put_user_error(regs->regs[2], &sf->uc.uc_mcontext.arm_r2, err); 422 __put_user_error(regs->regs[3], &sf->uc.uc_mcontext.arm_r3, err); 423 __put_user_error(regs->regs[4], &sf->uc.uc_mcontext.arm_r4, err); 424 __put_user_error(regs->regs[5], &sf->uc.uc_mcontext.arm_r5, err); 425 __put_user_error(regs->regs[6], &sf->uc.uc_mcontext.arm_r6, err); 426 __put_user_error(regs->regs[7], &sf->uc.uc_mcontext.arm_r7, err); 427 __put_user_error(regs->regs[8], &sf->uc.uc_mcontext.arm_r8, err); 428 __put_user_error(regs->regs[9], &sf->uc.uc_mcontext.arm_r9, err); 429 __put_user_error(regs->regs[10], &sf->uc.uc_mcontext.arm_r10, err); 430 __put_user_error(regs->regs[11], &sf->uc.uc_mcontext.arm_fp, err); 431 __put_user_error(regs->regs[12], &sf->uc.uc_mcontext.arm_ip, err); 432 __put_user_error(regs->compat_sp, &sf->uc.uc_mcontext.arm_sp, err); 433 __put_user_error(regs->compat_lr, &sf->uc.uc_mcontext.arm_lr, err); 434 __put_user_error(regs->pc, &sf->uc.uc_mcontext.arm_pc, err); 435 __put_user_error(regs->pstate, &sf->uc.uc_mcontext.arm_cpsr, err); 436 437 __put_user_error((compat_ulong_t)0, &sf->uc.uc_mcontext.trap_no, err); 438 /* set the compat FSR WnR */ 439 __put_user_error(!!(current->thread.fault_code & ESR_ELx_WNR) << 440 FSR_WRITE_SHIFT, &sf->uc.uc_mcontext.error_code, err); 441 __put_user_error(current->thread.fault_address, &sf->uc.uc_mcontext.fault_address, err); 442 __put_user_error(set->sig[0], &sf->uc.uc_mcontext.oldmask, err); 443 444 err |= put_sigset_t(&sf->uc.uc_sigmask, set); 445 446 aux = (struct compat_aux_sigframe __user *) sf->uc.uc_regspace; 447 448 if (err == 0) 449 err |= compat_preserve_vfp_context(&aux->vfp); 450 __put_user_error(0, &aux->end_magic, err); 451 452 return err; 453 } 454 455 /* 456 * 32-bit signal handling routines called from signal.c 457 */ 458 int compat_setup_rt_frame(int usig, struct ksignal *ksig, 459 sigset_t *set, struct pt_regs *regs) 460 { 461 struct compat_rt_sigframe __user *frame; 462 int err = 0; 463 464 frame = compat_get_sigframe(ksig, regs, sizeof(*frame)); 465 466 if (!frame) 467 return 1; 468 469 err |= copy_siginfo_to_user32(&frame->info, &ksig->info); 470 471 __put_user_error(0, &frame->sig.uc.uc_flags, err); 472 __put_user_error(0, &frame->sig.uc.uc_link, err); 473 474 err |= __compat_save_altstack(&frame->sig.uc.uc_stack, regs->compat_sp); 475 476 err |= compat_setup_sigframe(&frame->sig, regs, set); 477 478 if (err == 0) { 479 compat_setup_return(regs, &ksig->ka, frame->sig.retcode, frame, usig); 480 regs->regs[1] = (compat_ulong_t)(unsigned long)&frame->info; 481 regs->regs[2] = (compat_ulong_t)(unsigned long)&frame->sig.uc; 482 } 483 484 return err; 485 } 486 487 int compat_setup_frame(int usig, struct ksignal *ksig, sigset_t *set, 488 struct pt_regs *regs) 489 { 490 struct compat_sigframe __user *frame; 491 int err = 0; 492 493 frame = compat_get_sigframe(ksig, regs, sizeof(*frame)); 494 495 if (!frame) 496 return 1; 497 498 __put_user_error(0x5ac3c35a, &frame->uc.uc_flags, err); 499 500 err |= compat_setup_sigframe(frame, regs, set); 501 if (err == 0) 502 compat_setup_return(regs, &ksig->ka, frame->retcode, frame, usig); 503 504 return err; 505 } 506 507 void compat_setup_restart_syscall(struct pt_regs *regs) 508 { 509 regs->regs[7] = __NR_compat_restart_syscall; 510 } 511