linux 比较完整的字符型驱动（一）

　　本文是基于linux-2.6.37，有一些内核的API可能不完全一致，需要自己查找，解决，写本文的目的是方便自己以后查找。

　　本文的Code写了一个简单的字符串，实现了阻塞和非阻塞，自旋锁，信号量，并发，轮询，sysfs接口，proc接口，devfs设备接点，module_init调用过程，异步通知，内核定时器，内核模块参数，内核模块导出。

CSlunatic_drv.h

#ifndef __CSLUNATIC_H__
#define __CSLUNATIC_H__

#include <linux/cdev.h>
#include <linux/semaphore.h>
#include <linux/wait.h>
#include <linux/fs.h>

#define CSLUNATIC_DEVICE_NODE_NAME  "CSlunatic"
#define CSLUNATIC_DEVICE_FILE_NAME  "CSlunatic"
#define CSLUNATIC_DEVICE_PROC_NAME  "CSlunatic"
#define CSLUNATIC_DEVICE_CLASS_NAME "CSlunatic"

#define MAX_FIFO_BUF 16         //缓冲区的大小

struct CSlunatic_char_dev {    
    int val;    
    int timer_interval;
    struct semaphore sem;/*信号量*/
    struct timer_list  timer;/*定时器*/
    unsigned char buf[MAX_FIFO_BUF];   //缓冲区  
    unsigned int current_len;
    wait_queue_head_t r_wait;/*读等待队列*/
    wait_queue_head_t w_wait; /*写等待队列*/
    struct cdev dev;/*字符设备结构体*/
    struct fasync_struct *async_queue;/*异步结构体指针，用于读*/
};

#endif

CSlunatic_drv.c

           
#include <linux/init.h>
#include <linux/module.h>
#include <linux/types.h>
#include <linux/proc_fs.h>
#include <linux/device.h>
#include <linux/sched.h>
#include <linux/poll.h>
#include <asm/uaccess.h>

#include "cslunatic_drv.h"/*主设备和从设备号变量*/

#define DEFAULT_INTERVAL  500
#define MEM_CLEAR 0x1

static int CSlunatic_major = 0;
static int CSlunatic_minor = 0;/*设备类别和设备变量*/

static struct class *CSlunatic_class = NULL;
static struct CSlunatic_char_dev *CSlunatic_dev = NULL;/*传统的设备文件操作方法*/

static int int_var = 0;
static const char *str_var = "default";
static int int_array[6];
int narr;

/*定时器处理函数*/
static void CSlunatic_timer_hander(unsigned long args)
{
     int i;
     struct CSlunatic_char_dev *dev;

     printk("%s enter.\n", __func__);
     dev = (struct CSlunatic_char_dev *)args;
     
     /*同步访问*/    
    if(down_interruptible(&(dev->sem))) {        
        return;    
    }     
    
     for(i =0; i < 4; i++){
               dev->buf[i] = i;
     }
     
     dev->current_len += i;
     if(dev->current_len > MAX_FIFO_BUF){
            dev->current_len = MAX_FIFO_BUF;
     }
     
    wake_up_interruptible(&dev->r_wait);
     
    if(dev->timer_interval > 0)
        mod_timer(&dev->timer, jiffies + dev->timer_interval);/*修改定时器的到期时间*/
   
    up(&(dev->sem));   

    printk("%s leave.\n", __func__);
}

/*打开设备方法*/
static int CSlunatic_open(struct inode* inode, struct file* filp) 
{    
    struct CSlunatic_char_dev *dev;                

    /*将自定义设备结构体保存在文件指针的私有数据域中，以便访问设备时拿来用*/    
    dev = container_of(inode->i_cdev, struct CSlunatic_char_dev, dev);    
    
    init_timer(&dev->timer);/*初始化定时器*/
    dev->timer.function = CSlunatic_timer_hander; /*定时器操作函数*/
    dev->timer.expires = jiffies + dev->timer_interval; /*定时时间，*/
    dev->timer.data = (unsigned long)dev; /*传递给定时器操作函数函数的参数*/
    add_timer(&dev->timer);/*将定时器加到定时器队列中*/
    
    filp->private_data = dev;        

    return 0;
}

