JP2005122409A - Failure tracking method and device for system having virtual layer, and computer program - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To provide a failure tracking method for a system having a virtual layer. <P>SOLUTION: A stack system detects an error in a user application interface, and identifies an error being a relevant bottom cause in a much lower stack level, and prepares an error trace entry concerning the error, and associates an error log identifier with the error trace entry, and prepares an unique error identifier in the plurality of host systems of the stack system from the combined error log identifier and error trace entry. When there is high possibility that any failure is generated in a service due to the error being the bottom cause, the error identifier is transmitted to an arbitrary service request side through the user application interface of one or more host systems. Thus, the error detected by the user application interface of one or more host systems is associated with the error being the bottom cause in the stack level below a virtual layer. <P>COPYRIGHT: (C)2005,JPO&NCIPI

Description

  The present invention relates to error tracking, and in particular to error tracking in an environment having a virtualization layer between a host application and a device.

  Fault detection and isolation problems (finding complex system problems to their root cause) are very important issues. In some environments, error reporting information may only be lacking, but in many enterprise-wide environments, much effort has been put into presenting and logging detected faults. . In a fault tolerant system, such information is essential to ensure continued fault tolerance. Without an effective fault detection / repair mechanism, fault tolerant systems can only mask the problem until further faults fail.

  When problems arise, it is often difficult to predict the impact. For example, the storage controller subsystem has many components in the path or “stack” from the disk drive to the host application. It is difficult to relate the actual detected and logged errors to the impact seen by the application or the user's host system.

  When many errors occur at once, it is particularly difficult to determine which of those errors leads to a particular application failure. A powerful solution that repairs all reported errors will certainly help, but a priority-based approach to repairing errors that affected the business-critical application is more cost-effective and system-friendly. There is great value for users.

  The lack of any traceability means that the reliability that the appropriate error has been fixed to resolve a specific problem that has occurred to the user or application is also reduced.

  Today's systems with RAID arrays, extensions like Flash Copy, and caches already add a lot of confusion to top-down analysis (tracking failures from applications to system components). It takes a lot of time and knowledge to select the error that is the root cause of the failure.

  This problem is further magnified by introducing a virtualization layer in many systems. Not only does virtualization add another layer of no purpose, but many virtualization methods allow dynamic movement of data in the underlying actual subsystem, so accurate fault tracking is not possible It will be even more difficult.

