linux字符设备驱动程序笔记.docx

linux字符设备驱动程序笔记.docx

《linux字符设备驱动程序笔记.docx》由会员分享，可在线阅读，更多相关《linux字符设备驱动程序笔记.docx（15页珍藏版）》请在冰豆网上搜索。

linux字符设备驱动程序笔记

4.6linux字符设备驱动程序

[4-6-1]linux驱动程序介绍（参考课件）

驱动程序：

使硬件工作的软件。

模型一的缺点：

软件程序的复用性不好

模型二的缺点：

如果驱动程序接口变化，则所有的应用程序就必须都改

模型三：

即linux驱动程序驱动模型：

如图“使用驱动程序所示”。

解决了上述两种模型的缺点。

linux驱动程序的分类：

◎字符设备驱动（重点）

◎网络接口驱动（重点）

◎块设备驱动

1）字符设备：

字符设备是一种按字节来访问的设备，字符驱动则负责驱动字符设备，这样的驱动通

常实现open，close，read和write系统调用。

2）块设备：

◎在大部分unix系统，块设备不能按字节处理数据，只能一次传送一个或多个长度是

512字节（或一个更大的2次幂的数）的整块数据。

◎而Linux则允许块设备传送任意数目的字节。

因此块和字符设备的区别：

仅仅是驱动的接口函数与内核的接口函数不同。

3）网络接口：

任何网络事物都通过一个接口来进行，一个接口通常是一个硬件（eth0），但它也可以

是一个纯粹的软件设备，比如回环接口（lo）。

一个网络接口负责发送和接收数据报文。

字符设备与块设备：

随机访问？

块设备随机访问，字符设备必须按顺序访问

驱动程序安装方式：

有两种

◎模块方式（已知）（insmod,rmmod）（lsmod列出当前系统中加载的模块,rmmod是用于将当前模块卸载,insmod用于加载当前模块,mknod是用于创建相关模块）

◎直接编译进内核

如何直接把驱动程序（内核模块）编译进内核？

需要修改两个文件：

Kconfig，Makefile（Kconfig用来产生配置菜单，到处有Kconfig）：

第一步：

首先把驱动程序或内核模块源文件（hello.c）放到内核源代码相应的目录下（根据

功能选择目录）（如drivers/char下）

第二步：

修改Kconfig，修改所放源文件目录下的Kconfig，在内核源代码的顶层目录执行：

vidrivers/char/Kconfig（打开Kconfig），然后在其中加上如下两行代码（照着写）：

configHELLO_WORLD

Bool“helloworld”

第三步：

通过makemenuconfigARCH=arm进入配置菜单，选中刚添加（要编译进内核）

的项。

配置结果体现在（.config）中，.config文件位于内核源代码顶层目录下，通

过vi.config可以查看。

可以看到：

CONFIG_HELLO_WORLD=y

第四步：

修改Makefile，修改所放源文件目录下的Makefile。

照着写

obj-$（CONFIG_HELLO_WORLD）+=hello.o（加上这一项，hello.c）

第五步：

编译内核。

修改好后，回到内核源代码顶层目录执行如下命令编译内核。

：

maleuImageARCH=armCROSS_COMPILE=arm-linux-

*****************************hello.c代码如下：

**********************************

#include

#include

staticint__inithello_init（）

{

printk（"helloworld!

\n"）;

return0;

}

staticvoid__exithello_exit（）

{

printk（KERN_EMERG"helloexit!

\n"）;

}

module_init（hello_init）;

module_exit（hello_exit）;

*****************************************************************************

编译完成启动内核的过程中，会打印出：

HelloWorld！

信息。

因为执行了模块初始化函数。

__init标志表示此函数将被放置到初始化代码段；内核在启动时，会依次调用初始化代码段中的函数指针。

__exit类似。

驱动程序使用：

linux用户程序通过设备文件（也称：

设备节点）来使用驱动程序操作字符设备和块设备（根据*fp找到在内核里面对应的sturctfile结构，从而找到相应的read，write函数）

