内核中并发和竞态 互斥体 示例

作用

互斥体是比信号量更为专业的互斥机制，在进程未获取到互斥体后，会判断当前持有进程是否正在另一个 CPU 的临界区上运行，若是，它会假设该进程会很快执行完毕，从而进入自旋状态，否则会进入休眠状态（称为 spin 特性），此特性减少了进程切换的开销，例如当临界区较小时，互斥体比信号量效率高；但也因此导致了等待进程获取互斥体的不公平性，永远是自旋的先获得锁，已经休眠的后获得，自旋的有osq lock限制来保证顺序，休眠的有lock->wait_lock链表来保证顺序，但没有机制来保证自旋和休眠的先后顺序，所以如果在竞争十分激烈的情况下休眠进程甚至会饿死，对此内核有个折中的方案，休眠链表中第一个进程被唤醒时(后续节点不会唤醒，链表还是可以保持顺序)，若又没获取到互斥体，判断情况后又进入休眠，会被设置一个 HANDOFF 标志（HANDOFF 标志并没有使用独立的字段来描述，而是使用了 owner 的 bit1，另外bit2 是 PICKUP 标志，同样是"开后门"待遇的标志位，bit0 为 WAITERS 标志，表示当前 lock->wait_list 上有没有等待者），强制要求互斥体在下次释放后交给此进程，此机制仅解决了极端情况下出现的进程饿死弊端，而获取顺序的不公平性依然存在

特点

1.保护的临界区可以很大，允许有延时（休眠、拷贝等）的操作

2.不会死锁

3.不关闭抢占

互斥体结构体 struct mutex

struct mutex {

/*是一个 task_struct 成员，保存了进程描述符指针值，记录一个锁的属主，
用于实现 mutex 的第一个特性：加锁和解锁由同一个进(线)程完成，
同时还被用来控制加解锁，若 owner != 0,表示当前锁已经被占用，反之该锁未被占用，
因为进程描述符指针总是 8 字节对齐的，所以 owner 的 bit0～bit2 恒为 0 ，
内核使把这三位作为标志位，
bit0：MUTEX_FLAG_WAITERS：指示当前是否有睡眠的等待者，
bit1：MUTEX_FLAG_HANDOFF：指示下一次解锁需要将锁指定交给某个进程，
bit2：MUTEX_FLAG_PICKUP：和 bit1 配合，指定交给某个进程之后需要进程确认的标志位*/
    atomic_long_t       owner;

    spinlock_t      wait_lock;        //一个自旋锁，主要用来保证链表操作的安全性
#ifdef CONFIG_MUTEX_SPIN_ON_OWNER

/*一种锁。同时处于自旋状态的进程可以有多个，但是要尽量避免多个核上运行的进程共享一个全局对象，
因为一旦这个全局对象更新，就会导致其它所有 CPU 上对于该全局对象的 cache 失效，
而这种 cache 失效带来的后果就是 CPU 需要重新从内存中将数据载入到多级 cache 中，开销很大，
在进入自旋之前，如果当前已经有进程正在自旋，此进程会因为获取不到 osq 锁而切换自旋方式，
被阻塞在本地 CPU 上而不是阻塞在 mutex lock 上。
通过使用 percpu 的机制让每个等待进程只阻塞在本地锁变量上，
而不是阻塞在 lock->owner 这个全局锁变量上，只有获取到 osq 锁的进程才阻塞在 lock->owner 上，
这样就保证了 lock->owner 的修改不会导致所有 CPU 的 cache miss */
    struct optimistic_spin_queue osq; /* Spinner MCS lock */

#endif
    
/*用来保存休眠进程信息，休眠模式为 INTERRUPTIBLE，通过此链表唤醒进程，
wait_list同样是全局对象，所以需要使用 wait_lock 来进行数据同步 */
    struct list_head    wait_list;    

#ifdef CONFIG_DEBUG_MUTEXES
    void            *magic;
#endif
#ifdef CONFIG_DEBUG_LOCK_ALLOC
    struct lockdep_map  dep_map;
#endif
};

初始化互斥体，mutex_init(&lock)

#define mutex_init(mutex)                   \
do {                                        \
    static struct lock_class_key __key;     \
                                            \
    __mutex_init((mutex), #mutex, &__key);  \
} while (0)

void __mutex_init(struct mutex *lock, const char *name, struct lock_class_key *key)
{
    atomic_long_set(&lock->owner, 0);        // owner 初始化为 0
    spin_lock_init(&lock->wait_lock);        // 初始化 spin lock
    INIT_LIST_HEAD(&lock->wait_list);        // 初始化链表
#ifdef CONFIG_MUTEX_SPIN_ON_OWNER
    osq_lock_init(&lock->osq);               // 初始化 osq lock
#endif
    debug_mutex_init(lock, name, key);       // debug 相关的接口，暂不讨论
}

lock：定义的互斥体

返回值：无

获取互斥体

void __sched mutex_lock(struct mutex *lock)
{
    might_sleep();

    if (!__mutex_trylock_fast(lock))    //尝试直接加锁
        __mutex_lock_slowpath(lock);    //失败后尝试自旋或休眠
}

休眠进程可被信号打断，被信号唤醒 = -EINTR

int mutex_lock_interruptible(struct mutex *lock)

休眠进程可被kill，被信号杀死 = -EINTR

int mutex_lock_killable(struct mutex *lock)

尝试获取互斥体，不休眠直接返回，成功 = 1，失败 = 0，需要判断返回值再执行解锁操作

int mutex_trylock(struct mutex *lock)

lock：定义的互斥体

返回值：成功 = 0，失败 = !0

释放互斥体，唤醒其他进程

void __sched mutex_unlock(struct mutex *lock)
{
#ifndef CONFIG_DEBUG_LOCK_ALLOC
    if (__mutex_unlock_fast(lock))
        return;
#endif
    __mutex_unlock_slowpath(lock, _RET_IP_);
}

lock：定义的互斥体

返回值：无

获取互斥体状态

int mutex_is_locked(struct mutex *lock)

lock：定义的互斥体

返回值：1 = 已被获取，0 = 未被获取

示例

#include <linux/init.h>
#include <linux/module.h>
#include <linux/cdev.h>
#include <linux/fs.h>
#include <linux/device.h>
#include <linux/slab.h>
#include <linux/uaccess.h>

#define CNAME "mycdev"
struct cdev cdev;
int major = 0;
int minor = 0;
const int count = 3;
struct class *cls;
struct device *dev;
char kbuf[128] = {0};

//1.定义互斥体
struct mutex lock;

int mycdev_open(struct inode *inode, struct file *file){
    //3.获取互斥体
    if(!mutex_trylock(&lock)){
        return -EBUSY;
    }
    printk("%s:%s(%d)\n",__FILE__,__func__,__LINE__);
    return 0;
}

ssize_t mycdev_read(struct file *file, char __user *ubuf, size_t size, loff_t *offs){
    int ret = 0;
    printk("%s:%s(%d)\n",__FILE__,__func__,__LINE__);
    //校验大小
    if(size > sizeof(kbuf)){
        size = sizeof(kbuf);
    }
    //数据传输
    ret = copy_to_user(ubuf, kbuf, size);
    if(ret){
        printk("copy_to_user error\n");
        return -EIO;
    }
    return size;
}

ssize_t mycdev_write(struct file *file, const char __user *ubuf, size_t size, loff_t *offs){
    int ret;
    printk("%s:%s(%d)\n",__FILE__,__func__,__LINE__);
    //校验大小
    if(size > sizeof(kbuf)) size = sizeof(kbuf);
    //数据传输
    ret = copy_from_user(kbuf,ubuf,size);
    if(ret){
        printk("copy_from_user error\n");
        return -EIO;
    }
    return size;
}

int mycdev_close(struct inode*inode, struct file*file){
    printk("%s:%s(%d)\n",__FILE__,__func__,__LINE__);
    //4.释放互斥体
    mutex_unlock(&lock);
    return 0;
}

const struct file_operations fops = {
    .open = mycdev_open,
    .read = mycdev_read,
    .write = mycdev_write,
    .release = mycdev_close,
};

static int __init mycdev_init(void){
    int ret = 0;
    dev_t devno = 0;
    int i = 0;

    //1.初始化cdev
    cdev_init(&cdev,&fops);
    cdev.owner = THIS_MODULE;

    //2.申请设备号
    if(major > 0){
        ret = register_chrdev_region(MKDEV(major,minor),count,CNAME);
        if(ret){
            printk("register_chrdev_region error\n");
            goto ERR1;
        }
    }else if(major == 0){
        ret = alloc_chrdev_region(&devno,minor,count,CNAME);
        if(ret){
            printk("alloc_chrdev_region error\n");
            goto ERR1;
        }
        major = MAJOR(devno);
        minor = MINOR(devno);
    }

    //3.注册
    ret = cdev_add(&cdev,MKDEV(major,minor),count);
    if(ret){
        printk("cdev_add error\n");
        goto ERR2;
    }

    //4.创建设备节点
    cls = class_create(THIS_MODULE,CNAME);
    if(IS_ERR(cls)){
        printk("class_creat error\n");
        goto ERR3;
    }
    for(i = 0; i < count; i++){
        dev = device_create(cls, NULL, MKDEV(major,i), NULL, "mycdev%d",i);
        if(IS_ERR(dev)){
            printk("device_creat error\n");
            goto ERR4;
        }
    }

    //2.初始化互斥体
    mutex_init(&lock);

    return 0;

ERR4:
    for(--i; i >= 0; i--){
        device_destroy(cls, MKDEV(major, i));
    }
    class_destroy(cls);
ERR3:
    cdev_del(&cdev);
ERR2:
    unregister_chrdev_region(MKDEV(major,minor),count);
ERR1:
    return ret;
}

static void __exit mycdev_exit(void){
    int i = 0;
    for(i = 0; i < count; i++){
        device_destroy(cls, MKDEV(major, i));
    }
    class_destroy(cls);
    cdev_del(&cdev);
    unregister_chrdev_region(MKDEV(major, minor), count);
}
module_init(mycdev_init);
module_exit(mycdev_exit);
MODULE_LICENSE("GPL");