/* * 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 #include #include #include #include #include #include #include #include #include /* * per-source type vft */ static fib_entry_src_vft_t fib_entry_src_vft[FIB_SOURCE_MAX]; /** * Get the VFT for a given source. This is a combination of the source * enum and the interposer flags */ const fib_entry_src_vft_t* fib_entry_src_get_vft (const fib_entry_src_t *esrc) { if (esrc->fes_entry_flags & FIB_ENTRY_FLAG_INTERPOSE) { return (&fib_entry_src_vft[FIB_SOURCE_INTERPOSE]); } return (&fib_entry_src_vft[esrc->fes_src]); } static void fib_entry_src_copy_default (const fib_entry_src_t *orig_src, const fib_entry_t *fib_entry, fib_entry_src_t *copy_src) { clib_memcpy(©_src->u, &orig_src->u, sizeof(copy_src->u)); } void fib_entry_src_register (fib_source_t source, const fib_entry_src_vft_t *vft) { fib_entry_src_vft[source] = *vft; if (NULL == fib_entry_src_vft[source].fesv_copy) { fib_entry_src_vft[source].fesv_copy = fib_entry_src_copy_default; } } static int fib_entry_src_cmp_for_sort (void * v1, void * v2) { fib_entry_src_t *esrc1 = v1, *esrc2 = v2; return (esrc1->fes_src - esrc2->fes_src); } static void fib_entry_src_action_init (fib_entry_t *fib_entry, fib_source_t source, fib_entry_flag_t flags) { fib_entry_src_t esrc = { .fes_pl = FIB_NODE_INDEX_INVALID, .fes_flags = FIB_ENTRY_SRC_FLAG_NONE, .fes_src = source, .fes_entry_flags = flags, }; FIB_ENTRY_SRC_VFT_INVOKE(&esrc, fesv_init, (&esrc)); vec_add1(fib_entry->fe_srcs, esrc); vec_sort_with_function(fib_entry->fe_srcs, fib_entry_src_cmp_for_sort); } static fib_entry_src_t * fib_entry_src_find_i (const fib_entry_t *fib_entry, fib_source_t source, u32 *index) { fib_entry_src_t *esrc; int ii; ii = 0; vec_foreach(esrc, fib_entry->fe_srcs) { if (esrc->fes_src == source) { if (NULL != index) { *index = ii; } return (esrc); } else { ii++; } } return (NULL); } static fib_entry_src_t * fib_entry_src_find (const fib_entry_t *fib_entry, fib_source_t source) { return (fib_entry_src_find_i(fib_entry, source, NULL)); } int fib_entry_is_sourced (fib_node_index_t fib_entry_index, fib_source_t source) { fib_entry_t *fib_entry; fib_entry = fib_entry_get(fib_entry_index); return (NULL != fib_entry_src_find(fib_entry, source)); } static fib_entry_src_t * fib_entry_src_find_or_create (fib_entry_t *fib_entry, fib_source_t source, fib_entry_flag_t flags) { fib_entry_src_t *esrc; esrc = fib_entry_src_find(fib_entry, source); if (NULL == esrc) { fib_entry_src_action_init(fib_entry, source, flags); } return (fib_entry_src_find(fib_entry, source)); } static void fib_entry_src_action_deinit (fib_entry_t *fib_entry, fib_source_t source) { fib_entry_src_t *esrc; u32 index = ~0; esrc = fib_entry_src_find_i(fib_entry, source, &index); ASSERT(NULL != esrc); FIB_ENTRY_SRC_VFT_INVOKE(esrc, fesv_deinit, (esrc)); fib_path_ext_list_flush(&esrc->fes_path_exts); vec_del1(fib_entry->fe_srcs, index); vec_sort_with_function(fib_entry->fe_srcs, fib_entry_src_cmp_for_sort); } fib_entry_src_cover_res_t fib_entry_src_action_cover_change (fib_entry_t *fib_entry, fib_entry_src_t *esrc) { FIB_ENTRY_SRC_VFT_INVOKE_AND_RETURN(esrc, fesv_cover_change, (esrc, fib_entry)); fib_entry_src_cover_res_t res = { .install = !0, .bw_reason = FIB_NODE_BW_REASON_FLAG_NONE, }; return (res); } fib_entry_src_cover_res_t fib_entry_src_action_cover_update (fib_entry_t *fib_entry, fib_entry_src_t *esrc) { FIB_ENTRY_SRC_VFT_INVOKE_AND_RETURN(esrc, fesv_cover_update, (esrc, fib_entry)); fib_entry_src_cover_res_t res = { .install = !0, .bw_reason = FIB_NODE_BW_REASON_FLAG_NONE, }; return (res); } typedef struct fib_entry_src_collect_forwarding_ctx_t_ { load_balance_path_t *next_hops; const fib_entry_t *fib_entry; const fib_entry_src_t *esrc; fib_forward_chain_type_t fct; int n_recursive_constrained; u16 preference; } fib_entry_src_collect_forwarding_ctx_t; /** * @brief Determine whether this FIB entry should use a load-balance MAP * to support PIC edge fast convergence */ load_balance_flags_t fib_entry_calc_lb_flags (fib_entry_src_collect_forwarding_ctx_t *ctx) { /** * We'll use a LB map if the path-list has multiple recursive paths. * recursive paths implies BGP, and hence scale. */ if (ctx->n_recursive_constrained > 1 && fib_path_list_is_popular(ctx->esrc->fes_pl)) { return (LOAD_BALANCE_FLAG_USES_MAP); } return (LOAD_BALANCE_FLAG_NONE); } static int fib_entry_src_valid_out_label (mpls_label_t label) { return ((MPLS_LABEL_IS_REAL(label) || MPLS_LABEL_POP == label || MPLS_IETF_IPV4_EXPLICIT_NULL_LABEL == label || MPLS_IETF_IPV6_EXPLICIT_NULL_LABEL == label || MPLS_IETF_IMPLICIT_NULL_LABEL == label)); } /** * @brief Turn the chain type requested by the client into the one they * really wanted */ fib_forward_chain_type_t fib_entry_chain_type_fixup (const fib_entry_t *entry, fib_forward_chain_type_t fct) { /* * The EOS chain is a tricky since one cannot know the adjacency * to link to without knowing what the packets payload protocol * will be once the label is popped. */ fib_forward_chain_type_t dfct; if (FIB_FORW_CHAIN_TYPE_MPLS_EOS != fct) { return (fct); } dfct = fib_entry_get_default_chain_type(entry); if (FIB_FORW_CHAIN_TYPE_MPLS_EOS == dfct) { /* * If the entry being asked is a eos-MPLS label entry, * then use the payload-protocol field, that we stashed there * for just this purpose */ return (fib_forw_chain_type_from_dpo_proto( entry->fe_prefix.fp_payload_proto)); } /* * else give them what this entry would be by default. i.e. if it's a v6 * entry, then the label its local labelled should be carrying v6 traffic. * If it's a non-EOS label entry, then there are more labels and we want * a non-eos chain. */ return (dfct); } static dpo_proto_t fib_prefix_get_payload_proto (const fib_prefix_t *pfx) { switch (pfx->fp_proto) { case FIB_PROTOCOL_IP4: return (DPO_PROTO_IP4); case FIB_PROTOCOL_IP6: return (DPO_PROTO_IP6); case FIB_PROTOCOL_MPLS: return (pfx->fp_payload_proto); } ASSERT(0); return (DPO_PROTO_IP4); } static void fib_entry_src_get_path_forwarding (fib_node_index_t path_index, fib_entry_src_collect_forwarding_ctx_t *ctx) { load_balance_path_t *nh; /* * no extension => no out-going label for this path. that's OK * in the case of an IP or EOS chain, but not for non-EOS */ switch (ctx->fct) { case FIB_FORW_CHAIN_TYPE_UNICAST_IP4: case FIB_FORW_CHAIN_TYPE_UNICAST_IP6: case FIB_FORW_CHAIN_TYPE_MCAST_IP4: case FIB_FORW_CHAIN_TYPE_MCAST_IP6: case FIB_FORW_CHAIN_TYPE_BIER: /* * EOS traffic with no label to stack, we need the IP Adj */ vec_add2(ctx->next_hops, nh, 1); nh->path_index = path_index; nh->path_weight = fib_path_get_weight(path_index); fib_path_contribute_forwarding(path_index, ctx->fct, &nh->path_dpo); break; case FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS: if (fib_path_is_exclusive(path_index) || fib_path_is_deag(path_index)) { vec_add2(ctx->next_hops, nh, 1); nh->path_index = path_index; nh->path_weight = fib_path_get_weight(path_index); fib_path_contribute_forwarding(path_index, FIB_FORW_CHAIN_TYPE_MPLS_NON_EOS, &nh->path_dpo); } break; case FIB_FORW_CHAIN_TYPE_MPLS_EOS: { /* * no label. we need a chain based on the payload. fixup. */ vec_add2(ctx->next_hops, nh, 1); nh->path_index = path_index; nh->path_weight = fib_path_get_weight(path_index); fib_path_contribute_forwarding(path_index, fib_entry_chain_type_fixup(ctx->fib_entry, ctx->fct), &nh->path_dpo); fib_path_stack_mpls_disp(path_index, fib_prefix_get_payload_proto(&ctx->fib_entry->fe_prefix), FIB_MPLS_LSP_MODE_PIPE, &nh->path_dpo); break; } case FIB_FORW_CHAIN_TYPE_ETHERNET: case FIB_FORW_CHAIN_TYPE_NSH: ASSERT(0); break; } } static fib_path_list_walk_rc_t fib_entry_src_collect_forwarding (fib_node_index_t pl_index, fib_node_index_t path_index, void *arg) { fib_entry_src_collect_forwarding_ctx_t *ctx; fib_path_ext_t *path_ext; u32 n_nhs; ctx = arg; n_nhs = vec_len(ctx->next_hops); /* * if the path is not resolved, don't include it. */ if (!fib_path_is_resolved(path_index)) { return (FIB_PATH_LIST_WALK_CONTINUE); } if (fib_path_is_recursive_constrained(path_index)) { ctx->n_recursive_constrained += 1; } if (0xffff == ctx->preference) { /* * not set a preference yet, so the first path we encounter * sets the preference we are collecting. */ ctx->preference = fib_path_get_preference(path_index); } else if (ctx->preference != fib_path_get_preference(path_index)) { /* * this path does not belong to the same preference as the * previous paths encountered. we are done now. */ return (FIB_PATH_LIST_WALK_STOP); } /* * get the matching path-extension for the path being visited. */ path_ext = fib_path_ext_list_find_by_path_index(&ctx->esrc->fes_path_exts, path_index); if (NULL != path_ext) { switch (path_ext->fpe_type) { case FIB_PATH_EXT_MPLS: if (fib_entry_src_valid_out_label(path_ext->fpe_label_stack[0].fml_value)) { /* * found a matching extension. stack it to obtain the forwarding * info for this path. */ ctx->next_hops = fib_path_ext_stack(path_ext, ctx->fct, fib_entry_chain_type_fixup(ctx->fib_entry, ctx->fct), ctx->next_hops); } else { fib_entry_src_get_path_forwarding(path_index, ctx); } break; case FIB_PATH_EXT_ADJ: if (FIB_PATH_EXT_ADJ_FLAG_REFINES_COVER & path_ext->fpe_adj_flags) { fib_entry_src_get_path_forwarding(path_index, ctx); } /* * else * the path does not refine the cover, meaning that * the adjacency does/does not match the sub-net on the link. * So this path does not contribute forwarding. */ break; } } else { fib_entry_src_get_path_forwarding(path_index, ctx); } /* * a this point 'ctx' has the DPO the path contributed, plus * any labels from path extensions. * check if there are any interpose sources that want to contribute */ if (n_nhs < vec_len(ctx->next_hops)) { /* * the path contributed a new choice. */ const fib_entry_src_vft_t *vft; vft = fib_entry_src_get_vft(ctx->esrc); if (NULL != vft->fesv_contribute_interpose) { const dpo_id_t *interposer; interposer = vft->fesv_contribute_interpose(ctx->esrc, ctx->fib_entry); if (NULL != interposer) { dpo_id_t clone = DPO_INVALID; dpo_mk_interpose(interposer, &ctx->nex
# Copyright (c) 2020 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.

"""Stream profile for T-rex traffic generator.

Stream profile:
 - Two streams sent in directions 0 --> 1 and 1 --> 0 at the same time.
 - Packet: ETH / IP /
 - Direction 0 --> 1:
   - Source IP address range:      10.0.0.1
   - Destination IP address range: 20.0.0.0 - 20.0.3.231
 - Direction 1 --> 0:
   - Source IP address range:      20.0.0.1
   - Destination IP address range: 10.0.0.0 - 10.0.3.231
"""

from trex.stl.api import *
from profile_trex_stateless_base_class import TrafficStreamsBaseClass


class TrafficStreams(TrafficStreamsBaseClass):
    """Stream profile."""

    def __init__(self):
        """Initialization and setting of streams' parameters."""

        super(TrafficStreamsBaseClass, self).__init__()

        # IPs used in packet headers.
        self.p1_src_start_ip = u"10.0.0.1"
        self.p1_dst_start_ip = u"20.0.0.0"
        self.p1_dst_end_ip = u"20.0.3.231"

        self.p2_src_start_ip = u"20.0.0.1"
        self.p2_dst_start_ip = u"10.0.0.0"
        self.p2_dst_end_ip = u"10.0.3.231"

    def define_packets(self):
        """Defines the packets to be sent from the traffic generator.

        Packet definition: | ETH | IP |

        :returns: Packets to be sent from the traffic generator.
        :rtype: tuple
        """

        # Direction 0 --> 1
        base_pkt_a = (
            Ether() /
            IP(
                src=self.p1_src_start_ip,
                dst=self.p1_dst_start_ip,
                proto=61
            )
        )
        # Direction 1 --> 0
        base_pkt_b = (
            Ether() /
            IP(
                src=self.p2_src_start_ip,
                dst=self.p2_dst_start_ip,
                proto=61
            )
        )

        # Direction 0 --> 1
        vm1 = STLScVmRaw(
            [
                STLVmFlowVar(
                    name=u"dst",
                    min_value=self.p1_dst_start_ip,
                    max_value=self.p1_dst_end_ip,
                    size=4,
                    op=u"inc"
                ),
                STLVmWrFlowVar(
                    fv_name=u"dst",
                    pkt_offset=u"IP.dst"
                ),
                STLVmFixIpv4(
                    offset=u"IP"
                )
            ]
        )
        # Direction 1 --> 0
        vm2 = STLScVmRaw(
            [
                STLVmFlowVar(
                    name=u"dst",
                    min_value=self.p2_dst_start_ip,
                    max_value=self.p2_dst_end_ip,
                    size=4,
                    op=u"inc"
                ),
                STLVmWrFlowVar(
                    fv_name=u"dst",
                    pkt_offset=u"IP.dst"
                ),
                STLVmFixIpv4(
                    offset=u"IP"
                )
            ]
        )

        return base_pkt_a, base_pkt_b, vm1, vm2


def register():
    """Register this traffic profile to T-rex.

    Do not change this function.

    :return: Traffic streams.
    :rtype: Object
    """
    return TrafficStreams()
esrc, fib_entry)); fib_entry_src_action_fwd_update(fib_entry, source); } /* * fib_entry_src_action_add * * Adding a source can result in a new fib_entry being created, which * can inturn mean the pool is realloc'd and thus the entry passed as * an argument it also realloc'd * @return the original entry */ fib_entry_t * fib_entry_src_action_add (fib_entry_t *fib_entry, fib_source_t source, fib_entry_flag_t flags, const dpo_id_t *dpo) { fib_node_index_t fib_entry_index; fib_entry_src_t *esrc; esrc = fib_entry_src_find_or_create(fib_entry, source, flags); ASSERT(esrc->fes_ref_count < 255); esrc->fes_ref_count++; if (flags != esrc->fes_entry_flags) { FIB_ENTRY_SRC_VFT_INVOKE(esrc, fesv_flags_change, (esrc, fib_entry, flags)); } esrc->fes_entry_flags = flags; if (1 != esrc->fes_ref_count) { /* * we only want to add the source on the 0->1 transition */ return (fib_entry); } /* * save variable so we can recover from a fib_entry realloc. */ fib_entry_index = fib_entry_get_index(fib_entry); FIB_ENTRY_SRC_VFT_INVOKE(esrc, fesv_add, (esrc, fib_entry, flags, fib_entry_get_dpo_proto(fib_entry), dpo)); fib_entry = fib_entry_get(fib_entry_index); esrc->fes_flags |= FIB_ENTRY_SRC_FLAG_ADDED; fib_path_list_lock(esrc->fes_pl); /* * the source owns a lock on the entry */ fib_entry_lock(fib_entry_get_index(fib_entry)); return (fib_entry); } /* * fib_entry_src_action_update * * Adding a source can result in a new fib_entry being created, which * can inturn mean the pool is realloc'd and thus the entry passed as * an argument it also realloc'd * @return the original entry */ fib_entry_t * fib_entry_src_action_update (fib_entry_t *fib_entry, fib_source_t source, fib_entry_flag_t flags, const dpo_id_t *dpo) { fib_node_index_t fib_entry_index, old_path_list_index; fib_entry_src_t *esrc; esrc = fib_entry_src_find_or_create(fib_entry, source, flags); if (NULL == esrc) { return (fib_entry_src_action_add(fib_entry, source, flags, dpo)); } old_path_list_index = esrc->fes_pl; esrc->fes_entry_flags = flags; /* * save variable so we can recover from a fib_entry realloc. */ fib_entry_index = fib_entry_get_index(fib_entry); FIB_ENTRY_SRC_VFT_INVOKE(esrc, fesv_add, (esrc, fib_entry, flags, fib_entry_get_dpo_proto(fib_entry), dpo)); fib_entry = fib_entry_get(fib_entry_index); esrc->fes_flags |= FIB_ENTRY_SRC_FLAG_ADDED; fib_path_list_lock(esrc->fes_pl); fib_path_list_unlock(old_path_list_index); return (fib_entry); } fib_entry_src_flag_t fib_entry_src_action_remove_or_update_inherit (fib_entry_t *fib_entry, fib_source_t source) { fib_entry_src_t *esrc; esrc = fib_entry_src_find(fib_entry, source); if (NULL == esrc) return (FIB_ENTRY_SRC_FLAG_ACTIVE); if ((esrc->fes_entry_flags & FIB_ENTRY_FLAG_COVERED_INHERIT) && (esrc->fes_flags & FIB_ENTRY_SRC_FLAG_INHERITED)) { fib_entry_src_t *cover_src; fib_node_index_t coveri; fib_entry_t *cover; /* * this source was pushing inherited state, but so is its * cover. Now that this source is going away, we need to * pull the covers forwarding and use it to update the covereds. * Go grab the path-list from the cover, rather than start a walk from * the cover, so we don't recursively update this entry. */ coveri = fib_table_get_less_specific(fib_entry->fe_fib_index, &fib_entry->fe_prefix); /* * only the default route has itself as its own cover, but the * default route cannot have inherited from something else. */ ASSERT(coveri != fib_entry_get_index(fib_entry)); cover = fib_entry_get(coveri); cover_src = fib_entry_src_find(cover, source); ASSERT(NULL != cover_src); esrc = fib_entry_src_action_update_from_cover(fib_entry, cover_src); esrc->fes_entry_flags &= ~FIB_ENTRY_FLAG_COVERED_INHERIT; /* * Now push the new state from the cover down to the covereds */ fib_entry_src_covered_inherit_add(fib_entry, source); return (esrc->fes_flags); } else { return (fib_entry_src_action_remove(fib_entry, source)); } } fib_entry_src_flag_t fib_entry_src_action_remove (fib_entry_t *fib_entry, fib_source_t source) { fib_node_index_t old_path_list; fib_entry_src_flag_t sflags; fib_entry_src_t *esrc; esrc = fib_entry_src_find(fib_entry, source); if (NULL == esrc) return (FIB_ENTRY_SRC_FLAG_ACTIVE); esrc->fes_ref_count--; sflags = esrc->fes_flags; if (0 != esrc->fes_ref_count) { /* * only remove the source on the 1->0 transisition */ return (sflags); } if (esrc->fes_flags & FIB_ENTRY_SRC_FLAG_ACTIVE) { fib_entry_src_action_deactivate(fib_entry, source); } else if (esrc->fes_flags & FIB_ENTRY_SRC_FLAG_CONTRIBUTING) { FIB_ENTRY_SRC_VFT_INVOKE(esrc, fesv_deactivate, (esrc, fib_entry)); esrc->fes_flags &= ~FIB_ENTRY_SRC_FLAG_CONTRIBUTING; } old_path_list = esrc->fes_pl; FIB_ENTRY_SRC_VFT_INVOKE(esrc, fesv_remove, (esrc)); fib_path_list_unlock(old_path_list); fib_entry_unlock(fib_entry_get_index(fib_entry)); sflags &= ~FIB_ENTRY_SRC_FLAG_ADDED; fib_entry_src_action_deinit(fib_entry, source); return (sflags); } /* * fib_route_attached_cross_table * * Return true the the route is attached via an interface that * is not in the same table as the route */ static inline int fib_route_attached_cross_table (const fib_entry_t *fib_entry, const fib_route_path_t *rpath) { /* * - All zeros next-hop * - a valid interface * - entry's fib index not equeal to interface's index */ if (ip46_address_is_zero(&rpath->frp_addr) && (~0 != rpath->frp_sw_if_index) && !(rpath->frp_flags & FIB_ROUTE_PATH_DVR) && (fib_entry->fe_fib_index != fib_table_get_index_for_sw_if_index(fib_entry_get_proto(fib_entry), rpath->frp_sw_if_index))) { return (!0); } return (0); } /* * Return true if the path is attached */ static inline int fib_path_is_attached (const fib_route_path_t *rpath) { /* * DVR paths are not attached, since we are not playing the * L3 game with these */ if (rpath->frp_flags & FIB_ROUTE_PATH_DVR) { return (0); } /* * - All zeros next-hop * - a valid interface */ if (ip46_address_is_zero(&rpath->frp_addr) && (~0 != rpath->frp_sw_if_index)) { return (!0); } else if (rpath->frp_flags & FIB_ROUTE_PATH_ATTACHED) { return (!0); } return (0); } fib_path_list_flags_t fib_entry_src_flags_2_path_list_flags (fib_entry_flag_t eflags) { fib_path_list_flags_t plf = FIB_PATH_LIST_FLAG_NONE; if (eflags & FIB_ENTRY_FLAG_DROP) { plf |= FIB_PATH_LIST_FLAG_DROP; } if (eflags & FIB_ENTRY_FLAG_EXCLUSIVE) { plf |= FIB_PATH_LIST_FLAG_EXCLUSIVE; } if (eflags & FIB_ENTRY_FLAG_LOCAL) { plf |= FIB_PATH_LIST_FLAG_LOCAL; } return (plf); } static void fib_entry_flags_update (const fib_entry_t *fib_entry, const fib_route_path_t *rpaths, fib_path_list_flags_t *pl_flags, fib_entry_src_t *esrc) { const fib_route_path_t *rpath; vec_foreach(rpath, rpaths) { if ((esrc->fes_src == FIB_SOURCE_API) || (esrc->fes_src == FIB_SOURCE_CLI)) { if (fib_path_is_attached(rpath)) { esrc->fes_entry_flags |= FIB_ENTRY_FLAG_ATTACHED; } else { esrc->fes_entry_flags &= ~FIB_ENTRY_FLAG_ATTACHED; } if (rpath->frp_flags & FIB_ROUTE_PATH_DEAG) { esrc->fes_entry_flags |= FIB_ENTRY_FLAG_LOOSE_URPF_EXEMPT; } } if (fib_route_attached_cross_table(fib_entry, rpath) && !(esrc->fes_entry_flags & FIB_ENTRY_FLAG_NO_ATTACHED_EXPORT)) { esrc->fes_entry_flags |= FIB_ENTRY_FLAG_IMPORT; } else { esrc->fes_entry_flags &= ~FIB_ENTRY_FLAG_IMPORT; } } } /* * fib_entry_src_action_add * * Adding a source can result in a new fib_entry being created, which * can inturn mean the pool is realloc'd and thus the entry passed as * an argument it also realloc'd * @return the entry */ fib_entry_t* fib_entry_src_action_path_add (fib_entry_t *fib_entry, fib_source_t source, fib_entry_flag_t flags, const fib_route_path_t *rpaths) { fib_node_index_t old_path_list, fib_entry_index; fib_path_list_flags_t pl_flags; fib_entry_src_t *esrc; /* * save variable so we can recover from a fib_entry realloc. */ fib_entry_index = fib_entry_get_index(fib_entry); esrc = fib_entry_src_find(fib_entry, source); if (NULL == esrc) { const dpo_id_t *dpo; if (flags == FIB_ENTRY_FLAG_EXCLUSIVE) { dpo = &rpaths->dpo; } else { dpo = drop_dpo_get(fib_entry_get_dpo_proto(fib_entry)); } fib_entry = fib_entry_src_action_add(fib_entry, source, flags, dpo); esrc = fib_entry_src_find(fib_entry, source); } /* * we are no doubt modifying a path-list. If the path-list * is shared, and hence not modifiable, then the index returned * will be for a different path-list. This FIB entry to needs * to maintain its lock appropriately. */ old_path_list = esrc->fes_pl; ASSERT(FIB_ENTRY_SRC_VFT_EXISTS(esrc, fesv_path_add)); pl_flags = fib_entry_src_flags_2_path_list_flags(fib_entry_get_flags_i(fib_entry)); fib_entry_flags_update(fib_entry, rpaths, &pl_flags, esrc); FIB_ENTRY_SRC_VFT_INVOKE(esrc, fesv_path_add, (esrc, fib_entry, pl_flags, rpaths)); fib_entry = fib_entry_get(fib_entry_index); fib_path_list_lock(esrc->fes_pl); fib_path_list_unlock(old_path_list); return (fib_entry); } /* * fib_entry_src_action_swap * * The source is providing new paths to replace the old ones. * Adding a source can result in a new fib_entry being created, which * can inturn mean the pool is realloc'd and thus the entry passed as * an argument it also realloc'd * @return the entry */ fib_entry_t* fib_entry_src_action_path_swap (fib_entry_t *fib_entry, fib_source_t source, fib_entry_flag_t flags, const fib_route_path_t *rpaths) { fib_node_index_t old_path_list, fib_entry_index; fib_path_list_flags_t pl_flags; fib_entry_src_t *esrc; esrc = fib_entry_src_find(fib_entry, source); /* * save variable so we can recover from a fib_entry realloc. */ fib_entry_index = fib_entry_get_index(fib_entry); if (NULL == esrc) { const dpo_id_t *dpo; if (flags == FIB_ENTRY_FLAG_EXCLUSIVE) { dpo = &rpaths->dpo; } else { dpo = drop_dpo_get(fib_entry_get_dpo_proto(fib_entry)); } fib_entry = fib_entry_src_action_add(fib_entry, source, flags, dpo); esrc = fib_entry_src_find(fib_entry, source); } else { if (flags != esrc->fes_entry_flags) { FIB_ENTRY_SRC_VFT_INVOKE(esrc, fesv_flags_change, (esrc, fib_entry, flags)); } esrc->fes_entry_flags = flags; } /* * swapping paths may create a new path-list (or may use an existing shared) * but we are certainly getting a different one. This FIB entry to needs * to maintain its lock appropriately. */ old_path_list = esrc->fes_pl; ASSERT(FIB_ENTRY_SRC_VFT_EXISTS(esrc, fesv_path_swap)); pl_flags = fib_entry_src_flags_2_path_list_flags(flags); fib_entry_flags_update(fib_entry, rpaths, &pl_flags, esrc); FIB_ENTRY_SRC_VFT_INVOKE(esrc, fesv_path_swap, (esrc, fib_entry, pl_flags, rpaths)); fib_entry = fib_entry_get(fib_entry_index); fib_path_list_lock(esrc->fes_pl); fib_path_list_unlock(old_path_list); return (fib_entry); } fib_entry_src_flag_t fib_entry_src_action_path_remove (fib_entry_t *fib_entry, fib_source_t source, const fib_route_path_t *rpaths) { fib_path_list_flags_t pl_flags; fib_node_index_t old_path_list; fib_entry_src_t *esrc; esrc = fib_entry_src_find(fib_entry, source); ASSERT(NULL != esrc); ASSERT(esrc->fes_flags & FIB_ENTRY_SRC_FLAG_ADDED); /* * we no doubt modifying a path-list. If the path-list * is shared, and hence not modifiable, then the index returned * will be for a different path-list. This FIB entry to needs * to maintain its lock appropriately. */ old_path_list = esrc->fes_pl; ASSERT(FIB_ENTRY_SRC_VFT_EXISTS(esrc, fesv_path_remove)); pl_flags = fib_entry_src_flags_2_path_list_flags(fib_entry_get_flags_i(fib_entry)); fib_entry_flags_update(fib_entry, rpaths, &pl_flags, esrc); FIB_ENTRY_SRC_VFT_INVOKE(esrc, fesv_path_remove, (esrc, pl_flags, rpaths)); /* * lock the new path-list, unlock the old if it had one */ fib_path_list_unlock(old_path_list); if (FIB_NODE_INDEX_INVALID != esrc->fes_pl) { fib_path_list_lock(esrc->fes_pl); return (FIB_ENTRY_SRC_FLAG_ADDED); } else { /* * no more paths left from this source */ fib_entry_src_action_remove_or_update_inherit(fib_entry, source); return (FIB_ENTRY_SRC_FLAG_NONE); } } u8* fib_entry_src_format (fib_entry_t *fib_entry, fib_source_t source, u8* s) { fib_entry_src_t *esrc; esrc = fib_entry_src_find(fib_entry, source); FIB_ENTRY_SRC_VFT_INVOKE_AND_RETURN(esrc, fesv_format, (esrc, s)); return (s); } adj_index_t fib_entry_get_adj_for_source (fib_node_index_t fib_entry_index, fib_source_t source) { fib_entry_t *fib_entry; fib_entry_src_t *esrc; if (FIB_NODE_INDEX_INVALID == fib_entry_index) return (ADJ_INDEX_INVALID); fib_entry = fib_entry_get(fib_entry_index); esrc = fib_entry_src_find(fib_entry, source); if (NULL != esrc) { if (FIB_NODE_INDEX_INVALID != esrc->fes_pl) { return (fib_path_list_get_adj( esrc->fes_pl, fib_entry_get_default_chain_type(fib_entry))); } } return (ADJ_INDEX_INVALID); } const int fib_entry_get_dpo_for_source (fib_node_index_t fib_entry_index, fib_source_t source, dpo_id_t *dpo) { fib_entry_t *fib_entry; fib_entry_src_t *esrc; if (FIB_NODE_INDEX_INVALID == fib_entry_index) return (0); fib_entry = fib_entry_get(fib_entry_index); esrc = fib_entry_src_find(fib_entry, source); if (NULL != esrc) { if (FIB_NODE_INDEX_INVALID != esrc->fes_pl) { fib_path_list_contribute_forwarding( esrc->fes_pl, fib_entry_get_default_chain_type(fib_entry), FIB_PATH_LIST_FWD_FLAG_NONE, dpo); return (dpo_id_is_valid(dpo)); } } return (0); } u32 fib_entry_get_resolving_interface_for_source (fib_node_index_t entry_index, fib_source_t source) { fib_entry_t *fib_entry; fib_entry_src_t *esrc; fib_entry = fib_entry_get(entry_index); esrc = fib_entry_src_find(fib_entry, source); if (NULL != esrc) { if (FIB_NODE_INDEX_INVALID != esrc->fes_pl) { return (fib_path_list_get_resolving_interface(esrc->fes_pl)); } } return (~0); } fib_entry_flag_t fib_entry_get_flags_for_source (fib_node_index_t entry_index, fib_source_t source) { fib_entry_t *fib_entry; fib_entry_src_t *esrc; fib_entry = fib_entry_get(entry_index); esrc = fib_entry_src_find(fib_entry, source); if (NULL != esrc) { return (esrc->fes_entry_flags); } return (FIB_ENTRY_FLAG_NONE); } fib_source_t fib_entry_get_source_i (const fib_entry_t *fib_entry) { /* the vector of sources is deliberately arranged in priority order */ if (0 == vec_len(fib_entry->fe_srcs)) return (FIB_SOURCE_INVALID); return (vec_elt(fib_entry->fe_srcs, 0).fes_src); } fib_entry_flag_t fib_entry_get_flags_i (const fib_entry_t *fib_entry) { /* the vector of sources is deliberately arranged in priority order */ if (0 == vec_len(fib_entry->fe_srcs)) return (FIB_ENTRY_FLAG_NONE); return (vec_elt(fib_entry->fe_srcs, 0).fes_entry_flags); } void fib_entry_set_source_data (fib_node_index_t fib_entry_index, fib_source_t source, const void *data) { fib_entry_t *fib_entry; fib_entry_src_t *esrc; fib_entry = fib_entry_get(fib_entry_index); esrc = fib_entry_src_find(fib_entry, source); if (NULL != esrc) { FIB_ENTRY_SRC_VFT_INVOKE(esrc, fesv_set_data, (esrc, fib_entry, data)); } } const void* fib_entry_get_source_data (fib_node_index_t fib_entry_index, fib_source_t source) { fib_entry_t *fib_entry; fib_entry_src_t *esrc; fib_entry = fib_entry_get(fib_entry_index); esrc = fib_entry_src_find(fib_entry, source); if (NULL != esrc) { FIB_ENTRY_SRC_VFT_INVOKE_AND_RETURN(esrc, fesv_get_data, (esrc, fib_entry)); } return (NULL); } void fib_entry_src_module_init (void) { fib_entry_src_rr_register(); fib_entry_src_interface_register(); fib_entry_src_interpose_register(); fib_entry_src_default_route_register(); fib_entry_src_special_register(); fib_entry_src_api_register(); fib_entry_src_adj_register(); fib_entry_src_mpls_register(); fib_entry_src_lisp_register(); }