ldd3学习之十二(4)：高级字符驱动程序操作--llseek、设备文件的访问控制

旧城等待， 2022-06-18 03:29 294阅读 0赞

**1.llseek**

llseek方法实现了lseek和llseek的系统调用，如果设备操作为定义llseek方法，内核默认通过修改filp->f\_pos而执行定位，filp->f\_pos是文件的当前读取/写入位置，为了使lseek系统调用能正确工作，read和write方法必须通过更新他们收到的偏移量参数来配合。

Scrull的驱动例子

1.  loff\_t scull\_llseek(struct file \*filp, loff\_t off, int whence)  
    
2.  \{   
    
3.      struct scull\_dev \*dev = filp\->private\_data;  
    
4.      loff\_t newpos;  
    
5.    
    
6.      switch(whence) \{   
    
7.       case 0: /\* SEEK\_SET \*/  
    
8.          newpos = off;  
    
9.          break;  
    
10.   
    
11.      case 1: /\* SEEK\_CUR \*/  
    
12.         newpos = filp\->f\_pos \+ off;  
    
13.         break;  
    
14.   
    
15.      case 2: /\* SEEK\_END \*/  
    
16.         newpos = dev\->size \+ off;  
    
17.         break;  
    
18.   
    
19.      default: /\* can't happen \*/  
    
20.         return \-EINVAL;  
    
21.     \}  
    
22.     if (newpos < 0) return \-EINVAL;  
    
23.     filp\->f\_pos = newpos;  
    
24.     return newpos;  
    
25. \}

大多数设备只提供了数据流（比如串口和键盘），而不是数据区，定义这些设备没有意义，在这中情况下，不能简单的不声明llseek操作，因为默认方法是允许定位的，相反，应该在open方法中调用nonseekable\_open，以便通知内核设备不支持llseek，

int nonseekable\_open(struct inode \*inode, struct file \*filp)

该函数会吧给定的filp标记为不可定位；这样内核就不会让这种文件上的lseek调用成功。通过这种方式标记文件，还可以确保通过pread和pwrite系统调用也不能定位文件。

为了完整期间，我们还应该将file\_operations结构中的llseek方法设备为特殊的辅助函数no\_llseek（定义在 ）

**2.设备文件的访问控制**

提供访问控制对于一个设备节点来的可靠性来说有时是至关重要的。这部分的内容只是在open和release方法上做些修改，增加一些检查机制既可。

(1)独享设备

最生硬的访问控制方法是一次只允许一个进程打开设备(独享),最好避免使用这种技术，因为它制约了用户的灵活性。scullsingle设备维护一个atomic\_t变量，称为scull\_s\_available，该变量初值为1，表明设备真正可用，open调用会减小并测试scull\_s\_available，并在其他进程已经打开该设备拒绝访问

1.  static int scull\_s\_open(struct inode \*inode, struct file \*filp)  
    
2.  \{   
    
3.      struct scull\_dev \*dev; /\* device information \*/  
    
4.      dev = container\_of(inode\->i\_cdev, struct scull\_dev, cdev);  
    
5.    
    
6.      if (! atomic\_dec\_and\_test (&scull\_s\_available)) \{   
    
7.          atomic\_inc(&scull\_s\_available);  
    
8.          return \-EBUSY; /\* already open \*/  
    
9.      \}  
    
10.   
    
11.     /\* then, everything else is copied from the bare scull device \*/  
    
12.     if ( ((filp\->f\_flags & O\_ACCMODE) && O\_WRONLY))  
    
13.         scull\_trim(dev);  
    
14.     filp\->private\_data = dev;  
    
15.     return 0; /\* success \*/  
    
16. \}

release则标记设备为不忙

1.  static int scull\_s\_release(struct inode \*inode, struct file \*filp)
2.  \{
3.  atomic\_inc(&scull\_s\_available); /\* release the device \*/
4.  return 0;
5.  \}

建议吧打开标志scull\_s\_available放在私有设备结构里

(2)单用户访问

open调用在第一次打开授权，但它记录下设备的属主，这意味着一个用户可以多次打开设备，晕血多个进程并发的在设备上操作。其他用户不能打开这个设备，这样就避免了外部干扰。

1.  spin\_lock(&scull\_u\_lock);  
    
