Linux文件系统之proc文件系统

----------------------------------------------- 
#纯属个人理解,如有问题敬请谅解!

#kernel version: 2.6.26

#Author: andy wang

-------------------------------------------------


一: 概述

      Proc文件系统是一个虚拟文件系统, 它是一个非常有用的文件系统, 用户通过它可以查看内核信息,修改内核设置的机制, 是一种用户空间和内核空间通讯的一种方法. Proc下的文件都是虚拟文件;是系统动态创建的. 本文将分析proc文件系统是如何实现 ,其实只要有了VFS知识以后再分析procfs还是比较简单的.



二: procfs初始化

既然procfs是一个文件系统, 那么我们首先要将它注册到内核中, 如果要使用它,还的需要安装此文件系统. 下面我们就从profs 的初始化入手吧.

如果CONFIG_PROC_FS编译选项打开以后,kernel在启动时就会调用proc_root_init()初始化procfs了.

先看看初始化的代码:

void __init proc_root_init(void)

{

         int err = proc_init_inodecache();

         if (err)

                   return;

         err = register_filesystem(&proc_fs_type); //注册proc文件系统

         if (err)

                   return;

         proc_mnt = kern_mount_data(&proc_fs_type, &init_pid_ns); //挂载proc文件系统

         err = PTR_ERR(proc_mnt);

         if (IS_ERR(proc_mnt)) {

                   unregister_filesystem(&proc_fs_type);

                   return;

         }

 

……………..

 

}

首先是注册proc文件系统register_filesystem(),先看看procfs定义:

static struct file_system_type proc_fs_type = {

         .name                   = "proc",

         .get_sb                 = proc_get_sb,

         .kill_sb       = proc_kill_sb,

};

接下来调用kern_mount_data()挂载procfs ,这个函数的流程已经在挂载rootfs文章中介绍了.

我们需要关注的就是在挂载过程中 proc_get_sb()这个回调函数的实现过程.

下面是proc_get_sb()的代码片段:

static int proc_get_sb(struct file_system_type *fs_type,

         int flags, const char *dev_name, void *data, struct vfsmount *mnt)

{

         int err;

         struct super_block *sb;

         struct pid_namespace *ns;

         struct proc_inode *ei;

 

         if (proc_mnt) {

                   ei = PROC_I(proc_mnt->mnt_sb->s_root->d_inode);

                   if (!ei->pid)

                            ei->pid = find_get_pid(1);

         }

 

         if (flags & MS_KERNMOUNT)

                   ns = (struct pid_namespace *)data;

         else

                   ns = current->nsproxy->pid_ns;

 

         sb = sget(fs_type, proc_test_super, proc_set_super, ns); //获取procfs超级块

         if (IS_ERR(sb))

                   return PTR_ERR(sb);

 

         if (!sb->s_root) {    //判断是否建立procfs根目录

                   sb->s_flags = flags;

                   err = proc_fill_super(sb);

                   if (err) {

                            up_write(&sb->s_umount);

                            deactivate_super(sb);

                            return err;

                   }

 

                   ei = PROC_I(sb->s_root->d_inode);

                   if (!ei->pid) {

                            rcu_read_lock();

                            ei->pid = get_pid(find_pid_ns(1, ns));

                            rcu_read_unlock();

                   }

 

                   sb->s_flags |= MS_ACTIVE;

                   ns->proc_mnt = mnt;

         }

 

         return simple_set_mnt(mnt, sb);

}

在这个函数中首先是为procfs分配一个超级块 ,然后填充这个超级块super , 这是一个比较重要的函数,因为在这个函数中会建立proc文件系统的根目录.

下面跟踪一下代码:

int proc_fill_super(struct super_block *s)

{

         struct inode * root_inode;

 

         s->s_flags |= MS_NODIRATIME | MS_NOSUID | MS_NOEXEC;

         s->s_blocksize = 1024;  

         s->s_blocksize_bits = 10;

         s->s_magic = PROC_SUPER_MAGIC;

         s->s_op = &proc_sops;     //超级块操作方法 

         s->s_time_gran = 1;

         

         de_get(&proc_root);

         root_inode = proc_get_inode(s, PROC_ROOT_INO, &proc_root); //分配procfs根目录索引节点

         if (!root_inode)

                   goto out_no_root;

         root_inode->i_uid = 0;

         root_inode->i_gid = 0;

         s->s_root = d_alloc_root(root_inode);  //分配procfs根目录的目录项对象

         if (!s->s_root)

                   goto out_no_root;

         return 0;

 

out_no_root:

         printk("proc_read_super: get root inode failed\n");

         iput(root_inode);

         de_put(&proc_root);

         return -ENOMEM;

}