/*处理FASYNC标志变更*/
static int CSlunatic_fasync(int fd, struct file *filp, int mode)
{
    struct CSlunatic_char_dev *dev = filp->private_data;

    /*将该设备登记到fasync_queue队列中去，也可以从列表中删除*/
    return fasync_helper(fd, filp, mode, &(dev->async_queue));
}


/*设备文件释放时调用*/
static int CSlunatic_release(struct inode *inode, struct file *filp) 
{    
    struct CSlunatic_char_dev *dev;
    
    dev = (struct CSlunatic_char_dev*)filp->private_data;
    
    del_timer(&dev->timer);

    /*将文件从异步通知列表中删除*/
    CSlunatic_fasync(-1, filp, 0);
        
    printk("CSlunatic device close success!\n");
    
    return 0;
}

/*读取设备的缓冲区的值
   linux驱动中断屏蔽local_irq_disable(屏蔽中断)，local_irq_enable(开中断)
   linux 驱动阻塞wait_event_interruptible()(睡眠)   wake_up_interruptible() (唤醒)，
   linux驱动的同步down_interruptible()(获取信号量)  up(释放信号量)，
   linux驱动的互斥spin_lock(获取自旋锁)，spin_unlock(释放自旋锁),
   进程尽量不要嵌套互斥锁(或者自旋锁)
   */
static ssize_t CSlunatic_read(struct file* filp, char __user *buf, size_t count, loff_t* f_pos) 
{   
    ssize_t err = 0;    
    struct CSlunatic_char_dev *dev = filp->private_data;            

  
    /*同步访问
       当获取信号量成功时，对信号量的值减一。else表示获取信号量失败，此时进程进入睡眠状态，并将此进程插入到等待队列尾部
     */    
    if(down_interruptible(&(dev->sem))) {        
        return -ERESTARTSYS;    
    }  
    
    while(dev->current_len == 0){
        if(filp->f_flags & O_NONBLOCK){
            err = -EAGAIN; 
            goto out;
        }

        up(&(dev->sem));   
        
         /*为了将进程以一种安全的方式进入休眠，我们需要牢记两条规则：
             一、永远不要在原子上下文中进入休眠。
             二、进程休眠后，对环境一无所知。唤醒后，必须再次检查以确保我们等待的条件真正为真简单休眠
       */
        /*条件为真，当前进程的状态设置成TASK_INTERRUPTIBLE，然后调用schedule()，
           而schedule()会将位于TASK_INTERRUPTIBLE状态的当前进程从runqueue 队列中删除。
           从runqueue队列中删除的结果是，当前这个进程将不再参 与调度，除非通过其他函数将这个进程重新放入这个runqueue队列中
        */
        if (wait_event_interruptible(dev->r_wait, dev->current_len == 0)){
            return -ERESTARTSYS;
        }

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

     if(count > dev->current_len)
        count = dev->current_len;

    /*将缓冲区buf的值拷贝到用户提供的缓冲区*/   
    if(copy_to_user(buf, dev->buf,  count)){      
        err = -EFAULT;      
        goto out;   
     }   
    
    wake_up_interruptible(&dev->w_wait);

    /*产生异步读信号
    这样后我们在需要的地方（比如中断）调用下面的代码,就会向fasync_queue队列里的设备发送SIGIO
   信号，应用程序收到信号，执行处理程序
   注意, 一些设备还实现异步通知来指示当设备可被写入时; 在这个情况, 
   当然, kill_fasnyc 必须被使用一个 POLL_OUT 模式来调用.*/
    if(dev->async_queue)
        kill_fasync(&(dev->async_queue), SIGIO, POLL_IN);/*释放信号用的函数*/
    
    err = count;
    
 out: 
    up(&(dev->sem));   
    return err;
}

/*写设备的缓冲区buf*/
static ssize_t CSlunatic_write(struct file* filp, const char __user *buf, size_t count, loff_t* f_pos) 
{    
    struct CSlunatic_char_dev *dev = filp->private_data;    
    ssize_t err = 0;            

    /*同步访问*/    
    if(down_interruptible(&(dev->sem))) {      
        return -ERESTARTSYS;            
    }         

    while(dev->current_len == MAX_FIFO_BUF){
        if(filp->f_flags & O_NONBLOCK){
            err = -EAGAIN; 
            goto out;
        }

         up(&(dev->sem));   
         
        if (wait_event_interruptible(dev->w_wait, dev->current_len == 0)){
            err = -ERESTARTSYS;
            goto out;
        }

        if(down_interruptible(&(dev->sem))) {      
            return -ERESTARTSYS;            
        }        
    }
      
    if(count > (MAX_FIFO_BUF - dev->current_len))
    {
        count = MAX_FIFO_BUF-dev->current_len;
    }
    
    /*将用户提供的缓冲区的值写到设备寄存器去*/    
    if(copy_from_user(dev->buf + dev->current_len, buf, count)) {    
        err = -EFAULT;        
        goto out;    
    }
    
    dev->current_len += count;
    
    /*条件为真，且需要唤醒进程*/
   wake_up_interruptible(&(dev->r_wait));
   
    err = count;
    
out:    
    up(&(dev->sem));    
    return err;
}

/*驱动的ioctl实现*/
static long CSlunatic_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
    struct CSlunatic_char_dev *dev = filp->private_data;

    switch(cmd){
    case MEM_CLEAR:
        if(down_interruptible(&(dev->sem)))
            return -ERESTARTSYS;

        memset(dev->buf, 0, MAX_FIFO_BUF);
        up(&(dev->sem));

        printk(KERN_INFO "globamem is set to zero \n");
        break;
    default:
        return -EINVAL;
    }
}

