Method now

clock-bound/src/client.rs:92–125

Read the current time, but with a bound on accuracy and a status. Returns a pair of (earliest, latest) timespec between which current time exists. The interval width is twice the clock error bound (ceb) such that: (earliest, latest) = ((now - ceb), (now + ceb)) The function also returns a clock status to assert that the clock is being synchronized, or free-running, or ... # Errors Returns [`Clo

(&mut self)

    /// # Errors
    /// Returns [`ClockBoundError`] if the shared memory segments cannot be open or accessed.
    pub fn now(&mut self) -> Result<ClockBoundNowResult, ClockBoundError> {
        // The very first thing to do is to read from the ClockBound shared memory segment, take a
        // snapshot to obtain the clock parameters and bound on error, and create a timestamp.
        let cb_snap = self.clockbound_shm.snapshot()?;
        let mut clock_bound_now_result = cb_snap.now()?;

        // Now that the timestamp is created, check whether the clockbound daemon has been
        // restarted and the option to enable the clock disruption support has been turned on. If
        // so, need to create a reader for the VMClock device shared memory.
        if self.vmclock_shm.vmclock_shm_reader.is_none()
            && cb_snap.clock_disruption_support_enabled()
        {
            self.vmclock_shm.vmclock_shm_reader = Some(VMClockShmReader::new(
                self.vmclock_shm.vmclock_shm_path.as_str(),
            )?);
        }

        // Check whether the clock is disrupted. If the support to capture the clock disruption
        // signal has been explicitly disabled, there is nothing to do. Otherwise, and if the
        // VMClock shared memory is successfully read, this compares the value of the disruption
        // marker between the clockbound daemon and the VMClock. If these disagree, a disruption
        // has occured, and the clockbound daemon has not recovered from it yet.
        let is_disrupted = match self.vmclock_shm.disruption_marker()? {
            Some(marker) => marker != cb_snap.disruption_marker(),
            None => false,
        };

        // If the clock is disrupted, overwrite the status
        if is_disrupted {
            clock_bound_now_result.clock_status = ClockStatus::Disrupted;
        }

        Ok(clock_bound_now_result)
    }
}

/// `ClockBoundSHM` handles access to the shared memory segment populated by the ClockBound daemon.