1 /* SPDX-License-Identifier: BSD-3-Clause
3 * Copyright(c) 2019-2021 Xilinx, Inc.
4 * Copyright(c) 2019 Solarflare Communications Inc.
6 * This software was jointly developed between OKTET Labs (under contract
7 * for Solarflare) and Solarflare Communications, Inc.
10 #include <rte_service.h>
11 #include <rte_service_component.h>
14 #include "sfc_service.h"
15 #include "sfc_repr_proxy.h"
16 #include "sfc_repr_proxy_api.h"
23 * Amount of time to wait for the representor proxy routine (which is
24 * running on a service core) to handle a request sent via mbox.
26 #define SFC_REPR_PROXY_MBOX_POLL_TIMEOUT_MS 1000
29 * Amount of time to wait for the representor proxy routine (which is
30 * running on a service core) to terminate after service core is stopped.
32 #define SFC_REPR_PROXY_ROUTINE_TERMINATE_TIMEOUT_MS 10000
34 static struct sfc_repr_proxy *
35 sfc_repr_proxy_by_adapter(struct sfc_adapter *sa)
37 return &sa->repr_proxy;
40 static struct sfc_adapter *
41 sfc_get_adapter_by_pf_port_id(uint16_t pf_port_id)
43 struct rte_eth_dev *dev;
44 struct sfc_adapter *sa;
46 SFC_ASSERT(pf_port_id < RTE_MAX_ETHPORTS);
48 dev = &rte_eth_devices[pf_port_id];
49 sa = sfc_adapter_by_eth_dev(dev);
57 sfc_put_adapter(struct sfc_adapter *sa)
59 sfc_adapter_unlock(sa);
62 static struct sfc_repr_proxy_port *
63 sfc_repr_proxy_find_port(struct sfc_repr_proxy *rp, uint16_t repr_id)
65 struct sfc_repr_proxy_port *port;
67 TAILQ_FOREACH(port, &rp->ports, entries) {
68 if (port->repr_id == repr_id)
76 sfc_repr_proxy_mbox_send(struct sfc_repr_proxy_mbox *mbox,
77 struct sfc_repr_proxy_port *port,
78 enum sfc_repr_proxy_mbox_op op)
80 const unsigned int wait_ms = SFC_REPR_PROXY_MBOX_POLL_TIMEOUT_MS;
88 * Release ordering enforces marker set after data is populated.
89 * Paired with acquire ordering in sfc_repr_proxy_mbox_handle().
91 __atomic_store_n(&mbox->write_marker, true, __ATOMIC_RELEASE);
94 * Wait for the representor routine to process the request.
97 for (i = 0; i < wait_ms; i++) {
99 * Paired with release ordering in sfc_repr_proxy_mbox_handle()
100 * on acknowledge write.
102 if (__atomic_load_n(&mbox->ack, __ATOMIC_ACQUIRE))
110 "%s() failed to wait for representor proxy routine ack",
119 sfc_repr_proxy_mbox_handle(struct sfc_repr_proxy *rp)
121 struct sfc_repr_proxy_mbox *mbox = &rp->mbox;
124 * Paired with release ordering in sfc_repr_proxy_mbox_send()
127 if (!__atomic_load_n(&mbox->write_marker, __ATOMIC_ACQUIRE))
130 mbox->write_marker = false;
133 case SFC_REPR_PROXY_MBOX_ADD_PORT:
134 TAILQ_INSERT_TAIL(&rp->ports, mbox->port, entries);
136 case SFC_REPR_PROXY_MBOX_DEL_PORT:
137 TAILQ_REMOVE(&rp->ports, mbox->port, entries);
139 case SFC_REPR_PROXY_MBOX_START_PORT:
140 mbox->port->started = true;
142 case SFC_REPR_PROXY_MBOX_STOP_PORT:
143 mbox->port->started = false;
151 * Paired with acquire ordering in sfc_repr_proxy_mbox_send()
152 * on acknowledge read.
154 __atomic_store_n(&mbox->ack, true, __ATOMIC_RELEASE);
158 sfc_repr_proxy_handle_tx(struct sfc_repr_proxy_dp_txq *rp_txq,
159 struct sfc_repr_proxy_txq *repr_txq)
162 * With multiple representor proxy queues configured it is
163 * possible that not all of the corresponding representor
164 * queues were created. Skip the queues that do not exist.
166 if (repr_txq->ring == NULL)
169 if (rp_txq->available < RTE_DIM(rp_txq->tx_pkts)) {
171 rte_ring_sc_dequeue_burst(repr_txq->ring,
172 (void **)(&rp_txq->tx_pkts[rp_txq->available]),
173 RTE_DIM(rp_txq->tx_pkts) - rp_txq->available,
176 if (rp_txq->available == rp_txq->transmitted)
180 rp_txq->transmitted += rp_txq->pkt_burst(rp_txq->dp,
181 &rp_txq->tx_pkts[rp_txq->transmitted],
182 rp_txq->available - rp_txq->transmitted);
184 if (rp_txq->available == rp_txq->transmitted) {
185 rp_txq->available = 0;
186 rp_txq->transmitted = 0;
191 sfc_repr_proxy_routine(void *arg)
193 struct sfc_repr_proxy_port *port;
194 struct sfc_repr_proxy *rp = arg;
197 sfc_repr_proxy_mbox_handle(rp);
199 TAILQ_FOREACH(port, &rp->ports, entries) {
203 for (i = 0; i < rp->nb_txq; i++)
204 sfc_repr_proxy_handle_tx(&rp->dp_txq[i], &port->txq[i]);
210 static struct sfc_txq_info *
211 sfc_repr_proxy_txq_info_get(struct sfc_adapter *sa, unsigned int repr_queue_id)
213 struct sfc_adapter_shared *sas = sfc_sa2shared(sa);
214 struct sfc_repr_proxy_dp_txq *dp_txq;
216 SFC_ASSERT(repr_queue_id < sfc_repr_nb_txq(sas));
217 dp_txq = &sa->repr_proxy.dp_txq[repr_queue_id];
219 return &sas->txq_info[dp_txq->sw_index];
223 sfc_repr_proxy_txq_attach(struct sfc_adapter *sa)
225 struct sfc_adapter_shared * const sas = sfc_sa2shared(sa);
226 struct sfc_repr_proxy *rp = &sa->repr_proxy;
229 sfc_log_init(sa, "entry");
231 for (i = 0; i < sfc_repr_nb_txq(sas); i++) {
232 sfc_sw_index_t sw_index = sfc_repr_txq_sw_index(sas, i);
234 rp->dp_txq[i].sw_index = sw_index;
237 sfc_log_init(sa, "done");
243 sfc_repr_proxy_txq_detach(struct sfc_adapter *sa)
245 struct sfc_adapter_shared * const sas = sfc_sa2shared(sa);
246 struct sfc_repr_proxy *rp = &sa->repr_proxy;
249 sfc_log_init(sa, "entry");
251 for (i = 0; i < sfc_repr_nb_txq(sas); i++)
252 rp->dp_txq[i].sw_index = 0;
254 sfc_log_init(sa, "done");
258 sfc_repr_proxy_txq_init(struct sfc_adapter *sa)
260 struct sfc_adapter_shared * const sas = sfc_sa2shared(sa);
261 struct sfc_repr_proxy *rp = &sa->repr_proxy;
262 const struct rte_eth_txconf tx_conf = {
263 .tx_free_thresh = SFC_REPR_PROXY_TXQ_FREE_THRESH,
265 struct sfc_txq_info *txq_info;
270 sfc_log_init(sa, "entry");
272 if (!sfc_repr_available(sas)) {
273 sfc_log_init(sa, "representors not supported - skip");
277 for (init_i = 0; init_i < sfc_repr_nb_txq(sas); init_i++) {
278 struct sfc_repr_proxy_dp_txq *txq = &rp->dp_txq[init_i];
280 txq_info = &sfc_sa2shared(sa)->txq_info[txq->sw_index];
281 if (txq_info->state == SFC_TXQ_INITIALIZED) {
283 "representor proxy TxQ %u is already initialized - skip",
288 sfc_tx_qinit_info(sa, txq->sw_index);
290 rc = sfc_tx_qinit(sa, txq->sw_index,
291 SFC_REPR_PROXY_TX_DESC_COUNT, sa->socket_id,
295 sfc_err(sa, "failed to init representor proxy TxQ %u",
301 sfc_log_init(sa, "done");
306 for (i = 0; i < init_i; i++) {
307 struct sfc_repr_proxy_dp_txq *txq = &rp->dp_txq[i];
309 txq_info = &sfc_sa2shared(sa)->txq_info[txq->sw_index];
310 if (txq_info->state == SFC_TXQ_INITIALIZED)
311 sfc_tx_qfini(sa, txq->sw_index);
313 sfc_log_init(sa, "failed: %s", rte_strerror(rc));
319 sfc_repr_proxy_txq_fini(struct sfc_adapter *sa)
321 struct sfc_adapter_shared * const sas = sfc_sa2shared(sa);
322 struct sfc_repr_proxy *rp = &sa->repr_proxy;
323 struct sfc_txq_info *txq_info;
326 sfc_log_init(sa, "entry");
328 if (!sfc_repr_available(sas)) {
329 sfc_log_init(sa, "representors not supported - skip");
333 for (i = 0; i < sfc_repr_nb_txq(sas); i++) {
334 struct sfc_repr_proxy_dp_txq *txq = &rp->dp_txq[i];
336 txq_info = &sfc_sa2shared(sa)->txq_info[txq->sw_index];
337 if (txq_info->state != SFC_TXQ_INITIALIZED) {
339 "representor proxy TxQ %u is already finalized - skip",
344 sfc_tx_qfini(sa, txq->sw_index);
347 sfc_log_init(sa, "done");
351 sfc_repr_proxy_txq_start(struct sfc_adapter *sa)
353 struct sfc_adapter_shared * const sas = sfc_sa2shared(sa);
354 struct sfc_repr_proxy *rp = &sa->repr_proxy;
357 sfc_log_init(sa, "entry");
359 for (i = 0; i < sfc_repr_nb_txq(sas); i++) {
360 struct sfc_repr_proxy_dp_txq *txq = &rp->dp_txq[i];
362 txq->dp = sfc_repr_proxy_txq_info_get(sa, i)->dp;
363 txq->pkt_burst = sa->eth_dev->tx_pkt_burst;
365 txq->transmitted = 0;
368 sfc_log_init(sa, "done");
374 sfc_repr_proxy_txq_stop(struct sfc_adapter *sa)
376 sfc_log_init(sa, "entry");
377 sfc_log_init(sa, "done");
381 sfc_repr_proxy_rxq_attach(struct sfc_adapter *sa)
383 struct sfc_adapter_shared * const sas = sfc_sa2shared(sa);
384 struct sfc_repr_proxy *rp = &sa->repr_proxy;
387 sfc_log_init(sa, "entry");
389 for (i = 0; i < sfc_repr_nb_rxq(sas); i++) {
390 sfc_sw_index_t sw_index = sfc_repr_rxq_sw_index(sas, i);
392 rp->dp_rxq[i].sw_index = sw_index;
395 sfc_log_init(sa, "done");
401 sfc_repr_proxy_rxq_detach(struct sfc_adapter *sa)
403 struct sfc_adapter_shared * const sas = sfc_sa2shared(sa);
404 struct sfc_repr_proxy *rp = &sa->repr_proxy;
407 sfc_log_init(sa, "entry");
409 for (i = 0; i < sfc_repr_nb_rxq(sas); i++)
410 rp->dp_rxq[i].sw_index = 0;
412 sfc_log_init(sa, "done");
416 sfc_repr_proxy_rxq_init(struct sfc_adapter *sa,
417 struct sfc_repr_proxy_dp_rxq *rxq)
419 struct sfc_adapter_shared * const sas = sfc_sa2shared(sa);
420 uint16_t nb_rx_desc = SFC_REPR_PROXY_RX_DESC_COUNT;
421 struct sfc_rxq_info *rxq_info;
422 struct rte_eth_rxconf rxconf = {
423 .rx_free_thresh = SFC_REPR_PROXY_RXQ_REFILL_LEVEL,
428 sfc_log_init(sa, "entry");
430 rxq_info = &sas->rxq_info[rxq->sw_index];
431 if (rxq_info->state & SFC_RXQ_INITIALIZED) {
432 sfc_log_init(sa, "RxQ is already initialized - skip");
436 nb_rx_desc = RTE_MIN(nb_rx_desc, sa->rxq_max_entries);
437 nb_rx_desc = RTE_MAX(nb_rx_desc, sa->rxq_min_entries);
439 rc = sfc_rx_qinit_info(sa, rxq->sw_index, EFX_RXQ_FLAG_INGRESS_MPORT);
441 sfc_err(sa, "failed to init representor proxy RxQ info");
442 goto fail_repr_rxq_init_info;
445 rc = sfc_rx_qinit(sa, rxq->sw_index, nb_rx_desc, sa->socket_id, &rxconf,
448 sfc_err(sa, "failed to init representor proxy RxQ");
449 goto fail_repr_rxq_init;
452 sfc_log_init(sa, "done");
457 fail_repr_rxq_init_info:
458 sfc_log_init(sa, "failed: %s", rte_strerror(rc));
464 sfc_repr_proxy_rxq_fini(struct sfc_adapter *sa)
466 struct sfc_adapter_shared * const sas = sfc_sa2shared(sa);
467 struct sfc_repr_proxy *rp = &sa->repr_proxy;
468 struct sfc_rxq_info *rxq_info;
471 sfc_log_init(sa, "entry");
473 if (!sfc_repr_available(sas)) {
474 sfc_log_init(sa, "representors not supported - skip");
478 for (i = 0; i < sfc_repr_nb_rxq(sas); i++) {
479 struct sfc_repr_proxy_dp_rxq *rxq = &rp->dp_rxq[i];
481 rxq_info = &sas->rxq_info[rxq->sw_index];
482 if (rxq_info->state != SFC_RXQ_INITIALIZED) {
484 "representor RxQ %u is already finalized - skip",
489 sfc_rx_qfini(sa, rxq->sw_index);
492 sfc_log_init(sa, "done");
496 sfc_repr_proxy_rxq_stop(struct sfc_adapter *sa)
498 struct sfc_adapter_shared * const sas = sfc_sa2shared(sa);
501 sfc_log_init(sa, "entry");
503 for (i = 0; i < sfc_repr_nb_rxq(sas); i++)
504 sfc_rx_qstop(sa, sa->repr_proxy.dp_rxq[i].sw_index);
506 sfc_repr_proxy_rxq_fini(sa);
508 sfc_log_init(sa, "done");
512 sfc_repr_proxy_rxq_start(struct sfc_adapter *sa)
514 struct sfc_adapter_shared * const sas = sfc_sa2shared(sa);
515 struct sfc_repr_proxy *rp = &sa->repr_proxy;
519 sfc_log_init(sa, "entry");
521 if (!sfc_repr_available(sas)) {
522 sfc_log_init(sa, "representors not supported - skip");
526 for (i = 0; i < sfc_repr_nb_rxq(sas); i++) {
527 struct sfc_repr_proxy_dp_rxq *rxq = &rp->dp_rxq[i];
529 rc = sfc_repr_proxy_rxq_init(sa, rxq);
531 sfc_err(sa, "failed to init representor proxy RxQ %u",
536 rc = sfc_rx_qstart(sa, rxq->sw_index);
538 sfc_err(sa, "failed to start representor proxy RxQ %u",
544 sfc_log_init(sa, "done");
550 sfc_repr_proxy_rxq_stop(sa);
551 sfc_log_init(sa, "failed: %s", rte_strerror(rc));
556 sfc_repr_proxy_mae_rule_insert(struct sfc_adapter *sa,
557 struct sfc_repr_proxy_port *port)
559 struct sfc_repr_proxy *rp = &sa->repr_proxy;
560 efx_mport_sel_t mport_alias_selector;
561 efx_mport_sel_t mport_vf_selector;
562 struct sfc_mae_rule *mae_rule;
565 sfc_log_init(sa, "entry");
567 rc = efx_mae_mport_by_id(&port->egress_mport,
570 sfc_err(sa, "failed to get VF mport for repr %u",
575 rc = efx_mae_mport_by_id(&rp->mport_alias, &mport_alias_selector);
577 sfc_err(sa, "failed to get mport selector for repr %u",
582 rc = sfc_mae_rule_add_mport_match_deliver(sa, &mport_vf_selector,
583 &mport_alias_selector, -1,
586 sfc_err(sa, "failed to insert MAE rule for repr %u",
591 port->mae_rule = mae_rule;
593 sfc_log_init(sa, "done");
600 sfc_log_init(sa, "failed: %s", rte_strerror(rc));
605 sfc_repr_proxy_mae_rule_remove(struct sfc_adapter *sa,
606 struct sfc_repr_proxy_port *port)
608 struct sfc_mae_rule *mae_rule = port->mae_rule;
610 sfc_mae_rule_del(sa, mae_rule);
614 sfc_repr_proxy_mport_filter_insert(struct sfc_adapter *sa)
616 struct sfc_adapter_shared * const sas = sfc_sa2shared(sa);
617 struct sfc_repr_proxy *rp = &sa->repr_proxy;
618 struct sfc_rxq *rxq_ctrl;
619 struct sfc_repr_proxy_filter *filter = &rp->mport_filter;
620 efx_mport_sel_t mport_alias_selector;
621 static const efx_filter_match_flags_t flags[RTE_DIM(filter->specs)] = {
622 EFX_FILTER_MATCH_UNKNOWN_UCAST_DST,
623 EFX_FILTER_MATCH_UNKNOWN_MCAST_DST };
627 sfc_log_init(sa, "entry");
629 if (sfc_repr_nb_rxq(sas) == 1) {
630 rxq_ctrl = &sa->rxq_ctrl[rp->dp_rxq[0].sw_index];
632 sfc_err(sa, "multiple representor proxy RxQs not supported");
634 goto fail_multiple_queues;
637 rc = efx_mae_mport_by_id(&rp->mport_alias, &mport_alias_selector);
639 sfc_err(sa, "failed to get repr proxy mport by ID");
640 goto fail_get_selector;
643 memset(filter->specs, 0, sizeof(filter->specs));
644 for (i = 0; i < RTE_DIM(filter->specs); i++) {
645 filter->specs[i].efs_priority = EFX_FILTER_PRI_MANUAL;
646 filter->specs[i].efs_flags = EFX_FILTER_FLAG_RX;
647 filter->specs[i].efs_dmaq_id = rxq_ctrl->hw_index;
648 filter->specs[i].efs_match_flags = flags[i] |
649 EFX_FILTER_MATCH_MPORT;
650 filter->specs[i].efs_ingress_mport = mport_alias_selector.sel;
652 rc = efx_filter_insert(sa->nic, &filter->specs[i]);
654 sfc_err(sa, "failed to insert repr proxy filter");
659 sfc_log_init(sa, "done");
665 efx_filter_remove(sa->nic, &filter->specs[i]);
668 fail_multiple_queues:
669 sfc_log_init(sa, "failed: %s", rte_strerror(rc));
674 sfc_repr_proxy_mport_filter_remove(struct sfc_adapter *sa)
676 struct sfc_repr_proxy *rp = &sa->repr_proxy;
677 struct sfc_repr_proxy_filter *filter = &rp->mport_filter;
680 for (i = 0; i < RTE_DIM(filter->specs); i++)
681 efx_filter_remove(sa->nic, &filter->specs[i]);
685 sfc_repr_proxy_port_rule_insert(struct sfc_adapter *sa,
686 struct sfc_repr_proxy_port *port)
690 rc = sfc_repr_proxy_mae_rule_insert(sa, port);
692 goto fail_mae_rule_insert;
696 fail_mae_rule_insert:
701 sfc_repr_proxy_port_rule_remove(struct sfc_adapter *sa,
702 struct sfc_repr_proxy_port *port)
704 sfc_repr_proxy_mae_rule_remove(sa, port);
708 sfc_repr_proxy_ports_init(struct sfc_adapter *sa)
710 struct sfc_repr_proxy *rp = &sa->repr_proxy;
713 sfc_log_init(sa, "entry");
715 rc = efx_mcdi_mport_alloc_alias(sa->nic, &rp->mport_alias, NULL);
717 sfc_err(sa, "failed to alloc mport alias: %s",
719 goto fail_alloc_mport_alias;
722 TAILQ_INIT(&rp->ports);
724 sfc_log_init(sa, "done");
728 fail_alloc_mport_alias:
730 sfc_log_init(sa, "failed: %s", rte_strerror(rc));
735 sfc_repr_proxy_pre_detach(struct sfc_adapter *sa)
737 struct sfc_repr_proxy *rp = &sa->repr_proxy;
738 bool close_ports[RTE_MAX_ETHPORTS] = {0};
739 struct sfc_repr_proxy_port *port;
742 SFC_ASSERT(!sfc_adapter_is_locked(sa));
744 sfc_adapter_lock(sa);
746 if (sfc_repr_available(sfc_sa2shared(sa))) {
747 TAILQ_FOREACH(port, &rp->ports, entries)
748 close_ports[port->rte_port_id] = true;
750 sfc_log_init(sa, "representors not supported - skip");
753 sfc_adapter_unlock(sa);
755 for (i = 0; i < RTE_DIM(close_ports); i++) {
756 if (close_ports[i]) {
758 rte_eth_dev_close(i);
764 sfc_repr_proxy_ports_fini(struct sfc_adapter *sa)
766 struct sfc_repr_proxy *rp = &sa->repr_proxy;
768 efx_mae_mport_free(sa->nic, &rp->mport_alias);
772 sfc_repr_proxy_attach(struct sfc_adapter *sa)
774 struct sfc_adapter_shared * const sas = sfc_sa2shared(sa);
775 struct sfc_repr_proxy *rp = &sa->repr_proxy;
776 struct rte_service_spec service;
781 sfc_log_init(sa, "entry");
783 if (!sfc_repr_available(sas)) {
784 sfc_log_init(sa, "representors not supported - skip");
788 rc = sfc_repr_proxy_rxq_attach(sa);
790 goto fail_rxq_attach;
792 rc = sfc_repr_proxy_txq_attach(sa);
794 goto fail_txq_attach;
796 rc = sfc_repr_proxy_ports_init(sa);
798 goto fail_ports_init;
800 cid = sfc_get_service_lcore(sa->socket_id);
801 if (cid == RTE_MAX_LCORE && sa->socket_id != SOCKET_ID_ANY) {
802 /* Warn and try to allocate on any NUMA node */
804 "repr proxy: unable to get service lcore at socket %d",
807 cid = sfc_get_service_lcore(SOCKET_ID_ANY);
809 if (cid == RTE_MAX_LCORE) {
811 sfc_err(sa, "repr proxy: failed to get service lcore");
812 goto fail_get_service_lcore;
815 memset(&service, 0, sizeof(service));
816 snprintf(service.name, sizeof(service.name),
817 "net_sfc_%hu_repr_proxy", sfc_sa2shared(sa)->port_id);
818 service.socket_id = rte_lcore_to_socket_id(cid);
819 service.callback = sfc_repr_proxy_routine;
820 service.callback_userdata = rp;
822 rc = rte_service_component_register(&service, &sid);
825 sfc_err(sa, "repr proxy: failed to register service component");
829 rc = rte_service_map_lcore_set(sid, cid, 1);
832 sfc_err(sa, "repr proxy: failed to map lcore");
836 rp->service_core_id = cid;
837 rp->service_id = sid;
839 sfc_log_init(sa, "done");
844 rte_service_component_unregister(sid);
848 * No need to rollback service lcore get since
849 * it just makes socket_id based search and remembers it.
852 fail_get_service_lcore:
853 sfc_repr_proxy_ports_fini(sa);
856 sfc_repr_proxy_txq_detach(sa);
859 sfc_repr_proxy_rxq_detach(sa);
862 sfc_log_init(sa, "failed: %s", rte_strerror(rc));
867 sfc_repr_proxy_detach(struct sfc_adapter *sa)
869 struct sfc_adapter_shared * const sas = sfc_sa2shared(sa);
870 struct sfc_repr_proxy *rp = &sa->repr_proxy;
872 sfc_log_init(sa, "entry");
874 if (!sfc_repr_available(sas)) {
875 sfc_log_init(sa, "representors not supported - skip");
879 rte_service_map_lcore_set(rp->service_id, rp->service_core_id, 0);
880 rte_service_component_unregister(rp->service_id);
881 sfc_repr_proxy_ports_fini(sa);
882 sfc_repr_proxy_rxq_detach(sa);
883 sfc_repr_proxy_txq_detach(sa);
885 sfc_log_init(sa, "done");
889 sfc_repr_proxy_do_start_port(struct sfc_adapter *sa,
890 struct sfc_repr_proxy_port *port)
892 struct sfc_repr_proxy *rp = &sa->repr_proxy;
895 rc = sfc_repr_proxy_port_rule_insert(sa, port);
897 goto fail_filter_insert;
900 rc = sfc_repr_proxy_mbox_send(&rp->mbox, port,
901 SFC_REPR_PROXY_MBOX_START_PORT);
903 sfc_err(sa, "failed to start proxy port %u",
905 goto fail_port_start;
908 port->started = true;
914 sfc_repr_proxy_port_rule_remove(sa, port);
916 sfc_err(sa, "%s() failed %s", __func__, rte_strerror(rc));
922 sfc_repr_proxy_do_stop_port(struct sfc_adapter *sa,
923 struct sfc_repr_proxy_port *port)
926 struct sfc_repr_proxy *rp = &sa->repr_proxy;
930 rc = sfc_repr_proxy_mbox_send(&rp->mbox, port,
931 SFC_REPR_PROXY_MBOX_STOP_PORT);
933 sfc_err(sa, "failed to stop proxy port %u: %s",
934 port->repr_id, rte_strerror(rc));
938 port->started = false;
941 sfc_repr_proxy_port_rule_remove(sa, port);
947 sfc_repr_proxy_port_enabled(struct sfc_repr_proxy_port *port)
949 return port->rte_port_id != RTE_MAX_ETHPORTS && port->enabled;
953 sfc_repr_proxy_ports_disabled(struct sfc_repr_proxy *rp)
955 struct sfc_repr_proxy_port *port;
957 TAILQ_FOREACH(port, &rp->ports, entries) {
958 if (sfc_repr_proxy_port_enabled(port))
966 sfc_repr_proxy_start(struct sfc_adapter *sa)
968 struct sfc_adapter_shared * const sas = sfc_sa2shared(sa);
969 struct sfc_repr_proxy *rp = &sa->repr_proxy;
970 struct sfc_repr_proxy_port *last_port = NULL;
971 struct sfc_repr_proxy_port *port;
974 sfc_log_init(sa, "entry");
976 /* Representor proxy is not started when no representors are started */
977 if (!sfc_repr_available(sas)) {
978 sfc_log_init(sa, "representors not supported - skip");
982 if (sfc_repr_proxy_ports_disabled(rp)) {
983 sfc_log_init(sa, "no started representor ports - skip");
987 rc = sfc_repr_proxy_rxq_start(sa);
991 rc = sfc_repr_proxy_txq_start(sa);
995 rp->nb_txq = sfc_repr_nb_txq(sas);
997 /* Service core may be in "stopped" state, start it */
998 rc = rte_service_lcore_start(rp->service_core_id);
999 if (rc != 0 && rc != -EALREADY) {
1001 sfc_err(sa, "failed to start service core for %s: %s",
1002 rte_service_get_name(rp->service_id),
1004 goto fail_start_core;
1007 /* Run the service */
1008 rc = rte_service_component_runstate_set(rp->service_id, 1);
1011 sfc_err(sa, "failed to run %s component: %s",
1012 rte_service_get_name(rp->service_id),
1014 goto fail_component_runstate_set;
1016 rc = rte_service_runstate_set(rp->service_id, 1);
1019 sfc_err(sa, "failed to run %s: %s",
1020 rte_service_get_name(rp->service_id),
1022 goto fail_runstate_set;
1025 TAILQ_FOREACH(port, &rp->ports, entries) {
1026 if (sfc_repr_proxy_port_enabled(port)) {
1027 rc = sfc_repr_proxy_do_start_port(sa, port);
1035 rc = sfc_repr_proxy_mport_filter_insert(sa);
1037 goto fail_mport_filter_insert;
1041 sfc_log_init(sa, "done");
1045 fail_mport_filter_insert:
1047 if (last_port != NULL) {
1048 TAILQ_FOREACH(port, &rp->ports, entries) {
1049 if (sfc_repr_proxy_port_enabled(port)) {
1050 (void)sfc_repr_proxy_do_stop_port(sa, port);
1051 if (port == last_port)
1057 rte_service_runstate_set(rp->service_id, 0);
1060 rte_service_component_runstate_set(rp->service_id, 0);
1062 fail_component_runstate_set:
1063 /* Service lcore may be shared and we never stop it */
1066 sfc_repr_proxy_txq_stop(sa);
1069 sfc_repr_proxy_rxq_stop(sa);
1072 sfc_log_init(sa, "failed: %s", rte_strerror(rc));
1077 sfc_repr_proxy_stop(struct sfc_adapter *sa)
1079 struct sfc_adapter_shared * const sas = sfc_sa2shared(sa);
1080 struct sfc_repr_proxy *rp = &sa->repr_proxy;
1081 struct sfc_repr_proxy_port *port;
1082 const unsigned int wait_ms_total =
1083 SFC_REPR_PROXY_ROUTINE_TERMINATE_TIMEOUT_MS;
1087 sfc_log_init(sa, "entry");
1089 if (!sfc_repr_available(sas)) {
1090 sfc_log_init(sa, "representors not supported - skip");
1094 if (sfc_repr_proxy_ports_disabled(rp)) {
1095 sfc_log_init(sa, "no started representor ports - skip");
1099 TAILQ_FOREACH(port, &rp->ports, entries) {
1100 if (sfc_repr_proxy_port_enabled(port)) {
1101 rc = sfc_repr_proxy_do_stop_port(sa, port);
1104 "failed to stop representor proxy port %u: %s",
1105 port->repr_id, rte_strerror(rc));
1110 sfc_repr_proxy_mport_filter_remove(sa);
1112 rc = rte_service_runstate_set(rp->service_id, 0);
1114 sfc_err(sa, "failed to stop %s: %s",
1115 rte_service_get_name(rp->service_id),
1119 rc = rte_service_component_runstate_set(rp->service_id, 0);
1121 sfc_err(sa, "failed to stop %s component: %s",
1122 rte_service_get_name(rp->service_id),
1126 /* Service lcore may be shared and we never stop it */
1129 * Wait for the representor proxy routine to finish the last iteration.
1130 * Give up on timeout.
1132 for (i = 0; i < wait_ms_total; i++) {
1133 if (rte_service_may_be_active(rp->service_id) == 0)
1139 sfc_repr_proxy_rxq_stop(sa);
1140 sfc_repr_proxy_txq_stop(sa);
1142 rp->started = false;
1144 sfc_log_init(sa, "done");
1148 sfc_repr_proxy_add_port(uint16_t pf_port_id, uint16_t repr_id,
1149 uint16_t rte_port_id, const efx_mport_sel_t *mport_sel)
1151 struct sfc_repr_proxy_port *port;
1152 struct sfc_repr_proxy *rp;
1153 struct sfc_adapter *sa;
1156 sa = sfc_get_adapter_by_pf_port_id(pf_port_id);
1157 rp = sfc_repr_proxy_by_adapter(sa);
1159 sfc_log_init(sa, "entry");
1160 TAILQ_FOREACH(port, &rp->ports, entries) {
1161 if (port->rte_port_id == rte_port_id) {
1163 sfc_err(sa, "%s() failed: port exists", __func__);
1164 goto fail_port_exists;
1168 port = rte_zmalloc("sfc-repr-proxy-port", sizeof(*port),
1172 sfc_err(sa, "failed to alloc memory for proxy port");
1173 goto fail_alloc_port;
1176 rc = efx_mae_mport_id_by_selector(sa->nic, mport_sel,
1177 &port->egress_mport);
1180 "failed get MAE mport id by selector (repr_id %u): %s",
1181 repr_id, rte_strerror(rc));
1185 port->rte_port_id = rte_port_id;
1186 port->repr_id = repr_id;
1189 rc = sfc_repr_proxy_mbox_send(&rp->mbox, port,
1190 SFC_REPR_PROXY_MBOX_ADD_PORT);
1192 sfc_err(sa, "failed to add proxy port %u",
1197 TAILQ_INSERT_TAIL(&rp->ports, port, entries);
1200 sfc_log_init(sa, "done");
1201 sfc_put_adapter(sa);
1210 sfc_log_init(sa, "failed: %s", rte_strerror(rc));
1211 sfc_put_adapter(sa);
1217 sfc_repr_proxy_del_port(uint16_t pf_port_id, uint16_t repr_id)
1219 struct sfc_repr_proxy_port *port;
1220 struct sfc_repr_proxy *rp;
1221 struct sfc_adapter *sa;
1224 sa = sfc_get_adapter_by_pf_port_id(pf_port_id);
1225 rp = sfc_repr_proxy_by_adapter(sa);
1227 sfc_log_init(sa, "entry");
1229 port = sfc_repr_proxy_find_port(rp, repr_id);
1231 sfc_err(sa, "failed: no such port");
1237 rc = sfc_repr_proxy_mbox_send(&rp->mbox, port,
1238 SFC_REPR_PROXY_MBOX_DEL_PORT);
1240 sfc_err(sa, "failed to remove proxy port %u",
1242 goto fail_port_remove;
1245 TAILQ_REMOVE(&rp->ports, port, entries);
1250 sfc_log_init(sa, "done");
1252 sfc_put_adapter(sa);
1258 sfc_log_init(sa, "failed: %s", rte_strerror(rc));
1259 sfc_put_adapter(sa);
1265 sfc_repr_proxy_add_rxq(uint16_t pf_port_id, uint16_t repr_id,
1266 uint16_t queue_id, struct rte_ring *rx_ring,
1267 struct rte_mempool *mp)
1269 struct sfc_repr_proxy_port *port;
1270 struct sfc_repr_proxy_rxq *rxq;
1271 struct sfc_repr_proxy *rp;
1272 struct sfc_adapter *sa;
1274 sa = sfc_get_adapter_by_pf_port_id(pf_port_id);
1275 rp = sfc_repr_proxy_by_adapter(sa);
1277 sfc_log_init(sa, "entry");
1279 port = sfc_repr_proxy_find_port(rp, repr_id);
1281 sfc_err(sa, "%s() failed: no such port", __func__);
1285 rxq = &port->rxq[queue_id];
1286 if (rp->dp_rxq[queue_id].mp != NULL && rp->dp_rxq[queue_id].mp != mp) {
1287 sfc_err(sa, "multiple mempools per queue are not supported");
1288 sfc_put_adapter(sa);
1292 rxq->ring = rx_ring;
1294 rp->dp_rxq[queue_id].mp = mp;
1295 rp->dp_rxq[queue_id].ref_count++;
1297 sfc_log_init(sa, "done");
1298 sfc_put_adapter(sa);
1304 sfc_repr_proxy_del_rxq(uint16_t pf_port_id, uint16_t repr_id,
1307 struct sfc_repr_proxy_port *port;
1308 struct sfc_repr_proxy_rxq *rxq;
1309 struct sfc_repr_proxy *rp;
1310 struct sfc_adapter *sa;
1312 sa = sfc_get_adapter_by_pf_port_id(pf_port_id);
1313 rp = sfc_repr_proxy_by_adapter(sa);
1315 sfc_log_init(sa, "entry");
1317 port = sfc_repr_proxy_find_port(rp, repr_id);
1319 sfc_err(sa, "%s() failed: no such port", __func__);
1323 rxq = &port->rxq[queue_id];
1326 rxq->mb_pool = NULL;
1327 rp->dp_rxq[queue_id].ref_count--;
1328 if (rp->dp_rxq[queue_id].ref_count == 0)
1329 rp->dp_rxq[queue_id].mp = NULL;
1331 sfc_log_init(sa, "done");
1332 sfc_put_adapter(sa);
1336 sfc_repr_proxy_add_txq(uint16_t pf_port_id, uint16_t repr_id,
1337 uint16_t queue_id, struct rte_ring *tx_ring,
1338 efx_mport_id_t *egress_mport)
1340 struct sfc_repr_proxy_port *port;
1341 struct sfc_repr_proxy_txq *txq;
1342 struct sfc_repr_proxy *rp;
1343 struct sfc_adapter *sa;
1345 sa = sfc_get_adapter_by_pf_port_id(pf_port_id);
1346 rp = sfc_repr_proxy_by_adapter(sa);
1348 sfc_log_init(sa, "entry");
1350 port = sfc_repr_proxy_find_port(rp, repr_id);
1352 sfc_err(sa, "%s() failed: no such port", __func__);
1356 txq = &port->txq[queue_id];
1358 txq->ring = tx_ring;
1360 *egress_mport = port->egress_mport;
1362 sfc_log_init(sa, "done");
1363 sfc_put_adapter(sa);
1369 sfc_repr_proxy_del_txq(uint16_t pf_port_id, uint16_t repr_id,
1372 struct sfc_repr_proxy_port *port;
1373 struct sfc_repr_proxy_txq *txq;
1374 struct sfc_repr_proxy *rp;
1375 struct sfc_adapter *sa;
1377 sa = sfc_get_adapter_by_pf_port_id(pf_port_id);
1378 rp = sfc_repr_proxy_by_adapter(sa);
1380 sfc_log_init(sa, "entry");
1382 port = sfc_repr_proxy_find_port(rp, repr_id);
1384 sfc_err(sa, "%s() failed: no such port", __func__);
1388 txq = &port->txq[queue_id];
1392 sfc_log_init(sa, "done");
1393 sfc_put_adapter(sa);
1397 sfc_repr_proxy_start_repr(uint16_t pf_port_id, uint16_t repr_id)
1399 bool proxy_start_required = false;
1400 struct sfc_repr_proxy_port *port;
1401 struct sfc_repr_proxy *rp;
1402 struct sfc_adapter *sa;
1405 sa = sfc_get_adapter_by_pf_port_id(pf_port_id);
1406 rp = sfc_repr_proxy_by_adapter(sa);
1408 sfc_log_init(sa, "entry");
1410 port = sfc_repr_proxy_find_port(rp, repr_id);
1412 sfc_err(sa, "%s() failed: no such port", __func__);
1414 goto fail_not_found;
1417 if (port->enabled) {
1419 sfc_err(sa, "failed: repr %u proxy port already started",
1421 goto fail_already_started;
1424 if (sa->state == SFC_ETHDEV_STARTED) {
1425 if (sfc_repr_proxy_ports_disabled(rp)) {
1426 proxy_start_required = true;
1428 rc = sfc_repr_proxy_do_start_port(sa, port);
1431 "failed to start repr %u proxy port",
1438 port->enabled = true;
1440 if (proxy_start_required) {
1441 rc = sfc_repr_proxy_start(sa);
1443 sfc_err(sa, "failed to start proxy");
1444 goto fail_proxy_start;
1448 sfc_log_init(sa, "done");
1449 sfc_put_adapter(sa);
1454 port->enabled = false;
1457 fail_already_started:
1459 sfc_err(sa, "failed to start repr %u proxy port: %s", repr_id,
1461 sfc_put_adapter(sa);
1467 sfc_repr_proxy_stop_repr(uint16_t pf_port_id, uint16_t repr_id)
1469 struct sfc_repr_proxy_port *port;
1470 struct sfc_repr_proxy_port *p;
1471 struct sfc_repr_proxy *rp;
1472 struct sfc_adapter *sa;
1475 sa = sfc_get_adapter_by_pf_port_id(pf_port_id);
1476 rp = sfc_repr_proxy_by_adapter(sa);
1478 sfc_log_init(sa, "entry");
1480 port = sfc_repr_proxy_find_port(rp, repr_id);
1482 sfc_err(sa, "%s() failed: no such port", __func__);
1486 if (!port->enabled) {
1487 sfc_log_init(sa, "repr %u proxy port is not started - skip",
1489 sfc_put_adapter(sa);
1493 if (sa->state == SFC_ETHDEV_STARTED) {
1494 bool last_enabled = true;
1496 TAILQ_FOREACH(p, &rp->ports, entries) {
1500 if (sfc_repr_proxy_port_enabled(p)) {
1501 last_enabled = false;
1508 sfc_repr_proxy_stop(sa);
1510 rc = sfc_repr_proxy_do_stop_port(sa, port);
1514 "failed to stop representor proxy TxQ %u: %s",
1515 repr_id, rte_strerror(rc));
1516 sfc_put_adapter(sa);
1521 port->enabled = false;
1523 sfc_log_init(sa, "done");
1524 sfc_put_adapter(sa);