02.驱动调试

  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 
 15 struct proc_dir_entry *myentry;
 16 
 17 static char mylog_buf[MYLOG_BUF_LEN];
 18 static char tmp_buf[MYLOG_BUF_LEN];
 19 static int mylog_r = 0;
 20 static int mylog_r_for_read = 0;
 21 static int mylog_w = 0;
 22 
 23 static DECLARE_WAIT_QUEUE_HEAD(mymsg_waitq);
 24 
 25 static int is_mylog_empty(void)
 26 {
 27     return (mylog_r == mylog_w);
 28 }
 29 
 30 static int is_mylog_empty_for_read(void)
 31 {
 32     return (mylog_r_for_read == mylog_w);
 33 }
 34 
 35 static int is_mylog_full(void)
 36 {
 37     return ((mylog_w + 1)% MYLOG_BUF_LEN == mylog_r);
 38 }
 39 
 40 static void mylog_putc(char c)
 41 {
 42     if (is_mylog_full())
 43     {
 44         /* 丢弃一个数据 */
 45         mylog_r = (mylog_r + 1) % MYLOG_BUF_LEN;
 46 
 47         if ((mylog_r_for_read + 1) % MYLOG_BUF_LEN == mylog_r)
 48         {
 49             mylog_r_for_read = mylog_r;
 50         }
 51     }
 52 
 53     mylog_buf[mylog_w] = c;
 54     mylog_w = (mylog_w + 1) % MYLOG_BUF_LEN;
 55 
 56     /* 唤醒等待数据的进程 */    
 57     wake_up_interruptible(&mymsg_waitq);   /* 唤醒休眠的进程 */    
 58 }
 59 
 60 static int mylog_getc(char *p)
 61 {
 62     if (is_mylog_empty())
 63     {
 64         return 0;
 65     }
 66     *p = mylog_buf[mylog_r];
 67     mylog_r = (mylog_r + 1) % MYLOG_BUF_LEN;
 68     return 1;
 69 }
 70 
 71 static int mylog_getc_for_read(char *p)
 72 {
 73     if (is_mylog_empty_for_read())
 74     {
 75         return 0;
 76     }
 77     *p = mylog_buf[mylog_r_for_read];
 78     mylog_r_for_read = (mylog_r_for_read + 1) % MYLOG_BUF_LEN;
 79     return 1;
 80 }
 81 
 82 
 83 int myprintk(const char *fmt, ...)
 84 {
 85     va_list args;
 86     int i;
 87     int j;
 88 
 89     va_start(args, fmt);
 90     i = vsnprintf(tmp_buf, INT_MAX, fmt, args);
 91     va_end(args);
 92     
 93     for (j = 0; j < i; j++)
 94         mylog_putc(tmp_buf[j]);
 95         
 96     return i;
 97 }
 98 
 99 static ssize_t mymsg_read(struct file *file, char __user *buf,
100              size_t count, loff_t *ppos)
101 {
102     int error = 0;
103     int i = 0;
104     char c;
105 
106     /* 把mylog_buf的数据copy_to_user, return */
107     if ((file->f_flags & O_NONBLOCK) && is_mylog_empty_for_read())
108         return -EAGAIN;
109 
110     //printk("%s %d\n", __FUNCTION__, __LINE__);
111     //printk("count = %d\n", count);
112     //printk("mylog_r = %d\n", mylog_r);
113     //printk("mylog_w = %d\n", mylog_w);
114 
115     error = wait_event_interruptible(mymsg_waitq, !is_mylog_empty_for_read());
116 
117     //printk("%s %d\n", __FUNCTION__, __LINE__);
118     //printk("count = %d\n", count);
119     //printk("mylog_r = %d\n", mylog_r);
120     //printk("mylog_w = %d\n", mylog_w);
121 
122     /* copy_to_user */
123     while (!error && (mylog_getc_for_read(&c)) && i < count) {
124         error = __put_user(c, buf);
125         buf++;
126         i++;
127     }
128     
129     if (!error)
130         error = i;
131     
132     return error;
133 }
134 
135 static int mymsg_open(struct inode *inode, struct file *file)
136 {
137     mylog_r_for_read = mylog_r;
138     return 0;
139 }
140 
141 const struct file_operations proc_mymsg_operations = {
142     .open = mymsg_open,
143     .read = mymsg_read,
144 };
145 
146 static int mymsg_init(void)
147 {    
148     myentry = create_proc_entry("mymsg", S_IRUSR, &proc_root);
149     if (myentry)
150         myentry->proc_fops = &proc_mymsg_operations;
151     return 0;
152 }
153 
154 static void mymsg_exit(void)
155 {
156     remove_proc_entry("mymsg", &proc_root);
157 }
158 
159 module_init(mymsg_init);
160 module_exit(mymsg_exit);
161 
162 EXPORT_SYMBOL(myprintk);
163 
164 MODULE_LICENSE("GPL");

  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 <linux/irq.h>
  7 #include <asm/uaccess.h>
  8 #include <asm/irq.h>
  9 #include <asm/io.h>
 10 #include <asm/arch/regs-gpio.h>
 11 #include <asm/hardware.h>
 12 #include <linux/poll.h>
 13 #include <linux/device.h>
 14 
 15 #define KER_RW_R8      0
 16 #define KER_RW_R16     1
 17 #define KER_RW_R32     2
 18 
 19 #define KER_RW_W8      3
 20 #define KER_RW_W16     4
 21 #define KER_RW_W32     5
 22 
 23 
 24 static int major;
 25 static struct class *class;
 26 static struct class_device    *ker_dev;
 27 
 28 
 29 static int ker_rw_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
 30 {
 31     volatile unsigned char  *p8;
 32     volatile unsigned short *p16;
 33     volatile unsigned int   *p32;
 34     unsigned int val;
 35     unsigned int addr;
 36 
 37     unsigned int buf[2];
 38 
 39     copy_from_user(buf, (const void __user *)arg, 8);
 40     addr = buf[0];
 41     val  = buf[1];
 42     
 43     p8  = (volatile unsigned char *)ioremap(addr, 4);
 44     p16 = p8;
 45     p32 = p8;
 46 
 47     switch (cmd)
 48     {
 49         case KER_RW_R8:
 50         {
 51             val = *p8;
 52             copy_to_user((void __user *)(arg+4), &val, 4);
 53             break;
 54         }
 55 
 56         case KER_RW_R16:
 57         {
 58             val = *p16;
 59             copy_to_user((void __user *)(arg+4), &val, 4);
 60             break;
 61         }
 62 
 63         case KER_RW_R32:
 64         {
 65             val = *p32;
 66             copy_to_user((void __user *)(arg+4), &val, 4);
 67             break;
 68         }
 69 
 70         case KER_RW_W8:
 71         {
 72             *p8 = val;
 73             break;
 74         }
 75 
 76         case KER_RW_W16:
 77         {
 78             *p16 = val;
 79             break;
 80         }
 81 
 82         case KER_RW_W32:
 83         {
 84             *p32 = val;
 85             break;
 86         }
 87     }
 88 
 89     iounmap(p8);
 90     return 0;
 91 }
 92 
 93 static struct file_operations ker_rw_ops = {
 94     .owner   = THIS_MODULE,
 95     .ioctl   = ker_rw_ioctl,
 96 };
 97 
 98 static int ker_rw_init(void)
 99 {
100     major = register_chrdev(0, "ker_rw", &ker_rw_ops);
101 
102     class = class_create(THIS_MODULE, "ker_rw");
103 
104     /* 为了让mdev根据这些信息来创建设备节点 */
105     ker_dev = class_device_create(class, NULL, MKDEV(major, 0), NULL, "ker_rw"); /* /dev/ker_rw */
106     
107     return 0;
108 }
109 
110 static void ker_rw_exit(void)
111 {
112     class_device_unregister(ker_dev);
113     class_destroy(class);
114     unregister_chrdev(major, "ker_rw");
115 }
116 
117 module_init(ker_rw_init);
118 module_exit(ker_rw_exit);
119 
120 
121 MODULE_LICENSE("GPL");

  1 #include <sys/types.h>
  2 #include <sys/stat.h>
  3 #include <fcntl.h>
  4 #include <stdio.h>
  5 #include <poll.h>
  6 #include <signal.h>
  7 #include <sys/types.h>
  8 #include <unistd.h>
  9 #include <fcntl.h>
 10 #include <stdlib.h>
 11 #include <string.h>
 12 
 13 #define KER_RW_R8      0
 14 #define KER_RW_R16     1
 15 #define KER_RW_R32     2
 16 
 17 #define KER_RW_W8      3
 18 #define KER_RW_W16     4
 19 #define KER_RW_W32     5
 20 
 21 
 22 /* Usage:
 23  * ./regeditor r8  addr [num]
 24  * ./regeditor r16 addr [num]
 25  * ./regeditor r32 addr [num]
 26  *
 27  * ./regeditor w8  addr val
 28  * ./regeditor w16 addr val 
 29  * ./regeditor w32 addr val
 30  */
 31 
 32 void print_usage(char *file)
 33 {
 34     printf("Usage:\n");
 35     printf("%s <r8 | r16 | r32> <phy addr> [num]\n", file);
 36     printf("%s <w8 | w16 | w32> <phy addr> <val>\n", file);
 37 }
 38 
 39 int main(int argc, char **argv)
 40 {
 41     int fd;
 42     unsigned int buf[2];
 43     unsigned int i;
 44     unsigned int num;
 45     
 46     if ((argc != 3) && (argc != 4))
 47     {
 48         print_usage(argv[0]);
 49         return -1;
 50     }
 51 
 52     fd = open("/dev/ker_rw", O_RDWR);
 53     if (fd < 0)
 54     {
 55         printf("can‘t open /dev/ker_rw\n");
 56         return -2;
 57     }
 58 
 59     /* addr */
 60     buf[0] = strtoul(argv[2], NULL, 0);
 61 
 62     if (argc == 4)
 63     {
 64         buf[1] = strtoul(argv[3], NULL, 0);
 65         num    = buf[1];
 66     }
 67     else
 68     {
 69         num = 1;
 70     }
 71 
 72     if (strcmp(argv[1], "r8") == 0)
 73     {
 74         for ( i = 0; i < num; i++)
 75         {
 76             ioctl(fd, KER_RW_R8, buf);  /* val = buf[1] */
 77             printf("%02d. [%08x] = %02x\n", i, buf[0], (unsigned char)buf[1]);
 78             buf[0] += 1;
 79         }
 80     }
 81     else if (strcmp(argv[1], "r16") == 0)
 82     {
 83         for ( i = 0; i < num; i++)
 84         {
 85             ioctl(fd, KER_RW_R16, buf);  /* val = buf[1] */
 86             printf("%02d. [%08x] = %02x\n", i, buf[0], (unsigned short)buf[1]);
 87             buf[0] += 2;
 88         }
 89     }
 90     else if (strcmp(argv[1], "r32") == 0)
 91     {
 92         for ( i = 0; i < num; i++)
 93         {
 94             ioctl(fd, KER_RW_R32, buf);  /* val = buf[1] */
 95             printf("%02d. [%08x] = %02x\n", i, buf[0], (unsigned int)buf[1]);
 96             buf[0] += 4;
 97         }
 98     }
 99     else if (strcmp(argv[1], "w8") == 0)
100     {
101         ioctl(fd, KER_RW_W8, buf);  /* val = buf[1] */
102     }
103     else if (strcmp(argv[1], "w16") == 0)
104     {
105         ioctl(fd, KER_RW_W16, buf);  /* val = buf[1] */
106     }
107     else if (strcmp(argv[1], "w32") == 0)
108     {
109         ioctl(fd, KER_RW_W32, buf);  /* val = buf[1] */
110     }
111     else
112     {
113         printf(argv[0]);
114         return -1;
115     }
116 
117     return 0;
118     
119 }

 1  打印出如下信息：
 2            CPU0
 3  30:      85713         s3c  S3C2410 Timer Tick   //这个就是系统时钟中断
 4  33:          0         s3c  s3c-mci
 5  34:          0         s3c  I2SSDI
 6  35:          0         s3c  I2SSDO
 7  37:         12         s3c  s3c-mci
 8  42:          0         s3c  ohci_hcd:usb1
 9  43:          0         s3c  s3c2440-i2c
