1
hello.ko 的 ELF 段布局（简化）：
2

3
ELF Header
4
├── .text          — 模块代码（module_init/module_exit 等）
5
├── .rodata        — 只读数据（字符串常量等）
6
├── .data          — 可读写全局变量
7
├── .bss           — 未初始化全局变量
8
├── .modinfo       — 模块元信息（作者、许可证、描述等）
9
├── __versions     — 模块使用的内核符号 CRC 校验
10
├── .gnu.linkonce.this_module — struct module 实例
11
├── .symtab        — 符号表
12
├── .strtab        — 字符串表
13
└── .shstrtab      — 段名字符串表

1
// include/linux/module.h — 模块信息宏
2
#define MODULE_INFO(tag, info) __MODULE_INFO(tag, tag, info)
3

4
// 常用信息宏
5
MODULE_LICENSE("GPL");          // 许可证（必须）
6
MODULE_AUTHOR("Zhang San");     // 作者
7
MODULE_DESCRIPTION("A demo");   // 描述
8
MODULE_VERSION("1.0");          // 版本
9
MODULE_ALIAS("demo-module");    // 别名

1
license=GPL\0
2
author=Zhang San\0
3
description=A demo\0
4
version=1.0\0
5
depends=net_drv,usbcore\0

1
// 模块编译时生成，存储在 __versions 段
2
struct modversion_info {
3
    unsigned long crc;
4
    char name[MODULE_NAME_LEN];  // 符号名
5
};

1
// include/linux/module.h — 模块核心结构体（简化）
2
struct module {
3
    enum module_state state;           // 模块状态
4

5
    /* 模块基本信息 */
6
    char name[MODULE_NAME_LEN];       // 模块名
7
    const struct kernel_symbol *syms;  // 模块导出的符号
8
    const s32 *crcs;                   // 导出符号的 CRC
9
    unsigned int num_syms;             // 导出符号数量
10

11
    /* 依赖关系 */
12
    struct list_head list;             // 链入全局模块链表
13
    struct list_head source_list;      // 依赖本模块的模块列表
14
    struct list_head target_list;      // 本模块依赖的模块列表
15

16
    /* 初始化与清理 */
17
    int (*init)(void);                 // 模块初始化函数
18
    void (*exit)(void);                // 模块卸载函数
19

20
    /* 代码与数据段 */
21
    void *module_core;                 // 模块代码+数据在内核中的起始地址
22
    unsigned int core_size;            // 代码+数据总大小
23
    unsigned int core_text_size;       // 代码段大小
24

25
    /* 符号表与字符串表 */
26
    Elf_Sym *symtab;                   // 模块符号表
27
    unsigned int num_symtab;           // 符号数量
28
    char *strtab;                      // 字符串表
29

30
    /* 参数 */
31
    struct kernel_param *kp;           // 模块参数数组
32
    unsigned int num_kp;               // 参数数量
33

34
    /* 状态标志 */
35
    unsigned int taints;               // 污染标志
36

37
    /* 引用计数 */
38
    atomic_t refcnt;                   // 模块引用计数
39
};

1
// kernel/module/main.c — init_module 系统调用入口
2
SYSCALL_DEFINE3(init_module, void __user *, umod, unsigned long, len,
3
                const char __user *, uargs)
4
{
5
    int err;
6
    struct load_info info = { };
7

8
    // 基本安全检查
9
    err = may_init_module();
10
    if (err)
11
        return err;
12

13
    // 将用户空间的 ELF 数据拷贝到内核空间
14
    err = copy_module_from_user(umod, len, &info);
15
    if (err)
16
        return err;
17

18
    // 核心加载逻辑
19
    return load_module(&info, uargs, 0);
20
}

1
// kernel/module/main.c — ELF 头验证（简化）
2
static int elf_header_check(struct load_info *info)
3
{
4
    if (info->len < sizeof(*(info->hdr)))
5
        return -ENOEXEC;
6

7
    // 验证 ELF 魔数
8
    if (memcmp(info->hdr->e_ident, ELFMAG, SELFMAG) != 0)
9
        return -ENOEXEC;
10

11
    // 验证架构匹配（x86_64 模块不能加载到 ARM 内核）
12
    if (info->hdr->e_machine != CONFIG_ARCH_MCU_TYPE)
13
        return -ENOEXEC;
14

15
    return 0;
16
}

