Re: [PATCH net-next v1 2/8] net: ieee8021q: add pcp_to_tt()

[Luiz Angelo Daros de Luca]

> Add a helper that maps an IEEE 802.1Q Priority Code Point (PCP) to the
> corresponding 802.1Q traffic type, complementing the existing
> ietf_dscp_to_ieee8021q_tt().
>
> It is very nearly an identity map, except that PCP 0 (Best Effort) and
> PCP 1 (Background) are swapped: per 802.1Q-2022 (Annex I, Table I-2)
> Background is a lower priority than Best Effort even though it carries
> the higher PCP value. PCP 2..7 map straight through to the matching
> traffic type, and values above 7 are rejected with -EINVAL. This decodes
> the 8P0D encoding (Table I-7), where every PCP value is a priority and
> none carries drop eligibility.
>
> Drivers that classify ingress traffic by PCP need this to map into a
> priority-ordered internal space without misordering Best Effort and
> Background. The first consumer, the realtek rtl8365mb DSA driver, lands
> later in this series.
>
> Signed-off-by: Oleksij Rempel <o.rempel@xxxxxxxxxxxxxx>
> ---
>  include/net/ieee8021q.h      | 10 +++++++--
>  net/core/ieee8021q_helpers.c | 41 ++++++++++++++++++++++++++++++++++++
>  2 files changed, 49 insertions(+), 2 deletions(-)
>
> diff --git a/include/net/ieee8021q.h b/include/net/ieee8021q.h
> index 8bfe903dd3d0..d24e4036577b 100644
> --- a/include/net/ieee8021q.h
> +++ b/include/net/ieee8021q.h
> @@ -10,8 +10,8 @@
>   * 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 is 0
> - * but has higher priority than BK which is 1.
> + * @IEEE8021Q_TT_BE: Best Effort (default). According to 802.1Q-2022 (Annex I,
> + * Table I-2), BE is 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
> @@ -38,6 +38,7 @@ enum ieee8021q_traffic_type {
>  #if IS_ENABLED(CONFIG_NET_IEEE8021Q_HELPERS)
>
>  int ietf_dscp_to_ieee8021q_tt(u8 dscp);
> +int ieee8021q_pcp_to_tt(u8 pcp);
>  int ieee8021q_tt_to_tc(enum ieee8021q_traffic_type tt, unsigned int num_queues);
>
>  #else
> @@ -47,6 +48,11 @@ static inline int ietf_dscp_to_ieee8021q_tt(u8 dscp)
>         return -EOPNOTSUPP;
>  }
>
> +static inline int ieee8021q_pcp_to_tt(u8 pcp)
> +{
> +       return -EOPNOTSUPP;
> +}
> +
>  static inline int ieee8021q_tt_to_tc(enum ieee8021q_traffic_type tt,
>                                      unsigned int num_queues)
>  {
> diff --git a/net/core/ieee8021q_helpers.c b/net/core/ieee8021q_helpers.c
> index bbacdfff9b4c..a5bd5e039b47 100644
> --- a/net/core/ieee8021q_helpers.c
> +++ b/net/core/ieee8021q_helpers.c
> @@ -222,3 +222,44 @@ int ietf_dscp_to_ieee8021q_tt(u8 dscp)
>         return SIMPLE_IETF_DSCP_TO_IEEE8021Q_TT(dscp);
>  }
>  EXPORT_SYMBOL_GPL(ietf_dscp_to_ieee8021q_tt);
> +
> +/**
> + * ieee8021q_pcp_to_tt - Map an IEEE 802.1Q PCP to a traffic type
> + * @pcp: IEEE 802.1Q Priority Code Point value
> + *
> + * Decode @pcp to its IEEE 802.1Q traffic type per Table I-7 ("Priority Code
> + * Point decoding") for the 8P0D encoding, where all eight PCP values are
> + * priorities and none carries drop eligibility. It is nearly the identity,
> + * except PCP 0 (Best Effort) and PCP 1 (Background) map to swapped traffic
> + * types: Background is lower priority than Best Effort despite the higher PCP
> + * value (Table I-2: BE = priority 0, BK = priority 1).
> + *
> + * The 7P1D/6P2D/5P3D encodings, whose lower PCP values carry drop eligibility,
> + * are the other rows of Table I-7 and are not decoded here.
> + *
> + * Return: the traffic type, or a negative value on error.
> + */
> +int ieee8021q_pcp_to_tt(u8 pcp)
> +{
> +       switch (pcp) {
> +       case 0:
> +               return IEEE8021Q_TT_BE;
> +       case 1:
> +               return IEEE8021Q_TT_BK;
> +       case 2:
> +               return IEEE8021Q_TT_EE;
> +       case 3:
> +               return IEEE8021Q_TT_CA;
> +       case 4:
> +               return IEEE8021Q_TT_VI;
> +       case 5:
> +               return IEEE8021Q_TT_VO;
> +       case 6:
> +               return IEEE8021Q_TT_IC;
> +       case 7:
> +               return IEEE8021Q_TT_NC;
> +       }
> +
> +       return -EINVAL;

Would it be cleaner to use a lookup table here instead of the switch
statement? It saves quite a few lines (not tested):

static const u8 ieee8021q_pcp_to_tt_map[] = {
  [0] = IEEE8021Q_TT_BE,
  [1] = IEEE8021Q_TT_BK,
  [2] = IEEE8021Q_TT_EE,
  [3] = IEEE8021Q_TT_CA,
  [4] = IEEE8021Q_TT_VI,
  [5] = IEEE8021Q_TT_VO,
  [6] = IEEE8021Q_TT_IC,
  [7] = IEEE8021Q_TT_NC,
};

int ieee8021q_pcp_to_tt(u8 pcp)
{
  if (pcp >= ARRAY_SIZE(ieee8021q_pcp_to_tt_map))
    return -EINVAL;

  return ieee8021q_pcp_to_tt_map[pcp];
}

Best regards,
Luiz