proc探究记录

cmqy

/proc是个用于与内核进行交流的ramfs，渊源不作介绍，仅记录自己的认知

在以往的迷糊理解中，认为seq_file是对在/proc创建文件的另一种实现，然而并不是，先说说seq_file的/proc的关系seq_file仅仅是/proc文件向用户层输出的一种实现，为了克服之前不能输出大于1页数据的缺陷理解/proc文件系统之前，最好先看看VFS结构。
创建/proc文件的步骤为：
1、创建/proc条目

1. struct proc_dir_entry *entry;
   
2. entry=create_proc_entry("proctest",0666,NULL);

复制代码

struct proc_dir_entry是内核保存/proc条目的结构体，看看create_proc_entry的声明

1. 109 extern struct proc_dir_entry *create_proc_entry(const char *name, mode_t mode,
   
2. 110                                                 struct proc_dir_entry *parent);

复制代码

@name是创建的proc文件的名字，@mode是访问权限，@parent是父目录的proc_dir_entry结构体

2、关联操作集
看看proc_dir_entry的结构体原型 2.6.32的

1. struct proc_dir_entry {
   
2. 52         unsigned int low_ino;
   
3. 53         unsigned short namelen;
   
4. 54         const char *name;
   
5. 55         mode_t mode;
   
6. 56         nlink_t nlink;
   
7. 57         uid_t uid;
   
8. 58         gid_t gid;
   
9. 59         loff_t size;
   
10. 60         const struct inode_operations *proc_iops;
    
11. 61         /*
    
12. 62          * NULL ->proc_fops means "PDE is going away RSN" or
    
13. 63          * "PDE is just created". In either case, e.g. ->read_proc won't be
    
14. 64          * called because it's too late or too early, respectively.
    
15. 65          *
    
16. 66          * If you're allocating ->proc_fops dynamically, save a pointer
    
17. 67          * somewhere.
    
18. 68          */
    
19. 69         const struct file_operations *proc_fops;
    
20. 70         struct proc_dir_entry *next, *parent, *subdir;
    
21. 71         void *data;
    
22. 72         read_proc_t *read_proc;
    
23. 73         write_proc_t *write_proc;
    
24. 74         atomic_t count;         /* use count */
    
25. 75         int pde_users;  /* number of callers into module in progress */
    
26. 76         spinlock_t pde_unload_lock; /* proc_fops checks and pde_users bumps */
    
27. 77         struct completion *pde_unload_completion;
    
28. 78         struct list_head pde_openers;   /* who did ->open, but not ->release */
    
29. 79 };
    
30. 3.10的
    
31. 32 struct proc_dir_entry {
    
32. 33         unsigned int low_ino;
    
33. 34         umode_t mode;
    
34. 35         nlink_t nlink;
    
35. 36         kuid_t uid;
    
36. 37         kgid_t gid;
    
37. 38         loff_t size;
    
38. 39         const struct inode_operations *proc_iops;
    
39. 40         const struct file_operations *proc_fops;
    
40. 41         struct proc_dir_entry *next, *parent, *subdir;
    
41. 42         void *data;
    
42. 43         atomic_t count;         /* use count */
    
43. 44         atomic_t in_use;        /* number of callers into module in progress; */
    
44. 45                         /* negative -> it's going away RSN */
    
45. 46         struct completion *pde_unload_completion;
    
46. 47         struct list_head pde_openers;   /* who did ->open, but not ->release */
    
47. 48         spinlock_t pde_unload_lock; /* proc_fops checks and pde_users bumps */
    
48. 49         u8 namelen;
    
49. 50         char name[];
    
50. 51 };

复制代码

挂操作集的方式有使用file_operations和外面的write_proc和read_proc，新版本的内核不提供write_proc/read_proc了。
seq_file的操作方式

1. struct seq_operations normal_seq_ops =
   
2. {
   
3.         .start=nor_start,
   
4.         .show=nor_show,
   
5.         .next=nor_next,
   
6.         .stop=nor_stop
   
7. };
   
