linux 串口环形缓冲区,环形缓冲区的实现

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;

}