五。内核代码调试方法——proc文件系统、seqfile文件系统

如有错误大家一定告诉我，一起学习了；

############## proc 文件系统 ##################
1、    mount -t proc none /proc
    ps ---> /proc/(每个结构体（每个进程）在这创建一个目录。以pid名字命名，进程的状态，关系等属性都是内核写在相应的目录下)
    内核：找的是proc文件系统，我们只是通过上面的命令挂载到/proc下，找的不是proc目录，但是用户态的ps命令只会在proc目录下找，所以习惯放在proc目录
        
    task_struct（每个进程都对应这么一个结构体） ---> task_struct的list（链表） --->

    创建一个新的进程内核会自动分配一个这样的结构体（task_struct）,再分配一个pid，然后把父进程的页表拷贝过来，所以父子进程共享前半段，当子进程进行不同的操作时会重新写页表    

    这些创建都是在磁盘上创建，proc文件系统上的文件在硬盘是不存在的，是存在于内存的；所以/proc里的文件只有内核代码能够创建，我们需要写模块来执行这些操作
    不能这么创建，在/proc 下进行下列操作是错误的    
    mkdir /proc/test                X（错）
    touch /proc/test/hello             X（错）

2、功能：
    1>.调试：
        a.printk
        b.创建/proc/test/hello   打印到这个文件中。代替printk
    2>.给内核传数据：
        echo abc > /proc/test/hello
        hello文件不能容纳数据，只是一个标识，是内核接口；abc的内容是传到内核的。

3、proc文件系统的头文件，包含各种函数的实现
    <linux>/include/linux/proc_fs.h
        struct proc_dir_entry{         //proc目录每个文件都对应这么一个结构体
            void *data;        
            //这个值是写驱动的人提前写好的，内核不会操作这个值；在调用函数时会把这个值传给读写函数，无用就是NULL
            //这是一个指针
            read_proc_t *read_proc;        //proc下文件的读函数指针
            write_proc_t *write_proc;    //proc下文件的写函数指针
            loff_t size;／／偏移
            const struct inode_operations *proc_iops;／／该文件的一组操作
            ... //还包含其它的很多
        }；
        当执行 cat /proc/test/hello 时，调用的就是read_proc
        当执行 echo abc > /proc/test/hello 时，调用的就是write_proc


        create_proc_entry    创建一个proc文件
        remove_proc_entry    删除一个proc文件
        proc_mkdir        创建一个目录
        proc_symlink    创建一个符号链接
        create_proc_read_entry    创建一个只读的proc文件
        proc_create_data    创建seqfile文件，proc存在问题，seqfile是用来解决proc函数一次只能读一页（4K）数据的问题；seqfile文件系统是自动检测分配内存的，不够时会自动给添加一页

4、为什么在写内核模块函数的时候加上 static？
答：内核模块函数默认是 static 的，但是内核默认是 extern，加上 static 就是 静态的；
    又因为最后内核模块的函数最后都会被写到内核中，为了以后方便，也是一个习惯，就都加上

