CN115495158B - Dynamic construction method for system service in microkernel operating system - Google Patents

Abstract

The invention discloses a dynamic construction method of system service in microkernel operating system, which comprises compiling required system service module, device driver and application program into ELF executable file or ELF dynamic link library, deploying system service loader in user mode, compiling system service loader into mirror image file and integrating with kernel mirror image; the system service loader starts after the kernel starts, reads an ELF executable file of a module to be loaded according to a typed instruction and loads the ELF executable file, and the module operates in an address space isolated from other modules as an independent task after loading is completed, and dynamically links a shared library required by the module to the address space of the module; the system service loader may also complete the uninstallation and updating of executable program modules, shared libraries. The invention can dynamically load the ELF executable file and the dynamic link shared library of the module under the condition of not restarting the microkernel operating system, thereby realizing the dynamic construction of the system service.

Description

Dynamic Construction Method of System Service in Microkernel Operating System

technical field

The invention belongs to the technical field of microkernel operating systems, and more specifically relates to a method for dynamically constructing system services in a microkernel operating system.

Background technique

As the Internet of Things and industrial control scenarios put forward higher requirements for the security and reliability of embedded systems, the operating system of the microkernel architecture has received great attention. Although the microkernel operating system has a small kernel, it can implement rich system service modules in user mode to meet the complex requirements for operating system functions. Such a modular design ensures the security and fault isolation of the operating system.

In the microkernel operating system, the kernel only retains simplified functions, and most of the services in the operating system are decoupled and run as independent user-mode applications in user-mode address spaces isolated from each other. Therefore, microkernel-based operations The system needs to consider what method to use to build system services. In the current microkernel operating system construction process, system services are often integrated with the kernel, that is to say, only some service modules are statically selected and compiled into the operating system according to requirements. The biggest disadvantage of this method is that if a module needs to be upgraded or replaced , then the system needs to be recompiled, released and started, which cannot satisfy the rapid construction of the system and the dynamic expansion of resources. However, in the current Internet of Things and industrial control environment, it is often required that the operating system can support the dynamic increase or decrease of system services to adapt to the dynamic changes of hardware resources or adapt to the diverse node environments in the distributed processing environment. The existing technical solutions cannot meet this need.

