高级字符驱动程序操作之poll（实践篇）

1. scull.h 驱动程序由scullpipe改过来的

#ifndef _SCULL_H_
#define _SCULL_H_

#ifndef SCULL_P_NR_DEVS
#define SCULL_P_NR_DEVS 2
#endif

#ifndef SCULL_P_BUFFER
#define SCULL_P_BUFFER 4000
#endif

extern int scull_p_buffer;

int     scull_p_init(void);
void    scull_p_cleanup(void);

#endif /* _SCULL_H_ */

2. poll.c

#include <linux/module.h>
#include <linux/moduleparam.h>

#include <linux/kernel.h>	/* printk(), min() */
#include <linux/slab.h>		/* kmalloc() */
#include <linux/fs.h>		/* everything... */
#include <linux/proc_fs.h>
#include <linux/errno.h>	/* error codes */
#include <linux/types.h>	/* size_t */
#include <linux/fcntl.h>
#include <linux/poll.h>
#include <linux/cdev.h>
#include <asm/uaccess.h>

#include "scull.h"		/* local definitions */

struct scull_pipe {
wait_queue_head_t inq, outq;       /* read and write queues */
char *buffer, *end;                /* begin of buf, end of buf */
int buffersize;                    /* used in pointer arithmetic */
char *rp, *wp;                     /* where to read, where to write */
int nreaders, nwriters;            /* number of openings for r/w */
struct fasync_struct *async_queue; /* asynchronous readers */
struct semaphore sem;              /* mutual exclusion semaphore */
struct cdev cdev;                  /* Char device structure */
};

/* parameters */
static int scull_p_nr_devs = SCULL_P_NR_DEVS;	/* number of pipe devices */
int scull_p_buffer =  SCULL_P_BUFFER;	/* buffer size */
static int poll_major = 0;

static struct scull_pipe *scull_p_devices;

static int spacefree(struct scull_pipe *dev);

static int scull_p_open(struct inode *inode, struct file *filp)
{
struct scull_pipe *dev;

dev = container_of(inode->i_cdev, struct scull_pipe, cdev);
filp->private_data = dev;

if (down_interruptible(&dev->sem))
return -ERESTARTSYS;
if (!dev->buffer) {
/* allocate the buffer */
dev->buffer = kmalloc(scull_p_buffer, GFP_KERNEL);
if (!dev->buffer) {
up(&dev->sem);
return -ENOMEM;
}
}
dev->buffersize = scull_p_buffer;
dev->end = dev->buffer + dev->buffersize;
dev->rp = dev->wp = dev->buffer; /* rd and wr from the beginning */

/* use f_mode,not  f_flags: it's cleaner (fs/open.c tells why) */
if (filp->f_mode & FMODE_READ)
dev->nreaders++;
if (filp->f_mode & FMODE_WRITE)
dev->nwriters++;
up(&dev->sem);

return nonseekable_open(inode, filp);
}

static int scull_p_release(struct inode *inode, struct file *filp)
{
struct scull_pipe *dev = filp->private_data;

down(&dev->sem);
if (filp->f_mode & FMODE_READ)
dev->nreaders--;
if (filp->f_mode & FMODE_WRITE)
dev->nwriters--;
if (dev->nreaders + dev->nwriters == 0) {
kfree(dev->buffer);
dev->buffer = NULL; /* the other fields are not checked on open */
}
up(&dev->sem);
return 0;
}

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;

if (wait_event_interruptible(dev->inq, (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)) {
up (&dev->sem);
return -EFAULT;
}
dev->rp += count;
if (dev->rp == dev->end)
dev->rp = dev->buffer; /* wrapped */
up (&dev->sem);

/* finally, awake any writers and return */
wake_up_interruptible(&dev->outq);

return count;
}

static int scull_getwritespace(struct scull_pipe *dev, struct file *filp)
{
while (spacefree(dev) == 0) { /* full */
DEFINE_WAIT(wait);

up(&dev->sem);
if (filp->f_flags & O_NONBLOCK)
return -EAGAIN;

prepare_to_wait(&dev->outq, &wait, TASK_INTERRUPTIBLE);
if (spacefree(dev) == 0)
schedule();
finish_wait(&dev->outq, &wait);
if (signal_pending(current))
return -ERESTARTSYS; /* signal: tell the fs layer to handle it */
if (down_interruptible(&dev->sem))
return -ERESTARTSYS;
}
return 0;
}

/* How much space is free? */
static int spacefree(struct scull_pipe *dev)
{
if (dev->rp == dev->wp)
return dev->buffersize - 1;
return ((dev->rp + dev->buffersize - dev->wp) % dev->buffersize) - 1;
}

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

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);  /* blocked in read() and select() */

return count;
}

static unsigned int scull_p_poll(struct file *filp, poll_table *wait)
{
struct scull_pipe *dev = filp->private_data;
unsigned int mask = 0;

down(&dev->sem);
poll_wait(filp, &dev->inq,  wait);
poll_wait(filp, &dev->outq, wait);
if (dev->rp != dev->wp)
mask |= POLLIN | POLLRDNORM;	/* readable */
if (spacefree(dev))
mask |= POLLOUT | POLLWRNORM;	/* writable */
up(&dev->sem);
return mask;
}

struct file_operations scull_pipe_fops = {
.owner =	THIS_MODULE,
.llseek =	no_llseek,
.read =		scull_p_read,
.write =	scull_p_write,
.poll =		scull_p_poll,
.open =		scull_p_open,
.release =	scull_p_release,
};

