求助！！卸载驱动时，模块仍在使用中。module is in use

chen_q07

我刚接触驱动开发。学习资料是Linux Device Drivers 3rd。我根据书中的代码，稍微改写了一下，结果试验时就出现以下情况了。
求高手指导！！
1. 编译通过，用complete.init start加载模块时，Failed，但是，查看、proc/devices文件显示该模块已经加载上了，有major number。但是，

用complete.init stop卸载该模块时，出现module complete is in use的提示，不能卸载。此时，我再用complete.init start加载模块时，还是

Failed了，说是file exists，说明该模块已经加载上了。怎么办？

2. 情形如下
user 1:
cat /dev/complete
(block)

user 2:
echo "hello" > complete
(唤醒user1的cat程序，但是没有任何显示，同时，用户从root变为test（自动变的。。。）不懂了。

另外，附上源码。附件中我已经附上文件。
求高手指导。

1. #ifndef _COMPLETEL_H_
   
2. #define _COMPLETEL_H_
   
3. 
   
4. 
   
5. struct complete_dev {
   
6.         void* data;  /* Pointer to first quantum set */
   
7.         struct cdev cdev;          /* Char device structure                */
   
8. };
   
9. 
   
10. void complete_cleanup(void);
    
11. 
    
12. #endif /* _COMPLETEL_H_ */

复制代码

1. 
   
2. #include <linux/module.h>
   
3. #include <linux/init.h>
   
4. 
   
5. #include <linux/sched.h>  /* current and everything */
   
6. #include <linux/kernel.h> /* printk() */
   
7. #include <linux/fs.h>     /* everything... */
   
8. #include <linux/types.h>  /* size_t */
   
9. #include <linux/cdev.h>
   
10. #include <linux/errno.h>        /* error codes */
    
11. #include <linux/completion.h>
    
12. #include <asm/uaccess.h>        /* copy_*_user */
    
13. #include "complete.h"
    
14. 
    
15. MODULE_LICENSE("Dual BSD/GPL");
    
16. MODULE_AUTHOR("James Chen");
    
17. 
    
18. static int complete_major = 0;
    
19. struct complete_dev* complete_device;
    
20. 
    
21. DECLARE_COMPLETION(comp);
    
22. 
    
23. int complete_trim(struct complete_dev *dev)
    
24. {
    
25.         if (dev->data)
    
26.                 {
    
27.                 kfree(dev->data);
    
28.                 dev->data = NULL;
    
29.                 }
    
30.         return 0;
    
31. }
    
32. 
    
33. int complete_open(struct inode *inode, struct file *filp)
    
34. {       
    
35.          
    
36.          /*struct complete_dev *dev; */  /* device information */
    
37.         /*
    
38.         dev = container_of(inode->i_cdev, struct complete_dev, cdev);
    
39.         */
    
40.         filp->private_data = complete_device; /* for other methods */
    
41. 
    
42.         /* now trim to 0 the length of the device if open was write-only */
    
43.         if ( (filp->f_flags & O_ACCMODE) == O_WRONLY) {
    
44.                 complete_trim(complete_device); /* ignore errors */
    
45.         }
    
46.         return 0;          /* success */
    
47. }
    
48. 
    
49. int complete_release(struct inode *inode, struct file *filp)
    
50. {
    
51.         return 0;
    
52. }
    
53. 
    
54. ssize_t complete_read (struct file *filp, char __user *buf, size_t count, loff_t *pos)
    
55. {
    
56.         struct complete_dev *dev = filp->private_data;
    
57.         printk(KERN_DEBUG "process %i (%s) going to sleep\n",
    
58.                         current->pid, current->comm);
    
59.         wait_for_completion(&comp);
    
60.         printk(KERN_DEBUG "awoken %i (%s)\n", current->pid, current->comm);
    
61.         copy_to_user(buf, dev->data, count);
    
62.         return 0; /* EOF */
    
63. }
    
64. 
    
65. ssize_t complete_write (struct file *filp, const char __user *buf, size_t count,
    
66.                 loff_t *pos)
    
67. {
    
68.         struct complete_dev *dev = filp->private_data;
    
69.         printk(KERN_DEBUG "process %i (%s) awakening the readers...\n",
    
70.                         current->pid, current->comm);
    
71.         complete(&comp);
    
72.         copy_from_user(dev->data, buf, count);
    
73.         return count; /* succeed, to avoid retrial */
    
74. }
    
75. 
    
76. 
    
77. struct file_operations complete_fops = {
    
78.         .owner = THIS_MODULE,
    
79.         .open = complete_open,
    
80.         .release = complete_release,
    
81.         .read =  complete_read,
    
82.         .write = complete_write,
    
83. };
    
84. 
    
85. 
    
86. int complete_init(void)
    
87. {
    
88.         int result;
    
89.         dev_t devno;
    
90.         /*
    
91.          * Register your major, and accept a dynamic number
    
92.          */
    
93.          /*int  devno = MKDEV(complete_major, 0);*/
    
94.         result = register_chrdev(complete_major, "complete", &complete_fops);
    
95.         if (result < 0)
    
96.                 goto fail;
    
97.         if (complete_major == 0)
    
98.                 complete_major = result; /* dynamic */
    
99.         devno = MKDEV(complete_major, 0);
    
100.        
     
101.         complete_device= kmalloc(1 * sizeof(struct complete_dev), GFP_KERNEL);
     
102.         if (!complete_device) {
     
103.                 result = -ENOMEM;
     
104.                 goto fail;  /* Make this more graceful */
     
105.         }
     
106.         complete_device->data = kmalloc(1024, GFP_KERNEL);
     
107.         if (!complete_device->data) {
     
108.                 result = -ENOMEM;
     
109.                 goto fail;  /* Make this more graceful */
     
110.         }
     
111.         memset(complete_device, 0,1 * sizeof(struct complete_dev));
     
112.         memset(complete_device->data, 0, 1024);
     
113.        
     
114.         cdev_init(&complete_device->cdev, &complete_fops);
     
115.         complete_device->cdev.owner = THIS_MODULE;
     
116.         complete_device->cdev.ops = &complete_fops;
     
117. 
     
118.         result = cdev_add (&complete_device->cdev, devno, 1);
     
119.         /* Fail gracefully if need be */
     
120.         if (result)
     
121.                 {
     
122.                         goto fail;
     
123.                 }
     
124.        
     
125.         return 0;
     
126. 
     
127.         fail:
     
128.                 complete_cleanup();
     
129.                 return result;
     
130. }
     
131. 
     
132. void complete_cleanup(void)
     
133. {
     
134.         if (complete_device)
     
135.                 {
     
136.                         complete_trim(complete_device);
     
137.                         cdev_del(&complete_device->cdev);
     
138.                         kfree(complete_device);
     
139.                 }
     
140.        
     
141.         unregister_chrdev(complete_major, "complete");
     
142. }
     
143. 
     
144. module_init(complete_init);
     
145. module_exit(complete_cleanup);

复制代码

init脚本如下
#!/bin/bash
# Sample init script for the a driver module <rubini@linux.it>

DEVICE="complete"
SECTION="misc"

# The list of filenames and minor numbers: $PREFIX is prefixed to all names
PREFIX="complete"
FILES="     0 0     "

INSMOD=/sbin/insmod; # use /sbin/modprobe if you prefer

function device_specific_post_load () {
    true; # fill at will
}
function device_specific_pre_unload () {
    true; # fill at will
}

# Everything below this line should work unchanged for any char device.
# Obviously, however, no options on the command line: either in
# /etc/${DEVICE}.conf or /etc/modules.conf (if modprobe is used)

# Optional configuration file: format is
#    owner  <ownername>
#    group  <groupname>
#    mode   <modename>
#    options <insmod options>
CFG=/etc/${DEVICE}.conf

# kernel version, used to look for modules
KERNEL=`uname -r`

#FIXME: it looks like there is no misc section. Where should it be?
MODDIR="/lib/modules/${KERNEL}/kernel/drivers/${SECTION}"
if [ ! -d $MODDIR ]; then MODDIR="/lib/modules/${KERNEL}/${SECTION}"; fi

# Root or die
if [ "$(id -u)" != "0" ]
then
  echo "You must be root to load or unload kernel modules"
  exit 1
fi

# Read configuration file
if [ -r $CFG ]; then
    OWNER=`awk "\\$1==\"owner\" {print \\$2}" $CFG`
    GROUP=`awk "\\$1==\"group\" {print \\$2}" $CFG`
    MODE=`awk "\\$1==\"mode\" {print \\$2}" $CFG`
    # The options string may include extra blanks or only blanks
    OPTIONS=`sed -n '/^options / s/options //p' $CFG`
fi


# Create device files
function create_files () {
    cd /dev
    local devlist=""
    local file
    while true; do
        if [ $# -lt 2 ]; then break; fi
        file="${DEVICE}$1"
        mknod $file c $MAJOR $2
        devlist="$devlist $file"
        shift 2
    done
    if [ -n "$OWNER" ]; then chown $OWNER $devlist; fi
    if [ -n "$GROUP" ]; then chgrp $GROUP $devlist; fi
    if [ -n "$MODE"  ]; then chmod $MODE  $devlist; fi
}

# Remove device files
function remove_files () {
    cd /dev
    local devlist=""
    local file
    while true; do
        if [ $# -lt 2 ]; then break; fi
        file="${DEVICE}$1"
        devlist="$devlist $file"
        shift 2
    done
    rm -f $devlist
}

# Load and create files
function load_device () {
   
    if [ -f $MODDIR/$DEVICE.ko ]; then
        devpath=$MODDIR/$DEVICE.ko
    else if [ -f ./$DEVICE.ko ]; then
        devpath=./$DEVICE.ko
    else
        devpath=$DEVICE; # let insmod/modprobe guess
    fi; fi
    if [ "$devpath" != "$DEVICE" ]; then
        echo -n " (loading file $devpath)"
    fi

    if $INSMOD $devpath $OPTIONS; then
        MAJOR=`awk "\\$2==\"$DEVICE\" {print \\$1}" /proc/devices`
        remove_files $FILES
        create_files $FILES
        device_specific_post_load
    else
        echo " FAILED!"
     fi
}

# Unload and remove files
function unload_device () {
    device_specific_pre_unload
    /sbin/rmmod $DEVICE
    remove_files $FILES
}


case "$1" in
  start)
     echo -n "Loading $DEVICE"
     load_device
     echo "."
     ;;
  stop)
     echo -n "Unloading $DEVICE"
     unload_device
     echo "."
     ;;
  force-reload|restart)
     echo -n "Reloading $DEVICE"
     unload_device
     load_device
     echo "."
     ;;
  *)
     echo "Usage: $0 {start|stop|restart|force-reload}"
     exit 1
esac

exit 0