linux 内核同步机制使用

Linux 内核中的同步机制:原子操作、信号量、读写信号量、自旋锁的API、大内核锁、读写锁、大读者锁、RCU和顺序锁。

1、介绍

在现代操作系统里,同一时间可能有多个内核执行流在执行,即使单CPU内核也需要一些同步机制来同步不同执行单元对共享的数据的访问。 主流的Linux内核中的同步机制包括: 原子操作 信号量(semaphore) 读写信号量(rw_semaphore) 自旋锁spinlock 大内核锁BKL(Big Kernel Lock) 读写锁rwlock、

brlock(只包含在2.4内核中) RCU(只包含在2.6内核中) 顺序锁seqlock(只包含在2.6内核中)

2、原子操作

所谓原子操作,就是该操作绝不会在执行完毕前被任何其他任务或事件打断,也就说,它的最小的执行单位,不可能有比它更小的执行单位,因此这里的原子实际是使用了物理学里的物质微粒的概念。 原子操作需要硬件的支持,因此是架构相关的,其API和原子类型的定义都定义在内核源码树的include/asm/atomic.h文件中,它们都使用汇编语言实现,因为C语言并不能实现这样的操作。 原子操作主要用于实现资源计数,很多引用计数(refcnt)就是通过原子操作实现的。 typedef struct { volatile int counter; } atomic_t; 原子类型定义 volatile修饰字段告诉gcc不要对该类型的数据做优化处理,对它的访问都是对内存的访问,而不是对寄存器的访问。 原子操作API包括: atomic_read(atomic_t * v); 该函数对原子类型的变量进行原子读操作,它返回原子类型的变量v的值。 atomic_set(atomic_t * v, int i); 该函数设置原子类型的变量v的值为i。 void atomic_add(int i, atomic_t *v); 该函数给原子类型的变量v增加值i。 atomic_sub(int i, atomic_t *v); 该函数从原子类型的变量v中减去i。 int atomic_sub_and_test(int i, atomic_t *v); 该函数从原子类型的变量v中减去i,并判断结果是否为0,如果为0,返回真,否则返回假。 void atomic_inc(atomic_t *v); 该函数对原子类型变量v原子地增加1。 void atomic_dec(atomic_t *v); 该函数对原子类型的变量v原子地减1。 int atomic_dec_and_test(atomic_t *v); 该函数对原子类型的变量v原子地减1,并判断结果是否为0,如果为0,返回真,否则返回假。 int atomic_inc_and_test(atomic_t *v); 该函数对原子类型的变量v原子地增加1,并判断结果是否为0,如果为0,返回真,否则返回假。 int atomic_add_negative(int i, atomic_t *v); 该函数对原子类型的变量v原子地增加I,并判断结果是否为负数,如果是,返回真,否则返回假。 int atomic_add_return(int i, atomic_t *v); 该函数对原子类型的变量v原子地增加i,并且返回指向v的指针。 int atomic_sub_return(int i, atomic_t *v); 该函数从原子类型的变量v中减去i,并且返回指向v的指针。 int atomic_inc_return(atomic_t * v); 该函数对原子类型的变量v原子地增加1并且返回指向v的指针。 int atomic_dec_return(atomic_t * v); 该函数对原子类型的变量v原子地减1并且返回指向v的指针。 应用场合: 原子操作通常用于实现资源的引用计数,在TCP/IP协议栈的IP碎片处理中,就使用了引用计数,碎片队列结构struct ipq描述了一个IP碎片,字段refcnt就是引用计数器,它的类型为atomic_t,当创建IP碎片时(在函数ip_frag_create中),使用atomic_set函数把它设置为1,当引用该IP碎片时,就使用函数atomic_inc把引用计数加1,当不需要引用该IP碎片时,就使用函数ipq_put来释放该IP碎片,ipq_put使用函数atomic_dec_and_test把引用计数减1并判断引用计数是否为0,如果是就释放IP碎片。函数ipq_kill把IP碎片从ipq队列中删除,并把该删除的IP碎片的引用计数减1(通过使用函数atomic_dec实现)。

3、信号量(semaphore)

