nfp: flower: refactor tunnel key layer calculation

Refactor the key layer calculation function, in particular the tunnel
key layer calculation by introducing helper functions. This is done
in preparation for supporting GRE tunnel offloads.

Signed-off-by: Pieter Jansen van Vuuren <pieter.jansenvanvuuren@netronome.com>
Reviewed-by: Jakub Kicinski <jakub.kicinski@netronome.com>
Reviewed-by: John Hurley <john.hurley@netronome.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

diff --git a/drivers/net/ethernet/netronome/nfp/flower/offload.c b/drivers/net/ethernet/netronome/nfp/flower/offload.c
index 39e6599..6b28910 100644 (file)
--- a/drivers/net/ethernet/netronome/nfp/flower/offload.c
+++ b/drivers/net/ethernet/netronome/nfp/flower/offload.c
@@ -141,16 +141,16 @@ static bool nfp_flower_check_higher_than_l3(struct tc_cls_flower_offload *f)
 }
 
 static int
-nfp_flower_calc_opt_layer(struct flow_match_enc_opts *enc_opts,
+nfp_flower_calc_opt_layer(struct flow_dissector_key_enc_opts *enc_opts,
                          u32 *key_layer_two, int *key_size,
                          struct netlink_ext_ack *extack)
 {
-       if (enc_opts->key->len > NFP_FL_MAX_GENEVE_OPT_KEY) {
+       if (enc_opts->len > NFP_FL_MAX_GENEVE_OPT_KEY) {
                NL_SET_ERR_MSG_MOD(extack, "unsupported offload: geneve options exceed maximum length");
                return -EOPNOTSUPP;
        }
 
-       if (enc_opts->key->len > 0) {
+       if (enc_opts->len > 0) {
                *key_layer_two |= NFP_FLOWER_LAYER2_GENEVE_OP;
                *key_size += sizeof(struct nfp_flower_geneve_options);
        }
@@ -158,6 +158,57 @@ nfp_flower_calc_opt_layer(struct flow_match_enc_opts *enc_opts,
        return 0;
 }
 
+static int
+nfp_flower_calc_udp_tun_layer(struct flow_dissector_key_ports *enc_ports,
+                             struct flow_dissector_key_enc_opts *enc_op,
+                             u32 *key_layer_two, u8 *key_layer, int *key_size,
+                             struct nfp_flower_priv *priv,
+                             enum nfp_flower_tun_type *tun_type,
+                             struct netlink_ext_ack *extack)
+{
+       int err;
+
+       switch (enc_ports->dst) {
+       case htons(IANA_VXLAN_UDP_PORT):
+               *tun_type = NFP_FL_TUNNEL_VXLAN;
+               *key_layer |= NFP_FLOWER_LAYER_VXLAN;
+               *key_size += sizeof(struct nfp_flower_ipv4_udp_tun);
+
+               if (enc_op) {
+                       NL_SET_ERR_MSG_MOD(extack, "unsupported offload: encap options not supported on vxlan tunnels");
+                       return -EOPNOTSUPP;
+               }
+               break;
+       case htons(GENEVE_UDP_PORT):
+               if (!(priv->flower_ext_feats & NFP_FL_FEATS_GENEVE)) {
+                       NL_SET_ERR_MSG_MOD(extack, "unsupported offload: loaded firmware does not support geneve offload");
+                       return -EOPNOTSUPP;
+               }
+               *tun_type = NFP_FL_TUNNEL_GENEVE;
+               *key_layer |= NFP_FLOWER_LAYER_EXT_META;
+               *key_size += sizeof(struct nfp_flower_ext_meta);
+               *key_layer_two |= NFP_FLOWER_LAYER2_GENEVE;
+               *key_size += sizeof(struct nfp_flower_ipv4_udp_tun);
+
+               if (!enc_op)
+                       break;
+               if (!(priv->flower_ext_feats & NFP_FL_FEATS_GENEVE_OPT)) {
+                       NL_SET_ERR_MSG_MOD(extack, "unsupported offload: loaded firmware does not support geneve option offload");
+                       return -EOPNOTSUPP;
+               }
+               err = nfp_flower_calc_opt_layer(enc_op, key_layer_two,
+                                               key_size, extack);
+               if (err)
+                       return err;
+               break;
+       default:
+               NL_SET_ERR_MSG_MOD(extack, "unsupported offload: tunnel type unknown");
+               return -EOPNOTSUPP;
+       }
+
+       return 0;
+}
+
 static int
 nfp_flower_calculate_key_layers(struct nfp_app *app,
                                struct net_device *netdev,
@@ -243,44 +294,13 @@ nfp_flower_calculate_key_layers(struct nfp_app *app,
                if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_ENC_OPTS))
                        flow_rule_match_enc_opts(rule, &enc_op);
 
-               switch (enc_ports.key->dst) {
-               case htons(IANA_VXLAN_UDP_PORT):
-                       *tun_type = NFP_FL_TUNNEL_VXLAN;
-                       key_layer |= NFP_FLOWER_LAYER_VXLAN;
-                       key_size += sizeof(struct nfp_flower_ipv4_udp_tun);
-
-                       if (enc_op.key) {
-                               NL_SET_ERR_MSG_MOD(extack, "unsupported offload: encap options not supported on vxlan tunnels");
-                               return -EOPNOTSUPP;
-                       }
-                       break;
-               case htons(GENEVE_UDP_PORT):
-                       if (!(priv->flower_ext_feats & NFP_FL_FEATS_GENEVE)) {
-                               NL_SET_ERR_MSG_MOD(extack, "unsupported offload: loaded firmware does not support geneve offload");
-                               return -EOPNOTSUPP;
-                       }
-                       *tun_type = NFP_FL_TUNNEL_GENEVE;
-                       key_layer |= NFP_FLOWER_LAYER_EXT_META;
-                       key_size += sizeof(struct nfp_flower_ext_meta);
-                       key_layer_two |= NFP_FLOWER_LAYER2_GENEVE;
-                       key_size += sizeof(struct nfp_flower_ipv4_udp_tun);
 
-                       if (!enc_op.key)
-                               break;
-                       if (!(priv->flower_ext_feats &
-                             NFP_FL_FEATS_GENEVE_OPT)) {
-                               NL_SET_ERR_MSG_MOD(extack, "unsupported offload: loaded firmware does not support geneve option offload");
-                               return -EOPNOTSUPP;
-                       }
-                       err = nfp_flower_calc_opt_layer(&enc_op, &key_layer_two,
-                                                       &key_size, extack);
-                       if (err)
-                               return err;
-                       break;
-               default:
-                       NL_SET_ERR_MSG_MOD(extack, "unsupported offload: tunnel type unknown");
-                       return -EOPNOTSUPP;
-               }
+               err = nfp_flower_calc_udp_tun_layer(enc_ports.key, enc_op.key,
+                                                   &key_layer_two, &key_layer,
+                                                   &key_size, priv, tun_type,
+                                                   extack);
+               if (err)
+                       return err;
 
                /* Ensure the ingress netdev matches the expected tun type. */
                if (!nfp_fl_netdev_is_tunnel_type(netdev, *tun_type)) {