写了一个简单的linux 块设备驱动程序,加载后死机（源码）

954423389

谢谢您的时间
我写了一个简单的块设备驱动程序，加载后死机，不知道为啥。

就卡在这里，我的驱动程序源码在下面，根据《写一个块设备驱动程序》这个教程写的，

1. #include <linux/genhd.h>
   
2. #include <linux/fs.h>
   
3. #include <linux/blkdev.h>
   
4. #include <linux/types.h>
   
5. #include <linux/module.h>
   
6. 
   
7. /*全局数组，表示本设备*/
   
8. unsigned char array_data[16*1024*1024];
   
9. 
   
10. /*全局变量，表示本设备*/
    
11. struct gendisk *my_gendisk;
    
12. /*全局变量，主设备号*/
    
13. int major_num = -1;
    
14. 
    
15. /*全局变量，本设备关联的请求队列*/
    
16. struct request_queue *my_request_queue = NULL;
    
17. /*全局变量，内核访问请求队列的自旋锁*/
    
18. spinlock_t lock;
    
19. 
    
20. 
    
21. /*对块设备的操作函数集合（函数指针集合）*/
    
22. struct block_device_operations my_operations=
    
23. {
    
24.     .owner        = THIS_MODULE,
    
25. };
    
26. 
    
27. 
    
28. static void
    
29. my_process_on_request_queue(struct request_queue *q)
    
30. {
    
31.     struct request *req;
    
32.     sector_t sector = 0;
    
33.     unsigned int current_nr_sectors = 0;
    
34. 
    
35. 
    
36.    
    
37.    
    
38. 
    
39.     while (NULL != (req = blk_fetch_request (q)))/*linux/blkdev.h*/
    
40.     {
    
41.         sector = blk_rq_pos (req);
    
42.         current_nr_sectors = blk_rq_cur_sectors (req);
    
43. 
    
44.         if( (sector+current_nr_sectors)<<9 >16*1024*1024)
    
45.         {
    
46.             printk(KERN_ERR"bad request\n");
    
47.             blk_end_request_all (req,0);/*linux/blkdev.h*/
    
48.             continue;
    
49.         }
    
50.    
    
51.    
    
52.       switch (rq_data_dir (req))/*1为write   0为read*/
    
53.       {
    
54.         case 1:
    
55.             memcpy(req->buffer,array_data+(sector<<9),(current_nr_sectors<<9));   
    
56.             blk_end_request_all (req,1);
    
57.             break;
    
58.         case 0:
    
59.             memcpy(array_data+(sector<<9),req->buffer,(current_nr_sectors<<9));   
    
60.             blk_end_request_all (req,1);
    
61. 
    
62.         default:break;
    
63.             
    
64.       }
    
65.     }
    
66. 
    
67.     return;
    
68. }
    
69. 
    
70. 
    
71. static int __init
    
72. my_init(void)
    
73. {   
    
74.    
    
75.    
    
76.     /*1、为代表本设备的结构体申请内存
    
77.          这里的参数是本磁盘使用的次设备号的数目，一经申请，这个数字就不可更改   
    
78.     */
    
79.     my_gendisk = alloc_disk (1);/*linux/genhd.h*/
    
80.     if (NULL == my_gendisk)
    
81.     {
    
82.         printk(KERN_NOTICE"alloc gendisk failure\n");
    
83.         return -ENOMEM;
    
84.     }
    
85.     /*2、为这个结构体成员变量复制,必须的赋值有5个*/
    
86.     /*申请"主"设备号,这个名字是出现在：估计是设备号数据库那里的名字 /proc/devices下显示的（下面还有一个名字）事实证明的确如此“251 blocksimple”*/   
    
87. 
    
88.     major_num = register_blkdev (0,"blocksimple");/*linux/fs.h*/
    
89.     if (major_num<=0)
    
90.     {
    
91.         printk(KERN_WARNING"no major number\n");
    
92.         /*申请主设备号失败的时候，驱动程序就无法正常加载，要释放已经申请的资源，目前资源只有gendisk*/
    
93.         goto major_alloc_error;
    
94.         
    
95.     }
    
96.     /*3、我们提到过，每个块设备关联了一个请求队列，我们这里申请一个,需要注意的是：
    
97.     1）每个请求队列都对应一个”请求队列处理函数“，这个是设备相关的        
    
98.     2）每次分配一个请求队列的时候，必须提供一个自旋锁来控制对请求队列的访问,我们先不考虑并发访问
    
99.     */
    
100.     spin_lock_init (&lock);
     
101. 
     
102.     my_request_queue = blk_init_queue (my_process_on_request_queue,&lock);
     
103.     if (NULL == my_request_queue)
     
104.     {
     
105.         printk("request queue error");
     
106.         goto requeue_alloc_error;   
     
107.    
     
108.     }
     
109.     /*4、使用前面申请的资源为gendisk赋值*/
     
110.     strcpy(my_gendisk->disk_name ,"BlockSimple");/*本设备的名称，这个名称是出现在“/dev/”目录下的cd */
     
111.     my_gendisk->major = major_num;
     
112.     my_gendisk->first_minor = 0;
     
113.     my_gendisk->queue = my_request_queue;
     
114.     my_gendisk->fops = &my_operations;
     
115.     /*设置块设备的大小，以扇区为单位，因为内核总是认为扇区大小是512B，所以用函数设定*/
     
116.     set_capacity (my_gendisk,16*1024*2);
     
117. 
     
118.    
     
119.     /*5、注册gendisk*/
     
120.     add_disk (my_gendisk);
     
121.     return 0;
     
122. 
     
123. 
     
124. 
     
125. 
     
126. requeue_alloc_error:
     
127.     /*释放主设备号，和gendisk*/
     
128.     unregister_blkdev(major_num, "blocksimple");
     
129. major_alloc_error:
     
130.     /*释放gendisk*/
     
131.     del_gendisk(my_gendisk);
     
132.     return -ENOMEM;
     
133. 
     
134. }
     
