Commit aa75a222 authored by Takashi Iwai's avatar Takashi Iwai
Browse files

ALSA: seq: timer: 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: default avatarTakashi Iwai <tiwai@suse.de>
Link: https://lore.kernel.org/r/20240227085306.9764-17-tiwai@suse.de
parent 7c2e9821

sound/core/seq/seq_timer.c

+54 −101
Original line number Diff line number Diff line
@@ -75,9 +75,7 @@ void snd_seq_timer_delete(struct snd_seq_timer **tmr) 


void snd_seq_timer_defaults(struct snd_seq_timer * tmr)

{

	unsigned long flags;



	spin_lock_irqsave(&tmr->lock, flags);

	guard(spinlock_irqsave)(&tmr->lock);

	/* setup defaults */

	tmr->ppq = 96;		/* 96 PPQ */

	tmr->tempo = 500000;	/* 120 BPM */
@@ -93,7 +91,6 @@ void snd_seq_timer_defaults(struct snd_seq_timer * tmr) 
	tmr->preferred_resolution = seq_default_timer_resolution;



	tmr->skew = tmr->skew_base = SKEW_BASE;

	spin_unlock_irqrestore(&tmr->lock, flags);

}



static void seq_timer_reset(struct snd_seq_timer *tmr)
@@ -108,11 +105,8 @@ static void seq_timer_reset(struct snd_seq_timer *tmr) 


void snd_seq_timer_reset(struct snd_seq_timer *tmr)

{

	unsigned long flags;



	spin_lock_irqsave(&tmr->lock, flags);

	guard(spinlock_irqsave)(&tmr->lock);

	seq_timer_reset(tmr);

	spin_unlock_irqrestore(&tmr->lock, flags);

}
@@ -121,7 +115,6 @@ static void snd_seq_timer_interrupt(struct snd_timer_instance *timeri, 
				    unsigned long resolution,

				    unsigned long ticks)

