2 * Copyright (c) 2018 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:
7 * http://www.apache.org/licenses/LICENSE-2.0
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.
16 #include <vnet/devices/pipe/pipe.h>
18 #include <vppinfra/sparse_vec.h>
22 * @brief Pipe Interfaces.
24 * A pipe interface, like the UNIX pipe, is a pair of vpp interfaces
27 const static pipe_t PIPE_INVALID = {
33 * Various 'module' level variables
35 typedef struct pipe_main_t_
38 * Allocated pipe instances
43 * the per-swif-index array of pipes. Each end of the pipe is stored against
44 * its respective sw_if_index
49 static pipe_main_t pipe_main;
52 * The pipe rewrite is the same size as an ethernet header (since it
53 * is an ethernet interface and the DP is optimised for writing
54 * sizeof(ethernet_header_t) rewrites. However, there are no MAC addresses
55 * since pipes don't have them.
58 pipe_build_rewrite (vnet_main_t * vnm,
60 vnet_link_t link_type, const void *dst_address)
68 #define _(a,b) case VNET_LINK_##a: type = ETHERNET_TYPE_##b; break
78 vec_validate (rewrite, sizeof (ethernet_header_t));
80 h = (ethernet_header_t *) rewrite;
81 h->type = clib_host_to_net_u16 (type);
87 VNET_HW_INTERFACE_CLASS (pipe_hw_interface_class) = {
89 .build_rewrite = pipe_build_rewrite,
90 .flags = VNET_HW_INTERFACE_CLASS_FLAG_P2P,
95 pipe_get (u32 sw_if_index)
97 vec_validate_init_empty (pipe_main.pipes, sw_if_index, PIPE_INVALID);
99 return (&pipe_main.pipes[sw_if_index]);
103 unformat_pipe_interface (unformat_input_t * input, va_list * args)
105 vnet_main_t *vnm = va_arg (*args, vnet_main_t *);
106 u32 *result = va_arg (*args, u32 *);
108 ethernet_main_t *em = ðernet_main;
109 ethernet_interface_t *eif;
111 if (!unformat_user (input, unformat_vnet_hw_interface, vnm, &hw_if_index))
114 eif = ethernet_get_interface (em, hw_if_index);
117 *result = hw_if_index;
123 #define VNET_PIPE_TX_NEXT_ETHERNET_INPUT VNET_INTERFACE_TX_N_NEXT
126 * The TX function bounces the packets back to pipe-rx with the TX interface
130 pipe_tx (vlib_main_t * vm, vlib_node_runtime_t * node, vlib_frame_t * frame)
132 u32 n_left_from, n_left_to_next, n_copy, *from, *to_next;
133 u32 next_index = VNET_PIPE_TX_NEXT_ETHERNET_INPUT;
134 u32 i, sw_if_index = 0, n_pkts = 0;
138 n_left_from = frame->n_vectors;
139 from = vlib_frame_vector_args (frame);
141 while (n_left_from > 0)
143 vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
145 n_copy = clib_min (n_left_from, n_left_to_next);
147 clib_memcpy_fast (to_next, from, n_copy * sizeof (from[0]));
148 n_left_to_next -= n_copy;
149 n_left_from -= n_copy;
153 b = vlib_get_buffer (vm, from[i]);
154 sw_if_index = vnet_buffer (b)->sw_if_index[VLIB_TX];
156 pipe = &pipe_main.pipes[sw_if_index];
157 // Set up RX index to be recv'd by the other end of the pipe
158 vnet_buffer (b)->sw_if_index[VLIB_RX] = pipe->sw_if_index;
159 vnet_buffer (b)->sw_if_index[VLIB_TX] = ~0;
166 vlib_put_next_frame (vm, node, next_index, n_left_to_next);
169 return frame->n_vectors;
173 format_pipe_name (u8 * s, va_list * args)
175 u32 dev_instance = va_arg (*args, u32);
176 return format (s, "pipe%d", dev_instance);
179 static clib_error_t *
180 pipe_admin_up_down (vnet_main_t * vnm, u32 hw_if_index, u32 flags)
182 vnet_hw_interface_t *hi;
185 u32 hw_flags = ((flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) ?
186 VNET_HW_INTERFACE_FLAG_LINK_UP : 0);
187 vnet_hw_interface_set_flags (vnm, hw_if_index, hw_flags);
190 hi = vnet_get_hw_interface (vnm, hw_if_index);
191 hash_foreach (id, sw_if_index, hi->sub_interface_sw_if_index_by_id,
193 vnet_sw_interface_set_flags (vnm, sw_if_index, flags);
201 VNET_DEVICE_CLASS (pipe_device_class) = {
203 .format_device_name = format_pipe_name,
204 .tx_function = pipe_tx,
205 .admin_up_down_function = pipe_admin_up_down,
209 #define foreach_pipe_rx_next \
210 _ (DROP, "error-drop")
212 typedef enum pipe_rx_next_t_
214 #define _(s,n) PIPE_RX_NEXT_##s,
220 typedef struct pipe_rx_trace_t_
226 format_pipe_rx_trace (u8 * s, va_list * va)
228 CLIB_UNUSED (vlib_main_t * vm) = va_arg (*va, vlib_main_t *);
229 CLIB_UNUSED (vlib_node_t * node) = va_arg (*va, vlib_node_t *);
230 pipe_rx_trace_t *t = va_arg (*va, pipe_rx_trace_t *);
232 s = format (s, "%U", format_ethernet_header, t->packet_data);
238 * The pipe-rx node is a sibling of ethernet-input so steal it's
239 * next node mechanism
241 static_always_inline void
242 pipe_determine_next_node (ethernet_main_t * em,
245 vlib_buffer_t * b0, pipe_rx_next_t * next0)
249 *next0 = em->l2_next;
251 else if (type0 == ETHERNET_TYPE_IP4)
253 *next0 = em->l3_next.input_next_ip4;
255 else if (type0 == ETHERNET_TYPE_IP6)
257 *next0 = em->l3_next.input_next_ip6;
259 else if (type0 == ETHERNET_TYPE_MPLS)
261 *next0 = em->l3_next.input_next_mpls;
264 else if (em->redirect_l3)
266 // L3 Redirect is on, the cached common next nodes will be
267 // pointing to the redirect node, catch the uncommon types here
268 *next0 = em->redirect_l3_next;
272 // uncommon ethertype, check table
274 i0 = sparse_vec_index (em->l3_next.input_next_by_type, type0);
275 *next0 = vec_elt (em->l3_next.input_next_by_type, i0);
277 // The table is not populated with LLC values, so check that now.
280 *next0 = PIPE_RX_NEXT_DROP;
285 static_always_inline uword
286 pipe_rx (vlib_main_t * vm,
287 vlib_node_runtime_t * node, vlib_frame_t * from_frame)
289 u32 n_left_from, next_index, *from, *to_next;
292 from = vlib_frame_vector_args (from_frame);
293 n_left_from = from_frame->n_vectors;
295 if (node->flags & VLIB_NODE_FLAG_TRACE)
296 vlib_trace_frame_buffers_only (vm, node,
300 sizeof (pipe_rx_trace_t));
302 next_index = node->cached_next_index;
304 while (n_left_from > 0)
306 vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
308 while (n_left_from >= 4 && n_left_to_next >= 2)
310 u32 bi0, sw_if_index0, bi1, sw_if_index1;
311 pipe_rx_next_t next0, next1;
312 ethernet_header_t *e0, *e1;
313 vlib_buffer_t *b0, *b1;
314 pipe_t *pipe0, *pipe1;
318 // Prefetch next iteration
320 vlib_buffer_t *p2, *p3;
322 p2 = vlib_get_buffer (vm, from[2]);
323 p3 = vlib_get_buffer (vm, from[3]);
324 vlib_prefetch_buffer_header (p2, STORE);
325 vlib_prefetch_buffer_header (p3, STORE);
326 clib_prefetch_load (p2->data);
327 clib_prefetch_load (p3->data);
339 b0 = vlib_get_buffer (vm, bi0);
340 b1 = vlib_get_buffer (vm, bi1);
342 e0 = vlib_buffer_get_current (b0);
343 e1 = vlib_buffer_get_current (b1);
344 sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX];
345 sw_if_index1 = vnet_buffer (b1)->sw_if_index[VLIB_RX];
346 type0 = clib_net_to_host_u16 (e0->type);
347 type1 = clib_net_to_host_u16 (e1->type);
348 pipe0 = &pipe_main.pipes[sw_if_index0];
349 pipe1 = &pipe_main.pipes[sw_if_index1];
351 vnet_buffer (b0)->l2_hdr_offset = b0->current_data;
352 vnet_buffer (b1)->l2_hdr_offset = b1->current_data;
354 vnet_buffer (b0)->l3_hdr_offset =
355 vnet_buffer (b0)->l2_hdr_offset + sizeof (ethernet_header_t);
356 vnet_buffer (b1)->l3_hdr_offset =
357 vnet_buffer (b1)->l2_hdr_offset + sizeof (ethernet_header_t);
359 VNET_BUFFER_F_L2_HDR_OFFSET_VALID |
360 VNET_BUFFER_F_L3_HDR_OFFSET_VALID;
362 VNET_BUFFER_F_L2_HDR_OFFSET_VALID |
363 VNET_BUFFER_F_L3_HDR_OFFSET_VALID;
365 is_l20 = pipe0->subint.flags & SUBINT_CONFIG_L2;
366 is_l21 = pipe1->subint.flags & SUBINT_CONFIG_L2;
369 * from discussion with Neale - we do not support the tagged traffic.
370 * So assume a simple ethernet header
372 vnet_buffer (b0)->l2.l2_len = sizeof (ethernet_header_t);
373 vnet_buffer (b1)->l2.l2_len = sizeof (ethernet_header_t);
374 vlib_buffer_advance (b0, is_l20 ? 0 : sizeof (ethernet_header_t));
375 vlib_buffer_advance (b1, is_l21 ? 0 : sizeof (ethernet_header_t));
377 pipe_determine_next_node (ðernet_main, is_l20, type0, b0,
379 pipe_determine_next_node (ðernet_main, is_l21, type1, b1,
382 vlib_validate_buffer_enqueue_x2 (vm, node, next_index,
383 to_next, n_left_to_next,
384 bi0, bi1, next0, next1);
386 while (n_left_from > 0 && n_left_to_next > 0)
388 u32 bi0, sw_if_index0;
390 pipe_rx_next_t next0;
391 ethernet_header_t *e0;
403 b0 = vlib_get_buffer (vm, bi0);
405 e0 = vlib_buffer_get_current (b0);
406 sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX];
407 type0 = clib_net_to_host_u16 (e0->type);
408 pipe0 = &pipe_main.pipes[sw_if_index0];
410 vnet_buffer (b0)->l2_hdr_offset = b0->current_data;
411 vnet_buffer (b0)->l3_hdr_offset =
412 vnet_buffer (b0)->l2_hdr_offset + sizeof (ethernet_header_t);
414 VNET_BUFFER_F_L2_HDR_OFFSET_VALID |
415 VNET_BUFFER_F_L3_HDR_OFFSET_VALID;
417 is_l20 = pipe0->subint.flags & SUBINT_CONFIG_L2;
419 vnet_buffer (b0)->l2.l2_len = sizeof (ethernet_header_t);
420 vlib_buffer_advance (b0, is_l20 ? 0 : sizeof (ethernet_header_t));
422 pipe_determine_next_node (ðernet_main, is_l20, type0, b0,
425 vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
426 to_next, n_left_to_next,
430 vlib_put_next_frame (vm, node, next_index, n_left_to_next);
433 return from_frame->n_vectors;
437 VLIB_REGISTER_NODE (pipe_rx_node) = {
440 /* Takes a vector of packets. */
441 .vector_size = sizeof (u32),
442 .format_trace = format_pipe_rx_trace,
444 .sibling_of = "ethernet-input",
449 * Maintain a bitmap of allocated pipe instance numbers.
451 #define PIPE_MAX_INSTANCE (16 * 1024)
454 pipe_instance_alloc (u8 is_specified, u32 want)
457 * Check for dynamically allocaetd instance number.
463 bit = clib_bitmap_first_clear (pipe_main.instances);
464 if (bit >= PIPE_MAX_INSTANCE)
468 pipe_main.instances = clib_bitmap_set (pipe_main.instances, bit, 1);
475 if (want >= PIPE_MAX_INSTANCE)
483 if (clib_bitmap_get (pipe_main.instances, want))
489 * Grant allocation request.
491 pipe_main.instances = clib_bitmap_set (pipe_main.instances, want, 1);
497 pipe_instance_free (u32 instance)
499 if (instance >= PIPE_MAX_INSTANCE)
504 if (clib_bitmap_get (pipe_main.instances, instance) == 0)
509 pipe_main.instances = clib_bitmap_set (pipe_main.instances, instance, 0);
513 static clib_error_t *
514 pipe_create_sub_interface (vnet_hw_interface_t * hi,
515 u32 sub_id, u32 * sw_if_index)
517 vnet_sw_interface_t template;
519 clib_memset (&template, 0, sizeof (template));
520 template.type = VNET_SW_INTERFACE_TYPE_PIPE;
521 template.flood_class = VNET_FLOOD_CLASS_NORMAL;
522 template.sup_sw_if_index = hi->sw_if_index;
523 template.sub.id = sub_id;
525 return (vnet_create_sw_interface (vnet_get_main (),
526 &template, sw_if_index));
530 vnet_create_pipe_interface (u8 is_specified,
532 u32 * parent_sw_if_index, u32 pipe_sw_if_index[2])
534 vnet_main_t *vnm = vnet_get_main ();
535 vlib_main_t *vm = vlib_get_main ();
536 vnet_eth_interface_registration_t eir = {};
541 vnet_hw_interface_t *hi;
548 ASSERT (parent_sw_if_index);
550 clib_memset (address, 0, sizeof (address));
553 * Allocate a pipe instance. Either select one dynamically
554 * or try to use the desired user_instance number.
556 instance = pipe_instance_alloc (is_specified, user_instance);
559 return VNET_API_ERROR_INVALID_REGISTRATION;
563 * Default MAC address (0000:0000:0000 + instance) is allocated
565 address[5] = instance;
567 eir.dev_class_index = pipe_device_class.index;
568 eir.dev_instance = instance;
569 eir.address = address;
570 hw_if_index = vnet_eth_register_interface (vnm, &eir);
572 hi = vnet_get_hw_interface (vnm, hw_if_index);
573 *parent_sw_if_index = hi->sw_if_index;
574 slot = vlib_node_add_named_next_with_slot (vm, hi->tx_node_index,
576 VNET_PIPE_TX_NEXT_ETHERNET_INPUT);
577 ASSERT (slot == VNET_PIPE_TX_NEXT_ETHERNET_INPUT);
580 * create two sub-interfaces, one for each end of the pipe.
582 error = pipe_create_sub_interface (hi, 0, &pipe_sw_if_index[0]);
587 error = pipe_create_sub_interface (hi, 1, &pipe_sw_if_index[1]);
592 hash_set (hi->sub_interface_sw_if_index_by_id, 0, pipe_sw_if_index[0]);
593 hash_set (hi->sub_interface_sw_if_index_by_id, 1, pipe_sw_if_index[1]);
595 vec_validate_init_empty (pipe_main.pipes, pipe_sw_if_index[0],
597 vec_validate_init_empty (pipe_main.pipes, pipe_sw_if_index[1],
600 pipe_main.pipes[pipe_sw_if_index[0]].sw_if_index = pipe_sw_if_index[1];
601 pipe_main.pipes[pipe_sw_if_index[1]].sw_if_index = pipe_sw_if_index[0];
606 clib_error_report (error);
610 typedef struct pipe_hw_walk_ctx_t_
614 } pipe_hw_walk_ctx_t;
617 pipe_hw_walk (vnet_main_t * vnm, u32 hw_if_index, void *args)
619 vnet_hw_interface_t *hi;
620 pipe_hw_walk_ctx_t *ctx;
623 hi = vnet_get_hw_interface (vnm, hw_if_index);
625 if (hi->dev_class_index == pipe_device_class.index)
627 u32 pipe_sw_if_index[2], id, sw_if_index;
630 hash_foreach (id, sw_if_index, hi->sub_interface_sw_if_index_by_id,
633 pipe_sw_if_index[id] = sw_if_index;
637 ctx->cb (hi->sw_if_index, pipe_sw_if_index, hi->dev_instance, ctx->ctx);
640 return (WALK_CONTINUE);
644 pipe_walk (pipe_cb_fn_t fn, void *ctx)
646 pipe_hw_walk_ctx_t wctx = {
653 vnet_hw_interface_walk (vnet_get_main (), pipe_hw_walk, &wctx);
656 static clib_error_t *
657 create_pipe_interfaces (vlib_main_t * vm,
658 unformat_input_t * input, vlib_cli_command_t * cmd)
662 u32 pipe_sw_if_index[2];
664 u32 user_instance = 0;
666 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
668 if (unformat (input, "instance %d", &user_instance))
674 rv = vnet_create_pipe_interface (is_specified, user_instance,
675 &sw_if_index, pipe_sw_if_index);
678 return clib_error_return (0, "vnet_create_pipe_interface failed");
680 vlib_cli_output (vm, "%U\n", format_vnet_sw_if_index_name,
681 vnet_get_main (), sw_if_index);
686 * Create a pipe interface.
689 * The following two command syntaxes are equivalent:
690 * @cliexcmd{pipe create-interface [mac <mac-addr>] [instance <instance>]}
691 * Example of how to create a pipe interface:
692 * @cliexcmd{pipe create}
695 VLIB_CLI_COMMAND (pipe_create_interface_command, static) = {
696 .path = "pipe create",
697 .short_help = "pipe create [instance <instance>]",
698 .function = create_pipe_interfaces,
703 vnet_delete_pipe_interface (u32 sw_if_index)
705 vnet_main_t *vnm = vnet_get_main ();
706 vnet_sw_interface_t *si;
707 vnet_hw_interface_t *hi;
711 if (pool_is_free_index (vnm->interface_main.sw_interfaces, sw_if_index))
712 return VNET_API_ERROR_INVALID_SW_IF_INDEX;
714 si = vnet_get_sw_interface (vnm, sw_if_index);
715 hw_if_index = si->hw_if_index;
716 hi = vnet_get_hw_interface (vnm, hw_if_index);
717 instance = hi->dev_instance;
719 if (pipe_instance_free (instance) < 0)
721 return VNET_API_ERROR_INVALID_SW_IF_INDEX;
725 hash_foreach (id, sw_if_index, hi->sub_interface_sw_if_index_by_id,
727 vnet_delete_sub_interface(sw_if_index);
728 pipe_main.pipes[sw_if_index] = PIPE_INVALID;
732 ethernet_delete_interface (vnm, hw_if_index);
737 static clib_error_t *
738 delete_pipe_interfaces (vlib_main_t * vm,
739 unformat_input_t * input, vlib_cli_command_t * cmd)
741 vnet_main_t *vnm = vnet_get_main ();
742 u32 sw_if_index = ~0;
745 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
747 if (unformat (input, "%U",
748 unformat_vnet_sw_interface, vnm, &sw_if_index))
754 if (sw_if_index == ~0)
755 return clib_error_return (0, "interface not specified");
757 rv = vnet_delete_pipe_interface (sw_if_index);
760 return clib_error_return (0, "vnet_delete_pipe_interface failed");
766 * Delete a pipe interface.
769 * The following two command syntaxes are equivalent:
770 * @cliexcmd{pipe delete intfc <interface>}
771 * Example of how to delete a pipe interface:
772 * @cliexcmd{pipe delete-interface intfc loop0}
775 VLIB_CLI_COMMAND (pipe_delete_interface_command, static) = {
776 .path = "pipe delete",
777 .short_help = "pipe delete <interface>",
778 .function = delete_pipe_interfaces,
783 * fd.io coding-style-patch-verification: ON
786 * eval: (c-set-style "gnu")