Line data Source code
1 : /*
2 : * Copyright (c) 2015 Cisco and/or its affiliates.
3 : * Licensed under the Apache License, Version 2.0 (the "License");
4 : * you may not use this file except in compliance with the License.
5 : * You may obtain a copy of the License at:
6 : *
7 : * http://www.apache.org/licenses/LICENSE-2.0
8 : *
9 : * Unless required by applicable law or agreed to in writing, software
10 : * distributed under the License is distributed on an "AS IS" BASIS,
11 : * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 : * See the License for the specific language governing permissions and
13 : * limitations under the License.
14 : */
15 :
16 : #include <vnet/l2/l2_classify.h>
17 : #include <vnet/api_errno.h>
18 :
19 : /**
20 : * @file
21 : * @brief Layer 2 Output Classifier.
22 : *
23 : * @sa @ref vnet/vnet/classify/vnet_classify.c
24 : * @sa @ref vnet/vnet/classify/vnet_classify.h
25 : */
26 :
27 : typedef struct
28 : {
29 : /** interface handle for the ith packet */
30 : u32 sw_if_index;
31 : /** graph arc index selected for this packet */
32 : u32 next_index;
33 : /** classifier table which provided the final result */
34 : u32 table_index;
35 : /** offset in classifier heap of the corresponding session */
36 : u32 session_offset;
37 : } l2_output_classify_trace_t;
38 :
39 : typedef struct
40 : {
41 : /** use-case independent main object pointer */
42 : vnet_classify_main_t *vcm;
43 : /** l2 input classifier main object pointer */
44 : l2_output_classify_main_t *l2cm;
45 : } l2_output_classify_runtime_t;
46 :
47 : /** Packet trace format function. */
48 : static u8 *
49 0 : format_l2_output_classify_trace (u8 * s, va_list * args)
50 : {
51 0 : CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
52 0 : CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
53 0 : l2_output_classify_trace_t *t =
54 : va_arg (*args, l2_output_classify_trace_t *);
55 :
56 0 : s = format (s, "l2-classify: sw_if_index %d, table %d, offset %x, next %d",
57 : t->sw_if_index, t->table_index, t->session_offset,
58 : t->next_index);
59 0 : return s;
60 : }
61 :
62 : extern l2_output_classify_main_t l2_output_classify_main;
63 :
64 : #ifndef CLIB_MARCH_VARIANT
65 : /** l2 output classifier main data structure. */
66 : l2_output_classify_main_t l2_output_classify_main;
67 : #endif /* CLIB_MARCH_VARIANT */
68 :
69 : #define foreach_l2_output_classify_error \
70 : _(MISS, "Classify misses") \
71 : _(HIT, "Classify hits") \
72 : _(CHAIN_HIT, "Classify hits after chain walk") \
73 : _(DROP, "L2 Classify Drops")
74 :
75 : typedef enum
76 : {
77 : #define _(sym,str) L2_OUTPUT_CLASSIFY_ERROR_##sym,
78 : foreach_l2_output_classify_error
79 : #undef _
80 : L2_OUTPUT_CLASSIFY_N_ERROR,
81 : } l2_output_classify_error_t;
82 :
83 : static char *l2_output_classify_error_strings[] = {
84 : #define _(sym,string) string,
85 : foreach_l2_output_classify_error
86 : #undef _
87 : };
88 :
89 : /**
90 : * @brief l2 output classifier node.
91 : * @node l2-output-classify
92 : *
93 : * This is the l2 output classifier dispatch node
94 : *
95 : * @param vm vlib_main_t corresponding to the current thread.
96 : * @param node vlib_node_runtime_t data for this node.
97 : * @param frame vlib_frame_t whose contents should be dispatched.
98 : *
99 : * @par Graph mechanics: buffer metadata, next index usage
100 : *
101 : * @em Uses:
102 : * - <code>(l2_output_classify_runtime_t *)
103 : * rt->classify_table_index_by_sw_if_index</code>
104 : * Head of the per-interface, per-protocol classifier table chain
105 : * for a specific interface. ~0 => send pkts to the next
106 : * feature in the L2 feature chain.
107 : * - <code>vnet_buffer(b)->sw_if_index[VLIB_TX]</code>
108 : * - Indicates the @c sw_if_index value of the interface that the
109 : * packet was received on.
110 : * - <code>vnet_buffer (b0)->l2.feature_bitmap</code>
111 : * - Used to steer packets across l2 features enabled on the interface
112 : * - <code>(vnet_classify_entry_t) e0->next_index</code>
113 : * - Used to steer traffic when the classifier hits on a session
114 : * - <code>(vnet_classify_entry_t) e0->advance</code>
115 : * - Signed quantity applied via <code>vlib_buffer_advance</code>
116 : * when the classifier hits on a session
117 : * - <code>(vnet_classify_table_t) t0->miss_next_index</code>
118 : * - Used to steer traffic when the classifier misses
119 : *
120 : * @em Sets:
121 : * - <code>vnet_buffer (b0)->l2_classify.table_index</code>
122 : * - Classifier table index of the first classifier table in
123 : * the classifier table chain
124 : * - <code>vnet_buffer (b0)->l2_classify.hash</code>
125 : * - Bounded-index extensible hash corresponding to the
126 : * masked fields in the current packet
127 : * - <code>vnet_buffer (b0)->l2.feature_bitmap</code>
128 : * - Used to steer packets across l2 features enabled on the interface
129 : * - <code>vnet_buffer (b0)->l2_classify.opaque_index</code>
130 : * - Copied from the classifier session object upon classifier hit
131 : *
132 : * @em Counters:
133 : * - <code>L2_OUTPUT_CLASSIFY_ERROR_MISS</code> Classifier misses
134 : * - <code>L2_OUTPUT_CLASSIFY_ERROR_HIT</code> Classifier hits
135 : * - <code>L2_OUTPUT_CLASSIFY_ERROR_CHAIN_HIT</code>
136 : * Classifier hits in other than the first table
137 : */
138 :
139 2300 : VLIB_NODE_FN (l2_output_classify_node) (vlib_main_t * vm,
140 : vlib_node_runtime_t * node,
141 : vlib_frame_t * frame)
142 : {
143 : u32 n_left_from, *from, *to_next;
144 : l2_output_classify_next_t next_index;
145 0 : l2_output_classify_main_t *cm = &l2_output_classify_main;
146 0 : vnet_classify_main_t *vcm = cm->vnet_classify_main;
147 0 : l2_output_classify_runtime_t *rt =
148 : (l2_output_classify_runtime_t *) node->runtime_data;
149 0 : u32 hits = 0;
150 0 : u32 misses = 0;
151 0 : u32 chain_hits = 0;
152 : f64 now;
153 : u32 n_next_nodes;
154 : u32 sw_if_index0;
155 :
156 0 : n_next_nodes = node->n_next_nodes;
157 :
158 0 : now = vlib_time_now (vm);
159 :
160 0 : n_left_from = frame->n_vectors;
161 0 : from = vlib_frame_vector_args (frame);
162 :
163 : /* First pass: compute hash */
164 :
165 0 : while (n_left_from >= 4)
166 : {
167 : vlib_buffer_t *b0, *b1;
168 : u32 bi0, bi1;
169 : ethernet_header_t *h0, *h1;
170 : u32 sw_if_index0, sw_if_index1;
171 : u16 type0, type1;
172 : int type_index0, type_index1;
173 : vnet_classify_table_t *t0, *t1;
174 : u32 table_index0, table_index1;
175 : u32 hash0, hash1;
176 :
177 : /* prefetch next iteration */
178 : {
179 : vlib_buffer_t *p2, *p3;
180 :
181 0 : p2 = vlib_get_buffer (vm, from[2]);
182 0 : p3 = vlib_get_buffer (vm, from[3]);
183 :
184 0 : vlib_prefetch_buffer_header (p2, STORE);
185 0 : clib_prefetch_store (p2->data);
186 0 : vlib_prefetch_buffer_header (p3, STORE);
187 0 : clib_prefetch_store (p3->data);
188 : }
189 :
190 0 : bi0 = from[0];
191 0 : b0 = vlib_get_buffer (vm, bi0);
192 0 : h0 = vlib_buffer_get_current (b0);
193 :
194 0 : bi1 = from[1];
195 0 : b1 = vlib_get_buffer (vm, bi1);
196 0 : h1 = vlib_buffer_get_current (b1);
197 :
198 0 : sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_TX];
199 0 : vnet_buffer (b0)->l2_classify.table_index = ~0;
200 :
201 0 : sw_if_index1 = vnet_buffer (b1)->sw_if_index[VLIB_TX];
202 0 : vnet_buffer (b1)->l2_classify.table_index = ~0;
203 :
204 : /* Select classifier table based on ethertype */
205 0 : type0 = clib_net_to_host_u16 (h0->type);
206 0 : type1 = clib_net_to_host_u16 (h1->type);
207 :
208 0 : type_index0 = (type0 == ETHERNET_TYPE_IP4)
209 0 : ? L2_OUTPUT_CLASSIFY_TABLE_IP4 : L2_OUTPUT_CLASSIFY_TABLE_OTHER;
210 0 : type_index0 = (type0 == ETHERNET_TYPE_IP6)
211 0 : ? L2_OUTPUT_CLASSIFY_TABLE_IP6 : type_index0;
212 :
213 0 : type_index1 = (type1 == ETHERNET_TYPE_IP4)
214 0 : ? L2_OUTPUT_CLASSIFY_TABLE_IP4 : L2_OUTPUT_CLASSIFY_TABLE_OTHER;
215 0 : type_index1 = (type1 == ETHERNET_TYPE_IP6)
216 0 : ? L2_OUTPUT_CLASSIFY_TABLE_IP6 : type_index1;
217 :
218 0 : vnet_buffer (b0)->l2_classify.table_index =
219 0 : table_index0 =
220 0 : rt->l2cm->classify_table_index_by_sw_if_index
221 0 : [type_index0][sw_if_index0];
222 :
223 0 : if (table_index0 != ~0)
224 : {
225 0 : t0 = pool_elt_at_index (vcm->tables, table_index0);
226 :
227 0 : vnet_buffer (b0)->l2_classify.hash = hash0 =
228 0 : vnet_classify_hash_packet (t0, (u8 *) h0);
229 0 : vnet_classify_prefetch_bucket (t0, hash0);
230 : }
231 :
232 0 : vnet_buffer (b1)->l2_classify.table_index =
233 0 : table_index1 =
234 0 : rt->l2cm->classify_table_index_by_sw_if_index
235 0 : [type_index1][sw_if_index1];
236 :
237 0 : if (table_index1 != ~0)
238 : {
239 0 : t1 = pool_elt_at_index (vcm->tables, table_index1);
240 :
241 0 : vnet_buffer (b1)->l2_classify.hash = hash1 =
242 0 : vnet_classify_hash_packet (t1, (u8 *) h1);
243 0 : vnet_classify_prefetch_bucket (t1, hash1);
244 : }
245 :
246 0 : from += 2;
247 0 : n_left_from -= 2;
248 : }
249 :
250 0 : while (n_left_from > 0)
251 : {
252 : vlib_buffer_t *b0;
253 : u32 bi0;
254 : ethernet_header_t *h0;
255 : u16 type0;
256 : u32 type_index0;
257 : vnet_classify_table_t *t0;
258 : u32 table_index0;
259 : u32 hash0;
260 :
261 0 : bi0 = from[0];
262 0 : b0 = vlib_get_buffer (vm, bi0);
263 0 : h0 = vlib_buffer_get_current (b0);
264 :
265 0 : sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_TX];
266 0 : vnet_buffer (b0)->l2_classify.table_index = ~0;
267 :
268 : /* Select classifier table based on ethertype */
269 0 : type0 = clib_net_to_host_u16 (h0->type);
270 :
271 0 : type_index0 = (type0 == ETHERNET_TYPE_IP4)
272 0 : ? L2_OUTPUT_CLASSIFY_TABLE_IP4 : L2_OUTPUT_CLASSIFY_TABLE_OTHER;
273 0 : type_index0 = (type0 == ETHERNET_TYPE_IP6)
274 0 : ? L2_OUTPUT_CLASSIFY_TABLE_IP6 : type_index0;
275 :
276 0 : vnet_buffer (b0)->l2_classify.table_index =
277 0 : table_index0 = rt->l2cm->classify_table_index_by_sw_if_index
278 0 : [type_index0][sw_if_index0];
279 :
280 0 : if (table_index0 != ~0)
281 : {
282 0 : t0 = pool_elt_at_index (vcm->tables, table_index0);
283 :
284 0 : vnet_buffer (b0)->l2_classify.hash = hash0 =
285 0 : vnet_classify_hash_packet (t0, (u8 *) h0);
286 0 : vnet_classify_prefetch_bucket (t0, hash0);
287 : }
288 0 : from++;
289 0 : n_left_from--;
290 : }
291 :
292 0 : next_index = node->cached_next_index;
293 0 : from = vlib_frame_vector_args (frame);
294 0 : n_left_from = frame->n_vectors;
295 :
296 0 : while (n_left_from > 0)
297 : {
298 : u32 n_left_to_next;
299 :
300 0 : vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
301 :
302 : /* Not enough load/store slots to dual loop... */
303 0 : while (n_left_from > 0 && n_left_to_next > 0)
304 : {
305 : u32 bi0;
306 : vlib_buffer_t *b0;
307 0 : u32 next0 = ~0;
308 : ethernet_header_t *h0;
309 : u32 table_index0;
310 : u32 hash0;
311 : vnet_classify_table_t *t0;
312 : vnet_classify_entry_t *e0;
313 :
314 0 : if (PREDICT_TRUE (n_left_from > 2))
315 : {
316 0 : vlib_buffer_t *p2 = vlib_get_buffer (vm, from[2]);
317 : u32 phash2;
318 : u32 table_index2;
319 : vnet_classify_table_t *tp2;
320 :
321 : /*
322 : * Prefetch table entry two ahead. Buffer / data
323 : * were prefetched above...
324 : */
325 0 : table_index2 = vnet_buffer (p2)->l2_classify.table_index;
326 :
327 0 : if (PREDICT_TRUE (table_index2 != ~0))
328 : {
329 0 : tp2 = pool_elt_at_index (vcm->tables, table_index2);
330 0 : phash2 = vnet_buffer (p2)->l2_classify.hash;
331 0 : vnet_classify_prefetch_entry (tp2, phash2);
332 : }
333 : }
334 :
335 : /* speculatively enqueue b0 to the current next frame */
336 0 : bi0 = from[0];
337 0 : to_next[0] = bi0;
338 0 : from += 1;
339 0 : to_next += 1;
340 0 : n_left_from -= 1;
341 0 : n_left_to_next -= 1;
342 :
343 0 : b0 = vlib_get_buffer (vm, bi0);
344 0 : h0 = vlib_buffer_get_current (b0);
345 0 : table_index0 = vnet_buffer (b0)->l2_classify.table_index;
346 0 : e0 = 0;
347 0 : vnet_buffer (b0)->l2_classify.opaque_index = ~0;
348 :
349 0 : if (PREDICT_TRUE (table_index0 != ~0))
350 : {
351 0 : hash0 = vnet_buffer (b0)->l2_classify.hash;
352 0 : t0 = pool_elt_at_index (vcm->tables, table_index0);
353 :
354 0 : e0 = vnet_classify_find_entry (t0, (u8 *) h0, hash0, now);
355 0 : if (e0)
356 : {
357 0 : vnet_buffer (b0)->l2_classify.opaque_index
358 0 : = e0->opaque_index;
359 0 : vlib_buffer_advance (b0, e0->advance);
360 0 : next0 = (e0->next_index < n_next_nodes) ?
361 0 : e0->next_index : next0;
362 0 : hits++;
363 : }
364 : else
365 : {
366 : while (1)
367 : {
368 0 : if (t0->next_table_index != ~0)
369 0 : t0 = pool_elt_at_index (vcm->tables,
370 : t0->next_table_index);
371 : else
372 : {
373 0 : next0 = (t0->miss_next_index < n_next_nodes) ?
374 0 : t0->miss_next_index : next0;
375 0 : misses++;
376 0 : break;
377 : }
378 :
379 0 : hash0 = vnet_classify_hash_packet (t0, (u8 *) h0);
380 : e0 =
381 0 : vnet_classify_find_entry (t0, (u8 *) h0, hash0, now);
382 0 : if (e0)
383 : {
384 0 : vnet_buffer (b0)->l2_classify.opaque_index
385 0 : = e0->opaque_index;
386 0 : vlib_buffer_advance (b0, e0->advance);
387 0 : next0 = (e0->next_index < n_next_nodes) ?
388 0 : e0->next_index : next0;
389 0 : hits++;
390 0 : chain_hits++;
391 0 : break;
392 : }
393 : }
394 : }
395 : }
396 :
397 0 : if (PREDICT_FALSE (next0 == 0))
398 0 : b0->error = node->errors[L2_OUTPUT_CLASSIFY_ERROR_DROP];
399 :
400 : /* Determine the next node and remove ourself from bitmap */
401 0 : if (PREDICT_FALSE (next0 == ~0))
402 0 : next0 = vnet_l2_feature_next (b0, cm->l2_out_feat_next,
403 : L2OUTPUT_FEAT_OUTPUT_CLASSIFY);
404 : else
405 0 : vnet_buffer (b0)->l2.feature_bitmap &=
406 : ~L2OUTPUT_FEAT_OUTPUT_CLASSIFY;
407 :
408 0 : if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE)
409 : && (b0->flags & VLIB_BUFFER_IS_TRACED)))
410 : {
411 : l2_output_classify_trace_t *t =
412 0 : vlib_add_trace (vm, node, b0, sizeof (*t));
413 0 : t->sw_if_index = vnet_buffer (b0)->sw_if_index[VLIB_TX];
414 0 : t->table_index = table_index0;
415 0 : t->next_index = next0;
416 0 : t->session_offset = e0 ? vnet_classify_get_offset (t0, e0) : 0;
417 : }
418 :
419 : /* verify speculative enqueue, maybe switch current next frame */
420 0 : vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
421 : to_next, n_left_to_next,
422 : bi0, next0);
423 : }
424 :
425 0 : vlib_put_next_frame (vm, node, next_index, n_left_to_next);
426 : }
427 :
428 0 : vlib_node_increment_counter (vm, node->node_index,
429 : L2_OUTPUT_CLASSIFY_ERROR_MISS, misses);
430 0 : vlib_node_increment_counter (vm, node->node_index,
431 : L2_OUTPUT_CLASSIFY_ERROR_HIT, hits);
432 0 : vlib_node_increment_counter (vm, node->node_index,
433 : L2_OUTPUT_CLASSIFY_ERROR_CHAIN_HIT,
434 : chain_hits);
435 0 : return frame->n_vectors;
436 : }
437 :
438 : /* *INDENT-OFF* */
439 183788 : VLIB_REGISTER_NODE (l2_output_classify_node) = {
440 : .name = "l2-output-classify",
441 : .vector_size = sizeof (u32),
442 : .format_trace = format_l2_output_classify_trace,
443 : .type = VLIB_NODE_TYPE_INTERNAL,
444 :
445 : .n_errors = ARRAY_LEN(l2_output_classify_error_strings),
446 : .error_strings = l2_output_classify_error_strings,
447 :
448 : .runtime_data_bytes = sizeof (l2_output_classify_runtime_t),
449 :
450 : .n_next_nodes = L2_OUTPUT_CLASSIFY_N_NEXT,
451 :
452 : /* edit / add dispositions here */
453 : .next_nodes = {
454 : [L2_OUTPUT_CLASSIFY_NEXT_DROP] = "error-drop",
455 : },
456 : };
457 : /* *INDENT-ON* */
458 :
459 : #ifndef CLIB_MARCH_VARIANT
460 : /** l2 output classsifier feature initialization. */
461 : clib_error_t *
462 575 : l2_output_classify_init (vlib_main_t * vm)
463 : {
464 575 : l2_output_classify_main_t *cm = &l2_output_classify_main;
465 : l2_output_classify_runtime_t *rt;
466 :
467 575 : rt = vlib_node_get_runtime_data (vm, l2_output_classify_node.index);
468 :
469 575 : cm->vlib_main = vm;
470 575 : cm->vnet_main = vnet_get_main ();
471 575 : cm->vnet_classify_main = &vnet_classify_main;
472 :
473 : /* Initialize the feature next-node indexes */
474 575 : feat_bitmap_init_next_nodes (vm,
475 : l2_output_classify_node.index,
476 : L2OUTPUT_N_FEAT,
477 : l2output_get_feat_names (),
478 575 : cm->l2_out_feat_next);
479 575 : rt->l2cm = cm;
480 575 : rt->vcm = cm->vnet_classify_main;
481 :
482 575 : return 0;
483 : }
484 :
485 16703 : VLIB_INIT_FUNCTION (l2_output_classify_init);
486 :
487 : clib_error_t *
488 54 : l2_output_classify_worker_init (vlib_main_t * vm)
489 : {
490 54 : l2_output_classify_main_t *cm = &l2_output_classify_main;
491 : l2_output_classify_runtime_t *rt;
492 :
493 54 : rt = vlib_node_get_runtime_data (vm, l2_output_classify_node.index);
494 :
495 55 : rt->l2cm = cm;
496 55 : rt->vcm = cm->vnet_classify_main;
497 :
498 55 : return 0;
499 : }
500 :
501 1151 : VLIB_WORKER_INIT_FUNCTION (l2_output_classify_worker_init);
502 :
503 : /** Enable/disable l2 input classification on a specific interface. */
504 : void
505 0 : vnet_l2_output_classify_enable_disable (u32 sw_if_index, int enable_disable)
506 : {
507 :
508 0 : l2output_intf_bitmap_enable (sw_if_index, L2OUTPUT_FEAT_OUTPUT_CLASSIFY,
509 : (u32) enable_disable);
510 0 : }
511 :
512 : /** @brief Set l2 per-protocol, per-interface output classification tables.
513 : *
514 : * @param sw_if_index interface handle
515 : * @param ip4_table_index ip4 classification table index, or ~0
516 : * @param ip6_table_index ip6 classification table index, or ~0
517 : * @param other_table_index non-ip4, non-ip6 classification table index,
518 : * or ~0
519 : * @returns 0 on success, VNET_API_ERROR_NO_SUCH_TABLE, TABLE2, TABLE3
520 : * if the indicated (non-~0) table does not exist.
521 : */
522 :
523 : int
524 0 : vnet_l2_output_classify_set_tables (u32 sw_if_index,
525 : u32 ip4_table_index,
526 : u32 ip6_table_index,
527 : u32 other_table_index)
528 : {
529 0 : l2_output_classify_main_t *cm = &l2_output_classify_main;
530 0 : vnet_classify_main_t *vcm = cm->vnet_classify_main;
531 :
532 : /* Assume that we've validated sw_if_index in the API layer */
533 :
534 0 : if (ip4_table_index != ~0 &&
535 0 : pool_is_free_index (vcm->tables, ip4_table_index))
536 0 : return VNET_API_ERROR_NO_SUCH_TABLE;
537 :
538 0 : if (ip6_table_index != ~0 &&
539 0 : pool_is_free_index (vcm->tables, ip6_table_index))
540 0 : return VNET_API_ERROR_NO_SUCH_TABLE2;
541 :
542 0 : if (other_table_index != ~0 &&
543 0 : pool_is_free_index (vcm->tables, other_table_index))
544 0 : return VNET_API_ERROR_NO_SUCH_TABLE3;
545 :
546 0 : vec_validate
547 : (cm->classify_table_index_by_sw_if_index[L2_OUTPUT_CLASSIFY_TABLE_IP4],
548 : sw_if_index);
549 :
550 0 : vec_validate
551 : (cm->classify_table_index_by_sw_if_index[L2_OUTPUT_CLASSIFY_TABLE_IP6],
552 : sw_if_index);
553 :
554 0 : vec_validate
555 : (cm->classify_table_index_by_sw_if_index[L2_OUTPUT_CLASSIFY_TABLE_OTHER],
556 : sw_if_index);
557 :
558 0 : cm->classify_table_index_by_sw_if_index[L2_OUTPUT_CLASSIFY_TABLE_IP4]
559 0 : [sw_if_index] = ip4_table_index;
560 :
561 0 : cm->classify_table_index_by_sw_if_index[L2_OUTPUT_CLASSIFY_TABLE_IP6]
562 0 : [sw_if_index] = ip6_table_index;
563 :
564 0 : cm->classify_table_index_by_sw_if_index[L2_OUTPUT_CLASSIFY_TABLE_OTHER]
565 0 : [sw_if_index] = other_table_index;
566 :
567 0 : return 0;
568 : }
569 : #endif /* CLIB_MARCH_VARIANT */
570 :
571 : static clib_error_t *
572 0 : int_l2_output_classify_command_fn (vlib_main_t * vm,
573 : unformat_input_t * input,
574 : vlib_cli_command_t * cmd)
575 : {
576 0 : vnet_main_t *vnm = vnet_get_main ();
577 0 : u32 sw_if_index = ~0;
578 0 : u32 ip4_table_index = ~0;
579 0 : u32 ip6_table_index = ~0;
580 0 : u32 other_table_index = ~0;
581 : int rv;
582 :
583 0 : while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
584 : {
585 0 : if (unformat (input, "intfc %U", unformat_vnet_sw_interface,
586 : vnm, &sw_if_index))
587 : ;
588 0 : else if (unformat (input, "ip4-table %d", &ip4_table_index))
589 : ;
590 0 : else if (unformat (input, "ip6-table %d", &ip6_table_index))
591 : ;
592 0 : else if (unformat (input, "other-table %d", &other_table_index))
593 : ;
594 : else
595 0 : break;
596 : }
597 :
598 0 : if (sw_if_index == ~0)
599 0 : return clib_error_return (0, "interface must be specified");
600 :
601 :
602 0 : if (ip4_table_index == ~0 && ip6_table_index == ~0
603 0 : && other_table_index == ~0)
604 : {
605 0 : vlib_cli_output (vm, "L2 classification disabled");
606 0 : vnet_l2_output_classify_enable_disable (sw_if_index, 0 /* enable */ );
607 0 : return 0;
608 : }
609 :
610 0 : rv = vnet_l2_output_classify_set_tables (sw_if_index, ip4_table_index,
611 : ip6_table_index,
612 : other_table_index);
613 0 : switch (rv)
614 : {
615 0 : case 0:
616 0 : vnet_l2_output_classify_enable_disable (sw_if_index, 1 /* enable */ );
617 0 : break;
618 :
619 0 : default:
620 0 : return clib_error_return (0, "vnet_l2_output_classify_set_tables: %d",
621 : rv);
622 : break;
623 : }
624 :
625 0 : return 0;
626 : }
627 :
628 : /*?
629 : * Configure Layer 2 output classification.
630 : *
631 : * @cliexpar
632 : * @cliexstart{set interface l2 output classify intfc <interface-name> [ip4-table <index>] [ip6-table <index>] [other-table <index>]}
633 : * @cliexend
634 : * @todo This is incomplete. This needs a detailed description and a
635 : * practical example.
636 : ?*/
637 : /* *INDENT-OFF* */
638 285289 : VLIB_CLI_COMMAND (int_l2_output_classify_cli, static) = {
639 : .path = "set interface l2 output classify",
640 : .short_help =
641 : "set interface l2 output classify intfc <<interface-name>> [ip4-table <n>]\n"
642 : " [ip6-table <n>] [other-table <n>]",
643 : .function = int_l2_output_classify_command_fn,
644 : };
645 : /* *INDENT-ON* */
646 :
647 : /*
648 : * fd.io coding-style-patch-verification: ON
649 : *
650 : * Local Variables:
651 : * eval: (c-set-style "gnu")
652 : * End:
653 : */
|
