samsung-sm8650/android_kernel_samsung_sm8650-modules
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

qcacld-3.0: Check for null before taking the DSC lock

Browse Source 
Ic3121092c71d5c46e8521a775281ad2c45e3fe7d changed the driver-level DSC
context allocation method from static to dynamic. As a side effect, the
DSC driver lock needed a driver instance pointer instead of grabbing the
global context. However, many of the lock calls were updated to use the
input context pointer before it was validated.

Ensure the input context pointers are validated before using them to
grab the DSC driver lock.

Change-Id: Ifce2d603f3e9b7b7c0869a40f8632988a9509809
CRs-Fixed: 2327110
This commit is contained in:
Dustin Brown
2018-10-03 13:21:38 -07:00
committed by nshrivas
parent 728d65a2de
commit 627c43b823
3 changed files with 93 additions and 39 deletions
Download Patch File Download Diff File Expand all files Collapse all files

44
components/dsc/src/wlan_dsc_driver.c
View File

@@ -252,43 +252,63 @@ static void __dsc_driver_trans_stop(struct dsc_driver *driver)
if (!dsc_assert(driver))
return;
__dsc_lock(driver);
dsc_assert(driver->trans.active_desc);
driver->trans.active_desc = NULL;
__dsc_driver_trigger_trans(driver);
__dsc_unlock(driver);
}
void dsc_driver_trans_stop(struct dsc_driver *driver)
{
dsc_enter();
__dsc_lock(driver);
__dsc_driver_trans_stop(driver);
__dsc_unlock(driver);
dsc_exit();
}
static void __dsc_driver_trans_assert(struct dsc_driver *driver)
{
if (!dsc_assert(driver))
return;
__dsc_lock(driver);
dsc_assert(driver->trans.active_desc);
__dsc_unlock(driver);
}
void dsc_driver_trans_assert(struct dsc_driver *driver)
{
dsc_enter();
__dsc_lock(driver);
dsc_assert(driver->trans.active_desc);
__dsc_unlock(driver);
__dsc_driver_trans_assert(driver);
dsc_exit();
}
static QDF_STATUS
__dsc_driver_op_start(struct dsc_driver *driver, const char *func)
{
QDF_STATUS status;
if (!dsc_assert(driver))
return QDF_STATUS_E_INVAL;
if (!dsc_assert(func))
return QDF_STATUS_E_INVAL;
if (!__dsc_driver_can_op(driver))
return QDF_STATUS_E_AGAIN;
__dsc_lock(driver);
return __dsc_ops_insert(&driver->ops, func);
if (!__dsc_driver_can_op(driver)) {
status = QDF_STATUS_E_AGAIN;
goto unlock;
}
status = __dsc_ops_insert(&driver->ops, func);
unlock:
__dsc_unlock(driver);
return status;
}
QDF_STATUS _dsc_driver_op_start(struct dsc_driver *driver, const char *func)
@@ -296,9 +316,7 @@ QDF_STATUS _dsc_driver_op_start(struct dsc_driver *driver, const char *func)
QDF_STATUS status;
dsc_enter_str(func);
__dsc_lock(driver);
status = __dsc_driver_op_start(driver, func);
__dsc_unlock(driver);
dsc_exit_status(status);
return status;
@@ -312,16 +330,16 @@ static void __dsc_driver_op_stop(struct dsc_driver *driver, const char *func)
if (!dsc_assert(func))
return;
__dsc_lock(driver);
if (__dsc_ops_remove(&driver->ops, func))
qdf_event_set(&driver->ops.event);
__dsc_unlock(driver);
}
void _dsc_driver_op_stop(struct dsc_driver *driver, const char *func)
{
dsc_enter_str(func);
__dsc_lock(driver);
__dsc_driver_op_stop(driver, func);
__dsc_unlock(driver);
dsc_exit();
}

44
components/dsc/src/wlan_dsc_psoc.c
View File

