WO2011116672A1

WO2011116672A1 - Method and apparatus for patching shared code segment

Info

Publication number: WO2011116672A1
Application number: PCT/CN2011/071991
Authority: WO
Inventors: 陈福军
Original assignee: 成都市华为赛门铁克科技有限公司
Priority date: 2010-03-26
Filing date: 2011-03-21
Publication date: 2011-09-29
Also published as: CN101794272B; CN101794272A

Abstract

The embodiment of the invention provides a method and a device for patching a shared code segment. The method for patching the shared code segment includes the following steps: before a primitive function is patched, modifying a first instruction of the primitive function into an instruction for jumping to an exception handling in a shared memory, wherein the primitive function is a shared function that needs to be patched; sending a first interrupt message to each service VCPU (virtual CPU), wherein the first interrupt information is used to indicate each service VCPU to interrupt current services and instantly refresh its fast instruction buffer; modifying the first instruction and a second instruction of the primitive function into instructions for jumping to a patching function; and sending a second interrupt information to each service VCPU to indicate each service VCPU to interrupt the current services and instantly refresh its fast instruction buffer. The embodiment of the invention realizes patching the shared code segment and enabling the patch to take effect quickly without interfering with the normal service processing of the service VCPUs.

Description

Method and apparatus for patching shared code segments This application claims to be filed on March 26, 2010, the Chinese Patent Office, Application No. 201010138932.4. The Chinese patent application entitled "Method and Apparatus for Patching Shared Code Segments" Priority is hereby incorporated by reference in its entirety. The present invention relates to the field of computer technologies, and in particular, to a method and apparatus for patching shared code segments.

Background technique

Patch technology is gaining more and more attention as an upgrade tool. In the process of running a computer system, some errors in the software often cause abnormalities or crashes in the system. To compensate for such errors, patch software can be used to upgrade the software in question. In this process, it will not affect the processing of normal business.

Errors in the software often exist in one or more functions, and these erroneous primitives are called by other functions. Although it is difficult to find these calling functions, it is easy to find the original function of the error. Therefore, the key operations of patching should focus on the original function of these errors. The process of patching is: when calling the original function of these errors, jump from the wrong original function to the modified function (that is, the patch function), and then return to the calling function after executing the patch function. In this way, the software will never execute the wrong original function, thus completing the modification of the software.

In the multi-core processor environment, in the existing method of patching the shared code segment, the main virtual CPU (VCPU) VCPU sends a synchronization message to all service VCPUs executing the shared code segment, and notifies each service VCPU that the service VCPU needs to perform Patch operation. After receiving the synchronization message, each service VCPU stops its normal service processing, enters the waiting for patching state, and sends a response message to the primary VCPU to notify itself that it has entered the waiting state. After receiving the response message of all the VCPUs of the service, the main VCPU modifies the instructions in the original function that needs to be patched, and then performs the patching operation procedure to enable the service.

The VCPU jumps from the original function to the patch function when it executes the original function. After modifying the instructions, to all services The VCPU sends a completion synchronization message to notify all service VCPU that the patch operation has been completed. After receiving the synchronization message for completing the patch operation, all service VCPUs refresh their respective fast instruction buffers to make the modified instructions take effect, and then perform normal service processing. In this solution, although the problem that the main VCPU interacts with the service VCPU during the patch operation is avoided, that is, when the main VCPU modifies the instruction, there is no service VCPU executing to the current modification instruction.

In the process of implementing the present invention, the inventors have found that at least the following problems exist in the prior art: In the existing solution, after the primary VCPU sends the patched synchronization message to all service VCPUs, it needs to receive the response message sent by all service VCPUs. The shared code segment can be patched; and all service VCPUs can perform normal service processing only after receiving the synchronization message of the completion patch operation sent by the primary VCPU. Therefore, if the current service of a service VCPU is busy, after receiving the patched synchronization message sent by the primary VCPU, the response message cannot be sent to the primary VCPU in time, causing other service VCPUs and the primary VCPU to enter the waiting for patching. status. As a result, the patch takes effect for a long time, which prevents other services VCPUs from processing services.

Summary of the invention

The embodiment of the present invention provides a method and a device for patching a shared code segment, which is used to solve the defect that the patch is valid for a shared code segment, and the patch takes effect for a long time, which affects the normal processing service of the service VCPU. Patching the shared code segment and making the patch take effect quickly without affecting the normal business processing of the service VCPU.

An embodiment of the present invention provides a method for patching a shared code segment, including:

Before patching the original function, in the shared memory, the first instruction of the original function is modified to jump to the exception handling instruction, and the original function is a shared function that needs to be patched;

Sending a first interrupt message to the service VCPU, where the first interrupt information is used to indicate that the service VCPU interrupts the current service, and refreshes its own fast instruction buffer;

In the shared memory, modifying the first instruction and the second instruction of the original function into an instruction to jump to the patch function, so that the service VCPU executing the original function is executed from the original function Jumping to the patch function, the patch function is a function that replaces the original function;

Sending a second interrupt information to the service VCPU, where the second interrupt information is used to instruct the service VCPU to interrupt the current service and refresh its own fast instruction buffer. The embodiment of the present invention provides a method for patching a shared code segment, including: after receiving the first interrupt information sent by the main VCPU, interrupting the current service according to the instruction of the first interrupt information, and refreshing the fast instruction buffer. So that the instruction in the fast instruction buffer of the service VCPU itself is updated synchronously with the instruction in the shared memory, and the original function is a function that needs to be patched;

When the first instruction of the original function is executed, according to the first instruction of the original function, an exception processing is entered, in which the patch function is found in the patch area according to the first address of the original function. a first address, the patch function is a function that replaces the original function; and jumps from the exception processing to the patch function according to a first address of the patch function;

Receiving, according to the indication of the first interrupt information, interrupting the current service, and after refreshing the fast instruction buffer, receiving the second interrupt information sent by the primary VCPU;

And interrupting the current service according to the indication of the second interrupt information, and refreshing the fast instruction buffer area of the service, so that the instruction in the fast instruction buffer of the service VCPU itself is updated synchronously with the instruction in the shared memory.

An embodiment of the present invention provides an apparatus for patching a shared code segment, including:

a first modification module, configured to modify, in the shared memory, the first instruction of the original function to jump to an exception processing instruction before the original function is patched, where the original function is a shared function that needs to be patched; An interrupt module, configured to: after the first modification module in the shared memory, modify the first instruction of the original function to jump to the exception processing instruction, send a first interrupt message to the service VCPU, where the interrupt information is Used to instruct the service VCPU to interrupt the current service and refresh its own fast instruction buffer;

a first patch module, configured to: after the first interrupt module sends the first interrupt information to the service VPCU, in the shared memory, modify the first instruction and the second instruction of the original function to Jumping to an instruction of the patch function, so that the service VCPU executing to the original function jumps from the original function to the patch function, and the patch function is a function that replaces the original function;

a second interrupt module, configured to: after the first patch module in the shared memory, modify the first instruction and the second instruction of the original function to jump to a patch function, The service VPCU sends a second interrupt message.

a first refreshing module, configured to receive the first interrupt information sent by the main VCPU, according to the first An interrupt instruction indicates that the current service is interrupted, and the fast instruction buffer is refreshed, so that the instruction in the fast instruction buffer of the service VCPU itself is updated synchronously with the instruction in the shared memory, and the original function needs to be patched. The function;

a first exception processing module, configured to: after the first refresh module refreshes the fast instruction buffer, execute the first instruction to the original function, according to the first instruction of the original function, enter an exception processing, In the exception processing, according to the first address of the original function, the first address of the patch function is found in the patch area, and the patch function is a function that replaces the original function;

a first patch function execution module, configured to: after the first exception processing module finds the first address of the patch function, jump from the exception processing to the patch function according to a first address of the patch function carried out;

a second refreshing module, configured to: after the first refreshing module interrupts the current service according to the indication of the first interrupt information, and after refreshing the fast instruction buffer, receive the second interrupt information sent by the primary VCPU, according to the The indication of the second interrupt information, interrupting the current service, refreshing its own fast instruction buffer, so that the instruction in the fast instruction buffer of the service VCPU itself is updated synchronously with the instruction in the shared memory

In the embodiment of the present invention, a method and a device for patching a shared code segment are performed. In the running process of the multi-core processor system, before the main VCPU performs a patching operation on the original function, the first instruction of the original function is first modified to jump to The exception-handled instruction sends an interrupt message to the service VCPU, causing the service VCPU to immediately flush the fast instruction buffer. In the embodiment of the present invention, after receiving the interrupt information sent by the main CPU, the service VCPU does not need to send a response message to the main VCPU; and after the main CPU sends the interrupt information to the service VCPU, the original function can be patched. The embodiment of the invention enables the patch to take effect quickly. In addition, when the main VCPU patches the original function, if the service VCPU executes the original function, it enters the patch function from the exception processing, which ensures that the main VCPU performs the normal patching operation on the original function. Therefore, in the embodiment of the present invention, the method for patching the shared code segment, when the main VCPU patches the original function, does not affect the normal service processing of the service VCPU, and can also execute the service VCPU from the original function to the original function. Jump to the patch function to execute.

Before patching the original function, in the shared memory, the first instruction of the original function is modified to jump to the exception handling instruction, and the original function is a function that needs to be patched;

Sending a first patch activation message to each service VCPU, where the first patch activation message is used to indicate The service VCPU refreshes its own fast instruction buffer after processing the current service, so that the instruction in the fast instruction buffer of the service VCPU itself is updated synchronously with the instruction in the shared memory; indicating the last fast instruction of refreshing itself The VCPU of the buffer modifies the first instruction and the second instruction of the original function in the shared memory before refreshing its own fast instruction buffer.

The service VCPU receives the first patch activation message sent by the primary VCPU.

When the service VCPU is the last service VCPU that refreshes its own fast instruction buffer, according to the instruction of the first patch activation message, the first instruction and the second instruction of the original function are modified in the shared memory to The instruction that jumps to the patch function, the original function is a function that needs to be patched;

The service VCPU refreshes its own fast instruction buffer, and the other VCPUs other than the service VCPU that refreshes its own fast instruction buffer are refreshed by the main VCPU to refresh its own fast instruction buffer. The instruction in the fast instruction buffer of the service VCPU itself is updated synchronously with the instruction in the shared memory.

a third modification module, configured to modify, in the shared memory, the first instruction of the original function to jump to an exception processing instruction before the original function is patched, where the original function is a function that needs to be patched; a message sending module, configured to: in the shared memory, modify the first command of the original function to jump to the instruction of the exception processing, and send a first patch activation message to each service VCPU, where The first patch activation message is used to indicate that the service VCPU refreshes its own fast instruction buffer after processing the current service, so that the instruction in the fast instruction buffer of the service VCPU itself is updated synchronously with the instruction in the shared memory. ; indicates the last refresh of its own fast instruction buffer

The VCPU modifies the first instruction and the second instruction of the original function in the shared memory before refreshing its own fast instruction buffer.

a first receiving module, configured to receive, by the service VCPU, a first patch activation message sent by the primary VCPU, and a determining module, configured to determine whether the service VCPU is the last service VCPU that refreshes its own fast instruction buffer;

a second patch module, configured to: when the determining module determines that the service VCPU is the last service VCPU that refreshes its own fast instruction buffer, according to the first patch activation message The first instruction and the second instruction of the original function are modified in the shared memory to the instruction that jumps to the patch function, and the original function is a function that needs to be patched;

a first refresh notification module, configured to refresh the service VCPU after the second patch module modifies the first instruction and the second instruction of the original function into the instruction to jump to the patch function in the shared memory a fast instruction buffer, and through the main VCPU, notify the service VCPU other than the service VCPU that refreshes its own fast instruction buffer to refresh its own fast instruction buffer, so that the service VCPU itself is fast The instruction in the instruction buffer is updated synchronously with the instruction in the shared memory.

The method and device for patching the shared code segment in the embodiment of the present invention, in the running process of the multi-core processor system, the main VCPU modifies the first instruction of the original function to jump to the instruction of the exception processing, and sends a patch to the service VCPU. Activate the message to refresh the fast instruction buffer after the service VCPU has processed the current service. The last service that refreshes the fast instruction buffer VCPU notifies other services VCPU to refresh their respective fast instruction buffers after the original function is patched. When the last service VCPU patches the original function, if the other service VCPU executes the original function, the first instruction from the original function enters the exception processing, and then jumps from the exception processing to the first address of the patch function. Execute the instructions in the patch function. Therefore, when the last service VCPU performs a patch operation on the original function, it does not affect the normal service processing of other service VCPUs, and does not cause service congestion and loss.

DRAWINGS

In order to more clearly illustrate the embodiments of the present invention or the technical solutions in the prior art, a brief description of the drawings used in the embodiments or the prior art description will be briefly described below. Obviously, the drawings in the following description For some embodiments of the present invention, other drawings may be obtained from those skilled in the art without departing from the drawings.

FIG. 1B is a flowchart of a method for patching a shared code segment according to a first embodiment of the present invention; FIG. 1b is a flowchart of a patch execution method for patching a shared code segment according to a first embodiment of the present invention; A flowchart of a method for patching a shared code segment according to a second embodiment of the present invention; FIG. 3a is a flowchart of a method for patching a shared code segment according to a third embodiment of the present invention; FIG. 3b is a signaling interaction diagram of a method for patching a shared code segment according to a third embodiment of the present invention; FIG.

4a is a flowchart of a method for patching a shared code segment according to a fourth embodiment of the present invention; FIG. 4b is a signaling interaction diagram of a method for patching a shared code segment according to a fourth embodiment of the present invention;

FIG. 5 is a flowchart of a method for patching a shared code segment according to a fifth embodiment of the present invention; FIG. 6 is a flowchart of a method for patching a shared code segment according to a sixth embodiment of the present invention; A flowchart of a method for patching a shared code segment provided by the seventh embodiment;

FIG. 7b is a flowchart of another method for patching a shared code segment according to a seventh embodiment of the present invention;

FIG. 7c is a signal interaction diagram of another method for patching a shared code segment according to a seventh embodiment of the present invention;

FIG. 8 is a flowchart of a method for patching a shared code segment according to an eighth embodiment of the present invention; FIG. 8b is a signaling interaction diagram of a method for patching a shared code segment according to an eighth embodiment of the present invention;

FIG. 9 is a schematic structural diagram of an apparatus for patching a shared code segment according to a ninth embodiment of the present invention; FIG. 10 is a schematic structural diagram of an apparatus for patching a shared code segment according to a tenth embodiment of the present invention;

FIG. 11 is a schematic structural diagram of an apparatus for patching a shared code segment according to an eleventh embodiment of the present invention; FIG.

FIG. 1 ib is another apparatus for patching a shared code segment according to an eleventh embodiment of the present invention. FIG. 12 is a schematic structural diagram of an apparatus for patching a shared code segment according to a twelfth embodiment of the present invention;

13 is a schematic structural diagram of an apparatus for patching a shared code segment according to a thirteenth embodiment of the present invention; FIG. 14 is a schematic structural diagram of an apparatus for patching a shared code segment according to a fourteenth embodiment of the present invention;

15 is a schematic structural diagram of an apparatus for patching a shared code segment according to a fifteenth embodiment of the present invention;

FIG. 16 is a schematic structural diagram of an apparatus for patching a shared code segment according to a sixteenth embodiment of the present invention.

detailed description

BRIEF DESCRIPTION OF THE DRAWINGS The technical solutions in the embodiments of the present invention will be described in detail below with reference to the accompanying drawings. All other embodiments obtained by a person of ordinary skill in the art based on the embodiments of the present invention without creative work are within the scope of the present invention.

The VCPU running on the embedded operating system is called the primary VPCU, which is used to manage the common resources of the system and manage and monitor the service VCPU. The service VCPU runs a single-task operating system to perform efficient user data processing. The technical solution is applicable to an asymmetric processor AMP (asymmetnc multi-processing) structure, and a separate operating system must be run on each VCPU. Images running on a VCPU can have exclusive code segments or share code segments.

Take the MIPS (Microcomputer without interlocked pipeline stages) processor as an example to illustrate the patching principle in a multi-core processor environment. Since MIPS uses pipeline technology, the implementation refers to There is a delay slot when jumping, that is to say, the delay slot is executed first when the actual execution, and then the jump instruction is executed. Therefore, two instructions must be modified at the same time, that is, the empty instruction NOP is used as the delay slot instruction and the jump instruction is modified to implement the patching operation.

Since the two instructions need to be modified to perform the patch operation, in the case of the shared code segment of the multi-core processor, not only the modification of the instruction but also the timing of the modification of the instruction and the immediate effect of the patch need to be considered. Because, in a multi-core processor, multiple VCPUs access the same code segment together. If a VCPU has executed the first instruction and another VCPU is modifying the instruction at this time, the first VCPU instruction is abnormal. Causes the system to crash.

In the embodiment of the present invention, the combination of the interrupt and the exception processing, and the combination of the message and the exception processing, respectively, enable the patch to take effect quickly, and the normal service processing of each service VCPU is not affected. In the following embodiments, the first to fourth embodiments are methods for patching shared code segments in a multi-core processor system operation by means of interrupts and exceptions; wherein, the first embodiment and the second The embodiment describes the process of the patching operation from the perspective of the main VCPU. The third embodiment and the fourth embodiment explain the process of the patching operation from the perspective of each service VCPU. In addition, the fifth to eighth embodiments are a method for patching a shared code segment in a multi-core processor system operation by means of a combination of a message and an exception; wherein the fifth embodiment and the sixth embodiment are The main VCPU angle illustrates the process of the patching operation, and the seventh embodiment and the eighth embodiment explain the process of the patching operation from the perspective of each service VCPU.

It should be noted that the original function in the following embodiment is a function that needs to be patched, and the patch function is a function that replaces the original function.

FIG. 1 is a flowchart of a method for patching a shared code segment according to a first embodiment of the present invention. This embodiment illustrates a process of patching operations from the perspective of a main VCPU. As shown in FIG. 1 , this embodiment includes: Step 11: Before patching the original function, modify the first instruction of the original function to jump to the exception handling instruction in the shared memory;

During the operation of the multi-core processor system, the main VCPU modifies the first instruction of the original function to jump to the exception processing instruction, and the purpose is to perform the original function in the subsequent modification process, if each service VCPU executes the original function, each The service VCPU enters the exception handling according to the instruction that jumps to the exception handling. Among them, the instruction to jump to exception handling can be break.; The original function is a shared function that needs to be patched.

Step 12: Send a first interrupt message to each service VCPU.

The feature of the interrupt message is that after each service VCPU receives the interrupt message sent by the main VCPU, it That is, the current under execution service is stopped, and the interrupt message is processed. The main VCPU sends the first interrupt information to each service VCPU. The purpose is to instruct each service VCPU to interrupt the current service and immediately refresh its own fast instruction buffer after receiving the first interrupt information. Therefore, the instructions in the fast instruction buffer of each service VCPU itself are updated synchronously with the instructions in the shared memory. Since the fast instruction buffer access speed is higher than the memory access speed, the business VCPU usually transfers frequently used code segments from the shared memory into its own fast instruction buffer when executing the code segment. When these code segments are used, they are read directly from the fast instruction buffer, thereby increasing the access code speed.

If a service VCPU receives the first interrupt information, it has transferred the first instruction of the original function from the shared memory to its own fast instruction buffer, and after refreshing its own fast instruction buffer, its fast instruction buffer The first instruction of the original function in the region is updated to the first instruction of the original function in the shared memory, that is, the instruction that jumps to the exception processing.

If a service VCPU receives the first interrupt information, it has not transferred the first instruction of the original function from the shared memory to its own fast instruction buffer, and after refreshing its own fast instruction buffer, its fast instruction The instruction in the buffer is still the original instruction.

Step 13: In the shared memory, modify the first instruction and the second instruction of the original function to an instruction that jumps to the patch function;

Modify the first instruction and the second instruction of the original function, that is, patch the original function. the Lord

After the VCPU modifies the first instruction and the second instruction of the original function in the shared memory, the VCPUs executing the original function are jumped from the first instruction of the original function to the patch function, thereby realizing the original function. Modifications. Among them, the patch function is a function that replaces the original function.

The method for modifying the original function may be: first modify the second instruction of the original function into a delay slot instruction, that is, a NOP; and then modify the first instruction of the original function to an instruction that jumps to the patch function, that is, a JMP patch function. First address.

