linuxqudong

⑴ linux的设备驱动一般分为几类各有什么特点

大致分为三类，字符驱动，块设备驱动，网络设备驱动。
字符设备可以看成是用字节流存取的文件

块设备则可以看成是可以任意存取字节数的字符设备，在应用上只是内核管理数据方式不同

网络设备可以是一个硬件设备，或者是软件设备，他没有相应的read write，它是面向流的一种特殊设备。

⑵ 如何编写Linux 驱动程序

如何编写Linux设备驱动程序
回想学习Linux操作系统已经有近一年的时间了，前前后后，零零碎碎的一路学习过来，也该试着写的东西了。也算是给自己能留下一点记忆和回忆吧！由于完全是自学的，以下内容若有不当之处，还请大家多指教。
Linux是Unix操作系统的一种变种，在Linux下编写驱动程序的原理和思想完全类似于其他的Unix系统，但它dos或window环境下的驱动程序有很大的区别。在Linux环境下设计驱动程序，思想简洁，操作方便，功能也很强大，但是支持函数少，只能依赖kernel中的函数，有些常用的操作要自己来编写，而且调试也不方便。
以下的一些文字主要来源于khg，johnsonm的Write linux device driver，Brennan's Guide to Inline Assembly，The Linux A-Z，还有清华BBS上的有关device driver的一些资料。
一、Linux device driver 的概念
系统调用是操作系统内核和应用程序之间的接口，设备驱动程序是操作系统内核和机器硬件之间的接口。设备驱动程序为应用程序屏蔽了硬件的细节，这样在应用程序看来，硬件设备只是一个设备文件，应用程序可以象操作普通文件一样对硬件设备进行操作。设备驱动程序是内核的一部分，它完成以下的功能:
1、对设备初始化和释放。
2、把数据从内核传送到硬件和从硬件读取数据。
3、读取应用程序传送给设备文件的数据和回送应用程序请求的数据。
4、检测和处理设备出现的错误。
在Linux操作系统下有三类主要的设备文件类型，一是字符设备，二是块设备，三是网络设备。字符设备和块设备的主要区别是:在对字符设备发出读/写请求时，实际的硬件I/O一般就紧接着发生了，块设备则不然，它利用一块系统内存作缓冲区，当用户进程对设备请求能满足用户的要求，就返回请求的数据，如果不能，就调用请求函数来进行实际的I/O操作。块设备是主要针对磁盘等慢速设备设计的，以免耗费过多的CPU时间来等待。
已经提到，用户进程是通过设备文件来与实际的硬件打交道。每个设备文件都都有其文件属性(c/b)，表示是字符设备还是块设备?另外每个文件都有两个设备号，第一个是主设备号，标识驱动程序，第二个是从设备号，标识使用同一个设备驱动程序的不同的硬件设备，比如有两个软盘，就可以用从设备号来区分他们。设备文件的的主设备号必须与设备驱动程序在登记时申请的主设备号一致，否则用户进程将无法访问到驱动程序。
最后必须提到的是，在用户进程调用驱动程序时，系统进入核心态，这时不再是抢先式调度。也就是说，系统必须在你的驱动程序的子函数返回后才能进行其他的工作。如果你的驱动程序陷入死循环，不幸的是你只有重新启动机器了，然后就是漫长的fsck。
读/写时，它首先察看缓冲区的内容，如果缓冲区的数据未被处理，则先处理其中的内容。
如何编写Linux操作系统下的设备驱动程序

二、实例剖析
我们来写一个最简单的字符设备驱动程序。虽然它什么也不做，但是通过它可以了解Linux的设备驱动程序的工作原理。把下面的C代码输入机器，你就会获得一个真正的设备驱动程序。
#define __NO_VERSION__
#include <linux/moles.h>
#include <linux/version.h>
char kernel_version [] = UTS_RELEASE;
这一段定义了一些版本信息，虽然用处不是很大，但也必不可少。Johnsonm说所有的驱动程序的开头都要包含<linux/config.h>，一般来讲最好使用。
由于用户进程是通过设备文件同硬件打交道，对设备文件的操作方式不外乎就是一些系统调用，如 open，read，write，close…， 注意，不是fopen， fread，但是如何把系统调用和驱动程序关联起来呢?这需要了解一个非常关键的数据结构：
struct file_operations
{
int (*seek) (struct inode * ，struct file *， off_t ，int);
int (*read) (struct inode * ，struct file *， char ，int);
int (*write) (struct inode * ，struct file *， off_t ，int);
int (*readdir) (struct inode * ，struct file *， struct dirent * ，int);
int (*select) (struct inode * ，struct file *， int ，select_table *);
int (*ioctl) (struct inode * ，struct file *， unsined int ，unsigned long);
int (*mmap) (struct inode * ，struct file *， struct vm_area_struct *);
int (*open) (struct inode * ，struct file *);
int (*release) (struct inode * ，struct file *);
int (*fsync) (struct inode * ，struct file *);
int (*fasync) (struct inode * ，struct file *，int);
int (*check_media_change) (struct inode * ，struct file *);
int (*revalidate) (dev_t dev);
}

