linux 内核模块 && 强制卸载

最新推荐文章于 2024-08-14 17:06:28 发布
最新推荐文章于 2024-08-14 17:06:28 发布
阅读量8.2k 收藏 16
点赞数 3
分类专栏： linux 文章标签： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42121713/article/details/108989873
版权

0 问题：某项目中，关于一种调用设备驱动程序，出现异常时，驱动设备无法正常退出（lsmod 显示驱动设备被占用、无法rmmod 退出），也无法继续使用的问题。

1 linux 模块

内核模块是Linux内核向外部提供的一个插口，其全称为动态可加载内核模块（Loadable Kernel Module，LKM），我们简称为模块。模块具有以下特点：   

        模块本身不被编译入内核映像，从而控制了内核的大小 。

        模块一旦被加载，它就和内核中的其他部分一样 。 

 模块是具有独立功能的程序，它可以被单独编译，但不能独立运行。它在运行时被链接到内核作为内核的一部分在内核空间运行，这与运行在用户空间的进程是不同的。模块通常由一组函数和数据结构组成，用来实现一种文件系统、一个驱动程序或其他内核上层的功能。

2 编译内核模块

hello 模块

#include <linux/module.h> //所有模块都需要的头文件
#include <linux/init.h>   // init&exit相关宏
#include <linux/kernel.h>
 
MODULE_LICENSE("GPL");
MODULE_AUTHOR("xxx");      
MODULE_DESCRIPTION("hello world module");
 
static int __init hello_init(void)
{
      printk(KERN_WARNING "hello world.\n");
      return 0;
}
static void __exit hello_exit(void)
{
      printk(KERN_WARNING "hello exit!\n");
}
 
module_init(hello_init);
module_exit(hello_exit);

Makefile

ifneq ($(KERNELRELEASE),)
obj-m :=hello.o
else
KDIR :=/lib/modules/$(shell uname -r)/build
all:
	make -C $(KDIR) M=$(PWD) modules
clean:
	rm -f *.ko *.o *.mod.o *.mod.c *.symvers *.order
endif

使用

make 

sudo insmod hello.ko

sudo rmmod hello

dmesg

[10611.395806] hello world.
[10644.832158] hello exit!

 KERNELRELEASE

这个 makefile 在一次典型的建立中要被读 2 次。

KERNELRELEASE是在内核源码的顶层Makefile中定义的一个变量，在第一次(刚开始)读取执行此Makefile时，KERNELRELEASE没有被定义（为空），所以make将读取执行else之后的内容。如果make的目标是clean，直接执行clean操作，然后结束。当make的目标为all时，-C(KDIR)指明跳转到内核源码目录下读取那里的Makefile，M=(PWD)表明然后返回到当前目录继续读入、执行当前的Makefile。当从内核源码目录返回时，KERNELRELEASE已被被定义，kbuild也被启动去解析kbuild语法的语句，make将继续读取else之前的内容（指 obj-m :=hello.o）。else之前的内容为kbuild语法的语句,指明模块源码中各文件的依赖关系，以及要生成的目标模块名。

以上介绍了内核模块的概念以及内核模块的编译。

3 强制卸载内核模块

发现一篇非常好的文章，对照无法强制卸载内核模块的各个情况，相应进行了介绍。

原文链接:Linux强制卸载内核模块(由于驱动异常导致rmmod不能卸载)

对照文章，本人遇到的驱动被占用问题属于以下这种类型。

引用计数在有其它模块或者内核本身引用的时候不为0，要卸载就要等待它们不引用为止used需要通过外部修正的方式, 将驱动的引用计数置 0 即可

（1）现象

rmmod: ERROR: Module XXX is in use

（2）其本质就是模块的模块的引用计数不为 0, 要解决此类问题, 只需要将模块的引用计数强制置为 0 即可.

  1. 查找到 none_exit 模块的内核模块结构 struct moudle, 可以通过 find_module 函数查找到, 也可以参照 find_module 函数实现.

  2. 重置模块的引用计数

    //  清除驱动的引用计数
for_each_possible_cpu(cpu)
{
    local_set((local_t*)per_cpu_ptr(&(mod->refcnt), cpu), 0);
    //local_set(__module_ref_addr(mod, cpu), 0);
    //per_cpu_ptr(mod->refptr, cpu)->decs;
    //module_put(mod);
}
atomic_set(&mod->refcnt, 1);

4 强制卸载驱动源码

#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/cpumask.h>
#include <linux/list.h>
#include <asm-generic/local.h>
#include <linux/platform_device.h>
#include <linux/kallsyms.h>
#include <linux/sched.h>


/*
 *  加载模块的时候, 传递字符串到模块的一个全局字符数组里面
 *
 *  module_param_string(name, string, len, perm)
 *
 *  @name   在加载模块时，参数的名字
 *  @string 模块内部的字符数组的名字
 *  @len    模块内部的字符数组的大小
 *  #perm   访问权限
 *
 * */