/*非阻塞的时候轮询操作*/
static unsigned int CSlunatic_poll(struct file *filp, poll_table *wait)
{
    unsigned int mask = 0;
    struct CSlunatic_char_dev *dev = filp->private_data;  // 获得设备结构指针

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

    /*加入这两句话是为了在读写状态发生变化的时候，通知核心层，让核心层重新调用poll函数查询信息。
    也就是说这两句只会在select阻塞的时候用到。当利用select函数发现既不能读又不能写时，select
    函数会阻塞，但是此时的阻塞并不是轮询，而是睡眠，通过下面两个队列发生变化时通知select*/
    poll_wait(filp, &dev->r_wait, wait);  // 加读等待队列头
    poll_wait(filp, &dev->w_wait, wait);  // 加写等待队列头
   
    if(dev->current_len != 0)  // 可读
    {
        mask |= POLLIN | POLLRDNORM;  // 标示数据可获得
    }
   
    if(dev->current_len != MAX_FIFO_BUF)  // 可写
    {
        mask |= POLLOUT | POLLWRNORM;  // 标示数据可写入
    }

    up(&(dev->sem));
    
    return mask;
}

/*读取寄存器val的值到缓冲区buf中，内部使用*/
static ssize_t __CSlunatic_get_val(struct CSlunatic_char_dev *dev, char *buf) 
{    
    int val = 0;            

    /*同步访问*/    
    if(down_interruptible(&(dev->sem))) {                        
        return -ERESTARTSYS;     
    }            

    val = dev->val;            

    up(&(dev->sem));            

    return snprintf(buf, PAGE_SIZE, "%d\n", val);
}

/*把缓冲区buf的值写到设备寄存器val中去，内部使用*/
static ssize_t __CSlunatic_set_val(struct CSlunatic_char_dev *dev, const char *buf, size_t count) 
{    
    int val = 0;            

    /*将字符串转换成数字*/            
    val = simple_strtol(buf, NULL, 10);

    /*這個函数的功能就是获得信号量，如果得不到信号量就睡眠，此時沒有信號打斷打断，那么进
     入睡眠。但是在睡眠过程中可能被信号量打断，打断之后返回-EINTR，主要用来进程间的互斥同步。
     使用可被中断的信号量版本的意思是，万一出現了semaphore的死锁，还有机会用ctrl+c发出软中断，
     让等待这个等待内核驱动返回的用用户态进程退出。而不是把整个系統都锁住了。*/            
    if(down_interruptible(&(dev->sem))) {                        
        return -ERESTARTSYS;            
    }            

    dev->val = val;            

    up(&(dev->sem));    

    return count;
}

