static void enic_free_wq_buf(__rte_unused struct vnic_wq *wq, struct vnic_wq_buf *buf)
{
struct rte_mbuf *mbuf = (struct rte_mbuf *)buf->os_buf;
rte_mempool_put(mbuf->pool, mbuf);
buf->os_buf = NULL;
}
int anscli_ring_send(void *buff, int buff_len)
{
void *msg;
if(buff_len > ANS_RING_MSG_SIZE)
{
printf("Too long message size, max is %d \n", ANS_RING_MSG_SIZE);
return ANS_EMSGPOOL;
}
if (rte_mempool_get(anscli_message_pool, &msg) < 0)
{
printf("Getting message failed \n");
return ANS_EMSGPOOL;
}
rte_memcpy(msg, buff, buff_len);
if (rte_ring_enqueue(anscli_ring_tx, msg) < 0)
{
printf("Sending message to ANS stack failed \n");
rte_mempool_put(anscli_message_pool, msg);
return ANS_EMSGPOOL;
}
return 0;
}
static void
task_complete(struct reset_task *task, const struct spdk_nvme_cpl *completion)
{
struct ns_worker_ctx *ns_ctx;
ns_ctx = task->ns_ctx;
ns_ctx->current_queue_depth--;
if (spdk_nvme_cpl_is_error(completion)) {
ns_ctx->io_completed_error++;
} else {
ns_ctx->io_completed++;
}
rte_mempool_put(task_pool, task);
/*
* is_draining indicates when time has expired for the test run
* and we are just waiting for the previously submitted I/O
* to complete. In this case, do not submit a new I/O to replace
* the one just completed.
*/
if (!ns_ctx->is_draining) {
submit_single_io(ns_ctx);
}
}
int
CheckEtherOutRing(void)
{
struct rte_mbuf **Msg, *mbuf;
int mac_status = 0;
int num = rte_ring_dequeue(ip_to_ether_ring_recv, (void **)&Msg);
if(num < 0) {
return 0;
}
mbuf = *Msg;
printf("******Mbuf received = %p\n", mbuf);
rte_mempool_put(buffer_message_pool, Msg);
struct ipv4_hdr *hdr = (struct ipv4_hdr *)rte_pktmbuf_mtod (mbuf, struct ipv4_hdr*);
unsigned char dest_mac[6];
mac_status = get_mac(ntohl(hdr->dst_addr), dest_mac);
if(mac_status) {
printf("mac found sending packet out.\n");
ether_out(dest_mac, NULL, ETHER_TYPE_IPv4, mbuf);
}
else {
printf("mac not found pushing packet back to queue.\n");
// put this mbuf bak in queue.
}
return 0;
}
/** Get multi buffer session */
static struct aesni_mb_session *
get_session(struct aesni_mb_qp *qp, struct rte_crypto_op *op)
{
struct aesni_mb_session *sess = NULL;
if (op->sym->sess_type == RTE_CRYPTO_SYM_OP_WITH_SESSION) {
if (unlikely(op->sym->session->dev_type !=
RTE_CRYPTODEV_AESNI_MB_PMD))
return NULL;
sess = (struct aesni_mb_session *)op->sym->session->_private;
} else {
void *_sess = NULL;
if (rte_mempool_get(qp->sess_mp, (void **)&_sess))
return NULL;
sess = (struct aesni_mb_session *)
((struct rte_cryptodev_sym_session *)_sess)->_private;
if (unlikely(aesni_mb_set_session_parameters(qp->ops,
sess, op->sym->xform) != 0)) {
rte_mempool_put(qp->sess_mp, _sess);
sess = NULL;
}
}
return sess;
}
int netdpcmd_ring_send(void *buff, int buff_len)
{
void *msg;
if(buff_len > NETDP_RING_MSG_SIZE)
{
printf("Too long message size, max is %d \n", NETDP_RING_MSG_SIZE);
return NETDP_EMSGPOOL;
}
if (rte_mempool_get(netdpcmd_message_pool, &msg) < 0)
{
printf("Getting message failed \n");
return NETDP_EMSGPOOL;
}
rte_memcpy(msg, buff, buff_len);
if (rte_ring_enqueue(netdpcmd_ring_tx, msg) < 0)
{
printf("Sending message to NETDP stack failed \n");
rte_mempool_put(netdpcmd_message_pool, msg);
return NETDP_EMSGPOOL;
}
return 0;
}
static void
task_complete(struct perf_task *task)
{
struct ns_worker_ctx *ns_ctx;
uint64_t tsc_diff;
ns_ctx = task->ns_ctx;
ns_ctx->current_queue_depth--;
ns_ctx->io_completed++;
tsc_diff = rte_get_timer_cycles() - task->submit_tsc;
ns_ctx->total_tsc += tsc_diff;
if (ns_ctx->min_tsc > tsc_diff) {
ns_ctx->min_tsc = tsc_diff;
}
if (ns_ctx->max_tsc < tsc_diff) {
ns_ctx->max_tsc = tsc_diff;
}
rte_mempool_put(task_pool, task);
/*
* is_draining indicates when time has expired for the test run
* and we are just waiting for the previously submitted I/O
* to complete. In this case, do not submit a new I/O to replace
* the one just completed.
*/
if (!ns_ctx->is_draining) {
submit_single_io(ns_ctx);
}
}
void *
qat_crypto_sym_configure_session(struct rte_cryptodev *dev,
struct rte_crypto_sym_xform *xform, void *session_private)
{
struct qat_pmd_private *internals = dev->data->dev_private;
struct qat_session *session = session_private;
int qat_cmd_id;
PMD_INIT_FUNC_TRACE();
/* Get requested QAT command id */
qat_cmd_id = qat_get_cmd_id(xform);
if (qat_cmd_id < 0 || qat_cmd_id >= ICP_QAT_FW_LA_CMD_DELIMITER) {
PMD_DRV_LOG(ERR, "Unsupported xform chain requested");
goto error_out;
}
session->qat_cmd = (enum icp_qat_fw_la_cmd_id)qat_cmd_id;
switch (session->qat_cmd) {
case ICP_QAT_FW_LA_CMD_CIPHER:
session = qat_crypto_sym_configure_session_cipher(dev, xform, session);
break;
case ICP_QAT_FW_LA_CMD_AUTH:
session = qat_crypto_sym_configure_session_auth(dev, xform, session);
break;
case ICP_QAT_FW_LA_CMD_CIPHER_HASH:
session = qat_crypto_sym_configure_session_cipher(dev, xform, session);
session = qat_crypto_sym_configure_session_auth(dev, xform, session);
break;
case ICP_QAT_FW_LA_CMD_HASH_CIPHER:
session = qat_crypto_sym_configure_session_auth(dev, xform, session);
session = qat_crypto_sym_configure_session_cipher(dev, xform, session);
break;
case ICP_QAT_FW_LA_CMD_TRNG_GET_RANDOM:
case ICP_QAT_FW_LA_CMD_TRNG_TEST:
case ICP_QAT_FW_LA_CMD_SSL3_KEY_DERIVE:
case ICP_QAT_FW_LA_CMD_TLS_V1_1_KEY_DERIVE:
case ICP_QAT_FW_LA_CMD_TLS_V1_2_KEY_DERIVE:
case ICP_QAT_FW_LA_CMD_MGF1:
case ICP_QAT_FW_LA_CMD_AUTH_PRE_COMP:
case ICP_QAT_FW_LA_CMD_CIPHER_PRE_COMP:
case ICP_QAT_FW_LA_CMD_DELIMITER:
PMD_DRV_LOG(ERR, "Unsupported Service %u",
session->qat_cmd);
goto error_out;
default:
PMD_DRV_LOG(ERR, "Unsupported Service %u",
session->qat_cmd);
goto error_out;
}
return session;
error_out:
rte_mempool_put(internals->sess_mp, session);
return NULL;
}
ixgbe_tx_free_bufs(struct ixgbe_tx_queue *txq)
{
struct ixgbe_tx_entry_v *txep;
uint32_t status;
uint32_t n;
uint32_t i;
int nb_free = 0;
struct rte_mbuf *m, *free[RTE_IXGBE_TX_MAX_FREE_BUF_SZ];
/* check DD bit on threshold descriptor */
status = txq->tx_ring[txq->tx_next_dd].wb.status;
if (!(status & IXGBE_ADVTXD_STAT_DD))
return 0;
n = txq->tx_rs_thresh;
/*
* first buffer to free from S/W ring is at index
* tx_next_dd - (tx_rs_thresh-1)
*/
txep = &((struct ixgbe_tx_entry_v *)txq->sw_ring)[txq->tx_next_dd -
(n - 1)];
m = __rte_pktmbuf_prefree_seg(txep[0].mbuf);
if (likely(m != NULL)) {
free[0] = m;
nb_free = 1;
for (i = 1; i < n; i++) {
m = __rte_pktmbuf_prefree_seg(txep[i].mbuf);
if (likely(m != NULL)) {
if (likely(m->pool == free[0]->pool))
free[nb_free++] = m;
else {
rte_mempool_put_bulk(free[0]->pool,
(void *)free, nb_free);
free[0] = m;
nb_free = 1;
}
}
}
rte_mempool_put_bulk(free[0]->pool, (void **)free, nb_free);
} else {
for (i = 1; i < n; i++) {
m = __rte_pktmbuf_prefree_seg(txep[i].mbuf);
if (m != NULL)
rte_mempool_put(m->pool, m);
}
}
/* buffers were freed, update counters */
txq->nb_tx_free = (uint16_t)(txq->nb_tx_free + txq->tx_rs_thresh);
txq->tx_next_dd = (uint16_t)(txq->tx_next_dd + txq->tx_rs_thresh);
if (txq->tx_next_dd >= txq->nb_tx_desc)
txq->tx_next_dd = (uint16_t)(txq->tx_rs_thresh - 1);
return txq->tx_rs_thresh;
}
static __rte_always_inline int
fm10k_tx_free_bufs(struct fm10k_tx_queue *txq)
{
struct rte_mbuf **txep;
uint8_t flags;
uint32_t n;
uint32_t i;
int nb_free = 0;
struct rte_mbuf *m, *free[RTE_FM10K_TX_MAX_FREE_BUF_SZ];
/* check DD bit on threshold descriptor */
flags = txq->hw_ring[txq->next_dd].flags;
if (!(flags & FM10K_TXD_FLAG_DONE))
return 0;
n = txq->rs_thresh;
/* First buffer to free from S/W ring is at index
* next_dd - (rs_thresh-1)
*/
txep = &txq->sw_ring[txq->next_dd - (n - 1)];
m = rte_pktmbuf_prefree_seg(txep[0]);
if (likely(m != NULL)) {
free[0] = m;
nb_free = 1;
for (i = 1; i < n; i++) {
m = rte_pktmbuf_prefree_seg(txep[i]);
if (likely(m != NULL)) {
if (likely(m->pool == free[0]->pool))
free[nb_free++] = m;
else {
rte_mempool_put_bulk(free[0]->pool,
(void *)free, nb_free);
free[0] = m;
nb_free = 1;
}
}
}
rte_mempool_put_bulk(free[0]->pool, (void **)free, nb_free);
} else {
for (i = 1; i < n; i++) {
m = rte_pktmbuf_prefree_seg(txep[i]);
if (m != NULL)
rte_mempool_put(m->pool, m);
}
}
/* buffers were freed, update counters */
txq->nb_free = (uint16_t)(txq->nb_free + txq->rs_thresh);
txq->next_dd = (uint16_t)(txq->next_dd + txq->rs_thresh);
if (txq->next_dd >= txq->nb_desc)
txq->next_dd = (uint16_t)(txq->rs_thresh - 1);
return txq->rs_thresh;
}
i40e_tx_free_bufs(struct i40e_tx_queue *txq)
{
struct i40e_tx_entry *txep;
uint32_t n;
uint32_t i;
int nb_free = 0;
struct rte_mbuf *m, *free[RTE_I40E_TX_MAX_FREE_BUF_SZ];
/* check DD bits on threshold descriptor */
if ((txq->tx_ring[txq->tx_next_dd].cmd_type_offset_bsz &
rte_cpu_to_le_64(I40E_TXD_QW1_DTYPE_MASK)) !=
rte_cpu_to_le_64(I40E_TX_DESC_DTYPE_DESC_DONE))
return 0;
n = txq->tx_rs_thresh;
/* first buffer to free from S/W ring is at index
* tx_next_dd - (tx_rs_thresh-1)
*/
txep = &txq->sw_ring[txq->tx_next_dd - (n - 1)];
m = __rte_pktmbuf_prefree_seg(txep[0].mbuf);
if (likely(m != NULL)) {
free[0] = m;
nb_free = 1;
for (i = 1; i < n; i++) {
m = __rte_pktmbuf_prefree_seg(txep[i].mbuf);
if (likely(m != NULL)) {
if (likely(m->pool == free[0]->pool)) {
free[nb_free++] = m;
} else {
rte_mempool_put_bulk(free[0]->pool,
(void *)free,
nb_free);
free[0] = m;
nb_free = 1;
}
}
}
rte_mempool_put_bulk(free[0]->pool, (void **)free, nb_free);
} else {
for (i = 1; i < n; i++) {
m = __rte_pktmbuf_prefree_seg(txep[i].mbuf);
if (m != NULL)
rte_mempool_put(m->pool, m);
}
}
/* buffers were freed, update counters */
txq->nb_tx_free = (uint16_t)(txq->nb_tx_free + txq->tx_rs_thresh);
txq->tx_next_dd = (uint16_t)(txq->tx_next_dd + txq->tx_rs_thresh);
if (txq->tx_next_dd >= txq->nb_tx_desc)
txq->tx_next_dd = (uint16_t)(txq->tx_rs_thresh - 1);
return txq->tx_rs_thresh;
}
inline static int
onvm_nf_stop(struct onvm_nf_info *nf_info) {
uint16_t nf_id;
uint16_t service_id;
int mapIndex;
struct rte_mempool *nf_info_mp;
if(nf_info == NULL || nf_info->status != NF_RUNNING)
return 1;
nf_info->status = NF_STOPPED;
nf_id = nf_info->instance_id;
service_id = nf_info->service_id;
cores[nf_info->core].nf_count--;
cores[nf_info->core].is_dedicated_core = 0;
/* Clean up dangling pointers to info struct */
nfs[nf_id].info = NULL;
/* Reset stats */
onvm_stats_clear_nf(nf_id);
/* Remove this NF from the service map.
* Need to shift all elements past it in the array left to avoid gaps */
nf_per_service_count[service_id]--;
for (mapIndex = 0; mapIndex < MAX_NFS_PER_SERVICE; mapIndex++) {
if (services[service_id][mapIndex] == nf_id) {
break;
}
}
if (mapIndex < MAX_NFS_PER_SERVICE) { // sanity error check
services[service_id][mapIndex] = 0;
for (; mapIndex < MAX_NFS_PER_SERVICE - 1; mapIndex++) {
// Shift the NULL to the end of the array
if (services[service_id][mapIndex + 1] == 0) {
// Short circuit when we reach the end of this service's list
break;
}
services[service_id][mapIndex] = services[service_id][mapIndex + 1];
services[service_id][mapIndex + 1] = 0;
}
}
/* Free info struct */
/* Lookup mempool for nf_info struct */
nf_info_mp = rte_mempool_lookup(_NF_MEMPOOL_NAME);
if (nf_info_mp == NULL)
return 1;
rte_mempool_put(nf_info_mp, (void*)nf_info);
return 0;
}
/** Get multi buffer session */
static inline struct aesni_mb_session *
get_session(struct aesni_mb_qp *qp, struct rte_crypto_op *op)
{
struct aesni_mb_session *sess = NULL;
if (op->sess_type == RTE_CRYPTO_OP_WITH_SESSION) {
if (likely(op->sym->session != NULL))
sess = (struct aesni_mb_session *)
get_sym_session_private_data(
op->sym->session,
cryptodev_driver_id);
} else {
void *_sess = NULL;
void *_sess_private_data = NULL;
if (rte_mempool_get(qp->sess_mp, (void **)&_sess))
return NULL;
if (rte_mempool_get(qp->sess_mp, (void **)&_sess_private_data))
return NULL;
sess = (struct aesni_mb_session *)_sess_private_data;
if (unlikely(aesni_mb_set_session_parameters(qp->op_fns,
sess, op->sym->xform) != 0)) {
rte_mempool_put(qp->sess_mp, _sess);
rte_mempool_put(qp->sess_mp, _sess_private_data);
sess = NULL;
}
op->sym->session = (struct rte_cryptodev_sym_session *)_sess;
set_sym_session_private_data(op->sym->session,
cryptodev_driver_id, _sess_private_data);
}
if (unlikely(sess == NULL))
op->status = RTE_CRYPTO_OP_STATUS_INVALID_SESSION;
return sess;
}
int socket_read_nonblock(int ser_id, unsigned char *buffer)
{
void *msg;
struct tcb *ptcb = get_tcb_by_identifier(ser_id);
while (rte_ring_dequeue(ptcb->socket_tcb_ring_recv, &msg) < 0){
usleep(5);
continue;
}
// printf("Received %s and len %d\n",(char *)msg, strlen(msg));
memcpy(buffer, msg, strlen(msg));
rte_mempool_put(buffer_message_pool, msg);
return strlen(msg);//GetData(ser_id, buffer);
}
int
rte_security_session_destroy(struct rte_security_ctx *instance,
struct rte_security_session *sess)
{
int ret;
RTE_FUNC_PTR_OR_ERR_RET(*instance->ops->session_destroy, -ENOTSUP);
if (instance->sess_cnt)
instance->sess_cnt--;
ret = instance->ops->session_destroy(instance->device, sess);
if (!ret)
rte_mempool_put(rte_mempool_from_obj(sess), (void *)sess);
return ret;
}
int socket_connect(int identifier, struct sock_addr *client_addr)
{
/* using static ip for current. furute get ip from conf*/
int i;
uint8_t ip[4];
ip[0] = 192;
ip[1] = 168;
ip[2] = 78;
ip[3] = 2;
uint32_t DestIp = 0;
static uint16_t SrcPorts = 0;
if(SrcPorts == 0) {
SrcPorts = 10000;
}
SrcPorts ++;
for(i=0; i<4; i++) {
DestIp |= ip[i] << i*8;
}
printf("opening connection connect call\n");
Socket_Send_Msg *Msg = NULL;
struct tcb *ptcb = get_tcb_by_identifier(identifier);
if (rte_mempool_get(buffer_message_pool,(void **) &Msg) < 0) {
printf ("Failed to get message buffer\n");
/// / put assert ;
}
Msg->m_Identifier = identifier;
Msg->m_Msg_Type = CONNECTION_OPEN;
if (rte_ring_enqueue(ptcb->tcb_socket_ring_send, Msg) < 0) {
printf("Failed to send message - message discarded\n");
rte_mempool_put(buffer_message_pool, Msg);
}
ptcb->ipv4_src = htonl(client_addr->ip);
ptcb->sport = client_addr->port;
ptcb->ipv4_dst = DestIp;
ptcb->dport = SrcPorts;
ptcb->next_seq = 1;
pthread_mutex_lock(&(ptcb->mutex));
ptcb->WaitingOnConnect = 1;
pthread_cond_wait(&(ptcb->condAccept), &(ptcb->mutex));
ptcb->WaitingOnConnect = 0;
pthread_mutex_unlock(&(ptcb->mutex));
// wait on sema event of syn-ack.
// remove_tcb(identifier);
return 0;
}
int netdpcmd_ring_recv(void *buff, int buff_len)
{
void *msg;
int wait_num = 0;
while (wait_num < 100)
{
if (rte_ring_dequeue(netdpcmd_ring_rx, &msg) < 0)
{
wait_num++;
usleep(200);
continue;
}
rte_memcpy(buff, msg, buff_len);
rte_mempool_put(netdpcmd_message_pool, msg);
return NETDPCMD_RECV_MSG;
}
return NETDPCMD_NONRECV_MSG;
}
int
socket_close(int identifier)
{
printf("closing tcb\n");
Socket_Send_Msg *Msg = NULL;
struct tcb *ptcb = get_tcb_by_identifier(identifier);
if (rte_mempool_get(buffer_message_pool, (void **)&Msg) < 0) {
printf ("Failed to get message buffer\n");
/// / put assert ;
}
Msg->m_Identifier = identifier;
Msg->m_Msg_Type = SOCKET_CLOSE;
if (rte_ring_enqueue(ptcb->tcb_socket_ring_send, Msg) < 0) {
printf("Failed to send message - message discarded\n");
rte_mempool_put(buffer_message_pool, Msg);
}
// remove_tcb(identifier);
return 0;
}
int anscli_ring_recv(void *buff, int buff_len)
{
void *msg;
int wait_num = 0;
while (wait_num < 10)
{
if (rte_ring_dequeue(anscli_ring_rx, &msg) < 0)
{
wait_num++;
usleep(100000); /* 100 ms */
continue;
}
rte_memcpy(buff, msg, buff_len);
rte_mempool_put(anscli_message_pool, msg);
return ANSCLI_RECV_MSG;
}
return ANSCLI_NONRECV_MSG;
}
int
EnqueueMBuf(struct rte_mbuf *mbuf)
{
struct rte_mbuf **Msg;
if (rte_mempool_get(buffer_message_pool, (void **)&Msg) < 0) {
printf ("Failed to get rte_mbuf message buffer\n");
/// / put assert ;
return -1;
}
*Msg = mbuf;
if (rte_ring_enqueue(ip_to_ether_ring_send, Msg) < 0) {
printf("Failed to send rte_mbuf message - message discarded\n");
rte_mempool_put(buffer_message_pool, Msg);
}
else {
printf("mbuf enqueue = %p\n", mbuf);
}
return 0;
}
void
onvm_nf_check_status(void) {
int i;
void *msgs[MAX_NFS];
struct onvm_nf_msg *msg;
struct onvm_nf_info *nf;
int num_msgs = rte_ring_count(incoming_msg_queue);
if (num_msgs == 0) return;
if (rte_ring_dequeue_bulk(incoming_msg_queue, msgs, num_msgs, NULL) == 0)
return;
for (i = 0; i < num_msgs; i++) {
msg = (struct onvm_nf_msg*) msgs[i];
switch (msg->msg_type) {
case MSG_NF_STARTING:
nf = (struct onvm_nf_info*)msg->msg_data;
if (onvm_nf_start(nf) == 0) {
onvm_stats_add_event("NF Starting", nf);
}
break;
case MSG_NF_READY:
nf = (struct onvm_nf_info*)msg->msg_data;
if (onvm_nf_ready(nf) == 0) {
onvm_stats_add_event("NF Ready", nf);
}
break;
case MSG_NF_STOPPING:
nf = (struct onvm_nf_info*)msg->msg_data;
if (onvm_nf_stop(nf) == 0) {
onvm_stats_add_event("NF Stopping", nf);
num_nfs--;
}
break;
}
rte_mempool_put(nf_msg_pool, (void*)msg);
}
}
static void
task_complete(struct perf_task *task)
{
struct ns_worker_ctx *ns_ctx;
ns_ctx = task->ns_ctx;
ns_ctx->current_queue_depth--;
ns_ctx->io_completed++;
rte_mempool_put(task_pool, task);
/*
* is_draining indicates when time has expired for the test run
* and we are just waiting for the previously submitted I/O
* to complete. In this case, do not submit a new I/O to replace
* the one just completed.
*/
if (!ns_ctx->is_draining) {
submit_single_io(ns_ctx);
}
}
/** Configure the session from a crypto xform chain (PMD ops callback).
*
* @param dev Pointer to the device structure.
* @param xform Pointer to the crytpo configuration structure.
* @param sess Pointer to the empty session structure.
* @returns 0 upon success, negative value otherwise.
*/
static int
mrvl_crypto_pmd_session_configure(__rte_unused struct rte_cryptodev *dev,
struct rte_crypto_sym_xform *xform,
struct rte_cryptodev_sym_session *sess,
struct rte_mempool *mp)
{
struct mrvl_crypto_session *mrvl_sess;
void *sess_private_data;
int ret;
if (sess == NULL) {
MRVL_CRYPTO_LOG_ERR("Invalid session struct.");
return -EINVAL;
}
if (rte_mempool_get(mp, &sess_private_data)) {
CDEV_LOG_ERR("Couldn't get object from session mempool.");
return -ENOMEM;
}
ret = mrvl_crypto_set_session_parameters(sess_private_data, xform);
if (ret != 0) {
MRVL_CRYPTO_LOG_ERR("Failed to configure session parameters.");
/* Return session to mempool */
rte_mempool_put(mp, sess_private_data);
return ret;
}
set_session_private_data(sess, dev->driver_id, sess_private_data);
mrvl_sess = (struct mrvl_crypto_session *)sess_private_data;
if (sam_session_create(&mrvl_sess->sam_sess_params,
&mrvl_sess->sam_sess) < 0) {
MRVL_CRYPTO_LOG_DBG("Failed to create session!");
return -EIO;
}
return 0;
}
int
socket_send(int ser_id, const unsigned char *message, int len)
{
Socket_Send_Msg *Msg = NULL;
struct tcb *ptcb = get_tcb_by_identifier(ser_id);
if (rte_mempool_get(buffer_message_pool,(void **) &Msg) < 0) {
printf ("Failed to get message buffer\n");
/// / put assert ;
}
Msg->m_Identifier = ser_id;
Msg->m_Len = len;
Msg->m_Msg_Type = SEND_DATA;
memcpy(Msg->m_Data, message, len);
if (rte_ring_enqueue(ptcb->tcb_socket_ring_send, Msg) < 0) {
printf("Failed to send message - message discarded\n");
rte_mempool_put(buffer_message_pool, Msg);
}
printf("****** Enqued for %s and len %d and identifier %d\n",(char *)Msg->m_Data, Msg->m_Len, Msg->m_Identifier);
// sendtcppacket(ptcb, mbuf, message, len);
// ptcb->send_data(message, len);
return 0;
}
/**
* Process a completed job and return rte_mbuf which job processed
*
* @param job JOB_AES_HMAC job to process
*
* @return
* - Returns processed mbuf which is trimmed of output digest used in
* verification of supplied digest in the case of a HASH_CIPHER operation
* - Returns NULL on invalid job
*/
static struct rte_mbuf *
post_process_mb_job(struct aesni_mb_qp *qp, JOB_AES_HMAC *job)
{
struct rte_mbuf *m;
struct rte_crypto_op *c_op;
if (job->user_data == NULL)
return NULL;
/* handled retrieved job */
m = (struct rte_mbuf *)job->user_data;
c_op = (struct rte_crypto_op *)job->user_data2;
/* set status as successful by default */
c_op->status = RTE_CRYPTO_OP_STATUS_SUCCESS;
/* check if job has been processed */
if (unlikely(job->status != STS_COMPLETED)) {
c_op->status = RTE_CRYPTO_OP_STATUS_ERROR;
return m;
} else if (job->chain_order == HASH_CIPHER) {
/* Verify digest if required */
if (memcmp(job->auth_tag_output, c_op->digest.data,
job->auth_tag_output_len_in_bytes) != 0)
c_op->status = RTE_CRYPTO_OP_STATUS_AUTH_FAILED;
/* trim area used for digest from mbuf */
rte_pktmbuf_trim(m, get_digest_byte_length(job->hash_alg));
}
/* Free session if a session-less crypto op */
if (c_op->type == RTE_CRYPTO_OP_SESSIONLESS) {
rte_mempool_put(qp->sess_mp, c_op->session);
c_op->session = NULL;
}
return m;
}
struct rte_security_session *
rte_security_session_create(struct rte_security_ctx *instance,
struct rte_security_session_conf *conf,
struct rte_mempool *mp)
{
struct rte_security_session *sess = NULL;
if (conf == NULL)
return NULL;
RTE_FUNC_PTR_OR_ERR_RET(*instance->ops->session_create, NULL);
if (rte_mempool_get(mp, (void **)&sess))
return NULL;
if (instance->ops->session_create(instance->device, conf, sess, mp)) {
rte_mempool_put(mp, (void *)sess);
return NULL;
}
instance->sess_cnt++;
return sess;
}
/**
* Clear the memory of session so it doesn't leave key material behind.
*
* @param dev Pointer to the device structure.
* @returns 0. Always.
*/
static void
mrvl_crypto_pmd_session_clear(struct rte_cryptodev *dev,
struct rte_cryptodev_sym_session *sess)
{
uint8_t index = dev->driver_id;
void *sess_priv = get_session_private_data(sess, index);
/* Zero out the whole structure */
if (sess_priv) {
struct mrvl_crypto_session *mrvl_sess =
(struct mrvl_crypto_session *)sess_priv;
if (mrvl_sess->sam_sess &&
sam_session_destroy(mrvl_sess->sam_sess) < 0) {
MRVL_CRYPTO_LOG_INFO("Error while destroying session!");
}
memset(sess, 0, sizeof(struct mrvl_crypto_session));
struct rte_mempool *sess_mp = rte_mempool_from_obj(sess_priv);
set_session_private_data(sess, index, NULL);
rte_mempool_put(sess_mp, sess_priv);
}
}
static void
io_complete(void *ctx, const struct nvme_completion *completion)
{
struct perf_task *task;
struct ns_entry *entry;
task = (struct perf_task *)ctx;
entry = task->entry;
entry->current_queue_depth--;
entry->io_completed++;
rte_mempool_put(task_pool, task);
/*
* is_draining indicates when time has expired for the test run
* and we are just waiting for the previously submitted I/O
* to complete. In this case, do not submit a new I/O to replace
* the one just completed.
*/
if (!entry->is_draining) {
submit_single_io(entry);
}
}
static inline void ipaugenblick_free_command_buf(ipaugenblick_cmd_t *cmd)
{
rte_mempool_put(free_command_pool,(void *)cmd);
}
static int enic_rq_alloc_buf(struct vnic_rq *rq)
{
struct enic *enic = vnic_dev_priv(rq->vdev);
dma_addr_t dma_addr;
struct rq_enet_desc *desc = vnic_rq_next_desc(rq);
uint8_t type = RQ_ENET_TYPE_ONLY_SOP;
u16 split_hdr_size = vnic_get_hdr_split_size(enic->vdev);
struct rte_mbuf *mbuf = enic_rxmbuf_alloc(rq->mp);
struct rte_mbuf *hdr_mbuf = NULL;
if (!mbuf) {
dev_err(enic, "mbuf alloc in enic_rq_alloc_buf failed\n");
return -1;
}
if (unlikely(split_hdr_size)) {
if (vnic_rq_desc_avail(rq) < 2) {
rte_mempool_put(mbuf->pool, mbuf);
return -1;
}
hdr_mbuf = enic_rxmbuf_alloc(rq->mp);
if (!hdr_mbuf) {
rte_mempool_put(mbuf->pool, mbuf);
dev_err(enic,
"hdr_mbuf alloc in enic_rq_alloc_buf failed\n");
return -1;
}
hdr_mbuf->data_off = RTE_PKTMBUF_HEADROOM;
hdr_mbuf->nb_segs = 2;
hdr_mbuf->port = rq->index;
hdr_mbuf->next = mbuf;
dma_addr = (dma_addr_t)
(hdr_mbuf->buf_physaddr + hdr_mbuf->data_off);
rq_enet_desc_enc(desc, dma_addr, type, split_hdr_size);
vnic_rq_post(rq, (void *)hdr_mbuf, 0 /*os_buf_index*/, dma_addr,
(unsigned int)split_hdr_size, 0 /*wrid*/);
desc = vnic_rq_next_desc(rq);
type = RQ_ENET_TYPE_NOT_SOP;
} else {
mbuf->nb_segs = 1;
mbuf->port = rq->index;
}
mbuf->data_off = RTE_PKTMBUF_HEADROOM;
mbuf->next = NULL;
dma_addr = (dma_addr_t)
(mbuf->buf_physaddr + mbuf->data_off);
rq_enet_desc_enc(desc, dma_addr, type, mbuf->buf_len);
vnic_rq_post(rq, (void *)mbuf, 0 /*os_buf_index*/, dma_addr,
(unsigned int)mbuf->buf_len, 0 /*wrid*/);
return 0;
}
