20135323符运锦----第七周:Linux内核如何装载和启动一个可执行程序

可执行程序的装载

一、预处理、编译、链接和目标文件的格式

1.可执行程序是怎么得来的

20135323符运锦----第七周:Linux内核如何装载和启动一个可执行程序_第1张图片

①编译器预处理
gcc -E -o XX.cpp XX.c (-m32)//
注:把include的文件包含进来,并且完成宏的替换
②汇编器编译成汇编代码
gcc -x cpp-output -S -o hello.s hello.cpp (-m32)
③汇编代码编译成二进制目标文件
gcc -x assembler -c hello.s -o hello.o (-m32)
注:不可读,含有部分机器代码但不可执行
④链接成可执行文件
gcc -o hello.static hello.c (-m32) -static
⑤hello和hello.o都是ELF文件
⑥.static文件会将所有用到C库文件都放到这一个可执行程序中

2.目标文件的格式ELF

①A.out(最古老) COFF PE(Windows)、ELF(Linux中)

20135323符运锦----第七周:Linux内核如何装载和启动一个可执行程序_第2张图片

③一个可重定位文件保存着代码和适当的数据,用来和其他的object文件一起来创建一个可执行文件或者是一个共享文件。一个可执行文件保存着一个用来执行的程序;该文件指出了exec(BA_OS)如何来创建程序进程映象。一个共享object文件保存着代码和合适的数据,用来被下面的两个链接器链接。第一个是连接编辑器[请参看ld(SD_CMD)],可以和其他的可重定位和共享object文件来创建其他的object。第二个是动态链接器,联合一个可执行文件和其他的共享object文件来创建一个进程映象。

④ELF头描述了该文件的组织情况,程序投标告诉系统如何创建一个进程的内存映像,section头表包含了描述文件sections的信息。当系统要执行一个文件的时候,理论上讲,他会把程序段拷贝到虚拟内存中某个段。

20135323符运锦----第七周:Linux内核如何装载和启动一个可执行程序_第3张图片
程序从0x804800开始,可执行文件加载到内存中开始执行的第一行代码,一般静态链接将会把所有代码放在同一个代码段,动态连接的进程会有多个代码段。

二、可执行文件、共享库和动态链接

1.装载可执行程序之前的工作

可执行程序的执行环境

①命令行参数和shell环境,一般我们执行一个程序的Shell环境,我们的实验直接使用execve系统调用。

Shell本身不限制命令行参数的个数,命令行参数的个数受限于命令自身。例如,int main(int argc, char *argv[]), int main(int argc, char argv[], char envp[])
Shell会调用execve将命令行参数和环境参数传递给可执行程序的main函数。int execve(const char * filename,char * const argv[ ],char * const envp[ ]);库函数exec*都是execve的封装例程。

命令行参数和环境串都放在用户态堆栈中

20135323符运锦----第七周:Linux内核如何装载和启动一个可执行程序_第4张图片

①fork子进程的时候完全复制了父进程;调用exec的时候,要加载的可执行程序把原来的进程环境覆盖掉,用户态堆栈也被清空
②shell——execv——sys_execv
③先传递函数调用参数,再传递系统调用参数

2.装载时动态链接和运行时动态链接应用

动态链接分为可执行程序装载时动态链接和运行时动态链接。

例1:共享库的动态链接

准备.so文件

#ifndef _SH_LIB_EXAMPLE_H_
#define _SH_LIB_EXAMPLE_H_
#define SUCCESS 0
#define FAILURE (-1)
#ifdef __cplusplus
extern "C" {
#endif
/*
* Shared Lib API Example
* input : none
* output    : none
* return    : SUCCESS(0)/FAILURE(-1)
*
*/
int SharedLibApi();
#ifdef __cplusplus
}
#endif
#endif /* _SH_LIB_EXAMPLE_H_ */
/*------------------------------------------------------*/
#include 
#include "shlibexample.h"
int SharedLibApi()
{
printf("This is a shared libary!\n");
return SUCCESS;
}/* _SH_LIB_EXAMPLE_C_ */

shlibexample.h (1.3 KB) - Interface of Shared Lib Example

shlibexample.c (1.2 KB) - Implement of Shared Lib Example

编译成libshlibexample.so文件
$ gcc -shared shlibexample.c -o libshlibexample.so -m32

例2:动态加载库

#ifndef _DL_LIB_EXAMPLE_H_
#define _DL_LIB_EXAMPLE_H_
#ifdef __cplusplus
extern "C" {
#endif
/*
* Dynamical Loading Lib API Example
* input    : none
* output   : none
* return   : SUCCESS(0)/FAILURE(-1)
*
*/
int DynamicalLoadingLibApi();
#ifdef __cplusplus
}
#endif
#endif /* _DL_LIB_EXAMPLE_H_ */
/*------------------------------------------------------*/
#include 
#include "dllibexample.h"
#define SUCCESS 0
#define FAILURE (-1)
/*
* Dynamical Loading Lib API Example
* input    : none
 * output   : none
 * return   : SUCCESS(0)/FAILURE(-1)
 *
*/
int DynamicalLoadingLibApi()
{
printf("This is a Dynamical Loading libary!\n");
return SUCCESS;
}

编译成libdllibexample.so文件

$ gcc -shared dllibexample.c -o libdllibexample.so -m32

3.main.c

int main()
{
printf("This is a Main program!\n");
/* Use Shared Lib */
printf("Calling SharedLibApi() function of libshlibexample.so!\n");
SharedLibApi();//可以直接调用
/* Use Dynamical Loading Lib */
void * handle = dlopen("libdllibexample.so",RTLD_NOW);//先打开动态加载库
if(handle == NULL)
{
    printf("Open Lib libdllibexample.so Error:%s\n",dlerror());
    return   FAILURE;
}
int (*func)(void);
char * error;
func = dlsym(handle,"DynamicalLoadingLibApi");
if((error = dlerror()) != NULL)
{
    printf("DynamicalLoadingLibApi not found:%s\n",error);
    return   FAILURE;
}    
printf("Calling DynamicalLoadingLibApi() function of libdllibexample.so!\n");
func();  
dlclose(handle);//与dlopen函数配合,用于卸载链接库       
return SUCCESS;
}

编译main,注意这里只提供shlibexample的-L(库对应的接口头文件所在目录)和-l(库名,如libshlibexample.so去掉lib和.so的部分),并没有提供dllibexample的相关信息,只是指明了-ldl

$ gcc main.c -o main -L/path/to/your/dir lshlibexample -ldl -m32
$ export LD_LIBRARY_PATH=$PWD #将当前目录加入默认路径,否则main找不到依赖的库文件,当然也可以将库文件copy到默认路径下。
$ ./main

结果

This is a Main program!
Calling SharedLibApi() function of libshlibexample.so!
This is a shared libary!
Calling DynamicalLoadingLibApi() function of libdllibexample.so!
This is a Dynamical Loading libary!

三、可执行程序的装载

1.可执行程序的装载相关关键问题分析

①execve与fork是比较特殊的系统调用,execve用它加载的可执行文件把当前的进程覆盖掉,返回之后就不是原来的程序而是新的可执行程序起点

②sys_execve内部会解析可执行文件格式:do_execve -> do_execve_common -> exec_binprm,earch_binary_handler符合寻找文件格式对应的解析模块

list_for_each_entry(fmt, &formats, lh) //在链表中寻找可以处理这种格式的模块
if (!try_module_get(fmt->module))
 continue;
read_unlock(&binfmt_lock);
bprm->recursion_depth++;
retval = fmt->load_binary(bprm);//执行的应该是load_elf_binary其内部是和ELF文件格式解析的部分需要和ELF文件格式标准结合
read_lock(&binfmt_lock);

③Linux内核是如何支持多种不同的可执行文件格式的?

static struct linux_binfmt elf_format = {
.module     = THIS_MODULE,
.load_binary    = load_elf_binary,//函数指针
.load_shlib = load_elf_library,
.core_dump  = elf_core_dump,
.min_coredump   = ELF_EXEC_PAGESIZE,
};
************************************

static int __init init_elf_binfmt(void)
{
register_binfmt(&elf_format);//注册
return 0;
}

④庄周梦蝶——庄周(调用execve的可执行程序)入睡(调用execve陷入内核),醒来(系统调用execve返回用户态)发现自己是蝴蝶(被execve加载的可执行程序)

⑤load_elf_binary调用start_thread函数。修改int 0x80压入内核堆栈的EIP


744595-20160404215300687-1346464195.png

这里的elf_entry就是静态链接的时候可执行文件里面头部定义的entry

