include/linux/spinlock.h

   1 #ifndef __LINUX_SPINLOCK_H
   2 #define __LINUX_SPINLOCK_H
   3
   4 /*
   5  * These are the generic versions of the spinlocks and read-write
   6  * locks..
   7  */
   8 #define spin_lock_irqsave(lock, flags)          do { local_irq_save(flags);       spin_lock(lock); } while (0)
   9 #define spin_lock_irq(lock)                     do { local_irq_disable();         spin_lock(lock); } while (0)
  10 #define spin_lock_bh(lock)                      do { local_bh_disable();          spin_lock(lock); } while (0)
  11
  12 #define read_lock_irqsave(lock, flags)          do { local_irq_save(flags);       read_lock(lock); } while (0)
  13 #define read_lock_irq(lock)                     do { local_irq_disable();         read_lock(lock); } while (0)
  14 #define read_lock_bh(lock)                      do { local_bh_disable();          read_lock(lock); } while (0)
  15
  16 #define write_lock_irqsave(lock, flags)         do { local_irq_save(flags);      write_lock(lock); } while (0)
  17 #define write_lock_irq(lock)                    do { local_irq_disable();        write_lock(lock); } while (0)
  18 #define write_lock_bh(lock)                     do { local_bh_disable();         write_lock(lock); } while (0)
  19
  20 #define spin_unlock_irqrestore(lock, flags)     do { spin_unlock(lock);  local_irq_restore(flags); } while (0)
  21 #define spin_unlock_irq(lock)                   do { spin_unlock(lock);  local_irq_enable();       } while (0)
  22 #define spin_unlock_bh(lock)                    do { spin_unlock(lock);  local_bh_enable();        } while (0)
  23
  24 #define read_unlock_irqrestore(lock, flags)     do { read_unlock(lock);  local_irq_restore(flags); } while (0)
  25 #define read_unlock_irq(lock)                   do { read_unlock(lock);  local_irq_enable();       } while (0)
  26 #define read_unlock_bh(lock)                    do { read_unlock(lock);  local_bh_enable();        } while (0)
  27
  28 #define write_unlock_irqrestore(lock, flags)    do { write_unlock(lock); local_irq_restore(flags); } while (0)
  29 #define write_unlock_irq(lock)                  do { write_unlock(lock); local_irq_enable();       } while (0)
  30 #define write_unlock_bh(lock)                   do { write_unlock(lock); local_bh_enable();        } while (0)
  31
  32 #ifdef CONFIG_SMP
  33 #include <asm/spinlock.h>
  34
  35 #else /* !SMP */
  36
  37 #define DEBUG_SPINLOCKS 0       /* 0 == no debugging, 1 == maintain lock state, 2 == full debug */
  38
  39 #if (DEBUG_SPINLOCKS < 1)
  40
  41 /*
  42  * Your basic spinlocks, allowing only a single CPU anywhere
  43  *
  44  * Gcc-2.7.x has a nasty bug with empty initializers.
  45  */
  46 #if (__GNUC__ > 2) || (__GNUC__ == 2 && __GNUC_MINOR__ >= 8)
  47   typedef struct { } spinlock_t;
  48   #define SPIN_LOCK_UNLOCKED (spinlock_t) { }
  49 #else
  50   typedef struct { int gcc_is_buggy; } spinlock_t;
  51   #define SPIN_LOCK_UNLOCKED (spinlock_t) { 0 }
  52 #endif
  53
  54 #define spin_lock_init(lock)    do { } while(0)
  55 #define spin_lock(lock)         (void)(lock) /* Not "unused variable". */
  56 #define spin_trylock(lock)      (1)
  57 #define spin_unlock_wait(lock)  do { } while(0)
  58 #define spin_unlock(lock)       do { } while(0)
  59
  60 #elif (DEBUG_SPINLOCKS < 2)
  61
  62 typedef struct {
  63         volatile unsigned int lock;
  64 } spinlock_t;
  65 #define SPIN_LOCK_UNLOCKED (spinlock_t) { 0 }
  66
  67 #define spin_lock_init(x)       do { (x)->lock = 0; } while (0)
  68 #define spin_trylock(lock)      (!test_and_set_bit(0,(lock)))
  69
  70 #define spin_lock(x)            do { (x)->lock = 1; } while (0)
  71 #define spin_unlock_wait(x)     do { } while (0)
  72 #define spin_unlock(x)          do { (x)->lock = 0; } while (0)
  73
  74 #else /* (DEBUG_SPINLOCKS >= 2) */
  75
  76 typedef struct {
  77         volatile unsigned int lock;
  78         volatile unsigned int babble;
  79         const char *module;
  80 } spinlock_t;
  81 #define SPIN_LOCK_UNLOCKED (spinlock_t) { 0, 25, __BASE_FILE__ }
  82
  83 #include <linux/kernel.h>
  84
  85 #define spin_lock_init(x)       do { (x)->lock = 0; } while (0)
  86 #define spin_trylock(lock)      (!test_and_set_bit(0,(lock)))
  87
  88 #define spin_lock(x)            do {unsigned long __spinflags; save_flags(__spinflags); cli(); if ((x)->lock&&(x)->babble) {printk("%s:%d: spin_lock(%s:%p) already locked\n", __BASE_FILE__,__LINE__, (x)->module, (x));(x)->babble--;} (x)->lock = 1; restore_flags(__spinflags);} while (0)
  89 #define spin_unlock_wait(x)     do {unsigned long __spinflags; save_flags(__spinflags); cli(); if ((x)->lock&&(x)->babble) {printk("%s:%d: spin_unlock_wait(%s:%p) deadlock\n", __BASE_FILE__,__LINE__, (x)->module, (x));(x)->babble--;} restore_flags(__spinflags);} while (0)
  90 #define spin_unlock(x)          do {unsigned long __spinflags; save_flags(__spinflags); cli(); if (!(x)->lock&&(x)->babble) {printk("%s:%d: spin_unlock(%s:%p) not locked\n", __BASE_FILE__,__LINE__, (x)->module, (x));(x)->babble--;} (x)->lock = 0; restore_flags(__spinflags);} while (0)
  91
  92 #endif  /* DEBUG_SPINLOCKS */
  93
  94 /*
  95  * Read-write spinlocks, allowing multiple readers
  96  * but only one writer.
  97  *
  98  * NOTE! it is quite common to have readers in interrupts
  99  * but no interrupt writers. For those circumstances we
 100  * can "mix" irq-safe locks - any writer needs to get a
 101  * irq-safe write-lock, but readers can get non-irqsafe
 102  * read-locks.
 103  *
 104  * Gcc-2.7.x has a nasty bug with empty initializers.
 105  */
 106 #if (__GNUC__ > 2) || (__GNUC__ == 2 && __GNUC_MINOR__ >= 8)
 107   typedef struct { } rwlock_t;
 108   #define RW_LOCK_UNLOCKED (rwlock_t) { }
 109 #else
 110   typedef struct { int gcc_is_buggy; } rwlock_t;
 111   #define RW_LOCK_UNLOCKED (rwlock_t) { 0 }
 112 #endif
 113
 114 #define read_lock(lock)         (void)(lock) /* Not "unused variable". */
 115 #define read_unlock(lock)       do { } while(0)
 116 #define write_lock(lock)        (void)(lock) /* Not "unused variable". */
 117 #define write_unlock(lock)      do { } while(0)
 118
 119 #endif /* !SMP */
 120 #endif /* __LINUX_SPINLOCK_H */