proc源码解析（三）--proc初始化

来源：互联网发布：淘宝手机端搭配套餐编辑：程序博客网时间：2024/06/06 03:10

在使用proc之前，我们必须首先初始化并挂载proc，并在内核内存中创建数据结构来描述文件系统。但是，不同的体系结构拥有不同的proc内容，所以，在初始化阶段并不完全创建子目录的内容，有些文件要等到系统运行时动态创建。Proc文件系统初始化的流程图如下：

proc_root_init的定义定义如下：

void __init proc_root_init(void)
{
    int err = proc_init_inodecache();
    err = register_filesystem(&proc_fs_type);
    。。。
   proc_mnt = kern_mount_data(&proc_fs_type, &init_pid_ns);
   proc_misc_init();
    proc_net_init();
    。。。
    proc_root_fs = proc_mkdir("fs", NULL);
    proc_root_driver = proc_mkdir("driver", NULL);
    proc_mkdir("fs/nfsd", NULL);
   。。。
    proc_bus = proc_mkdir("bus", NULL);
    proc_sys_init();

｝

int __init proc_init_inodecache(void):为proc_inode创建slab cache，这是proc文件系统的主要部分，通常需要快速创建或销毁。
int register_filesystem(struct file_system_type * fs):注册文件系统类型proc，这个过程是文件系统初始化的关键步骤，下边会专门解释这个步骤。

struct vfsmount *kern_mount_data(struct file_system_type *type, void *data)
{
return vfs_kern_mount(type, MS_KERNMOUNT, type->name, data);
}

vfs_kern_mount:创建与proc_fs_type相关的vfsmount结构,该函数在VFS中已有讲述。
proc_misc_init:创建/proc目录下的文件和子目录，每个文件的创建都由相应的函数来完成，例如：meminfo的创建由 create_proc_read_entry 创建，而meminfo_read_proc则用于初始化meminfo的read_proc函数。其实际的调用过程是：

void __init proc_misc_init(void)
{
    static struct {
    char *name;
    int (*read_proc)(char*,char**,off_t,int,int*,void*);
    } *p, simple_ones[] = {
    {"loadavg", loadavg_read_proc},
    {"uptime", uptime_read_proc},
    {"meminfo", meminfo_read_proc},
    {"version", version_read_proc},
    。。。
    {"filesystems", filesystems_read_proc},
    {"cmdline", cmdline_read_proc},
    {"execdomains", execdomains_read_proc},
    {NULL,}
    };
    for (p = simple_ones; p->name; p++)
       create_proc_read_entry(p->name, 0, NULL, p->read_proc, NULL);

    proc_symlink("mounts", NULL, "self/mounts");
    create_seq_entry("locks", 0, &proc_locks_operations);
    create_seq_entry("devices", 0, &proc_devinfo_operations);
    create_seq_entry("cpuinfo", 0, &proc_cpuinfo_operations);
    。。。
}

另外一些文件是用create_seq_entry来调用创建函数。
create_seq_entry("locks", 0, &proc_locks_operations);
    这两个函数 create_proc_read_entry与create_seq_entry的不同之处是前者创建的是只读文件，后者创建的是可读可写文件。
proc_net_init：创建大量与网络相关的文件，创建方法与前者相似，所以此处不在赘述。
    以上步骤完成之后，初始化需要创建的文件都已完成，下边要调用proc_mkdir来创建子目录。
   实际上，函数最后还调用proc_sys_init();来完成sys子目录的创建。

register_filesystem的实现
在proc_root_init函数中，调用该函数的格式是：

static struct file_system_type proc_fs_type = {

    .name = "proc",
    .get_sb = proc_get_sb,
    .kill_sb = proc_kill_sb,
};

void __init proc_root_init(void)
{
    。。。
    err = register_filesystem(&proc_fs_type);
    if (err)
    return;
    。。。
}

也是就调用register_filesystem函数把描述proc文件类型的结构 proc_fs_type注册到系统中，其中register_filesystem函数函数实现很简单，这里主要关注 proc_get_sb函数。该函数的主要功能是获取proc的super_block。其调用流程图如下：

proc_get_sb中主要的执行函数是proc_fill_super;该函数的主要执行过程如下，为了方便理解，我删去了"多余部分"，只留下程序骨干。

int proc_fill_super(struct super_block *s)
{
    struct inode * root_inode;
    /* 初始化super block的元素*/
    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; //初始化时间精度1ns

    /* 获得root_inode*/
    de_get(&proc_root);
    root_inode = proc_get_inode(s, PROC_ROOT_INO, &proc_root);
    。。。
    /* 二者初始化为0说明proc只能是root用户的*/
    root_inode->i_uid = 0;

root_inode->i_gid = 0;

s->s_root = d_alloc_root(root_inode);
。。。
}

第一个阶段: 初始化super block的元素，唯一值得注意的是s->s_op = &proc_sops;
这是初始化super block的struct super_operations *s_op;其中函数集是：

static const struct super_operations proc_sops = {
    .alloc_inode    = proc_alloc_inode,
    .destroy_inode    = proc_destroy_inode,
    .read_inode    = proc_read_inode,
    .drop_inode    = generic_delete_inode,
    .delete_inode    = proc_delete_inode,
    .statfs        = simple_statfs,
    .remount_fs    = proc_remount,
};

第二个阶段 : proc_get_inode函数用来获得proc的inode，其主要的实现过程如下，为了便于理解我删去了部分代码：

struct inode *proc_get_inode(struct super_block *sb, unsigned int ino,
                struct proc_dir_entry *de)
{
    struct inode * inode;
    inode = iget(sb, ino);
    if (de) {
        /* 使用proc_root的mode初始化，此处的mode和虚拟文件系统的一样 */
        if (de->mode) {
            inode->i_mode = de->mode;
            inode->i_uid = de->uid;
            inode->i_gid = de->gid;
        }
        /* 使用proc_root的各个域初始化inode */
        if (de->size)
            inode->i_size = de->size;
        if (de->nlink)
            inode->i_nlink = de->nlink;
        if (de->proc_iops)
            inode->i_op = de->proc_iops;//proc_root的inode操作函数
        if (de->proc_fops) {
            if (S_ISREG(inode->i_mode)) {
                    inode->i_fop = &proc_reg_file_ops;
            }
            else
               inode->i_fop = de->proc_fops; //proc_root的file操作函数
        }
    }
}

红色部分说明如果是普通文件使用 proc_reg_file_ops 初始化，其定义为：

static const struct file_operations proc_reg_file_ops = {
    .llseek    = proc_reg_llseek,
    .read        = proc_reg_read,
    .write        = proc_reg_write,
    .poll        = proc_reg_poll,
    .unlocked_ioctl    = proc_reg_unlocked_ioctl,
    .mmap        = proc_reg_mmap,
    .open        = proc_reg_open,
    .release    = proc_reg_release,
};

proc_fill_super在调用该函数时(proc_get_inode(s, PROC_ROOT_INO, &proc_root))传入的参数为proc_root,这是一个全局变量，是proc的根目录的dentry，其定义为：

static const struct file_operations proc_root_operations = {
    .read         = generic_read_dir,
    .readdir     = proc_root_readdir,
};
static const struct inode_operations proc_root_inode_operations = {
    .lookup        = proc_root_lookup,
    .getattr    = proc_root_getattr,
};
struct proc_dir_entry proc_root = {
    .low_ino    = PROC_ROOT_INO,
    .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,

};

在 proc_get_inode函数的初始化过程中，大部分的域都是用proc_root中相应的域来初始化，这也正好将proc的dentry和VFS层的dentry和inode对接起来。各个域的操作函数集合此处就不在深入，有需要的朋友可以查阅源码。

第三个阶段: 调用 d_alloc_root创建proc根结点的dentry，该函数比较短，此处引用它的定义：

/**
* d_alloc_root - allocate root dentry
* @root_inode: inode to allocate the root for
* Allocate a root ("/") dentry for the inode given. The inode is
* instantiated and returned. %NULL is returned if there is insufficient
* memory or the inode passed is %NULL.
*/
struct dentry * d_alloc_root(struct inode * root_inode)
{
    struct dentry *res = NULL;

    if (root_inode) {
        static const struct qstr name = { .name = "/", .len = 1 };

        res = d_alloc(NULL, &name);//allocate a dcache entry
        if (res) {
            res->d_sb = root_inode->i_sb;
            res->d_parent = res;
            d_instantiate(res, root_inode);//初始化dentry res
        }
    }
    return res;
}

到此为止proc的初始化过程已经完成，此时，/proc目录下除了要动态创建的文件和子目录外，初始化过程中应该创建的文件和子目录都已创建完毕，接下来就需要挂载proc文件系统到目录树上，这是下一节要讲的内容。