Non Lasting Storage File System、procfs、sysfs

0. 引言
1. proc文件系统
2. 简单的文件系统
3. sysfs

1. proc文件系统(proc filesystem)
它使得内核可以生成与系统的状态和配置有关的信息，该信息可以由用户和系统程序从普通文件读取，而无需专门的工具与内核通信(通过简单的文件操作即可)，在某些情况下，一个简单的cat命令即可完成。数据不仅可以从内核读取，还可以通过向proc文件系统的文件写入字符串，来向内核发送数据，例如echo >> xx
该方法利用了一个虚拟文件系统"即时"产生文件信息，即只有在向proc文件系统发出读操作请求时，才会动态生成信息，对于此类文件系统，不需要专门的硬盘分区或其他块存储设备

2. Sysfs
它与procfs目的类似，默认装载在/sys目录，但并不是强制规定，它设计为从内核向用户层导出非常结构化的信息，与procfs相比，它并不提供用户直接使用，因此信息是层次化、深度嵌套的。此外，文件包含的信息并不总是ASCII文本形式，也有可能使用不可读的二进制串，Sysfs对于想要收集系统中的硬件和设备间拓朴关联方面详细信息的工具而言，是非常有用的
还可以对使用kobject的内核对象创建sysfs项，这使得用户层很容易访问内核中重要的核心数据结构

3. 用于专门目的的小文件系统
可以由内核提供的标准函数构建，在内核内部，libfs库提供了所需功能。此外，内核提供了易于实现顺序文件的方法，在调试文件系统debugfs中同时使用了这两种技术，该文件系统使得内核开发者能够快速地向用户空间导出值、或从用户空间导入值，而无需创建定制的接口或专门的文件系统

1. 可以获得有关内核各子系统的信息，例如
    1) 内存利用率
    2) 附接的外设等)
2. 不重新编译内核源代码的情况下修改内核的行为，或重启系统

1. 内存管理
2. 系统进程的特征数据
3. 文件系统
4. 设备驱动程序
5. 系统总线
6. 电源管理
7. 终端
8. 系统控制参数

1. cmdline: 进程的命令行，一个用"\0"分隔的字符串，包含了程序名和所有参数
2. environ: 表示为该进程设置的所有环境变量，使用了"\0"作为分隔符
3. maps: 列出了进程使用的所有库(和进程本身的二进制文件)的内存映射
4. status: 包含了有关进程状态的一般信息
    1) UID/GID
    2) 内存分配
    3) 进程能力
    4) 各个信号掩码的状态(待决、阻塞等)
5. stat、statm: 以一连串数字的形式，提供了进程及其内存消耗的更多状态信息
6. fd子目录: 包含了一些数字名字的文件，这些文加名表示进程的各个文件描述符，这里的每个文件都是一个符号链接，指向文加名对应的文件描述符在文件系统中的位置
7. cwd: 指向进程当前工作目录，如果用户有适当的权限，则可以使用cd cwd切换到该目录，而无需知道cwd具体指向哪个目录
8. exe: 指向包含了应用程序代码的二进制文件
9. root: 指向进程的根目录，但这并一定是全局的根目录(尤其是在chroot模式下)

1. iomem: 提供了用来和设备通信的内核地址
2. ioports: 提供了用来和设备通信的端口信息
3. buddyinfo: 提供了伙伴系统的当前使用情况
4. slabinfo: 提供了slab分配器的当前使用情况
5. meminfo: 给出了一般性的内存使用情况
    1) 高端内存
    2) 低端内存
    3) 空闲内存
    4) 已分配内存
    5) 共享区域
    6) 交换内存
    7) 回写内存
    ..
7. Vmstat: 给出了内存管理的其他特征信息，包括当前在内存管理的各个子系统中内存页的数目
8. kallsyms: 用于支持内核代码调试，是一个符号表，给出了所有全局内核变量和函数在内核内存中的地址
9. kcore: 用于支持内核代码调试，是一个动态的内核文件，"包含"了运行中的内核的所有数据，即主内存的全部内容，与用户应用程序发生致命错误时进行内存转储所产生的普通内核文件；类似，可以将调试器用于该二进制文件，来查看运行中系统的当前状态
10. interrupts: 保存了当前操作期间引发的中断说明，其中国不仅给出了中断的数目，还对每个中断号，都给出相关设备的名称或负责处理中断的驱动程序
11. loadavg: 给出了过去60s、5分钟、15分钟的平均系统负荷(即运行队列的长度)
12. uptime: 给出了系统的运行时间

