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

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

components/dsc/src/wlan_dsc_driver.c

@@ -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();
 }
 
-void dsc_driver_trans_assert(struct dsc_driver *driver)
+static void __dsc_driver_trans_assert(struct dsc_driver *driver)
 {
-	dsc_enter();
+	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_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);
+
+	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 __dsc_ops_insert(&driver->ops, func);
+	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();
 }
 

components/dsc/src/wlan_dsc_psoc.c

@@ -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();
 }
 
-void dsc_psoc_trans_assert(struct dsc_psoc *psoc)
+static void __dsc_psoc_trans_assert(struct dsc_psoc *psoc)
 {
-	dsc_enter();
+	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_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);
+
+	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 __dsc_ops_insert(&psoc->ops, func);
+	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();
 }
 

components/dsc/src/wlan_dsc_vdev.c

@@ -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();
 }
 
-void dsc_vdev_trans_assert(struct dsc_vdev *vdev)
+static void __dsc_vdev_trans_assert(struct dsc_vdev *vdev)
 {
-	dsc_enter();
+	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_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);
+
+	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 __dsc_ops_insert(&vdev->ops, func);
+	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();
 }