Source: http://www.google.com.tw/patents/US7039663
Timestamp: 2013-06-19 01:40:45
Document Index: 774669391

Matched Legal Cases: ['art 1102', 'art 1104', 'art 1102', 'art 1102', 'art 1104', 'art 1', 'art 1', 'art 1104', 'art 1', 'art 1', 'art 1104', 'art 1', 'art 1', 'art 1104', 'art 1102', 'art 1104', 'art 1']

�M�Q US7039663 - System and method for checkpointing and restarting an asynchronous transfer ... - Google �M�Q�j�M �Ϥ� �a�� Play YouTube �s�D Gmail ���ݵw�� ��h »�i���M�Q�j�M | �������� | �n�J�i���M�Q�j�M�M�QA system and method for inserting checkpoints into a data stream and for restarting an asynchronous transmission of a data stream from a source file system to a destination file system is provided. The data stream can be a set of changes between a base snapshot and incremental snapshot of the source...http://www.google.com.tw/patents/US7039663?utm_source=gb-gplus-share�M�Q US7039663 - System and method for checkpointing and restarting an asynchronous transfer of data between a source and destination snapshot���}��US7039663 B1�X���������v�ӽЮѽs��10/126,822�o�G���2006�~5��2���ӽФ��2002�~4��19�� �u���v���2002�~4��19����L���}�M�Q��US7769717, US20060184587���}��10126822, 126822, US 7039663 B1, US 7039663B1, US-B1-7039663, US7039663 B1, US7039663B1�o��HMichael L. Federwisch, Stephen L. Manley, Shane S. Owara��M�Q�v�HNetwork Appliance, Inc.�M�Q�ޥ� (20), �D�M�Q�ޥ� (39), �Q�H�U�M�Q�ޥ� (56), ���� (22) �~���s��: ���M�Q�ӼЧ�, ���M�Q�ӼЧ��M�Q����T��, �ڬw�M�Q��System and method for checkpointing and restarting an asynchronous transfer of data between a source and destination snapshotUS 7039663 B1�K�n A system and method for inserting checkpoints into a data stream and for restarting an asynchronous transmission of a data stream from a source file system to a destination file system is provided. The data stream can be a set of changes between a base snapshot and incremental snapshot of the source file system for update of a replicated file system on the destination. State information relating to the progress of the source in processing and transmitting the data stream is stored at regular intervals, and a checkpoint number associated with each stored segment of the state information is inserted into the data stream. The destination tracks the fall commitment of each segment of the data stream to persistent storage on the replicated file system. If an error or communication loss requires the data transfer to be restarted, the destination sends the checkpoint number associated with the last fully committed segment of the data stream. The source reinitializes its data gathering processes using the state information associated with the particular checkpoint number. The changes sent from the source file system to the destination file system relate to a sub-organization of a volume on the source such as a qtree, identified by a qtree identifier (ID) in the associated inodes and data stream.
A common type of file system is a ��write in-place�� file system, an example of which is the conventional Berkeley fast file system. By ��file system�� it is meant generally a structuring of data and metadata on a storage device, such as disks, which permits reading/writing of data on those disks. In a write in-place file system, the locations of the data structures, such as inodes and data blocks, on disk are typically fixed. An inode is a data structure used to store information, such as metadata, about a file, whereas the data blocks are structures used to store the actual data for the file. The information contained in an inode may include, e.g., ownership of the file, access permission for the file, size of the file, file type and references to locations on disk of the data blocks for the file. The references to the locations of the file data are provided by pointers in the inode, which may further reference indirect blocks that, in turn, reference the data blocks, depending upon the quantity of data in the file. Changes to the inodes and data blocks are made ��inplace�� in accordance with the write in-place file system. If an update to a file extends the quantity of data for the file, an additional data block is allocated and the appropriate inode is updated to reference that data block.
Another type of file system is a write-anywhere file system that does not over-write data on disks. If a data block on disk is retrieved (read) from disk into memory and ��dirtied�� with new data, the data block is stored (written) to a new location on disk to thereby optimize write performance. A write-anywhere file system may initially assume an optimal layout such that the data is substantially contiguously arranged on disks. The optimal disk layout results in efficient access operations, particularly for sequential read operations, directed to the disks. A particular example of a write-anywhere file system that is configured to operate on a filer is the Write Anywhere File Layout (WAFL™) file system available from Network Appliance, Inc. of Sunnyvale, Calif. The WAFL file system is implemented within a microkernel as part of the overall protocol stack of the filer and associated disk storage. This microkernel is supplied as part of Network Appliance's Data ONTAP™ software, residing on the filer, that processes file-service requests from network-attached clients.
In order to improve reliability and facilitate disaster recovery in the event of a failure of a filer, its associated disks or some portion of the storage infrastructure, it is common to ��mirror�� or replicate some or all of the underlying data and/or the file system that organizes the data. In one example, a mirror is established and stored at a remote site, making it more likely that recovery is possible in the event of a true disaster that may physically damage the main storage location or it's infrastructure (e.g. a flood, power outage, act of war, etc.). The mirror is updated at regular intervals, typically set by an administrator, in an effort to catch the most recent changes to the file system. One common form of update involves the use of a ��snapshot�� process in which the active file system at the storage site, consisting of inodes and blocks, is captured and the ��snapshot�� is transmitted as a whole, over a network (such as the well-known Internet) to the remote storage site. Generally, a snapshot is an image (typically read-only) of a file system at a point in time, which is stored on the same primary storage device as is the active file system and is accessible by users of the active file system. By ��active file system�� it is meant the file system to which current input/output operations are being directed. The primary storage device, e.g., a set of disks, stores the active file system, while a secondary storage, e.g. a tape drive, may be utilized to store backups of the active file system. Once snapshotted, the active file system is reestablished, leaving the snapshotted version in place for possible disaster recovery. Each time a snapshot occurs, the old active file system becomes the new snapshot, and the new active file system carries on, recording any new changes. A set number of snapshots may be retained depending upon various time-based and other criteria. The snapshotting process is described in further detail in U.S. Pat. application Ser. No. 09/932,578 now Published Patent No. 2002/0083037 A1 on Jun. 27, 2002, entitled INSTANT SNAPSHOT by Blake Lewis et al., which is hereby incorporated by reference as though fully set forth herein. In addition, the native Snapshot™ capabilities of the WAFL file system are further described in TR3002 File System Design for an NFS File Server Appliance by David Hitz et al., published by Network Appliance, Inc., and in commonly owned U.S. Pat. No. 5,819,292 issued on Oct. 6, 1998, entitled METHOD FOR MAINTAINING CONSISTENT STATES OF A FILE SYSTEM AND FOR CREATING USER-ACCESSIBLE READ-ONLY COPIES OF A FILE SYSTEM by David Hitz et al., which are hereby incorporated by reference.
In brief summary, the source creates a pair of time-separated snapshots of the volume. These can be created as part of the commit process in which data is committed to non-volatile memory in the filer or by another mechanism. The ��new�� snapshot 110 is a recent snapshot of the volume's active file system. The ��old�� snapshot 112 is an older snapshot of the volume, which should match the image of the file system replicated on the destination mirror. Note, that the file server is free to continue work on new file service requests once the new snapshot 112 is made. The new snapshot acts as a checkpoint of activity up to that time rather than an absolute representation of the then-current volume state. A differencer 120 scans the blocks 122 in the old and new snapshots. In particular, the differencer works in a block-by-block fashion, examining the list of blocks in each snapshot to compare which blocks have been allocated. In the case of a write-anywhere system, the block is not reused as long as a snapshot references it, thus a change in data is written to a new block. Where a change is identified (denoted by a presence or absence of an ��X�� designating data), a decision process 200, shown in FIG. 2, in the differencer 120 decides whether to transmit the data to the destination 102. The process 200 compares the old and new blocks as follows: (a) Where data is in neither an old nor new block (case 202) as in old/new block pair 130, no data is available to transfer. (b) Where data is in the old block, but not the new (case 204) as in old/new block pair 132, such data has already been transferred, (and any new destination snapshot pointers will ignore it), so the new block state is not transmitted. (c) Where data is present in the both the old block and the new block (case 206) as in the old/new block pair 134, no change has occurred and the block data has already been transferred in a previous snapshot. (d) Finally, where the data is not in the old block, but is in the new block (case 208) as in old/new block pair 136, then a changed data block is transferred over the network to become part of the changed volume snapshot set 140 at the destination as a changed block 142. In the exemplary write-anywhere arrangement, the changed blocks are written to new, unused locations in the storage array. Once all changed blocks are written, a base file system information block, that is the root pointer of the new snapshot, is then committed to the destination. The transmitted file system information block is committed, and updates the overall destination file system by pointing to the changed block structure in the destination, and replacing the previous file system information block. The changes are at this point committed as the latest incremental update of the destination volume snapshot. This file system accurately represents the ��new�� snapshot on the source. In time a new ��new�� snapshot is created from further incremental changes.
By way of further background, FIG. 3 is a schematic block diagram of a storage system environment 300 that includes a pair of interconnected file servers including a source file server 310 and a destination file server 312 that may each be advantageously used with the present invention. For the purposes of this description, the source file server is a networked computer that manages storage one or more source volumes 314, each having an array of storage disks 360 (described further below). Likewise, the destination filer 312 manages one or more destination volumes 316, also comprising arrays of disks 360. The source and destination file servers or ��filers�� are linked via a network 318 that can comprise a local or wide area network, such as the well-known Internet. An appropriate network adapter 330 residing in each filer 310, 312 facilitates communication over the network 318. Also for the purposes of this description, like components in each of the source and destination filer, 310 and 312 respectively, are described with like reference numerals. As used herein, the term ��source�� can be broadly defined as a location from which the subject data of this invention travels and the term ��destination�� can be defined as the location to which the data travels. While a source filer and a destination filer, connected by a network, is a particular example of a source and destination used herein, a source and destination could be computers/filers linked via a direct link, or via loopback (a ��networking�� arrangement internal to a single computer for transmitting a data stream between local source and local destination), in which case the source and the destination are the same filer. As will be described further below, the source and destination are broadly considered to be a source sub-organization of a volume and a destination sub-organization of a volume. Indeed, in at least one special case the source and destination sub-organizations can be the same at different points in time.
It will be understood to those skilled in the art that the inventive technique described herein may apply to any type of special-purpose computer (e.g., file serving appliance) or general-purpose computer, including a standalone computer, embodied as a storage system. To that end, the filers 310 and 312 can each be broadly, and alternatively, referred to as storage systems. Moreover, the teachings of this invention can be adapted to a variety of storage system architectures including, but not limited to, a network-attached storage environment, a storage area network and disk assembly directly-attached to a client/host computer. The term ��storage system�� should, therefore, be taken broadly to include such arrangements.
In the illustrative embodiment, the memory 325 comprises storage locations that are addressable by the processor and adapters for storing software program code. The memory comprises a form of random access memory (RAM) that is generally cleared by a power cycle or other reboot operation (i.e., it is ��volatile�� memory). The processor and adapters may, in turn, comprise processing elements and/or logic circuitry configured to execute the software code and manipulate the data structures. The operating system 400, portions of which are typically resident in memory and executed by the processing elements, functionally organizes the filer by, inter alia, invoking storage operations in support of a file service implemented by the filer. It will be apparent to those skilled in the art that other processing and memory means, including various computer readable media, may be used for storing and executing program instructions pertaining to the inventive technique described herein.
To facilitate generalized access to the disks 360, the storage operating system 400 (FIG. 4) implements a write-anywhere file system that logically organizes the information as a hierarchical structure of directories and files on the disks. Each ��on-disk�� file may be implemented as a set of disk blocks configured to store information, such as data, whereas the directory may be implemented as a specially formatted file in which references to other files and directories are stored. As noted and defined above, in the illustrative embodiment described herein, the storage operating system is the NetApp® Data ONTAP™ operating system available from Network Appliance, Inc., of Sunnyvale, Calif. that implements the Write Anywhere File Layout (WAFL™) file system. It is expressly contemplated that any appropriate file system can be used, and as such, where the term ��WAFL�� is employed, it should be taken broadly to refer to any file system that is other-wise adaptable to the teachings of this invention.
Bridging the disk software layers with the network and file system protocol layers is a file system layer 450 of the storage operating system 400. Generally, the layer 450 implements a file system having an on-disk format representation that is block-based using, e.g., 4-kilobyte (KB) data blocks and using inodes to describe the files. In response to transaction requests, the file system generates operations to load (retrieve) the requested data from volumes if it is not resident ��in-core��, i.e., in the filer's memory 325. If the information is not in memory, the file system layer 450 indexes into the inode file using the inode number to access an appropriate entry and retrieve a volume block number. The file system layer 450 then passes the volume block number to the disk storage (RAID) layer 440, which maps that volume block number to a disk block number and sends the latter to an appropriate driver (for example, an encapsulation of SCSI implemented on a fibre channel disk interconnection) of the disk driver layer 445. The disk driver accesses the disk block number from volumes and loads the requested data in memory 325 for processing by the filer 310, 312. Upon completion of the request, the filer (and storage operating system) returns a reply, e.g., a conventional acknowledgement packet 374 defined by the CIFS specification, to the client 370 over the respective network connection 372.
It should be noted that the software ��path�� 470 through the storage operating system layers described above needed to perform data storage access for the client request received at the filer may alternatively be implemented in hardware or a combination of hardware and software. That is, in an alternate embodiment of the invention, the storage access request data path 470 may be implemented as logic circuitry embodied within a field programmable gate array (FPGA) or an application specific integrated circuit (ASIC). This type of hardware implementation increases the performance of the file service provided by filer 310, 312 in response to a file system request packet 374 issued by the client 370.
The inherent Snapshot™ capabilities of the exemplary WAFL file system are further described in TR3002 File System Design for an NFS File Server Appliance by David Hitz et al., published by Network Appliance, Inc., which is hereby incorporated by reference. Note, ��Snapshot�� is a trademark of Network Appliance, Inc. It is used for purposes of this patent to designate a persistent consistency point (CP) image. A persistent consistency point image (PCPI) is a point-in-time representation of the storage system, and more particularly, of the active file system, stored on a storage device (e.g., on disk) or in other persistent memory and having a name or other unique identifiers that distinguishes it from other PCPIs taken at other points in time. A PCPI can also include other information (metadata) about the active file system at the particular point in time for which the image is taken. The terms ��PCPI�� and ��snapshot�� shall be used inter-changeably through out this patent without derogation of Network Appliance's trademark rights.
An exemplary file system inode structure 500 according to an illustrative embodiment is shown in FIG. 5. The inode for the inode file or more generally, the ��root�� inode 505 contains information describing the inode file 508 associated with a given file system. In this exemplary file system inode structure root inode 505 contains a pointer to the inode file indirect block 510. The inode file indirect block 510 points to one or more inode file direct blocks 512, each containing a set of pointers to inodes 515 that make up the inode file 508. The depicted subject inode file 508 is organized into volume blocks (not separately shown) made up of inodes 515 which, in turn, contain pointers to file data (or ��disk��) blocks 520A, 520B and 520C. In the diagram, this is simplified to show just the inode itself containing pointers to the file data blocks. Each of the file data blocks 520(A�VC) is adapted to store, in the illustrative embodiment, 4 kilobytes (KB) of data. Note, however, where more than a predetermined number of file data blocks are referenced by an inode (515) one or more indirect blocks 525 (shown in phantom) are used. These indirect blocks point to associated file data blocks (not shown). If an inode (515) points to an indirect block, it cannot also point to a file data block, and vice versa.
When the file system generates a snapshot of a given file system, a snapshot inode is generated as shown in FIG. 6. The snapshot inode 605 is, in essence, a duplicate copy of the root inode 505 of the file system 500. Thus, the exemplary file system structure 600 includes the same inode file indirect block 510, inode file direct block 512, inodes 515 and file data blocks 520(A�VC) as depicted in FIG. 5. When a user modifies a file data block, the file system layer writes the new data block to disk and changes the active file system to point to the newly created block. The file layer does not write new data to blocks that are contained in snapshots.
FIG. 7 shows an exemplary inode file system structure 700 after a file data block has been modified. In this illustrative example, file data which is stored at disk block 520C is modified. The exemplary WAFL file system writes the modified contents to disk block 520C��, which is a new location on disk. Because of this new location, the inode file data which is stored at disk block (515) is rewritten so that it points to block 520C��. This modification causes WAFL to allocate a new disk block (715) for the updated version of the data at 515. Similarly, the inode file indirect block 510 is rewritten to block 710 and direct block 512 is rewritten to block 712, to point to the newly revised inode 715. Thus, after a file data block has been modified the snapshot inode 605 contains a pointer to the original inode file system indirect block 510 which, in turn, contains a link to the inode 515. This inode 515 contains pointers to the original file data blocks 520A, 520B and 520C. However, the newly written inode 715 includes pointers to unmodified file data blocks 520A and 520B. The inode 715 also contains a pointer to the modified file data block 520C�� representing the new arrangement of the active file system. A new file system root inode 705 is established representing the new structure 700. Note that metadata in any snapshotted blocks (e.g. blocks 510, 515 and 520C) protects these blocks from being recycled or overwritten until they are released from all snapshots. Thus, while the active file system root 705 points to new blocks 710, 712, 715 and 520C��, the old blocks 510, 515 and 520C are retained until the snapshot is fully released.
In accordance with an illustrative embodiment of this invention the source utilizes two snapshots, a ��base�� snapshot, which represents the image of the replica file system on the destination, and an ��incremental�� snapshot, which is the image that the source system intends to replicate to the destination, to perform needed updates of the remote snapshot mirror to the destination. In one example, from the standpoint of the source, the incremental snapshot can comprise a most-recent snapshot and the base can comprise a less-recent snapshot, enabling an up-to-date set of changes to be presented to the destination. This procedure shall now be described in greater detail.
Having described the general procedure for deriving a snapshot, the mirroring of snapshot information from the source filer 310 (FIG. 3) to a remote destination filer 312 is described in further detail. As discussed generally above, the transmission of incremental changes in snapshot data based upon a comparison of changed blocks in the whole volume is advantageous in that it transfers only incremental changes in data rather than a complete file system snapshot, thereby allowing updates to be smaller and faster. However, a more efficient and/or versatile procedure for incremental remote update of a destination mirror snapshot is contemplated according to an illustrative embodiment of this invention. Note, as used herein the term ��replica snapshot,�� ��replicated snapshot�� or ��mirror snapshot�� shall be taken to also refer generally to the file system on the destination volume that contains the snapshot where appropriate (for example where a snapshot of a snapshot is implied.
Before describing further the process of deriving changes in two source snapshots, from which data is transferred to a destination for replication of the source at the destination, general reference is made again to the file block structures shown in FIGS. 5�V7. Every data block in a file is mapped to disk block (or volume block). Every disk/volume block is enumerated uniquely with a discrete volume block number (VBN). Each file is represented by a single inode, which contains pointers to these data blocks. These pointers are VBNs�Xeach pointer field in an inode having a VBN in it, whereby a file's data is accessed by loading up the appropriate disk/volume block with a request to the file system (or disk control) layer. When a file's data is altered, a new disk block is allocated to store the changed data. The VBN of this disk block is placed in the pointer field of the inode. A snapshot captures the inode at a point in time, and all the VBN fields in it.
In order to scale beyond the maximum number of VBN ��pointers�� in an inode, ��indirect blocks�� are used. In essence, a disk block is allocated and filled with the VBNs of the data blocks, the inode pointers then point to the indirect block. There can exist several levels of indirect blocks, which can create a large tree structure. Indirect blocks are modified in the same manner as regular data blocks are�Xvery time a VBN in an indirect block changes, a new disk/volume block is allocated for the altered data of the indirect block.
In the example of a write-anywhere file layout, storage blocks are not immediately overwritten or reused. Thus changes in a file comprised of a series of volume blocks will always result in the presence of a new volume block number (newly written-to) that can be detected at the appropriate logical file block offset relative to an old block. The existence of a changed volume block number at a given offset in the index between the base snapshot inode file and incremental snapshot inode file generally indicates that one or more of the underlying inodes and files to which the inodes point have been changed. Note, however, that the system may rely on other indicators of changes in the inodes or pointers�Xthis may be desirable where a write-in-place file system is implemented.
Block pairs (e.g. blocks 7 and 8) that have been identified as changed are forwarded (as they are detected by the scan 820) to the rest of the source process, which includes an inode picker process 830. The inode picker identifies specific inodes (based upon qtree ID) from the forwarded blocks that are part of the selected qtree being mirrored. In this example the qtree ID Q2 is selected, and inodes containing this value in their file metadata are ��picked�� for further processing. Other inodes not part of the selected qtree(s) (e.g. inodes with qtree IDs Q1 and Q3) are discarded or otherwise ignored by the picker process 830. Note that a multiplicity of qtree IDs can be selected, causing the picker to draw out a group of inodes�Xeach having one of the selected qtree associations.
The appropriately ��picked�� inodes from changed blocks are then formed into a running list or queue 840 of changed inodes 842. These inodes are denoted by a discrete inode number as shown. Each inode in the queue 840 is handed off to an inode handler or worker 850, 852 and 854 as a worker becomes available. FIG. 8A is a table 835 detailing the basic set of rules the inode picker process 830 uses to determine whether to send a given inode to the queue for the workers to process.
Inode 2801 is allocated in both inode files. It is in the proper qtree Q2, and the two versions of this inode share the same generation number. This means that the inode represents the same file in the base and the incremental snapshots. It is unknown at this point whether the file data itself has changed, so the inode picker sends the pair to the changed inode queue, and a worker determines what data has changed. Inode 2802 is allocated in the base inode file, but not allocated in the incremental inode file. The base version of the inode was in the proper qtree Q2. This means this inode has been deleted. The inode picker sends this information down to the workers as well. Finally, inode 2803 is allocated in the base inode file, and reallocated in the incremental inode file. The inode picker 830 can determine this because the generation number has changed between the two versions (from #1�V#2). The new file which this inode represents has been added to the qtree, so like inode 2800, this is sent to the changed inode queue for processing, with a note that the whole file is new.
The function of the worker is to determine changes between each snapshot's versions of the files and directories. As described above, the source snapshot mirror application is adapted to analyze two versions of inodes in the two snapshots and compares the pointers in the inodes. If the two versions of the pointers point to the same block, we know that that block hasn't changed. By extension, if the pointer to an indirect block has not changed, then that indirect block has no changed data, so none of its pointers can have changed, and, thus, none of the data blocks underneath it in the tree have changed. This means that, in a very large file, which is mostly unchanged between two snapshots, the process can skip over/overlook VBN ��pointers�� to each data block in the tree to query whether the VBNs of the data blocks have changed.
The operation of a worker 850 is shown by way of example in FIG. 9. Once a changed inode pair are received by the worker 850, each inode (base and incremental, respectively) 910 and 912 is scanned to determine whether the file offset between respective blocks is a match. In this example, blocks 6 and 7 do not match. The scan then continues down the ��tree�� of blocks 6 and 7, respectively, arriving at underlying indirect blocks 8/9 (920) and 8/10 (922). Again the file offset comparison indicates that blocks 8 both arrive at a common block 930 (and thus have not changed). Conversely, blocks 9 and 10 do not match due to offset differences and point to changed blocks 940 and 942. The changed block 942 and the metadata above can be singled out for transmission to the replicated snapshot on the destination (described below; see also FIG. 8). The tree, in an illustrative embodiment extends four levels in depth, but this procedure may be applied to any number of levels. In addition, the tree may in fact contain several changed branches, requiring the worker to traverse each of the branches in a recursive manner until all changes are identified. Each inode worker, thus provides the changes to the network for transmission in a manner also described below. In particular, new blocks and information about old, deleted blocks are sent to the destination. Likewise, information about modified blocks is sent.
With further reference to FIG. 10, the transmission of changes from the source snapshot to the replicated destination snapshot is described in an overview 1000. As already described, the old and new snapshots present the inode picker 830 with changed inodes corresponding to the qtree or other selected sub-organization of the subject volume. The changed inodes are placed in the queue 840, and then their respective trees are walked for changes by a set of inode workers 850, 852 and 854. The inode workers each send messages 1002, 1004 and 1006 containing the change information to a source pipeline 1010. Note that this pipeline is only an example of a way to implement a mechanism for packaging file system data into a data stream and sending that stream to a network layer. The messages are routed first to a receiver 1012 that collects the messages and sends them on to an assembler 1014 as a group comprising the snapshot change information to be transmitted over the network 318. Again, the ��network�� as described herein should be taken broadly to include anything that facilitates transmission of volume sub-organization (e.g. qtree) change data from a source sub-organization to a destination sub-organization, even where source and destination are on the same file server, volume or, indeed (in the case of rollback as described in the above-incorporated U.S. Pat. application Ser. No. 10/100,879 filed on Mar. 19, 2002 entitled FORMAT FOR TRANSMISSION OF FILE SYSTEM INFORMATION BETWEEN A SOURCE AND A DESTINATION are the same sub-organization at different points in time. An example of a ��network�� used as a path back to the same volume is a loopback. The assembler 1014 generates a specialized format 1020 for transmitting the data stream of information over the network 318 that is predictable and understood by the destination. The networker 1016 takes the assembled data stream and forwards it to a networking layer. This format is typically encapsulated within a reliable networking protocol such as TCP/IP. Encapsulation can be performed by the networking layer, which constructs, for example, TCP/IP packets of the formatted replication data stream
The format 1020 is described further below. In general, its use is predicated upon having a structure that supports multiple protocol attributes (e.g. Unix permissions, NT access control lists (ACLs), multiple file names, NT streams, file type, file-create/modify time, etc.). The format should also identity the data in the stream (i.e. the offset location in a file of specific data or whether files have ��holes�� in the file offset that should remain free). The names of files should also be relayed by the format. More generally, the format should also be independent of the underlying network protocol or device (in the case of a tape or local disk/non-volatile storage) protocol and file system�Xthat is, the information is system ��agnostic,�� and not bound to a particular operating system software, thereby allowing source and destination systems of different vendors to share the information. The format should, thus, be completely self-describing requiring no information outside the data stream. In this manner a source file directory of a first type can be readily translated into destination file directory of a different type. It should also allow extensibility, in that newer improvements to the source or destination operating system should not affect the compatibility of older versions. In particular, a data set (e.g. a new header) that is not recognized by the operating system should be ignored or dealt with in a predictable manner without triggering a system crash or other unwanted system failure (i.e. the stream is backwards compatible). This format should also enable transmission of a description of the whole file system, or a description of only changed blocks/information within any file or directory. In addition, the format should generally minimize network and processor overhead.
The destination pipeline 1030 forwards data and directory information to the main destination snapshot mirror process 1040, which is described in detail below. The destination snapshot mirror process 1040 consists of a directory stage 1042, which builds the new replicated file system directory hierarchy on the destination side based upon the received snapshot changes. To briefly summarize, the directory stage creates, removes and moves files based upon the received formatted information. A map of inodes from the destination to the source is generated and updated. In this manner, inode numbers on the source file system are associated with corresponding (but typically different) inode numbers on the destination file system. Notably, a temporary or ��purgatory�� directory 1050 (described in further detail below) is established to retain any modified or deleted directory entries 1052 until these entries are reused by or removed from the replicated snapshot at the appropriate directory rebuilding stage within the directory stage. In addition, a file stage 1044 of the destination mirror process populates the established files in the directory stage with data based upon information stripped from associated format headers.
The format into which source snapshot changes are organized is shown schematically in FIGS. 11 and 12. In the illustrative embodiment, the format is organized around 4 KB blocks. The header size and arrangement can be widely varied in alternate embodiments, however. There are 4 KB headers (1100 in FIG. 11) that are identified by certain ��header types.�� Basic data stream headers (��data��) are provided for at most every 2 megabytes (2 MB) of changed data. With reference to FIG. 11, the 4 KB standalone header includes three parts, a 1 KB generic part 1102, a 2 KB non-generic part 1104, and an 1 KB expansion part. The expansion part is not used, but is available for later versions.
The generic part 1102 contains an identifier of header type 1110. Standalone header types (i.e. headers not followed by associated data) can indicate a start of the data stream; an end of part one of the data stream; an end of the data stream; a list of deleted files encapsulated in the header; or the relationship of any NT streamdirs. Later versions of Windows NT allow for multiple NT ��streams�� related to particular filenames. A discussion of streams is found in U.S. Pat. application Ser. No. 10/657,573 filed on Sep. 8, 2003, entitled SYSTEM AND METHOD FOR REPRESENTING NAMED DATA STREAMS WITHIN AN ON-DISK STRUCTURE OF A FILE SYSTEM, by Kayuri Patel, et al, the teachings of which are expressly incorporated herein by reference. Also in the generic part 1102 is a checksum 1112 that ensures the header is not corrupted. In addition other data such as a ��checkpoint�� 1114 used by the source and destination to track the progress of replication is provided. By providing a list of header types, the destination can more easily operate in a backwards-compatible mode�Xthat is, a header type that is not recognized by the destination (provided from a newer version of the source) can be more easily ignored, while recognized headers within the limits of the destination version are processed as usual.
FIG. 12 describes the format 1020 of the illustrative replication data stream in further detail. The format of the replicated data stream is headed by a standalone data stream header 1202 of the type ��start of data stream.�� This header contains data in the non-generic part 1104 generated by the source describing the attributes of the data stream.
Next a series of headers and follow-on data in the format 1020 define various ��part 1�� information (1204). Significantly, each directory data set being transmitted is preceded by a basic header with no non-generic data. Only directories that have been modified are transmitted, and they need not arrive in a particular order. Note also that the data from any particular directory need not be contiguous. Each directory entry is loaded into a 4 KB block. Any overflow is loaded into a new 4 KB block. Each directory entry is a header followed by one or more names. The entry describes an inode and the directory names to follow. NT stream directories are also transmitted.
The part 1 format information 1204 also provides ACL information for every file that has an associated ACL. By transmitting the ACLs before their associated file data, the destination can set ACLs before file data is written. ACLs are transmitted in a ��regular�� file format. Deleted file information (described above) is sent with such information included in the non-generic part 1104 of one or more standalone headers (if any). By sending this information in advance, the directory tree builder can differentiate between moves and deletes.
Once various part 1 information 1204 is transmitted, the format calls for an ��end of part 1 of the data stream�� header 1206. This is a basic header having no data in the non-generic part 1104. This header tells the destination that part 1 is complete and to now expect file data.
After the part 1 information, the format presents the file and stream data 1208. A basic header 1210 for every 2 MB or less of changed data in a file is provided, followed by the file data 1212 itself. The files comprising the data need not be written in a particular order, nor must the data be contiguous. In addition, referring to the header in FIG. 11, the basic header includes a block numbers data structure 1130, associated with the non-generic part 1104 works in conjunction with the ��holes array�� 1132 within (in this example) the generic part 1102. The holes array denotes empty space. This structure, in essence, provides the mapping from the holes array to corresponding blocks in the file. This structure instructs the destination where to write data blocks or holes.
Finally, the end of the replicated data stream format 1020 is marked by a footer 1220 consisting of standalone header of the type ��end of data stream.�� This header has no specific data in its non-generic part 1104 (FIG. 11).
Next the directory stage undertakes a tree cleaning process (1312). This step removes all directory entries form the replicated snapshot directory 1330 that have been changed on the source snapshot. The data stream format (1020) indicates whether a directory entry has been added or removed. In fact, directory entries from the base version of the directory and directory entries from the incremental version of the directory are both present in the format. The destination snapshot mirror application converts the formatted data stream into a destination directory format in which each entry that includes an inode number, a list of relative names (e.g. various multi-protocol names) and a ��create�� or ��delete�� value. In general each file also has associated therewith a generation number. The inode number and the generation number together form a tuple used to directly access a file within the file system (on both the source and the destination). The source sends this tuple information to the destination within the format and the appropriate tuple is stored on the destination system. Generation numbers that are out of date with respect to existing destination files indicate that the file has been deleted on the source. The use of generation numbers is described further below.
The destination processes base directory entries as removals and incremental directory entries as additions. A file which has been moved or renamed is processed as a delete (from the old directory or from the old name), then as an add (to the new directory or with a new name). Any directory entries 1052 that are deleted, or otherwise modified, are moved temporarily to the temporary or ��purgatory�� directory, and are not accessible in this location by users. The purgatory directory allows modified entries to be, in essence, ��moved to the side�� rather than completely removed as the active file system's directory tree is worked on. The purgatory directory entries, themselves point to data, and thus prevent the data from becoming deleted or losing a link to a directory altogether.
For efficiency, the source side depends upon inode numbers and directory blocks rather than pathnames. In general, a file in the replicated directory tree (a qtree in this example) on the destination cannot expect to receive the same inode number as the corresponding file has used on the source (although it is possible). As such, an inode map is established in the destination. This map 1400, shown generally in FIG. 14, enables the source to relate each file on the source to the destination. The mapping is based generally upon file offsets. For example a received source block having ��offset 20 KB in inode 877�� maps to the block at offset 20 KB in replicated destination inode 9912. The block can then be written to the appropriate offset in the destination file.
By maintaining the source generation number, the destination can determine if a file has been modified or deleted on the source (and its source associated inode reallocated), as the source generation number is incremented upwardly with respect to the stored destination. When the source notifies the destination that an inode has been modified, it sends the tuple to the destination. This tuple uniquely identifies the inode on the source system. Each time the source indicates that an entirely new file or directory has to be created (e.g. ��create��) the destination file system creates that file. When the file is created, the destination registers data as a new entry in its inode map 1400. Each time the source indicates that an existing file or directory needs to be deleted, the destination obliterates that file, and then clears the entry in the inode map. Notably, when a file is modified, the source only sends the tuple and the data to be applied. The destination loads the source inode's entry from the inode map. If the source generation number matches, then it knows that the file already exists on the destination and needs to be modified. The destination uses the tuple recorded in the inode map to load the destination inode. Finally, it can apply the file modifications by using the inode.
As part of the tree building process reused entries are ��moved�� back from the purgatory directory to the replicated snapshot directory 1330. Traditionally, a move of a file requires knowledge of the name of the moved file and the name of the file it is being moved to. The original name of the moved file may not be easily available in the purgatory directory. In addition, a full move would require two directories (purgatory and replicated snapshot) to be modified implicating additional overhead.
The new directory tree may contain files with no data or old data. When the ��end of part 1�� format header is read, the destination mirror process 1040 enters the file stage 1044 in which snapshot data files 1340 referenced by the directory tree are populated with data (e.g. change data). FIG. 15 shows a simplified procedure 1500 for writing file data 1502 received from the source. In general, each (up to) 2 MB of data in 4 KB blocks arrives with corresponding source inode numbers. The inode map 1400 is consulted for corresponding entries 1402. Appropriate offsets 1504 are derived for the data, and it is written into predetermined empty destination snapshot data files 1340.
At the end of both the directory stage 1042 and data stage 1044, when all directory and file data have been processed, and the data stream transfer from the source is complete, the new replicated snapshot is exposed atomically to the user. At this time the contents of the purgatory directory 1050 (which includes any entries that have not be ��moved�� back into the rebuilt tree) is deleted.
It should be noted that the initial creation (the ��level zero�� transfer) of the replicated snapshot on the destination follows the general procedures discussed above. The difference between a level zero transfer and a regular update is that there is no base snapshot; so the comparisons always process information in the incremental snapshot as additions and creates rather than modifications. The destination mirror application starts tree building by processing any directories already known to it. The initial directory established in the destination is simply the root directory of the replicated snapshot (the qtree root). A destination root exists on the inode map. The source eventually transmits a root (other files received may be buffered until the root arrives), and the root is mapped to the existing destination root. Files referenced in the root are then mapped in turn in a ��create�� process as they are received and read by the destination. Eventually, the entire directory is created, and then the data files are populated. After this, a replica file system is complete.
As described above, in reference to FIG. 10, a source utilizes an inode picker process 830 and a set of inode workers 850, 852, and 854 detecting changes in inodes and blocks of a snapshot. These changes are then collected by the workers, and sent to a pipeline for transmission to the destination file system where a source file system snapshot pair is replicated by the above-described destination mirror application process. The transmission of data occurs via a generalized ��network�� 318, which can include loopback mechanisms and other techniques that can provide the change data stream to the same volume or even the same qtree/sub-organization (in a ��roll back�� of the replicated snapshot for example�Xas taught in above-incorporated U.S. Pat. application Ser. No. 10/100,950 filed on Mar. 19, 2002, entitled SYSTEM AND METHOD FOR ASYNCHRONOUS MIRRORING OF SNAPSHOTS AT A DESTINATION USING A PURGATORY DIRECTORY AND INODE MAPPING).
This checkpointing procedure 1600 is shown in detail in FIG. 16, with reference also to FIGS. 8�V10. Initially, in step 1605, the processing by the inode workers is temporarily halted (or otherwise ��benchmarked�� at a fixed point in time), thereby pausing the scan and collection of snapshot changes at the source. The procedure then writes the inode that is on top of the inode queue 840 to a top-of-queue registry (step 1610). This registry, described further below, is used to store state information relating to the state of the inode workers and inode picker process at the time the given checkpoint is created. Next, the status of each inode worker is written to the top-of-queue registry in step 1615. This status information includes, in the illustrative embodiment, the number of the inode that the inode worker is currently working on and the volume block number presently being checked. The registry is then associated with a new checkpoint number in step 1620. In this embodiment checkpoint numbers are provided as a sequentially increasing monotonic number set (e.g. ��checkpoint nos. 1, 2, 3 . . .��), used to identify successive synchronization points in the overall data stream transfer session (e.g. at least one full update of the replicated destination file system.
The destination receives and acts upon the checkpoint numbers packaged in the formatted data stream 1020 while receiving and performing the destination process on the stream. In the illustrative embodiment, the destination stores the checkpoint number for the last segment of the transfer that has been fully committed to persistent storage. For example, if all data up to ��checkpoint number 9�� has been written to disk, the destination stores ��checkpoint number 9�� for use during the novel restart procedure, which is now further described.
By way of example, if the destination has written all of the data up to ��checkpoint number 7�� plus some of the data between ��checkpoint number 7�� and ��checkpoint number 8,�� then if the loss of communication or other error occurs, the destination would transfer back to the source an alert stating that it has completed ��checkpoint number 7.�� After the destination alerts the source that is completed ��checkpoint number 7,�� the destination has an expectation that it will receive retransmission of all data starting no later than the end of the ��checkpoint number 7�� segment. The source can restart from any previous checkpoint (e.g., ��checkpoint number 4��); however, the closer that the source can begin to the checkpoint number sent by the destination, the less work needs to be redone. Thus, for example, if the destination had sent ��checkpoint number 7��, but the source begins at ��checkpoint number 4�� then the data between ��checkpoint number 4�� and ��checkpoint number 7�� will need to be rewritten.
After the restart procedure 1800 is performed, the transmission of changes from the source to the destination can continue with both the source and destination having agreed on a mutual starting point, namely the selected checkpoint transmitted by the destination. Note that the destination may receive change data after the restart procedure that the destination had already committed to persistent storage, i.e. a change that was written after the selected checkpoint but before the error condition requiring a restart. The destination simply rewrites the change data to its persistent storage using the methodology described above. This rewriting of change data is possible because the data stream sent from the source to the destination specifies the location in the file where the data needs to be written. Typical replication software simply appends data to a destination side file. By sending the location in the file where the change is to be written, the destination can accommodate the need to ��redo�� work by overwriting already written data.
�M�Q�ޥ� �ޥΪ��M�Q�ӽФ���o�G��� �ӽЪ��M�Q�W��US45702171983�~3��28��1986�~2��11��Allen; Bruce S.Man machine interfaceUS51631311989�~9��8��1992�~11��10��Auspex Systems, Inc.Parallel i/o network file server architectureUS52029791992�~6��26��1993�~4��13��Thinking Machines CorporationStorage system using multiple independently mechanically-driven storage unitsUS52789791990�~12��20��1994�~1��11��International Business Machines Corp.Version management system using pointers shared by a plurality of versions for indicating active lines of a versionUS53554531992�~10��13��1994�~10��11��Auspex Systems, Inc.Parallel I/O network file server architectureUS54855791994�~4��8��1996�~1��16��Auspex Systems, Inc.Multiple facility operating system architectureUS58023661994�~10��11��1998�~9��1��Auspex Systems, Inc.Parallel I/O network file server architectureUS58192921995�~5��31��1998�~10��6��Network Appliance, Inc.Method for maintaining consistent states of a file system and for creating user-accessible read-only copies of a file systemUS59319181997�~7��30��1999�~8��3��Auspex Systems, Inc.Parallel I/O network file server architectureUS59419721997�~12��31��1999�~8��24��Crossroads Systems, Inc.Storage router and method for providing virtual local storageUS59639621998�~6��30��1999�~10��5��Network Appliance, Inc.Write anywhere file-system layoutUS5987506 *1997�~5��2��1999�~11��16��Mangosoft CorporationRemote access and geographically distributed computers in a globally addressable storage environmentUS60650371995�~6��7��2000�~5��16��Auspex Systems, Inc.Multiple software-facility component operating system for co-operative processor control within a multiprocessor computer systemUS62893561998�~9��14��2001�~9��11��Network Appliance, Inc.Write anywhere file-system layoutUS64250352001�~9��27��2002�~7��23��Crossroads Systems, Inc.Storage router and method for providing virtual local storageUS6662196 *2001�~3��16��2003�~12��9��Iti, Inc.Collision avoidance in bidirectional database replicationUS20030070043 *2002�~3��7��2003�~4��10��Jeffrey Vernon MerkeyHigh speed fault tolerant storage systemsUS20030158861 *2002�~2��15��2003�~8��21��International Business Machines CorporationProviding a snapshot of a subset of a file systemUS20030158863 *2002�~2��15��2003�~8��21��International Business Machines CorporationFile system snapshot with ditto address featureUS20030159007 *2002�~2��15��2003�~8��21��International Business Machines CorporationDeferred copy-on-write of a snapshot* �Ѽf�d�H��ޥ��D�M�Q�ޥ��ѦҤ��m1Akyurek, Sedat, Placing Replicated Data to Reduce Seek Delays, Department of Computer Science, University of Maryland, UMIACS-TR-91-121, CS-TR-2746, Aug. 1991.2Bitton, Dina, Disk Shadowing, Proceedings of the 14<SUP>th </SUP>VLDB Conference, LA, CA 1988.3Chaudhuri, Surajit, et al., Self-Tuning Technology in Microsoft SQL Server, Data Engineering Journal 22, Feb. 1999 pp. 20-27.4Chutani, Sailesh, et al., The Episode File System, In Proceedings of the USENIX Winter 1992.5Coyne, Robert A., et al., Storage Systems for National Information Assets, Proc. Supercomputing 92, Minneapolis, Nov. 1992, pp. 626-633.6Finlayson, Ross S., et al., Log Files: An Extended File Service Exploiting Write-Once Storage Department of Computer Science, Stanford University, Report No. STAN-CS-87-1177, Sep. 1987.7Gray, Jim, et al., The Recovery Manager of the System R Database Manager, ACM Computing Surveys, (13)2:223-242 1981.8Hecht, Matthew S., et al., Shadowed Management of Free Disk Pages with a Linked List, ACM Transactions on Database Systems, 8/4, Dec. 1983, pp. 503-514.9Hitz, David, et al., TR3002 File System Design for an NFS File Server Appliance, 1-10, Network Appliance, Inc. Sunnvyale, CA, USA.10Howard, John H., An Overview of the Andrew File System, Carnegie Mellon University, CMU-ITC-88-062 1988.11Howard, John, H. et al., Scale and Performance in a Distributed File System, ACM Trans. Computer System, 6(1), Feb. 1988 pp. 51-81.12Howard, John, H. et al., Scale and Performance in a Distributed File System, Carnegie Mellon University, CMU-ITC-87-068, Aug. 1987.13Kazar, Michael L., et al., DEcorum File System Architectural Overview, USENIX Summer Conference, Anaheim, California, 1990.14Kazar, Michael Leon, Synchronization and Caching Issues in the Andrew File System, Carnegie Mellon University, CMU-ITC-88-063.15Kemper, Alfons, et al., Performance Tuning for SAP R/3, Data Engineering Journal 22, Feb. 1999 pp. 33-40.16Kent, Jack et al., Optimizing Shadow Recovery Algorithms, IEEE Transactions on Software Engineering, 14(2): 155-168 , Feb. 1988.17Kistler, et al., Disconnected Operation in the Coda File System, ACM Transactions on Computer Systems, vol. 10, No. 1, Feb. 1992, pp. 3-25.18Lorie, Raymond, A. Physical Integrity in a Large Segmented Database, ACM Trans. Database Syst., vol. 2, Mar. 1977, pp. 91-104.19Ousterhout, John et al., Beating the I/O Bottleneck: A Case for Log-Structured File Systems, Technical Report, Computer Science Division, Electrical Engineering and Computer Sciences, University of California at Berkeley, Oct. 30, 1988.20Patterson, D., et al., A Case for Redundant Arrays of Inexpensive Disks (RAID), SIGMOD International Conference on Management of Data, Chicago, IL, USA, Jun. 1-3, 1988, SIGMOD Record (17)3:109-Sep. 16, 1988.21Patterson, D., et al., A Case for Redundant Arrays of Inexpensive Disks (RAID), Technical Report, CSD-87-391, Computer Science Division, Electrical Engineering and Computer Sciences, University of California at Berkeley 1987.22Peterson, Zachary Nathaniel Joseph, Data Placement for Copy-on-Write Using Virtual Contiguity, University of CA, Santa Cruz, Master's Thesis for the Department of Science in Computer Science, Sep. 2002.23Quinlan, Sean, A Cached WORM File System, Software-Practice and Experience, 21(12):1289-1299 1991.24Rosenblum, Mendel, et al. The Design and Implementation of a Log-Structured File System Jul. 24, 1991 pp. 1-15.25Rosenblum, Mendel, et al., The Design and Implementation of a Log-Structured File System, In Proceedings of ACM Transactions on Computer Systems, (10)1:26-52, Feb. 1992.26Rosenblum, Mendel, et al., The LFS Storage Manager, Computer Science Division, Electrical Engineering And Computer Sciences, Univ. of CA, presented at Summer '90 USENIX Technical Conference, Anaheim, CA Jun. 1990.27Rosenblum, Mendel, The Design and Implementation of a Log-Structured File System, 1992, pp. 1-93.28Schiefer, Berni, et al., DB2 Universal Database Performance Tuning, Data Engineering Journal 22, Feb. 1999 pp. 12-19.29Seltzer, Margo I., et al., Journaling Versus Soft Updates: Asynchronous Meta-Data Protection in File Systems, Proceedings of 200 USENIX Annual Technical Conference, Jun. 18-23, 2000.30Shasha, Dennis, Tuning Time Series Queries in Finance: Case Studies and Recommendations, Data Engineering Journal 22, Feb. 1999 pp. 41-47.31Sidebotham, Bob, Volumes: The Andrew File System Data Structuring Primitive, EEUG Conference Proceedings, Manchester, UK, Autumn 1986.32Subramanian, Muralidhar, et al., Performance Challenges in Object-Relational DBMSs, Data Engineering Journal 22, Feb. 1999 pp. 28-32.33U.S. Appl. No. 10/100,434, Chen et al.34U.S. Appl. No. 10/100,879, Manley et al.35U.S. Appl. No. 10/100,945, Manley et al.36U.S. Appl. No. 10/100,950, Manley et al.37U.S. Appl. No. 10/100,967, Federwisch et al.38Weikum, Gerhard, et al., Towards Self-Tuning Memory Management for Data Servers, Data Engineering Journal 22, Feb. 1999 pp. 3-11.39West, Michael, et al. The ITC Distributed File System: Prototype and Experience, Carnegie-Mellon University, Technical Report CMU-ITC-040, Mar. 1985.�Q�H�U�M�Q�ޥ� �ޥΥ��M�Q�ӽФ���o�G��� �ӽЪ��M�Q�W��US7162662 *2004�~2��12��2007�~1��9��Network Appliance, Inc.System and method for fault-tolerant synchronization of replica updates for fixed persistent consistency point image consumptionUS7269706 *2004�~12��9��2007�~9��11��International Business Machines CorporationAdaptive incremental checkpointingUS7343518 *2004�~6��23��2008�~3��11��Intel CorporationMethod for data backup of computing platforms that are occasionally connectedUS7363537 *2006�~12��15��2008�~4��22��Network Appliance, Inc.System and method for fault-tolerant synchronization of replica updates for fixed persistent consistency point image consumptionUS7370025 *2002�~12��17��2008�~5��6��Symantec Operating CorporationSystem and method for providing access to replicated dataUS7398285 *2003�~7��30��2008�~7��8��International Business Machines CorporationApparatus and system for asynchronous replication of a hierarchically-indexed data storeUS7404051 *2005�~4��18��2008�~7��22��Hitachi, Ltd.Method for replicating snapshot volumes between storage systemsUS7440965 *2004�~2��11��2008�~10��21��Network Appliance, Inc.Method and system for generating and restoring a backup imageUS7440966 *2004�~2��12��2008�~10��21��International Business Machines CorporationMethod and apparatus for file system snapshot persistenceUS7519870 *2004�~6��8��2009�~4��14��Asempra Technologies, Inc.Method and system for no downtime, initial data upload for real-time, continuous data protectionUS7565661 *2004�~5��10��2009�~7��21��Siew Yong Sim-TangMethod and system for real-time event journaling to provide enterprise data servicesUS75906332005�~10��18��2009�~9��15��Netapp, Inc.Format for transmitting file system information between a source and a destinationUS7603391 *2006�~1��20��2009�~10��13��Netapp, Inc.System and method for determining changes in two snapshots and for transmitting changes to a destination snapshotUS76137502006�~8��2��2009�~11��3��Microsoft CorporationCreating frequent application-consistent backups efficientlyUS76172172006�~1��26��2009�~11��10��Netapp, Inc.System and method for redirecting access to a remote mirrored snapshotUS76441092006�~1��9��2010�~1��5��Netapp, Inc.System and method for storage of snapshot metadata in a remote fileUS76851782006�~10��31��2010�~3��23��Netapp, Inc.System and method for examining client generated content stored on a data container exported by a storage systemUS76853882008�~1��25��2010�~3��23��Netapp, Inc.Method and system for single pass volume scanning for multiple destination mirroringUS77026622007�~5��16��2010�~4��20��International Business Machines CorporationMethod and system for handling reallocated blocks in a file systemUS77028692008�~12��8��2010�~4��20��Netapp, Inc.System and method for verifying the consistency of mirrored data setsUS7707165 *2004�~12��9��2010�~4��27��Netapp, Inc.System and method for managing data versions in a file systemUS77208012004�~12��17��2010�~5��18��Netapp, Inc.System and method for supporting asynchronous data replication with very short update intervalsUS77349512006�~3��20��2010�~6��8��Netapp, Inc.System and method for data protection management in a logical namespace of a storage system environmentUS7769717 *2006�~4��10��2010�~8��3��Netapp, Inc.System and method for checkpointing and restarting an asynchronous transfer of data between a source and destination snapshotUS77697232006�~4��28��2010�~8��3��Netapp, Inc.System and method for providing continuous data protectionUS77745442006�~11��15��2010�~8��10��Netapp, Inc.Reliable disk ownership changesUS7792983 *2007�~7��31��2010�~9��7��International Business Machines CorporationMethod and apparatus for checkpoint and restart of pseudo terminalsUS78096922007�~1��31��2010�~10��5��Network Appliance, Inc.Method and system for generating and restoring a backup imageUS78182992009�~9��2��2010�~10��19��Netapp, Inc.System and method for determining changes in two snapshots and for transmitting changes to a destination snapshotUS7822728 *2006�~11��8��2010�~10��26��Emc CorporationMetadata pipelining and optimization in a file serverUS7849450 *2005�~1��28��2010�~12��7��Intel CorporationDevices, methods and computer program products for reverse execution of a simulationUS78654752007�~9��12��2011�~1��4��Netapp, Inc.Mechanism for converting one type of mirror to another type of mirror on a storage system without transferring dataUS7865485 *2003�~9��23��2011�~1��4��Emc CorporationMulti-threaded write interface and methods for increasing the single file read and write throughput of a file serverUS79211102004�~2��11��2011�~4��5��Netapp, Inc.System and method for comparing data setsUS7925749 *2007�~4��24��2011�~4��12��Netapp, Inc.System and method for transparent data replication over migrating virtual serversUS79304982008�~6��10��2011�~4��19��Hitachi, Ltd.Method for replicating snapshot volumes between storage systemsUS79498432009�~12��7��2011�~5��24��Netapp, Inc.Method and system for single pass volume scanning for multiple destination mirroringUS79500192007�~5��21��2011�~5��24��International Business Machines CorporationMethod and apparatus for checkpoint and restarting a stream in a software partitionUS7984016 *2008�~5��28��2011�~7��19��International Business Machines CorporationMethod for asynchronous replication of a hierarchically-indexed data storeUS79917912009�~10��8��2011�~8��2��Netapp, Inc.System and method for redirecting access to a remote mirrored snapshotUS7996361 *2003�~6��30��2011�~8��9��Symantec Operating CorporationMethod and system of providing replica files within a filesetUS80010902009�~11��30��2011�~8��16��Netapp, Inc.System and method for examining client generated content stored on a data container exported by a storage systemUS80463322010�~5��3��2011�~10��25��Network Appliance, Inc.Method and system for generating and restoring a backup imageUS8060889 *2009�~6��22��2011�~11��15��Quest Software, Inc.Method and system for real-time event journaling to provide enterprise data servicesUS80691492011�~6��8��2011�~11��29��Netapp, Inc.System and method for redirecting access to a remote mirrored snapshotUS81036252008�~4��28��2012�~1��24��Symantec Operating CorporationSystem and method for providing access to replicated dataUS81610072010�~1��27��2012�~4��17��Netapp, Inc.System and method for supporting asynchronous data replication with very short update intervalsUS81906572009�~9��28��2012�~5��29��International Business Machines CorporationMethod and system for handling reallocated blocks in a file systemUS82761272010�~11��8��2012�~9��25��Intel CorporationDevices, methods and computer program products for reverse execution of a simulationUS83017912008�~5��30��2012�~10��30��Netapp, Inc.System and method for non-disruptive check of a mirrorUS20120271799 *2012�~6��26��2012�~10��25��Bluearc Uk LimitedApparatus and Method for Hardware-Based File SystemUS20120303579 *2012�~8��6��2012�~11��29��International Business Machines CorporationConcurrent checkpointing and modifications in a transactional clustered file systemUS20120303683 *2012�~8��6��2012�~11��29��International Business Machines CorporationConcurrent transactional checkpoints in a clustered file systemCN101460934B2007�~4��26��2011�~10��19���L软���qCreating frequent application-consistent backups efficientlyEP2118781A1 *2008�~3��5��2009�~11��18��Appassure Software, Inc.A method and apparatus for efficiently merging, storing and retrieving incremental dataWO2007139647A1 *2007�~4��26��2007�~12��6��Microsoft CorporationCreating frequent application-consistent backups efficiently* �Ѽf�d�H��ޥ����� ���M�Q������1/1, 707/E17.7, 707/999.205��ڱM�Q������G06F17/30 �X�@����G06F17/30174, H04L29/08117, H04L29/08549, G06F11/2082, G06F17/30212, G06F11/1464, G06F11/1451, G06F17/30088, G06F2201/82, H04L29/0854 �ڬw������G06F11/14A10P4, G06F11/14A10D2, G06F17/30F7Y, G06F17/30F8D3, G06F17/30F1S, H04L29/08N9R, H04L29/08N5, H04L29/08N9S������l�Ϥ�Google ���� - Sitemap - USPTO �j�q�U�� - ���p�v�F�� - �A�ȱ�� - ���� Google �M�Q - �N���^�X��ƬO�Ѭ��ӷ~�M�Q��Ʈw (IFI CLAIMS Patent Services) ����©2012 Google