scull驱动奇怪的问题。不能运行。已解决

HJLin

从昨天晚上开始发现这个问题一直美法解决。非常郁闷啊。。。

问题如下：
ldd3上面的例子，原来我是用一个文件(scull.c)全部实现的。运行没有问题。后来为了优化设计，我把各个功能拆开到多个文件中(scull_fops.h scull_fops.c scull.c)中。出现问题了，编译正常，但是insmod scull.ko加载之后(dmesg, /var/log/messages)没有任何反应。/proc/devices也没有生成scull设备。非常的郁闷啊。

下面是代码，请高手帮助小弟一把： scull.tar.gz (2.85 KB, 下载次数: 62)

2010-12-01 10:34 上传

点击文件名下载附件

HJLin

附上直观的代码，望高手方便赐教。。

Makefile

1. obj-m := scull.o
   
2. 
   
3. scull-objs := scull_fops.o
   
4. 
   
5. KERNELDIR ?= /lib/modules/$(shell uname -r)/build
   
6. PWD := $(shell pwd)
   
7. default:
   
8.         $(MAKE) -C $(KERNELDIR) M=$(PWD) modules
   
9. 
   
10. clean:
    
11.         $(MAKE) -C $(KERNELDIR) M=$(PWD) clean
    
12.         rm -fr *.o *.ko *.symvers *.mod.c
    

复制代码

scull_fops.h

1. #ifndef _SCULL_FOPS_H_
   
2. #define _SCULL_FOPS_H_
   
3. 
   
4. #include <linux/sched.h>
   
5. #include <linux/types.h>
   
6. //file file_operations etc.
   
7. #include <linux/module.h>
   
8. #include <linux/fs.h>
   
9. #include <linux/cdev.h>
   
10. //copy
    
11. #include <asm/uaccess.h>
    
12. 
    
13. 
    
14. MODULE_LICENSE("Dual BSD/GPL");
    
15. 
    
16. loff_t scull_llseek(struct file *, loff_t, int);
    
17. ssize_t scull_read(struct file *, char __user *, size_t, loff_t *);
    
18. ssize_t scull_write(struct file *, const char __user *, size_t, loff_t *);
    
19. int scull_ioctl(struct inode *, struct file *, unsigned int, unsigned long);
    
20. int scull_open(struct inode *, struct file *);
    
21. int scull_release(struct inode *, struct file *);
    
22. 
    
23. struct scull_qset {
    
24.   void **data;
    
25.   struct scull_qset *next;
    
26. };
    
27. 
    
28. struct scull_dev {
    
29.   struct scull_qset *data;  /* Pointer to first quantum set */
    
30.   int quantum;  /* the current quantum size */
    
31.   int qset;  /* the current array size */
    
32.   unsigned long size;  /* amount of data stored here */
    
33.   unsigned int access_key;  /* used by sculluid and scullpriv */
    
34.   struct semaphore sem;  /* mutual exclusion semaphore  */
    
35. 
    
36.   struct cdev cdev; /* Char device structure */
    
37. };
    
38. 
    
39. int scull_trim(struct scull_dev *dev);
    
40. struct scull_qset *scull_follow(struct scull_dev *dev, int item);
    
41. 
    
42. #endif
    

复制代码

scull_fops.c

1. #include "scull_fops.h"
   
2. 
   
3. struct scull_dev dev;
   
4. //EXPORT_SYMBOL(dev);
   
5. 
   
6. struct file_operations scull_fops = {
   
7.   .owner = THIS_MODULE,
   
8.   .llseek = scull_llseek,
   
9.   .read = scull_read,
   
10.   .write = scull_write,
    
11.   .ioctl = scull_ioctl,
    
12.   .open = scull_open,
    
13.   .release = scull_release
    
14. };
    
15. //EXPORT_SYMBOL(scull_fops);
    
16. 
    
17. 
    
18. loff_t
    
19. scull_llseek(struct file *filp, loff_t offp, int count) {
    
20.   return 0;
    
21. }
    
22. 
    
23. ssize_t
    
