read时出现问题

ice2000feng

为什么下面的代码生成的字符驱动，在读的时候，内容一直在刷，是什么问题导致的呢？
测试方法:
date > /dev/对应的设备文件
cat /dev/对应的设备文件。
cat 后，屏幕上就一直打印出东西，内容还是乱码。
（代码就是linux设备驱动开发详解中的第6章的例子)

另外看到一个人的博客里这样写到：

2.加载和创建设备节点都是成功的．但就是用cat命令查看时，虽然读出了正确的字符，却总是在最后还要加上一句提示＂找不到设备或地址＂．不知为何会多出这句来．

# echo 'hello world!' > /dev/globalmem
written 13 bytes(s) from 0
# cat /dev/
/dev/console    /dev/globalmem  /dev/null
# cat /dev/globalmem
read 4096 bytes(s) from 0
hello world!
cat: read error: No such device or address
#
ANSWER:其实没问题，
<1>你把globalmem_read函数中的if (p >＝ GLOBALMEM_SIZE)改为if (p > GLOBALMEM_SIZE)就好了。具体原因是一次调用cat会读两次，每次读取4096个字节，此时文件读指针ppos就是4096了，在第二次读的时候，到if (p >＝ GLOBALMEM_SIZE)这里条件为真，globalmem_read就返回ENXIO错误了，所以才会出现No such device or address"错误。不知道在宋老师的机子上为什么就是正确的？
<2> 宋宝华 ：返回错误值才是正确的，因为读的位置已经越界，所以要返回错误。该返回错误的时候返回正确，那就是错误。改成if (p > GLOBALMEM_SIZE)是错误的。

<3> 根据上面两点可以小结书上是没有错误的。输出的错误信息是正常的debug信息，千不该万不该就是cat调用了read两次。
0

cat 会调用read两次？

1. #include <linux/module.h>
   
2. #include <linux/kernel.h>
   
3. #include <linux/fs.h>
   
4. #include <linux/types.h>
   
5. #include <linux/errno.h>
   
6. #include <linux/init.h>
   
7. #include <linux/cdev.h>
   
8. 
   
9. #include <asm/system.h>
   
10. #include <asm/uaccess.h>
    
11. 
    
12. #define GLOBALMEM_SIZE 0X1000 /* global memory size: 4kB */
    
13. 
    
14. #define MEM_CLEAR 0X1        /* fill 0 to the global memory */
    
15. 
    
16. #define GLOBALMEM_MAJOR 250        /* set globalmem device major number */
    
17. 
    
18. MODULE_LICENSE("Dual BSD/GPL");
    
19. 
    
20. 
    
21. static int globalmem_major = GLOBALMEM_MAJOR;
    
22. static int globalmem_minor = 0;
    
23. 
    
24. module_param(globalmem_major, int, S_IRUGO);
    
25. 
    
26. /* define self dev struct */
    
27. struct globalmem_dev
    
28. {
    
29.         struct cdev cdev;
    
30.         unsigned char mem[GLOBALMEM_SIZE];
    
31. };
    
32. 
    
33. struct globalmem_dev *dev;        /* the object of the device struct */
    
34. 
    
35. 
    
36. int globalmem_open(struct inode *inode, struct file *filp)
    
37. {
    
38.         struct globalmem_dev *dev;
    
39.         dev = container_of(inode, struct globalmem_dev, cdev);
    
40.         filp->private_data = dev;
    
41.         return 0;
    
42. }
    
43. 
    
44. int globalmem_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos)
    
45. {
    
46.         unsigned long p = *f_pos;
    
47.         struct globalmem_dev *dev = filp->private_data;
    
48.                
    
49.         if (p >= GLOBALMEM_SIZE)
    
50.         {
    
51.                 return count ? ENXIO:0;
    
52.         }        
    
53.         
    
54.         if (count > GLOBALMEM_SIZE - p)
    
55.         {
    
56.                 count = GLOBALMEM_SIZE - p;
    
57.         }
    
58. 
    
59.         if (copy_to_user(buf, (void *)(dev->mem + p), count))
    
60.         {
    
61.                 return -EFAULT;
    
62.         }
    
63.         printk(KERN_WARNING "The buf content is %s\n", buf);
    
64.         *f_pos += count;
    
65. 
    
66.         printk(KERN_NOTICE "read %d bytes from globalmem, and the content is %s\n", count, buf);
    
67. 
    
68.         return count;
    
69. }
    
70. 
    
71. int globalmem_write(struct file *filp, char __user *buf, size_t count, loff_t *f_pos)
    
72. {
    
73.         struct globalmem_dev *dev = filp->private_data;
    
74.         unsigned long p = *f_pos;
    
75.         
    
76.         if (p > GLOBALMEM_SIZE)
    
77.         {
    
78.                 return count ? -ENXIO:0;
    
79.         }        
    
80.         
    
81.         if (count > GLOBALMEM_SIZE - p)
    
82.         {
    
83.                 count = GLOBALMEM_SIZE - p;
    
84.         }
    
85. 
    
86.         if (copy_from_user(dev->mem + p, buf, count))
    
87.         {
    
88.                 printk(KERN_NOTICE "Writing data to device Fail\n");
    
89.                 return -EFAULT;
    
90.         }
    
91. 
    
92.         printk(KERN_NOTICE "Writed %d bytes data to device\n", count);
    
93.         *f_pos += count;
    
94. 
    
95.         return count;
    
96. }
    
