使用cat读取和echo写内核文件节点的一些问题

最新推荐文章于 2024-03-24 09:25:48 发布
最新推荐文章于 2024-03-24 09:25:48 发布
阅读量2.1k 收藏 6
点赞数 1
分类专栏： Linux驱动

平台：

busybox-1.24.2
Linux-4.10.17
Qemu+vexpress-ca9

概述：

在写驱动的时候，我们经常会向用户空间导出一些文件，然后用户空间使用cat命令去读取该节点，从而完成kernel跟user的通信。但是有时会发现，如果节点对应的read回调函数写的有问题的话，使用cat命令后，节点对应的read函数会被频繁调用，log直接刷屏，而我们只希望read被调用一次，echo也是一样的道理。背后的原因是什么呢？如何解决呢？下面我们以debugfs下的节点读写为例说明一下。

正文：
一、read和write的介绍：
1、系统调用read

ssize_t read(int fd, void *buf, size_t count);

这个函数会从fd表示的文件描述符中读取count个字节到buf缓冲区当中，返回值有下面几种：
如果返回值大于0，表示实际读到的字节数，返回0的话，表示读到了文件结尾，同时文件的file position也会被更新。实际读到的字节数可能会比count小。如果返回-1，表示读取失败，errno会被设置为相应的值。

2、系统调用write

ssize_t write(int fd, const void *buf, size_t count);

这个函数将以buf为首地址的缓冲区当中的count个字节写到文件描述符fd表示的文件当中，返回值：返回正整数，表示实际写入的字节数，返回0表示没有任何东西被写入，同时文件位置指针也会被更新返回-1，表示写失败，同时errno会被设置为相应的值。

3、LDD3上对驱动中实现的read回调函数的解释

原型：ssize_t (*read) (struct file *fp, char __user *user_buf, size_t count, loff_t *ppos);

fp：被打开的节点的文件描述符；
user_buf：表示的是用户空间的一段缓冲区的首地址，从kernel读取的数据需要存放该缓冲区当中
count：表示用户期望读取的字节数；
*ppos：表示当前当前文件位置指针的大小，这个值会需要驱动程序自己来更新，初始大小是0。
如果返回值等于传递给read系统调用的count参数，则说明所请求的字节数传输成功完成。这是最理想的情况。
如果返回值是正的，但是比count小，则说明只有部分数据传输成功。这种情况下因设备的不同可能有许多原因。大部分情况下，程序会再次读数据。例如，如果用fread函数读数据，这个库函数就会不断调用系统调用，直至所请求的数据传输完毕为止。
如果返回值为0，则表示已经达到了文件尾。
负值意味着发生了错误，该值指明了发生了什么错误，错误码在<linux/errno.h>中定义。比如这样的一些错误：-EINTR(系统调用被中断)或者-EFAULT(无效地址)。
4、LDD3上对驱动中实现的write回调函数的解释

原型：ssize_t (*write) (struct file *fp, const char __user *user_buf, size_t count, loff_t *ppos);

fp：被打开的要写的内核节点的文件描述符；
user_buf：表示的是用户空间的一段缓冲区的首地址，其中存放的是用户需要传递给kernel的数据；
count：用户期望写给kernel的字节数；
*ppos：文件位置指针，需要驱动程序自己更新。
如果返回值等于count，则完成了所请求数目的字节传输。
如果返回值为正的，但小于count，则这传输了部分数据。程序很可能再次试图写入余下的数据。
如果返回值为0，意味着什么也没有写入。这个结果不是错误，而且也没有理由返回一个错误码。再次重申，标准库会重复调用write。
负值意味着发生了错误，与read相同，有效的错误码定义在<linux/errno.h>中。
上面加粗的红色字体引起驱动中的write或者read被反复调用的原因。

二、简略的分析一下read和write系统调用的实现
在用户空间调用read函数后，内核函数vfs_read会被调用：