24. scull_read(struct file *filp, char __user *buff, size_t count, loff_t *f_pos) {
    
25.   printk("scull, scull_read() buff=%p, count=%i, *f_pos=%i\n", buff, count, *f_pos);
    
26.   struct scull_dev *dev = (struct scull_dev*)filp->private_data;
    
27.   struct scull_qset *p;
    
28.   int quantum = dev->quantum;
    
29.   int qset = dev->qset;
    
30.   int itemsize = qset * quantum;
    
31.   ssize_t retval = 0;
    
32. 
    
33.   if (down_interruptible(&dev->sem))
    
34.     return -ERESTARTSYS;
    
35.   if (*f_pos >= dev->size)
    
36.     goto out;
    
37.   if (*f_pos + count > dev->size)
    
38.     count = dev->size - *f_pos;
    
39. 
    
40.   int item = (long)*f_pos / itemsize;
    
41.   int rest = (long)*f_pos % itemsize;
    
42. 
    
43.   int s_pos = rest / quantum;
    
44.   int q_pos = rest % quantum;
    
45. 
    
46.   //follow the list up to the right qset
    
47.   p = scull_follow(dev, item);
    
48. 
    
49.   //printk("p = %p \n", p);
    
50.   //printk("p->data = %p \n", p->data);
    
51.   //printk("p->data[s_pos] = %p \n", p->data[s_pos]);
    
52.   
    
53.   if (p == NULL || p->data == NULL || p->data[s_pos] == NULL ) {
    
54.     printk("something is wrong\n");
    
55.     goto out;
    
56.   }
    
57.    
    
58.   char *str = p->data[s_pos] + q_pos;
    
59.   //read only up to the end of this quantum
    
60.   if (count > quantum - q_pos)
    
61.     count = quantum - q_pos;
    
62.   
    
63.   if (copy_to_user(buff, p->data[s_pos] + q_pos, count) != 0) {
    
64.     retval = -EFAULT;
    
65.     goto out;
    
66.   }  
    
67.   
    
68.   printk("scull, success read %i bytes\n", count);
    
69.   *f_pos += count;
    
70.   retval = count;
    
71. 
    
72. out:
    
73.   up(&dev->sem);
    
74.   return retval;
    
75. }
    
76. 
    
77. ssize_t
    
78. scull_write(struct file *filp, const char __user *buff, size_t count, loff_t *f_pos) {
    
79.   printk("scull, scull_write() start, buff=%p, count=%i, *f_pos=%i\n", buff, count, *f_pos);   
    
80.   struct scull_dev *dev = filp->private_data;
    
81.   int itemsize = dev->qset * dev->quantum;
    
82. 
    
83.   ssize_t retval = 0;
    
84.   if (down_interruptible(&dev->sem)) {
    
85.     return -ERESTARTSYS;
    
86.   }
    
87.   
    
88.   int item = (long)*f_pos / itemsize;
    
89.   int rest = (long)*f_pos % itemsize;
    
90.   int s_pos = rest / dev->quantum;
    
91.   int q_pos = rest % dev->quantum;
    
92.   
    
93.   struct scull_qset *p = scull_follow(dev, item);
    
94.   if (p == NULL) {
    
95.     printk("scull_follow() failed\n");
    
96.     goto out;
    
97.   }
    
98. 
    
99.   if (p->data == NULL) {
    
100.     p->data = kmalloc(sizeof(char*) * dev->qset, GFP_KERNEL);
     
101.     if (p->data == NULL)
     
102.       goto out;
     
103.     memset(p->data, 0, sizeof(char*) * dev->qset);  
     
104.   }
     
105.   if ((p->data)[s_pos] == NULL) {
     
106.     (p->data)[s_pos] = kmalloc(dev->quantum, GFP_KERNEL);
     
107.     if ((p->data)[s_pos] == NULL)
     
108.       goto out;
     
109.   }
     
110.   if (count > dev->quantum - q_pos)
     
111.     count = dev->quantum - q_pos;
     
112. 
     
113.   //printk("p = %p \n", p);
     
114.   //printk("p->data = %p \n", p->data);
     
115.   //printk("p->data[s_pos] = %p \n", p->data[s_pos]);
     
116. 
     
117.   if (copy_from_user(p->data[s_pos] + q_pos, buff, count) != 0) {
     
118.     retval = -EFAULT;
     
119.     goto out;
     
120.   }
     
121. 
     
122.   retval = count;
     
123.   *f_pos += count;
     
124.   
     
125.   if (dev->size < *f_pos) {
     
126.     dev->size = *f_pos;
     
127.   }
     
128.   printk("scull, copy_from_user %i bytes\n", count);
     
129. 
     
130. out:
     
131.   up(&dev->sem);
     
132.   return retval;
     
133. }
     
