From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from mail-vs1-f53.google.com (mail-vs1-f53.google.com [209.85.217.53]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id B88F729B793 for ; Fri, 12 Dec 2025 02:45:43 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.217.53 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1765507546; cv=none; b=JUjnjYUVblgCKWi5b1/bxcQeORwzivcAjQODl+eSfOoWIZb03F1aA8RrG8wXGuW3LyVpURgMrVRVLtefAKjtrAteNPqi/g+xajZ7SBRlPkBjGfQnvrD9duoC1ldZh7SSx26tnVvcRDfpQh8PgeHpDc5asEnRTDM1zjuuFhw49i8= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1765507546; c=relaxed/simple; bh=6RuhgjKQZQBu1gVOM1UJ1b8RuzOWlkNhUsVE6an3+VI=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=DIx6N9/uhgdRlmTSzBpuSj2lvzy+JWoDE8mh8hiu3pcTsXL6yTsiPV5Cr/HelE0VbyBjeDWvtw2GGm3RnKkCRJRWr+BFdvVkX5TwLvWTWV4c4KsU1bo2l1vgWJf2osYxaQid1rzTcYS8KyLOD4zyJAO81Tn6dR+gKc9QLd3qwm0= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=Iz9eQ6Ft; arc=none smtp.client-ip=209.85.217.53 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="Iz9eQ6Ft" Received: by mail-vs1-f53.google.com with SMTP id ada2fe7eead31-5dbe6be1ac5so325368137.1 for ; Thu, 11 Dec 2025 18:45:43 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1765507542; x=1766112342; darn=vger.kernel.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:from:to:cc:subject:date:message-id :reply-to; bh=7teUlQNakpyBekbyBa3L6SiOmkc3TRpBucnHceeLxnk=; b=Iz9eQ6FtGkzEi4SWvsGCSS8oq+1MRfMrm04dUqbrlggExKoGM2GcPGFWdo/J0lDDo6 ZQ+H7OwNaRKvE/izDQgvU3G0bmgl0bRIOZ12d2YL4y6eRgw4DcFN7sTdyn/sZ1fe+Qbu tfU9uRRCmbqeBtNB2JzH+a7Mjv081nwoCLNU9kRWICcl7+12tUTP7h1Knz9DpDSR3V0O wPIfvdl6Y57mdMesyHi7LyPM03XRw8Jf2ewnc4RqSVAH9CAokjfpxv3pAvio/T4mJRhM uTNd3krzNapcvU8mGVu9KVLfbdV/jfAps2cdnM3qcL6Y3zckfA6I4LEGALY85z7c4fwg 61+Q== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1765507542; x=1766112342; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-gg:x-gm-message-state:from:to :cc:subject:date:message-id:reply-to; bh=7teUlQNakpyBekbyBa3L6SiOmkc3TRpBucnHceeLxnk=; b=UQT7ZWBbXlmwFVmDkQCBmAr2+aoNH2MwsTWCys0Dd7IHFr9dJfJdzJQuMvWXgLJzgY Sb39tnhv87HNcw+KAde0DOEDCpHsTbpX3ATMGg6u/hzl6425iOmtNIS60wP/c5jl8mVS PtM8r6XfIoMGLpbqmr3D+n2KcdKzSZ2+B5jy0ZQRS3QwdIYFJjqyXB592TH9qPA3vQ9y 9OKibGca1e/PoDYrXsemdOHT+OhtovChjtq+xwVGcKUZ19VuVTwpwYn5VlwDzFUV9xvH rqHYj7u3h5KClEslaRa+9PnYv0ePf0PZxlQ/YaC0rQAdvPmy31+zN4EfxV9/4h/qmc2o SxcQ== X-Forwarded-Encrypted: i=1; AJvYcCVDvUB30few3XsDG+2THn3Bp+KS3JYzIWwOAOQTi8D6cy2v/sMBMaMoP8+YxGeUgc125kgxKMoRynGavNs=@vger.kernel.org X-Gm-Message-State: AOJu0YycAuOZOk17H3NTIJlRKzdEQa949BYKRQYZhsd3A+hSPcxg7edd bU0m4p0UXsID0B6/Kt4IPhXHrPNMbR7z7rhSmWGv2hNNcIi93B0o5AT3jfjxAQ== X-Gm-Gg: AY/fxX5NO8ElyNM+uHiG6oYKxug2zK7W8XnkERgXWIAYMlsabERiQXi2xyUhBKfaEnp 93K1WrUpjLATRUD8EFYnUuStIX3xKcCbG9nkRElxhlGSQJoICpQLcKsa882BFlg6JKo3586lDSx fPCbAyCMWI4OCEq0CD8NtIDWv4U3NkozptHSJO5JQRRNJLxOEwrJqcPHnKTZGTQyDiCLUWVhqXi GaHLtpJdWTtMJxPRRXJtqjcHauKqa92xzBpVvP2uUYijuMV5uUbcsv58rQydZlx8gqC32J89hIk eeZmA+dywBLCGcTn+DzVwl/amKwC2OOwqYlmGz8YS3Yohg/roIL6wkRkjs9d+2picCUKV2fLUOB BrDKa5vdTNdTII2ggGuhqbMNGZlbbp3iWp5OCWAo45j8lu5lTEg72kY7MFfvVxZzd6oWWvPwsky Bb2DpV3EnhkB7b X-Google-Smtp-Source: AGHT+IFCbSwjQx+j26I4gFkKKi2c2VWed7wiEapgwj8ZJoFsVfh4kg25ChAQAYsyJ44hwmfrSbsVtw== X-Received: by 2002:a05:6102:94d:b0:5db:3cda:cc3b with SMTP id ada2fe7eead31-5e827835ad9mr109640137.34.1765507541686; Thu, 11 Dec 2025 18:45:41 -0800 (PST) Received: from [192.168.100.70] ([2800:bf0:82:3d2:875c:6c76:e06b:3095]) by smtp.gmail.com with ESMTPSA id ada2fe7eead31-5e7d0f25ce2sm1693762137.8.2025.12.11.18.45.39 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 11 Dec 2025 18:45:41 -0800 (PST) From: Kurt Borja Date: Thu, 11 Dec 2025 21:45:22 -0500 Subject: [PATCH v2 4/7] iio: core: Add cleanup.h support for iio_device_claim_*() Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: 7bit Message-Id: <20251211-lock-impr-v2-4-6fb47bdaaf24@gmail.com> References: <20251211-lock-impr-v2-0-6fb47bdaaf24@gmail.com> In-Reply-To: <20251211-lock-impr-v2-0-6fb47bdaaf24@gmail.com> To: Andy Shevchenko , Lars-Peter Clausen , Michael Hennerich , Jonathan Cameron , Benson Leung , Antoniu Miclaus , Gwendal Grignou , Shrikant Raskar , Per-Daniel Olsson Cc: David Lechner , =?utf-8?q?Nuno_S=C3=A1?= , Andy Shevchenko , Guenter Roeck , Jonathan Cameron , linux-iio@vger.kernel.org, linux-kernel@vger.kernel.org, chrome-platform@lists.linux.dev, Kurt Borja X-Mailer: b4 0.14.3 X-Developer-Signature: v=1; a=openpgp-sha256; l=4071; i=kuurtb@gmail.com; h=from:subject:message-id; bh=6RuhgjKQZQBu1gVOM1UJ1b8RuzOWlkNhUsVE6an3+VI=; b=owGbwMvMwCUmluBs8WX+lTTG02pJDJnWjSc/Hl3I+GE9k2n2i5kNa865/P+6+/tGXw6FlycLw jQLr7bydZSyMIhxMciKKbK0Jyz69igq763fgdD7MHNYmUCGMHBxCsBEJnxjZNixR9ri+uLDqi0N LAdafz789yXIbGnsF9nHl3sDpNiYjQIYGY6cbI257HOhf+2N1YdvT3Zi1Gz7z3LD/Q33evbQ7F6 B6ywA X-Developer-Key: i=kuurtb@gmail.com; a=openpgp; fpr=54D3BE170AEF777983C3C63B57E3B6585920A69A 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 Signed-off-by: Kurt Borja --- include/linux/iio/iio.h | 83 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 83 insertions(+) diff --git a/include/linux/iio/iio.h b/include/linux/iio/iio.h index f8a7ef709210..c84853c7a37f 100644 --- a/include/linux/iio/iio.h +++ b/include/linux/iio/iio.h @@ -10,6 +10,7 @@ #include #include #include +#include #include #include #include @@ -739,6 +740,88 @@ static inline void iio_device_release_buffer_mode(struct iio_dev *indio_dev) __iio_dev_mode_unlock(indio_dev); } +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_buffer, + iio_device_claim_buffer_mode(_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 + * @_var: Dummy 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:: + * + * IIO_DEV_ACQUIRE_DIRECT_MODE(indio_dev, claim); + * if (IIO_DEV_ACQUIRE_ERR(&claim)) + * return -EBUSY; + * + * ...or a more common scenario (notice scope the braces):: + * + * switch() { + * case IIO_CHAN_INFO_RAW: { + * IIO_DEV_ACQUIRE_DIRECT_MODE(indio_dev, claim); + * if (IIO_DEV_ACQUIRE_ERR(&claim)) + * return -EBUSY; + * + * ... + * } + * case IIO_CHAN_INFO_SCALE: + * ... + * ... + * } + * + * Context: Can sleep + */ +#define IIO_DEV_ACQUIRE_DIRECT_MODE(_dev, _var) \ + ACQUIRE(__priv__iio_dev_mode_lock_try_direct, _var)(_dev) + +/** + * IIO_DEV_ACQUIRE_BUFFER_MODE(_dev, _var) - Tries to acquire the buffer mode + * lock with automatic release + * @_dev: IIO device instance + * @_var: Dummy variable identifier to store acquire result + * + * Tries to acquire the direct mode lock and automatically releases it at the + * end of the scope. It most be paired with IIO_DEV_ACQUIRE_ERR(), for example:: + * + * IIO_DEV_ACQUIRE_BUFFER_MODE(indio_dev, claim); + * if (IIO_DEV_ACQUIRE_ERR(&claim)) + * return IRQ_HANDLED; + * + * Context: Can sleep + */ +#define IIO_DEV_ACQUIRE_BUFFER_MODE(_dev, _var) \ + ACQUIRE(__priv__iio_dev_mode_lock_try_buffer, _var)(_dev) + +/** + * IIO_DEV_ACQUIRE_ERR() - ACQUIRE_ERR() wrapper + * @_var: Dummy variable passed to IIO_DEV_ACQUIRE_*_MODE() + * + * Return: true on success, false on error + */ +#define IIO_DEV_ACQUIRE_ERR(_var_ptr) \ + ACQUIRE_ERR(__priv__iio_dev_mode_lock_try_buffer, _var_ptr) + +/** + * IIO_DEV_GUARD_ANY_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. + */ +#define IIO_DEV_GUARD_ANY_MODE(_dev) \ + guard(__priv__iio_dev_mode_lock)(_dev) + extern const struct bus_type iio_bus_type; /** -- 2.52.0