diff options
Diffstat (limited to 'vpp/app/sticky_hash.c')
| -rw-r--r-- | vpp/app/sticky_hash.c | 583 |
1 files changed, 305 insertions, 278 deletions
diff --git a/vpp/app/sticky_hash.c b/vpp/app/sticky_hash.c index d6d35512..05d681f4 100644 --- a/vpp/app/sticky_hash.c +++ b/vpp/app/sticky_hash.c @@ -23,55 +23,59 @@ #include <vnet/ip/ip6_packet.h> #include <vppinfra/error.h> -typedef struct { +typedef struct +{ u32 fwd_entry_index; u32 rev_entry_index; /* Not strictly needed, for show command */ u32 fib_index; } sticky_hash_session_t; -typedef struct { +typedef struct +{ u32 cached_next_index; /* next index added to l2_classify */ u32 fwd_miss_next_index; /* session pool */ - sticky_hash_session_t * sessions; + sticky_hash_session_t *sessions; /* Forward and reverse data session setup buffers */ u8 fdata[3 * sizeof (u32x4)]; u8 rdata[3 * sizeof (u32x4)]; /* convenience variables */ - vlib_main_t * vlib_main; - vnet_main_t * vnet_main; - vnet_classify_main_t * vnet_classify_main; - l2_classify_main_t * l2_classify_main; -} sticky_hash_main_t; - -typedef struct { - /* $$$$ fill in with per-pkt trace data */ + vlib_main_t *vlib_main; + vnet_main_t *vnet_main; + vnet_classify_main_t *vnet_classify_main; + l2_classify_main_t *l2_classify_main; +} +sticky_hash_main_t; + +typedef struct +{ + /* $$$$ fill in with per-pkt trace data */ u32 next_index; u32 sw_if_index; } sticky_hash_miss_trace_t; /* packet trace format function */ -static u8 * format_sticky_hash_miss_trace (u8 * s, va_list * args) +static u8 * +format_sticky_hash_miss_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 *); - sticky_hash_miss_trace_t * t = va_arg (*args, sticky_hash_miss_trace_t *); - - s = format (s, "STICKY_HASH_MISS: sw_if_index %d", - t->sw_if_index); + sticky_hash_miss_trace_t *t = va_arg (*args, sticky_hash_miss_trace_t *); + + s = format (s, "STICKY_HASH_MISS: sw_if_index %d", t->sw_if_index); return s; } -typedef CLIB_PACKED(struct { - ethernet_header_t eh; - ip4_header_t ip; -}) classify_data_or_mask_t; +typedef CLIB_PACKED (struct + { + ethernet_header_t eh; ip4_header_t ip; + }) classify_data_or_mask_t; sticky_hash_main_t sticky_hash_main; @@ -80,22 +84,23 @@ vlib_node_registration_t sticky_hash_miss_node; #define foreach_sticky_hash_miss_error \ _(MISSES, "forward flow classify misses") -typedef enum { +typedef enum +{ #define _(sym,str) STICKY_HASH_MISS_ERROR_##sym, foreach_sticky_hash_miss_error #undef _ - STICKY_HASH_MISS_N_ERROR, + STICKY_HASH_MISS_N_ERROR, } sticky_hash_miss_error_t; -static char * sticky_hash_miss_error_strings[] = { +static char *sticky_hash_miss_error_strings[] = { #define _(sym,string) string, foreach_sticky_hash_miss_error #undef _ }; -/* +/* * To drop a pkt and increment one of the previous counters: - * + * * set b0->error = error_node->errors[STICKY_HASH_MISS_ERROR_EXAMPLE]; * set next0 to a disposition index bound to "error-drop". * @@ -105,27 +110,27 @@ static char * sticky_hash_miss_error_strings[] = { * u32 node_counter_base_index = n->error_heap_index; * vlib_error_main_t * em = &vm->error_main; * em->counters[node_counter_base_index + STICKY_HASH_MISS_ERROR_EXAMPLE] += 1; - * + * */ -typedef enum { +typedef enum +{ STICKY_HASH_MISS_NEXT_IP4_INPUT, STICKY_HASH_MISS_N_NEXT, } sticky_hash_miss_next_t; static uword sticky_hash_miss_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; sticky_hash_miss_next_t next_index; - sticky_hash_main_t * mp = &sticky_hash_main; + sticky_hash_main_t *mp = &sticky_hash_main; vlib_node_t *n = vlib_get_node (vm, sticky_hash_miss_node.index); u32 node_counter_base_index = n->error_heap_index; - vlib_error_main_t * em = &vm->error_main; - vnet_classify_main_t * cm = mp->vnet_classify_main; - ip4_main_t * im = &ip4_main; + vlib_error_main_t *em = &vm->error_main; + vnet_classify_main_t *cm = mp->vnet_classify_main; + ip4_main_t *im = &ip4_main; from = vlib_frame_vector_args (frame); n_left_from = frame->n_vectors; @@ -135,25 +140,24 @@ sticky_hash_miss_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 > 0 && n_left_to_next > 0) { - u32 bi0; - vlib_buffer_t * b0; - u32 next0; - u32 sw_if_index0; - u32 fib_index0, ft_index0, rt_index0; - vnet_classify_table_3_t * ft0, * rt0; - vnet_classify_entry_3_t * fe0, * re0; - classify_data_or_mask_t * h0; - u8 was_found0; - ip4_fib_t * fib0; - sticky_hash_session_t * s; - u32 tmp; - - /* speculatively enqueue b0 to the current next frame */ + u32 bi0; + vlib_buffer_t *b0; + u32 next0; + u32 sw_if_index0; + u32 fib_index0, ft_index0, rt_index0; + vnet_classify_table_3_t *ft0, *rt0; + vnet_classify_entry_3_t *fe0, *re0; + classify_data_or_mask_t *h0; + u8 was_found0; + ip4_fib_t *fib0; + sticky_hash_session_t *s; + u32 tmp; + + /* speculatively enqueue b0 to the current next frame */ bi0 = from[0]; to_next[0] = bi0; from += 1; @@ -163,69 +167,71 @@ sticky_hash_miss_node_fn (vlib_main_t * vm, b0 = vlib_get_buffer (vm, bi0); - sw_if_index0 = vnet_buffer(b0)->sw_if_index[VLIB_RX]; - next0 = mp->cached_next_index; - - h0 = vlib_buffer_get_current (b0); - - /* Add forward and reverse entries for this flow */ - clib_memcpy (mp->fdata, h0, sizeof (mp->fdata)); - clib_memcpy (mp->rdata, h0, sizeof (mp->rdata)); - - h0 = (classify_data_or_mask_t *)(mp->rdata); - - /* swap src + dst addresses to form reverse data */ - tmp = h0->ip.src_address.as_u32; - h0->ip.src_address.as_u32 = h0->ip.dst_address.as_u32; - h0->ip.dst_address.as_u32 = tmp; - - /* dig up fwd + rev tables */ - fib_index0 = vec_elt (im->fib_index_by_sw_if_index, sw_if_index0); - fib0 = vec_elt_at_index (im->fibs, fib_index0); - - ft_index0 = fib0->fwd_classify_table_index; - rt_index0 = fib0->rev_classify_table_index; - - ft0 = (vnet_classify_table_3_t *) - pool_elt_at_index (cm->tables, ft_index0); - rt0 = (vnet_classify_table_3_t *) - pool_elt_at_index (cm->tables, rt_index0); - - fe0 = vnet_classify_find_or_add_entry_3 (ft0, mp->fdata, &was_found0); - fe0->next_index = L2_CLASSIFY_NEXT_IP4_INPUT; - fe0->advance = sizeof (ethernet_header_t); - - re0 = vnet_classify_find_or_add_entry_3 (rt0, mp->rdata, 0); - re0->next_index = L2_CLASSIFY_NEXT_IP4_INPUT; /* $$$ FIXME */ - re0->advance = sizeof (ethernet_header_t); - - /* Note: we could get a whole vector of misses for the same sess */ - if (was_found0 == 0) - { - pool_get (mp->sessions, s); - - fe0->opaque_index = s - mp->sessions; - re0->opaque_index = s - mp->sessions; - - s->fwd_entry_index = fe0 - ft0->entries; - s->rev_entry_index = re0 - rt0->entries; - s->fib_index = fib_index0; - } - - if (PREDICT_FALSE((node->flags & VLIB_NODE_FLAG_TRACE) - && (b0->flags & VLIB_BUFFER_IS_TRACED))) { - sticky_hash_miss_trace_t *t = - vlib_add_trace (vm, node, b0, sizeof (*t)); - t->sw_if_index = sw_if_index0; - t->next_index = next0; - } - - em->counters[node_counter_base_index + STICKY_HASH_MISS_ERROR_MISSES] - += 1; - - vlib_buffer_advance (b0, sizeof (ethernet_header_t)); - - /* verify speculative enqueue, maybe switch current next frame */ + sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX]; + next0 = mp->cached_next_index; + + h0 = vlib_buffer_get_current (b0); + + /* Add forward and reverse entries for this flow */ + clib_memcpy (mp->fdata, h0, sizeof (mp->fdata)); + clib_memcpy (mp->rdata, h0, sizeof (mp->rdata)); + + h0 = (classify_data_or_mask_t *) (mp->rdata); + + /* swap src + dst addresses to form reverse data */ + tmp = h0->ip.src_address.as_u32; + h0->ip.src_address.as_u32 = h0->ip.dst_address.as_u32; + h0->ip.dst_address.as_u32 = tmp; + + /* dig up fwd + rev tables */ + fib_index0 = vec_elt (im->fib_index_by_sw_if_index, sw_if_index0); + fib0 = vec_elt_at_index (im->fibs, fib_index0); + + ft_index0 = fib0->fwd_classify_table_index; + rt_index0 = fib0->rev_classify_table_index; + + ft0 = (vnet_classify_table_3_t *) + pool_elt_at_index (cm->tables, ft_index0); + rt0 = (vnet_classify_table_3_t *) + pool_elt_at_index (cm->tables, rt_index0); + + fe0 = + vnet_classify_find_or_add_entry_3 (ft0, mp->fdata, &was_found0); + fe0->next_index = L2_CLASSIFY_NEXT_IP4_INPUT; + fe0->advance = sizeof (ethernet_header_t); + + re0 = vnet_classify_find_or_add_entry_3 (rt0, mp->rdata, 0); + re0->next_index = L2_CLASSIFY_NEXT_IP4_INPUT; /* $$$ FIXME */ + re0->advance = sizeof (ethernet_header_t); + + /* Note: we could get a whole vector of misses for the same sess */ + if (was_found0 == 0) + { + pool_get (mp->sessions, s); + + fe0->opaque_index = s - mp->sessions; + re0->opaque_index = s - mp->sessions; + + s->fwd_entry_index = fe0 - ft0->entries; + s->rev_entry_index = re0 - rt0->entries; + s->fib_index = fib_index0; + } + + if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE) + && (b0->flags & VLIB_BUFFER_IS_TRACED))) + { + sticky_hash_miss_trace_t *t = + vlib_add_trace (vm, node, b0, sizeof (*t)); + t->sw_if_index = sw_if_index0; + t->next_index = next0; + } + + em->counters[node_counter_base_index + + STICKY_HASH_MISS_ERROR_MISSES] += 1; + + vlib_buffer_advance (b0, sizeof (ethernet_header_t)); + + /* 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 +243,14 @@ sticky_hash_miss_node_fn (vlib_main_t * vm, return frame->n_vectors; } +/* *INDENT-OFF* */ VLIB_REGISTER_NODE (sticky_hash_miss_node) = { .function = sticky_hash_miss_node_fn, .name = "sticky-hash-miss", .vector_size = sizeof (u32), .format_trace = format_sticky_hash_miss_trace, .type = VLIB_NODE_TYPE_INTERNAL, - + .n_errors = ARRAY_LEN(sticky_hash_miss_error_strings), .error_strings = sticky_hash_miss_error_strings, @@ -251,16 +258,18 @@ VLIB_REGISTER_NODE (sticky_hash_miss_node) = { /* edit / add dispositions here */ .next_nodes = { - [STICKY_HASH_MISS_NEXT_IP4_INPUT] = "ip4-input", + [STICKY_HASH_MISS_NEXT_IP4_INPUT] = "ip4-input", }, }; +/* *INDENT-ON* */ -clib_error_t *sticky_hash_miss_init (vlib_main_t *vm) +clib_error_t * +sticky_hash_miss_init (vlib_main_t * vm) { - sticky_hash_main_t * mp = &sticky_hash_main; - + sticky_hash_main_t *mp = &sticky_hash_main; + mp->vlib_main = vm; - mp->vnet_main = vnet_get_main(); + mp->vnet_main = vnet_get_main (); mp->vnet_classify_main = &vnet_classify_main; mp->l2_classify_main = &l2_classify_main; @@ -269,87 +278,86 @@ clib_error_t *sticky_hash_miss_init (vlib_main_t *vm) VLIB_INIT_FUNCTION (sticky_hash_miss_init); -static int ip4_sticky_hash_enable_disable -(sticky_hash_main_t * mp, - u32 fwd_sw_if_index, u8 * fwd_mask, - u32 rev_sw_if_index, u8 * rev_mask, - u32 nbuckets, int enable_disable) +static int ip4_sticky_hash_enable_disable + (sticky_hash_main_t * mp, + u32 fwd_sw_if_index, u8 * fwd_mask, + u32 rev_sw_if_index, u8 * rev_mask, u32 nbuckets, int enable_disable) { - ip4_main_t * im = &ip4_main; + ip4_main_t *im = &ip4_main; u32 fib_index; - ip4_fib_t * fib; - vnet_classify_main_t * cm = mp->vnet_classify_main; - l2_classify_main_t * l2cm = mp->l2_classify_main; - vnet_classify_table_3_t * ft, * rt; - + ip4_fib_t *fib; + vnet_classify_main_t *cm = mp->vnet_classify_main; + l2_classify_main_t *l2cm = mp->l2_classify_main; + vnet_classify_table_3_t *ft, *rt; + fib_index = vec_elt (im->fib_index_by_sw_if_index, fwd_sw_if_index); - fib = vec_elt_at_index (im->fibs, fib_index); - + fib = vec_elt_at_index (im->fibs, fib_index); + if (fib->fwd_classify_table_index == ~0) { /* Set up forward table */ - ft = (vnet_classify_table_3_t *) - vnet_classify_new_table (cm, fwd_mask, nbuckets, - 0 /* skip */, 3 /* match */); - fib->fwd_classify_table_index - = ft - (vnet_classify_table_3_t *) cm->tables; - mp->fwd_miss_next_index = - vlib_node_add_next (mp->vlib_main, l2_classify_node.index, - sticky_hash_miss_node.index); + ft = (vnet_classify_table_3_t *) + vnet_classify_new_table (cm, fwd_mask, nbuckets, + 0 /* skip */ , 3 /* match */ ); + fib->fwd_classify_table_index + = ft - (vnet_classify_table_3_t *) cm->tables; + mp->fwd_miss_next_index = + vlib_node_add_next (mp->vlib_main, l2_classify_node.index, + sticky_hash_miss_node.index); ft->miss_next_index = mp->fwd_miss_next_index; /* Set up reverse table */ - rt = (vnet_classify_table_3_t *) - vnet_classify_new_table (cm, rev_mask, nbuckets, - 0 /* skip */, 3 /* match */); - fib->rev_classify_table_index - = rt - (vnet_classify_table_3_t *) cm->tables; + rt = (vnet_classify_table_3_t *) + vnet_classify_new_table (cm, rev_mask, nbuckets, + 0 /* skip */ , 3 /* match */ ); + fib->rev_classify_table_index + = rt - (vnet_classify_table_3_t *) cm->tables; } - vec_validate - (l2cm->classify_table_index_by_sw_if_index[L2_CLASSIFY_TABLE_IP4], + vec_validate + (l2cm->classify_table_index_by_sw_if_index[L2_CLASSIFY_TABLE_IP4], fwd_sw_if_index); - - vec_validate - (l2cm->classify_table_index_by_sw_if_index[L2_CLASSIFY_TABLE_IP6], + + vec_validate + (l2cm->classify_table_index_by_sw_if_index[L2_CLASSIFY_TABLE_IP6], fwd_sw_if_index); - - vec_validate - (l2cm->classify_table_index_by_sw_if_index[L2_CLASSIFY_TABLE_OTHER], + + vec_validate + (l2cm->classify_table_index_by_sw_if_index[L2_CLASSIFY_TABLE_OTHER], fwd_sw_if_index); - + l2cm->classify_table_index_by_sw_if_index[L2_CLASSIFY_TABLE_IP4] [fwd_sw_if_index] = fib->fwd_classify_table_index; l2cm->classify_table_index_by_sw_if_index[L2_CLASSIFY_TABLE_IP6] [fwd_sw_if_index] = ~0; - + l2cm->classify_table_index_by_sw_if_index[L2_CLASSIFY_TABLE_OTHER] [fwd_sw_if_index] = ~0; - - vec_validate - (l2cm->classify_table_index_by_sw_if_index[L2_CLASSIFY_TABLE_IP4], + + vec_validate + (l2cm->classify_table_index_by_sw_if_index[L2_CLASSIFY_TABLE_IP4], rev_sw_if_index); - - vec_validate - (l2cm->classify_table_index_by_sw_if_index[L2_CLASSIFY_TABLE_IP6], + + vec_validate + (l2cm->classify_table_index_by_sw_if_index[L2_CLASSIFY_TABLE_IP6], rev_sw_if_index); - - vec_validate - (l2cm->classify_table_index_by_sw_if_index[L2_CLASSIFY_TABLE_OTHER], + + vec_validate + (l2cm->classify_table_index_by_sw_if_index[L2_CLASSIFY_TABLE_OTHER], rev_sw_if_index); - + l2cm->classify_table_index_by_sw_if_index[L2_CLASSIFY_TABLE_IP4] [rev_sw_if_index] = fib->rev_classify_table_index; - + l2cm->classify_table_index_by_sw_if_index[L2_CLASSIFY_TABLE_IP6] [rev_sw_if_index] = ~0; - + l2cm->classify_table_index_by_sw_if_index[L2_CLASSIFY_TABLE_OTHER] [rev_sw_if_index] = ~0; - + vnet_l2_classify_enable_disable (fwd_sw_if_index, enable_disable); vnet_l2_classify_enable_disable (rev_sw_if_index, enable_disable); return 0; @@ -357,33 +365,37 @@ static int ip4_sticky_hash_enable_disable static clib_error_t * ip4_sticky_hash_init_command_fn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) + unformat_input_t * input, + vlib_cli_command_t * cmd) { u32 fwd_sw_if_index = ~0, rev_sw_if_index = ~0; int enable_disable = 1; u32 nbuckets = 2; int rv; - sticky_hash_main_t * mp = &sticky_hash_main; + sticky_hash_main_t *mp = &sticky_hash_main; classify_data_or_mask_t fwd_mask, rev_mask; - u8 * fm = 0, * rm = 0; - - while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) { - if (unformat (input, "fwd %U", unformat_vnet_sw_interface, mp->vnet_main, - &fwd_sw_if_index)) - ; - if (unformat (input, "rev %U", unformat_vnet_sw_interface, mp->vnet_main, - &rev_sw_if_index)) - ; - else if (unformat (input, "nbuckets %d", &nbuckets)) - ; - else if (unformat (input, "disable")) - enable_disable = 0; - - else break; - } + u8 *fm = 0, *rm = 0; + + while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) + { + if (unformat + (input, "fwd %U", unformat_vnet_sw_interface, mp->vnet_main, + &fwd_sw_if_index)) + ; + if (unformat + (input, "rev %U", unformat_vnet_sw_interface, mp->vnet_main, + &rev_sw_if_index)) + ; + else if (unformat (input, "nbuckets %d", &nbuckets)) + ; + else if (unformat (input, "disable")) + enable_disable = 0; + + else + break; + } - nbuckets = 1<<max_log2(nbuckets); + nbuckets = 1 << max_log2 (nbuckets); if (fwd_sw_if_index == ~0) return clib_error_return (0, "fwd interface not set"); @@ -391,27 +403,27 @@ ip4_sticky_hash_init_command_fn (vlib_main_t * vm, if (rev_sw_if_index == ~0) return clib_error_return (0, "rev interface not set"); - if (!is_pow2(nbuckets)) + if (!is_pow2 (nbuckets)) return clib_error_return (0, "nbuckets %d not a power of 2", nbuckets); - - ASSERT(sizeof(fwd_mask) <= 3 * sizeof (u32x4)); + + ASSERT (sizeof (fwd_mask) <= 3 * sizeof (u32x4)); /* Mask on src/dst address, depending on direction */ - memset(&fwd_mask, 0, sizeof (fwd_mask)); + memset (&fwd_mask, 0, sizeof (fwd_mask)); memset (&fwd_mask.ip.src_address, 0xff, 4); - memset(&rev_mask, 0, sizeof (rev_mask)); + memset (&rev_mask, 0, sizeof (rev_mask)); memset (&rev_mask.ip.dst_address, 0xff, 4); - vec_validate (fm, 3 * sizeof(u32x4) - 1); - vec_validate (rm, 3 * sizeof(u32x4) - 1); + vec_validate (fm, 3 * sizeof (u32x4) - 1); + vec_validate (rm, 3 * sizeof (u32x4) - 1); clib_memcpy (fm, &fwd_mask, sizeof (fwd_mask)); clib_memcpy (rm, &rev_mask, sizeof (rev_mask)); - - rv = ip4_sticky_hash_enable_disable (mp, fwd_sw_if_index, fm, - rev_sw_if_index, rm, - nbuckets, enable_disable); + + rv = ip4_sticky_hash_enable_disable (mp, fwd_sw_if_index, fm, + rev_sw_if_index, rm, + nbuckets, enable_disable); vec_free (fm); vec_free (rm); @@ -421,63 +433,66 @@ ip4_sticky_hash_init_command_fn (vlib_main_t * vm, return 0; default: - return clib_error_return (0, "ip4_sticky_hash_enable_disable returned %d", - rv); + return clib_error_return (0, + "ip4_sticky_hash_enable_disable returned %d", + rv); } return 0; } +/* *INDENT-OFF* */ VLIB_CLI_COMMAND (sticky_hash_init_command, static) = { - .path = "ip sticky classify", - .short_help = "ip sticky classify fwd <intfc> rev <intfc> " - "[nbuckets <nn>][disable]", - .function = ip4_sticky_hash_init_command_fn, + .path = "ip sticky classify", + .short_help = "ip sticky classify fwd <intfc> rev <intfc> " + "[nbuckets <nn>][disable]", + .function = ip4_sticky_hash_init_command_fn, }; +/* *INDENT-ON* */ -u8 * format_sticky_hash_session (u8 * s, va_list * args) +u8 * +format_sticky_hash_session (u8 * s, va_list * args) { - sticky_hash_main_t * mp = va_arg(*args, sticky_hash_main_t *); - sticky_hash_session_t * session = va_arg(*args, sticky_hash_session_t *); - vnet_classify_table_3_t * t; - vnet_classify_entry_3_t * e; - ip4_main_t * im = &ip4_main; - vnet_classify_main_t * cm = mp->vnet_classify_main; - ip4_fib_t * fib; - classify_data_or_mask_t * match; + sticky_hash_main_t *mp = va_arg (*args, sticky_hash_main_t *); + sticky_hash_session_t *session = va_arg (*args, sticky_hash_session_t *); + vnet_classify_table_3_t *t; + vnet_classify_entry_3_t *e; + ip4_main_t *im = &ip4_main; + vnet_classify_main_t *cm = mp->vnet_classify_main; + ip4_fib_t *fib; + classify_data_or_mask_t *match; fib = vec_elt_at_index (im->fibs, session->fib_index); - t = (vnet_classify_table_3_t *) + t = (vnet_classify_table_3_t *) pool_elt_at_index (cm->tables, fib->fwd_classify_table_index); e = pool_elt_at_index (t->entries, session->fwd_entry_index); - match = (classify_data_or_mask_t *)(e->key); - - s = format - (s, - "[%6d] fwd src %U next index %d session %d fib %d\n" - " hits %lld last-heard %.6f\n", - e - t->entries, - format_ip4_address, &match->ip.src_address, - e->next_index, e->opaque_index, fib->table_id, - e->hits, e->last_heard); - + match = (classify_data_or_mask_t *) (e->key); + + s = format + (s, + "[%6d] fwd src %U next index %d session %d fib %d\n" + " hits %lld last-heard %.6f\n", + e - t->entries, + format_ip4_address, &match->ip.src_address, + e->next_index, e->opaque_index, fib->table_id, e->hits, e->last_heard); + if (e->opaque_index != session - mp->sessions) s = format (s, "WARNING: forward session index mismatch!\n"); t = (vnet_classify_table_3_t *) pool_elt_at_index (cm->tables, fib->rev_classify_table_index); e = pool_elt_at_index (t->entries, session->rev_entry_index); - match = (classify_data_or_mask_t *)(e->key); - - s = format - (s, - "[%6d] rev dst %U next index %d session %d\n" - " hits %lld last-heard %.6f\n", - e - t->entries, - format_ip4_address, &match->ip.dst_address, - e->next_index, e->opaque_index, e->hits, e->last_heard); + match = (classify_data_or_mask_t *) (e->key); + + s = format + (s, + "[%6d] rev dst %U next index %d session %d\n" + " hits %lld last-heard %.6f\n", + e - t->entries, + format_ip4_address, &match->ip.dst_address, + e->next_index, e->opaque_index, e->hits, e->last_heard); if (e->opaque_index != session - mp->sessions) s = format (s, "WARNING: reverse session index mismatch!\n"); @@ -488,67 +503,79 @@ u8 * format_sticky_hash_session (u8 * s, va_list * args) static clib_error_t * show_ip4_sticky_hash_command_fn (vlib_main_t * vm, - unformat_input_t * input, - vlib_cli_command_t * cmd) + unformat_input_t * input, + vlib_cli_command_t * cmd) { - sticky_hash_main_t * mp = &sticky_hash_main; - sticky_hash_session_t * s; + sticky_hash_main_t *mp = &sticky_hash_main; + sticky_hash_session_t *s; int verbose = 0; int dump_classifier_tables = 0; - ip4_fib_t * fib; - ip4_main_t * im4 = &ip4_main; - vnet_classify_main_t * cm = mp->vnet_classify_main; - - while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) { - if (unformat (input, "verbose")) - verbose = 1; - else if (unformat (input, "dump-tables") - || unformat (input, "dump-classifier-tables")) - dump_classifier_tables = 1; - else - break; - } + ip4_fib_t *fib; + ip4_main_t *im4 = &ip4_main; + vnet_classify_main_t *cm = mp->vnet_classify_main; + + while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) + { + if (unformat (input, "verbose")) + verbose = 1; + else if (unformat (input, "dump-tables") + || unformat (input, "dump-classifier-tables")) + dump_classifier_tables = 1; + else + break; + } if (pool_elts (mp->sessions) == 0) vlib_cli_output (vm, "No ip sticky hash sessions"); - - vlib_cli_output (vm, "%d active sessions\n", - pool_elts (mp->sessions)); + + vlib_cli_output (vm, "%d active sessions\n", pool_elts (mp->sessions)); vec_foreach (fib, im4->fibs) - { - if (fib->fwd_classify_table_index != ~0) - vlib_cli_output (vm, "fib %d fwd table: \n%U", - fib->table_id, - format_classify_table, - cm, - pool_elt_at_index - (cm->tables, fib->fwd_classify_table_index), - dump_classifier_tables); - if (fib->rev_classify_table_index != ~0) - vlib_cli_output (vm, "fib %d rev table: \n%U", - fib->table_id, - format_classify_table, - cm, - pool_elt_at_index - (cm->tables, fib->rev_classify_table_index), - dump_classifier_tables); - } + { + if (fib->fwd_classify_table_index != ~0) + vlib_cli_output (vm, "fib %d fwd table: \n%U", + fib->table_id, + format_classify_table, + cm, + pool_elt_at_index + (cm->tables, fib->fwd_classify_table_index), + dump_classifier_tables); + if (fib->rev_classify_table_index != ~0) + vlib_cli_output (vm, "fib %d rev table: \n%U", + fib->table_id, + format_classify_table, + cm, + pool_elt_at_index + (cm->tables, fib->rev_classify_table_index), + dump_classifier_tables); + } if (verbose) { - pool_foreach (s, mp->sessions, + /* *INDENT-OFF* */ + pool_foreach (s, mp->sessions, ({ vlib_cli_output (vm, "%U", format_sticky_hash_session, mp, s); })); + /* *INDENT-ON* */ } return 0; } +/* *INDENT-OFF* */ VLIB_CLI_COMMAND (show_sticky_hash_command, static) = { - .path = "show sticky classify", - .short_help = "Display sticky classifier tables", - .function = show_ip4_sticky_hash_command_fn, + .path = "show sticky classify", + .short_help = "Display sticky classifier tables", + .function = show_ip4_sticky_hash_command_fn, }; +/* *INDENT-ON* */ + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ |