创建proc项，write函数调用copy_from_user读取换行符的疑问

nuclearxin

回复 10# superwujc

。。。请看5楼。啊 自己实现。
不确定使用空间大小的安全做法就是使用 环形链表。

superwujc

回复 11# nuclearxin

刚才搞错了，其实任何情况下，read都会执行2次的，最后一次读取遇到EOF，返回0

1. echo -ne "a b c \n d e \n f \n gh \n wxyz" > /proc/hello
   
2. [root@super memory]# cat /proc/hello
   
3. wxyz[root@super memory]# dmesg
   
4. [87130.808871] buf size: 1613
   
5. [87130.808875] write
   
6. [87130.808876] count = 7
   
7. [87130.808877] strlen(msg) = 16
   
8. [87130.808881] buf size: 1613
   
9. [87130.808882] write
   
10. [87130.808883] count = 6
    
11. [87130.808883] strlen(msg) = 16
    
12. [87130.808887] buf size: 1613
    
13. [87130.808888] write
    
14. [87130.808889] count = 4
    
15. [87130.808889] strlen(msg) = 16
    
16. [87130.808894] buf size: 1613
    
17. [87130.808894] write
    
18. [87130.808895] count = 5
    
19. [87130.808896] strlen(msg) = 16
    
20. [87130.808901] buf size: 1613
    
21. [87130.808901] write
    
22. [87130.808902] count = 5
    
23. [87130.808903] strlen(msg) = 16
    
24. [87134.014814] read
    
25. [87134.014819] count = 5
    
26. [87134.014820] strlen(msg) = 16
    
27. [87134.014840] read
    
28. [87134.014841] count = 0
    
29. [87134.014842] strlen(msg) = 16

复制代码

write会把user buf中最后一个'\n'之后的内容实际写入，覆盖掉'\n'之前的内容
所以read会返回最后一个'\n'之后的内容


另外，ring buf可有样例供参考？多谢

superwujc

回复 11# nuclearxin

哈喽，proc的文件内容操作函数是固定的，read和write的原型也是内核定义好的，换言之，写死的

1. const struct file_operations *proc_fops;

复制代码

1. ssize_t (*read) (struct file *file, char __user *buf, size_t count, loff_t *offset);
   
2. ssize_t (*write) (struct file *file, const char __user *buf, size_t count, loff_t *offset);

复制代码

read从file中读取count字节到buf中，并更新offset
write将buf中的count字节写入到file中，并更新offset
buffer都在用户空间

问下环形缓冲区在这怎么用？

nuclearxin

你想复杂了。不会修改任何 内核机制啊。修改你的module code。一会我写个。

nuclearxin

你想复杂了。不会修改任何 内核机制啊。修改你的module code。一会我写个。

nuclearxin

你想复杂了。不会修改任何 内核机制啊。修改你的module code。一会我写个。

superwujc

回复 16# nuclearxin


给力大神，有劳有劳

nuclearxin

1. 有点问题

复制代码

nuclearxin

1. linux-mkov:~/jerry # cat hh.c
   
2. #include <linux/module.h>
   
3. #include <linux/mm.h>
   
4. #include <linux/gfp.h>
   
5. #include <linux/kernel.h>
   
6. #include <linux/proc_fs.h>
   
7. #include <asm/uaccess.h>
   
8. #include <linux/slab.h>
   
9. #include <linux/string.h>
   
10. 
    
11. 
    
12. 
    
13. struct cir_list {
    
14.   unsigned int num ;
    
15.   struct list_head * cir_entry ;
    
16.   struct list_head * write;
    
17.   struct list_head * read;
    
18. };
    
19. 
    
20. struct cir_node {
    
21.   struct list_head list;
    
22.   int w_off_set ;
    
23.   int r_off_set ;
    
24.   char * buff ;
    
25.   int ok ;
    
26. };
    
27. 
    
28. struct cir_list * jerry;
    
29. 
    
30. 
    
31. int add_node (struct cir_list *c, struct cir_node * n)
    
32. {
    
33.   if(c == NULL) return 0;
    
34.   if(n == NULL) return 0;
    
35. 
    
36. 
    
37.   if(c->cir_entry == NULL){
    
38.     c->cir_entry = &n->list;
    
39.     c->write = &n->list;
    
40.     c->read = &n->list;
    
41.     printk("create the first node\n");
    
42.     return 1;
    
43.   }else {
    
44.     printk("add the new node to the list\n");
    
45.     list_add(&n->list,c->cir_entry);
    
46.     c->num +=1;
    
47.     printk("the num of c %d \n", c->num);
    
48.     return 1;
    
49.   }
    
50. 
    
51. }
    
