ldd3学习之三: 字符驱动

分手后的思念是犯贱 2022-06-18 03:21 201阅读 0赞

通过介绍字符设备scull（Simple Character Utility for Loading Localities，区域装载的简单字符工具）的 驱动程序编写，来学习Linux设备驱动的基本知识。scull可以为真正的设备驱动程序提供样板。

1.scull设备

编写驱动程序的第一步，就是定义驱动程序为用户程序提供的能力（机制）。ldd3里用的设备是内存的一部分，可以做任何想做的事情。

scull0-scull3：

这四个设备分别由一个全局且持久的内存区域组成。“ 全局”是指：设备多次被打开，打开它的所有文件描述符可共享该设备的数据。“ 持久”是指：若设备关闭后再打开，数据不会丢失。可以使用常用的命令来访问和测试这个设备，如cp,cat以及shell的I/O重定向等。

scullpipe0-scullpipe3

这四个FIFO设备与管道类似。一个进程读取另一个进程写入的数据，如果有多个进程读取一个设备，就会为数据发生竞争。scullpipe的内部实现将说明在不借助中断的情况下如何实现阻塞式和非阻塞式读/写操作。也可以采用硬件中断与他们的设备保持同步（多采用）。

scullsingle

scullpriv

sculluid

scullwuid

这些设备与scull0相似，但在何时允许open操作方面有一些限制。

scullsingle 一次只允许一个进程使用该驱动程序

scullpriv对每个 虚拟空间（或X终端会话） 是私有的，因为每个控制台的进程获取的内存区不同。

sculluid/scullwuid可以 多次被打开，但 每次只能有一个用户打开，如果一个用户锁定了该设备，sculluid将返回“Device Busy”的错误。

每个scull设备都展示了驱动程序不同的功能，也提出了不同的难点。

2.主次设备号

主设备号表示设备对应的驱动程序；次设备号由内核使用，用来确定设备文件所指的设备。除了知道次设备号用来指向驱动程序所使用的设备之外，内核本身基本不关心次设备号的其他信息。  
内核用dev\_t类型（）来保存设备编号，在V2.6中，dev\_t是一个32位的数，12位表示主设备号，20位表示次设备号。  
在实际使用中，是通过中定义的宏来转换格式。

<table style="WIDTH: 447px; HEIGHT: 21px; COLOR: rgb(0,1,255)"> 
 <tbody> 
 <tr> 
 <td>&nbsp;(dev_t)--&gt;主、次设备号</td> 
 <td>&nbsp;MAJOR(dev_t dev) &nbsp;MINOR(dev_t dev) </td> 
 </tr> 
 <tr> 
 <td>&nbsp;主、次设备号--&gt;(dev_t)</td> 
 <td>&nbsp;MKDEV(int major,int minor)&nbsp;</td> 
 </tr> 
 </tbody> 
</table>

建立一个字符设备之前，驱动程序首先要做的事情就是获得设备编号。

<table style="BORDER-COLLAPSE: collapse"> 
 <tbody> 
 <tr> 
 <td> #include //指定设备编号 int register_chrdev_region(dev_t first, unsigned int count,char *name); &nbsp; 成功时返回0，错误是返回错误码。 first的次设备好常被置为0，但不是必需的。count是所请求的连续设备编号的个数，name是和该编号范围关联的设备名称，它将出现在/proc/devices和sysfs中 //动态生成设备编号 int alloc_chrdev_region(dev_t *dev, unsigned int firstminor,unsigned int count, char *name); &nbsp; dev仅用于输出参数，调用成功后将保存已分配范围的第一个编号，&nbsp;firstminor被请求的第一个次设备号，通常是0.count，name同register_chrdev_region。 void unregister_chrdev_region(dev_t first, unsigned int count);&nbsp;&nbsp; &nbsp;&nbsp; //释放设备编号 在模块清除函数中调用unregister_chrdev_region函数。</td> 
 </tr> 
 </tbody> 
</table>

分配主设备号的最佳方式是：默认采用动态分配，同时保留在加载甚至是编译时指定主设备号的余地。

以下是ldd3中的用来获取主设备号的代码：

