rwsem.c 4.16 KB
Newer Older
1 2 3 4 5 6 7 8
/* kernel/rwsem.c: R/W semaphores, public implementation
 *
 * Written by David Howells (dhowells@redhat.com).
 * Derived from asm-i386/semaphore.h
 */

#include <linux/types.h>
#include <linux/kernel.h>
9
#include <linux/sched.h>
10
#include <linux/sched/debug.h>
11
#include <linux/export.h>
12
#include <linux/rwsem.h>
Arun Sharma's avatar
Arun Sharma committed
13
#include <linux/atomic.h>
14

15
#include "rwsem.h"
16

17 18 19
/*
 * lock for reading
 */
20
void __sched down_read(struct rw_semaphore *sem)
21 22 23 24
{
	might_sleep();
	rwsem_acquire_read(&sem->dep_map, 0, 0, _RET_IP_);

25
	LOCK_CONTENDED(sem, __down_read_trylock, __down_read);
26
	rwsem_set_reader_owned(sem);
27 28 29 30
}

EXPORT_SYMBOL(down_read);

31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46
int __sched down_read_killable(struct rw_semaphore *sem)
{
	might_sleep();
	rwsem_acquire_read(&sem->dep_map, 0, 0, _RET_IP_);

	if (LOCK_CONTENDED_RETURN(sem, __down_read_trylock, __down_read_killable)) {
		rwsem_release(&sem->dep_map, 1, _RET_IP_);
		return -EINTR;
	}

	rwsem_set_reader_owned(sem);
	return 0;
}

EXPORT_SYMBOL(down_read_killable);

47 48 49 50 51 52 53
/*
 * trylock for reading -- returns 1 if successful, 0 if contention
 */
int down_read_trylock(struct rw_semaphore *sem)
{
	int ret = __down_read_trylock(sem);

54
	if (ret == 1) {
55
		rwsem_acquire_read(&sem->dep_map, 0, 1, _RET_IP_);
56 57
		rwsem_set_reader_owned(sem);
	}
58 59 60 61 62 63 64 65
	return ret;
}

EXPORT_SYMBOL(down_read_trylock);

/*
 * lock for writing
 */
66
void __sched down_write(struct rw_semaphore *sem)
67 68 69 70
{
	might_sleep();
	rwsem_acquire(&sem->dep_map, 0, 0, _RET_IP_);

71
	LOCK_CONTENDED(sem, __down_write_trylock, __down_write);
72
	rwsem_set_owner(sem);
73 74 75 76
}

EXPORT_SYMBOL(down_write);

77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95
/*
 * lock for writing
 */
int __sched down_write_killable(struct rw_semaphore *sem)
{
	might_sleep();
	rwsem_acquire(&sem->dep_map, 0, 0, _RET_IP_);

	if (LOCK_CONTENDED_RETURN(sem, __down_write_trylock, __down_write_killable)) {
		rwsem_release(&sem->dep_map, 1, _RET_IP_);
		return -EINTR;
	}

	rwsem_set_owner(sem);
	return 0;
}

EXPORT_SYMBOL(down_write_killable);

96 97 98 99 100 101 102
/*
 * trylock for writing -- returns 1 if successful, 0 if contention
 */
int down_write_trylock(struct rw_semaphore *sem)
{
	int ret = __down_write_trylock(sem);

103
	if (ret == 1) {
104
		rwsem_acquire(&sem->dep_map, 0, 1, _RET_IP_);
105 106 107
		rwsem_set_owner(sem);
	}

108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131
	return ret;
}

EXPORT_SYMBOL(down_write_trylock);

/*
 * release a read lock
 */
void up_read(struct rw_semaphore *sem)
{
	rwsem_release(&sem->dep_map, 1, _RET_IP_);

	__up_read(sem);
}

EXPORT_SYMBOL(up_read);

/*
 * release a write lock
 */
void up_write(struct rw_semaphore *sem)
{
	rwsem_release(&sem->dep_map, 1, _RET_IP_);

132
	rwsem_clear_owner(sem);
133 134 135 136 137 138 139 140 141 142
	__up_write(sem);
}

EXPORT_SYMBOL(up_write);

/*
 * downgrade write lock to read lock
 */
void downgrade_write(struct rw_semaphore *sem)
{
143 144
	lock_downgrade(&sem->dep_map, _RET_IP_);

145
	rwsem_set_reader_owned(sem);
146 147 148 149
	__downgrade_write(sem);
}

EXPORT_SYMBOL(downgrade_write);
150 151 152 153 154 155 156 157

#ifdef CONFIG_DEBUG_LOCK_ALLOC

void down_read_nested(struct rw_semaphore *sem, int subclass)
{
	might_sleep();
	rwsem_acquire_read(&sem->dep_map, subclass, 0, _RET_IP_);

158
	LOCK_CONTENDED(sem, __down_read_trylock, __down_read);
159
	rwsem_set_reader_owned(sem);
160 161 162 163
}

EXPORT_SYMBOL(down_read_nested);

164 165 166 167 168 169
void _down_write_nest_lock(struct rw_semaphore *sem, struct lockdep_map *nest)
{
	might_sleep();
	rwsem_acquire_nest(&sem->dep_map, 0, 0, nest, _RET_IP_);

	LOCK_CONTENDED(sem, __down_write_trylock, __down_write);
170
	rwsem_set_owner(sem);
171 172 173 174
}

EXPORT_SYMBOL(_down_write_nest_lock);

175 176 177 178 179 180 181 182 183
void down_read_non_owner(struct rw_semaphore *sem)
{
	might_sleep();

	__down_read(sem);
}

EXPORT_SYMBOL(down_read_non_owner);

184 185 186 187 188
void down_write_nested(struct rw_semaphore *sem, int subclass)
{
	might_sleep();
	rwsem_acquire(&sem->dep_map, subclass, 0, _RET_IP_);

189
	LOCK_CONTENDED(sem, __down_write_trylock, __down_write);
190
	rwsem_set_owner(sem);
191 192 193 194
}

EXPORT_SYMBOL(down_write_nested);

Al Viro's avatar
Al Viro committed
195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210
int __sched down_write_killable_nested(struct rw_semaphore *sem, int subclass)
{
	might_sleep();
	rwsem_acquire(&sem->dep_map, subclass, 0, _RET_IP_);

	if (LOCK_CONTENDED_RETURN(sem, __down_write_trylock, __down_write_killable)) {
		rwsem_release(&sem->dep_map, 1, _RET_IP_);
		return -EINTR;
	}

	rwsem_set_owner(sem);
	return 0;
}

EXPORT_SYMBOL(down_write_killable_nested);

211 212 213 214 215 216 217
void up_read_non_owner(struct rw_semaphore *sem)
{
	__up_read(sem);
}

EXPORT_SYMBOL(up_read_non_owner);

218 219 220
#endif