信号量，等待队列，异步通知，驱动例子

#include <linux/init.h>

#include <linux/module.h>

#include <linux/cdev.h>

#include <linux/fs.h>

#include <linux/types.h>

#include <linux/errno.h>

#include <linux/mm.h>

#include <linux/sched.h>

#include <asm/uaccess.h>

#include <linux/slab.h>

#include <linux/semaphore.h>

#include <linux/poll.h>

#define GLOBALMEM_SIZE 0X1000

#define MEM_CLEAR 0X1

#define GLOBALMEM_MAJOR 250

static int globalfifo_major = GLOBALMEM_MAJOR;

struct globalfifo_dev {

struct cdev cdev;

unsigned int current_len;

unsigned char mem[GLOBALMEM_SIZE];

struct semaphore sem;

wait_queue_head_t r_wait;

wait_queue_head_t w_wait;

struct fasync_struct *async_queue;

};

struct globalfifo_dev *globalfifo_devp = NULL;

int globalfifo_open(struct inode *inode, struct file *filp)

{

filp->private_data = globalfifo_devp;

return 0;

}

static int globalfifo_fasync(int fd, struct file *filp, int mode)

{

struct globalfifo_dev *dev = filp->private_data;

return fasync_helper(fd, filp, mode, &dev->async_queue);

}

int globalfifo_release(struct inode *inode, struct file *filp)

{

globalfifo_fasync(-1, filp, 0);

return 0;

}

static unsigned int globalfifo_poll(struct file *filp, poll_table *wait)

{

unsigned int mask = 0;

struct globalfifo_dev *dev = filp->private_data;

down(&dev->sem);

poll_wait(filp, &dev->r_wait, wait);

poll_wait(filp, &dev->w_wait, wait);

if(dev->current_len != 0)

mask |= POLLIN | POLLRDNORM;

if(dev->current_len != GLOBALMEM_SIZE)

mask |= POLLOUT | POLLWRNORM;

up(&dev->sem);

return mask;

}

static ssize_t globalfifo_read(struct file *filp, char __user *buf, size_t count, loff_t *ppos)

{

/* int ret;

int p = *ppos;

struct globalfifo_dev *dev = filp->private_data;

if(p > GLOBALMEM_SIZE)

return 0;

if(count > GLOBALMEM_SIZE - p)

count = GLOBALMEM_SIZE -p;

if(copy_to_user(buf, (void *)(dev->mem + p), count)){

ret = -EFAULT;

}else{

*ppos += count;

ret = count;

printk(KERN_INFO "read %u bytes form %u\n", count, p);

}

return ret;

*/

int ret = 0;

struct globalfifo_dev *dev = filp->private_data;

DECLARE_WAITQUEUE(wait, current);

down(&dev->sem);

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);

up(&dev->sem);

schedule();

if(signal_pending(current)){

ret = -ERESTARTSYS;

goto out2;

}

down(&dev->sem);

}

if(count > dev->current_len)

count = dev->current_len;

if(copy_to_user(buf, dev->mem, count)){

return -EFAULT;

goto out;

}else{

memcpy(dev->mem, dev->mem + count, dev->current_len - count);

dev->current_len -= count;

printk(KERN_INFO "read %u bytes form %u\n", count, dev->current_len);

}

wake_up_interruptible(&dev->w_wait);

ret = count;

out:

up(&dev->sem);

out2:

remove_wait_queue(&dev->r_wait, &wait);

set_current_state(TASK_RUNNING);

return ret;

}

static ssize_t globalfifo_write(struct file *filp, const char __user *buf, size_t count, loff_t *ppos)

{

/* unsigned long p = *ppos;

int ret = 0;

struct globalfifo_dev *dev = filp->private_data;

if(p >= GLOBALMEM_SIZE)

return 0;

if(count > GLOBALMEM_SIZE - p)

count = GLOBALMEM_SIZE -p;

if(copy_from_user(dev->mem + p, buf, count))

ret = -EFAULT;

else{

*ppos += count;

ret = count;

}

return ret;

*/

int ret = 0;

struct globalfifo_dev *dev = filp->private_data;

DECLARE_WAITQUEUE(wait, current);

down(&dev->sem);

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);

up(&dev->sem);

schedule();

if(signal_pending(current)){

ret = - ERESTARTSYS;

goto out2;

}

down(&dev->sem);

}

if(count > GLOBALMEM_SIZE - dev->current_len)

count = GLOBALMEM_SIZE -dev->current_len;

if(copy_from_user(dev->mem + dev->current_len, buf, count)){

return - EFAULT;

goto out;

}

else{

dev->current_len += count;

printk(KERN_INFO "writen %u bytes from %u\n", count, dev->current_len);

wake_up_interruptible(&dev->r_wait);

if(dev->async_queue)

kill_fasync(&dev->async_queue, SIGIO, POLL_IN);

ret = count;

}

out:

up(&dev->sem);

out2:

remove_wait_queue(&dev->w_wait, &wait);

set_current_state(TASK_RUNNING);

return ret;

}

static const struct file_operations globalfifo_fops = {

.owner = THIS_MODULE,

.read = globalfifo_read,

.write = globalfifo_write,

.open = globalfifo_open,

.release = globalfifo_release,

.poll = globalfifo_poll,

.fasync = globalfifo_fasync,

};

static void globalfifo_setup(struct globalfifo_dev *dev, int index)

{

int err, devno = MKDEV(globalfifo_major, index);

cdev_init(&dev->cdev, &globalfifo_fops);

dev->cdev.owner = THIS_MODULE;

err = cdev_add(&dev->cdev, devno, 1);

if(err)

printk(KERN_NOTICE "Error %d adding globalfifo %d", err, index);

}

int globalfifo_init(void)

{

int result;

dev_t devno = MKDEV(globalfifo_major, 0);

if(globalfifo_major)

result = register_chrdev_region(devno, 1, "globalfifo");

else{

result = alloc_chrdev_region(&devno, 0, 1, "globalfifo");

globalfifo_major = devno;

}

if(result < 0)

return result;

globalfifo_devp = kmalloc(sizeof(struct globalfifo_dev), GFP_KERNEL);

if(!globalfifo_devp){

result = -ENOMEM;

goto fail_malloc;

}

memset(globalfifo_devp, 0, sizeof(struct globalfifo_dev));

globalfifo_setup(globalfifo_devp, 0);

sema_init(&globalfifo_devp->sem, 1);

init_waitqueue_head(&globalfifo_devp->r_wait);

init_waitqueue_head(&globalfifo_devp->w_wait);

return 0;

fail_malloc:

unregister_chrdev_region(devno, 1);

return result;

}

void globalfifo_exit(void)

{

cdev_del(&globalfifo_devp->cdev);

kfree(globalfifo_devp);

unregister_chrdev_region(MKDEV(globalfifo_major, 0), 1);

}

module_init(globalfifo_init);

module_exit(globalfifo_exit);

MODULE_AUTHOR("EMPEROR IS TEST");

MODULE_LICENSE("GPL");

MODULE_DESCRIPTION("I LOVE YOU");