kitten/kernel/spinlock.c

   1 /*
   2  * Copyright (2004) Linus Torvalds
   3  *
   4  * Author: Zwane Mwaikambo <zwane@fsmlabs.com>
   5  *
   6  * Copyright (2004, 2005) Ingo Molnar
   7  *
   8  * This file contains the spinlock/rwlock implementations for the
   9  * SMP and the DEBUG_SPINLOCK cases.
  10  */
  11
  12 #include <lwk/linkage.h>
  13 #include <lwk/spinlock.h>
  14 //#include <lwk/interrupt.h>
  15 #include <lwk/linux_compat.h>
  16
  17 /*
  18  * Generic declaration of the raw read_trylock() function,
  19  * architectures are supposed to optimize this:
  20  */
  21 int __lockfunc generic__raw_read_trylock(raw_rwlock_t *lock)
  22 {
  23         __raw_read_lock(lock);
  24         return 1;
  25 }
  26 EXPORT_SYMBOL(generic__raw_read_trylock);
  27
  28 int __lockfunc _spin_trylock(spinlock_t *lock)
  29 {
  30         if (_raw_spin_trylock(lock))
  31                 return 1;
  32         return 0;
  33 }
  34 EXPORT_SYMBOL(_spin_trylock);
  35
  36 int __lockfunc _read_trylock(rwlock_t *lock)
  37 {
  38         if (_raw_read_trylock(lock))
  39                 return 1;
  40         return 0;
  41 }
  42 EXPORT_SYMBOL(_read_trylock);
  43
  44 int __lockfunc _write_trylock(rwlock_t *lock)
  45 {
  46         if (_raw_write_trylock(lock))
  47                 return 1;
  48         return 0;
  49 }
  50 EXPORT_SYMBOL(_write_trylock);
  51
  52 void __lockfunc _read_lock(rwlock_t *lock)
  53 {
  54         _raw_read_lock(lock);
  55 }
  56 EXPORT_SYMBOL(_read_lock);
  57
  58 unsigned long __lockfunc _spin_lock_irqsave(spinlock_t *lock)
  59 {
  60         unsigned long flags;
  61
  62         local_irq_save(flags);
  63         _raw_spin_lock_flags(lock, &flags);
  64         return flags;
  65 }
  66 EXPORT_SYMBOL(_spin_lock_irqsave);
  67
  68 void __lockfunc _spin_lock_irq(spinlock_t *lock)
  69 {
  70         local_irq_disable();
  71         _raw_spin_lock(lock);
  72 }
  73 EXPORT_SYMBOL(_spin_lock_irq);
  74
  75 #if 0
  76 void __lockfunc _spin_lock_bh(spinlock_t *lock)
  77 {
  78         local_bh_disable();
  79         _raw_spin_lock(lock);
  80 }
  81 EXPORT_SYMBOL(_spin_lock_bh);
  82 #endif
  83
  84 unsigned long __lockfunc _read_lock_irqsave(rwlock_t *lock)
  85 {
  86         unsigned long flags;
  87
  88         local_irq_save(flags);
  89         _raw_read_lock(lock);
  90         return flags;
  91 }
  92 EXPORT_SYMBOL(_read_lock_irqsave);
  93
  94 void __lockfunc _read_lock_irq(rwlock_t *lock)
  95 {
  96         local_irq_disable();
  97         _raw_read_lock(lock);
  98 }
  99 EXPORT_SYMBOL(_read_lock_irq);
 100
 101 #if 0
 102 void __lockfunc _read_lock_bh(rwlock_t *lock)
 103 {
 104         local_bh_disable();
 105         _raw_read_lock(lock);
 106 }
 107 EXPORT_SYMBOL(_read_lock_bh);
 108 #endif
 109
 110 unsigned long __lockfunc _write_lock_irqsave(rwlock_t *lock)
 111 {
 112         unsigned long flags;
 113
 114         local_irq_save(flags);
 115         _raw_write_lock(lock);
 116         return flags;
 117 }
 118 EXPORT_SYMBOL(_write_lock_irqsave);
 119
 120 void __lockfunc _write_lock_irq(rwlock_t *lock)
 121 {
 122         local_irq_disable();
 123         _raw_write_lock(lock);
 124 }
 125 EXPORT_SYMBOL(_write_lock_irq);
 126
 127 #if 0
 128 void __lockfunc _write_lock_bh(rwlock_t *lock)
 129 {
 130         local_bh_disable();
 131         _raw_write_lock(lock);
 132 }
 133 EXPORT_SYMBOL(_write_lock_bh);
 134 #endif
 135
 136 void __lockfunc _spin_lock(spinlock_t *lock)
 137 {
 138         _raw_spin_lock(lock);
 139 }
 140
 141 EXPORT_SYMBOL(_spin_lock);
 142
 143 void __lockfunc _write_lock(rwlock_t *lock)
 144 {
 145         _raw_write_lock(lock);
 146 }
 147
 148 EXPORT_SYMBOL(_write_lock);
 149
 150 void __lockfunc _spin_unlock(spinlock_t *lock)
 151 {
 152         _raw_spin_unlock(lock);
 153 }
 154 EXPORT_SYMBOL(_spin_unlock);
 155
 156 void __lockfunc _write_unlock(rwlock_t *lock)
 157 {
 158         _raw_write_unlock(lock);
 159 }
 160 EXPORT_SYMBOL(_write_unlock);
 161
 162 void __lockfunc _read_unlock(rwlock_t *lock)
 163 {
 164         _raw_read_unlock(lock);
 165 }
 166 EXPORT_SYMBOL(_read_unlock);
 167
 168 void __lockfunc _spin_unlock_irqrestore(spinlock_t *lock, unsigned long flags)
 169 {
 170         _raw_spin_unlock(lock);
 171         local_irq_restore(flags);
 172 }
 173 EXPORT_SYMBOL(_spin_unlock_irqrestore);
 174
 175 void __lockfunc _spin_unlock_irq(spinlock_t *lock)
 176 {
 177         _raw_spin_unlock(lock);
 178         local_irq_enable();
 179 }
 180 EXPORT_SYMBOL(_spin_unlock_irq);
 181
 182 #if 0
 183 void __lockfunc _spin_unlock_bh(spinlock_t *lock)
 184 {
 185         _raw_spin_unlock(lock);
 186         local_bh_enable();
 187 }
 188 EXPORT_SYMBOL(_spin_unlock_bh);
 189 #endif
 190
 191 void __lockfunc _read_unlock_irqrestore(rwlock_t *lock, unsigned long flags)
 192 {
 193         _raw_read_unlock(lock);
 194         local_irq_restore(flags);
 195 }
 196 EXPORT_SYMBOL(_read_unlock_irqrestore);
 197
 198 void __lockfunc _read_unlock_irq(rwlock_t *lock)
 199 {
 200         _raw_read_unlock(lock);
 201         local_irq_enable();
 202 }
 203 EXPORT_SYMBOL(_read_unlock_irq);
 204
 205 #if 0
 206 void __lockfunc _read_unlock_bh(rwlock_t *lock)
 207 {
 208         _raw_read_unlock(lock);
 209         local_bh_enable();
 210 }
 211 EXPORT_SYMBOL(_read_unlock_bh);
 212 #endif
 213
 214 void __lockfunc _write_unlock_irqrestore(rwlock_t *lock, unsigned long flags)
 215 {
 216         _raw_write_unlock(lock);
 217         local_irq_restore(flags);
 218 }
 219 EXPORT_SYMBOL(_write_unlock_irqrestore);
 220
 221 void __lockfunc _write_unlock_irq(rwlock_t *lock)
 222 {
 223         _raw_write_unlock(lock);
 224         local_irq_enable();
 225 }
 226 EXPORT_SYMBOL(_write_unlock_irq);
 227
 228 #if 0
 229 void __lockfunc _write_unlock_bh(rwlock_t *lock)
 230 {
 231         _raw_write_unlock(lock);
 232         local_bh_enable();
 233 }
 234 EXPORT_SYMBOL(_write_unlock_bh);
 235 #endif
 236
 237 #if 0
 238 int __lockfunc _spin_trylock_bh(spinlock_t *lock)
 239 {
 240         local_bh_disable();
 241         if (_raw_spin_trylock(lock))
 242                 return 1;
 243         local_bh_enable();
 244         return 0;
 245 }
 246 EXPORT_SYMBOL(_spin_trylock_bh);
 247 #endif
 248
 249 int in_lock_functions(unsigned long addr)
 250 {
 251         /* Linker adds these: start and end of __lockfunc functions */
 252         extern char __lock_text_start[], __lock_text_end[];
 253
 254         return addr >= (unsigned long)__lock_text_start
 255         && addr < (unsigned long)__lock_text_end;
 256 }
 257 EXPORT_SYMBOL(in_lock_functions);