Struct BlockInfo 

pub struct BlockInfo {
    pub offset: u64,
    pub length: u32,
    pub logical_len: u32,
    pub checksum: u32,
}

Metadata for a single compressed block in the snapshot.

Each block represents a contiguous chunk of logical data (typically 4KB-64KB) that has been compressed, optionally encrypted, and written to the snapshot file.

Fields

• offset: Physical byte offset in the snapshot file (where compressed data starts)
• length: Compressed size in bytes (0 for sparse/zero blocks)
• logical_len: Uncompressed size in bytes (original data size)
• checksum: CRC32 of compressed data (for integrity verification)

Special Values

• offset = BLOCK_OFFSET_PARENT (u64::MAX): Block stored in parent snapshot (thin snapshots)
• length = 0: Sparse block (all zeros, not stored on disk)

Size

This struct is 20 bytes, kept compact to minimize index overhead.

Examples

use hexz_core::format::index::BlockInfo;

// Normal block
let block = BlockInfo {
    offset: 4096,         // Starts at byte 4096
    length: 2048,         // Compressed to 2KB
    logical_len: 4096,    // Original 4KB
    checksum: 0x12345678,
};

// Sparse (zero) block
let sparse = BlockInfo {
    offset: 0,
    length: 0,           // Not stored
    logical_len: 4096,   // But logically 4KB
    checksum: 0,
};

Fields

offset: u64

Physical offset in the snapshot file (bytes).

length: u32

Compressed size in bytes (0 for sparse blocks).

logical_len: u32

Uncompressed logical size in bytes.

checksum: u32

CRC32 checksum of compressed data.

Implementations

impl BlockInfo

pub fn sparse(len: u32) -> Self

Creates a sparse (zero-filled) block descriptor.

Sparse blocks represent regions of all-zero data that are not physically stored in the snapshot file. This optimization significantly reduces snapshot size for sparse disk images (e.g., freshly created filesystems, swap areas).

Returns

A BlockInfo with:

• offset = 0 (not stored on disk)
• length = 0 (no compressed data)
• logical_len = len (represents len bytes of zeros)
• checksum = 0 (no data to checksum)

Parameters

• len: Logical size of the zero-filled region in bytes

Examples

use hexz_core::format::index::BlockInfo;

// Create a sparse 4KB block
let sparse = BlockInfo::sparse(4096);
assert_eq!(sparse.offset, 0);
assert_eq!(sparse.length, 0);
assert_eq!(sparse.logical_len, 4096);

// When reading this block, reader fills output buffer with zeros
// without performing any I/O.

pub fn is_sparse(&self) -> bool

Tests whether this block is sparse (all zeros, not stored on disk).

Returns

true if length == 0 and offset != BLOCK_OFFSET_PARENT, indicating that this block is not stored in the snapshot file and should be read as zeros.

Examples

use hexz_core::format::index::BlockInfo;

let sparse = BlockInfo::sparse(4096);
assert!(sparse.is_sparse());

let normal = BlockInfo {
    offset: 4096,
    length: 2048,
    logical_len: 4096,
    checksum: 0x12345678,
};
assert!(!normal.is_sparse());

pub fn is_parent_ref(&self) -> bool

Tests whether this block is stored in the parent snapshot.

For thin snapshots, blocks that haven’t been modified are marked with offset = BLOCK_OFFSET_PARENT (u64::MAX) and must be read from the parent snapshot instead of the current file.

Returns

true if offset == u64::MAX, indicating a parent reference.

Examples

use hexz_core::format::index::BlockInfo;

let parent_block = BlockInfo {
    offset: u64::MAX,  // BLOCK_OFFSET_PARENT
    length: 0,
    logical_len: 4096,
    checksum: 0,
};
assert!(parent_block.is_parent_ref());

Trait Implementations

impl Clone for BlockInfo

fn clone(&self) -> BlockInfo

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for BlockInfo

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for BlockInfo

fn default() -> BlockInfo

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for BlockInfo

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for BlockInfo

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for BlockInfo