ligang/vpp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Metadata / opaque formatting belongs in vpp

Browse Source 
VPP graph dispatch trace record description:

    0                   1                   2                   3
    0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
   | Major Version | Minor Version | NStrings      | ProtoHint     |
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
   | Buffer index (big endian)                                     |
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
   + VPP graph node name ...     ...               | NULL octet    |
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
   | Buffer Metadata ... ...                       | NULL octet    |
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
   | Buffer Opaque ... ...                         | NULL octet    |
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
   | Buffer Opaque 2 ... ...                       | NULL octet    |
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
   | VPP ASCII packet trace (if NStrings > 4)      | NULL octet    |
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
   | Packet data (up to 16K)                                       |
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

Graph dispatch records comprise a version stamp, an indication of how
many NULL-terminated strings will follow the record header, and a
protocol hint.

The buffer index allows downstream consumers of these data to easily
filter/track single packets as they traverse the forwarding
graph. FWIW, the 32-bit buffer index is stored in big endian format.

As of this writing, major version = 1, minor version = 0. Nstrings
will be either 4 or 5.

Here is the current set of protocol hints:

typedef enum
  {
    VLIB_NODE_PROTO_HINT_NONE = 0,
    VLIB_NODE_PROTO_HINT_ETHERNET,
    VLIB_NODE_PROTO_HINT_IP4,
    VLIB_NODE_PROTO_HINT_IP6,
    VLIB_NODE_PROTO_HINT_TCP,
    VLIB_NODE_PROTO_HINT_UDP,
    VLIB_NODE_N_PROTO_HINTS,
  } vlib_node_proto_hint_t;

Example: VLIB_NODE_PROTO_HINT_IP6 means that the first octet of packet
data SHOULD be 0x60, and should begin an ipv6 packet header.

Change-Id: Idf310bad80cc0e4207394c80f18db5f77c378741
Signed-off-by: Dave Barach <dave@barachs.net>
This commit is contained in:
Dave Barach
2018-11-27 16:52:59 -05:00
committed by Florin Coras
parent 8861c1a1f2
commit 7fff3d2054
10 changed files with 526 additions and 862 deletions
Download Patch File Download Diff File Expand all files Collapse all files

961
extras/wireshark/packet-vpp.c
View File

File diff suppressed because it is too large Load Diff

145
src/vlib/main.c
View File