Linux内核的信号量在概念和原理上与用户态的System V的IPC机制信号量是一样的,但是它绝不可能在内核之外使用,因此它与System V的IPC机制信号量毫不相干。 信号量在创建时需要设置一个初始值,表示同时可以有几个任务可以访问该信号量保护的共享资源,初始值为1就变成互斥锁(Mutex),即同时只能有一个任务可以访问信号量保护的共享资源。 一个任务要想访问共享资源,首先必须得到信号量,获取信号量的操作将把信号量的值减1,若当前信号量的值为负数,表明无法获得信号量,该任务必须挂起在该信号量的等待队列等待该信号量可用;若当前信号量的值为非负数,表示可以获得信号量,因而可以立刻访问被该信号量保护的共享资源。当任务访问完被信号量保护的共享资源后,必须释放信号量,释放信号量通过把信号量的值加1实现,如果信号量的值为非正数,表明有任务等待当前信号量,因此它也唤醒所有等待该信号量的任务。 DECLARE_MUTEX(name) 该宏声明一个信号量name并初始化它的值为0,即声明一个互斥锁。 DECLARE_MUTEX_LOCKED(name) 该宏声明一个互斥锁name,但把它的初始值设置为0,即锁在创建时就处在已锁状态。因此对于这种锁,一般是先释放后获得。 void sema_init (struct semaphore *sem, int val); 该函用于数初始化设置信号量的初值,它设置信号量sem的值为val。 void init_MUTEX (struct semaphore *sem); 该函数用于初始化一个互斥锁,即它把信号量sem的值设置为1。 void init_MUTEX_LOCKED (struct semaphore *sem); 该函数也用于初始化一个互斥锁,但它把信号量sem的值设置为0,即一开始就处在已锁状态。 void down(struct semaphore * sem); 该函数用于获得信号量sem,它会导致睡眠,因此不能在中断上下文(包括IRQ上下文和softirq上下文)使用该函数。该函数将把sem的值减1,如果信号量sem的值非负,就直接返回,否则调用者将被挂起,直到别的任务释放该信号量才能继续运行。 int down_interruptible(struct semaphore * sem); 该函数功能与down类似,不同之处为,down不会被信号(signal)打断,但down_interruptible能被信号打断,因此该函数有返回值来区分是正常返回还是被信号中断,如果返回0,表示获得信号量正常返回,如果被信号打断,返回-EINTR。 int down_trylock(struct semaphore * sem); 该函数试着获得信号量sem,如果能够立刻获得,它就获得该信号量并返回0,否则,表示不能获得信号量sem,返回值为非0值。因此,它不会导致调用者睡眠,可以在中断上下文使用。 void up(struct semaphore * sem); 该函数释放信号量sem,即把sem的值加1,如果sem的值为非正数,表明有任务等待该信号量,因此唤醒这些等待者。 应用场合 信号量在绝大部分情况下作为互斥锁使用,下面以console驱动系统为例说明信号量的使用。 在内核源码树的kernel/printk.c中,使用宏DECLARE_MUTEX声明了一个互斥锁console_sem,它用于保护console驱动列表console_drivers以及同步对整个console驱动系统的访问,其中定义了函数acquire_console_sem来获得互斥锁console_sem,定义了release_console_sem来释放互斥锁console_sem,定义了函数try_acquire_console_sem来尽力得到互斥锁console_sem。这三个函数实际上是分别对函数down,up和down_trylock的简单包装。需要访问console_drivers驱动列表时就需要使用acquire_console_sem来保护console_drivers列表,当访问完该列表后,就调用release_console_sem释放信号量console_sem。函数console_unblank,console_device,console_stop,console_start,register_console和unregister_console都需要访问console_drivers,因此它们都使用函数对acquire_console_sem和release_console_sem来对console_drivers进行保护。

4、读写信号量(rw_semaphore)

