linux3.10 proc文件系统实现原理

3.1创建目录/文件

proc_create用于创建proc文件；proc_mkdir用于创建proc目录。接口__proc_create用于完成目录/文件创建的主要工作。

3.2目录创建

void __init proc_root_init(void)
{
	……
    proc_mkdir("fs", NULL);
   	……
}
 
struct proc_dir_entry *proc_mkdir_data(const char *name, umode_t mode,
        struct proc_dir_entry *parent, void *data)
{
    struct proc_dir_entry *ent;
 
    if (mode == 0)
        mode = S_IRUGO | S_IXUGO;
    
   // 目录或者文件都是由结构体proc_dir_entry 来描述，S_IFDIR表示创建的是目录
    ent = __proc_create(&parent, name, S_IFDIR | mode, 2); 
    if (ent) {
        ent->data = data;
        ent->proc_fops = &proc_dir_operations; // file_operations打开的时候会赋给inode
        ent->proc_iops = &proc_dir_inode_operations; // inode_operations打开的时候会赋给inode
        parent->nlink++;
//建立层次关系，proc_dir_entry->parent指向父目录，proc_dir_entry->subdir_node插入到parent->subdir中
        if (proc_register(parent, ent) < 0) { 
            kfree(ent);
            parent->nlink--;
            ent = NULL;
        }
    }
    return ent;
}

对于目录来说proc_dir_operations都是空实现

static const struct file_operations proc_dir_operations = {
    .llseek         = generic_file_llseek,
    .read           = generic_read_dir,
    .iterate_shared     = proc_readdir,
};

proc_dir_inode_operations会在open的时候赋给inode，后续会重点讲解函数proc_lookup

static const struct inode_operations proc_dir_inode_operations = {
    .lookup     = proc_lookup,
    .getattr    = proc_getattr,
    .setattr    = proc_notify_change,
};

3.3文件创建

如果在/proc目录下创建一个proc文件，具体应该怎么做，先申明一个file_operations，结构，然后注册：

static const struct file_operations version_proc_fops = {
    .open       = version_proc_open,
    .read       = seq_read,
    .llseek     = seq_lseek, 
    .release    = single_release, 
};                         
 
static int __init proc_version_init(void)
{
    proc_create("version", 0, NULL, &version_proc_fops);
    return 0;
}

上面函数最终会调用到proc_create_data，传递下来的参数&version_proc_fops对应到下面的proc_fops

