Linux Kernel Module(LKM) Init、Delete Code Principle Learning

            1
            . Linux模块(LKM)简介

            2
            . 使用Linux模块

            3
            . LKM模块加载原理

            4. LKM模块卸载原理

            1
            . 通过使用模块，内核程序员能够预先编译大量驱动程序，而不会致使内核映像的尺寸发生膨胀。在自动检测硬件或用户提示后，安装例程会选择适当的模块并将其添加到内核中

            2
            . 内核开发者可以将试验性的代码打包到模块中，模块可疑卸载，修改代码或重新打包后再重新加载，这使得可以快速测试新特性，无需每次都重启系统

            3. 模块(LKM)可疑无缝地插入到内核中，同时模块也可以导出一些函数，可以由其他核心模块(以及持久编译到内核中的代码)使用。在模块代码需要卸载时，模块和内核剩余部分之间的关联会自动终止

            1
            . 模块B依赖模块A
除非模块A已经驻留在内核内存，否则模块B无法装载


            2
            . 模块B引用模块A
除非模块B已经移除，否则模块A无法从内核移除，在内核中，这种关系称之为
            "
            模块B使用模块A
            "
        

            1
            . 模块B依赖模块A
除非模块A已经驻留在内核内存，否则模块B无法装载


            2
            . 模块B引用模块A
除非模块B已经移除，否则模块A无法从内核移除，在内核中，这种关系称之为
            "
            模块B使用模块A
            "
        

            1
            . modprobe
它考虑了各个模块之间可能出现的依赖性(在一个模块依赖于一个或多个合作者模块的功能时)，modprobe在识别出目标模块所依赖的模块之后，在内核也会使用insmod(即modprobe只是对insmod的一个包装)


            2
            . insmod
insmod只加载一个单一的模块到内核中，且该模块只信赖内核中已经存在的代码(不管是通过模块动态加载的、还是持久编译到内核中的)
        

            1
            . init_module()
init_module()是一个系统调用，用户空间的工具只需要提供二进制数据，所有其他工作(重定位、解决引用问题)由内核自身完成


            2
            . request_module()
request_module()不是系统调用，它用于从内核端加载模块，它不仅用于加载模块，还用于实现热插拔功能
        

            1. rmmod

            1
            . delete_module()
delete_module()是一个系统调用，它用于从内核移除一个模块，前提是该模块代码不再使用，且其他模块也不再使用该模块导出的函数(即不能有依赖关系)
        

http://files.cnblogs.com/LittleHann/Modultils%E5%B7%A5%E5%85%B7%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%E2%80%94%E2%80%94insmod%E7%AF%87.pdf

\linux-2.6.32.63\kernel\module.c
SYSCALL_DEFINE3(init_module, void __user *, umod, unsigned long, len, constchar __user *, uargs)
    1. *umod
    指向用户地址空间中的区域，表示模块的名字
    2. len
    该区域的长度
    3. *uargs
    指向字符串的指针，指定了模块的参数

            /*
             This is where the real work happens 
            */
            
SYSCALL_DEFINE3(init_module, 
            void __user *, umod, unsigned long, len, constchar __user *, uargs)
{
    struct module *mod;
    int ret = 0;

    /*
    Must have permission 
    确保有插入和删除模块不受限制的权利，并且模块没有被禁止插入或删除
    */if (!capable(CAP_SYS_MODULE) || modules_disabled)
    {
        return -EPERM;
    }
        

    /* Only one module load at a time, please */if (mutex_lock_interruptible(&module_mutex) != 0)
        return -EINTR;

    /* 
    Do all the hard work 
    分配，加载模块，并创建相关的sysfs文件
    */
    mod = load_module(umod, len, uargs);
    if (IS_ERR(mod)) 
    {
        mutex_unlock(&module_mutex);
        return PTR_ERR(mod);
    }

    /* Drop lock so they can recurse */
    mutex_unlock(&module_mutex);

    /*
    通知内核通知链module_notify_list上的监听者，模块状态变为MODULE_STATE_COMING
    关于module的状态信息，请参阅http://www.cnblogs.com/LittleHann/p/3865490.html，搜索: struct module
         enum module_state
        {
            MODULE_STATE_LIVE,    //模块当前正常使用中(存活状态) 
            MODULE_STATE_COMING,    //模块当前正在被加载
            MODULE_STATE_GOING,    //模块当前正在被卸载
        };
    */
    blocking_notifier_call_chain(&module_notify_list, MODULE_STATE_COMING, mod);

    //调用本模块的所有构造器    do_mod_ctors(mod);
    /* 
    Start the module 
    调用模块的init方法
    */if (mod->init != NULL)
        ret = do_one_initcall(mod->init);
    if (ret < 0)
    {
        /* Init routine failed: abort.  Try to protect us from
                   buggy refcounters. */
        mod->state = MODULE_STATE_GOING;
        synchronize_sched();
        module_put(mod);
        blocking_notifier_call_chain(&module_notify_list, MODULE_STATE_GOING, mod);
        mutex_lock(&module_mutex);
        free_module(mod);
        mutex_unlock(&module_mutex);
        wake_up(&module_wq);
        return ret;
    }
    if (ret > 0) 
    {
        printk(KERN_WARNING
"%s: ‘%s‘->init suspiciously returned %d, it should follow 0/-E convention\n""%s: loading module anyway...\n",
               __func__, mod->name, ret,
               __func__);
        dump_stack();
    }

    /* 
    Now it‘s a first class citizen!  Wake up anyone waiting for it.  
    */
    mod->state = MODULE_STATE_LIVE;
    //唤醒module_wq 队列上等待本模块初始化的所有任务
    wake_up(&module_wq);
    //通知内核通知链module_notify_list上的监听者，模块状态变为MODULE_STATE_LIVE
    blocking_notifier_call_chain(&module_notify_list, MODULE_STATE_LIVE, mod);

    /* 
    We need to finish all async code before the module init sequence is done 
    等待所有的异步函数调用完成
    */
    async_synchronize_full();

    //获得module_mutex锁，module_mutex作用之一就是保护全局的模块链表
    mutex_lock(&module_mutex);
    /* Drop initial reference. */
    module_put(mod);
    trim_init_extable(mod);
#ifdef CONFIG_KALLSYMS
    mod->num_symtab = mod->core_num_syms;
    mod->symtab = mod->core_symtab;
    mod->strtab = mod->core_strtab;
#endif/*
    释放与模块初始化相关的节区所占的内存
    这点和windows下的驱动加载是类似的，仅仅用于驱动加载的那部分"派遣初始化函数"被分配到"可换页内存"区域中，当驱动加载完毕后就立即释放
    */
    module_free(mod, mod->module_init);
    mod->module_init = NULL;
    mod->init_size = 0;
    mod->init_text_size = 0;
    mutex_unlock(&module_mutex);

    return0;
}

