gpiolib: cdev: fully adopt guard() and scoped_guard()

Use guard() or scoped_guard() for critical sections rather than
discrete lock/unlock pairs.

Signed-off-by: Kent Gibson <warthog618@gmail.com>
Reviewed-by: Andy Shevchenko <andy@kernel.org>
Signed-off-by: Bartosz Golaszewski <bartosz.golaszewski@linaro.org>

diff --git a/drivers/gpio/gpiolib-cdev.c b/drivers/gpio/gpiolib-cdev.c
index aecc4241b6c8e734373a3221fa5344d03ff3eade..84471b703402f07933edf5982b5249efa910bd15 100644 (file)
--- a/drivers/gpio/gpiolib-cdev.c
+++ b/drivers/gpio/gpiolib-cdev.c
@@ -748,13 +748,13 @@ static void linereq_put_event(struct linereq *lr,
 {
        bool overflow = false;
 
-       spin_lock(&lr->wait.lock);
-       if (kfifo_is_full(&lr->events)) {
-               overflow = true;
-               kfifo_skip(&lr->events);
+       scoped_guard(spinlock, &lr->wait.lock) {
+               if (kfifo_is_full(&lr->events)) {
+                       overflow = true;
+                       kfifo_skip(&lr->events);
+               }
+               kfifo_in(&lr->events, le, 1);
        }
-       kfifo_in(&lr->events, le, 1);
-       spin_unlock(&lr->wait.lock);
        if (!overflow)
                wake_up_poll(&lr->wait, EPOLLIN);
        else
@@ -1487,18 +1487,13 @@ static long linereq_set_values_unlocked(struct linereq *lr,
 static long linereq_set_values(struct linereq *lr, void __user *ip)
 {
        struct gpio_v2_line_values lv;
-       int ret;
 
        if (copy_from_user(&lv, ip, sizeof(lv)))
                return -EFAULT;
 
-       mutex_lock(&lr->config_mutex);
-
-       ret = linereq_set_values_unlocked(lr, &lv);
-
-       mutex_unlock(&lr->config_mutex);
+       guard(mutex)(&lr->config_mutex);
 
-       return ret;
+       return linereq_set_values_unlocked(lr, &lv);
 }
 
 static long linereq_set_config_unlocked(struct linereq *lr,
@@ -1556,13 +1551,9 @@ static long linereq_set_config(struct linereq *lr, void __user *ip)
        if (ret)
                return ret;
 
-       mutex_lock(&lr->config_mutex);
-
-       ret = linereq_set_config_unlocked(lr, &lc);
+       guard(mutex)(&lr->config_mutex);
 
-       mutex_unlock(&lr->config_mutex);
-
-       return ret;
+       return linereq_set_config_unlocked(lr, &lc);
 }
 
 static long linereq_ioctl_unlocked(struct file *file, unsigned int cmd,
@@ -1644,28 +1635,22 @@ static ssize_t linereq_read_unlocked(struct file *file, char __user *buf,
                return -EINVAL;
 
        do {
-               spin_lock(&lr->wait.lock);
-               if (kfifo_is_empty(&lr->events)) {
-                       if (bytes_read) {
-                               spin_unlock(&lr->wait.lock);
-                               return bytes_read;
+               scoped_guard(spinlock, &lr->wait.lock) {
+                       if (kfifo_is_empty(&lr->events)) {
+                               if (bytes_read)
+                                       return bytes_read;
+
+                               if (file->f_flags & O_NONBLOCK)
+                                       return -EAGAIN;
+
+                               ret = wait_event_interruptible_locked(lr->wait,
+                                               !kfifo_is_empty(&lr->events));
+                               if (ret)
+                                       return ret;
                        }
 
-                       if (file->f_flags & O_NONBLOCK) {
-                               spin_unlock(&lr->wait.lock);
-                               return -EAGAIN;
-                       }
-
-                       ret = wait_event_interruptible_locked(lr->wait,
-                                       !kfifo_is_empty(&lr->events));
-                       if (ret) {
-                               spin_unlock(&lr->wait.lock);
-                               return ret;
-                       }
+                       ret = kfifo_out(&lr->events, &le, 1);
                }
-
-               ret = kfifo_out(&lr->events, &le, 1);
-               spin_unlock(&lr->wait.lock);
                if (ret != 1) {
                        /*
                         * This should never happen - we were holding the
@@ -2015,28 +2000,22 @@ static ssize_t lineevent_read_unlocked(struct file *file, char __user *buf,
                return -EINVAL;
 
        do {
-               spin_lock(&le->wait.lock);
-               if (kfifo_is_empty(&le->events)) {
-                       if (bytes_read) {
-                               spin_unlock(&le->wait.lock);
-                               return bytes_read;
-                       }
-
-                       if (file->f_flags & O_NONBLOCK) {
-                               spin_unlock(&le->wait.lock);
-                               return -EAGAIN;
+               scoped_guard(spinlock, &le->wait.lock) {
+                       if (kfifo_is_empty(&le->events)) {
+                               if (bytes_read)
+                                       return bytes_read;
+
+                               if (file->f_flags & O_NONBLOCK)
+                                       return -EAGAIN;
+
+                               ret = wait_event_interruptible_locked(le->wait,
+                                               !kfifo_is_empty(&le->events));
+                               if (ret)
+                                       return ret;
                        }
 
-                       ret = wait_event_interruptible_locked(le->wait,
-                                       !kfifo_is_empty(&le->events));
-                       if (ret) {
-                               spin_unlock(&le->wait.lock);
-                               return ret;
-                       }
+                       ret = kfifo_out(&le->events, &ge, 1);
                }
-
-               ret = kfifo_out(&le->events, &ge, 1);
-               spin_unlock(&le->wait.lock);
                if (ret != 1) {
                        /*
                         * This should never happen - we were holding the lock
@@ -2732,38 +2711,30 @@ static ssize_t lineinfo_watch_read_unlocked(struct file *file, char __user *buf,
 #endif
 
        do {
-               spin_lock(&cdev->wait.lock);
-               if (kfifo_is_empty(&cdev->events)) {
-                       if (bytes_read) {
-                               spin_unlock(&cdev->wait.lock);
-                               return bytes_read;
-                       }
-
-                       if (file->f_flags & O_NONBLOCK) {
-                               spin_unlock(&cdev->wait.lock);
-                               return -EAGAIN;
-                       }
-
-                       ret = wait_event_interruptible_locked(cdev->wait,
-                                       !kfifo_is_empty(&cdev->events));
-                       if (ret) {
-                               spin_unlock(&cdev->wait.lock);
-                               return ret;
+               scoped_guard(spinlock, &cdev->wait.lock) {
+                       if (kfifo_is_empty(&cdev->events)) {
+                               if (bytes_read)
+                                       return bytes_read;
+
+                               if (file->f_flags & O_NONBLOCK)
+                                       return -EAGAIN;
+
+                               ret = wait_event_interruptible_locked(cdev->wait,
+                                               !kfifo_is_empty(&cdev->events));
+                               if (ret)
+                                       return ret;
                        }
-               }
 #ifdef CONFIG_GPIO_CDEV_V1
-               /* must be after kfifo check so watch_abi_version is set */
-               if (atomic_read(&cdev->watch_abi_version) == 2)
-                       event_size = sizeof(struct gpio_v2_line_info_changed);
-               else
-                       event_size = sizeof(struct gpioline_info_changed);
-               if (count < event_size) {
-                       spin_unlock(&cdev->wait.lock);
-                       return -EINVAL;
-               }
+                       /* must be after kfifo check so watch_abi_version is set */
+                       if (atomic_read(&cdev->watch_abi_version) == 2)
+                               event_size = sizeof(struct gpio_v2_line_info_changed);
+                       else
+                               event_size = sizeof(struct gpioline_info_changed);
+                       if (count < event_size)
+                               return -EINVAL;
 #endif
-               ret = kfifo_out(&cdev->events, &event, 1);
-               spin_unlock(&cdev->wait.lock);
+                       ret = kfifo_out(&cdev->events, &event, 1);
+               }
                if (ret != 1) {
                        ret = -EIO;
                        break;