读写信号量对访问者进行了细分,或者为读者,或者为写者,读者在保持读写信号量期间只能对该读写信号量保护的共享资源进行读访问,如果一个任务除了需要读,可能还需要写,那么它必须被归类为写者,它在对共享资源访问之前必须先获得写者身份,写者在发现自己不需要写访问的情况下可以降级为读者。读写信号量同时拥有的读者数不受限制,也就说可以有任意多个读者同时拥有一个读写信号量。如果一个读写信号量当前没有被写者拥有并且也没有写者等待读者释放信号量,那么任何读者都可以成功获得该读写信号量;否则,读者必须被挂起直到写者释放该信号量。如果一个读写信号量当前没有被读者或写者拥有并且也没有写者等待该信号量,那么一个写者可以成功获得该读写信号量,否则写者将被挂起,直到没有任何访问者。因此,写者是排他性的,独占性的。 读写信号量有两种实现,一种是通用的,不依赖于硬件架构,因此,增加新的架构不需要重新实现它,但缺点是性能低,获得和释放读写信号量的开销大;另一种是架构相关的,因此性能高,获取和释放读写信号量的开销小,但增加新的架构需要重新实现。在内核配置时,可以通过选项去控制使用哪一种实现。 读写信号量的相关API: DECLARE_RWSEM(name) 该宏声明一个读写信号量name并对其进行初始化。 void init_rwsem(struct rw_semaphore *sem); 该函数对读写信号量sem进行初始化。 void down_read(struct rw_semaphore *sem); 读者调用该函数来得到读写信号量sem。该函数会导致调用者睡眠,因此只能在进程上下文使用。 int down_read_trylock(struct rw_semaphore *sem); 该函数类似于down_read,只是它不会导致调用者睡眠。它尽力得到读写信号量sem,如果能够立即得到,它就得到该读写信号量,并且返回1,否则表示不能立刻得到该信号量,返回0。因此,它也可以在中断上下文使用。 void down_write(struct rw_semaphore *sem); 写者使用该函数来得到读写信号量sem,它也会导致调用者睡眠,因此只能在进程上下文使用。 int down_write_trylock(struct rw_semaphore *sem); 该函数类似于down_write,只是它不会导致调用者睡眠。该函数尽力得到读写信号量,如果能够立刻获得,就获得该读写信号量并且返回1,否则表示无法立刻获得,返回0。它可以在中断上下文使用。 void up_read(struct rw_semaphore *sem); 读者使用该函数释放读写信号量sem。它与down_read或down_read_trylock配对使用。如果down_read_trylock返回0,不需要调用up_read来释放读写信号量,因为根本就没有获得信号量。 void up_write(struct rw_semaphore *sem); 写者调用该函数释放信号量sem。它与down_write或down_write_trylock配对使用。如果down_write_trylock返回0,不需要调用up_write,因为返回0表示没有获得该读写信号量。 void downgrade_write(struct rw_semaphore *sem); 该函数用于把写者降级为读者,这有时是必要的。因为写者是排他性的,因此在写者保持读写信号量期间,任何读者或写者都将无法访问该读写信号量保护的共享资源,对于那些当前条件下不需要写访问的写者,降级为读者将,使得等待访问的读者能够立刻访问,从而增加了并发性,提高了效率。 读写信号量适于在读多写少的情况下使用,在linux内核中对进程的内存映像描述结构的访问就使用了读写信号量进行保护。在Linux中,每一个进程都用一个类型为task_t或struct task_struct的结构来描述,该结构的类型为struct mm_struct的字段mm描述了进程的内存映像,特别是mm_struct结构的mmap字段维护了整个进程的内存块列表,该列表将在进程生存期间被大量地遍利或修改,因此mm_struct结构就有一个字段mmap_sem来对mmap的访问进行保护,mmap_sem就是一个读写信号量,在proc文件系统里有很多进程内存使用情况的接口,通过它们能够查看某一进程的内存使用情况,命令free、ps和top都是通过proc来得到内存使用信息的,proc接口就使用down_read和up_read来读取进程的mmap信息。当进程动态地分配或释放内存时,需要修改mmap来反映分配或释放后的内存映像,因此动态内存分配或释放操作需要以写者身份获得读写信号量mmap_sem来对mmap进行更新。系统调用brk和munmap就使用了down_write和up_write来保护对mmap的访问。

5、自旋锁(spinlock)

自旋锁与互斥锁有点类似,只是自旋锁不会引起调用者睡眠,如果自旋锁已经被别的执行单元保持,调用者就一直循环在那里看是否该自旋锁的保持者已经释放了锁,"自旋"一词就是因此而得名。由于自旋锁使用者一般保持锁时间非常短,因此选择自旋而不是睡眠是非常必要的,自旋锁的效率远高于互斥锁。 信号量和读写信号量适合于保持时间较长的情况,它们会导致调用者睡眠,因此只能在进程上下文使用(_trylock的变种能够在中断上下文使用),而自旋锁适合于保持时间非常短的情况,它可以在任何上下文使用。如果被保护的共享资源只在进程上下文访问,使用信号量保护该共享资源非常合适,如果对共巷资源的访问时间非常短,自旋锁也可以。但是如果被保护的共享资源需要在中断上下文访问(包括底半部即中断处理句柄和顶半部即软中断),就必须使用自旋锁。 自旋锁保持期间是抢占失效的,而信号量和读写信号量保持期间是可以被抢占的。自旋锁只有在内核可抢占或SMP的情况下才真正需要,在单CPU且不可抢占的内核下,自旋锁的所有操作都是空操作。 跟互斥锁一样,一个执行单元要想访问被自旋锁保护的共享资源,必须先得到锁,在访问完共享资源后,必须释放锁。如果在获取自旋锁时,没有任何执行单元保持该锁,那么将立即得到锁;如果在获取自旋锁时锁已经有保持者,那么获取锁操作将自旋在那里,直到该自旋锁的保持者释放了锁。 无论是互斥锁,还是自旋锁,在任何时刻,最多只能有一个保持者,也就说,在任何时刻最多只能有一个执行单元获得锁。