ssize_t vfs_read(struct file *file, char __user *buf, size_t count, loff_t *pos)
{
    ssize_t ret;

    if (!(file->f_mode & FMODE_READ))
        return -EBADF;
    if (!(file->f_mode & FMODE_CAN_READ))
        return -EINVAL;
    if (unlikely(!access_ok(VERIFY_WRITE, buf, count)))
        return -EFAULT;

    ret = rw_verify_area(READ, file, pos, count);
    if (!ret) {
        if (count > MAX_RW_COUNT)
            count =  MAX_RW_COUNT;
        ret = __vfs_read(file, buf, count, pos);
        if (ret > 0) {
            fsnotify_access(file);
            add_rchar(current, ret);
        }
        inc_syscr(current);
    }
    return ret;
}

下面是需要关注的：
第9行检查用户空间的buf缓冲区是否可以写入。
第14行检查count的大小，这里MAX_RW_COUNT被设置为1个页的大小，这里的值是4KB，也就是一次用户一次read最多获得4KB数据。
第16行调用__vfs_read，这个函数最终会调用到我们的驱动中的read函数，可以看到这个函数的参数跟驱动中的read函数一样，驱动中read返回的数字ret会返回给用户，这里并没有看到更新pos，所以需要在我们的驱动中自己去更新。
用户空间调用write函数后，内核函数vfs_write会被调用：

ssize_t vfs_write(struct file *file, const char __user *buf, size_t count, loff_t *pos)
{
    ssize_t ret;

    if (!(file->f_mode & FMODE_WRITE))
        return -EBADF;
    if (!(file->f_mode & FMODE_CAN_WRITE))
        return -EINVAL;
    if (unlikely(!access_ok(VERIFY_READ, buf, count)))
        return -EFAULT;

    ret = rw_verify_area(WRITE, file, pos, count);
    if (!ret) {
        if (count > MAX_RW_COUNT)
            count =  MAX_RW_COUNT;
        file_start_write(file);
        ret = __vfs_write(file, buf, count, pos);
        if (ret > 0) {
            fsnotify_modify(file);
            add_wchar(current, ret);
        }
        inc_syscw(current);
        file_end_write(file);
    }

    return ret;
}

这里需要关注:
第9行，检查用户空间的缓冲区buf是否可以读。
第15行，限制一次写入的数据最多为1页，比如4KB。
第17行的_vfs_write的参数跟驱动中的write的参数一样，__vfs_write的返回值ret也就是用户调用write时的返回值，表示实际写入的字节数，这里也没有看到更新pos的代码，所以需要我们自己在驱动的write中实现。

三、简略分析cat和echo的实现
由于使用的根文件系统使用busybox做的，所以cat和echo的实现在busybox的源码中，如下：

coreutils/cat.c
coreutils/echo.c

CAT：
下面简略分析cat的实现，cat的默认实现采用了sendfile，采用sendfile可以减少不必要的内存拷贝，从而提高读写效率，这就是所谓的Linux的“零拷贝”。为了便于代码分析，可以关闭这个功能，然后cat就会调用read和write实现了：

Busybox Settings  --->
    General Configuration  --->
        [ ] Use sendfile system call

下面是cat的核心函数：
以cat xxx为例其中src_fd就是被打开的内核节点的文件描述符，dst_fd就是标准输出描述符，size是0。

