procfs read_func write_func分析及程序

《linux kernel procfs guide》手册： Linux+Kernel+Procfs+Guide.rar   

在《linux kernel procfs guide》手册的 reading data 章节：

read_func 函数

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

ibm网站解析：

page 参数是这些数据写入到的位置，其中 count 定义了可以写入的最大字符数。在返回多页数据（通常一页是 4KB）时，我们需要使用 start 和 off 参数。当所有数据全部写入之后，就需要设置 eof（文件结束参数）。与 write 类似，data 表示的也是私有数据。此处提供的 page 缓冲区在内核空间中。因此，我们可以直接写入，而不用调用 copy_to_user。

The read function should write its information into the page. For proper use, the function should start writing at an offset of off in page and write at most count bytes, but because most read functions are quite simple and only return a small amount of information, these two parameters are usually ignored (it breaks pagers like more and less, but cat still works).

在读函数中，应该把data数据写入到 page中。正确的用法是，函数应该考虑page中的offset偏移量，写入多少count字节。但是，因为在多数函数中仅仅返回很少的一点信息，这两个变量 off 和 count常常被忽视。我们可以使用 more less cat 读我们写入的数据。

If the off and count parameters are properly used, eof should be used to signal that the end of the file has been reached by writing 1 to the memory location eof points to.

假如off和 count变量被使用到，变量eof应该被设置为1，

The parameter start doesn’t seem to be used anywhere in the kernel. The data parameter can be used to create a single call back function for several files。
The read_func function must return the number of bytes written into the page.

参数start似乎并没有在内核中使用到。参数data可以被用来建立一个简单的回调函数

在read_func函数实现中，我们仅仅会使用 data 和 page 这两个参数，其他的较少使用到。

函数没有考虑到off偏移，所以当我们第一次写入“nihao”，再第二次写入“hello”的时候，hello就会完全覆盖“nihao”，所以read_func函数没有考虑到偏移

write_func

int write_func (struct file* file, const char__user* buffer, unsigned long count, void* data);

The write function should read countbytes at maximum from the buffer. Note that the buffer doesn’t live in the kernel’s memory space, so it should first be copied to kernel space with copy_from_user. The file parameter is usually ignored.

写函数，应该从buffer缓存中读取最大的数据量。注意：缓存不存在内核空间内存中，因此，它首先应该通过 copy_from_user从用户空间复制。 而参数file常常被忽视，

将buffer中的数据写入到 data中，count参数定义了在 buff 中有多少数据要被写入

========================================================================

http://www.cnblogs.com/hoys/archive/2011/04/10/2011141.html

附件： proc_exam.rar   将rar修改 为tar.bz2

读者可以通过cat和echo等文件操作函数来查看和设置这些proc文件。特别需要指出，bigprocfile是一个大文件（超过一个内存页），对于这种大文件，procfs有一些限制，因为它提供的缓存，只有一个页，因此必须特别小心，并对超过页的部分做特别的考虑，处理起来比较复杂并且很容易出错，所有procfs并不适合于大数据量的输入输出，后面一节seq_file就是因为这一缺陷而设计的，当然seq_file依赖于 procfs的一些基础功能。

//kernel module: procfs_exam.c
//#include <linux/config.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/proc_fs.h>
#include <linux/sched.h>
#include <linux/types.h>
#include <asm/uaccess.h>

#define STR_MAX_SIZE 255
static int int_var;
static char string_var[256];
static char big_buffer[65536];
static int big_buffer_len = 0;
static struct proc_dir_entry * myprocroot;
static int first_write_flag = 1;

int int_read_proc(char *page, char **start, off_t off, int count, int *eof, void *data)
{
    count = sprintf(page, "%d", *(int *)data); //格式化打印
    return count;
}

int int_write_proc(struct file *file, const char __user *buffer,unsigned long count, void *data)
{
    unsigned int c = 0, len = 0, val, sum = 0;
    int *temp = (int *)data;

    while (count)
    {
        if (get_user(c, buffer)) //§?? 从用户空间读取数据
         return -EFAULT;

        len++;
        buffer++;
        count--;

        if (c == 10 || c == 0) //10 字符 **，0 字符 空
            break;
        val = c - '0';
        if (val > 9)
            return -EINVAL;
        sum *= 10;
        sum += val;
    }
    *temp = sum;
    return len;
}