自旋锁的API有: spin_lock_init(x) 该宏用于初始化自旋锁x。自旋锁在真正使用前必须先初始化。该宏用于动态初始化。 DEFINE_SPINLOCK(x) 该宏声明一个自旋锁x并初始化它。该宏在2.6.11中第一次被定义,在先前的内核中并没有该宏。 SPIN_LOCK_UNLOCKED 该宏用于静态初始化一个自旋锁。 DEFINE_SPINLOCK(x)等同于spinlock_t x = SPIN_LOCK_UNLOCKED spin_is_locked(x) 该宏用于判断自旋锁x是否已经被某执行单元保持(即被锁),如果是,返回真,否则返回假。 spin_unlock_wait(x) 该宏用于等待自旋锁x变得没有被任何执行单元保持,如果没有任何执行单元保持该自旋锁,该宏立即返回,否则将循环在那里,直到该自旋锁被保持者释放。 spin_trylock(lock) 该宏尽力获得自旋锁lock,如果能立即获得锁,它获得锁并返回真,否则不能立即获得锁,立即返回假。它不会自旋等待lock被释放。 spin_lock(lock) 该宏用于获得自旋锁lock,如果能够立即获得锁,它就马上返回,否则,它将自旋在那里,直到该自旋锁的保持者释放,这时,它获得锁并返回。总之,只有它获得锁才返回。 spin_unlock(lock) 该宏释放自旋锁lock,它与spin_trylock或spin_lock配对使用。如果spin_trylock返回假,表明没有获得自旋锁,因此不必使用spin_unlock释放。

spin_lock_irqsave(lock, flags) 该宏获得自旋锁的同时把标志寄存器的值保存到变量flags中并失效本地中断。

spin_unlock_irqrestore(lock, flags) 该宏释放自旋锁lock的同时,也恢复标志寄存器的值为变量flags保存的值。它与spin_lock_irqsave配对使用。 spin_lock_irq(lock) 该宏类似于spin_lock_irqsave,只是该宏不保存标志寄存器的值。 spin_lock_bh(lock) 该宏在得到自旋锁的同时失效本地软中断。 spin_unlock_irq(lock) 该宏释放自旋锁lock的同时,也使能本地中断。它与spin_lock_irq配对应用。 spin_unlock_bh(lock) 该宏释放自旋锁lock的同时,也使能本地的软中断。它与spin_lock_bh配对使用。 spin_trylock_irqsave(lock, flags) 该宏如果获得自旋锁lock,它也将保存标志寄存器的值到变量flags中,并且失效本地中断(硬中断和软中断),如果没有获得锁,它什么也不做。因此如果能够立即获得锁,它等同于spin_lock_irqsave,如果不能获得锁,它等同于spin_trylock。如果该宏获得自旋锁lock,那需要使用spin_unlock_irqrestore来释放。 spin_trylock_irq(lock) 该宏类似于spin_trylock_irqsave,只是该宏不保存标志寄存器。如果该宏获得自旋锁lock,需要使用spin_unlock_irq来释放。 spin_trylock_bh(lock) 该宏如果获得了自旋锁,它也将失效本地软中断。如果得不到锁,它什么也不做。因此,如果得到了锁,它等同于spin_lock_bh,如果得不到锁,它等同于spin_trylock。如果该宏得到了自旋锁,需要使用spin_unlock_bh来释放。 spin_can_lock(lock) 该宏用于判断自旋锁lock是否能够被锁,它实际是spin_is_locked取反。如果lock没有被锁,它返回真,否则,返回假。该宏在2.6.11中第一次被定义,在先前的内核中并没有该宏。 获得自旋锁和释放自旋锁有好几个版本,因此让读者知道在什么样的情况下使用什么版本的获得和释放锁的宏是非常必要的: 1)相同CPU上的执行单元(存在软中断)上下文,使用spin_lock_bh和spin_unlock_bh:

