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

1. scull_pipe.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> 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 semaphore sem; /* mutual exclusion semaphore */ struct cdev cdev; /* Char device structure */ }; /* parameters */ int scull_p_buffer = 4000; /* buffer size */ static int pipe_major = 0; static struct scull_pipe *pdev = NULL; static int spacefree(struct scull_pipe *dev); void pipe_cleanup(void); static int pipe_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 pipe_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 pipe_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; } /* Wait for space for writing; caller must hold device semaphore. On * error the semaphore will be released before returning. */ static int 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 pipe_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 = 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; } struct file_operations pipe_fops = { .owner = THIS_MODULE, .read = pipe_read, .write = pipe_write, .open = pipe_open, .release = pipe_release, }; int pipe_init(void) { int result; dev_t dev = 0; if (pipe_major) { dev = MKDEV(pipe_major, 0); result = register_chrdev_region(dev, 1, "pipe0"); } else { result = alloc_chrdev_region(&dev, 0, 1, "pipe0"); pipe_major = MAJOR(dev); } if (result < 0) { return result; } pdev = kmalloc(sizeof(struct scull_pipe), GFP_KERNEL); if (!pdev) { result = -ENOMEM; goto fail; /* Make this more graceful */ } memset(pdev, 0, sizeof(struct scull_pipe)); init_waitqueue_head(&(pdev->inq)); init_waitqueue_head(&(pdev->outq)); init_MUTEX(&(pdev->sem)); cdev_init(&(pdev->cdev), &pipe_fops); (pdev->cdev).owner = THIS_MODULE; cdev_add(&(pdev->cdev), dev, 1); return 0; fail: pipe_cleanup(); return result; } void pipe_cleanup(void) { dev_t devno; devno = MKDEV(pipe_major, 0); if (!pdev) return; /* nothing else to release */ cdev_del(&(pdev->cdev)); kfree(pdev->buffer); kfree(pdev); pdev = NULL; /* pedantic */ unregister_chrdev_region(devno, 1); } MODULE_AUTHOR("victorsummer"); MODULE_LICENSE("Dual BSD/GPL"); module_init(pipe_init); module_exit(pipe_cleanup);

 

2. Makefile

 

KERNELDIR = /usr/src/linux-headers-2.6.31-14-generic PWD := $(shell pwd) obj-m := scull_pipe.o modules: $(MAKE) -C $(KERNELDIR) M=$(PWD) modules

 

3. pipe_testr.c 从pipe0读取8个字节

 

#include <unistd.h> #include <sys/stat.h> #include <fcntl.h> #include <stdlib.h> #include <stdio.h> int main() { char *read_buffer = malloc(sizeof(char*)*30); int pipe_fd; int code; int back = 0; pipe_fd = open("/dev/pipe0", O_RDONLY); if((code = read(pipe_fd , read_buffer , 8)) != -1) { printf("Read %d bytes from scull/n", code); read_buffer += code; back += code; } read_buffer -= back; printf("Read /"%s/" from scull /n", read_buffer); close(pipe_fd); exit(0); }

 

4. pipe_testw 向pipe0写入24个字节

 

#include <unistd.h> #include <sys/stat.h> #include <fcntl.h> #include <stdlib.h> #include <stdio.h> int main() { char *write_buffer = "Hello, Character driver!"; int pipe_fd; int code; pipe_fd = open("/dev/pipe0", O_WRONLY); while(*write_buffer != '/0') { code = write(pipe_fd , write_buffer , 24); printf("Write %d bytes to scull/n", code); write_buffer += code; } close(pipe_fd); exit(0); }

 

5. Makefile

 

all : pipe_testw.o pipe_testr.o gcc -o pipe_testw.o pipe_testw.c gcc -o pipe_testr.o pipe_testr.c

 

6. 测试

 

装载驱动模块

sudo insmod ./scull_pipe.ko

 

查看主设备号，假设为251

cat /proc/devices

 

建立设备节点

sudo mknod /dev/pipe0 c 251 0

 

更改权限

sudo chgrp staff /dev/pipe0

sudo chmod 664 /dev/pipe0

 

开启四个终端

 

分别在终端1，2，3 运行三个pipe_testr.o

现在没有数据，全部进入休眠

 

在终端4运行pipe_testw.o

终端4打印

Write 24 bytes to scull

首先运行在终端1的读进程被唤醒 打印

Read 8 bytes from scull
Read "Hello, C" from scull

接着运行在终端2的读进程被唤醒 打印

Read 8 bytes from scull
Read "haracter" from scull

最后运行在终端3的读进程被唤醒 打印

Read 8 bytes from scull
Read " driver!" from scull