博客
关于我
强烈建议你试试无所不能的chatGPT,快点击我
Linux并发与同步专题 (2)spinlock
阅读量:6516 次
发布时间:2019-06-24

本文共 17587 字,大约阅读时间需要 58 分钟。

关键词:wfe、FIFO ticket-based、spin_lock/spin_trylock/spin_unlock、spin_lock_irq/spin_lock_bh/spin_lock_irqsave

 

《》

《》

《》

《》

《》

《》

《》

《》

 

spinlock同一时刻只能被一个内核代码路径持有,如果有另外一个内核代码路径试图获取一个已经被持有的spinlock,那么该内核代码路径需要一直自旋忙等待,直到锁持有者释放了该锁。

spinlock锁的特性如下:

  • spinlock属于忙等待机制,当无法获取spinlock锁时会不断尝试,直到获取锁为止。
  • 同一时刻只能有一个内核代码路径可以获得所。
  • 要求spinlock锁持有者尽快完成临界区的执行任务。如果临界区执行时间过长,在锁外面忙等待的CPU比较浪费,特别是spinlock临界区里不能睡眠。
  • spinlock锁可以在中断上下文中使用。

 

1. spinlock实现

使用spinlock锁的重要原则是:拥有spinlock锁的临界区代码必须是原子执行,不能休眠和主动调度。

1.1 spinlock数据结构

spinlock的数据结构spinlock_t考虑了不同体系结构和实时性内核的要求。如果打上了RT-patch,就变成了使用rt_mutex。

如果没有使用RT-patch,那么arch_spinlock_t在ARM32体系结构下就对应如下。

typedef struct spinlock {    union {        structrlock;    };} spinlock_t;typedef struct raw_spinlock {     raw_lock;} raw_spinlock_t;#define TICKET_SHIFT    16typedef struct {    union {        u32 slock;----------------------------在Linux 2.6.25之前,spinlock数据结构是一个简单无符号类型变量,slock为1表示锁未被持有,为0或者负数表示锁被持有。        struct __raw_tickets {#ifdef __ARMEB__            u16 next;            u16 owner;#else            u16 owner;            u16 next;#endif        } tickets;    };} arch_spinlock_t;

在Linux  2.6.25内核之后,spinlock实现了一套名为“FIFO ticket-based”算法的spinlock机制。

ticket-based算法的shipinlock仍然使用原来数据结构,但slocl被拆分为两部分。

owner表示锁持有者的等号牌,next表示外面排队队列中末尾者的等号牌

 

1.2 spin_lock()/spin_unlock()/spin_trylock()

spin_lock()函数最终调用__raw_spin_lock()函数来实现。

首先关闭内核抢占,然后调用架构相关的arch_spin_lock()。

static inline void spin_lock(spinlock_t *lock){    raw_spin_lock(&lock->rlock);}#define raw_spin_lock(lock)    (lock)void __lockfunc _raw_spin_lock(raw_spinlock_t *lock){    __raw_spin_lock(lock);}static inline void __raw_spin_lock(raw_spinlock_t *lock){    preempt_disable();--------------------------------------------禁止抢占,这里受CONFIG_PREEMPT_COUNT和CONFIG_PREEMPT开关而不同。    spin_acquire(&lock->dep_map, 0, 0, _RET_IP_);-----------------如果相关调试选项没有打开,是一个空函数。    LOCK_CONTENDED(lock, do_raw_spin_trylock, );--在没有定义CONFIG_LOCK_STAT的情况下,就是直接调用do_raw_spin_lock()。} static inline void do_raw_spin_lock(raw_spinlock_t *lock) __acquires(lock) {
__acquire(lock); (&lock->raw_lock);------------------------------架构相关的0spin lock处理。 } 

  

spin_unlock()和spin_lock()对应,最终调用__raw_spin_unlock()。

分别调用架构相关的arch_spin_unlock(),然后打开抢占。

static inline void spin_unlock(spinlock_t *lock){    raw_spin_unlock(&lock->rlock);}#define raw_spin_unlock(lock)        _raw_spin_unlock(lock)void __lockfunc _raw_spin_unlock(raw_spinlock_t *lock){    __raw_spin_unlock(lock);}static inline void __raw_spin_unlock(raw_spinlock_t *lock){    spin_release(&lock->dep_map, 1, _RET_IP_);---------------------和spin_acquire()对应。    do_raw_spin_unlock(lock);    preempt_enable();----------------------------------------------打开抢占。}static inline void do_raw_spin_unlock(raw_spinlock_t *lock) __releases(lock){    (&lock->raw_lock);-----------------------------架构相关的spin unlock处理。    __release(lock);}

 

