linux内核分析--内核中的数据结构之队列（二）

内核中的队列是以字节形式保存数据的，所以获取数据的时候，需要知道数据的大小。

如果从队列中取得数据时指定的大小不对的话，取得数据会不完整或过大。

内核中关于队列定义的头文件位于： include/linux/kfifo.h

头文件中定义的函数的实现位于：kernel/kfifo.c

内核队列编程需要注意的是：

• 队列的size在初始化时，始终设定为2的n次方
• 使用队列之前将队列结构体中的锁(spinlock)释放

1. kfifo概述

        kfifo 是内核里面的一个First In First Out数据结构，它采用环形循环队列的数据结构来实现；它提供一个无边界的字节流服务，最重要的一点是，它使用并行无锁编程技术，即当它用于只有一个入队线程和一个出队线程的场情时，两个线程可以并发操作，而不需要任何加锁行为，就可以保证kfifo的线程安全。

 struct kfifo {  

        unsignedchar *buffer;    /* the buffer holdingthe data */  

        unsignedint size;    /* the size of the allocatedbuffer */  

        unsignedint in;    /* data is added at offset (in% size) */  

        unsignedint out;    /* data is extracted fromoff. (out % size) */  

        spinlock_t*lock;    /* protects concurrentmodifications */  

    };  

      这是kfifo的数据结构，kfifo主要提供了两个操作，__kfifo_put(入队操作)和__kfifo_get(出队操作)。 它的各个数据成员如下：

buffer， 用于存放数据的缓存

size,      buffer空间的大小，在初化时，将它向上扩展成2的幂

lock,      如果使用不能保证任何时间最多只有一个读线程和写线程，需要使用该lock实施同步。

in, out,  和buffer一起构成一个循环队列。 in指向buffer中队尾，而且out指向buffer中的队头，in是数据被开始存放的偏移位置，out是队列开始取出数据的偏移位置。它的结构如示图如下：

+--------------------------------------------------------------+
|           |<----------data---------->|                                   |
+--------------------------------------------------------------+
           ^                                      ^ 
            |                                       |
            out                                   in

在put和get函数中堆in,out做了很巧妙的处理！

2. kfifo_alloc 分配kfifo内存和初始化工作 

 struct kfifo*kfifo_alloc(unsigned int size, gfp_t gfp_mask, spinlock_t *lock)  
    {  
        unsignedchar *buffer;  
        structkfifo *ret;  
        /* 
         * round upto the next power of 2, since our 'let the indices 
         * wrap'tachnique works only in this case. 
         */  
        if (size& (size - 1)) {  
           BUG_ON(size > 0x80000000);  
            size = roundup_pow_of_two(size);  
        }  
        buffer =kmalloc(size, gfp_mask);  
        if(!buffer) 
            returnERR_PTR(-ENOMEM);  
        ret =kfifo_init(buffer, size, gfp_mask, lock);  
        if (IS_ERR(ret))  
           kfree(buffer);       
        returnret;  
    }   

      这里值得一提的是，kfifo->size的值总是在调用者传进来的size参数的基础上向2的幂扩展，这是内核一贯的做法。这样的好处不言而喻--对kfifo->size取模运算可以转化为与运算，如下：

kfifo->in % kfifo->size 可以转化为 kfifo->in & (kfifo->size – 1)

     在kfifo_alloc函数中，使用size & (size – 1)来判断size 是否为2幂，如果条件为真，则表示size不是2的幂，然后调用roundup_pow_of_two将之向上扩展为2的幂。在kfifo_alloc函 数中看到调用了kfifo_init函数：

/**
 30  * kfifo_init - allocates a new FIFO using apreallocated buffer
 31  * @buffer: the preallocated buffer to beused.
 32  * @size: the size of the internal buffer,this have to be a power of 2.
 33  * @gfp_mask: get_free_pages mask, passed tokmalloc()
 34  * @lock: the lock to be used to protect thefifo buffer
 35  *
 36  * Do NOT pass the kfifo to kfifo_free() afteruse! Simply free the
 37  * &struct kfifo with kfree().
 38  */
 39 struct kfifo*kfifo_init(unsigned char *buffer, unsigned int size,
 40              gfp_t gfp_mask, spinlock_t *lock)
 41 {
 42     struct kfifo *fifo;
 43
44     /* size must be a power of 2 */
 45     BUG_ON(!is_power_of_2(size));
 46
 47     fifo = kmalloc(sizeof(struct kfifo),gfp_mask);
 48     if (!fifo)
 49         return ERR_PTR(-ENOMEM);
 50
 51     fifo->buffer = buffer;
 52     fifo->size = size;
 53     fifo->in = fifo->out = 0;
 54     fifo->lock = lock;
 55
 56     return fifo;
 57 }

