模块机制让kernel有伸缩性，既保有宏内核的高效，又有一定微内核的稳定性。

1. 单个模块

1.1 模块的编译

1.1.1 源码树内编译

在源码树内添加模块

linux-5.16.2# touch drivers/char/hello.c

#include <linux/init.h>
#include <linux/modules.h>

static int __init hello_init(void)
{
        printk("hello world\n");
        return 0;
}

static void __exit hello_exit(void)
{

}

module_init(hello_init);
module_exit(hello_exit);

MODULE_LICENSE("GPL");

• __init 和 __exit 让被修饰的函数加入 init 或 exit 段，因为 init 函数和 exit 函数只需要执行一次，所以当其被执行后kernel可以很方便的释放 init段 和 exit段的代码，以节省内存
• module_init 和 module_exit 宏声明的函数为模块入口和出口函数
• MODULE_LICENSE 若不是 GPL 等开源协议，kernel会禁用一些功能

将模块加入Kbuild
vi drivers/char/Kconfig

config HELLO
    tristate "hello demo"
    help
        demo for module

• HELLO 会生成 变量 CONFIG_HELLO，写入 .config中

vi driver/char/Makefile

obj-$(CONFIG_HELLO) += hello.o

• kbuild使用 -f 分别加载源码不同目录下的Makefile，每个Makefile需要告诉Kbuid 本模块的 obj-y 或 obj-m（不同模块的obj-y 和 obj-m不会累加）。
• kbuild根据 .config的内容生成 include/config/auto.conf，其中定义了 变量 CONFIG_HELLO，kbuild会包含auto.conf，以定义 obj-$(CONFIG_HELLO)为 obj-m 或 obj-y，若为 obj-m ，则意味需构造名为 hello.ko的模块，若为 obj-y，生成一个 built-in.a，各个子目录下的 built-in.a 会链接成 父目录的 built-in.a ，最后链接成 vmlinux

make menuconfig
将hello设置为M

make modules

• 构造所有目录下 obj-m

将ko放到modules目录
mv hello.ko /lib/modules/5.16.2

加载模块
modprobe hello

卸载模块
rmmod hello

1.1.2 out-of-tree编译

准备单独目录
root@ubuntu:~/wlt/build/my/hello# ls
hello.c Makefile

cat Makefile

.PHONY: all clean

obj-m := hello.o

CROSS_COMPILE := arm-linux-gnueabi-
KBUILD_DIR := /root/wlt/build/linux-5.16.2

all:
        make -C $(KBUILD_DIR) M=$(PWD) ARCH=arm CROSS_COMPILE=$(CROSS_COMPILE) modules

clean:
        make -C $(KBUILD_DIR) M=$(PWD) ARCH=arm CROSS_COMPILE=$(CROSS_COMPILE) modules clean

• 此Makefile会被引用两次，第一次实际有效内容如下

.PHONY: all clean

CROSS_COMPILE := arm-linux-gnueabi-
KBUILD_DIR := /root/wlt/build/linux-5.16.2

all:
        make -C $(KBUILD_DIR) M=$(PWD) ARCH=arm CROSS_COMPILE=$(CROSS_COMPILE) modules

clean:
        make -C $(KBUILD_DIR) M=$(PWD) ARCH=arm CROSS_COMPILE=$(CROSS_COMPILE) modules clean

• 由于定义了 M变量，所以kernel/Makefile会 make -f $(M)，此时有效内容如下

obj-m := hello.o

若是多个目标文件构成一个模块，则这样写

.PHONY: all clean

obj-m := hello.o
hello-objs := main.o add.o sub.o

CROSS_COMPILE := arm-linux-gnueabi-
KBUILD_DIR := /root/wlt/build/linux-5.16.2

all:
        make -C $(KBUILD_DIR) M=$(PWD) ARCH=arm CROSS_COMPILE=$(CROSS_COMPILE) modules

clean:
        make -C $(KBUILD_DIR) M=$(PWD) ARCH=arm CROSS_COMPILE=$(CROSS_COMPILE) modules clean

