ppc64: 2.5.28 update

arch/ppc64/kernel/irq.c

@@ -169,6 +169,10 @@ setup_irq(unsigned int irq, struct irqaction * new)
 
 inline void synchronize_irq(unsigned int irq)
 {
+	/* is there anything to synchronize with? */
+	if (!irq_desc[irq].action)
+		return;
+
 	while (irq_desc[irq].status & IRQ_INPROGRESS) {
 		barrier();
 		cpu_relax();
@@ -567,7 +571,6 @@ void ppc_irq_dispatch_handler(struct pt_regs *regs, int irq)
 
 int do_IRQ(struct pt_regs *regs)
 {
-	int cpu = smp_processor_id();
 	int irq, first = 1;
 #ifdef CONFIG_PPC_ISERIES
 	struct paca_struct *lpaca;
@@ -615,9 +618,6 @@ int do_IRQ(struct pt_regs *regs)
 	}
 #endif
 
-	if (softirq_pending(cpu))
-		do_softirq();
-
 	return 1; /* lets ret_from_int know we can do checks */
 }
 

arch/ppc64/kernel/time.c

@@ -293,9 +293,6 @@ int timer_interrupt(struct pt_regs * regs)
 
 	irq_exit();
 
-	if (softirq_pending(cpu))
-		do_softirq();
-	
 	return 1;
 }
 

include/asm-ppc64/hardirq.h

@@ -13,30 +13,86 @@
 #include <linux/preempt.h>
 
 typedef struct {
-	unsigned long __softirq_pending;
-	unsigned long __syscall_count;
+	unsigned int __softirq_pending;
+	unsigned int __syscall_count;
 	struct task_struct * __ksoftirqd_task;
 	unsigned long idle_timestamp;
 } ____cacheline_aligned irq_cpustat_t;
 
 #include <linux/irq_cpustat.h>	/* Standard mappings for irq_cpustat_t above */
 
-#define IRQ_OFFSET 64
+/*
+ * We put the hardirq and softirq counter into the preemption
+ * counter. The bitmask has the following meaning:
+ *
+ * - bits 0-7 are the preemption count (max preemption depth: 256)
+ * - bits 8-15 are the softirq count (max # of softirqs: 256)
+ * - bits 16-24 are the hardirq count (max # of hardirqs: 512)
+ *
+ * - ( bit 26 is the PREEMPT_ACTIVE flag. )
+ *
+ * PREEMPT_MASK: 0x000000ff
+ * SOFTIRQ_MASK: 0x0000ff00
+ * HARDIRQ_MASK: 0x01ff0000
+ */
+
+#define PREEMPT_BITS	8
+#define SOFTIRQ_BITS	8
+#define HARDIRQ_BITS	9
+
+#define PREEMPT_SHIFT	0
+#define SOFTIRQ_SHIFT	(PREEMPT_SHIFT + PREEMPT_BITS)
+#define HARDIRQ_SHIFT	(SOFTIRQ_SHIFT + SOFTIRQ_BITS)
+
+#define __HARDIRQ_MASK(x)	((1UL << (x))-1)
+
+#define PREEMPT_MASK	(__HARDIRQ_MASK(PREEMPT_BITS) << PREEMPT_SHIFT)
+#define SOFTIRQ_MASK	(__HARDIRQ_MASK(SOFTIRQ_BITS) << SOFTIRQ_SHIFT)
+#define HARDIRQ_MASK	(__HARDIRQ_MASK(HARDIRQ_BITS) << HARDIRQ_SHIFT)
+
+#define hardirq_count()	(preempt_count() & HARDIRQ_MASK)
+#define softirq_count()	(preempt_count() & SOFTIRQ_MASK)
+#define irq_count()	(preempt_count() & (HARDIRQ_MASK | SOFTIRQ_MASK))
+
+#define PREEMPT_OFFSET	(1UL << PREEMPT_SHIFT)
+#define SOFTIRQ_OFFSET	(1UL << SOFTIRQ_SHIFT)
+#define HARDIRQ_OFFSET	(1UL << HARDIRQ_SHIFT)
 
 /*
- * Are we in an interrupt context? Either doing bottom half
- * or hardware interrupt processing?
+ * The hardirq mask has to be large enough to have
+ * space for potentially all IRQ sources in the system
+ * nesting on a single CPU:
  */
-#define in_interrupt() \
-		((preempt_count() & ~PREEMPT_ACTIVE) >= IRQ_OFFSET)
+#if (1 << HARDIRQ_BITS) < NR_IRQS
+# error HARDIRQ_BITS is too low!
+#endif
+
+/*
+ * Are we doing bottom half or hardware interrupt processing?
+ * Are we in a softirq context? Interrupt context?
+ */
+#define in_irq()		(hardirq_count())
+#define in_softirq()		(softirq_count())
+#define in_interrupt()		(irq_count())
 
