crypto/cnxk: use rlen from CPT result with lookaside
[dpdk.git] / lib / port / rte_swx_port_fd.c
1 /* SPDX-License-Identifier: BSD-3-Clause
2  * Copyright(c) 2021 Intel Corporation
3  */
4 #include <string.h>
5 #include <stdint.h>
6 #include <unistd.h>
7
8 #include <rte_mbuf.h>
9 #include <rte_malloc.h>
10 #include <rte_hexdump.h>
11
12 #include "rte_swx_port_fd.h"
13
14 #ifndef TRACE_LEVEL
15 #define TRACE_LEVEL 0
16 #endif
17
18 #if TRACE_LEVEL
19 #define TRACE(...) printf(__VA_ARGS__)
20 #else
21 #define TRACE(...)
22 #endif
23
24 /*
25  * FD Reader
26  */
27 struct reader {
28         struct {
29                 int fd;
30                 uint32_t mtu;
31                 uint32_t burst_size;
32                 struct rte_mempool *mempool;
33         } params;
34
35         struct rte_swx_port_in_stats stats;
36         struct rte_mbuf **pkts;
37         uint32_t n_pkts;
38         uint32_t pos;
39 };
40
41 static void *
42 reader_create(void *args)
43 {
44         struct rte_swx_port_fd_reader_params *conf = args;
45         struct reader *p;
46
47         /* Check input parameters. */
48         if (!conf || conf->fd < 0 || conf->mtu == 0 || !conf->mempool)
49                 return NULL;
50
51         /* Memory allocation. */
52         p = calloc(1, sizeof(struct reader));
53         if (!p)
54                 return NULL;
55
56         p->pkts = calloc(conf->burst_size, sizeof(struct rte_mbuf *));
57         if (!p->pkts) {
58                 free(p);
59                 return NULL;
60         }
61
62         /* Initialization. */
63         p->params.fd = conf->fd;
64         p->params.mtu = conf->mtu;
65         p->params.burst_size = conf->burst_size;
66         p->params.mempool = conf->mempool;
67
68         return p;
69 }
70
71 static void
72 reader_free(void *port)
73 {
74         struct reader *p = port;
75         uint32_t i;
76
77         if (!p)
78                 return;
79
80         for (i = 0; i < p->n_pkts; i++)
81                 rte_pktmbuf_free(p->pkts[i]);
82
83         free(p->pkts);
84         free(p);
85 }
86
87 static int
88 reader_pkt_rx(void *port, struct rte_swx_pkt *pkt)
89 {
90         struct reader *p = port;
91         struct rte_mbuf *m;
92         void *pkt_data;
93         ssize_t n_bytes;
94         uint32_t i, j;
95
96         if (p->n_pkts == p->pos) {
97                 if (rte_pktmbuf_alloc_bulk(p->params.mempool, p->pkts, p->params.burst_size) != 0)
98                         return 0;
99
100                 for (i = 0; i < p->params.burst_size; i++) {
101                         m = p->pkts[i];
102                         pkt_data = rte_pktmbuf_mtod(m, void *);
103                         n_bytes = read(p->params.fd, pkt_data, (size_t) p->params.mtu);
104
105                         if (n_bytes <= 0)
106                                 break;
107
108                         m->data_len = n_bytes;
109                         m->pkt_len = n_bytes;
110
111                         p->stats.n_pkts++;
112                         p->stats.n_bytes += n_bytes;
113                 }
114
115                 for (j = i; j < p->params.burst_size; j++)
116                         rte_pktmbuf_free(p->pkts[j]);
117
118                 p->n_pkts = i;
119                 p->pos = 0;
120
121                 if (!p->n_pkts)
122                         return 0;
123         }
124
125         m = p->pkts[p->pos++];
126         pkt->handle = m;
127         pkt->pkt = m->buf_addr;
128         pkt->offset = m->data_off;
129         pkt->length = m->pkt_len;
130
131         TRACE("[FD %u] Pkt %d (%u bytes at offset %u)\n",
132                 (uint32_t)p->params.fd,
133                 p->pos - 1,
134                 pkt->length,
135                 pkt->offset);
136
137         if (TRACE_LEVEL)
138                 rte_hexdump(stdout, NULL,
139                         &((uint8_t *)m->buf_addr)[m->data_off], m->data_len);
140
141         return 1;
142 }
143
144 static void
145 reader_stats_read(void *port, struct rte_swx_port_in_stats *stats)
146 {
147         struct reader *p = port;
148
149         memcpy(stats, &p->stats, sizeof(p->stats));
150 }
151
152 /*
153  * FD Writer
154  */
155 struct writer {
156         struct {
157                 int fd;
158                 uint32_t mtu;
159                 uint32_t burst_size;
160                 struct rte_mempool *mempool;
161         } params;
162
163         struct rte_swx_port_out_stats stats;
164         struct rte_mbuf **pkts;
165         uint32_t n_pkts;
166 };
167
168 static void *
169 writer_create(void *args)
170 {
171         struct rte_swx_port_fd_writer_params *conf = args;
172         struct writer *p;
173
174         /* Check input parameters. */
175         if (!conf)
176                 return NULL;
177
178         /* Memory allocation. */
179         p = calloc(1, sizeof(struct writer));
180         if (!p)
181                 return NULL;
182
183
184         p->pkts = calloc(conf->burst_size, sizeof(struct rte_mbuf *));
185         if (!p->pkts) {
186                 free(p);
187                 return NULL;
188         }
189
190         /* Initialization. */
191         p->params.fd = conf->fd;
192         p->params.burst_size = conf->burst_size;
193
194         return p;
195 }
196
197 static void
198 __writer_flush(struct writer *p)
199 {
200         struct rte_mbuf *pkt;
201         void *pkt_data;
202         size_t n_bytes;
203         ssize_t ret;
204         uint32_t i;
205
206         for (i = 0; i < p->n_pkts; i++) {
207                 pkt = p->pkts[i];
208                 pkt_data = rte_pktmbuf_mtod(pkt, void*);
209                 n_bytes = rte_pktmbuf_data_len(pkt);
210
211                 ret = write(p->params.fd, pkt_data, n_bytes);
212                 if (ret < 0)
213                         break;
214         }
215
216         TRACE("[FD %u] %u packets out\n",
217                 (uint32_t)p->params.fd,
218                 p->n_pkts);
219
220         for (i = 0; i < p->n_pkts; i++)
221                 rte_pktmbuf_free(p->pkts[i]);
222
223         p->n_pkts = 0;
224 }
225
226 static void
227 writer_pkt_tx(void *port, struct rte_swx_pkt *pkt)
228 {
229         struct writer *p = port;
230         struct rte_mbuf *m = pkt->handle;
231
232         TRACE("[FD %u] Pkt %u (%u bytes at offset %u)\n",
233                 (uint32_t)p->params.fd,
234                 p->n_pkts - 1,
235                 pkt->length,
236                 pkt->offset);
237
238         if (TRACE_LEVEL)
239                 rte_hexdump(stdout, NULL, &pkt->pkt[pkt->offset], pkt->length);
240
241         m->pkt_len = pkt->length;
242         m->data_len = (uint16_t)pkt->length;
243         m->data_off = (uint16_t)pkt->offset;
244
245         p->stats.n_pkts++;
246         p->stats.n_bytes += pkt->length;
247
248         p->pkts[p->n_pkts++] = m;
249         if (p->n_pkts == p->params.burst_size)
250                 __writer_flush(p);
251 }
252
253 static void
254 writer_flush(void *port)
255 {
256         struct writer *p = port;
257
258         if (p->n_pkts)
259                 __writer_flush(p);
260 }
261
262 static void
263 writer_free(void *port)
264 {
265         struct writer *p = port;
266
267         if (!p)
268                 return;
269
270         writer_flush(p);
271         free(p->pkts);
272         free(p);
273 }
274
275 static void
276 writer_stats_read(void *port, struct rte_swx_port_out_stats *stats)
277 {
278         struct writer *p = port;
279
280         memcpy(stats, &p->stats, sizeof(p->stats));
281 }
282
283 /*
284  * Summary of port operations
285  */
286 struct rte_swx_port_in_ops rte_swx_port_fd_reader_ops = {
287         .create = reader_create,
288         .free = reader_free,
289         .pkt_rx = reader_pkt_rx,
290         .stats_read = reader_stats_read,
291 };
292
293 struct rte_swx_port_out_ops rte_swx_port_fd_writer_ops = {
294         .create = writer_create,
295         .free = writer_free,
296         .pkt_tx = writer_pkt_tx,
297         .flush = writer_flush,
298         .stats_read = writer_stats_read,
299 };