Linux的应用层到底层驱动的调用过程

应用层如何内核.md

1.从应用层打通内核：驱动

首先来说是设备号的引入，我们通过 cat/proc/kallsyms |grep mydevice 可以查看设备号，当然我们也是可以自己创建设备号，这是源于我们在写内核模块的时候在程序中指定。设备号有了，他就可以标识我们具体的设备。那我们应用层如何操作那？其实我们应用层需要创建一个设备节点文件创建的方法是sudo mknod /dev/hello c 255 0 这样我们就可以创建一个指定设备号的设备节点文件。通过设备号，使设备节点文件和内核中的设备驱动程序关联了起来。这其实也就打通了。有了文件，我们应用层就可以用open啊，read啊去操作这个设备节点文件。真正体现了linux下一切皆文件啊！。

2.具体实现：

用户空间通过mknod创建了一个设备文件hello（设备号） 对应在内核空间创建一个inode结构体（包含有设备号）与之对应
应用程序打开这个设备文件： 操作inode结构体，取出inode里面的设备号 ==》 到内核的cdev链表中去查找这个设备号对应的cdev对象 ==》 找到
cdev对象里面的fops ===》 找到fops里面的open函数指针 ==》 这个函数指针指向我们自己实行的open函数。

3.实现一个驱动服务于多个设备：

按照以前的思路：我们现在如果是一个服务，服务于多个设备，那么问题就来了，显然我们是不会写多个驱动程序的，但是有些数据是我们必须要有多份的。比如我们现在拿最简单
的一个操作，我们在驱动程序里面注册俩个设备号，那么意味着我们在用户空间，有俩个设备节点文件，我们在应用程序中打开俩份，都采用写入的方式，写数据，如果内核中我们把
接受数据的缓冲区没有重新备份，公用一份，结果就是数据的覆盖。这些存储的数据显然是要区分的，那个设备就是那个设备，既然是服务于多设备，那设备号的创建也自然是创建多个
注册多个，这些都可以非常容易的指定，具体可以看代码以及cdev显然也是俩份，他们都在内核的链表中，但是注意cdev结构体中的fops指针都指向的是同一个，所以fops是使用的同一个
其实也很好理解fops里面都是些读写操作的函数指针，没必要区分。共用更加好。
，对于cdev还比较简单，我们在创建自己的cdev结构体的时候，指定参数就可以多创建。
最后我们干脆把这些都要用到的东西打包个结构体，叫做设备结构体。我们回顾上面，当我们又一个设备使用驱动程序的时候，我们指定一个相关数据接收，但是多个设备文件的时候
就出现了对应问题，那就是 ：对应问题，我们如何指定设备号对应的保存数据的变量（更加准确的是设备结构体中的变量，因为我们封装了）。在open的时候，我们是非常清楚当前的
设备号的因为open的时候，系统函数给我们传递了struct inode * inodep, struct file * filep 俩个参数，第一个参数是inode号，第二个是filep（这个结构体保存了我，文件的状态，以及当前
decv。我们通过inodep->i_cdev 获取到当前的cdev的地址，然后通过container_of(ptr, type, member)根据结构体成员的地址从而获取到整个结构体的首地址。
拿到了设备结构体的首地址，然后通过filep->private_data = dev;将地址保存到file结构体中，借助file传递，因为file在读写函数中也调用了。到了读写函数中我们首先用一个对应的结构体指针把传来
的地址接收struct hello_device * dev = filep->private_data;哈哈哈，我们在读写函数中拿到了我们的数据，而且是依靠不同的decv，拿到不同的设备结构体。