134. int
     
135. scull_ioctl(struct inode *indoe, struct file *filp, unsigned int flag, unsigned long num) {
     
136.   return 0;
     
137. }
     
138. 
     
139. int
     
140. scull_open(struct inode *inode, struct file *filp) {
     
141.   printk("scull, scull_open() start\n");
     
142.   struct scull_dev *dev;
     
143.   dev = container_of(inode->i_cdev, struct scull_dev, cdev);
     
144.   filp->private_data = dev;
     
145. 
     
146.   if ((filp->f_flags & O_ACCMODE) == O_WRONLY) {
     
147.     scull_trim(dev);   
     
148.   }
     
149.   return 0;
     
150. }
     
151. 
     
152. int
     
153. scull_release(struct inode *inode, struct file *filp) {
     
154.   printk("scull, scull_release() start\n");
     
155.   return 0;
     
156. }
     
157. 
     
158. int
     
159. scull_trim(struct scull_dev *dev) {
     
160.   printk("scull, scull_trim() start\n");
     
161.   struct scull_qset *p = dev->data;
     
162.   while (p != NULL) {
     
163.     int i;
     
164.     for (i=0; i<dev->qset; i++) {
     
165.       kfree((p->data)[i]);
     
166.     }
     
167.     kfree(p->data);
     
168.     struct scull_qset *next = p->next;
     
169.     kfree(p);
     
170.     p = next;
     
171.   }
     
172. 
     
173.   dev->size = 0;
     
174.   dev->data = NULL;
     
175.   return 0;
     
176. }
     
177. 
     
178. struct scull_qset *
     
179. scull_follow(struct scull_dev *dev, int item) {
     
180.   printk("scull, scull_follow() start\n");
     
181.   struct scull_qset *p = dev->data;
     
182.   if (dev->data == NULL) {
     
183.     dev->data = kmalloc(sizeof(struct scull_qset), GFP_KERNEL);
     
184.     if (dev->data == NULL)
     
185.       return NULL;
     
186.     p = dev->data;
     
187.     p->next = NULL;
     
188.     p->data = NULL;
     
189.   }
     
190. 
     
191.   while (item-- != 0) {
     
192.     if (p->next == NULL) {
     
193.       p->next = kmalloc(sizeof(struct scull_qset), GFP_KERNEL);
     
194.       if (p->next == NULL)
     
195.         return NULL;
     
196.       p->next->data = NULL;
     
197.       p->next->next = NULL;
     
198.     }
     
199.     p = p->next;
     
200.   }
     
201. 
     
202.   return p;
     
203. }
     

复制代码

scull.c

1. #include <linux/module.h>
   
2. #include <linux/init.h>
   
3. #include <linux/types.h>
   
4. #include <linux/cdev.h>
   
5. 
   
6. #include "scull_fops.h"
   
7. 
   
8. extern struct scull_dev dev;
   
9. extern struct file_operations scull_fops;
   
10. 
    
11. dev_t devno;
    
12. int major = 0;
    
13. int minor = 0;
    
14. int nr_devs = 4;
    
15. 
    
16. //init
    
17. int scull_init(void);
    
18. //exit
    
19. void scull_exit(void);
    
20. //分配设备
    
21. int alloc_dev(void);
    
22. //注册设备
    
23. int register_dev(void);
    
24. 
    
25. int
    
26. scull_init(void) {
    
27.   printk("hello, scull\n");
    
28.   printk("The process is \"%s\" (pid %i)\n", current->comm, current->pid);
    
29.   if (alloc_dev() == -1) {
    
30.     printk("scull: can't alloc devno, %i\n", major);
    
31.     return -1;
    
32.   }
    
33.   if (register_dev() == -1) {
    
34.     printk("scull, register_dev() failed\n");
    
35.     return -1;
    
36.   }
    
37.   return 0;
    
38. }
    
39. 
    
40. void
    
41. scull_exit(void) {
    
42.   printk("Goodbye, scull %i,%i\n", major, minor);
    
43.   unregister_chrdev_region(devno, nr_devs);
    
44.   cdev_del(&dev.cdev);
    
45. }
    
46. 
    
47. int
    
