/* * Copyright (c) 2017-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. */ #include #define TCP_TEST_I(_cond, _comment, _args...) \ ({ \ int _evald = (_cond); \ if (!(_evald)) { \ fformat(stderr, "FAIL:%d: " _comment "\n", \ __LINE__, ##_args); \ } else { \ fformat(stderr, "PASS:%d: " _comment "\n", \ __LINE__, ##_args); \ } \ _evald; \ }) #define TCP_TEST(_cond, _comment, _args...) \ { \ if (!TCP_TEST_I(_cond, _comment, ##_args)) { \ return 1; \ } \ } /* *INDENT-OFF* */ scoreboard_trace_elt_t sb_trace[] = {}; /* *INDENT-ON* */ static int tcp_test_scoreboard_replay (vlib_main_t * vm, unformat_input_t * input) { int verbose = 0; tcp_connection_t _tc, *tc = &_tc; u8 *s = 0; while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) { if (unformat (input, "detail")) verbose = 1; else { clib_error_t *e = clib_error_return (0, "unknown input `%U'", format_unformat_error, input); clib_error_report (e); return -1; } } #if TCP_SCOREBOARD_TRACE tc->sack_sb.trace = sb_trace; #endif s = tcp_scoreboard_replay (s, tc, verbose); vlib_cli_output (vm, "%v", s); return 0; } static int tcp_test_sack_rx (vlib_main_t * vm, unformat_input_t * input) { tcp_connection_t _tc, *tc = &_tc; sack_scoreboard_t *sb = &tc->sack_sb; sack_block_t *sacks = 0, block; sack_scoreboard_hole_t *hole; int i, verbose = 0; while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) { if (unformat (input, "verbose")) verbose = 1; else if (unformat (input, "replay")) return tcp_test_scoreboard_replay (vm, input); } clib_memset (tc, 0, sizeof (*tc)); tc->snd_una = 0; tc->snd_una_max = 1000; tc->snd_nxt = 1000; tc->rcv_opts.flags |= TCP_OPTS_FLAG_SACK; tc->snd_mss = 150; scoreboard_init (&tc->sack_sb); for (i = 0; i < 1000 / 100; i++) { block.start = i * 100; block.end = (i + 1) * 100; vec_add1 (sacks, block); } /* * Inject even blocks */ for (i = 0; i < 1000 / 200; i++) { vec_add1 (tc->rcv_opts.sacks, sacks[i * 2]); } tc->rcv_opts.n_sack_blocks = vec_len (tc->rcv_opts.sacks); tcp_rcv_sacks (tc, 0); if (verbose) vlib_cli_output (vm, "sb after even blocks (mss %u):\n%U", tc->snd_mss, format_tcp_scoreboard, sb, tc); TCP_TEST ((pool_elts (sb->holes) == 5), "scoreboard has %d elements", pool_elts (sb->holes)); /* First SACK block should be rejected */ hole = scoreboard_first_hole (sb); TCP_TEST ((hole->start == 0 && hole->end == 200), "first hole start %u end %u", hole->start, hole->end); hole = scoreboard_last_hole (sb); TCP_TEST ((hole->start == 900 && hole->end == 1000), "last hole start %u end %u", hole->start, hole->end); TCP_TEST ((sb->sacked_bytes == 400), "sacked bytes %d", sb->sacked_bytes); TCP_TEST ((sb->snd_una_adv == 0), "snd_una_adv %u", sb->snd_una_adv); TCP_TEST ((sb->last_sacked_bytes == 400), "last sacked bytes %d", sb->last_sacked_bytes); TCP_TEST ((sb->high_sacked == 900), "high sacked %u", sb->high_sacked); TCP_TEST ((sb->lost_bytes == 300), "lost bytes %u", sb->lost_bytes); /* * Inject odd blocks */ vec_reset_length (tc->rcv_opts.sacks); for (i = 0; i < 1000 / 200; i++) { vec_add1 (tc->rcv_opts.sacks, sacks[i * 2 + 1]); } tc->rcv_opts.n_sack_blocks = vec_len (tc->rcv_opts.sacks); tcp_rcv_sacks (tc, 0); if (verbose) vlib_cli_output (vm, "\nsb after odd blocks:\n%U", format_tcp_scoreboard, sb, tc); hole = scoreboard_first_hole (sb); TCP_TEST ((pool_elts (sb->holes) == 1), "scoreboard has %d holes", pool_elts (sb->holes)); TCP_TEST ((hole->start == 0 && hole->end == 100), "first hole start %u end %u", hole->start, hole->end); TCP_TEST ((sb->sacked_bytes == 900), "sacked bytes %d", sb->sacked_bytes); TCP_TEST ((sb->snd_una_adv == 0), "snd_una_adv %u", sb->snd_una_adv); TCP_TEST ((sb->high_sacked == 1000), "high sacked %u", sb->high_sacked); TCP_TEST ((sb->last_sacked_bytes == 500), "last sacked bytes %d", sb->last_sacked_bytes); TCP_TEST ((sb->lost_bytes == 100), "lost bytes %u", sb->lost_bytes); /* * Ack until byte 100, all bytes are now acked + sacked */ tcp_rcv_sacks (tc, 100); if (verbose) vlib_cli_output (vm, "\nack until byte 100:\n%U", format_tcp_scoreboard, sb, tc); TCP_TEST ((pool_elts (sb->holes) == 0), "scoreboard has %d elements", pool_elts (sb->holes)); TCP_TEST ((sb->snd_una_adv == 900), "snd_una_adv after ack %u", sb->snd_una_adv); TCP_TEST ((sb->high_sacked == 1000), "max sacked byte %u", sb->high_sacked); TCP_TEST ((sb->sacked_bytes == 0), "sacked bytes %d", sb->sacked_bytes); TCP_TEST ((sb->last_sacked_bytes == 0), "last sacked bytes %d", sb->last_sacked_bytes); TCP_TEST ((sb->lost_bytes == 0), "lost bytes %u", sb->lost_bytes); /* * Add new block */ vec_reset_length (tc->rcv_opts.sacks); block.start = 1200; block.end = 1300; vec_add1 (tc->rcv_opts.sacks, block); tc->snd_una_max = 1500; tc->snd_una = 1000; tc->snd_nxt = 1500; tcp_rcv_sacks (tc, 1000); if (verbose) vlib_cli_output (vm, "\nadd [1200, 1300] snd_una_max 1500, snd_una 1000:" " \n%U", format_tcp_scoreboard, sb, tc); TCP_TEST ((sb->snd_una_adv == 0), "snd_una_adv after ack %u", sb->snd_una_adv); TCP_TEST ((pool_elts (sb->holes) == 2), "scoreboard has %d holes", pool_elts (sb->holes)); hole = scoreboard_first_hole (sb); TCP_TEST ((hole->start == 1000 && hole->end == 1200), "first hole start %u end %u", hole->start, hole->end); TCP_TEST ((sb->snd_una_adv == 0), "snd_una_adv after ack %u", sb->snd_una_adv); TCP_TEST ((sb->high_sacked == 1300), "max sacked byte %u", sb->high_sacked); hole = scoreboard_last_hole (sb); TCP_TEST ((hole->start == 1300 && hole->end == 1500), "last hole start %u end %u", hole->start, hole->end); TCP_TEST ((sb->sacked_bytes == 100), "sacked bytes %d", sb->sacked_bytes); TCP_TEST ((sb->lost_bytes == 0), "lost bytes %u", sb->lost_bytes); /* * Ack first hole */ vec_reset_length (tc->rcv_opts.sacks); tcp_rcv_sacks (tc, 1200); if (verbose) vlib_cli_output (vm, "\nsb ack up to byte 1200:\n%U", format_tcp_scoreboard, sb, tc); TCP_TEST ((sb->snd_una_adv == 100), "snd_una_adv after ack %u", sb->snd_una_adv); TCP_TEST ((sb->sacked_bytes == 0), "sacked bytes %d", sb->sacked_bytes); TCP_TEST ((pool_elts (sb->holes) == 0), "scoreboard has %d elements", pool_elts (sb->holes)); TCP_TEST ((sb->last_bytes_delivered == 100), "last bytes delivered %d", sb->last_bytes_delivered); TCP_TEST ((sb->lost_bytes == 0), "lost bytes %u", sb->lost_bytes); TCP_TEST ((sb->head == TCP_INVALID_SACK_HOLE_INDEX), "head %u", sb->head); TCP_TEST ((sb->tail == TCP_INVALID_SACK_HOLE_INDEX), "tail %u", sb->tail); /* * Add some more blocks and then remove all */ vec_reset_length (tc->rcv_opts.sacks); tc->snd_una += sb->snd_una_adv; tc->snd_nxt = tc->snd_una_max = 1900; for (i = 0; i < 5; i++) { block.start = i * 100 + 1200; block.end = (i + 1) * 100 + 1200; vec_add1 (tc->rcv_opts.sacks, block); } tcp_rcv_sacks (tc, 1900); scoreboard_clear (sb); if (verbose) vlib_cli_output (vm, "\nsb cleared all:\n%U", format_tcp_scoreboard, sb, tc); TCP_TEST ((pool_elts (sb->holes) == 0), "number of holes %d", pool_elts (sb->holes)); TCP_TEST ((sb->head == TCP_INVALID_SACK_HOLE_INDEX), "head %u", sb->head); TCP_TEST ((sb->tail == TCP_INVALID_SACK_HOLE_INDEX), "tail %u", sb->tail); /* * Re-inject odd blocks and ack them all */ tc->snd_una = 0; tc->snd_una_max = 1000; tc->snd_nxt = 1000; for (i = 0; i < 5; i++) { vec_add1 (tc->rcv_opts.sacks, sacks[i * 2 + 1]); } tc->rcv_opts.n_sack_blocks = vec_len (tc->rcv_opts.sacks); tcp_rcv_sacks (tc, 0); if (verbose) vlib_cli_output (vm, "\nsb added odd blocks snd_una 0 snd_una_max 1500:" "\n%U", format_tcp_scoreboard, sb, tc); TCP_TEST ((pool_elts (sb->holes) == 5), "scoreboard has %d elements", pool_elts (sb->holes)); TCP_TEST ((sb->lost_bytes == 300), "lost bytes %u", sb->lost_bytes); tcp_rcv_sacks (tc, 950); if (verbose) vlib_cli_output (vm, "\nack [0, 950]:\n%U", format_tcp_scoreboard, sb, tc); TCP_TEST ((pool_elts (sb->holes) == 0), "scoreboard has %d elements", pool_elts (sb->holes)); TCP_TEST ((sb->snd_una_adv == 50), "snd_una_adv %u", sb->snd_una_adv); TCP_TEST ((sb->sacked_bytes == 0), "sacked bytes %d", sb->sacked_bytes); TCP_TEST ((sb->last_sacked_bytes == 0), "last sacked bytes %d", sb->last_sacked_bytes); TCP_TEST ((sb->lost_bytes == 0), "lost bytes %u", sb->lost_bytes); /* * Inject one block, ack it and overlap hole */ tc->snd_una = 0; tc->snd_una_max = 1000; tc->snd_nxt = 1000; block.start = 100; block.end = 500; vec_add1 (tc->rcv_opts.sacks, block); tc->rcv_opts.n_sack_blocks = vec_len (tc->rcv_opts.sacks); tcp_rcv_sacks (tc, 0); if (verbose) vlib_cli_output (vm, "\nsb added [100, 500] snd_una 0 snd_una_max 1000:" "\n%U", format_tcp_scoreboard, sb, tc); tcp_rcv_sacks (tc, 800); if (verbose) vlib_cli_output (vm, "\nsb ack [0, 800]:\n%U", format_tcp_scoreboard, sb, tc); TCP_TEST ((pool_elts (sb->holes) == 0), "scoreboard has %d elemen
/*
 * Copyright (c) 2016 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.
 */

