kernel module编程（四）：设备属性和与上层应用的联系

#include <stdlib.h>
 #include <stdio.h>

 int main(int argc ,char * argv[])
 {
         FILE * file = NULL;

         printf("************** TEST ACCESS DRIVER**************/n");
         file = fopen("/dev/scull0","w");
         if(file == NULL){
                 printf("Open scull0 error!/n");
                 exit(-1);
         }

         fclose(file);
         return 0;
 }

[wei@wei ~]$ cat scull.h
 #ifndef _WEI_SCULL_H
 #define _WEI_SCULL_H

 #define SCULL_MAJOR          0
 #define SCULL_MINOR_MIN 0
 #define SCULL_DEV_NUM    4 

/*这是根据内存组织情况给的链表结构*/ 
 struct scull_qset{
         void             ** data;
         struct scull_qset * next;
 };
/* 这是根据内存组织结构给的一个是Quantum的大小，一个是Data中具有多少个Quantum的队列长度*/ 
 #define SCULL_QUANTUM 1024
 #define SCULL_QSET      64

/*这是我们为内核模块对应的设备提供的结构，*/ 
 struct scull_dev {
         struct scull_qset     * data;
         int                           quantum;/* the quantum size */ 
         int                           qset;        /* the array size */ 

         struct  cdev            cdev;         /* Char device structure */ 
 };

 static void scull_setup_cdev(struct scull_dev * dev, int index);

 int scull_trim(struct scull_dev * dev);

 int scull_open(struct inode * inode , struct file * file);
 int scull_release(struct inode * inode , struct file * file);#endif

void cdev_init(struct cdev * cdev, strcut file_operations *fops);
 int  cdev_add (strcut cdev * dev, dev_t num, unsigned int count);
 void cdev_del (strcut cdev * dev);

[wei@wei ~]$ cat scull.c
 #include <linux/init.h>
 #include <linux/module.h> 
 #include <linux/fs.h>
 #include <linux/cdev.h>

 #include "scull.h"

MODULE_LICENSE("Dual BSD/GPL"); 

dev_t   dev;
 int     is_get_dev = -1; 

static int      scull_major = SCULL_MAJOR; 

/*这是文件操作结构，我们的四个scull0-3都具备同样的属性，应此可以对应到同一个数据结构中，请注意这个写法，我们在这里列出，使得程序更已读和便于修改。这在这个例子中，我们只是简单地进行打开和关闭的操作，所以我们只提供open和release两个函数映射*/ 
struct file_operations scull_fops  = {
         .owner          = THIS_MODULE,   /*这个参数不是一个操作，用于防止模块在操作过程中被卸载。*/ 
         .open           = scull_open,
         .release        = scull_release,  
 };

 /* strcut scull_dev是我们为每个设备设定的所有信息，四个设备放置在一个数组中 */ 
 struct scull_dev mydev[SCULL_DEV_NUM];

static int __init scull_init(void)
 {
         int i =0;

         printk("Scull module init enter/n");
         if(scull_major){
                 dev = MKDEV(scull_major,SCULL_MINOR_MIN);
                 is_get_dev = register_chrdev_region(dev, SCULL_DEV_NUM,"scull");
         }else{
                 is_get_dev = alloc_chrdev_region(&dev,SCULL_MINOR_MIN, SCULL_DEV_NUM,"scull");
                 scull_major = MAJOR(dev);
         }
         if(is_get_dev < 0){
                 printk(KERN_WARNING "scull: can't get device major number %d/n",scull_major);
                 return is_get_dev;
         } 

     /* 为这四个设备分别进行初始化 */ 
         for(i = 0 ; i < SCULL_DEV_NUM; i ++){
                 scull_setup_cdev(&mydev[i],i);
         }
        return 0;
 } 

static void __exit scull_exit(void)
 {
         if(is_get_dev < 0){
                 return ;
         }else{
                 int i = 0; 
                 /* 对于任何进行了cdev_add操作的设备，应该在卸载模块的时候进行cdev_del，将它从kernel中删除。*/ 
                 for(i = 0; i < SCULL_DEV_NUM; i ++){
                         cdev_del( & mydev[i].cdev  ); 
                 }
                 unregister_chrdev_region(dev,SCULL_DEV_NUM);
                 printk("Scull module exit/n");
         }
 } 

module_init(scull_init);
 module_exit(scull_exit); 

/* 根据我们为设备定义的结构，进行初始化*/ 
 static void scull_setup_cdev(struct scull_dev * dev, int index)
 {
         int err;
         /* 通过第二个参数index，我们可以知道具体是那个scullx，可以对应到相应的设备上。*/ 
         int devno = MKDEV(scull_major,SCULL_MINOR_MIN + index);
         printk("scull%d %d,%d is %d/n", index,scull_major, SCULL_MINOR_MIN + index, devno);/*进行char device的初始化，和file operation相关联，设置其属性，并将通过对应设备将其加入kernel中*/  
         cdev_init (& dev->cdev, & scull_fops ); 
         dev->cdev.owner = THIS_MODULE;
         dev->cdev.ops   = & scull_fops;  
         err = cdev_add(&dev->cdev,devno,1 ); 
         if(err){
                 printk(KERN_NOTICE "scull : Err %d adding scull %d/n", err,index);
         }
 }

/*当用户程序打开设备是触发，例如测试小程序中的fopen()，kernel将送来inode和该用户的文件属性，不同用户有不同的操作权限。*/ 
 int scull_open(struct inode * inode ,struct file *filp)
 {
         struct scull_dev * dev;
         
        /*这里给出了通过inode获得对应设备的方式，第一种通过获取设备号码来进行检索，第二中是个很有趣的函数contianer_of，据ldd3这本书说这是kernel hackers提供的。container_of(pointer,container_type,container_field），则是太方便了。方便得有些怀疑是否保险。*/ 
         printk("scull_open is called, node %d %d/n",imajor(inode ) , iminor(inode ) );
         dev = container_of(inode->i_cdev,struct scull_dev,cdev ); 
        。 */ 
         filp->private_data = dev;
         
         /* 查看一下用户权限。我们可以在fopen中使用"r"和"w"分别查看。如果给出的是只写操作，将清空原来的所有数据（scull_trim()）。*/ 
         printk("scull: open mode is %x/n",filp->f_mode);
         if((filp->f_flags & O_ACCMODE) == O_WRONLY){
                 printk("scull: only write: free all data/n");
                 scull_trim(dev);
         }

         return 0;
 }
/* 我们在用户程序fclose()时调用。*/ 
 int scull_release(struct inode * inode, struct file * filp)
 {       printk("scull: release is called./n");  
      return 0;
 }

/* 清空所有数据 */ 
 int scull_trim(struct scull_dev * dev)
 {
         struct scull_qset * next ,*dptr;
         int qset = dev-> qset;
         int i ;

         for (dptr = dev->data; dptr != NULL; 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->size = 0;
         dev->quantum = SCULL_QUANTUM;
         dev->qset = SCULL_QSET;
         dev->data = NULL;
         return 0;
 }