1
# insmod 需要指定完整路径，不处理依赖
2
insmod /lib/modules/6.12.7/kernel/drivers/net/ethernet/intel/e1000e/e1000e.ko
3

4
# modprobe 只需模块名，自动处理依赖
5
modprobe e1000e
6

7
# modprobe 还支持别名和通配符
8
modprobe -r e1000e    # 卸载模块及其未使用的依赖

1
// kernel/module/main.c — delete_module 系统调用
2
SYSCALL_DEFINE2(delete_module, const char __user *, name_user,
3
                unsigned int, flags)
4
{
5
    struct module *mod;
6
    char name[MODULE_NAME_LEN];
7
    int ret, forced = 0;
8

9
    // 查找目标模块
10
    ret = strncpy_from_user(name, name_user, MODULE_NAME_LEN);
11
    mod = find_module(name);
12
    if (!mod)
13
        return -ENOENT;
14

15
    // 检查模块是否有其他模块依赖
16
    if (list_empty(&mod->source_list) == false) {
17
        // 有其他模块依赖本模块，不允许卸载
18
        return -EBUSY;
19
    }
20

21
    // 检查引用计数
22
    if (atomic_read(&mod->refcnt) != 0) {
23
        if (flags & O_TRUNC)  // 强制卸载
24
            forced = 1;
25
        else
26
            return -EBUSY;
27
    }
28

29
    // 等待 RCU 宽限期结束
30
    wait_for_zero_refcount(mod);
31

32
    // 设置状态为 GOING
33
    mod->state = MODULE_STATE_GOING;
34

35
    // 调用模块的 exit 函数
36
    if (mod->exit != NULL)
37
        mod->exit();
38

39
    // 从全局链表中移除
40
    list_del_rcu(&mod->list);
41

42
    // 释放模块占用的内存
43
    free_module(mod);
44

45
    return 0;
46
}

1
# rmmod：直接卸载指定模块
2
rmmod hello
3

4
# modprobe -r：卸载模块及其不再被使用的依赖
5
modprobe -r e1000e
6

7
# 查看模块引用计数
8
cat /proc/modules | grep e1000e
9
lsmod | grep e1000e

1
Module                  Size  Used by
2
e1000e                327680  0
3
nvme                  57344  3
4
nvme_core            184320  5 nvme
5
ext4                  921600  2
6
jbd2                 1228800  1 ext4

1
// 导出符号——任何模块都可以使用
2
EXPORT_SYMBOL(symbol_name);
3

4
// 仅 GPL 许可的模块可以使用
5
EXPORT_SYMBOL_GPL(symbol_name);
6

7
// 仅 GPL + 未来版本的模块可以使用
8
EXPORT_SYMBOL_GPL_FUTURE(symbol_name);

1
// kernel/module/main.c — 符号查找（简化）
2
static const struct kernel_symbol *
3
resolve_symbol(struct module *mod, const struct load_info *info,
4
               const char *name, char ownername[])
5
{
6
    const struct kernel_symbol *sym;
7
    const unsigned long *crc;
8
    int err;
9

10
    // 在内核和已加载模块中查找符号
11
    sym = find_symbol(name, &ownername, &crc,
12
                      true, true);
13

14
    if (!sym)
15
        return ERR_PTR(-ENOENT);
16

17
    // CRC 版本校验
18
    err = check_version(info, name, mod, crc);
19
    if (err)
20
        return ERR_PTR(err);
21

22
    // 检查 GPL 许可兼容性
23
    if (!check_export_symbol(sym, mod))
24
        return ERR_PTR(-EPERM);
25

26
    return sym;
27
}

1
// 导出符号到特定命名空间
2
EXPORT_SYMBOL_NS(my_func, MY_NAMESPACE);
3

4
// 使用方模块需要显式导入
5
MODULE_IMPORT_NS(MY_NAMESPACE);

