JPH10307719A - High-level language patch preparation system - Google Patents

Abstract

PROBLEM TO BE SOLVED: To provide a high-level language patch preparation system which attains the provision of patch dealing system using a high-level language in place of a conventional patch dealing system based on assembler language and machine word, enables quick dealing and required quality maintenance through irreducibly minimum correction and can improve maintainability and reliability. SOLUTION: In this system, a database preparing device 11 prepares out a function variable allocation data base 22 for patch load module preparation management through plural load modules 21 to become patch objects. Then, a patch data preparing device 13 extracts out data corresponding to the same allocation address and size as a patch load module 27 prepared this time from the load modules 21 consisting of the existent system and a patch load module 27 prepared the last time based on the information of function variable allocation data base 22 outputted from this data base preparing device 11 and prepares out this patch load module 27 prepared this time as an old memory image file 28.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to maintenance of a program in a large-scale switching system and the like, and relates to a high-level language patch creating system in which a load module can be modified by a patch created from a source program (a source program before compilation). .

[0002]

2. Description of the Related Art Conventionally, as a general method of correcting a load module which is an executable object (object) program written in a programming language, a source file to be corrected is corrected, translated by a compiler, and then reloaded. And a patch handling method that directly corrects a part of the memory image extracted from the load module.

In the former load module rebuilding method, the load module needs to be recreated regardless of the amount of change due to the modification. Therefore, it is difficult to prove the maintenance of the quality of the entire system in a short period of time in a system requiring high reliability particularly in a large-scale switching system.

[0004] In other words, even if there are few corrections and changes,
Since the entire load module constituting the system is reconstructed, it is necessary to consider the reconstructed load module completely different from the one that has been driven before. As a result, in order to demonstrate the quality maintenance, there is an annoyance that a re-inspection and a re-evaluation test are required for the entire system.

In general, when maintaining system products, it is necessary to quickly respond to requests and maintain high quality. However, such a conventional load module rebuilding method has a problem that a large number of inspection and evaluation test steps are required as described above, which hinders customer service.

On the other hand, in the case of the latter patch handling system, a memory image of a machine language of an exchange system or the like is currently taken out by an output device or the like in order to minimize the correction portion of the system. Based on this, as shown in FIG. 5, the allocation addresses of the changed part and the related part are obtained by manual operation.
Furthermore, the extracted memory image is converted into an assembler language, corrected by an assembler language and a machine language, and a memory area on a system necessary for applying a patch is secured. That is, a method is employed in which patch image data in an executable format is directly created and input to an exchange system or the like.

[0007] The other parts except the modified part are the states of the existing load module itself. That point,
There is an advantage that re-examination and re-evaluation test are not required for the entire system presented in the former method. In other words, in this case, the re-examination and the evaluation test need only be performed on the part changed by the correction and the related part.

However, as a practical problem, engineers who are proficient in assembler language or machine language for directly correcting a memory image of a load module are limited, which makes operation difficult.

With the recent development of compiler technology, most of the large-scale and high-reliability system software has been written using high-level languages. At the same time, as the performance of CPUs (processors) increases, the creation of programs in assembler language and machine language requires considerably higher knowledge. As described above, in today's high-level languages, the declining trend of engineers who are proficient in assembler languages and machine languages cannot be met by conventional patch handling methods.

[0010] From the above, as an earlier problem such as quality maintenance and quick response processing, in order to easily realize the operation, a means for creating patch image data capable of dealing with a patch at a high-level language level is desired. It has become to.

To achieve this, see, for example, Japanese Patent Application Laid-Open No. 1-221.
Japanese Patent No. 4928 discloses a high-level language patch creation device. In this case, referring to FIG. 1, the patch data creation device creates a correction data file from the patch source file of the correction source. Further, the object file is converted into an object file by the object file creating means, and a link module is created after the conversion to create a load module having a patch inserted image and a card file of the patch inserted image.

[0012]

However, even with the apparatus described in this publication, the above-mentioned problems of the patch handling system have not been basically solved.