1. if (scull\_major) \{ 
 
2.     dev = MKDEV(scull\_major, scull\_minor); 
 
3.     result = register\_chrdev\_region(dev, scull\_nr\_devs, "scull"); 
 
4. \} else \{ 
 
5.     result = alloc\_chrdev\_region(&dev, scull\_minor, scull\_nr\_devs,"scull"); 
 
6.     scull\_major = MAJOR(dev); 
 
7. \} 
 
8. if (result < 0) \{ 
 
9.     printk(KERN\_WARNING "scull: can't get major %d\\n", scull\_major); 
 
10.     return result; 
 
11. \}

3.几个数据结构

大部分驱动都涉及到三个重要的内核数据结构：file\_operation，file，inode

①file\_operation

在 中定义，包含了一组函数指针，用来建立驱动程序和设备编号的链接。

1. struct file\_operations \{ 
 
2. struct module \*owner; 
 
3. 指向拥有该模块的指针，一般初始化为THIS\_MODULE,它是定义在<linux/module.h>中的一个宏。 
 
4. loff\_t (\*llseek) (struct file \*, loff\_t, int); 
 
5. llseek用来修改文件的当前读写位置，并将新位置作为返回值。loff\_t是一个长偏移量，至少占64位宽。如果这个函数指针为NULL,对seek的调用将以某种不可预期的方式修改file结构中的计数器 
 
6. ssize\_t (\*read) (struct file \*, char \_\_user \*, size\_t, loff\_t \*); 
 
7. 从设备中读取数据，该函数赋为NULL时，将导致read系统调用出错并返回\-EINVAL（非法参数） 
 
8. ssize\_t (\*write) (struct file \*, const char \_\_user \*, size\_t, loff\_t \*); 
 
9. 向设备中写数据，该函数赋为NULL时，将导致write系统调用出错并返回\-EINVAL（非法参数） 
 
10. ssize\_t (\*aio\_read) (struct kiocb \*, const struct iovec \*, unsigned long, loff\_t); 
 
11. ssize\_t (\*aio\_write) (struct kiocb \*, const struct iovec \*, unsigned long, loff\_t); 
 
12. int (\*readdir) (struct file \*, void \*, filldir\_t); 
 
13. unsigned int (\*poll) (struct file \*, struct poll\_table\_struct \*); 
 
14. poll方法是poll，epoll和select这三个系统调用的后端实现。用来查询某个或多个文件描述符上的读取或写入是否会被阻塞。poll应该返回一个位掩码，用来指出非阻塞的读取或写入是否可能，并且也会向内核提供将调用进程置于休眠状态知道I/O变为可能时的信息，如果设为NULL,则设备会被认为可读可写，且不会被阻塞。 
 
15. int (\*ioctl) (struct inode \*, struct file \*, unsigned int, unsigned long); 
 
16. ioctl提供了一种执行设备特定命令的方法，另外内核还能识别一部分ioctl命令，而不必调用fops表中的ioctl。若为NULL,ioctl系统调用将返回错误(\-ENOTTY,“No such ioctl for device”) 
 
17. long (\*unlocked\_ioctl) (struct file \*, unsigned int, unsigned long); 
 
18. long (\*compat\_ioctl) (struct file \*, unsigned int, unsigned long); 
 
19. int (\*mmap) (struct file \*, struct vm\_area\_struct \*); 
 
20. mmap用于请求将设备内存映射到进程地址空间。若为NULL,mmap系统调用将返回\-ENODEV. 
 
21. int (\*open) (struct inode \*, struct file \*); 
 
22. 若为NULL,则设备的打开操作永远成功，但系统不会通知驱动程序。 
 
23. int (\*flush) (struct file \*, fl\_owner\_t id); 
 
24. 关闭设备文件描述符副本时，执行设备上尚未完结的操作，（仅用于几个驱动程序），若为NULL,忽略用户请求。 
 
25. int (\*release) (struct inode \*, struct file \*); 
 
26. 当file结构被释放时，调用这个操作，与open相仿，也可置为NULL. 
 
27. int (\*fsync) (struct file \*, struct dentry \*, int datasync); 
 
28. int (\*aio\_fsync) (struct kiocb \*, int datasync); 
 
29. int (\*fasync) (int, struct file \*, int); 
 
30. int (\*lock) (struct file \*, int, struct file\_lock \*); 
 
31. ssize\_t (\*sendpage) (struct file \*, struct page \*, int, size\_t, loff\_t \*, int); 
 
32. unsigned long (\*get\_unmapped\_area)(struct file \*, unsigned long, unsigned long, unsigned long, unsigned long); 
 
33. int (\*check\_flags)(int); 
 
34. int (\*flock) (struct file \*, int, struct file\_lock \*); 
 
35. ssize\_t (\*splice\_write)(struct pipe\_inode\_info \*, struct file \*, loff\_t \*, size\_t, unsigned int); 
 
36. ssize\_t (\*splice\_read)(struct file \*, loff\_t \*, struct pipe\_inode\_info \*, size\_t, unsigned int); 
 
37. int (\*setlease)(struct file \*, long, struct file\_lock \*\*); 
 
38. \};

