block: enable to get a raw FD of each block device's DiskFile

This is a prerequisite for the next steps.

Signed-off-by: Philipp Schuster <philipp.schuster@cyberus-technology.de>
On-behalf-of: SAP philipp.schuster@sap.com

block/src/async_io.rs

@@ -2,6 +2,8 @@
 //
 // SPDX-License-Identifier: Apache-2.0 AND BSD-3-Clause
 
+use std::os::fd::RawFd;
+
 use thiserror::Error;
 use vmm_sys_util::eventfd::EventFd;
 
@@ -25,6 +27,12 @@ pub trait DiskFile: Send {
     fn topology(&mut self) -> DiskTopology {
         DiskTopology::default()
     }
+    /// Returns the file descriptor of the underlying disk image file.
+    // Impl Note:
+    // This must be `RawFd` instead of `BorrowedFd` or `&File`, as some
+    // implementations wrap the file in an `Arc<Mutex<T>>`, which makes it
+    // impossible to return a reference.
+    fn fd(&mut self) -> RawFd;
 }
 
 #[derive(Error, Debug)]

block/src/fixed_vhd_async.rs

@@ -33,6 +33,10 @@ impl DiskFile for FixedVhdDiskAsync {
                 .map_err(DiskFileError::NewAsyncIo)?,
         ) as Box<dyn AsyncIo>)
     }
+
+    fn fd(&mut self) -> RawFd {
+        self.0.as_raw_fd()
+    }
 }
 
 pub struct FixedVhdAsync {

block/src/fixed_vhd_sync.rs

@@ -33,6 +33,10 @@ impl DiskFile for FixedVhdDiskSync {
                 .map_err(DiskFileError::NewAsyncIo)?,
         ) as Box<dyn AsyncIo>)
     }
+
+    fn fd(&mut self) -> RawFd {
+        self.0.as_raw_fd()
+    }
 }
 
 pub struct FixedVhdSync {

block/src/qcow/mod.rs

@@ -13,6 +13,7 @@ use std::cmp::{max, min};
 use std::fs::OpenOptions;
 use std::io::{self, Read, Seek, SeekFrom, Write};
 use std::mem::size_of;
+use std::os::fd::{AsRawFd, RawFd};
 use std::str;
 
 use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
@@ -1516,6 +1517,12 @@ impl QcowFile {
     }
 }
 
+impl AsRawFd for QcowFile {
+    fn as_raw_fd(&self) -> RawFd {
+        self.raw_file.as_raw_fd()
+    }
+}
+
 impl Drop for QcowFile {
     fn drop(&mut self) {
         let _ = self.sync_caches();

block/src/qcow/qcow_raw_file.rs

@@ -6,6 +6,7 @@
 
 use std::io::{self, BufWriter, Seek, SeekFrom, Write};
 use std::mem::size_of;
+use std::os::fd::{AsRawFd, RawFd};
 
 use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
 use vmm_sys_util::write_zeroes::WriteZeroes;
@@ -159,3 +160,9 @@ impl Clone for QcowRawFile {
         }
     }
 }
+
+impl AsRawFd for QcowRawFile {
+    fn as_raw_fd(&self) -> RawFd {
+        self.file.as_raw_fd()
+    }
+}

block/src/qcow/raw_file.rs

@@ -369,3 +369,9 @@ impl Clone for RawFile {
         }
     }
 }
+
+impl AsRawFd for RawFile {
+    fn as_raw_fd(&self) -> RawFd {
+        self.file.as_raw_fd()
+    }
+}

block/src/qcow_sync.rs

@@ -5,6 +5,7 @@
 use std::collections::VecDeque;
 use std::fs::File;
 use std::io::{Seek, SeekFrom};
+use std::os::fd::{AsRawFd, RawFd};
 use std::sync::{Arc, Mutex, MutexGuard};
 
 use vmm_sys_util::eventfd::EventFd;
@@ -35,6 +36,11 @@ impl DiskFile for QcowDiskSync {
     fn new_async_io(&self, _ring_depth: u32) -> DiskFileResult<Box<dyn AsyncIo>> {
         Ok(Box::new(QcowSync::new(self.qcow_file.clone())) as Box<dyn AsyncIo>)
     }
+
+    fn fd(&mut self) -> RawFd {
+        let lock = self.qcow_file.lock().unwrap();
+        lock.as_raw_fd()
+    }
 }
 
 pub struct QcowSync {

block/src/raw_async.rs

@@ -46,6 +46,10 @@ impl DiskFile for RawFileDisk {
             DiskTopology::default()
         }
     }
+
+    fn fd(&mut self) -> RawFd {
+        self.file.as_raw_fd()
+    }
 }
 
 pub struct RawFileAsync {

block/src/raw_async_aio.rs

@@ -49,6 +49,10 @@ impl DiskFile for RawFileDiskAio {
             DiskTopology::default()
         }
     }
+
+    fn fd(&mut self) -> RawFd {
+        self.file.as_raw_fd()
+    }
 }
 
 pub struct RawFileAsyncAio {

block/src/raw_sync.rs

@@ -43,6 +43,10 @@ impl DiskFile for RawFileDiskSync {
             DiskTopology::default()
         }
     }
+
+    fn fd(&mut self) -> RawFd {
+        self.file.as_raw_fd()
+    }
 }
 
 pub struct RawFileSync {

block/src/vhdx/mod.rs

@@ -5,6 +5,7 @@
 use std::collections::btree_map::BTreeMap;
 use std::fs::File;
 use std::io::{Read, Seek, SeekFrom, Write};
+use std::os::fd::{AsRawFd, RawFd};
 
 use byteorder::{BigEndian, ByteOrder};
 use remain::sorted;
@@ -222,6 +223,12 @@ impl Clone for Vhdx {
     }
 }
 
+impl AsRawFd for Vhdx {
+    fn as_raw_fd(&self) -> RawFd {
+        self.file.as_raw_fd()
+    }
+}
+
 pub(crate) fn uuid_from_guid(buf: &[u8]) -> Uuid {
     // The first 3 fields of UUID are stored in Big Endian format, and
     // the last 8 bytes are stored as byte array. Therefore, we read the

block/src/vhdx_sync.rs

@@ -4,6 +4,7 @@
 
 use std::collections::VecDeque;
 use std::fs::File;
+use std::os::fd::{AsRawFd, RawFd};
 use std::sync::{Arc, Mutex, MutexGuard};
 
 use vmm_sys_util::eventfd::EventFd;
@@ -35,6 +36,11 @@ impl DiskFile for VhdxDiskSync {
                 as Box<dyn AsyncIo>,
         )
     }
+
+    fn fd(&mut self) -> RawFd {
+        let lock = self.vhdx_file.lock().unwrap();
+        lock.as_raw_fd()
+    }
 }
 
 pub struct VhdxSync {