CN107797820B

CN107797820B - Method and device for generating patch

Info

Publication number: CN107797820B
Application number: CN201711115857.8A
Authority: CN
Inventors: 刘琦; 张宇
Original assignee: Beijing Baidu Netcom Science and Technology Co Ltd
Current assignee: Beijing Baidu Netcom Science and Technology Co Ltd
Priority date: 2017-11-13
Filing date: 2017-11-13
Publication date: 2021-03-23
Anticipated expiration: 2037-11-13
Also published as: US20190146777A1; US11169792B2; CN107797820A

Abstract

The embodiment of the application discloses a method and a device for generating a patch file. One embodiment of the method comprises: acquiring a first target file for creating a target process, wherein the first target file comprises a first symbol table; acquiring a second target file obtained by compiling according to the target source code file, wherein the second target file comprises a second symbol table; determining a difference symbol between the first target file and the second target file by using the first symbol table and the second symbol table; and generating a patch file according to the difference symbol. The implementation enriches the way in which patch files are generated.

Description

Method and device for generating patch

Technical Field

The embodiment of the application relates to the technical field of computers, in particular to the technical field of internet, and particularly relates to a method and a device for generating patches.

Background

In the computer field, after a program is operated on line, errors in the program can be found over time. At this time, the patch file is needed to be used to correct the program or process in time.

The existing way of generating a patch file is usually to manually write out the patch file by a programmer.

Disclosure of Invention

The embodiment of the application provides a method and a device for generating a patch.

In a first aspect, an embodiment of the present application provides a method for generating a patch, where the method includes: acquiring a first target file for creating a target process, wherein the first target file comprises a first symbol table; acquiring a second object file compiled according to an object source code file, wherein the second object file comprises a second symbol table; determining a difference symbol between the first target file and the second target file using the first symbol table and the second symbol table; and generating a patch file according to the difference symbol.

In a second aspect, an embodiment of the present application provides an apparatus for generating a patch, where the apparatus includes: a first obtaining unit, configured to obtain a first target file for creating a target process, where the first target file includes a first symbol table; a second obtaining unit, configured to obtain a second object file compiled according to an object source code file, where the second object file includes a second symbol table; a determination unit configured to determine a difference symbol between the first target file and the second target file using the first symbol table and the second symbol table; and the generating unit is used for generating the patch file according to the difference symbol.

In a third aspect, an embodiment of the present application provides an electronic device, where the electronic device includes: one or more processors; storage means for storing one or more programs which, when executed by the one or more processors, cause the one or more processors to carry out the method according to the first aspect.

In a fourth aspect, embodiments of the present application provide a computer-readable storage medium on which a computer program is stored, which when executed by a processor, implements the method according to the first aspect.

According to the method and the device for generating the patch, a first target file for creating a target process is obtained, wherein the first target file comprises a first symbol table; acquiring a second object file compiled according to an object source code file, wherein the second object file comprises a second symbol table; determining a difference symbol between the first target file and the second target file using the first symbol table and the second symbol table; and generating the patch file according to the difference symbol, thereby enriching the generation mode of the patch file.

Drawings

Other features, objects and advantages of the present application will become more apparent upon reading of the following detailed description of non-limiting embodiments thereof, made with reference to the accompanying drawings in which:

FIG. 1 is an exemplary system architecture diagram in which the present application may be applied;

FIG. 2 is a flow diagram of one embodiment of a method for generating a patch in accordance with the present application;

FIG. 3 is a process diagram of a create process;

FIG. 4 is a flow diagram of one implementation of step 203;

FIG. 5 is a flow diagram of yet another embodiment of a method for generating a patch in accordance with the present application;

FIG. 6 is a schematic diagram illustrating one embodiment of an apparatus for generating a patch according to the present application;

FIG. 7 is a block diagram of a computer system suitable for use in implementing the electronic device of an embodiment of the present application.

Detailed Description

The present application will be described in further detail with reference to the following drawings and examples. It is to be understood that the specific embodiments described herein are merely illustrative of the relevant invention and not restrictive of the invention. It should be noted that, for convenience of description, only the portions related to the related invention are shown in the drawings.

It should be noted that the embodiments and features of the embodiments in the present application may be combined with each other without conflict. The present application will be described in detail below with reference to the embodiments with reference to the attached drawings.

Fig. 1 shows an exemplary system architecture 100 to which embodiments of the method for generating a patch or the apparatus for generating a patch of the present application may be applied.

As shown in fig. 1, the system architecture 100 may include a server 101, a network 102, and

terminal devices

103, 104. The network 102 serves as a medium for providing communication links between the server 101 and the

terminal devices

103, 104. Network 102 may include various connection types, such as wired, wireless communication links, or fiber optic cables, to name a few.

A user may use

terminal devices

103, 104 to interact with the server 101 over the network 102 to receive or send messages or the like. The

terminal devices

103 and 104 may have various communication client applications installed thereon, such as a web browser application, a shopping application, a search application, an instant messaging tool, a mailbox client, social platform software, and the like.

The

terminal devices

101, 102, 103 may be various electronic devices, including but not limited to smart phones, tablet computers, e-book readers, MP3 players (Moving Picture Experts Group Audio Layer III, mpeg compression standard Audio Layer 3), MP4 players (Moving Picture Experts Group Audio Layer IV, mpeg compression standard Audio Layer 4), laptop and desktop computers, and the like.

The server 101 may be a server providing various services, such as a background server providing support for applications on the

terminal devices

103, 104. The backend server may analyze and otherwise process data such as the patch acquisition request, and feed back a processing result (e.g., a patch file) to the terminal device.

It should be noted that the method for generating the patch provided by the embodiment of the present application is generally executed by the server 101, and accordingly, the apparatus for generating the patch is generally disposed in the server 101.

It should be understood that the number of terminal devices, networks, and servers in fig. 1 is merely illustrative. There may be any number of terminal devices, networks, and servers, as desired for implementation.

In some application scenarios, the system architecture 100 may not include a terminal device and a network. The patch file may also be used for the processes of the server itself, or processes of other servers.

With continued reference to FIG. 2, a flow 200 of one embodiment of a method for generating a patch in accordance with the present application is shown. The method for generating the patch comprises the following steps:

step 201, a first target file for creating a target process is obtained.

In this embodiment, an electronic device (e.g., a server as shown in fig. 1) on which the method for generating a patch operates may obtain a first target file for creating a target process from a local or other electronic device.

It should be noted that reference can be made to fig. 3, which shows a process of creating a process in a general case. From a source code file to an executable file and then to a process, the following processing modules are mainly passed in the middle: preprocessor, compiler, linker, loader and dynamic linker. Static libraries are also needed during processing.

In this embodiment, a file generated after the compiler compiles the source code is called an object file. The object file is structurally already an executable file after compilation, but has not yet undergone a linking process. Some of which have not been adjusted. In essence, the object file itself may be stored in an executable file format. The object file may include compiled machine instruction code, data. The target file may also include some information needed for linking, such as symbol tables, debugging information, string tables, relocation tables, etc.

It should be noted that the target process may be a designated process, and the target file is a file generated by a compiling process specified in the computer field.

In some optional implementations of this embodiment, the target process may be a process waiting for update. The target process may be updated with the patch file. An update of a process may also be referred to as an upgrade of the process. As an example, the target process may be a user-mode process of the virtual machine.

Alternatively, the address space of the old version of the process (target process) may be modified to obtain the new version of the process. In the process, the time for process interruption is short, so that the functions realized by the process can be upgraded without being aware of the interruption. It should be noted that the device for creating the target process may be the same as or different from the electronic device described above.

In this embodiment, if the target process is obtained after the target file passes through the linker, the loader and the dynamic connector, the target file may be referred to as a target file for creating the target process. The first of the first object files is to distinguish the object file used to create the object process from an object file referred to as the second object file below.

In this embodiment, the first target file may include a first symbol table.

In this embodiment, the symbol table may be a segment in the target file. Typically, the target file will have a corresponding symbol table. All symbols used by the target file are recorded in the table. The symbol table may record symbol names and symbol values. The function name and the variable name are symbolic names. If the symbol is a definition of a function or variable, the value of the symbol may be the address of the function or variable.

In some optional implementations of this embodiment, the first target file may be compiled from an old version of the source code file. It should be noted that the first object file corresponding to the object process is compiled before the execution time of step 201.

Step 202, a second object file compiled according to the object source code file is obtained.

In this embodiment, the electronic device may obtain a second object file compiled from the object source code file.

In some optional implementations of this embodiment, the target source code file may be a new version of the source code file obtained by adapting an old version of the source code file.

In this embodiment, the second target file includes a second symbol table. The second symbol table may record symbols used by the second object file.

In this embodiment, the second object file may be compiled by the electronic device before step 202, or may be compiled by another electronic device. The electronic device may obtain the second object file from a local or other electronic device.

Step 203, using the first symbol table and the second symbol table, determining a difference symbol between the first target file and the second target file.

In this embodiment, the electronic device may determine the difference symbol between the first target file and the second target file by using the first symbol table and the second symbol table.

In this embodiment, the difference symbol may be a symbol that causes a difference between the symbol set of the first target file and the symbol set of the second target file. As an example, the difference may be because the symbols in the second target file are increased, decreased, or modified relative to the symbols in the first target file.

In some optional implementations of this embodiment, step 203 may be implemented by: and comparing the first symbol table with the second symbol table to determine the difference symbol.

And step 204, generating a patch file according to the difference symbol.

In this embodiment, the electronic device may generate a patch file according to the difference symbol.

In this embodiment, the patch file may be a file for an update process. Optionally, after the patch file is generated in step 204, the target process may be updated by the electronic or other electronic device.

In some optional implementations of this embodiment, step 204 may be implemented by: and acquiring the symbol content of the difference symbol and/or the repositioning item of the difference symbol. And the symbol name of the difference symbol and at least one of the following items: and storing the symbol content and the relocation item into a pre-generated file.

The pre-generated file may be an empty file. And the symbol name of the difference symbol and at least one of the following items: and after the symbol content and the relocation item are stored, a patch file can be obtained after the empty file is stored.

Alternatively, the symbol content may be a function body or a variable value.

Alternatively, the relocation item of the symbol may be used to record the related information required when the symbol is relocated. As an example, the relocation entry may be used to record location information required for relocation.

In some optional implementations of this embodiment, the patch file may include a data section, a relocation section, and a symbol table section. Here, the patch file may be an executable file. The data section, the relocation section and the symbol section may be predefined components of the patch file, and may be similar to a cabinet comprising a first layer and a second layer, the cabinet corresponding to the patch file, the first layer corresponding to the data section, and so on.

In some optional implementations of this embodiment, the above-mentioned symbol name of the difference symbol and at least one of the following: the symbol content and the relocation item are saved in a pre-generated file, and the method can be realized by the following steps: saving the relocation item to a relocation section; storing the symbolic contents to a data section, wherein the symbolic contents in the data section can be indexed to a relocation item stored to a relocation section; and storing the symbol names into a symbol table section, wherein the symbol names stored into the symbol table can index the symbol contents stored into the data section.

In the method provided by the above embodiment of the present application, a first target file for creating a target process is obtained, where the first target file includes a first symbol table; acquiring a second object file compiled according to an object source code file, wherein the second object file comprises a second symbol table; determining a difference symbol between the first target file and the second target file using the first symbol table and the second symbol table; and generating the patch file according to the difference symbol, thereby enriching the mode of generating the patch file.

In some optional implementations of this embodiment, the symbol types of the symbol include a read-only type and a read-write type.

In some optional implementations of this embodiment, please refer to fig. 4, which shows a process 203, where the process 203 may be implemented as follows:

step 2031, according to the symbol types, dividing the symbols in the first symbol table into a first read-only symbol set and a first read-write symbol set, and dividing the symbols in the second symbol table into a second read-only symbol set and a second read-write symbol set.

Alternatively, the read-only type symbols may be symbols that do not change during program execution, such as functions and read-only strings. The read-write type symbols may be symbols that change during program execution, such as global variables and static variables.

Step 2032, comparing the symbol names of the symbols in the first read-write symbol set and the second read-write symbol set, and determining the difference symbol between the second read-write symbol set and the first read-write symbol set.

It should be noted that, for the read-write type symbol, the content of the symbol is not determined during the program running, so that the difference symbol cannot be accurately determined by comparing the content of the symbol, and the calculation resource is increased. Therefore, the addition and deletion can be directly judged according to the symbol name.

Step 2033 compares the first symbol content of the first symbol with the second symbol content of the second symbol.

In this implementation, the first symbol is a symbol in the first set of read-only symbols, and the second symbol is a symbol in the second set of read-only symbols that corresponds to the first symbol.

It should be noted that the first target file and the second target file are compiled from an old version of the source code file and a new version of the source code file, respectively. Since the main body and naming mode of the source code file are usually not changed greatly when the source code file is improved from an old version to a new version, the part of the first target file having the corresponding relationship with the second target file can be determined in various modes (such as location comparison, homonymy lookup) and the like.

Alternatively, step 2033 may be implemented by: determining whether the relocation type is the same and whether the used symbol is the same for the byte needing relocation in the first symbol content and the second symbol content; determining whether the bytes which do not need to be relocated are the same in the first symbol content and the second symbol content.

It should be noted that, for bytes that do not need to be relocated, direct comparison is possible. For bytes that need to be relocated, the comparison can be made according to the type of relocation and the sign used at the time of relocation.

It should be noted that, for a symbol, the symbol content can be said to have no change only when the byte that needs to be relocated and the byte that does not need to be relocated are completely the same. Otherwise, it may be that the symbols have been modified.

At step 2034, an indicator is generated.

In this implementation, the indicator is a no-difference indicator or a difference type indicator, the no-difference indicator is used to indicate that the first symbol content and the second symbol content are the same, the difference type indicator is used to indicate a difference type of the second symbol content relative to the first symbol content, and the difference type includes addition, deletion, and modification.

Step 2035, determining a difference symbol between the first set of read-only symbols and the second set of read-only symbols based on the indicator.

The difference symbols obtained in step 2032 and step 2035 are summarized to obtain the difference symbol between the first target file and the second target file.

With further reference to FIG. 5, a flow 500 of yet another embodiment of a method for generating a patch is shown. The process 500 of the method for generating a patch includes the following steps:

step 501, a first target file for creating a target process is obtained.

In this embodiment, an electronic device (e.g., a server shown in fig. 1) on which the method for generating a patch operates may obtain a first target file for creating a target process.

Step 502, a second object file compiled according to the object source code file is obtained.

Step 503, using the first symbol table and the second symbol table, determining a difference symbol between the first target file and the second target file.

And step 504, generating a patch file according to the difference symbol.

It should be noted that details and technical effects of step 501, step 502, step 503 and step 504 may refer to the descriptions of step 201, step 202, step 203 and step 204, and are not described herein again.

In some alternative implementations of this embodiment, the symbols comprise functions. Before step 505, this embodiment may further include: acquiring a current function call chain of the target process; determining whether the functions included in the function call chain and the functions in the patch file have intersection or not according to the function names; if not, determining that the preset pause condition is met.

It should be noted that if the functions included in the function call chain intersect with the functions in the patch file, and the functions that intersect with each other are modified during the call, many uncertainties may be caused. For example, the pre-update function may contain a main loop, so the target process may not exit the pre-update function, and then patching is meaningless at this time. The number of parameters before and after updating may not be consistent. If patched at this point, the target process may be caused to crash.

Alternatively, the function call chain may be acquired in various ways. For example, the entire call chain may be obtained using a call chain viewing interface provided by the system. And traversing the stack top of the process to the stack bottom of the process to obtain each stack frame and further obtain a call chain of the function.

Alternatively, the target process may be periodically paused and traced back to its current chain of function calls for comparison with the functions in the patch. And when the two have no intersection, starting the loading and the linking of the patch.

And 505, under the condition that a preset pause condition is met, pausing the target process and loading the generated patch file.

In this embodiment, the electronic device may suspend the target process and load the generated patch file when a preset suspension condition is satisfied.

In this embodiment, the target process may be a process waiting for updating, and is obtained from an old version of the source code file. The target source code file may be a new version of the source code file obtained by adapting an old version of the source code file.

In some alternative implementations of this embodiment, several instructions to be executed in a code segment of the target process may be backed up after the target process is halted. Then, within the target process, address space is allocated for the patch file. Then, the function, character string, variable, etc. in the patch are copied to the address space just allocated.

Alternatively, the suspending of the target process and the loading of the patch file may be implemented in various ways. As an example, it can be implemented by a system interface provided by the system with corresponding functionality.

Step 506, the target process and the loaded patch file are linked to update the target process.

In this embodiment, the electronic device may link the target process and the loaded patch file to update the target process.

In this embodiment, when linking the loaded patch file and the target process, three types of data may need to be modified, which is as follows: the function or variable within the patch may need to be accessed. The function or variable within the patch may need to access an existing function or variable in the target process. The old process may have existing functions or variables that need to be accessed within the patch.

Here, the third case requires special consideration: the target process cannot access the newly added variable in the patch. Whatever function that calls the newly added variable is necessarily the function that has changed and is therefore already included in the patch. The target process may access the function in the patch where the modification occurred. At this time, an indirect access method is used, namely, the first instruction of the same-name function in the target process is modified, and the function in the patch is changed into the function in the patch.

It should be noted that, besides simplifying the linking process, the above-mentioned linking method has the following advantages: the target process may use a variable to hold a function pointer and use the function pointer to call the function. If the called function has errors, only the first instruction of the old function is modified, and the old function is jumped to a new function in the patch, so that the calling to the old function through the function pointer can be avoided.

In some optional implementations of this embodiment, various linking methods may be used to implement the link between the target process and the loaded patch file. For example, for the memory link, a dynamic link mode may be used.

As an example, a loaded patch file, links to two types of symbols: the symbols defined inside the process (when the target process and the load address of the patch file are determined, here the symbol address is determined), the symbols defined in the shared library (calculated when the target process initializes). After calculating the absolute address of the symbol in the shared library, the loaded patch file may be linked to the address of the variable to be stored in the Global Offset Table (GOT) of the target process; the loaded patch file may be linked to a Procedure Link Table (PLT) of the target process, and then the PLT jumps to a corresponding function address stored in the GOT.

In some optional implementation manners of this embodiment, before step 506, this embodiment may further include: and modifying the relative address of the symbol in the first symbol table into an absolute address according to the absolute address of the target process in the address space.

For a program that is not related to a position, a patch can be added to the program using a symbol table in which an absolute address is recorded.

In some optional implementations of this embodiment, step 506 may include: and linking the function in the patch file to the function or the variable in the target process according to the modified first symbol table.

It should be noted that, for a static type symbol, there may be a case where names are the same in different sub-target files, and a symbol desired to be found cannot be uniquely determined in a plurality of sub-target files of a target file according to a symbol name.

In some optional implementations of this embodiment, the second object file includes at least two sub second object files. The embodiment may further include: for each sub second target file, a set of symbol names corresponding to the sub second target file is generated, the set of symbol names including symbol names of symbols of a static type in the sub second target file.

It should be noted that the generated symbol name set corresponding to the sub second target file has a mark indicating that it corresponds to the sub second target file. In the generation process of the target file, a plurality of sub target files of the executable file can be distinguished by adding separators. Accordingly, each second target file and the symbol name set corresponding to the mark can be defined.

As an example, the sub second target file a includes a static variable a and a static variable B, and a symbol name set { static variable a, static variable B } corresponding to the sub second target file a may be generated. The sub second target file B includes a static variable a and a static variable C, and a symbol name set { static variable a, static variable C } corresponding to the sub second target file B may be generated. The patch file comprises a static variable A, and the static variable A in the patch file is marked to indicate that the patch file belongs to the second target file A.

In some optional implementations of this embodiment, the first object file includes at least two sub first object files. Step 506 may include, for a static type target symbol in the patch file, searching a sub-first target file corresponding to a sub-second target file where the target symbol is located according to a symbol name set corresponding to the sub-second target file where the target symbol is located; and searching the symbol corresponding to the target symbol in the searched sub first target file.

As an example, the sub first target file a includes a static variable a and a static variable B, and a symbol name set { static variable a, static variable B } corresponding to the sub first target file a may be generated. The sub first target file B includes a static variable a and a static variable C, and a symbol name set { static variable a, static variable C } corresponding to the sub first target file B may be generated.

For the static variable a in the patch file, the static variable a may be according to the above. And finding the sub first target file A corresponding to the target sub second target file A by using the symbol name set { static variable A, static variable B } corresponding to the sub second target file A. And then, searching the symbol static variable A in the sub first target file A corresponding to the target symbol in the searched sub first target file.

In some optional implementation manners of this embodiment, after step 506, this embodiment may further include updating the first symbol table according to the updated symbol in the target process after the target process is updated.

Since a new symbol table is generated after the patch is input, the new symbol table can be used at the next patch input, and thus, multiple patch inputs can be supported.

As can be seen from fig. 5, compared with the embodiment corresponding to fig. 2, the process 500 of the method for generating a patch in this embodiment highlights a step of directly modifying the address space of the target process to update the target process after the patch is loaded, so as to implement process update.

With further reference to fig. 6, as an implementation of the method shown in the above figures, the present application provides an embodiment of an apparatus for generating a patch, where the embodiment of the apparatus corresponds to the embodiment of the method shown in fig. 2, and the apparatus may be applied to various electronic devices.

As shown in fig. 6, the apparatus 600 for generating a patch according to the present embodiment includes: a first acquisition unit 601, a second acquisition unit 602, a determination unit 603, and a generation unit 604. The system comprises a first acquisition unit, a second acquisition unit and a third acquisition unit, wherein the first acquisition unit is used for acquiring a first target file for creating a target process, and the first target file comprises a first symbol table; a second obtaining unit, configured to obtain a second object file compiled according to an object source code file, where the second object file includes a second symbol table; a determination unit configured to determine a difference symbol between the first target file and the second target file using the first symbol table and the second symbol table; and the generating unit is used for generating the patch file according to the difference symbol. .

In this embodiment, specific processes of the first receiving unit 601, the selecting unit 602, the determining unit 603, and the first generating unit 604 and technical effects thereof can refer to the related descriptions of step 201, step 202, step 203, and step 204 in the corresponding embodiment of fig. 2, which are not repeated herein.

In some optional implementations of this embodiment, the symbol types of the symbol include a read-only type and a read-write type; and the determining unit is further configured to: and dividing the symbols in the first symbol table into a first read-only symbol set and a first read-write symbol set according to the symbol types of the symbols, and dividing the symbols in the second symbol table into a second read-only symbol set and a second read-write symbol set.

In some optional implementation manners of this embodiment, the determining unit is further configured to: and comparing the symbol names of the symbols in the first read-write symbol set and the second read-write symbol set to determine the difference symbol between the second read-write symbol set and the first read-write symbol set.

In some optional implementation manners of this embodiment, the determining unit is further configured to: comparing a first symbol content of a first symbol to a second symbol content of a second symbol, wherein the first symbol is a symbol in the first set of read-only symbols and the second symbol is a symbol in the second set of read-only symbols that corresponds to the first symbol; generating an indicator, wherein the indicator is a no difference indicator for indicating that the first symbol content and the second symbol content are the same or a difference type indicator for indicating a difference type of the second symbol content relative to the first symbol content, and the difference type includes addition, deletion and modification.

In some optional implementation manners of this embodiment, the determining unit is further configured to: determining whether the relocation type is the same and whether the used symbol is the same for the byte needing relocation in the first symbol content and the second symbol content; determining whether the bytes which do not need to be relocated are the same in the first symbol content and the second symbol content.

In some optional implementation manners of this embodiment, the determining unit is further configured to: and determining a difference symbol between the first read-only symbol set and the second read-only symbol set according to the indicator.

In some optional implementation manners of this embodiment, the generating unit is further configured to: acquiring the symbol content of the difference symbol and/or the repositioning item of the difference symbol; a symbol name of the difference symbol and at least one of: and storing the symbol content and the relocation item into a pre-generated file.

In some optional implementations of this embodiment, the patch file includes a data section, a relocation section, and a symbol table section; and a generating unit further configured to: saving the relocation item to a relocation section; storing the symbolic contents to a data section, wherein the symbolic contents in the data section can be indexed to a relocation item stored to a relocation section; and storing the symbol names into a symbol table section, wherein the symbol names stored into the symbol table can index the symbol contents stored into the data section.

In some optional implementations of this embodiment, the apparatus further includes: a loading unit (not shown) for: under the condition that a preset pause condition is met, pausing the target process and loading the generated patch file; a linking unit (not shown) for further: and linking the target process and the loaded patch file to update the target process.

In some optional implementations of this embodiment, the symbol comprises a function; and

the above-mentioned device still includes: a third acquisition unit (not shown) for: acquiring a current function call chain of the target process; an intersection determination unit (not shown) for: determining whether the functions included in the function call chain and the functions in the patch file have intersection or not according to the function names; a condition determining unit (not shown) for: if not, determining that the preset pause condition is met.

In some optional implementation manners of this embodiment, before linking the target process and the loaded patch file to update the target process, the apparatus further includes: a modification unit for: and modifying the relative address of the symbol in the first symbol table into an absolute address according to the absolute address of the target process in the address space.

In some optional implementations of this embodiment, the link unit is further configured to: and linking the function in the patch file to the function or the variable in the target process according to the modified first symbol table.

In some optional implementations of this embodiment, the second target file includes at least two sub second target files; and the above apparatus, further comprising: a set generating unit (not shown) for: for each sub second target file, a set of symbol names corresponding to the sub second target file is generated, the set of symbol names including symbol names of symbols of a static type in the sub second target file.

In some optional implementations of this embodiment, the first object file includes at least two sub first object files; and the linking unit is further configured to: for the target symbols in the patch file and in a static type, searching a sub first target file corresponding to a sub second target file in which the target symbols are located according to a symbol name set corresponding to the sub second target file in which the target symbols are located; and searching the symbol corresponding to the target symbol in the searched sub first target file.

In some optional implementations of this embodiment, the apparatus further includes: an update unit configured to: and after the target process is updated, updating the first symbol table according to the updated symbols in the target process.

It should be noted that, for details of implementation and technical effects of each unit in the apparatus for generating a patch provided in this embodiment, reference may be made to descriptions of other embodiments in this application, and details are not described herein again.

Referring now to FIG. 7, shown is a block diagram of a computer system 700 suitable for use in implementing the electronic device of an embodiment of the present application. The electronic device shown in fig. 7 is only an example, and should not bring any limitation to the functions and the scope of use of the embodiments of the present application.

As shown in fig. 7, the computer system 700 includes a Central Processing Unit (CPU)701, which can perform various appropriate actions and processes in accordance with a program stored in a Read Only Memory (ROM)702 or a program loaded from a storage section 708 into a Random Access Memory (RAM) 703. In the RAM 703, various programs and data necessary for the operation of the system 700 are also stored. The CPU 701, the ROM 702, and the RAM 703 are connected to each other via a bus 704. An input/output (I/O) interface 705 is also connected to bus 704.

The following components are connected to the I/O interface 705: an input portion 706 including a keyboard, a mouse, and the like; an output section 707 including a display such as a Cathode Ray Tube (CRT), a Liquid Crystal Display (LCD), and the like, and a speaker; a storage section 708 including a hard disk and the like; and a communication section 709 including a network interface card such as a LAN card, a modem, or the like. The communication section 709 performs communication processing via a network such as the internet. A drive 710 is also connected to the I/O interface 705 as needed. A removable medium 711 such as a magnetic disk, an optical disk, a magneto-optical disk, a semiconductor memory, or the like is mounted on the drive 710 as necessary, so that a computer program read out therefrom is mounted into the storage section 708 as necessary.

In particular, according to an embodiment of the present disclosure, the processes described above with reference to the flowcharts may be implemented as computer software programs. For example, embodiments of the present disclosure include a computer program product comprising a computer program embodied on a computer readable medium, the computer program comprising program code for performing the method illustrated in the flow chart. In such an embodiment, the computer program can be downloaded and installed from a network through the communication section 709, and/or installed from the removable medium 711. The computer program, when executed by a Central Processing Unit (CPU)701, performs the above-described functions defined in the method of the present application.

It should be noted that the computer readable medium mentioned above in the present application may be a computer readable signal medium or a computer readable storage medium or any combination of the two. A computer readable storage medium may be, for example, but not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any combination of the foregoing. More specific examples of the computer readable storage medium may include, but are not limited to: an electrical connection having one or more wires, a portable computer diskette, a hard disk, a Random Access Memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber, a portable compact disc read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing. In the present application, a computer readable storage medium may be any tangible medium that can contain, or store a program for use by or in connection with an instruction execution system, apparatus, or device. In this application, however, a computer readable signal medium may include a propagated data signal with computer readable program code embodied therein, for example, in baseband or as part of a carrier wave. Such a propagated data signal may take many forms, including, but not limited to, electro-magnetic, optical, or any suitable combination thereof. A computer readable signal medium may also be any computer readable medium that is not a computer readable storage medium and that can communicate, propagate, or transport a program for use by or in connection with an instruction execution system, apparatus, or device. Program code embodied on a computer readable medium may be transmitted using any appropriate medium, including but not limited to: wireless, wire, fiber optic cable, RF, etc., or any suitable combination of the foregoing.

The flowchart and block diagrams in the figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods and computer program products according to various embodiments of the present application. In this regard, each block in the flowchart or block diagrams may represent a module, segment, or portion of code, which comprises one or more executable instructions for implementing the specified logical function(s). It should also be noted that, in some alternative implementations, the functions noted in the block may occur out of the order noted in the figures. For example, two blocks shown in succession may, in fact, be executed substantially concurrently, or the blocks may sometimes be executed in the reverse order, depending upon the functionality involved. It will also be noted that each block of the block diagrams and/or flowchart illustration, and combinations of blocks in the block diagrams and/or flowchart illustration, can be implemented by special purpose hardware-based systems which perform the specified functions or acts, or combinations of special purpose hardware and computer instructions.

The units described in the embodiments of the present application may be implemented by software or hardware. The described units may also be provided in a processor, and may be described as: a processor includes a first acquisition unit, a second acquisition unit, a determination unit, and a generation unit. Where the names of these units do not in some cases constitute a limitation on the units themselves, for example, the first obtaining unit may also be described as a "unit for obtaining a first target file for creating a target process".

As another aspect, the present application also provides a computer-readable medium, which may be contained in the apparatus described in the above embodiments; or may be present separately and not assembled into the device. The computer readable medium carries one or more programs which, when executed by the apparatus, cause the apparatus to: acquiring a first target file for creating a target process, wherein the first target file comprises a first symbol table; acquiring a second object file compiled according to an object source code file, wherein the second object file comprises a second symbol table; determining a difference symbol between the first target file and the second target file using the first symbol table and the second symbol table; and generating a patch file according to the difference symbol.

The above description is only a preferred embodiment of the application and is illustrative of the principles of the technology employed. It will be appreciated by those skilled in the art that the scope of the invention herein disclosed is not limited to the particular combination of features described above, but also encompasses other arrangements formed by any combination of the above features or their equivalents without departing from the spirit of the invention. For example, the above features may be replaced with (but not limited to) features having similar functions disclosed in the present application.

Claims

1. A method for generating a patch file, comprising:

acquiring a first target file for creating a target process, wherein the first target file comprises a first symbol table;

acquiring a second target file obtained by compiling according to a target source code file, wherein the second target file comprises a second symbol table;

determining a difference symbol between the first target file and the second target file using the first symbol table and the second symbol table;

generating a patch file according to the difference symbol;

the method further comprises the following steps:

under the condition that a preset pause condition is met, pausing the target process and loading the generated patch file, wherein the process comprises the following steps: after the target process is suspended, backing up an instruction to be executed in a code segment of the target process; in the target process, allocating an address space for the patch file; copying functions, character strings and variables in the patch file into the address space;

linking the target process and the loaded patch file to update the target process, including: and modifying the first instruction of the homonymous function in the target process, and jumping to the function in the patch file instead.

2. The method of claim 1, wherein the symbol types of the symbol include a read-only type and a read-write type; and

the determining a difference symbol between the first target file and the second target file using the first symbol table and the second symbol table comprises:

and dividing the symbols in the first symbol table into a first read-only symbol set and a first read-write symbol set according to the symbol types, and dividing the symbols in the second symbol table into a second read-only symbol set and a second read-write symbol set.

3. The method of claim 2, wherein said determining a difference symbol between the first target file and the second target file using the first symbol table and the second symbol table comprises:

and comparing the symbol names of the symbols in the first read-write symbol set and the second read-write symbol set, and determining the difference symbols between the second read-write symbol set and the first read-write symbol set.

