build: use static deps for pkg-config libs.private
[dpdk.git] / lib / librte_port / rte_port_ethdev.c
1 /* SPDX-License-Identifier: BSD-3-Clause
2  * Copyright(c) 2010-2014 Intel Corporation
3  */
4 #include <string.h>
5 #include <stdint.h>
6
7 #include <rte_mbuf.h>
8 #include <rte_ethdev.h>
9 #include <rte_malloc.h>
10
11 #include "rte_port_ethdev.h"
12
13 /*
14  * Port ETHDEV Reader
15  */
16 #ifdef RTE_PORT_STATS_COLLECT
17
18 #define RTE_PORT_ETHDEV_READER_STATS_PKTS_IN_ADD(port, val) \
19         port->stats.n_pkts_in += val
20 #define RTE_PORT_ETHDEV_READER_STATS_PKTS_DROP_ADD(port, val) \
21         port->stats.n_pkts_drop += val
22
23 #else
24
25 #define RTE_PORT_ETHDEV_READER_STATS_PKTS_IN_ADD(port, val)
26 #define RTE_PORT_ETHDEV_READER_STATS_PKTS_DROP_ADD(port, val)
27
28 #endif
29
30 struct rte_port_ethdev_reader {
31         struct rte_port_in_stats stats;
32
33         uint16_t queue_id;
34         uint16_t port_id;
35 };
36
37 static void *
38 rte_port_ethdev_reader_create(void *params, int socket_id)
39 {
40         struct rte_port_ethdev_reader_params *conf =
41                         params;
42         struct rte_port_ethdev_reader *port;
43
44         /* Check input parameters */
45         if (conf == NULL) {
46                 RTE_LOG(ERR, PORT, "%s: params is NULL\n", __func__);
47                 return NULL;
48         }
49
50         /* Memory allocation */
51         port = rte_zmalloc_socket("PORT", sizeof(*port),
52                         RTE_CACHE_LINE_SIZE, socket_id);
53         if (port == NULL) {
54                 RTE_LOG(ERR, PORT, "%s: Failed to allocate port\n", __func__);
55                 return NULL;
56         }
57
58         /* Initialization */
59         port->port_id = conf->port_id;
60         port->queue_id = conf->queue_id;
61
62         return port;
63 }
64
65 static int
66 rte_port_ethdev_reader_rx(void *port, struct rte_mbuf **pkts, uint32_t n_pkts)
67 {
68         struct rte_port_ethdev_reader *p =
69                 port;
70         uint16_t rx_pkt_cnt;
71
72         rx_pkt_cnt = rte_eth_rx_burst(p->port_id, p->queue_id, pkts, n_pkts);
73         RTE_PORT_ETHDEV_READER_STATS_PKTS_IN_ADD(p, rx_pkt_cnt);
74         return rx_pkt_cnt;
75 }
76
77 static int
78 rte_port_ethdev_reader_free(void *port)
79 {
80         if (port == NULL) {
81                 RTE_LOG(ERR, PORT, "%s: port is NULL\n", __func__);
82                 return -EINVAL;
83         }
84
85         rte_free(port);
86
87         return 0;
88 }
89
90 static int rte_port_ethdev_reader_stats_read(void *port,
91                 struct rte_port_in_stats *stats, int clear)
92 {
93         struct rte_port_ethdev_reader *p =
94                         port;
95
96         if (stats != NULL)
97                 memcpy(stats, &p->stats, sizeof(p->stats));
98
99         if (clear)
100                 memset(&p->stats, 0, sizeof(p->stats));
101
102         return 0;
103 }
104
105 /*
106  * Port ETHDEV Writer
107  */
108 #ifdef RTE_PORT_STATS_COLLECT
109
110 #define RTE_PORT_ETHDEV_WRITER_STATS_PKTS_IN_ADD(port, val) \
111         port->stats.n_pkts_in += val
112 #define RTE_PORT_ETHDEV_WRITER_STATS_PKTS_DROP_ADD(port, val) \
113         port->stats.n_pkts_drop += val
114
115 #else
116
117 #define RTE_PORT_ETHDEV_WRITER_STATS_PKTS_IN_ADD(port, val)
118 #define RTE_PORT_ETHDEV_WRITER_STATS_PKTS_DROP_ADD(port, val)
119
120 #endif
121
122 struct rte_port_ethdev_writer {
123         struct rte_port_out_stats stats;
124
125         struct rte_mbuf *tx_buf[2 * RTE_PORT_IN_BURST_SIZE_MAX];
126         uint32_t tx_burst_sz;
127         uint16_t tx_buf_count;
128         uint64_t bsz_mask;
129         uint16_t queue_id;
130         uint16_t port_id;
131 };
132
133 static void *
134 rte_port_ethdev_writer_create(void *params, int socket_id)
135 {
136         struct rte_port_ethdev_writer_params *conf =
137                         params;
138         struct rte_port_ethdev_writer *port;
139
140         /* Check input parameters */
141         if ((conf == NULL) ||
142                 (conf->tx_burst_sz == 0) ||
143                 (conf->tx_burst_sz > RTE_PORT_IN_BURST_SIZE_MAX) ||
144                 (!rte_is_power_of_2(conf->tx_burst_sz))) {
145                 RTE_LOG(ERR, PORT, "%s: Invalid input parameters\n", __func__);
146                 return NULL;
147         }
148
149         /* Memory allocation */
150         port = rte_zmalloc_socket("PORT", sizeof(*port),
151                         RTE_CACHE_LINE_SIZE, socket_id);
152         if (port == NULL) {
153                 RTE_LOG(ERR, PORT, "%s: Failed to allocate port\n", __func__);
154                 return NULL;
155         }
156
157         /* Initialization */
158         port->port_id = conf->port_id;
159         port->queue_id = conf->queue_id;
160         port->tx_burst_sz = conf->tx_burst_sz;
161         port->tx_buf_count = 0;
162         port->bsz_mask = 1LLU << (conf->tx_burst_sz - 1);
163
164         return port;
165 }
166
167 static inline void
168 send_burst(struct rte_port_ethdev_writer *p)
169 {
170         uint32_t nb_tx;
171
172         nb_tx = rte_eth_tx_burst(p->port_id, p->queue_id,
173                          p->tx_buf, p->tx_buf_count);
174
175         RTE_PORT_ETHDEV_WRITER_STATS_PKTS_DROP_ADD(p, p->tx_buf_count - nb_tx);
176         for ( ; nb_tx < p->tx_buf_count; nb_tx++)
177                 rte_pktmbuf_free(p->tx_buf[nb_tx]);
178
179         p->tx_buf_count = 0;
180 }
181
182 static int
183 rte_port_ethdev_writer_tx(void *port, struct rte_mbuf *pkt)
184 {
185         struct rte_port_ethdev_writer *p =
186                 port;
187
188         p->tx_buf[p->tx_buf_count++] = pkt;
189         RTE_PORT_ETHDEV_WRITER_STATS_PKTS_IN_ADD(p, 1);
190         if (p->tx_buf_count >= p->tx_burst_sz)
191                 send_burst(p);
192
193         return 0;
194 }
195
196 static int
197 rte_port_ethdev_writer_tx_bulk(void *port,
198                 struct rte_mbuf **pkts,
199                 uint64_t pkts_mask)
200 {
201         struct rte_port_ethdev_writer *p =
202                 port;
203         uint64_t bsz_mask = p->bsz_mask;
204         uint32_t tx_buf_count = p->tx_buf_count;
205         uint64_t expr = (pkts_mask & (pkts_mask + 1)) |
206                         ((pkts_mask & bsz_mask) ^ bsz_mask);
207
208         if (expr == 0) {
209                 uint64_t n_pkts = __builtin_popcountll(pkts_mask);
210                 uint32_t n_pkts_ok;
211
212                 if (tx_buf_count)
213                         send_burst(p);
214
215                 RTE_PORT_ETHDEV_WRITER_STATS_PKTS_IN_ADD(p, n_pkts);
216                 n_pkts_ok = rte_eth_tx_burst(p->port_id, p->queue_id, pkts,
217                         n_pkts);
218
219                 RTE_PORT_ETHDEV_WRITER_STATS_PKTS_DROP_ADD(p, n_pkts - n_pkts_ok);
220                 for ( ; n_pkts_ok < n_pkts; n_pkts_ok++) {
221                         struct rte_mbuf *pkt = pkts[n_pkts_ok];
222
223                         rte_pktmbuf_free(pkt);
224                 }
225         } else {
226                 for ( ; pkts_mask; ) {
227                         uint32_t pkt_index = __builtin_ctzll(pkts_mask);
228                         uint64_t pkt_mask = 1LLU << pkt_index;
229                         struct rte_mbuf *pkt = pkts[pkt_index];
230
231                         p->tx_buf[tx_buf_count++] = pkt;
232                         RTE_PORT_ETHDEV_WRITER_STATS_PKTS_IN_ADD(p, 1);
233                         pkts_mask &= ~pkt_mask;
234                 }
235
236                 p->tx_buf_count = tx_buf_count;
237                 if (tx_buf_count >= p->tx_burst_sz)
238                         send_burst(p);
239         }
240
241         return 0;
242 }
243
244 static int
245 rte_port_ethdev_writer_flush(void *port)
246 {
247         struct rte_port_ethdev_writer *p =
248                 port;
249
250         if (p->tx_buf_count > 0)
251                 send_burst(p);
252
253         return 0;
254 }
255
256 static int
257 rte_port_ethdev_writer_free(void *port)
258 {
259         if (port == NULL) {
260                 RTE_LOG(ERR, PORT, "%s: Port is NULL\n", __func__);
261                 return -EINVAL;
262         }
263
264         rte_port_ethdev_writer_flush(port);
265         rte_free(port);
266
267         return 0;
268 }
269
270 static int rte_port_ethdev_writer_stats_read(void *port,
271                 struct rte_port_out_stats *stats, int clear)
272 {
273         struct rte_port_ethdev_writer *p =
274                 port;
275
276         if (stats != NULL)
277                 memcpy(stats, &p->stats, sizeof(p->stats));
278
279         if (clear)
280                 memset(&p->stats, 0, sizeof(p->stats));
281
282         return 0;
283 }
284
285 /*
286  * Port ETHDEV Writer Nodrop
287  */
288 #ifdef RTE_PORT_STATS_COLLECT
289
290 #define RTE_PORT_ETHDEV_WRITER_NODROP_STATS_PKTS_IN_ADD(port, val) \
291         port->stats.n_pkts_in += val
292 #define RTE_PORT_ETHDEV_WRITER_NODROP_STATS_PKTS_DROP_ADD(port, val) \
293         port->stats.n_pkts_drop += val
294
295 #else
296
297 #define RTE_PORT_ETHDEV_WRITER_NODROP_STATS_PKTS_IN_ADD(port, val)
298 #define RTE_PORT_ETHDEV_WRITER_NODROP_STATS_PKTS_DROP_ADD(port, val)
299
300 #endif
301
302 struct rte_port_ethdev_writer_nodrop {
303         struct rte_port_out_stats stats;
304
305         struct rte_mbuf *tx_buf[2 * RTE_PORT_IN_BURST_SIZE_MAX];
306         uint32_t tx_burst_sz;
307         uint16_t tx_buf_count;
308         uint64_t bsz_mask;
309         uint64_t n_retries;
310         uint16_t queue_id;
311         uint16_t port_id;
312 };
313
314 static void *
315 rte_port_ethdev_writer_nodrop_create(void *params, int socket_id)
316 {
317         struct rte_port_ethdev_writer_nodrop_params *conf =
318                         params;
319         struct rte_port_ethdev_writer_nodrop *port;
320
321         /* Check input parameters */
322         if ((conf == NULL) ||
323                 (conf->tx_burst_sz == 0) ||
324                 (conf->tx_burst_sz > RTE_PORT_IN_BURST_SIZE_MAX) ||
325                 (!rte_is_power_of_2(conf->tx_burst_sz))) {
326                 RTE_LOG(ERR, PORT, "%s: Invalid input parameters\n", __func__);
327                 return NULL;
328         }
329
330         /* Memory allocation */
331         port = rte_zmalloc_socket("PORT", sizeof(*port),
332                         RTE_CACHE_LINE_SIZE, socket_id);
333         if (port == NULL) {
334                 RTE_LOG(ERR, PORT, "%s: Failed to allocate port\n", __func__);
335                 return NULL;
336         }
337
338         /* Initialization */
339         port->port_id = conf->port_id;
340         port->queue_id = conf->queue_id;
341         port->tx_burst_sz = conf->tx_burst_sz;
342         port->tx_buf_count = 0;
343         port->bsz_mask = 1LLU << (conf->tx_burst_sz - 1);
344
345         /*
346          * When n_retries is 0 it means that we should wait for every packet to
347          * send no matter how many retries should it take. To limit number of
348          * branches in fast path, we use UINT64_MAX instead of branching.
349          */
350         port->n_retries = (conf->n_retries == 0) ? UINT64_MAX : conf->n_retries;
351
352         return port;
353 }
354
355 static inline void
356 send_burst_nodrop(struct rte_port_ethdev_writer_nodrop *p)
357 {
358         uint32_t nb_tx = 0, i;
359
360         nb_tx = rte_eth_tx_burst(p->port_id, p->queue_id, p->tx_buf,
361                         p->tx_buf_count);
362
363         /* We sent all the packets in a first try */
364         if (nb_tx >= p->tx_buf_count) {
365                 p->tx_buf_count = 0;
366                 return;
367         }
368
369         for (i = 0; i < p->n_retries; i++) {
370                 nb_tx += rte_eth_tx_burst(p->port_id, p->queue_id,
371                                                          p->tx_buf + nb_tx, p->tx_buf_count - nb_tx);
372
373                 /* We sent all the packets in more than one try */
374                 if (nb_tx >= p->tx_buf_count) {
375                         p->tx_buf_count = 0;
376                         return;
377                 }
378         }
379
380         /* We didn't send the packets in maximum allowed attempts */
381         RTE_PORT_ETHDEV_WRITER_NODROP_STATS_PKTS_DROP_ADD(p, p->tx_buf_count - nb_tx);
382         for ( ; nb_tx < p->tx_buf_count; nb_tx++)
383                 rte_pktmbuf_free(p->tx_buf[nb_tx]);
384
385         p->tx_buf_count = 0;
386 }
387
388 static int
389 rte_port_ethdev_writer_nodrop_tx(void *port, struct rte_mbuf *pkt)
390 {
391         struct rte_port_ethdev_writer_nodrop *p =
392                 port;
393
394         p->tx_buf[p->tx_buf_count++] = pkt;
395         RTE_PORT_ETHDEV_WRITER_NODROP_STATS_PKTS_IN_ADD(p, 1);
396         if (p->tx_buf_count >= p->tx_burst_sz)
397                 send_burst_nodrop(p);
398
399         return 0;
400 }
401
402 static int
403 rte_port_ethdev_writer_nodrop_tx_bulk(void *port,
404                 struct rte_mbuf **pkts,
405                 uint64_t pkts_mask)
406 {
407         struct rte_port_ethdev_writer_nodrop *p =
408                 port;
409
410         uint64_t bsz_mask = p->bsz_mask;
411         uint32_t tx_buf_count = p->tx_buf_count;
412         uint64_t expr = (pkts_mask & (pkts_mask + 1)) |
413                         ((pkts_mask & bsz_mask) ^ bsz_mask);
414
415         if (expr == 0) {
416                 uint64_t n_pkts = __builtin_popcountll(pkts_mask);
417                 uint32_t n_pkts_ok;
418
419                 if (tx_buf_count)
420                         send_burst_nodrop(p);
421
422                 RTE_PORT_ETHDEV_WRITER_NODROP_STATS_PKTS_IN_ADD(p, n_pkts);
423                 n_pkts_ok = rte_eth_tx_burst(p->port_id, p->queue_id, pkts,
424                         n_pkts);
425
426                 if (n_pkts_ok >= n_pkts)
427                         return 0;
428
429                 /*
430                  * If we did not manage to send all packets in single burst,
431                  * move remaining packets to the buffer and call send burst.
432                  */
433                 for (; n_pkts_ok < n_pkts; n_pkts_ok++) {
434                         struct rte_mbuf *pkt = pkts[n_pkts_ok];
435                         p->tx_buf[p->tx_buf_count++] = pkt;
436                 }
437                 send_burst_nodrop(p);
438         } else {
439                 for ( ; pkts_mask; ) {
440                         uint32_t pkt_index = __builtin_ctzll(pkts_mask);
441                         uint64_t pkt_mask = 1LLU << pkt_index;
442                         struct rte_mbuf *pkt = pkts[pkt_index];
443
444                         p->tx_buf[tx_buf_count++] = pkt;
445                         RTE_PORT_ETHDEV_WRITER_NODROP_STATS_PKTS_IN_ADD(p, 1);
446                         pkts_mask &= ~pkt_mask;
447                 }
448
449                 p->tx_buf_count = tx_buf_count;
450                 if (tx_buf_count >= p->tx_burst_sz)
451                         send_burst_nodrop(p);
452         }
453
454         return 0;
455 }
456
457 static int
458 rte_port_ethdev_writer_nodrop_flush(void *port)
459 {
460         struct rte_port_ethdev_writer_nodrop *p =
461                 port;
462
463         if (p->tx_buf_count > 0)
464                 send_burst_nodrop(p);
465
466         return 0;
467 }
468
469 static int
470 rte_port_ethdev_writer_nodrop_free(void *port)
471 {
472         if (port == NULL) {
473                 RTE_LOG(ERR, PORT, "%s: Port is NULL\n", __func__);
474                 return -EINVAL;
475         }
476
477         rte_port_ethdev_writer_nodrop_flush(port);
478         rte_free(port);
479
480         return 0;
481 }
482
483 static int rte_port_ethdev_writer_nodrop_stats_read(void *port,
484                 struct rte_port_out_stats *stats, int clear)
485 {
486         struct rte_port_ethdev_writer_nodrop *p =
487                 port;
488
489         if (stats != NULL)
490                 memcpy(stats, &p->stats, sizeof(p->stats));
491
492         if (clear)
493                 memset(&p->stats, 0, sizeof(p->stats));
494
495         return 0;
496 }
497
498 /*
499  * Summary of port operations
500  */
501 struct rte_port_in_ops rte_port_ethdev_reader_ops = {
502         .f_create = rte_port_ethdev_reader_create,
503         .f_free = rte_port_ethdev_reader_free,
504         .f_rx = rte_port_ethdev_reader_rx,
505         .f_stats = rte_port_ethdev_reader_stats_read,
506 };
507
508 struct rte_port_out_ops rte_port_ethdev_writer_ops = {
509         .f_create = rte_port_ethdev_writer_create,
510         .f_free = rte_port_ethdev_writer_free,
511         .f_tx = rte_port_ethdev_writer_tx,
512         .f_tx_bulk = rte_port_ethdev_writer_tx_bulk,
513         .f_flush = rte_port_ethdev_writer_flush,
514         .f_stats = rte_port_ethdev_writer_stats_read,
515 };
516
517 struct rte_port_out_ops rte_port_ethdev_writer_nodrop_ops = {
518         .f_create = rte_port_ethdev_writer_nodrop_create,
519         .f_free = rte_port_ethdev_writer_nodrop_free,
520         .f_tx = rte_port_ethdev_writer_nodrop_tx,
521         .f_tx_bulk = rte_port_ethdev_writer_nodrop_tx_bulk,
522         .f_flush = rte_port_ethdev_writer_nodrop_flush,
523         .f_stats = rte_port_ethdev_writer_nodrop_stats_read,
524 };