spin_trylock()是spin_lock的变种,spin_trylock()尽力获得自旋锁lock,如果能立即获得锁,则获得锁并返回真;如果不能,则返回假。

spin_trylock()不会等待lock被释放。

static inline int spin_trylock(spinlock_t *lock){    return raw_spin_trylock(&lock->rlock);}#define raw_spin_trylock(lock)    __cond_lock(lock, _raw_spin_trylock(lock))int __lockfunc _raw_spin_trylock(raw_spinlock_t *lock){    return __raw_spin_trylock(lock);}static inline int __raw_spin_trylock(raw_spinlock_t *lock){    preempt_disable();    if (do_raw_spin_trylock(lock)) {        spin_acquire(&lock->dep_map, 0, 1, _RET_IP_);        return 1;    }    preempt_enable();    return 0;}static inline int do_raw_spin_trylock(raw_spinlock_t *lock){    return arch_spin_trylock(&(lock)->raw_lock);}

 

 

1.2.1 spinlock临界区为什么不允许发生抢占?

如果spinlock临界区中允许抢占,那么如果临界区内发生中断,中断返回时会去检查抢占调度。

这里有两个问题,一是抢占调度相当于持有锁的进程睡眠,违背了spinlock锁不能睡眠和快速执行完成的设计;

二是抢占调度进程也有可能会去申请spinlock锁,那么会导致发生死锁。

1.3 arch_spin_lock()/arch_spin_unlock()/arch_spin_trylock()

通过上面的分析可知,spin_lock()/spin_unlock()的核心是架构相关的部分。

static inline void arch_spin_lock(arch_spinlock_t *lock){    unsigned long tmp;    u32 newval;    arch_spinlock_t lockval;    prefetchw(&lock->slock);    __asm__ __volatile__("1:    ldrex    %0, [%3]\n""    add    %1, %0, %4\n""    strex    %2, %1, [%3]\n""    teq    %2, #0\n""    bne    1b"    : "=&r" (lockval), "=&r" (newval), "=&r" (tmp)    : "r" (&lock->slock), "I" (1 << TICKET_SHIFT)-----------------------------TICKET_SHIFT为16,也即lock->tickets.next++。    : "cc");    while (lockval.tickets.next != lockval.tickets.owner) {-------------------next是当前进程对应锁的等号牌,判断owner和next是否相等。如相等表示CPU成功获取了spinlock锁,arch_spin_lock()返回;如不等,则调用wfe让CPU进入等待状态。        wfe();        lockval.tickets.owner = ACCESS_ONCE(lock->tickets.owner);-------------更新整个系统锁持有者的等号牌,lockval.tickets.owner一直在变,而lockval.tickets.next是当前位置持锁等号牌,不变。    }    smp_mb();-----------------------------------------------------------------内存屏障}

 

 arch_spin_unlock()更新owner域的值,并且发送指令唤醒CPU。

static inline void arch_spin_unlock(arch_spinlock_t *lock){    smp_mb();    lock->tickets.owner++;---------------------------------------------------更新owner,表示所得持有者转到下一个临界区。    dsb_sev();}

 

可以看出arch_spin_trylock()并没有类似arch_spin_lock()一样执行wfe指令,所以会直接返回1或者0.

所以使用spin_trylock()的代码路径不会阻塞,它会导致其他欲持有该锁的代码路径阻塞。

在使用spin_trylock()成功获取锁之后,仍然需要使用spin_unlock()解锁。

static inline int arch_spin_trylock(arch_spinlock_t *lock){    unsigned long contended, res;    u32 slock;    prefetchw(&lock->slock);    do {        __asm__ __volatile__(        "    ldrex    %0, [%3]\n"        "    mov    %2, #0\n"        "    subs    %1, %0, %0, ror #16\n"        "    addeq    %0, %0, %4\n"        "    strexeq    %2, %0, [%3]"        : "=&r" (slock), "=&r" (contended), "=&r" (res)        : "r" (&lock->slock), "I" (1 << TICKET_SHIFT)        : "cc");    } while (res);    if (!contended) {        smp_mb();        return 1;    } else {        return 0;    }}

 