static off_t bb_full_fd_action(int src_fd, int dst_fd, off_t size)
{
    int status = -1;
    off_t total = 0;
    bool continue_on_write_error = 0;
    ssize_t sendfile_sz;
    char buffer[4 * 1024];   // 用户空间缓冲区，4KB大小
    enum { buffer_size = sizeof(buffer) };  // 每次read期望获得的字节数

    sendfile_sz = 0;
    if (!size) {
        size =  (16 * 1024 *1024); // 刚开始，如传入的size是0，这里将size设置为16MB
        status = 1; /* 表示一直读到文件结尾，也就是直到read返回0 */
    }

    while (1) {
        ssize_t rd;
        
        rd = safe_read(src_fd, buffer, buffer_size);  // 这里调用的就是read, 读取4KB，rd是实际读到的字节数
        if (rd < 0) {
            bb_perror_msg(bb_msg_read_error);
            break;
        }
 read_ok:
        if (!rd) { /* 表示读到了文件结尾，那么结束循环 */
            status = 0;
            break;
        }
        /* 将读到的内容输出到dst_fd表示的文件描述符 */
        if (dst_fd >= 0 && !sendfile_sz) {
            ssize_t wr = full_write(dst_fd, buffer, rd);
            if (wr < rd) {
                if (!continue_on_write_error) {
                    bb_perror_msg(bb_msg_write_error);
                    break;
                }
                dst_fd = -1;
            }
        }
        
        total += rd;  // total记录的是读到的字节数的累计值
        if (status < 0) { /* 如果传入的size不为0，那么status为-1，直到读到size个字节后，才会退出。如果size为0，这个条件不会满足 */
            size -= rd;
            if (!size) {
                /* 'size' bytes copied - all done */
                status = 0;
                break;
            }
        }
    }
 out:
    return status ? -1 : total;  // 当读完毕，status为0，这里返回累计读到的字节数
}

从上面的分析我们知道如下信息：
使用cat xxx时，上面的函数传入的size为0，那么上面的while循环会一直进行read，直到出错或者read返回0，read返回0也就是读到文件结尾。最后如果出错，那么返回-1，否则的话，返回读到的累计的字节数。
到这里，应该就是知道为什么驱动中的read会被频繁调用了吧，也就是驱动中的read的返回值有问题。

ECHO：
echo的核心函数是full_write；
这里fd是要写的内核节点，buf缓冲区中存放的是要写入的内容，len是buf缓冲区中存放的字节数。

ssize_t FAST_FUNC full_write(int fd, const void *buf, size_t len)
{
    ssize_t cc;
    ssize_t total;

    total = 0;

    while (len) {
        cc = safe_write(fd, buf, len);

        if (cc < 0) {
            if (total) {
                /* we already wrote some! */
                /* user can do another write to know the error code */
                return total;
            }
            return cc;  /* write() returns -1 on failure. */
        }

        total += cc;
        buf = ((const char *)buf) + cc;
        len -= cc;
    }

    return total;
}

上面的函数很简单，可以得到如下信息：
如果write的函数返回值cc小于len的话，会一直调用write，直到报错或者len个字节全部写完。而这里的cc对应的就是我们的驱动中write的返回值。最后，返回实际写入的字节数或者一个错误码。
到这里，应该也已经清除为什么调用一次echo后，驱动的write为什么会被频繁调用了吧，还是驱动中write的返回值的问题。

知道的上面的原因，下面我们结合一个简单的驱动看看。

四、实例分析
1、先看两个刷屏的例子
这个驱动在/sys/kernel/debug生成一个demo节点，支持读和写。

#include <linux/init.h>
#include <linux/module.h>
#include <linux/debugfs.h>
#include <linux/fs.h>
#include <asm/uaccess.h>

static struct dentry *demo_dir;

static ssize_t demo_read(struct file *fp, char __user *user_buf, size_t count, loff_t *ppos)
{
    char kbuf[10];
    int ret, wrinten;

    printk(KERN_INFO "user_buf: %p, count: %d, ppos: %lld\n",
        user_buf, count, *ppos);

    wrinten = snprintf(kbuf, 10, "%s", "Hello");

    ret = copy_to_user(user_buf, kbuf, wrinten+1);
    if (ret != 0) {
        printk(KERN_ERR "read error");
        return -EIO;
    }

    *ppos += wrinten;

    return wrinten;
}

static ssize_t demo_write (struct file *fp, const char __user *user_buf, size_t count, loff_t *ppos)
{
    char kbuf[10] = {0};
    int ret;

    printk(KERN_INFO "user_buf: %p, count: %d, ppos: %lld\n",
           user_buf, count, *ppos);

    ret = copy_from_user(kbuf, user_buf, count);
    if (ret) {
        pr_err("%s: write error\n", __func__);
        return -EIO;
    }

    *ppos += count;

    return 0;
}

static const struct file_operations demo_fops = {
    .read = demo_read,
    .write = demo_write,
};