If the main VCPU first modifies the first instruction of the original function, then the second instruction of the original function is modified. After the main VCPU changes the first instruction of the original function from the entry of the exception processing instruction to the jump instruction, and has not modified the second instruction of the original function into the delay slot instruction, the execution is performed to the original function first. The service VCPU of the instruction will cause the system to crash because the second instruction is not a delay slot instruction and cannot be jumped to the patch function for execution.

Therefore, in this embodiment, the main VCPU is modified first to use the second instruction of the original function as the delay slot instruction, and then the first instruction of the original function is modified as the jump instruction. At this point, if the business VCPU executes to the original function To the first instruction, since the first instruction of the original function still enters the exception handling instruction (for example, break ), the service VCPU enters the exception processing through the first instruction, and does not continue to execute the second function of the original function. Instructions. Thus, this embodiment avoids the effect of the delay slot instruction on patching the shared original function.

FIG. 1b is a flowchart of a patch execution in a method for patching a shared code segment according to a first embodiment of the present invention. As shown in Figure lb, after the original function is patched, during the operation of the multi-core processor system, when the service VCPU executes the instruction that jumps to the original function in the calling function, the call function jumps to the first function. The instructions begin execution. At this time, since the first instruction of the original function is an instruction to jump to the patch function, and the second instruction is a delay slot instruction, the service VCPU jumps from the original function to the patch function. When the execution reaches the end of the patch function, it returns to the calling function A, and continues to execute the instruction in the calling function A, thereby achieving the purpose of patching the original function.

Step 14: Send a second interrupt information to each service VCPU.

The second interrupt information is used to indicate the service VCPU, and the current service is interrupted to immediately refresh the respective fast instruction buffers. The instructions in the fast instruction buffer of each service VCPU and the instructions in the shared memory are updated synchronously.

When the main VCPU modifies the first instruction and the second instruction of the original function in the shared memory, a certain service VCPU has transferred the first instruction and the second instruction of the original function from the shared memory to its own fast instruction. The buffer, after refreshing its own fast instruction buffer, will update the first instruction and the second instruction of the original function in its own fast buffer to the first function of the original function modified by the main VCPU. The instruction and the second instruction.

In this embodiment, in the running process of the multi-core processor system, before the main VCPU performs the patching operation on the original function, the first instruction of the original function is first changed to the instruction that jumps to the exception processing, and is directed to the service VCPU. The interrupt message is sent so that the service VCPU immediately refreshes the fast instruction buffer. In the embodiment of the present invention, after receiving the interrupt information sent by the main CPU, the service VCPU does not need to send a response message to the main VCPU; and after the main CPU sends the interrupt information to the service VCPU, the original function can be patched. The embodiment of the invention enables the patch to take effect quickly. In addition, when the main VCPU patches the original function, if the service VCPU executes the first instruction to the original function, the instruction that jumps to the exception processing enters the exception processing, and then enters the patch function from the exception processing, thereby enabling Guarantee the Lord

The VCPU performs a normal patching operation on the original function, while avoiding the effect of the delayed instruction on patching the shared original function. Therefore, in the embodiment of the present invention, a method for patching a shared code segment is performed on a primary VCPU pair. When the original function is patched, it does not affect the normal business processing of the service VCPU. It also enables the service VCPU executing the original function to jump from the original function to the patch function, without causing service congestion and loss of service data. .

FIG. 2 is a flowchart of a method for patching a shared code segment according to a second embodiment of the present invention. In the embodiment corresponding to FIG. 1, the main VCPU has an error in the first instruction and the second instruction of the original function in step 13, and has performed step 14: sending a second interrupt message to each service VCPU. The main VCPU restores the first instruction and the second instruction of the original function to the original original instruction by the method in this embodiment. In the process of restoring the first instruction and the second instruction of the original function by the main VCPU, the method of the embodiment corresponding to FIG. 1 is similar, which does not affect the normal service processing of each service VCPU, and can also cause execution to the original The service VCPU of the first instruction of the function is executed by the exception processing into the number of patches. Specifically, as shown in FIG. 2, the embodiment includes:

Step 21: Before restoring the first instruction and the second instruction of the original function, modify the first instruction of the original function to jump to the instruction of the exception processing in the shared memory;

Among them, the instruction to jump to the exception processing can be break.

Step 22: Send a third interrupt message to each service VCPU.

The third interrupt information is used to instruct each service VCPU to interrupt the current service and immediately refresh its own fast instruction buffer, so that the instructions in the fast instruction buffer of each service VCPU and the instructions in the shared memory are updated synchronously;

Step 23: In the shared memory, restore the first instruction and the second instruction of the original function to the instruction before the original function is modified;

In step 23, the main VCPU restores the first instruction and the second instruction of the original function to the instruction before the original function is patched, that is, the instruction before the original function is modified.

Step 24: Send a fourth interrupt information to each service VCPU.

The fourth interrupt information is used to indicate the service VCPU, and the current service is interrupted to immediately refresh the respective fast instruction buffers, so that the instructions in the fast instruction buffer of each service VCPU itself are updated synchronously with the instructions in the shared memory.

In this embodiment, before the main VCPU restores the first instruction and the second instruction of the original function, the first instruction of the original function is first modified to jump to the exception processing instruction, and the interrupt information is sent to the service VCPU to enable the service. The VCPU immediately refreshes the fast instruction buffer. When the main VCPU restores the first instruction and the second instruction of the original function, if the service VCPU executes the original function, it jumps to the exception processing finger. Let the exception handling, and then jump from the exception processing to the first address of the patch function, start executing the instructions in the patch function to ensure that the main VCPU restores the original function.

FIG. 3 is a flowchart of a method for patching a shared code segment according to a third embodiment of the present invention. Figure

3b is a signaling interaction diagram of a method for patching a shared code segment according to a third embodiment of the present invention. This embodiment, in conjunction with the action of the main VCPU in the embodiment shown in FIG. 1, mainly describes the process of the patching operation from the perspective of the service VCPU. Referring to FIG. 3a and FIG. 3b, this embodiment includes:

Step 31: After receiving the first interrupt information sent by the main VCPU, according to the indication of the first interrupt information, interrupting the current service and immediately refreshing the fast instruction buffer;

Each service VCPU interrupts the current service, and the purpose of immediately refreshing its own fast instruction buffer is to synchronize the instructions in its own fast instruction buffer with the instructions in the shared memory to ensure instruction and sharing in its own fast instruction buffer. The corresponding instructions in the memory are consistent.

Step 32: When the first instruction to the original function is executed, according to the first instruction of the original function, the exception processing is entered;

If a service VCPU receives the first interrupt information, it has transferred the first instruction of the original function from the shared memory to its own fast instruction buffer, refreshing its own fast instruction buffer, and its fast instruction buffer. The first instruction of the original function is updated to the first instruction of the original function in the shared memory, that is, the instruction that jumps to the exception processing. When the second interrupt information sent by the main VCPU has not been received, that is, before the first instruction of the original function is not updated in its own fast instruction buffer, when the service VCPU executes the first instruction, According to the instruction that jumps to the exception processing, the exception processing is entered.

If a service VCPU receives the first interrupt information, it has not transferred the first instruction of the original function from the shared memory to its own fast instruction buffer, and after refreshing its own fast instruction buffer, its fast instruction buffer The instructions in the zone are still the original instructions. When the service VCPU subsequently transfers the first instruction of the original function into the fast buffer, if the second interrupt information sent by the main VCPU has not been received, if the first instruction of the original function is executed, At this time, the first instruction is an instruction that jumps to the exception processing, and the service VCPU enters the exception processing according to the instruction that jumps to the exception processing.

Step 33: In the exception handling, according to the first address of the original function to be patched, find the first address of the patch function in the patch area;

The patch area stores the first address of the original function, the first address of the patch function, the mapping relationship between the original function and the patch function, and the first two instructions of the original function. Step 34: According to the first address of the patch function, jump from exception processing to execution in the patch function. The service VCPU finds the first address of the corresponding patch function in the patch area according to the first address of the original function. After finding the first address of the corresponding patch function, the return address of the exception processing is modified to the first address of the patch function, and then the exception function is processed into the patch function, and the instruction in the patch function is executed. Therefore, before the service VCPU has received the second interrupt message sent by the primary VPCU, that is, before the patch operation of the original function by the primary VCPU has not yet taken effect, if the service VCPU executes the first instruction of the original function, In the exception handling, the patch function is executed for execution. Thus, not only does it not affect the normal service processing of the service VCPU, but it also enables the service VCPU to execute the middle instruction of the patch function.

Step 35: After interrupting the current service according to the indication of the first interrupt information, after refreshing the fast instruction buffer, receiving the second interrupt information sent by the main VCPU, and interrupting the current service to refresh itself quickly according to the indication of the second interrupt information. Instruction buffer.

The service VCPU refreshes its own fast instruction buffer, which causes the instructions in the fast instruction buffer of the service VCPU itself to be updated synchronously with the instructions in the shared memory.

After interrupting the current service according to the indication of the first interrupt information, after the fast instruction buffer is refreshed, the service VCPU receives the second interrupt information sent by the main VCPU, indicating that the main VCPU has the first two functions of the original function in the shared memory. The instruction is modified. If the first instruction and the second instruction of the original function are stored in the fast instruction buffer of the original function, the first instruction and the first instruction of the original function are refreshed after the fast instruction buffer is refreshed. The two instructions are updated to the modified VCPU instruction, that is, the first is Jump and the second is Nop. After the update, when the service VCPU executes the first instruction to the original function, it jumps directly from the original function to the patch function, thereby implementing the patching operation on the original function.

In this embodiment, during the operation of the multi-core processor system, each service VCPU immediately refreshes its respective fast instruction buffer after receiving the first interrupt information sent by the main CPU. When the service VCPU executes the first instruction to the original function, and does not receive the second interrupt information sent by the main VCPU, jumps to the exception processing according to the instruction that jumps to the exception processing, and then enters the patch from the exception processing. In the function, the patch function is started. Therefore, in the embodiment of the present invention, the method for patching the shared code segment, when the main VCPU patches the original function, does not affect the normal service processing of the service VCPU, and can also execute the service VCPU from the original function to the original function. Jump to the patch function to execute.

