Linux内核调试技术之自构proc

1、简介

在内核中使用printk可以讲调试信息保存在log_buf缓冲区中，可以使用命令 #cat /proc/kmsg 将缓冲区的数区的数数据打印出来,今天我们就来研究一下，自己写kmsg这个文件，我们取名叫做 mymsg。

2、查看内核中 /proc/kmsg怎么写的!

在Proc_misc.c (fs\proc) 文件中：

1. void __init proc_misc_init(void){ 
2.     ......................... 
3.         struct proc_dir_entry *entry; 
4.         //这里创建了一个proc入口kmsg 
5.         entry = create_proc_entry("kmsg", S_IRUSR, &proc_root); 
6.         if (entry)　/*构造一个proc_fops结构*/ 
7.  entry->proc_fops = &proc_kmsg_operations;......................... }  

在Kmsg.c (fs\proc) 文件中：

1. const struct file_operations proc_kmsg_operations = { 
2.     .read        = kmsg_read, 
3.     .poll        = kmsg_poll, 
4.     .open        = kmsg_open, 
5.     .release    = kmsg_release,};  

在用户空间中使用 cat /proc/kmsg的时候，会调用kmsg_open，在调用kmsg_read函数，读取log_buf中的数据，拷贝到用户空间显示。

3、在写之前，我们需要来学习一下循环队列

环形队列是在实际编程极为有用的数据结构，它有如下特点：

• 它是一个首尾相连的FIFO的数据结构，采用数组的线性空间，数据组织简单，能很快知道队列是否满为空。能以很快速度的来存取数据。
• 因为有简单高效的原因，甚至在硬件都实现了环形队列。
• 环形队列广泛用于网络数据收发，和不同程序间数据交换(比如内核与应用程序大量交换数据，从硬件接收大量数据)均使用了环形队列。

3.1.环形队列实现原理

内存上没有环形的结构，因此环形队列实上是数组的线性空间来实现。那当数据到了尾部如何处理呢?它将转回到0位置来处理。这个的转回是通过取模操作来执行的。

因此环列队列的是逻辑上将数组元素q[0]与q[MAXN-1]连接，形成一个存放队列的环形空间。

为了方便读写，还要用数组下标来指明队列的读写位置。head/tail.其中head指向可以读的位置，tail指向可以写的位置。

环形队列的关键是判断队列为空，还是为满。当tail追上head时，队列为满时，当head追上tail时，队列为空。但如何知道谁追上谁。还需要一些辅助的手段来判断.

如何判断环形队列为空，为满有两种判断方法。

(1)是附加一个标志位tag

当head赶上tail，队列空，则令tag=0,

当tail赶上head，队列满，则令tag=1,

(2)限制tail赶上head，即队尾结点与队首结点之间至少留有一个元素的空间。

队列空： head==tail

队列满： (tail+1)% MAXN ==head

4、程序编写

