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

来源:互联网 时间:2017-12-09

作者

[email protected]

彭东林

 

平台

busybox-1.24.2

Linux-4.10.17

 

概述

在写驱动的时候,我们经常会向用户空间导出一些文件,然后用户空间使用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会被调用:

 1 ssize_t vfs_read(struct file *file, char __user *buf, size_t count, loff_t *pos)

2 {

3 ssize_t ret;

4

5 if (!(file->f_mode & FMODE_READ))

6 return -EBADF;

7 if (!(file->f_mode & FMODE_CAN_READ))

8 return -EINVAL;

9 if (unlikely(!access_ok(VERIFY_WRITE, buf, count)))

10 return -EFAULT;

11

12 ret = rw_verify_area(READ, file, pos, count);

13 if (!ret) {

14 if (count > MAX_RW_COUNT)

15 count = MAX_RW_COUNT;

16 ret = __vfs_read(file, buf, count, pos);

17 if (ret > 0) {

18 fsnotify_access(file);

19 add_rchar(current, ret);

20 }

21 inc_syscr(current);

22 }

23

24 return ret;

25 }

下面是需要关注的:

第9行检查用户空间的buf缓冲区是否可以写入

第14行检查count的大小,这里MAX_RW_COUNT被设置为1个页的大小,这里的值是4KB,也就是一次用户一次read最多获得4KB数据

第16行调用__vfs_read,这个函数最终会调用到我们的驱动中的read函数,可以看到这个函数的参数跟驱动中的read函数一样,驱动中read返回的数字ret会返回给用户,这里并没有看到更新pos,所以需要在我们的驱动中自己去更新。

 

用户空间调用write函数后,内核函数vfs_write会被调用:

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

2 {

3 ssize_t ret;

4

5 if (!(file->f_mode & FMODE_WRITE))

6 return -EBADF;

7 if (!(file->f_mode & FMODE_CAN_WRITE))

8 return -EINVAL;

9 if (unlikely(!access_ok(VERIFY_READ, buf, count)))

10 return -EFAULT;

11

12 ret = rw_verify_area(WRITE, file, pos, count);

13 if (!ret) {

14 if (count > MAX_RW_COUNT)

15 count = MAX_RW_COUNT;

16 file_start_write(file);

17 ret = __vfs_write(file, buf, count, pos);

18 if (ret > 0) {

19 fsnotify_modify(file);

20 add_wchar(current, ret);

21 }

22 inc_syscw(current);

23 file_end_write(file);

24 }

25

26 return ret;

27 }

这里需要关注:

第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

 1 static off_t bb_full_fd_action(int src_fd, int dst_fd, off_t size)

2 {

3 int status = -1;

4 off_t total = 0;

5 bool continue_on_write_error = 0;

6 ssize_t sendfile_sz;

7 char buffer[4 * 1024]; // 用户空间缓冲区,4KB大小

8 enum { buffer_size = sizeof(buffer) }; // 每次read期望获得的字节数

9

10 sendfile_sz = 0;

11 if (!size) {

12 size = (16 * 1024 *1024); // 刚开始,如传入的size是0,这里将size设置为16MB

13 status = 1; /* 表示一直读到文件结尾,也就是知道read返回0 */

14 }

15

16 while (1) {

17 ssize_t rd;

18

19 rd = safe_read(src_fd, buffer, buffer_size); // 这里调用的就是read, 读取4KB,rd是实际读到的字节数

20 if (rd < 0) {

21 bb_perror_msg(bb_msg_read_error);

22 break;

23 }

24 read_ok:

25 if (!rd) { /* 表示读到了文件结尾 */

26 status = 0;

27 break;

28 }

29 /* 将读到的内容输出到dst_fd表示的文件描述符 */

30 if (dst_fd >= 0 && !sendfile_sz) {

31 ssize_t wr = full_write(dst_fd, buffer, rd);

32 if (wr < rd) {

33 if (!continue_on_write_error) {

34 bb_perror_msg(bb_msg_write_error);

35 break;

36 }

37 dst_fd = -1;

38 }

39 }

40

41 total += rd; // total记录的是读到的字节数的累计值

42 if (status < 0) { /* 如果传入的size不为0,那么status为-1,直到读到size个字节后,才会退出。如果size为0,这个条件不会满足 */

43 size -= rd;

44 if (!size) {

45 /* 'size' bytes copied - all done */

46 status = 0;

47 break;

48 }

49 }

50 }

51 out:

52 return status ? -1 : total; // 当读完毕,status为0,这里返回累计读到的字节数

53 }

