include/asm-generic/qrwlock.h

   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 */