mpmd,transport,prefs: Add xport_mgr for dpdk_zero_copy

Add configuration sections to the UHD config file for NIC entries. Keys
are based on MAC addresses, and the entries beneath the section describe
which CPU and I/O thread to use for the NIC and its IPv4 address.

Make ring sizes configurable for uhd-dpdk. Ring size is now an argument
for packet buffers. Note that the maximum number of available buffers
is still determined at init!

Add ability to receive broadcasts to uhd-dpdk. This is controllable by
a boolean in the sockarg during socket creation. dpdk_zero_copy will
filter broadcast packets out.

Add dpdk_simple transport (to mirror udp_simple). This transport allows
receiving from broadcast addresses, but it only permits one outstanding
buffer at a time.

Fix IP checksum handling in UHD-DPDK.
TX checksums were not being calculated in the NIC, and in RX, the check
for IP checksums allowed values of zero (reported as none). Now packets
with bad IP checksums will be dropped.

1 files changed, 246 insertions, 159 deletions

diff --git a/host/lib/transport/dpdk_zero_copy.cpp b/host/lib/transport/dpdk_zero_copy.cpp
index 51c9b9dba..9649c1cfb 100644
--- a/host/lib/transport/dpdk_zero_copy.cpp
+++ b/host/lib/transport/dpdk_zero_copy.cpp
@@ -7,24 +7,28 @@
 #include "dpdk_zero_copy.hpp"
 #include <uhd/config.hpp>
 #include <uhd/utils/log.hpp>
-#include <uhd/utils/static.hpp>
 #include <uhdlib/transport/uhd-dpdk.h>
-#include <arpa/inet.h>
-#include <sys/syslog.h>
+#include <uhdlib/utils/prefs.hpp>
+#include <boost/algorithm/string.hpp>
+#include <boost/format.hpp>
 #include <boost/make_shared.hpp>
 #include <stack>
