Linux应用程序访问字符设备驱动详细过程【转】

本文转载自：http://blog.csdn.net/coding__madman/article/details/51346532

下面先通过一个编写好的内核驱动模块来体验以下字符设备驱动

可以暂时先忽略下面的代码实现！

memdev.c

[cpp] view plain copy
 
 在CODE上查看代码片派生到我的代码片
  1. #include <linux/module.h>  
  2. #include <linux/fs.h>  
  3. #include <linux/init.h>  
  4. #include <linux/cdev.h>  
  5. #include <asm/uaccess.h>  
  6.   
  7. int dev1_registers[5];  
  8. int dev2_registers[5];  
  9.   
  10. struct cdev cdev;   
  11. dev_t devno;  
  12.   
  13. /*文件打开函数*/  
  14. int mem_open(struct inode *inode, struct file *filp)  
  15. {  
  16.       
  17.     /*获取次设备号*/  
  18.     int num = MINOR(inode->i_rdev);  
  19.       
  20.     if (num==0)  
  21.         filp->private_data = dev1_registers;  
  22.     else if(num == 1)  
  23.         filp->private_data = dev2_registers;  
  24.     else  
  25.         return -ENODEV;  //无效的次设备号  
  26.       
  27.     return 0;   
  28. }  
  29.   
  30. /*文件释放函数*/  
  31. int mem_release(struct inode *inode, struct file *filp)  
  32. {  
  33.   return 0;  
  34. }  
  35.   
  36. /*读函数*/  
  37. static ssize_t mem_read(struct file *filp, char __user *buf, size_t size, loff_t *ppos)  
  38. {  
  39.   unsigned long p =  *ppos;  
  40.   unsigned int count = size;  
  41.   int ret = 0;  
  42.   int *register_addr = filp->private_data; /*获取设备的寄存器基地址*/  
  43.   
  44.   /*判断读位置是否有效*/  
  45.   if (p >= 5*sizeof(int))  
  46.     return 0;  
  47.   if (count > 5*sizeof(int) - p)  
  48.     count = 5*sizeof(int) - p;  
  49.   
  50.   /*读数据到用户空间*/  
  51.   if (copy_to_user(buf, register_addr+p, count))  
  52.   {  
  53.     ret = -EFAULT;  
  54.   }  
  55.   else  
  56.   {  
  57.     *ppos += count;  
  58.     ret = count;  
  59.   }  
  60.   
  61.   return ret;  
  62. }  
  63.   
  64. /*写函数*/  
  65. static ssize_t mem_write(struct file *filp, const char __user *buf, size_t size, loff_t *ppos)  
  66. {  
  67.   unsigned long p =  *ppos;  
  68.   unsigned int count = size;  
  69.   int ret = 0;  
  70.   int *register_addr = filp->private_data; /*获取设备的寄存器地址*/  
  71.     
  72.   /*分析和获取有效的写长度*/  
  73.   if (p >= 5*sizeof(int))  
  74.     return 0;  
  75.   if (count > 5*sizeof(int) - p)  
  76.     count = 5*sizeof(int) - p;  
  77.       
  78.   /*从用户空间写入数据*/  
  79.   if (copy_from_user(register_addr + p, buf, count))  
  80.     ret = -EFAULT;  
  81.   else  
  82.   {  
  83.     *ppos += count;  
  84.     ret = count;  
  85.   }  
  86.   
  87.   return ret;  
  88. }  
  89.   
  90. /* seek文件定位函数 */  
  91. static loff_t mem_llseek(struct file *filp, loff_t offset, int whence)  
  92. {   
  93.     loff_t newpos;  
  94.   
  95.     switch(whence) {  
  96.       case SEEK_SET:   
  97.         newpos = offset;  
  98.         break;  
  99.   
  100.       case SEEK_CUR:   
  101.         newpos = filp->f_pos + offset;  
  102.         break;  
  103.   
  104.       case SEEK_END:   
  105.         newpos = 5*sizeof(int)-1 + offset;  
  106.         break;  
  107.   
  108.       default:   
  109.         return -EINVAL;  
  110.     }  
  111.     if ((newpos<0) || (newpos>5*sizeof(int)))  
  112.         return -EINVAL;  
  113.           
  114.     filp->f_pos = newpos;  
  115.     return newpos;  
  116.   
  117. }  
  118.   
  119. /*文件操作结构体*/  
  120. static const struct file_operations mem_fops =  
  121. {  
  122.   .llseek = mem_llseek,  
  123.   .read = mem_read,  
  124.   .write = mem_write,  
  125.   .open = mem_open,  
  126.   .release = mem_release,  
  127. };  
  128.   
  129. /*设备驱动模块加载函数*/  
  130. static int memdev_init(void)  
  131. {  
  132.   /*初始化cdev结构*/  
  133.   cdev_init(&cdev, &mem_fops);  
  134.     
  135.   /* 注册字符设备 */  
  136.   alloc_chrdev_region(&devno, 0, 2, "memdev");  
  137.   cdev_add(&cdev, devno, 2);  
  138. }  
  139.   
  140. /*模块卸载函数*/  
  141. static void memdev_exit(void)  
  142. {  
  143.   cdev_del(&cdev);   /*注销设备*/  
  144.   unregister_chrdev_region(devno, 2); /*释放设备号*/  
  145. }  
  146.   
  147. MODULE_LICENSE("GPL");  
  148.   
  149. module_init(memdev_init);  
  150. module_exit(memdev_exit);  