@@ -945,25 +945,69 @@ add_trajectory_trace (vlib_buffer_t * b, u32 node_index)
#endif
}
u8 *format_vnet_buffer_flags (u8 * s, va_list * args) __attribute__ ((weak));
u8 *
format_vnet_buffer_flags (u8 * s, va_list * args)
{
s = format (s, "BUG STUB %s", __FUNCTION__);
return s;
}
u8 *format_vnet_buffer_opaque (u8 * s, va_list * args) __attribute__ ((weak));
u8 *
format_vnet_buffer_opaque (u8 * s, va_list * args)
{
s = format (s, "BUG STUB %s", __FUNCTION__);
return s;
}
u8 *format_vnet_buffer_opaque2 (u8 * s, va_list * args)
__attribute__ ((weak));
u8 *
format_vnet_buffer_opaque2 (u8 * s, va_list * args)
{
s = format (s, "BUG STUB %s", __FUNCTION__);
return s;
}
static u8 *
format_buffer_metadata (u8 * s, va_list * args)
{
vlib_buffer_t *b = va_arg (*args, vlib_buffer_t *);
s = format (s, "flags: %U\n", format_vnet_buffer_flags, b);
s = format (s, "current_data: %d, current_length: %d\n",
(i32) (b->current_data), (i32) (b->current_length));
s = format (s, "current_config_index: %d, flow_id: %x, next_buffer: %x\n",
b->current_config_index, b->flow_id, b->next_buffer);
s = format (s, "error: %d, n_add_refs: %d, buffer_pool_index: %d\n",
(u32) (b->error), (u32) (b->n_add_refs),
(u32) (b->buffer_pool_index));
s = format (s,
"trace_index: %d, recycle_count: %d, len_not_first_buf: %d\n",
b->trace_index, b->recycle_count,
b->total_length_not_including_first_buffer);
s = format (s, "free_list_index: %d\n", (u32) (b->free_list_index));
return s;
}
#define A(x) vec_add1(vm->pcap_buffer, (x))
static void
dispatch_pcap_trace (vlib_main_t * vm,
vlib_node_runtime_t * node, vlib_frame_t * frame)
{
int i;
vlib_buffer_t *bufs[VLIB_FRAME_SIZE], **bufp, *b;
u8 name_tlv[64];
pcap_main_t *pm = &vm->dispatch_pcap_main;
vlib_trace_main_t *tm = &vm->trace_main;
u32 capture_size;
vlib_node_t *n;
u8 *packet_trace = 0;
i32 n_left;
f64 time_now = vlib_time_now (vm);
u32 *from;
u32 name_length;
u16 trace_length;
u8 version[2];
u8 *d;
u8 string_count;
/* Input nodes don't have frames yet */
if (frame == 0 || frame->n_vectors == 0)
@@ -973,15 +1017,7 @@ dispatch_pcap_trace (vlib_main_t * vm,
vlib_get_buffers (vm, from, bufs, frame->n_vectors);
bufp = bufs;
/* Create a node name TLV, since WS can't possibly guess */
n = vlib_get_node (vm, node->node_index);
name_length = vec_len (n->name);
name_length = name_length < ARRAY_LEN (name_tlv) - 2 ?
name_length : ARRAY_LEN (name_tlv) - 2;
name_tlv[0] = (u8) name_length;
clib_memcpy_fast (name_tlv + 1, n->name, name_length);
name_tlv[name_length + 1] = 0;
for (i = 0; i < frame->n_vectors; i++)
{
@@ -989,10 +1025,34 @@ dispatch_pcap_trace (vlib_main_t * vm,
{
b = bufp[i];
version[0] = VLIB_PCAP_MAJOR_VERSION;
version[1] = VLIB_PCAP_MINOR_VERSION;
vec_reset_length (vm->pcap_buffer);
string_count = 0;
vec_reset_length (packet_trace);
/* Version, flags */
A ((u8) VLIB_PCAP_MAJOR_VERSION);
A ((u8) VLIB_PCAP_MINOR_VERSION);
A (0 /* string_count */ );
A (n->protocol_hint);
/* Buffer index (big endian) */
A ((from[i] >> 24) & 0xff);
A ((from[i] >> 16) & 0xff);
A ((from[i] >> 8) & 0xff);
A ((from[i] >> 0) & 0xff);
/* Node name, NULL-terminated ASCII */
vm->pcap_buffer = format (vm->pcap_buffer, "%v%c", n->name, 0);
string_count++;
vm->pcap_buffer = format (vm->pcap_buffer, "%U%c",
format_buffer_metadata, b, 0);
string_count++;
vm->pcap_buffer = format (vm->pcap_buffer, "%U%c",
format_vnet_buffer_opaque, b, 0);
string_count++;
vm->pcap_buffer = format (vm->pcap_buffer, "%U%c",
format_vnet_buffer_opaque2, b, 0);
string_count++;
/* Is this packet traced? */
if (PREDICT_FALSE (b->flags & VLIB_BUFFER_IS_TRACED))
@@ -1000,55 +1060,29 @@ dispatch_pcap_trace (vlib_main_t * vm,
vlib_trace_header_t **h
= pool_elt_at_index (tm->trace_buffer_pool, b->trace_index);
packet_trace = format (packet_trace, "%U%c",
format_vlib_trace, vm, h[0], 0);
vm->pcap_buffer = format (vm->pcap_buffer, "%U%c",
format_vlib_trace, vm, h[0], 0);
string_count++;
}
/* Figure out how many bytes we're capturing */
/* *INDENT-OFF* */
capture_size = (sizeof (vlib_buffer_t) - VLIB_BUFFER_PRE_DATA_SIZE)
+ sizeof (version)
+ vlib_buffer_length_in_chain (vm, b)
+ sizeof (u32) + (name_length + 2) /* +2: count plus NULL byte */
+ (vec_len (packet_trace) + 2); /* +2: trace count */
/* *INDENT-ON* */
/* Save the string count */
vm->pcap_buffer[2] = string_count;
/* Figure out how many bytes in the pcap trace */
capture_size = vec_len (vm->pcap_buffer) +
+vlib_buffer_length_in_chain (vm, b);
clib_spinlock_lock_if_init (&pm->lock);
n_left = clib_min (capture_size, 16384);
d = pcap_add_packet (pm, time_now, n_left, capture_size);
/* Copy the (major, minor) version numbers */
clib_memcpy_fast (d, version, sizeof (version));
d += sizeof (version);
/* Copy the buffer index */
clib_memcpy_fast (d, &from[i], sizeof (u32));
d += 4;
/* Copy the name TLV */
clib_memcpy_fast (d, name_tlv, name_length + 2);
d += name_length + 2;
/* Copy the buffer metadata, but not the rewrite space */
clib_memcpy_fast (d, b, sizeof (*b) - VLIB_BUFFER_PRE_DATA_SIZE);
d += sizeof (*b) - VLIB_BUFFER_PRE_DATA_SIZE;
trace_length = vec_len (packet_trace);
/* Copy the trace data length (may be zero) */
clib_memcpy_fast (d, &trace_length, sizeof (trace_length));
d += 2;
/* Copy packet trace data (if any) */
if (vec_len (packet_trace))
clib_memcpy_fast (d, packet_trace, vec_len (packet_trace));
d += vec_len (packet_trace);
/* Copy the header */
clib_memcpy_fast (d, vm->pcap_buffer, vec_len (vm->pcap_buffer));
d += vec_len (vm->pcap_buffer);
n_left = clib_min
(vlib_buffer_length_in_chain (vm, b),
16384 -
((sizeof (*b) - VLIB_BUFFER_PRE_DATA_SIZE) +
(trace_length + 2)));
(16384 - vec_len (vm->pcap_buffer)));
/* Copy the packet data */
while (1)
{
@@ -1064,7 +1098,6 @@ dispatch_pcap_trace (vlib_main_t * vm,
clib_spinlock_unlock_if_init (&pm->lock);
}
}
vec_free (packet_trace);
}
static_always_inline u64

1
src/vlib/main.h
View File

@@ -134,6 +134,7 @@ typedef struct vlib_main_t
/* Pcap dispatch trace main */
pcap_main_t dispatch_pcap_main;
uword dispatch_pcap_enable;
u8 *pcap_buffer;
/* Error handling. */
vlib_error_main_t error_main;

1
src/vlib/node.c
View File

@@ -350,6 +350,7 @@ register_node (vlib_main_t * vm, vlib_node_registration_t * r)
clib_memset (n, 0, sizeof (n[0]));
n->index = vec_len (nm->nodes);
n->node_fn_registrations = r->node_fn_registrations;
n->protocol_hint = r->protocol_hint;
vec_add1 (nm->nodes, n);

17
src/vlib/node.h
View File

@@ -55,6 +55,17 @@ typedef uword (vlib_node_function_t) (struct vlib_main_t * vm,
struct vlib_node_runtime_t * node,
struct vlib_frame_t * frame);
typedef enum
{
VLIB_NODE_PROTO_HINT_NONE = 0,
VLIB_NODE_PROTO_HINT_ETHERNET,
VLIB_NODE_PROTO_HINT_IP4,
VLIB_NODE_PROTO_HINT_IP6,
VLIB_NODE_PROTO_HINT_TCP,
VLIB_NODE_PROTO_HINT_UDP,
VLIB_NODE_N_PROTO_HINTS,
} vlib_node_proto_hint_t;
typedef enum
{
/* An internal node on the call graph (could be output). */
@@ -134,6 +145,9 @@ typedef struct _vlib_node_registration
/* Node flags. */
u16 flags;
/* protocol at b->data[b->current_data] upon entry to the dispatch fn */
u8 protocol_hint;
/* Size of scalar and vector arguments in bytes. */
u16 scalar_size, vector_size;
@@ -320,6 +334,9 @@ typedef struct vlib_node_t
/* Number of bytes of run time data. */
u8 runtime_data_bytes;
/* protocol at b->data[b->current_data] upon entry to the dispatch fn */
u8 protocol_hint;
/* Number of error codes used by this node. */
u16 n_errors;

4
src/vnet/buffer.c
View File

@@ -24,9 +24,9 @@ format_vnet_buffer (u8 * s, va_list * args)
u32 indent = format_get_indent (s);
u8 *a = 0;
#define _(bit, name, v) \
#define _(bit,name,ss,v) \
if (v && (b->flags & VNET_BUFFER_F_##name)) \
a = format (a, "%s ", v);
a = format (a, "%s ", ss);
foreach_vnet_buffer_flag
#undef _
if (b->flags & VNET_BUFFER_F_L2_HDR_OFFSET_VALID)

44
src/vnet/buffer.h
View File

@@ -45,40 +45,40 @@
/**
* Flags that are set in the high order bits of ((vlib_buffer*)b)->flags
*/
#define foreach_vnet_buffer_flag \
_( 1, L4_CHECKSUM_COMPUTED, "l4-cksum-computed") \
_( 2, L4_CHECKSUM_CORRECT, "l4-cksum-correct") \
_( 3, VLAN_2_DEEP, "vlan-2-deep") \
_( 4, VLAN_1_DEEP, "vlan-1-deep") \
_( 5, SPAN_CLONE, "span-clone") \
_( 6, LOOP_COUNTER_VALID, 0) \
_( 7, LOCALLY_ORIGINATED, "local") \
_( 8, IS_IP4, "ip4") \
_( 9, IS_IP6, "ip6") \
_(10, OFFLOAD_IP_CKSUM, "offload-ip-cksum") \
_(11, OFFLOAD_TCP_CKSUM, "offload-tcp-cksum") \
_(12, OFFLOAD_UDP_CKSUM, "offload-udp-cksum") \
_(13, IS_NATED, "nated") \
_(14, L2_HDR_OFFSET_VALID, 0) \
_(15, L3_HDR_OFFSET_VALID, 0) \
_(16, L4_HDR_OFFSET_VALID, 0) \
_(17, FLOW_REPORT, "flow-report") \
_(18, IS_DVR, "dvr") \
_(19, QOS_DATA_VALID, 0)
#define foreach_vnet_buffer_flag \
_( 1, L4_CHECKSUM_COMPUTED, "l4-cksum-computed", 1) \
_( 2, L4_CHECKSUM_CORRECT, "l4-cksum-correct", 1) \
_( 3, VLAN_2_DEEP, "vlan-2-deep", 1) \
_( 4, VLAN_1_DEEP, "vlan-1-deep", 1) \
_( 5, SPAN_CLONE, "span-clone", 1) \
_( 6, LOOP_COUNTER_VALID, "loop-counter-valid", 0) \
_( 7, LOCALLY_ORIGINATED, "local", 1) \
_( 8, IS_IP4, "ip4", 1) \
_( 9, IS_IP6, "ip6", 1) \
_(10, OFFLOAD_IP_CKSUM, "offload-ip-cksum", 1) \
_(11, OFFLOAD_TCP_CKSUM, "offload-tcp-cksum", 1) \
_(12, OFFLOAD_UDP_CKSUM, "offload-udp-cksum", 1) \
_(13, IS_NATED, "natted", 1) \
_(14, L2_HDR_OFFSET_VALID, "l2_hdr_offset_valid", 0) \
_(15, L3_HDR_OFFSET_VALID, "l3_hdr_offset_valid", 0) \
_(16, L4_HDR_OFFSET_VALID, "l4_hdr_offset_valid", 0) \
_(17, FLOW_REPORT, "flow-report", 1) \
_(18, IS_DVR, "dvr", 1) \
_(19, QOS_DATA_VALID, "qos-data-valid", 0)
#define VNET_BUFFER_FLAGS_VLAN_BITS \
(VNET_BUFFER_F_VLAN_1_DEEP | VNET_BUFFER_F_VLAN_2_DEEP)
enum
{
#define _(bit, name, v) VNET_BUFFER_F_##name = (1 << LOG2_VLIB_BUFFER_FLAG_USER(bit)),
#define _(bit, name, s, v) VNET_BUFFER_F_##name = (1 << LOG2_VLIB_BUFFER_FLAG_USER(bit)),
foreach_vnet_buffer_flag
#undef _
};
enum
{
#define _(bit, name, v) VNET_BUFFER_F_LOG2_##name = LOG2_VLIB_BUFFER_FLAG_USER(bit),
#define _(bit, name, s, v) VNET_BUFFER_F_LOG2_##name = LOG2_VLIB_BUFFER_FLAG_USER(bit),
foreach_vnet_buffer_flag
#undef _
};

212
src/vnet/interface_format.c
View File

@@ -367,6 +367,218 @@ format_vnet_sw_interface_name_override (u8 * s, va_list * args)
return s;
}
u8 *
format_vnet_buffer_flags (u8 * s, va_list * args)
{
vlib_buffer_t *buf = va_arg (*args, vlib_buffer_t *);
#define _(a,b,c,v) if (buf->flags & VNET_BUFFER_F_##b) s = format (s, "%s ", c);
foreach_vnet_buffer_flag;
#undef _
return s;
}
u8 *
format_vnet_buffer_opaque (u8 * s, va_list * args)
{
vlib_buffer_t *b = va_arg (*args, vlib_buffer_t *);
vnet_buffer_opaque_t *o = (vnet_buffer_opaque_t *) b->opaque;
int i;
s = format (s, "raw: ");
for (i = 0; i < ARRAY_LEN (b->opaque); i++)
s = format (s, "%08x ", b->opaque[i]);
vec_add1 (s, '\n');
s = format (s,
"sw_if_index[VLIB_RX]: %d, sw_if_index[VLIB_TX]: %d",
o->sw_if_index[0], o->sw_if_index[1]);
vec_add1 (s, '\n');
s = format (s,
"L2 offset %d, L3 offset %d, L4 offset %d, feature arc index %d",
(u32) (o->l2_hdr_offset),
(u32) (o->l3_hdr_offset),
(u32) (o->l4_hdr_offset), (u32) (o->feature_arc_index));
vec_add1 (s, '\n');
s = format (s,
"ip.adj_index[VLIB_RX]: %d, ip.adj_index[VLIB_TX]: %d",
(u32) (o->ip.adj_index[0]), (u32) (o->ip.adj_index[1]));
vec_add1 (s, '\n');
s = format (s,
"ip.flow_hash: 0x%x, ip.save_protocol: 0x%x, ip.fib_index: %d",
o->ip.flow_hash, o->ip.save_protocol, o->ip.fib_index);
vec_add1 (s, '\n');
s = format (s,
"ip.save_rewrite_length: %d, ip.rpf_id: %d",
o->ip.save_rewrite_length, o->ip.rpf_id);
vec_add1 (s, '\n');
s = format (s,
"ip.icmp.type: %d ip.icmp.code: %d, ip.icmp.data: 0x%x",
(u32) (o->ip.icmp.type),
(u32) (o->ip.icmp.code), o->ip.icmp.data);
vec_add1 (s, '\n');
s = format (s,
"ip.reass.next_index: %d, ip.reass.estimated_mtu: %d",
o->ip.reass.next_index, (u32) (o->ip.reass.estimated_mtu));
vec_add1 (s, '\n');
s = format (s,
"ip.reass.fragment_first: %d ip.reass.fragment_last: %d",
(u32) (o->ip.reass.fragment_first),
(u32) (o->ip.reass.fragment_last));
vec_add1 (s, '\n');
s = format (s,
"ip.reass.range_first: %d ip.reass.range_last: %d",
(u32) (o->ip.reass.range_first),
(u32) (o->ip.reass.range_last));
vec_add1 (s, '\n');
s = format (s,
"ip.reass.next_range_bi: 0x%x, ip.reass.ip6_frag_hdr_offset: %d",
o->ip.reass.next_range_bi,
(u32) (o->ip.reass.ip6_frag_hdr_offset));
vec_add1 (s, '\n');
s = format (s,
"mpls.ttl: %d, mpls.exp: %d, mpls.first: %d, "
"mpls.save_rewrite_length: %d, mpls.bier.n_bytes: %d",
(u32) (o->mpls.ttl), (u32) (o->mpls.exp), (u32) (o->mpls.first),
o->mpls.save_rewrite_length, (u32) (o->mpls.bier.n_bytes));
vec_add1 (s, '\n');
s = format (s,
"l2.feature_bitmap: %08x, l2.bd_index: %d, l2.l2_len: %d, "
"l2.shg: %d, l2.l2fib_sn: %d, l2.bd_age: %d",
o->l2.feature_bitmap, (u32) (o->l2.bd_index),
(u32) (o->l2.l2_len), (u32) (o->l2.shg), (u32) (o->l2.l2fib_sn),
(u32) (o->l2.bd_age));
vec_add1 (s, '\n');
s = format (s,
"l2t.next_index: %d, l2t.session_index: %d",
(u32) (o->l2t.next_index), o->l2t.session_index);
vec_add1 (s, '\n');
s = format (s,
"l2_classify.table_index: %d, l2_classify.opaque_index: %d, "
"l2_classify.hash: 0x%llx",
o->l2_classify.table_index,
o->l2_classify.opaque_index, o->l2_classify.hash);
vec_add1 (s, '\n');
s = format (s, "policer.index: %d", o->policer.index);
vec_add1 (s, '\n');
s = format (s,
"ipsec.flags: 0x%x, ipsec.sad_index: %d",
o->ipsec.flags, o->ipsec.sad_index);
vec_add1 (s, '\n');
s = format (s, "map.mtu: %d", (u32) (o->map.mtu));
vec_add1 (s, '\n');
s = format (s,
"map_t.v6.saddr: 0x%x, map_t.v6.daddr: 0x%x, "
"map_t.v6.frag_offset: %d, map_t.v6.l4_offset: %d",
o->map_t.v6.saddr,
o->map_t.v6.daddr,
(u32) (o->map_t.v6.frag_offset), (u32) (o->map_t.v6.l4_offset));
vec_add1 (s, '\n');
s = format (s,
"map_t.v6.l4_protocol: %d, map_t.checksum_offset: %d, "
"map_t.mtu: %d",
(u32) (o->map_t.v6.l4_protocol),
(u32) (o->map_t.checksum_offset), (u32) (o->map_t.mtu));
vec_add1 (s, '\n');
s = format (s,
"ip_frag.mtu: %d, ip_frag.next_index: %d, ip_frag.flags: 0x%x",
(u32) (o->ip_frag.mtu),
(u32) (o->ip_frag.next_index), (u32) (o->ip_frag.flags));
vec_add1 (s, '\n');
s = format (s, "cop.current_config_index: %d", o->cop.current_config_index);
vec_add1 (s, '\n');
s = format (s, "lisp.overlay_afi: %d", (u32) (o->lisp.overlay_afi));
vec_add1 (s, '\n');
s = format
(s, "tcp.connection_index: %d, tcp.seq_number: %d, tcp.seq_end: %d, "
"tcp.ack_number: %d, tcp.hdr_offset: %d, tcp.data_offset: %d",
o->tcp.connection_index,
o->tcp.seq_number,
o->tcp.seq_end,
o->tcp.ack_number,
(u32) (o->tcp.hdr_offset), (u32) (o->tcp.data_offset));
vec_add1 (s, '\n');
s = format (s,
"tcp.data_len: %d, tcp.flags: 0x%x",
(u32) (o->tcp.data_len), (u32) (o->tcp.flags));
vec_add1 (s, '\n');
s = format (s,
"sctp.connection_index: %d, sctp.sid: %d, sctp.ssn: %d, "
"sctp.tsn: %d, sctp.hdr_offset: %d",
o->sctp.connection_index,
(u32) (o->sctp.sid),
(u32) (o->sctp.ssn),
(u32) (o->sctp.tsn), (u32) (o->sctp.hdr_offset));
vec_add1 (s, '\n');
s = format
(s, "sctp.data_offset: %d, sctp.data_len: %d, sctp.subconn_idx: %d, "
"sctp.flags: 0x%x",
(u32) (o->sctp.data_offset),
(u32) (o->sctp.data_len),
(u32) (o->sctp.subconn_idx), (u32) (o->sctp.flags));
vec_add1 (s, '\n');
s = format (s, "snat.flags: 0x%x", o->snat.flags);
vec_add1 (s, '\n');
return s;
}
u8 *
format_vnet_buffer_opaque2 (u8 * s, va_list * args)
{
vlib_buffer_t *b = va_arg (*args, vlib_buffer_t *);
vnet_buffer_opaque2_t *o = (vnet_buffer_opaque2_t *) b->opaque2;
int i;
s = format (s, "raw: ");
for (i = 0; i < ARRAY_LEN (b->opaque2); i++)
s = format (s, "%08x ", b->opaque2[i]);
vec_add1 (s, '\n');
s = format (s, "qos.bits: %x, qos.source: %x",
(u32) (o->qos.bits), (u32) (o->qos.source));
vec_add1 (s, '\n');
s = format (s, "loop_counter: %d", o->loop_counter);
vec_add1 (s, '\n');
s = format (s, "gbp.flags: %x, gbp.src_epg: %d",
(u32) (o->gbp.flags), (u32) (o->gbp.src_epg));
vec_add1 (s, '\n');
s = format (s, "pg_replay_timestamp: %llu", (u32) (o->pg_replay_timestamp));
vec_add1 (s, '\n');
return s;
}
uword
unformat_vnet_hw_interface (unformat_input_t * input, va_list * args)
{

1
src/vnet/ip/ip4_input.c
View File

@@ -317,6 +317,7 @@ char *ip4_error_strings[] = {
VLIB_REGISTER_NODE (ip4_input_node) = {
.name = "ip4-input",
.vector_size = sizeof (u32),
.protocol_hint = VLIB_NODE_PROTO_HINT_IP4,
.n_errors = IP4_N_ERROR,
.error_strings = ip4_error_strings,

2
src/vnet/tcp/tcp_output.c
View File

@@ -2214,6 +2214,7 @@ VLIB_REGISTER_NODE (tcp4_output_node) =
/* Takes a vector of packets. */
.vector_size = sizeof (u32),
.n_errors = TCP_N_ERROR,
.protocol_hint = VLIB_NODE_PROTO_HINT_TCP,
.error_strings = tcp_error_strings,
.n_next_nodes = TCP_OUTPUT_N_NEXT,
.next_nodes = {
@@ -2236,6 +2237,7 @@ VLIB_REGISTER_NODE (tcp6_output_node) =
/* Takes a vector of packets. */
.vector_size = sizeof (u32),
.n_errors = TCP_N_ERROR,
.protocol_hint = VLIB_NODE_PROTO_HINT_TCP,
.error_strings = tcp_error_strings,
.n_next_nodes = TCP_OUTPUT_N_NEXT,
.next_nodes = {