arch/sh/kernel/signal_64.c

   1 /*
   2  * arch/sh/kernel/signal_64.c
   3  *
   4  * Copyright (C) 2000, 2001  Paolo Alberelli
   5  * Copyright (C) 2003 - 2008  Paul Mundt
   6  * Copyright (C) 2004  Richard Curnow
   7  *
   8  * This file is subject to the terms and conditions of the GNU General Public
   9  * License.  See the file "COPYING" in the main directory of this archive
  10  * for more details.
  11  */
  12 #include <linux/rwsem.h>
  13 #include <linux/sched.h>
  14 #include <linux/mm.h>
  15 #include <linux/smp.h>
  16 #include <linux/kernel.h>
  17 #include <linux/signal.h>
  18 #include <linux/errno.h>
  19 #include <linux/wait.h>
  20 #include <linux/personality.h>
  21 #include <linux/ptrace.h>
  22 #include <linux/unistd.h>
  23 #include <linux/stddef.h>
  24 #include <linux/tracehook.h>
  25 #include <asm/ucontext.h>
  26 #include <asm/uaccess.h>
  27 #include <asm/pgtable.h>
  28 #include <asm/cacheflush.h>
  29 #include <asm/fpu.h>
  30
  31 #define REG_RET 9
  32 #define REG_ARG1 2
  33 #define REG_ARG2 3
  34 #define REG_ARG3 4
  35 #define REG_SP 15
  36 #define REG_PR 18
  37 #define REF_REG_RET regs->regs[REG_RET]
  38 #define REF_REG_SP regs->regs[REG_SP]
  39 #define DEREF_REG_PR regs->regs[REG_PR]
  40
  41 #define DEBUG_SIG 0
  42
  43 static void
  44 handle_signal(struct ksignal *ksig, struct pt_regs *regs);
  45
  46 static inline void
  47 handle_syscall_restart(struct pt_regs *regs, struct sigaction *sa)
  48 {
  49         /* If we're not from a syscall, bail out */
  50         if (regs->syscall_nr < 0)
  51                 return;
  52
  53         /* check for system call restart.. */
  54         switch (regs->regs[REG_RET]) {
  55                 case -ERESTART_RESTARTBLOCK:
  56                 case -ERESTARTNOHAND:
  57                 no_system_call_restart:
  58                         regs->regs[REG_RET] = -EINTR;
  59                         break;
  60
  61                 case -ERESTARTSYS:
  62                         if (!(sa->sa_flags & SA_RESTART))
  63                                 goto no_system_call_restart;
  64                 /* fallthrough */
  65                 case -ERESTARTNOINTR:
  66                         /* Decode syscall # */
  67                         regs->regs[REG_RET] = regs->syscall_nr;
  68                         regs->pc -= 4;
  69                         break;
  70         }
  71 }
  72
  73 /*
  74  * Note that 'init' is a special process: it doesn't get signals it doesn't
  75  * want to handle. Thus you cannot kill init even with a SIGKILL even by
  76  * mistake.
  77  *
  78  * Note that we go through the signals twice: once to check the signals that
  79  * the kernel can handle, and then we build all the user-level signal handling
  80  * stack-frames in one go after that.
  81  */
  82 static void do_signal(struct pt_regs *regs)
  83 {
  84         struct ksignal ksig;
  85
  86         /*
  87          * We want the common case to go fast, which
  88          * is why we may in certain cases get here from
  89          * kernel mode. Just return without doing anything
  90          * if so.
  91          */
  92         if (!user_mode(regs))
  93                 return;
  94
  95         if (get_signal(&ksig)) {
  96                 handle_syscall_restart(regs, &ksig.ka.sa);
  97
  98                 /* Whee!  Actually deliver the signal.  */
  99                 handle_signal(&ksig, regs);
 100                 return;
 101         }
 102
 103         /* Did we come from a system call? */
 104         if (regs->syscall_nr >= 0) {
 105                 /* Restart the system call - no handlers present */
 106                 switch (regs->regs[REG_RET]) {
 107                 case -ERESTARTNOHAND:
 108                 case -ERESTARTSYS:
 109                 case -ERESTARTNOINTR:
 110                         /* Decode Syscall # */
 111                         regs->regs[REG_RET] = regs->syscall_nr;
 112                         regs->pc -= 4;
 113                         break;
 114
 115                 case -ERESTART_RESTARTBLOCK:
 116                         regs->regs[REG_RET] = __NR_restart_syscall;
 117                         regs->pc -= 4;
 118                         break;
 119                 }
 120         }
 121
 122         /* No signal to deliver -- put the saved sigmask back */
 123         restore_saved_sigmask();
 124 }
 125
 126 /*
 127  * Do a signal return; undo the signal stack.
 128  */
 129 struct sigframe {
 130         struct sigcontext sc;
 131         unsigned long extramask[_NSIG_WORDS-1];
 132         long long retcode[2];
 133 };
 134
 135 struct rt_sigframe {
 136         struct siginfo __user *pinfo;
 137         void *puc;
 138         struct siginfo info;
 139         struct ucontext uc;
 140         long long retcode[2];
 141 };
 142
 143 #ifdef CONFIG_SH_FPU
 144 static inline int
 145 restore_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
 146 {
 147         int err = 0;
 148         int fpvalid;
 149
 150         err |= __get_user (fpvalid, &sc->sc_fpvalid);
 151         conditional_used_math(fpvalid);
 152         if (! fpvalid)
 153                 return err;
 154
 155         if (current == last_task_used_math) {
 156                 last_task_used_math = NULL;
 157                 regs->sr |= SR_FD;
 158         }
 159
 160         err |= __copy_from_user(&current->thread.xstate->hardfpu, &sc->sc_fpregs[0],
 161                                 (sizeof(long long) * 32) + (sizeof(int) * 1));
 162
 163         return err;
 164 }
 165
 166 static inline int
 167 setup_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
 168 {
 169         int err = 0;
 170         int fpvalid;
 171
 172         fpvalid = !!used_math();
 173         err |= __put_user(fpvalid, &sc->sc_fpvalid);
 174         if (! fpvalid)
 175                 return err;
 176
 177         if (current == last_task_used_math) {
 178                 enable_fpu();
 179                 save_fpu(current);
 180                 disable_fpu();
 181                 last_task_used_math = NULL;
 182                 regs->sr |= SR_FD;
 183         }
 184
 185         err |= __copy_to_user(&sc->sc_fpregs[0], &current->thread.xstate->hardfpu,
 186                               (sizeof(long long) * 32) + (sizeof(int) * 1));
 187         clear_used_math();
 188
 189         return err;
 190 }
 191 #else
 192 static inline int
 193 restore_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
 194 {
 195         return 0;
 196 }
 197 static inline int
 198 setup_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
 199 {
 200         return 0;
 201 }
 202 #endif
 203
 204 static int
 205 restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc, long long *r2_p)
 206 {
 207         unsigned int err = 0;
 208         unsigned long long current_sr, new_sr;
 209 #define SR_MASK 0xffff8cfd
 210
 211 #define COPY(x)         err |= __get_user(regs->x, &sc->sc_##x)
 212
 213         COPY(regs[0]);  COPY(regs[1]);  COPY(regs[2]);  COPY(regs[3]);
 214         COPY(regs[4]);  COPY(regs[5]);  COPY(regs[6]);  COPY(regs[7]);
 215         COPY(regs[8]);  COPY(regs[9]);  COPY(regs[10]); COPY(regs[11]);
 216         COPY(regs[12]); COPY(regs[13]); COPY(regs[14]); COPY(regs[15]);
 217         COPY(regs[16]); COPY(regs[17]); COPY(regs[18]); COPY(regs[19]);
 218         COPY(regs[20]); COPY(regs[21]); COPY(regs[22]); COPY(regs[23]);
 219         COPY(regs[24]); COPY(regs[25]); COPY(regs[26]); COPY(regs[27]);
 220         COPY(regs[28]); COPY(regs[29]); COPY(regs[30]); COPY(regs[31]);
 221         COPY(regs[32]); COPY(regs[33]); COPY(regs[34]); COPY(regs[35]);
 222         COPY(regs[36]); COPY(regs[37]); COPY(regs[38]); COPY(regs[39]);
 223         COPY(regs[40]); COPY(regs[41]); COPY(regs[42]); COPY(regs[43]);
 224         COPY(regs[44]); COPY(regs[45]); COPY(regs[46]); COPY(regs[47]);
 225         COPY(regs[48]); COPY(regs[49]); COPY(regs[50]); COPY(regs[51]);
 226         COPY(regs[52]); COPY(regs[53]); COPY(regs[54]); COPY(regs[55]);
 227         COPY(regs[56]); COPY(regs[57]); COPY(regs[58]); COPY(regs[59]);
 228         COPY(regs[60]); COPY(regs[61]); COPY(regs[62]);
 229         COPY(tregs[0]); COPY(tregs[1]); COPY(tregs[2]); COPY(tregs[3]);
 230         COPY(tregs[4]); COPY(tregs[5]); COPY(tregs[6]); COPY(tregs[7]);
 231
 232         /* Prevent the signal handler manipulating SR in a way that can
 233            crash the kernel. i.e. only allow S, Q, M, PR, SZ, FR to be
 234            modified */
 235         current_sr = regs->sr;
 236         err |= __get_user(new_sr, &sc->sc_sr);
 237         regs->sr &= SR_MASK;
 238         regs->sr |= (new_sr & ~SR_MASK);
 239
 240         COPY(pc);
 241
 242 #undef COPY
 243
 244         /* Must do this last in case it sets regs->sr.fd (i.e. after rest of sr
 245          * has been restored above.) */
 246         err |= restore_sigcontext_fpu(regs, sc);
 247
 248         regs->syscall_nr = -1;          /* disable syscall checks */
 249         err |= __get_user(*r2_p, &sc->sc_regs[REG_RET]);
 250         return err;
 251 }
 252
 253 asmlinkage int sys_sigreturn(unsigned long r2, unsigned long r3,
 254                                    unsigned long r4, unsigned long r5,
 255                                    unsigned long r6, unsigned long r7,
 256                                    struct pt_regs * regs)
 257 {
 258         struct sigframe __user *frame = (struct sigframe __user *) (long) REF_REG_SP;
 259         sigset_t set;
 260         long long ret;
 261
 262         /* Always make any pending restarted system calls return -EINTR */
 263         current->restart_block.fn = do_no_restart_syscall;
 264
 265         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 266                 goto badframe;
 267
 268         if (__get_user(set.sig[0], &frame->sc.oldmask)
 269             || (_NSIG_WORDS > 1
 270                 && __copy_from_user(&set.sig[1], &frame->extramask,
 271                                     sizeof(frame->extramask))))
 272                 goto badframe;
 273
 274         set_current_blocked(&set);
 275
 276         if (restore_sigcontext(regs, &frame->sc, &ret))
 277                 goto badframe;
 278         regs->pc -= 4;
 279
 280         return (int) ret;
 281
 282 badframe:
 283         force_sig(SIGSEGV, current);
 284         return 0;
 285 }
 286
 287 asmlinkage int sys_rt_sigreturn(unsigned long r2, unsigned long r3,
 288                                 unsigned long r4, unsigned long r5,
 289                                 unsigned long r6, unsigned long r7,
 290                                 struct pt_regs * regs)
 291 {
 292         struct rt_sigframe __user *frame = (struct rt_sigframe __user *) (long) REF_REG_SP;
 293         sigset_t set;
 294         long long ret;
 295
 296         /* Always make any pending restarted system calls return -EINTR */
 297         current->restart_block.fn = do_no_restart_syscall;
 298
 299         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 300                 goto badframe;
 301
 302         if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
 303                 goto badframe;
 304
 305         set_current_blocked(&set);
 306
 307         if (restore_sigcontext(regs, &frame->uc.uc_mcontext, &ret))
 308                 goto badframe;
 309         regs->pc -= 4;
 310
 311         if (restore_altstack(&frame->uc.uc_stack))
 312                 goto badframe;
 313
 314         return (int) ret;
 315
 316 badframe:
 317         force_sig(SIGSEGV, current);
 318         return 0;
 319 }
 320
 321 /*
 322  * Set up a signal frame.
 323  */
 324 static int
 325 setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs,
 326                  unsigned long mask)
 327 {
 328         int err = 0;
 329
 330         /* Do this first, otherwise is this sets sr->fd, that value isn't preserved. */
 331         err |= setup_sigcontext_fpu(regs, sc);
 332
 333 #define COPY(x)         err |= __put_user(regs->x, &sc->sc_##x)
 334
 335         COPY(regs[0]);  COPY(regs[1]);  COPY(regs[2]);  COPY(regs[3]);
 336         COPY(regs[4]);  COPY(regs[5]);  COPY(regs[6]);  COPY(regs[7]);
 337         COPY(regs[8]);  COPY(regs[9]);  COPY(regs[10]); COPY(regs[11]);
 338         COPY(regs[12]); COPY(regs[13]); COPY(regs[14]); COPY(regs[15]);
 339         COPY(regs[16]); COPY(regs[17]); COPY(regs[18]); COPY(regs[19]);
 340         COPY(regs[20]); COPY(regs[21]); COPY(regs[22]); COPY(regs[23]);
 341         COPY(regs[24]); COPY(regs[25]); COPY(regs[26]); COPY(regs[27]);
 342         COPY(regs[28]); COPY(regs[29]); COPY(regs[30]); COPY(regs[31]);
 343         COPY(regs[32]); COPY(regs[33]); COPY(regs[34]); COPY(regs[35]);
 344         COPY(regs[36]); COPY(regs[37]); COPY(regs[38]); COPY(regs[39]);
 345         COPY(regs[40]); COPY(regs[41]); COPY(regs[42]); COPY(regs[43]);
 346         COPY(regs[44]); COPY(regs[45]); COPY(regs[46]); COPY(regs[47]);
 347         COPY(regs[48]); COPY(regs[49]); COPY(regs[50]); COPY(regs[51]);
 348         COPY(regs[52]); COPY(regs[53]); COPY(regs[54]); COPY(regs[55]);
 349         COPY(regs[56]); COPY(regs[57]); COPY(regs[58]); COPY(regs[59]);
 350         COPY(regs[60]); COPY(regs[61]); COPY(regs[62]);
 351         COPY(tregs[0]); COPY(tregs[1]); COPY(tregs[2]); COPY(tregs[3]);
 352         COPY(tregs[4]); COPY(tregs[5]); COPY(tregs[6]); COPY(tregs[7]);
 353         COPY(sr);       COPY(pc);
 354
 355 #undef COPY
 356
 357         err |= __put_user(mask, &sc->oldmask);
 358
 359         return err;
 360 }
 361
 362 /*
 363  * Determine which stack to use..
 364  */
 365 static inline void __user *
 366 get_sigframe(struct k_sigaction *ka, unsigned long sp, size_t frame_size)
 367 {
 368         if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && ! sas_ss_flags(sp))
 369                 sp = current->sas_ss_sp + current->sas_ss_size;
 370
 371         return (void __user *)((sp - frame_size) & -8ul);
 372 }
 373
 374 void sa_default_restorer(void);         /* See comments below */
 375 void sa_default_rt_restorer(void);      /* See comments below */
 376
 377 static int setup_frame(struct ksignal *ksig, sigset_t *set, struct pt_regs *regs)
 378 {
 379         struct sigframe __user *frame;
 380         int err = 0, sig = ksig->sig;
 381         int signal;
 382
 383         frame = get_sigframe(&ksig->ka, regs->regs[REG_SP], sizeof(*frame));
 384
 385         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 386                 return -EFAULT;
 387
 388         signal = current_thread_info()->exec_domain
 389                 && current_thread_info()->exec_domain->signal_invmap
 390                 && sig < 32
 391                 ? current_thread_info()->exec_domain->signal_invmap[sig]
 392                 : sig;
 393
 394         err |= setup_sigcontext(&frame->sc, regs, set->sig[0]);
 395
 396         /* Give up earlier as i386, in case */
 397         if (err)
 398                 return -EFAULT;
 399
 400         if (_NSIG_WORDS > 1) {
 401                 err |= __copy_to_user(frame->extramask, &set->sig[1],
 402                                       sizeof(frame->extramask)); }
 403
 404         /* Give up earlier as i386, in case */
 405         if (err)
 406                 return -EFAULT;
 407
 408         /* Set up to return from userspace.  If provided, use a stub
 409            already in userspace.  */
 410         if (ksig->ka.sa.sa_flags & SA_RESTORER) {
 411                 /*
 412                  * On SH5 all edited pointers are subject to NEFF
 413                  */
 414                 DEREF_REG_PR = neff_sign_extend((unsigned long)
 415                         ksig->ka->sa.sa_restorer | 0x1);
 416         } else {
 417                 /*
 418                  * Different approach on SH5.
 419                  * . Endianness independent asm code gets placed in entry.S .
 420                  *   This is limited to four ASM instructions corresponding
 421                  *   to two long longs in size.
 422                  * . err checking is done on the else branch only
 423                  * . flush_icache_range() is called upon __put_user() only
 424                  * . all edited pointers are subject to NEFF
 425                  * . being code, linker turns ShMedia bit on, always
 426                  *   dereference index -1.
 427                  */
 428                 DEREF_REG_PR = neff_sign_extend((unsigned long)
 429                         frame->retcode | 0x01);
 430
 431                 if (__copy_to_user(frame->retcode,
 432                         (void *)((unsigned long)sa_default_restorer & (~1)), 16) != 0)
 433                         return -EFAULT;
 434
 435                 /* Cohere the trampoline with the I-cache. */
 436                 flush_cache_sigtramp(DEREF_REG_PR-1);
 437         }
 438
 439         /*
 440          * Set up registers for signal handler.
 441          * All edited pointers are subject to NEFF.
 442          */
 443         regs->regs[REG_SP] = neff_sign_extend((unsigned long)frame);
 444         regs->regs[REG_ARG1] = signal; /* Arg for signal handler */
 445
 446         /* FIXME:
 447            The glibc profiling support for SH-5 needs to be passed a sigcontext
 448            so it can retrieve the PC.  At some point during 2003 the glibc
 449            support was changed to receive the sigcontext through the 2nd
 450            argument, but there are still versions of libc.so in use that use
 451            the 3rd argument.  Until libc.so is stabilised, pass the sigcontext
 452            through both 2nd and 3rd arguments.
 453         */
 454
 455         regs->regs[REG_ARG2] = (unsigned long long)(unsigned long)(signed long)&frame->sc;
 456         regs->regs[REG_ARG3] = (unsigned long long)(unsigned long)(signed long)&frame->sc;
 457
 458         regs->pc = neff_sign_extend((unsigned long)ksig->ka.sa.sa_handler);
 459
 460         set_fs(USER_DS);
 461
 462         /* Broken %016Lx */
 463         pr_debug("SIG deliver (#%d,%s:%d): sp=%p pc=%08Lx%08Lx link=%08Lx%08Lx\n",
 464                  signal, current->comm, current->pid, frame,
 465                  regs->pc >> 32, regs->pc & 0xffffffff,
 466                  DEREF_REG_PR >> 32, DEREF_REG_PR & 0xffffffff);
 467
 468         return 0;
 469 }
 470
 471 static int setup_rt_frame(struct ksignal *kig, sigset_t *set,
 472                           struct pt_regs *regs)
 473 {
 474         struct rt_sigframe __user *frame;
 475         int err = 0, sig = ksig->sig;
 476         int signal;
 477
 478         frame = get_sigframe(&ksig->ka, regs->regs[REG_SP], sizeof(*frame));
 479
 480         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 481                 return -EFAULT;
 482
 483         signal = current_thread_info()->exec_domain
 484                 && current_thread_info()->exec_domain->signal_invmap
 485                 && sig < 32
 486                 ? current_thread_info()->exec_domain->signal_invmap[sig]
 487                 : sig;
 488
 489         err |= __put_user(&frame->info, &frame->pinfo);
 490         err |= __put_user(&frame->uc, &frame->puc);
 491         err |= copy_siginfo_to_user(&frame->info, &ksig->info);
 492
 493         /* Give up earlier as i386, in case */
 494         if (err)
 495                 return -EFAULT;
 496
 497         /* Create the ucontext.  */
 498         err |= __put_user(0, &frame->uc.uc_flags);
 499         err |= __put_user(0, &frame->uc.uc_link);
 500         err |= __save_altstack(&frame->uc.uc_stack, regs->regs[REG_SP]);
 501         err |= setup_sigcontext(&frame->uc.uc_mcontext,
 502                                 regs, set->sig[0]);
 503         err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
 504
 505         /* Give up earlier as i386, in case */
 506         if (err)
 507                 return -EFAULT;
 508
 509         /* Set up to return from userspace.  If provided, use a stub
 510            already in userspace.  */
 511         if (ksig->ka.sa.sa_flags & SA_RESTORER) {
 512                 /*
 513                  * On SH5 all edited pointers are subject to NEFF
 514                  */
 515                 DEREF_REG_PR = neff_sign_extend((unsigned long)
 516                         ksig->ka.sa.sa_restorer | 0x1);
 517         } else {
 518                 /*
 519                  * Different approach on SH5.
 520                  * . Endianness independent asm code gets placed in entry.S .
 521                  *   This is limited to four ASM instructions corresponding
 522                  *   to two long longs in size.
 523                  * . err checking is done on the else branch only
 524                  * . flush_icache_range() is called upon __put_user() only
 525                  * . all edited pointers are subject to NEFF
 526                  * . being code, linker turns ShMedia bit on, always
 527                  *   dereference index -1.
 528                  */
 529                 DEREF_REG_PR = neff_sign_extend((unsigned long)
 530                         frame->retcode | 0x01);
 531
 532                 if (__copy_to_user(frame->retcode,
 533                         (void *)((unsigned long)sa_default_rt_restorer & (~1)), 16) != 0)
 534                         return -EFAULT;
 535
 536                 /* Cohere the trampoline with the I-cache. */
 537                 flush_icache_range(DEREF_REG_PR-1, DEREF_REG_PR-1+15);
 538         }
 539
 540         /*
 541          * Set up registers for signal handler.
 542          * All edited pointers are subject to NEFF.
 543          */
 544         regs->regs[REG_SP] = neff_sign_extend((unsigned long)frame);
 545         regs->regs[REG_ARG1] = signal; /* Arg for signal handler */
 546         regs->regs[REG_ARG2] = (unsigned long long)(unsigned long)(signed long)&frame->info;
 547         regs->regs[REG_ARG3] = (unsigned long long)(unsigned long)(signed long)&frame->uc.uc_mcontext;
 548         regs->pc = neff_sign_extend((unsigned long)ksig->ka.sa.sa_handler);
 549
 550         set_fs(USER_DS);
 551
 552         pr_debug("SIG deliver (#%d,%s:%d): sp=%p pc=%08Lx%08Lx link=%08Lx%08Lx\n",
 553                  signal, current->comm, current->pid, frame,
 554                  regs->pc >> 32, regs->pc & 0xffffffff,
 555                  DEREF_REG_PR >> 32, DEREF_REG_PR & 0xffffffff);
 556
 557         return 0;
 558 }
 559
 560 /*
 561  * OK, we're invoking a handler
 562  */
 563 static void
 564 handle_signal(struct ksignal *ksig, struct pt_regs *regs)
 565 {
 566         sigset_t *oldset = sigmask_to_save();
 567         int ret;
 568
 569         /* Set up the stack frame */
 570         if (ksig->ka.sa.sa_flags & SA_SIGINFO)
 571                 ret = setup_rt_frame(ksig, oldset, regs);
 572         else
 573                 ret = setup_frame(ksig, oldset, regs);
 574
 575         signal_setup_done(ret, ksig, test_thread_flag(TIF_SINGLESTEP));
 576 }
 577
 578 asmlinkage void do_notify_resume(struct pt_regs *regs, unsigned long thread_info_flags)
 579 {
 580         if (thread_info_flags & _TIF_SIGPENDING)
 581                 do_signal(regs);
 582
 583         if (thread_info_flags & _TIF_NOTIFY_RESUME) {
 584                 clear_thread_flag(TIF_NOTIFY_RESUME);
 585                 tracehook_notify_resume(regs);
 586         }
 587 }