这个结构的每一个成员的名字都对应着一个系统调用。用户进程利用系统调用在对设备文件进行诸如read/write操作时，系统调用通过设备文件的主设备号找到相应的设备驱动程序，然后读取这个数据结构相应的函数指针，接着把控制权交给该函数。这是linux的设备驱动程序工作的基本原理。既然是这样，则编写设备驱动程序的主要工作就是编写子函数，并填充file_operations的各个域。
下面就开始写子程序。
#include <linux/types.h>
#include <linux/fs.h>
#include <linux/mm.h>
#include<linux/config.h>
#include <linux/errno.h>
#include <asm/segment.h>
unsigned int test_major = 0;
static int read_test(struct inode *node，struct file *file，char *buf，int count)
{
int left;
if (verify_area(VERIFY_WRITE，buf，count) == -EFAULT )
return -EFAULT;
for(left = count ; left > 0 ; left--)
{
__put_user(1，buf，1);
buf++;
}
return count;
}

这个函数是为read调用准备的。当调用read时，read_test()被调用，它把用户的缓冲区全部写1。buf 是read调用的一个参数。它是用户进程空间的一个地址。但是在read_test被调用时，系统进入核心态。所以不能使用buf这个地址，必须用__put_user()，这是kernel提供的一个函数，用于向用户传送数据。另外还有很多类似功能的函数。请参考Robert着的《Linux内核设计与实现》（第二版）。然而，在向用户空间拷贝数据之前，必须验证buf是否可用。这就用到函数verify_area。
static int write_tibet(struct inode *inode，struct file *file，const char *buf，int count)
{
return count;
}
static int open_tibet(struct inode *inode，struct file *file )
{
MOD_INC_USE_COUNT;
return 0;
}
static void release_tibet(struct inode *inode，struct file *file )
{
MOD_DEC_USE_COUNT;
}

这几个函数都是空操作。实际调用发生时什么也不做，他们仅仅为下面的结构提供函数指针。
struct file_operations test_fops = {
NULL，
read_test，
write_test，
NULL， /* test_readdir */
NULL，
NULL， /* test_ioctl */
NULL， /* test_mmap */
open_test，
release_test，
NULL， /* test_fsync */
NULL， /* test_fasync */
/* nothing more， fill with NULLs */
};
这样，设备驱动程序的主体可以说是写好了。现在要把驱动程序嵌入内核。驱动程序可以按照两种方式编译。一种是编译进kernel，另一种是编译成模块(moles)，如果编译进内核的话，会增加内核的大小，还要改动内核的源文件，而且不能动态的卸载，不利于调试，所以推荐使用模块方式。
int init_mole(void)
{
int result;
result = register_chrdev(0， "test"， &test_fops);
if (result < 0) {
printk(KERN_INFO "test: can't get major number\n");
return result;
}
if (test_major == 0) test_major = result; /* dynamic */
return 0;
}

在用insmod命令将编译好的模块调入内存时，init_mole 函数被调用。在这里，init_mole只做了一件事，就是向系统的字符设备表登记了一个字符设备。register_chrdev需要三个参数，参数一是希望获得的设备号，如果是零的话，系统将选择一个没有被占用的设备号返回。参数二是设备文件名，参数三用来登记驱动程序实际执行操作的函数的指针。
如果登记成功，返回设备的主设备号，不成功，返回一个负值。
void cleanup_mole(void)
{
unregister_chrdev(test_major，"test");
}
在用rmmod卸载模块时，cleanup_mole函数被调用，它释放字符设备test在系统字符设备表中占有的表项。
一个极其简单的字符设备可以说写好了，文件名就叫test.c吧。
下面编译 :
$ gcc -O2 -DMODULE -D__KERNEL__ -c test.c
得到文件test.o就是一个设备驱动程序。
如果设备驱动程序有多个文件，把每个文件按上面的命令行编译，然后
ld -r file1.o file2.o -o molename。
驱动程序已经编译好了，现在把它安装到系统中去。
$ insmod –f test.o
如果安装成功，在/proc/devices文件中就可以看到设备test，并可以看到它的主设备号。要卸载的话，运行 :
$ rmmod test
下一步要创建设备文件。
mknod /dev/test c major minor
c 是指字符设备，major是主设备号，就是在/proc/devices里看到的。
用shell命令
$ cat /proc/devices
就可以获得主设备号，可以把上面的命令行加入你的shell script中去。
minor是从设备号，设置成0就可以了。
我们现在可以通过设备文件来访问我们的驱动程序。写一个小小的测试程序。
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
main()
{
int testdev;
int i;
char buf[10];
testdev = open("/dev/test"，O_RDWR);
if ( testdev == -1 )
{
printf("Cann't open file \n");
exit(0);
}
read(testdev，buf，10);
for (i = 0; i < 10;i++)
printf("%d\n"，buf[i]);
close(testdev);
}