For example, it is known from the teaching of US Pat. No. 5,974,544 to use a redundant array of inexpensive disks to maintain a logical defect list at the RAID controller level of the storage system. However, in the case of a system that uses multiple such arrays in conjunction with other peripheral devices, and especially if they are part of a storage area network (SAN), the system may report an error as an external symptom. Introduce a layer of software with features like virtualization that makes it more difficult to track from root to root cause.
US Pat. No. 5,974,544

  Accordingly, there is a need for a method, system, or computer program that alleviates this problem. Furthermore, this problem is preferably alleviated with a minimal burden on the customer in terms of money, processing resources and time.

  Accordingly, the present invention provides, in a first aspect, an error detected in a user application interface of one or more host systems of a plurality of host systems at a stack level below the virtualization layer. A method in a stack system for associating with root cause errors, detecting errors in the user application interface, and identifying associated root cause errors at a lower stack level Creating an error tracking entry for the error; associating an error log identifier with the error tracking entry; from the combined error log identifier and the error tracking entry, the plurality of the stack system Host system Creating a unique error identifier within a system and one or more of a plurality of host systems if the service is likely to fail due to the root cause error Communicating the error identifier to any requestor of a service at a user application interface of a host system.

  Creating a unique error identifier within the plurality of host systems of the stack system from the combined error log identifier and the error tracking entry comprises: generating an error identifier that is unique within the plurality of host systems. Preferably, the method includes the step of combining the error tracking entry and the error log identifier with an integer value for creation.

  The error that is the root cause of the lower stack level is preferably in the peripheral device of the stack system.

  The peripheral device is preferably a storage device.

  The stack system preferably includes a storage area network.

  In a second aspect, the present invention provides a stack level root for detecting errors detected in a user application interface of one or more of the plurality of host systems below the virtualization layer. A device associated with the causal error, an error detector for detecting the error in the user application interface, and a diagnostic component for identifying the associated causal error at a lower stack level; A tracking component for creating an error tracking entry for the error, an identification component for associating an error log identifier with the error tracking entry, the combined error log identifier and the error tracking entry from the stack Said duplicate of the system A system-wide identification component to create a unique error identifier within the host system, and a plurality of hosts that are likely to fail the service due to the root cause error. An apparatus is provided comprising a communication component for conveying the error identifier to any requestor of service at a user application interface of one or more host systems of the system.

  A system-wide identification component for creating a unique error identifier within the plurality of host systems of the stack system from the combined error log identifier and the error tracking entry is within the plurality of host systems. Preferably, it comprises a component for combining the error tracking entry and the error log identifier with an integer value to create a unique error identifier.

  The error that is the root cause of the lower stack level is preferably in the peripheral device of the stack system.

  The peripheral device is preferably a storage device.

  The stack system preferably includes a storage area network.

  According to a third aspect of the present invention, in a third aspect, when loaded and executed on a computer system, the computer system has a user application application for one or more of the plurality of host systems. A computer program product tangibly implemented on storage media to correlate errors detected at the interface with errors at the root level of the stack level below the virtualization layer, the user application interface Computer program code means for detecting errors in the computer, computer program code means for identifying the relevant root cause error at a lower stack level, and a computer program for creating an error tracking entry for the error Ram code means, computer program code means for associating an error log identifier with the error tracking entry, and the plurality of host systems of the stack system from the combined error log identifier and error tracking entry Computer program code means for creating a unique error identifier within the host, and one of a plurality of host systems when the service is likely to fail due to the root cause error There is further provided a computer program product comprising computer program code means for communicating said error identifier to any requestor of service at a user application interface of one or more host systems.

  A preferred embodiment of the present invention for isolating faults in a virtualized storage subsystem where root cause information is tagged with errors using a unique error identifier is a plurality of faults caused by a single fault in the system. It offers the advantage that an error can be diagnosed immediately due to the one fault. This speeds up the diagnostic procedure and reduces potential downtime in a normally very effective system.

  Preferred embodiments of the present invention will now be described by way of example only with reference to the accompanying drawings.

  The preferred embodiment of the present invention begins with taking a conventional error log (170) as is prevalent in many enterprise-scale environments. The error log is used to record faults detected by system components. Typically, there are components that interface "outside", such as the network or driver layer, and first detect and handle errors.

  A unique identifier (210) is added to the existing conventional error log entry. This can be done using a large (eg 32 bit) integer for each entry. The unique identifier indicates a particular event that, when modified by the log identifier, may continue to cause a failure in input / output services or other operations. The error log contains supplemental information detailing the detected fault (220) sufficient for the user or service technician to repair the root cause fault.

  The unique identifier is then used as part of the response to any service request (eg, I / O request) that is likely to have failed due to the error. When the request issuer receives a failure response to the request, it determines its own service or request that is likely to have failed, if any. The issuer of the request fails its own request and again presents the first received unique identifier that indicates the cause of those failures.

  Thus, the identity of the event that is the cause of the failure passes through the entire series of failed requests until the origin of each request is reached. In this case, the source has the information necessary to accurately determine which error events need to be repaired for each detected fault, which facilitates the repair process and is the most dangerous An application that is in a safe state is reliably repaired first. There is also a higher degree of confidence that the appropriate error has been repaired, thereby preventing the expense associated with time delays and recovery failures.

  In the presently most preferred embodiment, the component that communicates the request is the layer of the software stack (100), management of the RAID controller (110), virtualization (120), flash copy (130), caching (140), Perform functions such as remote copy (150) and interface to host system (160). The method of the preferred embodiment of the present invention allows for traceability to track the stack throughout the system to the edge of the storage controller.

  Each component of the software stack can itself present an error as a result of the event in which the original failure occurred. As an example, a write operation from the application server (190) can be returned to the SCSI back end (110) as a failure, i.e., for some reason the write has failed due to physical storage. . As a result, the error is logged and the unique identifier (210) is returned to the component presenting the problem. The failing write is returned to the upper layer with a unique identifier. They are returned to the stack. At each layer, this can cause failures within that component. For example, if a flash copy is active for a disk that has failed to write, the flash copy operation is interrupted and an error is presented. The new error itself is assigned a unique identifier, which is marked with the unique identifier passed by the lower component, namely the root cause (230). The same thing may occur in each layer in the software stack. As a result, the first error is returned as part of the SCSI sense data to the application server that requested the write.

  In this case, the user must relate the failed write operation to the failed physical disk and the failed operation and function in the software stack, such as the flash copy operation described above. Can do.

  The methods described above are typically implemented in software running on one or more processors (not shown), and any suitable data carrier (also shown) such as a magnetic or optical computer disk. It will be understood that it can be provided as a computer program element carried in Similarly, channels for data transmission can include all types of storage media, as well as signal carrying media such as wired or wireless signal media.

  The present invention can be suitably implemented as a computer program product for use in a computer system. Such an implementation may be via a series of computer readable instructions fixed to a tangible medium, such as a computer readable medium such as a diskette, CD-ROM, ROM, or hard disk, or a modem or other interface device. A series that can be transmitted to a computer system by means of tangible media including, but not limited to, optical or analog communication lines, or intangibly using wireless technologies including but not limited to microwave, infrared, or other transmission technologies Computer readable instructions. This series of computer readable instructions implements all or part of the functionality already described herein.

  Those skilled in the art will appreciate that such computer readable instructions can be written in a number of programming languages for use in many computer architectures or operating systems. Further, such instructions can be stored using any current or future memory technology including, but not limited to, semiconductor, magnetic, or light, or are not limited to light, infrared, or micro Any current or future communication technology including waves can be used for transmission. Such computer program products can be distributed as removable media with attached printed materials or electronic documents, such as software packages, preloaded into a computer system, for example, by a system ROM or fixed disk, or, for example, the Internet or world It is expected that it can be distributed from a server or an electronic bulletin board via a network such as the wide web.

  It will be understood that various modifications to the above embodiments will be apparent to those skilled in the art.

  In summary, the following matters are disclosed regarding the configuration of the present invention.

