Краткая справка

Эта глава ввела большой набор символов для управления конкуренцией. Здесь приведены наиболее важные из них:

#include <asm/semaphore.h>

Подключает файл, который определяет семафоры и операции с ними.

DECLARE_MUTEX(name);

DECLARE_MUTEX_LOCKED(name);

Два макроса для объявления и инициализации семафора, используемого в режиме взаимного исключения.

void init_MUTEX(struct semaphore *sem);

void init_MUTEX_LOCKED(struct semaphore *sem);

Эти две функции могут быть использованы для инициализации семафора во время выполнения.

void down(struct semaphore *sem);

int down_interruptible(struct semaphore *sem);

int down_trylock(struct semaphore *sem);

void up(struct semaphore *sem);

Блокировка и разблокировка семафора. down в случае необходимости помещает вызывающий процесс в непрерываемый сон; down_interruptible, наоборот, может быть прервана сигналом. down_trylock не засыпает; вместо этого она сразу же возвращается, если семафор недоступен. Код, который блокирует семафор, в конечном итоге должен разблокировать его с помощью up.

struct rw_semaphore;

init_rwsem(struct rw_semaphore *sem);

Версии чтения/записи семафоров и функция инициализации.

void down_read(struct rw_semaphore *sem);

int down_read_trylock(struct rw_semaphore *sem);

void up_read(struct rw_semaphore *sem);

Функции для получения и освобождения доступа на чтение для семафора чтения/записи .

void down_write(struct rw_semaphore *sem);

int down_write_trylock(struct rw_semaphore *sem);

void up_write(struct rw_semaphore *sem);

void downgrade_write(struct rw_semaphore *sem);

Функции для управления доступом на запись для семафора чтения/записи .

#include <linux/completion.h>

DECLARE_COMPLETION(name);

init_completion(struct completion *c);

INIT_COMPLETION(struct completion c);

Подключаемый файл с описанием механизма завершения Linux и обычные методы для инициализации завершений. INIT_COMPLETION должен использоваться только для переинициализации завершения, которое было использовано ранее.

void wait_for_completion(struct completion *c);

Ожидает события завершения, чтобы просигнализировать.

void complete(struct completion *c);

void complete_all(struct completion *c);

Сигнал события завершения. complete будит, самое большее, один ожидающий поток, в то время как complete_all будит всех ожидающий.

void complete_and_exit(struct completion *c, long retval);

Сигнализирует о событии завершения, делая вызов completion и вызов exit для текущего потока.

#include <linux/spinlock.h>

spinlock_t lock = SPIN_LOCK_UNLOCKED;

spin_lock_init(spinlock_t *lock);

Подключает файл, определяющий интерфейс спин-блокировки и два способа инициализации блокировок.

void spin_lock(spinlock_t *lock);

void spin_lock_irqsave(spinlock_t *lock, unsigned long flags);

void spin_lock_irq(spinlock_t *lock);

void spin_lock_bh(spinlock_t *lock);

Различные способы блокирования спин-блокировки и, возможно, запрета прерываний.

int spin_trylock(spinlock_t *lock);

int spin_trylock_bh(spinlock_t *lock);

Незацикливающиеся версии указанных выше функций; возвращают 0 в случае неудачи при получении блокировки, ненулевое иначе.

void spin_unlock(spinlock_t *lock);

void spin_unlock_irqrestore(spinlock_t *lock, unsigned long flags);

void spin_unlock_irq(spinlock_t *lock);

void spin_unlock_bh(spinlock_t *lock);

Соответствующие способы освобождения спин-блокировок.

rwlock_t lock = RW_LOCK_UNLOCKED

rwlock_init(rwlock_t *lock);

Это два способа инициализации блокировок чтения/записи .

void read_lock(rwlock_t *lock);

void read_lock_irqsave(rwlock_t *lock, unsigned long flags);

void read_lock_irq(rwlock_t *lock);

void read_lock_bh(rwlock_t *lock);

Функции для получения доступа на чтение для блокировки чтения/записи.

void read_unlock(rwlock_t *lock);

