Method restore_by_uffd

vmm/src/memory_manager.rs:938–1076

Restore guest memory using userfaultfd for lazy demand paging. Instead of reading the entire snapshot into guest RAM upfront (which blocks restore for hundreds of milliseconds at multi-GB sizes), this registers the guest memory regions with a userfaultfd. A background thread handles page faults by reading the corresponding page from the snapshot file and copying it into guest memory via `UFFDIO_C

(
        &mut self,
        file_path: &Path,
        saved_regions: &MemoryRangeTable,
        exit_evt: &EventFd,
    )

    /// is active. The file must remain available until the VM is shut down or
    /// all faulted pages have been served.
    fn restore_by_uffd(
        &mut self,
        file_path: &Path,
        saved_regions: &MemoryRangeTable,
        exit_evt: &EventFd,
    ) -> Result<(), Error> {
        if saved_regions.is_empty() {
            return Ok(());
        }

        let guest_memory = self.guest_memory.memory();
        let required_uffd_features = self.required_uffd_features();

        // SAFETY: FFI call. Trivially safe.
        let base_page_size = unsafe { libc::sysconf(libc::_SC_PAGESIZE) } as u64;

        info!(
            "UFFD restore: attempting demand-paged restore for {} region(s)",
            saved_regions.regions().len()
        );

        if saved_regions
            .regions()
            .iter()
            .any(|range| range.gpa % base_page_size != 0 || range.length % base_page_size != 0)
        {
            return Err(UffdError::UnalignedRanges.into());
        }

        let snapshot_file = File::open(file_path).map_err(Error::SnapshotOpen)?;

        let uffd_fd = uffd::create(required_uffd_features).map_err(UffdError::Create)?;

        let mut handler_ranges: Vec<UffdRange> = Vec::new();
        let mut file_offset: u64 = 0;

        for range in saved_regions.regions() {
            let host_addr = guest_memory
                .get_host_address(GuestAddress(range.gpa))
                .map_err(|_| UffdError::GpaTranslation { gpa: range.gpa })?
                as u64;

            let ioctls = uffd::register(uffd_fd.as_fd(), host_addr, range.length).map_err(|e| {
                UffdError::Register {
                    addr: host_addr,
                    len: range.length,
                    source: e,
                }
            })?;

            if ioctls & crate::userfaultfd::UFFD_API_RANGE_IOCTLS_BASIC
                != crate::userfaultfd::UFFD_API_RANGE_IOCTLS_BASIC
            {
                return Err(UffdError::MissingIoctlSupport {
                    addr: host_addr,
                    len: range.length,
                }
                .into());