52. 
    
53. struct cir_list * gen_cir(int n){
    
54. 
    
55.   struct cir_list * hello_list;
    
56. 
    
57.   hello_list = kmalloc(sizeof(struct cir_list),GFP_KERNEL);
    
58. 
    
59.   if(hello_list == NULL){
    
60.     return NULL;
    
61.   }
    
62.   //init the list
    
63.   hello_list->cir_entry = NULL;
    
64.   hello_list->write = NULL;
    
65.   hello_list->num = 0;
    
66.   hello_list->read = NULL;
    
67. 
    
68.   struct cir_node * hello_node;
    
69.   int i;
    
70.   
    
71.   printk("start to generate nodes  in total %d \n",n);
    
72. 
    
73.   for(i=0;i<n;i++){
    
74.     printk("start to generate %d \n",i);
    
75.     hello_node = kmalloc(sizeof(struct cir_node),GFP_KERNEL);
    
76.     if(hello_node == NULL) {
    
77.       printk("not enough mem\n");
    
78.      //TO DO #free all the node already allocated;
    
79.       return NULL;
    
80.     }
    
81.     //init the node
    
82.     hello_node->list.next = &hello_node->list;
    
83.     hello_node->list.prev = &hello_node->list;
    
84.     hello_node->w_off_set = 0;
    
85.     hello_node->r_off_set = 0;
    
86.     hello_node->buff = get_zeroed_page(GFP_KERNEL);
    
87.     hello_node->ok = 1;
    
88.     printk("start to generate %d  add_node func\n",i);
    
89.     add_node(hello_list,hello_node);
    
90.   }
    
91. 
    
92.   return hello_list;
    
93. 
    
94. }
    
95. 
    
96. 
    
97. void clean_list_node(struct cir_list * c)
    
98. {
    
99.   struct cir_node * n;
    
100.   struct list_head * l;
     
101.   printk("start to free\n");
     
102. 
     
103.   list_for_each(l,c->cir_entry) {
     
104.     printk("in for each loop free\n");
     
105.     n = list_entry(l, struct cir_node, list);
     
106.     if(n==NULL) return;
     
107.     free_page(n->buff);
     
108.     printk("in for each loop free free_page\n");
     
109.     kfree(n);
     
110.     printk("in for each loop free node\n");
     
111.   }
     
112. 
     
113.   printk("out for each loop free list\n");
     
114. 
     
115.   //free the head
     
116.   printk("free the head \n");
     
117.   n = list_entry(c->cir_entry, struct cir_node, list);
     
118.   free_page(n->buff);
     
119.   printk("head free_page\n");
     
120.   kfree(n);
     
121.   printk("head node\n");
     
122.   kfree(c);
     
123.   printk("free the list descriptor\n");
     
124. }
     
125. 
     
126. 
     
127. void write_end(char * buff ,size_t count ,struct cir_list * l )
     
128. {
     
129. 
     
130.   printk("----------------------------------start write--------------------------------\n" );
     
131. 
     
132.   unsigned int done=0;
     
133.   unsigned int left_sp_node;
     
134.   struct cir_node * t_node;
     
135.   t_node = list_entry(l->write,struct cir_node,list);
     
136.   left_sp_node = 4096 - t_node->w_off_set;
     
137.   printk("the left space : %d , woffset : %d\n",left_sp_node,t_node->w_off_set );
     
138.   
     
139.   while(count > left_sp_node){
     
140.   
     
141.       printk("----------------------------------loops--------------------------------\n" );
     
142.       printk(" value lengh %d is bigger than left space %d\n",count,left_sp_node);
     
143.       copy_from_user(t_node->buff + t_node->w_off_set,buff+done,left_sp_node);
     
144.       printk(" count %d is decrease space\n",count,left_sp_node);
     
145.       count -= left_sp_node;   
     
146.       t_node->w_off_set += left_sp_node;
     
147.       done += left_sp_node;
     
148.       t_node = list_entry(t_node->list.next,struct cir_node,list);
     
149.       t_node->r_off_set = 0;
     
150.       t_node->w_off_set = 0;
     
151.       left_sp_node = 4096 - t_node->w_off_set;
     
152.       printk("----------------------------------loope--------------------------------\n" );
     
153.    
     
154.   }
     
155.   
     
156.   printk(" value length %d is small than left space %d\n",count,left_sp_node);
     
157.   printk(" --start to append value %d  at offset %d---\n",count,t_node->w_off_set );
     
158.   copy_from_user(t_node->buff + t_node->w_off_set,buff+done,count);
     
159.   t_node->w_off_set += count;
     
160.   done += count;
     
161.   printk(" finshed append %d , all done is %d in this time\n",count,done);
     
162.   l->write = &t_node->list;
     
163.   printk("----------------------------------end--------------------------------\n" );
     
164.   return 1;
     
165.   
     
166. }
     
