JPH09265412A - Computer system and method for verifying system error processing - Google Patents

Abstract

PROBLEM TO BE SOLVED: To provide a verification method for easily verifying system error processing and a highly reliable computer system. SOLUTION: A main storage device 2 is provided with application programs 6 for plural processes, system error processing 7 to be executed at the occurance of a process error and switching processing 8 for a process to be executed. In addition, a false error table 9 including a process name, an error sort number and a counter is set up in the device 2 by table preparing processing 12 called from an auxiliary storage device 3. An error generation program 10 corresponds to the error sort number. When error generation in a succeeding execution process is specified by switching, false error injecting processing 11 substitutes an error generation program corresponding to the error sort for the program of the process. When a process error is generated as the result, the system error processing 7 executes defined degenerate processing after reexecuting only a counter value and displays an error process name, an error sort, or the like.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a computer system having a redundancy function for application software errors, and more particularly to a system error processing validity verification method.

[0002]

2. Description of the Related Art Regarding the error detection function of application software in a computer system, Japanese Patent Laid-Open No.
As described in No.-106631 (Cited example 1), an address is specified for a process placed at a fixed address on the main memory, a pseudo error occurs when an instruction of that address is executed, and a pseudo fault is identified. The method of doing is known. Further, as described in JP-A-4-369046 (Cited example 2), an online check method is known in which a process operated while a failure occurrence valid mode is set is regarded as an error.

On the other hand, in a computer system having redundancy such as degeneration of functions and retries in response to the occurrence of an error in application software, depending on the process and the error type of the process, the subsequent processing of the system is "system error processing". It is defined.

[0004]

In a computer system having a redundant function, it is necessary to generate an error in a designated process in application software in order to verify the validity of the above system error processing. .
However, it has not been realized by the conventional technology.

That is, in the method of the first reference example, the address cannot be specified for the process dynamically assigned to the main memory when the process is executed, and the user cannot specify the process in which an error is desired to occur. Moreover, in the method of the second reference example, it is not possible to specify what process operated while the valid mode was set.

In view of the current state of the art and problems, it is an object of the present invention to enable an error to occur in a designated process in application software and to easily and accurately verify the validity of system error processing. It is to provide a method for verifying error processing and a highly reliable computer system.

Another object of the present invention is to provide a system error handling verification method and a computer system which simulate a normal execution state of application software and enable a real system error handling verification.

[0008]

The object of the present invention is to provide a method for verifying the validity of system error processing for performing post-processing such as degeneration processing when an error occurs in application software consisting of a plurality of processes. Among them, the process name is registered in the process that causes an error, and when the next execution process is registered as an error occurrence during execution of the application software, error injection is performed to bring the process into a predetermined error state, and the error is generated. This is achieved by executing the post-processing depending on the state.

Alternatively, from among the above processes, the process name and the waiting time are registered in the process causing the error,
During execution of the application software, if there is a registration of an error occurrence in the next execution process after the waiting time has elapsed, error injection is performed to bring the process into a predetermined error state, and the post-processing is executed according to the error state. It is achieved by

In the above, the error injection is performed by executing an error generating program which replaces the process. Further, it is characterized in that an error type is registered together with the process name, and an error generation program corresponding to the error type is executed.

According to the error information from the OS, the process is re-executed when the error type is an error that can be recovered. Alternatively, if the given process is of high importance or if subsequent processing includes retries,
The number of trials is registered together with the process name, and each time the predetermined process becomes the next execution process, the error state due to the error injection is repeated for the number of trials, and then the execution of the process is suppressed.

Further, an object of the present invention is to provide a process processing device for switching and processing application software consisting of a plurality of processes, a storage device for storing programs and data, an input device and an output device for interfacing with a user, and a process. In the case of a computer system that has a system error handling function that provides system redundancy by degrading functions and retrying when an error occurs, the user specified information including the process name that specifies the error occurrence from the above processes is taken in. And a system error processing verification unit having a pseudo error injection unit that puts the pseudo error table registered in 1 above into an error state when the process to be executed next is a process registered in the pseudo error table. It is achieved by

The pseudo error table is provided for each process that causes an error, and the error is caused by a plurality of processes designated during execution of the application software.

A counter is provided in the pseudo error table, the number of retries for making the process into an error state is adjusted according to the counter value registered as the user designation information, and the validity of the retry performed by the system error processing is adjusted. It is characterized by making it possible to confirm.

A timer is provided in the pseudo error table to measure a waiting time registered as the user designation information, and after the lapse of time, the pseudo error table can be referred to.

When an error is generated by the error injecting means, a message indicating that the error is pseudo is displayed on the output device.

According to the present invention, since the name of the process in which an error occurs is designated, it is not necessary to be aware of the position of the process in the main memory, and the user can arbitrarily designate the process in which an error is desired to occur. Further, since the process operation is used as a trigger to generate an error, an error does not occur in a process other than the designated process, so that verification can be easily executed. Furthermore, since various error types are prepared and a test can be performed with a plurality of error types corresponding to the process, the reliability of verification is improved.

[0018]

BEST MODE FOR CARRYING OUT THE INVENTION Embodiments of the present invention will be described in detail below.

[First Embodiment] FIG. 1 is an overall configuration diagram of a computer system according to a first embodiment. The computer system includes a process processor 1, a main memory 2, an auxiliary memory 3, an input device 4, and an output device 5. In addition, an application program 6 including a plurality of processes,
When an application program has an error, a system error process 7, a process switching process 8, a pseudo error table 9, and an error occurrence subprogram that perform different corresponding processes (post-processes) such as degeneracy and retry according to the error state 10, a pseudo error injection process 11 and a table creation process 12. The pseudo error table 9 has a structure including a process name, an error type number, a counter, and the like, and the error type number has a one-to-one correspondence with the error occurrence subprogram.

Normally, in a computer system having a redundant function for dealing with errors, the error occurrence process is re-executed or immediately suppressed depending on the error type. Error types of application programs include data-dependent ones and instruction-dependent ones. The former is an error caused by the data state at that time, such as an indefinite value reference or division by zero, and may be recovered by a retry. The latter is unrecoverable due to unimplemented address references, illegal instructions such as jump destination errors, or destruction of the program itself.

FIG. 2 shows a verification flow of system error processing according to the first embodiment. In the figure, the details of the processing by the thick block will be described later. First, the user inputs table information such as the name of a process in an application program desired to be a pseudo error, the error type number in which the process causes an error, and the number of times (trial number) at which an error is desired from the input device 4 (S101). .

Next, the table creation processing 12 registers the input table information for each process to create the pseudo error table 9 (S102). After that, the process switching process 8 determines the process to be executed next by the process processing apparatus 1 (S103). If the process to be executed next matches the process name specified by the user, a pseudo error is injected into that process (S104). The application program is executed (S105), the process without pseudo error injection is executed as it is, and the process returns to the next process switching process. On the other hand, when the process into which the pseudo error is injected is executed, an error occurs, and in response to this, the system error process is started, and the post process corresponding to the error process or the generated error is performed (S10).
6). In this way, it is possible to verify the validity of system error handling by causing an error in a designated process while executing an application program.

FIG. 3 shows details of the pseudo error table creating process. In the present process 12, first, the table information input in S101 is fetched (S301) and repeated until the end of data for a plurality of processes designated by the user (S302). Next, the main memory 2 pseudo error table 9 is created (S303), and the user-specified conditions are stored (S3).
04). The pseudo error table is created for each process in the application program.

The pseudo error table may be created after the designated waiting time processing (S302) after the data acquisition. This operation will be described in detail later in the second embodiment.

FIG. 4 shows details of the pseudo error injection process. The pseudo error injection process 11 is executed every time the process switching process 8 switches. After the process switching is performed, the process name of the determined next execution process is acquired (S401). Next, the process name in the pseudo error table 9 is searched and compared with the previously acquired process name (S402). If the comparison results do not match, the next table is searched (S403). This comparison process is performed for all of the pseudo error tables (S404). If the comparison results do not match, there is no designation of pseudo error injection for the next execution process, so this process ends.

If the comparison results match, the counter value in the table is acquired (S405). If the counter value is 0 or less, this process indicates that the process has made an error the specified number of times, and therefore the pseudo error injection process is not performed (S406). If the counter value is positive, the counter value is decremented by 1 to set in the pseudo error table that one error has occurred (S4
07). This counter allows the process to fail a specified number of times. Finally, a pseudo error generating process is performed (S408).

FIG. 5 shows details of the pseudo error generation process. First, by the comparison process of step S402, the error type number is acquired from the pseudo error table in which the process names match (S501). Next, the start address of the error occurrence subprogram corresponding to the acquired error type number is obtained (S502). Next, the execution start address of the next execution process determined by the process switching process 8 is acquired (S503). Finally, this execution start address is rewritten to the start address of the error occurrence subprogram (S50).
4). As a result, the next process to be executed is executed from the error occurrence subprogram process at the time of execution, and the process becomes an error.

According to this, since only the execution start address is replaced by the pseudo error injection processing 11, it behaves as if an error occurred in the next execution process. Further, since the execution start address after the process switching is replaced, it is not necessary to change the application program itself.

FIG. 6 shows an error occurrence subprogram. The error occurrence subprogram 10 first displays a message M601 indicating the process name and the pseudo error on the output device 5 in order to clearly indicate to the user that the error that has occurred is a pseudo error (S601). This message makes it possible to identify a random error due to a bug or the like. Next, a program error process according to the error type is executed (S602).

FIG. 7 shows system error handling. The system error processing 7 fetches error information of the process name and error type in error from the OS (S70).
1), it is determined whether the error type is re-executable (S
702). If it is a data-dependent error, there is a possibility of remedy by re-execution as described above. It is also possible to determine whether or not re-execution is possible depending on the importance of the process and retry the process that plays an important role in the application program.

In the case of no retry, the function degradation message M
703 is output (S703). On the other hand, if retry is possible, a retry message M704 is output (S704),
It is determined whether the number of retries has been exceeded (S705), and the error process is re-executed repeatedly while it is not exceeded (S705).
706). When the number of retries is exceeded, a message M807 to that effect is output (S707), and thereafter, the processing of the process is suppressed and the defined function degeneration processing is executed (S708).

FIG. 8 shows a specific example of the output message.
FIG. 10A shows the case of a process error for which retry is not defined. The message M801 is a standard message output by the OS based on the error information. By comparing the messages M601 and M801, it is possible to immediately recognize whether or not the process error is pseudo. Message M703
Is the processing result of step S703. FIG.
Is a process error with retries defined, M60
1 and M801 are the same as in (a). The message M704 is the processing result of S704, and M707 is the processing result of S707.

According to this embodiment, an error can be generated in an application program consisting of multiple processes, triggered by the execution of the process designated by the process name. As a result, the user does not need to be aware of the position of the process in the main memory at all, and since a plurality of designated processes do not simultaneously make an error, the validity verification of the system error processing is facilitated.

Further, an error can be generated without making any changes to the application program.
This keeps the state of the application program unique during the verification test of system error handling.
The validity of the system can be easily verified at startup, when the system is changed, and at regular inspections, and the reliability of the system can be maintained.

Further, various kinds of errors can be generated in the application program. As a result, it becomes possible to verify the validity of the system error processing including the number of retries and the number of times depending on the type of error, and improve the quality of verification.

Further, during the verification test, it is possible to clearly indicate whether or not the error that has occurred is a pseudo error according to the designation. This facilitates the identification of accidental errors and improves the accuracy of verification.

[Second Embodiment] FIG. 9 shows a system block diagram according to a second embodiment of the present invention. This figure expresses the processing loop of the computer system of FIG. 1 by functional blocks, and can be said to be an expression in which the view of the processing flow of FIG. 2 is changed. In the figure, the same steps as those in FIG. 2 are denoted by the same step numbers, and the different point is the table creation processing S10.
2 '.

In the pseudo error injection processing S104, error injection is not performed for the next execution process when the pseudo error table is not created, so that the process is normally executed in S105. That is, the pseudo error injection processing S104
Is executed as a result of table creation by the pseudo error table creation process S102 '.

Table creation processing S102 'of this embodiment
Creates a table after the designated waiting time has elapsed (S302 is inserted in FIG. 3). For this reason,
In the first embodiment, an error occurs at the same time as the start of the designated process, but in the present embodiment, a pseudo error can be generated in a timed manner by delaying the waiting time arbitrarily set in each process.

A timer for the waiting time may be provided in the pseudo error table created in advance so that the table can be searched from the pseudo error injection process depending on the time limit of the timer.

As described above, according to the present embodiment, it is possible to cause an error to occur in a designated process at an arbitrary time while executing an application program normally, and to verify the system error processing. Realistic verification assuming a close operating state is possible. Furthermore, in the case of a system configuration consisting of multiple computers,
Since simultaneous or continuous error occurrence can be realized by a plurality of computers, it is suitable for verification of system error processing including life-and-death monitoring and system switching processing in a multiple system.

[0042]

According to the present invention, it is possible to specify a process name for a plurality of processes and generate a pseudo error at the time of execution in any process. Moreover, there is an effect that the verification can be performed accurately. Further, by preparing a plurality of error types, it is possible to verify the validity of the system error processing corresponding to various errors, and it is possible to improve the reliability of the system.

Further, the system error processing verification test can be carried out without making any changes to the application software, etc., so that the actual system can be easily inspected by the user and the system reliability can be maintained. is there.

Furthermore, post-processing can be selected according to the importance of the designated process or the type of error, and for example, verification of high-grade system error processing including retry check for processes of high importance can be performed. become.

Further, since whether the generated process error is pseudo or not and the degeneracy process is executed are clearly indicated, it is easy to distinguish it from an accidental error during the test, which is convenient for the user.

Further, according to the present invention, since an error can be generated for a designated process at an arbitrary time, it is possible to simulate the actual error occurrence and verify the system error handling for a plurality of processes which are realistically designated. Since it can be tested, it can be applied to various systems.

[Brief description of drawings]

FIG. 1 is a configuration diagram of a computer system according to a first embodiment of the present invention.

FIG. 2 is a flowchart showing a verification operation of system error processing according to the first embodiment of the present invention.

FIG. 3 is a flowchart of table creation processing.

FIG. 4 is a flowchart of pseudo error injection processing.

FIG. 5 is a flowchart of pseudo error generation processing during pseudo error injection processing.

FIG. 6 is a flowchart of an error occurrence subprogram.

FIG. 7 is a flowchart of system error processing.

FIG. 8 is a diagram showing a display example of an output message in the verification operation of the system error processing.

FIG. 9 is a system block diagram showing a loop of system error processing according to the second embodiment of the present invention.

[Explanation of symbols]

1 ... Process processing device, 2 ... Main storage device, 3 ... Auxiliary storage device, 4 ... Input device, 5 ... Output device, 6 ... Application software, 7 ... System error processing, 8 ... Process switching processing, 9 ... Pseudo error table 10 ... Error occurrence subprogram, 11 ... Pseudo error injection processing, 12
… Table creation process.

 ─────────────────────────────────────────────────── ─── Continuation of the front page (72) Inventor Hajime Fujimoto 5-2-1, Omika-cho, Hitachi-shi, Ibaraki Hitachi Process Computer Engineering Co., Ltd. No. 1 Incorporated company Hitachi Ltd. Omika factory (72) Inventor Toshiaki Higashihara 5-2-1 Omika-cho, Hitachi City, Ibaraki Prefecture Incorporated company Hitachi Ltd. Omika factory

Claims (16)

[Claims] 1. A method of verifying the validity of system error processing, which performs post-processing such as degeneration processing when an error occurs in application software consisting of a plurality of processes, which is a process that causes an error from among the processes. A process name is registered in the process, and while the application software is being executed, if an error occurrence is registered in the next execution process, error injection is performed to bring the process into a predetermined error state, and the post-processing is executed according to the error state. A method for verifying system error handling, which is characterized in that 2. A method for verifying the validity of system error processing, which performs post-processing such as degeneracy processing when an error occurs in application software consisting of a plurality of processes, which is a process that causes an error from among the processes. If the process name and the waiting time are registered in, and the next execution process has registered the occurrence of an error after the waiting time during execution of the application software, error injection is performed to bring the process into a predetermined error state, A method for verifying system error processing, characterized in that the post-processing is executed according to the error state. 3. The system error processing verification method according to claim 1, wherein the error injection is performed by executing an error generation program that substitutes the process. 4. The method for verifying system error processing according to claim 1, 2 or 3, wherein an error type is registered together with the process name, and an error occurrence program corresponding to the error type is executed. 5. The system error handling verification method according to claim 4, wherein the process is re-executed when the error type is an error that may be recovered. 6. The method according to claim 1, wherein when the predetermined process has a high degree of importance or when the subsequent processing includes a retry, the number of trials is registered together with the process name, and the predetermined process is the next execution process. Each time, the error state due to the error injection is repeated for the number of times of the trial, and then the execution of the process is suppressed. 7. The method for verifying system error processing according to claim 3, wherein the error generation program performs processing for setting the error state and outputs a message that clearly indicates a pseudo error. 8. A method of verifying the validity of a system error process that performs post-processing such as degeneration process when an error occurs in an application program consisting of a plurality of processes, in which a process name is required, and further, an error type. A pseudo error table is created by fetching user-specified information such as the number of trials and the number of trials.While the application program is being executed, the process name of the next execution process due to process switching processing is searched for and registered in the pseudo error table. If the number of trials is set, the pseudo error is generated, and if the number of trials is set, it is subtracted by 1 until it becomes 0. Repeat the pseudo error generation, after the final generation of the pseudo error, A method for verifying system error processing, characterized in that execution of the process is suppressed and predetermined post-processing is performed. 9. The pseudo error generation according to claim 8, wherein an error type is acquired from the pseudo error table, a start address of an error occurrence program corresponding to the error type is obtained, and the start address is set to the next execution process. A method for verifying system error handling, which is characterized by writing at the start address of. 10. The system according to claim 8 or 9, wherein the pseudo error table creation process has a waiting time process, and the error occurrence timing of each process is adjusted by the arbitrarily specified waiting time. How to verify error handling. 11. When a process error occurs together with a process processing device for switching and processing application software consisting of a plurality of processes, a storage device for storing programs and data, and an input device and an output device for interfacing with a user. In a computer system that has a system error handling function that provides system redundancy by degrading functions and retrying, a pseudo error table that captures and registers user-specified information including the process name that specifies the error occurrence from the above process And a system error processing verification means having a pseudo error injection means for setting the process to be an error state when the process to be executed next is a process registered in the pseudo error table. system. 12. The error generation program according to claim 11, wherein an error occurrence program corresponding to an error type is stored in the storage device, and the error injection unit corresponds to an error type registered in the pseudo error table as the user designation information. A computer system that executes an error generating program that substitutes for the process. 13. The computer according to claim 11, wherein the pseudo error table is provided for each process that causes an error, and the error is caused by a plurality of processes designated during execution of the application software. system. 14. The counter according to claim 11, 12 or 13, wherein a counter is provided in the pseudo error table, and the number of trials in which the process is in an error state is adjusted according to a counter value registered as the user designation information, A computer system characterized by being able to confirm the validity of a retry performed by system error processing. 15. The pseudo error table according to claim 11, further comprising a timer for counting a waiting time registered as the user designation information, and enabling the reference of the pseudo error table after the elapse of the waiting time. A computer system characterized by that. 16. The computer system according to any one of claims 11 to 15, wherein when an error is generated by the error injection unit, a message indicating that the error is pseudo is displayed on the output device.