所有实验平台:Ubuntu10.04+mini2440(128M) scull.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/fcntl.h> /* O_ACCMODE */ #include <linux/cdev.h> #include <asm/system.h> /* cli(), *_flags */ #include <asm/uaccess.h> /* copy_*_user */ #include "scull.h" /* local definitions */ /* * Our parameters which can be set at load time. */ int scull_major = SCULL_MAJOR; //主设备号 int scull_minor = 0; //次设备号 int scull_nr_devs = SCULL_NR_DEVS; /* scull设备数量为4个.number of bare scull devices */ int scull_quantum = SCULL_QUANTUM; //量子的大小 int scull_qset = SCULL_QSET; //量子集的大小 //模块参数,方便加载模块时输入参数!! module_param(name,type,perm); module_param(scull_major, int, S_IRUGO); module_param(scull_minor, int, S_IRUGO); module_param(scull_nr_devs, int, S_IRUGO); module_param(scull_quantum, int, S_IRUGO); module_param(scull_qset, int, S_IRUGO); struct scull_dev *scull_devices; /* allocated in scull_init_module 全局变量!*/ /* * Empty out the scull device; must be called with the device * semaphore held. * scull_trim()函数是scull模块中的一个释放整个数据区的函数(类似清零处理),在scull以写方式打开和scull_cleanup_module中被调用 */ int scull_trim(struct scull_dev *dev) { struct scull_qset *next, *dptr; int qset = dev->qset; /* "dev" is not-null qset为量子集中量子的个数 */ int i; for (dptr = dev->data; dptr; dptr = next) { /* all the list items.dptr指向了dev设备的第一个量子集;遍历dev设备所有量子集,释放其空间 */ if (dptr->data) { //如果对应量子集中的数据(data就是量子)非0,则将其清零处理! for (i = 0; i < qset; i++) //遍历所有量子 kfree(dptr->data[i]); //释放该量子集中的所有量子 占用的内存空间 kfree(dptr->data); //再释放对应的量子集 占用的内存空间! dptr->data = NULL; //赋值清零量子集! } next = dptr->next; //接着遍历下一个量子集. kfree(dptr); } dev->size = 0; dev->quantum = scull_quantum; dev->qset = scull_qset; dev->data = NULL; return 0; } /* * Open and close */ 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); 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) { //只写的方式打开scull设备 if (down_interruptible(&dev->sem)) //获取信号量函数称为down_interruptible() return -ERESTARTSYS; scull_trim(dev); /* ignore errors */ up(&dev->sem); //释放信号量函数称为up() } return 0; /* success */ } int scull_release(struct inode *inode, struct file *filp)//释放设备,也就是关闭scull设备 { return 0; } /* * Follow the list * explain:scull_follow()函数的实质:如果已经存在这个scull_qset,就返回这个scull_qset的指针。如果不存在这个scull_qset,一边沿链表为scull_qset分配空间一边沿链表前行,直到所需要的scull_qset 被分配到空间并初始化为止,就返回这个scull_qset 的指针。 */ struct scull_qset *scull_follow(struct scull_dev *dev, int n)//建立scull_qset量子集链表,n为链表的长度 { struct scull_qset *qs = dev->data; /* Allocate first qset explicitly if need be */ if (! qs) { qs = dev->data = kmalloc(sizeof(struct scull_qset), GFP_KERNEL); if (qs == NULL) return NULL; /* Never mind 创建失败!*/ memset(qs, 0, sizeof(struct scull_qset)); } /* Then follow the list */ while (n--) { if (!qs->next) { qs->next = kmalloc(sizeof(struct scull_qset), GFP_KERNEL); if (qs->next == NULL) return NULL; /* Never mind 创建失败! */ memset(qs->next, 0, sizeof(struct scull_qset)); } qs = qs->next; continue; } return qs; } /* * Data management: read and write */ /*scull_read()函数将设备中的数据拷贝到用户空间,调用函数copy_to_user()*/ ssize_t scull_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos) //读取scull设备 { struct scull_dev *dev = filp->private_data; struct scull_qset *dptr; /* the first listitem */ int quantum = dev->quantum, qset = dev->qset;/*quantum:当前量子的大小,qset:当前量子集的大小*/ int itemsize = quantum * qset; /* how many bytes in the listitem-链表节点中的字节数目. */ /*每个量子集的容量(大小)为quantum.一共有qset个量子集.所以一共的字节数=quantum*qset*/ int item, s_pos, q_pos, rest; ssize_t retval = 0; if (down_interruptible(&dev->sem))/*dowm_interruptible(&sem)称为获取信号量函数,返回0表示成功,返回非0表示出错!*/ return -ERESTARTSYS; if (*f_pos >= dev->size)/*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; s_pos = rest / quantum; //找到需要读的量子集开始的位置! q_pos = rest % quantum; //量子开始的位置! /* follow the list up to the right position (defined elsewhere) */ /*遍历链表,直至到达正确的节点位置(该函数定义于其他地方)*/ dptr = scull_follow(dev, item);//建立链表,长度为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; if (copy_to_user(buf, dptr->data[s_pos] + q_pos, count)) {//返回0表示成功,非0表示失败! retval = -EFAULT; goto out; } *f_pos += count; retval = count; out: up(&dev->sem);/*释放信号量函数,在linux中使用up()函数,它递增信号量的值,并唤醒所有正在等待信号量转为可用状态的进程*/ return retval; } /*scull_write()函数,将用户空间的数据拷贝到设备中,调用copy_from_user()*/ ssize_t scull_write(struct file *filp, const char __user *buf, size_t count, loff_t *f_pos)//将用户空间的数据写入scull设备 { 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))//获取信号量函数,返回0表示成功,返回非0表示失败 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)) {//返回0表示成功,非0表示失败 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; } struct file_operations scull_fops = { .owner = THIS_MODULE, .read = scull_read,/*表示结构体成员函数read指针指向具体函数scull_read*/ .write = scull_write, .open = scull_open, .release = scull_release, }; /* * Finally, the module stuff */ /* * The cleanup function is used to handle initialization failures as well. * Thefore, it must be careful to work correctly even if some of the items * have not been initialized */ 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); } /* cleanup_module is never called if registering failed */ unregister_chrdev_region(devno, scull_nr_devs); } /* * Set up the char_dev structure for this device. */ static void scull_setup_cdev(struct scull_dev *dev, int index) { int err, devno = MKDEV(scull_major, scull_minor + index); cdev_init(&dev->cdev, &scull_fops); dev->cdev.owner = THIS_MODULE; // dev->cdev.ops = &scull_fops; err = cdev_add (&dev->cdev, devno, 1); /* Fail gracefully if need be */ if (err) printk(KERN_NOTICE "Error %d adding scull%d", err, index); } int scull_init_module(void) { int result, i; dev_t dev = 0; /* * 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); result = register_chrdev_region(dev, scull_nr_devs, "scull"); } else { 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 %d/n", scull_major); return result; } /* * 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)); /* Initialize each device. */ for (i = 0; i < scull_nr_devs; i++) { scull_devices[i].quantum = scull_quantum; scull_devices[i].qset = scull_qset; init_MUTEX(&scull_devices[i].sem); scull_setup_cdev(&scull_devices[i], i); } return 0; /* succeed */ fail: scull_cleanup_module(); return result; } module_init(scull_init_module); module_exit(scull_cleanup_module); MODULE_AUTHOR("Tekkamanninja"); MODULE_LICENSE("Dual BSD/GPL"); scull_test.c(测试程序) #include <unistd.h> #include <sys/stat.h> #include <fcntl.h> #include <stdlib.h> int main() { char buffer1[20]={0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19}; char buffer2[20]={0}; int sculltest; int code,i; sculltest = open("/dev/scull0",O_WRONLY ); for ( i=20 ; i>0 ; i-=code) { if ((code=write(sculltest , &buffer1[20-i] , i)) != i) printf("write error! code=%d /n",code); else printf("write ok! code=%d /n",code); } close(sculltest); sculltest = open("/dev/scull0",O_RDONLY ); for ( i=20 ; i>0 ; i-=code) { if ((code=read(sculltest , &buffer2[20-i] , i)) != i) printf("read error! code=%d /n",code); else printf("read ok! code=%d /n",code); } for(i=0;i<20;i+=5) printf("[%d]=%d [%d]=%d [%d]=%d [%d]=%d [%d]=%d/n",i,buffer2[i],i+1,buffer2[i+1],i+2,buffer2[i+2],i+3,buffer2[i+3],i+4,buffer2[i+4]); printf("/n"); close(sculltest); exit(0); }