Struct IpCounters 

pub struct IpCounters<I: IpCountersIpExt, C: CounterRepr = Counter> {

    pub deliver_unicast: C,
    pub deliver_multicast: C,
    pub dispatch_receive_ip_packet: C,
    pub dispatch_receive_ip_packet_other_host: C,
    pub receive_ip_packet: C,
    pub send_ip_packet: C,
    pub forwarding_disabled: C,
    pub forward: C,
    pub no_route_to_host: C,
    pub mtu_exceeded: C,
    pub ttl_expired: C,
    pub receive_icmp_error: C,
    pub fragment_reassembly_error: C,
    pub need_more_fragments: C,
    pub invalid_fragment: C,
    pub fragment_cache_full: C,
    pub parameter_problem: C,
    pub unspecified_destination: C,
    pub unspecified_source: C,
    pub invalid_source: C,
    pub dropped: C,
    pub drop_for_tentative: C,
    pub tx_illegal_loopback_address: C,
    pub version_rx: <I::RxCounters as CounterCollectionSpec>::CounterCollection<C>,
    pub multicast_no_interest: C,
    pub invalid_cached_conntrack_entry: C,
    pub fragmentation: FragmentationCounters<C>,
    pub socket_egress_filter_dropped: C,
}

Ip layer counters.

Fields

deliver_unicast: C

Count of incoming IP unicast packets delivered.

deliver_multicast: C

Count of incoming IP multicast packets delivered.

dispatch_receive_ip_packet: C

Count of incoming IP packets that are dispatched to the appropriate protocol.

dispatch_receive_ip_packet_other_host: C

Count of incoming IP packets destined to another host.

receive_ip_packet: C

Count of incoming IP packets received by the stack.

send_ip_packet: C

Count of sent outgoing IP packets.

forwarding_disabled: C

Count of packets to be forwarded which are instead dropped because forwarding is disabled.

forward: C

Count of incoming packets forwarded to another host.

no_route_to_host: C

Count of incoming packets which cannot be forwarded because there is no route to the destination host.

mtu_exceeded: C

Count of incoming packets which cannot be forwarded because the MTU has been exceeded.

ttl_expired: C

Count of incoming packets which cannot be forwarded because the TTL has expired.

receive_icmp_error: C

Count of ICMP error messages received.

fragment_reassembly_error: C

Count of IP fragment reassembly errors.

need_more_fragments: C

Count of IP fragments that could not be reassembled because more fragments were needed.

invalid_fragment: C

Count of IP fragments that could not be reassembled because the fragment was invalid.

fragment_cache_full: C

Count of IP fragments that could not be reassembled because the stack’s per-IP-protocol fragment cache was full.

parameter_problem: C

Count of incoming IP packets not delivered because of a parameter problem.

unspecified_destination: C

Count of incoming IP packets with an unspecified destination address.

unspecified_source: C

Count of incoming IP packets with an unspecified source address.

invalid_source: C

Count of incoming IP packets with an invalid source address. See the definitions of net_types::ip::Ipv4SourceAddr and net_types::ip::Ipv6SourceAddr for the exact requirements.

dropped: C

Count of incoming IP packets dropped.

drop_for_tentative: C

Count of incoming packets dropped because the destination address is only tentatively assigned to the device.

tx_illegal_loopback_address: C

Number of frames rejected because they’d cause illegal loopback addresses on the wire.

version_rx: <I::RxCounters as CounterCollectionSpec>::CounterCollection<C>

Version specific rx counters.

multicast_no_interest: C

Count of incoming IP multicast packets that were dropped because The stack doesn’t have any sockets that belong to the multicast group, and the stack isn’t configured to forward the multicast packet.

invalid_cached_conntrack_entry: C

Count of looped-back packets that held a cached conntrack entry that could not be downcasted to the expected type. This would happen if, for example, a packet was modified to a different IP version between EGRESS and INGRESS.

fragmentation: FragmentationCounters<C>

IP fragmentation counters.

socket_egress_filter_dropped: C

Number of packets filtered out by the socket egress filter.

Implementations

impl<I: IpCountersIpExt> IpCounters<I, u64>

pub fn expect_dispatched(count: u64) -> Self

Constructs the expected counter state when the given count of IP packets have been received & dispatched.

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

Assert that the counters tracked by core_ctx match expectations.

Trait Implementations

impl<I: IpCountersIpExt, C: CounterRepr + CounterRepr> CounterCollection for IpCounters<I, C>

type Spec = IpCounters<I>

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<I: IpCountersIpExt> CounterCollectionSpec for IpCounters<I, Counter>

type CounterCollection<C: CounterRepr> = IpCounters<I, C>

The underlying CounterCollection for this specification.

fn transform<C1: CounterRepr, C2: CounterRepr>( counters: &IpCounters<I, C1>, ) -> IpCounters<I, C2>

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

impl<I: Debug + IpCountersIpExt, C: Debug + CounterRepr> Debug for IpCounters<I, C>

where I::RxCounters: Debug,

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

Formats the value using the given formatter.

impl<I: Default + IpCountersIpExt, C: Default + CounterRepr> Default for IpCounters<I, C>

where I::RxCounters: Default,

fn default() -> IpCounters<I, C>

Returns the “default value” for a type.

impl<I: IpCountersIpExt, C: CounterRepr, IpType> GenericOverIp<IpType> for IpCounters<I, C>

where IpType: IpCountersIpExt + Ip,

type Type = IpCounters<IpType, C>

The type of Self when its IP-generic parameter is replaced with the type NewIp.

impl<I: IpCountersIpExt> Inspectable for IpCounters<I>

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

Records this value into inspector.

impl<I: PartialEq + IpCountersIpExt, C: PartialEq + CounterRepr> PartialEq for IpCounters<I, C>

where I::RxCounters: PartialEq,

fn eq(&self, other: &IpCounters<I, 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<I: IpCountersIpExt, C: CounterRepr> StructuralPartialEq for IpCounters<I, C>