10  51:       3509     s3c-ext  eth0
11  60:          0     s3c-ext  s3c-mci
12  70:         96   s3c-uart0  s3c2440-uart
13  71:         92   s3c-uart0  s3c2440-uart
14  83:          0           -  s3c2410-wdt
15 Err:          0
16 
17  30:      85713         s3c  S3C2410 Timer Tick   ：这个就是系统时钟中断，我们可以再内核中查找：S3C2410 Timer Tick，会找到这样一个结构体：
18 static struct irqaction s3c2410_timer_irq = {
19 .name= "S3C2410 Timer Tick",
20 .flags= IRQF_DISABLED | IRQF_TIMER | IRQF_IRQPOLL,
21 .handler= s3c2410_timer_interrupt,
22 };
23 
24 其中：s3c2410_timer_interrupt就是中断处理函数！我们在其中加入一些信息：
25 
26 s3c2410_timer_interrupt(int irq, void *dev_id)
27 {
28        static pid_t pre_pid;
29        static int cnt=0;
30 
31        if(pre_pid==current->pid)
32         {
33             cnt++;
34         }
35        else
36         {
37             cnt=0;
38             pre_pid=current->pid;
39         }
40        //如果本进程十秒钟还没有离开的话，就会打印下面的语句
41        if(cnt==10*HZ)
42         {
43             cnt=0;
44             printk("s3c2410_timer_interrupt : pid = %d, task_name = %s\n",current->pid,current->comm);
45         }       
46 
47 write_seqlock(&xtime_lock);
48 timer_tick();
49 write_sequnlock(&xtime_lock);
50 return IRQ_HANDLED;
51 }

 1 关于我们加入的代码有两点需要说一下：
 2 第一：每一个进程都需要用一个结构体来表示：task_struct，这里面保存着与进程的一些状态信息，而current是一个宏，它代表当前的进程，也是一个task_struct结构体。所以current->pid就代表本进程的id，而current->comm就代表本进程的名字！
 3 第二：HZ是一个宏定义，它表示1秒钟发生多少次中断，10*HZ就代表10秒钟发生多少次中断！
 4 
 5 下面我们测试一下：
 6 我们可以某个驱动程序里面放入语句：while(1);这样的话，当程序执行到这里的时候就会僵死掉，在之前没有加入上述信息之前，没有任何打印信息，我们根本不知道是哪一个进程发生了僵死，现在的话，没过10秒就会打印相关信息，告诉我们现在是什么进程正在发生僵死！我的测试打印信息如下：
 7 s3c2410_timer_interrupt : pid = 752, task_name = firstdrvtest
 8 s3c2410_timer_interrupt : pid = 752, task_name = firstdrvtest
 9 s3c2410_timer_interrupt : pid = 752, task_name = firstdrvtest