4. The method of claim 2, wherein said determining a difference symbol between the first target file and the second target file using the first symbol table and the second symbol table comprises:

comparing a first symbol content of a first symbol to a second symbol content of a second symbol, wherein the first symbol is a symbol in the first set of read-only symbols and the second symbol is a symbol in the second set of read-only symbols that corresponds to the first symbol;

generating an indicator, wherein the indicator is a no difference indicator for indicating that the first symbol content and the second symbol content are the same or a difference type indicator for indicating a difference type of the second symbol content relative to the first symbol content, the difference type including addition, deletion and modification.

5. The method of claim 4, wherein said comparing a first symbol content of a first symbol and a second symbol content of a second symbol comprises:

determining whether the relocation type is the same and whether the used symbols are the same for the bytes needing relocation in the first symbol content and the second symbol content;

determining whether the bytes that do not need to be relocated are the same for the bytes that do not need to be relocated in the first symbol content and the second symbol content.

6. The method of claim 5, wherein said determining a difference symbol between the first target file and the second target file using the first symbol table and the second symbol table comprises:

determining a difference symbol between the first set of read-only symbols and the second set of read-only symbols based on the indicator.

7. The method of claim 5, wherein the generating a patch file from the difference symbol comprises:

acquiring the symbol content of the difference symbol and/or the repositioning item of the difference symbol;

a symbol name of the difference symbol and at least one of: and the symbol content and the relocation item are saved in a pre-generated file.

8. The method of claim 7, wherein the patch file includes data sections, relocation sections, symbol table sections; and

the symbol name of the to-be-differentiated symbol and at least one of: the symbol content and the relocation item are saved to a pre-generated file, and the method comprises the following steps:

saving the relocation item to a relocation section;

storing the symbolic content to a data section, wherein the symbolic content in the data section can be indexed to a relocation item stored to a relocation section;

and storing the symbol names into a symbol table section, wherein the symbol names stored into the symbol table can index the symbol contents stored into the data section.

9. The method of claim 1, wherein a symbol comprises a function; and

the method further comprises the following steps:

acquiring a current function call chain of the target process;

determining whether the functions included in the function call chain have intersection with the functions in the patch file or not according to the function names;

if not, determining that the preset pause condition is met.

10. The method of claim 9, wherein prior to linking the target process and the loaded patch file to update the target process, the method further comprises:

and modifying the relative address of the symbol in the first symbol table into an absolute address according to the absolute address of the target process in an address space.

11. The method of claim 10, wherein the linking the target process and the loaded patch file to update the target process comprises:

and linking the function in the patch file to the function or the variable in the target process according to the modified first symbol table.

12. The method of claim 11, wherein the second object file comprises at least two sub-second object files; and

the method further comprises the following steps:

for each of the at least two sub second target files, generating a symbol name set corresponding to the sub second target file, the symbol name set including symbol names of static type symbols in the sub second target file.

13. The method of claim 12, wherein the first object file comprises at least two sub-first object files; and

the linking, according to the modified first symbol table, the function in the patch file to the function or the variable in the target process includes:

for a target symbol of a static type in the patch file, searching a sub first target file corresponding to a sub second target file in which the target symbol is located according to a symbol name set corresponding to the sub second target file in which the target symbol is located;

and searching a symbol corresponding to the target symbol in the searched sub first target file.

14. The method of claim 13, wherein after the linking the target process and the loaded patch file to update the target process, the method further comprises:

and updating the first symbol table according to the updated symbols in the target process.

15. An apparatus for generating a patch file, comprising:

the system comprises a first acquisition unit, a second acquisition unit and a third acquisition unit, wherein the first acquisition unit is used for acquiring a first target file for creating a target process, and the first target file comprises a first symbol table;

the second obtaining unit is used for obtaining a second target file obtained by compiling according to a target source code file, wherein the second target file comprises a second symbol table;

a determining unit configured to determine a difference symbol between the first target file and the second target file using the first symbol table and the second symbol table;

the generating unit is used for generating a patch file according to the difference symbol;

the device further comprises:

a loading unit, configured to suspend the target process and load the generated patch file when a preset suspension condition is met, where the loading unit includes: after the target process is suspended, backing up an instruction to be executed in a code segment of the target process; in the target process, allocating an address space for the patch file; copying functions, character strings and variables in the patch file into the address space; a linking unit, configured to link the target process and the loaded patch file to update the target process, including: and modifying the first instruction of the homonymous function in the target process, and jumping to the function in the patch file instead.

16. An electronic device, comprising:

one or more processors;

a storage device for storing one or more programs,

the one or more programs, when executed by the one or more processors, cause the one or more processors to implement the method recited in any of claims 1-14.

17. A computer-readable storage medium, on which a computer program is stored, which program, when being executed by a processor, carries out the method according to any one of claims 1-14.