deb/beegfs
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
beegfs/common/ib_lib/net/sock/ibvsocket/IBVSocket.cpp
geos_one c891bb7105 New upstream version 8.1.0
2025-08-10 01:34:16 +02:00

2504 lines
70 KiB
C++
Raw Blame History

#include "IBVSocket.h"
#include <sys/epoll.h>
#include <common/app/log/Logger.h>
#include <common/app/AbstractApp.h>
#include <common/threading/PThread.h>
#ifdef BEEGFS_NVFS
// only for WORKER_BUFOUT_SIZE
#include <common/components/worker/Worker.h>
#endif /* BEEGFS_NVFS */
#define IBVSOCKET_CONN_TIMEOUT_MS 3000
// IBVSOCKET_CONN_TIMEOUT_INITIAL_POLL_MS is the initial timeout to wait between checks for
// RDMA response events while establishing outgoing connections. Will be scaled up exponentially
// after every poll (up to IBVSOCKET_CONN_TIMEOUT_MAX_POLL_MS) to reduce load but allow for quick
// turnaround in the majority of cases where an event will come shortly after initiating the
// connection.
//
// There used to be a fixed timeout of 500ms here, which lead to long initial connection initiation
// times when an event was not received immediately
// (https://github.com/ThinkParQ/beegfs-core/issues/4054).
#define IBVSOCKET_CONN_TIMEOUT_INITIAL_POLL_MS 1
#define IBVSOCKET_CONN_TIMEOUT_MAX_POLL_MS 512
#define IBVSOCKET_FLOWCONTROL_ONSEND_TIMEOUT_MS 180000
#define IBVSOCKET_POLL_TIMEOUT_MS 7500
#define IBVSOCKET_LISTEN_BACKLOG 128
#define IBVSOCKET_FLOWCONTROL_MSG_LEN 1
#define IBVSOCKET_DEFAULT_TOS 0
/**
* IBVSOCKET_RECV_TIMEOUT_MS is used by IBVSocket_recv, which does not take a
* timeout value. It is very long because IBVSocket_recv continues to call
* IBVSocket_recvT until it does not timeout.
*/
#define IBVSOCKET_RECV_TIMEOUT_MS (1024*1024)
#define IBVSOCKET_MIN_BUF_NUM 1
#define IBVSOCKET_MIN_BUF_SIZE 4096 // 4kiB
#define IBVSOCKET_MAX_BUF_SIZE_NUM 134217728 // num * size <= 128MiB
#ifdef BEEGFS_NVFS
#define IBVSOCKET_WC_ENTRIES 1
#endif /* BEEGFS_NVFS */
void IBVSocket_init(IBVSocket* _this)
{
memset(_this, 0, sizeof(*_this) );
_this->sockValid = false;
_this->epollFD = -1;
_this->typeOfService = IBVSOCKET_DEFAULT_TOS;
_this->timeoutCfg.connectMS = IBVSOCKET_CONN_TIMEOUT_MS;
_this->timeoutCfg.flowSendMS = IBVSOCKET_FLOWCONTROL_ONSEND_TIMEOUT_MS;
_this->cm_channel = rdma_create_event_channel();
if(!_this->cm_channel)
{
LOG(SOCKLIB, WARNING, "rdma_create_event_channel failed.");
return;
}
if(rdma_create_id(_this->cm_channel, &_this->cm_id, NULL, RDMA_PS_TCP) )
{
LOG(SOCKLIB, WARNING, "rdma_create_id failed.");
return;
}
_this->sockValid = true;
return;
}
/**
* Note: Intended for incoming accepted connections.
*
* @param commContext belongs to this object (so do not use or free it after calling this!)
*/
void __IBVSocket_initFromCommContext(IBVSocket* _this, struct rdma_cm_id* cm_id,
IBVCommContext* commContext)
{
memset(_this, 0, sizeof(*_this) );
_this->sockValid = false;
_this->epollFD = -1;
_this->typeOfService = IBVSOCKET_DEFAULT_TOS;
_this->cm_id = cm_id;
_this->commContext = commContext;
#ifdef SYSTEM_HAS_RDMA_MIGRATE_ID__disabled
// note: see _accept() for the reasons why this is currently disabled
_this->cm_channel = rdma_create_event_channel();
if(!_this->cm_channel)
{
LOG(SOCKLIB, WARNING, "rdma_create_event_channel failed.");
return;
}
#endif // SYSTEM_HAS_RDMA_MIGRATE_ID
_this->sockValid = true;
LOG(SOCKLIB, DEBUG, __func__,
("_this", StringTk::uint64ToHexStr((uint64_t) _this)),
("device", cm_id->verbs->device->name));
return;
}
IBVSocket* IBVSocket_construct()
{
IBVSocket* _this = (IBVSocket*)malloc(sizeof(*_this) );
IBVSocket_init(_this);
return _this;
}
IBVSocket* __IBVSocket_constructFromCommContext(struct rdma_cm_id* cm_id,
IBVCommContext* commContext)
{
IBVSocket* _this = (IBVSocket*)malloc(sizeof(*_this) );
__IBVSocket_initFromCommContext(_this, cm_id, commContext);
return _this;
}
void IBVSocket_uninit(IBVSocket* _this)
{
if(_this->epollFD != -1)
close(_this->epollFD);
__IBVSocket_close(_this);
}
void IBVSocket_destruct(IBVSocket* _this)
{
IBVSocket_uninit(_this);
free(_this);
}
bool IBVSocket_rdmaDevicesExist()
{
bool devicesExist;
int numDevices = 1;
struct ibv_context** devicesRes;
devicesRes = rdma_get_devices(&numDevices);
devicesExist = (devicesRes != NULL) && (numDevices > 0);
if(devicesRes)
rdma_free_devices(devicesRes);
return devicesExist;
}
/**
* Prepare ibverbs for forking a child process. This is only required if the parent process
* has mapped memory for RDMA.
* Call this only once in your program.
*
* Note: There is no corresponding uninit-method that needs to be called.
*/
void IBVSocket_fork_init_once()
{
ibv_fork_init();
}
bool IBVSocket_connectByName(IBVSocket* _this, const char* hostname, unsigned short port,
IBVCommConfig* commCfg)
{
struct addrinfo *res;
struct addrinfo hints;
int getInfoRes;
struct in_addr ipaddress;
memset(&hints, 0, sizeof(hints) );
hints.ai_family = PF_INET;
hints.ai_socktype = SOCK_STREAM;
getInfoRes = getaddrinfo(hostname, NULL, &hints, &res);
if(getInfoRes < 0)
{
LOG(SOCKLIB, WARNING, "Name resolution error.", hostname, port,
("error", gai_strerror(getInfoRes)));
return false;
}
ipaddress.s_addr = ( (struct sockaddr_in*)res->ai_addr)->sin_addr.s_addr;
// clean-up
freeaddrinfo(res);
return IBVSocket_connectByIP(_this, ipaddress, port, commCfg);
}
bool IBVSocket_connectByIP(IBVSocket* _this, struct in_addr ipaddress, unsigned short port,
IBVCommConfig* commCfg)
{
struct rdma_cm_event* event;
struct sockaddr_in sin;
bool createContextRes;
struct rdma_conn_param conn_param;
bool parseCommDestRes;
bool epollInitRes;
int rc;
int connTimeoutMS = IBVSOCKET_CONN_TIMEOUT_INITIAL_POLL_MS;
int connTimeoutRemaining = IBVSOCKET_CONN_TIMEOUT_MS;
int oldChannelFlags;
int setOldFlagsRes;
LOG(SOCKLIB, DEBUG, "Connect RDMASocket", ("socket", _this), ("addr", Socket::endpointAddrToStr(ipaddress, port)),
("bindIP", Socket::ipaddrToStr(_this->bindIP)));
// resolve IP address...
sin.sin_addr.s_addr = ipaddress.s_addr;
sin.sin_family = AF_INET;
sin.sin_port = htons(port);
if(rdma_resolve_addr(_this->cm_id, NULL, (struct sockaddr*)&sin, _this->timeoutCfg.connectMS) )
{
LOG(SOCKLIB, WARNING, "rdma_resolve_addr failed.");
goto err_invalidateSock;
}
if(rdma_get_cm_event(_this->cm_channel, &event))
goto err_invalidateSock;
if(event->event != RDMA_CM_EVENT_ADDR_RESOLVED)
{
LOG(SOCKLIB, DEBUG, "Unexpected CM event.", ("event", rdma_event_str(event->event)));
goto err_ack_and_invalidateSock;
}
rdma_ack_cm_event(event);
// set type of service for connection
if (_this->typeOfService)
{
if (rdma_set_option(_this->cm_id, RDMA_OPTION_ID, RDMA_OPTION_ID_TOS, &(_this->typeOfService),
sizeof(_this->typeOfService)))
{
LOG(SOCKLIB, WARNING, "Failed to set Type Of Service.",
("tos", _this->typeOfService));
goto err_invalidateSock;
}
}
// resolve route...
if(rdma_resolve_route(_this->cm_id, _this->timeoutCfg.connectMS) )
{
LOG(SOCKLIB, WARNING, "rdma_resolve_route failed.");
goto err_invalidateSock;
}
if(rdma_get_cm_event(_this->cm_channel, &event))
goto err_invalidateSock;
if(event->event != RDMA_CM_EVENT_ROUTE_RESOLVED)
{
LOG(SOCKLIB, WARNING, "Unexpected CM event.",
("event", rdma_event_str(event->event)));
goto err_ack_and_invalidateSock;
}
rdma_ack_cm_event(event);
// create comm context...
createContextRes = __IBVSocket_createCommContext(_this, _this->cm_id, commCfg,
&_this->commContext);
if(!createContextRes)
{
LOG(SOCKLIB, WARNING, "creation of CommContext failed.");
goto err_invalidateSock;
}
// establish connection...
__IBVSocket_initCommDest(_this->commContext, &_this->localDest);
memset(&conn_param, 0, sizeof(conn_param) );
#ifdef BEEGFS_NVFS
conn_param.responder_resources = RDMA_MAX_RESP_RES;
conn_param.initiator_depth = RDMA_MAX_INIT_DEPTH;
#else
conn_param.responder_resources = 1;
conn_param.initiator_depth = 1;
#endif /* BEEGFS_NVFS */
conn_param.flow_control = 0;
conn_param.retry_count = 7; // (3 bits)
conn_param.rnr_retry_count = 7; // rnr = receiver not ready (3 bits, 7 means infinity)
conn_param.private_data = &_this->localDest;
conn_param.private_data_len = sizeof(_this->localDest);
if(rdma_connect(_this->cm_id, &conn_param))
{
LOG(SOCKLIB, DEBUG, "rdma_connect failed.");
goto err_invalidateSock;
}
oldChannelFlags = fcntl(IBVSocket_getConnManagerFD(_this), F_GETFL);
rc = fcntl(IBVSocket_getConnManagerFD(_this), F_SETFL, oldChannelFlags | O_NONBLOCK);
if(rc < 0)
{
LOG(SOCKLIB, WARNING, "Set conn manager channel non-blocking failed.", sysErr);
goto err_invalidateSock;
}
// rdma_connect() can take a very long time (>5m) to timeout if the peer's HCA is down.
// Change the channel to non-blocking and use a custom timeout mechanism.
rc = -1;
while (connTimeoutRemaining > 0)
{
// (non-blocking) check for new events
rc = rdma_get_cm_event(_this->cm_channel, &event);
if (rc)
{
if (errno != ETIMEDOUT && errno != EAGAIN)
{
LOG(SOCKLIB, WARNING, "rdma_get_cm_event failed", ("errno", errno));
break;
}
}
else
{
// we got an event
LOG(SOCKLIB, DEBUG, "Received RDMA connect response event.", ("Milliseconds spent polling", IBVSOCKET_CONN_TIMEOUT_MS - connTimeoutRemaining));
break;
}
connTimeoutRemaining -= connTimeoutMS;
if (connTimeoutRemaining > 0)
{
struct timespec ts = {
.tv_sec = 0,
.tv_nsec = (connTimeoutMS * 1000 * 1000)
};
// progressively scale the timeout by squaring it until it is larger than
// IBVSOCKET_CONN_TIMEOUT_MAX_POLL_MS
if (connTimeoutMS == 1)
{
connTimeoutMS = 2;
}
else if (connTimeoutMS * 2 <= IBVSOCKET_CONN_TIMEOUT_MAX_POLL_MS)
{
connTimeoutMS *= 2;
}
if (::nanosleep(&ts, NULL) != 0)
{
LOG(SOCKLIB, DEBUG, "rdma_connect: sleep interrupted");
break;
}
}
else
LOG(SOCKLIB, DEBUG, "rdma_connect: timed out");
}
// change channel mode back to blocking
setOldFlagsRes = fcntl(IBVSocket_getConnManagerFD(_this), F_SETFL, oldChannelFlags);
if(setOldFlagsRes < 0)
{
LOG(SOCKLIB, WARNING, "Set conn manager channel blocking failed.", sysErr);
if (rc == 0)
goto err_ack_and_invalidateSock;
else
goto err_invalidateSock;
}
if (rc != 0)
goto err_invalidateSock;
if(event->event != RDMA_CM_EVENT_ESTABLISHED)
{
if(event->event == RDMA_CM_EVENT_REJECTED)
LOG(SOCKLIB, DEBUG, "Connection rejected.");
else
LOG(SOCKLIB, WARNING, "Unexpected conn manager event.",
("event", rdma_event_str(event->event)));
goto err_ack_and_invalidateSock;
}
parseCommDestRes = __IBVSocket_parseCommDest(
event->param.conn.private_data, event->param.conn.private_data_len, &_this->remoteDest);
if(!parseCommDestRes)
{
LOG(SOCKLIB, WARNING, "Bad private data received.",
("len", event->param.conn.private_data_len));
goto err_ack_and_invalidateSock;
}
rdma_ack_cm_event(event);
epollInitRes = __IBVSocket_initEpollFD(_this);
if(!epollInitRes)
goto err_invalidateSock;
return true;
err_ack_and_invalidateSock:
rdma_ack_cm_event(event);
err_invalidateSock:
_this->errState = -1;
return false;
}
/**
* @return true on success
*/
bool IBVSocket_bind(IBVSocket* _this, unsigned short port)
{
in_addr_t ipAddr = INADDR_ANY;
return IBVSocket_bindToAddr(_this, ipAddr, port);
}
bool IBVSocket_bindToAddr(IBVSocket* _this, in_addr_t ipAddr, unsigned short port)
{
struct sockaddr_in bindAddr;
bindAddr.sin_family = AF_INET;
bindAddr.sin_addr.s_addr = ipAddr;
bindAddr.sin_port = htons(port);
LOG(SOCKLIB, DEBUG, "Bind RDMASocket", ("socket", _this), ("addr", Socket::endpointAddrToStr(ipAddr, port)));
if(rdma_bind_addr(_this->cm_id, (struct sockaddr*)&bindAddr) )
{
//SyslogLogger::log(LOG_WARNING, "%s:%d rdma_bind_addr failed (port: %d)\n",
//__func__, __LINE__, (int)port); // debug in
goto err_invalidateSock;
}
_this->bindIP.s_addr = ipAddr;
return true;
err_invalidateSock:
_this->errState = -1;
return false;
}
/**
* Note: This also inits the delayedCmEventsQueue.
*
* @return true on success
*/
bool IBVSocket_listen(IBVSocket* _this)
{
if(rdma_listen(_this->cm_id, IBVSOCKET_LISTEN_BACKLOG) )
{
LOG(SOCKLIB, WARNING, "rdma_listen failed.");
goto err_invalidateSock;
}
// init delayed events queue
_this->delayedCmEventsQ = new CmEventQueue();
return true;
err_invalidateSock:
_this->errState = -1;
return false;
}
/**
* Note: Call IBVSocket_checkDelayedEvents() after this to find out whether more events
* are waiting.
* Note: Because of the special way ibverbs accept connections, it is possible that we receive
* some other events here as well (e.g. a child socket disconnect). In these cases,
* ACCEPTRES_IGNORE will be returned.
*
* @param outAcceptedSock only valid when ACCEPTRES_SUCCESS is returned
* @param peerAddr (out) peer address
* @param peerAddrLen (out) length of peer address
* @return ACCEPTRES_IGNORE in case an irrelevant event occurred
*/
IBVSocket_AcceptRes IBVSocket_accept(IBVSocket* _this, IBVSocket** outAcceptedSock,
struct sockaddr* peerAddr, socklen_t* peerAddrLen)
{
struct rdma_cm_event* event = NULL;
IBVCommContext* childCommContext = NULL;
IBVSocket* acceptedSock = NULL; // auto-destructed on error/ignore (internal, not for caller)
IBVCommDest* childRemoteDest = NULL; // auto-freed on error/ignore
*outAcceptedSock = NULL;
// get next waiting event from delay-queue or from event channel
if (!_this->delayedCmEventsQ->empty())
{
event = _this->delayedCmEventsQ->front();
_this->delayedCmEventsQ->pop();
}
else
if(rdma_get_cm_event(_this->cm_channel, &event) )
{
_this->errState = -1;
return ACCEPTRES_ERR;
}
// handle event type
switch(event->event)
{
case RDMA_CM_EVENT_CONNECT_REQUEST:
{
// got an incoming 'connect request' => check validity of private data and accept/reject
bool createContextRes;
struct rdma_conn_param conn_param;
bool parseCommDestRes;
IBVCommConfig commCfg;
struct rdma_cm_id* child_cm_id = event->id;
//*peerAddrLen = sizeof(struct sockaddr_in);
//memcpy(peerAddr, &child_cm_id->route.addr.dst_addr, *peerAddrLen);
// parse private data to get remote dest
parseCommDestRes = __IBVSocket_parseCommDest(
event->param.conn.private_data, event->param.conn.private_data_len, &childRemoteDest);
if(!parseCommDestRes)
{ // bad private data => reject connection
LOG(SOCKLIB, WARNING, "Bad private data received.",
("len", event->param.conn.private_data_len));
if(rdma_reject(child_cm_id, NULL, 0) )
LOG(SOCKLIB, WARNING, "rdma_reject failed.");
goto ignore;
}
// private data (remote dest) okay => create local comm context and socket instance
// (we use the buffer config as suggested by the connecting peer)
commCfg.bufNum = childRemoteDest->recvBufNum;
commCfg.bufSize = childRemoteDest->recvBufSize;
createContextRes = __IBVSocket_createCommContext(_this, child_cm_id, &commCfg,
&childCommContext);
if(!createContextRes)
{
LOG(SOCKLIB, WARNING, "Creation of CommContext failed.");
if(rdma_reject(child_cm_id, NULL, 0) )
LOG(SOCKLIB, WARNING, "rdma_reject failed.");
goto ignore;
}
acceptedSock = __IBVSocket_constructFromCommContext(child_cm_id, childCommContext);
if(!acceptedSock->sockValid)
goto ignore;
acceptedSock->remoteDest = childRemoteDest;
childRemoteDest = NULL; // would otherwise be destroyed at 'ignore'
// send accept message (with local destination info)
__IBVSocket_initCommDest(childCommContext, &acceptedSock->localDest);
memset(&conn_param, 0, sizeof(conn_param) );
#ifdef BEEGFS_NVFS
conn_param.responder_resources = RDMA_MAX_RESP_RES;
conn_param.initiator_depth = RDMA_MAX_INIT_DEPTH;
#else
conn_param.responder_resources = 1;
conn_param.initiator_depth = 1;
#endif /* BEEGFS_NVFS */
conn_param.flow_control = 0;
conn_param.retry_count = 7; // (3 bits)
conn_param.rnr_retry_count = 7; // rnr = receiver not ready (3 bits, 7 means infinity)
conn_param.private_data = &acceptedSock->localDest;
conn_param.private_data_len = sizeof(acceptedSock->localDest);
// test point for dropping the connect request
if(IBVSocket_connectionRejection(_this))
goto ignore;
if(rdma_accept(child_cm_id, &conn_param) )
{
LOG(SOCKLIB, WARNING, "rdma_accept failed.");
goto ignore;
}
if(!__IBVSocket_initEpollFD(acceptedSock) )
goto ignore;
// Note that this code returns ACCEPTRES_IGNORE
LOG(SOCKLIB, DEBUG, "Connection request on RDMASocket");
child_cm_id->context = acceptedSock;
acceptedSock = NULL; // would otherwise be destroyed at 'ignore'
} break;
case RDMA_CM_EVENT_ESTABLISHED:
{
// received 'established' (this is what we've actually been waiting for!)
*peerAddrLen = sizeof(struct sockaddr_in);
memcpy(peerAddr, &event->id->route.addr.dst_addr, *peerAddrLen);
*outAcceptedSock = (IBVSocket*)event->id->context;
rdma_ack_cm_event(event);
#ifdef SYSTEM_HAS_RDMA_MIGRATE_ID__disabled
// note: this is currently disabled, because:
// a) rdma_migrate_id always returns "invalid argument"
// b) we need disconnect events for incoming conns to be handled and the handler must call
// rdma_disconnect to enable disconnect detection for the streamlistener
// note: migration might deadlock if there are any retrieved but not yet ack'ed events
// for the current channel, so we cannot migrate if this is the case
// note: the only purpose of migration to a separate channel is that we can do better
// disconnect detection in waitForCompletion(). so living without the migration is
// generally not a problem (but disconnect detection might take longer).
if(_this->delayedCmEventsQ->size() )
{ // events waiting => don't migrate
LOG(SOCKLIB, WARNING,
"Skipping rdma_migrate_id due to waiting events (but we can live without it).");
}
else
{ // migrate cm_id from general accept-channel to its own channel
int migrateRes = rdma_migrate_id(
(*outAcceptedSock)->cm_id, (*outAcceptedSock)->cm_channel);
if(migrateRes)
{
LOG(SOCKLIB, WARNING, "rdma_migrate_id failed (but we can live without it).",
migrateRes, sysErr);
}
}
#endif // SYSTEM_HAS_RDMA_MIGRATE_ID
return ACCEPTRES_SUCCESS;
} break;
case RDMA_CM_EVENT_DISCONNECTED:
{
// note: be careful about what we do with the event-socket here, because the socket might
// already be under destruction in another thread.
LOG(SOCKLIB, DEBUG, "Disconnect event.");
// note: the additional disconnect call is required to get the streamlistener event
// channel (the one of the listen sock) to report the disconnect
rdma_disconnect(event->id);
} break;
case RDMA_CM_EVENT_UNREACHABLE:
{
LOG(SOCKLIB, WARNING, "Remote unreachable event while waiting for 'established'.");
acceptedSock = (IBVSocket*)event->id->context; // will be destroyed at 'ignore'
} break;
case RDMA_CM_EVENT_CONNECT_ERROR:
{
LOG(SOCKLIB, WARNING, "Connect error event while waiting for 'established'.");
acceptedSock = (IBVSocket*)event->id->context; // will be destroyed at 'ignore'
} break;
case RDMA_CM_EVENT_TIMEWAIT_EXIT:
{ // log only with enabled debug code
LOG(SOCKLIB, DEBUG, "Ignoring conn manager event RDMA_CM_EVENT_TIMEWAIT_EXIT.");
} break;
case RDMA_CM_EVENT_DEVICE_REMOVAL:
{
AbstractApp* app = PThread::getCurrentThreadApp();
const char* devname = "unknown";
if (event->id && event->id->verbs)
devname = ibv_get_device_name(event->id->verbs->device);
LOG(SOCKLIB, ERR, "Device removed", ("device", devname));
app->handleNetworkInterfaceFailure(std::string(devname));
} break;
default:
{ // ignore other events
// always log
LOG(SOCKLIB, WARNING, "Ignoring conn manager event.",
("event", rdma_event_str(event->event)));
} break;
}
// irrelevant event (irrelevant for the caller)
ignore:
rdma_ack_cm_event(event);
SAFE_FREE(childRemoteDest);
if(acceptedSock)
IBVSocket_destruct(acceptedSock);
*outAcceptedSock = NULL;
return ACCEPTRES_IGNORE;
}
bool IBVSocket_shutdown(IBVSocket* _this)
{
IBVCommContext* commContext = _this->commContext;
if(!commContext)
return true; // this socket has never been connected
// if object is in errState, then the socket might be in an inconsistent state,
// therefore further commands (except for disconnect) should not be executed
if(!_this->errState && commContext->incompleteSend.numAvailable)
{ // wait for all incomplete sends
int waitRes;
waitRes = __IBVSocket_waitForTotalSendCompletion(
_this, commContext->incompleteSend.numAvailable, 0, 0);
if(waitRes < 0)
{
LOG(SOCKLIB, WARNING, "Waiting for incomplete send requests failed.");
return false;
}
}
__IBVSocket_disconnect(_this);
return true;
}
/**
* Continues an incomplete former recv() by returning immediately available data from the
* corresponding buffer.
*/
ssize_t __IBVSocket_recvContinueIncomplete(IBVSocket* _this, char* buf, size_t bufLen)
{
IBVCommContext* commContext = _this->commContext;
int completedOffset = commContext->incompleteRecv.completedOffset;
size_t availableLen = commContext->incompleteRecv.wc.byte_len - completedOffset;
size_t bufIndex = commContext->incompleteRecv.wc.wr_id - IBVSOCKET_RECV_WORK_ID_OFFSET;
if(availableLen <= bufLen)
{ // old data fits completely into buf
memcpy(buf, &(commContext->recvBufs)[bufIndex][completedOffset], availableLen);
commContext->incompleteRecv.isAvailable = 0;
int postRes = __IBVSocket_postRecv(_this, _this->commContext, bufIndex);
if(unlikely(postRes) )
goto err_invalidateSock;
return availableLen;
}
else
{ // still too much data for the buf => copy partially
memcpy(buf, &(commContext->recvBufs)[bufIndex][completedOffset], bufLen);
commContext->incompleteRecv.completedOffset += bufLen;
return bufLen;
}
err_invalidateSock:
_this->errState = -1;
return -1;
}
ssize_t IBVSocket_recv(IBVSocket* _this, char* buf, size_t bufLen, int flags)
{
const int timeoutMS = IBVSOCKET_RECV_TIMEOUT_MS;
ssize_t recvTRes;
do
{
recvTRes = IBVSocket_recvT(_this, buf, bufLen, flags, timeoutMS);
} while(recvTRes == -ETIMEDOUT);
return recvTRes;
}
/**
* @return number of received bytes on success, 0 on timeout, -1 on error
*/
ssize_t IBVSocket_recvT(IBVSocket* _this, char* buf, size_t bufLen, int flags, int timeoutMS)
{
IBVCommContext* commContext = _this->commContext;
struct ibv_wc* wc = &commContext->incompleteRecv.wc;
int flowControlRes;
int recvWCRes;
if(unlikely(_this->errState) )
return -1;
// check whether an old buffer has not been fully read yet
if(!commContext->incompleteRecv.isAvailable)
{ // no partially read data available => recv new buffer
// check whether we have a pending on-send flow control packet that needs to be received first
flowControlRes = __IBVSocket_flowControlOnSendWait(_this, timeoutMS);
if(flowControlRes <= 0)
{
if(likely(!flowControlRes) )
return -ETIMEDOUT; // timeout
goto err_invalidateSock;
}
// recv a new buffer (into the incompleteRecv structure)
recvWCRes = __IBVSocket_recvWC(_this, timeoutMS, wc);
if(recvWCRes <= 0)
{
if(likely(!recvWCRes) )
return -ETIMEDOUT; // timeout
goto err_invalidateSock; // error occurred
}
// recvWC was positive => we're guaranteed to have an incompleteRecv buf availabe
commContext->incompleteRecv.completedOffset = 0;
commContext->incompleteRecv.isAvailable = 1;
}
return __IBVSocket_recvContinueIncomplete(_this, buf, bufLen);
err_invalidateSock:
_this->errState = -1;
return -ECOMM;
}
ssize_t IBVSocket_send(IBVSocket* _this, const char* buf, size_t bufLen, int flags)
{
IBVCommContext* commContext = _this->commContext;
int flowControlRes;
size_t currentBufIndex;
int postRes;
size_t postedLen = 0;
int currentPostLen;
int waitRes;
if(unlikely(_this->errState) )
return -1;
do
{
flowControlRes = __IBVSocket_flowControlOnSendWait(_this,
_this->timeoutCfg.flowSendMS);
if(unlikely(flowControlRes <= 0) )
goto err_invalidateSock;
// note: we only poll for completed sends after we used up all (!) available bufs
if(commContext->incompleteSend.numAvailable == commContext->commCfg.bufNum)
{ // wait for all (!) incomplete sends
waitRes = __IBVSocket_waitForTotalSendCompletion(
_this, commContext->incompleteSend.numAvailable, 0, 0);
if(waitRes < 0)
goto err_invalidateSock;
commContext->incompleteSend.numAvailable = 0;
}
currentPostLen = BEEGFS_MIN(bufLen-postedLen, commContext->commCfg.bufSize);
currentBufIndex = commContext->incompleteSend.numAvailable;
memcpy( (commContext->sendBufs)[currentBufIndex], &buf[postedLen], currentPostLen);
commContext->incompleteSend.numAvailable++; /* inc'ed before postSend() for conn checks */
postRes = __IBVSocket_postSend(_this, currentBufIndex, currentPostLen);
if(unlikely(postRes) )
{
commContext->incompleteSend.numAvailable--;
goto err_invalidateSock;
}
postedLen += currentPostLen;
} while(postedLen < bufLen);
return (ssize_t)bufLen;
err_invalidateSock:
_this->errState = -1;
return -ECOMM;
}
int __IBVSocket_registerBuf(IBVCommContext* commContext, void* buf, size_t bufLen,
struct ibv_mr** outMR)
{
/* note: IB spec says:
"The consumer is not allowed to assign remote-write or remote-atomic to
a memory region that has not been assigned local-write." */
enum ibv_access_flags accessFlags = (enum ibv_access_flags)
(IBV_ACCESS_REMOTE_READ | IBV_ACCESS_REMOTE_WRITE | IBV_ACCESS_LOCAL_WRITE);
*outMR = ibv_reg_mr(commContext->pd, buf, bufLen, accessFlags);
if(!*outMR)
{
LOG(SOCKLIB, WARNING, "Couldn't allocate MR.");
return -1;
}
return 0;
}
char* __IBVSocket_allocAndRegisterBuf(IBVCommContext* commContext, size_t bufLen,
struct ibv_mr** outMR)
{
void* buf;
int registerRes;
int allocRes = posix_memalign(&buf, sysconf(_SC_PAGESIZE), bufLen);
if(allocRes)
{
LOG(SOCKLIB, WARNING, "Couldn't allocate work buf.");
return NULL;
}
memset(buf, 0, bufLen);
registerRes = __IBVSocket_registerBuf(commContext, buf, bufLen, outMR);
if(registerRes < 0)
{
free(buf);
return NULL;
}
return (char*)buf;
}
bool __IBVSocket_createCommContext(IBVSocket* _this, struct rdma_cm_id* cm_id,
IBVCommConfig* commCfg, IBVCommContext** outCommContext)
{
IBVCommContext* commContext = NULL;
int registerControlRes;
int registerControlResReset;
struct ibv_qp_init_attr qpInitAttr;
int createQPRes;
unsigned i;
// sanity checks
if (unlikely(commCfg->bufNum < IBVSOCKET_MIN_BUF_NUM) )
{
LOG(SOCKLIB, WARNING, "bufNum too small!",
("got", commCfg->bufNum), ("minimum", IBVSOCKET_MIN_BUF_NUM));
goto err_cleanup;
}
if (unlikely(commCfg->bufSize < IBVSOCKET_MIN_BUF_SIZE) ) // sanity check
{
LOG(SOCKLIB, WARNING, "bufSize too small!",
("got", commCfg->bufSize), ("minimum", IBVSOCKET_MIN_BUF_SIZE));
goto err_cleanup;
}
if (commCfg->bufSize * commCfg->bufNum > IBVSOCKET_MAX_BUF_SIZE_NUM)
{
LOG(SOCKLIB, WARNING, "bufSize*bufNum too large!",
("got", commCfg->bufSize * commCfg->bufNum),
("maximum", IBVSOCKET_MAX_BUF_SIZE_NUM));
goto err_cleanup;
}
commContext = (IBVCommContext*)calloc(1, sizeof(*commContext) );
if(!commContext)
goto err_cleanup;
commContext->context = cm_id->verbs;
if(!commContext->context)
{
LOG(SOCKLIB, WARNING, "Unbound cm_id!!");
goto err_cleanup;
}
commContext->pd = ibv_alloc_pd(commContext->context);
if(!commContext->pd)
{
LOG(SOCKLIB, WARNING, "Couldn't allocate PD.");
goto err_cleanup;
}
// alloc and register buffers...
commContext->commCfg = *commCfg;
commContext->recvBuf = __IBVSocket_allocAndRegisterBuf(
commContext, commCfg->bufSize * commCfg->bufNum, &commContext->recvMR);
if(!commContext->recvBuf)
{
LOG(SOCKLIB, WARNING, "Couldn't prepare recvBuf.");
goto err_cleanup;
}
commContext->recvBufs = (char**)calloc(1, commCfg->bufNum * sizeof(char*) );
for(i=0; i < commCfg->bufNum; i++)
commContext->recvBufs[i] = &commContext->recvBuf[i * commCfg->bufSize];
commContext->sendBuf = __IBVSocket_allocAndRegisterBuf(
commContext, commCfg->bufSize * commCfg->bufNum, &commContext->sendMR);
if(!commContext->sendBuf)
{
LOG(SOCKLIB, WARNING, "Couldn't prepare sendBuf.");
goto err_cleanup;
}
commContext->sendBufs = (char**)calloc(1, commCfg->bufNum * sizeof(char*) );
for(i=0; i < commCfg->bufNum; i++)
commContext->sendBufs[i] = &commContext->sendBuf[i * commCfg->bufSize];
registerControlRes = __IBVSocket_registerBuf(
commContext, (char*)&commContext->numUsedSendBufs,
sizeof(commContext->numUsedSendBufs), &commContext->controlMR);
if(registerControlRes < 0)
{
LOG(SOCKLIB, WARNING, "Couldn't register control memory region.");
goto err_cleanup;
}
registerControlResReset = __IBVSocket_registerBuf(
commContext, (char*)&commContext->numUsedSendBufsReset,
sizeof(commContext->numUsedSendBufsReset), &commContext->controlResetMR);
if(registerControlResReset < 0)
{
LOG(SOCKLIB, WARNING, "Couldn't register control memory reset region.");
goto err_cleanup;
}
// init flow control v2 (to avoid long receiver-not-ready timeouts)
/* note: we use -1 because the last buf might not be read by the user (eg during
nonblockingRecvCheck) and so it might not be immediately available again. */
commContext->numReceivedBufsLeft = commCfg->bufNum - 1;
commContext->numSendBufsLeft = commCfg->bufNum - 1;
// create completion channel and queues...
commContext->recvCompChannel = ibv_create_comp_channel(commContext->context);
if(!commContext->recvCompChannel)
{
LOG(SOCKLIB, WARNING, "Couldn't create comp channel.");
goto err_cleanup;
}
commContext->recvCQ = ibv_create_cq(
commContext->context, commCfg->bufNum, commContext, commContext->recvCompChannel,
rand()%commContext->context->num_comp_vectors);
if(!commContext->recvCQ)
{
LOG(SOCKLIB, WARNING, "Couldn't create recv CQ.");
goto err_cleanup;
}
// note: 1+commCfg->bufNum here for the RDMA write usedBufs reset work (=> flow/flood control)
commContext->sendCQ = ibv_create_cq(
commContext->context, 1+commCfg->bufNum, NULL, NULL,
rand()%commContext->context->num_comp_vectors);
if(!commContext->sendCQ)
{
LOG(SOCKLIB, WARNING, "Couldn't create send CQ.");
goto err_cleanup;
}
// note: 1+commCfg->bufNum here for the RDMA write usedBufs reset work
memset(&qpInitAttr, 0, sizeof(qpInitAttr) );
qpInitAttr.send_cq = commContext->sendCQ;
qpInitAttr.recv_cq = commContext->recvCQ;
qpInitAttr.qp_type = IBV_QPT_RC;
qpInitAttr.sq_sig_all = 1;
qpInitAttr.cap.max_send_wr = 1+commCfg->bufNum;
qpInitAttr.cap.max_recv_wr = commCfg->bufNum;
qpInitAttr.cap.max_send_sge = 1;
qpInitAttr.cap.max_recv_sge = 1;
qpInitAttr.cap.max_inline_data = 0;
createQPRes = rdma_create_qp(cm_id, commContext->pd, &qpInitAttr);
if(createQPRes)
{
LOG(SOCKLIB, WARNING, "Couldn't create QP.", sysErr);
goto err_cleanup;
}
commContext->qp = cm_id->qp;
// post initial recv buffers...
for(i=0; i < commCfg->bufNum; i++)
{
if(__IBVSocket_postRecv(_this, commContext, i) )
{
LOG(SOCKLIB, WARNING, "Couldn't post recv buffer.", ("index", i));
goto err_cleanup;
}
}
// prepare event notification...
// initial event notification request
if(ibv_req_notify_cq(commContext->recvCQ, 0) )
{
LOG(SOCKLIB, WARNING, "Couldn't request CQ notification.");
goto err_cleanup;
}
#ifdef BEEGFS_NVFS
commContext->workerMRs = new MRMap();
commContext->cqMutex = new Mutex();
commContext->cqCompletions = new CQMap();
// RDMA id. (This variable will increment for each RDMA operation.)
commContext->wr_id = 1;
#endif /* BEEGFS_NVFS */
LOG(SOCKLIB, DEBUG, __func__,
("_this", StringTk::uint64ToHexStr((uint64_t) _this)),
("device", cm_id->verbs->device->name));
*outCommContext = commContext;
return true;
// error handling
err_cleanup:
__IBVSocket_cleanupCommContext(cm_id, commContext);
*outCommContext = NULL;
return false;
}
void __IBVSocket_cleanupCommContext(struct rdma_cm_id* cm_id, IBVCommContext* commContext)
{
if(!commContext)
return;
if(commContext->qp)
{
// see recommendation here: https://www.rdmamojo.com/2012/12/28/ibv_destroy_qp/
// the qp should be set to error state, so that no more events can be pushed to that queue.
struct ibv_qp_attr qpAttr;
qpAttr.qp_state = IBV_QPS_ERR;
if (ibv_modify_qp(commContext->qp, &qpAttr, IBV_QP_STATE))
{
LOG(SOCKLIB, WARNING, "Failed to modify qp IBV_QP_STATE.");
}
}
// ack remaining delayed acks
if(commContext->recvCQ && commContext->numUnackedRecvCompChannelEvents)
ibv_ack_cq_events(commContext->recvCQ, commContext->numUnackedRecvCompChannelEvents);
if(commContext->qp)
{
rdma_destroy_qp(cm_id);
}
if(commContext->sendCQ)
{
if(ibv_destroy_cq(commContext->sendCQ) )
LOG(SOCKLIB, WARNING, "Failed to destroy sendCQ.");
}
if(commContext->recvCQ)
{
if(ibv_destroy_cq(commContext->recvCQ) )
LOG(SOCKLIB, WARNING, "Failed to destroy recvCQ.");
}
if(commContext->recvCompChannel)
{
if(ibv_destroy_comp_channel(commContext->recvCompChannel) )
LOG(SOCKLIB, WARNING, "Failed to destroy recvCompChannel.");
}
if(commContext->controlMR)
{
if(ibv_dereg_mr(commContext->controlMR) )
LOG(SOCKLIB, WARNING, "Failed to deregister controlMR.");
}
if(commContext->controlResetMR)
{
if(ibv_dereg_mr(commContext->controlResetMR) )
LOG(SOCKLIB, WARNING, "Failed to deregister controlResetMR.");
}
if(commContext->recvMR)
{
if(ibv_dereg_mr(commContext->recvMR) )
LOG(SOCKLIB, WARNING, "Failed to deregister recvMR.");
}
if(commContext->sendMR)
{
if(ibv_dereg_mr(commContext->sendMR) )
LOG(SOCKLIB, WARNING, "Failed to deregister sendMR.");
}
#ifdef BEEGFS_NVFS
if (commContext->workerMRs)
{
for (auto& iter: *(commContext->workerMRs))
{
if(ibv_dereg_mr(iter.second) )
LOG(SOCKLIB, WARNING, "Failed to deregister workerMR.");
}
commContext->workerMRs->clear();
delete(commContext->workerMRs);
}
if (commContext->cqCompletions)
{
commContext->cqCompletions->clear();
delete(commContext->cqCompletions);
}
delete(commContext->cqMutex);
#endif /* BEEGFS_NVFS */
SAFE_FREE(commContext->recvBuf);
SAFE_FREE(commContext->sendBuf);
SAFE_FREE(commContext->recvBufs);
SAFE_FREE(commContext->sendBufs);
if(commContext->pd)
{
if(ibv_dealloc_pd(commContext->pd) )
LOG(SOCKLIB, WARNING, "Failed to dealloc pd.");
}
free(commContext);
}
/**
* Initializes a (local) IBVCommDest.
*/
void __IBVSocket_initCommDest(IBVCommContext* commContext, IBVCommDest* outDest)
{
memcpy(outDest->verificationStr, IBVSOCKET_PRIVATEDATA_STR, IBVSOCKET_PRIVATEDATA_STR_LEN);
outDest->protocolVersion = HOST_TO_LE_64(IBVSOCKET_PRIVATEDATA_PROTOCOL_VER);
outDest->rkey = HOST_TO_LE_32(commContext->controlMR->rkey);
outDest->vaddr = HOST_TO_LE_64((uintptr_t)&commContext->numUsedSendBufs);
outDest->recvBufNum = HOST_TO_LE_32(commContext->commCfg.bufNum);
outDest->recvBufSize = HOST_TO_LE_32(commContext->commCfg.bufSize);
}
/**
* Checks and parses a (remote) IBVCommDest.
*
* @param buf should usually be the private_data of the connection handshake
* @param outDest will be alloced (if true is returned) and needs to be free'd by the caller
* @return true if data is okay, false otherwise
*/
bool __IBVSocket_parseCommDest(const void* buf, size_t bufLen, IBVCommDest** outDest)
{
IBVCommDest* dest = NULL;
*outDest = NULL;
// Note: "bufLen < ..." (and not "!="), because there might be some extra padding
if(!buf || (bufLen < sizeof(*dest) ) )
{
LOG(SOCKLIB, WARNING, "Bad private data size.", bufLen);
return false;
}
dest = (IBVCommDest*)malloc(sizeof(*dest) );
if(!dest)
return false;
memcpy(dest, buf, sizeof(*dest) );
if(memcmp(dest->verificationStr, IBVSOCKET_PRIVATEDATA_STR, IBVSOCKET_PRIVATEDATA_STR_LEN) != 0 )
goto err_cleanup;
dest->protocolVersion = LE_TO_HOST_64(dest->protocolVersion);
if (dest->protocolVersion != IBVSOCKET_PRIVATEDATA_PROTOCOL_VER)
goto err_cleanup;
dest->rkey = LE_TO_HOST_32(dest->rkey);
dest->vaddr = LE_TO_HOST_64(dest->vaddr);
dest->recvBufNum = LE_TO_HOST_32(dest->recvBufNum);
dest->recvBufSize = LE_TO_HOST_32(dest->recvBufSize);
*outDest = dest;
return true;
err_cleanup:
SAFE_FREE(dest);
return false;
}
/**
* Append buffer to receive queue.
*
* @param commContext passed seperately because it's not the _this->commContext during
* accept() of incoming connections
* @return 0 on success, -1 on error
*/
int __IBVSocket_postRecv(IBVSocket* _this, IBVCommContext* commContext, size_t bufIndex)
{
struct ibv_sge list;
struct ibv_recv_wr wr;
struct ibv_recv_wr* bad_wr;
int postRes;
list.addr = (uint64_t)commContext->recvBufs[bufIndex];
list.length = commContext->commCfg.bufSize;
list.lkey = commContext->recvMR->lkey;
wr.next = NULL;
wr.wr_id = bufIndex + IBVSOCKET_RECV_WORK_ID_OFFSET;
wr.sg_list = &list;
wr.num_sge = 1;
postRes = ibv_post_recv(commContext->qp, &wr, &bad_wr);
if(unlikely(postRes) )
{
LOG(SOCKLIB, WARNING, "ibv_post_recv failed.", postRes, sysErr(postRes));
return -1;
}
return 0;
}
/**
* Synchronous RDMA write (waits for completion)
*
* @return 0 on success, -1 on error
*/
int __IBVSocket_postWrite(IBVSocket* _this, IBVCommDest* remoteDest,
struct ibv_mr* localMR, char* localBuf, int bufLen)
{
IBVCommContext* commContext = _this->commContext;
struct ibv_sge list;
struct ibv_send_wr wr;
struct ibv_send_wr *bad_wr;
int postRes;
int waitRes;
list.addr = (uint64_t)localBuf;
list.length = bufLen;
list.lkey = localMR->lkey;
wr.wr.rdma.remote_addr = remoteDest->vaddr;
wr.wr.rdma.rkey = remoteDest->rkey;
wr.wr_id = IBVSOCKET_WRITE_WORK_ID;
wr.sg_list = &list;
wr.num_sge = 1;
wr.opcode = IBV_WR_RDMA_WRITE;
wr.send_flags = IBV_SEND_SIGNALED;
wr.next = NULL;
postRes = ibv_post_send(commContext->qp, &wr, &bad_wr);
if(unlikely(postRes) )
{
LOG(SOCKLIB, WARNING, "ibv_post_send() failed.", sysErr(postRes));
return -1;
}
waitRes = __IBVSocket_waitForTotalSendCompletion(_this,
commContext->incompleteSend.numAvailable, 1, 0);
if(unlikely(waitRes) )
return -1;
commContext->incompleteSend.numAvailable = 0;
return 0;
}
/**
* Synchronous RDMA read (waits for completion).
*
* @return 0 on success, -1 on error
*/
int __IBVSocket_postRead(IBVSocket* _this, IBVCommDest* remoteDest,
struct ibv_mr* localMR, char* localBuf, int bufLen)
{
IBVCommContext* commContext = _this->commContext;
struct ibv_sge list;
struct ibv_send_wr wr;
struct ibv_send_wr *bad_wr;
int postRes;
int waitRes;
list.addr = (uint64_t) localBuf;
list.length = bufLen;
list.lkey = localMR->lkey;
wr.wr.rdma.remote_addr = remoteDest->vaddr;
wr.wr.rdma.rkey = remoteDest->rkey;
wr.wr_id = IBVSOCKET_READ_WORK_ID;
wr.sg_list = &list;
wr.num_sge = 1;
wr.opcode = IBV_WR_RDMA_READ;
wr.send_flags = IBV_SEND_SIGNALED;
wr.next = NULL;
postRes = ibv_post_send(commContext->qp, &wr, &bad_wr);
if(unlikely(postRes) )
{
LOG(SOCKLIB, WARNING, "ibv_post_send() failed.", sysErr(postRes));
return -1;
}
waitRes = __IBVSocket_waitForTotalSendCompletion(_this,
commContext->incompleteSend.numAvailable, 0, 1);
if(unlikely(waitRes) )
return -1;
commContext->incompleteSend.numAvailable = 0;
return 0;
}
#ifdef BEEGFS_NVFS
static bool __IBVSocket_getBufferKey(IBVCommContext *commContext, char *buffer, unsigned *key)
{
struct ibv_mr *mr = NULL;
MRMap::const_iterator iter = commContext->workerMRs->find(buffer);
if (iter == commContext->workerMRs->end())
{
// It is assumed that buffer came from a Worker and is WORKER_BUFOUT_SIZE.
// TODO: pass around a Buffer with a length instead of unqualified char*.
// This cache of ibv_mr will potentially grow to Workers * Targets
// and the ibv_mr instances hang around until the IBVSocket is destroyed.
// That is probably something to look into...
if (unlikely(__IBVSocket_registerBuf(commContext, buffer, WORKER_BUFOUT_SIZE, &mr)))
{
LOG(SOCKLIB, WARNING, "ibv_postWrite(): failed to register buffer.");
return false;
}
commContext->workerMRs->insert({buffer, mr});
}
else
{
mr = iter->second;
}
*key = mr->lkey;
return true;
}
/**
* Wait for the completion of a specific RDMA operation.
* @return number of completed elements or -1 in case of an error
*/
static int __IBVSocket_waitForRDMACompletion(IBVCommContext* commContext, uint64_t id)
{
struct ibv_wc wc[IBVSOCKET_WC_ENTRIES];
int i = 0;
int found = 0;
int status = 0;
int num_wc = 0;
/*
* This function is locked so that we don't get a race condition between two workers
* looking for completions.
*/
commContext->cqMutex->lock();
CQMap::const_iterator iter = commContext->cqCompletions->find(id);
/*
* Check to see if we have already found the completion we are looking for.
*/
if (iter != commContext->cqCompletions->end())
{
commContext->cqCompletions->erase(id);
commContext->cqMutex->unlock();
return 0;
}
/*
* Continue to poll the CQ until we find the entry in question or we encounter a
* bad status.
*/
while (!found && !status)
{
num_wc = ibv_poll_cq(commContext->sendCQ, IBVSOCKET_WC_ENTRIES, wc);
if (num_wc > 0)
{
for (i = 0; i < num_wc; i++)
{
if (unlikely(wc[i].status != IBV_WC_SUCCESS))
{
LOG(SOCKLIB, DEBUG, "Connection error.", wc[i].status);
status = -1;
break;
}
if ((wc[i].opcode == IBV_WC_RDMA_WRITE) || (wc[i].opcode == IBV_WC_RDMA_READ))
{
if (wc[i].wr_id == id)
{
found = 1;
}
else
{
commContext->cqCompletions->insert({wc[i].wr_id, wc[i].opcode});
}
}
else if (wc[i].opcode == IBV_WC_SEND)
{
if (likely(commContext->incompleteSend.numAvailable))
{
commContext->incompleteSend.numAvailable--;
}
else
{
LOG(SOCKLIB, WARNING, "Received bad/unexpected send completion.");
status = -1;
break;
}
}
else
{
LOG(SOCKLIB, WARNING, "Received unexpected CQ opcode.", wc[i].opcode);
status = -1;
break;
}
}
}
}
commContext->cqMutex->unlock();
return status;
}
/**
* Process RDMA requests.
*
* @return 0 on success, -1 on error
*/
static int __IBVSocket_postRDMA(IBVSocket* _this, ibv_wr_opcode opcode,
char* localBuf, int bufLen, unsigned lkey,
uint64_t remoteBuf, unsigned rkey)
{
IBVCommContext* commContext = _this->commContext;
struct ibv_sge list;
struct ibv_send_wr wr;
struct ibv_send_wr *bad_wr;
int postRes;
int waitRes;
if (unlikely(lkey == 0))
{
if (unlikely(!__IBVSocket_getBufferKey(commContext, localBuf, &lkey)))
{
LOG(SOCKLIB, WARNING, "ibv_postRDMA(): no local key.");
return -1;
}
}
list.addr = (uint64_t) localBuf;
list.length = bufLen;
list.lkey = lkey;
wr.wr_id = __atomic_fetch_add(&commContext->wr_id, 1, __ATOMIC_SEQ_CST);
wr.next = NULL;
wr.sg_list = &list;
wr.num_sge = 1;
wr.opcode = opcode;
wr.send_flags = IBV_SEND_SIGNALED;
wr.wr.rdma.remote_addr = remoteBuf;
wr.wr.rdma.rkey = rkey;
postRes = ibv_post_send(commContext->qp, &wr, &bad_wr);
if(unlikely(postRes) )
{
LOG(SOCKLIB, WARNING, "ibv_post_send() failed.", sysErr(postRes));
return -1;
}
waitRes = __IBVSocket_waitForRDMACompletion(commContext, wr.wr_id);
return waitRes;
}
int __IBVSocket_postWrite(IBVSocket* _this, char* localBuf, int bufLen,
unsigned lkey, uint64_t remoteBuf, unsigned rkey)
{
return __IBVSocket_postRDMA(_this, IBV_WR_RDMA_WRITE, localBuf, bufLen,
lkey, remoteBuf, rkey);
}
int __IBVSocket_postRead(IBVSocket* _this, char* localBuf, int bufLen,
unsigned lkey, uint64_t remoteBuf, unsigned rkey)
{
return __IBVSocket_postRDMA(_this, IBV_WR_RDMA_READ, localBuf, bufLen,
lkey, remoteBuf, rkey);
}
ssize_t IBVSocket_read(IBVSocket* _this, const char* buf, size_t bufLen,
unsigned lkey, const uint64_t rbuf, unsigned rkey)
{
return __IBVSocket_postRead(_this, (char *)buf, bufLen, lkey, rbuf, rkey);
}
ssize_t IBVSocket_write(IBVSocket* _this, const char* buf, size_t bufLen,
unsigned lkey, const uint64_t rbuf, unsigned rkey)
{
return __IBVSocket_postWrite(_this, (char *)buf, bufLen, lkey, rbuf, rkey);
}
#endif /* BEEGFS_NVFS */
/**
* Note: Contains flow control.
*
* @return 0 on success, -1 on error
*/
int __IBVSocket_postSend(IBVSocket* _this, size_t bufIndex, int bufLen)
{
IBVCommContext* commContext = _this->commContext;
struct ibv_sge list;
struct ibv_send_wr wr;
struct ibv_send_wr *bad_wr;
int postRes;
list.addr = (uint64_t)commContext->sendBufs[bufIndex];
list.length = bufLen;
list.lkey = commContext->sendMR->lkey;
wr.wr_id = bufIndex + IBVSOCKET_SEND_WORK_ID_OFFSET;
wr.next = NULL;
wr.sg_list = &list;
wr.num_sge = 1;
wr.opcode = IBV_WR_SEND;
wr.send_flags = IBV_SEND_SIGNALED;
postRes = ibv_post_send(commContext->qp, &wr, &bad_wr);
if(unlikely(postRes) )
{
LOG(SOCKLIB, WARNING, "ibv_post_send() failed.", sysErr(postRes));
return -1;
}
// flow control
__IBVSocket_flowControlOnSendUpdateCounters(_this);
return 0;
}
/**
* Note: Contains flow control.
*
* @return 1 on success, 0 on timeout, -1 on error
*/
int __IBVSocket_recvWC(IBVSocket* _this, int timeoutMS, struct ibv_wc* outWC)
{
IBVCommContext* commContext = _this->commContext;
size_t bufIndex;
int waitRes = __IBVSocket_waitForRecvCompletionEvent(_this, timeoutMS, outWC);
if(waitRes <= 0)
{ // (note: waitRes==0 can often happen, because we call this with timeoutMS==0)
if(unlikely(waitRes < 0) )
LOG(SOCKLIB, DEBUG, "Retrieval of completion event failed.", waitRes);
else
if(unlikely(timeoutMS) )
LOG(SOCKLIB, DEBUG, "Waiting for recv completion timed out.");
return waitRes;
}
// we got something...
if(unlikely(outWC->status != IBV_WC_SUCCESS) )
{
LOG(SOCKLIB, DEBUG, "Connection error.", outWC->status);
return -1;
}
bufIndex = outWC->wr_id - IBVSOCKET_RECV_WORK_ID_OFFSET;
if(unlikely(bufIndex >= commContext->commCfg.bufNum) )
{
LOG(SOCKLIB, WARNING, "Completion for unknown/invalid wr_id.", outWC->wr_id);
return -1;
}
// receive completed
//printf("%s: Recveived %u bytes.\n", __func__, outWC->byte_len); // debug in
// flow control
if(unlikely(__IBVSocket_flowControlOnRecv(_this, timeoutMS) ) )
return -1;
return 1;
}
/**
* Intention: Avoid IB rnr by sending control msg when (almost) all our recv bufs are used up to
* show that we got our new recv bufs ready.
*
* @return 0 on success, -1 on error
*/
int __IBVSocket_flowControlOnRecv(IBVSocket* _this, int timeoutMS)
{
IBVCommContext* commContext = _this->commContext;
// we received a packet, so peer has received all of our currently pending data => reset counter
commContext->numSendBufsLeft = commContext->commCfg.bufNum - 1; /* (see
createCommContext() for "-1" reason) */
// send control packet if recv counter expires...
#ifdef BEEGFS_DEBUG
if(!commContext->numReceivedBufsLeft)
LOG(SOCKLIB, WARNING, "BUG: numReceivedBufsLeft underflow!");
#endif // BEEGFS_DEBUG
commContext->numReceivedBufsLeft--;
if(!commContext->numReceivedBufsLeft)
{
size_t currentBufIndex;
int postRes;
if(commContext->incompleteSend.numAvailable == commContext->commCfg.bufNum)
{ // wait for all (!) incomplete sends
/* note: it's ok that all send bufs are used up, because it's possible that we do a lot of
recv without the user sending any data in between (so the bufs were actually used up by
flow control). */
int waitRes = __IBVSocket_waitForTotalSendCompletion(
_this, commContext->incompleteSend.numAvailable, 0, 0);
if(waitRes < 0)
return -1;
commContext->incompleteSend.numAvailable = 0;
}
currentBufIndex = commContext->incompleteSend.numAvailable;
commContext->incompleteSend.numAvailable++; /* inc'ed before postSend() for conn checks */
postRes = __IBVSocket_postSend(_this, currentBufIndex, IBVSOCKET_FLOWCONTROL_MSG_LEN);
if(unlikely(postRes) )
{
commContext->incompleteSend.numAvailable--;
return -1;
}
// note: numReceivedBufsLeft is reset during postSend() flow control
}
return 0;
}
/**
* Called after sending a packet to update flow control counters.
*
* Intention: Avoid IB rnr by waiting for control msg when (almost) all peer bufs are used up.
*
* Note: This is only one part of the on-send flow control. The other one is
* _flowControlOnSendWait().
*/
void __IBVSocket_flowControlOnSendUpdateCounters(IBVSocket* _this)
{
IBVCommContext* commContext = _this->commContext;
// we sent a packet, so we received all currently pending data from the peer => reset counter
commContext->numReceivedBufsLeft = commContext->commCfg.bufNum - 1; /* (see
createCommContext() for "-1" reason) */
#ifdef BEEGFS_DEBUG
if(!commContext->numSendBufsLeft)
LOG(SOCKLIB, WARNING, "BUG: numSendBufsLeft underflow!");
#endif
commContext->numSendBufsLeft--;
}
/**
* Intention: Avoid IB rnr by waiting for control msg when (almost) all peer bufs are used up.
*
* @timeoutMS may be 0 for non-blocking operation, otherwise typically
* IBVSOCKET_FLOWCONTROL_ONSEND_TIMEOUT_MS
* @return >0 on success, 0 on timeout (waiting for flow control packet from peer), <0 on error
*/
int __IBVSocket_flowControlOnSendWait(IBVSocket* _this, int timeoutMS)
{
IBVCommContext* commContext = _this->commContext;
struct ibv_wc wc;
int recvRes;
size_t bufIndex;
int postRecvRes;
if(commContext->numSendBufsLeft)
return 1; // flow control not triggered yet
recvRes = __IBVSocket_recvWC(_this, timeoutMS, &wc);
if(recvRes <= 0)
return recvRes;
bufIndex = wc.wr_id - IBVSOCKET_RECV_WORK_ID_OFFSET;
if(unlikely(wc.byte_len != IBVSOCKET_FLOWCONTROL_MSG_LEN) )
{ // error (bad length)
LOG(SOCKLIB, WARNING, "Received flow control packet length mismatch.", wc.byte_len);
return -1;
}
postRecvRes = __IBVSocket_postRecv(_this, commContext, bufIndex);
if(postRecvRes)
return -1;
// note: numSendBufsLeft is reset during recvWC() (if it actually received a packet)
return 1;
}
/**
* @return 1 on available data, 0 on timeout, -1 on error
*/
int __IBVSocket_waitForRecvCompletionEvent(IBVSocket* _this, int timeoutMS, struct ibv_wc* outWC)
{
/* Note: This will also be called with timeoutMS==0 from nonblockingRecvCheck to remove
* a potentially outdated event notification. for this reason, we have to check the event
* channel even if "ibv_poll_cq returns 0" and "timeoutMS==0". */
IBVCommContext* commContext = _this->commContext;
struct ibv_cq* ev_cq; // event completion queue
void* ev_ctx; // event context
struct epoll_event epollEvent;
// check quick path (is an event available without waiting?)
int numImmediateEvents = ibv_poll_cq(commContext->recvCQ, 1, outWC);
if(unlikely(numImmediateEvents < 0) )
{
LOG(SOCKLIB, WARNING, "Poll CQ failed.", numImmediateEvents);
return -1;
}
else
if(numImmediateEvents > 0)
return 1;
// no immediate event available => wait for them...
for( ; ; ) /* (loop until "wc retrieved" or "timeout" or "error") */
{
/* note: we use pollTimeoutMS to check the conn every few secs (otherwise we might
wait for a very long time in case the other side disconnected silently) */
int pollTimeoutMS = BEEGFS_MIN(_this->timeoutCfg.pollMS, timeoutMS);
int epollRes = epoll_wait(_this->epollFD, &epollEvent, 1, pollTimeoutMS);
if(unlikely(epollRes < 0) )
{
if(errno == EINTR)
continue; // ignore EINTR, because debugger causes it
LOG(SOCKLIB, WARNING, "Epoll error.", sysErr);
return -1;
}
if(epollRes == 0)
{ // poll timed out
// Note: we check "timeoutMS != 0" here because we don't want to run the
// connCheck each time this method is called from nonblockingRecvCheck
if(timeoutMS)
{
int checkRes = IBVSocket_checkConnection(_this);
if(checkRes < 0)
return -1;
}
timeoutMS -= pollTimeoutMS;
if(!timeoutMS)
return 0;
continue;
}
if(unlikely(_this->cm_channel &&
(epollEvent.data.fd == _this->cm_channel->fd) ) )
{ // cm event incoming
struct rdma_cm_event* event = 0;
if (rdma_get_cm_event(_this->cm_channel, &event) < 0)
{
LOG(SOCKLIB, DEBUG, "Disconnected by rdma_get_cm_event error.");
_this->errState = -1;
return -1;
}
// Note: this code doesn't encounter RDMA_CM_EVENT_DEVICE_REMOVAL
if(event->event == RDMA_CM_EVENT_DISCONNECTED)
{
LOG(SOCKLIB, DEBUG, "Disconnect event received.");
rdma_ack_cm_event(event);
_this->errState = -1;
return -1;
}
else
{
LOG(SOCKLIB, DEBUG, "Ingoring received event",
("event", rdma_event_str(event->event))); // debug in
rdma_ack_cm_event(event);
continue;
}
}
// we received a completion event notification => retrieve the event...
int getEventRes = ibv_get_cq_event(commContext->recvCompChannel, &ev_cq, &ev_ctx);
if(unlikely(getEventRes) )
{
LOG(SOCKLIB, WARNING, "Failed to get cq_event.");
return -1;
}
if(unlikely(ev_cq != commContext->recvCQ) )
{
LOG(SOCKLIB, WARNING, "CQ event for unknown CQ.", ev_cq);
return -1;
}
// request notification for next event
int reqNotifyRes = ibv_req_notify_cq(commContext->recvCQ, 0);
if(unlikely(reqNotifyRes) )
{
LOG(SOCKLIB, WARNING, "Couldn't request CQ notification.");
return -1;
}
// ack is expensive, so we gather and ack multiple events
// note: spec says we need this, but current send_bw.c & co don't use ibv_ack_cq_events.
commContext->numUnackedRecvCompChannelEvents++;
if(commContext->numUnackedRecvCompChannelEvents == IBVSOCKET_EVENTS_GATHER_NUM)
{ // ack events and reset counter
ibv_ack_cq_events(commContext->recvCQ, commContext->numUnackedRecvCompChannelEvents);
commContext->numUnackedRecvCompChannelEvents = 0;
}
// query event...
/* note: ibv_poll_cq() does not necessarily return "!=0" after a received event, because the
event might be outdated */
int numEvents = ibv_poll_cq(commContext->recvCQ, 1, outWC);
if(unlikely(numEvents < 0) )
{
LOG(SOCKLIB, WARNING, "Poll CQ failed.", numEvents);
return -1;
}
else
if(numEvents > 0)
return 1;
// we received a notification for an outdated event => wait again in the next round
} // end of for-loop
}
/**
* @return number of completed elements or -1 in case of an error
*/
int __IBVSocket_waitForTotalSendCompletion(IBVSocket* _this,
int numSendElements, int numWriteElements, int numReadElements)
{
IBVCommContext* commContext = _this->commContext;
int numElements;
int i;
size_t bufIndex;
struct ibv_wc wc[2];
do
{
numElements = ibv_poll_cq(commContext->sendCQ, 2, wc);
if(unlikely(numElements < 0) )
{
LOG(SOCKLIB, WARNING, "Bad ibv_poll_cq result.", numElements);
return -1;
}
// for each completion element
for(i=0; i < numElements; i++)
{
if(unlikely(wc[i].status != IBV_WC_SUCCESS) )
{
LOG(SOCKLIB, DEBUG, "Connection error.", wc[i].status);
return -1;
}
switch(wc[i].opcode)
{
case IBV_WC_SEND:
{
bufIndex = wc[i].wr_id - IBVSOCKET_SEND_WORK_ID_OFFSET;
if(unlikely(bufIndex >= commContext->commCfg.bufNum) )
{
LOG(SOCKLIB, WARNING, "Bad send completion wr_id.", wc[i].wr_id);
return -1;
}
if(likely(numSendElements) )
numSendElements--;
else
{
LOG(SOCKLIB, WARNING, "Received bad/unexpected send completion.");
return -1;
}
} break;
case IBV_WC_RDMA_WRITE:
{
if(unlikely(wc[i].wr_id != IBVSOCKET_WRITE_WORK_ID) )
{
LOG(SOCKLIB, WARNING, "bad write completion wr_id.", wc[i].wr_id);
return -1;
}
if(likely(numWriteElements) )
numWriteElements--;
else
{
LOG(SOCKLIB, WARNING, "Received bad/unexpected RDMA write completion.");
return -1;
}
} break;
case IBV_WC_RDMA_READ:
{
if(unlikely(wc[i].wr_id != IBVSOCKET_READ_WORK_ID) )
{
LOG(SOCKLIB, WARNING, "Bad read completion wr_id.", wc[i].wr_id);
return -1;
}
if(likely(numReadElements) )
numReadElements--;
else
{
LOG(SOCKLIB, WARNING, "Received bad/unexpected RDMA read completion.");
return -1;
}
} break;
default:
{
LOG(SOCKLIB, WARNING, "Bad/unexpected completion opcode.", wc[i].opcode);
return -1;
} break;
} // end of switch
} // end of for-loop
} while(numSendElements || numWriteElements || numReadElements);
return 0;
}
/**
* @return 0 on success, -1 on error
*/
int IBVSocket_checkConnection(IBVSocket* _this)
{
struct ibv_qp_attr qpAttr;
struct ibv_qp_init_attr qpInitAttr;
int qpRes;
int postRes;
IBVCommContext* commContext = _this->commContext;
//printf("%s: querying qp...\n", __func__); // debug in
// check qp status
qpRes = ibv_query_qp(commContext->qp, &qpAttr, IBV_QP_STATE, &qpInitAttr);
if(qpRes || (qpAttr.qp_state == IBV_QPS_ERR) )
{
LOG(SOCKLIB, WARNING, "Detected QP error state.");
_this->errState = -1;
return -1;
}
// note: we read a remote value into the numUsedSendBufsReset field, which is actually
// meant for something else, so we need to reset the value afterwards
//printf("%d:%s: post rdma_read to check connection...\n", __LINE__, __func__); // debug in
postRes = __IBVSocket_postRead(_this, _this->remoteDest, commContext->controlResetMR,
(char*)&commContext->numUsedSendBufsReset, sizeof(commContext->numUsedSendBufsReset) );
if(postRes)
{
_this->errState = -1;
return -1;
}
commContext->numUsedSendBufsReset = 0;
//printf("%d:%s: rdma_read succeeded\n", __LINE__, __func__); // debug in
return 0;
}
/**
* @return <0 on error, 0 if recv would block, >0 if recv would not block
*/
ssize_t IBVSocket_nonblockingRecvCheck(IBVSocket* _this)
{
/* note: this will also be called from the stream listener for false alarm checks, so make
* sure that we remove an (outdated) event from the channel to mute the false alarm. */
IBVCommContext* commContext = _this->commContext;
struct ibv_wc* wc = &commContext->incompleteRecv.wc;
int flowControlRes;
int recvRes;
if(unlikely(_this->errState) )
return -1;
if(commContext->incompleteRecv.isAvailable)
return 1;
// check whether we have a pending on-send flow control packet that needs to be received first
flowControlRes = __IBVSocket_flowControlOnSendWait(_this, 0);
if(unlikely(flowControlRes < 0) )
goto err_invalidateSock;
if(!flowControlRes)
return 0;
// recv one packet (if available) and add it as incompleteRecv
// or remove event channel notification otherwise (to avoid endless false alerts)
recvRes = __IBVSocket_recvWC(_this, 0, wc);
if(unlikely(recvRes < 0) )
goto err_invalidateSock;
if(!recvRes)
return 0;
// we got something => prepare to continue later
commContext->incompleteRecv.completedOffset = 0;
commContext->incompleteRecv.isAvailable = 1;
return 1;
err_invalidateSock:
_this->errState = -1;
return -1;
}
/**
* Call this after accept() to find out whether more events are waiting (for which
* no notification would not be delivered through the file descriptor).
*
* @return true if more events are waiting and accept() should be called again
*/
bool IBVSocket_checkDelayedEvents(IBVSocket* _this)
{
bool retVal = false;
struct rdma_cm_event* event;
// check for events in the delay queue
if (!_this->delayedCmEventsQ->empty())
return true;
// Switch channel fd to non-blocking, check for waiting events and switch back to blocking.
// (Quite inefficient, but we really don't have to care about efficiency in this case.)
// Note: We do this to avoid race conditions (lost events) before we're waiting for
// new notifications with poll()
// change mode of the connection manager channel to non-blocking
int oldChannelFlags = fcntl(IBVSocket_getConnManagerFD(_this), F_GETFL);
int setNewFlagsRes = fcntl(
IBVSocket_getConnManagerFD(_this), F_SETFL, oldChannelFlags | O_NONBLOCK);
if(setNewFlagsRes < 0)
{
LOG(SOCKLIB, WARNING, "Set conn manager channel non-blocking failed.", sysErr);
return false;
}
// (non-blocking) check for new events
if(rdma_get_cm_event(_this->cm_channel, &event) )
{
// non-blocking mode, so we ignore "pseudo-errors" here
}
else
{ // incoming event available
//printf("%d:%s: enqueueing an event (during non-blocking check): %d (%s)\n",
// __LINE__, __func__, event->event, rdma_event_str(event->event) ); // debug in
_this->delayedCmEventsQ->push(event);
retVal = true;
}
// change channel mode back to blocking
int setOldFlagsRes = fcntl(IBVSocket_getConnManagerFD(_this), F_SETFL, oldChannelFlags);
if(setOldFlagsRes < 0)
{
LOG(SOCKLIB, WARNING, "Set conn manager channel blocking failed.", sysErr);
return false;
}
return retVal;
}
void __IBVSocket_disconnect(IBVSocket* _this)
{
/* note: we only call rdma_disconnect() here if the socket is not connected to the common
listen sock event channel to avoid a race condition (because the sock accept method also
calls rdma_disconnect() in the streamlistener thread. ...but that's ok. we really don't need
that additional event if we're actively disconnecting the sock. */
if(_this->cm_channel)
{
int disconnectRes = rdma_disconnect(_this->cm_id);
if(disconnectRes)
{
LOG(SOCKLIB, WARNING, "rdma disconnect error.", sysErr);
return;
}
// note: we can't wait for events here, because the disconnect event might
// be received by the listen socket channel (for accepted sockets with older
// ofed versions).
/*
if(!_this->cm_channel || !waitForEvent)
return;
rdma_get_cm_event(_this->cm_channel, &event);
if(event->event != RDMA_CM_EVENT_DISCONNECTED)
{
SyslogLogger::log(LOG_WARNING, "%s: unexpected event during disconnect %d: %s\n",
__func__, event->event, rdma_event_str(event->event) );
}
rdma_ack_cm_event(event);
*/
}
}
void __IBVSocket_close(IBVSocket* _this)
{
SAFE_FREE(_this->remoteDest);
if(_this->delayedCmEventsQ)
{ // ack all queued events
while (!_this->delayedCmEventsQ->empty())
{
struct rdma_cm_event* nextEvent = _this->delayedCmEventsQ->front();
rdma_ack_cm_event(nextEvent);
_this->delayedCmEventsQ->pop();
}
delete(_this->delayedCmEventsQ);
}
if(_this->commContext)
__IBVSocket_cleanupCommContext(_this->cm_id, _this->commContext);
if(_this->cm_id)
rdma_destroy_id(_this->cm_id);
if(_this->cm_channel)
rdma_destroy_event_channel(_this->cm_channel);
}
/**
* Note: Call this for connected sockets only.
*/
bool __IBVSocket_initEpollFD(IBVSocket* _this)
{
_this->epollFD = epoll_create(1); // "1" is just a hint (and is actually ignored)
if(_this->epollFD == -1)
{
LOG(SOCKLIB, WARNING, "epoll initialization error.", sysErr);
return false;
}
struct epoll_event epollEvent;
epollEvent.events = EPOLLIN;
epollEvent.data.fd = IBVSocket_getRecvCompletionFD(_this);
// note: we only add the recvCompletionFD here and not commContext->context->async_fd, because
// accepted sockets don't have their own async event channel (they receive events through
// their parent's fd)
int epollAddRes = epoll_ctl(_this->epollFD, EPOLL_CTL_ADD,
IBVSocket_getRecvCompletionFD(_this), &epollEvent);
if(epollAddRes == -1)
{
LOG(SOCKLIB, WARNING, "Unable to add sock to epoll set.", sysErr);
close(_this->epollFD);
_this->epollFD = -1;
return false;
}
if(_this->cm_channel)
{
epollEvent.events = EPOLLIN;
epollEvent.data.fd = _this->cm_channel->fd;
int epollAddRes = epoll_ctl(_this->epollFD, EPOLL_CTL_ADD,
_this->cm_channel->fd, &epollEvent);
if(epollAddRes == -1)
{
LOG(SOCKLIB, WARNING, "Unable to add sock to epoll set.", sysErr);
close(_this->epollFD);
_this->epollFD = -1;
return false;
}
}
return true;
}
/**
* @return pointer to static buffer with human readable string for a wc status code
*/
const char* __IBVSocket_wcStatusStr(int wcStatusCode)
{
switch(wcStatusCode)
{
case IBV_WC_WR_FLUSH_ERR:
return "work request flush error";
case IBV_WC_RETRY_EXC_ERR:
return "retries exceeded error";
case IBV_WC_RESP_TIMEOUT_ERR:
return "response timeout error";
default:
return "<undefined>";
}
}
bool IBVSocket_getSockValid(IBVSocket* _this)
{
return _this->sockValid;
}
int IBVSocket_getRecvCompletionFD(IBVSocket* _this)
{
IBVCommContext* commContext = _this->commContext;
return commContext ? commContext->recvCompChannel->fd : (-1);
}
int IBVSocket_getConnManagerFD(IBVSocket* _this)
{
return _this->cm_channel ? _this->cm_channel->fd : (-1);
}
void IBVSocket_setTypeOfService(IBVSocket* _this, uint8_t typeOfService)
{
_this->typeOfService = typeOfService;
}
void IBVSocket_setTimeouts(IBVSocket* _this, int connectMS, int flowSendMS, int pollMS)
{
_this->timeoutCfg.connectMS = connectMS > 0 ? connectMS : IBVSOCKET_CONN_TIMEOUT_MS;
_this->timeoutCfg.flowSendMS = flowSendMS > 0? flowSendMS : IBVSOCKET_FLOWCONTROL_ONSEND_TIMEOUT_MS;
_this->timeoutCfg.pollMS = pollMS > 0? pollMS : IBVSOCKET_POLL_TIMEOUT_MS;
LOG(SOCKLIB, DEBUG, "timeouts", ("connectMS", _this->timeoutCfg.connectMS),
("flowSendMS", _this->timeoutCfg.flowSendMS), ("pollMS", _this->timeoutCfg.pollMS));
}
void IBVSocket_setConnectionRejectionRate(IBVSocket* _this, unsigned rate)
{
_this->connectionRejectionRate = rate;
}
bool IBVSocket_connectionRejection(IBVSocket* _this)
{
if(_this->connectionRejectionRate)
{
++_this->connectionRejectionCount;
if((_this->connectionRejectionCount % _this->connectionRejectionRate) != 0)
{
LOG(SOCKLIB, WARNING, "dropping connection for testing.",
_this->connectionRejectionCount,
_this->connectionRejectionRate);
return true;
}
}
return false;
}
Reference in New Issue View Git Blame Copy Permalink