#include <vnet/fib/fib_entry.h>
#include <vnet/fib/fib_entry_src.h>
#include <vnet/fib/fib_path_list.h>
#include <vnet/fib/fib_path_ext.h>

/**
 * Source initialisation Function 
 */
static void
fib_entry_src_api_init (fib_entry_src_t *src)
{
}

/**
 * Source deinitialisation Function 
 */
static void
fib_entry_src_api_deinit (fib_entry_src_t *src)
{
}

static void
fib_entry_src_api_path_swap (fib_entry_src_t *src,
                             const fib_entry_t *entry,
			     fib_path_list_flags_t pl_flags,
			     const fib_route_path_t *rpaths)
{
    const fib_route_path_t *rpath;

    fib_path_ext_list_flush(&src->fes_path_exts);

    src->fes_pl = fib_path_list_create((FIB_PATH_LIST_FLAG_SHARED | pl_flags),
				       rpaths);

    vec_foreach(rpath, rpaths)
    {
        if (NULL != rpath->frp_label_stack)
        {
            fib_path_ext_list_push_back(&src->fes_path_exts,
                                        src->fes_pl,
                                        FIB_PATH_EXT_MPLS,
                                        rpath);
        }
    }
}

static void
fib_entry_src_api_path_add (fib_entry_src_t *src,
			    const fib_entry_t *entry,
			    fib_path_list_flags_t pl_flags,
			    const fib_route_path_t *rpaths)
{
    const fib_route_path_t *rpath;

    if (FIB_NODE_INDEX_INVALID == src->fes_pl)
    {	
	src->fes_pl =
	    fib_path_list_create((FIB_PATH_LIST_FLAG_SHARED | pl_flags), rpaths);
    }
    else
    {
	src->fes_pl =
	    fib_path_list_copy_and_path_add(src->fes_pl,
					    (FIB_PATH_LIST_FLAG_SHARED | pl_flags),
					    rpaths);
    }

    /*
     * re-resolve all the path-extensions with the new path-list
     */
    fib_path_ext_list_resolve(&src->fes_path_exts, src->fes_pl);

    /*
     * if the path has a label we need to add a path extension
     */
    vec_foreach(rpath, rpaths)
    {
        if (NULL != rpath->frp_label_stack)
        {
            fib_path_ext_list_insert(&src->fes_path_exts,
                                     src->fes_pl,
                                     FIB_PATH_EXT_MPLS,
                                     rpath);
        }
    }
}