1. #include <linux/module.h> 
2. #include<linux/kernel.h> 
3. #include<linux/fs.h> 
4. #include<linux/init.h> 
5. #include<linux/delay.h> 
6. #include<asm/uaccess.h> 
7. #include<asm/irq.h> 
8. #include<asm/io.h> 
9. #include<asm/arch/regs-gpio.h> 
10. #include<asm/hardware.h> 
11. #include<linux/proc_fs.h> 
12.  
13. #define MYLOG_BUF_LEN 1024 
14. static char mylog_buf[MYLOG_BUF_LEN]; 
15. static char tmp_buf[MYLOG_BUF_LEN]; 
16. static int mylog_r = 0; 
17. static int mylog_w = 0; 
18. static int mylog_r_tmp = 0; 
19.  
20. /*休眠队列初始化*/ 
21. static DECLARE_WAIT_QUEUE_HEAD(mymsg_waitq); 
22.  
23. /* 
24. *判断环形队列是否为空 
25. *返回0:表示不空  返回1:表示空 
26. */ 
27. static int is_mylog_empty(void) 
28. { 
29.    return (mylog_r == mylog_w); 
30. } 
31.  
32. /* 
33. *判断环形队列是否满 
34. *返回0:表示不满  返回1:表示满 
35. */ 
36. static int is_mylog_full(void) 
37. { 
38.    return((mylog_w + 1)% MYLOG_BUF_LEN == mylog_r); 
39. } 
40.  
41. /* 
42. *在读取的时候，判断环形队列中数据是否为空 
43. *返回0:表示不空  返回1:表示空 
44. */ 
45. static int is_mylog_empty_for_read(void) 
46. { 
47.    return (mylog_r_tmp == mylog_w); 
48. } 
49.  
50. /* 
51. *往循环队列中存字符 
52. *输入:c字符 单位:1byte 
53. *输出:无 
54. */ 
55. static void mylog_putc(char c) 
56. { 
57.  
58.    if(is_mylog_full()) 
59.     { 
60.        /*如果检测到队列已经满了，则丢弃该数据*/ 
61.         mylog_r= (mylog_r + 1) % MYLOG_BUF_LEN; 
62.          
63.        /*mylog_r_tmp不能大于mylog_r*/ 
64.         if((mylog_r_tmp + 1)% MYLOG_BUF_LEN == mylog_r) 
65.             mylog_r_tmp= mylog_r; 
66.          
67.     } 
68.     mylog_buf[mylog_w]= c; 
69.    /*当mylog_w=1023的时候 (mylog_w+1) % MYLOG_BUF_LEN =0,回到队列头，实现循环*/ 
70.     mylog_w= (mylog_w + 1) % MYLOG_BUF_LEN; 
71.    /* 唤醒等待数据的进程*/     
72.     wake_up_interruptible(&mymsg_waitq);   
73. } 
74.  
75. /* 
76. *从循环队列中读字符 
77. *输入:*p 单位:1byte 
78. *输出:1表示成功 
79. */ 
80. static int mylog_getc(char *p) 
81. { 
82.    /*判断数据是否为空*/ 
83.     if (is_mylog_empty_for_read()) 
84.     { 
85.        return 0; 
86.     } 
87.    *p = mylog_buf[mylog_r_tmp ]; 
88.     mylog_r_tmp = (mylog_r_tmp  + 1) % MYLOG_BUF_LEN; 
89.    return 1; 
90. } 
91.  
92. /* 
93. *调用myprintk，和printf用法相同 
94. */ 
95. int myprintk(const char *fmt, ...) 
96. { 
97.     va_list args; 
98.    int i; 
99.    int j; 
100.  
101.     va_start(args, fmt); 
102.     i= vsnprintf(tmp_buf, INT_MAX, fmt, args); 
103.     va_end(args); 
104.      
105.    for (j = 0; j < i; j++) 
106.         mylog_putc(tmp_buf[j]); 
107.          
108.    return i; 
109. } 
110.  
111.  
112. static ssize_t mymsg_read(struct file *file, char __user *buf, 
113.             size_t count, loff_t*ppos) 
114. { 
115.    int error=0; 
116.     size_t i=0; 
117.    char c; 
118.    /* 把mylog_buf的数据copy_to_user, return*/ 
119.  
120.     /*非阻塞 和 缓冲区为空的时候返回*/ 
121.     if ((file->f_flags & O_NONBLOCK) && is_mylog_empty()) 
122.        return -EAGAIN; 
123.      
124.    /*休眠队列wait_event_interruptible(xxx,0)-->休眠*/ 
125.     error= wait_event_interruptible(mymsg_waitq, !is_mylog_empty_for_read()); 
126.      
127.    /* copy_to_user*/ 
128.     while (!error && (mylog_getc(&c)) && i < count) { 
129.         error= __put_user(c, buf); 
130.         buf++; 
131.         i++; 
132.     } 
133.    if (!error) 
134.         error= i; 
135.    /*返回实际读到的个数*/ 
136.     return error; 
137. } 
138.  
139. static int mymsg_open(struct inode * inode, struct file * file) 
140. { 
141.     mylog_r_tmp= mylog_r; 
142.    return 0; 
143. } 
144.  
145.  
146. const struct file_operations proc_mymsg_operations = { 
147.     .read= mymsg_read, 
148.     .open= mymsg_open, 
149.     }; 
150. static int mymsg_init(void) 
151. { 
152.    struct proc_dir_entry *myentry; kmsg 
153.     myentry= create_proc_entry("mymsg", S_IRUSR, &proc_root); 
154.    if (myentry) 
155.         myentry->proc_fops = &proc_mymsg_operations; 
156.    return 0; 
157. } 
158.  
159. static void mymsg_exit(void) 
160. { 
161.     remove_proc_entry("mymsg", &proc_root); 
162. } 
163.  
164. module_init(mymsg_init); 
165. module_exit(mymsg_exit); 
166.  
167. /*声名到内核空间*/ 
168. EXPORT_SYMBOL(myprintk); 
169.  
170. MODULE_LICENSE("GPL");  

