Abstract: Apparatus and methods which allow multiple storage controllers sharing access to common data storage devices in a data storage subsystem to access a centralized intelligent cache. The intelligent central cache provides substantial processing for storage management functions. In particular, the central cache of the present invention performs RAID management functions on behalf of the plurality of storage controllers including, for example, redundancy information (parity) generation and checking as well as RAID geometry (striping) management. The plurality of storage controllers (also referred to herein as RAID controllers) transmit cache requests to the central cache controller. The central cache controller performs all operations related to storing supplied data in cache memory as well as posting such cached data to the storage array as required.

Abstract: In one embodiment, the present invention provides a storage system controller (10) having a main processor (12), a memory (14) and a device interface (18) adapted to interface with a peripheral component (28-32). The controller further includes an interrupt management scoreboard (24) adapted to receive a plurality of writes from the peripheral component(s) prior to interrupting the main processor. The main processor identifies a group of tasks to be executed, and sets up the scoreboard to await the completion of the tasks before interrupting the main processor.

Abstract: A method and apparatus for increasing performance in a data processing system. The data processing system includes a plurality of storage devices and a backup storage device. The backup storage device is configured as a log device. Data is logged to the backup storage device after the backup storage device has been configured as a log device. In response to a failure of a storage device within the plurality of storage devices, the backup storage device is reconfigured to be used as a replacement for the failed storage device.

Abstract: Methods and structures for defining partitions within a RAID storage system LUN such that each partition is managed in accordance with RAID management techniques independent of the other partitions. The total data storage of the LUN is subdivided and mapped into a plurality of partitions also referred to as partitions. Initially, each partition is configured and mapped to run as a RAID level 1 mirrored storage area. As performance and storage capacity needs as measured for each partition dictate, a partition of a LUN may be reconfigured to use a different RAID level (i.e., level 3 or 5) to reduce overhead storage needs at the cost of decreased write performance. A partition may later be returned to RAID level 1 as performance needs so indicate. Each partition is therefore managed in accordance with its own RAID level of management.

Abstract: Apparatus and methods which allow multiple storage controllers sharing access to common data storage devices in a data storage subsystem to access a centralized intelligent cache. The intelligent central cache provides substantial processing for storage management functions. In particular, the central cache of the present invention performs RAID management functions on behalf of the plurality of storage controllers including, for example, redundancy information (parity) generation and checking as well as AID geometry (striping) management. The plurality of storage controllers (also referred to herein as RAID controllers) transmit cache requests to the central cache controllers. The central cache controllers performs all operations related to storing supplied data in cache memory as well as posting such cached data to the storage array as required.

Abstract: A method for detection of hot-swap of disk drives in a storage subsystem devoid of special circuits for such detection and for buffering of bus signals. Typical prior designs utilize special circuits such as disk drive canisters for physically and electronically connecting the disk drives to the storage subsystem. These canisters provided electronic buffering to reduce or eliminate transient (noise and glitch) signals associated with hot-swap drive removal and insertion. In addition, such canisters provided special purpose circuits to inform storage subsystem control modules that a possible insertion or removal occurred by forcing a reset of the interconnection bus in response to detection of such transient signals. The present invention provides for such detection without need for such complex (e.g., costly) special purpose circuits.

Abstract: The present invention retrieves data across independent computer nodes of a server cluster by providing for I/O shipping of block level requests to peer intelligent host-bus adapters (hereinafter referred to as HBA). This peer-to-peer distribution of block I/O requests is transparent to the host. The HBA has the intelligence to decide whether to satisfy a block I/O request locally or remotely. Each HBA driver utilizes the I2O protocol, which allows peer-to-peer communication independent of the operating system or hardware of the underlying network. In a first embodiment of the present invention, local and remote storage channels, within a node, are supported by a single HBA. In a second embodiment of the present invention, local storage channels, within a node, are supported by one HBA, and the remote storage channel, within a node, is supported by a separate HBA.

