linux运行b,linux可执行文件的加载和运行之一

最新推荐文章于 2023-06-01 20:20:15 发布
最新推荐文章于 2023-06-01 20:20:15 发布
阅读量352 收藏
点赞数
文章标签： linux运行b

080411170239.jpg

这样程序在运行的时候就可以方便的确定参数及环境变量的个数.

现在,我们可以分析代码了.

bprm_mm_init()是bprm的初始化函数,我们跟踪进去看它是怎么样初始化的.

int bprm_mm_init(struct linux_binprm *bprm)

{

int err;

struct mm_struct *mm = NULL;

//分配一个mm

//mm_alloc我们在进程创建的时候已经分析过了,值得注意的是,它会调用mm_init()来为

//进程的用户空间建立PGD->PMD映射

bprm->mm = mm = mm_alloc();

err = -ENOMEM;

if (!mm)

goto err;

err = init_new_context(current, mm);

if (err)

goto err;

//初始化bprm->mm

err = __bprm_mm_init(bprm);

if (err)

goto err;

return 0;

err:

if (mm) {

bprm->mm = NULL;

mmdrop(mm);

}

return err;

}

重点是在__bprm_mm_init():

static int __bprm_mm_init(struct linux_binprm *bprm)

{

int err = -ENOMEM;

struct vm_area_struct *vma = NULL;

struct mm_struct *mm = bprm->mm;

//分配一个VMA

bprm->vma = vma = kmem_cache_zalloc(vm_area_cachep, GFP_KERNEL);

if (!vma)

goto err;

down_write(&mm->mmap_sem);

vma->vm_mm = mm;

//STACK_TOP_MAX：进程用户空间的最高值

//对应进程的栈顶

vma->vm_end = STACK_TOP_MAX;

vma->vm_start = vma->vm_end - PAGE_SIZE;

vma->vm_flags = VM_STACK_FLAGS;

vma->vm_page_prot = vm_get_page_prot(vma->vm_flags);

//将VM插入mm表示的进程空间结构

err = insert_vm_struct(mm, vma);

if (err) {

up_write(&mm->mmap_sem);

goto err;

}

mm->stack_vm = mm->total_vm = 1;

up_write(&mm->mmap_sem);

//bprm->p:用户栈的栈指针

bprm->p = vma->vm_end - sizeof(void *);

return 0;

err:

if (vma) {

bprm->vma = NULL;

kmem_cache_free(vm_area_cachep, vma);

}

return err;

}

上面的操作看起来比较隐晦,我们把它的操作用下面的图表示:

080411170401.jpg

在这里为bprm->mm的初始化下了这么多功夫是为什么呢?它跟进程的mm有什么关系?不急,继续耐着性子看代码,我们会看到它的用途的.

继续分析do_execve()中所调用的子函数.

Count()来用计算可执行文件的参数或者环境变量的个数.它的代码如下:

static int count(char __user * __user * argv, int max)

{

int i = 0;

if (argv != NULL) {

for (;;) {

char __user * p;

//在内核空间中取argv的值

//取值失败

if (get_user(p, argv))

return -EFAULT;

//如果为空。说明已经取到了NULL。结束了

if (!p)

break;

argv++;

//参数个数超过了允许的最大值

if(++i > max)

return -E2BIG;

cond_resched();

}

}

return i;

}

这个函数的原理是利用参数后面是以NULL结尾的,不懂的请回个头去看下上面的分析.

疑问:在取参数个数的时候,会进行用户空间到内核空间的copy.但是这里仅仅是得知它的个数,在后面的操作中,还会继续去取参数值放到bprm->mm表示的空间中.这里有两次拷copy.可不可把这两个过程放在一起.省掉一次从用户空间到内核空间的COPY呢?

prepare_binprm()会将文件的前128字节copy到bprm->buf.代码片段如下所示:

int prepare_binprm(struct linux_binprm *bprm)

{

……

……

memset(bprm->buf,0,BINPRM_BUF_SIZE);

//#define BINPRM_BUF_SIZE 128

return kernel_read(bprm->file,0,bprm->buf,BINPRM_BUF_SIZE);

}

将具体的参数COPY到bprm->mm所表示的存储空间中是由copy_strings()完成的.它的代码有一点繁锁.如下示:

/*

参数含义：

argc:参数个数

argv:参数数组

*/

static int copy_strings(int argc, char __user * __user * argv,

struct linux_binprm *bprm)

{

struct page *kmapped_page = NULL;

char *kaddr = NULL;

unsigned long kpos = 0;

int ret;

while (argc-- > 0) {

char __user *str;

int len;

unsigned long pos;

//取数组相应项，将其放至str中

//COPY失败，或者参数长度非法

if (get_user(str, argv+argc) ||

!(len = strnlen_user(str, MAX_ARG_STRLEN))) {

ret = -EFAULT;

goto out;

}

//判断参数长度是否超过允许的最大值

if (!valid_arg_len(bprm, len)) {

ret = -E2BIG;

goto out;

}

/* We're going to work our way backwords. */

//当前的位置

pos = bprm->p;

str += len;

bprm->p -= len;

while (len > 0) {

int offset, bytes_to_copy;

offset = pos % PAGE_SIZE;

if (offset == 0)

offset = PAGE_SIZE;

bytes_to_copy = offset;

if (bytes_to_copy > len)

bytes_to_copy = len;

offset -= bytes_to_copy;

pos -= bytes_to_copy;

str -= bytes_to_copy;

len -= bytes_to_copy;

if (!kmapped_page || kpos != (pos & PAGE_MASK)) {

struct page *page;

//根据映射关系得到pos地址在bprm->mm中所映射的页面

page = get_arg_page(bprm, pos, 1);

if (!page) {

ret = -E2BIG;

goto out;

}

if (kmapped_page) {

flush_kernel_dcache_page(kmapped_page);

//断开临时映射

kunmap(kmapped_page);

//减少引用计数

put_arg_page(kmapped_page);

}

kmapped_page = page;

//将临时映射到内核

kaddr = kmap(kmapped_page);

kpos = pos & PAGE_MASK;

flush_arg_page(bprm, kpos, kmapped_page);

}

//copy参数至刚才映射的页面

if (copy_from_user(kaddr+offset, str, bytes_to_copy)) {

ret = -EFAULT;

goto out;

}

}

}

ret = 0;

out:

if (kmapped_page) {

flush_kernel_dcache_page(kmapped_page);

kunmap(kmapped_page);

put_arg_page(kmapped_page);

}

return ret;

}

我们在前面看到,并没有给VM映射实际的内存,在这里COPY参数的时候,必然会引起缺页异常,再由缺页异常程序处理缺页的情况.

经过上面的过程之后,bprm->mm表示的存储空间如下所示:

080411170452.jpg

经过一系统的初始化之后,可以寻找该文件的加载module了.这是由search_binary_handler()完成的.在深入到这段代码之前.我们有必要讨论一下linux可执文件模块的组织.

在linux内核,用linux_binfmt结构来表示每一个加载模块.它的定义如下:

struct linux_binfmt {

//用来构成链表

struct list_head lh;

//所属的module

struct module *module;

//加载可执行文件

int (*load_binary)(struct linux_binprm *, struct  pt_regs * regs);

//加载共享库

int (*load_shlib)(struct file *);

int (*core_dump)(long signr, struct pt_regs *regs, struct file *file, unsigned long limit);

unsigned long min_coredump;        /* minimal dump size */

int hasvdso;

}

结构中的lh将之组成一个链表,这个链表的表头是formats.

为了说明,我们来看一下如何注册一个可执行文件的加载模块.

int register_binfmt(struct linux_binfmt * fmt)

{

if (!fmt)

return -EINVAL;

write_lock(&binfmt_lock);

//将其添加之链表

list_add(&fmt->lh, &formats);

write_unlock(&binfmt_lock);

return 0;

}

所以,在加载可执文件的时候,只要遍历formats这个链表,然后依次按module加载这个可执行文件.这正是search_binary_handler()所做的.代码如下:

int search_binary_handler(struct linux_binprm *bprm,struct pt_regs *regs)

