Rumah >Tutorial sistem >LINUX >Teknologi kawalan konkurensi dalam pemacu Linux: prinsip dan amalan
Teknologi kawalan konkurensi dalam pemacu Linux: prinsip dan amalan
- 王林ke hadapan
- 2024-02-09 19:15:32611semak imbas
Jika anda seorang pembangun Linux terbenam, anda mungkin menghadapi soalan ini: Bagaimana untuk berkongsi sumber peranti dengan selamat antara berbilang tugas atau utas? Bagaimana untuk mengelakkan perlumbaan data dan ketidakkonsistenan? Bagaimana untuk meningkatkan prestasi dan kebolehpercayaan sistem? Isu ini semua melibatkan teknologi kawalan konkurensi, iaitu, cara menyelaraskan akses berbilang entiti pelaksanaan kepada sumber yang dikongsi. Dalam artikel ini, kami akan memperkenalkan teknologi kawalan konkurensi yang biasa digunakan dalam pemacu Linux, termasuk operasi atom, kunci putaran, semafor, kunci mutex, kunci baca-tulis, kunci berurutan dan RCU, dsb., dan memberi contoh penggunaan dan perhatiannya. perkara.
Untuk mencapai pengurusan sumber kritikal yang berkesan, program lapisan aplikasi mempunyai pembolehubah atom, pembolehubah keadaan dan semaphore untuk mengawal konkurensi Masalah yang sama juga wujud dalam pembangunan pemacu masa yang sama. Ini Pembolehubah global dalam pemacu masa akan tergolong dalam ruang proses proses lapisan aplikasi pada masa yang sama Dalam kes ini, beberapa teknologi juga mesti digunakan untuk mengawal konkurensi. Artikel ini akan membincangkan ciri teknikal dan senario aplikasi bagi teknologi kawalan konkurensi berikut dalam kernel.
- Topeng gangguan
-
Operasi atom
- Operasi pembolehubah atom
- Operasi bit atom
-
kunci putaran
- Kunci putaran tradisional
- Baca dan tulis kunci putaran
- Kunci urutan
- RCU
-
semafor
- Semafor tradisional
- Baca dan tulis semaphore
- Jumlah lengkap
- Mutex
Topeng Gangguan
Seperti namanya, ia menyekat semua gangguan. Dalam sistem terbenam, perisai gangguan boleh mempunyai tiga peringkat, 1 Perisai antara muka perkakasan, 2. Perisai GIC perkakasan, 3. Perisai CPU (kernel). Sekiranya ia disekat di antara muka, maka gangguan akan hilang apabila ia datang dan tidak dapat ditemui sama sekali. Jika ia dilindungi di GIC, maka jika irq_1, irq_2, irq_3 sampukan datang semasa tempoh perisai, kerana hanya terdapat satu bendera yang belum selesai, bendera yang belum selesai akan ditetapkan apabila irq_3 akhirnya datang CPU mendapati bahawa terdapat bendera yang belum selesai Jika bit ditetapkan, ia masih akan diproses, tetapi 1 dan 2 pasti akan hilang. Perisai di ARM, iaitu, perisai dalam kernel, bergantung pada cara ia ditetapkan Jika ia adalah local_irq_disable, maka jika ia hilang, ia adalah sama seperti perisai pada antara muka local_irq_save, ia adalah sama seperti yang kedua, mengejar gangguan terakhir Kernel juga mempunyai mekanisme yang sepadan untuk mengira gangguan dan mengetahui berapa banyak gangguan yang telah datang dalam tempoh ini, bagaimanapun, dalam kebanyakan kes kita tidak akan mengejar sampukan yang terlepas melainkan sampukan itu sangat penting.
Apa yang kita bincangkan di sini ialah penyamaran interupsi dalam kernel. Memandangkan banyak operasi penting dalam kernel bergantung pada gangguan, adalah sangat berbahaya untuk menutup semua gangguan Kod yang dilaksanakan di dalam mesti secepat mungkin, kerana penjadualan proses kernel juga didorong oleh gangguan, ia sangat berbahaya untuk menutup semua gangguan mesti tiada kod yang boleh mencetuskan tidur, jika tidak, ia tidak boleh dibangunkan. Ambil perhatian bahawa interrupt masking hanya menutup gangguan CPU ini, jadi ia tidak menyelesaikan masalah persaingan yang disebabkan oleh SMP Biasanya, interrupt masking digunakan bersama dengan spin lock untuk menghalang akses kepada bahagian kritikal yang dilindungi oleh spin lock dengan gangguan
Topeng gangguan biasa
local_irq_disable(); //屏蔽中断 //或 local_irq_save(flags); //屏蔽中断并保存目前CPU中的中断位信息 /* 临界区 */ local_irq_enable(); //解除屏蔽 //或 local_irq_restore(flags); //解除屏蔽并恢复中断位信息
Menyampuk perisai di bahagian bawah
local_bh_disable(); //屏蔽中断 /* 临界区 */ local_bh_enable();
Operasi atom
Operasi atom ialah operasi yang tidak boleh diganggu Ia sama dengan konsep lapisan aplikasi Templat operasi atom dalam kernel adalah seperti berikut:
Pembolehubah atom integer
//asm/atomic.h //创建并初始化原子变量 atomic_t tv = ATOMIC_INIT(初值); //读原子变量 int atomic_read(atomic_t *v); //写原子变量 void atomic_set(atomic_t *v, int i); /** *atomic_dec_and_test - 尝试将原子变量-1 *v:如果-1之后原子变量变为0，返回非0, 否则返回0 */ int atomic_dec_and_test(volatile atomic_t *v); int atomic_inc_and_test(volatile atomic_t *v); int atomic_sub_and_test(int i, volatile atomic_t *v); //操作并返回 int atomic_add_return(int i, atomic *v); int atomic_sub_return(int i, atomic *v); int atomic_inc_return(atomic *v); int atomic_dev_return(atomic *v);
template
static atomic_t tv;
static int demo_open(struct inode *inode, struct file *filp)
{
if(!atomic_dec_and_test(&tv)){
atomic_inc(&tv);
return -EBUSY;
}
/* 操作代码 */
return 0;
}
static int demo_release(struct inode *inode, struct file *filp)
{
atomic_inc(&tv);
return 0;
}
static int __init demo_init(void)
{
// init atomic_t
atomic_set(&tv, 1);
}
operasi atom bit
Operasi bit atom ialah operasi bit atom Sebilangan besar "bit" digunakan dalam kernel untuk merekod maklumat, seperti bitmaps ini mestilah atomic API adalah seperti berikut:
//设置位 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);
Spin Lock
Ia bermaksud "berpusing di tempat". Apabila kunci tidak berjaya, putaran, dan kunci putaran akan terus menduduki CPU untuk ujian boleh ubah Memandangkan ia adalah operasi atom, penggunaan CPU akan meningkat kepada 100%, jadi, Apabila menggunakan kunci putaran, kod di bahagian kritikal perlu sangat pendek, jika tidak, ia akan menjejaskan prestasi sistem Di samping itu, sebagai sejenis mekanisme kunci, apabila menggunakan kunci putaran, anda juga perlu memberi perhatian kepada kejadian. Kegagalan untuk memanggil kunci putaran semasa tempoh kunci boleh menyebabkan fungsi penjadualan proses, jika proses terhalang selepas mendapatkan kunci putaran, cth, copy_from_user(), copy_to_user(), kmalloc(), msleep(), dsb., sekali penyekatan berlaku, kernel mungkin ranap.
Kunci putaran boleh digunakan untuk menyelesaikan masalah perlumbaan SMP. Jenis kunci putaran yang berbeza mempunyai mekanisme pemprosesan mereka sendiri, sesuai untuk situasi yang berbeza. Termasuk kunci putaran tradisional, kunci putaran baca-tulis, mekanisme RCU, kunci berjujukan, dsb. adalah alat pelaksanaan asas untuk semaphore dan mutex.
| Bandingkan jenis | Kunci putaran tradisional | Baca dan tulis kunci putaran | Kunci Urutan | Mekanisme RCU |
|---|---|---|---|---|
| Majlis permohonan | Memerlukan sumber eksklusif untuk loker | Memerlukan sumber eksklusif untuk penulis | Terdapat sedikit sumber yang boleh dibaca dan ditulis pada masa yang sama | Baca lebih banyak dan kurangkan tulis sumber |
| Baca+Baca Concurrency | × | √ | √ | √ |
| Baca + tulis serentak | × | × | √ | √ |
| Tulis+Tulis Concurrency | × | × | × | √ |
和其他锁机制的一样，使用自旋锁保护数据分为抢锁-操作-解锁,下面就是一个典型的使用锁的流程，通过自旋锁实现一个文件只被一个进程打开。
int cnt=0;
lock_t lock;
static int my_open()
{
lock(&lock);
if(cnt){
unlock(&lock)
}
cnt++;
unlock(&lock);
}
static int release()
{
lock(&lock);
cnt--;
unlock(&lock);
}
传统自旋锁
是一种比较粗暴的自旋锁，使用这种锁的时候，被锁定的临界区域不允许其他CPU访问，需要注意的是，尽管获得锁之后执行的临界区操作不会被其他CPU和本CPU内其他抢占进程的打扰，但是仍然会被中断和底半部的影响，所以通常我们会使用下述API中的衍生版本，比如上文中提到的将自旋锁+中断屏蔽来防止使用自旋锁访问临界资源的时候被中断打断，对应的宏函数就是spin_lock_irq和spin_lock_irqsave。
//定义并初始化自旋锁 spinlock_t spinlock void spin_lock_init(spinlock_t *); //加锁 //spin_lock - 加锁函数（忙等） void spin_lock(spinlock_t *lock); int spin_trylock(spinlock_t *lock); spin_lock_irq(); //=spin_lock() + local_irq_disable() spin_lock_irqsave(); //= spin_lock() + lock_irq_save(); spin_lock_bh(); //=spin_lock() + local_bh_disable(); //解锁 void spin_unlock(spinlock_t *lock); spin_unlock_irq(); //=spin_unlock() + local_irq_enable() spin_unlock_irqrestore(); //= spin_unlock() + lock_irq_restore(); spin_unlock_bh(); //=spin_unlock() + local_bh_enable();
读写自旋锁
传统的自旋锁粗暴的将临界资源划归给一个CPU，但是很多资源都不会因为读而被破坏，所以我们可以允许多个CPU同时读临界资源，但不允许同时写资源，类似于应用层的文件锁，内核的读写锁机制同样有下述互斥原则:
- 读者 + 读者 不互斥
- 读者 + 写者 互斥
- 写者 + 写者 互斥
//include/linux/rwlock.h //定义并初始化自旋锁 rwlock_t rwlock; void rwlock_init(rwlock_t *lock); //加读锁 void read_lock(rwlock_t *lock); int read_trylock(rwlock_t *lock); void read_lock_irqsave(rwlock_t *lock,unsigned long flags); void read_lock_irq(rwlock_t *lock, unsigned long flags); void read_lock_bh(rwlock_t *lock); //解读锁 void read_unlock(rwlock_t *lock) void read_unlock_irqrestrore(rwlock_t *lock,unsigned long flags); void read_unlock_irq(rwlock_t *lock, unsigned long flags); void read_unlock_bh(rwlock_t *lock); //加写锁 void write_lock(rwlock_t *lock) int write_trylock(rwlock_t *lock) void write_lock_irqsave(rwlock_t *lock,unsigned long flags); void write_lock_irq(rwlock_t *lock, unsigned long flags); void write_lock_bh(rwlock_t *lock); //解写锁 void write_unlock(rwlock_t *lock) void write_unlock_irqrestrore(rwlock_t *lock,unsigned long flags); void write_unlock_irq(rwlock_t *lock, unsigned long flags); void write_unlock_bh(rwlock_t *lock);
顺序锁
顺序锁可以看作读写锁的升级版，读写锁不允许同时存在读者和写者，顺序锁对这一情况进行了改良，它允许写者和读者同时访问临界区，不必再向读写锁那样读者要读必须等待写者写完，写者要写必须等待读者读完。不过，使用顺序锁的时候，临界区不能有指针，因为写者可能会修改指针的指向，如果读者去读，就会Oops，此外，如果读者读过的数据被写者改变了，读者需要重新读，以维持数据是最新的，虽然有这两个约束，但是顺序锁提供了比读写锁更大的灵活性。对于写者+写者的情况，顺序锁的机制和读写锁一样，必须等！
- 读者 + 读者 不互斥
- 读者 + 写者 不互斥 , 临界区没有指针+读者需自己注意更新
- 写者 + 写者 互斥
//include/linux/seqlock.h //定义顺序锁 struct seqlock_t sl; //获取顺序锁 void write_seqlock(seqlock_t *sl); void write_tryseqlock(seqlock_t *sl); void write_seqlock_irqsave(lock,flags); //=local_irq_save() + write_seqlock() void write_seqlock_irq(seqlock_t *sl); //=local_irq_disable() + write_seqlock() void write_seqlock_bh(seqlock_t *sl); //local_bh_disable() + write_seqlock() //释放顺序锁 void write_sequnlock(seqlock_t *sl); void write_sequnlock_irqsave(lock,flags); //=local_irq_restore() + write_sequnlock() void write_sequnlock_irq(seqlock_t *sl); //=local_irq_enable() + write_sequnlock() void write_sequnlock_bh(seqlock_t *sl); //local_bh_enable() + write_sequnlock() //读开始 unsigned read_seqbegin(const seqlock_t *sl); read_seqbegin_irqsave(lock,flags); //=local_irq_save() + read_seqbegin(); //重读 int read_seqretry(const seqlock_t *sl,unsigned iv); read_seqretry_irqrestore(lock,iv,flags); //=local_irq_restore() + read_seqretry();
RCU
RCU即Read-Copy Update，即读者直接读，写者先拷贝再择时更新，是另外一种读写锁的升级版，这种机制在VFS层被大量使用。正如其名，读者访问临界资源不需要锁，从下面的rcu_read_lock的定义即可看出，写者在写之前先将临界资源进行备份，去修改这个副本，等所有的CPU都退出对这块临界区的引用后，再通过回调机制，将引用这块资源的原指针指向已经修改的备份。从中可以看出，在RCU机制下，读者的开销大大降低，也没有顺序锁的指针问题，但是写者的开销很大，所以RCU适用于读多写少的临界资源。如果写操作很多，就有可能将读操作节约的性能抵消掉，得不偿失。
- 读者 + 读者 不互斥
- 读者 + 写者 不互斥 , 读者自己注意更新
- 写者 + 写者 不互斥 ，写者之间自己去同步
内核会为每一个CPU维护两个数据结构-rcu_data和rcu_bh_data，他们用于保存回调函数，函数call_rcu()把回调函数注册到rcu_data，而call_rcu_bh()则把回调函数注册到rcu_bh_data，在每一个数据结构上，回调函数们会组成一个队列。
使用RCU时，读执行单元必须提供一个信号给写执行单元以便写执行单元能够确定数据可以被安全地释放或修改的时机。内核中有一个专门的垃圾收集器来探测读执行单元的信号，一旦所有的读执行单元都已经发送信号告诉收集器自己都没有使用RCU的数据结构，收集器就调用回调函数完成最后的数据释放或修改操作。
读
读即RCU中的R，从下面的宏定义可以看出，读操作其实就是禁止内核的抢占调度，并没有使用一个锁对象。
//读锁定 //include/linux/rcupdate.h rcu_read_lock(); //preempt_disbale() rcu_read_lock_bh(); //local_bh_disable() //读解锁 rcu_read_unlock() //preempt_enable() rcu_read_unlock_bh(); //local_bh_enable()
同步
同步即是RCU写操作的最后一个步骤-Update，下面这个接口会则色写执行单元，直到所有的读执行单元已经完成读执行单元临界区，写执行单元才可以继续下一步操作。如果有多个RCU写执行单元调用该函数，他们将在一个grace period(即所有的读执行单元已经完成对临界区的访问)之后全部被唤醒。
synchrosize_rcu()
挂起回调
下面这个接口也由RCU写执行单元调用，它不会使写执行单元阻塞，因而可以在中断上下文或软中断中使用，该函数把func挂接到RCU回调函数链上，然后立即返回。函数sychrosize_rcu()其实也会调用call_rcu()。
void call_rcu(struct rcu_head *head,void (*func)(struct rcu_head *rcu));
下面这个接口会将软中断的完成也当作经历一个quiecent state(静默状态)，因此如果写执行单元调用了该函数，在进程上下文的读执行单元必须使用rcu_read_lock_bh();
void call_rcu_bh(struct rcu_head *head,void (*func)(struct rcu_head *rcu));
RCU机制被大量的运用在内核链表的读写中，下面这些就是内核中使用RCU机制保护的数据结构，函数的功能和非RCU版本一样，具体可以参考内核文件**”include/linux/list.h”**，只不过这里的操作都会使用RCU保护起来。
void list_add_rcu(struct list_head *new, struct list_head *head); void list_add_tail_rcu(struct list_head *new,struct list_head *head); void list_del_rcu(struct list_head *entry); void list_replace_rcu(struct list_head *old,struct list_head *new); list_for_each_rcu(pos,head); list_for_each_safe_rcu(pos,n,head); list_for_each_entry_rcu(pos,head,member); void hlist_del_rcu(struct hlist_node *n); void hlist_add_head_rcu(struct hlist_node *n, struct hlist_head *h); list_for_each_rcu(pos,head); hlist_for_each_entry_rcu(tpos,pos,head,member);
信号量
自旋锁一节提过，如果一个CPU不能获取临界资源，就会造成”原地自旋”，所以自旋锁保护的临界区的执行时间不能太长，但如果我们的确需要保护一段执行时间比较长的临界区呢？答案就是信号量
，信号量的底层依托于自旋锁来实现其原子性，并进一步将其提高到”进程”的维度，称为一种可以运行在进程上下文的”锁”，正是这种能运行在进程上下文的能力赋予了信号量和自旋锁的诸多不同。
使用信号量，如果试图获取信号量的进程获取失败，内核就会将其调度为睡眠状态，执行其他进程，避免了CPU的忙等。不过，进程上下文的切换也是有成本的，所以通常，信号量在内核中都是只用于保护大块临界区。
此外，一个进程一旦无法获取期待的信号量就会进入睡眠，所以信号量保护的临界区可以有睡眠的代码。在这方面，自旋锁保护的区域是不能睡眠也不能执行schedule()的，因为一旦一个抢到了锁的CPU进行了进程上下文的切换或睡眠，那么其他等待这个自旋锁的CPU就会一直在那忙等，就永远无法等到这个锁，，形成死锁，除非有其他进程将其唤醒(通常都不会有)。
也正是由于信号量操作可能引起阻塞，所以信号量不能用于中断上下文。总结一下刚才罗嗦这一段：
| Projek | Semaphore | Spin Lock |
|---|---|---|
| masa bahagian kritikal | Masa penukaran proses lebih singkat | Masa pelaksanaan bahagian kritikal lebih singkat |
| Konteks Proses | Bahagian kritikal boleh tidur atau jadualkan | Bahagian kritikaltidak boleh tidur atau jadual |
| Konteks gangguan | Hanya down_trylock() boleh | Ya |
传统信号量
内核的信号量和应用层的信号量的使用方式类似，但没有获取信号量这一步骤，因为内核中中的信号量可以映射到所有调用这个模块的用户进程的内核空间。这些用户进程也就直接共享了一个信号量，所以也就没有获取信号量一说，相关的内容我在”Linux IPC System V 信号量”一文中有所讨论。
和应用层的信号量一样，内核信号量也是用于对临界资源的互斥/顺序访问，同样，虽然在使用信号量的时候我们可以初始化为任意值，但实际操作上我们通常只初始化为1或0，下述是Linux内核提供的信号量API。
//include/linux/semaphore.h //定义并初始化semaphore对象 struct semphore sem; //初始化信号量 void sem_init(struct semaphore * sem,int val); init_MUTEX(sem); init_MUTEX_LOCKED(sem); DECLARE_MUTEX(sem); DECLARE_MUTEX_LOCKED(sem); //P操作 //down()会导致睡眠，不能用于中断上下文 void down(struct semaphore *sem); //down_interruptible同样会进入休眠，但能被打断 int down_interruptible(struct semaphore *sem); //down_trylock不能获得锁时会立即返回，不会睡眠，可以用在中断上下文 int down_trylock(struct semaphore *sem); //V操作 void up(struct semaphore *sem);
读写信号量
读写信号量与信号量的关系 和 读写自旋锁与自旋锁的关系类似，他们的互斥逻辑都是一样的，这里不再赘述
//定义并初始化读写信号量 struct rw_semaphore my_rwsem; void init_rwsem(struct rw_semaphore *sem); //P读信号量 void down_read(struct rw_semaphore *sem); int down_read_trylock(struct rw_semaphore *sem); //V读信号量 void up_read(struct rw_semaphore *sem); //P写信号量 void down_write(struct rw_semaphore *sem); int down_write_trylock(struct rw_semaphore *sem); //V写信号量 void up_write(struct rw_semaphore *sem);
模板
struct rw_semaphore my_rwsem; void init_rwsem(&my_rwsem); //读前获取读信号量 down_read(&my_rwsem); //若要非阻塞：down_read_trylock(&my_rwsem); /* 读临界区 */ //读完释放读信号量 up_read(&my_rwsem); //写前获取写信号量 down_write(&my_rwsem); //若要非阻塞：down_write_trylock(&my_rwsem); /* 写临界区 */ //写完释放写信号量 up_write(&my_rwsem);
完成量
完成量用于一个执行单元等待另一个执行单元执行完某事，和传统信号量一样，主要是用来实现队临界区的顺序/互斥访问。但是完成量还提供一种唤醒一个或唤醒所有等待进程的接口，有点类似与应用层的条件变量。
//定义并初始化完成量 struct completion my_completion; init_completion(&my_completion); //或 DECLARE_COMPLETION(my_completion) //等待completion void wait_for_completion(struct completion *c); //唤醒completion void complete(struct completion *c); //只唤醒一个等待的执行单元 void complete_all(struct completion *c); //释放所有等待该完成量的执行单元
互斥体
除了信号量，Linux内核还提供了一种专门用于实现互斥的机制-互斥体，相关的内核API如下：
//include/linux/mutex.h //定义并初始化mutex对象 struct mutex my_mutex; mutex_init(&my_mutex); //获取mutex void mutex_lock(struct mutex *lock); int mutex_trylock(struct mutex *lock); int mutex_lock_interruptible(struct mutex *lock); //释放mutex void mutex_unlock(struct mutex *lock);
通过本文，我们了解了Linux驱动中的并发控制技术，它们各有优缺点和适用场景。我们应该根据实际需求选择合适的技术，并遵循一些基本原则，如最小化临界区，避免死锁，减少上下文切换等。并发控制技术是Linux驱动开发中不可或缺的一部分，它可以保证设备资源的正确性和高效性，也可以提升系统的稳定性和可扩展性。希望本文能够对你有所帮助和启发。
Atas ialah kandungan terperinci Teknologi kawalan konkurensi dalam pemacu Linux: prinsip dan amalan. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!