1
# 查看内核导出的符号
2
cat /proc/kallsyms | head -5
3
# ffffffff81000000 T _text
4
# ffffffff81001000 T startup_64
5
# ffffffff81002000 T do_one_initcall
6

7
# 查看特定模块导出的符号
8
cat /proc/kallsyms | grep "e1000e" | head -5
9
# ffffffffc0420000 T e1000_probe  [e1000e]
10
# ffffffffc0420100 T e1000_remove  [e1000e]
11

12
# 非特权用户看到的地址为 0（安全保护）
13
# 需要设置 /proc/sys/kernel/kptr_restrict = 0 才能看到真实地址

1
# 查看模块参数
2
ls /sys/module/hello/parameters/
3
# count  name  debug
4

5
# 读取参数值
6
cat /sys/module/hello/parameters/count
7
# 1
8

9
# 运行时修改参数（需要 perm 允许写入）
10
echo 5 > /sys/module/hello/parameters/count

1
// 自定义参数名（参数名与变量名不同）
2
static int max_size = 1024;
3
module_param_named(maximum, max_size, int, 0644);
4
// insmod hello.ko maximum=2048
5

6
// 字符串数组参数
7
static int num_names;
8
static char *names[10];
9
module_param_array(names, charp, &num_names, 0644);
10
// insmod hello.ko names=alice,bob,charlie
11

12
// 参数回调函数（参数被修改时触发）
13
static int notify_param(const char *val, const struct kernel_param *kp)
14
{
15
    int ret = param_set_int(val, kp);
16
    if (ret == 0)
17
        pr_info("Parameter changed to %d\n", *(int *)kp->arg);
18
    return ret;
19
}
20
static const struct kernel_param_ops notify_ops = {
21
    .set = notify_param,
22
    .get = param_get_int,
23
};
24
module_param_cb(threshold, &notify_ops, &threshold, 0644);

1
// include/linux/printk.h — 日志级别
2
#define KERN_EMERG   "<0>"   // 系统不可用
3
#define KERN_ALERT   "<1>"   // 必须立即处理
4
#define KERN_CRIT    "<2>"   // 严重条件
5
#define KERN_ERR     "<3>"   // 错误条件
6
#define KERN_WARNING "<4>"   // 警告条件
7
#define KERN_NOTICE  "<5>"   // 正常但值得注意
8
#define KERN_INFO    "<6>"   // 信息性
9
#define KERN_DEBUG   "<7>"   // 调试信息
10

11
// 使用示例
12
printk(KERN_INFO "Hello from module\n");
13
printk(KERN_ERR "Failed to allocate memory: %d\n", err);
14
pr_info("Module loaded with count=%d\n", count);   // 等价于 printk(KERN_INFO ...)
15
pr_err("Something went wrong\n");                   // 等价于 printk(KERN_ERR ...)
16
pr_warn("Suspicious condition\n");                   // 等价于 printk(KERN_WARNING ...)

1
# 查看当前控制台日志级别
2
cat /proc/sys/kernel/printk
3
# 4  4  1  7
4
# │  │  │  └── 默认日志级别（printk 未指定级别时使用）
5
# │  │  └───── 最小控制台日志级别
6
# │  └──────── 默认控制台日志级别
7
# └─────────── 当前控制台日志级别
8

9
# 只有级别 < 当前控制台日志级别的消息才会显示到控制台
10
# 例如：当前级别为 4，则 KERN_EMERG(0)~KERN_ERR(3) 会显示
11

12
# 修改控制台日志级别
13
echo 8 > /proc/sys/kernel/printk   # 显示所有级别的日志
14

15
# 使用 dmesg 查看环形缓冲区中的所有日志
16
dmesg | tail -20
17
dmesg -w    # 实时跟踪（类似 tail -f）
18
dmesg -l err,warn   # 只显示错误和警告

1
// 使用 pr_debug 代替 printk(KERN_DEBUG ...)
2
pr_debug("Processing item %d\n", item_id);
3

4
// 使用 dev_dbg（设备驱动推荐）
5
dev_dbg(dev, "Register %x = %x\n", reg, val);