1. udp、tcp: 提供了IPv4的UDP、TCP套接字的统计数据
2. udp6、tcp6: IPv6的对应数据
3. unix: UNIX套接字的统计信息
4. arp: 用于反向地址解析的ARP表
5. dev: 保存了通过系统的网络接口传输的数据量的统计数据(包括换回接口)，该信息可用于检查网络的传输质量，因为其中也包括了传输不正确的数据包、被丢弃的数据包和冲突相关的数据

[root@iZ23lobjjltZ ~]# ll /proc/sys
total 0
dr-xr-xr-x 2 root root 0 Jun 12 11:15 abi
dr-xr-xr-x 2 root root 0 Jun 12 11:15 crypto
dr-xr-xr-x 2 root root 0 Jun 12 11:15 debug
dr-xr-xr-x 7 root root 0 Jun 12 11:15 dev
dr-xr-xr-x 6 root root 0 May 22 16:24 fs
dr-xr-xr-x 5 root root 0 Jun 12 11:15 kernel
dr-xr-xr-x 6 root root 0 Jun 12 11:15 net
dr-xr-xr-x 2 root root 0 Jun 12 11:15 vm
//各个子目录中包含了一系列文件，反映了对应的内核子系统的特征数据，这些文件不仅可以读，还可以通过普通的文件操作，向其中写入新值

struct proc_dir_entry 
{
    //inode编号
    unsigned int low_ino;

    //指定了文件名的长度
    unsigned short namelen;
    //指向存储文件名的字符串的指针
    const char *name;

    /*
    mode的语义与普通文件系统相同，因为该成员反映了
    1. 对应数据项的类型
        1) 文件
        2) 目录
        ..
    2. 访问权限的分配
        1) 所有者
        2) 组
        3) 其他
    uid、gid指定了该文件所有和的用户ID、组ID，二者都设置为0，这意味着root用户几乎似乎所有proc文件的所有者
    */
    mode_t mode;

    //proc文件系统中的每个数据项，都对应于一个独立的proc_dir_entry实例，内核借助它来表示文件系统的层次结构

    //nlink指定了目录中子目录和符号链接的数目，
    nlink_t nlink;
    uid_t uid;
    gid_t gid;

    //size成员表示按字节自算的文件长度，由于proc数据项是动态生成的，所以文件的长度通常无法预先知道，在这种情况下，该值为0
    loff_t size;

    //指向inode_operations
    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.
     */
    //指向file_operations，这些操作充当了与虚拟文件系统之间的接口
    const struct file_operations *proc_fops;
    struct proc_dir_entry *next, *parent, *subdir;
    void *data;

    /*
    read_proc、write_proc指向的函数分别支持从/向内核读取/写入数据
    */
    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 */
};

union proc_op 
{
    int (*proc_get_link)(struct inode *, struct path *);
    int (*proc_read)(struct task_struct *task, char *page);
    int (*proc_show)(struct seq_file *m,
        struct pid_namespace *ns, struct pid *pid,
        struct task_struct *task);
};

struct proc_inode 
{
    struct pid *pid;
    int fd;
    union proc_op op;

    //pde指向关联到proc数据项的proc_dir_entry实例
    struct proc_dir_entry *pde;
    struct ctl_table_header *sysctl;
    struct ctl_table *sysctl_entry;

    //inode实例
    struct inode vfs_inode;
};

