alarmtimer: Switch spin_{lock,unlock}_irqsave() to guards

Using guard/scoped_guard() to simplify code. Using guard() to remove
'goto unlock' label is neater especially.

[ tglx: Brought back the scoped_guard()'s which were dropped in v2 and
  	simplified alarmtimer_rtc_add_device() ]

Signed-off-by: Su Hui <suhui@nfschina.com>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Acked-by: John Stultz <jstultz@google.com>
Link: https://lore.kernel.org/all/20250430032734.2079290-4-suhui@nfschina.com

diff --git a/kernel/time/alarmtimer.c b/kernel/time/alarmtimer.c
index 621d39666e29f2f986e96dcd72bca86089efabf8..577f0e6842d4cef4d306ab59fb084826f4a44812 100644 (file)
--- a/kernel/time/alarmtimer.c
+++ b/kernel/time/alarmtimer.c
@@ -70,12 +70,10 @@ static DEFINE_SPINLOCK(rtcdev_lock);
  */
 struct rtc_device *alarmtimer_get_rtcdev(void)
 {
-       unsigned long flags;
        struct rtc_device *ret;
 
-       spin_lock_irqsave(&rtcdev_lock, flags);
+       guard(spinlock_irqsave)(&rtcdev_lock);
        ret = rtcdev;
-       spin_unlock_irqrestore(&rtcdev_lock, flags);
 
        return ret;
 }
