Computer-Implemented Method, System, and Computer Program (I / O Operations in Log-Structured Arrays)

Abstract

To provide a method, a system and a computer program product for managing an input / output (I / O) operation in a log structured array (LSA).SOLUTION: A method receives a write request to a storage volume. The write request includes a data set. The method determines that a data set about a target range of the storage volume is not copied to a target position on the basis of a target map of a flash copy volume. It commands an LSA to execute internal copy-on-write (COW) to a data set during the next I / O operation to the storage volume. The method moves an internal pointer at the target position from a virtual volume to the flash copy volume on the basis of the internal COW command.SELECTED DRAWING: Figure 2

Description

[Technical Field]

[0001] The present disclosure generally relates to methods for managing I / O operations in an LSA environment, and further relates to an associated system for managing I / O operations in an LSA environment, and a computer program for operating such a system. [Background technology]

[0002] Some computing storage systems allow point-in-time data copy capabilities. These capabilities may be available at the block storage level. For example, a point-in-time data copy capability may involve creating a copy to create a full volume copy of the data within a given storage unit. The copy establishes a relationship between the source volume and the target volume. Summary of the Invention [Problem to be solved by the invention]

[0003] The established pair of volumes acts as a point-in-time copy, allowing read and write operations to both the source and target volumes. When a write is performed to the source volume, the data may be copied to the target location, potentially resulting in new data being written to the source volume. [Means for solving the problem]

[0004] According to one embodiment described herein, a computer-implemented method for managing input / output (I / O) operations in a log-structured array (LSA) is provided. The method receives a write request to a storage volume. The write request includes a set of data. The method determines, based on a target map in a flash copy volume, that the set of data for a target range in the storage volume is not to be copied to a target location. The method instructs the LSA to perform an internal copy-on-write (COW) on the set of data during a next IO operation to the storage volume. Based on the internal COW instruction, the method moves an internal pointer of the target location from the virtual volume to the flash copy volume.

[0005] According to one embodiment described herein, a system for managing input / output (I / O) operations in a log-structured array (LSA) is provided. The system includes one or more processors and a computer-readable storage medium coupled to the one or more processors, the computer-readable storage medium storing program instructions that, when executed by the one or more processors, cause the one or more processors to perform operations. The operations receive a write request to a storage volume. The write request includes a set of data. The operations determine, based on a target map in the flash copy volume, that the set of data for a target range in the storage volume is not to be copied to a target location. The operations instruct the LSA to perform an internal copy-on-write (COW) on the set of data during a next IO operation to the storage volume. Based on the internal COW instruction, the operations move an internal pointer of the target location from the virtual volume to the flash copy volume.

[0006] According to one embodiment described herein, a computer program product for managing input / output (I / O) operations in a log-structured array (LSA) is provided. The computer program product includes a computer-readable storage medium having program instructions embodied thereon, the program instructions being executable by one or more processors to cause the one or more processors to receive a write request to a storage volume. The write request includes a set of data. The computer program product determines, based on a target map of the flash copy volume, that the set of data for a target range of the storage volume is not to be copied to a target location. The computer program product instructs the LSA to perform an internal copy-on-write (COW) on the set of data during a next IO operation to the storage volume. Based on the internal COW instruction, the computer program product moves an internal pointer of the target location from the virtual volume to the flash copy volume. [Brief explanation of the drawings]

[0007] The drawings included in this application are incorporated into and form a part of this specification. They illustrate embodiments of the present disclosure and, together with the description, explain the principles of the disclosure. The drawings are merely illustrative of particular embodiments and do not limit the disclosure.

[0008] [Figure 1] 1 illustrates a block diagram of a computing environment for implementing concepts and computer-based methods according to at least one embodiment.

[0009] [Figure 2] 1 illustrates a flow diagram of a computer-implemented method for managing I / O operations in an LSA environment, according to at least one embodiment.

[0010] [Figure 3]1 illustrates a flow diagram of a computer-implemented method for managing I / O operations in an LSA environment, according to at least one embodiment.

[0011] [Figure 4] 1 illustrates a block diagram of a computing system for managing I / O operations in an LSA environment, according to at least one embodiment.

[0012] [Figure 5] FIG. 1 is a schematic diagram of a cloud computing environment in which the concepts of the present disclosure may be implemented, according to one embodiment of the present disclosure.

[0013] [Figure 6] FIG. 1 is a diagram of model layers of a cloud computing environment in which the concepts of the present disclosure may be implemented, according to one embodiment of the present disclosure. DETAILED DESCRIPTION OF THE INVENTION

[0014] The present disclosure relates generally to methods for managing I / O operations in an LSA environment. More specifically, but not exclusively, embodiments of the present disclosure relate to computer-implemented methods for managing I / O operations in an LSA during block data backup in a unified storage system. Additionally, the present disclosure relates to related systems for managing I / O operations in an LSA environment and computer program products for operating such systems.

[0015] Data storage systems and facilities are often built to quickly complete processing tasks and for a relatively large number of users. Some of these systems integrate databases, processing, and storage into a single, compact system. These systems may be configured for analytical processing or designed for flexible growth. When analyzing raw data, business intelligence applications leveraging these data storage systems may issue many read input / output (I / O) operations to gather data for processing. These applications may also send many write I / O operations to store intermediate data in temporary storage. These applications may utilize data storage system architectures with multiple hosts connected to multiple server blades connected to multiple disk enclosures. Multiple disks may be volumes exposed from the storage system or storage system architecture. Each disk may have multiple virtualized volumes. Virtualized volumes can be exposed, at least temporarily, to higher levels of the system and used to store data. A storage controller or storage controller cluster may enable storage disk virtualization. These storage control components can also enable storage-level backups and snapshots, flash copies, or point-in-time data copies of virtualized volumes. These point-in-time data copies can be performed at the block level and can be used for a variety of purposes.