2.      if (scull\_u\_count &&  
    
3.              (scull\_u\_owner != current\->uid) && /\* allow user \*/  
    
4.              (scull\_u\_owner != current\->euid) && /\* allow whoever did su \*/  
    
5.              !capable(CAP\_DAC\_OVERRIDE)) \{  /\* still allow root \*/  
    
6.          spin\_unlock(&scull\_u\_lock);  
    
7.          return \-EBUSY; /\* \-EPERM would confuse the user \*/  
    
8.      \}  
    
9.    
    
10.     if (scull\_u\_count == 0)  
    
11.         scull\_u\_owner = current\->uid; /\* grab it \*/  
    
12.   
    
13.     scull\_u\_count\+\+;  
    
14.     spin\_unlock(&scull\_u\_lock);

相应的释放函数

1.  static int scull\_u\_release(struct inode \*inode, struct file \*filp)  
    
2.  \{   
    
3.      spin\_lock(&scull\_u\_lock);  
    
4.      scull\_u\_count\-\-; /\* nothing else \*/  
    
5.      spin\_unlock(&scull\_u\_lock);  
    
6.      return 0;  
    
7.  \}

(3)替代EBUSY的阻塞型open

当设备不能访问时返回一个错误，通常这是最合理的方式，但有些情况下可能需要让进程等待设备。

代理EBUSY的一个方法是实现阻塞型open。

1.  static int scull\_w\_open(struct inode \*inode, struct file \*filp)  
    
2.  \{   
    
3.      struct scull\_dev \*dev = &scull\_w\_device; /\* device information \*/  
    
4.    
    
5.      spin\_lock(&scull\_w\_lock);  
    
6.      while (! scull\_w\_available()) \{   
    
7.          spin\_unlock(&scull\_w\_lock);  
    
8.          if (filp\->f\_flags & O\_NONBLOCK) return \-EAGAIN;  
    
9.          if (wait\_event\_interruptible (scull\_w\_wait, scull\_w\_available()))  
    
10.             return \-ERESTARTSYS; /\* tell the fs layer to handle it \*/  
    
11.         spin\_lock(&scull\_w\_lock);  
    
12.     \}  
    
13.     if (scull\_w\_count == 0)  
    
14.         scull\_w\_owner = current\->uid; /\* grab it \*/  
    
15.     scull\_w\_count\+\+;  
    
16.     spin\_unlock(&scull\_w\_lock);  
    
17.   
    
18.     /\* then, everything else is copied from the bare scull device \*/  
    
19.     if ((filp\->f\_flags & O\_ACCMODE) == O\_WRONLY)  
    
20.         scull\_trim(dev);  
    
21.     filp\->private\_data = dev;  
    
22.     return 0; /\* success \*/  
    
23. \}

release方法唤醒所有等待的进程

1.  static int scull\_w\_release(struct inode \*inode, struct file \*filp)  
    
2.  \{   
    
3.      int temp;  
    
4.    
    
5.      spin\_lock(&scull\_w\_lock);  
    
6.      scull\_w\_count\-\-;  
    
7.      temp = scull\_w\_count;  
    
8.      spin\_unlock(&scull\_w\_lock);  
    
9.    
    
10.     if (temp == 0)  
    
11.         wake\_up\_interruptible\_sync(&scull\_w\_wait); /\* awake other uid's \*/  
    
12.     return 0;  
    
13. \}

这类问题(对同一设备的不同的，不兼容的策略)最好通过为每一种访问策略实现一个设备节点的方法来解决。

(4)在打开时复制设备

另一个实现访问控制的方法是，在进程打开设备时创建设备的不同私有副本。

显然这种方法只有在设备没有绑定到某个硬件对象时才能实现，/dev/tty内部也使用了类似的技术，以提供给它的进程一个不同于/dev入口点所表现出的“情景”，如果复制的设备是由软件驱动程序创建，我们称它们为“虚拟设备”--就像所有的虚拟终端都是用同一个物理终端设备一样。

虽然这种访问控制并不常见，但它的实现展示了内核代码可以轻松的改变应用程序看到的外部环境。

1.  /\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*  
    
2.   \*  
    