1
# 启用所有动态调试
2
echo 'p' > /sys/kernel/debug/dynamic_debug/control
3

4
# 启用特定文件的调试输出
5
echo 'file hello.c +p' > /sys/kernel/debug/dynamic_debug/control
6

7
# 启用特定函数的调试输出
8
echo 'func my_init +p' > /sys/kernel/debug/dynamic_debug/control
9

10
# 启用特定模块的调试输出
11
echo 'module my_module +p' > /sys/kernel/debug/dynamic_debug/control
12

13
# 启用并附加行号
14
echo 'file hello.c +pl' > /sys/kernel/debug/dynamic_debug/control
15

16
# 关闭调试输出
17
echo 'file hello.c -p' > /sys/kernel/debug/dynamic_debug/control
18

19
# 查看当前启用的调试规则
20
cat /sys/kernel/debug/dynamic_debug/control

1
# 内核配置选项
2
CONFIG_MODULE_SIG=y           # 启用模块签名
3
CONFIG_MODULE_SIG_ALL=y       # 自动为模块签名
4
CONFIG_MODULE_SIG_SHA256=y    # 使用 SHA-256 哈希
5
CONFIG_MODULE_SIG_FORCE=y     # 强制模式：签名验证失败则拒绝加载

1
# 查看内核污染状态
2
cat /proc/sys/kernel/tainted
3

4
# 污染标志含义（位图）：
5
#  P (0)     - 加载了非 GPL 模块
6
#  F (1)     - 强制加载了模块
7
#  S (2)     - 在不支持的架构上运行
8
#  R (3)     - 模块被强制卸载
9
#  M (4)     - 处理器报告了机器检查异常
10
#  B (5)     - 引用了错误的页
11
#  U (6)     - 用户空间导致 taint
12
#  D (7)     - 内核最近死锁
13
#  A (8)     - ACPI 表被覆盖
14
#  W (9)     - 警告
15
#  C (10)    - 加载了 staging 驱动
16
#  I (11)    - 平台固件问题
17
#  O (12)    - 加载了外部构建的模块
18
#  E (13)    - 签名验证失败的模块
19
#  L (14)    - 软锁定
20
#  K (15)    - 实时补丁
21
#  X (16)    - aux 污染

1
# 方式一：通过 sysctl 禁止加载新模块
2
echo 1 > /proc/sys/kernel/modules_disabled
3
# 注意：此设置一旦启用，无法在运行时关闭（需要重启）
4

5
# 方式二：通过 /etc/modprobe.d/ 黑名单
6
echo "blacklist e1000e" > /etc/modprobe.d/blacklist.conf
7
echo "install e1000e /bin/true" >> /etc/modprobe.d/blacklist.conf
8

9
# 方式三：通过 Linux Security Module (LSM) 限制
10
# SELinux、AppArmor 等可以限制模块加载操作
11

12
# 方式四：内核编译时禁用模块支持
13
# CONFIG_MODULES=n — 完全禁止模块加载（嵌入式系统常用）

1
// hello.c — 最简单的内核模块
2
#include <linux/init.h>
3
#include <linux/module.h>
4
#include <linux/kernel.h>
5

6
MODULE_LICENSE("GPL");
7
MODULE_AUTHOR("Linux Explorer");
8
MODULE_DESCRIPTION("Hello World Kernel Module");
9
MODULE_VERSION("1.0");
10

11
static int count = 1;
12
module_param(count, int, 0644);
13
MODULE_PARM_DESC(count, "Number of greetings");
14

15
static int __init hello_init(void)
16
{
17
    int i;
18
    for (i = 0; i < count; i++)
19
        pr_info("Hello, kernel world! (greeting %d)\n", i + 1);
20
    return 0;
21
}
22

23
static void __exit hello_exit(void)
24
{
25
    pr_info("Goodbye, kernel world!\n");
26
}
27

28
module_init(hello_init);
29
module_exit(hello_exit);

1
obj-m += hello.o
2

3
KDIR := /lib/modules/$(shell uname -r)/build
4