void read_unlock_irqrestore(rwlock_t *lock, unsigned long flags);

void read_unlock_irq(rwlock_t *lock);

void read_unlock_bh(rwlock_t *lock);

Функции для освобождения доступа на чтения для спин-блокировки чтения/записи .

void write_lock(rwlock_t *lock);

void write_lock_irqsave(rwlock_t *lock, unsigned long flags);

void write_lock_irq(rwlock_t *lock);

void write_lock_bh(rwlock_t *lock);

Функции для получения доступа на запись для блокировки чтения/записи.

void write_unlock(rwlock_t *lock);

void write_unlock_irqrestore(rwlock_t *lock, unsigned long flags);

void write_unlock_irq(rwlock_t *lock);

void write_unlock_bh(rwlock_t *lock);

Функции для освобождения доступа на запись для спин-блокировки чтения/записи .

#include <asm/atomic.h>

atomic_t v = ATOMIC_INIT(value);

void atomic_set(atomic_t *v, int i);

int atomic_read(atomic_t *v);

void atomic_add(int i, atomic_t *v);

void atomic_sub(int i, atomic_t *v);

void atomic_inc(atomic_t *v);

void atomic_dec(atomic_t *v);

int atomic_inc_and_test(atomic_t *v);

int atomic_dec_and_test(atomic_t *v);

int atomic_sub_and_test(int i, atomic_t *v);

int atomic_add_negative(int i, atomic_t *v);

int atomic_add_return(int i, atomic_t *v);

int atomic_sub_return(int i, atomic_t *v);

int atomic_inc_return(atomic_t *v);

int atomic_dec_return(atomic_t *v);

Целочисленные переменные с атомарным доступом. Переменные atomic_t должны быть доступны только через эти функции.

#include <asm/bitops.h>

void set_bit(nr, void *addr);

void clear_bit(nr, void *addr);

void change_bit(nr, void *addr);

test_bit(nr, void *addr);

int test_and_set_bit(nr, void *addr);

int test_and_clear_bit(nr, void *addr);

int test_and_change_bit(nr, void *addr);

Атомарный доступ к битовым величинам; они могут быть использованы для флагов или переменных блокировки. Использование этих функций позволяет избежать состояния гонок, связанного с одновременным доступом к битам.

#include <linux/seqlock.h>

seqlock_t lock = SEQLOCK_UNLOCKED;

seqlock_init(seqlock_t *lock);

Подключение файла, определяющего последовательные блокировки и два способа их инициализации.

unsigned int read_seqbegin(seqlock_t *lock);

unsigned int read_seqbegin_irqsave(seqlock_t *lock, unsigned long flags);

int read_seqretry(seqlock_t *lock, unsigned int seq);

int read_seqretry_irqrestore(seqlock_t *lock, unsigned int seq, unsigned long flags);

Функции для получения доступа на чтение к ресурсам, защищённым последовательной блокировкой.

void write_seqlock(seqlock_t *lock);

void write_seqlock_irqsave(seqlock_t *lock, unsigned long flags);

void write_seqlock_irq(seqlock_t *lock);

void write_seqlock_bh(seqlock_t *lock);

int write_tryseqlock(seqlock_t *lock);

Функции для получения доступа на запись к ресурсу, защищённому последовательной блокировкой.

void write_sequnlock(seqlock_t *lock);

void write_sequnlock_irqrestore(seqlock_t *lock, unsigned long flags);

void write_sequnlock_irq(seqlock_t *lock);

void write_sequnlock_bh(seqlock_t *lock);

Функции для освобождения доступа на запись к ресурсу, защищённому последовательной блокировкой.

#include <linux/rcupdate.h>

Подключает файл, необходимый для использования механизма чтения-копирования-обновления (RCU) .

void rcu_read_lock;

void rcu_read_unlock;

Макросы для получения атомарного доступа на чтение к ресурсу, защищённому RCU.

void call_rcu(struct rcu_head *head, void (*func)(void *arg), void *arg);

Организует обратный вызов для запуска безопасного освобождения защищённого RCU ресурса после того, как все процессоры получили от планировщика задач время для работы.