H. Peter Anvin | 1965aae | 2008-10-22 22:26:29 -0700 | [diff] [blame] | 1 | #ifndef _ASM_X86_SPINLOCK_H |
| 2 | #define _ASM_X86_SPINLOCK_H |
Glauber de Oliveira Costa | 2fed0c5 | 2008-01-30 13:30:33 +0100 | [diff] [blame] | 3 | |
Arun Sharma | 60063497 | 2011-07-26 16:09:06 -0700 | [diff] [blame] | 4 | #include <linux/atomic.h> |
Thomas Gleixner | 1075cf7 | 2008-01-30 13:30:34 +0100 | [diff] [blame] | 5 | #include <asm/page.h> |
| 6 | #include <asm/processor.h> |
Nick Piggin | 314cdbe | 2008-01-30 13:31:21 +0100 | [diff] [blame] | 7 | #include <linux/compiler.h> |
Jeremy Fitzhardinge | 74d4aff | 2008-07-07 12:07:50 -0700 | [diff] [blame] | 8 | #include <asm/paravirt.h> |
Thomas Gleixner | 1075cf7 | 2008-01-30 13:30:34 +0100 | [diff] [blame] | 9 | /* |
| 10 | * Your basic SMP spinlocks, allowing only a single CPU anywhere |
| 11 | * |
| 12 | * Simple spin lock operations. There are two variants, one clears IRQ's |
| 13 | * on the local processor, one does not. |
| 14 | * |
Richard Weinberger | 83be4ff | 2012-08-14 14:47:37 -0700 | [diff] [blame] | 15 | * These are fair FIFO ticket locks, which support up to 2^16 CPUs. |
Thomas Gleixner | 1075cf7 | 2008-01-30 13:30:34 +0100 | [diff] [blame] | 16 | * |
| 17 | * (the type definitions are in asm/spinlock_types.h) |
| 18 | */ |
| 19 | |
Thomas Gleixner | 96a388d | 2007-10-11 11:20:03 +0200 | [diff] [blame] | 20 | #ifdef CONFIG_X86_32 |
Thomas Gleixner | 1075cf7 | 2008-01-30 13:30:34 +0100 | [diff] [blame] | 21 | # define LOCK_PTR_REG "a" |
Thomas Gleixner | 96a388d | 2007-10-11 11:20:03 +0200 | [diff] [blame] | 22 | #else |
Thomas Gleixner | 1075cf7 | 2008-01-30 13:30:34 +0100 | [diff] [blame] | 23 | # define LOCK_PTR_REG "D" |
Thomas Gleixner | 96a388d | 2007-10-11 11:20:03 +0200 | [diff] [blame] | 24 | #endif |
Glauber de Oliveira Costa | 2fed0c5 | 2008-01-30 13:30:33 +0100 | [diff] [blame] | 25 | |
Nick Piggin | 3a556b2 | 2008-01-30 13:33:00 +0100 | [diff] [blame] | 26 | #if defined(CONFIG_X86_32) && \ |
| 27 | (defined(CONFIG_X86_OOSTORE) || defined(CONFIG_X86_PPRO_FENCE)) |
| 28 | /* |
| 29 | * On PPro SMP or if we are using OOSTORE, we use a locked operation to unlock |
| 30 | * (PPro errata 66, 92) |
| 31 | */ |
| 32 | # define UNLOCK_LOCK_PREFIX LOCK_PREFIX |
| 33 | #else |
| 34 | # define UNLOCK_LOCK_PREFIX |
Nick Piggin | 314cdbe | 2008-01-30 13:31:21 +0100 | [diff] [blame] | 35 | #endif |
| 36 | |
Linus Torvalds | bc08b44 | 2013-09-02 12:12:15 -0700 | [diff] [blame^] | 37 | static __always_inline int arch_spin_value_unlocked(arch_spinlock_t lock) |
| 38 | { |
| 39 | return lock.tickets.head == lock.tickets.tail; |
| 40 | } |
| 41 | |
Nick Piggin | 3a556b2 | 2008-01-30 13:33:00 +0100 | [diff] [blame] | 42 | /* |
| 43 | * Ticket locks are conceptually two parts, one indicating the current head of |
| 44 | * the queue, and the other indicating the current tail. The lock is acquired |
| 45 | * by atomically noting the tail and incrementing it by one (thus adding |
| 46 | * ourself to the queue and noting our position), then waiting until the head |
| 47 | * becomes equal to the the initial value of the tail. |
| 48 | * |
| 49 | * We use an xadd covering *both* parts of the lock, to increment the tail and |
| 50 | * also load the position of the head, which takes care of memory ordering |
| 51 | * issues and should be optimal for the uncontended case. Note the tail must be |
| 52 | * in the high part, because a wide xadd increment of the low part would carry |
| 53 | * up and contaminate the high part. |
Nick Piggin | 3a556b2 | 2008-01-30 13:33:00 +0100 | [diff] [blame] | 54 | */ |
Thomas Gleixner | 445c895 | 2009-12-02 19:49:50 +0100 | [diff] [blame] | 55 | static __always_inline void __ticket_spin_lock(arch_spinlock_t *lock) |
Thomas Gleixner | 1075cf7 | 2008-01-30 13:30:34 +0100 | [diff] [blame] | 56 | { |
Jeremy Fitzhardinge | 2994488 | 2010-07-13 14:07:45 -0700 | [diff] [blame] | 57 | register struct __raw_tickets inc = { .tail = 1 }; |
Nick Piggin | 314cdbe | 2008-01-30 13:31:21 +0100 | [diff] [blame] | 58 | |
Jeremy Fitzhardinge | 2994488 | 2010-07-13 14:07:45 -0700 | [diff] [blame] | 59 | inc = xadd(&lock->tickets, inc); |
Jeremy Fitzhardinge | c576a3e | 2010-07-03 01:06:04 +0100 | [diff] [blame] | 60 | |
| 61 | for (;;) { |
Jeremy Fitzhardinge | 2994488 | 2010-07-13 14:07:45 -0700 | [diff] [blame] | 62 | if (inc.head == inc.tail) |
Jeremy Fitzhardinge | c576a3e | 2010-07-03 01:06:04 +0100 | [diff] [blame] | 63 | break; |
| 64 | cpu_relax(); |
Jeremy Fitzhardinge | 2994488 | 2010-07-13 14:07:45 -0700 | [diff] [blame] | 65 | inc.head = ACCESS_ONCE(lock->tickets.head); |
Jeremy Fitzhardinge | c576a3e | 2010-07-03 01:06:04 +0100 | [diff] [blame] | 66 | } |
| 67 | barrier(); /* make sure nothing creeps before the lock is taken */ |
Thomas Gleixner | 1075cf7 | 2008-01-30 13:30:34 +0100 | [diff] [blame] | 68 | } |
| 69 | |
Thomas Gleixner | 445c895 | 2009-12-02 19:49:50 +0100 | [diff] [blame] | 70 | static __always_inline int __ticket_spin_trylock(arch_spinlock_t *lock) |
Thomas Gleixner | 1075cf7 | 2008-01-30 13:30:34 +0100 | [diff] [blame] | 71 | { |
Jeremy Fitzhardinge | 229855d | 2010-07-13 15:14:26 -0700 | [diff] [blame] | 72 | arch_spinlock_t old, new; |
Thomas Gleixner | 1075cf7 | 2008-01-30 13:30:34 +0100 | [diff] [blame] | 73 | |
Jeremy Fitzhardinge | 229855d | 2010-07-13 15:14:26 -0700 | [diff] [blame] | 74 | old.tickets = ACCESS_ONCE(lock->tickets); |
| 75 | if (old.tickets.head != old.tickets.tail) |
| 76 | return 0; |
Thomas Gleixner | 1075cf7 | 2008-01-30 13:30:34 +0100 | [diff] [blame] | 77 | |
Jeremy Fitzhardinge | 229855d | 2010-07-13 15:14:26 -0700 | [diff] [blame] | 78 | new.head_tail = old.head_tail + (1 << TICKET_SHIFT); |
| 79 | |
| 80 | /* cmpxchg is a full barrier, so nothing can move before it */ |
| 81 | return cmpxchg(&lock->head_tail, old.head_tail, new.head_tail) == old.head_tail; |
Thomas Gleixner | 1075cf7 | 2008-01-30 13:30:34 +0100 | [diff] [blame] | 82 | } |
| 83 | |
Thomas Gleixner | 445c895 | 2009-12-02 19:49:50 +0100 | [diff] [blame] | 84 | static __always_inline void __ticket_spin_unlock(arch_spinlock_t *lock) |
Thomas Gleixner | 1075cf7 | 2008-01-30 13:30:34 +0100 | [diff] [blame] | 85 | { |
Jeremy Fitzhardinge | 3d94ae0 | 2011-09-28 11:49:28 -0700 | [diff] [blame] | 86 | __add(&lock->tickets.head, 1, UNLOCK_LOCK_PREFIX); |
Thomas Gleixner | 1075cf7 | 2008-01-30 13:30:34 +0100 | [diff] [blame] | 87 | } |
| 88 | |
Thomas Gleixner | 445c895 | 2009-12-02 19:49:50 +0100 | [diff] [blame] | 89 | static inline int __ticket_spin_is_locked(arch_spinlock_t *lock) |
Jan Beulich | 08f5fcb | 2008-09-05 13:26:39 +0100 | [diff] [blame] | 90 | { |
Jeremy Fitzhardinge | 84eb950 | 2010-07-02 23:26:36 +0100 | [diff] [blame] | 91 | struct __raw_tickets tmp = ACCESS_ONCE(lock->tickets); |
Jan Beulich | 08f5fcb | 2008-09-05 13:26:39 +0100 | [diff] [blame] | 92 | |
Jan Beulich | 7931d49 | 2012-02-03 15:06:26 +0000 | [diff] [blame] | 93 | return tmp.tail != tmp.head; |
Jan Beulich | 08f5fcb | 2008-09-05 13:26:39 +0100 | [diff] [blame] | 94 | } |
| 95 | |
Thomas Gleixner | 445c895 | 2009-12-02 19:49:50 +0100 | [diff] [blame] | 96 | static inline int __ticket_spin_is_contended(arch_spinlock_t *lock) |
Jan Beulich | 08f5fcb | 2008-09-05 13:26:39 +0100 | [diff] [blame] | 97 | { |
Jeremy Fitzhardinge | 84eb950 | 2010-07-02 23:26:36 +0100 | [diff] [blame] | 98 | struct __raw_tickets tmp = ACCESS_ONCE(lock->tickets); |
Jan Beulich | 08f5fcb | 2008-09-05 13:26:39 +0100 | [diff] [blame] | 99 | |
Jan Beulich | 7931d49 | 2012-02-03 15:06:26 +0000 | [diff] [blame] | 100 | return (__ticket_t)(tmp.tail - tmp.head) > 1; |
Jan Beulich | 08f5fcb | 2008-09-05 13:26:39 +0100 | [diff] [blame] | 101 | } |
Jeremy Fitzhardinge | 74d4aff | 2008-07-07 12:07:50 -0700 | [diff] [blame] | 102 | |
Jeremy Fitzhardinge | b4ecc12 | 2009-05-13 17:16:55 -0700 | [diff] [blame] | 103 | #ifndef CONFIG_PARAVIRT_SPINLOCKS |
Jeremy Fitzhardinge | 8efcbab | 2008-07-07 12:07:51 -0700 | [diff] [blame] | 104 | |
Thomas Gleixner | 0199c4e | 2009-12-02 20:01:25 +0100 | [diff] [blame] | 105 | static inline int arch_spin_is_locked(arch_spinlock_t *lock) |
Jeremy Fitzhardinge | 74d4aff | 2008-07-07 12:07:50 -0700 | [diff] [blame] | 106 | { |
| 107 | return __ticket_spin_is_locked(lock); |
| 108 | } |
| 109 | |
Thomas Gleixner | 0199c4e | 2009-12-02 20:01:25 +0100 | [diff] [blame] | 110 | static inline int arch_spin_is_contended(arch_spinlock_t *lock) |
Jeremy Fitzhardinge | 74d4aff | 2008-07-07 12:07:50 -0700 | [diff] [blame] | 111 | { |
| 112 | return __ticket_spin_is_contended(lock); |
| 113 | } |
Thomas Gleixner | 0199c4e | 2009-12-02 20:01:25 +0100 | [diff] [blame] | 114 | #define arch_spin_is_contended arch_spin_is_contended |
Jeremy Fitzhardinge | 74d4aff | 2008-07-07 12:07:50 -0700 | [diff] [blame] | 115 | |
Thomas Gleixner | 0199c4e | 2009-12-02 20:01:25 +0100 | [diff] [blame] | 116 | static __always_inline void arch_spin_lock(arch_spinlock_t *lock) |
Jeremy Fitzhardinge | 74d4aff | 2008-07-07 12:07:50 -0700 | [diff] [blame] | 117 | { |
| 118 | __ticket_spin_lock(lock); |
| 119 | } |
| 120 | |
Thomas Gleixner | 0199c4e | 2009-12-02 20:01:25 +0100 | [diff] [blame] | 121 | static __always_inline int arch_spin_trylock(arch_spinlock_t *lock) |
Jeremy Fitzhardinge | 74d4aff | 2008-07-07 12:07:50 -0700 | [diff] [blame] | 122 | { |
| 123 | return __ticket_spin_trylock(lock); |
| 124 | } |
| 125 | |
Thomas Gleixner | 0199c4e | 2009-12-02 20:01:25 +0100 | [diff] [blame] | 126 | static __always_inline void arch_spin_unlock(arch_spinlock_t *lock) |
Jeremy Fitzhardinge | 74d4aff | 2008-07-07 12:07:50 -0700 | [diff] [blame] | 127 | { |
| 128 | __ticket_spin_unlock(lock); |
| 129 | } |
Jeremy Fitzhardinge | 63d3a75 | 2008-08-19 13:19:36 -0700 | [diff] [blame] | 130 | |
Thomas Gleixner | 0199c4e | 2009-12-02 20:01:25 +0100 | [diff] [blame] | 131 | static __always_inline void arch_spin_lock_flags(arch_spinlock_t *lock, |
Jeremy Fitzhardinge | 63d3a75 | 2008-08-19 13:19:36 -0700 | [diff] [blame] | 132 | unsigned long flags) |
| 133 | { |
Thomas Gleixner | 0199c4e | 2009-12-02 20:01:25 +0100 | [diff] [blame] | 134 | arch_spin_lock(lock); |
Jeremy Fitzhardinge | 63d3a75 | 2008-08-19 13:19:36 -0700 | [diff] [blame] | 135 | } |
| 136 | |
Jeremy Fitzhardinge | b4ecc12 | 2009-05-13 17:16:55 -0700 | [diff] [blame] | 137 | #endif /* CONFIG_PARAVIRT_SPINLOCKS */ |
Jeremy Fitzhardinge | 74d4aff | 2008-07-07 12:07:50 -0700 | [diff] [blame] | 138 | |
Thomas Gleixner | 0199c4e | 2009-12-02 20:01:25 +0100 | [diff] [blame] | 139 | static inline void arch_spin_unlock_wait(arch_spinlock_t *lock) |
Thomas Gleixner | 1075cf7 | 2008-01-30 13:30:34 +0100 | [diff] [blame] | 140 | { |
Thomas Gleixner | 0199c4e | 2009-12-02 20:01:25 +0100 | [diff] [blame] | 141 | while (arch_spin_is_locked(lock)) |
Thomas Gleixner | 1075cf7 | 2008-01-30 13:30:34 +0100 | [diff] [blame] | 142 | cpu_relax(); |
| 143 | } |
| 144 | |
| 145 | /* |
| 146 | * Read-write spinlocks, allowing multiple readers |
| 147 | * but only one writer. |
| 148 | * |
| 149 | * NOTE! it is quite common to have readers in interrupts |
| 150 | * but no interrupt writers. For those circumstances we |
| 151 | * can "mix" irq-safe locks - any writer needs to get a |
| 152 | * irq-safe write-lock, but readers can get non-irqsafe |
| 153 | * read-locks. |
| 154 | * |
| 155 | * On x86, we implement read-write locks as a 32-bit counter |
| 156 | * with the high bit (sign) being the "contended" bit. |
| 157 | */ |
| 158 | |
Nick Piggin | 314cdbe | 2008-01-30 13:31:21 +0100 | [diff] [blame] | 159 | /** |
| 160 | * read_can_lock - would read_trylock() succeed? |
| 161 | * @lock: the rwlock in question. |
| 162 | */ |
Thomas Gleixner | e593194 | 2009-12-03 20:08:46 +0100 | [diff] [blame] | 163 | static inline int arch_read_can_lock(arch_rwlock_t *lock) |
Thomas Gleixner | 1075cf7 | 2008-01-30 13:30:34 +0100 | [diff] [blame] | 164 | { |
Jan Beulich | a750036 | 2011-07-19 13:00:45 +0100 | [diff] [blame] | 165 | return lock->lock > 0; |
Thomas Gleixner | 1075cf7 | 2008-01-30 13:30:34 +0100 | [diff] [blame] | 166 | } |
| 167 | |
Nick Piggin | 314cdbe | 2008-01-30 13:31:21 +0100 | [diff] [blame] | 168 | /** |
| 169 | * write_can_lock - would write_trylock() succeed? |
| 170 | * @lock: the rwlock in question. |
| 171 | */ |
Thomas Gleixner | e593194 | 2009-12-03 20:08:46 +0100 | [diff] [blame] | 172 | static inline int arch_write_can_lock(arch_rwlock_t *lock) |
Thomas Gleixner | 1075cf7 | 2008-01-30 13:30:34 +0100 | [diff] [blame] | 173 | { |
Jan Beulich | a750036 | 2011-07-19 13:00:45 +0100 | [diff] [blame] | 174 | return lock->write == WRITE_LOCK_CMP; |
Thomas Gleixner | 1075cf7 | 2008-01-30 13:30:34 +0100 | [diff] [blame] | 175 | } |
| 176 | |
Thomas Gleixner | e593194 | 2009-12-03 20:08:46 +0100 | [diff] [blame] | 177 | static inline void arch_read_lock(arch_rwlock_t *rw) |
Thomas Gleixner | 1075cf7 | 2008-01-30 13:30:34 +0100 | [diff] [blame] | 178 | { |
Jan Beulich | a750036 | 2011-07-19 13:00:45 +0100 | [diff] [blame] | 179 | asm volatile(LOCK_PREFIX READ_LOCK_SIZE(dec) " (%0)\n\t" |
Thomas Gleixner | 1075cf7 | 2008-01-30 13:30:34 +0100 | [diff] [blame] | 180 | "jns 1f\n" |
| 181 | "call __read_lock_failed\n\t" |
| 182 | "1:\n" |
| 183 | ::LOCK_PTR_REG (rw) : "memory"); |
| 184 | } |
| 185 | |
Thomas Gleixner | e593194 | 2009-12-03 20:08:46 +0100 | [diff] [blame] | 186 | static inline void arch_write_lock(arch_rwlock_t *rw) |
Thomas Gleixner | 1075cf7 | 2008-01-30 13:30:34 +0100 | [diff] [blame] | 187 | { |
Jan Beulich | a750036 | 2011-07-19 13:00:45 +0100 | [diff] [blame] | 188 | asm volatile(LOCK_PREFIX WRITE_LOCK_SUB(%1) "(%0)\n\t" |
Thomas Gleixner | 1075cf7 | 2008-01-30 13:30:34 +0100 | [diff] [blame] | 189 | "jz 1f\n" |
| 190 | "call __write_lock_failed\n\t" |
| 191 | "1:\n" |
Jan Beulich | a750036 | 2011-07-19 13:00:45 +0100 | [diff] [blame] | 192 | ::LOCK_PTR_REG (&rw->write), "i" (RW_LOCK_BIAS) |
| 193 | : "memory"); |
Thomas Gleixner | 1075cf7 | 2008-01-30 13:30:34 +0100 | [diff] [blame] | 194 | } |
| 195 | |
Thomas Gleixner | e593194 | 2009-12-03 20:08:46 +0100 | [diff] [blame] | 196 | static inline int arch_read_trylock(arch_rwlock_t *lock) |
Thomas Gleixner | 1075cf7 | 2008-01-30 13:30:34 +0100 | [diff] [blame] | 197 | { |
Jan Beulich | a750036 | 2011-07-19 13:00:45 +0100 | [diff] [blame] | 198 | READ_LOCK_ATOMIC(t) *count = (READ_LOCK_ATOMIC(t) *)lock; |
Thomas Gleixner | 1075cf7 | 2008-01-30 13:30:34 +0100 | [diff] [blame] | 199 | |
Jan Beulich | a750036 | 2011-07-19 13:00:45 +0100 | [diff] [blame] | 200 | if (READ_LOCK_ATOMIC(dec_return)(count) >= 0) |
Thomas Gleixner | 1075cf7 | 2008-01-30 13:30:34 +0100 | [diff] [blame] | 201 | return 1; |
Jan Beulich | a750036 | 2011-07-19 13:00:45 +0100 | [diff] [blame] | 202 | READ_LOCK_ATOMIC(inc)(count); |
Thomas Gleixner | 1075cf7 | 2008-01-30 13:30:34 +0100 | [diff] [blame] | 203 | return 0; |
| 204 | } |
| 205 | |
Thomas Gleixner | e593194 | 2009-12-03 20:08:46 +0100 | [diff] [blame] | 206 | static inline int arch_write_trylock(arch_rwlock_t *lock) |
Thomas Gleixner | 1075cf7 | 2008-01-30 13:30:34 +0100 | [diff] [blame] | 207 | { |
Jan Beulich | a750036 | 2011-07-19 13:00:45 +0100 | [diff] [blame] | 208 | atomic_t *count = (atomic_t *)&lock->write; |
Thomas Gleixner | 1075cf7 | 2008-01-30 13:30:34 +0100 | [diff] [blame] | 209 | |
Jan Beulich | a750036 | 2011-07-19 13:00:45 +0100 | [diff] [blame] | 210 | if (atomic_sub_and_test(WRITE_LOCK_CMP, count)) |
Thomas Gleixner | 1075cf7 | 2008-01-30 13:30:34 +0100 | [diff] [blame] | 211 | return 1; |
Jan Beulich | a750036 | 2011-07-19 13:00:45 +0100 | [diff] [blame] | 212 | atomic_add(WRITE_LOCK_CMP, count); |
Thomas Gleixner | 1075cf7 | 2008-01-30 13:30:34 +0100 | [diff] [blame] | 213 | return 0; |
| 214 | } |
| 215 | |
Thomas Gleixner | e593194 | 2009-12-03 20:08:46 +0100 | [diff] [blame] | 216 | static inline void arch_read_unlock(arch_rwlock_t *rw) |
Thomas Gleixner | 1075cf7 | 2008-01-30 13:30:34 +0100 | [diff] [blame] | 217 | { |
Jan Beulich | a750036 | 2011-07-19 13:00:45 +0100 | [diff] [blame] | 218 | asm volatile(LOCK_PREFIX READ_LOCK_SIZE(inc) " %0" |
| 219 | :"+m" (rw->lock) : : "memory"); |
Thomas Gleixner | 1075cf7 | 2008-01-30 13:30:34 +0100 | [diff] [blame] | 220 | } |
| 221 | |
Thomas Gleixner | e593194 | 2009-12-03 20:08:46 +0100 | [diff] [blame] | 222 | static inline void arch_write_unlock(arch_rwlock_t *rw) |
Thomas Gleixner | 1075cf7 | 2008-01-30 13:30:34 +0100 | [diff] [blame] | 223 | { |
Jan Beulich | a750036 | 2011-07-19 13:00:45 +0100 | [diff] [blame] | 224 | asm volatile(LOCK_PREFIX WRITE_LOCK_ADD(%1) "%0" |
| 225 | : "+m" (rw->write) : "i" (RW_LOCK_BIAS) : "memory"); |
Thomas Gleixner | 1075cf7 | 2008-01-30 13:30:34 +0100 | [diff] [blame] | 226 | } |
| 227 | |
Thomas Gleixner | e593194 | 2009-12-03 20:08:46 +0100 | [diff] [blame] | 228 | #define arch_read_lock_flags(lock, flags) arch_read_lock(lock) |
| 229 | #define arch_write_lock_flags(lock, flags) arch_write_lock(lock) |
Robin Holt | f5f7eac | 2009-04-02 16:59:46 -0700 | [diff] [blame] | 230 | |
Jan Beulich | a750036 | 2011-07-19 13:00:45 +0100 | [diff] [blame] | 231 | #undef READ_LOCK_SIZE |
| 232 | #undef READ_LOCK_ATOMIC |
| 233 | #undef WRITE_LOCK_ADD |
| 234 | #undef WRITE_LOCK_SUB |
| 235 | #undef WRITE_LOCK_CMP |
| 236 | |
Thomas Gleixner | 0199c4e | 2009-12-02 20:01:25 +0100 | [diff] [blame] | 237 | #define arch_spin_relax(lock) cpu_relax() |
| 238 | #define arch_read_relax(lock) cpu_relax() |
| 239 | #define arch_write_relax(lock) cpu_relax() |
Thomas Gleixner | 1075cf7 | 2008-01-30 13:30:34 +0100 | [diff] [blame] | 240 | |
H. Peter Anvin | 1965aae | 2008-10-22 22:26:29 -0700 | [diff] [blame] | 241 | #endif /* _ASM_X86_SPINLOCK_H */ |