scull设备驱动程序所实现的知识最重要的设备方法，它的file\_operation结构初始化为：

1.  struct file\_operations scull\_fops = \{
2.  .owner = THIS\_MODULE,
3.  .llseek = scull\_llseek,
4.  .read = scull\_read,
5.  .write = scull\_write,
6.  .ioctl = scull\_ioctl,
7.  .open = scull\_open,
8.  .release = scull\_release,
9.  \};

②file结构

file结构代表一个打开的文件，由内核在open时创建，并传递给在该文件上操作的所有函数，知道最后close函数，在文件的所有实例都被关闭后，内核会释放这个数据结构

1.  struct file \{   
    
2.      /\*  
    
3.       \* fu\_list becomes invalid after file\_free is called and queued via  
    
4.       \* fu\_rcuhead for RCU freeing  
    
5.       \*/  
    
6.      union \{   
    
7.          struct list\_head    fu\_list;  
    
8.          struct rcu\_head     fu\_rcuhead;  
    
9.      \} f\_u;  
    
10.     struct path        f\_path;  
    
11. \#define f\_dentry    f\_path.dentry  
    
12. \#define f\_vfsmnt    f\_path.mnt  
    
13.     const struct file\_operations    \*f\_op;
14. //文件的关联操作可以在任何需要的时候修改，这种技巧允许相同的open代码可以根据要打开的次设备号替换filp->f\_op中的操作  
    
15.     spinlock\_t        f\_lock; /\* f\_ep\_links, f\_flags, no IRQ \*/  
    
16.     atomic\_long\_t        f\_count;  
    
17.     unsigned int         f\_flags;  
    
18.     fmode\_t            f\_mode;  
    
19.     loff\_t            f\_pos;  
    
20.     struct fown\_struct    f\_owner;  
    
21.     const struct cred    \*f\_cred;  
    
22.     struct file\_ra\_state    f\_ra;  
    
23.   
    
24.     u64            f\_version;  
    
25. \#ifdef CONFIG\_SECURITY  
    
26.     void            \*f\_security;  
    
27. \#endif  
    
28.     /\* needed for tty driver, and maybe others \*/  
    
29.     void            \*private\_data;  
    
30. //可用于任何目的或者忽略这个字段。驱动程序可以用这个字段指向已分配的数据，但一定要在内核销毁file结构之前在release方法中释放内存。
31.   
    
32. \#ifdef CONFIG\_EPOLL  
    
33.     /\* Used by fs/eventpoll.c to link all the hooks to this file \*/  
    
34.     struct list\_head    f\_ep\_links;  
    
35. \#endif /\* \#ifdef CONFIG\_EPOLL \*/  
    
36.     struct address\_space    \*f\_mapping;  
    
37. \#ifdef CONFIG\_DEBUG\_WRITECOUNT  
    
38.     unsigned long f\_mnt\_write\_state;  
    
39. \#endif  
    
40. \};

③inode结构

内核用inode结构在内部表示文件，与file(表示打开的文件描述符)不同，单个文件对应单个的inode结构。重要的字段：

dev\_t i\_rdev;

对表示设备的inode结构，该字段包含了真正的设备编号

struct cdev \* i\_cdev;

struct cdev是表示字符设备的内核的内部结构，当inode指向一个字符设备文件时，它包含了指向struct cdev结构的指针。

两个从inode获得设备号的宏：

1.  unsigned int iminor(struct inode \* inode);  
    
2.  unsigned int imajor(struct inode \* inode);

4.字符设备注册

