CN115167905A - Uninterrupted running updating method for C + + code and computer system - Google Patents

Abstract

The invention discloses a C++ code running update method and computer system without interruption. In the method, a protocol processing function is added to the C++ program to be updated, and the inter-process communication mechanism is used to realize that when the C++ program is running, a new function in the dynamic library is used to replace the running C++ program by means of a request-response method. to execute the old function of the same name. The solution provided by the present invention can realize hot updating of the C++ program without interrupting the running of the C++ program. When using the solution provided by the present invention to update the C++ service program running on the server, the server does not need to be restarted, and the connection between the server and the client does not need to be interrupted, and the business/service provided by the server will not be affected.

Description

A method and computer system for updating C++ code without interruption of operation

technical field

The invention discloses a C++ code uninterrupted running update method and computer system, and relates to the field of computer running code update. The technical solution provided by the present invention realizes that the C++ executable program can update the function functions and take effect immediately under the premise of not stopping or restarting; it is especially suitable for updating the C++ executable program running on the server and providing services to the outside world.

Background technique

When developing server running programs, C++ language is generally used in pursuit of the best performance. In order to realize the hot update of the developed C++ program at runtime and not stop providing services to the outside world, it is usually developed and deployed with other scripting languages. Although the script can be hot updated, if the functional logic of the running C++ program is modified, the server needs to be restarted when the C++ program is updated. Restarting the server will interrupt the connection of the client, and it also takes a certain amount of time for the server to initialize data/programs during restart. After the restart is complete, the client reconnects to the server and often needs to perform authentication again. If there are many clients connected before the server restarts (for example, there are five or six thousand), these clients will reconnect to the server after the server restarts. In this case, the cost of restarting the server is too high, and the server will provide The service and processing business will have a great impact.

In order to avoid restarting the server when the program code running in the server is updated, some developers increase the proportion of scripts, or even develop programs that run on the server in the form of pure scripts. In this way, with the continuous increase of the amount of code in the later stage, the performance of the server will decrease significantly; especially after two to three years of operation, the number of connected clients does not decrease as the business logic on the server continues to increase. , the performance of the server to provide external business processing will be seriously affected. At this point, because there are too many scripts written in the past, if we use C++ to rewrite, it will bring very high development costs.

In order to solve the above-mentioned problems/deficiencies when the server running program is updated, making the running C++ code also hot update has become a program development guidance direction often adopted by program developers. If the C++ program running on the hot update server is implemented, the server does not need to be restarted, the client does not need to reconnect, and the superior performance of the C++ code can be retained.

Currently, there are two methods for hot updating the running C++ program code:

1. Modify the got table to achieve hot update: this method requires compiling the existing C++ source code into a dynamic library, and then compiling the source code again; implicitly referencing the dynamic library to the second compiled in executable code. This method needs to be compiled twice before updating, and needs to open the memory module information of the process, parse the ELF file header and traverse the section table of the elf file to obtain the corresponding got table.

2. Start another process to directly modify the code segment: In this way, you need to traverse the memory page to find the function to be replaced, and call the ptrace function of the Linux system through another process to attach the new code to the process that needs to be modified. This method needs to save the registers of the process to be modified and restore the register scene; and calling the ptrace function will cause the target process to suspend, and if the suspend time is long, it will affect the logic of the original C++ program execution process.

The above two methods can achieve the purpose of hot updating the C++ code. But there are still some shortcomings: the first one needs to be compiled twice, and the operation of finding the got table and the function address in the got table is more complicated; the second is the operation cost of starting another process is relatively high and the traversal of memory pages is time-consuming, and Calling the ptrace function causes the target process to pause.

SUMMARY OF THE INVENTION

Aiming at the above-mentioned shortcomings of the traditional scheme, the present invention provides a C++ code running update scheme without interruption. The scheme realizes that the new function in the dynamic library is used to replace the corresponding old function in the C++ program to be updated to be executed when the C++ program is running through the preset protocol processing function; On the basis, hot update is performed on the C++ program running on the server.

The object of the present invention is achieved through the following technical solutions:

A C++ code uninterrupted running update method, the method comprises: compiling into a dynamic library a new function for replacing an old function in a running C++ program and a new function with the same name as the old function; adding to the C++ program A protocol processing function that supports hot updating by using the dynamic library; a process is started in the computer running the C++ program, and when the process receives a request for hot updating the C++ program, the protocol processing function is called to implement the In the dynamic library, a new function with the same name as the designated old function is executed instead of the designated old function in the running C++ program. Preferably, the compilation environment used when compiling the dynamic library is the same as the compilation environment for compiling the C++ program.

Wherein, the protocol processing function is implemented as: searching and loading a dynamic library for executing in place of the old function according to a preset path, and finding the address of the old function in the executable file of the C++ program in the memory , then modify the code segment, fill in the machine code at the address to make the processor jump to the new function in the dynamic library with the same name as the old function when executing the machine code, and return after execution Execution continues at the next address in memory of the old function described. The protocol processing function includes two parameters: the name of the old function in the C++ program, and the name of the dynamic library that contains the new function that is executed in place of the old function and has the same name as the old function; The value is specified in the request.