从上面的分析我们知道如下信息:

使用cat xxx时,上面的函数传入的size为0,那么上面的while循环会一直进行read,只到出错或者read返回0,read返回0也就是读到文件结尾。最后如果出错,那么返回-1,否则的话,返回读到的累计的字节数。

到这里,应该就是知道为什么驱动中的read会被频繁调用了吧,也就是驱动中的read的返回值有问题。

 

ECHO:

echo的核心函数是full_write

这里fd是要写的内核节点,buf缓冲区中存放的是要写入的内容,len是buf缓冲区中存放的字节数

 1 ssize_t FAST_FUNC full_write(int fd, const void *buf, size_t len)

2 {

3 ssize_t cc;

4 ssize_t total;

5

6 total = 0;

7

8 while (len) {

9 cc = safe_write(fd, buf, len);

10

11 if (cc < 0) {

12 if (total) {

13 /* we already wrote some! */

14 /* user can do another write to know the error code */

15 return total;

16 }

17 return cc; /* write() returns -1 on failure. */

18 }

19

20 total += cc;

21 buf = ((const char *)buf) + cc;

22 len -= cc;

23 }

24

25 return total;

26 }

上面的函数很简单,可以得到如下信息:

如果write的函数返回值cc小于len的话,会一直调用write,直到报错或者len个字节全部写完。而这里的cc对应的就是我们的驱动中write的返回值。最后,返回实际写入的字节数或者一个错误码。

到这里,应该也已经清除为什么调用一次echo后,驱动的write为什么会被频繁调用了吧,还是驱动中write的返回值的问题。

 

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

 

四、实例分析

1、先看两个刷屏的例子

这个驱动在/sys/kernel/debug生成一个demo节点,支持读和写。

 1 #include <linux/init.h>

2 #include <linux/module.h>

3 #include <linux/debugfs.h>

4 #include <linux/fs.h>

5 #include <asm/uaccess.h>

6

7 static struct dentry *demo_dir;

8

9 static ssize_t demo_read(struct file *fp, char __user *user_buf, size_t count, loff_t *ppos)

10 {

11 char kbuf[10];

12 int ret, wrinten;

13

14 printk(KERN_INFO "user_buf: %p, count: %d, ppos: %lld\n",

15 user_buf, count, *ppos);

16

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

18

19 ret = copy_to_user(user_buf, kbuf, wrinten+1);

20 if (ret != 0) {

21 printk(KERN_ERR "read error");

22 return -EIO;

23 }

24

25 *ppos += wrinten;

26

27 return wrinten;

28 }

29

30 static ssize_t demo_write (struct file *fp, const char __user *user_buf, size_t count, loff_t *ppos)

31 {

32 char kbuf[10] = {0};

33 int ret;

34

35 printk(KERN_INFO "user_buf: %p, count: %d, ppos: %lld\n",

36 user_buf, count, *ppos);

37

38 ret = copy_from_user(kbuf, user_buf, count);

39 if (ret) {

40 pr_err("%s: write error\n", __func__);

41 return -EIO;

42 }

43

44 *ppos += count;

45

46 return 0;

47 }

48

49 static const struct file_operations demo_fops = {

50 .read = demo_read,

51 .write = demo_write,

52 };

53

54 static int __init debugfs_demo_init(void)

55 {

56 int ret = 0;

57

58 demo_dir = debugfs_create_file("demo", 0444, NULL,

59 NULL, &demo_fops);

60

61 return ret;

62 }

63

64 static void __exit debugfs_demo_exit(void)

65 {

66 if (demo_dir)

67 debugfs_remove(demo_dir);

68 }

69

70 module_init(debugfs_demo_init);

71 module_exit(debugfs_demo_exit);

72 MODULE_LICENSE("GPL");

我们先来看看运行结果:

先试试写:

