Linux内核PROC文件系统的初始化和主要函数分析

                                Linux内核PROC文件系统的初始化和主要函数分析

                                             written by aweii

一、概述(内核版本2.4.0)

系统启动初始化阶段，调用init_proc_fs进行proc文件系统的注册。内核初始化完成后，可由初始化用户进程(如init进程之类)调用mount -t proc /dev/null /proc 进行挂接。

二、结构

(1)虚拟目录结构

struct proc_dir_entry {

    unsigned short low_ino;

    unsigned short namelen;

    const char *name;

    mode_t mode;

    nlink_t nlink;

    uid_t uid;

    gid_t gid;

    unsigned long size;

    struct inode_operations * proc_iops;

    struct file_operations * proc_fops;

    get_info_t *get_info;

    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 deleted;        /* delete flag */

    kdev_t    rdev;

};

inode->generic_ip指向proc_dir_entry，proc_lookup()通过proc_dir_entry的subdir链表搜寻其子节点的proc_dir_entry。

(2)

三、主要代码分析

(1)文件系统初始化

-------------init_proc_fs

static DECLARE_FSTYPE(proc_fs_type, "proc", proc_read_super, FS_SINGLE);

static int __init init_proc_fs(void)

{

    int err = register_filesystem(&proc_fs_type); //注册文件系统proc_fs_type，成员函数read_super指向proc_read_super

    if (!err) {

        proc_mnt = kern_mount(&proc_fs_type);//创建vfs_mount结构，挂接在proc_fs_type下，同时生成的元素包括超级块super_block和根节点root_inode

        err = PTR_ERR(proc_mnt);

        if (IS_ERR(proc_mnt))

            unregister_filesystem(&proc_fs_type);

        else

            err = 0;

    }

    return err;

}

(2)/proc/下的主要子节点初始化

--------------proc_misc_init

void __init proc_misc_init(void)

{

    struct proc_dir_entry *entry;

    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},

        {"cpuinfo",    cpuinfo_read_proc},

#ifdef CONFIG_PROC_HARDWARE

        {"hardware",    hardware_read_proc},

#endif

#ifdef CONFIG_STRAM_PROC

        {"stram",    stram_read_proc},

#endif

#ifdef CONFIG_DEBUG_MALLOC

        {"malloc",    malloc_read_proc},

#endif

#ifdef CONFIG_MODULES

        {"modules",    modules_read_proc},

        {"ksyms",    ksyms_read_proc},

#endif

        {"stat",    kstat_read_proc},

        {"devices",    devices_read_proc},

        {"partitions",    partitions_read_proc},

#if !defined(CONFIG_ARCH_S390)

        {"interrupts",    interrupts_read_proc},

#endif

        {"filesystems",    filesystems_read_proc},

        {"dma",        dma_read_proc},

        {"ioports",    ioports_read_proc},

        {"cmdline",    cmdline_read_proc},

#ifdef CONFIG_SGI_DS1286

        {"rtc",        ds1286_read_proc},

#endif

        {"locks",    locks_read_proc},

        {"mounts",    mounts_read_proc},

        {"swaps",    swaps_read_proc},

        {"iomem",    memory_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);

    /* And now for trickier ones */

    entry = create_proc_entry("kmsg", S_IRUSR, &proc_root);

    if (entry)

        entry->proc_fops = &proc_kmsg_operations;

    proc_root_kcore = create_proc_entry("kcore", S_IRUSR, NULL);

    if (proc_root_kcore) {

        proc_root_kcore->proc_fops = &proc_kcore_operations;

        proc_root_kcore->size =

                (size_t)high_memory - PAGE_OFFSET + PAGE_SIZE;

    }

    if (prof_shift) {

        entry = create_proc_entry("profile", S_IWUSR | S_IRUGO, NULL);

        if (entry) {

            entry->proc_fops = &proc_profile_operations;

            entry->size = (1+prof_len) * sizeof(unsigned int);

        }

    }

#ifdef __powerpc__

    {

        extern struct file_operations ppc_htab_operations;

        entry = create_proc_entry("ppc_htab", S_IRUGO|S_IWUSR, NULL);

        if (entry)

            entry->proc_fops = &ppc_htab_operations;

    }