Further, the C++ program is executed in the Linux operating system, and the name of the old function is the symbol name corresponding to the old function in the dynamic symbol table of the C++ program. Wherein, the dynamic symbol table is generated by adding the compilation options -rdynamic and -g when the C++ program is compiled using the g++ compiler in the Linux compilation environment. The memory address A of the symbolic name of the old function in the executable file of the C++ program can be found by calling the dlsym function of the Linux system; the dlsym function is called to obtain the symbolic name in the loaded dynamic library. memory address B.

Further, the modifying the code segment, filling in the machine code at the address, so that the processor jumps to the new function with the same name as the old function in the dynamic library when executing the machine code. To: call the mprotect function provided by the Linux system to set the protection flag of the memory page where the address A is located and a memory page immediately after it as writable. After the relevant memory is writable, the relevant functions of the Linux operating system (such as functions memset and memcpy) are called to sequentially write the machine codes corresponding to the assembly instructions mov rax B and jmp rax into the memory starting from the address A, and then the The protection flags of the two memory pages are modified to read-only; the rax is the register name.

Corresponding to the above method, the present invention also provides a computer system with a C++ code that does not interrupt running and updating, characterized in that the computer system adopts the above-mentioned C++ code that does not interrupt the running and updating method to update the C++ program running on it. Execute the file for function update. Preferably, the computer system provides services to connected clients by running the C++ program.

Description of drawings

FIG. 1 is a schematic flow chart of a method for updating the running of C++ code without interruption provided by the present invention.

Detailed ways

In order to make the technical problems, technical solutions and beneficial effects solved by the present invention clearer, the present invention will be further described in detail below with reference to the accompanying drawings. It should be understood that the specific embodiments described herein are only used to explain the present invention, but not to limit the present invention.

As shown in Figure 1, the present invention provides a C++ code running update method without interruption, and the method comprises the following steps:

a. Compile a new function with the same name as the old function used to replace the old function in the running C++ program into a dynamic library (also called a dynamic link library). When compiling the dynamic library, in order to avoid possible incompatibility caused by differences in the compilation environment, preferably, the compilation environment used when compiling the dynamic library is the same as the C++ program compilation environment.

Dynamic libraries (so files) help to share data and resources, and multiple applications can simultaneously access the contents of a single copy of the so file in memory. In a traditional non-shared library, a portion of the code is simply attached to the calling program. If two programs call the same subroutine, there will be two copies of that code. On the contrary, the code shared by many applications can be divided into a so file, stored as a file on the hard disk, and an instance of the dynamic library is used in memory, which can greatly save the disk and disk required by the application program. memory space. The function code that the program needs to call/need to be modified is compiled into a dynamic library (also called a dynamic link library), so that the execution process of the program can call functions that do not belong to its executable code.

b. Add a protocol processing function to the C++ program to support hot update by using the dynamic library. The protocol processing function is added when the C++ program is developed, and is used to implement the execution of using the new function in the dynamic library to replace the old function with the same name in the C++ program when the C++ program is running.

The protocol processing function is implemented as: searching and loading (for example, calling the dlopen function of the Linux system to load a dynamic library) according to a preset path, a dynamic library for replacing the execution of the old function. Find the address of the old function in the executable file of the C++ program in the memory, then modify the code segment, and fill in the machine code at the address to make the processor jump to the address when the machine code is executed. It executes the new function in the dynamic library with the same name as the old function, and returns to the next address of the old function in the memory to continue execution after the execution.

Preferably, setting the protocol processing function includes at least the following two parameters: the name of the old function in the C++ program, and the name of a dynamic library that contains a new function with the same name as the old function executed instead of the old function. The C++ program is a server-side program executed in the Linux operating system. The name of the old function is the symbol name corresponding to the old function in the dynamic symbol table of the C++ program; wherein, the dynamic symbol table is the addition to the g++ compiler when the C++ program is compiled in the Linux compilation environment Compiled with -rdynamic and -g. The parameter -g is used to tell the compiler that g++ needs to generate debugging information for debugger debugging when generating executable files, including extended dynamic symbol table, line number, local or external variable information, etc. The parameter -rdynamic is used to tell the linker to add all symbols to the dynamic symbol table.

In Linux, you can find the corresponding symbol name by searching the function name of a function in the source code through the nm command and the grep command in the dynamic symbol table. When the search result has multiple symbol names, you can use the c++filt command to pass in the multiple symbol names obtained by the above search to obtain the complete definition of the function in the source code corresponding to the symbol. The name of the symbol is what we need (if the C++filt command gets the result, if there is a formal parameter with only the type of the formal parameter, and there is no name of the formal parameter, the result can be determined only by the type of the formal parameter).