如果被保护的共享资源只在进程上下文访问和软中断上下文访问,那么当在进程上下文访问共享资源时,可能被软中断打断,从而可能进入软中断上下文来对被保护的共享资源访问,因此对于这种情况,对共享资源的访问必须使用spin_lock_bh和spin_unlock_bh来保护。当然使用spin_lock_irqsave和spin_unlock_irqrestore(或者spin_lock_irq和spin_unlock_irq)也可以,它们失效了本地硬中断,失效硬中断隐式地也失效了软中断。但是使用spin_lock_bh和spin_unlock_bh是最恰当的,它比其他两个效率高。

如果被保护的共享资源只在进程上下文和tasklet或timer上下文访问,那么应该使用与上面情况相同的获得和释放锁的宏,因为tasklet(linux中断处理机制中的软中断延迟机制)和timer是用软中断实现的。

如果被保护的共享资源只在一个tasklet或timer上下文访问,那么不需要任何自旋锁保护,因为同一个tasklet或timer只能在一个CPU上运行,即使是在SMP环境下也是如此。实际上tasklet在调用tasklet_schedule标记其需要被调度时已经把该tasklet绑定到当前CPU,因此同一个tasklet决不可能同时在其他CPU上运行。timer也是在其被使用add_timer添加到timer队列中时已经被帮定到当前CPU,所以同一个timer绝不可能运行在其他CPU上。当然同一个tasklet有两个实例同时运行在同一个CPU就更不可能了。

2)相同CPU上的执行单元(存在硬中断)上下文,使用spin_lock_irq和spin_unlock_irq(或者spin_lock_irqsave和spin_unlock_irqrestore):

如果被保护的共享资源在软中断(包括tasklet和timer)或进程上下文和硬中断上下文访问,那么在软中断或进程上下文访问期间,可能被硬中断打断,从而进入硬中断上下文对共享资源进行访问,因此,在进程或软中断上下文需要使用spin_lock_irq和spin_unlock_irq来保护对共享资源的访问。而在中断处理句柄中使用什么版本,需依情况而定,如果只有一个中断处理句柄访问该共享资源,那么在中断处理句柄中仅需要spin_lock和spin_unlock来保护对共享资源的访问就可以了。因为在执行中断处理句柄期间,不可能被同一CPU上的软中断或进程打断。但是如果有不同的中断处理句柄访问该共享资源,那么需要在中断处理句柄中使用spin_lock_irq和spin_unlock_irq来保护对共享资源的访问。

在使用spin_lock_irq和spin_unlock_irq的情况下,完全可以用spin_lock_irqsave和spin_unlock_irqrestore取代,那具体应该使用哪一个也需要依情况而定,如果可以确信在对共享资源访问前中断是使能的,那么使用spin_lock_irq更好一些,因为它比spin_lock_irqsave要快一些,但是如果你不能确定是否中断使能,那么使用spin_lock_irqsave和spin_unlock_irqrestore更好,因为它将恢复访问共享资源前的中断标志而不是直接使能中断。当然,有些情况下需要在访问共享资源时必须中断失效,而访问完后必须中断使能,这样的情形使用spin_lock_irq和spin_unlock_irq最好。

3)不同的CPU上的执行单元(存在软中断或硬中断),上下文使用spin_lock和spin_unlock:

如果被保护的共享资源只在两个或多个tasklet或timer上下文访问,那么对共享资源的访问仅需要用spin_lock和spin_unlock来保护,不必使用_bh版本,因为当tasklet或timer运行时,不可能有其他tasklet或timer在当前CPU上运行。 如果被保护的共享资源只在一个软中断(tasklet和timer除外)上下文访问,那么这个共享资源需要用spin_lock和spin_unlock来保护,因为同样的软中断可以同时在不同的CPU上运行。

如果被保护的共享资源在两个或多个软中断上下文访问,那么这个共享资源当然更需要用spin_lock和spin_unlock来保护,不同的软中断能够同时在不同的CPU上运行。

spin_lock用于阻止在不同CPU上的执行单元对共享资源的同时访问以及不同进程上下文互相抢占导致的对共享资源的非同步访问,而中断失效和软中断失效却是为了阻止在同一CPU上软中断或中断对共享资源的非同步访问。

