Linux内核实践之序列文件【转】

作者：bullbat

     

        seq_file机制提供了标准的例程，使得顺序文件的处理好不费力。小的文件系统中的文件，通常用户层是从头到尾读取的，其内容可能是遍历一些数据项创建的。Seq_file机制容许用最小代价实现此类文件，无论名称如何，但顺序文件是可以进行定为操作的，但其实现不怎么高效。顺序访问，即逐个访问读取数据项，显然是首选的访问模式。某个方面具有优势，通常会在其他方面付出代价。

 

       下面我们一步一步来看看怎么编写序列文件的处理程序。对于文件、设备相关驱动程序（其实设备也是文件）的操作，我们都知道需要提供一个struct file_operations的实例。对于这里序列文件的操作，内核中附加提供了一个struct seq_operations结构，该结构很简单：

​

 

​

2. struct seq_operations {  
3.     void * (*start) (struct seq_file *m, loff_t *pos);  
4.     void (*stop) (struct seq_file *m, void *v);  
5.     void * (*next) (struct seq_file *m, void *v, loff_t *pos);  
6.     int (*show) (struct seq_file *m, void *v);  
7. };  

start()：

         主要实现初始化工作，在遍历一个链接对象开始时，调用。返回一个链接对象的偏移或SEQ_START_TOKEN（表征这是所有循环的开始）。出错返回ERR_PTR。

stop():

        当所有链接对象遍历结束时调用。主要完成一些清理工作。

next():

       用来在遍历中寻找下一个链接对象。返回下一个链接对象或者NULL（遍历结束）。

show():

        对遍历对象进行操作的函数。主要是调用seq_printf(), seq_puts()之类的函数，打印出这个对象节点的信息。

 

        由于c语言中任何数据类型的数据块都可以转化为数据块的内存基址（指针）+数据块大小来传递，不难想到基于我们上面提供的函数，将我们操作的数据用于序列文件的读写、定为、释放等操作完全可以通用话。内核也为我们提供了这些用于读写、定位、释放等操作的通用函数。当然这些操作需要数据结构的支持（比如读取当前位置、数据大小等等），这就是在后面我们会看到的struct seq_file结构。由于我们读写的是文件，在内核中必须提供一个struct file_operations结构的实例，我们可以直接用内核为我们提供的上述函数，并且重写file_operatios结构的open方法，用该方法将虚拟文件系统关联到我们处理的序列文件，那么那些通用的读写函数就可以正常工作了。原理基本上是这样的，下面我们看怎么用file_operatios结构的open方法将我们的序列文件关联到虚拟文件系统。在此之前，我们看看序列文件的表示结构struct seq_file：

​

 

​

2. struct seq_file {  
3.     char *buf;  
4.     size_t size;  
5.     size_t from;  
6.     size_t count;  
7.     loff_t index;  
8.     loff_t read_pos;  
9.     u64 version;  
10.     struct mutex lock;  
11.     const struct seq_operations *op;  
12.     void *private;  
13. };  

        Buf指向一个内存缓冲区，用于构建传输给用户层的数据。Count指定了需要传输到用户层的剩余的字节数。复制操作的起始位置由from指定，而size给出了缓冲区总的字节数。Index是缓冲区的另一个索引。他标记了内核向缓冲区写入下一个新纪录的起始位置。要注意的是，index和from的演变过程是不同的，因为从内核向缓冲区写入数据，与将这些数据复制到用户空间，这两种操作是不同的。

 

一般情况，对于序列文件，我们的文件操作实例如下：

​

 

​

2. static struct file_operations my_operations={  
3.     .open   =my_open,  
4.     .read   =seq_read,  
5.     .llseek =seq_lseek,  
6.     .release    =seq_release,  
7. };  

        其中，my_open函数需要我们重写的，也是我们将其用于关联我们的序列文件。其他都是内核为我们实现好的，在后面我们会详细介绍。

​

 

​

2. static int my_open(struct inode *inode,struct file *filp)  
3. {  
4.     return seq_open(filp,&my_seq_operations);  
5. }  

我们这里调用seq_open函数建立这种关联。

​

 

​

2. int seq_open(struct file *file, const struct seq_operations *op)  
3. {  
4.     struct seq_file *p = file->private_data;/*p为seq_file结构实例*/  
5.   
6.     if (!p) {  
7.         p = kmalloc(sizeof(*p), GFP_KERNEL);  
8.         if (!p)  
9.             return -ENOMEM;  
10.         file->private_data = p;/*放到file的private_data中*/  
11.     }  
12.     memset(p, 0, sizeof(*p));  
13.     mutex_init(&p->lock);  
14.     p->op = op;/*设置seq_file的operation为op*/  
15.   
16.     /* 
17.      * Wrappers around seq_open(e.g. swaps_open) need to be 
18.      * aware of this. If they set f_version themselves, they 
19.      * should call seq_open first and then set f_version. 
20.      */  
21.     file->f_version = 0;  
22.   
23.     /* 
24.      * seq_files support lseek() and pread().  They do not implement 
25.      * write() at all, but we clear FMODE_PWRITE here for historical 
26.      * reasons. 
27.      * 
28.      * If a client of seq_files a) implements file.write() and b) wishes to 
29.      * support pwrite() then that client will need to implement its own 
30.      * file.open() which calls seq_open() and then sets FMODE_PWRITE. 
31.      */  
32.     file->f_mode &= ~FMODE_PWRITE;  
33.     return 0;  
34. }  

      可以看到，我们的seq_file结构以file的私有数据字段传入虚拟文件系统，同时在open函数中设置了seq_file的操作实例。

 

