悲剧了...卸载模块之后/proc/devices下创建的入口还存在...

PCliangtao

小弟正在学习设备驱动程序...  不料... 把加载模块和卸载模块的部分写了一下.. 然后编译成模块... 想试试写的是否正确.. 然后在逐渐添加方法...结果...
   insmod module.ko之后在/proc/module下能发现加载的模块. 在/proc/devices下也能发现device name。这表示正确的加载并且初始化了...
   可是rmmod能够把模块卸载... 但是/proc/devices/device_name仍然存在...  不晓得为什么... 求解...

1. 
   
2. #include <linux/module.h>
   
3. #include <linux/moduleparam.h>
   
4. #include <linux/init.h>
   
5. #include <linux/fcntl.h>
   
6. #include <linux/types.h>
   
7. #include <linux/fs.h>
   
8. #include <linux/blkdev.h>
   
9. #include <linux/spinlock.h>
   
10. #include <linux/kernel.h>
    
11. #include <linux/slab.h>
    
12. #include <linux/vmalloc.h>
    
13. #include <linux/errno.h>
    
14. 
    
15. struct ram_device {
    
16.         unsigned long size;
    
17.         char *data;
    
18.         short usage;
    
19.         short midea_changed;
    
20.         spinlock_t lock;
    
21.         struct request_queue *queue;
    
22.         struct gendisk *disk;
    
23. };
    
24. 
    
25. #define DEF_RAM_SIZE 4096000UL
    
26. #define DEF_RAM_MAJOR 0
    
27. #define DEF_RAM_MINOR 4
    
28. #define DEF_RAM_HARDSECTOR 512UL
    
29. #define KERNEL_HARDSECTOR 512UL
    
30. #define DEVICE_NAME "ram_block_device"
    
31. 
    
32. static unsigned long ram_size = DEF_RAM_SIZE;
    
33. static int ram_major = DEF_RAM_MAJOR;
    
34. static int ram_minor = DEF_RAM_MINOR;
    
35. static unsigned long ram_hardsector = DEF_RAM_HARDSECTOR;
    
36. //module_param(ram_size, unsigned long, DEF_RAM_SIZE);
    
37. //module_param(ram_major, int, DEF_RAM_MAJOR);
    
38. //module_param(ram_minor, int, DEF_RAM_MINOR);
    
39. //module_param(ram_hardsector, unsigned long, DEF_RAM_HARDSECTOR);
    
40. static struct ram_device *ram_dev;
    
41. 
    
42. static void ram_trans(struct ram_device *dev, unsigned long start_sector, unsigned long nr_sector, char *buffer, int rw)
    
43. {
    
44.         unsigned long offset = start_sector * KERNEL_HARDSECTOR;
    
45.         unsigned long nbytes = nr_sector * KERNEL_HARDSECTOR;
    
46.         char *start = dev->data + offset;
    
47.         if((offset + nbytes) > dev->size) {
    
48.                 printk(KERN_NOTICE "over bound : offset %ld, nbytes %ld\n", offset, nbytes);
    
49.                 return;
    
50.         }
    
51.         if(rw)
    
52.                 memcpy(start, buffer, nbytes);
    
53.         else
    
54.                 memcpy(buffer, start, nbytes);
    
55. }
    
56. 
    
57. static void ram_request(request_queue_t *q)
    
58. {
    
59.         struct request *req;
    
60.         while(!(req = elv_next_request(q))) {
    
61.                 struct ram_device *dev = req->rq_disk->private_data;
    
62.                 if(!blk_fs_request(req)) {
    
63.                         end_request(req, 0);
    
64.                         continue;
    
65.                 }
    
66.                 ram_trans(dev, req->sector, req->current_nr_sectors, req->buffer, rq_data_dir(req));
    
67.                 end_request(req, 1);
    
68.         }
    
69. }
    
70. 
    
71. 
    
72. static int ram_device_init(void)
    
73. {
    
74.         int retval = -EBUSY;
    
75.         ram_major = register_blkdev(ram_major, DEVICE_NAME);
    
76.         if(ram_major < 0)
    
77.                 goto out;
    
78.         retval = -ENOMEM;
    
79.         ram_dev = kmalloc(sizeof(struct ram_device), GFP_KERNEL);
    
80.         if(!ram_dev)
    
81.                 goto unregister;
    
82.         memset(ram_dev, 0, sizeof(struct ram_device));
    
83.         ram_dev->size = ram_size;
    
84.         ram_size &= (~4095);
    
85.         if(!ram_size)
    
86.                 goto unregister;
    
87.         ram_dev->data = vmalloc(ram_size);
    
88.         if(!ram_dev->data)
    
89.                 goto unregister;
    
90.         spin_lock_init(&ram_dev->lock);
    
91.        
    
92. /* initialize request queue and bind request function */
    
93.         ram_dev->queue = blk_init_queue(ram_request, &ram_dev->lock);
    
94.         if(!ram_dev->queue)
    
95.                 goto free;
    
96.         ram_dev->queue->queuedata = ram_dev;
    
97.         blk_queue_hardsect_size(ram_dev->queue, ram_hardsector);
    
98. /* allocate a gendisk struct and initialize some fields that we're interested in */
    
99.         ram_dev->disk = alloc_disk(ram_minor);
    
100.         if(!ram_dev->disk)
     
101.                 goto free;
     
102.         ram_dev->disk->major = ram_major;
     
103.         ram_dev->disk->first_minor = 0;
     
104. //        ram_dev->disk->fops = &ram_ops;
     
105.         ram_dev->disk->queue = ram_dev->queue;
     
106.         ram_dev->disk->private_data = ram_dev;
     
107.         sprintf(ram_dev->disk->disk_name, DEVICE_NAME);
     
108.         set_capacity(ram_dev->disk, (ram_size / KERNEL_HARDSECTOR));
     
109. /* register it*/
     
110.         add_disk(ram_dev->disk);
     
111.         return 0;
     
112. free:
     
113.                 vfree(ram_dev->data);
     
114. unregister:
     
115.         unregister_blkdev(ram_major, DEVICE_NAME);
     
116. out:
     
117.         return retval;
     
118. }
     
119. 
     
120. static void ram_device_exit(void)
     
121. {
     
122.         if(ram_dev && ram_dev->disk) {
     
123.                 del_gendisk(ram_dev->disk);
     
124.                 put_disk(ram_dev->disk);
     
125.         }
     
126.         if(ram_dev->queue)
     
127.                 blk_cleanup_queue(ram_dev->queue);
     
128.         if(ram_dev->data)
     
129.                 vfree(ram_dev->data);
     
130.         kfree(ram_dev);
     
131.         unregister_blkdev(ram_major, DEVICE_NAME);
     
132. }
     
133. 
     
134. module_init(ram_device_init);
     
135. module_exit(ram_device_exit);
     
136. 
     
137. MODULE_AUTHOR("liangtao");
     
138. MODULE_LICENSE("Dual BSD/GPL");
     
139. 
     

复制代码