JPH02249026A - High speed patch executing method - Google Patents

Abstract

PURPOSE:To prevent duplicate execution for an executed patch and to shorten a patch executing time by making patch data and a patch identifier given to every patch data to be a couple and storing it in a secondary storage medium. CONSTITUTION:Patch data required for the correction of the program file of the patch and the patch identifier provided to every patch data are divided, and they are made into a couple, which is stored in the patch data file 3 of the secondary storage medium. The patch identifier of the executed patch is registered in a patch execution/control file 4 at every patched program file 6. At the time of executing the patch, the patch identifier is read and whether it is registered in the patch execution/control file 4 or not is decided. When it is registered, patch data is not inputted. When it is not registered, patch data is inputted, is executed at every patched program file 6, and the patch identifier is registered in the patch execution/control file 4.

Description

[Detailed Description of the Invention] [Field of Industrial Application] The present invention relates to a high-speed patch implementation method, and in particular to a method for shortening the maintenance time of program files by implementing patches at high speed using a patch implementation management file. Concerning a fast patching method that enables

[Conventional technology]

Traditionally, as a programmatic debugging tool,
There is a patch method. This method differs from the method of replacing a program containing errors with a complete program;
This is a partial correction method. In other words, in order to apply a patch to an error location, patch data to be corrected is created for each error location, a number is assigned to each patch data, and the patch execution processing program is applied to the patched program file. The patch data will be used to implement corrections sequentially. Usually, for one patched program file, there are several 1000 to several 100
Since there are 00 modified locations, the same number of patch data are stored in the secondary storage device. Therefore, patch implementation times typically take a long time to complete.

When modifying program files using patches, the larger the scale of the system, the greater the amount of patches and the time required to implement them. For this reason, with regard to patches that are regularly applied, the implementation time has been shortened by managing generations of patches added within a certain period of time and reducing the amount of patches to be applied each time. However, in large-scale online systems or complex systems that operate for long periods of time, in order to prevent patches from being omitted due to incorrect generation specification, all patches are applied each time by specifying the previous generation or without specifying the generation. I was doing things like that. For this reason, the enforcement process may be performed redundantly even for patches that have already been applied, which further increases the time it takes to apply the patch.

As a conventional patch execution method, for example,
There is a method described in Japanese Patent No. 232032. In this method, the existence of a patched program corresponding to patch data is confirmed to prevent omission of patch data implementation.

[Problem to be solved by the invention]

In this way, with conventional patch execution methods, the patch execution time increases in proportion to the amount of patches, and even if a re-implementation request is made for a patch that has already been applied, the Patch implementation time was increasing to access patch program files. For this reason, patching cannot be completed within the limited maintenance time for systems that operate for long periods of time, causing problems in service operations.

Therefore, as mentioned above, there is a method to reduce the amount of patches to be applied at one time by assigning specific generation numbers to patches at regular intervals and specifying generation numbers as needed. was used to shorten the time it takes to apply patches, but with this generation management method, if the generation number was incorrectly specified, the necessary patches would not be applied and accidents would occur.
There was a risk that the system would go down.

The purpose of the present invention is to solve such conventional problems, prevent redundant implementation of patches that have already been applied, shorten the time for patch implementation, and prevent omission of patch implementation due to incorrect generation number specification. The objective is to provide a fast patching method.

[Means to solve the problem]

In order to achieve the above object, the high-speed patch enforcement method of the present invention is a patch enforcement method for modifying a program file of a computer system. a patch data file stored in a secondary storage medium as a pair, and a patch implementation management file in which patch identifiers that have been applied are registered for each patched program file. is input to determine whether or not the patch identifier is registered in the above patch enforcement management file. If it is registered, the patch data corresponding to the patch identifier is considered to have been processed, and if it is not registered, the patch data corresponding to the patch identifier is considered to have been processed. , extracting patch data corresponding to the patch identifier from the patch data file, inputting the patch data, applying the patch data to the patched program file, and registering the patch identifier in the patch implementation management file. The feature is that the processing is performed on all patch identifiers.

[For production]

In the present invention, a patch is divided into patch data necessary for modifying a program file and a patch identifier assigned to each patch data, and these are stored in pairs in advance in a patch data file on a secondary storage medium, and Register the patch identifier of the applied patch for each program file in the patch implementation management file. When applying the patch,
Reads the patch identifier from the patch data file and inputs it, determines whether it is registered in the patch enforcement management file, and if it is registered, inputs the patch data corresponding to the patch identifier from the patch data file. If not, or if it is not registered, the patch data corresponding to the patch identifier is read from the patch data file, inputted, applied to the patched program file, and the patch identifier is registered in the patch implementation management file.

This makes it possible to prevent duplicate patch implementation. That is, in order to prevent omissions in patch implementation due to generation number designation in the generation management method, the present invention specifies an old generation number that has already been implemented, or all patches are patched every time without using the generation management method. Even if a request for enforcement is made for a patch, the application will not be applied redundantly to a patch that has already been applied, so the patch implementation time can be shortened and patch implementation can be implemented at high speed.

〔Example〕

Hereinafter, embodiments of the present invention will be described in detail with reference to the drawings.

FIG. 1 is an explanatory diagram of a patch application method showing an embodiment of the present invention.

In FIG. 1, 1 is a patch enforcement processing program, 2 is
3 is a group of patch identifiers that request patch implementation, and 3 is a group of patch identifiers that are stored as pairs of patch data and patch identifiers.
4 is a patch data file on the secondary storage medium; 4 is a patch implementation management file on the secondary storage medium in which patch identifiers of patches that have been applied are registered for each program file;
5 is the content of the patch enforcement management file loaded onto the main memory, that is, the patch enforcement management table; 6
is the patched program file on the secondary storage medium.

Each patch in the patch data file 3 stores patch data necessary for modifying a program file and a patch identifier assigned to each patch data in order to select the patch data. On the other hand, the patch identifier of the patch that has been applied in the patch implementation management file 4 is registered as an on/off bit using the patch identifier as a key. It shows that it is enforcement.

When applying a patch, enter the patch identifier specified from the patch data file 3, and then
Check the state of the bit corresponding to the patch identifier. If the bit is on (or off), it indicates that no patching is required, and if the bit is off (or off)
In this case, the patch has not been applied and it is necessary to apply the patch. Therefore, patch data corresponding to the patch identifier is input from the patch data file 3, and applied to the patched program file 6 in the secondary storage medium. Furthermore, after implementation, turn on the bit corresponding to the patch identifier in patch implementation management file 4 (
or Off) to register that the patch has been implemented.

As a result, enforcement processing is performed only on patches that have not yet been enforced among the patches for which enforcement has been requested, and it is possible to prevent redundant enforcement of patches that have already been enforced.

Now, when the patch enforcement processing program 1 starts operating, it loads the patch enforcement management file 4 on the secondary storage medium and stores the batch enforcement processing table 5 on the main memory.
Create. Next, the patch identifier ■ from the patch identifier group 2 requested by the user is input, and the patch identifier of the corresponding patch is input from the patch data file 3 on the secondary storage medium. In other words, a group of patch identifiers are displayed one by one on the screen of the display device, and after the user confirms the patch identifiers, the user inputs the corresponding identifiers from the patch data file 3 in the secondary storage medium into the program. be. Next, the bit position corresponding to the patch identifier ■ is found from the patch enforcement management table 5 on the main memory, and its status is examined. That is, the patch enforcement management table 5 stores patch identifier groups and their corresponding on/off flags, and by referring to this table 5 by the patch enforcement processing program 1,
Check the enforcement status. If the flag bit is on (or off), processing for patch identifier ■ is completed. In other words, since the patch corresponding to this identifier (■) has already been applied, all you need to do is confirm this. On the other hand, if the flag bit is off (or on), it means that it has not been implemented, so input the patch data with the corresponding patch identifier ■ from the patch data file 3 on the secondary storage medium to the implementation processing program 1, This is applied to the patched program file 6 on the secondary storage medium. Then, the state of the flag bit position corresponding to the patch identifier ■ in the patch enforcement management table 5 on the main memory is updated to on (or off).

This process is repeated in the same way from patch identifier (■) to patch identifier (n). When the processing for patch identifier n is completed, the patch enforcement management table 5 on the main memory is stored in the patch enforcement management file 4 on the secondary storage medium, and the processing of the patch enforcement processing program 1 is completed.

FIG. 2 is an operational flowchart of the high-speed patching method of the present invention.

First, prior to patch implementation, the patch implementation management file (4 in Figure 1) on the secondary storage medium is loaded into the main memory, and the patch implementation management table (5 in Figure 1) is loaded into the main memory.
(Step 21). It is determined whether the processing for the patch identifier group (2 in FIG. 1) requested by the user is completed (step 22).

That is, by referring to the patch identifiers displayed on the display screen, the user determines whether all of the patch identifier groups have been completed. If everything is not completed yet, input the patch identifier specified by the user into the patch enforcement processing program from the patch data file (3 in Figure 1) on the secondary storage medium (step 23).
. The patch enforcement processing program finds the bit position of the patch enforcement management table (5 in Figure 1) on the main memory that corresponds to the input patch identifier (step 24).
. The content of the obtained bit position is determined, and if the bit is on (or off), the process returns to process 21, and if the bit is off (or on), the process proceeds to process 26 (step 25
). If the bit is off (or on), process 23
The patch data corresponding to the patch identifier input in 2
Next, input the patch data file (3 in Figure 1) on the storage medium to the patch implementation processing program (step 26).
). Next, the patch implementation processing program applies the input patch data to the patched program file (6 in Figure 1) on the secondary storage medium (step 27).
. Then, the content of the bit position in the patch implementation management table (5 in FIG. 1) on the main memory corresponding to the patch identifier corresponding to the applied patch data is set to on (or off) (step 28). In other words, flag bits that were off are updated to on. On the other hand, if it was initially on, update it to off.

In process 22, if it is confirmed that all the processes for the patch identifier group (2 in Figure 1) requested by the user have been completed, the patch enforcement management table (5 in Figure 1) in the main memory is It is stored in the patch enforcement management file (4 in FIG. 1) on the secondary storage medium (step 29).

As a result, it is possible to shorten the time required to apply the target patch, and a high-speed patch application method can be realized.

〔Effect of the invention〕

As explained above, according to the present invention, it is possible to prevent redundant implementation of patches that have already been applied, thereby reducing patch implementation time, and also to reduce the amount of time required to apply patches due to errors in generation number specification in the generation management method. It is possible to prevent failure to apply patches.

[Brief explanation of drawings]

FIG. 1 is an explanatory diagram of a high-speed patching method according to an embodiment of the present invention, and FIG. 2 is an operational flowchart of the patching method according to the present invention. 1: patch enforcement processing program, 2: patch identifier group of enforcement request, 3: patch data file, 4: patch enforcement management file, 5: patch enforcement management table, 6: patched program file. First identifier.・Data patch, ・Dataken file [-=I-π■

Claims (1)

[Claims] 1. In a patch implementation method for modifying a program file of a computer system, a patch data file stores a pair of patch data necessary for modifying the program file and a patch identifier assigned to each patch data in a secondary storage medium. and a patch implementation management file in which patch identifiers that have been applied are registered for each patched program file.When applying a patch, first input the patch identifier from the patch data file, and the patch identifier is stored in the patch implementation management file. If it is registered, the patch data corresponding to the patch identifier is considered to have been processed, and if it is not registered, the patch data corresponding to the patch identifier is extracted from the patch data file. , inputting the patch data, applying the patch data to the patched program file, and registering the patch identifier in the patch implementation management file for all patch identifiers. A fast patching method.