• obj-m := hello.o 定义一个模块 hello
• hello-objs := main.o add.o sub.o， hello模块由 main.o add.o sub.o 目标文件构成
• 由于 main.o add.o sub.o 会被链接成 module.o，这里module名称为hello，所以 会生成 hello.o ，所以 不能 写成 hello-objs := hello.o add.o sub.o

1.2 模块参数

使用 module_param 导出参数
module_param(name, type, perm)

在main.c加入

#include <linux/moduleparam.h>

static int num;
module_param(num, int, 0664);

module_param(name, type, perm)
perm不能为 0666

模块加载后，可以在 /sys/module/hello/parameters/ 下 读写参数值

可以通过uboot给模块传参，bootargs 添加 'hello.num=111'

2. 两个模块

2.1 符号导出和引用

使用 EXPORT_SYMBOL(sym) 导出符号

构造math模块

#include <linux/module.h>
#include <linux/init.h>
#include <linux/moduleparam.h>

int math_add(int a, int b)
{
        return a + b;
}
EXPORT_SYMBOL(math_add);

int math_sub(int a, int b)
{
        return a - b;
}
EXPORT_SYMBOL(math_sub);

static int __init math_init(void)
{
        return 0;
}

module_init(math_init);

MODULE_LICENSE("GPL");

math编译成功后会生成
root@ubuntu:~/wlt/build/my/math# cat Module.symvers
0x00000000 math_sub /root/wlt/build/my/math/math EXPORT_SYMBOL
0x00000000 math_add /root/wlt/build/my/math/math EXPORT_SYMBOL

构造 hello 模块，引用math的 add

#include <linux/module.h>
#include <linux/init.h>
#include <linux/moduleparam.h>

extern int math_add(int a, int b);

static int a;
static int b;

module_param(a, int, 0664);
module_param(b, int, 0664);

static int __init hello_init(void)
{
        printk("a + b : %d\n", math_add(a, b));
        return 0;
}

static void __exit hello_exit(void)
{
        printk("hello exit\n");
}

module_init(hello_init);
module_exit(hello_exit);

MODULE_LICENSE("GPL");

hello的Makefile 需要添加 match 的 导出符号表

ifneq ($(KERNELRELEASE),)

obj-m := hello.o
hello-objs := main.o

else

.PHONY: all clean

KBUILD_EXTRA_SYMBOLS += /root/wlt/build/my/math/Module.symvers
export KBUILD_EXTRA_SYMBOLS

CROSS_COMPILE := arm-linux-gnueabi-
KBUILD_DIR := /root/wlt/build/linux-5.16.2

all:
        make -C $(KBUILD_DIR) M=$(PWD) ARCH=arm CROSS_COMPILE=$(CROSS_COMPILE) modules

clean:
        make -C $(KBUILD_DIR) M=$(PWD) ARCH=arm CROSS_COMPILE=$(CROSS_COMPILE) modules clean

endif

2.2 模块依赖和自动加载

将模块放到 /lib/modules/${KVERSION}/
生成模块依赖
depmod -a
自动加载
modprobe hello
自动卸载
modprobe -r hello

3. 模块和驱动

一个字符设备驱动

#include <linux/module.h>
#include <linux/init.h>
#include <linux/fs.h>

#define DEV_MAJOR    222
#define DEV_NAME     "hello"

static char hello_buf[256];

static ssize_t
hello_read (struct file *fp, char __user *ubuf,
                size_t size, loff_t *pos)
{
        unsigned long p = *pos;
        unsigned long count = size;

        if (p >= 256)
                return -1;
        if (count > 256 - p)
                count = 256 - p;

        return copy_to_user(ubuf, hello_buf + p, count);
}

static ssize_t
hello_write (struct file *fp, const char __user *ubuf,
                size_t size, loff_t *pos)
{
        unsigned long p = *pos;
        unsigned long count = size;

        if (p >= 256)
                return -1;
        if (count > 256 - p)
                count = 256 - p;

        return copy_from_user((char *)hello_buf + p, ubuf, count);
}

static int
hello_open (struct inode *inode, struct file *fp)
{
        return 0;
}

