scullpipe阻塞型设备

源码来自lddr3_examples/scullc/

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>
#include <linux/sched.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 */
	};


static int scull_p_nr_devs=SCULL_P_NR_DEVS;
int scull_p_buffer=SCULL_P_BUFFER;
dev_t scull_p_devno;

module_param(scull_p_nr_devs, int, 0);	/* FIXME check perms */
module_param(scull_p_buffer, int, 0);


static struct scull_pipe *scull_p_devices;

 static int scull_p_fasync(int fd, struct file *filp,int mode);
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;
	//³õʼ»¯devÀïÃæ³ÉÔ±
	if(!dev->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;
	//ÿ´Î´ò¿ªµÄʱºò¶ÁдµÄλÖö¼ÔÚbuffersµÄ¿ªÍ·
	dev->rp=dev->wp=dev->buffer;
	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;
	//Òì²½ÖжϵĶ«Î÷
	scull_p_fasync(-1,filp,&dev->async_queue);
	//ÊÍ·Å×ÊÔ´µÄʱºò£¬Ê¹Óò»¿ÉÖжϵÄ×ÔÐýËø¶«¶«
	down(&dev->sem);
	if(filp->f_mode &FMODE_READ)
		dev->nreaders--;
	if(filp->f_mode&FMODE_WRITE)
		dev->nwriters--;
	if((dev->nwriters+dev->nreaders)==0)
		{
			kfree(dev->buffer);
				dev->buffer=NULL;
				
		}
	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)
		{
			up(&dev->sem);
			if(filp->f_flags &O_NONBLOCK)
				return -EAGAIN;
			//¼ÓÈëµÈ´ý¶ÓÁÐ
			if(wait_event_interruptible(dev->inq,(dev->rp!=dev->wp)))
				return -ERESTARTSYS;
			if(down_interruptible(&dev->sem))
				return -ERESTARTSYS;
		}
	if(dev->wp>dev->rp)
		count=min(count,(size_t)(dev->wp-dev->rp));
	else
		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;
	//¸´ÖƺÃÊý¾ÝµÄʱºò ¸æËßÓû§³ÌÐò
	//»½ÐÑдµÈ´ý¶ÓÁеÄËùÓÐʼþ
	up(&dev->sem);
	wake_up_interruptible(&dev->outq);
	PDEBUG(""%s" did read %li bytesn",current->comm, (long)count);
	return count;
	
}

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 int scull_getwritespace(struct scull_pipe *dev,struct file*filp)
{
	  while(spacefree(dev)==0)//û¿Õ¼ä䶫Î÷ÁË
	  	{
	  		DEFINE_WAIT(wait);
			up(&dev->sem);
		if (filp->f_flags & O_NONBLOCK)
			return -EAGAIN;
		PDEBUG(""%s" writing: going to sleepn",current->comm);
			prepare_to_wait(&dev->outq,&wait,TASK_INTERRUPTIBLE);
			if(spacefree(dev)==0)
				schedule();
			finish_wait(&dev->outq,&wait);
			if(signal_pending(current))
				return -ERESTARTSYS;
			if(down_interruptible(&dev->sem))
				return -ERESTARTSYS;
	  	}
	  return 0;
}



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));
	PDEBUG("Going to accept %li bytes to %p from %pn", (long)count, dev->wp, buf);
	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() */

	/* and signal asynchronous readers, explained late in chapter 5 */
	if (dev->async_queue)
		kill_fasync(&dev->async_queue, SIGIO, POLL_IN);
	PDEBUG(""%s" did write %li bytesn",current->comm, (long)count);
	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_table
	//µÈ´ý¶ÓÁÐÍ·
	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;
}
static int scull_p_fasync(int fd,struct file *filp,int mode)
{
	struct scull_pipe *dev=filp->private_data;
	return fasync_helper(fd,filp,mode,&dev->async_queue);
}
#ifdef SCULL_DEBUG
static void scullp_proc_offset(char *buf,char **start,off_t *offset,int *len)
{
	
	if (*offset == 0)
		return;
	if (*offset >= *len) {	/* Not there yet */
		*offset -= *len;
		*len = 0;
	}
	else {			/* We're into the interesting stuff now */
		*start = buf + *offset;
		*offset = 0;
	}
}
static int scull_read_p_mem(char *buf,char **start,off_t offset,int count,
			int *eof,void *data)
{
	int i, len;
	struct scull_pipe *p;

#define LIMIT (PAGE_SIZE-200)	/* don't print any more after this size */
	*start = buf;
	len = sprintf(buf, "Default buffersize is %in", scull_p_buffer);
	for(i = 0; i<scull_p_nr_devs && len <= LIMIT; i++) {
		p = &scull_p_devices[i];
		if (down_interruptible(&p->sem))
			return -ERESTARTSYS;
		len += sprintf(buf+len, "nDevice %i: %pn", i, p);
/*		len += sprintf(buf+len, "   Queues: %p %pn", p->inq, p->outq);*/
		len += sprintf(buf+len, "   Buffer: %p to %p (%i bytes)n", p->buffer, p->end, p->buffersize);
		len += sprintf(buf+len, "   rp %p   wp %pn", p->rp, p->wp);
		len += sprintf(buf+len, "   readers %i   writers %in", p->nreaders, p->nwriters);
		up(&p->sem);
		scullp_proc_offset(buf, start, &offset, &len);
	}
	*eof = (len <= LIMIT);
	return len;
}
#endif


struct file_operations scull_pipe_fops={
		.owner =	THIS_MODULE,
	.llseek =	no_llseek,
	.read =		scull_p_read,
	.write =	scull_p_write,
	.poll =		scull_p_poll,
	.unlocked_ioctl =	scull_ioctl,
	.open =		scull_p_open,
	.release =	scull_p_release,
	.fasync =	scull_p_fasync,
};
static void scull_p_setup_cdev(struct scull_pipe *dev,int index)
{
	int err, devno = scull_p_devno + index;
    	cdev_init(&dev->cdev, &scull_pipe_fops);
	dev->cdev.owner = THIS_MODULE;
	err = cdev_add (&dev->cdev, devno, 1);
	/* Fail gracefully if need be */
	if (err)
		printk(KERN_NOTICE "Error %d adding scullpipe%d", err, index);
}

int scull_p_init(dev_t firstdev)
{
	int i, result;

	result = register_chrdev_region(firstdev, scull_p_nr_devs, "scullp");
	if (result < 0) {
		printk(KERN_NOTICE "Unable to get scullp region, error %dn", result);
		return 0;
	}
	scull_p_devno = firstdev;
	scull_p_devices = kmalloc(scull_p_nr_devs * sizeof(struct scull_pipe), GFP_KERNEL);
	if (scull_p_devices == NULL) {
		unregister_chrdev_region(firstdev, scull_p_nr_devs);
		return 0;
	}
	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));
		sema_init(&scull_p_devices[i].sem,1);
		scull_p_setup_cdev(scull_p_devices + i, i);
	}
#ifdef SCULL_DEBUG
	create_proc_read_entry("scullpipe", 0, NULL, scull_read_p_mem, NULL);
#endif
	return scull_p_nr_devs;
}

void scull_p_cleanup(void)
{
	int i;

#ifdef SCULL_DEBUG
	remove_proc_entry("scullpipe", NULL);
#endif

	if (!scull_p_devices)
		return; /* nothing else to release */

	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(scull_p_devno, scull_p_nr_devs);
	scull_p_devices = NULL; /* pedantic */
}



main.c

 

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

#include <linux/kernel.h>	/* printk() */
#include <linux/slab.h>		/* kmalloc() */
#include <linux/fs.h>		/* everything... */
#include <linux/errno.h>	/* error codes */
#include <linux/types.h>	/* size_t */
#include <linux/proc_fs.h>
#include <linux/fcntl.h>	/* O_ACCMODE */
#include <linux/seq_file.h>
#include <linux/cdev.h>

#include <asm/system.h>		/* cli(), *_flags */
#include <asm/uaccess.h>	/* copy_*_user */

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

 int scull_major=SCULL_MAJOR;
int scull_minor=0;
int scull_nr_devs=SCULL_NR_DEVS;
int scull_quantum=SCULL_QUANTUM;
int scull_qset=SCULL_QSET;

module_param(scull_major,int,S_IRUGO);
module_param(scull_nr_devs,int,S_IRUGO);
module_param(scull_quantum,int,S_IRUGO);
MODULE_LICENSE("Dual BSD/GPL");


struct scull_dev *scull_devices;//scull_devices ½á¹¹Êý×飬Óкܶà¸öscull_dev½á¹¹

int scull_trim(struct scull_dev *dev)
{
	struct scull_qset *dptr,*next;
	int qset=dev->qset;
	int i;
	for(dptr=dev->data;dptr;dptr=next)
		{
		if(dptr->data)
			{
			for(i=0;i<qset;i++)
				kfree(dptr->data[i]);
			
			kfree(dptr->data);//?
			dptr->data=NULL;
			}
		next=dptr->next;
		kfree(dptr);

		}
	dev->quantum=scull_quantum;
	dev->size=0;
	dev->data=NULL;
	dev->qset=scull_qset;
	return 0;
}

#ifdef SCULL_DEBUG
//ÀÏ·½·¨ÊµÏÖproc
int scull_read_procmem(char *buf,char **start,off_t offset,
			int count,int *eof,void *data)
{
	int i ,j ,len=0;
	int limit=count-80;
	for(i=0;i<scull_nr_devs&&len<=limit;i++)
		{
			struct scull_dev *d=&scull_devices[i];
			struct scull_qset *qs=d->data;
			if(down_interruptible(&d->sem))
				return -ERESTARTSYS;
			len+=sprintf(buf+len,"%nDevice %i:qset %i,q%i,size %lin",
				i,d->qset,d->quantum,d->size);
			for(;qs&&len<=limit,qs=qs->next)
				{
					len+=sprintf(buf+len,"itme at %p,qset at %pn",
						qs,qs->data);
					//´òÓ¡qsetÁбíÖеÄ×îºóÒ»¸ö
					if(qs&&!qs->data)
						{
							for(j=0;j<d->qset;j++)
								{
									len+=sprintf(buf+len,
										"%4i,%8p:n",j,qs->data[j]);
								}
						}
				}
			up(&scull_devices[i]->sem);
			
			
		}
	*eof=1;
	return len;
	
}
//з½·¨ÊµÏÖproc,»ñÈ¡µÚpos¸öscull_devices;
static void *scull_seq_start(struct seq_file *s,loff_t *pos)
{
	if(*pos>=scull_nr_devs)
		{
			return NULL;
		}
	return scull_devices+*pos;
}
static void *scull_seq_next(struct seq_file *s,void *v ,loff_t *pos)
{
	*pos++;
	if(*pos>=scull_nr_devs)
		return NULL;
	return scull_devices+*pos;
}
static void *scull_seq_stop(struct seq_file *s,void *v)
{
	
}
static void *scull_seq_show(struct seq_file *s ,void *v)
{
		struct scull_dev *dev=(struct scull_dev *)v;
		struct scull_qset *d;
		int i;
		if(down_interruptible(&dev->sem))
			return -ERESTARTSYS;
		//´òÓ¡µÚ¼¸¸öscull_devices
		seq_printf(s,"nDevice:%i: qset %i,quantum %i,sz %lin"
					(int)(dev-scull_devices),dev->qset,dev->quantum,dev->size);
		for(d=dev->data;d;d=d->next)
			{
			//ÁгöËùÓеÄqset½á¹¹¼°ÆäÄÚÈÝ´æ·ÅλÖÃ
				seq_printf(s,"item at %p,qset at %pn",d,d->data);
			//ÔÚÉÏÃæËùÁеĽṹÀïÃ棬ֻ´òÓ¡×îºóÒ»¸öqset
			//½á¹¹ºÍÆäËùÓеÄÄÚÈÝ
				if(d->data&&!d->next)
					for(i=0;i<dev->qset;i++)
							{	if(d->data[i])
								
								seq_printf(s,"qset:%4i,data[i]%8pn",i,d->data[i]);
								
							}
				
			}
		up(&dev->sem);
		return 0;
			
		
}
static struct seq_operations scull_seq_ops={
			.start=scull_seq_start,
			.next=scull_seq_next,
			.stop=scull_seq_stop,
			.show=scull_seq_show
};
static scull_proc_open(struct inode *inode,struct file *file)
{
	return seq_open(file,&scull_seq_ops);
}
static struct file_operations scull_proc_ops={
		.owner=THIS_MODULE,
		.open=scull_proc_open,
		.read=seq_read,
		.llseek=seq_lseek,
		.release=seq_release
	};
