Snapshot processing method and device based on blind area snapshot

Abstract

The invention provides a snapshot processing method and device based on a blind area snapshot, and relates to the technical field of snapshot processing based on the blind area snap.The snapshot processing method based on the blind area snapshot can effectively avoid damage to a snapshot chain caused by snapshot rollback operation, and the snapshot processing efficiency is improved. And the integrity of the dependency relationship among the snapshot versions is kept, so that the reliability and the consistency of the distributed storage system in the data recovery process are improved.

Description

Technical Field

[0001] This invention relates to the field of snapshot management and rollback mechanism optimization technology for distributed storage systems, and particularly to a snapshot processing method, apparatus, electronic device, and computer-readable storage medium based on blind zone snapshots. Background Technology

[0002] Distributed storage systems, as core infrastructure of cloud computing and data centers, are widely used in large-scale data management, virtualization platforms, and enterprise-level storage services. Among related technologies, a highly available and scalable storage architecture is built through the collaborative operation of object storage devices (OSDs), placement groups (PGs), and metadata management. Specifically, this system covers the entire process from data writing and snapshot generation to version rollback, including key stages such as object cloning, forward relationship maintenance, and snapshot chain construction. With the development of storage pool append-only technology, snapshot operations have gradually evolved into a fine-grained management approach based on object information (OI) and clone hierarchy structure (clone_list) to improve storage efficiency and data consistency.

[0003] However, existing snapshot rollback schemes directly employ version tracing mechanisms based on snapshot chains, typically copying only basic information during object cloning without fully replicating forward relationships. This can lead to the snapshot chain being disrupted during rollback operations. Specifically, when the system performs a rollback, the dependencies between existing snapshot versions may become invalid, causing subsequent snapshots to be unable to correctly access historical data fragments, affecting the reliability and consistency of data recovery. Furthermore, traditional solutions require traversing the snapshot chain layer by layer to find dependent objects when handling read requests, resulting in high time complexity and storage overhead, making it difficult to meet the needs of large-scale distributed systems for efficient and stable snapshot management. Summary of the Invention

[0004] The present invention aims to at least partially solve one of the technical problems in the related art.

[0005] Therefore, the first objective of this invention is to propose a snapshot processing method based on blind zone snapshots.

[0006] The second objective of this invention is to provide an apparatus.

[0007] The third objective of this invention is to provide an electronic device.

[0008] The fourth objective of this invention is to provide a computer-readable storage medium.

[0009] The fifth objective of this invention is to provide a computer program product.

[0010] To achieve the above objectives, a first aspect of the present invention proposes a snapshot processing method based on blind zone snapshots, comprising: S1, determining the hierarchical clone object to which the target rollback clone object belongs based on the clone_list and the rollback target snapshot ID in the OI of the header object, and obtaining the OI of the hierarchical clone object; S2, calculating the target rollback clone object based on the clone_overlap information in the OI of the hierarchical clone object, and deleting the forward relationship of the header object; S3, generating a blind zone snapshot, wherein the key of the blind zone snapshot is the latest snapshot ID of the current object, and the value is the target snapshot ID to which it is rolled back; S4, modifying the clone_overlap information in the OI of the header object according to the generated blind zone snapshot, and assembling the forward relationship and the OI information into a key-value format and sending it to a distributed key-value storage for storage.

[0011] In one embodiment of the present invention, the step of determining the hierarchical clone object to which the target rollback clone object belongs based on the clone_list and the rollback target snapshot ID in the OI of the header object, and obtaining the OI of the hierarchical clone object, further includes: S11, traversing the hierarchical clone object list recorded in the clone_list, matching the rollback target snapshot ID with the snapshot ID range of each hierarchical clone object to determine the hierarchical clone object to which the target rollback clone object belongs; S12, extracting its OI information from the matched hierarchical clone object, and verifying the completeness and validity of the OI information to ensure data consistency in subsequent operations.

[0012] In one embodiment of the present invention, the step of calculating the target rollback clone object and deleting the positive relationship of the header object based on the clone_overlap information in the hierarchical clone object OI further includes: S21, determining the starting position and length of the positive relationship data segment to be rolled back according to the dependency range of the current clone object on the previous clone object recorded in clone_overlap; S22, marking and deleting the positive relationship data segment in the header object corresponding to the rollback target snapshot id, and retaining the positive relationship data that has not been affected by the rollback, so as to reduce the risk of data loss.

[0013] In one embodiment of the present invention, the step of generating a blind snapshot, wherein the key of the blind snapshot is the latest snapshot ID of the current object and the value is the target snapshot ID to which it is rolled back, further includes: S31, setting the key of the blind snapshot to the latest snapshot ID of the header object before the rollback, setting the value to the snapshot ID to which the actual rollback points, and storing the mapping relationship in the OI of the header object; S32, assigning a unique identifier to each blind snapshot and establishing an index in the distributed key-value storage so that subsequent read operations can quickly locate the dependency relationship.

[0014] In one embodiment of the present invention, the method further includes: S5, searching for the corresponding hierarchical clone object from the clone_list in the header object OI according to the snapshot ID carried in the read request, and determining the dependent object of the target data fragment based on the clone_overlap information of the hierarchical clone object, so as to support the read operation of the snapshot object.

[0015] To achieve the above objectives, a second aspect of the present invention provides a snapshot processing apparatus based on blind zone snapshots, comprising: a hierarchical object determination module, configured to determine the hierarchical clone object to which the target rollback clone object belongs based on the clone_list and the rollback target snapshot ID in the OI of the header object, and obtain the OI of the hierarchical clone object; a forward relationship processing module, configured to calculate the target rollback clone object based on the clone_overlap information in the OI of the hierarchical clone object, and delete the forward relationship of the header object; a blind zone snapshot generation module, configured to generate a blind zone snapshot, wherein the key of the blind zone snapshot is the latest snapshot ID of the current object, and the value is the target snapshot ID to which it is rolled back; and an information assembly and storage module, configured to modify the clone_overlap information in the OI of the header object based on the generated blind zone snapshot, and assemble the forward relationship and OI information into a key-value format and send it to a distributed key-value storage for storage.

