Clear L2 output config on interface mode change to L3 (VPP-651)

With VPP-651, the L2 output config with L2-tag rewrite was not
cleared when a sub-interface is deleted. Subsequently, when the
same sw_if_index was reused for another interface, the L2 output
config with L2-tag rewrite remained on the new interface.

On deleting a (sub-)interface which is in L2 mode, it will be
changed to L3 mode first to clear any L2 config. The L2 to L3 mode
change path did address L2 input config cleanup. It is now fixed
to also clear L2 output config.

Change-Id: I3352a89d92e1b27340a5adcf75bbaa01a5050c29
Signed-off-by: John Lo <loj@cisco.com>

1 files changed, 11 insertions, 4 deletions

diff --git a/src/vnet/l2/l2_input.c b/src/vnet/l2/l2_input.c
index ead9ca85494..fbd75f222e0 100644
--- a/src/vnet/l2/l2_input.c
+++ b/src/vnet/l2/l2_input.c
@@ -513,10 +513,13 @@ l2input_set_bridge_features (u32 bd_index, u32 feat_mask, u32 feat_value)
  */
 
 u32
-set_int_l2_mode (vlib_main_t * vm, vnet_main_t * vnet_main, u32 mode, u32 sw_if_index, u32 bd_index,	/* for bridged interface */
-		 u32 bvi,	/* the bridged interface is the BVI */
-		 u32 shg,	/* the bridged interface's split horizon group */
-		 u32 xc_sw_if_index)	/* peer interface for xconnect */
+set_int_l2_mode (vlib_main_t * vm, vnet_main_t * vnet_main,	/*           */
+		 u32 mode,	/* One of L2 modes or back to L3 mode        */
+		 u32 sw_if_index,	/* sw interface index                */
+		 u32 bd_index,	/* for bridged interface                     */
+		 u32 bvi,	/* the bridged interface is the BVI          */
+		 u32 shg,	/* the bridged interface split horizon group */
+		 u32 xc_sw_if_index)	/* peer interface for xconnect       */
 {
   l2input_main_t *mp = &l2input_main;
   l2output_main_t *l2om = &l2output_main;
@@ -584,6 +587,10 @@ set_int_l2_mode (vlib_main_t * vm, vnet_main_t * vnet_main, u32 mode, u32 sw_if_
       config->bd_index = 0;
       config->feature_bitmap = L2INPUT_FEAT_DROP;
 
+      /* Clear L2 output config */
+      out_config = l2output_intf_config (sw_if_index);
+      memset (out_config, 0, sizeof (l2_output_config_t));
+
       /* Make sure any L2-output packet to this interface now in L3 mode is
        * dropped. This may happen if L2 FIB MAC entry is stale */
       l2om->next_nodes.output_node_index_vec[sw_if_index] =

path: root/src

# Copyright (c) 2019 Cisco and/or its affiliates.
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at:
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

"""Memif interface library."""


from enum import IntEnum

from robot.api import logger

from resources.libraries.python.topology import NodeType, Topology
from resources.libraries.python.PapiExecutor import PapiSocketExecutor


class MemifRole(IntEnum):
    """Memif interface roles"""
    MASTER = 0
    SLAVE = 1


class Memif:
    """Memif interface class"""

    def __init__(self):
        pass

    @staticmethod
    def _memif_details(node):
        """Get the memif dump details on the given node.

        :param node: Given node to get Memif dump from.
        :type node: dict
        :returns: List of memif interfaces extracted from Papi response.
        :rtype: list
        """
        cmd = u"memif_dump"
        with PapiSocketExecutor(node) as papi_exec:
            details = papi_exec.add(cmd).get_details()

        for memif in details:
            memif[u"hw_addr"] = str(memif[u"hw_addr"])
            memif[u"role"] = memif[u"role"].value
            memif[u"mode"] = memif[u"mode"].value
            memif[u"flags"] = memif[u"flags"].value \
                if hasattr(memif[u"flags"], u"value") else int(memif[u"flags"])

        logger.debug(f"MEMIF details:\n{details}")

        return details

    @staticmethod
    def _memif_socket_filename_add_del(node, is_add, filename, sid):
        """Create Memif socket on the given node.

        :param node: Given node to create Memif socket on.
        :param is_add: If True, socket is added, otherwise deleted.
        :param filename: Memif interface socket filename.
        :param sid: Socket ID.
        :type node: dict
        :type is_add: bool
        :type filename: str
        :type sid: str
        :returns: Verified data from PAPI response. In this case, the response
            includes only retval.
        :rtype: dict
        """
        cmd = u"memif_socket_filename_add_del"
        err_msg = f"Failed to create memif socket on host {node[u'host']}"
        args = dict(
            is_add=is_add,
            socket_id=int(sid),
            socket_filename=str(u"/tmp/" + filename)
        )
        with PapiSocketExecutor(node) as papi_exec:
            return papi_exec.add(cmd, **args).get_reply(err_msg)

    @staticmethod
    def _memif_create(node, mid, sid, rxq=1, txq=1, role=1):
        """Create Memif interface on the given node, return its sw_if_index.

        :param node: Given node to create Memif interface on.
        :param mid: Memif interface ID.
        :param sid: Socket ID.
        :param rxq: Number of RX queues; 0 means do not set.
        :param txq: Number of TX queues; 0 means do not set.
        :param role: Memif interface role [master=0|slave=1]. Default is slave.
        :type node: dict
        :type mid: str
        :type sid: str
        :type rxq: int
        :type txq: int
        :type role: int
        :returns: sw_if_index
        :rtype: int
        """
        cmd = u"memif_create"
        err_msg = f"Failed to create memif interface on host {node[u'host']}"
        args = dict(
            role=role,
            rx_queues=int(rxq),
            tx_queues=int(txq),
            socket_id=int(sid),
            id=int(mid),
            secret=u""
        )

        with PapiSocketExecutor(node) as papi_exec:
            return papi_exec.add(cmd, **args).get_sw_if_index(err_msg)

    @staticmethod
    def create_memif_interface(
            node, filename, mid, sid, rxq=1, txq=1, role=u"SLAVE"):
        """Create Memif interface on the given node.

        :param node: Given node to create Memif interface on.
        :param filename: Memif interface socket filename.
        :param mid: Memif interface ID.
        :param sid: Socket ID.
        :param rxq: Number of RX queues; 0 means do not set.
        :param txq: Number of TX queues; 0 means do not set.
        :param role: Memif interface role [master=0|slave=1]. Default is master.
        :type node: dict
        :type filename: str
        :type mid: str
        :type sid: str
        :type rxq: int
        :type txq: int
        :type role: str
        :returns: SW interface index.
        :rtype: int
        :raises ValueError: If command 'create memif' fails.
        """
        role = getattr(MemifRole, role.upper()).value

        # Create socket
        Memif._memif_socket_filename_add_del(node, True, filename, sid)

        # Create memif
        sw_if_index = Memif._memif_create(
            node, mid, sid, rxq=rxq, txq=txq, role=role
        )

        # Update Topology
        if_key = Topology.add_new_port(node, u"memif")
        Topology.update_interface_sw_if_index(node, if_key, sw_if_index)

        ifc_name = Memif.vpp_get_memif_interface_name(node, sw_if_index)
        Topology.update_interface_name(node, if_key, ifc_name)

        ifc_mac = Memif.vpp_get_memif_interface_mac(node, sw_if_index)
        Topology.update_interface_mac_address(node, if_key, ifc_mac)

        Topology.update_interface_memif_socket(
            node, if_key, u"/tmp/" + filename
        )
        Topology.update_interface_memif_id(node, if_key, mid)
        Topology.update_interface_memif_role(node, if_key, str(role))

        return sw_if_index

    @staticmethod
    def show_memif(node):
        """Show Memif data for the given node.

        :param node: Given node to show Memif data on.
        :type node: dict
        """
        Memif._memif_details(node)

    @staticmethod
    def show_memif_on_all_duts(nodes):
        """Show Memif data on all DUTs.

        :param nodes: Topology nodes.
        :type nodes: dict
        """
        for node in nodes.values():
            if node[u"type"] == NodeType.DUT:
                Memif.show_memif(node)

    @staticmethod
    def vpp_get_memif_interface_name(node, sw_if_index):
        """Get Memif interface name from Memif interfaces dump.

        :param node: DUT node.
        :param sw_if_index: DUT node.
        :type node: dict
        :type sw_if_index: int
        :returns: Memif interface name, or None if not found.
        :rtype: str
        """
        details = Memif._memif_details(node)

        for memif in details:
            if memif[u"sw_if_index"] == sw_if_index:
                return memif[u"if_name"]
        return None

    @staticmethod
    def vpp_get_memif_interface_mac(node, sw_if_index):
        """Get Memif interface MAC address from Memif interfaces dump.

        :param node: DUT node.
        :param sw_if_index: DUT node.
        :type node: dict
        :type sw_if_index: int
        :returns: Memif interface MAC address, or None if not found.
        :rtype: str
        """
        details = Memif._memif_details(node)

        for memif in details:
            if memif[u"sw_if_index"] == sw_if_index:
                return memif[u"hw_addr"]
        return None