#endif

    entry = create_proc_read_entry("slabinfo", S_IWUSR | S_IRUGO, NULL,

                       slabinfo_read_proc, NULL);

    if (entry)

        entry->write_proc = slabinfo_write_proc;

}

(3)创建只读子节点的函数，能同时设置read_proc

-------------------------create_proc_read_entry

extern inline struct proc_dir_entry *create_proc_read_entry(const char *name,

    mode_t mode, struct proc_dir_entry *base,

    read_proc_t *read_proc, void * data)

{

    struct proc_dir_entry *res=create_proc_entry(name,mode,base); //创建名为name的proc_dir_entry,其父节点为base

    if (res) {

        res->read_proc=read_proc; //设置read_proc方法

        res->data=data;

    }

    return res;

}

(4)创建子节点的函数

-------------------------create_proc_entry

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

                     struct proc_dir_entry *parent)

{

    struct proc_dir_entry *ent = NULL;

    const char *fn = name;

    int len;

    if (!parent && xlate_proc_name(name, &parent, &fn) != 0)

        goto out;

    len = strlen(fn);

    ent = kmalloc(sizeof(struct proc_dir_entry) + len + 1, GFP_KERNEL); //分配proc_dir_entry,其后紧跟name+"\0"，所以空间大小为sizeof(struct proc_dir_entry) + strlen(name) + 1

    if (!ent)

        goto out;

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

    memcpy(((char *) ent) + sizeof(*ent), fn, len + 1);//拷贝name到proc_dir_entry后

    ent->name = ((char *) ent) + sizeof(*ent); //name指向它

    ent->namelen = len;

        

    //目录节点设置方法

    if (S_ISDIR(mode)) {

        if ((mode & S_IALLUGO) == 0)

        mode |= S_IRUGO | S_IXUGO;

        ent->proc_fops = &proc_dir_operations;

        ent->proc_iops = &proc_dir_inode_operations;

        ent->nlink = 2;

    } else {

        if ((mode & S_IFMT) == 0)

            mode |= S_IFREG;

        if ((mode & S_IALLUGO) == 0)

            mode |= S_IRUGO;

        ent->nlink = 1;

    }

    ent->mode = mode;

    proc_register(parent, ent); //级联到父节点

    

out:

    return ent;

}

(5)目录搜索函数

根据级联关系进行循环搜索，和目录中搜索文件一样，都要比对名称

-------------------------proc_lookup

struct dentry *proc_lookup(struct inode * dir, struct dentry *dentry)

{

    struct inode *inode;

    struct proc_dir_entry * de;

    int error;

    error = -ENOENT;

    inode = NULL;

    de = (struct proc_dir_entry *) dir->u.generic_ip;

    if (de) {

        for (de = de->subdir; de ; de = de->next) {

            if (!de || !de->low_ino)

                continue;

            if (de->namelen != dentry->d_name.len)

                continue;

            if (!memcmp(dentry->d_name.name, de->name, de->namelen)) {

                int ino = de->low_ino;

                error = -EINVAL;

                inode = proc_get_inode(dir->i_sb, ino, de);

                break;

            }

        }

    }

    if (inode) {

        dentry->d_op = &proc_dentry_operations;

        d_add(dentry, inode);

        return NULL;

    }

    return ERR_PTR(error);

}

(6)文件通用读函数，它调用proc_dir_entry的get_info或read_proc成员函数

注意proc_file_read和具体的read_proc的搭配使用方法，ppos和其他普通文件读函数相同，

但要注意ppos、start值的交互变化。

proc_file_read循环调用read_proc，read_proc每次最多只读PROC_BLOCK_SIZE(4K页的3/4,3KB)，

保证每次读入量都能容纳进page页面中。根据ppos内容在page中的偏移，调节start指针

-----------------------------proc_file_read

static struct file_operations proc_file_operations = {

    llseek:        proc_file_lseek,

    read:        proc_file_read,

    write:        proc_file_write,

};

#define PROC_BLOCK_SIZE    (PAGE_SIZE - 1024)

static ssize_t

proc_file_read(struct file * file, char * buf, size_t nbytes, loff_t *ppos)