2.sys_execve的内部处理过程

sys_execve() -> do_execve() -> do_execve_common() -> exec_binprm() -> search_binary_handler() -> load_elf_binary() -> start_thread()

注:ELF可执行文件默认映射到0x8048000这个地址,需要动态链接的可执行文件先加载连接器ld,否则直接把elf文件entry地址赋值给entry即可。start_thread(regs, elf_entry, bprm->p)会将CPU控制权交给ld来加载依赖库并完成动态链接;对于静态链接的文件elf_entry是新程序执行的起点。

四、实验

实验要求

使用gdb跟踪分析一个execve系统调用内核处理函数sys_execve ,验证您对Linux系统加载可执行程序所需处理过程的理解,详细内容参考本周第三节;推荐在实验楼Linux虚拟机环境下完成实验。

更新menu内核
20135323符运锦----第七周:Linux内核如何装载和启动一个可执行程序_第5张图片
查看test.c文件:可以看到新增加了exec系统调用
20135323符运锦----第七周:Linux内核如何装载和启动一个可执行程序_第6张图片
20135323符运锦----第七周:Linux内核如何装载和启动一个可执行程序_第7张图片
直接:e hello.c切换到hello.c
20135323符运锦----第七周:Linux内核如何装载和启动一个可执行程序_第8张图片
查看Makefile
20135323符运锦----第七周:Linux内核如何装载和启动一个可执行程序_第9张图片
启动内核并验证execv函数
20135323符运锦----第七周:Linux内核如何装载和启动一个可执行程序_第10张图片

冻结内核,启动GDB调试
20135323符运锦----第七周:Linux内核如何装载和启动一个可执行程序_第11张图片
进行调试
先停在sys_execve处,再设置其它断点;按c一路运行下去直到断点sys_execve
20135323符运锦----第七周:Linux内核如何装载和启动一个可执行程序_第12张图片
20135323符运锦----第七周:Linux内核如何装载和启动一个可执行程序_第13张图片
20135323符运锦----第七周:Linux内核如何装载和启动一个可执行程序_第14张图片
20135323符运锦----第七周:Linux内核如何装载和启动一个可执行程序_第15张图片
20135323符运锦----第七周:Linux内核如何装载和启动一个可执行程序_第16张图片
20135323符运锦----第七周:Linux内核如何装载和启动一个可执行程序_第17张图片
20135323符运锦----第七周:Linux内核如何装载和启动一个可执行程序_第18张图片
new_ip是返回到用户态的第一条指令
退出调试状态,输入redelf -h hello可以查看hello的EIF头部
745401-20160406212713640-1759998056.png
20135323符运锦----第七周:Linux内核如何装载和启动一个可执行程序_第19张图片
20135323符运锦----第七周:Linux内核如何装载和启动一个可执行程序_第20张图片
新开一个窗口,进入内部可以发现正在修改内核堆栈
20135323符运锦----第七周:Linux内核如何装载和启动一个可执行程序_第21张图片
20135323符运锦----第七周:Linux内核如何装载和启动一个可执行程序_第22张图片
struct pt_regs *regs就是内核堆栈栈底的部分,发生中断的时候,esp和ip都进行压栈。通过修改内核堆栈中EIP的值(也就是把压入栈中的值用new_ip替换)作为新程序的起点。

对“Linux内核装载和启动一个可执行程序”的理解

新的可执行程序通过修改内核堆栈eip作为新程序的起点,从new_ip开始执行后start_thread把返回到用户态的位置从int 0x80的下一条指令变成新加载的可执行文件的入口位置。

当执行到execve系统调用时,进入内核态,用execve()加载的可执行文件覆盖当前进程的可执行程序,当execve系统调用返回时,返回新的可执行程序的执行起点(main函数),所以execve系统调用返回后新的可执行程序能顺利执行。

execve系统调用返回时,如果是静态链接,elf_entry指向可执行文件规定的头部(main函数对应的位置0x8048***);如果需要依赖动态链接库,elf_entry指向动态链接器的起点。动态链接主要是由动态链接器ld来完成的。

符运锦 (原创作品转载请注明出处) + 《Linux内核分析》MOOC课程http://mooc.study.163.com/course/USTC-1000029000

转载于:https://www.cnblogs.com/20135323fuyunjin/p/5361282.html

你可能感兴趣的:(shell,数据结构与算法,操作系统)