Module kernel::time::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

• 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.

Enums

• HrTimerMode
  Operational mode of HrTimer.
• 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.
• HrTimerHandle
  A handle representing a potentially running timer.
• 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.