Method state_change_request

virtio-devices/src/mem.rs:481–543

(&mut self, addr: u64, nb_blocks: u16, plug: bool)

    }

    fn state_change_request(&mut self, addr: u64, nb_blocks: u16, plug: bool) -> u16 {
        let mut config = self.config.lock().unwrap();
        let size: u64 = nb_blocks as u64 * config.block_size;

        if plug && (config.plugged_size + size > config.requested_size) {
            return VIRTIO_MEM_RESP_NACK;
        }
        if !config.is_valid_range(addr, size) {
            return VIRTIO_MEM_RESP_ERROR;
        }

        let offset = addr - config.addr;

        let first_block_index = (offset / config.block_size) as usize;
        if !self.blocks_state.lock().unwrap().is_range_state(
            first_block_index,
            nb_blocks as usize,
            !plug,
        ) {
            return VIRTIO_MEM_RESP_ERROR;
        }

        if !plug && let Err(e) = self.discard_memory_range(offset, size) {
            error!("failed discarding memory range: {e:?}");
            return VIRTIO_MEM_RESP_ERROR;
        }

        self.blocks_state
            .lock()
            .unwrap()
            .set_range(first_block_index, nb_blocks as usize, plug);

        let handlers = self.dma_mapping_handlers.lock().unwrap();
        if plug {
            let mut gpa = addr;
            for _ in 0..nb_blocks {
                for (_, handler) in handlers.iter() {
                    if let Err(e) = handler.map(gpa, gpa, config.block_size) {
                        error!(
                            "failed DMA mapping addr 0x{:x} size 0x{:x}: {}",
                            gpa, config.block_size, e
                        );
                        return VIRTIO_MEM_RESP_ERROR;
                    }
                }

                gpa += config.block_size;
            }

            config.plugged_size += size;
        } else {
            for (_, handler) in handlers.iter() {
                if let Err(e) = handler.unmap(addr, size) {
                    error!("failed DMA unmapping addr 0x{addr:x} size 0x{size:x}: {e}");
                    return VIRTIO_MEM_RESP_ERROR;
                }
            }