ligang/vpp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
3c80c106a88f18523b7edaeaa8acf5728fd72ec3
vpp/src/plugins/mdata/mdata.c
Dave Barach d7b306657d mdata: buffer metadata change tracker plugin 
A handy tool in case you need to know which metadata will be changed
when a packet visits a certain node.

Reflect metadata changes into format functions used by the
vpp-specific wireshark dissector.

Type: feature

Signed-off-by: Dave Barach <dave@barachs.net>
Change-Id: I96fe8a24db4082bb29fe2a33cc522e8616a3a1bb
2019-10-25 14:36:13 +00:00

494 lines
14 KiB
C
Raw Blame History

/*
* mdata.c - Buffer metadata change tracker
*
* Copyright (c) 2019 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/vnet.h>
#include <vnet/plugin/plugin.h>
#include <mdata/mdata.h>
#include <vlibapi/api.h>
#include <vlibmemory/api.h>
#include <vpp/app/version.h>
#include <stdbool.h>
#include <mdata/mdata.api_enum.h>
#include <mdata/mdata.api_types.h>
#define REPLY_MSG_ID_BASE mmp->msg_id_base
#include <vlibapi/api_helper_macros.h>
mdata_main_t mdata_main;
/** @file buffer metadata change tracker
*/
static mdata_t mdata_none;
/** Metadata tracking callback
before_or_after: 0 => before, 1=> after
*/
static void
mdata_trace_callback (vlib_main_t * vm, u64 * c0, u64 * c1,
vlib_node_runtime_t * node,
vlib_frame_t * frame, int before_or_after)
{
int i;
mdata_main_t *mm = &mdata_main;
vlib_buffer_t *bufs[VLIB_FRAME_SIZE], **b;
u32 *from;
u32 n_left_from;
mdata_t *before, *modifies;
u8 *after;
/* Input nodes don't have frames, etc. */
if (frame == 0)
return;
n_left_from = frame->n_vectors;
if (n_left_from == 0)
return;
from = vlib_frame_vector_args (frame);
vlib_get_buffers (vm, from, bufs, n_left_from);
b = bufs;
if (before_or_after == 1 /* after */ )
goto after_pass;
/* Resize the per-thread "before" vector to cover the current frame */
vec_reset_length (mm->before_per_thread[vm->thread_index]);
vec_validate (mm->before_per_thread[vm->thread_index], n_left_from - 1);
before = mm->before_per_thread[vm->thread_index];
before->node_index = ~0;
/* Before we call the dispatch fn, copy metadata. */
while (n_left_from > 0)
{
clib_memcpy_fast (before->mdata, b[0], sizeof (before->mdata));
b++;
before++;
n_left_from--;
}
return;
after_pass:
/* Recover the metadata copy we saved a moment ago */
before = mm->before_per_thread[vm->thread_index];
/* We'd better have the same number of buffers... */
ASSERT (n_left_from == vec_len (before));
ASSERT (node->node_index);
clib_spinlock_lock_if_init (&mm->modify_lock);
/*
* Resize the per-node accumulator vector as needed
* Paint the "no data" patter across any nodes we haven't seen yet
*/
vec_validate_init_empty (mm->modifies, node->node_index, mdata_none);
modifies = vec_elt_at_index (mm->modifies, node->node_index);
modifies->node_index = node->node_index;
before = mm->before_per_thread[vm->thread_index];
/* Walk the frame */
while (n_left_from > 0)
{
after = (u8 *) b[0];
/* Compare metadata before and after node dispatch fn */
for (i = 0; i < ARRAY_LEN (before->mdata); i++)
{
/* Mark mdata octet changed */
if (before->mdata[i] != after[i])
modifies->mdata[i] = 0xff;
}
b++;
before++;
n_left_from--;
}
clib_spinlock_unlock_if_init (&mm->modify_lock);
}
int
mdata_enable_disable (mdata_main_t * mmp, int enable_disable)
{
int rv = 0;
vlib_thread_main_t *thread_main = vlib_get_thread_main ();
int i;
if (mmp->modify_lock == 0 && thread_main->n_vlib_mains > 1)
clib_spinlock_init (&mmp->modify_lock);
if (vec_len (mmp->before_per_thread) == 0)
{
mdata_none.node_index = ~0;
vec_validate (mmp->before_per_thread, vec_len (vlib_mains) - 1);
}
/* Reset the per-node accumulator, see vec_validate_init_empty above */
vec_reset_length (mmp->modifies);
for (i = 0; i < vec_len (vlib_mains); i++)
{
if (vlib_mains[i] == 0)
continue;
clib_callback_enable_disable
(vlib_mains[i]->vlib_node_runtime_perf_counter_cbs,
vlib_mains[i]->vlib_node_runtime_perf_counter_cb_tmp,
vlib_mains[i]->worker_thread_main_loop_callback_lock,
(void *) mdata_trace_callback, enable_disable);
}
return rv;
}
static clib_error_t *
mdata_enable_disable_command_fn (vlib_main_t * vm,
unformat_input_t * input,
vlib_cli_command_t * cmd)
{
mdata_main_t *mmp = &mdata_main;
int enable_disable = 1;
int rv;
while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
{
if (unformat (input, "disable") || unformat (input, "off"))
enable_disable = 0;
if (unformat (input, "enable") || unformat (input, "on"))
enable_disable = 1;
else
break;
}
rv = mdata_enable_disable (mmp, enable_disable);
switch (rv)
{
case 0:
break;
default:
return clib_error_return (0, "mdata_enable_disable returned %d", rv);
}
return 0;
}
/*?
* This command enables or disables buffer metadata change tracking
*
*@cliexpar
* To enable buffer metadata change tracking:
*@cliexstart{buffer metadata tracking on}
* Tracking enabled
*@cliexend
*
*@cliexstart{buffer metadata tracking off}
* Tracking disabled
*@cliexend
?*/
/* *INDENT-OFF* */
VLIB_CLI_COMMAND (mdata_enable_disable_command, static) =
{
.path = "buffer metadata tracking",
.short_help = "buffer metadata tracking [on][off]",
.function = mdata_enable_disable_command_fn,
};
/* *INDENT-ON* */
/* API message handler */
static void vl_api_mdata_enable_disable_t_handler
(vl_api_mdata_enable_disable_t * mp)
{
vl_api_mdata_enable_disable_reply_t *rmp;
mdata_main_t *mmp = &mdata_main;
int rv;
rv = mdata_enable_disable (mmp, (int) (mp->enable_disable));
REPLY_MACRO (VL_API_MDATA_ENABLE_DISABLE_REPLY);
}
/* API definitions */
#include <mdata/mdata.api.c>
static clib_error_t *
mdata_init (vlib_main_t * vm)
{
mdata_main_t *mmp = &mdata_main;
clib_error_t *error = 0;
mmp->vlib_main = vm;
mmp->vnet_main = vnet_get_main ();
/* Add our API messages to the global name_crc hash table */
mmp->msg_id_base = setup_message_id_table ();
return error;
}
VLIB_INIT_FUNCTION (mdata_init);
/* *INDENT-OFF* */
VLIB_PLUGIN_REGISTER () =
{
.version = VPP_BUILD_VER,
.description = "Buffer metadata change tracker."
};
/* *INDENT-ON* */
#define foreach_primary_metadata_field \
_(current_data) \
_(current_length) \
_(flags) \
_(flow_id) \
_(ref_count) \
_(buffer_pool_index) \
_(error) \
_(next_buffer) \
_(current_config_index) \
_(punt_reason)
#define foreach_opaque_metadata_field \
_(sw_if_index[0]) \
_(sw_if_index[1]) \
_(l2_hdr_offset) \
_(l3_hdr_offset) \
_(l4_hdr_offset) \
_(feature_arc_index) \
_(ip.adj_index[0]) \
_(ip.adj_index[1]) \
_(ip.flow_hash) \
_(ip.save_protocol) \
_(ip.fib_index) \
_(ip.icmp.type) \
_(ip.icmp.code) \
_(ip.icmp.data) \
_(ip.reass.next_index) \
_(ip.reass.error_next_index) \
_(ip.reass.owner_thread_index) \
_(ip.reass.ip_proto) \
_(ip.reass.l4_src_port) \
_(ip.reass.l4_dst_port) \
_(ip.reass.estimated_mtu) \
_(ip.reass.fragment_first) \
_(ip.reass.fragment_last) \
_(ip.reass.range_first) \
_(ip.reass.range_last) \
_(ip.reass.next_range_bi) \
_(ip.reass.ip6_frag_hdr_offset) \
_(mpls.ttl) \
_(mpls.exp) \
_(mpls.first) \
_(mpls.save_rewrite_length) \
_(mpls.mpls_hdr_length) \
_(mpls.bier.n_bytes) \
_(l2.feature_bitmap) \
_(l2.bd_index) \
_(l2.l2fib_sn) \
_(l2.l2_len) \
_(l2.shg) \
_(l2.bd_age) \
_(l2t.next_index) \
_(l2t.session_index) \
_(l2_classify.table_index) \
_(l2_classify.opaque_index) \
_(l2_classify.hash) \
_(policer.index) \
_(ipsec.sad_index) \
_(ipsec.protect_index) \
_(map.mtu) \
_(map_t.map_domain_index) \
_(map_t.v6.saddr) \
_(map_t.v6.daddr) \
_(map_t.v6.frag_offset) \
_(map_t.v6.l4_offset) \
_(map_t.v6.l4_protocol) \
_(map_t.checksum_offset) \
_(map_t.mtu) \
_(ip_frag.mtu) \
_(ip_frag.next_index) \
_(ip_frag.flags) \
_(cop.current_config_index) \
_(lisp.overlay_afi) \
_(tcp.connection_index) \
_(tcp.seq_number) \
_(tcp.next_node_opaque) \
_(tcp.seq_end) \
_(tcp.ack_number) \
_(tcp.hdr_offset) \
_(tcp.data_offset) \
_(tcp.data_len) \
_(tcp.flags) \
_(snat.flags)
#define foreach_opaque2_metadata_field \
_(qos.bits) \
_(qos.source) \
_(loop_counter) \
_(gbp.flags) \
_(gbp.sclass) \
_(gso_size) \
_(gso_l4_hdr_sz) \
_(pg_replay_timestamp)
static u8 *
format_buffer_metadata_changes (u8 * s, va_list * args)
{
mdata_main_t *mm = va_arg (*args, mdata_main_t *);
int verbose = va_arg (*args, int);
mdata_t *modifies;
vlib_buffer_t *b;
vnet_buffer_opaque_t *o;
vnet_buffer_opaque2_t *o2;
vlib_node_t *node;
int i, j;
int printed;
clib_spinlock_lock_if_init (&mm->modify_lock);
for (i = 0; i < vec_len (mm->modifies); i++)
{
modifies = vec_elt_at_index (mm->modifies, i);
node = vlib_get_node (mm->vlib_main, i);
/* No data for this node? */
if (modifies->node_index == ~0)
{
if (verbose)
s = format (s, "\n%v: no data\n", node->name);
continue;
}
/* We visited the node, but it may not have changed any metadata... */
for (j = 0; j < ARRAY_LEN (modifies->mdata); j++)
{
if (modifies->mdata[j])
goto found;
}
s = format (s, "\n%v: no metadata changes\n", node->name);
continue;
found:
/* Fields which the node modifies will be non-zero */
b = (vlib_buffer_t *) (modifies->mdata);
/* Dump primary metadata changes */
s = format (s, "\n%v: ", node->name);
printed = 0;
#define _(n) if (b->n) {s = format (s, "%s ", #n); printed = 1;}
foreach_primary_metadata_field;
#undef _
if (printed == 0)
s = format (s, "no vlib_buffer_t metadata changes");
vec_add1 (s, '\n');
/*
* Dump opaque union changes.
* Hopefully this will give folks a clue about opaque
* union data conflicts. That's the point of the exercise...
*/
o = vnet_buffer (b);
printed = 0;
s = format (s, " vnet_buffer_t: ");
#define _(n) if (o->n) {s = format (s, "%s ", #n); printed = 1;}
foreach_opaque_metadata_field;
#undef _
if (printed == 0)
s = format (s, "no changes");
vec_add1 (s, '\n');
o2 = vnet_buffer2 (b);
printed = 0;
s = format (s, " vnet_buffer2_t: ");
#define _(n) if (o2->n) {s = format (s, "%s ", #n); printed = 1;}
foreach_opaque2_metadata_field;
#undef _
if (printed == 0)
s = format (s, "no changes");
vec_add1 (s, '\n');
}
clib_spinlock_unlock_if_init (&mm->modify_lock);
return s;
}
static clib_error_t *
show_metadata_command_fn (vlib_main_t * vm,
unformat_input_t * input, vlib_cli_command_t * cmd)
{
int verbose = 0;
while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
{
if (unformat (input, "verbose %=", &verbose, 1))
;
else
break;
}
vlib_cli_output (vm, "%U", format_buffer_metadata_changes, &mdata_main,
verbose);
return 0;
}
/*?
* This command displays buffer metadata change information
*@cliexpar
* How to display buffer metadata change information
*@cliexstart{show buffer metadata}
* ethernet-input: current_data current_length flags error
* vnet_buffer_t: l2_hdr_offset l3_hdr_offset
* vnet_buffer2_t: no changes
*@cliexend
?*/
/* *INDENT-OFF* */
VLIB_CLI_COMMAND (show_metadata_command, static) =
{
.path = "show buffer metadata",
.short_help = "show buffer metadata",
.function = show_metadata_command_fn,
};
/* *INDENT-OFF* */
/*
* fd.io coding-style-patch-verification: ON
*
* Local Variables:
* eval: (c-set-style "gnu")
* End:
*/
Reference in New Issue View Git Blame Copy Permalink