1/*
 2 * The owner field of the rw_semaphore structure will be set to
 3 * RWSEM_READ_OWNED when a reader grabs the lock. A writer will clear
 4 * the owner field when it unlocks. A reader, on the other hand, will
 5 * not touch the owner field when it unlocks.
 6 *
 7 * In essence, the owner field now has the following 3 states:
 8 *  1) 0
 9 *     - lock is free or the owner hasn't set the field yet
10 *  2) RWSEM_READER_OWNED
11 *     - lock is currently or previously owned by readers (lock is free
12 *       or not set by owner yet)
13 *  3) Other non-zero value
14 *     - a writer owns the lock
 
 
 
15 */
16#define RWSEM_READER_OWNED	((struct task_struct *)1UL)
 
 
 
 
 
 
 
17
18#ifdef CONFIG_RWSEM_SPIN_ON_OWNER
19/*
20 * All writes to owner are protected by WRITE_ONCE() to make sure that
21 * store tearing can't happen as optimistic spinners may read and use
22 * the owner value concurrently without lock. Read from owner, however,
23 * may not need READ_ONCE() as long as the pointer value is only used
24 * for comparison and isn't being dereferenced.
25 */
26static inline void rwsem_set_owner(struct rw_semaphore *sem)
27{
28	WRITE_ONCE(sem->owner, current);
29}
30
31static inline void rwsem_clear_owner(struct rw_semaphore *sem)
32{
33	WRITE_ONCE(sem->owner, NULL);
34}
35
36static inline void rwsem_set_reader_owned(struct rw_semaphore *sem)
37{
38	/*
39	 * We check the owner value first to make sure that we will only
40	 * do a write to the rwsem cacheline when it is really necessary
41	 * to minimize cacheline contention.
42	 */
43	if (sem->owner != RWSEM_READER_OWNED)
44		WRITE_ONCE(sem->owner, RWSEM_READER_OWNED);
45}
46
47static inline bool rwsem_owner_is_writer(struct task_struct *owner)
 
 
 
 
 
48{
49	return owner && owner != RWSEM_READER_OWNED;
50}
51
52static inline bool rwsem_owner_is_reader(struct task_struct *owner)
 
 
 
53{
54	return owner == RWSEM_READER_OWNED;
55}
56#else
57static inline void rwsem_set_owner(struct rw_semaphore *sem)
58{
59}
60
61static inline void rwsem_clear_owner(struct rw_semaphore *sem)
62{
63}
64
65static inline void rwsem_set_reader_owned(struct rw_semaphore *sem)
66{
67}
68#endif

 1/* SPDX-License-Identifier: GPL-2.0 */
 2/*
 3 * The owner field of the rw_semaphore structure will be set to
 4 * RWSEM_READER_OWNED when a reader grabs the lock. A writer will clear
 5 * the owner field when it unlocks. A reader, on the other hand, will
 6 * not touch the owner field when it unlocks.
 7 *
 8 * In essence, the owner field now has the following 4 states:
 9 *  1) 0
10 *     - lock is free or the owner hasn't set the field yet
11 *  2) RWSEM_READER_OWNED
12 *     - lock is currently or previously owned by readers (lock is free
13 *       or not set by owner yet)
14 *  3) RWSEM_ANONYMOUSLY_OWNED bit set with some other bits set as well
15 *     - lock is owned by an anonymous writer, so spinning on the lock
16 *       owner should be disabled.
17 *  4) Other non-zero value
18 *     - a writer owns the lock and other writers can spin on the lock owner.
19 */
20#define RWSEM_ANONYMOUSLY_OWNED	(1UL << 0)
21#define RWSEM_READER_OWNED	((struct task_struct *)RWSEM_ANONYMOUSLY_OWNED)
22
23#ifdef CONFIG_DEBUG_RWSEMS
24# define DEBUG_RWSEMS_WARN_ON(c)	DEBUG_LOCKS_WARN_ON(c)
25#else
26# define DEBUG_RWSEMS_WARN_ON(c)
27#endif
28
29#ifdef CONFIG_RWSEM_SPIN_ON_OWNER
30/*
31 * All writes to owner are protected by WRITE_ONCE() to make sure that
32 * store tearing can't happen as optimistic spinners may read and use
33 * the owner value concurrently without lock. Read from owner, however,
34 * may not need READ_ONCE() as long as the pointer value is only used
35 * for comparison and isn't being dereferenced.
36 */
37static inline void rwsem_set_owner(struct rw_semaphore *sem)
38{
39	WRITE_ONCE(sem->owner, current);
40}
41
42static inline void rwsem_clear_owner(struct rw_semaphore *sem)
43{
44	WRITE_ONCE(sem->owner, NULL);
45}
46
47static inline void rwsem_set_reader_owned(struct rw_semaphore *sem)
48{
49	/*
50	 * We check the owner value first to make sure that we will only
51	 * do a write to the rwsem cacheline when it is really necessary
52	 * to minimize cacheline contention.
53	 */
54	if (READ_ONCE(sem->owner) != RWSEM_READER_OWNED)
55		WRITE_ONCE(sem->owner, RWSEM_READER_OWNED);
56}
57
58/*
59 * Return true if the a rwsem waiter can spin on the rwsem's owner
60 * and steal the lock, i.e. the lock is not anonymously owned.
61 * N.B. !owner is considered spinnable.
62 */
63static inline bool is_rwsem_owner_spinnable(struct task_struct *owner)
64{
65	return !((unsigned long)owner & RWSEM_ANONYMOUSLY_OWNED);
66}
67
68/*
69 * Return true if rwsem is owned by an anonymous writer or readers.
70 */
71static inline bool rwsem_has_anonymous_owner(struct task_struct *owner)
72{
73	return (unsigned long)owner & RWSEM_ANONYMOUSLY_OWNED;
74}
75#else
76static inline void rwsem_set_owner(struct rw_semaphore *sem)
77{
78}
79
80static inline void rwsem_clear_owner(struct rw_semaphore *sem)
81{
82}
83
84static inline void rwsem_set_reader_owned(struct rw_semaphore *sem)
85{
86}
87#endif