static int
hello_release (struct inode *inode, struct file *fp)
{
        return 0;
}

static struct file_operations hello_ops = {
        .owner = THIS_MODULE,
        .read = hello_read,
        .write = hello_write,
        .open = hello_open,
        .release = hello_release
};

static int __init
hello_init(void)
{
        // 静态分配 主设备号，
        // 绑定  主设备号 和 设备名 和 fops
        // 如此，可通过 文件系统 找到 主设备号，进而找到 驱动
        if (register_chrdev(DEV_MAJOR, DEV_NAME, &hello_ops) < 0) {
                printk("Failed to register_chrdev");
                return -1;
        }

        return 0;
}

static void __exit
hello_exit(void)
{
        unregister_chrdev(DEV_MAJOR, DEV_NAME);
}

module_init(hello_init);
module_exit(hello_exit);
MODULE_LICENSE("GPL");

测试程序

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>


int main()
{
        int fd;
        char buf[256];

        if ((fd = open("/dev/hello", O_RDWR)) < 0) {
                perror("open");
                return -1;
        }
        if (write(fd, "hello", 5) < 0) {
                perror("write");
                return -1;
        }
        if (read(fd, buf, sizeof(buf)) < 0) {
                perror("read");
                return -1;
        }
        printf("read : %s\n", buf);

        close(fd);

        return 0;
}

测试
加载驱动后，创建设备节点
mknod /dev/hello c 222 0
运行测试程序
yangxr@vexpress:/root # ./hello_test
read : hello

3. 模块加载流程

3.1 外部加载

3.1.1 调用栈

[<8010f358>] (unwind_backtrace) from [<8010b254>] (show_stack+0x10/0x14)
[<8010b254>] (show_stack) from [<80836b74>] (dump_stack_lvl+0x40/0x4c)
[<80836b74>] (dump_stack_lvl) from [<7f00500c>] (hello_init+0xc/0x1000 [hello])
[<7f00500c>] (hello_init [hello]) from [<80101f90>] (do_one_initcall+0x48/0x1e8)
[<80101f90>] (do_one_initcall) from [<808313b0>] (do_init_module+0x54/0x208)
[<808313b0>] (do_init_module) from [<801aca54>] (load_module+0x2058/0x2670)
[<801aca54>] (load_module) from [<801ad1c4>] (sys_init_module+0x158/0x170)
[<801ad1c4>] (sys_init_module) from [<80100060>] (ret_fast_syscall+0x0/0x54)

关键是三个函数
load_module ： 检查模块信息，加载模块，重定位代码，构造 mod 对象
do_init_module：执行mod对象的init函数，删除 __init 段
do_one_initcall：调用 init 函数

