From: Paul Mackerras When booting with kprobes and preemption both enabled and CONFIG_DEBUG_PREEMPT=y, I get lots of warnings about smp_processor_id being called in preemptible code, from kprobe_exceptions_notify. On ppc64, interrupts and preemption are not disabled in the handlers for most synchronous exceptions such as breakpoints and page faults (interrupts are disabled in the very early exception entry code but are reenabled before calling the C handler). This patch adds a preempt_disable/enable pair to kprobe_exceptions_notify, and moves the preempt_disable() in kprobe_handler() to be done only in the case where we are about to single-step an instruction. This eliminates the bug warnings. Signed-off-by: Paul Mackerras Signed-off-by: Andrew Morton --- 25-akpm/arch/ppc64/kernel/kprobes.c | 25 +++++++++++++++++-------- 1 files changed, 17 insertions(+), 8 deletions(-) diff -puN arch/ppc64/kernel/kprobes.c~ppc64-fix-kprobes-calling-smp_processor_id-when-preemptible arch/ppc64/kernel/kprobes.c --- 25/arch/ppc64/kernel/kprobes.c~ppc64-fix-kprobes-calling-smp_processor_id-when-preemptible Mon Mar 14 16:14:48 2005 +++ 25-akpm/arch/ppc64/kernel/kprobes.c Mon Mar 14 16:14:48 2005 @@ -80,9 +80,6 @@ static inline int kprobe_handler(struct int ret = 0; unsigned int *addr = (unsigned int *)regs->nip; - /* We're in an interrupt, but this is clear and BUG()-safe. */ - preempt_disable(); - /* Check we're not actually recursing */ if (kprobe_running()) { /* We *are* holding lock here, so this is safe. @@ -139,10 +136,14 @@ static inline int kprobe_handler(struct ss_probe: prepare_singlestep(p, regs); kprobe_status = KPROBE_HIT_SS; + /* + * This preempt_disable() matches the preempt_enable_no_resched() + * in post_kprobe_handler(). + */ + preempt_disable(); return 1; no_kprobe: - preempt_enable_no_resched(); return ret; } @@ -215,27 +216,35 @@ int kprobe_exceptions_notify(struct noti void *data) { struct die_args *args = (struct die_args *)data; + int ret = NOTIFY_DONE; + + /* + * Interrupts are not disabled here. We need to disable + * preemption, because kprobe_running() uses smp_processor_id(). + */ + preempt_disable(); switch (val) { case DIE_IABR_MATCH: case DIE_DABR_MATCH: case DIE_BPT: if (kprobe_handler(args->regs)) - return NOTIFY_STOP; + ret = NOTIFY_STOP; break; case DIE_SSTEP: if (post_kprobe_handler(args->regs)) - return NOTIFY_STOP; + ret = NOTIFY_STOP; break; case DIE_GPF: case DIE_PAGE_FAULT: if (kprobe_running() && kprobe_fault_handler(args->regs, args->trapnr)) - return NOTIFY_STOP; + ret = NOTIFY_STOP; break; default: break; } - return NOTIFY_DONE; + preempt_enable(); + return ret; } int setjmp_pre_handler(struct kprobe *p, struct pt_regs *regs) _