net/i40e: fix Rx packet statistics
[dpdk.git] / drivers / net / sfc / sfc_repr_proxy.c
1 /* SPDX-License-Identifier: BSD-3-Clause
2  *
3  * Copyright(c) 2019-2021 Xilinx, Inc.
4  * Copyright(c) 2019 Solarflare Communications Inc.
5  *
6  * This software was jointly developed between OKTET Labs (under contract
7  * for Solarflare) and Solarflare Communications, Inc.
8  */
9
10 #include <rte_service.h>
11 #include <rte_service_component.h>
12
13 #include "sfc_log.h"
14 #include "sfc_service.h"
15 #include "sfc_repr_proxy.h"
16 #include "sfc_repr_proxy_api.h"
17 #include "sfc.h"
18 #include "sfc_ev.h"
19 #include "sfc_rx.h"
20 #include "sfc_tx.h"
21 #include "sfc_dp_rx.h"
22
23 /**
24  * Amount of time to wait for the representor proxy routine (which is
25  * running on a service core) to handle a request sent via mbox.
26  */
27 #define SFC_REPR_PROXY_MBOX_POLL_TIMEOUT_MS     1000
28
29 /**
30  * Amount of time to wait for the representor proxy routine (which is
31  * running on a service core) to terminate after service core is stopped.
32  */
33 #define SFC_REPR_PROXY_ROUTINE_TERMINATE_TIMEOUT_MS     10000
34
35 #define SFC_REPR_INVALID_ROUTE_PORT_ID  (UINT16_MAX)
36
37 static struct sfc_repr_proxy *
38 sfc_repr_proxy_by_adapter(struct sfc_adapter *sa)
39 {
40         return &sa->repr_proxy;
41 }
42
43 static struct sfc_adapter *
44 sfc_get_adapter_by_pf_port_id(uint16_t pf_port_id)
45 {
46         struct rte_eth_dev *dev;
47         struct sfc_adapter *sa;
48
49         SFC_ASSERT(pf_port_id < RTE_MAX_ETHPORTS);
50
51         dev = &rte_eth_devices[pf_port_id];
52         sa = sfc_adapter_by_eth_dev(dev);
53
54         sfc_adapter_lock(sa);
55
56         return sa;
57 }
58
59 static void
60 sfc_put_adapter(struct sfc_adapter *sa)
61 {
62         sfc_adapter_unlock(sa);
63 }
64
65 static struct sfc_repr_proxy_port *
66 sfc_repr_proxy_find_port(struct sfc_repr_proxy *rp, uint16_t repr_id)
67 {
68         struct sfc_repr_proxy_port *port;
69
70         TAILQ_FOREACH(port, &rp->ports, entries) {
71                 if (port->repr_id == repr_id)
72                         return port;
73         }
74
75         return NULL;
76 }
77
78 static int
79 sfc_repr_proxy_mbox_send(struct sfc_repr_proxy_mbox *mbox,
80                          struct sfc_repr_proxy_port *port,
81                          enum sfc_repr_proxy_mbox_op op)
82 {
83         const unsigned int wait_ms = SFC_REPR_PROXY_MBOX_POLL_TIMEOUT_MS;
84         unsigned int i;
85
86         mbox->op = op;
87         mbox->port = port;
88         mbox->ack = false;
89
90         /*
91          * Release ordering enforces marker set after data is populated.
92          * Paired with acquire ordering in sfc_repr_proxy_mbox_handle().
93          */
94         __atomic_store_n(&mbox->write_marker, true, __ATOMIC_RELEASE);
95
96         /*
97          * Wait for the representor routine to process the request.
98          * Give up on timeout.
99          */
100         for (i = 0; i < wait_ms; i++) {
101                 /*
102                  * Paired with release ordering in sfc_repr_proxy_mbox_handle()
103                  * on acknowledge write.
104                  */
105                 if (__atomic_load_n(&mbox->ack, __ATOMIC_ACQUIRE))
106                         break;
107
108                 rte_delay_ms(1);
109         }
110
111         if (i == wait_ms) {
112                 SFC_GENERIC_LOG(ERR,
113                         "%s() failed to wait for representor proxy routine ack",
114                         __func__);
115                 return ETIMEDOUT;
116         }
117
118         return 0;
119 }
120
121 static void
122 sfc_repr_proxy_mbox_handle(struct sfc_repr_proxy *rp)
123 {
124         struct sfc_repr_proxy_mbox *mbox = &rp->mbox;
125
126         /*
127          * Paired with release ordering in sfc_repr_proxy_mbox_send()
128          * on marker set.
129          */
130         if (!__atomic_load_n(&mbox->write_marker, __ATOMIC_ACQUIRE))
131                 return;
132
133         mbox->write_marker = false;
134
135         switch (mbox->op) {
136         case SFC_REPR_PROXY_MBOX_ADD_PORT:
137                 TAILQ_INSERT_TAIL(&rp->ports, mbox->port, entries);
138                 break;
139         case SFC_REPR_PROXY_MBOX_DEL_PORT:
140                 TAILQ_REMOVE(&rp->ports, mbox->port, entries);
141                 break;
142         case SFC_REPR_PROXY_MBOX_START_PORT:
143                 mbox->port->started = true;
144                 break;
145         case SFC_REPR_PROXY_MBOX_STOP_PORT:
146                 mbox->port->started = false;
147                 break;
148         default:
149                 SFC_ASSERT(0);
150                 return;
151         }
152
153         /*
154          * Paired with acquire ordering in sfc_repr_proxy_mbox_send()
155          * on acknowledge read.
156          */
157         __atomic_store_n(&mbox->ack, true, __ATOMIC_RELEASE);
158 }
159
160 static void
161 sfc_repr_proxy_handle_tx(struct sfc_repr_proxy_dp_txq *rp_txq,
162                          struct sfc_repr_proxy_txq *repr_txq)
163 {
164         /*
165          * With multiple representor proxy queues configured it is
166          * possible that not all of the corresponding representor
167          * queues were created. Skip the queues that do not exist.
168          */
169         if (repr_txq->ring == NULL)
170                 return;
171
172         if (rp_txq->available < RTE_DIM(rp_txq->tx_pkts)) {
173                 rp_txq->available +=
174                         rte_ring_sc_dequeue_burst(repr_txq->ring,
175                                 (void **)(&rp_txq->tx_pkts[rp_txq->available]),
176                                 RTE_DIM(rp_txq->tx_pkts) - rp_txq->available,
177                                 NULL);
178
179                 if (rp_txq->available == rp_txq->transmitted)
180                         return;
181         }
182
183         rp_txq->transmitted += rp_txq->pkt_burst(rp_txq->dp,
184                                 &rp_txq->tx_pkts[rp_txq->transmitted],
185                                 rp_txq->available - rp_txq->transmitted);
186
187         if (rp_txq->available == rp_txq->transmitted) {
188                 rp_txq->available = 0;
189                 rp_txq->transmitted = 0;
190         }
191 }
192
193 static struct sfc_repr_proxy_port *
194 sfc_repr_proxy_rx_route_mbuf(struct sfc_repr_proxy *rp, struct rte_mbuf *m)
195 {
196         struct sfc_repr_proxy_port *port;
197         efx_mport_id_t mport_id;
198
199         mport_id.id = *RTE_MBUF_DYNFIELD(m, sfc_dp_mport_offset,
200                                          typeof(&((efx_mport_id_t *)0)->id));
201
202         TAILQ_FOREACH(port, &rp->ports, entries) {
203                 if (port->egress_mport.id == mport_id.id) {
204                         m->port = port->rte_port_id;
205                         m->ol_flags &= ~sfc_dp_mport_override;
206                         return port;
207                 }
208         }
209
210         return NULL;
211 }
212
213 /*
214  * Returns true if a packet is encountered which should be forwarded to a
215  * port which is different from the one that is currently routed.
216  */
217 static bool
218 sfc_repr_proxy_rx_route(struct sfc_repr_proxy *rp,
219                         struct sfc_repr_proxy_dp_rxq *rp_rxq)
220 {
221         unsigned int i;
222
223         for (i = rp_rxq->routed;
224              i < rp_rxq->available && !rp_rxq->stop_route;
225              i++, rp_rxq->routed++) {
226                 struct sfc_repr_proxy_port *port;
227                 struct rte_mbuf *m = rp_rxq->pkts[i];
228
229                 port = sfc_repr_proxy_rx_route_mbuf(rp, m);
230                 /* Cannot find destination representor */
231                 if (port == NULL) {
232                         /* Effectively drop the packet */
233                         rp_rxq->forwarded++;
234                         continue;
235                 }
236
237                 /* Currently routed packets are mapped to a different port */
238                 if (port->repr_id != rp_rxq->route_port_id &&
239                     rp_rxq->route_port_id != SFC_REPR_INVALID_ROUTE_PORT_ID)
240                         return true;
241
242                 rp_rxq->route_port_id = port->repr_id;
243         }
244
245         return false;
246 }
247
248 static void
249 sfc_repr_proxy_rx_forward(struct sfc_repr_proxy *rp,
250                           struct sfc_repr_proxy_dp_rxq *rp_rxq)
251 {
252         struct sfc_repr_proxy_port *port;
253
254         if (rp_rxq->route_port_id != SFC_REPR_INVALID_ROUTE_PORT_ID) {
255                 port = sfc_repr_proxy_find_port(rp, rp_rxq->route_port_id);
256
257                 if (port != NULL && port->started) {
258                         rp_rxq->forwarded +=
259                             rte_ring_sp_enqueue_burst(port->rxq[0].ring,
260                                 (void **)(&rp_rxq->pkts[rp_rxq->forwarded]),
261                                 rp_rxq->routed - rp_rxq->forwarded, NULL);
262                 } else {
263                         /* Drop all routed packets if the port is not started */
264                         rp_rxq->forwarded = rp_rxq->routed;
265                 }
266         }
267
268         if (rp_rxq->forwarded == rp_rxq->routed) {
269                 rp_rxq->route_port_id = SFC_REPR_INVALID_ROUTE_PORT_ID;
270                 rp_rxq->stop_route = false;
271         } else {
272                 /* Stall packet routing if not all packets were forwarded */
273                 rp_rxq->stop_route = true;
274         }
275
276         if (rp_rxq->available == rp_rxq->forwarded)
277                 rp_rxq->available = rp_rxq->forwarded = rp_rxq->routed = 0;
278 }
279
280 static void
281 sfc_repr_proxy_handle_rx(struct sfc_repr_proxy *rp,
282                          struct sfc_repr_proxy_dp_rxq *rp_rxq)
283 {
284         bool route_again;
285
286         if (rp_rxq->available < RTE_DIM(rp_rxq->pkts)) {
287                 rp_rxq->available += rp_rxq->pkt_burst(rp_rxq->dp,
288                                 &rp_rxq->pkts[rp_rxq->available],
289                                 RTE_DIM(rp_rxq->pkts) - rp_rxq->available);
290                 if (rp_rxq->available == rp_rxq->forwarded)
291                         return;
292         }
293
294         do {
295                 route_again = sfc_repr_proxy_rx_route(rp, rp_rxq);
296                 sfc_repr_proxy_rx_forward(rp, rp_rxq);
297         } while (route_again && !rp_rxq->stop_route);
298 }
299
300 static int32_t
301 sfc_repr_proxy_routine(void *arg)
302 {
303         struct sfc_repr_proxy_port *port;
304         struct sfc_repr_proxy *rp = arg;
305         unsigned int i;
306
307         sfc_repr_proxy_mbox_handle(rp);
308
309         TAILQ_FOREACH(port, &rp->ports, entries) {
310                 if (!port->started)
311                         continue;
312
313                 for (i = 0; i < rp->nb_txq; i++)
314                         sfc_repr_proxy_handle_tx(&rp->dp_txq[i], &port->txq[i]);
315         }
316
317         for (i = 0; i < rp->nb_rxq; i++)
318                 sfc_repr_proxy_handle_rx(rp, &rp->dp_rxq[i]);
319
320         return 0;
321 }
322
323 static struct sfc_txq_info *
324 sfc_repr_proxy_txq_info_get(struct sfc_adapter *sa, unsigned int repr_queue_id)
325 {
326         struct sfc_adapter_shared *sas = sfc_sa2shared(sa);
327         struct sfc_repr_proxy_dp_txq *dp_txq;
328
329         SFC_ASSERT(repr_queue_id < sfc_repr_nb_txq(sas));
330         dp_txq = &sa->repr_proxy.dp_txq[repr_queue_id];
331
332         return &sas->txq_info[dp_txq->sw_index];
333 }
334
335 static int
336 sfc_repr_proxy_txq_attach(struct sfc_adapter *sa)
337 {
338         struct sfc_adapter_shared * const sas = sfc_sa2shared(sa);
339         struct sfc_repr_proxy *rp = &sa->repr_proxy;
340         unsigned int i;
341
342         sfc_log_init(sa, "entry");
343
344         for (i = 0; i < sfc_repr_nb_txq(sas); i++) {
345                 sfc_sw_index_t sw_index = sfc_repr_txq_sw_index(sas, i);
346
347                 rp->dp_txq[i].sw_index = sw_index;
348         }
349
350         sfc_log_init(sa, "done");
351
352         return 0;
353 }
354
355 static void
356 sfc_repr_proxy_txq_detach(struct sfc_adapter *sa)
357 {
358         struct sfc_adapter_shared * const sas = sfc_sa2shared(sa);
359         struct sfc_repr_proxy *rp = &sa->repr_proxy;
360         unsigned int i;
361
362         sfc_log_init(sa, "entry");
363
364         for (i = 0; i < sfc_repr_nb_txq(sas); i++)
365                 rp->dp_txq[i].sw_index = 0;
366
367         sfc_log_init(sa, "done");
368 }
369
370 int
371 sfc_repr_proxy_txq_init(struct sfc_adapter *sa)
372 {
373         struct sfc_adapter_shared * const sas = sfc_sa2shared(sa);
374         struct sfc_repr_proxy *rp = &sa->repr_proxy;
375         const struct rte_eth_txconf tx_conf = {
376                 .tx_free_thresh = SFC_REPR_PROXY_TXQ_FREE_THRESH,
377         };
378         struct sfc_txq_info *txq_info;
379         unsigned int init_i;
380         unsigned int i;
381         int rc;
382
383         sfc_log_init(sa, "entry");
384
385         if (!sfc_repr_available(sas)) {
386                 sfc_log_init(sa, "representors not supported - skip");
387                 return 0;
388         }
389
390         for (init_i = 0; init_i < sfc_repr_nb_txq(sas); init_i++) {
391                 struct sfc_repr_proxy_dp_txq *txq = &rp->dp_txq[init_i];
392
393                 txq_info = &sfc_sa2shared(sa)->txq_info[txq->sw_index];
394                 if (txq_info->state == SFC_TXQ_INITIALIZED) {
395                         sfc_log_init(sa,
396                                 "representor proxy TxQ %u is already initialized - skip",
397                                 init_i);
398                         continue;
399                 }
400
401                 sfc_tx_qinit_info(sa, txq->sw_index);
402
403                 rc = sfc_tx_qinit(sa, txq->sw_index,
404                                   SFC_REPR_PROXY_TX_DESC_COUNT, sa->socket_id,
405                                   &tx_conf);
406
407                 if (rc != 0) {
408                         sfc_err(sa, "failed to init representor proxy TxQ %u",
409                                 init_i);
410                         goto fail_init;
411                 }
412         }
413
414         sfc_log_init(sa, "done");
415
416         return 0;
417
418 fail_init:
419         for (i = 0; i < init_i; i++) {
420                 struct sfc_repr_proxy_dp_txq *txq = &rp->dp_txq[i];
421
422                 txq_info = &sfc_sa2shared(sa)->txq_info[txq->sw_index];
423                 if (txq_info->state == SFC_TXQ_INITIALIZED)
424                         sfc_tx_qfini(sa, txq->sw_index);
425         }
426         sfc_log_init(sa, "failed: %s", rte_strerror(rc));
427
428         return rc;
429 }
430
431 void
432 sfc_repr_proxy_txq_fini(struct sfc_adapter *sa)
433 {
434         struct sfc_adapter_shared * const sas = sfc_sa2shared(sa);
435         struct sfc_repr_proxy *rp = &sa->repr_proxy;
436         struct sfc_txq_info *txq_info;
437         unsigned int i;
438
439         sfc_log_init(sa, "entry");
440
441         if (!sfc_repr_available(sas)) {
442                 sfc_log_init(sa, "representors not supported - skip");
443                 return;
444         }
445
446         for (i = 0; i < sfc_repr_nb_txq(sas); i++) {
447                 struct sfc_repr_proxy_dp_txq *txq = &rp->dp_txq[i];
448
449                 txq_info = &sfc_sa2shared(sa)->txq_info[txq->sw_index];
450                 if (txq_info->state != SFC_TXQ_INITIALIZED) {
451                         sfc_log_init(sa,
452                                 "representor proxy TxQ %u is already finalized - skip",
453                                 i);
454                         continue;
455                 }
456
457                 sfc_tx_qfini(sa, txq->sw_index);
458         }
459
460         sfc_log_init(sa, "done");
461 }
462
463 static int
464 sfc_repr_proxy_txq_start(struct sfc_adapter *sa)
465 {
466         struct sfc_adapter_shared * const sas = sfc_sa2shared(sa);
467         struct sfc_repr_proxy *rp = &sa->repr_proxy;
468         unsigned int i;
469
470         sfc_log_init(sa, "entry");
471
472         for (i = 0; i < sfc_repr_nb_txq(sas); i++) {
473                 struct sfc_repr_proxy_dp_txq *txq = &rp->dp_txq[i];
474
475                 txq->dp = sfc_repr_proxy_txq_info_get(sa, i)->dp;
476                 txq->pkt_burst = sa->eth_dev->tx_pkt_burst;
477                 txq->available = 0;
478                 txq->transmitted = 0;
479         }
480
481         sfc_log_init(sa, "done");
482
483         return 0;
484 }
485
486 static void
487 sfc_repr_proxy_txq_stop(struct sfc_adapter *sa)
488 {
489         sfc_log_init(sa, "entry");
490         sfc_log_init(sa, "done");
491 }
492
493 static int
494 sfc_repr_proxy_rxq_attach(struct sfc_adapter *sa)
495 {
496         struct sfc_adapter_shared * const sas = sfc_sa2shared(sa);
497         struct sfc_repr_proxy *rp = &sa->repr_proxy;
498         unsigned int i;
499
500         sfc_log_init(sa, "entry");
501
502         for (i = 0; i < sfc_repr_nb_rxq(sas); i++) {
503                 sfc_sw_index_t sw_index = sfc_repr_rxq_sw_index(sas, i);
504
505                 rp->dp_rxq[i].sw_index = sw_index;
506         }
507
508         sfc_log_init(sa, "done");
509
510         return 0;
511 }
512
513 static void
514 sfc_repr_proxy_rxq_detach(struct sfc_adapter *sa)
515 {
516         struct sfc_adapter_shared * const sas = sfc_sa2shared(sa);
517         struct sfc_repr_proxy *rp = &sa->repr_proxy;
518         unsigned int i;
519
520         sfc_log_init(sa, "entry");
521
522         for (i = 0; i < sfc_repr_nb_rxq(sas); i++)
523                 rp->dp_rxq[i].sw_index = 0;
524
525         sfc_log_init(sa, "done");
526 }
527
528 static struct sfc_rxq_info *
529 sfc_repr_proxy_rxq_info_get(struct sfc_adapter *sa, unsigned int repr_queue_id)
530 {
531         struct sfc_adapter_shared *sas = sfc_sa2shared(sa);
532         struct sfc_repr_proxy_dp_rxq *dp_rxq;
533
534         SFC_ASSERT(repr_queue_id < sfc_repr_nb_rxq(sas));
535         dp_rxq = &sa->repr_proxy.dp_rxq[repr_queue_id];
536
537         return &sas->rxq_info[dp_rxq->sw_index];
538 }
539
540 static int
541 sfc_repr_proxy_rxq_init(struct sfc_adapter *sa,
542                         struct sfc_repr_proxy_dp_rxq *rxq)
543 {
544         struct sfc_adapter_shared * const sas = sfc_sa2shared(sa);
545         uint16_t nb_rx_desc = SFC_REPR_PROXY_RX_DESC_COUNT;
546         struct sfc_rxq_info *rxq_info;
547         struct rte_eth_rxconf rxconf = {
548                 .rx_free_thresh = SFC_REPR_PROXY_RXQ_REFILL_LEVEL,
549                 .rx_drop_en = 1,
550         };
551         int rc;
552
553         sfc_log_init(sa, "entry");
554
555         rxq_info = &sas->rxq_info[rxq->sw_index];
556         if (rxq_info->state & SFC_RXQ_INITIALIZED) {
557                 sfc_log_init(sa, "RxQ is already initialized - skip");
558                 return 0;
559         }
560
561         nb_rx_desc = RTE_MIN(nb_rx_desc, sa->rxq_max_entries);
562         nb_rx_desc = RTE_MAX(nb_rx_desc, sa->rxq_min_entries);
563
564         rc = sfc_rx_qinit_info(sa, rxq->sw_index, EFX_RXQ_FLAG_INGRESS_MPORT);
565         if (rc != 0) {
566                 sfc_err(sa, "failed to init representor proxy RxQ info");
567                 goto fail_repr_rxq_init_info;
568         }
569
570         rc = sfc_rx_qinit(sa, rxq->sw_index, nb_rx_desc, sa->socket_id, &rxconf,
571                           rxq->mp);
572         if (rc != 0) {
573                 sfc_err(sa, "failed to init representor proxy RxQ");
574                 goto fail_repr_rxq_init;
575         }
576
577         sfc_log_init(sa, "done");
578
579         return 0;
580
581 fail_repr_rxq_init:
582 fail_repr_rxq_init_info:
583         sfc_log_init(sa, "failed: %s", rte_strerror(rc));
584
585         return rc;
586 }
587
588 static void
589 sfc_repr_proxy_rxq_fini(struct sfc_adapter *sa)
590 {
591         struct sfc_adapter_shared * const sas = sfc_sa2shared(sa);
592         struct sfc_repr_proxy *rp = &sa->repr_proxy;
593         struct sfc_rxq_info *rxq_info;
594         unsigned int i;
595
596         sfc_log_init(sa, "entry");
597
598         if (!sfc_repr_available(sas)) {
599                 sfc_log_init(sa, "representors not supported - skip");
600                 return;
601         }
602
603         for (i = 0; i < sfc_repr_nb_rxq(sas); i++) {
604                 struct sfc_repr_proxy_dp_rxq *rxq = &rp->dp_rxq[i];
605
606                 rxq_info = &sas->rxq_info[rxq->sw_index];
607                 if (rxq_info->state != SFC_RXQ_INITIALIZED) {
608                         sfc_log_init(sa,
609                                 "representor RxQ %u is already finalized - skip",
610                                 i);
611                         continue;
612                 }
613
614                 sfc_rx_qfini(sa, rxq->sw_index);
615         }
616
617         sfc_log_init(sa, "done");
618 }
619
620 static void
621 sfc_repr_proxy_rxq_stop(struct sfc_adapter *sa)
622 {
623         struct sfc_adapter_shared * const sas = sfc_sa2shared(sa);
624         unsigned int i;
625
626         sfc_log_init(sa, "entry");
627
628         for (i = 0; i < sfc_repr_nb_rxq(sas); i++)
629                 sfc_rx_qstop(sa, sa->repr_proxy.dp_rxq[i].sw_index);
630
631         sfc_repr_proxy_rxq_fini(sa);
632
633         sfc_log_init(sa, "done");
634 }
635
636 static int
637 sfc_repr_proxy_rxq_start(struct sfc_adapter *sa)
638 {
639         struct sfc_adapter_shared * const sas = sfc_sa2shared(sa);
640         struct sfc_repr_proxy *rp = &sa->repr_proxy;
641         unsigned int i;
642         int rc;
643
644         sfc_log_init(sa, "entry");
645
646         if (!sfc_repr_available(sas)) {
647                 sfc_log_init(sa, "representors not supported - skip");
648                 return 0;
649         }
650
651         for (i = 0; i < sfc_repr_nb_rxq(sas); i++) {
652                 struct sfc_repr_proxy_dp_rxq *rxq = &rp->dp_rxq[i];
653
654                 rc = sfc_repr_proxy_rxq_init(sa, rxq);
655                 if (rc != 0) {
656                         sfc_err(sa, "failed to init representor proxy RxQ %u",
657                                 i);
658                         goto fail_init;
659                 }
660
661                 rc = sfc_rx_qstart(sa, rxq->sw_index);
662                 if (rc != 0) {
663                         sfc_err(sa, "failed to start representor proxy RxQ %u",
664                                 i);
665                         goto fail_start;
666                 }
667
668                 rxq->dp = sfc_repr_proxy_rxq_info_get(sa, i)->dp;
669                 rxq->pkt_burst = sa->eth_dev->rx_pkt_burst;
670                 rxq->available = 0;
671                 rxq->routed = 0;
672                 rxq->forwarded = 0;
673                 rxq->stop_route = false;
674                 rxq->route_port_id = SFC_REPR_INVALID_ROUTE_PORT_ID;
675         }
676
677         sfc_log_init(sa, "done");
678
679         return 0;
680
681 fail_start:
682 fail_init:
683         sfc_repr_proxy_rxq_stop(sa);
684         sfc_log_init(sa, "failed: %s", rte_strerror(rc));
685         return rc;
686 }
687
688 static int
689 sfc_repr_proxy_mae_rule_insert(struct sfc_adapter *sa,
690                                struct sfc_repr_proxy_port *port)
691 {
692         struct sfc_repr_proxy *rp = &sa->repr_proxy;
693         efx_mport_sel_t mport_alias_selector;
694         efx_mport_sel_t mport_vf_selector;
695         struct sfc_mae_rule *mae_rule;
696         int rc;
697
698         sfc_log_init(sa, "entry");
699
700         rc = efx_mae_mport_by_id(&port->egress_mport,
701                                  &mport_vf_selector);
702         if (rc != 0) {
703                 sfc_err(sa, "failed to get VF mport for repr %u",
704                         port->repr_id);
705                 goto fail_get_vf;
706         }
707
708         rc = efx_mae_mport_by_id(&rp->mport_alias, &mport_alias_selector);
709         if (rc != 0) {
710                 sfc_err(sa, "failed to get mport selector for repr %u",
711                         port->repr_id);
712                 goto fail_get_alias;
713         }
714
715         rc = sfc_mae_rule_add_mport_match_deliver(sa, &mport_vf_selector,
716                                                   &mport_alias_selector, -1,
717                                                   &mae_rule);
718         if (rc != 0) {
719                 sfc_err(sa, "failed to insert MAE rule for repr %u",
720                         port->repr_id);
721                 goto fail_rule_add;
722         }
723
724         port->mae_rule = mae_rule;
725
726         sfc_log_init(sa, "done");
727
728         return 0;
729
730 fail_rule_add:
731 fail_get_alias:
732 fail_get_vf:
733         sfc_log_init(sa, "failed: %s", rte_strerror(rc));
734         return rc;
735 }
736
737 static void
738 sfc_repr_proxy_mae_rule_remove(struct sfc_adapter *sa,
739                                struct sfc_repr_proxy_port *port)
740 {
741         struct sfc_mae_rule *mae_rule = port->mae_rule;
742
743         sfc_mae_rule_del(sa, mae_rule);
744 }
745
746 static int
747 sfc_repr_proxy_mport_filter_insert(struct sfc_adapter *sa)
748 {
749         struct sfc_adapter_shared * const sas = sfc_sa2shared(sa);
750         struct sfc_repr_proxy *rp = &sa->repr_proxy;
751         struct sfc_rxq *rxq_ctrl;
752         struct sfc_repr_proxy_filter *filter = &rp->mport_filter;
753         efx_mport_sel_t mport_alias_selector;
754         static const efx_filter_match_flags_t flags[RTE_DIM(filter->specs)] = {
755                 EFX_FILTER_MATCH_UNKNOWN_UCAST_DST,
756                 EFX_FILTER_MATCH_UNKNOWN_MCAST_DST };
757         unsigned int i;
758         int rc;
759
760         sfc_log_init(sa, "entry");
761
762         if (sfc_repr_nb_rxq(sas) == 1) {
763                 rxq_ctrl = &sa->rxq_ctrl[rp->dp_rxq[0].sw_index];
764         } else {
765                 sfc_err(sa, "multiple representor proxy RxQs not supported");
766                 rc = ENOTSUP;
767                 goto fail_multiple_queues;
768         }
769
770         rc = efx_mae_mport_by_id(&rp->mport_alias, &mport_alias_selector);
771         if (rc != 0) {
772                 sfc_err(sa, "failed to get repr proxy mport by ID");
773                 goto fail_get_selector;
774         }
775
776         memset(filter->specs, 0, sizeof(filter->specs));
777         for (i = 0; i < RTE_DIM(filter->specs); i++) {
778                 filter->specs[i].efs_priority = EFX_FILTER_PRI_MANUAL;
779                 filter->specs[i].efs_flags = EFX_FILTER_FLAG_RX;
780                 filter->specs[i].efs_dmaq_id = rxq_ctrl->hw_index;
781                 filter->specs[i].efs_match_flags = flags[i] |
782                                 EFX_FILTER_MATCH_MPORT;
783                 filter->specs[i].efs_ingress_mport = mport_alias_selector.sel;
784
785                 rc = efx_filter_insert(sa->nic, &filter->specs[i]);
786                 if (rc != 0) {
787                         sfc_err(sa, "failed to insert repr proxy filter");
788                         goto fail_insert;
789                 }
790         }
791
792         sfc_log_init(sa, "done");
793
794         return 0;
795
796 fail_insert:
797         while (i-- > 0)
798                 efx_filter_remove(sa->nic, &filter->specs[i]);
799
800 fail_get_selector:
801 fail_multiple_queues:
802         sfc_log_init(sa, "failed: %s", rte_strerror(rc));
803         return rc;
804 }
805
806 static void
807 sfc_repr_proxy_mport_filter_remove(struct sfc_adapter *sa)
808 {
809         struct sfc_repr_proxy *rp = &sa->repr_proxy;
810         struct sfc_repr_proxy_filter *filter = &rp->mport_filter;
811         unsigned int i;
812
813         for (i = 0; i < RTE_DIM(filter->specs); i++)
814                 efx_filter_remove(sa->nic, &filter->specs[i]);
815 }
816
817 static int
818 sfc_repr_proxy_port_rule_insert(struct sfc_adapter *sa,
819                                 struct sfc_repr_proxy_port *port)
820 {
821         int rc;
822
823         rc = sfc_repr_proxy_mae_rule_insert(sa, port);
824         if (rc != 0)
825                 goto fail_mae_rule_insert;
826
827         return 0;
828
829 fail_mae_rule_insert:
830         return rc;
831 }
832
833 static void
834 sfc_repr_proxy_port_rule_remove(struct sfc_adapter *sa,
835                                 struct sfc_repr_proxy_port *port)
836 {
837         sfc_repr_proxy_mae_rule_remove(sa, port);
838 }
839
840 static int
841 sfc_repr_proxy_ports_init(struct sfc_adapter *sa)
842 {
843         struct sfc_repr_proxy *rp = &sa->repr_proxy;
844         int rc;
845
846         sfc_log_init(sa, "entry");
847
848         rc = efx_mcdi_mport_alloc_alias(sa->nic, &rp->mport_alias, NULL);
849         if (rc != 0) {
850                 sfc_err(sa, "failed to alloc mport alias: %s",
851                         rte_strerror(rc));
852                 goto fail_alloc_mport_alias;
853         }
854
855         TAILQ_INIT(&rp->ports);
856
857         sfc_log_init(sa, "done");
858
859         return 0;
860
861 fail_alloc_mport_alias:
862
863         sfc_log_init(sa, "failed: %s", rte_strerror(rc));
864         return rc;
865 }
866
867 void
868 sfc_repr_proxy_pre_detach(struct sfc_adapter *sa)
869 {
870         struct sfc_repr_proxy *rp = &sa->repr_proxy;
871         bool close_ports[RTE_MAX_ETHPORTS] = {0};
872         struct sfc_repr_proxy_port *port;
873         unsigned int i;
874
875         SFC_ASSERT(!sfc_adapter_is_locked(sa));
876
877         sfc_adapter_lock(sa);
878
879         if (sfc_repr_available(sfc_sa2shared(sa))) {
880                 TAILQ_FOREACH(port, &rp->ports, entries)
881                         close_ports[port->rte_port_id] = true;
882         } else {
883                 sfc_log_init(sa, "representors not supported - skip");
884         }
885
886         sfc_adapter_unlock(sa);
887
888         for (i = 0; i < RTE_DIM(close_ports); i++) {
889                 if (close_ports[i]) {
890                         rte_eth_dev_stop(i);
891                         rte_eth_dev_close(i);
892                 }
893         }
894 }
895
896 static void
897 sfc_repr_proxy_ports_fini(struct sfc_adapter *sa)
898 {
899         struct sfc_repr_proxy *rp = &sa->repr_proxy;
900
901         efx_mae_mport_free(sa->nic, &rp->mport_alias);
902 }
903
904 int
905 sfc_repr_proxy_attach(struct sfc_adapter *sa)
906 {
907         struct sfc_adapter_shared * const sas = sfc_sa2shared(sa);
908         struct sfc_repr_proxy *rp = &sa->repr_proxy;
909         struct rte_service_spec service;
910         uint32_t cid;
911         uint32_t sid;
912         int rc;
913
914         sfc_log_init(sa, "entry");
915
916         if (!sfc_repr_available(sas)) {
917                 sfc_log_init(sa, "representors not supported - skip");
918                 return 0;
919         }
920
921         rc = sfc_repr_proxy_rxq_attach(sa);
922         if (rc != 0)
923                 goto fail_rxq_attach;
924
925         rc = sfc_repr_proxy_txq_attach(sa);
926         if (rc != 0)
927                 goto fail_txq_attach;
928
929         rc = sfc_repr_proxy_ports_init(sa);
930         if (rc != 0)
931                 goto fail_ports_init;
932
933         cid = sfc_get_service_lcore(sa->socket_id);
934         if (cid == RTE_MAX_LCORE && sa->socket_id != SOCKET_ID_ANY) {
935                 /* Warn and try to allocate on any NUMA node */
936                 sfc_warn(sa,
937                         "repr proxy: unable to get service lcore at socket %d",
938                         sa->socket_id);
939
940                 cid = sfc_get_service_lcore(SOCKET_ID_ANY);
941         }
942         if (cid == RTE_MAX_LCORE) {
943                 rc = ENOTSUP;
944                 sfc_err(sa, "repr proxy: failed to get service lcore");
945                 goto fail_get_service_lcore;
946         }
947
948         memset(&service, 0, sizeof(service));
949         snprintf(service.name, sizeof(service.name),
950                  "net_sfc_%hu_repr_proxy", sfc_sa2shared(sa)->port_id);
951         service.socket_id = rte_lcore_to_socket_id(cid);
952         service.callback = sfc_repr_proxy_routine;
953         service.callback_userdata = rp;
954
955         rc = rte_service_component_register(&service, &sid);
956         if (rc != 0) {
957                 rc = ENOEXEC;
958                 sfc_err(sa, "repr proxy: failed to register service component");
959                 goto fail_register;
960         }
961
962         rc = rte_service_map_lcore_set(sid, cid, 1);
963         if (rc != 0) {
964                 rc = -rc;
965                 sfc_err(sa, "repr proxy: failed to map lcore");
966                 goto fail_map_lcore;
967         }
968
969         rp->service_core_id = cid;
970         rp->service_id = sid;
971
972         sfc_log_init(sa, "done");
973
974         return 0;
975
976 fail_map_lcore:
977         rte_service_component_unregister(sid);
978
979 fail_register:
980         /*
981          * No need to rollback service lcore get since
982          * it just makes socket_id based search and remembers it.
983          */
984
985 fail_get_service_lcore:
986         sfc_repr_proxy_ports_fini(sa);
987
988 fail_ports_init:
989         sfc_repr_proxy_txq_detach(sa);
990
991 fail_txq_attach:
992         sfc_repr_proxy_rxq_detach(sa);
993
994 fail_rxq_attach:
995         sfc_log_init(sa, "failed: %s", rte_strerror(rc));
996         return rc;
997 }
998
999 void
1000 sfc_repr_proxy_detach(struct sfc_adapter *sa)
1001 {
1002         struct sfc_adapter_shared * const sas = sfc_sa2shared(sa);
1003         struct sfc_repr_proxy *rp = &sa->repr_proxy;
1004
1005         sfc_log_init(sa, "entry");
1006
1007         if (!sfc_repr_available(sas)) {
1008                 sfc_log_init(sa, "representors not supported - skip");
1009                 return;
1010         }
1011
1012         rte_service_map_lcore_set(rp->service_id, rp->service_core_id, 0);
1013         rte_service_component_unregister(rp->service_id);
1014         sfc_repr_proxy_ports_fini(sa);
1015         sfc_repr_proxy_rxq_detach(sa);
1016         sfc_repr_proxy_txq_detach(sa);
1017
1018         sfc_log_init(sa, "done");
1019 }
1020
1021 static int
1022 sfc_repr_proxy_do_start_port(struct sfc_adapter *sa,
1023                            struct sfc_repr_proxy_port *port)
1024 {
1025         struct sfc_repr_proxy *rp = &sa->repr_proxy;
1026         int rc;
1027
1028         rc = sfc_repr_proxy_port_rule_insert(sa, port);
1029         if (rc != 0)
1030                 goto fail_filter_insert;
1031
1032         if (rp->started) {
1033                 rc = sfc_repr_proxy_mbox_send(&rp->mbox, port,
1034                                               SFC_REPR_PROXY_MBOX_START_PORT);
1035                 if (rc != 0) {
1036                         sfc_err(sa, "failed to start proxy port %u",
1037                                 port->repr_id);
1038                         goto fail_port_start;
1039                 }
1040         } else {
1041                 port->started = true;
1042         }
1043
1044         return 0;
1045
1046 fail_port_start:
1047         sfc_repr_proxy_port_rule_remove(sa, port);
1048 fail_filter_insert:
1049         sfc_err(sa, "%s() failed %s", __func__, rte_strerror(rc));
1050
1051         return rc;
1052 }
1053
1054 static int
1055 sfc_repr_proxy_do_stop_port(struct sfc_adapter *sa,
1056                           struct sfc_repr_proxy_port *port)
1057
1058 {
1059         struct sfc_repr_proxy *rp = &sa->repr_proxy;
1060         int rc;
1061
1062         if (rp->started) {
1063                 rc = sfc_repr_proxy_mbox_send(&rp->mbox, port,
1064                                               SFC_REPR_PROXY_MBOX_STOP_PORT);
1065                 if (rc != 0) {
1066                         sfc_err(sa, "failed to stop proxy port %u: %s",
1067                                 port->repr_id, rte_strerror(rc));
1068                         return rc;
1069                 }
1070         } else {
1071                 port->started = false;
1072         }
1073
1074         sfc_repr_proxy_port_rule_remove(sa, port);
1075
1076         return 0;
1077 }
1078
1079 static bool
1080 sfc_repr_proxy_port_enabled(struct sfc_repr_proxy_port *port)
1081 {
1082         return port->rte_port_id != RTE_MAX_ETHPORTS && port->enabled;
1083 }
1084
1085 static bool
1086 sfc_repr_proxy_ports_disabled(struct sfc_repr_proxy *rp)
1087 {
1088         struct sfc_repr_proxy_port *port;
1089
1090         TAILQ_FOREACH(port, &rp->ports, entries) {
1091                 if (sfc_repr_proxy_port_enabled(port))
1092                         return false;
1093         }
1094
1095         return true;
1096 }
1097
1098 int
1099 sfc_repr_proxy_start(struct sfc_adapter *sa)
1100 {
1101         struct sfc_adapter_shared * const sas = sfc_sa2shared(sa);
1102         struct sfc_repr_proxy *rp = &sa->repr_proxy;
1103         struct sfc_repr_proxy_port *last_port = NULL;
1104         struct sfc_repr_proxy_port *port;
1105         int rc;
1106
1107         sfc_log_init(sa, "entry");
1108
1109         /* Representor proxy is not started when no representors are started */
1110         if (!sfc_repr_available(sas)) {
1111                 sfc_log_init(sa, "representors not supported - skip");
1112                 return 0;
1113         }
1114
1115         if (sfc_repr_proxy_ports_disabled(rp)) {
1116                 sfc_log_init(sa, "no started representor ports - skip");
1117                 return 0;
1118         }
1119
1120         rc = sfc_repr_proxy_rxq_start(sa);
1121         if (rc != 0)
1122                 goto fail_rxq_start;
1123
1124         rc = sfc_repr_proxy_txq_start(sa);
1125         if (rc != 0)
1126                 goto fail_txq_start;
1127
1128         rp->nb_txq = sfc_repr_nb_txq(sas);
1129         rp->nb_rxq = sfc_repr_nb_rxq(sas);
1130
1131         /* Service core may be in "stopped" state, start it */
1132         rc = rte_service_lcore_start(rp->service_core_id);
1133         if (rc != 0 && rc != -EALREADY) {
1134                 rc = -rc;
1135                 sfc_err(sa, "failed to start service core for %s: %s",
1136                         rte_service_get_name(rp->service_id),
1137                         rte_strerror(rc));
1138                 goto fail_start_core;
1139         }
1140
1141         /* Run the service */
1142         rc = rte_service_component_runstate_set(rp->service_id, 1);
1143         if (rc < 0) {
1144                 rc = -rc;
1145                 sfc_err(sa, "failed to run %s component: %s",
1146                         rte_service_get_name(rp->service_id),
1147                         rte_strerror(rc));
1148                 goto fail_component_runstate_set;
1149         }
1150         rc = rte_service_runstate_set(rp->service_id, 1);
1151         if (rc < 0) {
1152                 rc = -rc;
1153                 sfc_err(sa, "failed to run %s: %s",
1154                         rte_service_get_name(rp->service_id),
1155                         rte_strerror(rc));
1156                 goto fail_runstate_set;
1157         }
1158
1159         TAILQ_FOREACH(port, &rp->ports, entries) {
1160                 if (sfc_repr_proxy_port_enabled(port)) {
1161                         rc = sfc_repr_proxy_do_start_port(sa, port);
1162                         if (rc != 0)
1163                                 goto fail_start_id;
1164
1165                         last_port = port;
1166                 }
1167         }
1168
1169         rc = sfc_repr_proxy_mport_filter_insert(sa);
1170         if (rc != 0)
1171                 goto fail_mport_filter_insert;
1172
1173         rp->started = true;
1174
1175         sfc_log_init(sa, "done");
1176
1177         return 0;
1178
1179 fail_mport_filter_insert:
1180 fail_start_id:
1181         if (last_port != NULL) {
1182                 TAILQ_FOREACH(port, &rp->ports, entries) {
1183                         if (sfc_repr_proxy_port_enabled(port)) {
1184                                 (void)sfc_repr_proxy_do_stop_port(sa, port);
1185                                 if (port == last_port)
1186                                         break;
1187                         }
1188                 }
1189         }
1190
1191         rte_service_runstate_set(rp->service_id, 0);
1192
1193 fail_runstate_set:
1194         rte_service_component_runstate_set(rp->service_id, 0);
1195
1196 fail_component_runstate_set:
1197         /* Service lcore may be shared and we never stop it */
1198
1199 fail_start_core:
1200         sfc_repr_proxy_txq_stop(sa);
1201
1202 fail_txq_start:
1203         sfc_repr_proxy_rxq_stop(sa);
1204
1205 fail_rxq_start:
1206         sfc_log_init(sa, "failed: %s", rte_strerror(rc));
1207         return rc;
1208 }
1209
1210 void
1211 sfc_repr_proxy_stop(struct sfc_adapter *sa)
1212 {
1213         struct sfc_adapter_shared * const sas = sfc_sa2shared(sa);
1214         struct sfc_repr_proxy *rp = &sa->repr_proxy;
1215         struct sfc_repr_proxy_port *port;
1216         const unsigned int wait_ms_total =
1217                 SFC_REPR_PROXY_ROUTINE_TERMINATE_TIMEOUT_MS;
1218         unsigned int i;
1219         int rc;
1220
1221         sfc_log_init(sa, "entry");
1222
1223         if (!sfc_repr_available(sas)) {
1224                 sfc_log_init(sa, "representors not supported - skip");
1225                 return;
1226         }
1227
1228         if (sfc_repr_proxy_ports_disabled(rp)) {
1229                 sfc_log_init(sa, "no started representor ports - skip");
1230                 return;
1231         }
1232
1233         TAILQ_FOREACH(port, &rp->ports, entries) {
1234                 if (sfc_repr_proxy_port_enabled(port)) {
1235                         rc = sfc_repr_proxy_do_stop_port(sa, port);
1236                         if (rc != 0) {
1237                                 sfc_err(sa,
1238                                         "failed to stop representor proxy port %u: %s",
1239                                         port->repr_id, rte_strerror(rc));
1240                         }
1241                 }
1242         }
1243
1244         sfc_repr_proxy_mport_filter_remove(sa);
1245
1246         rc = rte_service_runstate_set(rp->service_id, 0);
1247         if (rc < 0) {
1248                 sfc_err(sa, "failed to stop %s: %s",
1249                         rte_service_get_name(rp->service_id),
1250                         rte_strerror(-rc));
1251         }
1252
1253         rc = rte_service_component_runstate_set(rp->service_id, 0);
1254         if (rc < 0) {
1255                 sfc_err(sa, "failed to stop %s component: %s",
1256                         rte_service_get_name(rp->service_id),
1257                         rte_strerror(-rc));
1258         }
1259
1260         /* Service lcore may be shared and we never stop it */
1261
1262         /*
1263          * Wait for the representor proxy routine to finish the last iteration.
1264          * Give up on timeout.
1265          */
1266         for (i = 0; i < wait_ms_total; i++) {
1267                 if (rte_service_may_be_active(rp->service_id) == 0)
1268                         break;
1269
1270                 rte_delay_ms(1);
1271         }
1272
1273         sfc_repr_proxy_rxq_stop(sa);
1274         sfc_repr_proxy_txq_stop(sa);
1275
1276         rp->started = false;
1277
1278         sfc_log_init(sa, "done");
1279 }
1280
1281 int
1282 sfc_repr_proxy_add_port(uint16_t pf_port_id, uint16_t repr_id,
1283                         uint16_t rte_port_id, const efx_mport_sel_t *mport_sel)
1284 {
1285         struct sfc_repr_proxy_port *port;
1286         struct sfc_repr_proxy *rp;
1287         struct sfc_adapter *sa;
1288         int rc;
1289
1290         sa = sfc_get_adapter_by_pf_port_id(pf_port_id);
1291         rp = sfc_repr_proxy_by_adapter(sa);
1292
1293         sfc_log_init(sa, "entry");
1294         TAILQ_FOREACH(port, &rp->ports, entries) {
1295                 if (port->rte_port_id == rte_port_id) {
1296                         rc = EEXIST;
1297                         sfc_err(sa, "%s() failed: port exists", __func__);
1298                         goto fail_port_exists;
1299                 }
1300         }
1301
1302         port = rte_zmalloc("sfc-repr-proxy-port", sizeof(*port),
1303                            sa->socket_id);
1304         if (port == NULL) {
1305                 rc = ENOMEM;
1306                 sfc_err(sa, "failed to alloc memory for proxy port");
1307                 goto fail_alloc_port;
1308         }
1309
1310         rc = efx_mae_mport_id_by_selector(sa->nic, mport_sel,
1311                                           &port->egress_mport);
1312         if (rc != 0) {
1313                 sfc_err(sa,
1314                         "failed get MAE mport id by selector (repr_id %u): %s",
1315                         repr_id, rte_strerror(rc));
1316                 goto fail_mport_id;
1317         }
1318
1319         port->rte_port_id = rte_port_id;
1320         port->repr_id = repr_id;
1321
1322         if (rp->started) {
1323                 rc = sfc_repr_proxy_mbox_send(&rp->mbox, port,
1324                                               SFC_REPR_PROXY_MBOX_ADD_PORT);
1325                 if (rc != 0) {
1326                         sfc_err(sa, "failed to add proxy port %u",
1327                                 port->repr_id);
1328                         goto fail_port_add;
1329                 }
1330         } else {
1331                 TAILQ_INSERT_TAIL(&rp->ports, port, entries);
1332         }
1333
1334         sfc_log_init(sa, "done");
1335         sfc_put_adapter(sa);
1336
1337         return 0;
1338
1339 fail_port_add:
1340 fail_mport_id:
1341         rte_free(port);
1342 fail_alloc_port:
1343 fail_port_exists:
1344         sfc_log_init(sa, "failed: %s", rte_strerror(rc));
1345         sfc_put_adapter(sa);
1346
1347         return rc;
1348 }
1349
1350 int
1351 sfc_repr_proxy_del_port(uint16_t pf_port_id, uint16_t repr_id)
1352 {
1353         struct sfc_repr_proxy_port *port;
1354         struct sfc_repr_proxy *rp;
1355         struct sfc_adapter *sa;
1356         int rc;
1357
1358         sa = sfc_get_adapter_by_pf_port_id(pf_port_id);
1359         rp = sfc_repr_proxy_by_adapter(sa);
1360
1361         sfc_log_init(sa, "entry");
1362
1363         port = sfc_repr_proxy_find_port(rp, repr_id);
1364         if (port == NULL) {
1365                 sfc_err(sa, "failed: no such port");
1366                 rc = ENOENT;
1367                 goto fail_no_port;
1368         }
1369
1370         if (rp->started) {
1371                 rc = sfc_repr_proxy_mbox_send(&rp->mbox, port,
1372                                               SFC_REPR_PROXY_MBOX_DEL_PORT);
1373                 if (rc != 0) {
1374                         sfc_err(sa, "failed to remove proxy port %u",
1375                                 port->repr_id);
1376                         goto fail_port_remove;
1377                 }
1378         } else {
1379                 TAILQ_REMOVE(&rp->ports, port, entries);
1380         }
1381
1382         rte_free(port);
1383
1384         sfc_log_init(sa, "done");
1385
1386         sfc_put_adapter(sa);
1387
1388         return 0;
1389
1390 fail_port_remove:
1391 fail_no_port:
1392         sfc_log_init(sa, "failed: %s", rte_strerror(rc));
1393         sfc_put_adapter(sa);
1394
1395         return rc;
1396 }
1397
1398 int
1399 sfc_repr_proxy_add_rxq(uint16_t pf_port_id, uint16_t repr_id,
1400                        uint16_t queue_id, struct rte_ring *rx_ring,
1401                        struct rte_mempool *mp)
1402 {
1403         struct sfc_repr_proxy_port *port;
1404         struct sfc_repr_proxy_rxq *rxq;
1405         struct sfc_repr_proxy *rp;
1406         struct sfc_adapter *sa;
1407
1408         sa = sfc_get_adapter_by_pf_port_id(pf_port_id);
1409         rp = sfc_repr_proxy_by_adapter(sa);
1410
1411         sfc_log_init(sa, "entry");
1412
1413         port = sfc_repr_proxy_find_port(rp, repr_id);
1414         if (port == NULL) {
1415                 sfc_err(sa, "%s() failed: no such port", __func__);
1416                 return ENOENT;
1417         }
1418
1419         rxq = &port->rxq[queue_id];
1420         if (rp->dp_rxq[queue_id].mp != NULL && rp->dp_rxq[queue_id].mp != mp) {
1421                 sfc_err(sa, "multiple mempools per queue are not supported");
1422                 sfc_put_adapter(sa);
1423                 return ENOTSUP;
1424         }
1425
1426         rxq->ring = rx_ring;
1427         rxq->mb_pool = mp;
1428         rp->dp_rxq[queue_id].mp = mp;
1429         rp->dp_rxq[queue_id].ref_count++;
1430
1431         sfc_log_init(sa, "done");
1432         sfc_put_adapter(sa);
1433
1434         return 0;
1435 }
1436
1437 void
1438 sfc_repr_proxy_del_rxq(uint16_t pf_port_id, uint16_t repr_id,
1439                        uint16_t queue_id)
1440 {
1441         struct sfc_repr_proxy_port *port;
1442         struct sfc_repr_proxy_rxq *rxq;
1443         struct sfc_repr_proxy *rp;
1444         struct sfc_adapter *sa;
1445
1446         sa = sfc_get_adapter_by_pf_port_id(pf_port_id);
1447         rp = sfc_repr_proxy_by_adapter(sa);
1448
1449         sfc_log_init(sa, "entry");
1450
1451         port = sfc_repr_proxy_find_port(rp, repr_id);
1452         if (port == NULL) {
1453                 sfc_err(sa, "%s() failed: no such port", __func__);
1454                 return;
1455         }
1456
1457         rxq = &port->rxq[queue_id];
1458
1459         rxq->ring = NULL;
1460         rxq->mb_pool = NULL;
1461         rp->dp_rxq[queue_id].ref_count--;
1462         if (rp->dp_rxq[queue_id].ref_count == 0)
1463                 rp->dp_rxq[queue_id].mp = NULL;
1464
1465         sfc_log_init(sa, "done");
1466         sfc_put_adapter(sa);
1467 }
1468
1469 int
1470 sfc_repr_proxy_add_txq(uint16_t pf_port_id, uint16_t repr_id,
1471                        uint16_t queue_id, struct rte_ring *tx_ring,
1472                        efx_mport_id_t *egress_mport)
1473 {
1474         struct sfc_repr_proxy_port *port;
1475         struct sfc_repr_proxy_txq *txq;
1476         struct sfc_repr_proxy *rp;
1477         struct sfc_adapter *sa;
1478
1479         sa = sfc_get_adapter_by_pf_port_id(pf_port_id);
1480         rp = sfc_repr_proxy_by_adapter(sa);
1481
1482         sfc_log_init(sa, "entry");
1483
1484         port = sfc_repr_proxy_find_port(rp, repr_id);
1485         if (port == NULL) {
1486                 sfc_err(sa, "%s() failed: no such port", __func__);
1487                 return ENOENT;
1488         }
1489
1490         txq = &port->txq[queue_id];
1491
1492         txq->ring = tx_ring;
1493
1494         *egress_mport = port->egress_mport;
1495
1496         sfc_log_init(sa, "done");
1497         sfc_put_adapter(sa);
1498
1499         return 0;
1500 }
1501
1502 void
1503 sfc_repr_proxy_del_txq(uint16_t pf_port_id, uint16_t repr_id,
1504                        uint16_t queue_id)
1505 {
1506         struct sfc_repr_proxy_port *port;
1507         struct sfc_repr_proxy_txq *txq;
1508         struct sfc_repr_proxy *rp;
1509         struct sfc_adapter *sa;
1510
1511         sa = sfc_get_adapter_by_pf_port_id(pf_port_id);
1512         rp = sfc_repr_proxy_by_adapter(sa);
1513
1514         sfc_log_init(sa, "entry");
1515
1516         port = sfc_repr_proxy_find_port(rp, repr_id);
1517         if (port == NULL) {
1518                 sfc_err(sa, "%s() failed: no such port", __func__);
1519                 return;
1520         }
1521
1522         txq = &port->txq[queue_id];
1523
1524         txq->ring = NULL;
1525
1526         sfc_log_init(sa, "done");
1527         sfc_put_adapter(sa);
1528 }
1529
1530 int
1531 sfc_repr_proxy_start_repr(uint16_t pf_port_id, uint16_t repr_id)
1532 {
1533         bool proxy_start_required = false;
1534         struct sfc_repr_proxy_port *port;
1535         struct sfc_repr_proxy *rp;
1536         struct sfc_adapter *sa;
1537         int rc;
1538
1539         sa = sfc_get_adapter_by_pf_port_id(pf_port_id);
1540         rp = sfc_repr_proxy_by_adapter(sa);
1541
1542         sfc_log_init(sa, "entry");
1543
1544         port = sfc_repr_proxy_find_port(rp, repr_id);
1545         if (port == NULL) {
1546                 sfc_err(sa, "%s() failed: no such port", __func__);
1547                 rc = ENOENT;
1548                 goto fail_not_found;
1549         }
1550
1551         if (port->enabled) {
1552                 rc = EALREADY;
1553                 sfc_err(sa, "failed: repr %u proxy port already started",
1554                         repr_id);
1555                 goto fail_already_started;
1556         }
1557
1558         if (sa->state == SFC_ETHDEV_STARTED) {
1559                 if (sfc_repr_proxy_ports_disabled(rp)) {
1560                         proxy_start_required = true;
1561                 } else {
1562                         rc = sfc_repr_proxy_do_start_port(sa, port);
1563                         if (rc != 0) {
1564                                 sfc_err(sa,
1565                                         "failed to start repr %u proxy port",
1566                                         repr_id);
1567                                 goto fail_start_id;
1568                         }
1569                 }
1570         }
1571
1572         port->enabled = true;
1573
1574         if (proxy_start_required) {
1575                 rc = sfc_repr_proxy_start(sa);
1576                 if (rc != 0) {
1577                         sfc_err(sa, "failed to start proxy");
1578                         goto fail_proxy_start;
1579                 }
1580         }
1581
1582         sfc_log_init(sa, "done");
1583         sfc_put_adapter(sa);
1584
1585         return 0;
1586
1587 fail_proxy_start:
1588         port->enabled = false;
1589
1590 fail_start_id:
1591 fail_already_started:
1592 fail_not_found:
1593         sfc_err(sa, "failed to start repr %u proxy port: %s", repr_id,
1594                 rte_strerror(rc));
1595         sfc_put_adapter(sa);
1596
1597         return rc;
1598 }
1599
1600 int
1601 sfc_repr_proxy_stop_repr(uint16_t pf_port_id, uint16_t repr_id)
1602 {
1603         struct sfc_repr_proxy_port *port;
1604         struct sfc_repr_proxy_port *p;
1605         struct sfc_repr_proxy *rp;
1606         struct sfc_adapter *sa;
1607         int rc;
1608
1609         sa = sfc_get_adapter_by_pf_port_id(pf_port_id);
1610         rp = sfc_repr_proxy_by_adapter(sa);
1611
1612         sfc_log_init(sa, "entry");
1613
1614         port = sfc_repr_proxy_find_port(rp, repr_id);
1615         if (port == NULL) {
1616                 sfc_err(sa, "%s() failed: no such port", __func__);
1617                 return ENOENT;
1618         }
1619
1620         if (!port->enabled) {
1621                 sfc_log_init(sa, "repr %u proxy port is not started - skip",
1622                              repr_id);
1623                 sfc_put_adapter(sa);
1624                 return 0;
1625         }
1626
1627         if (sa->state == SFC_ETHDEV_STARTED) {
1628                 bool last_enabled = true;
1629
1630                 TAILQ_FOREACH(p, &rp->ports, entries) {
1631                         if (p == port)
1632                                 continue;
1633
1634                         if (sfc_repr_proxy_port_enabled(p)) {
1635                                 last_enabled = false;
1636                                 break;
1637                         }
1638                 }
1639
1640                 rc = 0;
1641                 if (last_enabled)
1642                         sfc_repr_proxy_stop(sa);
1643                 else
1644                         rc = sfc_repr_proxy_do_stop_port(sa, port);
1645
1646                 if (rc != 0) {
1647                         sfc_err(sa,
1648                                 "failed to stop representor proxy TxQ %u: %s",
1649                                 repr_id, rte_strerror(rc));
1650                         sfc_put_adapter(sa);
1651                         return rc;
1652                 }
1653         }
1654
1655         port->enabled = false;
1656
1657         sfc_log_init(sa, "done");
1658         sfc_put_adapter(sa);
1659
1660         return 0;
1661 }