(1) To correlate an error detected in the user application interface of one or more of the host systems to an error that is the root cause at the stack level below the virtualization layer. In a stack system of
Detecting errors in the user application interface;
Identifying the associated root cause error at a lower stack level;
Creating an error tracking entry for the error;
Associating an error log identifier with the error tracking entry;
Creating a unique error identifier within the plurality of host systems of the stack system from the combined error log identifier and the error tracking entry;
Any of the services in the user application interface of one or more of the host systems when there is a high probability that the service has failed due to the root cause error Communicating the error identifier to a requester of the method.
(2) creating a unique error identifier within the plurality of host systems of the stack system from the combined error log identifier and the error tracking entry;
The method of (1) above, comprising combining an error tracking entry and an error log identifier with an integer value to create a unique error identifier within the plurality of host systems.
(3) The method according to (1) above, wherein an error that is a root cause of a lower stack level is in a peripheral device of the stack system.
(4) The method according to (3) above, wherein the peripheral device is a storage device.
(5) The method according to (1) above, wherein the stack system includes a storage area network.
(6) An apparatus for associating an error detected in a user application interface of one or more host systems among a plurality of host systems with an error that is a root cause at a stack level below the virtualization layer Because
An error detector for detecting errors in the user application interface;
A diagnostic component to identify related root cause errors at lower stack levels;
A tracking component for creating an error tracking entry for the error;
An identification component for associating an error log identifier with the error tracking entry;
A system-wide identification component for creating a unique error identifier within the plurality of host systems of the stack system from the combined error log identifier and the error tracking entry;
Any of the services in the user application interface of one or more of the host systems when there is a high probability that the service has failed due to the root cause error A communication component for transmitting the error identifier to a requester of the system.
(7) A system-wide identification component
The apparatus of (6) above, comprising a component for combining an error tracking entry and an error log identifier with an integer value to create a unique error identifier within the plurality of host systems.
(8) The apparatus according to (6), wherein an error that is a root cause of a lower stack level is present in a peripheral device of the stack system.
(9) The device according to (6), wherein the peripheral device is a storage device.
(10) The apparatus according to (6) above, wherein the stack system includes a storage area network.
(11) An error detected in a user application interface of one or more host systems of a plurality of host systems when loaded and executed on the computer system. A computer program that causes a stack level underlying cause error below the virtualization layer to be associated,
Computer program code means for detecting errors in a user application interface;
Computer program code means to identify the associated root cause error at a lower stack level;
Computer program code means for creating an error tracking entry for said error;
Computer program code means for associating an error log identifier with the error tracking entry;
Computer program code means for creating a unique error identifier within the plurality of host systems of the stack system from the combined error log identifier and the error tracking entry;
Any of the services in the user application interface of one or more of the host systems when there is a high probability that the service has failed due to the root cause error A computer program comprising computer program code means for transmitting the error identifier to the requesting party.

