From 97d8dc2317780740af5faa3dc205d95d838fbd04 Mon Sep 17 00:00:00 2001 From: Dave Barach Date: Mon, 15 Aug 2016 15:31:15 -0400 Subject: VPP-257 Coding standards cleanup for vnet/vnet/l2 Change-Id: Iba5f33675bb2eb806e9becdc42b11da5d3932d55 Signed-off-by: Dave Barach --- vnet/vnet/l2/feat_bitmap.c | 115 ++-- vnet/vnet/l2/feat_bitmap.h | 84 +-- vnet/vnet/l2/l2_bd.c | 883 +++++++++++++++++-------------- vnet/vnet/l2/l2_bd.h | 93 ++-- vnet/vnet/l2/l2_bvi.c | 13 +- vnet/vnet/l2/l2_bvi.h | 117 +++-- vnet/vnet/l2/l2_classify.c | 583 +++++++++++---------- vnet/vnet/l2/l2_classify.h | 34 +- vnet/vnet/l2/l2_efp_filter.c | 690 ++++++++++++------------ vnet/vnet/l2/l2_efp_filter.h | 9 +- vnet/vnet/l2/l2_fib.c | 588 +++++++++++---------- vnet/vnet/l2/l2_fib.h | 306 ++++++----- vnet/vnet/l2/l2_flood.c | 566 ++++++++++---------- vnet/vnet/l2/l2_flood.h | 11 +- vnet/vnet/l2/l2_fwd.c | 471 +++++++++-------- vnet/vnet/l2/l2_fwd.h | 11 +- vnet/vnet/l2/l2_input.c | 1181 +++++++++++++++++++++++------------------- vnet/vnet/l2/l2_input.h | 216 ++++---- vnet/vnet/l2/l2_input_acl.c | 403 +++++++------- vnet/vnet/l2/l2_input_vtr.c | 350 +++++++------ vnet/vnet/l2/l2_input_vtr.h | 25 +- vnet/vnet/l2/l2_learn.c | 517 +++++++++--------- vnet/vnet/l2/l2_learn.h | 25 +- vnet/vnet/l2/l2_output.c | 742 +++++++++++++------------- vnet/vnet/l2/l2_output.h | 277 +++++----- vnet/vnet/l2/l2_output_acl.c | 314 +++++------ vnet/vnet/l2/l2_patch.c | 355 +++++++------ vnet/vnet/l2/l2_rw.c | 782 +++++++++++++++------------- vnet/vnet/l2/l2_rw.h | 31 +- vnet/vnet/l2/l2_vtr.c | 730 +++++++++++++++----------- vnet/vnet/l2/l2_vtr.h | 204 +++++--- vnet/vnet/l2/l2_xcrw.c | 460 ++++++++-------- vnet/vnet/l2/l2_xcrw.h | 39 +- 33 files changed, 6069 insertions(+), 5156 deletions(-) (limited to 'vnet') diff --git a/vnet/vnet/l2/feat_bitmap.c b/vnet/vnet/l2/feat_bitmap.c index 74917cda3ae..6c046467f2c 100644 --- a/vnet/vnet/l2/feat_bitmap.c +++ b/vnet/vnet/l2/feat_bitmap.c @@ -29,12 +29,13 @@ #include -// Drop node for feature bitmaps -// For features that just do a drop, or are not yet implemented. -// Initial feature dispatch nodes don't need to set b0->error -// in case of a possible drop because that will be done here. -// The next node is always error-drop. - +/* + * Drop node for feature bitmaps + * For features that just do a drop, or are not yet implemented. + * Initial feature dispatch nodes don't need to set b0->error + * in case of a possible drop because that will be done here. + *The next node is always error-drop. + */ static vlib_node_registration_t feat_bitmap_drop_node; @@ -42,49 +43,53 @@ static vlib_node_registration_t feat_bitmap_drop_node; _(NO_FWD, "L2 feature forwarding disabled") \ _(NYI, "L2 feature not implemented") -typedef enum { +typedef enum +{ #define _(sym,str) FEAT_BITMAP_DROP_ERROR_##sym, foreach_feat_bitmap_drop_error #undef _ - FEAT_BITMAP_DROP_N_ERROR, + FEAT_BITMAP_DROP_N_ERROR, } feat_bitmap_drop_error_t; -static char * feat_bitmap_drop_error_strings[] = { +static char *feat_bitmap_drop_error_strings[] = { #define _(sym,string) string, foreach_feat_bitmap_drop_error #undef _ }; -typedef enum { +typedef enum +{ FEAT_BITMAP_DROP_NEXT_DROP, FEAT_BITMAP_DROP_N_NEXT, } feat_bitmap_drop_next_t; -typedef struct { +typedef struct +{ u32 feature_bitmap; } feat_bitmap_drop_trace_t; /* packet trace format function */ -static u8 * format_feat_bitmap_drop_trace (u8 * s, va_list * args) +static u8 * +format_feat_bitmap_drop_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 *); - feat_bitmap_drop_trace_t * t = va_arg (*args, feat_bitmap_drop_trace_t *); - - s = format (s, "feat_bitmap_drop: feature bitmap 0x%08x", t->feature_bitmap); + feat_bitmap_drop_trace_t *t = va_arg (*args, feat_bitmap_drop_trace_t *); + + s = + format (s, "feat_bitmap_drop: feature bitmap 0x%08x", t->feature_bitmap); return s; } static uword feat_bitmap_drop_node_fn (vlib_main_t * vm, - vlib_node_runtime_t * node, - vlib_frame_t * frame) + vlib_node_runtime_t * node, vlib_frame_t * frame) { - u32 n_left_from, * from, * to_next; + u32 n_left_from, *from, *to_next; feat_bitmap_drop_next_t next_index; from = vlib_frame_vector_args (frame); - n_left_from = frame->n_vectors; /* number of packets to process */ + n_left_from = frame->n_vectors; /* number of packets to process */ next_index = node->cached_next_index; while (n_left_from > 0) @@ -92,16 +97,15 @@ feat_bitmap_drop_node_fn (vlib_main_t * vm, u32 n_left_to_next; /* get space to enqueue frame to graph node "next_index" */ - vlib_get_next_frame (vm, node, next_index, - to_next, 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) { - u32 bi0; - vlib_buffer_t * b0; - u32 next0; - - /* speculatively enqueue b0 to the current next frame */ + u32 bi0; + vlib_buffer_t *b0; + u32 next0; + + /* speculatively enqueue b0 to the current next frame */ bi0 = from[0]; to_next[0] = bi0; from += 1; @@ -111,23 +115,29 @@ feat_bitmap_drop_node_fn (vlib_main_t * vm, b0 = vlib_get_buffer (vm, bi0); - if (PREDICT_FALSE((node->flags & VLIB_NODE_FLAG_TRACE) - && (b0->flags & VLIB_BUFFER_IS_TRACED))) { - feat_bitmap_drop_trace_t *t = - vlib_add_trace (vm, node, b0, sizeof (*t)); - t->feature_bitmap = vnet_buffer(b0)->l2.feature_bitmap; - } - - if (vnet_buffer(b0)->l2.feature_bitmap == 1) { - // If we are executing the last feature, this is the - // No forwarding catch-all - b0->error = node->errors[FEAT_BITMAP_DROP_ERROR_NO_FWD]; - } else { - b0->error = node->errors[FEAT_BITMAP_DROP_ERROR_NYI]; - } - next0 = FEAT_BITMAP_DROP_NEXT_DROP; - - /* verify speculative enqueue, maybe switch current next frame */ + if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE) + && (b0->flags & VLIB_BUFFER_IS_TRACED))) + { + feat_bitmap_drop_trace_t *t = + vlib_add_trace (vm, node, b0, sizeof (*t)); + t->feature_bitmap = vnet_buffer (b0)->l2.feature_bitmap; + } + + if (vnet_buffer (b0)->l2.feature_bitmap == 1) + { + /* + * If we are executing the last feature, this is the + * No forwarding catch-all + */ + b0->error = node->errors[FEAT_BITMAP_DROP_ERROR_NO_FWD]; + } + else + { + b0->error = node->errors[FEAT_BITMAP_DROP_ERROR_NYI]; + } + next0 = FEAT_BITMAP_DROP_NEXT_DROP; + + /* verify speculative enqueue, maybe switch current next frame */ vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next, n_left_to_next, bi0, next0); @@ -138,20 +148,22 @@ feat_bitmap_drop_node_fn (vlib_main_t * vm, return frame->n_vectors; } -clib_error_t *feat_bitmap_drop_init (vlib_main_t *vm) +clib_error_t * +feat_bitmap_drop_init (vlib_main_t * vm) { return 0; } VLIB_INIT_FUNCTION (feat_bitmap_drop_init); +/* *INDENT-OFF* */ VLIB_REGISTER_NODE (feat_bitmap_drop_node,static) = { .function = feat_bitmap_drop_node_fn, .name = "feature-bitmap-drop", .vector_size = sizeof (u32), .format_trace = format_feat_bitmap_drop_trace, .type = VLIB_NODE_TYPE_INTERNAL, - + .n_errors = ARRAY_LEN(feat_bitmap_drop_error_strings), .error_strings = feat_bitmap_drop_error_strings, @@ -159,8 +171,15 @@ VLIB_REGISTER_NODE (feat_bitmap_drop_node,static) = { /* edit / add dispositions here */ .next_nodes = { - [FEAT_BITMAP_DROP_NEXT_DROP] = "error-drop", + [FEAT_BITMAP_DROP_NEXT_DROP] = "error-drop", }, }; +/* *INDENT-ON* */ - +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/vnet/vnet/l2/feat_bitmap.h b/vnet/vnet/l2/feat_bitmap.h index 7dd36a7712e..c6e02ecc7c9 100644 --- a/vnet/vnet/l2/feat_bitmap.h +++ b/vnet/vnet/l2/feat_bitmap.h @@ -21,60 +21,76 @@ #include #include -/* +/* * The feature bitmap is a way of organizing input and output feature graph nodes. - * The set of features to be executed are arranged in a bitmap with one bit per - * feature and each bit positioned in the same order that the features should be - * executed. Features can be dynamically removed from the set by masking off their + * The set of features to be executed are arranged in a bitmap with one bit per + * feature and each bit positioned in the same order that the features should be + * executed. Features can be dynamically removed from the set by masking off their * corresponding bits. The bitmap is stored in packet context. Each feature clears - * its bit and then calls feat_bitmap_get_next_node_index() to go to the next + * its bit and then calls feat_bitmap_get_next_node_index() to go to the next * graph node. */ -// 32 features in a u32 bitmap +/* 32 features in a u32 bitmap */ #define FEAT_MAX 32 -// Initialize the feature next-node indexes of a graph node. -// Should be called by the init function of each feature graph node. -always_inline -void feat_bitmap_init_next_nodes ( - vlib_main_t * vm, - u32 node_index, // the current graph node index - u32 num_features, // number of entries in feat_names - char ** feat_names, // array of feature graph node names - u32 * next_nodes) // array of 32 next indexes to init +/** + Initialize the feature next-node indexes of a graph node. + Should be called by the init function of each feature graph node. +*/ +always_inline void +feat_bitmap_init_next_nodes (vlib_main_t * vm, u32 node_index, /* the current graph node index */ + u32 num_features, /* number of entries in feat_names */ + char **feat_names, /* array of feature graph node names */ + u32 * next_nodes) /* array of 32 next indexes to init */ { u32 idx; - ASSERT(num_features <= FEAT_MAX); + ASSERT (num_features <= FEAT_MAX); + + for (idx = 0; idx < num_features; idx++) + { + if (vlib_get_node_by_name (vm, (u8 *) feat_names[idx])) + { + next_nodes[idx] = + vlib_node_add_named_next (vm, node_index, feat_names[idx]); + } + else + { // Node may be in plugin which is not installed, use drop node + next_nodes[idx] = + vlib_node_add_named_next (vm, node_index, "feature-bitmap-drop"); + } + } - for (idx=0; idxfeature_bitmap = ~L2INPUT_FEAT_ARP_TERM; - bd_config->bvi_sw_if_index = ~0; - bd_config->members = 0; - bd_config->mac_by_ip4 = 0; -// bd_config->mac_by_ip6 = hash_create_mem (0, sizeof(ip6_address_t), -// sizeof(uword)); - } + if (!bd_is_valid (bd_config)) + { + bd_config->feature_bitmap = ~L2INPUT_FEAT_ARP_TERM; + bd_config->bvi_sw_if_index = ~0; + bd_config->members = 0; + bd_config->mac_by_ip4 = 0; + } } -u32 bd_find_or_add_bd_index (bd_main_t * bdm, u32 bd_id) +u32 +bd_find_or_add_bd_index (bd_main_t * bdm, u32 bd_id) { - uword * p; + uword *p; u32 rv; - if (bd_id == ~0) { - bd_id = 0; - while (hash_get (bdm->bd_index_by_bd_id, bd_id)) - bd_id++; - } else { - p = hash_get (bdm->bd_index_by_bd_id, bd_id); - if (p) - return (p[0]); - } - + if (bd_id == ~0) + { + bd_id = 0; + while (hash_get (bdm->bd_index_by_bd_id, bd_id)) + bd_id++; + } + else + { + p = hash_get (bdm->bd_index_by_bd_id, bd_id); + if (p) + return (p[0]); + } + rv = clib_bitmap_first_clear (bdm->bd_index_bitmap); - // mark this index busy + /* mark this index busy */ bdm->bd_index_bitmap = clib_bitmap_set (bdm->bd_index_bitmap, rv, 1); hash_set (bdm->bd_index_by_bd_id, bd_id, rv); @@ -77,9 +82,10 @@ u32 bd_find_or_add_bd_index (bd_main_t * bdm, u32 bd_id) return rv; } -int bd_delete_bd_index (bd_main_t * bdm, u32 bd_id) +int +bd_delete_bd_index (bd_main_t * bdm, u32 bd_id) { - uword * p; + uword *p; u32 bd_index; p = hash_get (bdm->bd_index_by_bd_id, bd_id); @@ -87,8 +93,8 @@ int bd_delete_bd_index (bd_main_t * bdm, u32 bd_id) return -1; bd_index = p[0]; - - // mark this index clear + + /* mark this index clear */ bdm->bd_index_bitmap = clib_bitmap_set (bdm->bd_index_bitmap, bd_index, 0); hash_unset (bdm->bd_index_by_bd_id, bd_id); @@ -99,24 +105,28 @@ int bd_delete_bd_index (bd_main_t * bdm, u32 bd_id) } void -bd_add_member (l2_bridge_domain_t * bd_config, - l2_flood_member_t * member) +bd_add_member (l2_bridge_domain_t * bd_config, l2_flood_member_t * member) { - // Add one element to the vector - - // When flooding, the bvi interface (if present) must be the last member - // processed due to how BVI processing can change the packet. To enable - // this order, we make the bvi interface the first in the vector and - // flooding walks the vector in reverse. + /* + * Add one element to the vector + * + * When flooding, the bvi interface (if present) must be the last member + * processed due to how BVI processing can change the packet. To enable + * this order, we make the bvi interface the first in the vector and + * flooding walks the vector in reverse. + */ if ((member->flags == L2_FLOOD_MEMBER_NORMAL) || - (vec_len(bd_config->members) == 0)) { - vec_add1 (bd_config->members, *member); + (vec_len (bd_config->members) == 0)) + { + vec_add1 (bd_config->members, *member); - } else { - // Move 0th element to the end - vec_add1 (bd_config->members, bd_config->members[0]); - bd_config->members[0] = *member; - } + } + else + { + /* Move 0th element to the end */ + vec_add1 (bd_config->members, bd_config->members[0]); + bd_config->members[0] = *member; + } } @@ -124,99 +134,112 @@ bd_add_member (l2_bridge_domain_t * bd_config, #define BD_REMOVE_ERROR_NOT_FOUND 1 u32 -bd_remove_member (l2_bridge_domain_t * bd_config, - u32 sw_if_index) +bd_remove_member (l2_bridge_domain_t * bd_config, u32 sw_if_index) { u32 ix; - - // Find and delete the member - vec_foreach_index(ix, bd_config->members) { - if (vec_elt(bd_config->members, ix).sw_if_index == sw_if_index) { - vec_del1 (bd_config->members, ix); - return BD_REMOVE_ERROR_OK; - } + + /* Find and delete the member */ + vec_foreach_index (ix, bd_config->members) + { + if (vec_elt (bd_config->members, ix).sw_if_index == sw_if_index) + { + vec_del1 (bd_config->members, ix); + return BD_REMOVE_ERROR_OK; + } } return BD_REMOVE_ERROR_NOT_FOUND; } -clib_error_t *l2bd_init (vlib_main_t *vm) +clib_error_t * +l2bd_init (vlib_main_t * vm) { bd_main_t *bdm = &bd_main; u32 bd_index; - bdm->bd_index_by_bd_id = hash_create (0, sizeof(uword)); - // create a dummy bd with bd_id of 0 and bd_index of 0 with feature set - // to packet drop only. Thus, packets received from any L2 interface with - // uninitialized bd_index of 0 can be dropped safely. + bdm->bd_index_by_bd_id = hash_create (0, sizeof (uword)); + /* + * create a dummy bd with bd_id of 0 and bd_index of 0 with feature set + * to packet drop only. Thus, packets received from any L2 interface with + * uninitialized bd_index of 0 can be dropped safely. + */ bd_index = bd_find_or_add_bd_index (bdm, 0); ASSERT (bd_index == 0); - l2input_main.bd_configs[0].feature_bitmap = L2INPUT_FEAT_DROP; + l2input_main.bd_configs[0].feature_bitmap = L2INPUT_FEAT_DROP; return 0; } VLIB_INIT_FUNCTION (l2bd_init); -// Set the learn/forward/flood flags for the bridge domain -// Return 0 if ok, non-zero if for an error. -u32 -bd_set_flags (vlib_main_t * vm, - u32 bd_index, - u32 flags, - u32 enable) { +/** + Set the learn/forward/flood flags for the bridge domain + Return 0 if ok, non-zero if for an error. +*/ +u32 +bd_set_flags (vlib_main_t * vm, u32 bd_index, u32 flags, u32 enable) +{ - l2_bridge_domain_t * bd_config; + l2_bridge_domain_t *bd_config; u32 feature_bitmap = 0; vec_validate (l2input_main.bd_configs, bd_index); - bd_config = vec_elt_at_index(l2input_main.bd_configs, bd_index); + bd_config = vec_elt_at_index (l2input_main.bd_configs, bd_index); bd_validate (bd_config); - if (flags & L2_LEARN) { - feature_bitmap |= L2INPUT_FEAT_LEARN; - } - if (flags & L2_FWD) { - feature_bitmap |= L2INPUT_FEAT_FWD; - } - if (flags & L2_FLOOD) { - feature_bitmap |= L2INPUT_FEAT_FLOOD; - } - if (flags & L2_UU_FLOOD) { - feature_bitmap |= L2INPUT_FEAT_UU_FLOOD; - } - if (flags & L2_ARP_TERM) { - feature_bitmap |= L2INPUT_FEAT_ARP_TERM; - } + if (flags & L2_LEARN) + { + feature_bitmap |= L2INPUT_FEAT_LEARN; + } + if (flags & L2_FWD) + { + feature_bitmap |= L2INPUT_FEAT_FWD; + } + if (flags & L2_FLOOD) + { + feature_bitmap |= L2INPUT_FEAT_FLOOD; + } + if (flags & L2_UU_FLOOD) + { + feature_bitmap |= L2INPUT_FEAT_UU_FLOOD; + } + if (flags & L2_ARP_TERM) + { + feature_bitmap |= L2INPUT_FEAT_ARP_TERM; + } - if (enable) { - bd_config->feature_bitmap |= feature_bitmap; - } else { - bd_config->feature_bitmap &= ~feature_bitmap; - } + if (enable) + { + bd_config->feature_bitmap |= feature_bitmap; + } + else + { + bd_config->feature_bitmap &= ~feature_bitmap; + } return 0; } -// set bridge-domain learn enable/disable -// The CLI format is: -// set bridge-domain learn [disable] +/** + set bridge-domain learn enable/disable + The CLI format is: + set bridge-domain learn [disable] +*/ static clib_error_t * bd_learn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) + unformat_input_t * input, vlib_cli_command_t * cmd) { - bd_main_t * bdm = &bd_main; - clib_error_t * error = 0; + bd_main_t *bdm = &bd_main; + clib_error_t *error = 0; u32 bd_index, bd_id; u32 enable; - uword * p; - - if (! unformat (input, "%d", &bd_id)) + uword *p; + + if (!unformat (input, "%d", &bd_id)) { error = clib_error_return (0, "expecting bridge-domain id but got `%U'", - format_unformat_error, input); + format_unformat_error, input); goto done; } @@ -224,48 +247,53 @@ bd_learn (vlib_main_t * vm, if (p == 0) return clib_error_return (0, "No such bridge domain %d", bd_id); - + bd_index = p[0]; enable = 1; - if (unformat (input, "disable")) { - enable = 0; - } + if (unformat (input, "disable")) + { + enable = 0; + } - // set the bridge domain flag - if (bd_set_flags(vm, bd_index, L2_LEARN, enable)) { - error = clib_error_return (0, "bridge-domain id %d out of range", bd_index); - goto done; - } + /* set the bridge domain flag */ + if (bd_set_flags (vm, bd_index, L2_LEARN, enable)) + { + error = + clib_error_return (0, "bridge-domain id %d out of range", bd_index); + goto done; + } - done: +done: return error; } +/* *INDENT-OFF* */ VLIB_CLI_COMMAND (bd_learn_cli, static) = { .path = "set bridge-domain learn", .short_help = "set bridge-domain learn [disable]", .function = bd_learn, }; +/* *INDENT-ON* */ -// set bridge-domain forward enable/disable -// The CLI format is: -// set bridge-domain forward [disable] +/** + set bridge-domain forward enable/disable + The CLI format is: + set bridge-domain forward [disable] +*/ static clib_error_t * -bd_fwd (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) +bd_fwd (vlib_main_t * vm, unformat_input_t * input, vlib_cli_command_t * cmd) { - bd_main_t * bdm = &bd_main; - clib_error_t * error = 0; + bd_main_t *bdm = &bd_main; + clib_error_t *error = 0; u32 bd_index, bd_id; u32 enable; - uword * p; + uword *p; - if (! unformat (input, "%d", &bd_id)) + if (!unformat (input, "%d", &bd_id)) { error = clib_error_return (0, "expecting bridge-domain id but got `%U'", - format_unformat_error, input); + format_unformat_error, input); goto done; } @@ -273,48 +301,54 @@ bd_fwd (vlib_main_t * vm, if (p == 0) return clib_error_return (0, "No such bridge domain %d", bd_id); - + bd_index = p[0]; enable = 1; - if (unformat (input, "disable")) { - enable = 0; - } + if (unformat (input, "disable")) + { + enable = 0; + } - // set the bridge domain flag - if (bd_set_flags(vm, bd_index, L2_FWD, enable)) { - error = clib_error_return (0, "bridge-domain id %d out of range", bd_index); - goto done; - } + /* set the bridge domain flag */ + if (bd_set_flags (vm, bd_index, L2_FWD, enable)) + { + error = + clib_error_return (0, "bridge-domain id %d out of range", bd_index); + goto done; + } - done: +done: return error; } +/* *INDENT-OFF* */ VLIB_CLI_COMMAND (bd_fwd_cli, static) = { .path = "set bridge-domain forward", .short_help = "set bridge-domain forward [disable]", .function = bd_fwd, }; +/* *INDENT-ON* */ -// set bridge-domain flood enable/disable -// The CLI format is: -// set bridge-domain flood [disable] +/** + set bridge-domain flood enable/disable + The CLI format is: + set bridge-domain flood [disable] +*/ static clib_error_t * bd_flood (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) + unformat_input_t * input, vlib_cli_command_t * cmd) { - bd_main_t * bdm = &bd_main; - clib_error_t * error = 0; + bd_main_t *bdm = &bd_main; + clib_error_t *error = 0; u32 bd_index, bd_id; u32 enable; - uword * p; + uword *p; - if (! unformat (input, "%d", &bd_id)) + if (!unformat (input, "%d", &bd_id)) { error = clib_error_return (0, "expecting bridge-domain id but got `%U'", - format_unformat_error, input); + format_unformat_error, input); goto done; } @@ -322,48 +356,54 @@ bd_flood (vlib_main_t * vm, if (p == 0) return clib_error_return (0, "No such bridge domain %d", bd_id); - + bd_index = p[0]; enable = 1; - if (unformat (input, "disable")) { - enable = 0; - } + if (unformat (input, "disable")) + { + enable = 0; + } - // set the bridge domain flag - if (bd_set_flags(vm, bd_index, L2_FLOOD, enable)) { - error = clib_error_return (0, "bridge-domain id %d out of range", bd_index); - goto done; - } + /* set the bridge domain flag */ + if (bd_set_flags (vm, bd_index, L2_FLOOD, enable)) + { + error = + clib_error_return (0, "bridge-domain id %d out of range", bd_index); + goto done; + } - done: +done: return error; } +/* *INDENT-OFF* */ VLIB_CLI_COMMAND (bd_flood_cli, static) = { .path = "set bridge-domain flood", .short_help = "set bridge-domain flood [disable]", .function = bd_flood, }; +/* *INDENT-ON* */ -// set bridge-domain unkown-unicast flood enable/disable -// The CLI format is: -// set bridge-domain uu-flood [disable] +/** + set bridge-domain unkown-unicast flood enable/disable + The CLI format is: + set bridge-domain uu-flood [disable] +*/ static clib_error_t * bd_uu_flood (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) + unformat_input_t * input, vlib_cli_command_t * cmd) { - bd_main_t * bdm = &bd_main; - clib_error_t * error = 0; + bd_main_t *bdm = &bd_main; + clib_error_t *error = 0; u32 bd_index, bd_id; u32 enable; - uword * p; + uword *p; - if (! unformat (input, "%d", &bd_id)) + if (!unformat (input, "%d", &bd_id)) { error = clib_error_return (0, "expecting bridge-domain id but got `%U'", - format_unformat_error, input); + format_unformat_error, input); goto done; } @@ -371,331 +411,412 @@ bd_uu_flood (vlib_main_t * vm, if (p == 0) return clib_error_return (0, "No such bridge domain %d", bd_id); - + bd_index = p[0]; enable = 1; - if (unformat (input, "disable")) { - enable = 0; - } + if (unformat (input, "disable")) + { + enable = 0; + } - // set the bridge domain flag - if (bd_set_flags(vm, bd_index, L2_UU_FLOOD, enable)) { - error = clib_error_return (0, "bridge-domain id %d out of range", bd_index); - goto done; - } + /* set the bridge domain flag */ + if (bd_set_flags (vm, bd_index, L2_UU_FLOOD, enable)) + { + error = + clib_error_return (0, "bridge-domain id %d out of range", bd_index); + goto done; + } - done: +done: return error; } +/* *INDENT-OFF* */ VLIB_CLI_COMMAND (bd_uu_flood_cli, static) = { .path = "set bridge-domain uu-flood", .short_help = "set bridge-domain uu-flood [disable]", .function = bd_uu_flood, }; +/* *INDENT-ON* */ -// set bridge-domain arp term enable/disable -// The CLI format is: -// set bridge-domain arp term [disable] +/** + set bridge-domain arp term enable/disable + The CLI format is: + set bridge-domain arp term [disable] +*/ static clib_error_t * bd_arp_term (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) + unformat_input_t * input, vlib_cli_command_t * cmd) { - bd_main_t * bdm = &bd_main; - clib_error_t * error = 0; + bd_main_t *bdm = &bd_main; + clib_error_t *error = 0; u32 bd_index, bd_id; u32 enable; - uword * p; + uword *p; - if (! unformat (input, "%d", &bd_id)) { - error = clib_error_return (0, "expecting bridge-domain id but got `%U'", - format_unformat_error, input); - goto done; - } + if (!unformat (input, "%d", &bd_id)) + { + error = clib_error_return (0, "expecting bridge-domain id but got `%U'", + format_unformat_error, input); + goto done; + } p = hash_get (bdm->bd_index_by_bd_id, bd_id); - if (p) bd_index = *p; - else return clib_error_return (0, "No such bridge domain %d", bd_id); - + if (p) + bd_index = *p; + else + return clib_error_return (0, "No such bridge domain %d", bd_id); + enable = 1; - if (unformat (input, "disable")) enable = 0; + if (unformat (input, "disable")) + enable = 0; - // set the bridge domain flag - if (bd_set_flags(vm, bd_index, L2_ARP_TERM, enable)) { - error = clib_error_return (0, "bridge-domain id %d out of range", bd_index); - goto done; - } + /* set the bridge domain flag */ + if (bd_set_flags (vm, bd_index, L2_ARP_TERM, enable)) + { + error = + clib_error_return (0, "bridge-domain id %d out of range", bd_index); + goto done; + } done: return error; } +/* *INDENT-OFF* */ VLIB_CLI_COMMAND (bd_arp_term_cli, static) = { .path = "set bridge-domain arp term", .short_help = "set bridge-domain arp term [disable]", .function = bd_arp_term, }; +/* *INDENT-ON* */ -// The clib hash implementation stores uword entries in the hash table. -// The hash table mac_by_ip4 is keyed via IP4 address and store the -// 6-byte MAC address directly in the hash table entry uword. -// This only works for 64-bit processor with 8-byte uword; which means -// this code *WILL NOT WORK* for a 32-bit prcessor with 4-byte uword. -u32 bd_add_del_ip_mac(u32 bd_index, - u8 *ip_addr, - u8 *mac_addr, - u8 is_ip6, - u8 is_add) +/** + * The clib hash implementation stores uword entries in the hash table. + * The hash table mac_by_ip4 is keyed via IP4 address and store the + * 6-byte MAC address directly in the hash table entry uword. + * This only works for 64-bit processor with 8-byte uword; which means + * this code *WILL NOT WORK* for a 32-bit prcessor with 4-byte uword. + */ +u32 +bd_add_del_ip_mac (u32 bd_index, + u8 * ip_addr, u8 * mac_addr, u8 is_ip6, u8 is_add) { - l2input_main_t * l2im = &l2input_main; - l2_bridge_domain_t * bd_cfg = l2input_bd_config_from_index (l2im, bd_index); + l2input_main_t *l2im = &l2input_main; + l2_bridge_domain_t *bd_cfg = l2input_bd_config_from_index (l2im, bd_index); u64 new_mac = *(u64 *) mac_addr; - u64 * old_mac; - u16 * mac16 = (u16 *) &new_mac; - - ASSERT (sizeof(uword) == sizeof(u64)); // make sure uword is 8 bytes - - mac16[3] = 0; // Clear last 2 unsed bytes of the 8-byte MAC address - if (is_ip6) { - // ip6_address_t ip6_addr = *(ip6_address_t *) ip_addr; - return 1; // not yet implemented - } else { - ip4_address_t ip4_addr = *(ip4_address_t *) ip_addr; - old_mac = (u64 *) hash_get (bd_cfg->mac_by_ip4, ip4_addr.as_u32); - if (is_add) { - if (old_mac && (*old_mac == new_mac)) return 0; // mac entry already exist - hash_set (bd_cfg->mac_by_ip4, ip4_addr.as_u32, new_mac); - } else { - if (old_mac && (*old_mac == new_mac)) { // mac entry match - hash_unset (bd_cfg->mac_by_ip4, ip4_addr.as_u32); // clear entry - } else { - return 1; - } + u64 *old_mac; + u16 *mac16 = (u16 *) & new_mac; + + ASSERT (sizeof (uword) == sizeof (u64)); /* make sure uword is 8 bytes */ + + mac16[3] = 0; // Clear last 2 unsed bytes of the 8-byte MAC address + if (is_ip6) + { + /* not yet implemented */ + return 1; + } + else + { + ip4_address_t ip4_addr = *(ip4_address_t *) ip_addr; + old_mac = (u64 *) hash_get (bd_cfg->mac_by_ip4, ip4_addr.as_u32); + if (is_add) + { + /* mac entry already exist? */ + if (old_mac && (*old_mac == new_mac)) + return 0; + hash_set (bd_cfg->mac_by_ip4, ip4_addr.as_u32, new_mac); + } + else + { + /* Mac entry match? */ + if (old_mac && (*old_mac == new_mac)) + { + /* clear entry */ + hash_unset (bd_cfg->mac_by_ip4, ip4_addr.as_u32); + } + else + { + return 1; + } + } + return 0; } - return 0; - } } -// set bridge-domain arp entry add/delete -// The CLI format is: -// set bridge-domain arp entry [del] +/** + set bridge-domain arp entry add/delete + The CLI format is: + set bridge-domain arp entry [del] +*/ static clib_error_t * bd_arp_entry (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) + unformat_input_t * input, vlib_cli_command_t * cmd) { - bd_main_t * bdm = &bd_main; - clib_error_t * error = 0; + bd_main_t *bdm = &bd_main; + clib_error_t *error = 0; u32 bd_index, bd_id; u8 is_add = 1; u8 is_ip6 = 0; u8 ip_addr[16]; u8 mac_addr[6]; - uword * p; + uword *p; - if (! unformat (input, "%d", &bd_id)) { - error = clib_error_return (0, "expecting bridge-domain id but got `%U'", - format_unformat_error, input); - goto done; - } + if (!unformat (input, "%d", &bd_id)) + { + error = clib_error_return (0, "expecting bridge-domain id but got `%U'", + format_unformat_error, input); + goto done; + } p = hash_get (bdm->bd_index_by_bd_id, bd_id); - if (p) bd_index = *p; - else return clib_error_return (0, "No such bridge domain %d", bd_id); - - if (unformat (input, "%U", unformat_ip4_address, ip_addr)) { - is_ip6 = 0; - } else if (unformat (input, "%U", unformat_ip6_address, ip_addr)) { - is_ip6 = 1; - } else { - error = clib_error_return (0, "expecting IP address but got `%U'", - format_unformat_error, input); - goto done; - } + if (p) + bd_index = *p; + else + return clib_error_return (0, "No such bridge domain %d", bd_id); - if (!unformat(input, "%U", unformat_ethernet_address, mac_addr)) { - error = clib_error_return (0, "expecting MAC address but got `%U'", - format_unformat_error, input); - goto done; - } - - if (unformat (input, "del")) { - is_add = 0; - } + if (unformat (input, "%U", unformat_ip4_address, ip_addr)) + { + is_ip6 = 0; + } + else if (unformat (input, "%U", unformat_ip6_address, ip_addr)) + { + is_ip6 = 1; + } + else + { + error = clib_error_return (0, "expecting IP address but got `%U'", + format_unformat_error, input); + goto done; + } - // set the bridge domain flagAdd IP-MAC entry into bridge domain - if (bd_add_del_ip_mac(bd_index, ip_addr, mac_addr, is_ip6, is_add)) { - error = clib_error_return (0, "MAC %s for IP %U and MAC %U failed", - is_add ? "add" : "del", - format_ip4_address, ip_addr, - format_ethernet_address, mac_addr); - } + if (!unformat (input, "%U", unformat_ethernet_address, mac_addr)) + { + error = clib_error_return (0, "expecting MAC address but got `%U'", + format_unformat_error, input); + goto done; + } + + if (unformat (input, "del")) + { + is_add = 0; + } + + /* set the bridge domain flagAdd IP-MAC entry into bridge domain */ + if (bd_add_del_ip_mac (bd_index, ip_addr, mac_addr, is_ip6, is_add)) + { + error = clib_error_return (0, "MAC %s for IP %U and MAC %U failed", + is_add ? "add" : "del", + format_ip4_address, ip_addr, + format_ethernet_address, mac_addr); + } done: return error; } +/* *INDENT-OFF* */ VLIB_CLI_COMMAND (bd_arp_entry_cli, static) = { .path = "set bridge-domain arp entry", .short_help = "set bridge-domain arp entry [del]", .function = bd_arp_entry, }; +/* *INDENT-ON* */ -u8* format_vtr(u8 * s, va_list *args) +u8 * +format_vtr (u8 * s, va_list * args) { - u32 vtr_op = va_arg (*args, u32); - u32 dot1q = va_arg (*args, u32); - u32 tag1 = va_arg (*args, u32); - u32 tag2 = va_arg (*args, u32); - switch (vtr_op) { + u32 vtr_op = va_arg (*args, u32); + u32 dot1q = va_arg (*args, u32); + u32 tag1 = va_arg (*args, u32); + u32 tag2 = va_arg (*args, u32); + switch (vtr_op) + { case L2_VTR_DISABLED: - return format (s, "none"); + return format (s, "none"); case L2_VTR_PUSH_1: - return format (s, "push-1 %s %d", dot1q? "dot1q":"dot1ad", tag1); + return format (s, "push-1 %s %d", dot1q ? "dot1q" : "dot1ad", tag1); case L2_VTR_PUSH_2: - return format (s, "push-2 %s %d %d", dot1q? "dot1q":"dot1ad", tag1, tag2); + return format (s, "push-2 %s %d %d", dot1q ? "dot1q" : "dot1ad", tag1, + tag2); case L2_VTR_POP_1: - return format (s, "pop-1"); + return format (s, "pop-1"); case L2_VTR_POP_2: - return format (s, "pop-2"); + return format (s, "pop-2"); case L2_VTR_TRANSLATE_1_1: - return format (s, "trans-1-1 %s %d", dot1q? "dot1q":"dot1ad", tag1); + return format (s, "trans-1-1 %s %d", dot1q ? "dot1q" : "dot1ad", tag1); case L2_VTR_TRANSLATE_1_2: - return format (s, "trans-1-2 %s %d %d",dot1q? "dot1q":"dot1ad", tag1, tag2); + return format (s, "trans-1-2 %s %d %d", dot1q ? "dot1q" : "dot1ad", + tag1, tag2); case L2_VTR_TRANSLATE_2_1: - return format (s, "trans-2-1 %s %d", dot1q? "dot1q":"dot1ad", tag1); + return format (s, "trans-2-1 %s %d", dot1q ? "dot1q" : "dot1ad", tag1); case L2_VTR_TRANSLATE_2_2: - return format (s, "trans-2-2 %s %d %d", dot1q? "dot1q":"dot1ad", tag1, tag2); + return format (s, "trans-2-2 %s %d %d", dot1q ? "dot1q" : "dot1ad", + tag1, tag2); default: - return format (s, "none"); + return format (s, "none"); } } -// show bridge-domain state -// The CLI format is: -// show bridge-domain [] +/** + show bridge-domain state + The CLI format is: + show bridge-domain [] +*/ static clib_error_t * -bd_show (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) +bd_show (vlib_main_t * vm, unformat_input_t * input, vlib_cli_command_t * cmd) { - vnet_main_t * vnm = vnet_get_main(); - bd_main_t * bdm = &bd_main; - clib_error_t * error = 0; + vnet_main_t *vnm = vnet_get_main (); + bd_main_t *bdm = &bd_main; + clib_error_t *error = 0; u32 bd_index = ~0; - l2_bridge_domain_t * bd_config; + l2_bridge_domain_t *bd_config; u32 start, end; u32 printed; u32 detail = 0; u32 intf = 0; u32 arp = 0; u32 bd_id = ~0; - uword * p; + uword *p; start = 0; - end = vec_len(l2input_main.bd_configs); - - if (unformat (input, "%d", &bd_id)) { - if (unformat (input, "detail")) detail = 1; - else if (unformat (input, "det")) detail = 1; - if (unformat (input, "int")) intf = 1; - if (unformat (input, "arp")) arp = 1; - - p = hash_get (bdm->bd_index_by_bd_id, bd_id); - if (p) bd_index = *p; - else return clib_error_return (0, "No such bridge domain %d", bd_id); - - vec_validate (l2input_main.bd_configs, bd_index); - bd_config = vec_elt_at_index(l2input_main.bd_configs, bd_index); - if (bd_is_valid (bd_config)) { - start = bd_index; - end = start + 1; - } else { - vlib_cli_output (vm, "bridge-domain %d not in use", bd_id); - goto done; - } - } + end = vec_len (l2input_main.bd_configs); - // Show all bridge-domains that have been initialized + if (unformat (input, "%d", &bd_id)) + { + if (unformat (input, "detail")) + detail = 1; + else if (unformat (input, "det")) + detail = 1; + if (unformat (input, "int")) + intf = 1; + if (unformat (input, "arp")) + arp = 1; + + p = hash_get (bdm->bd_index_by_bd_id, bd_id); + if (p) + bd_index = *p; + else + return clib_error_return (0, "No such bridge domain %d", bd_id); + + vec_validate (l2input_main.bd_configs, bd_index); + bd_config = vec_elt_at_index (l2input_main.bd_configs, bd_index); + if (bd_is_valid (bd_config)) + { + start = bd_index; + end = start + 1; + } + else + { + vlib_cli_output (vm, "bridge-domain %d not in use", bd_id); + goto done; + } + } + /* Show all bridge-domains that have been initialized */ printed = 0; - for (bd_index=start; bd_indexbd_id, bd_index, - bd_config->feature_bitmap & L2INPUT_FEAT_LEARN ? "on" : "off", - bd_config->feature_bitmap & L2INPUT_FEAT_FWD ? "on" : "off", - bd_config->feature_bitmap & L2INPUT_FEAT_UU_FLOOD ? "on" : "off", - bd_config->feature_bitmap & L2INPUT_FEAT_FLOOD ? "on" : "off", - bd_config->feature_bitmap & L2INPUT_FEAT_ARP_TERM ? "on" : "off", - format_vnet_sw_if_index_name_with_NA, vnm, bd_config->bvi_sw_if_index); - - if (detail || intf) { - // Show all member interfaces - - l2_flood_member_t * member; - u32 header = 0; - - vec_foreach(member, bd_config->members) { - u32 vtr_opr, dot1q, tag1, tag2; - if (!header) { - header = 1; - vlib_cli_output (vm, "\n%=30s%=7s%=5s%=5s%=30s", - "Interface", "Index", "SHG", "BVI","VLAN-Tag-Rewrite"); - } - l2vtr_get(vm, vnm, member->sw_if_index, &vtr_opr, &dot1q, &tag1, &tag2); - vlib_cli_output (vm, "%=30U%=7d%=5d%=5s%=30U", - format_vnet_sw_if_index_name, vnm, member->sw_if_index, - member->sw_if_index, - member->shg, - member->flags & L2_FLOOD_MEMBER_BVI ? "*" : "-", - format_vtr, vtr_opr, dot1q, tag1, tag2); + for (bd_index = start; bd_index < end; bd_index++) + { + bd_config = vec_elt_at_index (l2input_main.bd_configs, bd_index); + if (bd_is_valid (bd_config)) + { + if (!printed) + { + printed = 1; + vlib_cli_output (vm, + "%=5s %=7s %=10s %=10s %=10s %=10s %=10s %=14s", + "ID", "Index", "Learning", "U-Forwrd", + "UU-Flood", "Flooding", "ARP-Term", + "BVI-Intf"); + } + + vlib_cli_output (vm, + "%=5d %=7d %=10s %=10s %=10s %=10s %=10s %=14U", + bd_config->bd_id, bd_index, + bd_config->feature_bitmap & L2INPUT_FEAT_LEARN ? + "on" : "off", + bd_config->feature_bitmap & L2INPUT_FEAT_FWD ? "on" + : "off", + bd_config->feature_bitmap & L2INPUT_FEAT_UU_FLOOD ? + "on" : "off", + bd_config->feature_bitmap & L2INPUT_FEAT_FLOOD ? + "on" : "off", + bd_config->feature_bitmap & L2INPUT_FEAT_ARP_TERM ? + "on" : "off", format_vnet_sw_if_index_name_with_NA, + vnm, bd_config->bvi_sw_if_index); + + if (detail || intf) + { + /* Show all member interfaces */ + + l2_flood_member_t *member; + u32 header = 0; + + vec_foreach (member, bd_config->members) + { + u32 vtr_opr, dot1q, tag1, tag2; + if (!header) + { + header = 1; + vlib_cli_output (vm, "\n%=30s%=7s%=5s%=5s%=30s", + "Interface", "Index", "SHG", "BVI", + "VLAN-Tag-Rewrite"); + } + l2vtr_get (vm, vnm, member->sw_if_index, &vtr_opr, &dot1q, + &tag1, &tag2); + vlib_cli_output (vm, "%=30U%=7d%=5d%=5s%=30U", + format_vnet_sw_if_index_name, vnm, + member->sw_if_index, member->sw_if_index, + member->shg, + member->flags & L2_FLOOD_MEMBER_BVI ? "*" : + "-", format_vtr, vtr_opr, dot1q, tag1, tag2); + } + } + + if ((detail || arp) && + (bd_config->feature_bitmap & L2INPUT_FEAT_ARP_TERM)) + { + u32 ip4_addr; + u64 mac_addr; + vlib_cli_output (vm, + "\n IP4 to MAC table for ARP Termination"); + + /* *INDENT-OFF* */ + hash_foreach (ip4_addr, mac_addr, bd_config->mac_by_ip4, + ({ + vlib_cli_output (vm, "%=20U => %=20U", + format_ip4_address, &ip4_addr, + format_ethernet_address, &mac_addr); + })); + /* *INDENT-ON* */ + } } - } - - if ((detail || arp) && - (bd_config->feature_bitmap & L2INPUT_FEAT_ARP_TERM)) { - u32 ip4_addr; - u64 mac_addr; - vlib_cli_output (vm, "\n IP4 to MAC table for ARP Termination"); - hash_foreach (ip4_addr, mac_addr, bd_config->mac_by_ip4, ({ - vlib_cli_output (vm, "%=20U => %=20U", - format_ip4_address, &ip4_addr, - format_ethernet_address, &mac_addr); - })); - } } - } - if (!printed) { - vlib_cli_output (vm, "no bridge-domains in use"); - } + if (!printed) + { + vlib_cli_output (vm, "no bridge-domains in use"); + } - done: +done: return error; } +/* *INDENT-OFF* */ VLIB_CLI_COMMAND (bd_show_cli, static) = { .path = "show bridge-domain", .short_help = "show bridge-domain [bridge-domain-id [detail|int|arp]]", .function = bd_show, }; +/* *INDENT-ON* */ + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/vnet/vnet/l2/l2_bd.h b/vnet/vnet/l2/l2_bd.h index d84c8e802d5..82453eea153 100644 --- a/vnet/vnet/l2/l2_bd.h +++ b/vnet/vnet/l2/l2_bd.h @@ -21,75 +21,76 @@ #include #include -typedef struct { - // hash bd_id -> bd_index - uword * bd_index_by_bd_id; +typedef struct +{ + /* hash bd_id -> bd_index */ + uword *bd_index_by_bd_id; - // Busy bd_index bitmap - uword * bd_index_bitmap; + /* Busy bd_index bitmap */ + uword *bd_index_bitmap; - // convenience - vlib_main_t * vlib_main; - vnet_main_t * vnet_main; + /* convenience */ + vlib_main_t *vlib_main; + vnet_main_t *vnet_main; } bd_main_t; bd_main_t bd_main; -// Bridge domain member +/* Bridge domain member */ #define L2_FLOOD_MEMBER_NORMAL 0 #define L2_FLOOD_MEMBER_BVI 1 -typedef struct { - u32 sw_if_index; // the output L2 interface - u8 flags; // 0=normal, 1=bvi - u8 shg; // split horizon group number - u16 spare; +typedef struct +{ + u32 sw_if_index; /* the output L2 interface */ + u8 flags; /* 0=normal, 1=bvi */ + u8 shg; /* split horizon group number */ + u16 spare; } l2_flood_member_t; -// Per-bridge domain configuration +/* Per-bridge domain configuration */ -typedef struct { - u32 feature_bitmap; - // Contains bit enables for flooding, learning, and forwarding. - // All other feature bits should always be set. - - // identity of the bridge-domain's BVI interface - // set to ~0 if there is no BVI +typedef struct +{ + u32 feature_bitmap; + /* + * Contains bit enables for flooding, learning, and forwarding. + * All other feature bits should always be set. + * + * identity of the bridge-domain's BVI interface + * set to ~0 if there is no BVI + */ u32 bvi_sw_if_index; - // bridge domain id, not to be confused with bd_index + /* bridge domain id, not to be confused with bd_index */ u32 bd_id; - // Vector of members in the replication group - l2_flood_member_t * members; + /* Vector of members in the replication group */ + l2_flood_member_t *members; - // hash ip4/ip6 -> mac for arp termination + /* hash ip4/ip6 -> mac for arp termination */ uword *mac_by_ip4; uword *mac_by_ip6; } l2_bridge_domain_t; -// Return 1 if bridge domain has been initialized +/* Return 1 if bridge domain has been initialized */ always_inline u32 -bd_is_valid (l2_bridge_domain_t * bd_config) +bd_is_valid (l2_bridge_domain_t * bd_config) { return (bd_config->feature_bitmap != 0); } -// Init bridge domain if not done already -void -bd_validate (l2_bridge_domain_t * bd_config); +/* Init bridge domain if not done already */ +void bd_validate (l2_bridge_domain_t * bd_config); void -bd_add_member (l2_bridge_domain_t * bd_config, - l2_flood_member_t * member); +bd_add_member (l2_bridge_domain_t * bd_config, l2_flood_member_t * member); -u32 -bd_remove_member (l2_bridge_domain_t * bd_config, - u32 sw_if_index); +u32 bd_remove_member (l2_bridge_domain_t * bd_config, u32 sw_if_index); #define L2_LEARN (1<<0) @@ -98,11 +99,7 @@ bd_remove_member (l2_bridge_domain_t * bd_config, #define L2_UU_FLOOD (1<<3) #define L2_ARP_TERM (1<<4) -u32 -bd_set_flags (vlib_main_t * vm, - u32 bd_index, - u32 flags, - u32 enable); +u32 bd_set_flags (vlib_main_t * vm, u32 bd_index, u32 flags, u32 enable); /** * \brief Get or create a bridge domain. @@ -126,11 +123,15 @@ u32 bd_find_or_add_bd_index (bd_main_t * bdm, u32 bd_id); */ int bd_delete_bd_index (bd_main_t * bdm, u32 bd_id); -u32 bd_add_del_ip_mac(u32 bd_index, - u8 *ip_addr, - u8 *mac_addr, - u8 is_ip6, - u8 is_add); +u32 bd_add_del_ip_mac (u32 bd_index, + u8 * ip_addr, u8 * mac_addr, u8 is_ip6, u8 is_add); #endif +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/vnet/vnet/l2/l2_bvi.c b/vnet/vnet/l2/l2_bvi.c index 828e955617b..f239743a9c4 100644 --- a/vnet/vnet/l2/l2_bvi.c +++ b/vnet/vnet/l2/l2_bvi.c @@ -22,14 +22,19 @@ #include -// Call the L2 nodes that need the ethertype mapping +/* Call the L2 nodes that need the ethertype mapping */ void l2bvi_register_input_type (vlib_main_t * vm, - ethernet_type_t type, - u32 node_index) + ethernet_type_t type, u32 node_index) { l2fwd_register_input_type (vm, type, node_index); l2flood_register_input_type (vm, type, node_index); } - +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/vnet/vnet/l2/l2_bvi.h b/vnet/vnet/l2/l2_bvi.h index 54b7606e06a..dd1130a6c29 100644 --- a/vnet/vnet/l2/l2_bvi.h +++ b/vnet/vnet/l2/l2_bvi.h @@ -28,77 +28,90 @@ #define TO_BVI_ERR_BAD_MAC 1 #define TO_BVI_ERR_ETHERTYPE 2 -// Send a packet from L2 processing to L3 via the BVI interface. -// Set next0 to the proper L3 input node. -// Return an error if the packet isn't what we expect. +/** + * Send a packet from L2 processing to L3 via the BVI interface. + * Set next0 to the proper L3 input node. + * Return an error if the packet isn't what we expect. + */ -static_always_inline u32 +static_always_inline u32 l2_to_bvi (vlib_main_t * vlib_main, - vnet_main_t * vnet_main, - vlib_buffer_t * b0, - u32 bvi_sw_if_index, - next_by_ethertype_t * l3_next, - u32 * next0) + vnet_main_t * vnet_main, + vlib_buffer_t * b0, + u32 bvi_sw_if_index, next_by_ethertype_t * l3_next, u32 * next0) { u8 l2_len; u16 ethertype; - u8 * l3h; - ethernet_header_t * e0; - vnet_hw_interface_t * hi; + u8 *l3h; + ethernet_header_t *e0; + vnet_hw_interface_t *hi; e0 = vlib_buffer_get_current (b0); hi = vnet_get_sup_hw_interface (vnet_main, bvi_sw_if_index); - // Perform L3 my-mac filter - if ((!ethernet_address_cast(e0->dst_address)) && - (!eth_mac_equal((u8 *)e0, hi->hw_address))) { + /* Perform L3 my-mac filter */ + if ((!ethernet_address_cast (e0->dst_address)) && + (!eth_mac_equal ((u8 *) e0, hi->hw_address))) + { return TO_BVI_ERR_BAD_MAC; - } + } - // Save L2 header position which may be changed due to packet replication + /* Save L2 header position which may be changed due to packet replication */ vnet_buffer (b0)->ethernet.start_of_ethernet_header = b0->current_data; - // Strip L2 header - l2_len = vnet_buffer(b0)->l2.l2_len; + /* Strip L2 header */ + l2_len = vnet_buffer (b0)->l2.l2_len; vlib_buffer_advance (b0, l2_len); l3h = vlib_buffer_get_current (b0); - ethertype = clib_net_to_host_u16(*(u16 *)(l3h - 2)); - - // Set the input interface to be the BVI interface - vnet_buffer(b0)->sw_if_index[VLIB_RX] = bvi_sw_if_index; - vnet_buffer(b0)->sw_if_index[VLIB_TX] = ~0; - - // Go to appropriate L3 input node - if (ethertype == ETHERNET_TYPE_IP4) { - *next0 = l3_next->input_next_ip4; - } else if (ethertype == ETHERNET_TYPE_IP6) { - *next0 = l3_next->input_next_ip6; - } else { - // uncommon ethertype, check table - u32 i0; - - i0 = sparse_vec_index (l3_next->input_next_by_type, ethertype); - *next0 = vec_elt (l3_next->input_next_by_type, i0); - - if (i0 == SPARSE_VEC_INVALID_INDEX) { - return TO_BVI_ERR_ETHERTYPE; - } - } - - // increment BVI RX interface stat - vlib_increment_combined_counter - (vnet_main->interface_main.combined_sw_if_counters - + VNET_INTERFACE_COUNTER_RX, - vlib_main->cpu_index, - vnet_buffer(b0)->sw_if_index[VLIB_RX], - 1, - vlib_buffer_length_in_chain (vlib_main, b0)); + ethertype = clib_net_to_host_u16 (*(u16 *) (l3h - 2)); + + /* Set the input interface to be the BVI interface */ + vnet_buffer (b0)->sw_if_index[VLIB_RX] = bvi_sw_if_index; + vnet_buffer (b0)->sw_if_index[VLIB_TX] = ~0; + + /* Go to appropriate L3 input node */ + if (ethertype == ETHERNET_TYPE_IP4) + { + *next0 = l3_next->input_next_ip4; + } + else if (ethertype == ETHERNET_TYPE_IP6) + { + *next0 = l3_next->input_next_ip6; + } + else + { + /* uncommon ethertype, check table */ + u32 i0; + + i0 = sparse_vec_index (l3_next->input_next_by_type, ethertype); + *next0 = vec_elt (l3_next->input_next_by_type, i0); + + if (i0 == SPARSE_VEC_INVALID_INDEX) + { + return TO_BVI_ERR_ETHERTYPE; + } + } + + /* increment BVI RX interface stat */ + vlib_increment_combined_counter + (vnet_main->interface_main.combined_sw_if_counters + + VNET_INTERFACE_COUNTER_RX, + vlib_main->cpu_index, + vnet_buffer (b0)->sw_if_index[VLIB_RX], + 1, vlib_buffer_length_in_chain (vlib_main, b0)); return TO_BVI_ERR_OK; } void l2bvi_register_input_type (vlib_main_t * vm, - ethernet_type_t type, - u32 node_index); + ethernet_type_t type, u32 node_index); #endif + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/vnet/vnet/l2/l2_classify.c b/vnet/vnet/l2/l2_classify.c index 765bc686c05..721cf2066c1 100644 --- a/vnet/vnet/l2/l2_classify.c +++ b/vnet/vnet/l2/l2_classify.c @@ -19,28 +19,32 @@ #include #include -typedef struct { - /* per-pkt trace data */ +typedef struct +{ + /* per-pkt trace data */ u32 sw_if_index; u32 next_index; u32 table_index; u32 session_offset; } l2_classify_trace_t; -typedef struct { - vnet_classify_main_t * vcm; - l2_classify_main_t * l2cm; +typedef struct +{ + vnet_classify_main_t *vcm; + l2_classify_main_t *l2cm; } l2_classify_runtime_t; /* packet trace format function */ -static u8 * format_l2_classify_trace (u8 * s, va_list * args) +static u8 * +format_l2_classify_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 *); - l2_classify_trace_t * t = va_arg (*args, l2_classify_trace_t *); - + l2_classify_trace_t *t = va_arg (*args, l2_classify_trace_t *); + s = format (s, "l2-classify: sw_if_index %d, table %d, offset %x, next %d", - t->sw_if_index, t->table_index, t->session_offset, t->next_index); + t->sw_if_index, t->table_index, t->session_offset, + t->next_index); return s; } @@ -54,14 +58,15 @@ _(HIT, "Classify hits") \ _(CHAIN_HIT, "Classify hits after chain walk") \ _(DROP, "L2 Classify Drops") -typedef enum { +typedef enum +{ #define _(sym,str) L2_CLASSIFY_ERROR_##sym, foreach_l2_classify_error #undef _ - L2_CLASSIFY_N_ERROR, + L2_CLASSIFY_N_ERROR, } l2_classify_error_t; -static char * l2_classify_error_strings[] = { +static char *l2_classify_error_strings[] = { #define _(sym,string) string, foreach_l2_classify_error #undef _ @@ -69,21 +74,20 @@ static char * l2_classify_error_strings[] = { static uword l2_classify_node_fn (vlib_main_t * vm, - vlib_node_runtime_t * node, - vlib_frame_t * frame) + vlib_node_runtime_t * node, vlib_frame_t * frame) { - u32 n_left_from, * from, * to_next; + u32 n_left_from, *from, *to_next; l2_classify_next_t next_index; - l2_classify_main_t * cm = &l2_classify_main; - vnet_classify_main_t * vcm = cm->vnet_classify_main; - l2_classify_runtime_t * rt = (l2_classify_runtime_t *)node->runtime_data; + l2_classify_main_t *cm = &l2_classify_main; + vnet_classify_main_t *vcm = cm->vnet_classify_main; + l2_classify_runtime_t *rt = (l2_classify_runtime_t *) node->runtime_data; u32 feature_bitmap; u32 hits = 0; u32 misses = 0; u32 chain_hits = 0; f64 now; - - now = vlib_time_now(vm); + + now = vlib_time_now (vm); n_left_from = frame->n_vectors; from = vlib_frame_vector_args (frame); @@ -92,30 +96,30 @@ l2_classify_node_fn (vlib_main_t * vm, while (n_left_from > 2) { - vlib_buffer_t * b0, * b1; + vlib_buffer_t *b0, *b1; u32 bi0, bi1; - ethernet_header_t * h0, * h1; + ethernet_header_t *h0, *h1; u32 sw_if_index0, sw_if_index1; u16 type0, type1; int type_index0, type_index1; - vnet_classify_table_t * t0, * t1; + vnet_classify_table_t *t0, *t1; u32 table_index0, table_index1; u64 hash0, hash1; /* prefetch next iteration */ - { - vlib_buffer_t * p1, * p2; - - p1 = vlib_get_buffer (vm, from[1]); - p2 = vlib_get_buffer (vm, from[2]); - - vlib_prefetch_buffer_header (p1, STORE); - CLIB_PREFETCH (p1->data, CLIB_CACHE_LINE_BYTES, STORE); - vlib_prefetch_buffer_header (p2, STORE); - CLIB_PREFETCH (p2->data, CLIB_CACHE_LINE_BYTES, STORE); - } - + { + vlib_buffer_t *p1, *p2; + + p1 = vlib_get_buffer (vm, from[1]); + p2 = vlib_get_buffer (vm, from[2]); + + vlib_prefetch_buffer_header (p1, STORE); + CLIB_PREFETCH (p1->data, CLIB_CACHE_LINE_BYTES, STORE); + vlib_prefetch_buffer_header (p2, STORE); + CLIB_PREFETCH (p2->data, CLIB_CACHE_LINE_BYTES, STORE); + } + bi0 = from[0]; b0 = vlib_get_buffer (vm, bi0); h0 = vlib_buffer_get_current (b0); @@ -123,54 +127,54 @@ l2_classify_node_fn (vlib_main_t * vm, bi1 = from[1]; b1 = vlib_get_buffer (vm, bi1); h1 = vlib_buffer_get_current (b1); - - sw_if_index0 = vnet_buffer(b0)->sw_if_index[VLIB_RX]; - vnet_buffer(b0)->l2_classify.table_index = ~0; - sw_if_index1 = vnet_buffer(b1)->sw_if_index[VLIB_RX]; - vnet_buffer(b1)->l2_classify.table_index = ~0; - + sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX]; + vnet_buffer (b0)->l2_classify.table_index = ~0; + + sw_if_index1 = vnet_buffer (b1)->sw_if_index[VLIB_RX]; + vnet_buffer (b1)->l2_classify.table_index = ~0; + /* Select classifier table based on ethertype */ type0 = clib_net_to_host_u16 (h0->type); type1 = clib_net_to_host_u16 (h1->type); - type_index0 = (type0 == ETHERNET_TYPE_IP4) - ? L2_CLASSIFY_TABLE_IP4 : L2_CLASSIFY_TABLE_OTHER; - type_index0 = (type0 == ETHERNET_TYPE_IP6) - ? L2_CLASSIFY_TABLE_IP6 : type_index0; - - type_index1 = (type1 == ETHERNET_TYPE_IP4) - ? L2_CLASSIFY_TABLE_IP4 : L2_CLASSIFY_TABLE_OTHER; - type_index1 = (type1 == ETHERNET_TYPE_IP6) - ? L2_CLASSIFY_TABLE_IP6 : type_index1; - - vnet_buffer(b0)->l2_classify.table_index = - table_index0 = - rt->l2cm->classify_table_index_by_sw_if_index - [type_index0][sw_if_index0]; - + type_index0 = (type0 == ETHERNET_TYPE_IP4) + ? L2_CLASSIFY_TABLE_IP4 : L2_CLASSIFY_TABLE_OTHER; + type_index0 = (type0 == ETHERNET_TYPE_IP6) + ? L2_CLASSIFY_TABLE_IP6 : type_index0; + + type_index1 = (type1 == ETHERNET_TYPE_IP4) + ? L2_CLASSIFY_TABLE_IP4 : L2_CLASSIFY_TABLE_OTHER; + type_index1 = (type1 == ETHERNET_TYPE_IP6) + ? L2_CLASSIFY_TABLE_IP6 : type_index1; + + vnet_buffer (b0)->l2_classify.table_index = + table_index0 = + rt->l2cm->classify_table_index_by_sw_if_index + [type_index0][sw_if_index0]; + if (table_index0 != ~0) - { - t0 = pool_elt_at_index (vcm->tables, table_index0); - - vnet_buffer(b0)->l2_classify.hash = hash0 = - vnet_classify_hash_packet (t0, (u8 *) h0); - vnet_classify_prefetch_bucket (t0, hash0); - } - - vnet_buffer(b1)->l2_classify.table_index = - table_index1 = - rt->l2cm->classify_table_index_by_sw_if_index - [type_index1][sw_if_index1]; - + { + t0 = pool_elt_at_index (vcm->tables, table_index0); + + vnet_buffer (b0)->l2_classify.hash = hash0 = + vnet_classify_hash_packet (t0, (u8 *) h0); + vnet_classify_prefetch_bucket (t0, hash0); + } + + vnet_buffer (b1)->l2_classify.table_index = + table_index1 = + rt->l2cm->classify_table_index_by_sw_if_index + [type_index1][sw_if_index1]; + if (table_index1 != ~0) - { - t1 = pool_elt_at_index (vcm->tables, table_index1); - - vnet_buffer(b1)->l2_classify.hash = hash1 = - vnet_classify_hash_packet (t1, (u8 *) h1); - vnet_classify_prefetch_bucket (t1, hash1); - } + { + t1 = pool_elt_at_index (vcm->tables, table_index1); + + vnet_buffer (b1)->l2_classify.hash = hash1 = + vnet_classify_hash_packet (t1, (u8 *) h1); + vnet_classify_prefetch_bucket (t1, hash1); + } from += 2; n_left_from -= 2; @@ -178,47 +182,47 @@ l2_classify_node_fn (vlib_main_t * vm, while (n_left_from > 0) { - vlib_buffer_t * b0; + vlib_buffer_t *b0; u32 bi0; - ethernet_header_t * h0; + ethernet_header_t *h0; u32 sw_if_index0; u16 type0; u32 type_index0; - vnet_classify_table_t * t0; + vnet_classify_table_t *t0; u32 table_index0; u64 hash0; bi0 = from[0]; b0 = vlib_get_buffer (vm, bi0); h0 = vlib_buffer_get_current (b0); - - sw_if_index0 = vnet_buffer(b0)->sw_if_index[VLIB_RX]; - vnet_buffer(b0)->l2_classify.table_index = ~0; - + + sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX]; + vnet_buffer (b0)->l2_classify.table_index = ~0; + /* Select classifier table based on ethertype */ type0 = clib_net_to_host_u16 (h0->type); - - type_index0 = (type0 == ETHERNET_TYPE_IP4) - ? L2_CLASSIFY_TABLE_IP4 : L2_CLASSIFY_TABLE_OTHER; - type_index0 = (type0 == ETHERNET_TYPE_IP6) - ? L2_CLASSIFY_TABLE_IP6 : type_index0; - - vnet_buffer(b0)->l2_classify.table_index = - table_index0 = rt->l2cm->classify_table_index_by_sw_if_index - [type_index0][sw_if_index0]; - + + type_index0 = (type0 == ETHERNET_TYPE_IP4) + ? L2_CLASSIFY_TABLE_IP4 : L2_CLASSIFY_TABLE_OTHER; + type_index0 = (type0 == ETHERNET_TYPE_IP6) + ? L2_CLASSIFY_TABLE_IP6 : type_index0; + + vnet_buffer (b0)->l2_classify.table_index = + table_index0 = rt->l2cm->classify_table_index_by_sw_if_index + [type_index0][sw_if_index0]; + if (table_index0 != ~0) - { - t0 = pool_elt_at_index (vcm->tables, table_index0); - - vnet_buffer(b0)->l2_classify.hash = hash0 = - vnet_classify_hash_packet (t0, (u8 *) h0); - vnet_classify_prefetch_bucket (t0, hash0); - } + { + t0 = pool_elt_at_index (vcm->tables, table_index0); + + vnet_buffer (b0)->l2_classify.hash = hash0 = + vnet_classify_hash_packet (t0, (u8 *) h0); + vnet_classify_prefetch_bucket (t0, hash0); + } from++; n_left_from--; } - + next_index = node->cached_next_index; from = vlib_frame_vector_args (frame); n_left_from = frame->n_vectors; @@ -227,43 +231,42 @@ l2_classify_node_fn (vlib_main_t * vm, { u32 n_left_to_next; - vlib_get_next_frame (vm, node, next_index, - to_next, n_left_to_next); + vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next); /* Not enough load/store slots to dual loop... */ while (n_left_from > 0 && n_left_to_next > 0) { - u32 bi0; - vlib_buffer_t * b0; - u32 next0 = L2_CLASSIFY_NEXT_ETHERNET_INPUT; - ethernet_header_t * h0; - u32 table_index0; - u64 hash0; - vnet_classify_table_t * t0; - vnet_classify_entry_t * e0; - - if (PREDICT_TRUE (n_left_from > 2)) - { - vlib_buffer_t * p2 = vlib_get_buffer(vm, from[2]); - u64 phash2; - u32 table_index2; - vnet_classify_table_t * tp2; - - /* - * Prefetch table entry two ahead. Buffer / data - * were prefetched above... - */ - table_index2 = vnet_buffer(p2)->l2_classify.table_index; - - if (PREDICT_TRUE (table_index2 != ~0)) - { - tp2 = pool_elt_at_index (vcm->tables, table_index2); - phash2 = vnet_buffer(p2)->l2_classify.hash; - vnet_classify_prefetch_entry (tp2, phash2); - } - } - - /* speculatively enqueue b0 to the current next frame */ + u32 bi0; + vlib_buffer_t *b0; + u32 next0 = L2_CLASSIFY_NEXT_ETHERNET_INPUT; + ethernet_header_t *h0; + u32 table_index0; + u64 hash0; + vnet_classify_table_t *t0; + vnet_classify_entry_t *e0; + + if (PREDICT_TRUE (n_left_from > 2)) + { + vlib_buffer_t *p2 = vlib_get_buffer (vm, from[2]); + u64 phash2; + u32 table_index2; + vnet_classify_table_t *tp2; + + /* + * Prefetch table entry two ahead. Buffer / data + * were prefetched above... + */ + table_index2 = vnet_buffer (p2)->l2_classify.table_index; + + if (PREDICT_TRUE (table_index2 != ~0)) + { + tp2 = pool_elt_at_index (vcm->tables, table_index2); + phash2 = vnet_buffer (p2)->l2_classify.hash; + vnet_classify_prefetch_entry (tp2, phash2); + } + } + + /* speculatively enqueue b0 to the current next frame */ bi0 = from[0]; to_next[0] = bi0; from += 1; @@ -272,89 +275,90 @@ l2_classify_node_fn (vlib_main_t * vm, n_left_to_next -= 1; b0 = vlib_get_buffer (vm, bi0); - h0 = vlib_buffer_get_current(b0); - table_index0 = vnet_buffer(b0)->l2_classify.table_index; - e0 = 0; - vnet_buffer(b0)->l2_classify.opaque_index = ~0; - - if (PREDICT_TRUE(table_index0 != ~0)) - { - hash0 = vnet_buffer(b0)->l2_classify.hash; - t0 = pool_elt_at_index (vcm->tables, table_index0); - - e0 = vnet_classify_find_entry (t0, (u8 *) h0, - hash0, now); - if (e0) - { - vnet_buffer(b0)->l2_classify.opaque_index - = e0->opaque_index; - vlib_buffer_advance (b0, e0->advance); - next0 = (e0->next_index < L2_CLASSIFY_N_NEXT)? - e0->next_index:next0; - hits++; - } - else - { - while (1) - { - if (t0->next_table_index != ~0) - t0 = pool_elt_at_index (vcm->tables, - t0->next_table_index); - else - { - next0 = (t0->miss_next_index < L2_CLASSIFY_N_NEXT)? - t0->miss_next_index:next0; - misses++; - break; - } - - hash0 = vnet_classify_hash_packet (t0, (u8 *) h0); - e0 = vnet_classify_find_entry (t0, (u8 *) h0, hash0, now); - if (e0) - { - vnet_buffer(b0)->l2_classify.opaque_index - = e0->opaque_index; - vlib_buffer_advance (b0, e0->advance); - next0 = (e0->next_index < L2_CLASSIFY_N_NEXT)? - e0->next_index:next0; - hits++; - chain_hits++; - break; - } - } - } - } - - if (PREDICT_FALSE(next0 == 0)) - b0->error = node->errors[L2_CLASSIFY_ERROR_DROP]; - - if (PREDICT_FALSE (next0 == ~0)) - { - - // Remove ourself from the feature bitmap - feature_bitmap = vnet_buffer(b0)->l2.feature_bitmap - & ~L2INPUT_FEAT_CLASSIFY; - - // save for next feature graph nodes - vnet_buffer(b0)->l2.feature_bitmap = feature_bitmap; - - // Determine the next node - next0 = feat_bitmap_get_next_node_index(cm->feat_next_node_index, - feature_bitmap); - } - - if (PREDICT_FALSE((node->flags & VLIB_NODE_FLAG_TRACE) - && (b0->flags & VLIB_BUFFER_IS_TRACED))) - { - l2_classify_trace_t *t = - vlib_add_trace (vm, node, b0, sizeof (*t)); - t->sw_if_index = vnet_buffer(b0)->sw_if_index[VLIB_RX]; - t->table_index = table_index0; - t->next_index = next0; - t->session_offset = e0 ? vnet_classify_get_offset (t0, e0) : 0; - } - - /* verify speculative enqueue, maybe switch current next frame */ + h0 = vlib_buffer_get_current (b0); + table_index0 = vnet_buffer (b0)->l2_classify.table_index; + e0 = 0; + vnet_buffer (b0)->l2_classify.opaque_index = ~0; + + if (PREDICT_TRUE (table_index0 != ~0)) + { + hash0 = vnet_buffer (b0)->l2_classify.hash; + t0 = pool_elt_at_index (vcm->tables, table_index0); + + e0 = vnet_classify_find_entry (t0, (u8 *) h0, hash0, now); + if (e0) + { + vnet_buffer (b0)->l2_classify.opaque_index + = e0->opaque_index; + vlib_buffer_advance (b0, e0->advance); + next0 = (e0->next_index < L2_CLASSIFY_N_NEXT) ? + e0->next_index : next0; + hits++; + } + else + { + while (1) + { + if (t0->next_table_index != ~0) + t0 = pool_elt_at_index (vcm->tables, + t0->next_table_index); + else + { + next0 = (t0->miss_next_index < L2_CLASSIFY_N_NEXT) ? + t0->miss_next_index : next0; + misses++; + break; + } + + hash0 = vnet_classify_hash_packet (t0, (u8 *) h0); + e0 = + vnet_classify_find_entry (t0, (u8 *) h0, hash0, now); + if (e0) + { + vnet_buffer (b0)->l2_classify.opaque_index + = e0->opaque_index; + vlib_buffer_advance (b0, e0->advance); + next0 = (e0->next_index < L2_CLASSIFY_N_NEXT) ? + e0->next_index : next0; + hits++; + chain_hits++; + break; + } + } + } + } + + if (PREDICT_FALSE (next0 == 0)) + b0->error = node->errors[L2_CLASSIFY_ERROR_DROP]; + + if (PREDICT_FALSE (next0 == ~0)) + { + + // Remove ourself from the feature bitmap + feature_bitmap = vnet_buffer (b0)->l2.feature_bitmap + & ~L2INPUT_FEAT_CLASSIFY; + + // save for next feature graph nodes + vnet_buffer (b0)->l2.feature_bitmap = feature_bitmap; + + // Determine the next node + next0 = + feat_bitmap_get_next_node_index (cm->feat_next_node_index, + feature_bitmap); + } + + if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE) + && (b0->flags & VLIB_BUFFER_IS_TRACED))) + { + l2_classify_trace_t *t = + vlib_add_trace (vm, node, b0, sizeof (*t)); + t->sw_if_index = vnet_buffer (b0)->sw_if_index[VLIB_RX]; + t->table_index = table_index0; + t->next_index = next0; + t->session_offset = e0 ? vnet_classify_get_offset (t0, e0) : 0; + } + + /* verify speculative enqueue, maybe switch current next frame */ vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next, n_left_to_next, bi0, next0); @@ -363,25 +367,23 @@ l2_classify_node_fn (vlib_main_t * vm, vlib_put_next_frame (vm, node, next_index, n_left_to_next); } - vlib_node_increment_counter (vm, node->node_index, - L2_CLASSIFY_ERROR_MISS, - misses); - vlib_node_increment_counter (vm, node->node_index, - L2_CLASSIFY_ERROR_HIT, - hits); - vlib_node_increment_counter (vm, node->node_index, - L2_CLASSIFY_ERROR_CHAIN_HIT, - chain_hits); + vlib_node_increment_counter (vm, node->node_index, + L2_CLASSIFY_ERROR_MISS, misses); + vlib_node_increment_counter (vm, node->node_index, + L2_CLASSIFY_ERROR_HIT, hits); + vlib_node_increment_counter (vm, node->node_index, + L2_CLASSIFY_ERROR_CHAIN_HIT, chain_hits); return frame->n_vectors; } +/* *INDENT-OFF* */ VLIB_REGISTER_NODE (l2_classify_node) = { .function = l2_classify_node_fn, .name = "l2-classify", .vector_size = sizeof (u32), .format_trace = format_l2_classify_trace, .type = VLIB_NODE_TYPE_INTERNAL, - + .n_errors = ARRAY_LEN(l2_classify_error_strings), .error_strings = l2_classify_error_strings, @@ -398,26 +400,26 @@ VLIB_REGISTER_NODE (l2_classify_node) = { [L2_CLASSIFY_NEXT_LI] = "li-hit", }, }; +/* *INDENT-ON* */ VLIB_NODE_FUNCTION_MULTIARCH (l2_classify_node, l2_classify_node_fn) - -clib_error_t *l2_classify_init (vlib_main_t *vm) + clib_error_t *l2_classify_init (vlib_main_t * vm) { - l2_classify_main_t * cm = &l2_classify_main; - l2_classify_runtime_t * rt; + l2_classify_main_t *cm = &l2_classify_main; + l2_classify_runtime_t *rt; rt = vlib_node_get_runtime_data (vm, l2_classify_node.index); - + cm->vlib_main = vm; - cm->vnet_main = vnet_get_main(); + cm->vnet_main = vnet_get_main (); cm->vnet_classify_main = &vnet_classify_main; - // Initialize the feature next-node indexes - feat_bitmap_init_next_nodes(vm, - l2_classify_node.index, - L2INPUT_N_FEAT, - l2input_get_feat_names(), - cm->feat_next_node_index); + /* Initialize the feature next-node indexes */ + feat_bitmap_init_next_nodes (vm, + l2_classify_node.index, + L2INPUT_N_FEAT, + l2input_get_feat_names (), + cm->feat_next_node_index); rt->l2cm = cm; rt->vcm = cm->vnet_classify_main; @@ -427,27 +429,25 @@ clib_error_t *l2_classify_init (vlib_main_t *vm) VLIB_INIT_FUNCTION (l2_classify_init); -void vnet_l2_classify_enable_disable (u32 sw_if_index, - int enable_disable) +void +vnet_l2_classify_enable_disable (u32 sw_if_index, int enable_disable) { - vlib_main_t * vm = vlib_get_main(); - vnet_main_t * vnm = vnet_get_main(); - + vlib_main_t *vm = vlib_get_main (); + vnet_main_t *vnm = vnet_get_main (); + if (enable_disable) - set_int_l2_mode (vm, vnm, MODE_L2_CLASSIFY, sw_if_index, - 0, 0, 0, 0); + set_int_l2_mode (vm, vnm, MODE_L2_CLASSIFY, sw_if_index, 0, 0, 0, 0); else - set_int_l2_mode (vm, vnm, MODE_L3, sw_if_index, - 0, 0, 0, 0); + set_int_l2_mode (vm, vnm, MODE_L3, sw_if_index, 0, 0, 0, 0); } -int vnet_l2_classify_set_tables (u32 sw_if_index, - u32 ip4_table_index, - u32 ip6_table_index, - u32 other_table_index) +int +vnet_l2_classify_set_tables (u32 sw_if_index, + u32 ip4_table_index, + u32 ip6_table_index, u32 other_table_index) { - l2_classify_main_t * cm = &l2_classify_main; - vnet_classify_main_t * vcm = cm->vnet_classify_main; + l2_classify_main_t *cm = &l2_classify_main; + vnet_classify_main_t *vcm = cm->vnet_classify_main; /* Assume that we've validated sw_if_index in the API layer */ @@ -458,29 +458,29 @@ int vnet_l2_classify_set_tables (u32 sw_if_index, if (ip6_table_index != ~0 && pool_is_free_index (vcm->tables, ip6_table_index)) return VNET_API_ERROR_NO_SUCH_TABLE2; - + if (other_table_index != ~0 && pool_is_free_index (vcm->tables, other_table_index)) return VNET_API_ERROR_NO_SUCH_TABLE3; - - vec_validate - (cm->classify_table_index_by_sw_if_index[L2_CLASSIFY_TABLE_IP4], + + vec_validate + (cm->classify_table_index_by_sw_if_index[L2_CLASSIFY_TABLE_IP4], sw_if_index); - - vec_validate - (cm->classify_table_index_by_sw_if_index[L2_CLASSIFY_TABLE_IP6], + + vec_validate + (cm->classify_table_index_by_sw_if_index[L2_CLASSIFY_TABLE_IP6], sw_if_index); - - vec_validate - (cm->classify_table_index_by_sw_if_index[L2_CLASSIFY_TABLE_OTHER], + + vec_validate + (cm->classify_table_index_by_sw_if_index[L2_CLASSIFY_TABLE_OTHER], sw_if_index); cm->classify_table_index_by_sw_if_index[L2_CLASSIFY_TABLE_IP4] [sw_if_index] = ip4_table_index; - + cm->classify_table_index_by_sw_if_index[L2_CLASSIFY_TABLE_IP6] [sw_if_index] = ip6_table_index; - + cm->classify_table_index_by_sw_if_index[L2_CLASSIFY_TABLE_OTHER] [sw_if_index] = other_table_index; @@ -489,66 +489,75 @@ int vnet_l2_classify_set_tables (u32 sw_if_index, static clib_error_t * int_l2_classify_command_fn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) + unformat_input_t * input, + vlib_cli_command_t * cmd) { - vnet_main_t * vnm = vnet_get_main(); + vnet_main_t *vnm = vnet_get_main (); u32 sw_if_index = ~0; u32 ip4_table_index = ~0; u32 ip6_table_index = ~0; u32 other_table_index = ~0; int rv; - while (unformat_check_input(input) != UNFORMAT_END_OF_INPUT) + while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) { - if (unformat (input, "intfc %U", unformat_vnet_sw_interface, - vnm, &sw_if_index)) - ; + if (unformat (input, "intfc %U", unformat_vnet_sw_interface, + vnm, &sw_if_index)) + ; else if (unformat (input, "ip4-table %d", &ip4_table_index)) - ; + ; else if (unformat (input, "ip6-table %d", &ip6_table_index)) - ; + ; else if (unformat (input, "other-table %d", &other_table_index)) - ; + ; else - break; + break; } if (sw_if_index == ~0) return clib_error_return (0, "interface must be specified"); - - if (ip4_table_index == ~0 && ip6_table_index == ~0 + + if (ip4_table_index == ~0 && ip6_table_index == ~0 && other_table_index == ~0) { vlib_cli_output (vm, "L2 classification disabled"); - vnet_l2_classify_enable_disable (sw_if_index, 0 /* enable */); + vnet_l2_classify_enable_disable (sw_if_index, 0 /* enable */ ); return 0; } - rv = vnet_l2_classify_set_tables (sw_if_index, ip4_table_index, - ip6_table_index, other_table_index); - switch(rv) + rv = vnet_l2_classify_set_tables (sw_if_index, ip4_table_index, + ip6_table_index, other_table_index); + switch (rv) { case 0: - vnet_l2_classify_enable_disable (sw_if_index, 1 /* enable */); + vnet_l2_classify_enable_disable (sw_if_index, 1 /* enable */ ); break; default: - return clib_error_return (0, "vnet_l2_classify_set_tables: %d", - rv); + return clib_error_return (0, "vnet_l2_classify_set_tables: %d", rv); break; } return 0; } +/* *INDENT-OFF* */ VLIB_CLI_COMMAND (int_l2_classify_cli, static) = { .path = "set interface l2 classify", - .short_help = + .short_help = "set interface l2 classify intfc [ip4-table ]\n" " [ip6-table ] [other-table ]", .function = int_l2_classify_command_fn, }; +/* *INDENT-ON* */ + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/vnet/vnet/l2/l2_classify.h b/vnet/vnet/l2/l2_classify.h index 74e9d91c1ad..f66e5209c88 100644 --- a/vnet/vnet/l2/l2_classify.h +++ b/vnet/vnet/l2/l2_classify.h @@ -33,7 +33,8 @@ #include -typedef enum { +typedef enum +{ L2_CLASSIFY_NEXT_DROP, L2_CLASSIFY_NEXT_ETHERNET_INPUT, L2_CLASSIFY_NEXT_IP4_INPUT, @@ -42,35 +43,44 @@ typedef enum { L2_CLASSIFY_N_NEXT, } l2_classify_next_t; -typedef enum { +typedef enum +{ L2_CLASSIFY_TABLE_IP4, L2_CLASSIFY_TABLE_IP6, L2_CLASSIFY_TABLE_OTHER, L2_CLASSIFY_N_TABLES, } l2_classify_table_id_t; -typedef struct { +typedef struct +{ - // Next nodes for each feature + /* Next nodes for each feature */ u32 feat_next_node_index[32]; /* Per-address-family classifier table vectors */ - u32 * classify_table_index_by_sw_if_index [L2_CLASSIFY_N_TABLES]; + u32 *classify_table_index_by_sw_if_index[L2_CLASSIFY_N_TABLES]; /* convenience variables */ - vlib_main_t * vlib_main; - vnet_main_t * vnet_main; - vnet_classify_main_t * vnet_classify_main; + vlib_main_t *vlib_main; + vnet_main_t *vnet_main; + vnet_classify_main_t *vnet_classify_main; } l2_classify_main_t; l2_classify_main_t l2_classify_main; extern vlib_node_registration_t l2_classify_node; -void vnet_l2_classify_enable_disable (u32 sw_if_index, - int enable_disable); +void vnet_l2_classify_enable_disable (u32 sw_if_index, int enable_disable); -int vnet_l2_classify_set_tables (u32 sw_if_index, u32 ip4_table_index, - u32 ip6_table_index, u32 other_table_index); +int vnet_l2_classify_set_tables (u32 sw_if_index, u32 ip4_table_index, + u32 ip6_table_index, u32 other_table_index); #endif /* __included_vnet_l2_classify_h__ */ + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/vnet/vnet/l2/l2_efp_filter.c b/vnet/vnet/l2/l2_efp_filter.c index 17b7eb3fcd6..221db9abc73 100644 --- a/vnet/vnet/l2/l2_efp_filter.c +++ b/vnet/vnet/l2/l2_efp_filter.c @@ -26,39 +26,43 @@ #include #include -typedef struct { +typedef struct +{ - // Next nodes for features and output interfaces + /* Next nodes for features and output interfaces */ l2_output_next_nodes_st next_nodes; /* convenience variables */ - vlib_main_t * vlib_main; - vnet_main_t * vnet_main; + vlib_main_t *vlib_main; + vnet_main_t *vnet_main; } l2_efp_filter_main_t; -typedef struct { - /* per-pkt trace data */ +typedef struct +{ + /* per-pkt trace data */ u8 src[6]; u8 dst[6]; - u8 raw[12]; // raw data (vlans) + u8 raw[12]; /* raw data (vlans) */ u32 sw_if_index; } l2_efp_filter_trace_t; /* packet trace format function */ -static u8 * format_l2_efp_filter_trace (u8 * s, va_list * args) +static u8 * +format_l2_efp_filter_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 *); - l2_efp_filter_trace_t * t = va_arg (*args, l2_efp_filter_trace_t *); - + l2_efp_filter_trace_t *t = va_arg (*args, l2_efp_filter_trace_t *); + s = format (s, "l2-output-vtr: sw_if_index %d dst %U src %U data " - "%02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x", + "%02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x", t->sw_if_index, - format_ethernet_address, t->dst, - format_ethernet_address, t->src, - t->raw[0], t->raw[1], t->raw[2], t->raw[3], t->raw[4], t->raw[5], - t->raw[6], t->raw[7], t->raw[8], t->raw[9], t->raw[10], t->raw[11]); + format_ethernet_address, t->dst, + format_ethernet_address, t->src, + t->raw[0], t->raw[1], t->raw[2], t->raw[3], t->raw[4], + t->raw[5], t->raw[6], t->raw[7], t->raw[8], t->raw[9], + t->raw[10], t->raw[11]); return s; } @@ -70,63 +74,67 @@ static vlib_node_registration_t l2_efp_filter_node; _(L2_EFP_FILTER, "L2 EFP filter packets") \ _(DROP, "L2 EFP filter post-rewrite drops") -typedef enum { +typedef enum +{ #define _(sym,str) L2_EFP_FILTER_ERROR_##sym, foreach_l2_efp_filter_error #undef _ - L2_EFP_FILTER_N_ERROR, + L2_EFP_FILTER_N_ERROR, } l2_efp_filter_error_t; -static char * l2_efp_filter_error_strings[] = { +static char *l2_efp_filter_error_strings[] = { #define _(sym,string) string, foreach_l2_efp_filter_error #undef _ }; -typedef enum { +typedef enum +{ L2_EFP_FILTER_NEXT_DROP, L2_EFP_FILTER_N_NEXT, } l2_efp_filter_next_t; -// Extract fields from the packet that will be used in interface classification +/** + * Extract fields from the packet that will be used in interface + * classification + */ static_always_inline void extract_keys (vnet_main_t * vnet_main, - u32 sw_if_index0, - vlib_buffer_t * b0, - u32 * port_sw_if_index0, - u16 * first_ethertype0, - u16 * outer_id0, - u16 * inner_id0, - u32 * match_flags0) + u32 sw_if_index0, + vlib_buffer_t * b0, + u32 * port_sw_if_index0, + u16 * first_ethertype0, + u16 * outer_id0, u16 * inner_id0, u32 * match_flags0) { - ethernet_header_t * e0; - ethernet_vlan_header_t * h0; + ethernet_header_t *e0; + ethernet_vlan_header_t *h0; u32 tag_len; u32 tag_num; - *port_sw_if_index0 = vnet_get_sup_sw_interface (vnet_main, sw_if_index0)->sw_if_index; + *port_sw_if_index0 = + vnet_get_sup_sw_interface (vnet_main, sw_if_index0)->sw_if_index; e0 = vlib_buffer_get_current (b0); - h0 = (ethernet_vlan_header_t *)(e0+1); + h0 = (ethernet_vlan_header_t *) (e0 + 1); - *first_ethertype0 = clib_net_to_host_u16(e0->type); + *first_ethertype0 = clib_net_to_host_u16 (e0->type); *outer_id0 = clib_net_to_host_u16 (h0[0].priority_cfi_and_id); *inner_id0 = clib_net_to_host_u16 (h0[1].priority_cfi_and_id); - tag_len = vnet_buffer(b0)->l2.l2_len - sizeof(ethernet_header_t); - tag_num = tag_len / sizeof(ethernet_vlan_header_t); + tag_len = vnet_buffer (b0)->l2.l2_len - sizeof (ethernet_header_t); + tag_num = tag_len / sizeof (ethernet_vlan_header_t); *match_flags0 = eth_create_valid_subint_match_flags (tag_num); } -/* - * EFP filtering is a basic switch feature which prevents an interface from - * transmitting a packet that doesn't match the interface's ingress match - * criteria. The check has two parts, one performed before egress vlan tag +/* + * EFP filtering is a basic switch feature which prevents an interface from + * transmitting a packet that doesn't match the interface's ingress match + * criteria. The check has two parts, one performed before egress vlan tag * rewrite and one after. * - * The pre-rewrite check insures the packet matches what an ingress packet looks - * like after going through the interface's ingress tag rewrite operation. Only + * The pre-rewrite check insures the packet matches what an ingress packet looks + * like after going through the interface's ingress tag rewrite operation. Only * pushed tags are compared. So: * - if the ingress vlan tag rewrite pushes no tags (or is not enabled), * any packet passes the filter @@ -137,8 +145,8 @@ extract_keys (vnet_main_t * vnet_main, * * The pre-rewrite check is performed in the l2-output node. * - * The post-rewrite check insures the packet matches what an ingress packet looks - * like before going through the interface's ingress tag rewrite operation. It verifies + * The post-rewrite check insures the packet matches what an ingress packet looks + * like before going through the interface's ingress tag rewrite operation. It verifies * that such a packet arriving on the wire at this port would be classified as arriving * an input interface equal to the packet's output interface. This can be done by running * the output packet's vlan tags and output port through the interface classification, @@ -149,15 +157,14 @@ extract_keys (vnet_main_t * vnet_main, static uword l2_efp_filter_node_fn (vlib_main_t * vm, - vlib_node_runtime_t * node, - vlib_frame_t * frame) + vlib_node_runtime_t * node, vlib_frame_t * frame) { - u32 n_left_from, * from, * to_next; + u32 n_left_from, *from, *to_next; l2_efp_filter_next_t next_index; - l2_efp_filter_main_t * msm = &l2_efp_filter_main; + l2_efp_filter_main_t *msm = &l2_efp_filter_main; vlib_node_t *n = vlib_get_node (vm, l2_efp_filter_node.index); u32 node_counter_base_index = n->error_heap_index; - vlib_error_main_t * em = &vm->error_main; + vlib_error_main_t *em = &vm->error_main; u32 cached_sw_if_index = ~0; u32 cached_next_index = ~0; @@ -165,7 +172,7 @@ l2_efp_filter_node_fn (vlib_main_t * vm, cached_sw_if_index = ~0; from = vlib_frame_vector_args (frame); - n_left_from = frame->n_vectors; /* number of packets to process */ + n_left_from = frame->n_vectors; /* number of packets to process */ next_index = node->cached_next_index; while (n_left_from > 0) @@ -173,55 +180,60 @@ l2_efp_filter_node_fn (vlib_main_t * vm, u32 n_left_to_next; /* get space to enqueue frame to graph node "next_index" */ - vlib_get_next_frame (vm, node, next_index, - to_next, n_left_to_next); + vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next); while (n_left_from >= 6 && n_left_to_next >= 2) { - u32 bi0, bi1; - vlib_buffer_t * b0, * b1; - u32 next0, next1; - u32 sw_if_index0, sw_if_index1; - u32 feature_bitmap0, feature_bitmap1; - u16 first_ethertype0, first_ethertype1; - u16 outer_id0, inner_id0, outer_id1, inner_id1; - u32 match_flags0, match_flags1; - u32 port_sw_if_index0, subint_sw_if_index0, port_sw_if_index1, subint_sw_if_index1; - vnet_hw_interface_t * hi0, * hi1; - main_intf_t * main_intf0, * main_intf1; - vlan_intf_t * vlan_intf0, * vlan_intf1; - qinq_intf_t * qinq_intf0, * qinq_intf1; - u32 is_l20, is_l21; - __attribute__((unused)) u32 matched0, matched1; - u8 error0, error1; - + u32 bi0, bi1; + vlib_buffer_t *b0, *b1; + u32 next0, next1; + u32 sw_if_index0, sw_if_index1; + u32 feature_bitmap0, feature_bitmap1; + u16 first_ethertype0, first_ethertype1; + u16 outer_id0, inner_id0, outer_id1, inner_id1; + u32 match_flags0, match_flags1; + u32 port_sw_if_index0, subint_sw_if_index0, port_sw_if_index1, + subint_sw_if_index1; + vnet_hw_interface_t *hi0, *hi1; + main_intf_t *main_intf0, *main_intf1; + vlan_intf_t *vlan_intf0, *vlan_intf1; + qinq_intf_t *qinq_intf0, *qinq_intf1; + u32 is_l20, is_l21; + __attribute__ ((unused)) u32 matched0, matched1; + u8 error0, error1; + /* Prefetch next iteration. */ { - vlib_buffer_t * p2, * p3, * p4, * p5; - __attribute__((unused)) u32 sw_if_index2, sw_if_index3; - + vlib_buffer_t *p2, *p3, *p4, *p5; + __attribute__ ((unused)) u32 sw_if_index2, sw_if_index3; + p2 = vlib_get_buffer (vm, from[2]); p3 = vlib_get_buffer (vm, from[3]); p4 = vlib_get_buffer (vm, from[4]); p5 = vlib_get_buffer (vm, from[5]); - - // Prefetch the buffer header and packet for the N+2 loop iteration + + /* Prefetch the buffer header and packet for the N+2 loop iteration */ vlib_prefetch_buffer_header (p4, LOAD); vlib_prefetch_buffer_header (p5, LOAD); CLIB_PREFETCH (p4->data, CLIB_CACHE_LINE_BYTES, STORE); CLIB_PREFETCH (p5->data, CLIB_CACHE_LINE_BYTES, STORE); - // Prefetch the input config for the N+1 loop iteration - // This depends on the buffer header above - sw_if_index2 = vnet_buffer(p2)->sw_if_index[VLIB_TX]; - sw_if_index3 = vnet_buffer(p3)->sw_if_index[VLIB_TX]; - //TODO CLIB_PREFETCH (vec_elt_at_index(l2output_main.configs, sw_if_index2), CLIB_CACHE_LINE_BYTES, LOAD); - //TODO CLIB_PREFETCH (vec_elt_at_index(l2output_main.configs, sw_if_index3), CLIB_CACHE_LINE_BYTES, LOAD); + /* + * Prefetch the input config for the N+1 loop iteration + * This depends on the buffer header above + */ + sw_if_index2 = vnet_buffer (p2)->sw_if_index[VLIB_TX]; + sw_if_index3 = vnet_buffer (p3)->sw_if_index[VLIB_TX]; + /* + * $$$ TODO + * CLIB_PREFETCH (vec_elt_at_index(l2output_main.configs, sw_if_index2), CLIB_CACHE_LINE_BYTES, LOAD); + * CLIB_PREFETCH (vec_elt_at_index(l2output_main.configs, sw_if_index3), CLIB_CACHE_LINE_BYTES, LOAD); + */ } - /* speculatively enqueue b0 and b1 to the current next frame */ - /* bi is "buffer index", b is pointer to the buffer */ + /* speculatively enqueue b0 and b1 to the current next frame */ + /* bi is "buffer index", b is pointer to the buffer */ to_next[0] = bi0 = from[0]; to_next[1] = bi1 = from[1]; from += 2; @@ -231,164 +243,156 @@ l2_efp_filter_node_fn (vlib_main_t * vm, b0 = vlib_get_buffer (vm, bi0); b1 = vlib_get_buffer (vm, bi1); - - /* TX interface handles */ - sw_if_index0 = vnet_buffer(b0)->sw_if_index[VLIB_TX]; - sw_if_index1 = vnet_buffer(b1)->sw_if_index[VLIB_TX]; - - // process 2 packets - em->counters[node_counter_base_index + L2_EFP_FILTER_ERROR_L2_EFP_FILTER] += 2; - - // Remove ourself from the feature bitmap - feature_bitmap0 = vnet_buffer(b0)->l2.feature_bitmap & ~L2OUTPUT_FEAT_EFP_FILTER; - feature_bitmap1 = vnet_buffer(b1)->l2.feature_bitmap & ~L2OUTPUT_FEAT_EFP_FILTER; - - // Determine next node - l2_output_dispatch (msm->vlib_main, - msm->vnet_main, - node, - l2_efp_filter_node.index, - &cached_sw_if_index, - &cached_next_index, - &msm->next_nodes, - b0, - sw_if_index0, - feature_bitmap0, - &next0); - l2_output_dispatch (msm->vlib_main, - msm->vnet_main, - node, - l2_efp_filter_node.index, - &cached_sw_if_index, - &cached_next_index, - &msm->next_nodes, - b1, - sw_if_index1, - feature_bitmap1, - &next1); - - // perform the efp filter check on two packets - - extract_keys (msm->vnet_main, - sw_if_index0, - b0, - &port_sw_if_index0, - &first_ethertype0, - &outer_id0, - &inner_id0, - &match_flags0); - - extract_keys (msm->vnet_main, - sw_if_index1, - b1, - &port_sw_if_index1, - &first_ethertype1, - &outer_id1, - &inner_id1, - &match_flags1); - - eth_vlan_table_lookups (ðernet_main, - msm->vnet_main, - port_sw_if_index0, - first_ethertype0, - outer_id0, - inner_id0, - &hi0, - &main_intf0, - &vlan_intf0, - &qinq_intf0); - - eth_vlan_table_lookups (ðernet_main, - msm->vnet_main, - port_sw_if_index1, - first_ethertype1, - outer_id1, - inner_id1, - &hi1, - &main_intf1, - &vlan_intf1, - &qinq_intf1); - - matched0 = eth_identify_subint (hi0, - b0, - match_flags0, - main_intf0, - vlan_intf0, - qinq_intf0, - &subint_sw_if_index0, - &error0, - &is_l20); - - matched1 = eth_identify_subint (hi1, - b1, - match_flags1, - main_intf1, - vlan_intf1, - qinq_intf1, - &subint_sw_if_index1, - &error1, - &is_l21); - - if (PREDICT_FALSE (sw_if_index0 != subint_sw_if_index0)) { - // Drop packet - next0 = L2_EFP_FILTER_NEXT_DROP; - b0->error = node->errors[L2_EFP_FILTER_ERROR_DROP]; - } - if (PREDICT_FALSE (sw_if_index1 != subint_sw_if_index1)) { - // Drop packet - next1 = L2_EFP_FILTER_NEXT_DROP; - b1->error = node->errors[L2_EFP_FILTER_ERROR_DROP]; - } + /* TX interface handles */ + sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_TX]; + sw_if_index1 = vnet_buffer (b1)->sw_if_index[VLIB_TX]; + + /* process 2 packets */ + em->counters[node_counter_base_index + + L2_EFP_FILTER_ERROR_L2_EFP_FILTER] += 2; + + /* Remove ourself from the feature bitmap */ + feature_bitmap0 = + vnet_buffer (b0)->l2.feature_bitmap & ~L2OUTPUT_FEAT_EFP_FILTER; + feature_bitmap1 = + vnet_buffer (b1)->l2.feature_bitmap & ~L2OUTPUT_FEAT_EFP_FILTER; + + /* Determine next node */ + l2_output_dispatch (msm->vlib_main, + msm->vnet_main, + node, + l2_efp_filter_node.index, + &cached_sw_if_index, + &cached_next_index, + &msm->next_nodes, + b0, sw_if_index0, feature_bitmap0, &next0); + l2_output_dispatch (msm->vlib_main, + msm->vnet_main, + node, + l2_efp_filter_node.index, + &cached_sw_if_index, + &cached_next_index, + &msm->next_nodes, + b1, sw_if_index1, feature_bitmap1, &next1); + + /* perform the efp filter check on two packets */ + + extract_keys (msm->vnet_main, + sw_if_index0, + b0, + &port_sw_if_index0, + &first_ethertype0, + &outer_id0, &inner_id0, &match_flags0); + + extract_keys (msm->vnet_main, + sw_if_index1, + b1, + &port_sw_if_index1, + &first_ethertype1, + &outer_id1, &inner_id1, &match_flags1); + + eth_vlan_table_lookups (ðernet_main, + msm->vnet_main, + port_sw_if_index0, + first_ethertype0, + outer_id0, + inner_id0, + &hi0, + &main_intf0, &vlan_intf0, &qinq_intf0); + + eth_vlan_table_lookups (ðernet_main, + msm->vnet_main, + port_sw_if_index1, + first_ethertype1, + outer_id1, + inner_id1, + &hi1, + &main_intf1, &vlan_intf1, &qinq_intf1); + + matched0 = eth_identify_subint (hi0, + b0, + match_flags0, + main_intf0, + vlan_intf0, + qinq_intf0, + &subint_sw_if_index0, + &error0, &is_l20); + + matched1 = eth_identify_subint (hi1, + b1, + match_flags1, + main_intf1, + vlan_intf1, + qinq_intf1, + &subint_sw_if_index1, + &error1, &is_l21); + + if (PREDICT_FALSE (sw_if_index0 != subint_sw_if_index0)) + { + /* Drop packet */ + next0 = L2_EFP_FILTER_NEXT_DROP; + b0->error = node->errors[L2_EFP_FILTER_ERROR_DROP]; + } + + if (PREDICT_FALSE (sw_if_index1 != subint_sw_if_index1)) + { + /* Drop packet */ + next1 = L2_EFP_FILTER_NEXT_DROP; + b1->error = node->errors[L2_EFP_FILTER_ERROR_DROP]; + } + + if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE))) + { + if (b0->flags & VLIB_BUFFER_IS_TRACED) + { + ethernet_header_t *h0 = vlib_buffer_get_current (b0); + l2_efp_filter_trace_t *t = + vlib_add_trace (vm, node, b0, sizeof (*t)); + t->sw_if_index = sw_if_index0; + clib_memcpy (t->src, h0->src_address, 6); + clib_memcpy (t->dst, h0->dst_address, 6); + clib_memcpy (t->raw, &h0->type, sizeof (t->raw)); + } + if (b1->flags & VLIB_BUFFER_IS_TRACED) + { + ethernet_header_t *h1 = vlib_buffer_get_current (b1); + l2_efp_filter_trace_t *t = + vlib_add_trace (vm, node, b1, sizeof (*t)); + t->sw_if_index = sw_if_index1; + clib_memcpy (t->src, h1->src_address, 6); + clib_memcpy (t->dst, h1->dst_address, 6); + clib_memcpy (t->raw, &h1->type, sizeof (t->raw)); + } + } + + /* verify speculative enqueues, maybe switch current next frame */ + /* if next0==next1==next_index then nothing special needs to be done */ + vlib_validate_buffer_enqueue_x2 (vm, node, next_index, + to_next, n_left_to_next, + bi0, bi1, next0, next1); + } - if (PREDICT_FALSE((node->flags & VLIB_NODE_FLAG_TRACE))) { - if (b0->flags & VLIB_BUFFER_IS_TRACED) { - ethernet_header_t * h0 = vlib_buffer_get_current (b0); - l2_efp_filter_trace_t *t = - vlib_add_trace (vm, node, b0, sizeof (*t)); - t->sw_if_index = sw_if_index0; - clib_memcpy(t->src, h0->src_address, 6); - clib_memcpy(t->dst, h0->dst_address, 6); - clib_memcpy(t->raw, &h0->type, sizeof(t->raw)); - } - if (b1->flags & VLIB_BUFFER_IS_TRACED) { - ethernet_header_t * h1 = vlib_buffer_get_current (b1); - l2_efp_filter_trace_t *t = - vlib_add_trace (vm, node, b1, sizeof (*t)); - t->sw_if_index = sw_if_index1; - clib_memcpy(t->src, h1->src_address, 6); - clib_memcpy(t->dst, h1->dst_address, 6); - clib_memcpy(t->raw, &h1->type, sizeof(t->raw)); - } - } - - /* verify speculative enqueues, maybe switch current next frame */ - /* if next0==next1==next_index then nothing special needs to be done */ - vlib_validate_buffer_enqueue_x2 (vm, node, next_index, - to_next, n_left_to_next, - bi0, bi1, next0, next1); - } - while (n_left_from > 0 && n_left_to_next > 0) { - u32 bi0; - vlib_buffer_t * b0; - u32 next0; - u32 sw_if_index0; - u32 feature_bitmap0; - u16 first_ethertype0; - u16 outer_id0, inner_id0; - u32 match_flags0; - u32 port_sw_if_index0, subint_sw_if_index0; - vnet_hw_interface_t * hi0; - main_intf_t * main_intf0; - vlan_intf_t * vlan_intf0; - qinq_intf_t * qinq_intf0; - u32 is_l20; - __attribute__((unused)) u32 matched0; - u8 error0; - - /* speculatively enqueue b0 to the current next frame */ + u32 bi0; + vlib_buffer_t *b0; + u32 next0; + u32 sw_if_index0; + u32 feature_bitmap0; + u16 first_ethertype0; + u16 outer_id0, inner_id0; + u32 match_flags0; + u32 port_sw_if_index0, subint_sw_if_index0; + vnet_hw_interface_t *hi0; + main_intf_t *main_intf0; + vlan_intf_t *vlan_intf0; + qinq_intf_t *qinq_intf0; + u32 is_l20; + __attribute__ ((unused)) u32 matched0; + u8 error0; + + /* speculatively enqueue b0 to the current next frame */ bi0 = from[0]; to_next[0] = bi0; from += 1; @@ -397,77 +401,73 @@ l2_efp_filter_node_fn (vlib_main_t * vm, n_left_to_next -= 1; b0 = vlib_get_buffer (vm, bi0); - sw_if_index0 = vnet_buffer(b0)->sw_if_index[VLIB_TX]; - - // process 1 packet - em->counters[node_counter_base_index + L2_EFP_FILTER_ERROR_L2_EFP_FILTER] += 1; - - // Remove ourself from the feature bitmap - feature_bitmap0 = vnet_buffer(b0)->l2.feature_bitmap & ~L2OUTPUT_FEAT_EFP_FILTER; - - // Determine next node - l2_output_dispatch (msm->vlib_main, - msm->vnet_main, - node, - l2_efp_filter_node.index, - &cached_sw_if_index, - &cached_next_index, - &msm->next_nodes, - b0, - sw_if_index0, - feature_bitmap0, - &next0); - - // perform the efp filter check on one packet - - extract_keys (msm->vnet_main, - sw_if_index0, - b0, - &port_sw_if_index0, - &first_ethertype0, - &outer_id0, - &inner_id0, - &match_flags0); - - eth_vlan_table_lookups (ðernet_main, - msm->vnet_main, - port_sw_if_index0, - first_ethertype0, - outer_id0, - inner_id0, - &hi0, - &main_intf0, - &vlan_intf0, - &qinq_intf0); - - matched0 = eth_identify_subint (hi0, - b0, - match_flags0, - main_intf0, - vlan_intf0, - qinq_intf0, - &subint_sw_if_index0, - &error0, - &is_l20); - - if (PREDICT_FALSE (sw_if_index0 != subint_sw_if_index0)) { - // Drop packet - next0 = L2_EFP_FILTER_NEXT_DROP; - b0->error = node->errors[L2_EFP_FILTER_ERROR_DROP]; - } - - if (PREDICT_FALSE((node->flags & VLIB_NODE_FLAG_TRACE) - && (b0->flags & VLIB_BUFFER_IS_TRACED))) { - ethernet_header_t * h0 = vlib_buffer_get_current (b0); - l2_efp_filter_trace_t *t = - vlib_add_trace (vm, node, b0, sizeof (*t)); - t->sw_if_index = sw_if_index0; - clib_memcpy(t->src, h0->src_address, 6); - clib_memcpy(t->dst, h0->dst_address, 6); - clib_memcpy(t->raw, &h0->type, sizeof(t->raw)); - } - - /* verify speculative enqueue, maybe switch current next frame */ + sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_TX]; + + /* process 1 packet */ + em->counters[node_counter_base_index + + L2_EFP_FILTER_ERROR_L2_EFP_FILTER] += 1; + + /* Remove ourself from the feature bitmap */ + feature_bitmap0 = + vnet_buffer (b0)->l2.feature_bitmap & ~L2OUTPUT_FEAT_EFP_FILTER; + + /* Determine next node */ + l2_output_dispatch (msm->vlib_main, + msm->vnet_main, + node, + l2_efp_filter_node.index, + &cached_sw_if_index, + &cached_next_index, + &msm->next_nodes, + b0, sw_if_index0, feature_bitmap0, &next0); + + /* perform the efp filter check on one packet */ + + extract_keys (msm->vnet_main, + sw_if_index0, + b0, + &port_sw_if_index0, + &first_ethertype0, + &outer_id0, &inner_id0, &match_flags0); + + eth_vlan_table_lookups (ðernet_main, + msm->vnet_main, + port_sw_if_index0, + first_ethertype0, + outer_id0, + inner_id0, + &hi0, + &main_intf0, &vlan_intf0, &qinq_intf0); + + matched0 = eth_identify_subint (hi0, + b0, + match_flags0, + main_intf0, + vlan_intf0, + qinq_intf0, + &subint_sw_if_index0, + &error0, &is_l20); + + if (PREDICT_FALSE (sw_if_index0 != subint_sw_if_index0)) + { + /* Drop packet */ + next0 = L2_EFP_FILTER_NEXT_DROP; + b0->error = node->errors[L2_EFP_FILTER_ERROR_DROP]; + } + + if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE) + && (b0->flags & VLIB_BUFFER_IS_TRACED))) + { + ethernet_header_t *h0 = vlib_buffer_get_current (b0); + l2_efp_filter_trace_t *t = + vlib_add_trace (vm, node, b0, sizeof (*t)); + t->sw_if_index = sw_if_index0; + clib_memcpy (t->src, h0->src_address, 6); + clib_memcpy (t->dst, h0->dst_address, 6); + clib_memcpy (t->raw, &h0->type, sizeof (t->raw)); + } + + /* verify speculative enqueue, maybe switch current next frame */ vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next, n_left_to_next, bi0, next0); @@ -480,13 +480,14 @@ l2_efp_filter_node_fn (vlib_main_t * vm, } +/* *INDENT-OFF* */ VLIB_REGISTER_NODE (l2_efp_filter_node,static) = { .function = l2_efp_filter_node_fn, .name = "l2-efp-filter", .vector_size = sizeof (u32), .format_trace = format_l2_efp_filter_trace, .type = VLIB_NODE_TYPE_INTERNAL, - + .n_errors = ARRAY_LEN(l2_efp_filter_error_strings), .error_strings = l2_efp_filter_error_strings, @@ -497,25 +498,25 @@ VLIB_REGISTER_NODE (l2_efp_filter_node,static) = { [L2_EFP_FILTER_NEXT_DROP] = "error-drop", }, }; +/* *INDENT-ON* */ VLIB_NODE_FUNCTION_MULTIARCH (l2_efp_filter_node, l2_efp_filter_node_fn) - -clib_error_t *l2_efp_filter_init (vlib_main_t *vm) + clib_error_t *l2_efp_filter_init (vlib_main_t * vm) { - l2_efp_filter_main_t * mp = &l2_efp_filter_main; - + l2_efp_filter_main_t *mp = &l2_efp_filter_main; + mp->vlib_main = vm; - mp->vnet_main = vnet_get_main(); + mp->vnet_main = vnet_get_main (); - // Initialize the feature next-node indexes - feat_bitmap_init_next_nodes(vm, - l2_efp_filter_node.index, - L2OUTPUT_N_FEAT, - l2output_get_feat_names(), - mp->next_nodes.feat_next_node_index); + /* Initialize the feature next-node indexes */ + feat_bitmap_init_next_nodes (vm, + l2_efp_filter_node.index, + L2OUTPUT_N_FEAT, + l2output_get_feat_names (), + mp->next_nodes.feat_next_node_index); - // Initialize the output node mapping table - l2output_init_output_node_vec(&mp->next_nodes.output_node_index_vec); + /* Initialize the output node mapping table */ + l2output_init_output_node_vec (&mp->next_nodes.output_node_index_vec); return 0; } @@ -523,52 +524,63 @@ clib_error_t *l2_efp_filter_init (vlib_main_t *vm) VLIB_INIT_FUNCTION (l2_efp_filter_init); -// Enable/disable the EFP Filter check on the subinterface -void l2_efp_filter_configure (vnet_main_t * vnet_main, - u32 sw_if_index, - u32 enable) +/** Enable/disable the EFP Filter check on the subinterface */ +void +l2_efp_filter_configure (vnet_main_t * vnet_main, u32 sw_if_index, u32 enable) { - // set the interface flag - l2output_intf_bitmap_enable(sw_if_index, L2OUTPUT_FEAT_EFP_FILTER, enable); + /* set the interface flag */ + l2output_intf_bitmap_enable (sw_if_index, L2OUTPUT_FEAT_EFP_FILTER, enable); } -// set subinterface egress efp filter enable/disable -// The CLI format is: -// set interface l2 efp-filter [disable]] +/** + * set subinterface egress efp filter enable/disable + * The CLI format is: + * set interface l2 efp-filter [disable]] + */ static clib_error_t * int_l2_efp_filter (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) + unformat_input_t * input, vlib_cli_command_t * cmd) { - vnet_main_t * vnm = vnet_get_main(); - clib_error_t * error = 0; + vnet_main_t *vnm = vnet_get_main (); + clib_error_t *error = 0; u32 sw_if_index; u32 enable; - if (! unformat_user (input, unformat_vnet_sw_interface, vnm, &sw_if_index)) + if (!unformat_user (input, unformat_vnet_sw_interface, vnm, &sw_if_index)) { error = clib_error_return (0, "unknown interface `%U'", - format_unformat_error, input); + format_unformat_error, input); goto done; } enable = 1; - if (unformat (input, "disable")) { - enable = 0; - } + if (unformat (input, "disable")) + { + enable = 0; + } - // enable/disable the feature + /* enable/disable the feature */ l2_efp_filter_configure (vnm, sw_if_index, enable); - done: +done: return error; } +/* *INDENT-OFF* */ VLIB_CLI_COMMAND (int_l2_efp_filter_cli, static) = { .path = "set interface l2 efp-filter", .short_help = "set interface l2 efp-filter [disable]", .function = int_l2_efp_filter, }; +/* *INDENT-ON* */ + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/vnet/vnet/l2/l2_efp_filter.h b/vnet/vnet/l2/l2_efp_filter.h index f8baf092fa8..f40851df3bd 100644 --- a/vnet/vnet/l2/l2_efp_filter.h +++ b/vnet/vnet/l2/l2_efp_filter.h @@ -19,10 +19,15 @@ #ifndef included_vnet_l2_efp_filter_h #define included_vnet_l2_efp_filter_h - #include #include - #endif +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/vnet/vnet/l2/l2_fib.c b/vnet/vnet/l2/l2_fib.c index 050eba563cc..4275e884ce0 100644 --- a/vnet/vnet/l2/l2_fib.c +++ b/vnet/vnet/l2/l2_fib.c @@ -30,39 +30,42 @@ #include -typedef struct { +typedef struct +{ /* hash table */ - BVT(clib_bihash) mac_table; + BVT (clib_bihash) mac_table; /* convenience variables */ - vlib_main_t * vlib_main; - vnet_main_t * vnet_main; + vlib_main_t *vlib_main; + vnet_main_t *vnet_main; } l2fib_main_t; l2fib_main_t l2fib_main; -// Format sw_if_index. If the value is ~0, use the text "N/A" -u8 * format_vnet_sw_if_index_name_with_NA (u8 * s, va_list * args) +/** Format sw_if_index. If the value is ~0, use the text "N/A" */ +u8 * +format_vnet_sw_if_index_name_with_NA (u8 * s, va_list * args) { - vnet_main_t * vnm = va_arg (*args, vnet_main_t *); + vnet_main_t *vnm = va_arg (*args, vnet_main_t *); u32 sw_if_index = va_arg (*args, u32); if (sw_if_index == ~0) return format (s, "N/A"); - else + else return format (s, "%U", - format_vnet_sw_interface_name, vnm, - vnet_get_sw_interface (vnm, sw_if_index)); + format_vnet_sw_interface_name, vnm, + vnet_get_sw_interface (vnm, sw_if_index)); } -void l2fib_table_dump (u32 bd_index, l2fib_entry_key_t **l2fe_key, - l2fib_entry_result_t **l2fe_res) +void +l2fib_table_dump (u32 bd_index, l2fib_entry_key_t ** l2fe_key, + l2fib_entry_result_t ** l2fe_res) { - l2fib_main_t * msm = &l2fib_main; - BVT(clib_bihash) * h = &msm->mac_table; - clib_bihash_bucket_t * b; - BVT(clib_bihash_value) * v; + l2fib_main_t *msm = &l2fib_main; + BVT (clib_bihash) * h = &msm->mac_table; + clib_bihash_bucket_t *b; + BVT (clib_bihash_value) * v; l2fib_entry_key_t key; l2fib_entry_result_t result; int i, j, k; @@ -71,40 +74,39 @@ void l2fib_table_dump (u32 bd_index, l2fib_entry_key_t **l2fe_key, { b = &h->buckets[i]; if (b->offset == 0) - continue; - v = BV(clib_bihash_get_value) (h, b->offset); - for (j = 0; j < (1<log2_pages); j++) - { - for (k = 0; k < BIHASH_KVP_PER_PAGE; k++) - { - if (v->kvp[k].key == ~0ULL && v->kvp[k].value == ~0ULL) - continue; - - key.raw = v->kvp[k].key; - result.raw = v->kvp[k].value; - - if ((bd_index == ~0) || (bd_index == key.fields.bd_index)) - { - vec_add1 (*l2fe_key, key); - vec_add1 (*l2fe_res, result); - } - } - v++; - } + continue; + v = BV (clib_bihash_get_value) (h, b->offset); + for (j = 0; j < (1 << b->log2_pages); j++) + { + for (k = 0; k < BIHASH_KVP_PER_PAGE; k++) + { + if (v->kvp[k].key == ~0ULL && v->kvp[k].value == ~0ULL) + continue; + + key.raw = v->kvp[k].key; + result.raw = v->kvp[k].value; + + if ((bd_index == ~0) || (bd_index == key.fields.bd_index)) + { + vec_add1 (*l2fe_key, key); + vec_add1 (*l2fe_res, result); + } + } + v++; + } } } -// Display the contents of the l2fib +/** Display the contents of the l2fib */ static clib_error_t * -show_l2fib (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) +show_l2fib (vlib_main_t * vm, + unformat_input_t * input, vlib_cli_command_t * cmd) { - bd_main_t * bdm = &bd_main; - l2fib_main_t * msm = &l2fib_main; - BVT(clib_bihash) * h = &msm->mac_table; - clib_bihash_bucket_t * b; - BVT(clib_bihash_value) * v; + bd_main_t *bdm = &bd_main; + l2fib_main_t *msm = &l2fib_main; + BVT (clib_bihash) * h = &msm->mac_table; + clib_bihash_bucket_t *b; + BVT (clib_bihash_value) * v; l2fib_entry_key_t key; l2fib_entry_result_t result; u32 first_entry = 1; @@ -123,65 +125,65 @@ show_l2fib (vlib_main_t * vm, else if (unformat (input, "bd_id %d", &bd_id)) { uword *p = hash_get (bdm->bd_index_by_bd_id, bd_id); - if (p) - { + if (p) + { verbose = 1; bd_index = p[0]; - } + } else - { + { vlib_cli_output (vm, "no such bridge domain id"); return 0; - } + } } for (i = 0; i < h->nbuckets; i++) { b = &h->buckets[i]; if (b->offset == 0) - continue; - v = BV(clib_bihash_get_value) (h, b->offset); - for (j = 0; j < (1<log2_pages); j++) - { - for (k = 0; k < BIHASH_KVP_PER_PAGE; k++) - { - if (v->kvp[k].key == ~0ULL && v->kvp[k].value == ~0ULL) - continue; - - if (verbose && first_entry) - { - first_entry=0; - vlib_cli_output (vm, - "%=19s%=7s%=30s%=7s%=8s%=8s%=5s%=9s%=11s", - "Mac Address", "BD Idx", "Interface", - "Index", "static", "filter", "bvi", - "refresh", "timestamp"); - } - - key.raw = v->kvp[k].key; - result.raw = v->kvp[k].value; - - if (verbose - & ((bd_index >>31) || (bd_index == key.fields.bd_index))) - { - vlib_cli_output (vm, - "%=19U%=7d%=30U%=7d%=8d%=8d%=5d%=9d%=11X", - format_ethernet_address, key.fields.mac, - key.fields.bd_index, - format_vnet_sw_if_index_name_with_NA, - msm->vnet_main, result.fields.sw_if_index, - result.fields.sw_if_index == ~0 - ? -1 : result.fields.sw_if_index, - result.fields.static_mac, - result.fields.filter, - result.fields.bvi, - result.fields.refresh, - result.fields.timestamp); - } - total_entries++; - } - v++; - } + continue; + v = BV (clib_bihash_get_value) (h, b->offset); + for (j = 0; j < (1 << b->log2_pages); j++) + { + for (k = 0; k < BIHASH_KVP_PER_PAGE; k++) + { + if (v->kvp[k].key == ~0ULL && v->kvp[k].value == ~0ULL) + continue; + + if (verbose && first_entry) + { + first_entry = 0; + vlib_cli_output (vm, + "%=19s%=7s%=30s%=7s%=8s%=8s%=5s%=9s%=11s", + "Mac Address", "BD Idx", "Interface", + "Index", "static", "filter", "bvi", + "refresh", "timestamp"); + } + + key.raw = v->kvp[k].key; + result.raw = v->kvp[k].value; + + if (verbose + & ((bd_index >> 31) || (bd_index == key.fields.bd_index))) + { + vlib_cli_output (vm, + "%=19U%=7d%=30U%=7d%=8d%=8d%=5d%=9d%=11X", + format_ethernet_address, key.fields.mac, + key.fields.bd_index, + format_vnet_sw_if_index_name_with_NA, + msm->vnet_main, result.fields.sw_if_index, + result.fields.sw_if_index == ~0 + ? -1 : result.fields.sw_if_index, + result.fields.static_mac, + result.fields.filter, + result.fields.bvi, + result.fields.refresh, + result.fields.timestamp); + } + total_entries++; + } + v++; + } } if (total_entries == 0) @@ -191,72 +193,81 @@ show_l2fib (vlib_main_t * vm, if (raw) vlib_cli_output (vm, "Raw Hash Table:\n%U\n", - BV(format_bihash), h, 1 /* verbose */); + BV (format_bihash), h, 1 /* verbose */ ); return 0; } +/* *INDENT-OFF* */ VLIB_CLI_COMMAND (show_l2fib_cli, static) = { .path = "show l2fib", .short_help = "show l2fib [verbose | bd_id | bd_index | raw]", .function = show_l2fib, }; +/* *INDENT-ON* */ -// Remove all entries from the l2fib -void l2fib_clear_table (uint keep_static) +/* Remove all entries from the l2fib */ +void +l2fib_clear_table (uint keep_static) { - l2fib_main_t * mp = &l2fib_main; + l2fib_main_t *mp = &l2fib_main; - if (keep_static) { - // TODO: remove only non-static entries - } else { - // Remove all entries - BV(clib_bihash_free) (&mp->mac_table); - BV(clib_bihash_init) (&mp->mac_table, "l2fib mac table", - L2FIB_NUM_BUCKETS, L2FIB_MEMORY_SIZE); - } + if (keep_static) + { + /* TODO: remove only non-static entries */ + } + else + { + /* Remove all entries */ + BV (clib_bihash_free) (&mp->mac_table); + BV (clib_bihash_init) (&mp->mac_table, "l2fib mac table", + L2FIB_NUM_BUCKETS, L2FIB_MEMORY_SIZE); + } l2learn_main.global_learn_count = 0; } -// Clear all entries in L2FIB -// TODO: Later we may want a way to remove only the non-static entries +/** Clear all entries in L2FIB + * TODO: Later we may want a way to remove only the non-static entries + */ static clib_error_t * -clear_l2fib (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) +clear_l2fib (vlib_main_t * vm, + unformat_input_t * input, vlib_cli_command_t * cmd) { l2fib_clear_table (0); return 0; } +/* *INDENT-OFF* */ VLIB_CLI_COMMAND (clear_l2fib_cli, static) = { .path = "clear l2fib", .short_help = "Clear l2fib mac forwarding entries", .function = clear_l2fib, }; +/* *INDENT-ON* */ -// Add an entry to the l2fib. -// If the entry already exists then overwrite it -void l2fib_add_entry (u64 mac, - u32 bd_index, - u32 sw_if_index, - u32 static_mac, - u32 filter_mac, - u32 bvi_mac) { +/** + * Add an entry to the l2fib. + * If the entry already exists then overwrite it + */ +void +l2fib_add_entry (u64 mac, + u32 bd_index, + u32 sw_if_index, u32 static_mac, u32 filter_mac, u32 bvi_mac) +{ l2fib_entry_key_t key; l2fib_entry_result_t result; - __attribute__((unused)) u32 bucket_contents; - l2fib_main_t * mp = &l2fib_main; - BVT(clib_bihash_kv) kv; - - // set up key - key.raw = l2fib_make_key ((u8 *)&mac, bd_index); - - // set up result - result.raw = 0; // clear all fields + __attribute__ ((unused)) u32 bucket_contents; + l2fib_main_t *mp = &l2fib_main; + BVT (clib_bihash_kv) kv; + + /* set up key */ + key.raw = l2fib_make_key ((u8 *) & mac, bd_index); + + /* set up result */ + result.raw = 0; /* clear all fields */ result.fields.sw_if_index = sw_if_index; result.fields.static_mac = static_mac; result.fields.filter = filter_mac; @@ -265,27 +276,29 @@ void l2fib_add_entry (u64 mac, kv.key = key.raw; kv.value = result.raw; - BV(clib_bihash_add_del) (&mp->mac_table, &kv, 1 /* is_add */); + BV (clib_bihash_add_del) (&mp->mac_table, &kv, 1 /* is_add */ ); - // increment counter if dynamically learned mac - if (result.fields.static_mac) { - l2learn_main.global_learn_count++; - } + /* increment counter if dynamically learned mac */ + if (result.fields.static_mac) + { + l2learn_main.global_learn_count++; + } } -// Add an entry to the L2FIB -// The CLI format is: -// l2fib add [static] [bvi] -// l2fib add filter -// Note that filter and bvi entries are always static +/** + * Add an entry to the L2FIB + * The CLI format is: + * l2fib add [static] [bvi] + * l2fib add filter + * Note that filter and bvi entries are always static + */ static clib_error_t * -l2fib_add (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) +l2fib_add (vlib_main_t * vm, + unformat_input_t * input, vlib_cli_command_t * cmd) { - bd_main_t * bdm = &bd_main; - vnet_main_t * vnm = vnet_get_main(); - clib_error_t * error = 0; + bd_main_t *bdm = &bd_main; + vnet_main_t *vnm = vnet_get_main (); + clib_error_t *error = 0; u64 mac; u32 bd_id; u32 bd_index; @@ -293,66 +306,78 @@ l2fib_add (vlib_main_t * vm, u32 filter_mac = 0; u32 static_mac = 0; u32 bvi_mac = 0; - uword * p; + uword *p; - if (! unformat_user (input, unformat_ethernet_address, &mac)) + if (!unformat_user (input, unformat_ethernet_address, &mac)) { error = clib_error_return (0, "expected mac address `%U'", - format_unformat_error, input); + format_unformat_error, input); goto done; } - - if (!unformat (input, "%d", &bd_id)) { + + if (!unformat (input, "%d", &bd_id)) + { error = clib_error_return (0, "expected bridge domain ID `%U'", - format_unformat_error, input); + format_unformat_error, input); goto done; - } + } p = hash_get (bdm->bd_index_by_bd_id, bd_id); - if (!p) { + if (!p) + { error = clib_error_return (0, "bridge domain ID %d invalid", bd_id); goto done; - } + } bd_index = p[0]; - if (unformat (input, "filter")) { - filter_mac = 1; - static_mac = 1; - - } else { + if (unformat (input, "filter")) + { + filter_mac = 1; + static_mac = 1; - if (! unformat_user (input, unformat_vnet_sw_interface, vnm, &sw_if_index)) { - error = clib_error_return (0, "unknown interface `%U'", - format_unformat_error, input); - goto done; } - if (unformat (input, "static")) { - static_mac = 1; - } else if (unformat (input, "bvi")) { - bvi_mac = 1; - static_mac = 1; + else + { + + if (!unformat_user + (input, unformat_vnet_sw_interface, vnm, &sw_if_index)) + { + error = clib_error_return (0, "unknown interface `%U'", + format_unformat_error, input); + goto done; + } + if (unformat (input, "static")) + { + static_mac = 1; + } + else if (unformat (input, "bvi")) + { + bvi_mac = 1; + static_mac = 1; + } } - } - l2fib_add_entry(mac, bd_index, sw_if_index, static_mac, filter_mac, bvi_mac); + l2fib_add_entry (mac, bd_index, sw_if_index, static_mac, filter_mac, + bvi_mac); - done: +done: return error; } +/* *INDENT-OFF* */ VLIB_CLI_COMMAND (l2fib_add_cli, static) = { .path = "l2fib add", .short_help = "Add l2fib mac forwarding entry filter | [static | bvi]", .function = l2fib_add, }; +/* *INDENT-ON* */ static clib_error_t * -l2fib_test_command_fn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) +l2fib_test_command_fn (vlib_main_t * vm, + unformat_input_t * input, vlib_cli_command_t * cmd) { - clib_error_t * error = 0; + clib_error_t *error = 0; u64 mac, save_mac; u32 bd_index = 0; u32 sw_if_index = 8; @@ -365,199 +390,215 @@ l2fib_test_command_fn (vlib_main_t * vm, int mac_set = 0; int i; - while (unformat_check_input(input) != UNFORMAT_END_OF_INPUT) + while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) { if (unformat (input, "mac %U", unformat_ethernet_address, &mac)) - mac_set = 1; + mac_set = 1; else if (unformat (input, "add")) - is_add = 1; + is_add = 1; else if (unformat (input, "del")) - is_del = 1; + is_del = 1; else if (unformat (input, "check")) - is_check = 1; + is_check = 1; else if (unformat (input, "count %d", &count)) - ; + ; else - break; - } + break; + } if (mac_set == 0) return clib_error_return (0, "mac not set"); if (is_add == 0 && is_del == 0 && is_check == 0) - return clib_error_return (0, "noop: pick at least one of (add,del,check)"); + return clib_error_return (0, + "noop: pick at least one of (add,del,check)"); save_mac = mac; if (is_add) { for (i = 0; i < count; i++) - { - u64 tmp; - l2fib_add_entry(mac, bd_index, sw_if_index, mac, - filter_mac, bvi_mac); - tmp = clib_net_to_host_u64(mac); - tmp >>= 16; - tmp++; - tmp <<= 16; - mac = clib_host_to_net_u64 (tmp); - } + { + u64 tmp; + l2fib_add_entry (mac, bd_index, sw_if_index, mac, + filter_mac, bvi_mac); + tmp = clib_net_to_host_u64 (mac); + tmp >>= 16; + tmp++; + tmp <<= 16; + mac = clib_host_to_net_u64 (tmp); + } } if (is_check) { - BVT(clib_bihash_kv) kv; - l2fib_main_t * mp = &l2fib_main; + BVT (clib_bihash_kv) kv; + l2fib_main_t *mp = &l2fib_main; mac = save_mac; for (i = 0; i < count; i++) - { - u64 tmp; - kv.key = l2fib_make_key ((u8 *)&mac, bd_index); - if (BV(clib_bihash_search) (&mp->mac_table, &kv, &kv)) - { - clib_warning ("key %U AWOL", format_ethernet_address, &mac); - break; - } - tmp = clib_net_to_host_u64(mac); - tmp >>= 16; - tmp++; - tmp <<= 16; - mac = clib_host_to_net_u64 (tmp); - } + { + u64 tmp; + kv.key = l2fib_make_key ((u8 *) & mac, bd_index); + if (BV (clib_bihash_search) (&mp->mac_table, &kv, &kv)) + { + clib_warning ("key %U AWOL", format_ethernet_address, &mac); + break; + } + tmp = clib_net_to_host_u64 (mac); + tmp >>= 16; + tmp++; + tmp <<= 16; + mac = clib_host_to_net_u64 (tmp); + } } if (is_del) { for (i = 0; i < count; i++) - { - u64 tmp; - - l2fib_del_entry (mac, bd_index); - - tmp = clib_net_to_host_u64(mac); - tmp >>= 16; - tmp++; - tmp <<= 16; - mac = clib_host_to_net_u64 (tmp); - } + { + u64 tmp; + + l2fib_del_entry (mac, bd_index); + + tmp = clib_net_to_host_u64 (mac); + tmp >>= 16; + tmp++; + tmp <<= 16; + mac = clib_host_to_net_u64 (tmp); + } } return error; } +/* *INDENT-OFF* */ VLIB_CLI_COMMAND (l2fib_test_command, static) = { .path = "test l2fib", .short_help = "test l2fib [del] mac count ", .function = l2fib_test_command_fn, }; +/* *INDENT-ON* */ -// Delete an entry from the l2fib. -// Return 0 if the entry was deleted, or 1 if it was not found -u32 l2fib_del_entry (u64 mac, - u32 bd_index) { +/** + * Delete an entry from the l2fib. + * Return 0 if the entry was deleted, or 1 if it was not found + */ +u32 +l2fib_del_entry (u64 mac, u32 bd_index) +{ l2fib_entry_result_t result; - l2fib_main_t * mp = &l2fib_main; - BVT(clib_bihash_kv) kv; + l2fib_main_t *mp = &l2fib_main; + BVT (clib_bihash_kv) kv; - // set up key - kv.key = l2fib_make_key ((u8 *)&mac, bd_index); + /* set up key */ + kv.key = l2fib_make_key ((u8 *) & mac, bd_index); - if (BV(clib_bihash_search) (&mp->mac_table, &kv, &kv)) + if (BV (clib_bihash_search) (&mp->mac_table, &kv, &kv)) return 1; result.raw = kv.value; - // decrement counter if dynamically learned mac - if (result.fields.static_mac) { - if (l2learn_main.global_learn_count > 0) { - l2learn_main.global_learn_count--; + /* decrement counter if dynamically learned mac */ + if (result.fields.static_mac) + { + if (l2learn_main.global_learn_count > 0) + { + l2learn_main.global_learn_count--; + } } - } - // Remove entry from hash table - BV(clib_bihash_add_del) (&mp->mac_table, &kv, 0 /* is_add */); + /* Remove entry from hash table */ + BV (clib_bihash_add_del) (&mp->mac_table, &kv, 0 /* is_add */ ); return 0; } -// Delete an entry from the L2FIB -// The CLI format is: -// l2fib del +/** + * Delete an entry from the L2FIB + * The CLI format is: + * l2fib del + */ static clib_error_t * -l2fib_del (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) +l2fib_del (vlib_main_t * vm, + unformat_input_t * input, vlib_cli_command_t * cmd) { - bd_main_t * bdm = &bd_main; - clib_error_t * error = 0; + bd_main_t *bdm = &bd_main; + clib_error_t *error = 0; u64 mac; u32 bd_id; u32 bd_index; - uword * p; + uword *p; - if (! unformat_user (input, unformat_ethernet_address, &mac)) + if (!unformat_user (input, unformat_ethernet_address, &mac)) { error = clib_error_return (0, "expected mac address `%U'", - format_unformat_error, input); + format_unformat_error, input); goto done; } - - if (!unformat (input, "%d", &bd_id)) { + + if (!unformat (input, "%d", &bd_id)) + { error = clib_error_return (0, "expected bridge domain ID `%U'", - format_unformat_error, input); + format_unformat_error, input); goto done; - } + } p = hash_get (bdm->bd_index_by_bd_id, bd_id); - if (!p) { + if (!p) + { error = clib_error_return (0, "bridge domain ID %d invalid", bd_id); goto done; - } + } bd_index = p[0]; - // Delete the entry - if (l2fib_del_entry(mac, bd_index)) { - error = clib_error_return (0, "mac entry not found"); - goto done; - } + /* Delete the entry */ + if (l2fib_del_entry (mac, bd_index)) + { + error = clib_error_return (0, "mac entry not found"); + goto done; + } - done: +done: return error; } +/* *INDENT-OFF* */ VLIB_CLI_COMMAND (l2fib_del_cli, static) = { .path = "l2fib del", .short_help = "Delete l2fib mac forwarding entry ", .function = l2fib_del, }; +/* *INDENT-ON* */ -BVT(clib_bihash) *get_mac_table(void) { - l2fib_main_t * mp = &l2fib_main; +BVT (clib_bihash) * get_mac_table (void) +{ + l2fib_main_t *mp = &l2fib_main; return &mp->mac_table; } -clib_error_t *l2fib_init (vlib_main_t *vm) +clib_error_t * +l2fib_init (vlib_main_t * vm) { - l2fib_main_t * mp = &l2fib_main; + l2fib_main_t *mp = &l2fib_main; l2fib_entry_key_t test_key; u8 test_mac[6]; - + mp->vlib_main = vm; - mp->vnet_main = vnet_get_main(); + mp->vnet_main = vnet_get_main (); - // Create the hash table - BV(clib_bihash_init) (&mp->mac_table, "l2fib mac table", - L2FIB_NUM_BUCKETS, L2FIB_MEMORY_SIZE); + /* Create the hash table */ + BV (clib_bihash_init) (&mp->mac_table, "l2fib mac table", + L2FIB_NUM_BUCKETS, L2FIB_MEMORY_SIZE); - // verify the key constructor is good, since it is endian-sensitive - memset (test_mac, 0, sizeof(test_mac)); + /* verify the key constructor is good, since it is endian-sensitive */ + memset (test_mac, 0, sizeof (test_mac)); test_mac[0] = 0x11; test_key.raw = 0; - test_key.raw = l2fib_make_key ((u8 *)&test_mac, 0x1234); + test_key.raw = l2fib_make_key ((u8 *) & test_mac, 0x1234); ASSERT (test_key.fields.mac[0] == 0x11); ASSERT (test_key.fields.bd_index == 0x1234); @@ -566,3 +607,10 @@ clib_error_t *l2fib_init (vlib_main_t *vm) VLIB_INIT_FUNCTION (l2fib_init); +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/vnet/vnet/l2/l2_fib.h b/vnet/vnet/l2/l2_fib.h index 5498abf29b0..d1b8534dfde 100644 --- a/vnet/vnet/l2/l2_fib.h +++ b/vnet/vnet/l2/l2_fib.h @@ -30,13 +30,17 @@ /* * The L2fib key is the mac address and bridge domain ID */ -typedef struct { - union { - struct { +typedef struct +{ + union + { + struct + { u16 bd_index; - u8 mac[6]; + u8 mac[6]; } fields; - struct { + struct + { u32 w0; u32 w1; } words; @@ -44,20 +48,23 @@ typedef struct { }; } l2fib_entry_key_t; -/* +/* * The l2fib entry results */ -typedef struct { - union { - struct { - u32 sw_if_index; // output sw_if_index (L3 interface if bvi==1) - - u8 static_mac:1; // static mac, no dataplane learning - u8 bvi:1; // mac is for a bridged virtual interface - u8 filter:1; // drop packets to/from this mac - u8 refresh:1; // refresh flag for aging - u8 unused1:4; - u8 timestamp; // timestamp for aging +typedef struct +{ + union + { + struct + { + u32 sw_if_index; /* output sw_if_index (L3 interface if bvi==1) */ + + u8 static_mac:1; /* static mac, no dataplane learning */ + u8 bvi:1; /* mac is for a bridged virtual interface */ + u8 filter:1; /* drop packets to/from this mac */ + u8 refresh:1; /* refresh flag for aging */ + u8 unused1:4; + u8 timestamp; /* timestamp for aging */ u16 unused2; } fields; u64 raw; @@ -65,37 +72,48 @@ typedef struct { } l2fib_entry_result_t; -// Compute the hash for the given key and return the corresponding bucket index -always_inline -u32 l2fib_compute_hash_bucket (l2fib_entry_key_t *key) { +/** + * Compute the hash for the given key and return + * the corresponding bucket index + */ +always_inline u32 +l2fib_compute_hash_bucket (l2fib_entry_key_t * key) +{ u32 result; u32 temp_a; u32 temp_b; - result = 0xa5a5a5a5; // some seed + result = 0xa5a5a5a5; /* some seed */ temp_a = key->words.w0; temp_b = key->words.w1; - hash_mix32(temp_a, temp_b, result); + hash_mix32 (temp_a, temp_b, result); return result % L2FIB_NUM_BUCKETS; } -always_inline -u64 l2fib_make_key (u8 * mac_address, u16 bd_index) { +always_inline u64 +l2fib_make_key (u8 * mac_address, u16 bd_index) +{ u64 temp; - // The mac address in memory is A:B:C:D:E:F - // The bd id in register is H:L + /* + * The mac address in memory is A:B:C:D:E:F + * The bd id in register is H:L + */ #if CLIB_ARCH_IS_LITTLE_ENDIAN - // Create the in-register key as F:E:D:C:B:A:H:L - // In memory the key is L:H:A:B:C:D:E:F - temp = *((u64 *)(mac_address - 2)); - temp = (temp & ~0xffff) | (u64)(bd_index); + /* + * Create the in-register key as F:E:D:C:B:A:H:L + * In memory the key is L:H:A:B:C:D:E:F + */ + temp = *((u64 *) (mac_address - 2)); + temp = (temp & ~0xffff) | (u64) (bd_index); #else - // Create the in-register key as H:L:A:B:C:D:E:F - // In memory the key is H:L:A:B:C:D:E:F - temp = *((u64 *)(mac_address)) >> 16; - temp = temp | (((u64)bd_index) << 48); + /* + * Create the in-register key as H:L:A:B:C:D:E:F + * In memory the key is H:L:A:B:C:D:E:F + */ + temp = *((u64 *) (mac_address)) >> 16; + temp = temp | (((u64) bd_index) << 48); #endif return temp; @@ -103,124 +121,142 @@ u64 l2fib_make_key (u8 * mac_address, u16 bd_index) { -// Lookup the entry for mac and bd_index in the mac table for 1 packet. -// Cached_key and cached_result are used as a one-entry cache. -// The function reads and updates them as needed. -// -// mac0 and bd_index0 are the keys. The entry is written to result0. -// If the entry was not found, result0 is set to ~0. -// -// key0 and bucket0 return with the computed key and hash bucket, -// convenient if the entry needs to be updated afterward. -// If the cached_result was used, bucket0 is set to ~0. +/** + * Lookup the entry for mac and bd_index in the mac table for 1 packet. + * Cached_key and cached_result are used as a one-entry cache. + * The function reads and updates them as needed. + * + * mac0 and bd_index0 are the keys. The entry is written to result0. + * If the entry was not found, result0 is set to ~0. + * + * key0 and bucket0 return with the computed key and hash bucket, + * convenient if the entry needs to be updated afterward. + * If the cached_result was used, bucket0 is set to ~0. + */ static_always_inline void -l2fib_lookup_1 (BVT(clib_bihash) * mac_table, - l2fib_entry_key_t * cached_key, - l2fib_entry_result_t * cached_result, - u8 * mac0, - u16 bd_index0, - l2fib_entry_key_t * key0, - u32 * bucket0, - l2fib_entry_result_t *result0) +l2fib_lookup_1 (BVT (clib_bihash) * mac_table, + l2fib_entry_key_t * cached_key, + l2fib_entry_result_t * cached_result, + u8 * mac0, + u16 bd_index0, + l2fib_entry_key_t * key0, + u32 * bucket0, l2fib_entry_result_t * result0) { - // set up key + /* set up key */ key0->raw = l2fib_make_key (mac0, bd_index0); *bucket0 = ~0; - - if (key0->raw == cached_key->raw) { - // Hit in the one-entry cache - result0->raw = cached_result->raw; - } else { - // Do a regular mac table lookup - BVT(clib_bihash_kv) kv; - - kv.key = key0->raw; - kv.value = ~0ULL; - BV(clib_bihash_search_inline) (mac_table, &kv); - result0->raw = kv.value; - - // Update one-entry cache - cached_key->raw = key0->raw; - cached_result->raw = result0->raw; - } -} + if (key0->raw == cached_key->raw) + { + /* Hit in the one-entry cache */ + result0->raw = cached_result->raw; + } + else + { + /* Do a regular mac table lookup */ + BVT (clib_bihash_kv) kv; + + kv.key = key0->raw; + kv.value = ~0ULL; + BV (clib_bihash_search_inline) (mac_table, &kv); + result0->raw = kv.value; + + /* Update one-entry cache */ + cached_key->raw = key0->raw; + cached_result->raw = result0->raw; + } +} -// Lookup the entry for mac and bd_index in the mac table for 2 packets. -// The lookups for the two packets are interleaved. -// -// Cached_key and cached_result are used as a one-entry cache. -// The function reads and updates them as needed. -// -// mac0 and bd_index0 are the keys. The entry is written to result0. -// If the entry was not found, result0 is set to ~0. The same -// holds for mac1/bd_index1/result1. +/** + * Lookup the entry for mac and bd_index in the mac table for 2 packets. + * The lookups for the two packets are interleaved. + * + * Cached_key and cached_result are used as a one-entry cache. + * The function reads and updates them as needed. + * + * mac0 and bd_index0 are the keys. The entry is written to result0. + * If the entry was not found, result0 is set to ~0. The same + * holds for mac1/bd_index1/result1. + */ static_always_inline void -l2fib_lookup_2 (BVT(clib_bihash) * mac_table, - l2fib_entry_key_t * cached_key, - l2fib_entry_result_t * cached_result, - u8 * mac0, - u8 * mac1, - u16 bd_index0, - u16 bd_index1, - l2fib_entry_key_t * key0, - l2fib_entry_key_t * key1, - u32 * bucket0, - u32 * bucket1, - l2fib_entry_result_t *result0, - l2fib_entry_result_t *result1) +l2fib_lookup_2 (BVT (clib_bihash) * mac_table, + l2fib_entry_key_t * cached_key, + l2fib_entry_result_t * cached_result, + u8 * mac0, + u8 * mac1, + u16 bd_index0, + u16 bd_index1, + l2fib_entry_key_t * key0, + l2fib_entry_key_t * key1, + u32 * bucket0, + u32 * bucket1, + l2fib_entry_result_t * result0, + l2fib_entry_result_t * result1) { - // set up key + /* set up key */ key0->raw = l2fib_make_key (mac0, bd_index0); key1->raw = l2fib_make_key (mac1, bd_index1); - if ((key0->raw == cached_key->raw) && - (key1->raw == cached_key->raw)) { - // Both hit in the one-entry cache - result0->raw = cached_result->raw; - result1->raw = cached_result->raw; - *bucket0 = ~0; - *bucket1 = ~0; - - } else { - BVT(clib_bihash_kv) kv0, kv1; - - // Do a regular mac table lookup - // Interleave lookups for packet 0 and packet 1 - kv0.key = key0->raw; - kv1.key = key1->raw; - kv0.value = ~0ULL; - kv1.value = ~0ULL; - - BV(clib_bihash_search_inline) (mac_table, &kv0); - BV(clib_bihash_search_inline) (mac_table, &kv1); - - result0->raw = kv0.value; - result1->raw = kv1.value; - - // Update one-entry cache - cached_key->raw = key1->raw; - cached_result->raw = result1->raw; - } + if ((key0->raw == cached_key->raw) && (key1->raw == cached_key->raw)) + { + /* Both hit in the one-entry cache */ + result0->raw = cached_result->raw; + result1->raw = cached_result->raw; + *bucket0 = ~0; + *bucket1 = ~0; + + } + else + { + BVT (clib_bihash_kv) kv0, kv1; + + /* + * Do a regular mac table lookup + * Interleave lookups for packet 0 and packet 1 + */ + kv0.key = key0->raw; + kv1.key = key1->raw; + kv0.value = ~0ULL; + kv1.value = ~0ULL; + + BV (clib_bihash_search_inline) (mac_table, &kv0); + BV (clib_bihash_search_inline) (mac_table, &kv1); + + result0->raw = kv0.value; + result1->raw = kv1.value; + + /* Update one-entry cache */ + cached_key->raw = key1->raw; + cached_result->raw = result1->raw; + } } -BVT(clib_bihash) *get_mac_table(void); -void l2fib_clear_table (uint keep_static); -void l2fib_add_entry (u64 mac, - u32 bd_index, - u32 sw_if_index, - u32 static_mac, - u32 drop_mac, - u32 bvi_mac); -u32 l2fib_del_entry (u64 mac, - u32 bd_index); +BVT (clib_bihash) * get_mac_table (void); + void + l2fib_clear_table (uint keep_static); + void + l2fib_add_entry (u64 mac, + u32 bd_index, + u32 sw_if_index, + u32 static_mac, u32 drop_mac, u32 bvi_mac); +u32 +l2fib_del_entry (u64 mac, u32 bd_index); -void l2fib_table_dump (u32 bd_index, l2fib_entry_key_t **l2fe_key, - l2fib_entry_result_t **l2fe_res); + void + l2fib_table_dump (u32 bd_index, l2fib_entry_key_t ** l2fe_key, + l2fib_entry_result_t ** l2fe_res); -u8 * format_vnet_sw_if_index_name_with_NA (u8 * s, va_list * args); + u8 *format_vnet_sw_if_index_name_with_NA (u8 * s, va_list * args); #endif + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/vnet/vnet/l2/l2_flood.c b/vnet/vnet/l2/l2_flood.c index 61554ac1244..0654fe293b8 100644 --- a/vnet/vnet/l2/l2_flood.c +++ b/vnet/vnet/l2/l2_flood.c @@ -1,5 +1,5 @@ /* - * l2_flood.c : layer 2 flooding + * l2_flood.c : layer 2 flooding * * Copyright (c) 2013 Cisco and/or its affiliates. * Licensed under the Apache License, Version 2.0 (the "License"); @@ -43,20 +43,22 @@ */ -typedef struct { +typedef struct +{ - // Next nodes for each feature + /* Next nodes for each feature */ u32 feat_next_node_index[32]; - - // next node index for the L3 input node of each ethertype + + /* next node index for the L3 input node of each ethertype */ next_by_ethertype_t l3_next; /* convenience variables */ - vlib_main_t * vlib_main; - vnet_main_t * vnet_main; + vlib_main_t *vlib_main; + vnet_main_t *vnet_main; } l2flood_main_t; -typedef struct { +typedef struct +{ u8 src[6]; u8 dst[6]; u32 sw_if_index; @@ -65,17 +67,17 @@ typedef struct { /* packet trace format function */ -static u8 * format_l2flood_trace (u8 * s, va_list * args) +static u8 * +format_l2flood_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 *); - l2flood_trace_t * t = va_arg (*args, l2flood_trace_t *); - + l2flood_trace_t *t = va_arg (*args, l2flood_trace_t *); + s = format (s, "l2-flood: sw_if_index %d dst %U src %U bd_index %d", - t->sw_if_index, - format_ethernet_address, t->dst, - format_ethernet_address, t->src, - t->bd_index); + t->sw_if_index, + format_ethernet_address, t->dst, + format_ethernet_address, t->src, t->bd_index); return s; } @@ -90,20 +92,22 @@ _(NO_MEMBERS, "L2 replication complete") \ _(BVI_BAD_MAC, "BVI L3 mac mismatch") \ _(BVI_ETHERTYPE, "BVI packet with unhandled ethertype") -typedef enum { +typedef enum +{ #define _(sym,str) L2FLOOD_ERROR_##sym, foreach_l2flood_error #undef _ - L2FLOOD_N_ERROR, + L2FLOOD_N_ERROR, } l2flood_error_t; -static char * l2flood_error_strings[] = { +static char *l2flood_error_strings[] = { #define _(sym,string) string, foreach_l2flood_error #undef _ }; -typedef enum { +typedef enum +{ L2FLOOD_NEXT_L2_OUTPUT, L2FLOOD_NEXT_DROP, L2FLOOD_N_NEXT, @@ -114,211 +118,226 @@ typedef enum { * * Due to the way BVI processing can modify the packet, the BVI interface * (if present) must be processed last in the replication. The member vector - * is arranged so that the BVI interface is always the first element. + * is arranged so that the BVI interface is always the first element. * Flooding walks the vector in reverse. * * BVI processing causes the packet to go to L3 processing. This strips the * L2 header, which is fine because the replication infrastructure restores * it. However L3 processing can trigger larger changes to the packet. For * example, an ARP request could be turned into an ARP reply, an ICMP request - * could be turned into an ICMP reply. If BVI processing is not performed - * last, the modified packet would be replicated to the remaining members. + * could be turned into an ICMP reply. If BVI processing is not performed + * last, the modified packet would be replicated to the remaining members. */ static_always_inline void l2flood_process (vlib_main_t * vm, - vlib_node_runtime_t * node, - l2flood_main_t * msm, - u64 * counter_base, - vlib_buffer_t * b0, - u32 * sw_if_index0, - l2fib_entry_key_t * key0, - u32 * bucket0, - l2fib_entry_result_t * result0, - u32 * next0) + vlib_node_runtime_t * node, + l2flood_main_t * msm, + u64 * counter_base, + vlib_buffer_t * b0, + u32 * sw_if_index0, + l2fib_entry_key_t * key0, + u32 * bucket0, l2fib_entry_result_t * result0, u32 * next0) { u16 bd_index0; l2_bridge_domain_t *bd_config; - l2_flood_member_t * members; - i32 current_member; // signed - replication_context_t * ctx; - u8 in_shg = vnet_buffer(b0)->l2.shg; - - if (!replication_is_recycled(b0)) { - - // Do flood "prep node" processing - - // Get config for the bridge domain interface - bd_index0 = vnet_buffer(b0)->l2.bd_index; - bd_config = vec_elt_at_index(l2input_main.bd_configs, bd_index0); - members = bd_config->members; - - // Find first member that passes the reflection and SHG checks - current_member = vec_len(members) - 1; - while ((current_member >= 0) && - ((members[current_member].sw_if_index == *sw_if_index0) || - (in_shg && members[current_member].shg == in_shg))) { - current_member--; - } + l2_flood_member_t *members; + i32 current_member; /* signed */ + replication_context_t *ctx; + u8 in_shg = vnet_buffer (b0)->l2.shg; - if (current_member < 0) { - // No members to flood to - *next0 = L2FLOOD_NEXT_DROP; - b0->error = node->errors[L2FLOOD_ERROR_NO_MEMBERS]; - return; - } + if (!replication_is_recycled (b0)) + { + + /* Do flood "prep node" processing */ + + /* Get config for the bridge domain interface */ + bd_index0 = vnet_buffer (b0)->l2.bd_index; + bd_config = vec_elt_at_index (l2input_main.bd_configs, bd_index0); + members = bd_config->members; + + /* Find first member that passes the reflection and SHG checks */ + current_member = vec_len (members) - 1; + while ((current_member >= 0) && + ((members[current_member].sw_if_index == *sw_if_index0) || + (in_shg && members[current_member].shg == in_shg))) + { + current_member--; + } + + if (current_member < 0) + { + /* No members to flood to */ + *next0 = L2FLOOD_NEXT_DROP; + b0->error = node->errors[L2FLOOD_ERROR_NO_MEMBERS]; + return; + } + + if ((current_member > 0) && + ((current_member > 1) || + ((members[0].sw_if_index != *sw_if_index0) && + (!in_shg || members[0].shg != in_shg)))) + { + /* If more than one member then initiate replication */ + ctx = + replication_prep (vm, b0, l2flood_node.index, 1 /* l2_packet */ ); + ctx->feature_replicas = (uword) members; + ctx->feature_counter = current_member; + } - if ((current_member > 0) && - ((current_member > 1) || - ((members[0].sw_if_index != *sw_if_index0) && - (!in_shg || members[0].shg != in_shg)))) { - // If more than one member then initiate replication - ctx = replication_prep (vm, b0, l2flood_node.index, 1 /* l2_packet */); - ctx->feature_replicas = (uword) members; - ctx->feature_counter = current_member; } + else + { + vnet_buffer_opaque_t *vnet_buff_op; - } else { - vnet_buffer_opaque_t *vnet_buff_op; + /* Do flood "recycle node" processing */ - // Do flood "recycle node" processing + if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_REPL_FAIL)) + { + (void) replication_recycle (vm, b0, 1 /* is_last */ ); + *next0 = L2FLOOD_NEXT_DROP; + b0->error = node->errors[L2FLOOD_ERROR_REPL_FAIL]; + return; + } - if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_REPL_FAIL)) - { - (void)replication_recycle (vm, b0, 1 /* is_last */); - *next0 = L2FLOOD_NEXT_DROP; - b0->error = node->errors[L2FLOOD_ERROR_REPL_FAIL]; - return; - } + ctx = replication_get_ctx (b0); + replication_clear_recycled (b0); - ctx = replication_get_ctx (b0); - replication_clear_recycled (b0); + members = (l2_flood_member_t *) (intptr_t) ctx->feature_replicas; + current_member = (i32) ctx->feature_counter - 1; - members = (l2_flood_member_t *)(intptr_t) ctx->feature_replicas; - current_member = (i32)ctx->feature_counter - 1; + /* Need to update input index from saved packet context */ + vnet_buff_op = (vnet_buffer_opaque_t *) ctx->vnet_buffer; + *sw_if_index0 = vnet_buff_op->sw_if_index[VLIB_RX]; - // Need to update input index from saved packet context - vnet_buff_op = (vnet_buffer_opaque_t *)ctx->vnet_buffer; - *sw_if_index0 = vnet_buff_op->sw_if_index[VLIB_RX]; + /* Find next member that passes the reflection and SHG check */ + while ((current_member >= 0) && + ((members[current_member].sw_if_index == *sw_if_index0) || + (in_shg && members[current_member].shg == in_shg))) + { + current_member--; + } - // Find next member that passes the reflection and SHG check - while ((current_member >= 0) && - ((members[current_member].sw_if_index == *sw_if_index0) || - (in_shg && members[current_member].shg == in_shg))) { - current_member--; - } + if (current_member < 0) + { + /* + * No more members to flood to. + * Terminate replication and drop packet. + */ - if (current_member < 0) { - // No more members to flood to. - // Terminate replication and drop packet. + replication_recycle (vm, b0, 1 /* is_last */ ); - replication_recycle (vm, b0, 1 /* is_last */); + *next0 = L2FLOOD_NEXT_DROP; + /* Ideally we woudn't bump a counter here, just silently complete */ + b0->error = node->errors[L2FLOOD_ERROR_NO_MEMBERS]; + return; + } - *next0 = L2FLOOD_NEXT_DROP; - // Ideally we woudn't bump a counter here, just silently complete - b0->error = node->errors[L2FLOOD_ERROR_NO_MEMBERS]; - return; + /* Restore packet and context and continue replication */ + ctx->feature_counter = current_member; + replication_recycle (vm, b0, ((current_member == 0) || /*is_last */ + ((current_member == 1) && + ((members[0].sw_if_index == + *sw_if_index0) || (in_shg + && members[0].shg == + in_shg))))); } - // Restore packet and context and continue replication - ctx->feature_counter = current_member; - replication_recycle (vm, b0, - ((current_member == 0) || /*is_last */ - ((current_member == 1) && - ((members[0].sw_if_index == *sw_if_index0) || - (in_shg && members[0].shg == in_shg))))); - } - - // Forward packet to the current member - - if (PREDICT_TRUE(members[current_member].flags == L2_FLOOD_MEMBER_NORMAL)) { - // Do normal L2 forwarding - vnet_buffer(b0)->sw_if_index[VLIB_TX] = members[current_member].sw_if_index; - *next0 = L2FLOOD_NEXT_L2_OUTPUT; - - } else { - // Do BVI processing - u32 rc; - rc = l2_to_bvi (vm, - msm->vnet_main, - b0, - members[current_member].sw_if_index, - &msm->l3_next, - next0); - - if (PREDICT_FALSE(rc)) { - if (rc == TO_BVI_ERR_BAD_MAC) { - b0->error = node->errors[L2FLOOD_ERROR_BVI_BAD_MAC]; - *next0 = L2FLOOD_NEXT_DROP; - } else if (rc == TO_BVI_ERR_ETHERTYPE) { - b0->error = node->errors[L2FLOOD_ERROR_BVI_ETHERTYPE]; - *next0 = L2FLOOD_NEXT_DROP; - } + /* Forward packet to the current member */ + + if (PREDICT_TRUE (members[current_member].flags == L2_FLOOD_MEMBER_NORMAL)) + { + /* Do normal L2 forwarding */ + vnet_buffer (b0)->sw_if_index[VLIB_TX] = + members[current_member].sw_if_index; + *next0 = L2FLOOD_NEXT_L2_OUTPUT; + + } + else + { + /* Do BVI processing */ + u32 rc; + rc = l2_to_bvi (vm, + msm->vnet_main, + b0, + members[current_member].sw_if_index, + &msm->l3_next, next0); + + if (PREDICT_FALSE (rc)) + { + if (rc == TO_BVI_ERR_BAD_MAC) + { + b0->error = node->errors[L2FLOOD_ERROR_BVI_BAD_MAC]; + *next0 = L2FLOOD_NEXT_DROP; + } + else if (rc == TO_BVI_ERR_ETHERTYPE) + { + b0->error = node->errors[L2FLOOD_ERROR_BVI_ETHERTYPE]; + *next0 = L2FLOOD_NEXT_DROP; + } + } } - } } static uword l2flood_node_fn (vlib_main_t * vm, - vlib_node_runtime_t * node, - vlib_frame_t * frame) + vlib_node_runtime_t * node, vlib_frame_t * frame) { - u32 n_left_from, * from, * to_next; + u32 n_left_from, *from, *to_next; l2flood_next_t next_index; - l2flood_main_t * msm = &l2flood_main; + l2flood_main_t *msm = &l2flood_main; vlib_node_t *n = vlib_get_node (vm, l2flood_node.index); u32 node_counter_base_index = n->error_heap_index; - vlib_error_main_t * em = &vm->error_main; + vlib_error_main_t *em = &vm->error_main; from = vlib_frame_vector_args (frame); - n_left_from = frame->n_vectors; /* number of packets to process */ + n_left_from = frame->n_vectors; /* number of packets to process */ next_index = node->cached_next_index; - + while (n_left_from > 0) { u32 n_left_to_next; /* get space to enqueue frame to graph node "next_index" */ - vlib_get_next_frame (vm, node, next_index, - to_next, n_left_to_next); + vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next); while (n_left_from >= 6 && n_left_to_next >= 2) { - u32 bi0, bi1; - vlib_buffer_t * b0, * b1; - u32 next0, next1; - u32 sw_if_index0, sw_if_index1; - l2fib_entry_key_t key0, key1; - l2fib_entry_result_t result0, result1; - u32 bucket0, bucket1; - + u32 bi0, bi1; + vlib_buffer_t *b0, *b1; + u32 next0, next1; + u32 sw_if_index0, sw_if_index1; + l2fib_entry_key_t key0, key1; + l2fib_entry_result_t result0, result1; + u32 bucket0, bucket1; + /* Prefetch next iteration. */ { - vlib_buffer_t * p2, * p3, * p4, * p5; - + vlib_buffer_t *p2, *p3, *p4, *p5; + p2 = vlib_get_buffer (vm, from[2]); p3 = vlib_get_buffer (vm, from[3]); p4 = vlib_get_buffer (vm, from[4]); p5 = vlib_get_buffer (vm, from[5]); - - // Prefetch the buffer header for the N+2 loop iteration + + /* Prefetch the buffer header for the N+2 loop iteration */ vlib_prefetch_buffer_header (p4, LOAD); vlib_prefetch_buffer_header (p5, LOAD); - // Prefetch the replication context for the N+1 loop iteration - // This depends on the buffer header above - replication_prefetch_ctx (p2); - replication_prefetch_ctx (p3); + /* Prefetch the replication context for the N+1 loop iteration */ + /* This depends on the buffer header above */ + replication_prefetch_ctx (p2); + replication_prefetch_ctx (p3); - // Prefetch the packet for the N+1 loop iteration + /* Prefetch the packet for the N+1 loop iteration */ CLIB_PREFETCH (p2->data, CLIB_CACHE_LINE_BYTES, STORE); CLIB_PREFETCH (p3->data, CLIB_CACHE_LINE_BYTES, STORE); } - /* speculatively enqueue b0 and b1 to the current next frame */ - /* bi is "buffer index", b is pointer to the buffer */ + /* speculatively enqueue b0 and b1 to the current next frame */ + /* bi is "buffer index", b is pointer to the buffer */ to_next[0] = bi0 = from[0]; to_next[1] = bi1 = from[1]; from += 2; @@ -328,60 +347,64 @@ l2flood_node_fn (vlib_main_t * vm, b0 = vlib_get_buffer (vm, bi0); b1 = vlib_get_buffer (vm, bi1); - - /* RX interface handles */ - sw_if_index0 = vnet_buffer(b0)->sw_if_index[VLIB_RX]; - sw_if_index1 = vnet_buffer(b1)->sw_if_index[VLIB_RX]; - - /* process 2 pkts */ - em->counters[node_counter_base_index + L2FLOOD_ERROR_L2FLOOD] += 2; - - l2flood_process (vm, node, msm, &em->counters[node_counter_base_index], - b0, &sw_if_index0, &key0, &bucket0, &result0, &next0); - - l2flood_process (vm, node, msm, &em->counters[node_counter_base_index], - b1, &sw_if_index1, &key1, &bucket1, &result1, &next1); - - if (PREDICT_FALSE((node->flags & VLIB_NODE_FLAG_TRACE))) - { - if (PREDICT_FALSE(b0->flags & VLIB_BUFFER_IS_TRACED)) - { - l2flood_trace_t *t = vlib_add_trace (vm, node, b0, sizeof (*t)); - ethernet_header_t * h0 = vlib_buffer_get_current (b0); - t->sw_if_index = sw_if_index0; - t->bd_index = vnet_buffer(b0)->l2.bd_index; - clib_memcpy(t->src, h0->src_address, 6); - clib_memcpy(t->dst, h0->dst_address, 6); - } - if (PREDICT_FALSE(b1->flags & VLIB_BUFFER_IS_TRACED)) - { - l2flood_trace_t *t = vlib_add_trace (vm, node, b1, sizeof (*t)); - ethernet_header_t * h1 = vlib_buffer_get_current (b1); - t->sw_if_index = sw_if_index1; - t->bd_index = vnet_buffer(b1)->l2.bd_index; - clib_memcpy(t->src, h1->src_address, 6); - clib_memcpy(t->dst, h1->dst_address, 6); - } - } - - /* verify speculative enqueues, maybe switch current next frame */ - /* if next0==next1==next_index then nothing special needs to be done */ - vlib_validate_buffer_enqueue_x2 (vm, node, next_index, - to_next, n_left_to_next, - bi0, bi1, next0, next1); - } - + + /* RX interface handles */ + sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX]; + sw_if_index1 = vnet_buffer (b1)->sw_if_index[VLIB_RX]; + + /* process 2 pkts */ + em->counters[node_counter_base_index + L2FLOOD_ERROR_L2FLOOD] += 2; + + l2flood_process (vm, node, msm, + &em->counters[node_counter_base_index], b0, + &sw_if_index0, &key0, &bucket0, &result0, &next0); + + l2flood_process (vm, node, msm, + &em->counters[node_counter_base_index], b1, + &sw_if_index1, &key1, &bucket1, &result1, &next1); + + if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE))) + { + if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED)) + { + l2flood_trace_t *t = + vlib_add_trace (vm, node, b0, sizeof (*t)); + ethernet_header_t *h0 = vlib_buffer_get_current (b0); + t->sw_if_index = sw_if_index0; + t->bd_index = vnet_buffer (b0)->l2.bd_index; + clib_memcpy (t->src, h0->src_address, 6); + clib_memcpy (t->dst, h0->dst_address, 6); + } + if (PREDICT_FALSE (b1->flags & VLIB_BUFFER_IS_TRACED)) + { + l2flood_trace_t *t = + vlib_add_trace (vm, node, b1, sizeof (*t)); + ethernet_header_t *h1 = vlib_buffer_get_current (b1); + t->sw_if_index = sw_if_index1; + t->bd_index = vnet_buffer (b1)->l2.bd_index; + clib_memcpy (t->src, h1->src_address, 6); + clib_memcpy (t->dst, h1->dst_address, 6); + } + } + + /* verify speculative enqueues, maybe switch current next frame */ + /* if next0==next1==next_index then nothing special needs to be done */ + vlib_validate_buffer_enqueue_x2 (vm, node, next_index, + to_next, n_left_to_next, + bi0, bi1, next0, next1); + } + while (n_left_from > 0 && n_left_to_next > 0) { - u32 bi0; - vlib_buffer_t * b0; - u32 next0; - u32 sw_if_index0; - l2fib_entry_key_t key0; - l2fib_entry_result_t result0; - u32 bucket0; - - /* speculatively enqueue b0 to the current next frame */ + u32 bi0; + vlib_buffer_t *b0; + u32 next0; + u32 sw_if_index0; + l2fib_entry_key_t key0; + l2fib_entry_result_t result0; + u32 bucket0; + + /* speculatively enqueue b0 to the current next frame */ bi0 = from[0]; to_next[0] = bi0; from += 1; @@ -391,26 +414,27 @@ l2flood_node_fn (vlib_main_t * vm, b0 = vlib_get_buffer (vm, bi0); - sw_if_index0 = vnet_buffer(b0)->sw_if_index[VLIB_RX]; - - /* process 1 pkt */ - em->counters[node_counter_base_index + L2FLOOD_ERROR_L2FLOOD] += 1; - - l2flood_process (vm, node, msm, &em->counters[node_counter_base_index], - b0, &sw_if_index0, &key0, &bucket0, &result0, &next0); - - if (PREDICT_FALSE((node->flags & VLIB_NODE_FLAG_TRACE) && - (b0->flags & VLIB_BUFFER_IS_TRACED))) - { - l2flood_trace_t *t = vlib_add_trace (vm, node, b0, sizeof (*t)); - ethernet_header_t * h0 = vlib_buffer_get_current (b0); - t->sw_if_index = sw_if_index0; - t->bd_index = vnet_buffer(b0)->l2.bd_index; - clib_memcpy(t->src, h0->src_address, 6); - clib_memcpy(t->dst, h0->dst_address, 6); - } - - /* verify speculative enqueue, maybe switch current next frame */ + sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX]; + + /* process 1 pkt */ + em->counters[node_counter_base_index + L2FLOOD_ERROR_L2FLOOD] += 1; + + l2flood_process (vm, node, msm, + &em->counters[node_counter_base_index], b0, + &sw_if_index0, &key0, &bucket0, &result0, &next0); + + if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE) && + (b0->flags & VLIB_BUFFER_IS_TRACED))) + { + l2flood_trace_t *t = vlib_add_trace (vm, node, b0, sizeof (*t)); + ethernet_header_t *h0 = vlib_buffer_get_current (b0); + t->sw_if_index = sw_if_index0; + t->bd_index = vnet_buffer (b0)->l2.bd_index; + clib_memcpy (t->src, h0->src_address, 6); + clib_memcpy (t->dst, h0->dst_address, 6); + } + + /* verify speculative enqueue, maybe switch current next frame */ vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next, n_left_to_next, bi0, next0); @@ -423,13 +447,14 @@ l2flood_node_fn (vlib_main_t * vm, } +/* *INDENT-OFF* */ VLIB_REGISTER_NODE (l2flood_node,static) = { .function = l2flood_node_fn, .name = "l2-flood", .vector_size = sizeof (u32), .format_trace = format_l2flood_trace, .type = VLIB_NODE_TYPE_INTERNAL, - + .n_errors = ARRAY_LEN(l2flood_error_strings), .error_strings = l2flood_error_strings, @@ -441,22 +466,22 @@ VLIB_REGISTER_NODE (l2flood_node,static) = { [L2FLOOD_NEXT_DROP] = "error-drop", }, }; +/* *INDENT-ON* */ VLIB_NODE_FUNCTION_MULTIARCH (l2flood_node, l2flood_node_fn) - -clib_error_t *l2flood_init (vlib_main_t *vm) + clib_error_t *l2flood_init (vlib_main_t * vm) { - l2flood_main_t * mp = &l2flood_main; - + l2flood_main_t *mp = &l2flood_main; + mp->vlib_main = vm; - mp->vnet_main = vnet_get_main(); + mp->vnet_main = vnet_get_main (); - // Initialize the feature next-node indexes - feat_bitmap_init_next_nodes(vm, - l2flood_node.index, - L2INPUT_N_FEAT, - l2input_get_feat_names(), - mp->feat_next_node_index); + /* Initialize the feature next-node indexes */ + feat_bitmap_init_next_nodes (vm, + l2flood_node.index, + L2INPUT_N_FEAT, + l2input_get_feat_names (), + mp->feat_next_node_index); return 0; } @@ -465,57 +490,66 @@ VLIB_INIT_FUNCTION (l2flood_init); -// Add the L3 input node for this ethertype to the next nodes structure +/** Add the L3 input node for this ethertype to the next nodes structure */ void l2flood_register_input_type (vlib_main_t * vm, - ethernet_type_t type, - u32 node_index) + ethernet_type_t type, u32 node_index) { - l2flood_main_t * mp = &l2flood_main; + l2flood_main_t *mp = &l2flood_main; u32 next_index; - next_index = vlib_node_add_next (vm, - l2flood_node.index, - node_index); + next_index = vlib_node_add_next (vm, l2flood_node.index, node_index); next_by_ethertype_register (&mp->l3_next, type, next_index); } -// set subinterface flood enable/disable -// The CLI format is: -// set interface l2 flood [disable] +/** + * set subinterface flood enable/disable + * The CLI format is: + * set interface l2 flood [disable] + */ static clib_error_t * int_flood (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) + unformat_input_t * input, vlib_cli_command_t * cmd) { - vnet_main_t * vnm = vnet_get_main(); - clib_error_t * error = 0; + vnet_main_t *vnm = vnet_get_main (); + clib_error_t *error = 0; u32 sw_if_index; u32 enable; - if (! unformat_user (input, unformat_vnet_sw_interface, vnm, &sw_if_index)) + if (!unformat_user (input, unformat_vnet_sw_interface, vnm, &sw_if_index)) { error = clib_error_return (0, "unknown interface `%U'", - format_unformat_error, input); + format_unformat_error, input); goto done; } enable = 1; - if (unformat (input, "disable")) { - enable = 0; - } + if (unformat (input, "disable")) + { + enable = 0; + } - // set the interface flag - l2input_intf_bitmap_enable(sw_if_index, L2INPUT_FEAT_FLOOD, enable); + /* set the interface flag */ + l2input_intf_bitmap_enable (sw_if_index, L2INPUT_FEAT_FLOOD, enable); - done: +done: return error; } +/* *INDENT-OFF* */ VLIB_CLI_COMMAND (int_flood_cli, static) = { .path = "set interface l2 flood", .short_help = "set interface l2 flood [disable]", .function = int_flood, }; +/* *INDENT-ON* */ + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/vnet/vnet/l2/l2_flood.h b/vnet/vnet/l2/l2_flood.h index 3c9273d48d5..acd7c905aaf 100644 --- a/vnet/vnet/l2/l2_flood.h +++ b/vnet/vnet/l2/l2_flood.h @@ -23,6 +23,13 @@ void l2flood_register_input_type (vlib_main_t * vm, - ethernet_type_t type, - u32 node_index); + ethernet_type_t type, u32 node_index); #endif + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/vnet/vnet/l2/l2_fwd.c b/vnet/vnet/l2/l2_fwd.c index d2c99ce2a5e..4950b23a8f0 100644 --- a/vnet/vnet/l2/l2_fwd.c +++ b/vnet/vnet/l2/l2_fwd.c @@ -31,21 +31,23 @@ #include -typedef struct { +typedef struct +{ - // Hash table - BVT(clib_bihash) *mac_table; + /* Hash table */ + BVT (clib_bihash) * mac_table; - // next node index for the L3 input node of each ethertype + /* next node index for the L3 input node of each ethertype */ next_by_ethertype_t l3_next; /* convenience variables */ - vlib_main_t * vlib_main; - vnet_main_t * vnet_main; + vlib_main_t *vlib_main; + vnet_main_t *vnet_main; } l2fwd_main_t; -typedef struct { - /* per-pkt trace data */ +typedef struct +{ + /* per-pkt trace data */ u8 src[6]; u8 dst[6]; u32 sw_if_index; @@ -53,17 +55,17 @@ typedef struct { } l2fwd_trace_t; /* packet trace format function */ -static u8 * format_l2fwd_trace (u8 * s, va_list * args) +static u8 * +format_l2fwd_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 *); - l2fwd_trace_t * t = va_arg (*args, l2fwd_trace_t *); - + l2fwd_trace_t *t = va_arg (*args, l2fwd_trace_t *); + s = format (s, "l2-fwd: sw_if_index %d dst %U src %U bd_index %d", t->sw_if_index, - format_ethernet_address, t->dst, - format_ethernet_address, t->src, - t->bd_index); + format_ethernet_address, t->dst, + format_ethernet_address, t->src, t->bd_index); return s; } @@ -80,114 +82,129 @@ _(BVI_ETHERTYPE, "BVI packet with unhandled ethertype") \ _(FILTER_DROP, "Filter Mac Drop") \ _(REFLECT_DROP, "Reflection Drop") -typedef enum { +typedef enum +{ #define _(sym,str) L2FWD_ERROR_##sym, foreach_l2fwd_error #undef _ - L2FWD_N_ERROR, + L2FWD_N_ERROR, } l2fwd_error_t; -static char * l2fwd_error_strings[] = { +static char *l2fwd_error_strings[] = { #define _(sym,string) string, foreach_l2fwd_error #undef _ }; -typedef enum { +typedef enum +{ L2FWD_NEXT_L2_OUTPUT, L2FWD_NEXT_FLOOD, L2FWD_NEXT_DROP, L2FWD_N_NEXT, } l2fwd_next_t; -// Forward one packet based on the mac table lookup result +/** Forward one packet based on the mac table lookup result */ static_always_inline void l2fwd_process (vlib_main_t * vm, - vlib_node_runtime_t * node, - l2fwd_main_t * msm, - vlib_error_main_t * em, - vlib_buffer_t * b0, - u32 sw_if_index0, - l2fib_entry_result_t * result0, - u32 * next0) + vlib_node_runtime_t * node, + l2fwd_main_t * msm, + vlib_error_main_t * em, + vlib_buffer_t * b0, + u32 sw_if_index0, l2fib_entry_result_t * result0, u32 * next0) { - if (PREDICT_FALSE (result0->raw == ~0)) { - // lookup miss, so flood - // TODO:replicate packet to each intf in bridge-domain - // For now just drop - if (vnet_buffer(b0)->l2.feature_bitmap & L2INPUT_FEAT_UU_FLOOD) { - *next0 = L2FWD_NEXT_FLOOD; - } else { - // Flooding is disabled - b0->error = node->errors[L2FWD_ERROR_FLOOD]; - *next0 = L2FWD_NEXT_DROP; - } + if (PREDICT_FALSE (result0->raw == ~0)) + { + /* + * lookup miss, so flood + * TODO:replicate packet to each intf in bridge-domain + * For now just drop + */ + if (vnet_buffer (b0)->l2.feature_bitmap & L2INPUT_FEAT_UU_FLOOD) + { + *next0 = L2FWD_NEXT_FLOOD; + } + else + { + /* Flooding is disabled */ + b0->error = node->errors[L2FWD_ERROR_FLOOD]; + *next0 = L2FWD_NEXT_DROP; + } - } else { + } + else + { - // lookup hit, forward packet + /* lookup hit, forward packet */ #ifdef COUNTERS - em->counters[node_counter_base_index + L2FWD_ERROR_HIT] += 1; -#endif - - vnet_buffer(b0)->sw_if_index[VLIB_TX] = result0->fields.sw_if_index; - *next0 = L2FWD_NEXT_L2_OUTPUT; - - // perform reflection check - if (PREDICT_FALSE (sw_if_index0 == result0->fields.sw_if_index)) { - b0->error = node->errors[L2FWD_ERROR_REFLECT_DROP]; - *next0 = L2FWD_NEXT_DROP; - - // perform filter check - } else if (PREDICT_FALSE (result0->fields.filter)) { - b0->error = node->errors[L2FWD_ERROR_FILTER_DROP]; - *next0 = L2FWD_NEXT_DROP; - - // perform BVI check - } else if (PREDICT_FALSE (result0->fields.bvi)) { - u32 rc; - rc = l2_to_bvi (vm, - msm->vnet_main, - b0, - vnet_buffer(b0)->sw_if_index[VLIB_TX], - &msm->l3_next, - next0); - - if (PREDICT_FALSE(rc)) { - if (rc == TO_BVI_ERR_BAD_MAC) { - b0->error = node->errors[L2FWD_ERROR_BVI_BAD_MAC]; - *next0 = L2FWD_NEXT_DROP; - } else if (rc == TO_BVI_ERR_ETHERTYPE) { - b0->error = node->errors[L2FWD_ERROR_BVI_ETHERTYPE]; - *next0 = L2FWD_NEXT_DROP; - } - } + em->counters[node_counter_base_index + L2FWD_ERROR_HIT] += 1; +#endif + + vnet_buffer (b0)->sw_if_index[VLIB_TX] = result0->fields.sw_if_index; + *next0 = L2FWD_NEXT_L2_OUTPUT; + + /* perform reflection check */ + if (PREDICT_FALSE (sw_if_index0 == result0->fields.sw_if_index)) + { + b0->error = node->errors[L2FWD_ERROR_REFLECT_DROP]; + *next0 = L2FWD_NEXT_DROP; + + /* perform filter check */ + } + else if (PREDICT_FALSE (result0->fields.filter)) + { + b0->error = node->errors[L2FWD_ERROR_FILTER_DROP]; + *next0 = L2FWD_NEXT_DROP; + + /* perform BVI check */ + } + else if (PREDICT_FALSE (result0->fields.bvi)) + { + u32 rc; + rc = l2_to_bvi (vm, + msm->vnet_main, + b0, + vnet_buffer (b0)->sw_if_index[VLIB_TX], + &msm->l3_next, next0); + + if (PREDICT_FALSE (rc)) + { + if (rc == TO_BVI_ERR_BAD_MAC) + { + b0->error = node->errors[L2FWD_ERROR_BVI_BAD_MAC]; + *next0 = L2FWD_NEXT_DROP; + } + else if (rc == TO_BVI_ERR_ETHERTYPE) + { + b0->error = node->errors[L2FWD_ERROR_BVI_ETHERTYPE]; + *next0 = L2FWD_NEXT_DROP; + } + } + } } - } } static uword l2fwd_node_fn (vlib_main_t * vm, - vlib_node_runtime_t * node, - vlib_frame_t * frame) + vlib_node_runtime_t * node, vlib_frame_t * frame) { - u32 n_left_from, * from, * to_next; + u32 n_left_from, *from, *to_next; l2fwd_next_t next_index; - l2fwd_main_t * msm = &l2fwd_main; + l2fwd_main_t *msm = &l2fwd_main; vlib_node_t *n = vlib_get_node (vm, l2fwd_node.index); - CLIB_UNUSED(u32 node_counter_base_index) = n->error_heap_index; - vlib_error_main_t * em = &vm->error_main; + CLIB_UNUSED (u32 node_counter_base_index) = n->error_heap_index; + vlib_error_main_t *em = &vm->error_main; l2fib_entry_key_t cached_key; l2fib_entry_result_t cached_result; - // Clear the one-entry cache in case mac table was updated - cached_key.raw = ~0; + /* Clear the one-entry cache in case mac table was updated */ + cached_key.raw = ~0; cached_result.raw = ~0; from = vlib_frame_vector_args (frame); - n_left_from = frame->n_vectors; /* number of packets to process */ + n_left_from = frame->n_vectors; /* number of packets to process */ next_index = node->cached_next_index; while (n_left_from > 0) @@ -195,27 +212,26 @@ l2fwd_node_fn (vlib_main_t * vm, u32 n_left_to_next; /* get space to enqueue frame to graph node "next_index" */ - vlib_get_next_frame (vm, node, next_index, - to_next, n_left_to_next); + vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next); while (n_left_from >= 4 && n_left_to_next >= 2) { - u32 bi0, bi1; - vlib_buffer_t * b0, * b1; - u32 next0, next1; - u32 sw_if_index0, sw_if_index1; - ethernet_header_t * h0, * h1; - l2fib_entry_key_t key0, key1; - l2fib_entry_result_t result0, result1; - u32 bucket0, bucket1; - + u32 bi0, bi1; + vlib_buffer_t *b0, *b1; + u32 next0, next1; + u32 sw_if_index0, sw_if_index1; + ethernet_header_t *h0, *h1; + l2fib_entry_key_t key0, key1; + l2fib_entry_result_t result0, result1; + u32 bucket0, bucket1; + /* Prefetch next iteration. */ { - vlib_buffer_t * p2, * p3; - + vlib_buffer_t *p2, *p3; + p2 = vlib_get_buffer (vm, from[2]); p3 = vlib_get_buffer (vm, from[3]); - + vlib_prefetch_buffer_header (p2, LOAD); vlib_prefetch_buffer_header (p3, LOAD); @@ -223,8 +239,8 @@ l2fwd_node_fn (vlib_main_t * vm, CLIB_PREFETCH (p3->data, CLIB_CACHE_LINE_BYTES, STORE); } - /* speculatively enqueue b0 and b1 to the current next frame */ - /* bi is "buffer index", b is pointer to the buffer */ + /* speculatively enqueue b0 and b1 to the current next frame */ + /* bi is "buffer index", b is pointer to the buffer */ to_next[0] = bi0 = from[0]; to_next[1] = bi1 = from[1]; from += 2; @@ -234,73 +250,69 @@ l2fwd_node_fn (vlib_main_t * vm, b0 = vlib_get_buffer (vm, bi0); b1 = vlib_get_buffer (vm, bi1); - - /* RX interface handles */ - sw_if_index0 = vnet_buffer(b0)->sw_if_index[VLIB_RX]; - sw_if_index1 = vnet_buffer(b1)->sw_if_index[VLIB_RX]; - - h0 = vlib_buffer_get_current (b0); - h1 = vlib_buffer_get_current (b1); - - if (PREDICT_FALSE((node->flags & VLIB_NODE_FLAG_TRACE))) - { - if (b0->flags & VLIB_BUFFER_IS_TRACED) - { - l2fwd_trace_t *t = - vlib_add_trace (vm, node, b0, sizeof (*t)); - t->sw_if_index = sw_if_index0; - t->bd_index = vnet_buffer(b0)->l2.bd_index; - clib_memcpy(t->src, h0->src_address, 6); - clib_memcpy(t->dst, h0->dst_address, 6); - } - if (b1->flags & VLIB_BUFFER_IS_TRACED) - { - l2fwd_trace_t *t = - vlib_add_trace (vm, node, b1, sizeof (*t)); - t->sw_if_index = sw_if_index1; - t->bd_index = vnet_buffer(b1)->l2.bd_index; - clib_memcpy(t->src, h1->src_address, 6); - clib_memcpy(t->dst, h1->dst_address, 6); - } - } - - /* process 2 pkts */ + + /* RX interface handles */ + sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX]; + sw_if_index1 = vnet_buffer (b1)->sw_if_index[VLIB_RX]; + + h0 = vlib_buffer_get_current (b0); + h1 = vlib_buffer_get_current (b1); + + if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE))) + { + if (b0->flags & VLIB_BUFFER_IS_TRACED) + { + l2fwd_trace_t *t = + vlib_add_trace (vm, node, b0, sizeof (*t)); + t->sw_if_index = sw_if_index0; + t->bd_index = vnet_buffer (b0)->l2.bd_index; + clib_memcpy (t->src, h0->src_address, 6); + clib_memcpy (t->dst, h0->dst_address, 6); + } + if (b1->flags & VLIB_BUFFER_IS_TRACED) + { + l2fwd_trace_t *t = + vlib_add_trace (vm, node, b1, sizeof (*t)); + t->sw_if_index = sw_if_index1; + t->bd_index = vnet_buffer (b1)->l2.bd_index; + clib_memcpy (t->src, h1->src_address, 6); + clib_memcpy (t->dst, h1->dst_address, 6); + } + } + + /* process 2 pkts */ #ifdef COUNTERS - em->counters[node_counter_base_index + L2FWD_ERROR_L2FWD] += 2; + em->counters[node_counter_base_index + L2FWD_ERROR_L2FWD] += 2; #endif - l2fib_lookup_2 (msm->mac_table, &cached_key, &cached_result, - h0->dst_address, - h1->dst_address, - vnet_buffer(b0)->l2.bd_index, - vnet_buffer(b1)->l2.bd_index, - &key0, // not used - &key1, // not used - &bucket0, // not used - &bucket1, // not used - &result0, - &result1); - l2fwd_process (vm, node, msm, em, b0, sw_if_index0, &result0, &next0); - l2fwd_process (vm, node, msm, em, b1, sw_if_index1, &result1, &next1); - - /* verify speculative enqueues, maybe switch current next frame */ - /* if next0==next1==next_index then nothing special needs to be done */ - vlib_validate_buffer_enqueue_x2 (vm, node, next_index, - to_next, n_left_to_next, - bi0, bi1, next0, next1); - } - + l2fib_lookup_2 (msm->mac_table, &cached_key, &cached_result, h0->dst_address, h1->dst_address, vnet_buffer (b0)->l2.bd_index, vnet_buffer (b1)->l2.bd_index, &key0, /* not used */ + &key1, /* not used */ + &bucket0, /* not used */ + &bucket1, /* not used */ + &result0, &result1); + l2fwd_process (vm, node, msm, em, b0, sw_if_index0, &result0, + &next0); + l2fwd_process (vm, node, msm, em, b1, sw_if_index1, &result1, + &next1); + + /* verify speculative enqueues, maybe switch current next frame */ + /* if next0==next1==next_index then nothing special needs to be done */ + vlib_validate_buffer_enqueue_x2 (vm, node, next_index, + to_next, n_left_to_next, + bi0, bi1, next0, next1); + } + while (n_left_from > 0 && n_left_to_next > 0) { - u32 bi0; - vlib_buffer_t * b0; - u32 next0; - u32 sw_if_index0; - ethernet_header_t * h0; - l2fib_entry_key_t key0; - l2fib_entry_result_t result0; - u32 bucket0; - - /* speculatively enqueue b0 to the current next frame */ + u32 bi0; + vlib_buffer_t *b0; + u32 next0; + u32 sw_if_index0; + ethernet_header_t *h0; + l2fib_entry_key_t key0; + l2fib_entry_result_t result0; + u32 bucket0; + + /* speculatively enqueue b0 to the current next frame */ bi0 = from[0]; to_next[0] = bi0; from += 1; @@ -310,32 +322,31 @@ l2fwd_node_fn (vlib_main_t * vm, b0 = vlib_get_buffer (vm, bi0); - sw_if_index0 = vnet_buffer(b0)->sw_if_index[VLIB_RX]; - - h0 = vlib_buffer_get_current (b0); - - if (PREDICT_FALSE((node->flags & VLIB_NODE_FLAG_TRACE) - && (b0->flags & VLIB_BUFFER_IS_TRACED))) { - l2fwd_trace_t *t = - vlib_add_trace (vm, node, b0, sizeof (*t)); - t->sw_if_index = sw_if_index0; - t->bd_index = vnet_buffer(b0)->l2.bd_index; - clib_memcpy(t->src, h0->src_address, 6); - clib_memcpy(t->dst, h0->dst_address, 6); - } - - /* process 1 pkt */ + sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX]; + + h0 = vlib_buffer_get_current (b0); + + if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE) + && (b0->flags & VLIB_BUFFER_IS_TRACED))) + { + l2fwd_trace_t *t = vlib_add_trace (vm, node, b0, sizeof (*t)); + t->sw_if_index = sw_if_index0; + t->bd_index = vnet_buffer (b0)->l2.bd_index; + clib_memcpy (t->src, h0->src_address, 6); + clib_memcpy (t->dst, h0->dst_address, 6); + } + + /* process 1 pkt */ #ifdef COUNTERS - em->counters[node_counter_base_index + L2FWD_ERROR_L2FWD] += 1; + em->counters[node_counter_base_index + L2FWD_ERROR_L2FWD] += 1; #endif - l2fib_lookup_1 (msm->mac_table, &cached_key, &cached_result, - h0->dst_address, vnet_buffer(b0)->l2.bd_index, - &key0, // not used - &bucket0, // not used - &result0); - l2fwd_process (vm, node, msm, em, b0, sw_if_index0, &result0, &next0); - - /* verify speculative enqueue, maybe switch current next frame */ + l2fib_lookup_1 (msm->mac_table, &cached_key, &cached_result, h0->dst_address, vnet_buffer (b0)->l2.bd_index, &key0, /* not used */ + &bucket0, /* not used */ + &result0); + l2fwd_process (vm, node, msm, em, b0, sw_if_index0, &result0, + &next0); + + /* verify speculative enqueue, maybe switch current next frame */ vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next, n_left_to_next, bi0, next0); @@ -347,13 +358,14 @@ l2fwd_node_fn (vlib_main_t * vm, return frame->n_vectors; } +/* *INDENT-OFF* */ VLIB_REGISTER_NODE (l2fwd_node,static) = { .function = l2fwd_node_fn, .name = "l2-fwd", .vector_size = sizeof (u32), .format_trace = format_l2fwd_trace, .type = VLIB_NODE_TYPE_INTERNAL, - + .n_errors = ARRAY_LEN(l2fwd_error_strings), .error_strings = l2fwd_error_strings, @@ -366,20 +378,20 @@ VLIB_REGISTER_NODE (l2fwd_node,static) = { [L2FWD_NEXT_DROP] = "error-drop", }, }; +/* *INDENT-ON* */ VLIB_NODE_FUNCTION_MULTIARCH (l2fwd_node, l2fwd_node_fn) - -clib_error_t *l2fwd_init (vlib_main_t *vm) + clib_error_t *l2fwd_init (vlib_main_t * vm) { - l2fwd_main_t * mp = &l2fwd_main; - + l2fwd_main_t *mp = &l2fwd_main; + mp->vlib_main = vm; - mp->vnet_main = vnet_get_main(); + mp->vnet_main = vnet_get_main (); /* init the hash table ptr */ - mp->mac_table = get_mac_table(); + mp->mac_table = get_mac_table (); - // Initialize the next nodes for each ethertype + /* Initialize the next nodes for each ethertype */ next_by_ethertype_init (&mp->l3_next); return 0; @@ -388,61 +400,72 @@ clib_error_t *l2fwd_init (vlib_main_t *vm) VLIB_INIT_FUNCTION (l2fwd_init); -// Add the L3 input node for this ethertype to the next nodes structure +/** Add the L3 input node for this ethertype to the next nodes structure */ void l2fwd_register_input_type (vlib_main_t * vm, - ethernet_type_t type, - u32 node_index) + ethernet_type_t type, u32 node_index) { - l2fwd_main_t * mp = &l2fwd_main; + l2fwd_main_t *mp = &l2fwd_main; u32 next_index; - next_index = vlib_node_add_next (vm, - l2fwd_node.index, - node_index); + next_index = vlib_node_add_next (vm, l2fwd_node.index, node_index); next_by_ethertype_register (&mp->l3_next, type, next_index); } -// set subinterface forward enable/disable -// The CLI format is: -// set interface l2 forward [disable] +/** + * set subinterface forward enable/disable + * The CLI format is: + * set interface l2 forward [disable] + */ static clib_error_t * -int_fwd (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) +int_fwd (vlib_main_t * vm, unformat_input_t * input, vlib_cli_command_t * cmd) { - vnet_main_t * vnm = vnet_get_main(); - clib_error_t * error = 0; + vnet_main_t *vnm = vnet_get_main (); + clib_error_t *error = 0; u32 sw_if_index; u32 enable; - if (! unformat_user (input, unformat_vnet_sw_interface, vnm, &sw_if_index)) + if (!unformat_user (input, unformat_vnet_sw_interface, vnm, &sw_if_index)) { error = clib_error_return (0, "unknown interface `%U'", - format_unformat_error, input); + format_unformat_error, input); goto done; } enable = 1; - if (unformat (input, "disable")) { - enable = 0; - } - - // set the interface flag - if (l2input_intf_config(sw_if_index)->xconnect) { - l2input_intf_bitmap_enable(sw_if_index, L2INPUT_FEAT_XCONNECT, enable); - } else { - l2input_intf_bitmap_enable(sw_if_index, L2INPUT_FEAT_FWD, enable); - } - - done: + if (unformat (input, "disable")) + { + enable = 0; + } + + /* set the interface flag */ + if (l2input_intf_config (sw_if_index)->xconnect) + { + l2input_intf_bitmap_enable (sw_if_index, L2INPUT_FEAT_XCONNECT, enable); + } + else + { + l2input_intf_bitmap_enable (sw_if_index, L2INPUT_FEAT_FWD, enable); + } + +done: return error; } +/* *INDENT-OFF* */ VLIB_CLI_COMMAND (int_fwd_cli, static) = { .path = "set interface l2 forward", .short_help = "set interface l2 forward [disable]", .function = int_fwd, }; +/* *INDENT-ON* */ + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/vnet/vnet/l2/l2_fwd.h b/vnet/vnet/l2/l2_fwd.h index f08717dfdf8..3968732dbc2 100644 --- a/vnet/vnet/l2/l2_fwd.h +++ b/vnet/vnet/l2/l2_fwd.h @@ -24,6 +24,13 @@ void l2fwd_register_input_type (vlib_main_t * vm, - ethernet_type_t type, - u32 node_index); + ethernet_type_t type, u32 node_index); #endif + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/vnet/vnet/l2/l2_input.c b/vnet/vnet/l2/l2_input.c index 532caf9c7d8..9607031fcda 100644 --- a/vnet/vnet/l2/l2_input.c +++ b/vnet/vnet/l2/l2_input.c @@ -35,20 +35,23 @@ #include -// Feature graph node names -static char * l2input_feat_names[] = { +/* Feature graph node names */ +static char *l2input_feat_names[] = { #define _(sym,name) name, foreach_l2input_feat #undef _ }; -char **l2input_get_feat_names(void) { +char ** +l2input_get_feat_names (void) +{ return l2input_feat_names; } -typedef struct { - /* per-pkt trace data */ +typedef struct +{ + /* per-pkt trace data */ u8 src[6]; u8 dst[6]; u32 next_index; @@ -56,16 +59,17 @@ typedef struct { } l2input_trace_t; /* packet trace format function */ -static u8 * format_l2input_trace (u8 * s, va_list * args) +static u8 * +format_l2input_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 *); - l2input_trace_t * t = va_arg (*args, l2input_trace_t *); - + l2input_trace_t *t = va_arg (*args, l2input_trace_t *); + s = format (s, "l2-input: sw_if_index %d dst %U src %U", t->sw_if_index, - format_ethernet_address, t->dst, - format_ethernet_address, t->src); + format_ethernet_address, t->dst, + format_ethernet_address, t->src); return s; } @@ -75,20 +79,22 @@ l2input_main_t l2input_main; _(L2INPUT, "L2 input packets") \ _(DROP, "L2 input drops") -typedef enum { +typedef enum +{ #define _(sym,str) L2INPUT_ERROR_##sym, foreach_l2input_error #undef _ - L2INPUT_N_ERROR, + L2INPUT_N_ERROR, } l2input_error_t; -static char * l2input_error_strings[] = { +static char *l2input_error_strings[] = { #define _(sym,string) string, foreach_l2input_error #undef _ }; -typedef enum { /* */ +typedef enum +{ /* */ L2INPUT_NEXT_LEARN, L2INPUT_NEXT_FWD, L2INPUT_NEXT_DROP, @@ -98,28 +104,28 @@ typedef enum { /* */ static_always_inline void classify_and_dispatch (vlib_main_t * vm, - vlib_node_runtime_t * node, - u32 cpu_index, - l2input_main_t * msm, - vlib_buffer_t * b0, - u32 *next0) + vlib_node_runtime_t * node, + u32 cpu_index, + l2input_main_t * msm, vlib_buffer_t * b0, u32 * next0) { - // Load L2 input feature struct - // Load bridge domain struct - // Parse ethernet header to determine unicast/mcast/broadcast - // take L2 input stat - // classify packet as IP/UDP/TCP, control, other - // mask feature bitmap - // go to first node in bitmap - // Later: optimize VTM - // - // For L2XC, - // set tx sw-if-handle - - u8 mcast_dmac; - __attribute__((unused)) u8 l2bcast; - __attribute__((unused)) u8 l2mcast; - __attribute__((unused)) u8 l2_stat_kind; + /* + * Load L2 input feature struct + * Load bridge domain struct + * Parse ethernet header to determine unicast/mcast/broadcast + * take L2 input stat + * classify packet as IP/UDP/TCP, control, other + * mask feature bitmap + * go to first node in bitmap + * Later: optimize VTM + * + * For L2XC, + * set tx sw-if-handle + */ + + u8 mcast_dmac; + __attribute__ ((unused)) u8 l2bcast; + __attribute__ ((unused)) u8 l2mcast; + __attribute__ ((unused)) u8 l2_stat_kind; u16 ethertype; u8 protocol; l2_input_config_t *config; @@ -127,8 +133,8 @@ classify_and_dispatch (vlib_main_t * vm, u16 bd_index0; u32 feature_bitmap; u32 feat_mask; - ethernet_header_t * h0; - u8 * l3h0; + ethernet_header_t *h0; + u8 *l3h0; u32 sw_if_index0; #define get_u32(addr) ( *((u32 *)(addr)) ) @@ -137,126 +143,150 @@ classify_and_dispatch (vlib_main_t * vm, #define STATS_IF_LAYER2_MCAST_INPUT_CNT 1 #define STATS_IF_LAYER2_BCAST_INPUT_CNT 2 - sw_if_index0 = vnet_buffer(b0)->sw_if_index[VLIB_RX]; + sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX]; h0 = vlib_buffer_get_current (b0); - l3h0 = (u8 *)h0 + vnet_buffer(b0)->l2.l2_len; - - // Determine L3 packet type. Only need to check the common types. - // Used to filter out features that don't apply to common packets. - ethertype = clib_net_to_host_u16(get_u16(l3h0 - 2)); - if (ethertype == ETHERNET_TYPE_IP4) { - protocol = ((ip4_header_t *)l3h0)->protocol; - if ((protocol == IP_PROTOCOL_UDP) || - (protocol == IP_PROTOCOL_TCP)) { - feat_mask = IP_UDP_TCP_FEAT_MASK; - } else { - feat_mask = IP4_FEAT_MASK; + l3h0 = (u8 *) h0 + vnet_buffer (b0)->l2.l2_len; + + /* + * Determine L3 packet type. Only need to check the common types. + * Used to filter out features that don't apply to common packets. + */ + ethertype = clib_net_to_host_u16 (get_u16 (l3h0 - 2)); + if (ethertype == ETHERNET_TYPE_IP4) + { + protocol = ((ip4_header_t *) l3h0)->protocol; + if ((protocol == IP_PROTOCOL_UDP) || (protocol == IP_PROTOCOL_TCP)) + { + feat_mask = IP_UDP_TCP_FEAT_MASK; + } + else + { + feat_mask = IP4_FEAT_MASK; + } } - } else if (ethertype == ETHERNET_TYPE_IP6) { - protocol = ((ip6_header_t *)l3h0)->protocol; - // Don't bother checking for extension headers for now - if ((protocol == IP_PROTOCOL_UDP) || - (protocol == IP_PROTOCOL_TCP)) { - feat_mask = IP_UDP_TCP_FEAT_MASK; - } else { + else if (ethertype == ETHERNET_TYPE_IP6) + { + protocol = ((ip6_header_t *) l3h0)->protocol; + /* Don't bother checking for extension headers for now */ + if ((protocol == IP_PROTOCOL_UDP) || (protocol == IP_PROTOCOL_TCP)) + { + feat_mask = IP_UDP_TCP_FEAT_MASK; + } + else + { + feat_mask = IP6_FEAT_MASK; + } + } + else if (ethertype == ETHERNET_TYPE_MPLS_UNICAST) + { feat_mask = IP6_FEAT_MASK; } - } else if (ethertype == ETHERNET_TYPE_MPLS_UNICAST) { - feat_mask = IP6_FEAT_MASK; - } else { - // allow all features - feat_mask = ~0; - } - - // determine layer2 kind for stat and mask - mcast_dmac = ethernet_address_cast(h0->dst_address); + else + { + /* allow all features */ + feat_mask = ~0; + } + + /* determine layer2 kind for stat and mask */ + mcast_dmac = ethernet_address_cast (h0->dst_address); l2bcast = 0; l2mcast = 0; l2_stat_kind = STATS_IF_LAYER2_UCAST_INPUT_CNT; - if (PREDICT_FALSE (mcast_dmac)) { - u32 *dsthi = (u32 *) &h0->dst_address[0]; - u32 *dstlo = (u32 *) &h0->dst_address[2]; + if (PREDICT_FALSE (mcast_dmac)) + { + u32 *dsthi = (u32 *) & h0->dst_address[0]; + u32 *dstlo = (u32 *) & h0->dst_address[2]; - // Disable bridge forwarding (flooding will execute instead if not xconnect) - feat_mask &= ~(L2INPUT_FEAT_FWD | L2INPUT_FEAT_UU_FLOOD); - if (ethertype != ETHERNET_TYPE_ARP) // Disable ARP-term for non-ARP packet + /* Disable bridge forwarding (flooding will execute instead if not xconnect) */ + feat_mask &= ~(L2INPUT_FEAT_FWD | L2INPUT_FEAT_UU_FLOOD); + if (ethertype != ETHERNET_TYPE_ARP) /* Disable ARP-term for non-ARP packet */ feat_mask &= ~(L2INPUT_FEAT_ARP_TERM); - // dest mac is multicast or broadcast - if ((*dstlo == 0xFFFFFFFF) && (*dsthi == 0xFFFFFFFF)) { - // dest mac == FF:FF:FF:FF:FF:FF - l2_stat_kind = STATS_IF_LAYER2_BCAST_INPUT_CNT; - l2bcast=1; - } else { - l2_stat_kind = STATS_IF_LAYER2_MCAST_INPUT_CNT; - l2mcast=1; + /* dest mac is multicast or broadcast */ + if ((*dstlo == 0xFFFFFFFF) && (*dsthi == 0xFFFFFFFF)) + { + /* dest mac == FF:FF:FF:FF:FF:FF */ + l2_stat_kind = STATS_IF_LAYER2_BCAST_INPUT_CNT; + l2bcast = 1; + } + else + { + l2_stat_kind = STATS_IF_LAYER2_MCAST_INPUT_CNT; + l2mcast = 1; + } } - } - // TODO: take l2 stat - - // Get config for the input interface - config = vec_elt_at_index(msm->configs, sw_if_index0); + /* TODO: take l2 stat */ - // Save split horizon group - vnet_buffer(b0)->l2.shg = config->shg; + /* Get config for the input interface */ + config = vec_elt_at_index (msm->configs, sw_if_index0); - if (config->xconnect) { - // Set the output interface - vnet_buffer(b0)->sw_if_index[VLIB_TX] = config->output_sw_if_index; + /* Save split horizon group */ + vnet_buffer (b0)->l2.shg = config->shg; - } else { + if (config->xconnect) + { + /* Set the output interface */ + vnet_buffer (b0)->sw_if_index[VLIB_TX] = config->output_sw_if_index; - // Check for from-BVI processing, TX is non-~0 if from BVI loopback - // Set SHG for BVI packets to 0 so it is not dropped for VXLAN tunnels - if (PREDICT_FALSE (vnet_buffer(b0)->sw_if_index[VLIB_TX] != ~0)) { - vnet_buffer(b0)->sw_if_index[VLIB_TX] = ~0; - vnet_buffer(b0)->l2.shg = 0; } + else + { - // Do bridge-domain processing - bd_index0 = config->bd_index; - // save BD ID for next feature graph nodes - vnet_buffer(b0)->l2.bd_index = bd_index0; - - // Get config for the bridge domain interface - bd_config = vec_elt_at_index(msm->bd_configs, bd_index0); + /* + * Check for from-BVI processing, TX is non-~0 if from BVI loopback + * Set SHG for BVI packets to 0 so it is not dropped for VXLAN tunnels + */ + if (PREDICT_FALSE (vnet_buffer (b0)->sw_if_index[VLIB_TX] != ~0)) + { + vnet_buffer (b0)->sw_if_index[VLIB_TX] = ~0; + vnet_buffer (b0)->l2.shg = 0; + } - // Process bridge domain feature enables. - // To perform learning/flooding/forwarding, the corresponding bit - // must be enabled in both the input interface config and in the - // bridge domain config. In the bd_bitmap, bits for features other - // than learning/flooding/forwarding should always be set. - feat_mask = feat_mask & bd_config->feature_bitmap; - } + /* Do bridge-domain processing */ + bd_index0 = config->bd_index; + /* save BD ID for next feature graph nodes */ + vnet_buffer (b0)->l2.bd_index = bd_index0; + + /* Get config for the bridge domain interface */ + bd_config = vec_elt_at_index (msm->bd_configs, bd_index0); + + /* + * Process bridge domain feature enables. + * To perform learning/flooding/forwarding, the corresponding bit + * must be enabled in both the input interface config and in the + * bridge domain config. In the bd_bitmap, bits for features other + * than learning/flooding/forwarding should always be set. + */ + feat_mask = feat_mask & bd_config->feature_bitmap; + } - // mask out features from bitmap using packet type and bd config + /* mask out features from bitmap using packet type and bd config */ feature_bitmap = config->feature_bitmap & feat_mask; - // save for next feature graph nodes - vnet_buffer(b0)->l2.feature_bitmap = feature_bitmap; + /* save for next feature graph nodes */ + vnet_buffer (b0)->l2.feature_bitmap = feature_bitmap; - // Determine the next node - *next0 = feat_bitmap_get_next_node_index(msm->feat_next_node_index, - feature_bitmap); + /* Determine the next node */ + *next0 = feat_bitmap_get_next_node_index (msm->feat_next_node_index, + feature_bitmap); } static uword l2input_node_fn (vlib_main_t * vm, - vlib_node_runtime_t * node, - vlib_frame_t * frame) + vlib_node_runtime_t * node, vlib_frame_t * frame) { - u32 n_left_from, * from, * to_next; + u32 n_left_from, *from, *to_next; l2input_next_t next_index; - l2input_main_t * msm = &l2input_main; + l2input_main_t *msm = &l2input_main; vlib_node_t *n = vlib_get_node (vm, l2input_node.index); u32 node_counter_base_index = n->error_heap_index; - vlib_error_main_t * em = &vm->error_main; - u32 cpu_index = os_get_cpu_number(); + vlib_error_main_t *em = &vm->error_main; + u32 cpu_index = os_get_cpu_number (); from = vlib_frame_vector_args (frame); - n_left_from = frame->n_vectors; /* number of packets to process */ + n_left_from = frame->n_vectors; /* number of packets to process */ next_index = node->cached_next_index; while (n_left_from > 0) @@ -264,48 +294,53 @@ l2input_node_fn (vlib_main_t * vm, u32 n_left_to_next; /* get space to enqueue frame to graph node "next_index" */ - vlib_get_next_frame (vm, node, next_index, - to_next, n_left_to_next); + vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next); while (n_left_from >= 6 && n_left_to_next >= 2) { - u32 bi0, bi1; - vlib_buffer_t * b0, * b1; - u32 next0, next1; - u32 sw_if_index0, sw_if_index1; - + u32 bi0, bi1; + vlib_buffer_t *b0, *b1; + u32 next0, next1; + u32 sw_if_index0, sw_if_index1; + /* Prefetch next iteration. */ { - vlib_buffer_t * p2, * p3, * p4 , * p5; - u32 sw_if_index2, sw_if_index3; - + vlib_buffer_t *p2, *p3, *p4, *p5; + u32 sw_if_index2, sw_if_index3; + p2 = vlib_get_buffer (vm, from[2]); p3 = vlib_get_buffer (vm, from[3]); p4 = vlib_get_buffer (vm, from[4]); p5 = vlib_get_buffer (vm, from[5]); - - // Prefetch the buffer header and packet for the N+2 loop iteration + + /* Prefetch the buffer header and packet for the N+2 loop iteration */ vlib_prefetch_buffer_header (p4, LOAD); vlib_prefetch_buffer_header (p5, LOAD); CLIB_PREFETCH (p4->data, CLIB_CACHE_LINE_BYTES, STORE); CLIB_PREFETCH (p5->data, CLIB_CACHE_LINE_BYTES, STORE); - // Prefetch the input config for the N+1 loop iteration - // This depends on the buffer header above - sw_if_index2 = vnet_buffer(p2)->sw_if_index[VLIB_RX]; - sw_if_index3 = vnet_buffer(p3)->sw_if_index[VLIB_RX]; - CLIB_PREFETCH (&msm->configs[sw_if_index2], CLIB_CACHE_LINE_BYTES, LOAD); - CLIB_PREFETCH (&msm->configs[sw_if_index3], CLIB_CACHE_LINE_BYTES, LOAD); - - // Don't bother prefetching the bridge-domain config (which - // depends on the input config above). Only a small number of - // bridge domains are expected. Plus the structure is small - // and several fit in a cache line. - } - - /* speculatively enqueue b0 and b1 to the current next frame */ - /* bi is "buffer index", b is pointer to the buffer */ + /* + * Prefetch the input config for the N+1 loop iteration + * This depends on the buffer header above + */ + sw_if_index2 = vnet_buffer (p2)->sw_if_index[VLIB_RX]; + sw_if_index3 = vnet_buffer (p3)->sw_if_index[VLIB_RX]; + CLIB_PREFETCH (&msm->configs[sw_if_index2], CLIB_CACHE_LINE_BYTES, + LOAD); + CLIB_PREFETCH (&msm->configs[sw_if_index3], CLIB_CACHE_LINE_BYTES, + LOAD); + + /* + * Don't bother prefetching the bridge-domain config (which + * depends on the input config above). Only a small number of + * bridge domains are expected. Plus the structure is small + * and several fit in a cache line. + */ + } + + /* speculatively enqueue b0 and b1 to the current next frame */ + /* bi is "buffer index", b is pointer to the buffer */ to_next[0] = bi0 = from[0]; to_next[1] = bi1 = from[1]; from += 2; @@ -316,60 +351,53 @@ l2input_node_fn (vlib_main_t * vm, b0 = vlib_get_buffer (vm, bi0); b1 = vlib_get_buffer (vm, bi1); - if (PREDICT_FALSE((node->flags & VLIB_NODE_FLAG_TRACE))) { - /* RX interface handles */ - sw_if_index0 = vnet_buffer(b0)->sw_if_index[VLIB_RX]; - sw_if_index1 = vnet_buffer(b1)->sw_if_index[VLIB_RX]; - - if (b0->flags & VLIB_BUFFER_IS_TRACED) { - ethernet_header_t * h0 = vlib_buffer_get_current (b0); - l2input_trace_t *t = - vlib_add_trace (vm, node, b0, sizeof (*t)); - t->sw_if_index = sw_if_index0; - clib_memcpy(t->src, h0->src_address, 6); - clib_memcpy(t->dst, h0->dst_address, 6); - } - if (b1->flags & VLIB_BUFFER_IS_TRACED) { - ethernet_header_t * h1 = vlib_buffer_get_current (b1); - l2input_trace_t *t = - vlib_add_trace (vm, node, b1, sizeof (*t)); - t->sw_if_index = sw_if_index1; - clib_memcpy(t->src, h1->src_address, 6); - clib_memcpy(t->dst, h1->dst_address, 6); - } - } - - em->counters[node_counter_base_index + L2INPUT_ERROR_L2INPUT] += 2; - - classify_and_dispatch (vm, - node, - cpu_index, - msm, - b0, - &next0); - - classify_and_dispatch (vm, - node, - cpu_index, - msm, - b1, - &next1); - - /* verify speculative enqueues, maybe switch current next frame */ - /* if next0==next1==next_index then nothing special needs to be done */ - vlib_validate_buffer_enqueue_x2 (vm, node, next_index, - to_next, n_left_to_next, - bi0, bi1, next0, next1); - } - + if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE))) + { + /* RX interface handles */ + sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX]; + sw_if_index1 = vnet_buffer (b1)->sw_if_index[VLIB_RX]; + + if (b0->flags & VLIB_BUFFER_IS_TRACED) + { + ethernet_header_t *h0 = vlib_buffer_get_current (b0); + l2input_trace_t *t = + vlib_add_trace (vm, node, b0, sizeof (*t)); + t->sw_if_index = sw_if_index0; + clib_memcpy (t->src, h0->src_address, 6); + clib_memcpy (t->dst, h0->dst_address, 6); + } + if (b1->flags & VLIB_BUFFER_IS_TRACED) + { + ethernet_header_t *h1 = vlib_buffer_get_current (b1); + l2input_trace_t *t = + vlib_add_trace (vm, node, b1, sizeof (*t)); + t->sw_if_index = sw_if_index1; + clib_memcpy (t->src, h1->src_address, 6); + clib_memcpy (t->dst, h1->dst_address, 6); + } + } + + em->counters[node_counter_base_index + L2INPUT_ERROR_L2INPUT] += 2; + + classify_and_dispatch (vm, node, cpu_index, msm, b0, &next0); + + classify_and_dispatch (vm, node, cpu_index, msm, b1, &next1); + + /* verify speculative enqueues, maybe switch current next frame */ + /* if next0==next1==next_index then nothing special needs to be done */ + vlib_validate_buffer_enqueue_x2 (vm, node, next_index, + to_next, n_left_to_next, + bi0, bi1, next0, next1); + } + while (n_left_from > 0 && n_left_to_next > 0) { - u32 bi0; - vlib_buffer_t * b0; - u32 next0; - u32 sw_if_index0; - - /* speculatively enqueue b0 to the current next frame */ + u32 bi0; + vlib_buffer_t *b0; + u32 next0; + u32 sw_if_index0; + + /* speculatively enqueue b0 to the current next frame */ bi0 = from[0]; to_next[0] = bi0; from += 1; @@ -379,27 +407,22 @@ l2input_node_fn (vlib_main_t * vm, b0 = vlib_get_buffer (vm, bi0); - if (PREDICT_FALSE((node->flags & VLIB_NODE_FLAG_TRACE) - && (b0->flags & VLIB_BUFFER_IS_TRACED))) { - ethernet_header_t * h0 = vlib_buffer_get_current (b0); - l2input_trace_t *t = - vlib_add_trace (vm, node, b0, sizeof (*t)); - sw_if_index0 = vnet_buffer(b0)->sw_if_index[VLIB_RX]; - t->sw_if_index = sw_if_index0; - clib_memcpy(t->src, h0->src_address, 6); - clib_memcpy(t->dst, h0->dst_address, 6); - } - - em->counters[node_counter_base_index + L2INPUT_ERROR_L2INPUT] += 1; - - classify_and_dispatch (vm, - node, - cpu_index, - msm, - b0, - &next0); - - /* verify speculative enqueue, maybe switch current next frame */ + if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE) + && (b0->flags & VLIB_BUFFER_IS_TRACED))) + { + ethernet_header_t *h0 = vlib_buffer_get_current (b0); + l2input_trace_t *t = vlib_add_trace (vm, node, b0, sizeof (*t)); + sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX]; + t->sw_if_index = sw_if_index0; + clib_memcpy (t->src, h0->src_address, 6); + clib_memcpy (t->dst, h0->dst_address, 6); + } + + em->counters[node_counter_base_index + L2INPUT_ERROR_L2INPUT] += 1; + + classify_and_dispatch (vm, node, cpu_index, msm, b0, &next0); + + /* verify speculative enqueue, maybe switch current next frame */ vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next, n_left_to_next, bi0, next0); @@ -412,6 +435,7 @@ l2input_node_fn (vlib_main_t * vm, } +/* *INDENT-OFF* */ VLIB_REGISTER_NODE (l2input_node) = { .function = l2input_node_fn, .name = "l2-input", @@ -419,7 +443,7 @@ VLIB_REGISTER_NODE (l2input_node) = { .format_trace = format_l2input_trace, .format_buffer = format_ethernet_header_with_length, .type = VLIB_NODE_TYPE_INTERNAL, - + .n_errors = ARRAY_LEN(l2input_error_strings), .error_strings = l2input_error_strings, @@ -432,29 +456,29 @@ VLIB_REGISTER_NODE (l2input_node) = { [L2INPUT_NEXT_DROP] = "error-drop", }, }; +/* *INDENT-ON* */ VLIB_NODE_FUNCTION_MULTIARCH (l2input_node, l2input_node_fn) - -clib_error_t *l2input_init (vlib_main_t *vm) + clib_error_t *l2input_init (vlib_main_t * vm) { - l2input_main_t * mp = &l2input_main; - + l2input_main_t *mp = &l2input_main; + mp->vlib_main = vm; - mp->vnet_main = vnet_get_main(); + mp->vnet_main = vnet_get_main (); - // Get packets RX'd from L2 interfaces + /* Get packets RX'd from L2 interfaces */ ethernet_register_l2_input (vm, l2input_node.index); - // Create the config vector - vec_validate(mp->configs, 100); - // create 100 sw interface entries and zero them + /* Create the config vector */ + vec_validate (mp->configs, 100); + /* create 100 sw interface entries and zero them */ - // Initialize the feature next-node indexes - feat_bitmap_init_next_nodes(vm, - l2input_node.index, - L2INPUT_N_FEAT, - l2input_get_feat_names(), - mp->feat_next_node_index); + /* Initialize the feature next-node indexes */ + feat_bitmap_init_next_nodes (vm, + l2input_node.index, + L2INPUT_N_FEAT, + l2input_get_feat_names (), + mp->feat_next_node_index); return 0; } @@ -462,480 +486,542 @@ clib_error_t *l2input_init (vlib_main_t *vm) VLIB_INIT_FUNCTION (l2input_init); -// Get a pointer to the config for the given interface -l2_input_config_t * l2input_intf_config (u32 sw_if_index) +/** Get a pointer to the config for the given interface */ +l2_input_config_t * +l2input_intf_config (u32 sw_if_index) { - l2input_main_t * mp = &l2input_main; - - vec_validate(mp->configs, sw_if_index); - return vec_elt_at_index(mp->configs, sw_if_index); + l2input_main_t *mp = &l2input_main; + + vec_validate (mp->configs, sw_if_index); + return vec_elt_at_index (mp->configs, sw_if_index); } -// Enable (or disable) the feature in the bitmap for the given interface -u32 l2input_intf_bitmap_enable (u32 sw_if_index, - u32 feature_bitmap, - u32 enable) +/** Enable (or disable) the feature in the bitmap for the given interface */ +u32 +l2input_intf_bitmap_enable (u32 sw_if_index, u32 feature_bitmap, u32 enable) { - l2input_main_t * mp = &l2input_main; + l2input_main_t *mp = &l2input_main; l2_input_config_t *config; - - vec_validate(mp->configs, sw_if_index); - config = vec_elt_at_index(mp->configs, sw_if_index); - - if (enable) { - config->feature_bitmap |= feature_bitmap; - } else { - config->feature_bitmap &= ~feature_bitmap; - } + + vec_validate (mp->configs, sw_if_index); + config = vec_elt_at_index (mp->configs, sw_if_index); + + if (enable) + { + config->feature_bitmap |= feature_bitmap; + } + else + { + config->feature_bitmap &= ~feature_bitmap; + } return config->feature_bitmap; } -u32 l2input_set_bridge_features(u32 bd_index, - u32 feat_mask, u32 feat_value) +u32 +l2input_set_bridge_features (u32 bd_index, u32 feat_mask, u32 feat_value) { - l2_bridge_domain_t * bd_config; + l2_bridge_domain_t *bd_config; vec_validate (l2input_main.bd_configs, bd_index); - bd_config = vec_elt_at_index(l2input_main.bd_configs, bd_index); + bd_config = vec_elt_at_index (l2input_main.bd_configs, bd_index); bd_validate (bd_config); - bd_config->feature_bitmap = (bd_config->feature_bitmap & ~feat_mask) | feat_value; + bd_config->feature_bitmap = + (bd_config->feature_bitmap & ~feat_mask) | feat_value; return bd_config->feature_bitmap; } -// Set the subinterface to run in l2 or l3 mode. -// for L3 mode, just the sw_if_index is specified -// for bridged mode, the bd id and bvi flag are also specified -// for xconnect mode, the peer sw_if_index is also specified -// Return 0 if ok, or non-0 if there was an error - -u32 set_int_l2_mode (vlib_main_t * vm, - vnet_main_t * vnet_main, - u32 mode, - u32 sw_if_index, - u32 bd_index, // for bridged interface - u32 bvi, // the bridged interface is the BVI - u32 shg, // the bridged interface's split horizon group - u32 xc_sw_if_index) // peer interface for xconnect +/** + * Set the subinterface to run in l2 or l3 mode. + * for L3 mode, just the sw_if_index is specified + * for bridged mode, the bd id and bvi flag are also specified + * for xconnect mode, the peer sw_if_index is also specified + * Return 0 if ok, or non-0 if there was an error + */ + +u32 +set_int_l2_mode (vlib_main_t * vm, vnet_main_t * vnet_main, u32 mode, u32 sw_if_index, u32 bd_index, /* for bridged interface */ + u32 bvi, /* the bridged interface is the BVI */ + u32 shg, /* the bridged interface's split horizon group */ + u32 xc_sw_if_index) /* peer interface for xconnect */ { - l2input_main_t * mp = &l2input_main; - l2output_main_t * l2om = &l2output_main; - vnet_main_t * vnm = vnet_get_main(); - vnet_hw_interface_t * hi; - l2_output_config_t * out_config; - l2_input_config_t * config; - l2_bridge_domain_t * bd_config; + l2input_main_t *mp = &l2input_main; + l2output_main_t *l2om = &l2output_main; + vnet_main_t *vnm = vnet_get_main (); + vnet_hw_interface_t *hi; + l2_output_config_t *out_config; + l2_input_config_t *config; + l2_bridge_domain_t *bd_config; l2_flood_member_t member; u64 mac; - i32 l2_if_adjust = 0; + i32 l2_if_adjust = 0; u32 slot; hi = vnet_get_sup_hw_interface (vnet_main, sw_if_index); - vec_validate(mp->configs, sw_if_index); - config = vec_elt_at_index(mp->configs, sw_if_index); - - if (config->bridge) { - // Interface is already in bridge mode. Undo the existing config. - bd_config = vec_elt_at_index(mp->bd_configs, config->bd_index); - - // remove interface from flood vector - bd_remove_member (bd_config, sw_if_index); - - // undo any BVI-related config - if (bd_config->bvi_sw_if_index == sw_if_index) { - bd_config->bvi_sw_if_index = ~0; - config->bvi = 0; - - // delete the l2fib entry for the bvi interface - mac = *((u64 *)hi->hw_address); - l2fib_del_entry (mac, config->bd_index); - - // Make loop output node send packet back to ethernet-input node - slot = vlib_node_add_named_next_with_slot ( - vm, hi->tx_node_index, "ethernet-input", - VNET_SIMULATED_ETHERNET_TX_NEXT_ETHERNET_INPUT); - ASSERT (slot == VNET_SIMULATED_ETHERNET_TX_NEXT_ETHERNET_INPUT); - } - l2_if_adjust--; - } else if (config->xconnect) { - l2_if_adjust--; - } + vec_validate (mp->configs, sw_if_index); + config = vec_elt_at_index (mp->configs, sw_if_index); + + if (config->bridge) + { + /* Interface is already in bridge mode. Undo the existing config. */ + bd_config = vec_elt_at_index (mp->bd_configs, config->bd_index); + + /* remove interface from flood vector */ + bd_remove_member (bd_config, sw_if_index); + + /* undo any BVI-related config */ + if (bd_config->bvi_sw_if_index == sw_if_index) + { + bd_config->bvi_sw_if_index = ~0; + config->bvi = 0; + + /* delete the l2fib entry for the bvi interface */ + mac = *((u64 *) hi->hw_address); + l2fib_del_entry (mac, config->bd_index); + + /* Make loop output node send packet back to ethernet-input node */ + slot = + vlib_node_add_named_next_with_slot (vm, hi->tx_node_index, + "ethernet-input", + VNET_SIMULATED_ETHERNET_TX_NEXT_ETHERNET_INPUT); + ASSERT (slot == VNET_SIMULATED_ETHERNET_TX_NEXT_ETHERNET_INPUT); + } + l2_if_adjust--; + } + else if (config->xconnect) + { + l2_if_adjust--; + } + + /* Initialize the l2-input configuration for the interface */ + if (mode == MODE_L3) + { + config->xconnect = 0; + config->bridge = 0; + config->shg = 0; + config->bd_index = 0; + config->feature_bitmap = L2INPUT_FEAT_DROP; + /* + * Directs the l2 output path to work out the interface + * output next-arc itself. Needed when recycling a sw_if_index. + */ + vec_validate_init_empty (l2om->next_nodes.output_node_index_vec, + sw_if_index, ~0); + l2om->next_nodes.output_node_index_vec[sw_if_index] = ~0; - // Initialize the l2-input configuration for the interface - if (mode == MODE_L3) { - config->xconnect = 0; - config->bridge = 0; - config->shg = 0; - config->bd_index = 0; - config->feature_bitmap = L2INPUT_FEAT_DROP; - // Directs the l2 output path to work out the interface - // output next-arc itself. Needed when recycling a sw_if_index. - vec_validate_init_empty(l2om->next_nodes.output_node_index_vec, - sw_if_index, ~0); - l2om->next_nodes.output_node_index_vec[sw_if_index] = ~0; - - } else if (mode == MODE_L2_CLASSIFY) { + } + else if (mode == MODE_L2_CLASSIFY) + { config->xconnect = 1; config->bridge = 0; config->output_sw_if_index = xc_sw_if_index; - // Make sure last-chance drop is configured + /* Make sure last-chance drop is configured */ config->feature_bitmap |= L2INPUT_FEAT_DROP | L2INPUT_FEAT_CLASSIFY; - // Make sure bridging features are disabled - config->feature_bitmap &= - ~(L2INPUT_FEAT_LEARN | L2INPUT_FEAT_FWD | L2INPUT_FEAT_FLOOD); - shg = 0; // not used in xconnect + /* Make sure bridging features are disabled */ + config->feature_bitmap &= + ~(L2INPUT_FEAT_LEARN | L2INPUT_FEAT_FWD | L2INPUT_FEAT_FLOOD); + shg = 0; /* not used in xconnect */ - // Insure all packets go to ethernet-input + /* Insure all packets go to ethernet-input */ ethernet_set_rx_redirect (vnet_main, hi, 1); - } else { - - if (mode == MODE_L2_BRIDGE) { - /* - * Remove a check that the interface must be an Ethernet. - * Specifically so we can bridge to L3 tunnel interfaces. - * Here's the check: - * if (hi->hw_class_index != ethernet_hw_interface_class.index) - * - */ - if (!hi) - return MODE_ERROR_ETH; // non-ethernet + } + else + { - config->xconnect = 0; - config->bridge = 1; - config->bd_index = bd_index; - - // Enable forwarding, flooding, learning and ARP termination by default - // (note that ARP term is disabled on BD feature bitmap by default) - config->feature_bitmap |= L2INPUT_FEAT_FWD | L2INPUT_FEAT_UU_FLOOD | - L2INPUT_FEAT_FLOOD | L2INPUT_FEAT_LEARN | L2INPUT_FEAT_ARP_TERM; - - // Make sure last-chance drop is configured - config->feature_bitmap |= L2INPUT_FEAT_DROP; - - // Make sure xconnect is disabled - config->feature_bitmap &= ~L2INPUT_FEAT_XCONNECT; - - // Set up bridge domain - vec_validate(mp->bd_configs, bd_index); - bd_config = vec_elt_at_index(mp->bd_configs, bd_index); - bd_validate (bd_config); - - // TODO: think: add l2fib entry even for non-bvi interface? - - // Do BVI interface initializations - if (bvi) { - // insure BD has no bvi interface (or replace that one with this??) - if (bd_config->bvi_sw_if_index != ~0) { - return MODE_ERROR_BVI_DEF; // bd already has a bvi interface - } - bd_config->bvi_sw_if_index = sw_if_index; - config->bvi = 1; - - // create the l2fib entry for the bvi interface - mac = *((u64 *)hi->hw_address); - l2fib_add_entry (mac, bd_index, sw_if_index, 1, 0, 1); // static + bvi - - // Disable learning by default. no use since l2fib entry is static. - config->feature_bitmap &= ~L2INPUT_FEAT_LEARN; - - // Make loop output node send packet to l2-input node - slot = vlib_node_add_named_next_with_slot ( - vm, hi->tx_node_index, "l2-input", - VNET_SIMULATED_ETHERNET_TX_NEXT_ETHERNET_INPUT); - ASSERT (slot == VNET_SIMULATED_ETHERNET_TX_NEXT_ETHERNET_INPUT); - } + if (mode == MODE_L2_BRIDGE) + { + /* + * Remove a check that the interface must be an Ethernet. + * Specifically so we can bridge to L3 tunnel interfaces. + * Here's the check: + * if (hi->hw_class_index != ethernet_hw_interface_class.index) + * + */ + if (!hi) + return MODE_ERROR_ETH; /* non-ethernet */ + + config->xconnect = 0; + config->bridge = 1; + config->bd_index = bd_index; + + /* + * Enable forwarding, flooding, learning and ARP termination by default + * (note that ARP term is disabled on BD feature bitmap by default) + */ + config->feature_bitmap |= L2INPUT_FEAT_FWD | L2INPUT_FEAT_UU_FLOOD | + L2INPUT_FEAT_FLOOD | L2INPUT_FEAT_LEARN | L2INPUT_FEAT_ARP_TERM; + + /* Make sure last-chance drop is configured */ + config->feature_bitmap |= L2INPUT_FEAT_DROP; + + /* Make sure xconnect is disabled */ + config->feature_bitmap &= ~L2INPUT_FEAT_XCONNECT; + + /* Set up bridge domain */ + vec_validate (mp->bd_configs, bd_index); + bd_config = vec_elt_at_index (mp->bd_configs, bd_index); + bd_validate (bd_config); + + /* TODO: think: add l2fib entry even for non-bvi interface? */ + + /* Do BVI interface initializations */ + if (bvi) + { + /* ensure BD has no bvi interface (or replace that one with this??) */ + if (bd_config->bvi_sw_if_index != ~0) + { + return MODE_ERROR_BVI_DEF; /* bd already has a bvi interface */ + } + bd_config->bvi_sw_if_index = sw_if_index; + config->bvi = 1; + + /* create the l2fib entry for the bvi interface */ + mac = *((u64 *) hi->hw_address); + l2fib_add_entry (mac, bd_index, sw_if_index, 1, 0, 1); /* static + bvi */ + + /* Disable learning by default. no use since l2fib entry is static. */ + config->feature_bitmap &= ~L2INPUT_FEAT_LEARN; + + /* Make loop output node send packet to l2-input node */ + slot = + vlib_node_add_named_next_with_slot (vm, hi->tx_node_index, + "l2-input", + VNET_SIMULATED_ETHERNET_TX_NEXT_ETHERNET_INPUT); + ASSERT (slot == VNET_SIMULATED_ETHERNET_TX_NEXT_ETHERNET_INPUT); + } + + /* Add interface to bridge-domain flood vector */ + member.sw_if_index = sw_if_index; + member.flags = bvi ? L2_FLOOD_MEMBER_BVI : L2_FLOOD_MEMBER_NORMAL; + member.shg = shg; + bd_add_member (bd_config, &member); - // Add interface to bridge-domain flood vector - member.sw_if_index = sw_if_index; - member.flags = bvi ? L2_FLOOD_MEMBER_BVI : L2_FLOOD_MEMBER_NORMAL; - member.shg = shg; - bd_add_member (bd_config, &member); - - } else { - config->xconnect = 1; - config->bridge = 0; - config->output_sw_if_index = xc_sw_if_index; + } + else + { + config->xconnect = 1; + config->bridge = 0; + config->output_sw_if_index = xc_sw_if_index; - // Make sure last-chance drop is configured - config->feature_bitmap |= L2INPUT_FEAT_DROP; + /* Make sure last-chance drop is configured */ + config->feature_bitmap |= L2INPUT_FEAT_DROP; - // Make sure bridging features are disabled - config->feature_bitmap &= ~(L2INPUT_FEAT_LEARN | L2INPUT_FEAT_FWD | L2INPUT_FEAT_FLOOD); + /* Make sure bridging features are disabled */ + config->feature_bitmap &= + ~(L2INPUT_FEAT_LEARN | L2INPUT_FEAT_FWD | L2INPUT_FEAT_FLOOD); - config->feature_bitmap |= L2INPUT_FEAT_XCONNECT; - shg = 0; // not used in xconnect - } + config->feature_bitmap |= L2INPUT_FEAT_XCONNECT; + shg = 0; /* not used in xconnect */ + } - // set up split-horizon group - config->shg = shg; - out_config = l2output_intf_config (sw_if_index); - out_config->shg = shg; + /* set up split-horizon group */ + config->shg = shg; + out_config = l2output_intf_config (sw_if_index); + out_config->shg = shg; - // Test: remove this when non-IP features can be configured. - // Enable a non-IP feature to test IP feature masking - // config->feature_bitmap |= L2INPUT_FEAT_CTRL_PKT; + /* + * Test: remove this when non-IP features can be configured. + * Enable a non-IP feature to test IP feature masking + * config->feature_bitmap |= L2INPUT_FEAT_CTRL_PKT; + */ - l2_if_adjust++; - } + l2_if_adjust++; + } - // Adjust count of L2 interfaces + /* Adjust count of L2 interfaces */ hi->l2_if_count += l2_if_adjust; - if (hi->hw_class_index == ethernet_hw_interface_class.index) { - if ((hi->l2_if_count == 1) && (l2_if_adjust == 1)) { - // Just added first L2 interface on this port + if (hi->hw_class_index == ethernet_hw_interface_class.index) + { + if ((hi->l2_if_count == 1) && (l2_if_adjust == 1)) + { + /* Just added first L2 interface on this port */ - // Set promiscuous mode on the l2 interface - ethernet_set_flags (vnet_main, hi->hw_if_index, - ETHERNET_INTERFACE_FLAG_ACCEPT_ALL); + /* Set promiscuous mode on the l2 interface */ + ethernet_set_flags (vnet_main, hi->hw_if_index, + ETHERNET_INTERFACE_FLAG_ACCEPT_ALL); - // Insure all packets go to ethernet-input - ethernet_set_rx_redirect (vnet_main, hi, 1); + /* ensure all packets go to ethernet-input */ + ethernet_set_rx_redirect (vnet_main, hi, 1); - } else if ((hi->l2_if_count == 0) && (l2_if_adjust == -1)) { - // Just removed only L2 subinterface on this port + } + else if ((hi->l2_if_count == 0) && (l2_if_adjust == -1)) + { + /* Just removed only L2 subinterface on this port */ - // Disable promiscuous mode on the l2 interface - ethernet_set_flags (vnet_main, hi->hw_if_index, 0); + /* Disable promiscuous mode on the l2 interface */ + ethernet_set_flags (vnet_main, hi->hw_if_index, 0); - // Allow ip packets to go directly to ip4-input etc - ethernet_set_rx_redirect (vnet_main, hi, 0); + /* Allow ip packets to go directly to ip4-input etc */ + ethernet_set_rx_redirect (vnet_main, hi, 0); + } } - } - // Set up the L2/L3 flag in the interface parsing tables - ethernet_sw_interface_set_l2_mode(vnm, sw_if_index, (mode!=MODE_L3)); + /* Set up the L2/L3 flag in the interface parsing tables */ + ethernet_sw_interface_set_l2_mode (vnm, sw_if_index, (mode != MODE_L3)); return 0; } -// set subinterface in bridging mode with a bridge-domain ID -// The CLI format is: -// set interface l2 bridge [bvi] [split-horizon-group] +/** + * set subinterface in bridging mode with a bridge-domain ID + * The CLI format is: + * set interface l2 bridge [bvi] [split-horizon-group] + */ static clib_error_t * -int_l2_bridge (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) +int_l2_bridge (vlib_main_t * vm, + unformat_input_t * input, vlib_cli_command_t * cmd) { - vnet_main_t * vnm = vnet_get_main(); - clib_error_t * error = 0; + vnet_main_t *vnm = vnet_get_main (); + clib_error_t *error = 0; u32 bd_index, bd_id; u32 sw_if_index; u32 bvi; u32 rc; u32 shg; - if (! unformat_user (input, unformat_vnet_sw_interface, vnm, &sw_if_index)) + if (!unformat_user (input, unformat_vnet_sw_interface, vnm, &sw_if_index)) { error = clib_error_return (0, "unknown interface `%U'", - format_unformat_error, input); + format_unformat_error, input); goto done; } - if (!unformat (input, "%d", &bd_id)) { + if (!unformat (input, "%d", &bd_id)) + { error = clib_error_return (0, "expected bridge domain ID `%U'", - format_unformat_error, input); + format_unformat_error, input); goto done; - } + } bd_index = bd_find_or_add_bd_index (&bd_main, bd_id); - // optional bvi + /* optional bvi */ bvi = unformat (input, "bvi"); - // optional split horizon group + /* optional split horizon group */ shg = 0; (void) unformat (input, "%d", &shg); - // set the interface mode - if ((rc = set_int_l2_mode(vm, vnm, MODE_L2_BRIDGE, sw_if_index, bd_index, bvi, shg, 0))) { - if (rc == MODE_ERROR_ETH) { - error = clib_error_return (0, "bridged interface must be ethernet", - format_unformat_error, input); - } else if (rc == MODE_ERROR_BVI_DEF) { - error = clib_error_return (0, "bridge-domain already has a bvi interface", - format_unformat_error, input); - } else { - error = clib_error_return (0, "invalid configuration for interface", - format_unformat_error, input); + /* set the interface mode */ + if ((rc = + set_int_l2_mode (vm, vnm, MODE_L2_BRIDGE, sw_if_index, bd_index, bvi, + shg, 0))) + { + if (rc == MODE_ERROR_ETH) + { + error = clib_error_return (0, "bridged interface must be ethernet", + format_unformat_error, input); + } + else if (rc == MODE_ERROR_BVI_DEF) + { + error = + clib_error_return (0, "bridge-domain already has a bvi interface", + format_unformat_error, input); + } + else + { + error = clib_error_return (0, "invalid configuration for interface", + format_unformat_error, input); + } + goto done; } - goto done; - } - done: +done: return error; } +/* *INDENT-OFF* */ VLIB_CLI_COMMAND (int_l2_bridge_cli, static) = { .path = "set interface l2 bridge", .short_help = "set interface to L2 bridging mode in [bvi] [shg]", .function = int_l2_bridge, }; +/* *INDENT-ON* */ -// set subinterface in xconnect mode with another interface -// The CLI format is: -// set interface l2 xconnect +/** + * set subinterface in xconnect mode with another interface + * The CLI format is: + * set interface l2 xconnect + */ static clib_error_t * int_l2_xc (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) + unformat_input_t * input, vlib_cli_command_t * cmd) { - vnet_main_t * vnm = vnet_get_main(); - clib_error_t * error = 0; + vnet_main_t *vnm = vnet_get_main (); + clib_error_t *error = 0; u32 sw_if_index; u32 xc_sw_if_index; - if (! unformat_user (input, unformat_vnet_sw_interface, vnm, &sw_if_index)) + if (!unformat_user (input, unformat_vnet_sw_interface, vnm, &sw_if_index)) { error = clib_error_return (0, "unknown interface `%U'", - format_unformat_error, input); + format_unformat_error, input); goto done; } - if (! unformat_user (input, unformat_vnet_sw_interface, vnm, &xc_sw_if_index)) + if (!unformat_user + (input, unformat_vnet_sw_interface, vnm, &xc_sw_if_index)) { error = clib_error_return (0, "unknown peer interface `%U'", - format_unformat_error, input); + format_unformat_error, input); goto done; } - // set the interface mode - if (set_int_l2_mode(vm, vnm, MODE_L2_XC, sw_if_index, 0, 0, 0, xc_sw_if_index)) { + /* set the interface mode */ + if (set_int_l2_mode + (vm, vnm, MODE_L2_XC, sw_if_index, 0, 0, 0, xc_sw_if_index)) + { error = clib_error_return (0, "invalid configuration for interface", - format_unformat_error, input); + format_unformat_error, input); goto done; - } + } - done: +done: return error; } +/* *INDENT-OFF* */ VLIB_CLI_COMMAND (int_l2_xc_cli, static) = { .path = "set interface l2 xconnect", .short_help = "set interface to L2 cross-connect mode with ", .function = int_l2_xc, }; +/* *INDENT-ON* */ -// set subinterface in L3 mode -// The CLI format is: -// set interface l3 +/** + * set subinterface in L3 mode + * The CLI format is: + * set interface l3 + */ static clib_error_t * -int_l3 (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) +int_l3 (vlib_main_t * vm, unformat_input_t * input, vlib_cli_command_t * cmd) { - vnet_main_t * vnm = vnet_get_main(); - clib_error_t * error = 0; + vnet_main_t *vnm = vnet_get_main (); + clib_error_t *error = 0; u32 sw_if_index; - if (! unformat_user (input, unformat_vnet_sw_interface, vnm, &sw_if_index)) + if (!unformat_user (input, unformat_vnet_sw_interface, vnm, &sw_if_index)) { error = clib_error_return (0, "unknown interface `%U'", - format_unformat_error, input); + format_unformat_error, input); goto done; } - // set the interface mode - if (set_int_l2_mode(vm, vnm, MODE_L3, sw_if_index, 0, 0, 0, 0)) { + /* set the interface mode */ + if (set_int_l2_mode (vm, vnm, MODE_L3, sw_if_index, 0, 0, 0, 0)) + { error = clib_error_return (0, "invalid configuration for interface", - format_unformat_error, input); + format_unformat_error, input); goto done; - } + } - done: +done: return error; } +/* *INDENT-OFF* */ VLIB_CLI_COMMAND (int_l3_cli, static) = { .path = "set interface l3", .short_help = "set interface to L3 mode", .function = int_l3, }; +/* *INDENT-ON* */ -// The CLI format is: -// show mode [ ...] +/** + * The CLI format is: + * show mode [ ...] + */ static clib_error_t * -show_int_mode (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) +show_int_mode (vlib_main_t * vm, + unformat_input_t * input, vlib_cli_command_t * cmd) { - vnet_main_t * vnm = vnet_get_main(); - clib_error_t * error = 0; - char * mode; - u8 * args; - vnet_interface_main_t * im = &vnm->interface_main; - vnet_sw_interface_t * si, * sis = 0; - l2input_main_t * mp = &l2input_main; - l2_input_config_t * config; - + vnet_main_t *vnm = vnet_get_main (); + clib_error_t *error = 0; + char *mode; + u8 *args; + vnet_interface_main_t *im = &vnm->interface_main; + vnet_sw_interface_t *si, *sis = 0; + l2input_main_t *mp = &l2input_main; + l2_input_config_t *config; + while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) { - u32 sw_if_index; + u32 sw_if_index; /* See if user wants to show specific interface */ - if (unformat (input, "%U", unformat_vnet_sw_interface, vnm, &sw_if_index)) + if (unformat + (input, "%U", unformat_vnet_sw_interface, vnm, &sw_if_index)) { - si = pool_elt_at_index (im->sw_interfaces, sw_if_index); + si = pool_elt_at_index (im->sw_interfaces, sw_if_index); vec_add1 (sis, si[0]); } else - { + { error = clib_error_return (0, "unknown input `%U'", format_unformat_error, input); goto done; - } + } } - if (vec_len (sis) == 0) /* Get all interfaces */ + if (vec_len (sis) == 0) /* Get all interfaces */ { /* Gather interfaces. */ sis = vec_new (vnet_sw_interface_t, pool_elts (im->sw_interfaces)); _vec_len (sis) = 0; + /* *INDENT-OFF* */ pool_foreach (si, im->sw_interfaces, ({ vec_add1 (sis, si[0]); })); + /* *INDENT-ON* */ } - + vec_foreach (si, sis) - { - vec_validate(mp->configs, si->sw_if_index); - config = vec_elt_at_index(mp->configs, si->sw_if_index); - if (config->bridge) { - u32 bd_id; - mode = "l2 bridge"; - bd_id = l2input_main.bd_configs[config->bd_index].bd_id; - - args = format (0, "bd_id %d%s%d", bd_id, - config->bvi ? " bvi shg " : " shg ", config->shg); - } else if (config->xconnect) { - mode = "l2 xconnect"; - args = format (0, "%U", - format_vnet_sw_if_index_name, - vnm, config->output_sw_if_index); - } else { + { + vec_validate (mp->configs, si->sw_if_index); + config = vec_elt_at_index (mp->configs, si->sw_if_index); + if (config->bridge) + { + u32 bd_id; + mode = "l2 bridge"; + bd_id = l2input_main.bd_configs[config->bd_index].bd_id; + + args = format (0, "bd_id %d%s%d", bd_id, + config->bvi ? " bvi shg " : " shg ", config->shg); + } + else if (config->xconnect) + { + mode = "l2 xconnect"; + args = format (0, "%U", + format_vnet_sw_if_index_name, + vnm, config->output_sw_if_index); + } + else + { mode = "l3"; - args = format (0, " "); + args = format (0, " "); } - vlib_cli_output (vm, "%s %U %v\n", - mode, - format_vnet_sw_if_index_name, - vnm, si->sw_if_index, - args); - vec_free (args); + vlib_cli_output (vm, "%s %U %v\n", + mode, + format_vnet_sw_if_index_name, + vnm, si->sw_if_index, args); + vec_free (args); } done: vec_free (sis); - + return error; } +/* *INDENT-OFF* */ VLIB_CLI_COMMAND (show_l2_mode, static) = { .path = "show mode", .short_help = "show mode [ ...]", .function = show_int_mode, }; +/* *INDENT-ON* */ #define foreach_l2_init_function \ _(feat_bitmap_drop_init) \ @@ -955,10 +1041,11 @@ _(l2output_init) \ _(l2_patch_init) \ _(l2_xcrw_init) -clib_error_t *l2_init (vlib_main_t * vm) +clib_error_t * +l2_init (vlib_main_t * vm) { - clib_error_t * error; - + clib_error_t *error; + #define _(a) do { \ if ((error = vlib_call_init_function (vm, a))) return error; } \ while (0); @@ -968,3 +1055,11 @@ while (0); } VLIB_INIT_FUNCTION (l2_init); + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/vnet/vnet/l2/l2_input.h b/vnet/vnet/l2/l2_input.h index 9ebfb39d0d3..3d8fc0afe5c 100644 --- a/vnet/vnet/l2/l2_input.h +++ b/vnet/vnet/l2/l2_input.h @@ -24,39 +24,42 @@ #include #include -// Per-subinterface L2 feature configuration +/* Per-subinterface L2 feature configuration */ -typedef struct { +typedef struct +{ - union { - u16 bd_index; // bridge domain id - u32 output_sw_if_index; // for xconnect + union + { + u16 bd_index; /* bridge domain id */ + u32 output_sw_if_index; /* for xconnect */ }; - // Interface mode. If both are 0, this interface is in L3 mode - u8 xconnect; - u8 bridge; + /* Interface mode. If both are 0, this interface is in L3 mode */ + u8 xconnect; + u8 bridge; - // this is the bvi interface for the bridge-domain - u8 bvi; + /* this is the bvi interface for the bridge-domain */ + u8 bvi; - // config for which input features are configured on this interface + /* config for which input features are configured on this interface */ u32 feature_bitmap; - // some of these flags are also in the feature bitmap - u8 learn_enable; - u8 fwd_enable; - u8 flood_enable; + /* some of these flags are also in the feature bitmap */ + u8 learn_enable; + u8 fwd_enable; + u8 flood_enable; - // split horizon group - u8 shg; + /* split horizon group */ + u8 shg; } l2_input_config_t; -typedef struct { +typedef struct +{ - // Next nodes for the feature bitmap + /* Next nodes for the feature bitmap */ u32 feat_next_node_index[32]; /* config vector indexed by sw_if_index */ @@ -66,27 +69,27 @@ typedef struct { l2_bridge_domain_t *bd_configs; /* convenience variables */ - vlib_main_t * vlib_main; - vnet_main_t * vnet_main; + vlib_main_t *vlib_main; + vnet_main_t *vnet_main; } l2input_main_t; extern l2input_main_t l2input_main; extern vlib_node_registration_t l2input_node; -static_always_inline l2_bridge_domain_t * +static_always_inline l2_bridge_domain_t * l2input_bd_config_from_index (l2input_main_t * l2im, u32 bd_index) { - l2_bridge_domain_t * bd_config; + l2_bridge_domain_t *bd_config; - bd_config = vec_elt_at_index (l2im->bd_configs, bd_index); - return bd_is_valid (bd_config) ? bd_config : NULL; + bd_config = vec_elt_at_index (l2im->bd_configs, bd_index); + return bd_is_valid (bd_config) ? bd_config : NULL; } -// L2 input features +/* L2 input features */ -// Mappings from feature ID to graph node name -#define foreach_l2input_feat \ +/* Mappings from feature ID to graph node name */ +#define foreach_l2input_feat \ _(DROP, "feature-bitmap-drop") \ _(CLASSIFY, "l2-classify") \ _(XCONNECT, "l2-output") \ @@ -112,56 +115,62 @@ l2input_bd_config_from_index (l2input_main_t * l2im, u32 bd_index) _(SPAN, "feature-bitmap-drop") \ _(POLICER_CLAS, "l2-policer-classify") -// Feature bitmap positions -typedef enum { +/* Feature bitmap positions */ +typedef enum +{ #define _(sym,str) L2INPUT_FEAT_##sym##_BIT, foreach_l2input_feat #undef _ - L2INPUT_N_FEAT, + L2INPUT_N_FEAT, } l2input_feat_t; -// Feature bit masks -typedef enum { +/* Feature bit masks */ +typedef enum +{ #define _(sym,str) L2INPUT_FEAT_##sym = (1<feature_bitmap & L2INPUT_FEAT_FLOOD) == - L2INPUT_FEAT_FLOOD); + return ((bd_config->feature_bitmap & L2INPUT_FEAT_FLOOD) == + L2INPUT_FEAT_FLOOD); } -static_always_inline u8 bd_feature_uu_flood (l2_bridge_domain_t * bd_config) +static_always_inline u8 +bd_feature_uu_flood (l2_bridge_domain_t * bd_config) { - return ((bd_config->feature_bitmap & L2INPUT_FEAT_UU_FLOOD) == - L2INPUT_FEAT_UU_FLOOD); + return ((bd_config->feature_bitmap & L2INPUT_FEAT_UU_FLOOD) == + L2INPUT_FEAT_UU_FLOOD); } -static_always_inline u8 bd_feature_forward (l2_bridge_domain_t * bd_config) +static_always_inline u8 +bd_feature_forward (l2_bridge_domain_t * bd_config) { - return ((bd_config->feature_bitmap & L2INPUT_FEAT_FWD) == - L2INPUT_FEAT_FWD); + return ((bd_config->feature_bitmap & L2INPUT_FEAT_FWD) == L2INPUT_FEAT_FWD); } -static_always_inline u8 bd_feature_learn (l2_bridge_domain_t * bd_config) +static_always_inline u8 +bd_feature_learn (l2_bridge_domain_t * bd_config) { - return ((bd_config->feature_bitmap & L2INPUT_FEAT_LEARN) == - L2INPUT_FEAT_LEARN); + return ((bd_config->feature_bitmap & L2INPUT_FEAT_LEARN) == + L2INPUT_FEAT_LEARN); } -static_always_inline u8 bd_feature_arp_term (l2_bridge_domain_t * bd_config) +static_always_inline u8 +bd_feature_arp_term (l2_bridge_domain_t * bd_config) { - return ((bd_config->feature_bitmap & L2INPUT_FEAT_ARP_TERM) == - L2INPUT_FEAT_ARP_TERM); + return ((bd_config->feature_bitmap & L2INPUT_FEAT_ARP_TERM) == + L2INPUT_FEAT_ARP_TERM); } -// Masks for eliminating features that do not apply to a packet +/** Masks for eliminating features that do not apply to a packet */ #define IP4_FEAT_MASK ~(L2INPUT_FEAT_CTRL_PKT | \ L2INPUT_FEAT_MLD_SNOOP | \ @@ -192,18 +201,15 @@ static_always_inline u8 bd_feature_arp_term (l2_bridge_domain_t * bd_config) L2INPUT_FEAT_DAI) -// Get a pointer to the config for the given interface -l2_input_config_t * l2input_intf_config (u32 sw_if_index); +/** Get a pointer to the config for the given interface */ +l2_input_config_t *l2input_intf_config (u32 sw_if_index); -// Enable (or disable) the feature in the bitmap for the given interface +/* Enable (or disable) the feature in the bitmap for the given interface */ u32 l2input_intf_bitmap_enable (u32 sw_if_index, - u32 feature_bitmap, - u32 enable); + u32 feature_bitmap, u32 enable); -//Sets modifies flags from a bridge domain -u32 l2input_set_bridge_features(u32 bd_index, - u32 feat_mask, - u32 feat_value); +/* Sets modifies flags from a bridge domain */ +u32 l2input_set_bridge_features (u32 bd_index, u32 feat_mask, u32 feat_value); #define MODE_L3 0 @@ -215,72 +221,72 @@ u32 l2input_set_bridge_features(u32 bd_index, #define MODE_ERROR_BVI_DEF 2 u32 set_int_l2_mode (vlib_main_t * vm, - vnet_main_t * vnet_main, - u32 mode, - u32 sw_if_index, - u32 bd_index, - u32 bvi, - u32 shg, - u32 xc_sw_if_index); + vnet_main_t * vnet_main, + u32 mode, + u32 sw_if_index, + u32 bd_index, u32 bvi, u32 shg, u32 xc_sw_if_index); static inline void vnet_update_l2_len (vlib_buffer_t * b) { - ethernet_header_t * eth; + ethernet_header_t *eth; u16 ethertype; u8 vlan_count = 0; /* point at currrent l2 hdr */ eth = vlib_buffer_get_current (b); - /* + /* * l2-output pays no attention to this * but the tag push/pop code on an l2 subif needs it. - * - * Determine l2 header len, check for up to 2 vlans + * + * Determine l2 header len, check for up to 2 vlans */ - vnet_buffer(b)->l2.l2_len = sizeof(ethernet_header_t); - ethertype = clib_net_to_host_u16(eth->type); + vnet_buffer (b)->l2.l2_len = sizeof (ethernet_header_t); + ethertype = clib_net_to_host_u16 (eth->type); if ((ethertype == ETHERNET_TYPE_VLAN) || (ethertype == ETHERNET_TYPE_DOT1AD) || (ethertype == ETHERNET_TYPE_VLAN_9100) || - (ethertype == ETHERNET_TYPE_VLAN_9200)) { - ethernet_vlan_header_t * vlan; - vnet_buffer(b)->l2.l2_len += sizeof (*vlan); - vlan_count = 1; - vlan = (void *) (eth+1); - ethertype = clib_net_to_host_u16 (vlan->type); - if (ethertype == ETHERNET_TYPE_VLAN) { - vnet_buffer(b)->l2.l2_len += sizeof (*vlan); - vlan_count = 2; + (ethertype == ETHERNET_TYPE_VLAN_9200)) + { + ethernet_vlan_header_t *vlan; + vnet_buffer (b)->l2.l2_len += sizeof (*vlan); + vlan_count = 1; + vlan = (void *) (eth + 1); + ethertype = clib_net_to_host_u16 (vlan->type); + if (ethertype == ETHERNET_TYPE_VLAN) + { + vnet_buffer (b)->l2.l2_len += sizeof (*vlan); + vlan_count = 2; + } } - } - ethernet_buffer_set_vlan_count(b, vlan_count); + ethernet_buffer_set_vlan_count (b, vlan_count); } /* - * Compute flow hash of an ethernet packet, use 5-tuple hash if L3 packet - * is ip4 or ip6. Otherwise hash on smac/dmac/etype. - * The vlib buffer current pointer is expected to be at ethernet header + * Compute flow hash of an ethernet packet, use 5-tuple hash if L3 packet + * is ip4 or ip6. Otherwise hash on smac/dmac/etype. + * The vlib buffer current pointer is expected to be at ethernet header * and vnet l2.l2_len is exppected to be setup already. */ -static inline u32 vnet_l2_compute_flow_hash (vlib_buffer_t *b) +static inline u32 +vnet_l2_compute_flow_hash (vlib_buffer_t * b) { - ethernet_header_t * eh = vlib_buffer_get_current(b); - u8 * l3h = (u8 *)eh + vnet_buffer(b)->l2.l2_len; - u16 ethertype = clib_net_to_host_u16(*(u16 *)(l3h - 2)); - - if (ethertype == ETHERNET_TYPE_IP4) - return ip4_compute_flow_hash((ip4_header_t *) l3h, IP_FLOW_HASH_DEFAULT); - else if (ethertype == ETHERNET_TYPE_IP6) - return ip6_compute_flow_hash((ip6_header_t *) l3h, IP_FLOW_HASH_DEFAULT); + ethernet_header_t *eh = vlib_buffer_get_current (b); + u8 *l3h = (u8 *) eh + vnet_buffer (b)->l2.l2_len; + u16 ethertype = clib_net_to_host_u16 (*(u16 *) (l3h - 2)); + + if (ethertype == ETHERNET_TYPE_IP4) + return ip4_compute_flow_hash ((ip4_header_t *) l3h, IP_FLOW_HASH_DEFAULT); + else if (ethertype == ETHERNET_TYPE_IP6) + return ip6_compute_flow_hash ((ip6_header_t *) l3h, IP_FLOW_HASH_DEFAULT); else { u32 a, b, c; - u32 * ap = (u32 *) &eh->dst_address[2]; - u32 * bp = (u32 *) &eh->src_address[2]; - a = * ap; - b = * bp; + u32 *ap = (u32 *) & eh->dst_address[2]; + u32 *bp = (u32 *) & eh->src_address[2]; + a = *ap; + b = *bp; c = ethertype; hash_v3_mix32 (a, b, c); hash_v3_finalize32 (a, b, c); @@ -290,3 +296,11 @@ static inline u32 vnet_l2_compute_flow_hash (vlib_buffer_t *b) #endif + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/vnet/vnet/l2/l2_input_acl.c b/vnet/vnet/l2/l2_input_acl.c index f8e77d7e58f..de9f6791225 100644 --- a/vnet/vnet/l2/l2_input_acl.c +++ b/vnet/vnet/l2/l2_input_acl.c @@ -34,17 +34,19 @@ #include #include -typedef struct { +typedef struct +{ - // Next nodes for each feature + /* Next nodes for each feature */ u32 feat_next_node_index[32]; /* convenience variables */ - vlib_main_t * vlib_main; - vnet_main_t * vnet_main; + vlib_main_t *vlib_main; + vnet_main_t *vnet_main; } l2_inacl_main_t; -typedef struct { +typedef struct +{ u32 sw_if_index; u32 next_index; u32 table_index; @@ -52,12 +54,13 @@ typedef struct { } l2_inacl_trace_t; /* packet trace format function */ -static u8 * format_l2_inacl_trace (u8 * s, va_list * args) +static u8 * +format_l2_inacl_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 *); - l2_inacl_trace_t * t = va_arg (*args, l2_inacl_trace_t *); - + l2_inacl_trace_t *t = va_arg (*args, l2_inacl_trace_t *); + s = format (s, "INACL: sw_if_index %d, next_index %d, table %d, offset %d", t->sw_if_index, t->next_index, t->table_index, t->offset); return s; @@ -76,14 +79,15 @@ _(TABLE_MISS, "input ACL table-miss drops") \ _(SESSION_DENY, "input ACL session deny drops") -typedef enum { +typedef enum +{ #define _(sym,str) L2_INACL_ERROR_##sym, foreach_l2_inacl_error #undef _ - L2_INACL_N_ERROR, + L2_INACL_N_ERROR, } l2_inacl_error_t; -static char * l2_inacl_error_strings[] = { +static char *l2_inacl_error_strings[] = { #define _(sym,string) string, foreach_l2_inacl_error #undef _ @@ -91,14 +95,13 @@ static char * l2_inacl_error_strings[] = { static uword l2_inacl_node_fn (vlib_main_t * vm, - vlib_node_runtime_t * node, - vlib_frame_t * frame) + vlib_node_runtime_t * node, vlib_frame_t * frame) { - u32 n_left_from, * from, * to_next; + u32 n_left_from, *from, *to_next; acl_next_index_t next_index; - l2_inacl_main_t * msm = &l2_inacl_main; - input_acl_main_t * am = &input_acl_main; - vnet_classify_main_t * vcm = am->vnet_classify_main; + l2_inacl_main_t *msm = &l2_inacl_main; + input_acl_main_t *am = &input_acl_main; + vnet_classify_main_t *vcm = am->vnet_classify_main; input_acl_table_id_t tid = INPUT_ACL_TABLE_L2; f64 now = vlib_time_now (vm); u32 hits = 0; @@ -106,30 +109,30 @@ l2_inacl_node_fn (vlib_main_t * vm, u32 chain_hits = 0; from = vlib_frame_vector_args (frame); - n_left_from = frame->n_vectors; /* number of packets to process */ + n_left_from = frame->n_vectors; /* number of packets to process */ next_index = node->cached_next_index; /* First pass: compute hashes */ while (n_left_from > 2) { - vlib_buffer_t * b0, * b1; + vlib_buffer_t *b0, *b1; u32 bi0, bi1; - u8 * h0, * h1; + u8 *h0, *h1; u32 sw_if_index0, sw_if_index1; u32 table_index0, table_index1; - vnet_classify_table_t * t0, * t1; + vnet_classify_table_t *t0, *t1; /* prefetch next iteration */ { - vlib_buffer_t * p1, * p2; + vlib_buffer_t *p1, *p2; - p1 = vlib_get_buffer (vm, from[1]); - p2 = vlib_get_buffer (vm, from[2]); + p1 = vlib_get_buffer (vm, from[1]); + p2 = vlib_get_buffer (vm, from[2]); - vlib_prefetch_buffer_header (p1, STORE); - CLIB_PREFETCH (p1->data, CLIB_CACHE_LINE_BYTES, STORE); - vlib_prefetch_buffer_header (p2, STORE); - CLIB_PREFETCH (p2->data, CLIB_CACHE_LINE_BYTES, STORE); + vlib_prefetch_buffer_header (p1, STORE); + CLIB_PREFETCH (p1->data, CLIB_CACHE_LINE_BYTES, STORE); + vlib_prefetch_buffer_header (p2, STORE); + CLIB_PREFETCH (p2->data, CLIB_CACHE_LINE_BYTES, STORE); } bi0 = from[0]; @@ -141,28 +144,30 @@ l2_inacl_node_fn (vlib_main_t * vm, h1 = b1->data; sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX]; - table_index0 = am->classify_table_index_by_sw_if_index[tid][sw_if_index0]; + table_index0 = + am->classify_table_index_by_sw_if_index[tid][sw_if_index0]; sw_if_index1 = vnet_buffer (b1)->sw_if_index[VLIB_RX]; - table_index1 = am->classify_table_index_by_sw_if_index[tid][sw_if_index1]; + table_index1 = + am->classify_table_index_by_sw_if_index[tid][sw_if_index1]; t0 = pool_elt_at_index (vcm->tables, table_index0); t1 = pool_elt_at_index (vcm->tables, table_index1); - vnet_buffer(b0)->l2_classify.hash = - vnet_classify_hash_packet (t0, (u8 *) h0); + vnet_buffer (b0)->l2_classify.hash = + vnet_classify_hash_packet (t0, (u8 *) h0); - vnet_classify_prefetch_bucket (t0, vnet_buffer(b0)->l2_classify.hash); + vnet_classify_prefetch_bucket (t0, vnet_buffer (b0)->l2_classify.hash); - vnet_buffer(b1)->l2_classify.hash = - vnet_classify_hash_packet (t1, (u8 *) h1); + vnet_buffer (b1)->l2_classify.hash = + vnet_classify_hash_packet (t1, (u8 *) h1); - vnet_classify_prefetch_bucket (t1, vnet_buffer(b1)->l2_classify.hash); + vnet_classify_prefetch_bucket (t1, vnet_buffer (b1)->l2_classify.hash); - vnet_buffer(b0)->l2_classify.table_index = table_index0; + vnet_buffer (b0)->l2_classify.table_index = table_index0; - vnet_buffer(b1)->l2_classify.table_index = table_index1; + vnet_buffer (b1)->l2_classify.table_index = table_index1; from += 2; n_left_from -= 2; @@ -170,26 +175,27 @@ l2_inacl_node_fn (vlib_main_t * vm, while (n_left_from > 0) { - vlib_buffer_t * b0; + vlib_buffer_t *b0; u32 bi0; - u8 * h0; + u8 *h0; u32 sw_if_index0; u32 table_index0; - vnet_classify_table_t * t0; + vnet_classify_table_t *t0; bi0 = from[0]; b0 = vlib_get_buffer (vm, bi0); h0 = b0->data; sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX]; - table_index0 = am->classify_table_index_by_sw_if_index[tid][sw_if_index0]; + table_index0 = + am->classify_table_index_by_sw_if_index[tid][sw_if_index0]; t0 = pool_elt_at_index (vcm->tables, table_index0); - vnet_buffer(b0)->l2_classify.hash = - vnet_classify_hash_packet (t0, (u8 *) h0); + vnet_buffer (b0)->l2_classify.hash = + vnet_classify_hash_packet (t0, (u8 *) h0); - vnet_buffer(b0)->l2_classify.table_index = table_index0; - vnet_classify_prefetch_bucket (t0, vnet_buffer(b0)->l2_classify.hash); + vnet_buffer (b0)->l2_classify.table_index = table_index0; + vnet_classify_prefetch_bucket (t0, vnet_buffer (b0)->l2_classify.hash); from++; n_left_from--; @@ -203,163 +209,162 @@ l2_inacl_node_fn (vlib_main_t * vm, { u32 n_left_to_next; - vlib_get_next_frame (vm, node, next_index, - to_next, n_left_to_next); + vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next); /* Not enough load/store slots to dual loop... */ while (n_left_from > 0 && n_left_to_next > 0) - { - u32 bi0; - vlib_buffer_t * b0; - u32 next0 = ACL_NEXT_INDEX_DENY; - u32 table_index0; - vnet_classify_table_t * t0; - vnet_classify_entry_t * e0; - u64 hash0; - u8 * h0; - u8 error0; - - /* Stride 3 seems to work best */ - if (PREDICT_TRUE (n_left_from > 3)) - { - vlib_buffer_t * p1 = vlib_get_buffer(vm, from[3]); - vnet_classify_table_t * tp1; - u32 table_index1; - u64 phash1; - - table_index1 = vnet_buffer(p1)->l2_classify.table_index; - - if (PREDICT_TRUE (table_index1 != ~0)) - { - tp1 = pool_elt_at_index (vcm->tables, table_index1); - phash1 = vnet_buffer(p1)->l2_classify.hash; - vnet_classify_prefetch_entry (tp1, phash1); - } - } - - /* speculatively enqueue b0 to the current next frame */ - 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); - h0 = b0->data; - table_index0 = vnet_buffer(b0)->l2_classify.table_index; - e0 = 0; - t0 = 0; - - /* Feature bitmap update */ - vnet_buffer(b0)->l2.feature_bitmap &= ~L2INPUT_FEAT_ACL; - - vnet_buffer(b0)->l2_classify.opaque_index = ~0; - /* Determine the next node */ - next0 = feat_bitmap_get_next_node_index(msm->feat_next_node_index, - vnet_buffer(b0)->l2.feature_bitmap); - - if (PREDICT_TRUE(table_index0 != ~0)) - { - hash0 = vnet_buffer(b0)->l2_classify.hash; - t0 = pool_elt_at_index (vcm->tables, table_index0); - - e0 = vnet_classify_find_entry (t0, (u8 *) h0, hash0, - now); - if (e0) - { - vnet_buffer(b0)->l2_classify.opaque_index - = e0->opaque_index; - vlib_buffer_advance (b0, e0->advance); - - next0 = (e0->next_index < ACL_NEXT_INDEX_N_NEXT)? - e0->next_index:next0; - - hits++; - - error0 = (next0 == ACL_NEXT_INDEX_DENY)? - L2_INACL_ERROR_SESSION_DENY:L2_INACL_ERROR_NONE; - b0->error = node->errors[error0]; - } - else - { - while (1) - { - if (PREDICT_TRUE(t0->next_table_index != ~0)) - t0 = pool_elt_at_index (vcm->tables, - t0->next_table_index); - else - { - next0 = (t0->miss_next_index < ACL_NEXT_INDEX_N_NEXT)? - t0->miss_next_index:next0; - - misses++; - - error0 = (next0 == ACL_NEXT_INDEX_DENY)? - L2_INACL_ERROR_TABLE_MISS:L2_INACL_ERROR_NONE; - b0->error = node->errors[error0]; - break; - } - - hash0 = vnet_classify_hash_packet (t0, (u8 *) h0); - e0 = vnet_classify_find_entry - (t0, (u8 *) h0, hash0, now); - if (e0) - { - vlib_buffer_advance (b0, e0->advance); - next0 = (e0->next_index < ACL_NEXT_INDEX_N_NEXT)? - e0->next_index:next0; - hits++; - chain_hits++; - - error0 = (next0 == ACL_NEXT_INDEX_DENY)? - L2_INACL_ERROR_SESSION_DENY:L2_INACL_ERROR_NONE; - b0->error = node->errors[error0]; - break; - } - } - } - } - - if (PREDICT_FALSE((node->flags & VLIB_NODE_FLAG_TRACE) - && (b0->flags & VLIB_BUFFER_IS_TRACED))) - { - l2_inacl_trace_t *t = - vlib_add_trace (vm, node, b0, sizeof (*t)); - t->sw_if_index = vnet_buffer(b0)->sw_if_index[VLIB_RX]; - t->next_index = next0; - t->table_index = t0 ? t0 - vcm->tables : ~0; - t->offset = (t0 && e0) ? vnet_classify_get_offset (t0, e0): ~0; - } - - /* verify speculative enqueue, maybe switch current next frame */ - vlib_validate_buffer_enqueue_x1 (vm, node, next_index, - to_next, n_left_to_next, - bi0, next0); - } + { + u32 bi0; + vlib_buffer_t *b0; + u32 next0 = ACL_NEXT_INDEX_DENY; + u32 table_index0; + vnet_classify_table_t *t0; + vnet_classify_entry_t *e0; + u64 hash0; + u8 *h0; + u8 error0; + + /* Stride 3 seems to work best */ + if (PREDICT_TRUE (n_left_from > 3)) + { + vlib_buffer_t *p1 = vlib_get_buffer (vm, from[3]); + vnet_classify_table_t *tp1; + u32 table_index1; + u64 phash1; + + table_index1 = vnet_buffer (p1)->l2_classify.table_index; + + if (PREDICT_TRUE (table_index1 != ~0)) + { + tp1 = pool_elt_at_index (vcm->tables, table_index1); + phash1 = vnet_buffer (p1)->l2_classify.hash; + vnet_classify_prefetch_entry (tp1, phash1); + } + } + + /* speculatively enqueue b0 to the current next frame */ + 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); + h0 = b0->data; + table_index0 = vnet_buffer (b0)->l2_classify.table_index; + e0 = 0; + t0 = 0; + + /* Feature bitmap update */ + vnet_buffer (b0)->l2.feature_bitmap &= ~L2INPUT_FEAT_ACL; + + vnet_buffer (b0)->l2_classify.opaque_index = ~0; + /* Determine the next node */ + next0 = feat_bitmap_get_next_node_index (msm->feat_next_node_index, + vnet_buffer (b0)-> + l2.feature_bitmap); + + if (PREDICT_TRUE (table_index0 != ~0)) + { + hash0 = vnet_buffer (b0)->l2_classify.hash; + t0 = pool_elt_at_index (vcm->tables, table_index0); + + e0 = vnet_classify_find_entry (t0, (u8 *) h0, hash0, now); + if (e0) + { + vnet_buffer (b0)->l2_classify.opaque_index + = e0->opaque_index; + vlib_buffer_advance (b0, e0->advance); + + next0 = (e0->next_index < ACL_NEXT_INDEX_N_NEXT) ? + e0->next_index : next0; + + hits++; + + error0 = (next0 == ACL_NEXT_INDEX_DENY) ? + L2_INACL_ERROR_SESSION_DENY : L2_INACL_ERROR_NONE; + b0->error = node->errors[error0]; + } + else + { + while (1) + { + if (PREDICT_TRUE (t0->next_table_index != ~0)) + t0 = pool_elt_at_index (vcm->tables, + t0->next_table_index); + else + { + next0 = + (t0->miss_next_index < + ACL_NEXT_INDEX_N_NEXT) ? t0->miss_next_index : + next0; + + misses++; + + error0 = (next0 == ACL_NEXT_INDEX_DENY) ? + L2_INACL_ERROR_TABLE_MISS : L2_INACL_ERROR_NONE; + b0->error = node->errors[error0]; + break; + } + + hash0 = vnet_classify_hash_packet (t0, (u8 *) h0); + e0 = vnet_classify_find_entry + (t0, (u8 *) h0, hash0, now); + if (e0) + { + vlib_buffer_advance (b0, e0->advance); + next0 = (e0->next_index < ACL_NEXT_INDEX_N_NEXT) ? + e0->next_index : next0; + hits++; + chain_hits++; + + error0 = (next0 == ACL_NEXT_INDEX_DENY) ? + L2_INACL_ERROR_SESSION_DENY : L2_INACL_ERROR_NONE; + b0->error = node->errors[error0]; + break; + } + } + } + } + + if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE) + && (b0->flags & VLIB_BUFFER_IS_TRACED))) + { + l2_inacl_trace_t *t = + vlib_add_trace (vm, node, b0, sizeof (*t)); + t->sw_if_index = vnet_buffer (b0)->sw_if_index[VLIB_RX]; + t->next_index = next0; + t->table_index = t0 ? t0 - vcm->tables : ~0; + t->offset = (t0 && e0) ? vnet_classify_get_offset (t0, e0) : ~0; + } + + /* verify speculative enqueue, maybe switch current next frame */ + 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, node->node_index, - L2_INACL_ERROR_MISS, - misses); + L2_INACL_ERROR_MISS, misses); vlib_node_increment_counter (vm, node->node_index, - L2_INACL_ERROR_HIT, - hits); + L2_INACL_ERROR_HIT, hits); vlib_node_increment_counter (vm, node->node_index, - L2_INACL_ERROR_CHAIN_HIT, - chain_hits); + L2_INACL_ERROR_CHAIN_HIT, chain_hits); return frame->n_vectors; } +/* *INDENT-OFF* */ VLIB_REGISTER_NODE (l2_inacl_node,static) = { .function = l2_inacl_node_fn, .name = "l2-input-acl", .vector_size = sizeof (u32), .format_trace = format_l2_inacl_trace, .type = VLIB_NODE_TYPE_INTERNAL, - + .n_errors = ARRAY_LEN(l2_inacl_error_strings), .error_strings = l2_inacl_error_strings, @@ -370,24 +375,32 @@ VLIB_REGISTER_NODE (l2_inacl_node,static) = { [ACL_NEXT_INDEX_DENY] = "error-drop", }, }; +/* *INDENT-ON* */ VLIB_NODE_FUNCTION_MULTIARCH (l2_inacl_node, l2_inacl_node_fn) - -clib_error_t *l2_inacl_init (vlib_main_t *vm) + clib_error_t *l2_inacl_init (vlib_main_t * vm) { - l2_inacl_main_t * mp = &l2_inacl_main; - + l2_inacl_main_t *mp = &l2_inacl_main; + mp->vlib_main = vm; - mp->vnet_main = vnet_get_main(); + mp->vnet_main = vnet_get_main (); - // Initialize the feature next-node indexes - feat_bitmap_init_next_nodes(vm, - l2_inacl_node.index, - L2INPUT_N_FEAT, - l2input_get_feat_names(), - mp->feat_next_node_index); + /* Initialize the feature next-node indexes */ + feat_bitmap_init_next_nodes (vm, + l2_inacl_node.index, + L2INPUT_N_FEAT, + l2input_get_feat_names (), + mp->feat_next_node_index); return 0; } VLIB_INIT_FUNCTION (l2_inacl_init); + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/vnet/vnet/l2/l2_input_vtr.c b/vnet/vnet/l2/l2_input_vtr.c index d0f2181be8c..47b12115071 100644 --- a/vnet/vnet/l2/l2_input_vtr.c +++ b/vnet/vnet/l2/l2_input_vtr.c @@ -29,28 +29,31 @@ #include -typedef struct { - /* per-pkt trace data */ - u8 src[6]; - u8 dst[6]; - u8 raw[12]; // raw data (vlans) +typedef struct +{ + /* per-pkt trace data */ + u8 src[6]; + u8 dst[6]; + u8 raw[12]; /* raw data (vlans) */ u32 sw_if_index; } l2_invtr_trace_t; /* packet trace format function */ -static u8 * format_l2_invtr_trace (u8 * s, va_list * args) +static u8 * +format_l2_invtr_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 *); - l2_invtr_trace_t * t = va_arg (*args, l2_invtr_trace_t *); - + l2_invtr_trace_t *t = va_arg (*args, l2_invtr_trace_t *); + s = format (s, "l2-input-vtr: sw_if_index %d dst %U src %U data " - "%02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x", + "%02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x", t->sw_if_index, - format_ethernet_address, t->dst, - format_ethernet_address, t->src, - t->raw[0], t->raw[1], t->raw[2], t->raw[3], t->raw[4], t->raw[5], - t->raw[6], t->raw[7], t->raw[8], t->raw[9], t->raw[10], t->raw[11]); + format_ethernet_address, t->dst, + format_ethernet_address, t->src, + t->raw[0], t->raw[1], t->raw[2], t->raw[3], t->raw[4], + t->raw[5], t->raw[6], t->raw[7], t->raw[8], t->raw[9], + t->raw[10], t->raw[11]); return s; } @@ -62,20 +65,22 @@ static vlib_node_registration_t l2_invtr_node; _(L2_INVTR, "L2 inverter packets") \ _(DROP, "L2 input tag rewrite drops") -typedef enum { +typedef enum +{ #define _(sym,str) L2_INVTR_ERROR_##sym, foreach_l2_invtr_error #undef _ - L2_INVTR_N_ERROR, + L2_INVTR_N_ERROR, } l2_invtr_error_t; -static char * l2_invtr_error_strings[] = { +static char *l2_invtr_error_strings[] = { #define _(sym,string) string, foreach_l2_invtr_error #undef _ }; -typedef enum { +typedef enum +{ L2_INVTR_NEXT_DROP, L2_INVTR_N_NEXT, } l2_invtr_next_t; @@ -83,18 +88,14 @@ typedef enum { static uword l2_invtr_node_fn (vlib_main_t * vm, - vlib_node_runtime_t * node, - vlib_frame_t * frame) + vlib_node_runtime_t * node, vlib_frame_t * frame) { - u32 n_left_from, * from, * to_next; + u32 n_left_from, *from, *to_next; l2_invtr_next_t next_index; - l2_invtr_main_t * msm = &l2_invtr_main; - // vlib_node_t *n = vlib_get_node (vm, l2_invtr_node.index); - // u32 node_counter_base_index = n->error_heap_index; - // vlib_error_main_t * em = &vm->error_main; + l2_invtr_main_t *msm = &l2_invtr_main; from = vlib_frame_vector_args (frame); - n_left_from = frame->n_vectors; /* number of packets to process */ + n_left_from = frame->n_vectors; /* number of packets to process */ next_index = node->cached_next_index; while (n_left_from > 0) @@ -102,44 +103,49 @@ l2_invtr_node_fn (vlib_main_t * vm, u32 n_left_to_next; /* get space to enqueue frame to graph node "next_index" */ - vlib_get_next_frame (vm, node, next_index, - to_next, n_left_to_next); + vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next); while (n_left_from >= 6 && n_left_to_next >= 2) { - u32 bi0, bi1; - vlib_buffer_t * b0, * b1; - u32 next0, next1; - u32 sw_if_index0, sw_if_index1; - u32 feature_bitmap0, feature_bitmap1; - + u32 bi0, bi1; + vlib_buffer_t *b0, *b1; + u32 next0, next1; + u32 sw_if_index0, sw_if_index1; + u32 feature_bitmap0, feature_bitmap1; + /* Prefetch next iteration. */ { - vlib_buffer_t * p2, * p3, * p4, * p5; - u32 sw_if_index2, sw_if_index3; - + vlib_buffer_t *p2, *p3, *p4, *p5; + u32 sw_if_index2, sw_if_index3; + p2 = vlib_get_buffer (vm, from[2]); p3 = vlib_get_buffer (vm, from[3]); p4 = vlib_get_buffer (vm, from[4]); p5 = vlib_get_buffer (vm, from[5]); - - // Prefetch the buffer header and packet for the N+2 loop iteration + + /* Prefetch the buffer header and packet for the N+2 loop iteration */ vlib_prefetch_buffer_header (p4, LOAD); vlib_prefetch_buffer_header (p5, LOAD); CLIB_PREFETCH (p4->data, CLIB_CACHE_LINE_BYTES, STORE); CLIB_PREFETCH (p5->data, CLIB_CACHE_LINE_BYTES, STORE); - // Prefetch the input config for the N+1 loop iteration - // This depends on the buffer header above - sw_if_index2 = vnet_buffer(p2)->sw_if_index[VLIB_RX]; - sw_if_index3 = vnet_buffer(p3)->sw_if_index[VLIB_RX]; - CLIB_PREFETCH (vec_elt_at_index(l2output_main.configs, sw_if_index2), CLIB_CACHE_LINE_BYTES, LOAD); - CLIB_PREFETCH (vec_elt_at_index(l2output_main.configs, sw_if_index3), CLIB_CACHE_LINE_BYTES, LOAD); + /* + * Prefetch the input config for the N+1 loop iteration + * This depends on the buffer header above + */ + sw_if_index2 = vnet_buffer (p2)->sw_if_index[VLIB_RX]; + sw_if_index3 = vnet_buffer (p3)->sw_if_index[VLIB_RX]; + CLIB_PREFETCH (vec_elt_at_index + (l2output_main.configs, sw_if_index2), + CLIB_CACHE_LINE_BYTES, LOAD); + CLIB_PREFETCH (vec_elt_at_index + (l2output_main.configs, sw_if_index3), + CLIB_CACHE_LINE_BYTES, LOAD); } - /* speculatively enqueue b0 and b1 to the current next frame */ - /* bi is "buffer index", b is pointer to the buffer */ + /* speculatively enqueue b0 and b1 to the current next frame */ + /* bi is "buffer index", b is pointer to the buffer */ to_next[0] = bi0 = from[0]; to_next[1] = bi1 = from[1]; from += 2; @@ -149,77 +155,89 @@ l2_invtr_node_fn (vlib_main_t * vm, b0 = vlib_get_buffer (vm, bi0); b1 = vlib_get_buffer (vm, bi1); - - /* RX interface handles */ - sw_if_index0 = vnet_buffer(b0)->sw_if_index[VLIB_RX]; - sw_if_index1 = vnet_buffer(b1)->sw_if_index[VLIB_RX]; - - // process 2 packets - // em->counters[node_counter_base_index + L2_INVTR_ERROR_L2_INVTR] += 2; - - // Remove ourself from the feature bitmap - feature_bitmap0 = vnet_buffer(b0)->l2.feature_bitmap & ~L2INPUT_FEAT_VTR; - feature_bitmap1 = vnet_buffer(b1)->l2.feature_bitmap & ~L2INPUT_FEAT_VTR; - - // save for next feature graph nodes - vnet_buffer(b0)->l2.feature_bitmap = feature_bitmap0; - vnet_buffer(b1)->l2.feature_bitmap = feature_bitmap1; - - // Determine the next node - next0 = feat_bitmap_get_next_node_index(msm->feat_next_node_index, - feature_bitmap0); - next1 = feat_bitmap_get_next_node_index(msm->feat_next_node_index, - feature_bitmap1); - - // perform the tag rewrite on two packets - if (l2_vtr_process(b0, &(vec_elt_at_index(l2output_main.configs, sw_if_index0)->input_vtr))) { - // Drop packet - next0 = L2_INVTR_NEXT_DROP; - b0->error = node->errors[L2_INVTR_ERROR_DROP]; - } - if (l2_vtr_process(b1, &(vec_elt_at_index(l2output_main.configs, sw_if_index1)->input_vtr))) { - // Drop packet - next1 = L2_INVTR_NEXT_DROP; - b1->error = node->errors[L2_INVTR_ERROR_DROP]; - } - if (PREDICT_FALSE((node->flags & VLIB_NODE_FLAG_TRACE))) { - if (b0->flags & VLIB_BUFFER_IS_TRACED) { - l2_invtr_trace_t *t = - vlib_add_trace (vm, node, b0, sizeof (*t)); - ethernet_header_t * h0 = vlib_buffer_get_current (b0); - t->sw_if_index = sw_if_index0; - clib_memcpy(t->src, h0->src_address, 6); - clib_memcpy(t->dst, h0->dst_address, 6); - clib_memcpy(t->raw, &h0->type, sizeof(t->raw)); - } - if (b1->flags & VLIB_BUFFER_IS_TRACED) { - l2_invtr_trace_t *t = - vlib_add_trace (vm, node, b1, sizeof (*t)); - ethernet_header_t * h1 = vlib_buffer_get_current (b1); - t->sw_if_index = sw_if_index0; - clib_memcpy(t->src, h1->src_address, 6); - clib_memcpy(t->dst, h1->dst_address, 6); - clib_memcpy(t->raw, &h1->type, sizeof(t->raw)); - } - } - - /* verify speculative enqueues, maybe switch current next frame */ - /* if next0==next1==next_index then nothing special needs to be done */ - vlib_validate_buffer_enqueue_x2 (vm, node, next_index, - to_next, n_left_to_next, - bi0, bi1, next0, next1); - } - + /* RX interface handles */ + sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX]; + sw_if_index1 = vnet_buffer (b1)->sw_if_index[VLIB_RX]; + + /* process 2 packets */ + + /* Remove ourself from the feature bitmap */ + feature_bitmap0 = + vnet_buffer (b0)->l2.feature_bitmap & ~L2INPUT_FEAT_VTR; + feature_bitmap1 = + vnet_buffer (b1)->l2.feature_bitmap & ~L2INPUT_FEAT_VTR; + + /* save for next feature graph nodes */ + vnet_buffer (b0)->l2.feature_bitmap = feature_bitmap0; + vnet_buffer (b1)->l2.feature_bitmap = feature_bitmap1; + + /* Determine the next node */ + next0 = feat_bitmap_get_next_node_index (msm->feat_next_node_index, + feature_bitmap0); + next1 = feat_bitmap_get_next_node_index (msm->feat_next_node_index, + feature_bitmap1); + + /* perform the tag rewrite on two packets */ + if (l2_vtr_process + (b0, + &(vec_elt_at_index + (l2output_main.configs, sw_if_index0)->input_vtr))) + { + /* Drop packet */ + next0 = L2_INVTR_NEXT_DROP; + b0->error = node->errors[L2_INVTR_ERROR_DROP]; + } + if (l2_vtr_process + (b1, + &(vec_elt_at_index + (l2output_main.configs, sw_if_index1)->input_vtr))) + { + /* Drop packet */ + next1 = L2_INVTR_NEXT_DROP; + b1->error = node->errors[L2_INVTR_ERROR_DROP]; + } + + if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE))) + { + if (b0->flags & VLIB_BUFFER_IS_TRACED) + { + l2_invtr_trace_t *t = + vlib_add_trace (vm, node, b0, sizeof (*t)); + ethernet_header_t *h0 = vlib_buffer_get_current (b0); + t->sw_if_index = sw_if_index0; + clib_memcpy (t->src, h0->src_address, 6); + clib_memcpy (t->dst, h0->dst_address, 6); + clib_memcpy (t->raw, &h0->type, sizeof (t->raw)); + } + if (b1->flags & VLIB_BUFFER_IS_TRACED) + { + l2_invtr_trace_t *t = + vlib_add_trace (vm, node, b1, sizeof (*t)); + ethernet_header_t *h1 = vlib_buffer_get_current (b1); + t->sw_if_index = sw_if_index0; + clib_memcpy (t->src, h1->src_address, 6); + clib_memcpy (t->dst, h1->dst_address, 6); + clib_memcpy (t->raw, &h1->type, sizeof (t->raw)); + } + } + + /* verify speculative enqueues, maybe switch current next frame */ + /* if next0==next1==next_index then nothing special needs to be done */ + vlib_validate_buffer_enqueue_x2 (vm, node, next_index, + to_next, n_left_to_next, + bi0, bi1, next0, next1); + } + while (n_left_from > 0 && n_left_to_next > 0) { - u32 bi0; - vlib_buffer_t * b0; - u32 next0; - u32 sw_if_index0; - u32 feature_bitmap0; + u32 bi0; + vlib_buffer_t *b0; + u32 next0; + u32 sw_if_index0; + u32 feature_bitmap0; - /* speculatively enqueue b0 to the current next frame */ + /* speculatively enqueue b0 to the current next frame */ bi0 = from[0]; to_next[0] = bi0; from += 1; @@ -229,40 +247,45 @@ l2_invtr_node_fn (vlib_main_t * vm, b0 = vlib_get_buffer (vm, bi0); - sw_if_index0 = vnet_buffer(b0)->sw_if_index[VLIB_RX]; - - // process 1 packet - // em->counters[node_counter_base_index + L2_INVTR_ERROR_L2_INVTR] += 1; - - // Remove ourself from the feature bitmap - feature_bitmap0 = vnet_buffer(b0)->l2.feature_bitmap & ~L2INPUT_FEAT_VTR; - - // save for next feature graph nodes - vnet_buffer(b0)->l2.feature_bitmap = feature_bitmap0; - - // Determine the next node - next0 = feat_bitmap_get_next_node_index(msm->feat_next_node_index, - feature_bitmap0); - - // perform the tag rewrite on one packet - if (l2_vtr_process(b0, &(vec_elt_at_index(l2output_main.configs, sw_if_index0)->input_vtr))) { - // Drop packet - next0 = L2_INVTR_NEXT_DROP; - b0->error = node->errors[L2_INVTR_ERROR_DROP]; - } - - if (PREDICT_FALSE((node->flags & VLIB_NODE_FLAG_TRACE) - && (b0->flags & VLIB_BUFFER_IS_TRACED))) { - l2_invtr_trace_t *t = - vlib_add_trace (vm, node, b0, sizeof (*t)); - ethernet_header_t * h0 = vlib_buffer_get_current (b0); - t->sw_if_index = sw_if_index0; - clib_memcpy(t->src, h0->src_address, 6); - clib_memcpy(t->dst, h0->dst_address, 6); - clib_memcpy(t->raw, &h0->type, sizeof(t->raw)); - } - - /* verify speculative enqueue, maybe switch current next frame */ + sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX]; + + /* process 1 packet */ + + /* Remove ourself from the feature bitmap */ + feature_bitmap0 = + vnet_buffer (b0)->l2.feature_bitmap & ~L2INPUT_FEAT_VTR; + + /* save for next feature graph nodes */ + vnet_buffer (b0)->l2.feature_bitmap = feature_bitmap0; + + /* Determine the next node */ + next0 = feat_bitmap_get_next_node_index (msm->feat_next_node_index, + feature_bitmap0); + + /* perform the tag rewrite on one packet */ + if (l2_vtr_process + (b0, + &(vec_elt_at_index + (l2output_main.configs, sw_if_index0)->input_vtr))) + { + /* Drop packet */ + next0 = L2_INVTR_NEXT_DROP; + b0->error = node->errors[L2_INVTR_ERROR_DROP]; + } + + if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE) + && (b0->flags & VLIB_BUFFER_IS_TRACED))) + { + l2_invtr_trace_t *t = + vlib_add_trace (vm, node, b0, sizeof (*t)); + ethernet_header_t *h0 = vlib_buffer_get_current (b0); + t->sw_if_index = sw_if_index0; + clib_memcpy (t->src, h0->src_address, 6); + clib_memcpy (t->dst, h0->dst_address, 6); + clib_memcpy (t->raw, &h0->type, sizeof (t->raw)); + } + + /* verify speculative enqueue, maybe switch current next frame */ vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next, n_left_to_next, bi0, next0); @@ -275,13 +298,14 @@ l2_invtr_node_fn (vlib_main_t * vm, } +/* *INDENT-OFF* */ VLIB_REGISTER_NODE (l2_invtr_node,static) = { .function = l2_invtr_node_fn, .name = "l2-input-vtr", .vector_size = sizeof (u32), .format_trace = format_l2_invtr_trace, .type = VLIB_NODE_TYPE_INTERNAL, - + .n_errors = ARRAY_LEN(l2_invtr_error_strings), .error_strings = l2_invtr_error_strings, @@ -292,25 +316,33 @@ VLIB_REGISTER_NODE (l2_invtr_node,static) = { [L2_INVTR_NEXT_DROP] = "error-drop", }, }; +/* *INDENT-ON* */ VLIB_NODE_FUNCTION_MULTIARCH (l2_invtr_node, l2_invtr_node_fn) - -clib_error_t *l2_invtr_init (vlib_main_t *vm) + clib_error_t *l2_invtr_init (vlib_main_t * vm) { - l2_invtr_main_t * mp = &l2_invtr_main; - + l2_invtr_main_t *mp = &l2_invtr_main; + mp->vlib_main = vm; - mp->vnet_main = vnet_get_main(); + mp->vnet_main = vnet_get_main (); - // Initialize the feature next-node indexes - feat_bitmap_init_next_nodes(vm, - l2_invtr_node.index, - L2INPUT_N_FEAT, - l2input_get_feat_names(), - mp->feat_next_node_index); + /* Initialize the feature next-node indexes */ + feat_bitmap_init_next_nodes (vm, + l2_invtr_node.index, + L2INPUT_N_FEAT, + l2input_get_feat_names (), + mp->feat_next_node_index); return 0; } VLIB_INIT_FUNCTION (l2_invtr_init); + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/vnet/vnet/l2/l2_input_vtr.h b/vnet/vnet/l2/l2_input_vtr.h index 57c8e409dea..f248669e550 100644 --- a/vnet/vnet/l2/l2_input_vtr.h +++ b/vnet/vnet/l2/l2_input_vtr.h @@ -24,20 +24,31 @@ #include -typedef struct { +typedef struct +{ - // The input vtr data is located in l2_output_config_t because - // the same config data is used for the egress EFP Filter check. + /* + * The input vtr data is located in l2_output_config_t because + * the same config data is used for the egress EFP Filter check. + */ - // Next nodes for each feature + /* Next nodes for each feature */ u32 feat_next_node_index[32]; /* convenience variables */ - vlib_main_t * vlib_main; - vnet_main_t * vnet_main; + vlib_main_t *vlib_main; + vnet_main_t *vnet_main; } l2_invtr_main_t; extern l2_invtr_main_t l2_invtr_main; -#endif // included_vnet_l2_input_vtr_h +#endif /* included_vnet_l2_input_vtr_h */ + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/vnet/vnet/l2/l2_learn.c b/vnet/vnet/l2/l2_learn.c index 0d94e43dc01..30f5617f05e 100644 --- a/vnet/vnet/l2/l2_learn.c +++ b/vnet/vnet/l2/l2_learn.c @@ -33,7 +33,7 @@ * Ethernet bridge learning * * Populate the mac table with entries mapping the packet's source mac + bridge - * domain ID to the input sw_if_index. + * domain ID to the input sw_if_index. * * Note that learning and forwarding are separate graph nodes. This means that * for a set of packets, all learning is performed first, then all nodes are @@ -45,7 +45,8 @@ */ -typedef struct { +typedef struct +{ u8 src[6]; u8 dst[6]; u32 sw_if_index; @@ -54,17 +55,17 @@ typedef struct { /* packet trace format function */ -static u8 * format_l2learn_trace (u8 * s, va_list * args) +static u8 * +format_l2learn_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 *); - l2learn_trace_t * t = va_arg (*args, l2learn_trace_t *); - + l2learn_trace_t *t = va_arg (*args, l2learn_trace_t *); + s = format (s, "l2-learn: sw_if_index %d dst %U src %U bd_index %d", - t->sw_if_index, - format_ethernet_address, t->dst, - format_ethernet_address, t->src, - t->bd_index); + t->sw_if_index, + format_ethernet_address, t->dst, + format_ethernet_address, t->src, t->bd_index); return s; } @@ -77,130 +78,151 @@ _(MAC_MOVE, "L2 mac moves") \ _(MAC_MOVE_VIOLATE, "L2 mac move violations") \ _(LIMIT, "L2 not learned due to limit") \ _(HIT, "L2 learn hits") \ -_(FILTER_DROP, "L2 filter mac drops") +_(FILTER_DROP, "L2 filter mac drops") -typedef enum { +typedef enum +{ #define _(sym,str) L2LEARN_ERROR_##sym, foreach_l2learn_error #undef _ - L2LEARN_N_ERROR, + L2LEARN_N_ERROR, } l2learn_error_t; -static char * l2learn_error_strings[] = { +static char *l2learn_error_strings[] = { #define _(sym,string) string, foreach_l2learn_error #undef _ }; -typedef enum { +typedef enum +{ L2LEARN_NEXT_L2FWD, L2LEARN_NEXT_DROP, L2LEARN_N_NEXT, } l2learn_next_t; -// Perform learning on one packet based on the mac table lookup result +/** Perform learning on one packet based on the mac table lookup result */ static_always_inline void l2learn_process (vlib_node_runtime_t * node, - l2learn_main_t * msm, - u64 * counter_base, - vlib_buffer_t * b0, - u32 sw_if_index0, - l2fib_entry_key_t * key0, - l2fib_entry_key_t * cached_key, - u32 * bucket0, - l2fib_entry_result_t * result0, - u32 * next0) + l2learn_main_t * msm, + u64 * counter_base, + vlib_buffer_t * b0, + u32 sw_if_index0, + l2fib_entry_key_t * key0, + l2fib_entry_key_t * cached_key, + u32 * bucket0, l2fib_entry_result_t * result0, u32 * next0) { u32 feature_bitmap; - // Set up the default next node (typically L2FWD) + /* Set up the default next node (typically L2FWD) */ - // Remove ourself from the feature bitmap - feature_bitmap = vnet_buffer(b0)->l2.feature_bitmap & ~L2INPUT_FEAT_LEARN; + /* Remove ourself from the feature bitmap */ + feature_bitmap = vnet_buffer (b0)->l2.feature_bitmap & ~L2INPUT_FEAT_LEARN; - // Save for next feature graph nodes - vnet_buffer(b0)->l2.feature_bitmap = feature_bitmap; + /* Save for next feature graph nodes */ + vnet_buffer (b0)->l2.feature_bitmap = feature_bitmap; - // Determine the next node - *next0 = feat_bitmap_get_next_node_index(msm->feat_next_node_index, - feature_bitmap); + /* Determine the next node */ + *next0 = feat_bitmap_get_next_node_index (msm->feat_next_node_index, + feature_bitmap); - // Check mac table lookup result + /* Check mac table lookup result */ - if (PREDICT_TRUE (result0->fields.sw_if_index == sw_if_index0)) { - // The entry was in the table, and the sw_if_index matched, the normal case + if (PREDICT_TRUE (result0->fields.sw_if_index == sw_if_index0)) + { + /* + * The entry was in the table, and the sw_if_index matched, the normal case + * + * TODO: for dataplane learning and aging, do this: + * if refresh=0 and not a static mac, set refresh=1 + */ + counter_base[L2LEARN_ERROR_HIT] += 1; - // TODO: for dataplane learning and aging, do this: - // if refresh=0 and not a static mac, set refresh=1 - counter_base[L2LEARN_ERROR_HIT] += 1; + } + else if (result0->raw == ~0) + { - } else if (result0->raw == ~0) { + /* The entry was not in table, so add it */ - // The entry was not in table, so add it + counter_base[L2LEARN_ERROR_MISS] += 1; - counter_base[L2LEARN_ERROR_MISS] += 1; + if (msm->global_learn_count == msm->global_learn_limit) + { + /* + * Global limit reached. Do not learn the mac but forward the packet. + * In the future, limits could also be per-interface or bridge-domain. + */ + counter_base[L2LEARN_ERROR_LIMIT] += 1; + goto done; - if (msm->global_learn_count == msm->global_learn_limit) { - // Global limit reached. Do not learn the mac but forward the packet. - // In the future, limits could also be per-interface or bridge-domain. - counter_base[L2LEARN_ERROR_LIMIT] += 1; - goto done; + } + else + { + BVT (clib_bihash_kv) kv; + /* It is ok to learn */ - } else { - BVT(clib_bihash_kv) kv; - // It is ok to learn + result0->raw = 0; /* clear all fields */ + result0->fields.sw_if_index = sw_if_index0; + /* TODO: set timestamp in entry to clock for dataplane aging */ + kv.key = key0->raw; + kv.value = result0->raw; - result0->raw = 0; // clear all fields - result0->fields.sw_if_index = sw_if_index0; - // TODO: set timestamp in entry to clock for dataplane aging - kv.key = key0->raw; - kv.value = result0->raw; + BV (clib_bihash_add_del) (msm->mac_table, &kv, 1 /* is_add */ ); - BV(clib_bihash_add_del) (msm->mac_table, &kv, 1 /* is_add */); + cached_key->raw = ~0; /* invalidate the cache */ + msm->global_learn_count++; + } - cached_key->raw = ~0; // invalidate the cache - msm->global_learn_count++; } + else + { - } else { + /* The entry was in the table, but with the wrong sw_if_index mapping (mac move) */ + counter_base[L2LEARN_ERROR_MAC_MOVE] += 1; - // The entry was in the table, but with the wrong sw_if_index mapping (mac move) - counter_base[L2LEARN_ERROR_MAC_MOVE] += 1; + if (result0->fields.static_mac) + { + /* + * Don't overwrite a static mac + * TODO: Check violation policy. For now drop the packet + */ + b0->error = node->errors[L2LEARN_ERROR_MAC_MOVE_VIOLATE]; + *next0 = L2LEARN_NEXT_DROP; + } + else + { + /* + * Update the entry + * TODO: may want to rate limit mac moves + * TODO: check global/bridge domain/interface learn limits + */ + BVT (clib_bihash_kv) kv; - if (result0->fields.static_mac) { - // Don't overwrite a static mac - // TODO: Check violation policy. For now drop the packet - b0->error = node->errors[L2LEARN_ERROR_MAC_MOVE_VIOLATE]; - *next0 = L2LEARN_NEXT_DROP; - } else { - // Update the entry - // TODO: may want to rate limit mac moves - // TODO: check global/bridge domain/interface learn limits - BVT(clib_bihash_kv) kv; + result0->raw = 0; /* clear all fields */ + result0->fields.sw_if_index = sw_if_index0; - result0->raw = 0; // clear all fields - result0->fields.sw_if_index = sw_if_index0; - - kv.key = key0->raw; - kv.value = result0->raw; + kv.key = key0->raw; + kv.value = result0->raw; - cached_key->raw = ~0; // invalidate the cache + cached_key->raw = ~0; /* invalidate the cache */ - BV(clib_bihash_add_del) (msm->mac_table, &kv, 1 /* is_add */); + BV (clib_bihash_add_del) (msm->mac_table, &kv, 1 /* is_add */ ); + } } - } - if (result0->fields.filter) { - // drop packet because lookup matched a filter mac entry + if (result0->fields.filter) + { + /* drop packet because lookup matched a filter mac entry */ - if (*next0 != L2LEARN_NEXT_DROP) { - // if we're not already dropping the packet, do it now - b0->error = node->errors[L2LEARN_ERROR_FILTER_DROP]; - *next0 = L2LEARN_NEXT_DROP; + if (*next0 != L2LEARN_NEXT_DROP) + { + /* if we're not already dropping the packet, do it now */ + b0->error = node->errors[L2LEARN_ERROR_FILTER_DROP]; + *next0 = L2LEARN_NEXT_DROP; + } } - } done: return; @@ -209,52 +231,50 @@ done: static uword l2learn_node_fn (vlib_main_t * vm, - vlib_node_runtime_t * node, - vlib_frame_t * frame) + vlib_node_runtime_t * node, vlib_frame_t * frame) { - u32 n_left_from, * from, * to_next; + u32 n_left_from, *from, *to_next; l2learn_next_t next_index; - l2learn_main_t * msm = &l2learn_main; + l2learn_main_t *msm = &l2learn_main; vlib_node_t *n = vlib_get_node (vm, l2learn_node.index); u32 node_counter_base_index = n->error_heap_index; - vlib_error_main_t * em = &vm->error_main; + vlib_error_main_t *em = &vm->error_main; l2fib_entry_key_t cached_key; l2fib_entry_result_t cached_result; from = vlib_frame_vector_args (frame); - n_left_from = frame->n_vectors; /* number of packets to process */ + n_left_from = frame->n_vectors; /* number of packets to process */ next_index = node->cached_next_index; - - // Clear the one-entry cache in case mac table was updated - cached_key.raw = ~0; - cached_result.raw = ~0; /* warning be gone */ + + /* Clear the one-entry cache in case mac table was updated */ + cached_key.raw = ~0; + cached_result.raw = ~0; /* warning be gone */ while (n_left_from > 0) { u32 n_left_to_next; /* get space to enqueue frame to graph node "next_index" */ - vlib_get_next_frame (vm, node, next_index, - to_next, n_left_to_next); + vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next); while (n_left_from >= 4 && n_left_to_next >= 2) { - u32 bi0, bi1; - vlib_buffer_t * b0, * b1; - u32 next0, next1; - u32 sw_if_index0, sw_if_index1; - ethernet_header_t * h0, * h1; - l2fib_entry_key_t key0, key1; - l2fib_entry_result_t result0, result1; - u32 bucket0, bucket1; - + u32 bi0, bi1; + vlib_buffer_t *b0, *b1; + u32 next0, next1; + u32 sw_if_index0, sw_if_index1; + ethernet_header_t *h0, *h1; + l2fib_entry_key_t key0, key1; + l2fib_entry_result_t result0, result1; + u32 bucket0, bucket1; + /* Prefetch next iteration. */ { - vlib_buffer_t * p2, * p3; - + vlib_buffer_t *p2, *p3; + p2 = vlib_get_buffer (vm, from[2]); p3 = vlib_get_buffer (vm, from[3]); - + vlib_prefetch_buffer_header (p2, LOAD); vlib_prefetch_buffer_header (p3, LOAD); @@ -262,8 +282,8 @@ l2learn_node_fn (vlib_main_t * vm, CLIB_PREFETCH (p3->data, CLIB_CACHE_LINE_BYTES, STORE); } - /* speculatively enqueue b0 and b1 to the current next frame */ - /* bi is "buffer index", b is pointer to the buffer */ + /* speculatively enqueue b0 and b1 to the current next frame */ + /* bi is "buffer index", b is pointer to the buffer */ to_next[0] = bi0 = from[0]; to_next[1] = bi1 = from[1]; from += 2; @@ -273,80 +293,76 @@ l2learn_node_fn (vlib_main_t * vm, b0 = vlib_get_buffer (vm, bi0); b1 = vlib_get_buffer (vm, bi1); - - /* RX interface handles */ - sw_if_index0 = vnet_buffer(b0)->sw_if_index[VLIB_RX]; - sw_if_index1 = vnet_buffer(b1)->sw_if_index[VLIB_RX]; - - /* Process 2 x pkts */ - - h0 = vlib_buffer_get_current (b0); - h1 = vlib_buffer_get_current (b1); - - if (PREDICT_FALSE((node->flags & VLIB_NODE_FLAG_TRACE))) - { - if (b0->flags & VLIB_BUFFER_IS_TRACED) - { - l2learn_trace_t *t = - vlib_add_trace (vm, node, b0, sizeof (*t)); - t->sw_if_index = sw_if_index0; - t->bd_index = vnet_buffer(b0)->l2.bd_index; - clib_memcpy(t->src, h0->src_address, 6); - clib_memcpy(t->dst, h0->dst_address, 6); - } - if (b1->flags & VLIB_BUFFER_IS_TRACED) - { - l2learn_trace_t *t = - vlib_add_trace (vm, node, b1, sizeof (*t)); - t->sw_if_index = sw_if_index1; - t->bd_index = vnet_buffer(b1)->l2.bd_index; - clib_memcpy(t->src, h1->src_address, 6); - clib_memcpy(t->dst, h1->dst_address, 6); - } - } - - /* process 2 pkts */ - em->counters[node_counter_base_index + L2LEARN_ERROR_L2LEARN] += 2; - - l2fib_lookup_2 (msm->mac_table, &cached_key, &cached_result, - h0->src_address, - h1->src_address, - vnet_buffer(b0)->l2.bd_index, - vnet_buffer(b1)->l2.bd_index, - &key0, - &key1, - &bucket0, - &bucket1, - &result0, - &result1); - - l2learn_process (node, msm, &em->counters[node_counter_base_index], - b0, sw_if_index0, &key0, &cached_key, - &bucket0, &result0, &next0); - - l2learn_process (node, msm, &em->counters[node_counter_base_index], - b1, sw_if_index1, &key1, &cached_key, - &bucket1, &result1, &next1); - - /* verify speculative enqueues, maybe switch current next frame */ - /* if next0==next1==next_index then nothing special needs to be done */ - vlib_validate_buffer_enqueue_x2 (vm, node, next_index, - to_next, n_left_to_next, - bi0, bi1, next0, next1); - } - + + /* RX interface handles */ + sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX]; + sw_if_index1 = vnet_buffer (b1)->sw_if_index[VLIB_RX]; + + /* Process 2 x pkts */ + + h0 = vlib_buffer_get_current (b0); + h1 = vlib_buffer_get_current (b1); + + if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE))) + { + if (b0->flags & VLIB_BUFFER_IS_TRACED) + { + l2learn_trace_t *t = + vlib_add_trace (vm, node, b0, sizeof (*t)); + t->sw_if_index = sw_if_index0; + t->bd_index = vnet_buffer (b0)->l2.bd_index; + clib_memcpy (t->src, h0->src_address, 6); + clib_memcpy (t->dst, h0->dst_address, 6); + } + if (b1->flags & VLIB_BUFFER_IS_TRACED) + { + l2learn_trace_t *t = + vlib_add_trace (vm, node, b1, sizeof (*t)); + t->sw_if_index = sw_if_index1; + t->bd_index = vnet_buffer (b1)->l2.bd_index; + clib_memcpy (t->src, h1->src_address, 6); + clib_memcpy (t->dst, h1->dst_address, 6); + } + } + + /* process 2 pkts */ + em->counters[node_counter_base_index + L2LEARN_ERROR_L2LEARN] += 2; + + l2fib_lookup_2 (msm->mac_table, &cached_key, &cached_result, + h0->src_address, + h1->src_address, + vnet_buffer (b0)->l2.bd_index, + vnet_buffer (b1)->l2.bd_index, + &key0, + &key1, &bucket0, &bucket1, &result0, &result1); + + l2learn_process (node, msm, &em->counters[node_counter_base_index], + b0, sw_if_index0, &key0, &cached_key, + &bucket0, &result0, &next0); + + l2learn_process (node, msm, &em->counters[node_counter_base_index], + b1, sw_if_index1, &key1, &cached_key, + &bucket1, &result1, &next1); + + /* verify speculative enqueues, maybe switch current next frame */ + /* if next0==next1==next_index then nothing special needs to be done */ + vlib_validate_buffer_enqueue_x2 (vm, node, next_index, + to_next, n_left_to_next, + bi0, bi1, next0, next1); + } + while (n_left_from > 0 && n_left_to_next > 0) { - u32 bi0; - vlib_buffer_t * b0; - u32 next0; - u32 sw_if_index0; - ethernet_header_t * h0; - l2fib_entry_key_t key0; - l2fib_entry_result_t result0; - u32 bucket0; - - /* speculatively enqueue b0 to the current next frame */ + u32 bi0; + vlib_buffer_t *b0; + u32 next0; + u32 sw_if_index0; + ethernet_header_t *h0; + l2fib_entry_key_t key0; + l2fib_entry_result_t result0; + u32 bucket0; + + /* speculatively enqueue b0 to the current next frame */ bi0 = from[0]; to_next[0] = bi0; from += 1; @@ -356,34 +372,32 @@ l2learn_node_fn (vlib_main_t * vm, b0 = vlib_get_buffer (vm, bi0); - sw_if_index0 = vnet_buffer(b0)->sw_if_index[VLIB_RX]; - - h0 = vlib_buffer_get_current (b0); - - if (PREDICT_FALSE((node->flags & VLIB_NODE_FLAG_TRACE) - && (b0->flags & VLIB_BUFFER_IS_TRACED))) { - l2learn_trace_t *t = - vlib_add_trace (vm, node, b0, sizeof (*t)); - t->sw_if_index = sw_if_index0; - t->bd_index = vnet_buffer(b0)->l2.bd_index; - clib_memcpy(t->src, h0->src_address, 6); - clib_memcpy(t->dst, h0->dst_address, 6); - } - - /* process 1 pkt */ - em->counters[node_counter_base_index + L2LEARN_ERROR_L2LEARN] += 1; - - l2fib_lookup_1 (msm->mac_table, &cached_key, &cached_result, - h0->src_address, vnet_buffer(b0)->l2.bd_index, - &key0, - &bucket0, - &result0); - - l2learn_process (node, msm, &em->counters[node_counter_base_index], - b0, sw_if_index0, &key0, &cached_key, - &bucket0, &result0, &next0); - - /* verify speculative enqueue, maybe switch current next frame */ + sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX]; + + h0 = vlib_buffer_get_current (b0); + + if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE) + && (b0->flags & VLIB_BUFFER_IS_TRACED))) + { + l2learn_trace_t *t = vlib_add_trace (vm, node, b0, sizeof (*t)); + t->sw_if_index = sw_if_index0; + t->bd_index = vnet_buffer (b0)->l2.bd_index; + clib_memcpy (t->src, h0->src_address, 6); + clib_memcpy (t->dst, h0->dst_address, 6); + } + + /* process 1 pkt */ + em->counters[node_counter_base_index + L2LEARN_ERROR_L2LEARN] += 1; + + l2fib_lookup_1 (msm->mac_table, &cached_key, &cached_result, + h0->src_address, vnet_buffer (b0)->l2.bd_index, + &key0, &bucket0, &result0); + + l2learn_process (node, msm, &em->counters[node_counter_base_index], + b0, sw_if_index0, &key0, &cached_key, + &bucket0, &result0, &next0); + + /* verify speculative enqueue, maybe switch current next frame */ vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next, n_left_to_next, bi0, next0); @@ -396,13 +410,14 @@ l2learn_node_fn (vlib_main_t * vm, } +/* *INDENT-OFF* */ VLIB_REGISTER_NODE (l2learn_node,static) = { .function = l2learn_node_fn, .name = "l2-learn", .vector_size = sizeof (u32), .format_trace = format_l2learn_trace, .type = VLIB_NODE_TYPE_INTERNAL, - + .n_errors = ARRAY_LEN(l2learn_error_strings), .error_strings = l2learn_error_strings, @@ -414,28 +429,30 @@ VLIB_REGISTER_NODE (l2learn_node,static) = { [L2LEARN_NEXT_L2FWD] = "l2-fwd", }, }; +/* *INDENT-ON* */ VLIB_NODE_FUNCTION_MULTIARCH (l2learn_node, l2learn_node_fn) - -clib_error_t *l2learn_init (vlib_main_t *vm) + clib_error_t *l2learn_init (vlib_main_t * vm) { - l2learn_main_t * mp = &l2learn_main; - + l2learn_main_t *mp = &l2learn_main; + mp->vlib_main = vm; - mp->vnet_main = vnet_get_main(); + mp->vnet_main = vnet_get_main (); - // Initialize the feature next-node indexes - feat_bitmap_init_next_nodes(vm, - l2learn_node.index, - L2INPUT_N_FEAT, - l2input_get_feat_names(), - mp->feat_next_node_index); + /* Initialize the feature next-node indexes */ + feat_bitmap_init_next_nodes (vm, + l2learn_node.index, + L2INPUT_N_FEAT, + l2input_get_feat_names (), + mp->feat_next_node_index); /* init the hash table ptr */ - mp->mac_table = get_mac_table(); + mp->mac_table = get_mac_table (); - // Set the default number of dynamically learned macs to the number - // of buckets. + /* + * Set the default number of dynamically learned macs to the number + * of buckets. + */ mp->global_learn_limit = L2FIB_NUM_BUCKETS * 16; return 0; @@ -444,43 +461,47 @@ clib_error_t *l2learn_init (vlib_main_t *vm) VLIB_INIT_FUNCTION (l2learn_init); -// set subinterface learn enable/disable -// The CLI format is: -// set interface l2 learn [disable] +/** + * set subinterface learn enable/disable + * The CLI format is: + * set interface l2 learn [disable] + */ static clib_error_t * int_learn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) + unformat_input_t * input, vlib_cli_command_t * cmd) { - vnet_main_t * vnm = vnet_get_main(); - clib_error_t * error = 0; + vnet_main_t *vnm = vnet_get_main (); + clib_error_t *error = 0; u32 sw_if_index; u32 enable; - if (! unformat_user (input, unformat_vnet_sw_interface, vnm, &sw_if_index)) + if (!unformat_user (input, unformat_vnet_sw_interface, vnm, &sw_if_index)) { error = clib_error_return (0, "unknown interface `%U'", - format_unformat_error, input); + format_unformat_error, input); goto done; } enable = 1; - if (unformat (input, "disable")) { - enable = 0; - } + if (unformat (input, "disable")) + { + enable = 0; + } - // set the interface flag - l2input_intf_bitmap_enable(sw_if_index, L2INPUT_FEAT_LEARN, enable); + /* set the interface flag */ + l2input_intf_bitmap_enable (sw_if_index, L2INPUT_FEAT_LEARN, enable); - done: +done: return error; } +/* *INDENT-OFF* */ VLIB_CLI_COMMAND (int_learn_cli, static) = { .path = "set interface l2 learn", .short_help = "set interface l2 learn [disable]", .function = int_learn, }; +/* *INDENT-ON* */ static clib_error_t * @@ -491,11 +512,11 @@ l2learn_config (vlib_main_t * vm, unformat_input_t * input) while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) { if (unformat (input, "limit %d", &mp->global_learn_limit)) - ; + ; else - return clib_error_return (0, "unknown input `%U'", - format_unformat_error, input); + return clib_error_return (0, "unknown input `%U'", + format_unformat_error, input); } return 0; @@ -503,3 +524,11 @@ l2learn_config (vlib_main_t * vm, unformat_input_t * input) VLIB_CONFIG_FUNCTION (l2learn_config, "l2learn"); + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/vnet/vnet/l2/l2_learn.h b/vnet/vnet/l2/l2_learn.h index 25674858fc9..5b5eff74df8 100644 --- a/vnet/vnet/l2/l2_learn.h +++ b/vnet/vnet/l2/l2_learn.h @@ -22,26 +22,35 @@ #include -typedef struct { +typedef struct +{ - // Hash table - BVT(clib_bihash) *mac_table; + /* Hash table */ + BVT (clib_bihash) * mac_table; - // number of dynamically learned mac entries + /* number of dynamically learned mac entries */ u32 global_learn_count; - // maximum number of dynamically learned mac entries + /* maximum number of dynamically learned mac entries */ u32 global_learn_limit; - // Next nodes for each feature + /* Next nodes for each feature */ u32 feat_next_node_index[32]; /* convenience variables */ - vlib_main_t * vlib_main; - vnet_main_t * vnet_main; + vlib_main_t *vlib_main; + vnet_main_t *vnet_main; } l2learn_main_t; l2learn_main_t l2learn_main; #endif + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/vnet/vnet/l2/l2_output.c b/vnet/vnet/l2/l2_output.c index acca349475c..8bc43744d9f 100644 --- a/vnet/vnet/l2/l2_output.c +++ b/vnet/vnet/l2/l2_output.c @@ -27,59 +27,68 @@ #include -// Feature graph node names -static char * l2output_feat_names[] = { +/* Feature graph node names */ +static char *l2output_feat_names[] = { #define _(sym,name) name, foreach_l2output_feat #undef _ }; -char **l2output_get_feat_names(void) { +char ** +l2output_get_feat_names (void) +{ return l2output_feat_names; } l2output_main_t l2output_main; -typedef struct { - /* per-pkt trace data */ +typedef struct +{ + /* per-pkt trace data */ u8 src[6]; u8 dst[6]; u32 sw_if_index; } l2output_trace_t; /* packet trace format function */ -static u8 * format_l2output_trace (u8 * s, va_list * args) +static u8 * +format_l2output_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 *); - l2output_trace_t * t = va_arg (*args, l2output_trace_t *); - + l2output_trace_t *t = va_arg (*args, l2output_trace_t *); + s = format (s, "l2-output: sw_if_index %d dst %U src %U", t->sw_if_index, - format_ethernet_address, t->dst, - format_ethernet_address, t->src); + format_ethernet_address, t->dst, + format_ethernet_address, t->src); return s; } -static char * l2output_error_strings[] = { +static char *l2output_error_strings[] = { #define _(sym,string) string, foreach_l2output_error #undef _ }; -// Return 0 if split horizon check passes, otherwise return non-zero -// Packets should not be transmitted out an interface with the same -// split-horizon group as the input interface, except if the shg is 0 -// in which case the check always passes. +/** + * Return 0 if split horizon check passes, otherwise return non-zero + * Packets should not be transmitted out an interface with the same + * split-horizon group as the input interface, except if the shg is 0 + * in which case the check always passes. + */ static_always_inline u32 split_horizon_violation (u8 shg1, u8 shg2) { - if (PREDICT_TRUE (shg1 == 0)) { - return 0; - } else { - return shg1 == shg2; - } + if (PREDICT_TRUE (shg1 == 0)) + { + return 0; + } + else + { + return shg1 == shg2; + } } @@ -87,24 +96,23 @@ static vlib_node_registration_t l2output_node; static uword l2output_node_fn (vlib_main_t * vm, - vlib_node_runtime_t * node, - vlib_frame_t * frame) + vlib_node_runtime_t * node, vlib_frame_t * frame) { - u32 n_left_from, * from, * to_next; + u32 n_left_from, *from, *to_next; l2output_next_t next_index; - l2output_main_t * msm = &l2output_main; + l2output_main_t *msm = &l2output_main; vlib_node_t *n = vlib_get_node (vm, l2output_node.index); u32 node_counter_base_index = n->error_heap_index; - vlib_error_main_t * em = &vm->error_main; + vlib_error_main_t *em = &vm->error_main; u32 cached_sw_if_index; u32 cached_next_index; /* Invalidate cache */ cached_sw_if_index = ~0; - cached_next_index = ~0; /* warning be gone */ + cached_next_index = ~0; /* warning be gone */ from = vlib_frame_vector_args (frame); - n_left_from = frame->n_vectors; /* number of packets to process */ + n_left_from = frame->n_vectors; /* number of packets to process */ next_index = node->cached_next_index; while (n_left_from > 0) @@ -112,44 +120,48 @@ l2output_node_fn (vlib_main_t * vm, u32 n_left_to_next; /* get space to enqueue frame to graph node "next_index" */ - vlib_get_next_frame (vm, node, next_index, - to_next, n_left_to_next); + vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next); while (n_left_from >= 6 && n_left_to_next >= 2) { - u32 bi0, bi1; - vlib_buffer_t * b0, * b1; - u32 next0, next1; - u32 sw_if_index0, sw_if_index1; - ethernet_header_t * h0, * h1; - l2_output_config_t * config0, * config1; - u32 feature_bitmap0, feature_bitmap1; - + u32 bi0, bi1; + vlib_buffer_t *b0, *b1; + u32 next0, next1; + u32 sw_if_index0, sw_if_index1; + ethernet_header_t *h0, *h1; + l2_output_config_t *config0, *config1; + u32 feature_bitmap0, feature_bitmap1; + /* Prefetch next iteration. */ { - vlib_buffer_t * p2, * p3, * p4 , * p5; - u32 sw_if_index2, sw_if_index3; - + vlib_buffer_t *p2, *p3, *p4, *p5; + u32 sw_if_index2, sw_if_index3; + p2 = vlib_get_buffer (vm, from[2]); p3 = vlib_get_buffer (vm, from[3]); p4 = vlib_get_buffer (vm, from[4]); p5 = vlib_get_buffer (vm, from[5]); - - // Prefetch the buffer header for the N+2 loop iteration + + /* Prefetch the buffer header for the N+2 loop iteration */ vlib_prefetch_buffer_header (p4, LOAD); vlib_prefetch_buffer_header (p5, LOAD); - // Note: no need to prefetch packet data. This node doesn't reference it. - - // Prefetch the input config for the N+1 loop iteration - // This depends on the buffer header above - sw_if_index2 = vnet_buffer(p2)->sw_if_index[VLIB_TX]; - sw_if_index3 = vnet_buffer(p3)->sw_if_index[VLIB_TX]; - CLIB_PREFETCH (&msm->configs[sw_if_index2], CLIB_CACHE_LINE_BYTES, LOAD); - CLIB_PREFETCH (&msm->configs[sw_if_index3], CLIB_CACHE_LINE_BYTES, LOAD); + /* + * Note: no need to prefetch packet data. + * This node doesn't reference it. + * + * Prefetch the input config for the N+1 loop iteration + * This depends on the buffer header above + */ + sw_if_index2 = vnet_buffer (p2)->sw_if_index[VLIB_TX]; + sw_if_index3 = vnet_buffer (p3)->sw_if_index[VLIB_TX]; + CLIB_PREFETCH (&msm->configs[sw_if_index2], CLIB_CACHE_LINE_BYTES, + LOAD); + CLIB_PREFETCH (&msm->configs[sw_if_index3], CLIB_CACHE_LINE_BYTES, + LOAD); } - /* speculatively enqueue b0 and b1 to the current next frame */ - /* bi is "buffer index", b is pointer to the buffer */ + /* speculatively enqueue b0 and b1 to the current next frame */ + /* bi is "buffer index", b is pointer to the buffer */ to_next[0] = bi0 = from[0]; to_next[1] = bi1 = from[1]; from += 2; @@ -159,140 +171,154 @@ l2output_node_fn (vlib_main_t * vm, b0 = vlib_get_buffer (vm, bi0); b1 = vlib_get_buffer (vm, bi1); - - /* TX interface handles */ - sw_if_index0 = vnet_buffer(b0)->sw_if_index[VLIB_TX]; - sw_if_index1 = vnet_buffer(b1)->sw_if_index[VLIB_TX]; - - if (PREDICT_FALSE((node->flags & VLIB_NODE_FLAG_TRACE))) - { - h0 = vlib_buffer_get_current (b0); - h1 = vlib_buffer_get_current (b1); - if (b0->flags & VLIB_BUFFER_IS_TRACED) - { - l2output_trace_t *t = - vlib_add_trace (vm, node, b0, sizeof (*t)); - t->sw_if_index = sw_if_index0; - clib_memcpy(t->src, h0->src_address, 6); - clib_memcpy(t->dst, h0->dst_address, 6); - } - if (b1->flags & VLIB_BUFFER_IS_TRACED) - { - l2output_trace_t *t = - vlib_add_trace (vm, node, b1, sizeof (*t)); - t->sw_if_index = sw_if_index1; - clib_memcpy(t->src, h1->src_address, 6); - clib_memcpy(t->dst, h1->dst_address, 6); - } - } - - em->counters[node_counter_base_index + L2OUTPUT_ERROR_L2OUTPUT] += 2; - - // Get config for the output interface - config0 = vec_elt_at_index(msm->configs, sw_if_index0); - config1 = vec_elt_at_index(msm->configs, sw_if_index1); - - // Get features from the config - // TODO: mask out any non-applicable features - feature_bitmap0 = config0->feature_bitmap; - feature_bitmap1 = config1->feature_bitmap; - - // Determine next node - l2_output_dispatch (msm->vlib_main, - msm->vnet_main, - node, - l2output_node.index, - &cached_sw_if_index, - &cached_next_index, - &msm->next_nodes, - b0, - sw_if_index0, - feature_bitmap0, - &next0); - - l2_output_dispatch (msm->vlib_main, - msm->vnet_main, - node, - l2output_node.index, - &cached_sw_if_index, - &cached_next_index, - &msm->next_nodes, - b1, - sw_if_index1, - feature_bitmap1, - &next1); - - // Perform output vlan tag rewrite and the pre-vtr EFP filter check. - // The EFP Filter only needs to be run if there is an output VTR - // configured. The flag for the post-vtr EFP Filter node is used - // to trigger the pre-vtr check as well. - - if (PREDICT_FALSE (config0->output_vtr.push_and_pop_bytes)) { - // Perform pre-vtr EFP filter check if configured - u32 failed1 = (feature_bitmap0 & L2OUTPUT_FEAT_EFP_FILTER) && - (l2_efp_filter_process(b0, &(config0->input_vtr))); - u32 failed2 = l2_vtr_process(b0, &(config0->output_vtr)); - - if (PREDICT_FALSE (failed1 | failed2)) { - next0 = L2OUTPUT_NEXT_DROP; - if (failed2) { - b0->error = node->errors[L2OUTPUT_ERROR_VTR_DROP]; - } - if (failed1) { - b0->error = node->errors[L2OUTPUT_ERROR_EFP_DROP]; - } - } + + /* TX interface handles */ + sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_TX]; + sw_if_index1 = vnet_buffer (b1)->sw_if_index[VLIB_TX]; + + if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE))) + { + h0 = vlib_buffer_get_current (b0); + h1 = vlib_buffer_get_current (b1); + if (b0->flags & VLIB_BUFFER_IS_TRACED) + { + l2output_trace_t *t = + vlib_add_trace (vm, node, b0, sizeof (*t)); + t->sw_if_index = sw_if_index0; + clib_memcpy (t->src, h0->src_address, 6); + clib_memcpy (t->dst, h0->dst_address, 6); + } + if (b1->flags & VLIB_BUFFER_IS_TRACED) + { + l2output_trace_t *t = + vlib_add_trace (vm, node, b1, sizeof (*t)); + t->sw_if_index = sw_if_index1; + clib_memcpy (t->src, h1->src_address, 6); + clib_memcpy (t->dst, h1->dst_address, 6); + } } - if (PREDICT_FALSE (config1->output_vtr.push_and_pop_bytes)) { - // Perform pre-vtr EFP filter check if configured - u32 failed1 = (feature_bitmap1 & L2OUTPUT_FEAT_EFP_FILTER) && - (l2_efp_filter_process(b1, &(config1->input_vtr))); - u32 failed2 = l2_vtr_process(b1, &(config1->output_vtr)); - - if (PREDICT_FALSE (failed1 | failed2)) { - next1 = L2OUTPUT_NEXT_DROP; - if (failed2) { - b1->error = node->errors[L2OUTPUT_ERROR_VTR_DROP]; - } - if (failed1) { - b1->error = node->errors[L2OUTPUT_ERROR_EFP_DROP]; - } - } + em->counters[node_counter_base_index + L2OUTPUT_ERROR_L2OUTPUT] += + 2; + + /* Get config for the output interface */ + config0 = vec_elt_at_index (msm->configs, sw_if_index0); + config1 = vec_elt_at_index (msm->configs, sw_if_index1); + + /* + * Get features from the config + * TODO: mask out any non-applicable features + */ + feature_bitmap0 = config0->feature_bitmap; + feature_bitmap1 = config1->feature_bitmap; + + /* Determine next node */ + l2_output_dispatch (msm->vlib_main, + msm->vnet_main, + node, + l2output_node.index, + &cached_sw_if_index, + &cached_next_index, + &msm->next_nodes, + b0, sw_if_index0, feature_bitmap0, &next0); + + l2_output_dispatch (msm->vlib_main, + msm->vnet_main, + node, + l2output_node.index, + &cached_sw_if_index, + &cached_next_index, + &msm->next_nodes, + b1, sw_if_index1, feature_bitmap1, &next1); + + /* + * Perform output vlan tag rewrite and the pre-vtr EFP filter check. + * The EFP Filter only needs to be run if there is an output VTR + * configured. The flag for the post-vtr EFP Filter node is used + * to trigger the pre-vtr check as well. + */ + + if (PREDICT_FALSE (config0->output_vtr.push_and_pop_bytes)) + { + /* Perform pre-vtr EFP filter check if configured */ + u32 failed1 = (feature_bitmap0 & L2OUTPUT_FEAT_EFP_FILTER) && + (l2_efp_filter_process (b0, &(config0->input_vtr))); + u32 failed2 = l2_vtr_process (b0, &(config0->output_vtr)); + + if (PREDICT_FALSE (failed1 | failed2)) + { + next0 = L2OUTPUT_NEXT_DROP; + if (failed2) + { + b0->error = node->errors[L2OUTPUT_ERROR_VTR_DROP]; + } + if (failed1) + { + b0->error = node->errors[L2OUTPUT_ERROR_EFP_DROP]; + } + } } - - // Perform the split horizon check - // The check can only fail for non-zero shg's - if (PREDICT_FALSE (config0->shg + config1->shg)) { - // one of the checks might fail, check both - if (split_horizon_violation (config0->shg, vnet_buffer(b0)->l2.shg)) { - next0 = L2OUTPUT_NEXT_DROP; - b0->error = node->errors[L2OUTPUT_ERROR_SHG_DROP]; - } - if (split_horizon_violation (config1->shg, vnet_buffer(b1)->l2.shg)) { - next1 = L2OUTPUT_NEXT_DROP; - b1->error = node->errors[L2OUTPUT_ERROR_SHG_DROP]; - } + + if (PREDICT_FALSE (config1->output_vtr.push_and_pop_bytes)) + { + /* Perform pre-vtr EFP filter check if configured */ + u32 failed1 = (feature_bitmap1 & L2OUTPUT_FEAT_EFP_FILTER) && + (l2_efp_filter_process (b1, &(config1->input_vtr))); + u32 failed2 = l2_vtr_process (b1, &(config1->output_vtr)); + + if (PREDICT_FALSE (failed1 | failed2)) + { + next1 = L2OUTPUT_NEXT_DROP; + if (failed2) + { + b1->error = node->errors[L2OUTPUT_ERROR_VTR_DROP]; + } + if (failed1) + { + b1->error = node->errors[L2OUTPUT_ERROR_EFP_DROP]; + } + } } - /* verify speculative enqueues, maybe switch current next frame */ - /* if next0==next1==next_index then nothing special needs to be done */ - vlib_validate_buffer_enqueue_x2 (vm, node, next_index, - to_next, n_left_to_next, - bi0, bi1, next0, next1); - } - + /* + * Perform the split horizon check + * The check can only fail for non-zero shg's + */ + if (PREDICT_FALSE (config0->shg + config1->shg)) + { + /* one of the checks might fail, check both */ + if (split_horizon_violation + (config0->shg, vnet_buffer (b0)->l2.shg)) + { + next0 = L2OUTPUT_NEXT_DROP; + b0->error = node->errors[L2OUTPUT_ERROR_SHG_DROP]; + } + if (split_horizon_violation + (config1->shg, vnet_buffer (b1)->l2.shg)) + { + next1 = L2OUTPUT_NEXT_DROP; + b1->error = node->errors[L2OUTPUT_ERROR_SHG_DROP]; + } + } + + /* verify speculative enqueues, maybe switch current next frame */ + /* if next0==next1==next_index then nothing special needs to be done */ + vlib_validate_buffer_enqueue_x2 (vm, node, next_index, + to_next, n_left_to_next, + bi0, bi1, next0, next1); + } + while (n_left_from > 0 && n_left_to_next > 0) { - u32 bi0; - vlib_buffer_t * b0; - u32 next0; - u32 sw_if_index0; - ethernet_header_t * h0; - l2_output_config_t *config0; - u32 feature_bitmap0; - - /* speculatively enqueue b0 to the current next frame */ + u32 bi0; + vlib_buffer_t *b0; + u32 next0; + u32 sw_if_index0; + ethernet_header_t *h0; + l2_output_config_t *config0; + u32 feature_bitmap0; + + /* speculatively enqueue b0 to the current next frame */ bi0 = from[0]; to_next[0] = bi0; from += 1; @@ -302,69 +328,79 @@ l2output_node_fn (vlib_main_t * vm, b0 = vlib_get_buffer (vm, bi0); - sw_if_index0 = vnet_buffer(b0)->sw_if_index[VLIB_TX]; - - if (PREDICT_FALSE((node->flags & VLIB_NODE_FLAG_TRACE) - && (b0->flags & VLIB_BUFFER_IS_TRACED))) { - l2output_trace_t *t = - vlib_add_trace (vm, node, b0, sizeof (*t)); - t->sw_if_index = sw_if_index0; - h0 = vlib_buffer_get_current (b0); - clib_memcpy(t->src, h0->src_address, 6); - clib_memcpy(t->dst, h0->dst_address, 6); - } - - em->counters[node_counter_base_index + L2OUTPUT_ERROR_L2OUTPUT] += 1; - - // Get config for the output interface - config0 = vec_elt_at_index(msm->configs, sw_if_index0); - - // Get features from the config - // TODO: mask out any non-applicable features - feature_bitmap0 = config0->feature_bitmap; - - // Determine next node - l2_output_dispatch (msm->vlib_main, - msm->vnet_main, - node, - l2output_node.index, - &cached_sw_if_index, - &cached_next_index, - &msm->next_nodes, - b0, - sw_if_index0, - feature_bitmap0, - &next0); - - // Perform output vlan tag rewrite and the pre-vtr EFP filter check. - // The EFP Filter only needs to be run if there is an output VTR - // configured. The flag for the post-vtr EFP Filter node is used - // to trigger the pre-vtr check as well. - - if (config0->output_vtr.push_and_pop_bytes) { - // Perform pre-vtr EFP filter check if configured - u32 failed1 = (feature_bitmap0 & L2OUTPUT_FEAT_EFP_FILTER) && - (l2_efp_filter_process(b0, &(config0->input_vtr))); - u32 failed2 = l2_vtr_process(b0, &(config0->output_vtr)); - - if (PREDICT_FALSE (failed1 | failed2)) { - next0 = L2OUTPUT_NEXT_DROP; - if (failed2) { - b0->error = node->errors[L2OUTPUT_ERROR_VTR_DROP]; - } - if (failed1) { - b0->error = node->errors[L2OUTPUT_ERROR_EFP_DROP]; - } - } - } - - // Perform the split horizon check - if (PREDICT_FALSE (split_horizon_violation (config0->shg, vnet_buffer(b0)->l2.shg))) { - next0 = L2OUTPUT_NEXT_DROP; - b0->error = node->errors[L2OUTPUT_ERROR_SHG_DROP]; - } - - /* verify speculative enqueue, maybe switch current next frame */ + sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_TX]; + + if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE) + && (b0->flags & VLIB_BUFFER_IS_TRACED))) + { + l2output_trace_t *t = + vlib_add_trace (vm, node, b0, sizeof (*t)); + t->sw_if_index = sw_if_index0; + h0 = vlib_buffer_get_current (b0); + clib_memcpy (t->src, h0->src_address, 6); + clib_memcpy (t->dst, h0->dst_address, 6); + } + + em->counters[node_counter_base_index + L2OUTPUT_ERROR_L2OUTPUT] += + 1; + + /* Get config for the output interface */ + config0 = vec_elt_at_index (msm->configs, sw_if_index0); + + /* + * Get features from the config + * TODO: mask out any non-applicable features + */ + feature_bitmap0 = config0->feature_bitmap; + + /* Determine next node */ + l2_output_dispatch (msm->vlib_main, + msm->vnet_main, + node, + l2output_node.index, + &cached_sw_if_index, + &cached_next_index, + &msm->next_nodes, + b0, sw_if_index0, feature_bitmap0, &next0); + + /* + * Perform output vlan tag rewrite and the pre-vtr EFP filter check. + * The EFP Filter only needs to be run if there is an output VTR + * configured. The flag for the post-vtr EFP Filter node is used + * to trigger the pre-vtr check as well. + */ + + if (config0->output_vtr.push_and_pop_bytes) + { + /* Perform pre-vtr EFP filter check if configured */ + u32 failed1 = (feature_bitmap0 & L2OUTPUT_FEAT_EFP_FILTER) && + (l2_efp_filter_process (b0, &(config0->input_vtr))); + u32 failed2 = l2_vtr_process (b0, &(config0->output_vtr)); + + if (PREDICT_FALSE (failed1 | failed2)) + { + next0 = L2OUTPUT_NEXT_DROP; + if (failed2) + { + b0->error = node->errors[L2OUTPUT_ERROR_VTR_DROP]; + } + if (failed1) + { + b0->error = node->errors[L2OUTPUT_ERROR_EFP_DROP]; + } + } + } + + /* Perform the split horizon check */ + if (PREDICT_FALSE + (split_horizon_violation + (config0->shg, vnet_buffer (b0)->l2.shg))) + { + next0 = L2OUTPUT_NEXT_DROP; + b0->error = node->errors[L2OUTPUT_ERROR_SHG_DROP]; + } + + /* verify speculative enqueue, maybe switch current next frame */ vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next, n_left_to_next, bi0, next0); @@ -377,13 +413,14 @@ l2output_node_fn (vlib_main_t * vm, } +/* *INDENT-OFF* */ VLIB_REGISTER_NODE (l2output_node,static) = { .function = l2output_node_fn, .name = "l2-output", .vector_size = sizeof (u32), .format_trace = format_l2output_trace, .type = VLIB_NODE_TYPE_INTERNAL, - + .n_errors = ARRAY_LEN(l2output_error_strings), .error_strings = l2output_error_strings, @@ -395,61 +432,63 @@ VLIB_REGISTER_NODE (l2output_node,static) = { [L2OUTPUT_NEXT_DEL_TUNNEL] = "l2-output-del-tunnel", }, }; +/* *INDENT-ON* */ #define foreach_l2output_del_tunnel_error \ _(DROP, "L2 output to deleted tunnel") -static char * l2output_del_tunnel_error_strings[] = { +static char *l2output_del_tunnel_error_strings[] = { #define _(sym,string) string, foreach_l2output_del_tunnel_error #undef _ }; -typedef enum { +typedef enum +{ #define _(sym,str) L2OUTPUT_DEL_TUNNEL_ERROR_##sym, foreach_l2output_del_tunnel_error #undef _ - L2OUTPUT_DEL_TUNNEL_N_ERROR, + L2OUTPUT_DEL_TUNNEL_N_ERROR, } l2output_del_tunnel_error_t; -// Output node for tunnels which was in L2 BD's but were deleted. -// On deletion of any tunnel which was on a L2 BD, its entry in -// l2_output_main table next_nodes.output_node_index_vec[sw_if_index] -// MUST be set to the value of L2OUTPUT_NEXT_DEL_TUNNEL. Thus, if there -// are stale entries in the L2FIB for this tunnel sw_if_index, l2-output -// will send packets for this sw_if_index to the l2-output-tunnel-del -// node which just setup the proper drop reason before sending packets -// to the error-drop node to drop the packet. Then, stale L2FIB entries -// for delted tunnels won't cause possible packet or memory corrpution. +/** + * Output node for tunnels which was in L2 BD's but were deleted. + * On deletion of any tunnel which was on a L2 BD, its entry in + * l2_output_main table next_nodes.output_node_index_vec[sw_if_index] + * MUST be set to the value of L2OUTPUT_NEXT_DEL_TUNNEL. Thus, if there + * are stale entries in the L2FIB for this tunnel sw_if_index, l2-output + * will send packets for this sw_if_index to the l2-output-tunnel-del + * node which just setup the proper drop reason before sending packets + * to the error-drop node to drop the packet. Then, stale L2FIB entries + * for delted tunnels won't cause possible packet or memory corrpution. + */ static vlib_node_registration_t l2output_del_tunnel_node; static uword l2output_del_tunnel_node_fn (vlib_main_t * vm, - vlib_node_runtime_t * node, - vlib_frame_t * frame) + vlib_node_runtime_t * node, vlib_frame_t * frame) { - u32 n_left_from, * from, * to_next; + u32 n_left_from, *from, *to_next; l2output_next_t next_index = 0; from = vlib_frame_vector_args (frame); - n_left_from = frame->n_vectors; // number of packets to process + n_left_from = frame->n_vectors; /* number of packets to process */ while (n_left_from > 0) { u32 n_left_to_next; - // get space to enqueue frame to graph node "next_index" - vlib_get_next_frame (vm, node, next_index, - to_next, n_left_to_next); + /* get space to enqueue frame to graph node "next_index" */ + vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next); while (n_left_from >= 4 && n_left_to_next >= 2) { - u32 bi0, bi1; - vlib_buffer_t * b0, * b1; + u32 bi0, bi1; + vlib_buffer_t *b0, *b1; - to_next[0] = bi0 = from[0]; + to_next[0] = bi0 = from[0]; to_next[1] = bi1 = from[1]; from += 2; to_next += 2; @@ -457,23 +496,23 @@ l2output_del_tunnel_node_fn (vlib_main_t * vm, n_left_to_next -= 2; b0 = vlib_get_buffer (vm, bi0); b1 = vlib_get_buffer (vm, bi1); - b0->error = node->errors[L2OUTPUT_DEL_TUNNEL_ERROR_DROP]; - b1->error = node->errors[L2OUTPUT_DEL_TUNNEL_ERROR_DROP]; - } - + b0->error = node->errors[L2OUTPUT_DEL_TUNNEL_ERROR_DROP]; + b1->error = node->errors[L2OUTPUT_DEL_TUNNEL_ERROR_DROP]; + } + while (n_left_from > 0 && n_left_to_next > 0) { - u32 bi0; - vlib_buffer_t * b0; + u32 bi0; + vlib_buffer_t *b0; - bi0 = from[0]; + 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); - b0->error = node->errors[L2OUTPUT_DEL_TUNNEL_ERROR_DROP]; + b0->error = node->errors[L2OUTPUT_DEL_TUNNEL_ERROR_DROP]; } vlib_put_next_frame (vm, node, next_index, n_left_to_next); @@ -482,12 +521,13 @@ l2output_del_tunnel_node_fn (vlib_main_t * vm, return frame->n_vectors; } +/* *INDENT-OFF* */ VLIB_REGISTER_NODE (l2output_del_tunnel_node,static) = { .function = l2output_del_tunnel_node_fn, .name = "l2-output-del-tunnel", .vector_size = sizeof (u32), .type = VLIB_NODE_TYPE_INTERNAL, - + .n_errors = ARRAY_LEN(l2output_del_tunnel_error_strings), .error_strings = l2output_del_tunnel_error_strings, @@ -498,48 +538,47 @@ VLIB_REGISTER_NODE (l2output_del_tunnel_node,static) = { [0] = "error-drop", }, }; +/* *INDENT-ON* */ VLIB_NODE_FUNCTION_MULTIARCH (l2output_node, l2output_node_fn) - -clib_error_t *l2output_init (vlib_main_t *vm) + clib_error_t *l2output_init (vlib_main_t * vm) { - l2output_main_t * mp = &l2output_main; - + l2output_main_t *mp = &l2output_main; + mp->vlib_main = vm; - mp->vnet_main = vnet_get_main(); + mp->vnet_main = vnet_get_main (); - // Create the config vector - vec_validate(mp->configs, 100); - // Until we hook up the CLI config, just create 100 sw interface entries and zero them + /* Create the config vector */ + vec_validate (mp->configs, 100); + /* Until we hook up the CLI config, just create 100 sw interface entries and zero them */ - // Initialize the feature next-node indexes - feat_bitmap_init_next_nodes(vm, - l2output_node.index, - L2OUTPUT_N_FEAT, - l2output_get_feat_names(), - mp->next_nodes.feat_next_node_index); + /* Initialize the feature next-node indexes */ + feat_bitmap_init_next_nodes (vm, + l2output_node.index, + L2OUTPUT_N_FEAT, + l2output_get_feat_names (), + mp->next_nodes.feat_next_node_index); - // Initialize the output node mapping table - l2output_init_output_node_vec(&mp->next_nodes.output_node_index_vec); + /* Initialize the output node mapping table */ + l2output_init_output_node_vec (&mp->next_nodes.output_node_index_vec); return 0; } VLIB_INIT_FUNCTION (l2output_init); -typedef struct { +typedef struct +{ u32 node_index; u32 sw_if_index; } output_node_mapping_rpc_args_t; #if DPDK > 0 -static void output_node_rpc_callback -( output_node_mapping_rpc_args_t * a); +static void output_node_rpc_callback (output_node_mapping_rpc_args_t * a); -static void output_node_mapping_send_rpc -(u32 node_index, - u32 sw_if_index) +static void +output_node_mapping_send_rpc (u32 node_index, u32 sw_if_index) { output_node_mapping_rpc_args_t args; void vl_api_rpc_call_main_thread (void *fp, u8 * data, u32 data_length); @@ -547,95 +586,104 @@ static void output_node_mapping_send_rpc args.node_index = node_index; args.sw_if_index = sw_if_index; - vl_api_rpc_call_main_thread (output_node_rpc_callback, - (u8 *) &args, sizeof (args)); + vl_api_rpc_call_main_thread (output_node_rpc_callback, + (u8 *) & args, sizeof (args)); } #endif -// Create a mapping in the next node mapping table 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) { +/** Create a mapping in the next node mapping table 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) +{ - u32 next; // index of next graph node + u32 next; /* index of next graph node */ vnet_hw_interface_t *hw0; - u32 *node; + u32 *node; hw0 = vnet_get_sup_hw_interface (vnet_main, sw_if_index); #if DPDK > 0 - uword cpu_number; + uword cpu_number; - cpu_number = os_get_cpu_number(); + cpu_number = os_get_cpu_number (); if (cpu_number) { u32 oldflags; - oldflags = __sync_fetch_and_or(&hw0->flags, - VNET_HW_INTERFACE_FLAG_L2OUTPUT_MAPPED); + oldflags = __sync_fetch_and_or (&hw0->flags, + VNET_HW_INTERFACE_FLAG_L2OUTPUT_MAPPED); - if ((oldflags & VNET_HW_INTERFACE_FLAG_L2OUTPUT_MAPPED) ) - return L2OUTPUT_NEXT_DROP; + if ((oldflags & VNET_HW_INTERFACE_FLAG_L2OUTPUT_MAPPED)) + return L2OUTPUT_NEXT_DROP; output_node_mapping_send_rpc (node_index, sw_if_index); - return L2OUTPUT_NEXT_DROP; + return L2OUTPUT_NEXT_DROP; } #endif - // dynamically create graph node arc - next = vlib_node_add_next (vlib_main, - node_index, - hw0->output_node_index); + /* dynamically create graph node arc */ + next = vlib_node_add_next (vlib_main, node_index, hw0->output_node_index); - // Initialize vector with the mapping + /* Initialize vector with the mapping */ - node = vec_elt_at_index(output_node_index_vec, sw_if_index); + node = vec_elt_at_index (output_node_index_vec, sw_if_index); *node = next; - + return next; } #if DPDK > 0 -void output_node_rpc_callback (output_node_mapping_rpc_args_t *a) +void +output_node_rpc_callback (output_node_mapping_rpc_args_t * a) { - vlib_main_t * vm = vlib_get_main(); - vnet_main_t * vnm = vnet_get_main(); - l2output_main_t * mp = &l2output_main; + vlib_main_t *vm = vlib_get_main (); + vnet_main_t *vnm = vnet_get_main (); + l2output_main_t *mp = &l2output_main; - (void) l2output_create_output_node_mapping - (vm, vnm, a->node_index, mp->next_nodes.output_node_index_vec, + (void) l2output_create_output_node_mapping + (vm, vnm, a->node_index, mp->next_nodes.output_node_index_vec, a->sw_if_index); } #endif -// Get a pointer to the config for the given interface -l2_output_config_t * l2output_intf_config (u32 sw_if_index) +/* Get a pointer to the config for the given interface */ +l2_output_config_t * +l2output_intf_config (u32 sw_if_index) { - l2output_main_t * mp = &l2output_main; - - vec_validate(mp->configs, sw_if_index); - return vec_elt_at_index(mp->configs, sw_if_index); + l2output_main_t *mp = &l2output_main; + + vec_validate (mp->configs, sw_if_index); + return vec_elt_at_index (mp->configs, 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) +/** 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) { - l2output_main_t * mp = &l2output_main; + l2output_main_t *mp = &l2output_main; l2_output_config_t *config; - - vec_validate(mp->configs, sw_if_index); - config = vec_elt_at_index(mp->configs, sw_if_index); - - if (enable) { - config->feature_bitmap |= feature_bitmap; - } else { - config->feature_bitmap &= ~feature_bitmap; - } + + vec_validate (mp->configs, sw_if_index); + config = vec_elt_at_index (mp->configs, sw_if_index); + + if (enable) + { + config->feature_bitmap |= feature_bitmap; + } + else + { + config->feature_bitmap &= ~feature_bitmap; + } } + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/vnet/vnet/l2/l2_output.h b/vnet/vnet/l2/l2_output.h index b525a745ba7..e29d32d4222 100644 --- a/vnet/vnet/l2/l2_output.h +++ b/vnet/vnet/l2/l2_output.h @@ -24,59 +24,70 @@ #include -// The L2 output feature configuration, a per-interface struct -typedef struct { +/* 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 + /* + * 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; + /* some of these flags may get integrated into the feature bitmap */ + u8 fwd_enable; + u8 flood_enable; - // split horizon group - u8 shg; + /* 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. +/* + * 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 +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; + vlib_main_t *vlib_main; + vnet_main_t *vnet_main; } l2output_main_t; l2output_main_t l2output_main; -// L2 output features +/* L2 output features */ -// Mappings from feature ID to graph node name +/* Mappings from feature ID to graph node name */ #define foreach_l2output_feat \ _(SPAN, "feature-bitmap-drop") \ _(CFM, "feature-bitmap-drop") \ @@ -89,21 +100,23 @@ l2output_main_t l2output_main; _(LINESTATUS_DOWN, "feature-bitmap-drop") \ _(XCRW, "l2-xcrw") -// Feature bitmap positions -typedef enum { +/* Feature bitmap positions */ +typedef enum +{ #define _(sym,str) L2OUTPUT_FEAT_##sym##_BIT, foreach_l2output_feat #undef _ - L2OUTPUT_N_FEAT, + L2OUTPUT_N_FEAT, } l2output_feat_t; -// Feature bit masks -typedef enum { +/* Feature bit masks */ +typedef enum +{ #define _(sym,str) L2OUTPUT_FEAT_##sym = (1<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; + 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); +/** 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 +/** 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); + u32 feature_bitmap, u32 enable); #endif + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/vnet/vnet/l2/l2_output_acl.c b/vnet/vnet/l2/l2_output_acl.c index cf6be97412a..4597d42e945 100644 --- a/vnet/vnet/l2/l2_output_acl.c +++ b/vnet/vnet/l2/l2_output_acl.c @@ -32,19 +32,21 @@ #include -typedef struct { - // Next nodes for features and output interfaces +typedef struct +{ + /* Next nodes for features and output interfaces */ l2_output_next_nodes_st next_nodes; /* convenience variables */ - vlib_main_t * vlib_main; - vnet_main_t * vnet_main; + vlib_main_t *vlib_main; + vnet_main_t *vnet_main; } l2_outacl_main_t; -typedef struct { - /* per-pkt trace data */ +typedef struct +{ + /* per-pkt trace data */ u8 src[6]; u8 dst[6]; u32 next_index; @@ -52,16 +54,17 @@ typedef struct { } l2_outacl_trace_t; /* packet trace format function */ -static u8 * format_l2_outacl_trace (u8 * s, va_list * args) +static u8 * +format_l2_outacl_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 *); - l2_outacl_trace_t * t = va_arg (*args, l2_outacl_trace_t *); - + l2_outacl_trace_t *t = va_arg (*args, l2_outacl_trace_t *); + s = format (s, "l2-output-acl: sw_if_index %d dst %U src %U", t->sw_if_index, - format_ethernet_address, t->dst, - format_ethernet_address, t->src); + format_ethernet_address, t->dst, + format_ethernet_address, t->src); return s; } @@ -73,20 +76,22 @@ static vlib_node_registration_t l2_outacl_node; _(L2_OUTACL, "L2 output ACL packets") \ _(DROP, "L2 output drops") -typedef enum { +typedef enum +{ #define _(sym,str) L2_OUTACL_ERROR_##sym, foreach_l2_outacl_error #undef _ - L2_OUTACL_N_ERROR, + L2_OUTACL_N_ERROR, } l2_outacl_error_t; -static char * l2_outacl_error_strings[] = { +static char *l2_outacl_error_strings[] = { #define _(sym,string) string, foreach_l2_outacl_error #undef _ }; -typedef enum { +typedef enum +{ L2_OUTACL_NEXT_DROP, L2_OUTACL_N_NEXT, } l2_outacl_next_t; @@ -95,20 +100,19 @@ typedef enum { static uword l2_outacl_node_fn (vlib_main_t * vm, - vlib_node_runtime_t * node, - vlib_frame_t * frame) + vlib_node_runtime_t * node, vlib_frame_t * frame) { - u32 n_left_from, * from, * to_next; + u32 n_left_from, *from, *to_next; l2_outacl_next_t next_index; - l2_outacl_main_t * msm = &l2_outacl_main; + l2_outacl_main_t *msm = &l2_outacl_main; vlib_node_t *n = vlib_get_node (vm, l2_outacl_node.index); u32 node_counter_base_index = n->error_heap_index; - vlib_error_main_t * em = &vm->error_main; - u32 cached_sw_if_index = (u32)~0; - u32 cached_next_index = (u32)~0; + vlib_error_main_t *em = &vm->error_main; + u32 cached_sw_if_index = (u32) ~ 0; + u32 cached_next_index = (u32) ~ 0; from = vlib_frame_vector_args (frame); - n_left_from = frame->n_vectors; /* number of packets to process */ + n_left_from = frame->n_vectors; /* number of packets to process */ next_index = node->cached_next_index; while (n_left_from > 0) @@ -116,24 +120,23 @@ l2_outacl_node_fn (vlib_main_t * vm, u32 n_left_to_next; /* get space to enqueue frame to graph node "next_index" */ - vlib_get_next_frame (vm, node, next_index, - to_next, n_left_to_next); + vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next); while (0 && n_left_from >= 4 && n_left_to_next >= 2) { - u32 bi0, bi1; - vlib_buffer_t * b0, * b1; - u32 next0, next1; - u32 sw_if_index0, sw_if_index1; - ethernet_header_t * h0, * h1; - + u32 bi0, bi1; + vlib_buffer_t *b0, *b1; + u32 next0, next1; + u32 sw_if_index0, sw_if_index1; + ethernet_header_t *h0, *h1; + /* Prefetch next iteration. */ { - vlib_buffer_t * p2, * p3; - + vlib_buffer_t *p2, *p3; + p2 = vlib_get_buffer (vm, from[2]); p3 = vlib_get_buffer (vm, from[3]); - + vlib_prefetch_buffer_header (p2, LOAD); vlib_prefetch_buffer_header (p3, LOAD); @@ -141,8 +144,8 @@ l2_outacl_node_fn (vlib_main_t * vm, CLIB_PREFETCH (p3->data, CLIB_CACHE_LINE_BYTES, STORE); } - /* speculatively enqueue b0 and b1 to the current next frame */ - /* bi is "buffer index", b is pointer to the buffer */ + /* speculatively enqueue b0 and b1 to the current next frame */ + /* bi is "buffer index", b is pointer to the buffer */ to_next[0] = bi0 = from[0]; to_next[1] = bi1 = from[1]; from += 2; @@ -152,54 +155,55 @@ l2_outacl_node_fn (vlib_main_t * vm, b0 = vlib_get_buffer (vm, bi0); b1 = vlib_get_buffer (vm, bi1); - - /* TX interface handles */ - sw_if_index0 = vnet_buffer(b0)->sw_if_index[VLIB_TX]; - sw_if_index1 = vnet_buffer(b1)->sw_if_index[VLIB_TX]; - - if (PREDICT_FALSE((node->flags & VLIB_NODE_FLAG_TRACE))) - { - if (b0->flags & VLIB_BUFFER_IS_TRACED) - { - l2_outacl_trace_t *t = - vlib_add_trace (vm, node, b0, sizeof (*t)); - t->sw_if_index = sw_if_index0; - t->next_index = next0; - clib_memcpy(t->src, h0->src_address, 6); - clib_memcpy(t->dst, h0->dst_address, 6); - } - if (b1->flags & VLIB_BUFFER_IS_TRACED) - { - l2_outacl_trace_t *t = - vlib_add_trace (vm, node, b1, sizeof (*t)); - t->sw_if_index = sw_if_index1; - t->next_index = next1; - clib_memcpy(t->src, h1->src_address, 6); - clib_memcpy(t->dst, h1->dst_address, 6); - } - } - - em->counters[node_counter_base_index + L2_OUTACL_ERROR_L2_OUTACL] += 2; - - /* add core loop code here */ - - /* verify speculative enqueues, maybe switch current next frame */ - /* if next0==next1==next_index then nothing special needs to be done */ - vlib_validate_buffer_enqueue_x2 (vm, node, next_index, - to_next, n_left_to_next, - bi0, bi1, next0, next1); - } - + + /* TX interface handles */ + sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_TX]; + sw_if_index1 = vnet_buffer (b1)->sw_if_index[VLIB_TX]; + + if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE))) + { + if (b0->flags & VLIB_BUFFER_IS_TRACED) + { + l2_outacl_trace_t *t = + vlib_add_trace (vm, node, b0, sizeof (*t)); + t->sw_if_index = sw_if_index0; + t->next_index = next0; + clib_memcpy (t->src, h0->src_address, 6); + clib_memcpy (t->dst, h0->dst_address, 6); + } + if (b1->flags & VLIB_BUFFER_IS_TRACED) + { + l2_outacl_trace_t *t = + vlib_add_trace (vm, node, b1, sizeof (*t)); + t->sw_if_index = sw_if_index1; + t->next_index = next1; + clib_memcpy (t->src, h1->src_address, 6); + clib_memcpy (t->dst, h1->dst_address, 6); + } + } + + em->counters[node_counter_base_index + L2_OUTACL_ERROR_L2_OUTACL] += + 2; + + /* add core loop code here */ + + /* verify speculative enqueues, maybe switch current next frame */ + /* if next0==next1==next_index then nothing special needs to be done */ + vlib_validate_buffer_enqueue_x2 (vm, node, next_index, + to_next, n_left_to_next, + bi0, bi1, next0, next1); + } + while (n_left_from > 0 && n_left_to_next > 0) { - u32 bi0; - vlib_buffer_t * b0; - u32 next0; - u32 sw_if_index0; - ethernet_header_t * h0; - u32 feature_bitmap0; - - /* speculatively enqueue b0 to the current next frame */ + u32 bi0; + vlib_buffer_t *b0; + u32 next0; + u32 sw_if_index0; + ethernet_header_t *h0; + u32 feature_bitmap0; + + /* speculatively enqueue b0 to the current next frame */ bi0 = from[0]; to_next[0] = bi0; from += 1; @@ -208,42 +212,44 @@ l2_outacl_node_fn (vlib_main_t * vm, n_left_to_next -= 1; b0 = vlib_get_buffer (vm, bi0); - h0 = vlib_buffer_get_current (b0); - - sw_if_index0 = vnet_buffer(b0)->sw_if_index[VLIB_TX]; - - if (PREDICT_FALSE((node->flags & VLIB_NODE_FLAG_TRACE) - && (b0->flags & VLIB_BUFFER_IS_TRACED))) { - l2_outacl_trace_t *t = - vlib_add_trace (vm, node, b0, sizeof (*t)); - t->sw_if_index = sw_if_index0; - clib_memcpy(t->src, h0->src_address, 6); - clib_memcpy(t->dst, h0->dst_address, 6); - } - - em->counters[node_counter_base_index + L2_OUTACL_ERROR_L2_OUTACL] += 1; - - // L2_OUTACL code - // Dummy for now, just go to next feature node - - - // Remove ourself from the feature bitmap - feature_bitmap0 = vnet_buffer(b0)->l2.feature_bitmap & ~L2OUTPUT_FEAT_ACL; - - // Determine next node - l2_output_dispatch (msm->vlib_main, - msm->vnet_main, - node, - l2_outacl_node.index, - &cached_sw_if_index, - &cached_next_index, - &msm->next_nodes, - b0, - sw_if_index0, - feature_bitmap0, - &next0); - - /* verify speculative enqueue, maybe switch current next frame */ + h0 = vlib_buffer_get_current (b0); + + sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_TX]; + + if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE) + && (b0->flags & VLIB_BUFFER_IS_TRACED))) + { + l2_outacl_trace_t *t = + vlib_add_trace (vm, node, b0, sizeof (*t)); + t->sw_if_index = sw_if_index0; + clib_memcpy (t->src, h0->src_address, 6); + clib_memcpy (t->dst, h0->dst_address, 6); + } + + em->counters[node_counter_base_index + L2_OUTACL_ERROR_L2_OUTACL] += + 1; + + /* + * L2_OUTACL code + * Dummy for now, just go to next feature node + */ + + + /* Remove ourself from the feature bitmap */ + feature_bitmap0 = + vnet_buffer (b0)->l2.feature_bitmap & ~L2OUTPUT_FEAT_ACL; + + /* Determine next node */ + l2_output_dispatch (msm->vlib_main, + msm->vnet_main, + node, + l2_outacl_node.index, + &cached_sw_if_index, + &cached_next_index, + &msm->next_nodes, + b0, sw_if_index0, feature_bitmap0, &next0); + + /* verify speculative enqueue, maybe switch current next frame */ vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next, n_left_to_next, bi0, next0); @@ -256,13 +262,14 @@ l2_outacl_node_fn (vlib_main_t * vm, } +/* *INDENT-OFF* */ VLIB_REGISTER_NODE (l2_outacl_node,static) = { .function = l2_outacl_node_fn, .name = "l2-output-acl", .vector_size = sizeof (u32), .format_trace = format_l2_outacl_trace, .type = VLIB_NODE_TYPE_INTERNAL, - + .n_errors = ARRAY_LEN(l2_outacl_error_strings), .error_strings = l2_outacl_error_strings, @@ -273,25 +280,25 @@ VLIB_REGISTER_NODE (l2_outacl_node,static) = { [L2_OUTACL_NEXT_DROP] = "error-drop", }, }; +/* *INDENT-ON* */ VLIB_NODE_FUNCTION_MULTIARCH (l2_outacl_node, l2_outacl_node_fn) - -clib_error_t *l2_outacl_init (vlib_main_t *vm) + clib_error_t *l2_outacl_init (vlib_main_t * vm) { - l2_outacl_main_t * mp = &l2_outacl_main; - + l2_outacl_main_t *mp = &l2_outacl_main; + mp->vlib_main = vm; - mp->vnet_main = vnet_get_main(); + mp->vnet_main = vnet_get_main (); - // Initialize the feature next-node indexes - feat_bitmap_init_next_nodes(vm, - l2_outacl_node.index, - L2OUTPUT_N_FEAT, - l2output_get_feat_names(), - mp->next_nodes.feat_next_node_index); + /* Initialize the feature next-node indexes */ + feat_bitmap_init_next_nodes (vm, + l2_outacl_node.index, + L2OUTPUT_N_FEAT, + l2output_get_feat_names (), + mp->next_nodes.feat_next_node_index); - // Initialize the output node mapping table - l2output_init_output_node_vec(&mp->next_nodes.output_node_index_vec); + /* Initialize the output node mapping table */ + l2output_init_output_node_vec (&mp->next_nodes.output_node_index_vec); return 0; } @@ -299,42 +306,53 @@ clib_error_t *l2_outacl_init (vlib_main_t *vm) VLIB_INIT_FUNCTION (l2_outacl_init); #if 0 -/** @todo maybe someone will add output ACL's in the future */ -// set subinterface outacl enable/disable -// The CLI format is: -// set interface acl output [disable] +/** @todo maybe someone will add output ACL's in the future + * set subinterface outacl enable/disable + * The CLI format is: + * set interface acl output [disable] + */ static clib_error_t * int_l2_outacl (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) + unformat_input_t * input, vlib_cli_command_t * cmd) { - vnet_main_t * vnm = vnet_get_main(); - clib_error_t * error = 0; + vnet_main_t *vnm = vnet_get_main (); + clib_error_t *error = 0; u32 sw_if_index; u32 enable; - if (! unformat_user (input, unformat_vnet_sw_interface, vnm, &sw_if_index)) + if (!unformat_user (input, unformat_vnet_sw_interface, vnm, &sw_if_index)) { error = clib_error_return (0, "unknown interface `%U'", - format_unformat_error, input); + format_unformat_error, input); goto done; } enable = 1; - if (unformat (input, "disable")) { - enable = 0; - } + if (unformat (input, "disable")) + { + enable = 0; + } - // set the interface flag - l2output_intf_bitmap_enable(sw_if_index, L2OUTPUT_FEAT_ACL, enable); + /* set the interface flag */ + l2output_intf_bitmap_enable (sw_if_index, L2OUTPUT_FEAT_ACL, enable); - done: +done: return error; } +/* *INDENT-OFF* */ VLIB_CLI_COMMAND (int_l2_outacl_cli, static) = { .path = "set interface acl output", .short_help = "set interface acl output [disable]", .function = int_l2_outacl, }; +/* *INDENT-ON* */ #endif + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/vnet/vnet/l2/l2_patch.c b/vnet/vnet/l2/l2_patch.c index 0839142b8ad..cc35d32c824 100644 --- a/vnet/vnet/l2/l2_patch.c +++ b/vnet/vnet/l2/l2_patch.c @@ -18,7 +18,8 @@ #include #include -typedef struct { +typedef struct +{ u32 cached_next_index; u32 cached_rx_sw_if_index; @@ -27,24 +28,26 @@ typedef struct { u32 *tx_sw_if_index_by_rx_sw_if_index; /* convenience variables */ - vlib_main_t * vlib_main; - vnet_main_t * vnet_main; + vlib_main_t *vlib_main; + vnet_main_t *vnet_main; } l2_patch_main_t; -typedef struct { +typedef struct +{ u32 rx_sw_if_index; u32 tx_sw_if_index; } l2_patch_trace_t; /* packet trace format function */ -static u8 * format_l2_patch_trace (u8 * s, va_list * args) +static u8 * +format_l2_patch_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 *); - l2_patch_trace_t * t = va_arg (*args, l2_patch_trace_t *); - + l2_patch_trace_t *t = va_arg (*args, l2_patch_trace_t *); + s = format (s, "L2_PATCH: rx %d tx %d", t->rx_sw_if_index, - t->tx_sw_if_index); + t->tx_sw_if_index); return s; } @@ -56,35 +59,36 @@ static vlib_node_registration_t l2_patch_node; _(PATCHED, "L2 patch packets") \ _(DROPPED, "L2 patch misconfigured drops") -typedef enum { +typedef enum +{ #define _(sym,str) L2_PATCH_ERROR_##sym, foreach_l2_patch_error #undef _ - L2_PATCH_N_ERROR, + L2_PATCH_N_ERROR, } l2_patch_error_t; -static char * l2_patch_error_strings[] = { +static char *l2_patch_error_strings[] = { #define _(sym,string) string, foreach_l2_patch_error #undef _ }; -typedef enum { +typedef enum +{ L2_PATCH_NEXT_DROP, L2_PATCH_N_NEXT, } l2_patch_next_t; static uword l2_patch_node_fn (vlib_main_t * vm, - vlib_node_runtime_t * node, - vlib_frame_t * frame) + vlib_node_runtime_t * node, vlib_frame_t * frame) { - u32 n_left_from, * from, * to_next; + u32 n_left_from, *from, *to_next; l2_patch_next_t next_index; - l2_patch_main_t * l2pm = &l2_patch_main; + l2_patch_main_t *l2pm = &l2_patch_main; vlib_node_t *n = vlib_get_node (vm, l2_patch_node.index); u32 node_counter_base_index = n->error_heap_index; - vlib_error_main_t * em = &vm->error_main; + vlib_error_main_t *em = &vm->error_main; from = vlib_frame_vector_args (frame); n_left_from = frame->n_vectors; @@ -94,30 +98,29 @@ l2_patch_node_fn (vlib_main_t * vm, { u32 n_left_to_next; - vlib_get_next_frame (vm, node, next_index, - to_next, n_left_to_next); + vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next); while (n_left_from >= 4 && n_left_to_next >= 2) { - u32 bi0, bi1; - vlib_buffer_t * b0, * b1; - u32 next0, next1; - u32 sw_if_index0, sw_if_index1; - + u32 bi0, bi1; + vlib_buffer_t *b0, *b1; + u32 next0, next1; + u32 sw_if_index0, sw_if_index1; + /* Prefetch next iteration. */ { - vlib_buffer_t * p2, * p3; - + vlib_buffer_t *p2, *p3; + p2 = vlib_get_buffer (vm, from[2]); p3 = vlib_get_buffer (vm, from[3]); - + vlib_prefetch_buffer_header (p2, LOAD); vlib_prefetch_buffer_header (p3, LOAD); - /* So stupid / simple, we don't need to prefetch data */ + /* So stupid / simple, we don't need to prefetch data */ } - /* speculatively enqueue b0 and b1 to the current next frame */ + /* speculatively enqueue b0 and b1 to the current next frame */ to_next[0] = bi0 = from[0]; to_next[1] = bi1 = from[1]; from += 2; @@ -128,62 +131,62 @@ l2_patch_node_fn (vlib_main_t * vm, b0 = vlib_get_buffer (vm, bi0); b1 = vlib_get_buffer (vm, bi1); - sw_if_index0 = vnet_buffer(b0)->sw_if_index[VLIB_RX]; - sw_if_index1 = vnet_buffer(b1)->sw_if_index[VLIB_RX]; - - ASSERT(l2pm->tx_next_by_rx_sw_if_index[sw_if_index0] != ~0); - ASSERT(l2pm->tx_sw_if_index_by_rx_sw_if_index[sw_if_index0] != ~0); - ASSERT(l2pm->tx_next_by_rx_sw_if_index[sw_if_index1] != ~0); - ASSERT(l2pm->tx_sw_if_index_by_rx_sw_if_index[sw_if_index1] != ~0); - - if (PREDICT_TRUE (sw_if_index0 == l2pm->cached_rx_sw_if_index)) - next0 = l2pm->cached_next_index; - else - { - next0 = l2pm->tx_next_by_rx_sw_if_index[sw_if_index0]; - l2pm->cached_rx_sw_if_index = sw_if_index0; - l2pm->cached_next_index = next0; - } - - if (PREDICT_TRUE (sw_if_index1 == l2pm->cached_rx_sw_if_index)) - next1 = l2pm->cached_next_index; - else - next1 = l2pm->tx_next_by_rx_sw_if_index [sw_if_index1]; - - if (PREDICT_FALSE((node->flags & VLIB_NODE_FLAG_TRACE))) - { - if (b0->flags & VLIB_BUFFER_IS_TRACED) - { - l2_patch_trace_t *t = - vlib_add_trace (vm, node, b0, sizeof (*t)); - t->rx_sw_if_index = sw_if_index0; - t->tx_sw_if_index = - l2pm->tx_sw_if_index_by_rx_sw_if_index [sw_if_index0]; - } - if (b1->flags & VLIB_BUFFER_IS_TRACED) - { - l2_patch_trace_t *t = - vlib_add_trace (vm, node, b1, sizeof (*t)); - t->rx_sw_if_index = sw_if_index1; - t->tx_sw_if_index = - l2pm->tx_sw_if_index_by_rx_sw_if_index [sw_if_index1]; - } - } - - /* verify speculative enqueues, maybe switch current next frame */ - vlib_validate_buffer_enqueue_x2 (vm, node, next_index, - to_next, n_left_to_next, - bi0, bi1, next0, next1); - } - + sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX]; + sw_if_index1 = vnet_buffer (b1)->sw_if_index[VLIB_RX]; + + ASSERT (l2pm->tx_next_by_rx_sw_if_index[sw_if_index0] != ~0); + ASSERT (l2pm->tx_sw_if_index_by_rx_sw_if_index[sw_if_index0] != ~0); + ASSERT (l2pm->tx_next_by_rx_sw_if_index[sw_if_index1] != ~0); + ASSERT (l2pm->tx_sw_if_index_by_rx_sw_if_index[sw_if_index1] != ~0); + + if (PREDICT_TRUE (sw_if_index0 == l2pm->cached_rx_sw_if_index)) + next0 = l2pm->cached_next_index; + else + { + next0 = l2pm->tx_next_by_rx_sw_if_index[sw_if_index0]; + l2pm->cached_rx_sw_if_index = sw_if_index0; + l2pm->cached_next_index = next0; + } + + if (PREDICT_TRUE (sw_if_index1 == l2pm->cached_rx_sw_if_index)) + next1 = l2pm->cached_next_index; + else + next1 = l2pm->tx_next_by_rx_sw_if_index[sw_if_index1]; + + if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE))) + { + if (b0->flags & VLIB_BUFFER_IS_TRACED) + { + l2_patch_trace_t *t = + vlib_add_trace (vm, node, b0, sizeof (*t)); + t->rx_sw_if_index = sw_if_index0; + t->tx_sw_if_index = + l2pm->tx_sw_if_index_by_rx_sw_if_index[sw_if_index0]; + } + if (b1->flags & VLIB_BUFFER_IS_TRACED) + { + l2_patch_trace_t *t = + vlib_add_trace (vm, node, b1, sizeof (*t)); + t->rx_sw_if_index = sw_if_index1; + t->tx_sw_if_index = + l2pm->tx_sw_if_index_by_rx_sw_if_index[sw_if_index1]; + } + } + + /* verify speculative enqueues, maybe switch current next frame */ + vlib_validate_buffer_enqueue_x2 (vm, node, next_index, + to_next, n_left_to_next, + bi0, bi1, next0, next1); + } + while (n_left_from > 0 && n_left_to_next > 0) { - u32 bi0; - vlib_buffer_t * b0; - u32 next0; - u32 sw_if_index0; + u32 bi0; + vlib_buffer_t *b0; + u32 next0; + u32 sw_if_index0; - /* speculatively enqueue b0 to the current next frame */ + /* speculatively enqueue b0 to the current next frame */ bi0 = from[0]; to_next[0] = bi0; from += 1; @@ -193,33 +196,33 @@ l2_patch_node_fn (vlib_main_t * vm, b0 = vlib_get_buffer (vm, bi0); - sw_if_index0 = vnet_buffer(b0)->sw_if_index[VLIB_RX]; - - ASSERT(l2pm->tx_next_by_rx_sw_if_index[sw_if_index0] != ~0); - ASSERT(l2pm->tx_sw_if_index_by_rx_sw_if_index[sw_if_index0] != ~0); - - if (PREDICT_TRUE (sw_if_index0 == l2pm->cached_rx_sw_if_index)) - next0 = l2pm->cached_next_index; - else - { - next0 = l2pm->tx_next_by_rx_sw_if_index [sw_if_index0]; - l2pm->cached_rx_sw_if_index = sw_if_index0; - l2pm->cached_next_index = next0; - } - - if (PREDICT_FALSE((node->flags & VLIB_NODE_FLAG_TRACE))) - { - if (b0->flags & VLIB_BUFFER_IS_TRACED) - { - l2_patch_trace_t *t = - vlib_add_trace (vm, node, b0, sizeof (*t)); - t->rx_sw_if_index = sw_if_index0; - t->tx_sw_if_index = - l2pm->tx_sw_if_index_by_rx_sw_if_index [sw_if_index0]; - } - } - - /* verify speculative enqueue, maybe switch current next frame */ + sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX]; + + ASSERT (l2pm->tx_next_by_rx_sw_if_index[sw_if_index0] != ~0); + ASSERT (l2pm->tx_sw_if_index_by_rx_sw_if_index[sw_if_index0] != ~0); + + if (PREDICT_TRUE (sw_if_index0 == l2pm->cached_rx_sw_if_index)) + next0 = l2pm->cached_next_index; + else + { + next0 = l2pm->tx_next_by_rx_sw_if_index[sw_if_index0]; + l2pm->cached_rx_sw_if_index = sw_if_index0; + l2pm->cached_next_index = next0; + } + + if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE))) + { + if (b0->flags & VLIB_BUFFER_IS_TRACED) + { + l2_patch_trace_t *t = + vlib_add_trace (vm, node, b0, sizeof (*t)); + t->rx_sw_if_index = sw_if_index0; + t->tx_sw_if_index = + l2pm->tx_sw_if_index_by_rx_sw_if_index[sw_if_index0]; + } + } + + /* verify speculative enqueue, maybe switch current next frame */ vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next, n_left_to_next, bi0, next0); @@ -228,19 +231,20 @@ l2_patch_node_fn (vlib_main_t * vm, vlib_put_next_frame (vm, node, next_index, n_left_to_next); } - em->counters[node_counter_base_index + L2_PATCH_ERROR_PATCHED] += + em->counters[node_counter_base_index + L2_PATCH_ERROR_PATCHED] += frame->n_vectors; return frame->n_vectors; } +/* *INDENT-OFF* */ VLIB_REGISTER_NODE (l2_patch_node, static) = { .function = l2_patch_node_fn, .name = "l2_patch", .vector_size = sizeof (u32), .format_trace = format_l2_patch_trace, .type = VLIB_NODE_TYPE_INTERNAL, - + .n_errors = ARRAY_LEN(l2_patch_error_strings), .error_strings = l2_patch_error_strings, @@ -251,16 +255,17 @@ VLIB_REGISTER_NODE (l2_patch_node, static) = { [L2_PATCH_NEXT_DROP] = "error-drop", }, }; +/* *INDENT-ON* */ VLIB_NODE_FUNCTION_MULTIARCH (l2_patch_node, l2_patch_node_fn) - -int vnet_l2_patch_add_del (u32 rx_sw_if_index, u32 tx_sw_if_index, int is_add) + int vnet_l2_patch_add_del (u32 rx_sw_if_index, u32 tx_sw_if_index, + int is_add) { - l2_patch_main_t * l2pm = &l2_patch_main; - vnet_hw_interface_t * rxhi, *txhi; + l2_patch_main_t *l2pm = &l2_patch_main; + vnet_hw_interface_t *rxhi, *txhi; u32 tx_next_index; - /* + /* * We assume that the API msg handler has used 2x VALIDATE_SW_IF_INDEX * macros... */ @@ -278,50 +283,49 @@ int vnet_l2_patch_add_del (u32 rx_sw_if_index, u32 tx_sw_if_index, int is_add) if (is_add) { tx_next_index = vlib_node_add_next (l2pm->vlib_main, - l2_patch_node.index, - txhi->output_node_index); + l2_patch_node.index, + txhi->output_node_index); vec_validate_init_empty (l2pm->tx_next_by_rx_sw_if_index, rx_sw_if_index, ~0); - + l2pm->tx_next_by_rx_sw_if_index[rx_sw_if_index] = tx_next_index; vec_validate_init_empty (l2pm->tx_sw_if_index_by_rx_sw_if_index, rx_sw_if_index, ~0); - l2pm->tx_sw_if_index_by_rx_sw_if_index[rx_sw_if_index] - = txhi->sw_if_index; - - ethernet_set_flags (l2pm->vnet_main, rxhi->hw_if_index, - ETHERNET_INTERFACE_FLAG_ACCEPT_ALL); - - vnet_hw_interface_rx_redirect_to_node (l2pm->vnet_main, - rxhi->hw_if_index, - l2_patch_node.index); + l2pm->tx_sw_if_index_by_rx_sw_if_index[rx_sw_if_index] + = txhi->sw_if_index; + + ethernet_set_flags (l2pm->vnet_main, rxhi->hw_if_index, + ETHERNET_INTERFACE_FLAG_ACCEPT_ALL); + + vnet_hw_interface_rx_redirect_to_node (l2pm->vnet_main, + rxhi->hw_if_index, + l2_patch_node.index); } else { - ethernet_set_flags (l2pm->vnet_main, rxhi->hw_if_index, - 0 /* disable promiscuous mode */); + ethernet_set_flags (l2pm->vnet_main, rxhi->hw_if_index, + 0 /* disable promiscuous mode */ ); - vnet_hw_interface_rx_redirect_to_node (l2pm->vnet_main, - rxhi->hw_if_index, - ~0 /* disable */); + vnet_hw_interface_rx_redirect_to_node (l2pm->vnet_main, + rxhi->hw_if_index, + ~0 /* disable */ ); if (vec_len (l2pm->tx_next_by_rx_sw_if_index) > rx_sw_if_index) - { - l2pm->tx_next_by_rx_sw_if_index[rx_sw_if_index] = ~0; - l2pm->tx_sw_if_index_by_rx_sw_if_index[rx_sw_if_index] = ~0; - } + { + l2pm->tx_next_by_rx_sw_if_index[rx_sw_if_index] = ~0; + l2pm->tx_sw_if_index_by_rx_sw_if_index[rx_sw_if_index] = ~0; + } } - + return 0; } static clib_error_t * test_patch_command_fn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) + unformat_input_t * input, vlib_cli_command_t * cmd) { - l2_patch_main_t * l2pm = &l2_patch_main; - unformat_input_t _line_input, * line_input = &_line_input; + l2_patch_main_t *l2pm = &l2_patch_main; + unformat_input_t _line_input, *line_input = &_line_input; u32 rx_sw_if_index, tx_sw_if_index; int rv; int rx_set = 0; @@ -329,20 +333,21 @@ test_patch_command_fn (vlib_main_t * vm, int is_add = 1; /* Get a line of input. */ - if (! unformat_user (input, unformat_line_input, line_input)) + if (!unformat_user (input, unformat_line_input, line_input)) return 0; while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) { if (unformat (line_input, "rx %U", unformat_vnet_sw_interface, - l2pm->vnet_main, &rx_sw_if_index)) - rx_set = 1; + l2pm->vnet_main, &rx_sw_if_index)) + rx_set = 1; else if (unformat (line_input, "tx %U", unformat_vnet_sw_interface, - l2pm->vnet_main, &tx_sw_if_index)) - tx_set = 1; + l2pm->vnet_main, &tx_sw_if_index)) + tx_set = 1; else if (unformat (line_input, "del")) - is_add = 0; - else break; + is_add = 0; + else + break; } if (rx_set == 0) @@ -365,35 +370,36 @@ test_patch_command_fn (vlib_main_t * vm, return clib_error_return (0, "tx interface not a physical port"); default: - return clib_error_return - (0, "WARNING: vnet_l2_patch_add_del returned %d", rv); + return clib_error_return + (0, "WARNING: vnet_l2_patch_add_del returned %d", rv); } - + return 0; } +/* *INDENT-OFF* */ VLIB_CLI_COMMAND (test_patch_command, static) = { .path = "test l2patch", - .short_help = + .short_help = "rx tx [del]", .function = test_patch_command_fn, }; +/* *INDENT-ON* */ -// Display the contents of the l2patch table. +/** Display the contents of the l2patch table. */ static clib_error_t * -show_l2patch (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) +show_l2patch (vlib_main_t * vm, + unformat_input_t * input, vlib_cli_command_t * cmd) { - l2_patch_main_t * l2pm = &l2_patch_main; + l2_patch_main_t *l2pm = &l2_patch_main; u32 rx_sw_if_index; u32 no_entries = 1; - ASSERT(vec_len(l2pm->tx_next_by_rx_sw_if_index) == - vec_len(l2pm->tx_sw_if_index_by_rx_sw_if_index)); - - for (rx_sw_if_index = 0; - rx_sw_if_index < vec_len (l2pm->tx_sw_if_index_by_rx_sw_if_index); + ASSERT (vec_len (l2pm->tx_next_by_rx_sw_if_index) == + vec_len (l2pm->tx_sw_if_index_by_rx_sw_if_index)); + + for (rx_sw_if_index = 0; + rx_sw_if_index < vec_len (l2pm->tx_sw_if_index_by_rx_sw_if_index); rx_sw_if_index++) { u32 tx_sw_if_index = @@ -404,8 +410,8 @@ show_l2patch (vlib_main_t * vm, vlib_cli_output (vm, "%26U -> %U", format_vnet_sw_if_index_name, l2pm->vnet_main, rx_sw_if_index, - format_vnet_sw_if_index_name, - l2pm->vnet_main,tx_sw_if_index); + format_vnet_sw_if_index_name, + l2pm->vnet_main, tx_sw_if_index); } } @@ -415,20 +421,31 @@ show_l2patch (vlib_main_t * vm, return 0; } +/* *INDENT-OFF* */ VLIB_CLI_COMMAND (show_l2patch_cli, static) = { .path = "show l2patch", .short_help = "Show l2 interface cross-connect entries", .function = show_l2patch, }; +/* *INDENT-ON* */ -clib_error_t *l2_patch_init (vlib_main_t *vm) +clib_error_t * +l2_patch_init (vlib_main_t * vm) { - l2_patch_main_t * mp = &l2_patch_main; - + l2_patch_main_t *mp = &l2_patch_main; + mp->vlib_main = vm; - mp->vnet_main = vnet_get_main(); + mp->vnet_main = vnet_get_main (); return 0; } VLIB_INIT_FUNCTION (l2_patch_init); + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/vnet/vnet/l2/l2_rw.c b/vnet/vnet/l2/l2_rw.c index ffb10f39d11..94096291cd0 100644 --- a/vnet/vnet/l2/l2_rw.c +++ b/vnet/vnet/l2/l2_rw.c @@ -21,349 +21,385 @@ l2_rw_main_t l2_rw_main; vlib_node_registration_t l2_rw_node; -typedef struct { +typedef struct +{ u32 sw_if_index; u32 classify_table_index; u32 rewrite_entry_index; } l2_rw_trace_t; -static u8 *format_l2_rw_entry (u8 * s, va_list *args) +static u8 * +format_l2_rw_entry (u8 * s, va_list * args) { l2_rw_entry_t *e = va_arg (*args, l2_rw_entry_t *); l2_rw_main_t *rw = &l2_rw_main; s = format (s, "%d - mask:%U value:%U\n", - e - rw->entries, - format_hex_bytes, e->mask, e->rewrite_n_vectors * sizeof(u32x4), - format_hex_bytes, e->value, e->rewrite_n_vectors * sizeof(u32x4)); - s = format (s, " hits:%d skip_bytes:%d", - e->hit_count, e->skip_n_vectors * sizeof(u32x4)); + e - rw->entries, + format_hex_bytes, e->mask, + e->rewrite_n_vectors * sizeof (u32x4), format_hex_bytes, + e->value, e->rewrite_n_vectors * sizeof (u32x4)); + s = + format (s, " hits:%d skip_bytes:%d", e->hit_count, + e->skip_n_vectors * sizeof (u32x4)); return s; } -static u8 *format_l2_rw_config (u8 * s, va_list *args) +static u8 * +format_l2_rw_config (u8 * s, va_list * args) { l2_rw_config_t *c = va_arg (*args, l2_rw_config_t *); - return format(s, "table-index:%d miss-index:%d", - c->table_index, - c->miss_index); + return format (s, "table-index:%d miss-index:%d", + c->table_index, c->miss_index); } /* packet trace format function */ -static u8 *format_l2_rw_trace (u8 * s, va_list * args) +static u8 * +format_l2_rw_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 *); - l2_rw_trace_t * t = va_arg (*args, l2_rw_trace_t *); + l2_rw_trace_t *t = va_arg (*args, l2_rw_trace_t *); return format (s, "l2-rw: sw_if_index %d, table %d, entry %d", - t->sw_if_index, t->classify_table_index, - t->rewrite_entry_index); + t->sw_if_index, t->classify_table_index, + t->rewrite_entry_index); } -always_inline l2_rw_config_t *l2_rw_get_config(u32 sw_if_index) +always_inline l2_rw_config_t * +l2_rw_get_config (u32 sw_if_index) { l2_rw_main_t *rw = &l2_rw_main; - if (PREDICT_FALSE(!clib_bitmap_get(rw->configs_bitmap, sw_if_index))) { - vec_validate(rw->configs, sw_if_index); - rw->configs[sw_if_index].table_index = ~0; - rw->configs[sw_if_index].miss_index = ~0; - rw->configs_bitmap = clib_bitmap_set(rw->configs_bitmap, sw_if_index, 1); - } + if (PREDICT_FALSE (!clib_bitmap_get (rw->configs_bitmap, sw_if_index))) + { + vec_validate (rw->configs, sw_if_index); + rw->configs[sw_if_index].table_index = ~0; + rw->configs[sw_if_index].miss_index = ~0; + rw->configs_bitmap = + clib_bitmap_set (rw->configs_bitmap, sw_if_index, 1); + } return &rw->configs[sw_if_index]; } -static_always_inline void l2_rw_rewrite(l2_rw_entry_t *rwe, u8 *h) +static_always_inline void +l2_rw_rewrite (l2_rw_entry_t * rwe, u8 * h) { - if (U32X4_ALIGNED(h)) { - u32x4 *d = ((u32x4 *) h) + rwe->skip_n_vectors; - switch(rwe->rewrite_n_vectors) { - case 5: - d[4] = (d[4] & ~rwe->mask[4]) | rwe->value[4]; - /* FALLTHROUGH */ - case 4: - d[3] = (d[3] & ~rwe->mask[3]) | rwe->value[3]; - /* FALLTHROUGH */ - case 3: - d[2] = (d[2] & ~rwe->mask[2]) | rwe->value[2]; - /* FALLTHROUGH */ - case 2: - d[1] = (d[1] & ~rwe->mask[1]) | rwe->value[1]; - /* FALLTHROUGH */ - case 1: - d[0] = (d[0] & ~rwe->mask[0]) | rwe->value[0]; - break; - default: - abort(); + if (U32X4_ALIGNED (h)) + { + u32x4 *d = ((u32x4 *) h) + rwe->skip_n_vectors; + switch (rwe->rewrite_n_vectors) + { + case 5: + d[4] = (d[4] & ~rwe->mask[4]) | rwe->value[4]; + /* FALLTHROUGH */ + case 4: + d[3] = (d[3] & ~rwe->mask[3]) | rwe->value[3]; + /* FALLTHROUGH */ + case 3: + d[2] = (d[2] & ~rwe->mask[2]) | rwe->value[2]; + /* FALLTHROUGH */ + case 2: + d[1] = (d[1] & ~rwe->mask[1]) | rwe->value[1]; + /* FALLTHROUGH */ + case 1: + d[0] = (d[0] & ~rwe->mask[0]) | rwe->value[0]; + break; + default: + abort (); + } } - } else { - u64 *d = ((u64 *) h) + rwe->skip_n_vectors * 2; - switch(rwe->rewrite_n_vectors) { - case 5: - d[8] = (d[8] & ~(((u64*)rwe->mask)[8])) | (((u64*)rwe->value)[8]); - d[9] = (d[9] & ~(((u64*)rwe->mask)[9])) | (((u64*)rwe->value)[9]); - /* FALLTHROUGH */ - case 4: - d[6] = (d[6] & ~(((u64*)rwe->mask)[6])) | (((u64*)rwe->value)[6]); - d[7] = (d[7] & ~(((u64*)rwe->mask)[7])) | (((u64*)rwe->value)[7]); - /* FALLTHROUGH */ - case 3: - d[4] = (d[4] & ~(((u64*)rwe->mask)[4])) | (((u64*)rwe->value)[4]); - d[5] = (d[5] & ~(((u64*)rwe->mask)[5])) | (((u64*)rwe->value)[5]); - /* FALLTHROUGH */ - case 2: - d[2] = (d[2] & ~(((u64*)rwe->mask)[2])) | (((u64*)rwe->value)[2]); - d[3] = (d[3] & ~(((u64*)rwe->mask)[3])) | (((u64*)rwe->value)[3]); - /* FALLTHROUGH */ - case 1: - d[0] = (d[0] & ~(((u64*)rwe->mask)[0])) | (((u64*)rwe->value)[0]); - d[1] = (d[1] & ~(((u64*)rwe->mask)[1])) | (((u64*)rwe->value)[1]); - break; - default: - abort(); + else + { + u64 *d = ((u64 *) h) + rwe->skip_n_vectors * 2; + switch (rwe->rewrite_n_vectors) + { + case 5: + d[8] = + (d[8] & ~(((u64 *) rwe->mask)[8])) | (((u64 *) rwe->value)[8]); + d[9] = + (d[9] & ~(((u64 *) rwe->mask)[9])) | (((u64 *) rwe->value)[9]); + /* FALLTHROUGH */ + case 4: + d[6] = + (d[6] & ~(((u64 *) rwe->mask)[6])) | (((u64 *) rwe->value)[6]); + d[7] = + (d[7] & ~(((u64 *) rwe->mask)[7])) | (((u64 *) rwe->value)[7]); + /* FALLTHROUGH */ + case 3: + d[4] = + (d[4] & ~(((u64 *) rwe->mask)[4])) | (((u64 *) rwe->value)[4]); + d[5] = + (d[5] & ~(((u64 *) rwe->mask)[5])) | (((u64 *) rwe->value)[5]); + /* FALLTHROUGH */ + case 2: + d[2] = + (d[2] & ~(((u64 *) rwe->mask)[2])) | (((u64 *) rwe->value)[2]); + d[3] = + (d[3] & ~(((u64 *) rwe->mask)[3])) | (((u64 *) rwe->value)[3]); + /* FALLTHROUGH */ + case 1: + d[0] = + (d[0] & ~(((u64 *) rwe->mask)[0])) | (((u64 *) rwe->value)[0]); + d[1] = + (d[1] & ~(((u64 *) rwe->mask)[1])) | (((u64 *) rwe->value)[1]); + break; + default: + abort (); + } } - } } static uword -l2_rw_node_fn(vlib_main_t * vm, - vlib_node_runtime_t * node, - vlib_frame_t * frame) +l2_rw_node_fn (vlib_main_t * vm, + vlib_node_runtime_t * node, vlib_frame_t * frame) { l2_rw_main_t *rw = &l2_rw_main; - u32 n_left_from, * from, * to_next, next_index; - //vlib_node_t *n = vlib_get_node(vm, node->node_index); + u32 n_left_from, *from, *to_next, next_index; vnet_classify_main_t *vcm = &vnet_classify_main; - f64 now = vlib_time_now(vlib_get_main()); + f64 now = vlib_time_now (vlib_get_main ()); u32 prefetch_size = 0; from = vlib_frame_vector_args (frame); - n_left_from = frame->n_vectors; /* number of packets to process */ + n_left_from = frame->n_vectors; /* number of packets to process */ next_index = node->cached_next_index; while (n_left_from > 0) - { - u32 n_left_to_next; - - /* get space to enqueue frame to graph node "next_index" */ - vlib_get_next_frame (vm, node, next_index, - to_next, n_left_to_next); - - while (n_left_from >= 4 && n_left_to_next >= 2) - { - u32 bi0, next0, sw_if_index0, feature_bitmap0, rwe_index0; - u32 bi1, next1, sw_if_index1, feature_bitmap1, rwe_index1; - vlib_buffer_t *b0, *b1; - ethernet_header_t *h0, *h1; - l2_rw_config_t *config0, *config1; - u64 hash0, hash1; - vnet_classify_table_t *t0, *t1; - vnet_classify_entry_t *e0, *e1; - l2_rw_entry_t *rwe0, *rwe1; - - { - vlib_buffer_t * p2, * p3; - p2 = vlib_get_buffer (vm, from[2]); - p3 = vlib_get_buffer (vm, from[3]); - - vlib_prefetch_buffer_header (p2, LOAD); - vlib_prefetch_buffer_header (p3, LOAD); - CLIB_PREFETCH (vlib_buffer_get_current(p2), prefetch_size, LOAD); - CLIB_PREFETCH (vlib_buffer_get_current(p3), prefetch_size, LOAD); - } - - bi0 = from[0]; - bi1 = from[1]; - to_next[0] = bi0; - to_next[1] = bi1; - from += 2; - to_next += 2; - n_left_from -= 2; - n_left_to_next -= 2; - - b0 = vlib_get_buffer(vm, bi0); - b1 = vlib_get_buffer(vm, bi1); - h0 = vlib_buffer_get_current(b0); - h1 = vlib_buffer_get_current(b1); - - sw_if_index0 = vnet_buffer(b0)->sw_if_index[VLIB_RX]; - sw_if_index1 = vnet_buffer(b1)->sw_if_index[VLIB_RX]; - config0 = l2_rw_get_config(sw_if_index0); //TODO: check sw_if_index0 value - config1 = l2_rw_get_config(sw_if_index1); //TODO: check sw_if_index0 value - t0 = pool_elt_at_index(vcm->tables, config0->table_index); - t1 = pool_elt_at_index(vcm->tables, config1->table_index); - prefetch_size = (t1->skip_n_vectors + t1->match_n_vectors)*sizeof(u32x4); - - hash0 = vnet_classify_hash_packet(t0, (u8 *)h0); - hash1 = vnet_classify_hash_packet(t1, (u8 *)h1); - e0 = vnet_classify_find_entry(t0, (u8 *) h0, hash0, now); - e1 = vnet_classify_find_entry(t1, (u8 *) h1, hash1, now); - - while (!e0 && (t0->next_table_index != ~0)) { - t0 = pool_elt_at_index(vcm->tables, t0->next_table_index); - hash0 = vnet_classify_hash_packet(t0, (u8 *)h0); - e0 = vnet_classify_find_entry(t0, (u8 *) h0, hash0, now); - } - - while (!e1 && (t1->next_table_index != ~0)) { - t1 = pool_elt_at_index(vcm->tables, t1->next_table_index); - hash1 = vnet_classify_hash_packet(t1, (u8 *)h1); - e1 = vnet_classify_find_entry(t1, (u8 *) h1, hash1, now); - } - - rwe_index0 = e0?e0->opaque_index:config0->miss_index; - rwe_index1 = e1?e1->opaque_index:config1->miss_index; - - if (rwe_index0 != ~0) { - rwe0 = pool_elt_at_index(rw->entries, rwe_index0); - l2_rw_rewrite(rwe0, (u8 *)h0); - } - if (rwe_index1 != ~0) { - rwe1 = pool_elt_at_index(rw->entries, rwe_index1); - l2_rw_rewrite(rwe1, (u8 *)h1); - } - - if (PREDICT_FALSE((b0->flags & VLIB_BUFFER_IS_TRACED))) { - l2_rw_trace_t *t = - vlib_add_trace (vm, node, b0, sizeof (*t)); - t->sw_if_index = sw_if_index0; - t->classify_table_index = config0->table_index; - t->rewrite_entry_index = rwe_index0; - } - - if (PREDICT_FALSE((b1->flags & VLIB_BUFFER_IS_TRACED))) { - l2_rw_trace_t *t = - vlib_add_trace (vm, node, b1, sizeof (*t)); - t->sw_if_index = sw_if_index1; - t->classify_table_index = config1->table_index; - t->rewrite_entry_index = rwe_index1; - } - - // Update feature bitmap and get next feature index - feature_bitmap0 = vnet_buffer(b0)->l2.feature_bitmap & ~L2INPUT_FEAT_RW; - feature_bitmap1 = vnet_buffer(b1)->l2.feature_bitmap & ~L2INPUT_FEAT_RW; - vnet_buffer(b0)->l2.feature_bitmap = feature_bitmap0; - vnet_buffer(b1)->l2.feature_bitmap = feature_bitmap1; - next0 = feat_bitmap_get_next_node_index(rw->feat_next_node_index, - feature_bitmap0); - next1 = feat_bitmap_get_next_node_index(rw->feat_next_node_index, - feature_bitmap1); - - vlib_validate_buffer_enqueue_x2 (vm, node, next_index, - to_next, n_left_to_next, - bi0, bi1, next0, next1); - } - - while (n_left_from > 0 && n_left_to_next > 0) { - u32 bi0, next0, sw_if_index0, feature_bitmap0, rwe_index0; - vlib_buffer_t *b0; - ethernet_header_t *h0; - l2_rw_config_t *config0; - u64 hash0; - vnet_classify_table_t *t0; - vnet_classify_entry_t *e0; - l2_rw_entry_t *rwe0; - - 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); - h0 = vlib_buffer_get_current(b0); - - sw_if_index0 = vnet_buffer(b0)->sw_if_index[VLIB_RX]; - config0 = l2_rw_get_config(sw_if_index0); //TODO: check sw_if_index0 value - t0 = pool_elt_at_index(vcm->tables, config0->table_index); - - hash0 = vnet_classify_hash_packet(t0, (u8 *)h0); - e0 = vnet_classify_find_entry(t0, (u8 *) h0, hash0, now); - - while (!e0 && (t0->next_table_index != ~0)) { - t0 = pool_elt_at_index(vcm->tables, t0->next_table_index); - hash0 = vnet_classify_hash_packet(t0, (u8 *)h0); - e0 = vnet_classify_find_entry(t0, (u8 *) h0, hash0, now); - } - - rwe_index0 = e0?e0->opaque_index:config0->miss_index; - - if (rwe_index0 != ~0) { - rwe0 = pool_elt_at_index(rw->entries, rwe_index0); - l2_rw_rewrite(rwe0, (u8 *)h0); - } - - if (PREDICT_FALSE((b0->flags & VLIB_BUFFER_IS_TRACED))) { - l2_rw_trace_t *t = - vlib_add_trace (vm, node, b0, sizeof (*t)); - t->sw_if_index = sw_if_index0; - t->classify_table_index = config0->table_index; - t->rewrite_entry_index = rwe_index0; - } - - // Update feature bitmap and get next feature index - feature_bitmap0 = vnet_buffer(b0)->l2.feature_bitmap & ~L2INPUT_FEAT_RW; - vnet_buffer(b0)->l2.feature_bitmap = feature_bitmap0; - next0 = feat_bitmap_get_next_node_index(rw->feat_next_node_index, - feature_bitmap0); - - vlib_validate_buffer_enqueue_x1 (vm, node, next_index, - to_next, n_left_to_next, - bi0, next0); + u32 n_left_to_next; + + /* get space to enqueue frame to graph node "next_index" */ + vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next); + + while (n_left_from >= 4 && n_left_to_next >= 2) + { + u32 bi0, next0, sw_if_index0, feature_bitmap0, rwe_index0; + u32 bi1, next1, sw_if_index1, feature_bitmap1, rwe_index1; + vlib_buffer_t *b0, *b1; + ethernet_header_t *h0, *h1; + l2_rw_config_t *config0, *config1; + u64 hash0, hash1; + vnet_classify_table_t *t0, *t1; + vnet_classify_entry_t *e0, *e1; + l2_rw_entry_t *rwe0, *rwe1; + + { + vlib_buffer_t *p2, *p3; + p2 = vlib_get_buffer (vm, from[2]); + p3 = vlib_get_buffer (vm, from[3]); + + vlib_prefetch_buffer_header (p2, LOAD); + vlib_prefetch_buffer_header (p3, LOAD); + CLIB_PREFETCH (vlib_buffer_get_current (p2), prefetch_size, LOAD); + CLIB_PREFETCH (vlib_buffer_get_current (p3), prefetch_size, LOAD); + } + + bi0 = from[0]; + bi1 = from[1]; + to_next[0] = bi0; + to_next[1] = bi1; + from += 2; + to_next += 2; + n_left_from -= 2; + n_left_to_next -= 2; + + b0 = vlib_get_buffer (vm, bi0); + b1 = vlib_get_buffer (vm, bi1); + h0 = vlib_buffer_get_current (b0); + h1 = vlib_buffer_get_current (b1); + + sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX]; + sw_if_index1 = vnet_buffer (b1)->sw_if_index[VLIB_RX]; + config0 = l2_rw_get_config (sw_if_index0); /*TODO: check sw_if_index0 value */ + config1 = l2_rw_get_config (sw_if_index1); /*TODO: check sw_if_index0 value */ + t0 = pool_elt_at_index (vcm->tables, config0->table_index); + t1 = pool_elt_at_index (vcm->tables, config1->table_index); + prefetch_size = + (t1->skip_n_vectors + t1->match_n_vectors) * sizeof (u32x4); + + hash0 = vnet_classify_hash_packet (t0, (u8 *) h0); + hash1 = vnet_classify_hash_packet (t1, (u8 *) h1); + e0 = vnet_classify_find_entry (t0, (u8 *) h0, hash0, now); + e1 = vnet_classify_find_entry (t1, (u8 *) h1, hash1, now); + + while (!e0 && (t0->next_table_index != ~0)) + { + t0 = pool_elt_at_index (vcm->tables, t0->next_table_index); + hash0 = vnet_classify_hash_packet (t0, (u8 *) h0); + e0 = vnet_classify_find_entry (t0, (u8 *) h0, hash0, now); + } + + while (!e1 && (t1->next_table_index != ~0)) + { + t1 = pool_elt_at_index (vcm->tables, t1->next_table_index); + hash1 = vnet_classify_hash_packet (t1, (u8 *) h1); + e1 = vnet_classify_find_entry (t1, (u8 *) h1, hash1, now); + } + + rwe_index0 = e0 ? e0->opaque_index : config0->miss_index; + rwe_index1 = e1 ? e1->opaque_index : config1->miss_index; + + if (rwe_index0 != ~0) + { + rwe0 = pool_elt_at_index (rw->entries, rwe_index0); + l2_rw_rewrite (rwe0, (u8 *) h0); + } + if (rwe_index1 != ~0) + { + rwe1 = pool_elt_at_index (rw->entries, rwe_index1); + l2_rw_rewrite (rwe1, (u8 *) h1); + } + + if (PREDICT_FALSE ((b0->flags & VLIB_BUFFER_IS_TRACED))) + { + l2_rw_trace_t *t = vlib_add_trace (vm, node, b0, sizeof (*t)); + t->sw_if_index = sw_if_index0; + t->classify_table_index = config0->table_index; + t->rewrite_entry_index = rwe_index0; + } + + if (PREDICT_FALSE ((b1->flags & VLIB_BUFFER_IS_TRACED))) + { + l2_rw_trace_t *t = vlib_add_trace (vm, node, b1, sizeof (*t)); + t->sw_if_index = sw_if_index1; + t->classify_table_index = config1->table_index; + t->rewrite_entry_index = rwe_index1; + } + + /* Update feature bitmap and get next feature index */ + feature_bitmap0 = + vnet_buffer (b0)->l2.feature_bitmap & ~L2INPUT_FEAT_RW; + feature_bitmap1 = + vnet_buffer (b1)->l2.feature_bitmap & ~L2INPUT_FEAT_RW; + vnet_buffer (b0)->l2.feature_bitmap = feature_bitmap0; + vnet_buffer (b1)->l2.feature_bitmap = feature_bitmap1; + next0 = feat_bitmap_get_next_node_index (rw->feat_next_node_index, + feature_bitmap0); + next1 = feat_bitmap_get_next_node_index (rw->feat_next_node_index, + feature_bitmap1); + + vlib_validate_buffer_enqueue_x2 (vm, node, next_index, + to_next, n_left_to_next, + bi0, bi1, next0, next1); + } + + while (n_left_from > 0 && n_left_to_next > 0) + { + u32 bi0, next0, sw_if_index0, feature_bitmap0, rwe_index0; + vlib_buffer_t *b0; + ethernet_header_t *h0; + l2_rw_config_t *config0; + u64 hash0; + vnet_classify_table_t *t0; + vnet_classify_entry_t *e0; + l2_rw_entry_t *rwe0; + + 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); + h0 = vlib_buffer_get_current (b0); + + sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX]; + config0 = l2_rw_get_config (sw_if_index0); /*TODO: check sw_if_index0 value */ + t0 = pool_elt_at_index (vcm->tables, config0->table_index); + + hash0 = vnet_classify_hash_packet (t0, (u8 *) h0); + e0 = vnet_classify_find_entry (t0, (u8 *) h0, hash0, now); + + while (!e0 && (t0->next_table_index != ~0)) + { + t0 = pool_elt_at_index (vcm->tables, t0->next_table_index); + hash0 = vnet_classify_hash_packet (t0, (u8 *) h0); + e0 = vnet_classify_find_entry (t0, (u8 *) h0, hash0, now); + } + + rwe_index0 = e0 ? e0->opaque_index : config0->miss_index; + + if (rwe_index0 != ~0) + { + rwe0 = pool_elt_at_index (rw->entries, rwe_index0); + l2_rw_rewrite (rwe0, (u8 *) h0); + } + + if (PREDICT_FALSE ((b0->flags & VLIB_BUFFER_IS_TRACED))) + { + l2_rw_trace_t *t = vlib_add_trace (vm, node, b0, sizeof (*t)); + t->sw_if_index = sw_if_index0; + t->classify_table_index = config0->table_index; + t->rewrite_entry_index = rwe_index0; + } + + /* Update feature bitmap and get next feature index */ + feature_bitmap0 = + vnet_buffer (b0)->l2.feature_bitmap & ~L2INPUT_FEAT_RW; + vnet_buffer (b0)->l2.feature_bitmap = feature_bitmap0; + next0 = feat_bitmap_get_next_node_index (rw->feat_next_node_index, + feature_bitmap0); + + 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_put_next_frame (vm, node, next_index, n_left_to_next); - } return frame->n_vectors; } -int l2_rw_mod_entry(u32 *index, - u8 *mask, u8 *value, u32 len, - u32 skip, u8 is_del) +int +l2_rw_mod_entry (u32 * index, + u8 * mask, u8 * value, u32 len, u32 skip, u8 is_del) { l2_rw_main_t *rw = &l2_rw_main; l2_rw_entry_t *e = 0; - if (*index != ~0) { - if (pool_is_free_index(rw->entries, *index)) { - return -1; + if (*index != ~0) + { + if (pool_is_free_index (rw->entries, *index)) + { + return -1; + } + e = pool_elt_at_index (rw->entries, *index); + } + else + { + pool_get (rw->entries, e); + *index = e - rw->entries; } - e = pool_elt_at_index(rw->entries, *index); - } else { - pool_get(rw->entries, e); - *index = e - rw->entries; - } if (!e) return -1; - if (is_del) { - pool_put(rw->entries, e); - return 0; - } + if (is_del) + { + pool_put (rw->entries, e); + return 0; + } - e->skip_n_vectors = skip / sizeof(u32x4); - skip -= e->skip_n_vectors * sizeof(u32x4); - e->rewrite_n_vectors = (skip + len - 1) / sizeof(u32x4) + 1; - vec_alloc_aligned(e->mask, e->rewrite_n_vectors, sizeof(u32x4)); - memset(e->mask, 0, e->rewrite_n_vectors * sizeof(u32x4)); - vec_alloc_aligned(e->value, e->rewrite_n_vectors, sizeof(u32x4)); - memset(e->value, 0, e->rewrite_n_vectors * sizeof(u32x4)); + e->skip_n_vectors = skip / sizeof (u32x4); + skip -= e->skip_n_vectors * sizeof (u32x4); + e->rewrite_n_vectors = (skip + len - 1) / sizeof (u32x4) + 1; + vec_alloc_aligned (e->mask, e->rewrite_n_vectors, sizeof (u32x4)); + memset (e->mask, 0, e->rewrite_n_vectors * sizeof (u32x4)); + vec_alloc_aligned (e->value, e->rewrite_n_vectors, sizeof (u32x4)); + memset (e->value, 0, e->rewrite_n_vectors * sizeof (u32x4)); - clib_memcpy(((u8 *)e->value) + skip, value, len); - clib_memcpy(((u8 *)e->mask) + skip, mask, len); + clib_memcpy (((u8 *) e->value) + skip, value, len); + clib_memcpy (((u8 *) e->mask) + skip, mask, len); int i; - for (i = 0; i < e->rewrite_n_vectors; i++) { - e->value[i] &= e->mask[i]; - } + for (i = 0; i < e->rewrite_n_vectors; i++) + { + e->value[i] &= e->mask[i]; + } return 0; } static clib_error_t * l2_rw_entry_cli_fn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) + unformat_input_t * input, vlib_cli_command_t * cmd) { u32 index = ~0; u8 *mask = 0; @@ -371,206 +407,223 @@ l2_rw_entry_cli_fn (vlib_main_t * vm, u32 skip = 0; u8 del = 0; - while (unformat_check_input(input) != UNFORMAT_END_OF_INPUT) - { - if (unformat (input, "index %d", &index)) - ; - else if (unformat (input, "mask %U", unformat_hex_string, &mask)) - ; - else if (unformat (input, "value %U", unformat_hex_string, &value)) - ; - else if (unformat (input, "skip %d", &skip)) - ; - else if (unformat (input, "del")) - del = 1; - else - break; - } + while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) + { + if (unformat (input, "index %d", &index)) + ; + else if (unformat (input, "mask %U", unformat_hex_string, &mask)) + ; + else if (unformat (input, "value %U", unformat_hex_string, &value)) + ; + else if (unformat (input, "skip %d", &skip)) + ; + else if (unformat (input, "del")) + del = 1; + else + break; + } if (!mask || !value) - return clib_error_return(0, "Unspecified mask or value"); + return clib_error_return (0, "Unspecified mask or value"); - if (vec_len(mask) != vec_len(value)) - return clib_error_return(0, "Mask and value lengths must be identical"); + if (vec_len (mask) != vec_len (value)) + return clib_error_return (0, "Mask and value lengths must be identical"); int ret; - if ((ret = l2_rw_mod_entry(&index, mask, value, vec_len(mask), skip, del))) - return clib_error_return(0, "Could not add entry"); + if ((ret = + l2_rw_mod_entry (&index, mask, value, vec_len (mask), skip, del))) + return clib_error_return (0, "Could not add entry"); return 0; } +/* *INDENT-OFF* */ VLIB_CLI_COMMAND (l2_rw_entry_cli, static) = { .path = "l2 rewrite entry", .short_help = "l2 rewrite entry [index ] [mask ] [value ] [skip ] [del]", .function = l2_rw_entry_cli_fn, }; +/* *INDENT-ON* */ -int l2_rw_interface_set_table(u32 sw_if_index, - u32 table_index, - u32 miss_index) +int +l2_rw_interface_set_table (u32 sw_if_index, u32 table_index, u32 miss_index) { - l2_rw_config_t *c = l2_rw_get_config(sw_if_index); + l2_rw_config_t *c = l2_rw_get_config (sw_if_index); l2_rw_main_t *rw = &l2_rw_main; c->table_index = table_index; c->miss_index = miss_index; - u32 feature_bitmap = (table_index == ~0)?0:L2INPUT_FEAT_RW; + u32 feature_bitmap = (table_index == ~0) ? 0 : L2INPUT_FEAT_RW; - l2input_intf_bitmap_enable(sw_if_index, L2INPUT_FEAT_RW, feature_bitmap); + l2input_intf_bitmap_enable (sw_if_index, L2INPUT_FEAT_RW, feature_bitmap); if (c->table_index == ~0) - clib_bitmap_set(rw->configs_bitmap, sw_if_index, 0); + clib_bitmap_set (rw->configs_bitmap, sw_if_index, 0); return 0; } static clib_error_t * l2_rw_interface_cli_fn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) + unformat_input_t * input, vlib_cli_command_t * cmd) { - vnet_main_t * vnm = vnet_get_main(); + vnet_main_t *vnm = vnet_get_main (); u32 table_index = ~0; u32 sw_if_index = ~0; u32 miss_index = ~0; - if (unformat_check_input(input) != UNFORMAT_END_OF_INPUT) { - unformat (input, "%U", unformat_vnet_sw_interface, - vnm, &sw_if_index); - } - - while (unformat_check_input(input) != UNFORMAT_END_OF_INPUT) - { - if (unformat (input, "table %d", &table_index)) - ; - else if (unformat (input, "miss-index %d", &miss_index)) - ; - else - break; - } + if (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) + { + unformat (input, "%U", unformat_vnet_sw_interface, vnm, &sw_if_index); + } + + while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) + { + if (unformat (input, "table %d", &table_index)) + ; + else if (unformat (input, "miss-index %d", &miss_index)) + ; + else + break; + } if (sw_if_index == ~0) - return clib_error_return(0, "You must specify an interface 'iface '", - format_unformat_error, input); + return clib_error_return (0, + "You must specify an interface 'iface '", + format_unformat_error, input); int ret; - if((ret = l2_rw_interface_set_table(sw_if_index, table_index, miss_index))) - return clib_error_return(0, "l2_rw_interface_set_table returned %d", ret); + if ((ret = + l2_rw_interface_set_table (sw_if_index, table_index, miss_index))) + return clib_error_return (0, "l2_rw_interface_set_table returned %d", + ret); return 0; } +/* *INDENT-OFF* */ VLIB_CLI_COMMAND (l2_rw_interface_cli, static) = { .path = "set interface l2 rewrite", .short_help = "set interface l2 rewrite [table ] [miss-index ]", .function = l2_rw_interface_cli_fn, }; +/* *INDENT-ON* */ static clib_error_t * l2_rw_show_interfaces_cli_fn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) + unformat_input_t * input, + vlib_cli_command_t * cmd) { l2_rw_main_t *rw = &l2_rw_main; - if (clib_bitmap_count_set_bits(rw->configs_bitmap) == 0) - vlib_cli_output (vm, "No interface is currently using l2 rewrite\n"); + if (clib_bitmap_count_set_bits (rw->configs_bitmap) == 0) + vlib_cli_output (vm, "No interface is currently using l2 rewrite\n"); uword i; + /* *INDENT-OFF* */ clib_bitmap_foreach(i, rw->configs_bitmap, { vlib_cli_output (vm, "sw_if_index:%d %U\n", i, format_l2_rw_config, &rw->configs[i]); }); + /* *INDENT-ON* */ return 0; } +/* *INDENT-OFF* */ VLIB_CLI_COMMAND (l2_rw_show_interfaces_cli, static) = { .path = "show l2 rewrite interfaces", .short_help = "show l2 rewrite interfaces", .function = l2_rw_show_interfaces_cli_fn, }; +/* *INDENT-ON* */ static clib_error_t * l2_rw_show_entries_cli_fn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) + unformat_input_t * input, vlib_cli_command_t * cmd) { l2_rw_main_t *rw = &l2_rw_main; l2_rw_entry_t *e; - if (pool_elts(rw->entries) == 0) + if (pool_elts (rw->entries) == 0) vlib_cli_output (vm, "No entries\n"); + /* *INDENT-OFF* */ pool_foreach(e, rw->entries, { vlib_cli_output (vm, "%U\n", format_l2_rw_entry, e); }); + /* *INDENT-ON* */ return 0; } +/* *INDENT-OFF* */ VLIB_CLI_COMMAND (l2_rw_show_entries_cli, static) = { .path = "show l2 rewrite entries", .short_help = "show l2 rewrite entries", .function = l2_rw_show_entries_cli_fn, }; +/* *INDENT-ON* */ int -l2_rw_enable_disable(u32 bridge_domain, u8 disable) +l2_rw_enable_disable (u32 bridge_domain, u8 disable) { u32 mask = L2INPUT_FEAT_RW; - l2input_set_bridge_features(bridge_domain, mask, - disable ? 0: mask); + l2input_set_bridge_features (bridge_domain, mask, disable ? 0 : mask); return 0; } static clib_error_t * l2_rw_set_cli_fn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) + unformat_input_t * input, vlib_cli_command_t * cmd) { u32 bridge_domain; u8 disable = 0; - if (unformat_check_input(input) == UNFORMAT_END_OF_INPUT || - !unformat (input, "%d", &bridge_domain)) { - return clib_error_return(0, "You must specify a bridge domain"); - } + if (unformat_check_input (input) == UNFORMAT_END_OF_INPUT || + !unformat (input, "%d", &bridge_domain)) + { + return clib_error_return (0, "You must specify a bridge domain"); + } - if (unformat_check_input(input) != UNFORMAT_END_OF_INPUT && - unformat (input, "disable")) { - disable = 1; - } + if (unformat_check_input (input) != UNFORMAT_END_OF_INPUT && + unformat (input, "disable")) + { + disable = 1; + } - if (l2_rw_enable_disable(bridge_domain, disable)) - return clib_error_return(0, "Could not enable or disable rewrite"); + if (l2_rw_enable_disable (bridge_domain, disable)) + return clib_error_return (0, "Could not enable or disable rewrite"); return 0; } +/* *INDENT-OFF* */ VLIB_CLI_COMMAND (l2_rw_set_cli, static) = { .path = "set bridge-domain rewrite", .short_help = "set bridge-domain rewrite [disable]", .function = l2_rw_set_cli_fn, }; +/* *INDENT-ON* */ -static -clib_error_t *l2_rw_init (vlib_main_t *vm) +static clib_error_t * +l2_rw_init (vlib_main_t * vm) { l2_rw_main_t *rw = &l2_rw_main; rw->configs = 0; rw->entries = 0; - clib_bitmap_alloc(rw->configs_bitmap, 1); - feat_bitmap_init_next_nodes(vm, - l2_rw_node.index, - L2INPUT_N_FEAT, - l2input_get_feat_names(), - rw->feat_next_node_index); + clib_bitmap_alloc (rw->configs_bitmap, 1); + feat_bitmap_init_next_nodes (vm, + l2_rw_node.index, + L2INPUT_N_FEAT, + l2input_get_feat_names (), + rw->feat_next_node_index); return 0; } + VLIB_INIT_FUNCTION (l2_rw_init); -enum { +enum +{ L2_RW_NEXT_DROP, L2_RW_N_NEXT, }; @@ -578,19 +631,21 @@ enum { #define foreach_l2_rw_error \ _(UNKNOWN, "Unknown error") -typedef enum { +typedef enum +{ #define _(sym,str) L2_RW_ERROR_##sym, foreach_l2_rw_error #undef _ - L2_RW_N_ERROR, + L2_RW_N_ERROR, } l2_rw_error_t; -static char * l2_rw_error_strings[] = { +static char *l2_rw_error_strings[] = { #define _(sym,string) string, - foreach_l2_rw_error + foreach_l2_rw_error #undef _ }; +/* *INDENT-OFF* */ VLIB_REGISTER_NODE (l2_rw_node) = { .function = l2_rw_node_fn, .name = "l2-rw", @@ -603,6 +658,13 @@ VLIB_REGISTER_NODE (l2_rw_node) = { .n_next_nodes = L2_RW_N_NEXT, .next_nodes = { [L2_RW_NEXT_DROP] = "error-drop"}, }; +/* *INDENT-ON* */ VLIB_NODE_FUNCTION_MULTIARCH (l2_rw_node, l2_rw_node_fn) - +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/vnet/vnet/l2/l2_rw.h b/vnet/vnet/l2/l2_rw.h index a46c476b3b1..49aa25fb601 100644 --- a/vnet/vnet/l2/l2_rw.h +++ b/vnet/vnet/l2/l2_rw.h @@ -27,6 +27,7 @@ #include +/* *INDENT-OFF* */ typedef CLIB_PACKED(struct _l2_rw_entry { u16 skip_n_vectors; u16 rewrite_n_vectors; @@ -34,14 +35,18 @@ typedef CLIB_PACKED(struct _l2_rw_entry { u32x4 *mask; u32x4 *value; }) l2_rw_entry_t; +/* *INDENT-ON* */ -// l2_rw configuration for one interface +/* l2_rw configuration for one interface */ +/* *INDENT-OFF* */ typedef CLIB_PACKED(struct _l2_rw_config { - u32 table_index; //Which classify table to use - u32 miss_index; //Rewrite entry to use if table does not match + u32 table_index; /* Which classify table to use */ + u32 miss_index; /* Rewrite entry to use if table does not match */ }) l2_rw_config_t; +/* *INDENT-ON* */ -typedef struct { +typedef struct +{ /* Next feature node indexes */ u32 feat_next_node_index[32]; @@ -64,9 +69,8 @@ extern l2_rw_main_t l2_rw_main; * when table_index or miss_index is not ~0. * returns 0 on success and something else on error. */ -int l2_rw_interface_set_table(u32 sw_if_index, - u32 table_index, - u32 miss_index); +int l2_rw_interface_set_table (u32 sw_if_index, + u32 table_index, u32 miss_index); /* * Creates, modifies or delete a rewrite entry. @@ -77,8 +81,15 @@ int l2_rw_interface_set_table(u32 sw_if_index, * is set). * returns 0 on success and something else on error. */ -int l2_rw_mod_entry(u32 *index, - u8 *mask, u8 *value, u32 len, - u32 skip, u8 is_del); +int l2_rw_mod_entry (u32 * index, + u8 * mask, u8 * value, u32 len, u32 skip, u8 is_del); #endif /* L2_FW_H_ */ + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/vnet/vnet/l2/l2_vtr.c b/vnet/vnet/l2/l2_vtr.c index a7499041009..6250074e303 100644 --- a/vnet/vnet/l2/l2_vtr.c +++ b/vnet/vnet/l2/l2_vtr.c @@ -30,220 +30,248 @@ #include -// Just a placeholder. Also insures file is not eliminated by linker. -clib_error_t *l2_vtr_init (vlib_main_t *vm) +/** Just a placeholder. Also ensures file is not eliminated by linker. */ +clib_error_t * +l2_vtr_init (vlib_main_t * vm) { return 0; } -VLIB_INIT_FUNCTION(l2_vtr_init); +VLIB_INIT_FUNCTION (l2_vtr_init); -// Configure vtag tag rewrite on the given interface. -// Return 1 if there is an error, 0 if ok -u32 l2vtr_configure (vlib_main_t * vlib_main, - vnet_main_t * vnet_main, - u32 sw_if_index, - u32 vtr_op, - u32 push_dot1q, // ethertype of first pushed tag is dot1q/dot1ad - u32 vtr_tag1, // first pushed tag - u32 vtr_tag2) // second pushed tag +/** + * Configure vtag tag rewrite on the given interface. + * Return 1 if there is an error, 0 if ok + */ +u32 +l2vtr_configure (vlib_main_t * vlib_main, vnet_main_t * vnet_main, u32 sw_if_index, u32 vtr_op, u32 push_dot1q, /* ethertype of first pushed tag is dot1q/dot1ad */ + u32 vtr_tag1, /* first pushed tag */ + u32 vtr_tag2) /* second pushed tag */ { - vnet_hw_interface_t * hi; - vnet_sw_interface_t * si; + vnet_hw_interface_t *hi; + vnet_sw_interface_t *si; u32 hw_no_tags; u32 error = 0; - vtr_config_t * in_config; - vtr_config_t * out_config; + vtr_config_t *in_config; + vtr_config_t *out_config; u32 enable; u32 push_inner_et; u32 push_outer_et; u32 cfg_tags; hi = vnet_get_sup_hw_interface (vnet_main, sw_if_index); - if (!hi || (hi->hw_class_index != ethernet_hw_interface_class.index)) { - error = VNET_API_ERROR_INVALID_INTERFACE; // non-ethernet interface - goto done; - } + if (!hi || (hi->hw_class_index != ethernet_hw_interface_class.index)) + { + error = VNET_API_ERROR_INVALID_INTERFACE; /* non-ethernet interface */ + goto done; + } - // Init the config for this interface + /* Init the config for this interface */ vec_validate (l2output_main.configs, sw_if_index); - in_config = &(vec_elt_at_index(l2output_main.configs, sw_if_index)->input_vtr); - out_config = &(vec_elt_at_index(l2output_main.configs, sw_if_index)->output_vtr); + in_config = + &(vec_elt_at_index (l2output_main.configs, sw_if_index)->input_vtr); + out_config = + &(vec_elt_at_index (l2output_main.configs, sw_if_index)->output_vtr); in_config->raw_tags = 0; out_config->raw_tags = 0; - // Get the configured tags for the interface + /* Get the configured tags for the interface */ si = vnet_get_sw_interface (vnet_main, sw_if_index); hw_no_tags = (si->type == VNET_SW_INTERFACE_TYPE_HARDWARE); - // Construct the input tag-rewrite config + /* Construct the input tag-rewrite config */ - push_outer_et = clib_net_to_host_u16 (push_dot1q ? ETHERNET_TYPE_VLAN : ETHERNET_TYPE_DOT1AD); + push_outer_et = + clib_net_to_host_u16 (push_dot1q ? ETHERNET_TYPE_VLAN : + ETHERNET_TYPE_DOT1AD); push_inner_et = clib_net_to_host_u16 (ETHERNET_TYPE_VLAN); vtr_tag1 = clib_net_to_host_u16 (vtr_tag1); vtr_tag2 = clib_net_to_host_u16 (vtr_tag2); - // Determine number of vlan tags with explictly configured values + /* Determine number of vlan tags with explictly configured values */ cfg_tags = 0; - if (hw_no_tags || si->sub.eth.flags.no_tags) { - cfg_tags = 0; - } else if (si->sub.eth.flags.one_tag) { - cfg_tags = 1; - if (si->sub.eth.flags.outer_vlan_id_any) { + if (hw_no_tags || si->sub.eth.flags.no_tags) + { cfg_tags = 0; } - } else if (si->sub.eth.flags.two_tags) { - cfg_tags = 2; - if (si->sub.eth.flags.inner_vlan_id_any) { + else if (si->sub.eth.flags.one_tag) + { cfg_tags = 1; + if (si->sub.eth.flags.outer_vlan_id_any) + { + cfg_tags = 0; + } } - if (si->sub.eth.flags.outer_vlan_id_any) { - cfg_tags = 0; + else if (si->sub.eth.flags.two_tags) + { + cfg_tags = 2; + if (si->sub.eth.flags.inner_vlan_id_any) + { + cfg_tags = 1; + } + if (si->sub.eth.flags.outer_vlan_id_any) + { + cfg_tags = 0; + } } - } - switch (vtr_op) { - case L2_VTR_DISABLED: - in_config->push_and_pop_bytes = 0; - break; + switch (vtr_op) + { + case L2_VTR_DISABLED: + in_config->push_and_pop_bytes = 0; + break; - case L2_VTR_POP_1: - if (cfg_tags < 1) { - error = VNET_API_ERROR_INVALID_VLAN_TAG_COUNT; // Need one or two tags - goto done; - } - in_config->pop_bytes = 4; - in_config->push_bytes = 0; - break; + case L2_VTR_POP_1: + if (cfg_tags < 1) + { + /* Need one or two tags */ + error = VNET_API_ERROR_INVALID_VLAN_TAG_COUNT; + goto done; + } + in_config->pop_bytes = 4; + in_config->push_bytes = 0; + break; - case L2_VTR_POP_2: - if (cfg_tags < 2) { - error = VNET_API_ERROR_INVALID_VLAN_TAG_COUNT; // Need two tags - goto done; - } - in_config->pop_bytes = 8; - in_config->push_bytes = 0; - - out_config->push_bytes = in_config->pop_bytes; - out_config->pop_bytes = in_config->push_bytes; - break; - - case L2_VTR_PUSH_1: - in_config->pop_bytes = 0; - in_config->push_bytes = 4; - in_config->tags[1].priority_cfi_and_id = vtr_tag1; - in_config->tags[1].type = push_outer_et; - break; - - case L2_VTR_PUSH_2: - in_config->pop_bytes = 0; - in_config->push_bytes = 8; - in_config->tags[0].priority_cfi_and_id = vtr_tag1; - in_config->tags[0].type = push_outer_et; - in_config->tags[1].priority_cfi_and_id = vtr_tag2; - in_config->tags[1].type = push_inner_et; - break; - - case L2_VTR_TRANSLATE_1_1: - if (cfg_tags < 1) { - error = VNET_API_ERROR_INVALID_VLAN_TAG_COUNT; // Need one or two tags - goto done; - } - in_config->pop_bytes = 4; - in_config->push_bytes = 4; - in_config->tags[1].priority_cfi_and_id = vtr_tag1; - in_config->tags[1].type = push_outer_et; - break; - - case L2_VTR_TRANSLATE_1_2: - if (cfg_tags < 1) { - error = VNET_API_ERROR_INVALID_VLAN_TAG_COUNT; // Need one or two tags - goto done; - } - in_config->pop_bytes = 4; - in_config->push_bytes = 8; - in_config->tags[0].priority_cfi_and_id = vtr_tag1; - in_config->tags[0].type = push_outer_et; - in_config->tags[1].priority_cfi_and_id = vtr_tag2; - in_config->tags[1].type = push_inner_et; - break; - - case L2_VTR_TRANSLATE_2_1: - if (cfg_tags < 2) { - error = VNET_API_ERROR_INVALID_VLAN_TAG_COUNT; // Need two tags - goto done; - } - in_config->pop_bytes = 8; - in_config->push_bytes = 4; - in_config->tags[1].priority_cfi_and_id = vtr_tag1; - in_config->tags[1].type = push_outer_et; - break; - - case L2_VTR_TRANSLATE_2_2: - if (cfg_tags < 2) { - error = VNET_API_ERROR_INVALID_VLAN_TAG_COUNT; // Need two tags - goto done; + case L2_VTR_POP_2: + if (cfg_tags < 2) + { + error = VNET_API_ERROR_INVALID_VLAN_TAG_COUNT; /* Need two tags */ + goto done; + } + in_config->pop_bytes = 8; + in_config->push_bytes = 0; + + out_config->push_bytes = in_config->pop_bytes; + out_config->pop_bytes = in_config->push_bytes; + break; + + case L2_VTR_PUSH_1: + in_config->pop_bytes = 0; + in_config->push_bytes = 4; + in_config->tags[1].priority_cfi_and_id = vtr_tag1; + in_config->tags[1].type = push_outer_et; + break; + + case L2_VTR_PUSH_2: + in_config->pop_bytes = 0; + in_config->push_bytes = 8; + in_config->tags[0].priority_cfi_and_id = vtr_tag1; + in_config->tags[0].type = push_outer_et; + in_config->tags[1].priority_cfi_and_id = vtr_tag2; + in_config->tags[1].type = push_inner_et; + break; + + case L2_VTR_TRANSLATE_1_1: + if (cfg_tags < 1) + { + error = VNET_API_ERROR_INVALID_VLAN_TAG_COUNT; /* Need one or two tags */ + goto done; + } + in_config->pop_bytes = 4; + in_config->push_bytes = 4; + in_config->tags[1].priority_cfi_and_id = vtr_tag1; + in_config->tags[1].type = push_outer_et; + break; + + case L2_VTR_TRANSLATE_1_2: + if (cfg_tags < 1) + { + error = VNET_API_ERROR_INVALID_VLAN_TAG_COUNT; /* Need one or two tags */ + goto done; + } + in_config->pop_bytes = 4; + in_config->push_bytes = 8; + in_config->tags[0].priority_cfi_and_id = vtr_tag1; + in_config->tags[0].type = push_outer_et; + in_config->tags[1].priority_cfi_and_id = vtr_tag2; + in_config->tags[1].type = push_inner_et; + break; + + case L2_VTR_TRANSLATE_2_1: + if (cfg_tags < 2) + { + error = VNET_API_ERROR_INVALID_VLAN_TAG_COUNT; /* Need two tags */ + goto done; + } + in_config->pop_bytes = 8; + in_config->push_bytes = 4; + in_config->tags[1].priority_cfi_and_id = vtr_tag1; + in_config->tags[1].type = push_outer_et; + break; + + case L2_VTR_TRANSLATE_2_2: + if (cfg_tags < 2) + { + error = VNET_API_ERROR_INVALID_VLAN_TAG_COUNT; /* Need two tags */ + goto done; + } + in_config->pop_bytes = 8; + in_config->push_bytes = 8; + in_config->tags[0].priority_cfi_and_id = vtr_tag1; + in_config->tags[0].type = push_outer_et; + in_config->tags[1].priority_cfi_and_id = vtr_tag2; + in_config->tags[1].type = push_inner_et; + break; } - in_config->pop_bytes = 8; - in_config->push_bytes = 8; - in_config->tags[0].priority_cfi_and_id = vtr_tag1; - in_config->tags[0].type = push_outer_et; - in_config->tags[1].priority_cfi_and_id = vtr_tag2; - in_config->tags[1].type = push_inner_et; - break; - } - - // Construct the output tag-rewrite config - - // The push/pop values are always reversed + + /* + * Construct the output tag-rewrite config + * + * The push/pop values are always reversed + */ out_config->push_bytes = in_config->pop_bytes; out_config->pop_bytes = in_config->push_bytes; - // Any pushed tags are derived from the subinterface config - push_outer_et = clib_net_to_host_u16 (si->sub.eth.flags.dot1ad ? ETHERNET_TYPE_DOT1AD : ETHERNET_TYPE_VLAN); + /* Any pushed tags are derived from the subinterface config */ + push_outer_et = + clib_net_to_host_u16 (si->sub.eth.flags.dot1ad ? ETHERNET_TYPE_DOT1AD : + ETHERNET_TYPE_VLAN); push_inner_et = clib_net_to_host_u16 (ETHERNET_TYPE_VLAN); vtr_tag1 = clib_net_to_host_u16 (si->sub.eth.outer_vlan_id); vtr_tag2 = clib_net_to_host_u16 (si->sub.eth.inner_vlan_id); - if (out_config->push_bytes == 4) { - out_config->tags[1].priority_cfi_and_id = vtr_tag1; - out_config->tags[1].type = push_outer_et; - } else if (out_config->push_bytes == 8) { - out_config->tags[0].priority_cfi_and_id = vtr_tag1; - out_config->tags[0].type = push_outer_et; - out_config->tags[1].priority_cfi_and_id = vtr_tag2; - out_config->tags[1].type = push_inner_et; - } - - // set the interface enable flags + if (out_config->push_bytes == 4) + { + out_config->tags[1].priority_cfi_and_id = vtr_tag1; + out_config->tags[1].type = push_outer_et; + } + else if (out_config->push_bytes == 8) + { + out_config->tags[0].priority_cfi_and_id = vtr_tag1; + out_config->tags[0].type = push_outer_et; + out_config->tags[1].priority_cfi_and_id = vtr_tag2; + out_config->tags[1].type = push_inner_et; + } + + /* set the interface enable flags */ enable = (vtr_op != L2_VTR_DISABLED); l2input_intf_bitmap_enable (sw_if_index, L2INPUT_FEAT_VTR, enable); - // output vtr enable is checked explicitly in l2_output + /* output vtr enable is checked explicitly in l2_output */ - done: +done: return error; } -// Get vtag tag rewrite on the given interface. -// Return 1 if there is an error, 0 if ok -u32 l2vtr_get (vlib_main_t * vlib_main, - vnet_main_t * vnet_main, - u32 sw_if_index, - u32 *vtr_op, - u32 *push_dot1q, // ethertype of first pushed tag is dot1q/dot1ad - u32 *vtr_tag1, // first pushed tag - u32 *vtr_tag2) // second pushed tag +/** + * Get vtag tag rewrite on the given interface. + * Return 1 if there is an error, 0 if ok + */ +u32 +l2vtr_get (vlib_main_t * vlib_main, vnet_main_t * vnet_main, u32 sw_if_index, u32 * vtr_op, u32 * push_dot1q, /* ethertype of first pushed tag is dot1q/dot1ad */ + u32 * vtr_tag1, /* first pushed tag */ + u32 * vtr_tag2) /* second pushed tag */ { - vnet_hw_interface_t * hi; + vnet_hw_interface_t *hi; u32 error = 0; - vtr_config_t * in_config; + vtr_config_t *in_config; - if (!vtr_op || !push_dot1q || !vtr_tag1 || !vtr_tag2) { - clib_warning ("invalid arguments"); - error = VNET_API_ERROR_INVALID_ARGUMENT; - goto done; - } + if (!vtr_op || !push_dot1q || !vtr_tag1 || !vtr_tag2) + { + clib_warning ("invalid arguments"); + error = VNET_API_ERROR_INVALID_ARGUMENT; + goto done; + } *vtr_op = L2_VTR_DISABLED; *vtr_tag1 = 0; @@ -251,198 +279,272 @@ u32 l2vtr_get (vlib_main_t * vlib_main, *push_dot1q = 0; hi = vnet_get_sup_hw_interface (vnet_main, sw_if_index); - if (!hi || (hi->hw_class_index != ethernet_hw_interface_class.index)) { - // non-ethernet interface - goto done; - } - - if (sw_if_index >= vec_len(l2output_main.configs)) { - // no specific config (return disabled) - goto done; - } - - // Get the config for this interface - in_config = &(vec_elt_at_index(l2output_main.configs, sw_if_index)->input_vtr); - - // DISABLED - if (in_config->push_and_pop_bytes == 0) { - goto done; - } - - // find out vtr_op - switch (in_config->pop_bytes) { + if (!hi || (hi->hw_class_index != ethernet_hw_interface_class.index)) + { + /* non-ethernet interface */ + goto done; + } + + if (sw_if_index >= vec_len (l2output_main.configs)) + { + /* no specific config (return disabled) */ + goto done; + } + + /* Get the config for this interface */ + in_config = + &(vec_elt_at_index (l2output_main.configs, sw_if_index)->input_vtr); + + /* DISABLED */ + if (in_config->push_and_pop_bytes == 0) + { + goto done; + } + + /* find out vtr_op */ + switch (in_config->pop_bytes) + { case 0: - switch (in_config->push_bytes) { - case 0: - // DISABLED - goto done; - case 4: - *vtr_op = L2_VTR_PUSH_1; - *vtr_tag1 = clib_host_to_net_u16 (in_config->tags[1].priority_cfi_and_id); - *push_dot1q = (ETHERNET_TYPE_VLAN == clib_host_to_net_u16 (in_config->tags[1].type)); - break; - case 8: - *vtr_op = L2_VTR_PUSH_2; - *vtr_tag1 = clib_host_to_net_u16 (in_config->tags[0].priority_cfi_and_id); - *vtr_tag2 = clib_host_to_net_u16 (in_config->tags[1].priority_cfi_and_id); - *push_dot1q = (ETHERNET_TYPE_VLAN == clib_host_to_net_u16 (in_config->tags[0].type)); - break; - default: - clib_warning ("invalid push_bytes count: %d", in_config->push_bytes); - error = VNET_API_ERROR_UNEXPECTED_INTF_STATE; - goto done; - } + switch (in_config->push_bytes) + { + case 0: + /* DISABLED */ + goto done; + case 4: + *vtr_op = L2_VTR_PUSH_1; + *vtr_tag1 = + clib_host_to_net_u16 (in_config->tags[1].priority_cfi_and_id); + *push_dot1q = + (ETHERNET_TYPE_VLAN == + clib_host_to_net_u16 (in_config->tags[1].type)); + break; + case 8: + *vtr_op = L2_VTR_PUSH_2; + *vtr_tag1 = + clib_host_to_net_u16 (in_config->tags[0].priority_cfi_and_id); + *vtr_tag2 = + clib_host_to_net_u16 (in_config->tags[1].priority_cfi_and_id); + *push_dot1q = + (ETHERNET_TYPE_VLAN == + clib_host_to_net_u16 (in_config->tags[0].type)); + break; + default: + clib_warning ("invalid push_bytes count: %d", + in_config->push_bytes); + error = VNET_API_ERROR_UNEXPECTED_INTF_STATE; + goto done; + } break; case 4: - switch (in_config->push_bytes) { - case 0: - *vtr_op = L2_VTR_POP_1; - break; - case 4: - *vtr_op = L2_VTR_TRANSLATE_1_1; - *vtr_tag1 = clib_host_to_net_u16 (in_config->tags[1].priority_cfi_and_id); - *push_dot1q = (ETHERNET_TYPE_VLAN == clib_host_to_net_u16 (in_config->tags[1].type)); - break; - case 8: - *vtr_op = L2_VTR_TRANSLATE_1_2; - *vtr_tag1 = clib_host_to_net_u16 (in_config->tags[0].priority_cfi_and_id); - *vtr_tag2 = clib_host_to_net_u16 (in_config->tags[1].priority_cfi_and_id); - *push_dot1q = (ETHERNET_TYPE_VLAN == clib_host_to_net_u16 (in_config->tags[0].type)); - break; - default: - clib_warning ("invalid push_bytes count: %d", in_config->push_bytes); - error = VNET_API_ERROR_UNEXPECTED_INTF_STATE; - goto done; - } + switch (in_config->push_bytes) + { + case 0: + *vtr_op = L2_VTR_POP_1; + break; + case 4: + *vtr_op = L2_VTR_TRANSLATE_1_1; + *vtr_tag1 = + clib_host_to_net_u16 (in_config->tags[1].priority_cfi_and_id); + *push_dot1q = + (ETHERNET_TYPE_VLAN == + clib_host_to_net_u16 (in_config->tags[1].type)); + break; + case 8: + *vtr_op = L2_VTR_TRANSLATE_1_2; + *vtr_tag1 = + clib_host_to_net_u16 (in_config->tags[0].priority_cfi_and_id); + *vtr_tag2 = + clib_host_to_net_u16 (in_config->tags[1].priority_cfi_and_id); + *push_dot1q = + (ETHERNET_TYPE_VLAN == + clib_host_to_net_u16 (in_config->tags[0].type)); + break; + default: + clib_warning ("invalid push_bytes count: %d", + in_config->push_bytes); + error = VNET_API_ERROR_UNEXPECTED_INTF_STATE; + goto done; + } break; case 8: - switch (in_config->push_bytes) { - case 0: - *vtr_op = L2_VTR_POP_2; - break; - case 4: - *vtr_op = L2_VTR_TRANSLATE_2_1; - *vtr_tag1 = clib_host_to_net_u16 (in_config->tags[1].priority_cfi_and_id); - *push_dot1q = (ETHERNET_TYPE_VLAN == clib_host_to_net_u16 (in_config->tags[1].type)); - break; - case 8: - *vtr_op = L2_VTR_TRANSLATE_2_2; - *vtr_tag1 = clib_host_to_net_u16 (in_config->tags[0].priority_cfi_and_id); - *vtr_tag2 = clib_host_to_net_u16 (in_config->tags[1].priority_cfi_and_id); - *push_dot1q = (ETHERNET_TYPE_VLAN == clib_host_to_net_u16 (in_config->tags[0].type)); - break; - default: - clib_warning ("invalid push_bytes count: %d", in_config->push_bytes); - error = VNET_API_ERROR_UNEXPECTED_INTF_STATE; - goto done; - } + switch (in_config->push_bytes) + { + case 0: + *vtr_op = L2_VTR_POP_2; + break; + case 4: + *vtr_op = L2_VTR_TRANSLATE_2_1; + *vtr_tag1 = + clib_host_to_net_u16 (in_config->tags[1].priority_cfi_and_id); + *push_dot1q = + (ETHERNET_TYPE_VLAN == + clib_host_to_net_u16 (in_config->tags[1].type)); + break; + case 8: + *vtr_op = L2_VTR_TRANSLATE_2_2; + *vtr_tag1 = + clib_host_to_net_u16 (in_config->tags[0].priority_cfi_and_id); + *vtr_tag2 = + clib_host_to_net_u16 (in_config->tags[1].priority_cfi_and_id); + *push_dot1q = + (ETHERNET_TYPE_VLAN == + clib_host_to_net_u16 (in_config->tags[0].type)); + break; + default: + clib_warning ("invalid push_bytes count: %d", + in_config->push_bytes); + error = VNET_API_ERROR_UNEXPECTED_INTF_STATE; + goto done; + } break; default: clib_warning ("invalid pop_bytes count: %d", in_config->pop_bytes); error = VNET_API_ERROR_UNEXPECTED_INTF_STATE; goto done; - } + } - done: +done: return error; } -// set subinterface vtr enable/disable -// The CLI format is: -// set interface l2 tag-rewrite [disable | pop 1 | pop 2 | push {dot1q|dot1ad} []] -// "push" can also be replaced by "translate-{1|2}-{1|2}" +/** + * set subinterface vtr enable/disable + * The CLI format is: + * set interface l2 tag-rewrite [disable | pop 1 | pop 2 | push {dot1q|dot1ad} []] + * + * "push" can also be replaced by "translate-{1|2}-{1|2}" + */ static clib_error_t * int_l2_vtr (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) + unformat_input_t * input, vlib_cli_command_t * cmd) { - vnet_main_t * vnm = vnet_get_main(); - clib_error_t * error = 0; + vnet_main_t *vnm = vnet_get_main (); + clib_error_t *error = 0; u32 sw_if_index; u32 vtr_op; u32 push_dot1q = 0; u32 tag1 = 0, tag2 = 0; - if (! unformat_user (input, unformat_vnet_sw_interface, vnm, &sw_if_index)) + if (!unformat_user (input, unformat_vnet_sw_interface, vnm, &sw_if_index)) { error = clib_error_return (0, "unknown interface `%U'", - format_unformat_error, input); + format_unformat_error, input); goto done; } vtr_op = L2_VTR_DISABLED; - if (unformat (input, "disable")) { - vtr_op = L2_VTR_DISABLED; - } else if (unformat (input, "pop 1")) { - vtr_op = L2_VTR_POP_1; - } else if (unformat (input, "pop 2")) { - vtr_op = L2_VTR_POP_2; - - } else if (unformat (input, "push dot1q %d %d", &tag1, &tag2)) { - vtr_op = L2_VTR_PUSH_2; - push_dot1q = 1; - } else if (unformat (input, "push dot1ad %d %d", &tag1, &tag2)) { - vtr_op = L2_VTR_PUSH_2; - - } else if (unformat (input, "push dot1q %d", &tag1)) { - vtr_op = L2_VTR_PUSH_1; - push_dot1q = 1; - } else if (unformat (input, "push dot1ad %d", &tag1)) { - vtr_op = L2_VTR_PUSH_1; - - } else if (unformat (input, "translate 1-1 dot1q %d", &tag1)) { - vtr_op = L2_VTR_TRANSLATE_1_1; - push_dot1q = 1; - } else if (unformat (input, "translate 1-1 dot1ad %d", &tag1)) { - vtr_op = L2_VTR_TRANSLATE_1_1; - - } else if (unformat (input, "translate 2-1 dot1q %d", &tag1)) { - vtr_op = L2_VTR_TRANSLATE_2_1; - push_dot1q = 1; - } else if (unformat (input, "translate 2-1 dot1ad %d", &tag1)) { - vtr_op = L2_VTR_TRANSLATE_2_1; - - } else if (unformat (input, "translate 2-2 dot1q %d %d", &tag1, &tag2)) { - vtr_op = L2_VTR_TRANSLATE_2_2; - push_dot1q = 1; - } else if (unformat (input, "translate 2-2 dot1ad %d %d", &tag1, &tag2)) { - vtr_op = L2_VTR_TRANSLATE_2_2; - - } else if (unformat (input, "translate 1-2 dot1q %d %d", &tag1, &tag2)) { - vtr_op = L2_VTR_TRANSLATE_1_2; - push_dot1q = 1; - } else if (unformat (input, "translate 1-2 dot1ad %d %d", &tag1, &tag2)) { - vtr_op = L2_VTR_TRANSLATE_1_2; - - } else { - error = clib_error_return (0, "expecting [disable | pop 1 | pop 2 | push {dot1q|dot1ah} []\n" - " | translate {1|2}-{1|2} {dot1q|dot1ah} []] but got `%U'", - format_unformat_error, input); - goto done; - } - - if (l2vtr_configure (vm, - vnm, - sw_if_index, - vtr_op, - push_dot1q, - tag1, - tag2)) { - error = clib_error_return (0, "vlan tag rewrite is not compatible with interface"); - goto done; - } - - done: + if (unformat (input, "disable")) + { + vtr_op = L2_VTR_DISABLED; + } + else if (unformat (input, "pop 1")) + { + vtr_op = L2_VTR_POP_1; + } + else if (unformat (input, "pop 2")) + { + vtr_op = L2_VTR_POP_2; + + } + else if (unformat (input, "push dot1q %d %d", &tag1, &tag2)) + { + vtr_op = L2_VTR_PUSH_2; + push_dot1q = 1; + } + else if (unformat (input, "push dot1ad %d %d", &tag1, &tag2)) + { + vtr_op = L2_VTR_PUSH_2; + + } + else if (unformat (input, "push dot1q %d", &tag1)) + { + vtr_op = L2_VTR_PUSH_1; + push_dot1q = 1; + } + else if (unformat (input, "push dot1ad %d", &tag1)) + { + vtr_op = L2_VTR_PUSH_1; + + } + else if (unformat (input, "translate 1-1 dot1q %d", &tag1)) + { + vtr_op = L2_VTR_TRANSLATE_1_1; + push_dot1q = 1; + } + else if (unformat (input, "translate 1-1 dot1ad %d", &tag1)) + { + vtr_op = L2_VTR_TRANSLATE_1_1; + + } + else if (unformat (input, "translate 2-1 dot1q %d", &tag1)) + { + vtr_op = L2_VTR_TRANSLATE_2_1; + push_dot1q = 1; + } + else if (unformat (input, "translate 2-1 dot1ad %d", &tag1)) + { + vtr_op = L2_VTR_TRANSLATE_2_1; + + } + else if (unformat (input, "translate 2-2 dot1q %d %d", &tag1, &tag2)) + { + vtr_op = L2_VTR_TRANSLATE_2_2; + push_dot1q = 1; + } + else if (unformat (input, "translate 2-2 dot1ad %d %d", &tag1, &tag2)) + { + vtr_op = L2_VTR_TRANSLATE_2_2; + + } + else if (unformat (input, "translate 1-2 dot1q %d %d", &tag1, &tag2)) + { + vtr_op = L2_VTR_TRANSLATE_1_2; + push_dot1q = 1; + } + else if (unformat (input, "translate 1-2 dot1ad %d %d", &tag1, &tag2)) + { + vtr_op = L2_VTR_TRANSLATE_1_2; + + } + else + { + error = + clib_error_return (0, + "expecting [disable | pop 1 | pop 2 | push {dot1q|dot1ah} []\n" + " | translate {1|2}-{1|2} {dot1q|dot1ah} []] but got `%U'", + format_unformat_error, input); + goto done; + } + + if (l2vtr_configure (vm, vnm, sw_if_index, vtr_op, push_dot1q, tag1, tag2)) + { + error = + clib_error_return (0, + "vlan tag rewrite is not compatible with interface"); + goto done; + } + +done: return error; } +/* *INDENT-OFF* */ VLIB_CLI_COMMAND (int_l2_vtr_cli, static) = { .path = "set interface l2 tag-rewrite", .short_help = "set interface l2 tag-rewrite [disable | pop {1|2} | push {dot1q|dot1ad} ]", .function = int_l2_vtr, }; +/* *INDENT-ON* */ + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/vnet/vnet/l2/l2_vtr.h b/vnet/vnet/l2/l2_vtr.h index ccd0920db52..5e41c6d91ad 100644 --- a/vnet/vnet/l2/l2_vtr.h +++ b/vnet/vnet/l2/l2_vtr.h @@ -23,8 +23,9 @@ #include #include -// VTR config options for API and CLI support -typedef enum { +/* VTR config options for API and CLI support */ +typedef enum +{ L2_VTR_DISABLED, L2_VTR_PUSH_1, L2_VTR_PUSH_2, @@ -36,136 +37,167 @@ typedef enum { L2_VTR_TRANSLATE_2_2 } l2_vtr_op_t; -// Per-interface vlan tag rewrite configuration -// There will be one instance of this struct for each sw_if_index -// for both input vtr and output vtr -typedef struct { - union { - // Up to two vlan tags to push. - // if there is only one vlan tag to push, it is in tags[1]. +/** + * Per-interface vlan tag rewrite configuration + * There will be one instance of this struct for each sw_if_index + * for both input vtr and output vtr + */ +typedef struct +{ + union + { + /* + * Up to two vlan tags to push. + * if there is only one vlan tag to push, it is in tags[1]. + */ ethernet_vlan_header_tv_t tags[2]; u64 raw_tags; }; - union { - struct { - u8 push_bytes; // number of bytes to push for up to 2 vlans (0,4,8) - u8 pop_bytes; // number of bytes to pop for up to 2 vlans (0,4,8) + union + { + struct + { + u8 push_bytes; /* number of bytes to push for up to 2 vlans (0,4,8) */ + u8 pop_bytes; /* number of bytes to pop for up to 2 vlans (0,4,8) */ }; - u16 push_and_pop_bytes; // if 0 then the feature is disabled + u16 push_and_pop_bytes; /* if 0 then the feature is disabled */ }; } vtr_config_t; -// Perform the configured tag rewrite on the packet. -// Return 0 if ok, 1 if packet should be dropped (e.g. tried to pop too many tags) +/** + * Perform the configured tag rewrite on the packet. + * Return 0 if ok, 1 if packet should be dropped (e.g. tried to pop + * too many tags) + */ always_inline u32 -l2_vtr_process (vlib_buffer_t * b0, - vtr_config_t * config) +l2_vtr_process (vlib_buffer_t * b0, vtr_config_t * config) { u64 temp_8; u32 temp_4; - u8 * eth; + u8 *eth; eth = vlib_buffer_get_current (b0); - // copy the 12B dmac and smac to a temporary location - temp_8 = *((u64 *)eth); - temp_4 = *((u32 *)(eth+8)); + /* copy the 12B dmac and smac to a temporary location */ + temp_8 = *((u64 *) eth); + temp_4 = *((u32 *) (eth + 8)); - // adjust for popped tags + /* adjust for popped tags */ eth += config->pop_bytes; - // if not enough tags to pop then drop packet - if (PREDICT_FALSE ((vnet_buffer(b0)->l2.l2_len - 12) < config->pop_bytes)) { - return 1; - } + /* if not enough tags to pop then drop packet */ + if (PREDICT_FALSE ((vnet_buffer (b0)->l2.l2_len - 12) < config->pop_bytes)) + { + return 1; + } - // copy the 2 new tags to the start of the packet - *((u64 *)(eth + 12 - 8)) = config->raw_tags; + /* copy the 2 new tags to the start of the packet */ + *((u64 *) (eth + 12 - 8)) = config->raw_tags; - // TODO: set cos bits + /* TODO: set cos bits */ - // adjust for pushed tags: + /* adjust for pushed tags: */ eth -= config->push_bytes; - // copy the 12 dmac and smac back to the packet - *((u64 *)eth) = temp_8; - *((u32 *)(eth+8)) = temp_4; + /* copy the 12 dmac and smac back to the packet */ + *((u64 *) eth) = temp_8; + *((u32 *) (eth + 8)) = temp_4; - // Update l2_len - vnet_buffer(b0)->l2.l2_len += (word)config->push_bytes - (word)config->pop_bytes; + /* Update l2_len */ + vnet_buffer (b0)->l2.l2_len += + (word) config->push_bytes - (word) config->pop_bytes; - // Update vlan tag count - ethernet_buffer_adjust_vlan_count_by_bytes(b0, - (word)config->push_bytes - (word)config->pop_bytes); + /* Update vlan tag count */ + ethernet_buffer_adjust_vlan_count_by_bytes (b0, + (word) config->push_bytes - + (word) config->pop_bytes); - // Update packet len - vlib_buffer_advance(b0, (word)config->pop_bytes - (word)config->push_bytes); + /* Update packet len */ + vlib_buffer_advance (b0, + (word) config->pop_bytes - (word) config->push_bytes); return 0; } -// Perform the egress pre-vlan tag rewrite EFP Filter check. The post-vlan tag rewrite -// check is a separate graph node. -// -// This check insures that a packet being output to an interface (before output vtr -// is performed) has vlan tags that match those on a packet received from that -// interface (after vtr has been performed). -// This means verifying that any tags pushed by input vtr are present on the packet. -// -// Return 0 if ok, 1 if packet should be dropped. -// This function should be passed the input vtr config for the interface. +/* + * Perform the egress pre-vlan tag rewrite EFP Filter check. + * The post-vlan tag rewrite check is a separate graph node. + * + * This check insures that a packet being output to an interface + * (before output vtr is performed) has vlan tags that match those + * on a packet received from that interface (after vtr has been performed). + * This means verifying that any tags pushed by input vtr are present + * on the packet. + * + * Return 0 if ok, 1 if packet should be dropped. + * This function should be passed the input vtr config for the interface. + */ always_inline u8 -l2_efp_filter_process (vlib_buffer_t * b0, - vtr_config_t * in_config) +l2_efp_filter_process (vlib_buffer_t * b0, vtr_config_t * in_config) { - u8 * eth; + u8 *eth; u64 packet_tags; u64 tag_mask; eth = vlib_buffer_get_current (b0); - // If there are 2 tags pushed, they must match config->tags[0] and config->tags[1]. - // If there is one tag pushed, it must match config->tag[1]. - // If there are 0 tags pushed, the check passes. - - // mask for two vlan id and ethertypes, no cos bits - tag_mask = clib_net_to_host_u64(0xFFFF0FFFFFFF0FFF); - // mask for one vlan id and ethertype, no cos bits - tag_mask = (in_config->push_bytes == 4) ? clib_net_to_host_u64(0xFFFF0FFF) : tag_mask; - // mask for always match + /* + * If there are 2 tags pushed, they must match config->tags[0] and + * config->tags[1]. + * If there is one tag pushed, it must match config->tag[1]. + * If there are 0 tags pushed, the check passes. + */ + + /* mask for two vlan id and ethertypes, no cos bits */ + tag_mask = clib_net_to_host_u64 (0xFFFF0FFFFFFF0FFF); + /* mask for one vlan id and ethertype, no cos bits */ + tag_mask = + (in_config->push_bytes == + 4) ? clib_net_to_host_u64 (0xFFFF0FFF) : tag_mask; + /* mask for always match */ tag_mask = (in_config->push_bytes == 0) ? 0 : tag_mask; - // Read 8B from the packet, getting the proper set of vlan tags - // For 0 push bytes, the address doesn't matter since the mask clears the data to 0. - packet_tags = *((u64 *)(eth + 4 + in_config->push_bytes)); + /* + * Read 8B from the packet, getting the proper set of vlan tags + * For 0 push bytes, the address doesn't matter since the mask + * clears the data to 0. + */ + packet_tags = *((u64 *) (eth + 4 + in_config->push_bytes)); - // Check if the packet tags match the configured tags + /* Check if the packet tags match the configured tags */ return (packet_tags & tag_mask) != in_config->raw_tags; } -// Configure vtag tag rewrite on the given interface. -// Return 1 if there is an error, 0 if ok -u32 l2vtr_configure(vlib_main_t * vlib_main, - vnet_main_t * vnet_main, - u32 sw_if_index, - u32 vtr_op, - u32 push_dot1q, - u32 vtr_tag1, - u32 vtr_tag2); - -// Get vtag tag rewrite on the given interface. -// Return 1 if there is an error, 0 if ok +/** + * Configure vtag tag rewrite on the given interface. + * Return 1 if there is an error, 0 if ok + */ +u32 l2vtr_configure (vlib_main_t * vlib_main, + vnet_main_t * vnet_main, + u32 sw_if_index, + u32 vtr_op, u32 push_dot1q, u32 vtr_tag1, u32 vtr_tag2); + +/** + * Get vtag tag rewrite on the given interface. + * Return 1 if there is an error, 0 if ok + */ u32 l2vtr_get (vlib_main_t * vlib_main, - vnet_main_t * vnet_main, - u32 sw_if_index, - u32 *vtr_op, - u32 *push_dot1q, - u32 *vtr_tag1, - u32 *vtr_tag2); + vnet_main_t * vnet_main, + u32 sw_if_index, + u32 * vtr_op, + u32 * push_dot1q, u32 * vtr_tag1, u32 * vtr_tag2); -#endif // included_vnet_l2_vtr_h +#endif /* included_vnet_l2_vtr_h */ + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/vnet/vnet/l2/l2_xcrw.c b/vnet/vnet/l2/l2_xcrw.c index 00542a19f80..95219e6e9f0 100644 --- a/vnet/vnet/l2/l2_xcrw.c +++ b/vnet/vnet/l2/l2_xcrw.c @@ -14,7 +14,7 @@ */ #include -/* +/* * General L2 / L3 cross-connect, used to set up * "L2 interface <--> your-favorite-tunnel-encap" tunnels. * @@ -22,35 +22,37 @@ * to hook L2 interface(s) up to the L3 stack in arbitrary ways. * * Each l2_xcrw adjacency specifies 3 things: - * + * * 1. The next graph node (presumably in the L3 stack) to * process the (L2 -> L3) packet * - * 2. A new value for vnet_buffer(b)->sw_if_index[VLIB_TX] + * 2. A new value for vnet_buffer(b)->sw_if_index[VLIB_TX] * (i.e. a lookup FIB index), * * 3. A rewrite string to apply. * * Example: to cross-connect an L2 interface or (future) bridge - * to an mpls-o-gre tunnel, set up the L2 rewrite string as shown in + * to an mpls-o-gre tunnel, set up the L2 rewrite string as shown in * mpls_gre_rewrite, and use "mpls-post-rewrite" to fix the * GRE IP header checksum and length fields. */ -typedef struct { +typedef struct +{ u32 next_index; u32 tx_fib_index; } l2_xcrw_trace_t; /* packet trace format function */ -static u8 * format_l2_xcrw_trace (u8 * s, va_list * args) +static u8 * +format_l2_xcrw_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 *); - l2_xcrw_trace_t * t = va_arg (*args, l2_xcrw_trace_t *); - + l2_xcrw_trace_t *t = va_arg (*args, l2_xcrw_trace_t *); + s = format (s, "L2_XCRW: next index %d tx_fib_index %d", - t->next_index, t->tx_fib_index); + t->next_index, t->tx_fib_index); return s; } @@ -58,7 +60,7 @@ l2_xcrw_main_t l2_xcrw_main; static vlib_node_registration_t l2_xcrw_node; -static char * l2_xcrw_error_strings[] = { +static char *l2_xcrw_error_strings[] = { #define _(sym,string) string, foreach_l2_xcrw_error #undef _ @@ -66,15 +68,14 @@ static char * l2_xcrw_error_strings[] = { static uword l2_xcrw_node_fn (vlib_main_t * vm, - vlib_node_runtime_t * node, - vlib_frame_t * frame) + vlib_node_runtime_t * node, vlib_frame_t * frame) { - u32 n_left_from, * from, * to_next; + u32 n_left_from, *from, *to_next; l2_xcrw_next_t next_index; - l2_xcrw_main_t * xcm = &l2_xcrw_main; + l2_xcrw_main_t *xcm = &l2_xcrw_main; vlib_node_t *n = vlib_get_node (vm, l2_xcrw_node.index); u32 node_counter_base_index = n->error_heap_index; - vlib_error_main_t * em = &vm->error_main; + vlib_error_main_t *em = &vm->error_main; from = vlib_frame_vector_args (frame); n_left_from = frame->n_vectors; @@ -84,24 +85,23 @@ l2_xcrw_node_fn (vlib_main_t * vm, { u32 n_left_to_next; - vlib_get_next_frame (vm, node, next_index, - to_next, n_left_to_next); + vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next); while (n_left_from >= 4 && n_left_to_next >= 2) { - u32 bi0, bi1; - vlib_buffer_t * b0, * b1; - u32 next0, next1; - u32 sw_if_index0, sw_if_index1; - l2_xcrw_adjacency_t * adj0, * adj1; - + u32 bi0, bi1; + vlib_buffer_t *b0, *b1; + u32 next0, next1; + u32 sw_if_index0, sw_if_index1; + l2_xcrw_adjacency_t *adj0, *adj1; + /* Prefetch next iteration. */ { - vlib_buffer_t * p2, * p3; - + vlib_buffer_t *p2, *p3; + p2 = vlib_get_buffer (vm, from[2]); p3 = vlib_get_buffer (vm, from[3]); - + vlib_prefetch_buffer_header (p2, LOAD); vlib_prefetch_buffer_header (p3, LOAD); @@ -109,7 +109,7 @@ l2_xcrw_node_fn (vlib_main_t * vm, CLIB_PREFETCH (p3->data, CLIB_CACHE_LINE_BYTES, STORE); } - /* speculatively enqueue b0 and b1 to the current next frame */ + /* speculatively enqueue b0 and b1 to the current next frame */ to_next[0] = bi0 = from[0]; to_next[1] = bi1 = from[1]; from += 2; @@ -120,76 +120,76 @@ l2_xcrw_node_fn (vlib_main_t * vm, b0 = vlib_get_buffer (vm, bi0); b1 = vlib_get_buffer (vm, bi1); - sw_if_index0 = vnet_buffer(b0)->sw_if_index[VLIB_RX]; - sw_if_index1 = vnet_buffer(b1)->sw_if_index[VLIB_RX]; - - adj0 = vec_elt_at_index (xcm->adj_by_sw_if_index, sw_if_index0); - adj1 = vec_elt_at_index (xcm->adj_by_sw_if_index, sw_if_index1); - - next0 = adj0->rewrite_header.next_index; - vnet_buffer(b0)->sw_if_index[VLIB_TX] = - adj0->rewrite_header.sw_if_index; - - next1 = adj1->rewrite_header.next_index; - vnet_buffer(b1)->sw_if_index[VLIB_TX] = - adj1->rewrite_header.sw_if_index; - - em->counters[node_counter_base_index + next1]++; - - if (PREDICT_TRUE(next0 > 0)) - { - u8 * h0 = vlib_buffer_get_current (b0); - vnet_rewrite_one_header (adj0[0], h0, - adj0->rewrite_header.data_bytes); - vlib_buffer_advance (b0, -adj0->rewrite_header.data_bytes); - em->counters[node_counter_base_index + L2_XCRW_ERROR_FWD]++; - } - - if (PREDICT_TRUE(next1 > 0)) - { - u8 * h1 = vlib_buffer_get_current (b1); - vnet_rewrite_one_header (adj1[0], h1, - adj1->rewrite_header.data_bytes); - vlib_buffer_advance (b1, -adj1->rewrite_header.data_bytes); - em->counters[node_counter_base_index + L2_XCRW_ERROR_FWD]++; - } - - - if (PREDICT_FALSE((node->flags & VLIB_NODE_FLAG_TRACE))) - { - if (PREDICT_FALSE((node->flags & VLIB_NODE_FLAG_TRACE) - && (b0->flags & VLIB_BUFFER_IS_TRACED))) - { - l2_xcrw_trace_t *t = - vlib_add_trace (vm, node, b0, sizeof (*t)); - t->next_index = next0; - t->tx_fib_index = adj0->rewrite_header.sw_if_index; - } - if (PREDICT_FALSE((node->flags & VLIB_NODE_FLAG_TRACE) - && (b1->flags & VLIB_BUFFER_IS_TRACED))) - { - l2_xcrw_trace_t *t = - vlib_add_trace (vm, node, b1, sizeof (*t)); - t->next_index = next1; - t->tx_fib_index = adj1->rewrite_header.sw_if_index; - } - } - - /* verify speculative enqueues, maybe switch current next frame */ - vlib_validate_buffer_enqueue_x2 (vm, node, next_index, - to_next, n_left_to_next, - bi0, bi1, next0, next1); - } - + sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX]; + sw_if_index1 = vnet_buffer (b1)->sw_if_index[VLIB_RX]; + + adj0 = vec_elt_at_index (xcm->adj_by_sw_if_index, sw_if_index0); + adj1 = vec_elt_at_index (xcm->adj_by_sw_if_index, sw_if_index1); + + next0 = adj0->rewrite_header.next_index; + vnet_buffer (b0)->sw_if_index[VLIB_TX] = + adj0->rewrite_header.sw_if_index; + + next1 = adj1->rewrite_header.next_index; + vnet_buffer (b1)->sw_if_index[VLIB_TX] = + adj1->rewrite_header.sw_if_index; + + em->counters[node_counter_base_index + next1]++; + + if (PREDICT_TRUE (next0 > 0)) + { + u8 *h0 = vlib_buffer_get_current (b0); + vnet_rewrite_one_header (adj0[0], h0, + adj0->rewrite_header.data_bytes); + vlib_buffer_advance (b0, -adj0->rewrite_header.data_bytes); + em->counters[node_counter_base_index + L2_XCRW_ERROR_FWD]++; + } + + if (PREDICT_TRUE (next1 > 0)) + { + u8 *h1 = vlib_buffer_get_current (b1); + vnet_rewrite_one_header (adj1[0], h1, + adj1->rewrite_header.data_bytes); + vlib_buffer_advance (b1, -adj1->rewrite_header.data_bytes); + em->counters[node_counter_base_index + L2_XCRW_ERROR_FWD]++; + } + + + if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE))) + { + if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE) + && (b0->flags & VLIB_BUFFER_IS_TRACED))) + { + l2_xcrw_trace_t *t = + vlib_add_trace (vm, node, b0, sizeof (*t)); + t->next_index = next0; + t->tx_fib_index = adj0->rewrite_header.sw_if_index; + } + if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE) + && (b1->flags & VLIB_BUFFER_IS_TRACED))) + { + l2_xcrw_trace_t *t = + vlib_add_trace (vm, node, b1, sizeof (*t)); + t->next_index = next1; + t->tx_fib_index = adj1->rewrite_header.sw_if_index; + } + } + + /* verify speculative enqueues, maybe switch current next frame */ + vlib_validate_buffer_enqueue_x2 (vm, node, next_index, + to_next, n_left_to_next, + bi0, bi1, next0, next1); + } + while (n_left_from > 0 && n_left_to_next > 0) { - u32 bi0; - vlib_buffer_t * b0; - u32 next0; - u32 sw_if_index0; - l2_xcrw_adjacency_t * adj0; - - /* speculatively enqueue b0 to the current next frame */ + u32 bi0; + vlib_buffer_t *b0; + u32 next0; + u32 sw_if_index0; + l2_xcrw_adjacency_t *adj0; + + /* speculatively enqueue b0 to the current next frame */ bi0 = from[0]; to_next[0] = bi0; from += 1; @@ -199,33 +199,32 @@ l2_xcrw_node_fn (vlib_main_t * vm, b0 = vlib_get_buffer (vm, bi0); - sw_if_index0 = vnet_buffer(b0)->sw_if_index[VLIB_RX]; - - adj0 = vec_elt_at_index (xcm->adj_by_sw_if_index, sw_if_index0); - - next0 = adj0->rewrite_header.next_index; - vnet_buffer(b0)->sw_if_index[VLIB_TX] = - adj0->rewrite_header.sw_if_index; - - if (PREDICT_TRUE(next0 > 0)) - { - u8 *h0 = vlib_buffer_get_current (b0); - vnet_rewrite_one_header (adj0[0], h0, - adj0->rewrite_header.data_bytes); - vlib_buffer_advance (b0, -adj0->rewrite_header.data_bytes); - em->counters[node_counter_base_index + L2_XCRW_ERROR_FWD]++; - } - - if (PREDICT_FALSE((node->flags & VLIB_NODE_FLAG_TRACE) - && (b0->flags & VLIB_BUFFER_IS_TRACED))) - { - l2_xcrw_trace_t *t = - vlib_add_trace (vm, node, b0, sizeof (*t)); - t->next_index = next0; - t->tx_fib_index = adj0->rewrite_header.sw_if_index; - } - - /* verify speculative enqueue, maybe switch current next frame */ + sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX]; + + adj0 = vec_elt_at_index (xcm->adj_by_sw_if_index, sw_if_index0); + + next0 = adj0->rewrite_header.next_index; + vnet_buffer (b0)->sw_if_index[VLIB_TX] = + adj0->rewrite_header.sw_if_index; + + if (PREDICT_TRUE (next0 > 0)) + { + u8 *h0 = vlib_buffer_get_current (b0); + vnet_rewrite_one_header (adj0[0], h0, + adj0->rewrite_header.data_bytes); + vlib_buffer_advance (b0, -adj0->rewrite_header.data_bytes); + em->counters[node_counter_base_index + L2_XCRW_ERROR_FWD]++; + } + + if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE) + && (b0->flags & VLIB_BUFFER_IS_TRACED))) + { + l2_xcrw_trace_t *t = vlib_add_trace (vm, node, b0, sizeof (*t)); + t->next_index = next0; + t->tx_fib_index = adj0->rewrite_header.sw_if_index; + } + + /* verify speculative enqueue, maybe switch current next frame */ vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next, n_left_to_next, bi0, next0); @@ -237,13 +236,14 @@ l2_xcrw_node_fn (vlib_main_t * vm, return frame->n_vectors; } +/* *INDENT-OFF* */ VLIB_REGISTER_NODE (l2_xcrw_node, static) = { .function = l2_xcrw_node_fn, .name = "l2-xcrw", .vector_size = sizeof (u32), .format_trace = format_l2_xcrw_trace, .type = VLIB_NODE_TYPE_INTERNAL, - + .n_errors = ARRAY_LEN(l2_xcrw_error_strings), .error_strings = l2_xcrw_error_strings, @@ -254,51 +254,54 @@ VLIB_REGISTER_NODE (l2_xcrw_node, static) = { [L2_XCRW_NEXT_DROP] = "error-drop", }, }; +/* *INDENT-ON* */ VLIB_NODE_FUNCTION_MULTIARCH (l2_xcrw_node, l2_xcrw_node_fn) - -clib_error_t *l2_xcrw_init (vlib_main_t *vm) + clib_error_t *l2_xcrw_init (vlib_main_t * vm) { - l2_xcrw_main_t * mp = &l2_xcrw_main; - + l2_xcrw_main_t *mp = &l2_xcrw_main; + mp->vlib_main = vm; mp->vnet_main = &vnet_main; - mp->tunnel_index_by_l2_sw_if_index = hash_create (0, sizeof(uword)); + mp->tunnel_index_by_l2_sw_if_index = hash_create (0, sizeof (uword)); return 0; } VLIB_INIT_FUNCTION (l2_xcrw_init); -static uword dummy_interface_tx (vlib_main_t * vm, - vlib_node_runtime_t * node, - vlib_frame_t * frame) +static uword +dummy_interface_tx (vlib_main_t * vm, + vlib_node_runtime_t * node, vlib_frame_t * frame) { clib_warning ("you shouldn't be here, leaking buffers..."); return frame->n_vectors; } -static u8 * format_xcrw_name (u8 * s, va_list * args) +static u8 * +format_xcrw_name (u8 * s, va_list * args) { u32 dev_instance = va_arg (*args, u32); return format (s, "xcrw%d", dev_instance); } +/* *INDENT-OFF* */ VNET_DEVICE_CLASS (xcrw_device_class,static) = { .name = "Xcrw", .format_device_name = format_xcrw_name, .tx_function = dummy_interface_tx, }; +/* *INDENT-ON* */ /* Create a sham tunnel interface and return its sw_if_index */ static u32 create_xcrw_interface (vlib_main_t * vm) { - vnet_main_t * vnm = vnet_get_main(); + vnet_main_t *vnm = vnet_get_main (); static u32 instance; u8 address[6]; u32 hw_if_index; - vnet_hw_interface_t * hi; + vnet_hw_interface_t *hi; u32 sw_if_index; /* mac address doesn't really matter */ @@ -307,17 +310,13 @@ create_xcrw_interface (vlib_main_t * vm) /* can returns error iff phy != 0 */ (void) ethernet_register_interface - (vnm, - xcrw_device_class.index, - instance++, - address, - &hw_if_index, + (vnm, xcrw_device_class.index, instance++, address, &hw_if_index, /* flag change */ 0); hi = vnet_get_hw_interface (vnm, hw_if_index); sw_if_index = hi->sw_if_index; - vnet_sw_interface_set_flags (vnm, sw_if_index, - VNET_SW_INTERFACE_FLAG_ADMIN_UP); + vnet_sw_interface_set_flags (vnm, sw_if_index, + VNET_SW_INTERFACE_FLAG_ADMIN_UP); /* Output to the sham tunnel invokes the encap node */ hi->output_node_index = l2_xcrw_node.index; @@ -325,15 +324,16 @@ create_xcrw_interface (vlib_main_t * vm) return sw_if_index; } -int vnet_configure_l2_xcrw (vlib_main_t * vm, vnet_main_t *vnm, - u32 l2_sw_if_index, u32 tx_fib_index, - u8 * rewrite, u32 next_node_index, int is_add) +int +vnet_configure_l2_xcrw (vlib_main_t * vm, vnet_main_t * vnm, + u32 l2_sw_if_index, u32 tx_fib_index, + u8 * rewrite, u32 next_node_index, int is_add) { - l2_xcrw_main_t * xcm = &l2_xcrw_main; - l2_xcrw_adjacency_t * a; - l2_xcrw_tunnel_t * t; - uword * p; - + l2_xcrw_main_t *xcm = &l2_xcrw_main; + l2_xcrw_adjacency_t *a; + l2_xcrw_tunnel_t *t; + uword *p; + if (is_add) { @@ -341,41 +341,41 @@ int vnet_configure_l2_xcrw (vlib_main_t * vm, vnet_main_t *vnm, /* No interface allocated? Do it. Otherwise, set admin up */ if (t->tunnel_sw_if_index == 0) - t->tunnel_sw_if_index = create_xcrw_interface (vm); + t->tunnel_sw_if_index = create_xcrw_interface (vm); else - vnet_sw_interface_set_flags (vnm, t->tunnel_sw_if_index, - VNET_SW_INTERFACE_FLAG_ADMIN_UP); - + vnet_sw_interface_set_flags (vnm, t->tunnel_sw_if_index, + VNET_SW_INTERFACE_FLAG_ADMIN_UP); + t->l2_sw_if_index = l2_sw_if_index; vec_validate (xcm->adj_by_sw_if_index, t->l2_sw_if_index); - + a = vec_elt_at_index (xcm->adj_by_sw_if_index, t->l2_sw_if_index); memset (a, 0, sizeof (*a)); a->rewrite_header.sw_if_index = tx_fib_index; - /* - * Add or find a dynamic disposition for the successor node, + /* + * Add or find a dynamic disposition for the successor node, * e.g. so we can ship pkts to mpls_post_rewrite... */ - a->rewrite_header.next_index = - vlib_node_add_next (vm, l2_xcrw_node.index, next_node_index); + a->rewrite_header.next_index = + vlib_node_add_next (vm, l2_xcrw_node.index, next_node_index); if (vec_len (rewrite)) - vnet_rewrite_set_data (a[0], rewrite, vec_len(rewrite)); - - set_int_l2_mode (vm, vnm, MODE_L2_XC, t->l2_sw_if_index, 0, 0, 0, - t->tunnel_sw_if_index); - hash_set (xcm->tunnel_index_by_l2_sw_if_index, - t->l2_sw_if_index, t - xcm->tunnels); + vnet_rewrite_set_data (a[0], rewrite, vec_len (rewrite)); + + set_int_l2_mode (vm, vnm, MODE_L2_XC, t->l2_sw_if_index, 0, 0, 0, + t->tunnel_sw_if_index); + hash_set (xcm->tunnel_index_by_l2_sw_if_index, + t->l2_sw_if_index, t - xcm->tunnels); return 0; } else { p = hash_get (xcm->tunnel_index_by_l2_sw_if_index, l2_sw_if_index); if (p == 0) - return VNET_API_ERROR_INVALID_SW_IF_INDEX; + return VNET_API_ERROR_INVALID_SW_IF_INDEX; t = pool_elt_at_index (xcm->tunnels, p[0]); @@ -385,7 +385,7 @@ int vnet_configure_l2_xcrw (vlib_main_t * vm, vnet_main_t *vnm, set_int_l2_mode (vm, vnm, MODE_L3, t->l2_sw_if_index, 0, 0, 0, 0); - vnet_sw_interface_set_flags (vnm, t->tunnel_sw_if_index, 0 /* down */); + vnet_sw_interface_set_flags (vnm, t->tunnel_sw_if_index, 0 /* down */ ); hash_unset (xcm->tunnel_index_by_l2_sw_if_index, l2_sw_if_index); pool_put (xcm->tunnels, t); @@ -396,67 +396,64 @@ int vnet_configure_l2_xcrw (vlib_main_t * vm, vnet_main_t *vnm, static clib_error_t * set_l2_xcrw_command_fn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) + unformat_input_t * input, vlib_cli_command_t * cmd) { - unformat_input_t _line_input, * line_input = &_line_input; + unformat_input_t _line_input, *line_input = &_line_input; int is_add = 1; - int is_ipv6 = 0; /* for fib id -> fib index mapping */ + int is_ipv6 = 0; /* for fib id -> fib index mapping */ u32 tx_fib_id = ~0; u32 tx_fib_index = ~0; u32 next_node_index = ~0; u32 l2_sw_if_index; - u8 * rw = 0; - vnet_main_t * vnm = vnet_get_main(); + u8 *rw = 0; + vnet_main_t *vnm = vnet_get_main (); int rv; - - - if (! unformat_user (input, unformat_line_input, line_input)) + + + if (!unformat_user (input, unformat_line_input, line_input)) return 0; - - if (! unformat (line_input, "%U", - unformat_vnet_sw_interface, vnm, &l2_sw_if_index)) + + if (!unformat (line_input, "%U", + unformat_vnet_sw_interface, vnm, &l2_sw_if_index)) return clib_error_return (0, "unknown input '%U'", - format_unformat_error, line_input); - + format_unformat_error, line_input); + while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) { - if (unformat (line_input, "next %U", - unformat_vlib_node, vm, &next_node_index)) - ; + if (unformat (line_input, "next %U", + unformat_vlib_node, vm, &next_node_index)) + ; else if (unformat (line_input, "tx-fib-id %d", &tx_fib_id)) - ; + ; else if (unformat (line_input, "del")) - is_add = 0; + is_add = 0; else if (unformat (line_input, "ipv6")) - is_ipv6 = 1; - else if (unformat (line_input, "rw %U", - unformat_hex_string, &rw)); + is_ipv6 = 1; + else if (unformat (line_input, "rw %U", unformat_hex_string, &rw)); else - break; + break; } - + if (next_node_index == ~0) return clib_error_return (0, "next node not specified"); - + if (tx_fib_id != ~0) { - uword * p; + uword *p; if (is_ipv6) - p = hash_get (ip6_main.fib_index_by_table_id, tx_fib_id); + p = hash_get (ip6_main.fib_index_by_table_id, tx_fib_id); else - p = hash_get (ip4_main.fib_index_by_table_id, tx_fib_id); + p = hash_get (ip4_main.fib_index_by_table_id, tx_fib_id); if (p == 0) - return clib_error_return (0, "nonexistent tx_fib_id %d", - tx_fib_id); + return clib_error_return (0, "nonexistent tx_fib_id %d", tx_fib_id); tx_fib_index = p[0]; } rv = vnet_configure_l2_xcrw (vm, vnm, l2_sw_if_index, tx_fib_index, - rw, next_node_index, is_add); + rw, next_node_index, is_add); switch (rv) { @@ -466,34 +463,36 @@ set_l2_xcrw_command_fn (vlib_main_t * vm, case VNET_API_ERROR_INVALID_SW_IF_INDEX: return clib_error_return (0, "%U not cross-connected", - format_vnet_sw_if_index_name, - vnm, l2_sw_if_index); + format_vnet_sw_if_index_name, + vnm, l2_sw_if_index); default: - return clib_error_return (0, "vnet_configure_l2_xcrw returned %d", - rv); + return clib_error_return (0, "vnet_configure_l2_xcrw returned %d", rv); } - + vec_free (rw); return 0; } +/* *INDENT-OFF* */ VLIB_CLI_COMMAND (set_l2_xcrw_command, static) = { .path = "set interface l2 xcrw", - .short_help = + .short_help = "set int l2 xcrw next \n" " [del] [tx-fib-id ] [ipv6] rw ", .function = set_l2_xcrw_command_fn, }; +/* *INDENT-ON* */ -static u8 * format_l2xcrw (u8 * s, va_list * args) +static u8 * +format_l2xcrw (u8 * s, va_list * args) { - vnet_main_t * vnm = va_arg (*args, vnet_main_t *); - l2_xcrw_tunnel_t * t = va_arg (*args, l2_xcrw_tunnel_t *); - l2_xcrw_main_t * xcm = &l2_xcrw_main; - vlib_main_t * vm = vlib_get_main (); - l2_xcrw_adjacency_t * a; - u8 * rewrite_string; + vnet_main_t *vnm = va_arg (*args, vnet_main_t *); + l2_xcrw_tunnel_t *t = va_arg (*args, l2_xcrw_tunnel_t *); + l2_xcrw_main_t *xcm = &l2_xcrw_main; + vlib_main_t *vm = vlib_get_main (); + l2_xcrw_adjacency_t *a; + u8 *rewrite_string; if (t == 0) { @@ -501,26 +500,26 @@ static u8 * format_l2xcrw (u8 * s, va_list * args) return s; } - s = format (s, "%-25U %U ", - format_vnet_sw_if_index_name, vnm, t->l2_sw_if_index, - format_vnet_sw_if_index_name, vnm, t->tunnel_sw_if_index); + s = format (s, "%-25U %U ", + format_vnet_sw_if_index_name, vnm, t->l2_sw_if_index, + format_vnet_sw_if_index_name, vnm, t->tunnel_sw_if_index); a = vec_elt_at_index (xcm->adj_by_sw_if_index, t->l2_sw_if_index); - + s = format (s, "next %U ", - format_vlib_next_node_name, vm, l2_xcrw_node.index, - a->rewrite_header.next_index); + format_vlib_next_node_name, vm, l2_xcrw_node.index, + a->rewrite_header.next_index); if (a->rewrite_header.sw_if_index != ~0) s = format (s, "tx fib index %d ", a->rewrite_header.sw_if_index); if (a->rewrite_header.data_bytes) { - rewrite_string = (u8 *)(a + 1); + rewrite_string = (u8 *) (a + 1); rewrite_string -= a->rewrite_header.data_bytes; s = format (s, "rewrite data: %U ", - format_hex_bytes, rewrite_string, - a->rewrite_header.data_bytes); + format_hex_bytes, rewrite_string, + a->rewrite_header.data_bytes); } s = format (s, "\n"); @@ -531,12 +530,11 @@ static u8 * format_l2xcrw (u8 * s, va_list * args) static clib_error_t * show_l2xcrw_command_fn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) + unformat_input_t * input, vlib_cli_command_t * cmd) { - vnet_main_t * vnm = vnet_get_main(); - l2_xcrw_main_t * xcm = &l2_xcrw_main; - l2_xcrw_tunnel_t * t; + vnet_main_t *vnm = vnet_get_main (); + l2_xcrw_main_t *xcm = &l2_xcrw_main; + l2_xcrw_tunnel_t *t; if (pool_elts (xcm->tunnels) == 0) { @@ -546,16 +544,28 @@ show_l2xcrw_command_fn (vlib_main_t * vm, vlib_cli_output (vm, "%U", format_l2xcrw, 0, 0); - pool_foreach (t, xcm->tunnels, + /* *INDENT-OFF* */ + pool_foreach (t, xcm->tunnels, ({ vlib_cli_output (vm, "%U", format_l2xcrw, vnm, t); })); + /* *INDENT-ON* */ return 0; } +/* *INDENT-OFF* */ VLIB_CLI_COMMAND (show_l2xcrw_command, static) = { .path = "show l2xcrw", .short_help = "Display L2/L3 rewrite cross-connects", .function = show_l2xcrw_command_fn, }; +/* *INDENT-ON* */ + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/vnet/vnet/l2/l2_xcrw.h b/vnet/vnet/l2/l2_xcrw.h index d32d1e8df5c..ca80aae9929 100644 --- a/vnet/vnet/l2/l2_xcrw.h +++ b/vnet/vnet/l2/l2_xcrw.h @@ -25,41 +25,45 @@ #include #include -typedef struct { - /* +typedef struct +{ + /* * Let: rewrite_header.sw_if_index = tx_fib_index or ~0. * rewrite_header.next_index = L2_XCRW_NEXT_XXX */ vnet_declare_rewrite (VLIB_BUFFER_PRE_DATA_SIZE); } l2_xcrw_adjacency_t; -typedef struct { +typedef struct +{ /* L2 interface */ u32 l2_sw_if_index; /* Tunnel interface */ - u32 tunnel_sw_if_index; /* This field remains set in freed pool elts */ + u32 tunnel_sw_if_index; /* This field remains set in freed pool elts */ } l2_xcrw_tunnel_t; -typedef struct { +typedef struct +{ u32 cached_next_index; /* Vector of cross-connect rewrites */ - l2_xcrw_adjacency_t * adj_by_sw_if_index; + l2_xcrw_adjacency_t *adj_by_sw_if_index; /* Pool of xcrw tunnels */ - l2_xcrw_tunnel_t * tunnels; + l2_xcrw_tunnel_t *tunnels; /* Tunnel index by tunnel sw_if_index */ - uword * tunnel_index_by_l2_sw_if_index; + uword *tunnel_index_by_l2_sw_if_index; /* convenience variables */ - vlib_main_t * vlib_main; - vnet_main_t * vnet_main; + vlib_main_t *vlib_main; + vnet_main_t *vnet_main; } l2_xcrw_main_t; -typedef enum { +typedef enum +{ L2_XCRW_NEXT_DROP, L2_XCRW_N_NEXT, } l2_xcrw_next_t; @@ -68,11 +72,20 @@ typedef enum { _(DROP, "Packets dropped") \ _(FWD, "Packets forwarded") -typedef enum { +typedef enum +{ #define _(sym,str) L2_XCRW_ERROR_##sym, foreach_l2_xcrw_error #undef _ - L2_XCRW_N_ERROR, + L2_XCRW_N_ERROR, } l2_xcrw_error_t; #endif /* __included_l2_xcrw_h__ */ + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ -- cgit 1.2.3-korg