Struct DeviceCounters 

pub struct DeviceCounters<C = Counter>
where
    C: CounterRepr,
{

    pub send_total_frames: C,
    pub send_frame: C,
    pub send_bytes: C,
    pub send_queue_full: C,
    pub send_serialize_error: C,
    pub recv_frame: C,
    pub recv_bytes: C,
    pub recv_parse_error: C,
    pub recv_ipv4_delivered: C,
    pub recv_ipv6_delivered: C,
    pub send_ipv4_frame: C,
    pub send_ipv6_frame: C,
    pub send_dropped_no_queue: C,
    pub send_dropped_dequeue: C,
}

Device layer counters.

Fields

send_total_frames: C

Count of outgoing frames which enter the device layer (but may or may not have been dropped prior to reaching the wire).

send_frame: C

Count of frames sent.

send_bytes: C

Count of bytes sent.

send_queue_full: C

Count of frames that failed to send because of a full Tx queue.

send_serialize_error: C

Count of frames that failed to send because of a serialization error.

recv_frame: C

Count of frames received.

recv_bytes: C

Count of bytes received.

recv_parse_error: C

Count of incoming frames dropped due to a parsing error.

recv_ipv4_delivered: C

Count of incoming frames containing an IPv4 packet delivered.

recv_ipv6_delivered: C

Count of incoming frames containing an IPv6 packet delivered.

send_ipv4_frame: C

Count of sent frames containing an IPv4 packet.

send_ipv6_frame: C

Count of sent frames containing an IPv6 packet.

send_dropped_no_queue: C

Count of frames that failed to send because there was no Tx queue.

send_dropped_dequeue: C

Count of frames that were dropped during Tx queue dequeuing.

Implementations

impl DeviceCounters

pub fn send_frame<I>(&self) -> &Counter

where I: Ip,

Either send_ipv4_frame or send_ipv6_frame depending on I.

impl DeviceCounters<u64>

pub fn assert_counters<D, CC>(&self, core_ctx: &CC, device: &D)

where CC: ResourceCounterContext<D, DeviceCounters>,

Assert that the counters tracked by core_ctx match expectations.

Trait Implementations

impl<C> CounterCollection for DeviceCounters<C>

where C: CounterRepr,

type Spec = DeviceCounters

The CounterCollectionSpec associated with this collection.

type Repr = C

The counter representation held by this collection.

fn cast<C>(&self) -> <Self::Spec as CounterCollectionSpec>::CounterCollection<C>

where C: CounterRepr,

A utility method to cast this collection of counters into a different underlying counter representation.

impl CounterCollectionSpec for DeviceCounters

type CounterCollection<C: CounterRepr> = DeviceCounters<C>

The underlying CounterCollection for this specification.

fn transform<C1, C2>(counters: &DeviceCounters<C1>) -> DeviceCounters<C2>

where C1: CounterRepr, C2: CounterRepr,

A utility method to transform the underlying counter representation within Self::CounterCollection.

impl<BT: BindingsTypes, L> CounterContext<DeviceCounters> for CoreCtx<'_, BT, L>

fn counters(&self) -> &DeviceCounters

Returns a reference to the counters.

impl<C> Debug for DeviceCounters<C>

where C: Debug + CounterRepr,

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

Formats the value using the given formatter.

impl<C> Default for DeviceCounters<C>

where C: Default + CounterRepr,

fn default() -> DeviceCounters<C>

Returns the “default value” for a type.

impl Inspectable for DeviceCounters

fn record<I>(&self, inspector: &mut I)

where I: Inspector,

Records this value into inspector.

impl<C> PartialEq for DeviceCounters<C>

where C: PartialEq + CounterRepr,

fn eq(&self, other: &DeviceCounters<C>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, BC: BindingsContext, D: DeviceStateSpec, L> ResourceCounterContext<BaseDeviceId<D, BC>, DeviceCounters> for CoreCtx<'a, BC, L>

fn per_resource_counters<'b>( &'b self, device_id: &'b BaseDeviceId<D, BC>, ) -> &'b DeviceCounters

Returns a reference to the set of counters on resource.

fn increment_both<F>(&self, resource: &R, cb: F)

where F: Fn(&T) -> &Counter,

Increments both the per-resource and stackwide versions of the counter returned by the callback.

fn add_both<F>(&self, resource: &R, value: u64, cb: F)

where F: Fn(&T) -> &Counter,

Adds value to both the per-resource and stackwide versions of the counter returned by the callback.

fn add_both_usize<F>(&self, resource: &R, value: usize, cb: F)

where F: Fn(&T) -> &Counter,

Like add_both but takes a usize value, saturating to u64::max if conversion fails.

impl<'a, BC: BindingsContext, L> ResourceCounterContext<DeviceId<BC>, DeviceCounters> for CoreCtx<'a, BC, L>

fn per_resource_counters<'b>( &'b self, device_id: &'b DeviceId<BC>, ) -> &'b DeviceCounters

Returns a reference to the set of counters on resource.

fn increment_both<F>(&self, resource: &R, cb: F)

where F: Fn(&T) -> &Counter,

Increments both the per-resource and stackwide versions of the counter returned by the callback.

fn add_both<F>(&self, resource: &R, value: u64, cb: F)

where F: Fn(&T) -> &Counter,

Adds value to both the per-resource and stackwide versions of the counter returned by the callback.

fn add_both_usize<F>(&self, resource: &R, value: usize, cb: F)

where F: Fn(&T) -> &Counter,

Like add_both but takes a usize value, saturating to u64::max if conversion fails.

impl<C> StructuralPartialEq for DeviceCounters<C>

where C: CounterRepr,