//ÓÃÁ½ÖÖ·½·¨¸÷×Ô´´½¨ÁËprocÎļþ
static scull_create_proc(void)
{
	struct proc_dir_entry *entry;
	//ÀÏ·½·¨´´½¨µÄ
	//
	create_proc_read_entry("scullmem",0,NULL,scull_read_procmem,NULL);
}

static void scull_remove_proc(void)
{
	//ֻҪע²áÁË ÒÔϺ¯Êý»ù±¾»áÔËÐÐÍê³É
	remove_proc_entry("scullmem",NULL);
	remove_proc_entry("scullseq",NULL);
}

#endif

int scull_open(struct inode *inode, struct file *filp)
{
	struct scull_dev *dev; /* device information */

	dev = container_of(inode->i_cdev, struct scull_dev, cdev);
	/*
	[˵Ã÷]
		1.ÎÒÃÇÒªÌî³äµÄÓ¦¸ÃÊÇÎÒÃÇ×Ô¼ºµÄÌØÊâÉ豸£¬¶ø²»ÊÇǯÔÚËûÀïÃæµÄ×Ö·ûÉ豸½á¹¹£»
		2.inode½á¹¹µÄi_cdev³ÉÔ±ÕâÄÜÌṩ»ù±¾×Ö·ûÉ豸½á¹¹£»
		3.ÕâÀïÀûÓÃÁ˶¨ÒåÔÚ<linux/kernel.h>ÖеĺêÀ´ÊµÏÖͨ¹ýcdevµÃµ½dev;
	*/
	
	/*
	ÒÔºóread , write ,µÈ²Ù×÷µÄʵÏÖÖоͿ¿ËûÀ´µÃµ½devÁË£»
	*/
	filp->private_data = dev; /* for other methods */
	

	/* now trim to 0 the length of the device if open was write-only */
	if ( (filp->f_flags & O_ACCMODE) == O_WRONLY) {
		if (down_interruptible(&dev->sem))
			return -ERESTARTSYS;
		scull_trim(dev); /* ignore errors */
		up(&dev->sem);
	}
	return 0;          /* success */
}

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

//Ö»Òª¹æ¶¨ÁËn£¬¼´Ê¹´ï²»µ½n£¬Ò²Òª´´½¨
struct scull_qset *scull_follow(struct scull_dev *dev,int n)
{
	struct scull_qset *qs=dev->data;
	if(!qs)
		{
			qs=dev->data=kmalloc(sizeof(struct scull_qset),GFP_KERNEL);
			if(!qs)
				return NULL;
			memset(qs,0,sizeof(struct scull_qset));
		}
	while(n--)
		{
			if(!qs->next)
				{
					qs->next=kmalloc(sizeof(struct scull_qset),GFP_KERNEL);
					if(!qs->next)
						return NULL;
					qs=qs->next;
					memset(qs->next,0,sizeof(struct scull_qset));
				}
			qs=qs->next;
		}
}

ssize_t scull_read(struct file *filp, char __user *buf, size_t count,
                loff_t *f_pos)
{
	struct scull_dev *dev = filp->private_data; 
	struct scull_qset *dptr;	/* the first listitem */
	int quantum = dev->quantum, qset = dev->qset;
	int itemsize = quantum * qset; /* how many bytes in the listitem */
	int item, s_pos, q_pos, rest;
	ssize_t retval = 0;

	if (down_interruptible(&dev->sem))
		return -ERESTARTSYS;
	if (*f_pos >= dev->size) //²Ù×÷λÖõ½Îļþ⣬»ò³¬³öÎļþβÁË
		goto out;
	if (*f_pos + count > dev->size) //ÔÚµ±Ç°Î»ÖÃËùÒª¶ÁµÄÊýÄ¿³¬¹ýÎļþβÁË
		count = dev->size - *f_pos;	//¼õСÕâ´ÎµÄÆÚÍû¶ÁÈ¡ÊýÄ¿

	/* find listitem, qset index, and offset in the quantum */
	item = (long)*f_pos / itemsize; //È·¶¨ÊÇÄĸöÁ´±íÏîÏ£¬¼´Äĸö½ÚµãÏ£»
	rest = (long)*f_pos % itemsize; //ÔÚÕâ¸öÁ´±íÏîµÄʲôλÖã¨Æ«ÒÆÁ¿£©£¬ÓÃÓÚÏÂÃæÕÒqsetË÷ÒýºÍÆ«ÒÆÁ¿£»
	s_pos = rest / quantum;		//ÔÚÕâ¸ö½ÚµãÀï**dataÕâ¸öÖ¸ÕëÊý×éµÄµÚ¼¸ÐУ»
	 q_pos = rest % quantum; //ÔÚÕâÐУ¬¼´Õâ¸öÁ¿×ÓÀïµÄÆ«ÒÆÁ¿£»

	/* follow the list up to the right position (defined elsewhere) */
	dptr = scull_follow(dev, item);  //ÕÒµ½Õâ¸öÁ´±íÏî

	if (dptr == NULL || !dptr->data || ! dptr->data[s_pos])
		goto out; /* don't fill holes */

//ÒÔÒ»¸öÁ¿×ÓΪµ¥Î»´«£¬¼ò»¯ÁË´úÂ룻
	/* read only up to the end of this quantum */
	if (count > quantum - q_pos)
		count = quantum - q_pos;

/*
 * ÉÏÃæΪÕâ²½×¼±¸Á˾ßÌåÔÚÄĸöÁ´±íÏîµÄÖ¸ÕëÊý×éµÄµÚ¼¸Ðеĵڼ¸ÁУ¨¼´dptr->data[s_pos] + q_pos£©
 * ´ÓÕâ¸öλÖõÄÄÚºË̬µÄbufÖп½¸øÓû§Ì¬	
*/	

//¹Ø¼üÒ»²½£¬½«Êý¾Ý¿½¸øÓû§¿Õ¼ä
	if (copy_to_user(buf, dptr->data[s_pos] + q_pos, count)) {
		retval = -EFAULT;
		goto out;
	}
	*f_pos += count; //¸üÐÂÎļþÖ¸Õë
	retval = count;

  out:
	up(&dev->sem);
	return retval;
}