void __init proc_root_init(void)
{
    int err;

    //使用proc_init_inodecache为proc_inode对象创建一个slab缓存，这些对象是proc文件系统的支柱，通常需要尽快创建和销毁
    proc_init_inodecache();

    //调用register_filesystem，将该文件系统正式的注册到内核
    err = register_filesystem(&proc_fs_type);
    if (err)
        return;

    //kern_mount_data是do_kern_mount的一个包装器函数，它返回一个指向vfsmount实例的指针，该指针保存在全局变量proc_mnt中，供内核在以后使用
    proc_mnt = kern_mount_data(&proc_fs_type, &init_pid_ns);
    err = PTR_ERR(proc_mnt);
    if (IS_ERR(proc_mnt)) 
    {
        unregister_filesystem(&proc_fs_type);
        return;
    }

    proc_symlink("mounts", NULL, "self/mounts");

    //内核调用proc_net_init在/proc/net下建立很多与网络相关的文件
    proc_net_init(); 

    /*
    创建子目录，下述列表的每个名字，都会调用create_proc_read_entry，该函数创建一个proc_dir_entry数据结构新实例
    对应的read_proc成员设置为与各个名称相关联的函数
    */
#ifdef CONFIG_SYSVIPC
    proc_mkdir("sysvipc", NULL);
#endif
    proc_mkdir("fs", NULL);
    proc_mkdir("driver", NULL);
    proc_mkdir("fs/nfsd", NULL); /* somewhere for the nfsd filesystem to be mounted */
#if defined(CONFIG_SUN_OPENPROMFS) || defined(CONFIG_SUN_OPENPROMFS_MODULE)
    /* just give it a mountpoint */
    proc_mkdir("openprom", NULL);
#endif
    proc_tty_init();
#ifdef CONFIG_PROC_DEVICETREE
    proc_device_tree_init();
#endif
    proc_mkdir("bus", NULL);
    proc_sys_init();
}

mount -t proc /proc

1. 在内核添加新文件系统时，会扫描一个链表，查找与该文件系统相关的file_system_type实例，该实例提供了如何读取对应文件系统超级块的一些信息，对于proc文件系统，该结构初始化如下
/*
static struct file_system_type proc_fs_type = 
{
    .name        = "proc",
    .get_sb        = proc_get_sb,
    .kill_sb    = proc_kill_sb,
};
*/

2. 将特定于文件系统的超级块数据填充到一个vfsmount结构的实例中，使得新的文件系统能够集成到VFS树中

int proc_fill_super(struct super_block *s)
{
    struct inode * root_inode;

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

    //块长度不能设置，总是1024
    s->s_blocksize = 1024;
    //2^10 = 1024
    s->s_blocksize_bits = 10;
    /*
    借助预处理器，用于识别proc文件系统的魔数定义为0x9fa0
    对proc文件系统来说，该数字实际上不需要，因为其数据并不保存在存储介质上，而是动态生成的
    */
    s->s_magic = PROC_SUPER_MAGIC;
    /*
    proc_sops中保存了对超级块的各个操作，其中收集了内核管理proc文件所需的各个函数
    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,
    };
    */
    s->s_op = &proc_sops;
    s->s_time_gran = 1;

    //为proc的根目录创建一个inode
    de_get(&proc_root);
    /*
    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,
    }; 
    */
    root_inode = proc_get_inode(s, PROC_ROOT_INO, &proc_root);
    if (!root_inode)
        goto out_no_root;
    root_inode->i_uid = 0;
    root_inode->i_gid = 0;
    //使用d_alloc_root将其转换为一个dentry，加入到超级块中，用作文件系统中查找操作的起点
    s->s_root = d_alloc_root(root_inode);
    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;
}

/*
 * The root /proc directory is special, as it has the
 * <pid> directories. Thus we don‘t use the generic
 * directory handling functions for that..
 */
static const struct file_operations proc_root_operations = {
    .read         = generic_read_dir,
    .readdir     = proc_root_readdir,
};

/*
 * proc root can do almost nothing..
 */
static const struct inode_operations proc_root_inode_operations = {
    .lookup        = proc_root_lookup,
    .getattr    = proc_root_getattr,
};

1. 创建proc_dir_entry的一个新实例，填充描述该数据项的所有需要的信息
2. 将该实例注册到proc的数据结构，使得外部能够看到该数据项
//因为这两个步骤从来不会独立执行，因此内核提供了辅助函数create_proc_entry用于合并这两个操作

/*
1. name: 指定了文件名
2. mode: 按传统的UNIX方案(用户/组/其他)指定了访问权限
3. parent: 一个指针，指向该文件父目录的proc_dir_entry实例
*/
extern struct proc_dir_entry *create_proc_entry(const char *name, mode_t mode, truct proc_dir_entry *parent);

struct proc_dir_entry *entry = NULL;
entry = create_proc_entry("hyperCard", S_IREG | S_IRUGO | S_IWUSR, %proc_net);

