linux下 proc文件系统

1、proc_dir_entry数据结构：
struct proc_dir_entry {
    unsigned int low_ino;
    unsigned short namelen;
    const char *name;
    mode_t mode;
    nlink_t nlink;
    uid_t uid;
    gid_t gid;
    loff_t size;
    const struct inode_operations *proc_iops;
    /*
     * NULL ->proc_fops means "PDE is going away RSN" or
     * "PDE is just created". In either case, e.g. ->read_proc won't be
     * called because it's too late or too early, respectively.
     *
     * If you're allocating ->proc_fops dynamically, save a pointer
     * somewhere.
     */
    const struct file_operations *proc_fops;
    struct module *owner;
    struct proc_dir_entry *next, *parent, *subdir;
    void *data;
    read_proc_t *read_proc;
    write_proc_t *write_proc;
    atomic_t count; /* use count */
    int pde_users; /* number of callers into module in progress */
    spinlock_t pde_unload_lock; /* proc_fops checks and pde_users bumps */
    struct completion *pde_unload_completion;
    struct list_head pde_openers; /* who did ->open, but not ->release */
};

2、创建函数：
struct proc_dir_entry *create_proc_entry(const char *name, mode_t mode,struct proc_dir_entry *parent);
name: 要创建的文件名称；
mode: 该文件的保护掩码；
parent: 确定文件所在目录，如果置NULL，则位置为/proc下。

create_proc_entry的返回值是一个proc_dir_entry指针（或者为NULL，说明在create时发生了错误）


3、读proc（read_proc函数）：
int mod_read(char *page, char **start, off_t off,
                          int count, int *eof, void *data);
page：数据写入到的位置（在内核空间中）；

count：可写入的最大字符数；
start和off：返回多页数据时使用（通常一页是4kb）；

data：表示指向私有数据的指针；
eof：文件结束参数。

4、写proc（write_proc函数）：
int mod_write (struct file *filp, const char __user *buff,
                           unsigned long len, void *data);
filp：实际上是一个打开文件结构（可以忽略这个参数）。

buff：用户空间要写入的数据。缓冲区地址实际上是一个用户空间的缓冲区，不能直接读取它。

len ：定义了在 buff 中有多少数据要被写入。

data ：参数是一个指向私有数据的指针。


5.删除

void remove_proc_entry(const char *name, struct proc_dir_entry *parent);

name: 要删除的文件名称；
parent: 确定文件所在目录，如果置NULL，则位置为/proc下。


6. 实现一个proc文件
实例：

1. procfile.c:
3. #include <linux/module.h>
4. #include <linux/kernel.h>
5. #include <linux/proc_fs.h>
6. #include <linux/string.h>
7. #include <linux/vmalloc.h>
8. #include <asm/uaccess.h>
10. #define MAX_COOKIE_LENGTH       PAGE_SIZE
12. static struct proc_dir_entry *proc_entry;
13. static char *cookie_pot;  // Space for procfile strings
14. static int cookie_index;  // Index to write next procfile
15. static int next_procfile;  // Index to read next procfile
17. int
18. procfile_write( struct file *filp, const char __user *buff,
19.                         unsigned long len, void *data )
20. {
21.   int space_available = (MAX_COOKIE_LENGTH-cookie_index) + 1;
22.   if (len > space_available)
23.   {
24.     printk(KERN_INFO "profile: space is full!/n");
25.     return -ENOSPC;
26.   }
27.   if (copy_from_user( &cookie_pot[cookie_index], buff, len ))
28.   {
29.     return -EFAULT;
30.   }
31.   cookie_index += len;
32.   cookie_pot[cookie_index-1] = 0;
33.   return len;
34. }
36. int
37. procfile_read(char *page, char **start, off_t off,
38.                           int count, int *eof, void *data)
39. {
40.   int len;
41.   if (off > 0)
42.   {
43.       printk(KERN_INFO "off > 0/n");
44.     *eof = 1;
45.     return 0;
46.   }
47.  
48.   if (next_procfile >= cookie_index)
49.   {
50.       next_procfile = 0;
51.   }
52.   len = sprintf(page, "%s/n", &cookie_pot[next_procfile]);
53.   next_procfile += len;
54.   return len;
55. }
57. static int __init procfile_module_init(void)
58. {
59.   int ret = 0;
60.   cookie_pot = (char *)vmalloc( MAX_COOKIE_LENGTH );
61.   if (!cookie_pot)
62.   {
63.     ret = -ENOMEM;
64.   }
65.   else
66.   {
67.     memset( cookie_pot, 0, MAX_COOKIE_LENGTH );
68.     proc_entry = create_proc_entry( "profile", 0644, NULL );
69.     if (proc_entry == NULL)
70.     {
71.       ret = -ENOMEM;
72.       vfree(cookie_pot);
73.       printk(KERN_INFO "profile: Couldn't create proc entry/n");
74.     }
75.     else
76.     {
77.       cookie_index = 0;
78.       next_procfile = 0;
79.       proc_entry->read_proc = procfile_read;
80.       proc_entry->write_proc = procfile_write;
81.       proc_entry->owner = THIS_MODULE;
82.       printk(KERN_INFO "profile: Module loaded./n");
83.     }
84.   }
85.   return ret;
86. }
88. static void __exit cleanup_procfile_module(void)
89. {
90.   remove_proc_entry("profile", &proc_root);
91.   vfree(cookie_pot);
92.   printk(KERN_INFO "profile: Module unloaded./n");
93. }
95. module_init( procfile_module_init );
96. module_exit( cleanup_procfile_module );
97. MODULE_LICENSE("GPL");

Makefile:

1. obj-m := proc_hello.o proc_fortune.o procfile.o
2. #KDIR := /lib/modules/$(shell uname -r)/build
3. #PWD := $(shell pwd)
5. PWD  := $(shell pwd)
6. KVER := /usr/src/linux-2.6.18.8
7. KDIR := $(KVER)
9. default:
10.     $(MAKE) -C $(KDIR) M=$(PWD) modules
11. clean:
12.     $(RM) *.o *.mod.c *.ko *.symvers

进行编译：

1. [root@fly procstudy]# make
2. make -C /usr/src/linux-2.6.18.8 M=/home/liuxl/procstudy modules
3. make[1]: Entering directory `/usr/src/linux-2.6.18.8'
4.   CC [M]  /home/liuxl/procstudy/procfile.o
5.   Building modules, stage 2.
6.   MODPOST
7.   LD [M]  /home/liuxl/procstudy/procfile.ko
8. make[1]: Leaving directory `/usr/src/linux-2.6.18.8'

运行：

1. [root@fly procstudy]# insmode procfile.o
2. -bash: insmode: command not found
3. [root@fly procstudy]# insmod procfile.ko
4. [root@fly procstudy]# dmesg | tail -1
5. profile: Module loaded.
6. [root@fly procstudy]# echo "liuxl procfile successful /n" > /proc/profile
7. [root@fly procstudy]# cat /proc/profile
8. liuxl procfile successful /n