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\n", __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 --\n", __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\n");
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 --\n", __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\n");
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\n");
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\n");
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 --\n", __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");