static int __init debugfs_demo_init(void)
{
    int ret = 0;

    demo_dir = debugfs_create_file("demo", 0444, NULL,
        NULL, &demo_fops);

    return ret;
}

static void __exit debugfs_demo_exit(void)
{
    if (demo_dir)
        debugfs_remove(demo_dir);
}

module_init(debugfs_demo_init);
module_exit(debugfs_demo_exit);
MODULE_LICENSE("GPL");

我们先来看看运行结果：
先试试写：
[root@vexpress mnt]# echo 1 > /d/demo
执行这个命令并不会返回，会卡主，再看看kernel log，已经刷屏：

[ 1021.547015] user_buf: 00202268, count: 2, ppos: 0
[ 1021.547181] user_buf: 00202268, count: 2, ppos: 2
[ 1021.547319] user_buf: 00202268, count: 2, ppos: 4
[ 1021.547466] user_buf: 00202268, count: 2, ppos: 6
.... ....
[ 1022.008736] user_buf: 00202268, count: 2, ppos: 6014
[ 1022.008880] user_buf: 00202268, count: 2, ppos: 6016
[ 1022.009012] user_buf: 00202268, count: 2, ppos: 6018
... ...

再试试读：
[root@vexpress mnt]# cat /d/demo
HelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHello... ...
可以看到，终端被Hello填满了，再看看kernel log，刷屏了：

[ 1832.074616] user_buf: becb6be8, count: 4096, ppos: 0
[ 1832.075033] user_buf: becb6be8, count: 4096, ppos: 5
[ 1832.075240] user_buf: becb6be8, count: 4096, ppos: 10
[ 1832.075898] user_buf: becb6be8, count: 4096, ppos: 15
[ 1832.076093] user_buf: becb6be8, count: 4096, ppos: 20
[ 1832.076282] user_buf: becb6be8, count: 4096, ppos: 25
[ 1832.076468] user_buf: becb6be8, count: 4096, ppos: 30
[ 1832.076653] user_buf: becb6be8, count: 4096, ppos: 35
[ 1832.076841] user_buf: becb6be8, count: 4096, ppos: 40

可以看到规律，对于write，每次的count都是2，因为写下来的是个字符串的"1"，ppos以2为台阶递增。此外，可以看到user_buf每次都相同，结合echo源码可以发现，用户的user_buf是在堆上分配的，所以地址比较小。
对于read，每次要读的count都是4KB，ppos是以5为台阶递增，正好是strlen("Hello")，user_buf的值每次都相同，结合cat源码可以发现，用户的user_buf是在栈上分配的，所以地址比较大
下图是x86系统下Linux进程的进程地址空间的内存布局，这是只是说明一下意思。

下面开始分别针对write和read进行修改：
2、对write进行修改
write版本2：
既然经过前面的分析，知道write被频繁调用的原因是用户调用write实际写入的字节数小于期望的，而用户的write的返回值来自驱动的write，那么我们直接让write返回count不就可以了吗。

static ssize_t demo_write (struct file *fp, const char __user *user_buf, size_t count, loff_t *ppos)
{
    char kbuf[10] = {0};
    int ret;

    printk(KERN_INFO "user_buf: %p, count: %d, ppos: %lld\n",
          user_buf, count, *ppos);

    ret = copy_from_user(kbuf, user_buf, count);
    if (ret) {
        pr_err("%s: write error\n", __func__);
        return -EIO;
    }

    *ppos += count;

    return count;
}

验证：

[root@vexpress mnt]# echo 1 > /d/demo

敲完回车后，立马就返回了，kernel log也只打印了一次：

[ 2444.363351] user_buf: 00202408, count: 2, ppos: 0

write版本3：
其实，kernel提供了一个很方便的函数，simple_write_to_buffer，这个函数专门完成从user空间向kernel空间拷贝数据：

static ssize_t demo_write (struct file *fp, const char __user *user_buf, size_t count, loff_t *ppos)
{
    char kbuf[10] = {0};

    printk(KERN_INFO "user_buf: %p, count: %d, ppos: %lld\n",
           user_buf, count, *ppos);

    return simple_write_to_buffer(kbuf, sizeof(kbuf), ppos, user_buf, count);
}

