Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  *  arch/sparc64/kernel/signal.c
0004  *
0005  *  Copyright (C) 1991, 1992  Linus Torvalds
0006  *  Copyright (C) 1995, 2008 David S. Miller (davem@davemloft.net)
0007  *  Copyright (C) 1996 Miguel de Icaza (miguel@nuclecu.unam.mx)
0008  *  Copyright (C) 1997 Eddie C. Dost   (ecd@skynet.be)
0009  *  Copyright (C) 1997,1998 Jakub Jelinek   (jj@sunsite.mff.cuni.cz)
0010  */
0011 
0012 #include <linux/sched.h>
0013 #include <linux/kernel.h>
0014 #include <linux/signal.h>
0015 #include <linux/errno.h>
0016 #include <linux/wait.h>
0017 #include <linux/ptrace.h>
0018 #include <linux/resume_user_mode.h>
0019 #include <linux/unistd.h>
0020 #include <linux/mm.h>
0021 #include <linux/tty.h>
0022 #include <linux/binfmts.h>
0023 #include <linux/bitops.h>
0024 #include <linux/context_tracking.h>
0025 
0026 #include <linux/uaccess.h>
0027 #include <asm/ptrace.h>
0028 #include <asm/fpumacro.h>
0029 #include <asm/uctx.h>
0030 #include <asm/siginfo.h>
0031 #include <asm/visasm.h>
0032 #include <asm/switch_to.h>
0033 #include <asm/cacheflush.h>
0034 
0035 #include "sigutil.h"
0036 #include "systbls.h"
0037 #include "kernel.h"
0038 #include "entry.h"
0039 
0040 /* {set, get}context() needed for 64-bit SparcLinux userland. */
0041 asmlinkage void sparc64_set_context(struct pt_regs *regs)
0042 {
0043     struct ucontext __user *ucp = (struct ucontext __user *)
0044         regs->u_regs[UREG_I0];
0045     enum ctx_state prev_state = exception_enter();
0046     mc_gregset_t __user *grp;
0047     unsigned long pc, npc, tstate;
0048     unsigned long fp, i7;
0049     unsigned char fenab;
0050     int err;
0051 
0052     synchronize_user_stack();
0053     if (get_thread_wsaved()                 ||
0054         (((unsigned long)ucp) & (sizeof(unsigned long)-1))  ||
0055         (!__access_ok(ucp, sizeof(*ucp))))
0056         goto do_sigsegv;
0057     grp  = &ucp->uc_mcontext.mc_gregs;
0058     err  = __get_user(pc, &((*grp)[MC_PC]));
0059     err |= __get_user(npc, &((*grp)[MC_NPC]));
0060     if (err || ((pc | npc) & 3))
0061         goto do_sigsegv;
0062     if (regs->u_regs[UREG_I1]) {
0063         sigset_t set;
0064 
0065         if (_NSIG_WORDS == 1) {
0066             if (__get_user(set.sig[0], &ucp->uc_sigmask.sig[0]))
0067                 goto do_sigsegv;
0068         } else {
0069             if (__copy_from_user(&set, &ucp->uc_sigmask, sizeof(sigset_t)))
0070                 goto do_sigsegv;
0071         }
0072         set_current_blocked(&set);
0073     }
0074     if (test_thread_flag(TIF_32BIT)) {
0075         pc &= 0xffffffff;
0076         npc &= 0xffffffff;
0077     }
0078     regs->tpc = pc;
0079     regs->tnpc = npc;
0080     err |= __get_user(regs->y, &((*grp)[MC_Y]));
0081     err |= __get_user(tstate, &((*grp)[MC_TSTATE]));
0082     regs->tstate &= ~(TSTATE_ASI | TSTATE_ICC | TSTATE_XCC);
0083     regs->tstate |= (tstate & (TSTATE_ASI | TSTATE_ICC | TSTATE_XCC));
0084     err |= __get_user(regs->u_regs[UREG_G1], (&(*grp)[MC_G1]));
0085     err |= __get_user(regs->u_regs[UREG_G2], (&(*grp)[MC_G2]));
0086     err |= __get_user(regs->u_regs[UREG_G3], (&(*grp)[MC_G3]));
0087     err |= __get_user(regs->u_regs[UREG_G4], (&(*grp)[MC_G4]));
0088     err |= __get_user(regs->u_regs[UREG_G5], (&(*grp)[MC_G5]));
0089     err |= __get_user(regs->u_regs[UREG_G6], (&(*grp)[MC_G6]));
0090 
0091     /* Skip %g7 as that's the thread register in userspace.  */
0092 
0093     err |= __get_user(regs->u_regs[UREG_I0], (&(*grp)[MC_O0]));
0094     err |= __get_user(regs->u_regs[UREG_I1], (&(*grp)[MC_O1]));
0095     err |= __get_user(regs->u_regs[UREG_I2], (&(*grp)[MC_O2]));
0096     err |= __get_user(regs->u_regs[UREG_I3], (&(*grp)[MC_O3]));
0097     err |= __get_user(regs->u_regs[UREG_I4], (&(*grp)[MC_O4]));
0098     err |= __get_user(regs->u_regs[UREG_I5], (&(*grp)[MC_O5]));
0099     err |= __get_user(regs->u_regs[UREG_I6], (&(*grp)[MC_O6]));
0100     err |= __get_user(regs->u_regs[UREG_I7], (&(*grp)[MC_O7]));
0101 
0102     err |= __get_user(fp, &(ucp->uc_mcontext.mc_fp));
0103     err |= __get_user(i7, &(ucp->uc_mcontext.mc_i7));
0104     err |= __put_user(fp,
0105           (&(((struct reg_window __user *)(STACK_BIAS+regs->u_regs[UREG_I6]))->ins[6])));
0106     err |= __put_user(i7,
0107           (&(((struct reg_window __user *)(STACK_BIAS+regs->u_regs[UREG_I6]))->ins[7])));
0108 
0109     err |= __get_user(fenab, &(ucp->uc_mcontext.mc_fpregs.mcfpu_enab));
0110     if (fenab) {
0111         unsigned long *fpregs = current_thread_info()->fpregs;
0112         unsigned long fprs;
0113         
0114         fprs_write(0);
0115         err |= __get_user(fprs, &(ucp->uc_mcontext.mc_fpregs.mcfpu_fprs));
0116         if (fprs & FPRS_DL)
0117             err |= copy_from_user(fpregs,
0118                           &(ucp->uc_mcontext.mc_fpregs.mcfpu_fregs),
0119                           (sizeof(unsigned int) * 32));
0120         if (fprs & FPRS_DU)
0121             err |= copy_from_user(fpregs+16,
0122              ((unsigned long __user *)&(ucp->uc_mcontext.mc_fpregs.mcfpu_fregs))+16,
0123              (sizeof(unsigned int) * 32));
0124         err |= __get_user(current_thread_info()->xfsr[0],
0125                   &(ucp->uc_mcontext.mc_fpregs.mcfpu_fsr));
0126         err |= __get_user(current_thread_info()->gsr[0],
0127                   &(ucp->uc_mcontext.mc_fpregs.mcfpu_gsr));
0128         regs->tstate &= ~TSTATE_PEF;
0129     }
0130     if (err)
0131         goto do_sigsegv;
0132 out:
0133     exception_exit(prev_state);
0134     return;
0135 do_sigsegv:
0136     force_sig(SIGSEGV);
0137     goto out;
0138 }
0139 
0140 asmlinkage void sparc64_get_context(struct pt_regs *regs)
0141 {
0142     struct ucontext __user *ucp = (struct ucontext __user *)
0143         regs->u_regs[UREG_I0];
0144     enum ctx_state prev_state = exception_enter();
0145     mc_gregset_t __user *grp;
0146     mcontext_t __user *mcp;
0147     unsigned long fp, i7;
0148     unsigned char fenab;
0149     int err;
0150 
0151     synchronize_user_stack();
0152     if (get_thread_wsaved() || clear_user(ucp, sizeof(*ucp)))
0153         goto do_sigsegv;
0154 
0155 #if 1
0156     fenab = 0; /* IMO get_context is like any other system call, thus modifies FPU state -jj */
0157 #else
0158     fenab = (current_thread_info()->fpsaved[0] & FPRS_FEF);
0159 #endif
0160         
0161     mcp = &ucp->uc_mcontext;
0162     grp = &mcp->mc_gregs;
0163 
0164     /* Skip over the trap instruction, first. */
0165     if (test_thread_flag(TIF_32BIT)) {
0166         regs->tpc   = (regs->tnpc & 0xffffffff);
0167         regs->tnpc  = (regs->tnpc + 4) & 0xffffffff;
0168     } else {
0169         regs->tpc   = regs->tnpc;
0170         regs->tnpc += 4;
0171     }
0172     err = 0;
0173     if (_NSIG_WORDS == 1)
0174         err |= __put_user(current->blocked.sig[0],
0175                   (unsigned long __user *)&ucp->uc_sigmask);
0176     else
0177         err |= __copy_to_user(&ucp->uc_sigmask, &current->blocked,
0178                       sizeof(sigset_t));
0179 
0180     err |= __put_user(regs->tstate, &((*grp)[MC_TSTATE]));
0181     err |= __put_user(regs->tpc, &((*grp)[MC_PC]));
0182     err |= __put_user(regs->tnpc, &((*grp)[MC_NPC]));
0183     err |= __put_user(regs->y, &((*grp)[MC_Y]));
0184     err |= __put_user(regs->u_regs[UREG_G1], &((*grp)[MC_G1]));
0185     err |= __put_user(regs->u_regs[UREG_G2], &((*grp)[MC_G2]));
0186     err |= __put_user(regs->u_regs[UREG_G3], &((*grp)[MC_G3]));
0187     err |= __put_user(regs->u_regs[UREG_G4], &((*grp)[MC_G4]));
0188     err |= __put_user(regs->u_regs[UREG_G5], &((*grp)[MC_G5]));
0189     err |= __put_user(regs->u_regs[UREG_G6], &((*grp)[MC_G6]));
0190     err |= __put_user(regs->u_regs[UREG_G7], &((*grp)[MC_G7]));
0191     err |= __put_user(regs->u_regs[UREG_I0], &((*grp)[MC_O0]));
0192     err |= __put_user(regs->u_regs[UREG_I1], &((*grp)[MC_O1]));
0193     err |= __put_user(regs->u_regs[UREG_I2], &((*grp)[MC_O2]));
0194     err |= __put_user(regs->u_regs[UREG_I3], &((*grp)[MC_O3]));
0195     err |= __put_user(regs->u_regs[UREG_I4], &((*grp)[MC_O4]));
0196     err |= __put_user(regs->u_regs[UREG_I5], &((*grp)[MC_O5]));
0197     err |= __put_user(regs->u_regs[UREG_I6], &((*grp)[MC_O6]));
0198     err |= __put_user(regs->u_regs[UREG_I7], &((*grp)[MC_O7]));
0199 
0200     err |= __get_user(fp,
0201          (&(((struct reg_window __user *)(STACK_BIAS+regs->u_regs[UREG_I6]))->ins[6])));
0202     err |= __get_user(i7,
0203          (&(((struct reg_window __user *)(STACK_BIAS+regs->u_regs[UREG_I6]))->ins[7])));
0204     err |= __put_user(fp, &(mcp->mc_fp));
0205     err |= __put_user(i7, &(mcp->mc_i7));
0206 
0207     err |= __put_user(fenab, &(mcp->mc_fpregs.mcfpu_enab));
0208     if (fenab) {
0209         unsigned long *fpregs = current_thread_info()->fpregs;
0210         unsigned long fprs;
0211         
0212         fprs = current_thread_info()->fpsaved[0];
0213         if (fprs & FPRS_DL)
0214             err |= copy_to_user(&(mcp->mc_fpregs.mcfpu_fregs), fpregs,
0215                         (sizeof(unsigned int) * 32));
0216         if (fprs & FPRS_DU)
0217             err |= copy_to_user(
0218                           ((unsigned long __user *)&(mcp->mc_fpregs.mcfpu_fregs))+16, fpregs+16,
0219               (sizeof(unsigned int) * 32));
0220         err |= __put_user(current_thread_info()->xfsr[0], &(mcp->mc_fpregs.mcfpu_fsr));
0221         err |= __put_user(current_thread_info()->gsr[0], &(mcp->mc_fpregs.mcfpu_gsr));
0222         err |= __put_user(fprs, &(mcp->mc_fpregs.mcfpu_fprs));
0223     }
0224     if (err)
0225         goto do_sigsegv;
0226 out:
0227     exception_exit(prev_state);
0228     return;
0229 do_sigsegv:
0230     force_sig(SIGSEGV);
0231     goto out;
0232 }
0233 
0234 /* Checks if the fp is valid.  We always build rt signal frames which
0235  * are 16-byte aligned, therefore we can always enforce that the
0236  * restore frame has that property as well.
0237  */
0238 static bool invalid_frame_pointer(void __user *fp)
0239 {
0240     if (((unsigned long) fp) & 15)
0241         return true;
0242     return false;
0243 }
0244 
0245 struct rt_signal_frame {
0246     struct sparc_stackf ss;
0247     siginfo_t       info;
0248     struct pt_regs      regs;
0249     __siginfo_fpu_t __user  *fpu_save;
0250     stack_t         stack;
0251     sigset_t        mask;
0252     __siginfo_rwin_t    *rwin_save;
0253 };
0254 
0255 void do_rt_sigreturn(struct pt_regs *regs)
0256 {
0257     unsigned long tpc, tnpc, tstate, ufp;
0258     struct rt_signal_frame __user *sf;
0259     __siginfo_fpu_t __user *fpu_save;
0260     __siginfo_rwin_t __user *rwin_save;
0261     sigset_t set;
0262     int err;
0263 
0264     /* Always make any pending restarted system calls return -EINTR */
0265     current->restart_block.fn = do_no_restart_syscall;
0266 
0267     synchronize_user_stack ();
0268     sf = (struct rt_signal_frame __user *)
0269         (regs->u_regs [UREG_FP] + STACK_BIAS);
0270 
0271     /* 1. Make sure we are not getting garbage from the user */
0272     if (invalid_frame_pointer(sf))
0273         goto segv;
0274 
0275     if (get_user(ufp, &sf->regs.u_regs[UREG_FP]))
0276         goto segv;
0277 
0278     if ((ufp + STACK_BIAS) & 0x7)
0279         goto segv;
0280 
0281     err = __get_user(tpc, &sf->regs.tpc);
0282     err |= __get_user(tnpc, &sf->regs.tnpc);
0283     if (test_thread_flag(TIF_32BIT)) {
0284         tpc &= 0xffffffff;
0285         tnpc &= 0xffffffff;
0286     }
0287     err |= ((tpc | tnpc) & 3);
0288 
0289     /* 2. Restore the state */
0290     err |= __get_user(regs->y, &sf->regs.y);
0291     err |= __get_user(tstate, &sf->regs.tstate);
0292     err |= copy_from_user(regs->u_regs, sf->regs.u_regs, sizeof(regs->u_regs));
0293 
0294     /* User can only change condition codes and %asi in %tstate. */
0295     regs->tstate &= ~(TSTATE_ASI | TSTATE_ICC | TSTATE_XCC);
0296     regs->tstate |= (tstate & (TSTATE_ASI | TSTATE_ICC | TSTATE_XCC));
0297 
0298     err |= __get_user(fpu_save, &sf->fpu_save);
0299     if (!err && fpu_save)
0300         err |= restore_fpu_state(regs, fpu_save);
0301 
0302     err |= __copy_from_user(&set, &sf->mask, sizeof(sigset_t));
0303     err |= restore_altstack(&sf->stack);
0304     if (err)
0305         goto segv;
0306 
0307     err |= __get_user(rwin_save, &sf->rwin_save);
0308     if (!err && rwin_save) {
0309         if (restore_rwin_state(rwin_save))
0310             goto segv;
0311     }
0312 
0313     regs->tpc = tpc;
0314     regs->tnpc = tnpc;
0315 
0316     /* Prevent syscall restart.  */
0317     pt_regs_clear_syscall(regs);
0318 
0319     set_current_blocked(&set);
0320     return;
0321 segv:
0322     force_sig(SIGSEGV);
0323 }
0324 
0325 static inline void __user *get_sigframe(struct ksignal *ksig, struct pt_regs *regs, unsigned long framesize)
0326 {
0327     unsigned long sp = regs->u_regs[UREG_FP] + STACK_BIAS;
0328 
0329     /*
0330      * If we are on the alternate signal stack and would overflow it, don't.
0331      * Return an always-bogus address instead so we will die with SIGSEGV.
0332      */
0333     if (on_sig_stack(sp) && !likely(on_sig_stack(sp - framesize)))
0334         return (void __user *) -1L;
0335 
0336     /* This is the X/Open sanctioned signal stack switching.  */
0337     sp = sigsp(sp, ksig) - framesize;
0338 
0339     /* Always align the stack frame.  This handles two cases.  First,
0340      * sigaltstack need not be mindful of platform specific stack
0341      * alignment.  Second, if we took this signal because the stack
0342      * is not aligned properly, we'd like to take the signal cleanly
0343      * and report that.
0344      */
0345     sp &= ~15UL;
0346 
0347     return (void __user *) sp;
0348 }
0349 
0350 static inline int
0351 setup_rt_frame(struct ksignal *ksig, struct pt_regs *regs)
0352 {
0353     struct rt_signal_frame __user *sf;
0354     int wsaved, err, sf_size;
0355     void __user *tail;
0356 
0357     /* 1. Make sure everything is clean */
0358     synchronize_user_stack();
0359     save_and_clear_fpu();
0360     
0361     wsaved = get_thread_wsaved();
0362 
0363     sf_size = sizeof(struct rt_signal_frame);
0364     if (current_thread_info()->fpsaved[0] & FPRS_FEF)
0365         sf_size += sizeof(__siginfo_fpu_t);
0366     if (wsaved)
0367         sf_size += sizeof(__siginfo_rwin_t);
0368     sf = (struct rt_signal_frame __user *)
0369         get_sigframe(ksig, regs, sf_size);
0370 
0371     if (invalid_frame_pointer (sf)) {
0372         if (show_unhandled_signals)
0373             pr_info("%s[%d] bad frame in setup_rt_frame: %016lx TPC %016lx O7 %016lx\n",
0374                 current->comm, current->pid, (unsigned long)sf,
0375                 regs->tpc, regs->u_regs[UREG_I7]);
0376         force_sigsegv(ksig->sig);
0377         return -EINVAL;
0378     }
0379 
0380     tail = (sf + 1);
0381 
0382     /* 2. Save the current process state */
0383     err = copy_to_user(&sf->regs, regs, sizeof (*regs));
0384 
0385     if (current_thread_info()->fpsaved[0] & FPRS_FEF) {
0386         __siginfo_fpu_t __user *fpu_save = tail;
0387         tail += sizeof(__siginfo_fpu_t);
0388         err |= save_fpu_state(regs, fpu_save);
0389         err |= __put_user((u64)fpu_save, &sf->fpu_save);
0390     } else {
0391         err |= __put_user(0, &sf->fpu_save);
0392     }
0393     if (wsaved) {
0394         __siginfo_rwin_t __user *rwin_save = tail;
0395         tail += sizeof(__siginfo_rwin_t);
0396         err |= save_rwin_state(wsaved, rwin_save);
0397         err |= __put_user((u64)rwin_save, &sf->rwin_save);
0398         set_thread_wsaved(0);
0399     } else {
0400         err |= __put_user(0, &sf->rwin_save);
0401     }
0402     
0403     /* Setup sigaltstack */
0404     err |= __save_altstack(&sf->stack, regs->u_regs[UREG_FP]);
0405 
0406     err |= copy_to_user(&sf->mask, sigmask_to_save(), sizeof(sigset_t));
0407 
0408     if (!wsaved) {
0409         err |= raw_copy_in_user((u64 __user *)sf,
0410                     (u64 __user *)(regs->u_regs[UREG_FP] +
0411                        STACK_BIAS),
0412                     sizeof(struct reg_window));
0413     } else {
0414         struct reg_window *rp;
0415 
0416         rp = &current_thread_info()->reg_window[wsaved - 1];
0417         err |= copy_to_user(sf, rp, sizeof(struct reg_window));
0418     }
0419     if (ksig->ka.sa.sa_flags & SA_SIGINFO)
0420         err |= copy_siginfo_to_user(&sf->info, &ksig->info);
0421     else {
0422         err |= __put_user(ksig->sig, &sf->info.si_signo);
0423         err |= __put_user(SI_NOINFO, &sf->info.si_code);
0424     }
0425     if (err)
0426         return err;
0427     
0428     /* 3. signal handler back-trampoline and parameters */
0429     regs->u_regs[UREG_FP] = ((unsigned long) sf) - STACK_BIAS;
0430     regs->u_regs[UREG_I0] = ksig->sig;
0431     regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
0432 
0433     /* The sigcontext is passed in this way because of how it
0434      * is defined in GLIBC's /usr/include/bits/sigcontext.h
0435      * for sparc64.  It includes the 128 bytes of siginfo_t.
0436      */
0437     regs->u_regs[UREG_I2] = (unsigned long) &sf->info;
0438 
0439     /* 5. signal handler */
0440     regs->tpc = (unsigned long) ksig->ka.sa.sa_handler;
0441     regs->tnpc = (regs->tpc + 4);
0442     if (test_thread_flag(TIF_32BIT)) {
0443         regs->tpc &= 0xffffffff;
0444         regs->tnpc &= 0xffffffff;
0445     }
0446     /* 4. return to kernel instructions */
0447     regs->u_regs[UREG_I7] = (unsigned long)ksig->ka.ka_restorer;
0448     return 0;
0449 }
0450 
0451 static inline void syscall_restart(unsigned long orig_i0, struct pt_regs *regs,
0452                    struct sigaction *sa)
0453 {
0454     switch (regs->u_regs[UREG_I0]) {
0455     case ERESTART_RESTARTBLOCK:
0456     case ERESTARTNOHAND:
0457     no_system_call_restart:
0458         regs->u_regs[UREG_I0] = EINTR;
0459         regs->tstate |= (TSTATE_ICARRY|TSTATE_XCARRY);
0460         break;
0461     case ERESTARTSYS:
0462         if (!(sa->sa_flags & SA_RESTART))
0463             goto no_system_call_restart;
0464         fallthrough;
0465     case ERESTARTNOINTR:
0466         regs->u_regs[UREG_I0] = orig_i0;
0467         regs->tpc -= 4;
0468         regs->tnpc -= 4;
0469     }
0470 }
0471 
0472 /* Note that 'init' is a special process: it doesn't get signals it doesn't
0473  * want to handle. Thus you cannot kill init even with a SIGKILL even by
0474  * mistake.
0475  */
0476 static void do_signal(struct pt_regs *regs, unsigned long orig_i0)
0477 {
0478     struct ksignal ksig;
0479     int restart_syscall;
0480     bool has_handler;
0481     
0482     /* It's a lot of work and synchronization to add a new ptrace
0483      * register for GDB to save and restore in order to get
0484      * orig_i0 correct for syscall restarts when debugging.
0485      *
0486      * Although it should be the case that most of the global
0487      * registers are volatile across a system call, glibc already
0488      * depends upon that fact that we preserve them.  So we can't
0489      * just use any global register to save away the orig_i0 value.
0490      *
0491      * In particular %g2, %g3, %g4, and %g5 are all assumed to be
0492      * preserved across a system call trap by various pieces of
0493      * code in glibc.
0494      *
0495      * %g7 is used as the "thread register".   %g6 is not used in
0496      * any fixed manner.  %g6 is used as a scratch register and
0497      * a compiler temporary, but it's value is never used across
0498      * a system call.  Therefore %g6 is usable for orig_i0 storage.
0499      */
0500     if (pt_regs_is_syscall(regs) &&
0501         (regs->tstate & (TSTATE_XCARRY | TSTATE_ICARRY)))
0502         regs->u_regs[UREG_G6] = orig_i0;
0503 
0504 #ifdef CONFIG_COMPAT
0505     if (test_thread_flag(TIF_32BIT)) {
0506         do_signal32(regs);
0507         return;
0508     }
0509 #endif  
0510 
0511     has_handler = get_signal(&ksig);
0512 
0513     restart_syscall = 0;
0514     if (pt_regs_is_syscall(regs) &&
0515         (regs->tstate & (TSTATE_XCARRY | TSTATE_ICARRY))) {
0516         restart_syscall = 1;
0517         orig_i0 = regs->u_regs[UREG_G6];
0518     }
0519 
0520     if (has_handler) {
0521         if (restart_syscall)
0522             syscall_restart(orig_i0, regs, &ksig.ka.sa);
0523         signal_setup_done(setup_rt_frame(&ksig, regs), &ksig, 0);
0524     } else {
0525         if (restart_syscall) {
0526             switch (regs->u_regs[UREG_I0]) {
0527             case ERESTARTNOHAND:
0528                 case ERESTARTSYS:
0529             case ERESTARTNOINTR:
0530                 /* replay the system call when we are done */
0531                 regs->u_regs[UREG_I0] = orig_i0;
0532                 regs->tpc -= 4;
0533                 regs->tnpc -= 4;
0534                 pt_regs_clear_syscall(regs);
0535                 fallthrough;
0536             case ERESTART_RESTARTBLOCK:
0537                 regs->u_regs[UREG_G1] = __NR_restart_syscall;
0538                 regs->tpc -= 4;
0539                 regs->tnpc -= 4;
0540                 pt_regs_clear_syscall(regs);
0541             }
0542         }
0543         restore_saved_sigmask();
0544     }
0545 }
0546 
0547 void do_notify_resume(struct pt_regs *regs, unsigned long orig_i0, unsigned long thread_info_flags)
0548 {
0549     user_exit();
0550     if (thread_info_flags & _TIF_UPROBE)
0551         uprobe_notify_resume(regs);
0552     if (thread_info_flags & (_TIF_SIGPENDING | _TIF_NOTIFY_SIGNAL))
0553         do_signal(regs, orig_i0);
0554     if (thread_info_flags & _TIF_NOTIFY_RESUME)
0555         resume_user_mode_work(regs);
0556     user_enter();
0557 }
0558 
0559 /*
0560  * Compile-time assertions for siginfo_t offsets. Check NSIG* as well, as
0561  * changes likely come with new fields that should be added below.
0562  */
0563 static_assert(NSIGILL   == 11);
0564 static_assert(NSIGFPE   == 15);
0565 static_assert(NSIGSEGV  == 9);
0566 static_assert(NSIGBUS   == 5);
0567 static_assert(NSIGTRAP  == 6);
0568 static_assert(NSIGCHLD  == 6);
0569 static_assert(NSIGSYS   == 2);
0570 static_assert(sizeof(siginfo_t) == 128);
0571 static_assert(__alignof__(siginfo_t) == 8);
0572 static_assert(offsetof(siginfo_t, si_signo) == 0x00);
0573 static_assert(offsetof(siginfo_t, si_errno) == 0x04);
0574 static_assert(offsetof(siginfo_t, si_code)  == 0x08);
0575 static_assert(offsetof(siginfo_t, si_pid)   == 0x10);
0576 static_assert(offsetof(siginfo_t, si_uid)   == 0x14);
0577 static_assert(offsetof(siginfo_t, si_tid)   == 0x10);
0578 static_assert(offsetof(siginfo_t, si_overrun)   == 0x14);
0579 static_assert(offsetof(siginfo_t, si_status)    == 0x18);
0580 static_assert(offsetof(siginfo_t, si_utime) == 0x20);
0581 static_assert(offsetof(siginfo_t, si_stime) == 0x28);
0582 static_assert(offsetof(siginfo_t, si_value) == 0x18);
0583 static_assert(offsetof(siginfo_t, si_int)   == 0x18);
0584 static_assert(offsetof(siginfo_t, si_ptr)   == 0x18);
0585 static_assert(offsetof(siginfo_t, si_addr)  == 0x10);
0586 static_assert(offsetof(siginfo_t, si_trapno)    == 0x18);
0587 static_assert(offsetof(siginfo_t, si_addr_lsb)  == 0x18);
0588 static_assert(offsetof(siginfo_t, si_lower) == 0x20);
0589 static_assert(offsetof(siginfo_t, si_upper) == 0x28);
0590 static_assert(offsetof(siginfo_t, si_pkey)  == 0x20);
0591 static_assert(offsetof(siginfo_t, si_perf_data) == 0x18);
0592 static_assert(offsetof(siginfo_t, si_perf_type) == 0x20);
0593 static_assert(offsetof(siginfo_t, si_perf_flags) == 0x24);
0594 static_assert(offsetof(siginfo_t, si_band)  == 0x10);
0595 static_assert(offsetof(siginfo_t, si_fd)    == 0x14);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!