[[email protected] 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

... ...

 

再试试读:

[[email protected] 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每次都相同

对于read,每次要读的count都是4KB,ppos是以5为台阶递增,正好是strlen("Hello"),user_buf的值每次都相同

 

下面开始分别针对write和read进行修改:

 

2、对write进行修改

write版本2:

既然经过前面的分析,知道write被频繁调用的原因是用户调用write实际写入的字节数小于期望的,而用户的write的返回值来自驱动的write,那么我们直接然write返回count不就可以了吗。

 1 static ssize_t demo_write (struct file *fp, const char __user *user_buf, size_t count, loff_t *ppos)

2 {

3 char kbuf[10] = {0};

4 int ret;

5

6 printk(KERN_INFO "user_buf: %p, count: %d, ppos: %lld\n",

7 user_buf, count, *ppos);

8

9 ret = copy_from_user(kbuf, user_buf, count);

10 if (ret) {

11 pr_err("%s: write error\n", __func__);

12 return -EIO;

13 }

14

15 *ppos += count;

16

17 return count;

18 }

验证:

[[email protected] 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空间拷贝数据:

1 static ssize_t demo_write (struct file *fp, const char __user *user_buf, size_t count, loff_t *ppos)

2 {

3 char kbuf[10] = {0};

4

5 printk(KERN_INFO "user_buf: %p, count: %d, ppos: %lld\n",

6 user_buf, count, *ppos);

7

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

9 }

验证:

[[email protected] mnt]# echo 1 > /d/demo

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

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

 

简单看看simple_write_to_buffer的实现:

 1 /**

2 * simple_write_to_buffer - copy data from user space to the buffer

3 * @to: the buffer to write to

4 * @available: the size of the buffer

5 * @ppos: the current position in the buffer

6 * @from: the user space buffer to read from

7 * @count: the maximum number of bytes to read

8 *

9 * The simple_write_to_buffer() function reads up to @count bytes from the user

10 * space address starting at @from into the buffer @to at offset @ppos.

11 *

12 * On success, the number of bytes written is returned and the offset @ppos is

13 * advanced by this number, or negative value is returned on error.

14 **/

15 ssize_t simple_write_to_buffer(void *to, size_t available, loff_t *ppos,

16 const void __user *from, size_t count)

17 {

18 loff_t pos = *ppos;

19 size_t res;

20

21 if (pos < 0)

22 return -EINVAL;

23 if (pos >= available || !count)

24 return 0;

25 if (count > available - pos)

26 count = available - pos;

27 res = copy_from_user(to + pos, from, count);

28 if (res == count)

29 return -EFAULT;

30 count -= res;

31 *ppos = pos + count;

32 return count;

33 }

34 EXPORT_SYMBOL(simple_write_to_buffer);

可以看到,最后返回的是count,如果copy_from_user没都拷贝全,将来write还是会被再次调用。

 

3、对read进行修改

我们知道read被返回调用的原因是,read返回的值小于用户期望读取的值,对于这里,就是4KB。而对于cat来说,每次read都期望获取4KB的数据,而且在不考虑出错的情况下,只有read返回0,cat才会终止。

 

read版本2:

 1 static ssize_t demo_read(struct file *fp, char __user *user_buf, size_t count, loff_t *ppos)

2 {

3 char kbuf[10];

4 int ret, wrinten;

5

6 printk(KERN_INFO "user_buf: %p, count: %d, ppos: %lld\n",

7 user_buf, count, *ppos);

8

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

10

11 ret = copy_to_user(user_buf, kbuf, wrinten+1);

12 if (ret != 0) {

13 printk(KERN_ERR "read error");

14 return -EIO;

15 }

16

17 *ppos += wrinten;

18

19 return 0;

20 }

验证:

[[email protected] 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:

 1 static ssize_t demo_read(struct file *fp, char __user *user_buf, size_t count, loff_t *ppos)

2 {

3 char kbuf[10];

4 int ret, wrinten;

5

6 printk(KERN_INFO "user_buf: %p, count: %d, ppos: %lld\n",

7 user_buf, count, *ppos);

8

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

10

11 ret = copy_to_user(user_buf, kbuf, wrinten+1);

12 if (ret != 0) {

13 printk(KERN_ERR "read error");

14 return -EIO;

15 }

16

17 *ppos += wrinten;

18

19 return count;

20 }

验证:

[[email protected] mnt]# cat /d/demo

ȸT�/mnt/busybox�u0�[email protected]^ξ���вu����\ξl����[email protected]����

可以看到,输出内容中有一些乱七八糟的东西。再看看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,这样就不会输出乱码了,但是还是会刷屏,

 1 static ssize_t demo_read(struct file *fp, char __user *user_buf, size_t count, loff_t *ppos)

2 {

3 char kbuf[10];

4 int ret, wrinten;

5

6 printk(KERN_INFO "user_buf: %p, count: %d, ppos: %lld\n",

7 user_buf, count, *ppos);

8

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

10

11 if (clear_user(user_buf, count)) {

12 printk(KERN_ERR "clear error\n");

13 return -EIO;

14 }

15

16 ret = copy_to_user(user_buf, kbuf, wrinten+1);

17 if (ret != 0) {

18 printk(KERN_ERR "read error\n");

19 return -EIO;

20 }

21

22 *ppos += wrinten;

23

24 return count;

25 }

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

 

read版本4:

那该怎么办呢?我们试试kernel提供的simple_read_from_buffer看看行不行,这个函数专门完成从kernel空间向user空间拷贝数据:

 1 static ssize_t demo_read(struct file *fp, char __user *user_buf, size_t count, loff_t *ppos)

2 {

3 char kbuf[10];

4 int wrinten;

5

6 printk(KERN_INFO "user_buf: %p, count: %d, ppos: %lld\n",

7 user_buf, count, *ppos);

8

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

10

11 if (clear_user(user_buf, count)) {

12 printk(KERN_ERR "clear error\n");

13 return -EIO;

14 }

15

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

17 }

验证:

[[email protected] 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的实现来看看:

 1 /**

2 * simple_read_from_buffer - copy data from the buffer to user space

3 * @to: the user space buffer to read to

4 * @count: the maximum number of bytes to read

5 * @ppos: the current position in the buffer

6 * @from: the buffer to read from

7 * @available: the size of the buffer

8 *

9 * The simple_read_from_buffer() function reads up to @count bytes from the

10 * buffer @from at offset @ppos into the user space address starting at @to.

11 *

12 * On success, the number of bytes read is returned and the offset @ppos is

13 * advanced by this number, or negative value is returned on error.

14 **/

15 ssize_t simple_read_from_buffer(void __user *to, size_t count, loff_t *ppos,

16 const void *from, size_t available)

17 {

18 loff_t pos = *ppos;

19 size_t ret;

20

21 if (pos < 0)

22 return -EINVAL;

23 if (pos >= available || !count)

24 return 0;

25 if (count > available - pos)

26 count = available - pos;

27 ret = copy_to_user(to, from + pos, count);

28 if (ret == count)

29 return -EFAULT;

30 count -= ret;

31 *ppos = pos + count;

32 return count;

33 }

34 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能输出读到的内容,我们可以做如下修改:

 1 static ssize_t demo_read(struct file *fp, char __user *user_buf, size_t count, loff_t *ppos)

2 {

3 char kbuf[10];

4 int wrinten;

5

6 if (*ppos)

7 return 0;

8

9 printk(KERN_INFO "user_buf: %p, count: %d, ppos: %lld\n",

10 user_buf, count, *ppos);

11

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

13

14 if (clear_user(user_buf, count)) {

15 printk(KERN_ERR "clear error\n");

16 return -EIO;

17 }

18

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

20 }

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

验证:

[[email protected] mnt]# cat /d/demo

Hello

用户空间没有刷屏,达到了我们的目的,kernel的log也只有一行:

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

也就是驱动的read确实被调用了一次。其实我们知道,驱动的read还是被调用了两次,只不多第二次没有什么干什么活,直接就返回了,不会影响我们的驱动逻辑。

 

也可以不用内核提供的接口:

read版本6:

 1 static ssize_t demo_read(struct file *fp, char __user *user_buf, size_t count, loff_t *ppos)

2 {

3 char kbuf[10];

4 int ret, wrinten;

5

6 if (*ppos)

7 return 0;

8

9 printk(KERN_INFO "user_buf: %p, count: %d, ppos: %lld\n",

10 user_buf, count, *ppos);

11

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

13

14 if (clear_user(user_buf, count)) {

15 printk(KERN_ERR "clear error\n");

16 return -EIO;

17 }

18

19

20 ret = copy_to_user(user_buf, kbuf, wrinten);

21 if (ret != 0) {

22 printk(KERN_ERR "copy error\n");

23 return -EIO;

24 }

25

26 *ppos += wrinten;

27

28 return wrinten;

29 }

效果跟前一个一样。

 

完。

相关阅读:
Top