验证：

[root@vexpress mnt]# echo 1 > /d/demo

敲完回车后，立马就返回了，kernel log也只打印了一次：

[ 2739.984844] user_buf: 00202340, count: 2, ppos: 0

简单看看simple_write_to_buffer的实现：

/**
 * simple_write_to_buffer - copy data from user space to the buffer
 * @to: the buffer to write to
 * @available: the size of the buffer
 * @ppos: the current position in the buffer
 * @from: the user space buffer to read from
 * @count: the maximum number of bytes to read
 *
 * The simple_write_to_buffer() function reads up to @count bytes from the user
 * space address starting at @from into the buffer @to at offset @ppos.
 *
 * On success, the number of bytes written is returned and the offset @ppos is
 * advanced by this number, or negative value is returned on error.
 **/
ssize_t simple_write_to_buffer(void *to, size_t available, loff_t *ppos,
        const void __user *from, size_t count)
{
    loff_t pos = *ppos;
    size_t res;

    if (pos < 0)
        return -EINVAL;
    if (pos >= available || !count)
        return 0;
    if (count > available - pos)
        count = available - pos;
    res = copy_from_user(to + pos, from, count);
    if (res == count)
        return -EFAULT;
    count -= res;
    *ppos = pos + count;
    return count;
}
EXPORT_SYMBOL(simple_write_to_buffer);

可以看到，最后返回的是count，如果copy_from_user没都拷贝全，将来write还是会被再次调用。
3、对read进行修改
我们知道read被反复调用的原因是，read返回的值小于用户期望读取的值，对于这里，就是4KB。而对于cat来说，每次read都期望获取4KB的数据，而且在不考虑出错的情况下，只有read返回0，cat才会终止。
read版本2：

static ssize_t demo_read(struct file *fp, char __user *user_buf, size_t count, loff_t *ppos)
{
    char kbuf[10];
    int ret, wrinten;

    printk(KERN_INFO "user_buf: %p, count: %d, ppos: %lld\n",
        user_buf, count, *ppos);

    wrinten = snprintf(kbuf, 10, "%s", "Hello");

    ret = copy_to_user(user_buf, kbuf, wrinten+1);
    if (ret != 0) {
        printk(KERN_ERR "read error");
        return -EIO;
    }

    *ppos += wrinten;

    return 0;
}

验证：

[root@vexpress mnt]# cat /d/demo

执行回车后，"Hello"却没有输出，但是驱动的read驱动被调用了一次：

[  118.837456] user_buf: beeb0be8, count: 4096, ppos: 0

这是什么原因呢？可以看看cat的核心函数bb_full_fd_action，其中，如果read返回0，并不会将读到的内容输出到标准输出上，所以cat的时候什么都没看到。
既然返回0不行，那么返回count，也就是用户期望的4KB，行不行呢？
read版本3：

static ssize_t demo_read(struct file *fp, char __user *user_buf, size_t count, loff_t *ppos)
{
    char kbuf[10];
    int ret, wrinten;

    printk(KERN_INFO "user_buf: %p, count: %d, ppos: %lld\n",
        user_buf, count, *ppos);

    wrinten = snprintf(kbuf, 10, "%s", "Hello");

    ret = copy_to_user(user_buf, kbuf, wrinten+1);
    if (ret != 0) {
        printk(KERN_ERR "read error");
        return -EIO;
    }

    *ppos += wrinten;

    return count;
}

验证：

[root@vexpress mnt]# cat /d/demo
ȸT�/mnt/busybox�u0�@ξ���вu����\ξl����@����

可以看到，输出内容中有一些乱七八糟的东西。再看看kernel log，依然刷屏：

[  339.079698] user_buf: bece4be8, count: 4096, ppos: 0
[  339.080124] user_buf: bece4be8, count: 4096, ppos: 5
[  339.085525] user_buf: bece4be8, count: 4096, ppos: 10
[  339.085886] user_buf: bece4be8, count: 4096, ppos: 15
[  339.087018] user_buf: bece4be8, count: 4096, ppos: 20
[  339.098798] user_buf: bece4be8, count: 4096, ppos: 25
... ...