4a is a flowchart of a method for patching a shared code segment according to a fourth embodiment of the present invention. The service VCPU receives the second interrupt information sent by the main VCPU in the embodiment corresponding to FIG. 3a, and may also receive the third middle sent by the main VCPU according to the refresh of the respective fast instruction buffers. Broken information. FIG. 4b is a signaling interaction diagram of a method for patching a shared code segment according to a fourth embodiment of the present invention. This embodiment, in conjunction with the execution flow of the main VCPU in the corresponding embodiment of FIG. 1 and FIG. 2, mainly illustrates the execution flow of the service VCPU after receiving the third interrupt information sent by the main VCPU, from the perspective of the service VCPU. As shown in FIG. 4a and FIG. 4b, this embodiment includes:

Step 41: After receiving the third interrupt information sent by the primary VCPU, interrupting the current service to immediately refresh the fast instruction buffer according to the indication of the third interrupt information.

The service VCPU receives the third interrupt message sent by the primary VCPU, indicating that the primary VCPU has modified the original function. Each service VCPU immediately refreshes its own fast instruction buffer, so that its instructions in the fast instruction buffer are synchronized with the instructions in the shared memory.

Step 42: When executing the first instruction to the original function, according to the first instruction of the original function, enter the exception processing;

After the main VCPU sends the third interrupt information to each service VCPU, the first instruction and the second instruction of the original function are restored to restore the original first instruction and the second instruction in the original function. In this process, similar to the embodiment corresponding to Fig. 3, if the service VCPU executes the first instruction to the original function at this time, the exception processing is entered by the instruction that jumps to the exception processing. Therefore, it does not affect the normal business processing of the service VCPU.

Step 43: In the exception processing, according to the first address of the original function to be patched, the first address of the patch function is searched in the patch area; the patch function is a function that replaces the original function;

Step 44: According to the first address of the patch function, return from exception processing to execution in the patch function. Step 45: After interrupting the current service according to the instruction of the third interrupt information, after refreshing the fast instruction buffer, receiving the fourth interrupt information sent by the main VCPU, and interrupting the current service to refresh itself quickly according to the indication of the second interrupt information. Instruction buffer.

After interrupting the current service and immediately refreshing its own fast instruction buffer according to the indication of the third interrupt information, the service VCPU receives the fourth interrupt information sent by the primary VCPU.

In this embodiment, during the operation of the multi-core processor system, if the main VCPU needs to restore the first instruction and the second instruction of the original function before modification, the first instruction of the original function is modified to jump to the exception processing. The instruction then sends a third interrupt message to each service VCPU, causing each VCPU to refresh its respective instruction buffer. After the main VCPU sends the third interrupt message, it starts to enter the first two instructions of the original function. Line recovery operation. At this stage, if the service VCPU executes the first instruction to the original function, it will enter the patch function by jumping to the exception handling instruction. Therefore, in the embodiment of the present invention, the method for patching the shared code segment, when the main VCPU restores the original function, does not affect the normal service processing of the service VCPU, and can also execute the service VCPU from the original function to the original function. Jump to the patch function to execute.

FIG. 5 is a flowchart of a method for patching a shared code segment according to a fifth embodiment of the present invention. This embodiment illustrates a process of patching operations from the perspective of a main VCPU. As shown in FIG. 5, this embodiment includes: Step 51: Before patching the original function, in the shared memory, modify the first instruction of the original function to jump to the exception processing instruction;

During the operation of the multi-core processor system, the main VCPU modifies the first instruction of the original function to jump to the exception processing instruction, and the purpose is to perform other functions in the subsequent VCPU to modify the original function. Function, the service VCPU enters exception handling according to the instruction that jumps to the director's processing. Among them, the instruction to jump to exception handling can be break.; The original function is a shared function that needs to be patched.

Step 52: Send a first patch activation message to each service VCPU.

The first patch activation message is used to instruct each service VCPU to refresh its own fast instruction buffer after processing the current service, so that the instruction in the fast instruction buffer of each service VCPU itself is updated synchronously with the instruction in the shared memory; A service that refreshes its own fast instruction buffer

The VCPU, in the shared memory, modifies the first instruction and the second instruction of the original function.

To determine the last service VCPU that refreshes its own fast instruction buffer, the primary VCPU saves all the service VCPU numbers that need to receive the first patch activation message in the shared memory before sending the first patch activation message. After receiving the patch activation message and refreshing its own fast instruction buffer, each service VCPU records its own VCPU number in the shared memory and checks whether all the service VCPUs except itself have been recorded in the shared memory. The number, if it is, indicates that it is the last business VCPU.

Due to the characteristics of the message, after receiving the first patch activation message, the service VCPU does not immediately process the first patch activation message. Instead, after processing the current business, refresh its own fast instruction buffer. The last service VCPU, before refreshing its own fast instruction buffer, modifies the first instruction and the second instruction of the original function in the shared memory, that is, the original function is patched. If the service VCPU that modifies the original function instruction is not the last quick refresh command The service VCPU of the rushing area, when the service VCPU modifies the first instruction and the second instruction of the original function in the shared memory, if the other service VCPU that does not refresh its own fast instruction buffer subsequently executes the first function to the original function An instruction or a second instruction may cause an instruction execution error. Therefore, in the embodiment of the present invention, the last VCPU that refreshes its own buffer is used, and the first instruction and the second instruction of the original function are modified.

After the service VCPU processes the current service and processes the first patch activation information, that is, after refreshing its own fast instruction buffer, the first instruction of the original function is stored in its own fast instruction buffer, and the instruction is Jump to the instruction of exception handling. When the service VCPU executes the instruction in the original function, it enters the exception processing, and then enters the patch function from the exception processing.

The embodiment of the present invention is a method for patching a shared code segment. During the operation of the multi-core processor system, the main VCPU modifies the first instruction of the original function to jump to the exception processing instruction, and sends the first patch to the service VCPU. Activate the message to refresh the fast instruction buffer after the service VCPU has processed the current service. The last service that refreshes the fast instruction buffer VCPU notifies other services VCPU to refresh their respective fast instruction buffers after the original function is patched. When the last service VCPU patches the original function, if the other service VCPU executes the original function, the first instruction from the original function enters the exception processing, and then jumps from the exception processing to the first address of the patch function. Execute the instructions in the patch function. Therefore, when the last service VCPU performs a patch operation on the original function, it does not affect the normal service processing of other service VCPUs, and does not cause service congestion and loss.

FIG. 6 is a flowchart of a method for patching a shared code segment according to a sixth embodiment of the present invention. After the step 52 of the embodiment corresponding to FIG. 5, if the modification of the original function by the service VCPU of the last fast instruction buffer is incorrect, the instruction of the original function is restored by this embodiment. Specifically, as shown in FIG. 6, the embodiment includes:

Step 61: Before restoring the first instruction and the second instruction of the original function, in the shared memory, modify the first instruction of the original function to jump to the instruction of the exception processing;

The instruction to jump to exception handling can be break.

Step 62: Send a second patch activation message to each service VCPU.

The second patch activation message is used to instruct each service VCPU to refresh its own fast instruction buffer, so that the instruction in the fast instruction buffer of each service VCPU itself is updated synchronously with the instruction in the shared memory; and the last refresh of each service VCPU is indicated. The VCPU of its own fast instruction buffer restores the first instruction and the second instruction of the original function to the original instruction in the shared memory. The second patch activation message in this embodiment differs from the first patch activation message in the corresponding implementation column of FIG. 5 in that the second patch activation message indicates the last service VCPU of the fast instruction buffer of its own refresh, in the shared memory. The first instruction and the second instruction of the original function are restored to the original instruction.

In this embodiment, in the running process of the multi-core processor system, if an error occurs in the patching operation of the original function, and the instruction of the original function needs to be restored, the main VCPU first modifies the first instruction of the original function to jump to the abnormality. Processing the instruction and sending a second patch activation message to the service VCPU. After the service VCPU processes the current service, after refreshing its own fast instruction buffer according to the second patch activation message, if the other service VCPU executes the first instruction of the original function, it jumps to the exception processing instruction, according to the jump to The exception-handled instruction enters the exception handling, and then jumps from the exception handling to the first address of the patch function to execute the instruction in the patch function. Therefore, when the last service VCPU restores the original function, it does not affect the normal service processing of other service VCPUs, and does not cause traffic congestion and loss.

FIG. 7a is a flowchart of a method for patching a shared code segment according to a seventh embodiment of the present invention. This embodiment mainly describes a process of patching operations from the perspective of a service VCPU. As shown in FIG. 7a, this embodiment includes :

Step 71a: The service VCPU receives the first patch activation message sent by the primary VCPU.

The purpose of the first VCPU to send the first patch activation message is to enable each service VCPU to refresh its own fast instruction buffer after processing the current service. When the fast instruction buffer in the service VCPU has stored the first instruction of the original function, the refresh can cause the first instruction of the modified original function in the shared memory to be transferred into the fast instruction buffer, thereby When the VCPU (except the last service VCPU that refreshes its own fast instruction buffer) executes the first instruction to the original function, it enters the exception handling, and then proceeds from the exception handling into the patch function. In this way, in the last service VCPU to patch the original function (change the first instruction to Jump, the second instruction to Nop), does not affect the normal business processing of other business VCPU, but also enables execution to the original The other business VCPU of the function jumps from the original function to the patch function.

Step 72a: When the service VCPU is the last service VCPU that refreshes its own fast instruction buffer, according to the instruction of the first patch activation message, the first instruction and the second instruction of the original function are modified in the shared memory to Jump to the instruction of the patch function;

After the service VCPU finishes processing the current service, it is determined that it is the last service VCPU that refreshes its own fast instruction buffer before preparing to refresh its own fast instruction buffer. Within the share The first instruction and the second instruction of the original function are modified to execute the instruction that jumps to the patch function. Step 73a: The service VCPU refreshes its own fast instruction buffer, and the main VCPU notifies the other service VCPUs other than the service VCPU that refreshes its own fast instruction buffer to refresh its own fast instruction buffer.

The service VCPU refreshes its own fast instruction buffer, which causes its instructions in the fast instruction buffer to be updated synchronously with the instructions in the shared memory.