[0016] In one embodiment of the present invention, the layered object determination module is further configured to: traverse the list of layered clone objects recorded in clone_list, match the target rollback snapshot ID with the snapshot ID range of each layered clone object, and determine the layered clone object where the target rollback clone object is located; extract the OI information from the matched layered clone object, and verify the integrity and validity of the OI information to ensure data consistency in subsequent operations.

[0017] In one embodiment of the present invention, the positive relationship processing module is further configured to: determine the starting position and length of the positive relationship data segment that needs to be rolled back based on the dependency range of the current clone object on the previous clone object recorded in clone_overlap; mark and delete the positive relationship data segment in the header object corresponding to the rollback target snapshot id, and retain the positive relationship data that has not been affected by the rollback, so as to reduce the risk of data loss.

[0018] In one embodiment of the present invention, the blind snapshot generation module is further configured to: set the key of the blind snapshot to the latest snapshot ID of the header object before rollback, set the value to the snapshot ID to which the actual rollback points, and store the mapping relationship in the OI of the header object; assign a unique identifier to each blind snapshot and establish an index in the distributed key-value storage so that subsequent read operations can quickly locate the dependency relationship.

[0019] In one embodiment of the present invention, it further includes: a read support module, configured to search for the corresponding hierarchical clone object from the clone_list in the header object OI according to the snapshot ID carried in the read request, and determine the dependent object of the target data fragment based on the clone_overlap information of the hierarchical clone object, so as to support the read operation of the snapshot object.

[0020] To achieve the above objectives, a third aspect of the present invention provides an electronic device, comprising: a processor, and a memory communicatively connected to the processor; The memory stores computer-executed instructions; The processor executes computer execution instructions stored in the memory to implement the method as described in any one of the first aspects.

[0021] To achieve the above objectives, a fourth aspect of the present invention provides a computer-readable storage medium storing computer-executable instructions, which, when executed by a processor, are used to implement the method as described in any one of the first aspects.

[0022] To achieve the above objectives, a fifth aspect of the present invention provides a computer program product that, when executed by a processor, implements the method described in any one of the first aspects.

[0023] The methods, apparatus, electronic devices, and computer-readable storage media of the present invention can effectively prevent snapshot rollback operations from damaging the snapshot chain, maintain the integrity of dependencies between snapshot versions, and thus improve system data consistency and reliability.

[0024] Additional aspects and advantages of the invention will be set forth in part in the description which follows, and in part will be obvious from the description, or may be learned by practice of the invention. Attached Figure Description

[0025] The above and / or additional aspects and advantages of the present invention will become apparent and readily understood from the following description of the embodiments taken in conjunction with the accompanying drawings, wherein: Figure 1 This is a schematic flowchart of a snapshot processing method based on blind zone snapshots provided in an embodiment of the present invention; Figure 2 This is a schematic diagram of a snapshot processing device based on blind zone snapshots provided in an embodiment of the present invention. Detailed Implementation

[0026] Embodiments of the present invention are described in detail below, examples of which are illustrated in the accompanying drawings, wherein the same or similar reference numerals denote the same or similar elements or elements having the same or similar functions throughout. The embodiments described below with reference to the accompanying drawings are exemplary and intended to explain the present invention, and should not be construed as limiting the present invention.

[0027] To address this issue, embodiments of the present invention provide a snapshot processing method based on blind zone snapshots. Figure 1 This is a flowchart of a snapshot processing method based on blind zone snapshots according to an embodiment of the present invention.

[0028] like Figure 1 As shown, the snapshot processing method based on blind spot snapshots includes the following steps: S1. Based on the clone_list and rollback target snapshot id in the OI of the header object, determine the hierarchical clone object to which the target rollback clone object belongs, and obtain the OI of that hierarchical clone object.

[0029] Specifically, in some implementations, this step determines the hierarchical clone object to which the target rollback clone object belongs by parsing the clone_list field in the header object's OI (Object Information) structure and the specified rollback target snapshot ID, and further obtains the OI information of that hierarchical clone object. Specifically, clone_list is an ordered list recording the clone objects of the header object under different snapshot versions and their corresponding snapshot IDs. During the rollback operation, the system first traverses this list, determining the position of the target clone object in the hierarchical structure by comparing the snapshot ID of each clone object with the target rollback snapshot ID. Further, the system traces upwards to the corresponding hierarchical clone object through the parent relationship of the clone object and reads the OI information of that hierarchical clone object from the distributed metadata storage.

[0030] From a parameter perspective, the clone_list is typically stored as an array or linked list, with each element containing metadata such as snapshot ID, clone object ID, and timestamp. The target snapshot ID for rollback must conform to the system-defined snapshot naming convention (such as UUID or an incrementing integer identifier) ​​and must have a valid mapping in the clone_list. Furthermore, the system supports accelerating the location of the target snapshot through binary search or hash indexing, with time complexity controlled within the range of O(log n) or O(1), significantly improving rollback efficiency.

[0031] In application scenarios, this step is commonly used in snapshot rollback processes in distributed storage systems, especially under Multi-Version Concurrency Control (MVCC) mechanisms, to ensure that rollback operations do not disrupt the integrity of the snapshot chain. Through this step, the system can quickly identify the dependency structure of the target snapshot, providing basic data support for subsequent forward relationship reconstruction and blind zone snapshot generation.

[0032] The technical advantage of this step is that it avoids the snapshot chain breakage problem caused by rollback in traditional solutions, ensuring that the system can still maintain data version traceability and consistency after rollback. At the same time, by acquiring the object's OI through hierarchical cloning, the system can achieve precise control over data dependencies, thereby improving the reliability and performance of snapshot processing.

[0033] Furthermore, S1 includes: S11, iterate through the list of layered clone objects recorded in clone_list, match the target rollback snapshot ID with the snapshot ID range of each layered clone object, and determine the layered clone object where the target rollback clone object is located.

[0034] Specifically, in some implementations, traversing the hierarchical clone object list recorded in `clone_list` and matching it with the snapshot ID range of each hierarchical clone object based on the target rollback snapshot ID is one of the key steps in the snapshot rollback process of this invention. The core technical principle of this step lies in maintaining the object's `clone_list` structure to achieve ordered access to each hierarchical clone object in the snapshot chain, and combining the `clone_overlap` field with the blind zone snapshot structure to quickly locate the clone object level involved in the target rollback operation.