http://bbs.chinaunix.net/thread-2194837-1-1.html
http://blog.csdn.net/wuhui_gdnt/article/details/5316616
http://blog.csdn.net/muge0913/article/details/7518568
http://blog.csdn.net/ganggexiongqi/article/details/6823960

SYSCALL_DEFINE2(delete_module, constchar __user *, name_user, unsigned int, flags)
    1. name_user
    待卸载的模块名称
    2. flags

SYSCALL_DEFINE2(delete_module, constchar __user *, name_user, unsigned int, flags)
{
    struct module *mod;
    char name[MODULE_NAME_LEN];
    int ret, forced = 0;

    //确保有插入和删除模块不受限制的权利，并且模块没有被禁止插入或删除if (!capable(CAP_SYS_MODULE) || modules_disabled)
        return -EPERM;

    //获得从用户空间传递到内核空间的模块名字 if (strncpy_from_user(name, name_user, MODULE_NAME_LEN-1) < 0)
        return -EFAULT;
    name[MODULE_NAME_LEN-1] = ‘\0‘;

    /* Create stop_machine threads since free_module relies on
     * a non-failing stop_machine call. */
    ret = stop_machine_create();
    if (ret)
        return ret;

    //获得module_mutex锁 if (mutex_lock_interruptible(&module_mutex) != 0) {
        ret = -EINTR;
        goto out_stop;
    }

    //得到要卸载的模块的指针
    mod = find_module(name);
    if (!mod) {
        ret = -ENOENT;
        gotoout;
    }

    /*
    检查，确认没有其他模块依赖要卸载的模块
    关于linux下模块间的依赖性以及相关数据结构，请参阅另一篇文章
    http://www.cnblogs.com/LittleHann/p/3865490.html，搜索: struct module_use
    */if (!list_empty(&mod->modules_which_use_me)) {
        /* Other modules depend on us: get rid of them first. */
        ret = -EWOULDBLOCK;
        gotoout;
    }

    /* 
    Doing init or already dying? 
    检查模块的状态是否是 MODULE_STATE_LIVE 
    */if (mod->state != MODULE_STATE_LIVE) {
        /* FIXME: if (force), slam module count and wake up
                   waiter --RR */
        DEBUGP("%s already dying\n", mod->name);
        ret = -EBUSY;
        gotoout;
    }

    /* If it has an init func, it must have an exit func to unload */if (mod->init && !mod->exit) {
        forced = try_force_unload(flags);
        if (!forced) {
            /* This module can‘t be removed */
            ret = -EBUSY;
            gotoout;
        }
    }

    /* 
    Set this up before setting mod->state 
    设置等待本模块退出 的进程为current
    */
    mod->waiter = current;

    /* Stop the machine so refcounts can‘t move and disable module. */
    ret = try_stop_module(mod, flags, &forced);
    if (ret != 0)
        gotoout;

    /* 
    Never wait if forced. 
    等待模块的引用计数变为0
    */if (!forced && module_refcount(mod) != 0)
    {
        wait_for_zero_refcount(mod);
    } 

    //释放module_mutex锁 
    mutex_unlock(&module_mutex);
    /* 
    Final destruction now noone is using it. 
    调用模块本身的exit函数
    */if (mod->exit != NULL)
    {
        mod->exit();
    } 
    //告诉通知链module_notify_list上的监听者，模块状态 变为 MODULE_STATE_GOING
    blocking_notifier_call_chain(&module_notify_list, MODULE_STATE_GOING, mod);
    //等待所有的异步函数调用完成    async_synchronize_full();
    mutex_lock(&module_mutex);
    /* Store the name of the last unloaded module for diagnostic purposes */
    strlcpy(last_unloaded_module, mod->name, sizeof(last_unloaded_module));
    free_module(mod);

 out:
    mutex_unlock(&module_mutex);
out_stop:
    stop_machine_destroy();
    return ret;
}