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         rwsem_set_reader_owned(sem);
  28 }
  29
  30 EXPORT_SYMBOL(down_read);
  31
  32 /*
  33  * trylock for reading -- returns 1 if successful, 0 if contention
  34  */
  35 int down_read_trylock(struct rw_semaphore *sem)
  36 {
  37         int ret = __down_read_trylock(sem);
  38
  39         if (ret == 1) {
  40                 rwsem_acquire_read(&sem->dep_map, 0, 1, _RET_IP_);
  41                 rwsem_set_reader_owned(sem);
  42         }
  43         return ret;
  44 }
  45
  46 EXPORT_SYMBOL(down_read_trylock);
  47
  48 /*
  49  * lock for writing
  50  */
  51 void __sched down_write(struct rw_semaphore *sem)
  52 {
  53         might_sleep();
  54         rwsem_acquire(&sem->dep_map, 0, 0, _RET_IP_);
  55
  56         LOCK_CONTENDED(sem, __down_write_trylock, __down_write);
  57         rwsem_set_owner(sem);
  58 }
  59
  60 EXPORT_SYMBOL(down_write);
  61
  62 /*
  63  * lock for writing
  64  */
  65 int __sched down_write_killable(struct rw_semaphore *sem)
  66 {
  67         might_sleep();
  68         rwsem_acquire(&sem->dep_map, 0, 0, _RET_IP_);
  69
  70         if (LOCK_CONTENDED_RETURN(sem, __down_write_trylock, __down_write_killable)) {
  71                 rwsem_release(&sem->dep_map, 1, _RET_IP_);
  72                 return -EINTR;
  73         }
  74
  75         rwsem_set_owner(sem);
  76         return 0;
  77 }
  78
  79 EXPORT_SYMBOL(down_write_killable);
  80
  81 /*
  82  * trylock for writing -- returns 1 if successful, 0 if contention
  83  */
  84 int down_write_trylock(struct rw_semaphore *sem)
  85 {
  86         int ret = __down_write_trylock(sem);
  87
  88         if (ret == 1) {
  89                 rwsem_acquire(&sem->dep_map, 0, 1, _RET_IP_);
  90                 rwsem_set_owner(sem);
  91         }
  92
  93         return ret;
  94 }
  95
  96 EXPORT_SYMBOL(down_write_trylock);
  97
  98 /*
  99  * release a read lock
 100  */
 101 void up_read(struct rw_semaphore *sem)
 102 {
 103         rwsem_release(&sem->dep_map, 1, _RET_IP_);
 104
 105         __up_read(sem);
 106 }
 107
 108 EXPORT_SYMBOL(up_read);
 109
 110 /*
 111  * release a write lock
 112  */
 113 void up_write(struct rw_semaphore *sem)
 114 {
 115         rwsem_release(&sem->dep_map, 1, _RET_IP_);
 116
 117         rwsem_clear_owner(sem);
 118         __up_write(sem);
 119 }
 120
 121 EXPORT_SYMBOL(up_write);
 122
 123 /*
 124  * downgrade write lock to read lock
 125  */
 126 void downgrade_write(struct rw_semaphore *sem)
 127 {
 128         lock_downgrade(&sem->dep_map, _RET_IP_);
 129
 130         rwsem_set_reader_owned(sem);
 131         __downgrade_write(sem);
 132 }
 133
 134 EXPORT_SYMBOL(downgrade_write);
 135
 136 #ifdef CONFIG_DEBUG_LOCK_ALLOC
 137
 138 void down_read_nested(struct rw_semaphore *sem, int subclass)
 139 {
 140         might_sleep();
 141         rwsem_acquire_read(&sem->dep_map, subclass, 0, _RET_IP_);
 142
 143         LOCK_CONTENDED(sem, __down_read_trylock, __down_read);
 144         rwsem_set_reader_owned(sem);
 145 }
 146
 147 EXPORT_SYMBOL(down_read_nested);
 148
 149 void _down_write_nest_lock(struct rw_semaphore *sem, struct lockdep_map *nest)
 150 {
 151         might_sleep();
 152         rwsem_acquire_nest(&sem->dep_map, 0, 0, nest, _RET_IP_);
 153
 154         LOCK_CONTENDED(sem, __down_write_trylock, __down_write);
 155         rwsem_set_owner(sem);
 156 }
 157
 158 EXPORT_SYMBOL(_down_write_nest_lock);
 159
 160 void down_read_non_owner(struct rw_semaphore *sem)
 161 {
 162         might_sleep();
 163
 164         __down_read(sem);
 165 }
 166
 167 EXPORT_SYMBOL(down_read_non_owner);
 168
 169 void down_write_nested(struct rw_semaphore *sem, int subclass)
 170 {
 171         might_sleep();
 172         rwsem_acquire(&sem->dep_map, subclass, 0, _RET_IP_);
 173
 174         LOCK_CONTENDED(sem, __down_write_trylock, __down_write);
 175         rwsem_set_owner(sem);
 176 }
 177
 178 EXPORT_SYMBOL(down_write_nested);
 179
 180 int __sched down_write_killable_nested(struct rw_semaphore *sem, int subclass)
 181 {
 182         might_sleep();
 183         rwsem_acquire(&sem->dep_map, subclass, 0, _RET_IP_);
 184
 185         if (LOCK_CONTENDED_RETURN(sem, __down_write_trylock, __down_write_killable)) {
 186                 rwsem_release(&sem->dep_map, 1, _RET_IP_);
 187                 return -EINTR;
 188         }
 189
 190         rwsem_set_owner(sem);
 191         return 0;
 192 }
 193
 194 EXPORT_SYMBOL(down_write_killable_nested);
 195
 196 void up_read_non_owner(struct rw_semaphore *sem)
 197 {
 198         __up_read(sem);
 199 }
 200
 201 EXPORT_SYMBOL(up_read_non_owner);
 202
 203 #endif
 204
 205