8. 
   
9. int normal_open(struct inode *inode, struct file *file)
   
10. {
    
11.         return seq_open(file,&normal_seq_ops);
    
12. }
    
13. 
    
14. static struct file_operations fops =
    
15. {
    
16.         .owner=THIS_MODULE,
    
17.         .llseek=seq_lseek,
    
18.         .read=seq_read,
    
19.         .write=seq_write,
    
20.         .open=normal_open,
    
21.         .release=seq_release
    
22. };

复制代码

使用file_operations对文件进行操作，用于只读的话，只需要挂上open和write函数就行，其他函数可以使用内核提供，其中open简单的返回seq_open，秘密在于其参数struct *seq_operations，需要自己实现4个回调函数。用于迭代产生内容。其调用规则为：启动时调用start，start执行后，如果返回非NULL，则返回值作为show的参数v调用show用于向/proc文件中输出数据，然后调用next，参数v仍为start返回结果，如果next返回非空则调用show，如此往复循环，返回空则调用stop。之后再调用start，直到start返回为NULL，最后仍会调用一次stop。seq_operations的原型为

1. 35 struct seq_operations {
   
2. 36         void * (*start) (struct seq_file *m, loff_t *pos);
   
3. 37         void (*stop) (struct seq_file *m, void *v);
   
4. 38         void * (*next) (struct seq_file *m, void *v, loff_t *pos);
   
5. 39         int (*show) (struct seq_file *m, void *v);
   
6. 40 };

复制代码

start返回一个存储了数据的空间，是自己创建的，并在调用show时作为v参数传给show，show负责向用户展示里面的内容。start的*pos是递增的，可以用于判断什么时候返回NULL结束迭代。
show可以对输出内容作格式化处理，参数v含有内容，参数m为输出接口，可使用以下函数

1. 82 int seq_putc(struct seq_file *m, char c);
   
2. 83 int seq_puts(struct seq_file *m, const char *s);
   
3. 
   
4. 86 int seq_printf(struct seq_file *, const char *, ...)

复制代码

对于路径及链表，还有其它函数可以使用，详情见内核文档Document/filesystem/seq_file.txt。其中还有一段话，说明其中指向seq_file的指针在调用seq_open的时候被存在struct file的private域中

1. On a successful open, seq_open() stores the struct seq_file pointer in
   
2. file->private_data. If you have an application where the same iterator can
   
3. be used for more than one file, you can store an arbitrary pointer in the
   
4. private field of the seq_file structure; that value can then be retrieved
   
5. by the iterator functions

复制代码

对于2.6.32之类的老内核，可以使用proc_dir_entry里的write_proc和read_proc函数对proc文件进行操作

1. 46 typedef int (read_proc_t)(char *page, char **start, off_t off,
   
2. 47                           int count, int *eof, void *data);
   
3. 48 typedef int (write_proc_t)(struct file *file, const char __user *buffer,
   
4. 49                            unsigned long count, void *data);

复制代码

对于read_proc
page 是内核创建的页，start是如果使用自己创建的内存空间，则将指针的地址赋给start，off是希望从proc中读开始取的偏移，count是page页提供的大小，eof 当传递结束时，应该把*eof赋1，data是使用proc_create_data创建proc_dir_entry时传的指针
对于write_proc
file是file结构体，buffer是用户空间，count是用户数据长度，data和read_proc一样。

3、创建目录和在指定目录下创建条目
使用proc_mkdir()可以在/proc下创建目录
而想要在/proc/net下创建文件，在内核2.6.32中的操作方式是讲create_proc_entry的parent参数设为init_net.proc_net，不同版本内核不一样


最后附上示例代码：

1. 
   
2. /*
   
3. *创建/proc/net/testdir/目录下ro_read_proc,rw_normal,rw_write_proc三个文件
   
4. *rw_normal用seq_file实现，只读
   
5. *rw_write_proc用write_proc和read_proc实现，读写，用于输入需要在内核打开的文件名
   
6. *ro_read_proc用create_proc_read_entry实现的只读，用打开并输出从rw_write_proc输入的文件名，文件应小于3072字节
   
7. */
   