if(!entry)
{
    printk(KERN_ERR "unable to cteate /proc/net/hyperCard\n");
    return -EIO;
}
else
{
    entry->read_proc = hypercard_proc_read;
    entry->write_proc = hypercard_proc_write;
}

1. 生成一个唯一的proc内部编号，向数据项赋予身份，get_inode_number返回一个未使用的编号，用于为动态生成的数据项
2. 必须适当地设置proc_dir_entry实例的next、parent成员。将新数据项集成到proc文件系统的层次结构中
3. 如果此前proc_dir_entry的成员proc_iops、proc_fops为NULL指针，那么需要根据文件类型，适当地设置指向file_operations和inode_operatoins结构实例的指针，否则使用原值即可

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();
    if (i == 0)
        return -EAGAIN;
    dp->low_ino = i;

    //proc目录使用的结构如下
    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++;
    } 
    //对符号链接只需要inode_operations，不需要file_operations
    else if (S_ISLNK(dp->mode)) 
    {
        if (dp->proc_iops == NULL)
            dp->proc_iops = &proc_link_inode_operations;
    } 
    //对于普通文件，内核使用proc_file_operations、proc_file_inode_operations来定义文件和inode‘的操作方法’
    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) {
            WARN(1, KERN_WARNING "proc_dir_entry ‘%s/%s‘ already registered\n",
                dir->name, dp->name);
            break;
        }

    dp->next = dir->subdir;
    dp->parent = dir;
    dir->subdir = dp;
    spin_unlock(&proc_subdir_lock);

    return 0;
}

1. 数据项可能是某个特定于进程的目录中的文件，例如: /proc/1/maps
2. 数据项也可能是驱动程序、子系统动态注册的文件，例如: /proc/cpuinfo
//内核需要区分这两种文件

static const struct file_operations proc_file_operations = 
{
    .llseek        = proc_file_lseek,
    .read        = proc_file_read,
    .write        = proc_file_write,
};

1. 分配一个内核内存页面，产生的数据将填充到页面中
2. 调用一个特定于文件的函数，向内核内存页面填充数据
//第二步是最重要的，必须为此准备好子系统的数据和内核中的数据结构
3. 数据丛内核空间复制到用户空间

static ssize_t proc_file_read(struct file *file, char __user *buf, size_t nbytes, loff_t *ppos)
{
    struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
    ssize_t rv = -EIO;

    spin_lock(&pde->pde_unload_lock);
    if (!pde->proc_fops) 
    {
        spin_unlock(&pde->pde_unload_lock);
        return rv;
    }
    pde->pde_users++;
    spin_unlock(&pde->pde_unload_lock);

    rv = __proc_file_read(file, buf, nbytes, ppos);

    pde_users_dec(pde);
    return rv;
}

static ssize_t proc_file_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos)
{
    //PDE函数用于从VFS inode使用container_of机制获取所需的proc_dir_entry实例
    struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
    ssize_t rv = -EIO;

    if (pde->write_proc) 
    {
        spin_lock(&pde->pde_unload_lock);
        if (!pde->proc_fops) 
        {
            spin_unlock(&pde->pde_unload_lock);
            return rv;
        }
        pde->pde_users++;
        spin_unlock(&pde->pde_unload_lock);

        /* FIXME: does this routine need ppos?  probably... */
        /*
        proc_write的实现通常会执行下列操作
        1. 必须检查用户输入的长度，确保不超出所分配区域的长度
        2. 数据从用户空间复制到分配的内核空间区域
        3. 从字符串中提取出信息，该操作称之为解析(parsing)
        4. 根据收到的用户信息，对该子系统进行操作
        */
        rv = pde->write_proc(file, buffer, count, pde->data);
        pde_users_dec(pde);
    }
    return rv;
}

struct dentry *proc_pid_lookup(struct inode *dir, struct dentry * dentry, struct nameidata *nd)
{
    struct dentry *result = ERR_PTR(-ENOENT);
    struct task_struct *task;
    unsigned tgid;
    struct pid_namespace *ns;

    result = proc_base_lookup(dir, dentry);
    if (!IS_ERR(result) || PTR_ERR(result) != -ENOENT)
        goto out;

    //因为文件名总是字符串形式的，而PID是整数，内核必须使用name_to_int辅助函数进行相应的转换，将由数字组成的字符串转换为整数
    tgid = name_to_int(dentry);
    if (tgid == ~0U)
        goto out;