int string_read_proc(char *page, char **start, off_t off,int count, int *eof, void *data)
{
    count = sprintf(page, "%s", (char *)data);
    return count;
}

int string_write_proc(struct file *file, const char __user *buffer, unsigned long count, void *data)
{
    if (count > STR_MAX_SIZE)
    {
        count = 255;
    }
    copy_from_user(data, buffer, count);
    return count;
}

int bigfile_read_proc(char *page, char **start, off_t off, int count, int *eof, void *data)
{
    if (off > big_buffer_len)
    {
        * eof = 1;
        return 0;
    }

    if (count > PAGE_SIZE)
    {
        count = PAGE_SIZE;
    }

    if (big_buffer_len - off < count)
    {
        count = big_buffer_len - off;
    }

    memcpy(page, data, count);
    *start = page;
    return count;
}

int bigfile_write_proc(struct file *file, const char __user *buffer, unsigned long count, void *data)
{
    char * p = (char *)data;

    if (first_write_flag)
    {
        big_buffer_len = 0;
        first_write_flag = 0;
    }

    if (65536 - big_buffer_len < count)
    {
        count = 65536 - big_buffer_len;
        first_write_flag = 1;
    }

    copy_from_user(p + big_buffer_len, buffer, count);
    big_buffer_len += count;
    return count;
}
static int __init procfs_exam_init(void)
{
    #ifdef CONFIG_PROC_FS
    struct proc_dir_entry * entry;
    myprocroot = proc_mkdir("myproctest", NULL);
    entry = create_proc_entry("aint", 0666, myprocroot);
    if (entry)
    {
        entry->data = &int_var;
        entry->read_proc = &int_read_proc;
        entry->write_proc = &int_write_proc;
    }

    entry = create_proc_entry("astring", 0666, myprocroot);
    if (entry)
    {
        entry->data = &string_var;
        entry->read_proc = &string_read_proc;
        entry->write_proc = &string_write_proc;
    }

    entry = create_proc_entry("bigprocfile", 0666, myprocroot);
    if (entry)
    {
        entry->data = &big_buffer;
        entry->read_proc = &bigfile_read_proc;
        entry->write_proc = &bigfile_write_proc;
    }
    #else
        printk("This module requires the kernel to support procfs,\n");
    #endif

    printk("exam init\n");
    return 0;
}

static void __exit procfs_exam_exit(void)
{
    #ifdef CONFIG_PROC_FS
    remove_proc_entry("aint", myprocroot);
    remove_proc_entry("astring", myprocroot);
    remove_proc_entry("bigprocfile", myprocroot);
    remove_proc_entry("myproctest", NULL);
    printk("exam exit\n");
    #endif
}

module_init(procfs_exam_init);
module_exit(procfs_exam_exit);
MODULE_LICENSE("GPL");

ywx@ywx:~/desktop/module/proc/proc_exam$ sudo insmod ./exam.ko
ywx@ywx:~/desktop/module/proc/proc_exam$ echo 123456 > /proc/myproctest/aint
ywx@ywx:~/desktop/module/proc/proc_exam$ cat /proc/myproctest/aint
123456ywx@ywx:~/desktop/module/proc/proc_exam$ echo "yuweixian" > /proc/myproctest/astring
ywx@ywx:~/desktop/module/proc/proc_exam$ cat /proc/myproctest/astring
yuweixian

注意：这里的程序，echo 会覆盖前一次输入的数据

ywx@ywx:~/desktop/module/proc/proc_exam$ sudo rmmod exam
ywx@ywx:~/desktop/module/proc/proc_exam$ dmesg | tail -5
[12474.351356] exam exit
[12496.784603] exam init
[12524.519173] exam exit
[12534.649329] exam init
[12617.528998] exam exit
ywx@ywx:~/desktop/module/proc/proc_exam$