Краткая справка |
Предыдущая Содержание Следующая |
Эта глава ввела большой набор символов для управления конкуренцией. Здесь приведены наиболее важные из них:
#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 ресурса после того, как все процессоры получили от планировщика задач время для работы.
|
Предыдущая Содержание Следующая |