aboutsummaryrefslogtreecommitdiffstats
path: root/tests/func/iacl_base/eth2p-ethip6-ip6base-iaclbase-func.robot
AgeCommit message (Expand)AuthorFilesLines
2017-01-25Remove _base from test suite dir namesJan Gelety1-577/+0
2017-01-24csit-func-tc-naming-change - phase 1Jan Gelety1-0/+577
7 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 
/*
 * 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/bier/bier_bift_table.h>
#include <vnet/dpo/drop_dpo.h>
#include <vnet/udp/udp.h>

typedef enum {
#define bier_error(n,s) BIER_INPUT_ERROR_##n,
#include <vnet/bier/bier_input_error.def>
#undef bier_error
    BIER_INPUT_N_ERROR,
} bier_input_error_t;

static char * bier_error_strings[] = {
#define bier_error(n,s) s,
#include <vnet/bier/bier_input_error.def>
#undef bier_error
};

/**
 * Global BIFT table
 */
bier_bfit_table_t *bier_bift_table;

/**
 * Forward declare the node
 */
vlib_node_registration_t bier_bift_input_node;

void
bier_bift_table_entry_add (bier_bift_id_t id,
                           const dpo_id_t *dpo)
{
    if (NULL == bier_bift_table)
    {
        u32 ii;

        /*
         * allocate the table and
         * set each of the entries therein to a BIER drop
         */
        bier_bift_table = clib_mem_alloc_aligned(sizeof(*bier_bift_table),
                                                 CLIB_CACHE_LINE_BYTES);
        clib_memset(bier_bift_table, 0, sizeof(*bier_bift_table));

        for (ii = 0; ii < BIER_BIFT_N_ENTRIES; ii++)
        {
            dpo_stack_from_node(bier_bift_input_node.index,
                                &bier_bift_table->bblt_dpos[ii],
                                drop_dpo_get(DPO_PROTO_BIER));
        }

        /*
         * register to handle packets that arrive on the assigned
         * UDP port
         */
        udp_register_dst_port(vlib_get_main(),
                              UDP_DST_PORT_BIER,
                              bier_bift_input_node.index,
                              0);
        udp_register_dst_port(vlib_get_main(),
                              UDP_DST_PORT_BIER,
                              bier_bift_input_node.index,
                              1);
    }

    dpo_stack_from_node(bier_bift_input_node.index,
                        &bier_bift_table->bblt_dpos[id],
                        dpo);

    bier_bift_table->bblt_n_entries++;
}

void
bier_bift_table_entry_remove (bier_bift_id_t id)
{
    ASSERT(NULL != bier_bift_table);

    dpo_reset(&bier_bift_table->bblt_dpos[id]);

    bier_bift_table->bblt_n_entries--;

    if (0 == bier_bift_table->bblt_n_entries)
    {
        udp_unregister_dst_port(vlib_get_main(),
                                UDP_DST_PORT_BIER,
                                0);
        udp_unregister_dst_port(vlib_get_main(),
                                UDP_DST_PORT_BIER,
                                1);

        clib_mem_free(bier_bift_table);
        bier_bift_table = NULL;
    }
}

/**
 * @brief Packet trace record for BIER input
 */
typedef struct bier_bift_input_trace_t_
{
    u32 bift_id;
} bier_bift_input_trace_t;