After finding the symbol name corresponding to the old function, find the memory address A of the symbol name of the old function in the executable file of the C++ program by calling the dlsym function of the Linux system, and call the dlsym function to obtain the memory address A of the symbol name of the old function in the executable file of the C++ program. In the loaded dynamic library, the memory address B of the symbol name; that is, the dlsym function needs to be called twice. Specifically, when calling the dlsym function for the first time, the first parameter is set to NULL, and the second parameter is set to the symbol name of the old function obtained from the dynamic symbol table, and the symbol name is obtained in the The memory address A in the execution process code segment of the C++ program. The second call to the dlysm function sets its first parameter to the handle obtained by loading the dynamic library, and the second parameter to the symbol name of the old function obtained from the dynamic symbol table (due to the new function It has the same name as the old function to be replaced), and obtains the memory address B of the symbol name in the loaded dynamic library. If the obtained address A or address B is equal to 0, the protocol processing function body returns a failure and does not continue to execute.

The modifying the code segment, filling in the machine code at the address, and causing the processor to jump to a new function with the same name as the old function in the dynamic library to execute when the machine code is executed, specifically: The mprotect function provided by the Linux system is called to change the protection mark of the memory page where the address A is located and a memory page immediately following it from read-only to write-able. After the relevant memory is writable, the relevant functions of the Linux operating system (such as functions memset and memcpy) are called to sequentially write the machine codes corresponding to the assembly instructions mov rax B and jmp rax into the memory starting from the address A, and then the The protection marks of the two memory pages are re-modified to read-only; wherein, the rax is a register name.

c. Initiate a process of processing the received hot update request of the C++ program in the computer running the C++ program. The parameter values that need to be specified in the hot update request include at least the following two: the name of the old function in the C++ program, and the name of the dynamic library that includes a new function that is executed in place of the old function and has the same name as the old function . The values of the above two parameters are used as input parameters of the protocol processing function when the process calls the protocol processing function.

d. The process receives the request, and calls the protocol processing function to implement a new function in the dynamic library with the same name as the specified old function to replace the specified old function in the C++ program for execution.

Corresponding to the above method, the present invention also provides a computer system whose C++ code is not interrupted to run and update. renew. Preferably, the computer system provides services to connected clients by running the C++ program.

Compared with the prior art, the technical solution provided by the present invention adopts the new function in the dynamic library to replace the corresponding old function in the C++ program to be updated to be executed when the C++ program is running, which can be executed without restarting the server and without interrupting the communication between the server and the client. On the basis of the connection, the C++ program running on the server is hot updated.

Claims (9)

1. A method for updating C + + code without interruption of running, the method comprising: compiling new functions which are used for replacing old functions in the running C + + program and are the same as the old functions into a dynamic library; adding a protocol processing function supporting the C + + program to adopt the dynamic library for hot updating; and starting a process in a computer running the C + + program, and calling the protocol processing function to realize that the appointed old function in the running C + + program is replaced by a new function which is in the same name as the appointed old function in the dynamic library for execution when the process receives a request for updating the C + + program.

2. The method of claim 1, wherein a compilation environment employed in compiling the dynamic library is the same as a compilation environment in which the C + + program is compiled.

3. The method according to claim 1 or 2, wherein the protocol handling function comprises two parameters: the name of an old function in the C + + program and the name of a dynamic library containing a new function which is used for replacing the old function and has the same name as the old function; and the values of the two parameters are specified in the C + + program function updating request.

4. The method of claim 3, wherein the protocol processing function is embodied as: loading a dynamic library for execution in place of the old function; finding the address of the old function in the executable file of the C + + program in the memory, then modifying the code segment, filling the machine code in the address to enable the processor to jump to a new function with the same name as the old function in the dynamic library for execution when executing the machine code, and returning to the next address of the old function in the memory for continuous execution after the execution is finished.

5. The method according to claim 4, wherein the C + + program is executed in a linux operating system, and a name of an old function in the C + + program is a symbolic name of the old function in a dynamic symbol table; the dynamic symbol table is generated by adding compiling options-rdynamic and-g when the C + + program is compiled by adopting a g + + compiler process in a compiling environment of Linux.

6. The method of claim 5, wherein finding the address of the old function in the executable file of the C + + program in the memory comprises: calling a dlsym function of a Linux system to find a memory address A of the symbolic name of the old function in the executable file of the C + + program; and calling the dlsym function to obtain the memory address B of the symbol name in the loaded dynamic library.

7. The method of claim 5, wherein modifying the code segment, filling the machine code at the address, and causing the processor, when executing the machine code, to jump to a new function in the dynamic library that is the same name as the old function to execute are: calling an mprotect function provided by a Linux system to set the protection mark of the memory page where the address A is located and the next adjacent memory page as writable; sequentially writing machine codes corresponding to an assembly instruction mov rax B and jmp rax into the memory starting from the address A, and modifying the protection marks of the two memory pages into read-only; wherein, the rax is a register name.

8. A computer system for updating C + + code without interruption, wherein the computer system performs function update on an executable file of the C + + program running on the computer system by using the C + + code updating method without interruption according to any one of claims 1 to 7.

9. The computer system of claim 8, wherein the computer system services clients connected thereto by running the C + + program.

Images