static void
fib_entry_src_api_path_remove (fib_entry_src_t *src,
			       fib_path_list_flags_t pl_flags,
			       const fib_route_path_t *rpaths)
{
    const fib_route_path_t *rpath;

    if (FIB_NODE_INDEX_INVALID != src->fes_pl)
    {
	src->fes_pl =
	    fib_path_list_copy_and_path_remove(src->fes_pl,
					       (FIB_PATH_LIST_FLAG_SHARED | pl_flags),
					       rpaths);
        /*
         * remove the path-extension for the path
         */
        vec_foreach(rpath, rpaths)
        {
            fib_path_ext_list_remove(&src->fes_path_exts, FIB_PATH_EXT_MPLS, rpath);
        };
        /*
         * resolve the remaining extensions
         */
        fib_path_ext_list_resolve(&src->fes_path_exts, src->fes_pl);
    }
}

static void
fib_entry_src_api_add (fib_entry_src_t *src,
		       const fib_entry_t *entry,
		       fib_entry_flag_t flags,
		       dpo_proto_t proto,
		       const dpo_id_t *dpo)
{
    if (FIB_ENTRY_FLAG_NONE != flags)
    {
	src->fes_pl = fib_path_list_create_special(
	                  proto,
			  fib_entry_src_flags_2_path_list_flags(flags),
			  dpo);
    }
}