3.1.2 init函数的调用

  1287 int __init_or_module do_one_initcall(initcall_t fn)
  1288 {
  1295     .....
  1297     ret = fn();

  3713 static noinline int do_init_module(struct module *mod)
  3714 {
           .....
  3733     if (mod->init != NULL)
  3734         ret = do_one_initcall(mod->init);

要调用init函数，必须构造 mod 对象。

模块编译时 生成 mod 对象

root@ubuntu:~/wlt/build/my/hello# cat hello.mod.c
...
__visible struct module __this_module
__section(".gnu.linkonce.this_module") = {
        .name = KBUILD_MODNAME,
        .init = init_module,
#ifdef CONFIG_MODULE_UNLOAD
        .exit = cleanup_module,
#endif
        .arch = MODULE_ARCH_INIT,
};
...

定义 mod 对象 在 .gnu.linkonce.this_module 段，
所以 模块加载时，是从 .gnu.linkonce.this_module段 加载 mod 对象，
而 .init = init_module，说明实际的 init 函数 符号名为 init_module

  129 /* Each module must use one module_init(). */
  130 #define module_init(initfn)                 \
  131     static inline initcall_t __maybe_unused __inittest(void)        \
  132     { return initfn; }                  \
  133     int init_module(void) __copy(initfn)            \
  134         __attribute__((alias(#initfn)));        \
  135     __CFI_ADDRESSABLE(init_module, __initdata);

可见 module_init宏的作用是 定义一个 函数 init_module，并将 initfn的代码复制给
init_module，并区别名。
所以 module_init(hello_init)后， init_module 就是 hello_init。

3.1.3 模块化加载总结

insmod命令会加载模块到内存，对模块进行合法性检查，并进行重定位，
由于 mod 对象位于 .gnu.linkonce.this_module 段，可以直接使用 mod 对象，
调用 mod->init 函数完成 模块初始化，释放 __init 段的内存。

3.2 模块内嵌内核的初始化

3.2.1 module_init 分析

module_init定义
include/linux/module.h

  #ifndef MODULE

  #define module_init(x)  __initcall(x);

  #else /* MODULE */

  /* Each module must use one module_init(). */
  #define module_init(initfn)                 \
      static inline initcall_t __maybe_unused __inittest(void)        \
      { return initfn; }                  \
      int init_module(void) __copy(initfn)            \
          __attribute__((alias(#initfn)));        \
      __CFI_ADDRESSABLE(init_module, __initdata);

#endif

而 MODULE 在 Makefile中定义

KBUILD_CFLAGS_KERNEL :=   
KBUILD_CFLAGS_MODULE  := -DMODULE k

所以若 编译的是 module 则定义 MODULE，否则不定义，
这里是内嵌内核，所以module_init的定义是

  #define module_init(x)  __initcall(x);

__initcall的定义是

  253 #define __unique_initcall(fn, id, __sec, __iid)         \
  254     ____define_initcall(fn,                 \
  255         __initcall_stub(fn, __iid, id),         \
  256         __initcall_name(initcall, __iid, id),       \
  257         __initcall_section(__sec, __iid))

  259 #define ___define_initcall(fn, id, __sec)           \
  260     __unique_initcall(fn, id, __sec, __initcall_id(fn))

#define __define_initcall(fn, id) ___define_initcall(fn, id, .initcall##id)
#define device_initcall(fn)     __define_initcall(fn, 6)
 #define __initcall(fn) device_initcall(fn)

所以__initcall最终展开为 ____define_initcall，
而____define_initcall定义

  239 #ifdef CONFIG_HAVE_ARCH_PREL32_RELOCATIONS
  240 #define ____define_initcall(fn, __stub, __name, __sec)      \
  241     __define_initcall_stub(__stub, fn)          \
  242     asm(".section   \"" __sec "\", \"a\"        \n" \
  243         __stringify(__name) ":          \n" \
  244         ".long  " __stringify(__stub) " - . \n" \
  245         ".previous                  \n");   \
  246     static_assert(__same_type(initcall_t, &fn));
  247 #else
  248 #define ____define_initcall(fn, __unused, __name, __sec)    \
  249     static initcall_t __name __used             \
  250         __attribute__((__section__(__sec))) = fn;
  251 #endif

CONFIG_HAVE_ARCH_PREL32_RELOCATIONS 的定义在 include/generated/autoconf.h（就是Kbuild生成的）。
我们看汇编（因为汇编更清晰）

  240 #define ____define_initcall(fn, __stub, __name, __sec)      \
  241     __define_initcall_stub(__stub, fn)          \
  242     asm(".section   \"" __sec "\", \"a\"        \n" \   // 定义段
  243         __stringify(__name) ":          \n" \           // 在该段定义一个符号
  244         ".long  " __stringify(__stub) " - . \n" \       // 这个符号对应的空间为long大小，值为 __stringify(__stub) - . 
  245         ".previous                  \n");   \           // 使用以前的段（本段定义结束）

    其中 __stringify(__stub) - .  为 函数地址 - 段起始地址，即这里保存一个偏移地址。
    通过此偏移地址和段起始地址就能找到 函数地址。

示例

module_init(hello_init);
__initcall(hello_init);
device_initcall(hello_init, 6);
__define_initcall(hello_init, 6);
___define_initcall(hello_init, 6, .initcall6);

.section ".initcall6.init", "a"
__initcall_hello_init6:
.long hello_init - .
.previous

在 段 .initcall6.init 定义一个符号 __initcall_hello_init6，值为 偏移地址（函数地址 - 段起始地址）。

总结：
module_init(fn)
定义 一个偏移值，定义在 特定的段 .initcall6.init.

3.2.2 init函数的调用

从上面我们获得关键信息 initcall6，搜索可得：

  1317 extern initcall_entry_t __initcall_start[];
  1318 extern initcall_entry_t __initcall0_start[];
  1319 extern initcall_entry_t __initcall1_start[];
  1320 extern initcall_entry_t __initcall2_start[];
  1321 extern initcall_entry_t __initcall3_start[];
  1322 extern initcall_entry_t __initcall4_start[];
  1323 extern initcall_entry_t __initcall5_start[];
  1324 extern initcall_entry_t __initcall6_start[];
  1325 extern initcall_entry_t __initcall7_start[];
  1326 extern initcall_entry_t __initcall_end[];
  1327
  1328 static initcall_entry_t *initcall_levels[] __initdata = {
  1329     __initcall0_start,
  1330     __initcall1_start,
  1331     __initcall2_start,
  1332     __initcall3_start,
  1333     __initcall4_start,
  1334     __initcall5_start,
  1335     __initcall6_start,
  1336     __initcall7_start,
  1337     __initcall_end,
  1338 };

定义一个指针数组，并引用一些符号，但这和 .initcall6 段没关系

搜索 __initcallx_start ，发现定义在链接脚本中

 59  .init.data : AT(ADDR(.init.data) - 0) { KEEP(*(SORT(___kentry+*))) *(.init.data init.data.*) *(.meminit.data*    ) *(.init.rodata .init.rodata.*) . = ALIGN(8); __start_ftrace_events = .; KEEP(*(_ftrace_events)) __stop_ftrac    e_events = .; __start_ftrace_eval_maps = .; KEEP(*(_ftrace_eval_map)) __stop_ftrace_eval_maps = .; *(.meminit.    rodata) . = ALIGN(8); __clk_of_table = .; KEEP(*(__clk_of_table)) KEEP(*(__clk_of_table_end)) . = ALIGN(8); __    reservedmem_of_table = .; KEEP(*(__reservedmem_of_table)) KEEP(*(__reservedmem_of_table_end)) . = ALIGN(8); __    timer_of_table = .; KEEP(*(__timer_of_table)) KEEP(*(__timer_of_table_end)) . = ALIGN(8); __cpu_method_of_tabl    e = .; KEEP(*(__cpu_method_of_table)) KEEP(*(__cpu_method_of_table_end)) . = ALIGN(8); __cpuidle_method_of_tab    le = .; KEEP(*(__cpuidle_method_of_table)) KEEP(*(__cpuidle_method_of_table_end)) . = ALIGN(32); __dtb_start =     .; KEEP(*(.dtb.init.rodata)) __dtb_end = .; . = ALIGN(8); __irqchip_of_table = .; KEEP(*(__irqchip_of_table))     KEEP(*(__irqchip_of_table_end)) . = ALIGN(8); __earlycon_table = .; KEEP(*(__earlycon_table)) __earlycon_tabl    e_end = .; . = ALIGN(8); __kunit_suites_start = .; KEEP(*(.kunit_test_suites)) __kunit_suites_end = .; . = ALI    GN(16); __setup_start = .; KEEP(*(.init.setup)) __setup_end = .; __initcall_start = .; KEEP(*(.initcallearly.init)) __initcall0_start = .; KEEP(*(.initcall0.init)) KEEP(*(.initcall0s.init)) __initcall1_start = .; KEEP(*(    .initcall1.init)) KEEP(*(.initcall1s.init)) __initcall2_start = .; KEEP(*(.initcall2.init)) KEEP(*(.initcall2s    .init)) __initcall3_start = .; KEEP(*(.initcall3.init)) KEEP(*(.initcall3s.init)) __initcall4_start = .; KEEP(    *(.initcall4.init)) KEEP(*(.initcall4s.init)) __initcall5_start = .; KEEP(*(.initcall5.init)) KEEP(*(.initcall    5s.init)) __initcallrootfs_start = .; KEEP(*(.initcallrootfs.init)) KEEP(*(.initcallrootfss.init)) __initcall6    _start = .; KEEP(*(.initcall6.init)) KEEP(*(.initcall6s.init)) __initcall7_start = .; KEEP(*(.initcall7.init))     KEEP(*(.initcall7s.init)) __initcall_end = .; __con_initcall_start = .; KEEP(*(.con_initcall.init)) __con_ini    tcall_end = .; . = ALIGN(4); __initramfs_start = .; KEEP(*(.init.ramfs)) . = ALIGN(8); KEEP(*(.init.ramfs.info    )) }

__initcall0_start = .; KEEP((.initcall0.init)) KEEP((.initcall0s.init)) __initcall1_start = .;
可见，链接脚本将 .initcallN.init 的段的 内容链接到一起，并 定义 __initcallN_start 符号为 该段的起始地址， __initcallN+1_start符号为该段的结束地址。
一共有 7个 initcall段，最后的结束地址用符号 __initcall_end 标记。

结合c代码中定义，可知：
所有 module_init 修饰的函数 fn，会定义一个 long类型的变量，值为相对于 fn 的偏移量，所有 变量会组成一个数组，定义在 .init.data段，数组起始地址用 __initcall6_start 标记，结束地址用 __initcall7_start标记。所有初始化相关数组又构成一个大数组 initcall_levels
所以要调用函数 fn，必须遍历 函数 initcall_levels.

搜索initcall_levels的使用。

  1287 int __init_or_module do_one_initcall(initcall_t fn)
  1288 {
          ...
  1295
  1296     do_trace_initcall_start(fn);
  1297     ret = fn();
  1298     do_trace_initcall_finish(fn, ret);
          ...

  1313     return ret;
  1314 }


  1358 static void __init do_initcall_level(int level, char *command_line)
  1359 {
  1360     initcall_entry_t *fn;
          ...
  1369     for (fn = initcall_levels[level]; fn < initcall_levels[level+1]; fn++)
  1370         do_one_initcall(initcall_from_entry(fn));
  1371 }

可见 若 level为 6，则执行 __initcall6_start数组的所有函数
而initcall_from_entry 为 当 地址值 加 内存的值，而内存中记录相对于module_init修饰的函数的偏移量，所以获得 模块初始化函数的地址。

  250 static inline void *offset_to_ptr(const int *off)
  251 {
  252     return (void *)((unsigned long)off + *off);
  253 }

  122 static inline initcall_t initcall_from_entry(initcall_entry_t *entry)
  123 {
  124     return offset_to_ptr(entry);
  125 }

do_initcall_level被do_initcalls调用，do_initcalls完成所有初始化函数的执行

  1373 static void __init do_initcalls(void)
  1374 {
  1375     int level;
  1376     size_t len = strlen(saved_command_line) + 1;
  1377     char *command_line;
  1378
  1379     command_line = kzalloc(len, GFP_KERNEL);
  1380     if (!command_line)
  1381         panic("%s: Failed to allocate %zu bytes\n", __func__, len);
  1382
  1383     for (level = 0; level < ARRAY_SIZE(initcall_levels) - 1; level++) {
  1384         /* Parser modifies command_line, restore it each time */
  1385         strcpy(command_line, saved_command_line);
  1386         do_initcall_level(level, command_line);
  1387     }
  1388
  1389     kfree(command_line);
  1390 }

而 do_basic_setup 调用 do_initcalls
kernel_init_freeable 调用 do_basic_setup
kernel_init 调用 kernel_init_freeable

3.2.3 释放空间

kernel_init 调用完 kernel_init_freeable后 释放 无用的空间。

  1490 static int __ref kernel_init(void *unused)
  1491 {
  1492     int ret;
  1493
  1494     /*
  1495      * Wait until kthreadd is all set-up.
  1496      */
  1497     wait_for_completion(&kthreadd_done);
  1498
  1499     kernel_init_freeable();
  1500     /* need to finish all async __init code before freeing the memory */
  1501     async_synchronize_full();
  1502
  1503     system_state = SYSTEM_FREEING_INITMEM;
  1504     kprobe_free_init_mem();
  1505     ftrace_free_init_mem();
  1506     kgdb_free_init_mem();
  1507     exit_boot_config();
  1508     free_initmem();
  1509     mark_readonly();
  1510

如下所示，将释放__init_begin 到 __init_end 指针指向的地址之间的空间。并打印 Free unused kernel image memory xxK

  513 void free_initmem(void)
  514 {
  515     fix_kernmem_perms();
  516
  517     poison_init_mem(__init_begin, __init_end - __init_begin);
  518     if (!machine_is_integrator() && !machine_is_cintegrator())
  519         free_initmem_default(-1);
  520 }
  521

2527 static inline unsigned long free_initmem_default(int poison)
2528 {
2529     extern char __init_begin[], __init_end[];
2530
2531     return free_reserved_area(&__init_begin, &__init_end,
2532                   poison, "unused kernel image (initmem)");
2533 }

  8115 unsigned long free_reserved_area(void *start, void *end, int poison, const char *s)
  8116 {
  8117     void *pos;
  8118     unsigned long pages = 0;
  8119
  8120     start = (void *)PAGE_ALIGN((unsigned long)start);
  8121     end = (void *)((unsigned long)end & PAGE_MASK);
  8122     for (pos = start; pos < end; pos += PAGE_SIZE, pages++) {
  8123         struct page *page = virt_to_page(pos);
  8124         void *direct_map_addr;
  8125
  8126         /*
  8127          * 'direct_map_addr' might be different from 'pos'
  8128          * because some architectures' virt_to_page()
  8129          * work with aliases.  Getting the direct map
  8130          * address ensures that we get a _writeable_
  8131          * alias for the memset().
  8132          */
  8133         direct_map_addr = page_address(page);
  8134         /*
  8135          * Perform a kasan-unchecked memset() since this memory
  8136          * has not been initialized.
  8137          */
  8138         direct_map_addr = kasan_reset_tag(direct_map_addr);
  8139         if ((unsigned int)poison <= 0xFF)
  8140             memset(direct_map_addr, poison, PAGE_SIZE);
  8141
  8142         free_reserved_page(page);
  8143     }
  8144
  8145     if (pages && s)
  8146         pr_info("Freeing %s memory: %ldK\n", s, K(pages));
  8147
  8148     return pages;
  8149 }

__init_begin和 __init_end在链接脚本 arch/arm/kernel/vmlinux.lds中定义，
而其中有定义

将 .init.text 段放到 __init_begin 和 __init_end 之间。
我们回顾 module_init(fn) 时， fn 的声明为

static int __init fn(void) 

根据目的，我们需要把 fn 的定义放到 __init_begin 和 __init_end 之间，以让其在执行后被释放。
我们查看 __init 宏的定义

   50 #define __init      __section(".init.text") __cold  __latent_entropy __noinitretpoline __nocfi

可见 __init 就是将修饰的符号 定义在 .init.text段，
再看连接脚本中 .init.text的位置

 30  __init_begin = .;
   ...
 . = ALIGN(8); .init.text : AT(ADDR(.init.text) - 0) { _sinittext = .; *(.init.text .init.text.*) *(.text.star    tup) *(.meminit.text*) _einittext = .; }
   ...
 65  __init_end = .;

可见 .init.text在 __init_begin和 __init_end之间，所以 被 __init宏修饰的 符号将会被free_initmem释放。

3.2.4 总结

模块内嵌内核时，module_init宏将 定义一个 内存空间 使用 基址加变址的方式保存 被修饰的函数地址，并将所有同类型空间链接到同一段.initcall6.init ，并定义 符号 __initcall6_start作为数组首地址，内核初始化时会遍历数组以执行模块初始化函数。所有的初始化完成后，会释放 __init_begin 到__init_end之间的空间，由于 模块 初始化函数使用 __init 宏定义，会被连接到 __init_begin和__init_end之间，所以模块初始化函数会被释放。