The embodiment of the present invention is a method for patching a shared code segment. During the operation of the multi-core processor system, the main VCPU modifies the first instruction of the original function to jump to the exception processing instruction, and sends a patch activation message to the service VCPU. , the service VCPU refreshes the fast instruction buffer after processing the current service. The last service that refreshes the fast instruction buffer VCPU notifies other services VCPU to refresh their respective fast instruction buffers after the original function is patched. When the last service VCPU patches the original function, if the other service VCPU executes the original function, the first instruction from the original function enters the exception processing, and then jumps from the exception processing to the first address of the patch function. Execute the instructions in the patch function. Therefore, when the last service VCPU performs a patch operation on the original function, it does not affect the normal service processing of other service VCPUs, and does not cause service congestion and loss.

FIG. 7b is a flowchart of another method for patching a shared code segment according to a seventh embodiment of the present invention, and FIG. 7c is another method for patching a shared code segment according to a seventh embodiment of the present invention. Make an interaction diagram. In this embodiment, the process of the patching operation is mainly described from the perspective of the service VCPU, as shown in FIG. 7b and FIG. 7c. The embodiment includes: Step 71: The service VCPU receives the main VCPU. The first patch activation message sent;

Step 72: Determine whether it is the last service VCPU that refreshes its own fast instruction buffer. To determine the last service VCPU that refreshes its own fast instruction buffer, the main VCPU saves in the shared memory before sending the first patch activation message. All service VCPU numbers that need to receive the first patch activation message. Each service VCPU records its own VCPU number in the shared memory before receiving the patch activation message and refreshing its own fast instruction buffer. And according to all the service VCPU numbers that the main VCPU saves in the shared memory, need to receive the first patch activation message, and check whether the number of all service VCPUs other than itself is recorded in the shared memory, and if so, it indicates that it is the last A business VCPU.

If the service VCPU is processing the current service and confirming that it is not the last VCPU that refreshes its own fast instruction buffer before refreshing its own fast instruction buffer, then step 73 is performed. Step 76, as follows:

Step 73: Refresh its own fast instruction buffer;

Step 74: When executing the first instruction to the original function, according to the instruction of the original function jumping to the exception processing, the exception processing is entered; the first instruction that does not execute the original function indicates that the service is normally processed.

Step 75: In the exception processing, according to the first address of the original function to be patched, find the first address of the patch function in the patch area;

Step 76: According to the first address of the patch function, return from the exception processing to the execution of the patch function. If the service VCPU is processing the current service and refreshing its own fast instruction buffer before determining that it is the last VCPU to refresh its own fast instruction buffer, then perform steps 77 to 78, as follows:

Step 77: Modify the first instruction and the second instruction of the original function into an instruction to jump to the patch function in the shared memory;

The last service VCPU that refreshes its own fast instruction buffer, the method of modifying the first instruction and the second instruction of the original function may be: first modify the second instruction of the original function into a delay slot instruction, that is, NOP; Modify the first instruction of the original function to the instruction that jumps to the patch function, that is, the first address of the JMP patch function.

Step 78: Refresh its own fast instruction buffer, and notify the other VCPUs through the main VCPU to refresh their fast instruction buffer.

The last service VCPU that refreshes its own fast instruction buffer, after modifying the first instruction and the second instruction of the original function, refreshes its own fast instruction buffer, and notifies other service VCPUs to refresh themselves through the main VCPU. The fast instruction buffer is used to synchronize the instructions in the fast instruction buffer of each service VCPU itself with the instructions in the shared memory.

The embodiment of the present invention is a method for patching a shared code segment. During the operation of the multi-core processor system, the main VCPU modifies the first instruction of the original function to jump to the exception processing instruction, and sends a patch activation message to the service VCPU. , the service VCPU refreshes the fast instruction buffer after processing the current service. The last service VCPU that refreshes the fast instruction buffer, after patching the original function, notifies other service VCPUs to refresh their respective fast instruction buffers. When the last service VCPU patches the original function, if the other service VCPU executes the original function, the first instruction from the original function enters the exception processing, and then jumps from the exception processing to the first address of the patch function. Execute the instructions in the patch function. Thus, when the last service VCPU performs a patch operation on the original function, The normal service processing of other service VCPUs will not cause traffic congestion and loss.

FIG. 8a is a flowchart of a method for patching a shared code segment according to an eighth embodiment of the present invention. After the step 72 of the embodiment corresponding to FIG. 7, if the modification of the original function by the service VCPU of the last fast instruction buffer is incorrect, the instruction of the original function is restored by this embodiment. FIG. 8b is a signaling interaction diagram of a method for patching a shared code segment according to an eighth embodiment of the present invention. Specifically, as shown in FIG. 8a and FIG. 8b, this embodiment includes:

Step 81: Receive a second patch activation message sent by the primary VCPU.

After the main VCPU modifies the first instruction of the original function in the shared memory to jump to the exception processing instruction, the purpose of sending the second patch activation message to each service VCPU is to enable each service VCPU to refresh itself after processing the current service. The instructions in the fast instruction buffer are used to synchronize the instructions in their own fast instruction buffer with the instructions in the shared memory.

Similar to the implementation column of Figure 7, before the original function is patched, that is, before modifying the first instruction and the second instruction, the main VCPU first modifies the first instruction to break, and then sends the first instruction to the service VCPU. Two patch activation messages. The difference between the second patch activation message and the first patch activation message is that the service VCPU indicating the last refresh of the fast instruction buffer restores the first instruction and the second instruction of the original function to the original function. instruction.

Step 82: Determine whether it is the last service VCPU that refreshes its own fast instruction buffer;

After processing the current service, each service VCPU needs to determine whether it is the last service VCPU that refreshes its own fast instruction buffer before refreshing its own fast instruction buffer to perform different operations according to the first patch activation message. . If it is not the last service VCPU that refreshes its own fast instruction buffer, go to step 83 to step 86:

Step 83: Refresh its own fast instruction buffer;

Step 84: According to the first instruction of the original function, enter exception processing;

When the service VCPU executes the first instruction to the original function, because the instruction in its own fast instruction buffer has been updated synchronously with the shared memory, the first instruction of the original function in its own fast instruction buffer is a jump. Go to the exception handling instructions. Therefore, the service VCPU enters the exception processing from the first instruction of the original function, and executes the exception handler. The first instruction that did not execute the original function indicates that the service is processed normally.

Step 85: In the exception handling, according to the first address of the original function to be patched, check in the patch area. Find the first address of the patch function;

Step 86: According to the first address of the patch function, return from the exception processing to the patch function. If it is the last service VCPU that refreshes its own fast instruction buffer, perform steps 87 to 88, as follows:

Step 87: Restore the first instruction and the second instruction of the original function in the shared memory; the last service VCPU that refreshes its own fast instruction buffer, and the method of modifying the original function first instruction and the second instruction For: first the second instruction of the original function (delay slot instruction, ie

NOP) restores the second instruction before the modification of the original function, and restores the first instruction of the original function (the instruction that jumps to the exception processing, ie, break) to the first instruction before the modification of the original function.

Step 88: Refresh its own fast instruction buffer, and notify the other VCPUs of the service VCPU to refresh their fast instruction buffer through the main VCPU.

The last service VCPU that refreshes its own fast instruction buffer, after restoring the first instruction and the second instruction of the original function, refreshes its own fast instruction buffer, and notifies other service VCPUs to refresh themselves through the main VCPU. The fast instruction buffer is used to synchronize the instructions in the fast instruction buffer of each service VCPU itself with the instructions in the shared memory.

The following is a description of an apparatus for patching a shared code segment in an embodiment of the present invention. Wherein, the ninth embodiment and the eleventh embodiment are devices for patching the original function in a combination of an interrupt and an abnormality; the twelfth to sixteenth embodiments are a combination of a message and an abnormality Method, a device that patches the original function.

FIG. 9 is a schematic structural diagram of an apparatus for patching a shared code segment according to a ninth embodiment of the present invention. As shown in FIG. 9, the embodiment includes: a first modification module 91, a first interruption module 92, a first patch module 93, and a second interrupt module 94. The first modification module 91 modifies the first instruction of the original function to jump to the exception processing instruction in the shared memory before the main VCPU patches the original function; wherein, the original function is a shared function that needs to be patched. The first interrupt module 92 sends the first interrupt message to the service VCPU after the first modification module 91 modifies the first instruction of the original function to jump to the exception processing instruction in the shared memory. The first interrupt information is used to instruct each service VCPU to interrupt the current service and immediately refresh its own fast instruction buffer, so that the modified instruction of the first modification module 91 takes effect quickly. Therefore, when the main VCPU patches the original function, each service VCPU is caused to jump to the exception processing according to the first instruction of the original function.

After the first interrupt module 92 sends the first interrupt information to the service VPCU, the first patch module 93 modifies the first instruction and the second instruction of the original function into an instruction to jump to the patch function in the shared memory. The specific operation of the first patch module 93 may be: first modifying the second instruction of the original function into a delay slot instruction; modifying the first instruction of the original function to an instruction that jumps to the patch function. Because the first patch module 93 changes the first instruction and the second instruction of the original function to the instruction to jump to the patch function in the shared memory, each service VCPU has refreshed according to the instruction of the first interrupt information. Its own fast instruction buffer. Therefore, if each service VCPU executes the original function, it will jump to the exception processing, so that it is not affected by the patching of the original function by the first patch module 93.

The second interrupt module 94 sends the second interrupt information to the service VPCU after the first patch module 93 modifies the first instruction and the second instruction of the original function to jump to the patch function in the shared memory. The second interrupt information is used to instruct each service VCPU to interrupt the current service and refresh its own fast instruction buffer, so that the patch function of the original function is decelerated.

For the working mechanism of each module in this embodiment, refer to the description in the corresponding embodiment of FIG. 1, and details are not described herein again.

