* [PATCH v2] i2c: i801: Clamp adapter timeout to prevent system lockup
@ 2026-07-23 3:43 Mingyu Wang
2026-07-24 22:44 ` Andi Shyti
0 siblings, 1 reply; 4+ messages in thread
From: Mingyu Wang @ 2026-07-23 3:43 UTC (permalink / raw)
To: jdelvare, andi.shyti
Cc: djkurtz, hkallweit1, wsa, linux-i2c, linux-kernel, stable, Mingyu Wang
Userspace applications with access to /dev/i2c-* can use the I2C_TIMEOUT
ioctl to manipulate the adap->timeout value. In the i2c-i801 driver,
this user-controlled timeout is used directly in both the interrupt
waiting paths (wait_for_completion_timeout) and the polling loops
(time_after(jiffies, timeout)).
If a malicious or arbitrarily large timeout value is injected from
userspace, and the hardware (or an emulated device in a fuzzing/VM
environment) fails to respond, the driver will block for the entirety
of that requested timeout while holding the i2c adapter's rt_mutex.
In IRQ mode, the task sleeps in wait_for_completion_timeout() in the
TASK_UNINTERRUPTIBLE (D) state for the entire duration, directly triggering
the khungtaskd watchdog if the timeout exceeds 120 seconds. In polling
mode, the endless usleep_range() loop keeps the rt_mutex locked permanently.
Consequently, any other processes attempting to acquire the i2c adapter
lock will be starved in TASK_UNINTERRUPTIBLE, which inevitably triggers
Hung Task panics as well.
Fix this by introducing i801_get_timeout(), which clamps the timeout
to a maximum of HZ (1 second). This is safe and strictly necessary:
1. Normal operations complete in milliseconds and are unaffected by
this ceiling. The timeout is only consumed during hardware failures.
2. Per the SMBus 2.0 specification, the maximum clock low timeout
(tTIMEOUT) is 25-35 ms. A 1-second clamp provides immense headroom
(orders of magnitude) for legitimate transactions while decisively
preventing prolonged rt_mutex lock contention and D-state lockups.
Fixes: 1de93d5d5217 ("i2c: i801: Replace waitqueue with completion API")
Cc: stable@vger.kernel.org
Signed-off-by: Mingyu Wang <25181214217@stu.xidian.edu.cn>
---
Changes in v2:
- Kept the 1-second (HZ) clamp but completely rewrote the commit message
to provide a bulletproof justification based on the SMBus 2.0 hardware
specification. This addresses the automated review concerns about
potentially breaking legitimate slow devices, proving that HZ is actually
orders of magnitude larger than the strictly required 35ms tTIMEOUT.
- Removed the unused 'adap' variable to prevent [-Wunused-variable] warnings.
drivers/i2c/busses/i2c-i801.c | 19 +++++++++++++------
1 file changed, 13 insertions(+), 6 deletions(-)
diff --git a/drivers/i2c/busses/i2c-i801.c b/drivers/i2c/busses/i2c-i801.c
index b29c99ed3883..f60ecf1071ff 100644
--- a/drivers/i2c/busses/i2c-i801.c
+++ b/drivers/i2c/busses/i2c-i801.c
@@ -345,10 +345,19 @@ MODULE_PARM_DESC(disable_features, "Disable selected driver features:\n"
"\t\t 0x10 don't use interrupts\n"
"\t\t 0x20 disable SMBus Host Notify ");
+/*
+ * Bound the maximum wait time to prevent system lockup if the
+ * userspace passes an arbitrarily large timeout via ioctl.
+ */
+static inline unsigned long i801_get_timeout(struct i801_priv *priv)
+{
+ return min_t(unsigned long, priv->adapter.timeout, HZ);
+}
+
/* Wait for BUSY being cleared and either INTR or an error flag being set */
static int i801_wait_intr(struct i801_priv *priv)
{
- unsigned long timeout = jiffies + priv->adapter.timeout;
+ unsigned long timeout = jiffies + i801_get_timeout(priv);
int status, busy;
do {
@@ -366,7 +375,7 @@ static int i801_wait_intr(struct i801_priv *priv)
/* Wait for either BYTE_DONE or an error flag being set */
static int i801_wait_byte_done(struct i801_priv *priv)
{
- unsigned long timeout = jiffies + priv->adapter.timeout;
+ unsigned long timeout = jiffies + i801_get_timeout(priv);
int status;
do {
@@ -497,13 +506,12 @@ static int i801_check_post(struct i801_priv *priv, int status)
static int i801_transaction(struct i801_priv *priv, int xact)
{
unsigned long result;
- const struct i2c_adapter *adap = &priv->adapter;
if (priv->features & FEATURE_IRQ) {
reinit_completion(&priv->done);
iowrite8(xact | SMBHSTCNT_INTREN | SMBHSTCNT_START,
SMBHSTCNT(priv));
- result = wait_for_completion_timeout(&priv->done, adap->timeout);
+ result = wait_for_completion_timeout(&priv->done, i801_get_timeout(priv));
return result ? priv->status : -ETIMEDOUT;
}
@@ -677,7 +685,6 @@ static int i801_block_transaction_byte_by_byte(struct i801_priv *priv,
int smbcmd;
int status;
unsigned long result;
- const struct i2c_adapter *adap = &priv->adapter;
if (command == I2C_SMBUS_BLOCK_PROC_CALL)
return -EOPNOTSUPP;
@@ -706,7 +713,7 @@ static int i801_block_transaction_byte_by_byte(struct i801_priv *priv,
reinit_completion(&priv->done);
iowrite8(priv->cmd | SMBHSTCNT_START, SMBHSTCNT(priv));
- result = wait_for_completion_timeout(&priv->done, adap->timeout);
+ result = wait_for_completion_timeout(&priv->done, i801_get_timeout(priv));
return result ? priv->status : -ETIMEDOUT;
}
--
2.34.1
^ permalink raw reply [flat|nested] 4+ messages in thread* Re: [PATCH v2] i2c: i801: Clamp adapter timeout to prevent system lockup
2026-07-23 3:43 [PATCH v2] i2c: i801: Clamp adapter timeout to prevent system lockup Mingyu Wang
@ 2026-07-24 22:44 ` Andi Shyti
2026-07-25 1:16 ` Mingyu Wang
0 siblings, 1 reply; 4+ messages in thread
From: Andi Shyti @ 2026-07-24 22:44 UTC (permalink / raw)
To: Mingyu Wang
Cc: jdelvare, djkurtz, hkallweit1, wsa, linux-i2c, linux-kernel, stable
Hi Mingyu,
On Thu, Jul 23, 2026 at 11:43:31AM +0800, Mingyu Wang wrote:
> Userspace applications with access to /dev/i2c-* can use the I2C_TIMEOUT
> ioctl to manipulate the adap->timeout value. In the i2c-i801 driver,
> this user-controlled timeout is used directly in both the interrupt
> waiting paths (wait_for_completion_timeout) and the polling loops
> (time_after(jiffies, timeout)).
>
> If a malicious or arbitrarily large timeout value is injected from
> userspace, and the hardware (or an emulated device in a fuzzing/VM
> environment) fails to respond, the driver will block for the entirety
> of that requested timeout while holding the i2c adapter's rt_mutex.
I am not convinced that we should fix this in the i801 driver.
Access to /dev/i2c-* is normally restricted to the administrator.
We cannot protect the kernel from every unreasonable value chosen
by a privileged user.
...
> Fix this by introducing i801_get_timeout(), which clamps the timeout
> to a maximum of HZ (1 second). This is safe and strictly necessary:
> 1. Normal operations complete in milliseconds and are unaffected by
> this ceiling. The timeout is only consumed during hardware failures.
> 2. Per the SMBus 2.0 specification, the maximum clock low timeout
> (tTIMEOUT) is 25-35 ms. A 1-second clamp provides immense headroom
The SMBus clock low timeout is not the maximum duration of a
complete transaction. It does not prove that one second is a
safe limit for every user.
The one second limit still looks arbitrary to me.
> (orders of magnitude) for legitimate transactions while decisively
> preventing prolonged rt_mutex lock contention and D-state lockups.
>
> Fixes: 1de93d5d5217 ("i2c: i801: Replace waitqueue with completion API")
This commit did not introduce the problem. It only replaced the
waitqueue with a completion. It looks like a convenient point in
the history rather than the actual commit that introduced the
"issue".
> Cc: stable@vger.kernel.org
> Signed-off-by: Mingyu Wang <25181214217@stu.xidian.edu.cn>
...
> +/*
> + * Bound the maximum wait time to prevent system lockup if the
> + * userspace passes an arbitrarily large timeout via ioctl.
> + */
> +static inline unsigned long i801_get_timeout(struct i801_priv *priv)
> +{
> + return min_t(unsigned long, priv->adapter.timeout, HZ);
This also silently ignores the timeout requested by userspace. A
user may request ten seconds and the ioctl will succeed, but the
driver will use only one second. There is no warning or other
indication that the value was clamped.
More generally, once a user has privileged access to a device
node, there are many ways to misuse the hardware. I do not think
adding arbitrary limits to individual drivers is the right way to
address that.
Thanks,
Andi
> +}
^ permalink raw reply [flat|nested] 4+ messages in thread* Re: [PATCH v2] i2c: i801: Clamp adapter timeout to prevent system lockup
2026-07-24 22:44 ` Andi Shyti
@ 2026-07-25 1:16 ` Mingyu Wang
2026-07-26 14:19 ` Andi Shyti
0 siblings, 1 reply; 4+ messages in thread
From: Mingyu Wang @ 2026-07-25 1:16 UTC (permalink / raw)
To: Andi Shyti
Cc: jdelvare, djkurtz, hkallweit1, wsa, linux-i2c, linux-kernel, stable
Hi Andi,
Thanks for the review.
I agree with your points. Silently clamping the timeout violates the
userspace API expectations, and adding arbitrary limits to restrict a
privileged user is indeed not the right approach.
I will drop this patch and handle the timeout constraints locally in my
testing environment.
Thanks for your time.
Best regards,
Mingyu Wang
^ permalink raw reply [flat|nested] 4+ messages in thread
end of thread, other threads:[~2026-07-26 14:19 UTC | newest]
Thread overview: 4+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2026-07-23 3:43 [PATCH v2] i2c: i801: Clamp adapter timeout to prevent system lockup Mingyu Wang
2026-07-24 22:44 ` Andi Shyti
2026-07-25 1:16 ` Mingyu Wang
2026-07-26 14:19 ` Andi Shyti
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox
all inboxes | Powered by JetHome®