@@ -241,27 +241,36 @@ static void __dsc_psoc_trans_stop(struct dsc_psoc *psoc)
if (!dsc_assert(psoc))
return;
__dsc_driver_lock(psoc);
dsc_assert(psoc->trans.active_desc);
psoc->trans.active_desc = NULL;
__dsc_psoc_trigger_trans(psoc);
__dsc_driver_unlock(psoc);
}
void dsc_psoc_trans_stop(struct dsc_psoc *psoc)
{
dsc_enter();
__dsc_driver_lock(psoc);
__dsc_psoc_trans_stop(psoc);
__dsc_driver_unlock(psoc);
dsc_exit();
}
static void __dsc_psoc_trans_assert(struct dsc_psoc *psoc)
{
if (!dsc_assert(psoc))
return;
__dsc_driver_lock(psoc);
dsc_assert(psoc->trans.active_desc);
__dsc_driver_unlock(psoc);
}
void dsc_psoc_trans_assert(struct dsc_psoc *psoc)
{
dsc_enter();
__dsc_driver_lock(psoc);
dsc_assert(psoc->trans.active_desc);
__dsc_driver_unlock(psoc);
__dsc_psoc_trans_assert(psoc);
dsc_exit();
}
@@ -279,16 +288,27 @@ bool __dsc_psoc_trans_trigger_checked(struct dsc_psoc *psoc)
static QDF_STATUS __dsc_psoc_op_start(struct dsc_psoc *psoc, const char *func)
{
QDF_STATUS status;
if (!dsc_assert(psoc))
return QDF_STATUS_E_INVAL;
if (!dsc_assert(func))
return QDF_STATUS_E_INVAL;
if (!__dsc_psoc_can_op(psoc))
return QDF_STATUS_E_AGAIN;
__dsc_driver_lock(psoc);
return __dsc_ops_insert(&psoc->ops, func);
if (!__dsc_psoc_can_op(psoc)) {
status = QDF_STATUS_E_AGAIN;
goto unlock;
}
status = __dsc_ops_insert(&psoc->ops, func);
unlock:
__dsc_driver_unlock(psoc);
return status;
}
QDF_STATUS _dsc_psoc_op_start(struct dsc_psoc *psoc, const char *func)
@@ -296,9 +316,7 @@ QDF_STATUS _dsc_psoc_op_start(struct dsc_psoc *psoc, const char *func)
QDF_STATUS status;
dsc_enter_str(func);
__dsc_driver_lock(psoc);
status = __dsc_psoc_op_start(psoc, func);
__dsc_driver_unlock(psoc);
dsc_exit_status(status);
return status;
@@ -312,16 +330,16 @@ static void __dsc_psoc_op_stop(struct dsc_psoc *psoc, const char *func)
if (!dsc_assert(func))
return;
__dsc_driver_lock(psoc);
if (__dsc_ops_remove(&psoc->ops, func))
qdf_event_set(&psoc->ops.event);
__dsc_driver_unlock(psoc);
}
void _dsc_psoc_op_stop(struct dsc_psoc *psoc, const char *func)
{
dsc_enter_str(func);
__dsc_driver_lock(psoc);
__dsc_psoc_op_stop(psoc, func);
__dsc_driver_unlock(psoc);
dsc_exit();
}

44
components/dsc/src/wlan_dsc_vdev.c
View File

@@ -212,42 +212,62 @@ static void __dsc_vdev_trans_stop(struct dsc_vdev *vdev)
if (!dsc_assert(vdev))
return;
__dsc_driver_lock(vdev);
dsc_assert(vdev->trans.active_desc);
vdev->trans.active_desc = NULL;
__dsc_vdev_trigger_trans(vdev);
__dsc_driver_unlock(vdev);
}
void dsc_vdev_trans_stop(struct dsc_vdev *vdev)
{
dsc_enter();
__dsc_driver_lock(vdev);
__dsc_vdev_trans_stop(vdev);
__dsc_driver_unlock(vdev);
dsc_exit();
}
static void __dsc_vdev_trans_assert(struct dsc_vdev *vdev)
{
if (!dsc_assert(vdev))
return;
__dsc_driver_lock(vdev);
dsc_assert(vdev->trans.active_desc);
__dsc_driver_unlock(vdev);
}
void dsc_vdev_trans_assert(struct dsc_vdev *vdev)
{
dsc_enter();
__dsc_driver_lock(vdev);
dsc_assert(vdev->trans.active_desc);
__dsc_driver_unlock(vdev);
__dsc_vdev_trans_assert(vdev);
dsc_exit();
}
static QDF_STATUS __dsc_vdev_op_start(struct dsc_vdev *vdev, const char *func)
{
QDF_STATUS status;
if (!dsc_assert(vdev))
return QDF_STATUS_E_INVAL;
if (!dsc_assert(func))
return QDF_STATUS_E_INVAL;
if (!__dsc_vdev_can_op(vdev))
return QDF_STATUS_E_AGAIN;
__dsc_driver_lock(vdev);
return __dsc_ops_insert(&vdev->ops, func);
if (!__dsc_vdev_can_op(vdev)) {
status = QDF_STATUS_E_AGAIN;
goto unlock;
}
status = __dsc_ops_insert(&vdev->ops, func);
unlock:
__dsc_driver_unlock(vdev);
return status;
}
QDF_STATUS _dsc_vdev_op_start(struct dsc_vdev *vdev, const char *func)
@@ -255,9 +275,7 @@ QDF_STATUS _dsc_vdev_op_start(struct dsc_vdev *vdev, const char *func)
QDF_STATUS status;
dsc_enter_str(func);
__dsc_driver_lock(vdev);
status = __dsc_vdev_op_start(vdev, func);
__dsc_driver_unlock(vdev);
dsc_exit_status(status);
return status;
@@ -271,16 +289,16 @@ static void __dsc_vdev_op_stop(struct dsc_vdev *vdev, const char *func)
if (!dsc_assert(func))
return;
__dsc_driver_lock(vdev);
if (__dsc_ops_remove(&vdev->ops, func))
qdf_event_set(&vdev->ops.event);
__dsc_driver_unlock(vdev);
}
void _dsc_vdev_op_stop(struct dsc_vdev *vdev, const char *func)
{
dsc_enter_str(func);
__dsc_driver_lock(vdev);
__dsc_vdev_op_stop(vdev, func);
__dsc_driver_unlock(vdev);
dsc_exit();
}