static char *modname = NULL;
module_param(modname, charp, 0644);
MODULE_PARM_DESC(modname, "The name of module you want do clean or delete...\n");


//#define CONFIG_REPLACE_EXIT_FUNCTION

#ifdef CONFIG_REPLACE_EXIT_FUNCTION
//  此处为外部注册的待卸载模块的exit函数
//  用于替代模块原来的exit函数
//  注意--此函数由于需要被待删除模块引用, 因此不能声明为static
/* static */ void force_replace_exit_module_function(void)
{
    /
    //  此处完善待卸载驱动的 exit/cleanup 函数
    /

    printk("module %s exit SUCCESS...\n", modname);
//    platform_device_unregister((struct platform_device*)(*(int*)symbol_addr));
}
#endif  //  CONFIG_REPLACE_EXIT_FUNCTION


static int force_cleanup_module(char *del_mod_name)
{
    struct module   *mod = NULL, *relate = NULL;
    int              cpu;
#ifdef CONFIG_REPLACE_EXIT_FUNCTION
    void            *origin_exit_addr = NULL;
#endif

    /
    //  找到待删除模块的内核module信息
    /
#if 0
    //  方法一, 遍历内核模块树list_mod查询
    struct module *list_mod = NULL;
    /*  遍历模块列表, 查找 del_mod_name 模块  */
    list_for_each_entry(list_mod, THIS_MODULE->list.prev, list)
    {
        if (strcmp(list_mod->name, del_mod_name) == 0)
        {
            mod = list_mod;
        }
    }
    /*  如果未找到 del_mod_name 则直接退出  */
    if(mod == NULL)
    {
        printk("[%s] module %s not found\n", THIS_MODULE->name, modname);
        return -1;
    }
#endif

    //  方法二, 通过find_mod函数查找
    if((mod = find_module(del_mod_name)) == NULL)
    {
        printk("[%s] module %s not found\n", THIS_MODULE->name, del_mod_name);
        return -1;
    }
    else
    {
        printk("[before] name:%s, state:%d, refcnt:%u\n",
                mod->name ,mod->state, module_refcount(mod));
    }

    /
    //  如果有其他驱动依赖于当前驱动, 则不能强制卸载, 立刻退出
    /
    /*  如果有其他模块依赖于 del_mod  */
    if (!list_empty(&mod->source_list))
    {
        /*  打印出所有依赖target的模块名  */
        list_for_each_entry(relate, &mod->source_list, source_list)
        {
            printk("[relate]:%s\n", relate->name);
        }
    }
    else
    {
        printk("No modules depond on %s...\n", del_mod_name);
    }

    /
    //  清除驱动的状态和引用计数
    /
    //  修正驱动的状态为LIVE
    mod->state = MODULE_STATE_LIVE;

    //  清除驱动的引用计数
    for_each_possible_cpu(cpu)
    {
        local_set((local_t*)per_cpu_ptr(&(mod->refcnt), cpu), 0);
        //local_set(__module_ref_addr(mod, cpu), 0);
        //per_cpu_ptr(mod->refptr, cpu)->decs;
        //module_put(mod);
    }
    atomic_set(&mod->refcnt, 1);

#ifdef CONFIG_REPLACE_EXIT_FUNCTION
    /
    //  重新注册驱动的exit函数
    /
    origin_exit_addr = mod->exit;
    if (origin_exit_addr == NULL)
    {
        printk("module %s don't have exit function...\n", mod->name);
    }
    else
    {
        printk("module %s exit function address %p\n", mod->name, origin_exit_addr);
    }

    mod->exit = force_replace_exit_module_function;
    printk("replace module %s exit function address (%p -=> %p)\n", mod->name, origin_exit_addr, mod->exit);
#endif

    printk("[after] name:%s, state:%d, refcnt:%u\n",
            mod->name, mod->state, module_refcount(mod));

    return 0;
}


static int __init force_rmmod_init(void)
{
    return force_cleanup_module(modname);
}


static void __exit force_rmmod_exit(void)
{
    printk("=======name : %s, state : %d EXIT=======\n", THIS_MODULE->name, THIS_MODULE->state);
}

module_init(force_rmmod_init);
module_exit(force_rmmod_exit);

MODULE_LICENSE("GPL");

5 Makefile 

MODULE_NAME := force_rmmod
#MODCFLAGS:=-O2 -Wall -DMODULE -D__KERNEL__ -DLINUX -std=c99
#EXTRA_CFLAGS  += $(MODULE_FLAGS) $(CFG_INC) $(CFG_INC)
EXTRA_CFLAGS  += -g -std=gnu99  -Wfatal-errors 



