feat: add support for 9pfs disk images and various improvements

- Add linux_errno module for errno handling
- Enhance vsock device implementation
- Add pollable_channel and signal utilities
- Add sized_vec and worker_message utilities
- Add syscall abstraction layer
- Add shm device manager support
- Add block, fs, net, kernel config modules
- Add firmware and instance_info support
- Add kernel_bundle and kernel_cmdline modules

Author: RoyLin

src/arch/src/lib.rs

@@ -67,3 +67,92 @@ pub struct InitrdConfig {
 
 /// Default (smallest) memory page size for the supported architectures.
 pub const PAGE_SIZE: usize = 4096;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_arch_memory_info_default() {
+        let info = ArchMemoryInfo::default();
+        assert_eq!(info.ram_last_addr, 0);
+        assert_eq!(info.shm_start_addr, 0);
+        assert_eq!(info.page_size, 0);
+        assert_eq!(info.initrd_addr, 0);
+        assert_eq!(info.firmware_addr, 0);
+    }
+
+    #[cfg(target_arch = "x86_64")]
+    #[test]
+    fn test_arch_memory_info_x86_64() {
+        let mut info = ArchMemoryInfo::default();
+        info.ram_below_gap = 0x1000;
+        info.ram_above_gap = 0x2000;
+        info.ram_last_addr = 0xFFFF_FFFF;
+        info.shm_start_addr = 0x1_0000_0000;
+        info.page_size = 4096;
+        info.initrd_addr = 0x2000_0000;
+        info.firmware_addr = 0xFFFC_0000;
+
+        assert_eq!(info.ram_below_gap, 0x1000);
+        assert_eq!(info.ram_above_gap, 0x2000);
+    }
+
+    #[cfg(target_arch = "aarch64")]
+    #[test]
+    fn test_arch_memory_info_aarch64() {
+        let mut info = ArchMemoryInfo::default();
+        info.ram_start_addr = 0x4000_0000;
+        info.ram_last_addr = 0x7F_FFFF_FFFF;
+        info.shm_start_addr = 0x1_0000_0000;
+        info.page_size = 4096;
+        info.fdt_addr = 0x4000_0000;
+        info.initrd_addr = 0x4_0000_0000;
+        info.firmware_addr = 0x0;
+
+        assert_eq!(info.ram_start_addr, 0x4000_0000);
+        assert_eq!(info.fdt_addr, 0x4000_0000);
+    }
+
+    #[test]
+    fn test_initrd_config() {
+        use vm_memory::GuestAddress;
+
+        let initrd = InitrdConfig {
+            address: GuestAddress(0x2000_0000),
+            size: 0x5000,
+        };
+
+        assert_eq!(initrd.address, GuestAddress(0x2000_0000));
+        assert_eq!(initrd.size, 0x5000);
+    }
+
+    #[test]
+    fn test_initrd_config_default() {
+        let initrd = InitrdConfig {
+            address: vm_memory::GuestAddress(0),
+            size: 0,
+        };
+
+        assert_eq!(initrd.address, vm_memory::GuestAddress(0));
+        assert_eq!(initrd.size, 0);
+    }
+
+    #[test]
+    fn test_page_size_constant() {
+        assert_eq!(PAGE_SIZE, 4096);
+    }
+
+    #[test]
+    fn test_arch_memory_info_clone() {
+        let mut info = ArchMemoryInfo::default();
+        info.ram_last_addr = 0xFFFF_FFFF;
+        info.shm_start_addr = 0x1_0000_0000;
+        info.page_size = 4096;
+
+        let cloned = info.clone();
+        assert_eq!(info.ram_last_addr, cloned.ram_last_addr);
+        assert_eq!(info.shm_start_addr, cloned.shm_start_addr);
+        assert_eq!(info.page_size, cloned.page_size);
+    }
+}

src/devices/src/lib.rs

@@ -56,3 +56,101 @@ impl fmt::Display for DeviceType {
         write!(f, "{self:?}")
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_device_type_virtio() {
+        let device = DeviceType::Virtio(1);
+        assert_eq!(format!("{:?}", device), "Virtio(1)");
+        assert_eq!(format!("{}", device), "Virtio(1)");
+    }
+
+    #[cfg(target_arch = "aarch64")]
+    #[test]
+    fn test_device_type_gpio() {
+        let device = DeviceType::Gpio;
+        assert_eq!(format!("{:?}", device), "Gpio");
+    }
+
+    #[cfg(any(target_arch = "aarch64", target_arch = "riscv64"))]
+    #[test]
+    fn test_device_type_serial() {
+        let device = DeviceType::Serial;
+        assert_eq!(format!("{:?}", device), "Serial");
+    }
+
+    #[cfg(target_arch = "aarch64")]
+    #[test]
+    fn test_device_type_rtc() {
+        let device = DeviceType::RTC;
+        assert_eq!(format!("{:?}", device), "RTC");
+    }
+
+    #[test]
+    fn test_device_type_clone() {
+        let device = DeviceType::Virtio(42);
+        let cloned = device.clone();
+        assert_eq!(device, cloned);
+    }
+
+    #[test]
+    fn test_device_type_eq() {
+        let device1 = DeviceType::Virtio(1);
+        let device2 = DeviceType::Virtio(1);
+        let device3 = DeviceType::Virtio(2);
+        assert_eq!(device1, device2);
+        assert_ne!(device1, device3);
+    }
+
+    #[test]
+    fn test_error_debug() {
+        let io_error = std::io::Error::new(std::io::ErrorKind::Other, "test");
+        let error = Error::FailedReadingQueue {
+            event_type: "RX",
+            underlying: io_error,
+        };
+        assert_eq!(format!("{:?}", error), "FailedReadingQueue { event_type: \"RX\", underlying: Custom { kind: Other, error: \"\" } }");
+    }
+
+    #[test]
+    fn test_error_display() {
+        let io_error = std::io::Error::new(std::io::ErrorKind::Other, "test error");
+        let error = Error::IoError(io_error);
+        assert!(format!("{}", error).contains("test error"));
+    }
+
+    #[test]
+    fn test_error_failed_read_tap() {
+        let error = Error::FailedReadTap;
+        assert_eq!(format!("{:?}", error), "FailedReadTap");
+    }
+
+    #[test]
+    fn test_error_no_avail_buffers() {
+        let error = Error::NoAvailBuffers;
+        assert_eq!(format!("{:?}", error), "NoAvailBuffers");
+    }
+
+    #[test]
+    fn test_error_spurious_event() {
+        let error = Error::SpuriousEvent;
+        assert_eq!(format!("{:?}", error), "SpuriousEvent");
+    }
+
+    #[test]
+    fn test_error_payload_expected() {
+        let error = Error::PayloadExpected;
+        assert_eq!(format!("{:?}", error), "PayloadExpected");
+    }
+
+    #[test]
+    fn test_error_failed_signaling_used_queue() {
+        let io_error = std::io::Error::new(std::io::ErrorKind::Other, "signal error");
+        let error = Error::FailedSignalingUsedQueue(io_error);
+        let display = format!("{}", error);
+        assert!(display.contains("FailedSignalingUsedQueue"));
+    }
+}