It is a figure which shows an example of the component stack of a virtualization subsystem. FIG. 5 is a diagram illustrating an example of an error log according to a presently preferred embodiment of the present invention.

Explanation of symbols

100 Virtualization subsystem (software stack)
110 SCSI back end 120 Virtualization 130 Flash copy 140 Cache 150 Remote copy 160 SCSI front end 170 Error log 190 Application server 220 Error code 230 Root cause

Claims (11)

A stack for associating errors detected in the user application interface of one or more of the host systems with the underlying error at the stack level below the virtualization layer A method in a system,
Detecting errors in the user application interface;
Identifying the associated root cause error at a lower stack level;
Creating an error tracking entry for the error;
Associating an error log identifier with the error tracking entry;
Creating a unique error identifier within the plurality of host systems of the stack system from the combined error log identifier and the error tracking entry;
Any of the services in the user application interface of one or more of the host systems when there is a high probability that the service has failed due to the root cause error Communicating the error identifier to a requester of the method. Creating a unique error identifier within the plurality of host systems of the stack system from the combined error log identifier and the error tracking entry;
The method of claim 1, comprising combining an error tracking entry and an error log identifier with an integer value to create a unique error identifier within the plurality of host systems.   The method of claim 1, wherein the error that is the root cause of the lower stack level is in a peripheral device of the stack system.   The method of claim 3, wherein the peripheral device is a storage device.   The method of claim 1, wherein the stack system comprises a storage area network. An apparatus for associating an error detected in a user application interface of one or more host systems of a plurality of host systems with a stack level root cause error below a virtualization layer. ,
An error detector for detecting errors in the user application interface;
A diagnostic component to identify related root cause errors at lower stack levels;
A tracking component for creating an error tracking entry for the error;
An identification component for associating an error log identifier with the error tracking entry;
A system-wide identification component for creating a unique error identifier within the plurality of host systems of the stack system from the combined error log identifier and the error tracking entry;
Any of the services in the user application interface of one or more of the host systems when there is a high probability that the service has failed due to the root cause error A communication component for transmitting the error identifier to a requester of the system. A system-wide identification component
7. The apparatus of claim 6, comprising a component for combining an error tracking entry and an error log identifier with an integer value to create a unique error identifier within the plurality of host systems.   7. The apparatus of claim 6, wherein the error that is the root cause of the lower stack level is in a peripheral device of the stack system.   The apparatus of claim 6, wherein the peripheral device is a storage device.   The apparatus of claim 6, wherein the stack system comprises a storage area network. A virtualization layer that, when loaded and executed on a computer system, causes an error detected in a user application interface of one or more host systems of the plurality of host systems to the computer system. A computer program that causes a stack level underlying cause error to be associated with
Computer program code means for detecting errors in a user application interface;
Computer program code means to identify the associated root cause error at a lower stack level;
Computer program code means for creating an error tracking entry for said error;
Computer program code means for associating an error log identifier with the error tracking entry;
Computer program code means for creating a unique error identifier within the plurality of host systems of the stack system from the combined error log identifier and the error tracking entry;
Any of the services in the user application interface of one or more of the host systems when there is a high probability that the service has failed due to the root cause error A computer program comprising computer program code means for transmitting the error identifier to the requesting party.

Images