今天在看Linux內核的時候看到了等待隊列的環(huán)形緩沖區(qū)，這種方法在很多地方后都會用到，對于系統(tǒng)的優(yōu)化和執(zhí)行效率是百利無一害的，今天抽空以Linux代碼為例把環(huán)形緩沖區(qū)的實現做一次總結。

先通過自定義數據結構，對緩沖區(qū)做幾個基本的指針和參數進行定義：

char * buffer_start, *buffer_end ： 指向buffer起始端和結束端的指針

char wp ,rp ： 數據的讀寫指針

int buffersize ： buffer大小

調用內存分配函數kmalloc函數，為該數據結構申請內存空間，初始化結束后，數據的讀寫指針都指向char *buffer_star，對于緩沖區(qū)，我們可以做一下幾個rules:

1. *wp = *rp ：這個數據緩沖區(qū)是空的。對于讀操作，遇到這種情況讀操作應該會被阻塞，無數據可讀，讀進程進入睡眠等待狀態(tài)；對于寫操作，寫睡眠將被喚醒，可寫入的大小為整個buffer空間的大小

2. *wp > *rp ：緩沖區(qū)有數據可讀，可讀大小為wp-rp，讀進程不會不會被阻塞，而wp-rp=buffersize時，寫進程被阻塞進入睡眠，若wp-rp<buffersize時，寫進程不會被阻塞，buffer還有空間可以寫入

3. *wp< *rp： 如果wp rp指向buffer_end的時候，會自動反轉到buffer_start位置，可寫空間為rp-wp-1

通過阻塞和睡眠機制，我們可以實現對這個buffer的讀寫的同步，下面還是以代碼的方式講解一下讀寫同步的原理：

static ssize_t scull_p_read (struct file *filp, char __user *buf, size_t count, loff_t *f_pos)
{
     struct scull_pipe *dev = filp->private_data;

     if (down_interruptible(&dev->sem))                               //鎖定信號量
                return -ERESTARTSYS;

      while (dev->rp == dev->wp)
      { /* nothing to read */        //此時緩沖區(qū)為空，無數據可讀
               up(&dev->sem); /* release the lock */                  /*解鎖信號量，注意：必須在進入阻塞睡眠之前解 鎖信號量，準備進入睡眠*/
              if (filp->f_flags & O_NONBLOCK)
                    return -EAGAIN;
             PDEBUG("/"%s/" reading: going to sleep/n", current->comm);
              if (wait_event_interruptible(dev->inq, (dev->rp != dev->wp)))     /* 阻塞，進入睡眠，當dev->rp != dev->wp這個條件被滿足的時候，喚醒睡眠，這個睡眠應 該   在 寫操作中被喚醒*/
                    return -ERESTARTSYS; /* signal: tell the fs layer to handle it */
  /* otherwise loop, but first reacquire the lock */
              if (down_interruptible(&dev->sem))            /* 如果被喚醒，則重新鎖定信號量，進行數據讀取*/
                    return -ERESTARTSYS;
      }
 /* ok, data is there, return something */
      if (dev->wp > dev->rp)
             count = min(count, (size_t)(dev->wp - dev->rp));
      else /* the write pointer has wrapped, return data up to dev->end */
             count = min(count, (size_t)(dev->end - dev->rp));
      if (copy_to_user(buf, dev->rp, count)) 
        {   /*i在rp>wp情況下，本次操作不能一次性讀取buffer里面所有的數據*/
            up (&dev->sem);                  /*必須分兩次讀取，第一次只讀到end-rp,第二次讀到wp-start*/
            return -EFAULT;
        }
      dev->rp += count;         /*count值已經被處理過，保證dev->rp += count不會超過buffer_end*/

      if (dev->rp == dev->end)
      dev->rp = dev->buffer; /* wrapped */
      up (&dev->sem);

 /* finally, awake any writers and return */
      wake_up_interruptible(&dev->outq);              /*讀取結束后完成指針的更新，喚醒寫睡眠*/
      PDEBUG("/"%s/" did read %li bytes/n",current->comm, (long)count);
      return count;
}

static ssize_t scull_p_write(struct file *filp, const char __user *buf, size_t count,
                loff_t *f_pos)
{
    struct scull_pipe *dev = filp->private_data;
    int result;

    if (down_interruptible(&dev->sem))
             return -ERESTARTSYS;

 /* Make sure there's space to write */
    result = scull_getwritespace(dev, filp);             /*測試是否還有可寫入的空間*/
    if (result)
             return result; /* scull_getwritespace called up(&dev->sem) */

 /* ok, space is there, accept something */
     count = min(count, (size_t)spacefree(dev));         /*如果有，察看還有多少空間可寫*/
     if (dev->wp >= dev->rp)
          count = min(count, (size_t)(dev->end - dev->wp)); /* to end-of-buf */  /*似乎還有一小段空間沒有寫入*/
     else /* the write pointer has wrapped, fill up to rp-1 */
     count = min(count, (size_t)(dev->rp - dev->wp - 1));
     PDEBUG("Going to accept %li bytes to %p from %p/n", (long)count, dev->wp, buf);
     if (copy_from_user(dev->wp, buf, count)) 
     {
        up (&dev->sem);
        return -EFAULT;
     }
     dev->wp += count;
     if (dev->wp == dev->end)
         dev->wp = dev->buffer; /* wrapped */                     /*更新寫指針*/
     up(&dev->sem);

 /* finally, awake any reader */
     wake_up_interruptible(&dev->inq);  /*寫完之后必定有數據可讀，喚醒讀睡眠*/

 /* and signal asynchronous readers, explained late in chapter 5 */
     if (dev->async_queue)
           kill_fasync(&dev->async_queue, SIGIO, POLL_IN);
     PDEBUG("/"%s/" did write %li bytes/n",current->comm, (long)count);
     return count;
}