FD.io VPP  v20.05.1-6-gf53edbc3b
Vector Packet Processing
input.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2017 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 #define _GNU_SOURCE
17 #include <vnet/bonding/node.h>
18 #include <lacp/node.h>
19 #include <vpp/stats/stat_segment.h>
20 
21 static int
23 {
24  lacp_pdu_t *lacpdu = (lacp_pdu_t *) sif->last_rx_pkt;
25 
26  if (lacpdu->subtype != LACP_SUBTYPE)
27  return LACP_ERROR_UNSUPPORTED;
28 
29  /*
30  * According to the spec, no checking on the version number and tlv types.
31  * But we may check the tlv lengths.
32  */
33  if ((lacpdu->actor.tlv_length != sizeof (lacp_actor_partner_t)) ||
34  (lacpdu->partner.tlv_length != sizeof (lacp_actor_partner_t)) ||
35  (lacpdu->collector.tlv_length != sizeof (lacp_collector_t)) ||
36  (lacpdu->terminator.tlv_length != 0))
37  return (LACP_ERROR_BAD_TLV);
38 
40  LACP_RX_EVENT_PDU_RECEIVED, &sif->rx_state);
41 
42  return LACP_ERROR_NONE;
43 }
44 
45 static void
46 marker_fill_pdu (marker_pdu_t * marker, slave_if_t * sif)
47 {
48  marker_pdu_t *pkt = (marker_pdu_t *) sif->last_marker_pkt;
49 
50  marker->marker_info = pkt->marker_info;
51  marker->marker_info.tlv_type = MARKER_RESPONSE_INFORMATION;
52 }
53 
54 void
55 marker_fill_request_pdu (marker_pdu_t * marker, slave_if_t * sif)
56 {
57  marker->marker_info.tlv_type = MARKER_INFORMATION;
58  marker->marker_info.requester_port = sif->actor.port_number;
59  clib_memcpy (marker->marker_info.requester_system, sif->actor.system, 6);
60  marker->marker_info.requester_transaction_id = sif->marker_tx_id;
61  sif->marker_tx_id++;
62 }
63 
64 static void
66 {
67  lacp_main_t *lm = &lacp_main;
68  u32 *to_next;
69  ethernet_marker_pdu_t *h0;
71  u32 bi0;
72  vlib_buffer_t *b0;
73  vlib_frame_t *f;
74  vnet_main_t *vnm = lm->vnet_main;
75 
76  /*
77  * see lacp_periodic_init() to understand what's already painted
78  * into the buffer by the packet template mechanism
79  */
81  (vm, &lm->marker_packet_templates[sif->packet_template_index], &bi0);
82 
83  if (!h0)
84  return;
85 
86  /* Add the interface's ethernet source address */
87  hw = vnet_get_sup_hw_interface (vnm, sif->sw_if_index);
88 
89  clib_memcpy (h0->ethernet.src_address, hw->hw_address,
90  vec_len (hw->hw_address));
91 
92  marker_fill_pdu (&h0->marker, sif);
93 
94  /* Set the outbound packet length */
95  b0 = vlib_get_buffer (vm, bi0);
96  b0->current_length = sizeof (ethernet_marker_pdu_t);
97  b0->current_data = 0;
99 
100  /* And the outbound interface */
101  vnet_buffer (b0)->sw_if_index[VLIB_TX] = hw->sw_if_index;
102 
103  /* And output the packet on the correct interface */
105 
106  to_next = vlib_frame_vector_args (f);
107  to_next[0] = bi0;
108  f->n_vectors = 1;
109 
112  sif->marker_pdu_sent++;
113 }
114 
115 static int
117 {
118  marker_pdu_t *marker = (marker_pdu_t *) sif->last_marker_pkt;
119 
120  /*
121  * According to the spec, no checking on the version number and tlv types.
122  * But we may check the tlv lengths.
123  */
124  if ((marker->marker_info.tlv_length != sizeof (marker_information_t)) ||
125  (marker->terminator.tlv_length != 0))
126  return (LACP_ERROR_BAD_TLV);
127 
129 
130  return LACP_ERROR_NONE;
131 }
132 
133 /*
134  * lacp input routine
135  */
138 {
139  bond_main_t *bm = &bond_main;
140  slave_if_t *sif;
141  uword nbytes;
142  lacp_error_t e;
143  marker_pdu_t *marker;
144  uword last_packet_signature;
145  bond_if_t *bif;
146 
147  sif =
149  if ((sif == 0) || (sif->mode != BOND_MODE_LACP))
150  {
151  return LACP_ERROR_DISABLED;
152  }
153 
154  /* Handle marker protocol */
155  marker = (marker_pdu_t *) (b0->data + b0->current_data);
156  if (marker->subtype == MARKER_SUBTYPE)
157  {
159  if (sif->last_marker_pkt)
160  _vec_len (sif->last_marker_pkt) = 0;
162  vlib_buffer_length_in_chain (vm, b0) - 1);
163  nbytes = vlib_buffer_contents (vm, bi0, sif->last_marker_pkt);
164  ASSERT (nbytes <= vec_len (sif->last_marker_pkt));
165  if (nbytes < sizeof (lacp_pdu_t))
166  {
168  return LACP_ERROR_TOO_SMALL;
169  }
170  e = handle_marker_protocol (vm, sif);
171  sif->marker_pdu_received++;
172  return e;
173  }
174 
175  /*
176  * typical clib idiom. Don't repeatedly allocate and free
177  * the per-neighbor rx buffer. Reset its apparent length to zero
178  * and reuse it.
179  */
180  if (sif->last_rx_pkt)
181  _vec_len (sif->last_rx_pkt) = 0;
182 
183  /*
184  * Make sure the per-neighbor rx buffer is big enough to hold
185  * the data we're about to copy
186  */
188 
189  /*
190  * Coalesce / copy the buffer chain into the per-neighbor
191  * rx buffer
192  */
193  nbytes = vlib_buffer_contents (vm, bi0, sif->last_rx_pkt);
194  ASSERT (nbytes <= vec_len (sif->last_rx_pkt));
195 
197  if (nbytes < sizeof (lacp_pdu_t))
198  {
199  sif->bad_pdu_received++;
200  return LACP_ERROR_TOO_SMALL;
201  }
202 
203  last_packet_signature =
204  hash_memory (sif->last_rx_pkt, vec_len (sif->last_rx_pkt), 0xd00b);
205 
206  if (sif->last_packet_signature_valid &&
207  (sif->last_packet_signature == last_packet_signature) &&
208  ((sif->actor.state & LACP_STEADY_STATE) == LACP_STEADY_STATE))
209  {
211  e = LACP_ERROR_CACHE_HIT;
212  }
213  else
214  {
215  /* Actually scan the packet */
216  e = lacp_packet_scan (vm, sif);
219  [sif->sw_if_index].actor_state,
220  sif->actor.state);
222  [sif->sw_if_index].partner_state,
223  sif->partner.state);
225  sif->last_packet_signature = last_packet_signature;
226  }
227  sif->pdu_received++;
228 
229  if (sif->last_rx_pkt)
230  _vec_len (sif->last_rx_pkt) = 0;
231 
232  return e;
233 }
234 
235 /*
236  * setup neighbor hash table
237  */
238 static clib_error_t *
240 {
241  return 0;
242 }
243 
244 /* *INDENT-OFF* */
246 {
247  .runs_after = VLIB_INITS("lacp_periodic_init"),
248 };
249 /* *INDENT-ON* */
250 
251 /*
252  * packet trace format function, very similar to
253  * lacp_packet_scan except that we call the per TLV format
254  * functions instead of the per TLV processing functions
255  */
256 u8 *
257 lacp_input_format_trace (u8 * s, va_list * args)
258 {
259  CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
260  CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
261  lacp_input_trace_t *t = va_arg (*args, lacp_input_trace_t *);
262  lacp_pdu_t *lacpdu = &t->pkt.lacpdu;
263  marker_pdu_t *marker = &t->pkt.marker;
264  int i, len;
265  u8 *p;
266  lacp_state_struct *state_entry;
267 
269  t->sw_if_index);
270  s = format (s, "Length: %d\n", t->len);
271  if (t->len >= sizeof (lacp_pdu_t))
272  {
273  switch (lacpdu->subtype)
274  {
275  case MARKER_SUBTYPE:
276  if (marker->version_number == MARKER_PROTOCOL_VERSION)
277  s = format (s, " Markerv1\n");
278  else
279  s = format (s, " Subtype %u, Version %u\n", marker->subtype,
280  marker->version_number);
281  s = format (s, " Marker Information TLV: type %u\n",
282  marker->marker_info.tlv_type);
283  s = format (s, " Marker Information TLV: length %u\n",
284  marker->marker_info.tlv_length);
285  s = format (s, " Requester port: %u\n",
286  ntohs (marker->marker_info.requester_port));
287  s = format (s, " Requester system: %U\n", format_ethernet_address,
288  marker->marker_info.requester_system);
289  s = format (s, " Requester transaction ID: %u\n",
290  ntohl (marker->marker_info.requester_transaction_id));
291  break;
292 
293  case LACP_SUBTYPE:
294  if (lacpdu->version_number == LACP_ACTOR_LACP_VERSION)
295  s = format (s, " LACPv1\n");
296  else
297  s = format (s, " Subtype %u, Version %u\n", lacpdu->subtype,
298  lacpdu->version_number);
299  s = format (s, " Actor Information TLV: length %u\n",
300  lacpdu->actor.tlv_length);
301  s = format (s, " System %U\n", format_ethernet_address,
302  lacpdu->actor.port_info.system);
303  s = format (s, " System priority %u\n",
304  ntohs (lacpdu->actor.port_info.system_priority));
305  s = format (s, " Key %u\n", ntohs (lacpdu->actor.port_info.key));
306  s = format (s, " Port priority %u\n",
307  ntohs (lacpdu->actor.port_info.port_priority));
308  s = format (s, " Port number %u\n",
309  ntohs (lacpdu->actor.port_info.port_number));
310  s = format (s, " State 0x%x\n", lacpdu->actor.port_info.state);
311  state_entry = (lacp_state_struct *) & lacp_state_array;
312  while (state_entry->str)
313  {
314  if (lacpdu->actor.port_info.state & (1 << state_entry->bit))
315  s = format (s, " %s (%d)\n", state_entry->str,
316  state_entry->bit);
317  state_entry++;
318  }
319 
320  s = format (s, " Partner Information TLV: length %u\n",
321  lacpdu->partner.tlv_length);
322  s = format (s, " System %U\n", format_ethernet_address,
323  lacpdu->partner.port_info.system);
324  s = format (s, " System priority %u\n",
325  ntohs (lacpdu->partner.port_info.system_priority));
326  s =
327  format (s, " Key %u\n", ntohs (lacpdu->partner.port_info.key));
328  s =
329  format (s, " Port priority %u\n",
330  ntohs (lacpdu->partner.port_info.port_priority));
331  s =
332  format (s, " Port number %u\n",
333  ntohs (lacpdu->partner.port_info.port_number));
334  s = format (s, " State 0x%x\n", lacpdu->partner.port_info.state);
335  state_entry = (lacp_state_struct *) & lacp_state_array;
336  while (state_entry->str)
337  {
338  if (lacpdu->partner.port_info.state & (1 << state_entry->bit))
339  s = format (s, " %s (%d)\n", state_entry->str,
340  state_entry->bit);
341  state_entry++;
342  }
343  break;
344 
345  default:
346  break;
347  }
348  }
349 
350  if (t->len > sizeof (lacp_pdu_t))
351  len = sizeof (lacp_pdu_t);
352  else
353  len = t->len;
354  p = (u8 *) lacpdu;
355  for (i = 0; i < len; i++)
356  {
357  if ((i % 16) == 0)
358  {
359  if (i)
360  s = format (s, "\n");
361  s = format (s, " 0x%04x: ", i);
362  }
363  if ((i % 2) == 0)
364  s = format (s, " ");
365  s = format (s, "%02x", p[i]);
366  }
367 
368  return s;
369 }
370 
371 /*
372  * fd.io coding-style-patch-verification: ON
373  *
374  * Local Variables:
375  * eval: (c-set-style "gnu")
376  * End:
377  */
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
Definition: vec.h:507
#define CLIB_UNUSED(x)
Definition: clib.h:86
lacp_stats_t ** stats
Definition: node.h:388
u64 marker_pdu_sent
Definition: node.h:346
u8 last_packet_signature_valid
Definition: node.h:235
vnet_main_t * vnet_get_main(void)
Definition: misc.c:46
static vnet_hw_interface_t * vnet_get_sup_hw_interface(vnet_main_t *vnm, u32 sw_if_index)
static int lacp_packet_scan(vlib_main_t *vm, slave_if_t *sif)
Definition: input.c:22
f64 last_lacpdu_recd_time
Definition: node.h:295
i16 current_data
signed offset in data[], pre_data[] that we are currently processing.
Definition: buffer.h:110
static f64 vlib_time_now(vlib_main_t *vm)
Definition: main.h:291
u8 * last_marker_pkt
Definition: node.h:242
u16 current_length
Nbytes between current data and the end of this buffer.
Definition: buffer.h:113
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:424
u64 pdu_received
Definition: node.h:331
static uword vlib_buffer_length_in_chain(vlib_main_t *vm, vlib_buffer_t *b)
Get length in bytes of the buffer chain.
Definition: buffer_funcs.h:402
u8 mode
Definition: node.h:328
format_function_t format_vnet_sw_if_index_name
unsigned char u8
Definition: types.h:56
#define clib_memcpy(d, s, n)
Definition: string.h:180
static void marker_fill_pdu(marker_pdu_t *marker, slave_if_t *sif)
Definition: input.c:46
u8 * lacp_input_format_trace(u8 *s, va_list *args)
Definition: input.c:257
f32 ttl_in_seconds
Definition: node.h:221
marker_pdu_t marker
Definition: node.h:86
u8 * format_ethernet_address(u8 *s, va_list *args)
Definition: format.c:44
void * vlib_packet_template_get_packet(vlib_main_t *vm, vlib_packet_template_t *t, u32 *bi_result)
Definition: buffer.c:400
vl_api_interface_index_t sw_if_index
Definition: gre.api:53
#define VLIB_INIT_FUNCTION(x)
Definition: init.h:173
vnet_main_t * vnet_main
Definition: node.h:122
f64 last_marker_pdu_recd_time
Definition: node.h:301
u32 sw_if_index
Definition: node.h:184
u64 bad_pdu_received
Definition: node.h:334
lacp_port_info_t actor
Definition: node.h:255
vlib_frame_t * vlib_get_frame_to_node(vlib_main_t *vm, u32 to_node_index)
Definition: main.c:182
u64 marker_pdu_received
Definition: node.h:340
static int handle_marker_protocol(vlib_main_t *vm, slave_if_t *sif)
Definition: input.c:116
unsigned int u32
Definition: types.h:88
u8 * last_rx_pkt
Definition: node.h:239
#define MARKER_SUBTYPE
Definition: protocol.h:132
f64 last_marker_pdu_sent_time
Definition: node.h:298
void vlib_put_frame_to_node(vlib_main_t *vm, u32 to_node_index, vlib_frame_t *f)
Definition: main.c:216
#define LACP_SUBTYPE
Definition: protocol.h:25
#define MARKER_PROTOCOL_VERSION
Definition: protocol.h:133
vlib_main_t * vm
Definition: in2out_ed.c:1599
static uword vlib_buffer_contents(vlib_main_t *vm, u32 buffer_index, u8 *contents)
Copy buffer contents to memory.
Definition: buffer_funcs.h:436
u8 len
Definition: ip_types.api:92
u32 marker_tx_id
Definition: node.h:321
u32 partner_state
Definition: node.h:357
u16 n_vectors
Definition: node.h:399
u32 sw_if_index
Definition: node.h:218
lacp_port_info_t partner
Definition: node.h:254
sll srl srl sll sra u16x4 i
Definition: vector_sse42.h:317
lacp_error_t
Definition: node.h:69
u8 data[]
Packet data.
Definition: buffer.h:181
int rx_state
Definition: node.h:313
lacp_main_t lacp_main
Definition: lacp.c:26
vlib_main_t vlib_node_runtime_t * node
Definition: in2out_ed.c:1599
#define ASSERT(truth)
lacp_pdu_t lacpdu
Definition: node.h:87
lacp_error_t lacp_input(vlib_main_t *vm, vlib_buffer_t *b0, u32 bi0)
Definition: input.c:137
static bond_if_t * bond_get_master_by_dev_instance(u32 dev_instance)
Definition: node.h:516
bond_main_t bond_main
Definition: node.c:25
uword hash_memory(void *p, word n_bytes, uword state)
Definition: hash.c:275
u32 bif_dev_instance
Definition: node.h:323
vlib_packet_template_t marker_packet_templates[MARKER_N_PACKET_TEMPLATES]
Definition: node.h:131
void marker_fill_request_pdu(marker_pdu_t *marker, slave_if_t *sif)
Definition: input.c:55
union lacp_input_trace_t::@56 pkt
Definition: defs.h:47
lacp_machine_t lacp_rx_machine
Definition: rx_machine.c:108
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
u32 sw_if_index
Definition: node.h:82
VLIB buffer representation.
Definition: buffer.h:102
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:244
static void lacp_start_current_while_timer(vlib_main_t *vm, slave_if_t *sif, u8 expiration)
Definition: rx_machine.h:77
#define LACP_STEADY_STATE
Definition: protocol.h:64
#define vnet_buffer(b)
Definition: buffer.h:417
static clib_error_t * lacp_init(vlib_main_t *vm)
Definition: input.c:239
u32 actor_state
Definition: node.h:358
static void send_ethernet_marker_response_pdu(vlib_main_t *vm, slave_if_t *sif)
Definition: input.c:65
static slave_if_t * bond_get_slave_by_sw_if_index(u32 sw_if_index)
Definition: node.h:524
u32 total_length_not_including_first_buffer
Only valid for first buffer in chain.
Definition: buffer.h:167
uword last_packet_signature
Definition: node.h:236
u8 packet_template_index
Definition: node.h:230
lacp_state_struct lacp_state_array[]
Definition: node.c:21
#define VLIB_INITS(...)
Definition: init.h:344
static vlib_buffer_t * vlib_get_buffer(vlib_main_t *vm, u32 buffer_index)
Translate buffer index into buffer pointer.
Definition: buffer_funcs.h:85
u64 marker_bad_pdu_received
Definition: node.h:343
int lacp_machine_dispatch(lacp_machine_t *machine, vlib_main_t *vm, slave_if_t *sif, int event, int *state)
Definition: lacp.c:317
Definition: defs.h:46
void stat_segment_set_state_counter(u32 index, u64 value)
Definition: stat_segment.c:961
#define LACP_ACTOR_LACP_VERSION
Definition: protocol.h:26