10 
11 不过这样还不够详细，有没有办法知道是在哪里发生了僵死呢？这也是有办法的！
12 先来说一下原理：在应用程序的执行的时候，会一直以固定的频率发生时钟中断，那么发生中断的时候肯定会保存现场吧，那么这个保存现场的时候就要保存发生中断处的PC值，这样才能返回，那么如果把这个PC值打印出来不就知道在哪里发生中断了吗！
13 
14 我们之前分析过，发生中断的时候经过一些前期处理之后会调用：asm_do_IRQ这个函数
15 在这个函数里面我们发现了一个结构体：struct pt_regs，这个结构体就用来保存发生中断时的现场，其中PC值就是：ARM_pc
16 我们将上面在：s3c2410_timer_interrupt里面加入的信息都删除，并在：asm_do_IRQ函数里面加入如下信息：

 1  static pid_t pre_pid;
 2        static int cnt=0;
 3         //时钟中断的中断号是30
 4         if(irq==30)
 5         {
 6         if(pre_pid==current->pid)
 7         {
 8             cnt++;
 9         }
10         else
11         {
12             cnt=0;
13             pre_pid=current->pid;
14         }
15 
16         if(cnt==10*HZ)
17         {
18             cnt=0;
19             printk("s3c2410_timer_interrupt : pid = %d, task_name = %s\n",current->pid,current->comm);
20             printk("pc = %08x\n",regs->ARM_pc);//打印pc值
21         }
22         }
23 
24 我们在次测试的话，会打印出如下信息：
25 s3c2410_timer_interrupt : pid = 752, task_name = firstdrvtest
26 pc = bf000084
27 s3c2410_timer_interrupt : pid = 752, task_name = firstdrvtest
28 pc = bf000084
29 s3c2410_timer_interrupt : pid = 752, task_name = firstdrvtest
30 pc = bf000084
31 s3c2410_timer_interrupt : pid = 752, task_name = firstdrvtest
32 pc = bf000084