[0035] In the specific implementation, `clone_list` is an ordered list that records hierarchical clone object information for objects under different snapshot versions. Each clone object contains its corresponding snapshot ID range (e.g., [start_id, end_id]) and OI (Object Info) metadata pointing to that level. When performing a snapshot rollback, the system first obtains the target snapshot ID, then iterates through `clone_list`, comparing each snapshot ID to see if it falls within the snapshot ID range of the current clone object. If a match is found, the clone object is determined to be the target level for the rollback operation, and its OI information is extracted for subsequent processing.

[0036] At the parameter level, the snapshot ID range of each clone object in the clone_list is typically stored as a closed interval, such as [1000, 2000], indicating that the clone object covers all versions from snapshot ID 1000 to 2000. The system uses either binary search or linear scan strategies during traversal, depending on the length of the clone_list and performance requirements. In large-scale distributed storage systems, binary search is typically used to improve efficiency, with a time complexity of O(logn), significantly better than the O(n) time complexity of linear scan.

[0037] This step is primarily used in distributed storage systems when performing snapshot rollback operations, especially in critical business processes such as multi-version object management, data consistency assurance, and system fault recovery. By accurately matching the target snapshot ID with the ID range of the hierarchical cloned object, the system can avoid unnecessary traversal of the entire snapshot chain, thereby reducing the number of metadata accesses and system overhead.

[0038] From a technical perspective, this step effectively solves the snapshot version failure problem caused by the disruption of chain dependencies in traditional snapshot rollback. By introducing a blind snapshot structure, the system does not need to copy forward relationships or object data during rollback; it only needs to update the clone_overlap field in OI and generate a new blind snapshot record, thereby significantly improving the efficiency of rollback operations and the data reliability of the system. Furthermore, this mechanism also supports quickly locating the required snapshot object during read operations, enhancing the system's concurrent processing capabilities and response speed.

[0039] S12, extract the OI information from the matched hierarchical clone object, and verify the integrity and validity of the OI information to ensure data consistency in subsequent operations.

[0040] Specifically, in some implementations, extracting the Object Information (OI) information from the matched hierarchical clone object and verifying the completeness and validity of this OI information is one of the key steps in the snapshot processing optimization scheme based on blind zone snapshots in this invention. This step aims to ensure that the system can accurately identify and access the correct data version during snapshot rollback or read operations, thereby guaranteeing data consistency and system reliability.

[0041] At the technical implementation level, this step first determines the hierarchical clone objects involved in the current request by traversing the clone_list field in the OI structure of the header object and combining it with the target snapshot ID. Each hierarchical clone object only copies the basic metadata of the object during creation, rather than the complete forwarding relationship. Therefore, its OI information includes a clone_overlap field, which records the scope of the current clone object's dependency on the previous version's forwarding relationship. When extracting OI information, the system needs to parse the starting offset and length of this field and, combined with the mapping relationship in the blind snapshot structure (such as (3,0) or (4,1)), determine whether the target data fragment exists in the current clone object or other snapshot objects it depends on.

[0042] At the parameter index level, the integrity verification of OI information usually includes checking whether the is_exist flag is true and whether there is a record in the clone_list that matches the target snapshot ID. The validity verification involves range checking of the clone_overlap field to ensure that its offset and length are within the legal range (e.g., 0 ≤ offset < object_size, 0 < length ≤ object_size - offset) and comply with the metadata specifications defined in Ceph or Ceph-compatible distributed storage systems. In addition, the key-value pairs in the blind area snapshot structure need to meet the requirements of monotonic increase of the snapshot ID and reachability of the rollback path to ensure the logical consistency of the snapshot chain.

[0043] At the application scenario level, this step is widely used in operations such as snapshot rollback and snapshot reading in distributed storage systems. For example, when performing snapshot rollback, the system needs to extract OI information from the target clone object and verify whether it contains the forward relationship of the data segments required for rollback; when reading a snapshot object, the client request carries the snapshot ID, and the system needs to determine the ownership object of the data segment through the joint analysis of OI information and the blind area snapshot structure, so as to achieve efficient data location and access.

[0044] At the technical effect level, this step effectively avoids the performance overhead caused by forward relationship copying during snapshot rollback by accurately extracting and verifying OI information, and at the same time ensures that the integrity of the snapshot chain is not damaged, thereby improving the stability and reliability of the system in multi-version data management. Further, this mechanism supports efficient and low-latency snapshot operations in a large-scale distributed environment, providing solid technical support for the disaster recovery and version control of the storage system.

[0045] S2. Calculate the target rollback clone object based on the clone_overlap information in the hierarchical clone object OI, and delete the forward relationship of the header object.

[0046] Specifically, in some implementations, calculating the target rollback clone object based on the clone_overlap information in the hierarchical clone object OI and deleting the forward relationship of the header object is one of the key steps in the snapshot processing optimization solution of this invention. The core technical principle of this step is to use the clone_overlap field to record the dependency range of the current clone object on the forward relationship of the previous version, so as to accurately locate the clone object that needs to be restored during rollback, avoid redundant copying of data or forward relationships for the entire object, reduce system overhead and maintain the integrity of the snapshot chain.

[0047] The specific implementation involves the following steps: First, the system determines the hierarchical structure of the target rollback clone object based on the clone_list maintained in the header object's OI (Object Information) and the user-specified rollback target snapshot ID, and then obtains the OI of that layer's clone object. Subsequently, by parsing the clone_overlap field in this OI, the system can identify which data ranges the current clone object depends on the previous version's positive relationship. Based on this, the system calculates the target rollback clone object, i.e., the specific version object that needs to be restored.

[0048] Furthermore, after identifying the target clone object, the system removes the currently saved forward relationships from the header object to prevent data conflicts or inconsistencies after rollback. Subsequently, the system generates a blind snapshot (e.g., (4,1) represents a rollback from snapshot 4 to snapshot 1) and updates the clone_overlap field in the header object's OI to reflect the new dependencies. Finally, the system assembles the forward relationships and the updated OI into a key-value (KV) structure and persists it using a distributed KV storage system.