网络设备没有设备文件，设备文件在dev目录下面。

[4-6-2]字符设备驱动程序设计（参考课件）

1、主次设备号

字符设备通过字符设备文件来存取。

字符设备文件由使用ls–l命令后输出的第一列的“c”标识。

在dev目录下使用ls–l命令可以看到设备文件项中有2个数字，由逗号分隔，这些数字就是设备文件的主次设备编号。

前主后次。

1.1设备号的作用

思考：

字符设备文件与字符设备驱动如何建立联系？

——通过主设备号

设备文件所对应的主设备号和驱动程序所对应的主设备号相同的话，那么这个驱动程序就对应这个设备文件。

（设备文件的主设备号通过创建设定，驱动程序通过申请获得）

主设备号：

用来标识与设备文件相连的驱动程序。

次设备号：

被驱动程序用来辨别操作的是哪个设备。

总结：

主设备号用来反映设备类型；次设备号用来区分同类型的设备。

主次设备号的描述：

内核描述

内核中通过类型dev_t来描述设备号，其实质是unsignedint32位整数，其中高12位为主设备号，低20位为次设备号。

◎分离出主设备号MAJOR（dev_tdev）；

◎分离出次设备号MINOR（dev_tdev）

◎定义主次设备号dev_tdevno=MKDEV（mem_major,mem_minor）

1.2分配主设备号

Linux内核通过静态申请和动态分配两种方法来给设备分配主设备号。

1.2.1静态申请（简单但易导致冲突）

方法如下：

1、根据Documentation/deices.txt，确定一个没有使用的主设备号；

2、使用register_chrdev_region函数注册设备号。

优点：

简单，

缺点：

一旦驱动程序被广泛使用，这个随机选定的主设备号可能会导致设备号冲突，而使驱

动程序无法注册。

原型：

intregister_chrdev_region（dev_tfrom,unsignedcount,constchar*name）

功能：

申请使用从from开始的count个设备号（主设备号不变，次设备号增加）

参数：

from：

希望申请使用的设备号

count：

希望申请使用的设备号数目

name：

设备名（体现在/proc/devices）

1.2.2动态分配（我们常常会担心自己选的设备号前面已经用过了，担心设备号选错引起不必要的麻烦，那么我们现在就采取动态分配设备号的方式。

简单，但无法在安装驱动前创建设备文件，因为安装前还没有分配到主设备号）

方法如下：

使用alloc_chrdev_region分配设备号

原型：

intalloc_chrdev_region（dev_t*dev,unsignedbaseminor,unsignedcount,constchar*name）

功能：

请求内核动态分配count个设备号，且次设备号从baseminor开始。

参数：

dev：

分配到的设备号位于dev指针所指向的内存中。

，不需要填值，用于获取值

baseminor：

起始次设备号

count：

需要分配的设备号数目

name：

设备名（体现在/proc/devices）

返回值：

成功返回0，失败返回-1。

优点：

简单，易于驱动推广

缺点：

无法在安装驱动前创建设备文件（因为安装前还没有分配到主设备号）

解决办法：

安装驱动后，从/proc/devices中查询设备号，然后再创建设备文件。

1.3注销设备号（不用时应该释放这些设备号）

原型：

voidunregister_chrdev_region（dev_tfrom,unsignedcount）

功能：

释放从from开始的count个设备号

2、创建设备文件——2种方法：

2.1、使用mknod命令手工创建

用法：

mknodfilenametypemajorminor

参数：

filename：

设备文件名

type：

设备文件类型“c”，“b”

major：

主设备号

minor：

次设备号

例如：

mknodserial0c1000//设备文件的主次设备号是确定的，一个设备文件只能对应一个

设备。

要操作哪个设备，首先要创建对应主次设备号的设备文件，再操作此设备文件。

2.2、自动创建

利用udev（mdev）来实现设备文件的自动创建，首先应保证支持udev（mdev），由busybox配置。