+#include <sys/syslog.h>
+#include <arpa/inet.h>
 
 namespace uhd { namespace transport {
 
 namespace {
-static constexpr uint64_t USEC = 1000000;
-// FIXME: Make configurable and have uhd-dpdk library track buffer sizes
-static constexpr size_t DEFAULT_FRAME_SIZE = 8000;
-
-inline char* eal_add_opt(
-    std::vector<const char*>& argv, size_t n, char* dst, const char* opt, const char* arg)
+constexpr uint64_t USEC = 1000000;
+constexpr size_t DEFAULT_FRAME_SIZE = 8000;
+constexpr int DEFAULT_NUM_MBUFS = 4095;
+constexpr int DEFAULT_MBUF_CACHE_SIZE = 315;
+constexpr size_t UHD_DPDK_HEADERS_SIZE = 14 + 20 + 8; // Ethernet + IPv4 + UDP
+
+inline char * eal_add_opt(std::vector<const char*> &argv, size_t n,
+    char *dst, const char *opt, const char *arg)
 {
-    char* ptr = dst;
+    char *ptr = dst;
     strncpy(ptr, opt, n);
     argv.push_back(ptr);
     ptr += strlen(opt) + 1;
@@ -34,6 +38,78 @@ inline char* eal_add_opt(
     ptr += strlen(arg) + 1;
     return ptr;
 }
+
+inline void uhd_dpdk_eal_init(const device_addr_t &eal_args)
+{
+    /* Build up argc and argv */
+    std::vector<const char *> argv;
+    argv.push_back("uhd-dpdk");
+    auto args = new std::array<char, 4096>();
+    char *opt = args->data();
+    char *end = args->data() + args->size();
+    for (std::string &key : eal_args.keys()) {
+        std::string val = eal_args[key];
+        if (key == "dpdk-coremask") {
+            opt = eal_add_opt(argv, end - opt, opt, "-c",
+                              val.c_str());
+        } else if (key == "dpdk-corelist") {
+            /* NOTE: This arg may have commas, so limited to config file */
+            opt = eal_add_opt(argv, end - opt, opt, "-l",
+                              val.c_str());
+        } else if (key == "dpdk-coremap") {
+            opt = eal_add_opt(argv, end - opt, opt, "--lcores",
+                              val.c_str());
+        } else if (key == "dpdk-master-lcore") {
+            opt = eal_add_opt(argv, end - opt, opt, "--master-lcore",
+                              val.c_str());
+        } else if (key == "dpdk-pci-blacklist") {
+            opt = eal_add_opt(argv, end - opt, opt, "-b",
+                              val.c_str());
+        } else if (key == "dpdk-pci-whitelist") {
+            opt = eal_add_opt(argv, end - opt, opt, "-w",
+                              val.c_str());
+        } else if (key == "dpdk-log-level") {
+            opt = eal_add_opt(argv, end - opt, opt, "--log-level",
+                              val.c_str());
+        } else if (key == "dpdk-huge-dir") {
+            opt = eal_add_opt(argv, end - opt, opt, "--huge-dir",
+                              val.c_str());
+        } else if (key == "dpdk-file-prefix") {
+            opt = eal_add_opt(argv, end - opt, opt, "--file-prefix",
+                              val.c_str());
+        } else if (key == "dpdk-driver") {
+            opt = eal_add_opt(argv, end - opt, opt, "-d",
+                              val.c_str());
+        }
+        /* TODO: Change where log goes?
+           int rte_openlog_stream( FILE * f)
+         */
+    }
+    /* Init DPDK's EAL */
+    uhd_dpdk_init(argv.size(), argv.data());
+    delete args;
+}
+
+inline std::string eth_addr_to_string(struct eth_addr mac_addr)
+{
+    auto mac_stream = boost::format("%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx");
+    mac_stream % (uint32_t) mac_addr.addr[0] % (uint32_t) mac_addr.addr[1]
+               % (uint32_t) mac_addr.addr[2] % (uint32_t) mac_addr.addr[3]
+               % (uint32_t) mac_addr.addr[4] % (uint32_t) mac_addr.addr[5];
+    return mac_stream.str();
+}
+
+inline void separate_ipv4_addr(const std::string ipv4,
+    uint32_t &ipv4_addr, uint32_t &netmask)
+{
+    std::vector<std::string> result;
+    boost::algorithm::split(result, ipv4,
+        [](const char &in) {return in == '/';}, boost::token_compress_on);
+    UHD_ASSERT_THROW(result.size() == 2);
+    ipv4_addr = (uint32_t) inet_addr(result[0].c_str());
+    int netbits = std::atoi(result[1].c_str());
+    netmask = htonl(0xffffffff << (32-netbits));
+}
 } // namespace
 
 uhd_dpdk_ctx::uhd_dpdk_ctx(void) : _init_done(false) {}
@@ -41,69 +117,82 @@ uhd_dpdk_ctx::uhd_dpdk_ctx(void) : _init_done(false) {}
 uhd_dpdk_ctx::~uhd_dpdk_ctx(void) {}
 
 /* Initialize uhd-dpdk (and do only once) */
-void uhd_dpdk_ctx::init(const dict<std::string, std::string>& eal_args,
-    unsigned int num_ports,
-    int* port_thread_mapping,
-    int num_mbufs,
-    int mbuf_cache_size,
-    size_t mtu)
+void uhd_dpdk_ctx::init(const device_addr_t &user_args)
 {
     std::lock_guard<std::mutex> lock(_init_mutex);
     if (!_init_done) {
-        _mtu = mtu;
-        /* Build up argc and argv */
-        std::vector<const char*> argv;
-        argv.push_back("uhd-dpdk");
-        char* args = new char[4096];
-        char* opt  = args;
-        char* end  = args + sizeof(args);
-        for (std::string& key : eal_args.keys()) {
-            std::string val = eal_args[key];
-            if (key == "coremask") {
-                opt = eal_add_opt(argv, end - opt, opt, "-c", val.c_str());
-            } else if (key == "corelist") {
-                /* NOTE: This arg may have commas, so limited to config file */
-                opt = eal_add_opt(argv, end - opt, opt, "-l", val.c_str());
-            } else if (key == "coremap") {
-                opt = eal_add_opt(argv, end - opt, opt, "--lcores", val.c_str());
-            } else if (key == "master-lcore") {
-                opt = eal_add_opt(argv, end - opt, opt, "--master-lcore", val.c_str());
-            } else if (key == "pci-blacklist") {
-                opt = eal_add_opt(argv, end - opt, opt, "-b", val.c_str());
-            } else if (key == "pci-whitelist") {
-                opt = eal_add_opt(argv, end - opt, opt, "-w", val.c_str());
-            } else if (key == "log-level") {
-                opt = eal_add_opt(argv, end - opt, opt, "--log-level", val.c_str());
-            } else if (key == "huge-dir") {
-                opt = eal_add_opt(argv, end - opt, opt, "--huge-dir", val.c_str());
-            } else if (key == "file-prefix") {
-                opt = eal_add_opt(argv, end - opt, opt, "--file-prefix", val.c_str());
+        /* Gather global config, build args for EAL, and init UHD-DPDK */
+        const device_addr_t dpdk_args = uhd::prefs::get_dpdk_args(user_args);
+        UHD_LOG_TRACE("DPDK", "Configuration:" << std::endl
+            << dpdk_args.to_pp_string());
+        uhd_dpdk_eal_init(dpdk_args);
+
+        _mtu = dpdk_args.has_key("dpdk-mtu")
+            ? dpdk_args.cast<size_t>("dpdk-mtu", 0)
+            : DEFAULT_FRAME_SIZE;
+        const int num_mbufs = dpdk_args.has_key("dpdk-num-mbufs")
+            ? dpdk_args.cast<int>("dpdk-num-mbufs", 0)
+            : DEFAULT_NUM_MBUFS;
+        const int mbuf_cache_size = dpdk_args.has_key("dpdk-mbuf-cache-size")
+            ? dpdk_args.cast<int>("dpdk-mbuf-cache-size", 0)
+            : DEFAULT_MBUF_CACHE_SIZE;
+
+        /* Get configuration for all the NIC ports */
+        device_addrs_t args = separate_device_addr(user_args);
+        int num_ports = uhd_dpdk_port_count();
+        std::vector<int> io_cpu_map(num_ports);
+        device_addrs_t nics(num_ports);
+        for (ssize_t i = 0; i < num_ports; i++) {
+            struct eth_addr mac_addr = uhd_dpdk_get_eth_addr(i);
+            nics[i]["dpdk-mac"] = eth_addr_to_string(mac_addr);
+            for (const auto &arg: args) {
+                if (arg.has_key("dpdk-mac")
+                    && arg["dpdk-mac"] == nics[i]["dpdk-mac"]) {
+                    for (const auto& key: arg.keys()) {
+                        nics[i][key] = arg[key];
+                    }
+                    break;
+                }
             }
+            nics[i] = uhd::prefs::get_dpdk_nic_args(nics[i]);
+            if (nics[i].has_key("dpdk-ipv4")
+                && nics[i].has_key("dpdk-io-cpu")) {
+                uint32_t ipv4_addr, netmask;
+                io_cpu_map[i] = std::atoi(nics[i]["dpdk-io-cpu"].c_str());
+                separate_ipv4_addr(nics[i]["dpdk-ipv4"], ipv4_addr, netmask);
+                uhd_dpdk_set_ipv4_addr((unsigned int) i, ipv4_addr, netmask);
+            } else {
+                /* Not enough configuration to use NIC */
+                io_cpu_map[i] = -1;
+            }
+            UHD_LOG_TRACE("DPDK", "Found NIC(" << i << "):" << std::endl
+                << nics[i].to_pp_string());
         }
-        uhd_dpdk_init(argv.size(),
-            argv.data(),
-            num_ports,
-            port_thread_mapping,
-            num_mbufs,
-            mbuf_cache_size,
-            _mtu);
-        delete args;
+        uhd_dpdk_start(num_ports, io_cpu_map.data(), num_mbufs,
+            mbuf_cache_size, _mtu);
         _init_done = true;
     }
 }
 
-int uhd_dpdk_ctx::get_port_id(std::array<uint8_t, 6> mac_addr, unsigned int& port_id)
+size_t uhd_dpdk_ctx::get_mtu(void) const
+{
+    UHD_ASSERT_THROW(is_init_done());
+    return _mtu;
+}
+
+int uhd_dpdk_ctx::get_port_id(std::array<uint8_t, 6> mac_addr,
+    unsigned int &port_id) const
 {
     UHD_ASSERT_THROW(is_init_done());
     int num_ports = uhd_dpdk_port_count();
     for (int i = 0; i < num_ports; i++) {
-        struct eth_addr port_mac_addr = uhd_dpdk_get_eth_addr((unsigned int)i);
+        struct eth_addr port_mac_addr = uhd_dpdk_get_eth_addr((unsigned int) i);
         for (int j = 0; j < 6; j++) {
             if (mac_addr[j] != port_mac_addr.addr[j]) {
                 break;
             }
             if (j == 5) {
-                port_id = (unsigned int)i;
+                port_id = (unsigned int) i;
                 return 0;
             }
         }
@@ -111,52 +200,54 @@ int uhd_dpdk_ctx::get_port_id(std::array<uint8_t, 6> mac_addr, unsigned int& por
     return -1;
 }
 
-int uhd_dpdk_ctx::get_route(const std::string& addr) const
+int uhd_dpdk_ctx::get_route(const std::string &addr) const
 {
-    const uint32_t dst_ipv4      = (uint32_t)inet_addr(addr.c_str());
+    const uint32_t dst_ipv4 = (uint32_t) inet_addr(addr.c_str());
     const unsigned int num_ports = uhd_dpdk_port_count();
     for (unsigned int port = 0; port < num_ports; port++) {
         uint32_t src_ipv4;
         uint32_t netmask;
+        if (uhd_dpdk_port_link_status(port) < 1)
+            continue;
         uhd_dpdk_get_ipv4_addr(port, &src_ipv4, &netmask);
         if ((src_ipv4 & netmask) == (dst_ipv4 & netmask)) {
-            return (int)port;
-        }
+            return (int) port;
+	}
     }
     return -ENODEV;
 }
 
-int uhd_dpdk_ctx::set_ipv4_addr(
-    unsigned int port_id, uint32_t ipv4_addr, uint32_t netmask)
+int uhd_dpdk_ctx::set_ipv4_addr(unsigned int port_id, uint32_t ipv4_addr,
+    uint32_t netmask)
 {
     return uhd_dpdk_set_ipv4_addr(port_id, ipv4_addr, netmask);
 }
 
-bool uhd_dpdk_ctx::is_init_done(void)
+bool uhd_dpdk_ctx::is_init_done(void) const
 {
     return _init_done.load();
 }
 
 
-class dpdk_zero_copy_msb : public managed_send_buffer
-{
+class dpdk_zero_copy_msb : public managed_send_buffer {
 public:
-    dpdk_zero_copy_msb(struct uhd_dpdk_socket* sock,
-        std::stack<dpdk_zero_copy_msb*, std::vector<dpdk_zero_copy_msb*>>& free_bufs)
-        : _sock(sock), _buf(nullptr), _free_bufs(free_bufs){};
+    dpdk_zero_copy_msb(struct uhd_dpdk_socket *sock,
+                       std::stack<dpdk_zero_copy_msb *, std::vector<dpdk_zero_copy_msb *>> &free_bufs,
+                       size_t frame_size)
+                      : _sock(sock), _buf(nullptr), _free_bufs(free_bufs),
+                        _frame_size(frame_size) {};
 
     ~dpdk_zero_copy_msb(void) {}
 
     void release(void)
     {
         if (_buf) {
-            _buf->pkt_len  = _length;
+            _buf->pkt_len = _length;
             _buf->data_len = _length;
-            int num_tx     = uhd_dpdk_send(_sock, &_buf, 1);
+            int num_tx = uhd_dpdk_send(_sock, &_buf, 1);
             if (num_tx == 0) {
                 /* Drop packet and free buffer (do not share sockets!) */
-                UHD_LOG_ERROR(
-                    "DPDK", "Invalid shared socket usage detected. Dropping packet...");
+                UHD_LOG_ERROR("DPDK", "Invalid shared socket usage detected. Dropping packet...");
                 uhd_dpdk_free_buf(_buf);
             }
             // Push back into pool
@@ -170,21 +261,22 @@ public:
         if (bufs != 1 || !_buf)
             return sptr();
 
-        return make(this, uhd_dpdk_buf_to_data(_sock, _buf), DEFAULT_FRAME_SIZE);
+        return make(this, uhd_dpdk_buf_to_data(_sock, _buf),
+                    _frame_size);
     }
 
 private:
-    struct uhd_dpdk_socket* _sock;
-    struct rte_mbuf* _buf;
-    std::stack<dpdk_zero_copy_msb*, std::vector<dpdk_zero_copy_msb*>>& _free_bufs;
+    struct uhd_dpdk_socket *_sock;
+    struct rte_mbuf *_buf;
+    std::stack<dpdk_zero_copy_msb *, std::vector<dpdk_zero_copy_msb *>> &_free_bufs;
+    size_t _frame_size;
 };
 
-class dpdk_zero_copy_mrb : public managed_recv_buffer
-{
+class dpdk_zero_copy_mrb : public managed_recv_buffer {
 public:
-    dpdk_zero_copy_mrb(struct uhd_dpdk_socket* sock,
-        std::stack<dpdk_zero_copy_mrb*, std::vector<dpdk_zero_copy_mrb*>>& free_bufs)
-        : _sock(sock), _buf(nullptr), _free_bufs(free_bufs){};
+    dpdk_zero_copy_mrb(struct uhd_dpdk_socket *sock,
+        std::stack<dpdk_zero_copy_mrb*, std::vector<dpdk_zero_copy_mrb*>> &free_bufs)
+        : _sock(sock), _buf(nullptr), _free_bufs(free_bufs) {};
     ~dpdk_zero_copy_mrb(void) {}
 
     void release(void)
@@ -197,78 +289,78 @@ public:
 
     sptr get_new(double timeout)
     {
-        int bufs = uhd_dpdk_recv(_sock, &_buf, 1, (int)(timeout * USEC));
+        int bufs = uhd_dpdk_recv(_sock, &_buf, 1, (int) (timeout*USEC));
         if (bufs != 1 || _buf == nullptr) {
             // Push back into pool if we didn't get a real buffer
             _free_bufs.push(this);
             return sptr();
         }
-        if ((_buf->ol_flags & PKT_RX_IP_CKSUM_MASK) == PKT_RX_IP_CKSUM_BAD) {
-            UHD_LOG_WARNING("DPDK", "IP checksum failure detected. Dropping packet...");
-            uhd_dpdk_free_buf(_buf);
-            _free_bufs.push(this);
-            return sptr();
-        }
 
-        return make(
-            this, uhd_dpdk_buf_to_data(_sock, _buf), uhd_dpdk_get_len(_sock, _buf));
+        return make(this, uhd_dpdk_buf_to_data(_sock, _buf),
+                    uhd_dpdk_get_len(_sock, _buf));
     }
 
 private:
-    struct uhd_dpdk_socket* _sock;
-    struct rte_mbuf* _buf;
-    std::stack<dpdk_zero_copy_mrb*, std::vector<dpdk_zero_copy_mrb*>>& _free_bufs;
+    struct uhd_dpdk_socket *_sock;
+    struct rte_mbuf *_buf;
+    std::stack<dpdk_zero_copy_mrb*, std::vector<dpdk_zero_copy_mrb*>> &_free_bufs;
 };
 
-class dpdk_zero_copy_impl : public dpdk_zero_copy
-{
+class dpdk_zero_copy_impl : public dpdk_zero_copy {
 public:
-    dpdk_zero_copy_impl(struct uhd_dpdk_ctx& ctx,
-        const unsigned int dpdk_port_id,
-        const std::string& addr,
-        const std::string& remote_port,
-        const std::string& local_port,
-        const zero_copy_xport_params& xport_params)
-        : _num_send_frames(xport_params.num_send_frames)
-        , _send_frame_size(xport_params.send_frame_size)
-        , _num_recv_frames(xport_params.num_recv_frames)
-        , _recv_frame_size(xport_params.recv_frame_size)
-        , _port_id(dpdk_port_id)
-        , _rx_empty_count(0)
-        , _tx_empty_count(0)
+
+    dpdk_zero_copy_impl(const struct uhd_dpdk_ctx &ctx,
+                        const unsigned int dpdk_port_id,
+                        const std::string &addr,
+                        const std::string &remote_port,
+                        const std::string &local_port,
+                        const zero_copy_xport_params& xport_params)
+                          : _num_send_frames(xport_params.num_send_frames),
+                            _send_frame_size(xport_params.send_frame_size),
+                            _num_recv_frames(xport_params.num_recv_frames),
+                            _recv_frame_size(xport_params.recv_frame_size),
+                            _port_id(dpdk_port_id),
+                            _rx_empty_count(0),
+                            _tx_empty_count(0)
     {
-        // TODO: Handle xport_params
         UHD_ASSERT_THROW(xport_params.recv_frame_size > 0);
         UHD_ASSERT_THROW(xport_params.send_frame_size > 0);
         UHD_ASSERT_THROW(xport_params.num_send_frames > 0);
         UHD_ASSERT_THROW(xport_params.num_recv_frames > 0);
 
         UHD_ASSERT_THROW(ctx.is_init_done());
+        UHD_ASSERT_THROW(xport_params.recv_frame_size < ctx.get_mtu() - UHD_DPDK_HEADERS_SIZE);
+        UHD_ASSERT_THROW(xport_params.send_frame_size < ctx.get_mtu() - UHD_DPDK_HEADERS_SIZE);
 
         const int num_ports = uhd_dpdk_port_count();
         UHD_ASSERT_THROW(num_ports > 0);
-        UHD_ASSERT_THROW(dpdk_port_id < (unsigned int)num_ports);
+        UHD_ASSERT_THROW(dpdk_port_id < (unsigned int) num_ports);
 
         // Convert ipv4 addr from string to uint32_t, network format
-        uint32_t dst_ipv4 = (uint32_t)inet_addr(addr.c_str());
+        uint32_t dst_ipv4 = (uint32_t) inet_addr(addr.c_str());
         // Convert port from string to uint16_t, network format
         uint16_t dst_port = htons(std::stoi(remote_port, NULL, 0));
         uint16_t src_port = htons(std::stoi(local_port, NULL, 0));
 
         // Create RX socket first
-        struct uhd_dpdk_sockarg_udp sockarg = {.is_tx = false,
-            .local_port                               = src_port,
-            .remote_port                              = dst_port,
-            .dst_addr                                 = dst_ipv4};
+        struct uhd_dpdk_sockarg_udp sockarg = {
+            .is_tx = false,
+            .filter_bcast = true,
+            .local_port = src_port,
+            .remote_port = dst_port,
+            .dst_addr = dst_ipv4,
+            .num_bufs = _num_recv_frames
+        };
         _rx_sock = uhd_dpdk_sock_open(dpdk_port_id, UHD_DPDK_SOCK_UDP, &sockarg);
         UHD_ASSERT_THROW(_rx_sock != nullptr);
 
         // Backfill the local port, in case it was auto-assigned
         uhd_dpdk_udp_get_info(_rx_sock, &sockarg);
 
-        sockarg.is_tx       = true;
+        sockarg.is_tx = true;
+        sockarg.num_bufs = _num_send_frames;
         sockarg.remote_port = dst_port;
-        sockarg.dst_addr    = dst_ipv4;
+        sockarg.dst_addr = dst_ipv4;
         _tx_sock = uhd_dpdk_sock_open(dpdk_port_id, UHD_DPDK_SOCK_UDP, &sockarg);
         UHD_ASSERT_THROW(_tx_sock != nullptr);
 
@@ -277,13 +369,12 @@ public:
             _mrb_pool.push(new dpdk_zero_copy_mrb(_rx_sock, _mrb_pool));
         }
         for (size_t i = 0; i < _num_send_frames; i++) {
-            _msb_pool.push(new dpdk_zero_copy_msb(_tx_sock, _msb_pool));
+            _msb_pool.push(new dpdk_zero_copy_msb(_tx_sock, _msb_pool, _send_frame_size));
         }
 
-        UHD_LOG_TRACE("DPDK",
-            "Created transports between " << addr << ":" << remote_port << " and NIC("
-                                          << dpdk_port_id
-                                          << "):" << ntohs(sockarg.local_port));
+        UHD_LOG_TRACE("DPDK", "Created transports between " << addr << ":"
+                               << remote_port << " and NIC(" << dpdk_port_id
+                               << "):" << ntohs(sockarg.local_port));
     }
 
     ~dpdk_zero_copy_impl(void)
@@ -292,23 +383,18 @@ public:
         size_t count;
         uhd_dpdk_udp_get_info(_rx_sock, &sockarg);
         uhd_dpdk_get_drop_count(_rx_sock, &count);
-        UHD_LOG_TRACE("DPDK",
-            "Closing transports between " << sockarg.dst_addr << ":"
-                                          << ntohs(sockarg.remote_port)
-                                          << " and local:" << ntohs(sockarg.local_port));
-        UHD_LOG_TRACE("DPDK",
-            "(" << ntohs(sockarg.remote_port) << "," << ntohs(sockarg.local_port) << ") "
-                << " Dropped " << count << " packets");
+        UHD_LOG_TRACE("DPDK", "Closing transports between " << sockarg.dst_addr << ":"
+                               << ntohs(sockarg.remote_port) << " and local:"
+                               << ntohs(sockarg.local_port));
+        UHD_LOG_TRACE("DPDK", "(" << ntohs(sockarg.remote_port) << "," << ntohs(sockarg.local_port) << ") "
+                              << " Dropped "<< count << " packets");
         uhd_dpdk_get_xfer_count(_rx_sock, &count);
-        UHD_LOG_TRACE("DPDK",
-            "(" << ntohs(sockarg.remote_port) << "," << ntohs(sockarg.local_port) << ") "
-                << " Received " << count << " packets");
-        UHD_LOG_TRACE("DPDK",
-            "(" << ntohs(sockarg.remote_port) << "," << ntohs(sockarg.local_port) << ") "
-                << "RX empty count is " << _rx_empty_count);
-        UHD_LOG_TRACE("DPDK",
-            "(" << ntohs(sockarg.remote_port) << "," << ntohs(sockarg.local_port) << ") "
-                << "TX empty count is " << _tx_empty_count);
+        UHD_LOG_TRACE("DPDK", "(" << ntohs(sockarg.remote_port) << "," << ntohs(sockarg.local_port) << ") "
+                              << " Received "<< count << " packets");
+        UHD_LOG_TRACE("DPDK", "(" << ntohs(sockarg.remote_port) << "," << ntohs(sockarg.local_port) << ") "
+                              << "RX empty count is " << _rx_empty_count);
+        UHD_LOG_TRACE("DPDK", "(" << ntohs(sockarg.remote_port) << "," << ntohs(sockarg.local_port) << ") "
+                              << "TX empty count is " << _tx_empty_count);
         uhd_dpdk_sock_close(_rx_sock);
         uhd_dpdk_sock_close(_tx_sock);
     }
@@ -320,7 +406,7 @@ public:
             return managed_recv_buffer::sptr();
         }
 
-        dpdk_zero_copy_mrb* mrb = _mrb_pool.top();
+        dpdk_zero_copy_mrb *mrb = _mrb_pool.top();
         _mrb_pool.pop();
         managed_recv_buffer::sptr buff = mrb->get_new(timeout);
         if (!buff)
@@ -345,7 +431,7 @@ public:
             return managed_send_buffer::sptr();
         }
 
-        dpdk_zero_copy_msb* msb = _msb_pool.top();
+        dpdk_zero_copy_msb *msb = _msb_pool.top();
         _msb_pool.pop();
         managed_send_buffer::sptr buff = msb->get_new(timeout);
         if (!buff)
@@ -367,18 +453,18 @@ public:
     {
         struct uhd_dpdk_sockarg_udp sockarg;
         int status = uhd_dpdk_udp_get_info(_rx_sock, &sockarg);
+        UHD_ASSERT_THROW(status == 0);
         return ntohs(sockarg.local_port);
     }
 
     std::string get_local_addr(void) const
     {
-        uint32_t ipv4_addr;
-        int status  = uhd_dpdk_get_ipv4_addr(_port_id, &ipv4_addr, NULL);
-        auto retval = std::to_string(ipv4_addr >> 0 & 0xff) + "."
-                      + std::to_string(ipv4_addr >> 8 & 0xff) + "."
-                      + std::to_string(ipv4_addr >> 16 & 0xff) + "."
-                      + std::to_string(ipv4_addr >> 24 & 0xff);
-        return retval;
+        struct in_addr ipv4_addr;
+        int status = uhd_dpdk_get_ipv4_addr(_port_id, &ipv4_addr.s_addr, NULL);
+        UHD_ASSERT_THROW(status == 0);
+        char addr_str[INET_ADDRSTRLEN];
+        inet_ntop(AF_INET, &ipv4_addr, addr_str, sizeof(addr_str));
+        return std::string(addr_str);
     }
 
     uint32_t get_drop_count(void) const
@@ -387,10 +473,9 @@ public:
         uhd_dpdk_get_drop_count(_rx_sock, &drop_count);
         return drop_count;
     }
-
 private:
-    struct uhd_dpdk_socket* _rx_sock;
-    struct uhd_dpdk_socket* _tx_sock;
+    struct uhd_dpdk_socket *_rx_sock;
+    struct uhd_dpdk_socket *_tx_sock;
     const size_t _num_send_frames;
     const size_t _send_frame_size;
     const size_t _num_recv_frames;
@@ -399,20 +484,22 @@ private:
     unsigned int _rx_empty_count;
     unsigned int _tx_empty_count;
 
-    std::stack<dpdk_zero_copy_mrb*, std::vector<dpdk_zero_copy_mrb*>> _mrb_pool;
-    std::stack<dpdk_zero_copy_msb*, std::vector<dpdk_zero_copy_msb*>> _msb_pool;
+    std::stack<dpdk_zero_copy_mrb *, std::vector<dpdk_zero_copy_mrb *>> _mrb_pool;
+    std::stack<dpdk_zero_copy_msb *, std::vector<dpdk_zero_copy_msb *>> _msb_pool;
 };
 
-dpdk_zero_copy::sptr dpdk_zero_copy::make(struct uhd_dpdk_ctx& ctx,
+dpdk_zero_copy::sptr dpdk_zero_copy::make(
+    const struct uhd_dpdk_ctx &ctx,
     const unsigned int dpdk_port_id,
-    const std::string& addr,
-    const std::string& remote_port,
-    const std::string& local_port,
-    const zero_copy_xport_params& default_buff_args,
-    const device_addr_t& hints)
+    const std::string &addr,
+    const std::string &remote_port,
+    const std::string &local_port,
+    const zero_copy_xport_params &default_buff_args,
+    const device_addr_t &/*hints*/)
 {
-    return dpdk_zero_copy::sptr(new dpdk_zero_copy_impl(
-        ctx, dpdk_port_id, addr, remote_port, local_port, default_buff_args));
+    return dpdk_zero_copy::sptr(
+        new dpdk_zero_copy_impl(ctx, dpdk_port_id, addr, remote_port, local_port, default_buff_args)
+    );
 }
 
 }} // namespace uhd::transport