5
all:
6
  make -C $(KDIR) M=$(PWD) modules
7

8
clean:
9
  make -C $(KDIR) M=$(PWD) clean

1
static int __init my_init(void) { ... }  // 初始化完成后释放代码内存
2
static void __exit my_exit(void) { ... }  // 不支持卸载时释放代码内存

1
static int __init my_init(void)
2
{
3
    int err;
4

5
    err = register_chrdev(MY_MAJOR, "mydev", &my_fops);
6
    if (err < 0)
7
        return err;  // 直接返回，无需清理
8

9
    err = device_create(my_class, NULL, MKDEV(MY_MAJOR, 0), NULL, "mydev");
10
    if (IS_ERR(err)) {
11
        unregister_chrdev(MY_MAJOR, "mydev");  // 回滚之前的注册
12
        return PTR_ERR(err);
13
    }
14

15
    return 0;
16
}

1
// 错误示范：泄漏资源
2
static int __init bad_init(void)
3
{
4
    if (request_irq(irq, handler, 0, "mydev", NULL))
5
        return -EBUSY;    // 如果下面的注册失败，IRQ 不会被释放！
6

7
    if (misc_register(&my_misc)) {
8
        // 忘记 free_irq！
9
        return -ENOMEM;
10
    }
11
    return 0;
12
}
13

14
// 正确示范：goto 链式清理
15
static int __init good_init(void)
16
{
17
    int err;
18

19
    err = request_irq(irq, handler, 0, "mydev", NULL);
20
    if (err)
21
        goto err_irq;
22

23
    err = misc_register(&my_misc);
24
    if (err)
25
        goto err_misc;
26

27
    return 0;
28

29
err_misc:
30
    free_irq(irq, NULL);
31
err_irq:
32
    return err;
33
}

1
struct my_device {
2
    struct cdev cdev;
3
    struct device *dev;
4
    void __iomem *regs;
5
    spinlock_t lock;
6
    wait_queue_head_t wq;
7
    // ... 所有设备相关状态
8
};
9

10
// 在 open 时分配，在 release 时释放
11
static int my_open(struct inode *inode, struct file *filp)
12
{
13
    struct my_device *dev = container_of(inode->i_cdev,
14
                                         struct my_device, cdev);
15
    filp->private_data = dev;
16
    return 0;
17
}

1
// 共享数据必须保护
2
static DEFINE_SPINLOCK(my_lock);
3
static LIST_HEAD(my_list);
4

5
static void add_item(struct my_item *item)
6
{
7
    unsigned long flags;
8
    spin_lock_irqsave(&my_lock, flags);
9
    list_add(&item->list, &my_list);
10
    spin_unlock_irqrestore(&my_lock, flags);
11
}

1
# 多文件编译为一个模块
2
obj-m += mydriver.o
3
mydriver-objs := main.o utils.o io.o
4

5
# 条件编译
6
ccflags-y := -DDEBUG
7
ccflags-y += -I$(src)/include
8

9
# 构建目标
10
KDIR := /lib/modules/$(shell uname -r)/build
11

12
all:
13
  $(MAKE) -C $(KDIR) M=$(PWD) modules
14

15
install:
16
  $(MAKE) -C $(KDIR) M=$(PWD) modules_install
17

18
clean:
19
  $(MAKE) -C $(KDIR) M=$(PWD) clean

1
# 检查补丁是否符合代码风格
2
scripts/checkpatch.pl my_patch.patch
3

4
# 检查单个文件
5
scripts/checkpatch.pl --file drivers/my_driver.c

1
[PATCH v2] subsystem: brief description
2

3
Detailed description of what the patch does, why it is needed,
4
and how it achieves the goal. Wrap at 72 columns.
5

6
Signed-off-by: Your Name <your@email.com>

1
# 查看 staging 驱动
2
ls drivers/staging/
3

4
# staging 驱动的 TODO 文件列出了需要改进的地方
5
cat drivers/staging/rtl8192e/TODO

1
// param_demo.c — 带参数的内核模块
2
#include <linux/init.h>
3
#include <linux/module.h>
4
#include <linux/kernel.h>
5
#include <linux/moduleparam.h>
6