在驱动初始化代码里调用class_create为该设备创建一个class，再为每个设备调用device_create创建对应的设备。

3、重要结构

在Linux字符设备驱动程序设计中，有三种非常重要的内核数据结构：

3.1、structfile：

代表一个打开的文件。

系统中每个打开的文件在内核空间都有一个关联的structfile。

它由内核在打开文件时创建，在文件关闭后释放。

（每打开一次创建一个）

重要成员：

loff_tf_pos/*文件读写位置*/

structfile_operations*f_op

3.2、structinode：

用来记录文件的物理上的信息（如存放位置、设备号等）。

因此它和代表打开文件的file结构是不同的，一个文件可以对应多个file结构，但只有一个inode结构。

重要成员：

dev_ti_rdev：

设备号//inode代表设备文件（设备节点）？

3.3、structfile_operations：

一个函数指针的集合（更像一个转化表），定义能在设备上进行的操作。

结构中的成员指向驱动中的函数，这些函数实现一个特殊的操作，对于不支持的操作保留为NULL。

structfile_operationsmem_fops={

.owner=THIS_MODULE,

.llseek=mem_seek,

.read=mem_read,

.write=mem_write,

.ioctl=mem_ioctl,

.open=mem_open,

.release=mem_release,

};

思考：

应用程序如何访问驱动程序？

解析：

当应用程序执行read系统调用，对设备文件进行读的时候，驱动程序就会做出mem_read函数调用。

当应用程序执行write系统调用，对设备文件进行写的时候，驱动程序就会做出mem_write函数调用。

把应用程序中对文件的操作转化成驱动程序中相应的函数。

（内核根据应用程序系统调用中传递的*fp指针找到在内核里面对应的sturctfile结构，从而找到驱动程序中相应的read，write函数）

4、设备注册

在linux2.6内核中，字符设备使用structcdev结构来描述。

字符设备的注册分为如下三个步骤：

4.1、分配cdev，分配空间：

分配是对于指针而言，静态的不需要分配

structcdev的分配可使用cedv_alloc函数来完成。

原型：

structcdev*cdev_alloc（void）。

分配完成后返回分配到的structcdev函数指针

注意：

如果cdev结构被定义为静态的，则不需要执行空间分配。

4.2、初始化cdev结构

structcdev的初始化可使用cedv_init函数来完成。

原型：

voidcdev_init（structcedv*cdev,conststructfile_operations*fops）

参数：

cdev：

待初始化的cdev结构

fops：

设备对应的操作函数集

4.3、添加cdev（即注册字符设备驱动）

structcdev的注册可使用cedv_add函数来完成。

原型：

intcdev_add（structcdev*p,dev_tdev,unsignedcount）

参数：

p：

待添加到内核的字符设备结构，要注册的字符设备

dev：

设备号，驱动程序对应的主设备号

count：

添加的设备个数

5、设备操作（注册完之后要实现structfile_operations结构中相关的设备操作）

◎1、int（*open）（structinode*,structfile*）对应open方法

在设备文件上的第一操作，可以不实现此方法，没有（即该项为NULL）时则认为永

远打开成功。

◎2、void（*release）（structinode*,structfile*）对应close方法

当设备文件被关闭时调用这个操作。

release也可以没有。

◎3、ssize_t（*read）（structfile*,char__user*,size_t,loff_t*）

从设备中读取数据

◎4、ssize_t（*write）（structfile*,constchar__user*,size_t,loff_t*）

向设备发送数据

◎5、unsignedint（*poll）（structfile*,structpoll_table_struct*）

对应select系统调用

◎6、int（*ioctl）（structinode*,structfile*,unsignedint,unsignedlong）

控制设备

◎7、int（*mmap）（structfile*,structvm_area_struct*）

将设备映射到进程虚拟地址空间中。

◎8、off_t（*llseek）（structfile*,loff_t,int）

修改文件的当前读写位置，并将新位置作为返回值。

open方法：

open方法是驱动程序用来为以后的操作完成初始化准备工作的。