ifneq ($(KERNELRELEASE),)  # kernelspace

obj-m := $(MODULE_NAME).o

else                        # userspace


CURRENT_PATH ?= $(shell pwd)
LINUX_KERNEL ?= $(shell uname -r)
LINUX_KERNEL_PATH ?= /lib/modules/$(LINUX_KERNEL)/build

CURRENT_PATH := $(shell pwd)

modules:
    make -C $(LINUX_KERNEL_PATH) M=$(CURRENT_PATH) modules

modules_install:
    make -C $(LINUX_KERNEL_PATH) M=$(CURRENT_PATH) modules_install


clean:
    make -C $(LINUX_KERNEL_PATH) M=$(CURRENT_PATH) clean
    rm -f modules.order Module.symvers Module.markers

.PHNOY:
    modules modules_install clean



endif

6 使用方法

# 通过 `modname` 制定待卸载驱动的信息

sudo insmod force_rmmod.ko modname=卸载驱动名称

sudo rmmod 卸载驱动名称

 

查尔斯是码农
关注
专栏目录
Linux模块化机制和module_init
嵌入式企鹅圈
06-30 1万+
致谢：微信公众号：嵌入式企鹅圈每天都新增爱好者关注，感谢大家的支持和大牛们的建议。本人将竭力出品更多优质的原创文章回馈大家的厚爱！模块化机制(module)是Linux系统的一大创新。本文重点阐述Linux module加载的来龙去脉，其中的奥秘就在于对宏module_init的解读。
一文了解linux 内核模块 && 强制卸载
m0_74282605的博客
12-10 1818
0 问题：某项目中，关于一种调用设备驱动程序，出现异常时，驱动设备无法正常退出（lsmod 显示驱动设备被占用、无法rmmod 退出），也无法继续使用的问题。
强力卸载内核模块
热门推荐
zhangskd的专栏
09-09 1万+
概述   内核为2.6.32。 卸载模块target时，不管是否为强制卸载，都输出： ERROR：Module target is in use. 用lsmod查看target，发现Used by计数为1，而据我所知，没有其它模块依赖target。 编写模块检查target的module结构，发现： target->state == 0 // 模块存活 module_refcoun
linux insmod error ko文件
wjw7869的专栏
08-08 3373
ko文件通常是Linux内核模块的文件。 与之相关的命令是 rmmod  内核模块名 # 卸载内核模块 insmod  内核模块名 # 加载内核模块 lsmod 查看 内核模块名，如果对应的计数为0，则表示此内核模块没有被应用程序使用。 被其他进程引用的内核模块不能删除。 内核模块的编译操作系统的内核版本必须和装载内核模块的内核版本一致，否则会提示错误：如下 root@loc
rmmod: ERROR: Module nvidia_uvm is in use
最新发布
keyboard专栏
08-14 658
这个错误信息表示nvidia_uvm内核模块当前正在使用中，因此不能被卸载 (rmmodnvidia_uvm是 NVIDIA Unified Memory 驱动程序的一部分，通常在 CUDA 应用程序运行时会被使用。
Linux模块机制浅析
weixin_33766805的博客
05-15 162
Linux模块机制浅析   Linux允许用户通过插入模块，实现干预内核的目的。一直以来，对linux的模块机制都不够清晰，因此本文对内核模块的加载机制进行简单地分析。 模块的Hello World！ 我们通过创建一个简单的模块进行测试。首先是源文件main.c和Makefile。 florian@florian-pc:~/module$ cat main.c #incl...
c++2013无法卸载_Linux强制卸载内核模块(由于驱动异常导致rmmod不能卸载)
weixin_39938165的博客
11-12 630
1 问题描述在进行驱动编程的时候, 如果驱动出现了异常, insmod, rmmod 或者使用过程中出现了异常, 那么导致系统的驱动加载了, 但是却无法被卸载, 或者卸载时出错.就比如前面我们在博文 Linux Kernel PANIC(三)–Soft Panic/Oops调试及实例分析 中讲解调试内核 OOPS 时, 使用的有异常的驱动, kerneloops 或者 createoops, 他们...
linux module常用操作命令
yyzq1319的博客
01-13 5736
常见驱动操作命令： insmod / modprobe  加载驱动 rmmod             卸载驱动 lsmod              查看系统中所有已经被加载了的所有的模块以及模块间的依赖关系 modinfo            获得模块的信息 查看已经加载的驱动模块的信息： lsmod              能够显示驱动的大小以及被谁使用   cat /proc/mod...
Linux之模块机制
猪哥的专栏
11-23 696
Linux内核整体结构很庞大，包含的组件也很多，如果我们把所有的功能都编译到Linux内核中，会导致2个问题，一是生成的内核会很大，二是如果我们要在现有的内核中新增或删除功能，将不得不重新编译内核。 于是模块机制就解决了上述的问题，编译出的内核本身不需要包含所有的功能，而这些功能需要被使用时，其对应的代码会被动态地加载到内核中。模块本身不被编译入内核影响，从而控制了内核的大小，模块一旦被加载，它
如何卸载linux内核中的驱动,linux3.x内核如何强制卸载模块？
weixin_32711097的博客
04-29 1263
一、问题现象：在insmod时调用的init函数代码执行过程中出现oops，导致rmmod卸载失败，此时不得不重启目标板？二、下面是《精通linux设备驱动程序开发》中模拟鼠标的输入设备驱动的内核模块vms.c代码：#include #include #include #include #include #include static struct platform_device *vms_dev...
Linux设备驱动-模块卸载过程
一起学嵌入式
12-08 3186
开篇 上一篇文章分析了内核模块的加载过程： Linux设备驱动-模块加载过程 这篇文章来讲讲内核模块的卸载过程机制。 本文引用的内核代码参考来自版本 linux-5.15.4 。 在用户空间，通过指令 rmmod 可以将一个内核模块从系统中卸载，使用方法如下： rmmod xx /* 卸载已经加载的内核模块 xx */ 注意，卸载内核模块需要具有 CAP_SYS_MODULE 权限（root用户或者其他具有这个权限的用户），否则会加载失败。 rmmod 指令通过系统调用 sys_modu
Linux内核模块的实现机制
07-16
Linux内核模块的实现机制，描述各个模块之间的相互关系
Linux rmmod命令用法详解
01-09
Linux rmmod命令 Linux rmmod命令用于删除模块。 执行rmmod指令，可删除不需要的模块。Linux操作系统的核心具有模块化的特性，应此在编译核心时，务须把全部的功能都放如核心。你可以将这些功能编译成一个个单独的模块，待有需要时再分别载入它们。 语法rmmod [-as][模块名称...] 参数： -a 　删除所有目前不需要的模块。 -s 　把信息输出至syslog常驻服务，而非终端机界面。 实例 显示已安装的模块 # lsmod Module Size Used by cramfs 39042 1 nfsd 238935
怎么强制卸载内核模块
08-02
在Linux系统中，如果你想要强制卸载内核模块（kernel module），通常可以按照以下步骤操作： 1. **停止模块**: 首先确认该模块是否正在运行并尝试停止它。如果模块提供了一个服务，如网络驱动，你可以通过命令行...
Linux内核模块加载与卸载
Linux内核模块的概述 ### 1.1 内核模块的定义和作用 在Linux系统中，内核模块是一种动态加载和卸载的代码，它可以扩展和改变内核的功能，而无需重新编译整个内核。内核模块通常是一个可编译的对象文件，其代码和...
linux 模块机制
qwaszx523的博客
09-01 2217
一、背景 linux内核框架庞大，如果把所有需要的功能都编译到linux内核中，会导致两个问题： 1、生成的内核非常大。 2、新增或删除功能需要重新编译内核。 linux为了解决上述问题，引入了模块机制，使得编译出的内核并不需要包含所有功能，而在这些功能需要被使用的时候，动态加载加载相应代码到内核中。 模块具有这样的特点： 1、模块本身不被编译入内核映像，从而控制住了内核大小。 2、
Linux模块机制
chi's blog
07-17 692
Linux 的模块机制大致就是这样的：按照规范编写模块，内核提供系统调用将模块的可执行文件从用户空间拷贝到内核空间，然后调用模块初始化函数进行初始化，并解析模块可执行文件（.ko 文件），用完之后再调用模块的卸载函数进行卸载。实际上 Linux 的模块机制比上面介绍的还要复杂，要完成的工作并不限于上述的几个步骤。当系统将 .ko 文件拷贝到内核空间后，内核还需要按照模块可执行文件格式（也就是 ELF）解析模块，将必要的符号（即函数、变量）地址暴露给外部，这样系统的其它组件才能使用模块的功能。
openvswitch 驱动卸载失败（Module openvswitch is in use）
weixin_30883311的博客
03-13 1022
现象： [root@ostack1 ~]# modprobe -r openvswitchmodprobe: FATAL: Module openvswitch is in use. 解决： [root@ostack1 ~]# ovs-dpctl showsystem@ovs-system: lookups: hit:116587 missed:10543 lost:0 ...
Linux内核模块
weixin_33769125的博客
05-16 82
导读 Linux内核采用的是模块化技术，这样的设计可以使得系统内核保持最小化，同时确保了内核的可扩展性和可维护性，模块化设计允许我们在需要时才将模块加载至内核，实现动态内核的调整。下面我给大家介绍一下有关内核的操作方法。 内核模块存放位置 Linux内核模块文件的命名方式通常为&lt;模块名称.ko&gt;，Centos 6.3 系统的内核模块被集中存放在/lib...
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值