vnet/vnet/l2/l2_output.h

   1 /*
   2  * l2_output.h : layer 2 output packet processing
   3  *
   4  * Copyright (c) 2013 Cisco and/or its affiliates.
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at:
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 #ifndef included_vnet_l2_output_h
  19 #define included_vnet_l2_output_h
  20
  21 #include <vlib/vlib.h>
  22 #include <vnet/vnet.h>
  23 #include <vnet/l2/feat_bitmap.h>
  24 #include <vnet/l2/l2_vtr.h>
  25
  26
  27 /* The L2 output feature configuration, a per-interface struct */
  28 typedef struct
  29 {
  30
  31   u32 feature_bitmap;
  32
  33   /*
  34    * vlan tag rewrite for ingress and egress
  35    * ingress vtr is located here because the same config data is used for
  36    * the egress EFP filter check
  37    */
  38   vtr_config_t input_vtr;
  39   vtr_config_t output_vtr;
  40
  41   /* some of these flags may get integrated into the feature bitmap */
  42   u8 fwd_enable;
  43   u8 flood_enable;
  44
  45   /* split horizon group */
  46   u8 shg;
  47
  48 } l2_output_config_t;
  49
  50
  51 /*
  52  * The set of next nodes for features and interface output.
  53  * Each output feature node should include this.
  54  */
  55 typedef struct
  56 {
  57   /*
  58    * vector of output next node index, indexed by sw_if_index.
  59    * used when all output features have been executed and the
  60    * next nodes are the interface output nodes.
  61    */
  62   u32 *output_node_index_vec;
  63
  64   /*
  65    * array of next node index for each output feature, indexed
  66    * by l2output_feat_t. Used to determine next feature node.
  67    */
  68   u32 feat_next_node_index[32];
  69
  70 } l2_output_next_nodes_st;
  71
  72
  73 typedef struct
  74 {
  75   /* Next nodes for features and output interfaces */
  76   l2_output_next_nodes_st next_nodes;
  77
  78   /* config vector indexed by sw_if_index */
  79   l2_output_config_t *configs;
  80
  81   /* Convenience variables */
  82   vlib_main_t *vlib_main;
  83   vnet_main_t *vnet_main;
  84 } l2output_main_t;
  85
  86 l2output_main_t l2output_main;
  87
  88 /* L2 output features */
  89
  90 /* Mappings from feature ID to graph node name */
  91 #define foreach_l2output_feat \
  92  _(SPAN,              "feature-bitmap-drop")        \
  93  _(CFM,               "feature-bitmap-drop")        \
  94  _(QOS,               "feature-bitmap-drop")        \
  95  _(ACL,               "l2-output-acl")              \
  96  _(L2PT,              "feature-bitmap-drop")        \
  97  _(EFP_FILTER,        "l2-efp-filter")              \
  98  _(IPIW,              "feature-bitmap-drop")        \
  99  _(STP_BLOCKED,       "feature-bitmap-drop")        \
 100  _(LINESTATUS_DOWN,   "feature-bitmap-drop")        \
 101  _(OUTPUT_CLASSIFY,   "l2-output-classify")         \
 102  _(XCRW,              "l2-xcrw")
 103
 104 /* Feature bitmap positions */
 105 typedef enum
 106 {
 107 #define _(sym,str) L2OUTPUT_FEAT_##sym##_BIT,
 108   foreach_l2output_feat
 109 #undef _
 110     L2OUTPUT_N_FEAT,
 111 } l2output_feat_t;
 112
 113 /* Feature bit masks */
 114 typedef enum
 115 {
 116 #define _(sym,str) L2OUTPUT_FEAT_##sym = (1<<L2OUTPUT_FEAT_##sym##_BIT),
 117   foreach_l2output_feat
 118 #undef _
 119 } l2output_feat_masks_t;
 120
 121 #define foreach_l2output_error                          \
 122 _(L2OUTPUT,     "L2 output packets")                    \
 123 _(EFP_DROP,     "L2 EFP filter pre-rewrite drops")      \
 124 _(VTR_DROP,     "L2 output tag rewrite drops")          \
 125 _(SHG_DROP,     "L2 split horizon drops")               \
 126 _(DROP,         "L2 output drops")
 127
 128 typedef enum
 129 {
 130   L2OUTPUT_NEXT_DROP,
 131   L2OUTPUT_NEXT_DEL_TUNNEL,
 132   L2OUTPUT_N_NEXT,
 133 } l2output_next_t;
 134
 135 typedef enum
 136 {
 137 #define _(sym,str) L2OUTPUT_ERROR_##sym,
 138   foreach_l2output_error
 139 #undef _
 140     L2OUTPUT_N_ERROR,
 141 } l2output_error_t;
 142
 143 /* Return an array of strings containing graph node names of each feature */
 144 char **l2output_get_feat_names (void);
 145
 146
 147 /**
 148  * The next set of functions is for use by output feature graph nodes.
 149  * When the last bit has been cleared from the output feature bitmap,
 150  * the next node is the output graph node for the TX sw_if_index.
 151  * These functions help the feature nodes get that node index.
 152  */
 153
 154 /* Create a mapping to the output graph node for the given sw_if_index */
 155 u32 l2output_create_output_node_mapping (vlib_main_t * vlib_main, vnet_main_t * vnet_main, u32 node_index,      /* index of current node */
 156                                          u32 * output_node_index_vec,
 157                                          u32 sw_if_index);
 158
 159 /* Initialize the next node mapping table */
 160 always_inline void
 161 l2output_init_output_node_vec (u32 ** output_node_index_vec)
 162 {
 163
 164   /*
 165    * Size it at 100 sw_if_indexes initially
 166    * Uninitialized mappings are set to ~0
 167    */
 168   vec_validate_init_empty (*output_node_index_vec, 100, ~0);
 169 }
 170
 171
 172 /**
 173  *  Get a mapping from the output node mapping table,
 174  * creating the entry if necessary.
 175  */
 176 always_inline u32
 177 l2output_get_output_node (vlib_main_t * vlib_main, vnet_main_t * vnet_main, u32 node_index,     /* index of current node */
 178                           u32 sw_if_index, u32 ** output_node_index_vec)        /* may be updated */
 179 {
 180   u32 next;                     /* index of next graph node */
 181
 182   /* Insure the vector is big enough */
 183   vec_validate_init_empty (*output_node_index_vec, sw_if_index, ~0);
 184
 185   /* Get the mapping for the sw_if_index */
 186   next = vec_elt (*output_node_index_vec, sw_if_index);
 187
 188   if (next == ~0)
 189     {
 190       /* Mapping doesn't exist so create it */
 191       next = l2output_create_output_node_mapping (vlib_main,
 192                                                   vnet_main,
 193                                                   node_index,
 194                                                   *output_node_index_vec,
 195                                                   sw_if_index);
 196     }
 197
 198   return next;
 199 }
 200
 201
 202 /** Determine the next L2 node based on the output feature bitmap */
 203 always_inline void
 204 l2_output_dispatch (vlib_main_t * vlib_main,
 205                     vnet_main_t * vnet_main,
 206                     vlib_node_runtime_t * node,
 207                     u32 node_index,
 208                     u32 * cached_sw_if_index,
 209                     u32 * cached_next_index,
 210                     l2_output_next_nodes_st * next_nodes,
 211                     vlib_buffer_t * b0,
 212                     u32 sw_if_index, u32 feature_bitmap, u32 * next0)
 213 {
 214   if (feature_bitmap)
 215     {
 216       /* There are some features to execute */
 217
 218       /* Save bitmap for the next feature graph nodes */
 219       vnet_buffer (b0)->l2.feature_bitmap = feature_bitmap;
 220
 221       /* Determine the next node */
 222       *next0 =
 223         feat_bitmap_get_next_node_index (next_nodes->feat_next_node_index,
 224                                          feature_bitmap);
 225     }
 226   else
 227     {
 228       /*
 229        * There are no features. Send packet to TX node for sw_if_index0
 230        * This is a little tricky in that the output interface next node indexes
 231        * are not precomputed at init time.
 232        */
 233
 234       if (sw_if_index == *cached_sw_if_index)
 235         {
 236           /* We hit in the one-entry cache. Use it. */
 237           *next0 = *cached_next_index;
 238         }
 239       else
 240         {
 241           /* Look up the output TX node */
 242           *next0 = l2output_get_output_node (vlib_main,
 243                                              vnet_main,
 244                                              node_index,
 245                                              sw_if_index,
 246                                              &next_nodes->output_node_index_vec);
 247
 248           /* Update the one-entry cache */
 249           *cached_sw_if_index = sw_if_index;
 250           *cached_next_index = *next0;
 251         }
 252     }
 253 }
 254
 255 /** Get a pointer to the config for the given interface */
 256 l2_output_config_t *l2output_intf_config (u32 sw_if_index);
 257
 258 /** Enable (or disable) the feature in the bitmap for the given interface */
 259 void l2output_intf_bitmap_enable (u32 sw_if_index,
 260                                   u32 feature_bitmap, u32 enable);
 261
 262 #endif
 263
 264 /*
 265  * fd.io coding-style-patch-verification: ON
 266  *
 267  * Local Variables:
 268  * eval: (c-set-style "gnu")
 269  * End:
 270  */