lisa/android_kernel_xiaomi_sm8350
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

qcacld-3.0: components: Remove logs for qdf_mem_malloc() checks

Browse Source 
qdf_mem_malloc() function already takes care of logging the
caller function name and line number in case of any allocation error.
Hence there is no need to add the error log again.

Getting rid of these unnecessary logs reduces driver memory footprint.

Change-Id: If0b9425f82f9ed793c7639c0ed09eb1f868b6d5c
CRs-Fixed: 2781932
This commit is contained in:
Srinivas Girigowda 2020-09-21 12:26:50 -07:00 committed by snandini
parent ecee02da1d
commit d36054fbd2
45 changed files with 95 additions and 282 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
components/action_oui/core/src/wlan_action_oui_main.c
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2012-2018 The Linux Foundation. All rights reserved.
* Copyright (c) 2012-2018, 2020 The Linux Foundation. All rights reserved.
*
* Permission to use, copy, modify, and/or distribute this software for
* any purpose with or without fee is hereby granted, provided that the
@ -133,7 +133,6 @@ action_oui_psoc_create_notification(struct wlan_objmgr_psoc *psoc, void *arg)
psoc_priv = qdf_mem_malloc(sizeof(*psoc_priv));
if (!psoc_priv) {
action_oui_err("Failed to allocate psoc_priv");
status = QDF_STATUS_E_NOMEM;
goto exit;
}

2
components/action_oui/core/src/wlan_action_oui_parse.c
View File