static void
fib_entry_src_api_remove (fib_entry_src_t *src)
{
    src->fes_pl = FIB_NODE_INDEX_INVALID;
}

const static fib_entry_src_vft_t api_src_vft = {
    .fesv_init = fib_entry_src_api_init,
    .fesv_deinit = fib_entry_src_api_deinit,
    .fesv_add = fib_entry_src_api_add,
    .fesv_remove = fib_entry_src_api_remove,
    .fesv_path_add = fib_entry_src_api_path_add,
    .fesv_path_swap = fib_entry_src_api_path_swap,
    .fesv_path_remove = fib_entry_src_api_path_remove,
};

void
fib_entry_src_api_register (void)
{
    fib_entry_src_register(FIB_SOURCE_PLUGIN_HI, &api_src_vft);
    fib_entry_src_register(FIB_SOURCE_API, &api_src_vft);
    fib_entry_src_register(FIB_SOURCE_CLI, &api_src_vft);
    fib_entry_src_register(FIB_SOURCE_DHCP, &api_src_vft);
    fib_entry_src_register(FIB_SOURCE_IP6_ND_PROXY, &api_src_vft);
    fib_entry_src_register(FIB_SOURCE_SR, &api_src_vft);
}
track_rxt (tc, snd_una + 2 * burst + 20, snd_una + 4 * burst); TCP_TEST (tcp_bt_is_sane (bt), "tracker should be sane"); TCP_TEST (pool_elts (bt->samples) == 5, "there should be 5 samples"); vec_validate (min_seqs, 4); min_seqs[0] = snd_una + 10; min_seqs[1] = snd_una + burst; min_seqs[2] = snd_una + burst + 10; min_seqs[3] = snd_una + 2 * burst + 10; min_seqs[4] = snd_una + 2 * burst + 20; root = bt->sample_lookup.nodes + bt->sample_lookup.root; bts = bt->samples + bt->head; for (i = 0; i < vec_len (min_seqs); i++) { if (bts->min_seq != min_seqs[i]) TCP_TEST (0, "should be %u is %u", min_seqs[i], bts->min_seq); rbn = rb_tree_search_subtree_custom (&bt->sample_lookup, root, bts->min_seq, tbt_seq_lt); if (rbn->opaque != bts - bt->samples) TCP_TEST (0, "lookup should work"); bts = bt->samples + bts->next; } /* 7) check delivery rate at time 10 * * tc->snd_una = snd_una + 2 * burst * sacks: * [snd_una + 2 * burst + 20, snd_una + 2 * burst + 30] * [snd_una + 2 * burst + 50, snd_una + 2 * burst + 60] */ session_main.wrk[thread_index].last_vlib_time = 10; tc->snd_una = snd_una + 2 * burst; tc->bytes_acked = 2 * burst - 10; sb->last_sacked_bytes = 20; sacks[0].start = snd_una + 2 * burst + 20; sacks[0].end = snd_una + 2 * burst + 30; sacks[1].start = snd_una + 2 * burst + 50; sacks[1].end = snd_una + 2 * burst + 60; tcp_bt_sample_delivery_rate (tc, rs); TCP_TEST (tcp_bt_is_sane (bt), "tracker should be sane"); TCP_TEST (pool_elts (bt->samples) == 3, "num samples should be 3 is %u", pool_elts (bt->samples)); TCP_TEST (tc->delivered_time == 10, "delivered time should be 10"); TCP_TEST (tc->delivered == 5 * burst + 40, "delivered should be %u is %u", 5 * burst + 40, tc->delivered); /* A rxt was acked and delivered time for it is 8 (last ack time) */ TCP_TEST (rs->interval_time == 2, "ack time should be 2 is %.2f", rs->interval_time); /* delivered_now - delivered_rxt ~ 5 * burst + 40 - 3 * burst - 30 */ TCP_TEST (rs->delivered == 2 * burst + 10, "delivered should be 210 is %u", rs->delivered); TCP_TEST (rs->prior_delivered == 3 * burst + 30, "sample delivered should be %u", 3 * burst + 30); TCP_TEST (approx_equal (rate, rs->tx_rate), "rate should be %u is %u", rate, rs->tx_rate); TCP_TEST (rs->flags & TCP_BTS_IS_RXT, "is retransmitted"); /* Sample is app limited because of the retransmits */ TCP_TEST (rs->flags & TCP_BTS_IS_APP_LIMITED, "is app limited"); TCP_TEST (tc->app_limited, "app limited should be set"); /* * 8) check delivery rate at time 11 */ session_main.wrk[thread_index].last_vlib_time = 11; tc->snd_una = tc->snd_nxt; tc->bytes_acked = 2 * burst; sb->last_sacked_bytes = 0; sb->last_bytes_delivered = 40; memset (rs, 0, sizeof (*rs)); tcp_bt_sample_delivery_rate (tc, rs); TCP_TEST (tcp_bt_is_sane (bt), "tracker should be sane"); TCP_TEST (pool_elts (bt->samples) == 0, "num samples should be 0 is %u", pool_elts (bt->samples)); TCP_TEST (tc->delivered_time == 11, "delivered time should be 11"); TCP_TEST (tc->delivered == 7 * burst, "delivered should be %u is %u", 7 * burst, tc->delivered); /* Last rxt was at time 8 */ TCP_TEST (rs->interval_time == 3, "ack time should be 3 is %.2f", rs->interval_time); /* delivered_now - delivered_rxt ~ 7 * burst - 3 * burst - 30. * That's because we didn't retransmit any new segment. */ TCP_TEST (rs->delivered == 4 * burst - 30, "delivered should be 160 is %u", rs->delivered); TCP_TEST (rs->prior_delivered == 3 * burst + 30, "sample delivered should be %u", 3 * burst + 30); TCP_TEST (approx_equal (rate, rs->tx_rate), "rate should be %u is %u", rate, rs->tx_rate); TCP_TEST (rs->flags & TCP_BTS_IS_RXT, "is retransmitted"); TCP_TEST (rs->flags & TCP_BTS_IS_APP_LIMITED, "is app limited"); TCP_TEST (tc->app_limited == 0, "app limited should be cleared"); /* * 9) test flush */ tcp_bt_track_tx (tc); tc->snd_nxt += burst; session_main.wrk[thread_index].last_vlib_time = 12; tcp_bt_track_tx (tc); tc->snd_nxt += burst; tcp_bt_flush_samples (tc); /* * Cleanup */ vec_free (sacks); vec_free (min_seqs); tcp_bt_cleanup (tc); return 0; } static clib_error_t * tcp_test (vlib_main_t * vm, unformat_input_t * input, vlib_cli_command_t * cmd_arg) { int res = 0; while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) { if (unformat (input, "sack")) { res = tcp_test_sack (vm, input); } else if (unformat (input, "session")) { res = tcp_test_session (vm, input); } else if (unformat (input, "lookup")) { res = tcp_test_lookup (vm, input); } else if (unformat (input, "delivery")) { res = tcp_test_delivery (vm, input); } else if (unformat (input, "all")) { if ((res = tcp_test_sack (vm, input))) goto done; if ((res = tcp_test_lookup (vm, input))) goto done; if ((res = tcp_test_delivery (vm, input))) goto done; } else break; } done: if (res) return clib_error_return (0, "TCP unit test failed"); return 0; } /* *INDENT-OFF* */ VLIB_CLI_COMMAND (tcp_test_command, static) = { .path = "test tcp", .short_help = "internal tcp unit tests", .function = tcp_test, }; /* *INDENT-ON* */ /* * fd.io coding-style-patch-verification: ON * * Local Variables: * eval: (c-set-style "gnu") * End: */