examples/l3fwd: fix error checking

[dpdk.git] / examples / ntb / ntb_fwd.c

diff --git a/examples/ntb/ntb_fwd.c b/examples/ntb/ntb_fwd.c
index b1ea71c..eba8ebf 100644 (file)
--- a/examples/ntb/ntb_fwd.c
+++ b/examples/ntb/ntb_fwd.c
@@ -19,6 +19,7 @@
 #include <rte_lcore.h>
 #include <rte_cycles.h>
 #include <rte_pmd_ntb.h>
+#include <rte_mbuf_pool_ops.h>
 
 /* Per-port statistics struct */
 struct ntb_port_statistics {
@@ -108,9 +109,9 @@ struct cmd_help_result {
 };
 
 static void
-cmd_help_parsed(__attribute__((unused)) void *parsed_result,
+cmd_help_parsed(__rte_unused void *parsed_result,
                struct cmdline *cl,
-               __attribute__((unused)) void *data)
+               __rte_unused void *data)
 {
        cmdline_printf(
                cl,
@@ -153,12 +154,12 @@ struct cmd_quit_result {
 };
 
 static void
-cmd_quit_parsed(__attribute__((unused)) void *parsed_result,
+cmd_quit_parsed(__rte_unused void *parsed_result,
                struct cmdline *cl,
-               __attribute__((unused)) void *data)
+               __rte_unused void *data)
 {
        struct ntb_fwd_lcore_conf *conf;
-       uint8_t lcore_id;
+       uint32_t lcore_id;
 
        /* Stop transmission first. */
        RTE_LCORE_FOREACH_SLAVE(lcore_id) {
@@ -208,19 +209,20 @@ struct cmd_sendfile_result {
 
 static void
 cmd_sendfile_parsed(void *parsed_result,
-                   __attribute__((unused)) struct cmdline *cl,
-                   __attribute__((unused)) void *data)
+                   __rte_unused struct cmdline *cl,
+                   __rte_unused void *data)
 {
        struct cmd_sendfile_result *res = parsed_result;
        struct rte_rawdev_buf *pkts_send[NTB_MAX_PKT_BURST];
        struct rte_mbuf *mbuf_send[NTB_MAX_PKT_BURST];
-       uint64_t size, count, i, nb_burst;
+       uint64_t size, count, i, j, nb_burst;
        uint16_t nb_tx, buf_size;
        unsigned int nb_pkt;
        size_t queue_id = 0;
        uint16_t retry = 0;
        uint32_t val;
        FILE *file;
+       int ret;
 
        if (num_queues != 1) {
                printf("File transmission only supports 1 queue.\n");
@@ -289,21 +291,37 @@ cmd_sendfile_parsed(void *parsed_result,
                        }
                }
 
-               nb_tx = rte_rawdev_enqueue_buffers(dev_id, pkts_send, nb_pkt,
-                                                  (void *)queue_id);
+               ret = rte_rawdev_enqueue_buffers(dev_id, pkts_send, nb_pkt,
+                                               (void *)queue_id);
+               if (ret < 0) {
+                       printf("Enqueue failed with err %d\n", ret);
+                       for (j = 0; j < nb_pkt; j++)
+                               rte_pktmbuf_free(mbuf_send[j]);
+                       goto clean;
+               }
+               nb_tx = ret;
                while (nb_tx != nb_pkt && retry < BURST_TX_RETRIES) {
                        rte_delay_us(1);
-                       nb_tx += rte_rawdev_enqueue_buffers(dev_id,
-                               &pkts_send[nb_tx], nb_pkt - nb_tx,
-                               (void *)queue_id);
+                       ret = rte_rawdev_enqueue_buffers(dev_id,
+                                       &pkts_send[nb_tx], nb_pkt - nb_tx,
+                                       (void *)queue_id);
+                       if (ret < 0) {
+                               printf("Enqueue failed with err %d\n", ret);
+                               for (j = nb_tx; j < nb_pkt; j++)
+                                       rte_pktmbuf_free(mbuf_send[j]);
+                               goto clean;
+                       }
+                       nb_tx += ret;
                }
                count -= nb_pkt;
        }
+
        /* Clear register after file sending done. */
        rte_rawdev_set_attr(dev_id, "spad_user_0", 0);
        rte_rawdev_set_attr(dev_id, "spad_user_1", 0);
        printf("Done sending file.\n");
 
+clean:
        for (i = 0; i < NTB_MAX_PKT_BURST; i++)
                free(pkts_send[i]);
        fclose(file);
@@ -339,6 +357,7 @@ start_polling_recv_file(void *param)
        uint16_t nb_rx, i, file_no;
        size_t queue_id = 0;
        FILE *file;
+       int ret;
 
        for (i = 0; i < NTB_MAX_PKT_BURST; i++)
                pkts_recv[i] = (struct rte_rawdev_buf *)
@@ -366,8 +385,14 @@ start_polling_recv_file(void *param)
                file_len = 0;
                nb_rx = NTB_MAX_PKT_BURST;
                while (file_len < size && !conf->stopped) {
-                       nb_rx = rte_rawdev_dequeue_buffers(dev_id, pkts_recv,
-                                               pkt_burst, (void *)queue_id);
+                       ret = rte_rawdev_dequeue_buffers(dev_id, pkts_recv,
+                                       pkt_burst, (void *)queue_id);
+                       if (ret < 0) {
+                               printf("Dequeue failed with err %d\n", ret);
+                               fclose(file);
+                               goto clean;
+                       }
+                       nb_rx = ret;
                        ntb_port_stats[0].rx += nb_rx;
                        for (i = 0; i < nb_rx; i++) {
                                mbuf = pkts_recv[i]->buf_addr;
@@ -385,6 +410,7 @@ start_polling_recv_file(void *param)
                file_no++;
        }
 
+clean:
        for (i = 0; i < NTB_MAX_PKT_BURST; i++)
                free(pkts_recv[i]);
        return 0;
@@ -398,7 +424,7 @@ start_iofwd_per_lcore(void *param)
        struct ntb_fwd_lcore_conf *conf = param;
        struct ntb_fwd_stream fs;
        uint16_t nb_rx, nb_tx;
-       int i, j;
+       int i, j, ret;
 
        for (i = 0; i < NTB_MAX_PKT_BURST; i++)
                ntb_buf[i] = (struct rte_rawdev_buf *)
@@ -415,17 +441,29 @@ start_iofwd_per_lcore(void *param)
                                        continue;
                                for (j = 0; j < nb_rx; j++)
                                        ntb_buf[j]->buf_addr = pkts_burst[j];
-                               nb_tx =
-                               rte_rawdev_enqueue_buffers(fs.tx_port,
+                               ret = rte_rawdev_enqueue_buffers(fs.tx_port,
                                                ntb_buf, nb_rx,
                                                (void *)(size_t)fs.qp_id);
+                               if (ret < 0) {
+                                       printf("Enqueue failed with err %d\n",
+                                               ret);
+                                       for (j = 0; j < nb_rx; j++)
+                                               rte_pktmbuf_free(pkts_burst[j]);
+                                       goto clean;
+                               }
+                               nb_tx = ret;
                                ntb_port_stats[0].tx += nb_tx;
                                ntb_port_stats[1].rx += nb_rx;
                        } else {
-                               nb_rx =
-                               rte_rawdev_dequeue_buffers(fs.rx_port,
+                               ret = rte_rawdev_dequeue_buffers(fs.rx_port,
                                                ntb_buf, pkt_burst,
                                                (void *)(size_t)fs.qp_id);
+                               if (ret < 0) {
+                                       printf("Dequeue failed with err %d\n",
+                                               ret);
+                                       goto clean;
+                               }
+                               nb_rx = ret;
                                if (unlikely(nb_rx == 0))
                                        continue;
                                for (j = 0; j < nb_rx; j++)
@@ -443,6 +481,7 @@ start_iofwd_per_lcore(void *param)
                }
        }
 
+clean:
        for (i = 0; i < NTB_MAX_PKT_BURST; i++)
                free(ntb_buf[i]);
 
@@ -456,7 +495,7 @@ start_rxonly_per_lcore(void *param)
        struct ntb_fwd_lcore_conf *conf = param;
        struct ntb_fwd_stream fs;
        uint16_t nb_rx;
-       int i, j;
+       int i, j, ret;
 
        for (i = 0; i < NTB_MAX_PKT_BURST; i++)
                ntb_buf[i] = (struct rte_rawdev_buf *)
@@ -465,8 +504,13 @@ start_rxonly_per_lcore(void *param)
        while (!conf->stopped) {
                for (i = 0; i < conf->nb_stream; i++) {
                        fs = fwd_streams[conf->stream_id + i];
-                       nb_rx = rte_rawdev_dequeue_buffers(fs.rx_port,
-                               ntb_buf, pkt_burst, (void *)(size_t)fs.qp_id);
+                       ret = rte_rawdev_dequeue_buffers(fs.rx_port,
+                             ntb_buf, pkt_burst, (void *)(size_t)fs.qp_id);
+                       if (ret < 0) {
+                               printf("Dequeue failed with err %d\n", ret);
+                               goto clean;
+                       }
+                       nb_rx = ret;
                        if (unlikely(nb_rx == 0))
                                continue;
                        ntb_port_stats[0].rx += nb_rx;
@@ -476,6 +520,7 @@ start_rxonly_per_lcore(void *param)
                }
        }
 
+clean:
        for (i = 0; i < NTB_MAX_PKT_BURST; i++)
                free(ntb_buf[i]);
 
@@ -491,7 +536,7 @@ start_txonly_per_lcore(void *param)
        struct ntb_fwd_lcore_conf *conf = param;
        struct ntb_fwd_stream fs;
        uint16_t nb_pkt, nb_tx;
-       int i;
+       int i, j, ret;
 
        for (i = 0; i < NTB_MAX_PKT_BURST; i++)
                ntb_buf[i] = (struct rte_rawdev_buf *)
@@ -528,18 +573,25 @@ start_txonly_per_lcore(void *param)
                                                pkts_burst[nb_pkt];
                                }
                        }
-                       nb_tx = rte_rawdev_enqueue_buffers(fs.tx_port,
-                               ntb_buf, nb_pkt, (void *)(size_t)fs.qp_id);
+                       ret = rte_rawdev_enqueue_buffers(fs.tx_port, ntb_buf,
+                                       nb_pkt, (void *)(size_t)fs.qp_id);
+                       if (ret < 0) {
+                               printf("Enqueue failed with err %d\n", ret);
+                               for (j = 0; j < nb_pkt; j++)
+                                       rte_pktmbuf_free(pkts_burst[j]);
+                               goto clean;
+                       }
+                       nb_tx = ret;
                        ntb_port_stats[0].tx += nb_tx;
                        if (unlikely(nb_tx < nb_pkt)) {
                                do {
-                                       rte_pktmbuf_free(
-                                               ntb_buf[nb_tx]->buf_addr);
+                                       rte_pktmbuf_free(pkts_burst[nb_tx]);
                                } while (++nb_tx < nb_pkt);
                        }
                }
        }
 
+clean:
        for (i = 0; i < NTB_MAX_PKT_BURST; i++)
                free(ntb_buf[i]);
 
@@ -612,7 +664,8 @@ assign_stream_to_lcores(void)
        struct ntb_fwd_lcore_conf *conf;
        struct ntb_fwd_stream *fs;
        uint16_t nb_streams, sm_per_lcore, sm_id, i;
-       uint8_t lcore_id, lcore_num, nb_extra;
+       uint32_t lcore_id;
+       uint8_t lcore_num, nb_extra;
 
        lcore_num = rte_lcore_count();
        /* Exclude master core */
@@ -674,7 +727,7 @@ start_pkt_fwd(void)
 {
        struct ntb_fwd_lcore_conf *conf;
        struct rte_eth_link eth_link;
-       uint8_t lcore_id;
+       uint32_t lcore_id;
        int ret, i;
 
        ret = ntb_fwd_config_setup();
@@ -688,7 +741,11 @@ start_pkt_fwd(void)
                printf("Checking eth link status...\n");
                /* Wait for eth link up at most 100 times. */
                for (i = 0; i < 100; i++) {
-                       rte_eth_link_get(eth_port_id, &eth_link);
+                       ret = rte_eth_link_get(eth_port_id, &eth_link);
+                       if (ret < 0) {
+                               printf("Link get failed with err %d\n", ret);
+                               return;
+                       }
                        if (eth_link.link_status) {
                                printf("Eth%u Link Up. Speed %u Mbps - %s\n",
                                        eth_port_id, eth_link.link_speed,
@@ -736,9 +793,9 @@ struct cmd_start_result {
 };
 
 static void
-cmd_start_parsed(__attribute__((unused)) void *parsed_result,
-                           __attribute__((unused)) struct cmdline *cl,
-                           __attribute__((unused)) void *data)
+cmd_start_parsed(__rte_unused void *parsed_result,
+                           __rte_unused struct cmdline *cl,
+                           __rte_unused void *data)
 {
        start_pkt_fwd();
 }
@@ -762,12 +819,12 @@ struct cmd_stop_result {
 };
 
 static void
-cmd_stop_parsed(__attribute__((unused)) void *parsed_result,
-               __attribute__((unused)) struct cmdline *cl,
-               __attribute__((unused)) void *data)
+cmd_stop_parsed(__rte_unused void *parsed_result,
+               __rte_unused struct cmdline *cl,
+               __rte_unused void *data)
 {
        struct ntb_fwd_lcore_conf *conf;
-       uint8_t lcore_id;
+       uint32_t lcore_id;
 
        RTE_LCORE_FOREACH_SLAVE(lcore_id) {
                conf = &fwd_lcore_conf[lcore_id];
@@ -926,8 +983,8 @@ struct cmd_stats_result {
 
 static void
 cmd_stats_parsed(void *parsed_result,
-                __attribute__((unused)) struct cmdline *cl,
-                __attribute__((unused)) void *data)
+                __rte_unused struct cmdline *cl,
+                __rte_unused void *data)
 {
        struct cmd_stats_result *res = parsed_result;
        if (!strcmp(res->show, "clear"))
@@ -964,9 +1021,9 @@ struct cmd_set_fwd_mode_result {
 };
 
 static void
-cmd_set_fwd_mode_parsed(__attribute__((unused)) void *parsed_result,
-                       __attribute__((unused)) struct cmdline *cl,
-                       __attribute__((unused)) void *data)
+cmd_set_fwd_mode_parsed(__rte_unused void *parsed_result,
+                       __rte_unused struct cmdline *cl,
+                       __rte_unused void *data)
 {
        struct cmd_set_fwd_mode_result *res = parsed_result;
        int i;
@@ -1200,6 +1257,12 @@ ntb_mbuf_pool_create(uint16_t mbuf_seg_size, uint32_t nb_mbuf,
        if (mp == NULL)
                return NULL;
 
+       if (rte_mempool_set_ops_byname(mp, rte_mbuf_best_mempool_ops(), NULL)) {
+               printf("error setting mempool handler\n");
+               goto fail;
+       }
+
+       memset(&mbp_priv, 0, sizeof(mbp_priv));
        mbp_priv.mbuf_data_room_size = mbuf_seg_size;
        mbp_priv.mbuf_priv_size = 0;
        rte_pktmbuf_pool_init(mp, &mbp_priv);
@@ -1256,7 +1319,7 @@ ntb_mbuf_pool_create(uint16_t mbuf_seg_size, uint32_t nb_mbuf,
                                        mz->len - ntb_info.ntb_hdr_size,
                                        ntb_mempool_mz_free,
                                        (void *)(uintptr_t)mz);
-               if (ret < 0) {
+               if (ret <= 0) {
                        rte_memzone_free(mz);
                        rte_mempool_free(mp);
                        return NULL;