[0049] At the parameter level, `clone_overlap` is typically represented as a range (offset, length), such as (1M, 2M), used to identify the data range of the previous version of the object that the currently cloned object depends on. Snapshot IDs are uniquely identified using a 64-bit integer or UUID format, ensuring good scalability and uniqueness in large-scale distributed systems. The generation of blind zone snapshots must follow certain naming conventions and storage strategies, usually consistent with the topology of the snapshot chain, to support subsequent read jumps.

[0050] This step is primarily used in the snapshot rollback operation phase of distributed storage systems, especially in scenarios where historical versions of data need to be restored without affecting the current snapshot chain structure. For example, when data anomalies or version conflicts occur in the storage pool, the system can use this step to quickly locate and restore to a specified snapshot version, while avoiding disrupting dependencies on other snapshot versions, thereby ensuring data reliability and consistency.

[0051] In terms of technical effectiveness, this step effectively solves the performance degradation and snapshot chain failure problems caused by forward copying during traditional snapshot rollback. By introducing a blind-zone snapshot mechanism, the system does not need to copy data during rollback; it only needs to update dependencies and generate metadata records, significantly reducing I / O overhead and storage resource consumption. Furthermore, this method ensures the integrity of the snapshot chain, allowing intermediate version snapshots to still be accessed correctly, thereby improving the system's data protection capabilities and version management efficiency.

[0052] Furthermore, S2 includes: S21. Based on the dependency range of the current cloned object on the previous cloned object recorded in clone_overlap, determine the starting position and length of the positive relationship data segment that needs to be rolled back.

[0053] Specifically, in some implementations, determining the starting position and length of the forward relationship data segment that needs to be rolled back based on the dependency range of the current cloned object on the previous cloned object recorded in clone_overlap is one of the core steps of this invention for snapshot rollback optimization based on the blind zone snapshot mechanism. This step achieves precise location and rollback operation of the forward relationship data by parsing the clone_overlap field in the object's OI (Object Info) information and combining it with the target snapshot ID, thereby avoiding the destruction of the snapshot chain.

[0054] In the specific technical implementation, `clone_overlap` is a range mapping structure used to record the dependency relationship between the current cloned object and its predecessor cloned object in terms of data offset and length. For example, if the current cloned object has a positive relationship with the previous snapshot object within an offset of 1M to 2M, then `clone_overlap` will record this range. During snapshot rollback, the system first obtains the `clone_list` from the OI of the header object and determines the level of the target cloned object based on the target snapshot ID. Subsequently, the system calculates the starting offset and length of the positive relationship data segment that needs to be rolled back by traversing the `clone_overlap` in the OI of that level, usually in bytes, with a precision of up to 1M (1024KB) or finer granularity, such as 512KB, depending on the block size parameter configured by the system.

[0055] At the parameter level, key parameters involved in this step include: snapshot_id (snapshot identifier), offset (data offset), length (data length), the interval structure of clone_overlap (such as [start_offset, end_offset]), and the hierarchical index of clone_list. The system typically uses a B+ tree or hash table structure for efficient indexing and querying of clone_overlap to meet the performance requirements of high-concurrency read / write scenarios.

[0056] In application scenarios, this step is widely used in snapshot rollback operations in distributed storage systems, especially in multi-version concurrency control (MVCC) and append-only storage architectures. Through this step, the system can recover specific versions of data without disrupting the snapshot chain, thereby improving the system's data reliability and consistency.

[0057] In terms of technical effectiveness, this step effectively avoids the performance degradation and storage overhead caused by copying data or forward relationships in traditional snapshot rollbacks. Simultaneously, through precise dependency range calculations, it ensures that the rollback operation only affects the target data segment and does not impact the integrity of other snapshot versions. Furthermore, this mechanism supports multi-level snapshot rollbacks, enhancing the system's fault tolerance and maintainability in complex data operation scenarios.

[0058] S22, mark and delete the positive relationship data fragments in the header object that correspond to the rollback target snapshot ID, and retain the positive relationship data that has not been affected by the rollback to reduce the risk of data loss.

[0059] Specifically, in some implementations, this step involves marking and deleting the forward relationship data fragments in the header object corresponding to the target snapshot ID during snapshot rollback operations in a distributed storage system, while retaining the forward relationship data unaffected by the rollback. The core technical principle of this operation is to introduce a "blind spot snapshot" mechanism to achieve intelligent jumps in dependencies within the snapshot chain, thereby avoiding damage to the integrity of the snapshot chain during rollback and reducing the risk of data loss.

[0060] The specific implementation involves the following steps: First, the system determines the hierarchical clone object to which the target rollback clone object belongs based on the clone_list and the rollback target snapshot ID recorded in the header object's OI (Object Info), and obtains its OI information. Then, by parsing the clone_overlap field in the OI, the system calculates the coverage area of ​​the target rollback clone object. Based on this, the system marks and deletes, rather than physically deleting, positive relationship data segments in the header object related to the rollback target snapshot ID, to preserve data segments unaffected by the rollback. The deletion operation is typically based on offset and length parameters to precisely control the deletion range of data segments, ensuring that data consistency in other snapshot versions is not affected.

[0061] Furthermore, the system generates a blind zone snapshot record with a key-value pair structure (key, value), where the key is the latest snapshot ID of the current object, and the value is the target snapshot ID for rollback. This record will be written to the OI of the header object and persistently stored through a distributed KV storage system. During read operations, the system will jump through the snapshot chain based on the blind zone snapshot and the clone_overlap field, thereby quickly locating the forward relationship of the required data fragment.

[0062] This step plays a crucial role in the snapshot rollback process. Its technical value lies in avoiding the snapshot chain breakage problem caused by rollback in traditional solutions, while also reducing the performance overhead of data copying. Through a precise data fragment marking and deletion mechanism, the system improves storage efficiency and data recovery reliability while ensuring data consistency. This technology is suitable for multi-version snapshot management scenarios in distributed storage systems, especially in business systems that require frequent rollbacks and version switching, such as cloud storage, database backup and recovery, and virtual machine snapshots. S3 generates a blind snapshot, where the key of the blind snapshot is the latest snapshot ID of the current object, and the value is the target snapshot ID to which it is rolled back.