    ns = dentry->d_sb->s_fs_info;
    rcu_read_lock();
    //根据pid获取对应进程的task_struct
    task = find_task_by_pid_ns(tgid, ns);
    if (task)
        get_task_struct(task);
    rcu_read_unlock();
    if (!task)
        goto out;

    /*
    在找到目标进程的task_struct之后，内核将剩余的大部分工作委托给fs/proc/base.c中实现的proc_pid_instantiate函数，该函数又依赖于proc_pid_make_inode
    1. 首先，通过VFS的标准函数new_inode创建一个新的ionde
    2. 这在本质上会归结到特定于proc文件系统的proc_alloc_inode例程，该例程利用自身的slab缓存创建了一个proc_inode结构实例
    3. 在调用proc_pid_make_indoe之后，proc_pid_instantiate中剩余的代码只需要执行几项管理任务，其中最重要的是将inode操作inode->i_op设置为指向proc_tgid_base_inode_operations
    */
    result = proc_pid_instantiate(dir, dentry, task, NULL);
    put_task_struct(task);
out:
    return result;
}

1. CTL_DEV: 外设有关信息
    1) DEV_PARPORT
    2) DEV_CDROM: 提供有关系统中的光驱的信息
        2.1) DEV_CDROM_INFO: 提供了有关驱动器能力的一般信息
        2.2) DEV_CDROM_AUTOCLOSE
        2.3) DEV_CDROM_CHECK_MEDIA
2. CTL_NET
    1) NET_CORE
        1.1) NET_CORE_FASTROUTE
        1.2) NET_CORE_DEVWEIGHT
    2) NET_IPV4
        2.1) NET_IPV4_TVP_FIN_TIMEOUT
        2.2) NET_IPV4_AUTOCONFIG
2. CTL_KERN: 内核本身有关信息
    1) KERN_OSTYPE
    2) KERN_OSRELEASE
    3) KERN_SYSRQ
3. CTL_VM: 内存管理信息和参数
    1) VM_PAGEBUF
    2) VM_SWAPPINESS

__BEGIN_DECLS

/* 
1. __name: 通过整数数组的形式给出具体的路径，每个数组元素表示一个路径分量
2. __nlen: 啮合并不指定路径有多少个分量，因此必须显示指明
3. __oldval: 一个指针，指向一个类型不确定的内存区，用于返回sysctl的原值
4. __oldlenp: 指定所分配的内存区以字节为单位的长度，在系统调用执行完毕后，输出数据的长度由__oldlenp指定
5. __newval
6. __newlen: __newval、__newlen形成了一对指针和长度的组合，在sysctl允许修改内核参数时，可以使用这两个参数
*/
extern int sysctl (int *__name, int __nlen, void *__oldval, size_t *__oldlenp, void *__newval, size_t __newlen) __THROW;

__END_DECLS

struct ctl_table 
{
    /* 
    Binary ID 二进制ID
    在该sysctl项所在的层次上必须是唯一的，但不不必在整个sysctl表中是唯一的，这和文件系统的概念是一样的
    */
    int ctl_name;            

    /* 
    Text ID for /proc/sys, or zero 
    /proc/sys下各目录项的文本ID，或NULL
    所有根数据项(即对应于几个基本类别的sysctl)的名称，都表现为/proc/sys下的目录名
    dr-xr-xr-x 2 root root 0 Jun 14 19:43 abi
    dr-xr-xr-x 2 root root 0 Jun 14 19:43 crypto
    dr-xr-xr-x 2 root root 0 Jun 14 19:43 debug
    dr-xr-xr-x 7 root root 0 Jun 14 19:43 dev
    dr-xr-xr-x 6 root root 0 May 22 16:24 fs
    dr-xr-xr-x 5 root root 0 Jun 14 19:43 kernel
    dr-xr-xr-x 6 root root 0 Jun 14 19:43 net
    dr-xr-xr-x 2 root root 0 Jun 14 19:43 vm
    */
    const char *procname;    

    //data可以指定任何值，通常是一个函数指针或字符串，字符串由特定于sysctl的函数处理，通用代码都不会访问该成员
    void *data;

    //maxlen指定了一个sysctl能够接收或输出的数据的最大长度(字节)
    int maxlen;