{

int try,retval;

struct linux_binfmt *fmt;

#ifdef __alpha__

/* handle /sbin/loader.. */

{

struct exec * eh = (struct exec *) bprm->buf;

if (!bprm->loader && eh->fh.f_magic == 0x183 &&

(eh->fh.f_flags & 0x3000) == 0x3000)

{

struct file * file;

unsigned long loader;

allow_write_access(bprm->file);

fput(bprm->file);

bprm->file = NULL;

loader = bprm->vma->vm_end - sizeof(void *);

file = open_exec("/sbin/loader");

retval = PTR_ERR(file);

if (IS_ERR(file))

return retval;

/* Remember if the application is TASO.  */

bprm->sh_bang = eh->ah.entry < 0x100000000UL;

bprm->file = file;

bprm->loader = loader;

retval = prepare_binprm(bprm);

if (retval<0)

return retval;

/* should call search_binary_handler recursively here,

but it does not matter */

}

}

#endif

retval = security_bprm_check(bprm);

if (retval)

return retval;

/* kernel module loader fixup */

/* so we don't try to load run modprobe in kernel space. */

set_fs(USER_DS);

retval = audit_bprm(bprm);

if (retval)

return retval;

retval = -ENOENT;

//这里会循环两次.待模块加载之后再遍历一次

for (try=0; try<2; try++) {

read_lock(&binfmt_lock);

list_for_each_entry(fmt, &formats, lh) {

//加载函数

int (*fn)(struct linux_binprm *, struct pt_regs *) = fmt->load_binary;

if (!fn)

continue;

if (!try_module_get(fmt->module))

continue;

read_unlock(&binfmt_lock);

//运行加载函数，如果加载末成功，则继续遍历

retval = fn(bprm, regs);

//加载成功了

if (retval >= 0) {

put_binfmt(fmt);

allow_write_access(bprm->file);

if (bprm->file)

fput(bprm->file);

bprm->file = NULL;

current->did_exec = 1;

proc_exec_connector(current);

return retval;

}

read_lock(&binfmt_lock);

put_binfmt(fmt);

if (retval != -ENOEXEC || bprm->mm == NULL)

break;

if (!bprm->file) {

read_unlock(&binfmt_lock);

return retval;

}

}

read_unlock(&binfmt_lock);

//所有模块加载这个可执行文件失败,则加载其它模块再试一次

if (retval != -ENOEXEC || bprm->mm == NULL) {

break;

//CONFIG_KMOD:动态加载模块标志

#ifdef CONFIG_KMOD

}else{

#define printable(c) (((c)=='\t') || ((c)=='\n') || (0x20<=(c) && (c)<=0x7e))

if (printable(bprm->buf[0]) &&

printable(bprm->buf[1]) &&

printable(bprm->buf[2]) &&

printable(bprm->buf[3]))

break; /* -ENOEXEC */

request_module("binfmt-%04x", *(unsigned short *)(&bprm->buf[2]));

#endif

}

}

return retval;

}

到这里,我们看到了可执行文件的加载过程,接下来,我们以a.out型的可执文件的加载过程为例.来看一看linux怎么处理可执行文件的.

李_涛
关注
Linux的执行elf可执行文件流程
新时代农民工
07-05 694
execve族系统调用用于运行一个新的进程，并且替换当前进程的内存映像（代码，数据，栈）为新进程的内存映像。这个系统调用会在指定的进程空间内加载一个新的程序，同时将参数和环境变量传递给新程序。execve族的调用可以让用户免于开发自己的shell或者cli程序，用现有的程序交互式地对系统进行操作，甚至可以在shell中启动其他进程。由以上代码可知，execve族系统调用主要是通过elf加载器解释加载到内存，再通过修改arm的pc sp指针，使得该elf可执行文件得以运行。
linux ko 文件运行,Linux下编写和加载 .ko 文件（驱动模块文件）
weixin_32568295的博客
05-02 5325
一、.ko 文件介绍.ko文件是kernel object文件(内核模块)，该文件的意义就是把内核的一些功能移动到内核外边， 需要的时候插入内核，不需要时卸载。二、优点(1)这样可以缩小内核体积；(2)使用方便。三、.ko文件一般的用处(1)作为一个功能模块，需要使用时，直接插入运行就行。如在imx6上连接模拟摄像头，先运行模拟摄像头对应的驱动模块 camera.ko文件，然后对应的工程执行文件运...
linux可执行文件的加载过程
热门推荐
Lux_Veritas的专栏
07-16 1万+
有关进程的创建，详细的机制书本上与在线资源中有很多说明，这篇文章有比较详细的介绍，可以先仔细阅读里面的内容。 本篇文章简要介绍linux可执行文件的进程创建与加载的过程。linux在创建进程时，采用写时复制(copy on write)技术，在加载进程时，采用按需加载机制。 写时复制技术 父进程通过fork()系统调用创建子进程，子进程复制父进程的页目录和
linux进程加载和运行,linux进程管理之可执行文件的加载和运行
weixin_30716641的博客
04-29 244
linux进程管理之可执行文件的加载和运行,非常详细,有志于内核分析和开发的人可以看看!linux进程管理之可执行文件的加载和运行(一)三:可执行文件的加载和运行Execve系统调用可以调用一个可执行文件完全代替当前的进程,它在libc中的封装有几个API: int execl(const charp a t* h n a m e, const char a* rg 0, ... /* (char...
[linux内核] 6.可执行文件的装载
H4ppyD0g的博客
11-25 427
文章目录1. execve系统调用上下文环境2. 静态、动态链接的装载区别3. execve系统调用过程4. execve系统调用过程总结5. 补充elf_format全局变量 1. execve系统调用上下文环境 int execlp(const char *filename, const char *arg, ...)说明 execlp函数会从PATH环境变量所指得目录中查找符合参数file的文件名，找到后便执行该文件， 然后将第二个以后的参数当作该文件的argv[0]、argv[1]…，最后一个参
* linux下编译，链接，运行，汇编程序
如丧
07-11 694
当前使用的操作系统：ubuntu11.10 汇编程序由定义好的段构成，每个段都有不同的目的，三个最常用的段：     1）data 段             汇编程序 data（数据）段是可选的。             数据段声明带有初始值的数据元素，这些数据元素用作汇编程序的变量。                    2）bss 段         
一文解决从进程栈内存底层原理到Segmentation fault报错
youzhangjing_的博客
02-14 444
来总结下本文的内容，本文讨论了进程栈内存的工作原理。第一，进程在加载的时候给进程栈申请了一块虚拟地址空间 vma 内核对象。vm_start 和 vm_end 之间留了一个 Page ，也就是说默认给栈准备了 4KB 的空间。第二，当进程在运行的过程中在栈上开始分配和访问变量的时候，如果物理页还没有分配，会触发缺页中断。在缺页中断中调用内核的伙伴系统真正地分配物理内存。第三，当栈中的存储超过 4KB 的时候会自动进行扩大。不过大小要受到限制，其大小限制可以通过 ulimit -s来查看和设置。
linux进程管理之可执行文件的加载和运行.pdf
10-31
### Linux 进程管理之可执行文件的加载与运行 #### 概述 在 Linux 系统中，可执行文件的加载与运行是一项基础而重要的功能。本篇内容主要聚焦于这一过程，通过分析 `execve` 系统调用及其相关函数，深入探讨 Linux...
linux下查看so或可执行程序的依赖库
09-15
总结起来，掌握如何在Linux下查看.so文件和可执行程序的依赖库，以及查找使用特定.so文件的进程，是系统管理员和开发者的基本技能。这有助于系统优化、故障排查和软件升级的顺利进行。希望本文提供的内容能对你在...
linux arm 运行 x86,ARM Linux可执行文件神秘地在x86_64上运行
weixin_36003504的博客
04-30 2111
我正在使用Docker容器( thewtex/cross-compiler-linux-armv7 )在Fedora 23 x86_64系统上交叉编译一个简单的“Hello World”Linux用户空间C程序。 目标系统是ARMv7embedded式系统(特别是带库存固件的Kobo Aura HD电子阅读器)。程序的源代码( hello_world.c )如下#include int main...
深入理解Linux内核day08--进程线性地址空间
dsf031411的博客
05-05 3013
进程地址空间     内核中的函数以相当直截了当的方式获得动态内存：         1.__get_free_pages()和alloc_pages()从分区页框分配器中获得页框。         2.kmem_cache_alloc()和kmalloc()使用slab分配器为专门或通用对象分配快。         3.vmalloc()和vmalloc_32()获得一块非连续的内存区。
进程管理(七)--进程的加载
奇小葩
05-16 1569
我们常见的一个应用场景是，在shell中输入命令，然后等待命令返回。如果以进程创建和终止的角度来看，shell首先会读取命令，解析命令，创建自建成并执行命令，然后父进程在等待子进程终止，其如下图示 对于用户空间的一个进程，首先我们需要编写对应的.c/.h文件，然后经过编译器编译成二进制的可执行文件，装载到硬盘上开始执行，最终生成用户进程，这里面涉及到很多细节，本章主要针对这些内容进行深入学习，主要包括以下内容 对于程序员如何从文本文件到可执行的程序 操作系统如何完成对于可执行文件加载 1 程序的编译
Linux安全模块（LSM）学习——推荐一个非常好的博客
qq_44109982的博客
12-01 1107
0.网址 博客地址 该博客基于linux 5.10.17，含有三个lsm demo，难度为递进顺序，作者展示了其如何逐步完成一个有实际使用价值的简单的lsm demo。 1.Whitelist demo hook函数 由于是第一个demo，所以只用到了一个hook函数bprm_check_security，该函数在exec()时被调用，返回值为0时允许执行二进制文件，返回值为负时会拒绝此次调用。 原理 不加载未知的二进制文件，未知这里被定义为无扩展属性security.whitelisted，即只允许存在扩
从bprm结构获得程序的参数
yldfree的博客
04-20 2964
&lt;内核3.10.x&gt;#include &lt;linux/highmem.h&gt;#include &lt;linux/mm.h&gt;static void acct_arg_size(struct linux_binprm *bprm, unsigned long pages){        struct mm_struct *mm = current-&gt;mm;     ...
IMA/EVM完整性检测代码分析
最新发布
inquisiter
06-01 2940
在IMA hook机制中，需要定义一系列回调函数，包括measure、appraise、policy、inode_free和post_parse等函数。measure函数用于在文件读取之前计算文件的哈希值；appraise函数用于评估文件完整性；policy函数用于读取并更新IMA策略；inode_free函数用于在删除文件时更新操作系统的IMA状态信息；post_parse函数用于在解析之后更新文件系统缓存和错误日志。int ret;
46-内存的申请与销毁
phantom66的博客
04-26 1031
46-内存的申请与销毁PHP底层对内存的管理， 围绕着小块内存列表（free_buckets）、 大块内存列表（large_free_buckets）和 剩余内存列表（rest_buckets）三个列表来分层进行的。 ZendMM向系统进行的内存申请，并不是有需要时向系统即时申请， 而是由ZendMM的最底层（heap层）先向系统申请一大块的内存，通过对上面三种列表的填充， 建立一个类似于内存池的管
Linux中ELF文件的装载过程_linux基础18/3/1
darkfaker的博客
03-01 704
前情提要 这片博客纯属为自己做个笔记，其中还有很多解释不到位的地方，特别是后面对底层源代码的分析，可能会有解释不恰当甚至不合理的地方。但我会在后面对源码有了更深层次的研究之后对这篇博客里的源码分析进行修改。还是一样，这篇博客还有很多的知识部分来自《程序员的自我修养》 Linux内核中的ELF文件装载过程之详解execve ———部分取材自《程序员的自我修养》 ...
嵌入式Linux+ARM开发：运行可执行文件与NFS配置详解
在开发过程中，讲座详细指导了如何运行可执行文件，例如在嵌入式Linux环境下，首先要搭建NFS（网络文件系统）以共享文件，然后进入可执行文件所在的目录，最后通过输入 "./<可执行文件名称>" 来启动程序。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值