//ÓëreadµÄʵÏÖÀàËÆ
ssize_t scull_write(struct file *filp, const char __user *buf, size_t count,
                loff_t *f_pos)
{
	struct scull_dev *dev = filp->private_data;
	struct scull_qset *dptr;
	int quantum = dev->quantum, qset = dev->qset;
	int itemsize = quantum * qset;
	int item, s_pos, q_pos, rest;
	ssize_t retval = -ENOMEM; /* value used in "goto out" statements */

	if (down_interruptible(&dev->sem))
		return -ERESTARTSYS;

	/* find listitem, qset index and offset in the quantum */
	item = (long)*f_pos / itemsize;
	rest = (long)*f_pos % itemsize;
	s_pos = rest / quantum; q_pos = rest % quantum;

	/* follow the list up to the right position */
	dptr = scull_follow(dev, item);
	if (dptr == NULL)
		goto out;
	if (!dptr->data) {
		dptr->data = kmalloc(qset * sizeof(char *), GFP_KERNEL);
		if (!dptr->data)
			goto out;
		memset(dptr->data, 0, qset * sizeof(char *));
	}
	if (!dptr->data[s_pos]) {
		dptr->data[s_pos] = kmalloc(quantum, GFP_KERNEL);
		if (!dptr->data[s_pos])
			goto out;
	}
	/* write only up to the end of this quantum */
	if (count > quantum - q_pos)
		count = quantum - q_pos;

	if (copy_from_user(dptr->data[s_pos]+q_pos, buf, count)) {
		retval = -EFAULT;
		goto out;
	}
	*f_pos += count;
	retval = count;

        /* update the size */
	if (dev->size < *f_pos)
		dev->size = *f_pos;

  out:
	up(&dev->sem);
	return retval;
}

/*
 * The ioctl() implementation
 */

long  scull_ioctl(struct inode *inode,struct file *filp,unsigned int cmd,unsigned long arg)
{
	int err=0,tmp;
	int retval=0;
	if(_IOC_TYPE(cmd)!=SCULL_IOC_MAGIC) return -ENOTTY;
	if(_IOC_NR(cmd)>SCULL_IOC_MAXNR)return -ENOTTY;
	if(_IOC_DIR(cmd)&_IOC_READ)
		err=!access_ok(VERIFY_WRITE,(void __user *)arg,_IOC_SIZE(cmd));
	if(err) return -EFAULT;

	switch(cmd)
		{
			case SCULL_IOCRESET:
		scull_quantum = SCULL_QUANTUM;
		scull_qset = SCULL_QSET;
		break;
        
	  case SCULL_IOCSQUANTUM: /* Set: arg points to the value */
		if (! capable (CAP_SYS_ADMIN))
			return -EPERM;
		retval = __get_user(scull_quantum, (int __user *)arg);
		break;

	  case SCULL_IOCTQUANTUM: /* Tell: arg is the value */
		if (! capable (CAP_SYS_ADMIN))
			return -EPERM;
		scull_quantum = arg;
		break;

	  case SCULL_IOCGQUANTUM: /* Get: arg is pointer to result */
		retval = __put_user(scull_quantum, (int __user *)arg);
		break;

	  case SCULL_IOCQQUANTUM: /* Query: return it (it's positive) */
		return scull_quantum;

	  case SCULL_IOCXQUANTUM: /* eXchange: use arg as pointer */
		if (! capable (CAP_SYS_ADMIN))
			return -EPERM;
		tmp = scull_quantum;
		retval = __get_user(scull_quantum, (int __user *)arg);
		if (retval == 0)
			retval = __put_user(tmp, (int __user *)arg);
		break;

	  case SCULL_IOCHQUANTUM: /* sHift: like Tell + Query */
		if (! capable (CAP_SYS_ADMIN))
			return -EPERM;
		tmp = scull_quantum;
		scull_quantum = arg;
		return tmp;
        
	  case SCULL_IOCSQSET:
		if (! capable (CAP_SYS_ADMIN))
			return -EPERM;
		retval = __get_user(scull_qset, (int __user *)arg);
		break;

	  case SCULL_IOCTQSET:
		if (! capable (CAP_SYS_ADMIN))
			return -EPERM;
		scull_qset = arg;
		break;

	  case SCULL_IOCGQSET:
		retval = __put_user(scull_qset, (int __user *)arg);
		break;

	  case SCULL_IOCQQSET:
		return scull_qset;

	  case SCULL_IOCXQSET:
		if (! capable (CAP_SYS_ADMIN))
			return -EPERM;
		tmp = scull_qset;
		retval = __get_user(scull_qset, (int __user *)arg);
		if (retval == 0)
			retval = put_user(tmp, (int __user *)arg);
		break;

	  case SCULL_IOCHQSET:
		if (! capable (CAP_SYS_ADMIN))
			return -EPERM;
		tmp = scull_qset;
		scull_qset = arg;
		return tmp;

        /*
         * The following two change the buffer size for scullpipe.
         * The scullpipe device uses this same ioctl method, just to
         * write less code. Actually, it's the same driver, isn't it?
         */

	  case SCULL_P_IOCTSIZE:
		scull_p_buffer = arg;
		break;

	  case SCULL_P_IOCQSIZE:
		return scull_p_buffer;


	  default:  /* redundant, as cmd was checked against MAXNR */
		return -ENOTTY;
		}
	return retval;
}


loff_t scull_llseek(struct file *filp, loff_t off, int whence)
{
	struct scull_dev *dev = filp->private_data;
	loff_t newpos;

	switch(whence) {
	  case 0: /* SEEK_SET */
		newpos = off;
		break;

	  case 1: /* SEEK_CUR */
		newpos = filp->f_pos + off;
		break;

	  case 2: /* SEEK_END */
		newpos = dev->size + off;
		break;

	  default: /* can't happen */
		return -EINVAL;
	}
	if (newpos < 0) return -EINVAL;
	filp->f_pos = newpos;
	return newpos;
}


//[Tag007]½«Õâ×é²Ù×÷´ò°üΪһ¸ö¶ÔÏó£»
struct file_operations scull_fops = {
	.owner =    THIS_MODULE,
	.llseek =   scull_llseek,
	.read =     scull_read,
	.write =    scull_write,
	.unlocked_ioctl = scull_ioctl,
	.open =     scull_open,
	.release =  scull_release,
};

