简介

使用内核的KFIFO作为缓冲区

API

  1. #include <linux/kfifo.h>
  2. # 声明一个FIFO
  3. #define DEFINE_KFIFO(fifo, type, size)
  5. # 使用例子
  6. static struct device *mydemodrv_device;
  7. DEFINE_KFIFO(mydemo_fifo, char, 64);
  9. # 读数据
  10. #define    kfifo_to_user(fifo, to, len, copied)
  11. # 写数据
  12. #define    kfifo_from_user(fifo, from, len, copied)

使用例程

  1. static struct device *mydemodrv_device;
  2. DEFINE_KFIFO(mydemo_fifo, char, 64);
  4. # 将数据读取到buf 中。
  5. kfifo_to_user(&mydemo_fifo, buf, count, &actual_readed);
  6. # 将数据从buf写入fifo
  7. kfifo_from_user(&mydemo_fifo, buf, count, &actual_write);

代码分析

  1. struct __kfifo {
  2.     unsigned int    in;
  3.     unsigned int    out;
  4.     unsigned int    mask;
  5.     unsigned int    esize;
  6.     void        *data; # 存放数据的指针
  7. };
  1. #include "kfifo.h"
  2. DEFINE_KFIFO(mydemo_fifo, char, 64);
  4. # gcc -E test.c -o test.i

声明

  1. # 将 DEFINE_KFIFO(mydemo_fifo, char, 64); 使用预处理以后的结果 test.i
  2. # 其中 rectype 这一个字段是
  3. struct __kfifo {
  4.   unsigned int in;
  5.   unsigned int out;
  6.   unsigned int mask;
  7.   unsigned int esize;
  8.   void *data;
  9. };
  11. struct kfifo {
  12.   union {
  13.     struct __kfifo kfifo;
  14.     unsigned char *type; # 存储类型
  15.     const unsigned char *const_type; # 
  16.     char (*rectype)[0]; # 
  17.     void *ptr; # 
  18.     void const *ptr_const;
  19.   };
  20.   unsigned char buf[0];
  21. };
  23. struct kfifo_rec_ptr_1 {
  24.   union {
  25.     struct __kfifo kfifo;
  26.     unsigned char *type;
  27.     const unsigned char *const_type;
  28.     char (*rectype)[1];
  29.     void *ptr;
  30.     void const *ptr_const;
  31.   };
  32.   unsigned char buf[0];
  33. };
  34. struct kfifo_rec_ptr_2 {
  35.   union {
  36.     struct __kfifo kfifo;
  37.     unsigned char *type;
  38.     const unsigned char *const_type;
  39.     char (*rectype)[2];
  40.     void *ptr;
  41.     void const *ptr_const;
  42.   };
  43.   unsigned char buf[0];
  44. };
  46. static inline unsigned int __must_check
  47. __kfifo_uint_must_check_helper(unsigned int val) {
  48.   return val;
  49. }
  51. static inline int __must_check __kfifo_int_must_check_helper(int val) {
  52.   return val;
  53. }
  55. # 比较重要的是这里， 声明缓存区和前后指针
  56. struct {
  57.   union {
  58.     struct __kfifo kfifo;
  59.     char *type;
  60.     const char *const_type;
  61.     char (*rectype)[0];
  62.     char *ptr;
  63.     char const *ptr_const;
  64.   }; # 可以看到，Kfifio是由一个联合体组合成的，缓存区buf,以及 union 的联合体
  65.   char buf[((64 < 2) || (64 & (64 - 1))) ? -1 : 64]; # 静态定义一个 64 字节的区域
  66. } mydemo_fifo = (typeof(mydemo_fifo)){{{ # 这里就是直接在声明一个结构体的时候定义并且初始化结构体。
  67.     .in = 0,# 初始化的是 __kfifo 结构体里面的数据
  68.     .out = 0, 
  69.     .mask = (sizeof(*&(mydemo_fifo)) == sizeof(struct __kfifo))
  70.                 ? 0
  71.                 : ARRAY_SIZE((mydemo_fifo).buf) - 1,
  72.     .esize = sizeof(*(mydemo_fifo).buf), # 前面使用的数组存储数组，表示数组的长度
  73.     .data = (sizeof(*&(mydemo_fifo)) == sizeof(struct __kfifo))
  74.                 ? NULL
  75.                 : (mydemo_fifo).buf,
  76. }}};

读数据

  1. # kfifo_to_user(&mydemo_fifo, buf, count, &actual_readed); 预处理以后的数据
  2. __kfifo_uint_must_check_helper(({
  3.   typeof((&mydemo_fifo) + 1) __tmp = (&mydemo_fifo);
  4.   void __user *__to = (buf);
  5.   unsigned int __len = (count);
  6.   unsigned int *__copied = (&actual_readed);
  7.   const size_t __recsize = sizeof(*__tmp->rectype);
  8.   struct __kfifo *__kfifo = &__tmp->kfifo;
  9.   (__recsize) ? __kfifo_to_user_r(__kfifo, __to, __len, __copied, __recsize)
  10.               : __kfifo_to_user(__kfifo, __to, __len, __copied);
  11. }));
  13. 我们可以观察到，调用的是两个函数（or）
  14. extern int __kfifo_to_user_r(struct __kfifo *fifo, void __user *to,
  15.                              unsigned long len, unsigned int *copied,
  16.                              size_t recsize);
  17. 或者
  18. extern int __kfifo_to_user(struct __kfifo *fifo, void __user *to,
  19.                            unsigned long len, unsigned int *copied);

__kfifo_to_user 函数

kfifo_to_user 函数将会调用 __kfifo_to_user来判断越界等操作。然后调用静态函数kfifo_copy_to_user来赋值数据。最终还是调用的 copy_to_user函数。

  1. lib/kfifo.c
  2. int __kfifo_to_user(struct __kfifo *fifo, void __user *to,
  3.         unsigned long len, unsigned int *copied)
  4.     kfifo_copy_to_user(fifo, to, len, fifo->out, copied);
  5.         copy_to_user(to, fifo->data + off, l);