for (i = 0; i < num_tuples; i++) {
pt = &pdump_t[i];
- if (pt->device_id)
- free(pt->device_id);
+ free(pt->device_id);
/* free the rings */
- if (pt->rx_ring)
- rte_ring_free(pt->rx_ring);
- if (pt->tx_ring)
- rte_ring_free(pt->tx_ring);
+ rte_ring_free(pt->rx_ring);
+ rte_ring_free(pt->tx_ring);
}
}
rte_cryptodev_sym_session_free(ctx->sess);
}
- if (ctx->pool)
- rte_mempool_free(ctx->pool);
+ rte_mempool_free(ctx->pool);
rte_free(ctx->res);
rte_free(ctx);
}
}
- if (ctx->pool)
- rte_mempool_free(ctx->pool);
+ rte_mempool_free(ctx->pool);
- if (ctx->ops)
- rte_free(ctx->ops);
+ rte_free(ctx->ops);
- if (ctx->ops_processed)
- rte_free(ctx->ops_processed);
+ rte_free(ctx->ops_processed);
rte_free(ctx);
}
rte_cryptodev_sym_session_free(ctx->sess);
}
}
- if (ctx->pool)
- rte_mempool_free(ctx->pool);
+ rte_mempool_free(ctx->pool);
rte_free(ctx);
}
err:
if (fp)
fclose(fp);
- if (line)
- free(line);
- if (entry)
- rte_free(entry);
+ free(line);
+ rte_free(entry);
return -1;
}
rte_cryptodev_sym_session_free(ctx->sess);
}
- if (ctx->pool)
- rte_mempool_free(ctx->pool);
+ rte_mempool_free(ctx->pool);
rte_free(ctx);
}
flow_error.message ? flow_error.message : "");
}
out:
- if (fp)
- free(fp);
+ free(fp);
}
#else /* RTE_HAS_JANSSON */
ret = 0;
no_print_return:
- if (proto)
- free(proto);
+ free(proto);
#endif
if (ret == -ENOTSUP)
fprintf(stderr, "Function not supported in PMD\n");
return 0;
fail:
- if (iovas)
- free(iovas);
+ free(iovas);
if (addr)
munmap(addr, mem_sz);
printf("Error, can't open file %s\n, err = %d", file, res);
if (fp)
fclose(fp);
- if (*buf)
- rte_free(*buf);
+ rte_free(*buf);
return -res;
}
rte_free(rules);
return 0;
error:
- if (rules)
- rte_free(rules);
+ rte_free(rules);
return res;
}
return mbuf;
fail:
- if (mbuf)
- rte_pktmbuf_free(mbuf);
+ rte_pktmbuf_free(mbuf);
return NULL;
}
rte_free(qp->buf);
qp->buf = NULL;
}
- if (mbuf_mp)
- rte_mempool_free(mbuf_mp);
+ rte_mempool_free(mbuf_mp);
rte_free(qps);
return res;
}
return 0;
fail:
- if (m)
- rte_pktmbuf_free(m);
+ rte_pktmbuf_free(m);
return -1;
}
if (stream != NULL)
rte_compressdev_stream_free(0, stream);
- if (all_decomp_data != NULL)
- rte_free(all_decomp_data);
+ rte_free(all_decomp_data);
/* Free compress private xforms */
for (i = 0; i < test_priv_data.num_priv_xforms; i++) {
return mbuf;
fail:
- if (mbuf)
- rte_pktmbuf_free(mbuf);
+ rte_pktmbuf_free(mbuf);
return NULL;
}
if (op != NULL)
rte_crypto_op_free(op);
- if (result != NULL)
- rte_free(result);
+ rte_free(result);
return status;
}
rte_cryptodev_sym_session_clear(dev_id, sess);
rte_cryptodev_sym_session_free(sess);
}
- if (cipher_xform)
- rte_free(cipher_xform);
- if (auth_xform)
- rte_free(auth_xform);
+ rte_free(cipher_xform);
+ rte_free(auth_xform);
}
if (op)
rte_crypto_op_free(op);
- if (obuf)
- rte_pktmbuf_free(obuf);
+ rte_pktmbuf_free(obuf);
- if (ibuf)
- rte_pktmbuf_free(ibuf);
+ rte_pktmbuf_free(ibuf);
return status;
}
int i;
rp = rte_ring_lookup("fr_test_once");
- if (rp != NULL)
- rte_ring_free(rp);
+ rte_ring_free(rp);
for (i = 0; i < MAX_ITER_MULTI; i++) {
snprintf(ring_name, sizeof(ring_name),
"fr_test_%d_%d", lcore_id, i);
rp = rte_ring_lookup(ring_name);
- if (rp != NULL)
- rte_ring_free(rp);
+ rte_ring_free(rp);
}
}
int i;
mp = rte_mempool_lookup("fr_test_once");
- if (mp != NULL)
- rte_mempool_free(mp);
+ rte_mempool_free(mp);
for (i = 0; i < MAX_ITER_MULTI; i++) {
snprintf(mempool_name, sizeof(mempool_name), "fr_test_%d_%d",
lcore_id, i);
mp = rte_mempool_lookup(mempool_name);
- if (mp != NULL)
- rte_mempool_free(mp);
+ rte_mempool_free(mp);
}
}
int i;
handle = rte_hash_find_existing("fr_test_once");
- if (handle != NULL)
- rte_hash_free(handle);
+ rte_hash_free(handle);
for (i = 0; i < MAX_ITER_MULTI; i++) {
snprintf(hash_name, sizeof(hash_name), "fr_test_%d_%d", lcore_id, i);
ret = 0;
fail_jhash2:
- if (handle != NULL)
- rte_hash_free(handle);
+ rte_hash_free(handle);
return ret;
}
ret = 0;
fail_2_jhash2:
- if (handle != NULL)
- rte_hash_free(handle);
+ rte_hash_free(handle);
return ret;
}
ret = 0;
fail_jhash_1word:
- if (handle != NULL)
- rte_hash_free(handle);
+ rte_hash_free(handle);
return ret;
}
ret = 0;
fail_jhash_2word:
- if (handle != NULL)
- rte_hash_free(handle);
+ rte_hash_free(handle);
return ret;
}
ret = 0;
fail_jhash_3word:
- if (handle != NULL)
- rte_hash_free(handle);
+ rte_hash_free(handle);
return ret;
}
ut_params.key_len = hashtest_key_lens[table_index];
ut_params.socket_id = rte_socket_id();
h[table_index] = rte_hash_find_existing(name);
- if (h[table_index] != NULL)
- /*
- * If table was already created, free it to create it again,
- * so we force it is empty
- */
- rte_hash_free(h[table_index]);
+ rte_hash_free(h[table_index]);
h[table_index] = rte_hash_create(&ut_params);
if (h[table_index] == NULL) {
printf("Error creating table\n");
/* free mbufs */
for (i = 0; i < MAX_PKT_BURST; i++) {
- if (rx_pkt_burst[i] != NULL)
- rte_pktmbuf_free(rx_pkt_burst[i]);
+ rte_pktmbuf_free(rx_pkt_burst[i]);
}
/* free mbufs */
for (i = 0; i < MAX_PKT_BURST; i++) {
- if (rx_pkt_burst[i] != NULL)
- rte_pktmbuf_free(rx_pkt_burst[i]);
+ rte_pktmbuf_free(rx_pkt_burst[i]);
}
/* Clean up and remove slaves from bonded device */
/* free mbufs */
for (i = 0; i < MAX_PKT_BURST; i++) {
- if (rx_pkt_burst[i] != NULL)
- rte_pktmbuf_free(rx_pkt_burst[i]);
+ rte_pktmbuf_free(rx_pkt_burst[i]);
}
/* Clean up and remove slaves from bonded device */
uint16_t i;
for (i = 0; i < count; i++) {
- if (pkts[i] != NULL)
- rte_pktmbuf_free(pkts[i]);
+ rte_pktmbuf_free(pkts[i]);
}
}
err_return:
/*clean up */
- if (p1) rte_free(p1);
+ rte_free(p1);
return -1;
}
err_return:
/* clean up pointer */
- if (bad_ptr)
- rte_free(bad_ptr);
+ rte_free(bad_ptr);
return -1;
}
return 0;
fail:
- if (m)
- rte_pktmbuf_free(m);
+ rte_pktmbuf_free(m);
return -1;
}
return 0;
fail:
- if (m)
- rte_pktmbuf_free(m);
- if (clone)
- rte_pktmbuf_free(clone);
- if (clone2)
- rte_pktmbuf_free(clone2);
+ rte_pktmbuf_free(m);
+ rte_pktmbuf_free(clone);
+ rte_pktmbuf_free(clone2);
return -1;
}
return 0;
fail:
- if (m)
- rte_pktmbuf_free(m);
- if (copy)
- rte_pktmbuf_free(copy);
- if (copy2)
- rte_pktmbuf_free(copy2);
+ rte_pktmbuf_free(m);
+ rte_pktmbuf_free(copy);
+ rte_pktmbuf_free(copy2);
return -1;
}
return 0;
fail:
- if (m)
- rte_pktmbuf_free(m);
- if (clone)
- rte_pktmbuf_free(clone);
- if (clone2)
- rte_pktmbuf_free(clone2);
+ rte_pktmbuf_free(m);
+ rte_pktmbuf_free(clone);
+ rte_pktmbuf_free(clone2);
return -1;
}
}
/* free them */
for (i=0; i<NB_MBUF; i++) {
- if (m[i] != NULL)
- rte_pktmbuf_free(m[i]);
+ rte_pktmbuf_free(m[i]);
}
return ret;
/* free them */
for (i=0; i<NB_MBUF; i++) {
- if (m[i] != NULL)
- rte_pktmbuf_free(m[i]);
+ rte_pktmbuf_free(m[i]);
}
for (i=0; i<NB_MBUF; i++)
/* free them */
for (i=0; i<NB_MBUF; i++) {
- if (m[i] != NULL)
- rte_pktmbuf_free(m[i]);
+ rte_pktmbuf_free(m[i]);
}
return ret;
return 0;
fail:
- if (mbuf)
- rte_pktmbuf_free(mbuf);
+ rte_pktmbuf_free(mbuf);
return -1;
}
return 0;
fail:
- if (pool != NULL)
- rte_mempool_free(pool);
+ rte_mempool_free(pool);
return -1;
}
static void
test_cleanup(void)
{
- if (mp)
- rte_mempool_free(mp);
+ rte_mempool_free(mp);
if (pcapng)
rte_pcapng_close(pcapng);
exit:
rte_reorder_free(b);
for (i = 0; i < num_bufs; i++) {
- if (bufs[i] != NULL)
- rte_pktmbuf_free(bufs[i]);
+ rte_pktmbuf_free(bufs[i]);
}
return ret;
}
ret = -1;
goto exit;
}
- if (robufs[0] != NULL)
- rte_pktmbuf_free(robufs[0]);
+ rte_pktmbuf_free(robufs[0]);
/* Insert more packets
* RB[] = {NULL, NULL, NULL, NULL}
goto exit;
}
for (i = 0; i < 3; i++) {
- if (robufs[i] != NULL)
- rte_pktmbuf_free(robufs[i]);
+ rte_pktmbuf_free(robufs[i]);
}
/*
exit:
rte_reorder_free(b);
for (i = 0; i < num_bufs; i++) {
- if (bufs[i] != NULL)
- rte_pktmbuf_free(bufs[i]);
- if (robufs[i] != NULL)
- rte_pktmbuf_free(robufs[i]);
+ rte_pktmbuf_free(bufs[i]);
+ rte_pktmbuf_free(robufs[i]);
}
return ret;
}
/* free packets in burst */
for (i = 0; i < successfully_txd; i++) {
/* free packets in burst */
- if (bufs[i] != NULL)
- rte_pktmbuf_free(bufs[i]);
+ rte_pktmbuf_free(bufs[i]);
bufs[i] = NULL;
}
}
printf("Number of 5GUL engines %d\n", numEngines);
- if (d->sw_rings_base != NULL)
- rte_free(d->sw_rings_base);
+ rte_free(d->sw_rings_base);
usleep(ACC100_LONG_WAIT);
}
}
exit:
- if (kvlist)
- rte_kvargs_free(kvlist);
+ rte_kvargs_free(kvlist);
return ret;
}
}
exit:
- if (kvlist)
- rte_kvargs_free(kvlist);
+ rte_kvargs_free(kvlist);
return ret;
}
}
exit:
- if (kvlist)
- rte_kvargs_free(kvlist);
+ rte_kvargs_free(kvlist);
return ret;
}
insert_in_device_list(dev);
/* Don't need the duplicated device filesystem entry anymore */
- if (dup_dev_name)
- free(dup_dev_name);
+ free(dup_dev_name);
return 0;
cleanup:
- if (dup_dev_name)
- free(dup_dev_name);
+ free(dup_dev_name);
if (dev) {
rte_intr_instance_free(dev->intr_handle);
free(dev);
if (!token) {
DPAA2_BUS_WARN("Failed to get interrupt id for dpio.%d",
dpio_id);
- if (temp)
- free(temp);
+ free(temp);
fclose(file);
return;
}
int i = 0;
for (i = 0; i < NUM_DQS_PER_QUEUE; i++) {
- if (q_storage->dq_storage[i])
- rte_free(q_storage->dq_storage[i]);
+ rte_free(q_storage->dq_storage[i]);
}
}
return afu_dev;
end:
- if (kvlist)
- rte_kvargs_free(kvlist);
- if (path)
- free(path);
+ rte_kvargs_free(kvlist);
+ free(path);
if (afu_dev) {
rte_intr_instance_free(afu_dev->intr_handle);
free(afu_dev);
}
end:
- if (kvlist)
- rte_kvargs_free(kvlist);
- if (name)
- free(name);
+ rte_kvargs_free(kvlist);
+ free(name);
return 0;
}
rte_pci_device_name(&addr, da->name, sizeof(da->name));
out:
- if (kvargs != NULL)
- rte_kvargs_free(kvargs);
+ rte_kvargs_free(kvargs);
if (ret != 0)
rte_errno = -ret;
return ret;
return 0;
end:
- if (dev)
- free(dev);
+ free(dev);
return ret;
}
CloseHandle(netuio);
}
- if (dev_ifx_detail)
- free(dev_ifx_detail);
+ free(dev_ifx_detail);
if (di_set != INVALID_HANDLE_VALUE)
SetupDiDestroyDeviceInfoList(di_set);
switch (sess->xfrm_type) {
case RTE_CRYPTO_ASYM_XFORM_RSA:
rsa = &sess->rsa_ctx;
- if (rsa->n.data)
- rte_free(rsa->n.data);
+ rte_free(rsa->n.data);
break;
case RTE_CRYPTO_ASYM_XFORM_MODEX:
mod = &sess->mod_ctx;
- if (mod->modulus.data)
- rte_free(mod->modulus.data);
+ rte_free(mod->modulus.data);
break;
case RTE_CRYPTO_ASYM_XFORM_ECDSA:
/* Fall through */
/* Allocator stuff */
#define kmalloc(sz, t) rte_malloc(NULL, sz, 0)
+#define kzalloc(sz, t) rte_zmalloc(NULL, sz, 0)
#define vmalloc(sz) rte_malloc(NULL, sz, 0)
-#define kfree(p) { if (p) rte_free(p); }
-static inline void *kzalloc(size_t sz, gfp_t __foo __rte_unused)
-{
- void *ptr = rte_malloc(NULL, sz, 0);
-
- if (ptr)
- memset(ptr, 0, sz);
- return ptr;
-}
+#define kfree(p) rte_free(p)
static inline unsigned long get_zeroed_page(gfp_t __foo __rte_unused)
{
return;
DRV_LOG(DEBUG, "freeing MR(%p):", (void *)mr);
dereg_mr_cb(&mr->pmd_mr);
- if (mr->ms_bmp != NULL)
- rte_bitmap_free(mr->ms_bmp);
+ rte_bitmap_free(mr->ms_bmp);
mlx5_free(mr);
}
updated_table[i].vendor_id = 0;
mlx5_common_pci_driver.id_table = updated_table;
mlx5_pci_id_table = updated_table;
- if (old_table)
- free(old_table);
+ free(old_table);
return 0;
}
create_err:
if (qp) {
- if (qp->op_cookie_pool)
- rte_mempool_free(qp->op_cookie_pool);
+ rte_mempool_free(qp->op_cookie_pool);
- if (qp->op_cookies)
- rte_free(qp->op_cookies);
+ rte_free(qp->op_cookies);
rte_free(qp);
}
for (i = 0; i < qp->nb_descriptors; i++)
rte_mempool_put(qp->op_cookie_pool, qp->op_cookies[i]);
- if (qp->op_cookie_pool)
- rte_mempool_free(qp->op_cookie_pool);
+ rte_mempool_free(qp->op_cookie_pool);
rte_free(qp->op_cookies);
rte_free(qp);
void *opaq = qp->opaque_mr.addr;
mlx5_common_verbs_dereg_mr(&qp->opaque_mr);
- if (opaq != NULL)
- rte_free(opaq);
+ rte_free(opaq);
}
mlx5_mr_btree_free(&qp->mr_ctrl.cache_bh);
rte_free(qp);
if (qp != NULL) {
zipvf_q_term(qp);
- if (qp->processed_pkts)
- rte_ring_free(qp->processed_pkts);
+ rte_ring_free(qp->processed_pkts);
rte_free(qp);
dev->data->queue_pairs[qp_id] = NULL;
return 0;
qp_setup_cleanup:
- if (qp->processed_pkts)
- rte_ring_free(qp->processed_pkts);
- if (qp)
- rte_free(qp);
+ rte_ring_free(qp->processed_pkts);
+ rte_free(qp);
return -1;
}
return 0;
qp_setup_cleanup:
- if (qp)
- rte_free(qp);
+ rte_free(qp);
return -1;
}
CCP_LOG_ERR("CCP Device probe failed");
if (uio_fd >= 0)
close(uio_fd);
- if (ccp_dev)
- rte_free(ccp_dev);
+ rte_free(ccp_dev);
return -1;
}
qp_setup_cleanup:
dev->data->queue_pairs[qp_id] = NULL;
- if (qp)
- rte_free(qp);
+ rte_free(qp);
return -1;
}
switch (sess->xfrm_type) {
case RTE_CRYPTO_ASYM_XFORM_RSA:
rsa = &sess->rsa_ctx;
- if (rsa->n.data)
- rte_free(rsa->n.data);
+ rte_free(rsa->n.data);
break;
case RTE_CRYPTO_ASYM_XFORM_MODEX:
mod = &sess->mod_ctx;
- if (mod->modulus.data)
- rte_free(mod->modulus.data);
+ rte_free(mod->modulus.data);
break;
case RTE_CRYPTO_ASYM_XFORM_ECDSA:
/* Fall through */
if (qp != NULL && rte_eal_process_type() == RTE_PROC_PRIMARY) {
r = rte_ring_lookup(qp->name);
- if (r)
- rte_ring_free(r);
+ rte_ring_free(r);
#if IMB_VERSION(1, 1, 0) > IMB_VERSION_NUM
if (qp->mb_mgr)
}
/* free the keys memory allocated for session creation */
- if (mrvl_sess->sam_sess_params.cipher_key != NULL)
- free(mrvl_sess->sam_sess_params.cipher_key);
- if (mrvl_sess->sam_sess_params.auth_key != NULL)
- free(mrvl_sess->sam_sess_params.auth_key);
+ free(mrvl_sess->sam_sess_params.cipher_key);
+ free(mrvl_sess->sam_sess_params.auth_key);
return 0;
}
if (dev->data->queue_pairs[qp_id] != NULL) {
struct null_crypto_qp *qp = dev->data->queue_pairs[qp_id];
- if (qp->processed_pkts)
- rte_ring_free(qp->processed_pkts);
+ rte_ring_free(qp->processed_pkts);
rte_free(dev->data->queue_pairs[qp_id]);
dev->data->queue_pairs[qp_id] = NULL;
return 0;
qp_setup_cleanup:
- if (qp)
- rte_free(qp);
+ rte_free(qp);
return -1;
}
misc = priv;
ctx = SESS_PRIV(misc);
- if (ctx->auth_key != NULL)
- rte_free(ctx->auth_key);
+ rte_free(ctx->auth_key);
memset(priv, 0, cpt_get_session_size());
if (dev->data->queue_pairs[qp_id] != NULL) {
struct openssl_qp *qp = dev->data->queue_pairs[qp_id];
- if (qp->processed_ops)
- rte_ring_free(qp->processed_ops);
+ rte_ring_free(qp->processed_ops);
rte_free(dev->data->queue_pairs[qp_id]);
dev->data->queue_pairs[qp_id] = NULL;
return 0;
qp_setup_cleanup:
- if (qp)
- rte_free(qp);
+ rte_free(qp);
return -1;
}
if (!qp_ctx)
return 0;
- if (qp_ctx->order_ring)
- rte_ring_free(qp_ctx->order_ring);
- if (qp_ctx->private_qp_ctx)
- rte_free(qp_ctx->private_qp_ctx);
+ rte_ring_free(qp_ctx->order_ring);
+ rte_free(qp_ctx->private_qp_ctx);
rte_free(qp_ctx);
dev->data->queue_pairs[qp_id] = NULL;
for (idx = 0; idx < vq->vq_nentries; idx++) {
cop = vq->vq_descx[idx].crypto_op;
if (cop) {
- if (cop->sym->m_src)
- rte_pktmbuf_free(cop->sym->m_src);
- if (cop->sym->m_dst)
- rte_pktmbuf_free(cop->sym->m_dst);
+ rte_pktmbuf_free(cop->sym->m_src);
+ rte_pktmbuf_free(cop->sym->m_dst);
rte_crypto_op_free(cop);
vq->vq_descx[idx].crypto_op = NULL;
}
* IQ chunk references were cleaned out of the QIDs in sw_stop(), and
* will be reinitialized in sw_start().
*/
- if (sw->chunks)
- rte_free(sw->chunks);
+ rte_free(sw->chunks);
sw->chunks = rte_malloc_socket(NULL,
sizeof(struct sw_queue_chunk) *
sw_ring = rx_queue->sw_ring;
if (sw_ring) {
for (i = 0; i < rx_queue->nb_desc; i++) {
- if (sw_ring[i])
- rte_pktmbuf_free(sw_ring[i]);
+ rte_pktmbuf_free(sw_ring[i]);
}
rte_free(sw_ring);
}
sw_ring = tx_queue->sw_ring;
if (sw_ring) {
for (i = 0; i < tx_queue->nb_desc; i++) {
- if (sw_ring[i])
- rte_pktmbuf_free(sw_ring[i]);
+ rte_pktmbuf_free(sw_ring[i]);
}
rte_free(sw_ring);
}
sw_ring = rx_queue->sw_ring;
if (NULL != sw_ring) {
for (i = 0; i < rx_queue->nb_rx_desc; i++) {
- if (NULL != sw_ring[i])
- rte_pktmbuf_free(sw_ring[i]);
+ rte_pktmbuf_free(sw_ring[i]);
}
rte_free(sw_ring);
}
sw_ring = tx_queue->sw_ring;
if (NULL != sw_ring) {
for (i = 0; i < tx_queue->nb_tx_desc; i++) {
- if (NULL != sw_ring[i])
- rte_pktmbuf_free(sw_ring[i]);
+ rte_pktmbuf_free(sw_ring[i]);
}
rte_free(sw_ring);
}
if (!ctx)
return;
- if (ctx->va)
- rte_free(ctx->va);
+ rte_free(ctx->va);
ctx->va = NULL;
ctx->dma = RTE_BAD_IOVA;
*/
rte_mempool_free(internals->mode6.mempool);
- if (internals->kvlist != NULL)
- rte_kvargs_free(internals->kvlist);
+ rte_kvargs_free(internals->kvlist);
return 0;
}
for (i = 0; i < eth_dev->data->nb_tx_queues; i++)
dev_ops->tx_queue_release(eth_dev, i);
fail:
- if (tx_qconf)
- free(tx_qconf);
- if (rx_qconf)
- free(rx_qconf);
+ free(tx_qconf);
+ free(rx_qconf);
return rc;
}
static void tid_free(struct tid_info *t)
{
if (t->tid_tab) {
- if (t->ftid_bmap)
- rte_bitmap_free(t->ftid_bmap);
+ rte_bitmap_free(t->ftid_bmap);
if (t->ftid_bmap_array)
t4_os_free(t->ftid_bmap_array);
}
/* release configuration memory */
- if (dpaa_intf->fc_conf)
- rte_free(dpaa_intf->fc_conf);
+ rte_free(dpaa_intf->fc_conf);
/* Release RX congestion Groups */
if (dpaa_intf->cgr_rx) {
_fml_dbg("Calling...\n");
close(p_dev->fd);
- if (p_dev->h_user_priv)
- free(p_dev->h_user_priv);
+ free(p_dev->h_user_priv);
free(p_dev);
_fml_dbg("Finishing.\n");
/* cleaning up queue storage */
for (i = 0; i < priv->nb_rx_queues; i++) {
dpaa2_q = (struct dpaa2_queue *)priv->rx_vq[i];
- if (dpaa2_q->q_storage)
- rte_free(dpaa2_q->q_storage);
+ rte_free(dpaa2_q->q_storage);
}
/* cleanup tx queue cscn */
for (i = 0; i < priv->nb_tx_queues; i++) {
return 0;
init_err:
- if (dpdmux_dev)
- rte_free(dpdmux_dev);
+ rte_free(dpdmux_dev);
return -1;
}
return 0;
init_err:
- if (dprtc_dev)
- rte_free(dprtc_dev);
+ rte_free(dprtc_dev);
return -1;
}
struct ena_ring *ring = dev->data->rx_queues[qid];
/* Free ring resources */
- if (ring->rx_buffer_info)
- rte_free(ring->rx_buffer_info);
+ rte_free(ring->rx_buffer_info);
ring->rx_buffer_info = NULL;
- if (ring->rx_refill_buffer)
- rte_free(ring->rx_refill_buffer);
+ rte_free(ring->rx_refill_buffer);
ring->rx_refill_buffer = NULL;
- if (ring->empty_rx_reqs)
- rte_free(ring->empty_rx_reqs);
+ rte_free(ring->empty_rx_reqs);
ring->empty_rx_reqs = NULL;
ring->configured = 0;
struct ena_ring *ring = dev->data->tx_queues[qid];
/* Free ring resources */
- if (ring->push_buf_intermediate_buf)
- rte_free(ring->push_buf_intermediate_buf);
+ rte_free(ring->push_buf_intermediate_buf);
- if (ring->tx_buffer_info)
- rte_free(ring->tx_buffer_info);
+ rte_free(ring->tx_buffer_info);
- if (ring->empty_tx_reqs)
- rte_free(ring->empty_tx_reqs);
+ rte_free(ring->empty_tx_reqs);
ring->empty_tx_reqs = NULL;
ring->tx_buffer_info = NULL;
static void hinic_copy_mempool_uninit(struct hinic_nic_dev *nic_dev)
{
- if (nic_dev->cpy_mpool != NULL)
- rte_mempool_free(nic_dev->cpy_mpool);
+ rte_mempool_free(nic_dev->cpy_mpool);
}
static int hinic_init_sw_rxtxqs(struct hinic_nic_dev *nic_dev)
hns3_rx_queue_release_mbufs(rxq);
if (rxq->mz)
rte_memzone_free(rxq->mz);
- if (rxq->sw_ring)
- rte_free(rxq->sw_ring);
+ rte_free(rxq->sw_ring);
rte_free(rxq);
}
}
hns3_tx_queue_release_mbufs(txq);
if (txq->mz)
rte_memzone_free(txq->mz);
- if (txq->sw_ring)
- rte_free(txq->sw_ring);
- if (txq->free)
- rte_free(txq->free);
+ rte_free(txq->sw_ring);
+ rte_free(txq->free);
rte_free(txq);
}
}
ethertype_rule = &pf->ethertype;
/* Remove all ethertype filter rules and hash */
- if (ethertype_rule->hash_map)
- rte_free(ethertype_rule->hash_map);
- if (ethertype_rule->hash_table)
- rte_hash_free(ethertype_rule->hash_table);
+ rte_free(ethertype_rule->hash_map);
+ rte_hash_free(ethertype_rule->hash_table);
while ((p_ethertype = TAILQ_FIRST(ðertype_rule->ethertype_list))) {
TAILQ_REMOVE(ðertype_rule->ethertype_list,
tunnel_rule = &pf->tunnel;
/* Remove all tunnel director rules and hash */
- if (tunnel_rule->hash_map)
- rte_free(tunnel_rule->hash_map);
- if (tunnel_rule->hash_table)
- rte_hash_free(tunnel_rule->hash_table);
+ rte_free(tunnel_rule->hash_map);
+ rte_hash_free(tunnel_rule->hash_table);
while ((p_tunnel = TAILQ_FIRST(&tunnel_rule->tunnel_list))) {
TAILQ_REMOVE(&tunnel_rule->tunnel_list, p_tunnel, rules);
fdir_info = &pf->fdir;
/* flow director memory cleanup */
- if (fdir_info->hash_map)
- rte_free(fdir_info->hash_map);
- if (fdir_info->hash_table)
- rte_hash_free(fdir_info->hash_table);
- if (fdir_info->fdir_flow_pool.bitmap)
- rte_free(fdir_info->fdir_flow_pool.bitmap);
- if (fdir_info->fdir_flow_pool.pool)
- rte_free(fdir_info->fdir_flow_pool.pool);
- if (fdir_info->fdir_filter_array)
- rte_free(fdir_info->fdir_filter_array);
+ rte_free(fdir_info->hash_map);
+ rte_hash_free(fdir_info->hash_table);
+ rte_free(fdir_info->fdir_flow_pool.bitmap);
+ rte_free(fdir_info->fdir_flow_pool.pool);
+ rte_free(fdir_info->fdir_filter_array);
}
void i40e_flex_payload_reg_set_default(struct i40e_hw *hw)
rxq->rx_tail = 0;
rxq->nb_rx_hold = 0;
- if (rxq->pkt_first_seg != NULL)
- rte_pktmbuf_free(rxq->pkt_first_seg);
+ rte_pktmbuf_free(rxq->pkt_first_seg);
rxq->pkt_first_seg = NULL;
rxq->pkt_last_seg = NULL;
rxq->rx_tail = 0;
rxq->nb_rx_hold = 0;
- if (rxq->pkt_first_seg != NULL)
- rte_pktmbuf_free(rxq->pkt_first_seg);
+ rte_pktmbuf_free(rxq->pkt_first_seg);
rxq->pkt_first_seg = NULL;
rxq->pkt_last_seg = NULL;
{
struct ice_fdir_info *fdir_info = &pf->fdir;
- if (fdir_info->hash_map)
- rte_free(fdir_info->hash_map);
- if (fdir_info->hash_table)
- rte_hash_free(fdir_info->hash_table);
+ rte_free(fdir_info->hash_map);
+ rte_hash_free(fdir_info->hash_table);
fdir_info->hash_map = NULL;
fdir_info->hash_table = NULL;
}
if (ret) {
- /* check and free the memory */
- if (flow)
- rte_free(flow);
-
+ rte_free(flow);
rte_flow_error_set(error, -ret,
RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
"Failed to create flow.");
IXGBE_DEV_PRIVATE_TO_FDIR_INFO(eth_dev->data->dev_private);
struct ixgbe_fdir_filter *fdir_filter;
- if (fdir_info->hash_map)
- rte_free(fdir_info->hash_map);
- if (fdir_info->hash_handle)
- rte_hash_free(fdir_info->hash_handle);
+ rte_free(fdir_info->hash_map);
+ rte_hash_free(fdir_info->hash_handle);
while ((fdir_filter = TAILQ_FIRST(&fdir_info->fdir_list))) {
TAILQ_REMOVE(&fdir_info->fdir_list,
IXGBE_DEV_PRIVATE_TO_L2_TN_INFO(eth_dev->data->dev_private);
struct ixgbe_l2_tn_filter *l2_tn_filter;
- if (l2_tn_info->hash_map)
- rte_free(l2_tn_info->hash_map);
- if (l2_tn_info->hash_handle)
- rte_hash_free(l2_tn_info->hash_handle);
+ rte_free(l2_tn_info->hash_map);
+ rte_hash_free(l2_tn_info->hash_handle);
while ((l2_tn_filter = TAILQ_FIRST(&l2_tn_info->l2_tn_list))) {
TAILQ_REMOVE(&l2_tn_info->l2_tn_list,
rxq->rx_tail = 0;
rxq->nb_rx_hold = 0;
- if (rxq->pkt_first_seg != NULL)
- rte_pktmbuf_free(rxq->pkt_first_seg);
+ rte_pktmbuf_free(rxq->pkt_first_seg);
rxq->pkt_first_seg = NULL;
rxq->pkt_last_seg = NULL;
ret = -EINVAL;
}
- if (dir != NULL)
- rte_free(dir);
+ rte_free(dir);
return ret;
}
log2_ring_size, pkt_buffer_size, secret, ether_addr);
exit:
- if (kvlist != NULL)
- rte_kvargs_free(kvlist);
+ rte_kvargs_free(kvlist);
return ret;
}
DEBUG("freeing MR(%p):", (void *)mr);
if (mr->ibv_mr != NULL)
claim_zero(mlx4_glue->dereg_mr(mr->ibv_mr));
- if (mr->ms_bmp != NULL)
- rte_bitmap_free(mr->ms_bmp);
+ rte_bitmap_free(mr->ms_bmp);
rte_free(mr);
}
data->rssq_num = MLX5_RSSQ_DEFAULT_NUM;
return data;
err:
- if (data->rss_desc.queue)
- free(data->rss_desc.queue);
+ free(data->rss_desc.queue);
free(data);
return NULL;
}
param->num_in_qs = inqs;
/* Release old config if necessary. */
- if (param->inqs_params)
- rte_free(param->inqs_params);
+ rte_free(param->inqs_params);
param->inqs_params = inq_params;
}
error:
- if (txq->txdesc_pool)
- rte_mempool_free(txq->txdesc_pool);
+ rte_mempool_free(txq->txdesc_pool);
rte_memzone_free(txq->tx_rndis_mz);
rte_free(txq);
return err;
if (!txq)
return;
- if (txq->txdesc_pool)
- rte_mempool_free(txq->txdesc_pool);
+ rte_mempool_free(txq->txdesc_pool);
rte_memzone_free(txq->tx_rndis_mz);
rte_free(txq);
ret = eth_dev_null_create(dev, &args);
free_kvlist:
- if (kvlist)
- rte_kvargs_free(kvlist);
+ rte_kvargs_free(kvlist);
return ret;
}
return res;
err:
- if (txq)
- rte_free(txq);
+ rte_free(txq);
return res;
}
if (rc != 0) {
octeontx_log_err("Fail to configure vlan filter entry "
"for port %d", nic->port_id);
- if (entry)
- rte_free(entry);
+ rte_free(entry);
goto done;
}
err:
#ifdef CONFIG_ECORE_BINARY_FW
if (IS_PF(edev)) {
- if (edev->firmware)
- rte_free(edev->firmware);
+ rte_free(edev->firmware);
edev->firmware = NULL;
}
#endif
}
}
- if (qdev->fp_array)
- rte_free(qdev->fp_array);
+ rte_free(qdev->fp_array);
qdev->fp_array = NULL;
- if (qdev->fp_array_cmt)
- rte_free(qdev->fp_array_cmt);
+ rte_free(qdev->fp_array_cmt);
qdev->fp_array_cmt = NULL;
}
switch (xform[i]->type) {
case RTE_CRYPTO_SYM_XFORM_CIPHER:
- if (p->cipher_auth.cipher_iv.val)
- free(p->cipher_auth.cipher_iv.val);
- if (p->cipher_auth.cipher_iv_update.val)
- free(p->cipher_auth.cipher_iv_update.val);
+ free(p->cipher_auth.cipher_iv.val);
+ free(p->cipher_auth.cipher_iv_update.val);
break;
case RTE_CRYPTO_SYM_XFORM_AUTH:
if (p->cipher_auth.auth_iv.val)
free(p->cipher_auth.cipher_iv_update.val);
break;
case RTE_CRYPTO_SYM_XFORM_AEAD:
- if (p->aead.iv.val)
- free(p->aead.iv.val);
- if (p->aead.aad.val)
- free(p->aead.aad.val);
+ free(p->aead.iv.val);
+ free(p->aead.aad.val);
break;
default:
continue;
return cryptodev;
error_exit:
- if (cryptodev->mp_create)
- rte_mempool_free(cryptodev->mp_create);
- if (cryptodev->mp_init)
- rte_mempool_free(cryptodev->mp_init);
+ rte_mempool_free(cryptodev->mp_create);
+ rte_mempool_free(cryptodev->mp_init);
free(cryptodev);
struct softnic_thread *t = &softnic->thread[i];
/* MSGQs */
- if (t->msgq_req)
- rte_ring_free(t->msgq_req);
+ rte_ring_free(t->msgq_req);
- if (t->msgq_rsp)
- rte_ring_free(t->msgq_rsp);
+ rte_ring_free(t->msgq_rsp);
}
}
}
return flow;
fail:
- if (remote_flow)
- rte_free(remote_flow);
+ rte_free(remote_flow);
if (flow)
tap_flow_free(pmd, flow);
return NULL;
}
}
end:
- if (remote_flow)
- rte_free(remote_flow);
+ rte_free(remote_flow);
tap_flow_free(pmd, flow);
return ret;
}
success:
return 0;
fail:
- if (remote_flow)
- rte_free(remote_flow);
+ rte_free(remote_flow);
return -1;
}
struct txgbe_hw_fdir_info *fdir_info = TXGBE_DEV_FDIR(eth_dev);
struct txgbe_fdir_filter *fdir_filter;
- if (fdir_info->hash_map)
- rte_free(fdir_info->hash_map);
- if (fdir_info->hash_handle)
- rte_hash_free(fdir_info->hash_handle);
+ rte_free(fdir_info->hash_map);
+ rte_hash_free(fdir_info->hash_handle);
while ((fdir_filter = TAILQ_FIRST(&fdir_info->fdir_list))) {
TAILQ_REMOVE(&fdir_info->fdir_list,
struct txgbe_l2_tn_info *l2_tn_info = TXGBE_DEV_L2_TN(eth_dev);
struct txgbe_l2_tn_filter *l2_tn_filter;
- if (l2_tn_info->hash_map)
- rte_free(l2_tn_info->hash_map);
- if (l2_tn_info->hash_handle)
- rte_hash_free(l2_tn_info->hash_handle);
+ rte_free(l2_tn_info->hash_map);
+ rte_hash_free(l2_tn_info->hash_handle);
while ((l2_tn_filter = TAILQ_FIRST(&l2_tn_info->l2_tn_list))) {
TAILQ_REMOVE(&l2_tn_info->l2_tn_list,
error:
++vdev_netvsc_ctx_inst;
ignore:
- if (kvargs)
- rte_kvargs_free(kvargs);
+ rte_kvargs_free(kvargs);
/* Reset alarm if there are device context created */
if (vdev_netvsc_ctx_count) {
ret = rte_eal_alarm_set(VDEV_NETVSC_PROBE_MS * 1000,
ret = 0;
end:
- if (kvlist)
- rte_kvargs_free(kvlist);
- if (path)
- free(path);
- if (mac_addr)
- free(mac_addr);
- if (ifname)
- free(ifname);
+ rte_kvargs_free(kvlist);
+ free(path);
+ free(mac_addr);
+ free(ifname);
return ret;
}
unsigned int i;
for (i = 0; i < cgx->num_queues; i++) {
- if (cgx->queues[i].rsp)
- rte_free(cgx->queues[i].rsp);
+ rte_free(cgx->queues[i].rsp);
}
cgx->num_queues = 0;
/* Reset and free virtual queues */
for (i = 0; i < qdma_dev->max_vqs; i++) {
- if (qdma_dev->vqs[i].status_ring)
- rte_ring_free(qdma_dev->vqs[i].status_ring);
+ rte_ring_free(qdma_dev->vqs[i].status_ring);
}
- if (qdma_dev->vqs)
- rte_free(qdma_dev->vqs);
+ rte_free(qdma_dev->vqs);
qdma_dev->vqs = NULL;
/* Reset per core info */
if (qdma_dev->vqs[i].hw_queue == NULL) {
DPAA2_QDMA_ERR("No H/W queue available for VQ");
- if (qdma_dev->vqs[i].status_ring)
- rte_ring_free(qdma_dev->vqs[i].status_ring);
+ rte_ring_free(qdma_dev->vqs[i].status_ring);
qdma_dev->vqs[i].status_ring = NULL;
rte_spinlock_unlock(&qdma_dev->lock);
return -ENODEV;
if (qdma_vq->exclusive_hw_queue)
free_hw_queue(qdma_vq->hw_queue);
else {
- if (qdma_vq->status_ring)
- rte_ring_free(qdma_vq->status_ring);
+ rte_ring_free(qdma_vq->status_ring);
put_hw_queue(qdma_vq->hw_queue);
}
- if (qdma_vq->fle_pool)
- rte_mempool_free(qdma_vq->fle_pool);
+ rte_mempool_free(qdma_vq->fle_pool);
memset(qdma_vq, 0, sizeof(struct qdma_virt_queue));
}
free_buffer:
- if (buf_to_free)
- rte_free(buf_to_free);
+ rte_free(buf_to_free);
close_fd:
close(file_fd);
file_fd = 0;
ret = rte_eal_hotplug_add(RTE_STR(IFPGA_BUS_NAME),
dev_name, devargs->args);
end:
- if (kvlist)
- rte_kvargs_free(kvlist);
- if (name)
- free(name);
+ rte_kvargs_free(kvlist);
+ free(name);
return ret;
}
RTE_TEST_ASSERT_EQUAL((unsigned int)ret, count,
"Unable to dequeue buffers");
- if (deq_buffers)
- free(deq_buffers);
+ free(deq_buffers);
return TEST_SUCCESS;
cleanup:
- if (buffers[0].buf_addr)
- free(buffers[0].buf_addr);
+ free(buffers[0].buf_addr);
return TEST_FAILED;
}
cn9k_err("Could not detach queues");
/* TEMP : should be in lib */
- if (data->queue_pairs)
- rte_free(data->queue_pairs);
- if (data->rules)
- rte_free(data->rules);
+ rte_free(data->queue_pairs);
+ rte_free(data->rules);
roc_ree_dev_fini(vf);
rxp_free_structs(NULL, NULL, NULL, NULL, NULL, &rof, NULL, &rofi, NULL,
1);
- if (rule_db)
- rte_free(rule_db);
+ rte_free(rule_db);
return ret;
}
if (priv->regexdev)
rte_regexdev_unregister(priv->regexdev);
dev_error:
- if (priv)
- rte_free(priv);
+ rte_free(priv);
return -rte_errno;
}
DRV_LOG(DEBUG, "Regex config without rules programming!");
return 0;
configure_error:
- if (priv->qps)
- rte_free(priv->qps);
+ rte_free(priv->qps);
return -rte_errno;
}
}
exit:
- if (mem)
- free(mem);
+ free(mem);
return ret;
}
}
exit:
- if (mem)
- free(mem);
+ free(mem);
return gpa;
}
error:
for (i = 0; i < nr_vring; i++)
- if (internal->m_vring[i].desc)
- rte_free(internal->m_vring[i].desc);
+ rte_free(internal->m_vring[i].desc);
return -1;
}
priv->gpa_mkey_index = entry->mkey->id;
return 0;
error:
- if (entry)
- rte_free(entry);
+ rte_free(entry);
mlx5_vdpa_mem_dereg(priv);
rte_errno = -ret;
return ret;
if (virtq->umems[i].obj)
claim_zero(mlx5_glue->devx_umem_dereg
(virtq->umems[i].obj));
- if (virtq->umems[i].buf)
- rte_free(virtq->umems[i].buf);
+ rte_free(virtq->umems[i].buf);
}
memset(&virtq->umems, 0, sizeof(virtq->umems));
if (virtq->eqp.fw_qp)
if (!mbuf)
return -1;
- if (op->sym->aead.aad.data)
- rte_free(op->sym->aead.aad.data);
+ rte_free(op->sym->aead.aad.data);
if (dir == self_test_dir_enc_auth_gen) {
src = vec->output.data;
fips_dev_auto_test_uninit(uint8_t dev_id,
struct fips_dev_auto_test_env *env)
{
- if (env->mbuf)
- rte_pktmbuf_free(env->mbuf);
+ rte_pktmbuf_free(env->mbuf);
if (env->op)
rte_crypto_op_free(env->op);
- if (env->mpool)
- rte_mempool_free(env->mpool);
- if (env->op_pool)
- rte_mempool_free(env->op_pool);
- if (env->sess_pool)
- rte_mempool_free(env->sess_pool);
- if (env->sess_priv_pool)
- rte_mempool_free(env->sess_priv_pool);
+ rte_mempool_free(env->mpool);
+ rte_mempool_free(env->op_pool);
+ rte_mempool_free(env->sess_pool);
+ rte_mempool_free(env->sess_priv_pool);
rte_cryptodev_stop(dev_id);
}
fclose(info.fp_rd);
if (info.fp_wr)
fclose(info.fp_wr);
- if (info.one_line_text)
- free(info.one_line_text);
+ free(info.one_line_text);
if (info.nb_vec_lines) {
uint32_t i;
error_exit:
rte_mempool_free(env.mpool);
- if (env.sess_mpool)
- rte_mempool_free(env.sess_mpool);
- if (env.sess_priv_mpool)
- rte_mempool_free(env.sess_priv_mpool);
- if (env.op_pool)
- rte_mempool_free(env.op_pool);
+ rte_mempool_free(env.sess_mpool);
+ rte_mempool_free(env.sess_priv_mpool);
+ rte_mempool_free(env.op_pool);
return ret;
}
uint16_t nb_seg;
int ret = 0;
- if (env.mbuf)
- rte_pktmbuf_free(env.mbuf);
+ rte_pktmbuf_free(env.mbuf);
if (total_len > RTE_MBUF_MAX_NB_SEGS) {
RTE_LOG(ERR, USER1, "Data len %u too big\n", total_len);
return 0;
error_exit:
- if (head)
- rte_pktmbuf_free(head);
+ rte_pktmbuf_free(head);
return ret;
}
if (ret < 0)
return ret;
- if (env.digest)
- rte_free(env.digest);
+ rte_free(env.digest);
env.digest = rte_zmalloc(NULL, vec.cipher_auth.digest.len,
RTE_CACHE_LINE_SIZE);
if (ret < 0)
return ret;
- if (env.digest)
- rte_free(env.digest);
+ rte_free(env.digest);
env.digest = rte_zmalloc(NULL, vec.aead.digest.len,
RTE_CACHE_LINE_SIZE);
if (!env.digest) {
}
}
- if (val.val)
- free(val.val);
+ free(val.val);
return 0;
}
}
}
- if (val.val)
- free(val.val);
+ free(val.val);
return 0;
}
memcpy(vec.iv.val, val.val, AES_BLOCK_SIZE);
}
- if (val.val)
- free(val.val);
+ free(val.val);
return 0;
}
rte_free(vec.pt.val);
- if (val.val)
- free(val.val);
+ free(val.val);
return 0;
}
rte_free(env.digest);
env.digest = NULL;
}
- if (env.mbuf)
- rte_pktmbuf_free(env.mbuf);
+ rte_pktmbuf_free(env.mbuf);
return ret;
}
switch (xform[i]->type) {
case RTE_CRYPTO_SYM_XFORM_CIPHER:
- if (p->cipher_auth.cipher_iv.val)
- free(p->cipher_auth.cipher_iv.val);
- if (p->cipher_auth.cipher_iv_update.val)
- free(p->cipher_auth.cipher_iv_update.val);
+ free(p->cipher_auth.cipher_iv.val);
+ free(p->cipher_auth.cipher_iv_update.val);
break;
case RTE_CRYPTO_SYM_XFORM_AUTH:
if (p->cipher_auth.auth_iv.val)
free(p->cipher_auth.cipher_iv_update.val);
break;
case RTE_CRYPTO_SYM_XFORM_AEAD:
- if (p->aead.iv.val)
- free(p->aead.iv.val);
- if (p->aead.aad.val)
- free(p->aead.aad.val);
+ free(p->aead.iv.val);
+ free(p->aead.aad.val);
break;
default:
continue;
return cryptodev;
error_exit:
- if (cryptodev->mp_create)
- rte_mempool_free(cryptodev->mp_create);
- if (cryptodev->mp_init)
- rte_mempool_free(cryptodev->mp_init);
+ rte_mempool_free(cryptodev->mp_create);
+ rte_mempool_free(cryptodev->mp_init);
free(cryptodev);
continue;
/* MSGQs */
- if (t->msgq_req)
- rte_ring_free(t->msgq_req);
+ rte_ring_free(t->msgq_req);
- if (t->msgq_rsp)
- rte_ring_free(t->msgq_rsp);
+ rte_ring_free(t->msgq_rsp);
}
}
#if PQOS_VERSION <= 103
memset(m_sockets, 0, sizeof(m_sockets));
#else
- if (m_sockets != NULL)
- free(m_sockets);
+ free(m_sockets);
#endif
m_sock_count = 0;
memset(m_config, 0, sizeof(m_config));
continue;
/* MSGQs */
- if (t->msgq_req)
- rte_ring_free(t->msgq_req);
+ rte_ring_free(t->msgq_req);
- if (t->msgq_rsp)
- rte_ring_free(t->msgq_rsp);
+ rte_ring_free(t->msgq_rsp);
}
}
vhost_blk_ctrlr_destroy(struct vhost_blk_ctrlr *ctrlr)
{
if (ctrlr->bdev != NULL) {
- if (ctrlr->bdev->data != NULL)
- rte_free(ctrlr->bdev->data);
+ rte_free(ctrlr->bdev->data);
rte_free(ctrlr->bdev);
}
return ret;
}
- if (dev->data->queue_pairs != NULL)
- rte_free(dev->data->queue_pairs);
+ rte_free(dev->data->queue_pairs);
dev->data->queue_pairs = NULL;
dev->data->nb_queue_pairs = 0;
get_out:
for (i = 0; i < RTE_DIM(layers); i++) {
- if (layers[i].kvlist)
- rte_kvargs_free(layers[i].kvlist);
+ rte_kvargs_free(layers[i].kvlist);
}
if (ret != 0) {
if (allocated_data) {
{
if (da == NULL)
return;
- if (da->data)
- free(da->data);
+ free(da->data);
da->data = NULL;
}
rte_rwlock_write_unlock(&mcfg->mlock);
- if (addr != NULL)
- rte_free(addr);
+ rte_free(addr);
rte_eal_trace_memzone_free(name, addr, ret);
return ret;
int
eal_cleanup_config(struct internal_config *internal_cfg)
{
- if (internal_cfg->hugefile_prefix != NULL)
- free(internal_cfg->hugefile_prefix);
- if (internal_cfg->hugepage_dir != NULL)
- free(internal_cfg->hugepage_dir);
- if (internal_cfg->user_mbuf_pool_ops_name != NULL)
- free(internal_cfg->user_mbuf_pool_ops_name);
+ free(internal_cfg->hugefile_prefix);
+ free(internal_cfg->hugepage_dir);
+ free(internal_cfg->user_mbuf_pool_ops_name);
return 0;
}
return rc;
free_str:
- if (str)
- free(str);
+ free(str);
return -ENOMEM;
}
return 0;
fail:
- if (meta)
- free(meta);
+ free(meta);
return -EBADF;
}
RTE_LOG(ERR, EAL, "Could not store mbuf pool ops name\n");
else {
/* free old ops name */
- if (internal_conf->user_mbuf_pool_ops_name !=
- NULL)
- free(internal_conf->user_mbuf_pool_ops_name);
+ free(internal_conf->user_mbuf_pool_ops_name);
internal_conf->user_mbuf_pool_ops_name =
ops_name;
RTE_LOG(ERR, EAL, "Could not store hugepage directory\n");
else {
/* free old hugepage dir */
- if (internal_conf->hugepage_dir != NULL)
- free(internal_conf->hugepage_dir);
+ free(internal_conf->hugepage_dir);
internal_conf->hugepage_dir = hdir;
}
break;
RTE_LOG(ERR, EAL, "Could not store file prefix\n");
else {
/* free old prefix */
- if (internal_conf->hugefile_prefix != NULL)
- free(internal_conf->hugefile_prefix);
+ free(internal_conf->hugefile_prefix);
internal_conf->hugefile_prefix = prefix;
}
break;
RTE_LOG(ERR, EAL, "Could not store mbuf pool ops name\n");
else {
/* free old ops name */
- if (internal_conf->user_mbuf_pool_ops_name !=
- NULL)
- free(internal_conf->user_mbuf_pool_ops_name);
+ free(internal_conf->user_mbuf_pool_ops_name);
internal_conf->user_mbuf_pool_ops_name =
ops_name;
fail:
if (timer != NULL)
CloseHandle(timer);
- if (ap != NULL)
- free(ap);
+ free(ap);
exit:
rte_eal_trace_alarm_set(us, cb_fn, cb_arg, ret);
ret = 0;
exit:
- if (detail != NULL)
- free(detail);
+ free(detail);
if (list != INVALID_HANDLE_VALUE)
SetupDiDestroyDeviceInfoList(list);
}
parse_cleanup:
- if (args.str)
- free(args.str);
+ free(args.str);
return result;
}
static void
cluster_fini(struct cluster *cluster)
{
- if (cluster->graphs)
- free(cluster->graphs);
+ free(cluster->graphs);
}
static int
rte_hash_free(sad->hash[RTE_IPSEC_SAD_SPI_DIP]);
rte_hash_free(sad->hash[RTE_IPSEC_SAD_SPI_DIP_SIP]);
rte_free(sad);
- if (te != NULL)
- rte_free(te);
+ rte_free(te);
}
/*
return 0;
error_exit:
- if (pkt_len_aligns)
- rte_free(pkt_len_aligns);
- if (port->pkt_len)
- rte_free(port->pkt_len);
- if (port->pkts)
- rte_free(port->pkts);
- if (port->pkt_buff)
- rte_free(port->pkt_buff);
+ rte_free(pkt_len_aligns);
+ rte_free(port->pkt_len);
+ rte_free(port->pkts);
+ rte_free(port->pkt_buff);
return -1;
}
if (p == NULL)
return 0;
- if (p->pkt_len)
- rte_free(p->pkt_len);
- if (p->pkts)
- rte_free(p->pkts);
- if (p->pkt_buff)
- rte_free(p->pkt_buff);
+ rte_free(p->pkt_len);
+ rte_free(p->pkts);
+ rte_free(p->pkt_buff);
rte_free(p);
RTE_LOG(INFO, POWER, "Close the Empty Poll\n");
- if (ep_params != NULL)
- rte_free(ep_params);
+ rte_free(ep_params);
}
int
/* Free up the mbufs of order buffer & ready buffer */
for (i = 0; i < b->order_buf.size; i++) {
- if (b->order_buf.entries[i])
- rte_pktmbuf_free(b->order_buf.entries[i]);
- if (b->ready_buf.entries[i])
- rte_pktmbuf_free(b->ready_buf.entries[i]);
+ rte_pktmbuf_free(b->order_buf.entries[i]);
+ rte_pktmbuf_free(b->ready_buf.entries[i]);
}
}
/* If already created, free it and recreate */
vq->iotlb_pool = rte_mempool_lookup(pool_name);
- if (vq->iotlb_pool)
- rte_mempool_free(vq->iotlb_pool);
+ rte_mempool_free(vq->iotlb_pool);
vq->iotlb_pool = rte_mempool_create(pool_name,
IOTLB_CACHE_SIZE, sizeof(struct vhost_iotlb_entry), 0,
return 0;
error_exit:
- if (vcrypto->session_map)
- rte_hash_free(vcrypto->session_map);
- if (vcrypto->mbuf_pool)
- rte_mempool_free(vcrypto->mbuf_pool);
+ rte_hash_free(vcrypto->session_map);
+ rte_mempool_free(vcrypto->mbuf_pool);
rte_free(vcrypto);
}
if (vq_is_packed(dev)) {
- if (vq->shadow_used_packed)
- rte_free(vq->shadow_used_packed);
+ rte_free(vq->shadow_used_packed);
vq->shadow_used_packed = rte_malloc_socket(NULL,
vq->size *
sizeof(struct vring_used_elem_packed),
}
} else {
- if (vq->shadow_used_split)
- rte_free(vq->shadow_used_split);
+ rte_free(vq->shadow_used_split);
vq->shadow_used_split = rte_malloc_socket(NULL,
vq->size * sizeof(struct vring_used_elem),
}
}
- if (vq->batch_copy_elems)
- rte_free(vq->batch_copy_elems);
+ rte_free(vq->batch_copy_elems);
vq->batch_copy_elems = rte_malloc_socket(NULL,
vq->size * sizeof(struct batch_copy_elem),
RTE_CACHE_LINE_SIZE, vq->numa_node);
git.droids-corp.org / dpdk.git / commitdiff