There is a lack of research on the dynamic construction of operating systems in the prior art. In the document "Design and Research on the Mechanism of Directly Loading ELF Files in Microkernel Systems", the ELF (Executable and ELF (Executable and Linkable Format, executable connection format) files, but only the loading method of statically linked executable files is studied. In the static construction method, the system service modules need to be compiled into target files, and then the linker will link these system service modules and the kernel into an operating system image, and then start the execution. The biggest disadvantage of this method is that if a system module needs to be upgraded or replaced, then the operating system needs to be recompiled, released and started. And in the static construction method, the system services are all statically linked executable files, and the mapping and loading process is relatively simple, but the code and data of the public shared library need to have a copy in each system service module, and there are extremely Big waste of system resources.

Contents of the invention

The purpose of the present invention is to overcome the deficiencies of the prior art and provide a method for dynamically constructing system services in a microkernel operating system. By deploying a system service loader, it can be packaged and released with the kernel without restarting the microkernel operating system. The ELF executable file of the dynamic loading module and the dynamic link shared library are used to realize the dynamic construction of the system service of the microkernel operating system.

In order to realize the object of the above invention, the system service dynamic construction method in the microkernel operating system of the present invention comprises the following steps:

S1: For the required system service modules and device drivers, if the conditions for compiling into an ELF dynamic link library are met, compile it into an ELF dynamic link library, and use it as a shared library for the ELF executable file to call, otherwise compile it into an ELF executable file ; Compile the desired application into an ELF executable;

S2: Deploy the system service loader in the user mode of the microkernel operating system, which is used to load the ELF executable file and link the ELF dynamic link library, compile the system service loader into an image file and integrate it with the kernel image;

S3: During the startup process of the microkernel operating system, the system service loader is started after the kernel is started; for system service modules, device drivers and applications compiled into ELF executable files, when any module needs to be loaded, the system service loader The loader reads the corresponding ELF executable file and loads it. After the loading is completed, the module runs as an independent task in an address space isolated from other modules; when the module is loaded, it needs to be linked to an ELF dynamic link library. When the system service module or device is driven, the system service loader dynamically links the ELF dynamic link library into the address space of the module, and then starts to execute the module, and the linked ELF dynamic link can be called during the execution of the module Library;

S4: When it is necessary to unload any module in the system service module, device driver or application that is loaded in the form of an ELF executable file, the system service loader unloads the corresponding ELF executable file, reclaims the cache and cancels the completion of the loading process the mapping;

When any one of the system service modules and device drivers linked in the form of ELF dynamic link library is no longer used, the system service loader disconnects its dynamic link with each dependent module and reclaims its system resources;

S5: When any module in the system service module, device driver, or application program loaded in the form of an ELF executable file needs to be updated, first unload it, then reload the updated ELF executable file, and re-install the required Shared library for dynamic linking;

When any module in the system service module or device driver that is linked in the form of an ELF dynamic link library needs to be updated, first disable the execution of related modules that depend on it, and then the system service loader will update the ELF dynamic link library Dynamically link to these dependent modules.

The system service dynamic construction method in the microkernel operating system of the present invention compiles the required system service modules, device drivers and application programs into mutually independent ELF executable files or ELF dynamic link libraries, and the user state in the microkernel operating system Deploy the system service loader, compile the system service loader into an image file and integrate it with the kernel image; the system service loader starts after the kernel starts, and then reads the ELF executable file that needs to be loaded according to the typed instruction and executes Loading, after loading, the module runs as an independent task in an address space isolated from other modules, and dynamically links the shared library required by the module to the address space of the module; the system service loader can also complete the executable program module , Uninstall and update of shared libraries.

The present invention has the following beneficial effects:

1) The present invention compiles system service modules, device drivers and application programs into ELF executable files, supports dynamic loading or unloading of system services when the operating system is running, and each module runs as an independent task at an isolated address after loading Space, which can be maintained independently, can effectively solve the problem of lack of flexibility in static service construction, and improve the flexibility of microkernel operating system system service construction;

2) The present invention builds shareable system service modules and device drivers into an ELF dynamic link library, and multiple modules that need to use the shared library adopt a dynamic link method to link with the ELF dynamic link library, which solves the problem of shared libraries in static service construction The resource waste problem can greatly save memory space resources.

Description of drawings

Fig. 1 is the flow chart of the specific embodiment of the system service dynamic construction method in the microkernel operating system of the present invention;

Fig. 2 is a framework diagram of dynamic construction of system services of the present invention;

Fig. 3 is the flow chart of the linking of system service loader to the loading of ELF executable file and the link of dynamic link library in the present embodiment;

Fig. 4 is the flowchart of loading main module in the present embodiment;

Fig. 5 is a flow chart of dynamically linking the ELF dynamic link library in this embodiment.

Detailed ways

Specific embodiments of the present invention will be described below in conjunction with the accompanying drawings, so that those skilled in the art can better understand the present invention. It should be noted that in the following description, when detailed descriptions of known functions and designs may dilute the main content of the present invention, these descriptions will be omitted here.

Example

FIG. 1 is a flowchart of a specific embodiment of a method for dynamically constructing system services in a microkernel operating system according to the present invention. As shown in Figure 1, the specific steps of the system service dynamic construction method in the microkernel operating system of the present invention include:

S101: Construct the ELF file:

For the required system service modules and device drivers, if the conditions for compiling into an ELF dynamic link library are met, they will be compiled into an ELF dynamic link library and used as a shared library for the ELF executable file to call, otherwise they will be compiled into an ELF executable file. Compile the desired application into an ELF executable.