在大部分驱动程序中，open完成如下工作：

◎初始化设备，设置寄存器等。

◎标明次设备号，这样驱动程序才知道操作哪个设备。

/*将设备描述结构指针赋值给文

件私有数据指针，然后在读写操作函数中就能知道该操作哪个设备*/

release方法：

release方法的作用正好与open相反。

这个设备方法有时也称为close，它应该：

◎关闭设备

读和写方法：

读和写方法都完成类似的工作：

从设备中读取数据到用户空间；将数据传递给驱动程序。

它们的原型也相当类似：

原型：

ssize_txxx_read（structfile*filp,char__user*buff,size_tcount,loff_t*offp）;

原型：

ssize_txxx_write（structfile*filp,char__user*buff,size_tcount,loff_t*offp）;

参数：

对于这两个方法，其参数含义如下：

filp是文件指针，内核构造后传给此函数的

count是请求传输的数据量。

来自用户空间

buff参数指向数据缓存。

来自用户空间

offp支出文件当前的访问位置。

来自内核

问题：

read和write方法的buff参数是用户空间指针。

因此，他不能被内核代码直接引用。

理由如下：

用户控件的指针在内核空间可能根本是无效的——没有那个地址的映射。

解决：

内核提供了专门的函数用于访问用户空间的指针，例如：

写：

intcopy_from_user（void*to,constvoid__user*from,intn）

数据从用户空间放到设备里面去

读：

intcopy_to_user（void__user*to,constvoid*from,intn）

从设备里面读，数据从设备到用户空间，

6、设备注销：

当不再使用驱动程序的时候应该把驱动程序注销掉。

字符设备的注销使用cdev_del函数来完成。

原型：

intcdev_del（structcdev*p）

参数：

p：

要注销的字符设备结构

[4-6-3]字符设备驱动程序实例分析memdev.cmemdev.happ-mem.c

[4-6-4]竞争与互斥

4.1驱动调试技术：

对于驱动程序设计来说，核心问题之一就是如何完成调试。

当前常用的驱动调试技术可分为：

◎打印调试：

printk

◎调试器调试：

gdb

◎查询调试：

proc文件系统

合理使用printk

应该使用全局打开或关闭printk打印的宏开关来控制是否使用printk。

#ifdefPDEBUG

#definePLOG（fmt,args…）printk（KERN_DEBUG“scull:

”fmt,##args）

#else

#definePLOG（fmt,args…）/*donothing*/

#endif

Makefile做如下修改：

DEBUG=y

ifeq（$（DEBUG）,y）

DEBFLAGS=-O2–g–DPDEBUG

else

DEBFLAGS=-O2

endif

CFLAFS+=$（DEBFLAGS）

4.2并发控制：

4.2.1概念：

并发与竞态

并发：

多个执行单元同时被执行

竞态：

并发的执行单元对共享资源（硬件资源和软件上的全局变量等）的访问导致的竞争状态

例：

if（copy_from_user（&（dev->data[pos]）,buf,count））

ret=-EFAULT;

gotoout;

假设有2个进程试图同时向一个设备的相同位置写入数据，就会造成数据混乱。

4.2.2并发控制技术：

处理并发的常用技术是加锁或者互斥，即确保在任何时候只有一个执行单元可以操作共享资源。

在linux内核中主要通过semaphore机制和spin_lock机制实现。

4.2.2.1信号量：

linux内核的信号量在概念和原理上与用户态的信号量是一样的，但是它不能在内核之外使用，它是一种睡眠锁。

如果有一个任务想要获得已经被占用的信号量时，信号量会将这个进程放入一个等待队列，然后让其睡眠。

当持有信号量的进程将信号释放以后，处于等待队列中的任务将被唤醒，并让其获得信号量。

◎信号量在创建时需要设置一个初始值，表示允许可以有几个任务同时访问该信号量保护的资源，初始值为1就变成互斥锁（Mutex），即同时只能有一个任务可以访问信号量保护的资源。

