impl<H: Hardware, I: PreparedImage> process::GuestCopyBackend for Owners<'_, H, I> {
    fn copy_current_user_data(
        &self,
        bag: &Self::Bag,
        pid: process::ProcessId,
        address: u64,
        output: &mut [u8],
    ) -> Result<(), process::GuestCopyError> {
        use process::GuestCopyError as CopyError;

        let before = self.before().map_err(|_| CopyError::Context)?;
        let launch = <Self as process::GuestLaunchBackend>::current_launch(self, bag, pid)
            .map_err(|_| CopyError::Context)?;
        let end = address
            .checked_add(output.len() as u64)
            .ok_or(CopyError::Fault)?;
        if address < DATA || end > DATA + PAGE {
            return Err(CopyError::Fault);
        }
        let data = bag.handles[1].ok_or(CopyError::Owner)?;
        if data.address() != launch.data_frame {
            return Err(CopyError::Owner);
        }
        let mut pin = self.store.pin(data, bag.owner).map_err(|_| CopyError::Owner)?;
        let offset = (address - DATA) as usize;
        let mut read_failed = false;
        for (index, byte) in output.iter_mut().enumerate() {
            match self.store.read(data, bag.owner, offset + index) {
                Ok(value) => *byte = value,
                Err(_) => {
                    read_failed = true;
                    break;
                }
            }
        }
        if self.store.unpin(&mut pin, bag.owner).is_err() {
            return Err(CopyError::Owner);
        }
        if read_failed {
            return Err(CopyError::Owner);
        }
        self.after(before).map_err(|_| CopyError::Context)?;
        Ok(())
    }
}