135. 
     
136. 
     
137. static void __exit
     
138. my_exit(void)
     
139. {
     
140.     blk_cleanup_queue (my_request_queue);
     
141.    
     
142.     unregister_blkdev(major_num, "blocksimple");
     
143. 
     
144.     del_gendisk(my_gendisk);
     
145.    
     
146. 
     
147. 
     
148. }
     
149. 
     
150. module_init (my_init);
     
151. module_exit (my_exit);
     

复制代码

954423389

:wink:先谢谢各位了

lovehahaforever

如果你机器的内存大于2G那你的那个全局变量开得太大了。
具体不懂可以再问啊。

npuazm

你可以参考一下这个帖子，我在这个帖子中做过回复～
http://bbs.chinaunix.net/viewthr ... ;page=1#pid21155610

954423389

回复 4# npuazm


    你好，我的问题解决了，我函数用错了，汗颜了，我并没有仔细研究那些函数，本想简单的实现个例子。
     blk_end_request_all   换成 __blk_end_request_all  就可以了。

     谢谢你的回复。
      下面是我的源码，希望有相同问题的人参考 内核版本是2.6.32 ubuntu 10.04

1. /*为了便于讲解，一律没有使用宏*/
   
2. #include <linux/genhd.h>
   
3. #include <linux/fs.h>
   
4. #include <linux/blkdev.h>
   
5. #include <linux/types.h>
   
6. #include <linux/module.h>
   
7. 
   
8. /*全局数组，表示本设备*/
   
9. unsigned char array_data[16*1024*1024];
   
10. 
    
11. /*全局变量，表示本设备*/
    
12. struct gendisk *my_gendisk;
    
13. /*全局变量，主设备号*/
    
14. int major_num = -1;
    
15. 
    
16. /*全局变量，本设备关联的请求队列*/
    
17. struct request_queue *my_request_queue = NULL;
    
18. /*全局变量，内核访问请求队列的自旋锁*/
    
19. static DEFINE_SPINLOCK (lock);
    
20. 
    
21. 
    
22. /*对块设备的操作函数集合（函数指针集合）*/
    
23. struct block_device_operations my_operations=
    
24. {
    
25.         .owner                = THIS_MODULE,
    
26. };
    
27. 
    
28. static void sbd_transfer(sector_t sector,unsigned long nsect, char *buffer, int write)
    
29. {
    
30.         unsigned long offset = sector<<9;
    
31.         unsigned long nbytes = nsect<<9;
    
32. 
    
33.         if ((offset + nbytes) > 16*1024*1024) {
    
34.                 printk (KERN_NOTICE "sbd: Beyond-end write (%ld %ld)\n", offset, nbytes);
    
35.                 return;
    
36.         }
    
37.         if (write)
    
38.                 memcpy(array_data + offset, buffer, nbytes);
    
39.         else
    
40.                 memcpy(buffer, array_data + offset, nbytes);
    
41. }
    
42. 
    
43. static void
    
44. my_process_on_request_queue(struct request_queue *q)
    