1.3.1 wfe和wfi对比

wfi和wfe指令都是让ARM核进入standby睡眠模式。wfi是直到有wfi唤醒事件发生才会唤醒CPU,wfe是直到wfe唤醒事件发生,这两类事件大部分相同。

唯一不同之处在于wfr可以被其他CPU上的sev指令唤醒,sec指令用于修改event寄存器的指令。

1.3.2 smp_mb和dsb_sev

smp_mb调用dmb指令来保证把调用函数之前所有的访问内存指令都执行完成。

dsb_sev()包含两个指令dsb和sev。dsb指令保证之前的owner与已经写入内存中;sev指令来唤醒通过wfe指令进入睡眠状态的CPU。

此处arch_spin_lock()的wfe()等待处被唤醒,进行owner更新以及和next比较。

2. spinlock变种

上面是spinlock最常见的形式spin_lock()/spin_trylock()/spin_unlock()。

spinlock还有其他一些变种。

2.1 irq变种

2.1.1 为什么需要irq变种

假设临界区有链表操作需要spinlock来保护。

当处于临界区发生了外部硬件中断,此时系统暂停当前进程的执行转而去处理该中断。

假设中断处理程序恰巧也要操作该链表,链表的操作是一个临界区,所以在操作之前要调用spin_lock()函数来对该链表进行保护。

中断处理函数试图去获取该spinlock,但因为它已经被别人持有了,于是导致中断处理函数进入忙等待状态或者wfe睡眠状态。

在中断上下文出现忙等待或者睡眠状态是致命的,中断处理程序要求“短“和”快“,锁的持有者因为被中断打断而不能尽快释放锁,而中断处理程序一直在忙等待锁,从而导致死锁的发生。

Linux内核spin_lock_irq()函数在获取spinlock时关闭本地CPU中断,可以解决该问题。

 

2.1.2 spin_lock_irq()/spin_trylock_irq()/spin_unlock_irq()

从下面三个函数的调用关系可以知道,最终跟spin_lock()/spin_trylock()/spin_unlock()相似,只是中间增加了local_irq_disable()/local_irq_enable()。

local_irq_disable()用于关闭本地处理器中断,这样在获取spinlock琐时可以确保不会发生中断,从而避免发生死锁问题。

因此spin_lock_irq()主要防止本地中断处理程序和持有锁者之间存在锁的争用。

spin_lock_irq()代码路径如下:

static inline void spin_lock_irq(spinlock_t *lock){    raw_spin_lock_irq(&lock->rlock);}#define raw_spin_lock_irq(lock)        _raw_spin_lock_irq(lock)void __lockfunc _raw_spin_lock_irq(raw_spinlock_t *lock){    __raw_spin_lock_irq(lock);}static inline void __raw_spin_lock_irq(raw_spinlock_t *lock){    local_irq_disable();-------------------------------------------------------关本地处理器中断    preempt_disable();---------------------------------------------------------禁止抢占    spin_acquire(&lock->dep_map, 0, 0, _RET_IP_);    LOCK_CONTENDED(lock, do_raw_spin_trylock, );}

 

下面是spin_unlock_irq()代码路径,可以看出在spin_lock_irq()和spin_unlock_irq()之间的部分是关本地中断和禁止抢占的。

static inline void spin_unlock_irq(spinlock_t *lock){    raw_spin_unlock_irq(&lock->rlock);}#define raw_spin_unlock_irq(lock)    _raw_spin_unlock_irq(lock)void __lockfunc _raw_spin_unlock_irq(raw_spinlock_t *lock){    __raw_spin_unlock_irq(lock);}static inline void __raw_spin_unlock_irq(raw_spinlock_t *lock){    spin_release(&lock->dep_map, 1, _RET_IP_);    (lock);    local_irq_enable();---------------------------------------------------------打开本地处理器中断    preempt_enable();-----------------------------------------------------------允许抢占}

 

spin_trylock_irq()主要通过raw_spin_trylock(),所以这里和spin_trylock()的区别也仅仅是关中断/开中断。

如果获取锁成功,那么后面会有spin_unlock_irq()来开中断;如果获取失败,直接开中断。

