openthread_fuchsia/backing/
alarm.rs

Help
1// Copyright 2022 The Fuchsia Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5use super::*;
6use crate::Platform;
7use fuchsia_async as fasync;
8//use futures::channel::mpsc as fmpsc;
9use std::task::{Context, Poll};
10
11// Number of entries in the timer wakeup buffer.
12// This value was chosen somewhat arbitrarily, with the only
13// requirement being that it be larger than what should happen
14// during normal operation.
15const TIMER_BUFFER_LEN: usize = 20;
16
17pub(crate) struct AlarmInstance {
18    pub task_alarm: Cell<Option<fasync::Task<()>>>,
19    pub timer_sender: fmpsc::Sender<usize>,
20}
21
22impl AlarmInstance {
23    pub(crate) fn new() -> (AlarmInstance, fmpsc::Receiver<usize>) {
24        let (timer_sender, timer_receiver) = fmpsc::channel(TIMER_BUFFER_LEN);
25
26        (AlarmInstance { task_alarm: Cell::new(None), timer_sender }, timer_receiver)
27    }
28
29    fn on_alarm_milli_get_now(&self) -> u32 {
30        #[no_mangle]
31        unsafe extern "C" fn otPlatAlarmMilliGetNow() -> u32 {
32            // SAFETY: Must only be called from OpenThread thread,
33            PlatformBacking::as_ref().alarm.on_alarm_milli_get_now()
34        }
35        (zx::MonotonicInstant::get() - zx::MonotonicInstant::ZERO).into_millis() as u32
36    }
37
38    fn on_time_get(&self) -> u64 {
39        #[no_mangle]
40        unsafe extern "C" fn otPlatTimeGet() -> u64 {
41            // SAFETY: Must only be called from OpenThread thread,
42            PlatformBacking::as_ref().alarm.on_time_get()
43        }
44        (zx::MonotonicInstant::get() - zx::MonotonicInstant::ZERO).into_micros() as u64
45    }
46
47    fn on_alarm_milli_start_at(&self, instance: Option<&ot::Instance>, t0: u32, dt: u32) {
48        #[no_mangle]
49        unsafe extern "C" fn otPlatAlarmMilliStartAt(
50            instance: *mut otsys::otInstance,
51            t0: u32,
52            dt: u32,
53        ) {
54            AlarmInstance::on_alarm_milli_start_at(
55                // SAFETY: Must only be called from OpenThread thread,
56                &PlatformBacking::as_ref().alarm,
57                // SAFETY: `instance` must be a pointer to a valid `otInstance`
58                ot::Instance::ref_from_ot_ptr(instance),
59                t0,
60                dt,
61            )
62        }
63
64        trace!(
65            tag = "alarm";
66            "on_alarm_milli_start_at: scheduling alarm for {:?}ms after {:?}",
67            dt,
68            t0
69        );
70
71        let ot_instance_ptrval =
72            instance.map(ot::Boxable::as_ot_ptr).map(|x| x as usize).unwrap_or(0usize);
73        let mut timer_sender = self.timer_sender.clone();
74
75        let future = async move {
76            let now_in_millis =
77                (zx::MonotonicInstant::get() - zx::MonotonicInstant::ZERO).into_millis() as u32;
78            let offset = ((now_in_millis - t0) as i32).min(0) as u32;
79            let duration = if offset <= dt {
80                Duration::from_millis((dt - offset) as u64)
81            } else {
82                Duration::ZERO
83            };
84            trace!(
85                tag = "alarm";
86                "on_alarm_milli_start_at: helper task now waiting {:?}",
87                duration
88            );
89            fasync::Timer::new(duration).await;
90            trace!(tag="alarm"; "on_alarm_milli_start_at: helper task finished waiting, now sending ot_instance_ptrval");
91            timer_sender.send(ot_instance_ptrval).await.unwrap();
92        };
93
94        // Make and spawn a helper task that waits for the duration
95        // and then puts the pointer value into the timer sender channel.
96        // The receiver end of the channel is being serviced by Platform::process_poll,
97        // which makes sure that the timer callback gets fired on the main
98        // thread. The previous alarm task, if any, is cancelled.
99        self.task_alarm.set(Some(fasync::Task::spawn(future)));
100    }
101
102    fn on_alarm_milli_stop(&self, _instance: Option<&ot::Instance>) {
103        #[no_mangle]
104        unsafe extern "C" fn otPlatAlarmMilliStop(instance: *mut otsys::otInstance) {
105            AlarmInstance::on_alarm_milli_stop(
106                // SAFETY: Must only be called from OpenThread thread,
107                &PlatformBacking::as_ref().alarm,
108                // SAFETY: `instance` must be a pointer to a valid `otInstance`
109                ot::Instance::ref_from_ot_ptr(instance),
110            )
111        }
112
113        if self.task_alarm.take().is_some() {
114            trace!(tag = "alarm"; "on_alarm_milli_stop: Alarm cancelled");
115        }
116    }
117
118    fn on_alarm_fired(&self, instance: &ot::Instance, value: usize) {
119        trace!(tag = "alarm"; "on_alarm_fired");
120
121        let instance_ptr = instance.as_ot_ptr();
122        assert_eq!(instance_ptr as usize, value, "Got wrong pointer from timer receiver");
123
124        // SAFETY: Must be called with a valid pointer to otInstance,
125        //         must also only be called from the main OpenThread thread,
126        //         which is a guarantee of this method.
127        unsafe {
128            if otsys::otPlatDiagModeGet() {
129                otsys::otPlatDiagAlarmFired(instance_ptr);
130            }
131
132            otsys::otPlatAlarmMilliFired(instance_ptr);
133        }
134    }
135}
136
137impl Platform {
138    pub(crate) fn process_poll_alarm(&mut self, instance: &ot::Instance, cx: &mut Context<'_>) {
139        while let Poll::Ready(Some(value)) = self.timer_receiver.poll_next_unpin(cx) {
140            // SAFETY: Guaranteed to only be called from the OpenThread thread.
141            unsafe { PlatformBacking::as_ref() }.alarm.on_alarm_fired(instance, value);
142        }
143    }
144}
openthread_fuchsia/backing/alarm.rs

openthread_fuchsia/backing/
alarm.rs
