X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=test%2Ftest_ip4.py;h=3f2894d01c104de22d5338a461aaddf3cd75cf6a;hb=06111a837;hp=c99ab63862f5f4d364582f36b4fbe538e21acaa2;hpb=c8f3cdf68a4ce4c480f96b9ca0a8f273ab79cd5e;p=vpp.git diff --git a/test/test_ip4.py b/test/test_ip4.py index c99ab63862f..3f2894d01c1 100644 --- a/test/test_ip4.py +++ b/test/test_ip4.py @@ -11,13 +11,14 @@ from scapy.layers.l2 import Ether, Dot1Q, ARP from scapy.packet import Raw from six import moves +from framework import tag_fixme_vpp_workers from framework import VppTestCase, VppTestRunner from util import ppp from vpp_ip_route import VppIpRoute, VppRoutePath, VppIpMRoute, \ VppMRoutePath, VppMplsIpBind, \ VppMplsTable, VppIpTable, FibPathType, find_route, \ VppIpInterfaceAddress, find_route_in_dump, find_mroute_in_dump -from vpp_ip import VppIpPuntPolicer, VppIpPuntRedirect +from vpp_ip import VppIpPuntPolicer, VppIpPuntRedirect, VppIpPathMtu from vpp_sub_interface import VppSubInterface, VppDot1QSubint, VppDot1ADSubint from vpp_papi import VppEnum from vpp_neighbor import VppNeighbor @@ -1533,6 +1534,14 @@ class TestIPPunt(IPPuntSetup, VppTestCase): # but not equal to the number sent, since some were policed # rx = self.pg1._get_capture(1) + + stats = policer.get_stats() + + # Single rate policer - expect conform, violate but no exceed + self.assertGreater(stats['conform_packets'], 0) + self.assertEqual(stats['exceed_packets'], 0) + self.assertGreater(stats['violate_packets'], 0) + self.assertGreater(len(rx), 0) self.assertLess(len(rx), len(pkts)) @@ -1596,7 +1605,7 @@ class TestIPPunt(IPPuntSetup, VppTestCase): class TestIPPuntHandoff(IPPuntSetup, VppTestCase): """ IPv4 Punt Policer thread handoff """ - worker_config = "workers 2" + vpp_worker_count = 2 def setUp(self): super(TestIPPuntHandoff, self).setUp() @@ -1633,8 +1642,69 @@ class TestIPPuntHandoff(IPPuntSetup, VppTestCase): for worker in [0, 1]: self.send_and_expect(self.pg0, pkts, self.pg1, worker=worker) - if worker == 0: - self.logger.debug(self.vapi.cli("show trace max 100")) + self.logger.debug(self.vapi.cli("show trace max 100")) + + # Combined stats, all threads + stats = policer.get_stats() + + # Single rate policer - expect conform, violate but no exceed + self.assertGreater(stats['conform_packets'], 0) + self.assertEqual(stats['exceed_packets'], 0) + self.assertGreater(stats['violate_packets'], 0) + + # Worker 0, should have done all the policing + stats0 = policer.get_stats(worker=0) + self.assertEqual(stats, stats0) + + # Worker 1, should have handed everything off + stats1 = policer.get_stats(worker=1) + self.assertEqual(stats1['conform_packets'], 0) + self.assertEqual(stats1['exceed_packets'], 0) + self.assertEqual(stats1['violate_packets'], 0) + + # Bind the policer to worker 1 and repeat + policer.bind_vpp_config(1, True) + for worker in [0, 1]: + self.send_and_expect(self.pg0, pkts, self.pg1, worker=worker) + self.logger.debug(self.vapi.cli("show trace max 100")) + + # The 2 workers should now have policed the same amount + stats = policer.get_stats() + stats0 = policer.get_stats(worker=0) + stats1 = policer.get_stats(worker=1) + + self.assertGreater(stats0['conform_packets'], 0) + self.assertEqual(stats0['exceed_packets'], 0) + self.assertGreater(stats0['violate_packets'], 0) + + self.assertGreater(stats1['conform_packets'], 0) + self.assertEqual(stats1['exceed_packets'], 0) + self.assertGreater(stats1['violate_packets'], 0) + + self.assertEqual(stats0['conform_packets'] + stats1['conform_packets'], + stats['conform_packets']) + + self.assertEqual(stats0['violate_packets'] + stats1['violate_packets'], + stats['violate_packets']) + + # Unbind the policer and repeat + policer.bind_vpp_config(1, False) + for worker in [0, 1]: + self.send_and_expect(self.pg0, pkts, self.pg1, worker=worker) + self.logger.debug(self.vapi.cli("show trace max 100")) + + # The policer should auto-bind to worker 0 when packets arrive + stats = policer.get_stats() + stats0new = policer.get_stats(worker=0) + stats1new = policer.get_stats(worker=1) + + self.assertGreater(stats0new['conform_packets'], + stats0['conform_packets']) + self.assertEqual(stats0new['exceed_packets'], 0) + self.assertGreater(stats0new['violate_packets'], + stats0['violate_packets']) + + self.assertEqual(stats1, stats1new) # # Clean up @@ -2069,6 +2139,7 @@ class TestIPLPM(VppTestCase): rx = self.send_and_expect(self.pg0, p_24 * NUM_PKTS, self.pg1) +@tag_fixme_vpp_workers class TestIPv4Frag(VppTestCase): """ IPv4 fragmentation """ @@ -2494,5 +2565,173 @@ class TestIP4Replace(VppTestCase): self.assertTrue(pfx.query_vpp_config()) +class TestIPv4PathMTU(VppTestCase): + """ IPv4 Path MTU """ + + @classmethod + def setUpClass(cls): + super(TestIPv4PathMTU, cls).setUpClass() + + cls.create_pg_interfaces(range(2)) + + # setup all interfaces + for i in cls.pg_interfaces: + i.admin_up() + i.config_ip4() + i.resolve_arp() + + @classmethod + def tearDownClass(cls): + super(TestIPv4PathMTU, cls).tearDownClass() + + def test_path_mtu(self): + """ Path MTU """ + + # + # The goal here is not to test that fragmentation works correctly, + # that's done elsewhere, the intent is to ensure that the Path MTU + # settings are honoured. + # + self.vapi.cli("adjacency counters enable") + + # set the interface MTU to a reasonable value + self.vapi.sw_interface_set_mtu(self.pg1.sw_if_index, + [1800, 0, 0, 0]) + + self.pg1.generate_remote_hosts(4) + + p_2k = (Ether(dst=self.pg0.local_mac, + src=self.pg0.remote_mac) / + IP(src=self.pg0.remote_ip4, + dst=self.pg1.remote_ip4) / + UDP(sport=1234, dport=5678) / + Raw(b'0xa' * 640)) + p_1k = (Ether(dst=self.pg0.local_mac, + src=self.pg0.remote_mac) / + IP(src=self.pg0.remote_ip4, + dst=self.pg1.remote_ip4) / + UDP(sport=1234, dport=5678) / + Raw(b'0xa' * 320)) + + nbr = VppNeighbor(self, + self.pg1.sw_if_index, + self.pg1.remote_mac, + self.pg1.remote_ip4).add_vpp_config() + + # this is now the interface MTU frags + self.send_and_expect(self.pg0, [p_2k], self.pg1, n_rx=2) + self.send_and_expect(self.pg0, [p_1k], self.pg1) + + # drop the path MTU for this neighbour to below the interface MTU + # expect more frags + pmtu = VppIpPathMtu(self, self.pg1.remote_ip4, 900).add_vpp_config() + + self.send_and_expect(self.pg0, [p_2k], self.pg1, n_rx=3) + self.send_and_expect(self.pg0, [p_1k], self.pg1, n_rx=2) + + # print/format the adj delegate + self.logger.info(self.vapi.cli("sh adj 5")) + + # increase the path MTU to more than the interface + # expect to use the interface MTU + pmtu.modify(8192) + + self.send_and_expect(self.pg0, [p_2k], self.pg1, n_rx=2) + self.send_and_expect(self.pg0, [p_1k], self.pg1) + + # go back to an MTU from the path + # wrap the call around mark-n-sweep to enusre updates clear stale + self.vapi.ip_path_mtu_replace_begin() + pmtu.modify(900) + self.vapi.ip_path_mtu_replace_end() + + self.send_and_expect(self.pg0, [p_2k], self.pg1, n_rx=3) + self.send_and_expect(self.pg0, [p_1k], self.pg1, n_rx=2) + + # raise the interface's MTU + # should still use that of the path + self.vapi.sw_interface_set_mtu(self.pg1.sw_if_index, + [2000, 0, 0, 0]) + self.send_and_expect(self.pg0, [p_2k], self.pg1, n_rx=3) + self.send_and_expect(self.pg0, [p_1k], self.pg1, n_rx=2) + + # set path high and interface low + pmtu.modify(2000) + self.vapi.sw_interface_set_mtu(self.pg1.sw_if_index, + [900, 0, 0, 0]) + self.send_and_expect(self.pg0, [p_2k], self.pg1, n_rx=3) + self.send_and_expect(self.pg0, [p_1k], self.pg1, n_rx=2) + + # remove the path MTU using the mark-n-sweep semantics + self.vapi.sw_interface_set_mtu(self.pg1.sw_if_index, + [1800, 0, 0, 0]) + self.vapi.ip_path_mtu_replace_begin() + self.vapi.ip_path_mtu_replace_end() + + self.send_and_expect(self.pg0, [p_2k], self.pg1, n_rx=2) + self.send_and_expect(self.pg0, [p_1k], self.pg1) + + # + # set path MTU for a neighbour that doesn't exist, yet + # + pmtu2 = VppIpPathMtu(self, + self.pg1.remote_hosts[2].ip4, + 900).add_vpp_config() + + p_2k = (Ether(dst=self.pg0.local_mac, + src=self.pg0.remote_mac) / + IP(src=self.pg0.remote_ip4, + dst=self.pg1.remote_hosts[2].ip4) / + UDP(sport=1234, dport=5678) / + Raw(b'0xa' * 640)) + p_1k = (Ether(dst=self.pg0.local_mac, + src=self.pg0.remote_mac) / + IP(src=self.pg0.remote_ip4, + dst=self.pg1.remote_hosts[2].ip4) / + UDP(sport=1234, dport=5678) / + Raw(b'0xa' * 320)) + + nbr2 = VppNeighbor(self, + self.pg1.sw_if_index, + self.pg1.remote_hosts[2].mac, + self.pg1.remote_hosts[2].ip4).add_vpp_config() + + # should frag to the path MTU + self.send_and_expect(self.pg0, [p_2k], self.pg1, n_rx=3) + self.send_and_expect(self.pg0, [p_1k], self.pg1, n_rx=2) + + # remove and re-add the neighbour + nbr2.remove_vpp_config() + nbr2.add_vpp_config() + + # should frag to the path MTU + self.send_and_expect(self.pg0, [p_2k], self.pg1, n_rx=3) + self.send_and_expect(self.pg0, [p_1k], self.pg1, n_rx=2) + + # + # set PMTUs for many peers + # + N_HOSTS = 16 + self.pg1.generate_remote_hosts(16) + self.pg1.configure_ipv4_neighbors() + + for h in range(N_HOSTS): + pmtu = VppIpPathMtu(self, self.pg1.remote_hosts[h].ip4, 900) + pmtu.add_vpp_config() + self.assertTrue(pmtu.query_vpp_config()) + + self.logger.info(self.vapi.cli("sh ip pmtu")) + dump = list(self.vapi.vpp.details_iter(self.vapi.ip_path_mtu_get)) + self.assertEqual(N_HOSTS, len(dump)) + + for h in range(N_HOSTS): + p_2k[IP].dst = self.pg1.remote_hosts[h].ip4 + p_1k[IP].dst = self.pg1.remote_hosts[h].ip4 + + # should frag to the path MTU + self.send_and_expect(self.pg0, [p_2k], self.pg1, n_rx=3) + self.send_and_expect(self.pg0, [p_1k], self.pg1, n_rx=2) + + if __name__ == '__main__': unittest.main(testRunner=VppTestRunner)