{

	unsigned long flags;

	struct snd_seq_queue *q = timeri->callback_data;

	struct snd_seq_timer *tmr;
@@ -130,11 +123,10 @@ static void snd_seq_timer_interrupt(struct snd_timer_instance *timeri, 
	tmr = q->timer;

	if (tmr == NULL)

		return;

	spin_lock_irqsave(&tmr->lock, flags);

	if (!tmr->running) {

		spin_unlock_irqrestore(&tmr->lock, flags);



	scoped_guard(spinlock_irqsave, &tmr->lock) {

		if (!tmr->running)

			return;

	}



		resolution *= ticks;

		if (tmr->skew != tmr->skew_base) {
@@ -151,8 +143,7 @@ static void snd_seq_timer_interrupt(struct snd_timer_instance *timeri, 


		/* register actual time of this timer update */

		ktime_get_ts64(&tmr->last_update);



	spin_unlock_irqrestore(&tmr->lock, flags);

	}



	/* check queues and dispatch events */

	snd_seq_check_queue(q, 1, 0);
@@ -161,18 +152,15 @@ static void snd_seq_timer_interrupt(struct snd_timer_instance *timeri, 
/* set current tempo */

int snd_seq_timer_set_tempo(struct snd_seq_timer * tmr, int tempo)

{

	unsigned long flags;



	if (snd_BUG_ON(!tmr))

		return -EINVAL;

	if (tempo <= 0)

		return -EINVAL;

	spin_lock_irqsave(&tmr->lock, flags);

	guard(spinlock_irqsave)(&tmr->lock);

	if ((unsigned int)tempo != tmr->tempo) {

		tmr->tempo = tempo;

		snd_seq_timer_set_tick_resolution(tmr);

	}

	spin_unlock_irqrestore(&tmr->lock, flags);

	return 0;

}
@@ -180,17 +168,15 @@ int snd_seq_timer_set_tempo(struct snd_seq_timer * tmr, int tempo) 
int snd_seq_timer_set_tempo_ppq(struct snd_seq_timer *tmr, int tempo, int ppq)

{

	int changed;

	unsigned long flags;



	if (snd_BUG_ON(!tmr))

		return -EINVAL;

	if (tempo <= 0 || ppq <= 0)

		return -EINVAL;

	spin_lock_irqsave(&tmr->lock, flags);

	guard(spinlock_irqsave)(&tmr->lock);

	if (tmr->running && (ppq != tmr->ppq)) {

		/* refuse to change ppq on running timers */

		/* because it will upset the song position (ticks) */

		spin_unlock_irqrestore(&tmr->lock, flags);

		pr_debug("ALSA: seq: cannot change ppq of a running timer\n");

		return -EBUSY;

	}
@@ -199,7 +185,6 @@ int snd_seq_timer_set_tempo_ppq(struct snd_seq_timer *tmr, int tempo, int ppq) 
	tmr->ppq = ppq;

	if (changed)

		snd_seq_timer_set_tick_resolution(tmr);

	spin_unlock_irqrestore(&tmr->lock, flags);

	return 0;

}
@@ -207,15 +192,12 @@ int snd_seq_timer_set_tempo_ppq(struct snd_seq_timer *tmr, int tempo, int ppq) 
int snd_seq_timer_set_position_tick(struct snd_seq_timer *tmr,

				    snd_seq_tick_time_t position)

{

	unsigned long flags;



	if (snd_BUG_ON(!tmr))

		return -EINVAL;



	spin_lock_irqsave(&tmr->lock, flags);

	guard(spinlock_irqsave)(&tmr->lock);

	tmr->tick.cur_tick = position;

	tmr->tick.fraction = 0;

	spin_unlock_irqrestore(&tmr->lock, flags);

	return 0;

}
@@ -223,15 +205,12 @@ int snd_seq_timer_set_position_tick(struct snd_seq_timer *tmr, 
int snd_seq_timer_set_position_time(struct snd_seq_timer *tmr,

				    snd_seq_real_time_t position)

{

	unsigned long flags;



	if (snd_BUG_ON(!tmr))

		return -EINVAL;



	snd_seq_sanity_real_time(&position);

	spin_lock_irqsave(&tmr->lock, flags);

	guard(spinlock_irqsave)(&tmr->lock);

	tmr->cur_time = position;

	spin_unlock_irqrestore(&tmr->lock, flags);

	return 0;

}
@@ -239,8 +218,6 @@ int snd_seq_timer_set_position_time(struct snd_seq_timer *tmr, 
int snd_seq_timer_set_skew(struct snd_seq_timer *tmr, unsigned int skew,

			   unsigned int base)

{

	unsigned long flags;



	if (snd_BUG_ON(!tmr))

		return -EINVAL;
@@ -249,9 +226,8 @@ int snd_seq_timer_set_skew(struct snd_seq_timer *tmr, unsigned int skew, 
		pr_debug("ALSA: seq: invalid skew base 0x%x\n", base);

		return -EINVAL;

	}

	spin_lock_irqsave(&tmr->lock, flags);

	guard(spinlock_irqsave)(&tmr->lock);

	tmr->skew = skew;

	spin_unlock_irqrestore(&tmr->lock, flags);

	return 0;

}
@@ -296,12 +272,12 @@ int snd_seq_timer_open(struct snd_seq_queue *q) 
		snd_timer_instance_free(t);

		return err;

	}

	spin_lock_irq(&tmr->lock);

	scoped_guard(spinlock_irq, &tmr->lock) {

		if (tmr->timeri)

			err = -EBUSY;

		else

			tmr->timeri = t;

	spin_unlock_irq(&tmr->lock);

	}

	if (err < 0) {

		snd_timer_close(t);

		snd_timer_instance_free(t);
@@ -318,10 +294,10 @@ int snd_seq_timer_close(struct snd_seq_queue *q) 
	tmr = q->timer;

	if (snd_BUG_ON(!tmr))

		return -EINVAL;

	spin_lock_irq(&tmr->lock);

	scoped_guard(spinlock_irq, &tmr->lock) {

		t = tmr->timeri;

		tmr->timeri = NULL;

	spin_unlock_irq(&tmr->lock);

	}

	if (t) {

		snd_timer_close(t);

		snd_timer_instance_free(t);
@@ -342,13 +318,8 @@ static int seq_timer_stop(struct snd_seq_timer *tmr) 


int snd_seq_timer_stop(struct snd_seq_timer *tmr)

{

	unsigned long flags;

	int err;



	spin_lock_irqsave(&tmr->lock, flags);

	err = seq_timer_stop(tmr);

	spin_unlock_irqrestore(&tmr->lock, flags);

	return err;

	guard(spinlock_irqsave)(&tmr->lock);

	return seq_timer_stop(tmr);

}



static int initialize_timer(struct snd_seq_timer *tmr)
@@ -398,13 +369,8 @@ static int seq_timer_start(struct snd_seq_timer *tmr) 


int snd_seq_timer_start(struct snd_seq_timer *tmr)

{

	unsigned long flags;

	int err;



	spin_lock_irqsave(&tmr->lock, flags);

	err = seq_timer_start(tmr);

	spin_unlock_irqrestore(&tmr->lock, flags);

	return err;

	guard(spinlock_irqsave)(&tmr->lock);

	return seq_timer_start(tmr);

}



static int seq_timer_continue(struct snd_seq_timer *tmr)
@@ -426,13 +392,8 @@ static int seq_timer_continue(struct snd_seq_timer *tmr) 


int snd_seq_timer_continue(struct snd_seq_timer *tmr)

{

	unsigned long flags;

	int err;



	spin_lock_irqsave(&tmr->lock, flags);

	err = seq_timer_continue(tmr);

	spin_unlock_irqrestore(&tmr->lock, flags);

	return err;

	guard(spinlock_irqsave)(&tmr->lock);

	return seq_timer_continue(tmr);

}



/* return current 'real' time. use timeofday() to get better granularity. */
@@ -440,9 +401,8 @@ snd_seq_real_time_t snd_seq_timer_get_cur_time(struct snd_seq_timer *tmr, 
					       bool adjust_ktime)

{

	snd_seq_real_time_t cur_time;

	unsigned long flags;



	spin_lock_irqsave(&tmr->lock, flags);

	guard(spinlock_irqsave)(&tmr->lock);

	cur_time = tmr->cur_time;

	if (adjust_ktime && tmr->running) {

		struct timespec64 tm;
@@ -453,7 +413,6 @@ snd_seq_real_time_t snd_seq_timer_get_cur_time(struct snd_seq_timer *tmr, 
		cur_time.tv_sec += tm.tv_sec;

		snd_seq_sanity_real_time(&cur_time);

	}

	spin_unlock_irqrestore(&tmr->lock, flags);

	return cur_time;	

}
@@ -461,13 +420,8 @@ snd_seq_real_time_t snd_seq_timer_get_cur_time(struct snd_seq_timer *tmr, 
 high PPQ values) */

snd_seq_tick_time_t snd_seq_timer_get_cur_tick(struct snd_seq_timer *tmr)

{

	snd_seq_tick_time_t cur_tick;

	unsigned long flags;



	spin_lock_irqsave(&tmr->lock, flags);

	cur_tick = tmr->tick.cur_tick;

	spin_unlock_irqrestore(&tmr->lock, flags);

	return cur_tick;

	guard(spinlock_irqsave)(&tmr->lock);

	return tmr->tick.cur_tick;

}
@@ -486,19 +440,18 @@ void snd_seq_info_timer_read(struct snd_info_entry *entry, 
		q = queueptr(idx);

		if (q == NULL)

			continue;

		mutex_lock(&q->timer_mutex);

		scoped_guard(mutex, &q->timer_mutex) {

			tmr = q->timer;

			if (!tmr)

			goto unlock;

				break;

			ti = tmr->timeri;

			if (!ti)

			goto unlock;

				break;

			snd_iprintf(buffer, "Timer for queue %i : %s\n", q->queue, ti->timer->name);

			resolution = snd_timer_resolution(ti) * tmr->ticks;

			snd_iprintf(buffer, "  Period time : %lu.%09lu\n", resolution / 1000000000, resolution % 1000000000);

			snd_iprintf(buffer, "  Skew : %u / %u\n", tmr->skew, tmr->skew_base);

unlock:

		mutex_unlock(&q->timer_mutex);

		}

		queuefree(q);

 	}

}