[PATCH v5 04/28] ALSA: compress: Set the draining state before the drain trigger

[Peter Ujfalusi <peter.ujfalusi@linux.intel.com>]

The state of the stream is set to SNDRV_PCM_STATE_DRAINING only after the
drain trigger has been sent to the driver.

Drivers can not block in the trigger callback and the drain is completed
asynchronously: snd_compr_drain_notify() can be called either from the
trigger callback itself or from a different context as soon as the
trigger returns. If that happens before the core updates the state then
the notification is lost: the state is overwritten with DRAINING right
after it and the wait for the drain to complete will not be woken up.

Set the state before the trigger is issued and restore it if the trigger
fails. The partial_drain flag is cleared on the error path as well as it
would otherwise be left set for the next drain.

Signed-off-by: Peter Ujfalusi <peter.ujfalusi@linux.intel.com>
---
 sound/core/compress_offload.c | 24 +++++++++++++++++++++++-
 1 file changed, 23 insertions(+), 1 deletion(-)

diff --git a/sound/core/compress_offload.c b/sound/core/compress_offload.c
index 89435e4394ef..5c0db178d635 100644
--- a/sound/core/compress_offload.c
+++ b/sound/core/compress_offload.c
@@ -947,8 +947,10 @@ static int snd_compress_wait_for_drain(struct snd_compr_stream *stream)
 	 * It is expected that driver will notify the drain completion and then
 	 * stream will be moved to SETUP state, even if draining resulted in an
 	 * error. We can trigger next track after this.
+	 *
+	 * The state has been set to SNDRV_PCM_STATE_DRAINING by the caller,
+	 * before the drain trigger was issued.
 	 */
-	stream->runtime->state = SNDRV_PCM_STATE_DRAINING;
 	mutex_unlock(&stream->device->lock);
 
 	/* we wait for drain to complete here, drain can return when
@@ -973,6 +975,7 @@ static int snd_compress_wait_for_drain(struct snd_compr_stream *stream)
 
 static int snd_compr_drain(struct snd_compr_stream *stream)
 {
+	snd_pcm_state_t state;
 	int retval;
 
 	switch (stream->runtime->state) {
@@ -987,9 +990,20 @@ static int snd_compr_drain(struct snd_compr_stream *stream)
 		break;
 	}
 
+	/*
+	 * The state must be set to draining before the trigger is issued as the
+	 * drain can be completed by the driver either from the trigger callback
+	 * itself or from a different context as soon as the trigger is called.
+	 * A snd_compr_drain_notify() arriving before the state is updated would
+	 * be lost and the wait for the drain to finish would never be woken up.
+	 */
+	state = stream->runtime->state;
+	stream->runtime->state = SNDRV_PCM_STATE_DRAINING;
+
 	retval = stream->ops->trigger(stream, SND_COMPR_TRIGGER_DRAIN);
 	if (retval) {
 		pr_debug("SND_COMPR_TRIGGER_DRAIN failed %d\n", retval);
+		stream->runtime->state = state;
 		wake_up(&stream->runtime->sleep);
 		return retval;
 	}
@@ -1025,6 +1039,7 @@ static int snd_compr_next_track(struct snd_compr_stream *stream)
 
 static int snd_compr_partial_drain(struct snd_compr_stream *stream)
 {
+	snd_pcm_state_t state;
 	int retval;
 
 	switch (stream->runtime->state) {
@@ -1048,9 +1063,16 @@ static int snd_compr_partial_drain(struct snd_compr_stream *stream)
 		return -EPERM;
 
 	stream->partial_drain = true;
+
+	/* See the comment in snd_compr_drain() on the state handling */
+	state = stream->runtime->state;
+	stream->runtime->state = SNDRV_PCM_STATE_DRAINING;
+
 	retval = stream->ops->trigger(stream, SND_COMPR_TRIGGER_PARTIAL_DRAIN);
 	if (retval) {
 		pr_debug("Partial drain returned failure\n");
+		stream->partial_drain = false;
+		stream->runtime->state = state;
 		wake_up(&stream->runtime->sleep);
 		return retval;
 	}
-- 
2.56.0