diff --git a/block_util/src/lib.rs b/block_util/src/lib.rs index 1130c5da9..269c0eef5 100644 --- a/block_util/src/lib.rs +++ b/block_util/src/lib.rs @@ -24,7 +24,6 @@ pub mod vhd; use crate::async_io::{AsyncIo, AsyncIoError, AsyncIoResult, DiskFileError, DiskFileResult}; #[cfg(feature = "io_uring")] use io_uring::{opcode, IoUring, Probe}; -use serde::ser::{Serialize, SerializeStruct, Serializer}; use std::cmp; use std::convert::TryInto; use std::fs::File; @@ -370,7 +369,7 @@ impl Request { } } -#[derive(Copy, Clone, Debug, Default, Deserialize)] +#[derive(Copy, Clone, Debug, Default, Deserialize, Serialize)] #[repr(C, packed)] pub struct VirtioBlockConfig { pub capacity: u64, @@ -393,95 +392,15 @@ pub struct VirtioBlockConfig { pub write_zeroes_may_unmap: u8, pub unused1: [u8; 3], } - -// We must explicitly implement Serialize since the structure is packed and -// it's unsafe to borrow from a packed structure. And by default, if we derive -// Serialize from serde, it will borrow the values from the structure. -// That's why this implementation copies each field separately before it -// serializes the entire structure field by field. -impl Serialize for VirtioBlockConfig { - fn serialize(&self, serializer: S) -> Result - where - S: Serializer, - { - let capacity = self.capacity; - let size_max = self.size_max; - let seg_max = self.seg_max; - let geometry = self.geometry; - let blk_size = self.blk_size; - let physical_block_exp = self.physical_block_exp; - let alignment_offset = self.alignment_offset; - let min_io_size = self.min_io_size; - let opt_io_size = self.opt_io_size; - let writeback = self.writeback; - let unused = self.unused; - let num_queues = self.num_queues; - let max_discard_sectors = self.max_discard_sectors; - let max_discard_seg = self.max_discard_seg; - let discard_sector_alignment = self.discard_sector_alignment; - let max_write_zeroes_sectors = self.max_write_zeroes_sectors; - let max_write_zeroes_seg = self.max_write_zeroes_seg; - let write_zeroes_may_unmap = self.write_zeroes_may_unmap; - let unused1 = self.unused1; - - let mut virtio_block_config = serializer.serialize_struct("VirtioBlockConfig", 60)?; - virtio_block_config.serialize_field("capacity", &capacity)?; - virtio_block_config.serialize_field("size_max", &size_max)?; - virtio_block_config.serialize_field("seg_max", &seg_max)?; - virtio_block_config.serialize_field("geometry", &geometry)?; - virtio_block_config.serialize_field("blk_size", &blk_size)?; - virtio_block_config.serialize_field("physical_block_exp", &physical_block_exp)?; - virtio_block_config.serialize_field("alignment_offset", &alignment_offset)?; - virtio_block_config.serialize_field("min_io_size", &min_io_size)?; - virtio_block_config.serialize_field("opt_io_size", &opt_io_size)?; - virtio_block_config.serialize_field("writeback", &writeback)?; - virtio_block_config.serialize_field("unused", &unused)?; - virtio_block_config.serialize_field("num_queues", &num_queues)?; - virtio_block_config.serialize_field("max_discard_sectors", &max_discard_sectors)?; - virtio_block_config.serialize_field("max_discard_seg", &max_discard_seg)?; - virtio_block_config - .serialize_field("discard_sector_alignment", &discard_sector_alignment)?; - virtio_block_config - .serialize_field("max_write_zeroes_sectors", &max_write_zeroes_sectors)?; - virtio_block_config.serialize_field("max_write_zeroes_seg", &max_write_zeroes_seg)?; - virtio_block_config.serialize_field("write_zeroes_may_unmap", &write_zeroes_may_unmap)?; - virtio_block_config.serialize_field("unused1", &unused1)?; - virtio_block_config.end() - } -} - unsafe impl ByteValued for VirtioBlockConfig {} -#[derive(Copy, Clone, Debug, Default, Deserialize)] +#[derive(Copy, Clone, Debug, Default, Serialize, Deserialize)] #[repr(C, packed)] pub struct VirtioBlockGeometry { pub cylinders: u16, pub heads: u8, pub sectors: u8, } - -// We must explicitly implement Serialize since the structure is packed and -// it's unsafe to borrow from a packed structure. And by default, if we derive -// Serialize from serde, it will borrow the values from the structure. -// That's why this implementation copies each field separately before it -// serializes the entire structure field by field. -impl Serialize for VirtioBlockGeometry { - fn serialize(&self, serializer: S) -> Result - where - S: Serializer, - { - let cylinders = self.cylinders; - let heads = self.heads; - let sectors = self.sectors; - - let mut virtio_block_geometry = serializer.serialize_struct("VirtioBlockGeometry", 4)?; - virtio_block_geometry.serialize_field("cylinders", &cylinders)?; - virtio_block_geometry.serialize_field("heads", &heads)?; - virtio_block_geometry.serialize_field("sectors", §ors)?; - virtio_block_geometry.end() - } -} - unsafe impl ByteValued for VirtioBlockGeometry {} /// Check if io_uring for block device can be used on the current system, as diff --git a/virtio-devices/src/console.rs b/virtio-devices/src/console.rs index 9fa8c3488..3c7b0a7f5 100644 --- a/virtio-devices/src/console.rs +++ b/virtio-devices/src/console.rs @@ -11,7 +11,6 @@ use crate::seccomp_filters::{get_seccomp_filter, Thread}; use crate::VirtioInterrupt; use libc::EFD_NONBLOCK; use seccomp::{SeccompAction, SeccompFilter}; -use serde::ser::{Serialize, SerializeStruct, Serializer}; use std::cmp; use std::collections::VecDeque; use std::io; @@ -41,7 +40,7 @@ const CONFIG_EVENT: u16 = EPOLL_HELPER_EVENT_LAST + 4; //Console size feature bit const VIRTIO_CONSOLE_F_SIZE: u64 = 0; -#[derive(Copy, Clone, Debug, Default, Deserialize)] +#[derive(Copy, Clone, Debug, Default, Deserialize, Serialize)] #[repr(C, packed)] pub struct VirtioConsoleConfig { cols: u16, @@ -50,30 +49,6 @@ pub struct VirtioConsoleConfig { emerg_wr: u32, } -// We must explicitly implement Serialize since the structure is packed and -// it's unsafe to borrow from a packed structure. And by default, if we derive -// Serialize from serde, it will borrow the values from the structure. -// That's why this implementation copies each field separately before it -// serializes the entire structure field by field. -impl Serialize for VirtioConsoleConfig { - fn serialize(&self, serializer: S) -> Result - where - S: Serializer, - { - let cols = self.cols; - let rows = self.rows; - let max_nr_ports = self.max_nr_ports; - let emerg_wr = self.emerg_wr; - - let mut virtio_console_config = serializer.serialize_struct("VirtioConsoleConfig", 12)?; - virtio_console_config.serialize_field("cols", &cols)?; - virtio_console_config.serialize_field("rows", &rows)?; - virtio_console_config.serialize_field("max_nr_ports", &max_nr_ports)?; - virtio_console_config.serialize_field("emerg_wr", &emerg_wr)?; - virtio_console_config.end() - } -} - // Safe because it only has data and has no implicit padding. unsafe impl ByteValued for VirtioConsoleConfig {} diff --git a/virtio-devices/src/net_util.rs b/virtio-devices/src/net_util.rs index 20e62bab0..2ae263737 100644 --- a/virtio-devices/src/net_util.rs +++ b/virtio-devices/src/net_util.rs @@ -7,7 +7,6 @@ use super::{ EPOLL_HELPER_EVENT_LAST, }; use net_util::MacAddr; -use serde::ser::{Serialize, SerializeStruct, Serializer}; use std::os::unix::io::{AsRawFd, RawFd}; use std::sync::atomic::AtomicBool; use std::sync::{Arc, Barrier}; @@ -25,7 +24,7 @@ const QUEUE_SIZE: usize = 256; const CTRL_QUEUE_EVENT: u16 = EPOLL_HELPER_EVENT_LAST + 1; #[repr(C, packed)] -#[derive(Copy, Clone, Debug, Default, Deserialize)] +#[derive(Copy, Clone, Debug, Default, Deserialize, Serialize)] pub struct VirtioNetConfig { pub mac: [u8; 6], pub status: u16, @@ -35,34 +34,6 @@ pub struct VirtioNetConfig { pub duplex: u8, } -// We must explicitly implement Serialize since the structure is packed and -// it's unsafe to borrow from a packed structure. And by default, if we derive -// Serialize from serde, it will borrow the values from the structure. -// That's why this implementation copies each field separately before it -// serializes the entire structure field by field. -impl Serialize for VirtioNetConfig { - fn serialize(&self, serializer: S) -> std::result::Result - where - S: Serializer, - { - let mac = self.mac; - let status = self.status; - let max_virtqueue_pairs = self.max_virtqueue_pairs; - let mtu = self.mtu; - let speed = self.speed; - let duplex = self.duplex; - - let mut virtio_net_config = serializer.serialize_struct("VirtioNetConfig", 17)?; - virtio_net_config.serialize_field("mac", &mac)?; - virtio_net_config.serialize_field("status", &status)?; - virtio_net_config.serialize_field("max_virtqueue_pairs", &max_virtqueue_pairs)?; - virtio_net_config.serialize_field("mtu", &mtu)?; - virtio_net_config.serialize_field("speed", &speed)?; - virtio_net_config.serialize_field("duplex", &duplex)?; - virtio_net_config.end() - } -} - // Safe because it only has data and has no implicit padding. unsafe impl ByteValued for VirtioNetConfig {}