struct proc_dir_entry *proc_create_data(const char *name, umode_t mode,
                    struct proc_dir_entry *parent,
                    const struct file_operations *proc_fops,
                    void *data)
{
    struct proc_dir_entry *pde;
    if ((mode & S_IFMT) == 0)
        mode |= S_IFREG; //表示创建的是普通文件，
        
	……
    pde = __proc_create(&parent, name, mode, 1); //分配文件对应的proc_dir_entry并初始化，这边
//需要注意，传入的parent参数，如果传进去的parent为null，则会寻找根节点，把parent置为根节点
    if (!pde)   
        goto out;
    pde->proc_fops = proc_fops; //也就是version_proc_fops，文件打开的时候会赋给inode
    pde->data = data; 
    pde->proc_iops = &proc_file_inode_operations; //对于普通文件来说很多接口都没有实现
    if (proc_register(parent, pde) < 0) //建立文件在proc中的层次关系
        goto out_free;
    return pde;
	……

static int proc_register(struct proc_dir_entry * dir, struct proc_dir_entry * dp)
{
	struct proc_dir_entry *tmp;
	int ret;
	
	ret = proc_alloc_inum(&dp->low_ino);
	if (ret)
		return ret;

	if (S_ISDIR(dp->mode)) {
		dp->proc_fops = &proc_dir_operations;
		dp->proc_iops = &proc_dir_inode_operations;
		dir->nlink++;
	} else if (S_ISLNK(dp->mode)) {
		dp->proc_iops = &proc_link_inode_operations;
	} else if (S_ISREG(dp->mode)) {
		BUG_ON(dp->proc_fops == NULL);
		dp->proc_iops = &proc_file_inode_operations;
	} else {
		WARN_ON(1);
		return -EINVAL;
	}

	spin_lock(&proc_subdir_lock);

	for (tmp = dir->subdir; tmp; tmp = tmp->next)
		if (strcmp(tmp->name, dp->name) == 0) {
			WARN(1, "proc_dir_entry '%s/%s' already registered\n",
				dir->name, dp->name);
			break;
		}

	dp->next = dir->subdir;
	dp->parent = dir;
	dir->subdir = dp;//和父目录的proc_dir_entry关联起来
	spin_unlock(&proc_subdir_lock);

	return 0;
}

从上面的源码分析也可以看到，创建proc文件或者目录的时候，只创建了该节点的proc_dir_entry结构，并把该结构和上层目录相关联，dentry和inode只有在打开该文件的时候才会被创建。

4 proc读写原理

以上面新建的/proc/version文件为例，看一下具体是怎么读写该文件的。

proc文件夹一般来说，都存在于上级文件系统化中，但是proc文件系统挂载在该文件夹下面，所以在open version文件，往下搜索的时候，先搜索proc节点，最终会找到proc文件系统根节点‘/’的dentry和inode结构，这两个结构在上面一节文件系统挂载的时候可以看到，已经被创建。接着就再往下搜索，为version文件创建dentry和inode节点。具体的函数调用流程看下图：

4.1文件打开

文件搜索的源码分析，在之前的sysfs文件系统博文中已经讲过，这边不再分析了，主要分析几个重点函数。继续之前的例子，当搜索到version文件时，需要为其建立inode和dentry，上层目录就是proc文件系统的根目录。所以我们调用根目录的inode的lookup方法，上面文件系统挂载的时候可以看到inode->i_op = de->proc_iops;de是定义的静态的proc_root;对应的是proc_root_inode_operations操作集函数，具体lookup函数为proc_root_lookup：

proc_root_lookup

     -------------->proc_lookup

            --------------->proc_lookup_de

struct dentry *proc_lookup_de(struct proc_dir_entry *de, struct inode *dir,
		struct dentry *dentry)
{
	struct inode *inode;

	spin_lock(&proc_subdir_lock);
	for (de = de->subdir; de ; de = de->next) { //找父proc_dir_entry对应的子proc_dir_entry,主要根据文件名来比对
		if (de->namelen != dentry->d_name.len)
			continue;
		if (!memcmp(dentry->d_name.name, de->name, de->namelen)) {
			pde_get(de);
			spin_unlock(&proc_subdir_lock);
			inode = proc_get_inode(dir->i_sb, de);//找到子proc_dir_entry，为其分配inode结构，关联proc_inode和proc_dir_entry
			if (!inode)
				return ERR_PTR(-ENOMEM);
			d_set_d_op(dentry, &proc_dentry_operations);//为当前节点的dentry设置dentry_operations函数
			d_add(dentry, inode);//dentry->d_inode = inode;把dentry和indoe关联起来。
			return NULL;
		}
	}
	spin_unlock(&proc_subdir_lock);
	return ERR_PTR(-ENOENT);
}

 经过上面的函数，dentry，inode，proc_inode都有了，再看do_dentry_open后面的流程。

文件的file->f_op来源于inode->i_fop，而i_fop在之前初始化为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,
#ifdef CONFIG_COMPAT
	.compat_ioctl	= proc_reg_compat_ioctl,
#endif
	.mmap		= proc_reg_mmap,
	.open		= proc_reg_open,
	.release	= proc_reg_release,
};

proc_reg_open会调用到proc_dir_entry->proc_fops->open，proc_dir_entry就是version文件注册的proc结构，前面注册的时候已经看到，其proc_fops就是前面的version_proc_fops ：

static int version_proc_open(struct inode *inode, struct file *file)
{
    return single_open(file, version_proc_show, NULL);
}
 