我们看下面这个简单的例子：

​

 

​

2. #include <linux/init.h>  
3. #include <linux/module.h>  
4. #include <linux/kernel.h>  
5. #include <linux/proc_fs.h>  
6. #include <linux/seq_file.h>  
7.   
8.   
9. #define MAX_SIZE 10  
10.   
11.   
12. MODULE_LICENSE("GPL");  
13. MODULE_AUTHOR("Mike Feng");  
14.   
15. /*用于操作的数据*/  
16. struct my_data  
17. {  
18.     int data;  
19. };  
20.   
21. /*全局变量*/  
22. struct my_data *md;  
23.   
24. /*数据的申请*/  
25. struct my_data* my_data_init(void)  
26. {  
27.     int i;  
28.     md=(struct my_data*)kmalloc(MAX_SIZE*sizeof(struct my_data),GFP_KERNEL);  
29.   
30.     for(i=0;i<MAX_SIZE;i++)  
31.         (md+i)->data=i;  
32.   
33.     return md;  
34. }  
35.   
36. /*seq的start函数，仅仅做越界判断然后返回pos*/  
37. void *my_seq_start(struct seq_file *file,loff_t *pos)  
38. {  
39.     return (*pos<MAX_SIZE)? pos :NULL;  
40. }  
41.   
42. /*seq的next函数，仅仅做越界判断然后pos递增*/  
43. void *my_seq_next(struct seq_file *p,void *v,loff_t *pos)  
44. {  
45.     (*pos)++;  
46.     if(*pos>=MAX_SIZE)  
47.         return NULL;  
48.   
49.     return pos;  
50. }  
51.   
52. /*seq的show函数，读数据的显示*/  
53. int my_seq_show(struct seq_file *file,void *v)  
54. {  
55.     unsigned int i=*(loff_t*)v;  
56.     seq_printf(file,"The %d data is:%d\n",i,(md+i)->data);  
57.       
58.     return 0;  
59. }  
60.   
61. /*seq的stop函数，什么也不做*/  
62. void my_seq_stop(struct seq_file *file,void *v)  
63. {  
64.   
65. }  
66.   
67.   
68. /*operations of seq_file */  
69. static const struct seq_operations my_seq_ops={  
70.     .start  =my_seq_start,  
71.     .next   =my_seq_next,  
72.     .stop   =my_seq_stop,  
73.     .show   =my_seq_show,  
74. };  
75.   
76. /*file的open函数，用于seq文件与虚拟文件联系*/  
77. static int my_open(struct inode *inode,struct file *filp)  
78. {  
79.     return seq_open(filp,&my_seq_ops);  
80. }  
81.   
82. /*file操作*/  
83. static const struct file_operations my_file_ops={  
84.     .open   =my_open,  
85.     .read   =seq_read,  
86.     .llseek =seq_lseek,  
87.     .release=seq_release,  
88.     .owner  =THIS_MODULE,  
89. };  
90.   
91. static __init int my_seq_init(void)  
92. {  
93.     struct proc_dir_entry *p;  
94.     my_data_init();  
95.     p=create_proc_entry("my_seq",0,NULL);  
96.     if(p)  
97.     {  
98.         p->proc_fops=&my_file_ops;  
99.     }  
100.   
101.     return 0;  
102.       
103. }  
104.   
105. static void my_seq_exit(void)  
106. {  
107.     remove_proc_entry("my_seq",NULL);  
108. }  
109.   
110. module_init(my_seq_init);  
111. module_exit(my_seq_exit);  

实验与结果：

       你可能会好奇，上面的结果是怎么得到的。当我们用命令cat /proc/my_seq时，即是读取文件/proc/my_seq，而在我们的程序中，my_seq文件绑定到了我们给定的文件操作（p->proc_fops=&my_file_ops;）。那么很自然想到，他是调用my_file_ops中的.read函数，即seq_read函数，我们看看这个函数在内核中是怎么实现的(<fs/seq_file.c>)。

ssize_t seq_read(struct file *file, char __user *buf, size_t size, loff_t *ppos)

