net: tc: Limit the max amount of packets in the traffic-class-fifo

To avoid starvation of a traffic class by another, limit the maximum amount
of packets, that can sit in a single traffic-class-fifo to a fraction of
the maximum amount of available packets. In the tx-case also reserve
packets for direct sending, in the case, where
CONFIG_NET_TC_SKIP_FOR_HIGH_PRIO is enabled.

Signed-off-by: Cla Mattia Galliard <[email protected]>

Author: clamattia

include/zephyr/net/net_if.h

@@ -614,6 +614,11 @@ struct net_traffic_class {
 	/** Fifo for handling this Tx or Rx packet */
 	struct k_fifo fifo;
 
+#if NET_TC_COUNT > 1 || defined(CONFIG_NET_TC_SKIP_FOR_HIGH_PRIO)
+	/** Semaphore for tracking the available slots in the fifo */
+	struct k_sem fifo_slot;
+#endif
+
 	/** Traffic class handler thread */
 	struct k_thread handler;
 

subsys/net/ip/net_core.c

@@ -483,8 +483,17 @@ static void net_queue_rx(struct net_if *iface, struct net_pkt *pkt)
 	if (NET_TC_RX_COUNT == 0) {
 		net_process_rx_packet(pkt);
 	} else {
-		net_tc_submit_to_rx_queue(tc, pkt);
+		if (net_tc_submit_to_rx_queue(tc, pkt) != NET_OK) {
+			goto drop;
+		}
 	}
+
+	return;
+
+drop:
+	net_pkt_unref(pkt);
+	/* TODO add statistics */
+	return;
 }
 
 /* Called by driver when a packet has been received */

subsys/net/ip/net_if.c

@@ -357,6 +357,10 @@ void net_if_queue_tx(struct net_if *iface, struct net_pkt *pkt)
 	net_stats_update_tc_sent_bytes(iface, tc, net_pkt_get_len(pkt));
 	net_stats_update_tc_sent_priority(iface, tc, prio);
 
+#if NET_TC_TX_COUNT > 1
+	NET_DBG("TC %d with prio %d pkt %p", tc, prio, pkt);
+#endif
+
 	/* For highest priority packet, skip the TX queue and push directly to
 	 * the driver. Also if there are no TX queue/thread, push the packet
 	 * directly to the driver.
@@ -366,23 +370,21 @@ void net_if_queue_tx(struct net_if *iface, struct net_pkt *pkt)
 		net_pkt_set_tx_stats_tick(pkt, k_cycle_get_32());
 
 		net_if_tx(net_pkt_iface(pkt), pkt);
-		return;
-	}
-
-#if NET_TC_TX_COUNT > 1
-	NET_DBG("TC %d with prio %d pkt %p", tc, prio, pkt);
-#endif
-
-#if defined(CONFIG_NET_POWER_MANAGEMENT)
-	iface->tx_pending++;
-#endif
-
-	if (!net_tc_submit_to_tx_queue(tc, pkt)) {
+	} else {
+		if (net_tc_submit_to_tx_queue(tc, pkt) != NET_OK) {
+			goto drop;
+		}
 #if defined(CONFIG_NET_POWER_MANAGEMENT)
-		iface->tx_pending--
+		iface->tx_pending++;
 #endif
-			;
 	}
+
+	return;
+
+drop:
+	net_pkt_unref(pkt);
+	/* TODO add statistics */
+	return;
 }
 #endif /* CONFIG_NET_NATIVE */
 

subsys/net/ip/net_private.h