5、测试程序

注意:在上面程序中 使用了 EXPORT_SYMBOL(myprintk);意思是把myprintk可以在整个内核空间使用。

使用方法：

①extern int myprintk(const char *fmt, ...);声明

② myprintk("first_drv_open : %d\n", ++cnt);使用

1. #include <linux/module.h> 
2. #include<linux/kernel.h> 
3. #include<linux/fs.h> 
4. #include<linux/init.h> 
5. #include<linux/delay.h> 
6. #include<asm/uaccess.h> 
7. #include<asm/irq.h> 
8. #include<asm/io.h> 
9. #include<asm/arch/regs-gpio.h> 
10. #include<asm/hardware.h> 
11.  
12. static struct class *firstdrv_class; 
13. static struct class_device    *firstdrv_class_dev; 
14.  
15. volatile unsigned long *gpfcon = NULL; 
16. volatile unsigned long *gpfdat = NULL; 
17.  
18. extern int myprintk(const char *fmt, ...); 
19.  
20. static int first_drv_open(struct inode *inode, struct file *file) 
21. { 
22.    static int cnt = 0; 
23.     myprintk("first_drv_open : %d\n", ++cnt); 
24.    /* 配置GPF4,5,6为输出*/ 
25.     *gpfcon &= ~((0x3<<(4*2)) | (0x3<<(5*2)) | (0x3<<(6*2))); 
26.    *gpfcon |= ((0x1<<(4*2)) | (0x1<<(5*2)) | (0x1<<(6*2))); 
27.    return 0; 
28. } 
29.  
30. static ssize_t first_drv_write(struct file *file, const char __user *buf, size_t count, loff_t * ppos) 
31. { 
32.    int val; 
33.    static int cnt = 0; 
34.  
35.     myprintk("first_drv_write : %d\n", ++cnt); 
36.  
37.     copy_from_user(&val, buf, count); //    copy_to_user(); 
38.  
39.     if (val == 1) 
40.     { 
41.        // 点灯 
42.         *gpfdat &= ~((1<<4) | (1<<5) | (1<<6)); 
43.     } 
44.    else 
45.     { 
46.        // 灭灯 
47.         *gpfdat |= (1<<4) | (1<<5) | (1<<6); 
48.     } 
49.      
50.    return 0; 
51. } 
52.  
53. static struct file_operations first_drv_fops = { 
54.     .owner =  THIS_MODULE,    /* 这是一个宏，推向编译模块时自动创建的__this_module变量*/ 
55.     .open  =  first_drv_open,     
56.     .write   =    first_drv_write,       
57. }; 
58.  
59.  
60. int major; 
61. static int first_drv_init(void) 
62. { 
63.     myprintk("first_drv_init\n"); 
64.     major= register_chrdev(0, "first_drv", &first_drv_fops); // 注册, 告诉内核 
65.  
66.     firstdrv_class= class_create(THIS_MODULE, "firstdrv"); 
67.  
68.     firstdrv_class_dev= class_device_create(firstdrv_class, NULL, MKDEV(major, 0), NULL, "xyz"); /* /dev/xyz*/ 
69.  
70.     gpfcon= (volatile unsigned long *)ioremap(0x56000050, 16); 
71.     gpfdat= gpfcon + 1; 
72.  
73.    return 0; 
74. } 
75.  
76. static void first_drv_exit(void) 
77. { 
78.     unregister_chrdev(major,"first_drv"); // 卸载 
79.  
80.     class_device_unregister(firstdrv_class_dev); 
81.     class_destroy(firstdrv_class); 
82.     iounmap(gpfcon); 
83. } 
84.  
85. module_init(first_drv_init); 
86. module_exit(first_drv_exit); 
87.  
88.  
89. MODULE_LICENSE("GPL");  

6、在tty中测试效果

1. # insmod my_msg.ko 
2. # insmod first_drv.ko 
3. # cat /proc/mymsg 
4. mymsg_open mylog_r_tmp=0 
5. first_drv_init  

本文作者：佚名

来源：51CTO