1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
|
//
// Copyright 2019 Ettus Research, a National Instruments Company
//
// SPDX-License-Identifier: GPL-3.0-or-later
//
#include <uhd/utils/log.hpp>
#include <uhdlib/transport/dpdk_simple.hpp>
#include <uhdlib/transport/uhd-dpdk.h>
#include <arpa/inet.h>
namespace uhd { namespace transport {
namespace {
constexpr uint64_t USEC = 1000000;
// Non-data fields are headers (Ethernet + IPv4 + UDP) + CRC
constexpr size_t DPDK_SIMPLE_NONDATA_SIZE = 14 + 20 + 8 + 4;
}
class dpdk_simple_impl : public dpdk_simple {
public:
dpdk_simple_impl(struct uhd_dpdk_ctx &ctx, const std::string &addr,
const std::string &port, bool filter_bcast)
{
UHD_ASSERT_THROW(ctx.is_init_done());
// Get NIC that can route to addr
int port_id = ctx.get_route(addr);
UHD_ASSERT_THROW(port_id >= 0);
_port_id = port_id;
uint32_t dst_ipv4 = (uint32_t) inet_addr(addr.c_str());
uint16_t dst_port = htons(std::stoi(port, NULL, 0));
struct uhd_dpdk_sockarg_udp sockarg = {
.is_tx = false,
.filter_bcast = filter_bcast,
.local_port = 0,
.remote_port = dst_port,
.dst_addr = dst_ipv4,
.num_bufs = 1
};
_rx_sock = uhd_dpdk_sock_open(_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.remote_port = dst_port;
sockarg.dst_addr = dst_ipv4;
sockarg.num_bufs = 1;
_tx_sock = uhd_dpdk_sock_open(_port_id, UHD_DPDK_SOCK_UDP, &sockarg);
UHD_ASSERT_THROW(_tx_sock != nullptr);
UHD_LOG_TRACE("DPDK", "Created simple transports between " << addr << ":"
<< ntohs(dst_port) << " and NIC(" << _port_id
<< "):" << ntohs(sockarg.local_port));
}
~dpdk_simple_impl(void)
{
if (_rx_mbuf)
uhd_dpdk_free_buf(_rx_mbuf);
if (_tx_mbuf)
uhd_dpdk_free_buf(_tx_mbuf);
}
/*!
* Request a single send buffer of specified size.
*
* \param buf a pointer to place to write buffer location
* \return the maximum length of the buffer
*/
size_t get_tx_buf(void** buf)
{
UHD_ASSERT_THROW(!_tx_mbuf);
int bufs = uhd_dpdk_request_tx_bufs(_tx_sock, &_tx_mbuf, 1, 0);
if (bufs != 1 || !_tx_mbuf) {
*buf = nullptr;
return 0;
}
*buf = uhd_dpdk_buf_to_data(_tx_sock, _tx_mbuf);
return _mtu - DPDK_SIMPLE_NONDATA_SIZE;
}
/*!
* Send and release outstanding buffer
*
* \param length bytes of data to send
* \return number of bytes sent (releases buffer if sent)
*/
size_t send(size_t length)
{
UHD_ASSERT_THROW(_tx_mbuf)
_tx_mbuf->pkt_len = length;
_tx_mbuf->data_len = length;
int num_tx = uhd_dpdk_send(_tx_sock, &_tx_mbuf, 1);
if (num_tx == 0)
return 0;
_tx_mbuf = nullptr;
return length;
}
/*!
* Receive a single packet.
* Buffer provided by transport (must be freed before next operation).
*
* \param buf a pointer to place to write buffer location
* \param timeout the timeout in seconds
* \return the number of bytes received or zero on timeout
*/
size_t recv(void **buf, double timeout)
{
UHD_ASSERT_THROW(!_rx_mbuf);
int bufs = uhd_dpdk_recv(_rx_sock, &_rx_mbuf, 1, (int) (timeout*USEC));
if (bufs != 1 || _rx_mbuf == nullptr) {
*buf = nullptr;
return 0;
}
if ((_tx_mbuf->ol_flags & PKT_RX_IP_CKSUM_MASK) == PKT_RX_IP_CKSUM_BAD) {
uhd_dpdk_free_buf(_rx_mbuf);
_rx_mbuf = nullptr;
return 0;
}
uhd_dpdk_get_src_ipv4(_rx_sock, _rx_mbuf, &_last_recv_addr);
*buf = uhd_dpdk_buf_to_data(_rx_sock, _rx_mbuf);
return uhd_dpdk_get_len(_rx_sock, _rx_mbuf);
}
/*!
* Return/free receive buffer
* Can also use to free un-sent TX bufs
*/
void put_rx_buf(void)
{
UHD_ASSERT_THROW(_rx_mbuf)
uhd_dpdk_free_buf(_rx_mbuf);
}
/*!
* Get the last IP address as seen by recv().
* Only use this with the broadcast socket.
*/
std::string get_recv_addr(void)
{
char addr_str[INET_ADDRSTRLEN];
struct in_addr ipv4_addr;
ipv4_addr.s_addr = _last_recv_addr;
inet_ntop(AF_INET, &ipv4_addr, addr_str, sizeof(addr_str));
return std::string(addr_str);
}
/*!
* Get the IP address for the destination
*/
std::string get_send_addr(void)
{
struct in_addr ipv4_addr;
int status = uhd_dpdk_get_ipv4_addr(_port_id, &ipv4_addr.s_addr, nullptr);
UHD_ASSERT_THROW(status);
char addr_str[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &ipv4_addr, addr_str, sizeof(addr_str));
return std::string(addr_str);
}
private:
unsigned int _port_id;
size_t _mtu;
struct uhd_dpdk_socket *_tx_sock;
struct rte_mbuf *_tx_mbuf = nullptr;
struct uhd_dpdk_socket *_rx_sock;
struct rte_mbuf *_rx_mbuf = nullptr;
uint32_t _last_recv_addr;
};
dpdk_simple::~dpdk_simple(void) {}
/***********************************************************************
* DPDK simple transport public make functions
**********************************************************************/
dpdk_simple::sptr dpdk_simple::make_connected(
struct uhd_dpdk_ctx &ctx, const std::string &addr, const std::string &port
){
return sptr(new dpdk_simple_impl(ctx, addr, port, true));
}
dpdk_simple::sptr dpdk_simple::make_broadcast(
struct uhd_dpdk_ctx &ctx, const std::string &addr, const std::string &port
){
return sptr(new dpdk_simple_impl(ctx, addr, port, false));
}
}} // namespace uhd::transport
|
