The SPs in a storage array are like independent computers that have access to some shared storage. Algorithms determine how concurrent access is handled.

For active/passive arrays, all the sectors on the storage that make up a given LUN can be accessed by only one SP at a time. The LUN ownership is passed around between the storage processors. The reason is that storage arrays use caches and SP A must not write anything to disk that invalidates the SP B cache. Because the SP has to flush the cache when it finishes the operation, it takes a little time to move the ownership. During that time, no I/O to the LUN can be processed by either SP.

Some active/passive arrays attempt to look like active/active arrays by passing the ownership of the LUN to the various SPs as I/O arrives. This approach works in a clustering setup, but if many ESX/ESXi systems access the same LUN concurrently through different SPs, the result is path thrashing.

Consider how path selection works:

On an active/active array the ESX/ESXi system starts sending I/O down the new path.

On an active/passive arrays, the ESX/ESXi system checks all standby paths. The SP of the path that is currently under consideration sends information to the system on whether it currently owns the LUN.

If the ESX/ESXi system finds an SP that owns the LUN, that path is selected and I/O is sent down that path.

If the ESX/ESXi host cannot find such a path, the ESX/ESXi host picks one of the standby paths and sends the SP of that path a command to move the LUN ownership to the SP.

Path thrashing can occur as a result of the following path choice: If server A can reach a LUN only through one SP, and server B can reach the same LUN only through a different SP, they both continually cause the ownership of the LUN to move between the two SPs, effectively ping-ponging the ownership of the LUN. Because the system moves the ownership quickly, the storage array cannot process any I/O (or can process only very little). As a result, any servers that depend on the LUN will experience low throughput due to the long time it takes to complete each I/O request.