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 "compat_linux.h" 32 #include "compat_ptrace.h" 33 #include "entry.h" 34 35 typedef struct 36 { 37 __u8 callee_used_stack[__SIGNAL_FRAMESIZE32]; 38 struct sigcontext32 sc; 39 _sigregs32 sregs; 40 int signo; 41 _sigregs_ext32 sregs_ext; 42 __u16 svc_insn; /* Offset of svc_insn is NOT fixed! */ 43 } sigframe32; 44 45 typedef struct 46 { 47 __u8 callee_used_stack[__SIGNAL_FRAMESIZE32]; 48 __u16 svc_insn; 49 compat_siginfo_t info; 50 struct ucontext32 uc; 51 } rt_sigframe32; 52 53 /* Store registers needed to create the signal frame */ 54 static void store_sigregs(void) 55 { 56 save_access_regs(current->thread.acrs); 57 save_fpu_regs(); 58 } 59 60 /* Load registers after signal return */ 61 static void load_sigregs(void) 62 { 63 restore_access_regs(current->thread.acrs); 64 } 65 66 static int save_sigregs32(struct pt_regs *regs, _sigregs32 __user *sregs) 67 { 68 _sigregs32 user_sregs; 69 int i; 70 71 user_sregs.regs.psw.mask = (__u32)(regs->psw.mask >> 32); 72 user_sregs.regs.psw.mask &= PSW32_MASK_USER | PSW32_MASK_RI; 73 user_sregs.regs.psw.mask |= PSW32_USER_BITS; 74 user_sregs.regs.psw.addr = (__u32) regs->psw.addr | 75 (__u32)(regs->psw.mask & PSW_MASK_BA); 76 for (i = 0; i < NUM_GPRS; i++) 77 user_sregs.regs.gprs[i] = (__u32) regs->gprs[i]; 78 memcpy(&user_sregs.regs.acrs, current->thread.acrs, 79 sizeof(user_sregs.regs.acrs)); 80 fpregs_store((_s390_fp_regs *) &user_sregs.fpregs, ¤t->thread.fpu); 81 if (__copy_to_user(sregs, &user_sregs, sizeof(_sigregs32))) 82 return -EFAULT; 83 return 0; 84 } 85 86 static int restore_sigregs32(struct pt_regs *regs,_sigregs32 __user *sregs) 87 { 88 _sigregs32 user_sregs; 89 int i; 90 91 /* Alwys make any pending restarted system call return -EINTR */ 92 current->restart_block.fn = do_no_restart_syscall; 93 94 if (__copy_from_user(&user_sregs, &sregs->regs, sizeof(user_sregs))) 95 return -EFAULT; 96 97 if (!is_ri_task(current) && (user_sregs.regs.psw.mask & PSW32_MASK_RI)) 98 return -EINVAL; 99 100 /* Test the floating-point-control word. */ 101 if (test_fp_ctl(user_sregs.fpregs.fpc)) 102 return -EINVAL; 103 104 /* Use regs->psw.mask instead of PSW_USER_BITS to preserve PER bit. */ 105 regs->psw.mask = (regs->psw.mask & ~(PSW_MASK_USER | PSW_MASK_RI)) | 106 (__u64)(user_sregs.regs.psw.mask & PSW32_MASK_USER) << 32 | 107 (__u64)(user_sregs.regs.psw.mask & PSW32_MASK_RI) << 32 | 108 (__u64)(user_sregs.regs.psw.addr & PSW32_ADDR_AMODE); 109 /* Check for invalid user address space control. */ 110 if ((regs->psw.mask & PSW_MASK_ASC) == PSW_ASC_HOME) 111 regs->psw.mask = PSW_ASC_PRIMARY | 112 (regs->psw.mask & ~PSW_MASK_ASC); 113 regs->psw.addr = (__u64)(user_sregs.regs.psw.addr & PSW32_ADDR_INSN); 114 for (i = 0; i < NUM_GPRS; i++) 115 regs->gprs[i] = (__u64) user_sregs.regs.gprs[i]; 116 memcpy(¤t->thread.acrs, &user_sregs.regs.acrs, 117 sizeof(current->thread.acrs)); 118 fpregs_load((_s390_fp_regs *) &user_sregs.fpregs, ¤t->thread.fpu); 119 120 clear_pt_regs_flag(regs, PIF_SYSCALL); /* No longer in a system call */ 121 clear_pt_regs_flag(regs, PIF_SYSCALL_RESTART); 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 /* Signal frames without vectors registers are short ! */ 308 __u16 __user *svc = (void __user *) frame + frame_size - 2; 309 if (__put_user(S390_SYSCALL_OPCODE | __NR_sigreturn, svc)) 310 return -EFAULT; 311 restorer = (unsigned long __force) svc | PSW32_ADDR_AMODE; 312 } 313 314 /* Set up registers for signal handler */ 315 regs->gprs[14] = restorer; 316 regs->gprs[15] = (__force __u64) frame; 317 /* Force 31 bit amode and default user address space control. */ 318 regs->psw.mask = PSW_MASK_BA | 319 (PSW_USER_BITS & PSW_MASK_ASC) | 320 (regs->psw.mask & ~PSW_MASK_ASC); 321 regs->psw.addr = (__force __u64) ksig->ka.sa.sa_handler; 322 323 regs->gprs[2] = sig; 324 regs->gprs[3] = (__force __u64) &frame->sc; 325 326 /* We forgot to include these in the sigcontext. 327 To avoid breaking binary compatibility, they are passed as args. */ 328 if (sig == SIGSEGV || sig == SIGBUS || sig == SIGILL || 329 sig == SIGTRAP || sig == SIGFPE) { 330 /* set extra registers only for synchronous signals */ 331 regs->gprs[4] = regs->int_code & 127; 332 regs->gprs[5] = regs->int_parm_long; 333 regs->gprs[6] = current->thread.last_break; 334 } 335 336 return 0; 337 } 338 339 static int setup_rt_frame32(struct ksignal *ksig, sigset_t *set, 340 struct pt_regs *regs) 341 { 342 rt_sigframe32 __user *frame; 343 unsigned long restorer; 344 size_t frame_size; 345 u32 uc_flags; 346 347 frame_size = sizeof(*frame) - 348 sizeof(frame->uc.uc_mcontext_ext.__reserved); 349 /* 350 * gprs_high are always present for 31-bit compat tasks. 351 * The space for vector registers is only allocated if 352 * the machine supports it 353 */ 354 uc_flags = UC_GPRS_HIGH; 355 if (MACHINE_HAS_VX) { 356 uc_flags |= UC_VXRS; 357 } else 358 frame_size -= sizeof(frame->uc.uc_mcontext_ext.vxrs_low) + 359 sizeof(frame->uc.uc_mcontext_ext.vxrs_high); 360 frame = get_sigframe(&ksig->ka, regs, frame_size); 361 if (frame == (void __user *) -1UL) 362 return -EFAULT; 363 364 /* Set up backchain. */ 365 if (__put_user(regs->gprs[15], (unsigned int __force __user *) frame)) 366 return -EFAULT; 367 368 /* Set up to return from userspace. If provided, use a stub 369 already in userspace. */ 370 if (ksig->ka.sa.sa_flags & SA_RESTORER) { 371 restorer = (unsigned long __force) 372 ksig->ka.sa.sa_restorer | PSW32_ADDR_AMODE; 373 } else { 374 __u16 __user *svc = &frame->svc_insn; 375 if (__put_user(S390_SYSCALL_OPCODE | __NR_rt_sigreturn, svc)) 376 return -EFAULT; 377 restorer = (unsigned long __force) svc | PSW32_ADDR_AMODE; 378 } 379 380 /* Create siginfo on the signal stack */ 381 if (copy_siginfo_to_user32(&frame->info, &ksig->info)) 382 return -EFAULT; 383 384 /* Store registers needed to create the signal frame */ 385 store_sigregs(); 386 387 /* Create ucontext on the signal stack. */ 388 if (__put_user(uc_flags, &frame->uc.uc_flags) || 389 __put_user(0, &frame->uc.uc_link) || 390 __compat_save_altstack(&frame->uc.uc_stack, regs->gprs[15]) || 391 save_sigregs32(regs, &frame->uc.uc_mcontext) || 392 put_compat_sigset(&frame->uc.uc_sigmask, set, sizeof(compat_sigset_t)) || 393 save_sigregs_ext32(regs, &frame->uc.uc_mcontext_ext)) 394 return -EFAULT; 395 396 /* Set up registers for signal handler */ 397 regs->gprs[14] = restorer; 398 regs->gprs[15] = (__force __u64) frame; 399 /* Force 31 bit amode and default user address space control. */ 400 regs->psw.mask = PSW_MASK_BA | 401 (PSW_USER_BITS & PSW_MASK_ASC) | 402 (regs->psw.mask & ~PSW_MASK_ASC); 403 regs->psw.addr = (__u64 __force) ksig->ka.sa.sa_handler; 404 405 regs->gprs[2] = ksig->sig; 406 regs->gprs[3] = (__force __u64) &frame->info; 407 regs->gprs[4] = (__force __u64) &frame->uc; 408 regs->gprs[5] = current->thread.last_break; 409 return 0; 410 } 411 412 /* 413 * OK, we're invoking a handler 414 */ 415 416 void handle_signal32(struct ksignal *ksig, sigset_t *oldset, 417 struct pt_regs *regs) 418 { 419 int ret; 420 421 /* Set up the stack frame */ 422 if (ksig->ka.sa.sa_flags & SA_SIGINFO) 423 ret = setup_rt_frame32(ksig, oldset, regs); 424 else 425 ret = setup_frame32(ksig, oldset, regs); 426 427 signal_setup_done(ret, ksig, test_thread_flag(TIF_SINGLE_STEP)); 428 } 429 430