int scull_p_init(void)
{
int result;
int i;
dev_t dev = 0;
struct scull_pipe *device;

if (poll_major) {
dev = MKDEV(poll_major, 0);
result = register_chrdev_region(dev, 1, "poll");
} else {
result = alloc_chrdev_region(&dev, 0, 1, "poll");
poll_major = MAJOR(dev);
}
if (result < 0) {
return result;
}

scull_p_devices = kmalloc(scull_p_nr_devs * sizeof(struct scull_pipe), GFP_KERNEL);
if (scull_p_devices == NULL) {
result = -ENOMEM;
goto fail;
}
memset(scull_p_devices, 0, scull_p_nr_devs * sizeof(struct scull_pipe));
for (i = 0; i < scull_p_nr_devs; i++) {
init_waitqueue_head(&(scull_p_devices[i].inq));
init_waitqueue_head(&(scull_p_devices[i].outq));
init_MUTEX(&scull_p_devices[i].sem);

device = scull_p_devices + i;
cdev_init(&device->cdev, &scull_pipe_fops);
device->cdev.owner = THIS_MODULE;
cdev_add(&device->cdev, dev + i, 1);
}

return scull_p_nr_devs;

fail:
scull_p_cleanup();
return result;
}

void scull_p_cleanup(void)
{
int i;
dev_t devno;
devno = MKDEV(poll_major, 0);

if (!scull_p_devices)
return;

for (i = 0; i < scull_p_nr_devs; i++) {
cdev_del(&scull_p_devices[i].cdev);
kfree(scull_p_devices[i].buffer);
}
kfree(scull_p_devices);
unregister_chrdev_region(devno, scull_p_nr_devs);
scull_p_devices = NULL; /* pedantic */
}

MODULE_AUTHOR("victorsummer");
MODULE_LICENSE("Dual BSD/GLP");

module_init(scull_p_init);
module_exit(scull_p_cleanup);

3. Makefile

KERNELDIR = /usr/src/linux-headers-2.6.31-14-generic
PWD := $(shell pwd)

obj-m := poll.o

modules:
$(MAKE) -C $(KERNELDIR) M=$(PWD) modules

4. poll_testw.c 带参数，0表示打开第一设备，1表示打开第二个设备

#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

int main(int argc, char **argv)
{
char *write_buffer = "Hello, Character driver!";
int poll_fd;
int code;

if(argc == 2 && !strcmp(argv[1],"1"))

poll_fd = open("/dev/poll_pipe1", O_WRONLY);
else if(argc == 2 && !strcmp(argv[1],"0"))
poll_fd = open("/dev/poll_pipe0", O_WRONLY);
else
{
printf("You have to input option 0, 1 or all! /n");
return;
}

while(*write_buffer != '/0')
{
code = write(poll_fd , write_buffer , 24);
printf("Write %d bytes to polltest/n", code);
write_buffer += code;
}

close(poll_fd);

exit(0);
}

5. poll_testr.c

#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <stdio.h>
#include <linux/poll.h>

int main()
{
int polltest0, polltest1;

int retval;
struct pollfd poll_list[2];

polltest0 = open("/dev/poll_pipe0", O_RDONLY);
polltest1 = open("/dev/poll_pipe1", O_RDONLY);

poll_list[0].fd = polltest0;
poll_list[1].fd = polltest1;
poll_list[0].events = POLLIN | POLLRDNORM;
poll_list[1].events = POLLIN | POLLRDNORM;

while(1)
{
retval = poll(poll_list, 2, -1);

if(retval < 0)
{
printf("Error in poll! /n");
return -1;
}

if(poll_list[0].revents&(POLLIN | POLLRDNORM))
{
char *read_buffer = malloc(sizeof(char)*30);
if (read(polltest0, read_buffer, 24) != -1)
{
printf("read %s from polltest0 /n", read_buffer);
}
free(read_buffer);
}

if(poll_list[1].revents&(POLLIN | POLLRDNORM))
{
char *read_buffer = malloc(sizeof(char)*30);
if (read(polltest1, read_buffer, 24) != -1)
{
printf("read %s from polltest1 /n", read_buffer);
}
free(read_buffer);
}
}

close(polltest0 );
close(polltest1 );

exit(0);
}

6. Makefile

all : poll_testw.o poll_testr.o
gcc -o poll_testw.o poll_testw.c
gcc -o poll_testr.o poll_testr.c

7. 开始测试

装载驱动程序

sudo insmod ./poll.ko

查看主设备号，这里假设为251

cat /proc/devices

建立设备节点

sudo mknod /dev/poll_pipe0 c 251 0

sudo mknod /dev/poll_pipe1 c 251 1

更改权限

sudo chgrp staff /dev/poll_pipe[0-1]

sudo chmod 664 /dev/poll_pipe[0-1]

在第一个终端打开读程序，程序阻塞在poll函数

sudo ./poll_testr.o

在第二个终端打开带参数为0的写程序

sudo ./poll_testw.o 0

结果：

第二个终端打印：Write 24 bytes to polltest

第一个终端打印：read Hello, Character driver! from polltest0

接着在第二个终端打开参数为1的写程序

sudo ./poll_testw.o 1

结果：

第二个终端打印：Write 24 bytes to polltest

第一个终端打印：read Hello, Character driver! from polltest1