1. 编译/安装驱动：在Linux系统中，驱动程序通常采用内核模块的程序结构来进行编码，因此编译、安装一个驱动程序，其实质就是编译/安装一个内核模块。

2. 创建设备文件

应用程序如何通过字符设备文件来访问设备驱动接口，即字符设备驱动程序访问大揭秘，下面先来看个应用程序的小例子：（应用程序是如何通过系统调用找到设备驱动程序入口的然后让设备驱动程序work）

read-mem.c

[html] view plain copy
 
 在CODE上查看代码片派生到我的代码片
  1. #include <stdio.h>  
  2. #include <sys/types.h>  
  3. #include <sys/stat.h>  
  4. #include <fcntl.h>  
  5.   
  6. int main()  
  7. {  
  8.     int fd = 0;  
  9.     int dst = 0;  
  10.       
  11.     /*打开设备文件*/  
  12.     fd = open("/dev/memdev0",O_RDWR);  
  13.       
  14.     /*写入数据*/  
  15.     read(fd, &dst, sizeof(int));  
  16.       
  17.     printf("dst is %d ",dst);  
  18.       
  19.     /*关闭设备*/  
  20.     close(fd);  
  21.       
  22.     return 0;     
  23.   
  24. }  


在linux下对上面的文件进行静态编译（考虑到前面开发板上移植的某些库还没有添加进去）生成read-mem目标文件，然后进行反汇编并将反汇编生成的文件导入到当前目录下的dump上去。

VIM打开dump文件，搜索/main 可以看到这一段汇编代码

可以看到 应用程序中的read()函数实际是调用了__libc_read函数, 然后继续在dump中搜索__libc_read函数

这里红箭头指向的两行是比较重要的两行，将3传给r7，然后使用了SVC系统调用指令，这时PC指针会从用户空间进入到内核空间（通过一个固定的入口），第二步会取r7寄存器里面的值3， 然后根据这个值查一个表确定要调用那个系统调用（即对于3的系统调用内核代码）。这里打开内核源码工程，打开一个文件：

entry-comon.S(/arch/arm/kernel目录下)

上面的内核代码部分vector_swi就是那个固定的入口，第二个箭头部分就是上面所说的第二步，第三步在这部分的代码下面这里截图截不了这么多（也就是根据number查表）

[html] view plain copy
 
 在CODE上查看代码片派生到我的代码片
  1. enable_irq  
  2.   
  3.     get_thread_info tsk  
  4.     adr tbl, <span style="color:#ff0000;">sys_call_table</span>     @ load syscall table pointer  

搜索sys_call_table，来看看这张表是什么？


查看calls.S文件

系统就是通过固定入口进入内核空间，然后取出系统调用编号，在利用编号查找上面的这张表，然后取出内核中对于上面用户空间的read的实现函数！（这里就分析了用户空间的read是如何找到内核空间的sys_read的过程）

这里顺便看一下sys_read的内核代码实现：/fs 目录下的 Read_write.c文件中

[cpp] view plain copy
 
 在CODE上查看代码片派生到我的代码片
  1. SYSCALL_DEFINE3(read, unsigned int, fd, char __user *, buf, size_t, count)  
  2. {  
  3.     struct file *file;  
  4.     ssize_t ret = -EBADF;  
  5.     int fput_needed;  
  6.   
  7.     file = fget_light(fd, &fput_needed);  
  8.     if (file) {  
  9.         loff_t pos = file_pos_read(file);  
  10.         ret = vfs_read(file, buf, count, &pos);  
  11.         file_pos_write(file, pos);  
  12.         fput_light(file, fput_needed);  
  13.     }  
  14.   
  15.     return ret;  
  16. }  

每个打开的文件都会有一个struct file与之对应！从上面的函数可以看到通过传入的fd参数 能找到与之对应的struct file.

然后通过file 调用了vfs_read()函数.下面先看看该函数的内部实现。



红色箭头部分！f_op部分是驱动程序里面的自定义结构，通过f_op结构找到设备读取方法！

就是这个：

[cpp] view plain copy
 
 在CODE上查看代码片派生到我的代码片
  1. /*文件操作结构体*/  
  2. static const struct file_operations mem_fops =  
  3. {  
  4.   .llseek = mem_llseek,  
  5.   .read = mem_read,  
  6.   .write = mem_write,  
  7.   .open = mem_open,  
  8.   .release = mem_release,  
  9. };  

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/zzb-Dream-90Time/p/6254973.html