编译运行，看看是不是打印出全1 ？
以上只是一个简单的演示。真正实用的驱动程序要复杂的多，要处理如中断，DMA，I/O port等问题。这些才是真正的难点。请看下节，实际情况的处理。
如何编写Linux操作系统下的设备驱动程序
三、设备驱动程序中的一些具体问题
1。 I/O Port。
和硬件打交道离不开I/O Port，老的ISA设备经常是占用实际的I/O端口，在linux下，操作系统没有对I/O口屏蔽，也就是说，任何驱动程序都可对任意的I/O口操作，这样就很容易引起混乱。每个驱动程序应该自己避免误用端口。
有两个重要的kernel函数可以保证驱动程序做到这一点。
1）check_region(int io_port， int off_set)
这个函数察看系统的I/O表，看是否有别的驱动程序占用某一段I/O口。
参数1：I/O端口的基地址，
参数2：I/O端口占用的范围。
返回值：0 没有占用， 非0，已经被占用。
2）request_region(int io_port， int off_set，char *devname)
如果这段I/O端口没有被占用，在我们的驱动程序中就可以使用它。在使用之前，必须向系统登记，以防止被其他程序占用。登记后，在/proc/ioports文件中可以看到你登记的I/O口。
参数1：io端口的基地址。
参数2：io端口占用的范围。
参数3：使用这段io地址的设备名。
在对I/O口登记后，就可以放心地用inb()， outb()之类的函来访问了。
在一些pci设备中，I/O端口被映射到一段内存中去，要访问这些端口就相当于访问一段内存。经常性的，我们要获得一块内存的物理地址。

2。内存操作
在设备驱动程序中动态开辟内存，不是用malloc，而是kmalloc，或者用get_free_pages直接申请页。释放内存用的是kfree，或free_pages。 请注意，kmalloc等函数返回的是物理地址！
注意，kmalloc最大只能开辟128k-16，16个字节是被页描述符结构占用了。
内存映射的I/O口，寄存器或者是硬件设备的RAM(如显存)一般占用F0000000以上的地址空间。在驱动程序中不能直接访问，要通过kernel函数vremap获得重新映射以后的地址。
另外，很多硬件需要一块比较大的连续内存用作DMA传送。这块程序需要一直驻留在内存，不能被交换到文件中去。但是kmalloc最多只能开辟128k的内存。
这可以通过牺牲一些系统内存的方法来解决。

3。中断处理
同处理I/O端口一样，要使用一个中断，必须先向系统登记。
int request_irq(unsigned int irq ，void(*handle)(int，void *，struct pt_regs *)，
unsigned int long flags， const char *device);
irq: 是要申请的中断。
handle：中断处理函数指针。
flags：SA_INTERRUPT 请求一个快速中断，0 正常中断。
device：设备名。

如果登记成功，返回0，这时在/proc/interrupts文件中可以看你请求的中断。
4。一些常见的问题。
对硬件操作，有时时序很重要（关于时序的具体问题就要参考具体的设备芯片手册啦！比如网卡芯片RTL8139）。但是如果用C语言写一些低级的硬件操作的话，gcc往往会对你的程序进行优化，这样时序会发生错误。如果用汇编写呢，gcc同样会对汇编代码进行优化，除非用volatile关键字修饰。最保险的办法是禁止优化。这当然只能对一部分你自己编写的代码。如果对所有的代码都不优化，你会发现驱动程序根本无法装载。这是因为在编译驱动程序时要用到gcc的一些扩展特性，而这些扩展特性必须在加了优化选项之后才能体现出来。
写在后面：学习Linux确实不是一件容易的事情，因为要付出很多精力，也必须具备很好的C语言基础；但是，学习Linux也是一件非常有趣的事情，它里面包含了许多高手的智慧和“幽默”，这些都需要自己亲自动手才能体会到，O(∩_∩)O~哈哈！