[0063] Specifically, in a distributed storage system, generating blind zone snapshots is one of the core steps in achieving snapshot rollback optimization. This step introduces a special key-value structure into the header object's OI (Object Information), where the key is the latest snapshot ID of the current object and the value is the target snapshot ID on which the rollback operation depends. This allows for efficient data rollback and reading without disrupting the snapshot chain dependencies.

[0064] In its implementation, when the system performs a snapshot rollback operation, it first determines the hierarchical clone structure to which the target rollback clone object belongs based on the clone_list and the target snapshot ID in the header object's OI, and then obtains its OI information. Subsequently, the system calculates the dependency scope of the target rollback clone object based on the clone_overlap field in the OI. Based on this, the system deletes the forward relationship of the current header object and generates a new blind snapshot record, binding the latest snapshot ID to the rollback target snapshot ID. This record is then written to the distributed key-value storage system for subsequent read operations.

[0065] From a technical perspective, the generation of blind zone snapshots must meet certain data consistency requirements. For example, the increment rule of the snapshot ID should follow the snapshot management specifications of Ceph or Ceph-like systems to ensure the orderliness of the snapshot chain. In addition, the clone_overlap field usually adopts an offset-length mapping method to record the dependency range of the current cloned object on the previous snapshot object. Its data structure can be an array or a hash table, supporting O(1) or O(log n) lookup efficiency.

[0066] In application scenarios, this step is widely used in distributed storage systems for version rollback, data recovery, and consistency assurance. For example, in Ceph or similar architectures, when a client requests to roll back to a historical snapshot version, the system quickly locates dependencies through the blind snapshot structure, avoiding the data unrecoverable problem caused by snapshot chain breaks in traditional solutions.

[0067] The technical value of this step lies in its effective solution to the problem of snapshot chain dependencies being disrupted during snapshot rollback by introducing a blind-zone snapshot mechanism, thereby improving the system's data reliability and snapshot management efficiency. Simultaneously, this mechanism avoids large-scale data or forward-relationship copying operations, significantly reducing storage overhead and I / O performance degradation.

[0068] Furthermore, S3 includes: S31, set the key of the blind zone snapshot to the latest snapshot ID of the header object before the rollback, set the value to the snapshot ID that the actual rollback points to, and store this mapping relationship in the OI of the header object.

[0069] Specifically, in some implementations, setting the key of the blind snapshot to the latest snapshot ID of the header object before rollback, and setting the value to the snapshot ID that the actual rollback points to, and storing this mapping relationship in the header object's OI (Object Info), is one of the core steps of this invention for optimizing snapshot rollback based on the blind snapshot mechanism. This step, by introducing a blind snapshot structure into the header object's OI, solves the problem of snapshot version failure caused by the destruction of dependency relationships during the rollback process in traditional snapshot chains.

[0070] In terms of specific technical implementation, when performing a snapshot rollback operation, the system first determines the hierarchical clone object to which the target rollback clone object belongs based on the clone_list and target snapshot ID recorded in the header object's OI, and obtains its OI information. Subsequently, the system calculates the dependency scope of the target rollback clone object based on the clone_overlap field in this OI. After deleting the forward relationship of the header object, the system generates a blind snapshot, whose key is the latest snapshot ID of the header object before rollback (e.g., Snapshot3), and the value is the snapshot ID that the actual rollback points to (e.g., Snapshot0), and writes it into the header object's OI. This mapping relationship is used to quickly locate dependent snapshots in subsequent read operations, avoiding direct access to invalid snapshot versions that have already been rolled back.

[0071] At the parameter level, both the key and value of a blind snapshot are 64-bit integer snapshot identifiers (SnapshotIDs) used to uniquely identify the snapshot version. The clone_overlap field typically represents the dependency range of the current cloned object on the previous cloned object in range form (e.g., [0, 1M]), with the unit being bytes, supporting data objects up to 2^64 bytes. This structure follows the standard protocols of distributed key-value storage systems during storage, such as using consistent hashing algorithms for distributed storage of key-value pairs to ensure data consistency and read / write performance under high concurrency access.

[0072] In application scenarios, this step is widely used in distributed storage systems for snapshot rollback, data recovery, and version control. For example, when data corruption or version conflicts occur in the storage pool, the system can quickly locate the valid snapshot version through blind snapshots, thereby restoring data consistency and avoiding snapshot chain breaks caused by rollback operations.

[0073] The technical advantage of this step lies in its ability to effectively maintain the integrity of the snapshot chain by introducing a blind-zone snapshot mapping mechanism, thus avoiding the snapshot version failure problem caused by rollback operations in traditional solutions. Simultaneously, this mechanism eliminates the need for large-scale data or forward relationship copying, significantly reducing system overhead and improving the efficiency and reliability of snapshot processing.

[0074] S32 assigns a unique identifier to each blind snapshot and creates an index in the distributed key-value store so that subsequent read operations can quickly locate dependencies.

[0075] Specifically, assigning a unique identifier to each blind snapshot and establishing an index in a distributed key-value store is a key step in this invention for achieving efficient management and rapid location of snapshot dependencies. In some implementations, this step introduces a snapshot ID as a unique identifier, combined with the clone_list and clone_overlap fields in the object metadata (OI), to construct a dependency graph between snapshot objects. The blind snapshot structure adopts a key-value pair format, where the key is the latest snapshot ID of the current object, and the value is the snapshot ID that the snapshot depends on after rollback. For example, (3,0) indicates that snapshot 3 depends on snapshot 0 after rollback.

[0076] In practice, when performing a snapshot rollback, the system first determines the hierarchical clone object to which the target rollback snapshot belongs based on the OI information of the header object, and calculates its clone_overlap range. Subsequently, the system generates a new blind snapshot record and writes it as a KV entry into the distributed KV storage system. This KV storage system can implement data distribution based on Ceph's CRUSH algorithm, supporting high-concurrency read / write and low-latency access. It typically employs consistent hashing or range partitioning strategies for data sharding to ensure the efficiency and scalability of the index.