[0016] When point-in-time copies are used with log-structured arrays, write operations performed on the point-in-time data copy can result in holes due to internal data movement creating invalid data locations. As holes accumulate, available storage can decrease. Garbage collection operations are used to remove holes from log-structured arrays. Garbage collection operations can be computationally intensive and can interrupt other operations.

[0017] Some data storage systems employ log-structured array (LSA) file systems. LSA systems can address the write performance issues of some data storage systems by buffering a series of file system changes. The changes can be buffered in a cache. After an appropriate number of changes, duration, or other threshold condition is met, the changes can be written sequentially from the cache to a given disk. Sequential writes can be performed in a single disk write operation. Changes written to disk can include file data blocks, attributes, index blocks, directories, or any other information that can be used to manage the file system.

[0018] Block storage systems can use a similar approach for log-structured block storage. In such systems, logical blocks can be defined for volumes. The logical blocks can point to actual logical block addresses (LBAs) on the disk. The logical volume LBAs of a block storage system (e.g., LBAs for virtual volumes on the disk) can be managed as a log-structured array for managing write operations to the storage system. Each host write operation can be saved to a new logical LBA location where a data pointer is located. In such a system, write I / O operations and seek times to the physical LBAs on the storage system can be eliminated for each write operation. For example, a block storage system can create volumes from a block storage pool. The volumes can be exposed to host applications to perform I / O operations on the disk. A volume can have a logical LBA associated with it that internally points to a physical LBA location based on the mapping policy of the storage controller architecture for the block storage system. In this way, a block storage system can have a storage pool-level log-structured implementation. Additionally, a block storage system may have one location as a pointer to a circular buffer location. When a host issues a write I / O to a volume, the data can be written to the latest pointer location in the LSA, and the pointer can be moved to the next logical location.

[0019] Writing data to the circular buffer thus creates an invalid location in the storage controller's LSA each time the pointer moves to the next location. Invalid data locations can become holes in the LSA. To clear the buffer space, the holes undergo garbage collection operations. The garbage collection process frees up physical volume LBAs in the LSA, but the operation is computationally intensive and causes a pause in normal I / O activity. Garbage collection operations can be triggered when a threshold number of logical blocks are occupied in the LSA or when the number of holes increases beyond a specified threshold. During a garbage collection operation, logical and physical LBA addresses can be modified so that their locations in the logical LBA map become contiguous. The LSA pointer can be updated so that additional freed logical LBA locations can become available to the LSA or storage controller. The impact of garbage collection operations on the storage system increases as garbage collection operations are used or become more frequent.

[0020] Block storage systems can create full-volume copies of data within a storage unit using point-in-time data copy features such as flash copy. Flash copy creates a relationship between the source volume and the target volume. The flash copy operation also creates a bitmap of the source volume. Once the relationship and bitmap are created, the target volume can be accessed as if the data had been physically copied. Similarly, a background process can copy tracks from the source volume to the target volume. The target, or copy created by the flash copy operation, creates a point-in-time copy of the source volume, and both the source and target volumes are capable of receiving read and write operations. In some cases, the target volume can be created as a flash copy when new data is to be written to the source volume. In such cases, data from the source volume at time T can be copied to the target location as T0 data. Data to be written to the source volume can be written as T1 data. Writing the T1 data can update the bitmap for selected I / O locations. In this way, an instant copy of the volume is created while copying the actual data when a write is issued to the source disk, which can be understood as a copy-on-write (COW) operation.

[0021] In log-structured arrays, storage-based snapshots can be configured in storage virtualization using a COW operation. When a write I / O operation is sent to the storage system, the logical volume-level LBA location is identified within the virtualization map. Existing flash copy relationships can be analyzed, and data movement decisions can be made by the virtualization engine or storage controller. When a write I / O operation is received by the source volume and no previous flash copy has been established, the data is moved to the target disk. The host I / O operation can then be written to the source disk. In this case, one internal I / O operation is generated from the move from the source volume to the target volume, which increments the LSA pointer by one. The internal I / O operation also creates a hole in the LSA. When the operation is complete, the host write operation is saved at the most recent LSA pointer location. This internal move results in a hole in the LSA. If the source disk is write-oriented, the number of holes in the LSA may increase, triggering a garbage collection operation. Repeated garbage collection operations can cause performance issues and delays in the host application while the garbage collection operations are being processed.

[0022] Embodiments of the present disclosure enable efficient handling of COW data and operations in LSA and similar implementations of storage systems. Some embodiments of the present disclosure enable a storage system to avoid holes or empty space in the log storage array or volume of the storage system. The present disclosure can reduce or eliminate empty space in log-structured arrays by enabling data movement from write operations in layers. In some embodiments, the present disclosure enables differentiation between internal data movement and host application write operations. Some embodiments of the present disclosure enable a mechanism for the LSA algorithm to distinguish between COW movement and write I / O operations to improve performance and data management efficiency within the storage system. In some embodiments, the present disclosure presents methods and systems that enable operation of a log-structured array and a flash copy service module in a storage management system. Embodiments of the present disclosure can provide information to the storage system regarding flash copy COW operations and internal movement of data blocks during COW operations. In some embodiments, the present disclosure enables communication between two models in a storage management system for inbound and outbound API implementations, enabling command exchange between functional modules of the storage system.

