Add guard classes for iio_device_claim_*() conditional locks. This will
aid drivers write safer and cleaner code when dealing with some common
patterns.
These classes are not meant to be used directly by drivers (hence the
__priv__ prefix). Instead, documented wrapper macros are provided to
enforce the use of ACQUIRE() or guard() semantics and avoid the
problematic scoped guard.
Suggested-by: Andy Shevchenko <andriy.shevchenko@intel.com>
Reviewed-by: David Lechner <dlechner@baylibre.com>
Reviewed-by: Nuno Sá <nuno.sa@analog.com>
Signed-off-by: Kurt Borja <kuurtb@gmail.com>
---
include/linux/iio/iio.h | 65 +++++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 65 insertions(+)
diff --git a/include/linux/iio/iio.h b/include/linux/iio/iio.h
index fa671e120e95..4a0a77fcfa8d 100644
--- a/include/linux/iio/iio.h
+++ b/include/linux/iio/iio.h
@@ -10,6 +10,7 @@
#include <linux/align.h>
#include <linux/device.h>
#include <linux/cdev.h>
+#include <linux/cleanup.h>
#include <linux/compiler_types.h>
#include <linux/minmax.h>
#include <linux/slab.h>
@@ -740,6 +741,70 @@ static inline bool iio_device_try_claim_buffer_mode(struct iio_dev *indio_dev)
*/
#define iio_device_release_buffer_mode(indio_dev) __iio_dev_mode_unlock(indio_dev)
+/*
+ * These classes are not meant to be used directly by drivers (hence the
+ * __priv__ prefix). Instead, documented wrapper macros are provided below to
+ * enforce the use of ACQUIRE() or guard() semantics and avoid the problematic
+ * scoped guard variants.
+ */
+DEFINE_GUARD(__priv__iio_dev_mode_lock, struct iio_dev *,
+ __iio_dev_mode_lock(_T), __iio_dev_mode_unlock(_T));
+DEFINE_GUARD_COND(__priv__iio_dev_mode_lock, _try_direct,
+ iio_device_claim_direct(_T));
+
+/**
+ * IIO_DEV_ACQUIRE_DIRECT_MODE(dev, var) - Tries to acquire the direct mode
+ * lock with automatic release
+ * @dev: IIO device instance
+ * @claim: Variable identifier to store acquire result
+ *
+ * Tries to acquire the direct mode lock with cleanup ACQUIRE() semantics and
+ * automatically releases it at the end of the scope. It most be always paired
+ * with IIO_DEV_ACQUIRE_ERR(), for example (notice the scope braces)::
+ *
+ * switch() {
+ * case IIO_CHAN_INFO_RAW: {
+ * IIO_DEV_ACQUIRE_DIRECT_MODE(indio_dev, claim);
+ * if (IIO_DEV_ACQUIRE_FAILED(claim))
+ * return -EBUSY;
+ *
+ * ...
+ * }
+ * case IIO_CHAN_INFO_SCALE:
+ * ...
+ * ...
+ * }
+ *
+ * Context: Can sleep
+ */
+#define IIO_DEV_ACQUIRE_DIRECT_MODE(dev, claim) \
+ ACQUIRE(__priv__iio_dev_mode_lock_try_direct, claim)(dev)
+
+/**
+ * IIO_DEV_ACQUIRE_FAILED() - ACQUIRE_ERR() wrapper
+ * @claim: The claim variable passed to IIO_DEV_ACQUIRE_*_MODE()
+ *
+ * Return: true if failed to acquire the mode, otherwise false.
+ */
+#define IIO_DEV_ACQUIRE_FAILED(claim) \
+ ACQUIRE_ERR(__priv__iio_dev_mode_lock_try_direct, &(claim))
+
+/**
+ * IIO_DEV_GUARD_CURRENT_MODE - Acquires the mode lock with automatic release
+ * @dev: IIO device instance
+ *
+ * Acquires the mode lock with cleanup guard() semantics. It is usually paired
+ * with iio_buffer_enabled().
+ *
+ * This should *not* be used to protect internal driver state and it's use in
+ * general is *strongly* discouraged. Use any of the IIO_DEV_ACQUIRE_*_MODE()
+ * variants.
+ *
+ * Context: Can sleep
+ */
+#define IIO_DEV_GUARD_CURRENT_MODE(dev) \
+ guard(__priv__iio_dev_mode_lock)(dev)
+
extern const struct bus_type iio_bus_type;
/**
--
2.52.0
On Sun, Jan 18, 2026 at 10:44:31AM -0500, Kurt Borja wrote: > Add guard classes for iio_device_claim_*() conditional locks. This will > aid drivers write safer and cleaner code when dealing with some common > patterns. > > These classes are not meant to be used directly by drivers (hence the > __priv__ prefix). Instead, documented wrapper macros are provided to > enforce the use of ACQUIRE() or guard() semantics and avoid the > problematic scoped guard. Acked-by: Andy Shevchenko <andriy.shevchenko@intel.com> -- With Best Regards, Andy Shevchenko
On Mon Jan 19, 2026 at 3:15 AM -05, Andy Shevchenko wrote: > On Sun, Jan 18, 2026 at 10:44:31AM -0500, Kurt Borja wrote: >> Add guard classes for iio_device_claim_*() conditional locks. This will >> aid drivers write safer and cleaner code when dealing with some common >> patterns. >> >> These classes are not meant to be used directly by drivers (hence the >> __priv__ prefix). Instead, documented wrapper macros are provided to >> enforce the use of ACQUIRE() or guard() semantics and avoid the >> problematic scoped guard. > > Acked-by: Andy Shevchenko <andriy.shevchenko@intel.com> Hi Andy, Thank you for your feedback! -- Thanks, ~ Kurt
On 1/18/26 9:44 AM, Kurt Borja wrote:
> Add guard classes for iio_device_claim_*() conditional locks. This will
> aid drivers write safer and cleaner code when dealing with some common
> patterns.
>
> These classes are not meant to be used directly by drivers (hence the
> __priv__ prefix). Instead, documented wrapper macros are provided to
> enforce the use of ACQUIRE() or guard() semantics and avoid the
> problematic scoped guard.
>
> Suggested-by: Andy Shevchenko <andriy.shevchenko@intel.com>
> Reviewed-by: David Lechner <dlechner@baylibre.com>
> Reviewed-by: Nuno Sá <nuno.sa@analog.com>
> Signed-off-by: Kurt Borja <kuurtb@gmail.com>
> ---
> include/linux/iio/iio.h | 65 +++++++++++++++++++++++++++++++++++++++++++++++++
> 1 file changed, 65 insertions(+)
>
> diff --git a/include/linux/iio/iio.h b/include/linux/iio/iio.h
> index fa671e120e95..4a0a77fcfa8d 100644
> --- a/include/linux/iio/iio.h
> +++ b/include/linux/iio/iio.h
> @@ -10,6 +10,7 @@
> #include <linux/align.h>
> #include <linux/device.h>
> #include <linux/cdev.h>
> +#include <linux/cleanup.h>
> #include <linux/compiler_types.h>
> #include <linux/minmax.h>
> #include <linux/slab.h>
> @@ -740,6 +741,70 @@ static inline bool iio_device_try_claim_buffer_mode(struct iio_dev *indio_dev)
> */
> #define iio_device_release_buffer_mode(indio_dev) __iio_dev_mode_unlock(indio_dev)
>
> +/*
> + * These classes are not meant to be used directly by drivers (hence the
> + * __priv__ prefix). Instead, documented wrapper macros are provided below to
> + * enforce the use of ACQUIRE() or guard() semantics and avoid the problematic
> + * scoped guard variants.
> + */
> +DEFINE_GUARD(__priv__iio_dev_mode_lock, struct iio_dev *,
> + __iio_dev_mode_lock(_T), __iio_dev_mode_unlock(_T));
> +DEFINE_GUARD_COND(__priv__iio_dev_mode_lock, _try_direct,
> + iio_device_claim_direct(_T));
> +
> +/**
> + * IIO_DEV_ACQUIRE_DIRECT_MODE(dev, var) - Tries to acquire the direct mode
> + * lock with automatic release
Should be just IIO_DEV_ACQUIRE_DIRECT_MODE()
> + * @dev: IIO device instance
> + * @claim: Variable identifier to store acquire result
> + *
> + * Tries to acquire the direct mode lock with cleanup ACQUIRE() semantics and
> + * automatically releases it at the end of the scope. It most be always paired
> + * with IIO_DEV_ACQUIRE_ERR(), for example (notice the scope braces)::
> + *
> + * switch() {
> + * case IIO_CHAN_INFO_RAW: {
> + * IIO_DEV_ACQUIRE_DIRECT_MODE(indio_dev, claim);
> + * if (IIO_DEV_ACQUIRE_FAILED(claim))
> + * return -EBUSY;
> + *
> + * ...
> + * }
> + * case IIO_CHAN_INFO_SCALE:
> + * ...
> + * ...
> + * }
> + *
> + * Context: Can sleep
> + */
> +#define IIO_DEV_ACQUIRE_DIRECT_MODE(dev, claim) \
> + ACQUIRE(__priv__iio_dev_mode_lock_try_direct, claim)(dev)
> +
> +/**
> + * IIO_DEV_ACQUIRE_FAILED() - ACQUIRE_ERR() wrapper
This one is correct style.
> + * @claim: The claim variable passed to IIO_DEV_ACQUIRE_*_MODE()
> + *
> + * Return: true if failed to acquire the mode, otherwise false.
> + */
> +#define IIO_DEV_ACQUIRE_FAILED(claim) \
> + ACQUIRE_ERR(__priv__iio_dev_mode_lock_try_direct, &(claim))
> +
> +/**
> + * IIO_DEV_GUARD_CURRENT_MODE - Acquires the mode lock with automatic release
Missing ()
> + * @dev: IIO device instance
> + *
> + * Acquires the mode lock with cleanup guard() semantics. It is usually paired
> + * with iio_buffer_enabled().
> + *
> + * This should *not* be used to protect internal driver state and it's use in
> + * general is *strongly* discouraged. Use any of the IIO_DEV_ACQUIRE_*_MODE()
> + * variants.
> + *
> + * Context: Can sleep
> + */
> +#define IIO_DEV_GUARD_CURRENT_MODE(dev) \
> + guard(__priv__iio_dev_mode_lock)(dev)
> +
> extern const struct bus_type iio_bus_type;
>
> /**
>
On Sun Jan 18, 2026 at 2:35 PM -05, David Lechner wrote:
> On 1/18/26 9:44 AM, Kurt Borja wrote:
>> Add guard classes for iio_device_claim_*() conditional locks. This will
>> aid drivers write safer and cleaner code when dealing with some common
>> patterns.
>>
>> These classes are not meant to be used directly by drivers (hence the
>> __priv__ prefix). Instead, documented wrapper macros are provided to
>> enforce the use of ACQUIRE() or guard() semantics and avoid the
>> problematic scoped guard.
>>
>> Suggested-by: Andy Shevchenko <andriy.shevchenko@intel.com>
>> Reviewed-by: David Lechner <dlechner@baylibre.com>
>> Reviewed-by: Nuno Sá <nuno.sa@analog.com>
>> Signed-off-by: Kurt Borja <kuurtb@gmail.com>
>> ---
>> include/linux/iio/iio.h | 65 +++++++++++++++++++++++++++++++++++++++++++++++++
>> 1 file changed, 65 insertions(+)
>>
>> diff --git a/include/linux/iio/iio.h b/include/linux/iio/iio.h
>> index fa671e120e95..4a0a77fcfa8d 100644
>> --- a/include/linux/iio/iio.h
>> +++ b/include/linux/iio/iio.h
>> @@ -10,6 +10,7 @@
>> #include <linux/align.h>
>> #include <linux/device.h>
>> #include <linux/cdev.h>
>> +#include <linux/cleanup.h>
>> #include <linux/compiler_types.h>
>> #include <linux/minmax.h>
>> #include <linux/slab.h>
>> @@ -740,6 +741,70 @@ static inline bool iio_device_try_claim_buffer_mode(struct iio_dev *indio_dev)
>> */
>> #define iio_device_release_buffer_mode(indio_dev) __iio_dev_mode_unlock(indio_dev)
>>
>> +/*
>> + * These classes are not meant to be used directly by drivers (hence the
>> + * __priv__ prefix). Instead, documented wrapper macros are provided below to
>> + * enforce the use of ACQUIRE() or guard() semantics and avoid the problematic
>> + * scoped guard variants.
>> + */
>> +DEFINE_GUARD(__priv__iio_dev_mode_lock, struct iio_dev *,
>> + __iio_dev_mode_lock(_T), __iio_dev_mode_unlock(_T));
>> +DEFINE_GUARD_COND(__priv__iio_dev_mode_lock, _try_direct,
>> + iio_device_claim_direct(_T));
>> +
>> +/**
>> + * IIO_DEV_ACQUIRE_DIRECT_MODE(dev, var) - Tries to acquire the direct mode
>> + * lock with automatic release
>
> Should be just IIO_DEV_ACQUIRE_DIRECT_MODE()
>
>> + * @dev: IIO device instance
>> + * @claim: Variable identifier to store acquire result
>> + *
>> + * Tries to acquire the direct mode lock with cleanup ACQUIRE() semantics and
>> + * automatically releases it at the end of the scope. It most be always paired
>> + * with IIO_DEV_ACQUIRE_ERR(), for example (notice the scope braces)::
>> + *
>> + * switch() {
>> + * case IIO_CHAN_INFO_RAW: {
>> + * IIO_DEV_ACQUIRE_DIRECT_MODE(indio_dev, claim);
>> + * if (IIO_DEV_ACQUIRE_FAILED(claim))
>> + * return -EBUSY;
>> + *
>> + * ...
>> + * }
>> + * case IIO_CHAN_INFO_SCALE:
>> + * ...
>> + * ...
>> + * }
>> + *
>> + * Context: Can sleep
>> + */
>> +#define IIO_DEV_ACQUIRE_DIRECT_MODE(dev, claim) \
>> + ACQUIRE(__priv__iio_dev_mode_lock_try_direct, claim)(dev)
>> +
>> +/**
>> + * IIO_DEV_ACQUIRE_FAILED() - ACQUIRE_ERR() wrapper
>
> This one is correct style.
>
>> + * @claim: The claim variable passed to IIO_DEV_ACQUIRE_*_MODE()
>> + *
>> + * Return: true if failed to acquire the mode, otherwise false.
>> + */
>> +#define IIO_DEV_ACQUIRE_FAILED(claim) \
>> + ACQUIRE_ERR(__priv__iio_dev_mode_lock_try_direct, &(claim))
>> +
>> +/**
>> + * IIO_DEV_GUARD_CURRENT_MODE - Acquires the mode lock with automatic release
>
> Missing ()
Hi David,
I didn't see what you meant in the previous email. Sorry! I'll correct
it.
--
Thanks,
~ Kurt
© 2016 - 2026 Red Hat, Inc.