什么原因呢？我们知道，如果驱动的read返回4KB，表示用户读到了4KB的数据，但是实际上用户的buffer中只有前5个字节是从kernel读到的，其他的都是用户的buffer缓冲区中的垃圾数据，由于read返回的一直都是4KB，所以会一直read，直到返回0，所以刷屏了。其实，kernel提供了清除用户buffer的函数：clear_user，这样就不会输出乱码了，但是还是会刷屏。

static ssize_t demo_read(struct file *fp, char __user *user_buf, size_t count, loff_t *ppos)
{
    char kbuf[10];
    int ret, wrinten;

    printk(KERN_INFO "user_buf: %p, count: %d, ppos: %lld\n",
        user_buf, count, *ppos);

    wrinten = snprintf(kbuf, 10, "%s", "Hello");

    if (clear_user(user_buf, count)) {
        printk(KERN_ERR "clear error\n");
        return -EIO;
    }

    ret = copy_to_user(user_buf, kbuf, wrinten+1);
    if (ret != 0) {
        printk(KERN_ERR "read error\n");
        return -EIO;
    }

    *ppos += wrinten;

    return count;
}

上面的这种改动只是不会输出乱码了，但是还是会刷屏。

read版本4：
那该怎么办呢？我们试试kernel提供的simple_read_from_buffer看看行不行，这个函数专门完成从kernel空间向user空间拷贝数据：

static ssize_t demo_read(struct file *fp, char __user *user_buf, size_t count, loff_t *ppos)
{
    char kbuf[10];
    int wrinten;

    printk(KERN_INFO "user_buf: %p, count: %d, ppos: %lld\n",
        user_buf, count, *ppos);

    wrinten = snprintf(kbuf, 10, "%s", "Hello");

    if (clear_user(user_buf, count)) {
        printk(KERN_ERR "clear error\n");
        return -EIO;
    }

    return simple_read_from_buffer(user_buf, count, ppos, kbuf, wrinten);
}

验证：

[root@vexpress mnt]# cat /d/demo
Hello

可以看到，cat没有刷屏，确实输出了我们想要的结果，那kernel log呢？

[  479.457637] user_buf: bec61be8, count: 4096, ppos: 0
[  479.458268] user_buf: bec61be8, count: 4096, ppos: 5

还不错，驱动的write被调用了两次，为什么呢？ 我们结合simple_read_from_buffer的实现来看看：

/**
 * simple_read_from_buffer - copy data from the buffer to user space
 * @to: the user space buffer to read to
 * @count: the maximum number of bytes to read
 * @ppos: the current position in the buffer
 * @from: the buffer to read from
 * @available: the size of the buffer
 *
 * The simple_read_from_buffer() function reads up to @count bytes from the
 * buffer @from at offset @ppos into the user space address starting at @to.
 *
 * On success, the number of bytes read is returned and the offset @ppos is
 * advanced by this number, or negative value is returned on error.
 **/
ssize_t simple_read_from_buffer(void __user *to, size_t count, loff_t *ppos,
                const void *from, size_t available)
{
    loff_t pos = *ppos;
    size_t ret;

    if (pos < 0)
        return -EINVAL;
    if (pos >= available || !count)
        return 0;
    if (count > available - pos)
        count = available - pos;
    ret = copy_to_user(to, from + pos, count);
    if (ret == count)
        return -EFAULT;
    count -= ret;
    *ppos = pos + count;
    return count;
}
EXPORT_SYMBOL(simple_read_from_buffer);

第一次read是ppos是0，读完毕之后，ppos变成了5。我们知道，cat不甘心，因为没有返回0，所以紧接着又调用了一次read，这次的ppos为5，上面的第23行代码生效了，available是5，所以直接返回了0，然后cat就乖乖的退出了。

read版本5：
因为我们想实现cat的时候，驱动的read只调用一次，同时还要保证cat能输出读到的内容，我们可以做如下修改：