/*读取设备寄存器val的值，保存在page缓冲区中*/
static ssize_t CSlunatic_proc_read(char *page, char **start, off_t off, int count, int *eof, void *data) 
{    
    if(off > 0) {        
        *eof = 1;      
        return 0;   
    }   

    return __CSlunatic_get_val(CSlunatic_dev, page);
}

/*把缓冲区的值buff保存到设备寄存器val中去*/
static ssize_t CSlunatic_proc_write(struct file *filp, const char __user *buff, unsigned long len, void *data) 
{    
    int err = 0;    
    char* page = NULL;    

    if(len > PAGE_SIZE) {        
        printk(KERN_ALERT"The buff is too large: %lu.\n", len);        
        return -EFAULT;    
    }    

    page = (char*)__get_free_page(GFP_KERNEL);    
    if(!page) {                        
        printk(KERN_ALERT"Failed to alloc page.\n");        
        return -ENOMEM; 
    }           
    
     /*先把用户提供的缓冲区值拷贝到内核缓冲区中去*/    
     if(copy_from_user(page, buff, len)) {        
        printk(KERN_ALERT"Failed to copy buff from user.\n");                        
        err = -EFAULT;        
        goto out;    
     }    

     err = __CSlunatic_set_val(CSlunatic_dev, page, len);

out:
    free_page((unsigned long)page); 
    return err;
}

/*读取设备属性val*/
static ssize_t CSlunatic_val_show(struct device *dev, struct device_attribute *attr, char *buf)
{    
    struct CSlunatic_char_dev* hdev = (struct CSlunatic_char_dev*)dev_get_drvdata(dev);       
    
    return __CSlunatic_get_val(hdev, buf);
}

/*写设备属性val*/
static ssize_t CSlunatic_val_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) 
{     
    struct CSlunatic_char_dev *hdev = (struct CSlunatic_char_dev*)dev_get_drvdata(dev);          

    return __CSlunatic_set_val(hdev, buf, count);
}

/*函数宏DEVICE_ATTR内封装的是__ATTR(_name,_mode,_show,_stroe)方法，_show表示的是读方法，_stroe表示的是写方法。
sysfs接口*/
static DEVICE_ATTR(val, S_IRUGO | S_IWUSR, CSlunatic_val_show, CSlunatic_val_store);

/*创建/proc/CSlunatic文件*/
static void CSlunatic_create_proc(void) 
{    
    struct proc_dir_entry *entry;    
    
    entry = create_proc_entry(CSLUNATIC_DEVICE_PROC_NAME, 0, NULL);    
    if(entry) {        
       // entry->owner = THIS_MODULE;        
        entry->read_proc = CSlunatic_proc_read;        
        entry->write_proc = CSlunatic_proc_write;    
    }
}

/*删除/proc/CSlunatic文件*/
static void CSlunatic_remove_proc(void) 
{    
    remove_proc_entry(CSLUNATIC_DEVICE_PROC_NAME, NULL);
}

/*访问设置属性方法*/
static struct file_operations CSlunatic_fops = {    
    .owner = THIS_MODULE,
    .open = CSlunatic_open, 
    .release = CSlunatic_release,   
    .read = CSlunatic_read, 
    .write = CSlunatic_write,
    .unlocked_ioctl = CSlunatic_ioctl,/*在kernel 2.6.37 中已经完全删除了struct file_operations 中的ioctl 函数指针，取而代之的是unlocked_ioctl */
    .fasync = CSlunatic_fasync,
    .poll = CSlunatic_poll,
};