System service modules usually include network protocol stack, UI framework, log system, etc. Device drivers usually include network card drivers, serial port drivers, etc. Currently, system service modules and device drivers are mostly compiled into ELF executable files. A system service module that can be compiled into a shared library usually includes a C library, a C++ library, and a cryptographic library. In the compilation process, in order to facilitate the shared library to be used by different modules at the same time, address-independent code (PIC) is used to compile the ELF dynamic link library, and the ELF executable file can be compiled by a conventional compilation method.

S102: Deploy the system service loader:

The user state deployment system service loader in the microkernel operating system is used to load the ELF executable file and link the ELF dynamic link library, compile the system service loader into an image file and integrate it with the kernel image.

Generally speaking, in the user mode in the microkernel operating system, a small number of necessary basic services will be deployed, including file system, memory management, Shell, error handling, etc., and the system service loader in the present invention also needs to rely on these basic services. Similarly, these basic services are also compiled into image files and integrated with the kernel image so that they can be loaded directly after the kernel starts.

S103: Load the ELF executable file and link the ELF dynamic link library:

During the startup process of the microkernel operating system, the system service loader is started after the kernel is started. For system service modules, device drivers, and applications compiled into ELF executable files, when any module needs to be loaded, the system service loader reads the corresponding ELF executable file and loads it. Tasks run in address spaces isolated from other modules. When a certain system service module or device driver compiled into an ELF dynamic link library needs to be linked during the loading process of the module, the system service loader dynamically links the ELF dynamic link library into the address space of the module. After that, the module can be started to be executed, and the linked ELF dynamic link library can be called during the execution of the module.

Generally speaking, if the execution of an application needs to depend on a certain system service module or device driver, the system service module or device driver needs to be loaded first when loading.

S104: Uninstall the ELF executable file or the ELF dynamic link library:

When it is necessary to unload any module in the system service module, device driver or application that is loaded in the form of an ELF executable file, the system service loader unloads the corresponding ELF executable file, reclaims the cache and cancels the mapping completed during the loading process .

When any one of the system service modules and device drivers linked in the form of ELF dynamic link library is no longer used, the system service loader breaks its dynamic link with each dependent module and reclaims its system resources.

S105: Updating the ELF executable file or the ELF dynamic link library:

When any of the system service modules, device drivers, or application modules loaded in the form of ELF executable files needs to be updated, first unload them, then reload the updated ELF executable files, and re-install the required shared libraries Do dynamic linking.

When any module in the system service module or device driver that is linked in the form of an ELF dynamic link library needs to be updated, first disable the execution of related modules that depend on it, and then the system service loader will update the ELF dynamic link library Dynamically link to these dependent modules.

Fig. 2 is a framework diagram of dynamic construction of system services in the present invention. As shown in Figure 2, the system service loader loads system service modules, device drivers, and application programs, and dynamically connects the required shared library to the address space of the corresponding module while loading. Under the framework of dynamic construction of system services, the microkernel operating system supports dynamic loading or unloading of system services while running, which realizes hot swapping of operating system functions and enhances the flexibility and scalability of the system. In addition, the system service module is compiled into a shared library and then dynamically linked to reduce the number of copies of the public service code in the system to reduce the waste of storage space resources, and this method also supports updating the system service shared library at runtime, which greatly increases Ease of use of the system.

In order to make the system service loader load and link the ELF executable file and the ELF dynamic link library more quickly, a preferred implementation method is proposed in this embodiment. FIG. 3 is a flow chart of the system service loader loading the ELF executable file and linking the ELF dynamic link library in this embodiment. As shown in Figure 3, the specific steps that the system service loader loads the ELF executable file and links the ELF dynamic link library in the present embodiment include:

S301: create elf_task task:

In the microkernel operating system, the user requests the system service loader to load the system service, device driver or application program in the ELF executable file format by entering a command in the Shell or through a system call. After the system service loader receives the user request, Create an elf_task (loading and executing ELF program) task for each loading process in the microkernel. This task is used to execute the code of the system service loader to load the ELF executable file and link the ELF dynamic link library. After the loading is completed System services, device drivers, and applications will all run in address spaces that are isolated from each other for their corresponding tasks.

S302: Load the main module:

