1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * arch/sparc64/kernel/signal.c 4 * 5 * Copyright (C) 1991, 1992 Linus Torvalds 6 * Copyright (C) 1995, 2008 David S. Miller (davem@davemloft.net) 7 * Copyright (C) 1996 Miguel de Icaza (miguel@nuclecu.unam.mx) 8 * Copyright (C) 1997 Eddie C. Dost (ecd@skynet.be) 9 * Copyright (C) 1997,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz) 10 */ 11 12 #include <linux/sched.h> 13 #include <linux/kernel.h> 14 #include <linux/signal.h> 15 #include <linux/errno.h> 16 #include <linux/wait.h> 17 #include <linux/ptrace.h> 18 #include <linux/resume_user_mode.h> 19 #include <linux/unistd.h> 20 #include <linux/mm.h> 21 #include <linux/tty.h> 22 #include <linux/binfmts.h> 23 #include <linux/bitops.h> 24 #include <linux/context_tracking.h> 25 26 #include <linux/uaccess.h> 27 #include <asm/ptrace.h> 28 #include <asm/fpumacro.h> 29 #include <asm/uctx.h> 30 #include <asm/siginfo.h> 31 #include <asm/visasm.h> 32 #include <asm/switch_to.h> 33 #include <asm/cacheflush.h> 34 35 #include "sigutil.h" 36 #include "systbls.h" 37 #include "kernel.h" 38 #include "entry.h" 39 40 /* {set, get}context() needed for 64-bit SparcLinux userland. */ 41 asmlinkage void sparc64_set_context(struct pt_regs *regs) 42 { 43 struct ucontext __user *ucp = (struct ucontext __user *) 44 regs->u_regs[UREG_I0]; 45 enum ctx_state prev_state = exception_enter(); 46 mc_gregset_t __user *grp; 47 unsigned long pc, npc, tstate; 48 unsigned long fp, i7; 49 unsigned char fenab; 50 int err; 51 52 synchronize_user_stack(); 53 if (get_thread_wsaved() || 54 (((unsigned long)ucp) & (sizeof(unsigned long)-1)) || 55 (!__access_ok(ucp, sizeof(*ucp)))) 56 goto do_sigsegv; 57 grp = &ucp->uc_mcontext.mc_gregs; 58 err = __get_user(pc, &((*grp)[MC_PC])); 59 err |= __get_user(npc, &((*grp)[MC_NPC])); 60 if (err || ((pc | npc) & 3)) 61 goto do_sigsegv; 62 if (regs->u_regs[UREG_I1]) { 63 sigset_t set; 64 65 if (_NSIG_WORDS == 1) { 66 if (__get_user(set.sig[0], &ucp->uc_sigmask.sig[0])) 67 goto do_sigsegv; 68 } else { 69 if (__copy_from_user(&set, &ucp->uc_sigmask, sizeof(sigset_t))) 70 goto do_sigsegv; 71 } 72 set_current_blocked(&set); 73 } 74 if (test_thread_flag(TIF_32BIT)) { 75 pc &= 0xffffffff; 76 npc &= 0xffffffff; 77 } 78 regs->tpc = pc; 79 regs->tnpc = npc; 80 err |= __get_user(regs->y, &((*grp)[MC_Y])); 81 err |= __get_user(tstate, &((*grp)[MC_TSTATE])); 82 regs->tstate &= ~(TSTATE_ASI | TSTATE_ICC | TSTATE_XCC); 83 regs->tstate |= (tstate & (TSTATE_ASI | TSTATE_ICC | TSTATE_XCC)); 84 err |= __get_user(regs->u_regs[UREG_G1], (&(*grp)[MC_G1])); 85 err |= __get_user(regs->u_regs[UREG_G2], (&(*grp)[MC_G2])); 86 err |= __get_user(regs->u_regs[UREG_G3], (&(*grp)[MC_G3])); 87 err |= __get_user(regs->u_regs[UREG_G4], (&(*grp)[MC_G4])); 88 err |= __get_user(regs->u_regs[UREG_G5], (&(*grp)[MC_G5])); 89 err |= __get_user(regs->u_regs[UREG_G6], (&(*grp)[MC_G6])); 90 91 /* Skip %g7 as that's the thread register in userspace. */ 92 93 err |= __get_user(regs->u_regs[UREG_I0], (&(*grp)[MC_O0])); 94 err |= __get_user(regs->u_regs[UREG_I1], (&(*grp)[MC_O1])); 95 err |= __get_user(regs->u_regs[UREG_I2], (&(*grp)[MC_O2])); 96 err |= __get_user(regs->u_regs[UREG_I3], (&(*grp)[MC_O3])); 97 err |= __get_user(regs->u_regs[UREG_I4], (&(*grp)[MC_O4])); 98 err |= __get_user(regs->u_regs[UREG_I5], (&(*grp)[MC_O5])); 99 err |= __get_user(regs->u_regs[UREG_I6], (&(*grp)[MC_O6])); 100 err |= __get_user(regs->u_regs[UREG_I7], (&(*grp)[MC_O7])); 101 102 err |= __get_user(fp, &(ucp->uc_mcontext.mc_fp)); 103 err |= __get_user(i7, &(ucp->uc_mcontext.mc_i7)); 104 err |= __put_user(fp, 105 (&(((struct reg_window __user *)(STACK_BIAS+regs->u_regs[UREG_I6]))->ins[6]))); 106 err |= __put_user(i7, 107 (&(((struct reg_window __user *)(STACK_BIAS+regs->u_regs[UREG_I6]))->ins[7]))); 108 109 err |= __get_user(fenab, &(ucp->uc_mcontext.mc_fpregs.mcfpu_enab)); 110 if (fenab) { 111 unsigned long *fpregs = current_thread_info()->fpregs; 112 unsigned long fprs; 113 114 fprs_write(0); 115 err |= __get_user(fprs, &(ucp->uc_mcontext.mc_fpregs.mcfpu_fprs)); 116 if (fprs & FPRS_DL) 117 err |= copy_from_user(fpregs, 118 &(ucp->uc_mcontext.mc_fpregs.mcfpu_fregs), 119 (sizeof(unsigned int) * 32)); 120 if (fprs & FPRS_DU) 121 err |= copy_from_user(fpregs+16, 122 ((unsigned long __user *)&(ucp->uc_mcontext.mc_fpregs.mcfpu_fregs))+16, 123 (sizeof(unsigned int) * 32)); 124 err |= __get_user(current_thread_info()->xfsr[0], 125 &(ucp->uc_mcontext.mc_fpregs.mcfpu_fsr)); 126 err |= __get_user(current_thread_info()->gsr[0], 127 &(ucp->uc_mcontext.mc_fpregs.mcfpu_gsr)); 128 regs->tstate &= ~TSTATE_PEF; 129 } 130 if (err) 131 goto do_sigsegv; 132 out: 133 exception_exit(prev_state); 134 return; 135 do_sigsegv: 136 force_sig(SIGSEGV); 137 goto out; 138 } 139 140 asmlinkage void sparc64_get_context(struct pt_regs *regs) 141 { 142 struct ucontext __user *ucp = (struct ucontext __user *) 143 regs->u_regs[UREG_I0]; 144 enum ctx_state prev_state = exception_enter(); 145 mc_gregset_t __user *grp; 146 mcontext_t __user *mcp; 147 unsigned long fp, i7; 148 unsigned char fenab; 149 int err; 150 151 synchronize_user_stack(); 152 if (get_thread_wsaved() || clear_user(ucp, sizeof(*ucp))) 153 goto do_sigsegv; 154 155 #if 1 156 fenab = 0; /* IMO get_context is like any other system call, thus modifies FPU state -jj */ 157 #else 158 fenab = (current_thread_info()->fpsaved[0] & FPRS_FEF); 159 #endif 160 161 mcp = &ucp->uc_mcontext; 162 grp = &mcp->mc_gregs; 163 164 /* Skip over the trap instruction, first. */ 165 if (test_thread_flag(TIF_32BIT)) { 166 regs->tpc = (regs->tnpc & 0xffffffff); 167 regs->tnpc = (regs->tnpc + 4) & 0xffffffff; 168 } else { 169 regs->tpc = regs->tnpc; 170 regs->tnpc += 4; 171 } 172 err = 0; 173 if (_NSIG_WORDS == 1) 174 err |= __put_user(current->blocked.sig[0], 175 (unsigned long __user *)&ucp->uc_sigmask); 176 else 177 err |= __copy_to_user(&ucp->uc_sigmask, ¤t->blocked, 178 sizeof(sigset_t)); 179 180 err |= __put_user(regs->tstate, &((*grp)[MC_TSTATE])); 181 err |= __put_user(regs->tpc, &((*grp)[MC_PC])); 182 err |= __put_user(regs->tnpc, &((*grp)[MC_NPC])); 183 err |= __put_user(regs->y, &((*grp)[MC_Y])); 184 err |= __put_user(regs->u_regs[UREG_G1], &((*grp)[MC_G1])); 185 err |= __put_user(regs->u_regs[UREG_G2], &((*grp)[MC_G2])); 186 err |= __put_user(regs->u_regs[UREG_G3], &((*grp)[MC_G3])); 187 err |= __put_user(regs->u_regs[UREG_G4], &((*grp)[MC_G4])); 188 err |= __put_user(regs->u_regs[UREG_G5], &((*grp)[MC_G5])); 189 err |= __put_user(regs->u_regs[UREG_G6], &((*grp)[MC_G6])); 190 err |= __put_user(regs->u_regs[UREG_G7], &((*grp)[MC_G7])); 191 err |= __put_user(regs->u_regs[UREG_I0], &((*grp)[MC_O0])); 192 err |= __put_user(regs->u_regs[UREG_I1], &((*grp)[MC_O1])); 193 err |= __put_user(regs->u_regs[UREG_I2], &((*grp)[MC_O2])); 194 err |= __put_user(regs->u_regs[UREG_I3], &((*grp)[MC_O3])); 195 err |= __put_user(regs->u_regs[UREG_I4], &((*grp)[MC_O4])); 196 err |= __put_user(regs->u_regs[UREG_I5], &((*grp)[MC_O5])); 197 err |= __put_user(regs->u_regs[UREG_I6], &((*grp)[MC_O6])); 198 err |= __put_user(regs->u_regs[UREG_I7], &((*grp)[MC_O7])); 199 200 err |= __get_user(fp, 201 (&(((struct reg_window __user *)(STACK_BIAS+regs->u_regs[UREG_I6]))->ins[6]))); 202 err |= __get_user(i7, 203 (&(((struct reg_window __user *)(STACK_BIAS+regs->u_regs[UREG_I6]))->ins[7]))); 204 err |= __put_user(fp, &(mcp->mc_fp)); 205 err |= __put_user(i7, &(mcp->mc_i7)); 206 207 err |= __put_user(fenab, &(mcp->mc_fpregs.mcfpu_enab)); 208 if (fenab) { 209 unsigned long *fpregs = current_thread_info()->fpregs; 210 unsigned long fprs; 211 212 fprs = current_thread_info()->fpsaved[0]; 213 if (fprs & FPRS_DL) 214 err |= copy_to_user(&(mcp->mc_fpregs.mcfpu_fregs), fpregs, 215 (sizeof(unsigned int) * 32)); 216 if (fprs & FPRS_DU) 217 err |= copy_to_user( 218 ((unsigned long __user *)&(mcp->mc_fpregs.mcfpu_fregs))+16, fpregs+16, 219 (sizeof(unsigned int) * 32)); 220 err |= __put_user(current_thread_info()->xfsr[0], &(mcp->mc_fpregs.mcfpu_fsr)); 221 err |= __put_user(current_thread_info()->gsr[0], &(mcp->mc_fpregs.mcfpu_gsr)); 222 err |= __put_user(fprs, &(mcp->mc_fpregs.mcfpu_fprs)); 223 } 224 if (err) 225 goto do_sigsegv; 226 out: 227 exception_exit(prev_state); 228 return; 229 do_sigsegv: 230 force_sig(SIGSEGV); 231 goto out; 232 } 233 234 /* Checks if the fp is valid. We always build rt signal frames which 235 * are 16-byte aligned, therefore we can always enforce that the 236 * restore frame has that property as well. 237 */ 238 static bool invalid_frame_pointer(void __user *fp) 239 { 240 if (((unsigned long) fp) & 15) 241 return true; 242 return false; 243 } 244 245 struct rt_signal_frame { 246 struct sparc_stackf ss; 247 siginfo_t info; 248 struct pt_regs regs; 249 __siginfo_fpu_t __user *fpu_save; 250 stack_t stack; 251 sigset_t mask; 252 __siginfo_rwin_t *rwin_save; 253 }; 254 255 void do_rt_sigreturn(struct pt_regs *regs) 256 { 257 unsigned long tpc, tnpc, tstate, ufp; 258 struct rt_signal_frame __user *sf; 259 __siginfo_fpu_t __user *fpu_save; 260 __siginfo_rwin_t __user *rwin_save; 261 sigset_t set; 262 int err; 263 264 /* Always make any pending restarted system calls return -EINTR */ 265 current->restart_block.fn = do_no_restart_syscall; 266 267 synchronize_user_stack (); 268 sf = (struct rt_signal_frame __user *) 269 (regs->u_regs [UREG_FP] + STACK_BIAS); 270 271 /* 1. Make sure we are not getting garbage from the user */ 272 if (invalid_frame_pointer(sf)) 273 goto segv; 274 275 if (get_user(ufp, &sf->regs.u_regs[UREG_FP])) 276 goto segv; 277 278 if ((ufp + STACK_BIAS) & 0x7) 279 goto segv; 280 281 err = __get_user(tpc, &sf->regs.tpc); 282 err |= __get_user(tnpc, &sf->regs.tnpc); 283 if (test_thread_flag(TIF_32BIT)) { 284 tpc &= 0xffffffff; 285 tnpc &= 0xffffffff; 286 } 287 err |= ((tpc | tnpc) & 3); 288 289 /* 2. Restore the state */ 290 err |= __get_user(regs->y, &sf->regs.y); 291 err |= __get_user(tstate, &sf->regs.tstate); 292 err |= copy_from_user(regs->u_regs, sf->regs.u_regs, sizeof(regs->u_regs)); 293 294 /* User can only change condition codes and %asi in %tstate. */ 295 regs->tstate &= ~(TSTATE_ASI | TSTATE_ICC | TSTATE_XCC); 296 regs->tstate |= (tstate & (TSTATE_ASI | TSTATE_ICC | TSTATE_XCC)); 297 298 err |= __get_user(fpu_save, &sf->fpu_save); 299 if (!err && fpu_save) 300 err |= restore_fpu_state(regs, fpu_save); 301 302 err |= __copy_from_user(&set, &sf->mask, sizeof(sigset_t)); 303 err |= restore_altstack(&sf->stack); 304 if (err) 305 goto segv; 306 307 err |= __get_user(rwin_save, &sf->rwin_save); 308 if (!err && rwin_save) { 309 if (restore_rwin_state(rwin_save)) 310 goto segv; 311 } 312 313 regs->tpc = tpc; 314 regs->tnpc = tnpc; 315 316 /* Prevent syscall restart. */ 317 pt_regs_clear_syscall(regs); 318 319 set_current_blocked(&set); 320 return; 321 segv: 322 force_sig(SIGSEGV); 323 } 324 325 static inline void __user *get_sigframe(struct ksignal *ksig, struct pt_regs *regs, unsigned long framesize) 326 { 327 unsigned long sp = regs->u_regs[UREG_FP] + STACK_BIAS; 328 329 /* 330 * If we are on the alternate signal stack and would overflow it, don't. 331 * Return an always-bogus address instead so we will die with SIGSEGV. 332 */ 333 if (on_sig_stack(sp) && !likely(on_sig_stack(sp - framesize))) 334 return (void __user *) -1L; 335 336 /* This is the X/Open sanctioned signal stack switching. */ 337 sp = sigsp(sp, ksig) - framesize; 338 339 /* Always align the stack frame. This handles two cases. First, 340 * sigaltstack need not be mindful of platform specific stack 341 * alignment. Second, if we took this signal because the stack 342 * is not aligned properly, we'd like to take the signal cleanly 343 * and report that. 344 */ 345 sp &= ~15UL; 346 347 return (void __user *) sp; 348 } 349 350 static inline int 351 setup_rt_frame(struct ksignal *ksig, struct pt_regs *regs) 352 { 353 struct rt_signal_frame __user *sf; 354 int wsaved, err, sf_size; 355 void __user *tail; 356 357 /* 1. Make sure everything is clean */ 358 synchronize_user_stack(); 359 save_and_clear_fpu(); 360 361 wsaved = get_thread_wsaved(); 362 363 sf_size = sizeof(struct rt_signal_frame); 364 if (current_thread_info()->fpsaved[0] & FPRS_FEF) 365 sf_size += sizeof(__siginfo_fpu_t); 366 if (wsaved) 367 sf_size += sizeof(__siginfo_rwin_t); 368 sf = (struct rt_signal_frame __user *) 369 get_sigframe(ksig, regs, sf_size); 370 371 if (invalid_frame_pointer (sf)) { 372 if (show_unhandled_signals) 373 pr_info("%s[%d] bad frame in setup_rt_frame: %016lx TPC %016lx O7 %016lx\n", 374 current->comm, current->pid, (unsigned long)sf, 375 regs->tpc, regs->u_regs[UREG_I7]); 376 force_sigsegv(ksig->sig); 377 return -EINVAL; 378 } 379 380 tail = (sf + 1); 381 382 /* 2. Save the current process state */ 383 err = copy_to_user(&sf->regs, regs, sizeof (*regs)); 384 385 if (current_thread_info()->fpsaved[0] & FPRS_FEF) { 386 __siginfo_fpu_t __user *fpu_save = tail; 387 tail += sizeof(__siginfo_fpu_t); 388 err |= save_fpu_state(regs, fpu_save); 389 err |= __put_user((u64)fpu_save, &sf->fpu_save); 390 } else { 391 err |= __put_user(0, &sf->fpu_save); 392 } 393 if (wsaved) { 394 __siginfo_rwin_t __user *rwin_save = tail; 395 tail += sizeof(__siginfo_rwin_t); 396 err |= save_rwin_state(wsaved, rwin_save); 397 err |= __put_user((u64)rwin_save, &sf->rwin_save); 398 set_thread_wsaved(0); 399 } else { 400 err |= __put_user(0, &sf->rwin_save); 401 } 402 403 /* Setup sigaltstack */ 404 err |= __save_altstack(&sf->stack, regs->u_regs[UREG_FP]); 405 406 err |= copy_to_user(&sf->mask, sigmask_to_save(), sizeof(sigset_t)); 407 408 if (!wsaved) { 409 err |= raw_copy_in_user((u64 __user *)sf, 410 (u64 __user *)(regs->u_regs[UREG_FP] + 411 STACK_BIAS), 412 sizeof(struct reg_window)); 413 } else { 414 struct reg_window *rp; 415 416 rp = ¤t_thread_info()->reg_window[wsaved - 1]; 417 err |= copy_to_user(sf, rp, sizeof(struct reg_window)); 418 } 419 if (ksig->ka.sa.sa_flags & SA_SIGINFO) 420 err |= copy_siginfo_to_user(&sf->info, &ksig->info); 421 else { 422 err |= __put_user(ksig->sig, &sf->info.si_signo); 423 err |= __put_user(SI_NOINFO, &sf->info.si_code); 424 } 425 if (err) 426 return err; 427 428 /* 3. signal handler back-trampoline and parameters */ 429 regs->u_regs[UREG_FP] = ((unsigned long) sf) - STACK_BIAS; 430 regs->u_regs[UREG_I0] = ksig->sig; 431 regs->u_regs[UREG_I1] = (unsigned long) &sf->info; 432 433 /* The sigcontext is passed in this way because of how it 434 * is defined in GLIBC's /usr/include/bits/sigcontext.h 435 * for sparc64. It includes the 128 bytes of siginfo_t. 436 */ 437 regs->u_regs[UREG_I2] = (unsigned long) &sf->info; 438 439 /* 5. signal handler */ 440 regs->tpc = (unsigned long) ksig->ka.sa.sa_handler; 441 regs->tnpc = (regs->tpc + 4); 442 if (test_thread_flag(TIF_32BIT)) { 443 regs->tpc &= 0xffffffff; 444 regs->tnpc &= 0xffffffff; 445 } 446 /* 4. return to kernel instructions */ 447 regs->u_regs[UREG_I7] = (unsigned long)ksig->ka.ka_restorer; 448 return 0; 449 } 450 451 static inline void syscall_restart(unsigned long orig_i0, struct pt_regs *regs, 452 struct sigaction *sa) 453 { 454 switch (regs->u_regs[UREG_I0]) { 455 case ERESTART_RESTARTBLOCK: 456 case ERESTARTNOHAND: 457 no_system_call_restart: 458 regs->u_regs[UREG_I0] = EINTR; 459 regs->tstate |= (TSTATE_ICARRY|TSTATE_XCARRY); 460 break; 461 case ERESTARTSYS: 462 if (!(sa->sa_flags & SA_RESTART)) 463 goto no_system_call_restart; 464 fallthrough; 465 case ERESTARTNOINTR: 466 regs->u_regs[UREG_I0] = orig_i0; 467 regs->tpc -= 4; 468 regs->tnpc -= 4; 469 } 470 } 471 472 /* Note that 'init' is a special process: it doesn't get signals it doesn't 473 * want to handle. Thus you cannot kill init even with a SIGKILL even by 474 * mistake. 475 */ 476 static void do_signal(struct pt_regs *regs, unsigned long orig_i0) 477 { 478 struct ksignal ksig; 479 int restart_syscall; 480 bool has_handler; 481 482 /* It's a lot of work and synchronization to add a new ptrace 483 * register for GDB to save and restore in order to get 484 * orig_i0 correct for syscall restarts when debugging. 485 * 486 * Although it should be the case that most of the global 487 * registers are volatile across a system call, glibc already 488 * depends upon that fact that we preserve them. So we can't 489 * just use any global register to save away the orig_i0 value. 490 * 491 * In particular %g2, %g3, %g4, and %g5 are all assumed to be 492 * preserved across a system call trap by various pieces of 493 * code in glibc. 494 * 495 * %g7 is used as the "thread register". %g6 is not used in 496 * any fixed manner. %g6 is used as a scratch register and 497 * a compiler temporary, but it's value is never used across 498 * a system call. Therefore %g6 is usable for orig_i0 storage. 499 */ 500 if (pt_regs_is_syscall(regs) && 501 (regs->tstate & (TSTATE_XCARRY | TSTATE_ICARRY))) 502 regs->u_regs[UREG_G6] = orig_i0; 503 504 #ifdef CONFIG_COMPAT 505 if (test_thread_flag(TIF_32BIT)) { 506 do_signal32(regs); 507 return; 508 } 509 #endif 510 511 has_handler = get_signal(&ksig); 512 513 restart_syscall = 0; 514 if (pt_regs_is_syscall(regs) && 515 (regs->tstate & (TSTATE_XCARRY | TSTATE_ICARRY))) { 516 restart_syscall = 1; 517 orig_i0 = regs->u_regs[UREG_G6]; 518 } 519 520 if (has_handler) { 521 if (restart_syscall) 522 syscall_restart(orig_i0, regs, &ksig.ka.sa); 523 signal_setup_done(setup_rt_frame(&ksig, regs), &ksig, 0); 524 } else { 525 if (restart_syscall) { 526 switch (regs->u_regs[UREG_I0]) { 527 case ERESTARTNOHAND: 528 case ERESTARTSYS: 529 case ERESTARTNOINTR: 530 /* replay the system call when we are done */ 531 regs->u_regs[UREG_I0] = orig_i0; 532 regs->tpc -= 4; 533 regs->tnpc -= 4; 534 pt_regs_clear_syscall(regs); 535 fallthrough; 536 case ERESTART_RESTARTBLOCK: 537 regs->u_regs[UREG_G1] = __NR_restart_syscall; 538 regs->tpc -= 4; 539 regs->tnpc -= 4; 540 pt_regs_clear_syscall(regs); 541 } 542 } 543 restore_saved_sigmask(); 544 } 545 } 546 547 void do_notify_resume(struct pt_regs *regs, unsigned long orig_i0, unsigned long thread_info_flags) 548 { 549 user_exit(); 550 if (thread_info_flags & _TIF_UPROBE) 551 uprobe_notify_resume(regs); 552 if (thread_info_flags & (_TIF_SIGPENDING | _TIF_NOTIFY_SIGNAL)) 553 do_signal(regs, orig_i0); 554 if (thread_info_flags & _TIF_NOTIFY_RESUME) 555 resume_user_mode_work(regs); 556 user_enter(); 557 } 558 559 /* 560 * Compile-time assertions for siginfo_t offsets. Check NSIG* as well, as 561 * changes likely come with new fields that should be added below. 562 */ 563 static_assert(NSIGILL == 11); 564 static_assert(NSIGFPE == 15); 565 static_assert(NSIGSEGV == 10); 566 static_assert(NSIGBUS == 5); 567 static_assert(NSIGTRAP == 6); 568 static_assert(NSIGCHLD == 6); 569 static_assert(NSIGSYS == 2); 570 static_assert(sizeof(siginfo_t) == 128); 571 static_assert(__alignof__(siginfo_t) == 8); 572 static_assert(offsetof(siginfo_t, si_signo) == 0x00); 573 static_assert(offsetof(siginfo_t, si_errno) == 0x04); 574 static_assert(offsetof(siginfo_t, si_code) == 0x08); 575 static_assert(offsetof(siginfo_t, si_pid) == 0x10); 576 static_assert(offsetof(siginfo_t, si_uid) == 0x14); 577 static_assert(offsetof(siginfo_t, si_tid) == 0x10); 578 static_assert(offsetof(siginfo_t, si_overrun) == 0x14); 579 static_assert(offsetof(siginfo_t, si_status) == 0x18); 580 static_assert(offsetof(siginfo_t, si_utime) == 0x20); 581 static_assert(offsetof(siginfo_t, si_stime) == 0x28); 582 static_assert(offsetof(siginfo_t, si_value) == 0x18); 583 static_assert(offsetof(siginfo_t, si_int) == 0x18); 584 static_assert(offsetof(siginfo_t, si_ptr) == 0x18); 585 static_assert(offsetof(siginfo_t, si_addr) == 0x10); 586 static_assert(offsetof(siginfo_t, si_trapno) == 0x18); 587 static_assert(offsetof(siginfo_t, si_addr_lsb) == 0x18); 588 static_assert(offsetof(siginfo_t, si_lower) == 0x20); 589 static_assert(offsetof(siginfo_t, si_upper) == 0x28); 590 static_assert(offsetof(siginfo_t, si_pkey) == 0x20); 591 static_assert(offsetof(siginfo_t, si_perf_data) == 0x18); 592 static_assert(offsetof(siginfo_t, si_perf_type) == 0x20); 593 static_assert(offsetof(siginfo_t, si_perf_flags) == 0x24); 594 static_assert(offsetof(siginfo_t, si_band) == 0x10); 595 static_assert(offsetof(siginfo_t, si_fd) == 0x14); 596