ALSA: compress_offload: Use guard() for locking

We can simplify the code gracefully with new guard() macro and co for
automatic cleanup of locks.

The explicit mutex_lock/unlock are still seen only in
snd_compress_wait_for_drain() which does temporary unlock/relocking.

Only the code refactoring, and no functional changes.

Signed-off-by: Takashi Iwai <tiwai@suse.de>
Link: https://lore.kernel.org/r/20240227085306.9764-3-tiwai@suse.de

diff --git a/sound/core/compress_offload.c b/sound/core/compress_offload.c
index 5d926c5b737d3ed034550f4d203c6039e6a0ec20..f0008fa2d8396c8e898829a41360dc11eed19b1d 100644 (file)
--- a/sound/core/compress_offload.c
+++ b/sound/core/compress_offload.c
@@ -127,9 +127,8 @@ static int snd_compr_open(struct inode *inode, struct file *f)
        init_waitqueue_head(&runtime->sleep);
        data->stream.runtime = runtime;
        f->private_data = (void *)data;
-       mutex_lock(&compr->lock);
-       ret = compr->ops->open(&data->stream);
-       mutex_unlock(&compr->lock);
+       scoped_guard(mutex, &compr->lock)
+               ret = compr->ops->open(&data->stream);
        if (ret) {
                kfree(runtime);
                kfree(data);
@@ -288,7 +287,7 @@ static ssize_t snd_compr_write(struct file *f, const char __user *buf,
                return -EFAULT;
 
        stream = &data->stream;
-       mutex_lock(&stream->device->lock);
+       guard(mutex)(&stream->device->lock);
        /* write is allowed when stream is running or has been steup */
        switch (stream->runtime->state) {
        case SNDRV_PCM_STATE_SETUP:
@@ -296,7 +295,6 @@ static ssize_t snd_compr_write(struct file *f, const char __user *buf,
        case SNDRV_PCM_STATE_RUNNING:
                break;
        default:
-               mutex_unlock(&stream->device->lock);
                return -EBADFD;
        }
 
@@ -322,7 +320,6 @@ static ssize_t snd_compr_write(struct file *f, const char __user *buf,
                pr_debug("stream prepared, Houston we are good to go\n");
        }
 
-       mutex_unlock(&stream->device->lock);
        return retval;
 }
 
@@ -339,7 +336,7 @@ static ssize_t snd_compr_read(struct file *f, char __user *buf,
                return -EFAULT;
 
        stream = &data->stream;
-       mutex_lock(&stream->device->lock);
+       guard(mutex)(&stream->device->lock);
 
        /* read is allowed when stream is running, paused, draining and setup
         * (yes setup is state which we transition to after stop, so if user
@@ -350,11 +347,9 @@ static ssize_t snd_compr_read(struct file *f, char __user *buf,
        case SNDRV_PCM_STATE_PREPARED:
        case SNDRV_PCM_STATE_SUSPENDED:
        case SNDRV_PCM_STATE_DISCONNECTED:
-               retval = -EBADFD;
-               goto out;
+               return -EBADFD;
        case SNDRV_PCM_STATE_XRUN:
-               retval = -EPIPE;
-               goto out;
+               return -EPIPE;
        }
 
        avail = snd_compr_get_avail(stream);
@@ -363,17 +358,13 @@ static ssize_t snd_compr_read(struct file *f, char __user *buf,
        if (avail > count)
                avail = count;
 
-       if (stream->ops->copy) {
+       if (stream->ops->copy)
                retval = stream->ops->copy(stream, buf, avail);
-       } else {
-               retval = -ENXIO;
-               goto out;
-       }
+       else
+               return -ENXIO;
        if (retval > 0)
                stream->runtime->total_bytes_transferred += retval;
 
-out:
-       mutex_unlock(&stream->device->lock);
        return retval;
 }
 
@@ -402,13 +393,12 @@ static __poll_t snd_compr_poll(struct file *f, poll_table *wait)
 
        stream = &data->stream;
 
-       mutex_lock(&stream->device->lock);
+       guard(mutex)(&stream->device->lock);
 
        switch (stream->runtime->state) {
        case SNDRV_PCM_STATE_OPEN:
        case SNDRV_PCM_STATE_XRUN:
-               retval = snd_compr_get_poll(stream) | EPOLLERR;
-               goto out;
+               return snd_compr_get_poll(stream) | EPOLLERR;
        default:
                break;
        }
@@ -433,11 +423,9 @@ static __poll_t snd_compr_poll(struct file *f, poll_table *wait)
                        retval = snd_compr_get_poll(stream);
                break;
        default:
-               retval = snd_compr_get_poll(stream) | EPOLLERR;
-               break;
+               return snd_compr_get_poll(stream) | EPOLLERR;
        }
-out:
-       mutex_unlock(&stream->device->lock);
+
        return retval;
 }
 
@@ -795,12 +783,10 @@ static void error_delayed_work(struct work_struct *work)
 
        stream = container_of(work, struct snd_compr_stream, error_work.work);
 
-       mutex_lock(&stream->device->lock);
+       guard(mutex)(&stream->device->lock);
 
        stream->ops->trigger(stream, SNDRV_PCM_TRIGGER_STOP);
        wake_up(&stream->runtime->sleep);
-
-       mutex_unlock(&stream->device->lock);
 }
 
 /**
@@ -957,70 +943,52 @@ static long snd_compr_ioctl(struct file *f, unsigned int cmd, unsigned long arg)
 {
        struct snd_compr_file *data = f->private_data;
        struct snd_compr_stream *stream;
-       int retval = -ENOTTY;
 
        if (snd_BUG_ON(!data))
                return -EFAULT;
 
        stream = &data->stream;
 
-       mutex_lock(&stream->device->lock);
+       guard(mutex)(&stream->device->lock);
        switch (_IOC_NR(cmd)) {
        case _IOC_NR(SNDRV_COMPRESS_IOCTL_VERSION):
-               retval = put_user(SNDRV_COMPRESS_VERSION,
+               return put_user(SNDRV_COMPRESS_VERSION,
                                (int __user *)arg) ? -EFAULT : 0;
-               break;
        case _IOC_NR(SNDRV_COMPRESS_GET_CAPS):
-               retval = snd_compr_get_caps(stream, arg);
-               break;
+               return snd_compr_get_caps(stream, arg);
 #ifndef COMPR_CODEC_CAPS_OVERFLOW
        case _IOC_NR(SNDRV_COMPRESS_GET_CODEC_CAPS):
-               retval = snd_compr_get_codec_caps(stream, arg);
-               break;
+               return snd_compr_get_codec_caps(stream, arg);
 #endif
        case _IOC_NR(SNDRV_COMPRESS_SET_PARAMS):
-               retval = snd_compr_set_params(stream, arg);
-               break;
+               return snd_compr_set_params(stream, arg);
        case _IOC_NR(SNDRV_COMPRESS_GET_PARAMS):
-               retval = snd_compr_get_params(stream, arg);
-               break;
+               return snd_compr_get_params(stream, arg);
        case _IOC_NR(SNDRV_COMPRESS_SET_METADATA):
-               retval = snd_compr_set_metadata(stream, arg);
-               break;
+               return snd_compr_set_metadata(stream, arg);
        case _IOC_NR(SNDRV_COMPRESS_GET_METADATA):
-               retval = snd_compr_get_metadata(stream, arg);
-               break;
+               return snd_compr_get_metadata(stream, arg);
        case _IOC_NR(SNDRV_COMPRESS_TSTAMP):
-               retval = snd_compr_tstamp(stream, arg);
-               break;
+               return snd_compr_tstamp(stream, arg);
        case _IOC_NR(SNDRV_COMPRESS_AVAIL):
-               retval = snd_compr_ioctl_avail(stream, arg);
-               break;
+               return snd_compr_ioctl_avail(stream, arg);
        case _IOC_NR(SNDRV_COMPRESS_PAUSE):
-               retval = snd_compr_pause(stream);
-               break;
+               return snd_compr_pause(stream);
        case _IOC_NR(SNDRV_COMPRESS_RESUME):
-               retval = snd_compr_resume(stream);
-               break;
+               return snd_compr_resume(stream);
        case _IOC_NR(SNDRV_COMPRESS_START):
-               retval = snd_compr_start(stream);
-               break;
+               return snd_compr_start(stream);
        case _IOC_NR(SNDRV_COMPRESS_STOP):
-               retval = snd_compr_stop(stream);
-               break;
+               return snd_compr_stop(stream);
        case _IOC_NR(SNDRV_COMPRESS_DRAIN):
-               retval = snd_compr_drain(stream);
-               break;
+               return snd_compr_drain(stream);
        case _IOC_NR(SNDRV_COMPRESS_PARTIAL_DRAIN):
-               retval = snd_compr_partial_drain(stream);
-               break;
+               return snd_compr_partial_drain(stream);
        case _IOC_NR(SNDRV_COMPRESS_NEXT_TRACK):
-               retval = snd_compr_next_track(stream);
-               break;
-
+               return snd_compr_next_track(stream);
        }
-       mutex_unlock(&stream->device->lock);
-       return retval;
+
+       return -ENOTTY;
 }
 
 /* support of 32bit userspace on 64bit platforms */