[0077] At the parameter level, the snapshot ID is typically a 64-bit integer or UUID format to ensure global uniqueness; the clone_overlap field records the dependency range of the current cloned object on the previous version object, such as (offset, length), in bytes or blocks. During read operations, the system quickly locates the snapshot object containing the required data segment by parsing the clone_list and clone_overlap in the OI and combining them with the blind snapshot index, thus avoiding the dependency breakage problem caused by traditional snapshot chain rollback.

[0078] This step is widely applicable in practical applications for snapshot management scenarios in distributed storage systems, especially in environments requiring frequent rollbacks or concurrent reading of multiple snapshot versions, such as cloud backup, virtual machine snapshot recovery, and database point-in-time recovery. By establishing an index in the KV storage, the system can complete the lookup of snapshot dependencies in O(1) or O(logN) time complexity, significantly improving snapshot reading efficiency and overall system stability, while reducing storage overhead and computational resource consumption, demonstrating the innovation and practicality of this invention in snapshot processing mechanisms.

[0079] S4. Modify the clone_overlap information in the header object OI based on the generated blind zone snapshot, and assemble the positive relationship and OI information into a key-value format and send it to the distributed key-value storage for storage.

[0080] Specifically, in some implementations, modifying the clone_overlap information in the header object OI (Object Info) based on the generated blind zone snapshot, and assembling the forward relationship with the OI information into a KV (Key-Value) format and sending it to a distributed KV storage for storage, is a key step in this invention for achieving snapshot chain integrity protection and efficient data retrieval. This step, by dynamically maintaining object dependencies, ensures that the original snapshot chain structure is not destroyed during snapshot rollback, thereby improving system data consistency and reliability.

[0081] At the technical implementation level, when the system detects a snapshot rollback operation, it first determines the hierarchical clone object to which the target rollback object belongs based on the clone_list in the header object's OI and the target snapshot ID, and obtains its OI information. Then, the system calculates the dependency scope of the target rollback clone object based on the clone_overlap field in the OI. Based on this, the system deletes the forward relationship of the current header object and generates a new blind snapshot, in key-value format, where the key is the latest snapshot ID of the current object and the value is the target snapshot ID. This blind snapshot records the jump relationships during the snapshot rollback process, used for quickly locating dependent objects in subsequent read operations.

[0082] At the parameter level, the `clone_overlap` field is typically represented as a range, such as (1M, 2M), used to identify the range of positive relationships between the currently cloned object and the previous version. The generation of blind zone snapshots must follow certain naming conventions, such as using the format "snapshot_id:rollback_id", to ensure good retrieval and consistency in the distributed key-value storage. During key-value assembly, positive relationships need to be serialized, usually using JSON or Protobuf format to improve transmission efficiency and storage compatibility.

[0083] At the application level, this step is widely used in the snapshot management module of distributed storage systems, especially in multi-version concurrency control (MVCC) and data rollback scenarios. For example, in a cloud storage platform, when a user requests to roll back to a certain historical snapshot version, the system uses this step to quickly build dependencies, avoiding data inconsistency issues caused by broken snapshot chains.

[0084] In terms of technical effectiveness, this step effectively avoids the performance loss and storage overhead caused by directly copying the forward relationship in traditional snapshot rollback. At the same time, through the blind zone snapshot mechanism, it ensures the integrity of the snapshot chain, thereby improving the system's stability and data recovery capabilities in high-concurrency, large-scale data scenarios.

[0085] The snapshot processing method based on blind snapshots in this invention effectively avoids damage to the snapshot chain during snapshot rollback by introducing a blind snapshot structure, maintains the dependency relationship between snapshot versions, and improves system data reliability and snapshot reading efficiency. S5. Based on the snapshot ID carried in the read request, find the corresponding hierarchical clone object from the clone_list in the header object OI, and determine the dependent objects of the target data fragment based on the clone_overlap information of the hierarchical clone object to support the read operation of the snapshot object.

[0086] Specifically, in a distributed storage system, when a read request is received, it typically carries a snapshot ID. The core of this step lies in using this snapshot ID to locate the corresponding hierarchical clone object from the clone_list in the header object OI (Object Information), and based on the clone_overlap information of this clone object, determining the dependent objects of the target data fragment, thereby supporting the read operation of the snapshot object. This process is a crucial step in implementing the blind snapshot mechanism, ensuring that historical versions of data can still be correctly accessed after a snapshot rollback.

[0087] In some implementations, the header object OI maintains a clone_list structure, which records the hierarchical clone objects and their snapshot IDs under different snapshot versions. When a read request arrives, the system first parses the snapshot ID in the request and performs a match search in the clone_list to determine the hierarchical clone object corresponding to that snapshot ID. The clone_list typically uses an ordered list or hash table structure to support lookup operations with O(1) or O(log n) time complexity; the specific implementation can be chosen based on system performance requirements.

[0088] Further, after locating the corresponding hierarchical clone object, the system will read its `clone_overlap` field from its OI (Object Identification and Analysis) database. `clone_overlap` is an interval mapping structure used to describe which data offset intervals the current clone object depends on the previous snapshot object in a positive relationship. For example, `clone_overlap` can be represented as a series of (offset, length) interval pairs, each interval corresponding to a dependent snapshot object. When reading the target data fragment, the system will determine whether the fragment exists in the current clone object or whether it needs to jump to the dependent snapshot object for reading, based on the fragment's offset and length, combined with the `clone_overlap` information.

[0089] Optionally, during a snapshot rollback operation, the system generates a blind snapshot record, which is stored in the header object OI in the form of (current_snapshot_id, rollback_target_id). When reading a (2M, 3M) data segment of Snapshot4, if this segment is marked as dependent on Snapshot1 in clone_overlap, the system will jump through the snapshot chain based on the blind snapshot record, thereby ensuring the correctness of the read path.

[0090] The technical implementation of this step relies on an efficient management mechanism for object metadata in the storage system, involving the maintenance of the snapshot chain, the hierarchical structure design of cloned objects, and the interval mapping algorithm for dependencies. Key parameters include the length of the snapshot ID (typically a 64-bit or 128-bit UUID), the interval granularity of clone_overlap (e.g., 1MB or 4KB), and the storage structure of clone_list (e.g., B+ tree or hash table). Through this step, the system can achieve efficient and reliable reading of historical version data without disrupting snapshot chain dependencies, thereby significantly improving data consistency and access performance of the distributed storage system in snapshot rollback scenarios.