[0023] Some embodiments of the concepts described herein may take the form of a system or computer program product. For example, a computer program product may store program instructions that, when executed by one or more processors of a computing system, cause the computing system to perform the operations described above for the computer-implemented methods. As a further example, a system may include components such as a processor and a computer-readable storage medium. The computer-readable storage medium interacts with other components of the system to cause the system to execute program instructions, including the operations of the computer-implemented methods described herein. As used herein, a computer-usable or computer-readable medium may be any apparatus capable of containing means for storing, communicating, propagating, or transporting a program for use by or in connection with an instruction execution system, apparatus, or device.

[0024] Referring now to FIG. 1 , a block diagram of an example computing environment 100 is shown. The present disclosure may be implemented within the example computing environment 100. In some embodiments, the computing environment 100 may be included within or embodied by a computer system, as described below. The computing environment 100 may include a storage management system 102. The storage management system 102 may comprise a storage controller 110, a flash copy manager 120, and an array component 130. The storage controller 110 receives requests for one or more storage volumes and coordinates operations on disks associated with the storage management system 102. The flash copy manager 120 performs operations on virtual storage volumes on disks associated with the storage management system 102. The array component 130 performs operations on a log-structured array of disks associated with the storage management system 102. While described with separate components, it should be understood that in at least some embodiments, components may be combined or divided, or additional components may be added, or both, without departing from the scope of the present disclosure.

[0025] 2, a flow diagram of a computer-implemented method 200 is shown. The computer-implemented method 200 is a method for managing I / O operations in an LSA environment. In some embodiments, the computer-implemented method 200 may be performed by one or more components of the computing environment 100, as described in more detail below.

[0026] In operation 210, storage controller 110 receives a write request to a storage volume. In some embodiments, the write request includes a set of data. The storage volume may be an individual storage volume within a plurality of storage volumes accessible to or managed by storage management system 102. The write request may be received from a host that interacts with a set of disks or a storage system coupled to storage management system 102. In some embodiments, the host may be a user-operated computing device that interacts with a storage system or set of disks remote from the host. For example, the host may transmit the write request over a communications network to storage controller 110. Storage controller 110 may receive the write request and process and implement the write request to a volume within the cloud-based storage system.

[0027] In operation 220, flash copy manager 120 determines the copy-on-write (COW) status for the storage volume targeted by the write request. In some embodiments, flash copy manager 120 determines the COW status by identifying that the storage volume has COW functionality enabled in the storage system. The flash copy manager may determine the COW status of a storage volume based on one or more configuration files for the storage volume, the disk that houses the storage volume, or the storage system of which the storage volume or disk is a part.

[0028] In operation 230, flash copy manager 120 determines that a set of data for a target range of a storage volume will not be copied to a target location. Flash copy manager 120 can determine that a set of data will not be copied based on a target map of the flash copy volume. The target map can indicate data stored within a specified data location of the target volume. In some instances, the target map represents data within a flash copy of a volume (e.g., a source volume) at a given time. For example, the target volume may be the target volume at time T0.

[0029] In some embodiments, the flash copy manager 120 communicates with the array component 130 using an out-of-band protocol. The flash copy manager 120 can communicate with the array component 130 using a reserved field in a write command description block (CBD), such as a Small Computer System Interface (SCSI) CBD. A SCSI CBD can be a block of information that describes a command. Each CBD can be 6, 10, 12, or 16 bytes in total, or any suitable variable length. In some cases, the flash copy manager 120 and the array component 130 communicate as layers within the storage management system 102 using both an out-of-band protocol and a reserved field in the CBD. The flash copy manager 120 and the array component 130 pass information between layers or any other suitable independent mechanism. In some embodiments, a heat map can be communicated from one storage system to another. The heat map can be communicated to ensure that a remote copy maintains designated data within a given storage volume, disk, or SSD, allowing for failover access to a remote location.

[0030] In operation 240, the array component 130 instructs a log-structured array (LSA) to perform an internal COW operation. The internal COW operation can be performed on a set of data during the next input / output (I / O) operation to the storage volume. In some embodiments, the flash copy manager 120 transmits the instruction to a storage pool configured as an LSA. The instruction indicates that the next I / O operation will be an internal COW operation. The internal COW operation can write the set of data for the write request to a virtual volume (e.g., a source volume). The internal COW operation can also generate a copy of the virtual volume as a flash copy volume (e.g., a target volume) before writing the set of data. The instruction can indicate that the internal COW operation will be followed by an actual application host write I / O operation.

[0031] In operation 250, the storage controller 110 moves an internal pointer of the target location from the virtual volume to the flash copy volume. In some embodiments, the internal pointer moves based on an internal COW command. In such cases, the internal COW command is treated as a signal to a hole prevention device within the storage controller 110 to move the internal pointer. In embodiments in which a set of data is written to a source volume and the target volume is created as a flash copy, the internal pointer of the target location moves from a location in the source volume to a location in the target volume. Moving the internal pointer of the target location to the target volume or flash copy volume prevents a hole from occurring in the LSA due to the set of data for the write request being written to the virtual volume or source volume. Once the flash copy volume is established and the internal pointer is moved, the older version of the data in the LSA associated with the write request becomes associated with a pointer pointing to the flash copy volume that points to the older source logical LBA.

[0032] In operation 260, array component 130 updates the LSA bitmap. In some embodiments, the bitmap is updated in response to changes to internal pointers. If the internal pointers move, the LSA bitmap can be updated by array component 130, which can send instructions to flash copy manager 120 to reconcile the volume copies between the flash-copied volumes. Once the bitmap update is complete and the volume copies are reconciled, the host application can proceed as normal, incrementing the LSA pointer and saving the data to the next location in the circular buffer. In such a case, a new pointer for the set of data in the write request can link the virtual volume or source volume to the set of data at its new location in the LSA.

