Line data    Source code

       1             : /*
       2             :  * Copyright (c) 2016 Cisco and/or its affiliates.
       3             :  * Licensed under the Apache License, Version 2.0 (the "License");
       4             :  * you may not use this file except in compliance with the License.
       5             :  * You may obtain a copy of the License at:
       6             :  *
       7             :  *     http://www.apache.org/licenses/LICENSE-2.0
       8             :  *
       9             :  * Unless required by applicable law or agreed to in writing, software
      10             :  * distributed under the License is distributed on an "AS IS" BASIS,
      11             :  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
      12             :  * See the License for the specific language governing permissions and
      13             :  * limitations under the License.
      14             :  */
      15             : /**
      16             :  * @brief bier_fmask : The BIER fmask
      17             :  *
      18             :  * The BIER fmask contains the bitString that is applied to packets that
      19             :  * egress towards the next-hop. As such the fmask is part of the rewrite
      20             :  * (adj) for that next-hop. It it thus an extension of the next-hop and in
      21             :  * no way associated with the bit-position(s) that are reachable through it.
      22             :  * Fmasks are thus shared by bit-positions that egress through the same
      23             :  * nh (BFR-NBR).
      24             :  * Deag fmasks are also shared in the event that a router has local
      25             :  * bit-positions. This is necessary to prevent the router receiving two copies
      26             :  * of each packet. Consequently it also means that they share the same
      27             :  * disposition data for the global data.
      28             :  */
      29             : 
      30             : #ifndef __BIER_FMASK_H__
      31             : #define __BIER_FMASK_H__
      32             : 
      33             : #include <vlib/vlib.h>
      34             : 
      35             : #include <vnet/fib/fib_node.h>
      36             : #include <vnet/mpls/packet.h>
      37             : #include <vnet/dpo/dpo.h>
      38             : 
      39             : #include <vnet/bier/bier_types.h>
      40             : #include <vnet/bier/bier_fmask_db.h>
      41             : 
      42             : /**
      43             :  * A struct that represents the reference counting of the bits
      44             :  */
      45             : typedef struct bier_fmask_bits_t_ {
      46             :     /**
      47             :      * each bit in the mask needs to be reference counted
      48             :      * and set/cleared on the 0->1 and 1->0 transitions.
      49             :      */
      50             :     bier_bit_string_t bfmb_input_reset_string;
      51             :     u32 *bfmb_refs;
      52             : 
      53             :     /**
      54             :      * The total number of references to bits set on this mask
      55             :      * in effect a count of the number of children.
      56             :      */
      57             :     u32 bfmb_count;
      58             : } bier_fmask_bits_t;
      59             : 
      60             : /**
      61             :  * Flags on fmask
      62             :  */
      63             : typedef enum bier_fmask_attributes_t_
      64             : {
      65             :     BIER_FMASK_ATTR_FIRST,
      66             :     BIER_FMASK_ATTR_FORWARDING = BIER_FMASK_ATTR_FIRST,
      67             :     BIER_FMASK_ATTR_DISP,
      68             :     BIER_FMASK_ATTR_MPLS,
      69             :     BIER_FMASK_ATTR_LAST = BIER_FMASK_ATTR_DISP,
      70             : } bier_fmask_attributes_t;
      71             : 
      72             : #define BIER_FMASK_ATTR_NAMES {                         \
      73             :      [BIER_FMASK_ATTR_FORWARDING] = "forwarding",       \
      74             :      [BIER_FMASK_ATTR_DISP] = "disposition",            \
      75             :      [BIER_FMASK_ATTR_MPLS] = "mpls",                   \
      76             : }
      77             : 
      78             : #define FOR_EACH_BIER_FMASK_ATTR(_item)          \
      79             :     for (_item =  BIER_FMASK_ATTR_FIRST;         \
      80             :          _item <= BIER_FMASK_ATTR_LAST;          \
      81             :          _item++)
      82             : 
      83             : typedef enum bier_fmask_flags_t_
      84             : {
      85             :     BIER_FMASK_FLAG_FORWARDING = (1 << BIER_FMASK_ATTR_FORWARDING),
      86             :     BIER_FMASK_FLAG_DISP = (1 << BIER_FMASK_ATTR_DISP),
      87             :     BIER_FMASK_FLAG_MPLS = (1 << BIER_FMASK_ATTR_MPLS),
      88             : } bier_fmask_flags_t;
      89             : 
      90             : /**
      91             :  * An outgoing BIER mask. aka forwarding bit mask (in the RFCs)
      92             :  *
      93             :  * This mask's function is two-fold
      94             :  *  1 - it is logical-AND with the input packet header to produce the
      95             :  *      output packet header
      96             :  *  2 - it is logical NAND with the input packet header to modify the bit-mask
      97             :  *      for the next lookup
      98             :  */
      99             : typedef struct bier_fmask_t_ {
     100             :     /**
     101             :      * Required for pool_get_aligned
     102             :      */
     103             :     CLIB_CACHE_LINE_ALIGN_MARK(cacheline0);
     104             : 
     105             :     /**
     106             :      * The BIER fmask is a child of a FIB entry in the FIB graph.
     107             :      */
     108             :     fib_node_t bfm_node;
     109             : 
     110             :     /**
     111             :      * operational/state flags on the fmask
     112             :      */
     113             :     bier_fmask_flags_t bfm_flags;
     114             : 
     115             :     /**
     116             :      * The bits, and their ref counts, that are set on this mask
     117             :      * This mask changes as BIER entries link to and from this fmask
     118             :      */
     119             :     bier_fmask_bits_t bfm_bits;
     120             : 
     121             :     /**
     122             :      * The key to this fmask - used for store/lookup in the DB
     123             :      */
     124             :     bier_fmask_id_t *bfm_id;
     125             : 
     126             :     /**
     127             :      * The MPLS label to paint on the header during forwarding
     128             :      */
     129             :     mpls_label_t bfm_label;
     130             : 
     131             :     /**
     132             :      * The path-list
     133             :      */
     134             :     fib_node_index_t bfm_pl;
     135             : 
     136             :     /**
     137             :      * the index of this fmask in the parent's child list.
     138             :      */
     139             :     u32 bfm_sibling;
     140             : 
     141             :     /**
     142             :      * The index into the adj table for the adj that
     143             :      * this fmask resolves via
     144             :      */
     145             :     dpo_id_t bfm_dpo;
     146             : } bier_fmask_t;
     147             : 
     148             : extern void bier_fmask_link(index_t bfmi, bier_bp_t bp);
     149             : extern void bier_fmask_unlink(index_t bfmi, bier_bp_t bp);
     150             : extern void bier_fmask_unlock(index_t bfmi);
     151             : extern void bier_fmask_lock(index_t bfmi);
     152             : 
     153             : extern index_t bier_fmask_create_and_lock(const bier_fmask_id_t *fmid,
     154             :                                           const fib_route_path_t *rpath);
     155             : 
     156             : extern u8* format_bier_fmask(u8 *s, va_list *ap);
     157             : 
     158             : extern void bier_fmask_contribute_forwarding(index_t bfmi,
     159             :                                              dpo_id_t *dpo);
     160             : 
     161             : extern u32 bier_fmask_child_add (fib_node_index_t fib_entry_index,
     162             :                                  fib_node_type_t child_type,
     163             :                                  fib_node_index_t child_index);
     164             : extern void bier_fmask_child_remove (fib_node_index_t fib_entry_index,
     165             :                                      u32 sibling_index);
     166             : extern void bier_fmask_get_stats (index_t bfmi, u64 * packets, u64 * bytes);
     167             : extern void bier_fmask_encode (index_t bfmi,
     168             :                                bier_table_id_t *btid,
     169             :                                fib_route_path_t *rpath);
     170             : 
     171             : /*
     172             :  * provided for fast data-path access
     173             :  */
     174             : extern bier_fmask_t *bier_fmask_pool;
     175             : 
     176             : static inline bier_fmask_t *
     177       10523 : bier_fmask_get (u32 index)
     178             : {
     179       10523 :     return (pool_elt_at_index(bier_fmask_pool, index));
     180             : }
     181             : 
     182             : #endif