Patent Publication Number: US-11640244-B2

Title: Intelligent block deallocation verification

Description:
CROSS REFERENCE TO RELATED APPLICATIONS 
     This application is a continuation of U.S. application Ser. No. 16/655,792, filed on Oct. 17, 2019, which is a continuation of U.S. application Ser. No. 15/337,151, filed on Oct. 28, 2016, the entire contents of which are incorporated by reference herein. 
    
    
     BACKGROUND 
     As computer memory storage and data bandwidth increase, so does the amount and complexity of data that businesses manage daily. Large-scale distributed storage systems, such as data centers, typically run many business operations. A datacenter, which also may be referred to as a server room, is a centralized repository, either physical or virtual, for the storage, management, and dissemination of data pertaining to one or more businesses. A distributed storage system may be coupled to client computers interconnected by one or more networks. If any portion of the distributed storage system has poor performance, company operations may be impaired. A distributed storage system therefore maintains high standards for data availability and high-performance functionality. 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
       The present disclosure is illustrated by way of example, and not by way of limitation, in the figures of the accompanying drawings. 
         FIG.  1    is a block diagram illustrating a storage system in which embodiments of the present disclosure may be implemented. 
         FIG.  2    is a block diagram illustrating a memory manager in a storage controller, according to an embodiment. 
         FIG.  3    is a flow diagram illustrating a method for performing a metadata scan to populate a data structure, according to an embodiment. 
         FIG.  4    is a flow diagram illustrating a method for identifying a deallocated data block on a storage device, according to an embodiment. 
         FIG.  5    is a flow diagram illustrating a method for identifying leading edge data on a storage device, according to an embodiment. 
         FIG.  6    is a block diagram illustrating an exemplary computer system, according to an embodiment. 
     
    
    
     DETAILED DESCRIPTION 
     Embodiments are described for efficient flash management for multiple controllers. In one embodiment, a memory manager module running on a storage controller utilizes physical block addressing rather than logical addressing to manage the data stored on the underlying storage devices in a connected storage array. The memory manager may abide by certain principles including having no preference for particular physical addresses, such that data does not have a “primary” location, “secondary” location, etc., but rather is just scattered randomly about the drive. Another principle of operations is not trying to write a “trickle” of tiny metadata updates because as the drive&#39;s state evolves, it may be best to use only the metadata persisted into flash blocks, along with periodically persisted data managed by the memory manager. 
     In one embodiment, the memory manager described herein achieves these principles by meeting at least three individual objectives. First, the memory manager allows a fast start of the primary storage controller by quickly locating recently-written flash blocks of one or more types of data. Second, the memory manager provides a list of flash blocks that are deallocated and ready for client writes. Third, the memory manager respects the needs of modern flash devices by delaying the erase of flash blocks until just before those blocks are needed for writing. 
     To accomplish the above objectives, the memory manager works in connection with firmware in the underlying storage devices. In one embodiment, the storage device firmware implements a metadata tracking scheme that stores certain values along with any data payload. These values may include a program/erase count for each data block that indicates a number of cycles during which the block has been written and erased, and a block type value, which may identify a storage client that owns the data in that block. In addition, the storage device firmware maintains a table or other data structure containing data for each data block and allows the memory manager to access the table. For each data block, the table also stores the program/erase count, the block type value, and a block status indicator (erased, written, unreadable, bad, etc.). On power-up of the storage device, the firmware may scan the data blocks to recover the embedded metadata and populate the data structure with the metadata recovered from those blocks. 
     The memory manager manages blocks in concert with a data structure called the “frontier set.” The frontier set is a data structure that is written to flash that declares the state of a storage device in a way that allows future readers to determine not only what was true at that point in time, but also to recover the effect of operations that occurred after the frontier set was written to flash. The frontier set, in its most primitive form, is simply a list of block numbers and their corresponding program/erase counts. This is a declaration that at the moment the frontier set was created, block X was deallocated when its program/erase count was Y. The memory manager can use the frontier set to extrapolate the state of a block beyond the moment the frontier set was created and written. If block X was deallocated when its program/erase count was Y, the memory manager can make at least two logical conclusions. First, a future reader that finds block X still at program/erase count Y can conclude that block must still be deallocated. Second, a future reader that finds block X at some program/erase count Z&gt;Y can conclude that some client must have written new data to that block, after this frontier set was created or updated. 
     As explained herein, these conclusions allow the memory manager to achieve the objectives described above. As long as the memory manager writes a new frontier set periodically (and sufficient blocks remain available), it is possible to allow the controller to discover known deallocated blocks that are ready for new writes. In addition, erases can be delayed until just before the blocks are rewritten because block deallocation will be “eventually consistent.” This means that a deallocated block may not be seen as deallocated by all possible future primary controllers since it&#39;s possible that deallocated blocks may revert to the allocated state, until the next frontier set is persisted. Deallocated blocks are available for reuse, but until the moment that their new owner actually writes to them (which implies that the embedded metadata will include a new program/erase count and block type value), that block may revert back to its previous owner. Furthermore, a fast start of the primary controller is achieved by locating the leading edge of newly written data from a particular client. To assist a major client storing on the order of 100,000 to 1,000,000 blocks or more, the memory manager can define two classes of data, or more precisely, two states that a data block can be in. A “boot” block is one that contains new data and a “standalone” block contains cold data (i.e., data that has been around and untouched for a certain period of time). Boot blocks can be quickly and efficiently enumerated by memory manager to the client, after a crash or power loss. When the client no longer requires this block to be enumerated as a boot block, it will indicate this to the memory manager (a process referred to as “graduation”). This block will then become a standalone block at the memory manager&#39;s discretion. 
       FIG.  1    is a block diagram illustrating a storage system  100  in which embodiments of the present disclosure may be implemented. Storage system  100  may include storage controllers  110 ,  150  and storage array  130 , which is representative of any number of data storage arrays or storage device groups. As shown, storage array  130  includes storage devices  135 A-n, which are representative of any number and type of storage devices (e.g., solid-state drives (SSDs)). Storage controller  110  may be coupled directly to initiator device  125  and storage controller  110  may be coupled remotely over network  120  to initiator device  115 . In one embodiment, storage controller  150  is coupled remotely over network  120  to initiator device  115 . Initiator devices  115  and  125  are representative of any number of clients which may utilize storage controllers  110  and  150  for storing and accessing data in storage system  100 . It is noted that some systems may include only a single client or initiator device, connected directly or remotely, to storage controllers  110  and  150 . 
     In one embodiment, controller  110  is designated as the “primary” controller, which performs most or all of the I/O operations on the array  130 . If, however, a software crash, hardware fault or other error occurs, the “secondary” controller  150  may be promoted to serve as the primary controller and take over all responsibilities for servicing the array  130 . In one embodiment, storage controllers  110  and  150  are identical and any description of controller  110  herein may be equally attributed to storage controller  150 . 
     Storage controller  110  may include software and/or hardware configured to provide access to storage devices  135 A-n. Although storage controller  110  is shown as being separate from storage array  130 , in some embodiments, storage controller  110  may be located within storage array  130 . Storage controller  110  may include or be coupled to a base operating system (OS), a volume manager, and additional control logic, such as memory manager  140 , for implementing the various techniques disclosed herein. In one embodiment, the OS is designed with flash storage in mind, so while it can use conventional SSDs to store data, it does not depend on a 512 byte random overwrite capability. Even on conventional SSDs, storage controller  110  can achieve better performance by writing and discarding data in large chunks. This style of I/O is sometimes called “flash friendly I/O.” This also makes it a much easier task to convert the OS to use the physical addressing of storage devices, as compared to conventional filesystems. 
     In one embodiment, the logic of memory manager  140  is contained within an object which manages one of devices  135 A-n. Thus, there may be a separate memory manager object for each device  135 A-n in storage array  130 . As new devices are connected to controller  110 , new memory manager objects may be created. These objects may be similarly discarded when a corresponding device is disconnected from storage controller  110 . Clients wishing to communicate with memory manager  140 , such as one of initiator applications  112 ,  122 , the operating system running on storage controller  110  or another client application running on storage controller  110 , may do so via a memory manager application programming interface (API) published by memory manager  140 . In one embodiment, multiple clients can access the same memory manager object concurrently. In one embodiment, storage controller  150  includes a separate instance(s) of memory manager  152 . 
     Storage controller  110  may include and/or execute on any number of processing devices and may include and/or execute on a single host computing device or be spread across multiple host computing devices, depending on the embodiment. In some embodiments, storage controller  110  may generally include or execute on one or more file servers and/or block servers. Storage controller  110  may use any of various techniques for replicating data across devices  135 A-n to prevent loss of data due to the failure of a device or the failure of storage locations within a device. Storage controller  110  may also utilize any of various deduplication techniques for reducing the amount of data stored in devices  135 A-n by deduplicating common data. 
     In one embodiment, storage controller  110  may utilize logical volumes and mediums to track client data that is stored in storage array  130 . A medium is defined as a logical grouping of data, and each medium has an identifier with which to identify the logical grouping of data. A volume is a single accessible storage area with a single file system, typically, though not necessarily, resident on a single partition of a storage device. The volumes may be logical organizations of data physically located on one or more of storage device  135 A-n in storage array  130 . Storage controller  110  may maintain a volume to medium mapping table to map each volume to a single medium, and this medium is referred to as the volume&#39;s anchor medium. A given request received by storage controller  110  may indicate at least a volume and block address or file name, and storage controller  110  may determine an anchor medium targeted by the given request from the volume to medium mapping table. 
     In one embodiment, storage controller  110  includes memory manager  140 . Memory manager  140  can perform various operations to identify deallocated data blocks available for writing and to identify leading edge data that was most recently written by a particular client. In one embodiment, memory manager  140  can receive a request to write data to a storage device  135 A and can determine a first data block on storage device  135 A comprising a list of deallocated data blocks. That list may include a block number of each deallocated data block and an access operation count value (e.g., program/erase count value) at which each deallocated data block was deallocated. Memory manager  140  can then identify a second data block from the list of deallocated data blocks and write the requested data to that second data block. To identify the leading edge data, memory manager  140  may access a data structure stored in memory on storage device  135 A, where the data structure stores block metadata for each data block on storage device  135 A. Memory manager  140  may determine, from the data structure, a first data block on storage device  135 A comprising a list of deallocated data blocks on the storage device and compare a first access operation count value associated with each of the deallocated data blocks from the data structure to a second access operation count value associated with each of the deallocated data blocks from the list of deallocated data blocks. Memory manager  140  may label a second data block on the list as comprising new data responsive to the first access operation count value associated with the second data block from the data structure not matching the second access operation count value associated with the second data block from the list of deallocated data blocks. 
     In various embodiments, multiple mapping tables may be maintained by storage controller  110 . These mapping tables may include a medium mapping table and a volume to medium mapping table. These tables may be utilized to record and maintain the mappings between mediums and underlying mediums and the mappings between volumes and mediums. Storage controller  110  may also include an address translation table with a plurality of entries, wherein each entry holds a virtual-to-physical mapping for a corresponding data component. This mapping table may be used to map logical read/write requests from each of the initiator devices  115  and  125  to physical locations in storage devices  135 A-n. A “physical” pointer value may be read from the mappings associated with a given medium during a lookup operation corresponding to a received read/write request. The term “mappings” is defined as the one or more entries of the address translation mapping table which convert a given medium ID and block number into a physical pointer value. This physical pointer value may then be used to locate a physical location within the storage devices  135 A-n. The physical pointer value may be used to access another mapping table within a given storage device of the storage devices  135 A-n. Consequently, one or more levels of indirection may exist between the physical pointer value and a target storage location. 
     In alternative embodiments, the number and type of client computers, initiator devices, storage controllers, networks, storage arrays, and data storage devices is not limited to those shown in  FIG.  1   . At various times one or more clients may operate offline. In addition, during operation, individual client computer connection types may change as users connect, disconnect, and reconnect to storage system  100 . Further, the systems and methods described herein may be applied to directly attached storage systems or network attached storage systems and may include a host operating system configured to perform one or more aspects of the described methods. Numerous such alternatives are possible and are contemplated. 
     Network  120  may utilize a variety of techniques including wireless connections, direct local area network (LAN) connections, wide area network (WAN) connections such as the Internet, a router, storage area network, Ethernet, and others. Network  120  may comprise one or more LANs that may also be wireless. Network  120  may further include remote direct memory access (RDMA) hardware and/or software, transmission control protocol/internet protocol (TCP/IP) hardware and/or software, router, repeaters, switches, grids, and/or others. Protocols such as Fibre Channel, Fibre Channel over Ethernet (FCoE), iSCSI, and so forth may be used in network  120 . The network  120  may interface with a set of communications protocols used for the Internet such as the Transmission Control Protocol (TCP) and the Internet Protocol (IP), or TCP/IP. In one embodiment, network  120  represents a storage area network (SAN) which provides access to consolidated, block level data storage. The SAN may be used to enhance the storage devices accessible to initiator devices so that the devices  135 A-n appear to the initiator devices  115  and  125  as locally attached storage. 
     Initiator devices  115  and  125  are representative of any number of stationary or mobile computers such as desktop personal computers (PCs), servers, server farms, workstations, laptops, handheld computers, servers, personal digital assistants (PDAs), smart phones, and so forth. Generally speaking, initiator devices  115  and  125  include one or more processing devices, each comprising one or more processor cores. Each processor core includes circuitry for executing instructions according to a predefined general-purpose instruction set. For example, the x 86  instruction set architecture may be selected. Alternatively, the ARM®, Alpha®, PowerPC®, SPARC®, or any other general-purpose instruction set architecture may be selected. The processor cores may access cache memory subsystems for data and computer program instructions. The cache subsystems may be coupled to a memory hierarchy comprising random access memory (RAM) and a storage device. 
     In one embodiment, initiator device  115  includes initiator application  112  and initiator device  125  includes initiator application  122 . Initiator applications  112  and  122  may be any computer application programs designed to utilize the data on devices  135 A-n in storage array  130  to implement or provide various functionalities. Initiator applications  112  and  122  may issue requests to read or write data from certain logical volumes data within storage system  100 . Those requests can be serviced by memory manager  140  of storage controller  110 , as described in detail herein. 
       FIG.  2    is a block diagram illustrating memory manager  140  in a storage controller  110 , according to an embodiment. In one embodiment, memory manager  140  includes client interface  242 , data structure interface  244 , data block interface  246  and comparison logic  248 . This arrangement of modules may be a logical separation, and in other embodiments, these modules, interfaces or other components can be combined together or separated in further components. In one embodiment, storage device  135 A is connected to memory manager  140  and includes firmware  252 , memory  235  storing data structure  254 , and data blocks  256 . In one embodiment, storage device  135 A may be external to storage controller  110  as part of storage array  130  and may be connected to storage controller  110  over a network or other connection. In other embodiments, storage controller  110  may include different and/or additional components which are not shown to simplify the description. Storage device  135 A may include one or more mass storage devices which can include, for example, flash memory or solid-state drives (SSDs). Memory  235  may include for example, random-access memory (RAM); dynamic random-access memory (DRAM); erasable programmable memory (e.g., EPROM and EEPROM); flash memory; or any other type of storage medium. In one embodiment, storage device  135 A includes volatile memory  235 , such as DRAM, and non-volatile data blocks  256 , such as flash blocks or other persistent data blocks. 
     In one embodiment, client interface  242  manages communication with client devices or applications in storage system  100 , such as initiator devices  115  or  125 , or applications within storage controller  110 . Client interface  242  can receive I/O requests to access data blocks  256  on storage device  135 A from an initiator application  112  or  122  over network  120 . In one embodiment, the I/O request includes a request to write new data to storage device  135 A. After the write is performed, client interface may provide a notification to initiator device  115  or  125  over network  120  indicating that the write was successfully performed. 
     In one embodiment, data structure interface  244  interacts with data structure  254  in memory  235  on storage device  135 A. In response to client interface  242  receiving a write request, for example, data structure interface  244  may access data structure  254  (e.g., a dynamic table) comprising block metadata for each of data blocks  256  on storage device  135 A. The block metadata may include an indication of a block type of each data block  256  and an access operation count value for each data block  256 . In one embodiment, the access operation count value is a total number of program/erase cycles that have been performed on the block. Using the block type indicator, data structure interface  244  may determine a first data block on storage device  135 A which stores a list of deallocated data blocks on storage device  135 A. This list may include a block number of each deallocated data block and an access operation count value at which each deallocated data block was deallocated. 
     In one embodiment, data block interface  246  interacts with data blocks  256  of storage device  135 A as part of any data access operations being performed. For example, once data structure interface  244  determines the block storing the list of deallocated data blocks, data block interface  246  may identify a second block of those deallocated blocks from the list, and read an access operation count value associated with the second block from the list. If memory manager  140  ultimately determines that the second block was in fact deallocated, data block interface  246  may perform the requested write operation by overwriting the old data in the second data block with new data. If the allegedly deallocated data block was not actually deallocated (or has since been reallocated), data block interface  246  can remove the second data block from the list stored in the first data block. When memory manager  140  is attempting to locate leading edge data, data block interface  246  can determine whether a particular block was previously labeled as comprising new data. In addition, once memory manager  140  identifies the leading edge data, data block interface  246  can label the data blocks as comprising either new or old data, as appropriate. 
     In one embodiment, comparison logic  248  performs various calculations and comparisons as part of the operations performed by memory manager  140 . For example, to verify that a block appearing on the list of deallocated data blocks is in fact deallocated or to determine whether a block is storing new or old data, comparison logic  248  may compare a first access operation count value associated with the data block from data structure  254  to a second access operation count value associated with the data block from the list of deallocated data blocks stored in one of data blocks  256  (identified by the block type value). If comparison logic  248  determines that the count values match, this indicates that the block has not been reallocated since it was added to the list of deallocated blocks and, thus, can either be labeled as storing old data or can safely be overwritten without losing any critical data. If the count values don&#39;t match, however, this indicates that another client has written data to that block and it should be removed from the list of deallocated blocks and/or labeled as comprising new data. 
       FIG.  3    is a flow diagram illustrating a method for performing a metadata scan to populate a data structure, according to an embodiment. The method  300  may be performed by processing logic that comprises hardware (e.g., circuitry, dedicated logic, programmable logic, microcode, etc.), software (e.g., instructions run on a processing device to perform hardware simulation), firmware, or a combination thereof. On power-up of the storage device  135 A, the method  300  may scan the data blocks  256  to recover the embedded metadata and populate the data structure  254  with the metadata recovered from those blocks. In one embodiment, method  300  may be performed by the firmware  252  of storage device  135 A, as shown in  FIG.  2   . 
     Referring to  FIG.  3   , at block  310 , method  300  detects a restart of storage device  135 A. After an event, such as a sudden power loss or software crash, storage device  135 A may be automatically restarted. Firmware  252  can detect the restart and initiate any number of start-up procedures. Storage system  100  is designed to be extremely reliable even in the face of hardware or software failures, including sudden power losses or software crashes. Storage devices  135 A-n may be designed with failures in mind, specifically to account for sudden crashes or power loss at any point during the process, and to assure that restarting after such an event is no different than any other restart operation. 
     At block  320 , method  300  scans a plurality of data blocks  256  on storage device  135 A to identify block metadata for each of the plurality of data blocks  256 . In one embodiment, firmware  252  may scan each of the data blocks  256  to recover the embedded metadata. This metadata may include, for example, an indication of a block type of each of the data blocks  256  and an access operation count value for each of the data blocks  256 . In one embodiment, this metadata may be stored in a header section of each individual block  256 , so that it can be obtained quickly and efficiently. In one embodiment, the scan is reasonably fast (e.g., taking less than 10 seconds to scan one million or more blocks). 
     At block  330 , method  300  stores the block metadata in data structure  254  stored in memory  235  on storage device  135 A, wherein the block metadata is accessible by storage controller  110  coupled to storage device  135 A. In one embodiment, data structure  254  comprises a plurality of entries, each of the entries corresponding to a different one of the data blocks  256  on storage device  135 A. In one embodiment, data structure  254  maintains an indication of a block type and an access operation count value for each data block. One example of a block type that may be stored in metadata is a “bootstrap data” block. This block type stores data that is needed to restart the system after a power loss or other failure. Since the data blocks  256  may have limited reusability (e.g., approximately three thousand program/erase cycles), this data cannot be stored in the same place since it gets accessed regularly. Since the bootstrap data can be located easily during the metadata scan, it can be located anywhere on storage device  135 A. 
     Data storage on flash follows a simple looking cycle: erase, program; erase, program. Once written or programmed, data is nonvolatile and may be read millions of times. Flash structures have a complex hierarchy (i.e., packages, dies, planes, blocks, pages, and bits). The memory manager  140  described herein operates primarily on the block level. This is because the block is the most common unit of erase and reuse. If a particular flash chip uses 16 MB blocks, then data will be written to flash in 16 MB chunks, and will be discarded in 16 MB chunks. One physical detail of NAND flash that becomes important is that the physical blocks and pages have some “extra” storage beyond the expected powers of two. Thus, a physical 16 KB block may actually contain 19 KB of physical bits. While most of these “extra” bits are consumed by error correction codes, there may be some room left over to store metadata about the block or its contents. Storage system  100  makes use of some of these bits to store metadata alongside any data stored by the controller. 
     There are a number of management tasks performed by any system that stores data on NAND flash chips. Normally these functions are all performed in SSD firmware and are concealed from the host computer. Flash chips have a limited lifespan, measured in program/erase (PE) cycles. Management software must spread data around such that flash blocks wear more or less evenly across the drive, or premature drive failure may result due to block failures. This may be referred to as “wear leveling.” Flash is an imperfect media and blocks may fail spontaneously. Thus, in one embodiment, management software must maintain a bad block list over the lifetime of the drive. In addition, most SSDs support a storage interface that is backwards compatible with hard disks from the last 20+ years, allowing a contiguous range of logical 512 byte sectors that can be overwritten randomly an arbitrary number of times. Firmware supports this interface via a complicated abstraction layer that maps logical addresses to physical flash locations dynamically to provide logical address mapping. In one embodiment, wear leveling and bad block handling are not performed in firmware, but rather are handled within memory manager  140  of storage controller  110 . Thus, the logical address feature may be discarded as only physical flash addresses are used. 
       FIG.  4    is a flow diagram illustrating a method for identifying a deallocated data block on a storage device, according to an embodiment. The method  400  may be performed by processing logic that comprises hardware (e.g., circuitry, dedicated logic, programmable logic, microcode, etc.), software (e.g., instructions run on a processing device to perform hardware simulation), firmware, or a combination thereof. The method  400  can allow a storage controller to identify deallocated data blocks to allow those blocks to be overwritten without the risk of losing any critical data. In one embodiment, method  400  may be performed by memory manager  140 , as shown in  FIGS.  1  and  2   . 
     Referring to  FIG.  4   , at block  410 , method  400  receives a request to write data to storage device  135 A (e.g., a SSD). In one embodiment, client interface  242  receives the request from an initiator application  112  or  122  over network  120 , or from another client application on storage controller  110 . The write request may not specify a particular data block on storage device  135 A, so it may be up to memory manager  140  to identify a deallocated block. Since data blocks  256  may not be erased until right before they are written, even a block currently storing data may be “deallocated” and, thus, available for writing. 
     At block  420 , method  400  accesses a dynamic table (e.g., data structure  254 ) stored in memory  235  on storage device  135 A, the dynamic table comprising block metadata for each data block  256  on storage device  135 A. In one embodiment, data structure interface  244  may access data structure  254  comprising block metadata for each of data blocks  256  on storage device  135 A. The block metadata may include an indication of a block type of each data block and an access operation count value for each data block. 
     At block  430 , method  400  determines a first data block on storage device  135 A comprising a list of deallocated data blocks on the storage device  135 A. In one embodiment, data structure interface  244  determines the first data block from the dynamic table based on the indication of the block type of the first data block. Using the block type indicator stored in the dynamic table, data structure interface  244  may determine a first data block on storage device  135 A which stores a list of deallocated data blocks on storage device  135 A. This list may include a block number of each deallocated data block and an access operation count value at which each deallocated data block was deallocated. In one embodiment, this list may be referred to as the “frontier set” and the block where it is stored may be given a special block type. In one embodiment, the frontier set is identified and read once when storage device  135 A is started-up (or restarted), and the list of deallocated blocks is stored and their corresponding operation count values are stored in memory  235 . 
     At block  440 , method  400  identifies a second data block from the list of deallocated data blocks on the storage device  135 A. In one embodiment, data block interface  246  accesses the first block on storage device  135 A identified at block  430  from the dynamic table. Data block interface  246  may identify a second block of those deallocated blocks from the list, and read an access operation count value associated with the second block from the list. In one embodiment, the second data block may be identified from the list of deallocated blocks stored in memory  235  some period of time after the frontier set is initially identified at block  430 . 
     At block  450 , method  400  compares a first access operation count value associated with the second data block from the dynamic table to a second access operation count value associated with the second data block from the list of deallocated data blocks. In one embodiment, comparison logic  248  compares the first access operation count value to the second access operation count value associated with the data block. If comparison logic  248  determines that the count values match, this indicates that the block has not been reallocated since it was added to the list of deallocated blocks. Thus, at block  460 , method  400  writes the requested data to the second data block. In one embodiment, data block interface  246  overwrites the old data stored in the second data block with the newly requested data received at block  410 . If the count values do not match, however, this indicates that another client has since written new data to that block. Thus, at block  470 , data block interface  246  removes the second data block from the list of deallocated data blocks. 
       FIG.  5    is a flow diagram illustrating a method for identifying leading edge data on a storage device, according to an embodiment. The method  500  may be performed by processing logic that comprises hardware (e.g., circuitry, dedicated logic, programmable logic, microcode, etc.), software (e.g., instructions run on a processing device to perform hardware simulation), firmware, or a combination thereof. The method  500  can allow a storage controller to identify leading edge data that was most recently written to storage device  135 A by a particular storage client. In one embodiment, method  500  may be performed by memory manager  140 , as shown in  FIGS.  1  and  2   . 
     Referring to  FIG.  5   , at block  510 , method  500  accesses data structure  254  in memory  235  on storage device  135 A, the data structure  254  comprising block metadata for each data block  256  on storage device  135 A. In one embodiment, data structure interface  244  may access data structure  254  comprising block metadata for each of data blocks  256  on storage device  135 A. The block metadata may include an indication of a block type of each data block and an access operation count value for each data block. 
     At block  520 , method  500  determines, from data structure  254 , a first data block on storage device  135 A comprising a list of deallocated data blocks on storage device  135 A. In one embodiment, data structure interface  244  determines the first data block from the data structure  254  based on the indication of the block type of the first data block. Using the block type indicator stored in the data structure  254 , data structure interface  244  may determine a first data block on storage device  135 A which stores a list of deallocated data blocks on storage device  135 A. This list may include a block number of each deallocated data block and an access operation count value at which each deallocated data block was deallocated and a state value indicating whether the block is known to be in use. The state value may be indicated as “boot” or “future,” where a boot block is known to be in use (because it includes new data) and a future block was, at the time data structure  254  was populated, not in use (because it includes old data). In one embodiment, this list may be referred to as the “frontier set” and the block where it is stored may be given a special block type. The frontier set represents a snapshot in time and permits a future primary controller to correctly recover the state of the drive (and all the clients&#39; data storage). A newly started primary controller can examine this frontier set, and compare the program/erase counts to those on the drive itself. “Future” blocks will become boot blocks if the program/erase count indicates new writes have occurred. “Boot” blocks will generally stay boot blocks, barring unusual events, such as flash errors, etc. 
     At block  530 , method  500  determines whether a data block on the list of deallocated data blocks was previously labeled as comprising old data. In one embodiment, data block interface  246  reads the data from the first data block where the frontier set itself is stored, locates an entry in the frontier set corresponding to a second data block and reads the state value for that entry. As described above data blocks on storage device  135 A comprising old data may be labeled as “future” blocks in the frontier set and data blocks comprising new data may be labeled as “boot” blocks in the frontier set. 
     If the block was previously labeled as comprising new data (i.e., labeled as “boot” blocks), at block  540 , method  500  maintains the previous new data label. Thus, boot blocks stay labeled boot blocks, regardless of whether they have new writes. 
     If the block was previously labeled as comprising old data, at block  550 , method  500  compares a first access operation count value associated with the deallocated data blocks from the data structure  254  to a second access operation count value associated with the deallocated data block from the list of deallocated data blocks. In one embodiment, comparison logic  248  compares the first access operation count value to the second access operation count value associated with the data block. If comparison logic  248  determines that the first access operation count value associated with the second data block from the data structure does not match the second access operation count value associated with the second data block from the list of deallocated data blocks, this indicates that the block has been written with new data since it was added to the list. Thus, at block  540 , method  500  labels the second data block on the list as comprising new data. In one embodiment, data block interface  246  changes the state value in the entry of the frontier set corresponding to the data block to “boot.” If the first access operation count value associated with the second data block from the data structure matches the second access operation count value associated with the second data block from the list of deallocated data blocks, however, this indicates that no new data has been written to that block. Thus, at block  560 , method  500  labels the second data block on the list as comprising old data. In one embodiment, data block interface  246  maintains the state value in the entry of the frontier set corresponding to the data block as “future.” 
     In one embodiment, standalone blocks are not tracked by the frontier set. Rather, they can be defined as “all the blocks not listed in the frontier set” (or marked bad). These blocks can be enumerated simply by searching the drive tables for blocks with the correct block type that are not covered by the current frontier set. It should also be noted that all newly allocated blocks may come from the list of blocks written in the frontier set. Otherwise the newly written data would not be detected as a boot block by a future primary controller. Furthermore, because boot blocks are be listed in the frontier set, there can be policy on clients with small storage needs that they will never use standalone blocks. This means that any blocks that contain data with that client&#39;s block type, but are not listed in the frontier set, have been deallocated, saving clients the bother of sifting through old data and deallocating those blocks. 
     Periodically, a new frontier set may be constructed and written to flash. This may be desirable if most of the deallocated blocks in the current frontier set have been exhausted. Writing a new frontier set can make additional blocks ready for allocation. In addition, if a particular client has written and then deallocated many blocks, a new frontier set may be created. In one embodiment, deallocations are not made permanent until a new frontier set is written. Thus, completing that write will limit the number of blocks a future primary will discover. This can affect failover time, so it may be advantageous to limit some clients&#39; block usage. Failover includes the transfer of the “primary” designation from one controller to another, which includes the transfer of the functionality of memory manager  140 . Furthermore, when some blocks with attractive (i.e., low) program/erase counts have become deallocated, for best wear leveling behavior, the system tries to use the blocks with the lowest program/erase count first. Persisting a new frontier set can make those more attractive blocks available. 
     A new frontier set may be constructed by selecting some new future blocks from the list of deallocated blocks and adding the list of known boot blocks. Blocks which were formerly boot blocks in the previous frontier set but have since been graduated may not be recorded in the new frontier set. While persisting a new frontier set, the system need not halt all client allocations and writes. The new frontier set is constructed to contain at least a small number of blocks that are also part of the previous frontier set (and are marked as “future” blocks). In this way the system can continue allocating blocks from this overlapping set, knowing that if it crashes or loses power at any time, memory manager  140  can safely start up using either the new set (assuming the new frontier set write completed) or the old set (if the write did not complete). Each new frontier set may be written to a flash block using a “frontier set” block type value. This assists in quickly locating the frontier set. 
     Because this design does not persist a new frontier set during every state change, there may be an accumulation of changes that have only taken effect inside the controller memory. These changes can be lost if a failover or power loss occurs. It is possible to lose block deallocations and graduations across these events, however, this does not affect the correctness of the controller application, as it is straightforward to simply repeat these actions on the new primary controller. It is also possible to lose a block allocation if the client did not write to the block in question before the failover or restart. In one embodiment, this problem is alleviated as whatever task that intended to write something will be repeated on the new primary controller and may allocate a new block without being aware that a previous primary controller was attempting a similar operation. 
     In one embodiment, the storage device firmware  252  provides a list of blocks containing data of a particular block type to memory manager  140 . This reduces the work required to locate the frontier set, and allows faster primary controller startup. When writing the frontier set, memory manager  140  also takes the unusual step of physically erasing old copies of frontier sets. This allows faster startup time by ensuring that controller  110  does not have to sift through many old frontier sets looking for the current one. To ensure correct behavior across a surprise block failure, frontier sets may be written to at least two physical locations, preferably spread across different failure domains (e.g. flash dies) to minimize the chance that both fail simultaneously. In one embodiment, the encryption capabilities of storage device firmware  252  are customized such that the data structures needed during startup (e.g. the frontier set) can be written unencrypted, and most client data can be written encrypted. 
       FIG.  6    illustrates a diagrammatic representation of a machine in the exemplary form of a computer system  600  within which a set of instructions, for causing the machine to perform any one or more of the methodologies discussed herein, may be executed. In alternative embodiments, the machine may be connected (e.g., networked) to other machines in a local area network (LAN), an intranet, an extranet, or the Internet. The machine may operate in the capacity of a server or a client machine in a client-server network environment, or as a peer machine in a peer-to-peer (or distributed) network environment. The machine may be a personal computer (PC), a tablet PC, a set-top box (STB), a Personal Digital Assistant (PDA), a cellular telephone, a web appliance, a server, a network router, switch or bridge, or any machine capable of executing a set of instructions (sequential or otherwise) that specify actions to be taken by that machine. Further, while only a single machine is illustrated, the term “machine” shall also be taken to include any collection of machines that individually or jointly execute a set (or multiple sets) of instructions to perform any one or more of the methodologies discussed herein. In one embodiment, computer system  600  may be representative of a server, such as storage controller  110  running memory manager  140  or of a client, such as initiator devices  115  or  125 . 
     The exemplary computer system  600  includes a processing device  602 , a main memory  604  (e.g., read-only memory (ROM), flash memory, dynamic random access memory (DRAM), a static memory  606  (e.g., flash memory, static random access memory (SRAM), etc.), and a data storage device  618 , which communicate with each other via a bus  630 . Data storage device  618  may be one example of any of the storage devices  135 A-n in  FIGS.  1  and  2   . Any of the signals provided over various buses described herein may be time multiplexed with other signals and provided over one or more common buses. Additionally, the interconnection between circuit components or blocks may be shown as buses or as single signal lines. Each of the buses may alternatively be one or more single signal lines and each of the single signal lines may alternatively be buses. 
     Processing device  602  represents one or more general-purpose processing devices such as a microprocessor, central processing unit, or the like. More particularly, the processing device may be complex instruction set computing (CISC) microprocessor, reduced instruction set computer (RISC) microprocessor, very long instruction word (VLIW) microprocessor, or processor implementing other instruction sets, or processors implementing a combination of instruction sets. Processing device  602  may also be one or more special-purpose processing devices such as an application specific integrated circuit (ASIC), a field programmable gate array (FPGA), a digital signal processor (DSP), network processor, or the like. The processing device  602  is configured to execute processing logic  626 , which may be one example of memory manager  140  shown in  FIGS.  1  and  2   , or of initiator application  112  or  122 , for performing the operations and steps discussed herein. 
     The data storage device  618  may include a machine-readable storage medium  628 , on which is stored one or more set of instructions  622  (e.g., software) embodying any one or more of the methodologies of functions described herein, including instructions to cause the processing device  602  to execute virtual copy logic  140  or initiator application  112  or  122 . The instructions  622  may also reside, completely or at least partially, within the main memory  604  and/or within the processing device  602  during execution thereof by the computer system  600 ; the main memory  604  and the processing device  602  also constituting machine-readable storage media. The instructions  622  may further be transmitted or received over a network  620  via the network interface device  608 . 
     The machine-readable storage medium  628  may also be used to store instructions to perform a method for efficient flash management for multiple controllers, as described herein. While the machine-readable storage medium  628  is shown in an exemplary embodiment to be a single medium, the term “machine-readable storage medium” should be taken to include a single medium or multiple media (e.g., a centralized or distributed database, and/or associated caches and servers) that store the one or more sets of instructions. A machine-readable medium includes any mechanism for storing information in a form (e.g., software, processing application) readable by a machine (e.g., a computer). The machine-readable medium may include, but is not limited to, magnetic storage medium (e.g., floppy diskette); optical storage medium (e.g., CD-ROM); magneto-optical storage medium; read-only memory (ROM); random-access memory (RAM); erasable programmable memory (e.g., EPROM and EEPROM); flash memory; or another type of medium suitable for storing electronic instructions. 
     The preceding description sets forth numerous specific details such as examples of specific systems, components, methods, and so forth, in order to provide a good understanding of several embodiments of the present disclosure. It will be apparent to one skilled in the art, however, that at least some embodiments of the present disclosure may be practiced without these specific details. In other instances, well-known components or methods are not described in detail or are presented in simple block diagram format in order to avoid unnecessarily obscuring the present disclosure. Thus, the specific details set forth are merely exemplary. Particular embodiments may vary from these exemplary details and still be contemplated to be within the scope of the present disclosure. 
     In situations in which the systems discussed herein collect personal information about users, or may make use of personal information, the users may be provided with an opportunity to control whether programs or features collect user information (e.g., information about a user&#39;s social network, social actions or activities, profession, a user&#39;s preferences, or a user&#39;s current location), or to control whether and/or how to receive content from the media server that may be more relevant to the user. In addition, certain data may be treated in one or more ways before it is stored or used, so that personally identifiable information is removed. For example, a user&#39;s identity may be treated so that no personally identifiable information can be determined for the user, or a user&#39;s geographic location may be generalized where location information is obtained (such as to a city, ZIP code, or state level), so that a particular location of a user cannot be determined. Thus, the user may have control over how information is collected about the user and used by the web server or media server. 
     Reference throughout this specification to “one embodiment” or “an embodiment” means that a particular feature, structure, or characteristic described in connection with the embodiments included in at least one embodiment. Thus, the appearances of the phrase “in one embodiment” or “in an embodiment” in various places throughout this specification are not necessarily all referring to the same embodiment. In addition, the term “or” is intended to mean an inclusive “or” rather than an exclusive or. 
     Although the operations of the methods herein are shown and described in a particular order, the order of the operations of each method may be altered so that certain operations may be performed in an inverse order or so that certain operation may be performed, at least in part, concurrently with other operations. In another embodiment, instructions or sub-operations of distinct operations may be in an intermittent and/or alternating manner.