kernel/locking/rwsem.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* kernel/rwsem.c: R/W semaphores, public implementation
   3  *
   4  * Written by David Howells (dhowells@redhat.com).
   5  * Derived from asm-i386/semaphore.h
   6  */
   7
   8 #include <linux/types.h>
   9 #include <linux/kernel.h>
  10 #include <linux/sched.h>
  11 #include <linux/sched/debug.h>
  12 #include <linux/export.h>
  13 #include <linux/rwsem.h>
  14 #include <linux/atomic.h>
  15
  16 #include "rwsem.h"
  17
  18 /*
  19  * lock for reading
  20  */
  21 void __sched down_read(struct rw_semaphore *sem)
  22 {
  23         might_sleep();
  24         rwsem_acquire_read(&sem->dep_map, 0, 0, _RET_IP_);
  25
  26         LOCK_CONTENDED(sem, __down_read_trylock, __down_read);
  27 }
  28
  29 EXPORT_SYMBOL(down_read);
  30
  31 int __sched down_read_killable(struct rw_semaphore *sem)
  32 {
  33         might_sleep();
  34         rwsem_acquire_read(&sem->dep_map, 0, 0, _RET_IP_);
  35
  36         if (LOCK_CONTENDED_RETURN(sem, __down_read_trylock, __down_read_killable)) {
  37                 rwsem_release(&sem->dep_map, 1, _RET_IP_);
  38                 return -EINTR;
  39         }
  40
  41         return 0;
  42 }
  43
  44 EXPORT_SYMBOL(down_read_killable);
  45
  46 /*
  47  * trylock for reading -- returns 1 if successful, 0 if contention
  48  */
  49 int down_read_trylock(struct rw_semaphore *sem)
  50 {
  51         int ret = __down_read_trylock(sem);
  52
  53         if (ret == 1)
  54                 rwsem_acquire_read(&sem->dep_map, 0, 1, _RET_IP_);
  55         return ret;
  56 }
  57
  58 EXPORT_SYMBOL(down_read_trylock);
  59
  60 /*
  61  * lock for writing
  62  */
  63 void __sched down_write(struct rw_semaphore *sem)
  64 {
  65         might_sleep();
  66         rwsem_acquire(&sem->dep_map, 0, 0, _RET_IP_);
  67
  68         LOCK_CONTENDED(sem, __down_write_trylock, __down_write);
  69 }
  70
  71 EXPORT_SYMBOL(down_write);
  72
  73 /*
  74  * lock for writing
  75  */
  76 int __sched down_write_killable(struct rw_semaphore *sem)
  77 {
  78         might_sleep();
  79         rwsem_acquire(&sem->dep_map, 0, 0, _RET_IP_);
  80
  81         if (LOCK_CONTENDED_RETURN(sem, __down_write_trylock, __down_write_killable)) {
  82                 rwsem_release(&sem->dep_map, 1, _RET_IP_);
  83                 return -EINTR;
  84         }
  85
  86         return 0;
  87 }
  88
  89 EXPORT_SYMBOL(down_write_killable);
  90
  91 /*
  92  * trylock for writing -- returns 1 if successful, 0 if contention
  93  */
  94 int down_write_trylock(struct rw_semaphore *sem)
  95 {
  96         int ret = __down_write_trylock(sem);
  97
  98         if (ret == 1)
  99                 rwsem_acquire(&sem->dep_map, 0, 1, _RET_IP_);
 100
 101         return ret;
 102 }
 103
 104 EXPORT_SYMBOL(down_write_trylock);
 105
 106 /*
 107  * release a read lock
 108  */
 109 void up_read(struct rw_semaphore *sem)
 110 {
 111         rwsem_release(&sem->dep_map, 1, _RET_IP_);
 112
 113         __up_read(sem);
 114 }
 115
 116 EXPORT_SYMBOL(up_read);
 117
 118 /*
 119  * release a write lock
 120  */
 121 void up_write(struct rw_semaphore *sem)
 122 {
 123         rwsem_release(&sem->dep_map, 1, _RET_IP_);
 124
 125         __up_write(sem);
 126 }
 127
 128 EXPORT_SYMBOL(up_write);
 129
 130 /*
 131  * downgrade write lock to read lock
 132  */
 133 void downgrade_write(struct rw_semaphore *sem)
 134 {
 135         lock_downgrade(&sem->dep_map, _RET_IP_);
 136
 137         __downgrade_write(sem);
 138 }
 139
 140 EXPORT_SYMBOL(downgrade_write);
 141
 142 #ifdef CONFIG_DEBUG_LOCK_ALLOC
 143
 144 void down_read_nested(struct rw_semaphore *sem, int subclass)
 145 {
 146         might_sleep();
 147         rwsem_acquire_read(&sem->dep_map, subclass, 0, _RET_IP_);
 148
 149         LOCK_CONTENDED(sem, __down_read_trylock, __down_read);
 150 }
 151
 152 EXPORT_SYMBOL(down_read_nested);
 153
 154 void _down_write_nest_lock(struct rw_semaphore *sem, struct lockdep_map *nest)
 155 {
 156         might_sleep();
 157         rwsem_acquire_nest(&sem->dep_map, 0, 0, nest, _RET_IP_);
 158
 159         LOCK_CONTENDED(sem, __down_write_trylock, __down_write);
 160 }
 161
 162 EXPORT_SYMBOL(_down_write_nest_lock);
 163
 164 void down_read_non_owner(struct rw_semaphore *sem)
 165 {
 166         might_sleep();
 167
 168         __down_read(sem);
 169         __rwsem_set_reader_owned(sem, NULL);
 170 }
 171
 172 EXPORT_SYMBOL(down_read_non_owner);
 173
 174 void down_write_nested(struct rw_semaphore *sem, int subclass)
 175 {
 176         might_sleep();
 177         rwsem_acquire(&sem->dep_map, subclass, 0, _RET_IP_);
 178
 179         LOCK_CONTENDED(sem, __down_write_trylock, __down_write);
 180 }
 181
 182 EXPORT_SYMBOL(down_write_nested);
 183
 184 int __sched down_write_killable_nested(struct rw_semaphore *sem, int subclass)
 185 {
 186         might_sleep();
 187         rwsem_acquire(&sem->dep_map, subclass, 0, _RET_IP_);
 188
 189         if (LOCK_CONTENDED_RETURN(sem, __down_write_trylock, __down_write_killable)) {
 190                 rwsem_release(&sem->dep_map, 1, _RET_IP_);
 191                 return -EINTR;
 192         }
 193
 194         return 0;
 195 }
 196
 197 EXPORT_SYMBOL(down_write_killable_nested);
 198
 199 void up_read_non_owner(struct rw_semaphore *sem)
 200 {
 201         DEBUG_RWSEMS_WARN_ON(!((unsigned long)sem->owner & RWSEM_READER_OWNED),
 202                                 sem);
 203         __up_read(sem);
 204 }
 205
 206 EXPORT_SYMBOL(up_read_non_owner);
 207
 208 #endif