完美@！

  1. #include<linux/module.h>
  2. #include<linux/init.h>
  3. #include<linux/fs.h>
  4. #include<linux/cdev.h>
  5. #include<asm/uaccess.h>
  6. /*2017年1月12日19:49:34 张飞online*/
  7. /* 许可证声明 */
  8. MODULE_LICENSE("GPL");
  10. #define NUM_OF_DEV 2
  12. int major =255;
  13. int minor =0;
  15. //设备结构体：将自己用的数据封装
  16. struct hello_device {
  17. dev_t devno;//设备号
  18. struct cdev mycdev;// cdev
  19. char data[64];
  20. }hello_dev[NUM_OF_DEV];
  21. //hello_dev[0] //设备1
  22. //hello_dev[1] //设备2
  25. /*##############################################
  26. *应用程序的open调用驱动的 hello_open 依靠 设备号和cdev中的iops，具体实现
  27. 可以看上面的文字
  28. *
  29. ##############################################*/
  30. staticint hello_open(struct inode * inodep,struct file * filep)
  31. {
  32. struct hello_device * dev;
  33. printk("-- %s called -- major = %d minor = %d ", __FUNCTION__, imajor(inodep), iminor(inodep));
  35. /*inodep->i_cdev指明设备结构体中的mycdev地址，最终获取到当前cdev对应的我们自己定义的
  36. 设备结构体的地址，这是核心：就是依靠当前cdev获取当前我们的结构体地址
  37. */
  38. dev = container_of(inodep->i_cdev,struct hello_device, mycdev);
  39. /*
  40. 用file中的私有数据传出，因为读写函数也传入了file，而且file也是一 一对应的，当前文件的file
  41. */
  42. filep->private_data = dev;
  44. return0;
  45. }
  47. //应用程序的close调用驱动的hello_release
  48. staticint hello_release(struct inode * inodep,struct file * filep)
  49. {
  50. printk("-- %s called -- ", __FUNCTION__);
  52. return0;
  53. }
  55. staticssize_t hello_read(struct file * filep,char __user * buf,size_t size,loff_t* off)
  56. {
  57. /*
  58. 获取到了当前file，然后用结构体指针承接，实现修改
  59. */
  60. struct hello_device * dev;
  62. dev = filep->private_data;
  63. //check param
  64. if(size <0|| size >64)
  65. return-EINVAL;
  67. if(copy_to_user(buf, dev->data, size))
  68. {
  69. //为真，表示失败
  70. printk("cp err ");
  71. return-1;
  72. }
  73. else{
  74. return size;
  75. }
  76. }
  79. staticssize_t hello_write(struct file * filep,constchar __user * buf,size_t size,loff_t* off)
  80. {
  81. struct hello_device * dev = filep->private_data;
  83. //check param
  84. if(size <0|| size >64)
  85. return-EINVAL;
  87. if(copy_from_user(dev->data, buf, size))
  88. {
  89. return-1;
  90. }
  91. else{
  92. return size;
  93. }
  94. }
  96. struct file_operations hello_fops ={
  97. .owner = THIS_MODULE,
  98. .open = hello_open,
  99. .release = hello_release,
  100. .read = hello_read,
  101. .write = hello_write,
  102. };
  104. staticint cdev_setup(struct cdev * cdev,dev_t devno)
  105. {
  106. int ret;
  108. cdev_init(cdev,&hello_fops);
  109. cdev->owner = THIS_MODULE;
  110. ret = cdev_add(cdev, devno,1);
  111. if(ret <0)
  112. return-1;
  114. return0;
  115. }
  118. /* 模块加载函数，当向内核中插入这个模块的时候会被调用 */
  119. int hello_init(void)
  120. {
  121. int ret;
  122. //做初始化的动作
  123. printk("-- %s called -- ", __FUNCTION__);
  125. //1. 注册设备号
  126. hello_dev[0].devno = MKDEV(major, minor);
  127. hello_dev[1].devno = MKDEV(major, minor+1);
  129. //注册来两个设备号，255 0 和255 1
  130. ret = register_chrdev_region(hello_dev[0].devno, NUM_OF_DEV,"hello-device");
  131. if(ret <0)
  132. {
  133. printk("register_chrdev_region err ");
  134. goto err1;
  135. }
  137. //2. cdev结构体插入内核链表
  138. ret = cdev_setup(&hello_dev[0].mycdev, hello_dev[0].devno);
  139. if(ret <0)
  140. {
  141. printk("cdev_add err ");
  142. goto err2;
  143. }
  145. ret = cdev_setup(&hello_dev[1].mycdev, hello_dev[1].devno);
  146. if(ret <0)
  147. {
  148. printk("cdev_add err ");
  149. goto err3;
  150. }
  151. // 初始化用户数据
  152. strcpy(hello_dev[0].data,"000000000000000000000000000000000000");
  153. strcpy(hello_dev[1].data,"111111111111111111111111111111111111");
  155. return0;
  156. /*
  157. 这里是删除内核链表中的cdev 和 释放设备号，借助goto，巧妙释放全部
  159. */
  160. err3:
  161. cdev_del(&hello_dev[0].mycdev);
  162. err2:
  163. unregister_chrdev_region(hello_dev[0].devno, NUM_OF_DEV);
  164. err1:
  165. return-1;
  166. }
  168. /* 模块的卸载函数，当从内核中把本模块删除的时候被调用 */
  169. void hello_exit(void)
  170. {
  171. //做和init_module相反的动作
  172. printk("-- %s called -- ", __FUNCTION__);
  174. cdev_del(&hello_dev[1].mycdev);
  175. cdev_del(&hello_dev[0].mycdev);
  176. unregister_chrdev_region(hello_dev[0].devno, NUM_OF_DEV);
  178. return;
  179. }
  181. //声明hello_init为模块的加载函数
  182. module_init(hello_init);
  183. module_exit(hello_exit);
  185. MODULE_AUTHOR("farsight");
  186. MODULE_DESCRIPTION("This is a simple moudles");

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/zhangfeionline/p/6279836.html