{

       struct seq_file *m = (struct seq_file *)file->private_data;

       ……

       /* we need at least one record in buffer */

       pos = m->index;

       p = m->op->start(m, &pos);

       while (1) {

              err = PTR_ERR(p);

              if (!p || IS_ERR(p))

                     break;

              err = m->op->show(m, p);

              if (err < 0)

                     break;

              if (unlikely(err))

                     m->count = 0;

              if (unlikely(!m->count)) {

                     p = m->op->next(m, p, &pos);

                     m->index = pos;

                     continue;

              }

              if (m->count < m->size)

                     goto Fill;

              m->op->stop(m, p);

              kfree(m->buf);

              m->buf = kmalloc(m->size <<= 1, GFP_KERNEL);

              if (!m->buf)

                     goto Enomem;

              m->count = 0;

              m->version = 0;

              pos = m->index;

              p = m->op->start(m, &pos);

       }

       m->op->stop(m, p);

       m->count = 0;

       goto Done;

……

}

       该函数代码比较长，我们只看while循环部分，也即循环打印的过程，我们从红色代码部分可以看出程序循环调用seq_file操作的start、show、next、stop函数，直到读完数据。而start返回的值传入了next和stop函数（就是我们的序列文件读指针索引，在next中为void*类型）。

 

       除了上面的描述，内核还为我们提供了一系列辅助函数，比如single_open函数只需要我们重写show函数即可，需要用的话可以查看相关的代码，了解其定义。这里，我们看看对于内核链表组织的数据seq_file是怎么使用的。

程序文件（list_seq.c）:

​

 

​

2. #include <linux/init.h>  
3. #include <linux/module.h>  
4. #include <linux/kernel.h>  
5. #include <linux/mutex.h>  
6. #include <linux/proc_fs.h>  
7. #include <linux/seq_file.h>  
8.   
9. #define N 10  
10.   
11. MODULE_LICENSE("GPL");  
12. MODULE_AUTHOR("Mike Feng");  
13.   
14. /*对内核链表操作需要加锁*/  
15. static struct mutex lock;  
16.   
17. static struct list_head head;  
18.   
19. struct my_data  
20. {  
21.     struct list_head list;  
22.     int value;  
23. };  
24.   
25. /*链表的插入元素*/  
26. struct list_head* insert_list(struct list_head *head,int value)  
27. {  
28.     struct my_data *md=NULL;  
29.     mutex_lock(&lock);  
30.     md=(struct my_data*)kmalloc(sizeof(struct my_data),GFP_KERNEL);  
31.     if(md)  
32.     {  
33.         md->value=value;  
34.         list_add(&md->list,head);  
35.           
36.     }  
37.     mutex_unlock(&lock);  
38.   
39.     return head;  
40. }  
41. /*打印，传入参数v为open函数返回的，链表需要操作的节点*/  
42. static int list_seq_show(struct seq_file *file,void *v)  
43. {  
44.     struct list_head *list=(struct list_head*)v;  
45.   
46.     struct my_data *md=list_entry(list,struct my_data,list);  
47.   
48.     seq_printf(file,"The value of my data is:%d\n",md->value);  
49.   
50.     return 0;  
51. }  
52. static void *list_seq_start(struct seq_file *file,loff_t *pos)  
53. {  
54.     /*加锁*/  
55.     mutex_lock(&lock);  
56.     return seq_list_start(&head,*pos);  
57. }  
58.   
59. static void *list_seq_next(struct seq_file *file,void *v,loff_t *pos)  
60. {  
61.     return seq_list_next(v,&head,pos);  
62. }  
63. static void list_seq_stop(struct seq_file *file,void *v)  
64. {  
65.     /*解锁*/  
66.     mutex_unlock(&lock);  
67. }  
68. static struct seq_operations list_seq_ops=  
69. {  
70.     .start  =list_seq_start,  
71.     .next   =list_seq_next,  
72.     .stop   =list_seq_stop,  
73.     .show   =list_seq_show,  
74. };  
75.   
76. static int list_seq_open(struct inode *inode,struct file *file)  
77. {  
78.     return seq_open(file,&list_seq_ops);  
79. }  
80.   
81. static struct file_operations my_file_ops=  
82. {  
83.     .open   =list_seq_open,  
84.     .read   =seq_read,  
85.     .write  =seq_write,  
86.     .llseek =seq_lseek,  
87.     .release=seq_release,  
88.     .owner  =THIS_MODULE,  
89. };  
90.   
91. static __init int list_seq_init(void)  
92. {  
93.     struct proc_dir_entry *entry;  
94.     int i;  
95.     mutex_init(&lock);  
96.     INIT_LIST_HEAD(&head);  
97.   
98.     for(i=0;i<N;i++)  
99.         head=*(insert_list(&head,i));  
100.   
101.     entry=create_proc_entry("list_seq",0,NULL);  
102.     if(entry)  
103.         entry->proc_fops=&my_file_ops;  
104.     return 0;  
105. }  
106.   
107. static void list_seq_exit(void)  
108. {  
109.     struct my_data *md=NULL;  
110.     remove_proc_entry("list_seq",NULL);  
111.   
112.     while(!list_empty(&head))  
113.     {  
114.         md=list_entry((&head)->next,struct my_data,list);  
115.         list_del(&md->list);  
116.         kfree(md);  
117.     }  
118.       
119. }  
120.   
121. module_init(list_seq_init);  
122. module_exit(list_seq_exit);  

测试试验结果：

由于内核函数list_add为前插，所以打出的数据为倒序的。

序列文件的实现基于proc文件系统，下一步将对其进行分析学习。

【作者】张昺华

【微信公众号】 张昺华