static uword
bier_bift_input (vlib_main_t * vm,
                 vlib_node_runtime_t * node,
                 vlib_frame_t * from_frame)
{
    u32 n_left_from, next_index, * from, * to_next;

    from = vlib_frame_vector_args (from_frame);
    n_left_from = from_frame->n_vectors;
    next_index = node->cached_next_index;

    while (n_left_from > 0)
    {
        u32 n_left_to_next;

        vlib_get_next_frame (vm, node, next_index,
                             to_next, n_left_to_next);

        while (n_left_from > 0 && n_left_to_next > 0)
        {
            bier_bift_id_t *biftp0, bift0;
            const dpo_id_t *dpo0;
            vlib_buffer_t * b0;
            u32 bi0, next0;

            bi0 = from[0];
            to_next[0] = bi0;
            from += 1;
            to_next += 1;
            n_left_from -= 1;
            n_left_to_next -= 1;

            b0 = vlib_get_buffer (vm, bi0);
            biftp0 = vlib_buffer_get_current (b0);
            vlib_buffer_advance(b0, sizeof(bift0));
            bift0 = clib_net_to_host_u32(*biftp0);

            /*
             * Do the lookup based on the first 20 bits, i.e. the
             * encoding of the set, sub-domain and BSL
             */
            dpo0 = bier_bift_dp_lookup(bift0);

            /*
             * save the TTL for later during egress
             */
            vnet_buffer(b0)->mpls.ttl = vnet_mpls_uc_get_ttl(bift0);

            next0 = dpo0->dpoi_next_node;
            vnet_buffer(b0)->ip.adj_index[VLIB_TX] = dpo0->dpoi_index;

            if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_IS_TRACED))
            {
                bier_bift_input_trace_t *tr;

                tr = vlib_add_trace(vm, node, b0, sizeof (*tr));
                tr->bift_id = bift0;
            }

            vlib_validate_buffer_enqueue_x1(vm, node, next_index,
                                            to_next, n_left_to_next,
                                            bi0, next0);
        }

        vlib_put_next_frame(vm, node, next_index, n_left_to_next);
    }

    vlib_node_increment_counter(vm, bier_bift_input_node.index,
                                BIER_INPUT_ERROR_PKTS_VALID,
                                from_frame->n_vectors);
    return (from_frame->n_vectors);
}

static u8 *
format_bier_bift_input_trace (u8 * s, va_list * args)
{
    CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
    CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
    bier_bift_input_trace_t * t = va_arg (*args, bier_bift_input_trace_t *);

    s = format (s, "BIFT-ID:[%U]", format_bier_bift_id,
                vnet_mpls_uc_get_label(t->bift_id));
    return s;
}

VLIB_REGISTER_NODE (bier_bift_input_node) = {
    .function = bier_bift_input,
    .name = "bier-bift-input",
    /* Takes a vector of packets. */
    .vector_size = sizeof (u32),
    .n_errors = BIER_INPUT_N_ERROR,
    .error_strings = bier_error_strings,
    .n_next_nodes = 0,
    .format_trace = format_bier_bift_input_trace,
};

clib_error_t *
show_bier_bift_cmd (vlib_main_t * vm,
                    unformat_input_t * input,
                    vlib_cli_command_t * cmd)
{
    clib_error_t * error = NULL;
    u32 hdr_len, set, sub_domain;

    set = hdr_len = sub_domain = ~0;

    while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) {
        if (unformat (input, "sd %d", &sub_domain)) {
            ;
        } else if (unformat (input, "set %d", &set)) {
            ;
        } else if (unformat (input, "bsl %d", &hdr_len)) {
            ;
        }
        else
        {
            error = unformat_parse_error (input);
            goto done;
        }
    }

    if (NULL == bier_bift_table)
    {
        vlib_cli_output(vm, "no BIFT entries");
        goto done;
    }

    if (~0 == set)
    {
        u32 ii;

        for (ii = 0; ii < BIER_BIFT_N_ENTRIES; ii++)
        {
            if (!dpo_is_drop(&bier_bift_table->bblt_dpos[ii]))
            {
                bier_hdr_len_id_t bsl;

                bier_bift_id_decode(ii, &set, &sub_domain, &bsl);

                vlib_cli_output(vm, "set: %d, sub-domain:%d, BSL:%U",
                                set, sub_domain,
                                format_bier_hdr_len_id, bsl);
                vlib_cli_output(vm, "  %U",
                                format_dpo_id,
                                &bier_bift_table->bblt_dpos[ii], 0);
            }
        }
    }
    else
    {
        bier_bift_id_t id;

        id = bier_bift_id_encode(set, sub_domain,
                                 bier_hdr_bit_len_to_id(hdr_len));

        if (!dpo_is_drop(&bier_bift_table->bblt_dpos[id]))
        {
            vlib_cli_output(vm, "set: %d, sub-domain:%d, BSL:%U",
                            set, sub_domain,
                            format_bier_hdr_len_id, hdr_len);
            vlib_cli_output(vm, "  %U",
                            format_dpo_id,
                            &bier_bift_table->bblt_dpos[id], 0);
        }
    }
done:
    return (error);
}

VLIB_CLI_COMMAND (show_bier_bift_command, static) = {
    .path = "show bier bift",
    .short_help = "show bier bift [set <value> sd <value> bsl <value>]",
    .function = show_bier_bift_cmd,
};