5、参考代码 <path>/02proc/*

6、在内核环境中，一定要注意出错处理，出错要将之前占用的全部资源释放

######################################    
# 错误码的出处：
# include/asm-generic/errno.h
# include/asm-generic/errno-base.h
######################################

7、proc文件系统读函数
    //先打开一个文件 fd = open("/proc/test_dir/test_att", xx（权限）)
    //用户态读 read(fd, buf, len)
    //内核分配一页内存（4K）（page）
    //len ---> count  读取长度
    //*eof = 1；代表文件读取结束
    //读取的时候，将读到的东西放到page内存中，结束时内核会自动将page内的东西放到buf（用户态传进来的）中
    //读取大小受page大小限制，最大读4K；seqfile文件系统解决这个问题

    int (read_proc_t)(char *page, char **start, off_t off, int count, int *eof, void *data)

8、proc文件系统写函数
    //ret = write(fd, buf, len)
    //struct file *file ---> 就是用户态的 FILE *，fopen 打开的文件流；封装后在用户态无法看到这个结构体
    //__user   代表是用户态分配的缓存；[4G - 1, 3G]内核缓存，[3G - 1,0]用户态缓存；两种缓存的使用方式是不一样
    //buf ---> buffer
    //len ---> count
    //data --->  初始化时的100，随便传的， 写内核的人自己定义的

    int (write_proc_t)(struct file *file, const char __user *buffer, unsigned long count, void *data)
    
9、proc文件系统中从用户态拷贝
    #include <asm/uaccess.h>    //包含在这个头文件

    //用户态 buffer ---> 内核buf
    //user ---> kernel
    //使用 memcpy（）从内核把东西拷贝到用户态，不是一定出错，是可能出错，内核不容许隐患
        因为拷贝内核的东西时会有权限问题，造成拷贝的数据不完全
    //内核提供的宏定义
    //  min(count, 1024)    //1024 是定义的 buf 的大小
    //  max(count, 1024)
    //copy_from_user  是内核实现的函数

    copy_from_user(buf, buffer, count)

############### seqfile 文件系统 ##############
1、对 proc 文件的操作只有简单的读写；对 seqfile 文件有一个操作集 ops，是一个结构体：
    struct file_operations ops = {
        .owner = THIS_MODULE,
        .open = test_seq_open,        //open，用户态，自己实现
        .release = seq_release,        //close    ，用户态，内核实现
        .llseek = seq_lseek,        //lseek，用户态，内核实现
        .read = seq_read,            //read，用户态，内核实现
        .write = test_seq_write,    //write，用户态，自己实现
    };
    ================================================
    = 此结构体包含在头文件 <path>/include/linux/fs.h
    = 这组操作于用户态的 I/O 操作对应
    ================================================
    ==========================================================================
    = test_seq_open 自己实现的原因：因为类型不匹配，需要把 seq_open 函数封装一下
    = test_seq_write 自己实现原因：因为需要我们自己决定要以什么样的方式写
    =================================================================

2、seqfile 文件系统打开函数
    int test_seq_open(struct inode *no, struct file *fp)
    {
        return seq_open(fp, &seq_ops);
    }
    
    //open--->vfs-inode file->sys_open-->test_seq_open
        调用用户态的open函数，经过VFS（虚拟文件系统），进入系统调用的函数，再到test_seq_open
    struct inode *nu 是在执行时内核创建的，
    //seq_open 函数的 seq_ops 结构体是让 seq_read 用的

3、seq_read 函数操作：
    struct seq_operations seq_ops = {
        .start = seq_start,
        .stop = seq_stop,
        .next = seq_next,
        .show = seq_show,
    };
    //seq_read 函数的执行过程
    //read-->vfs-->sys_read-->seq_read-->start-show-next-show-next-show-......-stop

4.seq_read 的过程函数
    void *seq_start(struct seq_file *m, loff_t *pos)
    {
        //返回第*pos个结点的指针
    }

    void seq_stop(struct seq_file *m, void *v)
    {
        //seq_start的反操作
    }
    //如果该函数返回一个NULL,则seq_read结束
    void *seq_next(struct seq_file *m, void *v, loff_t *pos)
    {
        //++*pos
        //返回第*pos个结点的指针
    }
    //v是seq_start和seq_next的返回值
    int seq_show(struct seq_file *m, void *v)
    {
        struct item_st *tmp = v;
            //ret += sprintf(page + ret, .....);
        //sprintf(m->buf, "No:%d     Len:%d  Content:%s", tmp->no, tmp->len, tmp->content);
        //在seq_read结束之后，内核会用copy_to_user(buffer, m->buf, xxxxxx)
        return seq_printf(m, "No:%d    Len:%d    Content:%s", tmp->no, tmp->len, tmp->content);
    }

5、简述 seqfile 过程：
    创建seq_file
    创建的时候绑定了一组操作ops（open，close，read，write，...）
    这组操作用于：用户态--->VFS---->sys_open系列函数--->test_seq_open-->seq_open-->...
    write里也要实现链表(自己选择的数据存储方式)，把数据存住（临时）
    read：start － show － next － show － next － show － stop
    每一个 seq_file 都对应自己的结构体，必须在 seq_open 之前把函数保存进去，然后在read的时候才能找到这些函数
    next返回个NULL，sig_read就结束了