48. alloc_dev(void) {
    
49.   int result = 0;
    
50.   printk("scull, alloc_dev() start\n");
    
51.   if (major == 0) {
    
52.     result = alloc_chrdev_region(&devno, minor, nr_devs, "scull");
    
53.     major = MAJOR(devno);
    
54.   } else {
    
55.     devno = MKDEV(major, minor);
    
56.     result = register_chrdev_region(devno, nr_devs, "scull");
    
57.   }
    
58.   return result;
    
59. }
    
60. 
    
61. int
    
62. register_dev(void) {
    
63.   printk("scull, register_dev() start\n");
    
64.   dev.data = NULL;
    
65.   dev.quantum = 4000;
    
66.   dev.qset = 1000;
    
67.   dev.size = 0;
    
68.   init_MUTEX(&dev.sem);
    
69.   
    
70.   cdev_init(&dev.cdev, &scull_fops);
    
71.   dev.cdev.owner = THIS_MODULE;
    
72.   dev.cdev.ops = &scull_fops;
    
73.   return cdev_add(&dev.cdev, devno, 1);
    
74. }
    
75. 
    
76. module_init(scull_init);
    
77. module_exit(scull_exit);
    

复制代码

dreamice

你为什么要写这一行：
scull-objs := scull_fops.o

dreamice

看起来应该是你的Makefile的问题

HJLin

scull-objs := scull_fops.o 这个是说这个模块（scull）依赖哪些文件的。
如果不加，编译的话报警告找不到符号。
insmod失败


这个语法也是昨天网上查到的。

yikaikai

编译没出现错误或者警告信息么？

HJLin

编译没有什么问题。就是一些代码混编的警告。


[root@localhost scull]# make
make -C /lib/modules/2.6.18-92.el5/build M=/root/ldd3/scull  modules
make[1]: Entering directory `/usr/src/kernels/2.6.18-92.el5-i686'
  CC [M]  /root/ldd3/scull/scull_fops.o
/root/ldd3/scull/scull_fops.c: In function ‘scull_read’:
/root/ldd3/scull/scull_fops.c:25: warning: format ‘%i’ expects type ‘int’, but argument 4 has type ‘loff_t’
/root/ldd3/scull/scull_fops.c:26: warning: ISO C90 forbids mixed declarations and code
/root/ldd3/scull/scull_fops.c:40: warning: ISO C90 forbids mixed declarations and code
/root/ldd3/scull/scull_fops.c:58: warning: ISO C90 forbids mixed declarations and code
/root/ldd3/scull/scull_fops.c:58: warning: unused variable ‘str’
/root/ldd3/scull/scull_fops.c: In function ‘scull_write’:
/root/ldd3/scull/scull_fops.c:79: warning: format ‘%i’ expects type ‘int’, but argument 4 has type ‘loff_t’
/root/ldd3/scull/scull_fops.c:80: warning: ISO C90 forbids mixed declarations and code
/root/ldd3/scull/scull_fops.c:88: warning: ISO C90 forbids mixed declarations and code
/root/ldd3/scull/scull_fops.c: In function ‘scull_open’:
/root/ldd3/scull/scull_fops.c:142: warning: ISO C90 forbids mixed declarations and code
/root/ldd3/scull/scull_fops.c: In function ‘scull_trim’:
/root/ldd3/scull/scull_fops.c:161: warning: ISO C90 forbids mixed declarations and code
/root/ldd3/scull/scull_fops.c:168: warning: ISO C90 forbids mixed declarations and code
/root/ldd3/scull/scull_fops.c: In function ‘scull_follow’:
/root/ldd3/scull/scull_fops.c:181: warning: ISO C90 forbids mixed declarations and code
  LD [M]  /root/ldd3/scull/scull.o
  Building modules, stage 2.
  MODPOST
  CC      /root/ldd3/scull/scull.mod.o
  LD [M]  /root/ldd3/scull/scull.ko
make[1]: Leaving directory `/usr/src/kernels/2.6.18-92.el5-i686'

EZWORD

程序本身没有问题，问题在于程序太乱，以下我测试结果
insmod scull.ko
hello, scull
The process is "insmod" (pid 83)
scull, alloc_dev() start
scull, register_dev() start
cat /proc/device
251 scull   


简单的把那个scull_fops.c包进来。。。。。
makefile中
scull-objs := scull_fops.o
这一行要去掉

建议好好学学c的编程规范

EZWORD

去试试吧，我这里就可以通过，而且出现设备了。

HJLin

回复 10# EZWORD


    你可以用，是按照我的源码，文件分开的吗？没有把scull_fops 合到scull.c 里面把？