JPH11306005A - Analyzing method for patch application state - Google Patents

Abstract

PROBLEM TO BE SOLVED: To easily confirm the application of patch by performing the comparison and totalization of files of different versions. SOLUTION: An execution file 1 is read by a reading part 2, and the version number 3 and the size 5 of program data are measured and stored in a reading buffer 6 separately from each other. Then an execution file of a 2nd version is read, and a comparison/totalization part 10 takes the version number 7, program data 8 and size 9 out of the buffer 6. Then the part 10 performs comparison between the program data of 1st and 2nd versions, checks a specific order of byte counted from the head where the patch is applied and stores the totalization result in a totalization result buffer 12. Meanwhile, the version number 7 of a 1st version, the data 8 and the size 9 are erased from the buffer 6 and an execution file of a 3rd version is read out of the buffer 6. The part 10 takes the number 7, data 8 and size 9 out of the buffer 6, performs comparison between the program data of 2nd and 3rd versions, checks a specific order of byte from the head where the patch is applied and stores the totalization result 11 in the buffer 12.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a method of analyzing a patch application situation when a computer program is revised.

[0002]

2. Description of the Related Art For modification of a computer program, etc.,
A patch application status analysis tool is used. If the patch is not applied to which version of the load module file, from what address to what address, the load module file of each version is compared, and from what address to what address for each version The patch application status analysis tool creates a table that indicates whether patches have been applied to the application. Note that a “patch” is an emergency correction of a program.

[0003] The following two methods are known as conventional methods for examining how a patch is applied to an executable file of a program.

(1) A patch list is used to check the location where a patch has been applied.
Write that patch.

(2) By using utility software for comparing files, the original executable file is compared with the executable file to which the patch is applied, and the difference is compared.
Know the patch application status.

[0006]

However, the method of writing a patch on the source list has a drawback that it takes much time and labor because all operations are manual. When using utility software to compare files,
Differences between the first and second versions of the executable file, the differences between the second and third version of the executable file,... That is, the history of how the patch was applied from the first edition to the third edition is not known. Furthermore, in general, source software requires several tens of pages to several hundreds of pages.
The method has a drawback in that it is difficult to grasp the patch application status at a glance by the method of writing the patch on the source list because it covers pages.

Therefore, an object of the present invention is to provide a first edition, a second edition,
To provide a method of analyzing the patch application status in which it is possible to easily compare the edition, the third edition,... And the load module file to which the patch is applied, and to which address of which edition the patch was applied. is there.

[0008]

Means for Solving the Problems To solve the above-mentioned problems, a patch application status analyzing method according to the present invention has the following characteristic configuration.

(1) In a method for analyzing a patch application status of a load module file of a plurality of generations, such as a first edition, a second edition, a third edition,... .., And sequentially counting the generations, and comparing and counting the files of the different versions by a comparison and counting unit. A method of analyzing patch application status that is tracked in the future.

(2) The reading section of the file is a version number,
The patch application status analysis method of (1) for measuring program data and size.

(3) The patch application status analysis method according to (2), further comprising a reading buffer for separating and outputting the output of the file reading section into the version number, program data and size.

[0012]

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS A preferred embodiment of a patch application status analysis method according to the present invention will be described below in detail with reference to the accompanying drawings. First, a description will be given with reference to FIG. 1 showing a conceptual diagram of an execution file. It is assumed that the execution file has a version number (revision) recorded at a predetermined position, for example, at the left end of the figure, which is the top position.

Next, FIG. 2 shows an example of a data flow diagram on a computer. The executable file is the first version,
It is assumed that there are four editions, a second edition, a third edition, and a fourth edition.

The execution file 1 is read by the file reading unit 2, and the version number 3 and the program data size 5 are measured. The measured version number 3 and the program data size 5 are separated and stored in the read buffer (memory) 6. First, the state of the reading buffer 6 when the first version of the execution file is read is as shown in FIG.

Next, the file reading section 2 reads the second version of the execution file. The contents of the read buffer 6 at that time are as shown in FIG.

After reading the two executable files of the first and second versions, the comparing and counting unit 10 extracts the version number 7, program data 8 and size 9 from the reading buffer 6. Then, the program data of the first version is compared with the program data of the second version, it is checked in which byte from the beginning the patch is applied, and the counting result is stored in the counting result buffer 12.

Next, FIG. 5 shows the result of comparing and compiling the first and second edition executable files. In the example of FIG. 5, the second version of the first version of the executable file is from the byte 00060H to the byte 00006H, from the byte 00008H to the byte 00008H, from the byte 0102H to the byte 000010H, and to the byte 20023H. To the 0022FH byte and the five patches from the 07D00H byte to the 07D30H byte.

Further, the file reading section 2 deletes the first edition 7 and the program data 8 and the size 9 from the reading buffer 6, and then reads the third edition execution file. At this time, the contents of the read buffer 6 are as shown in FIG.

After the third version of the executable file is read,
The comparing and counting unit 10 extracts the version number 7, the program data 8, and the size 9 from the read buffer 6. Then, the program data of the second edition is compared with the program data of the third edition, and it is checked at which byte from the beginning the patch is applied.
2 is stored.

Next, FIG. 7 shows the result of comparing and compiling the executable files of the second and third editions. In the example shown in FIG.
With respect to the version of the executable file, the third version is from the 0773H byte to the 0774H byte, from the 0155H byte to the 00157H byte, from the 07D20H byte to the 07D28H byte, and to the 07D31 byte.
This indicates that four patches from the H-th byte to the 07D3FH-th byte have been applied.

Next, the file reading section 2 deletes the version number, program data and size of the second edition from the reading buffer 6 and then reads the fourth edition execution file. The contents of the read buffer 6 at this time are as shown in FIG.

After the fourth version of the executable file is read,
The comparing and counting unit 10 reads the version number 7 from the read buffer 6,
The program data 8 and the size 9 are taken out. And
The third-version program data and the fourth-version program data are compared to determine the number of the byte from the beginning where the patch is applied, and the tally result 11 is stored in the tally result buffer 12.

Next, FIG. 9 shows the result of comparing and compiling the third and fourth edition executable files. In FIG. 9, the fourth edition shows that two patches from the 226th byte to the 22828th byte and the 07D40Hth byte to the 07D4AH byte are applied to the third edition of the executable file. I have.

Finally, the tallying result output unit 14 obtains the tallying result 13 from the tallying result buffer 12 and outputs it to the hard disk device 18, the display device 19 or the printer 20.

The preferred embodiment of the patch application status analysis method of the present invention has been described in detail above. However, those skilled in the art can easily understand that various modifications can be made without departing from the gist of the present invention. Like.

[0026]

As can be understood from the above description, according to the patch application status analysis method of the present invention, it is possible to easily grasp where in the executable file the patch is applied. As the number of versions increases, the history of where the patch was applied can be seen at a glance. Also,
A so-called "patch patch", that is, although a certain failure is corrected by a patch, the failure cannot be completely solved, and the hierarchy of patches that correct the patch itself with a patch can be grasped. Furthermore,
There is also a secondary effect that it is useful when taking over programs for which documents such as specifications (manuals) are not prepared from other persons in charge.

[Brief description of the drawings]

FIG. 1 is a diagram showing a configuration of an execution file according to an embodiment of the present invention.

FIG. 2 is a diagram illustrating a data flow diagram of a method for analyzing a patch application status according to an embodiment of the present invention.

FIG. 3 is a diagram showing a state of a read buffer 6 when a first version of the executable file is read in the embodiment of the present invention.

FIG. 4 is a diagram showing the contents of a read buffer 6 when a second version of the executable file is read in the embodiment of the present invention.

FIG. 5 is a diagram illustrating a result of comparing and totaling the executable files of the first and second versions.

FIG. 6 is a diagram showing the contents of a read buffer 6 when a third version of the executable file is read in the embodiment of the present invention.

FIG. 7 is a diagram showing a result obtained by comparing and totaling the executable files of the second version and the third version in the embodiment of the present invention.

FIG. 8 is a diagram showing the contents of a read buffer 6 when a fourth version of the executable file is read in the embodiment of the present invention.

FIG. 9 is a diagram illustrating a result obtained by comparing and compiling the third and fourth edition executable files in the embodiment of the present invention.

[Explanation of symbols]

 DESCRIPTION OF SYMBOLS 1 Execution file 2 File reading part 6 Reading buffer 10 Comparison and totaling part 12 Totaling result buffer

Claims (3)

[Claims] 1. A method for analyzing a patch application status of a load module file of a plurality of generations, such as a first edition, a second edition, a third edition,... , The second edition, the third edition,..., And the generations, and comparing and counting the files of the different versions by a comparison and counting unit. A patch application status analysis method characterized by grasping later. 2. The patch application status analysis method according to claim 1, wherein said file reading unit measures a version number, program data and size. 3. The patch application status analysis method according to claim 2, further comprising a reading buffer for separating and outputting the output of the file reading section into the version number, program data and size.