rt-thread的moudle源码分析

时间：2021-03-23 23:37:51

1 前言

大家都知道在windows操作系统中，可以运行一个个程序，这些程序大都是exe可执行文件，它是一个编译好的二进制文件，在windows下，在一个程序中还可以使用dll动态链接库dll文件，它同样也是编译好的二进制文件。相对的在Linux下也有可执行文件可动态链库.so文件，那么在rt-thread中是否也存在一种这样的文件，可以在系统的运行过程中，由用户启动并执行它，答案是有。在rt-thead中这样的可执行文件或是动态链表库文件,这种文件是elf格式的文件。本文将从内核的角度来看rt-thead是如何将这样一个elf格式的文件装载到内存并执行它。

2 模块控制块

在/include/rtdef.h文件中有模块控制块的定义，如下:

struct rt_module
{
    struct rt_object             parent;              //内核对象控制块

    rt_uint8_t                  *module_space;        //模块空间，保存装载elf文件后的内存空间

    void                        *module_entry;          //此模块对应的线程入口
    rt_thread_t                  module_thread;       //此模块对应的线程
    rt_uint32_t                  stack_size;            //此模块对应的线程栈
    rt_uint32_t                  thread_priority;    //此模块对应的线程优先级

#ifdef RT_USING_SLAB
    /* module memory allocator */
    void                        *mem_list;              //此模块对应的内存堆链表
    void                        *page_array;            //内存页
    rt_uint32_t                  page_cnt;              //内存页数量
#endif

    rt_uint32_t                  nsym;                  //此模块包含的符号个数
    struct rt_module_symtab     *symtab;                //此模块包含的符号表
    rt_uint32_t                  nref;                  //此模块被关联的次数

    /* object in this module, module object is the last basic object type */
    struct rt_object_information module_object[RT_Object_Class_Unknown];//此模块包含的内核对象容器
};
typedef struct rt_module *rt_module_t;

一般来说，rt-thread在装一个elf格式文件时，会自动为它创建一个线程来执行它，这个线程就是指上面的模块对应的线程。

下现来看看 rt-thread是如何装一个so文件(elf格式)，并执行它的。

3 装载so文件

在/components/libdl/dlfcn.h头文件中存在dlopen函数声明:

void *dlopen (const char *filename, int flag);

就是这个dlopen函数负责打开so文件并装载进内存(保存到rt_moudule结构体中),那么下面来分析一下这个dlopen函数: 

