1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright IBM Corp. 2000, 2006 4 * Author(s): Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com) 5 * Gerhard Tonn (ton@de.ibm.com) 6 * 7 * Copyright (C) 1991, 1992 Linus Torvalds 8 * 9 * 1997-11-28 Modified for POSIX.1b signals by Richard Henderson 10 */ 11 12 #include <linux/compat.h> 13 #include <linux/sched.h> 14 #include <linux/sched/task_stack.h> 15 #include <linux/mm.h> 16 #include <linux/smp.h> 17 #include <linux/kernel.h> 18 #include <linux/signal.h> 19 #include <linux/errno.h> 20 #include <linux/wait.h> 21 #include <linux/ptrace.h> 22 #include <linux/unistd.h> 23 #include <linux/stddef.h> 24 #include <linux/tty.h> 25 #include <linux/personality.h> 26 #include <linux/binfmts.h> 27 #include <asm/ucontext.h> 28 #include <linux/uaccess.h> 29 #include <asm/lowcore.h> 30 #include <asm/switch_to.h> 31 #include <asm/vdso.h> 32 #include "compat_linux.h" 33 #include "compat_ptrace.h" 34 #include "entry.h" 35 36 typedef struct 37 { 38 __u8 callee_used_stack[__SIGNAL_FRAMESIZE32]; 39 struct sigcontext32 sc; 40 _sigregs32 sregs; 41 int signo; 42 _sigregs_ext32 sregs_ext; 43 __u16 svc_insn; /* Offset of svc_insn is NOT fixed! */ 44 } sigframe32; 45 46 typedef struct 47 { 48 __u8 callee_used_stack[__SIGNAL_FRAMESIZE32]; 49 __u16 svc_insn; 50 compat_siginfo_t info; 51 struct ucontext32 uc; 52 } rt_sigframe32; 53 54 /* Store registers needed to create the signal frame */ 55 static void store_sigregs(void) 56 { 57 save_access_regs(current->thread.acrs); 58 save_fpu_regs(); 59 } 60 61 /* Load registers after signal return */ 62 static void load_sigregs(void) 63 { 64 restore_access_regs(current->thread.acrs); 65 } 66 67 static int save_sigregs32(struct pt_regs *regs, _sigregs32 __user *sregs) 68 { 69 _sigregs32 user_sregs; 70 int i; 71 72 user_sregs.regs.psw.mask = (__u32)(regs->psw.mask >> 32); 73 user_sregs.regs.psw.mask &= PSW32_MASK_USER | PSW32_MASK_RI; 74 user_sregs.regs.psw.mask |= PSW32_USER_BITS; 75 user_sregs.regs.psw.addr = (__u32) regs->psw.addr | 76 (__u32)(regs->psw.mask & PSW_MASK_BA); 77 for (i = 0; i < NUM_GPRS; i++) 78 user_sregs.regs.gprs[i] = (__u32) regs->gprs[i]; 79 memcpy(&user_sregs.regs.acrs, current->thread.acrs, 80 sizeof(user_sregs.regs.acrs)); 81 fpregs_store((_s390_fp_regs *) &user_sregs.fpregs, ¤t->thread.fpu); 82 if (__copy_to_user(sregs, &user_sregs, sizeof(_sigregs32))) 83 return -EFAULT; 84 return 0; 85 } 86 87 static int restore_sigregs32(struct pt_regs *regs,_sigregs32 __user *sregs) 88 { 89 _sigregs32 user_sregs; 90 int i; 91 92 /* Always make any pending restarted system call return -EINTR */ 93 current->restart_block.fn = do_no_restart_syscall; 94 95 if (__copy_from_user(&user_sregs, &sregs->regs, sizeof(user_sregs))) 96 return -EFAULT; 97 98 if (!is_ri_task(current) && (user_sregs.regs.psw.mask & PSW32_MASK_RI)) 99 return -EINVAL; 100 101 /* Test the floating-point-control word. */ 102 if (test_fp_ctl(user_sregs.fpregs.fpc)) 103 return -EINVAL; 104 105 /* Use regs->psw.mask instead of PSW_USER_BITS to preserve PER bit. */ 106 regs->psw.mask = (regs->psw.mask & ~(PSW_MASK_USER | PSW_MASK_RI)) | 107 (__u64)(user_sregs.regs.psw.mask & PSW32_MASK_USER) << 32 | 108 (__u64)(user_sregs.regs.psw.mask & PSW32_MASK_RI) << 32 | 109 (__u64)(user_sregs.regs.psw.addr & PSW32_ADDR_AMODE); 110 /* Check for invalid user address space control. */ 111 if ((regs->psw.mask & PSW_MASK_ASC) == PSW_ASC_HOME) 112 regs->psw.mask = PSW_ASC_PRIMARY | 113 (regs->psw.mask & ~PSW_MASK_ASC); 114 regs->psw.addr = (__u64)(user_sregs.regs.psw.addr & PSW32_ADDR_INSN); 115 for (i = 0; i < NUM_GPRS; i++) 116 regs->gprs[i] = (__u64) user_sregs.regs.gprs[i]; 117 memcpy(¤t->thread.acrs, &user_sregs.regs.acrs, 118 sizeof(current->thread.acrs)); 119 fpregs_load((_s390_fp_regs *) &user_sregs.fpregs, ¤t->thread.fpu); 120 121 clear_pt_regs_flag(regs, PIF_SYSCALL); /* No longer in a system call */ 122 return 0; 123 } 124 125 static int save_sigregs_ext32(struct pt_regs *regs, 126 _sigregs_ext32 __user *sregs_ext) 127 { 128 __u32 gprs_high[NUM_GPRS]; 129 __u64 vxrs[__NUM_VXRS_LOW]; 130 int i; 131 132 /* Save high gprs to signal stack */ 133 for (i = 0; i < NUM_GPRS; i++) 134 gprs_high[i] = regs->gprs[i] >> 32; 135 if (__copy_to_user(&sregs_ext->gprs_high, &gprs_high, 136 sizeof(sregs_ext->gprs_high))) 137 return -EFAULT; 138 139 /* Save vector registers to signal stack */ 140 if (MACHINE_HAS_VX) { 141 for (i = 0; i < __NUM_VXRS_LOW; i++) 142 vxrs[i] = *((__u64 *)(current->thread.fpu.vxrs + i) + 1); 143 if (__copy_to_user(&sregs_ext->vxrs_low, vxrs, 144 sizeof(sregs_ext->vxrs_low)) || 145 __copy_to_user(&sregs_ext->vxrs_high, 146 current->thread.fpu.vxrs + __NUM_VXRS_LOW, 147 sizeof(sregs_ext->vxrs_high))) 148 return -EFAULT; 149 } 150 return 0; 151 } 152 153 static int restore_sigregs_ext32(struct pt_regs *regs, 154 _sigregs_ext32 __user *sregs_ext) 155 { 156 __u32 gprs_high[NUM_GPRS]; 157 __u64 vxrs[__NUM_VXRS_LOW]; 158 int i; 159 160 /* Restore high gprs from signal stack */ 161 if (__copy_from_user(&gprs_high, &sregs_ext->gprs_high, 162 sizeof(sregs_ext->gprs_high))) 163 return -EFAULT; 164 for (i = 0; i < NUM_GPRS; i++) 165 *(__u32 *)®s->gprs[i] = gprs_high[i]; 166 167 /* Restore vector registers from signal stack */ 168 if (MACHINE_HAS_VX) { 169 if (__copy_from_user(vxrs, &sregs_ext->vxrs_low, 170 sizeof(sregs_ext->vxrs_low)) || 171 __copy_from_user(current->thread.fpu.vxrs + __NUM_VXRS_LOW, 172 &sregs_ext->vxrs_high, 173 sizeof(sregs_ext->vxrs_high))) 174 return -EFAULT; 175 for (i = 0; i < __NUM_VXRS_LOW; i++) 176 *((__u64 *)(current->thread.fpu.vxrs + i) + 1) = vxrs[i]; 177 } 178 return 0; 179 } 180 181 COMPAT_SYSCALL_DEFINE0(sigreturn) 182 { 183 struct pt_regs *regs = task_pt_regs(current); 184 sigframe32 __user *frame = (sigframe32 __user *)regs->gprs[15]; 185 sigset_t set; 186 187 if (get_compat_sigset(&set, (compat_sigset_t __user *)frame->sc.oldmask)) 188 goto badframe; 189 set_current_blocked(&set); 190 save_fpu_regs(); 191 if (restore_sigregs32(regs, &frame->sregs)) 192 goto badframe; 193 if (restore_sigregs_ext32(regs, &frame->sregs_ext)) 194 goto badframe; 195 load_sigregs(); 196 return regs->gprs[2]; 197 badframe: 198 force_sig(SIGSEGV); 199 return 0; 200 } 201 202 COMPAT_SYSCALL_DEFINE0(rt_sigreturn) 203 { 204 struct pt_regs *regs = task_pt_regs(current); 205 rt_sigframe32 __user *frame = (rt_sigframe32 __user *)regs->gprs[15]; 206 sigset_t set; 207 208 if (get_compat_sigset(&set, &frame->uc.uc_sigmask)) 209 goto badframe; 210 set_current_blocked(&set); 211 if (compat_restore_altstack(&frame->uc.uc_stack)) 212 goto badframe; 213 save_fpu_regs(); 214 if (restore_sigregs32(regs, &frame->uc.uc_mcontext)) 215 goto badframe; 216 if (restore_sigregs_ext32(regs, &frame->uc.uc_mcontext_ext)) 217 goto badframe; 218 load_sigregs(); 219 return regs->gprs[2]; 220 badframe: 221 force_sig(SIGSEGV); 222 return 0; 223 } 224 225 /* 226 * Set up a signal frame. 227 */ 228 229 230 /* 231 * Determine which stack to use.. 232 */ 233 static inline void __user * 234 get_sigframe(struct k_sigaction *ka, struct pt_regs * regs, size_t frame_size) 235 { 236 unsigned long sp; 237 238 /* Default to using normal stack */ 239 sp = (unsigned long) A(regs->gprs[15]); 240 241 /* Overflow on alternate signal stack gives SIGSEGV. */ 242 if (on_sig_stack(sp) && !on_sig_stack((sp - frame_size) & -8UL)) 243 return (void __user *) -1UL; 244 245 /* This is the X/Open sanctioned signal stack switching. */ 246 if (ka->sa.sa_flags & SA_ONSTACK) { 247 if (! sas_ss_flags(sp)) 248 sp = current->sas_ss_sp + current->sas_ss_size; 249 } 250 251 return (void __user *)((sp - frame_size) & -8ul); 252 } 253 254 static int setup_frame32(struct ksignal *ksig, sigset_t *set, 255 struct pt_regs *regs) 256 { 257 int sig = ksig->sig; 258 sigframe32 __user *frame; 259 unsigned long restorer; 260 size_t frame_size; 261 262 /* 263 * gprs_high are always present for 31-bit compat tasks. 264 * The space for vector registers is only allocated if 265 * the machine supports it 266 */ 267 frame_size = sizeof(*frame) - sizeof(frame->sregs_ext.__reserved); 268 if (!MACHINE_HAS_VX) 269 frame_size -= sizeof(frame->sregs_ext.vxrs_low) + 270 sizeof(frame->sregs_ext.vxrs_high); 271 frame = get_sigframe(&ksig->ka, regs, frame_size); 272 if (frame == (void __user *) -1UL) 273 return -EFAULT; 274 275 /* Set up backchain. */ 276 if (__put_user(regs->gprs[15], (unsigned int __user *) frame)) 277 return -EFAULT; 278 279 /* Create struct sigcontext32 on the signal stack */ 280 if (put_compat_sigset((compat_sigset_t __user *)frame->sc.oldmask, 281 set, sizeof(compat_sigset_t))) 282 return -EFAULT; 283 if (__put_user(ptr_to_compat(&frame->sregs), &frame->sc.sregs)) 284 return -EFAULT; 285 286 /* Store registers needed to create the signal frame */ 287 store_sigregs(); 288 289 /* Create _sigregs32 on the signal stack */ 290 if (save_sigregs32(regs, &frame->sregs)) 291 return -EFAULT; 292 293 /* Place signal number on stack to allow backtrace from handler. */ 294 if (__put_user(regs->gprs[2], (int __force __user *) &frame->signo)) 295 return -EFAULT; 296 297 /* Create _sigregs_ext32 on the signal stack */ 298 if (save_sigregs_ext32(regs, &frame->sregs_ext)) 299 return -EFAULT; 300 301 /* Set up to return from userspace. If provided, use a stub 302 already in userspace. */ 303 if (ksig->ka.sa.sa_flags & SA_RESTORER) { 304 restorer = (unsigned long __force) 305 ksig->ka.sa.sa_restorer | PSW32_ADDR_AMODE; 306 } else { 307 restorer = VDSO32_SYMBOL(current, sigreturn); 308 } 309 310 /* Set up registers for signal handler */ 311 regs->gprs[14] = restorer; 312 regs->gprs[15] = (__force __u64) frame; 313 /* Force 31 bit amode and default user address space control. */ 314 regs->psw.mask = PSW_MASK_BA | 315 (PSW_USER_BITS & PSW_MASK_ASC) | 316 (regs->psw.mask & ~PSW_MASK_ASC); 317 regs->psw.addr = (__force __u64) ksig->ka.sa.sa_handler; 318 319 regs->gprs[2] = sig; 320 regs->gprs[3] = (__force __u64) &frame->sc; 321 322 /* We forgot to include these in the sigcontext. 323 To avoid breaking binary compatibility, they are passed as args. */ 324 if (sig == SIGSEGV || sig == SIGBUS || sig == SIGILL || 325 sig == SIGTRAP || sig == SIGFPE) { 326 /* set extra registers only for synchronous signals */ 327 regs->gprs[4] = regs->int_code & 127; 328 regs->gprs[5] = regs->int_parm_long; 329 regs->gprs[6] = current->thread.last_break; 330 } 331 332 return 0; 333 } 334 335 static int setup_rt_frame32(struct ksignal *ksig, sigset_t *set, 336 struct pt_regs *regs) 337 { 338 rt_sigframe32 __user *frame; 339 unsigned long restorer; 340 size_t frame_size; 341 u32 uc_flags; 342 343 frame_size = sizeof(*frame) - 344 sizeof(frame->uc.uc_mcontext_ext.__reserved); 345 /* 346 * gprs_high are always present for 31-bit compat tasks. 347 * The space for vector registers is only allocated if 348 * the machine supports it 349 */ 350 uc_flags = UC_GPRS_HIGH; 351 if (MACHINE_HAS_VX) { 352 uc_flags |= UC_VXRS; 353 } else 354 frame_size -= sizeof(frame->uc.uc_mcontext_ext.vxrs_low) + 355 sizeof(frame->uc.uc_mcontext_ext.vxrs_high); 356 frame = get_sigframe(&ksig->ka, regs, frame_size); 357 if (frame == (void __user *) -1UL) 358 return -EFAULT; 359 360 /* Set up backchain. */ 361 if (__put_user(regs->gprs[15], (unsigned int __force __user *) frame)) 362 return -EFAULT; 363 364 /* Set up to return from userspace. If provided, use a stub 365 already in userspace. */ 366 if (ksig->ka.sa.sa_flags & SA_RESTORER) { 367 restorer = (unsigned long __force) 368 ksig->ka.sa.sa_restorer | PSW32_ADDR_AMODE; 369 } else { 370 restorer = VDSO32_SYMBOL(current, rt_sigreturn); 371 } 372 373 /* Create siginfo on the signal stack */ 374 if (copy_siginfo_to_user32(&frame->info, &ksig->info)) 375 return -EFAULT; 376 377 /* Store registers needed to create the signal frame */ 378 store_sigregs(); 379 380 /* Create ucontext on the signal stack. */ 381 if (__put_user(uc_flags, &frame->uc.uc_flags) || 382 __put_user(0, &frame->uc.uc_link) || 383 __compat_save_altstack(&frame->uc.uc_stack, regs->gprs[15]) || 384 save_sigregs32(regs, &frame->uc.uc_mcontext) || 385 put_compat_sigset(&frame->uc.uc_sigmask, set, sizeof(compat_sigset_t)) || 386 save_sigregs_ext32(regs, &frame->uc.uc_mcontext_ext)) 387 return -EFAULT; 388 389 /* Set up registers for signal handler */ 390 regs->gprs[14] = restorer; 391 regs->gprs[15] = (__force __u64) frame; 392 /* Force 31 bit amode and default user address space control. */ 393 regs->psw.mask = PSW_MASK_BA | 394 (PSW_USER_BITS & PSW_MASK_ASC) | 395 (regs->psw.mask & ~PSW_MASK_ASC); 396 regs->psw.addr = (__u64 __force) ksig->ka.sa.sa_handler; 397 398 regs->gprs[2] = ksig->sig; 399 regs->gprs[3] = (__force __u64) &frame->info; 400 regs->gprs[4] = (__force __u64) &frame->uc; 401 regs->gprs[5] = current->thread.last_break; 402 return 0; 403 } 404 405 /* 406 * OK, we're invoking a handler 407 */ 408 409 void handle_signal32(struct ksignal *ksig, sigset_t *oldset, 410 struct pt_regs *regs) 411 { 412 int ret; 413 414 /* Set up the stack frame */ 415 if (ksig->ka.sa.sa_flags & SA_SIGINFO) 416 ret = setup_rt_frame32(ksig, oldset, regs); 417 else 418 ret = setup_frame32(ksig, oldset, regs); 419 420 signal_setup_done(ret, ksig, test_thread_flag(TIF_SINGLE_STEP)); 421 } 422 423