@@ -83,7 +81,6 @@ EXPORT_SYMBOL_GPL(alarmtimer_get_rtcdev);
 
 static int alarmtimer_rtc_add_device(struct device *dev)
 {
-       unsigned long flags;
        struct rtc_device *rtc = to_rtc_device(dev);
        struct platform_device *pdev;
        int ret = 0;
@@ -101,25 +98,18 @@ static int alarmtimer_rtc_add_device(struct device *dev)
        if (!IS_ERR(pdev))
                device_init_wakeup(&pdev->dev, true);
 
-       spin_lock_irqsave(&rtcdev_lock, flags);
-       if (!IS_ERR(pdev) && !rtcdev) {
-               if (!try_module_get(rtc->owner)) {
+       scoped_guard(spinlock_irqsave, &rtcdev_lock) {
+               if (!IS_ERR(pdev) && !rtcdev && try_module_get(rtc->owner)) {
+                       rtcdev = rtc;
+                       /* hold a reference so it doesn't go away */
+                       get_device(dev);
+                       pdev = NULL;
+               } else {
                        ret = -1;
-                       goto unlock;
                }
-
-               rtcdev = rtc;
-               /* hold a reference so it doesn't go away */
-               get_device(dev);
-               pdev = NULL;
-       } else {
-               ret = -1;
        }
-unlock:
-       spin_unlock_irqrestore(&rtcdev_lock, flags);
 
        platform_device_unregister(pdev);
-
        return ret;
 }
 
@@ -198,7 +188,7 @@ static enum hrtimer_restart alarmtimer_fired(struct hrtimer *timer)
        struct alarm *alarm = container_of(timer, struct alarm, timer);
        struct alarm_base *base = &alarm_bases[alarm->type];
 
-       scoped_guard (spinlock_irqsave, &base->lock)
+       scoped_guard(spinlock_irqsave, &base->lock)
                alarmtimer_dequeue(base, alarm);
 
        if (alarm->function)
@@ -228,17 +218,16 @@ EXPORT_SYMBOL_GPL(alarm_expires_remaining);
 static int alarmtimer_suspend(struct device *dev)
 {
        ktime_t min, now, expires;
-       int i, ret, type;
        struct rtc_device *rtc;
-       unsigned long flags;
        struct rtc_time tm;
+       int i, ret, type;
 
-       spin_lock_irqsave(&freezer_delta_lock, flags);
-       min = freezer_delta;
-       expires = freezer_expires;
-       type = freezer_alarmtype;
-       freezer_delta = 0;
-       spin_unlock_irqrestore(&freezer_delta_lock, flags);
+       scoped_guard(spinlock_irqsave, &freezer_delta_lock) {
+               min = freezer_delta;
+               expires = freezer_expires;
+               type = freezer_alarmtype;
+               freezer_delta = 0;
+       }
 
        rtc = alarmtimer_get_rtcdev();
        /* If we have no rtcdev, just return */
@@ -251,9 +240,8 @@ static int alarmtimer_suspend(struct device *dev)
                struct timerqueue_node *next;
                ktime_t delta;
 
-               spin_lock_irqsave(&base->lock, flags);
-               next = timerqueue_getnext(&base->timerqueue);
-               spin_unlock_irqrestore(&base->lock, flags);
+               scoped_guard(spinlock_irqsave, &base->lock)
+                       next = timerqueue_getnext(&base->timerqueue);
                if (!next)
                        continue;
                delta = ktime_sub(next->expires, base->get_ktime());
@@ -352,13 +340,12 @@ EXPORT_SYMBOL_GPL(alarm_init);
 void alarm_start(struct alarm *alarm, ktime_t start)
 {
        struct alarm_base *base = &alarm_bases[alarm->type];
-       unsigned long flags;
 
-       spin_lock_irqsave(&base->lock, flags);
-       alarm->node.expires = start;
-       alarmtimer_enqueue(base, alarm);
-       hrtimer_start(&alarm->timer, alarm->node.expires, HRTIMER_MODE_ABS);
-       spin_unlock_irqrestore(&base->lock, flags);
+       scoped_guard(spinlock_irqsave, &base->lock) {
+               alarm->node.expires = start;
+               alarmtimer_enqueue(base, alarm);
+               hrtimer_start(&alarm->timer, alarm->node.expires, HRTIMER_MODE_ABS);
+       }
 
        trace_alarmtimer_start(alarm, base->get_ktime());
 }
@@ -381,13 +368,11 @@ EXPORT_SYMBOL_GPL(alarm_start_relative);
 void alarm_restart(struct alarm *alarm)
 {
        struct alarm_base *base = &alarm_bases[alarm->type];
-       unsigned long flags;
 
-       spin_lock_irqsave(&base->lock, flags);
+       guard(spinlock_irqsave)(&base->lock);
        hrtimer_set_expires(&alarm->timer, alarm->node.expires);
        hrtimer_restart(&alarm->timer);
        alarmtimer_enqueue(base, alarm);
-       spin_unlock_irqrestore(&base->lock, flags);
 }
 EXPORT_SYMBOL_GPL(alarm_restart);
 
@@ -401,14 +386,13 @@ EXPORT_SYMBOL_GPL(alarm_restart);
 int alarm_try_to_cancel(struct alarm *alarm)
 {
        struct alarm_base *base = &alarm_bases[alarm->type];
-       unsigned long flags;
        int ret;
 
-       spin_lock_irqsave(&base->lock, flags);
-       ret = hrtimer_try_to_cancel(&alarm->timer);
-       if (ret >= 0)
-               alarmtimer_dequeue(base, alarm);
-       spin_unlock_irqrestore(&base->lock, flags);
+       scoped_guard(spinlock_irqsave, &base->lock) {
+               ret = hrtimer_try_to_cancel(&alarm->timer);
+               if (ret >= 0)
+                       alarmtimer_dequeue(base, alarm);
+       }
 
        trace_alarmtimer_cancel(alarm, base->get_ktime());
        return ret;
@@ -479,7 +463,6 @@ EXPORT_SYMBOL_GPL(alarm_forward_now);
 static void alarmtimer_freezerset(ktime_t absexp, enum alarmtimer_type type)
 {
        struct alarm_base *base;
-       unsigned long flags;
        ktime_t delta;
 
        switch(type) {
@@ -498,13 +481,12 @@ static void alarmtimer_freezerset(ktime_t absexp, enum alarmtimer_type type)
 
        delta = ktime_sub(absexp, base->get_ktime());
 
-       spin_lock_irqsave(&freezer_delta_lock, flags);
+       guard(spinlock_irqsave)(&freezer_delta_lock);
        if (!freezer_delta || (delta < freezer_delta)) {
                freezer_delta = delta;
                freezer_expires = absexp;
                freezer_alarmtype = type;
        }
-       spin_unlock_irqrestore(&freezer_delta_lock, flags);
 }
 
 /**