5.8. 快速參考

5.8.?快速參考

本章已介紹了很多符號給并發(fā)的管理. 最重要的這些在此總結(jié):

#include <asm/semaphore.h>

定義旗標(biāo)和其上操作的包含文件.

DECLARE_MUTEX(name);
DECLARE_MUTEX_LOCKED(name);

2 個宏定義, 用來聲明和初始化一個在互斥模式下使用的旗標(biāo).

void init_MUTEX(struct semaphore *sem);
void init_MUTEX_LOCKED(struct semaphore *sem);

這 2 函數(shù)用來在運(yùn)行時初始化一個旗標(biāo).

void down(struct semaphore *sem);
int down_interruptible(struct semaphore *sem);
int down_trylock(struct semaphore *sem);
void up(struct semaphore *sem);

加鎖和解鎖旗標(biāo). down 使調(diào)用進(jìn)程進(jìn)入不可打斷睡眠, 如果需要; down_interruptible, 相反, 可以被信號打斷. down_trylock 不睡眠; 相反, 它立刻返回如果旗標(biāo)不可用. 加鎖旗標(biāo)的代碼必須最終使用 up 解鎖它.

struct rw_semaphore;
init_rwsem(struct rw_semaphore *sem);

旗標(biāo)的讀者/寫者版本和初始化它的函數(shù).

void down_read(struct rw_semaphore *sem);
int down_read_trylock(struct rw_semaphore *sem);
void up_read(struct rw_semaphore *sem);

獲得和釋放對讀者/寫者旗標(biāo)的讀存取的函數(shù).

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);

管理對讀者/寫者旗標(biāo)寫存取的函數(shù).

#include <linux/completion.h>
DECLARE_COMPLETION(name);
init_completion(struct completion *c);
INIT_COMPLETION(struct completion c);

描述 Linux completion 機(jī)制的包含文件, 已經(jīng)初始化 completion 的正常方法. INIT_COMPLETION 應(yīng)當(dāng)只用來重新初始化一個之前已經(jīng)使用過的 completion.

void wait_for_completion(struct completion *c);

等待一個 completion 事件發(fā)出.

void complete(struct completion *c);
void complete_all(struct completion *c);

發(fā)出一個 completion 事件. completion 喚醒, 最多, 一個等待著的線程, 而 complete_all 喚醒全部等待者.

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

通過調(diào)用 complete 來發(fā)出一個 completion 事件, 并且為當(dāng)前線程調(diào)用 exit.

#include <linux/spinlock.h>
spinlock_t lock = SPIN_LOCK_UNLOCKED;
spin_lock_init(spinlock_t *lock);

定義自旋鎖接口的包含文件, 以及初始化鎖的 2 個方法.

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);

上面函數(shù)的非自旋版本; 在獲取鎖失敗時返回 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);

釋放一個自旋鎖的相應(yīng)方法.

rwlock_t lock = RW_LOCK_UNLOCKEDrwlock_init(rwlock_t *lock);

初始化讀者/寫者鎖的 2 個方法.

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);

獲得一個讀者/寫者鎖的讀存取的函數(shù).

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);

獲得一個讀者/寫者鎖的寫存取的函數(shù).

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);

釋放一個讀者/寫者自旋鎖的寫存取的函數(shù).

#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);

原子地存取整數(shù)變量. atomic_t 變量必須只通過這些函數(shù)存取.

#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);

原子地存取位值; 它們可用做標(biāo)志或者鎖變量. 使用這些函數(shù)阻止任何與并發(fā)存取這個位相關(guān)的競爭情況.

#include <linux/seqlock.h>
seqlock_t lock = SEQLOCK_UNLOCKED;
seqlock_init(seqlock_t *lock);

定義 seqlock 的包含文件, 已經(jīng)初始化它們的 2 個方法.

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);

獲得一個 seqlock-保護(hù) 的資源的讀權(quán)限的函數(shù).

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);

獲取一個 seqlock-保護(hù)的資源的寫權(quán)限的函數(shù).

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);

釋放一個 seqlock-保護(hù)的資源的寫權(quán)限的函數(shù).

#include <linux/rcupdate.h>

需要使用讀取-拷貝-更新(RCU)機(jī)制的包含文件.

void rcu_read_lock;void rcu_read_unlock;

獲取對由 RCU 保護(hù)的資源的原子讀權(quán)限的宏定義.

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

安排一個回調(diào)在所有處理器已經(jīng)被調(diào)度以及一個 RCU-保護(hù)的資源可用被安全的釋放之后運(yùn)行.