diff options
Diffstat (limited to 'src/vpp/app')
-rw-r--r-- | src/vpp/app/sticky_hash.c | 581 | ||||
-rw-r--r-- | src/vpp/app/version.c | 92 | ||||
-rw-r--r-- | src/vpp/app/vpe_cli.c | 136 | ||||
-rw-r--r-- | src/vpp/app/vppctl.c | 384 |
4 files changed, 1193 insertions, 0 deletions
diff --git a/src/vpp/app/sticky_hash.c b/src/vpp/app/sticky_hash.c new file mode 100644 index 00000000..5569c677 --- /dev/null +++ b/src/vpp/app/sticky_hash.c @@ -0,0 +1,581 @@ +/* + * Copyright (c) 2015 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include <vnet/l2/l2_classify.h> + +#include <vlib/vlib.h> +#include <vnet/vnet.h> +#include <vnet/pg/pg.h> +#include <vnet/ip/ip.h> +#include <vnet/ip/ip_packet.h> +#include <vnet/ip/ip4_packet.h> +#include <vnet/ip/ip6_packet.h> +#include <vppinfra/error.h> + +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 +{ + u32 cached_next_index; + + /* next index added to l2_classify */ + u32 fwd_miss_next_index; + + /* session pool */ + 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_input_classify_main_t *l2_input_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) +{ + 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); + return s; +} + +typedef CLIB_PACKED (struct + { + ethernet_header_t eh; ip4_header_t ip; + }) classify_data_or_mask_t; + +sticky_hash_main_t sticky_hash_main; + +vlib_node_registration_t sticky_hash_miss_node; + +#define foreach_sticky_hash_miss_error \ +_(MISSES, "forward flow classify misses") + +typedef enum +{ +#define _(sym,str) STICKY_HASH_MISS_ERROR_##sym, + foreach_sticky_hash_miss_error +#undef _ + STICKY_HASH_MISS_N_ERROR, +} sticky_hash_miss_error_t; + +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". + * + * To manually increment the specific counter STICKY_HASH_MISS_ERROR_EXAMPLE: + * + * vlib_node_t *n = vlib_get_node (vm, sticky_hash_miss.index); + * 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 +{ + 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) +{ + u32 n_left_from, *from, *to_next; + sticky_hash_miss_next_t next_index; + 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; + + from = vlib_frame_vector_args (frame); + n_left_from = frame->n_vectors; + next_index = node->cached_next_index; + + while (n_left_from > 0) + { + u32 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 */ + 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); + + 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_INPUT_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_INPUT_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); + } + + vlib_put_next_frame (vm, node, next_index, n_left_to_next); + } + + 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, + + .n_next_nodes = STICKY_HASH_MISS_N_NEXT, + + /* edit / add dispositions here */ + .next_nodes = { + [STICKY_HASH_MISS_NEXT_IP4_INPUT] = "ip4-input", + }, +}; +/* *INDENT-ON* */ + +clib_error_t * +sticky_hash_miss_init (vlib_main_t * vm) +{ + sticky_hash_main_t *mp = &sticky_hash_main; + + mp->vlib_main = vm; + mp->vnet_main = vnet_get_main (); + mp->vnet_classify_main = &vnet_classify_main; + mp->l2_input_classify_main = &l2_input_classify_main; + + return 0; +} + +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) +{ + ip4_main_t *im = &ip4_main; + u32 fib_index; + ip4_fib_t *fib; + vnet_classify_main_t *cm = mp->vnet_classify_main; + l2_input_classify_main_t *l2cm = mp->l2_input_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); + + 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_input_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; + } + + vec_validate + (l2cm->classify_table_index_by_sw_if_index[L2_INPUT_CLASSIFY_TABLE_IP4], + fwd_sw_if_index); + + vec_validate + (l2cm->classify_table_index_by_sw_if_index[L2_INPUT_CLASSIFY_TABLE_IP6], + fwd_sw_if_index); + + vec_validate + (l2cm->classify_table_index_by_sw_if_index[L2_INPUT_CLASSIFY_TABLE_OTHER], + fwd_sw_if_index); + + l2cm->classify_table_index_by_sw_if_index[L2_INPUT_CLASSIFY_TABLE_IP4] + [fwd_sw_if_index] = fib->fwd_classify_table_index; + + l2cm->classify_table_index_by_sw_if_index[L2_INPUT_CLASSIFY_TABLE_IP6] + [fwd_sw_if_index] = ~0; + + l2cm->classify_table_index_by_sw_if_index[L2_INPUT_CLASSIFY_TABLE_OTHER] + [fwd_sw_if_index] = ~0; + + + vec_validate + (l2cm->classify_table_index_by_sw_if_index[L2_INPUT_CLASSIFY_TABLE_IP4], + rev_sw_if_index); + + vec_validate + (l2cm->classify_table_index_by_sw_if_index[L2_INPUT_CLASSIFY_TABLE_IP6], + rev_sw_if_index); + + vec_validate + (l2cm->classify_table_index_by_sw_if_index[L2_INPUT_CLASSIFY_TABLE_OTHER], + rev_sw_if_index); + + + l2cm->classify_table_index_by_sw_if_index[L2_INPUT_CLASSIFY_TABLE_IP4] + [rev_sw_if_index] = fib->rev_classify_table_index; + + l2cm->classify_table_index_by_sw_if_index[L2_INPUT_CLASSIFY_TABLE_IP6] + [rev_sw_if_index] = ~0; + + l2cm->classify_table_index_by_sw_if_index[L2_INPUT_CLASSIFY_TABLE_OTHER] + [rev_sw_if_index] = ~0; + + vnet_l2_input_classify_enable_disable (fwd_sw_if_index, enable_disable); + vnet_l2_input_classify_enable_disable (rev_sw_if_index, enable_disable); + return 0; +} + +static clib_error_t * +ip4_sticky_hash_init_command_fn (vlib_main_t * vm, + 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; + 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; + } + + nbuckets = 1 << max_log2 (nbuckets); + + if (fwd_sw_if_index == ~0) + return clib_error_return (0, "fwd interface not set"); + + if (rev_sw_if_index == ~0) + return clib_error_return (0, "rev interface not set"); + + if (!is_pow2 (nbuckets)) + return clib_error_return (0, "nbuckets %d not a power of 2", nbuckets); + + 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.ip.src_address, 0xff, 4); + + 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); + + 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); + + vec_free (fm); + vec_free (rm); + switch (rv) + { + case 0: + return 0; + + default: + 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, +}; +/* *INDENT-ON* */ + + +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; + + fib = vec_elt_at_index (im->fibs, session->fib_index); + + 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); + + 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); + + if (e->opaque_index != session - mp->sessions) + s = format (s, "WARNING: reverse session index mismatch!\n"); + s = format (s, "---------\n"); + + return s; +} + +static clib_error_t * +show_ip4_sticky_hash_command_fn (vlib_main_t * vm, + unformat_input_t * input, + vlib_cli_command_t * cmd) +{ + 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; + } + + 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)); + + 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 (verbose) + { + /* *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, +}; +/* *INDENT-ON* */ + + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/src/vpp/app/version.c b/src/vpp/app/version.c new file mode 100644 index 00000000..0a2c7fd4 --- /dev/null +++ b/src/vpp/app/version.c @@ -0,0 +1,92 @@ +/* + * Copyright (c) 2015 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include <vlib/vlib.h> +#include <vppinfra/cpu.h> +#include <vpp/app/version.h> + +static char *vpe_version_string = + "vpp v" VPP_BUILD_VER + " built by " VPP_BUILD_USER " on " VPP_BUILD_HOST " at " VPP_BUILD_DATE; + +static char *vpe_compiler = +#if defined(__INTEL_COMPILER) +#define __(x) #x +#define _(x) __(x) + "icc " _(__INTEL_COMPILER) " (" __VERSION__ ")"; +#undef _ +#undef __ +#elif defined(__clang__) + "Clang/LLVM " __clang_version__; +#elif defined (__GNUC__) + "GCC " __VERSION__; +#else + "unknown compiler"; +#endif + +static clib_error_t * +show_vpe_version_command_fn (vlib_main_t * vm, + unformat_input_t * input, + vlib_cli_command_t * cmd) +{ + if (unformat (input, "verbose")) + { +#define _(a,b,c) vlib_cli_output (vm, "%-25s " b, a ":", c); + _("Version", "%s", "v" VPP_BUILD_VER); + _("Compiled by", "%s", VPP_BUILD_USER); + _("Compile host", "%s", VPP_BUILD_HOST); + _("Compile date", "%s", VPP_BUILD_DATE); + _("Compile location", "%s", VPP_BUILD_TOPDIR); + _("Compiler", "%s", vpe_compiler); + _("Current PID", "%d", getpid ()); +#undef _ + } + else + vlib_cli_output (vm, "%s", vpe_version_string); + return 0; +} + +/* *INDENT-OFF* */ +VLIB_CLI_COMMAND (show_vpe_version_command, static) = { + .path = "show version", + .short_help = "show version information", + .function = show_vpe_version_command_fn, +}; +/* *INDENT-ON* */ + +char * +vpe_api_get_build_directory (void) +{ + return VPP_BUILD_TOPDIR; +} + +char * +vpe_api_get_version (void) +{ + return VPP_BUILD_VER; +} + +char * +vpe_api_get_build_date (void) +{ + return VPP_BUILD_DATE; +} + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/src/vpp/app/vpe_cli.c b/src/vpp/app/vpe_cli.c new file mode 100644 index 00000000..e19c23de --- /dev/null +++ b/src/vpp/app/vpe_cli.c @@ -0,0 +1,136 @@ +/* + * Copyright (c) 2015 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include <vnet/ip/ip.h> +#include <vnet/ethernet/ethernet.h> +#include <vnet/adj/adj.h> +#include <vnet/fib/fib_table.h> + +typedef struct +{ + u8 mac_addr[6]; +} mac_addr_t; + +static clib_error_t * +virtual_ip_cmd_fn_command_fn (vlib_main_t * vm, + unformat_input_t * input, + vlib_cli_command_t * cmd) +{ + unformat_input_t _line_input, *line_input = &_line_input; + vnet_main_t *vnm = vnet_get_main (); + ip46_address_t next_hop, *next_hops; + fib_route_path_t *rpaths; + fib_prefix_t prefix; + u8 mac_addr[6]; + mac_addr_t *mac_addrs = 0; + u32 sw_if_index; + u32 i; + clib_error_t *error = NULL; + + next_hops = NULL; + rpaths = NULL; + prefix.fp_len = 32; + prefix.fp_proto = FIB_PROTOCOL_IP4; + + /* Get a line of input. */ + if (!unformat_user (input, unformat_line_input, line_input)) + return 0; + + if (!unformat (line_input, "%U %U", + unformat_ip4_address, &prefix.fp_addr.ip4, + unformat_vnet_sw_interface, vnm, &sw_if_index)) + { + error = clib_error_return (0, "unknown input `%U'", + format_unformat_error, line_input); + goto done; + } + + while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) + { + if (unformat (line_input, "mac %U", + unformat_ethernet_address, &mac_addr)) + { + mac_addr_t *ma; + vec_add2 (mac_addrs, ma, 1); + clib_memcpy (ma, mac_addr, sizeof (mac_addr)); + } + else if (unformat (line_input, "next-hop %U", + unformat_ip4_address, &next_hop.ip4)) + { + vec_add1 (next_hops, next_hop); + } + else + { + error = clib_error_return (0, "unknown input `%U'", + format_unformat_error, line_input); + goto done; + } + } + + if (vec_len (mac_addrs) == 0 || vec_len (mac_addrs) != vec_len (next_hops)) + { + error = clib_error_return (0, "unknown input `%U'", + format_unformat_error, line_input); + goto done; + } + + /* Create / delete special interface route /32's */ + + for (i = 0; i < vec_len (mac_addrs); i++) + { + fib_route_path_t *rpath; + + adj_nbr_add_or_lock_w_rewrite (FIB_PROTOCOL_IP4, + VNET_LINK_IP4, + &next_hops[i], + sw_if_index, mac_addrs[i].mac_addr); + + vec_add2 (rpaths, rpath, 1); + + rpath->frp_proto = DPO_PROTO_IP4; + rpath->frp_addr = next_hops[i]; + rpath->frp_sw_if_index = sw_if_index; + rpath->frp_fib_index = ~0; + rpath->frp_weight = 1; + rpath->frp_label_stack = NULL; + } + + fib_table_entry_path_add2 (0, // default FIB table + &prefix, + FIB_SOURCE_CLI, FIB_ENTRY_FLAG_NONE, rpaths); + +done: + vec_free (mac_addrs); + vec_free (next_hops); + vec_free (rpaths); + unformat_free (line_input); + + return error; +} + +/* *INDENT-OFF* */ +VLIB_CLI_COMMAND (virtual_ip_cmd_fn_command, static) = { + .path = "ip virtual", + .short_help = "ip virtual <addr> <interface> [mac <Mi>]+", + .function = virtual_ip_cmd_fn_command_fn, +}; +/* *INDENT-ON* */ + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ diff --git a/src/vpp/app/vppctl.c b/src/vpp/app/vppctl.c new file mode 100644 index 00000000..66fe00ab --- /dev/null +++ b/src/vpp/app/vppctl.c @@ -0,0 +1,384 @@ +/* + * Copyright (c) 2017 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include <sys/socket.h> +#include <sys/un.h> +#include <sys/epoll.h> +#include <sys/ioctl.h> +#include <signal.h> +#include <termios.h> +#include <unistd.h> +#include <string.h> + +#define DEBUG 0 + +#if DEBUG +#define TELCMDS +#define TELOPTS +#endif + +#include <arpa/telnet.h> + +#include <vppinfra/mem.h> +#include <vppinfra/format.h> +#include <vppinfra/socket.h> + +#define SOCKET_FILE "/run/vpp/cli.sock" + +volatile int window_resized = 0; +struct termios orig_tio; + +static void +send_ttype (clib_socket_t * s, int is_interactive) +{ + char *term; + + term = is_interactive ? getenv ("TERM") : "vppctl"; + if (term == NULL) + term = "dumb"; + + clib_socket_tx_add_formatted (s, "%c%c%c" "%c%s" "%c%c", + IAC, SB, TELOPT_TTYPE, 0, term, IAC, SE); + clib_socket_tx (s); +} + +static void +send_naws (clib_socket_t * s) +{ + struct winsize ws; + + if (ioctl (STDIN_FILENO, TIOCGWINSZ, &ws) < 0) + { + clib_unix_warning ("ioctl(TIOCGWINSZ)"); + return; + } + + clib_socket_tx_add_formatted (s, "%c%c%c" "%c%c%c%c" "%c%c", + IAC, SB, TELOPT_NAWS, + ws.ws_col >> 8, ws.ws_col & 0xff, + ws.ws_row >> 8, ws.ws_row & 0xff, IAC, SE); + clib_socket_tx (s); +} + +static void +signal_handler_winch (int signum) +{ + window_resized = 1; +} + +static void +signal_handler_term (int signum) +{ + tcsetattr (STDIN_FILENO, TCSAFLUSH, &orig_tio); +} + +static u8 * +process_input (u8 * str, clib_socket_t * s, int is_interactive, + int *sent_ttype) +{ + int i = 0; + + while (i < vec_len (s->rx_buffer)) + { + if (s->rx_buffer[i] == IAC) + { + if (s->rx_buffer[i + 1] == SB) + { + u8 *sb = 0; + char opt = s->rx_buffer[i + 2]; + i += 3; + while (s->rx_buffer[i] != IAC) + vec_add1 (sb, s->rx_buffer[i++]); + +#if DEBUG + clib_warning ("SB %s\n %U", TELOPT (opt), + format_hexdump, sb, vec_len (sb)); +#endif + vec_free (sb); + i += 2; + if (opt == TELOPT_TTYPE) + { + send_ttype (s, is_interactive); + *sent_ttype = 1; + } + else if (is_interactive && opt == TELOPT_NAWS) + send_naws (s); + } + else + { +#if DEBUG + clib_warning ("IAC at %d, IAC %s %s", i, + TELCMD (s->rx_buffer[i + 1]), + TELOPT (s->rx_buffer[i + 2])); +#endif + i += 3; + } + } + else + vec_add1 (str, s->rx_buffer[i++]); + } + vec_reset_length (s->rx_buffer); + return str; +} + + +int +main (int argc, char *argv[]) +{ + clib_socket_t _s = { 0 }, *s = &_s; + clib_error_t *error = 0; + struct epoll_event event; + struct sigaction sa; + struct termios tio; + int efd = -1; + u8 *str = 0; + u8 *cmd = 0; + int do_quit = 0; + int is_interactive = 0; + int acked = 1; /* counts messages from VPP; starts at 1 */ + int sent_ttype = 0; + + + clib_mem_init (0, 64ULL << 10); + + /* process command line */ + argc--; + argv++; + + if (argc > 1 && strcmp (argv[0], "-s") == 0) + { + s->config = argv[1]; + argc -= 2; + argv += 2; + } + else + s->config = SOCKET_FILE; + + while (argc--) + cmd = format (cmd, "%s%c", (argv++)[0], argc ? ' ' : 0); + + s->flags = CLIB_SOCKET_F_IS_CLIENT; + + error = clib_socket_init (s); + if (error) + goto done; + + is_interactive = isatty (STDIN_FILENO) && cmd == 0; + + if (is_interactive) + { + /* Capture terminal resize events */ + memset (&sa, 0, sizeof (struct sigaction)); + sa.sa_handler = signal_handler_winch; + if (sigaction (SIGWINCH, &sa, 0) < 0) + { + error = clib_error_return_unix (0, "sigaction"); + goto done; + } + + /* Capture SIGTERM to reset tty settings */ + sa.sa_handler = signal_handler_term; + if (sigaction (SIGTERM, &sa, 0) < 0) + { + error = clib_error_return_unix (0, "sigaction"); + goto done; + } + + /* Save the original tty state so we can restore it later */ + if (tcgetattr (STDIN_FILENO, &orig_tio) < 0) + { + error = clib_error_return_unix (0, "tcgetattr"); + goto done; + } + + /* Tweak the tty settings */ + tio = orig_tio; + /* echo off, canonical mode off, ext'd input processing off */ + tio.c_lflag &= ~(ECHO | ICANON | IEXTEN); + tio.c_cc[VMIN] = 1; /* 1 byte at a time */ + tio.c_cc[VTIME] = 0; /* no timer */ + + if (tcsetattr (STDIN_FILENO, TCSAFLUSH, &tio) < 0) + { + error = clib_error_return_unix (0, "tcsetattr"); + goto done; + } + } + + efd = epoll_create1 (0); + + /* register STDIN */ + event.events = EPOLLIN | EPOLLPRI | EPOLLERR; + event.data.fd = STDIN_FILENO; + if (epoll_ctl (efd, EPOLL_CTL_ADD, STDIN_FILENO, &event) != 0) + { + /* ignore EPERM; it means stdin is something like /dev/null */ + if (errno != EPERM) + { + error = clib_error_return_unix (0, "epoll_ctl[%d]", STDIN_FILENO); + goto done; + } + } + + /* register socket */ + event.events = EPOLLIN | EPOLLPRI | EPOLLERR; + event.data.fd = s->fd; + if (epoll_ctl (efd, EPOLL_CTL_ADD, s->fd, &event) != 0) + { + error = clib_error_return_unix (0, "epoll_ctl[%d]", s->fd); + goto done; + } + + while (1) + { + int n; + + if (window_resized) + { + window_resized = 0; + send_naws (s); + } + + if ((n = epoll_wait (efd, &event, 1, -1)) < 0) + { + /* maybe we received signal */ + if (errno == EINTR) + continue; + + error = clib_error_return_unix (0, "epoll_wait"); + goto done; + } + + if (n == 0) + continue; + + if (event.data.fd == STDIN_FILENO) + { + int n; + char c[100]; + + if (!sent_ttype) + continue; /* not ready for this yet */ + + n = read (STDIN_FILENO, c, sizeof (c)); + if (n > 0) + { + memcpy (clib_socket_tx_add (s, n), c, n); + error = clib_socket_tx (s); + if (error) + goto done; + } + else if (n < 0) + clib_warning ("read rv=%d", n); + else /* EOF */ + do_quit = 1; + } + else if (event.data.fd == s->fd) + { + error = clib_socket_rx (s, 100); + if (error) + break; + + if (clib_socket_rx_end_of_file (s)) + break; + + str = process_input (str, s, is_interactive, &sent_ttype); + + if (vec_len (str) > 0) + { + int len = vec_len (str); + u8 *p = str, *q = str; + + while (len) + { + /* Search for and skip NUL bytes */ + while (q < (p + len) && *q) + q++; + + n = write (STDOUT_FILENO, p, q - p); + if (n < 0) + { + error = clib_error_return_unix (0, "write"); + goto done; + } + + while (q < (p + len) && !*q) + { + q++; + acked++; /* every NUL is an acknowledgement */ + } + len -= q - p; + p = q; + } + + vec_reset_length (str); + } + + if (do_quit && do_quit < acked) + { + /* Ask the other end to close the connection */ + clib_socket_tx_add_formatted (s, "quit\n"); + clib_socket_tx (s); + do_quit = 0; + } + if (cmd && sent_ttype) + { + /* We wait until after the TELNET TTYPE option has been sent. + * That is to make sure the session at the VPP end has switched + * to line-by-line mode, and thus avoid prompts and echoing. + * Note that it does also disable further TELNET option processing. + */ + clib_socket_tx_add_formatted (s, "%s\n", cmd); + clib_socket_tx (s); + vec_free (cmd); + do_quit = acked; /* quit after the next response */ + } + } + else + { + error = clib_error_return (0, "unknown fd"); + goto done; + } + } + + error = clib_socket_close (s); + +done: + vec_free (cmd); + vec_free (str); + if (efd > -1) + close (efd); + + if (is_interactive) + tcsetattr (STDIN_FILENO, TCSAFLUSH, &orig_tio); + + if (error) + { + clib_error_report (error); + return 1; + } + + return 0; +} + +/* *INDENT-ON* */ + +/* + * fd.io coding-style-patch-verification: ON + * + * Local Variables: + * eval: (c-set-style "gnu") + * End: + */ |