An object of the present invention is to realize a patch handling system using a high-level language instead of the conventional patch handling system using an assembler language and a machine language. It is an object of the present invention to provide a high-level language patch creation system that is capable of improving maintainability and reliability.

[0014]

According to the present invention, there is provided a high-level language patch creation system comprising: a database creation device for creating and outputting a function variable assignment database for patch load module creation management by a plurality of load modules to be patched; Based on the information of the function variable assignment database output from the database creation device, the load module constituting the existing system and the previously created patch load module are converted to the same allocation address and size as the currently created patch load module. A patch data creation device for extracting and outputting the corresponding data, and creating and outputting the patch load module created this time as an old memory image file.

[0015] In this case, the patch data creation device includes a plurality of patch object files created by translating a plurality of patch source files to be patched, and what patch processing is to be performed on the patch object files. A patch link instruction information file to be instructed, and a signal output from each of the previous patch load modules are received, an allocation address of patch target data is calculated by a function or a variable, and an existing area or a patch area is assigned to the existing system. It is configured to be coupled to.

Here, the patch link instruction information file may be modified by modifying the data to be patched by a function or a variable on the existing system, or may be newly added or deleted. Assignment can be automatically instructed. In this case, as the patch allocation performed automatically, the size of the patch target data is compared with the existing allocation size, and the size is determined.If the size is smaller, the same allocation address is allocated over the existing allocation area, A free area in a patch area prepared in advance is obtained and secured.

Further, the database creation device includes a load module configuration management unit for managing configuration information of a plurality of load modules, a patch area management unit for managing patch areas and past patch histories, and various entry addresses and allocation addresses. It is configured to output a function variable allocation database by a creation process in each section of the entry address management section to be managed.

Therefore, the load module is updated in the conventional patch handling method. However, the present invention has a function of creating a new load module for each patch and generating an image file before applying the patch as a load module. ing.

[0019]

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS An embodiment of a high-level language patch creation system according to the present invention will be described below in detail with reference to the drawings.

FIG. 1 is a block diagram showing the configuration of a creation system according to the present embodiment. It has a plurality of load modules 21 to be patched, and includes a database creation device 11 that creates a database for patch load module creation management based on these. Further, a patch data creation device 13 is provided. Here, a plurality of patch source files 23 are translated by the compiler 12 to create a plurality of patch object files 24, and the function variable assignment information output from the database creation device 11 is output. A database 22 is received, a patch link instruction information file 25 and a plurality of patch load modules 26 created up to the previous time are received and processed, and a patch load module 27 for data to be changed and an old memory image which is an allocation area of the patch load module 27 are stored. The files 28 are respectively output.

As an internal configuration, one database creation device 11 includes a load module configuration management unit 111, a patch area management unit 112, and an entry address management unit 1
It is 13 mag. The other patch data creating device 13 includes a patch area determining / securing unit 13.
1. Means 13 for locating addresses related to function / variable reference
2, the link means 133, the function variable assignment information database updating means 134, the old memory image file creating means 135, and the like.

Next, with respect to the present embodiment having the above configuration, a patch creation work flowchart in FIG. 2, a memory allocation image of an existing load module as a patch input source in FIG. 3, and a memory allocation after patch input in FIG. The operation up to the creation of a series of patches will be described with reference to an image.

First, as shown in FIG. 3, in the existing load module, an object file α, an object file β, and an object file γ are allocated in that order. In the memory, a patch input area is secured immediately after the last object file.
The existing load module includes the variable A and the functions F0 and F
l, F2, FX exist, of which functions F0,
Correction and change of FX and addition of variable B have occurred.

Therefore, in FIG. 2, a source file is first created as an operation which is not different from the conventional one. After the source file is created, all load modules constituting the system are constructed using a linker (step Al).

In the case of the present invention, the maintenance is not immediately performed, but a database for managing the creation of patch load modules is created by using the database creating device 11 (step A2).

