Struct Net 

pub struct Net {
    pub tap: Tap,
    pub mmds_ns: Option<MmdsNetworkStack>,
    /* private fields */
}

VirtIO network device.

It emulates a network device able to exchange L2 frames between the guest and a host-side tap device.

Fields

tap: Tap

The backend for this device: a tap.

mmds_ns: Option<MmdsNetworkStack>

The MMDS stack corresponding to this interface. Only if MMDS transport has been associated with it.

Implementations

impl Net

pub fn new_with_tap( id: String, tap: Tap, guest_mac: Option<MacAddr>, rx_rate_limiter: RateLimiter, tx_rate_limiter: RateLimiter, ) -> Result<Self, NetError>

Create a new virtio network device with the given TAP interface.

pub fn new( id: String, tap_if_name: &str, guest_mac: Option<MacAddr>, rx_rate_limiter: RateLimiter, tx_rate_limiter: RateLimiter, ) -> Result<Self, NetError>

Create a new virtio network device given the interface name.

pub fn id(&self) -> &String

Provides the ID of this net device.

pub fn guest_mac(&self) -> Option<&MacAddr>

Provides the MAC of this net device.

pub fn iface_name(&self) -> String

Provides the host IFACE name of this net device.

pub fn mmds_ns(&self) -> Option<&MmdsNetworkStack>

Provides the MmdsNetworkStack of this net device.

pub fn configure_mmds_network_stack( &mut self, ipv4_addr: Ipv4Addr, mmds: Arc<Mutex<Mmds>>, )

Configures the MmdsNetworkStack to allow device to forward MMDS requests. If the device already supports MMDS, updates the IPv4 address.

pub fn disable_mmds_network_stack(&mut self)

Disables the MmdsNetworkStack to prevent device to forward MMDS requests.

pub fn rx_rate_limiter(&self) -> &RateLimiter

Provides a reference to the configured RX rate limiter.

pub fn tx_rate_limiter(&self) -> &RateLimiter

Provides a reference to the configured TX rate limiter.

pub fn rate_limited_rx_single_frame(&mut self, frame_size: u32) -> bool

pub fn parse_rx_descriptors(&mut self) -> Result<(), InvalidAvailIdx>

Parse available RX DescriptorChains from the queue

pub fn build_tap_offload_features(guest_supported_features: u64) -> u32

Builds the offload features we will setup on the TAP device based on the features that the guest supports.

pub fn patch_rate_limiters( &mut self, rx_bytes: BucketUpdate, rx_ops: BucketUpdate, tx_bytes: BucketUpdate, tx_ops: BucketUpdate, )

Updates the parameters for the rate limiters

pub unsafe fn read_tap(&mut self) -> Result<usize>

Reads a frame from the TAP device inside the first descriptor held by self.rx_buffer.

Safety

self.rx_buffer needs to have at least one descriptor chain parsed

pub fn process_rx_queue_event(&mut self)

Process a single RX queue event.

This is called by the event manager responding to the guest adding a new buffer in the RX queue.

pub fn process_tap_rx_event(&mut self)

pub fn process_tx_queue_event(&mut self)

Process a single TX queue event.

This is called by the event manager responding to the guest adding a new buffer in the TX queue.

pub fn process_rx_rate_limiter_event(&mut self)

pub fn process_tx_rate_limiter_event(&mut self)

pub fn process_virtio_queues(&mut self) -> Result<(), InvalidAvailIdx>

Process device virtio queue(s).

pub fn prepare_save(&mut self)

Prepare saving state

Trait Implementations

impl Debug for Net

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<&Net> for NetworkInterfaceConfig

fn from(net: &Net) -> Self

Converts to this type from the input type.

impl MutEventSubscriber for Net

fn process(&mut self, event: Events, ops: &mut EventOps<'_>)

Process events triggered in the event manager loop.

fn init(&mut self, ops: &mut EventOps<'_>)

Initialization called by the EventManager when the subscriber is registered.

impl Persist<'_> for Net

type State = NetState

The type of the object representing the state of the component.

type ConstructorArgs = NetConstructorArgs

The type of the object holding the constructor arguments.

type Error = NetPersistError

The type of the error that can occur while constructing the object.

fn save(&self) -> Self::State

Returns the current state of the component.

fn restore( constructor_args: Self::ConstructorArgs, state: &Self::State, ) -> Result<Self, Self::Error>

Constructs a component from a specified state.

impl VirtioDevice for Net

fn const_device_type() -> u32

The virtio device type (as a constant of the struct).

fn device_type(&self) -> u32

The virtio device type.

fn avail_features(&self) -> u64

Get the available features offered by device.

fn acked_features(&self) -> u64

Get acknowledged features of the driver.

fn set_acked_features(&mut self, acked_features: u64)

Set acknowledged features of the driver. This function must maintain the following invariant:

fn queues(&self) -> &[Queue]

Returns the device queues.

fn queues_mut(&mut self) -> &mut [Queue]

Returns a mutable reference to the device queues.

fn queue_events(&self) -> &[EventFd]

Returns the device queues event fds.

fn interrupt_trigger(&self) -> &dyn VirtioInterrupt

fn read_config(&self, offset: u64, data: &mut [u8])

Reads this device configuration space at offset.

fn write_config(&mut self, offset: u64, data: &[u8])

Writes to this device configuration space at offset.

fn activate( &mut self, mem: GuestMemoryMmap, interrupt: Arc<dyn VirtioInterrupt>, ) -> Result<(), ActivateError>

Performs the formal activation for a device, which can be verified also with is_activated.

fn is_activated(&self) -> bool

Checks if the resources of this device are activated.

fn kick(&mut self)

Kick the device, as if it had received external events.

fn has_feature(&self, feature: u64) -> bool

Check if virtio device has negotiated given feature.

fn interrupt_status(&self) -> Arc<AtomicU32>

Returns the current device interrupt status.

fn avail_features_by_page(&self, page: u32) -> u32

The set of feature bits shifted by page * 32.

fn ack_features_by_page(&mut self, page: u32, value: u32)

Acknowledges that this set of features should be enabled.

fn reset(&mut self) -> Option<(Arc<dyn VirtioInterrupt>, Vec<EventFd>)>

Optionally deactivates this device and returns ownership of the guest memory map, interrupt event, and queue events.

fn mark_queue_memory_dirty( &mut self, mem: &GuestMemoryMmap, ) -> Result<(), QueueError>

Mark pages used by queues as dirty.

fn as_cow_file_engine(&self) -> Option<&CowFileEngine>

Returns a COW file engine if the device exposes one (NYX extension).

fn nyx_handle_queue_event(&mut self, _queue_index: u16)

Handle a queue notification from an MMIO write (NYX extension).