static ssize_t demo_read(struct file *fp, char __user *user_buf, size_t count, loff_t *ppos)
{
    char kbuf[10];
    int wrinten;

    if (*ppos)
        return 0;

    printk(KERN_INFO "user_buf: %p, count: %d, ppos: %lld\n",
        user_buf, count, *ppos);

    wrinten = snprintf(kbuf, 10, "%s", "Hello");

    if (clear_user(user_buf, count)) {
        printk(KERN_ERR "clear error\n");
        return -EIO;
    }

    return simple_read_from_buffer(user_buf, count, ppos, kbuf, wrinten);
}

在第6行，先判断*ppos的值，我们知道第一次调用驱动read时，*ppos是0，读完毕后，*ppos会被更新，第二次*ppos便不为0.

验证：

[root@vexpress mnt]# cat /d/demo
Hello

用户空间没有刷屏，达到了

[ 1217.948729] user_buf: beb88be8, count: 4096, ppos: 0

我们的目的，kernel的log也只有一行：

也就是驱动的read确实被调用了一次。其实我们知道，驱动的read还是被调用了两次，只不多第二次没有什么干什么活，直接就返回了，不会影响我们的驱动逻辑。
也可以不用内核提供的接口：
read版本6：

static ssize_t demo_read(struct file *fp, char __user *user_buf, size_t count, loff_t *ppos)
{
    char kbuf[10];
    int ret, wrinten;

    if (*ppos)
        return 0;

    printk(KERN_INFO "user_buf: %p, count: %d, ppos: %lld\n",
        user_buf, count, *ppos);

    wrinten = snprintf(kbuf, 10, "%s", "Hello");

    if (clear_user(user_buf, count)) {
        printk(KERN_ERR "clear error\n");
        return -EIO;
    }


    ret = copy_to_user(user_buf, kbuf, wrinten);
    if (ret != 0) {
        printk(KERN_ERR "copy error\n");
        return -EIO;
    }

    *ppos += wrinten;

    return wrinten;
}

效果跟前一个一样。
完。

本文转自

