linux 内核模块重定位过程 简单的示例解析

已于 2024-04-07 13:54:26 修改
阅读量1.2k 收藏 1
点赞数
分类专栏： 内核模块 文章标签： linux
于 2023-05-24 17:54:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41929943/article/details/130852232
版权

示例

以test_module1.ko为例，进行说明。

.rela.text节内容

readelf -r test_module1.ko | head -n 10 得到如下内容，如下内容为 .rela.text 节的内容。

Relocation section '.rela.text' at offset 0x21ab0 contains 12 entries:
  Offset          Info           Type           Sym. Value    Sym. Name + Addend
000000000005  002a00000004 R_X86_64_PLT32    0000000000000000 __fentry__ - 4
000000000011  002e0000000b R_X86_64_32S      0000000000000000 test_weakref + 0
00000000001d  003800000004 R_X86_64_PLT32    0000000000000000 msleep - 4
000000000026  000200000002 R_X86_64_PC32     0000000000000000 .text.unlikely + 17
00000000002b  002e00000004 R_X86_64_PLT32    0000000000000000 test_weakref - 4
000000000030  002900000004 R_X86_64_PLT32    0000000000000000 kthread_should_stop - 4
000000000045  002a00000004 R_X86_64_PLT32    0000000000000000 __fentry__ - 4

.text节内容

此内容为反汇编 test_module1.ko 所得到的部分反汇编文件的 .text 节的部分内容。

Disassembly of section .text:

0000000000000000 <debug_1>:
{
        printk("weakref\n");
}
#endif
int debug_1(void *arg)
{
   0:   f3 0f 1e fa             endbr64
   4:   e8 00 00 00 00          callq  9 <debug_1+0x9>
   9:   55                      push   %rbp
   a:   48 89 e5                mov    %rsp,%rbp
   d:   53                      push   %rbx
        while(!kthread_should_stop()){

                msleep(5000);
                if(test_weakref)
   e:   48 c7 c3 00 00 00 00    mov    $0x0,%rbx
        while(!kthread_should_stop()){
  15:   eb 18                   jmp    2f <debug_1+0x2f>
                msleep(5000);
  17:   bf 88 13 00 00          mov    $0x1388,%edi
  1c:   e8 00 00 00 00          callq  21 <debug_1+0x21>
                if(test_weakref)
  21:   48 85 db                test   %rbx,%rbx
  24:   0f 84 00 00 00 00       je     2a <debug_1+0x2a>
                        test_weakref();
  2a:   e8 00 00 00 00          callq  2f <debug_1+0x2f>
}

节头信息

此内容为 readelf -S test_module1.ko 获得的各节的节头信息：

There are 40 section headers, starting at offset 0x3c788:

Section Headers:
  [Nr] Name              Type             Address           Offset
       Size              EntSize          Flags  Link  Info  Align
  [ 0]                   NULL             0000000000000000  00000000
       0000000000000000  0000000000000000           0     0     0
  [ 1] .text             PROGBITS         0000000000000000  00000040
       00000000000000b0  0000000000000000  AX       0     0     16
  [ 2] .rela.text        RELA             0000000000000000  00021ab0
       0000000000000120  0000000000000018   I      37     1     8
......
  [37] .symtab           SYMTAB           0000000000000000  00021368
       0000000000000558  0000000000000018          38    36     8
  [38] .strtab           STRTAB           0000000000000000  000218c0
       00000000000001eb  0000000000000000           0     0     1
  [39] .shstrtab         STRTAB           0000000000000000  0003c600
       0000000000000181  0000000000000000           0     0     1

符号表：

此内容为 readelf -s test_module1.ko 获得的符号表

Symbol table '.symtab' contains 57 entries:
   Num:    Value          Size Type    Bind   Vis      Ndx Name
     0: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT  UND
......
    54: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT  UND unregister_module_notifie
    55: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT  UND register_module_notifier
    56: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT  UND msleep

解析

流程解析从 apply_relocations 函数开始。
模块函数调用关系：
init_module
->load_module
–>apply_relocations

static int apply_relocations(struct module *mod, const struct load_info *info)
{
	unsigned int i;
	int err = 0;

	/* Now do relocations. */
	for (i = 1; i < info->hdr->e_shnum; i++) {
		unsigned int infosec = info->sechdrs[i].sh_info;

		/* Not a valid relocation section? */
		if (infosec >= info->hdr->e_shnum)
			continue;

		/* Don't bother with non-allocated sections */
		if (!(info->sechdrs[infosec].sh_flags & SHF_ALLOC))
			continue;

		/* Livepatch relocation sections are applied by livepatch */
		if (info->sechdrs[i].sh_flags & SHF_RELA_LIVEPATCH)
			continue;

		if (info->sechdrs[i].sh_type == SHT_REL)
			err = apply_relocate(info->sechdrs, info->strtab,
					     info->index.sym, i, mod);
		else if (info->sechdrs[i].sh_type == SHT_RELA)
			err = apply_relocate_add(info->sechdrs, info->strtab,
						 info->index.sym, i, mod);
		if (err < 0)
			break;
	}
	return err;
}

以 apply_relocations 函数中的第第二次循环（i=2）为例，即处理的是 .rela.text 节。

在此基础上，apply_relocations 函数执行流程如下：

  • 从节头信息列表中可知，当前节的 sh_info 为 1 ，则循环中变量 infosec 的值为 1 。
  • info->sechdrs[infosec].sh_flags ，也就是 .rela.text 段中的 flags ，其值包含 SHF_ALLOC ，所以，程序继续向后执行。
  • info->sechdrs[i].sh_type 的值为 RELA 所以，进入到 apply_relocate_add 函数中。
  • 传入参数 ：
    • symindex 为 37
    • relsec 为 2
int apply_relocate_add(Elf64_Shdr *sechdrs,
		   const char *strtab,
		   unsigned int symindex,
		   unsigned int relsec,
		   struct module *me)
{
	unsigned int i;
	Elf64_Rela *rel = (void *)sechdrs[relsec].sh_addr;
	Elf64_Sym *sym;
	void *loc;
	u64 val;

	for (i = 0; i < sechdrs[relsec].sh_size / sizeof(*rel); i++) {
		/* This is where to make the change */
		loc = (void *)sechdrs[sechdrs[relsec].sh_info].sh_addr
			+ rel[i].r_offset;

		/* This is the symbol it is referring to.  Note that all
		   undefined symbols have been resolved.  */
		sym = (Elf64_Sym *)sechdrs[symindex].sh_addr
			+ ELF64_R_SYM(rel[i].r_info);

		DEBUGP("type %d st_value %Lx r_addend %Lx loc %Lx\n",
		       (int)ELF64_R_TYPE(rel[i].r_info),
		       sym->st_value, rel[i].r_addend, (u64)loc);

		val = sym->st_value + rel[i].r_addend;

		switch (ELF64_R_TYPE(rel[i].r_info)) {
		case R_X86_64_32S:
			if (*(s32 *)loc != 0)
				goto invalid_relocation;
			*(s32 *)loc = val;
			if ((s64)val != *(s32 *)loc)
				goto overflow;
			break;
		case R_X86_64_PC32:
		case R_X86_64_PLT32:
			if (*(u32 *)loc != 0)
				goto invalid_relocation;
			val -= (u64)loc;
			*(u32 *)loc = val;
			break;
		default:
			pr_err("%s: Unknown rela relocation: %llu\n",
			       me->name, ELF64_R_TYPE(rel[i].r_info));
			return -ENOEXEC;
		}
	}
	return 0;


}

假设，.text 段起始地址为 0x7000000 ，.rela.text 段起始地址为 0x8000000 , .symtab 段的起始地址为 0x9000000 。
在次基础上，且以第三次循环（i=2）为例， apply_relocate_add 函数执行流程如下：

  • loc 变量的值。
    • 从节头信息列表中可知，sechdrs[relsec].sh_info ，也就是 .rela.text 的 sh_info 的值为 1.
    • 则，sechdrs[sechdrs[relsec].sh_info].sh_addr 的值为 .text 节的起始地址，也就是 0x7000000 。其在 rewrite_section_headers 函数中完成重定位，位绝对地址，而非相对地址。
    • rel[i] 为 .rela.text 节的第三个条目，也就是 00000000001d 003800000004 R_X86_64_PLT32 0000000000000000 msleep - 4
    • 则 rel[i].r_offset 的值为 00000000001d
    • 将该偏移值对比反汇编文件中的部分可知， 1c 地址行处为跳转指令 callq 。整个跳转指令包含两部分，条钻指令和目的地址。而 1d 的位置就是跳转指令的后三个字节，也就是跳转指令要跳转符号的具体地址。
  • sym 变量的值。
    • sechdrs[symindex].sh_addr 的值为符号表地址，也就是 0x9000000 。其同样在 rewrite_section_headers 函数中完成重定位，位绝对地址，而非相对地址。
    • ELF64_R_SYM(rel[i].r_info) 就是 003800000004 的高32位。即 0x38 ，也就是十进制的 56。
    • 查看符号表可以指导，符号表中，第56个条目正是 msleep 。
    • 则 sym 的值就是符号表中，msleep 符号的信息。
  • val 的值。
    • sym->st_value 在 simplify_symbols 函数中，已被重新定位过，即 sym[i].st_value +=info->sechdrs[sym[i].st_shndx].sh_addr; ，其值为符号所在的绝对地址。
    • rel[i].r_addend 为加数。
  • 根据 .rela.text 节的内容可知， ELF64_R_TYPE(rel[i].r_info 的值为 R_X86_64_PLT32 。
  • val -= (u64)loc; 的值为，跳转指令与目的符号的相对地址。
  • *(u32 *)loc = val; 将跳转指令，写入到 .text 节中。至此，完成重定位。

总结

在编译阶段，由于无法确定符号运行时的实际地址，只能将跳转语句的目的地址置空（即 e8 00 00 00 00），然后将条目信息记录到重定位表中（也就是 .rela.xxxx 或者 .rel.xxxx 中），等模块在加载时重新写入。
重定位的过程，就是在加载模块时，根据 ELF 头中的重定位节中的信息以及符号表信息，计算符号的实际地址，然后填入到跳转语句的目的地址部分，最终变成完整的跳转语句。

加数的作用

以下回答来自 chatgpt：
重定位过程中需要加上一个加数的主要原因是，目标文件中的代码和数据段并非总是以对齐的地址开始，这时候需要通过加数来校正引用地址。
在链接过程中，代码和数据段的起始地址往往用一个虚拟起始地址表示，在运行时需要将其映射到实际的物理地址中。而在映射过程中，因为不同目标文件的段起始地址不一定对齐，导致代码和数据的实际地址与虚拟地址存在偏移。因此，在重定位过程中需要通过加上合适的加数，才能够正确地修正符号的引用地址，映射到正确的实际地址中。
例如，在 ELF32 的静态重定位中，对于绝对符号的引用，重定位类型为 R_386_32，重定位表中会记录需要将该符号引用的地址加上一个绝对的数值（加数）来得到符号的真实地址。而对于相对符号的引用，重定位类型为 R_386_PC32，重定位表中会记录需要将该符号引用的地址加上另一个相对的地址值（加数），计算出地址最终的绝对值。实际上，加数中记录的是绝对地址和相对地址的差值，通过加上这个差值，才能实现符号的正确重定位。
综上，加数在重定位过程中起到了一个关键作用，用于校正引用地址和符号地址之间的偏移，确保引用的地址最终能够正确地映射到实际的物理地址中。

对的时间点
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
[ELF文件] 可执行文件
shiawaseli的博客
10-14 703
现在我们接着上次的步骤分析可执行文件 largest，看看链接器都做了什么改动。 [test@localhost Assembler]$ readelf -a largest ELF 头： Magic： 7f 45 4c 46 02 01 01 00 00 00 00 00 00 00 00 00 Class: ELF64 D...
linux动态库的重定位机制
最新发布
domybest111的博客
04-12 952
linux的动态库可以被共享，这个符号会怎么被链接进去呢，让我们来看一下过程。下面以常见的printf来举例。
认识目标文件的结构
Dablelv 的博客专栏。
06-21 1495
目标文件是源代码编译但未链接的中间文件，Windows 的 .obj 和 Linux 的 .o 文件。Windows 的目标文件采用 PE 格式，Linux 采用 ELF 格式，两种格式均是基于通用目标文件格式（COFF，Common Object File Format）变化而来，所以二者大致相同。本文以 Linux 的 ELF 格式的目标文件为例，进行介绍。
共享库的加载时重定位和位置无关代码（Load-time Relocation and Position Independent Code of Shared Libraries）
Dong_HFUT的博客
09-17 4544
介绍加载时重定位和位置无关代码。关键词为 PIC、PLT、GOT 和 延迟绑定。
HITCSAPP大作业：程序人生 hello‘s P2P
JasonRapheal的博客
06-30 446
第1章 概述 1.1 Hello简介 程序员在文本编辑器中写下hello的C语言源代码，得到了hello的源文件hello.c。之后它被预处理、编译、汇编、链接后，得到了可执行文件hello。在终端运行hello，bash会替程序员运行hello，在shell中fork一个子进程并execve hello，随后hello被加载，正式开始运行。在运行过程中可以对其进行各种操作，包括使用Ctrl+C, Ctrl+Z等向其进程或其父进程传递各种信号。最后程序员在敲入最后一个字符后，程序终止，被父进程回收，彻底
哈工大计算机系统大作业
TC_Ning的博客
06-27 345
计算机系统 大作业 题 目 程序人生-Hello’s P2P 专 业 计算机类 学　　 号 1190202306 班　　 级 1903001 学 生 宁天弛 　　 指 导 教 师 郑贵滨 　 计算机科学与技术学院 2021年6月 摘...
Linux内核重编译常见故障介绍.rar_linux_linux内核
09-23
总的来说，Linux内核重编译是一个技术性强且需要细心操作的过程。在遇到问题时，首先要确保环境配置正确，然后通过查阅文档、错误日志和在线社区资源来定位并解决问题。通过不断学习和实践，你可以逐步掌握这个过程...
Linux 启动过程.docx
02-21
理解 Linux 启动过程对于系统运维和故障排查至关重要，因为这有助于定位启动问题的源头，同时也能加深对操作系统工作原理的理解。通过学习和掌握这些步骤，IT 专业人员能够更好地管理和维护 Linux 服务器。
linux网路编程 中文 23M 版
03-11
1.5.1 Linux内核的主要模块............................................ 7 1.5.2 Linux的文件结构................................................ 9 1.6 G N U 通用公共许可证...................................
ldd3-examples-updated:ldd3 示例已更新
06-26
它们涵盖了从简单的动态库加载到复杂的符号解析、重定位等各个层面，帮助开发者深入理解动态链接过程。更新后的示例针对3.6.10内核源进行优化，确保了代码与最新内核版本的兼容性，更有利于学习者跟踪最新的技术发展...
Linux经典故障排除
04-19
6. **内核问题**：如果问题与内核相关，可能需要查看dmesg输出，或者通过modprobe、insmod、rmmod管理模块。有时，升级或重新编译内核也是必要的。 7. **权限与SELinux**：权限错误是常见的故障源，chmod、chown、...
linux静态连接
god_wen的博客
10-08 2644
从文本到代码到机器指令可分为propressing >compilation->assembly->linking四个步骤。他们像流水线一样从上一步取结果处理完输出给下一步。每一个过程都有特定的软件来实现。如propressing 是gcc -E 变成file.i文件。compilation 是gcc -S 变成file.s文件。assembly 是gcc -c 或者as 变更file.o文件。assembly 是ld 变成file文件。经过前三步文件已经变成二进制文件了。
Linux 内核模块加载过程之重定位
小立仔
08-28 772
Linux 内核模块加载过程之重定位过程包括x86_64和arm64架构
编译、链接和库(1)
拾琛的博客
03-16 389
静态编译过程的简单拆解 #include <stdio.h> int main(int argc,char *argv[]) { printf("hello world\n"); return 0; } root@:~# gcc hello.c -o hello 上面是最简单的一段C语言代码，编译成hello可执行文件后，./hello就可以打印出hello world。当我们执行gcc编译hello.c时，编译器其实进行了大量的操作以便生成我们想要的可执行文件。 简单来说，执行过程可分
ELF文件格式
chenzhjlf的专栏
05-08 423
ELF文件格式 前言 ELF文件的结构 ELF文件中各个字段的用途 ELF头（ELF Header） 段表（Section Header table） 符号表（Symbol Table） ELF文件类型 说明 实例 Relocatable File 可重定位文件 未链接之前的ELF文件，可用于链接可执行文件或静态链接库 Linux下的".o"文件，Windows下".obj"文件 Executable File 可执行文件 最终的可执行程序 如Li
ELF文件中的各个节区
ashimida
08-25 6415
ELF节区信息概述: 节区名 节区说明 备注 .rodata1 和rodata类似，只存放只读数据 .comment 存放编译器版本信息，如字符串 "GCC:(GNU)4.2.0" .debug 存放调试信息 .shstrtab ..
内核编译make bzImage 错误Unsupported relocation type: R_X86_64_PLT32 (4)
o_alpha的博客
06-07 491
对于x86_64，不支持R_X86_64_32重定位，因为必须是 PIC。这表明 binutil 版本应该有问题，需要降级？
unsupported relocation type: r_x86_64_plt32 (4)
guoguangwu的专栏
12-31 1038
unsupported relocation type: r_x86_64_plt32 (4)
Linux学习_重定位
muzi_taibai的博客
02-07 231
Linux学习_重定位
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值