ssize_t socket_fd_api::rx_os(const rx_call_t call_type, iovec* p_iov,
ssize_t sz_iov, int* p_flags, sockaddr *__from,
socklen_t *__fromlen, struct msghdr *__msg)
{
errno = 0;
switch (call_type) {
case RX_READ:
__log_info_func("calling os receive with orig read");
return orig_os_api.read(m_fd, p_iov[0].iov_base, p_iov[0].iov_len);
case RX_READV:
__log_info_func("calling os receive with orig readv");
return orig_os_api.readv(m_fd, p_iov, sz_iov);
case RX_RECV:
__log_info_func("calling os receive with orig recv");
return orig_os_api.recv(m_fd, p_iov[0].iov_base, p_iov[0].iov_len,
*p_flags);
case RX_RECVFROM:
__log_info_func("calling os receive with orig recvfrom");
return orig_os_api.recvfrom(m_fd, p_iov[0].iov_base, p_iov[0].iov_len,
*p_flags, __from, __fromlen);
case RX_RECVMSG: {
__log_info_func("calling os receive with orig recvmsg");
return orig_os_api.recvmsg(m_fd, __msg, *p_flags);
}
}
return (ssize_t) -1;
}
buffer_pool::buffer_pool(size_t buffer_count, size_t buf_size, ib_ctx_handler *p_ib_ctx_h, mem_buf_desc_owner *owner, pbuf_free_custom_fn custom_free_function) :
m_lock_spin("buffer_pool"),
m_n_buffers(0),
m_n_buffers_created(buffer_count),
m_p_head(NULL)
{
size_t sz_aligned_element = 0;
uint8_t *ptr_buff, *ptr_desc;
__log_info_func("count = %d", buffer_count);
m_p_bpool_stat = &m_bpool_stat_static;
memset(m_p_bpool_stat , 0, sizeof(*m_p_bpool_stat));
vma_stats_instance_create_bpool_block(m_p_bpool_stat);
size_t size;
if (buffer_count) {
sz_aligned_element = (buf_size + MCE_ALIGNMENT) & (~MCE_ALIGNMENT);
size = (sizeof(mem_buf_desc_t) + sz_aligned_element) * buffer_count + MCE_ALIGNMENT;
} else {
size = buf_size;
}
void *data_block = m_allocator.alloc_and_reg_mr(size, p_ib_ctx_h);
if (!buffer_count) return;
// Align pointers
ptr_buff = (uint8_t *)((unsigned long)((char*)data_block + MCE_ALIGNMENT) & (~MCE_ALIGNMENT));
ptr_desc = ptr_buff + sz_aligned_element * buffer_count;
// Split the block to buffers
for (size_t i = 0; i < buffer_count; ++i) {
mem_buf_desc_t* ptr_desc_mbdt = (mem_buf_desc_t*)ptr_desc;
memset(ptr_desc_mbdt, 0, sizeof (*ptr_desc_mbdt));
mem_buf_desc_t *desc = new (ptr_desc) mem_buf_desc_t(ptr_buff, buf_size);
desc->p_desc_owner = owner;
desc->lwip_pbuf.custom_free_function = custom_free_function;
put_buffer_helper(desc);
#ifdef DEFINED_VMAPOLL
desc->rx.vma_polled = false;
#endif
ptr_buff += sz_aligned_element;
ptr_desc += sizeof(mem_buf_desc_t);
}
__log_info_func("done");
}
void buffer_pool::free_bpool_resources()
{
if (m_n_buffers == m_n_buffers_created) {
__log_info_func("count %lu, missing %lu", m_n_buffers,
m_n_buffers_created-m_n_buffers);
}
else {
__log_info_dbg("count %lu, missing %lu", m_n_buffers,
m_n_buffers_created - m_n_buffers);
}
vma_stats_instance_remove_bpool_block(m_p_bpool_stat);
__log_info_func("done");
}
int socket_fd_api::accept(struct sockaddr *__addr, socklen_t *__addrlen)
{
__log_info_func("");
int ret = orig_os_api.accept(m_fd, __addr, __addrlen);
if (ret < 0) {
__log_info_dbg("accept failed (ret=%d %m)", ret);
}
return ret;
}
int socket_fd_api::connect(const sockaddr *__to, socklen_t __tolen)
{
__log_info_func("");
int ret = orig_os_api.connect(m_fd, __to, __tolen);
if (ret) {
__log_info_dbg("connect failed (ret=%d %m)", ret);
}
return ret;
}
int socket_fd_api::bind(const sockaddr *__addr, socklen_t __addrlen)
{
__log_info_func("");
int ret = orig_os_api.bind(m_fd, __addr, __addrlen);
if (ret) {
__log_info_dbg("bind failed (ret=%d %m)", ret);
}
return ret;
}
int socket_fd_api::shutdown(int __how)
{
__log_info_func("");
int ret = orig_os_api.shutdown(m_fd, __how);
if (ret) {
__log_info_dbg("shutdown failed (ret=%d %m)", ret);
}
return ret;
}
int socket_fd_api::getpeername(sockaddr *__name, socklen_t *__namelen)
{
__log_info_func("");
int ret = orig_os_api.getpeername(m_fd, __name, __namelen);
if (ret) {
__log_info_dbg("getpeername failed (ret=%d %m)", ret);
}
return ret;
}
int socket_fd_api::listen(int backlog)
{
__log_info_func("");
int ret = orig_os_api.listen(m_fd, backlog);
if (ret < 0) {
__log_info_dbg("listen failed (ret=%d %m)", ret);
}
return ret;
}
int socket_fd_api::getsockopt(int __level, int __optname, void *__optval,
socklen_t *__optlen) throw (vma_error)
{
__log_info_func("");
int ret = orig_os_api.getsockopt(m_fd, __level, __optname, __optval, __optlen);
if (ret) {
__log_info_dbg("getsockopt failed (ret=%d %m)", ret);
}
return ret;
}
buffer_pool::buffer_pool(size_t buffer_count, size_t buf_size, pbuf_free_custom_fn custom_free_function) :
m_lock_spin("buffer_pool"),
m_n_buffers(0),
m_n_buffers_created(buffer_count),
m_p_head(NULL)
{
size_t sz_aligned_element = 0;
uint8_t *ptr_buff, *ptr_desc;
__log_info_func("count = %d", buffer_count);
m_p_bpool_stat = &m_bpool_stat_static;
memset(m_p_bpool_stat , 0, sizeof(*m_p_bpool_stat));
vma_stats_instance_create_bpool_block(m_p_bpool_stat);
if (buffer_count) {
sz_aligned_element = (buf_size + MCE_ALIGNMENT) & (~MCE_ALIGNMENT);
m_size = (sizeof(mem_buf_desc_t) + sz_aligned_element) * buffer_count + MCE_ALIGNMENT;
} else {
m_size = buf_size;
}
void *data_block = m_allocator.alloc_and_reg_mr(m_size, NULL);
if (!buffer_count) return;
// Align pointers
ptr_buff = (uint8_t *)((unsigned long)((char*)data_block + MCE_ALIGNMENT) & (~MCE_ALIGNMENT));
ptr_desc = ptr_buff + sz_aligned_element * buffer_count;
// Split the block to buffers
for (size_t i = 0; i < buffer_count; ++i) {
mem_buf_desc_t *desc = new (ptr_desc) mem_buf_desc_t(ptr_buff, buf_size, custom_free_function);
put_buffer_helper(desc);
ptr_buff += sz_aligned_element;
ptr_desc += sizeof(mem_buf_desc_t);
}
__log_info_func("done");
}
ssize_t socket_fd_api::tx_os(const tx_call_t call_type,
const iovec* p_iov, const ssize_t sz_iov,
const int __flags, const sockaddr *__to,
const socklen_t __tolen)
{
errno = 0;
switch (call_type) {
case TX_WRITE:
__log_info_func("calling os transmit with orig write");
return orig_os_api.write(m_fd, p_iov[0].iov_base, p_iov[0].iov_len);
case TX_WRITEV:
__log_info_func("calling os transmit with orig writev");
return orig_os_api.writev(m_fd, p_iov, sz_iov);
case TX_SEND:
__log_info_func("calling os transmit with orig send");
return orig_os_api.send(m_fd, p_iov[0].iov_base, p_iov[0].iov_len,
__flags);
case TX_SENDTO:
__log_info_func("calling os transmit with orig sendto");
return orig_os_api.sendto(m_fd, p_iov[0].iov_base, p_iov[0].iov_len,
__flags, __to, __tolen);
case TX_SENDMSG: {
msghdr __message;
memset(&__message, 0, sizeof(__message));
__message.msg_iov = (iovec*) p_iov;
__message.msg_iovlen = sz_iov;
__message.msg_name = (void*) __to;
__message.msg_namelen = __tolen;
__log_info_func("calling os transmit with orig sendmsg");
return orig_os_api.sendmsg(m_fd, &__message, __flags);
}
default:
__log_info_func("calling undefined os call type!");
break;
}
return (ssize_t) -1;
}