◎当任务访问完被信号量保护的共享资源后，就必须释放信号量，释放信号量通过把信号量的值加1实现，如果释放后信号量的值为非正数，表明有任务等待当前信号量，因此要唤醒等待该信号量的任务。

信号量的使用

信号量的实现也是与体系结构相关的，定义在中，structsemaphore类型用来表示信号量。

1、定义信号量

◎structsemaphoresem;

2、初始化信号量

◎voidsema_init（structsemaphore*sem,intval）

该函数用于初始化设置信号量的初值，它设置信号量sem的值为val。

◎voidinit_MUTEX（structsemaphore*sem）

该函数用于初始化一个互斥锁，即把信号量sem的值设置为1。

互斥锁的值只能为0或者1

◎voidinit_MUTEX_LOCKED（structsemaphore*sem）

该函数也用于初始化一个互斥锁，但它把信号量sem的值设置为0，

即一开始就处在已锁状态。

定义与初始化的工作可以由如下宏一步完成：

◎DECLARE_MUTEX（name）

定义一个信号量name，并初始化它的值为1。

◎DECLARE_MUTEX_LOCKED（name）

定义一个信号量name，但把它的初始值设置为0，即锁在创建时就处在已锁状态。

3、获取信号量

◎voiddown（structsemaphore*sem）

获取信号量sem，可能会导致进程睡眠，因此不能在中断上下文使用该函数。

该函数将

把sem的值减1，如果信号量sem的值非负，就直接返回，否则调用者将被挂起，直到

别的任务释放该信号量才能继续运行。

◎intdown_interruptible（structsemaphore*sem）

获取信号量sem。

如果信号量不可用，进程将被置为TASK_INTERRUPTIBLE类型的睡

眠状态。

该函数由返回值来区分是正常返回还是被信号中断返回，如果返回0，表示获

得的信号量正常返回，如果被信号打断，返回-EINTR。

◎down_killable（structsemaphore*sem）

获取信号量sem。

如果信号量不可用，进程将被置为TASK_KILLABLE类型的睡眠状态。

注：

down（）函数现已不建议继续使用。

建议使用down_killable（）或down_interruptible（）函数。

4、释放信号量

voidup（structsemaphore*sem）

该函数释放信号量sem，即把sem的值加1，如果sem的值为非正数，表明有任务在等

待该信号量，因此唤醒这些等待者。

4.2.2.2自旋锁

自旋锁最多只能被一个可执行单元持有。

自旋锁不会引起调用者睡眠，如果有一个执行线程试图获得一个已经被持有的自旋锁，那么线程就会一直进行忙循环，一直等待下去，在那里看是否该自旋锁的保持者已经释放了锁，“自旋”就是这个意思。

自旋锁的使用

1、初始化自旋锁

◎spin_lock_init（x）

该宏用于初始化自旋锁x，自旋锁在使用前必须先初始化。

2、获取自旋锁

◎spin_lock（lock）

获取自旋锁lock，如果成功，立即获得锁，并马上返回，否则它将一直自旋在那里，直

到该自旋锁的保持者释放。

◎spin_trylock（lock）

试图获取自旋锁lock，如果能立即获得锁，并返回真，否则立即返回假。

它不会一直等

待被释放。

3、释放自旋锁

◎spin_unlock（lock）

释放自旋锁lock，它与spin_trylock或spin_lock配对使用。

4.2.2.3信号量与自旋锁对比

◎信号量可能允许有多个持有者，而自旋锁在任何时候只能允许有一个持有者。

当然也有

信号量叫互斥信号量（只有一个持有者），允许有多个持有者的信号量叫计数信号量。

◎信号量适合于保持时间较长的情况；而自旋锁适合于保持时间非常短的情况，在实际应

用中自旋锁控制的代码只有几行，而持有自旋锁的时间也一般不会超过两次上下文切换

的时间，因为线程一旦要进行切换，就至少花费切出切入两次，自旋锁的占用时间如果

远远长于两次上下文切换，我们就应该选择信号量。