-#define in_irq in_interrupt
 
 #define hardirq_trylock()	(!in_interrupt())
 #define hardirq_endlock()	do { } while (0)
 
-#define irq_enter()		(preempt_count() += IRQ_OFFSET)
-#define irq_exit()		(preempt_count() -= IRQ_OFFSET)
+#define irq_enter()		(preempt_count() += HARDIRQ_OFFSET)
+
+#if CONFIG_PREEMPT
+# define IRQ_EXIT_OFFSET (HARDIRQ_OFFSET-1)
+#else
+# define IRQ_EXIT_OFFSET HARDIRQ_OFFSET
+#endif
+#define irq_exit()							\
+do {									\
+		preempt_count() -= IRQ_EXIT_OFFSET;			\
+		if (!in_interrupt() && softirq_pending(smp_processor_id())) \
+			do_softirq();					\
+		preempt_enable_no_resched();				\
+} while (0)
 
 #ifndef CONFIG_SMP
 # define synchronize_irq(irq)	barrier()
@@ -45,4 +101,13 @@ typedef struct {
 #endif /* CONFIG_SMP */
 
 #endif /* __KERNEL__ */
+	
+#define show_stack(SP)				\
+do {						\
+	if (SP)					\
+		print_backtrace(SP);		\
+	else					\
+		print_backtrace(_get_SP());	\
+} while (0)
+
 #endif /* __ASM_HARDIRQ_H */

include/asm-ppc64/softirq.h

@@ -12,24 +12,16 @@
 #include <asm/hardirq.h>
 
 #define local_bh_disable() \
-		do { preempt_count() += IRQ_OFFSET; barrier(); } while (0)
-
+		do { preempt_count() += SOFTIRQ_OFFSET; barrier(); } while (0)
 #define __local_bh_enable() \
-		do { barrier(); preempt_count() -= IRQ_OFFSET; } while (0)
+		do { barrier(); preempt_count() -= SOFTIRQ_OFFSET; } while (0)
 
 #define local_bh_enable()						\
 do {									\
-	if (unlikely((preempt_count() == IRQ_OFFSET) && \
-		     softirq_pending(smp_processor_id()))) { \
 	__local_bh_enable();						\
+	if (unlikely(!in_interrupt() && softirq_pending(smp_processor_id()))) \
 		do_softirq();						\
 	preempt_check_resched();					\
-	} else { \
-		__local_bh_enable(); \
-		preempt_check_resched(); \
-	} \
 } while (0)
 
-#define in_softirq() in_interrupt()
-
 #endif	/* __ASM_SOFTIRQ_H */

include/asm-ppc64/system.h

@@ -88,26 +88,18 @@ struct task_struct;
 extern void __switch_to(struct task_struct *, struct task_struct *);
 #define switch_to(prev, next, last) __switch_to((prev), (next))
 
-#define prepare_arch_schedule(prev)		do { } while(0)
-#define finish_arch_schedule(prev)		do { } while(0)
-#define prepare_arch_switch(rq)			do { } while(0)
-#define finish_arch_switch(rq)			spin_unlock_irq(&(rq)->lock)
-
 struct thread_struct;
 extern void _switch(struct thread_struct *prev, struct thread_struct *next);
 
 struct pt_regs;
 extern void dump_regs(struct pt_regs *);
 
-#ifndef CONFIG_SMP
-
-#define cli()	local_irq_disable()
-#define sti()	local_irq_enable()
-#define save_flags(flags)	local_save_flags(flags)
-#define restore_flags(flags)	local_irq_restore(flags)
-#define save_and_cli(flags)	local_irq_save(flags)
-
-#endif /* !CONFIG_SMP */
+#define irqs_disabled()				\
+({						\
+	unsigned long flags;			\
+	local_save_flags(flags);		\
+	!(flags & MSR_EE);			\
+})
 
 static __inline__ int __is_processor(unsigned long pv)
 {

include/asm-ppc64/thread_info.h

@@ -27,6 +27,8 @@ struct thread_info {
 
 /*
  * macros/functions for gaining access to the thread information structure
+ *
+ * preempt_count needs to be 1 initially, until the scheduler is functional.
  */
 #define INIT_THREAD_INFO(tsk)			\
 {						\
@@ -34,6 +36,7 @@ struct thread_info {
 	exec_domain:	&default_exec_domain,	\
 	flags:		0,			\
 	cpu:		0,			\
+	preempt_count:	1,			\
 }
 
 #define init_thread_info	(init_thread_union.thread_info)