⑶ Linux驱动的软件架构

Linux不是为了某单一电路板而设计的操作系统，它可以支持约30种体系结构下一定数量的硬件，因此，它的驱动架构很显然不能像RTOS下或者无操作系统下那么小儿科的做法。Linux设备驱动非常重视软件的可重用和跨平台能力。譬如，如果我们写下一个DM9000网卡的驱动，Linux的想法是这个驱动应该最好一行都不要改就可以在任何一个平台上跑起来。
#ifdef BOARD_Xxx
#define DM9000_BASE 0x100oo#define DM900o_IRQ 8
#elif defined(BOARD_YYY)#define DM9000_BASEox200oo#define DM90oo_IRo 7
#elif defined (BOARD_Z2Z)#define DM9000_BASEox3000o#define DM9o0o_IRQ9...
#endif
上述代码主要有如下问题:
1)此段代码看起来面目可憎，如果有100个板子，就要iflelse 100次，到了第101个板子，又得重新加ifelse。代码进行着简单的“复制—粘贴”，“复制—粘贴”式的简单重复通常意味着代码编写者的水平很差。
2）非常难做到一个驱动支持多个设备，如果某个电路板上有两个DM9000网卡，则DM9000_BASE这个宏就不够用了，此时势必要定义出来DM9000_BASE 1、DM9000_BASE 2、DM9000_IRQ 1、DM9000_IRQ 2类的宏;定义了DM9000_BASE 1、DM9000_BASE2后，如果又有第3个DM9000网卡加到板子上，前面的代码就又不适用了。
3）依赖于make menuconfig选择的项目来编译内核，因此，在不同的硬件平台下要依赖于所选择的BOARD_XXX、BOARD_YYY选项来决定代码逻辑。这不符合ARM Linux 3.x一个映像适用于多个硬件的目标。实际上，我们可能同时选择了BOARD_XXX、BOARD_YYY、BOARD_ZZZ。
我们按照上面的方法编写代码的时候，相信自己编着编着也会觉得奇怪，代码不好。这个时候，我们有没有办法把设备端的信息从驱动里面剥离出来，让驱动以某种标准方法拿到这些平台信息呢Linux总线、设备和驱动模型实际上可以做到这一点，驱动就可以放之四海而皆准了。

⑷ linux主机侧与设备侧USB驱动