7
MODULE_LICENSE("GPL");
8
MODULE_AUTHOR("Linux Explorer");
9
MODULE_DESCRIPTION("Parameter Demo Module");
10

11
static int count = 1;
12
static char *name = "world";
13
static bool verbose = false;
14

15
module_param(count, int, 0644);
16
MODULE_PARM_DESC(count, "Number of greetings (default: 1)");
17

18
module_param(name, charp, 0644);
19
MODULE_PARM_DESC(name, "Name to greet (default: world)");
20

21
module_param(verbose, bool, 0644);
22
MODULE_PARM_DESC(verbose, "Verbose output (default: false)");
23

24
static int __init param_init(void)
25
{
26
    int i;
27
    pr_info("param_demo: loaded with count=%d, name=%s, verbose=%d\n",
28
            count, name, verbose);
29
    for (i = 0; i < count; i++) {
30
        if (verbose)
31
            pr_info("param_demo: greeting #%d: Hello, %s!\n", i + 1, name);
32
        else
33
            pr_info("param_demo: Hello, %s!\n", name);
34
    }
35
    return 0;
36
}
37

38
static void __exit param_exit(void)
39
{
40
    pr_info("param_demo: Goodbye, %s!\n", name);
41
}
42

43
module_init(param_init);
44
module_exit(param_exit);

1
obj-m += param_demo.o
2
KDIR := /lib/modules/$(shell uname -r)/build
3

4
all:
5
  make -C $(KDIR) M=$(PWD) modules
6

7
clean:
8
  make -C $(KDIR) M=$(PWD) clean

1
# 编译模块
2
make
3

4
# 加载模块（带参数）
5
sudo insmod param_demo.ko count=3 name=Linux verbose=1
6

7
# 查看内核日志
8
dmesg | tail -10
9
# [ 1234.567890] param_demo: loaded with count=3, name=Linux, verbose=1
10
# [ 1234.567891] param_demo: greeting #1: Hello, Linux!
11
# [ 1234.567892] param_demo: greeting #2: Hello, Linux!
12
# [ 1234.567893] param_demo: greeting #3: Hello, Linux!
13

14
# 查看模块信息
15
cat /proc/modules | grep param_demo
16
# param_demo 16384 0 - Live 0xffffffffc0500000 (OE)
17

18
# 查看模块参数
19
ls /sys/module/param_demo/parameters/
20
# count  name  verbose
21

22
cat /sys/module/param_demo/parameters/name
23
# Linux
24

25
# 运行时修改参数
26
echo 5 | sudo tee /sys/module/param_demo/parameters/count
27

28
# 卸载模块
29
sudo rmmod param_demo
30

31
# 再次查看日志
32
dmesg | tail -5
33
# [ 1250.123456] param_demo: Goodbye, Linux!

1
# 查看内核导出的符号数量
2
cat /proc/kallsyms | wc -l
3
# 约 100,000+ 个符号
4

5
# 查找特定函数的地址
6
cat /proc/kallsyms | grep " printkl$"
7
# ffffffff8110a340 T printk
8

9
# 查看模块导出的符号（方括号中为模块名）
10
cat /proc/kallsyms | grep "\[e1000e\]" | head -5
11

12
# 查看当前内核的污染状态
13
cat /proc/sys/kernel/tainted
14
# 0 表示未污染
15

16
# 加载非 GPL 模块后再次检查
17
# 会出现非零值，表示内核已被污染

1
# 确保内核启用了动态调试
2
cat /boot/config-$(uname -r) | grep DYNAMIC_DEBUG
3
# CONFIG_DYNAMIC_DEBUG=y
4

5
# 启用特定模块的调试输出
6
echo 'module param_demo +p' > /sys/kernel/debug/dynamic_debug/control
7

8
# 查看已启用的调试规则
9
cat /sys/kernel/debug/dynamic_debug/control | grep param_demo
10

11
# 关闭调试输出
12
echo 'module param_demo -p' > /sys/kernel/debug/dynamic_debug/control