/*初始化设备*/
static int  __CSlunatic_setup_dev(struct CSlunatic_char_dev *dev) 
{    
    int err;    
    
    dev_t devno = MKDEV(CSlunatic_major, CSlunatic_minor);    

    /*如果cdev 没有分配空间，可以调用cdev_alloc来分配空间*/
    memset(dev, 0, sizeof(struct CSlunatic_char_dev));    

    cdev_init(&(dev->dev), &CSlunatic_fops);    
    dev->dev.owner = THIS_MODULE;    
    dev->dev.ops = &CSlunatic_fops;            

    /*注册字符设备*/    
    err = cdev_add(&(dev->dev),devno, 1);    
    if(err) {        
        return err;    
    }            

    /*初始化信号量
        linux 2.6.37 没有init_MUTEX()函数
        #define init_MUTEX(sem)                  sema_init(sem, 1)*/
    sema_init(&(dev->sem), 1);    

    /*初始化等待队列*/
    init_waitqueue_head(&(dev->r_wait));
    init_waitqueue_head(&(dev->w_wait));
    
    /*寄存器val的值*/
    dev->val = 0;    

    /*定时器间隔10 S*/
    dev->timer_interval = 10 * HZ;
    
    return 0;
}

/*模块加载方法  insmod cslunatic_drv.ko int_var=100 str_var=hello int_array=100,200
  * modinfo cslunatic_drv.ko 查看模块信息
  * lsmod 查看已加载的模块
  * modprobe 挂载新模块以及新模块相依赖的模块,若在载入过程中发生错误，在modprobe会卸载整组的模块。
  * modprobe 命令是根据depmod -a的输出/lib/modules/version/modules.dep来加载全部的所需要模块。
  * modprobe -r  模块名也可以卸载模块
  * rmmod cslunatic_drv.ko 卸载模块
  * dmesg | tail -8 查看输出的末尾8行信息
  */
