1 /* SPDX-License-Identifier: GPL-2.0 */ 2 #ifndef _ASM_GENERIC_BITOPS_LOCK_H_ 3 #define _ASM_GENERIC_BITOPS_LOCK_H_ 4 5 #include <linux/atomic.h> 6 #include <linux/compiler.h> 7 #include <asm/barrier.h> 8 9 /** 10 * test_and_set_bit_lock - Set a bit and return its old value, for lock 11 * @nr: Bit to set 12 * @addr: Address to count from 13 * 14 * This operation is atomic and provides acquire barrier semantics if 15 * the returned value is 0. 16 * It can be used to implement bit locks. 17 */ 18 static inline int test_and_set_bit_lock(unsigned int nr, 19 volatile unsigned long *p) 20 { 21 long old; 22 unsigned long mask = BIT_MASK(nr); 23 24 p += BIT_WORD(nr); 25 if (READ_ONCE(*p) & mask) 26 return 1; 27 28 old = atomic_long_fetch_or_acquire(mask, (atomic_long_t *)p); 29 return !!(old & mask); 30 } 31 32 33 /** 34 * clear_bit_unlock - Clear a bit in memory, for unlock 35 * @nr: the bit to set 36 * @addr: the address to start counting from 37 * 38 * This operation is atomic and provides release barrier semantics. 39 */ 40 static inline void clear_bit_unlock(unsigned int nr, volatile unsigned long *p) 41 { 42 p += BIT_WORD(nr); 43 atomic_long_fetch_andnot_release(BIT_MASK(nr), (atomic_long_t *)p); 44 } 45 46 /** 47 * __clear_bit_unlock - Clear a bit in memory, for unlock 48 * @nr: the bit to set 49 * @addr: the address to start counting from 50 * 51 * A weaker form of clear_bit_unlock() as used by __bit_lock_unlock(). If all 52 * the bits in the word are protected by this lock some archs can use weaker 53 * ops to safely unlock. 54 * 55 * See for example x86's implementation. 56 */ 57 static inline void __clear_bit_unlock(unsigned int nr, 58 volatile unsigned long *p) 59 { 60 unsigned long old; 61 62 p += BIT_WORD(nr); 63 old = READ_ONCE(*p); 64 old &= ~BIT_MASK(nr); 65 atomic_long_set_release((atomic_long_t *)p, old); 66 } 67 68 /** 69 * clear_bit_unlock_is_negative_byte - Clear a bit in memory and test if bottom 70 * byte is negative, for unlock. 71 * @nr: the bit to clear 72 * @addr: the address to start counting from 73 * 74 * This is a bit of a one-trick-pony for the filemap code, which clears 75 * PG_locked and tests PG_waiters, 76 */ 77 #ifndef clear_bit_unlock_is_negative_byte 78 static inline bool clear_bit_unlock_is_negative_byte(unsigned int nr, 79 volatile unsigned long *p) 80 { 81 long old; 82 unsigned long mask = BIT_MASK(nr); 83 84 p += BIT_WORD(nr); 85 old = atomic_long_fetch_andnot_release(mask, (atomic_long_t *)p); 86 return !!(old & BIT(7)); 87 } 88 #define clear_bit_unlock_is_negative_byte clear_bit_unlock_is_negative_byte 89 #endif 90 91 #endif /* _ASM_GENERIC_BITOPS_LOCK_H_ */ 92