继续跟踪procfs根目录索引节点实现函数:首先需要看看proc_root的定义

struct proc_dir_entry proc_root = {

         .low_ino     = PROC_ROOT_INO,  //inode编号

         .namelen     = 5, 

         .name                   = "/proc",

         .mode                  = S_IFDIR | S_IRUGO | S_IXUGO,  //目录文件

         .nlink                   = 2, 

         .count                  = ATOMIC_INIT(1),

         .proc_iops = &proc_root_inode_operations,  //索引节点操作方法

         .proc_fops = &proc_root_operations,   //文件操作方法

         .parent                 = &proc_root,    //父对象

};

这个结构记录了procfs根目录的信息, 在后面建立procfs根索引节点时会利用它初始化根inode .

 

下面看看根目录索引节点是如何建立并初始化的:

struct inode *proc_get_inode(struct super_block *sb, unsigned int ino,

                                     struct proc_dir_entry *de)

{

         struct inode * inode;

 

         if (!try_module_get(de->owner))

                   goto out_mod;

 

         inode = iget_locked(sb, ino);  //在索引节点高速缓存中分配一个inode

         if (!inode)

                   goto out_ino;

         if (inode->i_state & I_NEW) {

                   PROC_I(inode)->fd = 0;

                   PROC_I(inode)->pde = de;

                   if (de->proc_iops)

                            inode->i_op = de->proc_iops;  //初始化索引节点操作方法

                   if (de->proc_fops) {

                            if (S_ISREG(inode->i_mode)) {

……….

 

                                               inode->i_fop = &proc_reg_file_ops;  //procfs普通文件的操作方法

                            } else {

                                     inode->i_fop = de->proc_fops;   //非普通文件的操作方法

                            }

                   }

                   unlock_new_inode(inode);

         } else

                module_put(de->owner);

         return inode;

 

out_ino:

         module_put(de->owner);

out_mod:

         return NULL;

}       

函数iget_locked()就是分配一个inode, procfs分配inode是比较特殊的. 先看看在alloc_inode()函数中的这段代码:

if (sb->s_op->alloc_inode)

         inode = sb->s_op->alloc_inode(sb);

else

         inode = (struct inode *) kmem_cache_alloc(inode_cachep, GFP_KERNEL);                   

procfs定义的超级块操作方法为:

static const struct super_operations proc_sops = {

                 .alloc_inode = proc_alloc_inode,

                 .destroy_inode     = proc_destroy_inode,

                 .drop_inode = generic_delete_inode,

                 .delete_inode        = proc_delete_inode,

                 .statfs          = simple_statfs,

                 .remount_fs = proc_remount,

};

在这个结构体中可以看到定义了proc分配inode的方法 ,此函数为proc_alloc_inode()

跟踪一下代码:

static struct inode *proc_alloc_inode(struct super_block *sb)

{

                 struct proc_inode *ei;

                 struct inode *inode;

 

                 ei = (struct proc_inode *)kmem_cache_alloc(proc_inode_cachep, GFP_KERNEL);

                 if (!ei)

                   return NULL;

                 ei->pid = NULL;

                 ei->fd = 0;

                 ei->op.proc_get_link = NULL;

                 ei->pde = NULL;

                 inode = &ei->vfs_inode;

                 inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;

                 return inode;

}

在这个函数中先是在cache中分配一个proc_inode结构体. 然后初始化它,最后返回proc_inode中嵌套的inode.

下面再回到proc_get_inode()函数中,在分配到procfs根目录的inode后就需要初始化这个inode了,

 

回到函数proc_get_inode(),注意函数PROC_I(inode)->pde = de;就是将proc_dir_entry对象与inode关联在一起(inode和proc_dir_entry是一一对应的) ,在建立proc文件后proc_dir_entry对象会在内存中建立起一颗目录树, 因为我们现在建立的是procfs根目录的inode所以这里的proc_dir_entry对象就是这个树的根proc_root .

