关于/proc文件系统及seq_file实现，求解惑！！

wenshengking

第一：/proc文件系统是什么 ？这个网上很多，说的很细，我也就不说了。但是他是做什么用的，网上也很多，但是我不解，就我目前了解的，简单的说，/proc是驱动程序的一种调式方法（如有不对可以指出），那么怎样让我的/proc文件系统与我的驱动程序建立联系！！？？如下面最简单的一个/proc文件系统例子：

1. // include kernel head files
   
2. #include <linux/init.h>
   
3. #include <linux/module.h>
   
4. 
   
5. #include <linux/proc_fs.h>
   
6. #include <asm/uaccess.h>
   
7. 
   
8. // licensed under BSD/GPL
   
9. MODULE_LICENSE("Dual BSD/GPL");
   
10. 
    
11. static struct proc_dir_entry *prwd_dir = NULL;
    
12. static struct proc_dir_entry *prwd_rdonly = NULL;
    
13. static struct proc_dir_entry *prwd_rdwr = NULL;
    
14. 
    
15. static char sbufr[ 100 ] = "One test string from reading only !\n";
    
16. static char sbufrw[ 1000 ] = "";
    
17. 
    
18. // read-only function
    
19. static int prwd_rdonly_read(char *page, char **start, off_t off, int count, int *eof, void *data)
    
20. {
    
21.         sprintf( page, "%s", sbufr );
    
22. 
    
23.         *eof = 1;
    
24. 
    
25.         return strlen( sbufr );
    
26. }
    
27. 
    
28. // read function for read-write
    
29. static int prwd_rdwr_read(char *page, char **start, off_t off, int count, int *eof, void *data)
    
30. {
    
31.         int len;
    
32. 
    
33.         len = strlen( sbufrw );
    
34.         if( len <= off ) {
    
35.                 printk(KERN_ALERT "File pointer at end of file or no data for reading in read-write buffer !\n");
    
36.                 return -EINVAL;
    
37.         }
    
38. 
    
39.         if( ( len - off ) < count ) {
    
40.                 count = len - off;
    
41.         }
    
42. 
    
43.         memcpy( page, ( sbufrw + off ), count );
    
44. 
    
45.         if( len <= ( off + count ) ) {
    
46.                 *eof = 1;
    
47.         }
    
48. 
    
49.         return count;
    
50. }
    
51. 
    
52. // write function for read-write
    
53. static int prwd_rdwr_write(struct file *file, const char __user *buffer, unsigned long count, void *data)
    
54. {
    
55.         unsigned long cnt = count;
    
56. 
    
57.         if( cnt >= sizeof( sbufrw ) ) {
    
58.                 cnt = sizeof( sbufrw ) - 1;
    
59.         }
    
60. 
    
61.         if( copy_from_user( sbufrw, buffer, cnt ) ) {
    
62.                 printk(KERN_ALERT "Failure to copy data from user space !\n");
    
63.                 return -EFAULT;
    
64.         }
    
65. 
    
66.         sbufrw[ cnt ] = '\0';
    
67. 
    
68.         return cnt;
    
69. }
    
70. 
    
71. // initialize module function
    
72. static int __init procreadwritedemo_init(void)
    
73. {
    
74.         printk(KERN_ALERT "Entry procreadwritedemo_init !\n");
    
75. 
    
76.         // create directory: procreadwritedemo in /proc
    
77.         prwd_dir = proc_mkdir( "procreadwritedemo", NULL );
    
78.         if( NULL == prwd_dir ) {
    
79.                 printk(KERN_ALERT "Cann't create directory: /proc/procreadwritedemo !\n");
    
80.                 goto failure_create_dir;
    
81.         }
    
82.         printk(KERN_ALERT "Success to create directory: /proc/procreadwritedemo !\n");
    
83. 
    
84.         // create read-only file: rdonly in /proc/procreadwritedemo
    
85.         prwd_rdonly = create_proc_read_entry( "rdonly", 0400, prwd_dir, prwd_rdonly_read, NULL );
    
86.         if( NULL == prwd_rdonly ) {
    
87.                 printk(KERN_ALERT "Cann't create read-only file: /proc/procreadwritedemo/rdonly !\n");
    
88.                 goto failure_create_rdonly;
    
89.         }
    
90.         printk(KERN_ALERT "Success to create read-only file: /proc/procreadwritedemo/rdonly !\n");
    
91. 
    
92.         // create read-write file: rdwr in /proc/procreadwritedemo
    
93.         prwd_rdwr = create_proc_entry( "rdwr", 0666, prwd_dir );
    
94.         if( NULL == prwd_rdwr ) {
    
95.                 printk(KERN_ALERT "Cann't create read-write file: /proc/procreadwritedemo/rdwr !\n");
    
96.                 goto failure_create_rdwr;
    
97.         }
    
98.         prwd_rdwr->read_proc = prwd_rdwr_read;
    
99.         prwd_rdwr->write_proc = prwd_rdwr_write;
    
100.         printk(KERN_ALERT "Success to create read-write file: /proc/procreadwritedemo/rdwr !\n");
     
101. 
     
102.         return 0;
     
103. 
     
104. failure_create_rdwr:
     
105.         remove_proc_entry( "rdonly", prwd_dir );
     
106. failure_create_rdonly:
     
107.         remove_proc_entry( "procreadwritedemo", NULL );
     
108. failure_create_dir:
     
109.         return -EFAULT;
     
110. }
     