static int __init CSlunatic_init(void)
{     
    int err = -1;    
    int i = 0;
    dev_t dev = 0;    
    struct device *temp = NULL;    

    printk(KERN_ALERT"Initializing CSlunatic device.\n");        
    printk(KERN_ALERT "int_var %d.\n", int_var);
    printk(KERN_ALERT "str_var %s.\n", str_var);

    for(i = 0; i < narr; i ++){
        printk("int_array[%d] = %d\n", i, int_array[i]);
    }

    if (!CSlunatic_major) {
        /*动态设备号分配*/
        err = alloc_chrdev_region(&dev, 0, 1, CSLUNATIC_DEVICE_NODE_NAME);
        if (!err) {
            CSlunatic_major = MAJOR(dev);
            CSlunatic_minor = MINOR(dev);
        }
    } else {
        /*静态设备号分配*/
        dev = MKDEV(CSlunatic_major, CSlunatic_minor);
        err = register_chrdev_region(dev,1, CSLUNATIC_DEVICE_NODE_NAME);
    }
    if(err < 0) {        
        printk(KERN_ALERT"Failed to alloc char dev region.\n");     
        goto fail;  
    }   
    
    /*分配CSlunatic设备结构体变量*/    
    CSlunatic_dev = kmalloc(sizeof(struct CSlunatic_char_dev), GFP_KERNEL);    
    if(!CSlunatic_dev) {        
        err = -ENOMEM;      
        printk(KERN_ALERT"Failed to alloc CSlunatic_dev.\n");        
        goto unregister;    
    }            

    /*初始化设备*/    
    err = __CSlunatic_setup_dev(CSlunatic_dev);
    if(err) {        
        printk(KERN_ALERT"Failed to setup dev: %d.\n", err);        
        goto cleanup;    
    }            

    /*在/sys/class/目录下创建设备类别目录CSlunatic*/    
    CSlunatic_class = class_create(THIS_MODULE, CSLUNATIC_DEVICE_CLASS_NAME);    
    if(IS_ERR(CSlunatic_class)) {        
        err = PTR_ERR(CSlunatic_class);     
        printk(KERN_ALERT"Failed to create CSlunatic class.\n");        
        goto destroy_cdev;    
    }            

    /* 在/dev/目录和/sys/class/CSlunatic目录下分别创建设备文件CSlunatic* 也可以手工(mknod /dev/fgj c 50 0) 创建设备节点  
　　当使用udev制作的文件系统时，内核为我们提供了一组函数，可以用来在模块加载的时候自动在/dev目录下创建设备文件OR在卸载时自动删除设备文件。
　　主要涉及两个函数
　　class_create(owner, class_name) 
　　用来在sysfs创建一个类，设备信息导出在这下面；
　　struct device *device_create(struct class *class, struct device *parent,
    　　　　　　　　　　　　　　　　dev_t devt, void *drvdata, const char *fmt, ...)
　　用来在/dev目录下创建一个设备文件；
　　加载模块时，用户空间的udev会自动响应device_create()函数，在sysfs下寻找对应的类从而创建设备节点。
　　*/
    temp = device_create(CSlunatic_class, NULL, dev, "%s", CSLUNATIC_DEVICE_FILE_NAME);    
    if(IS_ERR(temp)) {        
        err = PTR_ERR(temp);        
        printk(KERN_ALERT"Failed to create CSlunatic device.");    
        goto destroy_class; 
    }      
    
    /*在/sys/class/CSlunatic/CSlunatic目录下创建属性文件val*/    
    err = device_create_file(temp, &dev_attr_val);    if(err < 0) {        
        printk(KERN_ALERT"Failed to create attribute val.");                        
        goto destroy_device;    
    }    

   /*设置设备的私有数据dev_get_drvdata 获取设备的相关信息
    如果在这里没有设置，也可以在open函数的时候设置*/
    dev_set_drvdata(temp, CSlunatic_dev);            

    /*创建/proc/CSlunatic文件*/    
    CSlunatic_create_proc();    
    
    printk(KERN_ALERT"Succedded to initialize CSlunatic device.\n");    
    
    return 0;
    
 destroy_device:    
    device_destroy(CSlunatic_class, dev);
destroy_class:    
    class_destroy(CSlunatic_class);
destroy_cdev:    
    cdev_del(&(CSlunatic_dev->dev));
cleanup:    
     kfree(CSlunatic_dev) ;
unregister:    
    unregister_chrdev_region(MKDEV(CSlunatic_major, CSlunatic_minor), 1);
fail:    
    return err;
}

/*模块卸载方法*/
static void __exit CSlunatic_exit(void) 
{   
    dev_t devno = MKDEV(CSlunatic_major, CSlunatic_minor);    
    printk(KERN_ALERT"Destroy CSlunatic device.\n");            

    /*删除/proc/CSlunatic文件*/    
    CSlunatic_remove_proc();            

    /*销毁设备类别和设备*/    
    if(CSlunatic_class) {        
        device_destroy(CSlunatic_class, MKDEV(CSlunatic_major, CSlunatic_minor));        
        class_destroy(CSlunatic_class);    
    }            

    /*删除字符设备和释放设备内存*/    
    if(CSlunatic_dev) {        
        cdev_del(&(CSlunatic_dev->dev));        
        kfree(CSlunatic_dev);    
     }            

     /*释放设备号*/    
     unregister_chrdev_region(devno, 1);
}

/*module_init中的初始化函数在系统启动过程中start_kernel()->rest_init()->kernel_init()->do_basic_setup()->do_initcalls()。
    do_initcalls调用.initcall.init节的函数指针，初始化内核模块。
    #define module_init(x) __initcall(x);
    #define __initcall(fn) device_initcall(fn)
    #define device_initcall(fn)           __define_initcall("6",fn)
    看出module_init是设备驱动的初始化，等级为6(也就是初始化的顺序为6)
    #define core_initcall(fn)        __define_initcall("1",fn)
    #define postcore_initcall(fn)        __define_initcall("2",fn)
    #define arch_initcall(fn)        __define_initcall("3",fn)
    #define subsys_initcall(fn)            __define_initcall("4",fn)
    #define fs_initcall(fn)                     __define_initcall("5",fn)
    #define device_initcall(fn)           __define_initcall("6",fn)
    #define late_initcall(fn)         __define_initcall("7",fn)
   */
