歡迎來到Linux教程網
Linux教程網
Linux教程網
Linux教程網
您现在的位置: Linux教程網 >> UnixLinux >  >> Linux綜合 >> Linux內核

Linux內核實踐之序列文件

seq_file機制提供了標准的例程,使得順序文件的處理好不費力。小的文件系統中的文件,通常用戶層是從頭到尾讀取的,其內容可能是遍歷一些數據項創建的。Seq_file機制容許用最小代價實現此類文件,無論名稱如何,但順序文件是可以進行定為操作的,但其實現不怎麼高效。順序訪問,即逐個訪問讀取數據項,顯然是首選的訪問模式。某個方面具有優勢,通常會在其他方面付出代價。

下面我們一步一步來看看怎麼編寫序列文件的處理程序。對於文件、設備相關驅動程序(其實設備也是文件)的操作,我們都知道需要提供一個struct file_operations的實例。對於這裡序列文件的操作,內核中附加提供了一個struct seq_operations結構,該結構很簡單:

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

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:

  1. struct seq_file {  
  2.     char *buf;  
  3.     size_t size;  
  4.     size_t from;  
  5.     size_t count;  
  6.     loff_t index;  
  7.     loff_t read_pos;  
  8.     u64 version;  
  9.     struct mutex lock;  
  10.     const struct seq_operations *op;  
  11.     void *private;  
  12. };  
Buf指向一個內存緩沖區,用於構建傳輸給用戶層的數據。Count指定了需要傳輸到用戶層的剩余的字節數。復制操作的起始位置由from指定,而size給出了緩沖區總的字節數。Index是緩沖區的另一個索引。他標記了內核向緩沖區寫入下一個新紀錄的起始位置。要注意的是,index和from的演變過程是不同的,因為從內核向緩沖區寫入數據,與將這些數據復制到用戶空間,這兩種操作是不同的。

一般情況,對於序列文件,我們的文件操作實例如下:

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

其中,my_open函數需要我們重寫的,也是我們將其用於關聯我們的序列文件。其他都是內核為我們實現好的,在後面我們會詳細介紹。

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

我們這裡調用seq_open函數建立這種關聯。

  1. int seq_open(struct file *file, const struct seq_operations *op)  
  2. {  
  3.     struct seq_file *p = file->private_data;/*p為seq_file結構實例*/  
  4.   
  5.     if (!p) {  
  6.         p = kmalloc(sizeof(*p), GFP_KERNEL);  
  7.         if (!p)  
  8.             return -ENOMEM;  
  9.         file->private_data = p;/*放到file的private_data中*/  
  10.     }  
  11.     memset(p, 0, sizeof(*p));  
  12.     mutex_init(&p->lock);  
  13.     p->op = op;/*設置seq_file的operation為op*/  
  14.   
  15.     /* 
  16.      * Wrappers around seq_open(e.g. swaps_open) need to be 
  17.      * aware of this. If they set f_version themselves, they 
  18.      * should call seq_open first and then set f_version. 
  19.      */  
  20.     file->f_version = 0;  
  21.   
  22.     /* 
  23.      * seq_files support lseek() and pread().  They do not implement 
  24.      * write() at all, but we clear FMODE_PWRITE here for historical 
  25.      * reasons. 
  26.      * 
  27.      * If a client of seq_files a) implements file.write() and b) wishes to 
  28.      * support pwrite() then that client will need to implement its own 
  29.      * file.open() which calls seq_open() and then sets FMODE_PWRITE. 
  30.      */  
  31.     file->f_mode &= ~FMODE_PWRITE;  
  32.     return 0;  
  33. }  
可以看到,我們的seq_file結構以file的私有數據字段傳入虛擬文件系統,同時在open函數中設置了seq_file的操作實例。

我們看下面這個簡單的例子:

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

實驗與結果:

     

Copyright © Linux教程網 All Rights Reserved