45. {
    
46. 
    
47.         struct request *req;
    
48. 
    
49.         req = blk_fetch_request(q);
    
50.         while (req != NULL)
    
51.         {
    
52.                 if (req == NULL || (req->cmd_type != REQ_TYPE_FS))
    
53.                 {
    
54.                         printk (KERN_NOTICE "Skip non-CMD request\n");
    
55.                         __blk_end_request_all(req, -EIO);
    
56.                         continue;
    
57.                 }
    
58.                 sbd_transfer(blk_rq_pos(req), blk_rq_cur_sectors(req),req->buffer, rq_data_dir(req));
    
59.                 if ( ! __blk_end_request_cur(req, 0) ) {
    
60.                         req = blk_fetch_request(q);
    
61.                 }
    
62.         }
    
63. }
    
64. 
    
65. 
    
66. static int __init
    
67. my_init(void)
    
68. {       
    
69.        
    
70.        
    
71.         /*1、为代表本设备的结构体申请内存
    
72.              这里的参数是本磁盘使用的次设备号的数目，一经申请，这个数字就不可更改       
    
73.         */
    
74.         my_gendisk = alloc_disk (1);/*linux/genhd.h*/
    
75.         if (NULL == my_gendisk)
    
76.         {
    
77.                 printk(KERN_NOTICE"alloc gendisk failure\n");
    
78.                 return -ENOMEM;
    
79.         }
    
80.         /*2、为这个结构体成员变量复制,必须的赋值有5个*/
    
81.         /*申请"主"设备号,这个名字是出现在：估计是设备号数据库那里的名字 /proc/devices下显示的（下面还有一个名字）事实证明的确如此“251 blocksimple”*/       
    
82. 
    
83.         major_num = register_blkdev (0,"blocksimple");/*linux/fs.h*/
    
84.         if (major_num<=0)
    
85.         {
    
86.                 printk(KERN_WARNING"no major number\n");
    
87.                 /*申请主设备号失败的时候，驱动程序就无法正常加载，要释放已经申请的资源，目前资源只有gendisk*/
    
88.                 goto major_alloc_error;
    
89.                
    
90.         }
    
91.         /*3、我们提到过，每个块设备关联了一个请求队列，我们这里申请一个,需要注意的是：
    
92.         1）每个请求队列都对应一个”请求队列处理函数“，这个是设备相关的               
    
93.         2）每次分配一个请求队列的时候，必须提供一个自旋锁来控制对请求队列的访问,我们先不考虑并发访问
    
94.         */
    
95.         //spin_lock_init (&lock);
    
96. 
    
97.         my_request_queue = blk_init_queue (my_process_on_request_queue,&lock);
    
98. 
    
99.         if (NULL == my_request_queue)
    
100.         {
     
101.                 printk("request queue error");
     
102.                 goto requeue_alloc_error;       
     
103.        
     
104.         }
     
105.         /*4、使用前面申请的资源为gendisk赋值*/
     
106.         strcpy(my_gendisk->disk_name ,"BlockSimple");/*本设备的名称，这个名称是出现在“/dev/”目录下的 */
     
107.         my_gendisk->major = major_num;
     
108.         my_gendisk->first_minor = 0;
     
109.         my_gendisk->queue = my_request_queue;
     
110.         my_gendisk->fops = &my_operations;
     
111.         /*设置块设备的大小，以扇区为单位，因为内核总是认为扇区大小是512B，所以用函数设定*/
     
112.         set_capacity (my_gendisk,16*1024*2);
     
113. 
     
114.        
     
115.         /*5、注册gendisk*/
     
116.         add_disk (my_gendisk);
     
117.         return 0;
     
118. 
     
119. 
     
120. 
     
121. 
     
122. requeue_alloc_error:
     
123.         /*释放主设备号，和gendisk*/
     
124.         unregister_blkdev(major_num, "blocksimple");
     
125. major_alloc_error:
     
126.         /*释放gendisk*/
     
127.         del_gendisk(my_gendisk);
     
128.         return -ENOMEM;
     
129. 
     
130. }
     
131. 
     
132. 
     
133. static void __exit
     
134. my_exit(void)
     
135. {
     
136.         blk_cleanup_queue (my_request_queue);
     
137.        
     
138.         unregister_blkdev(major_num, "blocksimple");
     
139. 
     
140.         del_gendisk(my_gendisk);
     
141.         put_disk (my_gendisk);
     
142. }
     
143. 
     
144. 
     
145. module_init (my_init);
     
146. module_exit (my_exit);

复制代码

954423389

回复 3# lovehahaforever


    谢谢你的回答，我的问题解决了，不是内存这边的事。
   我大体上能听明白你的回答，不过我不知道，高端内存大了之后，申请个16M的空间就会死机么，我的电脑是1G的，我对内存也是刚刚了解。非线性区那么紧缺么，以后下次找机会试试，呵呵