module_init(CSlunatic_init);
module_exit(CSlunatic_exit);

/*
  * EXPORT_SYMBOL只出现在2.6内核中，在2.4内核默认的非static 函数和变量都会自动导入到kernel 空间的， 都不用EXPORT_SYMBOL() 做标记的。
  * 2.6就必须用EXPORT_SYMBOL() 来导出来（因为2.6默认不到处所有的符号）。
  * EXPORT_SYMBOL标签内定义的函数或者符号对全部内核代码公开，不用修改内核代码就可以在您的内核模块中直接调用，即使用
  * EXPORT_SYMBOL可以将一个函数以符号的方式导出给其他模块使用。
  * 这里要和System.map做一下对比：
  * System.map 中的是连接时的函数地址。连接完成以后，在2.6内核运行过程中，是不知道哪个符号在哪个地址的。
  * EXPORT_SYMBOL的符号，是把这些符号和对应的地址保存起来，在内核运行的过程中，可以找到这些符号对应的地址。而模块在加载过程中，其本质就 
  * 是能动态连接到内核，如果在模块中引用了内核或其它模块的符号，就要EXPORT_SYMBOL这些符号，这样才能找到对应的地址连接。
  * 使用方法
  *     第一、在模块函数定义之后使用EXPORT_SYMBOL（函数名）
  *     第二、在调用该函数的模块中使用extern对之声明
  *     第三、首先加载定义该函数的模块，再加载调用该函数的模块
  *     另外，在编译调用某导出函数的模块时，往往会有WARNING: "＊＊＊＊" [＊＊＊＊＊＊＊＊＊＊] undefined!
  *  使用dmesg 命令后会看到相同的信息。开始我以为只要有这个错误就不能加载模块，后来上网查了一下，
  *  发现这主要是因为在编译连接的时候还没有和内核打交 道，当然找不到symbol了，但是由于你生成的是一个内核模块，
  *   所以ld 不提示error，而是给出一个warning，寄希望于在 insmod的时 候，内核能够把这个symbol连接上。
  */
void CSlunatic_fun(void)  
{  
    printk("CSlunatic_fun \n");  
}  
EXPORT_SYMBOL(CSlunatic_fun);  

/*_GPL版本的宏定义只能使符号对GPL许可的模块可用*/
void CSlunatic_fun_GPL(void)  
{  
    printk("hello wold again\n");  
}  
EXPORT_SYMBOL_GPL(CSlunatic_fun_GPL);  

/* 
  * module_param() 和 module_param_array() 的作用就是让那些全局变量对 insmod 可见，使模块装载时可重新赋值。
  * module_param_array() 宏的第三个参数用来记录用户 insmod 时提供的给这个数组的元素个数，NULL 表示不关心用户提供的个数
  * module_param() 和 module_param_array() 最后一个参数权限值不能包含让普通用户也有写权限，否则编译报错。这点可参考 linux/moduleparam.h 中 __module_param_call() 宏的定义。
  * 通过宏MODULE_PARM_DESC()对参数进行说明
  * 通过宏module_param_array_named()使得内部的数组名与外部的参数名有不同的名字。
  * 通过宏module_param_string()让内核把字符串直接复制到程序中的字符数组内。
  * 字符串数组中的字符串似乎不能包含逗号，否则一个字符串会被解析成两个
  */
module_param(int_var, int, 0644);
MODULE_PARM_DESC(int_var, "A integer variable");

module_param(str_var, charp, 0644);
MODULE_PARM_DESC(str_var, "A string variable");

module_param_array(int_array, int, &narr, 0644);
MODULE_PARM_DESC(int_array, "A integer array");

MODULE_LICENSE("GPL");
MODULE_AUTHOR("CSlunatic");
MODULE_DESCRIPTION("Linux Device Driver");

Makefile的实现：

