include/asm-i386/softirq.h

   1 #ifndef __ASM_SOFTIRQ_H
   2 #define __ASM_SOFTIRQ_H
   3
   4 #include <asm/atomic.h>
   5 #include <asm/hardirq.h>
   6
   7 extern unsigned int local_bh_count[NR_CPUS];
   8
   9 #define cpu_bh_disable(cpu)     do { local_bh_count[(cpu)]++; barrier(); } while (0)
  10 #define cpu_bh_enable(cpu)      do { barrier(); local_bh_count[(cpu)]--; } while (0)
  11
  12 #define cpu_bh_trylock(cpu)     (local_bh_count[(cpu)] ? 0 : (local_bh_count[(cpu)] = 1))
  13 #define cpu_bh_endlock(cpu)     (local_bh_count[(cpu)] = 0)
  14
  15 #define local_bh_disable()      cpu_bh_disable(smp_processor_id())
  16 #define local_bh_enable()       cpu_bh_enable(smp_processor_id())
  17
  18 #define get_active_bhs()        (bh_mask & bh_active)
  19 #define clear_active_bhs(x)     atomic_clear_mask((x),&bh_active)
  20
  21 extern spinlock_t i386_bh_lock;
  22
  23 #ifdef __SMP__
  24
  25 /*
  26  * The locking mechanism for base handlers, to prevent re-entrancy,
  27  * is entirely private to an implementation, it should not be
  28  * referenced at all outside of this file.
  29  */
  30 extern atomic_t global_bh_lock;
  31 extern atomic_t global_bh_count;
  32
  33 extern void synchronize_bh(void);
  34
  35 static inline void start_bh_atomic(void)
  36 {
  37         atomic_inc(&global_bh_lock);
  38         synchronize_bh();
  39 }
  40
  41 static inline void end_bh_atomic(void)
  42 {
  43         atomic_dec(&global_bh_lock);
  44 }
  45
  46 /* These are for the IRQs testing the lock */
  47 static inline int softirq_trylock(int cpu)
  48 {
  49         if (cpu_bh_trylock(cpu)) {
  50                 if (!test_and_set_bit(0,&global_bh_count)) {
  51                         if (atomic_read(&global_bh_lock) == 0)
  52                                 return 1;
  53                         clear_bit(0,&global_bh_count);
  54                 }
  55                 cpu_bh_endlock(cpu);
  56         }
  57         return 0;
  58 }
  59
  60 static inline void softirq_endlock(int cpu)
  61 {
  62         cpu_bh_enable(cpu);
  63         clear_bit(0,&global_bh_count);
  64 }
  65
  66 #else
  67
  68 extern inline void start_bh_atomic(void)
  69 {
  70         local_bh_disable();
  71         barrier();
  72 }
  73
  74 extern inline void end_bh_atomic(void)
  75 {
  76         barrier();
  77         local_bh_enable();
  78 }
  79
  80 /* These are for the irq's testing the lock */
  81 #define softirq_trylock(cpu)    (cpu_bh_trylock(cpu))
  82 #define softirq_endlock(cpu)    (cpu_bh_endlock(cpu))
  83 #define synchronize_bh()        barrier()
  84
  85 #endif  /* SMP */
  86
  87 extern inline void init_bh(int nr, void (*routine)(void))
  88 {
  89         unsigned long flags;
  90
  91         bh_base[nr] = routine;
  92         atomic_set(&bh_mask_count[nr], 0);
  93
  94         spin_lock_irqsave(&i386_bh_lock, flags);
  95         bh_mask |= 1 << nr;
  96         spin_unlock_irqrestore(&i386_bh_lock, flags);
  97 }
  98
  99 extern inline void remove_bh(int nr)
 100 {
 101         unsigned long flags;
 102
 103         spin_lock_irqsave(&i386_bh_lock, flags);
 104         bh_mask &= ~(1 << nr);
 105         spin_unlock_irqrestore(&i386_bh_lock, flags);
 106
 107         synchronize_bh();
 108         bh_base[nr] = NULL;
 109 }
 110
 111 extern inline void mark_bh(int nr)
 112 {
 113         set_bit(nr, &bh_active);
 114 }
 115
 116 /*
 117  * These use a mask count to correctly handle
 118  * nested disable/enable calls
 119  */
 120 extern inline void disable_bh(int nr)
 121 {
 122         unsigned long flags;
 123
 124         spin_lock_irqsave(&i386_bh_lock, flags);
 125         bh_mask &= ~(1 << nr);
 126         atomic_inc(&bh_mask_count[nr]);
 127         spin_unlock_irqrestore(&i386_bh_lock, flags);
 128         synchronize_bh();
 129 }
 130
 131 extern inline void enable_bh(int nr)
 132 {
 133         unsigned long flags;
 134
 135         spin_lock_irqsave(&i386_bh_lock, flags);
 136         if (atomic_dec_and_test(&bh_mask_count[nr]))
 137                 bh_mask |= 1 << nr;
 138         spin_unlock_irqrestore(&i386_bh_lock, flags);
 139 }
 140
 141 #endif  /* __ASM_SOFTIRQ_H */