FD.io VPP  v18.10-34-gcce845e
Vector Packet Processing
device.c
Go to the documentation of this file.
1 /*
2  *------------------------------------------------------------------
3  * Copyright (c) 2017 Cisco and/or its affiliates.
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at:
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  *------------------------------------------------------------------
16  */
17 
18 #define _GNU_SOURCE
19 #include <stdint.h>
20 #include <vnet/ethernet/ethernet.h>
21 #include <vnet/ip/ip4_packet.h>
22 #include <vnet/ip/ip6_packet.h>
24 #include <vnet/bonding/node.h>
25 #include <vppinfra/lb_hash_hash.h>
26 #include <vnet/ip/ip.h>
28 
29 #define foreach_bond_tx_error \
30  _(NONE, "no error") \
31  _(IF_DOWN, "interface down") \
32  _(NO_SLAVE, "no slave")
33 
34 typedef enum
35 {
36 #define _(f,s) BOND_TX_ERROR_##f,
38 #undef _
41 
42 static char *bond_tx_error_strings[] = {
43 #define _(n,s) s,
45 #undef _
46 };
47 
48 static u8 *
49 format_bond_tx_trace (u8 * s, va_list * args)
50 {
51  CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
52  CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
53  bond_packet_trace_t *t = va_arg (*args, bond_packet_trace_t *);
54  vnet_hw_interface_t *hw, *hw1;
55  vnet_main_t *vnm = vnet_get_main ();
56 
59  s = format (s, "src %U, dst %U, %s -> %s",
62  hw->name, hw1->name);
63 
64  return s;
65 }
66 
67 #ifndef CLIB_MARCH_VARIANT
68 u8 *
69 format_bond_interface_name (u8 * s, va_list * args)
70 {
71  u32 dev_instance = va_arg (*args, u32);
72  bond_main_t *bm = &bond_main;
73  bond_if_t *bif = pool_elt_at_index (bm->interfaces, dev_instance);
74 
75  s = format (s, "BondEthernet%lu", bif->dev_instance);
76 
77  return s;
78 }
79 #endif
80 
81 static __clib_unused clib_error_t *
83  struct vnet_hw_interface_t *bif_hw,
84  i32 l2_if_adjust)
85 {
86  bond_if_t *bif;
88  struct vnet_hw_interface_t *sif_hw;
89 
91  if (!bif)
92  return 0;
93 
94  if ((bif_hw->l2_if_count == 1) && (l2_if_adjust == 1))
95  {
96  /* Just added first L2 interface on this port */
97  vec_foreach (sw_if_index, bif->slaves)
98  {
99  sif_hw = vnet_get_sup_hw_interface (vnm, *sw_if_index);
100  ethernet_set_flags (vnm, sif_hw->hw_if_index,
102 
103  /* ensure all packets go to ethernet-input */
104  ethernet_set_rx_redirect (vnm, sif_hw, 1);
105  }
106  }
107 
108  return 0;
109 }
110 
111 static __clib_unused clib_error_t *
113  struct vnet_sw_interface_t *st, int is_add)
114 {
115  /* Nothing for now */
116  return 0;
117 }
118 
119 static clib_error_t *
121 {
122  vnet_hw_interface_t *hif = vnet_get_hw_interface (vnm, hw_if_index);
123  uword is_up = (flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) != 0;
124  bond_main_t *bm = &bond_main;
126 
127  bif->admin_up = is_up;
128  if (is_up && vec_len (bif->active_slaves))
131  return 0;
132 }
133 
136  bond_if_t * bif, vlib_buffer_t * b0,
137  uword slave_count)
138 {
139  bond_main_t *bm = &bond_main;
140  vlib_buffer_t *c0;
141  int port;
143  u16 thread_index = vm->thread_index;
145  thread_index);
146 
147  for (port = 1; port < slave_count; port++)
148  {
149  sw_if_index = *vec_elt_at_index (bif->active_slaves, port);
150  c0 = vlib_buffer_copy (vm, b0);
151  if (PREDICT_TRUE (c0 != 0))
152  {
153  vnet_buffer (c0)->sw_if_index[VLIB_TX] = sw_if_index;
156  vlib_get_buffer_index (vm, c0);
158  }
159  }
160 
161  return 0;
162 }
163 
166  bond_if_t * bif, vlib_buffer_t * b0, uword slave_count)
167 {
169  u32 c;
170  u64 *dst = (u64 *) & eth->dst_address[0];
171  u64 a = clib_mem_unaligned (dst, u64);
172  u32 *src = (u32 *) & eth->src_address[2];
173  u32 b = clib_mem_unaligned (src, u32);
174 
175  c = lb_hash_hash_2_tuples (a, b);
176 
177  if (BOND_MODULO_SHORTCUT (slave_count))
178  return (c & (slave_count - 1));
179  else
180  return c % slave_count;
181 }
182 
185 {
186  u16 *ethertype_p;
188 
189  if (!ethernet_frame_is_tagged (clib_net_to_host_u16 (eth->type)))
190  {
191  ethertype_p = &eth->type;
192  }
193  else
194  {
195  vlan = (void *) (eth + 1);
196  ethertype_p = &vlan->type;
197  if (*ethertype_p == ntohs (ETHERNET_TYPE_VLAN))
198  {
199  vlan++;
200  ethertype_p = &vlan->type;
201  }
202  }
203  return ethertype_p;
204 }
205 
208  bond_if_t * bif, vlib_buffer_t * b0, uword slave_count)
209 {
211  u8 ip_version;
212  ip4_header_t *ip4;
213  u16 ethertype, *ethertype_p;
214  u32 *mac1, *mac2, *mac3;
215 
216  ethertype_p = bond_locate_ethertype (eth);
217  ethertype = clib_mem_unaligned (ethertype_p, u16);
218 
219  if ((ethertype != htons (ETHERNET_TYPE_IP4)) &&
220  (ethertype != htons (ETHERNET_TYPE_IP6)))
221  return (bond_load_balance_l2 (vm, node, bif, b0, slave_count));
222 
223  ip4 = (ip4_header_t *) (ethertype_p + 1);
224  ip_version = (ip4->ip_version_and_header_length >> 4);
225 
226  if (ip_version == 0x4)
227  {
228  u32 a, c;
229 
230  mac1 = (u32 *) & eth->dst_address[0];
231  mac2 = (u32 *) & eth->dst_address[4];
232  mac3 = (u32 *) & eth->src_address[2];
233 
234  a = clib_mem_unaligned (mac1, u32) ^ clib_mem_unaligned (mac2, u32) ^
235  clib_mem_unaligned (mac3, u32);
236  c =
238  a);
239  if (BOND_MODULO_SHORTCUT (slave_count))
240  return (c & (slave_count - 1));
241  else
242  return c % slave_count;
243  }
244  else if (ip_version == 0x6)
245  {
246  u64 a;
247  u32 c;
248  ip6_header_t *ip6 = (ip6_header_t *) (eth + 1);
249 
250  mac1 = (u32 *) & eth->dst_address[0];
251  mac2 = (u32 *) & eth->dst_address[4];
252  mac3 = (u32 *) & eth->src_address[2];
253 
254  a = clib_mem_unaligned (mac1, u32) ^ clib_mem_unaligned (mac2, u32) ^
255  clib_mem_unaligned (mac3, u32);
256  c =
258  (&ip6->src_address.as_uword[0], uword),
260  uword),
262  uword),
264  uword), a);
265  if (BOND_MODULO_SHORTCUT (slave_count))
266  return (c & (slave_count - 1));
267  else
268  return c % slave_count;
269  }
270  return (bond_load_balance_l2 (vm, node, bif, b0, slave_count));
271 }
272 
275  bond_if_t * bif, vlib_buffer_t * b0, uword slave_count)
276 {
278  u8 ip_version;
279  uword is_tcp_udp;
280  ip4_header_t *ip4;
281  u16 ethertype, *ethertype_p;
282 
283  ethertype_p = bond_locate_ethertype (eth);
284  ethertype = clib_mem_unaligned (ethertype_p, u16);
285 
286  if ((ethertype != htons (ETHERNET_TYPE_IP4)) &&
287  (ethertype != htons (ETHERNET_TYPE_IP6)))
288  return (bond_load_balance_l2 (vm, node, bif, b0, slave_count));
289 
290  ip4 = (ip4_header_t *) (ethertype_p + 1);
291  ip_version = (ip4->ip_version_and_header_length >> 4);
292 
293  if (ip_version == 0x4)
294  {
295  u32 a, c, t1, t2;
296  tcp_header_t *tcp = (void *) (ip4 + 1);
297 
298  is_tcp_udp = (ip4->protocol == IP_PROTOCOL_TCP) ||
299  (ip4->protocol == IP_PROTOCOL_UDP);
300  t1 = is_tcp_udp ? clib_mem_unaligned (&tcp->src, u16) : 0;
301  t2 = is_tcp_udp ? clib_mem_unaligned (&tcp->dst, u16) : 0;
302  a = t1 ^ t2;
303  c =
304  lb_hash_hash_2_tuples (clib_mem_unaligned (&ip4->address_pair, u64),
305  a);
306  if (BOND_MODULO_SHORTCUT (slave_count))
307  return (c & (slave_count - 1));
308  else
309  return c % slave_count;
310  }
311  else if (ip_version == 0x6)
312  {
313  u64 a;
314  u32 c, t1, t2;
315  ip6_header_t *ip6 = (ip6_header_t *) (eth + 1);
316  tcp_header_t *tcp = (void *) (ip6 + 1);
317 
318  is_tcp_udp = 0;
319  if (PREDICT_TRUE ((ip6->protocol == IP_PROTOCOL_TCP) ||
320  (ip6->protocol == IP_PROTOCOL_UDP)))
321  {
322  is_tcp_udp = 1;
323  tcp = (void *) (ip6 + 1);
324  }
325  else if (ip6->protocol == IP_PROTOCOL_IP6_HOP_BY_HOP_OPTIONS)
326  {
328  (ip6_hop_by_hop_header_t *) (ip6 + 1);
329  if ((hbh->protocol == IP_PROTOCOL_TCP)
330  || (hbh->protocol == IP_PROTOCOL_UDP))
331  {
332  is_tcp_udp = 1;
333  tcp = (tcp_header_t *) ((u8 *) hbh + ((hbh->length + 1) << 3));
334  }
335  }
336  t1 = is_tcp_udp ? clib_mem_unaligned (&tcp->src, u16) : 0;
337  t2 = is_tcp_udp ? clib_mem_unaligned (&tcp->dst, u16) : 0;
338  a = t1 ^ t2;
339  c =
340  lb_hash_hash (clib_mem_unaligned
341  (&ip6->src_address.as_uword[0], uword),
342  clib_mem_unaligned (&ip6->src_address.as_uword[1],
343  uword),
344  clib_mem_unaligned (&ip6->dst_address.as_uword[0],
345  uword),
346  clib_mem_unaligned (&ip6->dst_address.as_uword[1],
347  uword), a);
348  if (BOND_MODULO_SHORTCUT (slave_count))
349  return (c & (slave_count - 1));
350  else
351  return c % slave_count;
352  }
353 
354  return (bond_load_balance_l2 (vm, node, bif, b0, slave_count));
355 }
356 
359  vlib_node_runtime_t * node,
360  bond_if_t * bif, vlib_buffer_t * b0,
361  uword slave_count)
362 {
363  bif->lb_rr_last_index++;
364  if (BOND_MODULO_SHORTCUT (slave_count))
365  bif->lb_rr_last_index &= slave_count - 1;
366  else
367  bif->lb_rr_last_index %= slave_count;
368 
369  return bif->lb_rr_last_index;
370 }
371 
374  vlib_node_runtime_t * node,
375  bond_if_t * bif, vlib_buffer_t * b0,
376  uword slave_count)
377 {
378  /* First interface is the active, the rest is backup */
379  return 0;
380 }
381 
384  vlib_frame_t * frame, bond_if_t * bif,
385  uword slave_count, u32 lb_alg)
386 {
387  bond_main_t *bm = &bond_main;
388  vnet_main_t *vnm = vnet_get_main ();
389  u16 thread_index = vm->thread_index;
391  uword n_trace = vlib_get_trace_count (vm, node);
392  u32 *to_next;
393  vlib_frame_t *f;
394  ethernet_header_t *eth;
395  vlib_buffer_t *bufs[VLIB_FRAME_SIZE], **b;
396  u32 *from = vlib_frame_vector_args (frame);
397  u32 n_left = frame->n_vectors;
399  u32 port0 = 0, port1 = 0, port2 = 0, port3 = 0;
401  thread_index);
402 
403  vlib_get_buffers (vm, from, bufs, n_left);
404  b = bufs;
405  while (n_left >= 4)
406  {
407  u32 sif_if_index0, sif_if_index1, sif_if_index2, sif_if_index3;
408 
409  // Prefetch next iteration
410  if (n_left >= 8)
411  {
412  vlib_buffer_t **pb = b + 4;
413 
414  vlib_prefetch_buffer_header (pb[0], LOAD);
415  vlib_prefetch_buffer_header (pb[1], LOAD);
416  vlib_prefetch_buffer_header (pb[2], LOAD);
417  vlib_prefetch_buffer_header (pb[3], LOAD);
418 
419  CLIB_PREFETCH (pb[0]->data, CLIB_CACHE_LINE_BYTES, LOAD);
420  CLIB_PREFETCH (pb[1]->data, CLIB_CACHE_LINE_BYTES, LOAD);
421  CLIB_PREFETCH (pb[2]->data, CLIB_CACHE_LINE_BYTES, LOAD);
422  CLIB_PREFETCH (pb[3]->data, CLIB_CACHE_LINE_BYTES, LOAD);
423  }
424 
429 
430  if (PREDICT_TRUE (slave_count > 1))
431  {
432  if (lb_alg == BOND_LB_L2)
433  {
434  port0 = bond_load_balance_l2 (vm, node, bif, b[0], slave_count);
435  port1 = bond_load_balance_l2 (vm, node, bif, b[1], slave_count);
436  port2 = bond_load_balance_l2 (vm, node, bif, b[2], slave_count);
437  port3 = bond_load_balance_l2 (vm, node, bif, b[3], slave_count);
438  }
439  else if (lb_alg == BOND_LB_L34)
440  {
441  port0 = bond_load_balance_l34 (vm, node, bif, b[0],
442  slave_count);
443  port1 = bond_load_balance_l34 (vm, node, bif, b[1],
444  slave_count);
445  port2 = bond_load_balance_l34 (vm, node, bif, b[2],
446  slave_count);
447  port3 = bond_load_balance_l34 (vm, node, bif, b[3],
448  slave_count);
449  }
450  else if (lb_alg == BOND_LB_L23)
451  {
452  port0 = bond_load_balance_l23 (vm, node, bif, b[0],
453  slave_count);
454  port1 = bond_load_balance_l23 (vm, node, bif, b[1],
455  slave_count);
456  port2 = bond_load_balance_l23 (vm, node, bif, b[2],
457  slave_count);
458  port3 = bond_load_balance_l23 (vm, node, bif, b[3],
459  slave_count);
460  }
461  else if (lb_alg == BOND_LB_RR)
462  {
463  port0 = bond_load_balance_round_robin (vm, node, bif, b[0],
464  slave_count);
465  port1 = bond_load_balance_round_robin (vm, node, bif, b[1],
466  slave_count);
467  port2 = bond_load_balance_round_robin (vm, node, bif, b[2],
468  slave_count);
469  port3 = bond_load_balance_round_robin (vm, node, bif, b[3],
470  slave_count);
471  }
472  else if (lb_alg == BOND_LB_BC)
473  {
474  port0 = bond_load_balance_broadcast (vm, node, bif, b[0],
475  slave_count);
476  port1 = bond_load_balance_broadcast (vm, node, bif, b[1],
477  slave_count);
478  port2 = bond_load_balance_broadcast (vm, node, bif, b[2],
479  slave_count);
480  port3 = bond_load_balance_broadcast (vm, node, bif, b[3],
481  slave_count);
482  }
483  else if (lb_alg == BOND_LB_AB)
484  {
485  port0 = bond_load_balance_active_backup (vm, node, bif, b[0],
486  slave_count);
487  port1 = bond_load_balance_active_backup (vm, node, bif, b[1],
488  slave_count);
489  port2 = bond_load_balance_active_backup (vm, node, bif, b[2],
490  slave_count);
491  port3 = bond_load_balance_active_backup (vm, node, bif, b[3],
492  slave_count);
493  }
494  else
495  {
496  ASSERT (0);
497  }
498  }
499 
500  sif_if_index0 = *vec_elt_at_index (bif->active_slaves, port0);
501  sif_if_index1 = *vec_elt_at_index (bif->active_slaves, port1);
502  sif_if_index2 = *vec_elt_at_index (bif->active_slaves, port2);
503  sif_if_index3 = *vec_elt_at_index (bif->active_slaves, port3);
504 
505  /* Do the tracing before the interface is overwritten */
506  if (PREDICT_FALSE (n_trace > 0))
507  {
508  u32 next0 = 0, next1 = 0, next2 = 0, next3 = 0;
509  vlib_trace_buffer (vm, node, next0, b[0], 0 /* follow_chain */ );
510  vlib_set_trace_count (vm, node, --n_trace);
511  t0 = vlib_add_trace (vm, node, b[0], sizeof (*t0));
513  t0->ethernet = *eth;
514  t0->sw_if_index = vnet_buffer (b[0])->sw_if_index[VLIB_TX];
515  t0->bond_sw_if_index = sif_if_index0;
516 
517  if (PREDICT_TRUE (n_trace > 0))
518  {
519  vlib_trace_buffer (vm, node, next1, b[1],
520  0 /* follow_chain */ );
521  vlib_set_trace_count (vm, node, --n_trace);
522  t0 = vlib_add_trace (vm, node, b[1], sizeof (*t0));
524  t0->ethernet = *eth;
525  t0->sw_if_index = vnet_buffer (b[1])->sw_if_index[VLIB_TX];
526  t0->bond_sw_if_index = sif_if_index1;
527 
528  if (PREDICT_TRUE (n_trace > 0))
529  {
530  vlib_trace_buffer (vm, node, next2, b[2],
531  0 /* follow_chain */ );
532  vlib_set_trace_count (vm, node, --n_trace);
533  t0 = vlib_add_trace (vm, node, b[2], sizeof (*t0));
535  t0->ethernet = *eth;
536  t0->sw_if_index = vnet_buffer (b[2])->sw_if_index[VLIB_TX];
537  t0->bond_sw_if_index = sif_if_index2;
538 
539  if (PREDICT_TRUE (n_trace > 0))
540  {
541  vlib_trace_buffer (vm, node, next3, b[3],
542  0 /* follow_chain */ );
543  vlib_set_trace_count (vm, node, --n_trace);
544  t0 = vlib_add_trace (vm, node, b[3], sizeof (*t0));
545  eth =
547  t0->ethernet = *eth;
548  t0->sw_if_index =
549  vnet_buffer (b[3])->sw_if_index[VLIB_TX];
550  t0->bond_sw_if_index = sif_if_index3;
551  }
552  }
553  }
554  }
555 
556  vnet_buffer (b[0])->sw_if_index[VLIB_TX] = sif_if_index0;
557  vnet_buffer (b[1])->sw_if_index[VLIB_TX] = sif_if_index1;
558  vnet_buffer (b[2])->sw_if_index[VLIB_TX] = sif_if_index2;
559  vnet_buffer (b[3])->sw_if_index[VLIB_TX] = sif_if_index3;
560 
561  ptd->per_port_queue[sif_if_index0].buffers[ptd->per_port_queue
562  [sif_if_index0].n_buffers] =
563  vlib_get_buffer_index (vm, b[0]);
564  ptd->per_port_queue[sif_if_index0].n_buffers++;
565 
566  ptd->per_port_queue[sif_if_index1].buffers[ptd->per_port_queue
567  [sif_if_index1].n_buffers] =
568  vlib_get_buffer_index (vm, b[1]);
569  ptd->per_port_queue[sif_if_index1].n_buffers++;
570 
571  ptd->per_port_queue[sif_if_index2].buffers[ptd->per_port_queue
572  [sif_if_index2].n_buffers] =
573  vlib_get_buffer_index (vm, b[2]);
574  ptd->per_port_queue[sif_if_index2].n_buffers++;
575 
576  ptd->per_port_queue[sif_if_index3].buffers[ptd->per_port_queue
577  [sif_if_index3].n_buffers] =
578  vlib_get_buffer_index (vm, b[3]);
579  ptd->per_port_queue[sif_if_index3].n_buffers++;
580 
581  n_left -= 4;
582  b += 4;
583  }
584 
585  while (n_left > 0)
586  {
587  u32 sif_if_index0;
588 
590 
591  if (PREDICT_TRUE (slave_count > 1))
592  {
593  if (bif->lb == BOND_LB_L2)
594  {
595  port0 = bond_load_balance_l2 (vm, node, bif, b[0], slave_count);
596  }
597  else if (bif->lb == BOND_LB_L34)
598  {
599  port0 = bond_load_balance_l34 (vm, node, bif, b[0],
600  slave_count);
601  }
602  else if (bif->lb == BOND_LB_L23)
603  {
604  port0 = bond_load_balance_l23 (vm, node, bif, b[0],
605  slave_count);
606  }
607  else if (bif->lb == BOND_LB_RR)
608  {
609  port0 = bond_load_balance_round_robin (vm, node, bif, b[0],
610  slave_count);
611  }
612  else if (bif->lb == BOND_LB_BC)
613  {
614  port0 = bond_load_balance_broadcast (vm, node, bif, b[0],
615  slave_count);
616  }
617  else if (bif->lb == BOND_LB_AB)
618  {
619  port0 = bond_load_balance_active_backup (vm, node, bif, b[0],
620  slave_count);
621  }
622  else
623  {
624  ASSERT (0);
625  }
626  }
627 
628  sif_if_index0 = *vec_elt_at_index (bif->active_slaves, port0);
629 
630  /* Do the tracing before the old interface is overwritten */
631  if (PREDICT_FALSE (n_trace > 0))
632  {
633  u32 next0 = 0;
634 
635  vlib_trace_buffer (vm, node, next0, b[0], 0 /* follow_chain */ );
636  vlib_set_trace_count (vm, node, --n_trace);
637  t0 = vlib_add_trace (vm, node, b[0], sizeof (*t0));
639  t0->ethernet = *eth;
640  t0->sw_if_index = vnet_buffer (b[0])->sw_if_index[VLIB_TX];
641  t0->bond_sw_if_index = sif_if_index0;
642  }
643 
644  vnet_buffer (b[0])->sw_if_index[VLIB_TX] = sif_if_index0;
645 
646  ptd->per_port_queue[sif_if_index0].buffers[ptd->per_port_queue
647  [sif_if_index0].n_buffers] =
648  vlib_get_buffer_index (vm, b[0]);
649  ptd->per_port_queue[sif_if_index0].n_buffers++;
650 
651  n_left -= 1;
652  b += 1;
653  }
654 
655  for (port0 = 0; port0 < slave_count; port0++)
656  {
657  sw_if_index = *vec_elt_at_index (bif->active_slaves, port0);
658  if (PREDICT_TRUE (ptd->per_port_queue[sw_if_index].n_buffers))
659  {
660  f = vnet_get_frame_to_sw_interface (vnm, sw_if_index);
662  to_next = vlib_frame_vector_args (f);
663  clib_memcpy (to_next, ptd->per_port_queue[sw_if_index].buffers,
664  f->n_vectors << 2);
665  vnet_put_frame_to_sw_interface (vnm, sw_if_index, f);
667  }
668  }
669 
671  + VNET_INTERFACE_COUNTER_TX, thread_index,
672  bif->sw_if_index, frame->n_vectors);
673 }
674 
676  vlib_node_runtime_t * node,
677  vlib_frame_t * frame)
678 {
679  vnet_interface_output_runtime_t *rund = (void *) node->runtime_data;
680  bond_main_t *bm = &bond_main;
681  u16 thread_index = vm->thread_index;
682  bond_if_t *bif = pool_elt_at_index (bm->interfaces, rund->dev_instance);
683  uword slave_count;
684 
685  if (PREDICT_FALSE (bif->admin_up == 0))
686  {
687  vlib_buffer_free (vm, vlib_frame_args (frame), frame->n_vectors);
690  thread_index, bif->sw_if_index,
691  frame->n_vectors);
692  vlib_error_count (vm, node->node_index, BOND_TX_ERROR_IF_DOWN,
693  frame->n_vectors);
694  return frame->n_vectors;
695  }
696 
697  slave_count = vec_len (bif->active_slaves);
698  if (PREDICT_FALSE (slave_count == 0))
699  {
700  vlib_buffer_free (vm, vlib_frame_args (frame), frame->n_vectors);
703  thread_index, bif->sw_if_index,
704  frame->n_vectors);
705  vlib_error_count (vm, node->node_index, BOND_TX_ERROR_NO_SLAVE,
706  frame->n_vectors);
707  return frame->n_vectors;
708  }
709 
710  if (bif->lb == BOND_LB_L2)
711  bond_tx_inline (vm, node, frame, bif, slave_count, BOND_LB_L2);
712  else if (bif->lb == BOND_LB_L34)
713  bond_tx_inline (vm, node, frame, bif, slave_count, BOND_LB_L34);
714  else if (bif->lb == BOND_LB_L23)
715  bond_tx_inline (vm, node, frame, bif, slave_count, BOND_LB_L23);
716  else if (bif->lb == BOND_LB_RR)
717  bond_tx_inline (vm, node, frame, bif, slave_count, BOND_LB_RR);
718  else if (bif->lb == BOND_LB_BC)
719  bond_tx_inline (vm, node, frame, bif, slave_count, BOND_LB_BC);
720  else if (bif->lb == BOND_LB_AB)
721  bond_tx_inline (vm, node, frame, bif, slave_count, BOND_LB_AB);
722  else
723  ASSERT (0);
724 
725  return frame->n_vectors;
726 }
727 
728 static walk_rc_t
730  void *arg)
731 {
732  bond_main_t *bm = &bond_main;
733 
734  send_ip4_garp (bm->vlib_main, sw_if_index);
735  send_ip6_na (bm->vlib_main, sw_if_index);
736 
737  return (WALK_CONTINUE);
738 }
739 
740 static uword
742 {
743  vnet_main_t *vnm = vnet_get_main ();
744  uword event_type, *event_data = 0;
745 
746  while (1)
747  {
748  u32 i;
750 
752  event_type = vlib_process_get_events (vm, &event_data);
753  ASSERT (event_type == BOND_SEND_GARP_NA);
754  for (i = 0; i < vec_len (event_data); i++)
755  {
756  hw_if_index = event_data[i];
757  /* walk hw interface to process all subinterfaces */
758  vnet_hw_interface_walk_sw (vnm, hw_if_index,
760  }
761  vec_reset_length (event_data);
762  }
763  return 0;
764 }
765 
766 /* *INDENT-OFF* */
768  .function = bond_process,
769  .type = VLIB_NODE_TYPE_PROCESS,
770  .name = "bond-process",
771 };
772 /* *INDENT-ON* */
773 
774 /* *INDENT-OFF* */
776  .name = "bond",
777  .tx_function_n_errors = BOND_TX_N_ERROR,
778  .tx_function_error_strings = bond_tx_error_strings,
779  .format_device_name = format_bond_interface_name,
780  .set_l2_mode_function = bond_set_l2_mode_function,
781  .admin_up_down_function = bond_interface_admin_up_down,
782  .subif_add_del_function = bond_subif_add_del_function,
783  .format_tx_trace = format_bond_tx_trace,
784 };
785 
786 /* *INDENT-ON* */
787 
788 /*
789  * fd.io coding-style-patch-verification: ON
790  *
791  * Local Variables:
792  * eval: (c-set-style "gnu")
793  * End:
794  */
u32 dev_instance
Definition: node.h:161
VNET_DEVICE_CLASS_TX_FN() bond_dev_class(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
Definition: device.c:675
u32 hw_if_index
Definition: node.h:162
vl_api_address_t src
Definition: vxlan_gbp.api:33
vlib_node_registration_t bond_process_node
(constructor) VLIB_REGISTER_NODE (bond_process_node)
Definition: device.c:767
#define CLIB_UNUSED(x)
Definition: clib.h:81
static __clib_unused clib_error_t * bond_set_l2_mode_function(vnet_main_t *vnm, struct vnet_hw_interface_t *bif_hw, i32 l2_if_adjust)
Definition: device.c:82
clib_error_t * vnet_hw_interface_set_flags(vnet_main_t *vnm, u32 hw_if_index, u32 flags)
Definition: interface.c:469
static u32 vlib_get_trace_count(vlib_main_t *vm, vlib_node_runtime_t *rt)
Definition: trace_funcs.h:156
a
Definition: bitmap.h:538
static void vlib_buffer_free(vlib_main_t *vm, u32 *buffers, u32 n_buffers)
Free buffers Frees the entire buffer chain for each buffer.
Definition: buffer_funcs.h:547
static uword * vlib_process_wait_for_event(vlib_main_t *vm)
Definition: node_funcs.h:619
vnet_main_t * vnet_get_main(void)
Definition: misc.c:47
static vnet_hw_interface_t * vnet_get_sup_hw_interface(vnet_main_t *vnm, u32 sw_if_index)
u8 lb
Definition: node.h:156
static_always_inline u32 bond_load_balance_round_robin(vlib_main_t *vm, vlib_node_runtime_t *node, bond_if_t *bif, vlib_buffer_t *b0, uword slave_count)
Definition: device.c:358
vnet_interface_main_t interface_main
Definition: vnet.h:56
#define PREDICT_TRUE(x)
Definition: clib.h:108
unsigned long u64
Definition: types.h:89
u32 buffers[VLIB_FRAME_SIZE]
Definition: node.h:143
static void vlib_error_count(vlib_main_t *vm, uword node_index, uword counter, uword increment)
Definition: error_funcs.h:57
static bond_if_t * bond_get_master_by_sw_if_index(u32 sw_if_index)
Definition: node.h:429
void vnet_hw_interface_walk_sw(vnet_main_t *vnm, u32 hw_if_index, vnet_hw_sw_interface_walk_t fn, void *ctx)
Walk the SW interfaces on a HW interface - this is the super interface and any sub-interfaces.
Definition: interface.c:982
u8 src_address[6]
Definition: packet.h:56
static vnet_hw_interface_t * vnet_get_hw_interface(vnet_main_t *vnm, u32 hw_if_index)
u32 thread_index
Definition: main.h:179
int i
bond_main_t bond_main
Definition: node.c:24
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:419
static void vlib_increment_simple_counter(vlib_simple_counter_main_t *cm, u32 thread_index, u32 index, u64 increment)
Increment a simple counter.
Definition: counter.h:78
static_always_inline u32 lb_hash_hash_2_tuples(u64 k0, u32 k1)
Definition: lb_hash_hash.h:54
#define VNET_HW_INTERFACE_FLAG_LINK_UP
Definition: interface.h:494
void send_ip6_na(vlib_main_t *vm, u32 sw_if_index)
#define BOND_MODULO_SHORTCUT(a)
Definition: node.h:34
struct _tcp_header tcp_header_t
ip6_address_t src_address
Definition: ip6_packet.h:378
static_always_inline void bond_tx_inline(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame, bond_if_t *bif, uword slave_count, u32 lb_alg)
Definition: device.c:383
unsigned char u8
Definition: types.h:56
bond_per_thread_data_t * per_thread_data
Definition: node.h:317
static vlib_buffer_t * vlib_buffer_copy(vlib_main_t *vm, vlib_buffer_t *b)
Definition: buffer_funcs.h:728
uword as_uword[16/sizeof(uword)]
Definition: ip6_packet.h:52
#define vec_reset_length(v)
Reset vector length to zero NULL-pointer tolerant.
static void vlib_trace_buffer(vlib_main_t *vm, vlib_node_runtime_t *r, u32 next_index, vlib_buffer_t *b, int follow_chain)
Definition: trace_funcs.h:114
enum walk_rc_t_ walk_rc_t
Walk return code.
#define static_always_inline
Definition: clib.h:95
u8 * format_ethernet_address(u8 *s, va_list *args)
Definition: format.c:44
static uword vlib_process_get_events(vlib_main_t *vm, uword **data_vector)
Return the first event type which has occurred and a vector of per-event data of that type...
Definition: node_funcs.h:542
u32 sw_if_index
Definition: vxlan_gbp.api:39
u8 dst_address[6]
Definition: packet.h:55
u32 sw_if_index
Definition: node.h:163
#define vlib_prefetch_buffer_header(b, type)
Prefetch buffer metadata.
Definition: buffer.h:187
#define vec_elt_at_index(v, i)
Get vector value at index i checking that i is in bounds.
static_always_inline u32 bond_load_balance_l23(vlib_main_t *vm, vlib_node_runtime_t *node, bond_if_t *bif, vlib_buffer_t *b0, uword slave_count)
Definition: device.c:207
vlib_main_t * vlib_main
Definition: node.h:307
#define VNET_DEVICE_CLASS_TX_FN(devclass)
Definition: interface.h:286
unsigned int u32
Definition: types.h:88
u32 lb_rr_last_index
Definition: node.h:159
#define VLIB_FRAME_SIZE
Definition: node.h:382
static u32 vlib_get_buffer_index(vlib_main_t *vm, void *p)
Translate buffer pointer into buffer index.
Definition: buffer_funcs.h:154
void ethernet_set_rx_redirect(vnet_main_t *vnm, vnet_hw_interface_t *hi, u32 enable)
Definition: node.c:1202
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:464
u8 admin_up
Definition: node.h:154
static_always_inline u16 * bond_locate_ethertype(ethernet_header_t *eth)
Definition: device.c:184
unsigned short u16
Definition: types.h:57
static void * vlib_buffer_get_current(vlib_buffer_t *b)
Get pointer to current data to process.
Definition: buffer.h:205
static_always_inline u32 bond_load_balance_broadcast(vlib_main_t *vm, vlib_node_runtime_t *node, bond_if_t *bif, vlib_buffer_t *b0, uword slave_count)
Definition: device.c:135
#define foreach_bond_tx_error
Definition: device.c:29
ip4_address_pair_t address_pair
Definition: ip4_packet.h:171
#define PREDICT_FALSE(x)
Definition: clib.h:107
vnet_main_t vnet_main
Definition: misc.c:43
vlib_simple_counter_main_t * sw_if_counters
Definition: interface.h:854
static char * bond_tx_error_strings[]
Definition: device.c:42
bond_if_t * interfaces
Definition: node.h:298
u32 flags
Definition: vhost_user.h:115
void send_ip4_garp(vlib_main_t *vm, u32 sw_if_index)
Definition: arp.c:2548
#define VLIB_REGISTER_NODE(x,...)
Definition: node.h:155
u32 * slaves
Definition: node.h:166
svmdb_client_t * c
u16 n_vectors
Definition: node.h:401
static void vnet_put_frame_to_sw_interface(vnet_main_t *vnm, u32 sw_if_index, vlib_frame_t *f)
#define CLIB_PREFETCH(addr, size, type)
Definition: cache.h:79
vlib_main_t * vm
Definition: buffer.c:294
vl_api_address_t dst
Definition: vxlan_gbp.api:34
ethernet_header_t ethernet
Definition: node.h:323
#define clib_memcpy(a, b, c)
Definition: string.h:75
#define ETHERNET_INTERFACE_FLAG_ACCEPT_ALL
Definition: ethernet.h:159
static u8 * format_bond_tx_trace(u8 *s, va_list *args)
Definition: device.c:49
signed int i32
Definition: types.h:77
#define ASSERT(truth)
static walk_rc_t bond_active_interface_switch_cb(vnet_main_t *vnm, u32 sw_if_index, void *arg)
Definition: device.c:729
static_always_inline int ethernet_frame_is_tagged(u16 type)
Definition: ethernet.h:97
static void * vlib_frame_args(vlib_frame_t *f)
Get pointer to frame scalar data.
Definition: node_funcs.h:284
static_always_inline u32 bond_load_balance_l2(vlib_main_t *vm, vlib_node_runtime_t *node, bond_if_t *bif, vlib_buffer_t *b0, uword slave_count)
Definition: device.c:165
VNET_DEVICE_CLASS(bond_dev_class)
u32 * active_slaves
Definition: node.h:169
#define clib_mem_unaligned(pointer, type)
Definition: types.h:155
static vlib_frame_t * vnet_get_frame_to_sw_interface(vnet_main_t *vnm, u32 sw_if_index)
static void * vlib_add_trace(vlib_main_t *vm, vlib_node_runtime_t *r, vlib_buffer_t *b, u32 n_data_bytes)
Definition: trace_funcs.h:57
static_always_inline u32 bond_load_balance_active_backup(vlib_main_t *vm, vlib_node_runtime_t *node, bond_if_t *bif, vlib_buffer_t *b0, uword slave_count)
Definition: device.c:373
Definition: defs.h:47
static_always_inline u32 bond_load_balance_l34(vlib_main_t *vm, vlib_node_runtime_t *node, bond_if_t *bif, vlib_buffer_t *b0, uword slave_count)
Definition: device.c:274
u8 * format_bond_interface_name(u8 *s, va_list *args)
Definition: device.c:69
bond_tx_error_t
Definition: device.c:34
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
#define VLIB_BUFFER_TRACE_TRAJECTORY_INIT(b)
Definition: buffer.h:547
u64 uword
Definition: types.h:112
static void * vlib_frame_vector_args(vlib_frame_t *f)
Get pointer to frame vector data.
Definition: node_funcs.h:267
#define vnet_buffer(b)
Definition: buffer.h:344
static __clib_unused clib_error_t * bond_subif_add_del_function(vnet_main_t *vnm, u32 hw_if_index, struct vnet_sw_interface_t *st, int is_add)
Definition: device.c:112
#define vec_foreach(var, vec)
Vector iterator.
static_always_inline u32 lb_hash_hash(u64 k0, u64 k1, u64 k2, u64 k3, u64 k4)
Definition: lb_hash_hash.h:46
u8 ip_version_and_header_length
Definition: ip4_packet.h:137
static void vlib_set_trace_count(vlib_main_t *vm, vlib_node_runtime_t *rt, u32 count)
Definition: trace_funcs.h:172
static_always_inline void vlib_get_buffers(vlib_main_t *vm, u32 *bi, vlib_buffer_t **b, int count)
Translate array of buffer indices into buffer pointers.
Definition: buffer_funcs.h:141
u32 bond_sw_if_index
Definition: node.h:325
#define CLIB_CACHE_LINE_BYTES
Definition: cache.h:59
static clib_error_t * bond_interface_admin_up_down(vnet_main_t *vnm, u32 hw_if_index, u32 flags)
Definition: device.c:120
ip6_address_t dst_address
Definition: ip6_packet.h:378
bond_per_port_queue_t * per_port_queue
Definition: node.h:149
u32 ethernet_set_flags(vnet_main_t *vnm, u32 hw_if_index, u32 flags)
Definition: interface.c:371
static uword bond_process(vlib_main_t *vm, vlib_node_runtime_t *rt, vlib_frame_t *f)
Definition: device.c:741