@@ -184,8 +184,8 @@ static inline enum net_verdict net_ipv6_input(struct net_pkt *pkt,
 static inline void net_tc_tx_init(void) { }
 static inline void net_tc_rx_init(void) { }
 #endif
-extern bool net_tc_submit_to_tx_queue(uint8_t tc, struct net_pkt *pkt);
-extern void net_tc_submit_to_rx_queue(uint8_t tc, struct net_pkt *pkt);
+extern enum net_verdict net_tc_submit_to_tx_queue(uint8_t tc, struct net_pkt *pkt);
+extern enum net_verdict net_tc_submit_to_rx_queue(uint8_t tc, struct net_pkt *pkt);
 extern enum net_verdict net_promisc_mode_input(struct net_pkt *pkt);
 
 char *net_sprint_addr(sa_family_t af, const void *addr);

subsys/net/ip/net_tc.c

@@ -18,6 +18,25 @@ LOG_MODULE_REGISTER(net_tc, CONFIG_NET_TC_LOG_LEVEL);
 #include "net_stats.h"
 #include "net_tc_mapping.h"
 
+#if NET_TC_RX_COUNT > 1
+#define NET_TC_RX_SLOTS (CONFIG_NET_PKT_RX_COUNT / NET_TC_RX_COUNT)
+BUILD_ASSERT(NET_TC_RX_SLOTS > 0,
+		"Misconfiguration: There are more traffic classes then packets, "
+		"either increase CONFIG_NET_PKT_RX_COUNT or decrease "
+		"CONFIG_NET_TC_RX_COUNT");
+#endif
+
+#define TC_TX_PSEUDO_QUEUE (COND_CODE_1(CONFIG_NET_TC_SKIP_FOR_HIGH_PRIO, (1), (0)))
+#define NET_TC_TX_EFFECTIVE_COUNT (NET_TC_TX_COUNT + TC_TX_PSEUDO_QUEUE)
+
+#if NET_TC_TX_EFFECTIVE_COUNT > 1
+#define NET_TC_TX_SLOTS (CONFIG_NET_PKT_TX_COUNT / NET_TC_TX_EFFECTIVE_COUNT)
+BUILD_ASSERT(NET_TC_TX_SLOTS > 0,
+		"Misconfiguration: There are more traffic classes then packets, "
+		"either increase CONFIG_NET_PKT_TX_COUNT or decrease "
+		"CONFIG_NET_TC_TX_COUNT or disable CONFIG_NET_TC_SKIP_FOR_HIGH_PRIO");
+#endif
+
 /* Template for thread name. The "xx" is either "TX" denoting transmit thread,
  * or "RX" denoting receive thread. The "q[y]" denotes the traffic class queue
  * where y indicates the traffic class id. The value of y can be from 0 to 7.
@@ -40,35 +59,43 @@ static struct net_traffic_class tx_classes[NET_TC_TX_COUNT];
 static struct net_traffic_class rx_classes[NET_TC_RX_COUNT];
 #endif
 
-#if NET_TC_RX_COUNT > 0 || NET_TC_TX_COUNT > 0
-static void submit_to_queue(struct k_fifo *queue, struct net_pkt *pkt)
-{
-	k_fifo_put(queue, pkt);
-}
-#endif
-
-bool net_tc_submit_to_tx_queue(uint8_t tc, struct net_pkt *pkt)
+enum net_verdict net_tc_submit_to_tx_queue(uint8_t tc, struct net_pkt *pkt)
 {
 #if NET_TC_TX_COUNT > 0
 	net_pkt_set_tx_stats_tick(pkt, k_cycle_get_32());
 
-	submit_to_queue(&tx_classes[tc].fifo, pkt);
+#if NET_TC_TX_EFFECTIVE_COUNT > 1
+	if (k_sem_take(&tx_classes[tc].fifo_slot, K_NO_WAIT) != 0) {
+		return NET_DROP;
+	}
+#endif
+
+	k_fifo_put(&tx_classes[tc].fifo, pkt);
+	return NET_OK;
 #else
 	ARG_UNUSED(tc);
 	ARG_UNUSED(pkt);
+	return NET_DROP;
 #endif
-	return true;
 }
 
-void net_tc_submit_to_rx_queue(uint8_t tc, struct net_pkt *pkt)
+enum net_verdict net_tc_submit_to_rx_queue(uint8_t tc, struct net_pkt *pkt)
 {
 #if NET_TC_RX_COUNT > 0
 	net_pkt_set_rx_stats_tick(pkt, k_cycle_get_32());
 
-	submit_to_queue(&rx_classes[tc].fifo, pkt);
+#if NET_TC_RX_COUNT > 1
+	if (k_sem_take(&rx_classes[tc].fifo_slot, K_NO_WAIT) != 0) {
+		return NET_DROP;
+	}
+#endif
+
+	k_fifo_put(&rx_classes[tc].fifo, pkt);
+	return NET_OK;
 #else
 	ARG_UNUSED(tc);
 	ARG_UNUSED(pkt);
+	return NET_DROP;
 #endif
 }
 
@@ -242,10 +269,14 @@ static void net_tc_rx_stats_priority_setup(struct net_if *iface,
 #if NET_TC_RX_COUNT > 0
 static void tc_rx_handler(void *p1, void *p2, void *p3)
 {
-	ARG_UNUSED(p2);
 	ARG_UNUSED(p3);
 
 	struct k_fifo *fifo = p1;
+#if NET_TC_RX_COUNT > 1
+	struct k_sem *fifo_slot = p2;
+#else
+	ARG_UNUSED(p2);
+#endif
 	struct net_pkt *pkt;
 
 	while (1) {
@@ -254,6 +285,10 @@ static void tc_rx_handler(void *p1, void *p2, void *p3)
 			continue;
 		}
 
+#if NET_TC_RX_COUNT > 1
+		k_sem_give(fifo_slot);
+#endif
+
 		net_process_rx_packet(pkt);
 	}
 }
@@ -262,10 +297,14 @@ static void tc_rx_handler(void *p1, void *p2, void *p3)
 #if NET_TC_TX_COUNT > 0
 static void tc_tx_handler(void *p1, void *p2, void *p3)
 {
-	ARG_UNUSED(p2);
 	ARG_UNUSED(p3);
 
 	struct k_fifo *fifo = p1;
+#if NET_TC_TX_EFFECTIVE_COUNT > 1
+	struct k_sem *fifo_slot = p2;
+#else
+	ARG_UNUSED(p2);
+#endif
 	struct net_pkt *pkt;
 
 	while (1) {
@@ -274,6 +313,10 @@ static void tc_tx_handler(void *p1, void *p2, void *p3)
 			continue;
 		}
 
+#if NET_TC_TX_EFFECTIVE_COUNT > 1
+		k_sem_give(fifo_slot);
+#endif
+
 		net_process_tx_packet(pkt);
 	}
 }
@@ -318,10 +361,20 @@ void net_tc_tx_init(void)
 
 		k_fifo_init(&tx_classes[i].fifo);
 
+#if NET_TC_TX_EFFECTIVE_COUNT > 1
+		k_sem_init(&tx_classes[i].fifo_slot, NET_TC_TX_SLOTS, NET_TC_TX_SLOTS);
+#endif
+
 		tid = k_thread_create(&tx_classes[i].handler, tx_stack[i],
 				      K_KERNEL_STACK_SIZEOF(tx_stack[i]),
 				      tc_tx_handler,
-				      &tx_classes[i].fifo, NULL, NULL,
+				      &tx_classes[i].fifo,
+#if NET_TC_TX_EFFECTIVE_COUNT > 1
+				      &tx_classes[i].fifo_slot,
+#else
+				      NULL,
+#endif
+				      NULL,
 				      priority, 0, K_FOREVER);
 		if (!tid) {
 			NET_ERR("Cannot create TC handler thread %d", i);
@@ -376,10 +429,20 @@ void net_tc_rx_init(void)
 
 		k_fifo_init(&rx_classes[i].fifo);
 
+#if NET_TC_RX_COUNT > 1
+		k_sem_init(&rx_classes[i].fifo_slot, NET_TC_RX_SLOTS, NET_TC_RX_SLOTS);
+#endif
+
 		tid = k_thread_create(&rx_classes[i].handler, rx_stack[i],
 				      K_KERNEL_STACK_SIZEOF(rx_stack[i]),
 				      tc_rx_handler,
-				      &rx_classes[i].fifo, NULL, NULL,
+				      &rx_classes[i].fifo,
+#if NET_TC_RX_COUNT > 1
+				      &rx_classes[i].fifo_slot,
+#else
+				      NULL,
+#endif
+				      NULL,
 				      priority, 0, K_FOREVER);
 		if (!tid) {
 			NET_ERR("Cannot create TC handler thread %d", i);