static inline int spin_trylock_irq(spinlock_t *lock){    return raw_spin_trylock_irq(&lock->rlock);}#define raw_spin_trylock_irq(lock) \({ \    local_irq_disable(); \-----------------------------------------------------增加禁止本地处理器中断    (lock) ? \    1 : ({ local_irq_enable(); 0;  }); \---------------------------------------如果获取锁不成功,打开本地处理器中断})

 

2.2 bh变种

bh变种可以对照原生的spinlock,区别在于原生spinlock使用preempt_enable()/preempt_disable()来禁止抢占;而bh变种不但表示了当前处于软中断上下文,还可能会禁止抢占,这取决于SOFTIRQ_LOCK_OFFSET的定义。

spin_lock_bh():

static inline void spin_lock_bh(spinlock_t *lock){    raw_spin_lock_bh(&lock->rlock);}#define raw_spin_lock_bh(lock)        _raw_spin_lock_bh(lock)void __lockfunc _raw_spin_lock_bh(raw_spinlock_t *lock){    __raw_spin_lock_bh(lock);}static inline void __raw_spin_lock_bh(raw_spinlock_t *lock){    __local_bh_disable_ip(_RET_IP_, SOFTIRQ_LOCK_OFFSET);    spin_acquire(&lock->dep_map, 0, 0, _RET_IP_);    LOCK_CONTENDED(lock, do_raw_spin_trylock, );}

 

spin_trylock_bh():

static inline int spin_trylock_bh(spinlock_t *lock){    return raw_spin_trylock_bh(&lock->rlock);}#define raw_spin_trylock_bh(lock) \    __cond_lock(lock, _raw_spin_trylock_bh(lock))int __lockfunc _raw_spin_trylock_bh(raw_spinlock_t *lock){    return __raw_spin_trylock_bh(lock);}static inline int __raw_spin_trylock_bh(raw_spinlock_t *lock){    __local_bh_disable_ip(_RET_IP_, SOFTIRQ_LOCK_OFFSET);    if (do_raw_spin_trylock(lock)) {        spin_acquire(&lock->dep_map, 0, 1, _RET_IP_);        return 1;    }    __local_bh_enable_ip(_RET_IP_, SOFTIRQ_LOCK_OFFSET);    return 0;}

 

spin_unlock_bh():

static inline void spin_unlock_bh(spinlock_t *lock){    raw_spin_unlock_bh(&lock->rlock);}#define raw_spin_unlock_bh(lock)    _raw_spin_unlock_bh(lock)void __lockfunc _raw_spin_unlock_bh(raw_spinlock_t *lock){    __raw_spin_unlock_bh(lock);}static inline void __raw_spin_unlock_bh(raw_spinlock_t *lock){    spin_release(&lock->dep_map, 1, _RET_IP_);    do_raw_spin_unlock(lock);    __local_bh_enable_ip(_RET_IP_, SOFTIRQ_LOCK_OFFSET);}

 

2.3 irqsave变种

下面是irqsave的三个变种函数,这些函数和irq变种基本上一致。

只是local_irq_enable()/local_irq_disable()换成了local_irq_save()/local_irq_restore()。

主要是保存和恢复CPSR寄存器内容,这样做的目的是防止破坏掉中断响应的状态。

spin_lock_irqsave()函数:

#define spin_lock_irqsave(lock, flags)                \do {                                \    raw_spin_lock_irqsave(spinlock_check(lock), flags);    \} while (0)#define raw_spin_lock_irqsave(lock, flags)            \    do {                        \        typecheck(unsigned long, flags);    \        flags = _raw_spin_lock_irqsave(lock);    \    } while (0)unsigned long __lockfunc _raw_spin_lock_irqsave(raw_spinlock_t *lock){    return __raw_spin_lock_irqsave(lock);}static inline unsigned long __raw_spin_lock_irqsave(raw_spinlock_t *lock){    unsigned long flags;    local_irq_save(flags);------------------------------------------------保存中断转改CPSR寄存器到flags,然后关闭本地CPU中断。    preempt_disable();----------------------------------------------------关闭抢占。    spin_acquire(&lock->dep_map, 0, 0, _RET_IP_);    /*     * On lockdep we dont want the hand-coded irq-enable of     * do_raw_spin_lock_flags() code, because lockdep assumes     * that interrupts are not re-enabled during lock-acquire:     */    do_raw_spin_lock_flags(lock, &flags);    return flags;}static inline voiddo_raw_spin_lock_flags(raw_spinlock_t *lock, unsigned long *flags) __acquires(lock){    __acquire(lock);    arch_spin_lock_flags(&lock->raw_lock, *flags);}#define arch_spin_lock_flags(lock, flags) (lock)

 