6、大内核锁

大内核锁(BKL)的设计是在kernel hacker们对多处理器的同步还没有十足把握时,引入的大粒度锁。 设计思想是,一旦某个内核路径获取了这把锁,那么其他所有的内核路径都不能再获取到这把锁。 自旋锁加锁的对象一般是一个全局变量,大内核锁加锁的对象是一段代码,里面可能包含多个全局变量。 那么他带来的问题是,虽然A只需要互斥访问全局变量a,但附带锁了全局变量b,从而导致B不能访问b了。 大内核锁最先的实现靠一个全局自旋锁,但大家觉得这个锁的开销太大了,影响了实时性,因此后来将自旋锁改成了mutex,但阻塞时间一般不是很长,所以加锁失败的挂起和唤醒也是非常costly 所以后来又改成了自旋锁实现。 大内核锁一般是在文件系统,驱动等中用的比较多。目前kernel hacker们仍然在努力将大内核锁从linux里铲除。 大内核锁有两种实现:分别是自旋锁和mutex锁。

如果是mutex锁实现,自然不能在中断环境下使用大内核锁,因为中断下禁止调度。那么在大内核锁内调度是否可以?我们知道,如果一个内核流程获取到资源后就应该尽快完成操作释放资源,以便下一个竞争者获取到资源。所以资源持有者不得睡眠是一个普遍共识。可是大内核锁不这么认为,持有大内核锁的用户是允许睡眠的-虽然我们并不鼓励这样,但是内核的大内核锁的设计方案里,会在进程切换时,检查当前进程是否持有大内核锁并释放,当重新获取到cpu后,再尝试抓这把大内核锁。也就是说,进程在持有大内核锁时是可以睡眠的,这就带来资源starvation。

基于自旋锁的大内核锁实现:

[cpp] view plain copy

  1. static inline void __lock_kernel(void)
  2. {
  3. preempt_disable();
  4. if (unlikely(!_raw_spin_trylock(&kernel_flag))) {
  5. /*
  6. * If preemption was disabled even before this
  7. * was called, there's nothing we can be polite
  8. * about - just spin.
  9. */
  10. if (preempt_count() > 1) {
  11. _raw_spin_lock(&kernel_flag);
  12. return;
  13. }
  14. /*
  15. * Otherwise, let's wait for the kernel lock
  16. * with preemption enabled..
  17. */
  18. do {
  19. preempt_enable();
  20. while (spin_is_locked(&kernel_flag))
  21. cpu_relax();
  22. preempt_disable();
  23. } while (!_raw_spin_trylock(&kernel_flag));
  24. }
  25. }
  26. void __lockfunc lock_kernel(void)
  27. {
  28. int depth = current->lock_depth+1;
  29. if (likely(!depth))
  30. __lock_kernel();
  31. current->lock_depth = depth;
  32. }

这段代码的意思: 1) 如果当前进程如果不是重复加锁的话,就尝试去抓这把锁,并把锁深度加1。这么做的目的是避免锁重入。 2)实际加锁的时候,先关抢占,如果尝试加锁失败,则会根据调用lock_kernel之前关抢占与否,来决定是闷头死转,还是大开门户的轮询。 如果是mutex实现的大内核锁kernel_lock,则第2步直接mutex_lock--要么成功要么阻塞。 之前我们提到,在进程发生切换时,会检查当前进程是否持有大内核锁,这是在schedule里做的。

[cpp] view plain copy

  1. asmlinkage void __sched schedule(void)
  2. {
  3. release_kernel_lock(prev);
  4. context_switch();
  5. reacquire_kernel_lock(current);
  6. }

release_kernel_lock会判断如果当前进程持有大内核锁,则释放锁。 reacquire_kernel_lock在进程再次被调度回来后,检查当前进程在切换之前是否因为持有大内核锁。如果有的话,说明在进程切换时,当前进程的大内核锁被强行释放了,需要再次获取。 需要说明的是自旋锁版本: release_kernel_lock在释放锁之后还会开抢占,因为获取到大内核锁之后会关闭; reacquire_kernel_lock在重新获取到锁之后,会关闭抢占。 重点关注__reacquire_kernel_lock的实现 自旋锁的实现版本: 成功抓到锁之后关抢占,如果抓不到锁,则一直遍历need resched标志直至退出。