The elf_task task starts the system service loader and loads the main module. The main module refers to the module where the ELF executable file is located. Fig. 4 is a flow chart of loading the main module in this embodiment. As shown in Figure 4, the specific steps of loading the main module in this embodiment include:

S401: Verify the validity of the ELF header:

Read the ELF executable file, check the legality of the ELF header, if it is legal, go to step S402, otherwise give an error prompt.

S402: Parse the file:

Parse the ELF executable file to determine whether there is a PT_INTERP segment. In the ELF executable file, the PT_INTERP segment is used to give the position and length of a string, which is called as an interpreter. This segment is only meaningful for executable files. The executable file that needs to be dynamically linked contains this part. Therefore, if the PT_INTERP section exists, the ELF dynamic link library needs to be linked, and if it does not exist, the ELF dynamic link library does not need to be linked. Then record the parsed PT_LOAD (loadable) segment and PT_DYNAMIC (dynamic link information) segment.

S403: PT_LOAD loading:

Map the PT_LOAD segment and load it into memory. In this embodiment, an interface SYS_MMAP adapted to the system service loader is configured in the kernel to allocate memory space for the ELF executable file and the ELF dynamic link library, map the memory, and load it into the physical memory.

S404: Obtain dependent libraries:

Traverse the PT_DYNAMIC section, find and record the dependent ELF dynamic link library, and get the list of dependent libraries.

S405: Find the dynamic link table:

Find and record tables for dynamic linking, including dynamic symbol tables, dynamic string tables, and hash (hash) tables.

S406: Analyzing the start and end segments:

Parse and record the init segment and the finit segment, which are used to initialize and finish during the execution of the module corresponding to the ELF executable file.

S303: Determine whether step S302 detects that the ELF dynamic link library needs to be linked during the process of loading the main module, if yes, go to step S304, otherwise, the loading ends.

S304: Link the ELF dynamic link library:

Traverse the list of dependent libraries in the ELF executable file, and link each ELF dynamic link library in turn. Fig. 5 is a flow chart of linking the ELF dynamic link library in this embodiment. As shown in Figure 5, the specific steps of linking the ELF dynamic link library in the present embodiment include:

S501: Mapping the ELF dynamic link library:

Take out the ELF dynamic link library sequentially from the dependent library list, if the ELF dynamic link library has not been loaded, then add the ELF dynamic link library to the loading set, otherwise do nothing.

S502: Redirection:

Traverse the section header table, find the redirection section SHT_REL (relocation table section) and SHT_RELA (redirection table section), and redirect the external symbols (including variables and functions) in the redirection section according to the type That is, the relative address of the external symbol in the ELF dynamic link library is converted into a definite address in the address space according to the address space of the dynamically linked ELF executable file.

S503: Load the ELF dynamic link library into memory:

The code segments and data segments of each ELF dynamic link library are sequentially taken out from the loading set, and loaded into the memory.

Although the illustrative specific embodiments of the present invention have been described above, so that those skilled in the art can understand the present invention, it should be clear that the present invention is not limited to the scope of the specific embodiments. For those of ordinary skill in the art, As long as various changes are within the spirit and scope of the present invention defined and determined by the appended claims, these changes are obvious, and all inventions and creations using the concept of the present invention are included in the protection list.

Claims (3)

1. The dynamic construction method of the system service in the microkernel operating system is characterized by comprising the following steps:

s1: for the required system service module and equipment driver, if the condition of compiling into an ELF dynamic link library is met, compiling into the ELF dynamic link library, and calling an ELF executable file as a shared library, otherwise compiling into the ELF executable file; compiling the required application program into an ELF executable file;

s2: a user mode deployment system service loader in the microkernel operating system is used for loading ELF executable files and linking ELF dynamic link libraries, compiling the system service loader into image files and integrating the image files with the kernel images;

