首先通過自定義數據結構，對緩衝區做幾個基本的指針和參數進行定義：
char * buffer_start, *buffer_end 指向buffer起始端和結束端的指針
char *wp ,*rp 數據的讀寫指針
int buffersize buffer大小
調用內存分配函數kmalloc函數，爲該數據結構申請內存空間，初始化結束後，數據的讀寫指針都指向char *buffer_star，對於緩衝區，我們可以做一下幾個rules:
1. *wp = *rp ：這個數據緩衝區是空的。對於讀操作，遇到這種情況讀操作應該會被阻塞，無數據可讀，讀進程進入睡眠等待狀態；對於寫操作，寫睡眠將被喚醒，可寫入的大小爲整個buffer空間的大小
2. *wp > *rp ：緩衝區有數據可讀，可讀大小爲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 */ 此時緩衝區爲空，無數據可讀
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;
}