Method read_at_inner

block/src/qcow/mod.rs:292–363

(kind: &mut BackingKind, address: u64, buf: &mut [u8])

    }

    fn read_at_inner(kind: &mut BackingKind, address: u64, buf: &mut [u8]) -> std::io::Result<()> {
        match kind {
            BackingKind::Raw(file) => {
                file.seek(SeekFrom::Start(address))?;
                file.read_exact(buf)
            }
            #[cfg(test)]
            BackingKind::QcowFile(qcow) => {
                qcow.seek(SeekFrom::Start(address))?;
                qcow.read_exact(buf)
            }
            BackingKind::Qcow { inner, backing } => {
                let has_backing = backing.is_some();
                let cluster_size = inner.raw_file.cluster_size();
                let mut pos = 0usize;
                while pos < buf.len() {
                    let curr_addr = address + pos as u64;
                    let intra = inner.raw_file.cluster_offset(curr_addr) as usize;
                    let count = min(buf.len() - pos, cluster_size as usize - intra);
                    let mapping = inner.map_cluster_read(curr_addr, count, has_backing)?;
                    match mapping {
                        ClusterReadMapping::Zero { length } => {
                            buf[pos..pos + length as usize].fill(0);
                        }
                        ClusterReadMapping::Allocated {
                            offset: host_off,
                            length,
                        } => {
                            inner.raw_file.file_mut().seek(SeekFrom::Start(host_off))?;
                            inner
                                .raw_file
                                .file_mut()
                                .read_exact(&mut buf[pos..pos + length as usize])?;
                        }
                        ClusterReadMapping::Compressed {
                            host_offset,
                            compressed_size,
                            cluster_offset,
                            length,
                        } => {
                            let mut compressed = vec![0u8; compressed_size];
                            inner
                                .raw_file
                                .file_mut()
                                .seek(SeekFrom::Start(host_offset))?;
                            inner.raw_file.file_mut().read_exact(&mut compressed)?;
                            let decompressed = decompress_cluster(
                                &compressed,
                                cluster_size as usize,
                                &*inner.header.get_decoder(),
                            )?;
                            buf[pos..pos + length].copy_from_slice(
                                &decompressed[cluster_offset..cluster_offset + length],
                            );
                        }
                        ClusterReadMapping::Backing {
                            offset: backing_off,
                            length,