97. 
    
98. int globalmem_release(struct inode *inode, struct file *filp)
    
99. {
    
100.         return 0;
     
101. }
     
102. 
     
103. loff_t globalmem_llseek(struct file *filp, loff_t off_set, int orig)
     
104. {
     
105.         loff_t ret;
     
106.         
     
107.         switch(orig)
     
108.         {
     
109.         case 0: /* from the header of the file to move */
     
110.                 if (off_set < 0)
     
111.                 {
     
112.                         ret = -EINVAL;
     
113.                 }               
     
114.                 else if ((unsigned int)off_set > GLOBALMEM_SIZE)
     
115.                 {
     
116.                         ret = -EINVAL;
     
117.                 }
     
118.                 else
     
119.                 {
     
120.                         filp->f_pos = (unsigned int)off_set;
     
121.                         ret = filp->f_pos;
     
122.                 }
     
123.                 break;
     
124.         case 1: /* from the current position of the file to move */
     
125.                 if (off_set + filp->f_pos < 0 || off_set + filp->f_pos > GLOBALMEM_SIZE)
     
126.                 {
     
127.                         ret = -EINVAL;
     
128.                 }
     
129.                 else
     
130.                 {
     
131.                         filp->f_pos += off_set;
     
132.                         ret = filp->f_pos;
     
133.                 }
     
134.                 break;
     
135.         case 2:
     
136.                 if (off_set > 0 || off_set + filp->f_pos < 0)
     
137.                 {
     
138.                         ret = -EINVAL;
     
139.                 }
     
140.                 else
     
141.                 {
     
142.                         filp->f_pos += off_set;
     
143.                         ret = filp->f_pos;
     
144.                 }
     
145.                 break;
     
146.         default:
     
147.                 ret = -EINVAL;               
     
148.         }
     
149. 
     
150.         return ret;
     
151. 
     
152. }
     
153. 
     
154. 
     
155. int globalmem_ioctrl(struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg)
     
156. {
     
157.         int ret;
     
158.         struct globalmem_dev *dev = filp->private_data;
     
159.         
     
160.         switch(cmd)
     
161.         {
     
162.         case MEM_CLEAR:
     
163.                 memset(dev->mem, 0, GLOBALMEM_SIZE);
     
164.                 printk(KERN_NOTICE "globalmem memory content reset is zero\n");
     
165.                 ret = 0;
     
166.                 break;
     
167.         default:
     
168.                 ret = -EINVAL;
     
169.         }
     
170. 
     
171.         return ret;        
     
172. }
     
173. 
     
174. struct file_operations globalmem_fops =
     
175. {
     
176.         .owner = THIS_MODULE,
     
177.         .open = globalmem_open,
     
178.         .release = globalmem_release,
     
179.         .read = globalmem_read,
     
180.         .write = globalmem_write,
     
181.         .ioctl = globalmem_ioctrl,
     
182.         .llseek = globalmem_llseek,
     
183. };
     
184. 
     
185. void globalmem_setup_cdev(struct globalmem_dev *dev, int index)
     
186. {
     
187.         int err;
     
188.         dev_t devno = MKDEV(globalmem_major, globalmem_minor + index);
     
189.         cdev_init(&(dev->cdev), &globalmem_fops);
     
190. 
     
191.         dev->cdev.owner = THIS_MODULE;
     
192.         err = cdev_add(&(dev->cdev), devno, 1);
     
193.         if (err)
     
194.         {
     
195.                 printk(KERN_NOTICE "add cdev fail\n");
     
196.         }        
     
197. }
     
198. 
     
199. static int globalmem_init(void)
     
200. {
     
201.         int result;
     
202.         dev_t devno = MKDEV(globalmem_major, 0);
     
203.         
     
204.         if (globalmem_major)
     
205.         {
     
206.                 result = register_chrdev_region(devno, 1, "globalmem");
     
207.         }
     
208.         else
     
209.         {
     
210.                 result = alloc_chrdev_region(&devno, 0, 1, "globalmem");
     
211.                 globalmem_major = MAJOR(devno);
     
212.         }
     
213. 
     
214.         if (result < 0)
     
215.         {
     
216.                 printk(KERN_NOTICE "call globalmem_init fail!\n");
     
217.                 return result;
     
218.         }
     
219. 
     
220.         dev = kmalloc(sizeof(struct globalmem_dev), GFP_KERNEL);
     
221.         if (dev == NULL)
     
222.         {
     
223.                 printk(KERN_WARNING "Alloc gobalmem_dev Fail\n");
     
224.                 unregister_chrdev_region(MKDEV(globalmem_major, 0), 1);
     
225.                 return 0;
     
226.         }
     
227. 
     
228.         memset(dev, 0, sizeof(struct globalmem_dev));
     
229. 
     
230.         globalmem_setup_cdev(dev, 0);
     
231.         
     
232.         
     
233.         return 0;
     
234. }
     
235. 
     
236. void globalmem_exit(void)
     
237. {
     
238.         cdev_del(&(dev->cdev));
     
239.         unregister_chrdev_region(MKDEV(globalmem_major, 0), 1);
     
240. }
     
241. 
     
242. module_init(globalmem_init);
     
243. module_exit(globalmem_exit);

复制代码