[0033] In the case of COW operations, internal pointers are moved and new pointers are generated, eliminating the need for an actual data copy to the physical disk. Creating a flash copy, using COW, and moving pointers reduces I / O movement to the physical location. Reducing I / O movement can reduce the computational time and resources required to functionally execute a write request. Limiting I / O movement can improve the performance of the associated storage system. Additionally, using COW and moving pointers minimizes holes in the log-structured array, thereby reducing the frequency of garbage collection operations in the LSA. Reducing the frequency of garbage collection operations can also improve the health and lifespan of SSD disks.

[0034] 3 illustrates a flow diagram of one embodiment of a computer-implemented method 300 for managing I / O operations in an LSA environment. Method 300 may be performed by or within computing environment 100. In some embodiments, method 300 includes or incorporates one or more operations of method 200.

[0035] In operation 310, storage controller 110 discovers a virtual volume for a storage volume associated with the write request. The virtual volume may be discovered in response to storage controller 110 receiving a write request containing a set of data to be written to the storage volume. In some embodiments, storage controller 110 discovers the virtual volume in cooperation with flash copy manager 120. The virtual volume may be a buffer or cache for a physical volume (e.g., a storage volume) for data storage.

[0036] In operation 320, storage controller 110 detects a flash copy volume for the storage volume. The flash copy may be a point-in-time copy of the virtual storage volume. In some embodiments, the flash copy volume is a previously generated copy of the virtual volume. The flash copy volume may contain a complete copy of the data in the virtual volume at a specified time. The specified time may be any time before the receipt of the write request. If a flash copy volume is not detected, flash copy manager 120 may be instructed to generate a flash copy of the virtual volume when storage controller 110 detects the virtual volume or when the write request is received. In some cases, the flash copy volume is detected or generated in response to one or more of operations 220 and 230.

[0037] In operation 330, array component 130 overwrites the set of data to the virtual volume. In some embodiments, the set of data replaces a previous set of values ​​in the virtual volume. In some cases, array component 130 overwrites the set of data in the virtual volume by inserting the set of data into the logical LBA map of the virtual volume.

[0038] In operation 340, storage controller 110 moves a first internal pointer of the target location from the virtual volume to the flash copy volume. In some embodiments, the first internal pointer is moved based on an internal COW instruction. The first internal pointer can be moved in a similar or identical manner as described with respect to operation 250.

[0039] In operation 350, storage controller 110 generates a second internal pointer to the set of data in the virtual volume. In some embodiments, the second internal pointer is generated to point from the set of data in the virtual volume to a location in a physical volume logical block address (LBA) map for the storage volume.

[0040] In operation 360, storage controller 110 triggers a bitmap update to the physical volume LBA map in the LSA. In some embodiments, the bitmap update is triggered based on moving a first internal pointer and generating a second internal pointer.

[0041] Embodiments of the present disclosure can be implemented with virtually any type of computer, regardless of whether the platform is suitable for storing and / or executing program code. Figure 4 illustrates an example computing system 400 (e.g., a cloud computing system) suitable for executing program code related to the methods disclosed herein and for managing I / O operations in an LSA environment.

[0042] Computing system 400 is merely one example of a suitable computer system, and whether or not computer system 400 is capable of implementing and / or performing any of the functions described above is not intended to suggest any limitation as to the scope of use or functionality of the embodiments of the present disclosure described herein. Computer system 400 has components that operate in numerous other general-purpose or special-purpose computing system environments or configurations. Examples of well-known computing systems, environments, or configurations, or combinations thereof, that may be suitable for use with computer system / server 400 include, but are not limited to, personal computer systems, server computer systems, thin clients, thick clients, handheld or laptop devices, multiprocessor systems, microprocessor-based systems, set-top boxes, programmable consumer electronics, network PCs, minicomputer systems, mainframe computer systems, and distributed cloud computing environments that include any of the above systems or devices. Computer system / server 400 may be described in the general context of computer system-executable instructions, such as program modules, executed by computer system 400. Generally, program modules may include routines, programs, objects, components, logic, data structures, etc. that perform particular tasks or implement particular abstract data types. Computer system / server 400 may be practiced in distributed cloud computing environments where tasks are performed by remote processing devices linked through a communications network. In a distributed cloud computing environment, program modules may be located in both local and remote computer system storage media, including memory storage devices.

[0043] As shown, a computer system / server 400 in the form of a general-purpose computing device is shown. Components of the computer system / server 400 may include, but are not limited to, one or more processors 402 (e.g., processing units), a system memory 404 (e.g., a computer-readable storage medium coupled to the one or more processors), and a bus 406 that couples various system components, including the system memory 404, to the processor 402. The bus 406 may represent any one or more of several types of bus structures, including a memory bus or memory controller, a peripheral bus, an accelerated graphics port, and a processor or local bus using any of a variety of bus architectures. By way of example and without limitation, such architectures include an Industry Standard Architecture (ISA) bus, a Micro Channel Architecture (MCA) bus, an Enhanced ISA (EISA) bus, a Video Electronics Standards Association (VESA) local bus, and a Peripheral Component Interconnect (PCI) bus. Computer system / server 400 typically includes a variety of computer system-readable media, which may be any available media that can be accessed by computer system / server 400 and includes both volatile and nonvolatile media, and removable and non-removable media.

[0044] System memory 404 may include computer-readable media in the form of volatile memory, such as random access memory (RAM) 408 and / or cache memory 410. Computer system / server 400 may further include other removable / non-removable, volatile / non-volatile computer-system storage media. By way of example only, storage system 412 may be provided for reading from and writing to non-removable, non-volatile magnetic media (not shown, and typically referred to as a "hard drive"). Although not shown, a magnetic disk drive may be provided for reading from and writing to removable, non-volatile magnetic disks (e.g., "floppy disks"), and an optical disk drive may be provided for reading from and writing to removable, non-volatile optical disks, such as CD-ROMs, DVD-ROMs, or other optical media. In such cases, each may be connected to bus 406 by one or more data media interfaces. As further depicted and described below, the system memory 404 may include at least one program product having a set (e.g., at least one) of program modules configured to perform the functions of embodiments of the present disclosure.

[0045] By way of example and without limitation, an operating system, one or more application programs, other program modules, and program data, as well as a program / utility having a set (at least one) of program modules 416, may be stored in system memory 404. The program modules may include one or more of storage controller 110, flash copy manager 120, and array component 130 shown in FIG. 1. Each of the operating system, one or more application programs, other program modules, and program data, or some combination thereof, may include an implementation of a networking environment. The program modules 416 generally perform the functions and / or methodologies of embodiments of the present disclosure, as described herein.

[0046] Additionally, computer system / server 400 may communicate with one or more external devices 418, such as a keyboard, pointing device, display 420, etc., one or more devices that allow a user to interact with computer system / server 400, or any device (e.g., network card, modem, etc.) that allows computer system / server 400 to communicate with one or more other computing devices, or a combination thereof. Such communication may occur via input / output (I / O) interface 414. Furthermore, computer system / server 400 may communicate with one or more networks, such as a local area network (LAN), a general wide area network (WAN), or a public network (e.g., the Internet), or a combination thereof, via network adapter 422. As depicted, network adapter 422 may communicate with other components of computer system / server 400 via bus 406. While not shown, it should be understood that other hardware and / or software components may be used in conjunction with computer system / server 400. Examples include, but are not limited to, microcode, device drivers, redundant processing units, external disk drive arrays, RAID systems, tape drives, and data archive storage systems.

[0047] Although this disclosure includes detailed descriptions of cloud computing, it should be understood that implementation of the teachings described herein is not limited to cloud computing environments. Rather, embodiments of the present disclosure may be implemented with any other type of computing environment now known or later developed.

[0048] Cloud computing is a service delivery model that enables convenient, on-demand network access to a shared pool of configurable computing resources (e.g., networks, network bandwidth, servers, processing, memory, storage, applications, virtual machines, and services) that can be rapidly provisioned and released with minimal management effort or interaction with the service provider. This cloud model can include at least five characteristics, at least three service models, and at least four deployment models.

[0049] Service models can include Software as a Service (SaaS), Platform as a Service (PaaS), and Infrastructure as a Service (IaaS). In SaaS, the consumer's ability is to use the provider's applications running on a cloud infrastructure. The applications are accessible from a variety of client devices through thin-client interfaces such as web browsers (e.g., web-based email). The consumer does not manage or control the underlying cloud infrastructure, including the network, servers, operating systems, storage, or possibly individual application capabilities, with the possible exception of limited user-specific application configuration settings. In PaaS, the consumer's ability is to deploy applications they create or acquire, written using programming languages ​​and tools supported by the provider, onto the cloud infrastructure. The consumer does not manage or control the underlying cloud infrastructure, including the network, servers, operating systems, or storage, but does have control over the deployed applications and, in some cases, the configuration of the environment hosting the applications. In IaaS, the customer is provided with the ability to provision processing, storage, network, and other basic computing resources onto which the customer can deploy and run any software, which may include operating systems and applications. The customer does not manage or control the underlying cloud infrastructure, but does have control over the selection of operating systems, storage, deployed applications, and in some cases, limited control over networking components (e.g., host firewalls).

[0050] Deployment models can include private clouds, community clouds, public clouds, and hybrid clouds. In a private cloud, the cloud infrastructure is operated solely for the organization. It may be managed by the organization or a third party and may reside on-site or off-site. In a community cloud, the cloud infrastructure is shared by several organizations to support a unique community of shared concerns (e.g., mission, security requirements, policies, and compliance considerations). The cloud infrastructure may be managed by the organization or a third party, which may reside on-site or off-site. In a public cloud, the cloud infrastructure is made available to the general public or large industry groups and is owned by the organization that sells cloud services. In a hybrid cloud, the cloud infrastructure remains a unique entity but is a structure of two or more clouds (private, community, or public) tied together by standard or proprietary technologies that enable data and application portability (e.g., cloud bursting for load balancing between clouds).

[0051] Cloud computing environments are service-oriented, with a focus on statelessness, loosely coupled modularity, and semantic interoperability. At the heart of cloud computing is an infrastructure that includes a network of interconnected nodes.

[0052] Referring now to FIG. 5, an exemplary cloud computing environment 50 is depicted. As shown, the cloud computing environment 50 includes one or more cloud computing nodes 10 with which local computing devices used by cloud users, such as, for example, a personal digital assistant (PDA) or cellular phone 54A, a desktop computer 54B, a laptop computer 54C, or an automobile computer system 54N, or any combination thereof, can communicate. The nodes 10 can communicate with each other. The nodes 10 can be physically or virtually grouped in one or more networks (not shown), such as private, community, public, or hybrid clouds, or any combination thereof, as described above. This enables the cloud computing environment 50 to provide infrastructure, platform, or software as a service, or any combination thereof, without the cloud user having to maintain resources on the local computing device. It is understood that the types of computing devices 54A-54N shown in FIG. 5 are intended to be illustrative only, and that computing node 10 and cloud computing environment 50 can communicate with any type of computerized device over any type of network and / or network-addressable connection (e.g., using a web browser).

[0053] Referring now to Figure 6, a set of functional abstraction layers provided by cloud computing environment 50 (Figure 5) is shown. It should be understood in advance that the components, layers, and functions shown in Figure 6 are intended to be illustrative only, and embodiments of the present disclosure are not limited thereto. As depicted, the following layers and corresponding functions are provided:

[0054] Hardware and software layer 60 includes hardware and software components. Examples of hardware components include mainframe 61, RISC (reduced instruction set computer) architecture-based servers 62, servers 63, blade servers 64, storage devices 65, and network and networking components 66. In some embodiments, software components include network application server software 67 and database software 68.

[0055] The virtualization layer 70 provides an abstraction layer that can provide examples of virtual entities: virtual servers 71, virtual storage 72, virtual networks including virtual private networks 73, virtual applications and operating systems 74, and virtual clients 75.

[0056] In one example, the management layer 80 may provide the following functions: Resource provisioning 81 dynamically procures computing and other resources utilized to execute tasks within the cloud computing environment. Metering and pricing 82 tracks costs as resources are utilized within the cloud computing environment and bills or invoices for the utilization of these resources. In one example, these resources may include application software licenses. Security verifies the identity of cloud users and tasks and protects data and other resources. User portal 83 provides users and system administrators with access to the cloud computing environment. Service level management 84 allocates and manages cloud computing resources to meet required service levels. Service level agreement (SLA) planning and fulfillment 85 pre-provisions and procures cloud computing resources in anticipation of future requirements according to SLAs.

[0057] The workload tier 90 provides examples of functions that can utilize a cloud computing environment. Examples of workloads and functions that can be provided from this tier include mapping and navigation 91, software development and lifecycle management 92, virtual classroom education delivery 93, data analytics processing 94, transaction processing 95, and storage management processing 96.

[0058] Cloud models can include characteristics such as on-demand self-service, broad network access, resource pooling, rapid elasticity, and metered service. With on-demand self-service, cloud consumers can unilaterally provision computing capacity, such as server time and network storage, automatically as needed, without requiring human interaction with the service provider. With broad network access, capacity is available over the network and accessed through standard mechanisms that facilitate use by heterogeneous thin or thick client platforms (e.g., mobile phones, laptops, and PDAs). With resource pooling, provider computing resources are pooled to serve multiple consumers using a multi-tenant model, with various physical and virtual resources dynamically allocated and reallocated according to demand. Consumers generally have no control or knowledge of the exact location of the resources provided, but they experience a sense of location independence in that they may be able to specify location at a higher level of abstraction (e.g., country, state, or data center). With rapid elasticity, capacity can be rapidly and elastically provisioned, sometimes automatically, to quickly scale out and rapidly released to quickly scale in. To the consumer, the capacity available for provisioning often appears unlimited and can be purchased in any quantity at any time. With metered services, cloud systems automatically control and optimize resource usage by leveraging metering capabilities at some level of abstraction appropriate to the type of service (e.g., storage, processing, bandwidth, and active user accounts). Resource utilization can be monitored, controlled, and reported, bringing transparency to both the provider and consumer of the services being used.

[0059] The description of various embodiments of the present disclosure has been presented for purposes of illustration, but is not intended to be exhaustive or to be limited to the disclosed embodiments. Many modifications and variations will be apparent to those skilled in the art without departing from the scope and spirit of the described embodiments. The terminology used herein has been chosen to best explain the principles, practical applications, or technical improvements of the embodiments over those found in the marketplace, or to enable others skilled in the art to understand the embodiments disclosed herein.

[0060] The present invention may be embodied as a system, method, or computer program product, or a combination thereof, and may include a computer-readable storage medium (or multiple computer-readable storage media) having computer-readable program instructions for causing a processor to perform aspects of the present invention.

[0061] The computer-readable storage medium may be an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system for a propagation medium. Examples of computer-readable media include semiconductor or solid-state memory, magnetic tape, removable computer diskettes, random access memory (RAM), read-only memory (ROM), fixed magnetic disks, and optical disks. Current examples of optical disks include compact disk-read-only memory (CD-ROM), compact disk-read / write (CD-R / W), DVD, and Blu-ray disk.

[0062] A computer-readable storage medium can be a tangible device that can hold and store instructions for use by an instruction-execution device. A computer-readable storage medium may be, for example, but not limited to, an electronic storage device, a magnetic storage device, an optical storage device, an electromagnetic storage device, a semiconductor storage device, or any suitable combination of the foregoing. A non-exhaustive list of more specific examples of computer-readable storage media includes portable computer diskettes, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), static random access memory (SRAM), portable compact disc read-only memory (CD-ROM), digital versatile disks (DVDs), memory sticks, floppy disks, mechanically encoded devices such as punch cards or ridge-in-groove structures with instructions recorded on them, and any suitable combination of the foregoing. Computer-readable storage media, as used herein, should not be construed as signals that are ephemeral in nature, such as radio waves or other freely propagating electromagnetic waves, electromagnetic waves propagating through a waveguide or other transmission medium (e.g., light pulses passing through fiber optic cable), or electrical signals transmitted through wires.