void* dlopen(const char *filename, int flags){rt_module_t module;char *fullpath;const char*def_path = MODULE_ROOT_DIR;/* check parameters */RT_ASSERT(filename != RT_NULL);        //处理相对路径if (filename[0] != '/') /* it's a absolute path, use it directly */{fullpath = rt_malloc(strlen(def_path) + strlen(filename) + 2);/* join path and file name */rt_snprintf(fullpath, strlen(def_path) + strlen(filename) + 2, "%s/%s", def_path, filename);}/* find in module list */module = rt_module_find(fullpath);//在内核对象容器中尝试查找此模块if(module != RT_NULL) module->nref++;//如果找到，那么将它的被关联次数加1else module = rt_module_open(fullpath);//打开模块rt_free(fullpath);return (void*)module;}
上面代码只是处理了一下路径问题，最终还是调用rt_module_open来处理，从源码中可知，其实形参flags是没有用到的.rt_module_open函数如下: 
rt_module_t rt_module_open(const char *path){    int fd, length;    struct rt_module *module;    struct stat s;    char *buffer, *offset_ptr;    char *name;    RT_DEBUG_NOT_IN_INTERRUPT;    /* check parameters */    RT_ASSERT(path != RT_NULL);   //读取输入的文件信息    if (stat(path, &s) !=0)    {        rt_kprintf("Module: access %s failed\n", path);        return RT_NULL;    }    //以下代码是将输入的文件打开并读入内存缓冲区    buffer = (char *)rt_malloc(s.st_size);    if (buffer == RT_NULL)    {        rt_kprintf("Module: out of memory\n");        return RT_NULL;    }    offset_ptr = buffer;    fd = open(path, O_RDONLY, 0);    if (fd < 0)    {        rt_kprintf("Module: open %s failed\n", path);        rt_free(buffer);        return RT_NULL;    }    do    {        length = read(fd, offset_ptr, 4096);        if (length > 0)        {            offset_ptr += length;        }    }while (length > 0);    /* close fd */    close(fd);    if ((rt_uint32_t)offset_ptr - (rt_uint32_t)buffer != s.st_size)    {        rt_kprintf("Module: read file failed\n");        rt_free(buffer);        return RT_NULL;    }    //获取文件名    name   = _module_name(path);   //将保存到内存中的so文件内容解释并执行    module = rt_module_load(name, (void *)buffer);    rt_free(buffer);    rt_free(name);    return module;}

从以上代码可以，到这里还只是将so文件读入内存，真正解析so文件(elf格式)并执行的是在rt_module_load函数，其定义如下代码: 

rt_module_t rt_module_load(const char *name, void *module_ptr){    rt_module_t module;    RT_DEBUG_NOT_IN_INTERRUPT;    RT_DEBUG_LOG(RT_DEBUG_MODULE, ("rt_module_load: %s ,", name));    /* check ELF header */    if (rt_memcmp(elf_module->e_ident, RTMMAG, SELFMAG) != 0 &&//判断elf格式文件的头部信息的文件标志是否为"\177RTM"或"\177ELF",否则将返回空，也就是说，此函数只能处理这两种文件标识的elf文件        rt_memcmp(elf_module->e_ident, ELFMAG, SELFMAG) != 0)    {        rt_kprintf("Module: magic error\n");        return RT_NULL;    }    /* check ELF class */    if (elf_module->e_ident[EI_CLASS] != ELFCLASS32)//检查此elf格式文件是否为32位机器码    {        rt_kprintf("Module: ELF class error\n");        return RT_NULL;    }    //判断elf文件的类型，这里处理可重定位文件和共享目标文件    if (elf_module->e_type == ET_REL)    {        module = _load_relocated_object(name, module_ptr);//装载可重定位文件    }    else if (elf_module->e_type == ET_DYN)    {        module = _load_shared_object(name, module_ptr);//装载共享目标文件    }    else    {        rt_kprintf("Module: unsupported elf type\n");        return RT_NULL;    }    if (module == RT_NULL)        return RT_NULL;    /* init module object container */    rt_module_init_object_container(module);//在模块内部的内核对象容器    /* increase module reference count */    module->nref ++;//模块的被索引次数加1   //如果模块的入口地址存在    if (elf_module->e_entry != 0)    {        rt_uint32_t *stack_size;        rt_uint8_t  *priority;#ifdef RT_USING_SLAB        /* init module memory allocator */        module->mem_list = RT_NULL;        /* create page array */        module->page_array =             (void *)rt_malloc(PAGE_COUNT_MAX * sizeof(struct rt_page_info));//为模块创建内存页        module->page_cnt = 0;#endif        /* get the main thread stack size */        module->stack_size = 2048;//模块的线程栈设为2K        module->thread_priority = RT_THREAD_PRIORITY_MAX - 2;//模块的线程优先级设为最大优先级-2        /* create module thread *///创建线程，将模块入口地址设置为此线程的入口函数        module->module_thread =            rt_thread_create(name,                             (void(*)(void *))module->module_entry,                             RT_NULL,                             module->stack_size,                             module->thread_priority,                             10);        RT_DEBUG_LOG(RT_DEBUG_MODULE, ("thread entry 0x%x\n",                                       module->module_entry));        /* set module id */        module->module_thread->module_id = (void *)module;//设置模块线程的模块ID为本模块        module->parent.flag = RT_MODULE_FLAG_WITHENTRY;        /* startup module thread */        rt_thread_startup(module->module_thread);//启动模块线程    }    else//如果模块无入口地址    {        /* without entry point */        module->parent.flag |= RT_MODULE_FLAG_WITHOUTENTRY;//设置标志为无入口地址    }#ifdef RT_USING_HOOK    if (rt_module_load_hook != RT_NULL)    {        rt_module_load_hook(module);//使用勾子函数    }#endif    return module;}

elf文件是一种标准的二进制文件格式，它有好几种类型，除了上面代码是提供到可重定位文件(ET_REL)和共享目标文件(ET_DYN)之外,还存在可执行文件(ET_EXEC),当然还存在一些其它的类型,这里就不具体说明.当前rt-thread的最新版本是V1.1.0,从源码可知,当前版本只支持可重定位文件和共享目标文件这两种文件.

上述代码大致流程如下,首先从传入的elf文件内存获取elf头部信息,判断一些信息是否满足条件,之后判断elf文件类型,是否为可重定位文件或共享目标文件,如果是,则分别用不用的代码解析它,并将它装进rt_module_t对应的内存结构体中,然后创建一个线程并启动它.就这样,一个so的执行过程就完了,它是通过为一个模块创建一个线程来执行的.

再次回到模块控制块结构定义中,这里特别说明一个,模块控制块成员module_space保存了elf文件中表示程序的内容,而module_entry指向modul_space中的入口.

有关elf文件格式的具体说明请参考:http://blog.csdn.net/flydream0/article/details/8719036

或参考:http://en.wikipedia.org/wiki/Elf_format

这里就不做具体说明了,另_load_relocated_object函数(处理可重定位文件)和函数_load_shared_object(处理共享目标文件),这两个函数由于与elf文件格式密切相关,不建议在没有深刻理解elf文件格式之前去看这两个函数的实现,这里暂且将理解为分别解析可重定位文件和共享目标文件即可.

因此这里先建议了解elf文件格式再进一步去看这两个函数的实现,后续我将再写博文来讨论,敬请关注!

OK,先这样!


标签：

相关文章