111. 
     
112. // clean up module function
     
113. static void __exit procreadwritedemo_exit(void)
     
114. {
     
115.         printk(KERN_ALERT "Entry procreadwritedemo_exit !\n");
     
116. 
     
117.         // remove files and directory created in /proc
     
118.         remove_proc_entry( "rdwr", prwd_dir );
     
119.         remove_proc_entry( "rdonly", prwd_dir );
     
120.         remove_proc_entry( "procreadwritedemo", NULL );
     
121. }
     
122. 
     
123. // the declarations of initilization and cleaning up module funcitons
     
124. module_init( procreadwritedemo_init );
     
125. module_exit( procreadwritedemo_exit );
     
126. 
     
127. // module information
     
128. MODULE_AUTHOR("wensheng");
     
129. MODULE_DESCRIPTION("Proc filesystem read/write demo");
     
130. MODULE_VERSION("0.0.1");
     
131. MODULE_ALIAS("ProcReadWriteDemo");
     

复制代码

上面的一例，完全是一个独立/proc系统代码的实现，问题是：他是那怎与我想调试的驱动（如一个块设备）程序建立关系了，如是不能跟我的相关驱动建联系，那/proc文件系统存在意义是什么 （简单说就是做什么用的，最好可以举个易懂的例子）？？


第二：关于seq_file机制
有如下代码

1. #include <linux/fs.h>
   
2. #include <linux/init.h>
   
3. #include <linux/proc_fs.h>
   
4. #include <linux/seq_file.h>
   
5. struct proc_dir_entry proc_root;
   
6. 
   
7. void * our_seq_start(struct seq_file *m, loff_t *pos)
   
8. {
   
9. //printk("<0>""in our_seq_start/n");
   
10. if(*pos == 0)
    
11.   return pos;
    
12. return NULL;
    
13. }
    
14. 
    
15. void * our_seq_stop(struct seq_file *m, void *v)
    
16. {
    
17. //printk("/nDO NOTHING/n");
    
18. }
    
19. 
    
20. 
    
21. int our_seq_show(struct seq_file *m, loff_t *pos)
    
22. {
    
23. static unsigned long counter = 0;
    
24. int i;
    
25. for(i=0;i<10;i++)
    
26. seq_printf(m,"the counter is %d/n",i);
    
27. return 0;
    
28. }
    
29. 
    
30. void *our_seq_next(struct seq_file *m, loff_t *pos)
    
31. {
    
32. static unsigned long counter_next = 0;
    
33. if(pos < 1)
    
34. {
    
35.   counter_next++;
    
36.   pos++;
    
37.   return pos;
    
38. }
    
39. else
    
40. {
    
41.   *pos = 0;
    
42.   return NULL;
    
43. }
    
44. }
    
45. 
    
46. static const struct seq_operations our_seq_ops = {
    
47. .start = our_seq_start,
    
48. .next  = our_seq_next,
    
49. .stop  = our_seq_stop,
    
50. .show  = our_seq_show
    
51. };
    
52. 
    
53. static int our_seq_open(struct inode *inode, struct file *filp)
    
54. {
    
55. printk("<0>""in our_seq_open/n");
    
56. return seq_open(filp, &our_seq_ops);
    
57. }
    
58. int our_ioctl()
    
59. {
    
60. printk("<0>""in our_seq_ioctl/n");
    
61. return 0;
    
62. }
    
63. 
    
64. int our_write()
    
65. {
    
66. printk("<0>""in our_seq_write/n");
    
67. return 5;
    
68. }
    
69. struct file_operations our_proc_ops = {
    
70. .open    = our_seq_open,
    
71. .read    = seq_read,
    
72. .write   = our_write,
    
73. .llseek  = seq_lseek,
    
74. .ioctl   = our_ioctl,
    
75. .release = seq_release
    
76. };
    
77. 
    
78. int our_init()
    
79. {
    
80. proc_create("hehe", 0, NULL, &our_proc_ops);
    
81. return 0;
    
82. }
    
83. void our_exit()
    
84. {
    
85. remove_proc_entry("hehe",NULL);
    
86. }
    
87. module_init(our_init);
    
88. module_exit(our_exit);

复制代码

上面代码是目前我在网上查到的/proc文件系统实现中唯一个涉及到ioctl操作（此处不关心代码是否有错，关心功能码是否以实现），因为之前所有相关seq_file机制建立/proc，中struct file_operations，只有如下操作

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

复制代码

而且我们只用实现open（），而read，lseek，release，都是seq_file内部实现，我们可不管。问题是没有write（），没有ioctl（）（为什么没有，我们可以暂不讨论），我想问的是，我们可否像上面那个代码一样添加自己的write与ioctl功能。
      以上都是自己跟据现有资做出的理解，如有不对，请您不吝指出，还有我的一些不解之处，求大神解惑！！