mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
205 lines
3.8 KiB
205 lines
3.8 KiB
/* kernel/rwsem.c: R/W semaphores, public implementation |
|
* |
|
* Written by David Howells ([email protected]). |
|
* Derived from asm-i386/semaphore.h |
|
*/ |
|
|
|
#include <linux/types.h> |
|
#include <linux/kernel.h> |
|
#include <linux/sched.h> |
|
#include <linux/export.h> |
|
#include <linux/rwsem.h> |
|
#include <linux/atomic.h> |
|
|
|
#include "rwsem.h" |
|
|
|
/* |
|
* lock for reading |
|
*/ |
|
void __sched down_read(struct rw_semaphore *sem) |
|
{ |
|
might_sleep(); |
|
rwsem_acquire_read(&sem->dep_map, 0, 0, _RET_IP_); |
|
|
|
LOCK_CONTENDED(sem, __down_read_trylock, __down_read); |
|
rwsem_set_reader_owned(sem); |
|
} |
|
|
|
EXPORT_SYMBOL(down_read); |
|
|
|
/* |
|
* trylock for reading -- returns 1 if successful, 0 if contention |
|
*/ |
|
int down_read_trylock(struct rw_semaphore *sem) |
|
{ |
|
int ret = __down_read_trylock(sem); |
|
|
|
if (ret == 1) { |
|
rwsem_acquire_read(&sem->dep_map, 0, 1, _RET_IP_); |
|
rwsem_set_reader_owned(sem); |
|
} |
|
return ret; |
|
} |
|
|
|
EXPORT_SYMBOL(down_read_trylock); |
|
|
|
/* |
|
* lock for writing |
|
*/ |
|
void __sched down_write(struct rw_semaphore *sem) |
|
{ |
|
might_sleep(); |
|
rwsem_acquire(&sem->dep_map, 0, 0, _RET_IP_); |
|
|
|
LOCK_CONTENDED(sem, __down_write_trylock, __down_write); |
|
rwsem_set_owner(sem); |
|
} |
|
|
|
EXPORT_SYMBOL(down_write); |
|
|
|
/* |
|
* 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); |
|
|
|
/* |
|
* trylock for writing -- returns 1 if successful, 0 if contention |
|
*/ |
|
int down_write_trylock(struct rw_semaphore *sem) |
|
{ |
|
int ret = __down_write_trylock(sem); |
|
|
|
if (ret == 1) { |
|
rwsem_acquire(&sem->dep_map, 0, 1, _RET_IP_); |
|
rwsem_set_owner(sem); |
|
} |
|
|
|
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_); |
|
|
|
rwsem_clear_owner(sem); |
|
__up_write(sem); |
|
} |
|
|
|
EXPORT_SYMBOL(up_write); |
|
|
|
/* |
|
* downgrade write lock to read lock |
|
*/ |
|
void downgrade_write(struct rw_semaphore *sem) |
|
{ |
|
/* |
|
* lockdep: a downgraded write will live on as a write |
|
* dependency. |
|
*/ |
|
rwsem_set_reader_owned(sem); |
|
__downgrade_write(sem); |
|
} |
|
|
|
EXPORT_SYMBOL(downgrade_write); |
|
|
|
#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_); |
|
|
|
LOCK_CONTENDED(sem, __down_read_trylock, __down_read); |
|
rwsem_set_reader_owned(sem); |
|
} |
|
|
|
EXPORT_SYMBOL(down_read_nested); |
|
|
|
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); |
|
rwsem_set_owner(sem); |
|
} |
|
|
|
EXPORT_SYMBOL(_down_write_nest_lock); |
|
|
|
void down_read_non_owner(struct rw_semaphore *sem) |
|
{ |
|
might_sleep(); |
|
|
|
__down_read(sem); |
|
} |
|
|
|
EXPORT_SYMBOL(down_read_non_owner); |
|
|
|
void down_write_nested(struct rw_semaphore *sem, int subclass) |
|
{ |
|
might_sleep(); |
|
rwsem_acquire(&sem->dep_map, subclass, 0, _RET_IP_); |
|
|
|
LOCK_CONTENDED(sem, __down_write_trylock, __down_write); |
|
rwsem_set_owner(sem); |
|
} |
|
|
|
EXPORT_SYMBOL(down_write_nested); |
|
|
|
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); |
|
|
|
void up_read_non_owner(struct rw_semaphore *sem) |
|
{ |
|
__up_read(sem); |
|
} |
|
|
|
EXPORT_SYMBOL(up_read_non_owner); |
|
|
|
#endif |
|
|
|
|
|
|