3. __kfifo_put和__kfifo_get，巧妙的入队和出队操作，无锁并发

__kfifo_put是入队操作，它先将数据放入buffer里面，最后才修改in参数；__kfifo_get是出队操作，它先将数据从buffer中移走，最后才修改out。你会发现in和out两者各司其职。

  unsigned int__kfifo_put(struct kfifo *fifo,  
                unsigned char *buffer, unsigned int len)  
    {  
        unsignedint l;  
        len =min(len, fifo->size - fifo->in + fifo->out);       
        /* 
         * Ensurethat we sample the fifo->out index -before- we 
         * startputting bytes into the kfifo. 
         */  
       smp_mb();  
        /* firstput the data starting from fifo->in to buffer end */  
        l =min(len, fifo->size - (fifo->in & (fifo->size - 1)));  
       memcpy(fifo->buffer + (fifo->in & (fifo->size - 1)),buffer, l);   
        /* then putthe rest (if any) at the beginning of the buffer */  
       memcpy(fifo->buffer, buffer + l, len - l);     
        /* 
         * Ensurethat we add the bytes to the kfifo -before- 
         * weupdate the fifo->in index. 
         */      
       smp_wmb();       
        fifo->in+= len;   //每次累加，到达最大值后溢出，自动转为0   
       returnlen;   
    } 
    
    unsigned int__kfifo_get(struct kfifo *fifo,  

                unsigned char *buffer, unsigned int len)  

   {  
       unsignedint l;  
        len =min(len, fifo->in - fifo->out);  
        /* 
         * Ensurethat we sample the fifo->in index -before- we 
         * startremoving bytes from the kfifo. 
         */  
       smp_rmb();       
        /* firstget the data from fifo->out until the end of the buffer */  
        l =min(len, fifo->size - (fifo->out & (fifo->size - 1)));  
       memcpy(buffer, fifo->buffer + (fifo->out & (fifo->size -1)), l);      
        /* then getthe rest (if any) from the beginning of the buffer */  
       memcpy(buffer + l, fifo->buffer, len - l);  
       /* 
         * Ensurethat we remove the bytes from the kfifo -before- 
         * weupdate the fifo->out index. 
         */       
       smp_mb();       
      fifo->out += len;   //每次累加，到达最大值后溢出，自动转为0     
        returnlen;  
    }   

        从上面的代码发现，put和get是非常精简的，下面分情况讨论函数的执行过程：

        队列的队头队尾下标不受队列长度的限制，就算队头下标大于队列长度，也一样可以使用，原理就在于，数据不是全部放在队头(fifo->out)和队尾(fifo->in)之间的内存空间，而是把超出队头队尾之间长度的数据放到整个队列buffer的开始处

