CN111666096B - Hot updating method and device for target application, storage medium and electronic equipment - Google Patents
Hot updating method and device for target application, storage medium and electronic equipment Download PDFInfo
- Publication number
- CN111666096B CN111666096B CN202010628955.7A CN202010628955A CN111666096B CN 111666096 B CN111666096 B CN 111666096B CN 202010628955 A CN202010628955 A CN 202010628955A CN 111666096 B CN111666096 B CN 111666096B
- Authority
- CN
- China
- Prior art keywords
- target
- address
- function
- code segment
- link script
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Active
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/60—Software deployment
- G06F8/65—Updates
- G06F8/656—Updates while running
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/40—Transformation of program code
- G06F8/41—Compilation
Abstract
The invention discloses a hot updating method and a device of target application, a storage medium and electronic equipment, comprising the following steps: under the condition that a first function in a currently running target application has a problem, generating a target link script by using a link script generator according to an original binary file of the target application, and compiling a patch code of the first function to obtain a target file; linking the target file according to the target link script to obtain a target binary file; extracting a target code segment from the target binary file, and generating a target patch package from the target code segment; loading a target patch package to a target reserved address in a target process address space; and when the instruction at the inlet of the first function is modified into a target jump instruction and the first function is executed in the process of running the target application, jumping to a target reserved address through the target jump instruction and executing a target code segment in the target patch package.
Description
Technical Field
The invention relates to the field of computers, in particular to a hot update method and device of a target application, a storage medium and an electronic device.
Background
The existing network problem is inevitable, and each online item more or less suffers from some problems. The method has the advantages that the service damage can be caused when the bug is restarted and repaired, and the hot update is a technology for dynamically repairing the code bug in the memory when the program runs, so that the service interruption caused by the process restart can be avoided, and the service availability can be ensured.
The java supports hot updating from the language level, and the java process runtime can reload the class from the compiled class file and replace the class in the memory. And C + + does not support hot update at the language level, and a scheme based on shared memory is adopted for common hot update at the C + + game server side. However, this technique is very invasive, which brings about many inconveniences to the business development, for example, the pointer needs to be encapsulated, and the Standard Template Library (STL) needs to be used for modification. There is also a hot update scheme based on dynamic libraries at the operating system level, but if static variables are used in a project, if a dynamic library scheme is used for hot update, there is a problem that repair cost is high.
Aiming at the problem that in the related art, when the existing network problem is subjected to hot updating, because a static variable is used in a project, a hot updating scheme based on a dynamic library has the problem of high repairing cost, and an effective solution is not provided yet.
Disclosure of Invention
The embodiment of the invention provides a hot updating method and device of a target application, a storage medium and electronic equipment, which are used for at least solving the technical problem that a hot updating scheme based on a dynamic library is not suitable for hot updating of a static variable due to the fact that the static variable is used in a project when the existing network problem is subjected to hot updating in the related art.
According to an aspect of an embodiment of the present invention, there is provided a hot update method for a target application, including: under the condition that a first function in a currently running target application has a problem, generating a target link script according to an original binary file of the target application by using a link script generator, and compiling a patch code of the first function to obtain a target file, wherein the patch code of the first function is used for repairing the problem of the first function; linking the target file according to the target link script to obtain a target binary file; extracting a target code segment from the target binary file, and generating a target patch package from the target code segment; loading the target patch package to a target reserved address in a target process address space, wherein the target process address space is used for storing a code segment and a data segment in the currently running target application; and when the instruction at the inlet of the first function is modified into a target jump instruction and the first function is executed in the process of running the target application, jumping to the target reserved address through the target jump instruction, and executing the target code segment in the target patch package, wherein the target jump instruction is used for jumping to the target reserved address and executing the target code segment.
According to another aspect of the embodiments of the present invention, there is also provided a hot update apparatus for a target application, including: the system comprises a first processing unit, a link script generator and a second processing unit, wherein the first processing unit is used for generating a target link script according to an original binary file of a target application by using the link script generator under the condition that a first function in the currently running target application has a problem, and compiling a patch code of the first function to obtain a target file, and the patch code of the first function is used for repairing the problem of the first function; the link unit is used for linking the target file according to the target link script to obtain a target binary file; the second processing unit is used for extracting a target code segment from the target binary file and generating a target patch package from the target code segment; a loading unit, configured to load the target patch package into a target reserved address in a target process address space, where the target process address space is used to store a code segment and a data segment in the currently running target application; and a third processing unit, configured to jump to the target reserved address through the target jump instruction and execute the target code segment in the target patch package when an instruction at an entry of the first function is modified into a target jump instruction and the first function is executed in a process of running the target application, where the target jump instruction is configured to jump to the target reserved address and execute the target code segment.
According to a further aspect of an embodiment of the invention, there is provided a computer program product or a computer program comprising computer instructions stored in a computer readable storage medium. The processor of the computer device reads the computer instructions from the computer-readable storage medium, and the processor executes the computer instructions to cause the computer device to perform the method provided in the various alternative implementations of the thermal update method of the target application.
According to another aspect of the embodiments of the present invention, there is also provided an electronic device, including a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor executes the hot update method of the target application through the computer program.
In the embodiment of the invention, in the running process of the currently running target application, when a first function in the target application has a problem, a link script generator is used for generating a target link script according to an original binary file of the target application by using the link script generator, patch codes of the first function are compiled to obtain a target file, and the patch codes of the first function are used for repairing the problem of the first function; then, linking the target file according to the target link script to obtain a target binary file; then, extracting a target code segment from the target binary file, and generating a target patch package from the target code segment; loading the target patch package to a target reserved address in a target process address space, wherein the target process address space is used for storing the code segment and the data segment in the currently running target application; and under the condition that the instruction at the inlet of the first function is modified into a target jump instruction and the first function is executed in the process of running the target application, the target application is jumped to the target reserved address through the target jump instruction, and the target code segment in the target patch package is executed. By the mode, in the running process of the target application, when the first function with problems in the target application is run, the target application can jump to the target reserved address through the target jump instruction, the target code section in the target patch package corresponding to the first function is executed, and the normal running of the target application is ensured.
Drawings
The accompanying drawings, which are included to provide a further understanding of the invention and are incorporated in and constitute a part of this application, illustrate embodiment(s) of the invention and together with the description serve to explain the invention without limiting the invention. In the drawings:
FIG. 1 is a schematic diagram of an application environment for a hot update method for a target application according to an embodiment of the present invention;
FIG. 2 is a flow chart illustrating an alternative hot-update method for a target application according to an embodiment of the present invention;
FIG. 3 is a schematic view of an alternative thermal refresh framework according to an embodiment of the present invention;
FIG. 4 is a schematic diagram of an alternative generation of a target link script, according to an embodiment of the present invention;
FIG. 5 is a schematic diagram of an alternative destination reservation address according to an embodiment of the present invention;
FIG. 6 is a flowchart illustrating an alternative hot-update method for a target application according to an embodiment of the present invention;
FIG. 7 is a schematic structural diagram of an alternative thermal update apparatus for a target application according to an embodiment of the present invention;
FIG. 8 is a schematic diagram of a thermal update apparatus for another alternative target application according to an embodiment of the present invention;
fig. 9 is a schematic structural diagram of an alternative electronic device according to an embodiment of the invention.
Detailed Description
In order to make the technical solutions of the present invention better understood, the technical solutions in the embodiments of the present invention will be clearly and completely described below with reference to the drawings in the embodiments of the present invention, and it is obvious that the described embodiments are only a part of the embodiments of the present invention, and not all of the embodiments. All other embodiments, which can be derived by a person skilled in the art from the embodiments given herein without making any creative effort, shall fall within the protection scope of the present invention.
It should be noted that the terms "first," "second," and the like in the description and claims of the present invention and in the drawings described above are used for distinguishing between similar elements and not necessarily for describing a particular sequential or chronological order. It is to be understood that the data so used is interchangeable under appropriate circumstances such that the embodiments of the invention described herein are capable of operation in sequences other than those illustrated or described herein. Furthermore, the terms "comprises," "comprising," and "having," and any variations thereof, are intended to cover a non-exclusive inclusion, such that a process, method, system, article, or apparatus that comprises a list of steps or elements is not necessarily limited to those steps or elements expressly listed, but may include other steps or elements not expressly listed or inherent to such process, method, article, or apparatus.
Technical terms involved in the embodiments of the present invention include:
c + +: a widely used general-purpose programming language.
Linux: a Unix-like operating system for free and open source code.
ELF: is an abbreviation of Executable and Linking Format, an Executable and linkable Format, and is part of the Unix/Linux System ABI (application Binary interface) specification. Executable binary files, object code files, shared library files and core dump files under Linux all belong to ELF files.
Mmap: a method for mapping files in a memory.
According to an aspect of the embodiment of the invention, a hot update method of a target application is provided. Alternatively, the above hot update method of the target application may be applied, but not limited to, in the application environment as shown in fig. 1. As shown in fig. 1, when a problem occurs in a first function in a currently running target application on a terminal device 102, the problem occurring in the first function is sent to a server 104 through a network, and after the server 104 receives the problem occurring in the first function, a target link script is generated by using a link script generator according to an original binary file of the target application, and a patch code of the first function is compiled to obtain a target file, where the patch code of the first function is used to repair the problem occurring in the first function; linking the target file according to the target link script to obtain a target binary file; extracting a target code segment from the target binary file, and generating a target patch package from the target code segment; loading the target patch package to a target reserved address in a target process address space, wherein the target process address space is used for storing a code segment and a data segment in the currently running target application; in the process of running on the terminal device 102, when the instruction at the entry of the first function is modified into a target jump instruction and the first function is executed in the process of running the target application, jumping to the target reserved address through the target jump instruction, and executing the target code segment in the target patch package, wherein the target jump instruction is used for jumping to the target reserved address and executing the target code segment. . The above is merely an example, and the embodiments of the present application are not limited herein.
It should be noted that the server may be an independent physical server, may also be a server cluster or distributed system formed by a plurality of physical servers, and may also be a cloud server providing basic cloud computing services such as a cloud service, a cloud database, cloud computing, a cloud function, cloud storage, a network service, cloud communication, a middleware service, a domain name service, a security service, a CDN, and a big data and artificial intelligence platform. The terminal may be, but is not limited to, a smart phone, a tablet computer, a laptop computer, a desktop computer, a smart speaker, a smart watch, and the like. The terminal and the server may be directly or indirectly connected through wired or wireless communication, and the application is not limited herein.
Optionally, the method may be applied to a hot update scenario for various applications, for example, a hot update scenario for a game server process, and the embodiment is not limited herein.
Optionally, in this embodiment, the terminal device may be a terminal device configured with a target client, and may include, but is not limited to, at least one of the following: mobile phones (such as Android phones, iOS phones, etc.), notebook computers, tablet computers, palm computers, MID (Mobile Internet Devices), PAD, desktop computers, smart televisions, etc. The target client may be a video client, an instant messaging client, a browser client, an educational client, etc. Such networks may include, but are not limited to: a wired network, a wireless network, wherein the wired network comprises: a local area network, a metropolitan area network, and a wide area network, the wireless network comprising: bluetooth, WIFI, and other networks that enable wireless communication. The server may be a single server, a server cluster composed of a plurality of servers, or a cloud server. The above is only an example, and the present embodiment is not limited to this.
Optionally, in this embodiment, as an optional implementation manner, the method may be executed by a server, or may be executed by a terminal device, or may be executed by both the server and the terminal device, and in this embodiment, the execution by the server (for example, the server 102) is taken as an example for description. As shown in fig. 2, the flow of the hot update method for the target application may include the steps of:
step S202, under the condition that a first function in the currently running target application has a problem, a link script generator is used for generating a target link script according to an original binary file of the target application, and a patch code of the first function is compiled to obtain a target file, wherein the patch code of the first function is used for repairing the problem of the first function.
Optionally, during the running process of the target application (such as a game application, a social application, etc.), a current network problem (such as bug) inevitably occurs, and the problem occurs in the first function in the target application. A link script generator (such as a link script generation module shown in fig. 3) may be used to generate a target link script according to an original binary file of a target application, and at the same time, a patch code of a first function needs to be compiled to obtain a target file, where the patch code of the first function may be used to repair a problem occurring in the first function.
And step S204, linking the target file according to the target link script to obtain a target binary file.
Optionally, the generated target link script is compiled to obtain a target binary file.
Step S206, extracting a target code segment from the target binary file, and generating a target patch package from the target code segment.
Optionally, a target code segment is extracted from the obtained target binary file, and a target patch package is generated according to the target code segment.
Wherein the code segment: in the architecture using segmented memory management, a code segment (code/text segment) generally refers to a memory region for storing program execution code.
Step S208, loading the target patch package into a target reserved address in a target process address space, where the target process address space is used to store the code segment and the data segment in the currently running target application.
Optionally, the generated target patch package is loaded into a target reserved address in a target process address space, where the target process address space may be used to store the code segment and the data segment in the currently running target application.
In the Data segment architecture using segment memory management, the Data segment usually refers to a memory region for storing initialized global variables in a program. The data segment belongs to a static memory allocation.
Step S210, when the instruction at the entry of the first function is modified into a target jump instruction and the first function is executed in the process of running the target application, jumping to the target reserved address through the target jump instruction, and executing the target code segment in the target patch package, where the target jump instruction is used to jump to the target reserved address and execute the target code segment.
Optionally, an instruction at an entry of the first function may be modified into a target jump instruction, and when the first function with a problem is executed in the running process of the target application, the target application is jumped to a target reserved address through the target jump instruction, and a target code segment in the target patch package is executed, where the target jump instruction is used to jump to the target reserved address and execute the target code segment.
According to the embodiment, in the running process of the currently running target application, when a first function in the target application has a problem, a target link script is generated by a link script generator according to an original binary file of the target application, and a patch code of the first function is compiled to obtain a target file, wherein the patch code of the first function is used for repairing the problem of the first function; then, linking the target file according to the target link script to obtain a target binary file; then, extracting a target code segment from the target binary file, and generating a target patch package from the target code segment; loading the target patch package to a target reserved address in a target process address space, wherein the target process address space is used for storing the code segment and the data segment in the currently running target application; and under the condition that the instruction at the inlet of the first function is modified into a target jump instruction and the first function is executed in the process of running the target application, the target application is jumped to the target reserved address through the target jump instruction, and the target code segment in the target patch package is executed. By the mode, in the running process of the target application, when the first function with problems in the target application is run, the target application can jump to the target reserved address through the target jump instruction, the target code section in the target patch package corresponding to the first function is executed, and the normal running of the target application is ensured.
Optionally, in this embodiment, the generating a target link script according to an original binary file of a target application by using a link script generator includes: and generating the target link script according to the original binary file of the original process of the target application and a preset link script template, wherein the starting address of the target link script is determined according to the code segment starting address in the link script template and the space size occupied by the code segment starting address in the original process to the data segment starting address, the address of the data segment of the target link script is consistent with the address of the data segment of the original binary file, and the address of the BSS segment of the target link script is consistent with the address of the BSS segment of the original binary file.
Optionally, the target link script may be generated as follows:
the target link script can be generated according to an original binary file of an original process of a target application and a preset link script template, wherein the start address of the target link script can be determined according to the code segment start address in the link script template and the size of a space occupied by the code segment start address in the original process to the data segment start address, the address of the data segment of the target link script is consistent with the address of the data segment of the original binary file, and the address of the BSS segment of the target link script is consistent with the address of the BSS segment of the original binary file.
It should be noted that, in the dynamic library-based hot patch scheme, since the static variable is a local variable, if the static variable is used in the code to be repaired, the code repaired by the dynamic library scheme cannot be directly accessed, and needs to be replaced by the actual address of the static variable to be accessed. Therefore, the patch is relatively high in cost, and the engineering practice is relatively troublesome to maintain.
The initialized global static variables and local static variables are stored in the data segment, and the uninitialized local static variables are stored in the BSS segment. In this embodiment, since the address of the data segment of the patch code is consistent with the address of the data segment of the original binary file, the original binary file and the patch code may share the data segment and the BSS segment, that is, the static variables accessed by the original binary file and the patch code are the same.
Through the embodiment, the cost for making the patch code is reduced and the maintenance efficiency of the target application is improved through the mode of sharing the data segment.
Optionally, in this embodiment, the generating the target link script according to the original binary file of the original process of the target application and a preset link script template includes: and respectively storing the space size occupied by the code segment starting address to the data segment starting address in the original process and the code segment starting address in the link script template into the link script template to obtain the target link script, wherein the starting address of the data segment in the original binary file in the target link script is X + N M, the starting address of the target link script in the link script template is X + i M, i is more than or equal to 1 and less than N, X is the code segment starting address in the link script template, and M is the space size occupied by the code segment starting address to the data segment starting address in the original process.
Optionally, the size of the space occupied by the start address of the code segment in the original process to the start address of the data segment and the start address of the code segment in the link script template are respectively stored in the link script template to obtain the target link script, where the start address of the data segment in the original binary file in the target link script is X + N M, the start address of the target link script in the link script template is X + i M, i < N is greater than or equal to 1, X is the start address of the code segment in the original binary file, and M is the size of the space occupied by the start address of the code segment in the original process to the start address of the data segment.
For example, as shown in fig. 4, the target link script is generated based on a preset link script template and the original binary file. The code segment in the link script of the current version of the target application starts from the address X, the space size from the start address of the code segment in the original process to the start address of the data segment is M, and the start address of the data segment in the original process is X + N M. The code section starting address of the 1 st patch version is X + M, and the data section starting address is also X + N M; the code segment start address of the 2 nd patch version is X + M × 2, and the data segment start address is still X + N × M; and so on, a linking script for each patch can be generated.
According to the embodiment, the starting address of the data segment in the original binary file in the target link script and the starting address of the target link script are both X + i M, so that the cost for making the patch code is reduced and the maintenance efficiency of the target application is improved by the way of sharing the data segment.
Optionally, in this embodiment, the method further includes: acquiring the modification authority of the address space of the target process; under the condition that the modification permission is obtained and the access permission of the target process address space is read-only permission, modifying the access permission of the target process address space into write permission; and modifying the instruction at the inlet of the first function into the target jump instruction under the condition that the access authority of the target process address space is the write permission.
It should be noted that the binary codes loaded into the memory are all read-only, and the code can be changed to replace the instruction at the function entry only when the write permission needs to be acquired. The mprotect system call may modify the memory page attribute. In the invention, the acquisition of the process code authority is realized by the invocation of the mprotect system, and the access authority of the process memory area is modified. It should be noted that the granularity of modifying the memory attribute is page-specific, so that the memory page where the primitive function is located needs to be searched, and then the attribute of the whole page is modified to be writable.
Optionally, when the instruction at the entry of the first function is modified into the target jump instruction, a modification permission of the target process address space needs to be acquired, and when the modification permission of the target process address space is acquired and the access permission of the target process address space is a read-only permission, the access permission of the target process address space is modified from a read-only permission to a write-permission, and then, when the access permission of the target process address space is the write-permission, the instruction at the entry of the first function may be modified into the target jump instruction.
According to the method and the device, the access permission of the target process address space is modified from the read-only permission to the write permission, the instruction at the inlet of the first function can be modified into the target jump instruction, so that the target application can execute the target code segment through the target jump instruction in time when the target application runs to the first function with problems, and the hot update can be smoothly completed.
Optionally, in this embodiment, the modifying the access right of the address space of the target process to be a permission to write includes: and modifying the access authority of the first memory page to the write permission when the memory page where the first function is located in the target process address space is the first memory page.
Optionally, when the memory page where the first function is located in the target process address space is a first memory page, modifying the access right of the first memory page to the write permission may be performed to modify the access right of the target process address space from a read-only right to a write permission.
Optionally, in this embodiment, the loading the target patch package to the target reserved address in the target process address space includes: and mapping the target patch package to the target reserved address.
Alternatively, as shown in fig. 5, the target patch package may be loaded to the target reserved address in the target process address space by mapping the target patch package to the target reserved address.
It should be noted that, in the related art, when the existing network problem occurs, a dynamic library-based hot patch scheme is provided at the operating system level to solve the existing network problem, and the principle of the existing network problem is code replacement and instruction jumping. And modifying the function to be repaired, packaging the modified function into the dynamic library, and then loading the dynamic library. Embedding an instruction jump in an original function, and jumping to a corresponding repaired function in a dynamic library to execute when a process runs to a defective function so as to perform hot update of an operating system, but the above scheme has the following disadvantages:
dynamic library-based hot-patch schemes are not friendly to static variables. The static variable is a local variable, and if the static variable is used in the code to be repaired, the code repaired by the dynamic library scheme cannot be directly accessed and needs to be replaced by the actual address of the static variable to be accessed. Therefore, the patch is relatively high in cost, and the engineering practice is relatively troublesome to maintain.
In order to solve the above problem, the following describes a flow of a hot update method for a target application with reference to an optional example, and an overall framework of the solution is shown in fig. 3, and a specific process is as follows:
optionally, as shown in fig. 3, the link script generating module (e.g., the link script generator) is responsible for a target link script used by the link file, and the target link script specifies memory addresses of segments such as code segments and data segments of the binary file (e.g., the target binary file) for generating the patch version. The patch preparation module is responsible for extracting patches from a patch version of a binary (such as the target binary described above) for mapping to the address space in which the process is running. The hot update framework is responsible for loading the generated target patch package and jumping to the corresponding function address in the target patch package for execution when executing to the old function to be repaired (such as the first function).
And cold repair can be carried out while hot repair is carried out, namely, the new version process is used for replacing the old version process, and after the process is restarted, the new version process is operated without loading patches for hot update.
Note that, the Data segment (Data segment): in a segmented memory management architecture, a data segment generally refers to a block of memory used to store global variables initialized in a program. The data segment belongs to a static memory allocation.
BSS segment (Block Started by Symbol, BSS for short): generally refers to a block of memory area used to store global and static variables that are not initialized or are initialized to 0 in a program. The method is characterized in that: readable and writable, the BSS segment will automatically clear 0 before the program is executed.
Code segment (code segment/text segment): in the segmented memory management architecture, the segmented memory management architecture generally refers to a memory area for storing program execution code.
The following details the generation process of the target link script, and the specific process is as follows:
a link script is a script used to control the linking process, specify how to place a section in an input file (such as the above-mentioned raw binary file) into an output file, and control the layout of the parts in the input file in the program address space. The linker has a default built-in link script, and a customized link script can be specified through the-T option to replace the default link script so as to add a customized link command.
Alternatively, a storage space for a patch package (such as the target patch package described above) may be reserved by specifying the starting addresses of the code segments and the data segments in the target link script through a custom link script. The code segment spaces of the existing web version (such as the original binary file described above) and the patch version (such as the patch code) cannot overlap but require the same data segment addresses so that the original code and the patch code access the same global variables and static variables, etc.
Generally, taking a game server as an example, game server processes are all deployed on 64-bit servers, and the process address space is wide enough. The size of the memory space from the code segment to the data segment can be calculated to be M based on the original version, then the space of N patches is reserved for the use of subsequent patching, and the initial address of the data segment is moved backwards by the size of N M patches. And reserving space for finding N problems and patching N times before the process of the presence network is required to be restarted.
As shown in FIG. 4, the link script is generated based on the link script template and the binary file of the original process. The code segment in the existing web version of the link script starts from the address X, and the size of the starting address space from the code segment to the data segment in the original process is M. The data segment start address is X + N × M. The code section starting address of the 1 st patch version is X + M, and the data section starting address is also X + N M; the code segment start address of the 2 nd patch version is X + M × 2, and the data segment start address is still X + N × M; and so on, a linking script for each patch can be generated.
The following details the manufacturing process of the target patch package, and the specific process is as follows:
when the existing network finds that the problem needs to be repaired, the existing network generally repairs a certain function and modifies the corresponding code. And then generating a link script of a corresponding version by using a link script generator according to the patch version. A linking script is specified in the compilation script to generate a patched version of the binary.
Objcopy is used to copy part or all of the object content to another object, and can be used to extract part of the segments from the binary file, generating a patch package. And extracting code segments from the binary file of the patch version through an objcopy command to generate a patch for subsequent loading to a reserved patch code segment area in the current network process memory image.
The text, data, eh _ frame _ hdr, eh _ frame and gcc _ except _ table segments in the patch version need to be extracted into the patch, like the following commands:
“objcopy-O binary--only-section＝.text--only-section＝.rodata--only-section＝.eh_frame_hdr--only-section＝.eh_frame--only-section＝.gcc_except_table pvpmatchsvr smain_patch.code”。
and subsequently, the patch package and the corresponding configuration are released to the current network, the patch package is loaded through a hot update framework, and the current network problem can be repaired by performing instruction jumping according to the configuration.
The hot-update framework is detailed below, and the specific process is as follows:
the game server process realized by C + + is accessed to the hot update framework, and then hot update can be carried out through the scheme of two code segments. The hot updating framework mainly comprises a patch loading module and a code skipping module.
The patch package for repairing the existing network problem needs to be loaded into the address space of the existing network process to be effective. mmap is a method for mapping files in a memory, and maps a file or other objects to an address space of a process to realize a one-to-one mapping relation between a file disk address and a section of virtual address in the virtual address space of the process. After the mapping relationship is realized, the process can read and write the memory section by adopting a pointer mode.
As shown in fig. 5, a mmap function is used to perform memory mapping, and a patch packet is loaded into a patch memory area reserved in the address space of the target process.
Meanwhile, the hot update framework needs to support a code jump function, and when a function with problems is executed, the function can jump to the function execution after repair in the patch package. By modifying the instruction at the entry of the function, a jump instruction is replaced. When a function with problems is called, the function jumps to a repaired function corresponding to the loaded patch package to be executed, and after the function is completed, the call instruction returns to the caller to be continuously executed.
The jump is simply a relative jump E9 instruction of jmp. The jump instruction plus the target address occupy 5 bytes, and the jump offset can be calculated by subtracting the current address from the jump target address and then subtracting 5. A jump instruction, i.e., 0XE9 offset address, needs to be inserted at the start of the primitive, where the offset address is the target address-current address-5. And after the function in the patch code is executed, returning to the call instruction of the caller of the existing process to continue executing according to the function call stack rule.
The binary codes loaded into the memory are read-only, and the codes can be changed to replace instructions at the function inlet only by acquiring the write permission. The mprotect system call may modify the memory page attribute. And acquiring the process code authority through the mprotect system call, and modifying the access authority of the process memory area. It should be noted here that the granularity of modifying the memory attribute is page-specific, so that the memory page where the primitive function is located needs to be searched, and then the attribute of the whole page is modified to be writable.
For a function to be repaired, its location in memory needs to be determined, as well as the location in the patch package. The game server process usually does not load a dynamic library, and can directly search a symbol table of the process to acquire a function address.
The operation steps of the specific project access code segment for replacing heat exchange and updating are shown in fig. 6:
step S601, the current network version is accessed into a hot patch framework replaced by the code segment, a link script is specified during compiling, and space needs to be reserved in the link script for storing the subsequent additional patch. And then released to the existing network.
Step S602, repairing the problems found in the existing network by modifying a certain function, and generating a patch version based on the patch linking script link after compiling. The text segment space in the link script is put into the reserved position, and the data segment is consistent with the link script of the current network binary system. And then, a patch package is made by extracting the text section in the patch version.
Step S603, searching for addresses of the original function (the first function) and the patch function, and putting the obtained information such as the address and the name of the patch package into a corresponding configuration file, and pushing the obtained information and the patch package to the current network together for Reload issue to repair the current network problem.
It should be noted that, the process that needs to be repaired is recompiled, and then the code segment is extracted. Mapping into an existing process memory map. In the above process, the specific storage carrier of the patch function is not limited, the repaired patch code may also be packed into the dynamic library, and then the dynamic library is dynamically loaded, and when a function with a problem is executed, the execution of the patch function corresponding to the dynamic library is skipped to. When the dynamic library mode is adopted, special processing is needed for static variables.
Through the embodiment of the invention, in the process, the C + + written code under the Linux environment is subjected to hot updating through the two sets of code segments and the shared data segment. Firstly, customizing a link script, and compiling codes by designating link addresses of code segments and data segments; then extracting a code segment which is used for compiling a generated file after the bug is modified to generate a patch package, and mapping the patch package to the memory address space of the existing process; and when the code with the bug is executed, jumping to the code execution in the patch package. The existing network problem can be repaired with lower cost, the game operation efficiency is improved, and better experience is brought to users.
It should be noted that, for simplicity of description, the above-mentioned method embodiments are described as a series of acts or combination of acts, but those skilled in the art will recognize that the present invention is not limited by the order of acts, as some steps may occur in other orders or concurrently in accordance with the invention. Further, those skilled in the art should also appreciate that the embodiments described in the specification are preferred embodiments and that the acts and modules referred to are not necessarily required by the invention.
According to another aspect of the embodiments of the present invention, there is also provided a hot-update apparatus for a target application, as shown in fig. 7, the apparatus including:
a first processing unit 702, configured to, when a first function in a currently running target application has a problem, generate a target link script according to an original binary file of the target application using a link script generator, and compile a patch code of the first function to obtain a target file, where the patch code of the first function is used to repair the problem occurring in the first function;
a linking unit 704, configured to link the target file according to the target link script to obtain a target binary file;
a second processing unit 706, configured to extract a target code segment from the target binary file, and generate a target patch package from the target code segment;
a loading unit 708, configured to load the target patch package into a target reserved address in a target process address space, where the target process address space is used to store a code segment and a data segment in the currently running target application;
a third processing unit 710, configured to jump to the target reserved address through the target jump instruction and execute the target code segment in the target patch package when an instruction at an entry of the first function is modified into a target jump instruction and the first function is executed in the process of running the target application, where the target jump instruction is configured to jump to the target reserved address and execute the target code segment.
According to the embodiment, in the running process of the currently running target application, when a first function in the target application has a problem, a target link script is generated by a link script generator according to an original binary file of the target application, and a patch code of the first function is compiled to obtain a target file, wherein the patch code of the first function is used for repairing the problem of the first function; then, linking the target file according to the target link script to obtain a target binary file; then, extracting a target code segment from the target binary file, and generating a target patch package from the target code segment; loading the target patch package to a target reserved address in a target process address space, wherein the target process address space is used for storing the code segment and the data segment in the currently running target application; and under the condition that the instruction at the inlet of the first function is modified into a target jump instruction and the first function is executed in the process of running the target application, the target application is jumped to the target reserved address through the target jump instruction, and the target code segment in the target patch package is executed. By the mode, in the running process of the target application, when the first function with problems in the target application is run, the target application can jump to the target reserved address through the target jump instruction, the target code section in the target patch package corresponding to the first function is executed, and the normal running of the target application is ensured.
As an optional technical solution, the first processing unit includes: and a generating module, configured to generate the target link script according to the original binary file of the original process of the target application and a preset link script template, where a start address of the target link script is determined according to a code segment start address in the link script template and a size of a space occupied by the code segment start address in the original process to a data segment start address, an address of a data segment of the target link script is consistent with an address of a data segment of the original binary file, and an address of a BSS segment of the target link script is consistent with an address of a BSS segment of the original binary file.
As an optional technical solution, the generating module is further configured to store, in the chaining script template, a space size occupied by a code segment start address to a data segment start address in an original process and a code segment start address in the chaining script template, respectively, to obtain the target chaining script, where a start address of the data segment in the original binary file in the target chaining script is X + N M, a start address of the target chaining script in the chaining script template is X + i M, i < N > 1 ≦ i, X is a code segment start address in the chaining script template, and M is a space size occupied by the code segment start address to the data segment start address in the original process.
As an optional technical solution, as shown in fig. 8, the apparatus further includes: an obtaining unit 802, configured to obtain a modification permission of the target process address space; a fourth processing unit 804, configured to modify the access right of the target process address space to an allowed write right when the modification right is acquired and the access right of the target process address space is a read-only right; a fifth processing unit 806, configured to modify the entry instruction of the first function to the target jump instruction if the access right of the target process address space is the write permission.
As an optional technical solution, the fourth processing unit is further configured to modify, when a memory page where the first function is located in the target process address space is a first memory page, an access permission of the first memory page to the permission to write.
According to a further aspect of embodiments of the present invention, there is also provided a storage medium having a computer program stored therein, wherein the computer program is arranged to perform the steps of any of the above-mentioned method embodiments when executed.
Alternatively, in the present embodiment, the storage medium may be configured to store a computer program for executing the steps of:
s1, under the condition that a first function in the currently running target application has a problem, generating a target link script according to an original binary file of the target application by using a link script generator, and compiling a patch code of the first function to obtain a target file, wherein the patch code of the first function is used for repairing the problem of the first function;
s2, linking the target file according to the target link script to obtain a target binary file;
s3, extracting target code segment from the target binary file, and generating target patch package from the target code segment;
s4, loading the target patch package into a target reserved address in a target process address space, where the target process address space is used to store the code segment and the data segment in the currently running target application;
s5, when the instruction at the entry of the first function is modified into a target jump instruction and the first function is executed during the running of the target application, jumping to the target reserved address through the target jump instruction, and executing the target code segment in the target patch package, wherein the target jump instruction is used to jump to the target reserved address and execute the target code segment.
Alternatively, in this embodiment, a person skilled in the art may understand that all or part of the steps in the methods of the foregoing embodiments may be implemented by instructing hardware related to the terminal device through a program, where the program may be stored in a computer-readable storage medium, and the storage medium may include: flash disks, ROM (Read-Only Memory), RAM (Random Access Memory), magnetic or optical disks, and the like.
According to another aspect of the embodiment of the present invention, there is also provided an electronic device for implementing the hot update method of the target application, where the electronic device may be a terminal device or a server shown in fig. 1. The present embodiment takes the electronic device as a server as an example for explanation. As shown in fig. 9, the electronic device comprises a memory 902 and a processor 904, the memory 902 having stored therein a computer program, the processor 904 being arranged to perform the steps of any of the above-described method embodiments by means of the computer program.
Optionally, in this embodiment, the processor may be configured to execute the following steps by a computer program:
s1, under the condition that a first function in the currently running target application has a problem, generating a target link script according to an original binary file of the target application by using a link script generator, and compiling a patch code of the first function to obtain a target file, wherein the patch code of the first function is used for repairing the problem of the first function;
s2, linking the target file according to the target link script to obtain a target binary file;
s3, extracting target code segment from the target binary file, and generating target patch package from the target code segment;
s4, loading the target patch package into a target reserved address in a target process address space, where the target process address space is used to store the code segment and the data segment in the currently running target application;
s5, when the instruction at the entry of the first function is modified into a target jump instruction and the first function is executed during the running of the target application, jumping to the target reserved address through the target jump instruction, and executing the target code segment in the target patch package, wherein the target jump instruction is used to jump to the target reserved address and execute the target code segment.
Alternatively, it is understood by those skilled in the art that the structure shown in fig. 9 is only an illustration and is not a limitation to the structure of the electronic device. For example, the electronic device may also include more or fewer components (e.g., network interfaces, etc.) than shown in FIG. 9, or have a different configuration than shown in FIG. 9.
The memory 902 may be configured to store software programs and modules, such as program commands/modules corresponding to the hot-update method and apparatus for a target application in the embodiment of the present invention, and the processor 904 executes various functional applications and hot-updates by running the software programs and modules stored in the memory 902, that is, implementing the hot-update method for the target application. The memory 902 may include high-speed random access memory, and may also include non-volatile memory, such as one or more magnetic storage devices, flash memory, or other non-volatile solid-state memory. In some examples, the memory 902 may further include memory located remotely from the processor 904, which may be connected to the terminal over a network. Examples of such networks include, but are not limited to, the internet, intranets, local area networks, mobile communication networks, and combinations thereof. As an example, as shown in fig. 9, the memory 902 may include, but is not limited to, a first processing unit 702, a linking unit 704, a second processing unit 706, a loading unit 708, and a third processing unit 710 in a hot-update apparatus of the target application. In addition, other module units in the thermal update apparatus of the target application may also be included, but are not limited to, and are not described in this example again.
Optionally, the transmitting device 906 is used for receiving or sending data via a network. Examples of the network may include a wired network and a wireless network. In one example, the transmission device 906 includes a Network adapter (NIC) that can be connected to a router via a Network cable and other Network devices to communicate with the internet or a local area Network. In one example, the transmission device 906 is a Radio Frequency (RF) module, which is used for communicating with the internet in a wireless manner.
In addition, the electronic device further includes: a connection bus 908 for connecting the respective module components in the electronic apparatus described above.
In other embodiments, the terminal device or the server may be a node in a distributed system, where the distributed system may be a blockchain system, and the blockchain system may be a distributed system formed by connecting a plurality of nodes through a network communication. Nodes can form a Peer-To-Peer (P2P, Peer To Peer) network, and any type of computing device, such as a server, a terminal, and other electronic devices, can become a node in the blockchain system by joining the Peer-To-Peer network.
Alternatively, in this embodiment, a person skilled in the art may understand that all or part of the steps in the methods of the foregoing embodiments may be implemented by instructing hardware related to the terminal device through a program, where the program may be stored in a computer-readable storage medium, and the storage medium may include: flash disks, Read-Only memories (ROMs), Random Access Memories (RAMs), magnetic or optical disks, and the like.
The above-mentioned serial numbers of the embodiments of the present invention are merely for description and do not represent the merits of the embodiments.
The integrated unit in the above embodiments, if implemented in the form of a software functional unit and sold or used as a separate product, may be stored in the above computer-readable storage medium. Based on such understanding, the technical solution of the present invention may be embodied in the form of a software product, which is stored in a storage medium and includes a plurality of commands for enabling one or more computer devices (which may be personal computers, servers, network devices, etc.) to execute all or part of the steps of the above methods according to the embodiments of the present invention.
In the above embodiments of the present invention, the descriptions of the respective embodiments have respective emphasis, and for parts that are not described in detail in a certain embodiment, reference may be made to related descriptions of other embodiments.
In the several embodiments provided in the present application, it should be understood that the disclosed client may be implemented in other manners. The above-described embodiments of the apparatus are merely illustrative, and for example, the above-described division of the units is only one type of division of logical functions, and other divisions may be realized in practice, for example, a plurality of units or components may be combined or integrated into another system, or some features may be omitted, or not executed. In addition, the shown or discussed mutual coupling or direct coupling or communication connection may be an indirect coupling or communication connection through some interfaces, units or modules, and may be in an electrical or other form.
The units described as separate parts may or may not be physically separate, and parts displayed as units may or may not be physical units, may be located in one place, or may be distributed on a plurality of network units. Some or all of the units can be selected according to actual needs to achieve the purpose of the solution of the embodiment.
In addition, functional units in the embodiments of the present invention may be integrated into one processing unit, or each unit may exist alone physically, or two or more units are integrated into one unit. The integrated unit can be realized in a form of hardware, and can also be realized in a form of a software functional unit.
The foregoing is only a preferred embodiment of the present invention, and it should be noted that, for those skilled in the art, various modifications and decorations can be made without departing from the principle of the present invention, and these modifications and decorations should also be regarded as the protection scope of the present invention.
Claims (10)
1. A method for thermal update of a target application, comprising:
under the condition that a first function in a currently running target application has a problem, a link script generator is used for generating a target link script according to an original binary file of the target application, wherein the target link script is obtained by respectively storing the space size occupied by a code segment starting address to a data segment starting address in an original process and the code segment starting address in a link script template, and compiling a patch code of the first function to obtain the target file, the patch code of the first function is used for repairing the problem of the first function, the starting address of the data segment in the original binary file in the target link script is X + N M, the starting address of the target link script in the link script template is X + i M, and i is not less than 1 and not more than N, x is the code segment initial address in the link script template, and M is the space size occupied by the code segment initial address to the data segment initial address in the original process;
linking the target file according to the target link script to obtain a target binary file;
extracting a target code segment from the target binary file, and generating a target patch package from the target code segment;
loading the target patch package to a target reserved address in a target process address space, wherein the target process address space is used for storing a code segment and a data segment in the currently running target application;
and when the instruction at the inlet of the first function is modified into a target jump instruction and the first function is executed in the process of running the target application, jumping to the target reserved address through the target jump instruction, and executing the target code segment in the target patch package, wherein the target jump instruction is used for jumping to the target reserved address and executing the target code segment.
2. The method of claim 1, further comprising:
acquiring the modification permission of the address space of the target process;
under the condition that the modification permission is obtained and the access permission of the target process address space is read-only permission, modifying the access permission of the target process address space to be write-permission;
and modifying the instruction at the inlet of the first function into the target jump instruction under the condition that the access authority of the target process address space is the write permission.
3. The method of claim 2, wherein modifying the access rights of the target process address space to allow write rights comprises:
and modifying the access permission of the first memory page to the permission to write when the memory page where the first function is located in the target process address space is the first memory page.
4. The method as claimed in claim 1, wherein said loading the target patch package to a target reserved address in a target process address space comprises:
and mapping the target patch package to the target reserved address.
5. A thermal update apparatus for a target application, comprising:
the system comprises a first processing unit, a link script generator and a second processing unit, wherein the first processing unit is used for generating a target link script according to an original binary file of a target application by using the link script generator under the condition that a first function in the currently running target application has a problem, and compiling a patch code of the first function to obtain a target file, and the patch code of the first function is used for repairing the problem of the first function;
the link unit is used for linking the target file according to the target link script to obtain a target binary file;
the second processing unit is used for extracting a target code segment from the target binary file and generating a target patch package from the target code segment;
a loading unit, configured to load the target patch package into a target reserved address in a target process address space, where the target process address space is used to store a code segment and a data segment in the currently running target application;
a third processing unit, configured to jump to the target reserved address through the target jump instruction and execute the target code segment in the target patch package when an entry instruction of the first function is modified to a target jump instruction and the first function is executed in a process of running the target application, where the target jump instruction is configured to jump to the target reserved address and execute the target code segment;
the first processing unit comprises a generating module, and is used for respectively storing the space size occupied by the code segment starting address to the data segment starting address in the original process and the code segment starting address in the link script template to obtain the target link script, wherein the starting address of the data segment in the original binary file in the target link script is X + N M, the starting address of the target link script in the link script template is X + i M, i is not less than 1 and not more than N, X is the code segment starting address in the link script template, and M is the space size occupied by the code segment starting address to the data segment starting address in the original process.
6. The apparatus of claim 5, further comprising:
the acquisition unit is used for acquiring the modification permission of the target process address space;
the fourth processing unit is used for modifying the access right of the target process address space into an allowed write right under the condition that the modification right is obtained and the access right of the target process address space is a read-only right;
and the fifth processing unit is used for modifying the instruction at the inlet of the first function into the target jump instruction under the condition that the access authority of the target process address space is the write permission.
7. The apparatus according to claim 6, wherein the fourth processing unit is further configured to, if the memory page where the first function is located in the target process address space is a first memory page, modify the access permission of the first memory page to the write permission.
8. The apparatus as claimed in claim 5, wherein the loading unit is further configured to map the target patch package to the target reserved address.
9. A computer-readable storage medium, comprising a stored program, wherein the program is operable to perform the method of any of claims 1 to 4.
10. An electronic device comprising a memory and a processor, characterized in that the memory has stored therein a computer program, the processor being arranged to execute the method of any of claims 1 to 4 by means of the computer program.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202010628955.7A CN111666096B (en) | 2020-07-02 | 2020-07-02 | Hot updating method and device for target application, storage medium and electronic equipment |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202010628955.7A CN111666096B (en) | 2020-07-02 | 2020-07-02 | Hot updating method and device for target application, storage medium and electronic equipment |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN111666096A CN111666096A (en) | 2020-09-15 |
| CN111666096B true CN111666096B (en) | 2021-03-16 |
Family
ID=72390846
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202010628955.7A Active CN111666096B (en) | 2020-07-02 | 2020-07-02 | Hot updating method and device for target application, storage medium and electronic equipment |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN111666096B (en) |
Families Citing this family (8)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN114579181A (en) * | 2020-11-30 | 2022-06-03 | 华为技术有限公司 | Patching method, related equipment and system |
| CN112631640B (en) * | 2020-12-23 | 2022-11-04 | 苏州三六零智能安全科技有限公司 | Patch generation method, device, equipment and storage medium |
| CN112650519A (en) * | 2020-12-28 | 2021-04-13 | 深圳大普微电子科技有限公司 | Firmware repair method, solid state disk controller and solid state disk |
| CN113342389B (en) * | 2021-05-31 | 2022-09-30 | 深圳市腾讯网络信息技术有限公司 | Service updating method and device and computer readable storage medium |
| CN113467803B (en) * | 2021-06-28 | 2024-03-01 | 广州虎牙科技有限公司 | Application program repairing method, related device and equipment |
| CN113849245B (en) * | 2021-09-23 | 2023-09-12 | 武汉深之度科技有限公司 | Application program running method, computing device and storage medium |
| CN115017058B (en) * | 2022-08-04 | 2022-11-29 | 飞腾信息技术有限公司 | Test method and device of kernel module, electronic equipment and storage medium |
| CN116414424B (en) * | 2023-06-09 | 2023-09-12 | 建信金融科技有限责任公司 | Thermal updating method, device, equipment and storage medium |
Citations (8)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN102609241A (en) * | 2012-01-19 | 2012-07-25 | 中兴通讯股份有限公司 | Hot patching method and device |
| CN103744709A (en) * | 2014-01-23 | 2014-04-23 | 华为技术有限公司 | Patch loading method and device |
| CN104809018A (en) * | 2015-05-18 | 2015-07-29 | 烽火通信科技股份有限公司 | Method and system for injecting hotfix into software of embedded system |
| CN105138341A (en) * | 2015-09-24 | 2015-12-09 | 上海斐讯数据通信技术有限公司 | Method for achieving heat patch long skip on basis of MIPS framework and vxworks system |
| CN105607937A (en) * | 2015-12-25 | 2016-05-25 | 京信通信技术(广州)有限公司 | Hot patching method and equipment |
| CN110543323A (en) * | 2019-09-11 | 2019-12-06 | 北京搜狐新动力信息技术有限公司 | Application program repairing method and device |
| CN110597544A (en) * | 2019-08-20 | 2019-12-20 | 杭州辰汉智能科技有限公司 | Software system upgrading method and device |
| US10698668B1 (en) * | 2018-05-29 | 2020-06-30 | Amazon Technologies, Inc. | Custom code transformations during compilation process |
Family Cites Families (13)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN100535901C (en) * | 2006-12-29 | 2009-09-02 | 腾讯科技（深圳）有限公司 | Dynamic web page updating method and system |
| US20100269106A1 (en) * | 2009-04-21 | 2010-10-21 | Ksplice, Inc. | Method of finding a safe time to modify code of a running computer program |
| CN104636161B (en) * | 2013-11-15 | 2018-06-19 | 华为技术有限公司 | The online patch method and system of a kind of multiple nucleus system |
| US9483248B2 (en) * | 2014-07-15 | 2016-11-01 | Oracle International Corporation | Automatic generation and execution of server update processes |
| CN105022646B (en) * | 2015-07-13 | 2018-02-13 | 苏州大学 | A kind of remote-code-update method and apparatus of data lossless |
| US20170300317A1 (en) * | 2016-03-24 | 2017-10-19 | Knight Point Systems, Inc. | System and method for patching software in a target computer system device |
| CN107783775A (en) * | 2016-08-25 | 2018-03-09 | 南京理工大学 | Based on RTOS embedded remote online upgrading functional based methods |
| US10360020B2 (en) * | 2017-04-11 | 2019-07-23 | Nio Usa, Inc. | Virtual machine (VM) approach to embedded system hot update |
| CN107797820B (en) * | 2017-11-13 | 2021-03-23 | 北京百度网讯科技有限公司 | Method and device for generating patch |
| CN108427571A (en) * | 2018-02-07 | 2018-08-21 | 深圳市雁联计算系统有限公司 | A kind of dynamic link library update method and server |
| CN108553897B (en) * | 2018-03-01 | 2019-06-18 | 腾讯科技（深圳）有限公司 | The processing method of data, device, storage medium and electronic device in game |
| CN110837391B (en) * | 2019-11-04 | 2021-02-12 | 广州方硅信息技术有限公司 | Application program hot updating method and device, storage medium and electronic equipment |
| CN110928569A (en) * | 2019-11-20 | 2020-03-27 | 杭州依赛通信有限公司 | Method for realizing Live Update function of communication equipment |
-
2020
- 2020-07-02 CN CN202010628955.7A patent/CN111666096B/en active Active
Patent Citations (8)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN102609241A (en) * | 2012-01-19 | 2012-07-25 | 中兴通讯股份有限公司 | Hot patching method and device |
| CN103744709A (en) * | 2014-01-23 | 2014-04-23 | 华为技术有限公司 | Patch loading method and device |
| CN104809018A (en) * | 2015-05-18 | 2015-07-29 | 烽火通信科技股份有限公司 | Method and system for injecting hotfix into software of embedded system |
| CN105138341A (en) * | 2015-09-24 | 2015-12-09 | 上海斐讯数据通信技术有限公司 | Method for achieving heat patch long skip on basis of MIPS framework and vxworks system |
| CN105607937A (en) * | 2015-12-25 | 2016-05-25 | 京信通信技术(广州)有限公司 | Hot patching method and equipment |
| US10698668B1 (en) * | 2018-05-29 | 2020-06-30 | Amazon Technologies, Inc. | Custom code transformations during compilation process |
| CN110597544A (en) * | 2019-08-20 | 2019-12-20 | 杭州辰汉智能科技有限公司 | Software system upgrading method and device |
| CN110543323A (en) * | 2019-09-11 | 2019-12-06 | 北京搜狐新动力信息技术有限公司 | Application program repairing method and device |
Also Published As
| Publication number | Publication date |
|---|---|
| CN111666096A (en) | 2020-09-15 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN111666096B (en) | Hot updating method and device for target application, storage medium and electronic equipment | |
| CN108958796B (en) | Service request processing method and device and service request processing system | |
| CN102411506B (en) | Java-system business-unit plug-in type managing system and dynamic business-function changing method | |
| CN109614162B (en) | Front-end loading optimization method based on component development mode and storage medium | |
| CN107391104B (en) | Client and reactive native code update dependence management method, device and system | |
| CN109491695A (en) | A kind of increment updating method of integrated Android application | |
| CN111782302B (en) | Process updating method and device, storage medium and electronic equipment | |
| CN104991793A (en) | Method, device and system used for application program subpackage | |
| KR20180137554A (en) | PATCH UPGRADE BASED FILE PROCESSING METHOD AND DEVICE, TERMINAL, | |
| CN103970563B (en) | The method of dynamic load Android class | |
| CN111897623B (en) | Cluster management method, device, equipment and storage medium | |
| CN109739600B (en) | Data processing method, medium, device and computing equipment | |
| CN111399840B (en) | Module development method and device | |
| CN103559065A (en) | Method and system for OTA (Over-the-Air Technology) upgrade | |
| CN111459539B (en) | Continuous integration pipeline operation method and device based on mirror layering | |
| CN104750528A (en) | Management method and device for components in Android program | |
| CN105577813A (en) | Update method and system for web hybrid application | |
| CN112181588A (en) | Application containerization method and device, electronic equipment and storage medium | |
| CN109344619A (en) | The hot restorative procedure and device of application program | |
| CN103716346A (en) | Management method and device of application on android handset client | |
| CN104699503A (en) | Method and device for replacing function execution logic in Android system | |
| CN105094878A (en) | System library file integration method and apparatus | |
| CN106293790B (en) | application program upgrading method and device based on Firefox operating system | |
| CN105447040A (en) | Binary file management and update method and device, and binary file management system | |
| CN116401003A (en) | Android application running method, system and storage medium based on desktop operating system |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |