这个自旋锁的实现是否正确？

Question

我是一名学习Linux操作系统内核、内核模块和设备驱动程序的新手。如果你假设多处理器系统提供顺序一致性，你能帮我确认一下自旋锁的以下实现是否正确吗？

struct Lock{
        int locked;
    }

int exchange_value(int* ptr, int val){
    int was;
    wss=*ptr;
    *ptr=val;
    return was;
}
voidacquire(Lock *lock){
    local_irq_disable();
    while(1){
        if(exchange_value(&lock->locked, 1) == 0)
        break;
    }
}

void release(Lock *lock){
    exchange_value(&lock->locked, 0);
    local_irq_enable();
}

如果不正确，你能提供一个更好的例子让我更好地理解吗？很抱歉没有提供任何表扬或更多解释，这是因为我没有完全理解我得到的这段代码。预先感谢您的协助。

Answer 1

这个 spinlock 的实现是否正确？ 不确定，但我不这么认为，因为你问的是 spinock 但你编写的代码在内核中大约是 interrupt handling。那么在某种程度上你可以 link 他们。阅读这篇关于内核中断的https://notes.shichao.io/lkd/ch8/#disabling-bottom-halves。

首先为什么要使用spinlock()机制？

简单的答案是在中断处理程序中实现同步。
如果锁可用，进程将获取它并继续进入临界区并在完成后将其解锁。这类似于互斥体。
但是，如果锁不可用怎么办？有趣的区别就在这里。使用互斥锁，进程将休眠，直到锁可用。但是，在自旋锁的情况下，它会进入紧密循环，不断检查锁，直到它可用。
这是自旋锁的自旋部分。这是为多处理器系统设计的。

API 的自旋锁 ?

首先创建struct spinlock_t的变量为struct spinlock_t my_slock;
将my_slock初始化为spinlock_init(&my_slock);。
在写时间的时候，通过调用spin_lock(&my_slock);放置自旋锁当 reader 应用程序看到自旋锁时，它将等待。
通过调用spin_unlock(&my_slock);

这里是驱动程序，供大家参考spinlock。

#include <linux/module.h>
#include <linux/fs.h>
#include <asm/uaccess.h>
#include <linux/spinlock.h>
#include <linux/delay.h>
static int major;
static spinlock_t slock;
static unsigned int pwait = 10000;
module_param(pwait, int, 0);
/* Default delay is 10 seconds */
/* MilliSeconds */
static int spin_open(struct inode *inode, struct file *filp) {
        return 0;
}
static int spin_close(struct inode *inode, struct file *filp) {
        return 0;
}
static ssize_t spin_read(struct file *filp, char __user *buf,size_t sz, loff_t *fpos) {/* main is read function */
        printk("Read begins: Trying to aquire same spinlock\n");
        spin_lock( &slock ); /* applied the lock .. when reader apps seen it, it will wait */
        printk("Read : Acquired spinlock now !!\n");
        printk("Read done. Releasing the spinlock\n");
        spin_unlock( &slock );
        return 0;
}
static ssize_t spin_write( struct file *filp, const char __user *buf,size_t sz, loff_t *fpos )
{
        printk("Write begins\n");
        spin_lock( &slock );
        printk("Write : Acquired a spinlock...\n");
        mdelay( pwait );
        /* Pretending to do some work */
        printk("Write done. Releasing the spinlock\n");
        spin_unlock( &slock );
        return sz;
}
static struct file_operations spin_fops = {
        .open = spin_open,
        .release = spin_close,
        .read = spin_read,
        .write = spin_write,
        .owner = THIS_MODULE,
};
static int __init start(void) {
        major = register_chrdev(0, "spin", &spin_fops);
        if ( major < 0 ) {
                printk("Error obtaining major number\n");
                return -1;
        }
        else {
                printk("Successfully registered major number %d\n",major);
                printk("create device name = spin \n");
        }
        spin_lock_init( &slock );
        return 0;
}
void stop(void){
        pr_info("module unregistered successfully \n");
        unregister_chrdev(major, "spin");
}
module_init(start);
module_exit(stop);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("achal singh : mail2inda@gmail.com");
MODULE_DESCRIPTION("Syn Technique : Spin lock");

假设您知道如何为您的驱动程序创建 Makefile，如何使用 mknod 或任何其他方法创建设备文件并检查 dmesg。最后写一个用户应用分析。

我希望它能给你关于 spinlock 的基本概念。

这个自旋锁的实现是否正确？

Is this implementation of a spinlock correct?

linux

implementation

operating-system

spinlock

sequential