use crate::ClockError;
use rusty_time_core::refclock::{LeapWarning, RefclockSample};
#[cfg(unix)]
pub mod shm {
use super::*;
pub const SHM_KEY_BASE: i32 = 0x4E54_5030;
mod layout {
pub const MODE: usize = 0;
pub const COUNT: usize = 4;
pub const CLOCK_SEC: usize = 8;
pub const CLOCK_USEC: usize = 16;
pub const RECEIVE_SEC: usize = 24;
pub const RECEIVE_USEC: usize = 32;
pub const LEAP: usize = 36;
pub const PRECISION: usize = 40;
pub const VALID: usize = 48;
pub const CLOCK_NSEC: usize = 52;
pub const RECEIVE_NSEC: usize = 56;
pub const SIZE: usize = 96;
}
pub struct ShmRefclock {
base: *mut u8,
unit: i32,
}
unsafe impl Send for ShmRefclock {}
impl ShmRefclock {
pub fn attach(unit: i32) -> Result<ShmRefclock, ClockError> {
let key = SHM_KEY_BASE + unit;
let id = unsafe { libc::shmget(key, layout::SIZE, 0) };
if id < 0 {
return Err(ClockError {
op: "shmget",
detail: format!(
"no SHM segment for unit {unit} (key {key:#x}): {}",
std::io::Error::last_os_error()
),
});
}
let base = unsafe { libc::shmat(id, core::ptr::null(), libc::SHM_RDONLY) };
if base as isize == -1 {
return Err(ClockError {
op: "shmat",
detail: std::io::Error::last_os_error().to_string(),
});
}
Ok(ShmRefclock {
base: base.cast::<u8>(),
unit,
})
}
pub fn unit(&self) -> i32 {
self.unit
}
fn read_i32(&self, offset: usize) -> i32 {
unsafe { core::ptr::read_volatile(self.base.add(offset).cast::<i32>()) }
}
fn read_i64(&self, offset: usize) -> i64 {
unsafe { core::ptr::read_volatile(self.base.add(offset).cast::<i64>()) }
}
pub fn sample(&self) -> Option<RefclockSample> {
for _ in 0..4 {
if self.read_i32(layout::VALID) == 0 {
return None;
}
let mode = self.read_i32(layout::MODE);
let count_before = self.read_i32(layout::COUNT);
let clock_sec = self.read_i64(layout::CLOCK_SEC);
let clock_usec = self.read_i32(layout::CLOCK_USEC);
let clock_nsec = self.read_i32(layout::CLOCK_NSEC);
let receive_sec = self.read_i64(layout::RECEIVE_SEC);
let receive_usec = self.read_i32(layout::RECEIVE_USEC);
let receive_nsec = self.read_i32(layout::RECEIVE_NSEC);
let leap = self.read_i32(layout::LEAP);
let precision = self.read_i32(layout::PRECISION);
if mode == 1 {
let count_after = self.read_i32(layout::COUNT);
if count_before != count_after {
continue; }
}
let sub_ns = |nsec: i32, usec: i32| -> i64 {
if nsec != 0 {
nsec as i64
} else {
usec as i64 * 1_000
}
};
let clock_ns = sub_ns(clock_nsec, clock_usec);
let receive_ns = sub_ns(receive_nsec, receive_usec);
let offset_s =
(clock_sec - receive_sec) as f64 + (clock_ns - receive_ns) as f64 * 1e-9;
return Some(RefclockSample {
local_s: receive_sec as f64 + receive_ns as f64 * 1e-9,
offset_s,
precision_log2: precision.clamp(-32, 0) as i8,
leap: LeapWarning::from_wire(leap),
});
}
None
}
}
impl Drop for ShmRefclock {
fn drop(&mut self) {
unsafe {
libc::shmdt(self.base.cast::<libc::c_void>());
}
}
}
}
#[cfg(unix)]
pub mod sock {
use super::*;
use std::os::unix::net::UnixDatagram;
pub const SOCK_MAGIC: i32 = 0x534F_434B;
pub const SAMPLE_SIZE: usize = 40;
pub struct SockRefclock {
socket: UnixDatagram,
}
impl SockRefclock {
pub fn bind(path: &str) -> Result<SockRefclock, ClockError> {
let _ = std::fs::remove_file(path);
let socket = UnixDatagram::bind(path).map_err(|e| ClockError {
op: "bind SOCK refclock",
detail: format!("{path}: {e}"),
})?;
socket.set_nonblocking(true).map_err(|e| ClockError {
op: "set_nonblocking",
detail: e.to_string(),
})?;
Ok(SockRefclock { socket })
}
pub fn try_sample(&self) -> Option<RefclockSample> {
let mut buf = [0u8; SAMPLE_SIZE];
let received = self.socket.recv(&mut buf).ok()?;
if received != SAMPLE_SIZE {
return None;
}
decode_sample(&buf)
}
}
pub fn decode_sample(buf: &[u8]) -> Option<RefclockSample> {
if buf.len() < SAMPLE_SIZE {
return None;
}
let i32_at = |o: usize| {
let mut b = [0u8; 4];
b.copy_from_slice(&buf[o..o + 4]);
i32::from_ne_bytes(b)
};
let i64_at = |o: usize| {
let mut b = [0u8; 8];
b.copy_from_slice(&buf[o..o + 8]);
i64::from_ne_bytes(b)
};
let f64_at = |o: usize| {
let mut b = [0u8; 8];
b.copy_from_slice(&buf[o..o + 8]);
f64::from_ne_bytes(b)
};
if i32_at(36) != SOCK_MAGIC {
return None; }
let sec = i64_at(0);
let usec = i64_at(8);
let offset = f64_at(16);
let leap = i32_at(28);
Some(RefclockSample {
local_s: sec as f64 + usec as f64 * 1e-6,
offset_s: offset,
precision_log2: -20,
leap: LeapWarning::from_wire(leap),
})
}
}
#[cfg(target_os = "linux")]
pub mod phc {
use super::*;
use std::os::fd::{AsRawFd, OwnedFd};
pub struct Phc {
fd: OwnedFd,
index: u32,
}
fn fd_to_clockid(fd: i32) -> libc::clockid_t {
((!fd) << 3) | 3
}
impl Phc {
pub fn open(index: u32) -> Result<Phc, ClockError> {
let path = format!("/dev/ptp{index}");
let file = std::fs::File::open(&path).map_err(|e| ClockError {
op: "open PHC",
detail: format!("{path}: {e}"),
})?;
Ok(Phc {
fd: OwnedFd::from(file),
index,
})
}
pub fn index(&self) -> u32 {
self.index
}
pub fn read_s(&self) -> Result<f64, ClockError> {
let mut ts = libc::timespec {
tv_sec: 0,
tv_nsec: 0,
};
let rc = unsafe { libc::clock_gettime(fd_to_clockid(self.fd.as_raw_fd()), &mut ts) };
if rc != 0 {
return Err(ClockError {
op: "clock_gettime(PHC)",
detail: std::io::Error::last_os_error().to_string(),
});
}
Ok(ts.tv_sec as f64 + ts.tv_nsec as f64 * 1e-9)
}
pub fn sample(&self) -> Result<RefclockSample, ClockError> {
let clock = crate::SystemClock;
let before = clock.wall_ns()? as f64 * 1e-9;
let phc = self.read_s()?;
let after = clock.wall_ns()? as f64 * 1e-9;
let midpoint = (before + after) / 2.0;
Ok(RefclockSample {
local_s: midpoint,
offset_s: phc - midpoint,
precision_log2: ((after - before).max(1e-9).log2().ceil() as i32).clamp(-32, 0)
as i8,
leap: LeapWarning::None,
})
}
}
use crate::ClockRead;
}
#[cfg(test)]
#[path = "refclock_tests.rs"]
mod refclock_tests;