linux驱动开发学习二：创建一个阻塞型的字符设备

#include <linux/module.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/cdev.h>
#include <linux/slab.h>
#include <linux/uaccess.h>
#include <linux/delay.h>
#include <linux/wait.h>
#include <linux/sched/signal.h>

#define GLOBALMEM_SIZE 0X1000
#define MEM_CLEAR 0X1
#define GLOBALMEM_MAJOR 230

static int globalmem_major=GLOBALMEM_MAJOR;
module_param(globalmem_major,int,S_IRUGO);

struct globalmem_dev{
    struct cdev cdev;
    unsigned char mem[GLOBALMEM_SIZE];
    struct mutex mutex;
    unsigned int current_len;
    wait_queue_head_t r_wait;
    wait_queue_head_t w_wait;
};

struct globalmem_dev *globalmem_devp;

static int globalmem_open(struct inode *inode,struct file *filp)
{
    filp->private_data=globalmem_devp;
    return 0;
}


static int globalmem_release(struct inode *inode,struct file *filp)
{
    return 0;
}

static long globalmem_ioctl(struct file *filp,unsigned int cmd,unsigned long arg)
{
    struct globalmem_dev *dev=filp->private_data;
    switch(cmd)
    {
        case MEM_CLEAR:
            mutex_lock(&dev->mutex);
            memset(dev->mem,0,GLOBALMEM_SIZE);
            printk(KERN_INFO "globalmem is set to zero\n");
            mutex_unlock(&dev->mutex);
        default:
            return -EINVAL;
    }
    return 0;
}


static ssize_t globalmem_read_queue(struct file *filp,char __user *buf,size_t size,loff_t *ppos)
{
    int ret;
    struct globalmem_dev *dev=filp->private_data;
    DECLARE_WAITQUEUE(wait,current);
    mutex_lock(&dev->mutex);
    add_wait_queue(&dev->r_wait,&wait);
    while(dev->current_len == 0){
        if(filp->f_flags & O_NONBLOCK){
            ret=-EAGAIN;
            goto out;
        }
        __set_current_state(TASK_INTERRUPTIBLE);
        mutex_unlock(&dev->mutex);
        schedule();
        if(signal_pending(current)){
            ret=-ERESTARTSYS;
            goto out2;
        }
        mutex_lock(&dev->mutex);
    }
    if(size > dev->current_len)
        size=dev->current_len;
    if(copy_to_user(buf,dev->mem,size)){
        printk("copy_to_user_fail\n");
        ret=-EFAULT;
        goto out;
    }else{
        memcpy(dev->mem,dev->mem+size,dev->current_len-size);
        dev->current_len-=size;
        wake_up_interruptible(&dev->w_wait);
        ret=size;
    }
    out:
        mutex_unlock(&dev->mutex);
    out2:
        remove_wait_queue(&dev->w_wait,&wait);
        set_current_state(TASK_RUNNING);

    return ret;
}


static ssize_t globalmem_write_queue(struct file *filp,const char __user *buf,size_t size, loff_t *ppos)
{
    int ret;
    struct globalmem_dev *dev=filp->private_data;
    DECLARE_WAITQUEUE(wait,current);
    mutex_lock(&dev->mutex);
    add_wait_queue(&dev->w_wait,&wait);
    while(dev->current_len == GLOBALMEM_SIZE){
        if(filp->f_flags & O_NONBLOCK){
            ret=-EAGAIN;
            goto out;
        }
        __set_current_state(TASK_INTERRUPTIBLE);
        mutex_unlock(&dev->mutex);
        schedule();
        if(signal_pending(current)){
            ret=-ERESTARTSYS;
            goto out2;
        }
        mutex_lock(&dev->mutex);
    } 
    if(size > GLOBALMEM_SIZE- dev->current_len)
        size=GLOBALMEM_SIZE - dev->current_len;
    if(copy_from_user(dev->mem+dev->current_len,buf,size)){
        ret=-EFAULT;
        goto out;
    }else{
        dev->current_len+=size;
        wake_up_interruptible(&dev->r_wait);
        ret=size;
    }
    out:
        mutex_unlock(&dev->mutex);
    out2:
        remove_wait_queue(&dev->w_wait,&wait);
        set_current_state(TASK_RUNNING);
    return ret;
}


static loff_t globalmem_llseek(struct file *filp,loff_t offset,int orig)
{
    loff_t ret=0;
    switch(orig){
        case 0:
            if (offset < 0)
                ret=-EFAULT;
                break;
            if ((unsigned int)offset > GLOBALMEM_SIZE){
                ret=-EFAULT;
                break;
            }
            filp->f_pos=(unsigned int)offset;
            ret=filp->f_pos;
            break;
        case 1:
            if((filp->f_pos+offset) > GLOBALMEM_SIZE){
                ret=-EFAULT;
                break;
            }
            if((filp->f_pos+offset) < 0){
                ret=-EFAULT;
                break;
            }
            filp->f_pos+=offset;
            ret=filp->f_pos;
            break;
    }
    return ret;
}

static const struct file_operations globalmem_fops={
    .owner=THIS_MODULE,
    .llseek=globalmem_llseek,
    .read=globalmem_read_queue,
    .write=globalmem_write_queue,
    .unlocked_ioctl=globalmem_ioctl,
    .open=globalmem_open,
    .release=globalmem_release,
};


static void globalmem_setup_dev(struct globalmem_dev *dev,int index)
{
    int err,devno=MKDEV(globalmem_major,index);
    cdev_init(&dev->cdev,&globalmem_fops);
    dev->cdev.owner=THIS_MODULE;
    err=cdev_add(&dev->cdev,devno,1);
    if(err)
        printk(KERN_NOTICE "Error %d adding globalmem%d",err,index);
}

static int __init globalmem_init(void)
{
    int ret;
    dev_t devno=MKDEV(globalmem_major,0);
    printk("devno=%d\n",devno);
    if(globalmem_major)
        ret=register_chrdev_region(devno,1,"globalmem_tmp");
    else{
        ret=alloc_chrdev_region(&devno,0,1,"globalmem_tmp");
        globalmem_major=MAJOR(devno);
    }
    if(ret < 0)
        return ret;
    globalmem_devp=kzalloc(sizeof(struct globalmem_dev),GFP_KERNEL);
    if(!globalmem_devp){
        ret=-EFAULT;
        goto fail_malloc;
    }

    mutex_init(&globalmem_devp->mutex);
    globalmem_setup_dev(globalmem_devp,0);
    printk("globalmem init success\n");
    init_waitqueue_head(&globalmem_devp->r_wait);
    init_waitqueue_head(&globalmem_devp->w_wait);
    return 0;
    fail_malloc:
        unregister_chrdev_region(devno,1);
        return ret;
}


module_init(globalmem_init);

static void __exit globalmem_exit(void)
{
    cdev_del(&globalmem_devp->cdev);
    kfree(globalmem_devp);
    unregister_chrdev_region(MKDEV(globalmem_major,0),1);
    printk("global_mem exited\n");
}

module_exit(globalmem_exit);

MODULE_AUTHOR("zhf");
MODULE_LICENSE("GPL");