subsys/net/ip/net_stats.c - third_party/github/zephyrproject-rtos/zephyr - Git at Google

 /*
  * Copyright (c) 2016 Intel Corporation
  *
  * SPDX-License-Identifier: Apache-2.0
  */

 #if defined(CONFIG_NET_STATISTICS_PERIODIC_OUTPUT)
 #define NET_LOG_LEVEL LOG_LEVEL_INF
 #else
 #define NET_LOG_LEVEL CONFIG_NET_STATISTICS_LOG_LEVEL
 #endif

 #include <zephyr/logging/log.h>
 LOG_MODULE_REGISTER(net_stats, NET_LOG_LEVEL);

 #include <zephyr/kernel.h>
 #include <string.h>
 #include <stdlib.h>
 #include <errno.h>
 #include <zephyr/net/net_core.h>
 #include <zephyr/net/prometheus/collector.h>
 #include <zephyr/net/prometheus/counter.h>
 #include <zephyr/net/prometheus/gauge.h>
 #include <zephyr/net/prometheus/histogram.h>
 #include <zephyr/net/prometheus/summary.h>

 #include "net_stats.h"
 #include "net_private.h"

 /* Global network statistics.
  *
  * The variable needs to be global so that the GET_STAT() macro can access it
  * from net_shell.c
  */
 struct net_stats net_stats = { 0 };

 #if defined(CONFIG_NET_STATISTICS_PERIODIC_OUTPUT)

 #define PRINT_STATISTICS_INTERVAL (30 * MSEC_PER_SEC)

 #if NET_TC_COUNT > 1
 static const char *priority2str(enum net_priority priority)
 {
 	switch (priority) {
 	case NET_PRIORITY_BK:
 		return "BK"; /* Background */
 	case NET_PRIORITY_BE:
 		return "BE"; /* Best effort */
 	case NET_PRIORITY_EE:
 		return "EE"; /* Excellent effort */
 	case NET_PRIORITY_CA:
 		return "CA"; /* Critical applications */
 	case NET_PRIORITY_VI:
 		return "VI"; /* Video, < 100 ms latency and jitter */
 	case NET_PRIORITY_VO:
 		return "VO"; /* Voice, < 10 ms latency and jitter  */
 	case NET_PRIORITY_IC:
 		return "IC"; /* Internetwork control */
 	case NET_PRIORITY_NC:
 		return "NC"; /* Network control */
 	}

 	return "??";
 }
 #endif

 static inline int64_t cmp_val(uint64_t val1, uint64_t val2)
 {
 	return (int64_t)(val1 - val2);
 }

 static inline void stats(struct net_if *iface)
 {
 	static uint64_t next_print;
 	uint64_t curr = k_uptime_get();
 	int64_t cmp = cmp_val(curr, next_print);
 	int i;

 	if (!next_print || (abs(cmp) > PRINT_STATISTICS_INTERVAL)) {
 		if (iface) {
 			NET_INFO("Interface %p [%d]", iface,
 				 net_if_get_by_iface(iface));
 		} else {
 			NET_INFO("Global statistics:");
 		}

 #if defined(CONFIG_NET_STATISTICS_IPV6)
 		NET_INFO("IPv6 recv      %d\tsent\t%d\tdrop\t%d\tforwarded\t%d",
 			 GET_STAT(iface, ipv6.recv),
 			 GET_STAT(iface, ipv6.sent),
 			 GET_STAT(iface, ipv6.drop),
 			 GET_STAT(iface, ipv6.forwarded));
 #if defined(CONFIG_NET_STATISTICS_IPV6_ND)
 		NET_INFO("IPv6 ND recv   %d\tsent\t%d\tdrop\t%d",
 			 GET_STAT(iface, ipv6_nd.recv),
 			 GET_STAT(iface, ipv6_nd.sent),
 			 GET_STAT(iface, ipv6_nd.drop));
 #endif /* CONFIG_NET_STATISTICS_IPV6_ND */
 #if defined(CONFIG_NET_STATISTICS_IPV6_PMTU)
 		NET_INFO("IPv6 PMTU recv %d\tsent\t%d\tdrop\t%d",
 			 GET_STAT(iface, ipv6_pmtu.recv),
 			 GET_STAT(iface, ipv6_pmtu.sent),
 			 GET_STAT(iface, ipv6_pmtu.drop));
 #endif /* CONFIG_NET_STATISTICS_IPV6_PMTU */
 #if defined(CONFIG_NET_STATISTICS_MLD)
 		NET_INFO("IPv6 MLD recv  %d\tsent\t%d\tdrop\t%d",
 			 GET_STAT(iface, ipv6_mld.recv),
 			 GET_STAT(iface, ipv6_mld.sent),
 			 GET_STAT(iface, ipv6_mld.drop));
 #endif /* CONFIG_NET_STATISTICS_MLD */
 #endif /* CONFIG_NET_STATISTICS_IPV6 */

 #if defined(CONFIG_NET_STATISTICS_IPV4)
 		NET_INFO("IPv4 recv      %d\tsent\t%d\tdrop\t%d\tforwarded\t%d",
 			 GET_STAT(iface, ipv4.recv),
 			 GET_STAT(iface, ipv4.sent),
 			 GET_STAT(iface, ipv4.drop),
 			 GET_STAT(iface, ipv4.forwarded));
 #endif /* CONFIG_NET_STATISTICS_IPV4 */

 		NET_INFO("IP vhlerr      %d\thblener\t%d\tlblener\t%d",
 			 GET_STAT(iface, ip_errors.vhlerr),
 			 GET_STAT(iface, ip_errors.hblenerr),
 			 GET_STAT(iface, ip_errors.lblenerr));
 		NET_INFO("IP fragerr     %d\tchkerr\t%d\tprotoer\t%d",
 			 GET_STAT(iface, ip_errors.fragerr),
 			 GET_STAT(iface, ip_errors.chkerr),
 			 GET_STAT(iface, ip_errors.protoerr));

 #if defined(CONFIG_NET_STATISTICS_IPV4_PMTU)
 		NET_INFO("IPv4 PMTU recv %d\tsent\t%d\tdrop\t%d",
 			 GET_STAT(iface, ipv4_pmtu.recv),
 			 GET_STAT(iface, ipv4_pmtu.sent),
 			 GET_STAT(iface, ipv4_pmtu.drop));
 #endif /* CONFIG_NET_STATISTICS_IPV4_PMTU */

 		NET_INFO("ICMP recv      %d\tsent\t%d\tdrop\t%d",
 			 GET_STAT(iface, icmp.recv),
 			 GET_STAT(iface, icmp.sent),
 			 GET_STAT(iface, icmp.drop));
 		NET_INFO("ICMP typeer    %d\tchkerr\t%d",
 			 GET_STAT(iface, icmp.typeerr),
 			 GET_STAT(iface, icmp.chkerr));

 #if defined(CONFIG_NET_STATISTICS_UDP)
 		NET_INFO("UDP recv       %d\tsent\t%d\tdrop\t%d",
 			 GET_STAT(iface, udp.recv),
 			 GET_STAT(iface, udp.sent),
 			 GET_STAT(iface, udp.drop));
 		NET_INFO("UDP chkerr     %d",
 			 GET_STAT(iface, udp.chkerr));
 #endif

 #if defined(CONFIG_NET_STATISTICS_TCP)
 		NET_INFO("TCP bytes recv %u\tsent\t%d",
 			 GET_STAT(iface, tcp.bytes.received),
 			 GET_STAT(iface, tcp.bytes.sent));
 		NET_INFO("TCP seg recv   %d\tsent\t%d\tdrop\t%d",
 			 GET_STAT(iface, tcp.recv),
 			 GET_STAT(iface, tcp.sent),
 			 GET_STAT(iface, tcp.drop));
 		NET_INFO("TCP seg resent %d\tchkerr\t%d\tackerr\t%d",
 			 GET_STAT(iface, tcp.resent),
 			 GET_STAT(iface, tcp.chkerr),
 			 GET_STAT(iface, tcp.ackerr));
 		NET_INFO("TCP seg rsterr %d\trst\t%d\tre-xmit\t%d",
 			 GET_STAT(iface, tcp.rsterr),
 			 GET_STAT(iface, tcp.rst),
 			 GET_STAT(iface, tcp.rexmit));
 		NET_INFO("TCP conn drop  %d\tconnrst\t%d",
 			 GET_STAT(iface, tcp.conndrop),
 			 GET_STAT(iface, tcp.connrst));
 #endif

 		NET_INFO("Bytes received %u", GET_STAT(iface, bytes.received));
 		NET_INFO("Bytes sent     %u", GET_STAT(iface, bytes.sent));
 		NET_INFO("Processing err %d",
 			 GET_STAT(iface, processing_error));

 #if NET_TC_COUNT > 1
 #if NET_TC_TX_COUNT > 1
 		NET_INFO("TX traffic class statistics:");
 		NET_INFO("TC  Priority\tSent pkts\tbytes");

 		for (i = 0; i < NET_TC_TX_COUNT; i++) {
 			NET_INFO("[%d] %s (%d)\t%d\t\t%d", i,
 				 priority2str(GET_STAT(iface,
 						       tc.sent[i].priority)),
 				 GET_STAT(iface, tc.sent[i].priority),
 				 GET_STAT(iface, tc.sent[i].pkts),
 				 GET_STAT(iface, tc.sent[i].bytes));
 		}
 #endif

 #if NET_TC_RX_COUNT > 1
 		NET_INFO("RX traffic class statistics:");
 		NET_INFO("TC  Priority\tRecv pkts\tbytes");

 		for (i = 0; i < NET_TC_RX_COUNT; i++) {
 			NET_INFO("[%d] %s (%d)\t%d\t\t%d", i,
 				 priority2str(GET_STAT(iface,
 						       tc.recv[i].priority)),
 				 GET_STAT(iface, tc.recv[i].priority),
 				 GET_STAT(iface, tc.recv[i].pkts),
 				 GET_STAT(iface, tc.recv[i].bytes));
 		}
 #endif
 #else /* NET_TC_COUNT > 1 */
 		ARG_UNUSED(i);
 #endif /* NET_TC_COUNT > 1 */

 #if defined(CONFIG_NET_STATISTICS_POWER_MANAGEMENT)
 		NET_INFO("Power management statistics:");
 		NET_INFO("Last suspend time: %u ms",
 			 GET_STAT(iface, pm.last_suspend_time));
 		NET_INFO("Got suspended %d times",
 			 GET_STAT(iface, pm.suspend_count));
 		NET_INFO("Average suspend time: %u ms",
 			 (uint32_t)(GET_STAT(iface, pm.overall_suspend_time) /
 				 GET_STAT(iface, pm.suspend_count)));
 		NET_INFO("Total suspended time: %llu ms",
 			 GET_STAT(iface, pm.overall_suspend_time));
 #endif
 		next_print = curr + PRINT_STATISTICS_INTERVAL;
 	}
 }

 void net_print_statistics_iface(struct net_if *iface)
 {
 	/* In order to make the info print lines shorter, use shorter
 	 * function name.
 	 */
 	stats(iface);
 }

 static void iface_cb(struct net_if *iface, void *user_data)
 {
 	net_print_statistics_iface(iface);
 }

 void net_print_statistics_all(void)
 {
 	net_if_foreach(iface_cb, NULL);
 }

 void net_print_statistics(void)
 {
 	net_print_statistics_iface(NULL);
 }

 #endif /* CONFIG_NET_STATISTICS_PERIODIC_OUTPUT */

 #if defined(CONFIG_NET_STATISTICS_USER_API)

 static int net_stats_get(uint32_t mgmt_request, struct net_if *iface,
 			 void *data, size_t len)
 {
 	size_t len_chk = 0;
 	void *src = NULL;

 	switch (NET_MGMT_GET_COMMAND(mgmt_request)) {
 	case NET_REQUEST_STATS_CMD_GET_ALL:
 		len_chk = sizeof(struct net_stats);
 #if defined(CONFIG_NET_STATISTICS_PER_INTERFACE)
 		src = iface ? &iface->stats : &net_stats;
 #else
 		src = &net_stats;
 #endif
 		break;
 	case NET_REQUEST_STATS_CMD_GET_PROCESSING_ERROR:
 		len_chk = sizeof(net_stats_t);
 		src = GET_STAT_ADDR(iface, processing_error);
 		break;
 	case NET_REQUEST_STATS_CMD_GET_BYTES:
 		len_chk = sizeof(struct net_stats_bytes);
 		src = GET_STAT_ADDR(iface, bytes);
 		break;
 	case NET_REQUEST_STATS_CMD_GET_IP_ERRORS:
 		len_chk = sizeof(struct net_stats_ip_errors);
 		src = GET_STAT_ADDR(iface, ip_errors);
 		break;
 #if defined(CONFIG_NET_STATISTICS_IPV4)
 	case NET_REQUEST_STATS_CMD_GET_IPV4:
 		len_chk = sizeof(struct net_stats_ip);
 		src = GET_STAT_ADDR(iface, ipv4);
 		break;
 #endif
 #if defined(CONFIG_NET_STATISTICS_IPV6)
 	case NET_REQUEST_STATS_CMD_GET_IPV6:
 		len_chk = sizeof(struct net_stats_ip);
 		src = GET_STAT_ADDR(iface, ipv6);
 		break;
 #endif
 #if defined(CONFIG_NET_STATISTICS_IPV6_ND)
 	case NET_REQUEST_STATS_CMD_GET_IPV6_ND:
 		len_chk = sizeof(struct net_stats_ipv6_nd);
 		src = GET_STAT_ADDR(iface, ipv6_nd);
 		break;
 #endif
 #if defined(CONFIG_NET_STATISTICS_IPV6_PMTU)
 	case NET_REQUEST_STATS_CMD_GET_IPV6_PMTU:
 		len_chk = sizeof(struct net_stats_ipv6_pmtu);
 		src = GET_STAT_ADDR(iface, ipv6_pmtu);
 		break;
 #endif
 #if defined(CONFIG_NET_STATISTICS_IPV4_PMTU)
 	case NET_REQUEST_STATS_CMD_GET_IPV4_PMTU:
 		len_chk = sizeof(struct net_stats_ipv4_pmtu);
 		src = GET_STAT_ADDR(iface, ipv4_pmtu);
 		break;
 #endif
 #if defined(CONFIG_NET_STATISTICS_ICMP)
 	case NET_REQUEST_STATS_CMD_GET_ICMP:
 		len_chk = sizeof(struct net_stats_icmp);
 		src = GET_STAT_ADDR(iface, icmp);
 		break;
 #endif
 #if defined(CONFIG_NET_STATISTICS_UDP)
 	case NET_REQUEST_STATS_CMD_GET_UDP:
 		len_chk = sizeof(struct net_stats_udp);
 		src = GET_STAT_ADDR(iface, udp);
 		break;
 #endif
 #if defined(CONFIG_NET_STATISTICS_TCP)
 	case NET_REQUEST_STATS_CMD_GET_TCP:
 		len_chk = sizeof(struct net_stats_tcp);
 		src = GET_STAT_ADDR(iface, tcp);
 		break;
 #endif
 #if defined(CONFIG_NET_STATISTICS_POWER_MANAGEMENT)
 	case NET_REQUEST_STATS_GET_PM:
 		len_chk = sizeof(struct net_stats_pm);
 		src = GET_STAT_ADDR(iface, pm);
 		break;
 #endif
 	}

 	if (len != len_chk || !src) {
 		return -EINVAL;
 	}

 	memcpy(data, src, len);

 	return 0;
 }

 NET_MGMT_REGISTER_REQUEST_HANDLER(NET_REQUEST_STATS_GET_ALL,
 				  net_stats_get);

 NET_MGMT_REGISTER_REQUEST_HANDLER(NET_REQUEST_STATS_GET_PROCESSING_ERROR,
 				  net_stats_get);

 NET_MGMT_REGISTER_REQUEST_HANDLER(NET_REQUEST_STATS_GET_BYTES,
 				  net_stats_get);

 NET_MGMT_REGISTER_REQUEST_HANDLER(NET_REQUEST_STATS_GET_IP_ERRORS,
 				  net_stats_get);

 #if defined(CONFIG_NET_STATISTICS_IPV4)
 NET_MGMT_REGISTER_REQUEST_HANDLER(NET_REQUEST_STATS_GET_IPV4,
 				  net_stats_get);
 #endif

 #if defined(CONFIG_NET_STATISTICS_IPV6)
 NET_MGMT_REGISTER_REQUEST_HANDLER(NET_REQUEST_STATS_GET_IPV6,
 				  net_stats_get);
 #endif

 #if defined(CONFIG_NET_STATISTICS_IPV6_ND)
 NET_MGMT_REGISTER_REQUEST_HANDLER(NET_REQUEST_STATS_GET_IPV6_ND,
 				  net_stats_get);
 #endif

 #if defined(CONFIG_NET_STATISTICS_IPV6_PMTU)
 NET_MGMT_REGISTER_REQUEST_HANDLER(NET_REQUEST_STATS_GET_IPV6_PMTU,
 				  net_stats_get);
 #endif

 #if defined(CONFIG_NET_STATISTICS_IPV4_PMTU)
 NET_MGMT_REGISTER_REQUEST_HANDLER(NET_REQUEST_STATS_GET_IPV4_PMTU,
 				  net_stats_get);
 #endif

 #if defined(CONFIG_NET_STATISTICS_ICMP)
 NET_MGMT_REGISTER_REQUEST_HANDLER(NET_REQUEST_STATS_GET_ICMP,
 				  net_stats_get);
 #endif

 #if defined(CONFIG_NET_STATISTICS_UDP)
 NET_MGMT_REGISTER_REQUEST_HANDLER(NET_REQUEST_STATS_GET_UDP,
 				  net_stats_get);
 #endif

 #if defined(CONFIG_NET_STATISTICS_TCP)
 NET_MGMT_REGISTER_REQUEST_HANDLER(NET_REQUEST_STATS_GET_TCP,
 				  net_stats_get);
 #endif

 #if defined(CONFIG_NET_STATISTICS_POWER_MANAGEMENT)
 NET_MGMT_REGISTER_REQUEST_HANDLER(NET_REQUEST_STATS_GET_PM,
 				  net_stats_get);
 #endif

 #endif /* CONFIG_NET_STATISTICS_USER_API */

 void net_stats_reset(struct net_if *iface)
 {
 	if (iface) {
 		net_if_stats_reset(iface);
 		return;
 	}

 	net_if_stats_reset_all();
 	memset(&net_stats, 0, sizeof(net_stats));
 }

 #if defined(CONFIG_NET_STATISTICS_VIA_PROMETHEUS)
 static void register_prometheus_metrics(struct net_if *iface)
 {
 	int total_count = 0;

 	/* Find the correct collector for this interface */
 	STRUCT_SECTION_FOREACH(prometheus_collector, entry) {
 		if (entry->user_data == (void *)iface) {
 			iface->collector = entry;
 			break;
 		}
 	}

 	if (iface->collector == NULL) {
 		NET_DBG("No collector found for interface %d",
 			net_if_get_by_iface(iface));
 		return;
 	}

 	STRUCT_SECTION_FOREACH(prometheus_counter, entry) {
 		if (entry->base.collector != iface->collector) {
 			continue;
 		}

 		prometheus_collector_register_metric(iface->collector,
 						     &entry->base);
 		total_count++;
 	}

 	STRUCT_SECTION_FOREACH(prometheus_gauge, entry) {
 		if (entry->base.collector != iface->collector) {
 			continue;
 		}

 		prometheus_collector_register_metric(iface->collector,
 						     &entry->base);
 		total_count++;
 	}

 	STRUCT_SECTION_FOREACH(prometheus_summary, entry) {
 		if (entry->base.collector != iface->collector) {
 			continue;
 		}

 		prometheus_collector_register_metric(iface->collector,
 						     &entry->base);
 		total_count++;
 	}

 	STRUCT_SECTION_FOREACH(prometheus_histogram, entry) {
 		if (entry->base.collector != iface->collector) {
 			continue;
 		}

 		prometheus_collector_register_metric(iface->collector,
 						     &entry->base);
 		total_count++;
 	}

 	NET_DBG("Registered %d metrics for interface %d", total_count,
 		net_if_get_by_iface(iface));
 }

 /* Do not update metrics one by one as that would require searching
  * each individual metric from the collector. Instead, let the
  * Prometheus API scrape the data from net_stats stored in net_if when
  * needed.
  */
 int net_stats_prometheus_scrape(struct prometheus_collector *collector,
 				struct prometheus_metric *metric,
 				void *user_data)
 {
 	struct net_if *iface = user_data;
 	net_stats_t value;

 	if (!iface) {
 		return -EINVAL;
 	}

 	if (iface->collector != collector) {
 		return -EINVAL;
 	}

 	/* Update the metrics */
 	if (metric->type == PROMETHEUS_COUNTER) {
 		struct prometheus_counter *counter =
 			CONTAINER_OF(metric, struct prometheus_counter, base);

 		if (counter->user_data == NULL) {
 			return -EAGAIN;
 		}

 		value = *((net_stats_t *)counter->user_data);

 		prometheus_counter_set(counter, (uint64_t)value);

 	} else if (metric->type == PROMETHEUS_GAUGE) {
 		struct prometheus_gauge *gauge =
 			CONTAINER_OF(metric, struct prometheus_gauge, base);

 		if (gauge->user_data == NULL) {
 			return -EAGAIN;
 		}

 		value = *((net_stats_t *)gauge->user_data);

 		prometheus_gauge_set(gauge, (double)value);

 	} else if (metric->type == PROMETHEUS_HISTOGRAM) {
 		struct prometheus_histogram *histogram =
 			CONTAINER_OF(metric, struct prometheus_histogram, base);

 		if (histogram->user_data == NULL) {
 			return -EAGAIN;
 		}

 	} else if (metric->type == PROMETHEUS_SUMMARY) {
 		struct prometheus_summary *summary =
 			CONTAINER_OF(metric, struct prometheus_summary, base);

 		if (summary->user_data == NULL) {
 			return -EAGAIN;
 		}

 		if (IS_ENABLED(CONFIG_NET_PKT_TXTIME_STATS) &&
 		    strstr(metric->name, "_tx_time_summary") == 0) {
 			IF_ENABLED(CONFIG_NET_PKT_TXTIME_STATS,
 				   (struct net_stats_tx_time *tx_time =
 				    (struct net_stats_tx_time *)summary->user_data;

 				    prometheus_summary_observe_set(
 					    summary,
 					    (double)tx_time->sum,
 					    (unsigned long)tx_time->count)));
 		} else if (IS_ENABLED(CONFIG_NET_PKT_RXTIME_STATS) &&
 			   strstr(metric->name, "_rx_time_summary") == 0) {
 			IF_ENABLED(CONFIG_NET_PKT_RXTIME_STATS,
 				   (struct net_stats_rx_time *rx_time =
 				    (struct net_stats_rx_time *)summary->user_data;

 				    prometheus_summary_observe_set(
 					    summary,
 					    (double)rx_time->sum,
 					    (unsigned long)rx_time->count)));
 		}
 	} else {
 		NET_DBG("Unknown metric type %d", metric->type);
 	}

 	return 0;
 }

 void net_stats_prometheus_init(struct net_if *iface)
 {
 	register_prometheus_metrics(iface);
 }
 #endif /* CONFIG_NET_STATISTICS_VIA_PROMETHEUS */
	/*
	* Copyright (c) 2016 Intel Corporation
	*
	* SPDX-License-Identifier: Apache-2.0
	*/

	#if defined(CONFIG_NET_STATISTICS_PERIODIC_OUTPUT)
	#define NET_LOG_LEVEL LOG_LEVEL_INF
	#else
	#define NET_LOG_LEVEL CONFIG_NET_STATISTICS_LOG_LEVEL
	#endif

	#include <zephyr/logging/log.h>
	LOG_MODULE_REGISTER(net_stats, NET_LOG_LEVEL);

	#include <zephyr/kernel.h>
	#include <string.h>
	#include <stdlib.h>
	#include <errno.h>
	#include <zephyr/net/net_core.h>
	#include <zephyr/net/prometheus/collector.h>
	#include <zephyr/net/prometheus/counter.h>
	#include <zephyr/net/prometheus/gauge.h>
	#include <zephyr/net/prometheus/histogram.h>
	#include <zephyr/net/prometheus/summary.h>

	#include "net_stats.h"
	#include "net_private.h"

	/* Global network statistics.
	*
	* The variable needs to be global so that the GET_STAT() macro can access it
	* from net_shell.c
	*/
	struct net_stats net_stats = { 0 };

	#if defined(CONFIG_NET_STATISTICS_PERIODIC_OUTPUT)

	#define PRINT_STATISTICS_INTERVAL (30 * MSEC_PER_SEC)

	#if NET_TC_COUNT > 1
	static const char *priority2str(enum net_priority priority)
	{
	switch (priority) {
	case NET_PRIORITY_BK:
	return "BK"; /* Background */
	case NET_PRIORITY_BE:
	return "BE"; /* Best effort */
	case NET_PRIORITY_EE:
	return "EE"; /* Excellent effort */
	case NET_PRIORITY_CA:
	return "CA"; /* Critical applications */
	case NET_PRIORITY_VI:
	return "VI"; /* Video, < 100 ms latency and jitter */
	case NET_PRIORITY_VO:
	return "VO"; /* Voice, < 10 ms latency and jitter */
	case NET_PRIORITY_IC:
	return "IC"; /* Internetwork control */
	case NET_PRIORITY_NC:
	return "NC"; /* Network control */
	}

	return "??";
	}
	#endif

	static inline int64_t cmp_val(uint64_t val1, uint64_t val2)
	{
	return (int64_t)(val1 - val2);
	}

	static inline void stats(struct net_if *iface)
	{
	static uint64_t next_print;
	uint64_t curr = k_uptime_get();
	int64_t cmp = cmp_val(curr, next_print);
	int i;

	if (!next_print \|\| (abs(cmp) > PRINT_STATISTICS_INTERVAL)) {
	if (iface) {
	NET_INFO("Interface %p [%d]", iface,
	net_if_get_by_iface(iface));
	} else {
	NET_INFO("Global statistics:");
	}

	#if defined(CONFIG_NET_STATISTICS_IPV6)
	NET_INFO("IPv6 recv %d\tsent\t%d\tdrop\t%d\tforwarded\t%d",
	GET_STAT(iface, ipv6.recv),
	GET_STAT(iface, ipv6.sent),
	GET_STAT(iface, ipv6.drop),
	GET_STAT(iface, ipv6.forwarded));
	#if defined(CONFIG_NET_STATISTICS_IPV6_ND)
	NET_INFO("IPv6 ND recv %d\tsent\t%d\tdrop\t%d",
	GET_STAT(iface, ipv6_nd.recv),
	GET_STAT(iface, ipv6_nd.sent),
	GET_STAT(iface, ipv6_nd.drop));
	#endif /* CONFIG_NET_STATISTICS_IPV6_ND */
	#if defined(CONFIG_NET_STATISTICS_IPV6_PMTU)
	NET_INFO("IPv6 PMTU recv %d\tsent\t%d\tdrop\t%d",
	GET_STAT(iface, ipv6_pmtu.recv),
	GET_STAT(iface, ipv6_pmtu.sent),
	GET_STAT(iface, ipv6_pmtu.drop));
	#endif /* CONFIG_NET_STATISTICS_IPV6_PMTU */
	#if defined(CONFIG_NET_STATISTICS_MLD)
	NET_INFO("IPv6 MLD recv %d\tsent\t%d\tdrop\t%d",
	GET_STAT(iface, ipv6_mld.recv),
	GET_STAT(iface, ipv6_mld.sent),
	GET_STAT(iface, ipv6_mld.drop));
	#endif /* CONFIG_NET_STATISTICS_MLD */
	#endif /* CONFIG_NET_STATISTICS_IPV6 */

	#if defined(CONFIG_NET_STATISTICS_IPV4)
	NET_INFO("IPv4 recv %d\tsent\t%d\tdrop\t%d\tforwarded\t%d",
	GET_STAT(iface, ipv4.recv),
	GET_STAT(iface, ipv4.sent),
	GET_STAT(iface, ipv4.drop),
	GET_STAT(iface, ipv4.forwarded));
	#endif /* CONFIG_NET_STATISTICS_IPV4 */

	NET_INFO("IP vhlerr %d\thblener\t%d\tlblener\t%d",
	GET_STAT(iface, ip_errors.vhlerr),
	GET_STAT(iface, ip_errors.hblenerr),
	GET_STAT(iface, ip_errors.lblenerr));
	NET_INFO("IP fragerr %d\tchkerr\t%d\tprotoer\t%d",
	GET_STAT(iface, ip_errors.fragerr),
	GET_STAT(iface, ip_errors.chkerr),
	GET_STAT(iface, ip_errors.protoerr));

	#if defined(CONFIG_NET_STATISTICS_IPV4_PMTU)
	NET_INFO("IPv4 PMTU recv %d\tsent\t%d\tdrop\t%d",
	GET_STAT(iface, ipv4_pmtu.recv),
	GET_STAT(iface, ipv4_pmtu.sent),
	GET_STAT(iface, ipv4_pmtu.drop));
	#endif /* CONFIG_NET_STATISTICS_IPV4_PMTU */

	NET_INFO("ICMP recv %d\tsent\t%d\tdrop\t%d",
	GET_STAT(iface, icmp.recv),
	GET_STAT(iface, icmp.sent),
	GET_STAT(iface, icmp.drop));
	NET_INFO("ICMP typeer %d\tchkerr\t%d",
	GET_STAT(iface, icmp.typeerr),
	GET_STAT(iface, icmp.chkerr));

	#if defined(CONFIG_NET_STATISTICS_UDP)
	NET_INFO("UDP recv %d\tsent\t%d\tdrop\t%d",
	GET_STAT(iface, udp.recv),
	GET_STAT(iface, udp.sent),
	GET_STAT(iface, udp.drop));
	NET_INFO("UDP chkerr %d",
	GET_STAT(iface, udp.chkerr));
	#endif

	#if defined(CONFIG_NET_STATISTICS_TCP)
	NET_INFO("TCP bytes recv %u\tsent\t%d",
	GET_STAT(iface, tcp.bytes.received),
	GET_STAT(iface, tcp.bytes.sent));
	NET_INFO("TCP seg recv %d\tsent\t%d\tdrop\t%d",
	GET_STAT(iface, tcp.recv),
	GET_STAT(iface, tcp.sent),
	GET_STAT(iface, tcp.drop));
	NET_INFO("TCP seg resent %d\tchkerr\t%d\tackerr\t%d",
	GET_STAT(iface, tcp.resent),
	GET_STAT(iface, tcp.chkerr),
	GET_STAT(iface, tcp.ackerr));
	NET_INFO("TCP seg rsterr %d\trst\t%d\tre-xmit\t%d",
	GET_STAT(iface, tcp.rsterr),
	GET_STAT(iface, tcp.rst),
	GET_STAT(iface, tcp.rexmit));
	NET_INFO("TCP conn drop %d\tconnrst\t%d",
	GET_STAT(iface, tcp.conndrop),
	GET_STAT(iface, tcp.connrst));
	#endif

	NET_INFO("Bytes received %u", GET_STAT(iface, bytes.received));
	NET_INFO("Bytes sent %u", GET_STAT(iface, bytes.sent));
	NET_INFO("Processing err %d",
	GET_STAT(iface, processing_error));

	#if NET_TC_COUNT > 1
	#if NET_TC_TX_COUNT > 1
	NET_INFO("TX traffic class statistics:");
	NET_INFO("TC Priority\tSent pkts\tbytes");

	for (i = 0; i < NET_TC_TX_COUNT; i++) {
	NET_INFO("[%d] %s (%d)\t%d\t\t%d", i,
	priority2str(GET_STAT(iface,
	tc.sent[i].priority)),
	GET_STAT(iface, tc.sent[i].priority),
	GET_STAT(iface, tc.sent[i].pkts),
	GET_STAT(iface, tc.sent[i].bytes));
	}
	#endif

	#if NET_TC_RX_COUNT > 1
	NET_INFO("RX traffic class statistics:");
	NET_INFO("TC Priority\tRecv pkts\tbytes");

	for (i = 0; i < NET_TC_RX_COUNT; i++) {
	NET_INFO("[%d] %s (%d)\t%d\t\t%d", i,
	priority2str(GET_STAT(iface,
	tc.recv[i].priority)),
	GET_STAT(iface, tc.recv[i].priority),
	GET_STAT(iface, tc.recv[i].pkts),
	GET_STAT(iface, tc.recv[i].bytes));
	}
	#endif
	#else /* NET_TC_COUNT > 1 */
	ARG_UNUSED(i);
	#endif /* NET_TC_COUNT > 1 */

	#if defined(CONFIG_NET_STATISTICS_POWER_MANAGEMENT)
	NET_INFO("Power management statistics:");
	NET_INFO("Last suspend time: %u ms",
	GET_STAT(iface, pm.last_suspend_time));
	NET_INFO("Got suspended %d times",
	GET_STAT(iface, pm.suspend_count));
	NET_INFO("Average suspend time: %u ms",
	(uint32_t)(GET_STAT(iface, pm.overall_suspend_time) /
	GET_STAT(iface, pm.suspend_count)));
	NET_INFO("Total suspended time: %llu ms",
	GET_STAT(iface, pm.overall_suspend_time));
	#endif
	next_print = curr + PRINT_STATISTICS_INTERVAL;
	}
	}

	void net_print_statistics_iface(struct net_if *iface)
	{
	/* In order to make the info print lines shorter, use shorter
	* function name.
	*/
	stats(iface);
	}

	static void iface_cb(struct net_if iface, void user_data)
	{
	net_print_statistics_iface(iface);
	}

	void net_print_statistics_all(void)
	{
	net_if_foreach(iface_cb, NULL);
	}

	void net_print_statistics(void)
	{
	net_print_statistics_iface(NULL);
	}

	#endif /* CONFIG_NET_STATISTICS_PERIODIC_OUTPUT */

	#if defined(CONFIG_NET_STATISTICS_USER_API)

	static int net_stats_get(uint32_t mgmt_request, struct net_if *iface,
	void *data, size_t len)
	{
	size_t len_chk = 0;
	void *src = NULL;

	switch (NET_MGMT_GET_COMMAND(mgmt_request)) {
	case NET_REQUEST_STATS_CMD_GET_ALL:
	len_chk = sizeof(struct net_stats);
	#if defined(CONFIG_NET_STATISTICS_PER_INTERFACE)
	src = iface ? &iface->stats : &net_stats;
	#else
	src = &net_stats;
	#endif
	break;
	case NET_REQUEST_STATS_CMD_GET_PROCESSING_ERROR:
	len_chk = sizeof(net_stats_t);
	src = GET_STAT_ADDR(iface, processing_error);
	break;
	case NET_REQUEST_STATS_CMD_GET_BYTES:
	len_chk = sizeof(struct net_stats_bytes);
	src = GET_STAT_ADDR(iface, bytes);
	break;
	case NET_REQUEST_STATS_CMD_GET_IP_ERRORS:
	len_chk = sizeof(struct net_stats_ip_errors);
	src = GET_STAT_ADDR(iface, ip_errors);
	break;
	#if defined(CONFIG_NET_STATISTICS_IPV4)
	case NET_REQUEST_STATS_CMD_GET_IPV4:
	len_chk = sizeof(struct net_stats_ip);
	src = GET_STAT_ADDR(iface, ipv4);
	break;
	#endif
	#if defined(CONFIG_NET_STATISTICS_IPV6)
	case NET_REQUEST_STATS_CMD_GET_IPV6:
	len_chk = sizeof(struct net_stats_ip);
	src = GET_STAT_ADDR(iface, ipv6);
	break;
	#endif
	#if defined(CONFIG_NET_STATISTICS_IPV6_ND)
	case NET_REQUEST_STATS_CMD_GET_IPV6_ND:
	len_chk = sizeof(struct net_stats_ipv6_nd);
	src = GET_STAT_ADDR(iface, ipv6_nd);
	break;
	#endif
	#if defined(CONFIG_NET_STATISTICS_IPV6_PMTU)
	case NET_REQUEST_STATS_CMD_GET_IPV6_PMTU:
	len_chk = sizeof(struct net_stats_ipv6_pmtu);
	src = GET_STAT_ADDR(iface, ipv6_pmtu);
	break;
	#endif
	#if defined(CONFIG_NET_STATISTICS_IPV4_PMTU)
	case NET_REQUEST_STATS_CMD_GET_IPV4_PMTU:
	len_chk = sizeof(struct net_stats_ipv4_pmtu);
	src = GET_STAT_ADDR(iface, ipv4_pmtu);
	break;
	#endif
	#if defined(CONFIG_NET_STATISTICS_ICMP)
	case NET_REQUEST_STATS_CMD_GET_ICMP:
	len_chk = sizeof(struct net_stats_icmp);
	src = GET_STAT_ADDR(iface, icmp);
	break;
	#endif
	#if defined(CONFIG_NET_STATISTICS_UDP)
	case NET_REQUEST_STATS_CMD_GET_UDP:
	len_chk = sizeof(struct net_stats_udp);
	src = GET_STAT_ADDR(iface, udp);
	break;
	#endif
	#if defined(CONFIG_NET_STATISTICS_TCP)
	case NET_REQUEST_STATS_CMD_GET_TCP:
	len_chk = sizeof(struct net_stats_tcp);
	src = GET_STAT_ADDR(iface, tcp);
	break;
	#endif
	#if defined(CONFIG_NET_STATISTICS_POWER_MANAGEMENT)
	case NET_REQUEST_STATS_GET_PM:
	len_chk = sizeof(struct net_stats_pm);
	src = GET_STAT_ADDR(iface, pm);
	break;
	#endif
	}

	if (len != len_chk \|\| !src) {
	return -EINVAL;
	}

	memcpy(data, src, len);

	return 0;
	}

	NET_MGMT_REGISTER_REQUEST_HANDLER(NET_REQUEST_STATS_GET_ALL,
	net_stats_get);

	NET_MGMT_REGISTER_REQUEST_HANDLER(NET_REQUEST_STATS_GET_PROCESSING_ERROR,
	net_stats_get);

	NET_MGMT_REGISTER_REQUEST_HANDLER(NET_REQUEST_STATS_GET_BYTES,
	net_stats_get);

	NET_MGMT_REGISTER_REQUEST_HANDLER(NET_REQUEST_STATS_GET_IP_ERRORS,
	net_stats_get);

	#if defined(CONFIG_NET_STATISTICS_IPV4)
	NET_MGMT_REGISTER_REQUEST_HANDLER(NET_REQUEST_STATS_GET_IPV4,
	net_stats_get);
	#endif

	#if defined(CONFIG_NET_STATISTICS_IPV6)
	NET_MGMT_REGISTER_REQUEST_HANDLER(NET_REQUEST_STATS_GET_IPV6,
	net_stats_get);
	#endif

	#if defined(CONFIG_NET_STATISTICS_IPV6_ND)
	NET_MGMT_REGISTER_REQUEST_HANDLER(NET_REQUEST_STATS_GET_IPV6_ND,
	net_stats_get);
	#endif

	#if defined(CONFIG_NET_STATISTICS_IPV6_PMTU)
	NET_MGMT_REGISTER_REQUEST_HANDLER(NET_REQUEST_STATS_GET_IPV6_PMTU,
	net_stats_get);
	#endif

	#if defined(CONFIG_NET_STATISTICS_IPV4_PMTU)
	NET_MGMT_REGISTER_REQUEST_HANDLER(NET_REQUEST_STATS_GET_IPV4_PMTU,
	net_stats_get);
	#endif

	#if defined(CONFIG_NET_STATISTICS_ICMP)
	NET_MGMT_REGISTER_REQUEST_HANDLER(NET_REQUEST_STATS_GET_ICMP,
	net_stats_get);
	#endif

	#if defined(CONFIG_NET_STATISTICS_UDP)
	NET_MGMT_REGISTER_REQUEST_HANDLER(NET_REQUEST_STATS_GET_UDP,
	net_stats_get);
	#endif

	#if defined(CONFIG_NET_STATISTICS_TCP)
	NET_MGMT_REGISTER_REQUEST_HANDLER(NET_REQUEST_STATS_GET_TCP,
	net_stats_get);
	#endif

	#if defined(CONFIG_NET_STATISTICS_POWER_MANAGEMENT)
	NET_MGMT_REGISTER_REQUEST_HANDLER(NET_REQUEST_STATS_GET_PM,
	net_stats_get);
	#endif

	#endif /* CONFIG_NET_STATISTICS_USER_API */

	void net_stats_reset(struct net_if *iface)
	{
	if (iface) {
	net_if_stats_reset(iface);
	return;
	}

	net_if_stats_reset_all();
	memset(&net_stats, 0, sizeof(net_stats));
	}

	#if defined(CONFIG_NET_STATISTICS_VIA_PROMETHEUS)
	static void register_prometheus_metrics(struct net_if *iface)
	{
	int total_count = 0;

	/* Find the correct collector for this interface */
	STRUCT_SECTION_FOREACH(prometheus_collector, entry) {
	if (entry->user_data == (void *)iface) {
	iface->collector = entry;
	break;
	}
	}

	if (iface->collector == NULL) {
	NET_DBG("No collector found for interface %d",
	net_if_get_by_iface(iface));
	return;
	}

	STRUCT_SECTION_FOREACH(prometheus_counter, entry) {
	if (entry->base.collector != iface->collector) {
	continue;
	}

	prometheus_collector_register_metric(iface->collector,
	&entry->base);
	total_count++;
	}

	STRUCT_SECTION_FOREACH(prometheus_gauge, entry) {
	if (entry->base.collector != iface->collector) {
	continue;
	}

	prometheus_collector_register_metric(iface->collector,
	&entry->base);
	total_count++;
	}

	STRUCT_SECTION_FOREACH(prometheus_summary, entry) {
	if (entry->base.collector != iface->collector) {
	continue;
	}

	prometheus_collector_register_metric(iface->collector,
	&entry->base);
	total_count++;
	}

	STRUCT_SECTION_FOREACH(prometheus_histogram, entry) {
	if (entry->base.collector != iface->collector) {
	continue;
	}

	prometheus_collector_register_metric(iface->collector,
	&entry->base);
	total_count++;
	}

	NET_DBG("Registered %d metrics for interface %d", total_count,
	net_if_get_by_iface(iface));
	}

	/* Do not update metrics one by one as that would require searching
	* each individual metric from the collector. Instead, let the
	* Prometheus API scrape the data from net_stats stored in net_if when
	* needed.
	*/
	int net_stats_prometheus_scrape(struct prometheus_collector *collector,
	struct prometheus_metric *metric,
	void *user_data)
	{
	struct net_if *iface = user_data;
	net_stats_t value;

	if (!iface) {
	return -EINVAL;
	}

	if (iface->collector != collector) {
	return -EINVAL;
	}

	/* Update the metrics */
	if (metric->type == PROMETHEUS_COUNTER) {
	struct prometheus_counter *counter =
	CONTAINER_OF(metric, struct prometheus_counter, base);

	if (counter->user_data == NULL) {
	return -EAGAIN;
	}

	value = ((net_stats_t )counter->user_data);

	prometheus_counter_set(counter, (uint64_t)value);

	} else if (metric->type == PROMETHEUS_GAUGE) {
	struct prometheus_gauge *gauge =
	CONTAINER_OF(metric, struct prometheus_gauge, base);

	if (gauge->user_data == NULL) {
	return -EAGAIN;
	}

	value = ((net_stats_t )gauge->user_data);

	prometheus_gauge_set(gauge, (double)value);

	} else if (metric->type == PROMETHEUS_HISTOGRAM) {
	struct prometheus_histogram *histogram =
	CONTAINER_OF(metric, struct prometheus_histogram, base);

	if (histogram->user_data == NULL) {
	return -EAGAIN;
	}

	} else if (metric->type == PROMETHEUS_SUMMARY) {
	struct prometheus_summary *summary =
	CONTAINER_OF(metric, struct prometheus_summary, base);

	if (summary->user_data == NULL) {
	return -EAGAIN;
	}

	if (IS_ENABLED(CONFIG_NET_PKT_TXTIME_STATS) &&
	strstr(metric->name, "_tx_time_summary") == 0) {
	IF_ENABLED(CONFIG_NET_PKT_TXTIME_STATS,
	(struct net_stats_tx_time *tx_time =
	(struct net_stats_tx_time *)summary->user_data;

	prometheus_summary_observe_set(
	summary,
	(double)tx_time->sum,
	(unsigned long)tx_time->count)));
	} else if (IS_ENABLED(CONFIG_NET_PKT_RXTIME_STATS) &&
	strstr(metric->name, "_rx_time_summary") == 0) {
	IF_ENABLED(CONFIG_NET_PKT_RXTIME_STATS,
	(struct net_stats_rx_time *rx_time =
	(struct net_stats_rx_time *)summary->user_data;

	prometheus_summary_observe_set(
	summary,
	(double)rx_time->sum,
	(unsigned long)rx_time->count)));
	}
	} else {
	NET_DBG("Unknown metric type %d", metric->type);
	}

	return 0;
	}

	void net_stats_prometheus_init(struct net_if *iface)
	{
	register_prometheus_metrics(iface);
	}
	#endif /* CONFIG_NET_STATISTICS_VIA_PROMETHEUS */