1 /* 2 * Queue read/write lock 3 * 4 * This program is free software; you can redistribute it and/or modify 5 * it under the terms of the GNU General Public License as published by 6 * the Free Software Foundation; either version 2 of the License, or 7 * (at your option) any later version. 8 * 9 * This program is distributed in the hope that it will be useful, 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 * GNU General Public License for more details. 13 * 14 * (C) Copyright 2013-2014 Hewlett-Packard Development Company, L.P. 15 * 16 * Authors: Waiman Long <waiman.long@hp.com> 17 */ 18 #ifndef __ASM_GENERIC_QRWLOCK_H 19 #define __ASM_GENERIC_QRWLOCK_H 20 21 #include <linux/atomic.h> 22 #include <asm/barrier.h> 23 #include <asm/processor.h> 24 25 #include <asm-generic/qrwlock_types.h> 26 27 /* 28 * Writer states & reader shift and bias. 29 * 30 * | +0 | +1 | +2 | +3 | 31 * ----+----+----+----+----+ 32 * LE | 78 | 56 | 34 | 12 | 0x12345678 33 * ----+----+----+----+----+ 34 * | wr | rd | 35 * +----+----+----+----+ 36 * 37 * ----+----+----+----+----+ 38 * BE | 12 | 34 | 56 | 78 | 0x12345678 39 * ----+----+----+----+----+ 40 * | rd | wr | 41 * +----+----+----+----+ 42 */ 43 #define _QW_WAITING 1 /* A writer is waiting */ 44 #define _QW_LOCKED 0xff /* A writer holds the lock */ 45 #define _QW_WMASK 0xff /* Writer mask */ 46 #define _QR_SHIFT 8 /* Reader count shift */ 47 #define _QR_BIAS (1U << _QR_SHIFT) 48 49 /* 50 * External function declarations 51 */ 52 extern void queued_read_lock_slowpath(struct qrwlock *lock, u32 cnts); 53 extern void queued_write_lock_slowpath(struct qrwlock *lock); 54 55 /** 56 * queued_read_can_lock- would read_trylock() succeed? 57 * @lock: Pointer to queue rwlock structure 58 */ 59 static inline int queued_read_can_lock(struct qrwlock *lock) 60 { 61 return !(atomic_read(&lock->cnts) & _QW_WMASK); 62 } 63 64 /** 65 * queued_write_can_lock- would write_trylock() succeed? 66 * @lock: Pointer to queue rwlock structure 67 */ 68 static inline int queued_write_can_lock(struct qrwlock *lock) 69 { 70 return !atomic_read(&lock->cnts); 71 } 72 73 /** 74 * queued_read_trylock - try to acquire read lock of a queue rwlock 75 * @lock : Pointer to queue rwlock structure 76 * Return: 1 if lock acquired, 0 if failed 77 */ 78 static inline int queued_read_trylock(struct qrwlock *lock) 79 { 80 u32 cnts; 81 82 cnts = atomic_read(&lock->cnts); 83 if (likely(!(cnts & _QW_WMASK))) { 84 cnts = (u32)atomic_add_return_acquire(_QR_BIAS, &lock->cnts); 85 if (likely(!(cnts & _QW_WMASK))) 86 return 1; 87 atomic_sub(_QR_BIAS, &lock->cnts); 88 } 89 return 0; 90 } 91 92 /** 93 * queued_write_trylock - try to acquire write lock of a queue rwlock 94 * @lock : Pointer to queue rwlock structure 95 * Return: 1 if lock acquired, 0 if failed 96 */ 97 static inline int queued_write_trylock(struct qrwlock *lock) 98 { 99 u32 cnts; 100 101 cnts = atomic_read(&lock->cnts); 102 if (unlikely(cnts)) 103 return 0; 104 105 return likely(atomic_cmpxchg_acquire(&lock->cnts, 106 cnts, cnts | _QW_LOCKED) == cnts); 107 } 108 /** 109 * queued_read_lock - acquire read lock of a queue rwlock 110 * @lock: Pointer to queue rwlock structure 111 */ 112 static inline void queued_read_lock(struct qrwlock *lock) 113 { 114 u32 cnts; 115 116 cnts = atomic_add_return_acquire(_QR_BIAS, &lock->cnts); 117 if (likely(!(cnts & _QW_WMASK))) 118 return; 119 120 /* The slowpath will decrement the reader count, if necessary. */ 121 queued_read_lock_slowpath(lock, cnts); 122 } 123 124 /** 125 * queued_write_lock - acquire write lock of a queue rwlock 126 * @lock : Pointer to queue rwlock structure 127 */ 128 static inline void queued_write_lock(struct qrwlock *lock) 129 { 130 /* Optimize for the unfair lock case where the fair flag is 0. */ 131 if (atomic_cmpxchg_acquire(&lock->cnts, 0, _QW_LOCKED) == 0) 132 return; 133 134 queued_write_lock_slowpath(lock); 135 } 136 137 /** 138 * queued_read_unlock - release read lock of a queue rwlock 139 * @lock : Pointer to queue rwlock structure 140 */ 141 static inline void queued_read_unlock(struct qrwlock *lock) 142 { 143 /* 144 * Atomically decrement the reader count 145 */ 146 (void)atomic_sub_return_release(_QR_BIAS, &lock->cnts); 147 } 148 149 /** 150 * __qrwlock_write_byte - retrieve the write byte address of a queue rwlock 151 * @lock : Pointer to queue rwlock structure 152 * Return: the write byte address of a queue rwlock 153 */ 154 static inline u8 *__qrwlock_write_byte(struct qrwlock *lock) 155 { 156 return (u8 *)lock + 3 * IS_BUILTIN(CONFIG_CPU_BIG_ENDIAN); 157 } 158 159 /** 160 * queued_write_unlock - release write lock of a queue rwlock 161 * @lock : Pointer to queue rwlock structure 162 */ 163 static inline void queued_write_unlock(struct qrwlock *lock) 164 { 165 smp_store_release(__qrwlock_write_byte(lock), 0); 166 } 167 168 /* 169 * Remapping rwlock architecture specific functions to the corresponding 170 * queue rwlock functions. 171 */ 172 #define arch_read_can_lock(l) queued_read_can_lock(l) 173 #define arch_write_can_lock(l) queued_write_can_lock(l) 174 #define arch_read_lock(l) queued_read_lock(l) 175 #define arch_write_lock(l) queued_write_lock(l) 176 #define arch_read_trylock(l) queued_read_trylock(l) 177 #define arch_write_trylock(l) queued_write_trylock(l) 178 #define arch_read_unlock(l) queued_read_unlock(l) 179 #define arch_write_unlock(l) queued_write_unlock(l) 180 181 #endif /* __ASM_GENERIC_QRWLOCK_H */ 182