void scull_cleanup_module(void)
{
	int i;
	dev_t devno = MKDEV(scull_major, scull_minor);

	/* Get rid of our char dev entries */
	if (scull_devices) {
		for (i = 0; i < scull_nr_devs; i++) {
			scull_trim(scull_devices + i);
			cdev_del(&scull_devices[i].cdev);	//[???]ÊÇÒ»¸öÄں˺¯Êýô£¿
		}
		kfree(scull_devices);
	}

#ifdef SCULL_DEBUG /* use proc only if debugging */
	scull_remove_proc();
#endif

	/* cleanup_module is never called if registering failed */
	unregister_chrdev_region(devno, scull_nr_devs);

	/* and call the cleanup functions for friend devices */
	scull_p_cleanup();
	scull_access_cleanup();

}


static void scull_setup_cdev(struct scull_dev *dev, int index)
{
	int err, devno = MKDEV(scull_major, scull_minor + index);
    
   // [1]
	cdev_init(&dev->cdev, &scull_fops);	/* ³õʼ»¯, ×Ö·ûÉ豸ºÍ¸øËüÒ»×éÔÚËüÉÏÃæ²Ù×÷µÄ·½·¨¼¯ */
	
	/* Ìî³ä»ù±¾×Ö·ûÉ豸µÄ³ÉÔ± */
	dev->cdev.owner = THIS_MODULE;		//Ä£¿é¼ÆÊý
	dev->cdev.ops = &scull_fops;		//¸½ÉÏÒ»×é²Ù×÷×Ô¼ºµÄ·½·¨¼¯
	
//	[2]
	err = cdev_add (&dev->cdev, devno, 1);
	/*
	º¯Êý˵Ã÷:
		cdev -- ×Ö·ûÉ豸µÄ½á¹¹Ö¸Õë,ÎÒÃǾÍÊÇÒª°ÑËû¸æË߸øÄÚºË;
		devno -- É豸±àºÅ,ÓÃMKDEVÀûÓÃÈ«¾ÖµÄÖ÷É豸ºÅºÍ´ÎÉ豸ºÅÉú³ÉµÄ;
		1	-- ÊÇÓ¦¸ÃºÍ¸ÃÉ豸¹ØÁªµÄÉ豸±àºÅµÄÊýÁ¿, Ò»°ãÇé¿ö϶¼Îª1;
			Ò»°ãÎÒÃǶ¼ÊÇÒ»¸öÉ豸±àºÅ¶ÔÓ¦Ò»¸öÉ豸;		
	*/
	/*
	×¢Òâ:
		ÔÚµ÷ÓÃcdev_addºó,ÎÒÃǵÄÉ豸¾Í±»Ìí¼Óµ½ÏµÍ³ÁË,Ëû"»î"ÁË. ¸½¼ÓµÄ²Ù×÷¼¯Ò²¾Í¿ÉÒÔ±»Äں˵÷ÓÃÁË
		,Òò´Ë,ÔÚÇý¶¯³ÌÐò»¹Ã»ÓÐÍêȫ׼±¸ºÃ´¦ÀíÉ豸ÉϵIJÙ×÷ʱ,¾Í²»Äܵ÷ÓÃcdev_add!
	*/
	/* Fail gracefully if need be */
	if (err)
		printk(KERN_NOTICE "Error %d adding scull%d", err, index);
}

/*[Tag000]
 * µ±Ä£¿é¼ÓÔØʱ£¬µ÷Ó㻵«ÊÇΪʲôҪ·ÅÔÚ×îºóÀ´ÊµÏÖËûÄØ£¬¿´µ½Tag002ʱ£¬ÄãÓ¦¸Ã¾ÍÃ÷°×ÁË£»
*/
int scull_init_module(void)
{
	int result, i;
	dev_t dev = 0;

/* [Tag001] */
/* [1]·ÖÅäÉ豸±àºÅ */
/*
 * Get a range of minor numbers to work with, asking for a dynamic
 * major unless directed otherwise at load time.
 */
	if (scull_major) { 	/* Ô¤ÏÈ×Ô¼ºÖ¸¶¨ÁËÖ÷É豸ºÅ */
		dev = MKDEV(scull_major, scull_minor); /* ÀûÓÃÖ÷É豸ºÅ,ÕÒµ½É豸±àºÅ¸ø·½·¨1Óà */
		result = register_chrdev_region(dev, scull_nr_devs, "scull");
	} else {		/* ¶¯Ì¬×Ô¼ºÉú³ÉÉ豸±àºÅ,È»ºóÔÙÀûÓÃÉ豸±àºÅµÃµ½Ö÷É豸ºÅ;
						¼ÇסÈç¹ûÓÃÕâ¸ö·½·¨ÄÇô¾ÍÒªºó½¨É豸ÎļþÁË,ÒòΪ²»ÄÜÌáÇ°ÖªµÀÖ÷ºÅ
						µ±È»Ò²¿ÉÒÔÀûÓÃldd3ÊéÖÐÌṩµÄ½Å±¾,¾Þ·½±ã&&ͨÓà */
		result = alloc_chrdev_region(&dev, scull_minor, scull_nr_devs,
				"scull");
		scull_major = MAJOR(dev);
	}
	if (result < 0) {
		printk(KERN_WARNING "scull: can't get major %dn", scull_major);
		return result;
	}

    /*[2]É豸¶ÔÏóʵÀý»¯*/ 
        /* 
	 * allocate the devices -- we can't have them static, as the number
	 * can be specified at load time
	 */
	scull_devices = kmalloc(scull_nr_devs * sizeof(struct scull_dev), GFP_KERNEL);
	if (!scull_devices) {
		result = -ENOMEM;
		goto fail;  /* Make this more graceful */
	}
	memset(scull_devices, 0, scull_nr_devs * sizeof(struct scull_dev));

/* [3]ÔÚÕâÀï³õʼ»¯É豸ÓÃÁË2.6µÄз½·¨,ÔÚscull_setup_cdevÀïÍê³É */
        /* Initialize each device. */
	for (i = 0; i < scull_nr_devs; i++) {
		scull_devices[i].quantum = scull_quantum;	/* ¿ÉÒÔ¸ù¾Ý×Ô¼ºinsmodʱ´«²Î
														À´×Ô¼º¸Ä±äÁ¿×ÓºÍÁ¿×Ó¼¯(Ö¸ÕëÊý×é)µÄ´óС */
		scull_devices[i].qset = scull_qset;
		sema_init(&scull_devices[i].sem,1);
		scull_setup_cdev(&scull_devices[i], i);	/* ÔÚ·Ö±ðÍêÖ÷É豸±àºÅºógoto Tag002 É豸ע²á */
	}

        /* At this point call the init function for any friend device */
	dev = MKDEV(scull_major, scull_minor + scull_nr_devs);
	dev += scull_p_init(dev);
	dev += scull_access_init(dev);

#ifdef SCULL_DEBUG /* only when debugging */
	scull_create_proc();
#endif

	return 0; /* succeed */

  fail:
	scull_cleanup_module();
	return result;
}