8. 
   
9. #include <linux/init.h>
   
10. #include <linux/module.h>
    
11. #include <linux/proc_fs.h>
    
12. #include <linux/fs.h>
    
13. #include <linux/seq_file.h>
    
14. #include <linux/slab.h>
    
15. #include <linux/string.h>
    
16. #include <asm/uaccess.h>
    
17. #include <net/net_namespace.h> //init_net.proc_net
    
18. #include <linux/err.h>        //IS_ERR
    
19. #include <linux/dcache.h> //dentry
    
20. 
    
21. #include <asm/segment.h>        //use for operating files in kernel space
    
22. #include <linux/buffer_head.h>
    
23. 
    
24. MODULE_AUTHOR("Liaosp");
    
25. MODULE_LICENSE("Dual BSD/GPL");
    
26. 
    
27. #define MAXPATHSIZE 256
    
28. static char pathbuff[MAXPATHSIZE];
    
29. 
    
30. void * nor_start(struct seq_file *m, loff_t *pos)
    
31. {
    
32. if(*pos>0)
    
33. return NULL;
    
34. return pathbuff;
    
35. }
    
36. 
    
37. void nor_stop(struct seq_file *m, void *v)
    
38. {
    
39. }
    
40. 
    
41. void * nor_next(struct seq_file *m, void *v, loff_t *pos)
    
42. {
    
43. return NULL;
    
44. }
    
45. 
    
46. int nor_show(struct seq_file *m, void *v)
    
47. {
    
48. seq_printf(m,"%s",(char *)v);
    
49. return 0;
    
50. }
    
51. 
    
52. 
    
53. struct seq_operations normal_seq_ops =
    
54. {
    
55. .start=nor_start,
    
56. .show=nor_show,
    
57. .next=nor_next,
    
58. .stop=nor_stop
    
59. };
    
60. 
    
61. int normal_open(struct inode *inode, struct file *file)
    
62. {
    
63. return seq_open(file,&normal_seq_ops);
    
64. }
    
65. 
    
66. static struct file_operations fops =
    
67. {
    
68. .owner=THIS_MODULE,
    
69. .llseek=seq_lseek,
    
70. .read=seq_read,
    
71. .write=seq_write,           //这里是个严重的BUG，write函数得自己写
    
72. .open=normal_open,
    
73. .release=seq_release
    
74. };
    
75. 
    
76. //operating files in kernel
    
77. struct file *file_open(const char *path, int flag,int right)
    
78. {
    
79. mm_segment_t oldfs;
    
80. struct file *filp=NULL;
    
81. int err=0;
    
82. 
    
83. oldfs=get_fs();
    
84. set_fs(get_ds());
    
85. 
    
86. filp=filp_open(path,flag,right);
    
87. if(IS_ERR(filp))
    
88. {
    
89. printk("open %s error\n",path);
    
90. err=PTR_ERR(filp);
    
91. return NULL;
    
92. }
    
93. set_fs(oldfs);
    
94. return filp;
    
95. }
    
96. 
    
97. void file_close(struct file *file)
    
98. {
    
99. filp_close(file,NULL);
    
100. }
     
101. 
     
102. int file_read(struct file *file,unsigned char *data, unsigned int size,unsigned long long offset)
     
103. {
     
104. mm_segment_t oldfs;
     
105. int ret;
     
106. 
     
107. oldfs=get_fs();
     
108. set_fs(get_ds());
     
109. 
     
110. ret=vfs_read(file, data, size, &offset);
     
111. 
     
112. set_fs(oldfs);
     
113. return ret;
     
114. }
     
115. 
     
116. 
     
117. 
     
118. // what is @start @off @eof @data mean?
     
119. static int read_ro(char *page,char **start, off_t off, int count, int *eof, void *date)
     