In this database, the load module configuration information management unit 111 stores the names of all load modules constituting the system, memory allocation address information, allocation size information, and source file names configuring individual load modules. Manage as information. That is, the allocation address information and the size information of the variable A, the function F0, the function F1, the function FX, and the function F2 in the existing load module, and the allocation address and the size information of the patch input area are managed.

Conventionally, the function F0 refers to the call of the function FX and the variable A. In this embodiment, the reference to the variable A is changed to the variable B. Further, as the function FX, the function Fl is conventionally called, but the function F2 is changed to be called, and a patch for adding a new variable B is input.

Therefore, in the case of this database, the patch area management unit 112 manages the existing allocation addresses and sizes of the functions and variables included in all the load modules, and the memory addresses of the areas for newly allocating patch load modules. Manage size. Thereafter, both the existing load module allocation area and the new allocation area are used as allocation target areas of the patch load module.

Further, in the database, various attribute information and address information of functions and variables included in all load modules are managed by the entry address management unit 113. This information is provided by link means 1
Used when the patch in 33 is combined with the existing system.

The database is created when the system is rebuilt, that is, all the load modules constituting the system are recreated again, or when all the load modules constituting the system are created for the first time. This is aside from creating a new load module, even if a patch load module has already been created and submitted, even if the system is reconfigured (all load modules that make up the system are recreated). This is because those patches are invalid (should be invalidated). In other words, this database is updated and used as long as the creation and input of the patch load module continue thereafter.

Next, the modification of the load module to be patched will be described.

In the present invention, the patch handling at the high-level language level is realized by returning to the modification of the corresponding source file instead of directly modifying the load module in response to the modification of the load module.

In order to realize the method, after analyzing a source file to determine a correction portion, an independent source file is extracted for each function / variable including the correction portion, and the source file is corrected (step A3). Hereinafter, this source file is referred to as a patch source file 23.

A patch is a function in an existing source file.
In addition to modifying and changing variables, new functions and variables are added. Similarly, an independent source file is created for each function / variable for this additional portion. That is, first, a source file is created for each of the function F0, the function FX, and the variable B, the processing is modified for a patch, and a patch source file is created.

Further, the patch source file 23 is translated by the compile 12 (step A4), and the object file generated is used as the patch object file 24. When a correction change is made to a source file, there are many cases where a plurality of correction changes occur at the same time. In this case, the creation of the patch source file 23 and the creation of the patch object file 24 are performed at this time for all the modification / change portions.

The patch link instruction information file 25 is used as a file for instructing the patch load module and the old memory image file creation device 13 on what kind of patch the user should perform on the plurality of patch object files 24 created here. It is created (step A5).

The patch link instruction information file 25 is for instructing whether a function / variable to be patched is to be modified / changed in the existing system, newly added, or deleted. The instruction method at that time is to change / add / change functions / variables belonging to (or added to) which source file in which load module.
Whether to delete, assign to a designated address consciously, or automatically assign without consciousness, and specify the management number (user management number that records software changes) for this change Define.

That is, here, three object files are created. A patch link instruction information file is created as instruction information for creating a patch load module from the patch object file. In this file, the name of the patch target object file, the name of the existing load module to which the function / variable to be patched belongs, the name of the existing source file and the name of the patch input area to which the function / variable belongs also are defined.

Next, the patch link instruction information file 25
And the patch object file 24, the load module 21 constituting the existing system, and if a patch load module already exists, all the patch load modules 26 up to the previous time are input to the patch data creating device 13.

In the patch data creating apparatus 13, a patch input area determining / securing means 131, an address determining means 132 for a function / variable reference related location, a link means 133, a function variable assignment information database updating means 13
4. The old memory image file creating means 135 is executed. Thereby, one or more patch loading modules 27 and the old memory image file 2
8 and updates the function variable allocation information database 22 (step A6).

In step A6, the allocation addresses and sizes of the function F0 and the function FX to be patched in the patch object file from the previously created database, and the functions F1 and F2 in the existing load module referred to by the patch. Find the assigned address. For the variable B to be an additional patch, the allocation position is obtained from the patch input area described in the patch link instruction information file, and the allocation area is secured.

Next, for the functions F0 and FX, the sizes after the change are obtained from the respective patch object files, and the sizes are compared with the existing allocation sizes. Here, it is assumed that the size of the function F0 has not changed, and in that case, the function F0 is re-assigned to an existing assignment address.
Regarding the function FX, it is considered that the size has increased due to the change. In this case, since it cannot be inserted into the existing allocation area, it is determined that it is to be newly allocated to the patch input area. As a result, the allocation address of the function FX is secured from the patch input area. However, when the function FX is moved and allocated to a new area without permission, as shown in FIG. , The function Fl
Will need to be modified by patches. However, the function FX is not only moved and assigned to the new area, but also a patch indicating the relationship with the new area is input to the existing assigned area so that the function Fl is not affected. As an embodiment, as shown in FIG. 4, a patch for branching to a new function FX 'allocation address with a branch instruction for an existing allocation address of the function FX is automatically generated by creating a patch load module.

With this, the allocation addresses of the object files to be patched are determined. Next, an object file composed of only the allocation addresses of the previously extracted functions F1 and F2 to be referred to is automatically generated. The link processing is executed by using the file and the patch link instruction information file to create a patch load module. FIG. 4 shows the assignment after the patch is input.

The patch input area discriminating / securing means 13 which is the first means for realizing the patch data creating device 13
1 is based on the input patch link instruction information file 25 and patch object file 24,
It is determined whether the variable is to be patched and, at the same time, the size of the data to be patched is determined. Next, the function / variable assignment information database 22 checks whether the function / variable is an existing function / variable or a newly added function / variable. Next, when the user specifies the patch allocation address by himself in the patch link instruction information file 25, the address is preferentially used for the allocation, but the patch allocation which is one of the characteristic functions of the present invention is performed. Is automatically performed in the patch link instruction information file 25, if the patch target data in the patch object file 24 exists in the existing system, the patch target data size is compared with the existing allocation size. Then, the same allocation address is assigned so that the small area is covered by the existing allocation area.

If the area is large, it cannot be allocated to the existing area. Therefore, an empty area in the patch area prepared in advance is obtained to secure an area. At this time, the present means 131 manages the area of the patch area, and performs the empty / closed management of the area on the database 22 by the function variable assignment information database updating means 134.

If the data to be patched is a variable and exists in the existing system, and the size increases due to the current patch, the allocation to the patch area is not performed, and a warning is issued to the user. This is because if a variable that is directly referenced is moved on its own, a malfunction will be given to what is being referenced elsewhere. If the data to be patched is a function and exists in the existing system and the size increases due to the current patch, the assignment to the patch area and the existing assignment area will be added to the new Automatically generate branch instruction patches. Thus, the patch input area determining / securing means 131 ends.

Next, the function / variable which needs to be combined with the data to be patched is extracted from the patch object file 24 using the function / variable reference-related address determining means 132, and the assigned address is obtained from the function variable assignment information database 22. Ask. Then, a temporary object file including only the obtained function / variable name and the assigned address is generated in the middle.

Next, using the temporary object file and the patch object file 24, the link means 1
The combination is performed at 33, and the patch load module 27 is generated. The link means 133 is realized by using the linker used when creating the load module 21 of the existing system. This ensures that the functionality of the link process itself is consistent whether it is a patch or a link in an existing system.

When a patch load module can be created,
Next, the function variable allocation information database updating means 134 updates the database 22. As the contents of the update, the management of the use information of the patch area mentioned above, the allocation address of the new function / variable, the size information, and the registration of the patch input history are performed. This history includes information on which load module 21 the function / variable in which source file has been changed / added / deleted, what the user's change control number is for this input processing, and what area to input. Manage what went.

Then, the old memory image file creating means 135 is performed as the last means. In this means, the memory image before application of the patch load module 27 created this time is created as an old memory image file in the form of a load module. This file has a role of a so-called return patch load module for returning to the original memory image in the event of an incorrect patch input.

The contents of the file are obtained from the module 21 that constitutes the existing system and the patch load module 26 that has been created up to the last time, based on the load module configuration information and the patch history information of the function variable assignment information database 22. Data corresponding to the same address and size as the patch load module 27 is extracted and created.

A patch load module is created by the above-described means in the input patch object file 24 for several minutes.

[0053]

As described above, the high-level language patch creation system according to the present invention does not require special knowledge acquisition for creating a patch for a load module, and can create patch data in a short time. Moreover, errors can be reduced. That is, the patch used for the source module can be used as it is for a patch for a load module, which can be created only by a technician who is proficient in assembler language or machine language.

Further, according to the present invention, the knowledge and the work of examining the portion to be combined with the patch, that is, the assignment address of the related reference location are not required. In other words, by incorporating the function variable assignment information database, the latest information for these reference locations is managed, and the present invention automatically searches, retrieves, and updates this database, eliminating the need for user work. It depends on.

Further, the present invention eliminates the need for man-hours for securing the patch allocation area. In other words, the function variable allocation information database manages the allocation area of the existing system and patches that have been submitted so far,
And the management of free space.

[Brief description of the drawings]

FIG. 1 is a configuration diagram showing an embodiment of a high-level language patch creation system according to the present invention.

FIG. 2 is a flowchart of a patch load module generation procedure.

FIG. 3 is a memory allocation image diagram showing allocation of existing load modules in the present embodiment.

FIG. 4 is a memory allocation image diagram showing a state after patch application in the present embodiment.

FIG. 5 is a flowchart showing a conventional patch creation procedure.

[Explanation of symbols]

 11 Database Creation Device 12 Compilation 13 Patch Data Creation Device 21 Load Module 22 Function Variable Assignment Information Database 23 Patch Source File 24 Patch Object File 25 Patch Link Instruction Information File 26 Previous Patch Load Module 27 Patch Load Module 28 Old Memory Image File 111 Load module configuration management unit 112 Patch area management unit 113 Entry address management unit 131 Patch input area discrimination / reservation means 132 Address / address reference means for function / variable reference related locations 133 Linking means 134 Function variable assignment information database updating means 135 Old memory image File creation means

Claims (5)

[Claims] 1. A database creation device for creating and outputting a function variable allocation database for patch load module creation management by a plurality of load modules to be patched, and a function variable allocation database output from the database creation device. Based on the information, data corresponding to the same allocation address and size as the patch load module created this time is extracted and output from the load module constituting the existing system and the patch load module created last time, and output this time. A patch data creation device for creating and outputting the patch load module as an old memory image file. 2. A database creation device comprising: a load module configuration management unit for managing configuration information of the plurality of load modules; a patch area management unit for managing patch areas and past patch histories; and various entry addresses and allocation addresses. 2. The high-level language patch creation system according to claim 1, wherein the function variable allocation database is output by creation processing in each section of an entry address management unit to be managed. 3. The patch data creating device instructs a plurality of patch object files created by translating a plurality of patch source files to be patched and what patch processing is to be performed on the patch object files. Receives the patch link instruction information file and the signal output from each of the previous patch load modules, calculates the allocation address of the patch target data by function or variable, allocates the existing area or patch area, and connects to the existing system The high-level language patch creation system according to claim 1, wherein 4. The patch link instruction information file is patch-allocated by either modifying the data to be patched by the function or the variable by modifying the existing data on the existing system, or adding or deleting the patch data. 4. The high-level language patch creation system according to claim 3, wherein the instruction is automatically given. 5. The patch allocation is performed by comparing the size of the data to be patched with the existing allocation size to determine the size. If the size is smaller, the patch allocation is performed over the existing allocation area and the same allocation address is allocated. 5. The high-level language patch creating system according to claim 4, wherein a free area in the prepared patch area is obtained and secured.