后面的代码就是利用proc_dir_entry对象初始化我们根目录的inode了,其中就包括最重要的inode操作方法和proc文件操作方法.的初始化.

 

既然根目录索引节点inode已经建好, 下面就是调用函数d_alloc_root() 建立一个名字为”/”的根目录项对象dentry,,这个就是procfs的根了.

好了,这个时候procfs的根已经在内存中建立起来了. 其实在这个时候内存中只有根目录的inode和dentry存在,而其他文件的inode和dentry都是动态建立起来的.  那么下面就要分析如何在procfs中建立一个文件了.

 

三: 在procfs中创建文件

   在procfs中创建一个文件用函数proc_create() 或者用create_proc_read_entry()创建一个只读文件.

这里我们用proc_create()函数来分析在procfs下是如何创建文件的:

 

static inline struct proc_dir_entry *proc_create(const char *name, mode_t mode,

                 struct proc_dir_entry *parent, const struct file_operations *proc_fops)

{

                 return proc_create_data(name, mode, parent, proc_fops, NULL);

}

接着跟踪proc_create_data():

struct proc_dir_entry *proc_create_data(const char *name, mode_t mode,

                                               struct proc_dir_entry *parent,

                                               const struct file_operations *proc_fops,

                                               void *data)

{

                 struct proc_dir_entry *pde;

                 nlink_t nlink;

 

                 if (S_ISDIR(mode)) {

                   if ((mode & S_IALLUGO) == 0)

                            mode |= S_IRUGO | S_IXUGO;  //可读写

                   nlink = 2;

                 } else {

                   if ((mode & S_IFMT) == 0)

                            mode |= S_IFREG;    //普通文件

                   if ((mode & S_IALLUGO) == 0)

                            mode |= S_IRUGO; //可读

                   nlink = 1;

                 }

 

                 pde = __proc_create(&parent, name, mode, nlink); //创建proc_dir_entry对象

                 if (!pde)

                   goto out;

                 pde->proc_fops = proc_fops;  //proc文件操作方法

                 pde->data = data;

                 if (proc_register(parent, pde) < 0)  //注册proc_dir_entry对象

                   goto out_free;

                 return pde;

out_free:

                 kfree(pde);

out:

                 return NULL;

}

继续跟踪proc_dir_entry对象的创建过程.

static struct proc_dir_entry *__proc_create(struct proc_dir_entry **parent,

         const char *name, mode_t mode,  nlink_t nlink)

{

                 struct proc_dir_entry *ent = NULL;

                 const char *fn = name;

                 int len;

                 if (!name || !strlen(name)) goto out;

 

                 if (xlate_proc_name(name, parent, &fn) != 0)  //查找要建立的proc_dir_entry对象是否存在

                   goto out;

 

                 if (strchr(fn, '/'))

                   goto out;

 

                 len = strlen(fn);

 

                 ent = kmalloc(sizeof(struct proc_dir_entry) + len + 1, GFP_KERNEL); //分配proc_dir_entry对象

                 if (!ent) goto out;

 

                 memset(ent, 0, sizeof(struct proc_dir_entry));

                 memcpy(((char *) ent) + sizeof(struct proc_dir_entry), fn, len + 1);

                 ent->name = ((char *) ent) + sizeof(*ent);

                 ent->namelen = len;               //初始化名字长度

                 ent->mode = mode;               //初始化模式

                  ……………

 out:

                 return ent;

}

xlate_proc_name()函数首先判断parent对象是否为空, 如果为空将proc_root指定为默认的parent对象 ,在xlate_proc_name()函数中还需要判断要建立的roc_dir_entry对象是否已经存在.如果存在就会返回错误 . 接下来就是在内存中建立并根据传入的参数初始化proc_dir_entry对象 .

在建立好proc_dir_entry对象后当然需要把这个它注册到内核中, 以便在后面动态建立该文件时根据名字找到这个proc_dir_entry对象.其实注册proc_dir_entry对象就是把它加到以proc_root为根的目录树中.

下面来看一下注册proc_dir_entry对象的代码:

static int proc_register(struct proc_dir_entry * dir, struct proc_dir_entry * dp)

