/*
 * l2_output.h : layer 2 output packet processing
 *
 * Copyright (c) 2013 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.
 */

#ifndef included_vnet_l2_output_h
#define included_vnet_l2_output_h

#include <vlib/vlib.h>
#include <vnet/vnet.h>
#include <vnet/l2/feat_bitmap.h>
#include <vnet/l2/l2_vtr.h>


// The L2 output feature configuration, a per-interface struct
typedef struct {

  u32 feature_bitmap;

  // vlan tag rewrite for ingress and egress
  // ingress vtr is located here because the same config data is used for
  // the egress EFP filter check
  vtr_config_t input_vtr;
  vtr_config_t output_vtr;

  // some of these flags may get integrated into the feature bitmap
  u8  fwd_enable;    
  u8  flood_enable;

  // split horizon group
  u8  shg;

} l2_output_config_t;


// The set of next nodes for features and interface output.
// Each output feature node should include this.
typedef struct {
  // vector of output next node index, indexed by sw_if_index.
  // used when all output features have been executed and the
  // next nodes are the interface output nodes.
  u32 * output_node_index_vec;

  // array of next node index for each output feature, indexed
  // by l2output_feat_t. Used to determine next feature node.
  u32 feat_next_node_index[32];

} l2_output_next_nodes_st;


typedef struct {
  // Next nodes for features and output interfaces
  l2_output_next_nodes_st next_nodes;

  /* config vector indexed by sw_if_index */
  l2_output_config_t *configs;

  /* Convenience variables */
  vlib_main_t * vlib_main;
  vnet_main_t * vnet_main;
} l2output_main_t;

l2output_main_t l2output_main;
vlib_node_registration_t l2output_node;

// L2 output features

// Mappings from feature ID to graph node name
#define foreach_l2output_feat \
 _(SPAN,              "feature-bitmap-drop")        \
 _(CFM,               "feature-bitmap-drop")        \
 _(QOS,               "feature-bitmap-drop")        \
 _(ACL,               "l2-output-acl")              \
 _(L2PT,              "feature-bitmap-drop")        \
 _(EFP_FILTER,        "l2-efp-filter")              \
 _(IPIW,              "feature-bitmap-drop")        \
 _(STP_BLOCKED,       "feature-bitmap-drop")        \
 _(LINESTATUS_DOWN,   "feature-bitmap-drop")        \
 _(XCRW,	      "l2-xcrw")

// Feature bitmap positions
typedef enum {
#define _(sym,str) L2OUTPUT_FEAT_##sym##_BIT,
  foreach_l2output_feat
#undef _
  L2OUTPUT_N_FEAT,
} l2output_feat_t;

// Feature bit masks
typedef enum {
#define _(sym,str) L2OUTPUT_FEAT_##sym = (1<<L2OUTPUT_FEAT_##sym##_BIT),
  foreach_l2output_feat
#undef _
} l2output_feat_masks_t;
           
// Return an array of strings containing graph node names of each feature
char **l2output_get_feat_names(void);


// The next set of functions is for use by output feature graph nodes.
// When the last bit has been cleared from the output feature bitmap,
// the next node is the output graph node for the TX sw_if_index.
// These functions help the feature nodes get that node index.

// Create a mapping to the output graph node for the given sw_if_index
u32 l2output_create_output_node_mapping (
            vlib_main_t * vlib_main,
            vnet_main_t * vnet_main,
            u32           node_index,  // index of current node
            u32         * output_node_index_vec,
            u32           sw_if_index);

// Initialize the next node mapping table
always_inline
void l2output_init_output_node_vec (u32 **output_node_index_vec) {

  // Size it at 100 sw_if_indexes initially
  // Uninitialized mappings are set to ~0
  vec_validate_init_empty(*output_node_index_vec, 100, ~0);
}


// Get a mapping from the output node mapping table,
// creating the entry if necessary.
always_inline
u32 l2output_get_output_node (vlib_main_t * vlib_main,
                              vnet_main_t * vnet_main,
                              u32           node_index,  // index of current node
                              u32           sw_if_index,
                              u32         ** output_node_index_vec)  // may be updated
{
  u32 next;  // index of next graph node

  // Insure the vector is big enough
  vec_validate_init_empty(*output_node_index_vec, sw_if_index, ~0);

  // Get the mapping for the sw_if_index
  next = vec_elt(*output_node_index_vec, sw_if_index);

  if (next == ~0) {
    // Mapping doesn't exist so create it
    next = l2output_create_output_node_mapping (vlib_main,
                                                vnet_main,
                                                node_index,
                                                *output_node_index_vec,
                                                sw_if_index);
  } 

  return next;
}


// Determine the next L2 node based on the output feature bitmap
always_inline void
l2_output_dispatch (vlib_main_t * vlib_main,
                    vnet_main_t * vnet_main,
                    vlib_node_runtime_t * node,
                    u32 node_index,
                    u32 * cached_sw_if_index,
                    u32 * cached_next_index,
                    l2_output_next_nodes_st *next_nodes,
                    vlib_buffer_t * b0,
                    u32 sw_if_index,
                    u32 feature_bitmap,
                    u32 *next0)
{
  if (feature_bitmap) {
    // There are some features to execute

    // Save bitmap for the next feature graph nodes
    vnet_buffer(b0)->l2.feature_bitmap = feature_bitmap;

    // Determine the next node
    *next0 = feat_bitmap_get_next_node_index(next_nodes->feat_next_node_index,
                                             feature_bitmap);
  } else {
    // There are no features. Send packet to TX node for sw_if_index0
    // This is a little tricky in that the output interface next node indexes
    // are not precomputed at init time.

    if (sw_if_index == *cached_sw_if_index) {
      // We hit in the one-entry cache. Use it.
      *next0 = *cached_next_index;
    } else {
      // Look up the output TX node
      *next0 = l2output_get_output_node(vlib_main,
                                        vnet_main,
                                        node_index,
                                        sw_if_index,
                                        &next_nodes->output_node_index_vec);

      // Update the one-entry cache
      *cached_sw_if_index = sw_if_index;
      *cached_next_index = *next0;
    }
  }
}

// Get a pointer to the config for the given interface
l2_output_config_t * l2output_intf_config (u32 sw_if_index);

// Enable (or disable) the feature in the bitmap for the given interface
void l2output_intf_bitmap_enable (u32 sw_if_index,
                                  u32 feature_bitmap,
                                  u32 enable);

#endif