167. 
     
168. int read_to_write (struct cir_list * l,char * buff,size_t count)
     
169. {
     
170.   
     
171.   struct cir_node * t_node;
     
172.   int o_left;
     
173. 
     
174.   t_node = list_entry(l->read,struct cir_node,list);
     
175.   
     
176.   if(l->read != l->write){
     
177.     printk("cross read\n");
     
178. 
     
179.     o_left = 4096 - t_node->r_off_set;
     
180.     printk("cross read this node have left %d , the request count is %d \n",o_left,count);
     
181. 
     
182.     printk("cross area read  woffset : %d , roffset : %d \n",t_node->w_off_set,t_node->r_off_set);
     
183.     if(count <= o_left){
     
184.       printk("cross read count is <= o_left \n");
     
185.       copy_to_user(buff,t_node->buff + t_node->r_off_set,count);
     
186.       printk("cross area read  copy to user %d \n",count);
     
187.       t_node->r_off_set += count;
     
188.       return count;
     
189.     }else{
     
190.       copy_to_user(buff ,t_node->buff + t_node->r_off_set,o_left);
     
191.       t_node->r_off_set = 4096;
     
192.       t_node = list_entry(t_node->list.next,struct cir_node,list);
     
193.       l->read  = &t_node->list;
     
194.       return o_left;
     
195.     }
     
196. 
     
197.   } else {
     
198. 
     
199.     printk("same area read\n");
     
200.     o_left = t_node->w_off_set - t_node->r_off_set;
     
201.     printk("same area read  woffset : %d , roffset : %d \n",t_node->w_off_set,t_node->r_off_set);
     
202.     if(o_left==0) return 0;
     
203. 
     
204.     if(count <= o_left){
     
205.       copy_to_user(buff,t_node->buff + t_node->r_off_set,count);
     
206.       t_node->r_off_set += count;
     
207.       return count;
     
208.     }else{
     
209.       copy_to_user(buff ,t_node->buff + t_node->r_off_set,o_left);
     
210.       t_node->r_off_set += o_left;
     
211.       return o_left;
     
212.     }
     
213.   
     
214.   }
     
215.   
     
216. 
     
217. }
     
218. int read_proc(struct file *filp,char *buf,size_t count,loff_t *offp)
     
219. {
     
220.   printk("read\n");
     
221.   int real_count;
     
222.   real_count = read_to_write(jerry,buf,count);
     
223.   return real_count;
     
224. }
     
225. 
     
226. int write_proc(struct file *filp,const char *buf,size_t count,loff_t *offp)
     
227. {
     
228.         printk("write\n");
     
229.         write_end(buf,count,jerry);           
     
230.         return count;
     
231. }
     
232. 
     
233. struct file_operations proc_fops = {
     
234.         read: read_proc,
     
235.         write: write_proc
     
236. };
     
237. 
     
238. 
     
239. void create_new_proc_entry()
     
240. {
     
241.         proc_create("hello",0,NULL,&proc_fops);
     
242. }
     
243. int proc_init (void) {
     
244.         
     
245.         jerry = gen_cir(4);
     
246.         create_new_proc_entry();
     
247.         return 0;
     
248. }
     
249. 
     
250. void proc_cleanup(void) {
     
251.         remove_proc_entry("hello",NULL);
     
252.         clean_list_node(jerry);
     
253. }
     
254. 
     
255. MODULE_LICENSE("GPL");
     
256. module_init(proc_init);
     
257. module_exit(proc_cleanup);
     

复制代码

nuclearxin

我申请了4个page大小的空间作为 buff。你自己随意分配吧。

也是新手。。学习玩了