module_init(scull_init_module);		//insmod	
module_exit(scull_cleanup_module);	//rmmod

access.c

#include <linux/kernel.h> /* printk() */
#include <linux/module.h>
#include <linux/slab.h>   /* kmalloc() */
#include <linux/fs.h>     /* everything... */
#include <linux/errno.h>  /* error codes */
#include <linux/types.h>  /* size_t */
#include <linux/fcntl.h>
#include <linux/cdev.h>
#include <linux/tty.h>
#include <asm/atomic.h>
#include <linux/list.h>

#include <linux/sched.h>
#include <linux/spinlock_types.h>

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

#define SPIN_LOCK_UNLOCKED	__SPIN_LOCK_UNLOCKED(old_style_spin_init)

static dev_t scull_a_firstdev;  /* Where our range begins */

/*
 * These devices fall back on the main scull operations. They only
 * differ in the implementation of open() and close()
 */



/************************************************************************
 *
 * The first device is the single-open one,
 *  it has an hw structure and an open count
 */

static struct scull_dev scull_s_device;
static atomic_t scull_s_available = ATOMIC_INIT(1);

static int scull_s_open(struct inode *inode, struct file *filp)
{
	struct scull_dev *dev = &scull_s_device; /* device information */

	if (! atomic_dec_and_test (&scull_s_available)) {
		atomic_inc(&scull_s_available);
		return -EBUSY; /* already open */
	}

	/* then, everything else is copied from the bare scull device */
	if ( (filp->f_flags & O_ACCMODE) == O_WRONLY)
		scull_trim(dev);
	filp->private_data = dev;
	return 0;          /* success */
}

static int scull_s_release(struct inode *inode, struct file *filp)
{
	atomic_inc(&scull_s_available); /* release the device */
	return 0;
}


/*
 * The other operations for the single-open device come from the bare device
 */
struct file_operations scull_sngl_fops = {
	.owner =	THIS_MODULE,
	.llseek =     	scull_llseek,
	.read =       	scull_read,
	.write =      	scull_write,
	.unlocked_ioctl =      	scull_ioctl,
	.open =       	scull_s_open,
	.release =    	scull_s_release,
};


/************************************************************************
 *
 * Next, the "uid" device. It can be opened multiple times by the
 * same user, but access is denied to other users if the device is open
 */

static struct scull_dev scull_u_device;
static int scull_u_count;	/* initialized to 0 by default */
static uid_t scull_u_owner;	/* initialized to 0 by default */
static spinlock_t scull_u_lock = SPIN_LOCK_UNLOCKED;

static int scull_u_open(struct inode *inode, struct file *filp)
{
	struct scull_dev *dev = &scull_u_device; /* device information */

	spin_lock(&scull_u_lock);
	if (scull_u_count && 
			(scull_u_owner != current->cred->uid) &&  /* allow user */
			(scull_u_owner != current->cred->euid) && /* allow whoever did su */
			!capable(CAP_DAC_OVERRIDE)) { /* still allow root */
		spin_unlock(&scull_u_lock);
		return -EBUSY;   /* -EPERM would confuse the user */
	}

	if (scull_u_count == 0)
		scull_u_owner = current->cred->uid; /* grab it */

	scull_u_count++;
	spin_unlock(&scull_u_lock);

/* then, everything else is copied from the bare scull device */

	if ((filp->f_flags & O_ACCMODE) == O_WRONLY)
		scull_trim(dev);
	filp->private_data = dev;
	return 0;          /* success */
}

static int scull_u_release(struct inode *inode, struct file *filp)
{
	spin_lock(&scull_u_lock);
	scull_u_count--; /* nothing else */
	spin_unlock(&scull_u_lock);
	return 0;
}



/*
 * The other operations for the device come from the bare device
 */
struct file_operations scull_user_fops = {
	.owner =      THIS_MODULE,
	.llseek =     scull_llseek,
	.read =       scull_read,
	.write =      scull_write,
	.unlocked_ioctl =      scull_ioctl,
	.open =       scull_u_open,
	.release =    scull_u_release,
};


/************************************************************************
 *
 * Next, the device with blocking-open based on uid
 */

static struct scull_dev scull_w_device;
static int scull_w_count;	/* initialized to 0 by default */
static uid_t scull_w_owner;	/* initialized to 0 by default */
static DECLARE_WAIT_QUEUE_HEAD(scull_w_wait);
static spinlock_t scull_w_lock = SPIN_LOCK_UNLOCKED;

static inline int scull_w_available(void)
{
	return scull_w_count == 0 ||
		scull_w_owner == current->cred->uid ||
		scull_w_owner == current->cred->euid ||
		capable(CAP_DAC_OVERRIDE);
}


static int scull_w_open(struct inode *inode, struct file *filp)
{
	struct scull_dev *dev = &scull_w_device; /* device information */

	spin_lock(&scull_w_lock);
	while (! scull_w_available()) {
		spin_unlock(&scull_w_lock);
		if (filp->f_flags & O_NONBLOCK) return -EAGAIN;
		if (wait_event_interruptible (scull_w_wait, scull_w_available()))
			return -ERESTARTSYS; /* tell the fs layer to handle it */
		spin_lock(&scull_w_lock);
	}
	if (scull_w_count == 0)
		scull_w_owner = current->cred->uid; /* grab it */
	scull_w_count++;
	spin_unlock(&scull_w_lock);

	/* then, everything else is copied from the bare scull device */
	if ((filp->f_flags & O_ACCMODE) == O_WRONLY)
		scull_trim(dev);
	filp->private_data = dev;
	return 0;          /* success */
}

static int scull_w_release(struct inode *inode, struct file *filp)
{
	int temp;

	spin_lock(&scull_w_lock);
	scull_w_count--;
	temp = scull_w_count;
	spin_unlock(&scull_w_lock);

	if (temp == 0)
		wake_up_interruptible_sync(&scull_w_wait); /* awake other uid's */
	return 0;
}


/*
 * The other operations for the device come from the bare device
 */
