LXR linux/arch/sh/kernel/signal

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