Line data Source code
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 : #include <vlib/vlib.h>
17 : #include <vnet/vnet.h>
18 : #include <vppinfra/error.h>
19 : #include <ioam/ipfixcollector/ipfixcollector.h>
20 : #include <vnet/ipfix-export/ipfix_packet.h>
21 :
22 : #define foreach_ipfix_collector_error \
23 : _(PROCESSED, "Number of IP-Fix packets processed") \
24 : _(NO_LISTENER, "Number of IP-Fix packets with no listener")
25 :
26 : typedef enum
27 : {
28 : #define _(sym,str) IPFIX_COLLECTOR_ERROR_##sym,
29 : foreach_ipfix_collector_error
30 : #undef _
31 : IPFIX_COLLECTOR_N_ERROR,
32 : } flowperpkt_error_t;
33 :
34 : static char *ipfix_collector_error_strings[] = {
35 : #define _(sym,string) string,
36 : foreach_ipfix_collector_error
37 : #undef _
38 : };
39 :
40 : typedef enum
41 : {
42 : IPFIX_COLLECTOR_NEXT_DROP,
43 : IPFIX_COLLECTOR_N_NEXT,
44 : } ipfix_collector_next_t;
45 :
46 : typedef struct
47 : {
48 : u32 next_node;
49 : u16 set_id;
50 : u16 pad;
51 : } ipfix_collector_trace_t;
52 :
53 : vlib_node_registration_t ipfix_collector_node;
54 :
55 : /* packet trace format function */
56 : static u8 *
57 0 : format_ipfix_collector_trace (u8 * s, va_list * args)
58 : {
59 0 : CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
60 0 : CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
61 0 : ipfix_collector_trace_t *t = va_arg (*args, ipfix_collector_trace_t *);
62 :
63 0 : s = format (s,
64 0 : "IPFIX_COLLECTOR: set_id %u, next_node %u", t->set_id,
65 : t->next_node);
66 0 : return s;
67 : }
68 :
69 : /**
70 : * @brief Node to receive IP-Fix packets.
71 : * @node ipfix-collector
72 : *
73 : * This function receives IP-FIX packets and forwards them to other graph nodes
74 : * based on SetID field in IP-FIX.
75 : *
76 : * @param vm vlib_main_t corresponding to the current thread.
77 : * @param node vlib_node_runtime_t data for this node.
78 : * @param frame vlib_frame_t whose contents should be dispatched.
79 : *
80 : * @par Graph mechanics: buffer, next index usage
81 : *
82 : * <em>Uses:</em>
83 : * - <code>vlib_buffer_get_current(p0)</code>
84 : * - Parses IP-Fix packet to extract SetId which will be used to decide
85 : * next node where packets should be enqueued.
86 : *
87 : * <em>Next Index:</em>
88 : * - Dispatches the packet to other VPP graph nodes based on their registartion
89 : * for the IP-Fix SetId using API ipfix_collector_reg_setid().
90 : */
91 : uword
92 0 : ipfix_collector_node_fn (vlib_main_t * vm,
93 : vlib_node_runtime_t * node,
94 : vlib_frame_t * from_frame)
95 : {
96 : u32 n_left_from, next_index, *from, *to_next;
97 0 : word n_no_listener = 0;
98 0 : word n_listener = 0;
99 :
100 0 : from = vlib_frame_vector_args (from_frame);
101 0 : n_left_from = from_frame->n_vectors;
102 :
103 0 : next_index = node->cached_next_index;
104 :
105 0 : while (n_left_from > 0)
106 : {
107 : u32 n_left_to_next;
108 :
109 0 : vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
110 :
111 0 : while (n_left_from >= 4 && n_left_to_next >= 2)
112 : {
113 : u32 bi0, bi1;
114 : vlib_buffer_t *b0, *b1;
115 : u32 next0, next1;
116 : ipfix_message_header_t *ipfix0, *ipfix1;
117 : ipfix_set_header_t *set0, *set1;
118 : u16 set_id0, set_id1;
119 : ipfix_client *client0, *client1;
120 :
121 : /* Prefetch next iteration. */
122 : {
123 : vlib_buffer_t *p2, *p3;
124 :
125 0 : p2 = vlib_get_buffer (vm, from[2]);
126 0 : p3 = vlib_get_buffer (vm, from[3]);
127 :
128 0 : vlib_prefetch_buffer_header (p2, LOAD);
129 0 : vlib_prefetch_buffer_header (p3, LOAD);
130 :
131 0 : CLIB_PREFETCH (p2->data,
132 : (sizeof (ipfix_message_header_t) +
133 : sizeof (ipfix_set_header_t)), LOAD);
134 0 : CLIB_PREFETCH (p3->data,
135 : (sizeof (ipfix_message_header_t) +
136 : sizeof (ipfix_set_header_t)), LOAD);
137 : }
138 :
139 0 : bi0 = from[0];
140 0 : bi1 = from[1];
141 0 : to_next[0] = bi0;
142 0 : to_next[1] = bi1;
143 0 : from += 2;
144 0 : to_next += 2;
145 0 : n_left_to_next -= 2;
146 0 : n_left_from -= 2;
147 :
148 0 : b0 = vlib_get_buffer (vm, bi0);
149 0 : b1 = vlib_get_buffer (vm, bi1);
150 :
151 0 : ipfix0 = vlib_buffer_get_current (b0);
152 0 : ipfix1 = vlib_buffer_get_current (b1);
153 :
154 0 : set0 = (ipfix_set_header_t *) (ipfix0 + 1);
155 0 : set1 = (ipfix_set_header_t *) (ipfix1 + 1);
156 :
157 0 : set_id0 = (u16) (clib_net_to_host_u32 (set0->set_id_length) >> 16);
158 0 : set_id1 = (u16) (clib_net_to_host_u32 (set1->set_id_length) >> 16);
159 :
160 0 : client0 = ipfix_collector_get_client (set_id0);
161 0 : client1 = ipfix_collector_get_client (set_id1);
162 :
163 0 : if (PREDICT_TRUE (NULL != client0))
164 : {
165 0 : next0 = client0->client_next_node;
166 0 : n_listener++;
167 : }
168 : else
169 : {
170 0 : next0 = IPFIX_COLLECTOR_NEXT_DROP;
171 0 : n_no_listener++;
172 : }
173 :
174 0 : if (PREDICT_TRUE (NULL != client1))
175 : {
176 0 : next1 = client1->client_next_node;
177 0 : n_listener++;
178 : }
179 : else
180 : {
181 0 : next1 = IPFIX_COLLECTOR_NEXT_DROP;
182 0 : n_no_listener++;
183 : }
184 :
185 0 : vlib_buffer_advance (b0,
186 : (sizeof (ipfix_message_header_t)
187 : + sizeof (ipfix_set_header_t)));
188 0 : vlib_buffer_advance (b1,
189 : (sizeof (ipfix_message_header_t)
190 : + sizeof (ipfix_set_header_t)));
191 :
192 0 : if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
193 : {
194 0 : ipfix_collector_trace_t *tr = vlib_add_trace (vm, node,
195 : b0, sizeof (*tr));
196 0 : tr->next_node = (client0 ? client0->client_node : 0xFFFFFFFF);
197 0 : tr->set_id = set_id0;
198 : }
199 0 : if (PREDICT_FALSE (b1->flags & VLIB_BUFFER_IS_TRACED))
200 : {
201 0 : ipfix_collector_trace_t *tr = vlib_add_trace (vm, node,
202 : b1, sizeof (*tr));
203 0 : tr->next_node = (client1 ? client1->client_node : 0xFFFFFFFF);
204 0 : tr->set_id = set_id1;
205 : }
206 :
207 0 : vlib_validate_buffer_enqueue_x2 (vm, node, next_index,
208 : to_next, n_left_to_next,
209 : bi0, bi1, next0, next1);
210 : }
211 :
212 0 : while (n_left_from > 0 && n_left_to_next > 0)
213 : {
214 : u32 bi0;
215 : vlib_buffer_t *b0;
216 : u32 next0;
217 : ipfix_message_header_t *ipfix0;
218 : ipfix_set_header_t *set0;
219 : u16 set_id0;
220 : ipfix_client *client0;
221 :
222 0 : bi0 = from[0];
223 0 : to_next[0] = bi0;
224 0 : from += 1;
225 0 : to_next += 1;
226 0 : n_left_from -= 1;
227 0 : n_left_to_next -= 1;
228 :
229 0 : b0 = vlib_get_buffer (vm, bi0);
230 0 : ipfix0 = vlib_buffer_get_current (b0);
231 :
232 0 : set0 = (ipfix_set_header_t *) (ipfix0 + 1);
233 :
234 0 : set_id0 = (u16) (clib_net_to_host_u32 (set0->set_id_length) >> 16);
235 :
236 0 : client0 = ipfix_collector_get_client (set_id0);
237 :
238 0 : if (PREDICT_TRUE (NULL != client0))
239 : {
240 0 : next0 = client0->client_next_node;
241 0 : n_listener++;
242 : }
243 : else
244 : {
245 0 : next0 = IPFIX_COLLECTOR_NEXT_DROP;
246 0 : n_no_listener++;
247 : }
248 :
249 0 : vlib_buffer_advance (b0,
250 : (sizeof (ipfix_message_header_t)
251 : + sizeof (ipfix_set_header_t)));
252 0 : if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
253 : {
254 0 : ipfix_collector_trace_t *tr = vlib_add_trace (vm, node,
255 : b0, sizeof (*tr));
256 0 : tr->next_node = (client0 ? client0->client_node : 0xFFFFFFFF);
257 0 : tr->set_id = set_id0;
258 : }
259 :
260 0 : vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
261 : to_next, n_left_to_next,
262 : bi0, next0);
263 : }
264 :
265 0 : vlib_put_next_frame (vm, node, next_index, n_left_to_next);
266 : }
267 0 : vlib_error_count (vm, node->node_index,
268 : IPFIX_COLLECTOR_ERROR_NO_LISTENER, n_no_listener);
269 0 : vlib_error_count (vm, node->node_index,
270 : IPFIX_COLLECTOR_ERROR_PROCESSED, n_listener);
271 0 : return from_frame->n_vectors;
272 : }
273 :
274 : /* *INDENT-OFF* */
275 114668 : VLIB_REGISTER_NODE (ipfix_collector_node) = {
276 : .function = ipfix_collector_node_fn,
277 : .name = "ipfix-collector",
278 : .vector_size = sizeof (u32),
279 : .format_trace = format_ipfix_collector_trace,
280 : .type = VLIB_NODE_TYPE_INTERNAL,
281 :
282 : .n_errors = ARRAY_LEN(ipfix_collector_error_strings),
283 : .error_strings = ipfix_collector_error_strings,
284 :
285 : .n_next_nodes = IPFIX_COLLECTOR_N_NEXT,
286 :
287 : /* edit / add dispositions here */
288 : .next_nodes = {
289 : [IPFIX_COLLECTOR_NEXT_DROP] = "error-drop",
290 : },
291 : };
292 : /* *INDENT-ON* */
293 :
294 : /*
295 : * fd.io coding-style-patch-verification: ON
296 : *
297 : * Local Variables:
298 : * eval: (c-set-style "gnu")
299 : * End:
300 : */
|