[0063] The computer-readable program instructions described herein can be downloaded from a computer-readable storage medium to each computing / processing device or to an external computer or storage device over a network, such as the Internet, a local area network, a wide area network, or a wireless network, or a combination thereof. The network can include copper transmission cables, fiber optic transmission cables, wireless transmission cables, routers, firewalls, switches, gateway computers, or edge servers, or a combination thereof. A network adapter card or network interface within each computing / processing device receives the computer-readable program instructions from the network and forwards the computer-readable program instructions to a computer-readable storage medium within the respective computing / processing device for storage.

[0064] Computer-readable program instructions for carrying out the operations of the present invention may be source or object code written in any combination of one or more programming languages, including assembler instructions, instruction set architecture (ISA) instructions, machine instructions, machine-dependent instructions, microcode, firmware instructions, state-setting data, or object code written in any combination of one or more programming languages, including object-oriented programming languages ​​such as Smalltalk®, C++, etc., and conventional procedural programming languages ​​such as the “C” programming language or similar programming languages. The computer-readable program instructions may execute entirely on the user's computer, partially on the user's computer as a stand-alone software package, partially on the user's computer and partially on a remote computer, or entirely on a remote computer or server. In the latter scenario, the remote computer may be connected to the user's computer through any type of network, including a local area network (LAN) or a wide area network (WAN), or the connection may be to an external computer (e.g., through the Internet using an Internet Service Provider). In some embodiments, electronic circuitry devices, including, for example, programmable logic devices, field programmable gate arrays (FPGAs), or programmable logic arrays (PLAs), can execute computer readable program instructions by utilizing state information of the computer readable program instructions to personalize the electronic circuitry to perform aspects of the present invention.

[0065] Aspects of the present invention are described herein with reference to flowchart and / or block diagrams of methods, apparatus (systems) and computer program products according to embodiments of the invention. It will be understood that each block of the flowchart and / or block diagrams, and combinations of blocks in the flowchart and / or block diagrams, can be implemented by computer-readable program instructions.

[0066] These computer-readable program instructions may be provided to a processor of a general-purpose computer, special-purpose computer, or other programmable data processing apparatus to produce a machine, the instructions of which execute on the processor of the computer or other programmable data processing apparatus to generate means for implementing the functions / acts specified in one or more blocks of the flowcharts and / or block diagrams. These computer-readable program instructions may be stored on a computer-readable storage medium that can instruct a computer, programmable data processing apparatus, or other device, or combination thereof, to function in a particular manner, such that the computer-readable storage medium having the instructions stored thereon comprises an article of manufacture including instructions that implement aspects of the functions / acts specified in one or more blocks of the flowcharts and / or block diagrams.

[0067] The computer-readable program instructions may be loaded into a computer, other programmable data processing apparatus, or another device to cause a series of operational steps to be performed on the computer, other programmable apparatus, or other device to generate a computer-implemented process, such that the instructions executing on the computer, other programmable apparatus, or other device implement the functions / acts specified in one or more blocks of the flowchart and / or block diagram.

[0068] The flowcharts and / or block diagrams in the figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments of the present invention. In this regard, each block in the flowcharts or block diagrams may represent a module, segment, or portion of instructions, including one or more executable instructions for implementing a specified logical function. In some alternative implementations, the functions noted in the blocks may occur out of the order noted in the figures. For example, two blocks shown in succession may, in fact, be executed substantially concurrently, depending on the functionality involved, or the blocks may sometimes be executed in the reverse order. It should also be noted that each block of the block diagrams and / or flowcharts, and combinations of blocks in the block diagrams and / or flowcharts, can be implemented by a dedicated hardware-based system that performs the specified function or operation or executes a combination of dedicated hardware and computer instructions.

[0069] The terminology used herein is for the purpose of describing particular embodiments only and is not intended to be limiting of the disclosure. As used herein, the singular forms "a," "an," and "the" are intended to include the plural forms as well, unless the context clearly dictates otherwise. It will be further understood that the terms "comprise" and / or "comprising," when used herein, specify the presence of stated features, integers, steps, operations, elements, or components, or combinations thereof, but do not exclude the presence or addition of one or more other features, integers, steps, operations, elements, components, or groups thereof, or combinations thereof.

[0070] In addition to the functional elements in the following claims, the corresponding structure, material, acts, and equivalents of all means or steps are intended to include any structure, material, or acts for performing a function in combination with other claimed elements as specifically claimed. The description of the present disclosure has been presented for purposes of illustration and description, but is not intended to be exhaustive or to limit the disclosure to the form disclosed. Many modifications and variations will be apparent to those skilled in the art without departing from the scope of the present disclosure. The embodiments have been chosen and described in order to explain the principles and practical application of the disclosure and to enable others skilled in the art to understand the disclosure in various embodiments with various modifications as suited to the particular uses envisioned.