struct file_operations scull_wusr_fops = {
	.owner =      THIS_MODULE,
	.llseek =     scull_llseek,
	.read =       scull_read,
	.write =      scull_write,
	.unlocked_ioctl =      scull_ioctl,
	.open =       scull_w_open,
	.release =    scull_w_release,
};

/************************************************************************
 *
 * Finally the `cloned' private device. This is trickier because it
 * involves list management, and dynamic allocation.
 */

/* The clone-specific data structure includes a key field */

struct scull_listitem {
	struct scull_dev device;
	dev_t key;
	struct list_head list;
    
};

/* The list of devices, and a lock to protect it */
static LIST_HEAD(scull_c_list);
static spinlock_t scull_c_lock = SPIN_LOCK_UNLOCKED;

/* A placeholder scull_dev which really just holds the cdev stuff. */
static struct scull_dev scull_c_device;   

/* Look for a device or create one if missing */
static struct scull_dev *scull_c_lookfor_device(dev_t key)
{
	struct scull_listitem *lptr;

	list_for_each_entry(lptr, &scull_c_list, list) {
		if (lptr->key == key)
			return &(lptr->device);
	}

	/* not found */
	lptr = kmalloc(sizeof(struct scull_listitem), GFP_KERNEL);
	if (!lptr)
		return NULL;

	/* initialize the device */
	memset(lptr, 0, sizeof(struct scull_listitem));
	lptr->key = key;
	scull_trim(&(lptr->device)); /* initialize it */
	sema_init(&(lptr->device.sem),1);

	/* place it in the list */
	list_add(&lptr->list, &scull_c_list);

	return &(lptr->device);
}

static int scull_c_open(struct inode *inode, struct file *filp)
{
	struct scull_dev *dev;
	dev_t key;
 
	if (!current->signal->tty) { 
		PDEBUG("Process "%s" has no ctl ttyn", current->comm);
		return -EINVAL;
	}
	key = tty_devnum(current->signal->tty);

	/* look for a scullc device in the list */
	spin_lock(&scull_c_lock);
	dev = scull_c_lookfor_device(key);
	spin_unlock(&scull_c_lock);

	if (!dev)
		return -ENOMEM;

	/* then, everything else is copied from the bare scull device */
	if ( (filp->f_flags & O_ACCMODE) == O_WRONLY)
		scull_trim(dev);
	filp->private_data = dev;
	return 0;          /* success */
}

static int scull_c_release(struct inode *inode, struct file *filp)
{
	/*
	 * Nothing to do, because the device is persistent.
	 * A `real' cloned device should be freed on last close
	 */
	return 0;
}



/*
 * The other operations for the device come from the bare device
 */
struct file_operations scull_priv_fops = {
	.owner =    THIS_MODULE,
	.llseek =   scull_llseek,
	.read =     scull_read,
	.write =    scull_write,
	.unlocked_ioctl =    scull_ioctl,
	.open =     scull_c_open,
	.release =  scull_c_release,
};

/************************************************************************
 *
 * And the init and cleanup functions come last
 */

static struct scull_adev_info {
	char *name;
	struct scull_dev *sculldev;
	struct file_operations *fops;
} scull_access_devs[] = {
	{ "scullsingle", &scull_s_device, &scull_sngl_fops },
	{ "sculluid", &scull_u_device, &scull_user_fops },
	{ "scullwuid", &scull_w_device, &scull_wusr_fops },
	{ "sullpriv", &scull_c_device, &scull_priv_fops }
};
#define SCULL_N_ADEVS 4

/*
 * Set up a single device.
 */
static void scull_access_setup (dev_t devno, struct scull_adev_info *devinfo)
{
	struct scull_dev *dev = devinfo->sculldev;
	int err;

	/* Initialize the device structure */
	dev->quantum = scull_quantum;
	dev->qset = scull_qset;
	sema_init(&dev->sem,1);

	/* Do the cdev stuff. */
	cdev_init(&dev->cdev, devinfo->fops);
	kobject_set_name(&dev->cdev.kobj, devinfo->name);
	dev->cdev.owner = THIS_MODULE;
	err = cdev_add (&dev->cdev, devno, 1);
        /* Fail gracefully if need be */
	if (err) {
		printk(KERN_NOTICE "Error %d adding %sn", err, devinfo->name);
		kobject_put(&dev->cdev.kobj);
	} else
		printk(KERN_NOTICE "%s registered at %xn", devinfo->name, devno);
}


int scull_access_init(dev_t firstdev)
{
	int result, i;

	/* Get our number space */
	result = register_chrdev_region (firstdev, SCULL_N_ADEVS, "sculla");
	if (result < 0) {
		printk(KERN_WARNING "sculla: device number registration failedn");
		return 0;
	}
	scull_a_firstdev = firstdev;

	/* Set up each device. */
	for (i = 0; i < SCULL_N_ADEVS; i++)
		scull_access_setup (firstdev + i, scull_access_devs + i);
	return SCULL_N_ADEVS;
}

/*
 * This is called by cleanup_module or on failure.
 * It is required to never fail, even if nothing was initialized first
 */
void scull_access_cleanup(void)
{
	struct scull_listitem *lptr, *next;
	int i;

	/* Clean up the static devs */
	for (i = 0; i < SCULL_N_ADEVS; i++) {
		struct scull_dev *dev = scull_access_devs[i].sculldev;
		cdev_del(&dev->cdev);
		scull_trim(scull_access_devs[i].sculldev);
	}

    	/* And all the cloned devices */
	list_for_each_entry_safe(lptr, next, &scull_c_list, list) {
		list_del(&lptr->list);
		scull_trim(&(lptr->device));
		kfree(lptr);
	}

	/* Free up our number space */
	unregister_chrdev_region(scull_a_firstdev, SCULL_N_ADEVS);
	return;
}


scull.h

#ifndef _SCULL_H_
#define _SCULL_H_

#include <linux/ioctl.h> /* needed for the _IOW etc stuff used later */

/*
 * Macros to help debugging
 */

#undef PDEBUG             /* undef it, just in case */
#ifdef SCULL_DEBUG
#  ifdef __KERNEL__
     /* This one if debugging is on, and kernel space */
#    define PDEBUG(fmt, args...) printk( KERN_DEBUG "scull: " fmt, ## args)
#  else
     /* This one for user space */
#    define PDEBUG(fmt, args...) fprintf(stderr, fmt, ## args)
#  endif
#else
#  define PDEBUG(fmt, args...) /* not debugging: nothing */
#endif

