1// SPDX-License-Identifier: GPL-2.0-only 2/* 3 * linux/arch/arm/kernel/signal.c 4 * 5 * Copyright (C) 1995-2009 Russell King 6 */ 7#include <linux/errno.h> 8#include <linux/random.h> 9#include <linux/signal.h> 10#include <linux/personality.h> 11#include <linux/uaccess.h> 12#include <linux/resume_user_mode.h> 13#include <linux/uprobes.h> 14#include <linux/syscalls.h> 15 16#include <asm/elf.h> 17#include <asm/cacheflush.h> 18#include <asm/traps.h> 19#include <asm/unistd.h> 20#include <asm/vfp.h> 21#include <asm/syscalls.h> 22 23#include "signal.h" 24 25extern const unsigned long sigreturn_codes[17]; 26 27static unsigned long signal_return_offset; 28 29#ifdef CONFIG_IWMMXT 30 31static int preserve_iwmmxt_context(struct iwmmxt_sigframe __user *frame) 32{ 33 char kbuf[sizeof(*frame) + 8]; 34 struct iwmmxt_sigframe *kframe; 35 int err = 0; 36 37 /* the iWMMXt context must be 64 bit aligned */ 38 kframe = (struct iwmmxt_sigframe *)((unsigned long)(kbuf + 8) & ~7); 39 40 if (test_thread_flag(TIF_USING_IWMMXT)) { 41 kframe->magic = IWMMXT_MAGIC; 42 kframe->size = IWMMXT_STORAGE_SIZE; 43 iwmmxt_task_copy(current_thread_info(), &kframe->storage); 44 } else { 45 /* 46 * For bug-compatibility with older kernels, some space 47 * has to be reserved for iWMMXt even if it's not used. 48 * Set the magic and size appropriately so that properly 49 * written userspace can skip it reliably: 50 */ 51 *kframe = (struct iwmmxt_sigframe) { 52 .magic = DUMMY_MAGIC, 53 .size = IWMMXT_STORAGE_SIZE, 54 }; 55 } 56 57 err = __copy_to_user(frame, kframe, sizeof(*kframe)); 58 59 return err; 60} 61 62static int restore_iwmmxt_context(char __user **auxp) 63{ 64 struct iwmmxt_sigframe __user *frame = 65 (struct iwmmxt_sigframe __user *)*auxp; 66 char kbuf[sizeof(*frame) + 8]; 67 struct iwmmxt_sigframe *kframe; 68 69 /* the iWMMXt context must be 64 bit aligned */ 70 kframe = (struct iwmmxt_sigframe *)((unsigned long)(kbuf + 8) & ~7); 71 if (__copy_from_user(kframe, frame, sizeof(*frame))) 72 return -1; 73 74 /* 75 * For non-iWMMXt threads: a single iwmmxt_sigframe-sized dummy 76 * block is discarded for compatibility with setup_sigframe() if 77 * present, but we don't mandate its presence. If some other 78 * magic is here, it's not for us: 79 */ 80 if (!test_thread_flag(TIF_USING_IWMMXT) && 81 kframe->magic != DUMMY_MAGIC) 82 return 0; 83 84 if (kframe->size != IWMMXT_STORAGE_SIZE) 85 return -1; 86 87 if (test_thread_flag(TIF_USING_IWMMXT)) { 88 if (kframe->magic != IWMMXT_MAGIC) 89 return -1; 90 91 iwmmxt_task_restore(current_thread_info(), &kframe->storage); 92 } 93 94 *auxp += IWMMXT_STORAGE_SIZE; 95 return 0; 96} 97 98#endif 99 100#ifdef CONFIG_VFP 101 102static int preserve_vfp_context(struct vfp_sigframe __user *frame) 103{ 104 struct vfp_sigframe kframe; 105 int err = 0; 106 107 memset(&kframe, 0, sizeof(kframe)); 108 kframe.magic = VFP_MAGIC; 109 kframe.size = VFP_STORAGE_SIZE; 110 111 err = vfp_preserve_user_clear_hwstate(&kframe.ufp, &kframe.ufp_exc); 112 if (err) 113 return err; 114 115 return __copy_to_user(frame, &kframe, sizeof(kframe)); 116} 117 118static int restore_vfp_context(char __user **auxp) 119{ 120 struct vfp_sigframe frame; 121 int err; 122 123 err = __copy_from_user(&frame, *auxp, sizeof(frame)); 124 if (err) 125 return err; 126 127 if (frame.magic != VFP_MAGIC || frame.size != VFP_STORAGE_SIZE) 128 return -EINVAL; 129 130 *auxp += sizeof(frame); 131 return vfp_restore_user_hwstate(&frame.ufp, &frame.ufp_exc); 132} 133 134#endif 135 136/* 137 * Do a signal return; undo the signal stack. These are aligned to 64-bit. 138 */ 139 140static int restore_sigframe(struct pt_regs *regs, struct sigframe __user *sf) 141{ 142 struct sigcontext context; 143 char __user *aux; 144 sigset_t set; 145 int err; 146 147 err = __copy_from_user(&set, &sf->uc.uc_sigmask, sizeof(set)); 148 if (err == 0) 149 set_current_blocked(&set); 150 151 err |= __copy_from_user(&context, &sf->uc.uc_mcontext, sizeof(context)); 152 if (err == 0) { 153 regs->ARM_r0 = context.arm_r0; 154 regs->ARM_r1 = context.arm_r1; 155 regs->ARM_r2 = context.arm_r2; 156 regs->ARM_r3 = context.arm_r3; 157 regs->ARM_r4 = context.arm_r4; 158 regs->ARM_r5 = context.arm_r5; 159 regs->ARM_r6 = context.arm_r6; 160 regs->ARM_r7 = context.arm_r7; 161 regs->ARM_r8 = context.arm_r8; 162 regs->ARM_r9 = context.arm_r9; 163 regs->ARM_r10 = context.arm_r10; 164 regs->ARM_fp = context.arm_fp; 165 regs->ARM_ip = context.arm_ip; 166 regs->ARM_sp = context.arm_sp; 167 regs->ARM_lr = context.arm_lr; 168 regs->ARM_pc = context.arm_pc; 169 regs->ARM_cpsr = context.arm_cpsr; 170 } 171 172 err |= !valid_user_regs(regs); 173 174 aux = (char __user *) sf->uc.uc_regspace; 175#ifdef CONFIG_IWMMXT 176 if (err == 0) 177 err |= restore_iwmmxt_context(&aux); 178#endif 179#ifdef CONFIG_VFP 180 if (err == 0) 181 err |= restore_vfp_context(&aux); 182#endif 183 184 return err; 185} 186 187asmlinkage int sys_sigreturn(struct pt_regs *regs) 188{ 189 struct sigframe __user *frame; 190 191 /* Always make any pending restarted system calls return -EINTR */ 192 current->restart_block.fn = do_no_restart_syscall; 193 194 /* 195 * Since we stacked the signal on a 64-bit boundary, 196 * then 'sp' should be word aligned here. If it's 197 * not, then the user is trying to mess with us. 198 */ 199 if (regs->ARM_sp & 7) 200 goto badframe; 201 202 frame = (struct sigframe __user *)regs->ARM_sp; 203 204 if (!access_ok(frame, sizeof (*frame))) 205 goto badframe; 206 207 if (restore_sigframe(regs, frame)) 208 goto badframe; 209 210 return regs->ARM_r0; 211 212badframe: 213 force_sig(SIGSEGV); 214 return 0; 215} 216 217asmlinkage int sys_rt_sigreturn(struct pt_regs *regs) 218{ 219 struct rt_sigframe __user *frame; 220 221 /* Always make any pending restarted system calls return -EINTR */ 222 current->restart_block.fn = do_no_restart_syscall; 223 224 /* 225 * Since we stacked the signal on a 64-bit boundary, 226 * then 'sp' should be word aligned here. If it's 227 * not, then the user is trying to mess with us. 228 */ 229 if (regs->ARM_sp & 7) 230 goto badframe; 231 232 frame = (struct rt_sigframe __user *)regs->ARM_sp; 233 234 if (!access_ok(frame, sizeof (*frame))) 235 goto badframe; 236 237 if (restore_sigframe(regs, &frame->sig)) 238 goto badframe; 239 240 if (restore_altstack(&frame->sig.uc.uc_stack)) 241 goto badframe; 242 243 return regs->ARM_r0; 244 245badframe: 246 force_sig(SIGSEGV); 247 return 0; 248} 249 250static int 251setup_sigframe(struct sigframe __user *sf, struct pt_regs *regs, sigset_t *set) 252{ 253 struct aux_sigframe __user *aux; 254 struct sigcontext context; 255 int err = 0; 256 257 context = (struct sigcontext) { 258 .arm_r0 = regs->ARM_r0, 259 .arm_r1 = regs->ARM_r1, 260 .arm_r2 = regs->ARM_r2, 261 .arm_r3 = regs->ARM_r3, 262 .arm_r4 = regs->ARM_r4, 263 .arm_r5 = regs->ARM_r5, 264 .arm_r6 = regs->ARM_r6, 265 .arm_r7 = regs->ARM_r7, 266 .arm_r8 = regs->ARM_r8, 267 .arm_r9 = regs->ARM_r9, 268 .arm_r10 = regs->ARM_r10, 269 .arm_fp = regs->ARM_fp, 270 .arm_ip = regs->ARM_ip, 271 .arm_sp = regs->ARM_sp, 272 .arm_lr = regs->ARM_lr, 273 .arm_pc = regs->ARM_pc, 274 .arm_cpsr = regs->ARM_cpsr, 275 276 .trap_no = current->thread.trap_no, 277 .error_code = current->thread.error_code, 278 .fault_address = current->thread.address, 279 .oldmask = set->sig[0], 280 }; 281 282 err |= __copy_to_user(&sf->uc.uc_mcontext, &context, sizeof(context)); 283 284 err |= __copy_to_user(&sf->uc.uc_sigmask, set, sizeof(*set)); 285 286 aux = (struct aux_sigframe __user *) sf->uc.uc_regspace; 287#ifdef CONFIG_IWMMXT 288 if (err == 0) 289 err |= preserve_iwmmxt_context(&aux->iwmmxt); 290#endif 291#ifdef CONFIG_VFP 292 if (err == 0) 293 err |= preserve_vfp_context(&aux->vfp); 294#endif 295 err |= __put_user(0, &aux->end_magic); 296 297 return err; 298} 299 300static inline void __user * 301get_sigframe(struct ksignal *ksig, struct pt_regs *regs, int framesize) 302{ 303 unsigned long sp = sigsp(regs->ARM_sp, ksig); 304 void __user *frame; 305 306 /* 307 * ATPCS B01 mandates 8-byte alignment 308 */ 309 frame = (void __user *)((sp - framesize) & ~7); 310 311 /* 312 * Check that we can actually write to the signal frame. 313 */ 314 if (!access_ok(frame, framesize)) 315 frame = NULL; 316 317 return frame; 318} 319 320static int 321setup_return(struct pt_regs *regs, struct ksignal *ksig, 322 unsigned long __user *rc, void __user *frame) 323{ 324 unsigned long handler = (unsigned long)ksig->ka.sa.sa_handler; 325 unsigned long handler_fdpic_GOT = 0; 326 unsigned long retcode; 327 unsigned int idx, thumb = 0; 328 unsigned long cpsr = regs->ARM_cpsr & ~(PSR_f | PSR_E_BIT); 329 bool fdpic = IS_ENABLED(CONFIG_BINFMT_ELF_FDPIC) && 330 (current->personality & FDPIC_FUNCPTRS); 331 332 if (fdpic) { 333 unsigned long __user *fdpic_func_desc = 334 (unsigned long __user *)handler; 335 if (__get_user(handler, &fdpic_func_desc[0]) || 336 __get_user(handler_fdpic_GOT, &fdpic_func_desc[1])) 337 return 1; 338 } 339 340 cpsr |= PSR_ENDSTATE; 341 342 /* 343 * Maybe we need to deliver a 32-bit signal to a 26-bit task. 344 */ 345 if (ksig->ka.sa.sa_flags & SA_THIRTYTWO) 346 cpsr = (cpsr & ~MODE_MASK) | USR_MODE; 347 348#ifdef CONFIG_ARM_THUMB 349 if (elf_hwcap & HWCAP_THUMB) { 350 /* 351 * The LSB of the handler determines if we're going to 352 * be using THUMB or ARM mode for this signal handler. 353 */ 354 thumb = handler & 1; 355 356 /* 357 * Clear the If-Then Thumb-2 execution state. ARM spec 358 * requires this to be all 000s in ARM mode. Snapdragon 359 * S4/Krait misbehaves on a Thumb=>ARM signal transition 360 * without this. 361 * 362 * We must do this whenever we are running on a Thumb-2 363 * capable CPU, which includes ARMv6T2. However, we elect 364 * to always do this to simplify the code; this field is 365 * marked UNK/SBZP for older architectures. 366 */ 367 cpsr &= ~PSR_IT_MASK; 368 369 if (thumb) { 370 cpsr |= PSR_T_BIT; 371 } else 372 cpsr &= ~PSR_T_BIT; 373 } 374#endif 375 376 if (ksig->ka.sa.sa_flags & SA_RESTORER) { 377 retcode = (unsigned long)ksig->ka.sa.sa_restorer; 378 if (fdpic) { 379 /* 380 * We need code to load the function descriptor. 381 * That code follows the standard sigreturn code 382 * (6 words), and is made of 3 + 2 words for each 383 * variant. The 4th copied word is the actual FD 384 * address that the assembly code expects. 385 */ 386 idx = 6 + thumb * 3; 387 if (ksig->ka.sa.sa_flags & SA_SIGINFO) 388 idx += 5; 389 if (__put_user(sigreturn_codes[idx], rc ) || 390 __put_user(sigreturn_codes[idx+1], rc+1) || 391 __put_user(sigreturn_codes[idx+2], rc+2) || 392 __put_user(retcode, rc+3)) 393 return 1; 394 goto rc_finish; 395 } 396 } else { 397 idx = thumb << 1; 398 if (ksig->ka.sa.sa_flags & SA_SIGINFO) 399 idx += 3; 400 401 /* 402 * Put the sigreturn code on the stack no matter which return 403 * mechanism we use in order to remain ABI compliant 404 */ 405 if (__put_user(sigreturn_codes[idx], rc) || 406 __put_user(sigreturn_codes[idx+1], rc+1)) 407 return 1; 408 409rc_finish: 410#ifdef CONFIG_MMU 411 if (cpsr & MODE32_BIT) { 412 struct mm_struct *mm = current->mm; 413 414 /* 415 * 32-bit code can use the signal return page 416 * except when the MPU has protected the vectors 417 * page from PL0 418 */ 419 retcode = mm->context.sigpage + signal_return_offset + 420 (idx << 2) + thumb; 421 } else 422#endif 423 { 424 /* 425 * Ensure that the instruction cache sees 426 * the return code written onto the stack. 427 */ 428 flush_icache_range((unsigned long)rc, 429 (unsigned long)(rc + 3)); 430 431 retcode = ((unsigned long)rc) + thumb; 432 } 433 } 434 435 regs->ARM_r0 = ksig->sig; 436 regs->ARM_sp = (unsigned long)frame; 437 regs->ARM_lr = retcode; 438 regs->ARM_pc = handler; 439 if (fdpic) 440 regs->ARM_r9 = handler_fdpic_GOT; 441 regs->ARM_cpsr = cpsr; 442 443 return 0; 444} 445 446static int 447setup_frame(struct ksignal *ksig, sigset_t *set, struct pt_regs *regs) 448{ 449 struct sigframe __user *frame = get_sigframe(ksig, regs, sizeof(*frame)); 450 int err = 0; 451 452 if (!frame) 453 return 1; 454 455 /* 456 * Set uc.uc_flags to a value which sc.trap_no would never have. 457 */ 458 err = __put_user(0x5ac3c35a, &frame->uc.uc_flags); 459 460 err |= setup_sigframe(frame, regs, set); 461 if (err == 0) 462 err = setup_return(regs, ksig, frame->retcode, frame); 463 464 return err; 465} 466 467static int 468setup_rt_frame(struct ksignal *ksig, sigset_t *set, struct pt_regs *regs) 469{ 470 struct rt_sigframe __user *frame = get_sigframe(ksig, regs, sizeof(*frame)); 471 int err = 0; 472 473 if (!frame) 474 return 1; 475 476 err |= copy_siginfo_to_user(&frame->info, &ksig->info); 477 478 err |= __put_user(0, &frame->sig.uc.uc_flags); 479 err |= __put_user(NULL, &frame->sig.uc.uc_link); 480 481 err |= __save_altstack(&frame->sig.uc.uc_stack, regs->ARM_sp); 482 err |= setup_sigframe(&frame->sig, regs, set); 483 if (err == 0) 484 err = setup_return(regs, ksig, frame->sig.retcode, frame); 485 486 if (err == 0) { 487 /* 488 * For realtime signals we must also set the second and third 489 * arguments for the signal handler. 490 * -- Peter Maydell <pmaydell@chiark.greenend.org.uk> 2000-12-06 491 */ 492 regs->ARM_r1 = (unsigned long)&frame->info; 493 regs->ARM_r2 = (unsigned long)&frame->sig.uc; 494 } 495 496 return err; 497} 498 499/* 500 * OK, we're invoking a handler 501 */ 502static void handle_signal(struct ksignal *ksig, struct pt_regs *regs) 503{ 504 sigset_t *oldset = sigmask_to_save(); 505 int ret; 506 507 /* 508 * Perform fixup for the pre-signal frame. 509 */ 510 rseq_signal_deliver(ksig, regs); 511 512 /* 513 * Set up the stack frame 514 */ 515 if (ksig->ka.sa.sa_flags & SA_SIGINFO) 516 ret = setup_rt_frame(ksig, oldset, regs); 517 else 518 ret = setup_frame(ksig, oldset, regs); 519 520 /* 521 * Check that the resulting registers are actually sane. 522 */ 523 ret |= !valid_user_regs(regs); 524 525 signal_setup_done(ret, ksig, 0); 526} 527 528/* 529 * Note that 'init' is a special process: it doesn't get signals it doesn't 530 * want to handle. Thus you cannot kill init even with a SIGKILL even by 531 * mistake. 532 * 533 * Note that we go through the signals twice: once to check the signals that 534 * the kernel can handle, and then we build all the user-level signal handling 535 * stack-frames in one go after that. 536 */ 537static int do_signal(struct pt_regs *regs, int syscall) 538{ 539 unsigned int retval = 0, continue_addr = 0, restart_addr = 0; 540 struct ksignal ksig; 541 int restart = 0; 542 543 /* 544 * If we were from a system call, check for system call restarting... 545 */ 546 if (syscall) { 547 continue_addr = regs->ARM_pc; 548 restart_addr = continue_addr - (thumb_mode(regs) ? 2 : 4); 549 retval = regs->ARM_r0; 550 551 /* 552 * Prepare for system call restart. We do this here so that a 553 * debugger will see the already changed PSW. 554 */ 555 switch (retval) { 556 case -ERESTART_RESTARTBLOCK: 557 restart -= 2; 558 fallthrough; 559 case -ERESTARTNOHAND: 560 case -ERESTARTSYS: 561 case -ERESTARTNOINTR: 562 restart++; 563 regs->ARM_r0 = regs->ARM_ORIG_r0; 564 regs->ARM_pc = restart_addr; 565 break; 566 } 567 } 568 569 /* 570 * Get the signal to deliver. When running under ptrace, at this 571 * point the debugger may change all our registers ... 572 */ 573 /* 574 * Depending on the signal settings we may need to revert the 575 * decision to restart the system call. But skip this if a 576 * debugger has chosen to restart at a different PC. 577 */ 578 if (get_signal(&ksig)) { 579 /* handler */ 580 if (unlikely(restart) && regs->ARM_pc == restart_addr) { 581 if (retval == -ERESTARTNOHAND || 582 retval == -ERESTART_RESTARTBLOCK 583 || (retval == -ERESTARTSYS 584 && !(ksig.ka.sa.sa_flags & SA_RESTART))) { 585 regs->ARM_r0 = -EINTR; 586 regs->ARM_pc = continue_addr; 587 } 588 } 589 handle_signal(&ksig, regs); 590 } else { 591 /* no handler */ 592 restore_saved_sigmask(); 593 if (unlikely(restart) && regs->ARM_pc == restart_addr) { 594 regs->ARM_pc = continue_addr; 595 return restart; 596 } 597 } 598 return 0; 599} 600 601asmlinkage int 602do_work_pending(struct pt_regs *regs, unsigned int thread_flags, int syscall) 603{ 604 /* 605 * The assembly code enters us with IRQs off, but it hasn't 606 * informed the tracing code of that for efficiency reasons. 607 * Update the trace code with the current status. 608 */ 609 trace_hardirqs_off(); 610 do { 611 if (likely(thread_flags & _TIF_NEED_RESCHED)) { 612 schedule(); 613 } else { 614 if (unlikely(!user_mode(regs))) 615 return 0; 616 local_irq_enable(); 617 if (thread_flags & (_TIF_SIGPENDING | _TIF_NOTIFY_SIGNAL)) { 618 int restart = do_signal(regs, syscall); 619 if (unlikely(restart)) { 620 /* 621 * Restart without handlers. 622 * Deal with it without leaving 623 * the kernel space. 624 */ 625 return restart; 626 } 627 syscall = 0; 628 } else if (thread_flags & _TIF_UPROBE) { 629 uprobe_notify_resume(regs); 630 } else { 631 resume_user_mode_work(regs); 632 } 633 } 634 local_irq_disable(); 635 thread_flags = read_thread_flags(); 636 } while (thread_flags & _TIF_WORK_MASK); 637 return 0; 638} 639 640struct page *get_signal_page(void) 641{ 642 unsigned long ptr; 643 unsigned offset; 644 struct page *page; 645 void *addr; 646 647 page = alloc_pages(GFP_KERNEL, 0); 648 649 if (!page) 650 return NULL; 651 652 addr = page_address(page); 653 654 /* Poison the entire page */ 655 memset32(addr, __opcode_to_mem_arm(0xe7fddef1), 656 PAGE_SIZE / sizeof(u32)); 657 658 /* Give the signal return code some randomness */ 659 offset = 0x200 + (get_random_u16() & 0x7fc); 660 signal_return_offset = offset; 661 662 /* Copy signal return handlers into the page */ 663 memcpy(addr + offset, sigreturn_codes, sizeof(sigreturn_codes)); 664 665 /* Flush out all instructions in this page */ 666 ptr = (unsigned long)addr; 667 flush_icache_range(ptr, ptr + PAGE_SIZE); 668 669 return page; 670} 671 672#ifdef CONFIG_DEBUG_RSEQ 673asmlinkage void do_rseq_syscall(struct pt_regs *regs) 674{ 675 rseq_syscall(regs); 676} 677#endif 678 679/* 680 * Compile-time assertions for siginfo_t offsets. Check NSIG* as well, as 681 * changes likely come with new fields that should be added below. 682 */ 683static_assert(NSIGILL == 11); 684static_assert(NSIGFPE == 15); 685static_assert(NSIGSEGV == 10); 686static_assert(NSIGBUS == 5); 687static_assert(NSIGTRAP == 6); 688static_assert(NSIGCHLD == 6); 689static_assert(NSIGSYS == 2); 690static_assert(sizeof(siginfo_t) == 128); 691static_assert(__alignof__(siginfo_t) == 4); 692static_assert(offsetof(siginfo_t, si_signo) == 0x00); 693static_assert(offsetof(siginfo_t, si_errno) == 0x04); 694static_assert(offsetof(siginfo_t, si_code) == 0x08); 695static_assert(offsetof(siginfo_t, si_pid) == 0x0c); 696static_assert(offsetof(siginfo_t, si_uid) == 0x10); 697static_assert(offsetof(siginfo_t, si_tid) == 0x0c); 698static_assert(offsetof(siginfo_t, si_overrun) == 0x10); 699static_assert(offsetof(siginfo_t, si_status) == 0x14); 700static_assert(offsetof(siginfo_t, si_utime) == 0x18); 701static_assert(offsetof(siginfo_t, si_stime) == 0x1c); 702static_assert(offsetof(siginfo_t, si_value) == 0x14); 703static_assert(offsetof(siginfo_t, si_int) == 0x14); 704static_assert(offsetof(siginfo_t, si_ptr) == 0x14); 705static_assert(offsetof(siginfo_t, si_addr) == 0x0c); 706static_assert(offsetof(siginfo_t, si_addr_lsb) == 0x10); 707static_assert(offsetof(siginfo_t, si_lower) == 0x14); 708static_assert(offsetof(siginfo_t, si_upper) == 0x18); 709static_assert(offsetof(siginfo_t, si_pkey) == 0x14); 710static_assert(offsetof(siginfo_t, si_perf_data) == 0x10); 711static_assert(offsetof(siginfo_t, si_perf_type) == 0x14); 712static_assert(offsetof(siginfo_t, si_perf_flags) == 0x18); 713static_assert(offsetof(siginfo_t, si_band) == 0x0c); 714static_assert(offsetof(siginfo_t, si_fd) == 0x10); 715static_assert(offsetof(siginfo_t, si_call_addr) == 0x0c); 716static_assert(offsetof(siginfo_t, si_syscall) == 0x10); 717static_assert(offsetof(siginfo_t, si_arch) == 0x14); 718