晴天_QQ
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
另一种简单的读写-simple_read_from_buffer
weixin_39821531的博客
03-14 3450
之前在《简单的读和写》中提到过file_operations结构中的读/写方法中的buff参数是指向用户空间的缓冲区。而用户空间的指针，内核代码不能直接引用其中的内容。 所以用了copy_to_user和copy_from_user来完成最后的读写操作。 这里介绍另一对可以完成读写的函数：simple_read_from_buffer和simple_write_to_buffer。 这两个方...
TwinCAT数据存储、配方和文件处理
05-16
TwinCAT PLC 还可以读写标准格式的文件，包括.bin、.txt 及.csv，其中.txt 及.csv 可以供其它应用程序（比如 Excel、Notepad）访问。配合特定的功能扩展包，TwinCAT PLC 还支持 XML 文件读写。
MiniDemoCSV1_TwinCAT3读写CSV文件_twincat_bicyclef1q_
09-28
TwinCAT ST编写的读写CSV文件功能
Shell脚本中使用for循环和cat命令实现按顺序合并文件
09-15
主要介绍了Shell脚本中使用for循环和cat命令实现按顺序合并文件,本文先是用sed命令来实现,发现不能完成需求,后使用for循环解决,需要的朋友可以参考下
busybox-1.24.2.tar.bz2
12-01
在使用openwrt进行编译的时候很容易下载 busybox-1.24.2.tar.bz2 失败，那么就将该资源下载后放到openwrt/dl/文件夹下面
TwinCAT2文件读写复制功能程序
11-28
压缩包包含以下4个例程 1.cx1010的文件复制至工控机.pro 2.读写CSV文件.pro 3.获取磁盘剩余空间.pro 4.批量删除文件.pro
Linux重度使用命令详解（科普cat，echo命令）四
zsk_john的技术分享专用博客
10-02 2510
cat和echo命令的使用频率非常高，但有一点需要注意，这两个命令通常是需要结合管道符配合其它的命令才可以体现出这两个命令的强大的哦，说通俗点，也就是这两个命令是基础的命令，并且具有极高的扩展性。 一，cat 命令 cat命令是查看文本文档的命令，这里需要啰嗦一下啦，请注意是文本文档，如果你想使用cat命令打开二进制文件，那么，不好意思，会是乱码哦。二进制文件的查看通常是反编译或者使用strings命令查看二进制文件的某些细节。 cat命令的用途：查看各类配置文件，日志文件获取到有用的信息，通过管道符
设备驱动-----自动创建节点
奔跑的蜗牛
06-21 2573
#include #include #include #include MODULE_LICENSE("GPL"); #define DEVICE_NAME ("my_dev") int MAJOR_NUM = 666; int g_val; struct device *dev; struct class *myclass; static ssize_t global_read(
linux设备驱动之字符设备
qq_32513649的博客
09-08 403
/*  1. 如何写字符设备驱动，添加字符设备   // 1 手动添加字符设备，cat/proc/divices ==> major 获得主设备号     已知主次设备号添加设备 cd /dev; mknod name c major minor   2 自动添加设备节点udev   class_create();   device_create();    2. 如何写设备fo
Linux常用命令：echo、cat、tail详解
里查叔叔
03-24 331
在Linux系统中，命令行工具是非常强大的。其中，echocat和tail这三个命令在日常的系统管理和文本处理中经常被使用。下面，我们将逐一探讨这三个命令的详细用法和常见示例。
TwinCAT3功能块封装库文件和库文件使用说明
11-10
TwinCAT3功能块封装库文件和库文件使用说明 1、库文件封装说明 2、新工程引用库文件使用说明。
Netty写刷数据源码解析
我神级欧文的博客
07-07 658
Netty写刷数据源码解析
树莓派移植FFmepg记录(x264、硬件编码支持)
NameisBoy的博客
10-22 1293
移植FFmpeg到树莓派3B，添加了x264软件编码器、Omx-rpi硬件编码的支持，降低CPU占用率。
c++实现一个简易的网络缓冲区
shi_xiao_xuan的博客
12-24 4016
简单的网络区设计与实现 1）.为什么需要设计网络缓冲区，内核中不是有读写缓冲区吗？ 2）.缓冲区应该设置为堆内存还是栈内存？ 3）.读写缓冲区的基本要求是什么？ 4）.如何界定数据包？ 5）.几种常见的缓冲区设计
cat & grep & read
sheshou199的博客
08-03 1506
linux shell cat（一） cat主要有三大功能： 1.一次显示整个文件。$ cat filename 2.从键盘创建一个文件。$ cat > filename      只能创建新文件,不能编辑已有文件. 3.将几个文件合并为一个文件： $cat file1 file2 > file 参数： -n 或 --number 由 1 开始对所有输出的行数编号 -b 或 -
Linux proc读操作为什么会执行3次
风之伤
10-08 1919
在使用cat 命令读取proc 文件时，奇怪的发现读函数被执行了三次 proc 读函数代码片断(直接读取内核模块的某个变量值) int proc_read_hello(char *page, char **start, off_t off, int count, int *eof,                 void *data) {        
2021数学建模美赛C题代码.zip
最新发布
04-24
最全的数学建模美赛C题和代码、大量刷题题库、逻辑清晰易于学习
使用mkdir,echo,cp,Chloe,cat命令创建一个可以读取和删除但不能修改的文件
04-19
好的，以下是创建一个可以读取和删除但不能修改的文件的方法： 1. 首先使用mkdir命令创建一个新目录： mkdir file_directory 2. 使用cd命令进入到新创建的目录中： cd file_directory 3. 使用echo命令创建一个新文件，内容为需要保护的信息： echo "This is sensitive information" > file.txt 4. 使用chmod命令修改文件的权限，保证任何人都可以对文件进行读取和删除操作，但不能对文件进行修改或更改： chmod 644 file.txt 5. 使用Chloe命令将文件所有者设置为root，以确保只有管理员才能对文件进行修改或更改： chown root file.txt 6. 最后，使用cat命令确认文件已经被正确创建，并能够被读取和删除： cat file.txt

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值