CN111782302A - Process updating method and device, storage medium and electronic equipment - Google Patents
Process updating method and device, storage medium and electronic equipment Download PDFInfo
- Publication number
- CN111782302A CN111782302A CN202010671460.2A CN202010671460A CN111782302A CN 111782302 A CN111782302 A CN 111782302A CN 202010671460 A CN202010671460 A CN 202010671460A CN 111782302 A CN111782302 A CN 111782302A
- Authority
- CN
- China
- Prior art keywords
- function
- memory address
- address
- process function
- file
- 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.)
- Granted
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/445—Program loading or initiating
- G06F9/44521—Dynamic linking or loading; Link editing at or after load time, e.g. Java class loading
-
- 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
Abstract
The invention discloses a process updating method and device, a storage medium and electronic equipment. Wherein, the method comprises the following steps: acquiring a process updating instruction, and loading a dynamic link compiling file matched with the current process; acquiring a first function identifier of a first process function and a second function identifier of a second process function from a configuration file associated with the dynamic link compilation file, wherein the first process function is a process function requested to be called in a current process calling instruction, and the second process function is used for replacing the first process function; acquiring a first memory address matched with the first function identifier and a second memory address matched with the second function identifier through a dynamic symbol table in a dynamic link compiling file; and updating the first memory address to a second memory address so as to replace the first process function with a second process function. The invention solves the technical problem that the smooth and lossless geothermal updating of the process in the server can not be completely realized.
Description
Technical Field
The invention relates to the field of computers, in particular to a process updating method and device, a storage medium and electronic equipment.
Background
In recent years, as the scale of the game industry has been expanded, the computational complexity and network load of the game server have been increasing. In the online deployment and operation process of the game server, functional abnormality and data errors caused by code errors can often occur. In such cases, game developers are often required to manually correct the code errors and redeploy the correct code onto the server to continue execution in place of the original code. Such on-line hot-update maintenance is required to minimize the impact on the quality of service
At present, for a game server developed by using a compiled language, in the process updating process, if there is no service state currently, the grayscale updating is generally performed by adopting a direct shutdown and restart manner (the grayscale updating is a group gradual updating), but the operation is complex, the time consumption is long, and the pressure of the rest service processes is increased instantly when part of the service processes are stopped. If the service state exists currently, a shutdown restart mode is also adopted, but before shutdown, state information (generally adopting a database or shared memory mode) needs to be stored in advance, so that the interrupted service state can be recovered after restart.
That is, in the process updating method provided in the related art, shutdown and restart are often necessary, which causes the service in operation to have to be interrupted or suspended, thereby causing a problem that smooth and lossless thermal updating of the process in the server cannot be achieved completely.
In view of the above problems, no effective solution has been proposed.
Disclosure of Invention
The embodiment of the invention provides a process updating method and device, a storage medium and electronic equipment, which at least solve the technical problem that smooth and lossless geothermal updating cannot be completely realized on a process in a server.
According to an aspect of an embodiment of the present invention, there is provided a process update method, including: acquiring a process updating instruction, and loading a dynamic link compiling file matched with the current process; acquiring a first function identifier of a first process function and a second function identifier of a second process function from a configuration file associated with the dynamic link compilation file, wherein the first process function is a process function requested to be called in a current process calling instruction, and the second process function is used for replacing the first process function; acquiring a first memory address matched with the first function identifier and a second memory address matched with the second function identifier through a dynamic symbol table in the dynamic link compilation file; and updating the first memory address to the second memory address to replace the first process function with the second process function.
According to another aspect of the embodiments of the present invention, there is also provided a process updating apparatus, including: the first processing unit is used for acquiring a process updating instruction and loading a dynamic link compiling file matched with the current process; a first obtaining unit, configured to obtain, from a configuration file associated with the dynamic link compilation file, a first function identifier of a first process function and a second function identifier of a second process function, where the first process function is a process function requested to be called in a current process call instruction, and the second process function is used to replace the first process function; a second obtaining unit, configured to obtain, through a dynamic symbol table in the dynamic link compilation file, a first memory address matching the first function identifier and a second memory address matching the second function identifier; an updating unit, configured to update the first memory address to the second memory address, so as to replace the first process function with the second process function.
According to still another aspect of the embodiments of the present invention, there is also provided a computer-readable storage medium in which a computer program is stored, wherein the computer program is configured to execute the above process updating method when running.
According to another aspect of the embodiments of the present invention, there is also provided an electronic device, including a memory and a processor, where the memory stores a computer program, and the processor is configured to execute the process updating method through the computer program.
In the embodiment of the present invention, when the obtained process update instruction indicates to update the current process, the dynamic link compilation file matched with the current process is loaded, and the first process function identifier of the first process function and the second function identifier of the second process function are obtained from the configuration file associated with the dynamic link compilation file. Further, a first memory address matched with the first function identifier and a second memory address matched with the second function identifier are obtained through a dynamic symbol table in a dynamic link compiling file. And then directly updating a first memory address in a call instruction for requesting to call the first process function in the current process into a second memory address. That is to say, the memory address of the called process function is directly updated to replace the first process function with the second process function, so that the update and replacement of the process function in the server process are completed on the premise of not stopping and interrupting the current process, the effect of smoothly updating the geothermal heat of the server process is achieved, and the technical problem that the process in the server cannot be completely smoothly updated without damage is solved.
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 diagram of a hardware environment for an alternative process update method according to an embodiment of the invention;
FIG. 2 is a flow diagram of an alternative process update method according to an embodiment of the invention;
FIG. 3 is a flow chart of an alternative process update method in the related art;
FIG. 4 is a flow diagram of an alternative process update method according to an embodiment of the invention;
FIG. 5 is a flow diagram of yet another alternative process update method according to an embodiment of the present invention;
FIG. 6 is a diagram of an alternative process update method according to an embodiment of the invention;
FIG. 7 is a diagram of an alternative process update method according to an embodiment of the invention;
FIG. 8 is a flow chart of yet another alternative process update method according to an embodiment of the present invention;
FIG. 9 is a block diagram of an alternative process update apparatus according to an embodiment of the present invention;
fig. 10 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.
In the embodiment of the present application, the above process updating method may be applied to, but not limited to, a game server in a game application scenario. To illustrate the update process of a server process, the following technical terms may be referred to, but are not limited to:
hot updating: and the game server dynamically updates in the running process, including configuration updating, process function updating and the like.
Gray level updating: the process group or the function group with the same function of the game server is updated in a partially alternate mode, and the function is shaken smoothly, so that the stability of the whole system is ensured.
Sharing the memory: two unrelated processes are allowed to access the same logical memory, sharing memory is a way to share and transfer data between two running processes, and is not reclaimed as the life cycle of the process is over.
Linux: operating system for game server
Reflection: the program language term is a method for acquiring a corresponding original class according to partial information, such as a specific object or an object name.
SO document: the dynamic link library file format under Linux provides a method to enable a process to call functions that do not belong to its executable code.
ELF file: an executable file for use in binary, executable, object code, shared libraries and core dump format files, Linux.
Golang: the server actually implements the parallel programming language used.
Goroutine: lightweight threads in the Golang language.
According to an aspect of the embodiments of the present invention, a process updating method is provided, and optionally, as an optional implementation manner, the process updating method may be but is not limited to be applied to a hardware environment as shown in fig. 1, where the hardware environment runs in a process updating system, and the system includes a terminal device 102 for acquiring an operation instruction, a network 104 for transmitting information, and a server 106 for performing a process update. Here, the terminal device 102 includes a human-machine interaction screen 1022, a processor 1024, and a memory 1026. The human-computer interaction screen 1022 is used to provide a human-computer interaction interface to accept user operations. The processor 1024 is configured to generate an operation instruction (e.g., trigger to generate a process update instruction) in response to the user operation, and execute a corresponding background operation according to the operation instruction. The memory 1026 is used for storing the above-mentioned operation instructions.
In addition, the server 106 includes a database 1062 and a processing engine 1064, and the database 1062 is used for storing the dynamic link compilation file and the configuration file. The processing engine 1064 is configured to determine, by using the dynamic link compiled file and the configuration file, a first process function to be replaced and a first memory address corresponding to the first process function, and a second process function used to replace the first process function and a second memory address corresponding to the second process function, and update the first memory address by using the second memory address, so as to achieve the purpose of smoothly updating the process function in the server process without interruption.
The specific process comprises the following steps: in step S102, the server 106 acquires a process update instruction triggered in the terminal apparatus 102 via the network 104. Then steps S104-S110 are performed: and loading a dynamic link compilation file matched with the current process, and acquiring a first process function identifier of the first process function and a second function identifier of the second process function from a configuration file associated with the dynamic link compilation file. Further, a first memory address matched with the first function identifier and a second memory address matched with the second function identifier are obtained through a dynamic symbol table in a dynamic link compiling file. And then updating a first memory address in a calling instruction for requesting to call the first process function in the current process into a second memory address.
It should be noted that, in this embodiment, after the obtained process update instruction, the dynamic link compilation file matched with the current process is loaded, and the first process function identifier of the first process function and the second function identifier of the second process function are obtained from the configuration file associated with the dynamic link compilation file. Further, a first memory address matched with the first function identifier and a second memory address matched with the second function identifier are obtained through a dynamic symbol table in a dynamic link compiling file. And then directly updating a first memory address in a call instruction for requesting to call the first process function in the current process into a second memory address. That is to say, the memory address of the called process function is directly updated to update the first process function to the second process function, so that the update and replacement of the process function in the server process are completed on the premise of not needing to stop and interrupting the current process, the effect of smoothly and thermally updating the process in the server is achieved, and the problem of bad influence on the service quality caused by the fact that the update is required to be stopped in the related technology is solved.
Optionally, in this embodiment, the terminal device may include, but is not limited to, at least one of the following: mobile phones (such as Android Mobile phones, iOS Mobile phones, etc.), notebook computers, tablet computers, palm computers, MID (Mobile internet devices), PADs, desktop computers, smart televisions, 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 merely an example, and this is not limited in this embodiment.
Optionally, as an optional implementation manner, as shown in fig. 2, the process updating method includes:
s202, acquiring a process updating instruction, and loading a dynamic link compiling file matched with the current process;
s204, acquiring a first function identifier of a first process function and a second function identifier of a second process function from a configuration file associated with the dynamic link compilation file, wherein the first process function is a process function requested to be called in a current process calling instruction, and the second process function is used for replacing the first process function;
s206, acquiring a first memory address matched with the first function identifier and a second memory address matched with the second function identifier through a dynamic symbol table in the dynamic link compiling file;
s208, the first memory address is updated to a second memory address, so that the first process function is replaced by a second process function.
Optionally, in this embodiment, the process updating method may be applied, but not limited to, to application servers of different terminal applications, such as a game server, an education server, a transaction server, and the like, and the data processing server implements corresponding functional roles through process functions in the servers. The first process function is a process function requested to be called in a current process calling instruction, and the second process function is used for replacing the first process function. It should be noted that, the first process function may be, but is not limited to, a process function carrying an error code, and needs to be updated to correct an error, so as to avoid an operation failure of the server; in addition, the first process function can also be but not limited to a process function with a lower version, and the version needs to be updated to be improved, so that the first process function is applicable to more scenes, and the performance of the server is improved. Specifically, the method can be applied to the dynamic hot updating process of the game server based on the Golang language, so that function updating of the game server at the function level is realized under the condition that the current process is not stopped, the system stability and the function are not influenced, and the method is efficient, lossless and safe. The above list is an example, and this is not limited in this embodiment.
Optionally, in this embodiment, in a process of implementing the process updating method in a server developed by using a parallel programming language Golang, but not limited to, a process function (i.e., a first process function) to be changed may be compiled and linked into a dynamic link library file (i.e., the dynamic link compiled file may also be referred to as a ". so file"), and the dynamic link library file is dynamically loaded into a memory of the server, so that a first memory address of the first process function and a second memory address of a second process function used to replace the first process function are directly obtained by reloading a configuration file associated with the dynamic link library file. Therefore, the effect of simplifying the obtaining operation of obtaining the used memory address in the updating process is achieved. The configuration file may include, but is not limited to: an indication tag for indicating whether the current process needs to be updated (e.g. hot update), a file identifier (e.g. file name) of the dynamically linked compiled file, and a first function identifier of the first process function and a second function identifier of the second process function.
Optionally, in this embodiment, the manner of obtaining the first memory address and the second memory address by dynamically linking the dynamic symbol table in the compiled file may include, but is not limited to: and reflecting and finding the memory address of the code segment where the first process function and/or the second process function are/is located according to the symbol information in the dynamic symbol table. It should be noted that the dynamic symbol table may be, but is not limited to, acquired by using an binary executable file (ELF file) in Linux when a server runs.
In addition, in the present embodiment, the symbol information may refer to, but is not limited to, detailed information corresponding to the definition symbol of the symbol in the ELF file, including the name, address, size, type, and the like of the symbol. The address information of the symbol table in the memory of the server is obtained by adding the address offset recorded in the Global Offset Table (GOT) to the base address of the code segment (TEXT).
Optionally, in this embodiment, after the first memory address and the second memory address are obtained, but not limited to, obtaining a modification permission for modifying a code segment of a current process, so as to adjust a read-only permission to a modification permission allowing reading and writing. And then, modifying the code segment of the current process, and hijacking a function entry of the first process function to realize the adjustment of the first process function into a second process function, for example, updating a first memory address requested to be called in the calling instruction into a second memory address, so as to realize the hot update of the server process without stopping at a function level.
It should be noted that, by combining the above-mentioned reflection addressing method of the dynamic symbol table and the method of the code segment hijack function entry, it is possible to achieve the operation time consumption imperceptible (at most tens of milliseconds) hot update on the server using the Golang compiled language under the premise of not stopping (restarting the process), and not to affect the normal operation of the original program (i.e. the current process), so as to ensure the reliability and security of the server process during operation.
Optionally, in this embodiment, before acquiring the process update instruction, the method further includes: when a problem such as a code error or a running fault is found in the normal running process of the server, the developer needs to update the first process function (e.g., function F1) replacing the problem. On this premise, the compiled link generates a so file that contains a process function (e.g., function F2) for replacing a second process function (e.g., function F1) of the problem. And further, modifying the corresponding configuration file while generating the so file, packaging the so file and the modified configuration file into a differential packet, and issuing the differential packet to a machine environment where the server process is located. And after the server process receives the process updating instruction, reloading the configuration file to determine whether the current process needs to be subjected to hot updating. The number of the first process functions may include, but is not limited to, one or at least two process functions, and the second process functions may include, but is not limited to, the same number. The above-mentioned F1 and F2 are examples for identifying the first process function and the second process function differently, and are not intended to constitute limitations.
Note that, in a server using the gold compiled language, the.so file can be imported using a plug-in (plugin) module of the gold itself. Here, the plug-in the form of a so file may be, but is not limited to, a running main function (main) package containing exportable (capital) functions and variables. The so file is initialized only once, the dynamic symbol table is read into the originally running process, the symbols of the same symbol table are covered by the original process during binding, and the symbols cannot be closed. By compiling the option-trimpath, it is guaranteed that the original file and the so file are not checked for file consistency to avoid unnecessary problems.
Assume that the current process is exemplified by a process in a game server. In the related art, for a game server with recorded state, the game server is usually required to be stopped and restarted when the server process is updated, which means that a developer is required to spend a great deal of effort to maintain and restore the state of the server. Currently, the state maintenance and recovery techniques generally used include modes of sharing a memory and a database. In addition, after the shutdown, the original service needs to be maintained continuously, the service data in the current state needs to be handed over to other service processes, and the service data in the current state needs to be transferred back after the restart.
Specifically, fig. 3 is a flow chart illustrating updating of the current process using the related art. After the first and second process functions are determined, the game server is controlled to stop as in step S302, and then the service data of the current service state S1 is stored in the shared memory as in step S304-1, while the service is suspended, and the service handover is performed as in step S304-2. After the binary file is changed as in step S306, step S308 is performed to restart the game server. The binary file may be, but is not limited to, in step S305 before step S306, the modification update is implemented by hot fix. Then, in step S310, the previously suspended current service state is recovered S1, the service data corresponding to the current service state S1 is read from the shared memory, and in step S312, the service that has been handed over before is taken over, so as to complete the process updating process of replacing the first process function with the second process function. That is to say, the update method provided in the related art not only has complex operation, but also occupies a lot of resources in the server, and greatly affects the performance of the server.
In the embodiment of the present application, as shown in fig. 4, the game server does not need to be stopped and restarted, and the state maintenance and recovery, and the suspension of the service, the handover of the service, or the withdrawal of the service are not needed. That is to say, when the method provided in the embodiment of the present application is used, the dynamic link compilation file and the configuration file thereof are used to determine the first memory address of the first process function and the second memory address of the second process function, and hijack update is performed on the function entry for calling the first process function, and step S402 is executed to implement modification update from the first process function to the second process function through the hotfix. Therefore, the hot updating process of the server process is completed under the condition of not interrupting the process and the service, and the flow of the hot updating is greatly simplified.
The description is made with reference to the example shown in fig. 5:
in the preprocessing stage, when the server finds a code error or a running fault or other problems through the control system during normal operation, as in step S502, a process function (e.g., function F2) that needs to be updated and replaced by a first process function (e.g., function F1) and a second process function (e.g., function F1) is determined. Then, as in step S504, the local compilation generates a. Next, in step S506, the configuration file is modified, and the so file and the modified configuration file are packaged as a delta packet. The delta packet is then distributed to the machine environment of the server process, as shown in step S508.
In the update phase, it is assumed that the current process P1 in the server receives the process update instruction and the delta packet. Then as in steps S510-S512, in the event that it is determined that a hot update to the current process P1 is needed based on the indication tag in the configuration file, the delta package is deployed and the configuration file is reloaded. Then steps S514-S520 are executed: the so file is loaded and the function identification of function F1 and the function identification of function F2 are determined from the configuration file. Then, the ELF file is used to read the dynamic symbol table, and the memory address of the code segment in the function F1 and the memory address of the code segment in the function F2 after being loaded into the memory are obtained through reflection. Then, the read-write authority of the code segment is modified through the MPROtect system call of Linux, the code segment is changed from read-only to writable, and a function entry in a call instruction for calling the first process function is adjusted, so that the hot update is completed in the call function F1 and the redirection to the function F2 is realized. Therefore, function replacement when the F1 function is operated by the F2 function is realized, and the purpose of hot updating without shutdown is achieved.
Optionally, in this embodiment, after updating the first memory address to the second memory address, the method further includes: and restoring the read-write permission of the program code segment of the current process to be unmodified. That is, after the hot update is completed, the modified read-write permission needs to be restored and adjusted to the read-only permission again, so as to avoid the security problem caused by performing illegal editing operation on the code segment at will. If the MProtect system is used, the code segment authority is modified from writable to read-only.
According to the embodiment provided by the application, after the obtained process updating instruction is obtained, the dynamic link compilation file matched with the current process is loaded, and the first process function identifier of the first process function and the second function identifier of the second process function are obtained from the configuration file associated with the dynamic link compilation file. Further, a first memory address matched with the first function identifier and a second memory address matched with the second function identifier are obtained through a dynamic symbol table in a dynamic link compiling file. And then directly updating the first memory address into a second memory address. That is to say, the memory address of the called process function is directly updated to replace the first process function with the second process function, so that the update and replacement of the process function in the server process are completed on the premise of not needing to stop the machine and not interrupting the current process, the effect of smoothly and thermally updating the server process is achieved, and the problem of bad influence on the service quality caused by the fact that the machine is required to be stopped for updating in the related technology is solved.
As an optional scheme, obtaining, by dynamically linking a dynamic symbol table in a compiled file, a first memory address matching a first function identifier, and a second memory address matching a second function identifier includes:
s1, reading the symbol information in the dynamic symbol table;
s2, obtaining a first base address where the first process function is located and a first address offset matched with the first process function from the first program code segment in the memory of the current process according to the symbolic information; superposing a first address offset on the first base address to obtain a first memory address;
s3, according to the symbol information, from the second program code segment loaded with the dynamic link file in the memory of the current process, obtaining a second base address where the second process function is located and a second address offset matched with the second process function; and superposing a second address offset on the second base address to obtain a second memory address.
That is, in this embodiment, for a server process using the gold programming language, after acquiring a first base address of a first process function and a second base address of a second process function, but not limited to, acquiring an address Offset through a Program Link Table (PLT) and a Global Offset Table (GOT), and further acquiring a first memory address corresponding to the first process function and a second memory address corresponding to the second process function by using the base addresses and the address Offset. Where the PLT is used to redirect location independent function calls to absolute addresses. GOT acts similarly to PLT, both for indirect addressing.
It should be noted that, here, the first base address is an original address of the first process function in the program code section, and the second base address is an original address of the second process function in the program code section. Wherein the original address is the current storage address of the process function. Here, the address offset is used to indicate an offset address, which is an offset of an address in a segment with respect to a segment start address after a memory in the computer is segmented.
Optionally, in this embodiment, obtaining, from the first program code segment in the memory of the current process according to the symbol information, the first base address where the first process function is located and the first address offset matching the first process function includes: acquiring a first base address indicated by the symbol information; searching a first address offset through a program link table corresponding to the current process; under the condition that the first process function is not executed, calculating by using a global offset table to obtain a first address offset; acquiring a second base address where a second process function is located and a second address offset matched with the second process function from a second program code segment loaded with a dynamic link file in a memory of a current process according to symbol information, wherein the second program code segment comprises: acquiring a second base address indicated by the symbol information; searching a second address offset through a program link table corresponding to the current process; in the case that the second process function has not been executed, a second address offset is computed using the global offset table.
In particular, assume that a server process in a server using the Golang programming language is still used as an example for explanation. In the embodiment, after the reading configuration file obtains the second function identifier of the second process function, the symbol information in the dynamic symbol table of the so file dynamically loaded into the memory can be read through the ELF file, but is not limited to the ELF file.
For example, as shown in fig. 6, it is assumed that the virtual address space of the current process,. text represents the program code segment,. data is the program data segment, and GOT is the global offset table for the chained offset addressing. In fig. 6, the bottom part shows the code segment, text and data segment, data of the original program in the current process, and the top part of fig. 6 shows the code segment, text and data segment, data of the loaded so file. In the example of the hypothetical scenario shown in the figure, it is assumed that the base address of the second process function (e.g., say, 0x20000000, which is calculated by using GOT, then the actual memory address of the second process.
The process of addressing with PLTs and GOT in the above example can be explained as follows in conjunction with fig. 7:
in this example, the PLT provides a mechanism for delayed binding. As shown in fig. 7, when a function (Code box in the figure) f (x) needs to be called, a PLT (PLT box in the figure) is entered first, and when a jump instruction "jmp × GOT [ n ]" in the PLT is executed, the address offset is searched by jumping to a GOT (GOT box in the figure). If the currently called function f (x) has not been executed yet, GOT [ n ] is equal to 0, and the dynamic binding process (i.e. calculating the address offset and then filling the address offset into GOT) is entered. If the function F (x) is executed, the address of the jump can be determined by using the obtained address offset, and then the jump is directly carried out to the corresponding function F (x).
According to the embodiment provided by the application, the first memory address of the first process function and the second memory address of the second process function are determined by combining the program link table and the global offset table, wherein the memory addresses are unchanged in the running period of the current process. By adopting the delayed binding mode, the processing load of the server can be reduced when the function is called at high frequency so as to avoid the influence on the performance of the server, and the memory address is determined by the mode, so that the processing efficiency of the server is improved.
As an optional scheme, the updating the first memory address to the second memory address includes:
s1, replacing the first memory address in the call instruction with a jump instruction when the read/write permission of the program code segment of the current process is adjusted to allow modification, where the jump instruction is used to instruct jumping to the second memory address, so as to replace the first process function with the second process function.
It should be noted that the manner of updating the first memory address to the second memory address in the call instruction may include, but is not limited to: and injecting a jump instruction at a function inlet for calling the first process function, so that the current process can directly jump to a second memory address of the second process function according to the jump instruction when calling the first process function. This updating method is an example, and this is not limited in this embodiment.
The description is made with reference to the example shown in fig. 8: assume that the server on which the current process is running is in the machine environment of the X86 architecture. The compilation of the Golang bottom layer is a Plan9 compilation. That is, in step S802, Plan9 assembly language is generated by compiling Golang source code, and in steps S804-S806, executable files are obtained by compiling and linking through an assembler. The executable file may be a binary file (bin file) of X86 machine code, the same as a binary file obtained after assembly linking of an assembler written in X86 assembly language. Machine code modification herein may refer, but is not limited to, machine code of X86. The binary file of the X86 machine code can be disassembled to obtain the X86 assembly language as step S808-1, and can also be disassembled to obtain the Plan9 assembly language as step S808-2. In addition, the X86 assembly language may be connected to a linker through an assembler assembly in step S810 to obtain a binary file (bin file) of the X86 machine code. The above is an example, and this is not limited in this embodiment.
It should be noted that the inserted code may be a jump instruction of X86 (jmp, the corresponding machine code opcode is 0xe9), for example, the function entry of the original first process function is replaced by the jmp instruction, and the addressing address is the memory address of the second process function, so as to achieve the purpose of directly jumping to the second process function when calling the first process function.
According to the embodiment provided by the application, the jump instruction can be used for replacing the first memory address in the call instruction, so that when the first memory address is called, the jump instruction is redirected to the second memory address indicated by the jump instruction, and therefore the hot updating process of replacing and updating the first process function into the second process function is completed on the premise of restarting without stopping.
As an optional scheme, the updating the first memory address to the second memory address includes:
s1, storing the second memory address into the target stack;
s2, replacing the first memory address in the call instruction with a return instruction when the read/write permission of the program code segment of the current process is adjusted to allow modification, where the return instruction is used to instruct reading the second memory address from the target stack, so as to replace the first process function with the second process function.
It should be noted that the stack is a data structure that allows a special linear table of insert and express operations to be performed at the same end. Inserting/writing data may be referred to as pushing and deleting/reading data may be referred to as popping.
The maximum jump distance of the jump instruction is 231Is (2 Gb), but a 64-bit operating system reads the so file, the jump distance may be greater than 231In order to meet the requirement of a new jump distance, in this embodiment of the application, the second memory address of the second process function may be pushed to the target stack, and then a return instruction is called, where the return instruction may take the second memory address of the second process function from the target stack and jump.
According to the embodiment provided by the application, the target stack can be used for temporarily storing the second memory address, and the second memory address in the stack is taken out when the first memory address is called through the return instruction (return), so that the hot updating process of replacing the first process function with the second process function is completed on the premise of restarting without stopping.
As an optional scheme, before loading the dynamically linked compiled file matching the current process, the method further includes:
s1, receiving a differential data packet obtained by packaging the dynamic link compiling file and the configuration file;
s2, in the case where the tag value of the profile record in the delta data packet indicates a target value, it is determined that the current process is updated.
It should be noted that, the configuration file may include, but is not limited to: an indication tag for indicating whether the current process needs to be updated (e.g. hot update), a file identifier (e.g. file name) of the dynamically linked compiled file, and a first function identifier of the first process function and a second function identifier of the second process function. Here, the indication tag may be needlehotfix, and the corresponding target value may be, but is not limited to "true". In other words, when the needleHotFix tag value is true, a hot update module in the server is started, and the so file is loaded to realize the hot update process from the first process function to the second process function.
By the embodiment provided by the application, in the process of realizing the hot update of the first process function to the second process function, the differential packet is transferred instead of the full packet. That is to say, the process updating process provided in the embodiment of the present application will also occupy less data transmission resources, thereby greatly improving the data transmission efficiency and further improving the process updating efficiency.
As an optional scheme, before receiving a delta data packet obtained by encapsulating the dynamic link compilation file and the configuration file, the method further includes:
and S1, adding a link label on an address corresponding to the private variable in the dynamic link compilation file under the condition that the invisible private variable is included in the first process function, wherein the link label is used for indicating a link target object to replace the compilation of the private variable.
It should be noted that, in this embodiment, the first process function may include a private variable, or the first process function may be a private function or a private function including similar private variables. That is, there is an access right restriction in the first process function, and not all the function contents are visible.
In order to avoid the compiling error caused by direct access, in the server using the Golang compiling type language in the embodiment of the present application, a go: linkname tag can be used, but not limited to, to specify a link target, so as to bypass the checking of the compiler, thereby avoiding the above-mentioned problems caused by invisibility.
With the embodiments provided by the present application, in the case where an invisible private variable is included in the first process function, the compilation of the private variable may be replaced by adding a link tag for linking to the target object. Therefore, the compiling problem when the first process function containing the private variable is subjected to hot updating is reduced, the second process function after the hot updating is ensured to be normally used, and unnecessary faults are avoided.
The description is made with specific reference to the following examples: assume still that a scenario of a server process performing a hot update in a game server developed based on the Golang programming language is taken as an example for illustration. Further assuming that a jump instruction is taken as an example, the hot update process for the current process may be as follows:
during the operation of the game server, it is detected that the function of the first process function in the current process needs to be modified. Assume that the first process function includes two functions:
function 1 gameutil/communils
Say function 2 gameutil/communilitis
Wherein, the gameutil/commenting is the packet name of the function, the (. StHot) represents the member function of the class StHot, the function names of the two functions are Say, the difference is that the first is the member function of the class, and the second is the common function.
The substitution function (i.e., the second process function) implementing substitution function 1 is named Say, the substitution function (i.e., the second process function) implementing function 2 is named NewSay. The implemented code is compiled and linked into a so file, such as a hot fix so.1.so file. Let us say/hot fix/main/"before the hot fix.1. so file is the relative path of the file.
And packaging and sending the compiled and linked hot fix so.1.so as to the machine environment where each server process needing to be updated is located, and sending a program updating instruction so as to inform each server process needing to be updated to carry out heavy load configuration.
After the server process reloads the configuration, the needleHotFix tag value is determined to be true from the configuration file, then a hot update module is started, and the so file is loaded into the memory, and the reflective addressing is carried out according to the dynamic symbol table in the so file, so as to find out the memory addresses (namely the first memory address) of the function 1 and the function 2 in the code segment. Then, the code segment is modified, and a jump instruction is injected into the call instruction, so that functional jumps from the function 1 and the function 2 to the corresponding alternative functions respectively are realized.
In the subsequent program running process, when the function 1 or the function 2 is executed, the function jumps to the second memory address corresponding to the substitute function through the jump instruction, so that the function repair of the function level in the server process is realized.
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 embodiment of the present invention, a process updating apparatus for implementing the process updating method is also provided. As shown in fig. 9, the apparatus includes:
1) the first processing unit 902 is configured to obtain a process update instruction, and load a dynamic link compilation file matched with a current process;
2) a first obtaining unit 904, configured to obtain, from a configuration file associated with the dynamic link compilation file, a first function identifier of a first process function and a second function identifier of a second process function, where the first process function is a process function requested to be called in a current process call instruction, and the second process function is used to replace the first process function;
3) a second obtaining unit 906, configured to obtain, through a dynamic symbol table in the dynamic link compilation file, a first memory address matched with the first function identifier and a second memory address matched with the second function identifier;
4) an updating unit 908 is configured to update the first memory address to a second memory address, so as to replace the first process function with a second process function.
In this embodiment of the application, the process updating apparatus may be, but is not limited to, applied to a server, and for an embodiment of the process updating apparatus, reference may be made to the foregoing method embodiment, which is not described herein again.
According to another aspect of the embodiment of the present invention, there is also provided an electronic device for implementing the process updating method, where the electronic device may be a server shown in fig. 1. As shown in fig. 10, the electronic device comprises a memory 1002 and a processor 1004, the memory 1002 having stored therein a computer program, the processor 1004 being arranged to execute the steps of any of the method embodiments described above by means of the computer program.
Optionally, in this embodiment, the electronic device may be located in at least one network device of a plurality of network devices of a computer network.
Optionally, in this embodiment, the processor may be configured to execute the following steps by a computer program:
s1, acquiring a process updating instruction, and loading a dynamic link compiling file matched with the current process;
s2, acquiring a first function identifier of a first process function and a second function identifier of a second process function from a configuration file associated with the dynamic link compilation file, wherein the first process function is a process function requested to be called in a current process calling instruction, and the second process function is used for replacing the first process function;
s3, acquiring a first memory address matched with the first function identifier and a second memory address matched with the second function identifier through dynamically linking a dynamic symbol table in the compiled file;
s4, the first memory address is updated to the second memory address, so as to replace the first process function with the second process function.
Alternatively, it can be understood by those skilled in the art that the structure shown in fig. 10 is only an illustration, and the electronic device may also be a terminal device such as a smart phone (e.g., an Android phone, an iOS phone, etc.), a tablet computer, a palmtop computer, a Mobile Internet Device (MID), a PAD, and the like. Fig. 10 is a diagram illustrating a structure of the electronic device. For example, the electronics may also include more or fewer components (e.g., network interfaces, etc.) than shown in FIG. 10, or have a different configuration than shown in FIG. 10.
The memory 1002 may be used to store software programs and modules, such as program instructions/modules corresponding to the process updating method and apparatus in the embodiment of the present invention, and the processor 1004 executes various functional applications and data processing by running the software programs and modules stored in the memory 1002, that is, implementing the process updating method described above. The memory 1002 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 1002 may further include memory located remotely from the processor 1004, 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. The memory 1002 may be used for storing information such as a dynamic link compilation file and a configuration file, but is not limited thereto. As an example, as shown in fig. 10, the memory 1002 may include, but is not limited to, a first processing unit 902, a first obtaining unit 904, a second obtaining unit 906, and an updating unit 908 in the process updating apparatus. In addition, other module units in the above process updating apparatus may also be included, but are not limited to these, and are not described in detail in this example.
Optionally, the above-mentioned transmission device 1006 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 1006 includes a Network adapter (NIC) that can be connected to a router via a Network cable and other Network devices so as to communicate with the internet or a local area Network. In one example, the transmission device 1006 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 display 1008 for displaying the information of the order to be processed; and a connection bus 1010 for connecting the respective module parts in the above-described electronic apparatus.
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.
According to an aspect of the application, a computer program product or computer program is provided, comprising computer instructions, the computer instructions being 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, so that the computer device executes the process updating method.
Alternatively, in the present embodiment, the above-mentioned computer-readable storage medium may be configured to store a computer program for executing the steps of:
s1, acquiring a process updating instruction, and loading a dynamic link compiling file matched with the current process;
s2, acquiring a first function identifier of a first process function and a second function identifier of a second process function from a configuration file associated with the dynamic link compilation file, wherein the first process function is a process function requested to be called in a current process calling instruction, and the second process function is used for replacing the first process function;
s3, acquiring a first memory address matched with the first function identifier and a second memory address matched with the second function identifier through dynamically linking a dynamic symbol table in the compiled file;
s4, the first memory address is updated to the second memory address, so as to replace the first process function with the second process function.
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 a program instructing hardware associated with the terminal device, 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 several instructions for causing one or more computer devices (which may be personal computers, servers, network devices, etc.) to execute all or part of the steps of the method 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 division of the units is only one type of division of logical functions, and there may be other divisions when actually implemented, for example, a plurality of units or components may be combined or may be 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 (11)
1. A process update method, comprising:
acquiring a process updating instruction, and loading a dynamic link compiling file matched with the current process;
acquiring a first function identifier of a first process function and a second function identifier of a second process function from a configuration file associated with the dynamic link compilation file, wherein the first process function is a process function requested to be called in a current process calling instruction, and the second process function is used for replacing the first process function;
acquiring a first memory address matched with the first function identifier and a second memory address matched with the second function identifier through a dynamic symbol table in the dynamic link compilation file;
and updating the first memory address to the second memory address so as to replace the first process function with the second process function.
2. The method of claim 1, wherein obtaining a first memory address matching the first function identifier and a second memory address matching the second function identifier via a dynamic symbol table in the dynamic link compilation file comprises:
reading symbol information in the dynamic symbol table;
acquiring a first base address of the first process function and a first address offset matched with the first process function from a first program code segment in the memory of the current process according to the symbol information; superposing the first address offset on the first base address to obtain the first memory address;
according to the symbol information, a second program code segment of the dynamic link file is loaded from a memory of the current process, and a second base address where the second process function is located and a second address offset matched with the second process function are obtained; and superposing the second address offset on the second base address to obtain the second memory address.
3. The method of claim 2,
the obtaining, from a first program code segment in the memory of the current process according to the symbol information, a first base address where the first process function is located and a first address offset matched with the first process function includes: acquiring the first base address indicated by the symbol information; searching the first address offset through a program link table corresponding to the current process; under the condition that the first process function is not executed, calculating the first address offset by using a global offset table;
the obtaining, from the second program code segment loaded with the dynamic link file from the memory of the current process according to the symbol information, a second base address where the second process function is located and a second address offset matched to the second process function includes: acquiring the second base address indicated by the symbol information; searching the second address offset through a program link table corresponding to the current process; calculating the second address offset using a global offset table if the second process function has not been executed.
4. The method of claim 1, wherein updating the first memory address to the second memory address comprises:
and replacing the first memory address in the call instruction with a jump instruction under the condition that the read-write permission of the program code segment of the current process is adjusted to be allowed to be modified, wherein the jump instruction is used for indicating to jump to the second memory address so as to replace the first process function with the second process function.
5. The method of claim 1, wherein updating the first memory address to the second memory address comprises:
storing the second memory address into a target stack;
and replacing the first memory address in the call instruction with a return instruction under the condition that the read-write permission of the program code segment of the current process is adjusted to allow modification, wherein the return instruction is used for indicating that the second memory address is read from the target stack so as to replace the first process function with the second process function.
6. The method according to claim 4 or 5, further comprising, after the updating the first memory address to the second memory address:
and restoring the read-write permission of the program code segment of the current process to be not modifiable.
7. The method according to any one of claims 1 to 5, further comprising, before the loading the dynamically linked compiled file matching the current process:
receiving a differential data packet obtained by packaging the dynamic link compiling file and the configuration file;
determining to update the current process if the tag value of the profile record in the delta data packet indicates a target value.
8. The method of claim 7, further comprising, before said receiving delta data packets obtained by encapsulating said dynamically linked compiled file and said configuration file:
and under the condition that the first process function comprises an invisible private variable, adding a link label on an address corresponding to the private variable in the dynamic link compiling file, wherein the link label is used for indicating a link target object to replace compiling of the private variable.
9. A process update apparatus, comprising:
the first processing unit is used for acquiring a process updating instruction and loading a dynamic link compiling file matched with the current process;
a first obtaining unit, configured to obtain, from a configuration file associated with the dynamic link compilation file, a first function identifier of a first process function and a second function identifier of a second process function, where the first process function is a process function requested to be called in a current process call instruction, and the second process function is used to replace the first process function;
a second obtaining unit, configured to obtain, through a dynamic symbol table in the dynamic link compilation file, a first memory address matching the first function identifier and a second memory address matching the second function identifier;
an updating unit, configured to update the first memory address to the second memory address, so as to replace the first process function with the second process function.
10. A computer-readable storage medium comprising a stored program, wherein the program when executed performs the method of any of claims 1 to 8.
11. 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 8 by means of the computer program.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202010671460.2A CN111782302B (en) | 2020-07-13 | 2020-07-13 | Process updating method and device, storage medium and electronic equipment |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202010671460.2A CN111782302B (en) | 2020-07-13 | 2020-07-13 | Process updating method and device, storage medium and electronic equipment |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN111782302A true CN111782302A (en) | 2020-10-16 |
| CN111782302B CN111782302B (en) | 2021-05-14 |
Family
ID=72767618
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202010671460.2A Active CN111782302B (en) | 2020-07-13 | 2020-07-13 | Process updating method and device, storage medium and electronic equipment |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN111782302B (en) |
Cited By (7)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN112988570A (en) * | 2021-02-08 | 2021-06-18 | 芯华章科技股份有限公司 | Method for debugging program, electronic equipment and storage medium |
| CN113110925A (en) * | 2021-04-09 | 2021-07-13 | 杭州复杂美科技有限公司 | Block packing method and equipment based on parallel execution and storage medium |
| CN113110865A (en) * | 2021-04-21 | 2021-07-13 | 北京字跳网络技术有限公司 | Server hot updating method and device |
| CN113688048A (en) * | 2021-08-27 | 2021-11-23 | 北京字节跳动网络技术有限公司 | Application stability detection method and device, electronic equipment and storage medium |
| CN113791809A (en) * | 2021-11-11 | 2021-12-14 | 腾讯科技（深圳）有限公司 | Application exception handling method and device and computer readable storage medium |
| CN115017058A (en) * | 2022-08-04 | 2022-09-06 | 飞腾信息技术有限公司 | Test method and device of kernel module, electronic equipment and storage medium |
| CN115640037A (en) * | 2022-09-09 | 2023-01-24 | 北京畅游创想软件技术有限公司 | Program updating method and device |
Citations (8)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN104239082A (en) * | 2013-06-20 | 2014-12-24 | 上海博达数据通信有限公司 | Hot patching implementation method of embedded system |
| CN105677435A (en) * | 2015-12-30 | 2016-06-15 | 小米科技有限责任公司 | Function invoking method, apparatus and terminal |
| CN106371940A (en) * | 2015-07-21 | 2017-02-01 | 腾讯科技（深圳）有限公司 | Solution method and device for program crash |
| CN106775671A (en) * | 2016-11-30 | 2017-05-31 | 武汉虹信通信技术有限责任公司 | A kind of hot patch restorative procedure in the linux environment for communication system |
| CN108595218A (en) * | 2018-04-17 | 2018-09-28 | 网宿科技股份有限公司 | A kind of method and apparatus of loading system dynamic base |
| CN109831476A (en) * | 2018-12-15 | 2019-05-31 | 中国平安人寿保险股份有限公司 | Installation kit method for down loading, device, electronic equipment and storage medium |
| US10310863B1 (en) * | 2013-07-31 | 2019-06-04 | Red Hat, Inc. | Patching functions in use on a running computer system |
| CN111309334A (en) * | 2020-02-18 | 2020-06-19 | 北京奇艺世纪科技有限公司 | Method and device for generating software installation package, computer equipment and storage medium |
-
2020
- 2020-07-13 CN CN202010671460.2A patent/CN111782302B/en active Active
Patent Citations (8)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN104239082A (en) * | 2013-06-20 | 2014-12-24 | 上海博达数据通信有限公司 | Hot patching implementation method of embedded system |
| US10310863B1 (en) * | 2013-07-31 | 2019-06-04 | Red Hat, Inc. | Patching functions in use on a running computer system |
| CN106371940A (en) * | 2015-07-21 | 2017-02-01 | 腾讯科技（深圳）有限公司 | Solution method and device for program crash |
| CN105677435A (en) * | 2015-12-30 | 2016-06-15 | 小米科技有限责任公司 | Function invoking method, apparatus and terminal |
| CN106775671A (en) * | 2016-11-30 | 2017-05-31 | 武汉虹信通信技术有限责任公司 | A kind of hot patch restorative procedure in the linux environment for communication system |
| CN108595218A (en) * | 2018-04-17 | 2018-09-28 | 网宿科技股份有限公司 | A kind of method and apparatus of loading system dynamic base |
| CN109831476A (en) * | 2018-12-15 | 2019-05-31 | 中国平安人寿保险股份有限公司 | Installation kit method for down loading, device, electronic equipment and storage medium |
| CN111309334A (en) * | 2020-02-18 | 2020-06-19 | 北京奇艺世纪科技有限公司 | Method and device for generating software installation package, computer equipment and storage medium |
Cited By (10)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN112988570A (en) * | 2021-02-08 | 2021-06-18 | 芯华章科技股份有限公司 | Method for debugging program, electronic equipment and storage medium |
| CN112988570B (en) * | 2021-02-08 | 2023-03-10 | 芯华章科技股份有限公司 | Method for debugging program, electronic equipment and storage medium |
| CN113110925A (en) * | 2021-04-09 | 2021-07-13 | 杭州复杂美科技有限公司 | Block packing method and equipment based on parallel execution and storage medium |
| CN113110865A (en) * | 2021-04-21 | 2021-07-13 | 北京字跳网络技术有限公司 | Server hot updating method and device |
| CN113688048A (en) * | 2021-08-27 | 2021-11-23 | 北京字节跳动网络技术有限公司 | Application stability detection method and device, electronic equipment and storage medium |
| CN113791809A (en) * | 2021-11-11 | 2021-12-14 | 腾讯科技（深圳）有限公司 | Application exception handling method and device and computer readable storage medium |
| CN115017058A (en) * | 2022-08-04 | 2022-09-06 | 飞腾信息技术有限公司 | Test method and device of kernel module, electronic equipment and storage medium |
| CN115017058B (en) * | 2022-08-04 | 2022-11-29 | 飞腾信息技术有限公司 | Test method and device of kernel module, electronic equipment and storage medium |
| CN115640037A (en) * | 2022-09-09 | 2023-01-24 | 北京畅游创想软件技术有限公司 | Program updating method and device |
| CN115640037B (en) * | 2022-09-09 | 2023-08-11 | 北京畅游创想软件技术有限公司 | Program updating method and device |
Also Published As
| Publication number | Publication date |
|---|---|
| CN111782302B (en) | 2021-05-14 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN111782302B (en) | Process updating method and device, storage medium and electronic equipment | |
| CN107506221B (en) | Application program upgrading method, device and equipment | |
| CN111666096B (en) | Hot updating method and device for target application, storage medium and electronic equipment | |
| CN105511911B (en) | The generation method and device of system firmware upgrade package | |
| CN103077043B (en) | A kind of method of quick Start-up and operating performance Linux | |
| US20170154017A1 (en) | Web Application Management | |
| CN110995473B (en) | Service node control method and related equipment | |
| CN103559065B (en) | Method and system for OTA (Over-the-Air Technology) upgrade | |
| CN104915263A (en) | Process fault processing method and device based on container technology | |
| CN105574411A (en) | Dynamic unshelling method, device and equipment | |
| CN110569108B (en) | Method for creating execution environment of mini-game virtual machine and related product | |
| CN103902265A (en) | Application implementation method and application implementation device | |
| CN110673837B (en) | Code repairing method and device, electronic equipment and computer readable storage medium | |
| CN108509215A (en) | A kind of replacing options of system software, device, terminal device and storage medium | |
| CN109800005B (en) | Client hot update method and device | |
| CN112099800A (en) | Code data processing method and device and server | |
| US20120222023A1 (en) | Automatic runtime dependency lookup | |
| CN113821226A (en) | ONIE system installation method, apparatus, device and medium | |
| CN113110865A (en) | Server hot updating method and device | |
| CN108228266A (en) | Start the method and apparatus of Fragment components under a kind of Android card cages between different plug-in units | |
| CN109656611A (en) | Three-dimensional visualization applies hot update method, device and terminal | |
| CN109190367A (en) | Utilize the method and device of sandbox operation application program installation kit | |
| CN106022125B (en) | A kind of restorative procedure and device of client | |
| CN114860202A (en) | Project operation method, device, server and storage medium | |
| CN114610516A (en) | Application program repairing method and device, computer equipment and storage medium |
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 | ||
| REG | Reference to a national code |
Ref country code: HK Ref legal event code: DE Ref document number: 40030710 Country of ref document: HK |
|
| GR01 | Patent grant | ||
| GR01 | Patent grant |