test/table: fix memory leak
[dpdk.git] / examples / ip_pipeline / config_check.c
1 /* SPDX-License-Identifier: BSD-3-Clause
2  * Copyright(c) 2010-2016 Intel Corporation
3  */
4
5 #include <stdio.h>
6
7 #include <rte_ip.h>
8
9 #include "app.h"
10
11 static void
12 check_mempools(struct app_params *app)
13 {
14         uint32_t i;
15
16         for (i = 0; i < app->n_mempools; i++) {
17                 struct app_mempool_params *p = &app->mempool_params[i];
18
19                 APP_CHECK((p->pool_size > 0),
20                         "Mempool %s size is 0\n", p->name);
21
22                 APP_CHECK((p->cache_size > 0),
23                         "Mempool %s cache size is 0\n", p->name);
24
25                 APP_CHECK(rte_is_power_of_2(p->cache_size),
26                         "Mempool %s cache size not a power of 2\n", p->name);
27         }
28 }
29
30 static inline uint32_t
31 link_rxq_used(struct app_link_params *link, uint32_t q_id)
32 {
33         uint32_t i;
34
35         if ((link->arp_q == q_id) ||
36                 (link->tcp_syn_q == q_id) ||
37                 (link->ip_local_q == q_id) ||
38                 (link->tcp_local_q == q_id) ||
39                 (link->udp_local_q == q_id) ||
40                 (link->sctp_local_q == q_id))
41                 return 1;
42
43         for (i = 0; i < link->n_rss_qs; i++)
44                 if (link->rss_qs[i] == q_id)
45                         return 1;
46
47         return 0;
48 }
49
50 static void
51 check_links(struct app_params *app)
52 {
53         uint32_t i;
54
55         /* Check that number of links matches the port mask */
56         if (app->port_mask) {
57                 uint32_t n_links_port_mask =
58                         __builtin_popcountll(app->port_mask);
59
60                 APP_CHECK((app->n_links == n_links_port_mask),
61                         "Not enough links provided in the PORT_MASK\n");
62         }
63
64         for (i = 0; i < app->n_links; i++) {
65                 struct app_link_params *link = &app->link_params[i];
66                 uint32_t rxq_max, n_rxq, n_txq, link_id, i;
67
68                 APP_PARAM_GET_ID(link, "LINK", link_id);
69
70                 /* Check that link RXQs are contiguous */
71                 rxq_max = 0;
72                 if (link->arp_q > rxq_max)
73                         rxq_max = link->arp_q;
74                 if (link->tcp_syn_q > rxq_max)
75                         rxq_max = link->tcp_syn_q;
76                 if (link->ip_local_q > rxq_max)
77                         rxq_max = link->ip_local_q;
78                 if (link->tcp_local_q > rxq_max)
79                         rxq_max = link->tcp_local_q;
80                 if (link->udp_local_q > rxq_max)
81                         rxq_max = link->udp_local_q;
82                 if (link->sctp_local_q > rxq_max)
83                         rxq_max = link->sctp_local_q;
84                 for (i = 0; i < link->n_rss_qs; i++)
85                         if (link->rss_qs[i] > rxq_max)
86                                 rxq_max = link->rss_qs[i];
87
88                 for (i = 1; i <= rxq_max; i++)
89                         APP_CHECK((link_rxq_used(link, i)),
90                                 "%s RXQs are not contiguous (A)\n", link->name);
91
92                 n_rxq = app_link_get_n_rxq(app, link);
93
94                 APP_CHECK((n_rxq), "%s does not have any RXQ\n", link->name);
95
96                 APP_CHECK((n_rxq == rxq_max + 1),
97                         "%s RXQs are not contiguous (B)\n", link->name);
98
99                 for (i = 0; i < n_rxq; i++) {
100                         char name[APP_PARAM_NAME_SIZE];
101                         int pos;
102
103                         sprintf(name, "RXQ%" PRIu32 ".%" PRIu32,
104                                 link_id, i);
105                         pos = APP_PARAM_FIND(app->hwq_in_params, name);
106                         APP_CHECK((pos >= 0),
107                                 "%s RXQs are not contiguous (C)\n", link->name);
108                 }
109
110                 /* Check that link TXQs are contiguous */
111                 n_txq = app_link_get_n_txq(app, link);
112
113                 APP_CHECK((n_txq),  "%s does not have any TXQ\n", link->name);
114
115                 for (i = 0; i < n_txq; i++) {
116                         char name[APP_PARAM_NAME_SIZE];
117                         int pos;
118
119                         sprintf(name, "TXQ%" PRIu32 ".%" PRIu32,
120                                 link_id, i);
121                         pos = APP_PARAM_FIND(app->hwq_out_params, name);
122                         APP_CHECK((pos >= 0),
123                                 "%s TXQs are not contiguous\n", link->name);
124                 }
125         }
126 }
127
128 static void
129 check_rxqs(struct app_params *app)
130 {
131         uint32_t i;
132
133         for (i = 0; i < app->n_pktq_hwq_in; i++) {
134                 struct app_pktq_hwq_in_params *p = &app->hwq_in_params[i];
135                 uint32_t n_readers = app_rxq_get_readers(app, p);
136
137                 APP_CHECK((p->size > 0),
138                         "%s size is 0\n", p->name);
139
140                 APP_CHECK((rte_is_power_of_2(p->size)),
141                         "%s size is not a power of 2\n", p->name);
142
143                 APP_CHECK((p->burst > 0),
144                         "%s burst size is 0\n", p->name);
145
146                 APP_CHECK((p->burst <= p->size),
147                         "%s burst size is bigger than its size\n", p->name);
148
149                 APP_CHECK((n_readers != 0),
150                         "%s has no reader\n", p->name);
151
152                 APP_CHECK((n_readers == 1),
153                         "%s has more than one reader\n", p->name);
154         }
155 }
156
157 static void
158 check_txqs(struct app_params *app)
159 {
160         uint32_t i;
161
162         for (i = 0; i < app->n_pktq_hwq_out; i++) {
163                 struct app_pktq_hwq_out_params *p = &app->hwq_out_params[i];
164                 uint32_t n_writers = app_txq_get_writers(app, p);
165
166                 APP_CHECK((p->size > 0),
167                         "%s size is 0\n", p->name);
168
169                 APP_CHECK((rte_is_power_of_2(p->size)),
170                         "%s size is not a power of 2\n", p->name);
171
172                 APP_CHECK((p->burst > 0),
173                         "%s burst size is 0\n", p->name);
174
175                 APP_CHECK((p->burst <= p->size),
176                         "%s burst size is bigger than its size\n", p->name);
177
178                 APP_CHECK((n_writers != 0),
179                         "%s has no writer\n", p->name);
180
181                 APP_CHECK((n_writers == 1),
182                         "%s has more than one writer\n", p->name);
183         }
184 }
185
186 static void
187 check_swqs(struct app_params *app)
188 {
189         uint32_t i;
190
191         for (i = 0; i < app->n_pktq_swq; i++) {
192                 struct app_pktq_swq_params *p = &app->swq_params[i];
193                 uint32_t n_readers = app_swq_get_readers(app, p);
194                 uint32_t n_writers = app_swq_get_writers(app, p);
195                 uint32_t n_flags;
196
197                 APP_CHECK((p->size > 0),
198                         "%s size is 0\n", p->name);
199
200                 APP_CHECK((rte_is_power_of_2(p->size)),
201                         "%s size is not a power of 2\n", p->name);
202
203                 APP_CHECK((p->burst_read > 0),
204                         "%s read burst size is 0\n", p->name);
205
206                 APP_CHECK((p->burst_read <= p->size),
207                         "%s read burst size is bigger than its size\n",
208                         p->name);
209
210                 APP_CHECK((p->burst_write > 0),
211                         "%s write burst size is 0\n", p->name);
212
213                 APP_CHECK((p->burst_write <= p->size),
214                         "%s write burst size is bigger than its size\n",
215                         p->name);
216
217                 APP_CHECK((n_readers != 0),
218                         "%s has no reader\n", p->name);
219
220                 if (n_readers > 1)
221                         APP_LOG(app, LOW, "%s has more than one reader", p->name);
222
223                 APP_CHECK((n_writers != 0),
224                         "%s has no writer\n", p->name);
225
226                 if (n_writers > 1)
227                         APP_LOG(app, LOW, "%s has more than one writer", p->name);
228
229                 n_flags = p->ipv4_frag + p->ipv6_frag + p->ipv4_ras + p->ipv6_ras;
230
231                 APP_CHECK((n_flags < 2),
232                         "%s has more than one fragmentation or reassembly mode enabled\n",
233                         p->name);
234
235                 APP_CHECK((!((n_readers > 1) && (n_flags == 1))),
236                         "%s has more than one reader when fragmentation or reassembly"
237                         " mode enabled\n",
238                         p->name);
239
240                 APP_CHECK((!((n_writers > 1) && (n_flags == 1))),
241                         "%s has more than one writer when fragmentation or reassembly"
242                         " mode enabled\n",
243                         p->name);
244
245                 n_flags = p->ipv4_ras + p->ipv6_ras;
246
247                 APP_CHECK((!((p->dropless == 1) && (n_flags == 1))),
248                         "%s has dropless when reassembly mode enabled\n", p->name);
249
250                 n_flags = p->ipv4_frag + p->ipv6_frag;
251
252                 if (n_flags == 1) {
253                         uint16_t ip_hdr_size = (p->ipv4_frag) ? sizeof(struct ipv4_hdr) :
254                                 sizeof(struct ipv6_hdr);
255
256                         APP_CHECK((p->mtu > ip_hdr_size),
257                                 "%s mtu size is smaller than ip header\n", p->name);
258
259                         APP_CHECK((!((p->mtu - ip_hdr_size) % 8)),
260                                 "%s mtu size is incorrect\n", p->name);
261                 }
262         }
263 }
264
265 static void
266 check_tms(struct app_params *app)
267 {
268         uint32_t i;
269
270         for (i = 0; i < app->n_pktq_tm; i++) {
271                 struct app_pktq_tm_params *p = &app->tm_params[i];
272                 uint32_t n_readers = app_tm_get_readers(app, p);
273                 uint32_t n_writers = app_tm_get_writers(app, p);
274
275                 APP_CHECK((n_readers != 0),
276                         "%s has no reader\n", p->name);
277
278                 APP_CHECK((n_readers == 1),
279                         "%s has more than one reader\n", p->name);
280
281                 APP_CHECK((n_writers != 0),
282                         "%s has no writer\n", p->name);
283
284                 APP_CHECK((n_writers == 1),
285                         "%s has more than one writer\n", p->name);
286         }
287 }
288
289 static void
290 check_taps(struct app_params *app)
291 {
292         uint32_t i;
293
294         for (i = 0; i < app->n_pktq_tap; i++) {
295                 struct app_pktq_tap_params *p = &app->tap_params[i];
296                 uint32_t n_readers = app_tap_get_readers(app, p);
297                 uint32_t n_writers = app_tap_get_writers(app, p);
298
299                 APP_CHECK((n_readers != 0),
300                         "%s has no reader\n", p->name);
301
302                 APP_CHECK((n_readers == 1),
303                         "%s has more than one reader\n", p->name);
304
305                 APP_CHECK((n_writers != 0),
306                         "%s has no writer\n", p->name);
307
308                 APP_CHECK((n_writers == 1),
309                         "%s has more than one writer\n", p->name);
310
311                 APP_CHECK((p->burst_read > 0),
312                         "%s read burst size is 0\n", p->name);
313
314                 APP_CHECK((p->burst_write > 0),
315                         "%s write burst size is 0\n", p->name);
316         }
317 }
318
319 static void
320 check_knis(struct app_params *app) {
321         uint32_t i;
322
323         for (i = 0; i < app->n_pktq_kni; i++) {
324                 struct app_pktq_kni_params *p = &app->kni_params[i];
325                 uint32_t n_readers = app_kni_get_readers(app, p);
326                 uint32_t n_writers = app_kni_get_writers(app, p);
327
328                 APP_CHECK((n_readers != 0),
329                         "%s has no reader\n", p->name);
330
331                 APP_CHECK((n_readers == 1),
332                         "%s has more than one reader\n", p->name);
333
334                 APP_CHECK((n_writers != 0),
335                         "%s has no writer\n", p->name);
336
337                 APP_CHECK((n_writers == 1),
338                         "%s has more than one writer\n", p->name);
339         }
340 }
341
342 static void
343 check_sources(struct app_params *app)
344 {
345         uint32_t i;
346
347         for (i = 0; i < app->n_pktq_source; i++) {
348                 struct app_pktq_source_params *p = &app->source_params[i];
349                 uint32_t n_readers = app_source_get_readers(app, p);
350
351                 APP_CHECK((n_readers != 0),
352                         "%s has no reader\n", p->name);
353
354                 APP_CHECK((n_readers == 1),
355                         "%s has more than one reader\n", p->name);
356         }
357 }
358
359 static void
360 check_sinks(struct app_params *app)
361 {
362         uint32_t i;
363
364         for (i = 0; i < app->n_pktq_sink; i++) {
365                 struct app_pktq_sink_params *p = &app->sink_params[i];
366                 uint32_t n_writers = app_sink_get_writers(app, p);
367
368                 APP_CHECK((n_writers != 0),
369                         "%s has no writer\n", p->name);
370
371                 APP_CHECK((n_writers == 1),
372                         "%s has more than one writer\n", p->name);
373         }
374 }
375
376 static void
377 check_msgqs(struct app_params *app)
378 {
379         uint32_t i;
380
381         for (i = 0; i < app->n_msgq; i++) {
382                 struct app_msgq_params *p = &app->msgq_params[i];
383                 uint32_t n_readers = app_msgq_get_readers(app, p);
384                 uint32_t n_writers = app_msgq_get_writers(app, p);
385                 uint32_t msgq_req_pipeline, msgq_rsp_pipeline;
386                 uint32_t msgq_req_core, msgq_rsp_core;
387
388                 APP_CHECK((p->size > 0),
389                         "%s size is 0\n", p->name);
390
391                 APP_CHECK((rte_is_power_of_2(p->size)),
392                         "%s size is not a power of 2\n", p->name);
393
394                 msgq_req_pipeline = (strncmp(p->name, "MSGQ-REQ-PIPELINE",
395                         strlen("MSGQ-REQ-PIPELINE")) == 0);
396
397                 msgq_rsp_pipeline = (strncmp(p->name, "MSGQ-RSP-PIPELINE",
398                         strlen("MSGQ-RSP-PIPELINE")) == 0);
399
400                 msgq_req_core = (strncmp(p->name, "MSGQ-REQ-CORE",
401                         strlen("MSGQ-REQ-CORE")) == 0);
402
403                 msgq_rsp_core = (strncmp(p->name, "MSGQ-RSP-CORE",
404                         strlen("MSGQ-RSP-CORE")) == 0);
405
406                 if ((msgq_req_pipeline == 0) &&
407                         (msgq_rsp_pipeline == 0) &&
408                         (msgq_req_core == 0) &&
409                         (msgq_rsp_core == 0)) {
410                         APP_CHECK((n_readers != 0),
411                                 "%s has no reader\n", p->name);
412
413                         APP_CHECK((n_readers == 1),
414                                 "%s has more than one reader\n", p->name);
415
416                         APP_CHECK((n_writers != 0),
417                                 "%s has no writer\n", p->name);
418
419                         APP_CHECK((n_writers == 1),
420                                 "%s has more than one writer\n", p->name);
421                 }
422
423                 if (msgq_req_pipeline) {
424                         struct app_pipeline_params *pipeline;
425                         uint32_t pipeline_id;
426
427                         APP_PARAM_GET_ID(p, "MSGQ-REQ-PIPELINE", pipeline_id);
428
429                         APP_PARAM_FIND_BY_ID(app->pipeline_params,
430                                 "PIPELINE",
431                                 pipeline_id,
432                                 pipeline);
433
434                         APP_CHECK((pipeline != NULL),
435                                 "%s is not associated with a valid pipeline\n",
436                                 p->name);
437                 }
438
439                 if (msgq_rsp_pipeline) {
440                         struct app_pipeline_params *pipeline;
441                         uint32_t pipeline_id;
442
443                         APP_PARAM_GET_ID(p, "MSGQ-RSP-PIPELINE", pipeline_id);
444
445                         APP_PARAM_FIND_BY_ID(app->pipeline_params,
446                                 "PIPELINE",
447                                 pipeline_id,
448                                 pipeline);
449
450                         APP_CHECK((pipeline != NULL),
451                                 "%s is not associated with a valid pipeline\n",
452                                 p->name);
453                 }
454         }
455 }
456
457 static void
458 check_pipelines(struct app_params *app)
459 {
460         uint32_t i;
461
462         for (i = 0; i < app->n_pipelines; i++) {
463                 struct app_pipeline_params *p = &app->pipeline_params[i];
464
465                 APP_CHECK((p->n_msgq_in == p->n_msgq_out),
466                         "%s number of input MSGQs does not match "
467                         "the number of output MSGQs\n", p->name);
468         }
469 }
470
471 int
472 app_config_check(struct app_params *app)
473 {
474         check_mempools(app);
475         check_links(app);
476         check_rxqs(app);
477         check_txqs(app);
478         check_swqs(app);
479         check_tms(app);
480         check_taps(app);
481         check_knis(app);
482         check_sources(app);
483         check_sinks(app);
484         check_msgqs(app);
485         check_pipelines(app);
486
487         return 0;
488 }