如果需要调用copy\u to\u用户，如何使用旋转锁？

我已经编写了一个小驱动程序来读取一些数据并将其提供给用户。我的驱动程序可以被多个应用程序使用，即它是可重入的驱动程序，因此使用旋转锁。但是我发现

copy\u to\u user

不应该在保持旋转锁的情况下调用<以下代码中的code>char\u device\u buf为共享数据；我必须保护它。除了互斥锁之外，是否有其他机制可以使用自旋锁和

复制到用户

static ssize_t char_dev_read(struct file *file,
                                char *buf,
                                size_t lbuf,
                                loff_t *ppos)
    {
            int maxbytes; /* number of bytes from ppos to MAX_LENGTH */
            int bytes_to_do; /* number of bytes to read */
            int nbytes; /* number of bytes actually read */

            maxbytes = MAX_LENGTH - *ppos;

            if( maxbytes > lbuf ) bytes_to_do = lbuf;
            else bytes_to_do = maxbytes;

            if( bytes_to_do == 0 ) {
                    printk("Reached end of device\n");
                    return -ENOSPC; /* Causes read() to return EOF */
            }

       /* Tesing for accidental release */
    //              accidental_release(); 

            printk(KERN_DEBUG "READER: trying for critical region lock \n");

            spin_lock(&myspin);/*begin of critical region */

                    printk(KERN_DEBUG "READER : acquired lock: executing critical code\n");
                    nbytes = bytes_to_do -
                             copy_to_user( buf, /* to */
                                           char_device_buf + *ppos, /* from */
                                           bytes_to_do ); /* how many bytes */


            spin_unlock(&myspin); /* end of critical region */
            *ppos += nbytes;
            return nbytes;
    }

---

copy{to，from}\u user

不应该在旋转锁中使用的原因是这些函数可以休眠。想象一下这个场景（在单处理器机器上）：

处理

mmap（）

ed文件

该进程调用驱动程序，向

mmap（）

ed区域提供地址

您的代码运行、锁定，然后

copy_to_user

会导致该地址出现页面错误-内存不存在，因此进程将进入休眠状态，直到数据从磁盘中出来

内核调度进程B，它以同样的方式调用驱动程序

死锁-进程A正在等待IO在锁内返回，但不会被调度，因为B正在等待相同的锁被解锁

---

除非100%保证

copy{to，from}{u user

不会导致segfault，否则不能使用自旋锁，而必须使用睡眠锁，例如“互斥锁”。睡眠锁将控制权交给调度程序，而旋转锁则不会。

在多处理器中，进程B将有机会在其他处理器上执行。因此，系统不会停止。一旦页面表被正确加载，它将从睡眠中出来，代码将被很好地执行。我看这里的多处理器没有任何问题。无论如何，自旋锁在单处理器中是没有用的，我们都知道这一点。我不理解您在多处理器上的示例的sleep（）缺点。你能说说关于多处理器环境的问题吗？在多处理器环境中，你可能会遇到同样的问题。假设进程A在保持自旋锁的同时被调度出去。现在，调度器可以将它想要的任何任务放在任何CPU上。假设它无辜地安排所有CPU运行一些代码来锁定该自旋锁，那么就会出现死锁，因为原始线程永远不会醒来释放它。在等待自旋锁的CPU上不能进行调度。

copy_to_user

示例只是需要调度程序睡眠的情况的一个示例。在任何其他情况下，如果您持有一个自旋锁，然后将其调度出去，则可能会出现死锁。因此，一般的假设是，任何持有

自旋锁的进程都不能从其运行的CPU上重新调度，除非关键部分内的代码可能会休眠，这将允许内核在持有自旋锁时重新调度它
spinlock
。