[v10,7/8] rust: Add read_poll_timeout functions

Commit Message

FUJITA Tomonori Feb. 7, 2025, 1:26 p.m. UTC

Add read_poll_timeout functions which poll periodically until a
condition is met or a timeout is reached.

The C's read_poll_timeout (include/linux/iopoll.h) is a complicated
macro and a simple wrapper for Rust doesn't work. So this implements
the same functionality in Rust.

The C version uses usleep_range() while the Rust version uses
fsleep(), which uses the best sleep method so it works with spans that
usleep_range() doesn't work nicely with.

Unlike the C version, __might_sleep() is used instead of might_sleep()
to show proper debug info; the file name and line
number. might_resched() could be added to match what the C version
does but this function works without it.

The sleep_before_read argument isn't supported since there is no user
for now. It's rarely used in the C version.

read_poll_timeout() can only be used in a nonatomic context. This
requirement is not checked by these abstractions, but it is intended
that klint [1] or a similar tool will be used to check it in the
future.

Link: https://rust-for-linux.com/klint [1]
Signed-off-by: FUJITA Tomonori <[e-mail]>
---
 rust/helpers/helpers.c |  1 +
 rust/helpers/kernel.c  | 13 +++++++
 rust/kernel/cpu.rs     | 13 +++++++
 rust/kernel/error.rs   |  1 +
 rust/kernel/io.rs      |  2 ++
 rust/kernel/io/poll.rs | 78 ++++++++++++++++++++++++++++++++++++++++++
 rust/kernel/lib.rs     |  1 +
 7 files changed, 109 insertions(+)
 create mode 100644 rust/helpers/kernel.c
 create mode 100644 rust/kernel/cpu.rs
 create mode 100644 rust/kernel/io/poll.rs

Comments

Daniel Almeida Feb. 8, 2025, 1:50 a.m. UTC | #1

Hi,

> +
> +/// Polls periodically until a condition is met or a timeout is reached.
> +///
> +/// ```rust
> +/// use kernel::io::poll::read_poll_timeout;
> +/// use kernel::time::Delta;
> +/// use kernel::sync::{SpinLock, new_spinlock};
> +///
> +/// let lock = KBox::pin_init(new_spinlock!(()), kernel::alloc::flags::GFP_KERNEL)?;
> +/// let g = lock.lock();
> +/// read_poll_timeout(|| Ok(()), |()| true, Delta::from_micros(42), Some(Delta::from_micros(42)));
> +/// drop(g);
> +///
> +/// # Ok::<(), Error>(())

IMHO, the example section here needs to be improved.

