Linux设备驱动读写FIFO

把设备驱动中的全局内存变成一个FIFO,只有当 FIFO 中有数据的时候（即有进程把数据写到这个 FIFO 而且没有被读进程读空），读进程才能把数据读出，而且读取后的数据会从全局内存中被拿掉； 只有当 FIFO 非满时（即还有一些空间未被写，或写满后被读进程从这个 FIFO 中读出了数据），写进程才能往这个 FIFO 中写入数据。

#define BUF_SIZE     15
struct demo_device{
    char *buffer;
    int value;
    struct miscdevice *mdev;
    wait_queue_head_t r_wait;
    wait_queue_head_t w_wait;
    unsigned int current_len;
    struct mutex lock;
};

BUF_SIZE表示内存大小为15，current_len 成员用于表征目前FIFO 中有效数据的长度。wait_queue_head_t r_wait声明阻塞读用的等待队列头 wait_queue_head_t w_waits声明阻塞写用的等待队列头。struct mutex lock声明并发控制用的信号量。

在设备驱动模块加载函数中初始化上述变量，此处省略。

1.增加等待队列后的读函数

static ssize_t demo_read(struct file *file, char __user *buf, size_t size, loff_t *pos){

	struct demo_device* demo=file->private_data;
    printk(KERN_INFO"Enter:%s\n",__func__);

   //lock
    if(mutex_lock_interruptible(&demo->lock)){
        return -ERESTARTSYS;
    } 
    //whether no data
    while(demo->current_len==0){
        mutex_unlock(&demo->lock);
        if(file->f_flags&O_NONBLOCK){
            return -EAGAIN;
        }
        if(wait_event_interruptible(demo->r_wait,(demo->current_len>0))){
            return -ERESTARTSYS;
        }
        if(mutex_lock_interruptible(&demo->lock)){
            return -ERESTARTSYS;
        }
    }
    //begin to read
    if(size>demo->current_len){
        size = demo->current_len;
    }
    if(copy_to_user(buf,demo->buffer,size)){
        mutex_unlock(&demo->lock);
        return -EFAULT;
    }
    else{
        memcpy(demo->buffer,demo->buffer+size,demo->current_len-size);
        demo->current_len-=size;
        wake_up_interruptible(&demo->w_wait);
        mutex_unlock(&demo->lock);
    }
    return size;

}

（1）判断队列是否为空

while(demo->current_len==0)表示队列为空，此时没有数据可以读出。然后通过file->f_flags标志获得用户空间是否要求非阻塞访问。然后进行不同处理。如果是非阻塞访问，则立即返回：return -EAGAIN;。（注意在返回之前要先解锁，否则会造成进程死锁）如果是阻塞访问，则wait_event_interruptible(demo->r_wait, demo->current_len>0)表示进入阻塞状态，解除阻塞状态的条件是current_len>0,即有数据可以读。

（2）开始读取数据

if(size>demo->current_len)首先判断用户想要读取的数据量是否超过内存已有数据量，做限制处理。size = demo->current_len。然后用函数copy_to_user将数据复制到用户空间。

然后进行最重要的步骤：memcpy(demo->buffer,demo->buffer+size,demo->current_len-size)将内存中的剩余数据整体移动到内存前部。然后将current_len指向剩余数据末端，比如：current_len的值为5，代表有效数据量为5。然后用户读出了3个数据。读取完成后，将剩余的两个数据复制到数组最前面，即buffer[0]=buffer[3],buffer[1]=buffer[4],然后将current_len值变为2，表示有效数据量为2。wake_up_interruptible(&demo->w_wait)用以唤醒写操作进程。

读者可以仔细揣摩当中的精妙所在。

2.增加等待队列后的写函数

static ssize_t demo_write(struct file *file, const char __user *buf, size_t size, loff_t *pos){

    struct demo_device* demo=file->private_data;
    printk(KERN_INFO"Enter:%s\n",__func__);
   //lock
    if(mutex_lock_interruptible(&demo->lock)){
        return -ERESTARTSYS;
    } 
    //full of data
    while(demo->current_len==BUF_SIZE){
        mutex_unlock(&demo->lock);
        if((file->f_flags)&O_NONBLOCK){
            return -EAGAIN;
        }
        if(wait_event_interruptible(demo->w_wait,(demo->current_len<BUF_SIZE))){
            return -ERESTARTSYS;
        }
        if(mutex_lock_interruptible(&demo->lock)){
            return -ERESTARTSYS;
        }
    }
    //begin to write
    if(size>BUF_SIZE-demo->current_len){
        size = BUF_SIZE-demo->current_len;
    }
    if(copy_from_user(demo->buffer+demo->current_len,buf,size)){
        mutex_unlock(&demo->lock);
        return -EFAULT;
    }
    else{
        demo->current_len+=size;
        wake_up_interruptible(&demo->r_wait);
        mutex_unlock(&demo->lock);
    }
    return size;
}

FIFO对应的写操作其实是与读操作相反的操作，此处介绍后半段。

if(size>BUF_SIZE-demo->current_len)用户要写入的数据量不能超过剩余可写数据量BUF_SIZE-current_len。

调用copy_from_user(demo->buffer+demo->current_len,buf,size),从current_len处写入数据。写入完成后将current_len指向可用数据尾部，最后唤醒读函数，返回成功写入的字节数size。