LCOV - code coverage report
Current view: top level - drivers/event/dsw - dsw_evdev.c (source / functions) Hit Total Coverage
Test: Code coverage Lines: 1 154 0.6 %
Date: 2024-01-22 16:26:08 Functions: 1 23 4.3 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 57 0.0 %

           Branch data     Line data    Source code
       1                 :            : /* SPDX-License-Identifier: BSD-3-Clause
       2                 :            :  * Copyright(c) 2018 Ericsson AB
       3                 :            :  */
       4                 :            : 
       5                 :            : #include <stdbool.h>
       6                 :            : 
       7                 :            : #include <rte_cycles.h>
       8                 :            : #include <eventdev_pmd.h>
       9                 :            : #include <eventdev_pmd_vdev.h>
      10                 :            : #include <rte_random.h>
      11                 :            : #include <rte_ring_elem.h>
      12                 :            : 
      13                 :            : #include "dsw_evdev.h"
      14                 :            : 
      15                 :            : #define EVENTDEV_NAME_DSW_PMD event_dsw
      16                 :            : 
      17                 :            : static int
      18                 :          0 : dsw_port_setup(struct rte_eventdev *dev, uint8_t port_id,
      19                 :            :                const struct rte_event_port_conf *conf)
      20                 :            : {
      21                 :            :         struct dsw_evdev *dsw = dsw_pmd_priv(dev);
      22                 :            :         struct dsw_port *port;
      23                 :            :         struct rte_event_ring *in_ring;
      24                 :            :         struct rte_ring *ctl_in_ring;
      25                 :            :         char ring_name[RTE_RING_NAMESIZE];
      26                 :            : 
      27                 :          0 :         port = &dsw->ports[port_id];
      28                 :            : 
      29                 :          0 :         *port = (struct dsw_port) {
      30                 :            :                 .id = port_id,
      31                 :            :                 .dsw = dsw,
      32                 :          0 :                 .dequeue_depth = conf->dequeue_depth,
      33                 :          0 :                 .enqueue_depth = conf->enqueue_depth,
      34                 :          0 :                 .new_event_threshold = conf->new_event_threshold
      35                 :            :         };
      36                 :            : 
      37                 :          0 :         snprintf(ring_name, sizeof(ring_name), "dsw%d_p%u", dev->data->dev_id,
      38                 :            :                  port_id);
      39                 :            : 
      40                 :          0 :         in_ring = rte_event_ring_create(ring_name, DSW_IN_RING_SIZE,
      41                 :          0 :                                         dev->data->socket_id,
      42                 :            :                                         RING_F_SC_DEQ|RING_F_EXACT_SZ);
      43                 :            : 
      44         [ #  # ]:          0 :         if (in_ring == NULL)
      45                 :            :                 return -ENOMEM;
      46                 :            : 
      47                 :          0 :         snprintf(ring_name, sizeof(ring_name), "dswctl%d_p%u",
      48                 :          0 :                  dev->data->dev_id, port_id);
      49                 :            : 
      50                 :          0 :         ctl_in_ring = rte_ring_create_elem(ring_name,
      51                 :            :                                            sizeof(struct dsw_ctl_msg),
      52                 :            :                                            DSW_CTL_IN_RING_SIZE,
      53                 :          0 :                                            dev->data->socket_id,
      54                 :            :                                            RING_F_SC_DEQ|RING_F_EXACT_SZ);
      55                 :            : 
      56         [ #  # ]:          0 :         if (ctl_in_ring == NULL) {
      57                 :          0 :                 rte_event_ring_free(in_ring);
      58                 :          0 :                 return -ENOMEM;
      59                 :            :         }
      60                 :            : 
      61                 :          0 :         port->in_ring = in_ring;
      62                 :          0 :         port->ctl_in_ring = ctl_in_ring;
      63                 :            : 
      64                 :          0 :         port->load_update_interval =
      65                 :          0 :                 (DSW_LOAD_UPDATE_INTERVAL * rte_get_timer_hz()) / US_PER_S;
      66                 :            : 
      67                 :          0 :         port->migration_interval =
      68                 :          0 :                 (DSW_MIGRATION_INTERVAL * rte_get_timer_hz()) / US_PER_S;
      69                 :            : 
      70                 :          0 :         dev->data->ports[port_id] = port;
      71                 :            : 
      72                 :          0 :         return 0;
      73                 :            : }
      74                 :            : 
      75                 :            : static void
      76                 :          0 : dsw_port_def_conf(struct rte_eventdev *dev __rte_unused,
      77                 :            :                   uint8_t port_id __rte_unused,
      78                 :            :                   struct rte_event_port_conf *port_conf)
      79                 :            : {
      80                 :          0 :         *port_conf = (struct rte_event_port_conf) {
      81                 :            :                 .new_event_threshold = 1024,
      82                 :            :                 .dequeue_depth = DSW_MAX_PORT_DEQUEUE_DEPTH / 4,
      83                 :            :                 .enqueue_depth = DSW_MAX_PORT_ENQUEUE_DEPTH / 4
      84                 :            :         };
      85                 :          0 : }
      86                 :            : 
      87                 :            : static void
      88                 :          0 : dsw_port_release(void *p)
      89                 :            : {
      90                 :            :         struct dsw_port *port = p;
      91                 :            : 
      92                 :          0 :         rte_event_ring_free(port->in_ring);
      93                 :          0 :         rte_ring_free(port->ctl_in_ring);
      94                 :          0 : }
      95                 :            : 
      96                 :            : static int
      97         [ #  # ]:          0 : dsw_queue_setup(struct rte_eventdev *dev, uint8_t queue_id,
      98                 :            :                 const struct rte_event_queue_conf *conf)
      99                 :            : {
     100                 :            :         struct dsw_evdev *dsw = dsw_pmd_priv(dev);
     101                 :          0 :         struct dsw_queue *queue = &dsw->queues[queue_id];
     102                 :            : 
     103         [ #  # ]:          0 :         if (RTE_EVENT_QUEUE_CFG_ALL_TYPES & conf->event_queue_cfg)
     104                 :            :                 return -ENOTSUP;
     105                 :            : 
     106                 :            :         /* SINGLE_LINK is better off treated as TYPE_ATOMIC, since it
     107                 :            :          * avoid the "fake" TYPE_PARALLEL flow_id assignment. Since
     108                 :            :          * the queue will only have a single serving port, no
     109                 :            :          * migration will ever happen, so the extra TYPE_ATOMIC
     110                 :            :          * migration overhead is avoided.
     111                 :            :          */
     112         [ #  # ]:          0 :         if (RTE_EVENT_QUEUE_CFG_SINGLE_LINK & conf->event_queue_cfg)
     113                 :          0 :                 queue->schedule_type = RTE_SCHED_TYPE_ATOMIC;
     114                 :            :         else {
     115         [ #  # ]:          0 :                 if (conf->schedule_type == RTE_SCHED_TYPE_ORDERED)
     116                 :            :                         return -ENOTSUP;
     117                 :            :                 /* atomic or parallel */
     118                 :          0 :                 queue->schedule_type = conf->schedule_type;
     119                 :            :         }
     120                 :            : 
     121                 :          0 :         queue->num_serving_ports = 0;
     122                 :            : 
     123                 :          0 :         return 0;
     124                 :            : }
     125                 :            : 
     126                 :            : static void
     127                 :          0 : dsw_queue_def_conf(struct rte_eventdev *dev __rte_unused,
     128                 :            :                    uint8_t queue_id __rte_unused,
     129                 :            :                    struct rte_event_queue_conf *queue_conf)
     130                 :            : {
     131                 :          0 :         *queue_conf = (struct rte_event_queue_conf) {
     132                 :            :                 .nb_atomic_flows = 4096,
     133                 :            :                 .schedule_type = RTE_SCHED_TYPE_ATOMIC,
     134                 :            :                 .priority = RTE_EVENT_DEV_PRIORITY_NORMAL
     135                 :            :         };
     136                 :          0 : }
     137                 :            : 
     138                 :            : static void
     139                 :          0 : dsw_queue_release(struct rte_eventdev *dev __rte_unused,
     140                 :            :                   uint8_t queue_id __rte_unused)
     141                 :            : {
     142                 :          0 : }
     143                 :            : 
     144                 :            : static void
     145                 :            : queue_add_port(struct dsw_queue *queue, uint16_t port_id)
     146                 :            : {
     147                 :          0 :         queue->serving_ports[queue->num_serving_ports] = port_id;
     148                 :          0 :         queue->num_serving_ports++;
     149                 :            : }
     150                 :            : 
     151                 :            : static bool
     152                 :            : queue_remove_port(struct dsw_queue *queue, uint16_t port_id)
     153                 :            : {
     154                 :            :         uint16_t i;
     155                 :            : 
     156         [ #  # ]:          0 :         for (i = 0; i < queue->num_serving_ports; i++)
     157         [ #  # ]:          0 :                 if (queue->serving_ports[i] == port_id) {
     158                 :          0 :                         uint16_t last_idx = queue->num_serving_ports - 1;
     159         [ #  # ]:          0 :                         if (i != last_idx)
     160                 :          0 :                                 queue->serving_ports[i] =
     161                 :          0 :                                         queue->serving_ports[last_idx];
     162                 :          0 :                         queue->num_serving_ports--;
     163                 :            :                         return true;
     164                 :            :                 }
     165                 :            :         return false;
     166                 :            : }
     167                 :            : 
     168                 :            : static int
     169                 :          0 : dsw_port_link_unlink(struct rte_eventdev *dev, void *port,
     170                 :            :                      const uint8_t queues[], uint16_t num, bool link)
     171                 :            : {
     172                 :            :         struct dsw_evdev *dsw = dsw_pmd_priv(dev);
     173                 :            :         struct dsw_port *p = port;
     174                 :            :         uint16_t i;
     175                 :            :         uint16_t count = 0;
     176                 :            : 
     177         [ #  # ]:          0 :         for (i = 0; i < num; i++) {
     178                 :          0 :                 uint8_t qid = queues[i];
     179                 :          0 :                 struct dsw_queue *q = &dsw->queues[qid];
     180         [ #  # ]:          0 :                 if (link) {
     181                 :          0 :                         queue_add_port(q, p->id);
     182                 :          0 :                         count++;
     183                 :            :                 } else {
     184                 :          0 :                         bool removed = queue_remove_port(q, p->id);
     185                 :            :                         if (removed)
     186                 :          0 :                                 count++;
     187                 :            :                 }
     188                 :            :         }
     189                 :            : 
     190                 :          0 :         return count;
     191                 :            : }
     192                 :            : 
     193                 :            : static int
     194                 :          0 : dsw_port_link(struct rte_eventdev *dev, void *port, const uint8_t queues[],
     195                 :            :               const uint8_t priorities[] __rte_unused, uint16_t num)
     196                 :            : {
     197                 :          0 :         return dsw_port_link_unlink(dev, port, queues, num, true);
     198                 :            : }
     199                 :            : 
     200                 :            : static int
     201                 :          0 : dsw_port_unlink(struct rte_eventdev *dev, void *port, uint8_t queues[],
     202                 :            :                 uint16_t num)
     203                 :            : {
     204                 :          0 :         return dsw_port_link_unlink(dev, port, queues, num, false);
     205                 :            : }
     206                 :            : 
     207                 :            : static void
     208                 :          0 : dsw_info_get(struct rte_eventdev *dev __rte_unused,
     209                 :            :              struct rte_event_dev_info *info)
     210                 :            : {
     211                 :          0 :         *info = (struct rte_event_dev_info) {
     212                 :            :                 .driver_name = DSW_PMD_NAME,
     213                 :            :                 .max_event_queues = DSW_MAX_QUEUES,
     214                 :            :                 .max_event_queue_flows = DSW_MAX_FLOWS,
     215                 :            :                 .max_event_queue_priority_levels = 1,
     216                 :            :                 .max_event_priority_levels = 1,
     217                 :            :                 .max_event_ports = DSW_MAX_PORTS,
     218                 :            :                 .max_event_port_dequeue_depth = DSW_MAX_PORT_DEQUEUE_DEPTH,
     219                 :            :                 .max_event_port_enqueue_depth = DSW_MAX_PORT_ENQUEUE_DEPTH,
     220                 :            :                 .max_num_events = DSW_MAX_EVENTS,
     221                 :            :                 .max_profiles_per_port = 1,
     222                 :            :                 .event_dev_cap = RTE_EVENT_DEV_CAP_BURST_MODE|
     223                 :            :                 RTE_EVENT_DEV_CAP_DISTRIBUTED_SCHED|
     224                 :            :                 RTE_EVENT_DEV_CAP_NONSEQ_MODE|
     225                 :            :                 RTE_EVENT_DEV_CAP_MULTIPLE_QUEUE_PORT|
     226                 :            :                 RTE_EVENT_DEV_CAP_CARRY_FLOW_ID
     227                 :            :         };
     228                 :          0 : }
     229                 :            : 
     230                 :            : static int
     231                 :          0 : dsw_configure(const struct rte_eventdev *dev)
     232                 :            : {
     233                 :            :         struct dsw_evdev *dsw = dsw_pmd_priv(dev);
     234                 :            :         const struct rte_event_dev_config *conf = &dev->data->dev_conf;
     235                 :            :         int32_t min_max_in_flight;
     236                 :            : 
     237                 :          0 :         dsw->num_ports = conf->nb_event_ports;
     238                 :          0 :         dsw->num_queues = conf->nb_event_queues;
     239                 :            : 
     240                 :            :         /* Avoid a situation where consumer ports are holding all the
     241                 :            :          * credits, without making use of them.
     242                 :            :          */
     243                 :          0 :         min_max_in_flight = conf->nb_event_ports * DSW_PORT_MAX_CREDITS;
     244                 :            : 
     245                 :          0 :         dsw->max_inflight = RTE_MAX(conf->nb_events_limit, min_max_in_flight);
     246                 :            : 
     247                 :          0 :         return 0;
     248                 :            : }
     249                 :            : 
     250                 :            : 
     251                 :            : static void
     252                 :          0 : initial_flow_to_port_assignment(struct dsw_evdev *dsw)
     253                 :            : {
     254                 :            :         uint8_t queue_id;
     255         [ #  # ]:          0 :         for (queue_id = 0; queue_id < dsw->num_queues; queue_id++) {
     256                 :          0 :                 struct dsw_queue *queue = &dsw->queues[queue_id];
     257                 :            :                 uint16_t flow_hash;
     258         [ #  # ]:          0 :                 for (flow_hash = 0; flow_hash < DSW_MAX_FLOWS; flow_hash++) {
     259                 :          0 :                         uint8_t port_idx =
     260                 :          0 :                                 rte_rand() % queue->num_serving_ports;
     261                 :          0 :                         uint8_t port_id =
     262                 :          0 :                                 queue->serving_ports[port_idx];
     263                 :          0 :                         dsw->queues[queue_id].flow_to_port_map[flow_hash] =
     264                 :            :                                 port_id;
     265                 :            :                 }
     266                 :            :         }
     267                 :          0 : }
     268                 :            : 
     269                 :            : static int
     270                 :          0 : dsw_start(struct rte_eventdev *dev)
     271                 :            : {
     272                 :            :         struct dsw_evdev *dsw = dsw_pmd_priv(dev);
     273                 :            :         uint16_t i;
     274                 :            :         uint64_t now;
     275                 :            : 
     276                 :          0 :         dsw->credits_on_loan = 0;
     277                 :            : 
     278                 :          0 :         initial_flow_to_port_assignment(dsw);
     279                 :            : 
     280                 :            :         now = rte_get_timer_cycles();
     281         [ #  # ]:          0 :         for (i = 0; i < dsw->num_ports; i++) {
     282                 :          0 :                 dsw->ports[i].measurement_start = now;
     283                 :          0 :                 dsw->ports[i].busy_start = now;
     284                 :            :         }
     285                 :            : 
     286                 :          0 :         return 0;
     287                 :            : }
     288                 :            : 
     289                 :            : static void
     290                 :            : dsw_port_drain_buf(uint8_t dev_id, struct rte_event *buf, uint16_t buf_len,
     291                 :            :                    eventdev_stop_flush_t flush, void *flush_arg)
     292                 :            : {
     293                 :            :         uint16_t i;
     294                 :            : 
     295   [ #  #  #  # ]:          0 :         for (i = 0; i < buf_len; i++)
     296                 :          0 :                 flush(dev_id, buf[i], flush_arg);
     297                 :            : }
     298                 :            : 
     299                 :            : static void
     300                 :            : dsw_port_drain_paused(uint8_t dev_id, struct dsw_port *port,
     301                 :            :                       eventdev_stop_flush_t flush, void *flush_arg)
     302                 :            : {
     303                 :          0 :         dsw_port_drain_buf(dev_id, port->paused_events, port->paused_events_len,
     304                 :            :                            flush, flush_arg);
     305                 :            : }
     306                 :            : 
     307                 :            : static void
     308                 :            : dsw_port_drain_out(uint8_t dev_id, struct dsw_evdev *dsw, struct dsw_port *port,
     309                 :            :                    eventdev_stop_flush_t flush, void *flush_arg)
     310                 :            : {
     311                 :            :         uint16_t dport_id;
     312                 :            : 
     313         [ #  # ]:          0 :         for (dport_id = 0; dport_id < dsw->num_ports; dport_id++)
     314         [ #  # ]:          0 :                 if (dport_id != port->id)
     315                 :          0 :                         dsw_port_drain_buf(dev_id, port->out_buffer[dport_id],
     316                 :          0 :                                            port->out_buffer_len[dport_id],
     317                 :            :                                            flush, flush_arg);
     318                 :            : }
     319                 :            : 
     320                 :            : static void
     321                 :          0 : dsw_port_drain_in_ring(uint8_t dev_id, struct dsw_port *port,
     322                 :            :                        eventdev_stop_flush_t flush, void *flush_arg)
     323                 :            : {
     324                 :            :         struct rte_event ev;
     325                 :            : 
     326   [ #  #  #  #  :          0 :         while (rte_event_ring_dequeue_burst(port->in_ring, &ev, 1, NULL))
                #  #  # ]
     327                 :          0 :                 flush(dev_id, ev, flush_arg);
     328                 :          0 : }
     329                 :            : 
     330                 :            : static void
     331                 :          0 : dsw_drain(uint8_t dev_id, struct dsw_evdev *dsw,
     332                 :            :           eventdev_stop_flush_t flush, void *flush_arg)
     333                 :            : {
     334                 :            :         uint16_t port_id;
     335                 :            : 
     336         [ #  # ]:          0 :         if (flush == NULL)
     337                 :            :                 return;
     338                 :            : 
     339         [ #  # ]:          0 :         for (port_id = 0; port_id < dsw->num_ports; port_id++) {
     340                 :          0 :                 struct dsw_port *port = &dsw->ports[port_id];
     341                 :            : 
     342                 :          0 :                 dsw_port_drain_out(dev_id, dsw, port, flush, flush_arg);
     343                 :            :                 dsw_port_drain_paused(dev_id, port, flush, flush_arg);
     344                 :          0 :                 dsw_port_drain_in_ring(dev_id, port, flush, flush_arg);
     345                 :            :         }
     346                 :            : }
     347                 :            : 
     348                 :            : static void
     349                 :          0 : dsw_stop(struct rte_eventdev *dev)
     350                 :            : {
     351                 :            :         struct dsw_evdev *dsw = dsw_pmd_priv(dev);
     352                 :            :         uint8_t dev_id;
     353                 :            :         eventdev_stop_flush_t flush;
     354                 :            :         void *flush_arg;
     355                 :            : 
     356                 :          0 :         dev_id = dev->data->dev_id;
     357                 :          0 :         flush = dev->dev_ops->dev_stop_flush;
     358                 :          0 :         flush_arg = dev->data->dev_stop_flush_arg;
     359                 :            : 
     360                 :          0 :         dsw_drain(dev_id, dsw, flush, flush_arg);
     361                 :          0 : }
     362                 :            : 
     363                 :            : static int
     364                 :          0 : dsw_close(struct rte_eventdev *dev)
     365                 :            : {
     366                 :            :         struct dsw_evdev *dsw = dsw_pmd_priv(dev);
     367                 :            :         uint16_t port_id;
     368                 :            : 
     369         [ #  # ]:          0 :         for (port_id = 0; port_id < dsw->num_ports; port_id++)
     370                 :          0 :                 dsw_port_release(&dsw->ports[port_id]);
     371                 :            : 
     372                 :          0 :         dsw->num_ports = 0;
     373                 :          0 :         dsw->num_queues = 0;
     374                 :            : 
     375                 :          0 :         return 0;
     376                 :            : }
     377                 :            : 
     378                 :            : static int
     379                 :          0 : dsw_eth_rx_adapter_caps_get(const struct rte_eventdev *dev __rte_unused,
     380                 :            :                             const struct rte_eth_dev *eth_dev __rte_unused,
     381                 :            :                             uint32_t *caps)
     382                 :            : {
     383                 :          0 :         *caps = RTE_EVENT_ETH_RX_ADAPTER_SW_CAP;
     384                 :          0 :         return 0;
     385                 :            : }
     386                 :            : 
     387                 :            : static int
     388                 :          0 : dsw_timer_adapter_caps_get(const struct rte_eventdev *dev __rte_unused,
     389                 :            :                            uint64_t flags __rte_unused, uint32_t *caps,
     390                 :            :                            const struct event_timer_adapter_ops **ops)
     391                 :            : {
     392                 :          0 :         *caps = 0;
     393                 :          0 :         *ops = NULL;
     394                 :          0 :         return 0;
     395                 :            : }
     396                 :            : 
     397                 :            : static int
     398                 :          0 : dsw_crypto_adapter_caps_get(const struct rte_eventdev *dev  __rte_unused,
     399                 :            :                             const struct rte_cryptodev *cdev  __rte_unused,
     400                 :            :                             uint32_t *caps)
     401                 :            : {
     402                 :          0 :         *caps = RTE_EVENT_CRYPTO_ADAPTER_SW_CAP;
     403                 :          0 :         return 0;
     404                 :            : }
     405                 :            : 
     406                 :            : static struct eventdev_ops dsw_evdev_ops = {
     407                 :            :         .port_setup = dsw_port_setup,
     408                 :            :         .port_def_conf = dsw_port_def_conf,
     409                 :            :         .port_release = dsw_port_release,
     410                 :            :         .queue_setup = dsw_queue_setup,
     411                 :            :         .queue_def_conf = dsw_queue_def_conf,
     412                 :            :         .queue_release = dsw_queue_release,
     413                 :            :         .port_link = dsw_port_link,
     414                 :            :         .port_unlink = dsw_port_unlink,
     415                 :            :         .dev_infos_get = dsw_info_get,
     416                 :            :         .dev_configure = dsw_configure,
     417                 :            :         .dev_start = dsw_start,
     418                 :            :         .dev_stop = dsw_stop,
     419                 :            :         .dev_close = dsw_close,
     420                 :            :         .eth_rx_adapter_caps_get = dsw_eth_rx_adapter_caps_get,
     421                 :            :         .timer_adapter_caps_get = dsw_timer_adapter_caps_get,
     422                 :            :         .crypto_adapter_caps_get = dsw_crypto_adapter_caps_get,
     423                 :            :         .xstats_get = dsw_xstats_get,
     424                 :            :         .xstats_get_names = dsw_xstats_get_names,
     425                 :            :         .xstats_get_by_name = dsw_xstats_get_by_name
     426                 :            : };
     427                 :            : 
     428                 :            : static int
     429         [ #  # ]:          0 : dsw_probe(struct rte_vdev_device *vdev)
     430                 :            : {
     431                 :            :         const char *name;
     432                 :            :         struct rte_eventdev *dev;
     433                 :            :         struct dsw_evdev *dsw;
     434                 :            : 
     435                 :            :         name = rte_vdev_device_name(vdev);
     436                 :            : 
     437                 :          0 :         dev = rte_event_pmd_vdev_init(name, sizeof(struct dsw_evdev),
     438                 :          0 :                                       rte_socket_id(), vdev);
     439         [ #  # ]:          0 :         if (dev == NULL)
     440                 :            :                 return -EFAULT;
     441                 :            : 
     442                 :          0 :         dev->dev_ops = &dsw_evdev_ops;
     443                 :          0 :         dev->enqueue = dsw_event_enqueue;
     444                 :          0 :         dev->enqueue_burst = dsw_event_enqueue_burst;
     445                 :          0 :         dev->enqueue_new_burst = dsw_event_enqueue_new_burst;
     446                 :          0 :         dev->enqueue_forward_burst = dsw_event_enqueue_forward_burst;
     447                 :          0 :         dev->dequeue = dsw_event_dequeue;
     448                 :          0 :         dev->dequeue_burst = dsw_event_dequeue_burst;
     449                 :          0 :         dev->maintain = dsw_event_maintain;
     450                 :            : 
     451         [ #  # ]:          0 :         if (rte_eal_process_type() != RTE_PROC_PRIMARY)
     452                 :            :                 return 0;
     453                 :            : 
     454                 :          0 :         dsw = dev->data->dev_private;
     455                 :          0 :         dsw->data = dev->data;
     456                 :            : 
     457                 :          0 :         event_dev_probing_finish(dev);
     458                 :          0 :         return 0;
     459                 :            : }
     460                 :            : 
     461                 :            : static int
     462         [ #  # ]:          0 : dsw_remove(struct rte_vdev_device *vdev)
     463                 :            : {
     464                 :            :         const char *name;
     465                 :            : 
     466                 :            :         name = rte_vdev_device_name(vdev);
     467                 :            :         if (name == NULL)
     468                 :            :                 return -EINVAL;
     469                 :            : 
     470                 :          0 :         return rte_event_pmd_vdev_uninit(name);
     471                 :            : }
     472                 :            : 
     473                 :            : static struct rte_vdev_driver evdev_dsw_pmd_drv = {
     474                 :            :         .probe = dsw_probe,
     475                 :            :         .remove = dsw_remove
     476                 :            : };
     477                 :            : 
     478                 :        235 : RTE_PMD_REGISTER_VDEV(EVENTDEV_NAME_DSW_PMD, evdev_dsw_pmd_drv);

Generated by: LCOV version 1.14