In this embodiment, during the operation of the multi-core processor system, before the first patch module 93 performs a patching operation on the original function, the first modification module 91 first modifies the first instruction of the original function to jump to the exception processing. The instruction, and instructing the first interrupt module 92 to send an interrupt message to the service VCPU, causes the service VCPU to immediately refresh the fast instruction buffer. In the embodiment of the present invention, after receiving the interrupt information sent by the first patch module 93, the service VCPU does not need to send a response message to the main VCPU; and after the first patch module 93 sends the interrupt information to the service VCPU, the original function can be The patching operation is performed. Therefore, the embodiment of the present invention enables the patch to take effect quickly. In addition, when the first patch module 93 performs a patching operation on the original function, if the service VCPU executes the first instruction to the original function, the instruction that jumps to the exception processing enters the exception processing, and then enters the patch function from the exception processing. , thus ensuring the first patch Module 93 performs a normal patching operation on the original function. Therefore, in the embodiment of the present invention, the device for patching the shared code segment does not affect the normal service processing of the service VCPU when the first patch module 93 patches the original function, and can also perform the service VCPU to the original function. Jump from the original function to the patch function, and will not cause business blocking and business data loss.

10 is a schematic structural diagram of an apparatus for patching a shared code segment according to a tenth embodiment of the present invention, as shown in FIG.

10, based on the corresponding embodiment of FIG. 9, further comprising: a second modification module 95, a third interrupt module 96, a first recovery module 97, and a fourth interrupt module 98.

If the first patch module 93 has an error in the first instruction and the second instruction of the original function, and after the first patch module 93 is modified, the second interrupt module 94 has sent the second interrupt information to each service VCPU. Then, by using the first recovery module in this embodiment, the first instruction and the second instruction of the original function are restored to the instruction before the original function is modified. details as follows:

After the second modification module 95 has sent the second interrupt information to each service VCPU, and before restoring the first instruction and the second instruction of the original function, in the shared memory, the first instruction of the original function is modified to Jump to the instruction of exception handling. After the third modification module 95 modifies the first instruction of the original function to jump to the exception processing instruction in the shared memory, the third interrupt module 96 sends a third interrupt message to the service VCPU to indicate that the service VCPU interrupts the current Business, refresh its own fast instruction buffer. After the third interrupt module 96 sends the third interrupt message to the service VCPU, the first recovery module 97 restores the first instruction and the second instruction of the original function to the instruction before the original function modification in the shared memory. The fourth interrupt module 98 restores the first instruction and the second instruction of the original function to the instruction before the original function modification in the shared memory in the first recovery module 97, and then sends the fourth interrupt information to the service VCPU. In order to indicate the service VCPU, the current service is interrupted and the respective fast instruction buffers are refreshed, so that the instructions in the fast instruction buffer of the service VCPU itself are updated synchronously with the instructions in the shared memory.

For the working mechanism of each module in this embodiment, refer to the description in the corresponding embodiment of FIG. 2, and details are not described herein again.

In this embodiment, before the first recovery module 97 restores the first instruction and the second instruction of the original function, the second modification module 95 first modifies the first instruction of the original function to jump to the instruction of the exception processing, and passes the instruction. The third interrupt module 96 sends a third interrupt message to the service VCPU, so that the service VCPU immediately refreshes the fast instruction buffer. When the first recovery module 97 restores the first instruction and the second instruction of the original function, if the service VCPU executes the original function, the exception processing is performed by jumping to the exception processing instruction, and then the exception processing is jumped to the patch function. At the first address, start executing the instructions in the patch function to ensure that A recovery module 97 modifies the original function. When the first recovery module 94 performs the patching operation on the original function, if the service VCPU executes the original function, the patch function is entered from the exception processing. Therefore, in the embodiment, when the first recovery module 97 patches the original function, It does not affect the normal service processing of the service VCPU, and will not cause traffic congestion and data loss.

11a is a schematic structural diagram of an apparatus for patching a shared code segment according to an eleventh embodiment of the present invention. As shown in FIG. 11a, the embodiment includes: a first refresh module 111, a first exception processing module 112, and a first patch function execution module 113 and a second refresh module 114.

After receiving the first interrupt information sent by the main VCPU, the first refresh module 111 interrupts the current service and immediately refreshes the fast instruction buffer according to the instruction of the first interrupt information, so that the instruction in the fast instruction buffer of the service VCPU itself is Synchronous updates to instructions in shared memory. Subsequently, when the service VCPU executes the first instruction to the original function, the first exception processing module 112 enters the exception processing according to the instruction of the original function to jump to the exception processing; in the exception processing, the original function that needs to be patched according to the need The first address, find the first address of the patch function in the patch area; the patch function is a function that replaces the original function. After the first exception processing module 112 finds the first address of the patch function, the first patch function execution module 113 returns from the exception processing to the first address of the patch function, and executes the patch function.

After the primary service VCPU sends the first interrupt information to the service VCPU, it performs the operation of patching the original function, and sends the second interrupt information to each service VCPU after the original function is patched. Therefore, the second refreshing module 114 interrupts the current service according to the instruction of the first interrupt information, refreshes the fast instruction buffer, and receives the second interrupt information sent by the main VCPU according to the indication of the second interrupt information. Interrupt the current service and refresh its own fast instruction buffer to synchronize the instructions in the fast instruction buffer of the service VCPU itself with the instructions in the shared memory.

The working mechanism of each module mentioned above is described in the corresponding embodiment of FIG. 3a and FIG. 3b, and details are not described herein again.

If the primary VCPU needs to restore the first instruction and the second instruction of the original function after patching the original function, as shown in FIG. 1 lb, the service VCPU can pass the following modules: the third refresh module 115, the second The exception handling module 116, the second patch function execution module 117, and the fourth refresh module 118 process the interaction with the master VPUC without affecting the normal processing of the current service.

After the second refresh module 114 refreshes the fast instruction buffer, the third refresh module 115 receives the third interrupt information sent by the main VCPU, and interrupts the current service according to the instruction of the third interrupt information, and refreshes its own fast instruction buffer. The second exception processing module 116 refreshes the fast finger in the third refresh module 115. After the buffer is executed, when the first instruction of the original function is executed, according to the first instruction of the original VCPU original function, the exception processing is entered; in the exception processing, according to the first address of the original function to be patched, in the patch The area finds the first address of the patch function. After the second exception function processing module 117 finds the first address of the patch function, the second patch function execution module 117 jumps from the exception processing to the patch function according to the first address of the patch function.

The fourth refresh module 118, after the third refresh module 115 interrupts the current service according to the instruction of the third interrupt information, and refreshes its own fast instruction buffer, receives an indication of the fourth interrupt information sent by the main VCPU, according to the fourth interrupt information. Instructs to interrupt the current service and refresh its own fast instruction buffer to synchronize the instructions in the fast instruction buffer of the service VCPU itself with the instructions in the shared memory.

The working mechanism of each of the above modules is described in the corresponding embodiment of FIG. 4a and FIG. 4b, and details are not described herein again.

In this embodiment, during the operation of the multi-core processor system, the first refresh module 111 immediately refreshes the respective fast instruction buffers after receiving the interrupt information sent by the main CPU. When the service VCPU executes the first instruction to the original function, and does not receive the second interrupt information sent by the main VCPU, jumps to the exception processing according to the instruction that jumps to the exception processing, and then enters the patch from the exception processing. In the function, the patch function is started. Therefore, in this embodiment, when the primary VCPU patches or restores the original function, it does not affect the normal service processing of the service VCPU, and can also cause the service VCPU executing the original function to jump from the original function to the patch function. carried out.

FIG. 12 is a schematic structural diagram of an apparatus for patching a shared code segment according to a twelfth embodiment of the present invention. As shown in FIG. 12, the embodiment includes: a third modification module 121 and a first message sending module 122.

Before the original function is patched, the third modification module 121 modifies the first instruction of the original function to jump to the exception processing instruction in the shared memory. The first message sending module 122 sends the first patch activation message to each service VCPU after the first modification module 121 modifies the first instruction of the original function to jump to the exception processing instruction in the shared memory.

The first patch activation message is used to instruct each service VCPU to refresh its own fast instruction buffer after processing the current service, so that the instructions in the fast instruction buffer of each service VCPU itself are updated synchronously with the instructions in the shared memory. The first patch activation message also indicates the last VCPU that refreshes its own fast instruction buffer, and modifies the first instruction and the second instruction of the original function in the shared memory.

For the working mechanism of each module in this embodiment, refer to the description in the corresponding embodiment in FIG. 5, and no longer Said.

In this embodiment, after the third modification module 121 modifies the first instruction of the original function to the instruction that jumps to the exception processing, the first message sending module 122 sends the first patch to the service VCPU. Activate the message to refresh the fast instruction buffer after the service VCPU has processed the current service. The last service that refreshes the fast instruction buffer VCPU notifies other services VCPU to refresh their respective fast instruction buffers after the original function is patched. When the last service VCPU patches the original function, if the other service VCPU executes the original function, the first instruction from the original function enters the exception processing, and then jumps from the exception processing to the first address of the patch function. Execute the instructions in the patch function. Therefore, when the last service VCPU performs a patch operation on the original function, it does not affect the normal service processing of other service VCPUs, and does not cause service congestion and loss.

FIG. 13 is a schematic structural diagram of an apparatus for patching a shared code segment according to a thirteenth embodiment of the present invention. As shown in FIG. 13, on the basis of the corresponding embodiment of FIG. 12, the embodiment further includes: a second message sending module 124 and a fourth modifying module 123.

If the last VCPU of its own fast instruction buffer is refreshed, the first instruction and the second instruction of the original function are incorrect, and each service VCPU has been notified to send a fast instruction buffer to refresh itself again. The second message sending module 124 of the embodiment may send a second activation patch message to each service VCPU to indicate the last VCPU that refreshes its own fast instruction buffer. Modify one instruction and the second instruction of the original function to the original instruction of the original function.

Specifically, the fourth modification module 123, after the first message sending module sends the first patch activation message to the service VCPU, modify the first instruction of the original function to jump to the abnormal processing instruction in the shared memory. The second message sending module 124 sends the second patch activation message to each service VCPU after the first modification module 123 modifies the first instruction of the original function to jump to the exception processing instruction in the shared memory. The activation message is used to instruct each service VCPU to refresh its own fast instruction buffer, so that the instructions in the fast instruction buffer of each service VCPU itself are updated synchronously with the instructions in the shared memory. The second patch activation message also indicates that the VCPU of the fast instruction buffer of each service VCPU is refreshed by itself, and in the shared memory, the first instruction and the second instruction of the original function are restored to the original function. instruction.

For the working mechanism of each module in this embodiment, refer to the description in the corresponding embodiment of FIG. 6, and details are not described herein again.

