Module hrtimer

Intrusive high resolution timers.

Allows running timer callbacks without doing allocations at the time of starting the timer. For now, only one timer per type is allowed.

Vocabulary

States:

• Stopped: initialized but not started, or cancelled, or not restarted.
• Started: initialized and started or restarted.
• Running: executing the callback.

Operations:

• Start
• Cancel
• Restart

Events:

• Expire

State Diagram

                                                  Return NoRestart
                      +---------------------------------------------------------------------+
                      |                                                                     |
                      |                                                                     |
                      |                                                                     |
                      |                                         Return Restart              |
                      |                                      +------------------------+     |
                      |                                      |                        |     |
                      |                                      |                        |     |
                      v                                      v                        |     |
          +-----------------+      Start      +------------------+           +--------+-----+--+
          |                 +---------------->|                  |           |                 |
Init      |                 |                 |                  |  Expire   |                 |
--------->|    Stopped      |                 |      Started     +---------->|     Running     |
          |                 |     Cancel      |                  |           |                 |
          |                 |<----------------+                  |           |                 |
          +-----------------+                 +---------------+--+           +-----------------+
                                                    ^         |
                                                    |         |
                                                    +---------+
                                                     Restart

A timer is initialized in the stopped state. A stopped timer can be started by the start operation, with an expiry time. After the start operation, the timer is in the started state. When the timer expires, the timer enters the running state and the handler is executed. After the handler has returned, the timer may enter the *started or stopped state, depending on the return value of the handler. A timer in the started or running state may be canceled by the cancel operation. A timer that is cancelled enters the stopped state.

A cancel or restart operation on a timer in the running state takes effect after the handler has returned and the timer has transitioned out of the running state.

A restart operation on a timer in the stopped state is equivalent to a start operation.

Structs

AbsoluteHardMode

Timer with absolute expiration, handled in hard irq context.

AbsoluteMode

Timer that expires at a fixed point in time.

AbsolutePinnedHardMode

Timer with absolute expiration, pinned to CPU and handled in hard irq context.

AbsolutePinnedMode

Timer with absolute expiration time, pinned to its current CPU.

AbsolutePinnedSoftMode

Timer with absolute expiration, pinned to CPU and handled in soft irq context.

AbsoluteSoftMode

Timer with absolute expiration, handled in soft irq context.

ArcHrTimerHandle

A handle for an Arc<HasHrTimer<T>> returned by a call to HrTimerPointer::start.

BoxHrTimerHandle

A handle for a Box<HasHrTimer<T>> returned by a call to HrTimerPointer::start.

HrTimer

A timer backed by a C struct hrtimer.

PinHrTimerHandle

A handle for a Pin<&HasHrTimer>. When the handle exists, the timer might be running.

PinMutHrTimerHandle

A handle for a Pin<&mut HasHrTimer>. When the handle exists, the timer might be running.

RelativeHardMode

Timer with relative expiration, handled in hard irq context.

RelativeMode

Timer that expires after a delay from now.

RelativePinnedHardMode

Timer with relative expiration, pinned to CPU and handled in hard irq context.

RelativePinnedMode

Timer with relative expiration time, pinned to its current CPU.

RelativePinnedSoftMode

Timer with absolute expiration, pinned to CPU and handled in soft irq context.

RelativeSoftMode

Timer with relative expiration, handled in soft irq context.

Enums

HrTimerRestart

Restart policy for timers.

Traits

HasHrTimer

Implemented by structs that contain timer nodes.

HrTimerCallback

Implemented by structs that can be the target of a timer callback.

HrTimerExpires

Time representations that can be used as expiration values in HrTimer.

HrTimerHandle

A handle representing a potentially running timer.

HrTimerMode

Operational mode of HrTimer.

HrTimerPointer

Implemented by pointer types that point to structs that contain a HrTimer.

RawHrTimerCallback

Implemented by HrTimerPointer implementers to give the C timer callback a function to call.

ScopedHrTimerPointer

A trait for stack allocated timers.

UnsafeHrTimerPointer

Unsafe version of HrTimerPointer for situations where leaking the HrTimerHandle returned by start would be unsound. This is the case for stack allocated timers.