s3: in the starting process of the microkernel operating system, a system service loader is started after the kernel is started; for a system service module, a device driver and an application program compiled into ELF executable files, when any one of the modules needs to be loaded, a system service loader reads the corresponding ELF executable file and loads the ELF executable file, and the module operates in an address space isolated from other modules as an independent task after loading is completed; when a certain system service module or equipment driver compiled into an ELF dynamic link library needs to be linked in the module loading process, the system service loader dynamically links the ELF dynamic link library into the address space of the module, and then the module can be started to be executed, and the linked ELF dynamic link library can be called in the module executing process; the loading of the ELF executable file and the linking of the dynamic link library by the system service loader are carried out by adopting the following method:

s3.1: in the microkernel operating system, a user requests a system service loader to load system services, device drivers or application programs in an ELF executable file format through inputting commands in Shell or through system call, after the system service loader receives a user request, an elf_task task is created for each loading process in microkernel, the task is used for executing codes of the system service loader to load the ELF executable files and link an ELF dynamic link library, and after loading is completed, the system services, the device drivers and the application programs are all operated in address spaces where corresponding tasks and other tasks are isolated from each other;

s3.2: the elf_task task starts a system service loader and loads a main module, wherein the main module refers to a module where an ELF executable file is located;

s3.3: judging whether the step S3.2 detects that the ELF dynamic link library needs to be linked in the process of loading the main module, if so, entering the step S3.4, otherwise, ending the loading;

s3.4: traversing a dependency library list in the ELF executable file, and sequentially linking all ELF dynamic link libraries;

s4: when any one of a system service module, a device driver or an application program loaded in an ELF executable file form is required to be unloaded, the system service loader unloads the corresponding ELF executable file, and the mapping completed in the loading process is recovered and canceled;

when any one of the system service module and the device driver which are linked in the form of an ELF dynamic link library is not used any more, the system service loader disconnects the dynamic link with each relevant module depending on the system service loader and recovers the system resources of the system service module;

s5: when any one of a system service module, a device driver or an application program which is loaded in an ELF executable file form needs to be updated, unloading is firstly carried out, then the updated ELF executable file is reloaded, and dynamic link is carried out on the needed shared library again;

when any one of the system service module or the device driver linked in the form of an ELF dynamic link library needs to be updated, execution of the relevant module dependent thereon is disabled, and then the system service loader dynamically links the updated ELF dynamic link library to the relevant module.

2. The method for dynamically constructing the system service in the microkernel operating system according to claim 1, wherein the specific method for loading the main module in step S3.2 is as follows:

s3.2.1: reading an ELF executable file, checking the validity of an ELF header, if the ELF header is legal, entering a step S3.2.2, otherwise, performing error prompt;

s3.2.2: analyzing the ELF executable file, judging whether a PT_INTEP segment exists, if so, linking the ELF dynamic link library, and if not, linking the ELF dynamic link library; then recording the analyzed PT_LOAD section and PT_DYNAMIC section;

s3.2.3: mapping the PT_LOAD segment, and then loading the PT_LOAD segment into a memory;

s3.2.4: traversing the PT_DYNAMIC segment, and searching and recording the dependent ELF DYNAMIC link library to obtain a dependency library list;

s3.2.5: searching and recording a table for dynamic link, wherein the table comprises a dynamic symbol table, a dynamic character string table and a hash table;

s3.2.6: and analyzing and recording init segments and finish segments, wherein the init segments and the finish segments are used for initializing and ending in the execution process of the module corresponding to the ELF executable file.

3. The method for dynamically constructing the system service in the microkernel operating system according to claim 1, wherein the specific method for linking the dynamic link library in step S3.4 is as follows:

s3.4.1: sequentially taking the ELF dynamic link library from the dependency library list, adding the ELF dynamic link library into a loading set if the ELF dynamic link library is not loaded, otherwise, performing no operation;

s3.4.2: traversing the header table of the section area, searching the redirection section areas SHT_REL and SHT_RELA, and redirecting the external symbols in the redirection section area according to the type, namely converting the relative addresses of the external symbols in an ELF dynamic link library into determined addresses in an ELF executable file according to the address space of the dynamic link;

s3.4.3: and sequentially taking out the code segments and the data segments of each ELF dynamic link library from the loading set, and loading the code segments and the data segments into the memory.