3.   \* Finally the \`cloned' private device. This is trickier because it  
    
4.   \* involves list management, and dynamic allocation.  
    
5.   \*/  
    
6.    
    
7.  /\* The clone\-specific data structure includes a key field \*/  
    
8.    
    
9.  struct scull\_listitem \{   
    
10.     struct scull\_dev device;  
    
11.     dev\_t key;  
    
12.     struct list\_head list;  
    
13.       
    
14. \};  
    
15.   
    
16. /\* The list of devices, and a lock to protect it \*/  
    
17. static LIST\_HEAD(scull\_c\_list);  
    
18. static spinlock\_t scull\_c\_lock = SPIN\_LOCK\_UNLOCKED;  
    
19.   
    
20. /\* A placeholder scull\_dev which really just holds the cdev stuff. \*/  
    
21. static struct scull\_dev scull\_c\_device;  
    
22.   
    
23. /\* Look for a device or create one if missing \*/  
    
24. static struct scull\_dev \*scull\_c\_lookfor\_device(dev\_t key)  
    
25. \{   
    
26.     struct scull\_listitem \*lptr;  
    
27.   
    
28.     list\_for\_each\_entry(lptr, &scull\_c\_list, list) \{   
    
29.         if (lptr\->key == key)  
    
30.             return &(lptr\->device);  
    
31.     \}  
    
32.   
    
33.     /\* not found \*/  
    
34.     lptr = kmalloc(sizeof(struct scull\_listitem), GFP\_KERNEL);  
    
35.     if (!lptr)  
    
36.         return NULL;  
    
37.   
    
38.     /\* initialize the device \*/  
    
39.     memset(lptr, 0, sizeof(struct scull\_listitem));  
    
40.     lptr\->key = key;  
    
41.     scull\_trim(&(lptr\->device)); /\* initialize it \*/  
    
42.     init\_MUTEX(&(lptr\->device.sem));  
    
43.   
    
44.     /\* place it in the list \*/  
    
45.     list\_add(&lptr\->list, &scull\_c\_list);  
    
46.   
    
47.     return &(lptr\->device);  
    
48. \}  
    
49.   
    
50. static int scull\_c\_open(struct inode \*inode, struct file \*filp)  
    
51. \{   
    
52.     struct scull\_dev \*dev;  
    
53.     dev\_t key;  
    
54.    
    
55.     if (!current\->signal\->tty) \{   
    
56.         PDEBUG("Process \\"%s\\" has no ctl tty\\n", current\->comm);  
    
57.         return \-EINVAL;  
    
58.     \}  
    
59.     key = tty\_devnum(current\->signal\->tty);  
    
60.   
    
61.     /\* look for a scullc device in the list \*/  
    
62.     spin\_lock(&scull\_c\_lock);  
    
63.     dev = scull\_c\_lookfor\_device(key);  
    
64.     spin\_unlock(&scull\_c\_lock);  
    
65.   
    
66.     if (!dev)  
    
67.         return \-ENOMEM;  
    
68.   
    
69.     /\* then, everything else is copied from the bare scull device \*/  
    
70.     if ( (filp\->f\_flags & O\_ACCMODE) == O\_WRONLY)  
    
71.         scull\_trim(dev);  
    
72.     filp\->private\_data = dev;  
    
73.     return 0; /\* success \*/  
    
74. \}  
    
75.   
    
76. static int scull\_c\_release(struct inode \*inode, struct file \*filp)  
    
77. \{   
    
78.     /\*  
    
79.      \* Nothing to do, because the device is persistent.  
    
80.      \* A \`real' cloned device should be freed on last close  
    
81.      \*/  
    
82.     return 0;  
    
83. \}

至此，Linux高级字符驱动程序操作已经学习完毕，（其实这部分已经看过几遍，后续还要继续看，有些没理解透）这部分笔记现在才整理，一方面是因为难度，一方面是实际工作用的不是很多，没有专门花时间来整理。anyway，到目前为止，Linux字符驱动所有基础知识笔记整理完毕，这是个辛苦的过程，但收获很大。再次的，特别感谢**Tekkaman Ninja**大侠，LDD3笔记整理过程中参考了他的大部分，给了我很大帮助(若涉及版权相关，全都归他)。

阅读(1383) | 评论(0) | 转发(3) |

上一篇：ldd3学习之十二(3)：高级字符驱动程序操作--poll/select、异步通知

下一篇：Linux I2C驱动（1）