[0091] The snapshot processing method based on blind zone snapshots in this invention improves the accuracy and efficiency of snapshot reading by finding the corresponding hierarchical clone object from the clone_list of the header object OI according to the snapshot ID in the read request, and accurately locating the dependent object of the target data segment using its clone_overlap information. This enhances the system's data consistency guarantee capability in complex snapshot dependency scenarios.

[0092] To implement the above embodiments, the present invention also proposes a snapshot processing device based on blind zone snapshots. Figure 2This is a schematic diagram of a snapshot processing device based on blind zone snapshots, provided as an embodiment of the present invention. Figure 2 As shown, the device includes: The layered object determination module 100 is used to determine the layered clone object to which the target rollback clone object belongs based on the clone_list and rollback target snapshot id in the OI of the header object, and to obtain the OI of the layered clone object. The positive relationship processing module 200 is used to calculate the target rollback clone object and delete the positive relationship of the header object based on the clone_overlap information in the hierarchical clone object OI. The blind spot snapshot generation module 300 is used to generate blind spot snapshots, where the key of the blind spot snapshot is the latest snapshot ID of the current object, and the value is the target snapshot ID to which it is rolled back. The information assembly and storage module 400 is used to modify the clone_overlap information in the header object OI according to the generated blind zone snapshot, and assemble the forward relationship and OI information into a key-value format and send it to the distributed key-value storage for storage.

[0093] Regarding the apparatus in the above embodiments, the specific manner in which each module performs its operation has been described in detail in the embodiments related to the method, and will not be elaborated upon here.

[0094] To implement the above embodiments, the present invention also proposes an electronic device, comprising: a processor, and a memory communicatively connected to the processor; the memory stores computer execution instructions; the processor executes the computer execution instructions stored in the memory to implement the method provided in the foregoing embodiments.

[0095] To implement the above embodiments, the present invention also proposes a computer-readable storage medium storing computer-executable instructions, which, when executed by a processor, are used to implement the methods provided in the foregoing embodiments.

[0096] To implement the above embodiments, the present invention also proposes a computer program product, including a computer program that, when executed by a processor, implements the methods provided in the foregoing embodiments.

[0097] The collection, storage, use, processing, transmission, provision, and disclosure of user personal information involved in this invention all comply with the provisions of relevant laws and regulations and do not violate public order and good morals.

[0098] It should be noted that personal information collected from users should be used for legitimate and reasonable purposes and should not be shared or sold outside of these legitimate uses. Furthermore, such collection / sharing should only be conducted after receiving the user's informed consent, including but not limited to notifying the user to read the user agreement / user notice and sign an agreement / authorization that includes authorization of relevant user information before the user uses the function. In addition, any necessary steps must be taken to protect and safeguard access to such personal information data and ensure that others with access to personal information data comply with their privacy policies and procedures.

[0099] This invention is intended to provide implementation schemes for users to selectively prevent the use or access to personal information data. That is, this disclosure is intended to provide hardware and / or software to prevent or block access to such personal information data. Once personal information data is no longer needed, risks can be minimized by restricting data collection and deleting data. Furthermore, where applicable, such personal information can be de-identified to protect user privacy.

[0100] In the foregoing descriptions of the embodiments, the terms "one embodiment," "some embodiments," "example," "specific example," or "some examples," etc., refer to specific features, structures, materials, or characteristics described in connection with that embodiment or example, which are included in at least one embodiment or example of the present invention. In this specification, the illustrative expressions of the above terms do not necessarily refer to the same embodiment or example. Furthermore, the specific features, structures, materials, or characteristics described may be combined in any suitable manner in one or more embodiments or examples. Moreover, without contradiction, those skilled in the art can combine and integrate the different embodiments or examples described in this specification, as well as the features of different embodiments or examples.

[0101] Furthermore, the terms "first" and "second" are used for descriptive purposes only and should not be construed as indicating or implying relative importance or implicitly specifying the number of technical features indicated. Thus, a feature defined as "first" or "second" may explicitly or implicitly include at least one of that feature. In the description of this invention, "a plurality of" means at least two, such as two, three, etc., unless otherwise explicitly specified.

[0102] Any process or method description in the flowchart or otherwise herein can be understood as representing a module, segment, or portion of code comprising one or more executable instructions for implementing custom logic functions or processes, and the scope of preferred embodiments of the invention includes additional implementations in which functions may be performed not in the order shown or discussed, including substantially simultaneously or in reverse order depending on the functions involved, as should be understood by those skilled in the art to which embodiments of the invention pertain.

[0103] The logic and / or steps represented in the flowchart or otherwise described herein, for example, can be considered as a sequenced list of executable instructions for implementing logical functions, and can be embodied in any computer-readable medium for use by, or in conjunction with, an instruction execution system, apparatus, or device (such as a computer-based system, a processor-included system, or other system that can fetch and execute instructions from, an instruction execution system, apparatus, or device). For the purposes of this specification, "computer-readable medium" can be any means that can contain, store, communicate, propagate, or transmit programs for use by, or in conjunction with, an instruction execution system, apparatus, or device. More specific examples (a non-exhaustive list) of computer-readable media include: an electrical connection having one or more wires (electronic device), a portable computer disk drive (magnetic device), random access memory (RAM), read-only memory (ROM), erasable and editable read-only memory (EPROM or flash memory), fiber optic devices, and portable optical disc read-only memory (CDROM). Alternatively, the computer-readable medium may be paper or other suitable media on which the program can be printed, since the program can be obtained electronically, for example, by optically scanning the paper or other medium, followed by editing, interpreting, or otherwise processing as necessary, and then stored in a computer memory.