In this embodiment, in the running process of the multi-core processor system, if the patching operation of the original function occurs If the instruction of the original function needs to be restored, the fourth modification module 124 first modifies the first instruction of the original function to jump to the exception processing instruction, and the second message sending module 123 sends the second patch activation to the service VCPU. Message. After the service VCPU processes the current service, after refreshing its own fast instruction buffer according to the second patch activation message, if the other service VCPU executes the first instruction of the original function, it jumps to the exception processing instruction, according to the jump to The exception-handled instruction enters the exception handling, and then jumps from the exception handling to the first address of the patch function to execute the instruction in the patch function. Therefore, when the last service VCPU restores the original function, it does not affect the normal service processing of other service VCPUs, and does not cause service congestion and loss.

FIG. 14 is a schematic structural diagram of an apparatus for patching a shared code segment according to a fourteenth embodiment of the present invention. As shown in FIG. 14, the embodiment includes: a first receiving module 141, a second patch module 142, and a first refresh notification module 143 and a determining module 144.

After the first receiving module 141 receives the first patch activation message sent by the primary VCPU, the determining module 144 determines. Current Service VCPU is the last service VCPU that refreshes its own fast instruction buffer. When the determining module 144 determines that the current service VPCU is the last service VCPU that refreshes its own fast command buffer, the second patch module 142 modifies the first two instructions of the original function in the shared memory according to the indication of the first patch activation message. The first refresh notification module 143 refreshes the fast instruction buffer of the service VCPU after the second patch module modifies the first instruction and the second instruction of the original function into the instruction to jump to the patch function in the shared memory, and The VCPU notifies the other service VCPUs other than the service VCPU that refreshes its own fast instruction buffer by the main VCPU to refresh its own fast instruction buffer, so that the instruction in the fast instruction buffer of the service VCPU itself and the instruction in the shared memory Synchronization Update.

For the working mechanism of each module in this embodiment, reference is made to the description in the corresponding embodiment in FIG. 7a and FIG. 7b, and details are not described herein again.

The embodiment of the present invention is a device for patching a shared code segment. During the running of the multi-core processor system, the main VCPU modifies the first instruction of the original function to jump to the instruction of the exception processing, and sends a patch activation message to the service VCPU. , the service VCPU refreshes the fast instruction buffer after processing the current service. The last service VCPU that refreshes the fast instruction buffer, after patching the original function, notifies other service VCPUs to refresh their respective fast instruction buffers. When the last service VCPU patches the original function, if the other service VCPU executes the original function, the first instruction from the original function enters the exception processing, and then jumps from the exception processing to the first address of the patch function. Execution The instruction in the function. Therefore, when the second patch module 142 performs the patch operation on the original function, it does not affect the normal service processing of other service VCPUs, and does not cause service congestion and loss.

In the above scheme, if the patching operation of the original function by the second patch module 142 is incorrect, and the instruction of the original function needs to be restored, the main VCPU first sets the first function of the original function so as not to affect the normal execution of the service VCPU. The instruction is modified to jump to the exception handling instruction, and then sends a second patch activation message to the service VCPU. The second patch activation message indicates that the last service VCPU resumes the first two instructions of the original function before refreshing its own fast instruction buffer. Therefore, on the basis of the corresponding embodiment of FIG. 14, the corresponding embodiment of FIG. 15 further includes: a second receiving module 145 and a second recovery module 146 and a second refresh notification module 147. Figure 15 is a block diagram showing the structure of a device for patching a shared code segment according to a fifteenth embodiment of the present invention.

After the second patch module 142 modifies the first instruction and the second instruction of the original function into the instruction to jump to the patch function in the shared memory, the second receiving module 145 receives the second patch activation message sent by the primary VCPU. Time. The judging module 144 judges that the current service VCPU is the last service VCPU that refreshes its own fast instruction buffer. The second recovery module 146 restores the first instruction and the second instruction of the original function to the instruction before the original function modification in the shared memory after the service VCPU processes the current service according to the indication of the second patch activation message. .

The second refresh notification module 147 restores the first instruction and the second instruction of the original function to the instruction before the original function modification in the shared memory, and refreshes the fast instruction buffer of the service VCPU. The area, and the main VCPU notifies the service VCPU except the service VCPU that refreshes its own fast instruction buffer to refresh its own fast instruction buffer, so that the instruction and sharing in the fast instruction buffer of the service VCPU itself In-memory instructions are updated synchronously.

In this embodiment, after the service VCPU processes the current service and refreshes its own fast instruction buffer according to the second patch activation message, if the service VCPU executes the first instruction to the original function, the instruction jumps to the exception processing instruction, according to The instruction that jumps to the exception handling enters the exception handling, and then jumps from the exception handling to the first address of the patch function to execute the instruction in the patch function. Therefore, when the second recovery module 146 performs the recovery operation on the original function, it does not affect the normal service processing of other service VCPUs, and does not cause service blocking and loss.

FIG. 16 is a diagram of a device for patching a shared code segment according to a sixteenth embodiment of the present invention. Figure 16 The present embodiment further includes: a fifth refresh module 148, a third exception processing module 149, and a third patch function execution module 140, based on the corresponding embodiment of FIG.

After the first receiving module 141 receives the first patch activation message sent by the primary VCPU or the second receiving module 145 receives the second patch activation message sent by the primary VCPU, the fifth refreshing module 148 determines in the determining module 144 that the current service VCPU is not When the service VCPU of the fast instruction buffer of the current service is refreshed, after the current service VCPU processes the current service, the fast instruction buffer of the service VCPU is refreshed according to the indication of the first patch activation message or the second patch activation message. Thereby, the instructions in the fast instruction buffer of each service VCPU itself are updated synchronously with the instructions in the shared memory. When the service VCPU executes the first instruction to the original function, the third exception processing module 149 enters the exception processing according to the instruction of the original function to jump to the exception processing; and in the exception processing, according to the first address of the original function, Find the first address of the patch function in the patch area. After the third exception processing module 149 finds the first address of the patch function, the third patch function execution module 140 jumps from the exception processing to the patch function according to the first address of the patch function.

The working mechanism of each of the above modules is described in the corresponding embodiments in FIG. 7a, FIG. 7b, FIG. 8a and FIG. 8b, and details are not described herein again.

The embodiment of the present invention is a device for patching a shared code segment. During the running of the multi-core processor system, the main VCPU modifies the first instruction of the original function to jump to the instruction of the exception processing, and sends a patch activation message to the service VCPU. , the service VCPU refreshes the fast instruction buffer after processing the current service. The last service that refreshes the fast instruction buffer VCPU notifies other services VCPU to refresh their respective fast instruction buffers after the original function is patched. When the last service VCPU patches the original function, if the other service VCPU executes the original function, the first instruction from the original function enters the exception processing, and then jumps from the exception processing to the first address of the patch function. Execute the instructions in the patch function. Therefore, when the second patch module 142 performs the patch operation on the original function, it does not affect the normal service processing of the VCPU of other services, and does not cause service congestion and loss.

Through the description of the above embodiments, those skilled in the art can clearly understand that the present invention can be implemented by means of software plus a necessary hardware platform, and of course, all can be implemented by hardware, but in many cases, the former is better. Implementation. Based on such understanding, all or part of the technical solution of the present invention contributing to the background art may be embodied in the form of a software product, which may be stored in a storage medium such as a ROM/RAM, a magnetic disk, an optical disk, or the like. , including a number of instructions to make a computer device (which can be a personal computer, server, or network device) Etc.) Performing the methods described in various embodiments of the invention or in certain portions of the embodiments.

It should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention and are not intended to be limiting, although the present invention will be described in detail with reference to the preferred embodiments. The technical solutions of the present invention may be modified or equivalently substituted, and the modified technical solutions may not deviate from the spirit and scope of the technical solutions of the present invention.

Claims

Rights request

A method for patching a shared code segment, the method comprising:

The second interrupt information is sent to the service VCPU, and the second interrupt information is used to instruct the service VCPU to interrupt the current service and refresh its own fast instruction buffer.

2. The method for patching a shared code segment according to claim 1, wherein after the sending the second interrupt information to the service VCPU, the method further includes:

Before restoring the first instruction and the second instruction of the original function, modifying the first instruction of the original function into an instruction that jumps to the exception processing in the shared memory;

Sending a third interrupt message to the service VCPU, where the third interrupt information is used to instruct the service VCPU to interrupt the current service and refresh its own fast instruction buffer;

Returning, in the shared memory, the first instruction and the second instruction of the original function to an instruction before modifying the original function;

And sending, by the service VCPU, fourth interrupt information, where the fourth interrupt information is used to instruct the service VCPU to interrupt the current service and immediately refresh the respective fast instruction buffers, so that the service VCPU itself has a fast instruction buffer. The instruction in the area is updated synchronously with the instruction in the shared memory.

3. A method for patching a shared code segment, the method comprising:

After receiving the first interrupt information sent by the main VCPU, interrupting the current service according to the instruction of the first interrupt information, and refreshing the fast instruction buffer, so that the instruction in the fast instruction buffer of the service VCPU itself is The instruction in the shared memory is synchronously updated, and the original function is a function that needs to be patched;

When executing the first instruction of the original function, according to the first instruction of the original function, entering an exception processing, in which the patch function is found in the patch area according to the first address of the original function. a first address of the number, the patch function is a function that replaces the original function; and jumps from the exception processing to the patch function according to a first address of the patch function;

The method for patching a shared code segment according to claim 3, wherein after interrupting the current service and refreshing the fast instruction buffer according to the indication of the second interrupt information, the method further includes:

After receiving the third interrupt information sent by the main VCPU, according to the indication of the third interrupt information, interrupting the current service, refreshing its own fast instruction buffer, so that the fast instruction buffer of the service VCPU itself The middle instruction is updated synchronously with the instruction in the shared memory;

When the first instruction of the original function is executed, according to the first instruction of the original function of the main VCPU, the exception processing is entered; in the exception processing, according to the first address of the original function to be patched, in the patch The area finds a first address of the patch function; according to the first address of the patch function, jumps from the exception processing to the patch function;

Receiving an indication of the fourth interrupt information sent by the host VCPU after interrupting the current service and refreshing the fast command buffer according to the indication of the third interrupt information;

