Linux中程序是怎样启动的
作者：互联网
Linux中程序是怎样启动的
前言
- 新程序的启动往往是通过libc中exe()系列函数进行的, exe系列函数最终都可以归纳为execve这个系统调用
- 系统层面
- kernel会检查这个文件的类型
- 确定是elf之后会为新进程分配页表, 文件描述符, task描述符等各种资源
- 然后解析这个elf文件, 把text data bss等段都映射到内存中
- 然后jmp到elf的入口点, 从而开始执行
ELF的入口点_start()
-
由于现代ELF使用运行时重定位机制。即：运行钱各种libc库函数的地址，编译时不知道libc会被mmap到哪
-
因此如果kernel发现需要运行时重定位, 那么就会转而jmp到这个elf指定的动态链接器(也就是常用的ld.so.2), 由ld去重定位elf中相关地址后再jmp到elf的入口点
-
但是ld并不是直接执行main()函数, 因为有析构函数就必定有构造函数, 在进入main之前还需要进行参数设置, 申请流缓冲区等操作
实际上ld会跳转到elf中的_start标号处, 这才是elf中第一个被执行的指令地址
-
_start标号处的程序由汇编编写, 对应libc中start.S文件,
- _start做的工作很少, 只会为__libc_start_main()设置好参数, 然后调用
- _start()会在编译的时候被链接入ELF文件中
- 而libc_start_main()定义在libc中, _start()通过PLT+GOT调用到libc_start_main()
ENTRY (_start) /* 编译时告诉链接器, 这里才是整个函数的入口点 */
/* Clearing frame pointer is insufficient, use CFI. */
cfi_undefined (rip)
/* 初始化栈底: %ebp=0 */
xorl %ebp, %ebp
/* 设置__libc_start_main的参数
调用__libc_start_main的参数会通过如下寄存器传递, 因为linux才用cdecl函数调用约定:
main: %rdi
argc: %rsi
argv: %rdx
init: %rcx
fini: %r8
rtld_fini: %r9
stack_end: stack. */
mov %RDX_LP, %R9_LP /* 设置参数rtld_fini */
#ifdef __ILP32__
mov (%rsp), %esi /* Simulate popping 4-byte argument count. */
add $4, %esp
#else
popq %rsi /* Pop argc */
#endif
/* 设置参数argv */
mov %RSP_LP, %RDX_LP
/* rsp对齐 */
and $~15, %RSP_LP
/* Push garbage because we push 8 more bytes. */
pushq %rax
/* Provide the highest stack address to the user code (for stackswhich grow downwards). */
pushq %rsp
#ifdef SHARED
/* 设置参数init和fini */
mov __libc_csu_fini@GOTPCREL(%rip), %R8_LP
mov __libc_csu_init@GOTPCREL(%rip), %RCX_LP
/* 设置参数main函数地址 */
mov main@GOTPCREL(%rip), %RDI_LP
/* 调用__libc_start_main()
__libc_start_main()进行一些构造工作, 然后调用main()
main() return到__libc_start_main之后 __libc_start_main会进行析构工作 */
call __libc_start_main@PLT
#else
/* Pass address of our own entry points to .fini and .init. */
mov $__libc_csu_fini, %R8_LP
mov $__libc_csu_init, %RCX_LP
mov $main, %RDI_LP
/* Call the user's main function, and exit with its value.
But let the libc call main. */
call __libc_start_main
#endif
hlt /* Crash if somehow `exit' does return. */
END (_start)
- 由此注册析构函数的关键点就在__libc_start_main()中
__libc_start_main
这个函数定义在libc源码的libc-start.c文件中, 由于比较复杂, 因此只分析关键部分
- 首先是其参数列表也就是_start()传递的参数, 我们中重点注意下面三个
- init: ELF文件 也就是main()的构造函数
- fini: ELF文件 也就是main()的析构函数
- rtld_fini: 动态链接器的析构函数
static int __libc_start_main(
int (*main)(int, char **, char **MAIN_AUXVEC_DECL), //参数: main函数指针
int argc, char **argv, //参数: argc argv
ElfW(auxv_t) * auxvec,
__typeof(main) init, //参数: init ELF的构造函数
void (*fini)(void), //参数: fini ELF的析构函数
void (*rtld_fini)(void), //参数: rtld_fini ld的析构函数
void *stack_end //参数: 栈顶
)
{
...函数体;
}
- 进入函数体, __libc_start_mian()主要做了以下几件事
- 为libc保存一些关于main的参数, 比如__environ…
- 通过atexit()注册fini 与 rtld_fini 这两个参数
- 调用init为main()进行构造操作
- 然后调用main()函数
_dl_fini（）
- 我们把进程空间中的一个单独文件, 称之为模块
- ld.so.2会通过dl_open()把所需文件到进程空间中, 他会把所有映射的文件都记录在结构体_rtld_global中
- 当一个进程终止, ld.so.2自然需要卸载所映射的模块, 这需要调用每一个非共享模块的fini_arrary段中的析构函数
- 一言以蔽之: _dl_fini()的功能就是调用进程空间中所有模块的析构函数
_dl_fini的任务:
- 遍历rtld_global中所有的命名空间
- 遍历命名空间中所有的模块
- 找到这个模块的fini_array段, 并调用其中的所有函数指针
- 找到这个模块的fini段, 调用
void internal_function _dl_fini(void)
{
#ifdef SHARED
int do_audit = 0;
again:
#endif
for (Lmid_t ns = GL(dl_nns) - 1; ns >= 0; --ns) //遍历_rtld_global中的所有非共享模块: _dl_ns[DL_NNS]
{
__rtld_lock_lock_recursive(GL(dl_load_lock)); //对rtld_global上锁
unsigned int nloaded = GL(dl_ns)[ns]._ns_nloaded;
/* 如果这个NameSapce没加载模块, 或者不需要释放, 就不需要做任何事, 就直接调用rtld中的函数指针释放锁 */
if (nloaded == 0 || GL(dl_ns)[ns]._ns_loaded->l_auditing != do_audit)
__rtld_lock_unlock_recursive(GL(dl_load_lock));
else //否则遍历模块
{
/* 把这个命名空间中的所有模块指针, 都复制到maps数组中 */
struct link_map *maps[nloaded];
unsigned int i;
struct link_map *l;
assert(nloaded != 0 || GL(dl_ns)[ns]._ns_loaded == NULL);
for (l = GL(dl_ns)[ns]._ns_loaded, i = 0; l != NULL; l = l->l_next) //遍历链表
if (l == l->l_real) /* Do not handle ld.so in secondary namespaces. */
{
assert(i < nloaded);
maps[i] = l;
l->l_idx = i;
++i;
/* Bump l_direct_opencount of all objects so that they are not dlclose()ed from underneath us. */
++l->l_direct_opencount;
}
...;
unsigned int nmaps = i; //多少个模块
/* 对maps进行排序, 确定析构顺序 */
_dl_sort_fini(maps, nmaps, NULL, ns);
//释放锁
__rtld_lock_unlock_recursive(GL(dl_load_lock));
/* 从前往后, 析构maps中的每一个模块 */
for (i = 0; i < nmaps; ++i)
{
struct link_map *l = maps[i];
if (l->l_init_called)
{
/* Make sure nothing happens if we are called twice. */
l->l_init_called = 0;
/* 是否包含fini_array节, 或者fini节 */
if (l->l_info[DT_FINI_ARRAY] != NULL || l->l_info[DT_FINI] != NULL)
{
/* debug时打印下相关信息 */
if (__builtin_expect(GLRO(dl_debug_mask) & DL_DEBUG_IMPCALLS, 0))
_dl_debug_printf("\ncalling fini: %s [%lu]\n\n",DSO_FILENAME(l->l_name),ns);
/* 如果有fini_array节的话 */
if (l->l_info[DT_FINI_ARRAY] != NULL)
{
/*
l->l_addr: 模块l的加载基地址
l->l_info[DT_FINI_ARRAY]: 模块l中fini_array节的描述符
l->l_info[DT_FINI_ARRAY]->d_un.d_ptr: 模块l中fini_arrary节的偏移
array: 为模块l的fini_array节的内存地址
*/
ElfW(Addr) *array = (ElfW(Addr) *)(l->l_addr + l->l_info[DT_FINI_ARRAY]->d_un.d_ptr);
/*
ELF中 fini_arraysz节用来记录fini_array节的大小
l->l_info[DT_FINI_ARRAYSZ]: 模块l中fini_arraysz节描述符
l->l_info[DT_FINI_ARRAYSZ]->d_un.d_val: 就是fini_array节的大小, 以B为单位
i: fini_array节的大小/一个指针大小, 即fini_array中有多少个析构函数
*/
unsigned int i = (l->l_info[DT_FINI_ARRAYSZ]->d_un.d_val / sizeof(ElfW(Addr)));
while (i-- > 0) //从后往前, 调用fini_array中的每一个析构函数
((fini_t)array[i])();
}
/* 调用fini段中的函数 */
if (l->l_info[DT_FINI] != NULL)
DL_CALL_DT_FINI(l, l->l_addr + l->l_info[DT_FINI]->d_un.d_ptr);
}
...;
}
/* Correct the previous increment. */
--l->l_direct_opencount;
}
}
}
...;
}
标签：__,ns,启动,libc,程序,fini,start,Linux,main 来源： https://www.cnblogs.com/7resp4ss/p/16677932.html