int single_open(struct file *file, int (*show)(struct seq_file *, void *),
        void *data)
{
    struct seq_operations *op = kmalloc(sizeof(*op), GFP_KERNEL);
    int res = -ENOMEM;
    
    if (op) {   
        op->start = single_start;
        op->next = single_next;
        op->stop = single_stop;
        op->show = show;  //也就是前面提到的version_proc_show
        res = seq_open(file, op);
		……
    return res;
}
 
int seq_open(struct file *file, const struct seq_operations *op)
{       
    struct seq_file *p;    
    p = kzalloc(sizeof(*p), GFP_KERNEL);
 
    file->private_data = p;  //与vfs中的file连接
        
    p->op = op; //设置顺序文件系统的seq_operations
    p->file = file;
    
    file->f_version = 0;
 
    file->f_mode &= ~FMODE_PWRITE;
    return 0;
}

4.2文件读取

 函数proc_reg_read是vfs read进入proc的入口。

static ssize_t proc_reg_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
{   
    ssize_t (*read)(struct file *, char __user *, size_t, loff_t *);
    struct proc_dir_entry *pde = PDE(file_inode(file));
    ssize_t rv = -EIO;
    if (use_pde(pde)) {
        read = pde->proc_fops->read;  //调用version文件注册的proc读函数
        if (read)
            rv = read(file, buf, count, ppos);
        unuse_pde(pde);
    }
    return rv;
}

pde->proc_fops->read函数就是seq_read函数：

ssize_t seq_read(struct file *file, char __user *buf, size_t size, loff_t *ppos)
{
    struct seq_file *m = file->private_data;
    size_t copied = 0;
    loff_t pos;
    size_t n;
    void *p;
    int err = 0;
 
    if (!m->buf) {//因为这是一个通用函数，它并不知道会读取多少数据所以这里暂且分配一页数据
        m->buf = seq_buf_alloc(m->size = PAGE_SIZE);
        if (!m->buf)
            goto Enomem;
    }
    /* if not empty - flush it first */
    if (m->count) {//如果buffer中有数据先将数据拷贝到用户空间
        n = min(m->count, size);
        err = copy_to_user(buf, m->buf + m->from, n);
        if (err)
            goto Efault;
        m->count -= n;
        m->from += n;
        size -= n;
        buf += n;
        copied += n;
        if (!m->count) {
            m->from = 0;
            m->index++;
        }
        if (!size)
            goto Done;
}
    /* we need at least one record in buffer */
    pos = m->index;
    p = m->op->start(m, &pos);
    while (1) {//测试先前分配的buffer够不够容纳将要读取的数据，如果不够就释放重新分配更大内存
        err = PTR_ERR(p);
        if (!p || IS_ERR(p))
            break;
        err = m->op->show(m, p); //尝试将数据拷贝到buffer中
        if (err < 0)
            break;
        if (unlikely(err))
            m->count = 0;
        if (unlikely(!m->count)) {
            p = m->op->next(m, p, &pos);
            m->index = pos;
            continue;
        }
        if (m->count < m->size) //如果m->count 等于 m->size就说明buffer满了，buffer不够用
            goto Fill;
        m->op->stop(m, p);
        kvfree(m->buf);//释放掉之前不够用的buffer
        m->count = 0;
        m->buf = seq_buf_alloc(m->size <<= 1);//分配更大内存
        if (!m->buf)
            goto Enomem;
        m->version = 0;
        pos = m->index;
        p = m->op->start(m, &pos);
    }
    m->op->stop(m, p);
    m->count = 0;
    goto Done;
Fill:
    /* they want more? let's try to get some more */
    while (m->count < size) {
        size_t offs = m->count;
        loff_t next = pos;
        p = m->op->next(m, p, &next);
        if (!p || IS_ERR(p)) {
            err = PTR_ERR(p);
            break;
        }
        err = m->op->show(m, p);//将剩余的数据拷贝到buffer
        if (seq_has_overflowed(m) || err) {
            m->count = offs;
            if (likely(err <= 0))
                break;
        }
        pos = next;
    }
    m->op->stop(m, p);
    n = min(m->count, size);
    err = copy_to_user(buf, m->buf, n);//将buffer中的数据拷贝到用户空间内存
    if (err)
        goto Efault;
    copied += n;
    m->count -= n;
    if (m->count)
        m->from = n;
    else
        pos++;
    m->index = pos;
Done:
    if (!copied)
        copied = err;
    else {
        *ppos += copied;
        m->read_pos += copied;
    }
    file->f_version = m->version;
    mutex_unlock(&m->lock);
    return copied;
}