> +/// ```
> +#[track_caller]
> +pub fn read_poll_timeout<Op, Cond, T>(
> +    mut op: Op,
> +    mut cond: Cond,
> +    sleep_delta: Delta,
> +    timeout_delta: Option<Delta>,
> +) -> Result<T>
> +where
> +    Op: FnMut() -> Result<T>,
> +    Cond: FnMut(&T) -> bool,
> +{
> +    let start = Instant::now();
> +    let sleep = !sleep_delta.is_zero();
> +
> +    if sleep {
> +        might_sleep(Location::caller());
> +    }
> +
> +    loop {
> +        let val = op()?;

I.e.: it’s not clear that `op` computes `val` until you read this.

> +        if cond(&val) {

It’s a bit unclear how `cond` works, until you see this line here.

It’s even more important to explain this a tad better, since it differs slightly from the C API.

Also, it doesn’t help that `Op` and `Cond` take and return the unit type in the
only example provided.

— Daniel

Gary Guo Feb. 9, 2025, 4:20 p.m. UTC | #2

On Fri,  7 Feb 2025 22:26:22 +0900
FUJITA Tomonori <[e-mail]> wrote:

> Add read_poll_timeout functions which poll periodically until a
> condition is met or a timeout is reached.
> 
> The C's read_poll_timeout (include/linux/iopoll.h) is a complicated
> macro and a simple wrapper for Rust doesn't work. So this implements
> the same functionality in Rust.
> 
> The C version uses usleep_range() while the Rust version uses
> fsleep(), which uses the best sleep method so it works with spans that
> usleep_range() doesn't work nicely with.
> 
> Unlike the C version, __might_sleep() is used instead of might_sleep()
> to show proper debug info; the file name and line
> number. might_resched() could be added to match what the C version
> does but this function works without it.
> 
> The sleep_before_read argument isn't supported since there is no user
> for now. It's rarely used in the C version.
> 
> read_poll_timeout() can only be used in a nonatomic context. This
> requirement is not checked by these abstractions, but it is intended
> that klint [1] or a similar tool will be used to check it in the
> future.
> 
> Link: https://rust-for-linux.com/klint [1]
> Signed-off-by: FUJITA Tomonori <[e-mail]>
> ---
>  rust/helpers/helpers.c |  1 +
>  rust/helpers/kernel.c  | 13 +++++++
>  rust/kernel/cpu.rs     | 13 +++++++
>  rust/kernel/error.rs   |  1 +
>  rust/kernel/io.rs      |  2 ++
>  rust/kernel/io/poll.rs | 78 ++++++++++++++++++++++++++++++++++++++++++
>  rust/kernel/lib.rs     |  1 +
>  7 files changed, 109 insertions(+)
>  create mode 100644 rust/helpers/kernel.c
>  create mode 100644 rust/kernel/cpu.rs
>  create mode 100644 rust/kernel/io/poll.rs
> 
> diff --git a/rust/helpers/helpers.c b/rust/helpers/helpers.c
> index 9565485a1a54..16d256897ccb 100644
> --- a/rust/helpers/helpers.c
> +++ b/rust/helpers/helpers.c
> @@ -14,6 +14,7 @@
>  #include "cred.c"
>  #include "device.c"
>  #include "err.c"
> +#include "kernel.c"
>  #include "fs.c"
>  #include "io.c"
>  #include "jump_label.c"
> diff --git a/rust/helpers/kernel.c b/rust/helpers/kernel.c
> new file mode 100644
> index 000000000000..9dff28f4618e
> --- /dev/null
> +++ b/rust/helpers/kernel.c
> @@ -0,0 +1,13 @@
> +// SPDX-License-Identifier: GPL-2.0
> +
> +#include <linux/kernel.h>
> +
> +void rust_helper_cpu_relax(void)
> +{
> +	cpu_relax();
> +}
> +
> +void rust_helper___might_sleep_precision(const char *file, int len, int line)
> +{
> +	__might_sleep_precision(file, len, line);
> +}
> diff --git a/rust/kernel/cpu.rs b/rust/kernel/cpu.rs
> new file mode 100644
> index 000000000000..eeeff4be84fa
> --- /dev/null
> +++ b/rust/kernel/cpu.rs
> @@ -0,0 +1,13 @@
> +// SPDX-License-Identifier: GPL-2.0
> +
> +//! Processor related primitives.
> +//!
> +//! C header: [`include/linux/processor.h`](srctree/include/linux/processor.h).
> +
> +/// Lower CPU power consumption or yield to a hyperthreaded twin processor.
> +///
> +/// It also happens to serve as a compiler barrier.
> +pub fn cpu_relax() {
> +    // SAFETY: FFI call.
> +    unsafe { bindings::cpu_relax() }
> +}
> diff --git a/rust/kernel/error.rs b/rust/kernel/error.rs
> index f6ecf09cb65f..8858eb13b3df 100644
> --- a/rust/kernel/error.rs
> +++ b/rust/kernel/error.rs
> @@ -64,6 +64,7 @@ macro_rules! declare_err {
>      declare_err!(EPIPE, "Broken pipe.");
>      declare_err!(EDOM, "Math argument out of domain of func.");
>      declare_err!(ERANGE, "Math result not representable.");
> +    declare_err!(ETIMEDOUT, "Connection timed out.");
>      declare_err!(ERESTARTSYS, "Restart the system call.");
>      declare_err!(ERESTARTNOINTR, "System call was interrupted by a signal and will be restarted.");
>      declare_err!(ERESTARTNOHAND, "Restart if no handler.");
> diff --git a/rust/kernel/io.rs b/rust/kernel/io.rs
> index d4a73e52e3ee..be63742f517b 100644
> --- a/rust/kernel/io.rs
> +++ b/rust/kernel/io.rs
> @@ -7,6 +7,8 @@
>  use crate::error::{code::EINVAL, Result};
>  use crate::{bindings, build_assert};
>  
> +pub mod poll;
> +
>  /// Raw representation of an MMIO region.
>  ///
>  /// By itself, the existence of an instance of this structure does not provide any guarantees that
> diff --git a/rust/kernel/io/poll.rs b/rust/kernel/io/poll.rs
> new file mode 100644
> index 000000000000..bed5b693402e
> --- /dev/null
> +++ b/rust/kernel/io/poll.rs
> @@ -0,0 +1,78 @@
> +// SPDX-License-Identifier: GPL-2.0
> +
> +//! IO polling.
> +//!
> +//! C header: [`include/linux/iopoll.h`](srctree/include/linux/iopoll.h).
> +
> +use crate::{
> +    cpu::cpu_relax,
> +    error::{code::*, Result},
> +    time::{delay::fsleep, Delta, Instant},
> +};
> +
> +use core::panic::Location;
> +
> +/// Polls periodically until a condition is met or a timeout is reached.
> +///
> +/// ```rust
> +/// use kernel::io::poll::read_poll_timeout;
> +/// use kernel::time::Delta;
> +/// use kernel::sync::{SpinLock, new_spinlock};
> +///
> +/// let lock = KBox::pin_init(new_spinlock!(()), kernel::alloc::flags::GFP_KERNEL)?;
> +/// let g = lock.lock();
> +/// read_poll_timeout(|| Ok(()), |()| true, Delta::from_micros(42), Some(Delta::from_micros(42)));
> +/// drop(g);
> +///
> +/// # Ok::<(), Error>(())
> +/// ```
> +#[track_caller]
> +pub fn read_poll_timeout<Op, Cond, T>(
> +    mut op: Op,
> +    mut cond: Cond,
> +    sleep_delta: Delta,
> +    timeout_delta: Option<Delta>,
> +) -> Result<T>
> +where
> +    Op: FnMut() -> Result<T>,
> +    Cond: FnMut(&T) -> bool,
> +{
> +    let start = Instant::now();
> +    let sleep = !sleep_delta.is_zero();
> +
> +    if sleep {
> +        might_sleep(Location::caller());
> +    }
> +
> +    loop {
> +        let val = op()?;
> +        if cond(&val) {
> +            // Unlike the C version, we immediately return.
> +            // We know the condition is met so we don't need to check again.
> +            return Ok(val);
> +        }
> +        if let Some(timeout_delta) = timeout_delta {
> +            if start.elapsed() > timeout_delta {
> +                // Unlike the C version, we immediately return.
> +                // We have just called `op()` so we don't need to call it again.
> +                return Err(ETIMEDOUT);
> +            }
> +        }
> +        if sleep {
> +            fsleep(sleep_delta);
> +        }
> +        // fsleep() could be busy-wait loop so we always call cpu_relax().
> +        cpu_relax();
> +    }
> +}
> +
> +fn might_sleep(loc: &Location<'_>) {
> +    // SAFETY: FFI call.
> +    unsafe {
> +        crate::bindings::__might_sleep_precision(
> +            loc.file().as_ptr().cast(),
> +            loc.file().len() as i32,
> +            loc.line() as i32,
> +        )
> +    }
> +}

One last Q: why isn't `might_sleep` marked as `track_caller` and then
have `Location::caller` be called internally?

It would make the API same as the C macro.

Also -- perhaps this function can be public (though I guess you'd need
to put it in a new module).

Best,
Gary

> diff --git a/rust/kernel/lib.rs b/rust/kernel/lib.rs
> index 496ed32b0911..415c500212dd 100644
> --- a/rust/kernel/lib.rs
> +++ b/rust/kernel/lib.rs
> @@ -40,6 +40,7 @@
>  pub mod block;
>  #[doc(hidden)]
>  pub mod build_assert;
> +pub mod cpu;
>  pub mod cred;
>  pub mod device;
>  pub mod device_id;

FUJITA Tomonori Feb. 14, 2025, 4:05 a.m. UTC | #3

On Sun, 9 Feb 2025 16:20:48 +0000
Gary Guo <[e-mail]> wrote:

>> +fn might_sleep(loc: &Location<'_>) {
>> +    // SAFETY: FFI call.
>> +    unsafe {
>> +        crate::bindings::__might_sleep_precision(
>> +            loc.file().as_ptr().cast(),
>> +            loc.file().len() as i32,
>> +            loc.line() as i32,
>> +        )
>> +    }
>> +}
> 
> One last Q: why isn't `might_sleep` marked as `track_caller` and then
> have `Location::caller` be called internally?
>
> It would make the API same as the C macro.

Equivalent to the C side __might_sleep(), not might_sleep(). To avoid
confusion, it might be better to change the name of this function.

The reason why __might_sleep() is used instead of might_sleep() is
might_sleep() can't always be called. It was discussed in v2:

https://lore.kernel.org/all/ZwPT7HZvG1aYONkQ@boqun-archlinux/

> Also -- perhaps this function can be public (though I guess you'd need
> to put it in a new module).

Wouldn't it be better to keep it private until actual users appear?

FUJITA Tomonori Feb. 14, 2025, 4:13 a.m. UTC | #4

On Fri, 7 Feb 2025 22:50:37 -0300
Daniel Almeida <[e-mail]> wrote:

>> +/// Polls periodically until a condition is met or a timeout is reached.
>> +///
>> +/// ```rust
>> +/// use kernel::io::poll::read_poll_timeout;
>> +/// use kernel::time::Delta;
>> +/// use kernel::sync::{SpinLock, new_spinlock};
>> +///
>> +/// let lock = KBox::pin_init(new_spinlock!(()), kernel::alloc::flags::GFP_KERNEL)?;
>> +/// let g = lock.lock();
>> +/// read_poll_timeout(|| Ok(()), |()| true, Delta::from_micros(42), Some(Delta::from_micros(42)));
>> +/// drop(g);
>> +///
>> +/// # Ok::<(), Error>(())
> 
> IMHO, the example section here needs to be improved.

Do you have any specific ideas?

Generally, this function is used to wait for the hardware to be
ready. So I can't think of a nice example.


>> +/// ```
>> +#[track_caller]
>> +pub fn read_poll_timeout<Op, Cond, T>(
>> +    mut op: Op,
>> +    mut cond: Cond,
>> +    sleep_delta: Delta,
>> +    timeout_delta: Option<Delta>,
>> +) -> Result<T>
>> +where
>> +    Op: FnMut() -> Result<T>,
>> +    Cond: FnMut(&T) -> bool,
>> +{
>> +    let start = Instant::now();
>> +    let sleep = !sleep_delta.is_zero();
>> +
>> +    if sleep {
>> +        might_sleep(Location::caller());
>> +    }
>> +
>> +    loop {
>> +        let val = op()?;
> 
> I.e.: it’s not clear that `op` computes `val` until you read this.
> 
>> +        if cond(&val) {
> 
> It’s a bit unclear how `cond` works, until you see this line here.
> 
> It’s even more important to explain this a tad better, since it differs slightly from the C API.

ok, I'll try to add some docs in v11.

> Also, it doesn’t help that `Op` and `Cond` take and return the unit type in the
> only example provided.
> 
> ― Daniel
> 
>

Gary Guo Feb. 14, 2025, 11:37 a.m. UTC | #5

On Fri, 14 Feb 2025 13:05:30 +0900 (JST)
FUJITA Tomonori <[e-mail]> wrote:

> On Sun, 9 Feb 2025 16:20:48 +0000
> Gary Guo <[e-mail]> wrote:
> 
> >> +fn might_sleep(loc: &Location<'_>) {
> >> +    // SAFETY: FFI call.
> >> +    unsafe {
> >> +        crate::bindings::__might_sleep_precision(
> >> +            loc.file().as_ptr().cast(),
> >> +            loc.file().len() as i32,
> >> +            loc.line() as i32,
> >> +        )
> >> +    }
> >> +}  
> > 
> > One last Q: why isn't `might_sleep` marked as `track_caller` and then
> > have `Location::caller` be called internally?
> >
> > It would make the API same as the C macro.  
> 
> Equivalent to the C side __might_sleep(), not might_sleep(). To avoid
> confusion, it might be better to change the name of this function.
> 
> The reason why __might_sleep() is used instead of might_sleep() is
> might_sleep() can't always be called. It was discussed in v2:
> 
> https://lore.kernel.org/all/ZwPT7HZvG1aYONkQ@boqun-archlinux/

I don't follow. `__might_sleep` or `might_sleep` wouldn't make a
difference here, given that this function may actually sleep.

- Gary

> 
> > Also -- perhaps this function can be public (though I guess you'd need
> > to put it in a new module).  

> 
> Wouldn't it be better to keep it private until actual users appear?

FUJITA Tomonori Feb. 15, 2025, 9:48 a.m. UTC | #6

On Fri, 14 Feb 2025 11:37:40 +0000
Gary Guo <[e-mail]> wrote:

> On Fri, 14 Feb 2025 13:05:30 +0900 (JST)
> FUJITA Tomonori <[e-mail]> wrote:
> 
>> On Sun, 9 Feb 2025 16:20:48 +0000
>> Gary Guo <[e-mail]> wrote:
>> 
>> >> +fn might_sleep(loc: &Location<'_>) {
>> >> +    // SAFETY: FFI call.
>> >> +    unsafe {
>> >> +        crate::bindings::__might_sleep_precision(
>> >> +            loc.file().as_ptr().cast(),
>> >> +            loc.file().len() as i32,
>> >> +            loc.line() as i32,
>> >> +        )
>> >> +    }
>> >> +}  
>> > 
>> > One last Q: why isn't `might_sleep` marked as `track_caller` and then
>> > have `Location::caller` be called internally?
>> >
>> > It would make the API same as the C macro.  
>> 
>> Equivalent to the C side __might_sleep(), not might_sleep(). To avoid
>> confusion, it might be better to change the name of this function.
>> 
>> The reason why __might_sleep() is used instead of might_sleep() is
>> might_sleep() can't always be called. It was discussed in v2:
>> 
>> https://lore.kernel.org/all/ZwPT7HZvG1aYONkQ@boqun-archlinux/
> 
> I don't follow. `__might_sleep` or `might_sleep` wouldn't make a
> difference here, given that this function may actually sleep.

Yeah, it doesn't matter here. If I understand correctly, the
discussion is about whether might_sleep() itself should be unsafe
considering the case where it is called from other functions. I simply
chose uncontroversial __might_sleep().

After reviewing the code again, I realized that I made a mistake;
__might_sleep() should only be executed when CONFIG_DEBUG_ATOMIC_SLEEP
is enabled. I also think that it is confusing that might_sleep() calls
C's __might_sleep().

How about implementing the equivalent to might_sleep()?

/// Annotation for functions that can sleep.
///
/// Equivalent to the C side [`might_sleep()`], this function serves as
/// a debugging aid and a potential scheduling point.
///
/// This function can only be used in a nonatomic context.
#[track_caller]
fn might_sleep() {
    #[cfg(CONFIG_DEBUG_ATOMIC_SLEEP)]
    {
        let loc = core::panic::Location::caller();
	// SAFETY: FFI call.
	unsafe {
	    crate::bindings::__might_sleep_precision(
	        loc.file().as_ptr().cast(),
	        loc.file().len() as i32,
                loc.line() as i32,
	    )
	}
    }
    // SAFETY: FFI call.
    unsafe { crate::bindings::might_resched() }
}


>> > Also -- perhaps this function can be public (though I guess you'd need
>> > to put it in a new module).  
>> 
>> Wouldn't it be better to keep it private until actual users appear?

I'll make the above public if you think that is the better approach.

C's might_sleep() is defined in linux/kernel.h but kernel/kernel.rs
isn't a good choice, I guess. kernel/sched.rs or other options?

Daniel Almeida Feb. 16, 2025, 12:19 p.m. UTC | #7

Sorry, ended up replying privately by mistake, resending with everybody else on cc:

——————


> On 14 Feb 2025, at 01:13, FUJITA Tomonori <[e-mail]> wrote:
> 
> On Fri, 7 Feb 2025 22:50:37 -0300
> Daniel Almeida <[e-mail]> wrote:
> 
>>> +/// Polls periodically until a condition is met or a timeout is reached.
>>> +///
>>> +/// ```rust
>>> +/// use kernel::io::poll::read_poll_timeout;
>>> +/// use kernel::time::Delta;
>>> +/// use kernel::sync::{SpinLock, new_spinlock};
>>> +///
>>> +/// let lock = KBox::pin_init(new_spinlock!(()), kernel::alloc::flags::GFP_KERNEL)?;
>>> +/// let g = lock.lock();
>>> +/// read_poll_timeout(|| Ok(()), |()| true, Delta::from_micros(42), Some(Delta::from_micros(42)));
>>> +/// drop(g);
>>> +///
>>> +/// # Ok::<(), Error>(())
>> 
>> IMHO, the example section here needs to be improved.
> 
> Do you have any specific ideas?
> 
> Generally, this function is used to wait for the hardware to be
> ready. So I can't think of a nice example.

Just pretend that you’re polling some mmio address that indicates whether some hardware
block is ready, for example.

You can use “ignore” if you want, the example just has to illustrate how this function works, really.

Something like

```ignore
 /* R is a fictional type that abstracts a memory-mapped register where `read()` returns Result<u32> */
 fn wait_for_hardware(ready_register: R) {
     let op = || ready_register.read()?

     // `READY` is some device-specific constant that we are waiting for.
     let cond =  |value: &u32| { *value == READY }

     let res = io::poll::read_poll_timeout (/* fill this with the right arguments */);

     /* show how `res` works, is -ETIMEDOUT returned on Err? */

     match res {
       Ok(<what is here?>) => { /* hardware is ready */}
       Err(e) => { /* explain that *value != READY here? */ }

     /* sleep is Option<Delta>, how does this work? i.e.: show both None, and Some(…) with some comments. */
 } 
```

That’s just a rough draft, but I think it's going to be helpful for users.

— Daniel

FUJITA Tomonori Feb. 16, 2025, 10:50 p.m. UTC | #8

On Sun, 16 Feb 2025 09:19:02 -0300
Daniel Almeida <[e-mail]> wrote:

>>>> +/// Polls periodically until a condition is met or a timeout is reached.
>>>> +///
>>>> +/// ```rust
>>>> +/// use kernel::io::poll::read_poll_timeout;
>>>> +/// use kernel::time::Delta;
>>>> +/// use kernel::sync::{SpinLock, new_spinlock};
>>>> +///
>>>> +/// let lock = KBox::pin_init(new_spinlock!(()), kernel::alloc::flags::GFP_KERNEL)?;
>>>> +/// let g = lock.lock();
>>>> +/// read_poll_timeout(|| Ok(()), |()| true, Delta::from_micros(42), Some(Delta::from_micros(42)));
>>>> +/// drop(g);
>>>> +///
>>>> +/// # Ok::<(), Error>(())
>>> 
>>> IMHO, the example section here needs to be improved.
>> 
>> Do you have any specific ideas?
>> 
>> Generally, this function is used to wait for the hardware to be
>> ready. So I can't think of a nice example.
> 
> Just pretend that you’re polling some mmio address that indicates whether some hardware
> block is ready, for example.
> 
> You can use “ignore” if you want, the example just has to illustrate how this function works, really.

Ah, you use `ignore` comment. I was only considering examples that
would actually be tested.


> Something like
> 
> ```ignore
>  /* R is a fictional type that abstracts a memory-mapped register where `read()` returns Result<u32> */
>  fn wait_for_hardware(ready_register: R) {
>      let op = || ready_register.read()?
> 
>      // `READY` is some device-specific constant that we are waiting for.
>      let cond =  |value: &u32| { *value == READY }
> 
>      let res = io::poll::read_poll_timeout (/* fill this with the right arguments */);
> 
>      /* show how `res` works, is -ETIMEDOUT returned on Err? */
> 
>      match res {
>        Ok(<what is here?>) => { /* hardware is ready */}
>        Err(e) => { /* explain that *value != READY here? */ }
> 
>      /* sleep is Option<Delta>, how does this work? i.e.: show both None, and Some(…) with some comments. */
>  } 
> ```
> 
> That’s just a rough draft, but I think it's going to be helpful for users.

I'll add an example based on the code QT2025 PHY (8th patch). It's
similar to the above.

Thanks,

Patch

diff --git a/rust/helpers/helpers.c b/rust/helpers/helpers.c
index 9565485a1a54..16d256897ccb 100644
--- a/rust/helpers/helpers.c
+++ b/rust/helpers/helpers.c
@@ -14,6 +14,7 @@ 
 #include "cred.c"
 #include "device.c"
 #include "err.c"
+#include "kernel.c"
 #include "fs.c"
 #include "io.c"
 #include "jump_label.c"
diff --git a/rust/helpers/kernel.c b/rust/helpers/kernel.c
new file mode 100644
index 000000000000..9dff28f4618e
--- /dev/null
+++ b/rust/helpers/kernel.c
@@ -0,0 +1,13 @@ 
+// SPDX-License-Identifier: GPL-2.0
+
+#include <linux/kernel.h>
+
+void rust_helper_cpu_relax(void)
+{
+	cpu_relax();
+}
+
+void rust_helper___might_sleep_precision(const char *file, int len, int line)
+{
+	__might_sleep_precision(file, len, line);
+}
diff --git a/rust/kernel/cpu.rs b/rust/kernel/cpu.rs
new file mode 100644
index 000000000000..eeeff4be84fa
--- /dev/null
+++ b/rust/kernel/cpu.rs
@@ -0,0 +1,13 @@ 
+// SPDX-License-Identifier: GPL-2.0
+
+//! Processor related primitives.
+//!
+//! C header: [`include/linux/processor.h`](srctree/include/linux/processor.h).
+
+/// Lower CPU power consumption or yield to a hyperthreaded twin processor.
+///
+/// It also happens to serve as a compiler barrier.
+pub fn cpu_relax() {
+    // SAFETY: FFI call.
+    unsafe { bindings::cpu_relax() }
+}
diff --git a/rust/kernel/error.rs b/rust/kernel/error.rs
index f6ecf09cb65f..8858eb13b3df 100644
--- a/rust/kernel/error.rs
+++ b/rust/kernel/error.rs
@@ -64,6 +64,7 @@  macro_rules! declare_err {
     declare_err!(EPIPE, "Broken pipe.");
     declare_err!(EDOM, "Math argument out of domain of func.");
     declare_err!(ERANGE, "Math result not representable.");
+    declare_err!(ETIMEDOUT, "Connection timed out.");
     declare_err!(ERESTARTSYS, "Restart the system call.");
     declare_err!(ERESTARTNOINTR, "System call was interrupted by a signal and will be restarted.");
     declare_err!(ERESTARTNOHAND, "Restart if no handler.");
diff --git a/rust/kernel/io.rs b/rust/kernel/io.rs
index d4a73e52e3ee..be63742f517b 100644
--- a/rust/kernel/io.rs
+++ b/rust/kernel/io.rs
@@ -7,6 +7,8 @@ 
 use crate::error::{code::EINVAL, Result};
 use crate::{bindings, build_assert};
 
+pub mod poll;
+
 /// Raw representation of an MMIO region.
 ///
 /// By itself, the existence of an instance of this structure does not provide any guarantees that
diff --git a/rust/kernel/io/poll.rs b/rust/kernel/io/poll.rs
new file mode 100644
index 000000000000..bed5b693402e
--- /dev/null
+++ b/rust/kernel/io/poll.rs
@@ -0,0 +1,78 @@ 
+// SPDX-License-Identifier: GPL-2.0
+
+//! IO polling.
+//!
+//! C header: [`include/linux/iopoll.h`](srctree/include/linux/iopoll.h).
+
+use crate::{
+    cpu::cpu_relax,
+    error::{code::*, Result},
+    time::{delay::fsleep, Delta, Instant},
+};
+
+use core::panic::Location;
+
+/// Polls periodically until a condition is met or a timeout is reached.
+///
+/// ```rust
+/// use kernel::io::poll::read_poll_timeout;
+/// use kernel::time::Delta;
+/// use kernel::sync::{SpinLock, new_spinlock};
+///
+/// let lock = KBox::pin_init(new_spinlock!(()), kernel::alloc::flags::GFP_KERNEL)?;
+/// let g = lock.lock();
+/// read_poll_timeout(|| Ok(()), |()| true, Delta::from_micros(42), Some(Delta::from_micros(42)));
+/// drop(g);
+///
+/// # Ok::<(), Error>(())
+/// ```
+#[track_caller]
+pub fn read_poll_timeout<Op, Cond, T>(
+    mut op: Op,
+    mut cond: Cond,
+    sleep_delta: Delta,
+    timeout_delta: Option<Delta>,
+) -> Result<T>
+where
+    Op: FnMut() -> Result<T>,
+    Cond: FnMut(&T) -> bool,
+{
+    let start = Instant::now();
+    let sleep = !sleep_delta.is_zero();
+
+    if sleep {
+        might_sleep(Location::caller());
+    }
+
+    loop {
+        let val = op()?;
+        if cond(&val) {
+            // Unlike the C version, we immediately return.
+            // We know the condition is met so we don't need to check again.
+            return Ok(val);
+        }
+        if let Some(timeout_delta) = timeout_delta {
+            if start.elapsed() > timeout_delta {
+                // Unlike the C version, we immediately return.
+                // We have just called `op()` so we don't need to call it again.
+                return Err(ETIMEDOUT);
+            }
+        }
+        if sleep {
+            fsleep(sleep_delta);
+        }
+        // fsleep() could be busy-wait loop so we always call cpu_relax().
+        cpu_relax();
+    }
+}
+
+fn might_sleep(loc: &Location<'_>) {
+    // SAFETY: FFI call.
+    unsafe {
+        crate::bindings::__might_sleep_precision(
+            loc.file().as_ptr().cast(),
+            loc.file().len() as i32,
+            loc.line() as i32,
+        )
+    }
+}
diff --git a/rust/kernel/lib.rs b/rust/kernel/lib.rs
index 496ed32b0911..415c500212dd 100644
--- a/rust/kernel/lib.rs
+++ b/rust/kernel/lib.rs
@@ -40,6 +40,7 @@ 
 pub mod block;
 #[doc(hidden)]
 pub mod build_assert;
+pub mod cpu;
 pub mod cred;
 pub mod device;
 pub mod device_id;