#undef PDEBUGG
#define PDEBUGG(fmt, args...) /* nothing: it's a placeholder */

#ifndef SCULL_MAJOR
#define SCULL_MAJOR 0   /* dynamic major by default */
#endif

#ifndef SCULL_NR_DEVS
#define SCULL_NR_DEVS 4    /* scull0 through scull3 */
#endif

#ifndef SCULL_P_NR_DEVS
#define SCULL_P_NR_DEVS 4  /* scullpipe0 through scullpipe3 */
#endif

/*
 * The bare device is a variable-length region of memory.
 * Use a linked list of indirect blocks.
 *
 * "scull_dev->data" points to an array of pointers, each
 * pointer refers to a memory area of SCULL_QUANTUM bytes.
 *
 * The array (quantum-set) is SCULL_QSET long.
 */
#ifndef SCULL_QUANTUM
#define SCULL_QUANTUM 4000		/* ÿ¸öÖ¸Õë(Á¿×Ó)Ö¸ÏòÒ»¸ö4000×Ö½ÚµÄÇøÓò */
#endif

#ifndef SCULL_QSET
#define SCULL_QSET    1000		/* Ò»¸öÓÐ1000¸ö(Á¿×Ó)µÄÖ¸ÕëÊý×é */
#endif

/*
 * The pipe device is a simple circular buffer. Here its default size
 */
#ifndef SCULL_P_BUFFER
#define SCULL_P_BUFFER 4000
#endif

/*
 * Representation of scull quantum sets.
 * Ò»¸öÁ´±íÏî
 */
struct scull_qset {
	void **data;
	struct scull_qset *next;	/* ÏÂÒ»¸öÁ´±í½Úµã£¨Á´±íÏ */
};

/* ÎÒÃÇ×Ô¼ºµÄÉ豸(°üº¬ÁË»ù±¾µÄcdev×Ö·ûÉ豸½á¹¹) */
struct scull_dev {
	struct scull_qset *data;  /* Pointer to first quantum set (Á´±íµÄÍ·)*/
	int quantum;              /* the current quantum size */
	int qset;                 /* the current array size */
	unsigned long size;       /* amount of data stored here (±£´æÔÚÆäÖеÄÊý¾Ý×ÜÁ¿)*/
	unsigned int access_key;  /* used by sculluid and scullpriv */
	struct semaphore sem;     /* mutual exclusion semaphore     */
	struct cdev cdev;	  /* Char device structure		*/
};

/*
 * Split minors in two parts
 */
#define TYPE(minor)	(((minor) >> 4) & 0xf)	/* high nibble */
#define NUM(minor)	((minor) & 0xf)		/* low  nibble */


/*
 * The different configurable parameters
 */
extern int scull_major;     /* main.c */
extern int scull_nr_devs;
extern int scull_quantum;
extern int scull_qset;

extern int scull_p_buffer;	/* pipe.c */


/*
 * Prototypes for shared functions
 */

int     scull_p_init(dev_t dev);
void    scull_p_cleanup(void);
int     scull_access_init(dev_t dev);
void    scull_access_cleanup(void);

int     scull_trim(struct scull_dev *dev);

ssize_t scull_read(struct file *filp, char __user *buf, size_t count,
                   loff_t *f_pos);
ssize_t scull_write(struct file *filp, const char __user *buf, size_t count,
                    loff_t *f_pos);
loff_t  scull_llseek(struct file *filp, loff_t off, int whence);
long     scull_ioctl(struct inode *inode, struct file *filp,
                    unsigned int cmd, unsigned long arg);


/*
 * Ioctl definitions
 */

/* Use 'k' as magic number */
#define SCULL_IOC_MAGIC  'k'
/* Please use a different 8-bit number in your code */

#define SCULL_IOCRESET    _IO(SCULL_IOC_MAGIC, 0)

/*
 * S means "Set" through a ptr,
 * T means "Tell" directly with the argument value
 * G means "Get": reply by setting through a pointer
 * Q means "Query": response is on the return value
 * X means "eXchange": switch G and S atomically
 * H means "sHift": switch T and Q atomically
 */
#define SCULL_IOCSQUANTUM _IOW(SCULL_IOC_MAGIC,  1, int)
#define SCULL_IOCSQSET    _IOW(SCULL_IOC_MAGIC,  2, int)
#define SCULL_IOCTQUANTUM _IO(SCULL_IOC_MAGIC,   3)
#define SCULL_IOCTQSET    _IO(SCULL_IOC_MAGIC,   4)
#define SCULL_IOCGQUANTUM _IOR(SCULL_IOC_MAGIC,  5, int)
#define SCULL_IOCGQSET    _IOR(SCULL_IOC_MAGIC,  6, int)
#define SCULL_IOCQQUANTUM _IO(SCULL_IOC_MAGIC,   7)
#define SCULL_IOCQQSET    _IO(SCULL_IOC_MAGIC,   8)
#define SCULL_IOCXQUANTUM _IOWR(SCULL_IOC_MAGIC, 9, int)
#define SCULL_IOCXQSET    _IOWR(SCULL_IOC_MAGIC,10, int)
#define SCULL_IOCHQUANTUM _IO(SCULL_IOC_MAGIC,  11)
#define SCULL_IOCHQSET    _IO(SCULL_IOC_MAGIC,  12)

/*
 * The other entities only have "Tell" and "Query", because they're
 * not printed in the book, and there's no need to have all six.
 * (The previous stuff was only there to show different ways to do it.
 */
#define SCULL_P_IOCTSIZE _IO(SCULL_IOC_MAGIC,   13)
#define SCULL_P_IOCQSIZE _IO(SCULL_IOC_MAGIC,   14)
/* ... more to come */

#define SCULL_IOC_MAXNR 14

#endif /* _SCULL_H_ */


先make，在切换到root权限中  ，使用 ./scull_load来加载模块

卸载时使用./scull_unload

测试scull_pipe的时候开两个终端

一个终端  输入cat /dev/scullpipe，会阻塞

另一个终端 输入 echo  hello /dev/scullpipe0

另一个窗口会有东西显示出来

解析：第一个终端。调用open打开设备，然后调用read，poll阻塞，释放信号量

第二个终端，获得信号量，再写数据，写完数据通知设备的文件描述符的读等待事件队列，让其进程继续执行读数据

便可以读到数据



申明：驱动程序及本博客一切内容归本博主所有，转载请注意来源，不得用于商业用途