注意和lock_kernel比较。 mutex版本就比较扯淡了:

[cpp] view plain copy

  1. int __lockfunc __reacquire_kernel_lock(void)
  2. {
  3. int saved_lock_depth = current->lock_depth;
  4. BUG_ON(saved_lock_depth < 0);
  5. current->lock_depth = -1;
  6. preempt_enable_no_resched();
  7. mutex_lock(&kernel_sem);
  8. preempt_disable();
  9. current->lock_depth = saved_lock_depth;
  10. return 0;
  11. }

之前看到kernel_lock的mutex实现就是一句mutex_lock 而这里的__reacquire_kernel_lock有些细节差别。 1)首先将当前进程的加锁深度设置为-1,代表无人加锁。这么做的意义是,第2步的mutex_lock如果产生调度,再次进入shedule时,不会重复释放大内核锁,因为__reacquire_kernel_lock之前已经释放锁了。 2)接着临时强行开抢占后执行mutex_lock 因为在schedule里是关抢占的,此时不能发生进程切换。 3)如果抓到锁则关抢占 恢复到schedule里调__reacquire_kernel_lock之前的抢占状态 4)将加锁深度恢复到__reacquire_kernel_lock之前的深度 恢复到schedule里调__reacquire_kernel_lock之前的大内核锁持有状态 总而言之,关于大内核锁,记住两点就可以了: 1)由spinlock或者mutex_lock锁住一个全局变量来实现 2)进程切换时会检查当前进程是否持有大内核锁,而采取释放和重获的操作,以支持持有大内核锁的用户代码睡眠。

原文发布于微信公众号 - Golang语言社区(Golangweb)

原文发表时间:2016-09-07

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏Ryan Miao

spring学习遇到的问题汇总

 1.spring注解路由方面的误解 我一直以为在web.xml中配置拦截*.action后,在注解路由的时候必须要xxxx.action。 刚才发现,访问的时...

3336
来自专栏程序员互动联盟

linux设备驱动第五篇:驱动中的并发与竟态

综述 在上一篇介绍了linux驱动的调试方法,这一篇介绍一下在驱动编程中会遇到的并发和竟态以及如何处理并发和竞争。 首先什么是并发与竟态呢?并发(concurr...

35810
来自专栏向治洪

Myexclipse创建Junit测试

. 下载JUnit的jar文件,下载地址在这里 2. 在MyEclipse中新建一个要测试的项目HelloJUnit 3. 添加一个要测试的类HelloJ...

1889
来自专栏xingoo, 一个梦想做发明家的程序员

【Spring实战】—— 16 基于JDBC持久化的事务管理

前面讲解了基于JDBC驱动的Spring的持久化管理,本篇开始则着重介绍下与事务相关的操作。 通过本文你可以了解到: 1 Spring 事务管理的机制 ...

2179
来自专栏Ryan Miao

springmvc学习笔记--json--返回json的日期格式问题

(一)输出json数据 springmvc中使用jackson-mapper-asl即可进行json输出,在配置上有几点: 1.使用mvc:annotation...

47810
来自专栏JavaEE

Thymeleaf的使用前言:一、thymeleaf简介:二、thymeleaf标准方言:三、thymeleaf与springboot集成案例:总结:

最近听说thymeleaf好像也挺流行的,还说是spring官方推荐使用,那thymeleaf究竟是什么呢?spring为什么推荐用它呢?怎么用呢?本文将为你揭...

1442
来自专栏Golang语言社区

Golang同步:锁的使用案例详解

互斥锁 互斥锁是传统的并发程序对共享资源进行访问控制的主要手段。它由标准库代码包sync中的Mutex结构体类型代表。只有两个公开方法 Lock Unlock ...

3918
来自专栏Kirito的技术分享

使用spring validation完成数据后端校验

前言 数据的校验是交互式网站一个不可或缺的功能,前端的js校验可以涵盖大部分的校验职责,如用户名唯一性,生日格式,邮箱格式校验等等常用的校验。但是为了避免用户...

1.1K12
来自专栏程序猿DD

Spring Boot使用@Async实现异步调用:自定义线程池

在之前的Spring Boot基础教程系列中,已经通过《Spring Boot中使用@Async实现异步调用》一文介绍过如何使用 @Async注解来实现异步调用...

6568
来自专栏Java修行之道

SpringMVC中controller接收Json数据

2311

扫码关注云+社区

领取腾讯云代金券