fs/aufs/rwsem.h

   1 /*
   2  * Copyright (C) 2005-2017 Junjiro R. Okajima
   3  *
   4  * This program, aufs 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  * You should have received a copy of the GNU General Public License
  15  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 /*
  19  * simple read-write semaphore wrappers
  20  */
  21
  22 #ifndef __AUFS_RWSEM_H__
  23 #define __AUFS_RWSEM_H__
  24
  25 #ifdef __KERNEL__
  26
  27 #include "debug.h"
  28
  29 struct au_rwsem {
  30         struct rw_semaphore     rwsem;
  31 #ifdef CONFIG_AUFS_DEBUG
  32         /* just for debugging, not almighty counter */
  33         atomic_t                rcnt, wcnt;
  34 #endif
  35 };
  36
  37 #ifdef CONFIG_LOCKDEP
  38 #define au_lockdep_set_name(rw)                                         \
  39         lockdep_set_class_and_name(&(rw)->rwsem,                        \
  40                                    /*original key*/(rw)->rwsem.dep_map.key, \
  41                                    /*name*/#rw)
  42 #else
  43 #define au_lockdep_set_name(rw) do {} while (0)
  44 #endif
  45
  46 #ifdef CONFIG_AUFS_DEBUG
  47 #define AuDbgCntInit(rw) do { \
  48         atomic_set(&(rw)->rcnt, 0); \
  49         atomic_set(&(rw)->wcnt, 0); \
  50         smp_mb(); /* atomic set */ \
  51 } while (0)
  52
  53 #define AuDbgCnt(rw, cnt)       atomic_read(&(rw)->cnt)
  54 #define AuDbgCntInc(rw, cnt)    atomic_inc(&(rw)->cnt)
  55 #define AuDbgCntDec(rw, cnt)    WARN_ON(atomic_dec_return(&(rw)->cnt) < 0)
  56 #define AuDbgRcntInc(rw)        AuDbgCntInc(rw, rcnt)
  57 #define AuDbgRcntDec(rw)        AuDbgCntDec(rw, rcnt)
  58 #define AuDbgWcntInc(rw)        AuDbgCntInc(rw, wcnt)
  59 #define AuDbgWcntDec(rw)        AuDbgCntDec(rw, wcnt)
  60 #else
  61 #define AuDbgCnt(rw, cnt)       0
  62 #define AuDbgCntInit(rw)        do {} while (0)
  63 #define AuDbgRcntInc(rw)        do {} while (0)
  64 #define AuDbgRcntDec(rw)        do {} while (0)
  65 #define AuDbgWcntInc(rw)        do {} while (0)
  66 #define AuDbgWcntDec(rw)        do {} while (0)
  67 #endif /* CONFIG_AUFS_DEBUG */
  68
  69 /* to debug easier, do not make them inlined functions */
  70 #define AuRwMustNoWaiters(rw)   AuDebugOn(rwsem_is_contended(&(rw)->rwsem))
  71 /* rwsem_is_locked() is unusable */
  72 #define AuRwMustReadLock(rw)    AuDebugOn(AuDbgCnt(rw, rcnt) <= 0)
  73 #define AuRwMustWriteLock(rw)   AuDebugOn(AuDbgCnt(rw, wcnt) <= 0)
  74 #define AuRwMustAnyLock(rw)     AuDebugOn(AuDbgCnt(rw, rcnt) <= 0       \
  75                                           && AuDbgCnt(rw, wcnt) <= 0)
  76 #define AuRwDestroy(rw)         AuDebugOn(AuDbgCnt(rw, rcnt)            \
  77                                           || AuDbgCnt(rw, wcnt))
  78
  79 #define au_rw_init(rw) do {                     \
  80                 AuDbgCntInit(rw);               \
  81                 init_rwsem(&(rw)->rwsem);       \
  82                 au_lockdep_set_name(rw);        \
  83         } while (0)
  84
  85 #define au_rw_init_wlock(rw) do {               \
  86                 au_rw_init(rw);                 \
  87                 down_write(&(rw)->rwsem);       \
  88                 AuDbgWcntInc(rw);               \
  89         } while (0)
  90
  91 #define au_rw_init_wlock_nested(rw, lsc) do { \
  92                 au_rw_init(rw);                         \
  93                 down_write_nested(&(rw)->rwsem, lsc);   \
  94                 AuDbgWcntInc(rw);                       \
  95         } while (0)
  96
  97 static inline void au_rw_read_lock(struct au_rwsem *rw)
  98 {
  99         down_read(&rw->rwsem);
 100         AuDbgRcntInc(rw);
 101 }
 102
 103 static inline void au_rw_read_lock_nested(struct au_rwsem *rw, unsigned int lsc)
 104 {
 105         down_read_nested(&rw->rwsem, lsc);
 106         AuDbgRcntInc(rw);
 107 }
 108
 109 static inline void au_rw_read_unlock(struct au_rwsem *rw)
 110 {
 111         AuRwMustReadLock(rw);
 112         AuDbgRcntDec(rw);
 113         up_read(&rw->rwsem);
 114 }
 115
 116 static inline void au_rw_dgrade_lock(struct au_rwsem *rw)
 117 {
 118         AuRwMustWriteLock(rw);
 119         AuDbgRcntInc(rw);
 120         AuDbgWcntDec(rw);
 121         downgrade_write(&rw->rwsem);
 122 }
 123
 124 static inline void au_rw_write_lock(struct au_rwsem *rw)
 125 {
 126         down_write(&rw->rwsem);
 127         AuDbgWcntInc(rw);
 128 }
 129
 130 static inline void au_rw_write_lock_nested(struct au_rwsem *rw,
 131                                            unsigned int lsc)
 132 {
 133         down_write_nested(&rw->rwsem, lsc);
 134         AuDbgWcntInc(rw);
 135 }
 136
 137 static inline void au_rw_write_unlock(struct au_rwsem *rw)
 138 {
 139         AuRwMustWriteLock(rw);
 140         AuDbgWcntDec(rw);
 141         up_write(&rw->rwsem);
 142 }
 143
 144 /* why is not _nested version defined */
 145 static inline int au_rw_read_trylock(struct au_rwsem *rw)
 146 {
 147         int ret;
 148
 149         ret = down_read_trylock(&rw->rwsem);
 150         if (ret)
 151                 AuDbgRcntInc(rw);
 152         return ret;
 153 }
 154
 155 static inline int au_rw_write_trylock(struct au_rwsem *rw)
 156 {
 157         int ret;
 158
 159         ret = down_write_trylock(&rw->rwsem);
 160         if (ret)
 161                 AuDbgWcntInc(rw);
 162         return ret;
 163 }
 164
 165 #undef AuDbgCntDec
 166 #undef AuDbgRcntInc
 167 #undef AuDbgRcntDec
 168 #undef AuDbgWcntDec
 169
 170 #define AuSimpleLockRwsemFuncs(prefix, param, rwsem) \
 171 static inline void prefix##_read_lock(param) \
 172 { au_rw_read_lock(rwsem); } \
 173 static inline void prefix##_write_lock(param) \
 174 { au_rw_write_lock(rwsem); } \
 175 static inline int prefix##_read_trylock(param) \
 176 { return au_rw_read_trylock(rwsem); } \
 177 static inline int prefix##_write_trylock(param) \
 178 { return au_rw_write_trylock(rwsem); }
 179 /* why is not _nested version defined */
 180 /* static inline void prefix##_read_trylock_nested(param, lsc)
 181 { au_rw_read_trylock_nested(rwsem, lsc)); }
 182 static inline void prefix##_write_trylock_nestd(param, lsc)
 183 { au_rw_write_trylock_nested(rwsem, lsc); } */
 184
 185 #define AuSimpleUnlockRwsemFuncs(prefix, param, rwsem) \
 186 static inline void prefix##_read_unlock(param) \
 187 { au_rw_read_unlock(rwsem); } \
 188 static inline void prefix##_write_unlock(param) \
 189 { au_rw_write_unlock(rwsem); } \
 190 static inline void prefix##_downgrade_lock(param) \
 191 { au_rw_dgrade_lock(rwsem); }
 192
 193 #define AuSimpleRwsemFuncs(prefix, param, rwsem) \
 194         AuSimpleLockRwsemFuncs(prefix, param, rwsem) \
 195         AuSimpleUnlockRwsemFuncs(prefix, param, rwsem)
 196
 197 #endif /* __KERNEL__ */
 198 #endif /* __AUFS_RWSEM_H__ */