内核内部使用struct cdev结构来表示字符设备。在内核调用设备的操作之前，必须分配并注册一个或多个struct cdev。代码应包含，它定义了struct cdev以及与其相关的一些辅助函数。

注册一个字符设备基本步骤如下：

① 为struct cdev 分配空间(如果已经将struct cdev 嵌入到自己的设备的特定结构体中，并分配了空间，这步略过！)

struct cdev \*my\_cdev = cdev\_alloc();

my\_cdev->ops = &my\_fops;

②初始化struct cdev

void cdev\_init(struct cdev \*cdev, const struct file\_operations \*fops)

③初始化cdev.owner

cdev.owner = THIS\_MODULE;

④cdev设置完成，通知内核struct cdev的信息(在驱动程序还没完全准备好处理设备上的操作时，就不能调用cdev\_add)

int cdev\_add(struct cdev \*cdev, dev\_t num, unsigned count)

⑤从系统中移除一个字符设备：

void cdev\_del(struct cdev \*dev)

将cdev结构传递到cdev\_del函数之后，就不应再访问cdev结构了。

5.scull的内存模型

[![24708340_1298361537cCEW.jpg][]][24708340_1298361537cCEW.jpg]

scull的结构（可以用来表示每个设备）如下：

1.  struct scull\_dev\{   
    
2.      struct scull\_qset \* data; //指向第一个量子集的指针  
    
3.      int quantum; //量子的大小（每个指针分配的内存）  
    
4.      int qset; //当前量子集的大小（指针数组）  
    
5.      unsigned long size; //保存在其中的数据总量  
    
6.      unsigned int access\_key; //由sculluid和scullpriv使用  
    
7.      struct semaphore sem; //互斥信号量  
    
8.      struct cdev cdev; //字符设备结构  
    
9.  \};

实际的数据结构：

1.  struct scull\_qset\{   
    
2.      void \*\*data;  
    
3.      struct scull\_qset \*next;  
    
4.  \}

scull的初始化代码：（已经分配了scull\_dev空间）

1.  static void scull\_setup\_cdev(struct scull\_dev \* dev,int index)  
    
2.  \{   
    
3.      int err,devno = MKDEV(scull\_major,scull\_minor\+index);  
    
4.      cdev\_init(&dev\->cdev,&scull\_fops) ;  
    
5.      dev\->cdev.owner = THIS\_MODULE;  
    
6.      dev\->cdev.ops = &scull\_fops;  
    
7.        
    
8.      err = cdev\_add(&dev\->cdev,devno,1);  
    
9.      /\*fail gracefully if need be\*/  
    
10.     if (err)  
    
11.         printk(KERN\_NOTICE"Error %d adding scull%d",err,index);      
    
12. \}

6.scull的设备驱动方法

①open方法

提供给驱动程序以初始化的能力，为以后的操作完成初始化做准备，在大部分驱动程序中，open完成如下工作：

.检查设备特定的错误（如设备未就绪或类似的硬件问题）。

.如果设备是首次打开，这对其初始化

.如有必要，更新f\_op指针

.分配并填写置于filp->private\_data里的数据结构

原型：

int (\*open) (struct inode \*inode, struct file \*filp);

inode 的i\_cdev字段包含我们需要的cdev结构，但是通常我们需要得到的不是cdev，而是包含cdev的scull\_dev结构。用如下宏实现。

1. \#include <linux/kernel.h> 
 
2. container\_of(pointer,container\_type,container\_field)；

经过稍微简化的scull\_open代码如下：

1.  int scull\_open(struct inode \*inode,struct file \*filp)  
    
2.  \{   
    
3.      struct scull\_dev \*dev;  
    
4.    
    
5.      dev = container\_of(inode\->i\_cdev,struct scull\_dev,cdev);  
    
6.      filp\->private\_data = dev;  
    
7.    
    
8.      if ((filp\->f\_flags & O\_ACCMODE) == O\_WRONLY)\{   
    
9.          scull\_trim(dev);//当以写方式打开时，把设备长度截为0  
    
10.     \}  
    
11.     return 0;  
    
12. \}

scull\_trim在以写入方式scull\_open和scull\_cleanup模块中调用，释放dev数据区

1. int scull\_trim(struct scull\_dev \*dev) 
 
