56 s =
format (s,
"l2-classify: sw_if_index %d, table %d, offset %x, next %d",
67 #define foreach_l2_output_classify_error \ 68 _(MISS, "Classify misses") \ 69 _(HIT, "Classify hits") \ 70 _(CHAIN_HIT, "Classify hits after chain walk") \ 71 _(DROP, "L2 Classify Drops") 75 #define _(sym,str) L2_OUTPUT_CLASSIFY_ERROR_##sym, 82 #define _(sym,string) string, 141 u32 n_left_from, *from, *to_next;
163 while (n_left_from > 2)
168 u32 sw_if_index0, sw_if_index1;
170 int type_index0, type_index1;
172 u32 table_index0, table_index1;
204 type0 = clib_net_to_host_u16 (h0->
type);
205 type1 = clib_net_to_host_u16 (h1->
type);
207 type_index0 = (type0 == ETHERNET_TYPE_IP4)
209 type_index0 = (type0 == ETHERNET_TYPE_IP6)
212 type_index1 = (type1 == ETHERNET_TYPE_IP4)
214 type_index1 = (type1 == ETHERNET_TYPE_IP6)
219 rt->
l2cm->classify_table_index_by_sw_if_index
220 [type_index0][sw_if_index0];
222 if (table_index0 != ~0)
233 rt->
l2cm->classify_table_index_by_sw_if_index
234 [type_index1][sw_if_index1];
236 if (table_index1 != ~0)
249 while (n_left_from > 0)
268 type0 = clib_net_to_host_u16 (h0->
type);
270 type_index0 = (type0 == ETHERNET_TYPE_IP4)
272 type_index0 = (type0 == ETHERNET_TYPE_IP6)
276 table_index0 = rt->
l2cm->classify_table_index_by_sw_if_index
277 [type_index0][sw_if_index0];
279 if (table_index0 != ~0)
295 while (n_left_from > 0)
302 while (n_left_from > 0 && n_left_to_next > 0)
311 vnet_classify_entry_t *e0;
324 table_index2 =
vnet_buffer (p2)->l2_classify.table_index;
344 table_index0 =
vnet_buffer (b0)->l2_classify.table_index;
359 next0 = (e0->next_index < n_next_nodes) ?
360 e0->next_index : next0;
386 next0 = (e0->next_index < n_next_nodes) ?
387 e0->next_index : next0;
397 b0->
error = node->
errors[L2_OUTPUT_CLASSIFY_ERROR_DROP];
402 L2OUTPUT_FEAT_OUTPUT_CLASSIFY);
405 ~L2OUTPUT_FEAT_OUTPUT_CLASSIFY;
420 to_next, n_left_to_next,
428 L2_OUTPUT_CLASSIFY_ERROR_MISS, misses);
430 L2_OUTPUT_CLASSIFY_ERROR_HIT, hits);
432 L2_OUTPUT_CLASSIFY_ERROR_CHAIN_HIT,
440 .name =
"l2-output-classify",
441 .vector_size =
sizeof (
u32),
480 cm->l2_out_feat_next);
482 rt->
vcm = cm->vnet_classify_main;
498 rt->
vcm = cm->vnet_classify_main;
511 (
u32) enable_disable);
529 u32 other_table_index)
536 if (ip4_table_index != ~0 &&
538 return VNET_API_ERROR_NO_SUCH_TABLE;
540 if (ip6_table_index != ~0 &&
542 return VNET_API_ERROR_NO_SUCH_TABLE2;
544 if (other_table_index != ~0 &&
546 return VNET_API_ERROR_NO_SUCH_TABLE3;
561 [sw_if_index] = ip4_table_index;
564 [sw_if_index] = ip6_table_index;
567 [sw_if_index] = other_table_index;
578 u32 sw_if_index = ~0;
579 u32 ip4_table_index = ~0;
580 u32 ip6_table_index = ~0;
581 u32 other_table_index = ~0;
589 else if (
unformat (input,
"ip4-table %d", &ip4_table_index))
591 else if (
unformat (input,
"ip6-table %d", &ip6_table_index))
593 else if (
unformat (input,
"other-table %d", &other_table_index))
599 if (sw_if_index == ~0)
603 if (ip4_table_index == ~0 && ip6_table_index == ~0
604 && other_table_index == ~0)
640 .path =
"set interface l2 output classify",
642 "set interface l2 output classify intfc <<interface-name>> [ip4-table <n>]\n" 643 " [ip6-table <n>] [other-table <n>]",
u64 vnet_classify_hash_packet(vnet_classify_table_t *t, u8 *h)
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
int vnet_l2_output_classify_set_tables(u32 sw_if_index, u32 ip4_table_index, u32 ip6_table_index, u32 other_table_index)
Set l2 per-protocol, per-interface output classification tables.
l2_output_classify_main_t * l2cm
l2 input classifier main object pointer
char ** l2output_get_feat_names(void)
u8 runtime_data[0]
Function dependent node-runtime data.
vnet_main_t * vnet_get_main(void)
VLIB_NODE_FUNCTION_MULTIARCH(l2_output_classify_node, l2_output_classify_node_fn)
void vnet_l2_output_classify_enable_disable(u32 sw_if_index, int enable_disable)
Enable/disable l2 input classification on a specific interface.
static f64 vlib_time_now(vlib_main_t *vm)
clib_error_t * l2_output_classify_init(vlib_main_t *vm)
l2 output classsifier feature initialization.
static uword l2_output_classify_node_fn(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
l2 output classifier node.
struct _vlib_node_registration vlib_node_registration_t
unformat_function_t unformat_vnet_sw_interface
vlib_error_t * errors
Vector of errors for this node.
static u32 vnet_l2_feature_next(vlib_buffer_t *b, u32 *next_nodes, u32 feat_bit)
Return the graph node index for the feature corresponding to the next set bit after clearing the curr...
static char * l2_output_classify_error_strings[]
#define VLIB_INIT_FUNCTION(x)
#define vlib_prefetch_buffer_header(b, type)
Prefetch buffer metadata.
#define clib_error_return(e, args...)
static void vnet_classify_prefetch_bucket(vnet_classify_table_t *t, u64 hash)
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.
static void vnet_classify_prefetch_entry(vnet_classify_table_t *t, u64 hash)
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
static u8 * format_l2_output_classify_trace(u8 *s, va_list *args)
Packet trace format function.
u32 sw_if_index
interface handle for the ith packet
struct _l2_classify_main l2_output_classify_main_t
l2_output_classify_main_t l2_output_classify_main
l2 output classifier main data structure.
static void * vlib_buffer_get_current(vlib_buffer_t *b)
Get pointer to current data to process.
VLIB_WORKER_INIT_FUNCTION(l2_output_classify_worker_init)
static void * vlib_node_get_runtime_data(vlib_main_t *vm, u32 node_index)
Get node runtime private data by node index.
u32 node_index
Node index.
#define vlib_validate_buffer_enqueue_x1(vm, node, next_index, to_next, n_left_to_next, bi0, next0)
Finish enqueueing one buffer forward in the graph.
#define vlib_get_next_frame(vm, node, next_index, vectors, n_vectors_left)
Get pointer to next frame vector data by (vlib_node_runtime_t, next_index).
vlib_error_t error
Error code for buffers to be enqueued to error handler.
static void vlib_node_increment_counter(vlib_main_t *vm, u32 node_index, u32 counter_index, u64 increment)
l2_output_classify_next_t
clib_error_t * l2_output_classify_worker_init(vlib_main_t *vm)
static uword vnet_classify_get_offset(vnet_classify_table_t *t, vnet_classify_entry_t *v)
#define CLIB_PREFETCH(addr, size, type)
static void feat_bitmap_init_next_nodes(vlib_main_t *vm, u32 node_index, u32 num_features, char **feat_names, u32 *next_nodes)
Initialize the feature next-node indexes of a graph node.
#define VLIB_BUFFER_IS_TRACED
vnet_classify_main_t * vcm
use-case independent main object pointer
#define pool_is_free_index(P, I)
Use free bitmap to query whether given index is free.
void vlib_put_next_frame(vlib_main_t *vm, vlib_node_runtime_t *r, u32 next_index, u32 n_vectors_left)
Release pointer to next frame vector data.
u32 table_index
classifier table which provided the final result
#define foreach_l2_output_classify_error
#define VLIB_CLI_COMMAND(x,...)
struct _vnet_classify_main vnet_classify_main_t
u16 cached_next_index
Next frame index that vector arguments were last enqueued to last time this node ran.
static void vlib_buffer_advance(vlib_buffer_t *b, word l)
Advance current data pointer by the supplied (signed!) amount.
#define VLIB_NODE_FLAG_TRACE
vnet_classify_main_t vnet_classify_main
static clib_error_t * int_l2_output_classify_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
l2_output_classify_error_t
static void * vlib_add_trace(vlib_main_t *vm, vlib_node_runtime_t *r, vlib_buffer_t *b, u32 n_data_bytes)
static void * vlib_frame_vector_args(vlib_frame_t *f)
Get pointer to frame vector data.
u32 session_offset
offset in classifier heap of the corresponding session
vlib_node_registration_t l2_output_classify_node
(constructor) VLIB_REGISTER_NODE (l2_output_classify_node)
#define VLIB_REGISTER_NODE(x,...)
u32 next_index
graph arc index selected for this packet
u16 flags
Copy of main node flags.
#define CLIB_CACHE_LINE_BYTES
u32 flags
buffer flags: VLIB_BUFFER_FREE_LIST_INDEX_MASK: bits used to store free list index, VLIB_BUFFER_IS_TRACED: trace this buffer.
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
static vlib_buffer_t * vlib_get_buffer(vlib_main_t *vm, u32 buffer_index)
Translate buffer index into buffer pointer.
vnet_classify_entry_t * vnet_classify_find_entry(vnet_classify_table_t *t, u8 *h, u64 hash, f64 now)