{

         unsigned int i;

         struct proc_dir_entry *tmp;

         

         i = get_inode_number();  //动态分配inode num

         if (i == 0)

                   return -EAGAIN;

         dp->low_ino = i;

 

         if (S_ISDIR(dp->mode)) {      //目录文件

                   if (dp->proc_iops == NULL) {

                            dp->proc_fops = &proc_dir_operations;   //默认的目录文件操作方法

                            dp->proc_iops = &proc_dir_inode_operations;  //默认目录文件的索引节点操作方法

                   }

                   dir->nlink++;

         } else if (S_ISLNK(dp->mode)) {

                   if (dp->proc_iops == NULL)    

                            dp->proc_iops = &proc_link_inode_operations;   //默认符号链接文件操作方法

         } else if (S_ISREG(dp->mode)) {

                   if (dp->proc_fops == NULL)

                            dp->proc_fops = &proc_file_operations;  //默认普通文件的操作方法

                   if (dp->proc_iops == NULL)

                            dp->proc_iops = &proc_file_inode_operations; //默认普通文件索引节点操作方法

         }

 

         spin_lock(&proc_subdir_lock);

 

         for (tmp = dir->subdir; tmp; tmp = tmp->next)  

                   if (strcmp(tmp->name, dp->name) == 0) {     //判断是否已经注册

                            printk(KERN_WARNING "proc_dir_entry '%s' already "

                                               "registered\n", dp->name);

                            dump_stack();

                            break;

                   }

 

         dp->next = dir->subdir;

         dp->parent = dir;

         dir->subdir = dp;

         spin_unlock(&proc_subdir_lock);

 

         return 0;

}

到这里proc_dir_entry对象就已经创建和注册到内核中了. 在内核中会建立一个以proc_root为根的树结构, 一个proc_dir_entry对象就对应一个文件. 在动态建立文件时,会根据文件名查找这棵树,找到对应的proc_dir_entry对象, 将其中的信息初始化给文件索引节点inode.

 

那么procfs是如何动态建立文件的呢 ,在以前的文章中介绍过vfs路径查找的流程 do_path_lookup()->…..-> real_lookup()->dir->i_op->lookup() ; lookup这个回调函数就是在内存中建立文件inode .

在procfs中默认定义的目录文件索引节点操作方法是:

static const struct inode_operations proc_dir_inode_operations = {

         .lookup                = proc_lookup,

         .getattr       = proc_getattr,

         .setattr       = proc_notify_change,

};

看看proc_lookup()中是如何建立inode的：proc_lookup()->proc_lookup_de()->proc_get_inode();

在找到父目录proc_dir_entry对象后, 调用函数proc_lookup_de() 根据目标文件的dentry->d_name查找到对应的proc_dir_entry对象 ,然后调用proc_get_inode()分配inode,并由proc_dir_entry对象初始化inode .此时文件操作方法也是在proc_dir_entry对象中取得.

 

 

四 : procfs文件续写

   还是找个具体例子来看看吧. 在/proc下有个devices文件,就拿它来分析: 我们read这个虚拟的device文件就会打印中注册到内核中的字符和块设备.

首先在procfs初始化的时候,调用proc_create("devices", 0, NULL, &proc_devinfo_operations);在proc顶层目录创建一个device文件. 

在以前已经分析过了VFS读写文件的过程 ,现在就来看看读device的流程, 如果cat /proc/device 函数执行流程为devinfo_open()->seq_read()->devinfo_show()

static int devinfo_show(struct seq_file *f, void *v)

{

         int i = *(loff_t *) v;

 

         if (i < CHRDEV_MAJOR_HASH_SIZE) {

                   if (i == 0)

                            seq_printf(f, "Character devices:\n");

                   chrdev_show(f, i);

         }

#ifdef CONFIG_BLOCK

         else {

                   i -= CHRDEV_MAJOR_HASH_SIZE;

                   if (i == 0)

                            seq_printf(f, "\nBlock devices:\n");

                   blkdev_show(f, i);

         }

#endif

         return 0;

}

chrdev_show()和blkdev_show();就是分别遍历注册在内核中的字符和块设备,返回设备信息.

 

五:小结

   可见procfs是一个伪文件系统,它只存在于内存中,而porcfs下面的文件全部都是虚拟的文件,他们的实际大小都是0 . 其实在分析完procfs文件系统以后再去分析Linux其他伪文件系统就比较简单了,如: tmpfs,ramfs,sysfs…原理都是一样的了哦.