ethdev: add return value to stats get dev op
[dpdk.git] / drivers / net / ring / rte_eth_ring.c
1 /*-
2  *   BSD LICENSE
3  *
4  *   Copyright(c) 2010-2015 Intel Corporation. All rights reserved.
5  *   All rights reserved.
6  *
7  *   Redistribution and use in source and binary forms, with or without
8  *   modification, are permitted provided that the following conditions
9  *   are met:
10  *
11  *     * Redistributions of source code must retain the above copyright
12  *       notice, this list of conditions and the following disclaimer.
13  *     * Redistributions in binary form must reproduce the above copyright
14  *       notice, this list of conditions and the following disclaimer in
15  *       the documentation and/or other materials provided with the
16  *       distribution.
17  *     * Neither the name of Intel Corporation nor the names of its
18  *       contributors may be used to endorse or promote products derived
19  *       from this software without specific prior written permission.
20  *
21  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
27  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32  */
33
34 #include "rte_eth_ring.h"
35 #include <rte_mbuf.h>
36 #include <rte_ethdev.h>
37 #include <rte_malloc.h>
38 #include <rte_memcpy.h>
39 #include <rte_memzone.h>
40 #include <rte_string_fns.h>
41 #include <rte_vdev.h>
42 #include <rte_kvargs.h>
43 #include <rte_errno.h>
44
45 #define ETH_RING_NUMA_NODE_ACTION_ARG   "nodeaction"
46 #define ETH_RING_ACTION_CREATE          "CREATE"
47 #define ETH_RING_ACTION_ATTACH          "ATTACH"
48 #define ETH_RING_INTERNAL_ARG           "internal"
49
50 static const char *valid_arguments[] = {
51         ETH_RING_NUMA_NODE_ACTION_ARG,
52         ETH_RING_INTERNAL_ARG,
53         NULL
54 };
55
56 struct ring_internal_args {
57         struct rte_ring * const *rx_queues;
58         const unsigned int nb_rx_queues;
59         struct rte_ring * const *tx_queues;
60         const unsigned int nb_tx_queues;
61         const unsigned int numa_node;
62         void *addr; /* self addr for sanity check */
63 };
64
65 enum dev_action {
66         DEV_CREATE,
67         DEV_ATTACH
68 };
69
70 struct ring_queue {
71         struct rte_ring *rng;
72         rte_atomic64_t rx_pkts;
73         rte_atomic64_t tx_pkts;
74         rte_atomic64_t err_pkts;
75 };
76
77 struct pmd_internals {
78         unsigned max_rx_queues;
79         unsigned max_tx_queues;
80
81         struct ring_queue rx_ring_queues[RTE_PMD_RING_MAX_RX_RINGS];
82         struct ring_queue tx_ring_queues[RTE_PMD_RING_MAX_TX_RINGS];
83
84         struct ether_addr address;
85         enum dev_action action;
86 };
87
88
89 static struct rte_eth_link pmd_link = {
90                 .link_speed = ETH_SPEED_NUM_10G,
91                 .link_duplex = ETH_LINK_FULL_DUPLEX,
92                 .link_status = ETH_LINK_DOWN,
93                 .link_autoneg = ETH_LINK_SPEED_AUTONEG
94 };
95
96 static uint16_t
97 eth_ring_rx(void *q, struct rte_mbuf **bufs, uint16_t nb_bufs)
98 {
99         void **ptrs = (void *)&bufs[0];
100         struct ring_queue *r = q;
101         const uint16_t nb_rx = (uint16_t)rte_ring_dequeue_burst(r->rng,
102                         ptrs, nb_bufs, NULL);
103         if (r->rng->flags & RING_F_SC_DEQ)
104                 r->rx_pkts.cnt += nb_rx;
105         else
106                 rte_atomic64_add(&(r->rx_pkts), nb_rx);
107         return nb_rx;
108 }
109
110 static uint16_t
111 eth_ring_tx(void *q, struct rte_mbuf **bufs, uint16_t nb_bufs)
112 {
113         void **ptrs = (void *)&bufs[0];
114         struct ring_queue *r = q;
115         const uint16_t nb_tx = (uint16_t)rte_ring_enqueue_burst(r->rng,
116                         ptrs, nb_bufs, NULL);
117         if (r->rng->flags & RING_F_SP_ENQ) {
118                 r->tx_pkts.cnt += nb_tx;
119                 r->err_pkts.cnt += nb_bufs - nb_tx;
120         } else {
121                 rte_atomic64_add(&(r->tx_pkts), nb_tx);
122                 rte_atomic64_add(&(r->err_pkts), nb_bufs - nb_tx);
123         }
124         return nb_tx;
125 }
126
127 static int
128 eth_dev_configure(struct rte_eth_dev *dev __rte_unused) { return 0; }
129
130 static int
131 eth_dev_start(struct rte_eth_dev *dev)
132 {
133         dev->data->dev_link.link_status = ETH_LINK_UP;
134         return 0;
135 }
136
137 static void
138 eth_dev_stop(struct rte_eth_dev *dev)
139 {
140         dev->data->dev_link.link_status = ETH_LINK_DOWN;
141 }
142
143 static int
144 eth_dev_set_link_down(struct rte_eth_dev *dev)
145 {
146         dev->data->dev_link.link_status = ETH_LINK_DOWN;
147         return 0;
148 }
149
150 static int
151 eth_dev_set_link_up(struct rte_eth_dev *dev)
152 {
153         dev->data->dev_link.link_status = ETH_LINK_UP;
154         return 0;
155 }
156
157 static int
158 eth_rx_queue_setup(struct rte_eth_dev *dev, uint16_t rx_queue_id,
159                                     uint16_t nb_rx_desc __rte_unused,
160                                     unsigned int socket_id __rte_unused,
161                                     const struct rte_eth_rxconf *rx_conf __rte_unused,
162                                     struct rte_mempool *mb_pool __rte_unused)
163 {
164         struct pmd_internals *internals = dev->data->dev_private;
165         dev->data->rx_queues[rx_queue_id] = &internals->rx_ring_queues[rx_queue_id];
166         return 0;
167 }
168
169 static int
170 eth_tx_queue_setup(struct rte_eth_dev *dev, uint16_t tx_queue_id,
171                                     uint16_t nb_tx_desc __rte_unused,
172                                     unsigned int socket_id __rte_unused,
173                                     const struct rte_eth_txconf *tx_conf __rte_unused)
174 {
175         struct pmd_internals *internals = dev->data->dev_private;
176         dev->data->tx_queues[tx_queue_id] = &internals->tx_ring_queues[tx_queue_id];
177         return 0;
178 }
179
180
181 static void
182 eth_dev_info(struct rte_eth_dev *dev,
183                 struct rte_eth_dev_info *dev_info)
184 {
185         struct pmd_internals *internals = dev->data->dev_private;
186         dev_info->max_mac_addrs = 1;
187         dev_info->max_rx_pktlen = (uint32_t)-1;
188         dev_info->max_rx_queues = (uint16_t)internals->max_rx_queues;
189         dev_info->max_tx_queues = (uint16_t)internals->max_tx_queues;
190         dev_info->min_rx_bufsize = 0;
191 }
192
193 static int
194 eth_stats_get(struct rte_eth_dev *dev, struct rte_eth_stats *stats)
195 {
196         unsigned i;
197         unsigned long rx_total = 0, tx_total = 0, tx_err_total = 0;
198         const struct pmd_internals *internal = dev->data->dev_private;
199
200         for (i = 0; i < RTE_ETHDEV_QUEUE_STAT_CNTRS &&
201                         i < dev->data->nb_rx_queues; i++) {
202                 stats->q_ipackets[i] = internal->rx_ring_queues[i].rx_pkts.cnt;
203                 rx_total += stats->q_ipackets[i];
204         }
205
206         for (i = 0; i < RTE_ETHDEV_QUEUE_STAT_CNTRS &&
207                         i < dev->data->nb_tx_queues; i++) {
208                 stats->q_opackets[i] = internal->tx_ring_queues[i].tx_pkts.cnt;
209                 stats->q_errors[i] = internal->tx_ring_queues[i].err_pkts.cnt;
210                 tx_total += stats->q_opackets[i];
211                 tx_err_total += stats->q_errors[i];
212         }
213
214         stats->ipackets = rx_total;
215         stats->opackets = tx_total;
216         stats->oerrors = tx_err_total;
217
218         return 0;
219 }
220
221 static void
222 eth_stats_reset(struct rte_eth_dev *dev)
223 {
224         unsigned i;
225         struct pmd_internals *internal = dev->data->dev_private;
226         for (i = 0; i < dev->data->nb_rx_queues; i++)
227                 internal->rx_ring_queues[i].rx_pkts.cnt = 0;
228         for (i = 0; i < dev->data->nb_tx_queues; i++) {
229                 internal->tx_ring_queues[i].tx_pkts.cnt = 0;
230                 internal->tx_ring_queues[i].err_pkts.cnt = 0;
231         }
232 }
233
234 static void
235 eth_mac_addr_remove(struct rte_eth_dev *dev __rte_unused,
236         uint32_t index __rte_unused)
237 {
238 }
239
240 static int
241 eth_mac_addr_add(struct rte_eth_dev *dev __rte_unused,
242         struct ether_addr *mac_addr __rte_unused,
243         uint32_t index __rte_unused,
244         uint32_t vmdq __rte_unused)
245 {
246         return 0;
247 }
248
249 static void
250 eth_queue_release(void *q __rte_unused) { ; }
251 static int
252 eth_link_update(struct rte_eth_dev *dev __rte_unused,
253                 int wait_to_complete __rte_unused) { return 0; }
254
255 static const struct eth_dev_ops ops = {
256         .dev_start = eth_dev_start,
257         .dev_stop = eth_dev_stop,
258         .dev_set_link_up = eth_dev_set_link_up,
259         .dev_set_link_down = eth_dev_set_link_down,
260         .dev_configure = eth_dev_configure,
261         .dev_infos_get = eth_dev_info,
262         .rx_queue_setup = eth_rx_queue_setup,
263         .tx_queue_setup = eth_tx_queue_setup,
264         .rx_queue_release = eth_queue_release,
265         .tx_queue_release = eth_queue_release,
266         .link_update = eth_link_update,
267         .stats_get = eth_stats_get,
268         .stats_reset = eth_stats_reset,
269         .mac_addr_remove = eth_mac_addr_remove,
270         .mac_addr_add = eth_mac_addr_add,
271 };
272
273 static struct rte_vdev_driver pmd_ring_drv;
274
275 static int
276 do_eth_dev_ring_create(const char *name,
277                 struct rte_ring * const rx_queues[], const unsigned nb_rx_queues,
278                 struct rte_ring *const tx_queues[], const unsigned nb_tx_queues,
279                 const unsigned int numa_node, enum dev_action action,
280                 struct rte_eth_dev **eth_dev_p)
281 {
282         struct rte_eth_dev_data *data = NULL;
283         struct pmd_internals *internals = NULL;
284         struct rte_eth_dev *eth_dev = NULL;
285         void **rx_queues_local = NULL;
286         void **tx_queues_local = NULL;
287         unsigned i;
288
289         RTE_LOG(INFO, PMD, "Creating rings-backed ethdev on numa socket %u\n",
290                         numa_node);
291
292         /* now do all data allocation - for eth_dev structure, dummy pci driver
293          * and internal (private) data
294          */
295         data = rte_zmalloc_socket(name, sizeof(*data), 0, numa_node);
296         if (data == NULL) {
297                 rte_errno = ENOMEM;
298                 goto error;
299         }
300
301         rx_queues_local = rte_zmalloc_socket(name,
302                         sizeof(void *) * nb_rx_queues, 0, numa_node);
303         if (rx_queues_local == NULL) {
304                 rte_errno = ENOMEM;
305                 goto error;
306         }
307
308         tx_queues_local = rte_zmalloc_socket(name,
309                         sizeof(void *) * nb_tx_queues, 0, numa_node);
310         if (tx_queues_local == NULL) {
311                 rte_errno = ENOMEM;
312                 goto error;
313         }
314
315         internals = rte_zmalloc_socket(name, sizeof(*internals), 0, numa_node);
316         if (internals == NULL) {
317                 rte_errno = ENOMEM;
318                 goto error;
319         }
320
321         /* reserve an ethdev entry */
322         eth_dev = rte_eth_dev_allocate(name);
323         if (eth_dev == NULL) {
324                 rte_errno = ENOSPC;
325                 goto error;
326         }
327
328         /* now put it all together
329          * - store queue data in internals,
330          * - store numa_node info in eth_dev_data
331          * - point eth_dev_data to internals
332          * - and point eth_dev structure to new eth_dev_data structure
333          */
334         /* NOTE: we'll replace the data element, of originally allocated eth_dev
335          * so the rings are local per-process */
336
337         rte_memcpy(data, eth_dev->data, sizeof(*data));
338         data->rx_queues = rx_queues_local;
339         data->tx_queues = tx_queues_local;
340
341         internals->action = action;
342         internals->max_rx_queues = nb_rx_queues;
343         internals->max_tx_queues = nb_tx_queues;
344         for (i = 0; i < nb_rx_queues; i++) {
345                 internals->rx_ring_queues[i].rng = rx_queues[i];
346                 data->rx_queues[i] = &internals->rx_ring_queues[i];
347         }
348         for (i = 0; i < nb_tx_queues; i++) {
349                 internals->tx_ring_queues[i].rng = tx_queues[i];
350                 data->tx_queues[i] = &internals->tx_ring_queues[i];
351         }
352
353         data->dev_private = internals;
354         data->nb_rx_queues = (uint16_t)nb_rx_queues;
355         data->nb_tx_queues = (uint16_t)nb_tx_queues;
356         data->dev_link = pmd_link;
357         data->mac_addrs = &internals->address;
358
359         eth_dev->data = data;
360         eth_dev->dev_ops = &ops;
361         data->dev_flags = RTE_ETH_DEV_DETACHABLE;
362         data->kdrv = RTE_KDRV_NONE;
363         data->numa_node = numa_node;
364
365         /* finally assign rx and tx ops */
366         eth_dev->rx_pkt_burst = eth_ring_rx;
367         eth_dev->tx_pkt_burst = eth_ring_tx;
368
369         *eth_dev_p = eth_dev;
370
371         return data->port_id;
372
373 error:
374         rte_free(rx_queues_local);
375         rte_free(tx_queues_local);
376         rte_free(data);
377         rte_free(internals);
378
379         return -1;
380 }
381
382 int
383 rte_eth_from_rings(const char *name, struct rte_ring *const rx_queues[],
384                 const unsigned nb_rx_queues,
385                 struct rte_ring *const tx_queues[],
386                 const unsigned nb_tx_queues,
387                 const unsigned numa_node)
388 {
389         struct ring_internal_args args = {
390                 .rx_queues = rx_queues,
391                 .nb_rx_queues = nb_rx_queues,
392                 .tx_queues = tx_queues,
393                 .nb_tx_queues = nb_tx_queues,
394                 .numa_node = numa_node,
395                 .addr = &args,
396         };
397         char args_str[32] = { 0 };
398         char ring_name[32] = { 0 };
399         uint16_t port_id = RTE_MAX_ETHPORTS;
400         int ret;
401
402         /* do some parameter checking */
403         if (rx_queues == NULL && nb_rx_queues > 0) {
404                 rte_errno = EINVAL;
405                 return -1;
406         }
407         if (tx_queues == NULL && nb_tx_queues > 0) {
408                 rte_errno = EINVAL;
409                 return -1;
410         }
411         if (nb_rx_queues > RTE_PMD_RING_MAX_RX_RINGS) {
412                 rte_errno = EINVAL;
413                 return -1;
414         }
415
416         snprintf(args_str, 32, "%s=%p", ETH_RING_INTERNAL_ARG, &args);
417         snprintf(ring_name, 32, "net_ring_%s", name);
418
419         ret = rte_vdev_init(ring_name, args_str);
420         if (ret) {
421                 rte_errno = EINVAL;
422                 return -1;
423         }
424
425         rte_eth_dev_get_port_by_name(ring_name, &port_id);
426
427         return port_id;
428 }
429
430 int
431 rte_eth_from_ring(struct rte_ring *r)
432 {
433         return rte_eth_from_rings(r->name, &r, 1, &r, 1,
434                         r->memzone ? r->memzone->socket_id : SOCKET_ID_ANY);
435 }
436
437 static int
438 eth_dev_ring_create(const char *name, const unsigned numa_node,
439                 enum dev_action action, struct rte_eth_dev **eth_dev)
440 {
441         /* rx and tx are so-called from point of view of first port.
442          * They are inverted from the point of view of second port
443          */
444         struct rte_ring *rxtx[RTE_PMD_RING_MAX_RX_RINGS];
445         unsigned i;
446         char rng_name[RTE_RING_NAMESIZE];
447         unsigned num_rings = RTE_MIN(RTE_PMD_RING_MAX_RX_RINGS,
448                         RTE_PMD_RING_MAX_TX_RINGS);
449
450         for (i = 0; i < num_rings; i++) {
451                 snprintf(rng_name, sizeof(rng_name), "ETH_RXTX%u_%s", i, name);
452                 rxtx[i] = (action == DEV_CREATE) ?
453                                 rte_ring_create(rng_name, 1024, numa_node,
454                                                 RING_F_SP_ENQ|RING_F_SC_DEQ) :
455                                 rte_ring_lookup(rng_name);
456                 if (rxtx[i] == NULL)
457                         return -1;
458         }
459
460         if (do_eth_dev_ring_create(name, rxtx, num_rings, rxtx, num_rings,
461                 numa_node, action, eth_dev) < 0)
462                 return -1;
463
464         return 0;
465 }
466
467 struct node_action_pair {
468         char name[PATH_MAX];
469         unsigned node;
470         enum dev_action action;
471 };
472
473 struct node_action_list {
474         unsigned total;
475         unsigned count;
476         struct node_action_pair *list;
477 };
478
479 static int parse_kvlist (const char *key __rte_unused, const char *value, void *data)
480 {
481         struct node_action_list *info = data;
482         int ret;
483         char *name;
484         char *action;
485         char *node;
486         char *end;
487
488         name = strdup(value);
489
490         ret = -EINVAL;
491
492         if (!name) {
493                 RTE_LOG(WARNING, PMD, "command line parameter is empty for ring pmd!\n");
494                 goto out;
495         }
496
497         node = strchr(name, ':');
498         if (!node) {
499                 RTE_LOG(WARNING, PMD, "could not parse node value from %s\n",
500                         name);
501                 goto out;
502         }
503
504         *node = '\0';
505         node++;
506
507         action = strchr(node, ':');
508         if (!action) {
509                 RTE_LOG(WARNING, PMD, "could not parse action value from %s\n",
510                         node);
511                 goto out;
512         }
513
514         *action = '\0';
515         action++;
516
517         /*
518          * Need to do some sanity checking here
519          */
520
521         if (strcmp(action, ETH_RING_ACTION_ATTACH) == 0)
522                 info->list[info->count].action = DEV_ATTACH;
523         else if (strcmp(action, ETH_RING_ACTION_CREATE) == 0)
524                 info->list[info->count].action = DEV_CREATE;
525         else
526                 goto out;
527
528         errno = 0;
529         info->list[info->count].node = strtol(node, &end, 10);
530
531         if ((errno != 0) || (*end != '\0')) {
532                 RTE_LOG(WARNING, PMD, "node value %s is unparseable as a number\n", node);
533                 goto out;
534         }
535
536         snprintf(info->list[info->count].name, sizeof(info->list[info->count].name), "%s", name);
537
538         info->count++;
539
540         ret = 0;
541 out:
542         free(name);
543         return ret;
544 }
545
546 static int
547 parse_internal_args(const char *key __rte_unused, const char *value,
548                 void *data)
549 {
550         struct ring_internal_args **internal_args = data;
551         void *args;
552
553         sscanf(value, "%p", &args);
554
555         *internal_args = args;
556
557         if ((*internal_args)->addr != args)
558                 return -1;
559
560         return 0;
561 }
562
563 static int
564 rte_pmd_ring_probe(struct rte_vdev_device *dev)
565 {
566         const char *name, *params;
567         struct rte_kvargs *kvlist = NULL;
568         int ret = 0;
569         struct node_action_list *info = NULL;
570         struct rte_eth_dev *eth_dev = NULL;
571         struct ring_internal_args *internal_args;
572
573         name = rte_vdev_device_name(dev);
574         params = rte_vdev_device_args(dev);
575
576         RTE_LOG(INFO, PMD, "Initializing pmd_ring for %s\n", name);
577
578         if (params == NULL || params[0] == '\0') {
579                 ret = eth_dev_ring_create(name, rte_socket_id(), DEV_CREATE,
580                                 &eth_dev);
581                 if (ret == -1) {
582                         RTE_LOG(INFO, PMD,
583                                 "Attach to pmd_ring for %s\n", name);
584                         ret = eth_dev_ring_create(name, rte_socket_id(),
585                                                   DEV_ATTACH, &eth_dev);
586                 }
587         } else {
588                 kvlist = rte_kvargs_parse(params, valid_arguments);
589
590                 if (!kvlist) {
591                         RTE_LOG(INFO, PMD, "Ignoring unsupported parameters when creating"
592                                         " rings-backed ethernet device\n");
593                         ret = eth_dev_ring_create(name, rte_socket_id(),
594                                                   DEV_CREATE, &eth_dev);
595                         if (ret == -1) {
596                                 RTE_LOG(INFO, PMD,
597                                         "Attach to pmd_ring for %s\n",
598                                         name);
599                                 ret = eth_dev_ring_create(name, rte_socket_id(),
600                                                           DEV_ATTACH, &eth_dev);
601                         }
602
603                         if (eth_dev)
604                                 eth_dev->device = &dev->device;
605
606                         return ret;
607                 }
608
609                 if (rte_kvargs_count(kvlist, ETH_RING_INTERNAL_ARG) == 1) {
610                         ret = rte_kvargs_process(kvlist, ETH_RING_INTERNAL_ARG,
611                                                  parse_internal_args,
612                                                  &internal_args);
613                         if (ret < 0)
614                                 goto out_free;
615
616                         ret = do_eth_dev_ring_create(name,
617                                 internal_args->rx_queues,
618                                 internal_args->nb_rx_queues,
619                                 internal_args->tx_queues,
620                                 internal_args->nb_tx_queues,
621                                 internal_args->numa_node,
622                                 DEV_ATTACH,
623                                 &eth_dev);
624                         if (ret >= 0)
625                                 ret = 0;
626                 } else {
627                         ret = rte_kvargs_count(kvlist, ETH_RING_NUMA_NODE_ACTION_ARG);
628                         info = rte_zmalloc("struct node_action_list",
629                                            sizeof(struct node_action_list) +
630                                            (sizeof(struct node_action_pair) * ret),
631                                            0);
632                         if (!info)
633                                 goto out_free;
634
635                         info->total = ret;
636                         info->list = (struct node_action_pair*)(info + 1);
637
638                         ret = rte_kvargs_process(kvlist, ETH_RING_NUMA_NODE_ACTION_ARG,
639                                                  parse_kvlist, info);
640
641                         if (ret < 0)
642                                 goto out_free;
643
644                         for (info->count = 0; info->count < info->total; info->count++) {
645                                 ret = eth_dev_ring_create(info->list[info->count].name,
646                                                           info->list[info->count].node,
647                                                           info->list[info->count].action,
648                                                           &eth_dev);
649                                 if ((ret == -1) &&
650                                     (info->list[info->count].action == DEV_CREATE)) {
651                                         RTE_LOG(INFO, PMD,
652                                                 "Attach to pmd_ring for %s\n",
653                                                 name);
654                                         ret = eth_dev_ring_create(name,
655                                                         info->list[info->count].node,
656                                                         DEV_ATTACH,
657                                                         &eth_dev);
658                                 }
659                         }
660                 }
661         }
662
663         if (eth_dev)
664                 eth_dev->device = &dev->device;
665
666 out_free:
667         rte_kvargs_free(kvlist);
668         rte_free(info);
669         return ret;
670 }
671
672 static int
673 rte_pmd_ring_remove(struct rte_vdev_device *dev)
674 {
675         const char *name = rte_vdev_device_name(dev);
676         struct rte_eth_dev *eth_dev = NULL;
677         struct pmd_internals *internals = NULL;
678         struct ring_queue *r = NULL;
679         uint16_t i;
680
681         RTE_LOG(INFO, PMD, "Un-Initializing pmd_ring for %s\n", name);
682
683         if (name == NULL)
684                 return -EINVAL;
685
686         /* find an ethdev entry */
687         eth_dev = rte_eth_dev_allocated(name);
688         if (eth_dev == NULL)
689                 return -ENODEV;
690
691         eth_dev_stop(eth_dev);
692
693         internals = eth_dev->data->dev_private;
694         if (internals->action == DEV_CREATE) {
695                 /*
696                  * it is only necessary to delete the rings in rx_queues because
697                  * they are the same used in tx_queues
698                  */
699                 for (i = 0; i < eth_dev->data->nb_rx_queues; i++) {
700                         r = eth_dev->data->rx_queues[i];
701                         rte_ring_free(r->rng);
702                 }
703         }
704
705         rte_free(eth_dev->data->rx_queues);
706         rte_free(eth_dev->data->tx_queues);
707         rte_free(eth_dev->data->dev_private);
708
709         rte_free(eth_dev->data);
710
711         rte_eth_dev_release_port(eth_dev);
712         return 0;
713 }
714
715 static struct rte_vdev_driver pmd_ring_drv = {
716         .probe = rte_pmd_ring_probe,
717         .remove = rte_pmd_ring_remove,
718 };
719
720 RTE_PMD_REGISTER_VDEV(net_ring, pmd_ring_drv);
721 RTE_PMD_REGISTER_ALIAS(net_ring, eth_ring);
722 RTE_PMD_REGISTER_PARAM_STRING(net_ring,
723         ETH_RING_NUMA_NODE_ACTION_ARG "=name:node:action(ATTACH|CREATE)");