{

    struct inode * inode = file->f_dentry->d_inode;

    char     *page;

    ssize_t    retval=0;

    int    eof=0;

    ssize_t    n, count;

    char    *start;

    struct proc_dir_entry * dp;

    dp = (struct proc_dir_entry *) inode->u.generic_ip;

    if (!(page = (char*) __get_free_page(GFP_KERNEL)))

        return -ENOMEM;

    while ((nbytes > 0) && !eof)

    {

        count = MIN(PROC_BLOCK_SIZE, nbytes);

        start = NULL;

        if (dp->get_info) {

            /*

             * Handle backwards compatibility with the old net

             * routines.

             */

            n = dp->get_info(page, &start, *ppos, count);

            if (n < count)

                eof = 1;

        } else if (dp->read_proc) {

            n = dp->read_proc(page, &start, *ppos,

                      count, &eof, dp->data);

        } else

            break;

        if (!start) {

            /*

             * For proc files that are less than 4k

             */

            start = page + *ppos;

            n -= *ppos;

            if (n <= 0)

                break;

            if (n > count)

                n = count;

        }

        if (n == 0)

            break;    /* End of file */

        if (n < 0) {

            if (retval == 0)

                retval = n;

            break;

        }

        

        /* This is a hack to allow mangling of file pos independent

          * of actual bytes read.  Simply place the data at page,

          * return the bytes, and set `start' to the desired offset

          * as an unsigned int. - Paul.Russell@rustcorp.com.au

         */

         n -= copy_to_user(buf, start < page ? page : start, n);

        if (n == 0) {

            if (retval == 0)

                retval = -EFAULT;

            break;

        }

        *ppos += start < page ? (long)start : n; /* Move down the file */

        nbytes -= n;

        buf += n;

        retval += n;

    }

    free_page((unsigned long) page);

    return retval;

}

(7)read_proc成员函数实例，读内核符号表

-------------------------read_proc举例

//见proc_misc_init()中的{"ksyms",    ksyms_read_proc},

static int ksyms_read_proc(char *page, char **start, off_t off,

                 int count, int *eof, void *data)

{

    int len = get_ksyms_list(page, start, off, count);

    if (len < count) *eof = 1;

    return len;

}

/*

begin始终指向buf处的内容在文件中的偏移，而

if (pos < offset) {

                len = 0;

                begin = pos;

            }

不断调节begin的位置使offset最终落到buf缓冲页(也就是上级函数传递过来的page)中

因此buf + (offset - begin)就得到offset对应的缓存页中的位置。

因为start可能>buf，为预防offset - begin + length 超出缓冲页，所以buf中只用了3/4空间限额，后边作预留。

由(6)知，每次调用read_proc时length最大值设置为PROC_BLOCK_SIZE(即3KB),此时，若当offset - begin>0,那么本段读入数据的末尾是超出3KB的,

但是不会超出4KB(begin的不断调节作用)。

*/

/*

 * Called by the /proc file system to return a current list of ksyms.

 */

int

get_ksyms_list(char *buf, char **start, off_t offset, int length)

{

    struct module *mod;

    char *p = buf;

    int len     = 0;    /* code from  net/ipv4/proc.c */

    off_t pos   = 0;

    off_t begin = 0;

    for (mod = module_list; mod; mod = mod->next) {

        unsigned i;

        struct module_symbol *sym;

        if (!MOD_CAN_QUERY(mod))

            continue;

        for (i = mod->nsyms, sym = mod->syms; i > 0; --i, ++sym) {

            p = buf + len;

            if (*mod->name) {

                len += sprintf(p, "%0*lx %s\t[%s]\n",

                           (int)(2*sizeof(void*)),

                           sym->value, sym->name,

                           mod->name);

            } else {

                len += sprintf(p, "%0*lx %s\n",

                           (int)(2*sizeof(void*)),

                           sym->value, sym->name);

            }

            pos = begin + len;

            if (pos < offset) {

                len = 0;

                begin = pos;

            }

            pos = begin + len;

            if (pos > offset+length)

                goto leave_the_loop;

        }

    }

leave_the_loop:

    *start = buf + (offset - begin);

    len -= (offset - begin);

    if (len > length)

        len = length;

    return len;

}