asmlinkage int sys_rt_sigreturn(long r10, long r11, long r12, long r13, long mof, long srp, struct pt_regs *regs) { struct rt_sigframe __user *frame = (struct rt_sigframe *)rdusp(); sigset_t set; if (((long)frame) & 3) goto badframe; if (!access_ok(VERIFY_READ, frame, sizeof(*frame))) goto badframe; if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set))) goto badframe; sigdelsetmask(&set, ~_BLOCKABLE); spin_lock_irq(¤t->sighand->siglock); current->blocked = set; recalc_sigpending(); spin_unlock_irq(¤t->sighand->siglock); if (restore_sigcontext(regs, &frame->uc.uc_mcontext)) goto badframe; if (do_sigaltstack(&frame->uc.uc_stack, NULL, rdusp()) == -EFAULT) goto badframe; return regs->r10; badframe: force_sig(SIGSEGV, current); return 0; }
asmlinkage int sys_rt_sigreturn(long r10, long r11, long r12, long r13, long mof, long srp, struct pt_regs *regs) { struct rt_sigframe __user *frame = (struct rt_sigframe *)rdusp(); sigset_t set; /* * Since we stacked the signal on a dword boundary, * then frame should be dword aligned here. If it's * not, then the user is trying to mess with us. */ if (((long)frame) & 3) goto badframe; if (!access_ok(VERIFY_READ, frame, sizeof(*frame))) goto badframe; if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set))) goto badframe; set_current_blocked(&set); if (restore_sigcontext(regs, &frame->uc.uc_mcontext)) goto badframe; if (do_sigaltstack(&frame->uc.uc_stack, NULL, rdusp()) == -EFAULT) goto badframe; return regs->r10; badframe: force_sig(SIGSEGV, current); return 0; }
/* * Fill in the user structure for an ECOFF core dump. */ void dump_thread(struct pt_regs * pt, struct user * dump) { /* switch stack follows right below pt_regs: */ struct switch_stack * sw = ((struct switch_stack *) pt) - 1; dump->magic = CMAGIC; dump->start_code = current->mm->start_code; dump->start_data = current->mm->start_data; dump->start_stack = rdusp() & ~(PAGE_SIZE - 1); dump->u_tsize = ((current->mm->end_code - dump->start_code) >> PAGE_SHIFT); dump->u_dsize = ((current->mm->brk + PAGE_SIZE-1 - dump->start_data) >> PAGE_SHIFT); dump->u_ssize = (current->mm->start_stack - dump->start_stack + PAGE_SIZE-1) >> PAGE_SHIFT; /* * We store the registers in an order/format that is * compatible with DEC Unix/OSF/1 as this makes life easier * for gdb. */ dump->regs[EF_V0] = pt->r0; dump->regs[EF_T0] = pt->r1; dump->regs[EF_T1] = pt->r2; dump->regs[EF_T2] = pt->r3; dump->regs[EF_T3] = pt->r4; dump->regs[EF_T4] = pt->r5; dump->regs[EF_T5] = pt->r6; dump->regs[EF_T6] = pt->r7; dump->regs[EF_T7] = pt->r8; dump->regs[EF_S0] = sw->r9; dump->regs[EF_S1] = sw->r10; dump->regs[EF_S2] = sw->r11; dump->regs[EF_S3] = sw->r12; dump->regs[EF_S4] = sw->r13; dump->regs[EF_S5] = sw->r14; dump->regs[EF_S6] = sw->r15; dump->regs[EF_A3] = pt->r19; dump->regs[EF_A4] = pt->r20; dump->regs[EF_A5] = pt->r21; dump->regs[EF_T8] = pt->r22; dump->regs[EF_T9] = pt->r23; dump->regs[EF_T10] = pt->r24; dump->regs[EF_T11] = pt->r25; dump->regs[EF_RA] = pt->r26; dump->regs[EF_T12] = pt->r27; dump->regs[EF_AT] = pt->r28; dump->regs[EF_SP] = rdusp(); dump->regs[EF_PS] = pt->ps; dump->regs[EF_PC] = pt->pc; dump->regs[EF_GP] = pt->gp; dump->regs[EF_A0] = pt->r16; dump->regs[EF_A1] = pt->r17; dump->regs[EF_A2] = pt->r18; memcpy((char *)dump->regs + EF_SIZE, sw->fp, 32 * 8); }
asmlinkage int sys_sigreturn(long r10, long r11, long r12, long r13, long mof, long srp, struct pt_regs *regs) { struct sigframe __user *frame = (struct sigframe *)rdusp(); sigset_t set; if (((long)frame) & 3) goto badframe; if (!access_ok(VERIFY_READ, frame, sizeof(*frame))) goto badframe; if (__get_user(set.sig[0], &frame->sc.oldmask) || (_NSIG_WORDS > 1 && __copy_from_user(&set.sig[1], frame->extramask, sizeof(frame->extramask)))) goto badframe; sigdelsetmask(&set, ~_BLOCKABLE); spin_lock_irq(¤t->sighand->siglock); current->blocked = set; recalc_sigpending(); spin_unlock_irq(¤t->sighand->siglock); if (restore_sigcontext(regs, &frame->sc)) goto badframe; return regs->r10; badframe: force_sig(SIGSEGV, current); return 0; }
long vmadump_store_cpu(struct vmadump_map_ctx *ctx, struct file *file, struct pt_regs *regs) { struct switch_stack *ss; unsigned long usp; long bytes = 0, r; /* Store struct pt_regs */ r = write_kern(ctx, file, regs, sizeof(*regs)); if (r != sizeof(*regs)) goto err; bytes += r; /* Alpha has more registers than what's in struct ptregs to save * The 'switch_stack' structure contains the rest of the integer * registers and the floating point registers. Then we still have * to go after the user's stack pointer via the PAL code. */ /* Some pointer voodoo... the switch_stack structure got * pushed on top of the struct pt_regs.. */ ss = ((struct switch_stack *) regs)-1; usp = rdusp(); r = write_kern(ctx, file, ss, sizeof(*ss)); if (r != sizeof(*ss)) goto err; bytes += r; r = write_kern(ctx, file, &usp, sizeof(usp)); if (r != sizeof(usp)) goto err; bytes += r; return bytes; err: if (r >= 0) r = -EIO; return r; }
asmlinkage int do_rt_sigreturn(unsigned long __unused) { struct pt_regs *regs = (struct pt_regs *)__unused; unsigned long usp = rdusp(); struct rt_sigframe *frame = (struct rt_sigframe *)(usp); sigset_t set; int r0; if (!access_ok(VERIFY_READ, frame, sizeof(*frame))) goto badframe; if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set))) goto badframe; sigdelsetmask(&set, ~_BLOCKABLE); set_current_blocked(&set); if (rt_restore_sigcontext(regs, &frame->uc.uc_mcontext, &r0)) goto badframe; if (do_sigaltstack(&frame->uc.uc_stack, NULL, regs->usp) == -EFAULT) goto badframe; return r0; badframe: force_sig(SIGSEGV, current); return 0; }
asmlinkage int do_rt_sigreturn(unsigned long __unused,...) { struct pt_regs *regs = (struct pt_regs *) &__unused; unsigned long usp = rdusp(); struct rt_sigframe *frame = (struct rt_sigframe *)(usp - 4); sigset_t set; int er0; if (!access_ok(VERIFY_READ, frame, sizeof(*frame))) goto badframe; if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set))) goto badframe; sigdelsetmask(&set, ~_BLOCKABLE); spin_unlock_irq(¤t->sighand->siglock); current->blocked = set; recalc_sigpending(); spin_lock_irq(¤t->sighand->siglock); if (restore_sigcontext(regs, &frame->uc.uc_mcontext, &er0)) goto badframe; if (do_sigaltstack(&frame->uc.uc_stack, NULL, usp) == -EFAULT) goto badframe; return er0; badframe: force_sig(SIGSEGV, current); return 0; }
asmlinkage int do_sigreturn(unsigned long __unused,...) { struct pt_regs *regs = (struct pt_regs *) (&__unused - 1); unsigned long usp = rdusp(); struct sigframe *frame = (struct sigframe *)(usp - 4); sigset_t set; int er0; if (!access_ok(VERIFY_READ, frame, sizeof(*frame))) goto badframe; if (__get_user(set.sig[0], &frame->sc.sc_mask) || (_NSIG_WORDS > 1 && __copy_from_user(&set.sig[1], &frame->extramask, sizeof(frame->extramask)))) goto badframe; sigdelsetmask(&set, ~_BLOCKABLE); spin_lock_irq(¤t->sighand->siglock); current->blocked = set; recalc_sigpending(); spin_unlock_irq(¤t->sighand->siglock); if (restore_sigcontext(regs, &frame->sc, &er0)) goto badframe; return er0; badframe: force_sig(SIGSEGV, current); return 0; }
/* * "alpha_clone()".. By the time we get here, the * non-volatile registers have also been saved on the * stack. We do some ugly pointer stuff here.. (see * also copy_thread) * * Notice that "fork()" is implemented in terms of clone, * with parameters (SIGCHLD, 0). */ int alpha_clone(unsigned long clone_flags, unsigned long usp, struct switch_stack * swstack) { if (!usp) usp = rdusp(); return do_fork(clone_flags, usp, (struct pt_regs *) (swstack+1)); }
asmlinkage int sys_sigreturn(void) { struct pt_regs *regs = current_pt_regs(); struct sigframe __user *frame = (struct sigframe *)rdusp(); sigset_t set; /* * Since we stacked the signal on a dword boundary, * then frame should be dword aligned here. If it's * not, then the user is trying to mess with us. */ if (((long)frame) & 3) goto badframe; if (!access_ok(VERIFY_READ, frame, sizeof(*frame))) goto badframe; if (__get_user(set.sig[0], &frame->sc.oldmask) || (_NSIG_WORDS > 1 && __copy_from_user(&set.sig[1], frame->extramask, sizeof(frame->extramask)))) goto badframe; set_current_blocked(&set); if (restore_sigcontext(regs, &frame->sc)) goto badframe; /* TODO: SIGTRAP when single-stepping as in arm ? */ return regs->r10; badframe: force_sig(SIGSEGV, current); return 0; }
asmlinkage int sys_rt_sigreturn(void) { unsigned long usp = rdusp(); struct rt_sigframe *frame = (struct rt_sigframe *)(usp - 4); sigset_t set; int er0; if (!access_ok(VERIFY_READ, frame, sizeof(*frame))) goto badframe; if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set))) goto badframe; set_current_blocked(&set); if (restore_sigcontext(&frame->uc.uc_mcontext, &er0)) goto badframe; if (restore_altstack(&frame->uc.uc_stack)) goto badframe; return er0; badframe: force_sig(SIGSEGV, current); return 0; }
static inline int rt_setup_sigcontext(struct sigcontext *sc, struct pt_regs *regs) { int err = 0; #define SETUP(x) err |= __put_user(regs->x, &sc->sc_##x) SETUP(r0); SETUP(r1); SETUP(r2); SETUP(r3); SETUP(r4); SETUP(r5); SETUP(r6); SETUP(r7); SETUP(p0); SETUP(p1); SETUP(p2); SETUP(p3); SETUP(p4); SETUP(p5); err |= __put_user(rdusp(), &sc->sc_usp); SETUP(a0w); SETUP(a1w); SETUP(a0x); SETUP(a1x); SETUP(astat); SETUP(rets); SETUP(pc); SETUP(retx); SETUP(fp); SETUP(i0); SETUP(i1); SETUP(i2); SETUP(i3); SETUP(m0); SETUP(m1); SETUP(m2); SETUP(m3); SETUP(l0); SETUP(l1); SETUP(l2); SETUP(l3); SETUP(b0); SETUP(b1); SETUP(b2); SETUP(b3); SETUP(lc0); SETUP(lc1); SETUP(lt0); SETUP(lt1); SETUP(lb0); SETUP(lb1); SETUP(seqstat); return err; }
asmlinkage int do_sigreturn(unsigned long __unused,...) { struct pt_regs *regs = (struct pt_regs *) (&__unused - 1); unsigned long usp = rdusp(); struct sigframe *frame = (struct sigframe *)(usp - 4); sigset_t set; int er0; if (!access_ok(VERIFY_READ, frame, sizeof(*frame))) goto badframe; if (__get_user(set.sig[0], &frame->sc.sc_mask) || (_NSIG_WORDS > 1 && __copy_from_user(&set.sig[1], &frame->extramask, sizeof(frame->extramask)))) goto badframe; set_current_blocked(&set); if (restore_sigcontext(regs, &frame->sc, &er0)) goto badframe; return er0; badframe: force_sig(SIGSEGV, current); return 0; }
/* FIXME: Is parent_tid/child_tid really third/fourth argument? Update lib? */ asmlinkage int sys_clone(unsigned long newusp, unsigned long flags, int* parent_tid, int* child_tid, long mof, long srp, struct pt_regs *regs) { if (!newusp) newusp = rdusp(); return do_fork(flags, newusp, regs, 0, parent_tid, child_tid); }
static void setup_frame(int sig, struct k_sigaction *ka, sigset_t *set, struct pt_regs *regs, struct switch_stack * sw) { unsigned long oldsp, r26, err = 0; struct sigframe *frame; oldsp = rdusp(); frame = get_sigframe(ka, oldsp, sizeof(*frame)); if (verify_area(VERIFY_WRITE, frame, sizeof(*frame))) goto give_sigsegv; err |= setup_sigcontext(&frame->sc, regs, sw, set->sig[0], oldsp); if (_NSIG_WORDS > 1) { err |= __copy_to_user(frame->extramask, &set->sig[1], sizeof(frame->extramask)); } if (err) goto give_sigsegv; /* Set up to return from userspace. If provided, use a stub already in userspace. */ if (ka->ka_restorer) { r26 = (unsigned long) ka->ka_restorer; } else { err |= __put_user(INSN_MOV_R30_R16, frame->retcode+0); err |= __put_user(INSN_LDI_R0+__NR_sigreturn, frame->retcode+1); err |= __put_user(INSN_CALLSYS, frame->retcode+2); imb(); r26 = (unsigned long) frame->retcode; } /* Check that everything was written properly. */ if (err) goto give_sigsegv; /* "Return" to the handler */ regs->r26 = r26; regs->r27 = regs->pc = (unsigned long) ka->sa.sa_handler; regs->r16 = sig; /* a0: signal number */ regs->r17 = 0; /* a1: exception code */ regs->r18 = (unsigned long) &frame->sc; /* a2: sigcontext pointer */ wrusp((unsigned long) frame); #if DEBUG_SIG printk("SIG deliver (%s:%d): sp=%p pc=%p ra=%p\n", current->comm, current->pid, frame, regs->pc, regs->r26); #endif return; give_sigsegv: if (sig == SIGSEGV) ka->sa.sa_handler = SIG_DFL; force_sig(SIGSEGV, current); }
static int setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info, sigset_t *set, struct pt_regs *regs) { unsigned long oldsp, r26, err = 0; struct rt_sigframe __user *frame; oldsp = rdusp(); frame = get_sigframe(ka, oldsp, sizeof(*frame)); if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame))) return -EFAULT; err |= copy_siginfo_to_user(&frame->info, info); /* Create the ucontext. */ err |= __put_user(0, &frame->uc.uc_flags); err |= __put_user(0, &frame->uc.uc_link); err |= __put_user(set->sig[0], &frame->uc.uc_osf_sigmask); err |= __save_altstack(&frame->uc.uc_stack, oldsp); err |= setup_sigcontext(&frame->uc.uc_mcontext, regs, set->sig[0], oldsp); err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set)); if (err) return -EFAULT; /* Set up to return from userspace. If provided, use a stub already in userspace. */ if (ka->ka_restorer) { r26 = (unsigned long) ka->ka_restorer; } else { err |= __put_user(INSN_MOV_R30_R16, frame->retcode+0); err |= __put_user(INSN_LDI_R0+__NR_rt_sigreturn, frame->retcode+1); err |= __put_user(INSN_CALLSYS, frame->retcode+2); imb(); r26 = (unsigned long) frame->retcode; } if (err) return -EFAULT; /* "Return" to the handler */ regs->r26 = r26; regs->r27 = regs->pc = (unsigned long) ka->sa.sa_handler; regs->r16 = sig; /* a0: signal number */ regs->r17 = (unsigned long) &frame->info; /* a1: siginfo pointer */ regs->r18 = (unsigned long) &frame->uc; /* a2: ucontext pointer */ wrusp((unsigned long) frame); #if DEBUG_SIG printk("SIG deliver (%s:%d): sp=%p pc=%p ra=%p\n", current->comm, current->pid, frame, regs->pc, regs->r26); #endif return 0; }
/* * "alpha_clone()".. By the time we get here, the * non-volatile registers have also been saved on the * stack. We do some ugly pointer stuff here.. (see * also copy_thread) * * Notice that "fork()" is implemented in terms of clone, * with parameters (SIGCHLD, 0). */ int alpha_clone(unsigned long clone_flags, unsigned long usp, int __user *parent_tid, int __user *child_tid, unsigned long tls_value, struct pt_regs *regs) { if (!usp) usp = rdusp(); return do_fork(clone_flags, usp, regs, 0, parent_tid, child_tid); }
int show_stack() { unsigned long *sp = (unsigned long *)rdusp(); int i; raw_printk("Stack dump [0x%08lx]:\n", (unsigned long)sp); for(i = 0; i < 16; i++) raw_printk("sp + %d: 0x%08lx\n", i*4, sp[i]); return 0; }
void show_regs(struct pt_regs *fp) { char buf [150]; printk(KERN_NOTICE "\n" KERN_NOTICE "SEQUENCER STATUS:\n"); printk(KERN_NOTICE " SEQSTAT: %08lx IPEND: %04lx SYSCFG: %04lx\n", (long)fp->seqstat, fp->ipend, fp->syscfg); decode_address(buf, fp->rete); printk(KERN_NOTICE " RETE: %s\n", buf); decode_address(buf, fp->retn); printk(KERN_NOTICE " RETN: %s\n", buf); decode_address(buf, fp->retx); printk(KERN_NOTICE " RETX: %s\n", buf); decode_address(buf, fp->rets); printk(KERN_NOTICE " RETS: %s\n", buf); decode_address(buf, fp->pc); printk(KERN_NOTICE " PC: %s\n", buf); if ((long)fp->seqstat & SEQSTAT_EXCAUSE) { decode_address(buf, bfin_read_DCPLB_FAULT_ADDR()); printk(KERN_NOTICE "DCPLB_FAULT_ADDR: %s\n", buf); decode_address(buf, bfin_read_ICPLB_FAULT_ADDR()); printk(KERN_NOTICE "ICPLB_FAULT_ADDR: %s\n", buf); } printk(KERN_NOTICE "\n" KERN_NOTICE "PROCESSOR STATE:\n"); printk(KERN_NOTICE " R0 : %08lx R1 : %08lx R2 : %08lx R3 : %08lx\n", fp->r0, fp->r1, fp->r2, fp->r3); printk(KERN_NOTICE " R4 : %08lx R5 : %08lx R6 : %08lx R7 : %08lx\n", fp->r4, fp->r5, fp->r6, fp->r7); printk(KERN_NOTICE " P0 : %08lx P1 : %08lx P2 : %08lx P3 : %08lx\n", fp->p0, fp->p1, fp->p2, fp->p3); printk(KERN_NOTICE " P4 : %08lx P5 : %08lx FP : %08lx SP : %08lx\n", fp->p4, fp->p5, fp->fp, (long)fp); printk(KERN_NOTICE " LB0: %08lx LT0: %08lx LC0: %08lx\n", fp->lb0, fp->lt0, fp->lc0); printk(KERN_NOTICE " LB1: %08lx LT1: %08lx LC1: %08lx\n", fp->lb1, fp->lt1, fp->lc1); printk(KERN_NOTICE " B0 : %08lx L0 : %08lx M0 : %08lx I0 : %08lx\n", fp->b0, fp->l0, fp->m0, fp->i0); printk(KERN_NOTICE " B1 : %08lx L1 : %08lx M1 : %08lx I1 : %08lx\n", fp->b1, fp->l1, fp->m1, fp->i1); printk(KERN_NOTICE " B2 : %08lx L2 : %08lx M2 : %08lx I2 : %08lx\n", fp->b2, fp->l2, fp->m2, fp->i2); printk(KERN_NOTICE " B3 : %08lx L3 : %08lx M3 : %08lx I3 : %08lx\n", fp->b3, fp->l3, fp->m3, fp->i3); printk(KERN_NOTICE "A0.w: %08lx A0.x: %08lx A1.w: %08lx A1.x: %08lx\n", fp->a0w, fp->a0x, fp->a1w, fp->a1x); printk(KERN_NOTICE "USP : %08lx ASTAT: %08lx\n", rdusp(), fp->astat); printk(KERN_NOTICE "\n"); }
static int setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t * info, sigset_t * set, struct pt_regs *regs) { struct rt_sigframe *frame; int err = 0; frame = get_sigframe(ka, regs, sizeof(*frame)); err |= __put_user((current_thread_info()->exec_domain && current_thread_info()->exec_domain->signal_invmap && sig < 32 ? current_thread_info()->exec_domain-> signal_invmap[sig] : sig), &frame->sig); err |= __put_user(&frame->info, &frame->pinfo); err |= __put_user(&frame->uc, &frame->puc); err |= copy_siginfo_to_user(&frame->info, info); /* Create the ucontext. */ err |= __put_user(0, &frame->uc.uc_flags); err |= __put_user(0, &frame->uc.uc_link); err |= __put_user((void *)current->sas_ss_sp, &frame->uc.uc_stack.ss_sp); err |= __put_user(sas_ss_flags(rdusp()), &frame->uc.uc_stack.ss_flags); err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size); err |= rt_setup_sigcontext(&frame->uc.uc_mcontext, regs); err |= copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set)); if (err) goto give_sigsegv; /* Set up registers for signal handler */ wrusp((unsigned long)frame); if (current->personality & FDPIC_FUNCPTRS) { struct fdpic_func_descriptor __user *funcptr = (struct fdpic_func_descriptor *) ka->sa.sa_handler; __get_user(regs->pc, &funcptr->text); __get_user(regs->p3, &funcptr->GOT); } else regs->pc = (unsigned long)ka->sa.sa_handler; regs->rets = SIGRETURN_STUB; regs->r0 = frame->sig; regs->r1 = (unsigned long)(&frame->info); regs->r2 = (unsigned long)(&frame->uc); return 0; give_sigsegv: if (sig == SIGSEGV) ka->sa.sa_handler = SIG_DFL; force_sig(SIGSEGV, current); return -EFAULT; }
static inline void __user * get_sigframe(struct ksignal *ksig, size_t frame_size) { unsigned long sp = sigsp(rdusp(), ksig); /* make sure the frame is dword-aligned */ sp &= ~3; return (void __user*)(sp - frame_size); }
int show_stack(void) { unsigned long *sp = (unsigned long *)rdusp(); int i; pr_err("Stack dump [0x%08lx]:\n", (unsigned long)sp); for (i = 0; i < 16; i++) pr_err("sp + %d: 0x%08lx\n", i*4, sp[i]); return 0; }
asmlinkage int h8300_clone(struct pt_regs *regs) { unsigned long clone_flags; unsigned long newsp; /* syscall2 puts clone_flags in d1 and usp in d2 */ clone_flags = regs->er1; newsp = regs->er2; if (!newsp) newsp = rdusp(); return do_fork(clone_flags, newsp, regs); }
static void setup_sigcontext(struct sigcontext *sc, struct pt_regs *regs, unsigned long mask) { sc->sc_mask = mask; sc->sc_usp = rdusp(); sc->sc_er0 = regs->er0; sc->sc_er1 = regs->er1; sc->sc_er2 = regs->er2; sc->sc_er3 = regs->er3; sc->sc_er5 = regs->er5; sc->sc_ccr = regs->ccr; sc->sc_pc = regs->pc; }
static int setup_rt_frame(struct ksignal *ksig, sigset_t *set, struct pt_regs *regs) { struct rt_sigframe *frame; int err = 0; unsigned char *ret; frame = get_sigframe(ksig, regs, sizeof(*frame)); if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame))) return -EFAULT; if (ksig->ka.sa.sa_flags & SA_SIGINFO) err |= copy_siginfo_to_user(&frame->info, &ksig->info); /* Create the ucontext. */ err |= __put_user(0, &frame->uc.uc_flags); err |= __put_user(0, &frame->uc.uc_link); err |= __save_altstack(&frame->uc.uc_stack, rdusp()); err |= setup_sigcontext(&frame->uc.uc_mcontext, regs, set->sig[0]); err |= copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set)); if (err) return -EFAULT; /* Set up to return from userspace. */ ret = frame->retcode; if (ksig->ka.sa.sa_flags & SA_RESTORER) ret = (unsigned char *)(ksig->ka.sa.sa_restorer); else { /* sub.l er0,er0; mov.b #__NR_rt_sigreturn,r0l; trapa #0 */ err |= __put_user(0x1a80f800 + (__NR_rt_sigreturn & 0xff), (unsigned long *)(frame->retcode + 0)); err |= __put_user(0x5700, (unsigned short *)(frame->retcode + 4)); } err |= __put_user(ret, &frame->pretcode); if (err) return -EFAULT; /* Set up registers for signal handler */ wrusp((unsigned long) frame); regs->pc = (unsigned long) ksig->ka.sa.sa_handler; regs->er0 = ksig->sig; regs->er1 = (unsigned long)&(frame->info); regs->er2 = (unsigned long)&frame->uc; regs->er5 = current->mm->start_data; /* GOT base */ return 0; }
void show_regs(struct pt_regs * regs) { printk("\n"); printk("PC: %08lx Status: %02x\n", regs->pc, regs->ccr); printk("ORIG_ER0: %08lx ER0: %08lx ER1: %08lx\n", regs->orig_er0, regs->er0, regs->er1); printk("ER2: %08lx ER3: %08lx ER4: %08lx\n", regs->er2, regs->er3, regs->er4); printk("ER5: %08lx ", regs->er5); if (!(regs->ccr & 0x10)) printk("USP: %08lx\n", rdusp()); }
asmlinkage int bfin_clone(struct pt_regs *regs) { unsigned long clone_flags; unsigned long newsp; /* syscall2 puts clone_flags in r0 and usp in r1 */ clone_flags = regs->r0; newsp = regs->r1; if (!newsp) newsp = rdusp(); else newsp -= 12; return do_fork(clone_flags, newsp, regs, 0, NULL, NULL); }
void show_regs(struct pt_regs * regs) { printk("\nPC: %08lx Status: %02x", regs->pc, regs->ccr); printk("\nORIG_ER0: %08lx ER0: %08lx ER1: %08lx", regs->orig_er0, regs->er0, regs->er1); printk("\nER2: %08lx ER3: %08lx ER4: %08lx ER5: %08lx", regs->er2, regs->er3, regs->er4, regs->er5); printk("\nER6' %08lx ",regs->er6); if (user_mode(regs)) printk("USP: %08lx\n", rdusp()); else printk("\n"); }
void show_regs(struct pt_regs * regs) { unsigned long usp = rdusp(); printk("IRP: %08lx SRP: %08lx DCCR: %08lx USP: %08lx MOF: %08lx\n", regs->irp, regs->srp, regs->dccr, usp, regs->mof ); printk(" r0: %08lx r1: %08lx r2: %08lx r3: %08lx\n", regs->r0, regs->r1, regs->r2, regs->r3); printk(" r4: %08lx r5: %08lx r6: %08lx r7: %08lx\n", regs->r4, regs->r5, regs->r6, regs->r7); printk(" r8: %08lx r9: %08lx r10: %08lx r11: %08lx\n", regs->r8, regs->r9, regs->r10, regs->r11); printk("r12: %08lx r13: %08lx oR10: %08lx\n", regs->r12, regs->r13, regs->orig_r10); }
int copy_thread(unsigned long clone_flags, unsigned long usp, unsigned long arg, struct task_struct *p) { struct pt_regs *childregs = task_pt_regs(p); struct switch_stack *swstack = ((struct switch_stack *) childregs) - 1; /* * Put the pt_regs structure at the end of the new kernel stack page and * fix it up. Note: the task_struct doubles as the kernel stack for the * task. */ if (unlikely(p->flags & PF_KTHREAD)) { memset(swstack, 0, sizeof(struct switch_stack) + sizeof(struct pt_regs)); swstack->r1 = usp; swstack->r2 = arg; childregs->ccs = 1 << (I_CCS_BITNR + CCS_SHIFT); swstack->return_ip = (unsigned long) ret_from_kernel_thread; p->thread.ksp = (unsigned long) swstack; p->thread.usp = 0; return 0; } *childregs = *current_pt_regs(); /* Struct copy of pt_regs. */ childregs->r10 = 0; /* Child returns 0 after a fork/clone. */ /* Set a new TLS ? * The TLS is in $mof because it is the 5th argument to sys_clone. */ if (p->mm && (clone_flags & CLONE_SETTLS)) { task_thread_info(p)->tls = childregs->mof; } /* Put the switch stack right below the pt_regs. */ /* Parameter to ret_from_sys_call. 0 is don't restart the syscall. */ swstack->r9 = 0; /* * We want to return into ret_from_sys_call after the _resume. * ret_from_fork will call ret_from_sys_call. */ swstack->return_ip = (unsigned long) ret_from_fork; /* Fix the user-mode and kernel-mode stackpointer. */ p->thread.usp = usp ?: rdusp(); p->thread.ksp = (unsigned long) swstack; return 0; }