@ -497,7 +497,6 @@ action_oui_extension_store(struct action_oui_psoc_priv *psoc_priv,
ext_priv = qdf_mem_malloc(sizeof(*ext_priv));
if (!ext_priv) {
qdf_mutex_release(&oui_priv->extension_lock);
action_oui_err("Failed to allocate memory for action oui extension priv");
return QDF_STATUS_E_NOMEM;
}
@ -698,7 +697,6 @@ QDF_STATUS action_oui_send(struct action_oui_psoc_priv *psoc_priv,
len = sizeof(*req) + no_oui_extensions * sizeof(*extension);
req = qdf_mem_malloc(len);
if (!req) {
action_oui_err("Failed to allocate memory for action_oui");
qdf_mutex_release(&oui_priv->extension_lock);
return QDF_STATUS_E_NOMEM;
}

1
components/action_oui/dispatcher/src/wlan_action_oui_ucfg_api.c
View File

@ -116,7 +116,6 @@ ucfg_action_oui_parse(struct wlan_objmgr_psoc *psoc,
oui_str = qdf_mem_malloc(len + 1);
if (!oui_str) {
action_oui_err("Mem alloc failed for string: %u", action_id);
status = QDF_STATUS_E_NOMEM;
goto exit;
}

1
components/blacklist_mgr/core/src/wlan_blm_core.c
View File

@ -969,7 +969,6 @@ blm_add_bssid_to_reject_list(struct wlan_objmgr_pdev *pdev,
blm_entry = qdf_mem_malloc(sizeof(*blm_entry));
if (!blm_entry) {
blm_err("Memory allocation of node failed");
qdf_mutex_release(&blm_ctx->reject_ap_list_lock);
return QDF_STATUS_E_FAILURE;
}

3
components/cmn_services/policy_mgr/src/wlan_policy_mgr_get_set_utils.c
View File

@ -668,7 +668,6 @@ QDF_STATUS policy_mgr_update_hw_mode_list(struct wlan_objmgr_psoc *psoc,
qdf_mem_malloc(sizeof(*pm_ctx->hw_mode.hw_mode_list) *
pm_ctx->num_dbs_hw_modes);
if (!pm_ctx->hw_mode.hw_mode_list) {
policy_mgr_err("Memory allocation failed for DBS");
pm_ctx->num_dbs_hw_modes = 0;
return QDF_STATUS_E_NOMEM;
}
@ -726,10 +725,10 @@ void policy_mgr_init_dbs_hw_mode(struct wlan_objmgr_psoc *psoc,
qdf_mem_malloc(sizeof(*pm_ctx->hw_mode.hw_mode_list) *
pm_ctx->num_dbs_hw_modes);
if (!pm_ctx->hw_mode.hw_mode_list) {
policy_mgr_err("Memory allocation failed for DBS");
pm_ctx->num_dbs_hw_modes = 0;
return;
}
qdf_mem_copy(pm_ctx->hw_mode.hw_mode_list,
ev_wlan_dbs_hw_mode_list,
(sizeof(*pm_ctx->hw_mode.hw_mode_list) *

5
components/cmn_services/policy_mgr/src/wlan_policy_mgr_init_deinit.c
View File

@ -44,10 +44,8 @@ static QDF_STATUS policy_mgr_psoc_obj_create_cb(struct wlan_objmgr_psoc *psoc,
policy_mgr_ctx = qdf_mem_malloc(
sizeof(struct policy_mgr_psoc_priv_obj));
if (!policy_mgr_ctx) {
policy_mgr_err("memory allocation failed");
if (!policy_mgr_ctx)
return QDF_STATUS_E_FAILURE;
}
policy_mgr_ctx->psoc = psoc;
policy_mgr_ctx->old_hw_mode_index = POLICY_MGR_DEFAULT_HW_MODE_INDEX;
@ -337,7 +335,6 @@ QDF_STATUS policy_mgr_psoc_open(struct wlan_objmgr_psoc *psoc)
sizeof(struct sta_ap_intf_check_work_ctx));
if (!pm_ctx->sta_ap_intf_check_work_info) {
qdf_mutex_destroy(&pm_ctx->qdf_conc_list_lock);
policy_mgr_err("Failed to alloc sta_ap_intf_check_work_info");
return QDF_STATUS_E_FAILURE;
}
pm_ctx->sta_ap_intf_check_work_info->psoc = psoc;

8
components/disa/core/src/wlan_disa_main.c
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2018-2019 The Linux Foundation. All rights reserved.
* Copyright (c) 2018-2020 The Linux Foundation. All rights reserved.
*
* Permission to use, copy, modify, and/or distribute this software for
* any purpose with or without fee is hereby granted, provided that the
@ -36,11 +36,9 @@ QDF_STATUS disa_allocate_ctx(void)
/* allocate DISA ctx */
gp_disa_ctx = qdf_mem_malloc(sizeof(*gp_disa_ctx));
if (!gp_disa_ctx) {
disa_err("unable to allocate disa_ctx");
QDF_ASSERT(0);
if (!gp_disa_ctx)
return QDF_STATUS_E_NOMEM;
}
qdf_spinlock_create(&gp_disa_ctx->lock);
return QDF_STATUS_SUCCESS;

3
components/disa/dispatcher/src/wlan_disa_obj_mgmt_api.c
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2018-2019 The Linux Foundation. All rights reserved.
* Copyright (c) 2018-2020 The Linux Foundation. All rights reserved.
*
* Permission to use, copy, modify, and/or distribute this software for
* any purpose with or without fee is hereby granted, provided that the
@ -129,7 +129,6 @@ QDF_STATUS disa_psoc_object_created_notification(
disa_priv = qdf_mem_malloc(sizeof(*disa_priv));
if (!disa_priv) {
disa_err("Failed to allocate disa_priv");
status = QDF_STATUS_E_NOMEM;
goto out;
}

45
components/ipa/core/src/wlan_ipa_core.c
View File

@ -158,10 +158,8 @@ static void wlan_ipa_uc_loaded_uc_cb(void *priv_ctxt)
}
msg = qdf_mem_malloc(sizeof(*msg));
if (!msg) {
ipa_err("op_msg allocation fails");
if (!msg)
return;
}
msg->op_code = WLAN_IPA_UC_OPCODE_UC_READY;
@ -456,10 +454,8 @@ wlan_ipa_wdi_setup(struct wlan_ipa_priv *ipa_ctx,
QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
sys_in = qdf_mem_malloc(sizeof(*sys_in) * WLAN_IPA_MAX_IFACE);
if (!sys_in) {
ipa_err("sys_in allocation failed");
if (!sys_in)
return QDF_STATUS_E_NOMEM;
}
for (i = 0; i < WLAN_IPA_MAX_IFACE; i++)
qdf_mem_copy(sys_in + i,
@ -1884,11 +1880,8 @@ static QDF_STATUS wlan_ipa_send_msg(qdf_netdev_t net_dev,
QDF_IPA_MSG_META_MSG_LEN(&meta) = sizeof(qdf_ipa_wlan_msg_t);
msg = qdf_mem_malloc(QDF_IPA_MSG_META_MSG_LEN(&meta));
if (!msg) {
ipa_err("msg allocation failed");
if (!msg)
return QDF_STATUS_E_NOMEM;
}
QDF_IPA_SET_META_MSG_TYPE(&meta, type);
strlcpy(QDF_IPA_WLAN_MSG_NAME(msg), net_dev->name, IPA_RESOURCE_NAME_MAX);
@ -2028,7 +2021,6 @@ static QDF_STATUS __wlan_ipa_wlan_evt(qdf_netdev_t net_dev, uint8_t device_mode,
}
if (!pending_event) {
ipa_err("Pending event memory alloc fail");
qdf_mutex_release(&ipa_ctx->ipa_lock);
return QDF_STATUS_E_NOMEM;
}
@ -2384,11 +2376,9 @@ static QDF_STATUS __wlan_ipa_wlan_evt(qdf_netdev_t net_dev, uint8_t device_mode,
(sizeof(qdf_ipa_wlan_msg_ex_t) +
sizeof(qdf_ipa_wlan_hdr_attrib_val_t));
msg_ex = qdf_mem_malloc(QDF_IPA_MSG_META_MSG_LEN(&meta));
if (!msg_ex) {
ipa_err("msg_ex allocation failed");
if (!msg_ex)
return QDF_STATUS_E_NOMEM;
}
strlcpy(msg_ex->name, net_dev->name,
IPA_RESOURCE_NAME_MAX);
msg_ex->num_of_attribs = 1;
@ -2503,10 +2493,8 @@ static QDF_STATUS __wlan_ipa_wlan_evt(qdf_netdev_t net_dev, uint8_t device_mode,
QDF_IPA_MSG_META_MSG_LEN(&meta) = sizeof(qdf_ipa_wlan_msg_t);
msg = qdf_mem_malloc(QDF_IPA_MSG_META_MSG_LEN(&meta));
if (!msg) {
ipa_err("msg allocation failed");
if (!msg)
return QDF_STATUS_E_NOMEM;
}
QDF_IPA_SET_META_MSG_TYPE(&meta, type);
strlcpy(QDF_IPA_WLAN_MSG_NAME(msg), net_dev->name,
@ -2701,11 +2689,8 @@ wlan_ipa_alloc_tx_desc_free_list(struct wlan_ipa_priv *ipa_ctx)
ipa_ctx->tx_desc_pool = qdf_mem_malloc(sizeof(struct wlan_ipa_tx_desc) *
max_desc_cnt);
if (!ipa_ctx->tx_desc_pool) {
ipa_err("Free Tx descriptor allocation failed");
if (!ipa_ctx->tx_desc_pool)
return QDF_STATUS_E_NOMEM;
}
qdf_list_create(&ipa_ctx->tx_desc_free_list, max_desc_cnt);
@ -2836,10 +2821,8 @@ static QDF_STATUS wlan_ipa_uc_send_wdi_control_msg(bool ctrl)
/* WDI enable message to IPA */
QDF_IPA_MSG_META_MSG_LEN(&meta) = sizeof(*ipa_msg);
ipa_msg = qdf_mem_malloc(QDF_IPA_MSG_META_MSG_LEN(&meta));
if (!ipa_msg) {
ipa_err("msg allocation failed");
if (!ipa_msg)
return QDF_STATUS_E_NOMEM;
}
if (ctrl) {
QDF_IPA_SET_META_MSG_TYPE(&meta, QDF_WDI_ENABLE);
@ -2994,10 +2977,8 @@ QDF_STATUS wlan_ipa_send_mcc_scc_msg(struct wlan_ipa_priv *ipa_ctx,
/* Send SCC/MCC Switching event to IPA */
QDF_IPA_MSG_META_MSG_LEN(&meta) = sizeof(*msg);
msg = qdf_mem_malloc(QDF_IPA_MSG_META_MSG_LEN(&meta));
if (!msg) {
ipa_err("msg allocation failed");
if (!msg)
return QDF_STATUS_E_NOMEM;
}
if (mcc_mode) {
QDF_IPA_SET_META_MSG_TYPE(&meta, QDF_SWITCH_TO_MCC);
@ -3682,10 +3663,8 @@ static QDF_STATUS wlan_ipa_uc_send_evt(qdf_netdev_t net_dev,
QDF_IPA_MSG_META_MSG_LEN(&meta) = sizeof(qdf_ipa_wlan_msg_t);
msg = qdf_mem_malloc(QDF_IPA_MSG_META_MSG_LEN(&meta));
if (!msg) {
ipa_err("msg allocation failed");
if (!msg)
return QDF_STATUS_E_NOMEM;
}
QDF_IPA_SET_META_MSG_TYPE(&meta, type);
qdf_str_lcopy(QDF_IPA_WLAN_MSG_NAME(msg), net_dev->name,
@ -3793,10 +3772,8 @@ void wlan_ipa_fw_rejuvenate_send_msg(struct wlan_ipa_priv *ipa_ctx)
meta.msg_len = sizeof(*msg);
msg = qdf_mem_malloc(meta.msg_len);
if (!msg) {
ipa_debug("msg allocation failed");
if (!msg)
return;
}
QDF_IPA_SET_META_MSG_TYPE(&meta, QDF_FWR_SSR_BEFORE_SHUTDOWN);
ipa_debug("ipa_send_msg(Evt:%d)",

4
components/ipa/core/src/wlan_ipa_main.c
View File

@ -47,10 +47,8 @@ QDF_STATUS ipa_config_mem_alloc(void)
return QDF_STATUS_SUCCESS;
ipa_cfg = qdf_mem_malloc(sizeof(*ipa_cfg));
if (!ipa_cfg) {
ipa_err("Failed to allocate memory for ipa config");
if (!ipa_cfg)
return QDF_STATUS_E_NOMEM;
}
g_ipa_config = ipa_cfg;

4
components/ipa/dispatcher/src/wlan_ipa_obj_mgmt_api.c
View File

@ -98,10 +98,8 @@ ipa_pdev_obj_create_notification(struct wlan_objmgr_pdev *pdev,
}
ipa_obj = qdf_mem_malloc(sizeof(*ipa_obj));
if (!ipa_obj) {
ipa_err("Failed to allocate memory for ipa pdev object");
if (!ipa_obj)
return QDF_STATUS_E_NOMEM;
}
status = wlan_objmgr_pdev_component_obj_attach(pdev,
WLAN_UMAC_COMP_IPA,

5
components/mlme/core/src/wlan_mlme_main.c
View File

@ -195,10 +195,8 @@ mlme_peer_object_created_notification(struct wlan_objmgr_peer *peer,
}
peer_priv = qdf_mem_malloc(sizeof(*peer_priv));
if (!peer_priv) {
mlme_legacy_err(" peer_priv component object alloc failed");
if (!peer_priv)
return QDF_STATUS_E_NOMEM;
}
status = wlan_objmgr_peer_component_obj_attach(peer,
WLAN_UMAC_COMP_MLME,
@ -1337,7 +1335,6 @@ mlme_acs_parse_weight_list(struct wlan_objmgr_psoc *psoc,
return;
acs_weight = qdf_mem_malloc(ACS_WEIGHT_MAX_STR_LEN);
if (!acs_weight)
return;

9
components/mlme/core/src/wlan_mlme_vdev_mgr_interface.c
View File

@ -1066,10 +1066,8 @@ QDF_STATUS vdevmgr_mlme_ext_hdl_create(struct vdev_mlme_obj *vdev_mlme)
vdev_mlme->vdev->vdev_objmgr.vdev_id);
vdev_mlme->ext_vdev_ptr =
qdf_mem_malloc(sizeof(struct mlme_legacy_priv));
if (!vdev_mlme->ext_vdev_ptr) {
mlme_legacy_err("failed to allocate meory for ext_vdev_ptr");
if (!vdev_mlme->ext_vdev_ptr)
return QDF_STATUS_E_NOMEM;
}
mlme_init_rate_config(vdev_mlme);
vdev_mlme->ext_vdev_ptr->fils_con_info = NULL;
@ -1316,10 +1314,9 @@ QDF_STATUS psoc_mlme_ext_hdl_create(struct psoc_mlme_obj *psoc_mlme)
{
psoc_mlme->ext_psoc_ptr =
qdf_mem_malloc(sizeof(struct wlan_mlme_psoc_ext_obj));
if (!psoc_mlme->ext_psoc_ptr) {
mlme_legacy_err("Failed to allocate memory");
if (!psoc_mlme->ext_psoc_ptr)
return QDF_STATUS_E_NOMEM;
}
target_if_cm_roam_register_tx_ops(
&psoc_mlme->ext_psoc_ptr->rso_tx_ops);

12
components/nan/core/src/nan_api.c
View File

@ -39,10 +39,8 @@ static QDF_STATUS nan_psoc_obj_created_notification(
nan_debug("nan_psoc_create_notif called");
nan_obj = qdf_mem_malloc(sizeof(*nan_obj));
if (!nan_obj) {
nan_alert("malloc failed for nan prv obj");
if (!nan_obj)
return QDF_STATUS_E_NOMEM;
}
qdf_spinlock_create(&nan_obj->lock);
status = wlan_objmgr_psoc_component_obj_attach(psoc, WLAN_UMAC_COMP_NAN,
@ -113,10 +111,8 @@ static QDF_STATUS nan_vdev_obj_created_notification(
}
nan_obj = qdf_mem_malloc(sizeof(*nan_obj));
if (!nan_obj) {
nan_err("malloc failed for nan prv obj");
if (!nan_obj)
return QDF_STATUS_E_NOMEM;
}
qdf_spinlock_create(&nan_obj->lock);
status = wlan_objmgr_vdev_component_obj_attach(vdev, WLAN_UMAC_COMP_NAN,
@ -184,10 +180,8 @@ static QDF_STATUS nan_peer_obj_created_notification(
QDF_STATUS status = QDF_STATUS_SUCCESS;
nan_peer_obj = qdf_mem_malloc(sizeof(*nan_peer_obj));
if (!nan_peer_obj) {
nan_err("malloc failed for nan prv obj");
if (!nan_peer_obj)
return QDF_STATUS_E_NOMEM;
}
qdf_spinlock_create(&nan_peer_obj->lock);
status = wlan_objmgr_peer_component_obj_attach(peer, WLAN_UMAC_COMP_NAN,

10
components/nan/dispatcher/src/nan_ucfg_api.c
View File

@ -420,10 +420,9 @@ QDF_STATUS ucfg_nan_req_processor(struct wlan_objmgr_vdev *vdev,
}
msg.bodyptr = qdf_mem_malloc(len);
if (!msg.bodyptr) {
nan_err("malloc failed");
if (!msg.bodyptr)
return QDF_STATUS_E_NOMEM;
}
qdf_mem_copy(msg.bodyptr, in_req, len);
msg.type = req_type;
msg.callback = nan_scheduled_msg_handler;
@ -1260,10 +1259,9 @@ QDF_STATUS ucfg_nan_disable_ind_to_userspace(struct wlan_objmgr_psoc *psoc)
disable_ind = qdf_mem_malloc(sizeof(struct nan_event_params) +
sizeof(msg));
if (!disable_ind) {
nan_err("failed to alloc disable_ind");
if (!disable_ind)
return QDF_STATUS_E_NOMEM;
}
disable_ind->psoc = psoc,
disable_ind->evt_type = nan_event_id_disable_ind;
disable_ind->buf_len = sizeof(msg);

9
components/ocb/core/src/wlan_ocb_main.c
View File

@ -94,10 +94,9 @@ static QDF_STATUS ocb_set_chan_info(void *dp_soc,
buf_size = sizeof(*ocb_channel_info) * config->channel_count;
ocb_set_chan.ocb_channel_info = qdf_mem_malloc(buf_size);
if (!ocb_set_chan.ocb_channel_info) {
ocb_err("Failed to allocate buffer for chan info");
if (!ocb_set_chan.ocb_channel_info)
return QDF_STATUS_E_NOMEM;
}
ocb_channel_info = ocb_set_chan.ocb_channel_info;
for (i = 0; i < config->channel_count; i++) {
ocb_channel_info[i].chan_freq =
@ -516,10 +515,8 @@ QDF_STATUS ocb_pdev_obj_create_notification(struct wlan_objmgr_pdev *pdev,
ocb_notice("ocb pdev created");
ocb_obj = qdf_mem_malloc(sizeof(*ocb_obj));
if (!ocb_obj) {
ocb_err("Failed to allocate memory for ocb pdev object");
if (!ocb_obj)
return QDF_STATUS_E_FAILURE;
}
status = wlan_objmgr_pdev_component_obj_attach(pdev,
WLAN_UMAC_COMP_OCB,

19
components/ocb/dispatcher/src/wlan_ocb_tgt_api.c
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2018 The Linux Foundation. All rights reserved.
* Copyright (c) 2018, 2020 The Linux Foundation. All rights reserved.
*
* Permission to use, copy, modify, and/or distribute this software for
* any purpose with or without fee is hereby granted, provided that the
@ -67,10 +67,8 @@ tgt_ocb_channel_config_status(struct wlan_objmgr_psoc *psoc,
struct ocb_rx_event *event;
event = qdf_mem_malloc(sizeof(*event));
if (!event) {
ocb_err("Memory malloc failed for channel config status");
if (!event)
return QDF_STATUS_E_NOMEM;
}
qdf_status = wlan_objmgr_psoc_try_get_ref(psoc, WLAN_OCB_SB_ID);
if (QDF_IS_STATUS_ERROR(qdf_status)) {
@ -114,10 +112,8 @@ tgt_ocb_get_tsf_timer(struct wlan_objmgr_psoc *psoc,
struct ocb_rx_event *event;
event = qdf_mem_malloc(sizeof(*event));
if (!event) {
ocb_err("Memory malloc failed for tsf timer");
if (!event)
return QDF_STATUS_E_NOMEM;
}
status = wlan_objmgr_psoc_try_get_ref(psoc, WLAN_OCB_SB_ID);
if (QDF_IS_STATUS_ERROR(status)) {
@ -172,10 +168,8 @@ tgt_ocb_dcc_ndl_update(struct wlan_objmgr_psoc *psoc,
struct ocb_rx_event *event;
event = qdf_mem_malloc(sizeof(*event));
if (!event) {
ocb_err("Memory malloc failed for ndl update response");
if (!event)
return QDF_STATUS_E_NOMEM;
}
status = wlan_objmgr_psoc_try_get_ref(psoc, WLAN_OCB_SB_ID);
if (QDF_IS_STATUS_ERROR(status)) {
@ -234,10 +228,9 @@ tgt_ocb_dcc_stats_indicate(struct wlan_objmgr_psoc *psoc,
size = sizeof(*event) +
response->channel_stats_array_len;
buf = qdf_mem_malloc(size);
if (!buf) {
ocb_err("Memory malloc failed for dcc indication");
if (!buf)
return QDF_STATUS_E_NOMEM;
}
event = (struct ocb_rx_event *)buf;
status = wlan_objmgr_psoc_try_get_ref(psoc, WLAN_OCB_SB_ID);
if (QDF_IS_STATUS_ERROR(status)) {

18
components/p2p/core/src/wlan_p2p_main.c
View File

@ -117,10 +117,8 @@ static QDF_STATUS p2p_psoc_obj_create_notification(
}
p2p_soc_obj = qdf_mem_malloc(sizeof(*p2p_soc_obj));
if (!p2p_soc_obj) {
p2p_err("Failed to allocate p2p soc private object");
if (!p2p_soc_obj)
return QDF_STATUS_E_NOMEM;
}
p2p_soc_obj->soc = soc;
@ -217,10 +215,8 @@ static QDF_STATUS p2p_vdev_obj_create_notification(
p2p_vdev_obj =
qdf_mem_malloc(sizeof(*p2p_vdev_obj));
if (!p2p_vdev_obj) {
p2p_err("Failed to allocate p2p vdev object");
if (!p2p_vdev_obj)
return QDF_STATUS_E_NOMEM;
}
p2p_vdev_obj->vdev = vdev;
p2p_vdev_obj->noa_status = true;
@ -423,10 +419,8 @@ static QDF_STATUS p2p_send_noa_to_pe(struct p2p_noa_info *noa_info)
}
noa_attr = qdf_mem_malloc(sizeof(*noa_attr));
if (!noa_attr) {
p2p_err("Failed to allocate memory for tSirP2PNoaAttr");
if (!noa_attr)
return QDF_STATUS_E_NOMEM;
}
noa_attr->index = noa_info->index;
noa_attr->opps_ps = noa_info->opps_ps;
@ -826,10 +820,9 @@ QDF_STATUS p2p_psoc_start(struct wlan_objmgr_psoc *soc,
}
start_param = qdf_mem_malloc(sizeof(*start_param));
if (!start_param) {
p2p_err("Failed to allocate start params");
if (!start_param)
return QDF_STATUS_E_NOMEM;
}
start_param->rx_cb = req->rx_cb;
start_param->rx_cb_data = req->rx_cb_data;
start_param->event_cb = req->event_cb;
@ -1263,7 +1256,6 @@ QDF_STATUS p2p_process_noa(struct p2p_noa_event *noa_event)
p2p_vdev_obj->noa_info =
qdf_mem_malloc(sizeof(struct p2p_noa_info));
if (!(p2p_vdev_obj->noa_info)) {
p2p_err("Failed to allocate p2p noa info");
status = QDF_STATUS_E_NOMEM;
goto fail;
}

8
components/p2p/core/src/wlan_p2p_off_chan_tx.c
View File

@ -1083,10 +1083,8 @@ static QDF_STATUS p2p_roc_req_for_tx_action(
QDF_STATUS status;
roc_ctx = qdf_mem_malloc(sizeof(struct p2p_roc_context));
if (!roc_ctx) {
p2p_err("Failed to allocate p2p roc context");
if (!roc_ctx)
return QDF_STATUS_E_NOMEM;
}
p2p_soc_obj = tx_ctx->p2p_soc_obj;
roc_ctx->p2p_soc_obj = p2p_soc_obj;
@ -1834,10 +1832,8 @@ QDF_STATUS p2p_cleanup_tx_sync(
p2p_debug("p2p_soc_obj:%pK, vdev:%pK", p2p_soc_obj, vdev);
param = qdf_mem_malloc(sizeof(*param));
if (!param) {
p2p_err("failed to allocate cleanup param");
if (!param)
return QDF_STATUS_E_NOMEM;
}
param->p2p_soc_obj = p2p_soc_obj;
if (vdev)

6
components/p2p/core/src/wlan_p2p_roc.c
View File

@ -93,7 +93,6 @@ static QDF_STATUS p2p_scan_start(struct p2p_roc_context *roc_ctx)
req = qdf_mem_malloc(sizeof(*req));
if (!req) {
p2p_err("failed to alloc scan start request");
status = QDF_STATUS_E_NOMEM;
goto fail;
}
@ -176,7 +175,6 @@ static QDF_STATUS p2p_scan_abort(struct p2p_roc_context *roc_ctx)
req = qdf_mem_malloc(sizeof(*req));
if (!req) {
p2p_err("failed to alloc scan cancel request");
status = QDF_STATUS_E_NOMEM;
goto fail;
}
@ -704,10 +702,8 @@ QDF_STATUS p2p_cleanup_roc_sync(
p2p_debug("p2p_soc_obj:%pK, vdev:%pK", p2p_soc_obj, vdev);
param = qdf_mem_malloc(sizeof(*param));
if (!param) {
p2p_err("failed to allocate cleanup param");
if (!param)
return QDF_STATUS_E_NOMEM;
}
param->p2p_soc_obj = p2p_soc_obj;
if (vdev)

7
components/p2p/dispatcher/src/wlan_p2p_tgt_api.c
View File

@ -107,7 +107,6 @@ QDF_STATUS tgt_p2p_lo_event_cb(struct wlan_objmgr_psoc *psoc,
lo_stop_event = qdf_mem_malloc(sizeof(*lo_stop_event));
if (!lo_stop_event) {
p2p_err("Failed to allocate p2p lo stop event");
qdf_mem_free(event_info);
return QDF_STATUS_E_NOMEM;
}
@ -158,10 +157,8 @@ tgt_p2p_add_mac_addr_status_event_cb(struct wlan_objmgr_psoc *psoc,
}
mac_filter_rsp = qdf_mem_malloc(sizeof(*mac_filter_rsp));
if (!mac_filter_rsp) {
p2p_err("random_mac:Failed to allocate mac_filter_rsp");
if (!mac_filter_rsp)
return QDF_STATUS_E_NOMEM;
}
mac_filter_rsp->p2p_soc_obj = p2p_soc_obj;
mac_filter_rsp->vdev_id = event_info->vdev_id;
@ -259,7 +256,6 @@ QDF_STATUS tgt_p2p_mgmt_ota_comp_cb(void *context, qdf_nbuf_t buf,
tx_conf_event = qdf_mem_malloc(sizeof(*tx_conf_event));
if (!tx_conf_event) {
p2p_err("Failed to allocate tx cnf event");
qdf_nbuf_free(buf);
return QDF_STATUS_E_NOMEM;
}
@ -408,7 +404,6 @@ QDF_STATUS tgt_p2p_noa_event_cb(struct wlan_objmgr_psoc *psoc,
noa_event = qdf_mem_malloc(sizeof(*noa_event));
if (!noa_event) {
p2p_err("Failed to allocate p2p noa event");
qdf_mem_free(event_info);
return QDF_STATUS_E_NOMEM;
}

13
components/p2p/dispatcher/src/wlan_p2p_ucfg_api.c
View File

@ -135,10 +135,8 @@ QDF_STATUS ucfg_p2p_roc_req(struct wlan_objmgr_psoc *soc,
}
roc_ctx = qdf_mem_malloc(sizeof(*roc_ctx));
if (!roc_ctx) {
p2p_err("failed to allocate p2p roc context");
if (!roc_ctx)
return QDF_STATUS_E_NOMEM;
}
status = qdf_idr_alloc(&p2p_soc_obj->p2p_idr, roc_ctx, &id);
if (QDF_IS_STATUS_ERROR(status)) {
@ -344,10 +342,8 @@ QDF_STATUS ucfg_p2p_mgmt_tx(struct wlan_objmgr_psoc *soc,
}
tx_action = qdf_mem_malloc(sizeof(*tx_action));
if (!tx_action) {
p2p_err("Failed to allocate tx action context");
if (!tx_action)
return QDF_STATUS_E_NOMEM;
}
/* return cookie just for ota ack frames */
if (mgmt_frm->dont_wait_for_ack)
@ -373,7 +369,6 @@ QDF_STATUS ucfg_p2p_mgmt_tx(struct wlan_objmgr_psoc *soc,
tx_action->off_chan = mgmt_frm->off_chan;
tx_action->buf = qdf_mem_malloc(tx_action->buf_len);
if (!(tx_action->buf)) {
p2p_err("Failed to allocate buffer for action frame");
qdf_mem_free(tx_action);
return QDF_STATUS_E_NOMEM;
}
@ -436,10 +431,8 @@ QDF_STATUS ucfg_p2p_mgmt_tx_cancel(struct wlan_objmgr_psoc *soc,
p2p_del_random_mac(soc, wlan_vdev_get_id(vdev), cookie, 20);
cancel_tx = qdf_mem_malloc(sizeof(*cancel_tx));
if (!cancel_tx) {
p2p_err("Failed to allocate cancel p2p roc");
if (!cancel_tx)
return QDF_STATUS_E_NOMEM;
}
cancel_tx->p2p_soc_obj = p2p_soc_obj;
cancel_tx->cookie = (uintptr_t)tx_ctx;

8
components/pkt_capture/core/src/wlan_pkt_capture_main.c
View File

@ -254,10 +254,8 @@ pkt_capture_callback_ctx_create(struct pkt_capture_vdev_priv *vdev_priv)
struct pkt_capture_cb_context *cb_ctx;
cb_ctx = qdf_mem_malloc(sizeof(*cb_ctx));
if (!cb_ctx) {
pkt_capture_err("MON context create failed");
if (!cb_ctx)
return QDF_STATUS_E_NOMEM;
}
vdev_priv->cb_ctx = cb_ctx;
@ -290,10 +288,8 @@ pkt_capture_mon_context_create(struct pkt_capture_vdev_priv *vdev_priv)
struct pkt_capture_mon_context *mon_context;
mon_context = qdf_mem_malloc(sizeof(*mon_context));
if (!mon_context) {
pkt_capture_err("MON context create failed");
if (!mon_context)
return QDF_STATUS_E_NOMEM;
}
vdev_priv->mon_ctx = mon_context;

5
components/pkt_capture/core/src/wlan_pkt_capture_mon_thread.c
View File

@ -101,10 +101,9 @@ pkt_capture_alloc_mon_pkt_freeq(struct pkt_capture_mon_context *mon_ctx)
for (i = 0; i < MAX_MON_PKT_SIZE; i++) {
pkt = qdf_mem_malloc(sizeof(*pkt));
if (!pkt) {
pkt_capture_err("mon packet freeq allocation fail");
if (!pkt)
goto free;
}
spin_lock_bh(&mon_ctx->mon_pkt_freeq_lock);
list_add_tail(&pkt->list,
&mon_ctx->mon_pkt_freeq);

1
components/pmo/core/src/wlan_pmo_arp.c
View File

@ -38,7 +38,6 @@ static QDF_STATUS pmo_core_cache_arp_in_vdev_priv(
request = qdf_mem_malloc(sizeof(*request));
if (!request) {
pmo_err("cannot allocate arp request");
status = QDF_STATUS_E_NOMEM;
goto exit_with_status;
}

2
components/pmo/core/src/wlan_pmo_gtk.c
View File

@ -277,7 +277,6 @@ QDF_STATUS pmo_core_enable_gtk_offload_in_fwr(struct wlan_objmgr_vdev *vdev)
op_gtk_req = qdf_mem_malloc(sizeof(*op_gtk_req));
if (!op_gtk_req) {
pmo_err("op_gtk_req is NULL");
status = QDF_STATUS_E_INVAL;
goto dec_ref;
}
@ -313,7 +312,6 @@ QDF_STATUS pmo_core_disable_gtk_offload_in_fwr(struct wlan_objmgr_vdev *vdev)
op_gtk_req = qdf_mem_malloc(sizeof(*op_gtk_req));
if (!op_gtk_req) {
pmo_err("op_gtk_req is NULL");
status = QDF_STATUS_E_NOMEM;
goto dec_ref;
}

6
components/pmo/core/src/wlan_pmo_main.c
View File

@ -39,11 +39,9 @@ QDF_STATUS pmo_allocate_ctx(void)
/* allocate offload mgr ctx */
gp_pmo_ctx = (struct wlan_pmo_ctx *)qdf_mem_malloc(
sizeof(*gp_pmo_ctx));
if (!gp_pmo_ctx) {
pmo_err("unable to allocate pmo_ctx");
QDF_ASSERT(0);
if (!gp_pmo_ctx)
return QDF_STATUS_E_NOMEM;
}
qdf_spinlock_create(&gp_pmo_ctx->lock);
return QDF_STATUS_SUCCESS;

2
components/pmo/core/src/wlan_pmo_mc_addr_filtering.c
View File

@ -430,7 +430,6 @@ static QDF_STATUS pmo_core_handle_enable_mc_list_trigger(
op_mc_list_req = qdf_mem_malloc(sizeof(*op_mc_list_req));
if (!op_mc_list_req) {
pmo_err("op_mc_list_req is NULL");
status = QDF_STATUS_E_NOMEM;
goto exit_with_status;
}
@ -526,7 +525,6 @@ static QDF_STATUS pmo_core_handle_disable_mc_list_trigger(
op_mc_list_req = qdf_mem_malloc(sizeof(*op_mc_list_req));
if (!op_mc_list_req) {
pmo_err("out of memory");
status = QDF_STATUS_E_NOMEM;
goto out;
}

2
components/pmo/dispatcher/src/wlan_pmo_obj_mgmt_api.c
View File

@ -158,7 +158,6 @@ QDF_STATUS pmo_psoc_object_created_notification(
psoc_ctx = qdf_mem_malloc(sizeof(*psoc_ctx));
if (!psoc_ctx) {
pmo_err("Failed to allocate pmo_psoc");
status = QDF_STATUS_E_NOMEM;
goto out;
}
@ -244,7 +243,6 @@ QDF_STATUS pmo_vdev_object_created_notification(
vdev_ctx = qdf_mem_malloc(sizeof(*vdev_ctx));
if (!vdev_ctx) {
pmo_err("Failed to allocate vdev_ctx");
status = QDF_STATUS_E_NOMEM;
goto out;
}

4
components/pmo/dispatcher/src/wlan_pmo_tgt_arp.c
View File

@ -42,14 +42,12 @@ QDF_STATUS pmo_tgt_enable_arp_offload_req(struct wlan_objmgr_vdev *vdev,
arp_offload_req = qdf_mem_malloc(sizeof(*arp_offload_req));
if (!arp_offload_req) {
pmo_err("unable to allocate arp_offload_req");
status = QDF_STATUS_E_NOMEM;
goto out;
}
ns_offload_req = qdf_mem_malloc(sizeof(*ns_offload_req));
if (!ns_offload_req) {
pmo_err("unable to allocate ns_offload_req");
status = QDF_STATUS_E_NOMEM;
goto out;
}
@ -112,14 +110,12 @@ QDF_STATUS pmo_tgt_disable_arp_offload_req(struct wlan_objmgr_vdev *vdev,
arp_offload_req = qdf_mem_malloc(sizeof(*arp_offload_req));
if (!arp_offload_req) {
pmo_err("unable to allocate arp_offload_req");
status = QDF_STATUS_E_NOMEM;
goto out;
}
ns_offload_req = qdf_mem_malloc(sizeof(*ns_offload_req));
if (!ns_offload_req) {
pmo_err("unable to allocate ns_offload_req");
status = QDF_STATUS_E_NOMEM;
goto out;
}

3
components/pmo/dispatcher/src/wlan_pmo_tgt_gtk.c
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2017-2019 The Linux Foundation. All rights reserved.
* Copyright (c) 2017-2020 The Linux Foundation. All rights reserved.
*
* Permission to use, copy, modify, and/or distribute this software for
* any purpose with or without fee is hereby granted, provided that the
@ -55,7 +55,6 @@ QDF_STATUS pmo_tgt_send_gtk_offload_req(struct wlan_objmgr_vdev *vdev,
op_gtk_req = qdf_mem_malloc(sizeof(*op_gtk_req));
if (!op_gtk_req) {
pmo_err("cannot allocate op_gtk_req ");
status = QDF_STATUS_E_NOMEM;
goto out;
}

4
components/pmo/dispatcher/src/wlan_pmo_tgt_ns.c
View File

@ -43,14 +43,12 @@ QDF_STATUS pmo_tgt_enable_ns_offload_req(struct wlan_objmgr_vdev *vdev,
arp_offload_req = qdf_mem_malloc(sizeof(*arp_offload_req));
if (!arp_offload_req) {
pmo_err("unable to allocate arp_offload_req");
status = QDF_STATUS_E_NOMEM;
goto out;
}
ns_offload_req = qdf_mem_malloc(sizeof(*ns_offload_req));
if (!ns_offload_req) {
pmo_err("unable to allocate ns_offload_req");
status = QDF_STATUS_E_NOMEM;
goto out;
}
@ -114,14 +112,12 @@ QDF_STATUS pmo_tgt_disable_ns_offload_req(struct wlan_objmgr_vdev *vdev,
arp_offload_req = qdf_mem_malloc(sizeof(*arp_offload_req));
if (!arp_offload_req) {
pmo_err("unable to allocate arp_offload_req");
status = QDF_STATUS_E_NOMEM;
goto out;
}
ns_offload_req = qdf_mem_malloc(sizeof(*ns_offload_req));
if (!ns_offload_req) {
pmo_err("unable to allocate ns_offload_req");
status = QDF_STATUS_E_NOMEM;
goto out;
}

6
components/pmo/dispatcher/src/wlan_pmo_tgt_pkt_filter.c
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2017-2019 The Linux Foundation. All rights reserved.
* Copyright (c) 2017-2020 The Linux Foundation. All rights reserved.
*
* Permission to use, copy, modify, and/or distribute this software for
* any purpose with or without fee is hereby granted, provided that the
@ -49,9 +49,7 @@ QDF_STATUS pmo_tgt_set_pkt_filter(struct wlan_objmgr_vdev *vdev,
pmo_set_pkt_fltr_req->filter_id);
request_buf = qdf_mem_malloc(sizeof(*request_buf));
if (!request_buf) {
pmo_err("Not able to allocate memory for Receive Filter Set Filter request");
status = QDF_STATUS_E_NOMEM;
goto out;
}
@ -113,9 +111,7 @@ QDF_STATUS pmo_tgt_clear_pkt_filter(struct wlan_objmgr_vdev *vdev,
pmo_debug("filter_id = %d", pmo_clr_pkt_fltr_param->filter_id);
request_buf = qdf_mem_malloc(sizeof(*request_buf));
if (!request_buf) {
pmo_err("Not able to allocate memory for Receive Filter Set Filter request");
status = QDF_STATUS_E_NOMEM;
goto out;
}

33
components/target_if/nan/src/target_if_nan.c
View File

@ -285,10 +285,8 @@ static int target_if_ndp_initiator_rsp_handler(ol_scn_t scn, uint8_t *data,
}
rsp = qdf_mem_malloc(sizeof(*rsp));
if (!rsp) {
target_if_err("malloc failed");
if (!rsp)
return -ENOMEM;
}
status = wmi_extract_ndp_initiator_rsp(wmi_handle, data, rsp);
if (QDF_IS_STATUS_ERROR(status)) {
@ -335,10 +333,8 @@ static int target_if_ndp_ind_handler(ol_scn_t scn, uint8_t *data,
}
rsp = qdf_mem_malloc(sizeof(*rsp));
if (!rsp) {
target_if_err("malloc failed");
if (!rsp)
return -ENOMEM;
}
status = wmi_extract_ndp_ind(wmi_handle, data, rsp);
if (QDF_IS_STATUS_ERROR(status)) {
@ -385,10 +381,8 @@ static int target_if_ndp_confirm_handler(ol_scn_t scn, uint8_t *data,
}
rsp = qdf_mem_malloc(sizeof(*rsp));
if (!rsp) {
target_if_err("malloc failed");
if (!rsp)
return -ENOMEM;
}
status = wmi_extract_ndp_confirm(wmi_handle, data, rsp);
if (QDF_IS_STATUS_ERROR(status)) {
@ -484,10 +478,8 @@ static int target_if_ndp_responder_rsp_handler(ol_scn_t scn, uint8_t *data,
}
rsp = qdf_mem_malloc(sizeof(*rsp));
if (!rsp) {
target_if_err("malloc failed");
if (!rsp)
return -ENOMEM;
}
status = wmi_extract_ndp_responder_rsp(wmi_handle, data, rsp);
if (QDF_IS_STATUS_ERROR(status)) {
@ -583,10 +575,8 @@ static int target_if_ndp_end_rsp_handler(ol_scn_t scn, uint8_t *data,
}
end_rsp = qdf_mem_malloc(sizeof(*end_rsp));
if (!end_rsp) {
target_if_err("malloc failed");
if (!end_rsp)
return -ENOMEM;
}
status = wmi_extract_ndp_end_rsp(wmi_handle, data, end_rsp);
if (QDF_IS_STATUS_ERROR(status)) {
@ -684,10 +674,8 @@ static int target_if_ndp_sch_update_handler(ol_scn_t scn, uint8_t *data,
}
rsp = qdf_mem_malloc(sizeof(*rsp));
if (!rsp) {
target_if_err("malloc failed");
if (!rsp)
return -ENOMEM;
}
status = wmi_extract_ndp_sch_update(wmi_handle, data, rsp);
if (QDF_IS_STATUS_ERROR(status)) {
@ -763,10 +751,8 @@ static int target_if_ndp_host_event_handler(ol_scn_t scn, uint8_t *data,
}
host_evt = qdf_mem_malloc(sizeof(*host_evt));
if (!host_evt) {
target_if_err("malloc failed");
if (!host_evt)
return -ENOMEM;
}
status = wmi_extract_ndp_host_event(wmi_handle, data, host_evt);
if (QDF_IS_STATUS_ERROR(status)) {
@ -947,10 +933,9 @@ int target_if_nan_rsp_handler(ol_scn_t scn, uint8_t *data, uint32_t len)
}
nan_rsp = qdf_mem_malloc(sizeof(*nan_rsp) + temp_evt_params.buf_len);
if (!nan_rsp) {
target_if_err("malloc failed");
if (!nan_rsp)
return -ENOMEM;
}
qdf_mem_copy(nan_rsp, &temp_evt_params, sizeof(*nan_rsp));
status = wlan_objmgr_psoc_try_get_ref(psoc, WLAN_NAN_ID);

3
components/target_if/ocb/src/target_if_ocb.c
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2018 The Linux Foundation. All rights reserved.
* Copyright (c) 2018, 2020 The Linux Foundation. All rights reserved.
*
* Permission to use, copy, modify, and/or distribute this software for
* any purpose with or without fee is hereby granted, provided that the
@ -395,7 +395,6 @@ static int target_if_dcc_update_ndl_resp(ol_scn_t scn,
/* Allocate and populate the response */
resp = qdf_mem_malloc(sizeof(*resp));
if (!resp) {
target_if_err("Error allocating memory for the response.");
rc = -ENOMEM;
goto exit;
}

8
components/target_if/p2p/src/target_if_p2p.c
View File

@ -85,10 +85,8 @@ static int target_p2p_lo_event_handler(ol_scn_t scn, uint8_t *data,
}
event_info = qdf_mem_malloc(sizeof(*event_info));
if (!event_info) {
target_if_err("Failed to allocate p2p lo event");
if (!event_info)
return -ENOMEM;
}
if (wmi_extract_p2p_lo_stop_ev_param(wmi_handle, data,
event_info)) {
@ -235,10 +233,8 @@ static int target_p2p_noa_event_handler(ol_scn_t scn, uint8_t *data,
}
event_info = qdf_mem_malloc(sizeof(*event_info));
if (!event_info) {
target_if_err("failed to allocate p2p noa information");
if (!event_info)
return -ENOMEM;
}
if (wmi_extract_p2p_noa_ev_param(wmi_handle, data,
event_info)) {

3
components/target_if/pmo/src/target_if_pmo_gtk.c
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2017-2018 The Linux Foundation. All rights reserved.
* Copyright (c) 2017-2018, 2020 The Linux Foundation. All rights reserved.
*
* Permission to use, copy, modify, and/or distribute this software for
* any purpose with or without fee is hereby granted, provided that the
@ -123,7 +123,6 @@ int target_if_pmo_gtk_offload_status_event(void *scn_handle,
gtk_rsp_param = qdf_mem_malloc(sizeof(*gtk_rsp_param));
if (!gtk_rsp_param) {
target_if_err("memory allocation failed");
ret = -ENOMEM;
goto out;
}

2
components/target_if/pmo/src/target_if_pmo_lphb.c
View File

@ -258,9 +258,7 @@ QDF_STATUS target_if_pmo_lphb_evt_handler(struct wlan_objmgr_psoc *psoc,
slphb_indication = (struct pmo_lphb_rsp *)qdf_mem_malloc(
sizeof(struct pmo_lphb_rsp));
if (!slphb_indication) {
target_if_err("Invalid LPHB indication buffer");
qdf_status = QDF_STATUS_E_NOMEM;
goto out;
}

21
components/tdls/core/src/wlan_tdls_cmds_process.c
View File

@ -135,10 +135,9 @@ static QDF_STATUS tdls_pe_add_peer(struct tdls_add_peer_request *req)
QDF_STATUS status;
addstareq = qdf_mem_malloc(sizeof(*addstareq));
if (!addstareq) {
tdls_err("allocate failed");
if (!addstareq)
return QDF_STATUS_E_NOMEM;
}
vdev = req->vdev;
soc_obj = wlan_vdev_get_tdls_soc_obj(vdev);
if (!soc_obj) {
@ -198,10 +197,9 @@ QDF_STATUS tdls_pe_del_peer(struct tdls_del_peer_request *req)
QDF_STATUS status;
delstareq = qdf_mem_malloc(sizeof(*delstareq));
if (!delstareq) {
tdls_err("allocate failed");
if (!delstareq)
return QDF_STATUS_E_NOMEM;
}
vdev = req->vdev;
soc_obj = wlan_vdev_get_tdls_soc_obj(vdev);
if (!soc_obj) {
@ -262,10 +260,9 @@ static QDF_STATUS tdls_pe_update_peer(struct tdls_update_peer_request *req)
QDF_STATUS status;
addstareq = qdf_mem_malloc(sizeof(*addstareq));
if (!addstareq) {
tdls_err("allocate failed");
if (!addstareq)
return QDF_STATUS_E_NOMEM;
}
vdev = req->vdev;
soc_obj = wlan_vdev_get_tdls_soc_obj(vdev);
if (!soc_obj) {
@ -1630,7 +1627,6 @@ QDF_STATUS tdls_process_enable_link(struct tdls_oper_request *req)
peer_update_param = qdf_mem_malloc(sizeof(*peer_update_param));
if (!peer_update_param) {
tdls_err("memory allocation failed");
status = QDF_STATUS_E_NOMEM;
goto error;
}
@ -1721,10 +1717,8 @@ static QDF_STATUS tdls_config_force_peer(
}
peer_update_param = qdf_mem_malloc(sizeof(*peer_update_param));
if (!peer_update_param) {
tdls_err("memory allocation failed");
if (!peer_update_param)
return QDF_STATUS_E_NOMEM;
}
peer = tdls_get_peer(vdev_obj, macaddr);
if (!peer) {
@ -1904,7 +1898,6 @@ QDF_STATUS tdls_process_remove_force_peer(struct tdls_oper_request *req)
tdls_set_callback(peer, NULL);
peer_update_param = qdf_mem_malloc(sizeof(*peer_update_param));
if (!peer_update_param) {
tdls_err("memory allocation failed");
status = QDF_STATUS_E_NOMEM;
goto error;
}

1
components/tdls/core/src/wlan_tdls_ct.c
View File

@ -1185,7 +1185,6 @@ QDF_STATUS tdls_delete_all_tdls_peers(struct wlan_objmgr_vdev *vdev,
del_msg = qdf_mem_malloc(sizeof(*del_msg));
if (!del_msg) {
tdls_err("memory alloc failed");
wlan_objmgr_peer_release_ref(peer, WLAN_TDLS_SB_ID);
return QDF_STATUS_E_FAILURE;
}

19
components/tdls/core/src/wlan_tdls_main.c
View File

@ -138,10 +138,8 @@ QDF_STATUS tdls_psoc_obj_create_notification(struct wlan_objmgr_psoc *psoc,
struct tdls_soc_priv_obj *tdls_soc_obj;
tdls_soc_obj = qdf_mem_malloc(sizeof(*tdls_soc_obj));
if (!tdls_soc_obj) {
tdls_err("Failed to allocate memory for tdls object");
if (!tdls_soc_obj)
return QDF_STATUS_E_NOMEM;
}
tdls_soc_obj->soc = psoc;
@ -272,7 +270,6 @@ QDF_STATUS tdls_vdev_obj_create_notification(struct wlan_objmgr_vdev *vdev,
tdls_vdev_obj = qdf_mem_malloc(sizeof(*tdls_vdev_obj));
if (!tdls_vdev_obj) {
tdls_err("Failed to allocate memory for tdls vdev object");
status = QDF_STATUS_E_NOMEM;
goto err;
}
@ -1122,12 +1119,8 @@ void tdls_send_update_to_fw(struct tdls_vdev_priv_obj *tdls_vdev_obj,
}
tdls_info_to_fw = qdf_mem_malloc(sizeof(struct tdls_info));
if (!tdls_info_to_fw) {
tdls_err("memory allocation failed for tdlsParams");
QDF_ASSERT(0);
if (!tdls_info_to_fw)
return;
}
threshold_params = &tdls_vdev_obj->threshold_config;
@ -1371,10 +1364,8 @@ QDF_STATUS tdls_peers_deleted_notification(struct wlan_objmgr_psoc *psoc,
struct wlan_objmgr_vdev *vdev;
notify = qdf_mem_malloc(sizeof(*notify));
if (!notify) {
tdls_err("memory allocation failed !!!");
if (!notify)
return QDF_STATUS_E_NULL_VALUE;
}
vdev = wlan_objmgr_get_vdev_by_id_from_psoc(psoc,
vdev_id,
@ -1422,10 +1413,8 @@ QDF_STATUS tdls_delete_all_peers_indication(struct wlan_objmgr_psoc *psoc,
struct wlan_objmgr_vdev *vdev;
indication = qdf_mem_malloc(sizeof(*indication));
if (!indication) {
tdls_err("memory allocation failed !!!");
if (!indication)
return QDF_STATUS_E_NULL_VALUE;
}
vdev = wlan_objmgr_get_vdev_by_id_from_psoc(psoc,
vdev_id,

2
components/tdls/core/src/wlan_tdls_mgmt.c
View File

@ -254,8 +254,6 @@ static QDF_STATUS tdls_activate_send_mgmt_request(
action_req->tdls_mgmt.len);
if (!tdls_mgmt_req) {
status = QDF_STATUS_E_NOMEM;
tdls_err("mem alloc failed ");
QDF_ASSERT(0);
goto release_cmd;
}

4
components/tdls/core/src/wlan_tdls_peer.c
View File

@ -165,10 +165,8 @@ static struct tdls_peer *tdls_add_peer(struct tdls_vdev_priv_obj *vdev_obj,
uint8_t reg_bw_offset;
peer = qdf_mem_malloc(sizeof(*peer));
if (!peer) {
tdls_err("add tdls peer malloc memory failed!");
if (!peer)
return NULL;
}
soc_obj = wlan_vdev_get_tdls_soc_obj(vdev_obj->vdev);
if (!soc_obj) {

8
components/tdls/dispatcher/src/wlan_tdls_tgt_api.c
View File

@ -188,10 +188,8 @@ tgt_tdls_event_handler(struct wlan_objmgr_psoc *psoc,
info->vdev_id, info->message_type, info->peer_reason,
QDF_MAC_ADDR_REF(info->peermac.bytes));
notify = qdf_mem_malloc(sizeof(*notify));
if (!notify) {
tdls_err("mem allocate fail");
if (!notify)
return QDF_STATUS_E_NOMEM;
}
vdev_id = info->vdev_id;
notify->vdev =
@ -278,10 +276,8 @@ QDF_STATUS tgt_tdls_mgmt_frame_process_rx_cb(
}
rx_mgmt_event = qdf_mem_malloc_atomic(sizeof(*rx_mgmt_event));
if (!rx_mgmt_event) {
tdls_debug_rl("Failed to allocate rx mgmt event");
if (!rx_mgmt_event)
return QDF_STATUS_E_NOMEM;
}
rx_mgmt = qdf_mem_malloc_atomic(sizeof(*rx_mgmt) +
mgmt_rx_params->buf_len);

35
components/tdls/dispatcher/src/wlan_tdls_ucfg_api.c
View File

@ -557,7 +557,6 @@ QDF_STATUS ucfg_tdls_add_peer(struct wlan_objmgr_vdev *vdev,
req = qdf_mem_malloc(sizeof(*req));
if (!req) {
tdls_err("mem allocate fail");
status = QDF_STATUS_E_NOMEM;
goto dec_ref;
}
@ -605,7 +604,6 @@ QDF_STATUS ucfg_tdls_update_peer(struct wlan_objmgr_vdev *vdev,
}
req = qdf_mem_malloc(sizeof(*req));
if (!req) {
tdls_err("mem allocate fail");
status = QDF_STATUS_E_NOMEM;
goto dec_ref;
}
@ -664,10 +662,8 @@ QDF_STATUS ucfg_tdls_oper(struct wlan_objmgr_vdev *vdev,
QDF_MAC_ADDR_REF(macaddr));
req = qdf_mem_malloc(sizeof(*req));
if (!req) {
tdls_err("%s: mem allocate fail", tdls_get_oper_str(cmd));
if (!req)
return QDF_STATUS_E_NOMEM;
}
status = wlan_objmgr_vdev_try_get_ref(vdev, WLAN_TDLS_NB_ID);
if (QDF_IS_STATUS_ERROR(status)) {
@ -706,11 +702,8 @@ QDF_STATUS ucfg_tdls_get_all_peers(struct wlan_objmgr_vdev *vdev,
QDF_STATUS status;
tdls_peers = qdf_mem_malloc(sizeof(*tdls_peers));
if (!tdls_peers) {
tdls_err("mem allocate fail");
if (!tdls_peers)
return QDF_STATUS_E_NOMEM;
}
tdls_peers->vdev = vdev;
tdls_peers->buf_len = buflen;
@ -759,10 +752,8 @@ QDF_STATUS ucfg_tdls_send_mgmt_frame(
mgmt_req = qdf_mem_malloc(sizeof(*mgmt_req) +
req->len);
if (!mgmt_req) {
tdls_err("mem allocate fail");
if (!mgmt_req)
return QDF_STATUS_E_NOMEM;
}
qdf_mem_copy(mgmt_req, req, sizeof(*req));
@ -966,10 +957,8 @@ QDF_STATUS ucfg_tdls_set_operating_mode(
tdls_debug("Enter ");
set_mode = qdf_mem_malloc(sizeof(*set_mode));
if (!set_mode) {
tdls_err("memory allocate fail");
if (!set_mode)
return QDF_STATUS_E_NULL_VALUE;
}
status = wlan_objmgr_vdev_try_get_ref(set_mode->vdev, WLAN_TDLS_NB_ID);
if (QDF_IS_STATUS_ERROR(status)) {
@ -1022,10 +1011,8 @@ QDF_STATUS ucfg_tdls_antenna_switch(struct wlan_objmgr_vdev *vdev,
struct scheduler_msg msg = {0, };
req = qdf_mem_malloc(sizeof(*req));
if (!req) {
tdls_err("mem allocate fail");
if (!req)
return QDF_STATUS_E_NOMEM;
}
status = wlan_objmgr_vdev_try_get_ref(vdev, WLAN_TDLS_NB_ID);
if (QDF_IS_STATUS_ERROR(status)) {
@ -1065,10 +1052,8 @@ QDF_STATUS ucfg_set_tdls_offchannel(struct wlan_objmgr_vdev *vdev,
struct tdls_set_offchannel *req;
req = qdf_mem_malloc(sizeof(*req));
if (!req) {
tdls_err("mem allocate fail");
if (!req)
return QDF_STATUS_E_NOMEM;
}
status = wlan_objmgr_vdev_try_get_ref(vdev, WLAN_TDLS_NB_ID);
if (QDF_IS_STATUS_ERROR(status)) {
@ -1108,10 +1093,8 @@ QDF_STATUS ucfg_set_tdls_offchan_mode(struct wlan_objmgr_vdev *vdev,
struct tdls_set_offchanmode *req;
req = qdf_mem_malloc(sizeof(*req));
if (!req) {
tdls_err("mem allocate fail");
if (!req)
return QDF_STATUS_E_NOMEM;
}
status = wlan_objmgr_vdev_try_get_ref(vdev, WLAN_TDLS_NB_ID);
if (QDF_IS_STATUS_ERROR(status)) {
@ -1151,10 +1134,8 @@ QDF_STATUS ucfg_set_tdls_secoffchanneloffset(struct wlan_objmgr_vdev *vdev,
struct tdls_set_secoffchanneloffset *req;
req = qdf_mem_malloc(sizeof(*req));
if (!req) {
tdls_err("mem allocate fail");
if (!req)
return QDF_STATUS_E_NOMEM;
}
status = wlan_objmgr_vdev_try_get_ref(vdev, WLAN_TDLS_NB_ID);
if (QDF_IS_STATUS_ERROR(status)) {