    //mode控制了对数据的访问权限，即磁盘ACL权限
    mode_t mode;

    /*
    child是一个指针，指向一个数组，各个数组项都是ctl_table实例，这些诶ctl_table实例是当前数据项的子节点，例如
    1. 在CTL_KERN sysctl项中，child指向一个数组，包含的sysctl项是KERN_OSTYPE、KERN_OSRELEASE、KERN_HOSTNAME
    2. 因为这些项在层次上属于CTL_KERN_ sysctl的下一级

    因为ctl_table数组的长度没有显示存储，因而数据的最后一项必须总是NULL指针，标志数组的结束
    */
    struct ctl_table *child;

    /* Automatically set 自动设置 */
    struct ctl_table *parent;    

    /* Callback for text formatting 用于格式化文本的回调函数 */
    proc_handler *proc_handler;    

    /* Callback function for all r/w 用于所有读/写操作的回调函数 */
    ctl_handler *strategy;        
    void *extra1;
    void *extra2;
};

struct ctl_table_header
{
    struct ctl_table *ctl_table;
    struct list_head ctl_entry;
    int used;
    int count;
    struct completion *unregistering;
    struct ctl_table *ctl_table_arg;
    struct ctl_table_root *root;
    struct ctl_table_set *set;
    struct ctl_table *attached_by;
    struct ctl_table *attached_to;
    struct ctl_table_header *parent;
};

static struct ctl_table root_table[];
static struct ctl_table_root sysctl_table_root;
static struct ctl_table_header root_table_header = 
{
    .count = 1,
    .ctl_table = root_table,
    .ctl_entry = LIST_HEAD_INIT(sysctl_table_root.default_set.list),
    .root = &sysctl_table_root,
    .set = &sysctl_table_root.default_set,
};
static struct ctl_table_root sysctl_table_root = 
{
    .root_list = LIST_HEAD_INIT(sysctl_table_root.root_list),
    .default_set.list = LIST_HEAD_INIT(root_table_header.ctl_entry),
};

static struct ctl_table root_table[] = {
    {
        .ctl_name    = CTL_KERN,
        .procname    = "kernel",
        .mode        = 0555,
        .child        = kern_table,
    },
    {
        .ctl_name    = CTL_VM,
        .procname    = "vm",
        .mode        = 0555,
        .child        = vm_table,
    },
    {
        .ctl_name    = CTL_FS,
        .procname    = "fs",
        .mode        = 0555,
        .child        = fs_table,
    },
    {
        .ctl_name    = CTL_DEBUG,
        .procname    = "debug",
        .mode        = 0555,
        .child        = debug_table,
    },
    {
        .ctl_name    = CTL_DEV,
        .procname    = "dev",
        .mode        = 0555,
        .child        = dev_table,
    },
/*
 * NOTE: do not add new entries to this table unless you have read
 * Documentation/sysctl/ctl_unnumbered.txt
 */
    { .ctl_name = 0 }
};

int __init proc_sys_init(void)
{
    struct proc_dir_entry *proc_sys_root;

    proc_sys_root = proc_mkdir("sys", NULL);
    proc_sys_root->proc_iops = &proc_sys_dir_operations;
    proc_sys_root->proc_fops = &proc_sys_dir_file_operations;
    proc_sys_root->nlink = 0;
    return 0;
}

1. do_proc_sys_lookup: 查找与/proc/sys中文件关联的sysctl表项
2. 不能保证目标sysctl项的所有权限都已经授权，即使root用于也是如此，有些项可能只允许读，而不允许修改，因而需要一个额外的权限检查，由sysctl_perm执行，而proc_sys_read需要读权限，proc_sys_write需要写权限
3. 调用sysctl表项中存储的proc处理程序来完成操作

static const struct seq_operations kprobes_seq_ops = 
{
    .start = kprobe_seq_start,
    .next  = kprobe_seq_next,
    .stop  = kprobe_seq_stop,
    .show  = show_kprobe_addr
};

static int __kprobes kprobes_open(struct inode *inode, struct file *filp)
{
    return seq_open(filp, &kprobes_seq_ops);
}

static const struct file_operations debugfs_kprobes_operations = 
{
    //唯一需要实现的方法是open，需要将文件关联到顺序文件接口
    .open           = kprobes_open,
    .read           = seq_read,
    .llseek         = seq_lseek,
    .release        = seq_release,
};

struct seq_file 
{
    //buf指向一个内存缓冲区，用于构建传输给用户层的数据
    char *buf;

    //size给出了缓冲区中总的字节数
    size_t size;

    //复制操作的起始位置由from指定
    size_t from;

    //count指定了需要传输到用户层的剩余的字节数
    size_t count;

    //index是缓冲区的另一个索引，它标记了内核向缓冲区写入下一个新记录的起始位置
    loff_t index;
    loff_t read_pos;
    u64 version;
    struct mutex lock;

    /*
    指向seq_operations的一个实例，这将通用的顺序文件实现与提供具体文件内容的例程关联起来
    内核需要4个方法，这需要由文件提供者实现
    struct seq_operations 
    {
        void * (*start) (struct seq_file *m, loff_t *pos);
        void (*stop) (struct seq_file *m, void *v);
        void * (*next) (struct seq_file *m, void *v, loff_t *pos);
        int (*show) (struct seq_file *m, void *v);
    };
    */
    const struct seq_operations *op;
    void *private;
};

//检查当前游标是否超出数组边界
static void __kprobes *kprobe_seq_start(struct seq_file *f, loff_t *pos)
{
    return (*pos < KPROBE_TABLE_SIZE) ? pos : NULL;
}

//将游标移动到下一个位置，并检查索引是否越界
static void __kprobes *kprobe_seq_next(struct seq_file *f, void *v, loff_t *pos)
{
    (*pos)++;
    if (*pos >= KPROBE_TABLE_SIZE)
        return NULL;
    return pos;
}

static void __kprobes kprobe_seq_stop(struct seq_file *f, void *v)
{
    /* Nothing to do */
}

1. 为建立关联，必须像debugfs_kprobes_operations那样，将seq_read赋值给file_operations的read方法，该方法将VFS和顺序文件连接起来
2. 该函数(seq_read)需要从VFS层的struct file获得seq_file实例，seq_open通过private_data建立了该关联
3. 如果有些数据等待写出(如果struct seq_file的count成员为正值)，则使用copy_to_user将其复制到用户层，此外，还需要更新seq_file的各个状态成员
4. 下一步，会产生新的数据，在调用start之后，内核连续调用show、next，直至填满可用的缓冲区，最后调用stop，使用copy_to_user将生成的数据复制到用户空间

const struct file_operations simple_dir_operations =
{
    .open        = dcache_dir_open,
    .release    = dcache_dir_close,
    .llseek        = dcache_dir_lseek,
    .read        = generic_read_dir,
    .readdir    = dcache_readdir,
    .fsync        = simple_sync_file,
};

const struct inode_operations simple_dir_inode_operations = {
    .lookup        = simple_lookup,
};

static const struct super_operations simple_super_operations = {
    .statfs        = simple_statfs,
};

static struct inode *debugfs_get_inode(struct super_block *sb, int mode, dev_t dev, void *data, const struct file_operations *fops)
{
    //分配一个新的struct inode实例
    struct inode *inode = new_inode(sb);

    if (inode) 
    {
        inode->i_mode = mode;
        inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
        //根据访问权限信息判断将什么文件操作和inode操作关联到该文件
        switch (mode & S_IFMT) 
        {
        default:
            //对于设备文件，使用标准例程init_special_inode(不予libfs关联)
            init_special_inode(inode, mode, dev);
            break;
        case S_IFREG:
            /*
            普通文件不能使用libfs的file_operations模版，至少需要手工指定read、write、open方法，这是必须的
            1. read: 负责从内核内存准备数据并复制到用户空间
            2. write: 用于读取用户的输出并以一定的方法应用它
            这就是实现定义的文件系统所需的全部工作
            */
            inode->i_fop = fops ? fops : &debugfs_file_operations;
            inode->i_private = data;
            break;
        case S_IFLNK:
            inode->i_op = &debugfs_link_operations;
            inode->i_fop = fops;
            inode->i_private = data;
            break;
        case S_IFDIR:
            //目录需要的是libfs提供的标准文件操作和inode操作，这确保了不需要其他工作就可以正确地处理新目录
            inode->i_op = &simple_dir_inode_operations;
            inode->i_fop = fops ? fops : &simple_dir_operations;
            inode->i_private = data;

            /* directory inodes start off with i_nlink == 2
             * (for "." entry) */
            inc_nlink(inode);
            break;
        }
    }
    return inode; 
}

