Commit fefe3b7d authored by Aaron Conole's avatar Aaron Conole Committed by Jakub Kicinski
Browse files

selftests: openvswitch: Add support for tunnel() key. 



This will be used when setting details about the tunnel to use as
transport.  There is a difference between the ODP format between tunnel():
the 'key' flag is not actually a flag field, so we don't support it in the
same way that the vswitchd userspace supports displaying it.

Signed-off-by: default avatarAaron Conole <aconole@redhat.com>
Reviewed-by: default avatarSimon Horman <horms@kernel.org>
Tested-by: default avatarSimon Horman <horms@kernel.org>
Link: https://patch.msgid.link/20240625172245.233874-5-aconole@redhat.com


Signed-off-by: default avatarJakub Kicinski <kuba@kernel.org>
parent a4126f90

tools/testing/selftests/net/openvswitch/ovs-dpctl.py

+166 −1
Original line number Diff line number Diff line
@@ -709,7 +709,7 @@ class ovskey(nla): 
        ("OVS_KEY_ATTR_ARP", "ovs_key_arp"),

        ("OVS_KEY_ATTR_ND", "ovs_key_nd"),

        ("OVS_KEY_ATTR_SKB_MARK", "uint32"),

        ("OVS_KEY_ATTR_TUNNEL", "none"),

        ("OVS_KEY_ATTR_TUNNEL", "ovs_key_tunnel"),

        ("OVS_KEY_ATTR_SCTP", "ovs_key_sctp"),

        ("OVS_KEY_ATTR_TCP_FLAGS", "be16"),

        ("OVS_KEY_ATTR_DP_HASH", "uint32"),