120. {
     
121. struct file *fp;
     
122. unsigned long re=0;
     
123. printk("%s\n",pathbuff);
     
124. 
     
125. fp=file_open(pathbuff,O_RDONLY,0);
     
126. printk("file open success :%s\n",fp->f_path.dentry->d_name.name);
     
127. re=file_read(fp,page,count,off);
     
128. file_close(fp);
     
129. if(re<=0)
     
130. 
     
131. //        re=snprintf(page,10,"in read_ro in ro\n");
     
132. *eof=1;
     
133. return re;
     
134. }
     
135. //@page 是内核创建的页
     
136. //@start 如果使用自己创建的内存空间，则将指针的地址赋给start
     
137. //@off 希望从proc中读开始取的偏移
     
138. //@count page页提供的大小
     
139. //@eof 当传递结束时，应该把*eof赋1
     
140. //@data proc_create_data传的指针
     
141. static int rw_r_proc(char *page, char **start, off_t off, int count, int *eof, void *data)
     
142. {
     
143. int re=0;
     
144. printk("in proc_read\noff:%d conut:%d\n",off,count);
     
145. re=snprintf(page,MAXPATHSIZE,"%s",pathbuff);
     
146. *eof=1;
     
147. return re;
     
148. 
     
149. }
     
150. 
     
151. static int rw_w_proc(struct file *file, const char __user *buffer, unsigned long count, void *data)
     
152. {
     
153. int re=0;
     
154. re=copy_from_user(pathbuff,buffer,count);
     
155. pathbuff[count-1]='\0';
     
156. printk("%s",pathbuff);
     
157. return count;
     
158. 
     
159. }
     
160. 
     
161. struct proc_dir_entry *dir;        // /proc/net/<dir>
     
162. 
     
163. static int exproc_init(void)
     
164. {
     
165. memset(pathbuff,0,MAXPATHSIZE);
     
166. strcpy(pathbuff,"echo the path into this file more len \n");
     
167. 
     
168. struct proc_dir_entry *rw_normal; //using file_operations
     
169. struct proc_dir_entry *rw_write_proc; //rw using write_proc
     
170. struct proc_dir_entry *ro_read_proc; //ro using create_proc_read_entry
     
171. 
     
172. 
     
173. 
     
174. //        dir=create_proc_entry("/proc/net/testdir",0666,NULL);
     
175. //        don't work
     
176. 
     
177. //        struct file *filp = filp_open("/proc/net",O_RDONLY,0);
     
178. //        parent=PDE(filp->f_dentry->d_inode);
     
179. //        dir=create_proc_entry("testdir",0666,parent);
     
180. //        can't work in kernel 2.6.35
     
181. 
     
182. dir=proc_mkdir("testdir",init_net.proc_net);
     
183. rw_normal=create_proc_entry("rw_normal",0444,dir);
     
184. rw_write_proc=create_proc_entry("rw_write_proc",0666,dir);
     
185. 
     
186. ro_read_proc=create_proc_read_entry("ro_read_proc",0,dir,read_ro,NULL);
     
187. 
     
188. rw_write_proc->read_proc=rw_r_proc;
     
189. rw_write_proc->write_proc=rw_w_proc;
     
190. 
     
191. rw_normal->proc_fops=&fops;
     
192. 
     
193. }
     
194. static void exproc_exit(void)
     
195. {
     
196. remove_proc_entry("rw_normal",dir);
     
197. remove_proc_entry("rw_write_proc",dir);
     
198. remove_proc_entry("ro_read_proc",dir);
     
199. remove_proc_entry("testdir",init_net.proc_net);
     
200. }
     
201. 
     
202. 
     
203. module_init(exproc_init);
     
204. module_exit(exproc_exit);

复制代码

这个文本编辑器真恶心，害我写了两次，还差点要写三次

Godbach

回复 1# cmqy
感谢分享。

   

_nosay

大牛！别走！帮我签个名。