ALSA: seq: fifo: Use guard() for locking

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

Only the code refactoring, and no functional changes.

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

diff --git a/sound/core/seq/seq_fifo.c b/sound/core/seq/seq_fifo.c
index f8e02e98709abe12a5ff6336958cc6e16f9f10ca..3a10b081f129c30d677a9e834a7477a065fd8044 100644 (file)
--- a/sound/core/seq/seq_fifo.c
+++ b/sound/core/seq/seq_fifo.c
@@ -88,12 +88,11 @@ void snd_seq_fifo_clear(struct snd_seq_fifo *f)
        atomic_set(&f->overflow, 0);
 
        snd_use_lock_sync(&f->use_lock);
-       spin_lock_irq(&f->lock);
+       guard(spinlock_irq)(&f->lock);
        /* drain the fifo */
        while ((cell = fifo_cell_out(f)) != NULL) {
                snd_seq_cell_free(cell);
        }
-       spin_unlock_irq(&f->lock);
 }
 
 
@@ -102,7 +101,6 @@ int snd_seq_fifo_event_in(struct snd_seq_fifo *f,
                          struct snd_seq_event *event)
 {
        struct snd_seq_event_cell *cell;
-       unsigned long flags;
        int err;
 
        if (snd_BUG_ON(!f))
@@ -118,15 +116,15 @@ int snd_seq_fifo_event_in(struct snd_seq_fifo *f,
        }
                
        /* append new cells to fifo */
-       spin_lock_irqsave(&f->lock, flags);
-       if (f->tail != NULL)
-               f->tail->next = cell;
-       f->tail = cell;
-       if (f->head == NULL)
-               f->head = cell;
-       cell->next = NULL;
-       f->cells++;
-       spin_unlock_irqrestore(&f->lock, flags);
+       scoped_guard(spinlock_irqsave, &f->lock) {
+               if (f->tail != NULL)
+                       f->tail->next = cell;
+               f->tail = cell;
+               if (f->head == NULL)
+                       f->head = cell;
+               cell->next = NULL;
+               f->cells++;
+       }
 
        /* wakeup client */
        if (waitqueue_active(&f->input_sleep))
@@ -199,16 +197,13 @@ int snd_seq_fifo_cell_out(struct snd_seq_fifo *f,
 void snd_seq_fifo_cell_putback(struct snd_seq_fifo *f,
                               struct snd_seq_event_cell *cell)
 {
-       unsigned long flags;
-
        if (cell) {
-               spin_lock_irqsave(&f->lock, flags);
+               guard(spinlock_irqsave)(&f->lock);
                cell->next = f->head;
                f->head = cell;
                if (!f->tail)
                        f->tail = cell;
                f->cells++;
-               spin_unlock_irqrestore(&f->lock, flags);
        }
 }
 
@@ -239,17 +234,17 @@ int snd_seq_fifo_resize(struct snd_seq_fifo *f, int poolsize)
                return -ENOMEM;
        }
 
-       spin_lock_irq(&f->lock);
-       /* remember old pool */
-       oldpool = f->pool;
-       oldhead = f->head;
-       /* exchange pools */
-       f->pool = newpool;
-       f->head = NULL;
-       f->tail = NULL;
-       f->cells = 0;
-       /* NOTE: overflow flag is not cleared */
-       spin_unlock_irq(&f->lock);
+       scoped_guard(spinlock_irq, &f->lock) {
+               /* remember old pool */
+               oldpool = f->pool;
+               oldhead = f->head;
+               /* exchange pools */
+               f->pool = newpool;
+               f->head = NULL;
+               f->tail = NULL;
+               f->cells = 0;
+               /* NOTE: overflow flag is not cleared */
+       }
 
        /* close the old pool and wait until all users are gone */
        snd_seq_pool_mark_closing(oldpool);
@@ -268,16 +263,14 @@ int snd_seq_fifo_resize(struct snd_seq_fifo *f, int poolsize)
 /* get the number of unused cells safely */
 int snd_seq_fifo_unused_cells(struct snd_seq_fifo *f)
 {
-       unsigned long flags;
        int cells;
 
        if (!f)
                return 0;
 
        snd_use_lock_use(&f->use_lock);
-       spin_lock_irqsave(&f->lock, flags);
-       cells = snd_seq_unused_cells(f->pool);
-       spin_unlock_irqrestore(&f->lock, flags);
+       scoped_guard(spinlock_irqsave, &f->lock)
+               cells = snd_seq_unused_cells(f->pool);
        snd_use_lock_free(&f->use_lock);
        return cells;
 }