#用+= 可以实现多个模块同时编译
#obj-m += mod.o
obj-m += cslunatic_drv.o
#设置你嵌入式开发板的内核源码路径，主要是内核的include目录下的头文件
KDIR = /opt/DM8168_DVRRDK_V03.00.00.00/ti_tools/linux_lsp/linux-psp-dvr-04.04.00.01/src/linux-04.04.00.01
#KDIR = libmodules$(shell uname -r)build
PWD = $(shell pwd)

default:
    $(MAKE) -C$(KDIR) CROSS_COMPILE=/opt/armgcc/bin/arm-none-linux-gnueabi- ARCH=arm SUBDIRS=$(PWD) modules

#    $(MAKE) -C $(KDIR) SUBDIRS=$(PWD) modules
clean:    
    $(MAKE) -C$(KDIR) CROSS_COMPILE=/opt/armgcc/bin/arm-none-linux-gnueabi- ARCH=arm SUBDIRS=$(PWD) clean
    rm -rf Module.markers Modules.order Moduke.symvers

linux驱动的入口函数module_init的加载和释放:

#define module_init(x)     __initcall(x);              //include/linux/init.h

#define __initcall(fn) device_initcall(fn)

#define device_initcall(fn)                 __define_initcall("6",fn,6)

#define __define_initcall(level,fn,id) /

         static initcall_t __initcall_##fn##id __used /

         __attribute__((__section__(".initcall" level ".init"))) = fn

      如果某驱动想以func作为该驱动的入口，则可以如下声明：module_init(func);被上面的宏处理过后，变成__initcall_func6 __used加入到内核映像的".initcall"区。内核的加载的时候，会搜索".initcall"中的所有条目，并按优先级加载它们，普通驱动程序的优先级是6。其它模块优先级列出如下：值越小，越先加载。

#define pure_initcall(fn)           __define_initcall("0",fn,0)

#define core_initcall(fn)            __define_initcall("1",fn,1)

#define core_initcall_sync(fn)          __define_initcall("1s",fn,1s)

#define postcore_initcall(fn)             __define_initcall("2",fn,2)

#define postcore_initcall_sync(fn)  __define_initcall("2s",fn,2s)

#define arch_initcall(fn)            __define_initcall("3",fn,3)

#define arch_initcall_sync(fn)          __define_initcall("3s",fn,3s)

#define subsys_initcall(fn)                 __define_initcall("4",fn,4)

#define subsys_initcall_sync(fn)      __define_initcall("4s",fn,4s)

#define fs_initcall(fn)                          __define_initcall("5",fn,5)

#define fs_initcall_sync(fn)               __define_initcall("5s",fn,5s)

#define rootfs_initcall(fn)                  __define_initcall("rootfs",fn,rootfs)

#define device_initcall(fn)                 __define_initcall("6",fn,6)

#define device_initcall_sync(fn)       __define_initcall("6s",fn,6s)

#define late_initcall(fn)             __define_initcall("7",fn,7)

#define late_initcall_sync(fn)           __define_initcall("7s",fn,7s)

可以看到，被声明为pure_initcall的最先加载。

module_init除了初始化加载之外，还有后期释放内存的作用。linux kernel中有很大一部分代码是设备驱动代码，这些驱动代码都有初始化和反初始化函数，这些代码一般都只执行一次，为了有更有效的利用内存，这些代码所占用的内存可以释放出来。

linux就是这样做的，对只需要初始化运行一次的函数都加上__init属性，__init 宏告诉编译器如果这个模块被编译到内核则把这个函数放到（.init.text）段，module_exit的参数卸载时同__init类似，如果驱动被编译进内核，则__exit宏会忽略清理函数，因为编译进内核的模块不需要做清理工作，显然__init和__exit对动态加载的模块是无效的，只支持完全编译进内核。

在kernel初始化后期，释放所有这些函数代码所占的内存空间。连接器把带__init属性的函数放在同一个section里，在用完以后，把整个section释放掉。当函数初始化完成后这个区域可以被清除掉以节约系统内存。Kenrel启动时看到的消息“Freeing unused kernel memory: xxxk freed”同它有关。