2. \{ 
 
3.     struct scull\_qset \*next,\*dptr; 
 
4.     int qset = dev\->qset; 
 
5.     int i; 
 
6.     for (dptr = dev\->data;dptr;dptr = next)\{ 
 
7.         if (dptr\->data)\{ 
 
8.             for(i = 0; i < qset; i\+\+) 
 
9.                 kfree(dptr\->data\[i\]); 
 
10.             kfree(dptr\->data); 
 
11.             dptr\->data = NULL; 
 
12.         \} 
 
13.         next = dptr\->next; 
 
14.         kfree(dptr); 
 
15.     \} 
 
16.     dev\->size = 0; 
 
17.     dev\->quantum = scull\_quantum; 
 
18.     dev\->qset = scull\_qset; 
 
19.     dev\->data = NULL; 
 
20.     return 0; 
 
21. \}

一个在设备链表中得到正确scull\_dev的函数，在read和write中调用

1.  /\*Follow the list\*/  
    
2.  struct scull\_qset \*scull\_follow(struct scull\_dev \*dev, int n)  
    
3.  \{   
    
4.      struct scull\_qset \*qs = dev\->data;  
    
5.          /\* Allocate first qset explicitly if need be \*/  
    
6.      if (! qs) \{   
    
7.          qs = dev\->data = kmalloc(sizeof(struct scull\_qset), GFP\_KERNEL);  
    
8.          if (qs == NULL)  
    
9.              return NULL;  
    
10.         memset(qs, 0, sizeof(struct scull\_qset));  
    
11.     \}  
    
12.     /\* Then follow the list \*/  
    
13.     while (n\-\-) \{   
    
14.         if (!qs\->next) \{   
    
15.             qs\->next = kmalloc(sizeof(struct scull\_qset), GFP\_KERNEL);  
    
16.             if (qs\->next == NULL)  
    
17.                 return NULL;  
    
18.             memset(qs\->next, 0, sizeof(struct scull\_qset));  
    
19.         \}  
    
20.         qs = qs\->next;  
    
21.         continue;  
    
22.     \}  
    
23.     return qs;  
    
24. \}

函数功能：若所找的scull\_qset存在，则返回其指针，若不存在，一边为链表分配空间，一边沿链表前行， 直到所需的节点被分配到，并被初始化及返回。

引入两个函数：

1. \#include <linux/slab.h> 
 
2. void \*kmalloc(size\_t size,int flags); 
 
3. void kfree(void \*ptr);

②release方法

完成以下任务：

.释放由open分配的，保存在filp->private\_data中的所有内容。

.在最后一次关闭操作时关闭设备。

只有当file结构的计数归0时，close系统调用才会执行release发放。每次close都会调用flush。这保证了每次open驱动那个程序只会弹道对应的一个release调用。

③read和write

内核空间与用户空间的数据不能直接传输，原因如下：

.在内核模式运行中，用户空间 指针是无效的，该地址可能根本无法被映射到内核空间，或指向某未知区域。

.用户空间的内存是分页的，而在系统调用被调用时，涉及到的内存可能 根本不在RAM中。直接对用户内存操作将导致页错误，其结果可能是一个oops。

.用户提供的程序可能 有缺陷或是恶意程序，威胁系统稳定和安全。

so，永远不要直接引用用户空间的指针。

1. \#include <asm/uaccess.h> 
 
2. unsigned long copy\_to\_user(void \_\_user\*to,const void \*from,unsigned long count); 
 
3. unsigned long copy\_from\_user(void \*to,const void \_\_user\*from,unsigned long count);

1.  ssize\_t read(struct file \*filp,char \_\_user \*buff,size\_t count,loff\_t \*offp);  
    
2.  ssize\_t write(struct file \* filp,const char \_\_user \*buff,size\_t count,loff\_t \*offp);

访问用户空间的任何函数必须是可重入的，并且必须可和其他驱动程序并发执行

read返回值：

.==count，说明说请求直接传输成功。

.0 <返回值>

.==0，表示到达文件尾。

.<0，表示出错，错误吗在 中定义。

write返回值：

.==count，完成所请求直接传送。

.0 <返回值>

.==0表示什么都没写入，标准库会重复调用write。

.负值，表示出错。

无论传输了多少数据，一般而言都应该更新\*offp说表示的文件位置，以便反映在新系统调用成功完成后当前的文件文字。