From nobody Mon Feb 9 21:21:23 2026 Received: from metis.whiteo.stw.pengutronix.de (metis.whiteo.stw.pengutronix.de [185.203.201.7]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 0F79713D506 for ; Wed, 10 Apr 2024 08:06:05 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=185.203.201.7 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1712736369; cv=none; b=nHw4AGKX+EaWDToROByJXA3a+6bzexATOyKmbL4Xjmcak8QJkT+EGQbY3ITOqpRFyQI/bw3dimB/ePJXRHmN6VZ+jcnPPaUNlaKSmmTXRtIGL17Pyz80NDYTtvWHaEQCHVLxXrBM/ovLyDVm+bdl7b/0YTa5xw9eZEfcZbi5xQY= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1712736369; c=relaxed/simple; bh=uVCYKrN3hLmbYLWsV6u5q0S29o1ULHD/9qmkd9S02TQ=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=K480HySrnYfr8XCVxabZqJv8FZBgMioJvWc1RffKs2r1AlpSBuLFBk/84gKe2nBtSOrZT/2VQIA251wCSjdRmAcEdnBUC2KZAq2mX67QQ8uyHbbcasMhFUR+D6gGjkF/2muSRQ2fGEW7L3z5ro1eMILnwuyb1Rg1r7pg4Wl/ngE= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=pengutronix.de; spf=pass smtp.mailfrom=pengutronix.de; arc=none smtp.client-ip=185.203.201.7 Authentication-Results: smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=pengutronix.de Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=pengutronix.de Received: from drehscheibe.grey.stw.pengutronix.de ([2a0a:edc0:0:c01:1d::a2]) by metis.whiteo.stw.pengutronix.de with esmtps (TLS1.3:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.92) (envelope-from ) id 1ruSy0-0004NQ-Bh; Wed, 10 Apr 2024 10:06:00 +0200 Received: from [2a0a:edc0:0:1101:1d::ac] (helo=dude04.red.stw.pengutronix.de) by drehscheibe.grey.stw.pengutronix.de with esmtps (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.94.2) (envelope-from ) id 1ruSxx-00BSay-Tw; Wed, 10 Apr 2024 10:05:57 +0200 Received: from ore by dude04.red.stw.pengutronix.de with local (Exim 4.96) (envelope-from ) id 1ruSxx-005Cu4-2g; Wed, 10 Apr 2024 10:05:57 +0200 From: Oleksij Rempel To: "David S. Miller" , Andrew Lunn , Eric Dumazet , Florian Fainelli , Jakub Kicinski , Paolo Abeni , Vladimir Oltean , Woojung Huh , Arun Ramadoss Cc: Oleksij Rempel , kernel@pengutronix.de, linux-kernel@vger.kernel.org, netdev@vger.kernel.org, UNGLinuxDriver@microchip.com, David Ahern , Simon Horman , Willem de Bruijn , =?UTF-8?q?S=C3=B8ren=20Andersen?= Subject: [PATCH net-next v6 3/9] net: add IEEE 802.1q specific helpers Date: Wed, 10 Apr 2024 10:05:50 +0200 Message-Id: <20240410080556.1241048-4-o.rempel@pengutronix.de> X-Mailer: git-send-email 2.39.2 In-Reply-To: <20240410080556.1241048-1-o.rempel@pengutronix.de> References: <20240410080556.1241048-1-o.rempel@pengutronix.de> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-SA-Exim-Connect-IP: 2a0a:edc0:0:c01:1d::a2 X-SA-Exim-Mail-From: ore@pengutronix.de X-SA-Exim-Scanned: No (on metis.whiteo.stw.pengutronix.de); SAEximRunCond expanded to false X-PTX-Original-Recipient: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" IEEE 802.1q specification provides recommendation and examples which can be used as good default values for different drivers. This patch implements mapping examples documented in IEEE 802.1Q-2022 in Annex I "I.3 Traffic type to traffic class mapping" and IETF DSCP naming and mapping DSCP to Traffic Type inspired by RFC8325. This helpers will be used in followup patches for dsa/microchip DCB implementation. Signed-off-by: Oleksij Rempel --- changes v6: - do not set default n for NET_IEEE8021Q_HELPERS - protect against accessing outside of the arrays in the ieee8021q_tt_to_tc() - use u8 for dscp instead of int changes v4: - use -EOPNOTSUPP instead of -ENOTSUP - ieee8021q_tt_to_tc() return error if requested not supported amount of queues changes v2: - properly export symbols with EXPORT_SYMBOL_GPL() - return error if NET_IEEE8021Q_HELPERS is not enabled --- include/net/dscp.h | 76 +++++++++++++ include/net/ieee8021q.h | 55 +++++++++ net/Kconfig | 3 + net/core/Makefile | 1 + net/core/ieee8021q_helpers.c | 208 +++++++++++++++++++++++++++++++++++ 5 files changed, 343 insertions(+) create mode 100644 include/net/dscp.h create mode 100644 include/net/ieee8021q.h create mode 100644 net/core/ieee8021q_helpers.c diff --git a/include/net/dscp.h b/include/net/dscp.h new file mode 100644 index 0000000000000..ba40540868c9c --- /dev/null +++ b/include/net/dscp.h @@ -0,0 +1,76 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* Copyright (c) 2024 Pengutronix, Oleksij Rempel = */ + +#ifndef __DSCP_H__ +#define __DSCP_H__ + +/* + * DSCP Pools and Codepoint Space Division: + * + * The Differentiated Services (Diffserv) architecture defines a method for + * classifying and managing network traffic using the DS field in IPv4 and= IPv6 + * packet headers. This field can carry one of 64 distinct DSCP (Different= iated + * Services Code Point) values, which are divided into three pools based on + * their Least Significant Bits (LSB) patterns and intended usage. Each po= ol has + * a specific registration procedure for assigning DSCP values: + * + * Pool 1 (Standards Action Pool): + * - Codepoint Space: xxxxx0 + * This pool includes DSCP values ending in '0' (binary), allocated via + * Standards Action. It is intended for globally recognized traffic clas= ses, + * ensuring interoperability across the internet. This pool encompasses + * well-known DSCP values such as CS0-CS7, AFxx, EF, and VOICE-ADMIT. + * + * Pool 2 (Experimental/Local Use Pool): + * - Codepoint Space: xxxx11 + * Reserved for DSCP values ending in '11' (binary), this pool is design= ated + * for Experimental or Local Use. It allows for private or temporary tra= ffic + * marking schemes not intended for standardized global use, facilitating + * testing and network-specific configurations without impacting + * interoperability. + * + * Pool 3 (Preferential Standardization Pool): + * - Codepoint Space: xxxx01 + * Initially reserved for experimental or local use, this pool now serve= s as + * a secondary standardization resource should Pool 1 become exhausted. = DSCP + * values ending in '01' (binary) are assigned via Standards Action, wit= h a + * focus on adopting new, standardized traffic classes as the need arise= s. + * + * For pool updates see: + * https://www.iana.org/assignments/dscp-registry/dscp-registry.xhtml + */ + +/* Pool 1: Standardized DSCP values as per [RFC8126] */ +#define DSCP_CS0 0 /* 000000, [RFC2474] */ +/* CS0 is some times called default (DF) */ +#define DSCP_DF 0 /* 000000, [RFC2474] */ +#define DSCP_CS1 8 /* 001000, [RFC2474] */ +#define DSCP_CS2 16 /* 010000, [RFC2474] */ +#define DSCP_CS3 24 /* 011000, [RFC2474] */ +#define DSCP_CS4 32 /* 100000, [RFC2474] */ +#define DSCP_CS5 40 /* 101000, [RFC2474] */ +#define DSCP_CS6 48 /* 110000, [RFC2474] */ +#define DSCP_CS7 56 /* 111000, [RFC2474] */ +#define DSCP_AF11 10 /* 001010, [RFC2597] */ +#define DSCP_AF12 12 /* 001100, [RFC2597] */ +#define DSCP_AF13 14 /* 001110, [RFC2597] */ +#define DSCP_AF21 18 /* 010010, [RFC2597] */ +#define DSCP_AF22 20 /* 010100, [RFC2597] */ +#define DSCP_AF23 22 /* 010110, [RFC2597] */ +#define DSCP_AF31 26 /* 011010, [RFC2597] */ +#define DSCP_AF32 28 /* 011100, [RFC2597] */ +#define DSCP_AF33 30 /* 011110, [RFC2597] */ +#define DSCP_AF41 34 /* 100010, [RFC2597] */ +#define DSCP_AF42 36 /* 100100, [RFC2597] */ +#define DSCP_AF43 38 /* 100110, [RFC2597] */ +#define DSCP_EF 46 /* 101110, [RFC3246] */ +#define DSCP_VOICE_ADMIT 44 /* 101100, [RFC5865] */ + +/* Pool 3: Standardized assignments, previously available for experimental= /local + * use + */ +#define DSCP_LE 1 /* 000001, [RFC8622] */ + +#define DSCP_MAX 64 + +#endif /* __DSCP_H__ */ diff --git a/include/net/ieee8021q.h b/include/net/ieee8021q.h new file mode 100644 index 0000000000000..3bec7ec951362 --- /dev/null +++ b/include/net/ieee8021q.h @@ -0,0 +1,55 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* Copyright (c) 2024 Pengutronix, Oleksij Rempel = */ + +#ifndef _NET_IEEE8021Q_H +#define _NET_IEEE8021Q_H + +#include + +/** + * enum ieee8021q_traffic_type - 802.1Q traffic type priority values (802.= 1Q-2022) + * + * @IEEE8021Q_TT_BK: Background + * @IEEE8021Q_TT_BE: Best Effort (default). According to 802.1Q-2022, BE i= s 0 + * but has higher priority than BK which is 1. + * @IEEE8021Q_TT_EE: Excellent Effort + * @IEEE8021Q_TT_CA: Critical Applications + * @IEEE8021Q_TT_VI: Video, < 100 ms latency and jitter + * @IEEE8021Q_TT_VO: Voice, < 10 ms latency and jitter + * @IEEE8021Q_TT_IC: Internetwork Control + * @IEEE8021Q_TT_NC: Network Control + */ +enum ieee8021q_traffic_type { + IEEE8021Q_TT_BK =3D 0, + IEEE8021Q_TT_BE =3D 1, + IEEE8021Q_TT_EE =3D 2, + IEEE8021Q_TT_CA =3D 3, + IEEE8021Q_TT_VI =3D 4, + IEEE8021Q_TT_VO =3D 5, + IEEE8021Q_TT_IC =3D 6, + IEEE8021Q_TT_NC =3D 7, + + IEEE8021Q_TT_MAX, +}; + +#define SIMPLE_IETF_DSCP_TO_IEEE8021Q_TT(dscp) ((dscp >> 3) & 0x7) + +#if IS_ENABLED(CONFIG_NET_IEEE8021Q_HELPERS) + +int ietf_dscp_to_ieee8021q_tt(u8 dscp); +int ieee8021q_tt_to_tc(unsigned int tt, unsigned int num_queues); + +#else + +static inline int ietf_dscp_to_ieee8021q_tt(int dscp) +{ + return -EOPNOTSUPP; +} + +static inline int ieee8021q_tt_to_tc(int tt, int num_queues) +{ + return -EOPNOTSUPP; +} + +#endif +#endif /* _NET_IEEE8021Q_H */ diff --git a/net/Kconfig b/net/Kconfig index d5ab791f7afa2..f0a8692496ffa 100644 --- a/net/Kconfig +++ b/net/Kconfig @@ -452,6 +452,9 @@ config GRO_CELLS config SOCK_VALIDATE_XMIT bool =20 +config NET_IEEE8021Q_HELPERS + bool + config NET_SELFTESTS def_tristate PHYLIB depends on PHYLIB && INET diff --git a/net/core/Makefile b/net/core/Makefile index 21d6fbc7e884c..62be9aef25285 100644 --- a/net/core/Makefile +++ b/net/core/Makefile @@ -26,6 +26,7 @@ obj-$(CONFIG_NETPOLL) +=3D netpoll.o obj-$(CONFIG_FIB_RULES) +=3D fib_rules.o obj-$(CONFIG_TRACEPOINTS) +=3D net-traces.o obj-$(CONFIG_NET_DROP_MONITOR) +=3D drop_monitor.o +obj-$(CONFIG_NET_IEEE8021Q_HELPERS) +=3D ieee8021q_helpers.o obj-$(CONFIG_NET_SELFTESTS) +=3D selftests.o obj-$(CONFIG_NETWORK_PHY_TIMESTAMPING) +=3D timestamping.o obj-$(CONFIG_NET_PTP_CLASSIFY) +=3D ptp_classifier.o diff --git a/net/core/ieee8021q_helpers.c b/net/core/ieee8021q_helpers.c new file mode 100644 index 0000000000000..74b42334746da --- /dev/null +++ b/net/core/ieee8021q_helpers.c @@ -0,0 +1,208 @@ +// SPDX-License-Identifier: GPL-2.0 +// Copyright (c) 2024 Pengutronix, Oleksij Rempel + +#include +#include +#include +#include +#include + +/* The following arrays map Traffic Types (TT) to traffic classes (TC) for + * different number of queues as shown in the example provided by + * IEEE 802.1Q-2022 in Annex I "I.3 Traffic type to traffic class mapping"= and + * Table I-1 "Traffic type to traffic class mapping". + */ +static const u8 ieee8021q_8queue_tt_tc_map[] =3D { + [IEEE8021Q_TT_BK] =3D 0, + [IEEE8021Q_TT_BE] =3D 1, + [IEEE8021Q_TT_EE] =3D 2, + [IEEE8021Q_TT_CA] =3D 3, + [IEEE8021Q_TT_VI] =3D 4, + [IEEE8021Q_TT_VO] =3D 5, + [IEEE8021Q_TT_IC] =3D 6, + [IEEE8021Q_TT_NC] =3D 7, +}; + +static const u8 ieee8021q_7queue_tt_tc_map[] =3D { + [IEEE8021Q_TT_BK] =3D 0, + [IEEE8021Q_TT_BE] =3D 1, + [IEEE8021Q_TT_EE] =3D 2, + [IEEE8021Q_TT_CA] =3D 3, + [IEEE8021Q_TT_VI] =3D 4, [IEEE8021Q_TT_VO] =3D 4, + [IEEE8021Q_TT_IC] =3D 5, + [IEEE8021Q_TT_NC] =3D 6, +}; + +static const u8 ieee8021q_6queue_tt_tc_map[] =3D { + [IEEE8021Q_TT_BK] =3D 0, + [IEEE8021Q_TT_BE] =3D 1, + [IEEE8021Q_TT_EE] =3D 2, [IEEE8021Q_TT_CA] =3D 2, + [IEEE8021Q_TT_VI] =3D 3, [IEEE8021Q_TT_VO] =3D 3, + [IEEE8021Q_TT_IC] =3D 4, + [IEEE8021Q_TT_NC] =3D 5, +}; + +static const u8 ieee8021q_5queue_tt_tc_map[] =3D { + [IEEE8021Q_TT_BK] =3D 0, [IEEE8021Q_TT_BE] =3D 0, + [IEEE8021Q_TT_EE] =3D 1, [IEEE8021Q_TT_CA] =3D 1, + [IEEE8021Q_TT_VI] =3D 2, [IEEE8021Q_TT_VO] =3D 2, + [IEEE8021Q_TT_IC] =3D 3, + [IEEE8021Q_TT_NC] =3D 4, +}; + +static const u8 ieee8021q_4queue_tt_tc_map[] =3D { + [IEEE8021Q_TT_BK] =3D 0, [IEEE8021Q_TT_BE] =3D 0, + [IEEE8021Q_TT_EE] =3D 1, [IEEE8021Q_TT_CA] =3D 1, + [IEEE8021Q_TT_VI] =3D 2, [IEEE8021Q_TT_VO] =3D 2, + [IEEE8021Q_TT_IC] =3D 3, [IEEE8021Q_TT_NC] =3D 3, +}; + +static const u8 ieee8021q_3queue_tt_tc_map[] =3D { + [IEEE8021Q_TT_BK] =3D 0, [IEEE8021Q_TT_BE] =3D 0, + [IEEE8021Q_TT_EE] =3D 0, [IEEE8021Q_TT_CA] =3D 0, + [IEEE8021Q_TT_VI] =3D 1, [IEEE8021Q_TT_VO] =3D 1, + [IEEE8021Q_TT_IC] =3D 2, [IEEE8021Q_TT_NC] =3D 2, +}; + +static const u8 ieee8021q_2queue_tt_tc_map[] =3D { + [IEEE8021Q_TT_BK] =3D 0, [IEEE8021Q_TT_BE] =3D 0, + [IEEE8021Q_TT_EE] =3D 0, [IEEE8021Q_TT_CA] =3D 0, + [IEEE8021Q_TT_VI] =3D 1, [IEEE8021Q_TT_VO] =3D 1, + [IEEE8021Q_TT_IC] =3D 1, [IEEE8021Q_TT_NC] =3D 1, +}; + +static const u8 ieee8021q_1queue_tt_tc_map[] =3D { + [IEEE8021Q_TT_BK] =3D 0, [IEEE8021Q_TT_BE] =3D 0, + [IEEE8021Q_TT_EE] =3D 0, [IEEE8021Q_TT_CA] =3D 0, + [IEEE8021Q_TT_VI] =3D 0, [IEEE8021Q_TT_VO] =3D 0, + [IEEE8021Q_TT_IC] =3D 0, [IEEE8021Q_TT_NC] =3D 0, +}; + +/** + * ieee8021q_tt_to_tc - Map IEEE 802.1Q Traffic Type to Traffic Class + * @tt: IEEE 802.1Q Traffic Type + * @num_queues: Number of queues + * + * This function maps an IEEE 802.1Q Traffic Type to a Traffic Class (TC) = based + * on the number of queues configured on the switch. The mapping is based = on the + * example provided by IEEE 802.1Q-2022 in Annex I "I.3 Traffic type to tr= affic + * class mapping" and Table I-1 "Traffic type to traffic class mapping". + * + * Return: Traffic Class corresponding to the given Traffic Type or -EINVA= L if + * the number of queues is not supported. -EINVAL is used to differentiate= from + * -EOPNOTSUPP which is used to indicate that this library function is not + * compiled in. + */ +int ieee8021q_tt_to_tc(unsigned int tt, unsigned int num_queues) +{ + if (tt >=3D IEEE8021Q_TT_MAX) { + pr_err("Requested Traffic Type (%d) is out of range (%d)\n", tt, + IEEE8021Q_TT_MAX); + return -EINVAL; + } + + switch (num_queues) { + case 8: + compiletime_assert(ARRAY_SIZE(ieee8021q_8queue_tt_tc_map) !=3D + IEEE8021Q_TT_MAX - 1, + "ieee8021q_8queue_tt_tc_map !=3D max - 1"); + return ieee8021q_8queue_tt_tc_map[tt]; + case 7: + compiletime_assert(ARRAY_SIZE(ieee8021q_7queue_tt_tc_map) !=3D + IEEE8021Q_TT_MAX - 1, + "ieee8021q_7queue_tt_tc_map !=3D max - 1"); + + return ieee8021q_7queue_tt_tc_map[tt]; + case 6: + compiletime_assert(ARRAY_SIZE(ieee8021q_6queue_tt_tc_map) !=3D + IEEE8021Q_TT_MAX - 1, + "ieee8021q_6queue_tt_tc_map !=3D max - 1"); + + return ieee8021q_6queue_tt_tc_map[tt]; + case 5: + compiletime_assert(ARRAY_SIZE(ieee8021q_5queue_tt_tc_map) !=3D + IEEE8021Q_TT_MAX - 1, + "ieee8021q_5queue_tt_tc_map !=3D max - 1"); + + return ieee8021q_5queue_tt_tc_map[tt]; + case 4: + compiletime_assert(ARRAY_SIZE(ieee8021q_4queue_tt_tc_map) !=3D + IEEE8021Q_TT_MAX - 1, + "ieee8021q_4queue_tt_tc_map !=3D max - 1"); + + return ieee8021q_4queue_tt_tc_map[tt]; + case 3: + compiletime_assert(ARRAY_SIZE(ieee8021q_3queue_tt_tc_map) !=3D + IEEE8021Q_TT_MAX - 1, + "ieee8021q_3queue_tt_tc_map !=3D max - 1"); + + return ieee8021q_3queue_tt_tc_map[tt]; + case 2: + compiletime_assert(ARRAY_SIZE(ieee8021q_2queue_tt_tc_map) !=3D + IEEE8021Q_TT_MAX - 1, + "ieee8021q_2queue_tt_tc_map !=3D max - 1"); + + return ieee8021q_2queue_tt_tc_map[tt]; + case 1: + compiletime_assert(ARRAY_SIZE(ieee8021q_1queue_tt_tc_map) !=3D + IEEE8021Q_TT_MAX - 1, + "ieee8021q_1queue_tt_tc_map !=3D max - 1"); + + return ieee8021q_1queue_tt_tc_map[tt]; + } + + pr_err("Invalid number of queues %d\n", num_queues); + + return -EINVAL; +} +EXPORT_SYMBOL_GPL(ieee8021q_tt_to_tc); + +/** + * ietf_dscp_to_ieee8021q_tt - Map IETF DSCP to IEEE 802.1Q Traffic Type + * @dscp: IETF DSCP value + * + * This function maps an IETF DSCP value to an IEEE 802.1Q Traffic Type (T= T). + * Since there is no corresponding mapping between DSCP and IEEE 802.1Q Tr= affic + * Type, this function is inspired by the RFC8325 documentation which desc= ribe + * the mapping between DSCP and 802.11 User Priority (UP) values. + * + * Return: IEEE 802.1Q Traffic Type corresponding to the given DSCP value + */ +int ietf_dscp_to_ieee8021q_tt(u8 dscp) +{ + switch (dscp) { + case DSCP_CS0: + case DSCP_AF11: + case DSCP_AF12: + case DSCP_AF13: + return IEEE8021Q_TT_BE; + case DSCP_CS1: + return IEEE8021Q_TT_BK; + case DSCP_CS2: + case DSCP_AF21: + case DSCP_AF22: + case DSCP_AF23: + return IEEE8021Q_TT_EE; + case DSCP_CS3: + case DSCP_AF31: + case DSCP_AF32: + case DSCP_AF33: + return IEEE8021Q_TT_CA; + case DSCP_CS4: + case DSCP_AF41: + case DSCP_AF42: + case DSCP_AF43: + return IEEE8021Q_TT_VI; + case DSCP_CS5: + case DSCP_EF: + case DSCP_VOICE_ADMIT: + return IEEE8021Q_TT_VO; + case DSCP_CS6: + return IEEE8021Q_TT_IC; + case DSCP_CS7: + return IEEE8021Q_TT_NC; + } + + return SIMPLE_IETF_DSCP_TO_IEEE8021Q_TT(dscp); +} +EXPORT_SYMBOL_GPL(ietf_dscp_to_ieee8021q_tt); --=20 2.39.2