[0071] The description of various embodiments of the present disclosure has been presented for purposes of illustration and is not intended to be exhaustive or to be limited to the disclosed embodiments. Many modifications and variations will be apparent to those skilled in the art without departing from the scope and spirit of the described embodiments. The terminology used herein has been chosen to explain the principles of the embodiments, their practical applications, or technical improvements over technology found in the market, or to enable others skilled in the art to understand the embodiments disclosed herein. 100 Computing Environments 102 Storage Management System 110 Storage Controller 120 Flash Copy Manager 130 Array Components 400 Computing Systems, Computer Systems, Computer Systems / Servers 402 processor 404 System Memory 406 Bus 408 Random Access Memory (RAM) 410 Cache Memory 412 Storage System 414 Input / Output (I / O) Interface 416 program modules 418 External Devices 420 Display 422 Network Adapter 10 cloud computing nodes, nodes, computing nodes 50 Cloud Computing Environments 54A Personal Digital Assistants (PDAs), Cellular Phones 54B Desktop Computer 54C Laptop Computer 54N Automotive Computer System 60 Hardware and Software Layers 61 Mainframe 62 RISC (Reduced Instruction Set Computer) architecture-based servers 63 servers 64 Blade Servers 65 Storage Devices 66 Networks and Networking Components 67 Network Application Server Software 68 Database Software 70 Virtualization Layer 71 Virtual Servers 72 Virtual Storage 73 Virtual Networks 74 Operating System 75 Virtual Clients 80 Management layer 81 Resource Provisioning 82 Metering and Pricing 83 User Portal 84 Service Level Management 85 Service Level Agreement (SLA) Planning and Fulfillment 90 Workload Tier 91 Mapping and Navigation 92 Software Development and Lifecycle Management 93 Virtual Classroom Educational Delivery 94 Data Analysis Processing 95 Transaction Processing 96 Storage Management Processing

Claims

1. 1. A computer-implemented method comprising: receiving, by a storage controller, a write request for a storage volume, the write request including a set of data; determining that the set of data for a target range of the storage volume has not been copied to a target location based on a target map of a flash copy volume, the flash copy volume being a copy of a virtual volume associated with the write request to the storage volume, and the target map indicating data stored within a specified data location of the flash copy volume; instructing a log-structured array (LSA) to perform an internal copy-on-write (COW) on the set of data during a next input / output (I / O) operation to the storage volume; moving an internal pointer of the target location from the virtual volume to the flash copy volume based on the internal COW; A computer-implemented method, including:

2. updating a bitmap of the LSA in response to the movement of the internal pointer. Further provided with The method of claim 1.

3. determining a COW status for the storage volume targeted by the write request; The method of claim 1 or 2, further comprising:

4. detecting the virtual volume for the storage volume; detecting the flash copy volume for the storage volume; The method of claim 1 , further comprising:

5. overwriting the virtual volume with the set of data, the set of data replacing a previous set of values ​​in the virtual volume; The method of claim 4 further comprising:

6. the internal pointer is a first internal pointer, and the method comprises: generating a second internal pointer for the set of data in the virtual volume to a location in a physical volume logical block address (LBA) map for the storage volume; The method of claim 5 further comprising:

7. triggering a bitmap update to the physical volume LBA map in the LSA based on the steps of moving the first internal pointer and generating the second internal pointer. The method of claim 6 further comprising:

8. 1. A system comprising: one or more processors; A computer-readable storage medium coupled to the one or more processors that, when executed by the one or more processors, receiving, by a storage controller, a write request for a storage volume, the write request including a set of data; determining that the set of data for a target range of the storage volume has not been copied to a target location based on a target map of a flash copy volume, the flash copy volume being a copy of a virtual volume of the storage volume associated with the write request, and the target map indicating data stored within a specified data location of the flash copy volume; instructing a log-structured array (LSA) to perform an internal copy-on-write (COW) on the set of data during a next input / output (I / O) operation to the storage volume; moving an internal pointer of the target location from the virtual volume to the flash copy volume based on the internal COW; a computer-readable storage medium storing program instructions that cause the one or more processors to perform operations including: A system comprising:

9. The operation is updating a bitmap of the LSA in response to the movement of the internal pointer. further comprising: The system of claim 8.

10. The operation is determining a COW status for the storage volume targeted by the write request; further comprising:

10. The system according to claim 8 or 9.

11. The operation is detecting the virtual volume for the storage volume; detecting the flash copy volume for the storage volume; further comprising: A system according to any one of claims 8 to 10.

12. The operation is overwriting the virtual volume with the set of data, the set of data replacing a previous set of values ​​in the virtual volume; further comprising: The system of claim 11.

13. The internal pointer is a first internal pointer, and the operation is generating a second internal pointer for the set of data in the virtual volume to a location in a physical volume logical block address (LBA) map for the storage volume; further comprising: The system of claim 12.

14. The operation is triggering a bitmap update to the physical volume LBA map in the LSA based on moving the first internal pointer and generating the second internal pointer; further comprising: The system of claim 13.

15. The processor receiving, by a storage controller, a write request for a storage volume, the write request including a set of data; determining that the set of data for a target range of the storage volume has not been copied to a target location based on a target map of a flash copy volume, the flash copy volume being a copy of a virtual volume of the storage volume associated with the write request, and the target map indicating data stored within a specified data location of the flash copy volume; instructing a log-structured array (LSA) to perform an internal copy-on-write (COW) on the set of data during a next input / output (I / O) operation to the storage volume; moving the internal pointer of the target location from the virtual volume to the flash copy volume based on the internal COW; A computer program for executing the above.

16. the processor, updating a bitmap of said LSA in response to said movement of said internal pointer. Further execute 16. A computer program product according to claim 15.

17. the processor, determining a COW status for the storage volume targeted by the write request; Further execute 17. A computer program according to claim 15 or 16.

18. the processor, detecting the virtual volume for the storage volume; detecting the flash copy volume for the storage volume; Further execute 18. A computer program according to any one of claims 15 to 17.

19. the processor, overwriting the set of data in the virtual volume, the set of data replacing a previous set of values ​​in the virtual volume; Further execute 20. The computer program of claim 18.

20. the internal pointer is a first internal pointer, and the processor generating a second internal pointer for the set of data in the virtual volume to a location in a physical volume logical block address (LBA) map for the storage volume; triggering a bitmap update to the physical volume LBA map in the LSA based on moving the first internal pointer and generating the second internal pointer; Further execute 20. The computer program product of claim 19.

Images