USB采用树形拓扑结构，主机侧和设备侧的USB控制器分别称为主机控制器（(Host Controller）和USB设备控制器(UDC)，每条总线上只有一个主机控制器，负责协调主机和设备间的通信，而设备不能主动向主机发送任何消息。

在Linux系统中，USB驱动可以从两个角度去观察，一个角度是主机侧，一个角度是设备侧。从上图主机侧去看，在Linux驱动中，处于USB驱动最底层的是USB主机控制器硬件，在其上运行的是USB主机控制器驱动，在主机控制器上的为USB核心层，再上层为USB设备驱动层(插入主机上的U盘、鼠标、USB转串口等设备驱动）。因此，在主机侧的层次结构中，要实现的USB驱动包括两类:USB主机控制器驱动和USB设备驱动，前者控制插入其中的USB设备，后者控制USB设备如何与主机通信。Linux内核中的USB核心负责USB驱动管理和协议处理的主要工作。主机控制器驱动和设备驱动之间的USB核心非常重要，其功能包括:通过定义一些数据结构、宏和功能函数，向上为设备驱动提供编程接口，向下为USB主机控制器驱动提供编程接口;维护整个系统的USB设备信息;完成设备热插拔控制、总线数据传输控制等。

⑸ linux驱动程序如何调用

1、进入到Ubuntu桌面后，打开终端，快捷键为ctrl+alt+T。

注意事项：

在很多企业网络中，为了追求速度和安全，Linux操作系统不仅仅是被网络运维人员当作服务器使用，Linux既可以当作服务器，又可以当作网络防火墙是Linux的 一大亮点。

⑹ linux如何安装驱动

在Intel网站直接下载的Linux驱动是e1000-5.2.52.tar.gz(版本可能会有改变),这个压缩包里面没有编译好的.o的文件,需要在Linux系统下编译之后才能使用，
因为网卡需要编译，所以要先确认将内核源文件安装好，下面是关于内核源文件的安装
● Linux下添加内核源文件
1． 用rpm –qa|grep kernel-source查看是否安装了这个包；
如果返回结果中有kernel-source-xxx(其中xxx为当前redhat的内核版本，如rhel3为2.4.21-4EL), 即已经 安装。如无返回结果则需要安装kernel-source包。到安装光盘中找到kernel-source-xxx.i386.rpm,用下面命令安装此rpm包：
2．如果安装了用rpm -V kernel-source校验是否有文件丢失,如果没有输出，表示文件完整；
3．如果有丢失用rpm -ivh --force kernel-source-xxxx...把包重新安装一下；
这个kernel-source包，在您的RH安装光盘中，在Redhat/RPMS中，如果以前没有安装过这个包，那么用rpm -ivh kernel-source-xxxx...来安装，如果安装过，需要覆盖安装，使用rpm -ivh --force kernel-source-xxxx...这个命令强制安装。
注：AS 4 开始，没有kernel-source这个包了，取而代之的是kernel-dev这个包，检查这个包有没有安装的方法同上
● 驱动安装步骤:
1. 把这个tar文件拷贝到用户自己定义的目录中,例如:
/home/username/e1000 or /usr/local/src/e1000
2. 用tar命令解这个压缩包:
tar zxf e1000-5.2.52.tar.gz
3. 切换到驱动的src目录下:
cd e1000-5.2.52/src/
4. 编译这个驱动模块:
make
然后安装这个模块
make install
这个二进制元将被安装到如下位置:
/lib/moles//kernel/drivers/net/e1000.o
以上的路径是默认的安装位置,在某些linux版本中可能是其他位置,具体信息可以查看在驱动的 tar压缩包中的ldistrib.txt文件.
5. 安装模块:
insmod e1000 （2.6以上的版本最好使用全路径安装 P insmod /lib/moles//kernel/drivers/net/e1000/e1000.ko）
6. 设定网卡IP地址：
ifconfig ethx <IP_address> x是网卡接口的号
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
若多个网卡的芯片相同可以cp ifcfg-eth0 ifcfg-eth1~~~~~~
修改下里面的drive名称就OK
!!!!!!!!!!!!!!!!!!!
在网卡的编译中很可能不能进行下去～这个原因除了kernel的开发包没有安装外还可能是由于开发环境不完全所引起的！
这时就需要你讲开发环境安装完成，最简单的办法就是通过 sysconfig-config-packet 安装gcc
安装完成后继续执行 make ；make install

了解更多开源相关，去LUPA社区看看吧

⑺ linux驱动有哪些

1、将驱动程序文件bcm5700src.rpm复制到一个临时目录中，并在此目录中运行以下命令；

2、运行以下命令切换到驱动目录中；

3、此目录中会生成一个名字为bcm5700.spec的文件，运行以下命令对驱动程序进行编译；

4、运行以下命令切换到RPM目录中；

5、运行以下命令安装驱动程序；

6、运行以下命令加载驱动模块；

7、运行kudzu命令，系统会自动搜索到硬件，进行配置即可。

linux是文件型系统，在linux中，一切皆文件，所有硬件都会在对应的目录(/dev)下面用相应的文件表示。 文件系统的linux下面，都有对于文件与这些设备关联的，访问这些文件就可以访问实际硬件。 通过访问文件去操作硬件设备，一切都会简单很多，不需要再调用各种复杂的接口。 直接读文件，写文件就可以向设备发送、接收数据。 按照读写存储数据方式，我们可以把设备分为以下几种：字符设备（character device）、块设备（Block device）和网络设备（ network interface）。

字符设备（character device）:指应用程序采用字符流方式访问的设备。这些设备节点通常为传真、虚拟终端和串口调制解调器、键盘之类设备提供流通信服务， 它通常只支持顺序访问。字符设备在实现时，大多不使用缓存器。系统直接从设备读取/写入每一个字符。

块设备（Block device）:通常支持随机存取和寻址，并使用缓存器，支持mount文件系统。典型的块设备有硬盘、SD卡、闪存等，但此类设备一般不需要自己开发，linux对此提过了大部分的驱动。

网络设备（network interface）:是一种特殊设备，它并不存在于/dev下面，主要用于网络数据的收发。网络驱动同块驱动最大的不同在于网络驱动异步接受外界数据，而块驱动只对内核的请求作出响应。

上述设备中，字符设备驱动程序适合于大多数简单的硬件设备，算是各类驱动程序中最简单的一类，一般也是从这类驱动开始学习，然后再开始学习采用IIC、SPI等通讯接口的一些设备驱动。可以基于此类驱动调试LKT和LCS系列加密芯片。注意7位IIC地址是0x28。

⑻ linux如何加载驱动

linux操作系统下，加载驱动的方式有二：
静态加载驱动；
动态加载驱动；

作为前者，静态加载驱动是通过将驱动程序编译到内核而进行的一系列配置操作；对于后者而言则是向内核注册设备信息，从而在kernel启动后，再通过insmod指令，关联好主、次设备号，从而以模块的形式进行加载的；

二者各有优点，所以应用的场合也是不一样的；

⑼ 想学习Linux 驱动，需要什么知识

首先，接触linux操作系统，在你的电脑上装一个linxu操作系统（建议ubuntu，比
较友好），熟悉经常要用的命令，熟悉环境（建议看“鸟哥的linux私房菜”）。
其次，阅读经典书籍是不可少的，建议先看ldd前四章，大概了解linux驱动的框架
，驱动是做什么的，该如何写驱动，那本书上有一些例子，可以在你的电脑上编译
，执行看看。后面的章节在结合自己的情况而定。
第三，建议阅读ulk（understanding the linux kernel）所有的内容，了解linux
内核的一些基本知识，在心中建立一个框架，不必完全懂，深入了解就好，以后经
常翻翻，受益无穷！
第四，别着急，这才是你真的进入linux驱动的第一步，花点钱买个开发板吧，然
后了解代码的编译，下载，看看板子的datasheet，针对自己感兴趣的深入研究。
建议学习流程，led灯控制---tp---i2c总线-----lcd-----camera----flash----
wifi/bt等。因为这个里面牵涉了甚多内核的子系统（input，v4l2,fb等
），所以可能要多话时间看代码，了解代码的框架，设计的思想等，只要一步一个
脚印，一定会有所成。
第五，因为现在的移动设备大多数都是android的了，所以你就要看看linux
kernel在android的作用，然后往上看看，看看hal层的代码，这些在调试中都是需
要的，如果有兴趣，更加可以看看framework的代码了，学习android一些工作机制
，类似于surfaceflinger，audioflinger等等。。
《linux就该这么学》免费提供最新Linux技术教程书籍，为开源技术爱好者努力做
得更多更好

⑽ Linux字符设备驱动的组成

在Linux中，字符设备驱动由如下几个部分组成。
1.字符设备驱动模块加载与卸载函数
在字符设备驱动模块加载函数中应该实现设备号的申请和cdev的注册，而在卸载函数中应实现设备号
的释放和cdev的注销。
Linux内核的编码习惯是为设备定义一个设备相关的结构体，该结构体包含设备所涉及的cdev、私有
数据及锁等信息。2.字符设备驱动的file_operations结构体中的成员函数
file_operations结构体中的成员函数是字符设备驱动与内核虚拟文件系统的接口，是用户空间对Linux
进行系统调用最终的落实者。设备驱动的读函数中，filp是文件结构体指针，buf是用户空间内存的地址，该地址在内核空间不宜直
接读写，count是要读的字节数，f_pos是读的位置相对于文件开头的偏移。
设备驱动的写函数中，filp是文件结构体指针，buf是用户空间内存的地址，该地址在内核空间不宜直
接读写，count是要写的字节数，f_pos是写的位置相对于文件开头的偏移。
由于用户空间不能直接访问内核空间的内存，因此借助了函数_from_user（）完成用户空间缓冲
区到内核空间的复制，以及_to_user（）完成内核空间到用户空间缓冲区的复制，见代码第6行和第14
行。
完成内核空间和用户空间内存复制的_from_user（）和_to_user（）的原型分别为：
unsigned long _from_user(void *to, const void _ _user *from, unsigned long count);
unsigned long _to_user(void _ _user *to, const void *from, unsigned long count);
上述函数均返回不能被复制的字节数，因此，如果完全复制成功，返回值为0。如果复制失败，则返
回负值。如果要复制的内存是简单类型，如char、int、long等，则可以使用简单的put_user（）和
get_user（）读和写函数中的_user是一个宏，表明其后的指针指向用户空间，实际上更多地充当了代码自注释的
功能。内核空间虽然可以访问用户空间的缓冲区，但是在访问之前，一般需要先检查其合法性，通过
access_ok（type，addr，size）进行判断，以确定传入的缓冲区的确属于用户空间。