1、入队操作    

         蓝色部分为真实数据所在内存段，白色部分其实为逻辑上假定的数据所在地，也就是说，为了给用户一种真正的队列感觉——从尾部推进数据，从头部拉取数据，那么就必须让fifo->out和fifo->in只能一直往一个方向推进，但是由于fifo所分配的buffer是有限的一段连续内存，fifo->out和fifo->in迟早要“越界”（这里的越界是in和out大于size，in和out是整数，是相对于buffer的偏移量）， 入队列的操作，保证fifo->out和fifo->in是一直往右推进的。

        如果fifo->in小于buffer->size，那么先放完buffer->size-fifo->in这段内存空间，剩下的部分，转移到buffer的可用空间开头存放；如果fifo->in大于buffer->size，那么直接把要入队列的数据放到buffer可用空间开头。

     在put的函数中，有两次取值min和两次memcpy,

         情况1、如果fifo->in小于fifo->size,并且in和out都没有越界（都小于size）

         那么第一个min中的fifo->size-fifo->in+fifo->out是队列空余的空间大小（这里要求所存放的字符串长度小于队列空余大小）

         第二个min中的fifo->in &(fifo->size - 1)是in相对于buffer的偏移位置

         如果从in开始到队列末尾便可存放字符串，第一个min取len，第二个min取len，第一个memcpy是从buffer的in开始拷贝len个字符，第二个memcpy拷贝0个字符。

        如果从in开始到队列末尾不能存放所有的字符，第一个min取值为len，第二个min取值fifo->size- (fifo->in & (fifo->size - 1)),也就是从in到队列末尾的大小；第一个memcpy是讲队列从in开始到队列末尾填充满，填充的长度也就是l，第二个memcpy是从队列开始填充剩余的len-l长度的字符串。

          in累加len的长度，in一直累加，这也是一个巧妙之处，是利用了unsigned int 的回环。

  情况2、如果fifo->in小于fifo->size, out没有越界，in超过了size

          如果in一旦超多size，那么队列的开头一定存放了数据，并且队列末尾没有空余，将数据存放到对垒开始的地方。

          那么第一个min中的fifo->size-fifo->in+fifo->out是队列空余的空间大小

          第二个min中的fifo->in& (fifo->size - 1)是in相对于buffer的偏移位置 

          这个时候fifo->in > fifo->out，但是fifo->in & (fifo->size - 1)  < fifo->out

         此时需要从队列的开始存放数据，第一个min取len，第二个min取len，因为此时fifo->size- (fifo->in & (fifo->size - 1))肯定小于fifo->size-fifo->in+fifo->out；第一个memcpy是从队列开头的in存放len的字节，第二个memcpy不拷贝字节。

       情况3、如果fifo->in小于fifo->size, out没有越界，in和out都超过了size

         这种情况的复制情况和上面一样，都是第一次直接拷贝结束。

        分析，因为我们只考虑了放，没有考虑取，在取的过程也是Out一直累加，如果累加到超过了unsigned  int，那么又从0开始赋值。同时里面关于in和out的操作都是和size取模运算，所以in和out都会在size范围内。这也是笼统的理解，但是这个理解是正确的。

        在put的过程中，只要字符串长度小于队列空余空间大小，in和Out无论从数值上怎么越界，第一个min取值为len，第二个min中的fifo->size- (fifo->in & (fifo->size - 1))一定是从in偏移量开始到队列末尾的空余大小，这个值和len相比较，取其中较小者，换句话说，如果从in开始到队列末尾的空余空间长度大于字符串长度，那么第一个memcpy搞定一切，第二个memcpy不再从buffer的头部开始复制数据；如果从in开始到队列末尾的空余空间大小小于字符串长度，那么从in开始的空间先复制满，然后从空开始复制剩余的字符。无论哪种情况都是这个过程。

    2、对于get函数

      情况1：fifo->in大于fifo->size而fifo->out小于fifo->size（即只有fifo->in“越界”），则先读取fifo->out到fifo->size-1的那一段,大小为l个byte，然后再读取剩下的从buffer开头，大小为len-l个byte的数据（如下图所示，即先读data A段, 再读出data B段）；

       情况2：fifo->in和fifo->out都“越界”了，那么l = min(len, fifo->size - (fifo->out & (fifo->size -1))); 这一语句便起作用了，此时fifo->out&fifo->size-1的结果即实际要读的数据所在的内存地址相对于buffer起始地址的偏移值（如下图所示，左边为实际上存在于内存中的data A段, 而右边虚线框为逻辑上的data A段的位置）；

        分析：对于get的情况， 假设整个过程中fifo->in> fifo->out始终成立，并且假设get的字符串长度始终小于队列总数据的长度，第一个min的取值为min。第二个min中的fifo->size - (fifo->out & (fifo->size - 1))表示从out到队列末尾的字符串长度，如果这段字符串的长度大于len，那么第一个memcpy直接拷贝所要获取的字符串长度，第二个不拷贝，如果小于len的长度，从out开始拷贝到结束，然后从队列的开始拷贝剩余的字符串。

    整个过程一气呵成，巧妙！！