spin_trylock_irqsave()函数:

#define spin_trylock_irqsave(lock, flags)            \({                                \    raw_spin_trylock_irqsave(spinlock_check(lock), flags); \})#define raw_spin_trylock_irqsave(lock, flags) \({ \    local_irq_save(flags); \    (lock) ? \    1 : ({ local_irq_restore(flags); 0; }); \})

 

spin_unlock_irqrestore()函数:

static inline void spin_unlock_irqrestore(spinlock_t *lock, unsigned long flags){    raw_spin_unlock_irqrestore(&lock->rlock, flags);}#define raw_spin_unlock_irqrestore(lock, flags)        \    do {                            \        typecheck(unsigned long, flags);        \        _raw_spin_unlock_irqrestore(lock, flags);    \    } while (0)void __lockfunc _raw_spin_unlock_irqrestore(raw_spinlock_t *lock, unsigned long flags){    __raw_spin_unlock_irqrestore(lock, flags);}static inline void __raw_spin_unlock_irqrestore(raw_spinlock_t *lock,                        unsigned long flags){    spin_release(&lock->dep_map, 1, _RET_IP_);    (lock);    local_irq_restore(flags);-----------------------------------------恢复flags到寄存器中,并打开处理器中断相应。    preempt_enable();-------------------------------------------------打开抢占。}

 

2.4 preempt_enable()/preempt_disable()和__local_bh_enable_ip()/__local_bh_disable_ip()

这四个函数都是改变进程preempt_count计数的,其中preempt_enable()/preempt_disable()只修改preempt域,表示是否允许抢占。 

#define preempt_enable() \do { \    barrier(); \    preempt_count_dec(); \} while (0)#define preempt_count_dec() preempt_count_sub(1)#define preempt_count_sub(val)    __preempt_count_sub(val)#define preempt_disable() \do { \    preempt_count_inc(); \    barrier(); \} while (0)#define preempt_count_inc() preempt_count_add(1)#define preempt_count_add(val)    __preempt_count_add(val)

 

而__local_bh_enable_ip()/__local_bh_disable_ip()修改的内容则是可变的,具体到bh变种中对应的是SOFTIRQ_LOCK_OFFSET。

#define SOFTIRQ_LOCK_OFFSET (SOFTIRQ_DISABLE_OFFSET + PREEMPT_CHECK_OFFSET)

由上面的定义可知,这里可能会禁止软中断和抢占。

void __local_bh_enable_ip(unsigned long ip, unsigned int cnt){...    preempt_count_sub(cnt - 1);    if (unlikely(!in_interrupt() && local_softirq_pending())) {        /*         * Run softirq if any pending. And do it in its own stack         * as we may be calling this deep in a task call stack already.         */        do_softirq();    }    preempt_count_dec();...}static __always_inline void __local_bh_disable_ip(unsigned long ip, unsigned int cnt){    preempt_count_add(cnt);    barrier();}

 

2.5 local_irq_enable()/local_irq_disable()、local_irq_save()/local_irq_restore()

这四个函数最终都通过架构相关的函数实现。