[0104] It should be understood that various parts of the present invention can be implemented in hardware, software, firmware, or a combination thereof. In the above embodiments, multiple steps or methods can be implemented in software or firmware stored in memory and executed by a suitable instruction execution system. For example, if implemented in hardware as in another embodiment, it can be implemented using any of the following techniques known in the art, or a combination thereof: discrete logic circuits having logic gates for implementing logical functions on data signals, application-specific integrated circuits (ASICs) having suitable combinational logic gates, programmable gate arrays (PGAs), field-programmable gate arrays (FPGAs), etc.

[0105] Those skilled in the art will understand that all or part of the steps of the methods in the above embodiments can be implemented by a program instructing related hardware. The program can be stored in a computer-readable storage medium, and when executed, the program includes one or a combination of the steps of the method embodiments.

[0106] Furthermore, the functional units in the various embodiments of the present invention can be integrated into a processing module, or each unit can exist physically separately, or two or more units can be integrated into a module. The integrated module can be implemented in hardware or as a software functional module. If the integrated module is implemented as a software functional module and sold or used as an independent product, it can also be stored in a computer-readable storage medium.

[0107] The storage medium mentioned above can be a read-only memory, a disk, or an optical disk, etc. Although embodiments of the present invention have been shown and described above, it is to be understood that the above embodiments are exemplary and should not be construed as limiting the present invention. Those skilled in the art can make changes, modifications, substitutions, and variations to the above embodiments within the scope of the present invention.

[0108] It should be understood that the various forms of processes shown above can be used, with steps reordered, added, or deleted. For example, the steps described in this invention can be executed in parallel, sequentially, or in different orders, as long as the desired result of the technical solution of this invention can be achieved, and this is not limited herein.

[0109] The specific embodiments described above do not constitute a limitation on the scope of protection of this invention. Those skilled in the art should understand that various modifications, combinations, sub-combinations, and substitutions can be made according to design requirements and other factors. Any modifications, equivalent substitutions, and improvements made within the spirit and principles of this invention should be included within the scope of protection of this invention.

Claims

1. A snapshot processing method based on blind zone snapshots, characterized in that, Includes the following steps: S1. Based on the clone_list and rollback target snapshot id in the OI of the header object, determine the hierarchical clone object to which the target rollback clone object belongs, and obtain the OI of that hierarchical clone object; S2, based on the clone_overlap information in the hierarchical clone object OI, calculate the target rollback clone object and delete the positive relationship of the header object; S3, generate a blind zone snapshot, where the key of the blind zone snapshot is the latest snapshot ID of the current object, and the value is the target snapshot ID to which it is rolled back; S4. Modify the clone_overlap information in the header object OI based on the generated blind zone snapshot, and assemble the positive relationship and OI information into a key-value format and send it to the distributed key-value storage for saving.

2. The method as described in claim 1, characterized in that, The step of determining the hierarchical clone object to which the target rollback clone object belongs based on the clone_list and the rollback target snapshot ID in the header object's OI, and obtaining the OI of that hierarchical clone object, further includes: S11, Traverse the list of layered clone objects recorded in clone_list, match the target rollback snapshot ID with the snapshot ID range of each layered clone object, and determine the layered clone object where the target rollback clone object is located; S12, extract the OI information from the matched hierarchical clone object, and verify the integrity and validity of the OI information to ensure data consistency in subsequent operations.

3. The method as described in claim 1, characterized in that, The step of calculating the target rollback clone object based on the clone_overlap information in the hierarchical clone object OI and deleting the positive relationship of the header object also includes: S21. Based on the dependency range of the current cloned object on the previous cloned object recorded in clone_overlap, determine the starting position and length of the positive relationship data segment that needs to be rolled back. S22, mark and delete the positive relationship data fragments in the header object that correspond to the rollback target snapshot ID, and retain the positive relationship data that has not been affected by the rollback to reduce the risk of data loss.

4. The method as described in claim 1, characterized in that, The process of generating a blind spot snapshot, where the key of the blind spot snapshot is the latest snapshot ID of the current object and the value is the target snapshot ID to which it is rolled back, also includes: S31, set the key of the blind zone snapshot to the latest snapshot ID of the header object before the rollback, set the value to the snapshot ID that the actual rollback points to, and store this mapping relationship in the OI of the header object; S32 assigns a unique identifier to each blind snapshot and creates an index in the distributed key-value store so that subsequent read operations can quickly locate dependencies.

5. The method as described in claim 1, characterized in that, Also includes: S5. Based on the snapshot ID carried in the read request, find the corresponding hierarchical clone object from the clone_list in the header object OI, and determine the dependent objects of the target data fragment based on the clone_overlap information of the hierarchical clone object to support the read operation of the snapshot object.

6. A snapshot processing apparatus based on blind zone snapshots, characterized in that, include: The layered object determination module is used to determine the layered clone object to which the target rollback clone object belongs based on the clone_list and rollback target snapshot id in the OI of the header object, and to obtain the OI of that layered clone object; The positive relationship processing module is used to calculate the target rollback clone object and delete the positive relationship of the header object based on the clone_overlap information in the hierarchical clone object OI. The blind spot snapshot generation module is used to generate blind spot snapshots, where the key of the blind spot snapshot is the latest snapshot ID of the current object, and the value is the target snapshot ID to which it is rolled back. The information assembly and storage module is used to modify the clone_overlap information in the header object OI based on the generated blind zone snapshot, and assemble the forward relationship and OI information into a key-value format and send it to the distributed key-value storage for storage.

7. The apparatus as claimed in claim 6, characterized in that, The hierarchical object determination module is also used for: Iterate through the list of layered clone objects recorded in clone_list, and match the target rollback snapshot ID with the snapshot ID range of each layered clone object to determine the layered clone object where the target rollback clone object is located; Extract the OI information from the matched hierarchical clone objects and verify the integrity and validity of the OI information to ensure data consistency in subsequent operations.

8. An electronic device, characterized in that, include: A processor, and a memory communicatively connected to the processor; The memory stores computer-executed instructions; The processor executes computer execution instructions stored in the memory to implement the method as described in any one of claims 1-6.

9. A computer-readable storage medium, characterized in that, The computer-readable storage medium stores computer-executable instructions, which, when executed by a processor, are used to implement the method as described in any one of claims 1-6.

10. A computer program product, characterized in that, Includes a computer program that, when executed by a processor, implements the method of any one of claims 1-6.

Images