And interrupting the current service according to the indication of the fourth interrupt information, and refreshing its own fast instruction buffer area, so that the instruction in the fast instruction buffer of the service VCPU itself is updated synchronously with the instruction in the shared memory.

5. A method for patching a shared code segment, the method comprising:

Sending a first patch activation message to each service VCPU, where the first patch activation message is used to indicate that the service VCPU refreshes its own fast instruction buffer after processing the current service, so that the service VCPU itself has a fast instruction. The instruction in the buffer is updated synchronously with the instruction in the shared memory; the VCPU indicating the last refresh instruction buffer of its own, modifying the original function in the shared memory before refreshing its own fast instruction buffer The first instruction and the second instruction.

The method for patching the shared code segment according to claim 5, further comprising: after sending the first patch activation message to the service VCPU,

Before restoring the first instruction and the second instruction of the original function, modifying, in the shared memory, the first instruction of the original function to jump to an instruction for exception processing;

Sending a second patch activation message to the service VCPU, where the second patch activation message is used to instruct the service VCPU to refresh its own fast instruction buffer, so that the service VCPU itself has a fast instruction buffer instruction Synchronizing with the instruction in the shared memory; indicating that the service VCPU of the service VCPU last refreshing its own fast instruction buffer, before the refreshing its own fast instruction buffer, the original function in the shared memory The first instruction and the second instruction are restored to the instruction before the function modification.

7. A method for patching a shared code segment, the method comprising:

When the service VCPU is the last service VCPU that refreshes its own fast instruction buffer, according to the instruction of the first patch activation message, the first instruction and the second instruction of the original function are modified in the shared memory. For the instruction to jump to the patch function, the original function is a function that needs to be patched;

8. The method for patching a shared code segment according to claim 7, wherein the first instruction and the second instruction of the original function are modified into the jump to patch function in a shared memory. After the instructions, it also includes:

Receiving a second patch activation message sent by the primary VCPU;

When the service VCPU is the last service VCPU that refreshes its own fast instruction buffer, according to the indication of the second patch activation message, after processing the current service, the original function is used in the shared memory. The first instruction and the second instruction are restored to the instruction before the modification of the principle function;

The service VCPU refreshes its own fast instruction buffer, and notifies the VCPU of the service VCPU other than the service VCPU that refreshes its own fast instruction buffer by the main VCPU. Refreshing its own fast instruction buffer to synchronize the instructions in the fast instruction buffer of the service VCPU itself with the instructions in the shared memory.

The method for patching a shared code segment according to claim 8, further comprising: when the service VCPU is not the last service VCPU that refreshes its own fast instruction buffer, according to the first The instruction of the patch activation message or the second patch activation message refreshes its own fast instruction buffer after the current service is processed, so that the instruction in the fast instruction buffer of each service VCPU itself is updated synchronously with the instruction in the shared memory;

When executing the first instruction to the original function, according to the first instruction of the original function, entering an exception processing; in the exception processing, searching for the content in the patch area according to the first address of the original function The first address of the patch function;

According to the first address of the patch function, jump from the exception processing to execution in the patch function.

10. A device for patching a shared code segment, comprising:

The device for patching a shared code segment according to claim 10, further comprising:

a second modifying module, configured to: after the second interrupt information is sent to the service VCPU, before recovering the first instruction and the second instruction of the original function, the first instruction of the original function is in the shared memory Modified to jump to the exception handling instructions;

a third interrupt module, configured to: in the shared memory, modify the first instruction of the original function to jump to the instruction of the exception processing, and send a third interrupt message to the service VCPU, where The third interrupt information is used to indicate that the service VCPU interrupts the current service and refreshes its own fast instruction buffer.

a first recovery module, configured to: after the third interrupt module sends a third interrupt message to the service VCPU, restore the first instruction and the second instruction of the original function in the shared memory The instruction before the modification of the original function in pairs;

a fourth interrupt module, configured to: after the first recovery module restores the first instruction and the second instruction of the original function in the shared memory, to an instruction before modifying the original function, Sending a fourth interrupt information to the service VCPU, where the fourth interrupt information is used to instruct the service VCPU to interrupt the current service and immediately refresh the respective fast instruction buffers, so that the fast instruction buffer of the service VCPU itself is buffered. The instruction in the area is updated synchronously with the instruction in the shared memory.

12. A device for patching a shared code segment, comprising:

a first refreshing module, configured to: after receiving the first interrupt information sent by the main VCPU, interrupt the current service according to the indication of the first interrupt information, and refresh the fast instruction buffer to enable the fast instruction of the service VCPU itself The instruction in the buffer is updated synchronously with the instruction in the shared memory, and the original function is a function that needs to be patched;

a second refreshing module, configured to: after the first refreshing module interrupts the current service according to the indication of the first interrupt information, after receiving the fast instruction buffer, receiving the second interrupt information sent by the primary VCPU, according to the The instruction of the second interrupt information interrupts the current service, and refreshes its own fast instruction buffer, so that the instruction in the fast instruction buffer of the service VCPU itself is updated synchronously with the instruction in the shared memory.

The device for patching a shared code segment according to claim 12, further comprising:

a third refreshing module, configured to: after the second refreshing module refreshes the fast instruction buffer, after receiving the third interrupt information sent by the primary VCPU, interrupting the current service according to the indication of the third interrupt information, Refreshing its own fast instruction buffer, so that the instruction in the fast instruction buffer of the service VCPU itself is updated synchronously with the instruction in the shared memory;

a second exception processing module, configured to: when the third refresh module refreshes the fast instruction buffer, execute the first instruction to the original function, according to the first instruction of the original function of the main VCPU , enter exception handling; in exception handling, according to the first address of the original function to be patched, find the first address of the patch function in the patch area;

a second patch execution module, configured to: after the first exception processing module finds the first address of the patch function, jump from the exception processing to the patch function according to the first address of the patch function ;

a fourth refreshing module, configured to: after the third refreshing module interrupts the current service according to the indication of the third interrupt information, refreshing the fast instruction buffer of the third refreshing module, and receiving the fourth interrupt information sent by the main VCPU Instructing, according to the indication of the fourth interrupt information, interrupting the current service, and refreshing its own fast instruction buffer, so that the instruction in the fast instruction buffer of the service VCPU itself is updated synchronously with the instruction in the shared memory.

14. A device for patching a shared code segment, comprising:

a third modification module, configured to modify, in the shared memory, the first instruction of the original function to jump to an exception processing instruction before the original function is patched, where the original function is a function that needs to be patched; a message sending module, configured to: in the shared memory, modify the first instruction of the original function to jump to the instruction of the exception processing, and send a first patch activation message to each service VCPU, where The first patch activation message is used to indicate that the service VCPU refreshes its own fast instruction buffer after processing the current service, so that the instruction in the fast instruction buffer of the service VCPU itself is updated synchronously with the instruction in the shared memory. The VCPU indicating the last refresh instruction buffer of its own, the first instruction and the second instruction of the original function are modified in the shared memory before refreshing its own fast instruction buffer.

The device for patching a shared code segment according to claim 14, further comprising: a fourth modification module, configured to: after the first message sending module sends a first patch activation message to the service VCPU, modify the first instruction of the original function to a jump in the shared memory An instruction to the exception handling;

a second message sending module, configured to: in the shared memory, modify the first instruction of the original function to jump to an instruction of exception processing, and send a second message to the service VCPU a patch activation message, the second patch activation message is used to indicate that the service VCPU refreshes its own fast instruction buffer after processing the current service, so that the instruction in the fast instruction buffer of the service VCPU itself is The instruction in the shared memory is synchronously updated; indicating that the service VCPU of the service VCPU last refreshing its own fast instruction buffer, before refreshing its own fast instruction buffer, the first function of the original function in the shared memory The instruction and the second instruction are restored to the instruction before the modification of the original function.

16. A device for patching a shared code segment, comprising:

a second patch module, configured to: when the determining module determines that the service VCPU is the last service VCPU that refreshes its own fast instruction buffer, according to the indication of the first patch activation message, the original The first instruction and the second instruction of the function are modified into the instruction to jump to the patch function, and the original function is a function that needs to be patched;

a first refresh notification module, configured to refresh the service after the second patch module modifies the first instruction and the second instruction of the original function into the instruction to jump to the patch function in the shared memory

a fast instruction buffer of the VCPU, and the other VCPUs other than the service VCPU that refreshes its own fast instruction buffer are notified by the main VCPU to refresh its own fast instruction buffer, so that the service VCPU itself The instructions in the fast instruction buffer are updated synchronously with the instructions in the shared memory.

The device for patching a shared code segment according to claim 16, further comprising:

a second receiving module, configured to: after the first refresh notification module refreshes the fast instruction buffer of the service VCPU, receive a second patch activation message sent by the primary VCPU;

a recovery module, configured to determine, in the determining module, that the service VCPU is the last brush When the service VCPU of the new fast instruction buffer is new, according to the indication of the second patch activation message, after the current service is processed, the first instruction and the second instruction of the original function are in the shared memory. An instruction to restore the instruction before the modification of the original function;

a second refresh notification module, configured to: after the second recovery module restores the first instruction and the second instruction of the original function in the shared memory, to an instruction before modifying the original function Refreshing the fast instruction buffer of the service VCPU, and notifying the service VCPU other than the service VCPU that refreshes its own fast instruction buffer by the main VCPU to refresh its fast instruction buffer, The instruction in the fast instruction buffer of the service VCPU itself is updated synchronously with the instruction in the shared memory.

18. The apparatus for patching a shared code segment according to claim 17, further comprising:

a fifth refreshing module, configured to: when the determining module determines that the service VCPU is not the last service VCPU that refreshes its own fast instruction buffer, according to the indication of the first patch activation message or the second patch activation message After the service VCPU processes the current service, refresh the fast instruction buffer of the service VCPU, so that the instruction in the fast instruction buffer of each service VCPU itself is updated synchronously with the instruction in the shared memory;

a third exception processing module, configured to: after the fifth refresh module refreshes the fast instruction buffer of the service VCPU, execute the first instruction to the original function, according to the first instruction of the original function, Entering the exception processing; in the exception processing, searching for the first address of the patch function in the patch area according to the first address of the original function;

a third patch function execution module, configured to: after the third exception processing module finds the first address of the patch function, jump from the exception processing to the patch function according to the first address of the patch function carried out.