Abstract: Method and apparatus for accelerating write operations logging write requests in a log structured cache and by expanding the log structured cache using a cache-extension disk region. The log structured cache include a cache memory region partitioned into one or more write cache segments and one or more redundancy-data (parity) cache segments. The cache-extension disk region is a portion of a disk array separate from a main disk region. The cache-extension disk region is also partitioned into segments and is used to extend the size of the log structured cache. The main disk region is instead managed in accordance with storage management techniques (e.g., RAID storage management). The write cache segment is partitioned into multiple write cache segments so that when one is full another can be used to handle new write requests. When one of these multiple write cache segments is filled, it is moved to the cache-extension disk region thereby freeing the write cache segment for reuse.

Abstract: Methods and associated apparatus for balancing the I/O request processing load within a plurality of controllers in a storage subsystem. The methods of the present invention are operable within interconnected controllers of a storage subsystem to shift the processing of received I/O requests to less loaded controllers and to do so in a manner transparent to legacy attached host systems. In a first embodiment of the present invention referred to as back-end load balancing, I/O requests are transferred from a first controller, to which the I/O request was directed by the attached host system, to a second controller for further processing. In this back-end load balancing embodiment, all write data associated with a write request as well as returned information including status or read data, is exchanged between the first and second controllers such that the first controller performs all communication with the attached host system.

Abstract: Methods and associated apparatus for automatically synchronizing the operating code between a plurality of controllers. In a first embodiment after the spare controller is swapped into the storage subsystem, if the native controller determines that the spare controller's operating code is incompatible with the native controller's operating code, then the native controller notifies the spare controller that synchronization is required between both controllers. The native controller creates an image of its operating code including configuration parameters, and copies this "synch info" into a reserved area of cache memory. The spare controller's main CPU utilizes mirroring routines to copy the operating code and configuration parameters into a reserved area of its cache memory. After the transfer is complete, the spare controller's main CPU loads the operating code and configuration parameters into its program memory and resets itself to operate with the modified program memory.

Abstract: Methods and associated apparatus for performing concurrent I/O operations on a common shared subset of disk drives (LUNs) by a plurality of RAID controllers. The methods of the present invention are operable in all of a plurality of RAID controllers to coordinate concurrent access to a shared set of disk drives. In addition to providing redundancy features, the plurality of RAID controllers operable in accordance with the methods of the present invention enhance the performance of a RAID subsystem by better utilizing available processing power among the plurality of RAID controllers. Under the methods of the present invention, each of a plurality of RAID controllers may actively process different I/O requests on a common shared subset of disk drives. One of the plurality of controllers is designated as primary with respect to a particular shared subset of disk drives.

Abstract: The invention relates to a method and apparatus for maintaining data/parity consistency in a RAID data storage system. The invention utilizes reserved disk storage space in the RAID array to log data necessary to restore data/parity consistency should an interruption event, such as a power failure, corrupt the data stored in a particular redundancy group. In one embodiment, the invention logs new data and new parity information to the reserved disk storage space before the new data and new parity information are written to the appropriate locations in the associated redundancy group. In this way, if an interruption event occurs when either the new data or the new parity information has already been written to the redundancy group but the other has not, the corresponding data and parity information stored in the reserved disk storage space can be used to restore data/parity consistency after the event has ended.

Abstract: A loop isolation circuit (LIC) to enable subdivision of a single daisy-chained communication loop (e.g., FC-AL) into smaller loops and to enable joining of smaller loops into a single larger loop. An LIC comprises essentially two multiplexors configured so as to permit controlled subdivision or joining of two loop portions. In a first selected state, the LIC subdivides a communication loop in which it is inserted into two loops. This configuration sacrifices accessibility among some devices previously on the larger loop for the benefit of enhanced bandwidth and reduced overhead due to node count. Bandwidth is enhanced by enabling simultaneous operation of two (or more) loop portions for establishing and communicating over logical circuit connections. However, when a failure of a redundant loop precludes access to devices, the LIC may be set to a second state to rejoin previously subdivided loops into a larger loop. This configuration restores access among all devices sharing common access to the larger loop.

Abstract: Resource allocation logic for a computer system including a plurality of processors which share access to, and control of, a plurality of resources, such as disk drive units or busses. The resource allocation logic coordinates the execution of requests received from the processors to avoid resource sharing inefficiencies and deadlock situations. The allocation logic maintains a "request" queue for each processor, seeking to satisfy all requests quickly and fairly. The queues contain an entry corresponding to each request received from its corresponding processor and an identification of resources that are required by the entry's corresponding request. The allocation logic also maintains a "resources available" status array of resources which are not currently in use by any processors, or are not reserved for future use by any processors.

Abstract: Methods and associated apparatus within a RAID subsystem having redundant controllers define a private LUN as a data storage area known and accessible to all controllers in the system and used by them for diagnostic purposes. The methods involve sending a diagnostic write command to a first controller with instructions for it to write test data to the private LUN. This first controller writes this test data to the private LUN. A second controller, in response to another diagnostic command, then reads this test data from the private LUN and compares it to expected values provided in the diagnostic command. Using the results, it can then be determined which controller, if any, failed. If the first controller fails, then the second controller takes over ownership of portions of the data storage area assigned to the first controller. The private LUN is preferably striped across all channels used by the controllers to communicate to commonly attached disk drives.

Abstract: The invention provides a method and apparatus for increasing the efficiency of data transfer between a host computer and a disk array in a RAID system. The invention operates by splitting up large I/O requests from the computer into smaller, more manageable pieces and processing the pieces as though they were individual I/O requests. In one embodiment, the invention keeps only a limited number of these smaller individual I/O requests "active" at any particular time so that a single large I/O request cannot preclude other I/O requests from making progress in the controller. Both the size of the smaller I/O request pieces and the limited number of these pieces which will be "active" at any one time may be tunable parameters. The invention improves the efficiency of data transfer between the host computer and the array of disk drives by providing for increased overlap of activity in the controller. This increased overlap of activity results in increased controller throughput.

Abstract: A data processing system that includes an improved architecture for providing hot spare storage devices. Specifically, the data processing includes a bus that is connected to one or more computer systems and a number of storage subsystems. Each storage subsystem includes storage devices and a controller. The controller in a storage subsystem provides the connection to the bus and an interface for controlling data transfers to and from the storage device. A backup storage system is connected to the bus. The data processing system also includes a detection means for detecting a failure of a storage device within one of the plurality of storage subsystems and a backup means for using the backup storage device to replace the failed storage device.

Abstract: Methods and associated apparatus for coordinating file lock requests from a cluster of attached host computer systems within I/O controllers (e.g., intelligent I/O adapters) attached to a storage subsystem. The I/O controllers, operable in accordance with the methods of the present invention, includes semaphore tables used to provide temporary exclusive access to an identified portion of an identified file. The host systems request the temporary exclusive access of a file through the I/O controllers rather than over slower network communication media and protocols as is known in the art. The I/O controllers then manages a plurality of competing lock requests to provide mutual exclusivity of the file access. The file lock management is therefore managed over the higher bandwidth storage interface channels of the host systems and without the generalized network protocols burdening the lock management process and the host system CPUs.

Abstract: A method and apparatus for transferring data from a first device to a second device connected by a controller having a parity buffer and a memory having a first storage and a second storage is disclosed. The method includes the steps of transferring first data from the first device to the first storage; transferring second data from the first device to the second storage; transferring the first data to the second device and storing the first data in the parity buffer; and determining parity data from the second data and the first data stored in the parity buffer.

Abstract: Methods and associated apparatus in a RAID storage subsystem to enhance the performance of write operations for sequences of large buffers generally non-aligned with stripe boundaries in the RAID storage subsystem. In particular, the methods identify a starting non-aligned portion of each large buffer to be written to the RAID storage subsystem, an ending non-aligned portion of each large buffer to be written to the RAID subsystem, and a larger middle portion of the large buffer to be written to the RAID subsystem which is aligned with stripe boundaries of the RAID storage subsystem. The stripe-aligned middle portion is written to the RAID storage devices in a cache write through mode using stripe write operations to maximize data throughput. The starting and ending portions identified by the methods of the present invention are written to the cache memory in a write back mode such that they will eventually be posted to the RAID storage devices in due course through normal RAID processing.