static int __kprobes debugfs_kprobe_init(void)
{
    struct dentry *dir, *file;
    unsigned int value = 1;

    //debugfs_create_dir用于创建一个新目录
    dir = debugfs_create_dir("kprobes", NULL);
    if (!dir)
        return -ENOMEM;

    //debugfs_create_file用于在目录中创建一个新文件
    file = debugfs_create_file("list", 0444, dir, NULL,
                &debugfs_kprobes_operations);
    if (!file) {
        debugfs_remove(dir);
        return -ENOMEM;
    }

    file = debugfs_create_file("enabled", 0600, dir,
                    &value, &fops_kp);
    if (!file) {
        debugfs_remove(dir);
        return -ENOMEM;
    }

    return 0;
}

//普通文件
struct dentry *debugfs_create_file(const char *name, mode_t mode, struct dentry *parent, void *data, const struct file_operations *fops);

//目录
struct dentry *debugfs_create_dir(const char *name, struct dentry *parent);

//符号链接
struct dentry *debugfs_create_symlink(const char *name, struct dentry *parent, const char *dest);

//删除
void debugfs_remove(struct dentry *dentry);
void debugfs_remove_recursive(struct dentry *dentry);

//重命名
struct dentry *debugfs_rename(struct dentry *old_dir, struct dentry *old_dentry, struct dentry *new_dir, const char *new_name);

static int bd_get_sb(struct file_system_type *fs_type, int flags, const char *dev_name, void *data, struct vfsmount *mnt)
{
    //get_sb_pseudo方法可以确保不能从用户空间装载该文件系统，这需要设置MS_NOUSER标志，还填充了一个struct super_block实例，并分配了伪文件系统根目录的inode
    return get_sb_pseudo(fs_type, "bdev:", &bdev_sops, 0x62646576, mnt);
}

static struct file_system_type bd_type = 
{
    .name        = "bdev",
    .get_sb        = bd_get_sb,
    .kill_sb    = kill_anon_super,
};

1. kobject包含在一个层次化的组织中，最重要的一点是，它们可以有一个父对象，可以包含到一个kset中，这决定了kobject出现在sysfs层次结构中的位置
    1) 如果存在父对象，那么需要在父对象对应的目录中新建一项
    2) 否则，将其防止到kobject所在kset所属的kobject对应的目录中
2. 每个kobject在sysfs中都表示为一个目录，出现在该目录中的文件是对象的属性，用户导出和设置属性的操作由对象所属的子系统提供
3. 总线、设备、驱动程序和类是使用kobject机制的主要内核对象，因而也占据了sysfs中几乎所有的数据项

struct sysfs_dirent 
{
    atomic_t        s_count;
    atomic_t        s_active;
    struct sysfs_dirent    *s_parent;

    //s_sibling用于捕获数据结构中各sysfs数据项之间的父子关系
    struct sysfs_dirent    *s_sibling;

    //s_name表示文件、目录、符号链接的名称
    const char        *s_name;

    union {
        struct sysfs_elem_dir        s_dir;
        struct sysfs_elem_symlink    s_symlink;
        struct sysfs_elem_attr        s_attr;
        struct sysfs_elem_bin_attr    s_bin_attr;
    };

    /*
    内核使用s_flags有两方面的目的
    1. 用来设置sysfs数据项的类型
    2. 设置若干标志
        1) 低8位用作类型: 可以用辅助函数sysfs_type访问
            1.1) SYSFS_DIR: 目录
            1.2) SYSFS_KOBJ_ATTR: 普通属性
            1.3) SYS_KOBJ_BIN_ATTR: 二进制属性
            1.4) SYS_KOBJ_LINK: 符号链接
        2) 剩余比特用作标志位: 
            2.1) SYSFS_FLAG_REMOVED: 正在删除某个sysfs数据项
    */
    unsigned int        s_flags;
    ino_t            s_ino;

    //与sysfs_dirent实例相关的目录项的访问权限信息保存在s_mode中
    umode_t            s_mode;
    struct sysfs_inode_attrs *s_iattr;
};