@@ -1269,6 +1269,163 @@ class ovskey(nla): 
                init=init,

            )



    class ovs_key_tunnel(nla):

        nla_flags = NLA_F_NESTED



        nla_map = (

            ("OVS_TUNNEL_KEY_ATTR_ID", "be64"),

            ("OVS_TUNNEL_KEY_ATTR_IPV4_SRC", "ipaddr"),

            ("OVS_TUNNEL_KEY_ATTR_IPV4_DST", "ipaddr"),

            ("OVS_TUNNEL_KEY_ATTR_TOS", "uint8"),

            ("OVS_TUNNEL_KEY_ATTR_TTL", "uint8"),

            ("OVS_TUNNEL_KEY_ATTR_DONT_FRAGMENT", "flag"),

            ("OVS_TUNNEL_KEY_ATTR_CSUM", "flag"),

            ("OVS_TUNNEL_KEY_ATTR_OAM", "flag"),

            ("OVS_TUNNEL_KEY_ATTR_GENEVE_OPTS", "array(uint32)"),

            ("OVS_TUNNEL_KEY_ATTR_TP_SRC", "be16"),

            ("OVS_TUNNEL_KEY_ATTR_TP_DST", "be16"),

            ("OVS_TUNNEL_KEY_ATTR_VXLAN_OPTS", "none"),

            ("OVS_TUNNEL_KEY_ATTR_IPV6_SRC", "ipaddr"),

            ("OVS_TUNNEL_KEY_ATTR_IPV6_DST", "ipaddr"),

            ("OVS_TUNNEL_KEY_ATTR_PAD", "none"),

            ("OVS_TUNNEL_KEY_ATTR_ERSPAN_OPTS", "none"),

            ("OVS_TUNNEL_KEY_ATTR_IPV4_INFO_BRIDGE", "flag"),

        )



        def parse(self, flowstr, mask=None):

            if not flowstr.startswith("tunnel("):

                return None, None



            k = ovskey.ovs_key_tunnel()

            if mask is not None:

                mask = ovskey.ovs_key_tunnel()



            flowstr = flowstr[len("tunnel("):]



            v6_address = None



            fields = [

                ("tun_id=", r"(\d+)", int, "OVS_TUNNEL_KEY_ATTR_ID",

                 0xffffffffffffffff, None, None),



                ("src=", r"([0-9a-fA-F\.]+)", str,

                 "OVS_TUNNEL_KEY_ATTR_IPV4_SRC", "255.255.255.255", "0.0.0.0",

                 False),

                ("dst=", r"([0-9a-fA-F\.]+)", str,

                 "OVS_TUNNEL_KEY_ATTR_IPV4_DST", "255.255.255.255", "0.0.0.0",

                 False),



                ("ipv6_src=", r"([0-9a-fA-F:]+)", str,

                 "OVS_TUNNEL_KEY_ATTR_IPV6_SRC",

                 "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", "::", True),

                ("ipv6_dst=", r"([0-9a-fA-F:]+)", str,

                 "OVS_TUNNEL_KEY_ATTR_IPV6_DST",

                 "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", "::", True),



                ("tos=", r"(\d+)", int, "OVS_TUNNEL_KEY_ATTR_TOS", 255, 0,

                 None),

                ("ttl=", r"(\d+)", int, "OVS_TUNNEL_KEY_ATTR_TTL", 255, 0,

                 None),



                ("tp_src=", r"(\d+)", int, "OVS_TUNNEL_KEY_ATTR_TP_SRC",

                 65535, 0, None),

                ("tp_dst=", r"(\d+)", int, "OVS_TUNNEL_KEY_ATTR_TP_DST",

                 65535, 0, None),

            ]



            forced_include = ["OVS_TUNNEL_KEY_ATTR_TTL"]



            for prefix, regex, typ, attr_name, mask_val, default_val, v46_flag in fields:

                flowstr, value = parse_extract_field(flowstr, prefix, regex, typ, False)

                if not attr_name:

                    raise Exception("Bad list value in tunnel fields")



                if value is None and attr_name in forced_include:

                    value = default_val

                    mask_val = default_val



                if value is not None:

                    if v46_flag is not None:

                        if v6_address is None:

                            v6_address = v46_flag

                        if v46_flag != v6_address:

                            raise ValueError("Cannot mix v6 and v4 addresses")

                    k["attrs"].append([attr_name, value])

                    if mask is not None:

                        mask["attrs"].append([attr_name, mask_val])

                else:

                    if v46_flag is not None:

                        if v6_address is None or v46_flag != v6_address:

                            continue

                    if mask is not None:

                        mask["attrs"].append([attr_name, default_val])



            if k["attrs"][0][0] != "OVS_TUNNEL_KEY_ATTR_ID":

                raise ValueError("Needs a tunid set")



            if flowstr.startswith("flags("):

                flowstr = flowstr[len("flags("):]

                flagspos = flowstr.find(")")

                flags = flowstr[:flagspos]

                flowstr = flowstr[flagspos + 1:]



                flag_attrs = {

                    "df": "OVS_TUNNEL_KEY_ATTR_DONT_FRAGMENT",

                    "csum": "OVS_TUNNEL_KEY_ATTR_CSUM",

                    "oam": "OVS_TUNNEL_KEY_ATTR_OAM"

                }



                for flag in flags.split("|"):

                    if flag in flag_attrs:

                        k["attrs"].append([flag_attrs[flag], True])

                        if mask is not None:

                            mask["attrs"].append([flag_attrs[flag], True])



            flowstr = flowstr[strspn(flowstr, ", ") :]

            return flowstr, k, mask



        def dpstr(self, mask=None, more=False):

            print_str = "tunnel("



            flagsattrs = []

            for k in self["attrs"]:

                noprint = False

                if k[0] == "OVS_TUNNEL_KEY_ATTR_ID":

                    print_str += "tun_id=%d" % k[1]

                elif k[0] == "OVS_TUNNEL_KEY_ATTR_IPV4_SRC":

                    print_str += "src=%s" % k[1]

                elif k[0] == "OVS_TUNNEL_KEY_ATTR_IPV4_DST":

                    print_str += "dst=%s" % k[1]

                elif k[0] == "OVS_TUNNEL_KEY_ATTR_IPV6_SRC":

                    print_str += "ipv6_src=%s" % k[1]

                elif k[0] == "OVS_TUNNEL_KEY_ATTR_IPV6_DST":

                    print_str += "ipv6_dst=%s" % k[1]

                elif k[0] == "OVS_TUNNEL_KEY_ATTR_TOS":

                    print_str += "tos=%d" % k[1]

                elif k[0] == "OVS_TUNNEL_KEY_ATTR_TTL":

                    print_str += "ttl=%d" % k[1]

                elif k[0] == "OVS_TUNNEL_KEY_ATTR_TP_SRC":

                    print_str += "tp_src=%d" % k[1]

                elif k[0] == "OVS_TUNNEL_KEY_ATTR_TP_DST":

                    print_str += "tp_dst=%d" % k[1]

                elif k[0] == "OVS_TUNNEL_KEY_ATTR_DONT_FRAGMENT":

                    noprint = True

                    flagsattrs.append("df")

                elif k[0] == "OVS_TUNNEL_KEY_ATTR_CSUM":

                    noprint = True

                    flagsattrs.append("csum")

                elif k[0] == "OVS_TUNNEL_KEY_ATTR_OAM":

                    noprint = True

                    flagsattrs.append("oam")



                if not noprint:

                    print_str += ","



            if len(flagsattrs):

                print_str += "flags(" + "|".join(flagsattrs) + ")"

            print_str += ")"

            return print_str



    class ovs_key_mpls(nla):

        fields = (("lse", ">I"),)
@@ -1277,6 +1434,7 @@ class ovskey(nla): 
            ("OVS_KEY_ATTR_PRIORITY", "skb_priority", intparse),

            ("OVS_KEY_ATTR_SKB_MARK", "skb_mark", intparse),

            ("OVS_KEY_ATTR_RECIRC_ID", "recirc_id", intparse),

            ("OVS_KEY_ATTR_TUNNEL", "tunnel", ovskey.ovs_key_tunnel),

            ("OVS_KEY_ATTR_DP_HASH", "dp_hash", intparse),

            ("OVS_KEY_ATTR_CT_STATE", "ct_state", parse_ct_state),

            ("OVS_KEY_ATTR_CT_ZONE", "ct_zone", intparse),
@@ -1379,6 +1537,13 @@ class ovskey(nla): 
                lambda x: False,

                True,

            ),

            (

                "OVS_KEY_ATTR_TUNNEL",

                "tunnel",

                None,

                False,

                False,

            ),

            (

                "OVS_KEY_ATTR_CT_STATE",

                "ct_state",