#define local_irq_enable()    do { raw_local_irq_enable(); } while (0)#define local_irq_disable()    do { raw_local_irq_disable(); } while (0)#define local_irq_save(flags)                    \    do {                            \        raw_local_irq_save(flags);            \    } while (0)#define local_irq_restore(flags) do { raw_local_irq_restore(flags); } while (0)#define raw_local_irq_disable()        arch_local_irq_disable()#define raw_local_irq_enable()        arch_local_irq_enable()#define raw_local_irq_save(flags)            \    do {                        \        typecheck(unsigned long, flags);    \        flags = arch_local_irq_save();        \    } while (0)#define raw_local_irq_restore(flags)            \    do {                        \        typecheck(unsigned long, flags);    \        arch_local_irq_restore(flags);        \    } while (0)/* * Disable IRQs */static inline void arch_local_irq_disable(void){    unsigned long temp;    asm volatile(        "    mrs    %0, cpsr    @ arch_local_irq_disable\n"        "    orr    %0, %0, #128\n"        "    msr    cpsr_c, %0"        : "=r" (temp)        :        : "memory", "cc");}/* * Enable IRQs */static inline void arch_local_irq_enable(void){    unsigned long temp;    asm volatile(        "    mrs    %0, cpsr    @ arch_local_irq_enable\n"        "    bic    %0, %0, #128\n"        "    msr    cpsr_c, %0"        : "=r" (temp)        :        : "memory", "cc");}/* * Save the current interrupt enable state & disable IRQs */static inline unsigned long arch_local_irq_save(void){    unsigned long flags, temp;    asm volatile(        "    mrs    %0, cpsr    @ arch_local_irq_save\n"        "    orr    %1, %0, #128\n"        "    msr    cpsr_c, %1"        : "=r" (flags), "=r" (temp)        :        : "memory", "cc");    return flags;}static inline void arch_local_irq_restore(unsigned long flags){    asm volatile(        "    msr    " IRQMASK_REG_NAME_W ", %0    @ local_irq_restore"        :        : "r" (flags)        : "memory", "cc");}

 

3. spin_lock()和raw_spin_lock()

对于没有打RT-patch的平台,spin_lock()直接调用raw_spin_lock()。

在传统的include/linux/spinlock.h中定义了spin_lock()。

和RT-pathc后的内核差异在spin_lock()的定义转到spinlock_rt.h中去了。

#ifdef CONFIG_PREEMPT_RT_FULL# include 
#else /* PREEMPT_RT_FULL */...static __always_inline void spin_lock(spinlock_t *lock){ raw_spin_lock(&lock->rlock);}...#endif /* !PREEMPT_RT_FULL */

 

Linux的RT-patch旨在提升Linux内核的实时性,它允许在spinlock锁的临界区内被强占,且临界区内允许进程睡眠等到,这样会导致spinlock语义被修改。

当打开CONFIG_PREEMPT_RT_FULL选项后,spin_lock()的工作就从raw_spin_lock()变成了rt_spin_lock()。 

rt_spin_lock()依赖于rt_mutex,其中允许睡眠和抢占。

#define spin_lock(lock)            rt_spin_lock(lock)void __lockfunc rt_spin_lock(spinlock_t *lock){    (&lock->lock, , true);    spin_acquire(&lock->dep_map, 0, 0, _RET_IP_);}static inline void rt_spin_lock_fastlock(struct rt_mutex *lock,                     void  (*slowfn)(struct rt_mutex *lock,                             bool mg_off),                     bool do_mig_dis){    might_sleep_no_state_check();    if (do_mig_dis)        migrate_disable();    if (likely(rt_mutex_cmpxchg_acquire(lock, NULL, current)))        rt_mutex_deadlock_account_lock(lock, current);    else        slowfn(lock, do_mig_dis);}static void  noinline __sched rt_spin_lock_slowlock(struct rt_mutex *lock,                            bool mg_off){...}

 

内核中真正不允许睡眠的地方修改为使用raw_spin_lock(),其它地方使用spin_lock()。

spin_lock()和raw_spin_lock()的区别在于:在绝对不允许被强占和睡眠的临界区,应该使用raw_spin_lock(),否则使用spin_lock()。

 

转载地址:http://udofo.baihongyu.com/

你可能感兴趣的文章
Java学习笔记(1)
查看>>
我的友情链接
查看>>
c++类模板深度剖析
查看>>
Xshell远程连接VMware如何修改网卡配置文件
查看>>
/proc/sys/net/ipv4详解(1)
查看>>
rpm命令浅析
查看>>
第一篇博文
查看>>
Windows SQL2008数据库系列一数据的导入导出
查看>>
web应用程序资源作用顺序测试报告
查看>>
华为以太网基础(二)
查看>>
制作VBS病毒文件
查看>>
filebeat 6.0以后版本设置index名字
查看>>
关于虚函数
查看>>
Oracle 11g R2在CentOS 5.5服务器上的安装(中)
查看>>
我的友情链接
查看>>
nmap原理及用法
查看>>
R语言进行文件夹操作示例(转)
查看>>
easyui---修改删除查询
查看>>
MySql安装部署及脚本自动化安装
查看>>
offsetof与container_of宏[总结]
查看>>